package markdown import ( "html" "net/url" "path" "strings" ) // Afbeeldingen in Markdown. Een relatief pad wijst naar het bestand in de repo // en wordt een /-/raw/-adres op dezelfde ref. Een .svg krijgt as=img, zodat de // server hem als image/svg+xml in een sandbox levert; een voert nooit // script uit. Ruwe HTML blijft geëscaped, behalve een kleine, herschreven set // tags (img, a, br, en omhullende p/div/center/picture/span zonder attributen). var imageExts = map[string]bool{".png": true, ".jpg": true, ".jpeg": true, ".gif": true, ".webp": true, ".svg": true, ".avif": true, ".bmp": true, ".ico": true} // splitBlobBase splitst /owner/repo/-/blob/dir/ in /owner/repo/-/blob/ en dir/. func splitBlobBase(linkBase string) (root, dir string, ok bool) { const mark = "/-/blob/" i := strings.Index(linkBase, mark) if i < 0 { return "", "", false } return linkBase[:i+len(mark)], linkBase[i+len(mark):], true } // cleanRepoPath maakt van href een pad vanaf de repo-root, met dir als map van // het document. Een leidende / is de repo-root; .. kan nooit boven de root uit. // Een #anker blijft achteraan staan. func cleanRepoPath(dir, href string) string { p, _ := cleanRepoPathFrag(dir, href) return p } func cleanRepoPathFrag(dir, href string) (string, string) { frag := "" if j := strings.IndexByte(href, '#'); j >= 0 { href, frag = href[:j], href[j:] } if j := strings.IndexByte(href, '?'); j >= 0 { href = href[:j] } if un, err := url.PathUnescape(href); err == nil { href = un } var p string if strings.HasPrefix(href, "/") { p = path.Clean(href) } else { p = path.Clean("/" + dir + "/" + href) } p = strings.TrimPrefix(p, "/") segs := strings.Split(p, "/") for k := range segs { segs[k] = url.PathEscape(segs[k]) } return strings.Join(segs, "/"), frag } // rawBase geeft het /-/raw/-voorvoegsel en de map voor relatieve afbeeldingen. func rawBase(linkBase, repoPath string) (root, dir string, ok bool) { if r, d, ok := splitBlobBase(linkBase); ok { return strings.TrimSuffix(r, "/-/blob/") + "/-/raw/", d, true } if repoPath != "" { return "/" + strings.Trim(repoPath, "/") + "/-/raw/", "", true } return "", "", false } // imageSrc maakt een veilig src-adres, of "" als het niet mag. func imageSrc(src, linkBase, rev, repoPath string) string { src = strings.TrimSpace(src) src = strings.TrimSuffix(strings.TrimPrefix(src, "<"), ">") src = strings.ReplaceAll(src, " ", "%20") if src == "" || strings.ContainsAny(src, "\"'<>\\`\x00\n\r\t ") { return "" } lower := strings.ToLower(src) switch { case strings.HasPrefix(lower, "https://"): return src case strings.HasPrefix(lower, "data:image/") && !strings.HasPrefix(lower, "data:image/svg"): return src case strings.HasPrefix(lower, "//"), hasScheme(lower): // http:, javascript:, data:text/..., schema-relatief: niet laden. return "" } if strings.HasPrefix(src, "#") { return "" } root, dir, ok := rawBase(linkBase, repoPath) if !ok { // Geen repo (bv. /help): alleen relatief aan linkBase. if linkBase == "" { return "" } return linkBase + strings.TrimPrefix(src, "./") } rel := cleanRepoPath(dir, src) if rel == "" || rel == "." { return "" } q := url.Values{} if rev != "" { q.Set("rev", rev) } if strings.EqualFold(path.Ext(rel), ".svg") { q.Set("as", "img") } out := root + rel if len(q) > 0 { out += "?" + encodeOrdered(q) } return out } // encodeOrdered zet rev vóór as, zodat adressen voorspelbaar zijn. func encodeOrdered(q url.Values) string { var parts []string for _, k := range []string{"rev", "as"} { if v := q.Get(k); v != "" { parts = append(parts, k+"="+url.QueryEscape(v)) } } return strings.Join(parts, "&") } // imageTag schrijft een ; zonder geldige bron alleen de alt-tekst. func imageTag(src, alt, title, width, height, linkBase, rev, repoPath string) string { u := imageSrc(src, linkBase, rev, repoPath) if u == "" { return html.EscapeString(alt) } var b strings.Builder b.WriteString(``)
	b.WriteString(html.EscapeString(alt))
	b.WriteString(``) return b.String() } // dimension laat alleen een getal (pixels) door, maximaal vier cijfers. func dimension(v string) string { v = strings.TrimSuffix(strings.TrimSpace(v), "px") if v == "" || len(v) > 4 { return "" } for _, c := range v { if c < '0' || c > '9' { return "" } } return v } // bracketLink leest [tekst](doel) vanaf s[i] == '[' met geneste haken. func bracketLink(s string, i int) (text, dest string, n int, ok bool) { if i >= len(s) || s[i] != '[' { return "", "", 0, false } depth := 0 j := i for ; j < len(s); j++ { switch s[j] { case '\\': j++ case '[': depth++ case ']': depth-- } if depth == 0 { break } } if j >= len(s) || j+1 >= len(s) || s[j+1] != '(' { return "", "", 0, false } text = s[i+1 : j] k := j + 2 pd := 1 for ; k < len(s); k++ { if s[k] == '(' { pd++ } else if s[k] == ')' { pd-- if pd == 0 { break } } } if k >= len(s) { return "", "", 0, false } dest = strings.TrimSpace(s[j+2 : k]) if dest == "" { return "", "", 0, false } return text, dest, k + 1 - i, true } // splitTitle haalt een "titel" achter het doel weg. func splitTitle(dest string) (href, title string) { dest = strings.TrimSpace(dest) if sp := strings.IndexAny(dest, " \t"); sp > 0 { rest := strings.TrimSpace(dest[sp:]) if len(rest) >= 2 && (rest[0] == '"' && rest[len(rest)-1] == '"' || rest[0] == '\'' && rest[len(rest)-1] == '\'') { return dest[:sp], rest[1 : len(rest)-1] } return dest[:sp], "" } return dest, "" } // plainText haalt eenvoudige Markdown-tekens uit een alt-tekst. func plainText(s string) string { return strings.NewReplacer("**", "", "*", "", "`", "").Replace(s) } // bareImage maakt van een los https-adres naar een afbeelding een met link. func bareImage(s, linkBase, rev, repoPath string) (string, int, bool) { if !strings.HasPrefix(strings.ToLower(s), "https://") { return "", 0, false } end := strings.IndexAny(s, " \t<>\"'`") if end < 0 { end = len(s) } u := strings.TrimRight(s[:end], ".,;:!?)") p := u if q := strings.IndexAny(p, "?#"); q >= 0 { p = p[:q] } if !imageExts[strings.ToLower(path.Ext(p))] { return "", 0, false } parsed, err := url.Parse(u) if err != nil || parsed.Host == "" { return "", 0, false } img := imageTag(u, path.Base(parsed.Path), "", "", "", linkBase, rev, repoPath) return `` + img + ``, len(u), true } // htmlTag herschrijft een toegestane HTML-tag. Al het andere blijft tekst. func htmlTag(s, linkBase, rev, repoPath string, anchors *int) (string, int, bool) { end := strings.IndexByte(s, '>') if end < 0 || end > 4000 { return "", 0, false } raw := s[1:end] closing := strings.HasPrefix(raw, "/") raw = strings.TrimPrefix(raw, "/") raw = strings.TrimSuffix(strings.TrimSpace(raw), "/") name := raw if sp := strings.IndexAny(raw, " \t\n"); sp >= 0 { name = raw[:sp] } name = strings.ToLower(name) attrs, okAttrs := parseAttrs(raw[len(name):]) if !okAttrs { return "", 0, false } n := end + 1 switch name { case "img": if closing { return "", n, true } return imageTag(attrs["src"], attrs["alt"], attrs["title"], attrs["width"], attrs["height"], linkBase, rev, repoPath), n, true case "br": return "
