- <%- site.description %> -
- - <%- body %> -- <%- site.description %> -
- - <%- body %> -<%- site.description %>
- - <%- body %> -- <%- site.description %> -
- - <%- body %> -Most of the documentation is still at an early stage. For more details, please have a look at the source of this website.
- <%- include('documentation/variables') %> -Terminal CSS uses a single font size for almost all elements. However, there is a way to use browser default font sizes if you wish.
-<body class="terminal">. If you leave that option, it will fallback to browser defaults. See here.Customizing the style of Terminal CSS with CSS Variables is easy.
- -@font-face or any other font provider to include your custom fonts.code.<code> elements.h1 elements. Possible values are:Version: <%- site.libVersion %> Top
-Most of the documentation is still at an early stage. For more details, please have a look at the source of this website.
+Customizing the style of Terminal CSS with CSS Variables is easy.
+ +@font-face or any other font provider to include your custom fonts.code.<code> elements.h1 elements. Possible values are:Terminal CSS uses a single font size for almost all elements. However, there is a way to use browser default font sizes if you wish.
+<body class="terminal">. If you leave that option, it will fallback to browser defaults. See here.Version: v{{ .Version }} Top
+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.
+ AdditionalAttributes []string // Defines additional attributes to use during rendering.
+}
+
+// CrossReference is a reference node.
+type CrossReference struct {
+ Container
+
+ Destination []byte // Destination is where the reference points to
+ Suffix []byte // Potential citation suffix, i.e. (#myid, text)
+}
+
+// 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
+ ColSpan int // How many columns to span
+}
+
+// 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 0000000..a4e3d62
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/ast/print.go
@@ -0,0 +1,168 @@
+package ast
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "strings"
+ "unicode/utf8"
+)
+
+// 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 utf8.RuneCountInString(s) < maxLen {
+ return s
+ }
+ // add "…" to indicate truncation
+ return string(append([]rune(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)
+ case *CodeBlock:
+ printDefault(w, indent, typeName + ":" + string(v.Info), 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 0000000..b618dfe
--- /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/doc.go b/vendor/github.com/gomarkdown/markdown/doc.go
new file mode 100644
index 0000000..b623024
--- /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.NewWithExtensions(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 0000000..f31adb8
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/fuzz.go
@@ -0,0 +1,10 @@
+//go:build gofuzz
+// +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/html/doc.go b/vendor/github.com/gomarkdown/markdown/html/doc.go
new file mode 100644
index 0000000..34bbbe2
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/html/doc.go
@@ -0,0 +1,43 @@
+/*
+Package html implements HTML renderer of parsed markdown document.
+
+Configuring and customizing a renderer
+
+A renderer can be configured with multiple options:
+
+ import "github.com/gomarkdown/markdown/html"
+
+ flags := html.CommonFlags | html.CompletePage | html.HrefTargetBlank
+ opts := html.RendererOptions{
+ Title: "A custom title",
+ Flags: flags,
+ }
+ renderer := html.NewRenderer(opts)
+
+You can also re-use most of the logic and customize rendering of selected nodes
+by providing node render hook.
+This is most useful for rendering nodes that allow for design choices, like
+links or code blocks.
+
+ import (
+ "github.com/gomarkdown/markdown/html"
+ "github.com/gomarkdown/markdown/ast"
+ )
+
+ // a very dummy render hook that will output "code_replacements" instead of
+ // for paragraph tag
+ ParagraphTag 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 ${content} emitted by html.Renderer
+ func renderHookCodeBlock(w io.Writer, node ast.Node, entering bool) (ast.WalkStatus, bool) {
+ _, ok := node.(*ast.CodeBlock)
+ 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/renderer.go b/vendor/github.com/gomarkdown/markdown/html/renderer.go
new file mode 100644
index 0000000..494e754
--- /dev/null
+++ b/vendor/github.com/gomarkdown/markdown/html/renderer.go
@@ -0,0 +1,1339 @@
+package html
+
+import (
+ "bytes"
+ "fmt"
+ "html"
+ "io"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+
+ "github.com/gomarkdown/markdown/ast"
+ "github.com/gomarkdown/markdown/parser"
+)
+
+// 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"
+ NoopenerLinks // Only link with rel="noopener"
+ 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
+ LazyLoadImages // Include loading="lazy" with images
+
+ 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 blank, 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
+ // can over-write
")
+ EscapeHTML(w, node.Literal)
+ r.Outs(w, "")
+}
+
+// HTMLBlock write ast.HTMLBlock node
+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) 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) 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)
+ }
+}
+
+// Heading writes ast.Heading node
+func (r *Renderer) Heading(w io.Writer, node *ast.Heading, entering bool) {
+ if entering {
+ r.headingEnter(w, node)
+ } else {
+ r.headingExit(w, node)
+ }
+}
+
+// HorizontalRule writes ast.HorizontalRule 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("")
+ r.Outs(w, " ")
+ if !IsListItem(codeBlock.Parent) {
+ r.CR(w)
+ }
+}
+
+// Caption writes ast.Caption node
+func (r *Renderer) Caption(w io.Writer, caption *ast.Caption, entering bool) {
+ if entering {
+ r.Outs(w, "\[`, `\]
`) + if entering { + EscapeHTML(w, node.Literal) + } + case *ast.DocumentMatter: + r.DocumentMatter(w, node, entering) + case *ast.Callout: + r.Callout(w, node) + case *ast.Index: + r.Index(w, node) + case *ast.Subscript: + r.OutOneOf(w, true, "", "") + if entering { + Escape(w, node.Literal) + } + r.OutOneOf(w, false, "", "") + case *ast.Superscript: + r.OutOneOf(w, true, "", "") + if entering { + Escape(w, node.Literal) + } + r.OutOneOf(w, false, "", "") + case *ast.Footnotes: + // nothing by default; just output the list. + default: + panic(fmt.Sprintf("Unknown node %T", node)) + } + return ast.GoToNext +} + +// RenderHeader writes HTML document preamble and TOC if requested. +func (r *Renderer) RenderHeader(w io.Writer, ast ast.Node) { + r.writeDocumentHeader(w) + if r.Opts.Flags&TOC != 0 { + r.writeTOC(w, ast) + } +} + +// RenderFooter writes HTML document footer. +func (r *Renderer) RenderFooter(w io.Writer, _ ast.Node) { + if r.documentMatter != ast.DocumentMatterNone { + r.Outs(w, "