Source: block.go in package github.com/russross/blackfriday/v2

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.

Functions to parse block-level elements.


package blackfriday

import (
	"bytes"
	"html"
	"regexp"
	"strings"

	"github.com/shurcooL/sanitized_anchor_name"
)

const (
	charEntity = "&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});"
	escapable  = "[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]"
)

var (
	reBackslashOrAmp      = regexp.MustCompile("[\\&]")
	reEntityOrEscapedChar = regexp.MustCompile("(?i)\\\\" + escapable + "|" + charEntity)
)

Parse block-level data. Note: this function and many that it calls assume that the input buffer ends with a newline.

this is called recursively: enforce a maximum depth

	if p.nesting >= p.maxNesting {
		return
	}
	p.nesting++

parse out one block-level construct at a time

prefixed heading: # Heading 1 ## Heading 2 ... ###### Heading 6

		if p.isPrefixHeading(data) {
			data = data[p.prefixHeading(data):]
			continue
		}

block of preformatted HTML: <div> ... </div>

		if data[0] == '<' {
			if i := p.html(data, true); i > 0 {
				data = data[i:]
				continue
			}
		}

title block % stuff % more stuff % even more stuff

		if p.extensions&Titleblock != 0 {
			if data[0] == '%' {
				if i := p.titleBlock(data, true); i > 0 {
					data = data[i:]
					continue
				}
			}
		}

blank lines. note: returns the # of bytes to skip

		if i := p.isEmpty(data); i > 0 {
			data = data[i:]
			continue
		}

indented code block: func max(a, b int) int { if a > b { return a } return b }

		if p.codePrefix(data) > 0 {
			data = data[p.code(data):]
			continue
		}

fenced code block: ``` go func fact(n int) int { if n <= 1 { return n } return n * fact(n-1) } ```

		if p.extensions&FencedCode != 0 {
			if i := p.fencedCodeBlock(data, true); i > 0 {
				data = data[i:]
				continue
			}
		}

horizontal rule: ------ or ****** or ______

		if p.isHRule(data) {
			p.addBlock(HorizontalRule, nil)
			var i int
			for i = 0; i < len(data) && data[i] != '\n'; i++ {
			}
			data = data[i:]
			continue
		}

block quote: > A big quote I found somewhere > on the web

		if p.quotePrefix(data) > 0 {
			data = data[p.quote(data):]
			continue
		}

table: Name | Age | Phone ------|-----|--------- Bob | 31 | 555-1234 Alice | 27 | 555-4321

		if p.extensions&Tables != 0 {
			if i := p.table(data); i > 0 {
				data = data[i:]
				continue
			}
		}

an itemized/unordered list: * Item 1 * Item 2 also works with + or -

		if p.uliPrefix(data) > 0 {
			data = data[p.list(data, 0):]
			continue
		}

a numbered/ordered list: 1. Item 1 2. Item 2

		if p.oliPrefix(data) > 0 {
			data = data[p.list(data, ListTypeOrdered):]
			continue
		}

definition lists: Term 1 : Definition a : Definition b Term 2 : Definition c

		if p.extensions&DefinitionLists != 0 {
			if p.dliPrefix(data) > 0 {
				data = data[p.list(data, ListTypeDefinition):]
				continue
			}
		}

anything else must look like a normal paragraph note: this finds underlined headings, too

		data = data[p.paragraph(data):]
	}

	p.nesting--
}

func (p *Markdown) addBlock(typ NodeType, content []byte) *Node {
	p.closeUnmatchedBlocks()
	container := p.addChild(typ, 0)
	container.content = content
	return container
}

func (p *Markdown) isPrefixHeading(data []byte) bool {
	if data[0] != '#' {
		return false
	}

	if p.extensions&SpaceHeadings != 0 {
		level := 0
		for level < 6 && level < len(data) && data[level] == '#' {
			level++
		}
		if level == len(data) || data[level] != ' ' {
			return false
		}
	}
	return true
}

