templ fmt cuts off necessary whitespace

[mxmlndml]

Describe the bug
I have an issue with templ fmt with composed templates that contain inline elements. When embedding a different template on a new line, the whitespace before or after the template gets automatically removed by the formatter. See the example below.

To Reproduce
Assume, you have this .templ file:

package main

templ Link(href string) {
	<a href={ templ.URL(href) }>
		{ children... }
	</a>
}

templ Index() {
	<p>
		@Link("https://templ.guide") {
			This
		}
		 is my favorite website
	</p>
}

After running templ fmt ., the formatting gets changed to this:

package main

templ Link(href string) {
	<a href={ templ.URL(href) }>
		{ children... }
	</a>
}

templ Index() {
	<p>
		@Link("https://templ.guide") {
			This
		}
		is my favorite website
	</p>
}

Notice how the space in front of "is my favorite website" got removed. This would not be an issue if the Link template would not be an inline element. Now the resulting HTML looks like this:

<p><a href="https://templ.guide">This</a>is my favorite website</p>

instead of this:

<p><a href="https://templ.guide">This</a> is my favorite website</p>

Side-by-side comparison in the browser:

Expected behavior
templ fmt should only remove unnecessary whitespace so that the formatting does not cause a difference when rendered by a browser. Specifically in this case, templ fmt should not remove the space in front of the text or a template.

templ info output
(✓) os [ goos=darwin goarch=arm64 ]
(✓) go [ location=/opt/homebrew/bin/go version=go version go1.24.0 darwin/arm64 ]
(✓) gopls [ location=/Users/user/go/bin/gopls version=golang.org/x/tools/gopls v0.18.1 ]
(✓) templ [ location=/Users/user/go/bin/templ version=v0.3.833 ]

Desktop (please complete the following information):

• OS: macOS
• templ CLI version v0.3.833
• Go version go1.24.0 darwin/arm64
• gopls version golang.org/x/tools/gopls v0.18.1

Additional context
This issue is not restricted to templ fmt. Running templ generate on an unformatted .templ file yields the same formatting issue. I suspect during generation whitespace is trimmed in a similar manner as with templ fmt.

I came up with the following workarounds for the moment:

1. use HTML entities:

templ Index() {
	<p>
		@Link("https://templ.guide") {
			This
		}
		&nbsp;is my favorite website
	</p>
}

However, this leads to different textual output but will get rendered correctly in a browser.

2. use an empty expression:

templ Index() {
	<p>
		@Link("https://templ.guide") {
			This
		}
		{ `` } is my favorite website
	</p>
}

[a-h]

Thanks for the bug report. Just leaving some notes.

Some of the parsed elements parse trailing whitespace so it can be maintained:

• templ/parser/v2/textparser.go

  Lines 33 to 41 in f0a1f0c

  	// Parse trailing whitespace.
  	ws, _, err := parse.Whitespace.Parse(pi)
  	if err != nil {
  	return t, false, err
  	}
  	t.TrailingSpace, err = NewTrailingSpace(ws)
  	if err != nil {
  	return t, false, err
  	}

• templ/parser/v2/stringexpressionparser.go

  Lines 29 to 36 in f0a1f0c

  	ws, _, err := parse.Whitespace.Parse(pi)
  	if err != nil {
  	return r, false, err
  	}
  	r.TrailingSpace, err = NewTrailingSpace(ws)
  	if err != nil {
  	return r, false, err
  	}

• templ/parser/v2/elementparser.go

  Lines 492 to 515 in f0a1f0c

  	func addTrailingSpaceAndValidate(start parse.Position, e Element, pi *parse.Input) (n Node, ok bool, err error) {
  	// Elide any void close tags.
  	if _, _, err = voidElementCloser.Parse(pi); err != nil {
  	return e, false, err
  	}
  	// Add trailing space.
  	ws, _, err := parse.Whitespace.Parse(pi)
  	if err != nil {
  	return e, false, err
  	}
  	e.TrailingSpace, err = NewTrailingSpace(ws)
  	if err != nil {
  	return e, false, err
  	}
  	// Validate.
  	var msgs []string
  	if msgs, ok = e.Validate(); !ok {
  	err = parse.Error(fmt.Sprintf("<%s>: %s", e.Name, strings.Join(msgs, ", ")), start)
  	return e, false, err
  	}
  	return e, true, nil
  	}

Whereas others just throw any padding away:

• templ/parser/v2/elementparser.go

  Lines 220 to 224 in f0a1f0c

  	// Optional whitespace leader.
  	if _, ok, err = parse.OptionalWhitespace.Parse(pi); err != nil || !ok {
  	pi.Seek(start)
  	return
  	}

I expect the fix here is to apply the same rules as the HTML element stuff -

templ/parser/v2/elementparser.go

Lines 492 to 515 in f0a1f0c

	func addTrailingSpaceAndValidate(start parse.Position, e Element, pi *parse.Input) (n Node, ok bool, err error) {
	// Elide any void close tags.
	if _, _, err = voidElementCloser.Parse(pi); err != nil {
	return e, false, err
	}
	// Add trailing space.
	ws, _, err := parse.Whitespace.Parse(pi)
	if err != nil {
	return e, false, err
	}
	e.TrailingSpace, err = NewTrailingSpace(ws)
	if err != nil {
	return e, false, err
	}
	// Validate.
	var msgs []string
	if msgs, ok = e.Validate(); !ok {
	err = parse.Error(fmt.Sprintf("<%s>: %s", e.Name, strings.Join(msgs, ", ")), start)
	return e, false, err
	}
	return e, true, nil
	}

[a-h]

Oh, by the way, the formatter works by parsing the template into an in-memory representation, then writing it out again.

e.g. trailing whitespace rules for HTML elements are here:

templ/parser/v2/types.go

Lines 609 to 617 in f0a1f0c

	// Apply trailing whitespace if present.
	trailing := SpaceVertical
	if wst, isWhitespaceTrailer := nodes[i].(WhitespaceTrailer); isWhitespaceTrailer {
	trailing = wst.Trailing()
	}
	// Put a newline after the last node in indentation mode.
	if indent && ((nextNodeIsBlock(nodes, i) || i == len(nodes)-1) || shouldAlwaysBreakAfter(nodes[i])) {
	trailing = SpaceVertical
	}