BlueGit

timfa bluegit

Files

bluegit / internal / markdown / images.go

images.go

images.go 9.5 KiB Download Raw
1package markdown
2
3import (
4 "html"
5 "net/url"
6 "path"
7 "strings"
8)
9
10// Afbeeldingen in Markdown. Een relatief pad wijst naar het bestand in de repo
11// en wordt een /-/raw/-adres op dezelfde ref. Een .svg krijgt as=img, zodat de
12// server hem als image/svg+xml in een sandbox levert; een <img> voert nooit
13// script uit. Ruwe HTML blijft geëscaped, behalve een kleine, herschreven set
14// tags (img, a, br, en omhullende p/div/center/picture/span zonder attributen).
15
16var imageExts = map[string]bool{".png": true, ".jpg": true, ".jpeg": true, ".gif": true, ".webp": true, ".svg": true, ".avif": true, ".bmp": true, ".ico": true}
17
18// splitBlobBase splitst /owner/repo/-/blob/dir/ in /owner/repo/-/blob/ en dir/.
19func splitBlobBase(linkBase string) (root, dir string, ok bool) {
20 const mark = "/-/blob/"
21 i := strings.Index(linkBase, mark)
22 if i < 0 {
23 return "", "", false
24 }
25 return linkBase[:i+len(mark)], linkBase[i+len(mark):], true
26}
27
28// cleanRepoPath maakt van href een pad vanaf de repo-root, met dir als map van
29// het document. Een leidende / is de repo-root; .. kan nooit boven de root uit.
30// Een #anker blijft achteraan staan.
31func cleanRepoPath(dir, href string) string {
32 p, _ := cleanRepoPathFrag(dir, href)
33 return p
34}
35
36func cleanRepoPathFrag(dir, href string) (string, string) {
37 frag := ""
38 if j := strings.IndexByte(href, '#'); j >= 0 {
39 href, frag = href[:j], href[j:]
40 }
41 if j := strings.IndexByte(href, '?'); j >= 0 {
42 href = href[:j]
43 }
44 if un, err := url.PathUnescape(href); err == nil {
45 href = un
46 }
47 var p string
48 if strings.HasPrefix(href, "/") {
49 p = path.Clean(href)
50 } else {
51 p = path.Clean("/" + dir + "/" + href)
52 }
53 p = strings.TrimPrefix(p, "/")
54 segs := strings.Split(p, "/")
55 for k := range segs {
56 segs[k] = url.PathEscape(segs[k])
57 }
58 return strings.Join(segs, "/"), frag
59}
60
61// rawBase geeft het /-/raw/-voorvoegsel en de map voor relatieve afbeeldingen.
62func rawBase(linkBase, repoPath string) (root, dir string, ok bool) {
63 if r, d, ok := splitBlobBase(linkBase); ok {
64 return strings.TrimSuffix(r, "/-/blob/") + "/-/raw/", d, true
65 }
66 if repoPath != "" {
67 return "/" + strings.Trim(repoPath, "/") + "/-/raw/", "", true
68 }
69 return "", "", false
70}
71
72// imageSrc maakt een veilig src-adres, of "" als het niet mag.
73func imageSrc(src, linkBase, rev, repoPath string) string {
74 src = strings.TrimSpace(src)
75 src = strings.TrimSuffix(strings.TrimPrefix(src, "<"), ">")
76 src = strings.ReplaceAll(src, " ", "%20")
77 if src == "" || strings.ContainsAny(src, "\"'<>\\`\x00\n\r\t ") {
78 return ""
79 }
80 lower := strings.ToLower(src)
81 switch {
82 case strings.HasPrefix(lower, "https://"):
83 return src
84 case strings.HasPrefix(lower, "data:image/") && !strings.HasPrefix(lower, "data:image/svg"):
85 return src
86 case strings.HasPrefix(lower, "//"), hasScheme(lower):
87 // http:, javascript:, data:text/..., schema-relatief: niet laden.
88 return ""
89 }
90 if strings.HasPrefix(src, "#") {
91 return ""
92 }
93 root, dir, ok := rawBase(linkBase, repoPath)
94 if !ok {
95 // Geen repo (bv. /help): alleen relatief aan linkBase.
96 if linkBase == "" {
97 return ""
98 }
99 return linkBase + strings.TrimPrefix(src, "./")
100 }
101 rel := cleanRepoPath(dir, src)
102 if rel == "" || rel == "." {
103 return ""
104 }
105 q := url.Values{}
106 if rev != "" {
107 q.Set("rev", rev)
108 }
109 if strings.EqualFold(path.Ext(rel), ".svg") {
110 q.Set("as", "img")
111 }
112 out := root + rel
113 if len(q) > 0 {
114 out += "?" + encodeOrdered(q)
115 }
116 return out
117}
118
119// encodeOrdered zet rev vóór as, zodat adressen voorspelbaar zijn.
120func encodeOrdered(q url.Values) string {
121 var parts []string
122 for _, k := range []string{"rev", "as"} {
123 if v := q.Get(k); v != "" {
124 parts = append(parts, k+"="+url.QueryEscape(v))
125 }
126 }
127 return strings.Join(parts, "&")
128}
129
130// imageTag schrijft een <img>; zonder geldige bron alleen de alt-tekst.
131func imageTag(src, alt, title, width, height, linkBase, rev, repoPath string) string {
132 u := imageSrc(src, linkBase, rev, repoPath)
133 if u == "" {
134 return html.EscapeString(alt)
135 }
136 var b strings.Builder
137 b.WriteString(`<img class="mdimg" src="`)
138 b.WriteString(html.EscapeString(u))
139 b.WriteString(`" alt="`)
140 b.WriteString(html.EscapeString(alt))
141 b.WriteString(`"`)
142 if title != "" {
143 b.WriteString(` title="`)
144 b.WriteString(html.EscapeString(title))
145 b.WriteString(`"`)
146 }
147 if w := dimension(width); w != "" {
148 b.WriteString(` width="` + w + `"`)
149 }
150 if h := dimension(height); h != "" {
151 b.WriteString(` height="` + h + `"`)
152 }
153 b.WriteString(` loading="lazy" decoding="async" referrerpolicy="no-referrer">`)
154 return b.String()
155}
156
157// dimension laat alleen een getal (pixels) door, maximaal vier cijfers.
158func dimension(v string) string {
159 v = strings.TrimSuffix(strings.TrimSpace(v), "px")
160 if v == "" || len(v) > 4 {
161 return ""
162 }
163 for _, c := range v {
164 if c < '0' || c > '9' {
165 return ""
166 }
167 }
168 return v
169}
170
171// bracketLink leest [tekst](doel) vanaf s[i] == '[' met geneste haken.
172func bracketLink(s string, i int) (text, dest string, n int, ok bool) {
173 if i >= len(s) || s[i] != '[' {
174 return "", "", 0, false
175 }
176 depth := 0
177 j := i
178 for ; j < len(s); j++ {
179 switch s[j] {
180 case '\\':
181 j++
182 case '[':
183 depth++
184 case ']':
185 depth--
186 }
187 if depth == 0 {
188 break
189 }
190 }
191 if j >= len(s) || j+1 >= len(s) || s[j+1] != '(' {
192 return "", "", 0, false
193 }
194 text = s[i+1 : j]
195 k := j + 2
196 pd := 1
197 for ; k < len(s); k++ {
198 if s[k] == '(' {
199 pd++
200 } else if s[k] == ')' {
201 pd--
202 if pd == 0 {
203 break
204 }
205 }
206 }
207 if k >= len(s) {
208 return "", "", 0, false
209 }
210 dest = strings.TrimSpace(s[j+2 : k])
211 if dest == "" {
212 return "", "", 0, false
213 }
214 return text, dest, k + 1 - i, true
215}
216
217// splitTitle haalt een "titel" achter het doel weg.
218func splitTitle(dest string) (href, title string) {
219 dest = strings.TrimSpace(dest)
220 if sp := strings.IndexAny(dest, " \t"); sp > 0 {
221 rest := strings.TrimSpace(dest[sp:])
222 if len(rest) >= 2 && (rest[0] == '"' && rest[len(rest)-1] == '"' || rest[0] == '\'' && rest[len(rest)-1] == '\'') {
223 return dest[:sp], rest[1 : len(rest)-1]
224 }
225 return dest[:sp], ""
226 }
227 return dest, ""
228}
229
230// plainText haalt eenvoudige Markdown-tekens uit een alt-tekst.
231func plainText(s string) string {
232 return strings.NewReplacer("**", "", "*", "", "`", "").Replace(s)
233}
234
235// bareImage maakt van een los https-adres naar een afbeelding een <img> met link.
236func bareImage(s, linkBase, rev, repoPath string) (string, int, bool) {
237 if !strings.HasPrefix(strings.ToLower(s), "https://") {
238 return "", 0, false
239 }
240 end := strings.IndexAny(s, " \t<>\"'`")
241 if end < 0 {
242 end = len(s)
243 }
244 u := strings.TrimRight(s[:end], ".,;:!?)")
245 p := u
246 if q := strings.IndexAny(p, "?#"); q >= 0 {
247 p = p[:q]
248 }
249 if !imageExts[strings.ToLower(path.Ext(p))] {
250 return "", 0, false
251 }
252 parsed, err := url.Parse(u)
253 if err != nil || parsed.Host == "" {
254 return "", 0, false
255 }
256 img := imageTag(u, path.Base(parsed.Path), "", "", "", linkBase, rev, repoPath)
257 return `<a href="` + html.EscapeString(u) + `" rel="noopener noreferrer">` + img + `</a>`, len(u), true
258}
259
260// htmlTag herschrijft een toegestane HTML-tag. Al het andere blijft tekst.
261func htmlTag(s, linkBase, rev, repoPath string, anchors *int) (string, int, bool) {
262 end := strings.IndexByte(s, '>')
263 if end < 0 || end > 4000 {
264 return "", 0, false
265 }
266 raw := s[1:end]
267 closing := strings.HasPrefix(raw, "/")
268 raw = strings.TrimPrefix(raw, "/")
269 raw = strings.TrimSuffix(strings.TrimSpace(raw), "/")
270 name := raw
271 if sp := strings.IndexAny(raw, " \t\n"); sp >= 0 {
272 name = raw[:sp]
273 }
274 name = strings.ToLower(name)
275 attrs, okAttrs := parseAttrs(raw[len(name):])
276 if !okAttrs {
277 return "", 0, false
278 }
279 n := end + 1
280 switch name {
281 case "img":
282 if closing {
283 return "", n, true
284 }
285 return imageTag(attrs["src"], attrs["alt"], attrs["title"], attrs["width"], attrs["height"], linkBase, rev, repoPath), n, true
286 case "br":
287 return "<br>", n, true
288 case "a":
289 if closing {
290 if *anchors == 0 {
291 return "", n, true
292 }
293 *anchors--
294 return "</a>", n, true
295 }
296 href, ok := attrs["href"]
297 if !ok {
298 return "", 0, false
299 }
300 h := strings.TrimSpace(href)
301 lower := strings.ToLower(h)
302 if strings.Contains(lower, ":") && !strings.HasPrefix(lower, "https://") && !strings.HasPrefix(lower, "http://") && !strings.HasPrefix(lower, "mailto:") {
303 return "", 0, false
304 }
305 *anchors++
306 return `<a href="` + html.EscapeString(resolveLink(h, linkBase, rev)) + `" rel="noopener noreferrer">`, n, true
307 case "p", "div", "center", "picture", "span", "source", "sup", "sub":
308 // Omhulsels (vaak <p align="center">) vallen weg; de inhoud blijft.
309 return "", n, true
310 }
311 return "", 0, false
312}
313
314// parseAttrs leest name="waarde"-paren. Ongeldige syntaxis geeft ok=false.
315func parseAttrs(s string) (map[string]string, bool) {
316 out := map[string]string{}
317 i := 0
318 for {
319 for i < len(s) && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n') {
320 i++
321 }
322 if i >= len(s) {
323 return out, true
324 }
325 j := i
326 for j < len(s) && (isIdent(s[j]) || s[j] == '-' || s[j] == ':') {
327 j++
328 }
329 if j == i {
330 return nil, false
331 }
332 key := strings.ToLower(s[i:j])
333 i = j
334 if i < len(s) && s[i] == '=' {
335 i++
336 if i < len(s) && (s[i] == '"' || s[i] == '\'') {
337 q := s[i]
338 k := strings.IndexByte(s[i+1:], q)
339 if k < 0 {
340 return nil, false
341 }
342 out[key] = html.UnescapeString(s[i+1 : i+1+k])
343 i += k + 2
344 } else {
345 k := i
346 for k < len(s) && s[k] != ' ' && s[k] != '\t' && s[k] != '\n' {
347 k++
348 }
349 out[key] = html.UnescapeString(s[i:k])
350 i = k
351 }
352 } else {
353 out[key] = ""
354 }
355 }
356}
357
358// hasScheme ziet een "schema:" vóór de eerste /, ? of #.
359func hasScheme(s string) bool {
360 c := strings.IndexByte(s, ':')
361 if c < 0 {
362 return false
363 }
364 if k := strings.IndexAny(s, "/?#"); k >= 0 && k < c {
365 return false
366 }
367 return true
368}