func (p *Markdown) prefixHeading(data []byte) int {
	level := 0
	for level < 6 && level < len(data) && data[level] == '#' {
		level++
	}
	i := skipChar(data, level, ' ')
	end := skipUntilChar(data, i, '\n')
	skip := end
	id := ""
	if p.extensions&HeadingIDs != 0 {

find start/end of heading id

		for j = i; j < end-1 && (data[j] != '{' || data[j+1] != '#'); j++ {
		}
		for k = j + 1; k < end && data[k] != '}'; k++ {

extract heading id iff found

		if j < end && k < end {
			id = string(data[j+2 : k])
			end = j
			skip = k + 1
			for end > 0 && data[end-1] == ' ' {
				end--
			}
		}
	}
	for end > 0 && data[end-1] == '#' {
		if isBackslashEscaped(data, end-1) {
			break
		}
		end--
	}
	for end > 0 && data[end-1] == ' ' {
		end--
	}
	if end > i {
		if id == "" && p.extensions&AutoHeadingIDs != 0 {
			id = sanitized_anchor_name.Create(string(data[i:end]))
		}
		block := p.addBlock(Heading, data[i:end])
		block.HeadingID = id
		block.Level = level
	}
	return skip
}

test of level 1 heading

	if data[0] == '=' {
		i := skipChar(data, 1, '=')
		i = skipChar(data, i, ' ')
		if i < len(data) && data[i] == '\n' {
			return 1
		}
		return 0
	}

test of level 2 heading

	if data[0] == '-' {
		i := skipChar(data, 1, '-')
		i = skipChar(data, i, ' ')
		if i < len(data) && data[i] == '\n' {
			return 2
		}
		return 0
	}

	return 0
}

func (p *Markdown) titleBlock(data []byte, doRender bool) int {
	if data[0] != '%' {
		return 0
	}
	splitData := bytes.Split(data, []byte("\n"))
	var i int
	for idx, b := range splitData {
		if !bytes.HasPrefix(b, []byte("%")) {
			i = idx // - 1
			break
		}
	}

	data = bytes.Join(splitData[0:i], []byte("\n"))
	consumed := len(data)
	data = bytes.TrimPrefix(data, []byte("% "))
	data = bytes.Replace(data, []byte("\n% "), []byte("\n"), -1)
	block := p.addBlock(Heading, data)
	block.Level = 1
	block.IsTitleblock = true

	return consumed
}

func (p *Markdown) html(data []byte, doRender bool) int {
	var i, j int

identify the opening tag

	if data[0] != '<' {
		return 0
	}
	curtag, tagfound := p.htmlFindTag(data[1:])

handle special cases

check for an HTML comment

		if size := p.htmlComment(data, doRender); size > 0 {
			return size
		}

check for an <hr> tag

		if size := p.htmlHr(data, doRender); size > 0 {
			return size
		}

no special case recognized

		return 0
	}

look for an unindented matching closing tag followed by a blank line

closetag := []byte("\n</" + curtag + ">") j = len(curtag) + 1 for !found { scan for a closing tag at the beginning of a line if skip := bytes.Index(data[j:], closetag); skip >= 0 { j += skip + len(closetag) } else { break }

see if it is the only thing on the line if skip := p.isEmpty(data[j:]); skip > 0 { see if it is followed by a blank line/eof j += skip if j >= len(data) { found = true i = j } else { if skip := p.isEmpty(data[j:]); skip > 0 { j += skip found = true i = j } } } }

if not found, try a second pass looking for indented match but not if tag is "ins" or "del" (following original Markdown.pl)

	if !found && curtag != "ins" && curtag != "del" {
		i = 1
		for i < len(data) {
			i++
			for i < len(data) && !(data[i-1] == '<' && data[i] == '/') {
				i++
			}

			if i+2+len(curtag) >= len(data) {
				break
			}

			j = p.htmlFindEnd(curtag, data[i-1:])

			if j > 0 {
				i += j - 1
				found = true
				break
			}
		}
	}

	if !found {
		return 0
	}

the end of the block has been found

trim newlines

		end := i
		for end > 0 && data[end-1] == '\n' {
			end--
		}
		finalizeHTMLBlock(p.addBlock(HTMLBlock, data[:end]))
	}

	return i
}

func finalizeHTMLBlock(block *Node) {
	block.Literal = block.content
	block.content = nil
}

HTML comment, lax form

func (p *Markdown) htmlComment(data []byte, doRender bool) int {

needs to end with a blank line

	if j := p.isEmpty(data[i:]); j > 0 {
		size := i + j

trim trailing newlines

			end := size
			for end > 0 && data[end-1] == '\n' {
				end--
			}
			block := p.addBlock(HTMLBlock, data[:end])
			finalizeHTMLBlock(block)
		}
		return size
	}
	return 0
}

HR, which is the only self-closing block tag considered

