diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 0c17cf9..96e298d 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -13,12 +13,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Set up Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.19'
+          go-version: 'stable'
 
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Get dependencies
         run: go mod download
@@ -33,15 +33,17 @@ jobs:
     name: Lint
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v5
         with:
-          go-version: '1.19'
+          go-version: 'stable'
 
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v8
         with:
-          # Optional: version of golangci-lint to use in form of v1.2 or v1.2.3 or `latest` to use the latest version
           version: latest
+          # skip cache to avoid flakes (and avoid using gh-action storage)
+          skip-cache: true
+          skip-save-cache: true
diff --git a/common.go b/common.go
index 63ae985..063caaa 100644
--- a/common.go
+++ b/common.go
@@ -18,11 +18,11 @@ func validStart(pos int, input []rune) bool {
 	}
 
 	// If the previous char is alphanumeric, it is an invalid start char.
-	return !(unicode.IsLetter(input[pos-1]) || unicode.IsDigit(input[pos-1]))
+	return !unicode.IsLetter(input[pos-1]) && !unicode.IsDigit(input[pos-1])
 }
 
 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
@@ -34,17 +34,7 @@ func validEnd(pos int, input []rune) bool {
 	}
 
 	// If the next char is alphanumeric, it is an invalid end char.
-	return !(unicode.IsLetter(input[pos+1]) || unicode.IsDigit(input[pos+1]))
-}
-
-func contains(r rune, rr []rune) bool {
-	for _, x := range rr {
-		if r == x {
-			return true
-		}
-	}
-
-	return false
+	return !unicode.IsLetter(input[pos+1]) && !unicode.IsDigit(input[pos+1])
 }
 
 var link = regexp.MustCompile(`a href="(.*)"`)
diff --git a/commonV2.go b/commonV2.go
index 8bc9173..527c818 100644
--- a/commonV2.go
+++ b/commonV2.go
@@ -4,8 +4,22 @@ import (
 	"strings"
 )
 
