Bot API 10.1 Updated!

[tonyhorton]

please add SendRichMessage method and request struct
update msg link: https://t.me/BotNews/119
richMessage document: https://core.telegram.org/bots/api#rich-messages

preview:

bots_md_demo.mp4

[mymmrac]

Hi, yes, planned to do this today or on weekends

[tonyhorton]

👍 It is as efficient as ever. The updated function actually works very well. However, after looking at it, I found that it requires a client update before it can be rendered. The old version does not support rendering.

[mymmrac]

Telego now supports API v.10.1

https://github.com/mymmrac/telego/releases/tag/v1.10.0

[tonyhorton]

Is it possible to provide RichMessage content construction auxiliary functions, such as MessageEntity? Below is a constructor with similar functions that I wrote using chatgpt:

package richhtml

import (
	"errors"
	"fmt"
	"html"
	"net/url"
	"strconv"
	"strings"

	"github.com/mymmrac/telego"
)

type Builder struct {
	b   strings.Builder
	err error
}

type Align string

const (
	AlignLeft   Align = "left"
	AlignCenter Align = "center"
	AlignRight  Align = "right"
)

type VAlign string

const (
	VAlignTop    VAlign = "top"
	VAlignMiddle VAlign = "middle"
	VAlignBottom VAlign = "bottom"
)

type OrderedType string

const (
	OrderedDecimal         OrderedType = "1"
	OrderedLowerAlpha      OrderedType = "a"
	OrderedUpperAlpha      OrderedType = "A"
	OrderedLowerRoman      OrderedType = "i"
	OrderedUpperRoman      OrderedType = "I"
)

type TableOptions struct {
	Bordered bool
	Striped  bool
	Caption  string
}

type CellOptions struct {
	Header  bool
	Colspan int
	Rowspan int
	Align   Align
	VAlign  VAlign
}

type FigureCaption struct {
	Text   string
	Credit string
}

func New() *Builder {
	return &Builder{}
}

func (b *Builder) Err() error {
	return b.err
}

func (b *Builder) String() string {
	return b.b.String()
}

func (b *Builder) Build() (telego.InputRichMessage, error) {
	if b.err != nil {
		return telego.InputRichMessage{}, b.err
	}

	return telego.InputRichMessage{
		HTML: b.b.String(),
	}, nil
}

func (b *Builder) MustBuild() telego.InputRichMessage {
	msg, err := b.Build()
	if err != nil {
		panic(err)
	}

	return msg
}

func (b *Builder) BuildWithOptions(isRTL bool, skipEntityDetection bool) (telego.InputRichMessage, error) {
	if b.err != nil {
		return telego.InputRichMessage{}, b.err
	}

	return telego.InputRichMessage{
		HTML:                b.b.String(),
		IsRtl:               isRTL,
		SkipEntityDetection: skipEntityDetection,
	}, nil
}

func (b *Builder) addErr(format string, args ...any) *Builder {
	err := fmt.Errorf(format, args...)
	if b.err == nil {
		b.err = err
		return b
	}

	b.err = errors.Join(b.err, err)
	return b
}

func text(s string) string {
	return html.EscapeString(s)
}

func attr(s string) string {
	return html.EscapeString(s)
}

func (b *Builder) write(s string) *Builder {
	if b.err != nil {
		return b
	}

	b.b.WriteString(s)
	return b
}

func (b *Builder) Text(s string) *Builder {
	return b.write(text(s))
}

func (b *Builder) Space() *Builder {
	return b.write(" ")
}

func (b *Builder) Br() *Builder {
	return b.write("<br>")
}

func (b *Builder) TrustedRawHTML(s string) *Builder {
	return b.write(s)
}

// Inline formatting.

func (b *Builder) Bold(s string) *Builder {
	return b.wrapText("b", s)
}

func (b *Builder) Strong(s string) *Builder {
	return b.wrapText("strong", s)
}

func (b *Builder) Italic(s string) *Builder {
	return b.wrapText("i", s)
}

func (b *Builder) Em(s string) *Builder {
	return b.wrapText("em", s)
}

func (b *Builder) Underline(s string) *Builder {
	return b.wrapText("u", s)
}