func (p *Markdown) htmlHr(data []byte, doRender bool) int {
	if len(data) < 4 {
		return 0
	}
	if data[0] != '<' || (data[1] != 'h' && data[1] != 'H') || (data[2] != 'r' && data[2] != 'R') {
		return 0
	}

not an <hr> tag after all; at least not a valid one

		return 0
	}
	i := 3
	for i < len(data) && data[i] != '>' && data[i] != '\n' {
		i++
	}
	if i < len(data) && data[i] == '>' {
		i++
		if j := p.isEmpty(data[i:]); j > 0 {
			size := i + j

trim newlines

				end := size
				for end > 0 && data[end-1] == '\n' {
					end--
				}
				finalizeHTMLBlock(p.addBlock(HTMLBlock, data[:end]))
			}
			return size
		}
	}
	return 0
}

func (p *Markdown) htmlFindTag(data []byte) (string, bool) {
	i := 0
	for i < len(data) && isalnum(data[i]) {
		i++
	}
	key := string(data[:i])
	if _, ok := blockTags[key]; ok {
		return key, true
	}
	return "", false
}

assume data[0] == '<' && data[1] == '/' already tested

	if tag == "hr" {
		return 2

check if tag is a match

	closetag := []byte("</" + tag + ">")
	if !bytes.HasPrefix(data, closetag) {
		return 0
	}
	i := len(closetag)

check that the rest of the line is blank

	skip := 0
	if skip = p.isEmpty(data[i:]); skip == 0 {
		return 0
	}
	i += skip
	skip = 0

	if i >= len(data) {
		return i
	}

	if p.extensions&LaxHTMLBlocks != 0 {
		return i
	}

following line must be blank

		return 0
	}

	return i + skip
}

it is okay to call isEmpty on an empty buffer

	if len(data) == 0 {
		return 0
	}

	var i int
	for i = 0; i < len(data) && data[i] != '\n'; i++ {
		if data[i] != ' ' && data[i] != '\t' {
			return 0
		}
	}
	if i < len(data) && data[i] == '\n' {
		i++
	}
	return i
}

func (*Markdown) isHRule(data []byte) bool {
	i := 0

skip up to three spaces

	for i < 3 && data[i] == ' ' {
		i++
	}

look at the hrule char

	if data[i] != '*' && data[i] != '-' && data[i] != '_' {
		return false
	}
	c := data[i]

the whole line must be the char or whitespace

	n := 0
	for i < len(data) && data[i] != '\n' {
		switch {
		case data[i] == c:
			n++
		case data[i] != ' ':
			return false
		}
		i++
	}

	return n >= 3
}

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 isFenceLine(data []byte, info *string, oldmarker string) (end int, marker string) {
	i, size := 0, 0

skip up to three spaces

	for i < len(data) && i < 3 && data[i] == ' ' {
		i++
	}

check for the marker characters: ~ or `

	if i >= len(data) {
		return 0, ""
	}
	if data[i] != '~' && data[i] != '`' {
		return 0, ""
	}

	c := data[i]

the whole line must be the same char or whitespace

	for i < len(data) && data[i] == c {
		size++
		i++
	}

the marker char must occur at least 3 times

	if size < 3 {
		return 0, ""
	}
	marker = string(data[i-size : i])

if this is the end marker, it must match the beginning marker

	if oldmarker != "" && marker != oldmarker {
		return 0, ""
	}

TODO(shurcooL): It's probably a good idea to simplify the 2 code paths here into one, always get the info string, and discard it if the caller doesn't care.

	if info != nil {
		infoLength := 0
		i = skipChar(data, i, ' ')

		if i >= len(data) {
			if i == len(data) {
				return i, marker
			}
			return 0, ""
		}

		infoStart := i

		if data[i] == '{' {
			i++
			infoStart++

			for i < len(data) && data[i] != '}' && data[i] != '\n' {
				infoLength++
				i++
			}

			if i >= len(data) || data[i] != '}' {
				return 0, ""
			}

strip all whitespace at the beginning and the end of the {} block

			for infoLength > 0 && isspace(data[infoStart]) {
				infoStart++
				infoLength--
			}

			for infoLength > 0 && isspace(data[infoStart+infoLength-1]) {
				infoLength--
			}
			i++
			i = skipChar(data, i, ' ')
		} else {
			for i < len(data) && !isverticalspace(data[i]) {
				infoLength++
				i++
			}
		}

		*info = strings.TrimSpace(string(data[infoStart : infoStart+infoLength]))
	}

	if i == len(data) {
		return i, marker
	}
	if i > len(data) || data[i] != '\n' {
		return 0, ""
	}
	return i + 1, marker // Take newline into account.
}

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.

