xesite/vendor/github.com/russross/blackfriday/inline.go

1215 lines
24 KiB
Go
Raw Normal View History

2017-05-20 22:43:42 +00:00
//
// 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 inline elements.
//
package blackfriday
import (
"bytes"
"regexp"
"strconv"
)
var (
urlRe = `((https?|ftp):\/\/|\/)[-A-Za-z0-9+&@#\/%?=~_|!:,.;\(\)]+`
anchorRe = regexp.MustCompile(`^(<a\shref="` + urlRe + `"(\stitle="[^"<>]+")?\s?>` + urlRe + `<\/a>)`)
2017-12-13 18:43:58 +00:00
// TODO: improve this regexp to catch all possible entities:
htmlEntityRe = regexp.MustCompile(`&[a-z]{2,5};`)
2017-05-20 22:43:42 +00:00
)
// Functions to parse text within a block
// Each function returns the number of chars taken care of
// data is the complete block being rendered
// offset is the number of valid chars before the current cursor
2017-12-13 18:43:58 +00:00
func (p *Markdown) inline(currBlock *Node, data []byte) {
// handlers might call us recursively: enforce a maximum depth
if p.nesting >= p.maxNesting || len(data) == 0 {
2017-05-20 22:43:42 +00:00
return
}
p.nesting++
2017-12-13 18:43:58 +00:00
beg, end := 0, 0
for end < len(data) {
2017-05-20 22:43:42 +00:00
handler := p.inlineCallback[data[end]]
2017-12-13 18:43:58 +00:00
if handler != nil {
if consumed, node := handler(p, data, end); consumed == 0 {
// No action from the callback.
end++
} else {
// Copy inactive chars into the output.
currBlock.AppendChild(text(data[beg:end]))
if node != nil {
currBlock.AppendChild(node)
}
// Skip past whatever the callback used.
beg = end + consumed
end = beg
}
2017-05-20 22:43:42 +00:00
} else {
2017-12-13 18:43:58 +00:00
end++
2017-05-20 22:43:42 +00:00
}
}
2017-12-13 18:43:58 +00:00
if beg < len(data) {
if data[end-1] == '\n' {
end--
}
currBlock.AppendChild(text(data[beg:end]))
}
2017-05-20 22:43:42 +00:00
p.nesting--
}
// single and double emphasis parsing
2017-12-13 18:43:58 +00:00
func emphasis(p *Markdown, data []byte, offset int) (int, *Node) {
2017-05-20 22:43:42 +00:00
data = data[offset:]
c := data[0]
if len(data) > 2 && data[1] != c {
// whitespace cannot follow an opening emphasis;
// strikethrough only takes two characters '~~'
if c == '~' || isspace(data[1]) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
ret, node := helperEmphasis(p, data[1:], c)
if ret == 0 {
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return ret + 1, node
2017-05-20 22:43:42 +00:00
}
if len(data) > 3 && data[1] == c && data[2] != c {
if isspace(data[2]) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
ret, node := helperDoubleEmphasis(p, data[2:], c)
if ret == 0 {
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return ret + 2, node
2017-05-20 22:43:42 +00:00
}
if len(data) > 4 && data[1] == c && data[2] == c && data[3] != c {
if c == '~' || isspace(data[3]) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
ret, node := helperTripleEmphasis(p, data, 3, c)
if ret == 0 {
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return ret + 3, node
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
func codeSpan(p *Markdown, data []byte, offset int) (int, *Node) {
2017-05-20 22:43:42 +00:00
data = data[offset:]
nb := 0
// count the number of backticks in the delimiter
for nb < len(data) && data[nb] == '`' {
nb++
}
// find the next delimiter
i, end := 0, 0
for end = nb; end < len(data) && i < nb; end++ {
if data[end] == '`' {
i++
} else {
i = 0
}
}
// no matching delimiter?
if i < nb && end >= len(data) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
// trim outside whitespace
fBegin := nb
for fBegin < end && data[fBegin] == ' ' {
fBegin++
}
fEnd := end - nb
for fEnd > fBegin && data[fEnd-1] == ' ' {
fEnd--
}
// render the code span
if fBegin != fEnd {
2017-12-13 18:43:58 +00:00
code := NewNode(Code)
code.Literal = data[fBegin:fEnd]
return end, code
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return end, nil
2017-05-20 22:43:42 +00:00
}
// newline preceded by two spaces becomes <br>
2017-12-13 18:43:58 +00:00
func maybeLineBreak(p *Markdown, data []byte, offset int) (int, *Node) {
origOffset := offset
for offset < len(data) && data[offset] == ' ' {
offset++
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
if offset < len(data) && data[offset] == '\n' {
if offset-origOffset >= 2 {
return offset - origOffset + 1, NewNode(Hardbreak)
}
return offset - origOffset, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return 0, nil
}
2017-05-20 22:43:42 +00:00
2017-12-13 18:43:58 +00:00
// newline without two spaces works when HardLineBreak is enabled
func lineBreak(p *Markdown, data []byte, offset int) (int, *Node) {
if p.extensions&HardLineBreak != 0 {
return 1, NewNode(Hardbreak)
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
type linkType int
const (
linkNormal linkType = iota
linkImg
linkDeferredFootnote
linkInlineFootnote
)
func isReferenceStyleLink(data []byte, pos int, t linkType) bool {
if t == linkDeferredFootnote {
return false
}
return pos < len(data)-1 && data[pos] == '[' && data[pos+1] != '^'
}
2017-12-13 18:43:58 +00:00
func maybeImage(p *Markdown, data []byte, offset int) (int, *Node) {
if offset < len(data)-1 && data[offset+1] == '[' {
return link(p, data, offset)
}
return 0, nil
}
func maybeInlineFootnote(p *Markdown, data []byte, offset int) (int, *Node) {
if offset < len(data)-1 && data[offset+1] == '[' {
return link(p, data, offset)
}
return 0, nil
}
2017-05-20 22:43:42 +00:00
// '[': parse a link or an image or a footnote
2017-12-13 18:43:58 +00:00
func link(p *Markdown, data []byte, offset int) (int, *Node) {
2017-05-20 22:43:42 +00:00
// no links allowed inside regular links, footnote, and deferred footnotes
if p.insideLink && (offset > 0 && data[offset-1] == '[' || len(data)-1 > offset && data[offset+1] == '^') {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
var t linkType
switch {
// special case: ![^text] == deferred footnote (that follows something with
// an exclamation point)
2017-12-13 18:43:58 +00:00
case p.extensions&Footnotes != 0 && len(data)-1 > offset && data[offset+1] == '^':
2017-05-20 22:43:42 +00:00
t = linkDeferredFootnote
// ![alt] == image
2017-12-13 18:43:58 +00:00
case offset >= 0 && data[offset] == '!':
2017-05-20 22:43:42 +00:00
t = linkImg
2017-12-13 18:43:58 +00:00
offset++
2017-05-20 22:43:42 +00:00
// ^[text] == inline footnote
// [^refId] == deferred footnote
2017-12-13 18:43:58 +00:00
case p.extensions&Footnotes != 0:
if offset >= 0 && data[offset] == '^' {
2017-05-20 22:43:42 +00:00
t = linkInlineFootnote
2017-12-13 18:43:58 +00:00
offset++
2017-05-20 22:43:42 +00:00
} else if len(data)-1 > offset && data[offset+1] == '^' {
t = linkDeferredFootnote
}
// [text] == regular link
default:
t = linkNormal
}
data = data[offset:]
var (
i = 1
2017-12-13 18:43:58 +00:00
noteID int
2017-05-20 22:43:42 +00:00
title, link, altContent []byte
textHasNl = false
)
if t == linkDeferredFootnote {
i++
}
// look for the matching closing bracket
for level := 1; level > 0 && i < len(data); i++ {
switch {
case data[i] == '\n':
textHasNl = true
case data[i-1] == '\\':
continue
case data[i] == '[':
level++
case data[i] == ']':
level--
if level <= 0 {
i-- // compensate for extra i++ in for loop
}
}
}
if i >= len(data) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
txtE := i
i++
2017-12-13 18:43:58 +00:00
var footnoteNode *Node
2017-05-20 22:43:42 +00:00
// skip any amount of whitespace or newline
// (this is much more lax than original markdown syntax)
for i < len(data) && isspace(data[i]) {
i++
}
// inline style link
2017-12-13 18:43:58 +00:00
switch {
2017-05-20 22:43:42 +00:00
case i < len(data) && data[i] == '(':
// skip initial whitespace
i++
for i < len(data) && isspace(data[i]) {
i++
}
linkB := i
2017-12-13 18:43:58 +00:00
// look for link end: ' " )
2017-05-20 22:43:42 +00:00
findlinkend:
for i < len(data) {
switch {
case data[i] == '\\':
i += 2
2017-12-13 18:43:58 +00:00
case data[i] == ')' || data[i] == '\'' || data[i] == '"':
2017-05-20 22:43:42 +00:00
break findlinkend
default:
i++
}
}
if i >= len(data) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
linkE := i
// look for title end if present
titleB, titleE := 0, 0
if data[i] == '\'' || data[i] == '"' {
i++
titleB = i
findtitleend:
for i < len(data) {
switch {
case data[i] == '\\':
i += 2
case data[i] == ')':
break findtitleend
default:
i++
}
}
if i >= len(data) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
// skip whitespace after title
titleE = i - 1
for titleE > titleB && isspace(data[titleE]) {
titleE--
}
// check for closing quote presence
if data[titleE] != '\'' && data[titleE] != '"' {
titleB, titleE = 0, 0
linkE = i
}
}
// remove whitespace at the end of the link
for linkE > linkB && isspace(data[linkE-1]) {
linkE--
}
// remove optional angle brackets around the link
if data[linkB] == '<' {
linkB++
}
if data[linkE-1] == '>' {
linkE--
}
// build escaped link and title
if linkE > linkB {
link = data[linkB:linkE]
}
if titleE > titleB {
title = data[titleB:titleE]
}
i++
// reference style link
case isReferenceStyleLink(data, i, t):
var id []byte
altContentConsidered := false
// look for the id
i++
linkB := i
for i < len(data) && data[i] != ']' {
i++
}
if i >= len(data) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
linkE := i
// find the reference
if linkB == linkE {
if textHasNl {
var b bytes.Buffer
for j := 1; j < txtE; j++ {
switch {
case data[j] != '\n':
b.WriteByte(data[j])
case data[j-1] != ' ':
b.WriteByte(' ')
}
}
id = b.Bytes()
} else {
id = data[1:txtE]
altContentConsidered = true
}
} else {
id = data[linkB:linkE]
}
// find the reference with matching id
lr, ok := p.getRef(string(id))
if !ok {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
// keep link and title from reference
link = lr.link
title = lr.title
if altContentConsidered {
altContent = lr.text
}
i++
// shortcut reference style link or reference or inline footnote
default:
var id []byte
// craft the id
if textHasNl {
var b bytes.Buffer
for j := 1; j < txtE; j++ {
switch {
case data[j] != '\n':
b.WriteByte(data[j])
case data[j-1] != ' ':
b.WriteByte(' ')
}
}
id = b.Bytes()
} else {
if t == linkDeferredFootnote {
id = data[2:txtE] // get rid of the ^
} else {
id = data[1:txtE]
}
}
2017-12-13 18:43:58 +00:00
footnoteNode = NewNode(Item)
2017-05-20 22:43:42 +00:00
if t == linkInlineFootnote {
// create a new reference
2017-12-13 18:43:58 +00:00
noteID = len(p.notes) + 1
2017-05-20 22:43:42 +00:00
var fragment []byte
if len(id) > 0 {
if len(id) < 16 {
fragment = make([]byte, len(id))
} else {
fragment = make([]byte, 16)
}
copy(fragment, slugify(id))
} else {
2017-12-13 18:43:58 +00:00
fragment = append([]byte("footnote-"), []byte(strconv.Itoa(noteID))...)
2017-05-20 22:43:42 +00:00
}
ref := &reference{
2017-12-13 18:43:58 +00:00
noteID: noteID,
2017-05-20 22:43:42 +00:00
hasBlock: false,
link: fragment,
title: id,
2017-12-13 18:43:58 +00:00
footnote: footnoteNode,
2017-05-20 22:43:42 +00:00
}
p.notes = append(p.notes, ref)
link = ref.link
title = ref.title
} else {
// find the reference with matching id
lr, ok := p.getRef(string(id))
if !ok {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
if t == linkDeferredFootnote {
2017-12-13 18:43:58 +00:00
lr.noteID = len(p.notes) + 1
lr.footnote = footnoteNode
2017-05-20 22:43:42 +00:00
p.notes = append(p.notes, lr)
}
// keep link and title from reference
link = lr.link
// if inline footnote, title == footnote contents
title = lr.title
2017-12-13 18:43:58 +00:00
noteID = lr.noteID
2017-05-20 22:43:42 +00:00
}
// rewind the whitespace
i = txtE + 1
}
var uLink []byte
if t == linkNormal || t == linkImg {
if len(link) > 0 {
var uLinkBuf bytes.Buffer
unescapeText(&uLinkBuf, link)
uLink = uLinkBuf.Bytes()
}
// links need something to click on and somewhere to go
2017-12-13 18:43:58 +00:00
if len(uLink) == 0 || (t == linkNormal && txtE <= 1) {
return 0, nil
2017-05-20 22:43:42 +00:00
}
}
// call the relevant rendering function
2017-12-13 18:43:58 +00:00
var linkNode *Node
2017-05-20 22:43:42 +00:00
switch t {
case linkNormal:
2017-12-13 18:43:58 +00:00
linkNode = NewNode(Link)
linkNode.Destination = normalizeURI(uLink)
linkNode.Title = title
2017-05-20 22:43:42 +00:00
if len(altContent) > 0 {
2017-12-13 18:43:58 +00:00
linkNode.AppendChild(text(altContent))
2017-05-20 22:43:42 +00:00
} else {
2017-12-13 18:43:58 +00:00
// links cannot contain other links, so turn off link parsing
// temporarily and recurse
insideLink := p.insideLink
p.insideLink = true
p.inline(linkNode, data[1:txtE])
p.insideLink = insideLink
2017-05-20 22:43:42 +00:00
}
case linkImg:
2017-12-13 18:43:58 +00:00
linkNode = NewNode(Image)
linkNode.Destination = uLink
linkNode.Title = title
linkNode.AppendChild(text(data[1:txtE]))
i++
2017-05-20 22:43:42 +00:00
2017-12-13 18:43:58 +00:00
case linkInlineFootnote, linkDeferredFootnote:
linkNode = NewNode(Link)
linkNode.Destination = link
linkNode.Title = title
linkNode.NoteID = noteID
linkNode.Footnote = footnoteNode
if t == linkInlineFootnote {
i++
2017-05-20 22:43:42 +00:00
}
default:
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return i, linkNode
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
func (p *Markdown) inlineHTMLComment(data []byte) int {
2017-05-20 22:43:42 +00:00
if len(data) < 5 {
return 0
}
if data[0] != '<' || data[1] != '!' || data[2] != '-' || data[3] != '-' {
return 0
}
i := 5
// scan for an end-of-comment marker, across lines if necessary
for i < len(data) && !(data[i-2] == '-' && data[i-1] == '-' && data[i] == '>') {
i++
}
// no end-of-comment marker
if i >= len(data) {
return 0
}
return i + 1
}
2017-12-13 18:43:58 +00:00
func stripMailto(link []byte) []byte {
if bytes.HasPrefix(link, []byte("mailto://")) {
return link[9:]
} else if bytes.HasPrefix(link, []byte("mailto:")) {
return link[7:]
} else {
return link
}
}
// autolinkType specifies a kind of autolink that gets detected.
type autolinkType int
// These are the possible flag values for the autolink renderer.
const (
notAutolink autolinkType = iota
normalAutolink
emailAutolink
)
2017-05-20 22:43:42 +00:00
// '<' when tags or autolinks are allowed
2017-12-13 18:43:58 +00:00
func leftAngle(p *Markdown, data []byte, offset int) (int, *Node) {
2017-05-20 22:43:42 +00:00
data = data[offset:]
2017-12-13 18:43:58 +00:00
altype, end := tagLength(data)
if size := p.inlineHTMLComment(data); size > 0 {
2017-05-20 22:43:42 +00:00
end = size
}
if end > 2 {
2017-12-13 18:43:58 +00:00
if altype != notAutolink {
2017-05-20 22:43:42 +00:00
var uLink bytes.Buffer
unescapeText(&uLink, data[1:end+1-2])
if uLink.Len() > 0 {
2017-12-13 18:43:58 +00:00
link := uLink.Bytes()
node := NewNode(Link)
node.Destination = link
if altype == emailAutolink {
node.Destination = append([]byte("mailto:"), link...)
}
node.AppendChild(text(stripMailto(link)))
return end, node
2017-05-20 22:43:42 +00:00
}
} else {
2017-12-13 18:43:58 +00:00
htmlTag := NewNode(HTMLSpan)
htmlTag.Literal = data[:end]
return end, htmlTag
2017-05-20 22:43:42 +00:00
}
}
2017-12-13 18:43:58 +00:00
return end, nil
2017-05-20 22:43:42 +00:00
}
// '\\' backslash escape
var escapeChars = []byte("\\`*_{}[]()#+-.!:|&<>~")
2017-12-13 18:43:58 +00:00
func escape(p *Markdown, data []byte, offset int) (int, *Node) {
2017-05-20 22:43:42 +00:00
data = data[offset:]
if len(data) > 1 {
2017-12-13 18:43:58 +00:00
if p.extensions&BackslashLineBreak != 0 && data[1] == '\n' {
return 2, NewNode(Hardbreak)
}
2017-05-20 22:43:42 +00:00
if bytes.IndexByte(escapeChars, data[1]) < 0 {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return 2, text(data[1:2])
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return 2, nil
2017-05-20 22:43:42 +00:00
}
func unescapeText(ob *bytes.Buffer, src []byte) {
i := 0
for i < len(src) {
org := i
for i < len(src) && src[i] != '\\' {
i++
}
if i > org {
ob.Write(src[org:i])
}
if i+1 >= len(src) {
break
}
ob.WriteByte(src[i+1])
i += 2
}
}
// '&' escaped when it doesn't belong to an entity
// valid entities are assumed to be anything matching &#?[A-Za-z0-9]+;
2017-12-13 18:43:58 +00:00
func entity(p *Markdown, data []byte, offset int) (int, *Node) {
2017-05-20 22:43:42 +00:00
data = data[offset:]
end := 1
if end < len(data) && data[end] == '#' {
end++
}
for end < len(data) && isalnum(data[end]) {
end++
}
if end < len(data) && data[end] == ';' {
end++ // real entity
} else {
2017-12-13 18:43:58 +00:00
return 0, nil // lone '&'
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
ent := data[:end]
// undo &amp; escaping or it will be converted to &amp;amp; by another
// escaper in the renderer
if bytes.Equal(ent, []byte("&amp;")) {
ent = []byte{'&'}
}
2017-05-20 22:43:42 +00:00
2017-12-13 18:43:58 +00:00
return end, text(ent)
2017-05-20 22:43:42 +00:00
}
func linkEndsWithEntity(data []byte, linkEnd int) bool {
2017-12-13 18:43:58 +00:00
entityRanges := htmlEntityRe.FindAllIndex(data[:linkEnd], -1)
2017-05-20 22:43:42 +00:00
return entityRanges != nil && entityRanges[len(entityRanges)-1][1] == linkEnd
}
2017-12-13 18:43:58 +00:00
// hasPrefixCaseInsensitive is a custom implementation of
// strings.HasPrefix(strings.ToLower(s), prefix)
// we rolled our own because ToLower pulls in a huge machinery of lowercasing
// anything from Unicode and that's very slow. Since this func will only be
// used on ASCII protocol prefixes, we can take shortcuts.
func hasPrefixCaseInsensitive(s, prefix []byte) bool {
if len(s) < len(prefix) {
return false
}
delta := byte('a' - 'A')
for i, b := range prefix {
if b != s[i] && b != s[i]+delta {
return false
}
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return true
}
2017-05-20 22:43:42 +00:00
2017-12-13 18:43:58 +00:00
var protocolPrefixes = [][]byte{
[]byte("http://"),
[]byte("https://"),
[]byte("ftp://"),
[]byte("file://"),
[]byte("mailto:"),
}
const shortestPrefix = 6 // len("ftp://"), the shortest of the above
func maybeAutoLink(p *Markdown, data []byte, offset int) (int, *Node) {
// quick check to rule out most false hits
if p.insideLink || len(data) < offset+shortestPrefix {
return 0, nil
}
for _, prefix := range protocolPrefixes {
endOfHead := offset + 8 // 8 is the len() of the longest prefix
if endOfHead > len(data) {
endOfHead = len(data)
}
if hasPrefixCaseInsensitive(data[offset:endOfHead], prefix) {
return autoLink(p, data, offset)
}
}
return 0, nil
}
func autoLink(p *Markdown, data []byte, offset int) (int, *Node) {
2017-05-20 22:43:42 +00:00
// Now a more expensive check to see if we're not inside an anchor element
anchorStart := offset
offsetFromAnchor := 0
for anchorStart > 0 && data[anchorStart] != '<' {
anchorStart--
offsetFromAnchor++
}
anchorStr := anchorRe.Find(data[anchorStart:])
if anchorStr != nil {
2017-12-13 18:43:58 +00:00
anchorClose := NewNode(HTMLSpan)
anchorClose.Literal = anchorStr[offsetFromAnchor:]
return len(anchorStr) - offsetFromAnchor, anchorClose
2017-05-20 22:43:42 +00:00
}
// scan backward for a word boundary
rewind := 0
for offset-rewind > 0 && rewind <= 7 && isletter(data[offset-rewind-1]) {
rewind++
}
if rewind > 6 { // longest supported protocol is "mailto" which has 6 letters
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
origData := data
data = data[offset-rewind:]
if !isSafeLink(data) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
linkEnd := 0
for linkEnd < len(data) && !isEndOfLink(data[linkEnd]) {
linkEnd++
}
// Skip punctuation at the end of the link
if (data[linkEnd-1] == '.' || data[linkEnd-1] == ',') && data[linkEnd-2] != '\\' {
linkEnd--
}
// But don't skip semicolon if it's a part of escaped entity:
if data[linkEnd-1] == ';' && data[linkEnd-2] != '\\' && !linkEndsWithEntity(data, linkEnd) {
linkEnd--
}
// See if the link finishes with a punctuation sign that can be closed.
var copen byte
switch data[linkEnd-1] {
case '"':
copen = '"'
case '\'':
copen = '\''
case ')':
copen = '('
case ']':
copen = '['
case '}':
copen = '{'
default:
copen = 0
}
if copen != 0 {
bufEnd := offset - rewind + linkEnd - 2
openDelim := 1
/* Try to close the final punctuation sign in this same line;
* if we managed to close it outside of the URL, that means that it's
* not part of the URL. If it closes inside the URL, that means it
* is part of the URL.
*
* Examples:
*
* foo http://www.pokemon.com/Pikachu_(Electric) bar
* => http://www.pokemon.com/Pikachu_(Electric)
*
* foo (http://www.pokemon.com/Pikachu_(Electric)) bar
* => http://www.pokemon.com/Pikachu_(Electric)
*
* foo http://www.pokemon.com/Pikachu_(Electric)) bar
* => http://www.pokemon.com/Pikachu_(Electric))
*
* (foo http://www.pokemon.com/Pikachu_(Electric)) bar
* => foo http://www.pokemon.com/Pikachu_(Electric)
*/
for bufEnd >= 0 && origData[bufEnd] != '\n' && openDelim != 0 {
if origData[bufEnd] == data[linkEnd-1] {
openDelim++
}
if origData[bufEnd] == copen {
openDelim--
}
bufEnd--
}
if openDelim == 0 {
linkEnd--
}
}
var uLink bytes.Buffer
unescapeText(&uLink, data[:linkEnd])
if uLink.Len() > 0 {
2017-12-13 18:43:58 +00:00
node := NewNode(Link)
node.Destination = uLink.Bytes()
node.AppendChild(text(uLink.Bytes()))
return linkEnd, node
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return linkEnd, nil
2017-05-20 22:43:42 +00:00
}
func isEndOfLink(char byte) bool {
return isspace(char) || char == '<'
}
var validUris = [][]byte{[]byte("http://"), []byte("https://"), []byte("ftp://"), []byte("mailto://")}
var validPaths = [][]byte{[]byte("/"), []byte("./"), []byte("../")}
func isSafeLink(link []byte) bool {
for _, path := range validPaths {
if len(link) >= len(path) && bytes.Equal(link[:len(path)], path) {
if len(link) == len(path) {
return true
} else if isalnum(link[len(path)]) {
return true
}
}
}
for _, prefix := range validUris {
// TODO: handle unicode here
// case-insensitive prefix test
if len(link) > len(prefix) && bytes.Equal(bytes.ToLower(link[:len(prefix)]), prefix) && isalnum(link[len(prefix)]) {
return true
}
}
return false
}
// return the length of the given tag, or 0 is it's not valid
2017-12-13 18:43:58 +00:00
func tagLength(data []byte) (autolink autolinkType, end int) {
2017-05-20 22:43:42 +00:00
var i, j int
// a valid tag can't be shorter than 3 chars
if len(data) < 3 {
2017-12-13 18:43:58 +00:00
return notAutolink, 0
2017-05-20 22:43:42 +00:00
}
// begins with a '<' optionally followed by '/', followed by letter or number
if data[0] != '<' {
2017-12-13 18:43:58 +00:00
return notAutolink, 0
2017-05-20 22:43:42 +00:00
}
if data[1] == '/' {
i = 2
} else {
i = 1
}
if !isalnum(data[i]) {
2017-12-13 18:43:58 +00:00
return notAutolink, 0
2017-05-20 22:43:42 +00:00
}
// scheme test
2017-12-13 18:43:58 +00:00
autolink = notAutolink
2017-05-20 22:43:42 +00:00
// try to find the beginning of an URI
for i < len(data) && (isalnum(data[i]) || data[i] == '.' || data[i] == '+' || data[i] == '-') {
i++
}
if i > 1 && i < len(data) && data[i] == '@' {
if j = isMailtoAutoLink(data[i:]); j != 0 {
2017-12-13 18:43:58 +00:00
return emailAutolink, i + j
2017-05-20 22:43:42 +00:00
}
}
if i > 2 && i < len(data) && data[i] == ':' {
2017-12-13 18:43:58 +00:00
autolink = normalAutolink
2017-05-20 22:43:42 +00:00
i++
}
// complete autolink test: no whitespace or ' or "
switch {
case i >= len(data):
2017-12-13 18:43:58 +00:00
autolink = notAutolink
case autolink != notAutolink:
2017-05-20 22:43:42 +00:00
j = i
for i < len(data) {
if data[i] == '\\' {
i += 2
} else if data[i] == '>' || data[i] == '\'' || data[i] == '"' || isspace(data[i]) {
break
} else {
i++
}
}
if i >= len(data) {
2017-12-13 18:43:58 +00:00
return autolink, 0
2017-05-20 22:43:42 +00:00
}
if i > j && data[i] == '>' {
2017-12-13 18:43:58 +00:00
return autolink, i + 1
2017-05-20 22:43:42 +00:00
}
// one of the forbidden chars has been found
2017-12-13 18:43:58 +00:00
autolink = notAutolink
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
i += bytes.IndexByte(data[i:], '>')
if i < 0 {
return autolink, 0
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return autolink, i + 1
2017-05-20 22:43:42 +00:00
}
// look for the address part of a mail autolink and '>'
// this is less strict than the original markdown e-mail address matching
func isMailtoAutoLink(data []byte) int {
nb := 0
// address is assumed to be: [-@._a-zA-Z0-9]+ with exactly one '@'
for i := 0; i < len(data); i++ {
if isalnum(data[i]) {
continue
}
switch data[i] {
case '@':
nb++
case '-', '.', '_':
2017-12-13 18:43:58 +00:00
break
2017-05-20 22:43:42 +00:00
case '>':
if nb == 1 {
return i + 1
}
2017-12-13 18:43:58 +00:00
return 0
2017-05-20 22:43:42 +00:00
default:
return 0
}
}
return 0
}
// look for the next emph char, skipping other constructs
func helperFindEmphChar(data []byte, c byte) int {
i := 0
for i < len(data) {
for i < len(data) && data[i] != c && data[i] != '`' && data[i] != '[' {
i++
}
if i >= len(data) {
return 0
}
// do not count escaped chars
if i != 0 && data[i-1] == '\\' {
i++
continue
}
if data[i] == c {
return i
}
if data[i] == '`' {
// skip a code span
tmpI := 0
i++
for i < len(data) && data[i] != '`' {
if tmpI == 0 && data[i] == c {
tmpI = i
}
i++
}
if i >= len(data) {
return tmpI
}
i++
} else if data[i] == '[' {
// skip a link
tmpI := 0
i++
for i < len(data) && data[i] != ']' {
if tmpI == 0 && data[i] == c {
tmpI = i
}
i++
}
i++
for i < len(data) && (data[i] == ' ' || data[i] == '\n') {
i++
}
if i >= len(data) {
return tmpI
}
if data[i] != '[' && data[i] != '(' { // not a link
if tmpI > 0 {
return tmpI
}
2017-12-13 18:43:58 +00:00
continue
2017-05-20 22:43:42 +00:00
}
cc := data[i]
i++
for i < len(data) && data[i] != cc {
if tmpI == 0 && data[i] == c {
return i
}
i++
}
if i >= len(data) {
return tmpI
}
i++
}
}
return 0
}
2017-12-13 18:43:58 +00:00
func helperEmphasis(p *Markdown, data []byte, c byte) (int, *Node) {
2017-05-20 22:43:42 +00:00
i := 0
// skip one symbol if coming from emph3
if len(data) > 1 && data[0] == c && data[1] == c {
i = 1
}
for i < len(data) {
length := helperFindEmphChar(data[i:], c)
if length == 0 {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
i += length
if i >= len(data) {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
if i+1 < len(data) && data[i+1] == c {
i++
continue
}
if data[i] == c && !isspace(data[i-1]) {
2017-12-13 18:43:58 +00:00
if p.extensions&NoIntraEmphasis != 0 {
2017-05-20 22:43:42 +00:00
if !(i+1 == len(data) || isspace(data[i+1]) || ispunct(data[i+1])) {
continue
}
}
2017-12-13 18:43:58 +00:00
emph := NewNode(Emph)
p.inline(emph, data[:i])
return i + 1, emph
2017-05-20 22:43:42 +00:00
}
}
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
func helperDoubleEmphasis(p *Markdown, data []byte, c byte) (int, *Node) {
2017-05-20 22:43:42 +00:00
i := 0
for i < len(data) {
length := helperFindEmphChar(data[i:], c)
if length == 0 {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
i += length
if i+1 < len(data) && data[i] == c && data[i+1] == c && i > 0 && !isspace(data[i-1]) {
2017-12-13 18:43:58 +00:00
nodeType := Strong
if c == '~' {
nodeType = Del
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
node := NewNode(nodeType)
p.inline(node, data[:i])
return i + 2, node
2017-05-20 22:43:42 +00:00
}
i++
}
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
func helperTripleEmphasis(p *Markdown, data []byte, offset int, c byte) (int, *Node) {
2017-05-20 22:43:42 +00:00
i := 0
origData := data
data = data[offset:]
for i < len(data) {
length := helperFindEmphChar(data[i:], c)
if length == 0 {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
i += length
// skip whitespace preceded symbols
if data[i] != c || isspace(data[i-1]) {
continue
}
switch {
case i+2 < len(data) && data[i+1] == c && data[i+2] == c:
// triple symbol found
2017-12-13 18:43:58 +00:00
strong := NewNode(Strong)
em := NewNode(Emph)
strong.AppendChild(em)
p.inline(em, data[:i])
return i + 3, strong
2017-05-20 22:43:42 +00:00
case (i+1 < len(data) && data[i+1] == c):
// double symbol found, hand over to emph1
2017-12-13 18:43:58 +00:00
length, node := helperEmphasis(p, origData[offset-2:], c)
2017-05-20 22:43:42 +00:00
if length == 0 {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return length - 2, node
2017-05-20 22:43:42 +00:00
default:
// single symbol found, hand over to emph2
2017-12-13 18:43:58 +00:00
length, node := helperDoubleEmphasis(p, origData[offset-1:], c)
2017-05-20 22:43:42 +00:00
if length == 0 {
2017-12-13 18:43:58 +00:00
return 0, nil
2017-05-20 22:43:42 +00:00
}
2017-12-13 18:43:58 +00:00
return length - 1, node
2017-05-20 22:43:42 +00:00
}
}
2017-12-13 18:43:58 +00:00
return 0, nil
}
func text(s []byte) *Node {
node := NewNode(Text)
node.Literal = s
return node
}
func normalizeURI(s []byte) []byte {
return s // TODO: implement
2017-05-20 22:43:42 +00:00
}