func (b *Builder) Inserted(s string) *Builder {
	return b.wrapText("ins", s)
}

func (b *Builder) Strike(s string) *Builder {
	return b.wrapText("s", s)
}

func (b *Builder) Deleted(s string) *Builder {
	return b.wrapText("del", s)
}

func (b *Builder) InlineCode(s string) *Builder {
	return b.wrapText("code", s)
}

func (b *Builder) Mark(s string) *Builder {
	return b.wrapText("mark", s)
}

func (b *Builder) Sub(s string) *Builder {
	return b.wrapText("sub", s)
}

func (b *Builder) Sup(s string) *Builder {
	return b.wrapText("sup", s)
}

func (b *Builder) Spoiler(s string) *Builder {
	b.write("<tg-spoiler>")
	b.Text(s)
	b.write("</tg-spoiler>")
	return b
}

func (b *Builder) BoldFunc(fn func(*Builder)) *Builder {
	return b.wrapFunc("b", fn)
}

func (b *Builder) ItalicFunc(fn func(*Builder)) *Builder {
	return b.wrapFunc("i", fn)
}

func (b *Builder) UnderlineFunc(fn func(*Builder)) *Builder {
	return b.wrapFunc("u", fn)
}

func (b *Builder) StrikeFunc(fn func(*Builder)) *Builder {
	return b.wrapFunc("s", fn)
}

func (b *Builder) MarkFunc(fn func(*Builder)) *Builder {
	return b.wrapFunc("mark", fn)
}

func (b *Builder) SpoilerFunc(fn func(*Builder)) *Builder {
	return b.wrapFunc("tg-spoiler", fn)
}

func (b *Builder) SubFunc(fn func(*Builder)) *Builder {
	return b.wrapFunc("sub", fn)
}

func (b *Builder) SupFunc(fn func(*Builder)) *Builder {
	return b.wrapFunc("sup", fn)
}

func (b *Builder) InlineCodeFunc(fn func(*Builder)) *Builder {
	return b.wrapFunc("code", fn)
}

func (b *Builder) wrapText(tag string, s string) *Builder {
	b.write("<")
	b.write(tag)
	b.write(">")
	b.Text(s)
	b.write("</")
	b.write(tag)
	b.write(">")
	return b
}

func (b *Builder) wrapFunc(tag string, fn func(*Builder)) *Builder {
	b.write("<")
	b.write(tag)
	b.write(">")

	if fn != nil {
		fn(b)
	}

	b.write("</")
	b.write(tag)
	b.write(">")
	return b
}

// Inline links and rich entities.

func (b *Builder) Link(label string, href string) *Builder {
	if !isAllowedHref(href) {
		return b.addErr("invalid link href: %q", href)
	}

	b.write(`<a href="`)
	b.write(attr(href))
	b.write(`">`)
	b.Text(label)
	b.write("</a>")
	return b
}

func (b *Builder) LinkFunc(href string, fn func(*Builder)) *Builder {
	if !isAllowedHref(href) {
		return b.addErr("invalid link href: %q", href)
	}

	b.write(`<a href="`)
	b.write(attr(href))
	b.write(`">`)

	if fn != nil {
		fn(b)
	}

	b.write("</a>")
	return b
}

func (b *Builder) Email(label string, email string) *Builder {
	return b.Link(label, "mailto:"+email)
}

func (b *Builder) Phone(label string, phone string) *Builder {
	return b.Link(label, "tel:"+phone)
}

func (b *Builder) UserMention(label string, userID int64) *Builder {
	return b.Link(label, "tg://user?id="+strconv.FormatInt(userID, 10))
}

func (b *Builder) Anchor(name string) *Builder {
	if name == "" {
		return b.addErr("anchor name is empty")
	}

	b.write(`<a name="`)
	b.write(attr(name))
	b.write(`"></a>`)
	return b
}

func (b *Builder) AnchorLink(label string, name string) *Builder {
	if name == "" {
		return b.Link(label, "#")
	}

	return b.Link(label, "#"+name)
}

