How to replace optional group with regex and Golang

I am trying to translate this:

{% img <right> /images/testing %}

into this:

{{< figure <class="right"> src="/images/testing" >}}

with regex in Golang. The part in <> in the source string is optional.

I have this code, which seems to work in the main test case, when the first capturing group exists ("right"):

regexp.MustCompile(`{%\s*img\s*(\p{L}*)\s+([/\S]+)\s+%}`)
.ReplaceAllString("{% img right /images/testing %}", "{{< figure class=\"$1\" src=\"$2\" >}}")

If the optional group is missing, however, I get:

{{< figure class="" src="/images/testing" >}}

which is not what I need - I want the entire class="" section gone, like this:

{{< figure src="/images/testing" >}}

Is this possible? Can I indicate somehow in the replacing string:

{{< figure class=\"$1\" src=\"$2\" >}}

that I want the additional text ("class=") gone if the optional group is empty?

Go regexp do not support conditional statements and the Replace family of regexp functions doesn't either.
The solution to this depends on the number of special cases you have.

If you only have the one case I'd suggest to just do a two pass replacement: First replace all occurences with the attribute set, then replace all the cases without the attribute (on play):

txt := `{% img right /images/testing %}\n{% img /images/testing %}`

// without attribute
txt = regexp.MustCompile(`{%\s*img\s*([/\S]+)\s+%}`).
  ReplaceAllString(txt, "{{< figure src=\"$1\" >}}")

// with attribute
txt = regexp.MustCompile(`{%\s*img\s*(\p{L}*)\s+([/\S]+)\s+%}`).
  ReplaceAllString(txt, "{{< figure class=\"$1\" src=\"$2\" >}}")

If you say this is inefficient I say: probably, yes. If you want something more efficient (i.e. something that does not iterate the source string twice) then you have to build something more akin to a parser which decides at the time of detection which format to use. A rough sketch of this would be something like this (on play):

src := []byte("ok" + "{% img right /images/testing %}" + "this" + 
              "{% img /images/testing %}" + "no?")
dst := bytes.NewBufferString("")
cidx := 0

for _, match := range p.FindAllSubmatchIndex(src, -1) {
	dst.Write(src[cidx:match[0]])
	dst.WriteString(newFormat(src, src[match[2]:match[3]], src[match[4]:match[5]]))
	cidx = match[1]
}
dst.Write(src[cidx:])

In this example you copy everything from your source text src to a buffer dst, replacing every occurrence of your pattern with the output of the value of a function. This function can then decide to include specific formatting or not.