|
66
|
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 //
|
|
|
12 // HTML rendering backend
|
|
|
13 //
|
|
|
14 //
|
|
|
15
|
|
|
16 package blackfriday
|
|
|
17
|
|
|
18 import (
|
|
|
19 "bytes"
|
|
|
20 "fmt"
|
|
|
21 "io"
|
|
|
22 "regexp"
|
|
|
23 "strings"
|
|
|
24 )
|
|
|
25
|
|
|
26 // HTMLFlags control optional behavior of HTML renderer.
|
|
|
27 type HTMLFlags int
|
|
|
28
|
|
|
29 // HTML renderer configuration options.
|
|
|
30 const (
|
|
|
31 HTMLFlagsNone HTMLFlags = 0
|
|
|
32 SkipHTML HTMLFlags = 1 << iota // Skip preformatted HTML blocks
|
|
|
33 SkipImages // Skip embedded images
|
|
|
34 SkipLinks // Skip all links
|
|
|
35 Safelink // Only link to trusted protocols
|
|
|
36 NofollowLinks // Only link with rel="nofollow"
|
|
|
37 NoreferrerLinks // Only link with rel="noreferrer"
|
|
|
38 NoopenerLinks // Only link with rel="noopener"
|
|
|
39 HrefTargetBlank // Add a blank target
|
|
|
40 CompletePage // Generate a complete HTML page
|
|
|
41 UseXHTML // Generate XHTML output instead of HTML
|
|
|
42 FootnoteReturnLinks // Generate a link at the end of a footnote to return to the source
|
|
|
43 Smartypants // Enable smart punctuation substitutions
|
|
|
44 SmartypantsFractions // Enable smart fractions (with Smartypants)
|
|
|
45 SmartypantsDashes // Enable smart dashes (with Smartypants)
|
|
|
46 SmartypantsLatexDashes // Enable LaTeX-style dashes (with Smartypants)
|
|
|
47 SmartypantsAngledQuotes // Enable angled double quotes (with Smartypants) for double quotes rendering
|
|
|
48 SmartypantsQuotesNBSP // Enable « French guillemets » (with Smartypants)
|
|
|
49 TOC // Generate a table of contents
|
|
|
50 )
|
|
|
51
|
|
|
52 var (
|
|
|
53 htmlTagRe = regexp.MustCompile("(?i)^" + htmlTag)
|
|
|
54 )
|
|
|
55
|
|
|
56 const (
|
|
|
57 htmlTag = "(?:" + openTag + "|" + closeTag + "|" + htmlComment + "|" +
|
|
|
58 processingInstruction + "|" + declaration + "|" + cdata + ")"
|
|
|
59 closeTag = "</" + tagName + "\\s*[>]"
|
|
|
60 openTag = "<" + tagName + attribute + "*" + "\\s*/?>"
|
|
|
61 attribute = "(?:" + "\\s+" + attributeName + attributeValueSpec + "?)"
|
|
|
62 attributeValue = "(?:" + unquotedValue + "|" + singleQuotedValue + "|" + doubleQuotedValue + ")"
|
|
|
63 attributeValueSpec = "(?:" + "\\s*=" + "\\s*" + attributeValue + ")"
|
|
|
64 attributeName = "[a-zA-Z_:][a-zA-Z0-9:._-]*"
|
|
|
65 cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>"
|
|
|
66 declaration = "<![A-Z]+" + "\\s+[^>]*>"
|
|
|
67 doubleQuotedValue = "\"[^\"]*\""
|
|
|
68 htmlComment = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->"
|
|
|
69 processingInstruction = "[<][?].*?[?][>]"
|
|
|
70 singleQuotedValue = "'[^']*'"
|
|
|
71 tagName = "[A-Za-z][A-Za-z0-9-]*"
|
|
|
72 unquotedValue = "[^\"'=<>`\\x00-\\x20]+"
|
|
|
73 )
|
|
|
74
|
|
|
75 // HTMLRendererParameters is a collection of supplementary parameters tweaking
|
|
|
76 // the behavior of various parts of HTML renderer.
|
|
|
77 type HTMLRendererParameters struct {
|
|
|
78 // Prepend this text to each relative URL.
|
|
|
79 AbsolutePrefix string
|
|
|
80 // Add this text to each footnote anchor, to ensure uniqueness.
|
|
|
81 FootnoteAnchorPrefix string
|
|
|
82 // Show this text inside the <a> tag for a footnote return link, if the
|
|
|
83 // HTML_FOOTNOTE_RETURN_LINKS flag is enabled. If blank, the string
|
|
|
84 // <sup>[return]</sup> is used.
|
|
|
85 FootnoteReturnLinkContents string
|
|
|
86 // If set, add this text to the front of each Heading ID, to ensure
|
|
|
87 // uniqueness.
|
|
|
88 HeadingIDPrefix string
|
|
|
89 // If set, add this text to the back of each Heading ID, to ensure uniqueness.
|
|
|
90 HeadingIDSuffix string
|
|
|
91 // Increase heading levels: if the offset is 1, <h1> becomes <h2> etc.
|
|
|
92 // Negative offset is also valid.
|
|
|
93 // Resulting levels are clipped between 1 and 6.
|
|
|
94 HeadingLevelOffset int
|
|
|
95
|
|
|
96 Title string // Document title (used if CompletePage is set)
|
|
|
97 CSS string // Optional CSS file URL (used if CompletePage is set)
|
|
|
98 Icon string // Optional icon file URL (used if CompletePage is set)
|
|
|
99
|
|
|
100 Flags HTMLFlags // Flags allow customizing this renderer's behavior
|
|
|
101 }
|
|
|
102
|
|
|
103 // HTMLRenderer is a type that implements the Renderer interface for HTML output.
|
|
|
104 //
|
|
|
105 // Do not create this directly, instead use the NewHTMLRenderer function.
|
|
|
106 type HTMLRenderer struct {
|
|
|
107 HTMLRendererParameters
|
|
|
108
|
|
|
109 closeTag string // how to end singleton tags: either " />" or ">"
|
|
|
110
|
|
|
111 // Track heading IDs to prevent ID collision in a single generation.
|
|
|
112 headingIDs map[string]int
|
|
|
113
|
|
|
114 lastOutputLen int
|
|
|
115 disableTags int
|
|
|
116
|
|
|
117 sr *SPRenderer
|
|
|
118 }
|
|
|
119
|
|
|
120 const (
|
|
|
121 xhtmlClose = " />"
|
|
|
122 htmlClose = ">"
|
|
|
123 )
|
|
|
124
|
|
|
125 // NewHTMLRenderer creates and configures an HTMLRenderer object, which
|
|
|
126 // satisfies the Renderer interface.
|
|
|
127 func NewHTMLRenderer(params HTMLRendererParameters) *HTMLRenderer {
|
|
|
128 // configure the rendering engine
|
|
|
129 closeTag := htmlClose
|
|
|
130 if params.Flags&UseXHTML != 0 {
|
|
|
131 closeTag = xhtmlClose
|
|
|
132 }
|
|
|
133
|
|
|
134 if params.FootnoteReturnLinkContents == "" {
|
|
|
135 // U+FE0E is VARIATION SELECTOR-15.
|
|
|
136 // It suppresses automatic emoji presentation of the preceding
|
|
|
137 // U+21A9 LEFTWARDS ARROW WITH HOOK on iOS and iPadOS.
|
|
|
138 params.FootnoteReturnLinkContents = "<span aria-label='Return'>↩\ufe0e</span>"
|
|
|
139 }
|
|
|
140
|
|
|
141 return &HTMLRenderer{
|
|
|
142 HTMLRendererParameters: params,
|
|
|
143
|
|
|
144 closeTag: closeTag,
|
|
|
145 headingIDs: make(map[string]int),
|
|
|
146
|
|
|
147 sr: NewSmartypantsRenderer(params.Flags),
|
|
|
148 }
|
|
|
149 }
|
|
|
150
|
|
|
151 func isHTMLTag(tag []byte, tagname string) bool {
|
|
|
152 found, _ := findHTMLTagPos(tag, tagname)
|
|
|
153 return found
|
|
|
154 }
|
|
|
155
|
|
|
156 // Look for a character, but ignore it when it's in any kind of quotes, it
|
|
|
157 // might be JavaScript
|
|
|
158 func skipUntilCharIgnoreQuotes(html []byte, start int, char byte) int {
|
|
|
159 inSingleQuote := false
|
|
|
160 inDoubleQuote := false
|
|
|
161 inGraveQuote := false
|
|
|
162 i := start
|
|
|
163 for i < len(html) {
|
|
|
164 switch {
|
|
|
165 case html[i] == char && !inSingleQuote && !inDoubleQuote && !inGraveQuote:
|
|
|
166 return i
|
|
|
167 case html[i] == '\'':
|
|
|
168 inSingleQuote = !inSingleQuote
|
|
|
169 case html[i] == '"':
|
|
|
170 inDoubleQuote = !inDoubleQuote
|
|
|
171 case html[i] == '`':
|
|
|
172 inGraveQuote = !inGraveQuote
|
|
|
173 }
|
|
|
174 i++
|
|
|
175 }
|
|
|
176 return start
|
|
|
177 }
|
|
|
178
|
|
|
179 func findHTMLTagPos(tag []byte, tagname string) (bool, int) {
|
|
|
180 i := 0
|
|
|
181 if i < len(tag) && tag[0] != '<' {
|
|
|
182 return false, -1
|
|
|
183 }
|
|
|
184 i++
|
|
|
185 i = skipSpace(tag, i)
|
|
|
186
|
|
|
187 if i < len(tag) && tag[i] == '/' {
|
|
|
188 i++
|
|
|
189 }
|
|
|
190
|
|
|
191 i = skipSpace(tag, i)
|
|
|
192 j := 0
|
|
|
193 for ; i < len(tag); i, j = i+1, j+1 {
|
|
|
194 if j >= len(tagname) {
|
|
|
195 break
|
|
|
196 }
|
|
|
197
|
|
|
198 if strings.ToLower(string(tag[i]))[0] != tagname[j] {
|
|
|
199 return false, -1
|
|
|
200 }
|
|
|
201 }
|
|
|
202
|
|
|
203 if i == len(tag) {
|
|
|
204 return false, -1
|
|
|
205 }
|
|
|
206
|
|
|
207 rightAngle := skipUntilCharIgnoreQuotes(tag, i, '>')
|
|
|
208 if rightAngle >= i {
|
|
|
209 return true, rightAngle
|
|
|
210 }
|
|
|
211
|
|
|
212 return false, -1
|
|
|
213 }
|
|
|
214
|
|
|
215 func skipSpace(tag []byte, i int) int {
|
|
|
216 for i < len(tag) && isspace(tag[i]) {
|
|
|
217 i++
|
|
|
218 }
|
|
|
219 return i
|
|
|
220 }
|
|
|
221
|
|
|
222 func isRelativeLink(link []byte) (yes bool) {
|
|
|
223 // a tag begin with '#'
|
|
|
224 if link[0] == '#' {
|
|
|
225 return true
|
|
|
226 }
|
|
|
227
|
|
|
228 // link begin with '/' but not '//', the second maybe a protocol relative link
|
|
|
229 if len(link) >= 2 && link[0] == '/' && link[1] != '/' {
|
|
|
230 return true
|
|
|
231 }
|
|
|
232
|
|
|
233 // only the root '/'
|
|
|
234 if len(link) == 1 && link[0] == '/' {
|
|
|
235 return true
|
|
|
236 }
|
|
|
237
|
|
|
238 // current directory : begin with "./"
|
|
|
239 if bytes.HasPrefix(link, []byte("./")) {
|
|
|
240 return true
|
|
|
241 }
|
|
|
242
|
|
|
243 // parent directory : begin with "../"
|
|
|
244 if bytes.HasPrefix(link, []byte("../")) {
|
|
|
245 return true
|
|
|
246 }
|
|
|
247
|
|
|
248 return false
|
|
|
249 }
|
|
|
250
|
|
|
251 func (r *HTMLRenderer) ensureUniqueHeadingID(id string) string {
|
|
|
252 for count, found := r.headingIDs[id]; found; count, found = r.headingIDs[id] {
|
|
|
253 tmp := fmt.Sprintf("%s-%d", id, count+1)
|
|
|
254
|
|
|
255 if _, tmpFound := r.headingIDs[tmp]; !tmpFound {
|
|
|
256 r.headingIDs[id] = count + 1
|
|
|
257 id = tmp
|
|
|
258 } else {
|
|
|
259 id = id + "-1"
|
|
|
260 }
|
|
|
261 }
|
|
|
262
|
|
|
263 if _, found := r.headingIDs[id]; !found {
|
|
|
264 r.headingIDs[id] = 0
|
|
|
265 }
|
|
|
266
|
|
|
267 return id
|
|
|
268 }
|
|
|
269
|
|
|
270 func (r *HTMLRenderer) addAbsPrefix(link []byte) []byte {
|
|
|
271 if r.AbsolutePrefix != "" && isRelativeLink(link) && link[0] != '.' {
|
|
|
272 newDest := r.AbsolutePrefix
|
|
|
273 if link[0] != '/' {
|
|
|
274 newDest += "/"
|
|
|
275 }
|
|
|
276 newDest += string(link)
|
|
|
277 return []byte(newDest)
|
|
|
278 }
|
|
|
279 return link
|
|
|
280 }
|
|
|
281
|
|
|
282 func appendLinkAttrs(attrs []string, flags HTMLFlags, link []byte) []string {
|
|
|
283 if isRelativeLink(link) {
|
|
|
284 return attrs
|
|
|
285 }
|
|
|
286 val := []string{}
|
|
|
287 if flags&NofollowLinks != 0 {
|
|
|
288 val = append(val, "nofollow")
|
|
|
289 }
|
|
|
290 if flags&NoreferrerLinks != 0 {
|
|
|
291 val = append(val, "noreferrer")
|
|
|
292 }
|
|
|
293 if flags&NoopenerLinks != 0 {
|
|
|
294 val = append(val, "noopener")
|
|
|
295 }
|
|
|
296 if flags&HrefTargetBlank != 0 {
|
|
|
297 attrs = append(attrs, "target=\"_blank\"")
|
|
|
298 }
|
|
|
299 if len(val) == 0 {
|
|
|
300 return attrs
|
|
|
301 }
|
|
|
302 attr := fmt.Sprintf("rel=%q", strings.Join(val, " "))
|
|
|
303 return append(attrs, attr)
|
|
|
304 }
|
|
|
305
|
|
|
306 func isMailto(link []byte) bool {
|
|
|
307 return bytes.HasPrefix(link, []byte("mailto:"))
|
|
|
308 }
|
|
|
309
|
|
|
310 func needSkipLink(flags HTMLFlags, dest []byte) bool {
|
|
|
311 if flags&SkipLinks != 0 {
|
|
|
312 return true
|
|
|
313 }
|
|
|
314 return flags&Safelink != 0 && !isSafeLink(dest) && !isMailto(dest)
|
|
|
315 }
|
|
|
316
|
|
|
317 func isSmartypantable(node *Node) bool {
|
|
|
318 pt := node.Parent.Type
|
|
|
319 return pt != Link && pt != CodeBlock && pt != Code
|
|
|
320 }
|
|
|
321
|
|
|
322 func appendLanguageAttr(attrs []string, info []byte) []string {
|
|
|
323 if len(info) == 0 {
|
|
|
324 return attrs
|
|
|
325 }
|
|
|
326 endOfLang := bytes.IndexAny(info, "\t ")
|
|
|
327 if endOfLang < 0 {
|
|
|
328 endOfLang = len(info)
|
|
|
329 }
|
|
|
330 return append(attrs, fmt.Sprintf("class=\"language-%s\"", info[:endOfLang]))
|
|
|
331 }
|
|
|
332
|
|
|
333 func (r *HTMLRenderer) tag(w io.Writer, name []byte, attrs []string) {
|
|
|
334 w.Write(name)
|
|
|
335 if len(attrs) > 0 {
|
|
|
336 w.Write(spaceBytes)
|
|
|
337 w.Write([]byte(strings.Join(attrs, " ")))
|
|
|
338 }
|
|
|
339 w.Write(gtBytes)
|
|
|
340 r.lastOutputLen = 1
|
|
|
341 }
|
|
|
342
|
|
|
343 func footnoteRef(prefix string, node *Node) []byte {
|
|
|
344 urlFrag := prefix + string(slugify(node.Destination))
|
|
|
345 anchor := fmt.Sprintf(`<a href="#fn:%s">%d</a>`, urlFrag, node.NoteID)
|
|
|
346 return []byte(fmt.Sprintf(`<sup class="footnote-ref" id="fnref:%s">%s</sup>`, urlFrag, anchor))
|
|
|
347 }
|
|
|
348
|
|
|
349 func footnoteItem(prefix string, slug []byte) []byte {
|
|
|
350 return []byte(fmt.Sprintf(`<li id="fn:%s%s">`, prefix, slug))
|
|
|
351 }
|
|
|
352
|
|
|
353 func footnoteReturnLink(prefix, returnLink string, slug []byte) []byte {
|
|
|
354 const format = ` <a class="footnote-return" href="#fnref:%s%s">%s</a>`
|
|
|
355 return []byte(fmt.Sprintf(format, prefix, slug, returnLink))
|
|
|
356 }
|
|
|
357
|
|
|
358 func itemOpenCR(node *Node) bool {
|
|
|
359 if node.Prev == nil {
|
|
|
360 return false
|
|
|
361 }
|
|
|
362 ld := node.Parent.ListData
|
|
|
363 return !ld.Tight && ld.ListFlags&ListTypeDefinition == 0
|
|
|
364 }
|
|
|
365
|
|
|
366 func skipParagraphTags(node *Node) bool {
|
|
|
367 grandparent := node.Parent.Parent
|
|
|
368 if grandparent == nil || grandparent.Type != List {
|
|
|
369 return false
|
|
|
370 }
|
|
|
371 tightOrTerm := grandparent.Tight || node.Parent.ListFlags&ListTypeTerm != 0
|
|
|
372 return grandparent.Type == List && tightOrTerm
|
|
|
373 }
|
|
|
374
|
|
|
375 func cellAlignment(align CellAlignFlags) string {
|
|
|
376 switch align {
|
|
|
377 case TableAlignmentLeft:
|
|
|
378 return "left"
|
|
|
379 case TableAlignmentRight:
|
|
|
380 return "right"
|
|
|
381 case TableAlignmentCenter:
|
|
|
382 return "center"
|
|
|
383 default:
|
|
|
384 return ""
|
|
|
385 }
|
|
|
386 }
|
|
|
387
|
|
|
388 func (r *HTMLRenderer) out(w io.Writer, text []byte) {
|
|
|
389 if r.disableTags > 0 {
|
|
|
390 w.Write(htmlTagRe.ReplaceAll(text, []byte{}))
|
|
|
391 } else {
|
|
|
392 w.Write(text)
|
|
|
393 }
|
|
|
394 r.lastOutputLen = len(text)
|
|
|
395 }
|
|
|
396
|
|
|
397 func (r *HTMLRenderer) cr(w io.Writer) {
|
|
|
398 if r.lastOutputLen > 0 {
|
|
|
399 r.out(w, nlBytes)
|
|
|
400 }
|
|
|
401 }
|
|
|
402
|
|
|
403 var (
|
|
|
404 nlBytes = []byte{'\n'}
|
|
|
405 gtBytes = []byte{'>'}
|
|
|
406 spaceBytes = []byte{' '}
|
|
|
407 )
|
|
|
408
|
|
|
409 var (
|
|
|
410 brTag = []byte("<br>")
|
|
|
411 brXHTMLTag = []byte("<br />")
|
|
|
412 emTag = []byte("<em>")
|
|
|
413 emCloseTag = []byte("</em>")
|
|
|
414 strongTag = []byte("<strong>")
|
|
|
415 strongCloseTag = []byte("</strong>")
|
|
|
416 delTag = []byte("<del>")
|
|
|
417 delCloseTag = []byte("</del>")
|
|
|
418 ttTag = []byte("<tt>")
|
|
|
419 ttCloseTag = []byte("</tt>")
|
|
|
420 aTag = []byte("<a")
|
|
|
421 aCloseTag = []byte("</a>")
|
|
|
422 preTag = []byte("<pre>")
|
|
|
423 preCloseTag = []byte("</pre>")
|
|
|
424 codeTag = []byte("<code>")
|
|
|
425 codeCloseTag = []byte("</code>")
|
|
|
426 pTag = []byte("<p>")
|
|
|
427 pCloseTag = []byte("</p>")
|
|
|
428 blockquoteTag = []byte("<blockquote>")
|
|
|
429 blockquoteCloseTag = []byte("</blockquote>")
|
|
|
430 hrTag = []byte("<hr>")
|
|
|
431 hrXHTMLTag = []byte("<hr />")
|
|
|
432 ulTag = []byte("<ul>")
|
|
|
433 ulCloseTag = []byte("</ul>")
|
|
|
434 olTag = []byte("<ol>")
|
|
|
435 olCloseTag = []byte("</ol>")
|
|
|
436 dlTag = []byte("<dl>")
|
|
|
437 dlCloseTag = []byte("</dl>")
|
|
|
438 liTag = []byte("<li>")
|
|
|
439 liCloseTag = []byte("</li>")
|
|
|
440 ddTag = []byte("<dd>")
|
|
|
441 ddCloseTag = []byte("</dd>")
|
|
|
442 dtTag = []byte("<dt>")
|
|
|
443 dtCloseTag = []byte("</dt>")
|
|
|
444 tableTag = []byte("<table>")
|
|
|
445 tableCloseTag = []byte("</table>")
|
|
|
446 tdTag = []byte("<td")
|
|
|
447 tdCloseTag = []byte("</td>")
|
|
|
448 thTag = []byte("<th")
|
|
|
449 thCloseTag = []byte("</th>")
|
|
|
450 theadTag = []byte("<thead>")
|
|
|
451 theadCloseTag = []byte("</thead>")
|
|
|
452 tbodyTag = []byte("<tbody>")
|
|
|
453 tbodyCloseTag = []byte("</tbody>")
|
|
|
454 trTag = []byte("<tr>")
|
|
|
455 trCloseTag = []byte("</tr>")
|
|
|
456 h1Tag = []byte("<h1")
|
|
|
457 h1CloseTag = []byte("</h1>")
|
|
|
458 h2Tag = []byte("<h2")
|
|
|
459 h2CloseTag = []byte("</h2>")
|
|
|
460 h3Tag = []byte("<h3")
|
|
|
461 h3CloseTag = []byte("</h3>")
|
|
|
462 h4Tag = []byte("<h4")
|
|
|
463 h4CloseTag = []byte("</h4>")
|
|
|
464 h5Tag = []byte("<h5")
|
|
|
465 h5CloseTag = []byte("</h5>")
|
|
|
466 h6Tag = []byte("<h6")
|
|
|
467 h6CloseTag = []byte("</h6>")
|
|
|
468
|
|
|
469 footnotesDivBytes = []byte("\n<div class=\"footnotes\">\n\n")
|
|
|
470 footnotesCloseDivBytes = []byte("\n</div>\n")
|
|
|
471 )
|
|
|
472
|
|
|
473 func headingTagsFromLevel(level int) ([]byte, []byte) {
|
|
|
474 if level <= 1 {
|
|
|
475 return h1Tag, h1CloseTag
|
|
|
476 }
|
|
|
477 switch level {
|
|
|
478 case 2:
|
|
|
479 return h2Tag, h2CloseTag
|
|
|
480 case 3:
|
|
|
481 return h3Tag, h3CloseTag
|
|
|
482 case 4:
|
|
|
483 return h4Tag, h4CloseTag
|
|
|
484 case 5:
|
|
|
485 return h5Tag, h5CloseTag
|
|
|
486 }
|
|
|
487 return h6Tag, h6CloseTag
|
|
|
488 }
|
|
|
489
|
|
|
490 func (r *HTMLRenderer) outHRTag(w io.Writer) {
|
|
|
491 if r.Flags&UseXHTML == 0 {
|
|
|
492 r.out(w, hrTag)
|
|
|
493 } else {
|
|
|
494 r.out(w, hrXHTMLTag)
|
|
|
495 }
|
|
|
496 }
|
|
|
497
|
|
|
498 // RenderNode is a default renderer of a single node of a syntax tree. For
|
|
|
499 // block nodes it will be called twice: first time with entering=true, second
|
|
|
500 // time with entering=false, so that it could know when it's working on an open
|
|
|
501 // tag and when on close. It writes the result to w.
|
|
|
502 //
|
|
|
503 // The return value is a way to tell the calling walker to adjust its walk
|
|
|
504 // pattern: e.g. it can terminate the traversal by returning Terminate. Or it
|
|
|
505 // can ask the walker to skip a subtree of this node by returning SkipChildren.
|
|
|
506 // The typical behavior is to return GoToNext, which asks for the usual
|
|
|
507 // traversal to the next node.
|
|
|
508 func (r *HTMLRenderer) RenderNode(w io.Writer, node *Node, entering bool) WalkStatus {
|
|
|
509 attrs := []string{}
|
|
|
510 switch node.Type {
|
|
|
511 case Text:
|
|
|
512 if r.Flags&Smartypants != 0 {
|
|
|
513 var tmp bytes.Buffer
|
|
|
514 escapeHTML(&tmp, node.Literal)
|
|
|
515 r.sr.Process(w, tmp.Bytes())
|
|
|
516 } else {
|
|
|
517 if node.Parent.Type == Link {
|
|
|
518 escLink(w, node.Literal)
|
|
|
519 } else {
|
|
|
520 escapeHTML(w, node.Literal)
|
|
|
521 }
|
|
|
522 }
|
|
|
523 case Softbreak:
|
|
|
524 r.cr(w)
|
|
|
525 // TODO: make it configurable via out(renderer.softbreak)
|
|
|
526 case Hardbreak:
|
|
|
527 if r.Flags&UseXHTML == 0 {
|
|
|
528 r.out(w, brTag)
|
|
|
529 } else {
|
|
|
530 r.out(w, brXHTMLTag)
|
|
|
531 }
|
|
|
532 r.cr(w)
|
|
|
533 case Emph:
|
|
|
534 if entering {
|
|
|
535 r.out(w, emTag)
|
|
|
536 } else {
|
|
|
537 r.out(w, emCloseTag)
|
|
|
538 }
|
|
|
539 case Strong:
|
|
|
540 if entering {
|
|
|
541 r.out(w, strongTag)
|
|
|
542 } else {
|
|
|
543 r.out(w, strongCloseTag)
|
|
|
544 }
|
|
|
545 case Del:
|
|
|
546 if entering {
|
|
|
547 r.out(w, delTag)
|
|
|
548 } else {
|
|
|
549 r.out(w, delCloseTag)
|
|
|
550 }
|
|
|
551 case HTMLSpan:
|
|
|
552 if r.Flags&SkipHTML != 0 {
|
|
|
553 break
|
|
|
554 }
|
|
|
555 r.out(w, node.Literal)
|
|
|
556 case Link:
|
|
|
557 // mark it but don't link it if it is not a safe link: no smartypants
|
|
|
558 dest := node.LinkData.Destination
|
|
|
559 if needSkipLink(r.Flags, dest) {
|
|
|
560 if entering {
|
|
|
561 r.out(w, ttTag)
|
|
|
562 } else {
|
|
|
563 r.out(w, ttCloseTag)
|
|
|
564 }
|
|
|
565 } else {
|
|
|
566 if entering {
|
|
|
567 dest = r.addAbsPrefix(dest)
|
|
|
568 var hrefBuf bytes.Buffer
|
|
|
569 hrefBuf.WriteString("href=\"")
|
|
|
570 escLink(&hrefBuf, dest)
|
|
|
571 hrefBuf.WriteByte('"')
|
|
|
572 attrs = append(attrs, hrefBuf.String())
|
|
|
573 if node.NoteID != 0 {
|
|
|
574 r.out(w, footnoteRef(r.FootnoteAnchorPrefix, node))
|
|
|
575 break
|
|
|
576 }
|
|
|
577 attrs = appendLinkAttrs(attrs, r.Flags, dest)
|
|
|
578 if len(node.LinkData.Title) > 0 {
|
|
|
579 var titleBuff bytes.Buffer
|
|
|
580 titleBuff.WriteString("title=\"")
|
|
|
581 escapeHTML(&titleBuff, node.LinkData.Title)
|
|
|
582 titleBuff.WriteByte('"')
|
|
|
583 attrs = append(attrs, titleBuff.String())
|
|
|
584 }
|
|
|
585 r.tag(w, aTag, attrs)
|
|
|
586 } else {
|
|
|
587 if node.NoteID != 0 {
|
|
|
588 break
|
|
|
589 }
|
|
|
590 r.out(w, aCloseTag)
|
|
|
591 }
|
|
|
592 }
|
|
|
593 case Image:
|
|
|
594 if r.Flags&SkipImages != 0 {
|
|
|
595 return SkipChildren
|
|
|
596 }
|
|
|
597 if entering {
|
|
|
598 dest := node.LinkData.Destination
|
|
|
599 dest = r.addAbsPrefix(dest)
|
|
|
600 if r.disableTags == 0 {
|
|
|
601 //if options.safe && potentiallyUnsafe(dest) {
|
|
|
602 //out(w, `<img src="" alt="`)
|
|
|
603 //} else {
|
|
|
604 r.out(w, []byte(`<img src="`))
|
|
|
605 escLink(w, dest)
|
|
|
606 r.out(w, []byte(`" alt="`))
|
|
|
607 //}
|
|
|
608 }
|
|
|
609 r.disableTags++
|
|
|
610 } else {
|
|
|
611 r.disableTags--
|
|
|
612 if r.disableTags == 0 {
|
|
|
613 if node.LinkData.Title != nil {
|
|
|
614 r.out(w, []byte(`" title="`))
|
|
|
615 escapeHTML(w, node.LinkData.Title)
|
|
|
616 }
|
|
|
617 r.out(w, []byte(`" />`))
|
|
|
618 }
|
|
|
619 }
|
|
|
620 case Code:
|
|
|
621 r.out(w, codeTag)
|
|
|
622 escapeAllHTML(w, node.Literal)
|
|
|
623 r.out(w, codeCloseTag)
|
|
|
624 case Document:
|
|
|
625 break
|
|
|
626 case Paragraph:
|
|
|
627 if skipParagraphTags(node) {
|
|
|
628 break
|
|
|
629 }
|
|
|
630 if entering {
|
|
|
631 // TODO: untangle this clusterfuck about when the newlines need
|
|
|
632 // to be added and when not.
|
|
|
633 if node.Prev != nil {
|
|
|
634 switch node.Prev.Type {
|
|
|
635 case HTMLBlock, List, Paragraph, Heading, CodeBlock, BlockQuote, HorizontalRule:
|
|
|
636 r.cr(w)
|
|
|
637 }
|
|
|
638 }
|
|
|
639 if node.Parent.Type == BlockQuote && node.Prev == nil {
|
|
|
640 r.cr(w)
|
|
|
641 }
|
|
|
642 r.out(w, pTag)
|
|
|
643 } else {
|
|
|
644 r.out(w, pCloseTag)
|
|
|
645 if !(node.Parent.Type == Item && node.Next == nil) {
|
|
|
646 r.cr(w)
|
|
|
647 }
|
|
|
648 }
|
|
|
649 case BlockQuote:
|
|
|
650 if entering {
|
|
|
651 r.cr(w)
|
|
|
652 r.out(w, blockquoteTag)
|
|
|
653 } else {
|
|
|
654 r.out(w, blockquoteCloseTag)
|
|
|
655 r.cr(w)
|
|
|
656 }
|
|
|
657 case HTMLBlock:
|
|
|
658 if r.Flags&SkipHTML != 0 {
|
|
|
659 break
|
|
|
660 }
|
|
|
661 r.cr(w)
|
|
|
662 r.out(w, node.Literal)
|
|
|
663 r.cr(w)
|
|
|
664 case Heading:
|
|
|
665 headingLevel := r.HTMLRendererParameters.HeadingLevelOffset + node.Level
|
|
|
666 openTag, closeTag := headingTagsFromLevel(headingLevel)
|
|
|
667 if entering {
|
|
|
668 if node.IsTitleblock {
|
|
|
669 attrs = append(attrs, `class="title"`)
|
|
|
670 }
|
|
|
671 if node.HeadingID != "" {
|
|
|
672 id := r.ensureUniqueHeadingID(node.HeadingID)
|
|
|
673 if r.HeadingIDPrefix != "" {
|
|
|
674 id = r.HeadingIDPrefix + id
|
|
|
675 }
|
|
|
676 if r.HeadingIDSuffix != "" {
|
|
|
677 id = id + r.HeadingIDSuffix
|
|
|
678 }
|
|
|
679 attrs = append(attrs, fmt.Sprintf(`id="%s"`, id))
|
|
|
680 }
|
|
|
681 r.cr(w)
|
|
|
682 r.tag(w, openTag, attrs)
|
|
|
683 } else {
|
|
|
684 r.out(w, closeTag)
|
|
|
685 if !(node.Parent.Type == Item && node.Next == nil) {
|
|
|
686 r.cr(w)
|
|
|
687 }
|
|
|
688 }
|
|
|
689 case HorizontalRule:
|
|
|
690 r.cr(w)
|
|
|
691 r.outHRTag(w)
|
|
|
692 r.cr(w)
|
|
|
693 case List:
|
|
|
694 openTag := ulTag
|
|
|
695 closeTag := ulCloseTag
|
|
|
696 if node.ListFlags&ListTypeOrdered != 0 {
|
|
|
697 openTag = olTag
|
|
|
698 closeTag = olCloseTag
|
|
|
699 }
|
|
|
700 if node.ListFlags&ListTypeDefinition != 0 {
|
|
|
701 openTag = dlTag
|
|
|
702 closeTag = dlCloseTag
|
|
|
703 }
|
|
|
704 if entering {
|
|
|
705 if node.IsFootnotesList {
|
|
|
706 r.out(w, footnotesDivBytes)
|
|
|
707 r.outHRTag(w)
|
|
|
708 r.cr(w)
|
|
|
709 }
|
|
|
710 r.cr(w)
|
|
|
711 if node.Parent.Type == Item && node.Parent.Parent.Tight {
|
|
|
712 r.cr(w)
|
|
|
713 }
|
|
|
714 r.tag(w, openTag[:len(openTag)-1], attrs)
|
|
|
715 r.cr(w)
|
|
|
716 } else {
|
|
|
717 r.out(w, closeTag)
|
|
|
718 //cr(w)
|
|
|
719 //if node.parent.Type != Item {
|
|
|
720 // cr(w)
|
|
|
721 //}
|
|
|
722 if node.Parent.Type == Item && node.Next != nil {
|
|
|
723 r.cr(w)
|
|
|
724 }
|
|
|
725 if node.Parent.Type == Document || node.Parent.Type == BlockQuote {
|
|
|
726 r.cr(w)
|
|
|
727 }
|
|
|
728 if node.IsFootnotesList {
|
|
|
729 r.out(w, footnotesCloseDivBytes)
|
|
|
730 }
|
|
|
731 }
|
|
|
732 case Item:
|
|
|
733 openTag := liTag
|
|
|
734 closeTag := liCloseTag
|
|
|
735 if node.ListFlags&ListTypeDefinition != 0 {
|
|
|
736 openTag = ddTag
|
|
|
737 closeTag = ddCloseTag
|
|
|
738 }
|
|
|
739 if node.ListFlags&ListTypeTerm != 0 {
|
|
|
740 openTag = dtTag
|
|
|
741 closeTag = dtCloseTag
|
|
|
742 }
|
|
|
743 if entering {
|
|
|
744 if itemOpenCR(node) {
|
|
|
745 r.cr(w)
|
|
|
746 }
|
|
|
747 if node.ListData.RefLink != nil {
|
|
|
748 slug := slugify(node.ListData.RefLink)
|
|
|
749 r.out(w, footnoteItem(r.FootnoteAnchorPrefix, slug))
|
|
|
750 break
|
|
|
751 }
|
|
|
752 r.out(w, openTag)
|
|
|
753 } else {
|
|
|
754 if node.ListData.RefLink != nil {
|
|
|
755 slug := slugify(node.ListData.RefLink)
|
|
|
756 if r.Flags&FootnoteReturnLinks != 0 {
|
|
|
757 r.out(w, footnoteReturnLink(r.FootnoteAnchorPrefix, r.FootnoteReturnLinkContents, slug))
|
|
|
758 }
|
|
|
759 }
|
|
|
760 r.out(w, closeTag)
|
|
|
761 r.cr(w)
|
|
|
762 }
|
|
|
763 case CodeBlock:
|
|
|
764 attrs = appendLanguageAttr(attrs, node.Info)
|
|
|
765 r.cr(w)
|
|
|
766 r.out(w, preTag)
|
|
|
767 r.tag(w, codeTag[:len(codeTag)-1], attrs)
|
|
|
768 escapeAllHTML(w, node.Literal)
|
|
|
769 r.out(w, codeCloseTag)
|
|
|
770 r.out(w, preCloseTag)
|
|
|
771 if node.Parent.Type != Item {
|
|
|
772 r.cr(w)
|
|
|
773 }
|
|
|
774 case Table:
|
|
|
775 if entering {
|
|
|
776 r.cr(w)
|
|
|
777 r.out(w, tableTag)
|
|
|
778 } else {
|
|
|
779 r.out(w, tableCloseTag)
|
|
|
780 r.cr(w)
|
|
|
781 }
|
|
|
782 case TableCell:
|
|
|
783 openTag := tdTag
|
|
|
784 closeTag := tdCloseTag
|
|
|
785 if node.IsHeader {
|
|
|
786 openTag = thTag
|
|
|
787 closeTag = thCloseTag
|
|
|
788 }
|
|
|
789 if entering {
|
|
|
790 align := cellAlignment(node.Align)
|
|
|
791 if align != "" {
|
|
|
792 attrs = append(attrs, fmt.Sprintf(`align="%s"`, align))
|
|
|
793 }
|
|
|
794 if node.Prev == nil {
|
|
|
795 r.cr(w)
|
|
|
796 }
|
|
|
797 r.tag(w, openTag, attrs)
|
|
|
798 } else {
|
|
|
799 r.out(w, closeTag)
|
|
|
800 r.cr(w)
|
|
|
801 }
|
|
|
802 case TableHead:
|
|
|
803 if entering {
|
|
|
804 r.cr(w)
|
|
|
805 r.out(w, theadTag)
|
|
|
806 } else {
|
|
|
807 r.out(w, theadCloseTag)
|
|
|
808 r.cr(w)
|
|
|
809 }
|
|
|
810 case TableBody:
|
|
|
811 if entering {
|
|
|
812 r.cr(w)
|
|
|
813 r.out(w, tbodyTag)
|
|
|
814 // XXX: this is to adhere to a rather silly test. Should fix test.
|
|
|
815 if node.FirstChild == nil {
|
|
|
816 r.cr(w)
|
|
|
817 }
|
|
|
818 } else {
|
|
|
819 r.out(w, tbodyCloseTag)
|
|
|
820 r.cr(w)
|
|
|
821 }
|
|
|
822 case TableRow:
|
|
|
823 if entering {
|
|
|
824 r.cr(w)
|
|
|
825 r.out(w, trTag)
|
|
|
826 } else {
|
|
|
827 r.out(w, trCloseTag)
|
|
|
828 r.cr(w)
|
|
|
829 }
|
|
|
830 default:
|
|
|
831 panic("Unknown node type " + node.Type.String())
|
|
|
832 }
|
|
|
833 return GoToNext
|
|
|
834 }
|
|
|
835
|
|
|
836 // RenderHeader writes HTML document preamble and TOC if requested.
|
|
|
837 func (r *HTMLRenderer) RenderHeader(w io.Writer, ast *Node) {
|
|
|
838 r.writeDocumentHeader(w)
|
|
|
839 if r.Flags&TOC != 0 {
|
|
|
840 r.writeTOC(w, ast)
|
|
|
841 }
|
|
|
842 }
|
|
|
843
|
|
|
844 // RenderFooter writes HTML document footer.
|
|
|
845 func (r *HTMLRenderer) RenderFooter(w io.Writer, ast *Node) {
|
|
|
846 if r.Flags&CompletePage == 0 {
|
|
|
847 return
|
|
|
848 }
|
|
|
849 io.WriteString(w, "\n</body>\n</html>\n")
|
|
|
850 }
|
|
|
851
|
|
|
852 func (r *HTMLRenderer) writeDocumentHeader(w io.Writer) {
|
|
|
853 if r.Flags&CompletePage == 0 {
|
|
|
854 return
|
|
|
855 }
|
|
|
856 ending := ""
|
|
|
857 if r.Flags&UseXHTML != 0 {
|
|
|
858 io.WriteString(w, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" ")
|
|
|
859 io.WriteString(w, "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n")
|
|
|
860 io.WriteString(w, "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n")
|
|
|
861 ending = " /"
|
|
|
862 } else {
|
|
|
863 io.WriteString(w, "<!DOCTYPE html>\n")
|
|
|
864 io.WriteString(w, "<html>\n")
|
|
|
865 }
|
|
|
866 io.WriteString(w, "<head>\n")
|
|
|
867 io.WriteString(w, " <title>")
|
|
|
868 if r.Flags&Smartypants != 0 {
|
|
|
869 r.sr.Process(w, []byte(r.Title))
|
|
|
870 } else {
|
|
|
871 escapeHTML(w, []byte(r.Title))
|
|
|
872 }
|
|
|
873 io.WriteString(w, "</title>\n")
|
|
|
874 io.WriteString(w, " <meta name=\"GENERATOR\" content=\"Blackfriday Markdown Processor v")
|
|
|
875 io.WriteString(w, Version)
|
|
|
876 io.WriteString(w, "\"")
|
|
|
877 io.WriteString(w, ending)
|
|
|
878 io.WriteString(w, ">\n")
|
|
|
879 io.WriteString(w, " <meta charset=\"utf-8\"")
|
|
|
880 io.WriteString(w, ending)
|
|
|
881 io.WriteString(w, ">\n")
|
|
|
882 if r.CSS != "" {
|
|
|
883 io.WriteString(w, " <link rel=\"stylesheet\" type=\"text/css\" href=\"")
|
|
|
884 escapeHTML(w, []byte(r.CSS))
|
|
|
885 io.WriteString(w, "\"")
|
|
|
886 io.WriteString(w, ending)
|
|
|
887 io.WriteString(w, ">\n")
|
|
|
888 }
|
|
|
889 if r.Icon != "" {
|
|
|
890 io.WriteString(w, " <link rel=\"icon\" type=\"image/x-icon\" href=\"")
|
|
|
891 escapeHTML(w, []byte(r.Icon))
|
|
|
892 io.WriteString(w, "\"")
|
|
|
893 io.WriteString(w, ending)
|
|
|
894 io.WriteString(w, ">\n")
|
|
|
895 }
|
|
|
896 io.WriteString(w, "</head>\n")
|
|
|
897 io.WriteString(w, "<body>\n\n")
|
|
|
898 }
|
|
|
899
|
|
|
900 func (r *HTMLRenderer) writeTOC(w io.Writer, ast *Node) {
|
|
|
901 buf := bytes.Buffer{}
|
|
|
902
|
|
|
903 inHeading := false
|
|
|
904 tocLevel := 0
|
|
|
905 headingCount := 0
|
|
|
906
|
|
|
907 ast.Walk(func(node *Node, entering bool) WalkStatus {
|
|
|
908 if node.Type == Heading && !node.HeadingData.IsTitleblock {
|
|
|
909 inHeading = entering
|
|
|
910 if entering {
|
|
|
911 node.HeadingID = fmt.Sprintf("toc_%d", headingCount)
|
|
|
912 if node.Level == tocLevel {
|
|
|
913 buf.WriteString("</li>\n\n<li>")
|
|
|
914 } else if node.Level < tocLevel {
|
|
|
915 for node.Level < tocLevel {
|
|
|
916 tocLevel--
|
|
|
917 buf.WriteString("</li>\n</ul>")
|
|
|
918 }
|
|
|
919 buf.WriteString("</li>\n\n<li>")
|
|
|
920 } else {
|
|
|
921 for node.Level > tocLevel {
|
|
|
922 tocLevel++
|
|
|
923 buf.WriteString("\n<ul>\n<li>")
|
|
|
924 }
|
|
|
925 }
|
|
|
926
|
|
|
927 fmt.Fprintf(&buf, `<a href="#toc_%d">`, headingCount)
|
|
|
928 headingCount++
|
|
|
929 } else {
|
|
|
930 buf.WriteString("</a>")
|
|
|
931 }
|
|
|
932 return GoToNext
|
|
|
933 }
|
|
|
934
|
|
|
935 if inHeading {
|
|
|
936 return r.RenderNode(&buf, node, entering)
|
|
|
937 }
|
|
|
938
|
|
|
939 return GoToNext
|
|
|
940 })
|
|
|
941
|
|
|
942 for ; tocLevel > 0; tocLevel-- {
|
|
|
943 buf.WriteString("</li>\n</ul>")
|
|
|
944 }
|
|
|
945
|
|
|
946 if buf.Len() > 0 {
|
|
|
947 io.WriteString(w, "<nav>\n")
|
|
|
948 w.Write(buf.Bytes())
|
|
|
949 io.WriteString(w, "\n\n</nav>\n")
|
|
|
950 }
|
|
|
951 r.lastOutputLen = buf.Len()
|
|
|
952 }
|
