Using {{- .Inner -}} still adds newlines


According to this article, if you add dashes when getting a variable it should strip all new lines and white-space.

I’m currently using a custom shortcode that looks like this:

<pre><code class="language-{{- .Get 0 -}}">{{- .Inner -}}</code></pre>

If I use it like so:

{{< prism yaml >}}
highlighter: none
{{< /prism >}}

It renders output like:

<pre><code class="language-yaml">
highlighter: none

Which isn’t correct because it has newlines surrounding the highlighter: none even though the dashes are supposed to remove it.

From my understanding, it should just output <pre><code class="language-yaml">highlighter: none</code></pre>.

Is it just user error on my part or something else?

I’m using Hugo version 0.39.


I confirm this issue:

But there’s also a workaround. Try:

{{< prism yaml >}}highlighter: none{{< /prism >}}


I found that workaround as well but the issue is that whenever I have content spanning multiple lines that are surrounded in the short-codes, it is very ugly.

Do you think this is a bug within Hugo?


It’s not clear if the current behavior is intended or not. I’ll allow @bep to comment on that.

I agree that the workaround looks quite ugly.


Any comment on this @bep?


I’m pretty confident that the shortcode parser/handler does not add anything, so I would expect the same as you in the above. But whitespace in Go templates is little bit of a mystery.

So, if you could try the same construct (if possible) in a regular template and see how that works …

package main

import (

type Data struct {
    Content string

func main() {
    validData := Data{"highlight: true"}

    brokenData := Data{"\nhighlight: true"}

    tmpl, err := template.New("test").Parse("{{- .Content -}}")
    if err != nil { panic(err) }

    fmt.Printf("Doesn't contain a new line\n")
    err = tmpl.Execute(os.Stdout, validData)
    if err != nil { panic(err) }

    fmt.Printf("\nContains a new line but should be removed\n")
    err = tmpl.Execute(os.Stdout, brokenData)
    if err != nil { panic(err) }


If you run the above example, the second data entry (brokenData) contains a new line but Go doesn’t seem to be stripping like it is supposed to. So is the issue with Go itself or is my test wrong?

I ran the above with go v1.10.1 (linux/amd64)


Your test looks correct and reproduces the exact same scenario. I ran it myself with the same result.

I reread the spec about this:

And this looks like a bug to me.

Could you raise an issue here:

Add the test program on the issue so it is obvious what you are talking about.


Would it be best to re-open the issue I made previously on GitHub or make a new one?


Sorry, I posted the wrong link:


Here is a link to the created issue


The above issue was closed as the dashes aren’t supposed to remove newlines from the variable, but the area surrounding it.

I’m just using this now:

<pre><code class="language-{{- .Get 0 -}}">{{ trim .Inner "\n" }}</code></pre>