diff --git a/common.go b/common.go
index 63ae985..62f39d6 100644
--- a/common.go
+++ b/common.go
@@ -22,7 +22,7 @@ func validStart(pos int, input []rune) bool {
 }
 
 func validEnd(pos int, input []rune) bool {
-	// First char is not a valid end char.
+	// First char is not a valid end char; we do NOT allow empty entities.
 	// If the end char has a space before it, its not valid either.
 	if pos == 0 || unicode.IsSpace(input[pos-1]) {
 		return false
diff --git a/commonV2.go b/commonV2.go
index 8bc9173..355cdca 100644
--- a/commonV2.go
+++ b/commonV2.go
@@ -148,7 +148,7 @@ func isClosingTag(in []rune, pos int) bool {
 	return false
 }
 
-func getClosingTag(in []rune, tag string) (int, int) {
+func getClosingTag(in []rune, openingTag string, closingTag string) (int, int) {
 	offset := 0
 	subtags := 0
 	for offset < len(in) {
@@ -164,9 +164,9 @@ func getClosingTag(in []rune, tag string) (int, int) {
 		}
 
 		closingTagIdx := openingTagIdx + 2 + c
-		if string(in[openingTagIdx+1:closingTagIdx]) == tag { // found a nested tag, this is annoying
+		if string(in[openingTagIdx+1:closingTagIdx]) == openingTag { // found a nested tag, this is annoying
 			subtags++
-		} else if isClosingTag(in, openingTagIdx) && string(in[openingTagIdx+2:closingTagIdx]) == tag {
+		} else if isClosingTag(in, openingTagIdx) && string(in[openingTagIdx+2:closingTagIdx]) == closingTag {
 			if subtags == 0 {
 				return openingTagIdx, closingTagIdx
 			}
diff --git a/common_test.go b/common_test.go
new file mode 100644
index 0000000..11c66c3
--- /dev/null
+++ b/common_test.go
@@ -0,0 +1,14 @@
+package tg_md2html_test
+
+import "github.com/PaulSonOfLars/gotg_md2html"
+
+func testConverter() *tg_md2html.ConverterV2 {
+	return tg_md2html.NewV2(map[string]string{
+		"url":  "buttonurl",
+		"text": "buttontext",
+	}, map[string]string{
+		"primary": "primary",
+		"success": "success",
+		"danger":  "danger",
+	})
+}
diff --git a/go.mod b/go.mod
index 77b6cd7..ac44284 100644
--- a/go.mod
+++ b/go.mod
@@ -2,7 +2,7 @@ module github.com/PaulSonOfLars/gotg_md2html
 
 go 1.19
 
-require github.com/stretchr/testify v1.8.4
+require github.com/stretchr/testify v1.11.1
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
diff --git a/go.sum b/go.sum
index fa4b6e6..c4c1710 100644
--- a/go.sum
+++ b/go.sum
@@ -2,8 +2,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/md2htmlV2.go b/md2htmlV2.go
index 56d3a5a..a750080 100644
--- a/md2htmlV2.go
+++ b/md2htmlV2.go
@@ -4,31 +4,61 @@ import (
 	"html"
 	"sort"
 	"strings"
+	"unicode"
 )
 
 var defaultConverterV2 = ConverterV2{
 	Prefixes: map[string]string{
-		"url": "buttonurl:",
+		"url": "buttonurl",
+	},
+	Styles: map[string]string{
+		"primary": "primary",
+		"success": "success",
+		"danger":  "danger",
 	},
 	SameLineSuffix: sameLineSuffix,
 }
 
-// ButtonV2 identifies a button. It can contain either a URL, or Text, depending on whether it is a buttonURL: or a buttonText:
+// ButtonV2 identifies a button.
+// The markdown syntax for a button is as such (where <> represents fields)
+// [<name>](<prefix>:<content>)
+// [<name>](<prefix>:<content>:<sameline>)
+// [<name>](<prefix>#<style>:<content>)
+// [<name>](<prefix>#<style>:<content>:<sameline>)
 type ButtonV2 struct {
-	Name     string
-	Type     string
-	Content  string
+	// Name of the button, defined by the user inside the []
+	Name string
+	// The type of the button - as determined by the "prefixes" in ConverterV2
+	Type string
+	// The content of the button; a url, text, etc.
+	Content string
+	// Whether the button should be on the same line as the previous one.
 	SameLine bool
+	// According to telegram, one of: "danger" (red), "success" (green), or "primary" (blue).
+	// https://core.telegram.org/bots/api#keyboardbutton
+	Style string
 }
 
 type ConverterV2 struct {
-	Prefixes       map[string]string
+	// Prefixes determines how to map button types to button prefixes.
+	// Eg; "url": "buttonurl" creates a URL button when the prefix is "buttonurl"
+	Prefixes map[string]string
+	// Styles determines how to map style names to the relevant telegram value.
+	// Eg: "primary": "primary" just enabled "primary" style.
+	// Eg: "green": "success" would allow users to use "green" as an alias for "success"
+	Styles         map[string]string
 	SameLineSuffix string
 }
 
-func NewV2(prefixes map[string]string) *ConverterV2 {
+func NewV2(prefixes map[string]string, styles map[string]string) *ConverterV2 {
+	cleanPref := make(map[string]string)
+	for k, v := range prefixes {
+		cleanPref[k] = strings.TrimSuffix(v, ":")
+	}
+
 	return &ConverterV2{
-		Prefixes:       prefixes,
+		Prefixes:       cleanPref,
+		Styles:         styles,
 		SameLineSuffix: sameLineSuffix,
 	}
 }
@@ -42,20 +72,23 @@ func MD2HTMLButtonsV2(in string) (string, []ButtonV2) {
 }
 
 var chars = map[string]string{
-	"`":   "code",
-	"```": "pre",
-	"_":   "i",
-	"*":   "b",
-	"~":   "s",
-	"__":  "u",
-	"|":   "", // this is a placeholder for || to work
-	"||":  "span class=\"tg-spoiler\"",
-	"!":   "", // for emoji
-	"[":   "", // for links
-	"]":   "", // for links/emoji
-	"(":   "", // for links/emoji
-	")":   "", // for links/emoji
-	"\\":  "", // for escapes
+	"`":    "code",
+	"```":  "pre",
+	"_":    "i",
+	"*":    "b",
+	"~":    "s",
+	"__":   "u",
+	"|":    "", // this is a placeholder for || to work
+	"||":   "span class=\"tg-spoiler\"",
+	"!":    "", // for emoji
+	"![":   "", // for emoji
+	"[":    "", // for links
+	"]":    "", // for links/emoji
+	"(":    "", // for links/emoji
+	")":    "", // for links/emoji
+	"\\":   "", // for escapes
+	"&":    "", // for blockquotes
+	"&gt;": "blockquote",
 }
 
 var AllMarkdownV2Chars = func() []rune {
@@ -86,6 +119,53 @@ var skipStarts = map[rune]bool{
 	'[': true, // links
 }
 
+func getItem(in []rune, i int) (string, int, bool) {
+	c := in[i]
+	if _, ok := chars[string(c)]; !ok {
+		return "", 0, false
+	}
+
+	if !validStart(i, in) && !skipStarts[c] {
+		if c == '\\' && i+1 < len(in) {
+			escaped := string(in[i+1])
+			if _, ok := chars[escaped]; ok {
+				return escaped, 1, false
+			}
+		}
+		return "", 0, false
+	}
+
+	item := string(c)
+	if c == '|' &&
+		i+1 < len(in) && in[i+1] == '|' {
+		return "||", 1, true
+
+	} else if c == '_' &&
+		i+1 < len(in) && in[i+1] == '_' { // support __
+		return "__", 1, true
+
+	} else if c == '`' &&
+		i+2 < len(in) && in[i+1] == '`' && in[i+2] == '`' { // support ```
+		return "```", 2, true
+
+	} else if c == '&' &&
+		i+3 < len(in) && in[i+1] == 'g' && in[i+2] == 't' && in[i+3] == ';' &&
+		validBlockQuoteStart(in, i) {
+		return "&gt;", 3, true
+
+	} else if c == '*' &&
+		i+5 < len(in) && in[i+1] == '*' && in[i+2] == '&' && in[i+3] == 'g' && in[i+4] == 't' && in[i+5] == ';' &&
+		// We force support for **> to allow for people to separate quotes/expandable quote blocks with **
+		validBlockQuoteStart(in, i) {
+		return "**&gt;", 5, true
+
+	} else if c == '!' && i+1 < len(in) && in[i+1] == '[' {
+		return "![", 1, true
+	}
+
+	return item, 0, true
+}
+
 // TODO: add support for a map-like check of which items cannot be included.
 //
 //	Eg: `code` cannot be italic/bold/underline/strikethrough
@@ -96,49 +176,20 @@ func (cv ConverterV2) md2html(in []rune, enableButtons bool) (string, []ButtonV2
 	out := strings.Builder{}
 
 	for i := 0; i < len(in); i++ {
-		c := in[i]
-		if _, ok := chars[string(c)]; !ok {
-			out.WriteRune(c)
-			continue
-		}
-
-		if !validStart(i, in) && !skipStarts[c] {
-			if c == '\\' && i+1 < len(in) {
-				if _, ok := chars[string(in[i+1])]; ok {
-					out.WriteRune(in[i+1])
-					i++
-					continue
-				}
+		item, offset, ok := getItem(in, i)
+		if !ok {
+			if item == "" {
+				item = string(in[i])
 			}
-			out.WriteRune(c)
+			out.WriteString(item)
+			i += offset
 			continue
 		}
+		i += offset
 
-		switch c {
-		case '`', '*', '~', '_', '|': // '||', '__', and '```' are included here too
-			item := string(c)
-			if c == '|' { // support ||
-				// if single |, ignore. We only care about double ||
-				if i+1 >= len(in) || in[i+1] != '|' {
-					out.WriteRune(c)
-					continue
-				}
-
-				item = "||"
-				i++
-			} else if c == '_' && i+1 < len(in) && in[i+1] == '_' { // support __
-				item = "__"
-				i++
-			} else if c == '`' && i+2 < len(in) && in[i+1] == '`' && in[i+2] == '`' { // support ```
-				item = "```"
-				i += 2
-			}
-
-			if i+1 >= len(in) {
-				out.WriteString(item)
-				continue
-			}
-
+		switch item {
+		// All cases where start and closing tags are the same.
+		case "`", "*", "~", "_", "```", "||", "__":
 			idx := getValidEnd(in[i+1:], item)
 			if idx < 0 {
 				// not found; write and move on.
@@ -174,18 +225,33 @@ func (cv ConverterV2) md2html(in []rune, enableButtons bool) (string, []ButtonV2
 			nestedT, nestedB := cv.md2html(in[nStart:nEnd], enableButtons)
 			return out.String() + "<" + chars[item] + ">" + nestedT + "</" + closeSpans(chars[item]) + ">" + followT, append(nestedB, followB...)
 
-		case '!':
-			if len(in) <= i+1 || in[i+1] != '[' {
-				out.WriteRune(c)
+		case "&gt;", "**&gt;":
+			nStart := i + 1
+			for nStart < len(in) && unicode.IsSpace(in[nStart]) {
+				nStart++
+			}
+
+			if nStart >= len(in) {
+				out.WriteString(item)
 				continue
 			}
 
-			ok, text, content, newEnd := getLinkContents(in[i+1:], true)
+			nEnd, contents, expandable := getBlockQuoteEnd(in, nStart)
+			nestedT, nestedB := cv.md2html(contents, enableButtons)
+			followT, followB := cv.md2html(in[nEnd:], enableButtons)
+
+			if expandable {
+				return out.String() + "<blockquote expandable>" + strings.TrimSpace(nestedT) + "</blockquote>" + followT, append(nestedB, followB...)
+			}
+			return out.String() + "<blockquote>" + strings.TrimSpace(nestedT) + "</blockquote>" + followT, append(nestedB, followB...)
+
+		case "![":
+			ok, text, content, newEnd := getLinkContents(in[i:], true)
 			if !ok {
-				out.WriteRune(c)
+				out.WriteString(item)
 				continue
 			}
-			end := i + 1 + newEnd
+			end := i + newEnd
 
 			content = strings.TrimPrefix(content, "tg://emoji?id=")
 
@@ -193,10 +259,10 @@ func (cv ConverterV2) md2html(in []rune, enableButtons bool) (string, []ButtonV2
 			followT, followB := cv.md2html(in[end:], enableButtons)
 			return out.String() + `<tg-emoji emoji-id="` + content + `">` + nestedT + "</tg-emoji>" + followT, append(nestedB, followB...)
 
-		case '[':
+		case "[":
 			ok, text, content, newEnd := getLinkContents(in[i:], false)
 			if !ok {
-				out.WriteRune(c)
+				out.WriteString(item)
 				continue
 			}
 			end := i + newEnd
@@ -205,11 +271,22 @@ func (cv ConverterV2) md2html(in []rune, enableButtons bool) (string, []ButtonV2
 
 			if enableButtons {
 				for buttonType, prefix := range cv.Prefixes {
-					if !strings.HasPrefix(content, prefix) {
+					pref, url, ok := strings.Cut(content, ":")
+					if !ok {
 						continue
 					}
 
-					content := strings.TrimLeft(strings.TrimPrefix(content, prefix), "/")
+					var style string
+					if p, s, ok := strings.Cut(pref, "#"); ok {
+						style = s
+						pref = p
+					}
+
+					if pref != prefix {
+						continue
+					}
+
+					content := strings.TrimLeft(url, "/")
 					sameline := strings.HasSuffix(content, cv.SameLineSuffix)
 					if sameline {
 						content = strings.TrimSuffix(content, cv.SameLineSuffix)
@@ -220,6 +297,7 @@ func (cv ConverterV2) md2html(in []rune, enableButtons bool) (string, []ButtonV2
 						Type:     buttonType,
 						Content:  content,
 						SameLine: sameline,
+						Style:    style,
 					}}, followB...)
 				}
 			}
@@ -227,10 +305,7 @@ func (cv ConverterV2) md2html(in []rune, enableButtons bool) (string, []ButtonV2
 			nestedT, nestedB := cv.md2html(text, enableButtons)
 			return out.String() + `<a href="` + content + `">` + nestedT + "</a>" + followT, append(nestedB, followB...)
 
-		case ']', '(', ')':
-			out.WriteRune(c)
-
-		case '\\':
+		case "\\":
 			if i+1 < len(in) {
 				if _, ok := chars[string(in[i+1])]; ok {
 					out.WriteRune(in[i+1])
@@ -238,13 +313,70 @@ func (cv ConverterV2) md2html(in []rune, enableButtons bool) (string, []ButtonV2
 					continue
 				}
 			}
-			out.WriteRune(c)
+			out.WriteString(item)
+
+		default:
+			out.WriteString(item)
 		}
 	}
 
 	return out.String(), nil
 }
 
+func getBlockQuoteEnd(in []rune, nStart int) (int, []rune, bool) {
+	var contents []rune // We store all the contents, minus the > characters, so we avoid double-html tags
+	lineStart := true
+	for j := nStart; j < len(in); j++ {
+		if lineStart && in[j] == ' ' {
+			// Skip space chars at start of lines
+			continue
+		}
+
+		lineStart = in[j] == '\n'
+		contents = append(contents, in[j])
+
+		// Keep skipping until we get a newline
+		if in[j] != '\n' {
+			continue
+		}
+
+		if isExpandableEnd(in, j) {
+			// Extra -1 to include newline
+			return j, contents[:len(contents)-3], true
+		}
+
+		if j+4 < len(in) && in[j+1] == '&' && in[j+2] == 'g' && in[j+3] == 't' && in[j+4] == ';' {
+			j = j + 4 // skip '>' symbol for the next blockquote start
+			continue
+		}
+		return j, contents, false
+	}
+
+	if isExpandableEnd(in, len(in)) {
+		return len(in), contents[:len(contents)-2], true
+	}
+
+	return len(in), contents, false
+}
+
+func isExpandableEnd(in []rune, j int) bool {
+	return j-2 >= 0 && in[j-1] == '|' && in[j-2] == '|'
+}
+
+func validBlockQuoteStart(in []rune, i int) bool {
+	for j := i - 1; j >= 0; j-- {
+		if !unicode.IsSpace(in[j]) {
+			return false
+		}
+		if in[j] == '\n' {
+			return true
+		}
+	}
+
+	// Start of message; must be valid.
+	return true
+}
+
 func EscapeMarkdownV2(r []rune) string {
 	out := strings.Builder{}
 	for i, x := range r {
diff --git a/md2htmlV2_test.go b/md2htmlV2_test.go
index 1f68a0e..c4a6ee7 100644
--- a/md2htmlV2_test.go
+++ b/md2htmlV2_test.go
@@ -21,6 +21,9 @@ var basicMDv2 = []struct {
 	}, {
 		in:  "||hello||",
 		out: "<span class=\"tg-spoiler\">hello</span>",
+	}, {
+		in:  "||<hello>||",
+		out: "<span class=\"tg-spoiler\">&lt;hello&gt;</span>",
 	}, {
 		in:  "```content```",
 		out: "<pre>content</pre>",
@@ -64,18 +67,40 @@ var basicMDv2 = []struct {
 	}, { // ensure that premium stickers can get converted
 		in:  `![👍](tg://emoji?id=5368324170671202286)`,
 		out: `<tg-emoji emoji-id="5368324170671202286">👍</tg-emoji>`,
-	}, {},
+	}, {
+		in:  "> quote",
+		out: "<blockquote>quote</blockquote>",
+	}, {
+		in:  ">multi\n> line",
+		out: "<blockquote>multi\nline</blockquote>",
+	}, {
+		in:  ">expandable multi\n>line\n>quote||",
+		out: "<blockquote expandable>expandable multi\nline\nquote</blockquote>",
+	}, {
+		in:  ">expandable multi\n>line\n>quote||\nMore text on another line",
+		out: "<blockquote expandable>expandable multi\nline\nquote</blockquote>\nMore text on another line",
+	}, {
+		in:  "**>expandable multi with star prefix\n>line\n>quote||",
+		out: "<blockquote expandable>expandable multi with star prefix\nline\nquote</blockquote>",
+	}, {
+		in:  ">normal quote\n**>expandable multi\n>idk||",
+		out: "<blockquote>normal quote</blockquote>\n<blockquote expandable>expandable multi\nidk</blockquote>",
+	},
 }
 
 func TestMD2HTMLV2Basic(t *testing.T) {
 	for _, x := range append(basicMD, basicMDv2...) {
-		assert.Equal(t, x.out, tg_md2html.MD2HTMLV2(x.in))
+		t.Run(x.in, func(t *testing.T) {
+			assert.Equal(t, x.out, tg_md2html.MD2HTMLV2(x.in))
+		})
 	}
 }
 
 func TestMD2HTMLV2Advanced(t *testing.T) {
 	for _, x := range advancedMD {
-		assert.Equal(t, x.out, tg_md2html.MD2HTMLV2(x.in))
+		t.Run(x.in, func(t *testing.T) {
+			assert.Equal(t, x.out, tg_md2html.MD2HTMLV2(x.in))
+		})
 	}
 }
 
@@ -108,6 +133,9 @@ func TestNotMD2HTMLV2(t *testing.T) {
 		}, {
 			in:  "|noop|",
 			out: "|noop|",
+		}, {
+			in:  "end with >",
+			out: "end with &gt;",
 		}, {
 			in:  "no premium ! in text", // confirm that a '!' doesnt break premiums
 			out: "no premium ! in text",
@@ -243,15 +271,45 @@ var md2HTMLV2Buttons = []struct {
 				SameLine: false,
 			},
 		},
+	}, {
+		in:  "text\n> quote\ntext",
+		out: "text\n<blockquote>quote</blockquote>\ntext",
+	}, {
+		in:  "> `code quote`",
+		out: "<blockquote><code>code quote</code></blockquote>",
+	}, {
+		in:  "```go\ntext\n> not quote\nmore text```",
+		out: "<pre><code class=\"language-go\">text\n&gt; not quote\nmore text</code></pre>",
+	}, {
+		in: `[text](buttonurl#primary://example.com)
+[text](buttonurl#success://example.com)
+[text](buttonurl#danger://example.com)`,
+		out: "",
+		btns: []tg_md2html.ButtonV2{{
+			Name:     "text",
+			Type:     "url",
+			Content:  "example.com",
+			SameLine: false,
+			Style:    "primary",
+		}, {
+			Name:     "text",
+			Type:     "url",
+			Content:  "example.com",
+			SameLine: false,
+			Style:    "success",
+		}, {
+			Name:     "text",
+			Type:     "url",
+			Content:  "example.com",
+			SameLine: false,
+			Style:    "danger",
+		}},
 	},
 }
 
 func TestMD2HTMLV2Buttons(t *testing.T) {
 	for _, x := range md2HTMLV2Buttons {
-		cv := tg_md2html.NewV2(map[string]string{
-			"url":  "buttonurl:",
-			"text": "buttontext:",
-		})
+		cv := testConverter()
 		t.Run(x.in, func(t *testing.T) {
 			txt, b := cv.MD2HTMLButtons(x.in)
 			assert.Equal(t, x.out, txt)
diff --git a/reverseV2.go b/reverseV2.go
index a7bd6cc..a1858f8 100644
--- a/reverseV2.go
+++ b/reverseV2.go
@@ -4,11 +4,16 @@ import (
 	"errors"
 	"fmt"
 	"html"
+	"maps"
 	"regexp"
+	"slices"
 	"strings"
 )
 
-var ErrNoButtonContent = errors.New("no button contents")
+var (
+	ErrNoButtonContent    = errors.New("missing button name or contents")
+	ErrInvalidButtonStyle = errors.New("invalid button style")
+)
 
 var languageCodeblock = regexp.MustCompile(`^(?s)<code class="language-(.*?)">(.*)</code>$`)
 
@@ -38,12 +43,12 @@ func (cv ConverterV2) reverse(in []rune, buttons []ButtonV2) (string, error) {
 			if len(tagFields) < 1 {
 				return "", fmt.Errorf("no tag name for HTML tag started at %d", i)
 			}
-			tag := tagFields[0]
+			tagType := tagFields[0]
 
-			co, cc := getClosingTag(in[closeTag+1:], tag)
+			co, cc := getClosingTag(in[closeTag+1:], tagContent, tagType)
 			if co < 0 || cc < 0 {
 				// "no closing open"
-				return "", fmt.Errorf("no closing tag for HTML tag %q started at %d", tag, i)
+				return "", fmt.Errorf("no closing tag for HTML tag %q started at %d", tagType, i)
 			}
 			closingOpen, closingClose := closeTag+1+co, closeTag+1+cc
 			out.WriteString(html.UnescapeString(string(in[prev:i])))
@@ -53,7 +58,7 @@ func (cv ConverterV2) reverse(in []rune, buttons []ButtonV2) (string, error) {
 				return "", err
 			}
 
-			switch tag {
+			switch tagType {
 			case "b", "strong":
 				out.WriteString("*" + nested + "*")
 			case "i", "em":
@@ -85,9 +90,9 @@ func (cv ConverterV2) reverse(in []rune, buttons []ButtonV2) (string, error) {
 
 				switch spanType := tagFields[1]; spanType {
 				case "class=\"tg-spoiler\"":
-					out.WriteString("||" + html.UnescapeString(string(in[closeTag+1:closingOpen])) + "||")
+					out.WriteString("||" + nested + "||")
 				default:
-					return "", fmt.Errorf("unknown tag type %q", spanType)
+					return "", fmt.Errorf("unknown span type %q", spanType)
 				}
 			case "a":
 				if link.MatchString(tagContent) {
@@ -103,14 +108,21 @@ func (cv ConverterV2) reverse(in []rune, buttons []ButtonV2) (string, error) {
 				} else {
 					return "", fmt.Errorf("badly formatted anchor tag %q", tagContent)
 				}
+			case "blockquote":
+				if len(tagFields) == 2 && tagFields[1] == "expandable" {
+					out.WriteString("**>" + strings.Join(strings.Split(nested, "\n"), "\n>") + "||")
+				} else {
+					out.WriteString(">" + strings.Join(strings.Split(nested, "\n"), "\n>"))
+				}
+
 			default:
-				return "", fmt.Errorf("unknown tag %q", tag)
+				return "", fmt.Errorf("unknown tag %q", tagType)
 			}
 
 			prev = closingClose + 1
 			i = closingClose
 
-		case '\\', '_', '*', '~', '`', '[', ']', '(', ')': // these all need to be escaped to ensure we retain the same message
+		case '\\', '_', '*', '~', '`', '[', ']', '(', ')', '>': // these all need to be escaped to ensure we retain the same message
 			out.WriteString(html.UnescapeString(string(in[prev:i])))
 			out.WriteRune('\\')
 			out.WriteRune(in[i])
@@ -136,8 +148,21 @@ func (cv ConverterV2) ButtonToMarkdown(btn ButtonV2) (string, error) {
 		sameline = cv.SameLineSuffix
 	}
 
-	if prefix, ok := cv.Prefixes[btn.Type]; ok {
-		return "[" + EscapeMarkdownV2([]rune(btn.Name)) + "](" + prefix + "//" + html.UnescapeString(btn.Content) + sameline + ")", nil
+	prefix, ok := cv.Prefixes[btn.Type]
+	if !ok || btn.Name == "" || btn.Content == "" {
+		return "", ErrNoButtonContent
 	}
-	return "", ErrNoButtonContent
+
+	if btn.Style != "" {
+		trn, ok := cv.Styles[btn.Style]
+		if !ok {
+			return "", fmt.Errorf("%w: %s (expected one of: %s)",
+				ErrInvalidButtonStyle, btn.Style,
+				strings.Join(slices.Collect(maps.Keys(cv.Styles)), ", "))
+		}
+
+		prefix += "#" + trn
+	}
+
+	return "[" + EscapeMarkdownV2([]rune(btn.Name)) + "](" + prefix + "://" + html.UnescapeString(btn.Content) + sameline + ")", nil
 }
diff --git a/reverseV2_test.go b/reverseV2_test.go
index 0220ff6..c44b432 100644
--- a/reverseV2_test.go
+++ b/reverseV2_test.go
@@ -10,35 +10,43 @@ import (
 
 func TestReverseV2(t *testing.T) {
 	for _, test := range reverseTest {
-		out, err := tg_md2html.ReverseV2(tg_md2html.MD2HTMLV2(test), nil)
-		assert.NoError(t, err, "Error for:\n%s", test)
-		assert.Equal(t, tg_md2html.MD2HTMLV2(test), tg_md2html.MD2HTMLV2(out))
+		t.Run(test, func(t *testing.T) {
+			out, err := tg_md2html.ReverseV2(tg_md2html.MD2HTMLV2(test), nil)
+			assert.NoError(t, err, "Error for:\n%s", test)
+			assert.Equal(t, tg_md2html.MD2HTMLV2(test), tg_md2html.MD2HTMLV2(out))
+		})
 	}
 
 	for _, test := range append(append(basicMD, basicMDv2...), advancedMD...) {
-		out, err := tg_md2html.ReverseV2(tg_md2html.MD2HTMLV2(test.in), nil)
-		assert.NoError(t, err, "Error for:\n%s", test)
-		assert.Equal(t, tg_md2html.MD2HTMLV2(test.in), tg_md2html.MD2HTMLV2(out))
+		t.Run(test.in, func(t *testing.T) {
+			out, err := tg_md2html.ReverseV2(tg_md2html.MD2HTMLV2(test.in), nil)
+			assert.NoError(t, err, " Error for:\n%s", test)
+			assert.Equal(t, tg_md2html.MD2HTMLV2(test.in), tg_md2html.MD2HTMLV2(out))
+		})
 	}
 
 	for _, test := range []string{
-		"___________test_______",
-		"|||||spoiler|||",
-		`![👍](tg://emoji?id=5368324170671202286)`,
+		"___________test_______",                  // uneven underlines
+		"|||||spoiler|||",                         // uneven spoilers
+		"||<spoiler>||",                           // spoilers, but with HTML bits inside
+		"![👍](tg://emoji?id=5368324170671202286)", // premium emoji
+		"> ",             // empty quotes
+		"test\n>\ntest",  // multiline quotes
+		"||||||||| test", // nested spoilers
 	} {
-		out, err := tg_md2html.ReverseV2(tg_md2html.MD2HTMLV2(test), nil)
-		assert.NoError(t, err, "Error for:\n%s", test)
-		assert.Equal(t, tg_md2html.MD2HTMLV2(test), tg_md2html.MD2HTMLV2(out))
+		t.Run(test, func(t *testing.T) {
+			htmlv2 := tg_md2html.MD2HTMLV2(test)
+			out, err := tg_md2html.ReverseV2(htmlv2, nil)
+			assert.NoError(t, err, "Error for:\n%s", test)
+			assert.Equal(t, htmlv2, tg_md2html.MD2HTMLV2(out))
+		})
 	}
 }
 
 func TestReverseV2Buttons(t *testing.T) {
 	for _, x := range md2HTMLV2Buttons {
 		t.Run(x.in, func(t *testing.T) {
-			cv := tg_md2html.NewV2(map[string]string{
-				"url":  "buttonurl:",
-				"text": "buttontext:",
-			})
+			cv := testConverter()
 
 			// Button parsing is lossful; we apply opinionated changes to ensure stability. (eg, strip markdown from button names)
 			// So, we don't compare the reverse to the input.
@@ -56,3 +64,44 @@ func TestReverseV2Buttons(t *testing.T) {
 		})
 	}
 }
+
+func TestReverseV2Buttons_errors(t *testing.T) {
+	for _, x := range []struct {
+		name    string
+		in      string
+		wantErr error
+	}{
+		{
+			name:    "valid button",
+			in:      "[test](buttonurl://example.com)",
+			wantErr: nil,
+		}, {
+			name:    "empty button name",
+			in:      "[](buttonurl://example.com)",
+			wantErr: tg_md2html.ErrNoButtonContent,
+		}, {
+			name:    "empty button url",
+			in:      "[test](buttonurl://)",
+			wantErr: tg_md2html.ErrNoButtonContent,
+		}, {
+			name:    "valid button style",
+			in:      "[test](buttonurl#primary://blah)",
+			wantErr: nil,
+		}, {
+			name:    "invalid button style",
+			in:      "[test](buttonurl#green://blah)",
+			wantErr: tg_md2html.ErrInvalidButtonStyle,
+		},
+	} {
+		t.Run(x.name, func(t *testing.T) {
+			cv := testConverter()
+
+			// Button parsing is lossful; we apply opinionated changes to ensure stability. (eg, strip markdown from button names)
+			// So, we don't compare the reverse to the input.
+			// Instead, we ensure that the parsed input is equal to the parsed reverse.
+			txt, b := cv.MD2HTMLButtons(x.in)
+			_, err := cv.Reverse(txt, b)
+			assert.ErrorIs(t, err, x.wantErr)
+		})
+	}
+}