| 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 inline elements. |
| 12 |
// |
| 13 |
|
| 14 |
package blackfriday |
| 15 |
|
| 16 |
import ( |
| 17 |
"bytes" |
| 18 |
"regexp" |
| 19 |
"strconv" |
| 20 |
) |
| 21 |
|
| 22 |
var ( |
| 23 |
urlRe = `((https?|ftp):\/\/|\/)[-A-Za-z0-9+&@#\/%?=~_|!:,.;\(\)]+` |
| 24 |
anchorRe = regexp.MustCompile(`^(<a\shref="` + urlRe + `"(\stitle="[^"<>]+")?\s?>` + urlRe + `<\/a>)`) |
| 25 |
|
| 26 |
// https://www.w3.org/TR/html5/syntax.html#character-references |
| 27 |
// highest unicode code point in 17 planes (2^20): 1,114,112d = |
| 28 |
// 7 dec digits or 6 hex digits |
| 29 |
// named entity references can be 2-31 characters with stuff like < |
| 30 |
// at one end and ∳ at the other. There |
| 31 |
// are also sometimes numbers at the end, although this isn't inherent |
| 32 |
// in the specification; there are never numbers anywhere else in |
| 33 |
// current character references, though; see ¾ and ▒, etc. |
| 34 |
// https://www.w3.org/TR/html5/syntax.html#named-character-references |
| 35 |
// |
| 36 |
// entity := "&" (named group | number ref) ";" |
| 37 |
// named group := [a-zA-Z]{2,31}[0-9]{0,2} |
| 38 |
// number ref := "#" (dec ref | hex ref) |
| 39 |
// dec ref := [0-9]{1,7} |
| 40 |
// hex ref := ("x" | "X") [0-9a-fA-F]{1,6} |
| 41 |
htmlEntityRe = regexp.MustCompile(`&([a-zA-Z]{2,31}[0-9]{0,2}|#([0-9]{1,7}|[xX][0-9a-fA-F]{1,6}));`) |
| 42 |
) |
| 43 |
|
| 44 |
// Functions to parse text within a block |
| 45 |
// Each function returns the number of chars taken care of |
| 46 |
// data is the complete block being rendered |
| 47 |
// offset is the number of valid chars before the current cursor |
| 48 |
|
| 49 |
func (p *Markdown) inline(currBlock *Node, data []byte) { |
| 50 |
// handlers might call us recursively: enforce a maximum depth |
| 51 |
if p.nesting >= p.maxNesting || len(data) == 0 { |
| 52 |
return |
| 53 |
} |
| 54 |
p.nesting++ |
| 55 |
beg, end := 0, 0 |
| 56 |
for end < len(data) { |
| 57 |
handler := p.inlineCallback[data[end]] |
| 58 |
if handler != nil { |
| 59 |
if consumed, node := handler(p, data, end); consumed == 0 { |
| 60 |
// No action from the callback. |
| 61 |
end++ |
| 62 |
} else { |
| 63 |
// Copy inactive chars into the output. |
| 64 |
currBlock.AppendChild(text(data[beg:end])) |
| 65 |
if node != nil { |
| 66 |
currBlock.AppendChild(node) |
| 67 |
} |
| 68 |
// Skip past whatever the callback used. |
| 69 |
beg = end + consumed |
| 70 |
end = beg |
| 71 |
} |
| 72 |
} else { |
| 73 |
end++ |
| 74 |
} |
| 75 |
} |
| 76 |
if beg < len(data) { |
| 77 |
if data[end-1] == '\n' { |
| 78 |
end-- |
| 79 |
} |
| 80 |
currBlock.AppendChild(text(data[beg:end])) |
| 81 |
} |
| 82 |
p.nesting-- |
| 83 |
} |
| 84 |
|
| 85 |
// single and double emphasis parsing |
| 86 |
func emphasis(p *Markdown, data []byte, offset int) (int, *Node) { |
| 87 |
data = data[offset:] |
| 88 |
c := data[0] |
| 89 |
|
| 90 |
if len(data) > 2 && data[1] != c { |
| 91 |
// whitespace cannot follow an opening emphasis; |
| 92 |
// strikethrough only takes two characters '~~' |
| 93 |
if c == '~' || isspace(data[1]) { |
| 94 |
return 0, nil |
| 95 |
} |
| 96 |
ret, node := helperEmphasis(p, data[1:], c) |
| 97 |
if ret == 0 { |
| 98 |
return 0, nil |
| 99 |
} |
| 100 |
|
| 101 |
return ret + 1, node |
| 102 |
} |
| 103 |
|
| 104 |
if len(data) > 3 && data[1] == c && data[2] != c { |
| 105 |
if isspace(data[2]) { |
| 106 |
return 0, nil |
| 107 |
} |
| 108 |
ret, node := helperDoubleEmphasis(p, data[2:], c) |
| 109 |
if ret == 0 { |
| 110 |
return 0, nil |
| 111 |
} |
| 112 |
|
| 113 |
return ret + 2, node |
| 114 |
} |
| 115 |
|
| 116 |
if len(data) > 4 && data[1] == c && data[2] == c && data[3] != c { |
| 117 |
if c == '~' || isspace(data[3]) { |
| 118 |
return 0, nil |
| 119 |
} |
| 120 |
ret, node := helperTripleEmphasis(p, data, 3, c) |
| 121 |
if ret == 0 { |
| 122 |
return 0, nil |
| 123 |
} |
| 124 |
|
| 125 |
return ret + 3, node |
| 126 |
} |
| 127 |
|
| 128 |
return 0, nil |
| 129 |
} |
| 130 |
|
| 131 |
func codeSpan(p *Markdown, data []byte, offset int) (int, *Node) { |
| 132 |
data = data[offset:] |
| 133 |
|
| 134 |
nb := 0 |
| 135 |
|
| 136 |
// count the number of backticks in the delimiter |
| 137 |
for nb < len(data) && data[nb] == '`' { |
| 138 |
nb++ |
| 139 |
} |
| 140 |
|
| 141 |
// find the next delimiter |
| 142 |
i, end := 0, 0 |
| 143 |
for end = nb; end < len(data) && i < nb; end++ { |
| 144 |
if data[end] == '`' { |
| 145 |
i++ |
| 146 |
} else { |
| 147 |
i = 0 |
| 148 |
} |
| 149 |
} |
| 150 |
|
| 151 |
// no matching delimiter? |
| 152 |
if i < nb && end >= len(data) { |
| 153 |
return 0, nil |
| 154 |
} |
| 155 |
|
| 156 |
// trim outside whitespace |
| 157 |
fBegin := nb |
| 158 |
for fBegin < end && data[fBegin] == ' ' { |
| 159 |
fBegin++ |
| 160 |
} |
| 161 |
|
| 162 |
fEnd := end - nb |
| 163 |
for fEnd > fBegin && data[fEnd-1] == ' ' { |
| 164 |
fEnd-- |
| 165 |
} |
| 166 |
|
| 167 |
// render the code span |
| 168 |
if fBegin != fEnd { |
| 169 |
code := NewNode(Code) |
| 170 |
code.Literal = data[fBegin:fEnd] |
| 171 |
return end, code |
| 172 |
} |
| 173 |
|
| 174 |
return end, nil |
| 175 |
} |
| 176 |
|
| 177 |
// newline preceded by two spaces becomes <br> |
| 178 |
func maybeLineBreak(p *Markdown, data []byte, offset int) (int, *Node) { |
| 179 |
origOffset := offset |
| 180 |
for offset < len(data) && data[offset] == ' ' { |
| 181 |
offset++ |
| 182 |
} |
| 183 |
|
| 184 |
if offset < len(data) && data[offset] == '\n' { |
| 185 |
if offset-origOffset >= 2 { |
| 186 |
return offset - origOffset + 1, NewNode(Hardbreak) |
| 187 |
} |
| 188 |
return offset - origOffset, nil |
| 189 |
} |
| 190 |
return 0, nil |
| 191 |
} |
| 192 |
|
| 193 |
// newline without two spaces works when HardLineBreak is enabled |
| 194 |
func lineBreak(p *Markdown, data []byte, offset int) (int, *Node) { |
| 195 |
if p.extensions&HardLineBreak != 0 { |
| 196 |
return 1, NewNode(Hardbreak) |
| 197 |
} |
| 198 |
return 0, nil |
| 199 |
} |
| 200 |
|
| 201 |
type linkType int |
| 202 |
|
| 203 |
const ( |
| 204 |
linkNormal linkType = iota |
| 205 |
linkImg |
| 206 |
linkDeferredFootnote |
| 207 |
linkInlineFootnote |
| 208 |
) |
| 209 |
|
| 210 |
func isReferenceStyleLink(data []byte, pos int, t linkType) bool { |
| 211 |
if t == linkDeferredFootnote { |
| 212 |
return false |
| 213 |
} |
| 214 |
return pos < len(data)-1 && data[pos] == '[' && data[pos+1] != '^' |
| 215 |
} |
| 216 |
|
| 217 |
func maybeImage(p *Markdown, data []byte, offset int) (int, *Node) { |
| 218 |
if offset < len(data)-1 && data[offset+1] == '[' { |
| 219 |
return link(p, data, offset) |
| 220 |
} |
| 221 |
return 0, nil |
| 222 |
} |
| 223 |
|
| 224 |
func maybeInlineFootnote(p *Markdown, data []byte, offset int) (int, *Node) { |
| 225 |
if offset < len(data)-1 && data[offset+1] == '[' { |
| 226 |
return link(p, data, offset) |
| 227 |
} |
| 228 |
return 0, nil |
| 229 |
} |
| 230 |
|
| 231 |
// '[': parse a link or an image or a footnote |
| 232 |
func link(p *Markdown, data []byte, offset int) (int, *Node) { |
| 233 |
// no links allowed inside regular links, footnote, and deferred footnotes |
| 234 |
if p.insideLink && (offset > 0 && data[offset-1] == '[' || len(data)-1 > offset && data[offset+1] == '^') { |
| 235 |
return 0, nil |
| 236 |
} |
| 237 |
|
| 238 |
var t linkType |
| 239 |
switch { |
| 240 |
// special case: ![^text] == deferred footnote (that follows something with |
| 241 |
// an exclamation point) |
| 242 |
case p.extensions&Footnotes != 0 && len(data)-1 > offset && data[offset+1] == '^': |
| 243 |
t = linkDeferredFootnote |
| 244 |
// ![alt] == image |
| 245 |
case offset >= 0 && data[offset] == '!': |
| 246 |
t = linkImg |
| 247 |
offset++ |
| 248 |
// ^[text] == inline footnote |
| 249 |
// [^refId] == deferred footnote |
| 250 |
case p.extensions&Footnotes != 0: |
| 251 |
if offset >= 0 && data[offset] == '^' { |
| 252 |
t = linkInlineFootnote |
| 253 |
offset++ |
| 254 |
} else if len(data)-1 > offset && data[offset+1] == '^' { |
| 255 |
t = linkDeferredFootnote |
| 256 |
} |
| 257 |
// [text] == regular link |
| 258 |
default: |
| 259 |
t = linkNormal |
| 260 |
} |
| 261 |
|
| 262 |
data = data[offset:] |
| 263 |
|
| 264 |
var ( |
| 265 |
i = 1 |
| 266 |
noteID int |
| 267 |
title, link, altContent []byte |
| 268 |
textHasNl = false |
| 269 |
) |
| 270 |
|
| 271 |
if t == linkDeferredFootnote { |
| 272 |
i++ |
| 273 |
} |
| 274 |
|
| 275 |
// look for the matching closing bracket |
| 276 |
for level := 1; level > 0 && i < len(data); i++ { |
| 277 |
switch { |
| 278 |
case data[i] == '\n': |
| 279 |
textHasNl = true |
| 280 |
|
| 281 |
case isBackslashEscaped(data, i): |
| 282 |
continue |
| 283 |
|
| 284 |
case data[i] == '[': |
| 285 |
level++ |
| 286 |
|
| 287 |
case data[i] == ']': |
| 288 |
level-- |
| 289 |
if level <= 0 { |
| 290 |
i-- // compensate for extra i++ in for loop |
| 291 |
} |
| 292 |
} |
| 293 |
} |
| 294 |
|
| 295 |
if i >= len(data) { |
| 296 |
return 0, nil |
| 297 |
} |
| 298 |
|
| 299 |
txtE := i |
| 300 |
i++ |
| 301 |
var footnoteNode *Node |
| 302 |
|
| 303 |
// skip any amount of whitespace or newline |
| 304 |
// (this is much more lax than original markdown syntax) |
| 305 |
for i < len(data) && isspace(data[i]) { |
| 306 |
i++ |
| 307 |
} |
| 308 |
|
| 309 |
// inline style link |
| 310 |
switch { |
| 311 |
case i < len(data) && data[i] == '(': |
| 312 |
// skip initial whitespace |
| 313 |
i++ |
| 314 |
|
| 315 |
for i < len(data) && isspace(data[i]) { |
| 316 |
i++ |
| 317 |
} |
| 318 |
|
| 319 |
linkB := i |
| 320 |
|
| 321 |
// look for link end: ' " ) |
| 322 |
findlinkend: |
| 323 |
for i < len(data) { |
| 324 |
switch { |
| 325 |
case data[i] == '\\': |
| 326 |
i += 2 |
| 327 |
|
| 328 |
case data[i] == ')' || data[i] == '\'' || data[i] == '"': |
| 329 |
break findlinkend |
| 330 |
|
| 331 |
default: |
| 332 |
i++ |
| 333 |
} |
| 334 |
} |
| 335 |
|
| 336 |
if i >= len(data) { |
| 337 |
return 0, nil |
| 338 |
} |
| 339 |
linkE := i |
| 340 |
|
| 341 |
// look for title end if present |
| 342 |
titleB, titleE := 0, 0 |
| 343 |
if data[i] == '\'' || data[i] == '"' { |
| 344 |
i++ |
| 345 |
titleB = i |
| 346 |
|
| 347 |
findtitleend: |
| 348 |
for i < len(data) { |
| 349 |
switch { |
| 350 |
case data[i] == '\\': |
| 351 |
i += 2 |
| 352 |
|
| 353 |
case data[i] == ')': |
| 354 |
break findtitleend |
| 355 |
|
| 356 |
default: |
| 357 |
i++ |
| 358 |
} |
| 359 |
} |
| 360 |
|
| 361 |
if i >= len(data) { |
| 362 |
return 0, nil |
| 363 |
} |
| 364 |
|
| 365 |
// skip whitespace after title |
| 366 |
titleE = i - 1 |
| 367 |
for titleE > titleB && isspace(data[titleE]) { |
| 368 |
titleE-- |
| 369 |
} |
| 370 |
|
| 371 |
// check for closing quote presence |
| 372 |
if data[titleE] != '\'' && data[titleE] != '"' { |
| 373 |
titleB, titleE = 0, 0 |
| 374 |
linkE = i |
| 375 |
} |
| 376 |
} |
| 377 |
|
| 378 |
// remove whitespace at the end of the link |
| 379 |
for linkE > linkB && isspace(data[linkE-1]) { |
| 380 |
linkE-- |
| 381 |
} |
| 382 |
|
| 383 |
// remove optional angle brackets around the link |
| 384 |
if data[linkB] == '<' { |
| 385 |
linkB++ |
| 386 |
} |
| 387 |
if data[linkE-1] == '>' { |
| 388 |
linkE-- |
| 389 |
} |
| 390 |
|
| 391 |
// build escaped link and title |
| 392 |
if linkE > linkB { |
| 393 |
link = data[linkB:linkE] |
| 394 |
} |
| 395 |
|
| 396 |
if titleE > titleB { |
| 397 |
title = data[titleB:titleE] |
| 398 |
} |
| 399 |
|
| 400 |
i++ |
| 401 |
|
| 402 |
// reference style link |
| 403 |
case isReferenceStyleLink(data, i, t): |
| 404 |
var id []byte |
| 405 |
altContentConsidered := false |
| 406 |
|
| 407 |
// look for the id |
| 408 |
i++ |
| 409 |
linkB := i |
| 410 |
for i < len(data) && data[i] != ']' { |
| 411 |
i++ |
| 412 |
} |
| 413 |
if i >= len(data) { |
| 414 |
return 0, nil |
| 415 |
} |
| 416 |
linkE := i |
| 417 |
|
| 418 |
// find the reference |
| 419 |
if linkB == linkE { |
| 420 |
if textHasNl { |
| 421 |
var b bytes.Buffer |
| 422 |
|
| 423 |
for j := 1; j < txtE; j++ { |
| 424 |
switch { |
| 425 |
case data[j] != '\n': |
| 426 |
b.WriteByte(data[j]) |
| 427 |
case data[j-1] != ' ': |
| 428 |
b.WriteByte(' ') |
| 429 |
} |
| 430 |
} |
| 431 |
|
| 432 |
id = b.Bytes() |
| 433 |
} else { |
| 434 |
id = data[1:txtE] |
| 435 |
altContentConsidered = true |
| 436 |
} |
| 437 |
} else { |
| 438 |
id = data[linkB:linkE] |
| 439 |
} |
| 440 |
|
| 441 |
// find the reference with matching id |
| 442 |
lr, ok := p.getRef(string(id)) |
| 443 |
if !ok { |
| 444 |
return 0, nil |
| 445 |
} |
| 446 |
|
| 447 |
// keep link and title from reference |
| 448 |
link = lr.link |
| 449 |
title = lr.title |
| 450 |
if altContentConsidered { |
| 451 |
altContent = lr.text |
| 452 |
} |
| 453 |
i++ |
| 454 |
|
| 455 |
// shortcut reference style link or reference or inline footnote |
| 456 |
default: |
| 457 |
var id []byte |
| 458 |
|
| 459 |
// craft the id |
| 460 |
if textHasNl { |
| 461 |
var b bytes.Buffer |
| 462 |
|
| 463 |
for j := 1; j < txtE; j++ { |
| 464 |
switch { |
| 465 |
case data[j] != '\n': |
| 466 |
b.WriteByte(data[j]) |
| 467 |
case data[j-1] != ' ': |
| 468 |
b.WriteByte(' ') |
| 469 |
} |
| 470 |
} |
| 471 |
|
| 472 |
id = b.Bytes() |
| 473 |
} else { |
| 474 |
if t == linkDeferredFootnote { |
| 475 |
id = data[2:txtE] // get rid of the ^ |
| 476 |
} else { |
| 477 |
id = data[1:txtE] |
| 478 |
} |
| 479 |
} |
| 480 |
|
| 481 |
footnoteNode = NewNode(Item) |
| 482 |
if t == linkInlineFootnote { |
| 483 |
// create a new reference |
| 484 |
noteID = len(p.notes) + 1 |
| 485 |
|
| 486 |
var fragment []byte |
| 487 |
if len(id) > 0 { |
| 488 |
if len(id) < 16 { |
| 489 |
fragment = make([]byte, len(id)) |
| 490 |
} else { |
| 491 |
fragment = make([]byte, 16) |
| 492 |
} |
| 493 |
copy(fragment, slugify(id)) |
| 494 |
} else { |
| 495 |
fragment = append([]byte("footnote-"), []byte(strconv.Itoa(noteID))...) |
| 496 |
} |
| 497 |
|
| 498 |
ref := &reference{ |
| 499 |
noteID: noteID, |
| 500 |
hasBlock: false, |
| 501 |
link: fragment, |
| 502 |
title: id, |
| 503 |
footnote: footnoteNode, |
| 504 |
} |
| 505 |
|
| 506 |
p.notes = append(p.notes, ref) |
| 507 |
|
| 508 |
link = ref.link |
| 509 |
title = ref.title |
| 510 |
} else { |
| 511 |
// find the reference with matching id |
| 512 |
lr, ok := p.getRef(string(id)) |
| 513 |
if !ok { |
| 514 |
return 0, nil |
| 515 |
} |
| 516 |
|
| 517 |
if t == linkDeferredFootnote { |
| 518 |
lr.noteID = len(p.notes) + 1 |
| 519 |
lr.footnote = footnoteNode |
| 520 |
p.notes = append(p.notes, lr) |
| 521 |
} |
| 522 |
|
| 523 |
// keep link and title from reference |
| 524 |
link = lr.link |
| 525 |
// if inline footnote, title == footnote contents |
| 526 |
title = lr.title |
| 527 |
noteID = lr.noteID |
| 528 |
} |
| 529 |
|
| 530 |
// rewind the whitespace |
| 531 |
i = txtE + 1 |
| 532 |
} |
| 533 |
|
| 534 |
var uLink []byte |
| 535 |
if t == linkNormal || t == linkImg { |
| 536 |
if len(link) > 0 { |
| 537 |
var uLinkBuf bytes.Buffer |
| 538 |
unescapeText(&uLinkBuf, link) |
| 539 |
uLink = uLinkBuf.Bytes() |
| 540 |
} |
| 541 |
|
| 542 |
// links need something to click on and somewhere to go |
| 543 |
if len(uLink) == 0 || (t == linkNormal && txtE <= 1) { |
| 544 |
return 0, nil |
| 545 |
} |
| 546 |
} |
| 547 |
|
| 548 |
// call the relevant rendering function |
| 549 |
var linkNode *Node |
| 550 |
switch t { |
| 551 |
case linkNormal: |
| 552 |
linkNode = NewNode(Link) |
| 553 |
linkNode.Destination = normalizeURI(uLink) |
| 554 |
linkNode.Title = title |
| 555 |
if len(altContent) > 0 { |
| 556 |
linkNode.AppendChild(text(altContent)) |
| 557 |
} else { |
| 558 |
// links cannot contain other links, so turn off link parsing |
| 559 |
// temporarily and recurse |
| 560 |
insideLink := p.insideLink |
| 561 |
p.insideLink = true |
| 562 |
p.inline(linkNode, data[1:txtE]) |
| 563 |
p.insideLink = insideLink |
| 564 |
} |
| 565 |
|
| 566 |
case linkImg: |
| 567 |
linkNode = NewNode(Image) |
| 568 |
linkNode.Destination = uLink |
| 569 |
linkNode.Title = title |
| 570 |
linkNode.AppendChild(text(data[1:txtE])) |
| 571 |
i++ |
| 572 |
|
| 573 |
case linkInlineFootnote, linkDeferredFootnote: |
| 574 |
linkNode = NewNode(Link) |
| 575 |
linkNode.Destination = link |
| 576 |
linkNode.Title = title |
| 577 |
linkNode.NoteID = noteID |
| 578 |
linkNode.Footnote = footnoteNode |
| 579 |
if t == linkInlineFootnote { |
| 580 |
i++ |
| 581 |
} |
| 582 |
|
| 583 |
default: |
| 584 |
return 0, nil |
| 585 |
} |
| 586 |
|
| 587 |
return i, linkNode |
| 588 |
} |
| 589 |
|
| 590 |
func (p *Markdown) inlineHTMLComment(data []byte) int { |
| 591 |
if len(data) < 5 { |
| 592 |
return 0 |
| 593 |
} |
| 594 |
if data[0] != '<' || data[1] != '!' || data[2] != '-' || data[3] != '-' { |
| 595 |
return 0 |
| 596 |
} |
| 597 |
i := 5 |
| 598 |
// scan for an end-of-comment marker, across lines if necessary |
| 599 |
for i < len(data) && !(data[i-2] == '-' && data[i-1] == '-' && data[i] == '>') { |
| 600 |
i++ |
| 601 |
} |
| 602 |
// no end-of-comment marker |
| 603 |
if i >= len(data) { |
| 604 |
return 0 |
| 605 |
} |
| 606 |
return i + 1 |
| 607 |
} |
| 608 |
|
| 609 |
func stripMailto(link []byte) []byte { |
| 610 |
if bytes.HasPrefix(link, []byte("mailto://")) { |
| 611 |
return link[9:] |
| 612 |
} else if bytes.HasPrefix(link, []byte("mailto:")) { |
| 613 |
return link[7:] |
| 614 |
} else { |
| 615 |
return link |
| 616 |
} |
| 617 |
} |
| 618 |
|
| 619 |
// autolinkType specifies a kind of autolink that gets detected. |
| 620 |
type autolinkType int |
| 621 |
|
| 622 |
// These are the possible flag values for the autolink renderer. |
| 623 |
const ( |
| 624 |
notAutolink autolinkType = iota |
| 625 |
normalAutolink |
| 626 |
emailAutolink |
| 627 |
) |
| 628 |
|
| 629 |
// '<' when tags or autolinks are allowed |
| 630 |
func leftAngle(p *Markdown, data []byte, offset int) (int, *Node) { |
| 631 |
data = data[offset:] |
| 632 |
altype, end := tagLength(data) |
| 633 |
if size := p.inlineHTMLComment(data); size > 0 { |
| 634 |
end = size |
| 635 |
} |
| 636 |
if end > 2 { |
| 637 |
if altype != notAutolink { |
| 638 |
var uLink bytes.Buffer |
| 639 |
unescapeText(&uLink, data[1:end+1-2]) |
| 640 |
if uLink.Len() > 0 { |
| 641 |
link := uLink.Bytes() |
| 642 |
node := NewNode(Link) |
| 643 |
node.Destination = link |
| 644 |
if altype == emailAutolink { |
| 645 |
node.Destination = append([]byte("mailto:"), link...) |
| 646 |
} |
| 647 |
node.AppendChild(text(stripMailto(link))) |
| 648 |
return end, node |
| 649 |
} |
| 650 |
} else { |
| 651 |
htmlTag := NewNode(HTMLSpan) |
| 652 |
htmlTag.Literal = data[:end] |
| 653 |
return end, htmlTag |
| 654 |
} |
| 655 |
} |
| 656 |
|
| 657 |
return end, nil |
| 658 |
} |
| 659 |
|
| 660 |
// '\\' backslash escape |
| 661 |
var escapeChars = []byte("\\`*_{}[]()#+-.!:|&<>~") |
| 662 |
|
| 663 |
func escape(p *Markdown, data []byte, offset int) (int, *Node) { |
| 664 |
data = data[offset:] |
| 665 |
|
| 666 |
if len(data) > 1 { |
| 667 |
if p.extensions&BackslashLineBreak != 0 && data[1] == '\n' { |
| 668 |
return 2, NewNode(Hardbreak) |
| 669 |
} |
| 670 |
if bytes.IndexByte(escapeChars, data[1]) < 0 { |
| 671 |
return 0, nil |
| 672 |
} |
| 673 |
|
| 674 |
return 2, text(data[1:2]) |
| 675 |
} |
| 676 |
|
| 677 |
return 2, nil |
| 678 |
} |
| 679 |
|
| 680 |
func unescapeText(ob *bytes.Buffer, src []byte) { |
| 681 |
i := 0 |
| 682 |
for i < len(src) { |
| 683 |
org := i |
| 684 |
for i < len(src) && src[i] != '\\' { |
| 685 |
i++ |
| 686 |
} |
| 687 |
|
| 688 |
if i > org { |
| 689 |
ob.Write(src[org:i]) |
| 690 |
} |
| 691 |
|
| 692 |
if i+1 >= len(src) { |
| 693 |
break |
| 694 |
} |
| 695 |
|
| 696 |
ob.WriteByte(src[i+1]) |
| 697 |
i += 2 |
| 698 |
} |
| 699 |
} |
| 700 |
|
| 701 |
// '&' escaped when it doesn't belong to an entity |
| 702 |
// valid entities are assumed to be anything matching &#?[A-Za-z0-9]+; |
| 703 |
func entity(p *Markdown, data []byte, offset int) (int, *Node) { |
| 704 |
data = data[offset:] |
| 705 |
|
| 706 |
end := 1 |
| 707 |
|
| 708 |
if end < len(data) && data[end] == '#' { |
| 709 |
end++ |
| 710 |
} |
| 711 |
|
| 712 |
for end < len(data) && isalnum(data[end]) { |
| 713 |
end++ |
| 714 |
} |
| 715 |
|
| 716 |
if end < len(data) && data[end] == ';' { |
| 717 |
end++ // real entity |
| 718 |
} else { |
| 719 |
return 0, nil // lone '&' |
| 720 |
} |
| 721 |
|
| 722 |
ent := data[:end] |
| 723 |
// undo & escaping or it will be converted to &amp; by another |
| 724 |
// escaper in the renderer |
| 725 |
if bytes.Equal(ent, []byte("&")) { |
| 726 |
ent = []byte{'&'} |
| 727 |
} |
| 728 |
|
| 729 |
return end, text(ent) |
| 730 |
} |
| 731 |
|
| 732 |
func linkEndsWithEntity(data []byte, linkEnd int) bool { |
| 733 |
entityRanges := htmlEntityRe.FindAllIndex(data[:linkEnd], -1) |
| 734 |
return entityRanges != nil && entityRanges[len(entityRanges)-1][1] == linkEnd |
| 735 |
} |
| 736 |
|
| 737 |
// hasPrefixCaseInsensitive is a custom implementation of |
| 738 |
// strings.HasPrefix(strings.ToLower(s), prefix) |
| 739 |
// we rolled our own because ToLower pulls in a huge machinery of lowercasing |
| 740 |
// anything from Unicode and that's very slow. Since this func will only be |
| 741 |
// used on ASCII protocol prefixes, we can take shortcuts. |
| 742 |
func hasPrefixCaseInsensitive(s, prefix []byte) bool { |
| 743 |
if len(s) < len(prefix) { |
| 744 |
return false |
| 745 |
} |
| 746 |
delta := byte('a' - 'A') |
| 747 |
for i, b := range prefix { |
| 748 |
if b != s[i] && b != s[i]+delta { |
| 749 |
return false |
| 750 |
} |
| 751 |
} |
| 752 |
return true |
| 753 |
} |
| 754 |
|
| 755 |
var protocolPrefixes = [][]byte{ |
| 756 |
[]byte("http://"), |
| 757 |
[]byte("https://"), |
| 758 |
[]byte("ftp://"), |
| 759 |
[]byte("file://"), |
| 760 |
[]byte("mailto:"), |
| 761 |
} |
| 762 |
|
| 763 |
const shortestPrefix = 6 // len("ftp://"), the shortest of the above |
| 764 |
|
| 765 |
func maybeAutoLink(p *Markdown, data []byte, offset int) (int, *Node) { |
| 766 |
// quick check to rule out most false hits |
| 767 |
if p.insideLink || len(data) < offset+shortestPrefix { |
| 768 |
return 0, nil |
| 769 |
} |
| 770 |
for _, prefix := range protocolPrefixes { |
| 771 |
endOfHead := offset + 8 // 8 is the len() of the longest prefix |
| 772 |
if endOfHead > len(data) { |
| 773 |
endOfHead = len(data) |
| 774 |
} |
| 775 |
if hasPrefixCaseInsensitive(data[offset:endOfHead], prefix) { |
| 776 |
return autoLink(p, data, offset) |
| 777 |
} |
| 778 |
} |
| 779 |
return 0, nil |
| 780 |
} |
| 781 |
|
| 782 |
func autoLink(p *Markdown, data []byte, offset int) (int, *Node) { |
| 783 |
// Now a more expensive check to see if we're not inside an anchor element |
| 784 |
anchorStart := offset |
| 785 |
offsetFromAnchor := 0 |
| 786 |
for anchorStart > 0 && data[anchorStart] != '<' { |
| 787 |
anchorStart-- |
| 788 |
offsetFromAnchor++ |
| 789 |
} |
| 790 |
|
| 791 |
anchorStr := anchorRe.Find(data[anchorStart:]) |
| 792 |
if anchorStr != nil { |
| 793 |
anchorClose := NewNode(HTMLSpan) |
| 794 |
anchorClose.Literal = anchorStr[offsetFromAnchor:] |
| 795 |
return len(anchorStr) - offsetFromAnchor, anchorClose |
| 796 |
} |
| 797 |
|
| 798 |
// scan backward for a word boundary |
| 799 |
rewind := 0 |
| 800 |
for offset-rewind > 0 && rewind <= 7 && isletter(data[offset-rewind-1]) { |
| 801 |
rewind++ |
| 802 |
} |
| 803 |
if rewind > 6 { // longest supported protocol is "mailto" which has 6 letters |
| 804 |
return 0, nil |
| 805 |
} |
| 806 |
|
| 807 |
origData := data |
| 808 |
data = data[offset-rewind:] |
| 809 |
|
| 810 |
if !isSafeLink(data) { |
| 811 |
return 0, nil |
| 812 |
} |
| 813 |
|
| 814 |
linkEnd := 0 |
| 815 |
for linkEnd < len(data) && !isEndOfLink(data[linkEnd]) { |
| 816 |
linkEnd++ |
| 817 |
} |
| 818 |
|
| 819 |
// Skip punctuation at the end of the link |
| 820 |
if (data[linkEnd-1] == '.' || data[linkEnd-1] == ',') && data[linkEnd-2] != '\\' { |
| 821 |
linkEnd-- |
| 822 |
} |
| 823 |
|
| 824 |
// But don't skip semicolon if it's a part of escaped entity: |
| 825 |
if data[linkEnd-1] == ';' && data[linkEnd-2] != '\\' && !linkEndsWithEntity(data, linkEnd) { |
| 826 |
linkEnd-- |
| 827 |
} |
| 828 |
|
| 829 |
// See if the link finishes with a punctuation sign that can be closed. |
| 830 |
var copen byte |
| 831 |
switch data[linkEnd-1] { |
| 832 |
case '"': |
| 833 |
copen = '"' |
| 834 |
case '\'': |
| 835 |
copen = '\'' |
| 836 |
case ')': |
| 837 |
copen = '(' |
| 838 |
case ']': |
| 839 |
copen = '[' |
| 840 |
case '}': |
| 841 |
copen = '{' |
| 842 |
default: |
| 843 |
copen = 0 |
| 844 |
} |
| 845 |
|
| 846 |
if copen != 0 { |
| 847 |
bufEnd := offset - rewind + linkEnd - 2 |
| 848 |
|
| 849 |
openDelim := 1 |
| 850 |
|
| 851 |
/* Try to close the final punctuation sign in this same line; |
| 852 |
* if we managed to close it outside of the URL, that means that it's |
| 853 |
* not part of the URL. If it closes inside the URL, that means it |
| 854 |
* is part of the URL. |
| 855 |
* |
| 856 |
* Examples: |
| 857 |
* |
| 858 |
* foo http://www.pokemon.com/Pikachu_(Electric) bar |
| 859 |
* => http://www.pokemon.com/Pikachu_(Electric) |
| 860 |
* |
| 861 |
* foo (http://www.pokemon.com/Pikachu_(Electric)) bar |
| 862 |
* => http://www.pokemon.com/Pikachu_(Electric) |
| 863 |
* |
| 864 |
* foo http://www.pokemon.com/Pikachu_(Electric)) bar |
| 865 |
* => http://www.pokemon.com/Pikachu_(Electric)) |
| 866 |
* |
| 867 |
* (foo http://www.pokemon.com/Pikachu_(Electric)) bar |
| 868 |
* => foo http://www.pokemon.com/Pikachu_(Electric) |
| 869 |
*/ |
| 870 |
|
| 871 |
for bufEnd >= 0 && origData[bufEnd] != '\n' && openDelim != 0 { |
| 872 |
if origData[bufEnd] == data[linkEnd-1] { |
| 873 |
openDelim++ |
| 874 |
} |
| 875 |
|
| 876 |
if origData[bufEnd] == copen { |
| 877 |
openDelim-- |
| 878 |
} |
| 879 |
|
| 880 |
bufEnd-- |
| 881 |
} |
| 882 |
|
| 883 |
if openDelim == 0 { |
| 884 |
linkEnd-- |
| 885 |
} |
| 886 |
} |
| 887 |
|
| 888 |
var uLink bytes.Buffer |
| 889 |
unescapeText(&uLink, data[:linkEnd]) |
| 890 |
|
| 891 |
if uLink.Len() > 0 { |
| 892 |
node := NewNode(Link) |
| 893 |
node.Destination = uLink.Bytes() |
| 894 |
node.AppendChild(text(uLink.Bytes())) |
| 895 |
return linkEnd, node |
| 896 |
} |
| 897 |
|
| 898 |
return linkEnd, nil |
| 899 |
} |
| 900 |
|
| 901 |
func isEndOfLink(char byte) bool { |
| 902 |
return isspace(char) || char == '<' |
| 903 |
} |
| 904 |
|
| 905 |
var validUris = [][]byte{[]byte("http://"), []byte("https://"), []byte("ftp://"), []byte("mailto://")} |
| 906 |
var validPaths = [][]byte{[]byte("/"), []byte("./"), []byte("../")} |
| 907 |
|
| 908 |
func isSafeLink(link []byte) bool { |
| 909 |
for _, path := range validPaths { |
| 910 |
if len(link) >= len(path) && bytes.Equal(link[:len(path)], path) { |
| 911 |
if len(link) == len(path) { |
| 912 |
return true |
| 913 |
} else if isalnum(link[len(path)]) { |
| 914 |
return true |
| 915 |
} |
| 916 |
} |
| 917 |
} |
| 918 |
|
| 919 |
for _, prefix := range validUris { |
| 920 |
// TODO: handle unicode here |
| 921 |
// case-insensitive prefix test |
| 922 |
if len(link) > len(prefix) && bytes.Equal(bytes.ToLower(link[:len(prefix)]), prefix) && isalnum(link[len(prefix)]) { |
| 923 |
return true |
| 924 |
} |
| 925 |
} |
| 926 |
|
| 927 |
return false |
| 928 |
} |
| 929 |
|
| 930 |
// return the length of the given tag, or 0 is it's not valid |
| 931 |
func tagLength(data []byte) (autolink autolinkType, end int) { |
| 932 |
var i, j int |
| 933 |
|
| 934 |
// a valid tag can't be shorter than 3 chars |
| 935 |
if len(data) < 3 { |
| 936 |
return notAutolink, 0 |
| 937 |
} |
| 938 |
|
| 939 |
// begins with a '<' optionally followed by '/', followed by letter or number |
| 940 |
if data[0] != '<' { |
| 941 |
return notAutolink, 0 |
| 942 |
} |
| 943 |
if data[1] == '/' { |
| 944 |
i = 2 |
| 945 |
} else { |
| 946 |
i = 1 |
| 947 |
} |
| 948 |
|
| 949 |
if !isalnum(data[i]) { |
| 950 |
return notAutolink, 0 |
| 951 |
} |
| 952 |
|
| 953 |
// scheme test |
| 954 |
autolink = notAutolink |
| 955 |
|
| 956 |
// try to find the beginning of an URI |
| 957 |
for i < len(data) && (isalnum(data[i]) || data[i] == '.' || data[i] == '+' || data[i] == '-') { |
| 958 |
i++ |
| 959 |
} |
| 960 |
|
| 961 |
if i > 1 && i < len(data) && data[i] == '@' { |
| 962 |
if j = isMailtoAutoLink(data[i:]); j != 0 { |
| 963 |
return emailAutolink, i + j |
| 964 |
} |
| 965 |
} |
| 966 |
|
| 967 |
if i > 2 && i < len(data) && data[i] == ':' { |
| 968 |
autolink = normalAutolink |
| 969 |
i++ |
| 970 |
} |
| 971 |
|
| 972 |
// complete autolink test: no whitespace or ' or " |
| 973 |
switch { |
| 974 |
case i >= len(data): |
| 975 |
autolink = notAutolink |
| 976 |
case autolink != notAutolink: |
| 977 |
j = i |
| 978 |
|
| 979 |
for i < len(data) { |
| 980 |
if data[i] == '\\' { |
| 981 |
i += 2 |
| 982 |
} else if data[i] == '>' || data[i] == '\'' || data[i] == '"' || isspace(data[i]) { |
| 983 |
break |
| 984 |
} else { |
| 985 |
i++ |
| 986 |
} |
| 987 |
|
| 988 |
} |
| 989 |
|
| 990 |
if i >= len(data) { |
| 991 |
return autolink, 0 |
| 992 |
} |
| 993 |
if i > j && data[i] == '>' { |
| 994 |
return autolink, i + 1 |
| 995 |
} |
| 996 |
|
| 997 |
// one of the forbidden chars has been found |
| 998 |
autolink = notAutolink |
| 999 |
} |
| 1000 |
i += bytes.IndexByte(data[i:], '>') |
| 1001 |
if i < 0 { |
| 1002 |
return autolink, 0 |
| 1003 |
} |
| 1004 |
return autolink, i + 1 |
| 1005 |
} |
| 1006 |
|
| 1007 |
// look for the address part of a mail autolink and '>' |
| 1008 |
// this is less strict than the original markdown e-mail address matching |
| 1009 |
func isMailtoAutoLink(data []byte) int { |
| 1010 |
nb := 0 |
| 1011 |
|
| 1012 |
// address is assumed to be: [-@._a-zA-Z0-9]+ with exactly one '@' |
| 1013 |
for i := 0; i < len(data); i++ { |
| 1014 |
if isalnum(data[i]) { |
| 1015 |
continue |
| 1016 |
} |
| 1017 |
|
| 1018 |
switch data[i] { |
| 1019 |
case '@': |
| 1020 |
nb++ |
| 1021 |
|
| 1022 |
case '-', '.', '_': |
| 1023 |
break |
| 1024 |
|
| 1025 |
case '>': |
| 1026 |
if nb == 1 { |
| 1027 |
return i + 1 |
| 1028 |
} |
| 1029 |
return 0 |
| 1030 |
default: |
| 1031 |
return 0 |
| 1032 |
} |
| 1033 |
} |
| 1034 |
|
| 1035 |
return 0 |
| 1036 |
} |
| 1037 |
|
| 1038 |
// look for the next emph char, skipping other constructs |
| 1039 |
func helperFindEmphChar(data []byte, c byte) int { |
| 1040 |
i := 0 |
| 1041 |
|
| 1042 |
for i < len(data) { |
| 1043 |
for i < len(data) && data[i] != c && data[i] != '`' && data[i] != '[' { |
| 1044 |
i++ |
| 1045 |
} |
| 1046 |
if i >= len(data) { |
| 1047 |
return 0 |
| 1048 |
} |
| 1049 |
// do not count escaped chars |
| 1050 |
if i != 0 && data[i-1] == '\\' { |
| 1051 |
i++ |
| 1052 |
continue |
| 1053 |
} |
| 1054 |
if data[i] == c { |
| 1055 |
return i |
| 1056 |
} |
| 1057 |
|
| 1058 |
if data[i] == '`' { |
| 1059 |
// skip a code span |
| 1060 |
tmpI := 0 |
| 1061 |
i++ |
| 1062 |
for i < len(data) && data[i] != '`' { |
| 1063 |
if tmpI == 0 && data[i] == c { |
| 1064 |
tmpI = i |
| 1065 |
} |
| 1066 |
i++ |
| 1067 |
} |
| 1068 |
if i >= len(data) { |
| 1069 |
return tmpI |
| 1070 |
} |
| 1071 |
i++ |
| 1072 |
} else if data[i] == '[' { |
| 1073 |
// skip a link |
| 1074 |
tmpI := 0 |
| 1075 |
i++ |
| 1076 |
for i < len(data) && data[i] != ']' { |
| 1077 |
if tmpI == 0 && data[i] == c { |
| 1078 |
tmpI = i |
| 1079 |
} |
| 1080 |
i++ |
| 1081 |
} |
| 1082 |
i++ |
| 1083 |
for i < len(data) && (data[i] == ' ' || data[i] == '\n') { |
| 1084 |
i++ |
| 1085 |
} |
| 1086 |
if i >= len(data) { |
| 1087 |
return tmpI |
| 1088 |
} |
| 1089 |
if data[i] != '[' && data[i] != '(' { // not a link |
| 1090 |
if tmpI > 0 { |
| 1091 |
return tmpI |
| 1092 |
} |
| 1093 |
continue |
| 1094 |
} |
| 1095 |
cc := data[i] |
| 1096 |
i++ |
| 1097 |
for i < len(data) && data[i] != cc { |
| 1098 |
if tmpI == 0 && data[i] == c { |
| 1099 |
return i |
| 1100 |
} |
| 1101 |
i++ |
| 1102 |
} |
| 1103 |
if i >= len(data) { |
| 1104 |
return tmpI |
| 1105 |
} |
| 1106 |
i++ |
| 1107 |
} |
| 1108 |
} |
| 1109 |
return 0 |
| 1110 |
} |
| 1111 |
|
| 1112 |
func helperEmphasis(p *Markdown, data []byte, c byte) (int, *Node) { |
| 1113 |
i := 0 |
| 1114 |
|
| 1115 |
// skip one symbol if coming from emph3 |
| 1116 |
if len(data) > 1 && data[0] == c && data[1] == c { |
| 1117 |
i = 1 |
| 1118 |
} |
| 1119 |
|
| 1120 |
for i < len(data) { |
| 1121 |
length := helperFindEmphChar(data[i:], c) |
| 1122 |
if length == 0 { |
| 1123 |
return 0, nil |
| 1124 |
} |
| 1125 |
i += length |
| 1126 |
if i >= len(data) { |
| 1127 |
return 0, nil |
| 1128 |
} |
| 1129 |
|
| 1130 |
if i+1 < len(data) && data[i+1] == c { |
| 1131 |
i++ |
| 1132 |
continue |
| 1133 |
} |
| 1134 |
|
| 1135 |
if data[i] == c && !isspace(data[i-1]) { |
| 1136 |
|
| 1137 |
if p.extensions&NoIntraEmphasis != 0 { |
| 1138 |
if !(i+1 == len(data) || isspace(data[i+1]) || ispunct(data[i+1])) { |
| 1139 |
continue |
| 1140 |
} |
| 1141 |
} |
| 1142 |
|
| 1143 |
emph := NewNode(Emph) |
| 1144 |
p.inline(emph, data[:i]) |
| 1145 |
return i + 1, emph |
| 1146 |
} |
| 1147 |
} |
| 1148 |
|
| 1149 |
return 0, nil |
| 1150 |
} |
| 1151 |
|
| 1152 |
func helperDoubleEmphasis(p *Markdown, data []byte, c byte) (int, *Node) { |
| 1153 |
i := 0 |
| 1154 |
|
| 1155 |
for i < len(data) { |
| 1156 |
length := helperFindEmphChar(data[i:], c) |
| 1157 |
if length == 0 { |
| 1158 |
return 0, nil |
| 1159 |
} |
| 1160 |
i += length |
| 1161 |
|
| 1162 |
if i+1 < len(data) && data[i] == c && data[i+1] == c && i > 0 && !isspace(data[i-1]) { |
| 1163 |
nodeType := Strong |
| 1164 |
if c == '~' { |
| 1165 |
nodeType = Del |
| 1166 |
} |
| 1167 |
node := NewNode(nodeType) |
| 1168 |
p.inline(node, data[:i]) |
| 1169 |
return i + 2, node |
| 1170 |
} |
| 1171 |
i++ |
| 1172 |
} |
| 1173 |
return 0, nil |
| 1174 |
} |
| 1175 |
|
| 1176 |
func helperTripleEmphasis(p *Markdown, data []byte, offset int, c byte) (int, *Node) { |
| 1177 |
i := 0 |
| 1178 |
origData := data |
| 1179 |
data = data[offset:] |
| 1180 |
|
| 1181 |
for i < len(data) { |
| 1182 |
length := helperFindEmphChar(data[i:], c) |
| 1183 |
if length == 0 { |
| 1184 |
return 0, nil |
| 1185 |
} |
| 1186 |
i += length |
| 1187 |
|
| 1188 |
// skip whitespace preceded symbols |
| 1189 |
if data[i] != c || isspace(data[i-1]) { |
| 1190 |
continue |
| 1191 |
} |
| 1192 |
|
| 1193 |
switch { |
| 1194 |
case i+2 < len(data) && data[i+1] == c && data[i+2] == c: |
| 1195 |
// triple symbol found |
| 1196 |
strong := NewNode(Strong) |
| 1197 |
em := NewNode(Emph) |
| 1198 |
strong.AppendChild(em) |
| 1199 |
p.inline(em, data[:i]) |
| 1200 |
return i + 3, strong |
| 1201 |
case (i+1 < len(data) && data[i+1] == c): |
| 1202 |
// double symbol found, hand over to emph1 |
| 1203 |
length, node := helperEmphasis(p, origData[offset-2:], c) |
| 1204 |
if length == 0 { |
| 1205 |
return 0, nil |
| 1206 |
} |
| 1207 |
return length - 2, node |
| 1208 |
default: |
| 1209 |
// single symbol found, hand over to emph2 |
| 1210 |
length, node := helperDoubleEmphasis(p, origData[offset-1:], c) |
| 1211 |
if length == 0 { |
| 1212 |
return 0, nil |
| 1213 |
} |
| 1214 |
return length - 1, node |
| 1215 |
} |
| 1216 |
} |
| 1217 |
return 0, nil |
| 1218 |
} |
| 1219 |
|
| 1220 |
func text(s []byte) *Node { |
| 1221 |
node := NewNode(Text) |
| 1222 |
node.Literal = s |
| 1223 |
return node |
| 1224 |
} |
| 1225 |
|
| 1226 |
func normalizeURI(s []byte) []byte { |
| 1227 |
return s // TODO: implement |
| 1228 |
} |
