//

// Blackfriday Markdown Processor

// Available at http://github.com/russross/blackfriday

//

// Copyright © 2011 Russ Ross <russ@russross.com>.

// Distributed under the Simplified BSD License.

// See README.md for details.

//

//

//

// Markdown parsing and processing

//

//

package blackfriday

import (

	"bytes"

	"fmt"

	"strings"

	"unicode/utf8"

)

const VERSION = "1.5"

// These are the supported markdown parsing extensions.

// OR these values together to select multiple extensions.

const (

	EXTENSION_NO_INTRA_EMPHASIS          = 1 << iota // ignore emphasis markers inside words

	EXTENSION_TABLES                                 // render tables

	EXTENSION_FENCED_CODE                            // render fenced code blocks

	EXTENSION_AUTOLINK                               // detect embedded URLs that are not explicitly marked

	EXTENSION_STRIKETHROUGH                          // strikethrough text using ~~test~~

	EXTENSION_LAX_HTML_BLOCKS                        // loosen up HTML block parsing rules

	EXTENSION_SPACE_HEADERS                          // be strict about prefix header rules

	EXTENSION_HARD_LINE_BREAK                        // translate newlines into line breaks

	EXTENSION_TAB_SIZE_EIGHT                         // expand tabs to eight spaces instead of four

	EXTENSION_FOOTNOTES                              // Pandoc-style footnotes

	EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK             // No need to insert an empty line to start a (code, quote, ordered list, unordered list) block

	EXTENSION_HEADER_IDS                             // specify header IDs  with {#id}

	EXTENSION_TITLEBLOCK                             // Titleblock ala pandoc

	EXTENSION_AUTO_HEADER_IDS                        // Create the header ID from the text

	EXTENSION_BACKSLASH_LINE_BREAK                   // translate trailing backslashes into line breaks

	EXTENSION_DEFINITION_LISTS                       // render definition lists

	EXTENSION_JOIN_LINES                             // delete newline and join lines

	commonHtmlFlags = 0 |

		HTML_USE_XHTML |

		HTML_USE_SMARTYPANTS |

		HTML_SMARTYPANTS_FRACTIONS |

		HTML_SMARTYPANTS_DASHES |

		HTML_SMARTYPANTS_LATEX_DASHES

	commonExtensions = 0 |

		EXTENSION_NO_INTRA_EMPHASIS |

		EXTENSION_TABLES |

		EXTENSION_FENCED_CODE |

		EXTENSION_AUTOLINK |

		EXTENSION_STRIKETHROUGH |

		EXTENSION_SPACE_HEADERS |

		EXTENSION_HEADER_IDS |

		EXTENSION_BACKSLASH_LINE_BREAK |

		EXTENSION_DEFINITION_LISTS

)

// These are the possible flag values for the link 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 (

	LINK_TYPE_NOT_AUTOLINK = iota

	LINK_TYPE_NORMAL

	LINK_TYPE_EMAIL

)

// 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 (

	LIST_TYPE_ORDERED = 1 << iota

	LIST_TYPE_DEFINITION

	LIST_TYPE_TERM

	LIST_ITEM_CONTAINS_BLOCK

	LIST_ITEM_BEGINNING_OF_LIST

	LIST_ITEM_END_OF_LIST

)

// 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 (

	TABLE_ALIGNMENT_LEFT = 1 << iota

	TABLE_ALIGNMENT_RIGHT

	TABLE_ALIGNMENT_CENTER = (TABLE_ALIGNMENT_LEFT | TABLE_ALIGNMENT_RIGHT)

)

// The size of a tab stop.

const (

	TAB_SIZE_DEFAULT = 4

	TAB_SIZE_EIGHT   = 8

)

// 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 blockTags = map[string]struct{}{

	"blockquote": {},

	"del":        {},

	"div":        {},

	"dl":         {},

	"fieldset":   {},

	"form":       {},

	"h1":         {},

	"h2":         {},

	"h3":         {},

	"h4":         {},

	"h5":         {},

	"h6":         {},

	"iframe":     {},

	"ins":        {},

	"math":       {},

	"noscript":   {},

	"ol":         {},

	"pre":        {},

	"p":          {},

	"script":     {},

	"style":      {},

	"table":      {},

	"ul":         {},

	// HTML5

	"address":    {},

	"article":    {},

	"aside":      {},

	"canvas":     {},

	"figcaption": {},

	"figure":     {},

	"footer":     {},

	"header":     {},

	"hgroup":     {},

	"main":       {},

	"nav":        {},

	"output":     {},

	"progress":   {},

	"section":    {},

	"video":      {},

}