func (p *Markdown) fencedCodeBlock(data []byte, doRender bool) int {
	var info string
	beg, marker := isFenceLine(data, &info, "")
	if beg == 0 || beg >= len(data) {
		return 0
	}

	var work bytes.Buffer
	work.Write([]byte(info))
	work.WriteByte('\n')

safe to assume beg < len(data)

check for the end of the code block

		fenceEnd, _ := isFenceLine(data[beg:], nil, marker)
		if fenceEnd != 0 {
			beg += fenceEnd
			break
		}

copy the current line

		end := skipUntilChar(data, beg, '\n') + 1

did we reach the end of the buffer without a closing marker?

		if end >= len(data) {
			return 0
		}

verbatim copy to the working buffer

		if doRender {
			work.Write(data[beg:end])
		}
		beg = end
	}

	if doRender {
		block := p.addBlock(CodeBlock, work.Bytes()) // TODO: get rid of temp buffer
		block.IsFenced = true
		finalizeCodeBlock(block)
	}

	return beg
}

func unescapeChar(str []byte) []byte {
	if str[0] == '\\' {
		return []byte{str[1]}
	}
	return []byte(html.UnescapeString(string(str)))
}

func unescapeString(str []byte) []byte {
	if reBackslashOrAmp.Match(str) {
		return reEntityOrEscapedChar.ReplaceAllFunc(str, unescapeChar)
	}
	return str
}

func finalizeCodeBlock(block *Node) {
	if block.IsFenced {
		newlinePos := bytes.IndexByte(block.content, '\n')
		firstLine := block.content[:newlinePos]
		rest := block.content[newlinePos+1:]
		block.Info = unescapeString(bytes.Trim(firstLine, "\n"))
		block.Literal = rest
	} else {
		block.Literal = block.content
	}
	block.content = nil
}

func (p *Markdown) table(data []byte) int {
	table := p.addBlock(Table, nil)
	i, columns := p.tableHeader(data)
	if i == 0 {
		p.tip = table.Parent
		table.Unlink()
		return 0
	}

	p.addBlock(TableBody, nil)

	for i < len(data) {
		pipes, rowStart := 0, i
		for ; i < len(data) && data[i] != '\n'; i++ {
			if data[i] == '|' {
				pipes++
			}
		}

		if pipes == 0 {
			i = rowStart
			break
		}

include the newline in data sent to tableRow

		if i < len(data) && data[i] == '\n' {
			i++
		}
		p.tableRow(data[rowStart:i], columns, false)
	}

	return i
}

check if the specified position is preceded by an odd number of backslashes

func isBackslashEscaped(data []byte, i int) bool {
	backslashes := 0
	for i-backslashes-1 >= 0 && data[i-backslashes-1] == '\\' {
		backslashes++
	}
	return backslashes&1 == 1
}

