Markdown Parser and HTML Renderer for Go

It's very fast, supports common extensions and has a CommonMark mode that passes all 652 examples of the CommonMark 0.31.2 spec.

Tutorial: https://blog.kowalczyk.info/article/cxn3/advanced-markdown-processing-in-go.html

Code examples:

• https://arslexis.io/goplayground/#txO7hJ-ibeU : basic markdown => HTML
• https://arslexis.io/goplayground/#yFRIWRiu-KL : customize HTML renderer
• https://arslexis.io/goplayground/#2yV5-HDKBUV : modify AST
• https://arslexis.io/goplayground/#9fqKwRbuJ04 : customize parser
• https://arslexis.io/goplayground/#Bk0zTvrzUDR : syntax highlight

API Docs:

• https://pkg.go.dev/github.com/gomarkdown/markdown : top level package
• https://pkg.go.dev/github.com/gomarkdown/markdown/ast : defines abstract syntax tree of parsed markdown document
• https://pkg.go.dev/github.com/gomarkdown/markdown/parser : parser
• https://pkg.go.dev/github.com/gomarkdown/markdown/html : html renderer

Usage

To convert markdown text to HTML using reasonable defaults:

package main
import (
	"github.com/gomarkdown/markdown"
	"github.com/gomarkdown/markdown/html"
	"github.com/gomarkdown/markdown/parser"
"fmt"
)
var mds = # header

Sample text.
link

func mdToHTML(md []byte) []byte {
	// create markdown parser with extensions
	extensions := parser.CommonExtensions | parser.AutoHeadingIDs | parser.NoEmptyLineBeforeBlock
	p := parser.NewWithExtensions(extensions)
	doc := p.Parse(md)
// create HTML renderer with extensions
	htmlFlags := html.CommonFlags | html.HrefTargetBlank
	opts := html.RendererOptions{Flags: htmlFlags}
	renderer := html.NewRenderer(opts)
return markdown.Render(doc, renderer)
}
func main() {
	md := []byte(mds)
	html := mdToHTML(md)
fmt.Printf("--- Markdown:\n%s\n\n--- HTML:\n%s\n", md, html)
}

Example source: examples/basic.go

CommonMark

parser.NewCommonMark() creates a parser for the CommonMark 0.31.2 grammar. It's a shortcut for setting the parser.CommonMark flag. All 652 official examples are tested against exact HTML output. The flag is off by default, preserving existing parsing and rendering behavior.

CommonMark mode uses this library's parser and usual ast nodes, so AST traversal, transformation, custom renderers, and HTML rendering hooks remain available. It uses strict CommonMark syntax regardless of the parser's Extensions setting; extensions and custom block/inline parsers apply only when the flag is off. Reference destination and title overrides remain available.

When markdown.ToHTML receives no renderer, CommonMark documents use XHTML tags and no smart punctuation, matching the official examples. To customize rendering, supply an html.Renderer with your own flags.

p := parser.NewCommonMark()
output := markdown.ToHTML([]byte("# Hello\n"), p, nil)

For more documentation, read this guide

Comparing to other markdown parsers: https://babelmark.github.io/

Sanitize untrusted content

We don't protect against malicious content. When dealing with user-provided markdown, run the rendered HTML through an HTML sanitizer such as Bluemonday.

In particular, the parser.Attributes and parser.InlineAttributes extensions let the markdown author set arbitrary HTML attributes such as onclick via {: key="value"}. That is by design, so never enable them for untrusted input, even with html.SkipHTML.

html.Safelink is not a sanitizer. It restricts the URL scheme of links and images, but doesn't check hosts (http://[email protected]/ is allowed) and doesn't affect raw HTML, which is only removed by html.SkipHTML.

Here's an example of simple usage with Bluemonday:

import (
    "github.com/microcosm-cc/bluemonday"
    "github.com/gomarkdown/markdown"
)
// ...
maybeUnsafeHTML := markdown.ToHTML(md, nil, nil)
html := bluemonday.UGCPolicy().SanitizeBytes(maybeUnsafeHTML)

mdtohtml command-line tool

https://github.com/gomarkdown/mdtohtml is a command-line markdown-to-HTML converter built using this library.

You can also use it as an example of how to use the library.

You can install it with:

go get -u github.com/gomarkdown/mdtohtml

To run: mdtohtml input-file [output-file]

Features

• CommonMark compliance. With parser.NewCommonMark(), parsing follows

• Compatibility. The Markdown v1.0.3 test suite passes with

• Common extensions, including table support, fenced code

• Safety. Markdown is paranoid when parsing, making it safe

NOTE: "safety" in this context means _runtime safety only_. In order to protect yourself against JavaScript injection in untrusted content, see this example.

• Fast. It is fast enough to render on-demand in

• Thread safety. You can run multiple parsers in different

• Minimal dependencies. Only depends on standard library packages in Go.

• Standards compliant. Output successfully validates using the

Extensions

In addition to the standard markdown syntax, this package implements the following extensions:

• Intra-word emphasis suppression. The _ character is

• Tables. Tables can be created by drawing them in the input

Name    | Age
  --------|------
  Bob     | 27
  Alice   | 23

Table footers are supported as well and can be added with equal signs (=):

Name    | Age
  --------|------
  Bob     | 27
  Alice   | 23
  ========|======
  Total   | 50

A cell spanning multiple columns (colspan) is supported; just repeat the pipe symbol:

Name    | Age
  --------|------
  Bob     ||
  Alice   | 23
  ========|======
  Total   | 23

A pipe inside a code span does not end the cell, so ` a|b is one cell. Elsewhere, write a literal pipe as \|. This differs from GitHub, where a pipe always ends the cell and \| is the only way to include one; a \| inside a code span is left as written here rather than unescaped.

func getTrue() bool {
          return true
      }

• Strikethrough. Use two tildes (~~) to mark text that

• LaTeX-style dash parsing is an additional option, where --

$$
  \left[ \begin{array}{a} a^l_1 \\ ⋮ \\ a^l_{d_l} \end{array}\right]
  = \sigma(
   \left[ \begin{matrix}
   	w^l_{1,1} & ⋯  & w^l_{1,d_{l-1}} \\
   	⋮ & ⋱  & ⋮  \\
   	w^l_{d_l,1} & ⋯  & w^l_{d_l,d_{l-1}} \\
   \end{matrix}\right]  ·
   \left[ \begin{array}{x} a^{l-1}_1 \\ ⋮ \\ ⋮ \\ a^{l-1}_{d_{l-1}} \end{array}\right] +
   \left[ \begin{array}{b} b^l_1 \\ ⋮ \\ b^l_{d_l} \end{array}\right])
   $$

• Super- and subscript. With this extension enabled, text between ^ is

{#id3 .myclass fontsize="tiny"}
  # Header 1

Will convert into

Header 1

Users

Some tools using this package: https://pkg.go.dev/github.com/gomarkdown/markdown?tab=importedby

History

markdown is a fork of v2 of https://github.com/russross/blackfriday.

I refactored the API (split into ast/parser/html sub-packages).

Blackfriday itself was based on the C implementation sundown, which in turn was based on libsoldout.

License

Simplified BSD License