func (b *Builder) Reference(name string, textValue string) *Builder {
	if name == "" {
		return b.addErr("reference name is empty")
	}

	b.write(`<tg-reference name="`)
	b.write(attr(name))
	b.write(`">`)
	b.Text(textValue)
	b.write(`</tg-reference>`)
	return b
}

func (b *Builder) ReferenceFunc(name string, fn func(*Builder)) *Builder {
	if name == "" {
		return b.addErr("reference name is empty")
	}

	b.write(`<tg-reference name="`)
	b.write(attr(name))
	b.write(`">`)

	if fn != nil {
		fn(b)
	}

	b.write(`</tg-reference>`)
	return b
}

func (b *Builder) ReferenceLink(label string, name string) *Builder {
	return b.Link(label, "#"+name)
}

func (b *Builder) CustomEmoji(fallbackEmoji string, customEmojiID string) *Builder {
	if fallbackEmoji == "" {
		return b.addErr("custom emoji fallback is empty")
	}
	if customEmojiID == "" {
		return b.addErr("custom emoji id is empty")
	}

	b.write(`<tg-emoji emoji-id="`)
	b.write(attr(customEmojiID))
	b.write(`">`)
	b.Text(fallbackEmoji)
	b.write(`</tg-emoji>`)
	return b
}

func (b *Builder) CustomEmojiImg(fallbackEmoji string, customEmojiID string) *Builder {
	if fallbackEmoji == "" {
		return b.addErr("custom emoji image fallback is empty")
	}
	if customEmojiID == "" {
		return b.addErr("custom emoji image id is empty")
	}

	b.write(`<img src="tg://emoji?id=`)
	b.write(attr(customEmojiID))
	b.write(`" alt="`)
	b.write(attr(fallbackEmoji))
	b.write(`"/>`)
	return b
}

func (b *Builder) Time(label string, unix int64, format string) *Builder {
	if format == "" {
		return b.addErr("time format is empty")
	}

	b.write(`<tg-time unix="`)
	b.write(strconv.FormatInt(unix, 10))
	b.write(`" format="`)
	b.write(attr(format))
	b.write(`">`)
	b.Text(label)
	b.write(`</tg-time>`)
	return b
}

func (b *Builder) Math(expr string) *Builder {
	if expr == "" {
		return b.addErr("inline math expression is empty")
	}

	b.write("<tg-math>")
	b.Text(expr)
	b.write("</tg-math>")
	return b
}

// Blocks.

func (b *Builder) H1(s string) *Builder { return b.heading(1, s) }
func (b *Builder) H2(s string) *Builder { return b.heading(2, s) }
func (b *Builder) H3(s string) *Builder { return b.heading(3, s) }
func (b *Builder) H4(s string) *Builder { return b.heading(4, s) }
func (b *Builder) H5(s string) *Builder { return b.heading(5, s) }
func (b *Builder) H6(s string) *Builder { return b.heading(6, s) }

func (b *Builder) Heading(level int, s string) *Builder {
	return b.heading(level, s)
}

func (b *Builder) HeadingFunc(level int, fn func(*Builder)) *Builder {
	if level < 1 || level > 6 {
		return b.addErr("heading level must be 1-6, got %d", level)
	}

	tag := "h" + strconv.Itoa(level)

	b.write("<")
	b.write(tag)
	b.write(">")

	if fn != nil {
		fn(b)
	}

	b.write("</")
	b.write(tag)
	b.write(">\n")
	return b
}

func (b *Builder) heading(level int, s string) *Builder {
	if level < 1 || level > 6 {
		return b.addErr("heading level must be 1-6, got %d", level)
	}

	tag := "h" + strconv.Itoa(level)
	b.write("<")
	b.write(tag)
	b.write(">")
	b.Text(s)
	b.write("</")
	b.write(tag)
	b.write(">\n")
	return b
}

func (b *Builder) P(s string) *Builder {
	b.write("<p>")
	b.Text(s)
	b.write("</p>\n")
	return b
}

func (b *Builder) PFunc(fn func(*Builder)) *Builder {
	b.write("<p>")
	if fn != nil {
		fn(b)
	}
	b.write("</p>\n")
	return b
}

func (b *Builder) Footer(s string) *Builder {
	b.write("<footer>")
	b.Text(s)
	b.write("</footer>\n")
	return b
}