func (p *Markdown) tableHeader(data []byte) (size int, columns []CellAlignFlags) {
	i := 0
	colCount := 1
	for i = 0; i < len(data) && data[i] != '\n'; i++ {
		if data[i] == '|' && !isBackslashEscaped(data, i) {
			colCount++
		}
	}

doesn't look like a table header

	if colCount == 1 {
		return
	}

include the newline in the data sent to tableRow

	j := i
	if j < len(data) && data[j] == '\n' {
		j++
	}
	header := data[:j]

column count ignores pipes at beginning or end of line

	if data[0] == '|' {
		colCount--
	}
	if i > 2 && data[i-1] == '|' && !isBackslashEscaped(data, i-1) {
		colCount--
	}

	columns = make([]CellAlignFlags, colCount)

move on to the header underline

	i++
	if i >= len(data) {
		return
	}

	if data[i] == '|' && !isBackslashEscaped(data, i) {
		i++
	}
	i = skipChar(data, i, ' ')

each column header is of form: / *:?-+:? *|/ with # dashes + # colons >= 3 and trailing | optional on last column

	col := 0
	for i < len(data) && data[i] != '\n' {
		dashes := 0

		if data[i] == ':' {
			i++
			columns[col] |= TableAlignmentLeft
			dashes++
		}
		for i < len(data) && data[i] == '-' {
			i++
			dashes++
		}
		if i < len(data) && data[i] == ':' {
			i++
			columns[col] |= TableAlignmentRight
			dashes++
		}
		for i < len(data) && data[i] == ' ' {
			i++
		}
		if i == len(data) {
			return

end of column test is messy

		switch {

not a valid column

			return

marker found, now skip past trailing whitespace

			col++
			i++
			for i < len(data) && data[i] == ' ' {
				i++
			}

trailing junk found after last column

			if col >= colCount && i < len(data) && data[i] != '\n' {
				return
			}

something else found where marker was required

			return

marker is optional for the last column

			col++

trailing junk found after last column

			return
		}
	}
	if col != colCount {
		return
	}

	p.addBlock(TableHead, nil)
	p.tableRow(header, columns, true)
	size = i
	if size < len(data) && data[size] == '\n' {
		size++
	}
	return
}

func (p *Markdown) tableRow(data []byte, columns []CellAlignFlags, header bool) {
	p.addBlock(TableRow, nil)
	i, col := 0, 0

	if data[i] == '|' && !isBackslashEscaped(data, i) {
		i++
	}

	for col = 0; col < len(columns) && i < len(data); col++ {
		for i < len(data) && data[i] == ' ' {
			i++
		}

		cellStart := i

		for i < len(data) && (data[i] != '|' || isBackslashEscaped(data, i)) && data[i] != '\n' {
			i++
		}

		cellEnd := i

skip the end-of-cell marker, possibly taking us past end of buffer

		i++

		for cellEnd > cellStart && cellEnd-1 < len(data) && data[cellEnd-1] == ' ' {
			cellEnd--
		}

		cell := p.addBlock(TableCell, data[cellStart:cellEnd])
		cell.IsHeader = header
		cell.Align = columns[col]
	}

pad it out with empty columns to get the right number

	for ; col < len(columns); col++ {
		cell := p.addBlock(TableCell, nil)
		cell.IsHeader = header
		cell.Align = columns[col]
	}

silently ignore rows with too many cells

returns blockquote prefix length

func (p *Markdown) quotePrefix(data []byte) int {
	i := 0
	for i < 3 && i < len(data) && data[i] == ' ' {
		i++
	}
	if i < len(data) && data[i] == '>' {
		if i+1 < len(data) && data[i+1] == ' ' {
			return i + 2
		}
		return i + 1
	}
	return 0
}

blockquote ends with at least one blank line followed by something without a blockquote prefix

func (p *Markdown) terminateBlockquote(data []byte, beg, end int) bool {
	if p.isEmpty(data[beg:]) <= 0 {
		return false
	}
	if end >= len(data) {
		return true
	}
	return p.quotePrefix(data[end:]) == 0 && p.isEmpty(data[end:]) == 0
}

parse a blockquote fragment

func (p *Markdown) quote(data []byte) int {
	block := p.addBlock(BlockQuote, nil)
	var raw bytes.Buffer
	beg, end := 0, 0
	for beg < len(data) {

Step over whole lines, collecting them. While doing that, check for fenced code and if one's found, incorporate it altogether, irregardless of any contents inside it

		for end < len(data) && data[end] != '\n' {
			if p.extensions&FencedCode != 0 {

-1 to compensate for the extra end++ after the loop:

					end += i - 1
					break
				}
			}
			end++
		}
		if end < len(data) && data[end] == '\n' {
			end++
		}

skip the prefix

			beg += pre
		} else if p.terminateBlockquote(data, beg, end) {
			break

this line is part of the blockquote

		raw.Write(data[beg:end])
		beg = end
	}
	p.block(raw.Bytes())
	p.finalize(block)
	return end
}

returns prefix length for block code

func (p *Markdown) codePrefix(data []byte) int {
	if len(data) >= 1 && data[0] == '\t' {
		return 1
	}
	if len(data) >= 4 && data[0] == ' ' && data[1] == ' ' && data[2] == ' ' && data[3] == ' ' {
		return 4
	}
	return 0
}

func (p *Markdown) code(data []byte) int {
	var work bytes.Buffer

	i := 0
	for i < len(data) {
		beg := i
		for i < len(data) && data[i] != '\n' {
			i++
		}
		if i < len(data) && data[i] == '\n' {
			i++
		}

		blankline := p.isEmpty(data[beg:i]) > 0
		if pre := p.codePrefix(data[beg:i]); pre > 0 {
			beg += pre

non-empty, non-prefixed line breaks the pre

			i = beg
			break
		}

verbatim copy to the working buffer

		if blankline {
			work.WriteByte('\n')
		} else {
			work.Write(data[beg:i])
		}
	}

trim all the \n off the end of work

	workbytes := work.Bytes()
	eol := len(workbytes)
	for eol > 0 && workbytes[eol-1] == '\n' {
		eol--
	}
	if eol != len(workbytes) {
		work.Truncate(eol)
	}

	work.WriteByte('\n')

	block := p.addBlock(CodeBlock, work.Bytes()) // TODO: get rid of temp buffer
	block.IsFenced = false
	finalizeCodeBlock(block)

	return i
}

returns unordered list item prefix

func (p *Markdown) uliPrefix(data []byte) int {

start with up to 3 spaces

	for i < len(data) && i < 3 && data[i] == ' ' {
		i++
	}
	if i >= len(data)-1 {
		return 0

need one of {'*', '+', '-'} followed by a space or a tab

	if (data[i] != '*' && data[i] != '+' && data[i] != '-') ||
		(data[i+1] != ' ' && data[i+1] != '\t') {
		return 0
	}
	return i + 2
}

returns ordered list item prefix

func (p *Markdown) oliPrefix(data []byte) int {
	i := 0

start with up to 3 spaces

	for i < 3 && i < len(data) && data[i] == ' ' {
		i++
	}

count the digits

	start := i
	for i < len(data) && data[i] >= '0' && data[i] <= '9' {
		i++
	}
	if start == i || i >= len(data)-1 {
		return 0
	}

we need >= 1 digits followed by a dot and a space or a tab

	if data[i] != '.' || !(data[i+1] == ' ' || data[i+1] == '\t') {
		return 0
	}
	return i + 2
}

returns definition list item prefix

func (p *Markdown) dliPrefix(data []byte) int {
	if len(data) < 2 {
		return 0
	}

need a ':' followed by a space or a tab

	if data[i] != ':' || !(data[i+1] == ' ' || data[i+1] == '\t') {
		return 0
	}
	for i < len(data) && data[i] == ' ' {
		i++
	}
	return i + 2
}

parse ordered or unordered list block

func (p *Markdown) list(data []byte, flags ListType) int {
	i := 0
	flags |= ListItemBeginningOfList
	block := p.addBlock(List, nil)
	block.ListFlags = flags
	block.Tight = true

	for i < len(data) {
		skip := p.listItem(data[i:], &flags)
		if flags&ListItemContainsBlock != 0 {
			block.ListData.Tight = false
		}
		i += skip
		if skip == 0 || flags&ListItemEndOfList != 0 {
			break
		}
		flags &= ^ListItemBeginningOfList
	}

	above := block.Parent
	finalizeList(block)
	p.tip = above
	return i
}

Returns true if the list item is not the same type as its parent list

func (p *Markdown) listTypeChanged(data []byte, flags *ListType) bool {
	if p.dliPrefix(data) > 0 && *flags&ListTypeDefinition == 0 {
		return true
	} else if p.oliPrefix(data) > 0 && *flags&ListTypeOrdered == 0 {
		return true
	} else if p.uliPrefix(data) > 0 && (*flags&ListTypeOrdered != 0 || *flags&ListTypeDefinition != 0) {
		return true
	}
	return false
}

Returns true if block ends with a blank line, descending if needed into lists and sublists.

TODO: figure this out. Always false now.

if block.lastLineBlank { return true }

		t := block.Type
		if t == List || t == Item {
			block = block.LastChild
		} else {
			break
		}
	}
	return false
}

