package blackfriday

Import Path
	github.com/russross/blackfriday/v2 (on go.dev)

Dependency Relation
	imports 9 packages, and imported by 2 packages

Involved Source Files

	      block.go
	   d➜ doc.go
		Package blackfriday is a markdown processor.

		It translates plain text with simple formatting rules into an AST, which can
		then be further processed to HTML (provided by Blackfriday itself) or other
		formats (provided by the community).

		The simplest way to invoke Blackfriday is to call the Run function. It will
		take a text input and produce a text output in HTML (or other format).

		A slightly more sophisticated way to use Blackfriday is to create a Markdown
		processor and to call Parse, which returns a syntax tree for the input
		document. You can leverage Blackfriday's parsing for content extraction from
		markdown documents. You can assign a custom renderer and set various options
		to the Markdown processor.

		If you're interested in calling Blackfriday from command line, see
		https://github.com/russross/blackfriday-tool.

	      esc.go
	      html.go
	      inline.go
	      markdown.go
	      node.go
	      smartypants.go
Package-Level Type Names (total 27, in which 21 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type CellAlignFlags int (basic type)
		CellAlignFlags holds a type of alignment in a table cell.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Markdown).tableHeader(data []byte) (size int, columns []CellAlignFlags)
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func cellAlignment(align CellAlignFlags) string
			func (*Markdown).tableRow(data []byte, columns []CellAlignFlags, header bool)
		As Types Of (total 3, all are exported)
			const TableAlignmentCenter
			const TableAlignmentLeft
			const TableAlignmentRight

	 type CodeBlockData (struct)
		CodeBlockData contains fields relevant to a CodeBlock node type.

		Fields (total 5, all are exported)
			FenceChar byte
			FenceLength int
			FenceOffset int
			Info []byte
				// This holds the info string

			IsFenced bool
				// Specifies whether it's a fenced code block or an indented one


	 type Extensions int (basic type)
		Extensions is a bitwise or'ed collection of enabled Blackfriday's
		extensions.

		As Inputs Of (at least one exported)
			func WithExtensions(e Extensions) Option
		As Types Of (total 18, all are exported)
			const AutoHeadingIDs
			const Autolink
			const BackslashLineBreak
			const CommonExtensions
			const DefinitionLists
			const FencedCode
			const Footnotes
			const HardLineBreak
			const HeadingIDs
			const LaxHTMLBlocks
			const NoEmptyLineBeforeBlock
			const NoExtensions
			const NoIntraEmphasis
			const SpaceHeadings
			const Strikethrough
			const Tables
			const TabSizeEight
			const Titleblock

	 type HeadingData (struct)
		HeadingData contains fields relevant to a Heading node type.

		Fields (total 3, all are exported)
			HeadingID string
				// This might hold heading ID, if present

			IsTitleblock bool
				// Specifies whether it's a title block

			Level int
				// This holds the heading level number


	 type HTMLFlags int (basic type)
		HTMLFlags control optional behavior of HTML renderer.

		As Inputs Of (at least 3, in which 1 are exported)
			func NewSmartypantsRenderer(flags HTMLFlags) *SPRenderer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func appendLinkAttrs(attrs []string, flags HTMLFlags, link []byte) []string
			func needSkipLink(flags HTMLFlags, dest []byte) bool
		As Types Of (total 20, all are exported)
			const CommonHTMLFlags
			const CompletePage
			const FootnoteReturnLinks
			const HrefTargetBlank
			const HTMLFlagsNone
			const NofollowLinks
			const NoopenerLinks
			const NoreferrerLinks
			const Safelink
			const SkipHTML
			const SkipImages
			const SkipLinks
			const Smartypants
			const SmartypantsAngledQuotes
			const SmartypantsDashes
			const SmartypantsFractions
			const SmartypantsLatexDashes
			const SmartypantsQuotesNBSP
			const TOC
			const UseXHTML

	 type HTMLRenderer (struct)
		HTMLRenderer is a type that implements the Renderer interface for HTML output.

		Do not create this directly, instead use the NewHTMLRenderer function.

		Fields (total 16, in which 11 are exported)
			HTMLRendererParameters HTMLRendererParameters
			HTMLRendererParameters.AbsolutePrefix string
				Prepend this text to each relative URL.

			HTMLRendererParameters.CSS string
				// Optional CSS file URL (used if CompletePage is set)

			HTMLRendererParameters.Flags HTMLFlags
				// Flags allow customizing this renderer's behavior

			HTMLRendererParameters.FootnoteAnchorPrefix string
				Add this text to each footnote anchor, to ensure uniqueness.

			HTMLRendererParameters.FootnoteReturnLinkContents string
				Show this text inside the <a> tag for a footnote return link, if the
				HTML_FOOTNOTE_RETURN_LINKS flag is enabled. If blank, the string
				<sup>[return]</sup> is used.

			HTMLRendererParameters.HeadingIDPrefix string
				If set, add this text to the front of each Heading ID, to ensure
				uniqueness.

			HTMLRendererParameters.HeadingIDSuffix string
				If set, add this text to the back of each Heading ID, to ensure uniqueness.

			HTMLRendererParameters.HeadingLevelOffset int
				Increase heading levels: if the offset is 1, <h1> becomes <h2> etc.
				Negative offset is also valid.
				Resulting levels are clipped between 1 and 6.

			HTMLRendererParameters.Icon string
				// Optional icon file URL (used if CompletePage is set)

			HTMLRendererParameters.Title string
				// Document title (used if CompletePage is set)

			/* 5 unexporteds ... *//* 5 unexporteds: */
			closeTag string
				// how to end singleton tags: either " />" or ">"

			disableTags int
			headingIDs map[string]int
				Track heading IDs to prevent ID collision in a single generation.

			lastOutputLen int
			sr *SPRenderer
		Methods (total 11, in which 3 are exported)
			(*T) RenderFooter(w io.Writer, ast *Node)
				RenderFooter writes HTML document footer.

			(*T) RenderHeader(w io.Writer, ast *Node)
				RenderHeader writes HTML document preamble and TOC if requested.

			(*T) RenderNode(w io.Writer, node *Node, entering bool) WalkStatus
				RenderNode is a default renderer of a single node of a syntax tree. For
				block nodes it will be called twice: first time with entering=true, second
				time with entering=false, so that it could know when it's working on an open
				tag and when on close. It writes the result to w.

				The return value is a way to tell the calling walker to adjust its walk
				pattern: e.g. it can terminate the traversal by returning Terminate. Or it
				can ask the walker to skip a subtree of this node by returning SkipChildren.
				The typical behavior is to return GoToNext, which asks for the usual
				traversal to the next node.

			/* 8 unexporteds ... *//* 8 unexporteds: */
			(*T) addAbsPrefix(link []byte) []byte
			(*T) cr(w io.Writer)
			(*T) ensureUniqueHeadingID(id string) string
			(*T) out(w io.Writer, text []byte)
			(*T) outHRTag(w io.Writer)
			(*T) tag(w io.Writer, name []byte, attrs []string)
			(*T) writeDocumentHeader(w io.Writer)
			(*T) writeTOC(w io.Writer, ast *Node)
		Implements (at least one exported)
			*T : Renderer
		As Outputs Of (at least one exported)
			func NewHTMLRenderer(params HTMLRendererParameters) *HTMLRenderer

	 type HTMLRendererParameters (struct)
		HTMLRendererParameters is a collection of supplementary parameters tweaking
		the behavior of various parts of HTML renderer.

		Fields (total 10, all are exported)
			AbsolutePrefix string
				Prepend this text to each relative URL.

			CSS string
				// Optional CSS file URL (used if CompletePage is set)

			Flags HTMLFlags
				// Flags allow customizing this renderer's behavior

			FootnoteAnchorPrefix string
				Add this text to each footnote anchor, to ensure uniqueness.

			FootnoteReturnLinkContents string
				Show this text inside the <a> tag for a footnote return link, if the
				HTML_FOOTNOTE_RETURN_LINKS flag is enabled. If blank, the string
				<sup>[return]</sup> is used.

			HeadingIDPrefix string
				If set, add this text to the front of each Heading ID, to ensure
				uniqueness.

			HeadingIDSuffix string
				If set, add this text to the back of each Heading ID, to ensure uniqueness.

			HeadingLevelOffset int
				Increase heading levels: if the offset is 1, <h1> becomes <h2> etc.
				Negative offset is also valid.
				Resulting levels are clipped between 1 and 6.

			Icon string
				// Optional icon file URL (used if CompletePage is set)

			Title string
				// Document title (used if CompletePage is set)

		As Inputs Of (at least one exported)
			func NewHTMLRenderer(params HTMLRendererParameters) *HTMLRenderer

	 type LinkData (struct)
		LinkData contains fields relevant to a Link node type.

		Fields (total 4, all are exported)
			Destination []byte
				// Destination is what goes into a href

			Footnote *Node
				// If it's a footnote, this is a direct link to the footnote Node. Otherwise nil.

			NoteID int
				// NoteID contains a serial number of a footnote, zero if it's not a footnote

			Title []byte
				// Title is the tooltip thing that goes in a title attribute


	 type ListData (struct)
		ListData contains fields relevant to a List and Item node type.

		Fields (total 6, all are exported)
			BulletChar byte
				// '*', '+' or '-' in bullet lists

			Delimiter byte
				// '.' or ')' after the number in ordered lists

			IsFootnotesList bool
				// This is a list of footnotes

			ListFlags ListType
			RefLink []byte
				// If not nil, turns this list item into a footnote item and triggers different rendering

			Tight bool
				// Skip <p>s around list item data if true


	 type ListType int (basic type)
		ListType contains bitwise or'ed flags for list and list item objects.

		As Inputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func (*Markdown).list(data []byte, flags ListType) int
			func (*Markdown).listItem(data []byte, flags *ListType) int
			func (*Markdown).listTypeChanged(data []byte, flags *ListType) bool
		As Types Of (total 6, all are exported)
			const ListItemBeginningOfList
			const ListItemContainsBlock
			const ListItemEndOfList
			const ListTypeDefinition
			const ListTypeOrdered
			const ListTypeTerm

	 type Markdown (struct)
		Markdown is a type that holds extensions and the runtime state used by
		Parse, and the renderer. You can not use it directly, construct it with New.

		Fields (total 14, none are exported)
			/* 14 unexporteds ... *//* 14 unexporteds: */
			allClosed bool
			doc *Node
			extensions Extensions
			inlineCallback [256]inlineParser
			insideLink bool
			lastMatchedContainer *Node
				// = doc

			maxNesting int
			nesting int
			notes []*reference
				Footnotes need to be ordered as well as available to quickly check for
				presence. If a ref is also a footnote, it's stored both in refs and here
				in notes. Slice is nil if footnotes not enabled.

			oldTip *Node
			referenceOverride ReferenceOverrideFunc
			refs map[string]*reference
			renderer Renderer
			tip *Node
				// = doc

		Methods (total 39, in which 1 are exported)
			(*T) Parse(input []byte) *Node
				Parse is an entry point to the parsing part of Blackfriday. It takes an
				input markdown document and produces a syntax tree for its contents. This
				tree can then be rendered with a default or custom renderer, or
				analyzed/transformed by the caller to whatever non-standard needs they have.
				The return value is the root node of the syntax tree.

			/* 38 unexporteds ... *//* 38 unexporteds: */
			(*T) addBlock(typ NodeType, content []byte) *Node
			(*T) addChild(node NodeType, offset uint32) *Node
			(*T) addExistingChild(node *Node, offset uint32) *Node
			(*T) block(data []byte)
				Parse block-level data.
				Note: this function and many that it calls assume that
				the input buffer ends with a newline.

			(*T) closeUnmatchedBlocks()
			(*T) code(data []byte) int
			(*T) codePrefix(data []byte) int
				returns prefix length for block code

			(*T) dliPrefix(data []byte) int
				returns definition list item prefix

			(*T) fencedCodeBlock(data []byte, doRender bool) int
				fencedCodeBlock returns the end index if data contains a fenced code block at the beginning,
				or 0 otherwise. It writes to out if doRender is true, otherwise it has no side effects.
				If doRender is true, a final newline is mandatory to recognize the fenced code block.

			(*T) finalize(block *Node)
			(*T) getRef(refid string) (ref *reference, found bool)
			(*T) html(data []byte, doRender bool) int
			(*T) htmlComment(data []byte, doRender bool) int
				HTML comment, lax form

			(*T) htmlFindEnd(tag string, data []byte) int
			(*T) htmlFindTag(data []byte) (string, bool)
			(*T) htmlHr(data []byte, doRender bool) int
				HR, which is the only self-closing block tag considered

			(*T) inline(currBlock *Node, data []byte)
			(*T) inlineHTMLComment(data []byte) int
			(*T) isEmpty(data []byte) int
			(*T) isHRule(data []byte) bool
			(*T) isPrefixHeading(data []byte) bool
			(*T) isUnderlinedHeading(data []byte) int
			(*T) list(data []byte, flags ListType) int
				parse ordered or unordered list block

			(*T) listItem(data []byte, flags *ListType) int
				Parse a single list item.
				Assumes initial prefix is already removed if this is a sublist.

			(*T) listTypeChanged(data []byte, flags *ListType) bool
				Returns true if the list item is not the same type as its parent list

			(*T) oliPrefix(data []byte) int
				returns ordered list item prefix

			(*T) paragraph(data []byte) int
			(*T) parseRefsToAST()
			(*T) prefixHeading(data []byte) int
			(*T) quote(data []byte) int
				parse a blockquote fragment

			(*T) quotePrefix(data []byte) int
				returns blockquote prefix length

			(*T) renderParagraph(data []byte)
				render a single paragraph that has already been parsed out

			(*T) table(data []byte) int
			(*T) tableHeader(data []byte) (size int, columns []CellAlignFlags)
			(*T) tableRow(data []byte, columns []CellAlignFlags, header bool)
			(*T) terminateBlockquote(data []byte, beg, end int) bool
				blockquote ends with at least one blank line
				followed by something without a blockquote prefix

			(*T) titleBlock(data []byte, doRender bool) int
			(*T) uliPrefix(data []byte) int
				returns unordered list item prefix

		As Outputs Of (at least one exported)
			func New(opts ...Option) *Markdown
		As Inputs Of (at least 18, none are exported)
			/* 18+ unexporteds ... *//* 18+ unexporteds: */
			func autoLink(p *Markdown, data []byte, offset int) (int, *Node)
			func codeSpan(p *Markdown, data []byte, offset int) (int, *Node)
			func emphasis(p *Markdown, data []byte, offset int) (int, *Node)
			func entity(p *Markdown, data []byte, offset int) (int, *Node)
			func escape(p *Markdown, data []byte, offset int) (int, *Node)
			func helperDoubleEmphasis(p *Markdown, data []byte, c byte) (int, *Node)
			func helperEmphasis(p *Markdown, data []byte, c byte) (int, *Node)
			func helperTripleEmphasis(p *Markdown, data []byte, offset int, c byte) (int, *Node)
			func isReference(p *Markdown, data []byte, tabSize int) int
			func leftAngle(p *Markdown, data []byte, offset int) (int, *Node)
			func lineBreak(p *Markdown, data []byte, offset int) (int, *Node)
			func link(p *Markdown, data []byte, offset int) (int, *Node)
			func maybeAutoLink(p *Markdown, data []byte, offset int) (int, *Node)
			func maybeImage(p *Markdown, data []byte, offset int) (int, *Node)
			func maybeInlineFootnote(p *Markdown, data []byte, offset int) (int, *Node)
			func maybeLineBreak(p *Markdown, data []byte, offset int) (int, *Node)
			func scanFootnote(p *Markdown, data []byte, i, indentSize int) (blockStart, blockEnd int, contents []byte, hasBlock bool)
			func scanLinkRef(p *Markdown, data []byte, i int) (linkOffset, linkEnd, titleOffset, titleEnd, lineEnd int)

	 type Node (struct)
		Node is a single element in the abstract syntax tree of the parsed document.
		It holds connections to the structurally neighboring nodes and, for certain
		types of nodes, additional information that might be needed when rendering.

		Fields (total 34, in which 32 are exported)
			CodeBlockData CodeBlockData
				// Populated if Type is CodeBlock

			CodeBlockData.FenceChar byte
			CodeBlockData.FenceLength int
			CodeBlockData.FenceOffset int
			CodeBlockData.Info []byte
				// This holds the info string

			CodeBlockData.IsFenced bool
				// Specifies whether it's a fenced code block or an indented one

			FirstChild *Node
				// Points to the first child, if any

			HeadingData HeadingData
				// Populated if Type is Heading

			HeadingData.HeadingID string
				// This might hold heading ID, if present

			HeadingData.IsTitleblock bool
				// Specifies whether it's a title block

			HeadingData.Level int
				// This holds the heading level number

			LastChild *Node
				// Points to the last child, if any

			LinkData LinkData
				// Populated if Type is Link

			LinkData.Destination []byte
				// Destination is what goes into a href

			LinkData.Footnote *Node
				// If it's a footnote, this is a direct link to the footnote Node. Otherwise nil.

			LinkData.NoteID int
				// NoteID contains a serial number of a footnote, zero if it's not a footnote

			LinkData.Title []byte
				// Title is the tooltip thing that goes in a title attribute

			ListData ListData
				// Populated if Type is List

			ListData.BulletChar byte
				// '*', '+' or '-' in bullet lists

			ListData.Delimiter byte
				// '.' or ')' after the number in ordered lists

			ListData.IsFootnotesList bool
				// This is a list of footnotes

			ListData.ListFlags ListType
			ListData.RefLink []byte
				// If not nil, turns this list item into a footnote item and triggers different rendering

			ListData.Tight bool
				// Skip <p>s around list item data if true

			Literal []byte
				// Text contents of the leaf nodes

			Next *Node
				// Next sibling; nil if it's the last child

			Parent *Node
				// Points to the parent

			Prev *Node
				// Previous sibling; nil if it's the first child

			TableCellData TableCellData
				// Populated if Type is TableCell

			TableCellData.Align CellAlignFlags
				// This holds the value for align attribute

			TableCellData.IsHeader bool
				// This tells if it's under the header row

			Type NodeType
				// Determines the type of the node

			/* 2 unexporteds ... *//* 2 unexporteds: */
			content []byte
				// Markdown content of the block nodes

			open bool
				// Specifies an open block node that has not been finished to process yet

		Methods (total 7, in which 5 are exported)
			(*T) AppendChild(child *Node)
				AppendChild adds a node 'child' as a child of 'n'.
				It panics if either node is nil.

			(*T) InsertBefore(sibling *Node)
				InsertBefore inserts 'sibling' immediately before 'n'.
				It panics if either node is nil.

			(*T) String() string
			(*T) Unlink()
				Unlink removes node 'n' from the tree.
				It panics if the node is nil.

			(*T) Walk(visitor NodeVisitor)
				Walk is a convenience method that instantiates a walker and starts a
				traversal of subtree rooted at n.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) canContain(t NodeType) bool
			(*T) isContainer() bool
		Implements (at least 4, in which 2 are exported)
			*T : expvar.Var
			*T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*T : context.stringer
			*T : runtime.stringer
		As Outputs Of (at least 21, in which 2 are exported)
			func NewNode(typ NodeType) *Node
			func (*Markdown).Parse(input []byte) *Node
			/* 19+ unexporteds ... *//* 19+ unexporteds: */
			func autoLink(p *Markdown, data []byte, offset int) (int, *Node)
			func codeSpan(p *Markdown, data []byte, offset int) (int, *Node)
			func emphasis(p *Markdown, data []byte, offset int) (int, *Node)
			func entity(p *Markdown, data []byte, offset int) (int, *Node)
			func escape(p *Markdown, data []byte, offset int) (int, *Node)
			func helperDoubleEmphasis(p *Markdown, data []byte, c byte) (int, *Node)
			func helperEmphasis(p *Markdown, data []byte, c byte) (int, *Node)
			func helperTripleEmphasis(p *Markdown, data []byte, offset int, c byte) (int, *Node)
			func leftAngle(p *Markdown, data []byte, offset int) (int, *Node)
			func lineBreak(p *Markdown, data []byte, offset int) (int, *Node)
			func link(p *Markdown, data []byte, offset int) (int, *Node)
			func maybeAutoLink(p *Markdown, data []byte, offset int) (int, *Node)
			func maybeImage(p *Markdown, data []byte, offset int) (int, *Node)
			func maybeInlineFootnote(p *Markdown, data []byte, offset int) (int, *Node)
			func maybeLineBreak(p *Markdown, data []byte, offset int) (int, *Node)
			func text(s []byte) *Node
			func (*Markdown).addBlock(typ NodeType, content []byte) *Node
			func (*Markdown).addChild(node NodeType, offset uint32) *Node
			func (*Markdown).addExistingChild(node *Node, offset uint32) *Node
		As Inputs Of (at least 25, in which 8 are exported)
			func (*HTMLRenderer).RenderFooter(w io.Writer, ast *Node)
			func (*HTMLRenderer).RenderHeader(w io.Writer, ast *Node)
			func (*HTMLRenderer).RenderNode(w io.Writer, node *Node, entering bool) WalkStatus
			func (*Node).AppendChild(child *Node)
			func (*Node).InsertBefore(sibling *Node)
			func Renderer.RenderFooter(w io.Writer, ast *Node)
			func Renderer.RenderHeader(w io.Writer, ast *Node)
			func Renderer.RenderNode(w io.Writer, node *Node, entering bool) WalkStatus
			/* 17+ unexporteds ... *//* 17+ unexporteds: */
			func dump(ast *Node)
			func dumpR(ast *Node, depth int) string
			func dumpString(ast *Node) string
			func endsWithBlankLine(block *Node) bool
			func finalizeCodeBlock(block *Node)
			func finalizeHTMLBlock(block *Node)
			func finalizeList(block *Node)
			func footnoteRef(prefix string, node *Node) []byte
			func isSmartypantable(node *Node) bool
			func itemOpenCR(node *Node) bool
			func newNodeWalker(root *Node) *nodeWalker
			func skipParagraphTags(node *Node) bool
			func (*HTMLRenderer).writeTOC(w io.Writer, ast *Node)
			func (*Markdown).addExistingChild(node *Node, offset uint32) *Node
			func (*Markdown).finalize(block *Node)
			func (*Markdown).inline(currBlock *Node, data []byte)
			func golang.org/x/pkgsite/internal/postgres.walkMarkdown(n *Node, buf []byte, level int) []byte

	 type NodeType int (basic type)
		NodeType specifies a type of a single node of a syntax tree. Usually one
		node (and its type) corresponds to a single markdown feature, e.g. emphasis
		or code block.

		Methods (only one, which is exported)
			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Inputs Of (at least 4, in which 1 are exported)
			func NewNode(typ NodeType) *Node
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func (*Markdown).addBlock(typ NodeType, content []byte) *Node
			func (*Markdown).addChild(node NodeType, offset uint32) *Node
			func (*Node).canContain(t NodeType) bool
		As Types Of (total 24, all are exported)
			const BlockQuote
			const Code
			const CodeBlock
			const Del
			const Document
			const Emph
			const Hardbreak
			const Heading
			const HorizontalRule
			const HTMLBlock
			const HTMLSpan
			const Image
			const Item
			const Link
			const List
			const Paragraph
			const Softbreak
			const Strong
			const Table
			const TableBody
			const TableCell
			const TableHead
			const TableRow
			const Text

	 type NodeVisitor (func)
		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.

		As Inputs Of (at least one exported)
			func (*Node).Walk(visitor NodeVisitor)

	 type Option (func)
		Option customizes the Markdown processor's default behavior.

		As Outputs Of (at least 4, all are exported)
			func WithExtensions(e Extensions) Option
			func WithNoExtensions() Option
			func WithRefOverride(o ReferenceOverrideFunc) Option
			func WithRenderer(r Renderer) Option
		As Inputs Of (at least 2, both are exported)
			func New(opts ...Option) *Markdown
			func Run(input []byte, opts ...Option) []byte

	 type Reference (struct)
		Reference represents the details of a link.
		See the documentation in Options for more details on use-case.

		Fields (total 3, all are exported)
			Link string
				Link is usually the URL the reference points to.

			Text string
				Text is the optional text to override the ref with if the syntax used was
				[refid][]

			Title string
				Title is the alternate text describing the link in more detail.


	 type ReferenceOverrideFunc (func)
		ReferenceOverrideFunc is expected to be called with a reference string and
		return either a valid Reference type that the reference string maps to or
		nil. If overridden is false, the default reference logic will be executed.
		See the documentation in Options for more details on use-case.

		As Inputs Of (at least one exported)
			func WithRefOverride(o ReferenceOverrideFunc) Option

	 type Renderer (interface)
		Renderer is the rendering interface. This is mostly of interest if you are
		implementing a new rendering format.

		Only an HTML implementation is provided in this repository, see the README
		for external implementations.

		Methods (total 3, all are exported)
			( T) RenderFooter(w io.Writer, ast *Node)
				RenderFooter is a symmetric counterpart of RenderHeader.

			( T) RenderHeader(w io.Writer, ast *Node)
				RenderHeader is a method that allows the renderer to produce some
				content preceding the main body of the output document. The header is
				understood in the broad sense here. For example, the default HTML
				renderer will write not only the HTML document preamble, but also the
				table of contents if it was requested.

				The method will be passed an entire document tree, in case a particular
				implementation needs to inspect it to produce output.

				The output should be written to the supplied writer w. If your
				implementation has no header to write, supply an empty implementation.

			( T) RenderNode(w io.Writer, node *Node, entering bool) WalkStatus
				RenderNode is the main rendering method. It will be called once for
				every leaf node and twice for every non-leaf node (first with
				entering=true, then with entering=false). The method should write its
				rendition of the node to the supplied writer w.

		Implemented By (at least one exported)
			*HTMLRenderer
		As Inputs Of (at least one exported)
			func WithRenderer(r Renderer) Option

	 type SPRenderer (struct)
		SPRenderer is a struct containing state of a Smartypants renderer.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			callbacks [256]smartCallback
			inDoubleQuote bool
			inSingleQuote bool
		Methods (total 15, in which 1 are exported)
			(*T) Process(w io.Writer, text []byte)
				Process is the entry point of the Smartypants renderer.

			/* 14 unexporteds ... *//* 14 unexporteds: */
			(*T) smartAmp(angledQuotes, addNBSP bool) func(*bytes.Buffer, byte, []byte) int
			(*T) smartAmpVariant(out *bytes.Buffer, previousChar byte, text []byte, quote byte, addNBSP bool) int
			(*T) smartAngledDoubleQuote(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartBacktick(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartDash(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartDashLatex(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartDoubleQuote(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartDoubleQuoteVariant(out *bytes.Buffer, previousChar byte, text []byte, quote byte) int
			(*T) smartLeftAngle(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartNumber(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartNumberGeneric(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartParens(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartPeriod(out *bytes.Buffer, previousChar byte, text []byte) int
			(*T) smartSingleQuote(out *bytes.Buffer, previousChar byte, text []byte) int
		As Outputs Of (at least one exported)
			func NewSmartypantsRenderer(flags HTMLFlags) *SPRenderer

	 type TableCellData (struct)
		TableCellData contains fields relevant to a TableCell node type.

		Fields (total 2, both are exported)
			Align CellAlignFlags
				// This holds the value for align attribute

			IsHeader bool
				// This tells if it's under the header row


	 type WalkStatus int (basic type)
		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.

		As Outputs Of (at least 2, both are exported)
			func (*HTMLRenderer).RenderNode(w io.Writer, node *Node, entering bool) WalkStatus
			func Renderer.RenderNode(w io.Writer, node *Node, entering bool) WalkStatus
		As Types Of (total 3, all are exported)
			const GoToNext
			const SkipChildren
			const Terminate

	/* 6 unexporteds ... *//* 6 unexporteds: */
	 type autolinkType int (basic type)
		autolinkType specifies a kind of autolink that gets detected.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func tagLength(data []byte) (autolink autolinkType, end int)
		As Types Of (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			const emailAutolink
			const normalAutolink
			const notAutolink

	 type inlineParser (func)
		Callback functions for inline parsing. One such function is defined
		for each character that triggers a response when parsing inline data.


	 type linkType int (basic type)

		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func isReferenceStyleLink(data []byte, pos int, t linkType) bool
		As Types Of (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			const linkDeferredFootnote
			const linkImg
			const linkInlineFootnote
			const linkNormal

	 type nodeWalker (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			current *Node
			entering bool
			root *Node
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*T) next()
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newNodeWalker(root *Node) *nodeWalker

	 type reference (struct)
		reference holds all information necessary for a reference-style links or
		footnotes.

		Consider this markdown with reference-style links:

		    [link][ref]

		    [ref]: /url/ "tooltip title"

		It will be ultimately converted to this HTML:

		    <p><a href=\"/url/\" title=\"title\">link</a></p>

		And a reference structure will be populated as follows:

		    p.refs["ref"] = &reference{
		        link: "/url/",
		        title: "tooltip title",
		    }

		Alternatively, reference can contain information about a footnote. Consider
		this markdown:

		    Text needing a footnote.[^a]

		    [^a]: This is the note

		A reference structure will be populated as follows:

		    p.refs["a"] = &reference{
		        link: "a",
		        title: "This is the note",
		        noteID: <some positive int>,
		    }

		TODO: As you can see, it begs for splitting into two dedicated structures
		for refs and for footnotes.

		Fields (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			footnote *Node
				// a link to the Item node within a list of footnotes

			hasBlock bool
			link []byte
			noteID int
				// 0 if not a footnote ref

			text []byte
				// only gets populated by refOverride feature with Reference.Text

			title []byte
		Methods (only one, which is exported)
			(*T) String() string
		Implements (at least 4, in which 2 are exported)
			*T : expvar.Var
			*T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*T : context.stringer
			*T : runtime.stringer
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Markdown).getRef(refid string) (ref *reference, found bool)

	 type smartCallback (func)
Package-Level Functions (total 85, in which 9 are exported)

	 func New(opts ...Option) *Markdown
		New constructs a Markdown processor. You can use the same With* functions as
		for Run() to customize parser's behavior and the renderer.

	 func NewHTMLRenderer(params HTMLRendererParameters) *HTMLRenderer
		NewHTMLRenderer creates and configures an HTMLRenderer object, which
		satisfies the Renderer interface.

	 func NewNode(typ NodeType) *Node
		NewNode allocates a node of a specified type.

	 func NewSmartypantsRenderer(flags HTMLFlags) *SPRenderer
		NewSmartypantsRenderer constructs a Smartypants renderer object.

	 func Run(input []byte, opts ...Option) []byte
		Run is the main entry point to Blackfriday. It parses and renders a
		block of markdown-encoded text.

		The simplest invocation of Run takes one argument, input:
		    output := Run(input)
		This will parse the input with CommonExtensions enabled and render it with
		the default HTMLRenderer (with CommonHTMLFlags).

		Variadic arguments opts can customize the default behavior. Since Markdown
		type does not contain exported fields, you can not use it directly. Instead,
		use the With* functions. For example, this will call the most basic
		functionality, with no extensions:
		    output := Run(input, WithNoExtensions())

		You can use any number of With* arguments, even contradicting ones. They
		will be applied in order of appearance and the latter will override the
		former:
		    output := Run(input, WithNoExtensions(), WithExtensions(exts),
		        WithRenderer(yourRenderer))

	 func WithExtensions(e Extensions) Option
		WithExtensions allows you to pick some of the many extensions provided by
		Blackfriday. You can bitwise OR them.

	 func WithNoExtensions() Option
		WithNoExtensions turns off all extensions and custom behavior.

	 func WithRefOverride(o ReferenceOverrideFunc) Option
		WithRefOverride sets an optional function callback that is called every
		time a reference is resolved.

		In Markdown, the link reference syntax can be made to resolve a link to
		a reference instead of an inline URL, in one of the following ways:

		 * [link text][refid]
		 * [refid][]

		Usually, the refid is defined at the bottom of the Markdown document. If
		this override function is provided, the refid is passed to the override
		function first, before consulting the defined refids at the bottom. If
		the override function indicates an override did not occur, the refids at
		the bottom will be used to fill in the link details.

	 func WithRenderer(r Renderer) Option
		WithRenderer allows you to override the default renderer.

	/* 76 unexporteds ... *//* 76 unexporteds: */
	 func appendLanguageAttr(attrs []string, info []byte) []string
	 func appendLinkAttrs(attrs []string, flags HTMLFlags, link []byte) []string
	 func autoLink(p *Markdown, data []byte, offset int) (int, *Node)
	 func cellAlignment(align CellAlignFlags) string
	 func codeSpan(p *Markdown, data []byte, offset int) (int, *Node)
	 func dump(ast *Node)
	 func dumpR(ast *Node, depth int) string
	 func dumpString(ast *Node) string
	 func emphasis(p *Markdown, data []byte, offset int) (int, *Node)
		single and double emphasis parsing

	 func endsWithBlankLine(block *Node) bool
		Returns true if block ends with a blank line, descending if needed
		into lists and sublists.

	 func entity(p *Markdown, data []byte, offset int) (int, *Node)
		'&' escaped when it doesn't belong to an entity
		valid entities are assumed to be anything matching &#?[A-Za-z0-9]+;

	 func escape(p *Markdown, data []byte, offset int) (int, *Node)
	 func escapeHTML(w io.Writer, s []byte)
	 func escLink(w io.Writer, text []byte)
	 func expandTabs(out *bytes.Buffer, line []byte, tabSize int)
		Replace tab characters with spaces, aligning to the next TAB_SIZE column.
		always ends output with a newline

	 func finalizeCodeBlock(block *Node)
	 func finalizeHTMLBlock(block *Node)
	 func finalizeList(block *Node)
	 func findHTMLTagPos(tag []byte, tagname string) (bool, int)
	 func footnoteItem(prefix string, slug []byte) []byte
	 func footnoteRef(prefix string, node *Node) []byte
	 func footnoteReturnLink(prefix, returnLink string, slug []byte) []byte
	 func hasPrefixCaseInsensitive(s, prefix []byte) bool
		hasPrefixCaseInsensitive is a custom implementation of
		    strings.HasPrefix(strings.ToLower(s), prefix)
		we rolled our own because ToLower pulls in a huge machinery of lowercasing
		anything from Unicode and that's very slow. Since this func will only be
		used on ASCII protocol prefixes, we can take shortcuts.

	 func headingTagsFromLevel(level int) ([]byte, []byte)
	 func helperDoubleEmphasis(p *Markdown, data []byte, c byte) (int, *Node)
	 func helperEmphasis(p *Markdown, data []byte, c byte) (int, *Node)
	 func helperFindEmphChar(data []byte, c byte) int
		look for the next emph char, skipping other constructs

	 func helperTripleEmphasis(p *Markdown, data []byte, offset int, c byte) (int, *Node)
	 func isalnum(c byte) bool
		Test if a character is a letter or a digit.
		TODO: check when this is looking for ASCII alnum and when it should use unicode

	 func isBackslashEscaped(data []byte, i int) bool
		check if the specified position is preceded by an odd number of backslashes

	 func isdigit(c byte) bool
	 func isEndOfLink(char byte) bool
	 func isFenceLine(data []byte, info *string, oldmarker string) (end int, marker string)
		isFenceLine checks if there's a fence line (e.g., ``` or ``` go) at the beginning of data,
		and returns the end index if so, or 0 otherwise. It also returns the marker found.
		If info is not nil, it gets set to the syntax specified in the fence line.

	 func ishorizontalspace(c byte) bool
		Test if a character is a horizontal whitespace character.

	 func isHTMLTag(tag []byte, tagname string) bool
	 func isIndented(data []byte, indentSize int) int
		Find if a line counts as indented or not.
		Returns number of characters the indent is (0 = not indented).

	 func isletter(c byte) bool
		Test if a character is letter.

	 func isMailto(link []byte) bool
	 func isMailtoAutoLink(data []byte) int
		look for the address part of a mail autolink and '>'
		this is less strict than the original markdown e-mail address matching

	 func ispunct(c byte) bool
		Test if a character is a punctuation symbol.
		Taken from a private function in regexp in the stdlib.

	 func isReference(p *Markdown, data []byte, tabSize int) int
		Check whether or not data starts with a reference link.
		If so, it is parsed and stored in the list of references
		(in the render struct).
		Returns the number of bytes to skip to move past it,
		or zero if the first line is not a reference.

	 func isReferenceStyleLink(data []byte, pos int, t linkType) bool
	 func isRelativeLink(link []byte) (yes bool)
	 func isSafeLink(link []byte) bool
	 func isSmartypantable(node *Node) bool
	 func isspace(c byte) bool
		Test if a character is a whitespace character.

	 func isverticalspace(c byte) bool
		Test if a character is a vertical character.

	 func itemOpenCR(node *Node) bool
	 func leftAngle(p *Markdown, data []byte, offset int) (int, *Node)
		'<' when tags or autolinks are allowed

	 func lineBreak(p *Markdown, data []byte, offset int) (int, *Node)
		newline without two spaces works when HardLineBreak is enabled

	 func link(p *Markdown, data []byte, offset int) (int, *Node)
		'[': parse a link or an image or a footnote

	 func linkEndsWithEntity(data []byte, linkEnd int) bool
	 func maybeAutoLink(p *Markdown, data []byte, offset int) (int, *Node)
	 func maybeImage(p *Markdown, data []byte, offset int) (int, *Node)
	 func maybeInlineFootnote(p *Markdown, data []byte, offset int) (int, *Node)
	 func maybeLineBreak(p *Markdown, data []byte, offset int) (int, *Node)
		newline preceded by two spaces becomes <br>

	 func needSkipLink(flags HTMLFlags, dest []byte) bool
	 func newNodeWalker(root *Node) *nodeWalker
	 func normalizeURI(s []byte) []byte
	 func scanFootnote(p *Markdown, data []byte, i, indentSize int) (blockStart, blockEnd int, contents []byte, hasBlock bool)
		The first bit of this logic is the same as Parser.listItem, but the rest
		is much simpler. This function simply finds the entire block and shifts it
		over by one tab if it is indeed a block (just returns the line if it's not).
		blockEnd is the end of the section in the input buffer, and contents is the
		extracted text that was shifted over one tab. It will need to be rendered at
		the end of the document.

	 func scanLinkRef(p *Markdown, data []byte, i int) (linkOffset, linkEnd, titleOffset, titleEnd, lineEnd int)
	 func skipChar(data []byte, start int, char byte) int
	 func skipParagraphTags(node *Node) bool
	 func skipSpace(tag []byte, i int) int
	 func skipUntilChar(text []byte, start int, char byte) int
	 func skipUntilCharIgnoreQuotes(html []byte, start int, char byte) int
		Look for a character, but ignore it when it's in any kind of quotes, it
		might be JavaScript

	 func slugify(in []byte) []byte
		Create a url-safe slug for fragments

	 func smartQuoteHelper(out *bytes.Buffer, previousChar byte, nextChar byte, quote byte, isOpen *bool, addNBSP bool) bool
	 func stripMailto(link []byte) []byte
	 func tagLength(data []byte) (autolink autolinkType, end int)
		return the length of the given tag, or 0 is it's not valid

	 func text(s []byte) *Node
	 func tolower(c byte) byte
	 func unescapeChar(str []byte) []byte
	 func unescapeString(str []byte) []byte
	 func unescapeText(ob *bytes.Buffer, src []byte)
	 func wordBoundary(c byte) bool
Package-Level Variables (total 76, none are exported)

	/* 76 unexporteds ... *//* 76 unexporteds: */
	  var aCloseTag []byte
	  var anchorRe *regexp.Regexp
	  var aTag []byte
	  var blockquoteCloseTag []byte
	  var blockquoteTag []byte
	  var blockTags map[string]struct{}
		blockTags is a set of tags that are recognized as HTML block tags.
		Any of these can be included in markdown text without special escaping.

	  var brTag []byte
	  var brXHTMLTag []byte
	  var codeCloseTag []byte
	  var codeTag []byte
	  var ddCloseTag []byte
	  var ddTag []byte
	  var delCloseTag []byte
	  var delTag []byte
	  var dlCloseTag []byte
	  var dlTag []byte
	  var dtCloseTag []byte
	  var dtTag []byte
	  var emCloseTag []byte
	  var emTag []byte
	  var escapeChars []byte
		'\\' backslash escape

	  var footnotesCloseDivBytes []byte
	  var footnotesDivBytes []byte
	  var gtBytes []byte
	  var h1CloseTag []byte
	  var h1Tag []byte
	  var h2CloseTag []byte
	  var h2Tag []byte
	  var h3CloseTag []byte
	  var h3Tag []byte
	  var h4CloseTag []byte
	  var h4Tag []byte
	  var h5CloseTag []byte
	  var h5Tag []byte
	  var h6CloseTag []byte
	  var h6Tag []byte
	  var hrTag []byte
	  var hrXHTMLTag []byte
	  var htmlEntityRe *regexp.Regexp
		https://www.w3.org/TR/html5/syntax.html#character-references
		highest unicode code point in 17 planes (2^20): 1,114,112d =
		7 dec digits or 6 hex digits
		named entity references can be 2-31 characters with stuff like &lt;
		at one end and &CounterClockwiseContourIntegral; at the other. There
		are also sometimes numbers at the end, although this isn't inherent
		in the specification; there are never numbers anywhere else in
		current character references, though; see &frac34; and &blk12;, etc.
		https://www.w3.org/TR/html5/syntax.html#named-character-references

		entity := "&" (named group | number ref) ";"
		named group := [a-zA-Z]{2,31}[0-9]{0,2}
		number ref := "#" (dec ref | hex ref)
		dec ref := [0-9]{1,7}
		hex ref := ("x" | "X") [0-9a-fA-F]{1,6}

	  var htmlEscaper [256][]byte
	  var htmlTagRe *regexp.Regexp
	  var liCloseTag []byte
	  var liTag []byte
	  var nlBytes []byte
	  var nodeTypeNames []string
	  var olCloseTag []byte
	  var olTag []byte
	  var pCloseTag []byte
	  var preCloseTag []byte
	  var preTag []byte
	  var protocolPrefixes [][]byte
	  var pTag []byte
	  var reBackslashOrAmp *regexp.Regexp
	  var reEntityOrEscapedChar *regexp.Regexp
	  var spaceBytes []byte
	  var strongCloseTag []byte
	  var strongTag []byte
	  var tableCloseTag []byte
	  var tableTag []byte
	  var tbodyCloseTag []byte
	  var tbodyTag []byte
	  var tdCloseTag []byte
	  var tdTag []byte
	  var thCloseTag []byte
	  var theadCloseTag []byte
	  var theadTag []byte
	  var thTag []byte
	  var trCloseTag []byte
	  var trTag []byte
	  var ttCloseTag []byte
	  var ttTag []byte
	  var ulCloseTag []byte
	  var ulTag []byte
	  var urlRe string
	  var validPaths [][]byte
	  var validUris [][]byte
Package-Level Constants (total 104, in which 77 are exported)

	const AutoHeadingIDs Extensions = 16384 // Create the heading ID from the text
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const Autolink Extensions = 16 // Detect embedded URLs that are not explicitly marked
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const BackslashLineBreak Extensions = 32768 // Translate trailing backslashes into line breaks
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const BlockQuote NodeType = 1
		Constants for identifying different types of nodes. See NodeType.

	const Code NodeType = 17
		Constants for identifying different types of nodes. See NodeType.

	const CodeBlock NodeType = 14
		Constants for identifying different types of nodes. See NodeType.

	const CommonExtensions Extensions = 102590
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const CommonHTMLFlags HTMLFlags = 62464
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const CompletePage HTMLFlags = 512 // Generate a complete HTML page
		HTML renderer configuration options.

	const DefinitionLists Extensions = 65536 // Render definition lists
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const Del NodeType = 9
		Constants for identifying different types of nodes. See NodeType.

	const Document NodeType = 0
		Constants for identifying different types of nodes. See NodeType.

	const Emph NodeType = 7
		Constants for identifying different types of nodes. See NodeType.

	const FencedCode Extensions = 8 // Render fenced code blocks
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const FootnoteReturnLinks HTMLFlags = 2048 // Generate a link at the end of a footnote to return to the source
		HTML renderer configuration options.

	const Footnotes Extensions = 1024 // Pandoc-style footnotes
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const GoToNext WalkStatus = 0
		GoToNext is the default traversal of every node.

	const Hardbreak NodeType = 16
		Constants for identifying different types of nodes. See NodeType.

	const HardLineBreak Extensions = 256 // Translate newlines into line breaks
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const Heading NodeType = 5
		Constants for identifying different types of nodes. See NodeType.

	const HeadingIDs Extensions = 4096 // specify heading IDs  with {#id}
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const HorizontalRule NodeType = 6
		Constants for identifying different types of nodes. See NodeType.

	const HrefTargetBlank HTMLFlags = 256 // Add a blank target
		HTML renderer configuration options.

	const HTMLBlock NodeType = 13
		Constants for identifying different types of nodes. See NodeType.

	const HTMLFlagsNone HTMLFlags = 0
		HTML renderer configuration options.

	const HTMLSpan NodeType = 18
		Constants for identifying different types of nodes. See NodeType.

	const Image NodeType = 11
		Constants for identifying different types of nodes. See NodeType.

	const Item NodeType = 3
		Constants for identifying different types of nodes. See NodeType.

	const LaxHTMLBlocks Extensions = 64 // Loosen up HTML block parsing rules
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const Link NodeType = 10
		Constants for identifying different types of nodes. See NodeType.

	const List NodeType = 2
		Constants for identifying different types of nodes. See NodeType.

	const ListItemBeginningOfList ListType = 16 // TODO: figure out if this is of any use now
		These are the possible flag values for the ListItem renderer.
		Multiple flag values may be ORed together.
		These are mostly of interest if you are writing a new output format.

	const ListItemContainsBlock ListType = 8
		These are the possible flag values for the ListItem renderer.
		Multiple flag values may be ORed together.
		These are mostly of interest if you are writing a new output format.

	const ListItemEndOfList ListType = 32
		These are the possible flag values for the ListItem renderer.
		Multiple flag values may be ORed together.
		These are mostly of interest if you are writing a new output format.

	const ListTypeDefinition ListType = 2
		These are the possible flag values for the ListItem renderer.
		Multiple flag values may be ORed together.
		These are mostly of interest if you are writing a new output format.

	const ListTypeOrdered ListType = 1
		These are the possible flag values for the ListItem renderer.
		Multiple flag values may be ORed together.
		These are mostly of interest if you are writing a new output format.

	const ListTypeTerm ListType = 4
		These are the possible flag values for the ListItem renderer.
		Multiple flag values may be ORed together.
		These are mostly of interest if you are writing a new output format.

	const NoEmptyLineBeforeBlock Extensions = 2048 // No need to insert an empty line to start a (code, quote, ordered list, unordered list) block
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const NoExtensions Extensions = 0
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const NofollowLinks HTMLFlags = 32 // Only link with rel="nofollow"
		HTML renderer configuration options.

	const NoIntraEmphasis Extensions = 2 // Ignore emphasis markers inside words
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const NoopenerLinks HTMLFlags = 128 // Only link with rel="noopener"
		HTML renderer configuration options.

	const NoreferrerLinks HTMLFlags = 64 // Only link with rel="noreferrer"
		HTML renderer configuration options.

	const Paragraph NodeType = 4
		Constants for identifying different types of nodes. See NodeType.

	const Safelink HTMLFlags = 16 // Only link to trusted protocols
		HTML renderer configuration options.

	const SkipChildren WalkStatus = 1
		SkipChildren tells walker to skip all children of current node.

	const SkipHTML HTMLFlags = 2 // Skip preformatted HTML blocks
		HTML renderer configuration options.

	const SkipImages HTMLFlags = 4 // Skip embedded images
		HTML renderer configuration options.

	const SkipLinks HTMLFlags = 8 // Skip all links
		HTML renderer configuration options.

	const Smartypants HTMLFlags = 4096 // Enable smart punctuation substitutions
		HTML renderer configuration options.

	const SmartypantsAngledQuotes HTMLFlags = 65536 // Enable angled double quotes (with Smartypants) for double quotes rendering
		HTML renderer configuration options.

	const SmartypantsDashes HTMLFlags = 16384 // Enable smart dashes (with Smartypants)
		HTML renderer configuration options.

	const SmartypantsFractions HTMLFlags = 8192 // Enable smart fractions (with Smartypants)
		HTML renderer configuration options.

	const SmartypantsLatexDashes HTMLFlags = 32768 // Enable LaTeX-style dashes (with Smartypants)
		HTML renderer configuration options.

	const SmartypantsQuotesNBSP HTMLFlags = 131072 // Enable « French guillemets » (with Smartypants)
		HTML renderer configuration options.

	const Softbreak NodeType = 15
		Constants for identifying different types of nodes. See NodeType.

	const SpaceHeadings Extensions = 128 // Be strict about prefix heading rules
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const Strikethrough Extensions = 32 // Strikethrough text using ~~test~~
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const Strong NodeType = 8
		Constants for identifying different types of nodes. See NodeType.

	const Table NodeType = 19
		Constants for identifying different types of nodes. See NodeType.

	const TableAlignmentCenter CellAlignFlags = 3
		These are the possible flag values for the table cell renderer.
		Only a single one of these values will be used; they are not ORed together.
		These are mostly of interest if you are writing a new output format.

	const TableAlignmentLeft CellAlignFlags = 1
		These are the possible flag values for the table cell renderer.
		Only a single one of these values will be used; they are not ORed together.
		These are mostly of interest if you are writing a new output format.

	const TableAlignmentRight CellAlignFlags = 2
		These are the possible flag values for the table cell renderer.
		Only a single one of these values will be used; they are not ORed together.
		These are mostly of interest if you are writing a new output format.

	const TableBody NodeType = 22
		Constants for identifying different types of nodes. See NodeType.

	const TableCell NodeType = 20
		Constants for identifying different types of nodes. See NodeType.

	const TableHead NodeType = 21
		Constants for identifying different types of nodes. See NodeType.

	const TableRow NodeType = 23
		Constants for identifying different types of nodes. See NodeType.

	const Tables Extensions = 4 // Render tables
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const TabSizeDefault = 4
		The size of a tab stop.

	const TabSizeDouble = 8
		The size of a tab stop.

	const TabSizeEight Extensions = 512 // Expand tabs to eight spaces instead of four
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const Terminate WalkStatus = 2
		Terminate tells walker to terminate the traversal.

	const Text NodeType = 12
		Constants for identifying different types of nodes. See NodeType.

	const Titleblock Extensions = 8192 // Titleblock ala pandoc
		These are the supported markdown parsing extensions.
		OR these values together to select multiple extensions.

	const TOC HTMLFlags = 262144 // Generate a table of contents
		HTML renderer configuration options.

	const UseXHTML HTMLFlags = 1024 // Generate XHTML output instead of HTML
		HTML renderer configuration options.

	const Version = "2.0"
		Version string of the package. Appears in the rendered document when
		CompletePage flag is on.

	/* 27 unexporteds ... *//* 27 unexporteds: */
	const attribute = "(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20...
	const attributeName = "[a-zA-Z_:][a-zA-Z0-9:._-]*"
	const attributeValue = "(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\")"
	const attributeValueSpec = "(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))"
	const cdata = ""
	const charEntity = "&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});"
	const closeTag = "]"
	const declaration = "]*>"
	const doubleQuotedValue = "\"[^\"]*\""
	const emailAutolink autolinkType = 2
		These are the possible flag values for the autolink renderer.

	const escapable = "[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]"
	const htmlClose = ">"
	const htmlComment = "|"
	const htmlTag = "(?:<[A-Za-z][A-Za-z0-9-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\...
	const linkDeferredFootnote linkType = 2
	const linkImg linkType = 1
	const linkInlineFootnote linkType = 3
	const linkNormal linkType = 0
	const normalAutolink autolinkType = 1
		These are the possible flag values for the autolink renderer.

	const notAutolink autolinkType = 0
		These are the possible flag values for the autolink renderer.

	const openTag = "<[A-Za-z][A-Za-z0-9-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(...
	const processingInstruction = "[<][?].*?[?][>]"
	const shortestPrefix = 6 // len("ftp://"), the shortest of the above
	const singleQuotedValue = "'[^']*'"
	const tagName = "[A-Za-z][A-Za-z0-9-]*"
	const unquotedValue = "[^\"'=<>`\\x00-\\x20]+"
	const xhtmlClose = " />"

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.