s around list item data if true + BulletChar byte // '*', '+' or '-' in bullet lists + Delimiter byte // '.' or ')' after the number in ordered lists + Start int // for ordered lists this indicates the starting number if > 0 + RefLink []byte // If not nil, turns this list item into a footnote item and triggers different rendering + IsFootnotesList bool // This is a list of footnotes +} + +// ListItem represents markdown list item node +type ListItem struct { + Container + + ListFlags ListType + Tight bool // Skip
s around list item data if true
+ BulletChar byte // '*', '+' or '-' in bullet lists
+ Delimiter byte // '.' or ')' after the number in ordered lists
+ RefLink []byte // If not nil, turns this list item into a footnote item and triggers different rendering
+ IsFootnotesList bool // This is a list of footnotes
+}
+
+// Paragraph represents markdown paragraph node
+type Paragraph struct {
+ Container
+}
+
+// Math represents markdown MathAjax inline node
+type Math struct {
+ Leaf
+}
+
+// MathBlock represents markdown MathAjax block node
+type MathBlock struct {
+ Container
+}
+
+// Heading represents markdown heading node
+type Heading struct {
+ Container
+
+ Level int // This holds the heading level number
+ HeadingID string // This might hold heading ID, if present
+ IsTitleblock bool // Specifies whether it's a title block
+ IsSpecial bool // We are a special heading (starts with .#)
+}
+
+// HorizontalRule represents markdown horizontal rule node
+type HorizontalRule struct {
+ Leaf
+}
+
+// Emph represents markdown emphasis node
+type Emph struct {
+ Container
+}
+
+// Strong represents markdown strong node
+type Strong struct {
+ Container
+}
+
+// Del represents markdown del node
+type Del struct {
+ Container
+}
+
+// Link represents markdown link node
+type Link struct {
+ Container
+
+ Destination []byte // Destination is what goes into a href
+ Title []byte // Title is the tooltip thing that goes in a title attribute
+ NoteID int // NoteID contains a serial number of a footnote, zero if it's not a footnote
+ Footnote Node // If it's a footnote, this is a direct link to the footnote Node. Otherwise nil.
+ DeferredID []byte // If a deferred link this holds the original ID.
+}
+
+// CrossReference is a reference node.
+type CrossReference struct {
+ Container
+
+ Destination []byte // Destination is where the reference points to
+}
+
+// Citation is a citation node.
+type Citation struct {
+ Leaf
+
+ Destination [][]byte // Destination is where the citation points to. Multiple ones are allowed.
+ Type []CitationTypes // 1:1 mapping of destination and citation type
+ Suffix [][]byte // Potential citation suffix, i.e. [@!RFC1035, p. 144]
+}
+
+// Image represents markdown image node
+type Image struct {
+ Container
+
+ Destination []byte // Destination is what goes into a href
+ Title []byte // Title is the tooltip thing that goes in a title attribute
+}
+
+// Text represents markdown text node
+type Text struct {
+ Leaf
+}
+
+// HTMLBlock represents markdown html node
+type HTMLBlock struct {
+ Leaf
+}
+
+// CodeBlock represents markdown code block node
+type CodeBlock struct {
+ Leaf
+
+ IsFenced bool // Specifies whether it's a fenced code block or an indented one
+ Info []byte // This holds the info string
+ FenceChar byte
+ FenceLength int
+ FenceOffset int
+}
+
+// Softbreak represents markdown softbreak node
+// Note: not used currently
+type Softbreak struct {
+ Leaf
+}
+
+// Hardbreak represents markdown hard break node
+type Hardbreak struct {
+ Leaf
+}
+
+// NonBlockingSpace represents markdown non-blocking space node
+type NonBlockingSpace struct {
+ Leaf
+}
+
+// Code represents markdown code node
+type Code struct {
+ Leaf
+}
+
+// HTMLSpan represents markdown html span node
+type HTMLSpan struct {
+ Leaf
+}
+
+// Table represents markdown table node
+type Table struct {
+ Container
+}
+
+// TableCell represents markdown table cell node
+type TableCell struct {
+ Container
+
+ IsHeader bool // This tells if it's under the header row
+ Align CellAlignFlags // This holds the value for align attribute
+}
+
+// TableHeader represents markdown table head node
+type TableHeader struct {
+ Container
+}
+
+// TableBody represents markdown table body node
+type TableBody struct {
+ Container
+}
+
+// TableRow represents markdown table row node
+type TableRow struct {
+ Container
+}
+
+// TableFooter represents markdown table foot node
+type TableFooter struct {
+ Container
+}
+
+// Caption represents a figure, code or quote caption
+type Caption struct {
+ Container
+}
+
+// CaptionFigure is a node (blockquote or codeblock) that has a caption
+type CaptionFigure struct {
+ Container
+
+ HeadingID string // This might hold heading ID, if present
+}
+
+// Callout is a node that can exist both in text (where it is an actual node) and in a code block.
+type Callout struct {
+ Leaf
+
+ ID []byte // number of this callout
+}
+
+// Index is a node that contains an Index item and an optional, subitem.
+type Index struct {
+ Leaf
+
+ Primary bool
+ Item []byte
+ Subitem []byte
+ ID string // ID of the index
+}
+
+// Subscript is a subscript node
+type Subscript struct {
+ Leaf
+}
+
+// Subscript is a superscript node
+type Superscript struct {
+ Leaf
+}
+
+// Footnotes is a node that contains all footnotes
+type Footnotes struct {
+ Container
+}
+
+func removeNodeFromArray(a []Node, node Node) []Node {
+ n := len(a)
+ for i := 0; i < n; i++ {
+ if a[i] == node {
+ return append(a[:i], a[i+1:]...)
+ }
+ }
+ return nil
+}
+
+// AppendChild appends child to children of parent
+// It panics if either node is nil.
+func AppendChild(parent Node, child Node) {
+ RemoveFromTree(child)
+ child.SetParent(parent)
+ newChildren := append(parent.GetChildren(), child)
+ parent.SetChildren(newChildren)
+}
+
+// RemoveFromTree removes this node from tree
+func RemoveFromTree(n Node) {
+ if n.GetParent() == nil {
+ return
+ }
+ // important: don't clear n.Children if n has no parent
+ // we're called from AppendChild and that might happen on a node
+ // that accumulated Children but hasn't been inserted into the tree
+ n.SetChildren(nil)
+ p := n.GetParent()
+ newChildren := removeNodeFromArray(p.GetChildren(), n)
+ if newChildren != nil {
+ p.SetChildren(newChildren)
+ }
+}
+
+// GetLastChild returns last child of node n
+// It's implemented as stand-alone function to keep Node interface small
+func GetLastChild(n Node) Node {
+ a := n.GetChildren()
+ if len(a) > 0 {
+ return a[len(a)-1]
+ }
+ return nil
+}
+
+// GetFirstChild returns first child of node n
+// It's implemented as stand-alone function to keep Node interface small
+func GetFirstChild(n Node) Node {
+ a := n.GetChildren()
+ if len(a) > 0 {
+ return a[0]
+ }
+ return nil
+}
+
+// GetNextNode returns next sibling of node n (node after n)
+// We can't make it part of Container or Leaf because we loose Node identity
+func GetNextNode(n Node) Node {
+ parent := n.GetParent()
+ if parent == nil {
+ return nil
+ }
+ a := parent.GetChildren()
+ len := len(a) - 1
+ for i := 0; i < len; i++ {
+ if a[i] == n {
+ return a[i+1]
+ }
+ }
+ return nil
+}
+
+// GetPrevNode returns previous sibling of node n (node before n)
+// We can't make it part of Container or Leaf because we loose Node identity
+func GetPrevNode(n Node) Node {
+ parent := n.GetParent()
+ if parent == nil {
+ return nil
+ }
+ a := parent.GetChildren()
+ len := len(a)
+ for i := 1; i < len; i++ {
+ if a[i] == n {
+ return a[i-1]
+ }
+ }
+ return nil
+}
+
+// WalkStatus allows NodeVisitor to have some control over the tree traversal.
+// It is returned from NodeVisitor and different values allow Node.Walk to
+// decide which node to go to next.
+type WalkStatus int
+
+const (
+ // GoToNext is the default traversal of every node.
+ GoToNext WalkStatus = iota
+ // SkipChildren tells walker to skip all children of current node.
+ SkipChildren
+ // Terminate tells walker to terminate the traversal.
+ Terminate
+)
+
+// NodeVisitor is a callback to be called when traversing the syntax tree.
+// Called twice for every node: once with entering=true when the branch is
+// first visited, then with entering=false after all the children are done.
+type NodeVisitor interface {
+ Visit(node Node, entering bool) WalkStatus
+}
+
+// NodeVisitorFunc casts a function to match NodeVisitor interface
+type NodeVisitorFunc func(node Node, entering bool) WalkStatus
+
+// Walk traverses tree recursively
+func Walk(n Node, visitor NodeVisitor) WalkStatus {
+ isContainer := n.AsContainer() != nil
+ status := visitor.Visit(n, true) // entering
+ if status == Terminate {
+ // even if terminating, close container node
+ if isContainer {
+ visitor.Visit(n, false)
+ }
+ return status
+ }
+ if isContainer && status != SkipChildren {
+ children := n.GetChildren()
+ for _, n := range children {
+ status = Walk(n, visitor)
+ if status == Terminate {
+ return status
+ }
+ }
+ }
+ if isContainer {
+ status = visitor.Visit(n, false) // exiting
+ if status == Terminate {
+ return status
+ }
+ }
+ return GoToNext
+}
+
+// Visit calls visitor function
+func (f NodeVisitorFunc) Visit(node Node, entering bool) WalkStatus {
+ return f(node, entering)
+}
+
+// WalkFunc is like Walk but accepts just a callback function
+func WalkFunc(n Node, f NodeVisitorFunc) {
+ visitor := NodeVisitorFunc(f)
+ Walk(n, visitor)
+}
diff --git a/vendor/github.com/gomarkdown/markdown/ast/print.go b/vendor/github.com/gomarkdown/markdown/ast/print.go
new file mode 100644
index 00000000..75daf911
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/ast/print.go
@@ -0,0 +1,165 @@
+package ast
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "strings"
+)
+
+// Print is for debugging. It prints a string representation of parsed
+// markdown doc (result of parser.Parse()) to dst.
+//
+// To make output readable, it shortens text output.
+func Print(dst io.Writer, doc Node) {
+ PrintWithPrefix(dst, doc, " ")
+}
+
+// PrintWithPrefix is like Print but allows customizing prefix used for
+// indentation. By default it's 2 spaces. You can change it to e.g. tab
+// by passing "\t"
+func PrintWithPrefix(w io.Writer, doc Node, prefix string) {
+ // for more compact output, don't print outer Document
+ if _, ok := doc.(*Document); ok {
+ for _, c := range doc.GetChildren() {
+ printRecur(w, c, prefix, 0)
+ }
+ } else {
+ printRecur(w, doc, prefix, 0)
+ }
+}
+
+// ToString is like Dump but returns result as a string
+func ToString(doc Node) string {
+ var buf bytes.Buffer
+ Print(&buf, doc)
+ return buf.String()
+}
+
+func contentToString(d1 []byte, d2 []byte) string {
+ if d1 != nil {
+ return string(d1)
+ }
+ if d2 != nil {
+ return string(d2)
+ }
+ return ""
+}
+
+func getContent(node Node) string {
+ if c := node.AsContainer(); c != nil {
+ return contentToString(c.Literal, c.Content)
+ }
+ leaf := node.AsLeaf()
+ return contentToString(leaf.Literal, leaf.Content)
+}
+
+func shortenString(s string, maxLen int) string {
+ // for cleaner, one-line ouput, replace some white-space chars
+ // with their escaped version
+ s = strings.Replace(s, "\n", `\n`, -1)
+ s = strings.Replace(s, "\r", `\r`, -1)
+ s = strings.Replace(s, "\t", `\t`, -1)
+ if maxLen < 0 {
+ return s
+ }
+ if len(s) < maxLen {
+ return s
+ }
+ // add "..." to indicate truncation
+ return s[:maxLen-3] + "..."
+}
+
+// get a short name of the type of v which excludes package name
+// and strips "()" from the end
+func getNodeType(node Node) string {
+ s := fmt.Sprintf("%T", node)
+ s = strings.TrimSuffix(s, "()")
+ if idx := strings.Index(s, "."); idx != -1 {
+ return s[idx+1:]
+ }
+ return s
+}
+
+func printDefault(w io.Writer, indent string, typeName string, content string) {
+ content = strings.TrimSpace(content)
+ if len(content) > 0 {
+ fmt.Fprintf(w, "%s%s '%s'\n", indent, typeName, content)
+ } else {
+ fmt.Fprintf(w, "%s%s\n", indent, typeName)
+ }
+}
+
+func getListFlags(f ListType) string {
+ var s string
+ if f&ListTypeOrdered != 0 {
+ s += "ordered "
+ }
+ if f&ListTypeDefinition != 0 {
+ s += "definition "
+ }
+ if f&ListTypeTerm != 0 {
+ s += "term "
+ }
+ if f&ListItemContainsBlock != 0 {
+ s += "has_block "
+ }
+ if f&ListItemBeginningOfList != 0 {
+ s += "start "
+ }
+ if f&ListItemEndOfList != 0 {
+ s += "end "
+ }
+ s = strings.TrimSpace(s)
+ return s
+}
+
+func printRecur(w io.Writer, node Node, prefix string, depth int) {
+ if node == nil {
+ return
+ }
+ indent := strings.Repeat(prefix, depth)
+
+ content := shortenString(getContent(node), 40)
+ typeName := getNodeType(node)
+ switch v := node.(type) {
+ case *Link:
+ content := "url=" + string(v.Destination)
+ printDefault(w, indent, typeName, content)
+ case *Image:
+ content := "url=" + string(v.Destination)
+ printDefault(w, indent, typeName, content)
+ case *List:
+ if v.Start > 1 {
+ content += fmt.Sprintf("start=%d ", v.Start)
+ }
+ if v.Tight {
+ content += "tight "
+ }
+ if v.IsFootnotesList {
+ content += "footnotes "
+ }
+ flags := getListFlags(v.ListFlags)
+ if len(flags) > 0 {
+ content += "flags=" + flags + " "
+ }
+ printDefault(w, indent, typeName, content)
+ case *ListItem:
+ if v.Tight {
+ content += "tight "
+ }
+ if v.IsFootnotesList {
+ content += "footnotes "
+ }
+ flags := getListFlags(v.ListFlags)
+ if len(flags) > 0 {
+ content += "flags=" + flags + " "
+ }
+ printDefault(w, indent, typeName, content)
+ default:
+ printDefault(w, indent, typeName, content)
+ }
+ for _, child := range node.GetChildren() {
+ printRecur(w, child, prefix, depth+1)
+ }
+}
diff --git a/vendor/github.com/gomarkdown/markdown/changes-from-blackfriday.md b/vendor/github.com/gomarkdown/markdown/changes-from-blackfriday.md
new file mode 100644
index 00000000..b618dfef
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/changes-from-blackfriday.md
@@ -0,0 +1,27 @@
+## Changes from blackfriday
+
+This library is derived from blackfriday library. Here's a list of changes.
+
+**Redesigned API**
+
+- split into 3 separate packages: ast, parser and html (for html renderer). This makes the API more manageable. It also separates e.g. parser option from renderer options
+- changed how AST node is represented from union-like representation (manually keeping track of the type of the node) to using interface{} (which is a Go way to combine an arbitrary value with its type)
+
+**Allow re-using most of html renderer logic**
+
+You can implement your own renderer by implementing `Renderer` interface.
+
+Implementing a full renderer is a lot of work and often you just want to tweak html rendering of few node typs.
+
+I've added a way to hook `Renderer.Render` function in html renderer with a custom function that can take over rendering of specific nodes.
+
+I use it myself to do syntax-highlighting of code snippets.
+
+**Speed up go test**
+
+Running `go test` was really slow (17 secs) because it did a poor man's version of fuzzing by feeding the parser all subsets of test strings in order to find panics
+due to incorrect parsing logic.
+
+I've moved that logic to `cmd/crashtest`, so that it can be run on CI but not slow down regular development.
+
+Now `go test` is blazing fast.
diff --git a/vendor/github.com/gomarkdown/markdown/codecov.yml b/vendor/github.com/gomarkdown/markdown/codecov.yml
new file mode 100644
index 00000000..f681ff11
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/codecov.yml
@@ -0,0 +1,8 @@
+coverage:
+ status:
+ project:
+ default:
+ # basic
+ target: 60%
+ threshold: 2%
+ base: auto
diff --git a/vendor/github.com/gomarkdown/markdown/doc.go b/vendor/github.com/gomarkdown/markdown/doc.go
new file mode 100644
index 00000000..9fb77e02
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/doc.go
@@ -0,0 +1,35 @@
+/*
+Package markdown implements markdown parser and HTML renderer.
+
+It parses markdown into AST format which can be serialized to HTML
+(using html.Renderer) or possibly other formats (using alternate renderers).
+
+Convert markdown to HTML
+
+The simplest way to convert markdown document to HTML
+
+ md := []byte("## markdown document")
+ html := markdown.ToHTML(md, nil, nil)
+
+Customizing parsing and HTML rendering
+
+You can customize parser and HTML renderer:
+
+ import (
+ "github.com/gomarkdown/markdown/parser"
+ "github.com/gomarkdown/markdown/renderer"
+ "github.com/gomarkdown/markdown"
+ )
+ extensions := parser.CommonExtensions | parser.AutoHeadingIDs
+ p := parser.NewWithExensions(extensions)
+
+ htmlFlags := html.CommonFlags | html.HrefTargetBlank
+ opts := html.RendererOptions{Flags: htmlFlags}
+ renderer := html.NewRenderer(opts)
+
+ md := []byte("markdown text")
+ html := markdown.ToHTML(md, p, renderer)
+
+For a cmd-line tool see https://github.com/gomarkdown/mdtohtml
+*/
+package markdown
diff --git a/vendor/github.com/gomarkdown/markdown/fuzz.go b/vendor/github.com/gomarkdown/markdown/fuzz.go
new file mode 100644
index 00000000..704182b8
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/fuzz.go
@@ -0,0 +1,9 @@
+// +build gofuzz
+
+package markdown
+
+// Fuzz is to be used by https://github.com/dvyukov/go-fuzz
+func Fuzz(data []byte) int {
+ Parse(data, nil)
+ return 0
+}
diff --git a/vendor/github.com/gomarkdown/markdown/go.mod b/vendor/github.com/gomarkdown/markdown/go.mod
new file mode 100644
index 00000000..899e3237
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/go.mod
@@ -0,0 +1,5 @@
+module github.com/gomarkdown/markdown
+
+go 1.12
+
+require golang.org/dl v0.0.0-20190829154251-82a15e2f2ead // indirect
diff --git a/vendor/github.com/gomarkdown/markdown/html/callouts.go b/vendor/github.com/gomarkdown/markdown/html/callouts.go
new file mode 100644
index 00000000..e377af22
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/html/callouts.go
@@ -0,0 +1,42 @@
+package html
+
+import (
+ "bytes"
+ "io"
+
+ "github.com/gomarkdown/markdown/ast"
+ "github.com/gomarkdown/markdown/parser"
+)
+
+// EscapeHTMLCallouts writes html-escaped d to w. It escapes &, <, > and " characters, *but*
+// expands callouts < \[`, `\]${content} emitted by html.Renderer
+ func renderHookCodeBlock(w io.Writer, node *ast.Node, entering bool) (ast.WalkStatus, bool) {
+ _, ok := node.Data.(*ast.CodeBlockData)
+ if !ok {
+ return ast.GoToNext, false
+ }
+ io.WriteString(w, "code_replacement")
+ return ast.GoToNext, true
+ }
+
+ opts := html.RendererOptions{
+ RenderNodeHook: renderHookCodeBlock,
+ }
+ renderer := html.NewRenderer(opts)
+*/
+package html
diff --git a/vendor/github.com/gomarkdown/markdown/html/esc.go b/vendor/github.com/gomarkdown/markdown/html/esc.go
new file mode 100644
index 00000000..89ec9a27
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/html/esc.go
@@ -0,0 +1,50 @@
+package html
+
+import (
+ "html"
+ "io"
+)
+
+var Escaper = [256][]byte{
+ '&': []byte("&"),
+ '<': []byte("<"),
+ '>': []byte(">"),
+ '"': []byte("""),
+}
+
+// EscapeHTML writes html-escaped d to w. It escapes &, <, > and " characters.
+func EscapeHTML(w io.Writer, d []byte) {
+ var start, end int
+ n := len(d)
+ for end < n {
+ escSeq := Escaper[d[end]]
+ if escSeq != nil {
+ w.Write(d[start:end])
+ w.Write(escSeq)
+ start = end + 1
+ }
+ end++
+ }
+ if start < n && end <= n {
+ w.Write(d[start:end])
+ }
+}
+
+func escLink(w io.Writer, text []byte) {
+ unesc := html.UnescapeString(string(text))
+ EscapeHTML(w, []byte(unesc))
+}
+
+// Escape writes the text to w, but skips the escape character.
+func Escape(w io.Writer, text []byte) {
+ esc := false
+ for i := 0; i < len(text); i++ {
+ if text[i] == '\\' {
+ esc = !esc
+ }
+ if esc && text[i] == '\\' {
+ continue
+ }
+ w.Write([]byte{text[i]})
+ }
+}
diff --git a/vendor/github.com/gomarkdown/markdown/html/renderer.go b/vendor/github.com/gomarkdown/markdown/html/renderer.go
new file mode 100644
index 00000000..367f7dfa
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/html/renderer.go
@@ -0,0 +1,1318 @@
+package html
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+
+ "github.com/gomarkdown/markdown/ast"
+)
+
+// Flags control optional behavior of HTML renderer.
+type Flags int
+
+// IDTag is the tag used for tag identification, it defaults to "id", some renderers
+// may wish to override this and use e.g. "anchor".
+var IDTag = "id"
+
+// HTML renderer configuration options.
+const (
+ FlagsNone Flags = 0
+ SkipHTML Flags = 1 << iota // Skip preformatted HTML blocks
+ SkipImages // Skip embedded images
+ SkipLinks // Skip all links
+ Safelink // Only link to trusted protocols
+ NofollowLinks // Only link with rel="nofollow"
+ NoreferrerLinks // Only link with rel="noreferrer"
+ HrefTargetBlank // Add a blank target
+ CompletePage // Generate a complete HTML page
+ UseXHTML // Generate XHTML output instead of HTML
+ FootnoteReturnLinks // Generate a link at the end of a footnote to return to the source
+ FootnoteNoHRTag // Do not output an HR after starting a footnote list.
+ Smartypants // Enable smart punctuation substitutions
+ SmartypantsFractions // Enable smart fractions (with Smartypants)
+ SmartypantsDashes // Enable smart dashes (with Smartypants)
+ SmartypantsLatexDashes // Enable LaTeX-style dashes (with Smartypants)
+ SmartypantsAngledQuotes // Enable angled double quotes (with Smartypants) for double quotes rendering
+ SmartypantsQuotesNBSP // Enable « French guillemets » (with Smartypants)
+ TOC // Generate a table of contents
+
+ CommonFlags Flags = Smartypants | SmartypantsFractions | SmartypantsDashes | SmartypantsLatexDashes
+)
+
+var (
+ htmlTagRe = regexp.MustCompile("(?i)^" + htmlTag)
+)
+
+const (
+ htmlTag = "(?:" + openTag + "|" + closeTag + "|" + htmlComment + "|" +
+ processingInstruction + "|" + declaration + "|" + cdata + ")"
+ closeTag = "]"
+ openTag = "<" + tagName + attribute + "*" + "\\s*/?>"
+ attribute = "(?:" + "\\s+" + attributeName + attributeValueSpec + "?)"
+ attributeValue = "(?:" + unquotedValue + "|" + singleQuotedValue + "|" + doubleQuotedValue + ")"
+ attributeValueSpec = "(?:" + "\\s*=" + "\\s*" + attributeValue + ")"
+ attributeName = "[a-zA-Z_:][a-zA-Z0-9:._-]*"
+ cdata = ""
+ declaration = "]*>"
+ doubleQuotedValue = "\"[^\"]*\""
+ htmlComment = "|"
+ processingInstruction = "[<][?].*?[?][>]"
+ singleQuotedValue = "'[^']*'"
+ tagName = "[A-Za-z][A-Za-z0-9-]*"
+ unquotedValue = "[^\"'=<>`\\x00-\\x20]+"
+)
+
+// RenderNodeFunc allows reusing most of Renderer logic and replacing
+// rendering of some nodes. If it returns false, Renderer.RenderNode
+// will execute its logic. If it returns true, Renderer.RenderNode will
+// skip rendering this node and will return WalkStatus
+type RenderNodeFunc func(w io.Writer, node ast.Node, entering bool) (ast.WalkStatus, bool)
+
+// RendererOptions is a collection of supplementary parameters tweaking
+// the behavior of various parts of HTML renderer.
+type RendererOptions struct {
+ // Prepend this text to each relative URL.
+ AbsolutePrefix string
+ // Add this text to each footnote anchor, to ensure uniqueness.
+ FootnoteAnchorPrefix string
+ // Show this text inside the tag for a footnote return link, if the
+ // FootnoteReturnLinks flag is enabled. If blank, the string
+ // [return] is used.
+ FootnoteReturnLinkContents string
+ // CitationFormatString defines how a citation is rendered. If blnck, the string
+ // [%s] is used. Where %s will be substituted with the citation target.
+ CitationFormatString string
+ // If set, add this text to the front of each Heading ID, to ensure uniqueness.
+ HeadingIDPrefix string
+ // If set, add this text to the back of each Heading ID, to ensure uniqueness.
+ HeadingIDSuffix string
+
+ Title string // Document title (used if CompletePage is set)
+ CSS string // Optional CSS file URL (used if CompletePage is set)
+ Icon string // Optional icon file URL (used if CompletePage is set)
+ Head []byte // Optional head data injected in the section (used if CompletePage is set)
+
+ Flags Flags // Flags allow customizing this renderer's behavior
+
+ // if set, called at the start of RenderNode(). Allows replacing
+ // rendering of some nodes
+ RenderNodeHook RenderNodeFunc
+
+ // Comments is a list of comments the renderer should detect when
+ // parsing code blocks and detecting callouts.
+ Comments [][]byte
+
+ // Generator is a meta tag that is inserted in the generated HTML so show what rendered it. It should not include the closing tag.
+ // Defaults (note content quote is not closed) to ` " or ">"
+
+ // Track heading IDs to prevent ID collision in a single generation.
+ headingIDs map[string]int
+
+ lastOutputLen int
+ disableTags int
+
+ sr *SPRenderer
+
+ documentMatter ast.DocumentMatters // keep track of front/main/back matter.
+}
+
+// NewRenderer creates and configures an Renderer object, which
+// satisfies the Renderer interface.
+func NewRenderer(opts RendererOptions) *Renderer {
+ // configure the rendering engine
+ closeTag := ">"
+ if opts.Flags&UseXHTML != 0 {
+ closeTag = " />"
+ }
+
+ if opts.FootnoteReturnLinkContents == "" {
+ opts.FootnoteReturnLinkContents = `[return]`
+ }
+ if opts.CitationFormatString == "" {
+ opts.CitationFormatString = `[%s]`
+ }
+ if opts.Generator == "" {
+ opts.Generator = ` = len(tagname) {
+ break
+ }
+
+ if strings.ToLower(string(tag[i]))[0] != tagname[j] {
+ return false, -1
+ }
+ }
+
+ if i == len(tag) {
+ return false, -1
+ }
+
+ rightAngle := skipUntilCharIgnoreQuotes(tag, i, '>')
+ if rightAngle >= i {
+ return true, rightAngle
+ }
+
+ return false, -1
+}
+
+func isRelativeLink(link []byte) (yes bool) {
+ // a tag begin with '#'
+ if link[0] == '#' {
+ return true
+ }
+
+ // link begin with '/' but not '//', the second maybe a protocol relative link
+ if len(link) >= 2 && link[0] == '/' && link[1] != '/' {
+ return true
+ }
+
+ // only the root '/'
+ if len(link) == 1 && link[0] == '/' {
+ return true
+ }
+
+ // current directory : begin with "./"
+ if bytes.HasPrefix(link, []byte("./")) {
+ return true
+ }
+
+ // parent directory : begin with "../"
+ if bytes.HasPrefix(link, []byte("../")) {
+ return true
+ }
+
+ return false
+}
+
+func (r *Renderer) ensureUniqueHeadingID(id string) string {
+ for count, found := r.headingIDs[id]; found; count, found = r.headingIDs[id] {
+ tmp := fmt.Sprintf("%s-%d", id, count+1)
+
+ if _, tmpFound := r.headingIDs[tmp]; !tmpFound {
+ r.headingIDs[id] = count + 1
+ id = tmp
+ } else {
+ id = id + "-1"
+ }
+ }
+
+ if _, found := r.headingIDs[id]; !found {
+ r.headingIDs[id] = 0
+ }
+
+ return id
+}
+
+func (r *Renderer) addAbsPrefix(link []byte) []byte {
+ if r.opts.AbsolutePrefix != "" && isRelativeLink(link) && link[0] != '.' {
+ newDest := r.opts.AbsolutePrefix
+ if link[0] != '/' {
+ newDest += "/"
+ }
+ newDest += string(link)
+ return []byte(newDest)
+ }
+ return link
+}
+
+func appendLinkAttrs(attrs []string, flags Flags, link []byte) []string {
+ if isRelativeLink(link) {
+ return attrs
+ }
+ var val []string
+ if flags&NofollowLinks != 0 {
+ val = append(val, "nofollow")
+ }
+ if flags&NoreferrerLinks != 0 {
+ val = append(val, "noreferrer")
+ }
+ if flags&HrefTargetBlank != 0 {
+ attrs = append(attrs, `target="_blank"`)
+ }
+ if len(val) == 0 {
+ return attrs
+ }
+ attr := fmt.Sprintf("rel=%q", strings.Join(val, " "))
+ return append(attrs, attr)
+}
+
+func isMailto(link []byte) bool {
+ return bytes.HasPrefix(link, []byte("mailto:"))
+}
+
+func needSkipLink(flags Flags, dest []byte) bool {
+ if flags&SkipLinks != 0 {
+ return true
+ }
+ return flags&Safelink != 0 && !isSafeLink(dest) && !isMailto(dest)
+}
+
+func isSmartypantable(node ast.Node) bool {
+ switch node.GetParent().(type) {
+ case *ast.Link, *ast.CodeBlock, *ast.Code:
+ return false
+ }
+ return true
+}
+
+func appendLanguageAttr(attrs []string, info []byte) []string {
+ if len(info) == 0 {
+ return attrs
+ }
+ endOfLang := bytes.IndexAny(info, "\t ")
+ if endOfLang < 0 {
+ endOfLang = len(info)
+ }
+ s := `class="language-` + string(info[:endOfLang]) + `"`
+ return append(attrs, s)
+}
+
+func (r *Renderer) outTag(w io.Writer, name string, attrs []string) {
+ s := name
+ if len(attrs) > 0 {
+ s += " " + strings.Join(attrs, " ")
+ }
+ io.WriteString(w, s+">")
+ r.lastOutputLen = 1
+}
+
+func footnoteRef(prefix string, node *ast.Link) string {
+ urlFrag := prefix + string(slugify(node.Destination))
+ nStr := strconv.Itoa(node.NoteID)
+ anchor := `` + nStr + ``
+ return `` + anchor + ``
+}
+
+func footnoteItem(prefix string, slug []byte) string {
+ return `
", "
")
+ r.cr(w)
+}
+
+func (r *Renderer) nonBlockingSpace(w io.Writer, node *ast.NonBlockingSpace) {
+ r.outs(w, " ")
+}
+
+func (r *Renderer) outOneOf(w io.Writer, outFirst bool, first string, second string) {
+ if outFirst {
+ r.outs(w, first)
+ } else {
+ r.outs(w, second)
+ }
+}
+
+func (r *Renderer) outOneOfCr(w io.Writer, outFirst bool, first string, second string) {
+ if outFirst {
+ r.cr(w)
+ r.outs(w, first)
+ } else {
+ r.outs(w, second)
+ r.cr(w)
+ }
+}
+
+func (r *Renderer) htmlSpan(w io.Writer, span *ast.HTMLSpan) {
+ if r.opts.Flags&SkipHTML == 0 {
+ r.out(w, span.Literal)
+ }
+}
+
+func (r *Renderer) linkEnter(w io.Writer, link *ast.Link) {
+ var attrs []string
+ dest := link.Destination
+ dest = r.addAbsPrefix(dest)
+ var hrefBuf bytes.Buffer
+ hrefBuf.WriteString("href=\"")
+ escLink(&hrefBuf, dest)
+ hrefBuf.WriteByte('"')
+ attrs = append(attrs, hrefBuf.String())
+ if link.NoteID != 0 {
+ r.outs(w, footnoteRef(r.opts.FootnoteAnchorPrefix, link))
+ return
+ }
+
+ attrs = appendLinkAttrs(attrs, r.opts.Flags, dest)
+ if len(link.Title) > 0 {
+ var titleBuff bytes.Buffer
+ titleBuff.WriteString("title=\"")
+ EscapeHTML(&titleBuff, link.Title)
+ titleBuff.WriteByte('"')
+ attrs = append(attrs, titleBuff.String())
+ }
+ r.outTag(w, "`)
+ }
+}
+
+func (r *Renderer) paragraphEnter(w io.Writer, para *ast.Paragraph) {
+ // TODO: untangle this clusterfuck about when the newlines need
+ // to be added and when not.
+ prev := ast.GetPrevNode(para)
+ if prev != nil {
+ switch prev.(type) {
+ case *ast.HTMLBlock, *ast.List, *ast.Paragraph, *ast.Heading, *ast.CaptionFigure, *ast.CodeBlock, *ast.BlockQuote, *ast.Aside, *ast.HorizontalRule:
+ r.cr(w)
+ }
+ }
+
+ if prev == nil {
+ _, isParentBlockQuote := para.Parent.(*ast.BlockQuote)
+ if isParentBlockQuote {
+ r.cr(w)
+ }
+ _, isParentAside := para.Parent.(*ast.Aside)
+ if isParentAside {
+ r.cr(w)
+ }
+ }
+
+ tag := tagWithAttributes("
")
+ EscapeHTML(w, node.Literal)
+ r.outs(w, "")
+}
+
+func (r *Renderer) htmlBlock(w io.Writer, node *ast.HTMLBlock) {
+ if r.opts.Flags&SkipHTML != 0 {
+ return
+ }
+ r.cr(w)
+ r.out(w, node.Literal)
+ r.cr(w)
+}
+
+func (r *Renderer) headingEnter(w io.Writer, nodeData *ast.Heading) {
+ var attrs []string
+ var class string
+ // TODO(miek): add helper functions for coalescing these classes.
+ if nodeData.IsTitleblock {
+ class = "title"
+ }
+ if nodeData.IsSpecial {
+ if class != "" {
+ class += " special"
+ } else {
+ class = "special"
+ }
+ }
+ if class != "" {
+ attrs = []string{`class="` + class + `"`}
+ }
+ if nodeData.HeadingID != "" {
+ id := r.ensureUniqueHeadingID(nodeData.HeadingID)
+ if r.opts.HeadingIDPrefix != "" {
+ id = r.opts.HeadingIDPrefix + id
+ }
+ if r.opts.HeadingIDSuffix != "" {
+ id = id + r.opts.HeadingIDSuffix
+ }
+ attrID := `id="` + id + `"`
+ attrs = append(attrs, attrID)
+ }
+ attrs = append(attrs, BlockAttrs(nodeData)...)
+ r.cr(w)
+ r.outTag(w, headingOpenTagFromLevel(nodeData.Level), attrs)
+}
+
+func (r *Renderer) headingExit(w io.Writer, heading *ast.Heading) {
+ r.outs(w, headingCloseTagFromLevel(heading.Level))
+ if !(isListItem(heading.Parent) && ast.GetNextNode(heading) == nil) {
+ r.cr(w)
+ }
+}
+
+func (r *Renderer) heading(w io.Writer, node *ast.Heading, entering bool) {
+ if entering {
+ r.headingEnter(w, node)
+ } else {
+ r.headingExit(w, node)
+ }
+}
+
+func (r *Renderer) horizontalRule(w io.Writer, node *ast.HorizontalRule) {
+ r.cr(w)
+ r.outHRTag(w, BlockAttrs(node))
+ r.cr(w)
+}
+
+func (r *Renderer) listEnter(w io.Writer, nodeData *ast.List) {
+ // TODO: attrs don't seem to be set
+ var attrs []string
+
+ if nodeData.IsFootnotesList {
+ r.outs(w, "\n")
+ code := tagWithAttributes("")
+ if !isListItem(codeBlock.Parent) {
+ r.cr(w)
+ }
+}
+
+func (r *Renderer) caption(w io.Writer, caption *ast.Caption, entering bool) {
+ if entering {
+ r.outs(w, "", "")
+ case *ast.BlockQuote:
+ tag := tagWithAttributes("", " ")
+ case *ast.TableFooter:
+ r.outOneOfCr(w, entering, "", "")
+ case *ast.Math:
+ r.outOneOf(w, true, `\(`, `\)`)
+ EscapeHTML(w, node.Literal)
+ r.outOneOf(w, false, `\(`, `\)`)
+ case *ast.MathBlock:
+ r.outOneOf(w, entering, `