func (b *Builder) FooterFunc(fn func(*Builder)) *Builder {
	b.write("<footer>")
	if fn != nil {
		fn(b)
	}
	b.write("</footer>\n")
	return b
}

func (b *Builder) HR() *Builder {
	return b.write("<hr/>\n")
}

func (b *Builder) Pre(code string) *Builder {
	b.write("<pre>")
	b.Text(code)
	b.write("</pre>\n")
	return b
}

func (b *Builder) CodeBlock(language string, code string) *Builder {
	if language == "" {
		return b.Pre(code)
	}

	b.write(`<pre><code class="language-`)
	b.write(attr(language))
	b.write(`">`)
	b.Text(code)
	b.write("</code></pre>\n")
	return b
}

func (b *Builder) MathBlock(expr string) *Builder {
	if expr == "" {
		return b.addErr("math block expression is empty")
	}

	b.write("<tg-math-block>")
	b.Text(expr)
	b.write("</tg-math-block>\n")
	return b
}

func (b *Builder) Details(summary string, open bool, fn func(*Builder)) *Builder {
	b.write("<details")
	if open {
		b.write(" open")
	}
	b.write("><summary>")
	b.Text(summary)
	b.write("</summary>")

	if fn != nil {
		fn(b)
	}

	b.write("</details>\n")
	return b
}

func (b *Builder) DetailsFunc(open bool, summaryFn func(*Builder), bodyFn func(*Builder)) *Builder {
	b.write("<details")
	if open {
		b.write(" open")
	}
	b.write("><summary>")

	if summaryFn != nil {
		summaryFn(b)
	}

	b.write("</summary>")

	if bodyFn != nil {
		bodyFn(b)
	}

	b.write("</details>\n")
	return b
}

func (b *Builder) Thinking(textValue string) *Builder {
	b.write("<tg-thinking>")
	b.Text(textValue)
	b.write("</tg-thinking>\n")
	return b
}

func (b *Builder) ThinkingFunc(fn func(*Builder)) *Builder {
	b.write("<tg-thinking>")
	if fn != nil {
		fn(b)
	}
	b.write("</tg-thinking>\n")
	return b
}

// Lists.

func (b *Builder) UL(fn func(*ListBuilder)) *Builder {
	lb := &ListBuilder{b: b, ordered: false}
	b.write("<ul>\n")
	if fn != nil {
		fn(lb)
	}
	b.write("</ul>\n")
	return b
}

func (b *Builder) OL(start int, typ OrderedType, reversed bool, fn func(*ListBuilder)) *Builder {
	if typ != "" && !validOrderedType(typ) {
		return b.addErr("invalid ordered list type: %q", typ)
	}

	lb := &ListBuilder{b: b, ordered: true}

	b.write("<ol")
	if start > 0 {
		b.write(` start="`)
		b.write(strconv.Itoa(start))
		b.write(`"`)
	}
	if typ != "" {
		b.write(` type="`)
		b.write(attr(string(typ)))
		b.write(`"`)
	}
	if reversed {
		b.write(" reversed")
	}
	b.write(">\n")

	if fn != nil {
		fn(lb)
	}

	b.write("</ol>\n")
	return b
}

type ListBuilder struct {
	b       *Builder
	ordered bool
}

func (l *ListBuilder) Item(s string) *ListBuilder {
	l.b.write("<li>")
	l.b.Text(s)
	l.b.write("</li>\n")
	return l
}

func (l *ListBuilder) ItemFunc(fn func(*Builder)) *ListBuilder {
	l.b.write("<li>")
	if fn != nil {
		fn(l.b)
	}
	l.b.write("</li>\n")
	return l
}

func (l *ListBuilder) ItemValue(value int, typ OrderedType, s string) *ListBuilder {
	if !l.ordered {
		l.b.addErr("item value is only valid in ordered list")
		return l
	}
	if typ != "" && !validOrderedType(typ) {
		l.b.addErr("invalid ordered item type: %q", typ)
		return l
	}

	l.b.write("<li")
	if value > 0 {
		l.b.write(` value="`)
		l.b.write(strconv.Itoa(value))
		l.b.write(`"`)
	}
	if typ != "" {
		l.b.write(` type="`)
		l.b.write(attr(string(typ)))
		l.b.write(`"`)
	}
	l.b.write(">")
	l.b.Text(s)
	l.b.write("</li>\n")
	return l
}

