`, ``, a component, and a `svelte:*` special element on both boundary arities (``, ``), the pair that pins the SpecialElement projection onto the same element analysis — with a prose-free run in an inline container as the null control — the one run whose authored lines survive under both formatters, which is what keeps "the container does not decide" from being satisfied by a rule that never consults the run either. **The SIBLING kind reaches one arm none of those fixtures does**: a `svelte:*` special element, which answers the flow question by the same block/inline classification a plain element does — the inline ones (``, ``, ``) flow like a ``, and the four global ones own their line. [special_element_newline_flow](../tests/fixtures/svelte/elements/special_element_newline_flow_prettier_divergence/) pins both halves, the block one as the control that keeps "a special element flows" from being satisfied by a rule that never asks the classification — it is root-only, since Svelte rejects those four inside an element or a block. Its second `prettier_variant_*` carries the classification's own divergence from the layout side: prettier has no `svelte:*` in its block list, so it keeps a **space**-authored `a ⏎a text2` packs). tsv gives the component the same inline-sibling wrap an element takes, in **both** multiline arms of the separator site: a component pair beside prose packs per width from either spelling, and an authored **space** before a component is kept where an element would keep it — in a prose-free run, after a comment, after a control-flow block, and after a predecessor that renders multiline (the component hugs the closing tag as an element does — for the **space** spelling; the newline spelling there is the layout-keyed hold above, for both kinds alike). Holding it in only one arm is a two-pass cycle, not a policy: the one time the arms disagreed, a preceding sibling that rendered multiline left the closing tag at a short column, the wrap fit the component after it, and the emitted container newline made the next pass take the other arm and split the pair. — [inline_adjacent_component_flow](../tests/fixtures/svelte/elements/inline_adjacent_component_flow_prettier_divergence/) (the prose runs, with the element pair beside them, both kind orders, components with children, prose only at the run's end, and the structural and prose-free controls), [inline_adjacent_component_space](../tests/fixtures/svelte/elements/inline_adjacent_component_space_prettier_divergence/) (the space spelling with no prose — prose-free pair, after a comment, after a block, at the root — where the newline spelling is dual-stable, `variant_newline`), [inline_adjacent_component_after_multiline](../tests/fixtures/svelte/elements/inline_adjacent_component_after_multiline_prettier_divergence/) (the multiline predecessor, whose prose-free control keeps its line). Where this rule and the render-free content boundary meet on one element, the two compose to a single form — the flowed content with the boundaries hugged — and must settle in **one pass**, since the flow and the collapse it enables are one decision ([inline_content_flow_collapse](../tests/fixtures/svelte/elements/inline_content_flow_collapse_prettier_divergence/), which pins prettier's two stable forms alongside it). **The prose gate reaches that interior side too, and reaches it at BOTH spellings of the newline.** An authored newline between two inline siblings is folded by the parser into a whitespace-only node when nothing else sits there and into the edge whitespace of the content text beside it when something does, so a rule that reads only one of them gives one document two layouts by that accident — the same accident the run scan rules out at its blank-line boundary above. A one-word run is a label with no fill, so its interior newline is the author's structure and expands the hugged element (`⏎a⏎b text1⏎ `), and it does so equally when the newline sits at a content text's edge (`text1⏎a `, `a b,⏎c` at the edge leaves the text beside it as the effective first or last), and an edge facing a SIBLING, which is the fill's separator and is therefore excluded only where there IS a fill. An element-separator run where both formatters agree once tsv flows it is pinned by `tests/fixtures/svelte/script/escapes` and `tests/fixtures/svelte/style/escapes`.
+**The rule's boundary is the presence of a `fill` to reflow into, not the shape of the separator node.** Flowing means reflowing a run per width, and a run reflows only where there is prose for a `fill` to pack. So the rule reaches a whitespace-only separator standing *between two non-text siblings* — `text1⏎<span>a</span>` and `<span>a</span>⏎<span>b</span>` converge alike — **when that separator's inline run holds prose, which is at least two words**, and not otherwise. A run of pure elements or tags (`<Comp {a} />⏎<Comp {b} />`) keeps its authored lines: with no prose its newlines are the only structure the author has, collapsing them packs independent siblings onto one line, and on a short run the collapse cascades into the parent element's own hug decision — an outright idempotency break (`<mrow>` re-hugs on the second pass once its children fold). **A run holding a single word is a label, not prose, and keeps its lines the same way** — `<Comp />⏎Delete⏎{n}`, `hue:⏎<input />`, `<input />⏎private`, `chars⏎{n}`, `{@render icon()}⏎text1` are a caption beside its icon, a field beside its unit, a label beside its value, and a fill needs a phrase to reflow into; prettier holds every such shape too, so the hold is agreement. Only the run's TEXT counts: an expression tag renders as a value, and a word beside one is a label like any other. The count is **run-level and never node-local**: at a content text's edge run the node beside the sibling is often the one-word tail a previous wrap left behind (`…<code>x</code>⏎prop.`), which a node-local test would hold alone on its line — the accretion the flow rule exists to heal, run in reverse — where the run's total sees the sentence it belongs to, so a one-word node ending a real sentence flows with it. The cliff is two words (`Remember me` still packs), where label and prose genuinely blur, and the count is the most words any **one** text node carries, never a sum over the run: words in two different text nodes are separated by a sibling, and that separation is the author's, so two one-word captions in one run (`text1⏎<input />⏎text2⏎<input />`, an icon-and-caption list) are two labels and hold — a sum packs every such list the moment it holds two entries. The cost is a sentence spelled entirely as one-word fragments between siblings (`text1⏎<span>inline1</span>⏎text2`), which holds; real prose has a two-word node somewhere in its run. The cliff's own cost is the mirror: one two-word caption in a list of one-word captions is prose, and packs its neighbours with it (`<Comp1 />⏎text1⏎<Comp2 />⏎text2 text3` → one line) — pinned as a control so it is recorded, not discovered. The gate is asked identically at all three of the rule's sites — the whitespace-only separator and a content text's leading and trailing runs — and **it is a hold, never a forced break**: it decides whether an authored newline may reflow, and says nothing about an authored space. So a run's space spelling stays inline everywhere, whatever the run holds and whatever precedes it — beside an element, a void element, a component, a render/html tag, inside a content text, and between two **tags**, where the whitespace-only separator defers to the tag's per-width group as a prose run's does: the space-spelled tag separator reads **no run gate and no neighbour gate at all**, so a wordless `{a} {b}` packs exactly as `text1 {a} {b}` does, in every container, and a tag after a comment, a `<br />` or a control-flow block keeps its authored space exactly as an inline element or component does there (`<!-- c --> <span>x</span>` and `<!-- c --> {x}` hug alike; the comment's own line is what the NEWLINE spelling holds). Prettier's `line` between a tag and its neighbour breaks with the container whatever the run holds, so a space-spelled tag after any sibling but text in a multiline container is a divergence of the same family as the prose tag pair below — tsv packs where prettier splits. **And the follower never turns a space into a newline either**: a space before a **comment**, a `{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap after any sibling — an element, a component, a tag, another comment — exactly as it already was after text, so `<span>a</span> <!-- c -->` keeps its space as `text1 <!-- c -->` does, where prettier breaks the former with the container; the NEWLINE spelling is what holds a comment's line, on both of its sides. Only a **block element** on either side of a space still breaks it (its own break already separates them, and a wrap would strand a space after it), and a unit that **renders multiline** drops to a fresh line whole — the wrap's group breaks on its own hardlines — so a space is decided by the follower's kind alone, for every predecessor but a block. — [inline_sibling_space_before_bounding](../tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/) (comment, `{@debug}` and inline-block followers after an element, a component and a tag, in a block and at the root, a comment spaced on both sides, a two-comment run; `variant_newline` the held control, with the multiline block, the block predecessor and the comment's own 100/101 as the parity controls), [inline_adjacent_comment_space_long](../tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/) (the same follower at the ELEMENT's width boundary: the 101-char `<p>` goes block-style and the comment stays on its 97-wide content line). — [inline_sibling_newline_label_hold](../tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_prettier_divergence/) (every label shape held, the caption list and the fragmented sentence among them; the two-word cliff, the one-word sentence tail, the phrase's reach across a whole run and the cliff in a list flowing as `prettier_variant_newline`; `variant_space` the null control), [inline_tag_pair_space](../tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/) (the space-spelled pair — wordless, before and after a word, at the root, and led by an inline element or a component — with the newline spelling as the held control), [inline_tag_pair_space_container](../tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/) (the same pair in every container kind), [inline_tag_pair_space_bounded](../tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/) (the pair after a comment, a `<br />`, a multiline control-flow block and a multiline element — the space hugs the neighbour's line as an element's would and the newline spelling is held — with a block-element predecessor and a line-owning follower as the controls that still break), [inline_tag_pair_space_welded](../tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/) (a welded unit — a glued pair, an ` `, a word glued to both tags — beside a spaced boundary: the weld holds and the space packs), [inline_tag_pair_space_expr_break](../tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/) (a first tag whose expression breaks — the second hugs its closing `)}` line per width, as an element or a word does after a broken tag; the newline spelling held and a breaking second tag travelling whole are the controls), and [inline_sibling_newline_label_hold_long](../tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_long_prettier_divergence/) (the hold at the print-width boundary: the space spelling stays at 100 and wraps at 101 onto the newline spelling, which is then held — the one-way ratchet the hold accepts, prettier's too, though prettier tolerates the 101-char line itself; the wrap is the Elements catalog's fill-boundary divergence). What counts as a word is the fill's own item split over the SOURCE BYTES — an NBSP-joined pair is one word, and so is an entity-encoded space (`text1 text2` is one unbreakable fill item under both formatters, so the count must not promise a seam the fill has not got; the render-side question, whether a node is a separator in content's clothing, reads the decoded text, and the two axes are deliberately distinct), punctuation alone is a word, a hyphenated pair is one, a word glued to a tag is one — and the cliff is the same at a void element (`<input /> text1 text2`, the checkbox-and-caption shape): [inline_sibling_newline_prose_words](../tests/fixtures/svelte/elements/inline_sibling_newline_prose_words_prettier_divergence/). The container is not an axis on the holding side either — the root, an inline element, a list item, a table cell, a control-flow block body and a snippet body hold a one-word run alike: [inline_sibling_newline_label_hold_container](../tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_container_prettier_divergence/). A run is bounded by whatever owns its own line — a block element, a control-flow block, a comment, a `<br />` — and by an authored blank line **wherever the parser put it**: in a whitespace-only node between two siblings, or folded into the edge whitespace of the content text beside it, so that one document does not count two ways by that accident. The count is per run, so a fragment's prose does not license flow in a neighbouring run that has none — a two-word run on one side of a boundary flows right up to it, and the one-word run on the other holds: [inline_sibling_newline_run_bounded](../tests/fixtures/svelte/elements/inline_sibling_newline_run_bounded_prettier_divergence/) (every boundary kind, the blank in both spellings, prose on one side and a label on the other in each, the prose half flowing as `prettier_variant_newline`; and the unbounded twin, where the label flows with the prose). An authored blank INSIDE one text node is not a boundary — a run is a partition of nodes — and the fill collapses it under both formatters, so the sibling newlines beside such a node flow with its prose where prettier holds them: [inline_sibling_newline_interior_blank](../tests/fixtures/svelte/elements/inline_sibling_newline_interior_blank_prettier_divergence/). Bounding is not sterilizing, though: a run that *does* hold prose still flows right up against the bounding sibling, and the two spellings of that ("its own boundaries are held" vs "every line near it is held") are only separated by a control that re-authors the neighbouring run — see the comment-boundary note above. Two mechanics keep this sound and are load-bearing. First, a flowing single newline takes the **space arm verbatim** rather than a parallel one: emitting a different collapsible form for the newline than for the space it claims to equal makes the formatter write a newline that its next pass re-reads as flowable and collapses. Second, the boundary must defer to the next sibling for every follower kind — a tag, a comment, a `{@debug}`, a control-flow block — as it always did for an element: a bare `line` in the child list resolves all-or-nothing with the parent group, and a multiline fragment's parent group is always broken, so without that the one boundary owned by a content text's `fill` would flow while the rest of the same run hard-broke. The deferral is unconditional (a block-element predecessor excepted, whose own break already separates them; a declaration takes its own line): a space asks nothing about what precedes it — a comment's line is authorship, and it is the NEWLINE spelling that holds it. Note `authoring_audit` is blind to the tag half: both spellings agree there whichever form the rule picks — on the flowed form now, on the hard-broken one under a narrower gate — so it scores them as converging either way. — [inline_sibling_newline_flow](../tests/fixtures/svelte/elements/inline_sibling_newline_flow_prettier_divergence/) (an inline element, a component and all three tag kinds — expression, render and `{@html}`, one predicate arm each — plus all five controls) and [expressions/angle_escaped](../tests/fixtures/svelte/expressions/angle_escaped_prettier_divergence/) (the tag-separator case, where prettier's plain `line` holds each tag on its authored line), and the shapes the rule reaches across the suite: [fill_text_inline_collapse](../tests/fixtures/svelte/elements/fill_text_inline_collapse_prettier_divergence/), [root_text_newline_inline](../tests/fixtures/svelte/elements/root_text_newline_inline_prettier_divergence/), [block_text_multiline_collapse](../tests/fixtures/svelte/elements/block_text_multiline_collapse_prettier_divergence/), [inline_attrs_multiline_content](../tests/fixtures/svelte/elements/inline_attrs_multiline_content_prettier_divergence/), [components/root_with_text](../tests/fixtures/svelte/components/root_with_text_prettier_divergence/). **The CONTAINER holding the run is not an axis either**, and no fixture above varies it to say so — nearly all put the flowing run in a block container, and the one inline container that carries one ([inline_attrs_multiline_content](../tests/fixtures/svelte/elements/inline_attrs_multiline_content_prettier_divergence/)) reaches multiline past a 99-char attribute line, confounding the kind with the attribute wrap that fixture exists to test. An inline element reaches the multiline form by a *different boundary rule* — both-or-neither, rather than the block's leading boundary alone — so it is the kind where a container-keyed rule would show, and the run lays out identically once there: [container_kind_newline_flow](../tests/fixtures/svelte/elements/container_kind_newline_flow_prettier_divergence/) holds one run fixed and varies the container across all four kinds — `<button>` / `<label>`, `<p>`, a component, and a `svelte:*` special element on both boundary arities (`<svelte:element>`, `<svelte:head>`), the pair that pins the SpecialElement projection onto the same element analysis — with a prose-free run in an inline container as the null control — the one run whose authored lines survive under both formatters, which is what keeps "the container does not decide" from being satisfied by a rule that never consults the run either. **The SIBLING kind reaches one arm none of those fixtures does**: a `svelte:*` special element, which answers the flow question by the same block/inline classification a plain element does — the inline ones (`<svelte:element>`, `<slot>`, `<svelte:boundary>`) flow like a `<span>`, and the four global ones own their line. [special_element_newline_flow](../tests/fixtures/svelte/elements/special_element_newline_flow_prettier_divergence/) pins both halves, the block one as the control that keeps "a special element flows" from being satisfied by a rule that never asks the classification — it is root-only, since Svelte rejects those four inside an element or a block. Its second `prettier_variant_*` carries the classification's own divergence from the layout side: prettier has no `svelte:*` in its block list, so it keeps a **space**-authored `<svelte:window />` on the text line where tsv gives it its own line from either spelling. **A COMPONENT is the other sibling kind the predicate admits, and it is one follower kind with the inline element at every site that prints this separator.** Prettier's `isInlineElement` admits only a `RegularElement`, so the whitespace-only node before a component is printed as a plain `line` that breaks with the container while the text-adjacent boundaries of the same run hug — one run, two answers, in a line that fits (`text1 <Comp1 />⏎<Comp2 /> text2`, from the **space** spelling as much as the newline one), and the answer turns on which kind happens to sit on which side of the gap (`text1 <span>a</span>⏎<Comp /> text2` splits where `text1 <Comp />⏎<span>a</span> text2` packs). tsv gives the component the same inline-sibling wrap an element takes, in **both** multiline arms of the separator site: a component pair beside prose packs per width from either spelling, and an authored **space** before a component is kept where an element would keep it — in a prose-free run, after a comment, after a control-flow block, and after a predecessor that renders multiline (the component hugs the closing tag as an element does — for the **space** spelling; the newline spelling there is the layout-keyed hold above, for both kinds alike). Holding it in only one arm is a two-pass cycle, not a policy: the one time the arms disagreed, a preceding sibling that rendered multiline left the closing tag at a short column, the wrap fit the component after it, and the emitted container newline made the next pass take the other arm and split the pair. — [inline_adjacent_component_flow](../tests/fixtures/svelte/elements/inline_adjacent_component_flow_prettier_divergence/) (the prose runs, with the element pair beside them, both kind orders, components with children, prose only at the run's end, and the structural and prose-free controls), [inline_adjacent_component_space](../tests/fixtures/svelte/elements/inline_adjacent_component_space_prettier_divergence/) (the space spelling with no prose — prose-free pair, after a comment, after a block, at the root — where the newline spelling is dual-stable, `variant_newline`), [inline_adjacent_component_after_multiline](../tests/fixtures/svelte/elements/inline_adjacent_component_after_multiline_prettier_divergence/) (the multiline predecessor, whose prose-free control keeps its line). Where this rule and the render-free content boundary meet on one element, the two compose to a single form — the flowed content with the boundaries hugged — and must settle in **one pass**, since the flow and the collapse it enables are one decision ([inline_content_flow_collapse](../tests/fixtures/svelte/elements/inline_content_flow_collapse_prettier_divergence/), which pins prettier's two stable forms alongside it). **The prose gate reaches that interior side too, and reaches it at BOTH spellings of the newline.** An authored newline between two inline siblings is folded by the parser into a whitespace-only node when nothing else sits there and into the edge whitespace of the content text beside it when something does, so a rule that reads only one of them gives one document two layouts by that accident — the same accident the run scan rules out at its blank-line boundary above. A one-word run is a label with no fill, so its interior newline is the author's structure and expands the hugged element (`<span>⏎<code>a</code>⏎<code>b</code> text1⏎</span>`), and it does so equally when the newline sits at a content text's edge (`<span>text1⏎<code>a</code></span>`, `<span><code>a</code> <code>b</code>,⏎<code>c</code></span>` — a lone `,` is a word like any other). Prettier holds the newline at both spellings, so the hold is agreement and the divergence stays the block-style-vs-dangle spelling. The two-word twin is the control: the run is prose, the newline is the fill's own wrap point, and the element collapses. — [inline_interior_newline_label_hold](../tests/fixtures/svelte/elements/inline_interior_newline_label_hold_prettier_divergence/) (both spellings held, with the prose twin of each as the control). The mechanism is one gate, not two: the interior scan trims a text's edge run for two different reasons — the element's own boundary air, which is the boundary question and is excluded unconditionally (keyed on the fragment's CONTENT bounds, since a hoisted `{@debug}` / `<title>` at the edge leaves the text beside it as the effective first or last), and an edge facing a SIBLING, which is the fill's separator and is therefore excluded only where there IS a fill. An element-separator run where both formatters agree once tsv flows it is pinned by `tests/fixtures/svelte/script/escapes` and `tests/fixtures/svelte/style/escapes`.
**That same "is there a `fill`?" question decides whether an authored newline in the run's INTERIOR may select the layout** — never the content boundary, whose air the per-kind boundary rule honors regardless of what the content is made of (both boundaries for an inline element or a component, the leading one for a block: [inline_boundary_air](../tests/fixtures/svelte/elements/inline_boundary_air/) / [boundary_air_one_sided](../tests/fixtures/svelte/elements/boundary_air_one_sided_prettier_divergence/)). It is asked of the RUN, never of the separator's shape, the sibling count, or the container's kind. A fill needs two things: **prose to pack** (the run-level count above — at least two words, a one-word run being a label — shared verbatim) and **a whitespace seam to reflow at**. With both, an interior newline is the fill's own wrap point rather than authoring, so the element collapses when it fits — `<span>text1⏎text2 <code>a</code></span>` reflows to the one-line form, its `<p>` and `<Comp>` twins identically (expanding a block or a component on an interior newline, as an inline element never is, would be a split keyed on the container rather than on anything the rule is about), and a ONE-boundary newline reaches the same answer through the arity above, since the edge run it lands in is trimmed before the interior is read ([content_interior_newline_collapse](../tests/fixtures/svelte/elements/content_interior_newline_collapse/), [boundary_air_one_sided](../tests/fixtures/svelte/elements/boundary_air_one_sided_prettier_divergence/); prettier agrees with the collapse in every kind). A pure-sibling run reaches **no** fill answer, and there is deliberately no third path granting it one. `<span>{a}\t{b}</span>` holds no prose, so it has nothing to reflow into, and a pure-sibling run the author DID break keeps its lines for the same reason: with no fill, those lines are the only structure the author has. A `{a} {b}` disjunct granting such a run the fill answer (on the reading that the author left the siblings on one line themselves) would be inert: every reader of "did the author break this content?" is unified onto the two interior-newline arms, which ask the question *of a text node carrying a newline*, and a run such a disjunct accepts has none — every newline-bearing node in it would have to be prose, and a run with prose already reaches the fill answer through the prose path. ⚠️ **A separator's *spelling* still may not pick a layout** — that equality is carried by the boundary and separator paths rather than by a fill answer for content that has no fill: a space and a tab render the same and reach one form across all three sibling kinds, where testing a literal space lets the spelling pick the layout and one document reaches two — [inline_separator_tab](../tests/fixtures/svelte/elements/inline_separator_tab_prettier_divergence/), whose hugged-boundary control isolates it: the tab alone is never the trigger, only the tab *with* a newline-authored boundary that has a layout left to select. **A spelling reaches that rule through what it DECODES to, not through its bytes**, so an entity-encoded space or tab does too: ` ` decodes to whitespace the compiler collapses, which makes it interchangeable with the plain space beside it — and only the *layout* converges, since the entity's own bytes print verbatim (respelling one is a content edit) — [inline_separator_entity_collapse](../tests/fixtures/svelte/elements/inline_separator_entity_collapse_prettier_divergence/). An ` ` decodes to a non-breaking space, which renders as itself and never collapses, so it does not reach the rule at all ([inline_separator_nbsp_newline](../tests/fixtures/svelte/elements/inline_separator_nbsp_newline/)), and neither does an entity in a run the author *did* break, which holds no prose to reflow ([inline_separator_entity_newline](../tests/fixtures/svelte/elements/inline_separator_entity_newline/)). So the two questions read different texts on purpose and neither may borrow the other's axis: the whitespace scalars that decide what PRINTS read `raw` (matching prettier's `node.raw || node.data`), while the separator questions that decide LAYOUT — is this node the run's prose, is this separator interchangeable with a space — read the decoded data. ⚠️ The authority for "same render" is rule 1 for an element or component pair and the **browser's** own collapse for a tag pair, because `clean_nodes` skips the collapse whenever a neighbor is an `ExpressionTag` — `{a}⇥{b}` reaches compiled output with its tab, where `<code>a</code>⇥<code>b</code>` compiles to a space. Both are render-identical under `white-space: normal`, which is the model tsv's render oracle implements and the one this whole section already assumes ([conformance_svelte.md §Template Whitespace](./conformance_svelte.md#template-whitespace-clean_nodes)); do not restate the tag case as a rule-1 consequence, it is not one. Without a seam the content is one unbreakable unit with nothing to reflow, so the boundary is the only signal the author has and it keeps its authored lines — glued `<a>⏎{expr}text⏎</a>` stays multiline, and prettier agrees ([elements/inline_multiline_nontext](../tests/fixtures/svelte/elements/inline_multiline_nontext/)). Two consequences are load-bearing. First, the run boundary is the *same* one the flow rule uses: a comment, a control-flow block, a block element or an authored blank line ends the run, and content holding one is structured rather than flowed — without that, a `<!-- … -->` and the text beneath it flatten onto one line and an authored blank line is deleted, content-preservation breaks rather than layout choices. Second, **every** reader of "did the author break this content?" must consult this one answer. The predicate suppresses a multiline signal, and a suppressed element lays its content out as one `fill` — which, once the content is wide, wraps a prose text ACROSS LINES and so writes the very newline the other readers key on. A reader left out reports the break on the next pass, the multiline arm then freezes the authored newlines as hardlines, and the two arrangements alternate forever: a real F1 break on real prose tables, which is why a narrower predicate gating only the boundary arm is not an option. — [inline_content_flow_collapse](../tests/fixtures/svelte/elements/inline_content_flow_collapse_prettier_divergence/) carries the whole class (element pair, table cell, component pair, expression-tag pair, a lone element with prose leading and trailing, and an element pair followed by prose). The holding side of the same answer — a one-word run (or two one-word texts in one run: the count is per node), whose interior whitespace-only newline is the author's structure and so EXPANDS the hugged element, boundaries and all, where the same newline in a run whose text carries two words is the fill's wrap point and collapses — is [inline_interior_newline_label_hold](../tests/fixtures/svelte/elements/inline_interior_newline_label_hold_prettier_divergence/); prettier keeps the hug and dangles the closing delimiter from the hugged authoring, its interior newline held but never selecting the layout. ⚠️ Only the whitespace-only arm holds it: the content-text arm's edge trim still collapses a one-word interior newline at a text node's edge (`<span>text1⏎<code>a</code></span>`), so the two spellings do not yet agree — open work, deliberately unpinned. That last case is what put the whitespace-ONLY arm on the shared answer: its newline lands in a whitespace-only separator node rather than inside a content text, so the run's prose and its break live in *different* nodes — the one shape the content-text arm cannot reach, and the last arm to be left out. The two interior arms are the predicate's only layout readers, for every container kind alike; the boundary arms honor their air without consulting it.
-**The rule has one boundary — the prose gate above — and the enclosing element's own multiline cause is not a second one.** The rule reaches this separator wherever the element is multiline at all, however it came to be, which is what keeps one run from reaching two answers: the flow rule is consulted at three sites, and the other two — a content text's leading and trailing runs — ask nothing about the cause, so a narrower gate here half-applies it. Inside an element made multiline by its own newlines the boundaries touching a text node then flow while the one between two adjacent siblings does not, and `text1 <span>a</span>⏎<span>b</span> text2` comes out broken in a line that fits — a form neither formatter produces, and a rule keyed on the container cannot be right at one of its boundaries and wrong at the next. A narrower gate would be defending against a period-2 cycle — collapsing the separator deleting the break that chose the multiline arm, so the next pass takes the inline arm, whose separator before a tag is a bare `line`, all-or-nothing with the already-broken parent group, and splits the run apart again. That cycle does not occur, for a structural reason rather than a lucky one: this separator is *interior* to the content, so collapsing it cannot touch the element's own boundary newlines, which are what the multiline decision reads. Both spellings converge, for element and tag siblings alike. ⚠️ `authoring_audit` guards only the **element** half of that: on the tag half it scores the two spellings as converging whichever form they land on (the note above), so it cannot see a regression back to the split form, and the fixture below is the only pin. A run laid out by **width** rather than by its own newlines reaches the same interior: the separator before a tag defers to the next sibling's per-width group exactly as it does in the multiline arm, so one prose run has one layout however its element became multiline. Keying it on the cause instead gives a width-broken element one tag per line while its newline-authored twin packs — two interior policies for one document, held apart only by a reflowable-fill suppression keeping the authored form out of the multiline arm entirely, and a two-pass cycle the moment authored air is honored there ([inline_boundary_air](../tests/fixtures/svelte/elements/inline_boundary_air/), where the kinds agree with each other and with prettier on the both-boundaries case; the ONE-boundary arity differs per kind and is pinned by [boundary_air_one_sided](../tests/fixtures/svelte/elements/boundary_air_one_sided_prettier_divergence/) — inline elements and components are both-or-neither, a block expands on its leading boundary alone — and which NODE the newline lands in, a whitespace-only separator in front of an element or the edge run inside a content text, is not part of the question). — [inline_content_spaced_tags_tail_long](../tests/fixtures/svelte/elements/inline_content_spaced_tags_tail_long_prettier_divergence/), whose overflowing `<small>` holds a spaced tag pair with a trailing text run (the shape that makes the run prose) — one case each for a tag lead and an element lead, plus the 100-char control that stays inline and an `unformatted_ours_one_per_line` variant carrying prettier's form, which tsv packs back in one pass. ⚠️ The widening costs a **tag** divergence prettier does not share: tsv converges an adjacent tag pair onto one line where prettier splits it even though the line fits. That is the same convergence this whole section spends everywhere else, and an element pair in the identical shape prettier already agrees on — the pair beside each other is the assertion. — [inline_adjacent_sibling_newline_flow](../tests/fixtures/svelte/elements/inline_adjacent_sibling_newline_flow_prettier_divergence/) (element pair, tag pair, the structural-cause control that isolates the axis, and a prose-free run that keeps its authored lines).
+**The rule has one boundary — the prose gate above — and the enclosing element's own multiline cause is not a second one.** The rule reaches this separator wherever the element is multiline at all, however it came to be, which is what keeps one run from reaching two answers: the flow rule is consulted at three sites, and the other two — a content text's leading and trailing runs — ask nothing about the cause, so a narrower gate here half-applies it. Inside an element made multiline by its own newlines the boundaries touching a text node then flow while the one between two adjacent siblings does not, and `text1 <span>a</span>⏎<span>b</span> text2` comes out broken in a line that fits — a form neither formatter produces, and a rule keyed on the container cannot be right at one of its boundaries and wrong at the next. A narrower gate would be defending against a period-2 cycle — collapsing the separator deleting the break that chose the multiline arm, so the next pass takes the inline arm and lays the run out by that arm's policy. That cycle does not occur, for two structural reasons rather than a lucky one: this separator is *interior* to the content, so collapsing it cannot touch the element's own boundary newlines, which are what the multiline decision reads; and the two arms build one doc for a space-spelled separator anyway — before a tag, a comment or a control-flow block, both defer to the follower's per-width group, so there is no second policy for a pass to fall into. Both spellings converge, for element and tag siblings alike. ⚠️ `authoring_audit` guards only the **element** half of that: on the tag half it scores the two spellings as converging whichever form they land on (the note above), so it cannot see a regression back to the split form, and the fixture below is the only pin. A run laid out by **width** rather than by its own newlines reaches the same interior: the separator before a tag defers to the next sibling's per-width group exactly as it does in the multiline arm, so one prose run has one layout however its element became multiline. Keying it on the cause instead gives a width-broken element one tag per line while its newline-authored twin packs — two interior policies for one document, held apart only by a reflowable-fill suppression keeping the authored form out of the multiline arm entirely, and a two-pass cycle the moment authored air is honored there ([inline_boundary_air](../tests/fixtures/svelte/elements/inline_boundary_air/), where the kinds agree with each other and with prettier on the both-boundaries case; the ONE-boundary arity differs per kind and is pinned by [boundary_air_one_sided](../tests/fixtures/svelte/elements/boundary_air_one_sided_prettier_divergence/) — inline elements and components are both-or-neither, a block expands on its leading boundary alone — and which NODE the newline lands in, a whitespace-only separator in front of an element or the edge run inside a content text, is not part of the question). — [inline_content_spaced_tags_tail_long](../tests/fixtures/svelte/elements/inline_content_spaced_tags_tail_long_prettier_divergence/), whose overflowing `<small>` holds a spaced tag pair with a trailing text run (the shape that makes the run prose) — one case each for a tag lead and an element lead, plus the 100-char control that stays inline and an `unformatted_ours_one_per_line` variant carrying prettier's form, which tsv packs back in one pass. ⚠️ The widening costs a **tag** divergence prettier does not share: tsv converges an adjacent tag pair onto one line where prettier splits it even though the line fits. That is the same convergence this whole section spends everywhere else, and an element pair in the identical shape prettier already agrees on — the pair beside each other is the assertion. — [inline_adjacent_sibling_newline_flow](../tests/fixtures/svelte/elements/inline_adjacent_sibling_newline_flow_prettier_divergence/) (element pair, tag pair, the structural-cause control that isolates the axis, and a prose-free run that keeps its authored lines).
**Two boundaries meeting on one element break outside-in.** A text run after an inline element meets a *second* boundary whenever that element also carries a leading one (the inline-sibling wrap — the collapsible boundary to the sibling before it). The two are independent decisions and tsv resolves the **leading** one first: once it breaks, the element starts a fresh line, and every later pass measures the trailing boundary from that fresh line. Measuring both inside one group instead answers the trailing question against the column *before* the leading break — a column the output no longer contains — so the document formats to one form and reformats to another, forever. Prettier keeps the leading boundary hugged and breaks only the trailing one; that holds a stable form per authoring but cannot converge them, because the other side of this shape is pinned — a comment's authored line is authorship ([§Comment Position Philosophy](./conformance_prettier.md#comment-position-philosophy)), so the own-line authoring is a fixed point the hugged form can never reach. The price is one more line in the shapes where the hugged form would have fit, and the purchase is the single fixed point. The trailing boundary still measures *together with* the element, because an element too wide to sit flat has to push its tail down and only the joint measurement sees that: detaching it to decide on its own column packs a tail after an element that wrapped its own attributes, which the next pass unpacks. — [inline_sibling_drop_tail_flow_long](../tests/fixtures/svelte/elements/inline_sibling_drop_tail_flow_long_prettier_divergence/), whose 100-char control keeps the element hugged on the sibling's line and whose 101-char case gives the element its own line and flows the tail onto the closing tag. **The leading boundary is not fused into that measurement**: a fusion would be conditioned on a property its own output destroys — the wrap exists only while the sibling and the element share a line, and breaking that line is the fused measurement's whole action, so the next parse sees no wrap and answers per width. Where the element stays intact the two answers agree by arithmetic (its closing tag sits at print width, so the tail does not fit after it either way), but a **block-styled** element puts `</tag>` back at the content indent, where the tail does fit, so a fused document formats to the dropped tail and reformats to the hugged one forever — [inline_sibling_drop_tail_wide_long](../tests/fixtures/svelte/elements/inline_sibling_drop_tail_wide_long_prettier_divergence/) pins that razor, one column past the flow fixture's. Nothing is given up: a comment's authored line is authorship, so the hugged and own-line spellings are **two** fixed points — which the flow fixture holds at its fitting width — and the two non-flowing siblings stay in step with the three flowing ones, which answer per width. What tsv converges is the **tail** spelling, which is where prettier differs alone (`prettier_variant_own_line`). No content kind is scoped out: a non-text-only kind regenerates the static trigger when width-broken (the regenerating-kinds note above), so its tail answers per width even inside the wrap — [inline_comment_wrap_fill_tail_long](../tests/fixtures/svelte/elements/inline_comment_wrap_fill_tail_long_prettier_divergence/), the fill-content twin, whose one-line authoring converges on the hugged form in one pass (the dropped-tail authoring is dual-stable). At fitting widths the convergence deliberately stops at the comment boundary — both spellings are comment authorship, so the control holds **two** fixed points, hug and own-line (the fixture's dual-stable `variant_control_own_line`), while a tail split mid-run repacks identically under both formatters (`unformatted_tail_split`): the divergence is confined to the boundary. The same shape meets a plain **text** sibling one step in — a word standing between two elements in a mid-run pack, where the leading boundary is ordinary inter-sibling whitespace and so carries no authorship: tsv converges the spaced and own-line authorings and lets the word, the element after it and that element's terminal tail reflow as one fill, while prettier holds the own-line authoring stable and isolates the word on a line of its own. — [inline_multi_element_pack_boundary_long](../tests/fixtures/svelte/elements/inline_multi_element_pack_boundary_long_prettier_divergence/), whose 100-column control packs the run to exactly print width and **agrees** with prettier, and whose 101-column case moves the word and folds element plus tail after it (`prettier_variant_own_line` pins prettier's second fixed point).
diff --git a/docs/conformance_svelte.md b/docs/conformance_svelte.md
index 90962da7e..1f6d8ecf5 100644
--- a/docs/conformance_svelte.md
+++ b/docs/conformance_svelte.md
@@ -1263,7 +1263,7 @@ Svelte deals with template whitespace at **compile time**, not parse time. The p
The **formatter** mirrors this: in inline layout tsv deletes exactly the render-free boundary runs `clean_nodes` deletes — a `_prettier_divergence`, cataloged in [conformance_prettier_svelte.md §Svelte: Inline content block-style](./conformance_prettier_svelte.md#svelte-inline-content-block-style) (elements) and [§Svelte: Blocks](./conformance_prettier_svelte.md#svelte-blocks) (block sections). tsv is deliberately more conservative than the compiler in one respect: comments **block** the trim (they are treated as nodes rather than removed first), so the formatted output renders identically under `preserveComments` too. `<svelte:options preserveWhitespace />` is not detected — any reformatting is already render-visible under it (prettier behaves the same).
-Where the formatter rewrites an **interior separator's spelling** it is answering to the *browser's* whitespace collapse rather than to `clean_nodes`, and the two do not agree everywhere. `clean_nodes` collapses only where neither neighbor is an `ExpressionTag`, so `{a}⇥{b}` reaches compiled output with its tab intact while `<code>a</code>⇥<code>b</code>` compiles to a single space; tsv (and prettier) print both as one space, which is render-identical under `white-space: normal` — the model `tsv_debug`'s `svelte-render-key` oracle and `render_normalize` both implement — and divergent under `pre`/`pre-wrap`. tsv already relies on that same browser model wherever a spaced tag pair goes block-style and each tag takes its own line.
+Where the formatter rewrites an **interior separator's spelling** it is answering to the *browser's* whitespace collapse rather than to `clean_nodes`, and the two do not agree everywhere. `clean_nodes` collapses only where neither neighbor is an `ExpressionTag`, so `{a}⇥{b}` reaches compiled output with its tab intact while `<code>a</code>⇥<code>b</code>` compiles to a single space; tsv (and prettier) print both as one space, which is render-identical under `white-space: normal` — the model `tsv_debug`'s `svelte-render-key` oracle and `render_normalize` both implement — and divergent under `pre`/`pre-wrap`. tsv already relies on that same browser model wherever a spaced tag pair packs on a block-style content line and breaks per width, respelling the space before the tag that would overflow as a newline.
The **character class** that decides all of this is `internal::is_collapsible_ws` = `[ \t\n\r]`, matching `clean_nodes`' `regex_not_whitespace` rather than Rust's `is_ascii_whitespace` or prettier-plugin-svelte's `[\t\n\f\r ]`, both of which are one character wider. A **form feed** (U+000C) is rendered content per CSS — white-space processing reaches only U+0020, U+0009 and segment breaks — so tsv preserves it verbatim in every position, where prettier respells it as a space. That is a `_prettier_divergence` no corpus diff against prettier can surface, since prettier shares the wider class: [conformance_prettier_svelte.md §Whitespace: Form feed](./conformance_prettier_svelte.md#whitespace-form-feed).
diff --git a/tests/fixtures/svelte/components/multi_expressions_multiline/unformatted_compact.svelte b/tests/fixtures/svelte/components/multi_expressions_multiline/unformatted_compact.svelte
index c144948c4..dbf13960c 100644
--- a/tests/fixtures/svelte/components/multi_expressions_multiline/unformatted_compact.svelte
+++ b/tests/fixtures/svelte/components/multi_expressions_multiline/unformatted_compact.svelte
@@ -1,3 +1,5 @@
<Comp>
-{expr1} {expr2} {expr3}
+{expr1}
+{expr2}
+{expr3}
</Comp>
diff --git a/tests/fixtures/svelte/components/multi_expressions_multiline/unformatted_spaces.svelte b/tests/fixtures/svelte/components/multi_expressions_multiline/unformatted_spaces.svelte
index 46d4d74ee..1d9068f57 100644
--- a/tests/fixtures/svelte/components/multi_expressions_multiline/unformatted_spaces.svelte
+++ b/tests/fixtures/svelte/components/multi_expressions_multiline/unformatted_spaces.svelte
@@ -1,3 +1,5 @@
<Comp>
- { expr1 } { expr2 } { expr3 }
+ { expr1 }
+ { expr2 }
+ { expr3 }
</Comp>
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space/expected.json b/tests/fixtures/svelte/elements/inline_adjacent_comment_space/expected.json
index 01664ded3..0ae2609c0 100644
--- a/tests/fixtures/svelte/elements/inline_adjacent_comment_space/expected.json
+++ b/tests/fixtures/svelte/elements/inline_adjacent_comment_space/expected.json
@@ -2,7 +2,7 @@
"css": null,
"js": [],
"start": 0,
- "end": 1201,
+ "end": 1264,
"type": "Root",
"fragment": {
"type": "Fragment",
@@ -418,31 +418,31 @@
{
"type": "Comment",
"start": 971,
- "end": 1129,
- "data": "\n\tcontrol: multiline STRUCTURALLY (a block child), where the separator becomes a break rather\n\tthan a space — the same boundary, held by the other arm\n"
+ "end": 1192,
+ "data": "\n\tcontrol: multiline STRUCTURALLY (a block child), authored with a NEWLINE before the comment,\n\twhich is held — the space spelling stays a space in a multiline container too\n\t(inline_sibling_space_before_bounding)\n"
},
{
"type": "Text",
- "start": 1129,
- "end": 1130,
+ "start": 1192,
+ "end": 1193,
"raw": "\n",
"data": "\n"
},
{
"type": "RegularElement",
- "start": 1130,
- "end": 1200,
+ "start": 1193,
+ "end": 1263,
"name": "div",
"name_loc": {
"start": {
- "line": 26,
+ "line": 27,
"column": 1,
- "character": 1131
+ "character": 1194
},
"end": {
- "line": 26,
+ "line": 27,
"column": 4,
- "character": 1134
+ "character": 1197
}
},
"attributes": [],
@@ -451,26 +451,26 @@
"nodes": [
{
"type": "Text",
- "start": 1135,
- "end": 1143,
+ "start": 1198,
+ "end": 1206,
"raw": "\n\ttext1 ",
"data": "\n\ttext1 "
},
{
"type": "RegularElement",
- "start": 1143,
- "end": 1157,
+ "start": 1206,
+ "end": 1220,
"name": "span",
"name_loc": {
"start": {
- "line": 27,
+ "line": 28,
"column": 8,
- "character": 1144
+ "character": 1207
},
"end": {
- "line": 27,
+ "line": 28,
"column": 12,
- "character": 1148
+ "character": 1211
}
},
"attributes": [],
@@ -479,8 +479,8 @@
"nodes": [
{
"type": "Text",
- "start": 1149,
- "end": 1150,
+ "start": 1212,
+ "end": 1213,
"raw": "x",
"data": "x"
}
@@ -489,39 +489,39 @@
},
{
"type": "Text",
- "start": 1157,
- "end": 1159,
+ "start": 1220,
+ "end": 1222,
"raw": "\n\t",
"data": "\n\t"
},
{
"type": "Comment",
- "start": 1159,
- "end": 1169,
+ "start": 1222,
+ "end": 1232,
"data": " c "
},
{
"type": "Text",
- "start": 1169,
- "end": 1176,
+ "start": 1232,
+ "end": 1239,
"raw": "text2\n\t",
"data": "text2\n\t"
},
{
"type": "RegularElement",
- "start": 1176,
- "end": 1193,
+ "start": 1239,
+ "end": 1256,
"name": "div",
"name_loc": {
"start": {
- "line": 29,
+ "line": 30,
"column": 2,
- "character": 1177
+ "character": 1240
},
"end": {
- "line": 29,
+ "line": 30,
"column": 5,
- "character": 1180
+ "character": 1243
}
},
"attributes": [],
@@ -530,8 +530,8 @@
"nodes": [
{
"type": "Text",
- "start": 1181,
- "end": 1187,
+ "start": 1244,
+ "end": 1250,
"raw": "block1",
"data": "block1"
}
@@ -540,8 +540,8 @@
},
{
"type": "Text",
- "start": 1193,
- "end": 1194,
+ "start": 1256,
+ "end": 1257,
"raw": "\n",
"data": "\n"
}
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space/input.svelte b/tests/fixtures/svelte/elements/inline_adjacent_comment_space/input.svelte
index 7225ba229..193b3d19b 100644
--- a/tests/fixtures/svelte/elements/inline_adjacent_comment_space/input.svelte
+++ b/tests/fixtures/svelte/elements/inline_adjacent_comment_space/input.svelte
@@ -20,8 +20,9 @@
<p>text1 <span>x</span><!-- c -->text2</p>
<!--
- control: multiline STRUCTURALLY (a block child), where the separator becomes a break rather
- than a space — the same boundary, held by the other arm
+ control: multiline STRUCTURALLY (a block child), authored with a NEWLINE before the comment,
+ which is held — the space spelling stays a space in a multiline container too
+ (inline_sibling_space_before_bounding)
-->
<div>
text1 <span>x</span>
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long/input.svelte b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long/input.svelte
deleted file mode 100644
index 47bf55e6f..000000000
--- a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long/input.svelte
+++ /dev/null
@@ -1,22 +0,0 @@
-<!--
- The deferred separator in front of a run-ending sibling is a BARE collapsible break, resolved
- by the container's own group: a space while the whole element fits, a newline the moment it
- does not. The 101-char cases are the discriminator — their content line is only 97 wide, so a
- separator measured on its OWN width would keep the sibling on it, and the next pass, reading
- that break back, would move it anyway.
--->
-
-<!-- exactly 100 chars — inline, and the separator is the rendered space -->
-<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> <!-- c -->text2</p>
-
-<!-- 101 chars — the element breaks, and the separator breaks with it -->
-<p>
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp />
- <!-- c -->text2
-</p>
-
-<!-- the `{@debug}` follower is the same run-ending kind, at the same boundary -->
-<p>
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp />
- {@debug a}text2
-</p>
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long/unformatted_inline.svelte b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long/unformatted_inline.svelte
deleted file mode 100644
index 3c3ccf5c9..000000000
--- a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long/unformatted_inline.svelte
+++ /dev/null
@@ -1,16 +0,0 @@
-<!--
- The deferred separator in front of a run-ending sibling is a BARE collapsible break, resolved
- by the container's own group: a space while the whole element fits, a newline the moment it
- does not. The 101-char cases are the discriminator — their content line is only 97 wide, so a
- separator measured on its OWN width would keep the sibling on it, and the next pass, reading
- that break back, would move it anyway.
--->
-
-<!-- exactly 100 chars — inline, and the separator is the rendered space -->
-<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> <!-- c -->text2</p>
-
-<!-- 101 chars — the element breaks, and the separator breaks with it -->
-<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> <!-- c -->text2</p>
-
-<!-- the `{@debug}` follower is the same run-ending kind, at the same boundary -->
-<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> {@debug a}text2</p>
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/README.md
new file mode 100644
index 000000000..25785a3c6
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/README.md
@@ -0,0 +1,29 @@
+# inline_adjacent_comment_space_long_prettier_divergence
+
+A space-separated run-ending follower — a comment, a `{@debug}` — after a component, at the
+print-width boundary of the **element**. At exactly 100 chars everything stays inline and the
+separator is the rendered space (both formatters). At 101 the `<p>` overflows and goes
+block-style; its content line is then only 97 wide, and the follower keeps its authored space on
+it (`<Comp /> <!-- c -->text2`). Prettier's `line` before a comment breaks with the container
+instead (`output_prettier.svelte`).
+
+`unformatted_ours_inline.svelte` is the one-line authoring of every case: tsv lays the 101-char
+elements out block-style and normalizes to `input.svelte` in one pass.
+
+`variant_split.svelte` is prettier's form itself, and tsv keeps it stable too — the newline spelling of
+every boundary is held — so the two forms are two fixed points; a rule change that started
+normalizing prettier's form back to `input.svelte` fails this file rather than passing in prose.
+
+## Reason
+
+Design choice — the rule of
+[inline_sibling_space_before_bounding](../inline_sibling_space_before_bounding_prettier_divergence/)
+(which carries the follower's own 100/101 boundary), met here by the element's block-style
+conversion: a space before a comment or a `{@debug}` is that follower's own per-width wrap after
+any sibling, as it already is after text, and the container's break is no reason to turn it into
+a newline. This fixture used to pin the opposite — a bare break resolved by the container —
+because the inline and multiline arms then disagreed on this separator and the wrap was a
+two-pass cycle; with both arms on the wrap, the hazard is gone.
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long/expected.json b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/expected.json
similarity index 67%
rename from tests/fixtures/svelte/elements/inline_adjacent_comment_space_long/expected.json
rename to tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/expected.json
index bd8afcc93..8b0d36489 100644
--- a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long/expected.json
+++ b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/expected.json
@@ -2,7 +2,7 @@
"css": null,
"js": [],
"start": 0,
- "end": 976,
+ "end": 993,
"type": "Root",
"fragment": {
"type": "Fragment",
@@ -10,44 +10,44 @@
{
"type": "Comment",
"start": 0,
- "end": 425,
- "data": "\n\tThe deferred separator in front of a run-ending sibling is a BARE collapsible break, resolved\n\tby the container's own group: a space while the whole element fits, a newline the moment it\n\tdoes not. The 101-char cases are the discriminator — their content line is only 97 wide, so a\n\tseparator measured on its OWN width would keep the sibling on it, and the next pass, reading\n\tthat break back, would move it anyway.\n"
+ "end": 412,
+ "data": "\n\tThe deferred separator in front of a run-ending sibling — a comment, a {@debug} — is that\n\tfollower's own per-width wrap, exactly as before an element: when the element overflows and\n\tgoes block-style, the content line is only 97 wide, so the follower stays on it. Prettier\n\tbreaks that space with the container instead. The width boundary of the hug itself is in\n\tinline_sibling_space_before_bounding.\n"
},
{
"type": "Text",
- "start": 425,
- "end": 427,
+ "start": 412,
+ "end": 414,
"raw": "\n\n",
"data": "\n\n"
},
{
"type": "Comment",
- "start": 427,
- "end": 503,
+ "start": 414,
+ "end": 490,
"data": " exactly 100 chars — inline, and the separator is the rendered space "
},
{
"type": "Text",
- "start": 503,
- "end": 504,
+ "start": 490,
+ "end": 491,
"raw": "\n",
"data": "\n"
},
{
"type": "RegularElement",
- "start": 504,
- "end": 604,
+ "start": 491,
+ "end": 591,
"name": "p",
"name_loc": {
"start": {
"line": 10,
"column": 1,
- "character": 505
+ "character": 492
},
"end": {
"line": 10,
"column": 2,
- "character": 506
+ "character": 493
}
},
"attributes": [],
@@ -56,26 +56,26 @@
"nodes": [
{
"type": "Text",
- "start": 507,
- "end": 576,
+ "start": 494,
+ "end": 563,
"raw": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 ",
"data": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 "
},
{
"type": "Component",
- "start": 576,
- "end": 584,
+ "start": 563,
+ "end": 571,
"name": "Comp",
"name_loc": {
"start": {
"line": 10,
"column": 73,
- "character": 577
+ "character": 564
},
"end": {
"line": 10,
"column": 77,
- "character": 581
+ "character": 568
}
},
"attributes": [],
@@ -86,21 +86,21 @@
},
{
"type": "Text",
- "start": 584,
- "end": 585,
+ "start": 571,
+ "end": 572,
"raw": " ",
"data": " "
},
{
"type": "Comment",
- "start": 585,
- "end": 595,
+ "start": 572,
+ "end": 582,
"data": " c "
},
{
"type": "Text",
- "start": 595,
- "end": 600,
+ "start": 582,
+ "end": 587,
"raw": "text2",
"data": "text2"
}
@@ -109,39 +109,39 @@
},
{
"type": "Text",
- "start": 604,
- "end": 606,
+ "start": 591,
+ "end": 593,
"raw": "\n\n",
"data": "\n\n"
},
{
"type": "Comment",
- "start": 606,
- "end": 679,
- "data": " 101 chars — the element breaks, and the separator breaks with it "
+ "start": 593,
+ "end": 698,
+ "data": " 101 chars — the element breaks block-style, and the follower keeps its space on the content line "
},
{
"type": "Text",
- "start": 679,
- "end": 680,
+ "start": 698,
+ "end": 699,
"raw": "\n",
"data": "\n"
},
{
"type": "RegularElement",
- "start": 680,
- "end": 785,
+ "start": 699,
+ "end": 803,
"name": "p",
"name_loc": {
"start": {
"line": 13,
"column": 1,
- "character": 681
+ "character": 700
},
"end": {
"line": 13,
"column": 2,
- "character": 682
+ "character": 701
}
},
"attributes": [],
@@ -150,26 +150,26 @@
"nodes": [
{
"type": "Text",
- "start": 683,
- "end": 755,
+ "start": 702,
+ "end": 774,
"raw": "\n\taaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 ",
"data": "\n\taaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 "
},
{
"type": "Component",
- "start": 755,
- "end": 763,
+ "start": 774,
+ "end": 782,
"name": "Comp",
"name_loc": {
"start": {
"line": 14,
"column": 72,
- "character": 756
+ "character": 775
},
"end": {
"line": 14,
"column": 76,
- "character": 760
+ "character": 779
}
},
"attributes": [],
@@ -180,21 +180,21 @@
},
{
"type": "Text",
- "start": 763,
- "end": 765,
- "raw": "\n\t",
- "data": "\n\t"
+ "start": 782,
+ "end": 783,
+ "raw": " ",
+ "data": " "
},
{
"type": "Comment",
- "start": 765,
- "end": 775,
+ "start": 783,
+ "end": 793,
"data": " c "
},
{
"type": "Text",
- "start": 775,
- "end": 781,
+ "start": 793,
+ "end": 799,
"raw": "text2\n",
"data": "text2\n"
}
@@ -203,39 +203,39 @@
},
{
"type": "Text",
- "start": 785,
- "end": 787,
+ "start": 803,
+ "end": 805,
"raw": "\n\n",
"data": "\n\n"
},
{
"type": "Comment",
- "start": 787,
- "end": 869,
+ "start": 805,
+ "end": 887,
"data": " the `{@debug}` follower is the same run-ending kind, at the same boundary "
},
{
"type": "Text",
- "start": 869,
- "end": 870,
+ "start": 887,
+ "end": 888,
"raw": "\n",
"data": "\n"
},
{
"type": "RegularElement",
- "start": 870,
- "end": 975,
+ "start": 888,
+ "end": 992,
"name": "p",
"name_loc": {
"start": {
- "line": 19,
+ "line": 18,
"column": 1,
- "character": 871
+ "character": 889
},
"end": {
- "line": 19,
+ "line": 18,
"column": 2,
- "character": 872
+ "character": 890
}
},
"attributes": [],
@@ -244,26 +244,26 @@
"nodes": [
{
"type": "Text",
- "start": 873,
- "end": 945,
+ "start": 891,
+ "end": 963,
"raw": "\n\taaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 ",
"data": "\n\taaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 "
},
{
"type": "Component",
- "start": 945,
- "end": 953,
+ "start": 963,
+ "end": 971,
"name": "Comp",
"name_loc": {
"start": {
- "line": 20,
+ "line": 19,
"column": 72,
- "character": 946
+ "character": 964
},
"end": {
- "line": 20,
+ "line": 19,
"column": 76,
- "character": 950
+ "character": 968
}
},
"attributes": [],
@@ -274,28 +274,28 @@
},
{
"type": "Text",
- "start": 953,
- "end": 955,
- "raw": "\n\t",
- "data": "\n\t"
+ "start": 971,
+ "end": 972,
+ "raw": " ",
+ "data": " "
},
{
"type": "DebugTag",
- "start": 955,
- "end": 965,
+ "start": 972,
+ "end": 982,
"identifiers": [
{
"type": "Identifier",
- "start": 963,
- "end": 964,
+ "start": 980,
+ "end": 981,
"loc": {
"start": {
- "line": 21,
- "column": 9
+ "line": 19,
+ "column": 88
},
"end": {
- "line": 21,
- "column": 10
+ "line": 19,
+ "column": 89
}
},
"name": "a"
@@ -304,8 +304,8 @@
},
{
"type": "Text",
- "start": 965,
- "end": 971,
+ "start": 982,
+ "end": 988,
"raw": "text2\n",
"data": "text2\n"
}
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/input.svelte
new file mode 100644
index 000000000..99253e065
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/input.svelte
@@ -0,0 +1,20 @@
+<!--
+ The deferred separator in front of a run-ending sibling — a comment, a {@debug} — is that
+ follower's own per-width wrap, exactly as before an element: when the element overflows and
+ goes block-style, the content line is only 97 wide, so the follower stays on it. Prettier
+ breaks that space with the container instead. The width boundary of the hug itself is in
+ inline_sibling_space_before_bounding.
+-->
+
+<!-- exactly 100 chars — inline, and the separator is the rendered space -->
+<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> <!-- c -->text2</p>
+
+<!-- 101 chars — the element breaks block-style, and the follower keeps its space on the content line -->
+<p>
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> <!-- c -->text2
+</p>
+
+<!-- the `{@debug}` follower is the same run-ending kind, at the same boundary -->
+<p>
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> {@debug a}text2
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..66bcdda17
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,22 @@
+<!--
+ The deferred separator in front of a run-ending sibling — a comment, a {@debug} — is that
+ follower's own per-width wrap, exactly as before an element: when the element overflows and
+ goes block-style, the content line is only 97 wide, so the follower stays on it. Prettier
+ breaks that space with the container instead. The width boundary of the hug itself is in
+ inline_sibling_space_before_bounding.
+-->
+
+<!-- exactly 100 chars — inline, and the separator is the rendered space -->
+<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> <!-- c -->text2</p>
+
+<!-- 101 chars — the element breaks block-style, and the follower keeps its space on the content line -->
+<p>
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp />
+ <!-- c -->text2
+</p>
+
+<!-- the `{@debug}` follower is the same run-ending kind, at the same boundary -->
+<p>
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp />
+ {@debug a}text2
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/unformatted_ours_inline.svelte b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/unformatted_ours_inline.svelte
new file mode 100644
index 000000000..7822a2b21
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/unformatted_ours_inline.svelte
@@ -0,0 +1,16 @@
+<!--
+ The deferred separator in front of a run-ending sibling — a comment, a {@debug} — is that
+ follower's own per-width wrap, exactly as before an element: when the element overflows and
+ goes block-style, the content line is only 97 wide, so the follower stays on it. Prettier
+ breaks that space with the container instead. The width boundary of the hug itself is in
+ inline_sibling_space_before_bounding.
+-->
+
+<!-- exactly 100 chars — inline, and the separator is the rendered space -->
+<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> <!-- c -->text2</p>
+
+<!-- 101 chars — the element breaks block-style, and the follower keeps its space on the content line -->
+<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> <!-- c -->text2</p>
+
+<!-- the `{@debug}` follower is the same run-ending kind, at the same boundary -->
+<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> {@debug a}text2</p>
diff --git a/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/variant_split.svelte b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/variant_split.svelte
new file mode 100644
index 000000000..66bcdda17
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/variant_split.svelte
@@ -0,0 +1,22 @@
+<!--
+ The deferred separator in front of a run-ending sibling — a comment, a {@debug} — is that
+ follower's own per-width wrap, exactly as before an element: when the element overflows and
+ goes block-style, the content line is only 97 wide, so the follower stays on it. Prettier
+ breaks that space with the container instead. The width boundary of the hug itself is in
+ inline_sibling_space_before_bounding.
+-->
+
+<!-- exactly 100 chars — inline, and the separator is the rendered space -->
+<p>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp /> <!-- c -->text2</p>
+
+<!-- 101 chars — the element breaks block-style, and the follower keeps its space on the content line -->
+<p>
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp />
+ <!-- c -->text2
+</p>
+
+<!-- the `{@debug}` follower is the same run-ending kind, at the same boundary -->
+<p>
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa text1 <Comp />
+ {@debug a}text2
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/README.md
index 12632e510..b3c7b7492 100644
--- a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/README.md
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/README.md
@@ -1,29 +1,36 @@
# inline_content_spaced_tags_long_prettier_divergence
-An inline element (`<small>`) whose content is two **space-separated expression
-tags** (`{a} {b}`) and overflows print width.
+An inline element (`<small>`) whose content is two **space-separated expression tags**
+(`{a} {b}`) and overflows print width.
-**tsv** lays the element out **block-style** — both tags intact, content on its own
-indented line — and once the element is multiline each expression tag takes its own
-line. The separating whitespace is a collapsible break: a space while the element
-fits on one line, a newline once it breaks. Content that fits stays inline (the
-100-char case). Text between the tags (the third case) flows as one fill, so the
-tags share the content line.
+**tsv** lays the element out **block-style** — both tags intact, content on its own indented
+line — and the tags **pack on that content line**: the separating whitespace is a fill boundary
+that breaks per width, never with the container. Content that fits stays inline (the 100-char
+case). Text between the tags (the third case) flows as one fill the same way.
-**Prettier** keeps the tags split the same way once the element is multiline, but on
-a compact single-line authoring it instead **dangles** the closing delimiter
-(`<small>{a} {b}</small⏎>`) and lets the content run past printWidth — see
-`prettier_variant_compact`.
+**Prettier** puts each tag on its own line once the element is multiline — its `line` between
+two tags breaks with the container (`output_prettier.svelte`) — and on a compact single-line
+authoring instead **dangles** the closing delimiter (`<small>{a} {b}</small⏎>`) and lets the
+content run past printWidth (`prettier_variant_compact`).
-The layout is driven by width, never by the authored boundary whitespace: the
-compact authoring (`unformatted_ours_compact`) and prettier's dangle
-(`prettier_variant_compact`) both normalize to `input.svelte` under tsv in one pass,
-so the block-style form tsv emits is its own fixed point.
+The layout is driven by width, never by the authored boundary whitespace: the compact authoring
+(`unformatted_ours_compact`) and prettier's dangle (`prettier_variant_compact`) both normalize to
+`input.svelte` under tsv in one pass, so the block-style form tsv emits is its own fixed point.
+
+`variant_split.svelte` is prettier's form itself, and tsv keeps it stable too — the newline spelling of
+every boundary is held — so the two forms are two fixed points; a rule change that started
+normalizing prettier's form back to `input.svelte` fails this file rather than passing in prose.
## Reason
-tsv treats printWidth as a hard limit and prefers block-style content over a dangled,
-over-width line. Content-boundary whitespace is render-free under Svelte 5, so its spelling
-must not select the tags' layout — and the block-style form tsv emits is its own fixed point,
-since the emitted boundary air re-selects the multiline form on the next parse. See
+tsv treats printWidth as a hard limit and prefers block-style content over a dangled, over-width
+line. Content-boundary whitespace is render-free under Svelte 5, so its spelling must not select
+the tags' layout — and the block-style form tsv emits is its own fixed point, since the emitted
+boundary air re-selects the multiline form on the next parse. The separator between the tags is
+the fill boundary of
+[inline_tag_pair_space](../inline_tag_pair_space_prettier_divergence/): it packs per width
+whatever the run holds and is never forced open by the container; where the packed line itself
+reaches print width is
+[inline_content_spaced_tags_pack_long](../inline_content_spaced_tags_pack_long_prettier_divergence/).
+See
[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/expected.json
index 0fe50f616..e88e74c36 100644
--- a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/expected.json
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/expected.json
@@ -2,7 +2,7 @@
"css": null,
"js": [],
"start": 0,
- "end": 579,
+ "end": 572,
"type": "Root",
"fragment": {
"type": "Fragment",
@@ -141,31 +141,31 @@
{
"type": "Comment",
"start": 154,
- "end": 241,
- "data": " 101 chars - overflows; block-style, and each expression tag takes its own line "
+ "end": 236,
+ "data": " 101 chars - overflows; block-style, and the tags pack on the content line "
},
{
"type": "Text",
- "start": 241,
- "end": 242,
+ "start": 236,
+ "end": 237,
"raw": "\n",
"data": "\n"
},
{
"type": "RegularElement",
- "start": 242,
- "end": 362,
+ "start": 237,
+ "end": 355,
"name": "div",
"name_loc": {
"start": {
"line": 7,
"column": 1,
- "character": 243
+ "character": 238
},
"end": {
"line": 7,
"column": 4,
- "character": 246
+ "character": 241
}
},
"attributes": [],
@@ -174,26 +174,26 @@
"nodes": [
{
"type": "Text",
- "start": 247,
- "end": 249,
+ "start": 242,
+ "end": 244,
"raw": "\n\t",
"data": "\n\t"
},
{
"type": "RegularElement",
- "start": 249,
- "end": 355,
+ "start": 244,
+ "end": 348,
"name": "small",
"name_loc": {
"start": {
"line": 8,
"column": 2,
- "character": 250
+ "character": 245
},
"end": {
"line": 8,
"column": 7,
- "character": 255
+ "character": 250
}
},
"attributes": [],
@@ -202,19 +202,19 @@
"nodes": [
{
"type": "Text",
- "start": 256,
- "end": 259,
+ "start": 251,
+ "end": 254,
"raw": "\n\t\t",
"data": "\n\t\t"
},
{
"type": "ExpressionTag",
- "start": 259,
- "end": 262,
+ "start": 254,
+ "end": 257,
"expression": {
"type": "Identifier",
- "start": 260,
- "end": 261,
+ "start": 255,
+ "end": 256,
"loc": {
"start": {
"line": 9,
@@ -230,27 +230,27 @@
},
{
"type": "Text",
- "start": 262,
- "end": 265,
- "raw": "\n\t\t",
- "data": "\n\t\t"
+ "start": 257,
+ "end": 258,
+ "raw": " ",
+ "data": " "
},
{
"type": "ExpressionTag",
- "start": 265,
- "end": 345,
+ "start": 258,
+ "end": 338,
"expression": {
"type": "Identifier",
- "start": 266,
- "end": 344,
+ "start": 259,
+ "end": 337,
"loc": {
"start": {
- "line": 10,
- "column": 3
+ "line": 9,
+ "column": 7
},
"end": {
- "line": 10,
- "column": 81
+ "line": 9,
+ "column": 85
}
},
"name": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
@@ -258,8 +258,8 @@
},
{
"type": "Text",
- "start": 345,
- "end": 347,
+ "start": 338,
+ "end": 340,
"raw": "\n\t",
"data": "\n\t"
}
@@ -268,8 +268,8 @@
},
{
"type": "Text",
- "start": 355,
- "end": 356,
+ "start": 348,
+ "end": 349,
"raw": "\n",
"data": "\n"
}
@@ -278,39 +278,39 @@
},
{
"type": "Text",
- "start": 362,
- "end": 364,
+ "start": 355,
+ "end": 357,
"raw": "\n\n",
"data": "\n\n"
},
{
"type": "Comment",
- "start": 364,
- "end": 459,
+ "start": 357,
+ "end": 452,
"data": " 101 chars, text between the tags - the content flows as one fill, so they share a line "
},
{
"type": "Text",
- "start": 459,
- "end": 460,
+ "start": 452,
+ "end": 453,
"raw": "\n",
"data": "\n"
},
{
"type": "RegularElement",
- "start": 460,
- "end": 578,
+ "start": 453,
+ "end": 571,
"name": "div",
"name_loc": {
"start": {
- "line": 15,
+ "line": 14,
"column": 1,
- "character": 461
+ "character": 454
},
"end": {
- "line": 15,
+ "line": 14,
"column": 4,
- "character": 464
+ "character": 457
}
},
"attributes": [],
@@ -319,26 +319,26 @@
"nodes": [
{
"type": "Text",
- "start": 465,
- "end": 467,
+ "start": 458,
+ "end": 460,
"raw": "\n\t",
"data": "\n\t"
},
{
"type": "RegularElement",
- "start": 467,
- "end": 571,
+ "start": 460,
+ "end": 564,
"name": "small",
"name_loc": {
"start": {
- "line": 16,
+ "line": 15,
"column": 2,
- "character": 468
+ "character": 461
},
"end": {
- "line": 16,
+ "line": 15,
"column": 7,
- "character": 473
+ "character": 466
}
},
"attributes": [],
@@ -347,26 +347,26 @@
"nodes": [
{
"type": "Text",
- "start": 474,
- "end": 477,
+ "start": 467,
+ "end": 470,
"raw": "\n\t\t",
"data": "\n\t\t"
},
{
"type": "ExpressionTag",
- "start": 477,
- "end": 480,
+ "start": 470,
+ "end": 473,
"expression": {
"type": "Identifier",
- "start": 478,
- "end": 479,
+ "start": 471,
+ "end": 472,
"loc": {
"start": {
- "line": 17,
+ "line": 16,
"column": 3
},
"end": {
- "line": 17,
+ "line": 16,
"column": 4
}
},
@@ -375,26 +375,26 @@
},
{
"type": "Text",
- "start": 480,
- "end": 485,
+ "start": 473,
+ "end": 478,
"raw": " and ",
"data": " and "
},
{
"type": "ExpressionTag",
- "start": 485,
- "end": 561,
+ "start": 478,
+ "end": 554,
"expression": {
"type": "Identifier",
- "start": 486,
- "end": 560,
+ "start": 479,
+ "end": 553,
"loc": {
"start": {
- "line": 17,
+ "line": 16,
"column": 11
},
"end": {
- "line": 17,
+ "line": 16,
"column": 85
}
},
@@ -403,8 +403,8 @@
},
{
"type": "Text",
- "start": 561,
- "end": 563,
+ "start": 554,
+ "end": 556,
"raw": "\n\t",
"data": "\n\t"
}
@@ -413,8 +413,8 @@
},
{
"type": "Text",
- "start": 571,
- "end": 572,
+ "start": 564,
+ "end": 565,
"raw": "\n",
"data": "\n"
}
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/input.svelte
index f53a07160..35c14025e 100644
--- a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/input.svelte
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/input.svelte
@@ -3,11 +3,10 @@
<small>{a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}</small>
</div>
-<!-- 101 chars - overflows; block-style, and each expression tag takes its own line -->
+<!-- 101 chars - overflows; block-style, and the tags pack on the content line -->
<div>
<small>
- {a}
- {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+ {a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
</small>
</div>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/unformatted_shared_line.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/output_prettier.svelte
similarity index 69%
rename from tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/unformatted_shared_line.svelte
rename to tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/output_prettier.svelte
index 46ddaab07..5c18e75e7 100644
--- a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/unformatted_shared_line.svelte
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/output_prettier.svelte
@@ -3,10 +3,11 @@
<small>{a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}</small>
</div>
-<!-- 101 chars - overflows; block-style, and each expression tag takes its own line -->
+<!-- 101 chars - overflows; block-style, and the tags pack on the content line -->
<div>
<small>
- {a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+ {a}
+ {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
</small>
</div>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/prettier_variant_compact.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/prettier_variant_compact.svelte
index c12c85af2..7836e08e1 100644
--- a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/prettier_variant_compact.svelte
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/prettier_variant_compact.svelte
@@ -3,7 +3,7 @@
<small>{a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}</small>
</div>
-<!-- 101 chars - overflows; block-style, and each expression tag takes its own line -->
+<!-- 101 chars - overflows; block-style, and the tags pack on the content line -->
<div>
<small>{a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}</small
>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/unformatted_ours_compact.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/unformatted_ours_compact.svelte
index 02e948cc7..646214a9d 100644
--- a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/unformatted_ours_compact.svelte
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/unformatted_ours_compact.svelte
@@ -3,7 +3,7 @@
<small>{a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}</small>
</div>
-<!-- 101 chars - overflows; block-style, and each expression tag takes its own line -->
+<!-- 101 chars - overflows; block-style, and the tags pack on the content line -->
<div>
<small>{a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}</small>
</div>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/variant_split.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/variant_split.svelte
new file mode 100644
index 000000000..5c18e75e7
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_long_prettier_divergence/variant_split.svelte
@@ -0,0 +1,19 @@
+<!-- 100 chars - fits, stays inline -->
+<div>
+ <small>{a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}</small>
+</div>
+
+<!-- 101 chars - overflows; block-style, and the tags pack on the content line -->
+<div>
+ <small>
+ {a}
+ {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+ </small>
+</div>
+
+<!-- 101 chars, text between the tags - the content flows as one fill, so they share a line -->
+<div>
+ <small>
+ {a} and {cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}
+ </small>
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/README.md
new file mode 100644
index 000000000..b58c7c31b
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/README.md
@@ -0,0 +1,30 @@
+# inline_content_spaced_tags_pack_long_prettier_divergence
+
+Space-separated expression tags **pack per width** on their content line. The separator between
+two tags is a fill boundary: a space while the next tag fits, a break only before the tag that
+would cross print width — a pair at exactly 100 chars packs and at 101 breaks before the second
+tag, and a three-tag run in a block-styled `<small>` packs all three at 100 and keeps the first
+two packed at 101, breaking only before the third. One tag per line is never the answer to width.
+
+**Prettier** breaks its `line` between two tags with the container, so once the container is
+multiline every tag takes its own line (`output_prettier.svelte`); on a compact authoring it
+pre-breaks the opening tag and dangles the closing one instead.
+
+`unformatted_ours_compact.svelte` is the hugged authoring of every case: tsv lays the container
+out block-style and packs the run to `input.svelte` in one pass.
+
+`variant_split.svelte` is prettier's form itself, and tsv keeps it stable too — the newline spelling of
+every boundary is held — so the two forms are two fixed points; a rule change that started
+normalizing prettier's form back to `input.svelte` fails this file rather than passing in prose.
+
+## Reason
+
+Design choice — the print-width boundary of
+[inline_tag_pair_space](../inline_tag_pair_space_prettier_divergence/): the whitespace-only
+separator before a tag defers to the tag's per-width `group([line, tag])`, so the run reflows
+exactly as a fill of words does, whatever the run holds. The element-boundary side of the same
+shape — block-style where prettier dangles — is
+[inline_content_spaced_tags_long](../inline_content_spaced_tags_long_prettier_divergence/). See
+[conformance_prettier.md §Print Width Philosophy](../../../../../docs/conformance_prettier.md#print-width-philosophy)
+and
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/divergent_variant_compact.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/divergent_variant_compact.svelte
new file mode 100644
index 000000000..4e214fda3
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/divergent_variant_compact.svelte
@@ -0,0 +1,36 @@
+<!--
+ Space-separated tags pack per width on their content line: the separator between two tags is
+ a fill boundary that breaks only before the tag that would cross print width, never with the
+ container — one tag per line is never the answer to width.
+-->
+
+<!-- a pair whose content line is exactly 100 chars - packs -->
+<p>
+ {a}
+ {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+</p>
+
+<!-- a pair whose content line would be 101 chars - breaks before the second tag -->
+<p>
+ {a}
+ {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+</p>
+
+<!-- three tags in an inline element, the content line exactly 100 chars - all three pack -->
+<div>
+ <small
+ >{a}
+ {b}
+ {cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}</small
+ >
+</div>
+
+<!-- three tags, the content line would be 101 chars - the run breaks before the tag that
+ overflows, and the first two stay packed -->
+<div>
+ <small
+ >{a}
+ {b}
+ {ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}</small
+ >
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/expected.json
new file mode 100644
index 000000000..a8bb0c214
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/expected.json
@@ -0,0 +1,580 @@
+{
+ "css": null,
+ "js": [],
+ "start": 0,
+ "end": 1125,
+ "type": "Root",
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Comment",
+ "start": 0,
+ "end": 256,
+ "data": "\n\tSpace-separated tags pack per width on their content line: the separator between two tags is\n\ta fill boundary that breaks only before the tag that would cross print width, never with the\n\tcontainer — one tag per line is never the answer to width.\n"
+ },
+ {
+ "type": "Text",
+ "start": 256,
+ "end": 258,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 258,
+ "end": 321,
+ "data": " a pair whose content line is exactly 100 chars - packs "
+ },
+ {
+ "type": "Text",
+ "start": 321,
+ "end": 322,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 322,
+ "end": 430,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 8,
+ "column": 1,
+ "character": 323
+ },
+ "end": {
+ "line": 8,
+ "column": 2,
+ "character": 324
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 325,
+ "end": 327,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 327,
+ "end": 330,
+ "expression": {
+ "type": "Identifier",
+ "start": 328,
+ "end": 329,
+ "loc": {
+ "start": {
+ "line": 9,
+ "column": 2
+ },
+ "end": {
+ "line": 9,
+ "column": 3
+ }
+ },
+ "name": "a"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 330,
+ "end": 331,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 331,
+ "end": 425,
+ "expression": {
+ "type": "Identifier",
+ "start": 332,
+ "end": 424,
+ "loc": {
+ "start": {
+ "line": 9,
+ "column": 6
+ },
+ "end": {
+ "line": 9,
+ "column": 98
+ }
+ },
+ "name": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 425,
+ "end": 426,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 430,
+ "end": 432,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 432,
+ "end": 516,
+ "data": " a pair whose content line would be 101 chars - breaks before the second tag "
+ },
+ {
+ "type": "Text",
+ "start": 516,
+ "end": 517,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 517,
+ "end": 627,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 13,
+ "column": 1,
+ "character": 518
+ },
+ "end": {
+ "line": 13,
+ "column": 2,
+ "character": 519
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 520,
+ "end": 522,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 522,
+ "end": 525,
+ "expression": {
+ "type": "Identifier",
+ "start": 523,
+ "end": 524,
+ "loc": {
+ "start": {
+ "line": 14,
+ "column": 2
+ },
+ "end": {
+ "line": 14,
+ "column": 3
+ }
+ },
+ "name": "a"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 525,
+ "end": 527,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 527,
+ "end": 622,
+ "expression": {
+ "type": "Identifier",
+ "start": 528,
+ "end": 621,
+ "loc": {
+ "start": {
+ "line": 15,
+ "column": 2
+ },
+ "end": {
+ "line": 15,
+ "column": 95
+ }
+ },
+ "name": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 622,
+ "end": 623,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 627,
+ "end": 629,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 629,
+ "end": 722,
+ "data": " three tags in an inline element, the content line exactly 100 chars - all three pack "
+ },
+ {
+ "type": "Text",
+ "start": 722,
+ "end": 723,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 723,
+ "end": 853,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 19,
+ "column": 1,
+ "character": 724
+ },
+ "end": {
+ "line": 19,
+ "column": 4,
+ "character": 727
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 728,
+ "end": 730,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 730,
+ "end": 846,
+ "name": "small",
+ "name_loc": {
+ "start": {
+ "line": 20,
+ "column": 2,
+ "character": 731
+ },
+ "end": {
+ "line": 20,
+ "column": 7,
+ "character": 736
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 737,
+ "end": 740,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 740,
+ "end": 743,
+ "expression": {
+ "type": "Identifier",
+ "start": 741,
+ "end": 742,
+ "loc": {
+ "start": {
+ "line": 21,
+ "column": 3
+ },
+ "end": {
+ "line": 21,
+ "column": 4
+ }
+ },
+ "name": "a"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 743,
+ "end": 744,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 744,
+ "end": 747,
+ "expression": {
+ "type": "Identifier",
+ "start": 745,
+ "end": 746,
+ "loc": {
+ "start": {
+ "line": 21,
+ "column": 7
+ },
+ "end": {
+ "line": 21,
+ "column": 8
+ }
+ },
+ "name": "b"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 747,
+ "end": 748,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 748,
+ "end": 836,
+ "expression": {
+ "type": "Identifier",
+ "start": 749,
+ "end": 835,
+ "loc": {
+ "start": {
+ "line": 21,
+ "column": 11
+ },
+ "end": {
+ "line": 21,
+ "column": 97
+ }
+ },
+ "name": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 836,
+ "end": 838,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 846,
+ "end": 847,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 853,
+ "end": 855,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 855,
+ "end": 990,
+ "data": " three tags, the content line would be 101 chars - the run breaks before the tag that\n\toverflows, and the first two stay packed "
+ },
+ {
+ "type": "Text",
+ "start": 990,
+ "end": 991,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 991,
+ "end": 1124,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 27,
+ "column": 1,
+ "character": 992
+ },
+ "end": {
+ "line": 27,
+ "column": 4,
+ "character": 995
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 996,
+ "end": 998,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 998,
+ "end": 1117,
+ "name": "small",
+ "name_loc": {
+ "start": {
+ "line": 28,
+ "column": 2,
+ "character": 999
+ },
+ "end": {
+ "line": 28,
+ "column": 7,
+ "character": 1004
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1005,
+ "end": 1008,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1008,
+ "end": 1011,
+ "expression": {
+ "type": "Identifier",
+ "start": 1009,
+ "end": 1010,
+ "loc": {
+ "start": {
+ "line": 29,
+ "column": 3
+ },
+ "end": {
+ "line": 29,
+ "column": 4
+ }
+ },
+ "name": "a"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1011,
+ "end": 1012,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1012,
+ "end": 1015,
+ "expression": {
+ "type": "Identifier",
+ "start": 1013,
+ "end": 1014,
+ "loc": {
+ "start": {
+ "line": 29,
+ "column": 7
+ },
+ "end": {
+ "line": 29,
+ "column": 8
+ }
+ },
+ "name": "b"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1015,
+ "end": 1018,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1018,
+ "end": 1107,
+ "expression": {
+ "type": "Identifier",
+ "start": 1019,
+ "end": 1106,
+ "loc": {
+ "start": {
+ "line": 30,
+ "column": 3
+ },
+ "end": {
+ "line": 30,
+ "column": 90
+ }
+ },
+ "name": "ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1107,
+ "end": 1109,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1117,
+ "end": 1118,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ }
+ ]
+ },
+ "options": null,
+ "comments": []
+}
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/input.svelte
new file mode 100644
index 000000000..dc44dac8e
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/input.svelte
@@ -0,0 +1,32 @@
+<!--
+ Space-separated tags pack per width on their content line: the separator between two tags is
+ a fill boundary that breaks only before the tag that would cross print width, never with the
+ container — one tag per line is never the answer to width.
+-->
+
+<!-- a pair whose content line is exactly 100 chars - packs -->
+<p>
+ {a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+</p>
+
+<!-- a pair whose content line would be 101 chars - breaks before the second tag -->
+<p>
+ {a}
+ {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+</p>
+
+<!-- three tags in an inline element, the content line exactly 100 chars - all three pack -->
+<div>
+ <small>
+ {a} {b} {cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}
+ </small>
+</div>
+
+<!-- three tags, the content line would be 101 chars - the run breaks before the tag that
+ overflows, and the first two stay packed -->
+<div>
+ <small>
+ {a} {b}
+ {ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}
+ </small>
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..0d37111c7
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,36 @@
+<!--
+ Space-separated tags pack per width on their content line: the separator between two tags is
+ a fill boundary that breaks only before the tag that would cross print width, never with the
+ container — one tag per line is never the answer to width.
+-->
+
+<!-- a pair whose content line is exactly 100 chars - packs -->
+<p>
+ {a}
+ {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+</p>
+
+<!-- a pair whose content line would be 101 chars - breaks before the second tag -->
+<p>
+ {a}
+ {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+</p>
+
+<!-- three tags in an inline element, the content line exactly 100 chars - all three pack -->
+<div>
+ <small>
+ {a}
+ {b}
+ {cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}
+ </small>
+</div>
+
+<!-- three tags, the content line would be 101 chars - the run breaks before the tag that
+ overflows, and the first two stay packed -->
+<div>
+ <small>
+ {a}
+ {b}
+ {ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}
+ </small>
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/unformatted_ours_compact.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/unformatted_ours_compact.svelte
new file mode 100644
index 000000000..490d1b9bf
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/unformatted_ours_compact.svelte
@@ -0,0 +1,22 @@
+<!--
+ Space-separated tags pack per width on their content line: the separator between two tags is
+ a fill boundary that breaks only before the tag that would cross print width, never with the
+ container — one tag per line is never the answer to width.
+-->
+
+<!-- a pair whose content line is exactly 100 chars - packs -->
+<p>{a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}</p>
+
+<!-- a pair whose content line would be 101 chars - breaks before the second tag -->
+<p>{a} {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}</p>
+
+<!-- three tags in an inline element, the content line exactly 100 chars - all three pack -->
+<div>
+ <small>{a} {b} {cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}</small>
+</div>
+
+<!-- three tags, the content line would be 101 chars - the run breaks before the tag that
+ overflows, and the first two stay packed -->
+<div>
+ <small>{a} {b} {ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}</small>
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/variant_split.svelte b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/variant_split.svelte
new file mode 100644
index 000000000..0d37111c7
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_content_spaced_tags_pack_long_prettier_divergence/variant_split.svelte
@@ -0,0 +1,36 @@
+<!--
+ Space-separated tags pack per width on their content line: the separator between two tags is
+ a fill boundary that breaks only before the tag that would cross print width, never with the
+ container — one tag per line is never the answer to width.
+-->
+
+<!-- a pair whose content line is exactly 100 chars - packs -->
+<p>
+ {a}
+ {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+</p>
+
+<!-- a pair whose content line would be 101 chars - breaks before the second tag -->
+<p>
+ {a}
+ {bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb}
+</p>
+
+<!-- three tags in an inline element, the content line exactly 100 chars - all three pack -->
+<div>
+ <small>
+ {a}
+ {b}
+ {cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}
+ </small>
+</div>
+
+<!-- three tags, the content line would be 101 chars - the run breaks before the tag that
+ overflows, and the first two stay packed -->
+<div>
+ <small>
+ {a}
+ {b}
+ {ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc}
+ </small>
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_prettier_divergence/README.md
index 7bfc9f8f9..e5c3a405b 100644
--- a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_prettier_divergence/README.md
+++ b/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_prettier_divergence/README.md
@@ -65,7 +65,7 @@ tag, or inside a content text — so it is dual-stable. The one space spelling i
newline form is a whitespace-only space between two **tags**: tsv keeps that packed as well (the
separator defers to its per-width group as a prose run's does), but prettier's bare `line`
between two tags breaks with the container, so that pair is its own fixture,
-[inline_sibling_newline_label_hold_tag_pair_space](../inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/).
+[inline_tag_pair_space](../inline_tag_pair_space_prettier_divergence/).
Without the null control an implementation that always broke a one-word run would satisfy every
other file here.
diff --git a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/README.md
deleted file mode 100644
index 13e7f8d34..000000000
--- a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence
-
-The sibling-newline flow rule's prose gate
-([inline_sibling_newline_label_hold](../inline_sibling_newline_label_hold_prettier_divergence/))
-is a **hold**, never a forced break: it decides whether an authored newline may reflow, and says
-nothing about an authored space. A one-word run holds its authored lines, but its SPACE-spelled
-tag pair — `text1 {expr1} {expr2}`, `{expr1} {expr2} {expr3} text1`, and the escaped-angle-bracket
-pair at the root — is a fill like a prose run's and packs per width. Prettier's bare `line`
-between two tags breaks with the multiline container whatever the run holds, so it splits every
-one of them (`output_prettier.svelte`). The control is a wordless pair (`{expr1} {expr2}`, no
-content text at all), which breaks with the container under both formatters
-(`unformatted_ours_space.svelte`: tsv normalizes its space spelling to the split `input.svelte`
-form, prettier to `output_prettier.svelte`).
-
-## Reason
-
-Design choice. The whitespace-only separator before a tag asks two different run gates for its two
-spellings. The NEWLINE spelling asks the prose gate — is there a phrase to reflow into — and a
-one-word run says no, so the newline is held as the author's structure. The SPACE spelling asks
-only whether the run holds a word at all — is there a fill for this separator to sit in —
-so it defers to the next tag's per-width group and the pair packs, exactly as a prose run's does
-([inline_adjacent_sibling_newline_flow](../inline_adjacent_sibling_newline_flow_prettier_divergence/),
-the prose tag pair prettier also splits). Gating the space on the prose count would turn the hold
-into a forced break — `Price: {currency} {amount}` authored on one line coming out on two — a
-layout keyed on nothing the author wrote. Only a run with no word in it keeps the bare `line`
-that breaks with the container: with no fill at all, its authored spacing is the only structure it
-has, and both formatters agree (the tag-separator rule of
-[inline_content_spaced_tags_long](../inline_content_spaced_tags_long_prettier_divergence/)).
-Both arms of the separator site read the same run fact, so a width-broken container and a
-newline-authored one lay the pair out identically.
-
-See
-[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/expected.json
deleted file mode 100644
index 9ccb8b098..000000000
--- a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/expected.json
+++ /dev/null
@@ -1,536 +0,0 @@
-{
- "css": null,
- "js": [],
- "start": 0,
- "end": 912,
- "type": "Root",
- "fragment": {
- "type": "Fragment",
- "nodes": [
- {
- "type": "Comment",
- "start": 0,
- "end": 420,
- "data": "\n\tThe sibling-newline flow rule's prose gate is a HOLD on an authored newline, never a forced\n\tone: a one-word run keeps its authored lines, but its SPACE-spelled tag pair is a fill like a\n\tprose run's and packs per width, where prettier's bare `line` between two tags breaks with\n\tthe multiline container. Only a prose-FREE run's tag pair — no content text at all — takes\n\tthat break under tsv too: the control.\n"
- },
- {
- "type": "Text",
- "start": 420,
- "end": 422,
- "raw": "\n\n",
- "data": "\n\n"
- },
- {
- "type": "Comment",
- "start": 422,
- "end": 484,
- "data": " a word before a spaced tag pair, and a word after one "
- },
- {
- "type": "Text",
- "start": 484,
- "end": 485,
- "raw": "\n",
- "data": "\n"
- },
- {
- "type": "RegularElement",
- "start": 485,
- "end": 516,
- "name": "p",
- "name_loc": {
- "start": {
- "line": 10,
- "column": 1,
- "character": 486
- },
- "end": {
- "line": 10,
- "column": 2,
- "character": 487
- }
- },
- "attributes": [],
- "fragment": {
- "type": "Fragment",
- "nodes": [
- {
- "type": "Text",
- "start": 488,
- "end": 496,
- "raw": "\n\ttext1 ",
- "data": "\n\ttext1 "
- },
- {
- "type": "ExpressionTag",
- "start": 496,
- "end": 503,
- "expression": {
- "type": "Identifier",
- "start": 497,
- "end": 502,
- "loc": {
- "start": {
- "line": 11,
- "column": 8
- },
- "end": {
- "line": 11,
- "column": 13
- }
- },
- "name": "expr1"
- }
- },
- {
- "type": "Text",
- "start": 503,
- "end": 504,
- "raw": " ",
- "data": " "
- },
- {
- "type": "ExpressionTag",
- "start": 504,
- "end": 511,
- "expression": {
- "type": "Identifier",
- "start": 505,
- "end": 510,
- "loc": {
- "start": {
- "line": 11,
- "column": 16
- },
- "end": {
- "line": 11,
- "column": 21
- }
- },
- "name": "expr2"
- }
- },
- {
- "type": "Text",
- "start": 511,
- "end": 512,
- "raw": "\n",
- "data": "\n"
- }
- ]
- }
- },
- {
- "type": "Text",
- "start": 516,
- "end": 517,
- "raw": "\n",
- "data": "\n"
- },
- {
- "type": "RegularElement",
- "start": 517,
- "end": 556,
- "name": "p",
- "name_loc": {
- "start": {
- "line": 13,
- "column": 1,
- "character": 518
- },
- "end": {
- "line": 13,
- "column": 2,
- "character": 519
- }
- },
- "attributes": [],
- "fragment": {
- "type": "Fragment",
- "nodes": [
- {
- "type": "Text",
- "start": 520,
- "end": 522,
- "raw": "\n\t",
- "data": "\n\t"
- },
- {
- "type": "ExpressionTag",
- "start": 522,
- "end": 529,
- "expression": {
- "type": "Identifier",
- "start": 523,
- "end": 528,
- "loc": {
- "start": {
- "line": 14,
- "column": 2
- },
- "end": {
- "line": 14,
- "column": 7
- }
- },
- "name": "expr1"
- }
- },
- {
- "type": "Text",
- "start": 529,
- "end": 530,
- "raw": " ",
- "data": " "
- },
- {
- "type": "ExpressionTag",
- "start": 530,
- "end": 537,
- "expression": {
- "type": "Identifier",
- "start": 531,
- "end": 536,
- "loc": {
- "start": {
- "line": 14,
- "column": 10
- },
- "end": {
- "line": 14,
- "column": 15
- }
- },
- "name": "expr2"
- }
- },
- {
- "type": "Text",
- "start": 537,
- "end": 538,
- "raw": " ",
- "data": " "
- },
- {
- "type": "ExpressionTag",
- "start": 538,
- "end": 545,
- "expression": {
- "type": "Identifier",
- "start": 539,
- "end": 544,
- "loc": {
- "start": {
- "line": 14,
- "column": 18
- },
- "end": {
- "line": 14,
- "column": 23
- }
- },
- "name": "expr3"
- }
- },
- {
- "type": "Text",
- "start": 545,
- "end": 552,
- "raw": " text1\n",
- "data": " text1\n"
- }
- ]
- }
- },
- {
- "type": "Text",
- "start": 556,
- "end": 558,
- "raw": "\n\n",
- "data": "\n\n"
- },
- {
- "type": "Comment",
- "start": 558,
- "end": 716,
- "data": " at the root, which is always a multiline container: the escaped-angle-bracket pair, whose\n glued `div` / `code` words make the run a one-word run "
- },
- {
- "type": "Text",
- "start": 716,
- "end": 717,
- "raw": "\n",
- "data": "\n"
- },
- {
- "type": "ExpressionTag",
- "start": 717,
- "end": 722,
- "expression": {
- "type": "Literal",
- "start": 718,
- "end": 721,
- "loc": {
- "start": {
- "line": 19,
- "column": 1
- },
- "end": {
- "line": 19,
- "column": 4
- }
- },
- "value": "<",
- "raw": "'<'"
- }
- },
- {
- "type": "Text",
- "start": 722,
- "end": 725,
- "raw": "div",
- "data": "div"
- },
- {
- "type": "ExpressionTag",
- "start": 725,
- "end": 730,
- "expression": {
- "type": "Literal",
- "start": 726,
- "end": 729,
- "loc": {
- "start": {
- "line": 19,
- "column": 9
- },
- "end": {
- "line": 19,
- "column": 12
- }
- },
- "value": ">",
- "raw": "'>'"
- }
- },
- {
- "type": "Text",
- "start": 730,
- "end": 731,
- "raw": " ",
- "data": " "
- },
- {
- "type": "ExpressionTag",
- "start": 731,
- "end": 736,
- "expression": {
- "type": "Literal",
- "start": 732,
- "end": 735,
- "loc": {
- "start": {
- "line": 19,
- "column": 15
- },
- "end": {
- "line": 19,
- "column": 18
- }
- },
- "value": "<",
- "raw": "'<'"
- }
- },
- {
- "type": "Text",
- "start": 736,
- "end": 740,
- "raw": "code",
- "data": "code"
- },
- {
- "type": "ExpressionTag",
- "start": 740,
- "end": 745,
- "expression": {
- "type": "Literal",
- "start": 741,
- "end": 744,
- "loc": {
- "start": {
- "line": 19,
- "column": 24
- },
- "end": {
- "line": 19,
- "column": 27
- }
- },
- "value": ">",
- "raw": "'>'"
- }
- },
- {
- "type": "ExpressionTag",
- "start": 745,
- "end": 750,
- "expression": {
- "type": "Literal",
- "start": 746,
- "end": 749,
- "loc": {
- "start": {
- "line": 19,
- "column": 29
- },
- "end": {
- "line": 19,
- "column": 32
- }
- },
- "value": "<",
- "raw": "'<'"
- }
- },
- {
- "type": "Text",
- "start": 750,
- "end": 755,
- "raw": "/code",
- "data": "/code"
- },
- {
- "type": "ExpressionTag",
- "start": 755,
- "end": 760,
- "expression": {
- "type": "Literal",
- "start": 756,
- "end": 759,
- "loc": {
- "start": {
- "line": 19,
- "column": 39
- },
- "end": {
- "line": 19,
- "column": 42
- }
- },
- "value": ">",
- "raw": "'>'"
- }
- },
- {
- "type": "Text",
- "start": 760,
- "end": 762,
- "raw": "\n\n",
- "data": "\n\n"
- },
- {
- "type": "Comment",
- "start": 762,
- "end": 884,
- "data": " control: a prose-free pair has no fill at all, and its space breaks with the container\n under both formatters "
- },
- {
- "type": "Text",
- "start": 884,
- "end": 885,
- "raw": "\n",
- "data": "\n"
- },
- {
- "type": "RegularElement",
- "start": 885,
- "end": 911,
- "name": "p",
- "name_loc": {
- "start": {
- "line": 23,
- "column": 1,
- "character": 886
- },
- "end": {
- "line": 23,
- "column": 2,
- "character": 887
- }
- },
- "attributes": [],
- "fragment": {
- "type": "Fragment",
- "nodes": [
- {
- "type": "Text",
- "start": 888,
- "end": 890,
- "raw": "\n\t",
- "data": "\n\t"
- },
- {
- "type": "ExpressionTag",
- "start": 890,
- "end": 897,
- "expression": {
- "type": "Identifier",
- "start": 891,
- "end": 896,
- "loc": {
- "start": {
- "line": 24,
- "column": 2
- },
- "end": {
- "line": 24,
- "column": 7
- }
- },
- "name": "expr1"
- }
- },
- {
- "type": "Text",
- "start": 897,
- "end": 899,
- "raw": "\n\t",
- "data": "\n\t"
- },
- {
- "type": "ExpressionTag",
- "start": 899,
- "end": 906,
- "expression": {
- "type": "Identifier",
- "start": 900,
- "end": 905,
- "loc": {
- "start": {
- "line": 25,
- "column": 2
- },
- "end": {
- "line": 25,
- "column": 7
- }
- },
- "name": "expr2"
- }
- },
- {
- "type": "Text",
- "start": 906,
- "end": 907,
- "raw": "\n",
- "data": "\n"
- }
- ]
- }
- }
- ]
- },
- "options": null,
- "comments": []
-}
diff --git a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/input.svelte
deleted file mode 100644
index 2c6ddc8b3..000000000
--- a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/input.svelte
+++ /dev/null
@@ -1,26 +0,0 @@
-<!--
- The sibling-newline flow rule's prose gate is a HOLD on an authored newline, never a forced
- one: a one-word run keeps its authored lines, but its SPACE-spelled tag pair is a fill like a
- prose run's and packs per width, where prettier's bare `line` between two tags breaks with
- the multiline container. Only a prose-FREE run's tag pair — no content text at all — takes
- that break under tsv too: the control.
--->
-
-<!-- a word before a spaced tag pair, and a word after one -->
-<p>
- text1 {expr1} {expr2}
-</p>
-<p>
- {expr1} {expr2} {expr3} text1
-</p>
-
-<!-- at the root, which is always a multiline container: the escaped-angle-bracket pair, whose
- glued `div` / `code` words make the run a one-word run -->
-{'<'}div{'>'} {'<'}code{'>'}{'<'}/code{'>'}
-
-<!-- control: a prose-free pair has no fill at all, and its space breaks with the container
- under both formatters -->
-<p>
- {expr1}
- {expr2}
-</p>
diff --git a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/output_prettier.svelte
deleted file mode 100644
index 5a2d33dfa..000000000
--- a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/output_prettier.svelte
+++ /dev/null
@@ -1,30 +0,0 @@
-<!--
- The sibling-newline flow rule's prose gate is a HOLD on an authored newline, never a forced
- one: a one-word run keeps its authored lines, but its SPACE-spelled tag pair is a fill like a
- prose run's and packs per width, where prettier's bare `line` between two tags breaks with
- the multiline container. Only a prose-FREE run's tag pair — no content text at all — takes
- that break under tsv too: the control.
--->
-
-<!-- a word before a spaced tag pair, and a word after one -->
-<p>
- text1 {expr1}
- {expr2}
-</p>
-<p>
- {expr1}
- {expr2}
- {expr3} text1
-</p>
-
-<!-- at the root, which is always a multiline container: the escaped-angle-bracket pair, whose
- glued `div` / `code` words make the run a one-word run -->
-{'<'}div{'>'}
-{'<'}code{'>'}{'<'}/code{'>'}
-
-<!-- control: a prose-free pair has no fill at all, and its space breaks with the container
- under both formatters -->
-<p>
- {expr1}
- {expr2}
-</p>
diff --git a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/unformatted_ours_space.svelte b/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/unformatted_ours_space.svelte
deleted file mode 100644
index a166306dd..000000000
--- a/tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/unformatted_ours_space.svelte
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
- The sibling-newline flow rule's prose gate is a HOLD on an authored newline, never a forced
- one: a one-word run keeps its authored lines, but its SPACE-spelled tag pair is a fill like a
- prose run's and packs per width, where prettier's bare `line` between two tags breaks with
- the multiline container. Only a prose-FREE run's tag pair — no content text at all — takes
- that break under tsv too: the control.
--->
-
-<!-- a word before a spaced tag pair, and a word after one -->
-<p>
- text1 {expr1} {expr2}
-</p>
-<p>
- {expr1} {expr2} {expr3} text1
-</p>
-
-<!-- at the root, which is always a multiline container: the escaped-angle-bracket pair, whose
- glued `div` / `code` words make the run a one-word run -->
-{'<'}div{'>'} {'<'}code{'>'}{'<'}/code{'>'}
-
-<!-- control: a prose-free pair has no fill at all, and its space breaks with the container
- under both formatters -->
-<p>
- {expr1} {expr2}
-</p>
diff --git a/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/README.md
new file mode 100644
index 000000000..28120f761
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/README.md
@@ -0,0 +1,42 @@
+# inline_sibling_space_before_bounding_prettier_divergence
+
+**The follower never turns a space into a newline either.** A space before a **comment**, a
+`{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap after
+*any* sibling — an inline element, a component, every tag kind, another comment, a `<br />`, an
+inline-rendering block, and a control-flow block or element that renders multiline — exactly as it
+already is after text, so `<span>inline1</span> <!-- c -->`, `{/if} <!-- c -->`,
+`{expr} {#if cond}text1{/if}`, `<span>inline1</span> {#await promise}text1{/await}` and
+`<!-- c1 --> <!-- c2 -->` keep their authored space in a multiline container, in a block and at the
+root, and a comment spaced on both sides keeps both. Prettier keeps the space after text and breaks
+it with the container after anything else (`output_prettier.svelte`). The **newline** spelling of
+every such boundary is held by both formatters (`variant_newline.svelte`): a comment's line is
+authorship, and it is the newline that holds it.
+
+The controls agree with prettier: a control-flow block that renders **multiline** drops to a fresh
+line whole (the wrap's group breaks on the block's own hardlines — the spaced whole-unit drop every
+unit kind has), a **block element** predecessor keeps the follower off its line, and a `<br />`
+after a comment takes its wrap; the comment's and the inline block's own width boundary hugs at
+exactly 100 chars and drops at 101. `unformatted_ours_boundary_space` spells those breaking
+boundaries as a space, and `unformatted_ours_spaces` widens every kept space to three; tsv
+normalizes both to `input.svelte` in one pass.
+
+`variant_prettier_split.svelte` is prettier's form itself (it differs from `variant_newline` only in keeping
+the two after-text spaces), and tsv keeps it stable too, so a rule change that started normalizing
+prettier's form back to `input.svelte` fails this file rather than passing in prose.
+
+## Reason
+
+Design choice — the follower-side twin of
+[inline_tag_pair_space_bounded](../inline_tag_pair_space_bounded_prettier_divergence/). The
+whitespace-only separator's bare `line` before a run-ending follower broke with the container while
+the fill's `line` before the same follower packed per width, so `<span>a</span> <!-- c -->` split
+where `text1 <!-- c -->` hugged: one boundary, two answers, keyed on whether a text node happened to
+precede it. The rule family's thesis is that the prose gate holds an authored newline and never
+forces one — a space is never turned into a newline the author did not write — and comment
+position is held by the newline spelling, not by breaking the author's space
+([§Comment Position Philosophy](../../../../../docs/conformance_prettier.md#comment-position-philosophy)).
+The old bare `line` was also half of a two-arm disagreement (the inline arm already wrapped these
+followers per width), which is a two-pass cycle rather than a policy; both arms now wrap.
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/expected.json
new file mode 100644
index 000000000..36128be92
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/expected.json
@@ -0,0 +1,2705 @@
+{
+ "css": null,
+ "js": [],
+ "start": 0,
+ "end": 3120,
+ "type": "Root",
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Comment",
+ "start": 0,
+ "end": 434,
+ "data": "\n\tThe follower never turns a space into a newline either: a space before a COMMENT, a\n\t`{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap\n\tafter any sibling, exactly as it already is after text — a comment's line is authorship, and\n\tit is the NEWLINE spelling that holds it. Prettier keeps the space after text and breaks it\n\twith the container after an element, a component or a tag.\n"
+ },
+ {
+ "type": "Text",
+ "start": 434,
+ "end": 436,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 436,
+ "end": 529,
+ "data": " a comment after an inline element, a component and every tag kind: the space is kept "
+ },
+ {
+ "type": "Text",
+ "start": 529,
+ "end": 530,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 530,
+ "end": 664,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 10,
+ "column": 1,
+ "character": 531
+ },
+ "end": {
+ "line": 10,
+ "column": 4,
+ "character": 534
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 535,
+ "end": 537,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 537,
+ "end": 557,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 11,
+ "column": 2,
+ "character": 538
+ },
+ "end": {
+ "line": 11,
+ "column": 6,
+ "character": 542
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 543,
+ "end": 550,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 557,
+ "end": 558,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 558,
+ "end": 568,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 568,
+ "end": 570,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Component",
+ "start": 570,
+ "end": 578,
+ "name": "Comp",
+ "name_loc": {
+ "start": {
+ "line": 12,
+ "column": 2,
+ "character": 571
+ },
+ "end": {
+ "line": 12,
+ "column": 6,
+ "character": 575
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 578,
+ "end": 579,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 579,
+ "end": 589,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 589,
+ "end": 591,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 591,
+ "end": 597,
+ "expression": {
+ "type": "Identifier",
+ "start": 592,
+ "end": 596,
+ "loc": {
+ "start": {
+ "line": 13,
+ "column": 2
+ },
+ "end": {
+ "line": 13,
+ "column": 6
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 597,
+ "end": 598,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 598,
+ "end": 608,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 608,
+ "end": 610,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RenderTag",
+ "start": 610,
+ "end": 624,
+ "expression": {
+ "type": "CallExpression",
+ "start": 619,
+ "end": 623,
+ "loc": {
+ "start": {
+ "line": 14,
+ "column": 10
+ },
+ "end": {
+ "line": 14,
+ "column": 14
+ }
+ },
+ "callee": {
+ "type": "Identifier",
+ "start": 619,
+ "end": 621,
+ "loc": {
+ "start": {
+ "line": 14,
+ "column": 10
+ },
+ "end": {
+ "line": 14,
+ "column": 12
+ }
+ },
+ "name": "fn"
+ },
+ "arguments": [],
+ "optional": false
+ }
+ },
+ {
+ "type": "Text",
+ "start": 624,
+ "end": 625,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 625,
+ "end": 635,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 635,
+ "end": 637,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "HtmlTag",
+ "start": 637,
+ "end": 646,
+ "expression": {
+ "type": "Identifier",
+ "start": 644,
+ "end": 645,
+ "loc": {
+ "start": {
+ "line": 15,
+ "column": 8
+ },
+ "end": {
+ "line": 15,
+ "column": 9
+ }
+ },
+ "name": "a"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 646,
+ "end": 647,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 647,
+ "end": 657,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 657,
+ "end": 658,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 664,
+ "end": 666,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 666,
+ "end": 845,
+ "data": " and after a bounding predecessor: an inline-rendering control-flow block, a <br />, a\n control-flow block that renders multiline and an element that renders multiline "
+ },
+ {
+ "type": "Text",
+ "start": 845,
+ "end": 846,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 846,
+ "end": 921,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 20,
+ "column": 1,
+ "character": 847
+ },
+ "end": {
+ "line": 20,
+ "column": 4,
+ "character": 850
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 851,
+ "end": 853,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 853,
+ "end": 873,
+ "test": {
+ "type": "Identifier",
+ "start": 858,
+ "end": 862,
+ "loc": {
+ "start": {
+ "line": 21,
+ "column": 6
+ },
+ "end": {
+ "line": 21,
+ "column": 10
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 863,
+ "end": 868,
+ "raw": "text1",
+ "data": "text1"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 873,
+ "end": 874,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 874,
+ "end": 884,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 884,
+ "end": 897,
+ "raw": "\n\ttext1 text2",
+ "data": "\n\ttext1 text2"
+ },
+ {
+ "type": "RegularElement",
+ "start": 897,
+ "end": 903,
+ "name": "br",
+ "name_loc": {
+ "start": {
+ "line": 22,
+ "column": 13,
+ "character": 898
+ },
+ "end": {
+ "line": 22,
+ "column": 15,
+ "character": 900
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 903,
+ "end": 904,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 904,
+ "end": 914,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 914,
+ "end": 915,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 921,
+ "end": 922,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 922,
+ "end": 984,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 24,
+ "column": 1,
+ "character": 923
+ },
+ "end": {
+ "line": 24,
+ "column": 4,
+ "character": 926
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 927,
+ "end": 929,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 929,
+ "end": 966,
+ "test": {
+ "type": "Identifier",
+ "start": 934,
+ "end": 938,
+ "loc": {
+ "start": {
+ "line": 25,
+ "column": 6
+ },
+ "end": {
+ "line": 25,
+ "column": 10
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 939,
+ "end": 942,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 942,
+ "end": 959,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 26,
+ "column": 3,
+ "character": 943
+ },
+ "end": {
+ "line": 26,
+ "column": 6,
+ "character": 946
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 947,
+ "end": 953,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 959,
+ "end": 961,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 966,
+ "end": 967,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 967,
+ "end": 977,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 977,
+ "end": 978,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 984,
+ "end": 985,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 985,
+ "end": 1045,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 29,
+ "column": 1,
+ "character": 986
+ },
+ "end": {
+ "line": 29,
+ "column": 4,
+ "character": 989
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 990,
+ "end": 992,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 992,
+ "end": 1027,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 30,
+ "column": 2,
+ "character": 993
+ },
+ "end": {
+ "line": 30,
+ "column": 6,
+ "character": 997
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 998,
+ "end": 1001,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1001,
+ "end": 1018,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 31,
+ "column": 3,
+ "character": 1002
+ },
+ "end": {
+ "line": 31,
+ "column": 6,
+ "character": 1005
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1006,
+ "end": 1012,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1018,
+ "end": 1020,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1027,
+ "end": 1028,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 1028,
+ "end": 1038,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 1038,
+ "end": 1039,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1045,
+ "end": 1047,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1047,
+ "end": 1076,
+ "data": " the same at the root "
+ },
+ {
+ "type": "Text",
+ "start": 1076,
+ "end": 1077,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1077,
+ "end": 1097,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 36,
+ "column": 1,
+ "character": 1078
+ },
+ "end": {
+ "line": 36,
+ "column": 5,
+ "character": 1082
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1083,
+ "end": 1090,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1097,
+ "end": 1098,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 1098,
+ "end": 1108,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 1108,
+ "end": 1109,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1109,
+ "end": 1115,
+ "expression": {
+ "type": "Identifier",
+ "start": 1110,
+ "end": 1114,
+ "loc": {
+ "start": {
+ "line": 37,
+ "column": 1
+ },
+ "end": {
+ "line": 37,
+ "column": 5
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1115,
+ "end": 1116,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 1116,
+ "end": 1126,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 1126,
+ "end": 1128,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1128,
+ "end": 1221,
+ "data": " a `{@debug}` is the same follower kind, after an element and after a tag at the root "
+ },
+ {
+ "type": "Text",
+ "start": 1221,
+ "end": 1222,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1222,
+ "end": 1267,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 40,
+ "column": 1,
+ "character": 1223
+ },
+ "end": {
+ "line": 40,
+ "column": 4,
+ "character": 1226
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1227,
+ "end": 1229,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1229,
+ "end": 1249,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 41,
+ "column": 2,
+ "character": 1230
+ },
+ "end": {
+ "line": 41,
+ "column": 6,
+ "character": 1234
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1235,
+ "end": 1242,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1249,
+ "end": 1250,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "DebugTag",
+ "start": 1250,
+ "end": 1260,
+ "identifiers": [
+ {
+ "type": "Identifier",
+ "start": 1258,
+ "end": 1259,
+ "loc": {
+ "start": {
+ "line": 41,
+ "column": 30
+ },
+ "end": {
+ "line": 41,
+ "column": 31
+ }
+ },
+ "name": "a"
+ }
+ ]
+ },
+ {
+ "type": "Text",
+ "start": 1260,
+ "end": 1261,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1267,
+ "end": 1268,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1268,
+ "end": 1274,
+ "expression": {
+ "type": "Identifier",
+ "start": 1269,
+ "end": 1273,
+ "loc": {
+ "start": {
+ "line": 43,
+ "column": 1
+ },
+ "end": {
+ "line": 43,
+ "column": 5
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1274,
+ "end": 1275,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "DebugTag",
+ "start": 1275,
+ "end": 1285,
+ "identifiers": [
+ {
+ "type": "Identifier",
+ "start": 1283,
+ "end": 1284,
+ "loc": {
+ "start": {
+ "line": 43,
+ "column": 15
+ },
+ "end": {
+ "line": 43,
+ "column": 16
+ }
+ },
+ "name": "a"
+ }
+ ]
+ },
+ {
+ "type": "Text",
+ "start": 1285,
+ "end": 1287,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1287,
+ "end": 1416,
+ "data": " an inline-rendering control-flow block after an inline element, a tag, a component and a\n comment — every block kind "
+ },
+ {
+ "type": "Text",
+ "start": 1416,
+ "end": 1417,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1417,
+ "end": 1677,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 47,
+ "column": 1,
+ "character": 1418
+ },
+ "end": {
+ "line": 47,
+ "column": 4,
+ "character": 1421
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1422,
+ "end": 1424,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1424,
+ "end": 1444,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 48,
+ "column": 2,
+ "character": 1425
+ },
+ "end": {
+ "line": 48,
+ "column": 6,
+ "character": 1429
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1430,
+ "end": 1437,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1444,
+ "end": 1445,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 1445,
+ "end": 1465,
+ "test": {
+ "type": "Identifier",
+ "start": 1450,
+ "end": 1454,
+ "loc": {
+ "start": {
+ "line": 48,
+ "column": 27
+ },
+ "end": {
+ "line": 48,
+ "column": 31
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1455,
+ "end": 1460,
+ "raw": "text1",
+ "data": "text1"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 1465,
+ "end": 1467,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1467,
+ "end": 1473,
+ "expression": {
+ "type": "Identifier",
+ "start": 1468,
+ "end": 1472,
+ "loc": {
+ "start": {
+ "line": 49,
+ "column": 2
+ },
+ "end": {
+ "line": 49,
+ "column": 6
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1473,
+ "end": 1474,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 1474,
+ "end": 1494,
+ "test": {
+ "type": "Identifier",
+ "start": 1479,
+ "end": 1483,
+ "loc": {
+ "start": {
+ "line": 49,
+ "column": 13
+ },
+ "end": {
+ "line": 49,
+ "column": 17
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1484,
+ "end": 1489,
+ "raw": "text1",
+ "data": "text1"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 1494,
+ "end": 1496,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Component",
+ "start": 1496,
+ "end": 1504,
+ "name": "Comp",
+ "name_loc": {
+ "start": {
+ "line": 50,
+ "column": 2,
+ "character": 1497
+ },
+ "end": {
+ "line": 50,
+ "column": 6,
+ "character": 1501
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1504,
+ "end": 1505,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "EachBlock",
+ "start": 1505,
+ "end": 1539,
+ "expression": {
+ "type": "Identifier",
+ "start": 1512,
+ "end": 1517,
+ "loc": {
+ "start": {
+ "line": 50,
+ "column": 17
+ },
+ "end": {
+ "line": 50,
+ "column": 22
+ }
+ },
+ "name": "items"
+ },
+ "body": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "ExpressionTag",
+ "start": 1526,
+ "end": 1532,
+ "expression": {
+ "type": "Identifier",
+ "start": 1527,
+ "end": 1531,
+ "loc": {
+ "start": {
+ "line": 50,
+ "column": 32
+ },
+ "end": {
+ "line": 50,
+ "column": 36
+ }
+ },
+ "name": "item"
+ }
+ }
+ ]
+ },
+ "context": {
+ "type": "Identifier",
+ "name": "item",
+ "start": 1521,
+ "end": 1525,
+ "loc": {
+ "start": {
+ "line": 50,
+ "column": 26,
+ "character": 1521
+ },
+ "end": {
+ "line": 50,
+ "column": 30,
+ "character": 1525
+ }
+ }
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1539,
+ "end": 1541,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Comment",
+ "start": 1541,
+ "end": 1551,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 1551,
+ "end": 1552,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 1552,
+ "end": 1572,
+ "test": {
+ "type": "Identifier",
+ "start": 1557,
+ "end": 1561,
+ "loc": {
+ "start": {
+ "line": 51,
+ "column": 17
+ },
+ "end": {
+ "line": 51,
+ "column": 21
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1562,
+ "end": 1567,
+ "raw": "text1",
+ "data": "text1"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 1572,
+ "end": 1574,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1574,
+ "end": 1594,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 52,
+ "column": 2,
+ "character": 1575
+ },
+ "end": {
+ "line": 52,
+ "column": 6,
+ "character": 1579
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1580,
+ "end": 1587,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1594,
+ "end": 1595,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "AwaitBlock",
+ "start": 1595,
+ "end": 1624,
+ "expression": {
+ "type": "Identifier",
+ "start": 1603,
+ "end": 1610,
+ "loc": {
+ "start": {
+ "line": 52,
+ "column": 30
+ },
+ "end": {
+ "line": 52,
+ "column": 37
+ }
+ },
+ "name": "promise"
+ },
+ "value": null,
+ "error": null,
+ "pending": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1611,
+ "end": 1616,
+ "raw": "text1",
+ "data": "text1"
+ }
+ ]
+ },
+ "then": null,
+ "catch": null
+ },
+ {
+ "type": "Text",
+ "start": 1624,
+ "end": 1626,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1626,
+ "end": 1646,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 53,
+ "column": 2,
+ "character": 1627
+ },
+ "end": {
+ "line": 53,
+ "column": 6,
+ "character": 1631
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1632,
+ "end": 1639,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1646,
+ "end": 1647,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "KeyBlock",
+ "start": 1647,
+ "end": 1670,
+ "expression": {
+ "type": "Identifier",
+ "start": 1653,
+ "end": 1658,
+ "loc": {
+ "start": {
+ "line": 53,
+ "column": 28
+ },
+ "end": {
+ "line": 53,
+ "column": 33
+ }
+ },
+ "name": "value"
+ },
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1659,
+ "end": 1664,
+ "raw": "text1",
+ "data": "text1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1670,
+ "end": 1671,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1677,
+ "end": 1679,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1679,
+ "end": 1809,
+ "data": " a comment spaced on both sides, between two tags, two components and two elements, at the\n root: both spaces are kept "
+ },
+ {
+ "type": "Text",
+ "start": 1809,
+ "end": 1810,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1810,
+ "end": 1817,
+ "expression": {
+ "type": "Identifier",
+ "start": 1811,
+ "end": 1816,
+ "loc": {
+ "start": {
+ "line": 58,
+ "column": 1
+ },
+ "end": {
+ "line": 58,
+ "column": 6
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1817,
+ "end": 1818,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 1818,
+ "end": 1828,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 1828,
+ "end": 1829,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1829,
+ "end": 1836,
+ "expression": {
+ "type": "Identifier",
+ "start": 1830,
+ "end": 1835,
+ "loc": {
+ "start": {
+ "line": 58,
+ "column": 20
+ },
+ "end": {
+ "line": 58,
+ "column": 25
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1836,
+ "end": 1837,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "Component",
+ "start": 1837,
+ "end": 1846,
+ "name": "Comp1",
+ "name_loc": {
+ "start": {
+ "line": 59,
+ "column": 1,
+ "character": 1838
+ },
+ "end": {
+ "line": 59,
+ "column": 6,
+ "character": 1843
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1846,
+ "end": 1847,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 1847,
+ "end": 1857,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 1857,
+ "end": 1858,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Component",
+ "start": 1858,
+ "end": 1867,
+ "name": "Comp2",
+ "name_loc": {
+ "start": {
+ "line": 59,
+ "column": 22,
+ "character": 1859
+ },
+ "end": {
+ "line": 59,
+ "column": 27,
+ "character": 1864
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1867,
+ "end": 1868,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1868,
+ "end": 1888,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 60,
+ "column": 1,
+ "character": 1869
+ },
+ "end": {
+ "line": 60,
+ "column": 5,
+ "character": 1873
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1874,
+ "end": 1881,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1888,
+ "end": 1889,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 1889,
+ "end": 1899,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 1899,
+ "end": 1900,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "RegularElement",
+ "start": 1900,
+ "end": 1920,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 60,
+ "column": 33,
+ "character": 1901
+ },
+ "end": {
+ "line": 60,
+ "column": 37,
+ "character": 1905
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1906,
+ "end": 1913,
+ "raw": "inline2",
+ "data": "inline2"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1920,
+ "end": 1922,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1922,
+ "end": 1987,
+ "data": " two comments: the second keeps its space after the first "
+ },
+ {
+ "type": "Text",
+ "start": 1987,
+ "end": 1988,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1988,
+ "end": 2025,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 63,
+ "column": 1,
+ "character": 1989
+ },
+ "end": {
+ "line": 63,
+ "column": 4,
+ "character": 1992
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1993,
+ "end": 1995,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Comment",
+ "start": 1995,
+ "end": 2006,
+ "data": " c1 "
+ },
+ {
+ "type": "Text",
+ "start": 2006,
+ "end": 2007,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 2007,
+ "end": 2018,
+ "data": " c2 "
+ },
+ {
+ "type": "Text",
+ "start": 2018,
+ "end": 2019,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2025,
+ "end": 2027,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 2027,
+ "end": 2102,
+ "data": " parity controls: after TEXT both formatters keep the space already "
+ },
+ {
+ "type": "Text",
+ "start": 2102,
+ "end": 2103,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2103,
+ "end": 2173,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 68,
+ "column": 1,
+ "character": 2104
+ },
+ "end": {
+ "line": 68,
+ "column": 4,
+ "character": 2107
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2108,
+ "end": 2122,
+ "raw": "\n\ttext1 text2 ",
+ "data": "\n\ttext1 text2 "
+ },
+ {
+ "type": "Comment",
+ "start": 2122,
+ "end": 2132,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 2132,
+ "end": 2146,
+ "raw": "\n\ttext1 text2 ",
+ "data": "\n\ttext1 text2 "
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 2146,
+ "end": 2166,
+ "test": {
+ "type": "Identifier",
+ "start": 2151,
+ "end": 2155,
+ "loc": {
+ "start": {
+ "line": 70,
+ "column": 18
+ },
+ "end": {
+ "line": 70,
+ "column": 22
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2156,
+ "end": 2161,
+ "raw": "text1",
+ "data": "text1"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 2166,
+ "end": 2167,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2173,
+ "end": 2175,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 2175,
+ "end": 2404,
+ "data": " controls: a control-flow block that renders multiline drops to a fresh line whole, a\n block element predecessor keeps the comment off its line, and a <br /> after a comment\n takes its wrap — under both formatters "
+ },
+ {
+ "type": "Text",
+ "start": 2404,
+ "end": 2405,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2405,
+ "end": 2478,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 76,
+ "column": 1,
+ "character": 2406
+ },
+ "end": {
+ "line": 76,
+ "column": 4,
+ "character": 2409
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2410,
+ "end": 2412,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2412,
+ "end": 2432,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 77,
+ "column": 2,
+ "character": 2413
+ },
+ "end": {
+ "line": 77,
+ "column": 6,
+ "character": 2417
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2418,
+ "end": 2425,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2432,
+ "end": 2434,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 2434,
+ "end": 2471,
+ "test": {
+ "type": "Identifier",
+ "start": 2439,
+ "end": 2443,
+ "loc": {
+ "start": {
+ "line": 78,
+ "column": 6
+ },
+ "end": {
+ "line": 78,
+ "column": 10
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2444,
+ "end": 2447,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2447,
+ "end": 2464,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 79,
+ "column": 3,
+ "character": 2448
+ },
+ "end": {
+ "line": 79,
+ "column": 6,
+ "character": 2451
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2452,
+ "end": 2458,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2464,
+ "end": 2466,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 2471,
+ "end": 2472,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2478,
+ "end": 2479,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2479,
+ "end": 2522,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 82,
+ "column": 1,
+ "character": 2480
+ },
+ "end": {
+ "line": 82,
+ "column": 4,
+ "character": 2483
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2484,
+ "end": 2486,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2486,
+ "end": 2503,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 83,
+ "column": 2,
+ "character": 2487
+ },
+ "end": {
+ "line": 83,
+ "column": 5,
+ "character": 2490
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2491,
+ "end": 2497,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2503,
+ "end": 2505,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Comment",
+ "start": 2505,
+ "end": 2515,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 2515,
+ "end": 2516,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2522,
+ "end": 2523,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2523,
+ "end": 2554,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 86,
+ "column": 1,
+ "character": 2524
+ },
+ "end": {
+ "line": 86,
+ "column": 4,
+ "character": 2527
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2528,
+ "end": 2530,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Comment",
+ "start": 2530,
+ "end": 2540,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 2540,
+ "end": 2541,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "RegularElement",
+ "start": 2541,
+ "end": 2547,
+ "name": "br",
+ "name_loc": {
+ "start": {
+ "line": 87,
+ "column": 13,
+ "character": 2542
+ },
+ "end": {
+ "line": 87,
+ "column": 15,
+ "character": 2544
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2547,
+ "end": 2548,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2554,
+ "end": 2556,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 2556,
+ "end": 2663,
+ "data": " the width boundary: the comment and the inline block hug at exactly 100 chars and drop at\n 101 "
+ },
+ {
+ "type": "Text",
+ "start": 2663,
+ "end": 2664,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2664,
+ "end": 2776,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 92,
+ "column": 1,
+ "character": 2665
+ },
+ "end": {
+ "line": 92,
+ "column": 4,
+ "character": 2668
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2669,
+ "end": 2671,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2671,
+ "end": 2691,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 93,
+ "column": 2,
+ "character": 2672
+ },
+ "end": {
+ "line": 93,
+ "column": 6,
+ "character": 2676
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2677,
+ "end": 2684,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2691,
+ "end": 2692,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 2692,
+ "end": 2769,
+ "data": " cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc "
+ },
+ {
+ "type": "Text",
+ "start": 2769,
+ "end": 2770,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2776,
+ "end": 2777,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2777,
+ "end": 2891,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 95,
+ "column": 1,
+ "character": 2778
+ },
+ "end": {
+ "line": 95,
+ "column": 4,
+ "character": 2781
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2782,
+ "end": 2784,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2784,
+ "end": 2804,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 96,
+ "column": 2,
+ "character": 2785
+ },
+ "end": {
+ "line": 96,
+ "column": 6,
+ "character": 2789
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2790,
+ "end": 2797,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2804,
+ "end": 2806,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Comment",
+ "start": 2806,
+ "end": 2884,
+ "data": " ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc "
+ },
+ {
+ "type": "Text",
+ "start": 2884,
+ "end": 2885,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2891,
+ "end": 2892,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2892,
+ "end": 3004,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 99,
+ "column": 1,
+ "character": 2893
+ },
+ "end": {
+ "line": 99,
+ "column": 4,
+ "character": 2896
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2897,
+ "end": 2899,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2899,
+ "end": 2919,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 100,
+ "column": 2,
+ "character": 2900
+ },
+ "end": {
+ "line": 100,
+ "column": 6,
+ "character": 2904
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2905,
+ "end": 2912,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2919,
+ "end": 2920,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 2920,
+ "end": 2997,
+ "test": {
+ "type": "Identifier",
+ "start": 2925,
+ "end": 2929,
+ "loc": {
+ "start": {
+ "line": 100,
+ "column": 27
+ },
+ "end": {
+ "line": 100,
+ "column": 31
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2930,
+ "end": 2992,
+ "raw": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+ "data": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 2997,
+ "end": 2998,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 3004,
+ "end": 3005,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 3005,
+ "end": 3119,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 102,
+ "column": 1,
+ "character": 3006
+ },
+ "end": {
+ "line": 102,
+ "column": 4,
+ "character": 3009
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 3010,
+ "end": 3012,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 3012,
+ "end": 3032,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 103,
+ "column": 2,
+ "character": 3013
+ },
+ "end": {
+ "line": 103,
+ "column": 6,
+ "character": 3017
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 3018,
+ "end": 3025,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 3032,
+ "end": 3034,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 3034,
+ "end": 3112,
+ "test": {
+ "type": "Identifier",
+ "start": 3039,
+ "end": 3043,
+ "loc": {
+ "start": {
+ "line": 104,
+ "column": 6
+ },
+ "end": {
+ "line": 104,
+ "column": 10
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 3044,
+ "end": 3107,
+ "raw": "ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+ "data": "ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 3112,
+ "end": 3113,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ }
+ ]
+ },
+ "options": null,
+ "comments": []
+}
diff --git a/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/input.svelte
new file mode 100644
index 000000000..eb36aa70c
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/input.svelte
@@ -0,0 +1,105 @@
+<!--
+ The follower never turns a space into a newline either: a space before a COMMENT, a
+ `{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap
+ after any sibling, exactly as it already is after text — a comment's line is authorship, and
+ it is the NEWLINE spelling that holds it. Prettier keeps the space after text and breaks it
+ with the container after an element, a component or a tag.
+-->
+
+<!-- a comment after an inline element, a component and every tag kind: the space is kept -->
+<div>
+ <span>inline1</span> <!-- c -->
+ <Comp /> <!-- c -->
+ {expr} <!-- c -->
+ {@render fn()} <!-- c -->
+ {@html a} <!-- c -->
+</div>
+
+<!-- and after a bounding predecessor: an inline-rendering control-flow block, a <br />, a
+ control-flow block that renders multiline and an element that renders multiline -->
+<div>
+ {#if cond}text1{/if} <!-- c -->
+ text1 text2<br /> <!-- c -->
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if} <!-- c -->
+</div>
+<div>
+ <span>
+ <div>block1</div>
+ </span> <!-- c -->
+</div>
+
+<!-- the same at the root -->
+<span>inline1</span> <!-- c -->
+{expr} <!-- c -->
+
+<!-- a `{@debug}` is the same follower kind, after an element and after a tag at the root -->
+<div>
+ <span>inline1</span> {@debug a}
+</div>
+{expr} {@debug a}
+
+<!-- an inline-rendering control-flow block after an inline element, a tag, a component and a
+ comment — every block kind -->
+<div>
+ <span>inline1</span> {#if cond}text1{/if}
+ {expr} {#if cond}text1{/if}
+ <Comp /> {#each items as item}{item}{/each}
+ <!-- c --> {#if cond}text1{/if}
+ <span>inline1</span> {#await promise}text1{/await}
+ <span>inline1</span> {#key value}text1{/key}
+</div>
+
+<!-- a comment spaced on both sides, between two tags, two components and two elements, at the
+ root: both spaces are kept -->
+{expr1} <!-- c --> {expr2}
+<Comp1 /> <!-- c --> <Comp2 />
+<span>inline1</span> <!-- c --> <span>inline2</span>
+
+<!-- two comments: the second keeps its space after the first -->
+<div>
+ <!-- c1 --> <!-- c2 -->
+</div>
+
+<!-- parity controls: after TEXT both formatters keep the space already -->
+<div>
+ text1 text2 <!-- c -->
+ text1 text2 {#if cond}text1{/if}
+</div>
+
+<!-- controls: a control-flow block that renders multiline drops to a fresh line whole, a
+ block element predecessor keeps the comment off its line, and a <br /> after a comment
+ takes its wrap — under both formatters -->
+<div>
+ <span>inline1</span>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+</div>
+<div>
+ <div>block1</div>
+ <!-- c -->
+</div>
+<div>
+ <!-- c --> <br />
+</div>
+
+<!-- the width boundary: the comment and the inline block hug at exactly 100 chars and drop at
+ 101 -->
+<div>
+ <span>inline1</span> <!-- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span>
+ <!-- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span> {#if cond}cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
+<div>
+ <span>inline1</span>
+ {#if cond}ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..1c47cee3e
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,132 @@
+<!--
+ The follower never turns a space into a newline either: a space before a COMMENT, a
+ `{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap
+ after any sibling, exactly as it already is after text — a comment's line is authorship, and
+ it is the NEWLINE spelling that holds it. Prettier keeps the space after text and breaks it
+ with the container after an element, a component or a tag.
+-->
+
+<!-- a comment after an inline element, a component and every tag kind: the space is kept -->
+<div>
+ <span>inline1</span>
+ <!-- c -->
+ <Comp />
+ <!-- c -->
+ {expr}
+ <!-- c -->
+ {@render fn()}
+ <!-- c -->
+ {@html a}
+ <!-- c -->
+</div>
+
+<!-- and after a bounding predecessor: an inline-rendering control-flow block, a <br />, a
+ control-flow block that renders multiline and an element that renders multiline -->
+<div>
+ {#if cond}text1{/if}
+ <!-- c -->
+ text1 text2<br />
+ <!-- c -->
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ <!-- c -->
+</div>
+<div>
+ <span>
+ <div>block1</div>
+ </span>
+ <!-- c -->
+</div>
+
+<!-- the same at the root -->
+<span>inline1</span>
+<!-- c -->
+{expr}
+<!-- c -->
+
+<!-- a `{@debug}` is the same follower kind, after an element and after a tag at the root -->
+<div>
+ <span>inline1</span>
+ {@debug a}
+</div>
+{expr}
+{@debug a}
+
+<!-- an inline-rendering control-flow block after an inline element, a tag, a component and a
+ comment — every block kind -->
+<div>
+ <span>inline1</span>
+ {#if cond}text1{/if}
+ {expr}
+ {#if cond}text1{/if}
+ <Comp />
+ {#each items as item}{item}{/each}
+ <!-- c -->
+ {#if cond}text1{/if}
+ <span>inline1</span>
+ {#await promise}text1{/await}
+ <span>inline1</span>
+ {#key value}text1{/key}
+</div>
+
+<!-- a comment spaced on both sides, between two tags, two components and two elements, at the
+ root: both spaces are kept -->
+{expr1}
+<!-- c -->
+{expr2}
+<Comp1 />
+<!-- c -->
+<Comp2 />
+<span>inline1</span>
+<!-- c --> <span>inline2</span>
+
+<!-- two comments: the second keeps its space after the first -->
+<div>
+ <!-- c1 -->
+ <!-- c2 -->
+</div>
+
+<!-- parity controls: after TEXT both formatters keep the space already -->
+<div>
+ text1 text2 <!-- c -->
+ text1 text2 {#if cond}text1{/if}
+</div>
+
+<!-- controls: a control-flow block that renders multiline drops to a fresh line whole, a
+ block element predecessor keeps the comment off its line, and a <br /> after a comment
+ takes its wrap — under both formatters -->
+<div>
+ <span>inline1</span>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+</div>
+<div>
+ <div>block1</div>
+ <!-- c -->
+</div>
+<div>
+ <!-- c --> <br />
+</div>
+
+<!-- the width boundary: the comment and the inline block hug at exactly 100 chars and drop at
+ 101 -->
+<div>
+ <span>inline1</span>
+ <!-- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span>
+ <!-- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span>
+ {#if cond}cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
+<div>
+ <span>inline1</span>
+ {#if cond}ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/unformatted_ours_boundary_space.svelte b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/unformatted_ours_boundary_space.svelte
new file mode 100644
index 000000000..1fe0d607e
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/unformatted_ours_boundary_space.svelte
@@ -0,0 +1,101 @@
+<!--
+ The follower never turns a space into a newline either: a space before a COMMENT, a
+ `{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap
+ after any sibling, exactly as it already is after text — a comment's line is authorship, and
+ it is the NEWLINE spelling that holds it. Prettier keeps the space after text and breaks it
+ with the container after an element, a component or a tag.
+-->
+
+<!-- a comment after an inline element, a component and every tag kind: the space is kept -->
+<div>
+ <span>inline1</span> <!-- c -->
+ <Comp /> <!-- c -->
+ {expr} <!-- c -->
+ {@render fn()} <!-- c -->
+ {@html a} <!-- c -->
+</div>
+
+<!-- and after a bounding predecessor: an inline-rendering control-flow block, a <br />, a
+ control-flow block that renders multiline and an element that renders multiline -->
+<div>
+ {#if cond}text1{/if} <!-- c -->
+ text1 text2<br /> <!-- c -->
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if} <!-- c -->
+</div>
+<div>
+ <span>
+ <div>block1</div>
+ </span> <!-- c -->
+</div>
+
+<!-- the same at the root -->
+<span>inline1</span> <!-- c -->
+{expr} <!-- c -->
+
+<!-- a `{@debug}` is the same follower kind, after an element and after a tag at the root -->
+<div>
+ <span>inline1</span> {@debug a}
+</div>
+{expr} {@debug a}
+
+<!-- an inline-rendering control-flow block after an inline element, a tag, a component and a
+ comment — every block kind -->
+<div>
+ <span>inline1</span> {#if cond}text1{/if}
+ {expr} {#if cond}text1{/if}
+ <Comp /> {#each items as item}{item}{/each}
+ <!-- c --> {#if cond}text1{/if}
+ <span>inline1</span> {#await promise}text1{/await}
+ <span>inline1</span> {#key value}text1{/key}
+</div>
+
+<!-- a comment spaced on both sides, between two tags, two components and two elements, at the
+ root: both spaces are kept -->
+{expr1} <!-- c --> {expr2}
+<Comp1 /> <!-- c --> <Comp2 />
+<span>inline1</span> <!-- c --> <span>inline2</span>
+
+<!-- two comments: the second keeps its space after the first -->
+<div>
+ <!-- c1 --> <!-- c2 -->
+</div>
+
+<!-- parity controls: after TEXT both formatters keep the space already -->
+<div>
+ text1 text2 <!-- c -->
+ text1 text2 {#if cond}text1{/if}
+</div>
+
+<!-- controls: a control-flow block that renders multiline drops to a fresh line whole, a
+ block element predecessor keeps the comment off its line, and a <br /> after a comment
+ takes its wrap — under both formatters -->
+<div>
+ <span>inline1</span> {#if cond}
+ <div>block1</div>
+ {/if}
+</div>
+<div>
+ <div>block1</div> <!-- c -->
+</div>
+<div>
+ <!-- c --> <br />
+</div>
+
+<!-- the width boundary: the comment and the inline block hug at exactly 100 chars and drop at
+ 101 -->
+<div>
+ <span>inline1</span> <!-- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span> <!-- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span> {#if cond}cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
+<div>
+ <span>inline1</span> {#if cond}ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/unformatted_ours_spaces.svelte b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/unformatted_ours_spaces.svelte
new file mode 100644
index 000000000..5131647aa
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/unformatted_ours_spaces.svelte
@@ -0,0 +1,105 @@
+<!--
+ The follower never turns a space into a newline either: a space before a COMMENT, a
+ `{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap
+ after any sibling, exactly as it already is after text — a comment's line is authorship, and
+ it is the NEWLINE spelling that holds it. Prettier keeps the space after text and breaks it
+ with the container after an element, a component or a tag.
+-->
+
+<!-- a comment after an inline element, a component and every tag kind: the space is kept -->
+<div>
+ <span>inline1</span> <!-- c -->
+ <Comp /> <!-- c -->
+ {expr} <!-- c -->
+ {@render fn()} <!-- c -->
+ {@html a} <!-- c -->
+</div>
+
+<!-- and after a bounding predecessor: an inline-rendering control-flow block, a <br />, a
+ control-flow block that renders multiline and an element that renders multiline -->
+<div>
+ {#if cond}text1{/if} <!-- c -->
+ text1 text2<br /> <!-- c -->
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if} <!-- c -->
+</div>
+<div>
+ <span>
+ <div>block1</div>
+ </span> <!-- c -->
+</div>
+
+<!-- the same at the root -->
+<span>inline1</span> <!-- c -->
+{expr} <!-- c -->
+
+<!-- a `{@debug}` is the same follower kind, after an element and after a tag at the root -->
+<div>
+ <span>inline1</span> {@debug a}
+</div>
+{expr} {@debug a}
+
+<!-- an inline-rendering control-flow block after an inline element, a tag, a component and a
+ comment — every block kind -->
+<div>
+ <span>inline1</span> {#if cond}text1{/if}
+ {expr} {#if cond}text1{/if}
+ <Comp /> {#each items as item}{item}{/each}
+ <!-- c --> {#if cond}text1{/if}
+ <span>inline1</span> {#await promise}text1{/await}
+ <span>inline1</span> {#key value}text1{/key}
+</div>
+
+<!-- a comment spaced on both sides, between two tags, two components and two elements, at the
+ root: both spaces are kept -->
+{expr1} <!-- c --> {expr2}
+<Comp1 /> <!-- c --> <Comp2 />
+<span>inline1</span> <!-- c --> <span>inline2</span>
+
+<!-- two comments: the second keeps its space after the first -->
+<div>
+ <!-- c1 --> <!-- c2 -->
+</div>
+
+<!-- parity controls: after TEXT both formatters keep the space already -->
+<div>
+ text1 text2 <!-- c -->
+ text1 text2 {#if cond}text1{/if}
+</div>
+
+<!-- controls: a control-flow block that renders multiline drops to a fresh line whole, a
+ block element predecessor keeps the comment off its line, and a <br /> after a comment
+ takes its wrap — under both formatters -->
+<div>
+ <span>inline1</span>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+</div>
+<div>
+ <div>block1</div>
+ <!-- c -->
+</div>
+<div>
+ <!-- c --> <br />
+</div>
+
+<!-- the width boundary: the comment and the inline block hug at exactly 100 chars and drop at
+ 101 -->
+<div>
+ <span>inline1</span> <!-- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span>
+ <!-- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span> {#if cond}cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
+<div>
+ <span>inline1</span>
+ {#if cond}ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/variant_newline.svelte b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/variant_newline.svelte
new file mode 100644
index 000000000..a992056e6
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/variant_newline.svelte
@@ -0,0 +1,136 @@
+<!--
+ The follower never turns a space into a newline either: a space before a COMMENT, a
+ `{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap
+ after any sibling, exactly as it already is after text — a comment's line is authorship, and
+ it is the NEWLINE spelling that holds it. Prettier keeps the space after text and breaks it
+ with the container after an element, a component or a tag.
+-->
+
+<!-- a comment after an inline element, a component and every tag kind: the space is kept -->
+<div>
+ <span>inline1</span>
+ <!-- c -->
+ <Comp />
+ <!-- c -->
+ {expr}
+ <!-- c -->
+ {@render fn()}
+ <!-- c -->
+ {@html a}
+ <!-- c -->
+</div>
+
+<!-- and after a bounding predecessor: an inline-rendering control-flow block, a <br />, a
+ control-flow block that renders multiline and an element that renders multiline -->
+<div>
+ {#if cond}text1{/if}
+ <!-- c -->
+ text1 text2<br />
+ <!-- c -->
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ <!-- c -->
+</div>
+<div>
+ <span>
+ <div>block1</div>
+ </span>
+ <!-- c -->
+</div>
+
+<!-- the same at the root -->
+<span>inline1</span>
+<!-- c -->
+{expr}
+<!-- c -->
+
+<!-- a `{@debug}` is the same follower kind, after an element and after a tag at the root -->
+<div>
+ <span>inline1</span>
+ {@debug a}
+</div>
+{expr}
+{@debug a}
+
+<!-- an inline-rendering control-flow block after an inline element, a tag, a component and a
+ comment — every block kind -->
+<div>
+ <span>inline1</span>
+ {#if cond}text1{/if}
+ {expr}
+ {#if cond}text1{/if}
+ <Comp />
+ {#each items as item}{item}{/each}
+ <!-- c -->
+ {#if cond}text1{/if}
+ <span>inline1</span>
+ {#await promise}text1{/await}
+ <span>inline1</span>
+ {#key value}text1{/key}
+</div>
+
+<!-- a comment spaced on both sides, between two tags, two components and two elements, at the
+ root: both spaces are kept -->
+{expr1}
+<!-- c -->
+{expr2}
+<Comp1 />
+<!-- c -->
+<Comp2 />
+<span>inline1</span>
+<!-- c -->
+<span>inline2</span>
+
+<!-- two comments: the second keeps its space after the first -->
+<div>
+ <!-- c1 -->
+ <!-- c2 -->
+</div>
+
+<!-- parity controls: after TEXT both formatters keep the space already -->
+<div>
+ text1 text2
+ <!-- c -->
+ text1 text2
+ {#if cond}text1{/if}
+</div>
+
+<!-- controls: a control-flow block that renders multiline drops to a fresh line whole, a
+ block element predecessor keeps the comment off its line, and a <br /> after a comment
+ takes its wrap — under both formatters -->
+<div>
+ <span>inline1</span>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+</div>
+<div>
+ <div>block1</div>
+ <!-- c -->
+</div>
+<div>
+ <!-- c -->
+ <br />
+</div>
+
+<!-- the width boundary: the comment and the inline block hug at exactly 100 chars and drop at
+ 101 -->
+<div>
+ <span>inline1</span>
+ <!-- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span>
+ <!-- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span>
+ {#if cond}cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
+<div>
+ <span>inline1</span>
+ {#if cond}ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/variant_prettier_split.svelte b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/variant_prettier_split.svelte
new file mode 100644
index 000000000..1c47cee3e
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/variant_prettier_split.svelte
@@ -0,0 +1,132 @@
+<!--
+ The follower never turns a space into a newline either: a space before a COMMENT, a
+ `{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap
+ after any sibling, exactly as it already is after text — a comment's line is authorship, and
+ it is the NEWLINE spelling that holds it. Prettier keeps the space after text and breaks it
+ with the container after an element, a component or a tag.
+-->
+
+<!-- a comment after an inline element, a component and every tag kind: the space is kept -->
+<div>
+ <span>inline1</span>
+ <!-- c -->
+ <Comp />
+ <!-- c -->
+ {expr}
+ <!-- c -->
+ {@render fn()}
+ <!-- c -->
+ {@html a}
+ <!-- c -->
+</div>
+
+<!-- and after a bounding predecessor: an inline-rendering control-flow block, a <br />, a
+ control-flow block that renders multiline and an element that renders multiline -->
+<div>
+ {#if cond}text1{/if}
+ <!-- c -->
+ text1 text2<br />
+ <!-- c -->
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ <!-- c -->
+</div>
+<div>
+ <span>
+ <div>block1</div>
+ </span>
+ <!-- c -->
+</div>
+
+<!-- the same at the root -->
+<span>inline1</span>
+<!-- c -->
+{expr}
+<!-- c -->
+
+<!-- a `{@debug}` is the same follower kind, after an element and after a tag at the root -->
+<div>
+ <span>inline1</span>
+ {@debug a}
+</div>
+{expr}
+{@debug a}
+
+<!-- an inline-rendering control-flow block after an inline element, a tag, a component and a
+ comment — every block kind -->
+<div>
+ <span>inline1</span>
+ {#if cond}text1{/if}
+ {expr}
+ {#if cond}text1{/if}
+ <Comp />
+ {#each items as item}{item}{/each}
+ <!-- c -->
+ {#if cond}text1{/if}
+ <span>inline1</span>
+ {#await promise}text1{/await}
+ <span>inline1</span>
+ {#key value}text1{/key}
+</div>
+
+<!-- a comment spaced on both sides, between two tags, two components and two elements, at the
+ root: both spaces are kept -->
+{expr1}
+<!-- c -->
+{expr2}
+<Comp1 />
+<!-- c -->
+<Comp2 />
+<span>inline1</span>
+<!-- c --> <span>inline2</span>
+
+<!-- two comments: the second keeps its space after the first -->
+<div>
+ <!-- c1 -->
+ <!-- c2 -->
+</div>
+
+<!-- parity controls: after TEXT both formatters keep the space already -->
+<div>
+ text1 text2 <!-- c -->
+ text1 text2 {#if cond}text1{/if}
+</div>
+
+<!-- controls: a control-flow block that renders multiline drops to a fresh line whole, a
+ block element predecessor keeps the comment off its line, and a <br /> after a comment
+ takes its wrap — under both formatters -->
+<div>
+ <span>inline1</span>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+</div>
+<div>
+ <div>block1</div>
+ <!-- c -->
+</div>
+<div>
+ <!-- c --> <br />
+</div>
+
+<!-- the width boundary: the comment and the inline block hug at exactly 100 chars and drop at
+ 101 -->
+<div>
+ <span>inline1</span>
+ <!-- cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span>
+ <!-- ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc -->
+</div>
+<div>
+ <span>inline1</span>
+ {#if cond}cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
+<div>
+ <span>inline1</span>
+ {#if cond}ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc{/if}
+</div>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/README.md
new file mode 100644
index 000000000..40c29d1ec
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/README.md
@@ -0,0 +1,48 @@
+# inline_tag_pair_space_bounded_prettier_divergence
+
+**The predecessor never decides a space.** A space-spelled tag pair after a comment, a `<br />`,
+a control-flow block that renders multiline, or an inline element that renders multiline keeps
+its authored space: the separator before the first tag is that tag's own per-width wrap, exactly
+what an inline element or component takes at the same boundary (`<!-- c --> <span>x</span>` and
+`{/if} <span>x</span>` hug under both formatters), so the pair stays on its neighbour's line and
+packs. Prettier's bare `line` between a tag and its neighbour breaks with the multiline
+container, so it splits every one of them (`output_prettier.svelte`). The **newline** spelling of
+each boundary is held — the sibling-newline flow rule excludes those neighbours — so the two
+spellings are two fixed points, the dual stability `variant_space` carries everywhere else.
+
+The follower does not decide it either: the pair keeps its space before a comment and before an
+inline-rendering control-flow block, which take that space as their own per-width wrap
+([inline_sibling_space_before_bounding](../inline_sibling_space_before_bounding_prettier_divergence/)).
+Only two things still break a space, under both formatters: a **block element** predecessor, whose
+own break keeps the tag off its line, and a **declaration tag**, which takes its own line by its
+own rule. A spaced `<br />` between two tags stays on one line: it is inline flow content on both
+of its sides.
+
+`unformatted_ours_line_owner_space.svelte` spells each of those breaking separators as a space;
+tsv breaks them back and keeps every pair packed, normalizing to `input.svelte` in one pass,
+while prettier splits the pairs as well (`divergent_variant_line_owner_space.svelte`).
+
+`variant_split.svelte` is prettier's form itself, and tsv keeps it stable too — the newline spelling of
+every boundary is held — so the two forms are two fixed points; a rule change that started
+normalizing prettier's form back to `input.svelte` fails this file rather than passing in prose.
+
+## Reason
+
+Design choice — the rule of
+[inline_tag_pair_space](../inline_tag_pair_space_prettier_divergence/) with its last gate removed:
+a space before a tag asks nothing about what precedes it, as a space before an inline element or
+component never did. Gating it on the predecessor's kind was the one place a space still turned
+into a newline the author did not write — a forced break, in a rule family whose whole thesis is
+that the prose gate holds an authored newline and never forces one — and it was prettier's
+`line`-between-tags rule surviving for one neighbour class after being dropped for the rest. A
+comment's line is authorship
+([§Comment Position Philosophy](../../../../../docs/conformance_prettier.md#comment-position-philosophy)),
+and that is exactly what the NEWLINE spelling holds; an authored space beside the comment is the
+author's too, and tsv already kept it for text, an element and a component. The boundary set is
+the flow rule's own
+([inline_sibling_newline_run_bounded](../inline_sibling_newline_run_bounded_prettier_divergence/)
+holds the newline spellings across it); the multiline-predecessor pair is the tag twin of
+[inline_adjacent_component_after_multiline](../inline_adjacent_component_after_multiline_prettier_divergence/).
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/divergent_variant_line_owner_space.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/divergent_variant_line_owner_space.svelte
new file mode 100644
index 000000000..594719577
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/divergent_variant_line_owner_space.svelte
@@ -0,0 +1,98 @@
+<!--
+ The predecessor never decides a space: a tag after a comment, a <br />, a control-flow
+ block or a predecessor that renders multiline takes its per-width wrap exactly as an inline
+ element or component does there, so the authored space is kept and the pair packs — where
+ prettier breaks its line between two tags with the container. The newline spelling of the
+ same boundary is held, so the two spellings are two fixed points. Only a block element
+ predecessor keeps the tag off its line; a comment or a control-flow block after the pair
+ takes the space as its own per-width wrap (inline_sibling_space_before_bounding); a
+ declaration tag takes its own line.
+-->
+
+<!-- after a comment: the space spelling hugs, the newline spelling is held; and at the root -->
+<p>
+ <!-- c -->
+ {expr1}
+ {expr2}
+</p>
+<p>
+ <!-- c -->
+ {expr1}
+ {expr2}
+</p>
+<!-- c -->
+{expr1}
+{expr2}
+
+<!-- before a comment, and before a control-flow block that renders inline: the pair keeps its
+ space there too — the follower's own per-width wrap, as after text -->
+<p>
+ {expr1}
+ {expr2}
+ <!-- c -->
+</p>
+<p>
+ {expr1}
+ {expr2}
+ {#if cond}text1{/if}
+</p>
+
+<!-- after a <br />, both spellings, and a spaced <br /> between two tags -->
+<p>
+ text1 text2<br />
+ {expr1}
+ {expr2}
+</p>
+<p>
+ text1 text2<br />
+ {expr1}
+ {expr2}
+</p>
+<p>
+ {expr1} <br />
+ {expr2}
+</p>
+
+<!-- after a block element, whose own break keeps the tag off its line -->
+<div>
+ <div>block1</div>
+ {expr1}
+ {expr2}
+</div>
+
+<!-- after a control-flow block that renders multiline, both spellings, and after a declaration
+ tag, which takes its own line -->
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ {expr1}
+ {expr2}
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ {expr1}
+ {expr2}
+</div>
+{#if cond}
+ {@const x = expr} {expr1} {expr2}
+{/if}
+
+<!-- after a predecessor that renders multiline: the space spelling hugs its closing tag, as an
+ element or component does there, and the newline spelling is held -->
+<p>
+ <span>
+ <div>block1</div>
+ </span>
+ {expr1}
+ {expr2}
+</p>
+<p>
+ <span>
+ <div>block1</div>
+ </span>
+ {expr1}
+ {expr2}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/expected.json
new file mode 100644
index 000000000..bc1be1799
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/expected.json
@@ -0,0 +1,1973 @@
+{
+ "css": null,
+ "js": [],
+ "start": 0,
+ "end": 2077,
+ "type": "Root",
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Comment",
+ "start": 0,
+ "end": 671,
+ "data": "\n\tThe predecessor never decides a space: a tag after a comment, a <br />, a control-flow\n\tblock or a predecessor that renders multiline takes its per-width wrap exactly as an inline\n\telement or component does there, so the authored space is kept and the pair packs — where\n\tprettier breaks its line between two tags with the container. The newline spelling of the\n\tsame boundary is held, so the two spellings are two fixed points. Only a block element\n\tpredecessor keeps the tag off its line; a comment or a control-flow block after the pair\n\ttakes the space as its own per-width wrap (inline_sibling_space_before_bounding); a\n\tdeclaration tag takes its own line.\n"
+ },
+ {
+ "type": "Text",
+ "start": 671,
+ "end": 673,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 673,
+ "end": 769,
+ "data": " after a comment: the space spelling hugs, the newline spelling is held; and at the root "
+ },
+ {
+ "type": "Text",
+ "start": 769,
+ "end": 770,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 770,
+ "end": 806,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 13,
+ "column": 1,
+ "character": 771
+ },
+ "end": {
+ "line": 13,
+ "column": 2,
+ "character": 772
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 773,
+ "end": 775,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Comment",
+ "start": 775,
+ "end": 785,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 785,
+ "end": 786,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 786,
+ "end": 793,
+ "expression": {
+ "type": "Identifier",
+ "start": 787,
+ "end": 792,
+ "loc": {
+ "start": {
+ "line": 14,
+ "column": 13
+ },
+ "end": {
+ "line": 14,
+ "column": 18
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 793,
+ "end": 794,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 794,
+ "end": 801,
+ "expression": {
+ "type": "Identifier",
+ "start": 795,
+ "end": 800,
+ "loc": {
+ "start": {
+ "line": 14,
+ "column": 21
+ },
+ "end": {
+ "line": 14,
+ "column": 26
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 801,
+ "end": 802,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 806,
+ "end": 807,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 807,
+ "end": 844,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 16,
+ "column": 1,
+ "character": 808
+ },
+ "end": {
+ "line": 16,
+ "column": 2,
+ "character": 809
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 810,
+ "end": 812,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Comment",
+ "start": 812,
+ "end": 822,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 822,
+ "end": 824,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 824,
+ "end": 831,
+ "expression": {
+ "type": "Identifier",
+ "start": 825,
+ "end": 830,
+ "loc": {
+ "start": {
+ "line": 18,
+ "column": 2
+ },
+ "end": {
+ "line": 18,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 831,
+ "end": 832,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 832,
+ "end": 839,
+ "expression": {
+ "type": "Identifier",
+ "start": 833,
+ "end": 838,
+ "loc": {
+ "start": {
+ "line": 18,
+ "column": 10
+ },
+ "end": {
+ "line": 18,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 839,
+ "end": 840,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 844,
+ "end": 845,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "Comment",
+ "start": 845,
+ "end": 855,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 855,
+ "end": 856,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 856,
+ "end": 863,
+ "expression": {
+ "type": "Identifier",
+ "start": 857,
+ "end": 862,
+ "loc": {
+ "start": {
+ "line": 20,
+ "column": 12
+ },
+ "end": {
+ "line": 20,
+ "column": 17
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 863,
+ "end": 864,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 864,
+ "end": 871,
+ "expression": {
+ "type": "Identifier",
+ "start": 865,
+ "end": 870,
+ "loc": {
+ "start": {
+ "line": 20,
+ "column": 20
+ },
+ "end": {
+ "line": 20,
+ "column": 25
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 871,
+ "end": 873,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 873,
+ "end": 1043,
+ "data": " before a comment, and before a control-flow block that renders inline: the pair keeps its\n space there too — the follower's own per-width wrap, as after text "
+ },
+ {
+ "type": "Text",
+ "start": 1043,
+ "end": 1044,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1044,
+ "end": 1080,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 24,
+ "column": 1,
+ "character": 1045
+ },
+ "end": {
+ "line": 24,
+ "column": 2,
+ "character": 1046
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1047,
+ "end": 1049,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1049,
+ "end": 1056,
+ "expression": {
+ "type": "Identifier",
+ "start": 1050,
+ "end": 1055,
+ "loc": {
+ "start": {
+ "line": 25,
+ "column": 2
+ },
+ "end": {
+ "line": 25,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1056,
+ "end": 1057,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1057,
+ "end": 1064,
+ "expression": {
+ "type": "Identifier",
+ "start": 1058,
+ "end": 1063,
+ "loc": {
+ "start": {
+ "line": 25,
+ "column": 10
+ },
+ "end": {
+ "line": 25,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1064,
+ "end": 1065,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Comment",
+ "start": 1065,
+ "end": 1075,
+ "data": " c "
+ },
+ {
+ "type": "Text",
+ "start": 1075,
+ "end": 1076,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1080,
+ "end": 1081,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1081,
+ "end": 1127,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 27,
+ "column": 1,
+ "character": 1082
+ },
+ "end": {
+ "line": 27,
+ "column": 2,
+ "character": 1083
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1084,
+ "end": 1086,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1086,
+ "end": 1093,
+ "expression": {
+ "type": "Identifier",
+ "start": 1087,
+ "end": 1092,
+ "loc": {
+ "start": {
+ "line": 28,
+ "column": 2
+ },
+ "end": {
+ "line": 28,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1093,
+ "end": 1094,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1094,
+ "end": 1101,
+ "expression": {
+ "type": "Identifier",
+ "start": 1095,
+ "end": 1100,
+ "loc": {
+ "start": {
+ "line": 28,
+ "column": 10
+ },
+ "end": {
+ "line": 28,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1101,
+ "end": 1102,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 1102,
+ "end": 1122,
+ "test": {
+ "type": "Identifier",
+ "start": 1107,
+ "end": 1111,
+ "loc": {
+ "start": {
+ "line": 28,
+ "column": 22
+ },
+ "end": {
+ "line": 28,
+ "column": 26
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1112,
+ "end": 1117,
+ "raw": "text1",
+ "data": "text1"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 1122,
+ "end": 1123,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1127,
+ "end": 1129,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1129,
+ "end": 1206,
+ "data": " after a <br />, both spellings, and a spaced <br /> between two tags "
+ },
+ {
+ "type": "Text",
+ "start": 1206,
+ "end": 1207,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1207,
+ "end": 1250,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 32,
+ "column": 1,
+ "character": 1208
+ },
+ "end": {
+ "line": 32,
+ "column": 2,
+ "character": 1209
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1210,
+ "end": 1223,
+ "raw": "\n\ttext1 text2",
+ "data": "\n\ttext1 text2"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1223,
+ "end": 1229,
+ "name": "br",
+ "name_loc": {
+ "start": {
+ "line": 33,
+ "column": 13,
+ "character": 1224
+ },
+ "end": {
+ "line": 33,
+ "column": 15,
+ "character": 1226
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1229,
+ "end": 1230,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1230,
+ "end": 1237,
+ "expression": {
+ "type": "Identifier",
+ "start": 1231,
+ "end": 1236,
+ "loc": {
+ "start": {
+ "line": 33,
+ "column": 20
+ },
+ "end": {
+ "line": 33,
+ "column": 25
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1237,
+ "end": 1238,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1238,
+ "end": 1245,
+ "expression": {
+ "type": "Identifier",
+ "start": 1239,
+ "end": 1244,
+ "loc": {
+ "start": {
+ "line": 33,
+ "column": 28
+ },
+ "end": {
+ "line": 33,
+ "column": 33
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1245,
+ "end": 1246,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1250,
+ "end": 1251,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1251,
+ "end": 1295,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 35,
+ "column": 1,
+ "character": 1252
+ },
+ "end": {
+ "line": 35,
+ "column": 2,
+ "character": 1253
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1254,
+ "end": 1267,
+ "raw": "\n\ttext1 text2",
+ "data": "\n\ttext1 text2"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1267,
+ "end": 1273,
+ "name": "br",
+ "name_loc": {
+ "start": {
+ "line": 36,
+ "column": 13,
+ "character": 1268
+ },
+ "end": {
+ "line": 36,
+ "column": 15,
+ "character": 1270
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1273,
+ "end": 1275,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1275,
+ "end": 1282,
+ "expression": {
+ "type": "Identifier",
+ "start": 1276,
+ "end": 1281,
+ "loc": {
+ "start": {
+ "line": 37,
+ "column": 2
+ },
+ "end": {
+ "line": 37,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1282,
+ "end": 1283,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1283,
+ "end": 1290,
+ "expression": {
+ "type": "Identifier",
+ "start": 1284,
+ "end": 1289,
+ "loc": {
+ "start": {
+ "line": 37,
+ "column": 10
+ },
+ "end": {
+ "line": 37,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1290,
+ "end": 1291,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1295,
+ "end": 1296,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1296,
+ "end": 1328,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 39,
+ "column": 1,
+ "character": 1297
+ },
+ "end": {
+ "line": 39,
+ "column": 2,
+ "character": 1298
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1299,
+ "end": 1301,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1301,
+ "end": 1308,
+ "expression": {
+ "type": "Identifier",
+ "start": 1302,
+ "end": 1307,
+ "loc": {
+ "start": {
+ "line": 40,
+ "column": 2
+ },
+ "end": {
+ "line": 40,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1308,
+ "end": 1309,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "RegularElement",
+ "start": 1309,
+ "end": 1315,
+ "name": "br",
+ "name_loc": {
+ "start": {
+ "line": 40,
+ "column": 10,
+ "character": 1310
+ },
+ "end": {
+ "line": 40,
+ "column": 12,
+ "character": 1312
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1315,
+ "end": 1316,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1316,
+ "end": 1323,
+ "expression": {
+ "type": "Identifier",
+ "start": 1317,
+ "end": 1322,
+ "loc": {
+ "start": {
+ "line": 40,
+ "column": 17
+ },
+ "end": {
+ "line": 40,
+ "column": 22
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1323,
+ "end": 1324,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1328,
+ "end": 1330,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1330,
+ "end": 1404,
+ "data": " after a block element, whose own break keeps the tag off its line "
+ },
+ {
+ "type": "Text",
+ "start": 1404,
+ "end": 1405,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1405,
+ "end": 1453,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 44,
+ "column": 1,
+ "character": 1406
+ },
+ "end": {
+ "line": 44,
+ "column": 4,
+ "character": 1409
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1410,
+ "end": 1412,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1412,
+ "end": 1429,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 45,
+ "column": 2,
+ "character": 1413
+ },
+ "end": {
+ "line": 45,
+ "column": 5,
+ "character": 1416
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1417,
+ "end": 1423,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1429,
+ "end": 1431,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1431,
+ "end": 1438,
+ "expression": {
+ "type": "Identifier",
+ "start": 1432,
+ "end": 1437,
+ "loc": {
+ "start": {
+ "line": 46,
+ "column": 2
+ },
+ "end": {
+ "line": 46,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1438,
+ "end": 1439,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1439,
+ "end": 1446,
+ "expression": {
+ "type": "Identifier",
+ "start": 1440,
+ "end": 1445,
+ "loc": {
+ "start": {
+ "line": 46,
+ "column": 10
+ },
+ "end": {
+ "line": 46,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1446,
+ "end": 1447,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1453,
+ "end": 1455,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1455,
+ "end": 1589,
+ "data": " after a control-flow block that renders multiline, both spellings, and after a declaration\n tag, which takes its own line "
+ },
+ {
+ "type": "Text",
+ "start": 1589,
+ "end": 1590,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1590,
+ "end": 1657,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 51,
+ "column": 1,
+ "character": 1591
+ },
+ "end": {
+ "line": 51,
+ "column": 4,
+ "character": 1594
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1595,
+ "end": 1597,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 1597,
+ "end": 1634,
+ "test": {
+ "type": "Identifier",
+ "start": 1602,
+ "end": 1606,
+ "loc": {
+ "start": {
+ "line": 52,
+ "column": 6
+ },
+ "end": {
+ "line": 52,
+ "column": 10
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1607,
+ "end": 1610,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1610,
+ "end": 1627,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 53,
+ "column": 3,
+ "character": 1611
+ },
+ "end": {
+ "line": 53,
+ "column": 6,
+ "character": 1614
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1615,
+ "end": 1621,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1627,
+ "end": 1629,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 1634,
+ "end": 1635,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1635,
+ "end": 1642,
+ "expression": {
+ "type": "Identifier",
+ "start": 1636,
+ "end": 1641,
+ "loc": {
+ "start": {
+ "line": 54,
+ "column": 8
+ },
+ "end": {
+ "line": 54,
+ "column": 13
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1642,
+ "end": 1643,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1643,
+ "end": 1650,
+ "expression": {
+ "type": "Identifier",
+ "start": 1644,
+ "end": 1649,
+ "loc": {
+ "start": {
+ "line": 54,
+ "column": 16
+ },
+ "end": {
+ "line": 54,
+ "column": 21
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1650,
+ "end": 1651,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1657,
+ "end": 1658,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1658,
+ "end": 1726,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 56,
+ "column": 1,
+ "character": 1659
+ },
+ "end": {
+ "line": 56,
+ "column": 4,
+ "character": 1662
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1663,
+ "end": 1665,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 1665,
+ "end": 1702,
+ "test": {
+ "type": "Identifier",
+ "start": 1670,
+ "end": 1674,
+ "loc": {
+ "start": {
+ "line": 57,
+ "column": 6
+ },
+ "end": {
+ "line": 57,
+ "column": 10
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1675,
+ "end": 1678,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1678,
+ "end": 1695,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 58,
+ "column": 3,
+ "character": 1679
+ },
+ "end": {
+ "line": 58,
+ "column": 6,
+ "character": 1682
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1683,
+ "end": 1689,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1695,
+ "end": 1697,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 1702,
+ "end": 1704,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1704,
+ "end": 1711,
+ "expression": {
+ "type": "Identifier",
+ "start": 1705,
+ "end": 1710,
+ "loc": {
+ "start": {
+ "line": 60,
+ "column": 2
+ },
+ "end": {
+ "line": 60,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1711,
+ "end": 1712,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1712,
+ "end": 1719,
+ "expression": {
+ "type": "Identifier",
+ "start": 1713,
+ "end": 1718,
+ "loc": {
+ "start": {
+ "line": 60,
+ "column": 10
+ },
+ "end": {
+ "line": 60,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1719,
+ "end": 1720,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1726,
+ "end": 1727,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 1727,
+ "end": 1779,
+ "test": {
+ "type": "Identifier",
+ "start": 1732,
+ "end": 1736,
+ "loc": {
+ "start": {
+ "line": 62,
+ "column": 5
+ },
+ "end": {
+ "line": 62,
+ "column": 9
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1737,
+ "end": 1739,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ConstTag",
+ "start": 1739,
+ "end": 1756,
+ "declaration": {
+ "type": "VariableDeclaration",
+ "kind": "const",
+ "declarations": [
+ {
+ "type": "VariableDeclarator",
+ "id": {
+ "type": "Identifier",
+ "name": "x",
+ "start": 1747,
+ "end": 1748,
+ "loc": {
+ "start": {
+ "line": 63,
+ "column": 9,
+ "character": 1747
+ },
+ "end": {
+ "line": 63,
+ "column": 10,
+ "character": 1748
+ }
+ }
+ },
+ "init": {
+ "type": "Identifier",
+ "start": 1751,
+ "end": 1755,
+ "loc": {
+ "start": {
+ "line": 63,
+ "column": 13
+ },
+ "end": {
+ "line": 63,
+ "column": 17
+ }
+ },
+ "name": "expr"
+ },
+ "start": 1747,
+ "end": 1755
+ }
+ ],
+ "start": 1741,
+ "end": 1755
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1756,
+ "end": 1758,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1758,
+ "end": 1765,
+ "expression": {
+ "type": "Identifier",
+ "start": 1759,
+ "end": 1764,
+ "loc": {
+ "start": {
+ "line": 64,
+ "column": 2
+ },
+ "end": {
+ "line": 64,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1765,
+ "end": 1766,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1766,
+ "end": 1773,
+ "expression": {
+ "type": "Identifier",
+ "start": 1767,
+ "end": 1772,
+ "loc": {
+ "start": {
+ "line": 64,
+ "column": 10
+ },
+ "end": {
+ "line": 64,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1773,
+ "end": 1774,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 1779,
+ "end": 1781,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1781,
+ "end": 1951,
+ "data": " after a predecessor that renders multiline: the space spelling hugs its closing tag, as an\n element or component does there, and the newline spelling is held "
+ },
+ {
+ "type": "Text",
+ "start": 1951,
+ "end": 1952,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1952,
+ "end": 2013,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 69,
+ "column": 1,
+ "character": 1953
+ },
+ "end": {
+ "line": 69,
+ "column": 2,
+ "character": 1954
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1955,
+ "end": 1957,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1957,
+ "end": 1992,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 70,
+ "column": 2,
+ "character": 1958
+ },
+ "end": {
+ "line": 70,
+ "column": 6,
+ "character": 1962
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1963,
+ "end": 1966,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1966,
+ "end": 1983,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 71,
+ "column": 3,
+ "character": 1967
+ },
+ "end": {
+ "line": 71,
+ "column": 6,
+ "character": 1970
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1971,
+ "end": 1977,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1983,
+ "end": 1985,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1992,
+ "end": 1993,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1993,
+ "end": 2000,
+ "expression": {
+ "type": "Identifier",
+ "start": 1994,
+ "end": 1999,
+ "loc": {
+ "start": {
+ "line": 72,
+ "column": 10
+ },
+ "end": {
+ "line": 72,
+ "column": 15
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2000,
+ "end": 2001,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 2001,
+ "end": 2008,
+ "expression": {
+ "type": "Identifier",
+ "start": 2002,
+ "end": 2007,
+ "loc": {
+ "start": {
+ "line": 72,
+ "column": 18
+ },
+ "end": {
+ "line": 72,
+ "column": 23
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2008,
+ "end": 2009,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2013,
+ "end": 2014,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2014,
+ "end": 2076,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 74,
+ "column": 1,
+ "character": 2015
+ },
+ "end": {
+ "line": 74,
+ "column": 2,
+ "character": 2016
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2017,
+ "end": 2019,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2019,
+ "end": 2054,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 75,
+ "column": 2,
+ "character": 2020
+ },
+ "end": {
+ "line": 75,
+ "column": 6,
+ "character": 2024
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2025,
+ "end": 2028,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 2028,
+ "end": 2045,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 76,
+ "column": 3,
+ "character": 2029
+ },
+ "end": {
+ "line": 76,
+ "column": 6,
+ "character": 2032
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 2033,
+ "end": 2039,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2045,
+ "end": 2047,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2054,
+ "end": 2056,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 2056,
+ "end": 2063,
+ "expression": {
+ "type": "Identifier",
+ "start": 2057,
+ "end": 2062,
+ "loc": {
+ "start": {
+ "line": 78,
+ "column": 2
+ },
+ "end": {
+ "line": 78,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2063,
+ "end": 2064,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 2064,
+ "end": 2071,
+ "expression": {
+ "type": "Identifier",
+ "start": 2065,
+ "end": 2070,
+ "loc": {
+ "start": {
+ "line": 78,
+ "column": 10
+ },
+ "end": {
+ "line": 78,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 2071,
+ "end": 2072,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ }
+ ]
+ },
+ "options": null,
+ "comments": []
+}
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/input.svelte
new file mode 100644
index 000000000..b65b0adaf
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/input.svelte
@@ -0,0 +1,79 @@
+<!--
+ The predecessor never decides a space: a tag after a comment, a <br />, a control-flow
+ block or a predecessor that renders multiline takes its per-width wrap exactly as an inline
+ element or component does there, so the authored space is kept and the pair packs — where
+ prettier breaks its line between two tags with the container. The newline spelling of the
+ same boundary is held, so the two spellings are two fixed points. Only a block element
+ predecessor keeps the tag off its line; a comment or a control-flow block after the pair
+ takes the space as its own per-width wrap (inline_sibling_space_before_bounding); a
+ declaration tag takes its own line.
+-->
+
+<!-- after a comment: the space spelling hugs, the newline spelling is held; and at the root -->
+<p>
+ <!-- c --> {expr1} {expr2}
+</p>
+<p>
+ <!-- c -->
+ {expr1} {expr2}
+</p>
+<!-- c --> {expr1} {expr2}
+
+<!-- before a comment, and before a control-flow block that renders inline: the pair keeps its
+ space there too — the follower's own per-width wrap, as after text -->
+<p>
+ {expr1} {expr2} <!-- c -->
+</p>
+<p>
+ {expr1} {expr2} {#if cond}text1{/if}
+</p>
+
+<!-- after a <br />, both spellings, and a spaced <br /> between two tags -->
+<p>
+ text1 text2<br /> {expr1} {expr2}
+</p>
+<p>
+ text1 text2<br />
+ {expr1} {expr2}
+</p>
+<p>
+ {expr1} <br /> {expr2}
+</p>
+
+<!-- after a block element, whose own break keeps the tag off its line -->
+<div>
+ <div>block1</div>
+ {expr1} {expr2}
+</div>
+
+<!-- after a control-flow block that renders multiline, both spellings, and after a declaration
+ tag, which takes its own line -->
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if} {expr1} {expr2}
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ {expr1} {expr2}
+</div>
+{#if cond}
+ {@const x = expr}
+ {expr1} {expr2}
+{/if}
+
+<!-- after a predecessor that renders multiline: the space spelling hugs its closing tag, as an
+ element or component does there, and the newline spelling is held -->
+<p>
+ <span>
+ <div>block1</div>
+ </span> {expr1} {expr2}
+</p>
+<p>
+ <span>
+ <div>block1</div>
+ </span>
+ {expr1} {expr2}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..d5e0e08dd
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,100 @@
+<!--
+ The predecessor never decides a space: a tag after a comment, a <br />, a control-flow
+ block or a predecessor that renders multiline takes its per-width wrap exactly as an inline
+ element or component does there, so the authored space is kept and the pair packs — where
+ prettier breaks its line between two tags with the container. The newline spelling of the
+ same boundary is held, so the two spellings are two fixed points. Only a block element
+ predecessor keeps the tag off its line; a comment or a control-flow block after the pair
+ takes the space as its own per-width wrap (inline_sibling_space_before_bounding); a
+ declaration tag takes its own line.
+-->
+
+<!-- after a comment: the space spelling hugs, the newline spelling is held; and at the root -->
+<p>
+ <!-- c -->
+ {expr1}
+ {expr2}
+</p>
+<p>
+ <!-- c -->
+ {expr1}
+ {expr2}
+</p>
+<!-- c -->
+{expr1}
+{expr2}
+
+<!-- before a comment, and before a control-flow block that renders inline: the pair keeps its
+ space there too — the follower's own per-width wrap, as after text -->
+<p>
+ {expr1}
+ {expr2}
+ <!-- c -->
+</p>
+<p>
+ {expr1}
+ {expr2}
+ {#if cond}text1{/if}
+</p>
+
+<!-- after a <br />, both spellings, and a spaced <br /> between two tags -->
+<p>
+ text1 text2<br />
+ {expr1}
+ {expr2}
+</p>
+<p>
+ text1 text2<br />
+ {expr1}
+ {expr2}
+</p>
+<p>
+ {expr1} <br />
+ {expr2}
+</p>
+
+<!-- after a block element, whose own break keeps the tag off its line -->
+<div>
+ <div>block1</div>
+ {expr1}
+ {expr2}
+</div>
+
+<!-- after a control-flow block that renders multiline, both spellings, and after a declaration
+ tag, which takes its own line -->
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ {expr1}
+ {expr2}
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ {expr1}
+ {expr2}
+</div>
+{#if cond}
+ {@const x = expr}
+ {expr1}
+ {expr2}
+{/if}
+
+<!-- after a predecessor that renders multiline: the space spelling hugs its closing tag, as an
+ element or component does there, and the newline spelling is held -->
+<p>
+ <span>
+ <div>block1</div>
+ </span>
+ {expr1}
+ {expr2}
+</p>
+<p>
+ <span>
+ <div>block1</div>
+ </span>
+ {expr1}
+ {expr2}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/unformatted_ours_line_owner_space.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/unformatted_ours_line_owner_space.svelte
new file mode 100644
index 000000000..9a129a99f
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/unformatted_ours_line_owner_space.svelte
@@ -0,0 +1,77 @@
+<!--
+ The predecessor never decides a space: a tag after a comment, a <br />, a control-flow
+ block or a predecessor that renders multiline takes its per-width wrap exactly as an inline
+ element or component does there, so the authored space is kept and the pair packs — where
+ prettier breaks its line between two tags with the container. The newline spelling of the
+ same boundary is held, so the two spellings are two fixed points. Only a block element
+ predecessor keeps the tag off its line; a comment or a control-flow block after the pair
+ takes the space as its own per-width wrap (inline_sibling_space_before_bounding); a
+ declaration tag takes its own line.
+-->
+
+<!-- after a comment: the space spelling hugs, the newline spelling is held; and at the root -->
+<p>
+ <!-- c --> {expr1} {expr2}
+</p>
+<p>
+ <!-- c -->
+ {expr1} {expr2}
+</p>
+<!-- c --> {expr1} {expr2}
+
+<!-- before a comment, and before a control-flow block that renders inline: the pair keeps its
+ space there too — the follower's own per-width wrap, as after text -->
+<p>
+ {expr1} {expr2} <!-- c -->
+</p>
+<p>
+ {expr1} {expr2} {#if cond}text1{/if}
+</p>
+
+<!-- after a <br />, both spellings, and a spaced <br /> between two tags -->
+<p>
+ text1 text2<br /> {expr1} {expr2}
+</p>
+<p>
+ text1 text2<br />
+ {expr1} {expr2}
+</p>
+<p>
+ {expr1} <br /> {expr2}
+</p>
+
+<!-- after a block element, whose own break keeps the tag off its line -->
+<div>
+ <div>block1</div> {expr1} {expr2}
+</div>
+
+<!-- after a control-flow block that renders multiline, both spellings, and after a declaration
+ tag, which takes its own line -->
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if} {expr1} {expr2}
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ {expr1} {expr2}
+</div>
+{#if cond}
+ {@const x = expr} {expr1} {expr2}
+{/if}
+
+<!-- after a predecessor that renders multiline: the space spelling hugs its closing tag, as an
+ element or component does there, and the newline spelling is held -->
+<p>
+ <span>
+ <div>block1</div>
+ </span> {expr1} {expr2}
+</p>
+<p>
+ <span>
+ <div>block1</div>
+ </span>
+ {expr1} {expr2}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/variant_split.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/variant_split.svelte
new file mode 100644
index 000000000..d5e0e08dd
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/variant_split.svelte
@@ -0,0 +1,100 @@
+<!--
+ The predecessor never decides a space: a tag after a comment, a <br />, a control-flow
+ block or a predecessor that renders multiline takes its per-width wrap exactly as an inline
+ element or component does there, so the authored space is kept and the pair packs — where
+ prettier breaks its line between two tags with the container. The newline spelling of the
+ same boundary is held, so the two spellings are two fixed points. Only a block element
+ predecessor keeps the tag off its line; a comment or a control-flow block after the pair
+ takes the space as its own per-width wrap (inline_sibling_space_before_bounding); a
+ declaration tag takes its own line.
+-->
+
+<!-- after a comment: the space spelling hugs, the newline spelling is held; and at the root -->
+<p>
+ <!-- c -->
+ {expr1}
+ {expr2}
+</p>
+<p>
+ <!-- c -->
+ {expr1}
+ {expr2}
+</p>
+<!-- c -->
+{expr1}
+{expr2}
+
+<!-- before a comment, and before a control-flow block that renders inline: the pair keeps its
+ space there too — the follower's own per-width wrap, as after text -->
+<p>
+ {expr1}
+ {expr2}
+ <!-- c -->
+</p>
+<p>
+ {expr1}
+ {expr2}
+ {#if cond}text1{/if}
+</p>
+
+<!-- after a <br />, both spellings, and a spaced <br /> between two tags -->
+<p>
+ text1 text2<br />
+ {expr1}
+ {expr2}
+</p>
+<p>
+ text1 text2<br />
+ {expr1}
+ {expr2}
+</p>
+<p>
+ {expr1} <br />
+ {expr2}
+</p>
+
+<!-- after a block element, whose own break keeps the tag off its line -->
+<div>
+ <div>block1</div>
+ {expr1}
+ {expr2}
+</div>
+
+<!-- after a control-flow block that renders multiline, both spellings, and after a declaration
+ tag, which takes its own line -->
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ {expr1}
+ {expr2}
+</div>
+<div>
+ {#if cond}
+ <div>block1</div>
+ {/if}
+ {expr1}
+ {expr2}
+</div>
+{#if cond}
+ {@const x = expr}
+ {expr1}
+ {expr2}
+{/if}
+
+<!-- after a predecessor that renders multiline: the space spelling hugs its closing tag, as an
+ element or component does there, and the newline spelling is held -->
+<p>
+ <span>
+ <div>block1</div>
+ </span>
+ {expr1}
+ {expr2}
+</p>
+<p>
+ <span>
+ <div>block1</div>
+ </span>
+ {expr1}
+ {expr2}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/README.md
new file mode 100644
index 000000000..cbb94a54c
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/README.md
@@ -0,0 +1,25 @@
+# inline_tag_pair_space_container_prettier_divergence
+
+The container holding a space-spelled tag pair is not an axis. `{expr1} {expr2}` packs per width
+in every multiline container — the root, a block element, an inline element authored with
+boundary air, a list item, a table cell, a component's content, and an `{#if}` / `{#each}` /
+`{#snippet}` body — where prettier's bare `line` between two tags breaks with the container and
+splits the pair in every one of them (`output_prettier.svelte`).
+
+`variant_split.svelte` is prettier's form itself, and tsv keeps it stable too — the newline spelling of
+every boundary is held — so the two forms are two fixed points; a rule change that started
+normalizing prettier's form back to `input.svelte` fails this file rather than passing in prose.
+
+## Reason
+
+Design choice — the rule of
+[inline_tag_pair_space](../inline_tag_pair_space_prettier_divergence/), varied over the container
+alone. The whitespace-only separator before a tag defers to the next tag's per-width group in
+both arms of the separator site, and neither arm asks what container the run sits in, so a
+block, an inline element made multiline by its own air, a table cell, a component and a block
+body all reach one answer. The holding side of the same sweep — the NEWLINE spelling of a
+prose-free or one-word run, held in every container — is
+[inline_sibling_newline_label_hold_container](../inline_sibling_newline_label_hold_container_prettier_divergence/).
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/expected.json
new file mode 100644
index 000000000..ecb69256c
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/expected.json
@@ -0,0 +1,1272 @@
+{
+ "css": null,
+ "js": [],
+ "start": 0,
+ "end": 976,
+ "type": "Root",
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Comment",
+ "start": 0,
+ "end": 325,
+ "data": "\n\tThe container holding a space-spelled tag pair is not an axis: the pair packs per width in\n\tevery multiline container — the root, a block element, an inline element authored with air,\n\ta list item, a table cell, a component's content and a control-flow block's body — where\n\tprettier splits it in every one of them.\n"
+ },
+ {
+ "type": "Text",
+ "start": 325,
+ "end": 327,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 327,
+ "end": 383,
+ "data": " the root, which is always a multiline container "
+ },
+ {
+ "type": "Text",
+ "start": 383,
+ "end": 384,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 384,
+ "end": 391,
+ "expression": {
+ "type": "Identifier",
+ "start": 385,
+ "end": 390,
+ "loc": {
+ "start": {
+ "line": 9,
+ "column": 1
+ },
+ "end": {
+ "line": 9,
+ "column": 6
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 391,
+ "end": 392,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 392,
+ "end": 399,
+ "expression": {
+ "type": "Identifier",
+ "start": 393,
+ "end": 398,
+ "loc": {
+ "start": {
+ "line": 9,
+ "column": 9
+ },
+ "end": {
+ "line": 9,
+ "column": 14
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 399,
+ "end": 401,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 401,
+ "end": 473,
+ "data": " a block element, and inline elements authored with boundary air "
+ },
+ {
+ "type": "Text",
+ "start": 473,
+ "end": 474,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 474,
+ "end": 503,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 12,
+ "column": 1,
+ "character": 475
+ },
+ "end": {
+ "line": 12,
+ "column": 4,
+ "character": 478
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 479,
+ "end": 481,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 481,
+ "end": 488,
+ "expression": {
+ "type": "Identifier",
+ "start": 482,
+ "end": 487,
+ "loc": {
+ "start": {
+ "line": 13,
+ "column": 2
+ },
+ "end": {
+ "line": 13,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 488,
+ "end": 489,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 489,
+ "end": 496,
+ "expression": {
+ "type": "Identifier",
+ "start": 490,
+ "end": 495,
+ "loc": {
+ "start": {
+ "line": 13,
+ "column": 10
+ },
+ "end": {
+ "line": 13,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 496,
+ "end": 497,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 503,
+ "end": 504,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 504,
+ "end": 551,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 15,
+ "column": 1,
+ "character": 505
+ },
+ "end": {
+ "line": 15,
+ "column": 4,
+ "character": 508
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 509,
+ "end": 511,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 511,
+ "end": 544,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 16,
+ "column": 2,
+ "character": 512
+ },
+ "end": {
+ "line": 16,
+ "column": 6,
+ "character": 516
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 517,
+ "end": 520,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 520,
+ "end": 527,
+ "expression": {
+ "type": "Identifier",
+ "start": 521,
+ "end": 526,
+ "loc": {
+ "start": {
+ "line": 17,
+ "column": 3
+ },
+ "end": {
+ "line": 17,
+ "column": 8
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 527,
+ "end": 528,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 528,
+ "end": 535,
+ "expression": {
+ "type": "Identifier",
+ "start": 529,
+ "end": 534,
+ "loc": {
+ "start": {
+ "line": 17,
+ "column": 11
+ },
+ "end": {
+ "line": 17,
+ "column": 16
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 535,
+ "end": 537,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 544,
+ "end": 545,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 551,
+ "end": 552,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 552,
+ "end": 603,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 20,
+ "column": 1,
+ "character": 553
+ },
+ "end": {
+ "line": 20,
+ "column": 4,
+ "character": 556
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 557,
+ "end": 559,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 559,
+ "end": 596,
+ "name": "button",
+ "name_loc": {
+ "start": {
+ "line": 21,
+ "column": 2,
+ "character": 560
+ },
+ "end": {
+ "line": 21,
+ "column": 8,
+ "character": 566
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 567,
+ "end": 570,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 570,
+ "end": 577,
+ "expression": {
+ "type": "Identifier",
+ "start": 571,
+ "end": 576,
+ "loc": {
+ "start": {
+ "line": 22,
+ "column": 3
+ },
+ "end": {
+ "line": 22,
+ "column": 8
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 577,
+ "end": 578,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 578,
+ "end": 585,
+ "expression": {
+ "type": "Identifier",
+ "start": 579,
+ "end": 584,
+ "loc": {
+ "start": {
+ "line": 22,
+ "column": 11
+ },
+ "end": {
+ "line": 22,
+ "column": 16
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 585,
+ "end": 587,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 596,
+ "end": 597,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 603,
+ "end": 605,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 605,
+ "end": 642,
+ "data": " a list item and a table cell "
+ },
+ {
+ "type": "Text",
+ "start": 642,
+ "end": 643,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 643,
+ "end": 684,
+ "name": "ul",
+ "name_loc": {
+ "start": {
+ "line": 27,
+ "column": 1,
+ "character": 644
+ },
+ "end": {
+ "line": 27,
+ "column": 3,
+ "character": 646
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 647,
+ "end": 649,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 649,
+ "end": 678,
+ "name": "li",
+ "name_loc": {
+ "start": {
+ "line": 28,
+ "column": 2,
+ "character": 650
+ },
+ "end": {
+ "line": 28,
+ "column": 4,
+ "character": 652
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 653,
+ "end": 656,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 656,
+ "end": 663,
+ "expression": {
+ "type": "Identifier",
+ "start": 657,
+ "end": 662,
+ "loc": {
+ "start": {
+ "line": 29,
+ "column": 3
+ },
+ "end": {
+ "line": 29,
+ "column": 8
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 663,
+ "end": 664,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 664,
+ "end": 671,
+ "expression": {
+ "type": "Identifier",
+ "start": 665,
+ "end": 670,
+ "loc": {
+ "start": {
+ "line": 29,
+ "column": 11
+ },
+ "end": {
+ "line": 29,
+ "column": 16
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 671,
+ "end": 673,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 678,
+ "end": 679,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 684,
+ "end": 685,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 685,
+ "end": 748,
+ "name": "table",
+ "name_loc": {
+ "start": {
+ "line": 32,
+ "column": 1,
+ "character": 686
+ },
+ "end": {
+ "line": 32,
+ "column": 6,
+ "character": 691
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 692,
+ "end": 694,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 694,
+ "end": 739,
+ "name": "tr",
+ "name_loc": {
+ "start": {
+ "line": 33,
+ "column": 2,
+ "character": 695
+ },
+ "end": {
+ "line": 33,
+ "column": 4,
+ "character": 697
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 698,
+ "end": 701,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 701,
+ "end": 732,
+ "name": "td",
+ "name_loc": {
+ "start": {
+ "line": 34,
+ "column": 3,
+ "character": 702
+ },
+ "end": {
+ "line": 34,
+ "column": 5,
+ "character": 704
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 705,
+ "end": 709,
+ "raw": "\n\t\t\t",
+ "data": "\n\t\t\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 709,
+ "end": 716,
+ "expression": {
+ "type": "Identifier",
+ "start": 710,
+ "end": 715,
+ "loc": {
+ "start": {
+ "line": 35,
+ "column": 4
+ },
+ "end": {
+ "line": 35,
+ "column": 9
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 716,
+ "end": 717,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 717,
+ "end": 724,
+ "expression": {
+ "type": "Identifier",
+ "start": 718,
+ "end": 723,
+ "loc": {
+ "start": {
+ "line": 35,
+ "column": 12
+ },
+ "end": {
+ "line": 35,
+ "column": 17
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 724,
+ "end": 727,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 732,
+ "end": 734,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 739,
+ "end": 740,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 748,
+ "end": 750,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 750,
+ "end": 780,
+ "data": " a component's content "
+ },
+ {
+ "type": "Text",
+ "start": 780,
+ "end": 781,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "Component",
+ "start": 781,
+ "end": 812,
+ "name": "Comp",
+ "name_loc": {
+ "start": {
+ "line": 41,
+ "column": 1,
+ "character": 782
+ },
+ "end": {
+ "line": 41,
+ "column": 5,
+ "character": 786
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 787,
+ "end": 789,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 789,
+ "end": 796,
+ "expression": {
+ "type": "Identifier",
+ "start": 790,
+ "end": 795,
+ "loc": {
+ "start": {
+ "line": 42,
+ "column": 2
+ },
+ "end": {
+ "line": 42,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 796,
+ "end": 797,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 797,
+ "end": 804,
+ "expression": {
+ "type": "Identifier",
+ "start": 798,
+ "end": 803,
+ "loc": {
+ "start": {
+ "line": 42,
+ "column": 10
+ },
+ "end": {
+ "line": 42,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 804,
+ "end": 805,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 812,
+ "end": 814,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 814,
+ "end": 848,
+ "data": " control-flow block bodies "
+ },
+ {
+ "type": "Text",
+ "start": 848,
+ "end": 849,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 849,
+ "end": 882,
+ "test": {
+ "type": "Identifier",
+ "start": 854,
+ "end": 858,
+ "loc": {
+ "start": {
+ "line": 46,
+ "column": 5
+ },
+ "end": {
+ "line": 46,
+ "column": 9
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 859,
+ "end": 861,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 861,
+ "end": 868,
+ "expression": {
+ "type": "Identifier",
+ "start": 862,
+ "end": 867,
+ "loc": {
+ "start": {
+ "line": 47,
+ "column": 2
+ },
+ "end": {
+ "line": 47,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 868,
+ "end": 869,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 869,
+ "end": 876,
+ "expression": {
+ "type": "Identifier",
+ "start": 870,
+ "end": 875,
+ "loc": {
+ "start": {
+ "line": 47,
+ "column": 10
+ },
+ "end": {
+ "line": 47,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 876,
+ "end": 877,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 882,
+ "end": 883,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "EachBlock",
+ "start": 883,
+ "end": 931,
+ "expression": {
+ "type": "Identifier",
+ "start": 890,
+ "end": 895,
+ "loc": {
+ "start": {
+ "line": 49,
+ "column": 7
+ },
+ "end": {
+ "line": 49,
+ "column": 12
+ }
+ },
+ "name": "items"
+ },
+ "body": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 904,
+ "end": 906,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 906,
+ "end": 914,
+ "expression": {
+ "type": "MemberExpression",
+ "start": 907,
+ "end": 913,
+ "loc": {
+ "start": {
+ "line": 50,
+ "column": 2
+ },
+ "end": {
+ "line": 50,
+ "column": 8
+ }
+ },
+ "object": {
+ "type": "Identifier",
+ "start": 907,
+ "end": 911,
+ "loc": {
+ "start": {
+ "line": 50,
+ "column": 2
+ },
+ "end": {
+ "line": 50,
+ "column": 6
+ }
+ },
+ "name": "item"
+ },
+ "property": {
+ "type": "Identifier",
+ "start": 912,
+ "end": 913,
+ "loc": {
+ "start": {
+ "line": 50,
+ "column": 7
+ },
+ "end": {
+ "line": 50,
+ "column": 8
+ }
+ },
+ "name": "a"
+ },
+ "computed": false,
+ "optional": false
+ }
+ },
+ {
+ "type": "Text",
+ "start": 914,
+ "end": 915,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 915,
+ "end": 923,
+ "expression": {
+ "type": "MemberExpression",
+ "start": 916,
+ "end": 922,
+ "loc": {
+ "start": {
+ "line": 50,
+ "column": 11
+ },
+ "end": {
+ "line": 50,
+ "column": 17
+ }
+ },
+ "object": {
+ "type": "Identifier",
+ "start": 916,
+ "end": 920,
+ "loc": {
+ "start": {
+ "line": 50,
+ "column": 11
+ },
+ "end": {
+ "line": 50,
+ "column": 15
+ }
+ },
+ "name": "item"
+ },
+ "property": {
+ "type": "Identifier",
+ "start": 921,
+ "end": 922,
+ "loc": {
+ "start": {
+ "line": 50,
+ "column": 16
+ },
+ "end": {
+ "line": 50,
+ "column": 17
+ }
+ },
+ "name": "b"
+ },
+ "computed": false,
+ "optional": false
+ }
+ },
+ {
+ "type": "Text",
+ "start": 923,
+ "end": 924,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ },
+ "context": {
+ "type": "Identifier",
+ "name": "item",
+ "start": 899,
+ "end": 903,
+ "loc": {
+ "start": {
+ "line": 49,
+ "column": 16,
+ "character": 899
+ },
+ "end": {
+ "line": 49,
+ "column": 20,
+ "character": 903
+ }
+ }
+ }
+ },
+ {
+ "type": "Text",
+ "start": 931,
+ "end": 932,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "SnippetBlock",
+ "start": 932,
+ "end": 975,
+ "expression": {
+ "type": "Identifier",
+ "name": "fn",
+ "start": 942,
+ "end": 944,
+ "loc": {
+ "start": {
+ "line": 52,
+ "column": 10,
+ "character": 942
+ },
+ "end": {
+ "line": 52,
+ "column": 12,
+ "character": 944
+ }
+ }
+ },
+ "parameters": [],
+ "body": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 947,
+ "end": 949,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 949,
+ "end": 956,
+ "expression": {
+ "type": "Identifier",
+ "start": 950,
+ "end": 955,
+ "loc": {
+ "start": {
+ "line": 53,
+ "column": 2
+ },
+ "end": {
+ "line": 53,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 956,
+ "end": 957,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 957,
+ "end": 964,
+ "expression": {
+ "type": "Identifier",
+ "start": 958,
+ "end": 963,
+ "loc": {
+ "start": {
+ "line": 53,
+ "column": 10
+ },
+ "end": {
+ "line": 53,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 964,
+ "end": 965,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ }
+ ]
+ },
+ "options": null,
+ "comments": []
+}
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/input.svelte
new file mode 100644
index 000000000..0c7d71c49
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/input.svelte
@@ -0,0 +1,54 @@
+<!--
+ The container holding a space-spelled tag pair is not an axis: the pair packs per width in
+ every multiline container — the root, a block element, an inline element authored with air,
+ a list item, a table cell, a component's content and a control-flow block's body — where
+ prettier splits it in every one of them.
+-->
+
+<!-- the root, which is always a multiline container -->
+{expr1} {expr2}
+
+<!-- a block element, and inline elements authored with boundary air -->
+<div>
+ {expr1} {expr2}
+</div>
+<div>
+ <span>
+ {expr1} {expr2}
+ </span>
+</div>
+<div>
+ <button>
+ {expr1} {expr2}
+ </button>
+</div>
+
+<!-- a list item and a table cell -->
+<ul>
+ <li>
+ {expr1} {expr2}
+ </li>
+</ul>
+<table>
+ <tr>
+ <td>
+ {expr1} {expr2}
+ </td>
+ </tr>
+</table>
+
+<!-- a component's content -->
+<Comp>
+ {expr1} {expr2}
+</Comp>
+
+<!-- control-flow block bodies -->
+{#if cond}
+ {expr1} {expr2}
+{/if}
+{#each items as item}
+ {item.a} {item.b}
+{/each}
+{#snippet fn()}
+ {expr1} {expr2}
+{/snippet}
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..3fd6198a3
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,61 @@
+<!--
+ The container holding a space-spelled tag pair is not an axis: the pair packs per width in
+ every multiline container — the root, a block element, an inline element authored with air,
+ a list item, a table cell, a component's content and a control-flow block's body — where
+ prettier splits it in every one of them.
+-->
+
+<!-- the root, which is always a multiline container -->
+{expr1}
+{expr2}
+
+<!-- a block element, and inline elements authored with boundary air -->
+<div>
+ {expr1}
+ {expr2}
+</div>
+<div>
+ <span>
+ {expr1}
+ {expr2}
+ </span>
+</div>
+<div>
+ <button>
+ {expr1}
+ {expr2}
+ </button>
+</div>
+
+<!-- a list item and a table cell -->
+<ul>
+ <li>
+ {expr1}
+ {expr2}
+ </li>
+</ul>
+<table>
+ <tr>
+ <td>
+ {expr1}
+ {expr2}
+ </td>
+ </tr>
+</table>
+
+<!-- a component's content -->
+<Comp>
+ {expr1}
+ {expr2}
+</Comp>
+
+<!-- control-flow block bodies -->
+{#if cond}
+ {expr1} {expr2}
+{/if}
+{#each items as item}
+ {item.a} {item.b}
+{/each}
+{#snippet fn()}
+ {expr1} {expr2}
+{/snippet}
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/variant_split.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/variant_split.svelte
new file mode 100644
index 000000000..3fd6198a3
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/variant_split.svelte
@@ -0,0 +1,61 @@
+<!--
+ The container holding a space-spelled tag pair is not an axis: the pair packs per width in
+ every multiline container — the root, a block element, an inline element authored with air,
+ a list item, a table cell, a component's content and a control-flow block's body — where
+ prettier splits it in every one of them.
+-->
+
+<!-- the root, which is always a multiline container -->
+{expr1}
+{expr2}
+
+<!-- a block element, and inline elements authored with boundary air -->
+<div>
+ {expr1}
+ {expr2}
+</div>
+<div>
+ <span>
+ {expr1}
+ {expr2}
+ </span>
+</div>
+<div>
+ <button>
+ {expr1}
+ {expr2}
+ </button>
+</div>
+
+<!-- a list item and a table cell -->
+<ul>
+ <li>
+ {expr1}
+ {expr2}
+ </li>
+</ul>
+<table>
+ <tr>
+ <td>
+ {expr1}
+ {expr2}
+ </td>
+ </tr>
+</table>
+
+<!-- a component's content -->
+<Comp>
+ {expr1}
+ {expr2}
+</Comp>
+
+<!-- control-flow block bodies -->
+{#if cond}
+ {expr1} {expr2}
+{/if}
+{#each items as item}
+ {item.a} {item.b}
+{/each}
+{#snippet fn()}
+ {expr1} {expr2}
+{/snippet}
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/README.md
new file mode 100644
index 000000000..35f004940
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/README.md
@@ -0,0 +1,34 @@
+# inline_tag_pair_space_expr_break_prettier_divergence
+
+A space-spelled tag pair where one expression must break. When the **first** tag's expression
+breaks, the second tag hugs its closing `)}` line (`)} {expr}`) — the tag expands inside its own
+braces and leaves its adjacencies untouched, so the boundary after it is the ordinary per-width
+fill boundary, exactly as an inline element or a word takes after a broken tag. Prettier's bare
+`line` between two tags breaks with the container and puts `{expr}` on its own line
+(`output_prettier.svelte`).
+
+The two controls agree with prettier: the **newline** spelling of that boundary is held (the
+prose gate holds an authored newline in a wordless run), and a **second** tag whose expression
+cannot fit flat after its predecessor travels to a fresh line whole and breaks internally there
+([fill_spaced_tag_travel_long](../fill_spaced_tag_travel_long_prettier_divergence/) for the text
+predecessor).
+
+`unformatted_ours_space.svelte` is the one-line authoring of every case: tsv breaks each
+expression and normalizes to `input.svelte` in one pass; prettier lands on `output_prettier`.
+
+`variant_split.svelte` is prettier's form itself, and tsv keeps it stable too — the newline spelling of
+every boundary is held — so the two forms are two fixed points; a rule change that started
+normalizing prettier's form back to `input.svelte` fails this file rather than passing in prose.
+
+## Reason
+
+Design choice — the rule of
+[inline_tag_pair_space](../inline_tag_pair_space_prettier_divergence/) at a predecessor that
+renders multiline. A TAG predecessor is excluded from the layout-keyed hold
+([sibling_newline_after_multiline](../sibling_newline_after_multiline_prettier_divergence/))
+because its break lands inside its own expression, so the space-spelled boundary after it stays
+the per-width hug for every follower kind; only the newline spelling is held, and by the prose
+gate rather than the multiline predecessor.
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/expected.json
new file mode 100644
index 000000000..2cf5d7c21
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/expected.json
@@ -0,0 +1,491 @@
+{
+ "css": null,
+ "js": [],
+ "start": 0,
+ "end": 1106,
+ "type": "Root",
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Comment",
+ "start": 0,
+ "end": 451,
+ "data": "\n\tA spaced tag pair where one expression must break. A tag whose expression breaks expands\n\tINSIDE its own braces and leaves its adjacencies untouched, so a space-spelled tag after it\n\thugs the closing `)}` per width, exactly as an element or a word does after a broken tag;\n\tthe newline spelling of that boundary is held. A tag whose expression cannot fit flat after\n\tits predecessor travels to a fresh line whole and breaks internally there.\n"
+ },
+ {
+ "type": "Text",
+ "start": 451,
+ "end": 453,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 453,
+ "end": 527,
+ "data": " the first expression breaks: the second tag hugs its closing line "
+ },
+ {
+ "type": "Text",
+ "start": 527,
+ "end": 528,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 528,
+ "end": 664,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 10,
+ "column": 1,
+ "character": 529
+ },
+ "end": {
+ "line": 10,
+ "column": 2,
+ "character": 530
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 531,
+ "end": 533,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 533,
+ "end": 652,
+ "expression": {
+ "type": "CallExpression",
+ "start": 534,
+ "end": 651,
+ "loc": {
+ "start": {
+ "line": 11,
+ "column": 2
+ },
+ "end": {
+ "line": 14,
+ "column": 2
+ }
+ },
+ "callee": {
+ "type": "Identifier",
+ "start": 534,
+ "end": 536,
+ "loc": {
+ "start": {
+ "line": 11,
+ "column": 2
+ },
+ "end": {
+ "line": 11,
+ "column": 4
+ }
+ },
+ "name": "fn"
+ },
+ "arguments": [
+ {
+ "type": "Identifier",
+ "start": 540,
+ "end": 591,
+ "loc": {
+ "start": {
+ "line": 12,
+ "column": 2
+ },
+ "end": {
+ "line": 12,
+ "column": 53
+ }
+ },
+ "name": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ },
+ {
+ "type": "Identifier",
+ "start": 595,
+ "end": 648,
+ "loc": {
+ "start": {
+ "line": 13,
+ "column": 2
+ },
+ "end": {
+ "line": 13,
+ "column": 55
+ }
+ },
+ "name": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+ }
+ ],
+ "optional": false
+ }
+ },
+ {
+ "type": "Text",
+ "start": 652,
+ "end": 653,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 653,
+ "end": 659,
+ "expression": {
+ "type": "Identifier",
+ "start": 654,
+ "end": 658,
+ "loc": {
+ "start": {
+ "line": 14,
+ "column": 5
+ },
+ "end": {
+ "line": 14,
+ "column": 9
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 659,
+ "end": 660,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 664,
+ "end": 666,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 666,
+ "end": 733,
+ "data": " control: the newline spelling of the same boundary is held "
+ },
+ {
+ "type": "Text",
+ "start": 733,
+ "end": 734,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 734,
+ "end": 871,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 18,
+ "column": 1,
+ "character": 735
+ },
+ "end": {
+ "line": 18,
+ "column": 2,
+ "character": 736
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 737,
+ "end": 739,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 739,
+ "end": 858,
+ "expression": {
+ "type": "CallExpression",
+ "start": 740,
+ "end": 857,
+ "loc": {
+ "start": {
+ "line": 19,
+ "column": 2
+ },
+ "end": {
+ "line": 22,
+ "column": 2
+ }
+ },
+ "callee": {
+ "type": "Identifier",
+ "start": 740,
+ "end": 742,
+ "loc": {
+ "start": {
+ "line": 19,
+ "column": 2
+ },
+ "end": {
+ "line": 19,
+ "column": 4
+ }
+ },
+ "name": "fn"
+ },
+ "arguments": [
+ {
+ "type": "Identifier",
+ "start": 746,
+ "end": 797,
+ "loc": {
+ "start": {
+ "line": 20,
+ "column": 2
+ },
+ "end": {
+ "line": 20,
+ "column": 53
+ }
+ },
+ "name": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ },
+ {
+ "type": "Identifier",
+ "start": 801,
+ "end": 854,
+ "loc": {
+ "start": {
+ "line": 21,
+ "column": 2
+ },
+ "end": {
+ "line": 21,
+ "column": 55
+ }
+ },
+ "name": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+ }
+ ],
+ "optional": false
+ }
+ },
+ {
+ "type": "Text",
+ "start": 858,
+ "end": 860,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 860,
+ "end": 866,
+ "expression": {
+ "type": "Identifier",
+ "start": 861,
+ "end": 865,
+ "loc": {
+ "start": {
+ "line": 23,
+ "column": 2
+ },
+ "end": {
+ "line": 23,
+ "column": 6
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 866,
+ "end": 867,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 871,
+ "end": 873,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 873,
+ "end": 967,
+ "data": " control: the second expression breaks, so it travels whole and breaks on its own line "
+ },
+ {
+ "type": "Text",
+ "start": 967,
+ "end": 968,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 968,
+ "end": 1105,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 27,
+ "column": 1,
+ "character": 969
+ },
+ "end": {
+ "line": 27,
+ "column": 2,
+ "character": 970
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 971,
+ "end": 973,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 973,
+ "end": 979,
+ "expression": {
+ "type": "Identifier",
+ "start": 974,
+ "end": 978,
+ "loc": {
+ "start": {
+ "line": 28,
+ "column": 2
+ },
+ "end": {
+ "line": 28,
+ "column": 6
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 979,
+ "end": 981,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 981,
+ "end": 1100,
+ "expression": {
+ "type": "CallExpression",
+ "start": 982,
+ "end": 1099,
+ "loc": {
+ "start": {
+ "line": 29,
+ "column": 2
+ },
+ "end": {
+ "line": 32,
+ "column": 2
+ }
+ },
+ "callee": {
+ "type": "Identifier",
+ "start": 982,
+ "end": 984,
+ "loc": {
+ "start": {
+ "line": 29,
+ "column": 2
+ },
+ "end": {
+ "line": 29,
+ "column": 4
+ }
+ },
+ "name": "fn"
+ },
+ "arguments": [
+ {
+ "type": "Identifier",
+ "start": 988,
+ "end": 1039,
+ "loc": {
+ "start": {
+ "line": 30,
+ "column": 2
+ },
+ "end": {
+ "line": 30,
+ "column": 53
+ }
+ },
+ "name": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ },
+ {
+ "type": "Identifier",
+ "start": 1043,
+ "end": 1096,
+ "loc": {
+ "start": {
+ "line": 31,
+ "column": 2
+ },
+ "end": {
+ "line": 31,
+ "column": 55
+ }
+ },
+ "name": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+ }
+ ],
+ "optional": false
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1100,
+ "end": 1101,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ }
+ ]
+ },
+ "options": null,
+ "comments": []
+}
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/input.svelte
new file mode 100644
index 000000000..e3edbadec
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/input.svelte
@@ -0,0 +1,33 @@
+<!--
+ A spaced tag pair where one expression must break. A tag whose expression breaks expands
+ INSIDE its own braces and leaves its adjacencies untouched, so a space-spelled tag after it
+ hugs the closing `)}` per width, exactly as an element or a word does after a broken tag;
+ the newline spelling of that boundary is held. A tag whose expression cannot fit flat after
+ its predecessor travels to a fresh line whole and breaks internally there.
+-->
+
+<!-- the first expression breaks: the second tag hugs its closing line -->
+<p>
+ {fn(
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+ )} {expr}
+</p>
+
+<!-- control: the newline spelling of the same boundary is held -->
+<p>
+ {fn(
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+ )}
+ {expr}
+</p>
+
+<!-- control: the second expression breaks, so it travels whole and breaks on its own line -->
+<p>
+ {expr}
+ {fn(
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+ )}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..75f097b0d
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,34 @@
+<!--
+ A spaced tag pair where one expression must break. A tag whose expression breaks expands
+ INSIDE its own braces and leaves its adjacencies untouched, so a space-spelled tag after it
+ hugs the closing `)}` per width, exactly as an element or a word does after a broken tag;
+ the newline spelling of that boundary is held. A tag whose expression cannot fit flat after
+ its predecessor travels to a fresh line whole and breaks internally there.
+-->
+
+<!-- the first expression breaks: the second tag hugs its closing line -->
+<p>
+ {fn(
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+ )}
+ {expr}
+</p>
+
+<!-- control: the newline spelling of the same boundary is held -->
+<p>
+ {fn(
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+ )}
+ {expr}
+</p>
+
+<!-- control: the second expression breaks, so it travels whole and breaks on its own line -->
+<p>
+ {expr}
+ {fn(
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+ )}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/unformatted_ours_space.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/unformatted_ours_space.svelte
new file mode 100644
index 000000000..72609bbe8
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/unformatted_ours_space.svelte
@@ -0,0 +1,23 @@
+<!--
+ A spaced tag pair where one expression must break. A tag whose expression breaks expands
+ INSIDE its own braces and leaves its adjacencies untouched, so a space-spelled tag after it
+ hugs the closing `)}` per width, exactly as an element or a word does after a broken tag;
+ the newline spelling of that boundary is held. A tag whose expression cannot fit flat after
+ its predecessor travels to a fresh line whole and breaks internally there.
+-->
+
+<!-- the first expression breaks: the second tag hugs its closing line -->
+<p>
+ {fn(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)} {expr}
+</p>
+
+<!-- control: the newline spelling of the same boundary is held -->
+<p>
+ {fn(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)}
+ {expr}
+</p>
+
+<!-- control: the second expression breaks, so it travels whole and breaks on its own line -->
+<p>
+ {expr} {fn(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/variant_split.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/variant_split.svelte
new file mode 100644
index 000000000..75f097b0d
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/variant_split.svelte
@@ -0,0 +1,34 @@
+<!--
+ A spaced tag pair where one expression must break. A tag whose expression breaks expands
+ INSIDE its own braces and leaves its adjacencies untouched, so a space-spelled tag after it
+ hugs the closing `)}` per width, exactly as an element or a word does after a broken tag;
+ the newline spelling of that boundary is held. A tag whose expression cannot fit flat after
+ its predecessor travels to a fresh line whole and breaks internally there.
+-->
+
+<!-- the first expression breaks: the second tag hugs its closing line -->
+<p>
+ {fn(
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+ )}
+ {expr}
+</p>
+
+<!-- control: the newline spelling of the same boundary is held -->
+<p>
+ {fn(
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+ )}
+ {expr}
+</p>
+
+<!-- control: the second expression breaks, so it travels whole and breaks on its own line -->
+<p>
+ {expr}
+ {fn(
+ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+ )}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/README.md
new file mode 100644
index 000000000..b8f261f46
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/README.md
@@ -0,0 +1,45 @@
+# inline_tag_pair_space_prettier_divergence
+
+A **space-spelled** separator between two tags — `{expr1} {expr2}` — is a fill boundary that
+packs per width in a multiline container, whatever its run holds: no word at all, one word
+(`text1 {expr1} {expr2}`, `{expr1} {expr2} {expr3} text1`, the escaped-angle-bracket pair at the
+root), or prose. An inline element or a component before the tag (`<span>inline1</span> {expr}`,
+`<Comp /> {expr}`), a component between two tags, and every tag kind in one run
+(`{@html a} {@render fn()} {expr}`) pack the same way. Prettier's bare `line` between two tags
+breaks with the multiline container, so it splits every one of them (`output_prettier.svelte`).
+The control is the **newline** spelling of the wordless pair, which both formatters hold.
+
+`unformatted_ours_tab.svelte` spells every packed separator as a tab: a tab and a space are one
+document ([inline_separator_tab](../inline_separator_tab_prettier_divergence/)), so tsv
+normalizes it to `input.svelte`; prettier splits the pairs as it does from the space.
+
+`variant_split.svelte` is prettier's form itself, and tsv keeps it stable too — the newline spelling of
+every boundary is held — so the two forms are two fixed points; a rule change that started
+normalizing prettier's form back to `input.svelte` fails this file rather than passing in prose.
+
+## Reason
+
+Design choice. The sibling-newline flow rule's prose gate
+([inline_sibling_newline_label_hold](../inline_sibling_newline_label_hold_prettier_divergence/))
+is a **hold**, never a forced break: it decides whether an authored newline may reflow, and says
+nothing about an authored space. So the whitespace-only separator before a tag reads the prose
+gate for its NEWLINE spelling alone — a wordless or one-word run holds its authored lines — and
+its SPACE spelling defers to the next tag's per-width group unconditionally, the same
+`group([line, tag])` an inline element or component takes at that boundary
+([inline_adjacent_sibling_newline_flow](../inline_adjacent_sibling_newline_flow_prettier_divergence/),
+the prose tag pair prettier also splits). Gating the space on what the run holds would turn the
+hold into a forced break — `Price: {currency} {amount}`, or a bare `{a} {b}`, authored on one
+line and coming out on two — a layout keyed on nothing the author wrote, and the one place the
+rule family used to do it. Both arms of the separator site defer the tag's space to that
+per-width group, so a width-broken container and a newline-authored one lay the pair out
+identically; and the space asks nothing about what precedes it either — a comment, a `<br />` or
+a control-flow block before the pair keeps the space exactly as it would before an element
+([inline_tag_pair_space_bounded](../inline_tag_pair_space_bounded_prettier_divergence/)).
+
+The container is not an axis either —
+[inline_tag_pair_space_container](../inline_tag_pair_space_container_prettier_divergence/); the
+pair packs per width at the print-width boundary in
+[inline_content_spaced_tags_long](../inline_content_spaced_tags_long_prettier_divergence/).
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/expected.json
new file mode 100644
index 000000000..263f18e32
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/expected.json
@@ -0,0 +1,1132 @@
+{
+ "css": null,
+ "js": [],
+ "start": 0,
+ "end": 1376,
+ "type": "Root",
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Comment",
+ "start": 0,
+ "end": 456,
+ "data": "\n\tA space-spelled separator between two tags is a fill boundary that packs per width, whatever\n\tits run holds — no word at all, one word, or prose — where prettier's bare `line` between two\n\ttags breaks with the multiline container. The sibling-newline flow rule's prose gate is a\n\tHOLD on an authored newline and never turns a space into one: the newline spelling of the\n\tsame pair is held (the control), so the two spellings are two fixed points.\n"
+ },
+ {
+ "type": "Text",
+ "start": 456,
+ "end": 458,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 458,
+ "end": 538,
+ "data": " a wordless pair: the run holds no text at all, and the pair still packs "
+ },
+ {
+ "type": "Text",
+ "start": 538,
+ "end": 539,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 539,
+ "end": 564,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 10,
+ "column": 1,
+ "character": 540
+ },
+ "end": {
+ "line": 10,
+ "column": 2,
+ "character": 541
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 542,
+ "end": 544,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 544,
+ "end": 551,
+ "expression": {
+ "type": "Identifier",
+ "start": 545,
+ "end": 550,
+ "loc": {
+ "start": {
+ "line": 11,
+ "column": 2
+ },
+ "end": {
+ "line": 11,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 551,
+ "end": 552,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 552,
+ "end": 559,
+ "expression": {
+ "type": "Identifier",
+ "start": 553,
+ "end": 558,
+ "loc": {
+ "start": {
+ "line": 11,
+ "column": 10
+ },
+ "end": {
+ "line": 11,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 559,
+ "end": 560,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 564,
+ "end": 566,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 566,
+ "end": 628,
+ "data": " a word before a spaced tag pair, and a word after one "
+ },
+ {
+ "type": "Text",
+ "start": 628,
+ "end": 629,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 629,
+ "end": 660,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 15,
+ "column": 1,
+ "character": 630
+ },
+ "end": {
+ "line": 15,
+ "column": 2,
+ "character": 631
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 632,
+ "end": 640,
+ "raw": "\n\ttext1 ",
+ "data": "\n\ttext1 "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 640,
+ "end": 647,
+ "expression": {
+ "type": "Identifier",
+ "start": 641,
+ "end": 646,
+ "loc": {
+ "start": {
+ "line": 16,
+ "column": 8
+ },
+ "end": {
+ "line": 16,
+ "column": 13
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 647,
+ "end": 648,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 648,
+ "end": 655,
+ "expression": {
+ "type": "Identifier",
+ "start": 649,
+ "end": 654,
+ "loc": {
+ "start": {
+ "line": 16,
+ "column": 16
+ },
+ "end": {
+ "line": 16,
+ "column": 21
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 655,
+ "end": 656,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 660,
+ "end": 661,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 661,
+ "end": 700,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 18,
+ "column": 1,
+ "character": 662
+ },
+ "end": {
+ "line": 18,
+ "column": 2,
+ "character": 663
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 664,
+ "end": 666,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 666,
+ "end": 673,
+ "expression": {
+ "type": "Identifier",
+ "start": 667,
+ "end": 672,
+ "loc": {
+ "start": {
+ "line": 19,
+ "column": 2
+ },
+ "end": {
+ "line": 19,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 673,
+ "end": 674,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 674,
+ "end": 681,
+ "expression": {
+ "type": "Identifier",
+ "start": 675,
+ "end": 680,
+ "loc": {
+ "start": {
+ "line": 19,
+ "column": 10
+ },
+ "end": {
+ "line": 19,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 681,
+ "end": 682,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 682,
+ "end": 689,
+ "expression": {
+ "type": "Identifier",
+ "start": 683,
+ "end": 688,
+ "loc": {
+ "start": {
+ "line": 19,
+ "column": 18
+ },
+ "end": {
+ "line": 19,
+ "column": 23
+ }
+ },
+ "name": "expr3"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 689,
+ "end": 696,
+ "raw": " text1\n",
+ "data": " text1\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 700,
+ "end": 702,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 702,
+ "end": 793,
+ "data": " at the root, which is always a multiline container: the escaped-angle-bracket pair "
+ },
+ {
+ "type": "Text",
+ "start": 793,
+ "end": 794,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 794,
+ "end": 799,
+ "expression": {
+ "type": "Literal",
+ "start": 795,
+ "end": 798,
+ "loc": {
+ "start": {
+ "line": 23,
+ "column": 1
+ },
+ "end": {
+ "line": 23,
+ "column": 4
+ }
+ },
+ "value": "<",
+ "raw": "'<'"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 799,
+ "end": 802,
+ "raw": "div",
+ "data": "div"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 802,
+ "end": 807,
+ "expression": {
+ "type": "Literal",
+ "start": 803,
+ "end": 806,
+ "loc": {
+ "start": {
+ "line": 23,
+ "column": 9
+ },
+ "end": {
+ "line": 23,
+ "column": 12
+ }
+ },
+ "value": ">",
+ "raw": "'>'"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 807,
+ "end": 808,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 808,
+ "end": 813,
+ "expression": {
+ "type": "Literal",
+ "start": 809,
+ "end": 812,
+ "loc": {
+ "start": {
+ "line": 23,
+ "column": 15
+ },
+ "end": {
+ "line": 23,
+ "column": 18
+ }
+ },
+ "value": "<",
+ "raw": "'<'"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 813,
+ "end": 817,
+ "raw": "code",
+ "data": "code"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 817,
+ "end": 822,
+ "expression": {
+ "type": "Literal",
+ "start": 818,
+ "end": 821,
+ "loc": {
+ "start": {
+ "line": 23,
+ "column": 24
+ },
+ "end": {
+ "line": 23,
+ "column": 27
+ }
+ },
+ "value": ">",
+ "raw": "'>'"
+ }
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 822,
+ "end": 827,
+ "expression": {
+ "type": "Literal",
+ "start": 823,
+ "end": 826,
+ "loc": {
+ "start": {
+ "line": 23,
+ "column": 29
+ },
+ "end": {
+ "line": 23,
+ "column": 32
+ }
+ },
+ "value": "<",
+ "raw": "'<'"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 827,
+ "end": 832,
+ "raw": "/code",
+ "data": "/code"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 832,
+ "end": 837,
+ "expression": {
+ "type": "Literal",
+ "start": 833,
+ "end": 836,
+ "loc": {
+ "start": {
+ "line": 23,
+ "column": 39
+ },
+ "end": {
+ "line": 23,
+ "column": 42
+ }
+ },
+ "value": ">",
+ "raw": "'>'"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 837,
+ "end": 839,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 839,
+ "end": 1049,
+ "data": " an inline element or a component before a tag, and a component between two tags, pack the\n same way: one answer at every sibling kind, where a tag before an element or component\n already packed "
+ },
+ {
+ "type": "Text",
+ "start": 1049,
+ "end": 1050,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1050,
+ "end": 1087,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 28,
+ "column": 1,
+ "character": 1051
+ },
+ "end": {
+ "line": 28,
+ "column": 2,
+ "character": 1052
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1053,
+ "end": 1055,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1055,
+ "end": 1075,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 29,
+ "column": 2,
+ "character": 1056
+ },
+ "end": {
+ "line": 29,
+ "column": 6,
+ "character": 1060
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1061,
+ "end": 1068,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1075,
+ "end": 1076,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1076,
+ "end": 1082,
+ "expression": {
+ "type": "Identifier",
+ "start": 1077,
+ "end": 1081,
+ "loc": {
+ "start": {
+ "line": 29,
+ "column": 23
+ },
+ "end": {
+ "line": 29,
+ "column": 27
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1082,
+ "end": 1083,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1087,
+ "end": 1088,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1088,
+ "end": 1113,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 31,
+ "column": 1,
+ "character": 1089
+ },
+ "end": {
+ "line": 31,
+ "column": 2,
+ "character": 1090
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1091,
+ "end": 1093,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "Component",
+ "start": 1093,
+ "end": 1101,
+ "name": "Comp",
+ "name_loc": {
+ "start": {
+ "line": 32,
+ "column": 2,
+ "character": 1094
+ },
+ "end": {
+ "line": 32,
+ "column": 6,
+ "character": 1098
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1101,
+ "end": 1102,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1102,
+ "end": 1108,
+ "expression": {
+ "type": "Identifier",
+ "start": 1103,
+ "end": 1107,
+ "loc": {
+ "start": {
+ "line": 32,
+ "column": 11
+ },
+ "end": {
+ "line": 32,
+ "column": 15
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1108,
+ "end": 1109,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1113,
+ "end": 1114,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1114,
+ "end": 1148,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 34,
+ "column": 1,
+ "character": 1115
+ },
+ "end": {
+ "line": 34,
+ "column": 2,
+ "character": 1116
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1117,
+ "end": 1119,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1119,
+ "end": 1126,
+ "expression": {
+ "type": "Identifier",
+ "start": 1120,
+ "end": 1125,
+ "loc": {
+ "start": {
+ "line": 35,
+ "column": 2
+ },
+ "end": {
+ "line": 35,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1126,
+ "end": 1127,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "Component",
+ "start": 1127,
+ "end": 1135,
+ "name": "Comp",
+ "name_loc": {
+ "start": {
+ "line": 35,
+ "column": 10,
+ "character": 1128
+ },
+ "end": {
+ "line": 35,
+ "column": 14,
+ "character": 1132
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": []
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1135,
+ "end": 1136,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1136,
+ "end": 1143,
+ "expression": {
+ "type": "Identifier",
+ "start": 1137,
+ "end": 1142,
+ "loc": {
+ "start": {
+ "line": 35,
+ "column": 19
+ },
+ "end": {
+ "line": 35,
+ "column": 24
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1143,
+ "end": 1144,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1148,
+ "end": 1150,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1150,
+ "end": 1184,
+ "data": " every tag kind in one run "
+ },
+ {
+ "type": "Text",
+ "start": 1184,
+ "end": 1185,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1185,
+ "end": 1226,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 39,
+ "column": 1,
+ "character": 1186
+ },
+ "end": {
+ "line": 39,
+ "column": 2,
+ "character": 1187
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1188,
+ "end": 1190,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "HtmlTag",
+ "start": 1190,
+ "end": 1199,
+ "expression": {
+ "type": "Identifier",
+ "start": 1197,
+ "end": 1198,
+ "loc": {
+ "start": {
+ "line": 40,
+ "column": 8
+ },
+ "end": {
+ "line": 40,
+ "column": 9
+ }
+ },
+ "name": "a"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1199,
+ "end": 1200,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "RenderTag",
+ "start": 1200,
+ "end": 1214,
+ "expression": {
+ "type": "CallExpression",
+ "start": 1209,
+ "end": 1213,
+ "loc": {
+ "start": {
+ "line": 40,
+ "column": 20
+ },
+ "end": {
+ "line": 40,
+ "column": 24
+ }
+ },
+ "callee": {
+ "type": "Identifier",
+ "start": 1209,
+ "end": 1211,
+ "loc": {
+ "start": {
+ "line": 40,
+ "column": 20
+ },
+ "end": {
+ "line": 40,
+ "column": 22
+ }
+ },
+ "name": "fn"
+ },
+ "arguments": [],
+ "optional": false
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1214,
+ "end": 1215,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1215,
+ "end": 1221,
+ "expression": {
+ "type": "Identifier",
+ "start": 1216,
+ "end": 1220,
+ "loc": {
+ "start": {
+ "line": 40,
+ "column": 27
+ },
+ "end": {
+ "line": 40,
+ "column": 31
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1221,
+ "end": 1222,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1226,
+ "end": 1228,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1228,
+ "end": 1348,
+ "data": " control: the newline spelling of the wordless pair is held — the rule holds a newline, it\n never forces one "
+ },
+ {
+ "type": "Text",
+ "start": 1348,
+ "end": 1349,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1349,
+ "end": 1375,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 45,
+ "column": 1,
+ "character": 1350
+ },
+ "end": {
+ "line": 45,
+ "column": 2,
+ "character": 1351
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1352,
+ "end": 1354,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1354,
+ "end": 1361,
+ "expression": {
+ "type": "Identifier",
+ "start": 1355,
+ "end": 1360,
+ "loc": {
+ "start": {
+ "line": 46,
+ "column": 2
+ },
+ "end": {
+ "line": 46,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1361,
+ "end": 1363,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1363,
+ "end": 1370,
+ "expression": {
+ "type": "Identifier",
+ "start": 1364,
+ "end": 1369,
+ "loc": {
+ "start": {
+ "line": 47,
+ "column": 2
+ },
+ "end": {
+ "line": 47,
+ "column": 7
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1370,
+ "end": 1371,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ }
+ ]
+ },
+ "options": null,
+ "comments": []
+}
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/input.svelte
new file mode 100644
index 000000000..5a705db23
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/input.svelte
@@ -0,0 +1,48 @@
+<!--
+ A space-spelled separator between two tags is a fill boundary that packs per width, whatever
+ its run holds — no word at all, one word, or prose — where prettier's bare `line` between two
+ tags breaks with the multiline container. The sibling-newline flow rule's prose gate is a
+ HOLD on an authored newline and never turns a space into one: the newline spelling of the
+ same pair is held (the control), so the two spellings are two fixed points.
+-->
+
+<!-- a wordless pair: the run holds no text at all, and the pair still packs -->
+<p>
+ {expr1} {expr2}
+</p>
+
+<!-- a word before a spaced tag pair, and a word after one -->
+<p>
+ text1 {expr1} {expr2}
+</p>
+<p>
+ {expr1} {expr2} {expr3} text1
+</p>
+
+<!-- at the root, which is always a multiline container: the escaped-angle-bracket pair -->
+{'<'}div{'>'} {'<'}code{'>'}{'<'}/code{'>'}
+
+<!-- an inline element or a component before a tag, and a component between two tags, pack the
+ same way: one answer at every sibling kind, where a tag before an element or component
+ already packed -->
+<p>
+ <span>inline1</span> {expr}
+</p>
+<p>
+ <Comp /> {expr}
+</p>
+<p>
+ {expr1} <Comp /> {expr2}
+</p>
+
+<!-- every tag kind in one run -->
+<p>
+ {@html a} {@render fn()} {expr}
+</p>
+
+<!-- control: the newline spelling of the wordless pair is held — the rule holds a newline, it
+ never forces one -->
+<p>
+ {expr1}
+ {expr2}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..f0058b00c
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,59 @@
+<!--
+ A space-spelled separator between two tags is a fill boundary that packs per width, whatever
+ its run holds — no word at all, one word, or prose — where prettier's bare `line` between two
+ tags breaks with the multiline container. The sibling-newline flow rule's prose gate is a
+ HOLD on an authored newline and never turns a space into one: the newline spelling of the
+ same pair is held (the control), so the two spellings are two fixed points.
+-->
+
+<!-- a wordless pair: the run holds no text at all, and the pair still packs -->
+<p>
+ {expr1}
+ {expr2}
+</p>
+
+<!-- a word before a spaced tag pair, and a word after one -->
+<p>
+ text1 {expr1}
+ {expr2}
+</p>
+<p>
+ {expr1}
+ {expr2}
+ {expr3} text1
+</p>
+
+<!-- at the root, which is always a multiline container: the escaped-angle-bracket pair -->
+{'<'}div{'>'}
+{'<'}code{'>'}{'<'}/code{'>'}
+
+<!-- an inline element or a component before a tag, and a component between two tags, pack the
+ same way: one answer at every sibling kind, where a tag before an element or component
+ already packed -->
+<p>
+ <span>inline1</span>
+ {expr}
+</p>
+<p>
+ <Comp />
+ {expr}
+</p>
+<p>
+ {expr1}
+ <Comp />
+ {expr2}
+</p>
+
+<!-- every tag kind in one run -->
+<p>
+ {@html a}
+ {@render fn()}
+ {expr}
+</p>
+
+<!-- control: the newline spelling of the wordless pair is held — the rule holds a newline, it
+ never forces one -->
+<p>
+ {expr1}
+ {expr2}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/unformatted_ours_tab.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/unformatted_ours_tab.svelte
new file mode 100644
index 000000000..0b9f9c9cf
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/unformatted_ours_tab.svelte
@@ -0,0 +1,48 @@
+<!--
+ A space-spelled separator between two tags is a fill boundary that packs per width, whatever
+ its run holds — no word at all, one word, or prose — where prettier's bare `line` between two
+ tags breaks with the multiline container. The sibling-newline flow rule's prose gate is a
+ HOLD on an authored newline and never turns a space into one: the newline spelling of the
+ same pair is held (the control), so the two spellings are two fixed points.
+-->
+
+<!-- a wordless pair: the run holds no text at all, and the pair still packs -->
+<p>
+ {expr1} {expr2}
+</p>
+
+<!-- a word before a spaced tag pair, and a word after one -->
+<p>
+ text1 {expr1} {expr2}
+</p>
+<p>
+ {expr1} {expr2} {expr3} text1
+</p>
+
+<!-- at the root, which is always a multiline container: the escaped-angle-bracket pair -->
+{'<'}div{'>'} {'<'}code{'>'}{'<'}/code{'>'}
+
+<!-- an inline element or a component before a tag, and a component between two tags, pack the
+ same way: one answer at every sibling kind, where a tag before an element or component
+ already packed -->
+<p>
+ <span>inline1</span> {expr}
+</p>
+<p>
+ <Comp /> {expr}
+</p>
+<p>
+ {expr1} <Comp /> {expr2}
+</p>
+
+<!-- every tag kind in one run -->
+<p>
+ {@html a} {@render fn()} {expr}
+</p>
+
+<!-- control: the newline spelling of the wordless pair is held — the rule holds a newline, it
+ never forces one -->
+<p>
+ {expr1}
+ {expr2}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/variant_split.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/variant_split.svelte
new file mode 100644
index 000000000..f0058b00c
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/variant_split.svelte
@@ -0,0 +1,59 @@
+<!--
+ A space-spelled separator between two tags is a fill boundary that packs per width, whatever
+ its run holds — no word at all, one word, or prose — where prettier's bare `line` between two
+ tags breaks with the multiline container. The sibling-newline flow rule's prose gate is a
+ HOLD on an authored newline and never turns a space into one: the newline spelling of the
+ same pair is held (the control), so the two spellings are two fixed points.
+-->
+
+<!-- a wordless pair: the run holds no text at all, and the pair still packs -->
+<p>
+ {expr1}
+ {expr2}
+</p>
+
+<!-- a word before a spaced tag pair, and a word after one -->
+<p>
+ text1 {expr1}
+ {expr2}
+</p>
+<p>
+ {expr1}
+ {expr2}
+ {expr3} text1
+</p>
+
+<!-- at the root, which is always a multiline container: the escaped-angle-bracket pair -->
+{'<'}div{'>'}
+{'<'}code{'>'}{'<'}/code{'>'}
+
+<!-- an inline element or a component before a tag, and a component between two tags, pack the
+ same way: one answer at every sibling kind, where a tag before an element or component
+ already packed -->
+<p>
+ <span>inline1</span>
+ {expr}
+</p>
+<p>
+ <Comp />
+ {expr}
+</p>
+<p>
+ {expr1}
+ <Comp />
+ {expr2}
+</p>
+
+<!-- every tag kind in one run -->
+<p>
+ {@html a}
+ {@render fn()}
+ {expr}
+</p>
+
+<!-- control: the newline spelling of the wordless pair is held — the rule holds a newline, it
+ never forces one -->
+<p>
+ {expr1}
+ {expr2}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/README.md b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/README.md
new file mode 100644
index 000000000..558c43664
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/README.md
@@ -0,0 +1,24 @@
+# inline_tag_pair_space_welded_prettier_divergence
+
+A **welded** tag unit beside a **spaced** separator. The glued boundary inside the unit —
+`{expr1}{expr2}`, an ` `, a word glued to both tags — is never split, since breaking there
+would inject a rendered space; the spaced boundary beside it packs per width exactly as it does
+between two lone tags, so the whole run sits on one content line. Prettier's bare `line` between
+a tag and its spaced neighbour breaks with the multiline container, so it splits at every spaced
+boundary (`output_prettier.svelte`) while keeping the welds.
+
+`variant_split.svelte` is prettier's form itself, and tsv keeps it stable too — the newline spelling of
+every boundary is held — so the two forms are two fixed points; a rule change that started
+normalizing prettier's form back to `input.svelte` fails this file rather than passing in prose.
+
+## Reason
+
+Design choice — the rule of
+[inline_tag_pair_space](../inline_tag_pair_space_prettier_divergence/) meeting the welded-unit
+rule of [§Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style):
+a separator's *presence* carries signal (a glued boundary is never split) and its *spelling* does
+not (a space before a tag defers to the tag's per-width group). The welded unit is one movable
+item and the space in front of or behind it is the fill boundary that moves it.
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/expected.json
new file mode 100644
index 000000000..02d788351
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/expected.json
@@ -0,0 +1,520 @@
+{
+ "css": null,
+ "js": [],
+ "start": 0,
+ "end": 567,
+ "type": "Root",
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Comment",
+ "start": 0,
+ "end": 286,
+ "data": "\n\tA welded unit beside a spaced separator: the glued boundary is never split (breaking it would\n\tinject a rendered space), and the spaced one packs per width exactly as it does between two\n\tlone tags — the unit travels whole and the space beside it is an ordinary fill boundary.\n"
+ },
+ {
+ "type": "Text",
+ "start": 286,
+ "end": 288,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 288,
+ "end": 339,
+ "data": " a glued pair before and after a spaced tag "
+ },
+ {
+ "type": "Text",
+ "start": 339,
+ "end": 340,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 340,
+ "end": 372,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 8,
+ "column": 1,
+ "character": 341
+ },
+ "end": {
+ "line": 8,
+ "column": 2,
+ "character": 342
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 343,
+ "end": 345,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 345,
+ "end": 352,
+ "expression": {
+ "type": "Identifier",
+ "start": 346,
+ "end": 351,
+ "loc": {
+ "start": {
+ "line": 9,
+ "column": 2
+ },
+ "end": {
+ "line": 9,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 352,
+ "end": 359,
+ "expression": {
+ "type": "Identifier",
+ "start": 353,
+ "end": 358,
+ "loc": {
+ "start": {
+ "line": 9,
+ "column": 9
+ },
+ "end": {
+ "line": 9,
+ "column": 14
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 359,
+ "end": 360,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 360,
+ "end": 367,
+ "expression": {
+ "type": "Identifier",
+ "start": 361,
+ "end": 366,
+ "loc": {
+ "start": {
+ "line": 9,
+ "column": 17
+ },
+ "end": {
+ "line": 9,
+ "column": 22
+ }
+ },
+ "name": "expr3"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 367,
+ "end": 368,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 372,
+ "end": 373,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 373,
+ "end": 405,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 11,
+ "column": 1,
+ "character": 374
+ },
+ "end": {
+ "line": 11,
+ "column": 2,
+ "character": 375
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 376,
+ "end": 378,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 378,
+ "end": 385,
+ "expression": {
+ "type": "Identifier",
+ "start": 379,
+ "end": 384,
+ "loc": {
+ "start": {
+ "line": 12,
+ "column": 2
+ },
+ "end": {
+ "line": 12,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 385,
+ "end": 386,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 386,
+ "end": 393,
+ "expression": {
+ "type": "Identifier",
+ "start": 387,
+ "end": 392,
+ "loc": {
+ "start": {
+ "line": 12,
+ "column": 10
+ },
+ "end": {
+ "line": 12,
+ "column": 15
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 393,
+ "end": 400,
+ "expression": {
+ "type": "Identifier",
+ "start": 394,
+ "end": 399,
+ "loc": {
+ "start": {
+ "line": 12,
+ "column": 17
+ },
+ "end": {
+ "line": 12,
+ "column": 22
+ }
+ },
+ "name": "expr3"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 400,
+ "end": 401,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 405,
+ "end": 407,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 407,
+ "end": 489,
+ "data": " glue that is content: a non-breaking space, and a word glued to both tags "
+ },
+ {
+ "type": "Text",
+ "start": 489,
+ "end": 490,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 490,
+ "end": 528,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 16,
+ "column": 1,
+ "character": 491
+ },
+ "end": {
+ "line": 16,
+ "column": 2,
+ "character": 492
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 493,
+ "end": 495,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 495,
+ "end": 502,
+ "expression": {
+ "type": "Identifier",
+ "start": 496,
+ "end": 501,
+ "loc": {
+ "start": {
+ "line": 17,
+ "column": 2
+ },
+ "end": {
+ "line": 17,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 502,
+ "end": 508,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 508,
+ "end": 515,
+ "expression": {
+ "type": "Identifier",
+ "start": 509,
+ "end": 514,
+ "loc": {
+ "start": {
+ "line": 17,
+ "column": 15
+ },
+ "end": {
+ "line": 17,
+ "column": 20
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 515,
+ "end": 516,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 516,
+ "end": 523,
+ "expression": {
+ "type": "Identifier",
+ "start": 517,
+ "end": 522,
+ "loc": {
+ "start": {
+ "line": 17,
+ "column": 23
+ },
+ "end": {
+ "line": 17,
+ "column": 28
+ }
+ },
+ "name": "expr3"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 523,
+ "end": 524,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 528,
+ "end": 529,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 529,
+ "end": 566,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 19,
+ "column": 1,
+ "character": 530
+ },
+ "end": {
+ "line": 19,
+ "column": 2,
+ "character": 531
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 532,
+ "end": 534,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 534,
+ "end": 541,
+ "expression": {
+ "type": "Identifier",
+ "start": 535,
+ "end": 540,
+ "loc": {
+ "start": {
+ "line": 20,
+ "column": 2
+ },
+ "end": {
+ "line": 20,
+ "column": 7
+ }
+ },
+ "name": "expr1"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 541,
+ "end": 546,
+ "raw": "text1",
+ "data": "text1"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 546,
+ "end": 553,
+ "expression": {
+ "type": "Identifier",
+ "start": 547,
+ "end": 552,
+ "loc": {
+ "start": {
+ "line": 20,
+ "column": 14
+ },
+ "end": {
+ "line": 20,
+ "column": 19
+ }
+ },
+ "name": "expr2"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 553,
+ "end": 554,
+ "raw": " ",
+ "data": " "
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 554,
+ "end": 561,
+ "expression": {
+ "type": "Identifier",
+ "start": 555,
+ "end": 560,
+ "loc": {
+ "start": {
+ "line": 20,
+ "column": 22
+ },
+ "end": {
+ "line": 20,
+ "column": 27
+ }
+ },
+ "name": "expr3"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 561,
+ "end": 562,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ }
+ ]
+ },
+ "options": null,
+ "comments": []
+}
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/input.svelte
new file mode 100644
index 000000000..1b1c110bb
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/input.svelte
@@ -0,0 +1,21 @@
+<!--
+ A welded unit beside a spaced separator: the glued boundary is never split (breaking it would
+ inject a rendered space), and the spaced one packs per width exactly as it does between two
+ lone tags — the unit travels whole and the space beside it is an ordinary fill boundary.
+-->
+
+<!-- a glued pair before and after a spaced tag -->
+<p>
+ {expr1}{expr2} {expr3}
+</p>
+<p>
+ {expr1} {expr2}{expr3}
+</p>
+
+<!-- glue that is content: a non-breaking space, and a word glued to both tags -->
+<p>
+ {expr1} {expr2} {expr3}
+</p>
+<p>
+ {expr1}text1{expr2} {expr3}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..7b5a38c41
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,25 @@
+<!--
+ A welded unit beside a spaced separator: the glued boundary is never split (breaking it would
+ inject a rendered space), and the spaced one packs per width exactly as it does between two
+ lone tags — the unit travels whole and the space beside it is an ordinary fill boundary.
+-->
+
+<!-- a glued pair before and after a spaced tag -->
+<p>
+ {expr1}{expr2}
+ {expr3}
+</p>
+<p>
+ {expr1}
+ {expr2}{expr3}
+</p>
+
+<!-- glue that is content: a non-breaking space, and a word glued to both tags -->
+<p>
+ {expr1} {expr2}
+ {expr3}
+</p>
+<p>
+ {expr1}text1{expr2}
+ {expr3}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/variant_split.svelte b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/variant_split.svelte
new file mode 100644
index 000000000..7b5a38c41
--- /dev/null
+++ b/tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/variant_split.svelte
@@ -0,0 +1,25 @@
+<!--
+ A welded unit beside a spaced separator: the glued boundary is never split (breaking it would
+ inject a rendered space), and the spaced one packs per width exactly as it does between two
+ lone tags — the unit travels whole and the space beside it is an ordinary fill boundary.
+-->
+
+<!-- a glued pair before and after a spaced tag -->
+<p>
+ {expr1}{expr2}
+ {expr3}
+</p>
+<p>
+ {expr1}
+ {expr2}{expr3}
+</p>
+
+<!-- glue that is content: a non-breaking space, and a word glued to both tags -->
+<p>
+ {expr1} {expr2}
+ {expr3}
+</p>
+<p>
+ {expr1}text1{expr2}
+ {expr3}
+</p>
diff --git a/tests/fixtures/svelte/elements/inline_with_if_block_multiline_prettier_divergence/unformatted_ours_compact.svelte b/tests/fixtures/svelte/elements/inline_with_if_block_multiline_prettier_divergence/unformatted_ours_compact.svelte
index 1f1b2e533..d64a36bd1 100644
--- a/tests/fixtures/svelte/elements/inline_with_if_block_multiline_prettier_divergence/unformatted_ours_compact.svelte
+++ b/tests/fixtures/svelte/elements/inline_with_if_block_multiline_prettier_divergence/unformatted_ours_compact.svelte
@@ -1,3 +1,4 @@
<span data-attr="value">{#if cond} <Comp />
-{/if} {x}</span>
+{/if}
+{x}</span>
diff --git a/tests/fixtures/svelte/elements/multiline_sibling_block_break/unformatted_compact.svelte b/tests/fixtures/svelte/elements/multiline_sibling_block_break/unformatted_compact.svelte
index 1ecbe0a21..9ddf199ff 100644
--- a/tests/fixtures/svelte/elements/multiline_sibling_block_break/unformatted_compact.svelte
+++ b/tests/fixtures/svelte/elements/multiline_sibling_block_break/unformatted_compact.svelte
@@ -1,5 +1,7 @@
<section>
- <span>s</span> {#if a}b{/if}
- <Comp /> {#each xs as x}{x}{/each}
- <p>force</p>
+<span>s</span>
+{#if a}b{/if}
+<Comp />
+{#each xs as x}{x}{/each}
+<p>force</p>
</section>
diff --git a/tests/fixtures/svelte/elements/multiline_sibling_comment_break/unformatted_compact.svelte b/tests/fixtures/svelte/elements/multiline_sibling_comment_break/unformatted_compact.svelte
index 840fb2f22..5c0994f93 100644
--- a/tests/fixtures/svelte/elements/multiline_sibling_comment_break/unformatted_compact.svelte
+++ b/tests/fixtures/svelte/elements/multiline_sibling_comment_break/unformatted_compact.svelte
@@ -1,5 +1,8 @@
<section>
- <span>a</span> <!-- c -->
- <Comp /> <!-- d --> {e}
- <p>force</p>
+<span>a</span>
+<!-- c -->
+<Comp />
+<!-- d -->
+{e}
+<p>force</p>
</section>
diff --git a/tests/fixtures/svelte/elements/multiline_siblings_break/unformatted_compact.svelte b/tests/fixtures/svelte/elements/multiline_siblings_break/unformatted_compact.svelte
index ebfb8bf73..6e371c57c 100644
--- a/tests/fixtures/svelte/elements/multiline_siblings_break/unformatted_compact.svelte
+++ b/tests/fixtures/svelte/elements/multiline_siblings_break/unformatted_compact.svelte
@@ -1,7 +1,8 @@
<Foo/>
<Bar/>
-{a} {b}
+{a}
+{b}
<section>
<Baz/>
diff --git a/tests/fixtures/svelte/expressions/angle_escaped_prettier_divergence/README.md b/tests/fixtures/svelte/expressions/angle_escaped_prettier_divergence/README.md
index cb9c07883..3eb997e53 100644
--- a/tests/fixtures/svelte/expressions/angle_escaped_prettier_divergence/README.md
+++ b/tests/fixtures/svelte/expressions/angle_escaped_prettier_divergence/README.md
@@ -33,7 +33,7 @@ one word each, and a pair with nothing else in its run is a list of labels whose
both formatters hold — the flow rule's prose gate,
[inline_sibling_newline_label_hold](../../elements/inline_sibling_newline_label_hold_prettier_divergence/);
its space spelling is
-[inline_sibling_newline_label_hold_tag_pair_space](../../elements/inline_sibling_newline_label_hold_tag_pair_space_prettier_divergence/),
+[inline_tag_pair_space](../../elements/inline_tag_pair_space_prettier_divergence/),
where tsv keeps the pair packed and prettier splits it — so the two-word content is what makes
the newline-authored run flow here. The comment is load-bearing — it bounds the run above, so the
pair and its content are the whole flowing run.
diff --git a/tests/fixtures/svelte/syntax/comments/inline_html_spaced/unformatted_spaces.svelte b/tests/fixtures/svelte/syntax/comments/inline_html_spaced/unformatted_spaces.svelte
index 5803be7eb..fa3767940 100644
--- a/tests/fixtures/svelte/syntax/comments/inline_html_spaced/unformatted_spaces.svelte
+++ b/tests/fixtures/svelte/syntax/comments/inline_html_spaced/unformatted_spaces.svelte
@@ -1 +1,2 @@
-<span>a</span> <!-- comment --> <span>b</span>
+<span>a</span>
+<!-- comment --> <span>b</span>
diff --git a/tests/fixtures/svelte/syntax/comments/root_components_spaced/unformatted_spaced.svelte b/tests/fixtures/svelte/syntax/comments/root_components_spaced/unformatted_spaced.svelte
deleted file mode 100644
index 4b2cfb402..000000000
--- a/tests/fixtures/svelte/syntax/comments/root_components_spaced/unformatted_spaced.svelte
+++ /dev/null
@@ -1,2 +0,0 @@
-<Comp /> <!-- comment -->
-<Comp2 />
diff --git a/tests/fixtures/svelte/syntax/comments/root_components_spaced/unformatted_spaces.svelte b/tests/fixtures/svelte/syntax/comments/root_components_spaced/unformatted_spaces.svelte
index 36eaa32a5..6f12a31b3 100644
--- a/tests/fixtures/svelte/syntax/comments/root_components_spaced/unformatted_spaces.svelte
+++ b/tests/fixtures/svelte/syntax/comments/root_components_spaced/unformatted_spaces.svelte
@@ -1,2 +1,3 @@
-<Comp /> <!-- comment -->
-<Comp2 />
+<Comp />
+<!-- comment -->
+ <Comp2 />
diff --git a/tests/fixtures/svelte/syntax/comments/root_expressions_spaced/unformatted_spaced.svelte b/tests/fixtures/svelte/syntax/comments/root_expressions_spaced/unformatted_spaced.svelte
deleted file mode 100644
index 0ece9451b..000000000
--- a/tests/fixtures/svelte/syntax/comments/root_expressions_spaced/unformatted_spaced.svelte
+++ /dev/null
@@ -1 +0,0 @@
-{expr1} <!-- comment --> {expr2}
diff --git a/tests/fixtures/svelte/syntax/comments/root_expressions_spaced/unformatted_spaces.svelte b/tests/fixtures/svelte/syntax/comments/root_expressions_spaced/unformatted_spaces.svelte
index 54122da49..8d5cc80f4 100644
--- a/tests/fixtures/svelte/syntax/comments/root_expressions_spaced/unformatted_spaces.svelte
+++ b/tests/fixtures/svelte/syntax/comments/root_expressions_spaced/unformatted_spaces.svelte
@@ -1 +1,3 @@
-{expr1} <!-- comment --> {expr2}
+{expr1}
+<!-- comment -->
+ {expr2}