func finalizeList(block *Node) {
	block.open = false
	item := block.FirstChild

check for non-final list item ending with blank line:

		if endsWithBlankLine(item) && item.Next != nil {
			block.ListData.Tight = false
			break

recurse into children of list item, to see if there are spaces between any of them:

		subItem := item.FirstChild
		for subItem != nil {
			if endsWithBlankLine(subItem) && (item.Next != nil || subItem.Next != nil) {
				block.ListData.Tight = false
				break
			}
			subItem = subItem.Next
		}
		item = item.Next
	}
}

Parse a single list item. Assumes initial prefix is already removed if this is a sublist.

keep track of the indentation of the first line

	itemIndent := 0
	if data[0] == '\t' {
		itemIndent += 4
	} else {
		for itemIndent < 3 && data[itemIndent] == ' ' {
			itemIndent++
		}
	}

	var bulletChar byte = '*'
	i := p.uliPrefix(data)
	if i == 0 {
		i = p.oliPrefix(data)
	} else {
		bulletChar = data[i-2]
	}
	if i == 0 {

reset definition term flag

		if i > 0 {
			*flags &= ^ListTypeTerm
		}
	}

if in definition list, set term flag and continue

		if *flags&ListTypeDefinition != 0 {
			*flags |= ListTypeTerm
		} else {
			return 0
		}
	}