func (l *ListBuilder) Checkbox(checked bool, s string) *ListBuilder {
	l.b.write("<li><input type=\"checkbox\"")
	if checked {
		l.b.write(" checked")
	}
	l.b.write(">")
	l.b.Text(s)
	l.b.write("</li>\n")
	return l
}

func (l *ListBuilder) CheckboxFunc(checked bool, fn func(*Builder)) *ListBuilder {
	l.b.write("<li><input type=\"checkbox\"")
	if checked {
		l.b.write(" checked")
	}
	l.b.write(">")

	if fn != nil {
		fn(l.b)
	}

	l.b.write("</li>\n")
	return l
}

// Quotes.

func (b *Builder) BlockQuote(credit string, fn func(*Builder)) *Builder {
	b.write("<blockquote>")

	if fn != nil {
		fn(b)
	}

	if credit != "" {
		b.write("<cite>")
		b.Text(credit)
		b.write("</cite>")
	}

	b.write("</blockquote>\n")
	return b
}

func (b *Builder) PullQuote(textValue string, credit string) *Builder {
	b.write("<aside>")
	b.Text(textValue)

	if credit != "" {
		b.write("<cite>")
		b.Text(credit)
		b.write("</cite>")
	}

	b.write("</aside>\n")
	return b
}

func (b *Builder) PullQuoteFunc(credit string, fn func(*Builder)) *Builder {
	b.write("<aside>")

	if fn != nil {
		fn(b)
	}

	if credit != "" {
		b.write("<cite>")
		b.Text(credit)
		b.write("</cite>")
	}

	b.write("</aside>\n")
	return b
}

// Media blocks. Telegram requires HTTP/HTTPS URLs for rich media blocks.

func (b *Builder) Image(src string, spoiler bool) *Builder {
	if !isHTTPURL(src) {
		return b.addErr("image src must be http/https URL: %q", src)
	}

	b.write(`<img src="`)
	b.write(attr(src))
	b.write(`"`)
	if spoiler {
		b.write(" tg-spoiler")
	}
	b.write("/>\n")
	return b
}

func (b *Builder) Video(src string, spoiler bool) *Builder {
	if !isHTTPURL(src) {
		return b.addErr("video src must be http/https URL: %q", src)
	}

	b.write(`<video src="`)
	b.write(attr(src))
	b.write(`"`)
	if spoiler {
		b.write(" tg-spoiler")
	}
	b.write("></video>\n")
	return b
}

func (b *Builder) Audio(src string) *Builder {
	if !isHTTPURL(src) {
		return b.addErr("audio src must be http/https URL: %q", src)
	}

	b.write(`<audio src="`)
	b.write(attr(src))
	b.write(`"></audio>` + "\n")
	return b
}

func (b *Builder) FigureImage(src string, spoiler bool, caption FigureCaption) *Builder {
	if !isHTTPURL(src) {
		return b.addErr("figure image src must be http/https URL: %q", src)
	}

	b.write("<figure>")
	b.write(`<img src="`)
	b.write(attr(src))
	b.write(`"`)
	if spoiler {
		b.write(" tg-spoiler")
	}
	b.write("/>")
	b.writeCaption(caption)
	b.write("</figure>\n")
	return b
}

func (b *Builder) FigureVideo(src string, spoiler bool, caption FigureCaption) *Builder {
	if !isHTTPURL(src) {
		return b.addErr("figure video src must be http/https URL: %q", src)
	}

	b.write("<figure>")
	b.write(`<video src="`)
	b.write(attr(src))
	b.write(`"`)
	if spoiler {
		b.write(" tg-spoiler")
	}
	b.write("></video>")
	b.writeCaption(caption)
	b.write("</figure>\n")
	return b
}

