package html

Import Path
	github.com/gomarkdown/markdown/html (on go.dev)

Dependency Relation
	imports 10 packages, and imported by 2 packages

Involved Source Files

	  d doc.go
		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
			// <code>${content}</code> 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)

	    renderer.go
	    smartypants.go
Package-Level Type Names (total 5)

	/* sort by: alphabet | popularity */
	 type Flags int (basic type)
		Flags control optional behavior of HTML renderer.

		As Inputs Of (at least one exported)
			func NewSmartypantsRenderer(flags Flags) *SPRenderer
		As Types Of (total 22)
			const CommonFlags
			const CompletePage
			const FlagsNone
			const FootnoteNoHRTag
			const FootnoteReturnLinks
			const HrefTargetBlank
			const LazyLoadImages
			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 Renderer (struct)
		Renderer implements Renderer interface for HTML output.
		
		Do not create this directly, instead use the NewRenderer function.

		Fields (total 3)
			DisableTags int
				if > 0, will strip html tags in Out and Outs

			IsSafeURLOverride func(url []byte) bool
				IsSafeURLOverride allows overriding the default URL matcher. URL is
				safe if the overriding function returns true. Can be used to extend
				the default list of safe URLs.

			Opts RendererOptions
		Methods (total 37)
			(*Renderer) CR(w io.Writer)
				CR writes a new line

			(*Renderer) Callout(w io.Writer, node *ast.Callout)
				Callout writes ast.Callout node

			(*Renderer) Caption(w io.Writer, caption *ast.Caption, entering bool)
				Caption writes ast.Caption node

			(*Renderer) CaptionFigure(w io.Writer, figure *ast.CaptionFigure, entering bool)
				CaptionFigure writes ast.CaptionFigure node

			(*Renderer) Citation(w io.Writer, node *ast.Citation)
				Citation writes ast.Citation node

			(*Renderer) Code(w io.Writer, node *ast.Code)
				Code writes ast.Code node

			(*Renderer) CodeBlock(w io.Writer, codeBlock *ast.CodeBlock)
				CodeBlock writes ast.CodeBlock node

			(*Renderer) DocumentMatter(w io.Writer, node *ast.DocumentMatter, entering bool)
				DocumentMatter writes ast.DocumentMatter

			(*Renderer) EnsureUniqueHeadingID(id string) string
			(*Renderer) EscapeHTMLCallouts(w io.Writer, d []byte)
				EscapeHTMLCallouts writes html-escaped d to w. It escapes &, <, > and " characters, *but*
				expands callouts <<N>> with the callout HTML, i.e. by calling r.callout() with a newly created
				ast.Callout node.

			(*Renderer) HTMLBlock(w io.Writer, node *ast.HTMLBlock)
				HTMLBlock write ast.HTMLBlock node

			(*Renderer) HTMLSpan(w io.Writer, span *ast.HTMLSpan)
				HTMLSpan writes ast.HTMLSpan node

			(*Renderer) HardBreak(w io.Writer, node *ast.Hardbreak)
				HardBreak writes ast.Hardbreak node

			(*Renderer) Heading(w io.Writer, hdr *ast.Heading, entering bool)
				Heading writes ast.Heading node

			(*Renderer) HeadingEnter(w io.Writer, hdr *ast.Heading)
			(*Renderer) HeadingExit(w io.Writer, hdr *ast.Heading)
			(*Renderer) HorizontalRule(w io.Writer, node *ast.HorizontalRule)
				HorizontalRule writes ast.HorizontalRule node

			(*Renderer) Image(w io.Writer, node *ast.Image, entering bool)
				Image writes ast.Image node

			(*Renderer) Index(w io.Writer, node *ast.Index)
				Index writes ast.Index node

			(*Renderer) Link(w io.Writer, link *ast.Link, entering bool)
				Link writes ast.Link node

			(*Renderer) List(w io.Writer, list *ast.List, entering bool)
				List writes ast.List node

			(*Renderer) ListItem(w io.Writer, listItem *ast.ListItem, entering bool)
				ListItem writes ast.ListItem node

			(*Renderer) MakeUniqueHeadingID(hdr *ast.Heading) string
			(*Renderer) NonBlockingSpace(w io.Writer, node *ast.NonBlockingSpace)
				NonBlockingSpace writes ast.NonBlockingSpace node

			(*Renderer) Out(w io.Writer, d []byte)
				Out is a helper to write data to writer

			(*Renderer) OutHRTag(w io.Writer, attrs []string)
			(*Renderer) OutOneOf(w io.Writer, outFirst bool, first string, second string)
				OutOneOf writes first or second depending on outFirst

			(*Renderer) OutOneOfCr(w io.Writer, outFirst bool, first string, second string)
				OutOneOfCr writes CR + first or second + CR depending on outFirst

			(*Renderer) OutTag(w io.Writer, name string, attrs []string)
			(*Renderer) Outs(w io.Writer, s string)
				Outs is a helper to write data to writer

			(*Renderer) Paragraph(w io.Writer, para *ast.Paragraph, entering bool)
				Paragraph writes ast.Paragraph node

			(*Renderer) RenderFooter(w io.Writer, _ ast.Node)
				RenderFooter writes HTML document footer.

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

			(*Renderer) RenderNode(w io.Writer, node ast.Node, entering bool) ast.WalkStatus
				RenderNode renders a markdown node to HTML

			(*Renderer) TableBody(w io.Writer, node *ast.TableBody, entering bool)
				TableBody writes ast.TableBody node

			(*Renderer) TableCell(w io.Writer, tableCell *ast.TableCell, entering bool)
				TableCell writes ast.TableCell node

			(*Renderer) Text(w io.Writer, text *ast.Text)
				Text writes ast.Text node

		Implements (at least one exported)
			*Renderer : github.com/gomarkdown/markdown.Renderer
		As Outputs Of (at least one exported)
			func NewRenderer(opts RendererOptions) *Renderer

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

		Fields (total 15)
			AbsolutePrefix string
				Prepend this text to each relative URL.

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

			CitationFormatString string
				CitationFormatString defines how a citation is rendered. If blank, the string
				<sup>[%s]</sup> is used. Where %s will be substituted with the citation target.

			Comments [][]byte
				Comments is a list of comments the renderer should detect when
				parsing code blocks and detecting callouts.

			Flags Flags
				// 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
				FootnoteReturnLinks flag is enabled. If blank, the string
				<sup>[return]</sup> is used.

			Generator string
				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 `  <meta name="GENERATOR" content="github.com/gomarkdown/markdown markdown processor for Go`

			Head []byte
				// Optional head data injected in the <head> section (used if CompletePage is set)

			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.

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

			ParagraphTag string
				can over-write <p> for paragraph tag

			RenderNodeHook RenderNodeFunc
				if set, called at the start of RenderNode(). Allows replacing
				rendering of some nodes

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

		As Inputs Of (at least one exported)
			func NewRenderer(opts RendererOptions) *Renderer

	 type RenderNodeFunc (func)
		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 SPRenderer (struct)
		SPRenderer is a struct containing state of a Smartypants renderer.

		Methods (only one)
			(*SPRenderer) Process(w io.Writer, text []byte)
				Process is the entry point of the Smartypants renderer.

		As Outputs Of (at least one exported)
			func NewSmartypantsRenderer(flags Flags) *SPRenderer


