198 lines
5.8 KiB
Go
198 lines
5.8 KiB
Go
package grammaratur
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"io"
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/google/uuid"
|
|
"golang.org/x/net/html"
|
|
)
|
|
|
|
// HTMLToMarkdownAuthoring keeps source HTML when conversion loses structure,
|
|
// attributes, comments or text. This is not a sanitization boundary.
|
|
func HTMLToMarkdownAuthoring(source string) (string, error) {
|
|
converted, err := HTMLToMarkdown(source)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if htmlStructure(source) != htmlStructure(MarkdownToHTML(converted)) {
|
|
// Protect only the blocks which cannot round-trip. One custom component
|
|
// must not turn the headings, lists and paragraphs around it into HTML.
|
|
blocks, ok := authoringBlocks(source)
|
|
if !ok {
|
|
return rawHTMLBlock(source), nil
|
|
}
|
|
var parts []string
|
|
for _, raw := range blocks {
|
|
if strings.TrimSpace(raw) == "" {
|
|
continue
|
|
}
|
|
md, e := HTMLToMarkdown(raw)
|
|
if e != nil || htmlStructure(raw) != htmlStructure(MarkdownToHTML(md)) {
|
|
md = rawHTMLBlock(raw)
|
|
}
|
|
parts = append(parts, md)
|
|
}
|
|
mixed := strings.Join(parts, "\n\n")
|
|
// Includes head content, comments outside body and fragment edge cases.
|
|
if htmlStructure(source) != htmlStructure(MarkdownAuthoringHTML(mixed)) {
|
|
return rawHTMLBlock(source), nil
|
|
}
|
|
return mixed, nil
|
|
}
|
|
return converted, nil
|
|
}
|
|
|
|
// Token boundaries retain the exact source of protected components (including
|
|
// attribute quoting and void-element syntax). Never serialize the parsed DOM
|
|
// back over their source. Malformed/implicit nesting uses whole-document fallback.
|
|
func authoringBlocks(source string) ([]string, bool) {
|
|
z := html.NewTokenizer(strings.NewReader(source))
|
|
var stack, blocks []string
|
|
start, offset := 0, 0
|
|
for {
|
|
kind := z.Next()
|
|
if kind == html.ErrorToken {
|
|
return blocks, z.Err() == io.EOF && len(stack) == 0 && offset == len(source)
|
|
}
|
|
offset += len(z.Raw())
|
|
switch kind {
|
|
case html.StartTagToken:
|
|
name, _ := z.TagName()
|
|
switch string(name) {
|
|
case "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr":
|
|
default:
|
|
stack = append(stack, string(name))
|
|
}
|
|
case html.EndTagToken:
|
|
name, _ := z.TagName()
|
|
if len(stack) == 0 || stack[len(stack)-1] != string(name) {
|
|
return nil, false
|
|
}
|
|
stack = stack[:len(stack)-1]
|
|
}
|
|
if len(stack) == 0 {
|
|
blocks = append(blocks, source[start:offset])
|
|
start = offset
|
|
if len(blocks) > 1024 {
|
|
return nil, false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// {=html} is an explicit authoring fence, not an ordinary code sample. The
|
|
// closing delimiter is longer than any run in the source, so arbitrary HTML
|
|
// (including Markdown examples) cannot accidentally terminate it.
|
|
func rawHTMLBlock(source string) string {
|
|
longest, run := 2, 0
|
|
for _, c := range source {
|
|
if c == '`' {
|
|
run++
|
|
if run > longest {
|
|
longest = run
|
|
}
|
|
} else {
|
|
run = 0
|
|
}
|
|
}
|
|
fence := strings.Repeat("`", longest+1)
|
|
return fence + "{=html}\n" + source + "\n" + fence
|
|
}
|
|
|
|
// MarkdownAuthoringHTML preserves protected HTML byte-for-byte while rendering
|
|
// ordinary Markdown. Callers must still apply projection sanitization for UI.
|
|
func MarkdownAuthoringHTML(source string) string {
|
|
lines := strings.SplitAfter(source, "\n")
|
|
var markdown strings.Builder
|
|
type rawBlock struct{ token, html string }
|
|
var blocks []rawBlock
|
|
var ordinary byte
|
|
ordinaryLen := 0
|
|
for i := 0; i < len(lines); i++ {
|
|
line := strings.TrimSuffix(strings.TrimSuffix(lines[i], "\n"), "\r")
|
|
char, n := byte(0), 0
|
|
if len(line) > 0 && (line[0] == '`' || line[0] == '~') {
|
|
char = line[0]
|
|
for n < len(line) && line[n] == char {
|
|
n++
|
|
}
|
|
}
|
|
if ordinary != 0 {
|
|
markdown.WriteString(lines[i])
|
|
if char == ordinary && n >= ordinaryLen && strings.TrimSpace(line[n:]) == "" {
|
|
ordinary = 0
|
|
}
|
|
continue
|
|
}
|
|
if char == '`' && n >= 3 && strings.TrimSpace(line[n:]) == "{=html}" {
|
|
end := i + 1
|
|
for ; end < len(lines); end++ {
|
|
close := strings.TrimSpace(lines[end])
|
|
if len(close) >= n && strings.Trim(close, "`") == "" {
|
|
break
|
|
}
|
|
}
|
|
if end < len(lines) {
|
|
raw := strings.TrimSuffix(strings.Join(lines[i+1:end], ""), "\n")
|
|
token := "PAGESWIKIRAW" + strings.ReplaceAll(uuid.NewString(), "-", "")
|
|
blocks = append(blocks, rawBlock{token, raw})
|
|
markdown.WriteString("\n\n" + token + "\n\n")
|
|
i = end
|
|
continue
|
|
}
|
|
}
|
|
if n >= 3 {
|
|
ordinary, ordinaryLen = char, n
|
|
}
|
|
markdown.WriteString(lines[i])
|
|
}
|
|
if len(blocks) == 1 && strings.TrimSpace(markdown.String()) == blocks[0].token {
|
|
return blocks[0].html
|
|
}
|
|
out := MarkdownToHTML(markdown.String())
|
|
for _, block := range blocks {
|
|
out = strings.Replace(out, "<p>"+block.token+"</p>", block.html, 1)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func htmlStructure(source string) string {
|
|
n, err := html.Parse(strings.NewReader(source))
|
|
if err != nil {
|
|
return source
|
|
}
|
|
var out bytes.Buffer
|
|
var visit func(*html.Node, bool)
|
|
visit = func(n *html.Node, literal bool) {
|
|
literal = literal || n.Data == "pre" || n.Data == "code" || n.Data == "script" || n.Data == "style"
|
|
data := n.Data
|
|
if n.Type == html.TextNode && !literal {
|
|
if strings.TrimSpace(data) == "" && n.Parent != nil {
|
|
switch n.Parent.Data {
|
|
case "ul", "ol", "table", "thead", "tbody", "tfoot", "tr":
|
|
return
|
|
}
|
|
}
|
|
if strings.TrimSpace(data) == "" && (n.Parent == nil || n.Parent.Data == "body" || n.Parent.Data == "html") {
|
|
return
|
|
}
|
|
// Inline whitespace can separate words (including around an inline
|
|
// element). Never normalize it away when deciding conversion safety.
|
|
}
|
|
attrs := append([]html.Attribute(nil), n.Attr...)
|
|
sort.Slice(attrs, func(i, j int) bool { return attrs[i].Namespace+":"+attrs[i].Key < attrs[j].Namespace+":"+attrs[j].Key })
|
|
b, _ := json.Marshal([]any{n.Type, n.Namespace, data, attrs})
|
|
out.Write(b)
|
|
for c := n.FirstChild; c != nil; c = c.NextSibling {
|
|
visit(c, literal)
|
|
}
|
|
out.WriteByte(')')
|
|
}
|
|
visit(n, false)
|
|
return out.String()
|
|
}
|