prime8dev

markdown.go (4391B)

---

 package tui
 
 import (
 	"regexp"
 	"strings"
 
 	termmarkdown "github.com/MichaelMure/go-term-markdown"
 )
 
 var (
 	ansiEscapeRE         = regexp.MustCompile(`\x1b\[[0-9;]*m`)
 	urlRE                = regexp.MustCompile(`https?://[^\s)]+`)
 	headingNumberTokenRE = regexp.MustCompile(`^\d+(?:\.\d+)+$`)
 	horizontalRuleLineRE = regexp.MustCompile(`^\s*─+\s*$`)
 	alphaNumericRE       = regexp.MustCompile(`[A-Za-z0-9]`)
 	ansiArtGlyphRE       = regexp.MustCompile(`[█▓▒░▄▀▌▐▖▗▘▙▚▛▜▝▞▟⣿⣀-⣿]`)
 	markdownImageRE      = regexp.MustCompile(`!\[[^\]]*\]\([^\)]+\)`)
 	htmlImageRE          = regexp.MustCompile(`(?i)<img\b`)
 )
 
 func renderMarkdown(markdown string, width int) string {
 	markdown = strings.TrimSpace(markdown)
 	if markdown == "" {
 		return ""
 	}
 
 	width = max(width, 20)
 	renderWidth := markdownRenderWidth(markdown, width)
 	out := termmarkdown.Render(markdown, renderWidth, 0)
 	if len(out) == 0 {
 		return markdown
 	}
 
 	return styleRenderedMarkdown(strings.TrimRight(string(out), "\n"))
 }
 
 func styleRenderedMarkdown(rendered string) string {
 	lines := strings.Split(rendered, "\n")
 	plainLines := make([]string, len(lines))
 	preserveANSI := make([]bool, len(lines))
 	for i := range lines {
 		plainLines[i] = ansiEscapeRE.ReplaceAllString(lines[i], "")
 		preserveANSI[i] = shouldPreserveANSILine(lines[i], plainLines[i])
 	}
 
 	headingOpen := false
 
 	for i := range lines {
 		if preserveANSI[i] {
 			continue
 		}
 
 		plainLine := plainLines[i]
 		trimmed := strings.TrimSpace(plainLine)
 		if trimmed == "" {
 			lines[i] = ""
 			headingOpen = false
 			continue
 		}
 		if horizontalRuleLineRE.MatchString(trimmed) {
 			lines[i] = dimStyle.Render(plainLine)
 			headingOpen = false
 			continue
 		}
 
 		line, headingStart := stripHeadingNumber(plainLine, plainLines, i)
 		if headingStart {
 			lines[i] = titleStyle.Render(line)
 			headingOpen = true
 			continue
 		}
 		if headingOpen {
 			lines[i] = titleStyle.Render(plainLine)
 			continue
 		}
 
 		lines[i] = styleBodyLine(plainLine)
 	}
 
 	return strings.Join(lines, "\n")
 }
 
 func markdownRenderWidth(markdown string, width int) int {
 	if !markdownHasImages(markdown) {
 		return width
 	}
 
 	reduced := int(float64(width) * 0.72)
 	return max(min(reduced, width), 20)
 }
 
 func markdownHasImages(markdown string) bool {
 	return markdownImageRE.MatchString(markdown) || htmlImageRE.MatchString(markdown)
 }
 
 func shouldPreserveANSILine(raw string, plain string) bool {
 	if !ansiEscapeRE.MatchString(raw) {
 		return false
 	}
 
 	trimmed := strings.TrimSpace(plain)
 	if trimmed == "" {
 		return true
 	}
 	if alphaNumericRE.MatchString(trimmed) {
 		return false
 	}
 
 	return ansiArtGlyphRE.MatchString(trimmed)
 }
 
 func stripHeadingNumber(line string, lines []string, lineIdx int) (string, bool) {
 	trimmed := strings.TrimSpace(line)
 	if trimmed == "" {
 		return line, false
 	}
 
 	parts := strings.Fields(trimmed)
 	if len(parts) < 2 {
 		return line, false
 	}
 
 	token := parts[0]
 	isOrderedList := strings.HasSuffix(token, ".")
 	isNestedHeading := headingNumberTokenRE.MatchString(token)
 	isTopLevelHeading := isDigitsOnly(token) && hasRuleBeforeBlank(lines, lineIdx)
 	if isOrderedList || (!isNestedHeading && !isTopLevelHeading) {
 		return line, false
 	}
 
 	leading := len(line) - len(strings.TrimLeft(line, " "))
 	body := strings.TrimLeft(line[leading:], " ")
 	if !strings.HasPrefix(body, token) {
 		return line, false
 	}
 
 	body = strings.TrimLeft(body[len(token):], " ")
 	return line[:leading] + body, true
 }
 
 func hasRuleBeforeBlank(lines []string, lineIdx int) bool {
 	for i := lineIdx + 1; i < len(lines); i++ {
 		trimmed := strings.TrimSpace(lines[i])
 		if trimmed == "" {
 			return false
 		}
 		if horizontalRuleLineRE.MatchString(trimmed) {
 			return true
 		}
 	}
 
 	return false
 }
 
 func styleBodyLine(line string) string {
 	matches := urlRE.FindAllStringIndex(line, -1)
 	if len(matches) == 0 {
 		return rowStyle.Render(line)
 	}
 
 	var b strings.Builder
 	cursor := 0
 	for _, match := range matches {
 		if match[0] > cursor {
 			b.WriteString(rowStyle.Render(line[cursor:match[0]]))
 		}
 		b.WriteString(linkStyle.Render(line[match[0]:match[1]]))
 		cursor = match[1]
 	}
 	if cursor < len(line) {
 		b.WriteString(rowStyle.Render(line[cursor:]))
 	}
 
 	return b.String()
 }
 
 func isDigitsOnly(s string) bool {
 	if s == "" {
 		return false
 	}
 
 	for _, ch := range s {
 		if ch < '0' || ch > '9' {
 			return false
 		}
 	}
 
 	return true
 }