// Renderer is the rendering interface.

// This is mostly of interest if you are implementing a new rendering format.

//

// When a byte slice is provided, it contains the (rendered) contents of the

// element.

//

// When a callback is provided instead, it will write the contents of the

// respective element directly to the output buffer and return true on success.

// If the callback returns false, the rendering function should reset the

// output buffer as though it had never been called.

//

// Currently Html and Latex implementations are provided

type Renderer interface {

	// block-level callbacks

	BlockCode(out *bytes.Buffer, text []byte, infoString string)

	BlockQuote(out *bytes.Buffer, text []byte)

	BlockHtml(out *bytes.Buffer, text []byte)

	Header(out *bytes.Buffer, text func() bool, level int, id string)

	HRule(out *bytes.Buffer)

	List(out *bytes.Buffer, text func() bool, flags int)

	ListItem(out *bytes.Buffer, text []byte, flags int)

	Paragraph(out *bytes.Buffer, text func() bool)

	Table(out *bytes.Buffer, header []byte, body []byte, columnData []int)

	TableRow(out *bytes.Buffer, text []byte)

	TableHeaderCell(out *bytes.Buffer, text []byte, flags int)

	TableCell(out *bytes.Buffer, text []byte, flags int)

	Footnotes(out *bytes.Buffer, text func() bool)

	FootnoteItem(out *bytes.Buffer, name, text []byte, flags int)

	TitleBlock(out *bytes.Buffer, text []byte)

	// Span-level callbacks

	AutoLink(out *bytes.Buffer, link []byte, kind int)

	CodeSpan(out *bytes.Buffer, text []byte)

	DoubleEmphasis(out *bytes.Buffer, text []byte)

	Emphasis(out *bytes.Buffer, text []byte)

	Image(out *bytes.Buffer, link []byte, title []byte, alt []byte)

	LineBreak(out *bytes.Buffer)

	Link(out *bytes.Buffer, link []byte, title []byte, content []byte)

	RawHtmlTag(out *bytes.Buffer, tag []byte)

	TripleEmphasis(out *bytes.Buffer, text []byte)

	StrikeThrough(out *bytes.Buffer, text []byte)

	FootnoteRef(out *bytes.Buffer, ref []byte, id int)

	// Low-level callbacks

	Entity(out *bytes.Buffer, entity []byte)

	NormalText(out *bytes.Buffer, text []byte)

	// Header and footer

	DocumentHeader(out *bytes.Buffer)

	DocumentFooter(out *bytes.Buffer)

	GetFlags() int

}

// Callback functions for inline parsing. One such function is defined

// for each character that triggers a response when parsing inline data.

type inlineParser func(p *parser, out *bytes.Buffer, data []byte, offset int) int

// Parser holds runtime state used by the parser.

// This is constructed by the Markdown function.

type parser struct {

	r              Renderer

	refOverride    ReferenceOverrideFunc

	refs           map[string]*reference

	inlineCallback [256]inlineParser

	flags          int

	nesting        int

	maxNesting     int

	insideLink     bool

	// 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.

	notes       []*reference

	notesRecord map[string]struct{}

}

func (p *parser) getRef(refid string) (ref *reference, found bool) {

	if p.refOverride != nil {

		r, overridden := p.refOverride(refid)

		if overridden {

			if r == nil {

				return nil, false

			}

			return &reference{

				link:     []byte(r.Link),

				title:    []byte(r.Title),

				noteId:   0,

				hasBlock: false,

				text:     []byte(r.Text)}, true

		}

	}

	// refs are case insensitive

	ref, found = p.refs[strings.ToLower(refid)]

	return ref, found

}

func (p *parser) isFootnote(ref *reference) bool {

	_, ok := p.notesRecord[string(ref.link)]

	return ok

}

//

//

// Public interface

//

//

// Reference represents the details of a link.

// See the documentation in Options for more details on use-case.

type Reference struct {

	// Link is usually the URL the reference points to.

	Link string

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

	Title string

	// Text is the optional text to override the ref with if the syntax used was

	// [refid][]

	Text string

}

// 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.

type ReferenceOverrideFunc func(reference string) (ref *Reference, overridden bool)

// Options represents configurable overrides and callbacks (in addition to the

// extension flag set) for configuring a Markdown parse.