func (b *Builder) FigureAudio(src string, caption FigureCaption) *Builder {
	if !isHTTPURL(src) {
		return b.addErr("figure audio src must be http/https URL: %q", src)
	}

	b.write("<figure>")
	b.write(`<audio src="`)
	b.write(attr(src))
	b.write(`"></audio>`)
	b.writeCaption(caption)
	b.write("</figure>\n")
	return b
}

func (b *Builder) Map(lat float64, long float64, zoom int) *Builder {
	if zoom < 13 || zoom > 20 {
		return b.addErr("map zoom must be 13-20, got %d", zoom)
	}

	b.write(`<tg-map lat="`)
	b.write(strconv.FormatFloat(lat, 'f', -1, 64))
	b.write(`" long="`)
	b.write(strconv.FormatFloat(long, 'f', -1, 64))
	b.write(`" zoom="`)
	b.write(strconv.Itoa(zoom))
	b.write(`"/>` + "\n")
	return b
}

func (b *Builder) FigureMap(lat float64, long float64, zoom int, caption FigureCaption) *Builder {
	if zoom < 13 || zoom > 20 {
		return b.addErr("map zoom must be 13-20, got %d", zoom)
	}

	b.write("<figure>")
	b.write(`<tg-map lat="`)
	b.write(strconv.FormatFloat(lat, 'f', -1, 64))
	b.write(`" long="`)
	b.write(strconv.FormatFloat(long, 'f', -1, 64))
	b.write(`" zoom="`)
	b.write(strconv.Itoa(zoom))
	b.write(`"/>`)
	b.writeCaption(caption)
	b.write("</figure>\n")
	return b
}

func (b *Builder) Collage(caption FigureCaption, fn func(*MediaGroupBuilder)) *Builder {
	mg := &MediaGroupBuilder{b: b}

	b.write("<tg-collage>")

	if fn != nil {
		fn(mg)
	}

	b.writeCaption(caption)
	b.write("</tg-collage>\n")
	return b
}

func (b *Builder) Slideshow(caption FigureCaption, fn func(*MediaGroupBuilder)) *Builder {
	mg := &MediaGroupBuilder{b: b}

	b.write("<tg-slideshow>")

	if fn != nil {
		fn(mg)
	}

	b.writeCaption(caption)
	b.write("</tg-slideshow>\n")
	return b
}

type MediaGroupBuilder struct {
	b *Builder
}

func (m *MediaGroupBuilder) Image(src string) *MediaGroupBuilder {
	m.b.ImageInline(src, false)
	return m
}

func (m *MediaGroupBuilder) Video(src string) *MediaGroupBuilder {
	m.b.VideoInline(src, false)
	return m
}

func (b *Builder) ImageInline(src string, spoiler bool) *Builder {
	if !isHTTPURL(src) {
		return b.addErr("image src must be http/https URL: %q", src)
	}

	b.write(`<img src="`)
	b.write(attr(src))
	b.write(`"`)
	if spoiler {
		b.write(" tg-spoiler")
	}
	b.write("/>")
	return b
}

func (b *Builder) VideoInline(src string, spoiler bool) *Builder {
	if !isHTTPURL(src) {
		return b.addErr("video src must be http/https URL: %q", src)
	}

	b.write(`<video src="`)
	b.write(attr(src))
	b.write(`"`)
	if spoiler {
		b.write(" tg-spoiler")
	}
	b.write("></video>")
	return b
}

func (b *Builder) writeCaption(c FigureCaption) {
	if c.Text == "" && c.Credit == "" {
		return
	}

	b.write("<figcaption>")
	if c.Text != "" {
		b.Text(c.Text)
	}
	if c.Credit != "" {
		b.write("<cite>")
		b.Text(c.Credit)
		b.write("</cite>")
	}
	b.write("</figcaption>")
}

// Tables.

func (b *Builder) Table(options TableOptions, fn func(*TableBuilder)) *Builder {
	tb := &TableBuilder{b: b}

	b.write("<table")
	if options.Bordered {
		b.write(" bordered")
	}
	if options.Striped {
		b.write(" striped")
	}
	b.write(">")

	if options.Caption != "" {
		b.write("<caption>")
		b.Text(options.Caption)
		b.write("</caption>")
	}

	if fn != nil {
		fn(tb)
	}

	b.write("</table>\n")
	return b
}