+func hasPrefix(s string, tgPrefixes []string) bool {
+	rest, ok := strings.CutPrefix(s, "tg://")
+	if !ok {
+		return false
+	}
+
+	for _, prefix := range tgPrefixes {
+		if strings.HasPrefix(rest, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
 // finds the middle '](' section of in a link markdown
-func findLinkMidSectionIdx(in []rune, emoji bool) int {
+func findLinkMidSectionIdx(in []rune, tgSpecial bool) int {
 	var textEnd int
 	var offset int
 	for offset < len(in) {
@@ -15,8 +29,8 @@ func findLinkMidSectionIdx(in []rune, emoji bool) int {
 		}
 		textEnd = offset + idx
 		if !IsEscaped(in, textEnd) {
-			isEmoji := strings.HasPrefix(string(in[textEnd+2:]), "tg://emoji?id=")
-			if (isEmoji && emoji) || (!isEmoji && !emoji) {
+			prefixed := hasPrefix(string(in[textEnd+2:]), []string{"emoji?", "time?"})
+			if (prefixed && tgSpecial) || (!prefixed && !tgSpecial) {
 				return textEnd
 			}
 		}
@@ -44,8 +58,8 @@ func findLinkEndSectionIdx(in []rune) int {
 }
 
 // finds the middle and closing sections of in a link markdown
-func findLinkSectionsIdx(in []rune, isEmojiLink bool) (int, int) {
-	textEnd := findLinkMidSectionIdx(in, isEmojiLink)
+func findLinkSectionsIdx(in []rune, tgSpecial bool) (int, int) {
+	textEnd := findLinkMidSectionIdx(in, tgSpecial)
 	if textEnd < 0 {
 		return -1, -1
 	}
@@ -60,7 +74,7 @@ func findLinkSectionsIdx(in []rune, isEmojiLink bool) (int, int) {
 	// Now, we iterate over the text in between the mid and end sections to see if any other mid sections exist.
 	// If yes, we choose those instead - it would be invalid in a URL anyway.
 	for textEnd < offsetLinkEnd {
-		newTextEnd := findLinkMidSectionIdx(in[textEnd+1:offsetLinkEnd], isEmojiLink)
+		newTextEnd := findLinkMidSectionIdx(in[textEnd+1:offsetLinkEnd], tgSpecial)
 		if newTextEnd == -1 {
 			break
 		}
@@ -70,9 +84,9 @@ func findLinkSectionsIdx(in []rune, isEmojiLink bool) (int, int) {
 	return textEnd, offsetLinkEnd
 }
 
-func getLinkContents(in []rune, emoji bool) (bool, []rune, string, int) {
+func getLinkContents(in []rune, tgSpecial bool) (bool, []rune, string, int) {
 	// find ]( and then )
-	textEndIdx, urlEndIdx := findLinkSectionsIdx(in, emoji)
+	textEndIdx, urlEndIdx := findLinkSectionsIdx(in, tgSpecial)
 	if textEndIdx < 0 || urlEndIdx < 0 {
 		return false, nil, "", 0
 	}
@@ -82,6 +96,13 @@ func getLinkContents(in []rune, emoji bool) (bool, []rune, string, int) {
 	return true, text, content, urlEndIdx + 1
 }
 
+func isCodeBlockNewlineEnd(in []rune, offset int, item string) bool {
+	if item != "```" {
+		return false
+	}
+	return offset == 0 || in[offset-1] == '\n'
+}
+
 func getValidEnd(in []rune, s string) int {
 	offset := 0
 	for offset < len(in) {
@@ -92,7 +113,7 @@ func getValidEnd(in []rune, s string) int {
 
 		end := offset + idx
 		// validEnd check has double logic to account for multi char strings
-		if validEnd(end, in) && validEnd(end+len(s)-1, in) && !IsEscaped(in, end) {
+		if (validEnd(end, in) || isCodeBlockNewlineEnd(in, end, s)) && validEnd(end+len(s)-1, in) && !IsEscaped(in, end) {
 			idx = stringIndex(in[end+1:], s)
 			for idx == 0 {
 				end++
@@ -148,7 +169,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 +185,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..9ac6ff5 100644
--- a/go.mod
+++ b/go.mod
@@ -1,8 +1,8 @@
 module github.com/PaulSonOfLars/gotg_md2html
 
-go 1.19
+go 1.24
 
-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/md2html.go b/md2html.go
index c2e1447..0275cb0 100644
--- a/md2html.go
+++ b/md2html.go
@@ -2,6 +2,8 @@ package tg_md2html
 
 import (
 	"html"
+	"maps"
+	"slices"
 	"strings"
 )
 
@@ -102,7 +104,7 @@ func (cv *Converter) md2html(input []rune, buttons bool) (string, []Button) {
 			v[char] = append(v[char], pos-offset)
 			containedMDChars = append(containedMDChars, char)
 		case '\\':
-			if len(input) <= pos+1 || !contains(input[pos+1], allMdChars) {
+			if len(input) <= pos+1 || !slices.Contains(allMdChars, input[pos+1]) {
 				continue
 			}
 			escaped = true
@@ -192,9 +194,7 @@ func (cv *Converter) md2html(input []rune, buttons bool) (string, []Button) {
 			}
 			i = cnt // set i to copy
 
-			for x, y := range bkp {
-				v[x] = y
-			}
+			maps.Copy(v, bkp)
 
 		case '[':
 			nameOpen, rest := posArr[0], posArr[1:]
@@ -405,7 +405,7 @@ func (cv *Converter) stripHTML(r []rune) string {
 func EscapeMarkdown(r []rune, toEscape []rune) string {
 	out := strings.Builder{}
 	for i, x := range r {
-		if contains(x, toEscape) {
+		if slices.Contains(toEscape, x) {
 			if i == 0 || i == len(r)-1 || validEnd(i, r) || validStart(i, r) {
 				out.WriteRune('\\')
 			}
diff --git a/md2htmlV2.go b/md2htmlV2.go
index 56d3a5a..5b1e03b 100644
--- a/md2htmlV2.go
+++ b/md2htmlV2.go
@@ -2,33 +2,65 @@ package tg_md2html
 
 import (
 	"html"
+	"net/url"
+	"slices"
 	"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 +74,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 or datetime
+	"![":   "", // for emoji or datetime
+	"[":    "", // for links
+	"]":    "", // for links/emoji
+	"(":    "", // for links/emoji
+	")":    "", // for links/emoji
+	"\\":   "", // for escapes
+	"&":    "", // for blockquotes
+	"&gt;": "blockquote",
 }
 
 var AllMarkdownV2Chars = func() []rune {
@@ -86,6 +121,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 +178,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.
@@ -149,11 +202,12 @@ func (cv ConverterV2) md2html(in []rune, enableButtons bool) (string, []ButtonV2
 			nStart, nEnd := i+1, i+idx+1
 			followT, followB := cv.md2html(in[nEnd+len(item):], enableButtons)
 
-			if item == "`" {
+			switch item {
+			case "`":
 				// ` doesn't support nested items, so don't parse children.
 				return out.String() + "<code>" + string(in[nStart:nEnd]) + "</code>" + followT, followB
 
-			} else if item == "```" {
+			case "```":
 				// ``` doesn't support nested items, so don't parse children.
 				nestedT := string(in[nStart:nEnd])
 
@@ -174,29 +228,80 @@ 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.WriteString(item)
+				continue
+			}
+			end := i + newEnd
+
+			contentType, content, ok := strings.Cut(strings.TrimPrefix(content, "tg://"), "?")
 			if !ok {
-				out.WriteRune(c)
+				out.WriteString(item)
 				continue
 			}
-			end := i + 1 + newEnd
 
-			content = strings.TrimPrefix(content, "tg://emoji?id=")
+			queryForm, err := url.ParseQuery(html.UnescapeString(content))
+			if err != nil {
+				out.WriteString(item)
+				continue
+			}
 
 			nestedT, nestedB := cv.md2html(text, enableButtons)
 			followT, followB := cv.md2html(in[end:], enableButtons)
-			return out.String() + `<tg-emoji emoji-id="` + content + `">` + nestedT + "</tg-emoji>" + followT, append(nestedB, followB...)
 
-		case '[':
+			switch contentType {
+			case "emoji":
+				// id=5368324170671202286
+				id := queryForm.Get("id")
+				if id == "" {
+					out.WriteString(item)
+					continue
+				}
+
+				return out.String() + `<tg-emoji emoji-id="` + id + `">` + nestedT + "</tg-emoji>" + followT, append(nestedB, followB...)
+			case "time":
+				// unix="1647531900" format="wDT"
+				unix := queryForm.Get("unix")
+				if unix == "" {
+					out.WriteString(item)
+					continue
+				}
+				format := queryForm.Get("format")
+				if format != "" {
+					return out.String() + `<tg-time unix="` + unix + `" format="` + format + `">` + nestedT + "</tg-time>" + followT, append(nestedB, followB...)
+				}
+				return out.String() + `<tg-time unix="` + unix + `">` + nestedT + "</tg-time>" + followT, append(nestedB, followB...)
+
+			default:
+				out.WriteString(item)
+			}
+
+		case "[":
 			ok, text, content, newEnd := getLinkContents(in[i:], false)
 			if !ok {
-				out.WriteRune(c)
+				out.WriteString(item)
 				continue
 			}
 			end := i + newEnd
@@ -205,11 +310,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
+					}
+
+					var style string
+					if p, s, ok := strings.Cut(pref, "#"); ok {
+						style = s
+						pref = p
+					}
+
+					if pref != prefix {
 						continue
 					}
 
-					content := strings.TrimLeft(strings.TrimPrefix(content, prefix), "/")
+					content := strings.TrimLeft(url, "/")
 					sameline := strings.HasSuffix(content, cv.SameLineSuffix)
 					if sameline {
 						content = strings.TrimSuffix(content, cv.SameLineSuffix)
@@ -220,6 +336,7 @@ func (cv ConverterV2) md2html(in []rune, enableButtons bool) (string, []ButtonV2
 						Type:     buttonType,
 						Content:  content,
 						SameLine: sameline,
+						Style:    style,
 					}}, followB...)
 				}
 			}
@@ -227,10 +344,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,17 +352,74 @@ 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 {
-		if contains(x, AllMarkdownV2Chars) {
+		if slices.Contains(AllMarkdownV2Chars, x) {
 			if i == 0 || i == len(r)-1 || validEnd(i, r) || validStart(i, r) {
 				out.WriteRune('\\')
 			}
diff --git a/md2htmlV2_test.go b/md2htmlV2_test.go
index 1f68a0e..4ef8b13 100644
--- a/md2htmlV2_test.go
+++ b/md2htmlV2_test.go
@@ -21,12 +21,18 @@ 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>",
 	}, {
 		in:  "```code\ncontent```",
 		out: "<pre><code class=\"language-code\">content</code></pre>",
+	}, {
+		in:  "```code\ncontent\n```",
+		out: "<pre><code class=\"language-code\">content\n</code></pre>",
 	}, {
 		in:  "```spaced words\ncontent```",
 		out: "<pre><code class=\"language-spaced words\">content</code></pre>",
@@ -64,18 +70,55 @@ var basicMDv2 = []struct {
 	}, { // ensure that premium stickers can get converted
 		in:  `![👍](tg://emoji?id=5368324170671202286)`,
 		out: `<tg-emoji emoji-id="5368324170671202286">👍</tg-emoji>`,
-	}, {},
+	}, { // ensure that timestamps can get converted
+		in:  `![22:45 tomorrow](tg://time?unix=1647531900&format=wDT)`,
+		out: `<tg-time unix="1647531900" format="wDT">22:45 tomorrow</tg-time>`,
+	}, { // ensure that timestamps can get converted
+		in:  `![22:45 tomorrow](tg://time?unix=1647531900&format=t)`,
+		out: `<tg-time unix="1647531900" format="t">22:45 tomorrow</tg-time>`,
+	}, { // ensure that timestamps can get converted
+		in:  `![22:45 tomorrow](tg://time?unix=1647531900&format=r)`,
+		out: `<tg-time unix="1647531900" format="r">22:45 tomorrow</tg-time>`,
+	}, { // ensure that timestamps can get converted
+		in:  `![22:45 tomorrow](tg://time?unix=1647531900)`,
+		out: `<tg-time unix="1647531900">22:45 tomorrow</tg-time>`,
+	}, {
+		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>",
+	}, {
+		in:  "[test](tg://user?id=1234)",
+		out: `<a href="tg://user?id=1234">test</a>`,
+	},
 }
 
 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 +151,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 +289,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..a7f66d0 100644
--- a/reverseV2.go
+++ b/reverseV2.go
@@ -4,11 +4,17 @@ import (
 	"errors"
 	"fmt"
 	"html"
+	"maps"
 	"regexp"
+	"slices"
+	"strconv"
 	"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 +44,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 +59,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 +91,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 +109,46 @@ 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>"))
+				}
+			case "tg-time":
+				var unix, format string
+				for _, tag := range tagFields[1:] {
+					fieldType, valueQuoted, ok := strings.Cut(tag, "=")
+					if !ok {
+						return "", fmt.Errorf("badly formatted tag %q", tag)
+					}
+
+					value, err := strconv.Unquote(valueQuoted)
+					if err != nil {
+						return "", fmt.Errorf("badly formatted tag %q", tag)
+					}
+
+					switch fieldType {
+					case "unix":
+						unix = value
+					case "format":
+						format = value
+					}
+				}
+				if format != "" {
+					out.WriteString("![" + nested + "](tg://time?unix=" + unix + "&format=" + format + ")")
+				} else {
+					out.WriteString("![" + nested + "](tg://time?unix=" + unix + ")")
+				}
+
 			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])
@@ -122,7 +160,7 @@ func (cv ConverterV2) reverse(in []rune, buttons []ButtonV2) (string, error) {
 	for idx, btn := range buttons {
 		bText, err := cv.ButtonToMarkdown(btn)
 		if err != nil {
-			return "", fmt.Errorf("failed to convert button %d (%s) to markdown: %w", idx, btn.Name, err)
+			return "", fmt.Errorf("invalid button %d (%s): %w", idx, btn.Name, err)
 		}
 		out.WriteString("\n" + bText)
 	}
@@ -136,8 +174,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
+	}
+
+	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 "", ErrNoButtonContent
+
+	return "[" + EscapeMarkdownV2([]rune(btn.Name)) + "](" + prefix + "://" + html.UnescapeString(btn.Content) + sameline + ")", nil
 }
diff --git a/reverseV2_test.go b/reverseV2_test.go
index 0220ff6..687936b 100644
--- a/reverseV2_test.go
+++ b/reverseV2_test.go
@@ -10,35 +10,47 @@ 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
+		"![22:45 tomorrow](tg://time?unix=1647531900&format=wDT)", // timestamps
+		"![22:45 tomorrow](tg://time?unix=1647531900&format=t)",   // timestamps
+		"![22:45 tomorrow](tg://time?unix=1647531900&format=r)",   // timestamps
+		"![22:45 tomorrow](tg://time?unix=1647531900)",            // timestamps
+		"> ",             // 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 +68,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)
+		})
+	}
+}