skip leading whitespace on first line

	for i < len(data) && data[i] == ' ' {
		i++
	}

find the end of the line

	line := i
	for i > 0 && i < len(data) && data[i-1] != '\n' {
		i++
	}

get working buffer

	var raw bytes.Buffer

put the first line into the working buffer

	raw.Write(data[line:i])
	line = i

process the following lines

	containsBlankLine := false
	sublist := 0
	codeBlockMarker := ""

gatherlines:
	for line < len(data) {
		i++

find the end of this line

		for i < len(data) && data[i-1] != '\n' {
			i++
		}

if it is an empty line, guess that it is part of this item and move on to the next line

		if p.isEmpty(data[line:i]) > 0 {
			containsBlankLine = true
			line = i
			continue
		}

calculate the indentation

		indent := 0
		indentIndex := 0
		if data[line] == '\t' {
			indentIndex++
			indent += 4
		} else {
			for indent < 4 && line+indent < i && data[line+indent] == ' ' {
				indent++
				indentIndex++
			}
		}

		chunk := data[line+indentIndex : i]

determine if in or out of codeblock if in codeblock, ignore normal list processing

			_, marker := isFenceLine(chunk, nil, codeBlockMarker)
			if marker != "" {

start of codeblock

					codeBlockMarker = marker

end of codeblock.

					codeBlockMarker = ""
				}

we are in a codeblock, write line, and continue

			if codeBlockMarker != "" || marker != "" {
				raw.Write(data[line+indentIndex : i])
				line = i
				continue gatherlines
			}
		}

evaluate how this line fits in

is this a nested list item?

		case (p.uliPrefix(chunk) > 0 && !p.isHRule(chunk)) ||
			p.oliPrefix(chunk) > 0 ||
			p.dliPrefix(chunk) > 0:

to be a nested list, it must be indented more if not, it is either a different kind of list or the next item in the same list

			if indent <= itemIndent {
				if p.listTypeChanged(chunk, flags) {
					*flags |= ListItemEndOfList
				} else if containsBlankLine {
					*flags |= ListItemContainsBlock
				}

				break gatherlines
			}

			if containsBlankLine {
				*flags |= ListItemContainsBlock
			}

is this the first item in the nested list?

			if sublist == 0 {
				sublist = raw.Len()
			}

is this a nested prefix heading?

if the heading is not indented, it is not nested in the list and thus ends the list

			if containsBlankLine && indent < 4 {
				*flags |= ListItemEndOfList
				break gatherlines
			}
			*flags |= ListItemContainsBlock

anything following an empty line is only part of this item if it is indented 4 spaces (regardless of the indentation of the beginning of the item)

		case containsBlankLine && indent < 4:

is the next item still a part of this list?

				next := i
				for next < len(data) && data[next] != '\n' {
					next++
				}
				for next < len(data)-1 && data[next] == '\n' {
					next++
				}
				if i < len(data)-1 && data[i] != ':' && data[next] != ':' {
					*flags |= ListItemEndOfList
				}
			} else {
				*flags |= ListItemEndOfList
			}
			break gatherlines

a blank line means this should be parsed as a block

		case containsBlankLine:
			raw.WriteByte('\n')
			*flags |= ListItemContainsBlock
		}

if this line was preceded by one or more blanks, re-introduce the blank into the buffer

		if containsBlankLine {
			containsBlankLine = false
			raw.WriteByte('\n')
		}

add the line into the working buffer without prefix

		raw.Write(data[line+indentIndex : i])

		line = i
	}

	rawBytes := raw.Bytes()

	block := p.addBlock(Item, nil)
	block.ListFlags = *flags
	block.Tight = false
	block.BulletChar = bulletChar
	block.Delimiter = '.' // Only '.' is possible in Markdown, but ')' will also be possible in CommonMark

render the contents of the list item