", n, true case "a": if closing { if *anchors == 0 { return "", n, true } *anchors-- return "", n, true } href, ok := attrs["href"] if !ok { return "", 0, false } h := strings.TrimSpace(href) lower := strings.ToLower(h) if strings.Contains(lower, ":") && !strings.HasPrefix(lower, "https://") && !strings.HasPrefix(lower, "http://") && !strings.HasPrefix(lower, "mailto:") { return "", 0, false } *anchors++ return ``, n, true case "p", "div", "center", "picture", "span", "source", "sup", "sub": // Omhulsels (vaak

) vallen weg; de inhoud blijft. return "", n, true } return "", 0, false } // parseAttrs leest name="waarde"-paren. Ongeldige syntaxis geeft ok=false. func parseAttrs(s string) (map[string]string, bool) { out := map[string]string{} i := 0 for { for i < len(s) && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n') { i++ } if i >= len(s) { return out, true } j := i for j < len(s) && (isIdent(s[j]) || s[j] == '-' || s[j] == ':') { j++ } if j == i { return nil, false } key := strings.ToLower(s[i:j]) i = j if i < len(s) && s[i] == '=' { i++ if i < len(s) && (s[i] == '"' || s[i] == '\'') { q := s[i] k := strings.IndexByte(s[i+1:], q) if k < 0 { return nil, false } out[key] = html.UnescapeString(s[i+1 : i+1+k]) i += k + 2 } else { k := i for k < len(s) && s[k] != ' ' && s[k] != '\t' && s[k] != '\n' { k++ } out[key] = html.UnescapeString(s[i:k]) i = k } } else { out[key] = "" } } } // hasScheme ziet een "schema:" vóór de eerste /, ? of #. func hasScheme(s string) bool { c := strings.IndexByte(s, ':') if c < 0 { return false } if k := strings.IndexAny(s, "/?#"); k >= 0 && k < c { return false } return true }