From 7d5b0e4b8b1d2092bd98e7786964deb22a0c69e0 Mon Sep 17 00:00:00 2001
From: Ryan Atkinson <mail@ryanatkn.com>
Date: Sun, 14 Jun 2026 20:37:39 -0400
Subject: [PATCH] fix: parse svelte braces in regex/comments and unquoted
 attribute sequences

---
 crates/tsv_svelte/CLAUDE.md                   |   2 +-
 crates/tsv_svelte/src/parser/attribute.rs     | 296 ++++------
 crates/tsv_svelte/src/parser/block.rs         |  64 +-
 crates/tsv_svelte/src/parser/element.rs       |  19 +-
 .../tsv_svelte/src/parser/expression_tag.rs   | 281 ++++-----
 crates/tsv_svelte/src/parser/script.rs        |  18 +-
 crates/tsv_svelte/src/parser/style.rs         |  17 +-
 docs/conformance_prettier.md                  | 109 ++--
 .../expected.json                             | 547 ++++++++++++++++++
 .../input.svelte                              |  11 +
 .../unformatted_unquoted.svelte               |  11 +
 .../expected.json                             | 309 ++++++++++
 .../input.svelte                              |   4 +
 .../unquoted_sequence/expected.json           | 447 ++++++++++++++
 .../attributes/unquoted_sequence/input.svelte |  14 +
 .../unformatted_unquoted.svelte               |  14 +
 .../if_brace_in_regex_comment/expected.json   | 202 +++++++
 .../if/if_brace_in_regex_comment/input.svelte |   3 +
 .../expected.json                             | 309 ++++++++++
 .../input.svelte                              |   4 +
 .../html_brace_in_regex_comment/expected.json | 174 ++++++
 .../html_brace_in_regex_comment/input.svelte  |   3 +
 22 files changed, 2388 insertions(+), 470 deletions(-)
 create mode 100644 tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/expected.json
 create mode 100644 tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/input.svelte
 create mode 100644 tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/unformatted_unquoted.svelte
 create mode 100644 tests/fixtures/svelte/attributes/spread_brace_in_regex_comment/expected.json
 create mode 100644 tests/fixtures/svelte/attributes/spread_brace_in_regex_comment/input.svelte
 create mode 100644 tests/fixtures/svelte/attributes/unquoted_sequence/expected.json
 create mode 100644 tests/fixtures/svelte/attributes/unquoted_sequence/input.svelte
 create mode 100644 tests/fixtures/svelte/attributes/unquoted_sequence/unformatted_unquoted.svelte
 create mode 100644 tests/fixtures/svelte/blocks/if/if_brace_in_regex_comment/expected.json
 create mode 100644 tests/fixtures/svelte/blocks/if/if_brace_in_regex_comment/input.svelte
 create mode 100644 tests/fixtures/svelte/tags/attach/attach_brace_in_regex_comment/expected.json
 create mode 100644 tests/fixtures/svelte/tags/attach/attach_brace_in_regex_comment/input.svelte
 create mode 100644 tests/fixtures/svelte/tags/html/html_brace_in_regex_comment/expected.json
 create mode 100644 tests/fixtures/svelte/tags/html/html_brace_in_regex_comment/input.svelte

diff --git a/crates/tsv_svelte/CLAUDE.md b/crates/tsv_svelte/CLAUDE.md
index aebe6c0e..5abc76eb 100644
--- a/crates/tsv_svelte/CLAUDE.md
+++ b/crates/tsv_svelte/CLAUDE.md
@@ -31,7 +31,7 @@ What separates this crate from `tsv_ts` / `tsv_css`:
 - **Embeds two other languages.** The printer delegates `<script>` / `<style>` and every template `{expr}` to `tsv_ts::build_program_doc` / `tsv_css::build_stylesheet_doc`, passing an `EmbedContext` with the current indent state and `LayoutMode::Embedded` so binary expressions use continuation indent. See `printer/script_style.rs` and `printer/tags.rs`.
 - **Element classification adapter.** `printer/classification/element.rs` resolves interned tag-name symbols and dispatches to the pure `tsv_html` functions. The Svelte-specific overlay (Components are inline; non-empty `<script>`/`<style>` are block) lives here, not in `tsv_html`.
 - **No `escapes/` module.** String/template-literal escapes are handled inside the embedded TS/CSS — Svelte itself has no escape rules at the template level.
-- **Lazy entity decoding on `Text`.** The internal `Text` node stores `raw` plus a parse-time `TextDecoding` context (`Fragment` / `AttributeValue` / `Raw`); the decoded form comes from `Text::data() -> Cow<str>`, which borrows `raw` when no `&` is present (decode is identity) or in `Raw` context. Contexts mirror the canonical parser: fragment text decodes with text-content rules, quoted attribute values with attribute rules, raw-content element text and unquoted attribute values not at all (the unquoted case diverges from Svelte — see the TODO in `parser/attribute.rs`). The printer reads `raw`; `data()` serves boundary and cold paths (public-AST conversion, `lang`/`context` attribute checks, root-span whitespace trimming).
+- **Lazy entity decoding on `Text`.** The internal `Text` node stores `raw` plus a parse-time `TextDecoding` context (`Fragment` / `AttributeValue` / `Raw`); the decoded form comes from `Text::data() -> Cow<str>`, which borrows `raw` when no `&` is present (decode is identity) or in `Raw` context. Contexts mirror the canonical parser: fragment text decodes with text-content rules, quoted and unquoted attribute values with attribute rules, raw-content element text not at all. The printer reads `raw`; `data()` serves boundary and cold paths (public-AST conversion, `lang`/`context` attribute checks, root-span whitespace trimming).
 - **Dual schema for `<script>` conversion.** `ast/convert/special.rs` picks `tsv_ts::ast::convert::Schema::Acorn` for `lang="ts"` and `Schema::SvelteScript` otherwise. The latter omits `importKind` / `exportKind = "value"` and always emits `attributes` on import/export declarations to match Svelte's parser output.
 
 ## See Also
diff --git a/crates/tsv_svelte/src/parser/attribute.rs b/crates/tsv_svelte/src/parser/attribute.rs
index b0b71af4..68dd40bf 100644
--- a/crates/tsv_svelte/src/parser/attribute.rs
+++ b/crates/tsv_svelte/src/parser/attribute.rs
@@ -5,8 +5,23 @@ use crate::lexer::TokenKind;
 use tsv_lang::{ParseError, Span};
 use tsv_ts::ast::internal::{Expression, Identifier};
 
+use super::expression_tag::scan_to_matching_brace;
 use super::parser_impl::SvelteParser;
 