type TableBuilder struct {
	b *Builder
}

func (t *TableBuilder) Row(fn func(*TableRowBuilder)) *TableBuilder {
	rb := &TableRowBuilder{b: t.b}

	t.b.write("<tr>")
	if fn != nil {
		fn(rb)
	}
	t.b.write("</tr>")

	return t
}

type TableRowBuilder struct {
	b *Builder
}

func (r *TableRowBuilder) TH(s string) *TableRowBuilder {
	r.cell(s, CellOptions{Header: true})
	return r
}

func (r *TableRowBuilder) TD(s string) *TableRowBuilder {
	r.cell(s, CellOptions{})
	return r
}

func (r *TableRowBuilder) Cell(s string, options CellOptions) *TableRowBuilder {
	r.cell(s, options)
	return r
}

func (r *TableRowBuilder) CellFunc(options CellOptions, fn func(*Builder)) *TableRowBuilder {
	tag := "td"
	if options.Header {
		tag = "th"
	}

	r.b.write("<")
	r.b.write(tag)
	r.writeCellAttrs(options)
	r.b.write(">")

	if fn != nil {
		fn(r.b)
	}

	r.b.write("</")
	r.b.write(tag)
	r.b.write(">")

	return r
}

func (r *TableRowBuilder) cell(s string, options CellOptions) {
	tag := "td"
	if options.Header {
		tag = "th"
	}

	r.b.write("<")
	r.b.write(tag)
	r.writeCellAttrs(options)
	r.b.write(">")
	r.b.Text(s)
	r.b.write("</")
	r.b.write(tag)
	r.b.write(">")
}

func (r *TableRowBuilder) writeCellAttrs(options CellOptions) {
	if options.Colspan > 1 {
		r.b.write(` colspan="`)
		r.b.write(strconv.Itoa(options.Colspan))
		r.b.write(`"`)
	}

	if options.Rowspan > 1 {
		r.b.write(` rowspan="`)
		r.b.write(strconv.Itoa(options.Rowspan))
		r.b.write(`"`)
	}

	if options.Align != "" {
		if !validAlign(options.Align) {
			r.b.addErr("invalid table align: %q", options.Align)
			return
		}

		r.b.write(` align="`)
		r.b.write(attr(string(options.Align)))
		r.b.write(`"`)
	}

	if options.VAlign != "" {
		if !validVAlign(options.VAlign) {
			r.b.addErr("invalid table valign: %q", options.VAlign)
			return
		}

		r.b.write(` valign="`)
		r.b.write(attr(string(options.VAlign)))
		r.b.write(`"`)
	}
}

// Helpers.

func isHTTPURL(raw string) bool {
	u, err := url.Parse(raw)
	if err != nil {
		return false
	}

	return u.Scheme == "http" || u.Scheme == "https"
}

func isAllowedHref(raw string) bool {
	if raw == "" {
		return false
	}

	if strings.HasPrefix(raw, "#") {
		return true
	}

	u, err := url.Parse(raw)
	if err != nil {
		return false
	}

	switch u.Scheme {
	case "http", "https", "mailto", "tel", "tg":
		return true
	default:
		return false
	}
}

func validAlign(v Align) bool {
	switch v {
	case AlignLeft, AlignCenter, AlignRight:
		return true
	default:
		return false
	}
}

func validVAlign(v VAlign) bool {
	switch v {
	case VAlignTop, VAlignMiddle, VAlignBottom:
		return true
	default:
		return false
	}
}

func validOrderedType(v OrderedType) bool {
	switch v {
	case OrderedDecimal, OrderedLowerAlpha, OrderedUpperAlpha, OrderedLowerRoman, OrderedUpperRoman:
		return true
	default:
		return false
	}
}

[mymmrac]

Hi, thanks for the suggestion, I will think on this

[mymmrac]

Hi @tonyhorton, in the latest update, Telegram allowed sending rich text as a structured object, so I added a lot of helper methods that basically do the same as constructing HTML, but even more type safe and efficient. You can use it in Telego v1.11.0.

Also, here is an example:
https://github.com/mymmrac/telego/blob/main/examples/rich_text/main.go