type Options struct {

	// Extensions is a flag set of bit-wise ORed extension bits. See the

	// EXTENSION_* flags defined in this package.

	Extensions int

	// ReferenceOverride is 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.

	ReferenceOverride ReferenceOverrideFunc

}

// MarkdownBasic is a convenience function for simple rendering.

// It processes markdown input with no extensions enabled.

func MarkdownBasic(input []byte) []byte {

	// set up the HTML renderer

	htmlFlags := HTML_USE_XHTML

	renderer := HtmlRenderer(htmlFlags, "", "")

	// set up the parser

	return MarkdownOptions(input, renderer, Options{Extensions: 0})

}

// Call Markdown with most useful extensions enabled

// MarkdownCommon is a convenience function for simple rendering.

// It processes markdown input with common extensions enabled, including:

//

// * Smartypants processing with smart fractions and LaTeX dashes

//

// * Intra-word emphasis suppression

//

// * Tables

//

// * Fenced code blocks

//

// * Autolinking

//

// * Strikethrough support

//

// * Strict header parsing

//

// * Custom Header IDs

func MarkdownCommon(input []byte) []byte {

	// set up the HTML renderer

	renderer := HtmlRenderer(commonHtmlFlags, "", "")

	return MarkdownOptions(input, renderer, Options{

		Extensions: commonExtensions})

}

// Markdown is the main rendering function.

// It parses and renders a block of markdown-encoded text.

// The supplied Renderer is used to format the output, and extensions dictates

// which non-standard extensions are enabled.

//

// To use the supplied Html or LaTeX renderers, see HtmlRenderer and

// LatexRenderer, respectively.

func Markdown(input []byte, renderer Renderer, extensions int) []byte {

	return MarkdownOptions(input, renderer, Options{

		Extensions: extensions})

}

// MarkdownOptions is just like Markdown but takes additional options through

// the Options struct.

func MarkdownOptions(input []byte, renderer Renderer, opts Options) []byte {

	// no point in parsing if we can't render

	if renderer == nil {

		return nil

	}

	extensions := opts.Extensions

	// fill in the render structure

	p := new(parser)

	p.r = renderer

	p.flags = extensions

	p.refOverride = opts.ReferenceOverride

	p.refs = make(map[string]*reference)

	p.maxNesting = 16

	p.insideLink = false

	// register inline parsers

	p.inlineCallback['*'] = emphasis

	p.inlineCallback['_'] = emphasis

	if extensions&EXTENSION_STRIKETHROUGH != 0 {

		p.inlineCallback['~'] = emphasis

	}

	p.inlineCallback['`'] = codeSpan

	p.inlineCallback['\n'] = lineBreak

	p.inlineCallback['['] = link

	p.inlineCallback['<'] = leftAngle

	p.inlineCallback['\\'] = escape

	p.inlineCallback['&'] = entity

	if extensions&EXTENSION_AUTOLINK != 0 {

		p.inlineCallback[':'] = autoLink

	}

	if extensions&EXTENSION_FOOTNOTES != 0 {

		p.notes = make([]*reference, 0)

		p.notesRecord = make(map[string]struct{})

	}

	first := firstPass(p, input)

	second := secondPass(p, first)

	return second

}

// first pass:

// - normalize newlines

// - extract references (outside of fenced code blocks)

// - expand tabs (outside of fenced code blocks)

// - copy everything else

func firstPass(p *parser, input []byte) []byte {

	var out bytes.Buffer

	tabSize := TAB_SIZE_DEFAULT

	if p.flags&EXTENSION_TAB_SIZE_EIGHT != 0 {

		tabSize = TAB_SIZE_EIGHT

	}

	beg := 0

	lastFencedCodeBlockEnd := 0

	for beg < len(input) {

		// Find end of this line, then process the line.

		end := beg

		for end < len(input) && input[end] != '\n' && input[end] != '\r' {

			end++

		}

		if p.flags&EXTENSION_FENCED_CODE != 0 {

			// track fenced code block boundaries to suppress tab expansion

			// and reference extraction inside them:

			if beg >= lastFencedCodeBlockEnd {

				if i := p.fencedCodeBlock(&out, input[beg:], false); i > 0 {

					lastFencedCodeBlockEnd = beg + i

				}

			}

		}

		// add the line body if present

		if end > beg {

			if end < lastFencedCodeBlockEnd { // Do not expand tabs while inside fenced code blocks.

				out.Write(input[beg:end])

			} else if refEnd := isReference(p, input[beg:], tabSize); refEnd > 0 {

				beg += refEnd