intermediate render of block item, except for definition term

		if sublist > 0 {
			p.block(rawBytes[:sublist])
			p.block(rawBytes[sublist:])
		} else {
			p.block(rawBytes)
		}

intermediate render of inline item

		if sublist > 0 {
			child := p.addChild(Paragraph, 0)
			child.content = rawBytes[:sublist]
			p.block(rawBytes[sublist:])
		} else {
			child := p.addChild(Paragraph, 0)
			child.content = rawBytes
		}
	}
	return line
}

render a single paragraph that has already been parsed out

func (p *Markdown) renderParagraph(data []byte) {
	if len(data) == 0 {
		return
	}

trim leading spaces

	beg := 0
	for data[beg] == ' ' {
		beg++
	}

trim trailing newline

	if data[len(data)-1] == '\n' {
		end--
	}

trim trailing spaces

	for end > beg && data[end-1] == ' ' {
		end--
	}

	p.addBlock(Paragraph, data[beg:end])
}

prev: index of 1st char of previous line line: index of 1st char of current line i: index of cursor/end of current line

	var prev, line, i int
	tabSize := TabSizeDefault
	if p.extensions&TabSizeEight != 0 {
		tabSize = TabSizeDouble

keep going until we find something to mark the end of the paragraph

mark the beginning of the current line

		prev = line
		current := data[i:]
		line = i

did we find a reference or a footnote? If so, end a paragraph preceding it and report that we have consumed up to the end of that reference:

		if refEnd := isReference(p, current, tabSize); refEnd > 0 {
			p.renderParagraph(data[:i])
			return i + refEnd
		}

did we find a blank line marking the end of the paragraph?

did this blank line followed by a definition list item?

			if p.extensions&DefinitionLists != 0 {
				if i < len(data)-1 && data[i+1] == ':' {
					return p.list(data[prev:], ListTypeDefinition)
				}
			}

			p.renderParagraph(data[:i])
			return i + n
		}

an underline under some text marks a heading, so our paragraph ended on prev line

		if i > 0 {

render the paragraph

				p.renderParagraph(data[:prev])

ignore leading and trailing whitespace

				eol := i - 1
				for prev < eol && data[prev] == ' ' {
					prev++
				}
				for eol > prev && data[eol-1] == ' ' {
					eol--
				}

				id := ""
				if p.extensions&AutoHeadingIDs != 0 {
					id = sanitized_anchor_name.Create(string(data[prev:eol]))
				}

				block := p.addBlock(Heading, data[prev:eol])
				block.Level = level
				block.HeadingID = id

find the end of the underline

				for i < len(data) && data[i] != '\n' {
					i++
				}
				return i
			}
		}

if the next line starts a block of HTML, then the paragraph ends here

		if p.extensions&LaxHTMLBlocks != 0 {

rewind to before the HTML block

				p.renderParagraph(data[:i])
				return i
			}
		}

if there's a prefixed heading or a horizontal rule after this, paragraph is over

		if p.isPrefixHeading(current) || p.isHRule(current) {
			p.renderParagraph(data[:i])
			return i
		}

if there's a fenced code block, paragraph is over

		if p.extensions&FencedCode != 0 {
			if p.fencedCodeBlock(current, false) > 0 {
				p.renderParagraph(data[:i])
				return i
			}
		}

if there's a definition list item, prev line is a definition term

		if p.extensions&DefinitionLists != 0 {
			if p.dliPrefix(current) != 0 {
				ret := p.list(data[prev:], ListTypeDefinition)
				return ret
			}
		}

if there's a list after this, paragraph is over

		if p.extensions&NoEmptyLineBeforeBlock != 0 {
			if p.uliPrefix(current) != 0 ||
				p.oliPrefix(current) != 0 ||
				p.quotePrefix(current) != 0 ||
				p.codePrefix(current) != 0 {
				p.renderParagraph(data[:i])
				return i
			}
		}

otherwise, scan to the beginning of the next line

		nl := bytes.IndexByte(data[i:], '\n')
		if nl >= 0 {
			i += nl + 1
		} else {
			i += len(data[i:])
		}
	}

	p.renderParagraph(data[:i])
	return i
}

func skipChar(data []byte, start int, char byte) int {
	i := start
	for i < len(data) && data[i] == char {
		i++
	}
	return i
}

func skipUntilChar(text []byte, start int, char byte) int {
	i := start
	for i < len(text) && text[i] != char {
		i++
	}
	return i