Chat Messages: components 201-220
This commit is contained in:
121 files changed
+5737
-1
No files matched your search
@@ -0,0 +1,305 @@
|
||||
package internal
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// BlockKind is the kind of a Markdown block.
|
||||
type BlockKind uint8
|
||||
|
||||
const (
|
||||
BlockParagraph BlockKind = iota
|
||||
BlockHeading
|
||||
BlockList
|
||||
BlockQuote
|
||||
BlockCode
|
||||
BlockTable
|
||||
BlockRule
|
||||
)
|
||||
|
||||
// MdSpan is a run of inline text with one style.
|
||||
type MdSpan struct {
|
||||
Text string
|
||||
// URL is set for a link.
|
||||
URL string
|
||||
Strong, Em, Code, Strike bool
|
||||
}
|
||||
|
||||
// MdItem is one list item.
|
||||
type MdItem struct {
|
||||
// Number is the ordinal of an ordered item, 0 for a bullet.
|
||||
Number int
|
||||
Depth int
|
||||
Spans []MdSpan
|
||||
}
|
||||
|
||||
// TableAlign is a table column's alignment.
|
||||
type TableAlign uint8
|
||||
|
||||
const (
|
||||
AlignLeft TableAlign = iota
|
||||
AlignCenter
|
||||
AlignRight
|
||||
)
|
||||
|
||||
// MdBlock is one parsed block.
|
||||
type MdBlock struct {
|
||||
Kind BlockKind
|
||||
// Level is a heading's level, 1 to 6.
|
||||
Level int
|
||||
// Spans hold a paragraph's, heading's or quote's text.
|
||||
Spans []MdSpan
|
||||
Items []MdItem
|
||||
// Lang and Code hold a fenced code block; Open is true until its fence closes.
|
||||
Lang, Code string
|
||||
Open bool
|
||||
Header []string
|
||||
Align []TableAlign
|
||||
Rows [][]string
|
||||
}
|
||||
|
||||
// Markdown is a document parsed incrementally as its source grows.
|
||||
type Markdown struct {
|
||||
src string
|
||||
Blocks []MdBlock
|
||||
starts []int
|
||||
}
|
||||
|
||||
// Update parses src and returns the index of the first block parsed anew.
|
||||
// When src extends the last source, blocks before the last stay as they are.
|
||||
func (m *Markdown) Update(src string) int {
|
||||
if src == m.src && m.starts != nil {
|
||||
return len(m.Blocks)
|
||||
}
|
||||
from := 0
|
||||
if len(m.Blocks) > 0 && strings.HasPrefix(src, m.src) {
|
||||
from = len(m.Blocks) - 1
|
||||
}
|
||||
off := 0
|
||||
if from > 0 {
|
||||
off = m.starts[from]
|
||||
}
|
||||
m.Blocks, m.starts = m.Blocks[:from], m.starts[:from]
|
||||
m.src = src
|
||||
parseBlocks(m, src, off)
|
||||
return from
|
||||
}
|
||||
|
||||
// mdLine is one source line and its byte offset.
|
||||
type mdLine struct {
|
||||
text string
|
||||
off int
|
||||
}
|
||||
|
||||
func parseBlocks(m *Markdown, src string, off int) {
|
||||
var lines []mdLine
|
||||
for off < len(src) {
|
||||
end := strings.IndexByte(src[off:], '\n')
|
||||
if end < 0 {
|
||||
lines = append(lines, mdLine{src[off:], off})
|
||||
break
|
||||
}
|
||||
lines = append(lines, mdLine{strings.TrimRight(src[off:off+end], "\r"), off})
|
||||
off += end + 1
|
||||
}
|
||||
for i := 0; i < len(lines); {
|
||||
l := lines[i].text
|
||||
if strings.TrimSpace(l) == "" {
|
||||
i++
|
||||
continue
|
||||
}
|
||||
start := lines[i].off
|
||||
var b MdBlock
|
||||
switch {
|
||||
case mdFence(l) != "":
|
||||
b, i = parseFenced(lines, i)
|
||||
case mdHeadingLevel(l) > 0:
|
||||
lv := mdHeadingLevel(l)
|
||||
b = MdBlock{Kind: BlockHeading, Level: lv, Spans: ParseInline(strings.TrimSpace(strings.TrimRight(l[lv:], "# ")))}
|
||||
i++
|
||||
case mdIsRule(l):
|
||||
b = MdBlock{Kind: BlockRule}
|
||||
i++
|
||||
case strings.HasPrefix(strings.TrimLeft(l, " "), ">"):
|
||||
b, i = parseQuote(lines, i)
|
||||
case mdListMarker(l) != nil:
|
||||
b, i = parseList(lines, i)
|
||||
case i+1 < len(lines) && strings.Contains(l, "|") && mdDelimiter(lines[i+1].text) != nil:
|
||||
b, i = parseTable(lines, i)
|
||||
default:
|
||||
b, i = parseParagraph(lines, i)
|
||||
}
|
||||
m.Blocks = append(m.Blocks, b)
|
||||
m.starts = append(m.starts, start)
|
||||
}
|
||||
}
|
||||
|
||||
// mdStarts reports whether line l begins a block other than a paragraph.
|
||||
func mdStarts(lines []mdLine, i int) bool {
|
||||
l := lines[i].text
|
||||
return strings.TrimSpace(l) == "" || mdFence(l) != "" || mdHeadingLevel(l) > 0 || mdIsRule(l) ||
|
||||
strings.HasPrefix(strings.TrimLeft(l, " "), ">") || mdListMarker(l) != nil ||
|
||||
i+1 < len(lines) && strings.Contains(l, "|") && mdDelimiter(lines[i+1].text) != nil
|
||||
}
|
||||
|
||||
func parseParagraph(lines []mdLine, i int) (MdBlock, int) {
|
||||
var parts []string
|
||||
for ; i < len(lines) && (len(parts) == 0 || !mdStarts(lines, i)); i++ {
|
||||
parts = append(parts, strings.TrimSpace(lines[i].text))
|
||||
}
|
||||
return MdBlock{Kind: BlockParagraph, Spans: ParseInline(strings.Join(parts, " "))}, i
|
||||
}
|
||||
|
||||
// mdFence returns the fence a line opens, "```" or "~~~", or "".
|
||||
func mdFence(l string) string {
|
||||
t := strings.TrimLeft(l, " ")
|
||||
for _, f := range []string{"```", "~~~"} {
|
||||
if strings.HasPrefix(t, f) {
|
||||
return f
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func parseFenced(lines []mdLine, i int) (MdBlock, int) {
|
||||
fence := mdFence(lines[i].text)
|
||||
b := MdBlock{Kind: BlockCode, Open: true, Lang: strings.ToLower(strings.TrimSpace(strings.TrimLeft(strings.TrimSpace(lines[i].text), fence[:1])))}
|
||||
var code []string
|
||||
for i++; i < len(lines); i++ {
|
||||
if strings.HasPrefix(strings.TrimSpace(lines[i].text), fence) && strings.Trim(strings.TrimSpace(lines[i].text), fence[:1]) == "" {
|
||||
b.Open = false
|
||||
i++
|
||||
break
|
||||
}
|
||||
code = append(code, lines[i].text)
|
||||
}
|
||||
b.Code = strings.Join(code, "\n")
|
||||
return b, i
|
||||
}
|
||||
|
||||
func mdHeadingLevel(l string) int {
|
||||
n := 0
|
||||
for n < len(l) && l[n] == '#' {
|
||||
n++
|
||||
}
|
||||
if n == 0 || n > 6 || n < len(l) && l[n] != ' ' {
|
||||
return 0
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func mdIsRule(l string) bool {
|
||||
t := strings.ReplaceAll(strings.TrimSpace(l), " ", "")
|
||||
if len(t) < 3 {
|
||||
return false
|
||||
}
|
||||
return strings.Count(t, t[:1]) == len(t) && strings.ContainsAny(t[:1], "-*_")
|
||||
}
|
||||
|
||||
func parseQuote(lines []mdLine, i int) (MdBlock, int) {
|
||||
var parts []string
|
||||
for ; i < len(lines); i++ {
|
||||
t := strings.TrimLeft(lines[i].text, " ")
|
||||
if !strings.HasPrefix(t, ">") {
|
||||
break
|
||||
}
|
||||
parts = append(parts, strings.TrimSpace(t[1:]))
|
||||
}
|
||||
return MdBlock{Kind: BlockQuote, Spans: ParseInline(strings.Join(parts, " "))}, i
|
||||
}
|
||||
|
||||
// mdMarker is a list item's marker.
|
||||
type mdMarker struct {
|
||||
number, depth, width int
|
||||
}
|
||||
|
||||
func mdListMarker(l string) *mdMarker {
|
||||
indent := len(l) - len(strings.TrimLeft(l, " "))
|
||||
t := l[indent:]
|
||||
if len(t) >= 2 && strings.ContainsRune("-*+", rune(t[0])) && t[1] == ' ' {
|
||||
return &mdMarker{depth: indent / 2, width: indent + 2}
|
||||
}
|
||||
d := 0
|
||||
for d < len(t) && t[d] >= '0' && t[d] <= '9' {
|
||||
d++
|
||||
}
|
||||
if d == 0 || d > 9 || d+1 >= len(t) || !strings.ContainsRune(".)", rune(t[d])) || t[d+1] != ' ' {
|
||||
return nil
|
||||
}
|
||||
n, _ := strconv.Atoi(t[:d])
|
||||
return &mdMarker{number: max(n, 1), depth: indent / 2, width: indent + d + 2}
|
||||
}
|
||||
|
||||
func parseList(lines []mdLine, i int) (MdBlock, int) {
|
||||
b := MdBlock{Kind: BlockList}
|
||||
var texts []string
|
||||
for ; i < len(lines); i++ {
|
||||
l := lines[i].text
|
||||
if mk := mdListMarker(l); mk != nil {
|
||||
b.Items = append(b.Items, MdItem{Number: mk.number, Depth: mk.depth})
|
||||
texts = append(texts, strings.TrimSpace(l[mk.width:]))
|
||||
continue
|
||||
}
|
||||
if mdStarts(lines, i) {
|
||||
break
|
||||
}
|
||||
// A lazy line continues the item above.
|
||||
texts[len(texts)-1] += " " + strings.TrimSpace(l)
|
||||
}
|
||||
for j := range b.Items {
|
||||
b.Items[j].Spans = ParseInline(texts[j])
|
||||
}
|
||||
return b, i
|
||||
}
|
||||
|
||||
// mdCells splits a table row into trimmed cells.
|
||||
func mdCells(l string) []string {
|
||||
t := strings.TrimSpace(l)
|
||||
t = strings.TrimSuffix(strings.TrimPrefix(t, "|"), "|")
|
||||
cells := strings.Split(t, "|")
|
||||
for i := range cells {
|
||||
cells[i] = strings.TrimSpace(cells[i])
|
||||
}
|
||||
return cells
|
||||
}
|
||||
|
||||
// mdDelimiter parses a table's delimiter row, or returns nil.
|
||||
func mdDelimiter(l string) []TableAlign {
|
||||
if !strings.Contains(l, "-") {
|
||||
return nil
|
||||
}
|
||||
var out []TableAlign
|
||||
for _, c := range mdCells(l) {
|
||||
left, right := strings.HasPrefix(c, ":"), strings.HasSuffix(c, ":")
|
||||
if strings.Trim(c, ":") == "" || strings.Trim(c, ":-") != "" {
|
||||
return nil
|
||||
}
|
||||
switch {
|
||||
case left && right:
|
||||
out = append(out, AlignCenter)
|
||||
case right:
|
||||
out = append(out, AlignRight)
|
||||
default:
|
||||
out = append(out, AlignLeft)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func parseTable(lines []mdLine, i int) (MdBlock, int) {
|
||||
b := MdBlock{Kind: BlockTable, Header: mdCells(lines[i].text), Align: mdDelimiter(lines[i+1].text)}
|
||||
n := len(b.Header)
|
||||
for len(b.Align) < n {
|
||||
b.Align = append(b.Align, AlignLeft)
|
||||
}
|
||||
b.Align = b.Align[:n]
|
||||
for i += 2; i < len(lines) && strings.Contains(lines[i].text, "|") && strings.TrimSpace(lines[i].text) != ""; i++ {
|
||||
row := mdCells(lines[i].text)
|
||||
for len(row) < n {
|
||||
row = append(row, "")
|
||||
}
|
||||
b.Rows = append(b.Rows, row[:n])
|
||||
}
|
||||
return b, i
|
||||
}
|
||||
Reference in new issue
Block a user