Package-Level Functions (total 20)

	 func AddAbsPrefix(link []byte, prefix string) []byte
	 func BlockAttrs(node ast.Node) []string
		BlockAttrs takes a node and checks if it has block level attributes set. If so it
		will return a slice each containing a "key=value(s)" string.

	 func Escape(w io.Writer, text []byte)
		Escape writes the text to w, but skips the escape character.

	 func EscapeHTML(w io.Writer, d []byte)
		EscapeHTML writes html-escaped d to w. It escapes &, <, > and " characters.

	 func EscLink(w io.Writer, text []byte)
	 func FootnoteItem(prefix string, slug []byte) string
	 func FootnoteRef(prefix string, node *ast.Link) string
	 func FootnoteReturnLink(prefix, returnLink string, slug []byte) string
	 func HeadingCloseTagFromLevel(level int) string
	 func HeadingOpenTagFromLevel(level int) string
	 func IsList(node ast.Node) bool
	 func IsListItem(node ast.Node) bool
	 func IsListItemTerm(node ast.Node) bool
	 func IsListTight(node ast.Node) bool
	 func ListItemOpenCR(listItem *ast.ListItem) bool
	 func NewRenderer(opts RendererOptions) *Renderer
		NewRenderer creates and configures an Renderer object, which
		satisfies the Renderer interface.

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

	 func SkipParagraphTags(para *ast.Paragraph) bool
	 func Slugify(in []byte) []byte
		TODO: move to internal package
		Create a url-safe slug for fragments

	 func TagWithAttributes(name string, attrs []string) string
		TagWithAttributes creates a HTML tag with a given name and attributes


Package-Level Variables (total 2)

	  var Escaper [256][]byte
		Escaper defines how to escape HTML special characters

	  var IDTag string
		IDTag is the tag used for tag identification, it defaults to "id", some renderers
		may wish to override this and use e.g. "anchor".


Package-Level Constants (total 22)

	const CommonFlags Flags = 122880
		HTML renderer configuration options.

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

	const FlagsNone Flags = 0
		HTML renderer configuration options.

	const FootnoteNoHRTag Flags = 4096 // Do not output an HR after starting a footnote list.
		HTML renderer configuration options.

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

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

	const LazyLoadImages Flags = 1048576 // Include loading="lazy" with images
		HTML renderer configuration options.

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

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

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

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

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

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

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

	const Smartypants Flags = 8192 // Enable smart punctuation substitutions
		HTML renderer configuration options.

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

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

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

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

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

	const TOC Flags = 524288 // Generate a table of contents
		HTML renderer configuration options.

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

The pages are generated with Golds v0.8.2. (GOOS=linux 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 @zigo_101 (reachable from the left QR code) to get the latest news of Golds.