1 //

     2 // Blackfriday Markdown Processor

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

     4 //

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

     6 // Distributed under the Simplified BSD License.

     7 // See README.md for details.

     8 //

     9 

    10 //

    11 // Functions to parse block-level elements.

    12 //

    13 

    14 package blackfriday

    15 

    16 import (

    17 	"bytes"

    18 	"html"

    19 	"regexp"

    20 

    21 	"github.com/shurcooL/sanitized_anchor_name"

    22 )

    23 

    24 const (

    25 	charEntity = "&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});"

    26 	escapable  = "[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]"

    27 )

    28 

    29 var (

    30 	reBackslashOrAmp      = regexp.MustCompile("[\\&]")

    31 	reEntityOrEscapedChar = regexp.MustCompile("(?i)\\\\" + escapable + "|" + charEntity)

    32 )

    33 

    34 // Parse block-level data.

    35 // Note: this function and many that it calls assume that

    36 // the input buffer ends with a newline.

    37 func (p *Markdown) block(data []byte) {

    38 	// this is called recursively: enforce a maximum depth

    39 	if p.nesting >= p.maxNesting {

    40 		return

    41 	}

    42 	p.nesting++

    43 

    44 	// parse out one block-level construct at a time

    45 	for len(data) > 0 {

    46 		// prefixed heading:

    47 		//

    48 		// # Heading 1

    49 		// ## Heading 2

    50 		// ...

    51 		// ###### Heading 6

    52 		if p.isPrefixHeading(data) {

    53 			data = data[p.prefixHeading(data):]

    54 			continue

    55 		}

    56 

    57 		// block of preformatted HTML:

    58 		//

    59 		// <div>

    60 		//     ...

    61 		// </div>

    62 		if data[0] == '<' {

    63 			if i := p.html(data, true); i > 0 {

    64 				data = data[i:]

    65 				continue

    66 			}

    67 		}

    68 

    69 		// title block

    70 		//

    71 		// % stuff

    72 		// % more stuff

    73 		// % even more stuff

    74 		if p.extensions&Titleblock != 0 {

    75 			if data[0] == '%' {

    76 				if i := p.titleBlock(data, true); i > 0 {

    77 					data = data[i:]

    78 					continue

    79 				}

    80 			}

    81 		}

    82 

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

    84 		if i := p.isEmpty(data); i > 0 {

    85 			data = data[i:]

    86 			continue

    87 		}

    88 

    89 		// indented code block:

    90 		//

    91 		//     func max(a, b int) int {

    92 		//         if a > b {

    93 		//             return a

    94 		//         }

    95 		//         return b

    96 		//      }

    97 		if p.codePrefix(data) > 0 {

    98 			data = data[p.code(data):]

    99 			continue

   100 		}

   101 

   102 		// fenced code block:

   103 		//

   104 		// ``` go

   105 		// func fact(n int) int {

   106 		//     if n <= 1 {

   107 		//         return n

   108 		//     }

   109 		//     return n * fact(n-1)

   110 		// }

   111 		// ```

   112 		if p.extensions&FencedCode != 0 {

   113 			if i := p.fencedCodeBlock(data, true); i > 0 {

   114 				data = data[i:]

   115 				continue

   116 			}

   117 		}

   118 

   119 		// horizontal rule:

   120 		//

   121 		// ------

   122 		// or

   123 		// ******

   124 		// or

   125 		// ______

   126 		if p.isHRule(data) {

   127 			p.addBlock(HorizontalRule, nil)

   128 			var i int

   129 			for i = 0; i < len(data) && data[i] != '\n'; i++ {

   130 			}

   131 			data = data[i:]

   132 			continue

   133 		}

   134 

   135 		// block quote:

   136 		//

   137 		// > A big quote I found somewhere

   138 		// > on the web

   139 		if p.quotePrefix(data) > 0 {

   140 			data = data[p.quote(data):]

   141 			continue

   142 		}

   143 

   144 		// table:

   145 		//

   146 		// Name  | Age | Phone

   147 		// ------|-----|---------

   148 		// Bob   | 31  | 555-1234

   149 		// Alice | 27  | 555-4321

   150 		if p.extensions&Tables != 0 {

   151 			if i := p.table(data); i > 0 {

   152 				data = data[i:]

   153 				continue

   154 			}

   155 		}

   156 

   157 		// an itemized/unordered list:

   158 		//

   159 		// * Item 1

   160 		// * Item 2

   161 		//

   162 		// also works with + or -

   163 		if p.uliPrefix(data) > 0 {

   164 			data = data[p.list(data, 0):]

   165 			continue

   166 		}

   167 

   168 		// a numbered/ordered list:

   169 		//

   170 		// 1. Item 1

   171 		// 2. Item 2

   172 		if p.oliPrefix(data) > 0 {

   173 			data = data[p.list(data, ListTypeOrdered):]

   174 			continue

   175 		}

   176 

   177 		// definition lists:

   178 		//

   179 		// Term 1

   180 		// :   Definition a

   181 		// :   Definition b

   182 		//

   183 		// Term 2

   184 		// :   Definition c

   185 		if p.extensions&DefinitionLists != 0 {

   186 			if p.dliPrefix(data) > 0 {

   187 				data = data[p.list(data, ListTypeDefinition):]

   188 				continue

   189 			}

   190 		}

   191 

   192 		// anything else must look like a normal paragraph

   193 		// note: this finds underlined headings, too

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

   195 	}

   196 

   197 	p.nesting--

   198 }

   199 

   200 func (p *Markdown) addBlock(typ NodeType, content []byte) *Node {

   201 	p.closeUnmatchedBlocks()

   202 	container := p.addChild(typ, 0)

   203 	container.content = content

   204 	return container

   205 }

   206 

   207 func (p *Markdown) isPrefixHeading(data []byte) bool {

   208 	if data[0] != '#' {

   209 		return false

   210 	}

   211 

   212 	if p.extensions&SpaceHeadings != 0 {

   213 		level := 0

   214 		for level < 6 && level < len(data) && data[level] == '#' {

   215 			level++

   216 		}

   217 		if level == len(data) || data[level] != ' ' {

   218 			return false

   219 		}

   220 	}

   221 	return true

   222 }

   223 

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

   225 	level := 0

   226 	for level < 6 && level < len(data) && data[level] == '#' {

   227 		level++

   228 	}

   229 	i := skipChar(data, level, ' ')

   230 	end := skipUntilChar(data, i, '\n')

   231 	skip := end

   232 	id := ""

   233 	if p.extensions&HeadingIDs != 0 {

   234 		j, k := 0, 0

   235 		// find start/end of heading id

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

   237 		}

   238 		for k = j + 1; k < end && data[k] != '}'; k++ {

   239 		}

   240 		// extract heading id iff found

   241 		if j < end && k < end {

   242 			id = string(data[j+2 : k])

   243 			end = j

   244 			skip = k + 1

   245 			for end > 0 && data[end-1] == ' ' {

   246 				end--

   247 			}

   248 		}

   249 	}

   250 	for end > 0 && data[end-1] == '#' {

   251 		if isBackslashEscaped(data, end-1) {

   252 			break

   253 		}

   254 		end--

   255 	}

   256 	for end > 0 && data[end-1] == ' ' {

   257 		end--

   258 	}

   259 	if end > i {

   260 		if id == "" && p.extensions&AutoHeadingIDs != 0 {

   261 			id = sanitized_anchor_name.Create(string(data[i:end]))

   262 		}

   263 		block := p.addBlock(Heading, data[i:end])

   264 		block.HeadingID = id

   265 		block.Level = level

   266 	}

   267 	return skip

   268 }

   269 

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

   271 	// test of level 1 heading

   272 	if data[0] == '=' {

   273 		i := skipChar(data, 1, '=')

   274 		i = skipChar(data, i, ' ')

   275 		if i < len(data) && data[i] == '\n' {

   276 			return 1

   277 		}

   278 		return 0

   279 	}

   280 

   281 	// test of level 2 heading

   282 	if data[0] == '-' {

   283 		i := skipChar(data, 1, '-')

   284 		i = skipChar(data, i, ' ')

   285 		if i < len(data) && data[i] == '\n' {

   286 			return 2

   287 		}

   288 		return 0

   289 	}

   290 

   291 	return 0

   292 }

   293 

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

   295 	if data[0] != '%' {

   296 		return 0

   297 	}

   298 	splitData := bytes.Split(data, []byte("\n"))

   299 	var i int

   300 	for idx, b := range splitData {

   301 		if !bytes.HasPrefix(b, []byte("%")) {

   302 			i = idx // - 1

   303 			break

   304 		}

   305 	}

   306 

   307 	data = bytes.Join(splitData[0:i], []byte("\n"))

   308 	consumed := len(data)

   309 	data = bytes.TrimPrefix(data, []byte("% "))

   310 	data = bytes.Replace(data, []byte("\n% "), []byte("\n"), -1)

   311 	block := p.addBlock(Heading, data)

   312 	block.Level = 1

   313 	block.IsTitleblock = true

   314 

   315 	return consumed

   316 }

   317 

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

   319 	var i, j int

   320 

   321 	// identify the opening tag

   322 	if data[0] != '<' {

   323 		return 0

   324 	}

   325 	curtag, tagfound := p.htmlFindTag(data[1:])

   326 

   327 	// handle special cases

   328 	if !tagfound {

   329 		// check for an HTML comment

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

   331 			return size

   332 		}

   333 

   334 		// check for an <hr> tag

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

   336 			return size

   337 		}

   338 

   339 		// no special case recognized

   340 		return 0

   341 	}

   342 

   343 	// look for an unindented matching closing tag

   344 	// followed by a blank line

   345 	found := false

   346 	/*

   347 		closetag := []byte("\n</" + curtag + ">")

   348 		j = len(curtag) + 1

   349 		for !found {

   350 			// scan for a closing tag at the beginning of a line

   351 			if skip := bytes.Index(data[j:], closetag); skip >= 0 {

   352 				j += skip + len(closetag)

   353 			} else {

   354 				break

   355 			}

   356 

   357 			// see if it is the only thing on the line

   358 			if skip := p.isEmpty(data[j:]); skip > 0 {

   359 				// see if it is followed by a blank line/eof

   360 				j += skip

   361 				if j >= len(data) {

   362 					found = true

   363 					i = j

   364 				} else {

   365 					if skip := p.isEmpty(data[j:]); skip > 0 {

   366 						j += skip

   367 						found = true

   368 						i = j

   369 					}

   370 				}

   371 			}

   372 		}

   373 	*/

   374 

   375 	// if not found, try a second pass looking for indented match

   376 	// but not if tag is "ins" or "del" (following original Markdown.pl)

   377 	if !found && curtag != "ins" && curtag != "del" {

   378 		i = 1

   379 		for i < len(data) {

   380 			i++

   381 			for i < len(data) && !(data[i-1] == '<' && data[i] == '/') {

   382 				i++

   383 			}

   384 

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

   386 				break

   387 			}

   388 

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

   390 

   391 			if j > 0 {

   392 				i += j - 1

   393 				found = true

   394 				break

   395 			}

   396 		}

   397 	}

   398 

   399 	if !found {

   400 		return 0

   401 	}

   402 

   403 	// the end of the block has been found

   404 	if doRender {

   405 		// trim newlines

   406 		end := i

   407 		for end > 0 && data[end-1] == '\n' {

   408 			end--

   409 		}

   410 		finalizeHTMLBlock(p.addBlock(HTMLBlock, data[:end]))

   411 	}

   412 

   413 	return i

   414 }

   415 

   416 func finalizeHTMLBlock(block *Node) {

   417 	block.Literal = block.content

   418 	block.content = nil

   419 }

   420 

   421 // HTML comment, lax form

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

   423 	i := p.inlineHTMLComment(data)

   424 	// needs to end with a blank line

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

   426 		size := i + j

   427 		if doRender {

   428 			// trim trailing newlines

   429 			end := size

   430 			for end > 0 && data[end-1] == '\n' {

   431 				end--

   432 			}

   433 			block := p.addBlock(HTMLBlock, data[:end])

   434 			finalizeHTMLBlock(block)

   435 		}

   436 		return size

   437 	}

   438 	return 0

   439 }

   440 

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

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

   443 	if len(data) < 4 {

   444 		return 0

   445 	}

   446 	if data[0] != '<' || (data[1] != 'h' && data[1] != 'H') || (data[2] != 'r' && data[2] != 'R') {

   447 		return 0

   448 	}

   449 	if data[3] != ' ' && data[3] != '/' && data[3] != '>' {

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

   451 		return 0

   452 	}

   453 	i := 3

   454 	for i < len(data) && data[i] != '>' && data[i] != '\n' {

   455 		i++

   456 	}

   457 	if i < len(data) && data[i] == '>' {

   458 		i++

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

   460 			size := i + j

   461 			if doRender {

   462 				// trim newlines

   463 				end := size

   464 				for end > 0 && data[end-1] == '\n' {

   465 					end--

   466 				}

   467 				finalizeHTMLBlock(p.addBlock(HTMLBlock, data[:end]))

   468 			}

   469 			return size

   470 		}

   471 	}

   472 	return 0

   473 }

   474 

   475 func (p *Markdown) htmlFindTag(data []byte) (string, bool) {

   476 	i := 0

   477 	for i < len(data) && isalnum(data[i]) {

   478 		i++

   479 	}

   480 	key := string(data[:i])

   481 	if _, ok := blockTags[key]; ok {

   482 		return key, true

   483 	}

   484 	return "", false

   485 }

   486 

   487 func (p *Markdown) htmlFindEnd(tag string, data []byte) int {

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

   489 	if tag == "hr" {

   490 		return 2

   491 	}

   492 	// check if tag is a match

   493 	closetag := []byte("</" + tag + ">")

   494 	if !bytes.HasPrefix(data, closetag) {

   495 		return 0

   496 	}

   497 	i := len(closetag)

   498 

   499 	// check that the rest of the line is blank

   500 	skip := 0

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

   502 		return 0

   503 	}

   504 	i += skip

   505 	skip = 0

   506 

   507 	if i >= len(data) {

   508 		return i

   509 	}

   510 

   511 	if p.extensions&LaxHTMLBlocks != 0 {

   512 		return i

   513 	}

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

   515 		// following line must be blank

   516 		return 0

   517 	}

   518 

   519 	return i + skip

   520 }

   521 

   522 func (*Markdown) isEmpty(data []byte) int {

   523 	// it is okay to call isEmpty on an empty buffer

   524 	if len(data) == 0 {

   525 		return 0

   526 	}

   527 

   528 	var i int

   529 	for i = 0; i < len(data) && data[i] != '\n'; i++ {

   530 		if data[i] != ' ' && data[i] != '\t' {

   531 			return 0

   532 		}

   533 	}

   534 	if i < len(data) && data[i] == '\n' {

   535 		i++

   536 	}

   537 	return i

   538 }

   539 

   540 func (*Markdown) isHRule(data []byte) bool {

   541 	i := 0

   542 

   543 	// skip up to three spaces

   544 	for i < 3 && data[i] == ' ' {

   545 		i++

   546 	}

   547 

   548 	// look at the hrule char

   549 	if data[i] != '*' && data[i] != '-' && data[i] != '_' {

   550 		return false

   551 	}

   552 	c := data[i]

   553 

   554 	// the whole line must be the char or whitespace

   555 	n := 0

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

   557 		switch {

   558 		case data[i] == c:

   559 			n++

   560 		case data[i] != ' ':

   561 			return false

   562 		}

   563 		i++

   564 	}

   565 

   566 	return n >= 3

   567 }

   568 

   569 // isFenceLine checks if there's a fence line (e.g., ``` or ``` go) at the beginning of data,

   570 // and returns the end index if so, or 0 otherwise. It also returns the marker found.

   571 // If syntax is not nil, it gets set to the syntax specified in the fence line.

   572 func isFenceLine(data []byte, syntax *string, oldmarker string) (end int, marker string) {

   573 	i, size := 0, 0

   574 

   575 	// skip up to three spaces

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

   577 		i++

   578 	}

   579 

   580 	// check for the marker characters: ~ or `

   581 	if i >= len(data) {

   582 		return 0, ""

   583 	}

   584 	if data[i] != '~' && data[i] != '`' {

   585 		return 0, ""

   586 	}

   587 

   588 	c := data[i]

   589 

   590 	// the whole line must be the same char or whitespace

   591 	for i < len(data) && data[i] == c {

   592 		size++

   593 		i++

   594 	}

   595 

   596 	// the marker char must occur at least 3 times

   597 	if size < 3 {

   598 		return 0, ""

   599 	}

   600 	marker = string(data[i-size : i])

   601 

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

   603 	if oldmarker != "" && marker != oldmarker {

   604 		return 0, ""

   605 	}

   606 

   607 	// TODO(shurcooL): It's probably a good idea to simplify the 2 code paths here

   608 	// into one, always get the syntax, and discard it if the caller doesn't care.

   609 	if syntax != nil {

   610 		syn := 0

   611 		i = skipChar(data, i, ' ')

   612 

   613 		if i >= len(data) {

   614 			if i == len(data) {

   615 				return i, marker

   616 			}

   617 			return 0, ""

   618 		}

   619 

   620 		syntaxStart := i

   621 

   622 		if data[i] == '{' {

   623 			i++

   624 			syntaxStart++

   625 

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

   627 				syn++

   628 				i++

   629 			}

   630 

   631 			if i >= len(data) || data[i] != '}' {

   632 				return 0, ""

   633 			}

   634 

   635 			// strip all whitespace at the beginning and the end

   636 			// of the {} block

   637 			for syn > 0 && isspace(data[syntaxStart]) {

   638 				syntaxStart++

   639 				syn--

   640 			}

   641 

   642 			for syn > 0 && isspace(data[syntaxStart+syn-1]) {

   643 				syn--

   644 			}

   645 

   646 			i++

   647 		} else {

   648 			for i < len(data) && !isspace(data[i]) {

   649 				syn++

   650 				i++

   651 			}

   652 		}

   653 

   654 		*syntax = string(data[syntaxStart : syntaxStart+syn])

   655 	}

   656 

   657 	i = skipChar(data, i, ' ')

   658 	if i >= len(data) || data[i] != '\n' {

   659 		if i == len(data) {

   660 			return i, marker

   661 		}

   662 		return 0, ""

   663 	}

   664 	return i + 1, marker // Take newline into account.

   665 }

   666 

   667 // fencedCodeBlock returns the end index if data contains a fenced code block at the beginning,

   668 // or 0 otherwise. It writes to out if doRender is true, otherwise it has no side effects.

   669 // If doRender is true, a final newline is mandatory to recognize the fenced code block.

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

   671 	var syntax string

   672 	beg, marker := isFenceLine(data, &syntax, "")

   673 	if beg == 0 || beg >= len(data) {

   674 		return 0

   675 	}

   676 

   677 	var work bytes.Buffer

   678 	work.Write([]byte(syntax))

   679 	work.WriteByte('\n')

   680 

   681 	for {

   682 		// safe to assume beg < len(data)

   683 

   684 		// check for the end of the code block

   685 		fenceEnd, _ := isFenceLine(data[beg:], nil, marker)

   686 		if fenceEnd != 0 {

   687 			beg += fenceEnd

   688 			break

   689 		}

   690 

   691 		// copy the current line

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

   693 

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

   695 		if end >= len(data) {

   696 			return 0

   697 		}

   698 

   699 		// verbatim copy to the working buffer

   700 		if doRender {

   701 			work.Write(data[beg:end])

   702 		}

   703 		beg = end

   704 	}

   705 

   706 	if doRender {

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

   708 		block.IsFenced = true

   709 		finalizeCodeBlock(block)

   710 	}

   711 

   712 	return beg

   713 }

   714 

   715 func unescapeChar(str []byte) []byte {

   716 	if str[0] == '\\' {

   717 		return []byte{str[1]}

   718 	}

   719 	return []byte(html.UnescapeString(string(str)))

   720 }

   721 

   722 func unescapeString(str []byte) []byte {

   723 	if reBackslashOrAmp.Match(str) {

   724 		return reEntityOrEscapedChar.ReplaceAllFunc(str, unescapeChar)

   725 	}

   726 	return str

   727 }

   728 

   729 func finalizeCodeBlock(block *Node) {

   730 	if block.IsFenced {

   731 		newlinePos := bytes.IndexByte(block.content, '\n')

   732 		firstLine := block.content[:newlinePos]

   733 		rest := block.content[newlinePos+1:]

   734 		block.Info = unescapeString(bytes.Trim(firstLine, "\n"))

   735 		block.Literal = rest

   736 	} else {

   737 		block.Literal = block.content

   738 	}

   739 	block.content = nil

   740 }

   741 

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

   743 	table := p.addBlock(Table, nil)

   744 	i, columns := p.tableHeader(data)

   745 	if i == 0 {

   746 		p.tip = table.Parent

   747 		table.Unlink()

   748 		return 0

   749 	}

   750 

   751 	p.addBlock(TableBody, nil)

   752 

   753 	for i < len(data) {

   754 		pipes, rowStart := 0, i

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

   756 			if data[i] == '|' {

   757 				pipes++

   758 			}

   759 		}

   760 

   761 		if pipes == 0 {

   762 			i = rowStart

   763 			break

   764 		}

   765 

   766 		// include the newline in data sent to tableRow

   767 		if i < len(data) && data[i] == '\n' {

   768 			i++

   769 		}

   770 		p.tableRow(data[rowStart:i], columns, false)

   771 	}

   772 

   773 	return i

   774 }

   775 

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

   777 func isBackslashEscaped(data []byte, i int) bool {

   778 	backslashes := 0

   779 	for i-backslashes-1 >= 0 && data[i-backslashes-1] == '\\' {

   780 		backslashes++

   781 	}

   782 	return backslashes&1 == 1

   783 }

   784 

   785 func (p *Markdown) tableHeader(data []byte) (size int, columns []CellAlignFlags) {

   786 	i := 0

   787 	colCount := 1

   788 	for i = 0; i < len(data) && data[i] != '\n'; i++ {

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

   790 			colCount++

   791 		}

   792 	}

   793 

   794 	// doesn't look like a table header

   795 	if colCount == 1 {

   796 		return

   797 	}

   798 

   799 	// include the newline in the data sent to tableRow

   800 	j := i

   801 	if j < len(data) && data[j] == '\n' {

   802 		j++

   803 	}

   804 	header := data[:j]

   805 

   806 	// column count ignores pipes at beginning or end of line

   807 	if data[0] == '|' {

   808 		colCount--

   809 	}

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

   811 		colCount--

   812 	}

   813 

   814 	columns = make([]CellAlignFlags, colCount)

   815 

   816 	// move on to the header underline

   817 	i++

   818 	if i >= len(data) {

   819 		return

   820 	}

   821 

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

   823 		i++

   824 	}

   825 	i = skipChar(data, i, ' ')

   826 

   827 	// each column header is of form: / *:?-+:? *|/ with # dashes + # colons >= 3

   828 	// and trailing | optional on last column

   829 	col := 0

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

   831 		dashes := 0

   832 

   833 		if data[i] == ':' {

   834 			i++

   835 			columns[col] |= TableAlignmentLeft

   836 			dashes++

   837 		}

   838 		for i < len(data) && data[i] == '-' {

   839 			i++

   840 			dashes++

   841 		}

   842 		if i < len(data) && data[i] == ':' {

   843 			i++

   844 			columns[col] |= TableAlignmentRight

   845 			dashes++

   846 		}

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

   848 			i++

   849 		}

   850 		if i == len(data) {

   851 			return

   852 		}

   853 		// end of column test is messy

   854 		switch {

   855 		case dashes < 3:

   856 			// not a valid column

   857 			return

   858 

   859 		case data[i] == '|' && !isBackslashEscaped(data, i):

   860 			// marker found, now skip past trailing whitespace

   861 			col++

   862 			i++

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

   864 				i++

   865 			}

   866 

   867 			// trailing junk found after last column

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

   869 				return

   870 			}

   871 

   872 		case (data[i] != '|' || isBackslashEscaped(data, i)) && col+1 < colCount:

   873 			// something else found where marker was required

   874 			return

   875 

   876 		case data[i] == '\n':

   877 			// marker is optional for the last column

   878 			col++

   879 

   880 		default:

   881 			// trailing junk found after last column

   882 			return

   883 		}

   884 	}

   885 	if col != colCount {

   886 		return

   887 	}

   888 

   889 	p.addBlock(TableHead, nil)

   890 	p.tableRow(header, columns, true)

   891 	size = i

   892 	if size < len(data) && data[size] == '\n' {

   893 		size++

   894 	}

   895 	return

   896 }

   897 

   898 func (p *Markdown) tableRow(data []byte, columns []CellAlignFlags, header bool) {

   899 	p.addBlock(TableRow, nil)

   900 	i, col := 0, 0

   901 

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

   903 		i++

   904 	}

   905 

   906 	for col = 0; col < len(columns) && i < len(data); col++ {

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

   908 			i++

   909 		}

   910 

   911 		cellStart := i

   912 

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

   914 			i++

   915 		}

   916 

   917 		cellEnd := i

   918 

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

   920 		i++

   921 

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

   923 			cellEnd--

   924 		}

   925 

   926 		cell := p.addBlock(TableCell, data[cellStart:cellEnd])

   927 		cell.IsHeader = header

   928 		cell.Align = columns[col]

   929 	}

   930 

   931 	// pad it out with empty columns to get the right number

   932 	for ; col < len(columns); col++ {

   933 		cell := p.addBlock(TableCell, nil)

   934 		cell.IsHeader = header

   935 		cell.Align = columns[col]

   936 	}

   937 

   938 	// silently ignore rows with too many cells

   939 }

   940 

   941 // returns blockquote prefix length

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

   943 	i := 0

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

   945 		i++

   946 	}

   947 	if i < len(data) && data[i] == '>' {

   948 		if i+1 < len(data) && data[i+1] == ' ' {

   949 			return i + 2

   950 		}

   951 		return i + 1

   952 	}

   953 	return 0

   954 }

   955 

   956 // blockquote ends with at least one blank line

   957 // followed by something without a blockquote prefix

   958 func (p *Markdown) terminateBlockquote(data []byte, beg, end int) bool {

   959 	if p.isEmpty(data[beg:]) <= 0 {

   960 		return false

   961 	}

   962 	if end >= len(data) {

   963 		return true

   964 	}

   965 	return p.quotePrefix(data[end:]) == 0 && p.isEmpty(data[end:]) == 0

   966 }

   967 

   968 // parse a blockquote fragment

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

   970 	block := p.addBlock(BlockQuote, nil)

   971 	var raw bytes.Buffer

   972 	beg, end := 0, 0

   973 	for beg < len(data) {

   974 		end = beg

   975 		// Step over whole lines, collecting them. While doing that, check for

   976 		// fenced code and if one's found, incorporate it altogether,

   977 		// irregardless of any contents inside it

   978 		for end < len(data) && data[end] != '\n' {

   979 			if p.extensions&FencedCode != 0 {

   980 				if i := p.fencedCodeBlock(data[end:], false); i > 0 {

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

   982 					end += i - 1

   983 					break

   984 				}

   985 			}

   986 			end++

   987 		}

   988 		if end < len(data) && data[end] == '\n' {

   989 			end++

   990 		}

   991 		if pre := p.quotePrefix(data[beg:]); pre > 0 {

   992 			// skip the prefix

   993 			beg += pre

   994 		} else if p.terminateBlockquote(data, beg, end) {

   995 			break

   996 		}

   997 		// this line is part of the blockquote

   998 		raw.Write(data[beg:end])

   999 		beg = end

  1000 	}

  1001 	p.block(raw.Bytes())

  1002 	p.finalize(block)

  1003 	return end

  1004 }

  1005 

  1006 // returns prefix length for block code

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

  1008 	if len(data) >= 1 && data[0] == '\t' {

  1009 		return 1

  1010 	}

  1011 	if len(data) >= 4 && data[0] == ' ' && data[1] == ' ' && data[2] == ' ' && data[3] == ' ' {

  1012 		return 4

  1013 	}

  1014 	return 0

  1015 }

  1016 

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

  1018 	var work bytes.Buffer

  1019 

  1020 	i := 0

  1021 	for i < len(data) {

  1022 		beg := i

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

  1024 			i++

  1025 		}

  1026 		if i < len(data) && data[i] == '\n' {

  1027 			i++

  1028 		}

  1029 

  1030 		blankline := p.isEmpty(data[beg:i]) > 0

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

  1032 			beg += pre

  1033 		} else if !blankline {

  1034 			// non-empty, non-prefixed line breaks the pre

  1035 			i = beg

  1036 			break

  1037 		}

  1038 

  1039 		// verbatim copy to the working buffer

  1040 		if blankline {

  1041 			work.WriteByte('\n')

  1042 		} else {

  1043 			work.Write(data[beg:i])

  1044 		}

  1045 	}

  1046 

  1047 	// trim all the \n off the end of work

  1048 	workbytes := work.Bytes()

  1049 	eol := len(workbytes)

  1050 	for eol > 0 && workbytes[eol-1] == '\n' {

  1051 		eol--

  1052 	}

  1053 	if eol != len(workbytes) {

  1054 		work.Truncate(eol)

  1055 	}

  1056 

  1057 	work.WriteByte('\n')

  1058 

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

  1060 	block.IsFenced = false

  1061 	finalizeCodeBlock(block)

  1062 

  1063 	return i

  1064 }

  1065 

  1066 // returns unordered list item prefix

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

  1068 	i := 0

  1069 	// start with up to 3 spaces

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

  1071 		i++

  1072 	}

  1073 	if i >= len(data)-1 {

  1074 		return 0

  1075 	}

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

  1077 	if (data[i] != '*' && data[i] != '+' && data[i] != '-') ||

  1078 		(data[i+1] != ' ' && data[i+1] != '\t') {

  1079 		return 0

  1080 	}

  1081 	return i + 2

  1082 }

  1083 

  1084 // returns ordered list item prefix

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

  1086 	i := 0

  1087 

  1088 	// start with up to 3 spaces

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

  1090 		i++

  1091 	}

  1092 

  1093 	// count the digits

  1094 	start := i

  1095 	for i < len(data) && data[i] >= '0' && data[i] <= '9' {

  1096 		i++

  1097 	}

  1098 	if start == i || i >= len(data)-1 {

  1099 		return 0

  1100 	}

  1101 

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

  1103 	if data[i] != '.' || !(data[i+1] == ' ' || data[i+1] == '\t') {

  1104 		return 0

  1105 	}

  1106 	return i + 2

  1107 }

  1108 

  1109 // returns definition list item prefix

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

  1111 	if len(data) < 2 {

  1112 		return 0

  1113 	}

  1114 	i := 0

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

  1116 	if data[i] != ':' || !(data[i+1] == ' ' || data[i+1] == '\t') {

  1117 		return 0

  1118 	}

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

  1120 		i++

  1121 	}

  1122 	return i + 2

  1123 }

  1124 

  1125 // parse ordered or unordered list block

  1126 func (p *Markdown) list(data []byte, flags ListType) int {

  1127 	i := 0

  1128 	flags |= ListItemBeginningOfList

  1129 	block := p.addBlock(List, nil)

  1130 	block.ListFlags = flags

  1131 	block.Tight = true

  1132 

  1133 	for i < len(data) {

  1134 		skip := p.listItem(data[i:], &flags)

  1135 		if flags&ListItemContainsBlock != 0 {