package web import ( "encoding/json" "fmt" "html/template" "io" "net/http" "regexp" "strings" ) // mathSpan finds what KaTeX will typeset, in the order its delimiters are // tried on the page: display before inline, and a single $ last. // // A single-$ span must not start or end with a space. That is what keeps // "$5 and $10" a sentence about prices rather than a formula, as KaTeX's own // rule does. var mathSpan = regexp.MustCompile(`(?s)\$\$.+?\$\$|\\\[.+?\\\]|\\\(.+?\\\)|\$[^\s$](?:[^$\n]*?[^\s$])?\$`) // codeSpan finds fenced code blocks and inline code, which maths is not // looked for in. A fence left open — a reply cut off mid-block — is not // matched, and is read as text. var codeSpan = regexp.MustCompile("(?s)(?:^|\n)[ \t]*(```|~~~).*?\n[ \t]*(?:```|~~~)[^\n]*|`[^`\n]+`") // renderReply turns a model's reply into HTML for the chat page. // // Markdown with the model card's rules — raw HTML dropped, dangerous links // emptied, images shown as links — with the maths set aside first. Read as // markdown, "a_1 * b_2" loses its underscores to emphasis before KaTeX ever // sees it; set aside, it reaches the page as the text the model wrote, for // KaTeX to typeset there. func renderReply(reply string) template.HTML { var spans []string protect := func(text string) string { return mathSpan.ReplaceAllStringFunc(text, func(m string) string { spans = append(spans, m) // Letters and digits only, so no markdown rule touches it. return fmt.Sprintf("llmgwmath%dx", len(spans)-1) }) } // Only outside code: "echo $HOME $PATH" in a code block is shell, and a // formula quoted in backticks is being shown, not typeset. var b strings.Builder last := 0 for _, c := range codeSpan.FindAllStringIndex(reply, -1) { b.WriteString(protect(reply[last:c[0]])) b.WriteString(reply[c[0]:c[1]]) last = c[1] } b.WriteString(protect(reply[last:])) protected := b.String() out := string(safeMarkdown(protected, "")) for i, m := range spans { out = strings.Replace(out, fmt.Sprintf("llmgwmath%dx", i), mathElement(m), 1) } return template.HTML(out) //nolint:gosec // goldmark's safe output, maths escaped } // mathElement marks one span of maths for the page to typeset, its // delimiters removed and the TeX escaped as text. // // Marked here rather than found again in the page: KaTeX's own search, run // over the reply, took "$5 and $10" for a formula. Deciding once, on the // server, with the stricter rule above, means the page typesets exactly what // was set aside and nothing else. Inside a code block the mark is shown as // the text it replaced, since that is all a code block holds. func mathElement(m string) string { tex, display := m, false switch { case strings.HasPrefix(m, "$$"): tex, display = m[2:len(m)-2], true case strings.HasPrefix(m, `\[`): tex, display = m[2:len(m)-2], true case strings.HasPrefix(m, `\(`): tex = m[2 : len(m)-2] default: tex = m[1 : len(m)-1] } mode := "0" if display { mode = "1" } return `` + template.HTMLEscapeString(tex) + `` } // ReplyRenderer answers the chat page's request to render a finished reply. // // On the server rather than in the page: the markdown rules are then the // model card's, already written and tested, and the page carries no parser // of its own. func ReplyRenderer(maxBody int64) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var in struct { Content string `json:"content"` } body, err := io.ReadAll(io.LimitReader(r.Body, maxBody)) if err != nil || json.Unmarshal(body, &in) != nil { http.Error(w, "send the reply as {\"content\": ...}", http.StatusBadRequest) return } w.Header().Set("Content-Type", "text/html; charset=utf-8") _, _ = io.WriteString(w, string(renderReply(in.Content))) } }