func MarkdownCommon(input []byte) []byte {
	renderer := HtmlRenderer(commonHtmlFlags, "", "")
	return MarkdownOptions(input, renderer, Options{
		Extensions: commonExtensions})
}
Call Markdown with most useful extensions enabled
MarkdownCommon is a convenience function for simple rendering.
It processes markdown input with common extensions enabled, including:

* Smartypants processing with smart fractions and LaTeX dashes

* Intra-word emphasis suppression

* Tables

* Fenced code blocks

* Autolinking

* Strikethrough support

* Strict header parsing

* Custom Header IDs
package blackfriday
import (
	"bytes"
	"fmt"
	"strings"
	"unicode/utf8"
)
const VERSION = "1.5"
const (
	EXTENSION_NO_INTRA_EMPHASIS          = 1 << iota  
	EXTENSION_TABLES                                  
	EXTENSION_FENCED_CODE                             
	EXTENSION_AUTOLINK                                
	EXTENSION_STRIKETHROUGH                           
	EXTENSION_LAX_HTML_BLOCKS                         
	EXTENSION_SPACE_HEADERS                           
	EXTENSION_HARD_LINE_BREAK                         
	EXTENSION_TAB_SIZE_EIGHT                          
	EXTENSION_FOOTNOTES                               
	EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK              
	EXTENSION_HEADER_IDS                              
	EXTENSION_TITLEBLOCK                              
	EXTENSION_AUTO_HEADER_IDS                         
	EXTENSION_BACKSLASH_LINE_BREAK                    
	EXTENSION_DEFINITION_LISTS                        
	EXTENSION_JOIN_LINES                              
	commonHtmlFlags = 0 |
		HTML_USE_XHTML |
		HTML_USE_SMARTYPANTS |
		HTML_SMARTYPANTS_FRACTIONS |
		HTML_SMARTYPANTS_DASHES |
		HTML_SMARTYPANTS_LATEX_DASHES
	commonExtensions = 0 |
		EXTENSION_NO_INTRA_EMPHASIS |
		EXTENSION_TABLES |
		EXTENSION_FENCED_CODE |
		EXTENSION_AUTOLINK |
		EXTENSION_STRIKETHROUGH |
		EXTENSION_SPACE_HEADERS |
		EXTENSION_HEADER_IDS |
		EXTENSION_BACKSLASH_LINE_BREAK |
		EXTENSION_DEFINITION_LISTS
)
const (
	LINK_TYPE_NOT_AUTOLINK = iota
	LINK_TYPE_NORMAL
	LINK_TYPE_EMAIL
)
const (
	LIST_TYPE_ORDERED = 1 << iota
	LIST_TYPE_DEFINITION
	LIST_TYPE_TERM
	LIST_ITEM_CONTAINS_BLOCK
	LIST_ITEM_BEGINNING_OF_LIST
	LIST_ITEM_END_OF_LIST
)
const (
	TABLE_ALIGNMENT_LEFT = 1 << iota
	TABLE_ALIGNMENT_RIGHT
	TABLE_ALIGNMENT_CENTER = (TABLE_ALIGNMENT_LEFT | TABLE_ALIGNMENT_RIGHT)
)
const (
	TAB_SIZE_DEFAULT = 4
	TAB_SIZE_EIGHT   = 8
)
var blockTags = map[string]struct{}{
	"blockquote": {},
	"del":        {},
	"div":        {},
	"dl":         {},
	"fieldset":   {},
	"form":       {},
	"h1":         {},
	"h2":         {},
	"h3":         {},
	"h4":         {},
	"h5":         {},
	"h6":         {},
	"iframe":     {},
	"ins":        {},
	"math":       {},
	"noscript":   {},
	"ol":         {},
	"pre":        {},
	"p":          {},
	"script":     {},
	"style":      {},
	"table":      {},
	"ul":         {},
	"address":    {},
	"article":    {},
	"aside":      {},
	"canvas":     {},
	"figcaption": {},
	"figure":     {},
	"footer":     {},
	"header":     {},
	"hgroup":     {},
	"main":       {},
	"nav":        {},
	"output":     {},
	"progress":   {},
	"section":    {},
	"video":      {},
}
type Renderer interface {
	BlockCode(out *bytes.Buffer, text []byte, lang string)
	BlockQuote(out *bytes.Buffer, text []byte)
	BlockHtml(out *bytes.Buffer, text []byte)
	Header(out *bytes.Buffer, text func() bool, level int, id string)
	HRule(out *bytes.Buffer)
	List(out *bytes.Buffer, text func() bool, flags int)
	ListItem(out *bytes.Buffer, text []byte, flags int)
	Paragraph(out *bytes.Buffer, text func() bool)
	Table(out *bytes.Buffer, header []byte, body []byte, columnData []int)
	TableRow(out *bytes.Buffer, text []byte)
	TableHeaderCell(out *bytes.Buffer, text []byte, flags int)
	TableCell(out *bytes.Buffer, text []byte, flags int)
	Footnotes(out *bytes.Buffer, text func() bool)
	FootnoteItem(out *bytes.Buffer, name, text []byte, flags int)
	TitleBlock(out *bytes.Buffer, text []byte)
	AutoLink(out *bytes.Buffer, link []byte, kind int)
	CodeSpan(out *bytes.Buffer, text []byte)
	DoubleEmphasis(out *bytes.Buffer, text []byte)
	Emphasis(out *bytes.Buffer, text []byte)
	Image(out *bytes.Buffer, link []byte, title []byte, alt []byte)
	LineBreak(out *bytes.Buffer)
	Link(out *bytes.Buffer, link []byte, title []byte, content []byte)
	RawHtmlTag(out *bytes.Buffer, tag []byte)
	TripleEmphasis(out *bytes.Buffer, text []byte)
	StrikeThrough(out *bytes.Buffer, text []byte)
	FootnoteRef(out *bytes.Buffer, ref []byte, id int)
	Entity(out *bytes.Buffer, entity []byte)
	NormalText(out *bytes.Buffer, text []byte)
	DocumentHeader(out *bytes.Buffer)
	DocumentFooter(out *bytes.Buffer)
	GetFlags() int
}
type inlineParser func(p *parser, out *bytes.Buffer, data []byte, offset int) int
type parser struct {
	r              Renderer
	refOverride    ReferenceOverrideFunc
	refs           map[string]*reference
	inlineCallback [256]inlineParser
	flags          int
	nesting        int
	maxNesting     int
	insideLink     bool
	notes []*reference
}
func (p *parser) getRef(refid string) (ref *reference, found bool) {
	if p.refOverride != nil {
		r, overridden := p.refOverride(refid)
		if overridden {
			if r == nil {
				return nil, false
			}
			return &reference{
				link:     []byte(r.Link),
				title:    []byte(r.Title),
				noteId:   0,
				hasBlock: false,
				text:     []byte(r.Text)}, true
		}
	}
	ref, found = p.refs[strings.ToLower(refid)]
	return ref, found
}
type Reference struct {
	Link string
	Title string
	Text string
}
type ReferenceOverrideFunc func(reference string) (ref *Reference, overridden bool)
type Options struct {
	Extensions int
	ReferenceOverride ReferenceOverrideFunc
}
func MarkdownBasic(input []byte) []byte {
	htmlFlags := HTML_USE_XHTML
	renderer := HtmlRenderer(htmlFlags, "", "")
	return MarkdownOptions(input, renderer, Options{Extensions: 0})
}