+/// Does a `{` at byte `pos` begin an expression tag, vs a block/tag construct?
+///
+/// `{#`, `{:`, `{@` (block/tag opens) and `{/word}` (block close) are not
+/// expression tags; `{/*` and `{//` are comments, which are. Mirrors the lexer's
+/// brace dispatch — shared by the quoted and unquoted attribute-value readers so
+/// the two can't drift apart.
+fn brace_starts_expression(bytes: &[u8], pos: usize) -> bool {
+    match bytes.get(pos + 1) {
+        Some(b'#' | b':' | b'@') => false,
+        Some(b'/') => matches!(bytes.get(pos + 2), Some(b'*' | b'/')),
+        _ => true,
+    }
+}
+
 /// Directive prefix types
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum DirectiveType {
@@ -383,7 +398,7 @@ impl<'a> SvelteParser<'a> {
                 }
             } else if self.check(TokenKind::Identifier) {
                 // Unquoted value: style:background=green
-                let parts = self.parse_unquoted_attribute_value()?;
+                let parts = self.parse_unquoted_attribute_value(true)?;
                 StyleDirectiveValue::Parts(parts)
             } else {
                 return Err(
@@ -440,30 +455,14 @@ impl<'a> SvelteParser<'a> {
         // The content is: {@attach expr}
         let brace_start = self.current_start;
 
-        // Find the closing brace by scanning forward (handles nested braces)
         let content_start = brace_start + 2; // Skip "{@"
-        let mut depth = 1;
-        let mut pos = content_start;
-        let source_bytes = self.source.as_bytes();
-
-        while pos < self.source.len() && depth > 0 {
-            match source_bytes[pos] {
-                b'{' => depth += 1,
-                b'}' => depth -= 1,
-                _ => {}
-            }
-            if depth > 0 {
-                pos += 1;
-            }
-        }
 
-        if depth != 0 {
+        // Find the matching closing `}` (skips strings/comments/regex).
+        let Some(content_end) = scan_to_matching_brace(self.source.as_bytes(), content_start)
+        else {
             return Err(self.error_unclosed_at("{@attach} tag", start));
-        }
-
-        // pos is now at the closing '}'
-        let content_end = pos;
-        let end = pos + 1; // Include the closing '}'
+        };
+        let end = content_end + 1; // Include the closing '}'
 
         // Extract content: "attach expr"
         let content = &self.source[content_start..content_end];
@@ -511,30 +510,14 @@ impl<'a> SvelteParser<'a> {
         // We're at '{', scan forward to find the closing '}'
         let brace_start = self.current_start;
 
-        // Find the closing brace by scanning forward (handles nested braces)
         let content_start = brace_start + 1; // Skip "{"
-        let mut depth = 1;
-        let mut pos = content_start;
-        let source_bytes = self.source.as_bytes();
 
-        while pos < self.source.len() && depth > 0 {
-            match source_bytes[pos] {
-                b'{' => depth += 1,
-                b'}' => depth -= 1,
-                _ => {}
-            }
-            if depth > 0 {
-                pos += 1;
-            }
-        }
-
-        if depth != 0 {
+        // Find the matching closing `}` (skips strings/comments/regex).
+        let Some(content_end) = scan_to_matching_brace(self.source.as_bytes(), content_start)
+        else {
             return Err(self.error_unclosed_at("spread attribute", start));
-        }
-
-        // pos is now at the closing '}'
-        let content_end = pos;
-        let end = pos + 1; // Include the closing '}'
+        };
+        let end = content_end + 1; // Include the closing '}'
 
         // Extract content: "...expr" or " ...expr " (with whitespace)
         let content = &self.source[content_start..content_end];
@@ -737,27 +720,17 @@ impl<'a> SvelteParser<'a> {
         &mut self,
         parse_expressions: bool,
     ) -> Result<Vec<AttributeValue>, ParseError> {
-        let mut parts = Vec::new();
-
-        // Check for expression attribute {expr}
-        if self.check(TokenKind::LeftBrace) {
-            let expr_tag = self.parse_expression_tag()?;
-            parts.push(AttributeValue::ExpressionTag(expr_tag));
-            return Ok(parts);
-        }
-
-        // Check for unquoted attribute value
-        // HTML allows unquoted attribute values: any chars except whitespace, ", ', =, <, >, `
-        // This handles simple identifiers (data-attr=value) and URLs (href=https://example.com)
-        if self.check(TokenKind::Identifier) {
-            return self.parse_unquoted_attribute_value();
-        }
-
-        // Otherwise expect string value
+        // Any value not starting with a quote is unquoted, read as a Svelte
+        // `read_sequence` — a run of Text + {expr} chunks to the terminator regex.
+        // Covers a bare identifier (`data-attr=value`), a single expression
+        // (`prop={a}`), concatenations (`prop={a}{b}`, `src={a}//cdn`), and
+        // slash-led paths (`href=/path`).
         if !self.check(TokenKind::String) {
-            return Err(self.error_expected_found("string or expression value"));
+            return self.parse_unquoted_attribute_value(parse_expressions);
         }
 
+        let mut parts = Vec::new();
+
         // Extract string content (without quotes)
         let (token_start, token_end) = self.current_pos();
 
@@ -782,23 +755,23 @@ impl<'a> SvelteParser<'a> {
             return Ok(parts);
         }
 
-        // Scan for expression tags within the quoted value
-        // Example: "delete {'\"'}" contains text "delete " and expression {'\"'}
+        // Scan the quoted value as a sequence of Text and {expr} chunks. Each
+        // `{expr}` is parsed by the shared `parse_expression_tag_at`, which skips
+        // nested braces, strings, comments, and regex literals — so a `}` inside one
+        // (`"{/* } */ x}"`, `"{f(/[}]/)}"`) doesn't desync brace matching.
+        // Example: "delete {'\"'}" contains text "delete " and expression {'\"'}.
         let mut pos = content_start;
         let source_bytes = self.source.as_bytes();
 
         while pos < content_end {
-            // Scan for the start of an expression tag
+            // Accumulate text up to the next `{`.
             let text_start = pos;
             while pos < content_end && source_bytes[pos] != b'{' {
                 pos += 1;
             }
-
-            // If we found text before the expression tag (or we're at the end), create a text part
             if pos > text_start {
-                let text_content = self.source[text_start..pos].to_string();
                 parts.push(AttributeValue::Text(Text {
-                    raw: text_content,
+                    raw: self.source[text_start..pos].to_string(),
                     decoding: TextDecoding::AttributeValue,
                     span: Span {
                         start: text_start as u32,
@@ -807,95 +780,13 @@ impl<'a> SvelteParser<'a> {
                 }));
             }
 
-            // If we're at an expression tag, parse it
             if pos < content_end && source_bytes[pos] == b'{' {
-                // Check if this is really an expression tag (not a block tag)
-                // Expression tags start with { followed by anything except # / : @
-                let next_char = source_bytes.get(pos + 1);
-                let is_expression_tag =
-                    !matches!(next_char, Some(b'#') | Some(b'/') | Some(b':') | Some(b'@'));
-
-                if is_expression_tag {
-                    // Manually extract the expression content by scanning for the matching }
-                    // NOTE: Similar brace/string tracking logic exists in the lexer (lexer.rs).
-                    // The lexer tokenizes the whole string; we extract expression boundaries here.
-                    let expr_start = pos + 1; // Skip the opening {
-                    let mut brace_depth = 1;
-                    let mut expr_end = expr_start;
-                    let mut in_string = false;
-                    let mut string_char = '\0';
-                    let mut escape_next = false;
-
-                    let mut i = expr_start;
-                    while i < content_end && brace_depth > 0 {
-                        let ch = source_bytes[i] as char;
-
-                        if in_string && escape_next {
-                            escape_next = false;
-                            i += 1;
-                            continue;
-                        }
-
-                        if in_string && ch == '\\' {
-                            escape_next = true;
-                            i += 1;
-                            continue;
-                        }
-
-                        if in_string {
-                            if ch == string_char {
-                                in_string = false;
-                            }
-                        } else if ch == '"' || ch == '\'' || ch == '`' {
-                            in_string = true;
-                            string_char = ch;
-                        } else if ch == '{' {
-                            brace_depth += 1;
-                        } else if ch == '}' {
-                            brace_depth -= 1;
-                            if brace_depth == 0 {
-                                expr_end = i;
-                                break;
-                            }
-                        }
-
-                        i += 1;
-                    }
-
-                    if brace_depth != 0 {
-                        return Err(ParseError::InvalidSyntax {
-                            message: "Unclosed expression tag in attribute value".to_string(),
-                            position: pos,
-                            context: None,
-                        });
-                    }
-
-                    // Parse the expression content
-                    let expr_content = &self.source[expr_start..expr_end];
-                    let (expression, comments) = tsv_ts::parse_expression_with_comments(
-                        expr_content,
-                        expr_start,
-                        std::rc::Rc::clone(&self.interner),
-                    )?;
-
-                    // Add expression comments to the parser's collection
-                    self.expression_comments.extend(comments);
-
-                    // Create the expression tag
-                    let tag_end = expr_end + 1; // Include the closing }
-                    parts.push(AttributeValue::ExpressionTag(ExpressionTag {
-                        expression,
-                        span: Span {
-                            start: pos as u32,
-                            end: tag_end as u32,
-                        },
-                    }));
-
-                    // Move past the expression tag
-                    pos = tag_end;
+                if brace_starts_expression(source_bytes, pos) {
+                    let tag = self.parse_expression_tag_at(pos)?;
+                    pos = tag.span.end as usize;
+                    parts.push(AttributeValue::ExpressionTag(tag));
                 } else {
-                    // Not an expression tag, treat { as literal text
-                    pos += 1;
+                    pos += 1; // literal `{`
                 }
             }
         }
@@ -915,48 +806,89 @@ impl<'a> SvelteParser<'a> {
         Ok(parts)
     }
 
-    /// Parse an unquoted attribute value by scanning raw bytes.
+    /// Parse an unquoted attribute value as a Svelte `read_sequence`.
+    ///
+    /// An unquoted value is a run of `Text` and `{expr}` chunks terminated by
+    /// `regex_invalid_unquoted_attribute_value` — `/>` or one of whitespace, `"`,
+    /// `'`, `=`, `<`, `>`, `` ` ``. So `prop={a}{b}` is one value `[{a}, {b}]`,
+    /// `src={a}//cdn` is `[{a}, "//cdn"]`, and `href=/path` is `["/path"]`. A bare
+    /// `/` (only `/>`) does not terminate, so protocol-relative and root-relative
+    /// URLs read as plain text.
+    ///
+    /// We scan raw bytes because the lexer's identifier token doesn't span `/`,
+    /// `:`, and the like. `Text` chunks decode with attribute-context rules to
+    /// match Svelte (`decode_character_references(raw, true)`).
     ///
-    /// HTML spec: unquoted values are any chars except whitespace, `"`, `'`, `=`, `<`, `>`, `` ` ``.
-    /// The lexer's identifier token only covers alphanumeric and a few special chars (`:`, `.`, `-`),
-    /// so URLs like `https://example.com/path` would be split across tokens. Instead, we start from
-    /// the current token position and scan raw bytes for the full unquoted value.
+    /// `parse_expressions` is `false` for `<script>` / `<style>` tag attributes,
+    /// where `{` is literal text and the whole value is a single `Text` chunk.
     pub(crate) fn parse_unquoted_attribute_value(
         &mut self,
+        parse_expressions: bool,
     ) -> Result<Vec<AttributeValue>, ParseError> {
+        // `src`/`bytes` borrow the source data (lifetime `'a`), so they stay valid
+        // across the `&mut self` `parse_expression_tag_at` call below.
+        let src = self.source;
+        let bytes = src.as_bytes();
         let start = self.current_start;
-        let source_bytes = self.source.as_bytes();
+        let mut parts: Vec<AttributeValue> = Vec::new();
+        let mut text_start = start;
         let mut pos = start;
 
-        while pos < source_bytes.len() {
-            match source_bytes[pos] {
-                b' ' | b'\t' | b'\n' | b'\r' | b'\x0C' // whitespace
-                | b'"' | b'\'' | b'=' | b'<' | b'>' | b'`' => break,
-                _ => pos += 1,
+        let flush_text = |parts: &mut Vec<AttributeValue>, from: usize, to: usize| {
+            if to > from {
+                parts.push(AttributeValue::Text(Text {
+                    raw: src[from..to].to_string(),
+                    decoding: TextDecoding::AttributeValue,
+                    span: Span {
+                        start: from as u32,
+                        end: to as u32,
+                    },
+                }));
+            }
+        };
+
+        loop {
+            // Terminator regex: `/>` or one of whitespace " ' = < > `
+            let terminated = match bytes.get(pos).copied() {
+                None => true,
+                Some(b'/') => bytes.get(pos + 1) == Some(&b'>'),
+                Some(
+                    b' ' | b'\t' | b'\n' | b'\r' | b'\x0C' | b'"' | b'\'' | b'=' | b'<' | b'>'
+                    | b'`',
+                ) => true,
+                Some(_) => false,
+            };
+            if terminated {
+                flush_text(&mut parts, text_start, pos);
+                break;
+            }
+
+            // An `{expr}` chunk starts a new part. Every `{` is literal text when
+            // expressions are disabled (script/style tag attributes).
+            if parse_expressions && bytes[pos] == b'{' && brace_starts_expression(bytes, pos) {
+                flush_text(&mut parts, text_start, pos);
+                // Parse the `{expr}` without disturbing the lexer (it handles nested
+                // braces, strings, comments, and regex that a raw byte scan cannot);
+                // we own the cursor and sync the lexer once below.
+                let tag = self.parse_expression_tag_at(pos)?;
+                pos = tag.span.end as usize;
+                text_start = pos;
+                parts.push(AttributeValue::ExpressionTag(tag));
+                continue;
             }
+
+            pos += 1;
         }
 
         if pos == start {
             return Err(self.error_msg("Expected attribute value"));
         }
 
-        // TODO: Svelte decodes unquoted attribute values with attribute-context
-        // rules (element.js read_attribute_value decodes the unquoted match too);
-        // tsv has never decoded here, so `data` keeps entities (e.g. `a&amp;b`).
-        // Latent public-AST divergence, unpinned by any fixture — fix fixture-first.
-        let text_content = self.source[start..pos].to_string();
-        let text = Text {
-            raw: text_content,
-            decoding: TextDecoding::Raw,
-            span: Span {
-                start: start as u32,
-                end: pos as u32,
-            },
-        };
-
-        // Advance the lexer past the raw-scanned value
+        // Sync the lexer to the value terminator for the element parser. The loop
+        // never touched the lexer, so `inside_tag` is still set (we're inside the
+        // tag) and `advance_to_position` re-lexes the terminator in tag mode.
         self.advance_to_position(pos)?;
 
-        Ok(vec![AttributeValue::Text(text)])
+        Ok(parts)
     }
 }
diff --git a/crates/tsv_svelte/src/parser/block.rs b/crates/tsv_svelte/src/parser/block.rs
index 0311cacf..8d8b79fb 100644
--- a/crates/tsv_svelte/src/parser/block.rs
+++ b/crates/tsv_svelte/src/parser/block.rs
@@ -9,6 +9,7 @@ use crate::lexer::TokenKind;
 use crate::parser::element::ParsedElement;
 use tsv_lang::{ParseError, Span};
 
+use super::expression_tag::scan_to_matching_brace;
 use super::parser_impl::SvelteParser;
 
 /// Find the position of the LAST top-level ` as ` keyword in a string.
@@ -1312,63 +1313,20 @@ impl<'a> SvelteParser<'a> {
     /// Scan source from a position until we find the closing } of a block tag
     /// Returns (content between start and }, position after })
     fn scan_block_tag_content(&mut self, start: usize) -> Result<(&'a str, usize), ParseError> {
-        let source_bytes = self.source.as_bytes();
-        let mut end = start;
-        let mut brace_depth = 0;
-        let mut in_string = false;
-        let mut string_char = '\0';
-        let mut escape_next = false;
-
-        for (i, &byte) in source_bytes.iter().enumerate().skip(start) {
-            let ch = byte as char;
-
-            if in_string && escape_next {
-                escape_next = false;
-                continue;
-            }
-
-            if in_string && ch == '\\' {
-                escape_next = true;
-                continue;
-            }
-
-            if in_string {
-                if ch == string_char {
-                    in_string = false;
-                }
-            } else if ch == '"' || ch == '\'' || ch == '`' {
-                in_string = true;
-                string_char = ch;
-            } else if ch == '{' {
-                brace_depth += 1;
-            } else if ch == '}' {
-                if brace_depth == 0 {
-                    end = i;
-                    break;
-                }
-                brace_depth -= 1;
-            }
-        }
+        // Find the block tag's closing `}` (skips strings/comments/regex). `start`
+        // is just after the `{#…`/`{@…` keyword, so the opening `{` is the depth-1
+        // brace that `scan_to_matching_brace` matches.
+        let Some(end) = scan_to_matching_brace(self.source.as_bytes(), start) else {
+            return Err(self.error_unclosed_at("block tag", start));
+        };
 
         let content = &self.source[start..end];
 
-        // Recreate lexer at the position after }
+        // Reposition the lexer past `}`. Block tags only occur in template content,
+        // so `inside_tag` is already `false` (template mode) and stays that way for
+        // the block body, which `advance_to_position` preserves.
         let after_close = end + 1; // Skip past the }
-        let remaining_source = &self.source[after_close..];
-        let mut new_lexer = crate::lexer::Lexer::new(remaining_source);
-        new_lexer.inside_tag = false; // Back to template mode
-
-        let (token_kind, token_start, token_end) = {
-            let token = new_lexer.next_token()?;
-            (token.kind, token.start, token.end)
-        };
-
-        self.lexer = new_lexer;
-        self.base_offset = after_close;
-        self.current_kind = token_kind;
-        self.current_start = after_close + token_start;
-        self.current_end = after_close + token_end;
-        self.peek_cache = None;
+        self.advance_to_position(after_close)?;
 
         Ok((content, after_close))
     }
diff --git a/crates/tsv_svelte/src/parser/element.rs b/crates/tsv_svelte/src/parser/element.rs
index 93b5b0ed..a4d30cbd 100644
--- a/crates/tsv_svelte/src/parser/element.rs
+++ b/crates/tsv_svelte/src/parser/element.rs
@@ -438,21 +438,10 @@ impl<'a> SvelteParser<'a> {
             );
         }
 
-        // Reposition lexer to the closing tag
-        let remaining_source = &self.source[content_end..];
-        let mut new_lexer = crate::lexer::Lexer::new(remaining_source);
-
-        let (token_kind, token_start, token_end) = {
-            let token = new_lexer.next_token()?;
-            (token.kind, token.start, token.end)
-        };
-
-        self.lexer = new_lexer;
-        self.base_offset = content_end;
-        self.current_kind = token_kind;
-        self.current_start = content_end + token_start;
-        self.current_end = content_end + token_end;
-        self.peek_cache = None;
+        // Reposition the lexer to the closing tag. We resume at `<`, which lexes to
+        // `LeftAngle` in either mode; `inside_tag` is `false` here (after the opening
+        // tag's `>`), which `advance_to_position` preserves.
+        self.advance_to_position(content_end)?;
 
         // Create a Text node (Svelte always emits one, even if empty)
         let raw_content = &self.source[content_start..content_end];
diff --git a/crates/tsv_svelte/src/parser/expression_tag.rs b/crates/tsv_svelte/src/parser/expression_tag.rs
index 38bb27e5..25cc3c19 100644
--- a/crates/tsv_svelte/src/parser/expression_tag.rs
+++ b/crates/tsv_svelte/src/parser/expression_tag.rs
@@ -9,123 +9,55 @@ use tsv_lang::{ParseError, Span};
 use super::parser_impl::SvelteParser;
 
 impl<'a> SvelteParser<'a> {
-    /// Parse an expression tag: {expression}
+    /// Parse an expression tag `{expression}` at the current lexer position, then
+    /// advance the lexer past the closing `}`.
+    ///
+    /// Used by callers that drive the token stream (template `{expr}` tags,
+    /// directive values). Position-based callers that own their own cursor — the
+    /// attribute-value sequence readers — use `parse_expression_tag_at`, which runs
+    /// the same scan + parse without touching the lexer.
     pub(crate) fn parse_expression_tag(&mut self) -> Result<ExpressionTag, ParseError> {
-        let start = self.current_start;
-
         // Verify we're at opening brace
         if !self.check(TokenKind::LeftBrace) {
             return Err(self.error_expected_found("'{'"));
         }
 
-        // Calculate expression start (after the '{')
-        let expr_start = self.current_end;
-
-        // Find matching closing brace with proper handling of nested braces, strings, and comments
-        let source_bytes = self.source.as_bytes();
-        let mut expr_end = expr_start;
-        let mut found_close = false;
-        let mut brace_depth = 1; // Already saw opening {
-        let mut in_string = false;
-        let mut string_char = '\0';
-        let mut in_block_comment = false;
-        let mut in_line_comment = false;
-        let mut escape_next = false;
-
-        // Scan raw source for matching closing brace
-        let mut i = expr_start;
-        while i < source_bytes.len() {
-            let ch = source_bytes[i] as char;
-
-            // Handle escape sequences in strings
-            if in_string && escape_next {
-                escape_next = false;
-                i += 1;
-                continue;
-            }
-
-            if in_string && ch == '\\' {
-                escape_next = true;
-                i += 1;
-                continue;
-            }
-
-            // Handle line comment end (newline ends line comment)
-            if in_line_comment {
-                if ch == '\n' {
-                    in_line_comment = false;
-                }
-                i += 1;
-                continue;
-            }
-
-            // Handle strings (skip braces when inside)
-            if !in_block_comment {
-                if in_string {
-                    if ch == string_char {
-                        in_string = false;
-                    }
-                    i += 1;
-                    continue;
-                } else if ch == '"' || ch == '\'' || ch == '`' {
-                    in_string = true;
-                    string_char = ch;
-                    i += 1;
-                    continue;
-                }
-            }
+        let tag = self.parse_expression_tag_at(self.current_start)?;
 
-            // Handle comments and regex (skip braces when inside)
-            if !in_string {
-                if in_block_comment {
-                    // Block comment: /* ... */
-                    if ch == '*' && i + 1 < source_bytes.len() && source_bytes[i + 1] as char == '/'
-                    {
-                        in_block_comment = false;
-                        i += 2; // Skip */
-                        continue;
-                    }
-                    i += 1;
-                    continue;
-                } else if ch == '/' && i + 1 < source_bytes.len() {
-                    let next_char = source_bytes[i + 1] as char;
-                    if next_char == '*' {
-                        in_block_comment = true;
-                        i += 2; // Skip /*
-                        continue;
-                    } else if next_char == '/' {
-                        in_line_comment = true;
-                        i += 2; // Skip //
-                        continue;
-                    } else if is_regex_start(source_bytes, i, expr_start) {
-                        // Regex literal: /pattern/flags - skip to end
-                        i = skip_regex_literal(source_bytes, i);
-                        continue;
-                    }
-                    // Otherwise, treat / as division operator - continue normal processing
-                }
-            }
+        // Resume lexing AFTER the closing brace (not at it), preserving tag-vs-template
+        // context. Repositioning past `}` means the lexer never tokenizes it, so a `}`
+        // in template text stays plain text — matching Svelte, which consumes `}`
+        // directly after expression parsing (e.g. `class={expr}>` stays in tag mode,
+        // `{expr}</div>` returns to template mode).
+        self.advance_to_position(tag.span.end as usize)?;
 
-            // Count braces (only outside strings, comments, and regex)
-            if !in_string && !in_block_comment {
-                if ch == '{' {
-                    brace_depth += 1;
-                } else if ch == '}' {
-                    brace_depth -= 1;
-                    if brace_depth == 0 {
-                        expr_end = i;
-                        found_close = true;
-                        break;
-                    }
-                }
-            }
+        Ok(tag)
+    }
 
-            i += 1;
-        }
+    /// Scan and parse an expression tag `{expression}` starting at byte `brace_pos`
+    /// (which must be `{`). The returned tag's span runs from `brace_pos` through the
+    /// byte just past the matching `}` (`tag.span.end`).
+    ///
+    /// Unlike `parse_expression_tag`, this does **not** touch the lexer — the caller
+    /// owns the cursor (the raw-byte attribute-value sequence readers reposition once
+    /// when the whole value is done). The matching `}` is found by a raw scan that
+    /// skips nested braces, string literals, line/block comments, and regex literals.
+    pub(crate) fn parse_expression_tag_at(
+        &mut self,
+        brace_pos: usize,
+    ) -> Result<ExpressionTag, ParseError> {
+        debug_assert_eq!(
+            self.source.as_bytes().get(brace_pos),
+            Some(&b'{'),
+            "parse_expression_tag_at must start at `{{`"
+        );
+        let start = brace_pos;
+        let expr_start = brace_pos + 1; // after the '{'
 
-        if !found_close {
+        // Find the matching closing `}` — the one robust brace matcher.
+        let Some(expr_end) = scan_to_matching_brace(self.source.as_bytes(), expr_start) else {
             return Err(self.error_unclosed_at("expression tag", start));
-        }
+        };
 
         // Extract expression content
         let expr_content = &self.source[expr_start..expr_end];
@@ -143,35 +75,6 @@ impl<'a> SvelteParser<'a> {
         // The span end is right after the closing brace
         let end = expr_end + 1;
 
-        // Recreate lexer AFTER the closing brace (not at it)
-        // This way we don't need the lexer to produce a RightBrace token,
-        // which allows '}' in template text to be treated as plain text.
-        // This matches Svelte's parser behavior where '}' is consumed directly
-        // after expression parsing, not tokenized.
-        let remaining_source = &self.source[end..];
-
-        // Save the lexer state before creating new lexer
-        // This preserves the context (tag vs template) after expression parsing
-        // Example: class={expr}> - we're still in tag mode after the }
-        // Example: {expr}</div> - we're in template mode after the }
-        let saved_inside_tag = self.lexer.inside_tag;
-        let mut new_lexer = crate::lexer::Lexer::new(remaining_source);
-        new_lexer.inside_tag = saved_inside_tag;
-
-        // Get the first token at the new position (after the '}')
-        let (token_kind, token_start, token_end) = {
-            let token = new_lexer.next_token()?;
-            (token.kind, token.start, token.end)
-        };
-
-        // Update parser state
-        self.lexer = new_lexer;
-        self.base_offset = end;
-        self.current_kind = token_kind;
-        self.current_start = end + token_start;
-        self.current_end = end + token_end;
-        self.peek_cache = None;
-
         Ok(ExpressionTag {
             expression,
             span: Span {
@@ -182,6 +85,114 @@ impl<'a> SvelteParser<'a> {
     }
 }
 
+/// Find the `}` that closes the construct opened by a `{` just before
+/// `scan_start`, skipping nested braces, string literals, line/block comments,
+/// and regex literals. `scan_start` is the first byte to scan (the opening `{` is
+/// counted as depth 1). Returns the byte offset of the matching `}`, or `None`
+/// if the braces never balance.
+///
+/// The single robust brace matcher shared by every `{…}` construct — expression
+/// tags, `{@…}` tags, `{...spread}`, and block tags — so none reimplements it
+/// (and weaker copies can't desync on a `}` inside a regex/comment/string).
+pub(crate) fn scan_to_matching_brace(bytes: &[u8], scan_start: usize) -> Option<usize> {
+    let mut brace_depth = 1; // the opening `{` before scan_start
+    let mut in_string = false;
+    let mut string_char = '\0';
+    let mut in_block_comment = false;
+    let mut in_line_comment = false;
+    let mut escape_next = false;
+
+    let mut i = scan_start;
+    while i < bytes.len() {
+        let ch = bytes[i] as char;
+
+        // Escape sequences inside strings
+        if in_string && escape_next {
+            escape_next = false;
+            i += 1;
+            continue;
+        }
+        if in_string && ch == '\\' {
+            escape_next = true;
+            i += 1;
+            continue;
+        }
+
+        // A newline ends a line comment
+        if in_line_comment {
+            if ch == '\n' {
+                in_line_comment = false;
+            }
+            i += 1;
+            continue;
+        }
+
+        // Strings (braces inside are ignored)
+        if !in_block_comment {
+            if in_string {
+                if ch == string_char {
+                    in_string = false;
+                }
+                i += 1;
+                continue;
+            } else if ch == '"' || ch == '\'' || ch == '`' {
+                in_string = true;
+                string_char = ch;
+                i += 1;
+                continue;
+            }
+        }
+
+        // Comments and regex (braces inside are ignored)
+        if !in_string {
+            if in_block_comment {
+                if ch == '*' && i + 1 < bytes.len() && bytes[i + 1] as char == '/' {
+                    in_block_comment = false;
+                    i += 2; // skip */
+                    continue;
+                }
+                i += 1;
+                continue;
+            } else if ch == '/' && i + 1 < bytes.len() {
+                match bytes[i + 1] as char {
+                    '*' => {
+                        in_block_comment = true;
+                        i += 2; // skip /*
+                        continue;
+                    }
+                    '/' => {
+                        in_line_comment = true;
+                        i += 2; // skip //
+                        continue;
+                    }
+                    _ if is_regex_start(bytes, i, scan_start) => {
+                        i = skip_regex_literal(bytes, i);
+                        continue;
+                    }
+                    // otherwise `/` is division — fall through
+                    _ => {}
+                }
+            }
+        }
+
+        // Count braces only outside strings/comments/regex
+        if !in_string && !in_block_comment {
+            if ch == '{' {
+                brace_depth += 1;
+            } else if ch == '}' {
+                brace_depth -= 1;
+                if brace_depth == 0 {
+                    return Some(i);
+                }
+            }
+        }
+
+        i += 1;
+    }
+
+    None
+}
+
 /// Determine if `/` at position `slash_pos` is starting a regex literal.
 ///
 /// Uses context: if the previous non-whitespace character could end an expression
diff --git a/crates/tsv_svelte/src/parser/script.rs b/crates/tsv_svelte/src/parser/script.rs
index d425bd3a..ccd565cc 100644
--- a/crates/tsv_svelte/src/parser/script.rs
+++ b/crates/tsv_svelte/src/parser/script.rs
@@ -67,22 +67,8 @@ impl<'a> SvelteParser<'a> {
         let program =
             tsv_ts::parse_with_interner(content, content_start, Rc::clone(&self.interner))?;
 
-        // Recreate lexer starting from the closing tag position
-        // (same pattern as expression tags)
-        let remaining_source = &self.source[content_end..];
-        let mut new_lexer = crate::lexer::Lexer::new(remaining_source);
-
-        let (token_kind, token_start, token_end) = {
-            let token = new_lexer.next_token()?;
-            (token.kind, token.start, token.end)
-        };
-
-        self.lexer = new_lexer;
-        self.base_offset = content_end;
-        self.current_kind = token_kind;
-        self.current_start = content_end + token_start;
-        self.current_end = content_end + token_end;
-        self.peek_cache = None;
+        // Reposition the lexer to the closing `</script>` tag (resumes at `<`).
+        self.advance_to_position(content_end)?;
 
         // Verify it's the closing tag: </script>
         if !self.check(TokenKind::LeftAngle) {
diff --git a/crates/tsv_svelte/src/parser/style.rs b/crates/tsv_svelte/src/parser/style.rs
index 21bde636..de4a0dc5 100644
--- a/crates/tsv_svelte/src/parser/style.rs
+++ b/crates/tsv_svelte/src/parser/style.rs
@@ -51,21 +51,8 @@ impl<'a> SvelteParser<'a> {
             return Err(self.error_msg_at("Unterminated style tag", start));
         }
 
-        // Recreate lexer starting from the closing tag position
-        let remaining_source = &self.source[content_end..];
-        let mut new_lexer = crate::lexer::Lexer::new(remaining_source);
-
-        let (token_kind, token_start, token_end) = {
-            let token = new_lexer.next_token()?;
-            (token.kind, token.start, token.end)
-        };
-
-        self.lexer = new_lexer;
-        self.base_offset = content_end;
-        self.current_kind = token_kind;
-        self.current_start = content_end + token_start;
-        self.current_end = content_end + token_end;
-        self.peek_cache = None;
+        // Reposition the lexer to the closing `</style>` tag (resumes at `<`).
+        self.advance_to_position(content_end)?;
 
         // Verify it's the closing tag: </style>
         if !self.check(TokenKind::LeftAngle) {
diff --git a/docs/conformance_prettier.md b/docs/conformance_prettier.md
index 43287423..d7ce4838 100644
--- a/docs/conformance_prettier.md
+++ b/docs/conformance_prettier.md
@@ -2,7 +2,7 @@
 
 The tsv formatter tracks Prettier closely, matching its output except where it **intentionally differs**. This document catalogs those divergences.
 
-## Mental Model
+## Terminology
 
 **Matched**: tsv produces identical output to Prettier — the goal and the common case (measure current rates with `deno task corpus:compare:format --all --summary`).
 
@@ -14,13 +14,18 @@ The tsv formatter tracks Prettier closely, matching its output except where it *
 | ------------------------- | ------------------------------------------------------- | ------------------------------------- |
 | **Spec violation**        | Prettier violates CSS/HTML/JS spec                      | tsv follows the spec                  |
 | **Stable quirk**          | Prettier preserves multiple forms without normalizing   | tsv normalizes consistently           |
-| **Toolchain fix**         | Prettier's output breaks Svelte's parser                | tsv produces Svelte-compatible output |
-| **Strict print width**    | Prettier allows lines to exceed printWidth              | tsv breaks to stay within limit       |
+| **Prettier bug**          | Prettier is non-idempotent or emits invalid output      | tsv produces stable, valid output     |
+| **Parser compat**         | Prettier's output breaks Svelte's parser                | tsv produces Svelte-compatible output |
+| **Print width**           | Prettier allows lines to exceed printWidth              | tsv breaks to stay within limit       |
+| **Tabs-only indent**      | Prettier mixes tabs and spaces under --use-tabs         | tsv uses whole tabs only              |
+| **BOM stripping**         | Prettier preserves byte-order marks                     | tsv strips them                       |
 | **Semantic preservation** | Prettier changes meaning (strips parens)                | tsv preserves original semantics      |
 | **Comment preservation**  | Prettier moves comments to different syntactic position | tsv preserves comment position        |
 | **Content preservation**  | Prettier silently drops user comments                   | tsv preserves all comments            |
 | **Design choice**         | Other deliberate behavior differences                   | Documented rationale in fixture       |
 
+> Most `Comment preservation` and `Content preservation` divergences live in the prose-form [TypeScript: Comments](#typescript-comments) and [CSS: Comments](#css-comments) catalogs, not the Reason-column tables — they're the largest divergence category but don't fit a one-word table cell.
+
 ## Decision Framework
 
 **When to match Prettier:**
@@ -29,13 +34,7 @@ The tsv formatter tracks Prettier closely, matching its output except where it *
 - Output that's valid and reasonable
 - Unclear which approach is "better"
 
-**When to differ from Prettier:**
-
-- Spec violations (Prettier misses required whitespace)
-- Svelte compatibility (Prettier output breaks Svelte parser)
-- Semantic preservation (Prettier strips parens that change meaning)
-- Comment position preservation (Prettier moves comments — see below)
-- Strict print width enforcement (see below)
+**When to differ:** any reason in [Reasons tsv Differs](#reasons-tsv-differs) above. The three cross-cutting principles — comment position, print width, and tabs-only indentation — are detailed below.
 
 ### Comment Position Philosophy
 
@@ -78,6 +77,24 @@ Prettier moves comments and we preserve position.
 
 The benefit: predictable output that respects the configured line length. The tradeoff: some constructs may break where Prettier would keep them inline.
 
+### Tabs-Only Indentation Philosophy
+
+**tsv renders all indentation as whole tabs and never mixes tabs with alignment spaces.**
+When breaking a union type, Prettier wraps each member's type doc in
+`align(2, …)` (`union-type.js`) to offset the 2-char `|` prefix. With
+`--use-tabs`, Prettier's indentation algorithm renders that 2-column offset as
+a **sub-tab alignment**: content that is further indented rounds the offset up
+to a whole tab, but a closing delimiter sitting at the offset column is emitted
+as `tabs + 2 spaces`. The result mixes tabs and spaces on a single indentation
+level.
+
+tsv rounds the 2-column offset up to one tab everywhere. At
+`tab_width = 2` the two are the same visual width; only the representation
+differs (`⟨n+1 tabs⟩}` vs `⟨n tabs⟩··}`). This keeps indentation
+tab-width-agnostic: a reader viewing tabs at any width sees consistent
+structure, whereas Prettier's 2-space offset assumes the prefix is exactly 2
+columns wide. Cataloged in [Tabs-Only Alignment](#tabs-only-alignment).
+
 ---
 
 ## Catalog
@@ -87,13 +104,13 @@ The benefit: predictable output that respects the configured line length. The tr
 | Feature                | Reason         | Fixture                                                                                                                |
 | ---------------------- | -------------- | ---------------------------------------------------------------------------------------------------------------------- |
 | @container spacing     | Spec violation | [container_spacing](../tests/fixtures/css/at_rules/container_spacing_prettier_divergence/)                             |
-| @container line wrap   | Design choice  | [container_long](../tests/fixtures/css/at_rules/container_long_prettier_divergence/)                                   |
-| @import line wrap      | Design choice  | [import_media_query_long](../tests/fixtures/css/at_rules/import_media_query_long_prettier_divergence/)                 |
+| @container line wrap   | Print width    | [container_long](../tests/fixtures/css/at_rules/container_long_prettier_divergence/)                                   |
+| @import line wrap      | Print width    | [import_media_query_long](../tests/fixtures/css/at_rules/import_media_query_long_prettier_divergence/)                 |
 | @media boolean spacing | Spec violation | [media_boolean_spacing](../tests/fixtures/css/at_rules/media_boolean_spacing_prettier_divergence/)                     |
-| @media line wrap       | Design choice  | [media_long](../tests/fixtures/css/at_rules/media_long_prettier_divergence/)                                           |
+| @media line wrap       | Print width    | [media_long](../tests/fixtures/css/at_rules/media_long_prettier_divergence/)                                           |
 | @scope whitespace      | Stable quirk   | [scope_complex](../tests/fixtures/css/at_rules/scope_complex_prettier_divergence/)                                     |
 | @scope newlines        | Stable quirk   | [scope_selector](../tests/fixtures/css/at_rules/scope_selector_prettier_divergence/)                                   |
-| @supports line wrap    | Design choice  | [supports_long](../tests/fixtures/css/at_rules/supports_long_prettier_divergence/)                                     |
+| @supports line wrap    | Print width    | [supports_long](../tests/fixtures/css/at_rules/supports_long_prettier_divergence/)                                     |
 | SCSS directive numbers | Design choice  | [scss_directive_number_preserved](../tests/fixtures/css/at_rules/scss_directive_number_preserved_prettier_divergence/) |
 
 **Spec violations**: CSS Syntax 3 §4.3.4 specifies that an identifier immediately followed by `(` tokenizes as a `<function-token>`, not as an `<ident-token>` plus `(`. Media Queries 4 §3 explicitly notes: "Whitespace is required between a 'not', 'and', or 'or' keyword and the following '(' character, because without it that would instead parse as a `<function-token>`." Container Queries (CSS Conditional 5) use the same grammar pattern. Prettier normalizes this for `@supports` but not `@media` or `@container`.
@@ -106,7 +123,7 @@ The benefit: predictable output that respects the configured line length. The tr
 
 | Feature                  | Reason        | Fixture                                                                                  |
 | ------------------------ | ------------- | ---------------------------------------------------------------------------------------- |
-| Column combinator `\|\|` | Toolchain fix | [column](../tests/fixtures/css/selectors/combinators/column_prettier_divergence/)        |
+| Column combinator `\|\|` | Parser compat | [column](../tests/fixtures/css/selectors/combinators/column_prettier_divergence/)        |
 | :nth-child() An+B        | Stable quirk  | [nth_child](../tests/fixtures/css/selectors/pseudo_class/nth_child_prettier_divergence/) |
 
 ### CSS: Values
@@ -114,14 +131,14 @@ The benefit: predictable output that respects the configured line length. The tr
 | Feature                    | Reason         | Fixture                                                                                                                    |
 | -------------------------- | -------------- | -------------------------------------------------------------------------------------------------------------------------- |
 | Ratio in media queries     | Stable quirk   | [ratio](../tests/fixtures/css/values/ratio/ratio_prettier_divergence/)                                                     |
-| Transform list wrap        | Design choice  | [transform_long](../tests/fixtures/css/values/functions/transform_long_prettier_divergence/)                               |
-| Space-separated value wrap | Design choice  | [space_separated_long_wrap](../tests/fixtures/css/values/lists/space_separated_long_wrap_prettier_divergence/)             |
-| Comma+space value boundary | Design choice  | [comma_space_separated_long](../tests/fixtures/css/values/lists/comma_space_separated_long_prettier_divergence/)           |
+| Transform list wrap        | Print width    | [transform_long](../tests/fixtures/css/values/functions/transform_long_prettier_divergence/)                               |
+| Space-separated value wrap | Print width    | [space_separated_long_wrap](../tests/fixtures/css/values/lists/space_separated_long_wrap_prettier_divergence/)             |
+| Comma+space value boundary | Print width    | [comma_space_separated_long](../tests/fixtures/css/values/lists/comma_space_separated_long_prettier_divergence/)           |
 | Number dot-ident           | Spec violation | [number_dot_ident](../tests/fixtures/css/values/numbers/number_dot_ident_prettier_divergence/)                             |
 | Block-valued custom prop   | Design choice  | [block_value](../tests/fixtures/css/values/variables/block_value_svelte_prettier_divergence/)                              |
 | Empty custom-prop value    | Stable quirk   | [empty_value](../tests/fixtures/css/values/variables/empty_value_prettier_divergence/)                                     |
 | Empty value + `!important` | Prettier bug   | [empty_value_important](../tests/fixtures/css/values/variables/empty_value_important_prettier_divergence/)                 |
-| var() value-less fallback  | Stable quirk   | [var_empty_fallback_degenerate](../tests/fixtures/css/values/variables/var_empty_fallback_degenerate_prettier_divergence/) |
+| var() value-less fallback  | Prettier bug   | [var_empty_fallback_degenerate](../tests/fixtures/css/values/variables/var_empty_fallback_degenerate_prettier_divergence/) |
 
 **Space-separated value wrap**: Prettier doesn't wrap CSS space-separated values (e.g., `box-shadow`) when they exceed print width. A 101-char `box-shadow: var(--a) color-mix(...)` stays on one line. tsv wraps at the print width boundary, breaking between space-separated values. This respects the configured print width rather than allowing arbitrary overflows.
 
@@ -137,7 +154,7 @@ The benefit: predictable output that respects the configured line length. The tr
 
 ### CSS: Layout
 
-**Greedy fill overflow** (design choice) — [comma_separated_greedy_fill](../tests/fixtures/css/comma_separated_greedy_fill_prettier_divergence/): Prettier's `fill()` algorithm allows lines to exceed `printWidth` by 1 char when fill segments exactly consume remaining width and the parent adds trailing punctuation. tsv treats `printWidth` as a hard limit.
+**Greedy fill overflow** (print width) — [comma_separated_greedy_fill](../tests/fixtures/css/comma_separated_greedy_fill_prettier_divergence/): Prettier's `fill()` algorithm allows lines to exceed `printWidth` by 1 char when fill segments exactly consume remaining width and the parent adds trailing punctuation. tsv treats `printWidth` as a hard limit.
 
 > **Related fill boundary divergences**: Several fixtures test variations of Prettier allowing lines to exceed `printWidth`. These share a common root cause—Prettier's `fill()` algorithm boundary conditions:
 >
@@ -147,7 +164,7 @@ The benefit: predictable output that respects the configured line length. The tr
 
 ### CSS: Comments
 
-Prettier has stable variants for comment positioning. tsv normalizes consistently.
+**Stable quirk.** Prettier has stable variants for comment positioning. tsv normalizes consistently.
 
 - At-rule before `{` — [atrule_before_opening_brace](../tests/fixtures/css/tokens/comments/atrule_before_opening_brace_prettier_divergence/)
 - At-rule in prelude — [atrule_in_prelude](../tests/fixtures/css/tokens/comments/atrule_in_prelude_prettier_divergence/)
@@ -161,7 +178,7 @@ Prettier has stable variants for comment positioning. tsv normalizes consistentl
 
 ### Whitespace: BOM Handling
 
-Prettier preserves byte-order marks. tsv strips them (they serve no purpose in UTF-8).
+**BOM stripping.** Prettier preserves byte-order marks. tsv strips them (they serve no purpose in UTF-8).
 
 - Svelte — [bom](../tests/fixtures/svelte/syntax/whitespace/bom_prettier_divergence/)
 - CSS — [bom](../tests/fixtures/css/tokens/whitespace/bom_prettier_divergence/)
@@ -173,14 +190,14 @@ Prettier preserves byte-order marks. tsv strips them (they serve no purpose in U
 | ------------------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
 | Menu block element        | Spec violation       | [menu_block](../tests/fixtures/svelte/elements/menu_block_prettier_divergence/)                                               |
 | Self-closing non-void     | Design choice        | [self_closing_nonvoid](../tests/fixtures/svelte/elements/self_closing_nonvoid_prettier_divergence/)                           |
-| Fill after inline         | Design choice        | [fill_after_inline](../tests/fixtures/svelte/elements/fill_after_inline_prettier_divergence/)                                 |
-| Fill boundary             | Design choice        | [inline_element_fill_long](../tests/fixtures/svelte/elements/inline_element_fill_long_prettier_divergence/)                   |
-| Fill after breaking attr  | Design choice        | [multiline_value_inline_long](../tests/fixtures/svelte/attributes/multiline_value_inline_long_prettier_divergence/)           |
-| Component fill boundary   | Design choice        | [inline_component_fill_long](../tests/fixtures/svelte/elements/inline_component_fill_long_prettier_divergence/)               |
-| Fill multiple expr        | Design choice        | [fill_multiple_expr_long](../tests/fixtures/svelte/elements/fill_multiple_expr_long_prettier_divergence/)                     |
+| Fill after inline         | Print width          | [fill_after_inline](../tests/fixtures/svelte/elements/fill_after_inline_prettier_divergence/)                                 |
+| Fill boundary             | Print width          | [inline_element_fill_long](../tests/fixtures/svelte/elements/inline_element_fill_long_prettier_divergence/)                   |
+| Fill after breaking attr  | Print width          | [multiline_value_inline_long](../tests/fixtures/svelte/attributes/multiline_value_inline_long_prettier_divergence/)           |
+| Component fill boundary   | Print width          | [inline_component_fill_long](../tests/fixtures/svelte/elements/inline_component_fill_long_prettier_divergence/)               |
+| Fill multiple expr        | Print width          | [fill_multiple_expr_long](../tests/fixtures/svelte/elements/fill_multiple_expr_long_prettier_divergence/)                     |
 | Inline content hug        | Design choice        | [inline_content_hug_long](../tests/fixtures/svelte/elements/inline_content_hug_long_prettier_divergence/)                     |
-| Block multiline attrs hug | Design choice        | [block_multiline_attrs_content_hug](../tests/fixtures/svelte/elements/block_multiline_attrs_content_hug_prettier_divergence/) |
-| Fill expr break boundary  | Design choice        | [fill_expr_break_boundary_long](../tests/fixtures/svelte/elements/fill_expr_break_boundary_long_prettier_divergence/)         |
+| Block multiline attrs hug | Print width          | [block_multiline_attrs_content_hug](../tests/fixtures/svelte/elements/block_multiline_attrs_content_hug_prettier_divergence/) |
+| Fill expr break boundary  | Print width          | [fill_expr_break_boundary_long](../tests/fixtures/svelte/elements/fill_expr_break_boundary_long_prettier_divergence/)         |
 | @debug comments           | Content preservation | [debug_comment](../tests/fixtures/svelte/tags/debug/debug_comment_prettier_divergence/)                                       |
 
 **Fill after inline**: Prettier's fill algorithm allows lines to exceed print width when text follows an inline element closing tag. Prettier produces 111 char lines, tsv breaks at exactly 100 chars.
@@ -205,7 +222,7 @@ Prettier preserves byte-order marks. tsv strips them (they serve no purpose in U
 
 **Trailing comments in `{...}`** (content preservation) — [expr_trailing](../tests/fixtures/svelte/syntax/comments/expr_trailing_prettier_divergence/) (block comments, inline); [expr_trailing_line](../tests/fixtures/svelte/syntax/comments/expr_trailing_line_prettier_divergence/) (line comments — `}` kept on its own line so the `//` doesn't swallow it).
 
-**Same-line `//` comment placement in the attribute list** (placement preservation) — [comment_same_line](../tests/fixtures/svelte/attributes/comment_same_line_prettier_divergence/): a line comment the author put on the same line as the tag name (`<div // foo`) or trailing an attribute that has more attributes after it (`a="1" // mid`) stays trailing that token; prettier relocates it to its own line. A `//` trailing the *last* attribute (before `>`/`/>`) already stays inline in both formatters, so it is not a divergence — [comment_trailing_same_line](../tests/fixtures/svelte/attributes/comment_trailing_same_line/). Block comments and own-line comments are preserved as-written by both. See [Comment Position Philosophy](#comment-position-philosophy).
+**Same-line `//` comment placement in the attribute list** (comment preservation) — [comment_same_line](../tests/fixtures/svelte/attributes/comment_same_line_prettier_divergence/): a line comment the author put on the same line as the tag name (`<div // foo`) or trailing an attribute that has more attributes after it (`a="1" // mid`) stays trailing that token; prettier relocates it to its own line. A `//` trailing the *last* attribute (before `>`/`/>`) already stays inline in both formatters, so it is not a divergence — [comment_trailing_same_line](../tests/fixtures/svelte/attributes/comment_trailing_same_line/). Block comments and own-line comments are preserved as-written by both. See [Comment Position Philosophy](#comment-position-philosophy).
 
 ### Svelte: Blocks
 
@@ -216,7 +233,7 @@ Prettier preserves byte-order marks. tsv strips them (they serve no purpose in U
 - `{#if}` last block quirk — [last_block](../tests/fixtures/svelte/blocks/if/last_block_prettier_divergence/)
 - `{#if}` short expr 100+ — [in_inline_element_long](../tests/fixtures/svelte/blocks/if/in_inline_element_long_prettier_divergence/)
 
-Prettier doesn't apply width-based wrapping to block expressions:
+**Print width.** Prettier doesn't apply width-based wrapping to block expressions:
 
 - **Method chains** in `{#each}`, `{#await}`, `{#if}`, `{#key}`, etc. don't account for the tag prefix width, resulting in 140+ char lines. tsv passes context offset for proper wrapping.
 - **Logical expressions** (`&&`, `||`) in block conditions are never wrapped internally by Prettier, even when exceeding 100 chars. (In `<script>`, assignments provide a break point so this isn't an issue.) tsv wraps them with proper indentation.
@@ -231,15 +248,15 @@ Prettier doesn't apply width-based wrapping to block expressions:
 | Feature                                   | Reason                | Fixture                                                                                                                                          |
 | ----------------------------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
 | Empty statement blank lines               | Design choice         | [empty_standalone](../tests/fixtures/typescript/statements/empty_standalone_prettier_divergence/)                                                |
-| Return type generic union                 | Design choice         | [return_type_generic_union_long](../tests/fixtures/typescript/declarations/function/return_type_generic_union_long_prettier_divergence/)         |
-| Single specifier import                   | Design choice         | [single_specifier_long](../tests/fixtures/typescript/modules/imports/single_specifier_long_prettier_divergence/)                                 |
-| Module path calls                         | Design choice         | [path_calls_long](../tests/fixtures/typescript/modules/imports/path_calls_long_prettier_divergence/)                                             |
+| Return type generic union                 | Print width           | [return_type_generic_union_long](../tests/fixtures/typescript/declarations/function/return_type_generic_union_long_prettier_divergence/)         |
+| Single specifier import                   | Print width           | [single_specifier_long](../tests/fixtures/typescript/modules/imports/single_specifier_long_prettier_divergence/)                                 |
+| Module path calls                         | Print width           | [path_calls_long](../tests/fixtures/typescript/modules/imports/path_calls_long_prettier_divergence/)                                             |
 | Instantiation expression parens           | Semantic preservation | [instantiation_parens](../tests/fixtures/typescript/typescript_specific/assertions/instantiation_parens_prettier_divergence/)                    |
 | Optional-chain base member chain          | Semantic preservation | [optional_paren_member_chain](../tests/fixtures/typescript/expressions/chain/optional_paren_member_chain_prettier_divergence/)                   |
 | Optional-chain non-null base member chain | Semantic preservation | [optional_paren_non_null_member_chain](../tests/fixtures/typescript/expressions/chain/optional_paren_non_null_member_chain_prettier_divergence/) |
-| Optional-chain non-null new callee        | Semantic preservation | [optional_paren_non_null_new_callee](../tests/fixtures/typescript/expressions/chain/optional_paren_non_null_new_callee_prettier_divergence/)     |
+| Optional-chain non-null new callee        | Prettier bug          | [optional_paren_non_null_new_callee](../tests/fixtures/typescript/expressions/chain/optional_paren_non_null_new_callee_prettier_divergence/)     |
 | Non-null parenthesized base               | Design choice         | [non_null_paren_base_long](../tests/fixtures/typescript/expressions/member/non_null_paren_base_long_prettier_divergence/)                        |
-| Constrained infer extends-operand parens  | Semantic preservation | [constrained_extends_parens](../tests/fixtures/typescript/types/infer/constrained_extends_parens_prettier_divergence/)                           |
+| Constrained infer extends-operand parens  | Prettier bug          | [constrained_extends_parens](../tests/fixtures/typescript/types/infer/constrained_extends_parens_prettier_divergence/)                           |
 
 **Instantiation expression parens**: Prettier strips parentheses from ternary and binary expressions in `TSInstantiationExpression` (`(x ? y : z)<T>` → `x ? y : z<T>`), changing semantics. Without parens, `<T>` only applies to the last operand. tsv preserves parens to maintain the original meaning. Both formatters agree on preserving parens for assignment expressions (`(x = y)<T>`).
 
@@ -263,23 +280,9 @@ tsv treats these like any other function call—no special-casing for module pat
 
 **Return type generic union**: Prettier has special handling for `null` and `void` in union types within generic return types. When the second union member is `null` or `void`: (1) function declarations and class methods allow lines to exceed print width instead of breaking inside `<>`, (2) arrow functions break the assignment (`const fn =`) instead of breaking inside the return type. tsv breaks consistently inside the return type generic at the print width boundary regardless of type keyword.
 
-### Tabs-Only Alignment (No Sub-Tab Spaces)
-
-When breaking a union type, Prettier wraps each member's type doc in
-`align(2, …)` (`union-type.js`) to offset the 2-char `|` prefix. With
-`--use-tabs`, Prettier's indentation algorithm renders that 2-column offset as
-a **sub-tab alignment**: content that is further indented rounds the offset up
-to a whole tab, but a closing delimiter sitting at the offset column is emitted
-as `tabs + 2 spaces`. The result mixes tabs and spaces on a single indentation
-level.
+### Tabs-Only Alignment
 
-tsv renders **all** indentation as whole tabs and never mixes tabs with
-alignment spaces — the 2-column offset is rounded up to one tab everywhere. At
-`tab_width = 2` the two are the same visual width; only the representation
-differs (`⟨n+1 tabs⟩}` vs `⟨n tabs⟩··}`). This keeps indentation
-tab-width-agnostic: a reader viewing tabs at any width sees consistent
-structure, whereas Prettier's 2-space offset assumes the prefix is exactly 2
-columns wide.
+These fixtures exercise the [Tabs-Only Indentation Philosophy](#tabs-only-indentation-philosophy): Prettier's `align(2, …)` for broken union members emits `tabs + 2 spaces` under `--use-tabs`, while tsv rounds the 2-column offset up to a whole tab everywhere.
 
 - Union object member — [union_object_member](../tests/fixtures/typescript/types/union_object_member_prettier_divergence/)
 - Union hugged object — [union_hug_object](../tests/fixtures/typescript/types/union_hug_object_prettier_divergence/)
@@ -521,7 +524,7 @@ Prettier moves comments between syntactic boundaries into adjacent blocks, paren
 
 **Retained paren union member line comment**: the line-comment analog of the above — a line comment trailing the last inner member of a retained parenthesized union (`(a | b // c) | c`, `a | (b | c // c) | d`) → Prettier hoists it out to trail the whole member and keeps the inner union inline (`| (a | b) // c`). tsv keeps it inside the parens; because a line comment must end its line, the parenthesized union expands to its broken form (one member per line) with `)` on its own line. (Otherwise the comment is dropped entirely — content loss.) Unlike the block-comment case — which stays inline because a block comment can — the line comment forces the expanded layout. Our expanded form is stable in tsv; Prettier's inline-with-relocated-comment form is its own stable shape.
 
-**Retained paren first-member leading line comment**: a **leading** line comment inside a retained parenthesized union member, when that member is the **first** member of the outer union (`(// c\n A | B) | C`) → Prettier moves the comment out of the parens to lead the member, keeping the inner union inline when it fits (`| // c\n (A | B)`). tsv keeps it inside the parens leading the inner union; because a line comment must end its line, the parenthesized union expands to its broken form with `)` on its own line. (Otherwise the comment is dropped entirely — content loss: the inner-leading line comment has no previous member to relocate onto.) This is the leading-comment counterpart of the trailing **Retained paren union member line comment** above, and mirrors its keep-inside behavior. A leading line comment inside a **later** member's parens instead relocates to trail the previous member, where both formatters agree (see the [Tabs-Only Alignment](#tabs-only-alignment-no-sub-tab-spaces) `union_paren_member_long_line_comment` fixture); only the first member, lacking a previous member, keeps the comment inside.
+**Retained paren first-member leading line comment**: a **leading** line comment inside a retained parenthesized union member, when that member is the **first** member of the outer union (`(// c\n A | B) | C`) → Prettier moves the comment out of the parens to lead the member, keeping the inner union inline when it fits (`| // c\n (A | B)`). tsv keeps it inside the parens leading the inner union; because a line comment must end its line, the parenthesized union expands to its broken form with `)` on its own line. (Otherwise the comment is dropped entirely — content loss: the inner-leading line comment has no previous member to relocate onto.) This is the leading-comment counterpart of the trailing **Retained paren union member line comment** above, and mirrors its keep-inside behavior. A leading line comment inside a **later** member's parens instead relocates to trail the previous member, where both formatters agree (see the [Tabs-Only Alignment](#tabs-only-alignment) `union_paren_member_long_line_comment` fixture); only the first member, lacking a previous member, keeps the comment inside.
 
 **Retained paren intersection member comment**: the intersection counterpart of the retained-paren-union case — a block comment inside a parenthesized **intersection** member whose parens are retained because it nests in an outer union (`(a & b /* c */) | c`, `a | (/* c */ b & c)`, `a | (b & c /* c */)`) → Prettier hoists the comment out of the parens (trailing after `)`, leading before `(`: `(a & b) /* c */ | c`, `a | /* c */ (b & c)`). tsv keeps it inside the parens, associating it with the parenthesized member. (Unlike the union case this never dropped — it preserves through the paren-unwrapping path — but it is the same comment-position divergence and is pinned for completeness.) Both positions are dual-stable in our formatter.
 
diff --git a/tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/expected.json b/tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/expected.json
new file mode 100644
index 00000000..747ed38e
--- /dev/null
+++ b/tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/expected.json
@@ -0,0 +1,547 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 424,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": [
+			{
+				"type": "Comment",
+				"start": 0,
+				"end": 80,
+				"data": " regex literal containing `}` — closing-brace matching must skip over it "
+			},
+			{
+				"type": "Text",
+				"start": 80,
+				"end": 81,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 81,
+				"end": 116,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 2,
+						"column": 1,
+						"character": 82
+					},
+					"end": {
+						"line": 2,
+						"column": 4,
+						"character": 85
+					}
+				},
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 86,
+						"end": 109,
+						"name": "title",
+						"name_loc": {
+							"start": {
+								"line": 2,
+								"column": 5,
+								"character": 86
+							},
+							"end": {
+								"line": 2,
+								"column": 10,
+								"character": 91
+							}
+						},
+						"value": [
+							{
+								"start": 93,
+								"end": 98,
+								"type": "Text",
+								"raw": "text1",
+								"data": "text1"
+							},
+							{
+								"type": "ExpressionTag",
+								"start": 98,
+								"end": 108,
+								"expression": {
+									"type": "CallExpression",
+									"start": 99,
+									"end": 107,
+									"loc": {
+										"start": {
+											"line": 2,
+											"column": 18
+										},
+										"end": {
+											"line": 2,
+											"column": 26
+										}
+									},
+									"callee": {
+										"type": "Identifier",
+										"start": 99,
+										"end": 100,
+										"loc": {
+											"start": {
+												"line": 2,
+												"column": 18
+											},
+											"end": {
+												"line": 2,
+												"column": 19
+											}
+										},
+										"name": "f"
+									},
+									"arguments": [
+										{
+											"type": "Literal",
+											"start": 101,
+											"end": 106,
+											"loc": {
+												"start": {
+													"line": 2,
+													"column": 20
+												},
+												"end": {
+													"line": 2,
+													"column": 25
+												}
+											},
+											"value": {},
+											"raw": "/[}]/",
+											"regex": {
+												"pattern": "[}]",
+												"flags": ""
+											}
+										}
+									],
+									"optional": false
+								}
+							}
+						]
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 116,
+				"end": 118,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "Comment",
+				"start": 118,
+				"end": 200,
+				"data": " the `}` is inside the second expression's regex, after a first expression "
+			},
+			{
+				"type": "Text",
+				"start": 200,
+				"end": 201,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 201,
+				"end": 234,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 5,
+						"column": 1,
+						"character": 202
+					},
+					"end": {
+						"line": 5,
+						"column": 4,
+						"character": 205
+					}
+				},
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 206,
+						"end": 227,
+						"name": "title",
+						"name_loc": {
+							"start": {
+								"line": 5,
+								"column": 5,
+								"character": 206
+							},
+							"end": {
+								"line": 5,
+								"column": 10,
+								"character": 211
+							}
+						},
+						"value": [
+							{
+								"type": "ExpressionTag",
+								"start": 213,
+								"end": 216,
+								"expression": {
+									"type": "Identifier",
+									"start": 214,
+									"end": 215,
+									"loc": {
+										"start": {
+											"line": 5,
+											"column": 13
+										},
+										"end": {
+											"line": 5,
+											"column": 14
+										}
+									},
+									"name": "a"
+								}
+							},
+							{
+								"type": "ExpressionTag",
+								"start": 216,
+								"end": 226,
+								"expression": {
+									"type": "CallExpression",
+									"start": 217,
+									"end": 225,
+									"loc": {
+										"start": {
+											"line": 5,
+											"column": 16
+										},
+										"end": {
+											"line": 5,
+											"column": 24
+										}
+									},
+									"callee": {
+										"type": "Identifier",
+										"start": 217,
+										"end": 218,
+										"loc": {
+											"start": {
+												"line": 5,
+												"column": 16
+											},
+											"end": {
+												"line": 5,
+												"column": 17
+											}
+										},
+										"name": "f"
+									},
+									"arguments": [
+										{
+											"type": "Literal",
+											"start": 219,
+											"end": 224,
+											"loc": {
+												"start": {
+													"line": 5,
+													"column": 18
+												},
+												"end": {
+													"line": 5,
+													"column": 23
+												}
+											},
+											"value": {},
+											"raw": "/[}]/",
+											"regex": {
+												"pattern": "[}]",
+												"flags": ""
+											}
+										}
+									],
+									"optional": false
+								}
+							}
+						]
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 234,
+				"end": 236,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "Comment",
+				"start": 236,
+				"end": 273,
+				"data": " block comment containing `}` "
+			},
+			{
+				"type": "Text",
+				"start": 273,
+				"end": 274,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 274,
+				"end": 310,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 8,
+						"column": 1,
+						"character": 275
+					},
+					"end": {
+						"line": 8,
+						"column": 4,
+						"character": 278
+					}
+				},
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 279,
+						"end": 303,
+						"name": "title",
+						"name_loc": {
+							"start": {
+								"line": 8,
+								"column": 5,
+								"character": 279
+							},
+							"end": {
+								"line": 8,
+								"column": 10,
+								"character": 284
+							}
+						},
+						"value": [
+							{
+								"start": 286,
+								"end": 291,
+								"type": "Text",
+								"raw": "text1",
+								"data": "text1"
+							},
+							{
+								"type": "ExpressionTag",
+								"start": 291,
+								"end": 302,
+								"expression": {
+									"type": "Identifier",
+									"start": 300,
+									"end": 301,
+									"loc": {
+										"start": {
+											"line": 8,
+											"column": 26
+										},
+										"end": {
+											"line": 8,
+											"column": 27
+										}
+									},
+									"name": "b",
+									"leadingComments": [
+										{
+											"type": "Block",
+											"value": " } ",
+											"start": 292,
+											"end": 299
+										}
+									]
+								}
+							}
+						]
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 310,
+				"end": 312,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "Comment",
+				"start": 312,
+				"end": 382,
+				"data": " regex with balanced braces already matches; must stay correct "
+			},
+			{
+				"type": "Text",
+				"start": 382,
+				"end": 383,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 383,
+				"end": 423,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 11,
+						"column": 1,
+						"character": 384
+					},
+					"end": {
+						"line": 11,
+						"column": 4,
+						"character": 387
+					}
+				},
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 388,
+						"end": 416,
+						"name": "title",
+						"name_loc": {
+							"start": {
+								"line": 11,
+								"column": 5,
+								"character": 388
+							},
+							"end": {
+								"line": 11,
+								"column": 10,
+								"character": 393
+							}
+						},
+						"value": [
+							{
+								"start": 395,
+								"end": 400,
+								"type": "Text",
+								"raw": "text1",
+								"data": "text1"
+							},
+							{
+								"type": "ExpressionTag",
+								"start": 400,
+								"end": 415,
+								"expression": {
+									"type": "CallExpression",
+									"start": 401,
+									"end": 414,
+									"loc": {
+										"start": {
+											"line": 11,
+											"column": 18
+										},
+										"end": {
+											"line": 11,
+											"column": 31
+										}
+									},
+									"callee": {
+										"type": "Identifier",
+										"start": 401,
+										"end": 402,
+										"loc": {
+											"start": {
+												"line": 11,
+												"column": 18
+											},
+											"end": {
+												"line": 11,
+												"column": 19
+											}
+										},
+										"name": "f"
+									},
+									"arguments": [
+										{
+											"type": "Literal",
+											"start": 403,
+											"end": 410,
+											"loc": {
+												"start": {
+													"line": 11,
+													"column": 20
+												},
+												"end": {
+													"line": 11,
+													"column": 27
+												}
+											},
+											"value": {},
+											"raw": "/[{}]/g",
+											"regex": {
+												"pattern": "[{}]",
+												"flags": "g"
+											}
+										},
+										{
+											"type": "Identifier",
+											"start": 412,
+											"end": 413,
+											"loc": {
+												"start": {
+													"line": 11,
+													"column": 29
+												},
+												"end": {
+													"line": 11,
+													"column": 30
+												}
+											},
+											"name": "b"
+										}
+									],
+									"optional": false
+								}
+							}
+						]
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			}
+		]
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Block",
+			"value": " } ",
+			"start": 292,
+			"end": 299,
+			"loc": {
+				"start": {
+					"line": 8,
+					"column": 18
+				},
+				"end": {
+					"line": 8,
+					"column": 25
+				}
+			}
+		}
+	]
+}
diff --git a/tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/input.svelte b/tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/input.svelte
new file mode 100644
index 00000000..a2394fc3
--- /dev/null
+++ b/tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/input.svelte
@@ -0,0 +1,11 @@
+<!-- regex literal containing `}` — closing-brace matching must skip over it -->
+<div title="text1{f(/[}]/)}"></div>
+
+<!-- the `}` is inside the second expression's regex, after a first expression -->
+<div title="{a}{f(/[}]/)}"></div>
+
+<!-- block comment containing `}` -->
+<div title="text1{/* } */ b}"></div>
+
+<!-- regex with balanced braces already matches; must stay correct -->
+<div title="text1{f(/[{}]/g, b)}"></div>
diff --git a/tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/unformatted_unquoted.svelte b/tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/unformatted_unquoted.svelte
new file mode 100644
index 00000000..672fdeb7
--- /dev/null
+++ b/tests/fixtures/svelte/attributes/expression_brace_in_regex_comment/unformatted_unquoted.svelte
@@ -0,0 +1,11 @@
+<!-- regex literal containing `}` — closing-brace matching must skip over it -->
+<div title=text1{f(/[}]/)}></div>
+
+<!-- the `}` is inside the second expression's regex, after a first expression -->
+<div title={a}{f(/[}]/)}></div>
+
+<!-- block comment containing `}` -->
+<div title=text1{/* } */ b}></div>
+
+<!-- regex with balanced braces already matches; must stay correct -->
+<div title=text1{f(/[{}]/g, b)}></div>
diff --git a/tests/fixtures/svelte/attributes/spread_brace_in_regex_comment/expected.json b/tests/fixtures/svelte/attributes/spread_brace_in_regex_comment/expected.json
new file mode 100644
index 00000000..2f0ff69d
--- /dev/null
+++ b/tests/fixtures/svelte/attributes/spread_brace_in_regex_comment/expected.json
@@ -0,0 +1,309 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 159,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": [
+			{
+				"type": "Comment",
+				"start": 0,
+				"end": 78,
+				"data": " `}` inside a regex, string, or comment must not close the {...} early "
+			},
+			{
+				"type": "Text",
+				"start": 78,
+				"end": 79,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 79,
+				"end": 104,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 2,
+						"column": 1,
+						"character": 80
+					},
+					"end": {
+						"line": 2,
+						"column": 4,
+						"character": 83
+					}
+				},
+				"attributes": [
+					{
+						"type": "SpreadAttribute",
+						"start": 84,
+						"end": 97,
+						"expression": {
+							"type": "CallExpression",
+							"start": 88,
+							"end": 96,
+							"loc": {
+								"start": {
+									"line": 2,
+									"column": 9
+								},
+								"end": {
+									"line": 2,
+									"column": 17
+								}
+							},
+							"callee": {
+								"type": "Identifier",
+								"start": 88,
+								"end": 89,
+								"loc": {
+									"start": {
+										"line": 2,
+										"column": 9
+									},
+									"end": {
+										"line": 2,
+										"column": 10
+									}
+								},
+								"name": "f"
+							},
+							"arguments": [
+								{
+									"type": "Literal",
+									"start": 90,
+									"end": 95,
+									"loc": {
+										"start": {
+											"line": 2,
+											"column": 11
+										},
+										"end": {
+											"line": 2,
+											"column": 16
+										}
+									},
+									"value": {},
+									"raw": "/[}]/",
+									"regex": {
+										"pattern": "[}]",
+										"flags": ""
+									}
+								}
+							],
+							"optional": false
+						}
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 104,
+				"end": 105,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 105,
+				"end": 128,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 3,
+						"column": 1,
+						"character": 106
+					},
+					"end": {
+						"line": 3,
+						"column": 4,
+						"character": 109
+					}
+				},
+				"attributes": [
+					{
+						"type": "SpreadAttribute",
+						"start": 110,
+						"end": 121,
+						"expression": {
+							"type": "CallExpression",
+							"start": 114,
+							"end": 120,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 9
+								},
+								"end": {
+									"line": 3,
+									"column": 15
+								}
+							},
+							"callee": {
+								"type": "Identifier",
+								"start": 114,
+								"end": 115,
+								"loc": {
+									"start": {
+										"line": 3,
+										"column": 9
+									},
+									"end": {
+										"line": 3,
+										"column": 10
+									}
+								},
+								"name": "g"
+							},
+							"arguments": [
+								{
+									"type": "Literal",
+									"start": 116,
+									"end": 119,
+									"loc": {
+										"start": {
+											"line": 3,
+											"column": 11
+										},
+										"end": {
+											"line": 3,
+											"column": 14
+										}
+									},
+									"value": "}",
+									"raw": "'}'"
+								}
+							],
+							"optional": false
+						}
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 128,
+				"end": 129,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 129,
+				"end": 158,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 4,
+						"column": 1,
+						"character": 130
+					},
+					"end": {
+						"line": 4,
+						"column": 4,
+						"character": 133
+					}
+				},
+				"attributes": [
+					{
+						"type": "SpreadAttribute",
+						"start": 134,
+						"end": 151,
+						"expression": {
+							"type": "CallExpression",
+							"start": 138,
+							"end": 150,
+							"loc": {
+								"start": {
+									"line": 4,
+									"column": 9
+								},
+								"end": {
+									"line": 4,
+									"column": 21
+								}
+							},
+							"callee": {
+								"type": "Identifier",
+								"start": 138,
+								"end": 139,
+								"loc": {
+									"start": {
+										"line": 4,
+										"column": 9
+									},
+									"end": {
+										"line": 4,
+										"column": 10
+									}
+								},
+								"name": "h"
+							},
+							"arguments": [
+								{
+									"type": "Identifier",
+									"start": 148,
+									"end": 149,
+									"loc": {
+										"start": {
+											"line": 4,
+											"column": 19
+										},
+										"end": {
+											"line": 4,
+											"column": 20
+										}
+									},
+									"name": "k",
+									"leadingComments": [
+										{
+											"type": "Block",
+											"value": " } ",
+											"start": 140,
+											"end": 147
+										}
+									]
+								}
+							],
+							"optional": false
+						}
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			}
+		]
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Block",
+			"value": " } ",
+			"start": 140,
+			"end": 147,
+			"loc": {
+				"start": {
+					"line": 4,
+					"column": 11
+				},
+				"end": {
+					"line": 4,
+					"column": 18
+				}
+			}
+		}
+	]
+}
diff --git a/tests/fixtures/svelte/attributes/spread_brace_in_regex_comment/input.svelte b/tests/fixtures/svelte/attributes/spread_brace_in_regex_comment/input.svelte
new file mode 100644
index 00000000..fc012060
--- /dev/null
+++ b/tests/fixtures/svelte/attributes/spread_brace_in_regex_comment/input.svelte
@@ -0,0 +1,4 @@
+<!-- `}` inside a regex, string, or comment must not close the {...} early -->
+<div {...f(/[}]/)}></div>
+<div {...g('}')}></div>
+<div {...h(/* } */ k)}></div>
diff --git a/tests/fixtures/svelte/attributes/unquoted_sequence/expected.json b/tests/fixtures/svelte/attributes/unquoted_sequence/expected.json
new file mode 100644
index 00000000..15ccff97
--- /dev/null
+++ b/tests/fixtures/svelte/attributes/unquoted_sequence/expected.json
@@ -0,0 +1,447 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 456,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": [
+			{
+				"type": "Comment",
+				"start": 0,
+				"end": 72,
+				"data": " adjacent expressions read as one value, not separate attributes "
+			},
+			{
+				"type": "Text",
+				"start": 72,
+				"end": 73,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 73,
+				"end": 104,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 2,
+						"column": 1,
+						"character": 74
+					},
+					"end": {
+						"line": 2,
+						"column": 4,
+						"character": 77
+					}
+				},
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 78,
+						"end": 97,
+						"name": "data-attr1",
+						"name_loc": {
+							"start": {
+								"line": 2,
+								"column": 5,
+								"character": 78
+							},
+							"end": {
+								"line": 2,
+								"column": 15,
+								"character": 88
+							}
+						},
+						"value": [
+							{
+								"type": "ExpressionTag",
+								"start": 90,
+								"end": 93,
+								"expression": {
+									"type": "Identifier",
+									"start": 91,
+									"end": 92,
+									"loc": {
+										"start": {
+											"line": 2,
+											"column": 18
+										},
+										"end": {
+											"line": 2,
+											"column": 19
+										}
+									},
+									"name": "a"
+								}
+							},
+							{
+								"type": "ExpressionTag",
+								"start": 93,
+								"end": 96,
+								"expression": {
+									"type": "Identifier",
+									"start": 94,
+									"end": 95,
+									"loc": {
+										"start": {
+											"line": 2,
+											"column": 21
+										},
+										"end": {
+											"line": 2,
+											"column": 22
+										}
+									},
+									"name": "b"
+								}
+							}
+						]
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 104,
+				"end": 106,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "Comment",
+				"start": 106,
+				"end": 142,
+				"data": " expression followed by text "
+			},
+			{
+				"type": "Text",
+				"start": 142,
+				"end": 143,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 143,
+				"end": 178,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 5,
+						"column": 1,
+						"character": 144
+					},
+					"end": {
+						"line": 5,
+						"column": 4,
+						"character": 147
+					}
+				},
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 148,
+						"end": 171,
+						"name": "data-attr2",
+						"name_loc": {
+							"start": {
+								"line": 5,
+								"column": 5,
+								"character": 148
+							},
+							"end": {
+								"line": 5,
+								"column": 15,
+								"character": 158
+							}
+						},
+						"value": [
+							{
+								"type": "ExpressionTag",
+								"start": 160,
+								"end": 163,
+								"expression": {
+									"type": "Identifier",
+									"start": 161,
+									"end": 162,
+									"loc": {
+										"start": {
+											"line": 5,
+											"column": 18
+										},
+										"end": {
+											"line": 5,
+											"column": 19
+										}
+									},
+									"name": "a"
+								}
+							},
+							{
+								"start": 163,
+								"end": 170,
+								"type": "Text",
+								"raw": "//text1",
+								"data": "//text1"
+							}
+						]
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 178,
+				"end": 180,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "Comment",
+				"start": 180,
+				"end": 216,
+				"data": " text followed by expression "
+			},
+			{
+				"type": "Text",
+				"start": 216,
+				"end": 217,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 217,
+				"end": 250,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 8,
+						"column": 1,
+						"character": 218
+					},
+					"end": {
+						"line": 8,
+						"column": 4,
+						"character": 221
+					}
+				},
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 222,
+						"end": 243,
+						"name": "data-attr3",
+						"name_loc": {
+							"start": {
+								"line": 8,
+								"column": 5,
+								"character": 222
+							},
+							"end": {
+								"line": 8,
+								"column": 15,
+								"character": 232
+							}
+						},
+						"value": [
+							{
+								"start": 234,
+								"end": 239,
+								"type": "Text",
+								"raw": "text1",
+								"data": "text1"
+							},
+							{
+								"type": "ExpressionTag",
+								"start": 239,
+								"end": 242,
+								"expression": {
+									"type": "Identifier",
+									"start": 240,
+									"end": 241,
+									"loc": {
+										"start": {
+											"line": 8,
+											"column": 23
+										},
+										"end": {
+											"line": 8,
+											"column": 24
+										}
+									},
+									"name": "a"
+								}
+							}
+						]
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 250,
+				"end": 252,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "Comment",
+				"start": 252,
+				"end": 330,
+				"data": " a bare slash is value content; only `/>` terminates an unquoted value "
+			},
+			{
+				"type": "Text",
+				"start": 330,
+				"end": 331,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 331,
+				"end": 362,
+				"name": "a",
+				"name_loc": {
+					"start": {
+						"line": 11,
+						"column": 1,
+						"character": 332
+					},
+					"end": {
+						"line": 11,
+						"column": 2,
+						"character": 333
+					}
+				},
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 334,
+						"end": 353,
+						"name": "href",
+						"name_loc": {
+							"start": {
+								"line": 11,
+								"column": 3,
+								"character": 334
+							},
+							"end": {
+								"line": 11,
+								"column": 7,
+								"character": 338
+							}
+						},
+						"value": [
+							{
+								"start": 340,
+								"end": 352,
+								"type": "Text",
+								"raw": "/text1/text2",
+								"data": "/text1/text2"
+							}
+						]
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": [
+						{
+							"type": "Text",
+							"start": 354,
+							"end": 358,
+							"raw": "link",
+							"data": "link"
+						}
+					]
+				}
+			},
+			{
+				"type": "Text",
+				"start": 362,
+				"end": 364,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "Comment",
+				"start": 364,
+				"end": 426,
+				"data": " `/>` self-close terminates the value before the slash "
+			},
+			{
+				"type": "Text",
+				"start": 426,
+				"end": 427,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 427,
+				"end": 455,
+				"name": "input",
+				"name_loc": {
+					"start": {
+						"line": 14,
+						"column": 1,
+						"character": 428
+					},
+					"end": {
+						"line": 14,
+						"column": 6,
+						"character": 433
+					}
+				},
+				"attributes": [
+					{
+						"type": "Attribute",
+						"start": 434,
+						"end": 452,
+						"name": "data-attr4",
+						"name_loc": {
+							"start": {
+								"line": 14,
+								"column": 7,
+								"character": 434
+							},
+							"end": {
+								"line": 14,
+								"column": 17,
+								"character": 444
+							}
+						},
+						"value": [
+							{
+								"start": 446,
+								"end": 451,
+								"type": "Text",
+								"raw": "value",
+								"data": "value"
+							}
+						]
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			}
+		]
+	},
+	"options": null,
+	"comments": []
+}
diff --git a/tests/fixtures/svelte/attributes/unquoted_sequence/input.svelte b/tests/fixtures/svelte/attributes/unquoted_sequence/input.svelte
new file mode 100644
index 00000000..0695ab4a
--- /dev/null
+++ b/tests/fixtures/svelte/attributes/unquoted_sequence/input.svelte
@@ -0,0 +1,14 @@
+<!-- adjacent expressions read as one value, not separate attributes -->
+<div data-attr1="{a}{b}"></div>
+
+<!-- expression followed by text -->
+<div data-attr2="{a}//text1"></div>
+
+<!-- text followed by expression -->
+<div data-attr3="text1{a}"></div>
+
+<!-- a bare slash is value content; only `/>` terminates an unquoted value -->
+<a href="/text1/text2">link</a>
+
+<!-- `/>` self-close terminates the value before the slash -->
+<input data-attr4="value" />
diff --git a/tests/fixtures/svelte/attributes/unquoted_sequence/unformatted_unquoted.svelte b/tests/fixtures/svelte/attributes/unquoted_sequence/unformatted_unquoted.svelte
new file mode 100644
index 00000000..aab1dcaf
--- /dev/null
+++ b/tests/fixtures/svelte/attributes/unquoted_sequence/unformatted_unquoted.svelte
@@ -0,0 +1,14 @@
+<!-- adjacent expressions read as one value, not separate attributes -->
+<div data-attr1={a}{b}></div>
+
+<!-- expression followed by text -->
+<div data-attr2={a}//text1></div>
+
+<!-- text followed by expression -->
+<div data-attr3=text1{a}></div>
+
+<!-- a bare slash is value content; only `/>` terminates an unquoted value -->
+<a href=/text1/text2>link</a>
+
+<!-- `/>` self-close terminates the value before the slash -->
+<input data-attr4=value/>
diff --git a/tests/fixtures/svelte/blocks/if/if_brace_in_regex_comment/expected.json b/tests/fixtures/svelte/blocks/if/if_brace_in_regex_comment/expected.json
new file mode 100644
index 00000000..b579e13a
--- /dev/null
+++ b/tests/fixtures/svelte/blocks/if/if_brace_in_regex_comment/expected.json
@@ -0,0 +1,202 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 115,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": [
+			{
+				"type": "Comment",
+				"start": 0,
+				"end": 68,
+				"data": " `}` inside a regex / comment must not close the {#if} early "
+			},
+			{
+				"type": "Text",
+				"start": 68,
+				"end": 69,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "IfBlock",
+				"elseif": false,
+				"start": 69,
+				"end": 89,
+				"test": {
+					"type": "CallExpression",
+					"start": 74,
+					"end": 82,
+					"loc": {
+						"start": {
+							"line": 2,
+							"column": 5
+						},
+						"end": {
+							"line": 2,
+							"column": 13
+						}
+					},
+					"callee": {
+						"type": "Identifier",
+						"start": 74,
+						"end": 75,
+						"loc": {
+							"start": {
+								"line": 2,
+								"column": 5
+							},
+							"end": {
+								"line": 2,
+								"column": 6
+							}
+						},
+						"name": "f"
+					},
+					"arguments": [
+						{
+							"type": "Literal",
+							"start": 76,
+							"end": 81,
+							"loc": {
+								"start": {
+									"line": 2,
+									"column": 7
+								},
+								"end": {
+									"line": 2,
+									"column": 12
+								}
+							},
+							"value": {},
+							"raw": "/[}]/",
+							"regex": {
+								"pattern": "[}]",
+								"flags": ""
+							}
+						}
+					],
+					"optional": false
+				},
+				"consequent": {
+					"type": "Fragment",
+					"nodes": [
+						{
+							"type": "Text",
+							"start": 83,
+							"end": 84,
+							"raw": "a",
+							"data": "a"
+						}
+					]
+				},
+				"alternate": null
+			},
+			{
+				"type": "Text",
+				"start": 89,
+				"end": 90,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "IfBlock",
+				"elseif": false,
+				"start": 90,
+				"end": 114,
+				"test": {
+					"type": "CallExpression",
+					"start": 95,
+					"end": 107,
+					"loc": {
+						"start": {
+							"line": 3,
+							"column": 5
+						},
+						"end": {
+							"line": 3,
+							"column": 17
+						}
+					},
+					"callee": {
+						"type": "Identifier",
+						"start": 95,
+						"end": 96,
+						"loc": {
+							"start": {
+								"line": 3,
+								"column": 5
+							},
+							"end": {
+								"line": 3,
+								"column": 6
+							}
+						},
+						"name": "g"
+					},
+					"arguments": [
+						{
+							"type": "Identifier",
+							"start": 105,
+							"end": 106,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 15
+								},
+								"end": {
+									"line": 3,
+									"column": 16
+								}
+							},
+							"name": "x",
+							"leadingComments": [
+								{
+									"type": "Block",
+									"value": " } ",
+									"start": 97,
+									"end": 104
+								}
+							]
+						}
+					],
+					"optional": false
+				},
+				"consequent": {
+					"type": "Fragment",
+					"nodes": [
+						{
+							"type": "Text",
+							"start": 108,
+							"end": 109,
+							"raw": "b",
+							"data": "b"
+						}
+					]
+				},
+				"alternate": null
+			}
+		]
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Block",
+			"value": " } ",
+			"start": 97,
+			"end": 104,
+			"loc": {
+				"start": {
+					"line": 3,
+					"column": 7
+				},
+				"end": {
+					"line": 3,
+					"column": 14
+				}
+			}
+		}
+	]
+}
diff --git a/tests/fixtures/svelte/blocks/if/if_brace_in_regex_comment/input.svelte b/tests/fixtures/svelte/blocks/if/if_brace_in_regex_comment/input.svelte
new file mode 100644
index 00000000..08a037e3
--- /dev/null
+++ b/tests/fixtures/svelte/blocks/if/if_brace_in_regex_comment/input.svelte
@@ -0,0 +1,3 @@
+<!-- `}` inside a regex / comment must not close the {#if} early -->
+{#if f(/[}]/)}a{/if}
+{#if g(/* } */ x)}b{/if}
diff --git a/tests/fixtures/svelte/tags/attach/attach_brace_in_regex_comment/expected.json b/tests/fixtures/svelte/tags/attach/attach_brace_in_regex_comment/expected.json
new file mode 100644
index 00000000..cb3dc31e
--- /dev/null
+++ b/tests/fixtures/svelte/tags/attach/attach_brace_in_regex_comment/expected.json
@@ -0,0 +1,309 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 178,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": [
+			{
+				"type": "Comment",
+				"start": 0,
+				"end": 82,
+				"data": " `}` inside a regex, string, or comment must not close the {@attach} early "
+			},
+			{
+				"type": "Text",
+				"start": 82,
+				"end": 83,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 83,
+				"end": 113,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 2,
+						"column": 1,
+						"character": 84
+					},
+					"end": {
+						"line": 2,
+						"column": 4,
+						"character": 87
+					}
+				},
+				"attributes": [
+					{
+						"type": "AttachTag",
+						"start": 88,
+						"end": 106,
+						"expression": {
+							"type": "CallExpression",
+							"start": 97,
+							"end": 105,
+							"loc": {
+								"start": {
+									"line": 2,
+									"column": 14
+								},
+								"end": {
+									"line": 2,
+									"column": 22
+								}
+							},
+							"callee": {
+								"type": "Identifier",
+								"start": 97,
+								"end": 98,
+								"loc": {
+									"start": {
+										"line": 2,
+										"column": 14
+									},
+									"end": {
+										"line": 2,
+										"column": 15
+									}
+								},
+								"name": "a"
+							},
+							"arguments": [
+								{
+									"type": "Literal",
+									"start": 99,
+									"end": 104,
+									"loc": {
+										"start": {
+											"line": 2,
+											"column": 16
+										},
+										"end": {
+											"line": 2,
+											"column": 21
+										}
+									},
+									"value": {},
+									"raw": "/[}]/",
+									"regex": {
+										"pattern": "[}]",
+										"flags": ""
+									}
+								}
+							],
+							"optional": false
+						}
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 113,
+				"end": 114,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 114,
+				"end": 142,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 3,
+						"column": 1,
+						"character": 115
+					},
+					"end": {
+						"line": 3,
+						"column": 4,
+						"character": 118
+					}
+				},
+				"attributes": [
+					{
+						"type": "AttachTag",
+						"start": 119,
+						"end": 135,
+						"expression": {
+							"type": "CallExpression",
+							"start": 128,
+							"end": 134,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 14
+								},
+								"end": {
+									"line": 3,
+									"column": 20
+								}
+							},
+							"callee": {
+								"type": "Identifier",
+								"start": 128,
+								"end": 129,
+								"loc": {
+									"start": {
+										"line": 3,
+										"column": 14
+									},
+									"end": {
+										"line": 3,
+										"column": 15
+									}
+								},
+								"name": "b"
+							},
+							"arguments": [
+								{
+									"type": "Literal",
+									"start": 130,
+									"end": 133,
+									"loc": {
+										"start": {
+											"line": 3,
+											"column": 16
+										},
+										"end": {
+											"line": 3,
+											"column": 19
+										}
+									},
+									"value": "}",
+									"raw": "'}'"
+								}
+							],
+							"optional": false
+						}
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			},
+			{
+				"type": "Text",
+				"start": 142,
+				"end": 143,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "RegularElement",
+				"start": 143,
+				"end": 177,
+				"name": "div",
+				"name_loc": {
+					"start": {
+						"line": 4,
+						"column": 1,
+						"character": 144
+					},
+					"end": {
+						"line": 4,
+						"column": 4,
+						"character": 147
+					}
+				},
+				"attributes": [
+					{
+						"type": "AttachTag",
+						"start": 148,
+						"end": 170,
+						"expression": {
+							"type": "CallExpression",
+							"start": 157,
+							"end": 169,
+							"loc": {
+								"start": {
+									"line": 4,
+									"column": 14
+								},
+								"end": {
+									"line": 4,
+									"column": 26
+								}
+							},
+							"callee": {
+								"type": "Identifier",
+								"start": 157,
+								"end": 158,
+								"loc": {
+									"start": {
+										"line": 4,
+										"column": 14
+									},
+									"end": {
+										"line": 4,
+										"column": 15
+									}
+								},
+								"name": "c"
+							},
+							"arguments": [
+								{
+									"type": "Identifier",
+									"start": 167,
+									"end": 168,
+									"loc": {
+										"start": {
+											"line": 4,
+											"column": 24
+										},
+										"end": {
+											"line": 4,
+											"column": 25
+										}
+									},
+									"name": "d",
+									"leadingComments": [
+										{
+											"type": "Block",
+											"value": " } ",
+											"start": 159,
+											"end": 166
+										}
+									]
+								}
+							],
+							"optional": false
+						}
+					}
+				],
+				"fragment": {
+					"type": "Fragment",
+					"nodes": []
+				}
+			}
+		]
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Block",
+			"value": " } ",
+			"start": 159,
+			"end": 166,
+			"loc": {
+				"start": {
+					"line": 4,
+					"column": 16
+				},
+				"end": {
+					"line": 4,
+					"column": 23
+				}
+			}
+		}
+	]
+}
diff --git a/tests/fixtures/svelte/tags/attach/attach_brace_in_regex_comment/input.svelte b/tests/fixtures/svelte/tags/attach/attach_brace_in_regex_comment/input.svelte
new file mode 100644
index 00000000..f88a8960
--- /dev/null
+++ b/tests/fixtures/svelte/tags/attach/attach_brace_in_regex_comment/input.svelte
@@ -0,0 +1,4 @@
+<!-- `}` inside a regex, string, or comment must not close the {@attach} early -->
+<div {@attach a(/[}]/)}></div>
+<div {@attach b('}')}></div>
+<div {@attach c(/* } */ d)}></div>
diff --git a/tests/fixtures/svelte/tags/html/html_brace_in_regex_comment/expected.json b/tests/fixtures/svelte/tags/html/html_brace_in_regex_comment/expected.json
new file mode 100644
index 00000000..df4a891c
--- /dev/null
+++ b/tests/fixtures/svelte/tags/html/html_brace_in_regex_comment/expected.json
@@ -0,0 +1,174 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 109,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": [
+			{
+				"type": "Comment",
+				"start": 0,
+				"end": 70,
+				"data": " `}` inside a regex / comment must not close the {@html} early "
+			},
+			{
+				"type": "Text",
+				"start": 70,
+				"end": 71,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "HtmlTag",
+				"start": 71,
+				"end": 87,
+				"expression": {
+					"type": "CallExpression",
+					"start": 78,
+					"end": 86,
+					"loc": {
+						"start": {
+							"line": 2,
+							"column": 7
+						},
+						"end": {
+							"line": 2,
+							"column": 15
+						}
+					},
+					"callee": {
+						"type": "Identifier",
+						"start": 78,
+						"end": 79,
+						"loc": {
+							"start": {
+								"line": 2,
+								"column": 7
+							},
+							"end": {
+								"line": 2,
+								"column": 8
+							}
+						},
+						"name": "h"
+					},
+					"arguments": [
+						{
+							"type": "Literal",
+							"start": 80,
+							"end": 85,
+							"loc": {
+								"start": {
+									"line": 2,
+									"column": 9
+								},
+								"end": {
+									"line": 2,
+									"column": 14
+								}
+							},
+							"value": {},
+							"raw": "/[}]/",
+							"regex": {
+								"pattern": "[}]",
+								"flags": ""
+							}
+						}
+					],
+					"optional": false
+				}
+			},
+			{
+				"type": "Text",
+				"start": 87,
+				"end": 88,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "HtmlTag",
+				"start": 88,
+				"end": 108,
+				"expression": {
+					"type": "CallExpression",
+					"start": 95,
+					"end": 107,
+					"loc": {
+						"start": {
+							"line": 3,
+							"column": 7
+						},
+						"end": {
+							"line": 3,
+							"column": 19
+						}
+					},
+					"callee": {
+						"type": "Identifier",
+						"start": 95,
+						"end": 96,
+						"loc": {
+							"start": {
+								"line": 3,
+								"column": 7
+							},
+							"end": {
+								"line": 3,
+								"column": 8
+							}
+						},
+						"name": "g"
+					},
+					"arguments": [
+						{
+							"type": "Identifier",
+							"start": 105,
+							"end": 106,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 17
+								},
+								"end": {
+									"line": 3,
+									"column": 18
+								}
+							},
+							"name": "x",
+							"leadingComments": [
+								{
+									"type": "Block",
+									"value": " } ",
+									"start": 97,
+									"end": 104
+								}
+							]
+						}
+					],
+					"optional": false
+				}
+			}
+		]
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Block",
+			"value": " } ",
+			"start": 97,
+			"end": 104,
+			"loc": {
+				"start": {
+					"line": 3,
+					"column": 9
+				},
+				"end": {
+					"line": 3,
+					"column": 16
+				}
+			}
+		}
+	]
+}
diff --git a/tests/fixtures/svelte/tags/html/html_brace_in_regex_comment/input.svelte b/tests/fixtures/svelte/tags/html/html_brace_in_regex_comment/input.svelte
new file mode 100644
index 00000000..6a180b27
--- /dev/null
+++ b/tests/fixtures/svelte/tags/html/html_brace_in_regex_comment/input.svelte
@@ -0,0 +1,3 @@
+<!-- `}` inside a regex / comment must not close the {@html} early -->
+{@html h(/[}]/)}
+{@html g(/* } */ x)}