snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/public/shared/markdown/autolink.go

@@ -0,0 +1,265 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"regexp"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// Based off of extensions/autolink.c from https://github.com/github/cmark
+
+var (
+	DefaultURLSchemes = []string{"http", "https", "ftp", "mailto", "tel"}
+	wwwAutoLinkRegex  = regexp.MustCompile(`^www\d{0,3}\.`)
+)
+
+// Given a string with a w at the given position, tries to parse and return a range containing a www link.
+// if one exists. If the text at the given position isn't a link, returns an empty string. Equivalent to
+// www_match from the reference code.
+func parseWWWAutolink(data string, position int) (Range, bool) {
+	// Check that this isn't part of another word
+	if position > 1 {
+		prevChar := data[position-1]
+
+		if !isWhitespaceByte(prevChar) && !isAllowedBeforeWWWLink(prevChar) {
+			return Range{}, false
+		}
+	}
+
+	// Check that this starts with www
+	if len(data)-position < 4 || !wwwAutoLinkRegex.MatchString(data[position:]) {
+		return Range{}, false
+	}
+
+	end := checkDomain(data[position:], false)
+	if end == 0 {
+		return Range{}, false
+	}
+
+	end += position
+
+	// Grab all text until the end of the string or the next whitespace character
+	for end < len(data) && !isWhitespaceByte(data[end]) {
+		end += 1
+	}
+
+	// Trim trailing punctuation
+	end = trimTrailingCharactersFromLink(data, position, end)
+	if position == end {
+		return Range{}, false
+	}
+
+	return Range{position, end}, true
+}
+
+func isAllowedBeforeWWWLink(c byte) bool {
+	switch c {
+	case '*', '_', '~', ')', '<', '(', '>':
+		return true
+	}
+	return false
+}
+
+// Given a string with a : at the given position, tried to parse and return a range containing a URL scheme
+// if one exists. If the text around the given position isn't a link, returns an empty string. Equivalent to
+// url_match from the reference code.
+func parseURLAutolink(data string, position int) (Range, bool) {
+	// Check that a :// exists. This doesn't match the clients that treat the slashes as optional.
+	if len(data)-position < 4 || data[position+1] != '/' || data[position+2] != '/' {
+		return Range{}, false
+	}
+
+	start := position - 1
+	for start > 0 && isAlphanumericByte(data[start-1]) {
+		start -= 1
+	}
+
+	if start < 0 || position >= len(data) {
+		return Range{}, false
+	}
+
+	// Ensure that the URL scheme is allowed and that at least one character after the scheme is valid.
+	scheme := data[start:position]
+	if !isSchemeAllowed(scheme) || !isValidHostCharacter(data[position+3:]) {
+		return Range{}, false
+	}
+
+	end := checkDomain(data[position+3:], true)
+	if end == 0 {
+		return Range{}, false
+	}
+
+	end += position
+
+	// Grab all text until the end of the string or the next whitespace character
+	for end < len(data) && !isWhitespaceByte(data[end]) {
+		end += 1
+	}
+
+	// Trim trailing punctuation
+	end = trimTrailingCharactersFromLink(data, start, end)
+	if start == end {
+		return Range{}, false
+	}
+
+	return Range{start, end}, true
+}
+
+func isSchemeAllowed(scheme string) bool {
+	// Note that this doesn't support the custom URL schemes implemented by the client
+	for _, allowed := range DefaultURLSchemes {
+		if strings.EqualFold(allowed, scheme) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Given a string starting with a URL, returns the number of valid characters that make up the URL's domain.
+// Returns 0 if the string doesn't start with a domain name. allowShort determines whether or not the domain
+// needs to contain a period to be considered valid. Equivalent to check_domain from the reference code.
+func checkDomain(data string, allowShort bool) int {
+	foundUnderscore := false
+	foundPeriod := false
+
+	i := 1
+	for ; i < len(data)-1; i++ {
+		if data[i] == '_' {
+			foundUnderscore = true
+			break
+		} else if data[i] == '.' {
+			foundPeriod = true
+		} else if !isValidHostCharacter(data[i:]) && data[i] != '-' {
+			break
+		}
+	}
+
+	if foundUnderscore {
+		return 0
+	}
+
+	if allowShort {
+		// If allowShort is set, accept any string of valid domain characters
+		return i
+	}
+
+	// If allowShort isn't set, a valid domain just requires at least a single period. Note that this
+	// logic isn't entirely necessary because we already know the string starts with "www." when
+	// this is called from parseWWWAutolink
+	if foundPeriod {
+		return i
+	}
+	return 0
+}
+
+// Returns true if the provided link starts with a valid character for a domain name. Equivalent to
+// is_valid_hostchar from the reference code.
+func isValidHostCharacter(link string) bool {
+	c, _ := utf8.DecodeRuneInString(link)
+	if c == utf8.RuneError {
+		return false
+	}
+
+	return !unicode.IsSpace(c) && !unicode.IsPunct(c)
+}
+
+// Removes any trailing characters such as punctuation or stray brackets that shouldn't be part of the link.
+// Returns a new end position for the link. Equivalent to autolink_delim from the reference code.
+func trimTrailingCharactersFromLink(markdown string, start int, end int) int {
+	runes := []rune(markdown[start:end])
+	linkEnd := len(runes)
+
+	// Cut off the link before an angle bracket if it contains one
+	for i, c := range runes {
+		if c == '<' || c == '>' {
+			linkEnd = i
+			break
+		}
+	}
+
+	numClosing := 0
+	numOpening := 0
+	for i := range linkEnd {
+		if runes[i] == '(' {
+			numOpening += 1
+		} else if runes[i] == ')' {
+			numClosing += 1
+		}
+	}
+
+	trimLinkEnd := func(newEnd int) {
+		for i := newEnd; i < linkEnd; i++ {
+			if runes[i] == '(' {
+				numOpening -= 1
+			} else if runes[i] == ')' {
+				numClosing -= 1
+			}
+		}
+		linkEnd = newEnd
+	}
+
+	for linkEnd > 0 {
+		c := runes[linkEnd-1]
+
+		if !canEndAutolink(c) {
+			// Trim trailing quotes, periods, etc
+			trimLinkEnd(linkEnd - 1)
+		} else if c == ';' {
+			// Trim a trailing HTML entity
+			newEnd := linkEnd - 2
+
+			for newEnd > 0 && ((runes[newEnd] >= 'a' && runes[newEnd] <= 'z') || (runes[newEnd] >= 'A' && runes[newEnd] <= 'Z')) {
+				newEnd -= 1
+			}
+
+			if newEnd < linkEnd-2 && runes[newEnd] == '&' {
+				trimLinkEnd(newEnd)
+			} else {
+				// This isn't actually an HTML entity, so just trim the semicolon
+				trimLinkEnd(linkEnd - 1)
+			}
+		} else if c == ')' {
+			// Only allow an autolink ending with a bracket if that bracket is part of a matching pair of brackets.
+			// If there are more closing brackets than opening ones, remove the extra bracket
+
+			// Examples (input text => output linked portion):
+			//
+			//  http://www.pokemon.com/Pikachu_(Electric)
+			//    => http://www.pokemon.com/Pikachu_(Electric)
+			//
+			//  http://www.pokemon.com/Pikachu_((Electric)
+			//    => http://www.pokemon.com/Pikachu_((Electric)
+			//
+			//  http://www.pokemon.com/Pikachu_(Electric))
+			//    => http://www.pokemon.com/Pikachu_(Electric)
+			//
+			//  http://www.pokemon.com/Pikachu_((Electric))
+			//    => http://www.pokemon.com/Pikachu_((Electric))
+
+			if numClosing <= numOpening {
+				// There's fewer or equal closing brackets, so we've found the end of the link
+				break
+			}
+
+			trimLinkEnd(linkEnd - 1)
+		} else {
+			// There's no special characters at the end of the link, so we're at the end
+			break
+		}
+	}
+
+	return start + len(string(runes[:linkEnd]))
+}
+
+func canEndAutolink(c rune) bool {
+	switch c {
+	case '?', '!', '.', ',', ':', '*', '_', '~', '\'', '"':
+		return false
+	}
+	return true
+}

server/public/shared/markdown/block_quote.go

@@ -0,0 +1,65 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+type BlockQuote struct {
+	blockBase
+	markdown string
+
+	Children []Block
+}
+
+func (b *BlockQuote) Continuation(indentation int, r Range) *continuation {
+	if indentation > 3 {
+		return nil
+	}
+	s := b.markdown[r.Position:r.End]
+	if s == "" || s[0] != '>' {
+		return nil
+	}
+	remaining := Range{r.Position + 1, r.End}
+	indentation, indentationBytes := countIndentation(b.markdown, remaining)
+	if indentation > 0 {
+		indentation--
+	}
+	return &continuation{
+		Indentation: indentation,
+		Remaining:   Range{remaining.Position + indentationBytes, remaining.End},
+	}
+}
+
+func (b *BlockQuote) AddChild(openBlocks []Block) []Block {
+	b.Children = append(b.Children, openBlocks[0])
+	return openBlocks
+}
+
+func blockQuoteStart(markdown string, indent int, r Range, depth int) []Block {
+	if indent > 3 {
+		return nil
+	}
+	if depth >= maxNestingDepth {
+		return nil
+	}
+	s := markdown[r.Position:r.End]
+	if s == "" || s[0] != '>' {
+		return nil
+	}
+
+	block := &BlockQuote{
+		markdown: markdown,
+	}
+	r.Position++
+	if len(s) > 1 && s[1] == ' ' {
+		r.Position++
+	}
+
+	indent, bytes := countIndentation(markdown, r)
+
+	ret := []Block{block}
+	if descendants := blockStartOrParagraph(markdown, indent, Range{r.Position + bytes, r.End}, nil, nil, depth+1); descendants != nil {
+		block.Children = append(block.Children, descendants[0])
+		ret = append(ret, descendants...)
+	}
+	return ret
+}

server/public/shared/markdown/block_quote_test.go

@@ -0,0 +1,42 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBlockQuoteStart(t *testing.T) {
+	t.Run("depth at the nesting limit is rejected even for a well-formed block quote", func(t *testing.T) {
+		markdown := "> foo"
+		blocks := blockQuoteStart(markdown, 0, Range{0, len(markdown)}, maxNestingDepth)
+		assert.Nil(t, blocks)
+	})
+
+	t.Run("nesting from a single line is capped at maxNestingDepth", func(t *testing.T) {
+		n := maxNestingDepth + 8
+		markdown := strings.Repeat("> ", n) + "x"
+		blocks := blockQuoteStart(markdown, 0, Range{0, len(markdown)}, 0)
+		require.NotEmpty(t, blocks)
+
+		counts := countBlocksByType(blocks)
+		assert.Equal(t, maxNestingDepth, counts["*markdown.BlockQuote"])
+		assert.Equal(t, 1, counts["*markdown.Paragraph"])
+		assert.IsType(t, &Paragraph{}, blocks[len(blocks)-1])
+	})
+
+	t.Run("nesting is capped relative to the depth already accrued by open ancestor blocks", func(t *testing.T) {
+		markdown := "> > > x"
+		blocks := blockQuoteStart(markdown, 0, Range{0, len(markdown)}, maxNestingDepth-2)
+		require.NotEmpty(t, blocks)
+
+		counts := countBlocksByType(blocks)
+		assert.Equal(t, 2, counts["*markdown.BlockQuote"])
+		assert.Equal(t, 1, counts["*markdown.Paragraph"])
+	})
+}

server/public/shared/markdown/blocks.go

@@ -0,0 +1,157 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"strings"
+)
+
+// See MM-69445
+const maxNestingDepth = 32
+
+type continuation struct {
+	Indentation int
+	Remaining   Range
+}
+
+type Block interface {
+	Continuation(indentation int, r Range) *continuation
+	AddLine(indentation int, r Range) bool
+	Close()
+	AllowsBlockStarts() bool
+	HasTrailingBlankLine() bool
+}
+
+type blockBase struct{}
+
+func (*blockBase) AddLine(indentation int, r Range) bool { return false }
+func (*blockBase) Close()                                {}
+func (*blockBase) AllowsBlockStarts() bool               { return true }
+func (*blockBase) HasTrailingBlankLine() bool            { return false }
+
+type ContainerBlock interface {
+	Block
+	AddChild(openBlocks []Block) []Block
+}
+
+type Range struct {
+	Position int
+	End      int
+}
+
+func closeBlocks(blocks []Block, referenceDefinitions []*ReferenceDefinition) []*ReferenceDefinition {
+	for _, block := range blocks {
+		block.Close()
+		if p, ok := block.(*Paragraph); ok && len(p.ReferenceDefinitions) > 0 {
+			referenceDefinitions = append(referenceDefinitions, p.ReferenceDefinitions...)
+		}
+	}
+	return referenceDefinitions
+}
+
+func ParseBlocks(markdown string, lines []Line) (*Document, []*ReferenceDefinition) {
+	document := &Document{}
+	var referenceDefinitions []*ReferenceDefinition
+
+	openBlocks := []Block{document}
+
+	for _, line := range lines {
+		r := line.Range
+		lastMatchIndex := 0
+
+		indentation, indentationBytes := countIndentation(markdown, r)
+		r = Range{r.Position + indentationBytes, r.End}
+
+		for i, block := range openBlocks {
+			if continuation := block.Continuation(indentation, r); continuation != nil {
+				indentation = continuation.Indentation
+				r = continuation.Remaining
+				additionalIndentation, additionalIndentationBytes := countIndentation(markdown, r)
+				r = Range{r.Position + additionalIndentationBytes, r.End}
+				indentation += additionalIndentation
+				lastMatchIndex = i
+			} else {
+				break
+			}
+		}
+
+		if openBlocks[lastMatchIndex].AllowsBlockStarts() {
+			if newBlocks := blockStart(markdown, indentation, r, openBlocks[:lastMatchIndex+1], openBlocks[lastMatchIndex+1:], lastMatchIndex+1); newBlocks != nil {
+				didAdd := false
+				for i := lastMatchIndex; i >= 0; i-- {
+					if container, ok := openBlocks[i].(ContainerBlock); ok {
+						if addedBlocks := container.AddChild(newBlocks); addedBlocks != nil {
+							referenceDefinitions = closeBlocks(openBlocks[i+1:], referenceDefinitions)
+							openBlocks = openBlocks[:i+1]
+							openBlocks = append(openBlocks, addedBlocks...)
+							didAdd = true
+							break
+						}
+					}
+				}
+				if didAdd {
+					continue
+				}
+			}
+		}
+
+		isBlank := strings.TrimSpace(markdown[r.Position:r.End]) == ""
+		if paragraph, ok := openBlocks[len(openBlocks)-1].(*Paragraph); ok && !isBlank {
+			paragraph.Text = append(paragraph.Text, r)
+			continue
+		}
+
+		referenceDefinitions = closeBlocks(openBlocks[lastMatchIndex+1:], referenceDefinitions)
+		openBlocks = openBlocks[:lastMatchIndex+1]
+
+		if openBlocks[lastMatchIndex].AddLine(indentation, r) {
+			continue
+		}
+
+		if paragraph := newParagraph(markdown, r); paragraph != nil {
+			for i := lastMatchIndex; i >= 0; i-- {
+				if container, ok := openBlocks[i].(ContainerBlock); ok {
+					if newBlocks := container.AddChild([]Block{paragraph}); newBlocks != nil {
+						referenceDefinitions = closeBlocks(openBlocks[i+1:], referenceDefinitions)
+						openBlocks = openBlocks[:i+1]
+						openBlocks = append(openBlocks, newBlocks...)
+						break
+					}
+				}
+			}
+		}
+	}
+
+	referenceDefinitions = closeBlocks(openBlocks, referenceDefinitions)
+
+	return document, referenceDefinitions
+}
+
+func blockStart(markdown string, indentation int, r Range, matchedBlocks, unmatchedBlocks []Block, depth int) []Block {
+	if r.Position >= r.End {
+		return nil
+	}
+
+	if start := blockQuoteStart(markdown, indentation, r, depth); start != nil {
+		return start
+	} else if start := listStart(markdown, indentation, r, matchedBlocks, unmatchedBlocks, depth); start != nil {
+		return start
+	} else if start := indentedCodeStart(markdown, indentation, r, matchedBlocks, unmatchedBlocks); start != nil {
+		return start
+	} else if start := fencedCodeStart(markdown, indentation, r); start != nil {
+		return start
+	}
+
+	return nil
+}
+
+func blockStartOrParagraph(markdown string, indentation int, r Range, matchedBlocks, unmatchedBlocks []Block, depth int) []Block {
+	if start := blockStart(markdown, indentation, r, matchedBlocks, unmatchedBlocks, depth); start != nil {
+		return start
+	}
+	if paragraph := newParagraph(markdown, r); paragraph != nil {
+		return []Block{paragraph}
+	}
+	return nil
+}

server/public/shared/markdown/blocks_test.go

@@ -0,0 +1,80 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// countBlocksByType tallies the concrete type of each block in a flat block chain, such as the one
+// returned by blockQuoteStart/listStart/blockStart, which append each nesting level's block(s)
+// directly onto the same slice as its descendants.
+func countBlocksByType(blocks []Block) map[string]int {
+	counts := map[string]int{}
+	for _, block := range blocks {
+		counts[fmt.Sprintf("%T", block)]++
+	}
+	return counts
+}
+
+func TestBlockStart(t *testing.T) {
+	t.Run("block quote nesting is capped at maxNestingDepth", func(t *testing.T) {
+		markdown := "> foo"
+		blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth)
+		assert.Nil(t, blocks)
+	})
+
+	t.Run("list nesting is capped at maxNestingDepth", func(t *testing.T) {
+		markdown := "- foo"
+		blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth)
+		assert.Nil(t, blocks)
+	})
+
+	t.Run("a single line cannot recurse past maxNestingDepth nested block quotes", func(t *testing.T) {
+		n := maxNestingDepth + 8
+		markdown := strings.Repeat("> ", n) + "x"
+		blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, 0)
+		require.NotEmpty(t, blocks)
+
+		counts := countBlocksByType(blocks)
+		assert.Equal(t, maxNestingDepth, counts["*markdown.BlockQuote"])
+		assert.Equal(t, 1, counts["*markdown.Paragraph"])
+	})
+
+	t.Run("a single line cannot recurse past maxNestingDepth nested list items", func(t *testing.T) {
+		n := maxNestingDepth + 8
+		markdown := strings.Repeat("- ", n) + "x"
+		blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, 0)
+		require.NotEmpty(t, blocks)
+
+		counts := countBlocksByType(blocks)
+		assert.Equal(t, maxNestingDepth, counts["*markdown.List"])
+		assert.Equal(t, maxNestingDepth, counts["*markdown.ListItem"])
+		assert.Equal(t, 1, counts["*markdown.Paragraph"])
+	})
+
+	t.Run("nesting already accrued by open ancestor blocks counts toward the cap", func(t *testing.T) {
+		markdown := "> > > x"
+		blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth-2)
+		require.NotEmpty(t, blocks)
+
+		counts := countBlocksByType(blocks)
+		assert.Equal(t, 2, counts["*markdown.BlockQuote"])
+		assert.Equal(t, 1, counts["*markdown.Paragraph"])
+	})
+}
+
+func TestBlockStartOrParagraph(t *testing.T) {
+	t.Run("falls back to a paragraph once the nesting depth is exhausted", func(t *testing.T) {
+		markdown := "> foo"
+		blocks := blockStartOrParagraph(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth)
+		require.Len(t, blocks, 1)
+		assert.IsType(t, &Paragraph{}, blocks[0])
+	})
+}

server/public/shared/markdown/document.go

@@ -0,0 +1,22 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+type Document struct {
+	blockBase
+
+	Children []Block
+}
+
+func (b *Document) Continuation(indentation int, r Range) *continuation {
+	return &continuation{
+		Indentation: indentation,
+		Remaining:   r,
+	}
+}
+
+func (b *Document) AddChild(openBlocks []Block) []Block {
+	b.Children = append(b.Children, openBlocks[0])
+	return openBlocks
+}

server/public/shared/markdown/emoji.go

@@ -0,0 +1,42 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"regexp"
+)
+
+// Based off the mobile app's emoji parsing from https://github.com/mattermost/commonmark.js
+
+var (
+	emojiRegex = regexp.MustCompile(`^:([a-z0-9_\-+]+):\B`)
+)
+
+// parseEmoji attempts to parse a named emoji (eg. :taco:) starting at the current parser position. If an emoji is
+// found, it adds that to p.inlines and returns true. Otherwise, it returns false.
+func (p *inlineParser) parseEmoji() bool {
+	// Only allow emojis after non-word characters
+	if p.position > 1 {
+		prevChar := p.raw[p.position-1]
+
+		if isWordByte(prevChar) {
+			return false
+		}
+	}
+
+	remaining := p.raw[p.position:]
+
+	loc := emojiRegex.FindStringIndex(remaining)
+	if loc == nil {
+		return false
+	}
+
+	// Note that there may not be a system or custom emoji that exists with this name
+	p.inlines = append(p.inlines, &Emoji{
+		Name: remaining[loc[0]+1 : loc[1]-1],
+	})
+	p.position += loc[1] - loc[0]
+
+	return true
+}

server/public/shared/markdown/emoji_test.go

@@ -0,0 +1,203 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseEmoji(t *testing.T) {
+	for name, tc := range map[string]struct {
+		Input             string
+		Position          int
+		ExpectedOk        bool
+		ExpectedPosition  int
+		ExpectedEmojiName string
+	}{
+		"just a colon": {
+			Input:            ":",
+			Position:         0,
+			ExpectedOk:       false,
+			ExpectedPosition: 0,
+		},
+		"no closing colon": {
+			Input:            ":emoji",
+			Position:         0,
+			ExpectedOk:       false,
+			ExpectedPosition: 0,
+		},
+		"no closing colon before whitespace": {
+			Input:            ":emoji example",
+			Position:         0,
+			ExpectedOk:       false,
+			ExpectedPosition: 0,
+		},
+		"valid emoji": {
+			Input:             ":emoji:",
+			Position:          0,
+			ExpectedOk:        true,
+			ExpectedPosition:  7,
+			ExpectedEmojiName: "emoji",
+		},
+		"valid emoji with punctuation": {
+			Input:             ":valid-emoji:",
+			Position:          0,
+			ExpectedOk:        true,
+			ExpectedPosition:  13,
+			ExpectedEmojiName: "valid-emoji",
+		},
+		"valid emoji with text before": {
+			Input:             "this is an :emoji:",
+			Position:          11,
+			ExpectedOk:        true,
+			ExpectedPosition:  18,
+			ExpectedEmojiName: "emoji",
+		},
+		"invalid emoji with text before": {
+			Input:            "this is not an :emoji",
+			Position:         15,
+			ExpectedOk:       false,
+			ExpectedPosition: 15,
+		},
+		"valid emoji with text after": {
+			Input:             ":emoji: before some text",
+			Position:          0,
+			ExpectedOk:        true,
+			ExpectedPosition:  7,
+			ExpectedEmojiName: "emoji",
+		},
+		"valid emoji with text before and after": {
+			Input:             "this is an :emoji: in a sentence",
+			Position:          11,
+			ExpectedOk:        true,
+			ExpectedPosition:  18,
+			ExpectedEmojiName: "emoji",
+		},
+		"multiple emojis 1": {
+			Input:             ":multiple: :emojis:",
+			Position:          0,
+			ExpectedOk:        true,
+			ExpectedPosition:  10,
+			ExpectedEmojiName: "multiple",
+		},
+		"multiple emojis 2": {
+			Input:             ":multiple: :emojis:",
+			Position:          11,
+			ExpectedOk:        true,
+			ExpectedPosition:  19,
+			ExpectedEmojiName: "emojis",
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			p := newInlineParser(tc.Input, []Range{}, []*ReferenceDefinition{})
+			p.raw = tc.Input
+			p.position = tc.Position
+
+			ok := p.parseEmoji()
+
+			assert.Equal(t, tc.ExpectedOk, ok)
+			assert.Equal(t, tc.ExpectedPosition, p.position)
+			if tc.ExpectedOk {
+				require.True(t, len(p.inlines) > 0)
+				require.IsType(t, &Emoji{}, p.inlines[len(p.inlines)-1])
+				assert.Equal(t, tc.ExpectedEmojiName, p.inlines[len(p.inlines)-1].(*Emoji).Name)
+			}
+		})
+	}
+}
+
+func TestParseEmojiFull(t *testing.T) {
+	// These tests are based on https://github.com/mattermost/commonmark.js/blob/master/test/mattermost.txt
+
+	for name, tc := range map[string]struct {
+		Markdown     string
+		ExpectedHTML string
+	}{
+		// Valid emojis
+
+		"emoji": {
+			Markdown:     "This is an :emoji:",
+			ExpectedHTML: `<p>This is an <span data-emoji-name="emoji" data-literal=":emoji:" /></p>`,
+		},
+		"emoji with underscore": {
+			Markdown:     "This is an :emo_ji:",
+			ExpectedHTML: `<p>This is an <span data-emoji-name="emo_ji" data-literal=":emo_ji:" /></p>`,
+		},
+		"emoji with hyphen": {
+			Markdown:     "This is an :emo-ji:",
+			ExpectedHTML: `<p>This is an <span data-emoji-name="emo-ji" data-literal=":emo-ji:" /></p>`,
+		},
+		"emoji with numbers": {
+			Markdown:     "This is an :emoji123:",
+			ExpectedHTML: `<p>This is an <span data-emoji-name="emoji123" data-literal=":emoji123:" /></p>`,
+		},
+		"emoji in brackets": {
+			Markdown:     "This is an (:emoji:)",
+			ExpectedHTML: `<p>This is an (<span data-emoji-name="emoji" data-literal=":emoji:" />)</p>`,
+		},
+		"two emojis without space between": {
+			Markdown:     "These are some :emoji1::emoji2:",
+			ExpectedHTML: `<p>These are some <span data-emoji-name="emoji1" data-literal=":emoji1:" /><span data-emoji-name="emoji2" data-literal=":emoji2:" /></p>`,
+		},
+		"two emojis separated by a slash": {
+			Markdown:     "These are some :emoji1:/:emoji2:",
+			ExpectedHTML: `<p>These are some <span data-emoji-name="emoji1" data-literal=":emoji1:" />/<span data-emoji-name="emoji2" data-literal=":emoji2:" /></p>`,
+		},
+		"+1 emoji": {
+			Markdown:     "This is an :+1:",
+			ExpectedHTML: `<p>This is an <span data-emoji-name="+1" data-literal=":+1:" /></p>`,
+		},
+		"-1 emoji": {
+			Markdown:     "This is an :-1:",
+			ExpectedHTML: `<p>This is an <span data-emoji-name="-1" data-literal=":-1:" /></p>`,
+		},
+		"emoji with surrounding words": {
+			Markdown:     "This is an :emoji: in a sentence.",
+			ExpectedHTML: `<p>This is an <span data-emoji-name="emoji" data-literal=":emoji:" /> in a sentence.</p>`,
+		},
+
+		// Invalid emojis
+
+		"incomplete emoji 1": {
+			Markdown:     "This is not an :emoji",
+			ExpectedHTML: `<p>This is not an :emoji</p>`,
+		},
+		"incomplete emoji 2": {
+			Markdown:     "This is not an emoji:",
+			ExpectedHTML: `<p>This is not an emoji:</p>`,
+		},
+		"invalid emoji with whitespace": {
+			Markdown:     "This is not an :emo ji:",
+			ExpectedHTML: `<p>This is not an :emo ji:</p>`,
+		},
+		"invalid emoji with other punctuation": {
+			Markdown:     "This is not an :emo'ji:",
+			ExpectedHTML: `<p>This is not an :emo'ji:</p>`,
+		},
+		"invalid emoji due to adjacent text 1": {
+			Markdown: "Thisisnotan:emoji:",
+			// This differs slightly from our commonmark.js implementation because it doesn't require :// when autolinking
+			ExpectedHTML: `<p>Thisisnotan:emoji:</p>`,
+		},
+		"invalid emoji due to adjacent text 2": {
+			Markdown: "This is not an :emoji:isit",
+			// This differs slightly from our commonmark.js implementation because it doesn't require :// when autolinking
+			ExpectedHTML: `<p>This is not an :emoji:isit</p>`,
+		},
+		"invalid emoji due to adjacent text 3": {
+			Markdown: "This is not an:emoji:isit",
+			// This differs slightly from our commonmark.js implementation because it doesn't require :// when autolinking
+			ExpectedHTML: `<p>This is not an:emoji:isit</p>`,
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			actual := RenderHTML(tc.Markdown)
+
+			assert.Equal(t, tc.ExpectedHTML, actual)
+		})
+	}
+}

server/public/shared/markdown/fenced_code.go

@@ -0,0 +1,113 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"strings"
+)
+
+type FencedCodeLine struct {
+	Indentation int
+	Range       Range
+}
+
+type FencedCode struct {
+	blockBase
+	markdown           string
+	didSeeClosingFence bool
+
+	Indentation  int
+	OpeningFence Range
+	RawInfo      Range
+	RawCode      []FencedCodeLine
+}
+
+func (b *FencedCode) Code() string {
+	var resultSb strings.Builder
+	for _, code := range b.RawCode {
+		resultSb.WriteString(strings.Repeat(" ", code.Indentation) + b.markdown[code.Range.Position:code.Range.End])
+	}
+	return resultSb.String()
+}
+
+func (b *FencedCode) Info() string {
+	return Unescape(b.markdown[b.RawInfo.Position:b.RawInfo.End])
+}
+
+func (b *FencedCode) Continuation(indentation int, r Range) *continuation {
+	if b.didSeeClosingFence {
+		return nil
+	}
+	return &continuation{
+		Indentation: indentation,
+		Remaining:   r,
+	}
+}
+
+func (b *FencedCode) AddLine(indentation int, r Range) bool {
+	s := b.markdown[r.Position:r.End]
+	if indentation <= 3 && strings.HasPrefix(s, b.markdown[b.OpeningFence.Position:b.OpeningFence.End]) {
+		suffix := strings.TrimSpace(s[b.OpeningFence.End-b.OpeningFence.Position:])
+		isClosingFence := true
+		for _, c := range suffix {
+			if c != rune(s[0]) {
+				isClosingFence = false
+				break
+			}
+		}
+		if isClosingFence {
+			b.didSeeClosingFence = true
+			return true
+		}
+	}
+
+	if indentation >= b.Indentation {
+		indentation -= b.Indentation
+	} else {
+		indentation = 0
+	}
+
+	b.RawCode = append(b.RawCode, FencedCodeLine{
+		Indentation: indentation,
+		Range:       r,
+	})
+	return true
+}
+
+func (b *FencedCode) AllowsBlockStarts() bool {
+	return false
+}
+
+func fencedCodeStart(markdown string, indentation int, r Range) []Block {
+	s := markdown[r.Position:r.End]
+
+	if !strings.HasPrefix(s, "```") && !strings.HasPrefix(s, "~~~") {
+		return nil
+	}
+
+	fenceCharacter := rune(s[0])
+	fenceLength := 3
+	for _, c := range s[3:] {
+		if c == fenceCharacter {
+			fenceLength++
+		} else {
+			break
+		}
+	}
+
+	for i := r.Position + fenceLength; i < r.End; i++ {
+		if markdown[i] == '`' {
+			return nil
+		}
+	}
+
+	return []Block{
+		&FencedCode{
+			markdown:     markdown,
+			Indentation:  indentation,
+			RawInfo:      trimRightSpace(markdown, Range{r.Position + fenceLength, r.End}),
+			OpeningFence: Range{r.Position, r.Position + fenceLength},
+		},
+	}
+}

server/public/shared/markdown/html.go

@@ -0,0 +1,213 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"fmt"
+	"strings"
+)
+
+var htmlEscaper = strings.NewReplacer(
+	`&`, "&",
+	`<`, "&lt;",
+	`>`, "&gt;",
+	`"`, "&quot;",
+)
+
+// RenderHTML produces HTML with the same behavior as the example renderer used in the CommonMark
+// reference materials except for one slight difference: for brevity, no unnecessary whitespace is
+// inserted between elements. The output is not defined by the CommonMark spec, and it exists
+// primarily as an aid in testing.
+func RenderHTML(markdown string) string {
+	return RenderBlockHTML(Parse(markdown))
+}
+
+func RenderBlockHTML(block Block, referenceDefinitions []*ReferenceDefinition) (result string) {
+	return renderBlockHTML(block, referenceDefinitions, false)
+}
+
+func renderBlockHTML(block Block, referenceDefinitions []*ReferenceDefinition, isTightList bool) string {
+	var resultSb strings.Builder
+
+	switch v := block.(type) {
+	case *Document:
+		for _, block := range v.Children {
+			resultSb.WriteString(RenderBlockHTML(block, referenceDefinitions))
+		}
+	case *Paragraph:
+		if len(v.Text) == 0 {
+			return ""
+		}
+		if !isTightList {
+			resultSb.WriteString("<p>")
+		}
+		for _, inline := range v.ParseInlines(referenceDefinitions) {
+			resultSb.WriteString(RenderInlineHTML(inline))
+		}
+		if !isTightList {
+			resultSb.WriteString("</p>")
+		}
+	case *List:
+		if v.IsOrdered {
+			if v.OrderedStart != 1 {
+				resultSb.WriteString(fmt.Sprintf(`<ol start="%v">`, v.OrderedStart))
+			} else {
+				resultSb.WriteString("<ol>")
+			}
+		} else {
+			resultSb.WriteString("<ul>")
+		}
+		for _, block := range v.Children {
+			resultSb.WriteString(renderBlockHTML(block, referenceDefinitions, !v.IsLoose))
+		}
+		if v.IsOrdered {
+			resultSb.WriteString("</ol>")
+		} else {
+			resultSb.WriteString("</ul>")
+		}
+	case *ListItem:
+		resultSb.WriteString("<li>")
+		for _, block := range v.Children {
+			resultSb.WriteString(renderBlockHTML(block, referenceDefinitions, isTightList))
+		}
+		resultSb.WriteString("</li>")
+	case *BlockQuote:
+		resultSb.WriteString("<blockquote>")
+		for _, block := range v.Children {
+			resultSb.WriteString(RenderBlockHTML(block, referenceDefinitions))
+		}
+		resultSb.WriteString("</blockquote>")
+	case *FencedCode:
+		if info := v.Info(); info != "" {
+			language := strings.Fields(info)[0]
+			resultSb.WriteString(`<pre><code class="language-` + htmlEscaper.Replace(language) + `">`)
+		} else {
+			resultSb.WriteString("<pre><code>")
+		}
+		resultSb.WriteString(htmlEscaper.Replace(v.Code()))
+		resultSb.WriteString("</code></pre>")
+	case *IndentedCode:
+		resultSb.WriteString("<pre><code>")
+		resultSb.WriteString(htmlEscaper.Replace(v.Code()))
+		resultSb.WriteString("</code></pre>")
+	default:
+		panic(fmt.Sprintf("missing case for type %T", v))
+	}
+
+	return resultSb.String()
+}
+
+func escapeURL(url string) (result string) {
+	for i := 0; i < len(url); {
+		switch b := url[i]; b {
+		case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '-', '_', '.', '!', '~', '*', '\'', '(', ')', '#':
+			result += string(b)
+			i++
+		default:
+			if b == '%' && i+2 < len(url) && isHexByte(url[i+1]) && isHexByte(url[i+2]) {
+				result += url[i : i+3]
+				i += 3
+			} else if (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9') {
+				result += string(b)
+				i++
+			} else {
+				result += fmt.Sprintf("%%%0X", b)
+				i++
+			}
+		}
+	}
+	return
+}
+
+func RenderInlineHTML(inline Inline) (result string) {
+	switch v := inline.(type) {
+	case *Text:
+		return htmlEscaper.Replace(v.Text)
+	case *HardLineBreak:
+		return "<br />"
+	case *SoftLineBreak:
+		return "\n"
+	case *CodeSpan:
+		return "<code>" + htmlEscaper.Replace(v.Code) + "</code>"
+	case *InlineImage:
+		result += `<img src="` + htmlEscaper.Replace(escapeURL(v.Destination())) + `" alt="` + htmlEscaper.Replace(renderImageAltText(v.Children)) + `"`
+		if title := v.Title(); title != "" {
+			result += ` title="` + htmlEscaper.Replace(title) + `"`
+		}
+		result += ` />`
+	case *ReferenceImage:
+		result += `<img src="` + htmlEscaper.Replace(escapeURL(v.Destination())) + `" alt="` + htmlEscaper.Replace(renderImageAltText(v.Children)) + `"`
+		if title := v.Title(); title != "" {
+			result += ` title="` + htmlEscaper.Replace(title) + `"`
+		}
+		result += ` />`
+	case *InlineLink:
+		var resultSb strings.Builder
+		resultSb.WriteString(`<a href="` + htmlEscaper.Replace(escapeURL(v.Destination())) + `"`)
+		if title := v.Title(); title != "" {
+			resultSb.WriteString(` title="` + htmlEscaper.Replace(title) + `"`)
+		}
+		resultSb.WriteString(`>`)
+		for _, inline := range v.Children {
+			resultSb.WriteString(RenderInlineHTML(inline))
+		}
+		resultSb.WriteString("</a>")
+		return resultSb.String()
+	case *ReferenceLink:
+		var resultSb strings.Builder
+		resultSb.WriteString(`<a href="` + htmlEscaper.Replace(escapeURL(v.Destination())) + `"`)
+		if title := v.Title(); title != "" {
+			resultSb.WriteString(` title="` + htmlEscaper.Replace(title) + `"`)
+		}
+		resultSb.WriteString(`>`)
+		for _, inline := range v.Children {
+			resultSb.WriteString(RenderInlineHTML(inline))
+		}
+		resultSb.WriteString("</a>")
+		return resultSb.String()
+	case *Autolink:
+		var resultSb strings.Builder
+		resultSb.WriteString(`<a href="` + htmlEscaper.Replace(escapeURL(v.Destination())) + `">`)
+		for _, inline := range v.Children {
+			resultSb.WriteString(RenderInlineHTML(inline))
+		}
+		resultSb.WriteString("</a>")
+		return resultSb.String()
+	case *Emoji:
+		escapedName := htmlEscaper.Replace(v.Name)
+		result += fmt.Sprintf(`<span data-emoji-name="%s" data-literal=":%s:" />`, escapedName, escapedName)
+
+	default:
+		panic(fmt.Sprintf("missing case for type %T", v))
+	}
+	return
+}
+
+func renderImageAltText(children []Inline) string {
+	var resultSb strings.Builder
+	for _, inline := range children {
+		resultSb.WriteString(renderImageChildAltText(inline))
+	}
+	return resultSb.String()
+}
+
+func renderImageChildAltText(inline Inline) string {
+	switch v := inline.(type) {
+	case *Text:
+		return v.Text
+	case *InlineImage:
+		var resultSb strings.Builder
+		for _, inline := range v.Children {
+			resultSb.WriteString(renderImageChildAltText(inline))
+		}
+		return resultSb.String()
+	case *InlineLink:
+		var resultSb strings.Builder
+		for _, inline := range v.Children {
+			resultSb.WriteString(renderImageChildAltText(inline))
+		}
+		return resultSb.String()
+	}
+	return ""
+}

server/public/shared/markdown/indented_code.go

@@ -0,0 +1,99 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"strings"
+)
+
+type IndentedCodeLine struct {
+	Indentation int
+	Range       Range
+}
+
+type IndentedCode struct {
+	blockBase
+	markdown string
+
+	RawCode []IndentedCodeLine
+}
+
+func (b *IndentedCode) Code() string {
+	var resultSb strings.Builder
+	for _, code := range b.RawCode {
+		resultSb.WriteString(strings.Repeat(" ", code.Indentation) + b.markdown[code.Range.Position:code.Range.End])
+	}
+	return resultSb.String()
+}
+
+func (b *IndentedCode) Continuation(indentation int, r Range) *continuation {
+	if indentation >= 4 {
+		return &continuation{
+			Indentation: indentation - 4,
+			Remaining:   r,
+		}
+	}
+	s := b.markdown[r.Position:r.End]
+	if strings.TrimSpace(s) == "" {
+		return &continuation{
+			Remaining: r,
+		}
+	}
+	return nil
+}
+
+func (b *IndentedCode) AddLine(indentation int, r Range) bool {
+	b.RawCode = append(b.RawCode, IndentedCodeLine{
+		Indentation: indentation,
+		Range:       r,
+	})
+	return true
+}
+
+func (b *IndentedCode) Close() {
+	for {
+		last := b.RawCode[len(b.RawCode)-1]
+		s := b.markdown[last.Range.Position:last.Range.End]
+		if strings.TrimRight(s, "\r\n") == "" {
+			b.RawCode = b.RawCode[:len(b.RawCode)-1]
+		} else {
+			break
+		}
+	}
+}
+
+func (b *IndentedCode) AllowsBlockStarts() bool {
+	return false
+}
+
+func indentedCodeStart(markdown string, indentation int, r Range, matchedBlocks, unmatchedBlocks []Block) []Block {
+	if len(unmatchedBlocks) > 0 {
+		if _, ok := unmatchedBlocks[len(unmatchedBlocks)-1].(*Paragraph); ok {
+			return nil
+		}
+	} else if len(matchedBlocks) > 0 {
+		if _, ok := matchedBlocks[len(matchedBlocks)-1].(*Paragraph); ok {
+			return nil
+		}
+	}
+
+	if indentation < 4 {
+		return nil
+	}
+
+	s := markdown[r.Position:r.End]
+	if strings.TrimSpace(s) == "" {
+		return nil
+	}
+
+	return []Block{
+		&IndentedCode{
+			markdown: markdown,
+			RawCode: []IndentedCodeLine{{
+				Indentation: indentation - 4,
+				Range:       r,
+			}},
+		},
+	}
+}

server/public/shared/markdown/inlines.go

@@ -0,0 +1,681 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"container/list"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+type Inline interface {
+	IsInline() bool
+}
+
+type inlineBase struct{}
+
+func (inlineBase) IsInline() bool { return true }
+
+type Text struct {
+	inlineBase
+
+	Text  string
+	Range Range
+}
+
+type CodeSpan struct {
+	inlineBase
+
+	Code string
+}
+
+type HardLineBreak struct {
+	inlineBase
+}
+
+type SoftLineBreak struct {
+	inlineBase
+}
+
+type InlineLinkOrImage struct {
+	inlineBase
+
+	Children []Inline
+
+	RawDestination Range
+
+	markdown string
+	rawTitle string
+}
+
+func (i *InlineLinkOrImage) Destination() string {
+	return Unescape(i.markdown[i.RawDestination.Position:i.RawDestination.End])
+}
+
+func (i *InlineLinkOrImage) Title() string {
+	return Unescape(i.rawTitle)
+}
+
+type InlineLink struct {
+	InlineLinkOrImage
+}
+
+type InlineImage struct {
+	InlineLinkOrImage
+}
+
+type ReferenceLinkOrImage struct {
+	inlineBase
+	*ReferenceDefinition
+
+	Children []Inline
+}
+
+type ReferenceLink struct {
+	ReferenceLinkOrImage
+}
+
+type ReferenceImage struct {
+	ReferenceLinkOrImage
+}
+
+type Autolink struct {
+	inlineBase
+
+	Children []Inline
+
+	RawDestination Range
+
+	markdown string
+}
+
+func (i *Autolink) Destination() string {
+	destination := Unescape(i.markdown[i.RawDestination.Position:i.RawDestination.End])
+
+	if strings.HasPrefix(destination, "www") {
+		destination = "http://" + destination
+	}
+
+	return destination
+}
+
+type Emoji struct {
+	inlineBase
+
+	Name string
+}
+
+type delimiterType int
+
+const (
+	linkOpeningDelimiter delimiterType = iota
+	imageOpeningDelimiter
+)
+
+type delimiter struct {
+	Type       delimiterType
+	IsInactive bool
+	TextNode   int
+	Range      Range
+}
+
+type inlineParser struct {
+	markdown             string
+	ranges               []Range
+	referenceDefinitions []*ReferenceDefinition
+
+	raw            string
+	position       int
+	inlines        []Inline
+	delimiterStack *list.List
+}
+
+func newInlineParser(markdown string, ranges []Range, referenceDefinitions []*ReferenceDefinition) *inlineParser {
+	return &inlineParser{
+		markdown:             markdown,
+		ranges:               ranges,
+		referenceDefinitions: referenceDefinitions,
+		delimiterStack:       list.New(),
+	}
+}
+
+func (p *inlineParser) parseBackticks() {
+	count := 1
+	for i := p.position + 1; i < len(p.raw) && p.raw[i] == '`'; i++ {
+		count++
+	}
+	opening := p.raw[p.position : p.position+count]
+	search := p.position + count
+	for search < len(p.raw) {
+		end := strings.Index(p.raw[search:], opening)
+		if end == -1 {
+			break
+		}
+		if search+end+count < len(p.raw) && p.raw[search+end+count] == '`' {
+			search += end + count
+			for search < len(p.raw) && p.raw[search] == '`' {
+				search++
+			}
+			continue
+		}
+		code := strings.Join(strings.Fields(p.raw[p.position+count:search+end]), " ")
+		p.position = search + end + count
+		p.inlines = append(p.inlines, &CodeSpan{
+			Code: code,
+		})
+		return
+	}
+	p.position += len(opening)
+	absPos := relativeToAbsolutePosition(p.ranges, p.position-len(opening))
+	p.inlines = append(p.inlines, &Text{
+		Text:  opening,
+		Range: Range{absPos, absPos + len(opening)},
+	})
+}
+
+func (p *inlineParser) parseLineEnding() {
+	if p.position >= 1 && p.raw[p.position-1] == '\t' {
+		p.inlines = append(p.inlines, &HardLineBreak{})
+	} else if p.position >= 2 && p.raw[p.position-1] == ' ' && (p.raw[p.position-2] == '\t' || p.raw[p.position-1] == ' ') {
+		p.inlines = append(p.inlines, &HardLineBreak{})
+	} else {
+		p.inlines = append(p.inlines, &SoftLineBreak{})
+	}
+	p.position++
+	if p.position < len(p.raw) && p.raw[p.position] == '\n' {
+		p.position++
+	}
+}
+
+func (p *inlineParser) parseEscapeCharacter() {
+	if p.position+1 < len(p.raw) && isEscapableByte(p.raw[p.position+1]) {
+		absPos := relativeToAbsolutePosition(p.ranges, p.position+1)
+		p.inlines = append(p.inlines, &Text{
+			Text:  string(p.raw[p.position+1]),
+			Range: Range{absPos, absPos + len(string(p.raw[p.position+1]))},
+		})
+		p.position += 2
+	} else {
+		absPos := relativeToAbsolutePosition(p.ranges, p.position)
+		p.inlines = append(p.inlines, &Text{
+			Text:  `\`,
+			Range: Range{absPos, absPos + 1},
+		})
+		p.position++
+	}
+}
+
+func (p *inlineParser) parseText() {
+	if next := strings.IndexAny(p.raw[p.position:], "\r\n\\`&![]wW:"); next == -1 {
+		absPos := relativeToAbsolutePosition(p.ranges, p.position)
+		p.inlines = append(p.inlines, &Text{
+			Text:  strings.TrimRightFunc(p.raw[p.position:], isWhitespace),
+			Range: Range{absPos, absPos + len(p.raw[p.position:])},
+		})
+		p.position = len(p.raw)
+	} else {
+		absPos := relativeToAbsolutePosition(p.ranges, p.position)
+		if p.raw[p.position+next] == '\r' || p.raw[p.position+next] == '\n' {
+			s := strings.TrimRightFunc(p.raw[p.position:p.position+next], isWhitespace)
+			p.inlines = append(p.inlines, &Text{
+				Text:  s,
+				Range: Range{absPos, absPos + len(s)},
+			})
+		} else {
+			if next == 0 {
+				// Always read at least one character since 'w', 'W', and ':' may not actually match another
+				// type of node
+				next = 1
+			}
+
+			p.inlines = append(p.inlines, &Text{
+				Text:  p.raw[p.position : p.position+next],
+				Range: Range{absPos, absPos + next},
+			})
+		}
+		p.position += next
+	}
+}
+
+func (p *inlineParser) parseLinkOrImageDelimiter() {
+	absPos := relativeToAbsolutePosition(p.ranges, p.position)
+	if p.raw[p.position] == '[' {
+		p.inlines = append(p.inlines, &Text{
+			Text:  "[",
+			Range: Range{absPos, absPos + 1},
+		})
+		p.delimiterStack.PushBack(&delimiter{
+			Type:     linkOpeningDelimiter,
+			TextNode: len(p.inlines) - 1,
+			Range:    Range{p.position, p.position + 1},
+		})
+		p.position++
+	} else if p.raw[p.position] == '!' && p.position+1 < len(p.raw) && p.raw[p.position+1] == '[' {
+		p.inlines = append(p.inlines, &Text{
+			Text:  "![",
+			Range: Range{absPos, absPos + 2},
+		})
+		p.delimiterStack.PushBack(&delimiter{
+			Type:     imageOpeningDelimiter,
+			TextNode: len(p.inlines) - 1,
+			Range:    Range{p.position, p.position + 2},
+		})
+		p.position += 2
+	} else {
+		p.inlines = append(p.inlines, &Text{
+			Text:  "!",
+			Range: Range{absPos, absPos + 1},
+		})
+		p.position++
+	}
+}
+
+func (p *inlineParser) peekAtInlineLinkDestinationAndTitle(position int, isImage bool) (destination, title Range, end int, ok bool) {
+	if position >= len(p.raw) || p.raw[position] != '(' {
+		return
+	}
+	position++
+
+	destinationStart := nextNonWhitespace(p.raw, position)
+	if destinationStart >= len(p.raw) {
+		return
+	} else if p.raw[destinationStart] == ')' {
+		return Range{destinationStart, destinationStart}, Range{destinationStart, destinationStart}, destinationStart + 1, true
+	}
+
+	destination, end, ok = parseLinkDestination(p.raw, destinationStart)
+	if !ok {
+		return
+	}
+	position = end
+
+	if isImage && position < len(p.raw) && isWhitespaceByte(p.raw[position]) {
+		dimensionsStart := nextNonWhitespace(p.raw, position)
+		if dimensionsStart >= len(p.raw) {
+			return
+		}
+
+		if p.raw[dimensionsStart] == '=' {
+			// Read optional image dimensions even if we don't use them
+			_, end, ok = parseImageDimensions(p.raw, dimensionsStart)
+			if !ok {
+				return
+			}
+
+			position = end
+		}
+	}
+
+	if position < len(p.raw) && isWhitespaceByte(p.raw[position]) {
+		titleStart := nextNonWhitespace(p.raw, position)
+		if titleStart >= len(p.raw) {
+			return
+		} else if p.raw[titleStart] == ')' {
+			return destination, Range{titleStart, titleStart}, titleStart + 1, true
+		}
+
+		if p.raw[titleStart] == '"' || p.raw[titleStart] == '\'' || p.raw[titleStart] == '(' {
+			title, end, ok = parseLinkTitle(p.raw, titleStart)
+			if !ok {
+				return
+			}
+			position = end
+		}
+	}
+
+	closingPosition := nextNonWhitespace(p.raw, position)
+	if closingPosition >= len(p.raw) || p.raw[closingPosition] != ')' {
+		return Range{}, Range{}, 0, false
+	}
+
+	return destination, title, closingPosition + 1, true
+}
+
+func (p *inlineParser) referenceDefinition(label string) *ReferenceDefinition {
+	clean := strings.Join(strings.Fields(label), " ")
+	for _, d := range p.referenceDefinitions {
+		if strings.EqualFold(clean, strings.Join(strings.Fields(d.Label()), " ")) {
+			return d
+		}
+	}
+	return nil
+}
+
+func (p *inlineParser) lookForLinkOrImage() {
+	for element := p.delimiterStack.Back(); element != nil; element = element.Prev() {
+		d := element.Value.(*delimiter)
+		if d.Type != imageOpeningDelimiter && d.Type != linkOpeningDelimiter {
+			continue
+		}
+		if d.IsInactive {
+			p.delimiterStack.Remove(element)
+			break
+		}
+
+		isImage := d.Type == imageOpeningDelimiter
+
+		var inline Inline
+
+		if destination, title, next, ok := p.peekAtInlineLinkDestinationAndTitle(p.position+1, isImage); ok {
+			destinationMarkdownPosition := relativeToAbsolutePosition(p.ranges, destination.Position)
+			linkOrImage := InlineLinkOrImage{
+				Children:       append([]Inline(nil), p.inlines[d.TextNode+1:]...),
+				RawDestination: Range{destinationMarkdownPosition, destinationMarkdownPosition + destination.End - destination.Position},
+				markdown:       p.markdown,
+				rawTitle:       p.raw[title.Position:title.End],
+			}
+			if d.Type == imageOpeningDelimiter {
+				inline = &InlineImage{linkOrImage}
+			} else {
+				inline = &InlineLink{linkOrImage}
+			}
+			p.position = next
+		} else {
+			referenceLabel := ""
+			label, next, hasLinkLabel := parseLinkLabel(p.raw, p.position+1)
+			if hasLinkLabel && label.End > label.Position {
+				referenceLabel = p.raw[label.Position:label.End]
+			} else {
+				referenceLabel = p.raw[d.Range.End:p.position]
+				if !hasLinkLabel {
+					next = p.position + 1
+				}
+			}
+			if referenceLabel != "" {
+				if reference := p.referenceDefinition(referenceLabel); reference != nil {
+					linkOrImage := ReferenceLinkOrImage{
+						ReferenceDefinition: reference,
+						Children:            append([]Inline(nil), p.inlines[d.TextNode+1:]...),
+					}
+					if d.Type == imageOpeningDelimiter {
+						inline = &ReferenceImage{linkOrImage}
+					} else {
+						inline = &ReferenceLink{linkOrImage}
+					}
+					p.position = next
+				}
+			}
+		}
+
+		if inline != nil {
+			if d.Type == imageOpeningDelimiter {
+				p.inlines = append(p.inlines[:d.TextNode], inline)
+			} else {
+				p.inlines = append(p.inlines[:d.TextNode], inline)
+				for inlineElement := element.Prev(); inlineElement != nil; inlineElement = inlineElement.Prev() {
+					if d := inlineElement.Value.(*delimiter); d.Type == linkOpeningDelimiter {
+						d.IsInactive = true
+					}
+				}
+			}
+			p.delimiterStack.Remove(element)
+			return
+		}
+		p.delimiterStack.Remove(element)
+		break
+	}
+	absPos := relativeToAbsolutePosition(p.ranges, p.position)
+	p.inlines = append(p.inlines, &Text{
+		Text:  "]",
+		Range: Range{absPos, absPos + 1},
+	})
+	p.position++
+}
+
+func CharacterReference(ref string) string {
+	if ref == "" {
+		return ""
+	}
+	if ref[0] == '#' {
+		if len(ref) < 2 {
+			return ""
+		}
+		n := 0
+		if ref[1] == 'X' || ref[1] == 'x' {
+			if len(ref) < 3 {
+				return ""
+			}
+			for i := 2; i < len(ref); i++ {
+				if i > 9 {
+					return ""
+				}
+				d := ref[i]
+				switch {
+				case d >= '0' && d <= '9':
+					n = n*16 + int(d-'0')
+				case d >= 'a' && d <= 'f':
+					n = n*16 + 10 + int(d-'a')
+				case d >= 'A' && d <= 'F':
+					n = n*16 + 10 + int(d-'A')
+				default:
+					return ""
+				}
+			}
+		} else {
+			for i := 1; i < len(ref); i++ {
+				if i > 8 || ref[i] < '0' || ref[i] > '9' {
+					return ""
+				}
+				n = n*10 + int(ref[i]-'0')
+			}
+		}
+		c := rune(n)
+		if c == '\u0000' || !utf8.ValidRune(c) {
+			return string(unicode.ReplacementChar)
+		}
+		return string(c)
+	}
+	if entity, ok := htmlEntities[ref]; ok {
+		return entity
+	}
+	return ""
+}
+
+func (p *inlineParser) parseCharacterReference() {
+	absPos := relativeToAbsolutePosition(p.ranges, p.position)
+	p.position++
+	if semicolon := strings.IndexByte(p.raw[p.position:], ';'); semicolon == -1 {
+		p.inlines = append(p.inlines, &Text{
+			Text:  "&",
+			Range: Range{absPos, absPos + 1},
+		})
+	} else if s := CharacterReference(p.raw[p.position : p.position+semicolon]); s != "" {
+		p.position += semicolon + 1
+		p.inlines = append(p.inlines, &Text{
+			Text:  s,
+			Range: Range{absPos, absPos + len(s)},
+		})
+	} else {
+		p.inlines = append(p.inlines, &Text{
+			Text:  "&",
+			Range: Range{absPos, absPos + 1},
+		})
+	}
+}
+
+func (p *inlineParser) parseAutolink(c rune) bool {
+	for element := p.delimiterStack.Back(); element != nil; element = element.Prev() {
+		d := element.Value.(*delimiter)
+		if !d.IsInactive {
+			return false
+		}
+	}
+
+	var link Range
+	if c == ':' {
+		var ok bool
+		link, ok = parseURLAutolink(p.raw, p.position)
+
+		if !ok {
+			return false
+		}
+
+		// Since the current position is at the colon, we have to rewind the parsing slightly so that
+		// we don't duplicate the URL scheme
+		rewind := strings.Index(p.raw[link.Position:link.End], ":")
+		if rewind != -1 {
+			lastInline := p.inlines[len(p.inlines)-1]
+			lastText, ok := lastInline.(*Text)
+
+			if !ok {
+				// This should never occur since parseURLAutolink will only return a non-empty value
+				// when the previous text ends in a valid URL protocol which would mean that the previous
+				// node is a Text node
+				return false
+			}
+
+			p.inlines = p.inlines[0 : len(p.inlines)-1]
+			p.inlines = append(p.inlines, &Text{
+				Text:  lastText.Text[:len(lastText.Text)-rewind],
+				Range: Range{lastText.Range.Position, lastText.Range.End - rewind},
+			})
+			p.position -= rewind
+		}
+	} else if c == 'w' || c == 'W' {
+		var ok bool
+		link, ok = parseWWWAutolink(p.raw, p.position)
+
+		if !ok {
+			return false
+		}
+	}
+
+	linkMarkdownPosition := relativeToAbsolutePosition(p.ranges, link.Position)
+	linkRange := Range{linkMarkdownPosition, linkMarkdownPosition + link.End - link.Position}
+
+	p.inlines = append(p.inlines, &Autolink{
+		Children: []Inline{
+			&Text{
+				Text:  p.raw[link.Position:link.End],
+				Range: linkRange,
+			},
+		},
+		RawDestination: linkRange,
+		markdown:       p.markdown,
+	})
+	p.position += (link.End - link.Position)
+
+	return true
+}
+
+func (p *inlineParser) Parse() []Inline {
+	for _, r := range p.ranges {
+		p.raw += p.markdown[r.Position:r.End]
+	}
+
+	for p.position < len(p.raw) {
+		c, _ := utf8.DecodeRuneInString(p.raw[p.position:])
+
+		switch c {
+		case '\r', '\n':
+			p.parseLineEnding()
+		case '\\':
+			p.parseEscapeCharacter()
+		case '`':
+			p.parseBackticks()
+		case '&':
+			p.parseCharacterReference()
+		case '!', '[':
+			p.parseLinkOrImageDelimiter()
+		case ']':
+			p.lookForLinkOrImage()
+		case 'w', 'W':
+			matched := p.parseAutolink(c)
+
+			if !matched {
+				p.parseText()
+			}
+		case ':':
+			matched := p.parseAutolink(c)
+			if matched {
+				continue
+			}
+
+			matched = p.parseEmoji()
+			if matched {
+				continue
+			}
+
+			p.parseText()
+		default:
+			p.parseText()
+		}
+	}
+
+	return p.inlines
+}
+
+func ParseInlines(markdown string, ranges []Range, referenceDefinitions []*ReferenceDefinition) (inlines []Inline) {
+	return newInlineParser(markdown, ranges, referenceDefinitions).Parse()
+}
+
+func MergeInlineText(inlines []Inline) []Inline {
+	ret := inlines[:0]
+	for i, v := range inlines {
+		// always add first node
+		if i == 0 {
+			ret = append(ret, v)
+			continue
+		}
+		// not a text node? nothing to merge
+		text, ok := v.(*Text)
+		if !ok {
+			ret = append(ret, v)
+			continue
+		}
+		// previous node is not a text node? nothing to merge
+		prevText, ok := ret[len(ret)-1].(*Text)
+		if !ok {
+			ret = append(ret, v)
+			continue
+		}
+		// previous node is not right before this one
+		if prevText.Range.End != text.Range.Position {
+			ret = append(ret, v)
+			continue
+		}
+		// we have two consecutive text nodes
+		ret[len(ret)-1] = &Text{
+			Text:  prevText.Text + text.Text,
+			Range: Range{prevText.Range.Position, text.Range.End},
+		}
+	}
+	return ret
+}
+
+func Unescape(markdown string) string {
+	var ret strings.Builder
+
+	position := 0
+	for position < len(markdown) {
+		c, cSize := utf8.DecodeRuneInString(markdown[position:])
+
+		switch c {
+		case '\\':
+			if position+1 < len(markdown) && isEscapableByte(markdown[position+1]) {
+				ret.WriteByte(markdown[position+1])
+				position += 2
+			} else {
+				ret.WriteString(`\`)
+				position++
+			}
+		case '&':
+			position++
+			if semicolon := strings.IndexByte(markdown[position:], ';'); semicolon == -1 {
+				ret.WriteString("&")
+			} else if s := CharacterReference(markdown[position : position+semicolon]); s != "" {
+				position += semicolon + 1
+				ret.WriteString(s)
+			} else {
+				ret.WriteString("&")
+			}
+		default:
+			ret.WriteRune(c)
+			position += cSize
+		}
+	}
+
+	return ret.String()
+}

server/public/shared/markdown/inspect.go

@@ -0,0 +1,150 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"slices"
+	"sync/atomic"
+)
+
+// defaultMaxPostRunes is used only if no value has been registered via
+// SetMaxPostRunes, which should not happen in practice. It assumes a post is at
+// most 64KiB in DB. Assuming four bytes per rune, it gives us 16*1024 runes.
+// If we allow scanning up to twice (arbitrary value) that value, we get:
+const defaultMaxPostRunes = 2 * 16 * 1024
+
+var maxPostRunes atomic.Int64
+
+func init() {
+	maxPostRunes.Store(defaultMaxPostRunes)
+}
+
+// SetMaxPostRunes registers the real configured maximum post size, in runes, that MaxLen uses to
+// compute the maximum markdown input length. This lets MaxLen reflect the real limit regardless
+// of which code path first parses markdown, rather than depending on that path having already
+// pushed the value in. Safe to call concurrently with MaxLen.
+func SetMaxPostRunes(size int) {
+	maxPostRunes.Store(int64(size))
+}
+
+// MaxLen returns the current maximum markdown input length, in bytes, enforced by Parse and
+// Inspect: four times the maximum post size, in runes, registered via SetMaxPostRunes (or
+// defaultMaxPostRunes if it hasn't been called yet), assuming a worst case of four bytes per
+// rune.
+func MaxLen() int {
+	return 4 * int(maxPostRunes.Load())
+}
+
+// Inspect traverses the markdown tree in depth-first order. If f returns true, Inspect invokes f
+// recursively for each child of the block or inline, followed by a call of f(nil).
+func Inspect(markdown string, f func(any) bool) {
+	if len(markdown) > MaxLen() {
+		return
+	}
+	document, referenceDefinitions := Parse(markdown)
+	InspectBlock(document, func(block Block) bool {
+		if !f(block) {
+			return false
+		}
+		switch v := block.(type) {
+		case *Paragraph:
+			for _, inline := range MergeInlineText(v.ParseInlines(referenceDefinitions)) {
+				InspectInline(inline, func(inline Inline) bool {
+					return f(inline)
+				})
+			}
+		}
+		return true
+	})
+}
+
+// InspectBlock traverses the blocks in depth-first order, starting with block. If f returns true,
+// InspectBlock invokes f recursively for each child of the block, followed by a call of f(nil).
+func InspectBlock(block Block, f func(Block) bool) {
+	stack := []Block{block}
+	// Using seen for backtracking
+	seen := map[Block]bool{}
+
+	for len(stack) > 0 {
+		// "peek" the node from the stack
+		block := stack[len(stack)-1]
+
+		if seen[block] {
+			// "pop" the node only when backtracking(seen)
+			stack = stack[:len(stack)-1]
+			f(nil)
+			continue
+		}
+		seen[block] = true
+
+		// Process the node
+		if !f(block) {
+			continue
+		}
+
+		switch v := block.(type) {
+		case *Document:
+			for _, v0 := range slices.Backward(v.Children) {
+				stack = append(stack, v0)
+			}
+		case *List:
+			for _, v0 := range slices.Backward(v.Children) {
+				stack = append(stack, v0)
+			}
+		case *ListItem:
+			for _, v0 := range slices.Backward(v.Children) {
+				stack = append(stack, v0)
+			}
+		case *BlockQuote:
+			for _, v0 := range slices.Backward(v.Children) {
+				stack = append(stack, v0)
+			}
+		}
+	}
+}
+
+// InspectInline traverses the blocks in depth-first order, starting with block. If f returns true,
+// InspectInline invokes f recursively for each child of the block, followed by a call of f(nil).
+func InspectInline(inline Inline, f func(Inline) bool) {
+	stack := []Inline{inline}
+	// Using seen for backtracking
+	seen := map[Inline]bool{}
+
+	for len(stack) > 0 {
+		// "peek" the node from the stack
+		inline := stack[len(stack)-1]
+
+		if seen[inline] {
+			// "pop" the node only when backtracking(seen)
+			stack = stack[:len(stack)-1]
+			f(nil)
+			continue
+		}
+		seen[inline] = true
+
+		// Process the node
+		if !f(inline) {
+			continue
+		}
+
+		switch v := inline.(type) {
+		case *InlineImage:
+			for _, v0 := range slices.Backward(v.Children) {
+				stack = append(stack, v0)
+			}
+		case *InlineLink:
+			for _, v0 := range slices.Backward(v.Children) {
+				stack = append(stack, v0)
+			}
+		case *ReferenceImage:
+			for _, v0 := range slices.Backward(v.Children) {
+				stack = append(stack, v0)
+			}
+		case *ReferenceLink:
+			for _, v0 := range slices.Backward(v.Children) {
+				stack = append(stack, v0)
+			}
+		}
+	}
+}

server/public/shared/markdown/inspect_test.go

@@ -0,0 +1,177 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestInspect(t *testing.T) {
+	t.Run("base", func(t *testing.T) {
+		markdown := `
+[foo]: bar
+- a
+  > [![]()]()
+  > [![foo]][foo]
+- d
+`
+
+		visited := []string{}
+		level := 0
+		Inspect(markdown, func(blockOrInline any) bool {
+			if blockOrInline == nil {
+				level--
+			} else {
+				visited = append(visited, strings.Repeat(" ", level*4)+strings.TrimPrefix(fmt.Sprintf("%T", blockOrInline), "*markdown."))
+				level++
+			}
+			return true
+		})
+
+		assert.Equal(t, []string{
+			"Document",
+			"    Paragraph",
+			"    List",
+			"        ListItem",
+			"            Paragraph",
+			"                Text",
+			"            BlockQuote",
+			"                Paragraph",
+			"                    InlineLink",
+			"                        InlineImage",
+			"                    SoftLineBreak",
+			"                    ReferenceLink",
+			"                        ReferenceImage",
+			"                            Text",
+			"        ListItem",
+			"            Paragraph",
+			"                Text",
+		}, visited)
+	})
+
+	t.Run("visit nodes when len is smaller than maxLen", func(t *testing.T) {
+		n := MaxLen() / 5
+		markdown := strings.Repeat(`![`, n) + strings.Repeat(`]()`, n)
+
+		visited := []string{}
+		level := 0
+		Inspect(markdown, func(blockOrInline any) bool {
+			if blockOrInline == nil {
+				level--
+			} else {
+				visited = append(visited, strings.Repeat(" ", level*4)+strings.TrimPrefix(fmt.Sprintf("%T", blockOrInline), "*markdown."))
+				level++
+			}
+			return true
+		})
+
+		assert.NotEmpty(t, visited)
+	})
+
+	t.Run("do not visit any nodes when len is greater than maxLen", func(t *testing.T) {
+		n := (MaxLen() / 5) + 1
+		markdown := strings.Repeat(`![`, n) + strings.Repeat(`]()`, n)
+
+		visited := []string{}
+		level := 0
+		Inspect(markdown, func(blockOrInline any) bool {
+			if blockOrInline == nil {
+				level--
+			} else {
+				visited = append(visited, strings.Repeat(" ", level*4)+strings.TrimPrefix(fmt.Sprintf("%T", blockOrInline), "*markdown."))
+				level++
+			}
+			return true
+		})
+
+		assert.Empty(t, visited)
+	})
+
+	t.Run("a deeply nested single-line block quote is bounded rather than fully descended", func(t *testing.T) {
+		n := 20000
+		markdown := strings.Repeat("> ", n) + "x"
+
+		blockQuoteCount := 0
+		Inspect(markdown, func(blockOrInline any) bool {
+			if _, ok := blockOrInline.(*BlockQuote); ok {
+				blockQuoteCount++
+			}
+			return true
+		})
+
+		assert.Equal(t, maxNestingDepth-1, blockQuoteCount)
+	})
+
+	t.Run("a deeply nested single-line list is bounded rather than fully descended", func(t *testing.T) {
+		n := 20000
+		markdown := strings.Repeat("- ", n) + "x"
+
+		listCount := 0
+		Inspect(markdown, func(blockOrInline any) bool {
+			if _, ok := blockOrInline.(*List); ok {
+				listCount++
+			}
+			return true
+		})
+
+		assert.Equal(t, maxNestingDepth-1, listCount)
+	})
+}
+
+var counterSink int
+
+func BenchmarkInspect(b *testing.B) {
+	text := `Some standard piece of text.
+
+Has a link [post](https://github.com) and also has a blockquote.
+
+> This is a famous quote.
+
+Some bold text **Text for markdown?** to go with it.
+
+At the end, some more lines`
+
+	for b.Loop() {
+		Inspect(text, func(_ any) bool {
+			counterSink++
+			return true
+		})
+	}
+}
+
+// BenchmarkInspectNestedBlockQuote and BenchmarkInspectNestedList measure the cost of parsing a
+// single line made up of repeated block-quote/list markers. These benchmarks should scale roughly
+// linearly with input size (i.e. per-op time should stay flat as the marker count grows), since the
+// number of nested blocks actually created is capped at maxNestingDepth regardless of input size.
+func BenchmarkInspectNestedBlockQuote(b *testing.B) {
+	for _, n := range []int{1_000, 10_000, 60_000} {
+		markdown := strings.Repeat("> ", n) + "x"
+		b.Run(fmt.Sprintf("n=%d", n), func(b *testing.B) {
+			for b.Loop() {
+				Inspect(markdown, func(_ any) bool {
+					counterSink++
+					return true
+				})
+			}
+		})
+	}
+}
+
+func BenchmarkInspectNestedList(b *testing.B) {
+	for _, n := range []int{1_000, 10_000, 60_000} {
+		markdown := strings.Repeat("- ", n) + "x"
+		b.Run(fmt.Sprintf("n=%d", n), func(b *testing.B) {
+			for b.Loop() {
+				Inspect(markdown, func(_ any) bool {
+					counterSink++
+					return true
+				})
+			}
+		})
+	}
+}

server/public/shared/markdown/lines.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"strings"
+)
+
+type Line struct {
+	Range
+}
+
+func ParseLines(markdown string) []Line {
+	lineStartPosition := 0
+	isAfterCarriageReturn := false
+	lines := make([]Line, 0, strings.Count(markdown, "\n"))
+	for position, r := range markdown {
+		if r == '\n' {
+			lines = append(lines, Line{Range{lineStartPosition, position + 1}})
+			lineStartPosition = position + 1
+		} else if isAfterCarriageReturn {
+			lines = append(lines, Line{Range{lineStartPosition, position}})
+			lineStartPosition = position
+		}
+		isAfterCarriageReturn = r == '\r'
+	}
+	if lineStartPosition < len(markdown) {
+		lines = append(lines, Line{Range{lineStartPosition, len(markdown)}})
+	}
+	return lines
+}

server/public/shared/markdown/lines_test.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseLines(t *testing.T) {
+	assert.Equal(t, []Line{
+		{Range{0, 4}}, {Range{4, 7}},
+	}, ParseLines("foo\nbar"))
+
+	assert.Equal(t, []Line{
+		{Range{0, 5}}, {Range{5, 8}},
+	}, ParseLines("foo\r\nbar"))
+
+	assert.Equal(t, []Line{
+		{Range{0, 4}}, {Range{4, 6}}, {Range{6, 9}},
+	}, ParseLines("foo\r\r\nbar"))
+
+	assert.Equal(t, []Line{
+		{Range{0, 4}},
+	}, ParseLines("foo\n"))
+
+	assert.Equal(t, []Line{
+		{Range{0, 4}},
+	}, ParseLines("foo\r"))
+
+	assert.Equal(t, []Line{
+		{Range{0, 5}},
+	}, ParseLines("foo\r\n"))
+}

server/public/shared/markdown/links.go

@@ -0,0 +1,184 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"unicode/utf8"
+)
+
+func parseLinkDestination(markdown string, position int) (raw Range, next int, ok bool) {
+	if position >= len(markdown) {
+		return
+	}
+
+	if markdown[position] == '<' {
+		isEscaped := false
+
+		for offset, c := range []byte(markdown[position+1:]) {
+			if isEscaped {
+				isEscaped = false
+				if isEscapableByte(c) {
+					continue
+				}
+			}
+
+			if c == '\\' {
+				isEscaped = true
+			} else if c == '<' {
+				break
+			} else if c == '>' {
+				return Range{position + 1, position + 1 + offset}, position + 1 + offset + 1, true
+			} else if isWhitespaceByte(c) {
+				break
+			}
+		}
+	}
+
+	openCount := 0
+	isEscaped := false
+	for offset, c := range []byte(markdown[position:]) {
+		if isEscaped {
+			isEscaped = false
+			if isEscapableByte(c) {
+				continue
+			}
+		}
+
+		switch c {
+		case '\\':
+			isEscaped = true
+		case '(':
+			openCount++
+		case ')':
+			if openCount < 1 {
+				return Range{position, position + offset}, position + offset, true
+			}
+			openCount--
+		default:
+			if isWhitespaceByte(c) {
+				return Range{position, position + offset}, position + offset, true
+			}
+		}
+	}
+	return Range{position, len(markdown)}, len(markdown), true
+}
+
+func parseLinkTitle(markdown string, position int) (raw Range, next int, ok bool) {
+	if position >= len(markdown) {
+		return
+	}
+
+	originalPosition := position
+
+	var closer byte
+	switch markdown[position] {
+	case '"', '\'':
+		closer = markdown[position]
+	case '(':
+		closer = ')'
+	default:
+		return
+	}
+	position++
+
+	for position < len(markdown) {
+		switch markdown[position] {
+		case '\\':
+			position++
+			if position < len(markdown) && isEscapableByte(markdown[position]) {
+				position++
+			}
+		case closer:
+			return Range{originalPosition + 1, position}, position + 1, true
+		default:
+			position++
+		}
+	}
+
+	return
+}
+
+func parseLinkLabel(markdown string, position int) (raw Range, next int, ok bool) {
+	if position >= len(markdown) || markdown[position] != '[' {
+		return
+	}
+
+	originalPosition := position
+	position++
+
+	for position < len(markdown) {
+		switch markdown[position] {
+		case '\\':
+			position++
+			if position < len(markdown) && isEscapableByte(markdown[position]) {
+				position++
+			}
+		case '[':
+			return
+		case ']':
+			if position-originalPosition >= 1000 && utf8.RuneCountInString(markdown[originalPosition:position]) >= 1000 {
+				return
+			}
+			return Range{originalPosition + 1, position}, position + 1, true
+		default:
+			position++
+		}
+	}
+
+	return
+}
+
+// As a non-standard feature, we allow image links to specify dimensions of the image by adding "=WIDTHxHEIGHT"
+// after the image destination but before the image title like ![alt](http://example.com/image.png =100x200 "title").
+// Both width and height are optional, but at least one of them must be specified.
+func parseImageDimensions(markdown string, position int) (raw Range, next int, ok bool) {
+	if position >= len(markdown) {
+		return
+	}
+
+	originalPosition := position
+
+	// Read =
+	position += 1
+	if position >= len(markdown) {
+		return
+	}
+
+	// Read width
+	hasWidth := false
+	for position < len(markdown)-1 && isNumericByte(markdown[position]) {
+		hasWidth = true
+		position += 1
+	}
+
+	// Look for early end of dimensions
+	if isWhitespaceByte(markdown[position]) || markdown[position] == ')' {
+		return Range{originalPosition, position - 1}, position, true
+	}
+
+	// Read the x
+	if (markdown[position] != 'x' && markdown[position] != 'X') || position == len(markdown)-1 {
+		return
+	}
+	position += 1
+
+	// Read height
+	hasHeight := false
+	for position < len(markdown)-1 && isNumericByte(markdown[position]) {
+		hasHeight = true
+		position += 1
+	}
+
+	// Make sure the there's no trailing characters
+	if !isWhitespaceByte(markdown[position]) && markdown[position] != ')' {
+		return
+	}
+
+	if !hasWidth && !hasHeight {
+		// At least one of width or height is required
+		return
+	}
+
+	return Range{originalPosition, position - 1}, position, true
+}

server/public/shared/markdown/links_test.go

@@ -0,0 +1,244 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseImageDimensions(t *testing.T) {
+	for name, tc := range map[string]struct {
+		Input         string
+		Position      int
+		ExpectedRange Range
+		ExpectedNext  int
+		ExpectedOk    bool
+	}{
+		"no dimensions, no title": {
+			Input:         `![alt](https://example.com)`,
+			Position:      26,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"no dimensions, title": {
+			Input:         `![alt](https://example.com "title")`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"only width, no title": {
+			Input:         `![alt](https://example.com =100)`,
+			Position:      27,
+			ExpectedRange: Range{27, 30},
+			ExpectedNext:  31,
+			ExpectedOk:    true,
+		},
+		"only width, title": {
+			Input:         `![alt](https://example.com =100 "title")`,
+			Position:      27,
+			ExpectedRange: Range{27, 30},
+			ExpectedNext:  31,
+			ExpectedOk:    true,
+		},
+		"only height, no title": {
+			Input:         `![alt](https://example.com =x100)`,
+			Position:      27,
+			ExpectedRange: Range{27, 31},
+			ExpectedNext:  32,
+			ExpectedOk:    true,
+		},
+		"only height, title": {
+			Input:         `![alt](https://example.com =x100 "title")`,
+			Position:      27,
+			ExpectedRange: Range{27, 31},
+			ExpectedNext:  32,
+			ExpectedOk:    true,
+		},
+		"dimensions, no title": {
+			Input:         `![alt](https://example.com =100x200)`,
+			Position:      27,
+			ExpectedRange: Range{27, 34},
+			ExpectedNext:  35,
+			ExpectedOk:    true,
+		},
+		"dimensions, title": {
+			Input:         `![alt](https://example.com =100x200 "title")`,
+			Position:      27,
+			ExpectedRange: Range{27, 34},
+			ExpectedNext:  35,
+			ExpectedOk:    true,
+		},
+		"no dimensions, no title, trailing whitespace": {
+			Input:         `![alt](https://example.com )`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"only width, no title, trailing whitespace": {
+			Input:         `![alt](https://example.com  =100  )`,
+			Position:      28,
+			ExpectedRange: Range{28, 31},
+			ExpectedNext:  32,
+			ExpectedOk:    true,
+		},
+		"only height, no title, trailing whitespace": {
+			Input:         `![alt](https://example.com   =x100   )`,
+			Position:      29,
+			ExpectedRange: Range{29, 33},
+			ExpectedNext:  34,
+			ExpectedOk:    true,
+		},
+		"dimensions, no title, trailing whitespace": {
+			Input:         `![alt](https://example.com    =100x200   )`,
+			Position:      30,
+			ExpectedRange: Range{30, 37},
+			ExpectedNext:  38,
+			ExpectedOk:    true,
+		},
+		"no width or height": {
+			Input:         `![alt](https://example.com =x)`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"garbage 1": {
+			Input:         `![alt](https://example.com =aaa)`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"garbage 2": {
+			Input:         `![alt](https://example.com ====)`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"garbage 3": {
+			Input:         `![alt](https://example.com =100xx200)`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"garbage 4": {
+			Input:         `![alt](https://example.com =100x200x300x400)`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"garbage 5": {
+			Input:         `![alt](https://example.com =100x200`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"garbage 6": {
+			Input:         `![alt](https://example.com =100x`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+		"garbage 7": {
+			Input:         `![alt](https://example.com =x200`,
+			Position:      27,
+			ExpectedRange: Range{0, 0},
+			ExpectedNext:  0,
+			ExpectedOk:    false,
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			raw, next, ok := parseImageDimensions(tc.Input, tc.Position)
+			assert.Equal(t, tc.ExpectedOk, ok)
+			assert.Equal(t, tc.ExpectedNext, next)
+			assert.Equal(t, tc.ExpectedRange, raw)
+		})
+	}
+}
+
+func TestImageLinksWithDimensions(t *testing.T) {
+	for name, tc := range map[string]struct {
+		Markdown     string
+		ExpectedHTML string
+	}{
+		"regular link": {
+			Markdown:     `[link](https://example.com)`,
+			ExpectedHTML: `<p><a href="https://example.com">link</a></p>`,
+		},
+		"image link": {
+			Markdown:     `![image](https://example.com/image.png)`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" /></p>`,
+		},
+		"image link with title": {
+			Markdown:     `![image](https://example.com/image.png "title")`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" title="title" /></p>`,
+		},
+		"image link with bracketed title": {
+			Markdown:     `![image](https://example.com/image.png (title))`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" title="title" /></p>`,
+		},
+		"image link with width": {
+			Markdown:     `![image](https://example.com/image.png =500)`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" /></p>`,
+		},
+		"image link with width and title": {
+			Markdown:     `![image](https://example.com/image.png =500 "title")`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" title="title" /></p>`,
+		},
+		"image link with width and bracketed title": {
+			Markdown:     `![image](https://example.com/image.png =500 (title))`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" title="title" /></p>`,
+		},
+		"image link with height": {
+			Markdown:     `![image](https://example.com/image.png =x500)`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" /></p>`,
+		},
+		"image link with height and title": {
+			Markdown:     `![image](https://example.com/image.png =x500 "title")`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" title="title" /></p>`,
+		},
+		"image link with height and bracketed title": {
+			Markdown:     `![image](https://example.com/image.png =x500 (title))`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" title="title" /></p>`,
+		},
+		"image link with dimensions": {
+			Markdown:     `![image](https://example.com/image.png =500x400)`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" /></p>`,
+		},
+		"image link with dimensions and title": {
+			Markdown:     `![image](https://example.com/image.png =500x400 "title")`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" title="title" /></p>`,
+		},
+		"image link with dimensions and bracketed title": {
+			Markdown:     `![image](https://example.com/image.png =500x400 (title))`,
+			ExpectedHTML: `<p><img src="https://example.com/image.png" alt="image" title="title" /></p>`,
+		},
+		"no image link 1": {
+			Markdown:     `![image]()`,
+			ExpectedHTML: `<p><img src="" alt="image" /></p>`,
+		},
+		"no image link 2": {
+			Markdown:     `![image]( )`,
+			ExpectedHTML: `<p><img src="" alt="image" /></p>`,
+		},
+		"no image link with dimensions": {
+			Markdown:     `![image]( =500x400)`,
+			ExpectedHTML: `<p><img src="=500x400" alt="image" /></p>`,
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			assert.Equal(t, tc.ExpectedHTML, RenderHTML(tc.Markdown))
+		})
+	}
+}

server/public/shared/markdown/list.go

@@ -0,0 +1,223 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"strings"
+)
+
+type ListItem struct {
+	blockBase
+	markdown                    string
+	hasTrailingBlankLine        bool
+	hasBlankLineBetweenChildren bool
+
+	Indentation int
+	Children    []Block
+}
+
+func (b *ListItem) Continuation(indentation int, r Range) *continuation {
+	s := b.markdown[r.Position:r.End]
+	if strings.TrimSpace(s) == "" {
+		if b.Children == nil {
+			return nil
+		}
+		return &continuation{
+			Remaining: r,
+		}
+	}
+	if indentation < b.Indentation {
+		return nil
+	}
+	return &continuation{
+		Indentation: indentation - b.Indentation,
+		Remaining:   r,
+	}
+}
+
+func (b *ListItem) AddChild(openBlocks []Block) []Block {
+	b.Children = append(b.Children, openBlocks[0])
+	if b.hasTrailingBlankLine {
+		b.hasBlankLineBetweenChildren = true
+	}
+	b.hasTrailingBlankLine = false
+	return openBlocks
+}
+
+func (b *ListItem) AddLine(indentation int, r Range) bool {
+	isBlank := strings.TrimSpace(b.markdown[r.Position:r.End]) == ""
+	if isBlank {
+		b.hasTrailingBlankLine = true
+	}
+	return false
+}
+
+func (b *ListItem) HasTrailingBlankLine() bool {
+	return b.hasTrailingBlankLine || (len(b.Children) > 0 && b.Children[len(b.Children)-1].HasTrailingBlankLine())
+}
+
+func (b *ListItem) isLoose() bool {
+	if b.hasBlankLineBetweenChildren {
+		return true
+	}
+	for i, child := range b.Children {
+		if i < len(b.Children)-1 && child.HasTrailingBlankLine() {
+			return true
+		}
+	}
+	return false
+}
+
+type List struct {
+	blockBase
+	markdown                    string
+	hasTrailingBlankLine        bool
+	hasBlankLineBetweenChildren bool
+
+	IsLoose           bool
+	IsOrdered         bool
+	OrderedStart      int
+	BulletOrDelimiter byte
+	Children          []*ListItem
+}
+
+func (b *List) Continuation(indentation int, r Range) *continuation {
+	s := b.markdown[r.Position:r.End]
+	if strings.TrimSpace(s) == "" {
+		return &continuation{
+			Remaining: r,
+		}
+	}
+	return &continuation{
+		Indentation: indentation,
+		Remaining:   r,
+	}
+}
+
+func (b *List) AddChild(openBlocks []Block) []Block {
+	if item, ok := openBlocks[0].(*ListItem); ok {
+		b.Children = append(b.Children, item)
+		if b.hasTrailingBlankLine {
+			b.hasBlankLineBetweenChildren = true
+		}
+		b.hasTrailingBlankLine = false
+		return openBlocks
+	} else if list, ok := openBlocks[0].(*List); ok {
+		if len(list.Children) == 1 && list.IsOrdered == b.IsOrdered && list.BulletOrDelimiter == b.BulletOrDelimiter {
+			return b.AddChild(openBlocks[1:])
+		}
+	}
+	return nil
+}
+
+func (b *List) AddLine(indentation int, r Range) bool {
+	isBlank := strings.TrimSpace(b.markdown[r.Position:r.End]) == ""
+	if isBlank {
+		b.hasTrailingBlankLine = true
+	}
+	return false
+}
+
+func (b *List) HasTrailingBlankLine() bool {
+	return b.hasTrailingBlankLine || (len(b.Children) > 0 && b.Children[len(b.Children)-1].HasTrailingBlankLine())
+}
+
+func (b *List) isLoose() bool {
+	if b.hasBlankLineBetweenChildren {
+		return true
+	}
+	for i, child := range b.Children {
+		if child.isLoose() || (i < len(b.Children)-1 && child.HasTrailingBlankLine()) {
+			return true
+		}
+	}
+	return false
+}
+
+func (b *List) Close() {
+	b.IsLoose = b.isLoose()
+}
+
+func parseListMarker(markdown string, r Range) (success, isOrdered bool, orderedStart int, bulletOrDelimiter byte, markerWidth int, remaining Range) {
+	digits := 0
+	n := 0
+	for i := r.Position; i < r.End && markdown[i] >= '0' && markdown[i] <= '9'; i++ {
+		digits++
+		n = n*10 + int(markdown[i]-'0')
+	}
+	if digits > 0 {
+		if digits > 9 || r.Position+digits >= r.End {
+			return
+		}
+		next := markdown[r.Position+digits]
+		if next != '.' && next != ')' {
+			return
+		}
+		return true, true, n, next, digits + 1, Range{r.Position + digits + 1, r.End}
+	}
+	if r.Position >= r.End {
+		return
+	}
+	next := markdown[r.Position]
+	if next != '-' && next != '+' && next != '*' {
+		return
+	}
+	return true, false, 0, next, 1, Range{r.Position + 1, r.End}
+}
+
+func listStart(markdown string, indent int, r Range, matchedBlocks, unmatchedBlocks []Block, depth int) []Block {
+	afterList := false
+	if len(matchedBlocks) > 0 {
+		_, afterList = matchedBlocks[len(matchedBlocks)-1].(*List)
+	}
+	if !afterList && indent > 3 {
+		return nil
+	}
+	if depth >= maxNestingDepth {
+		return nil
+	}
+
+	success, isOrdered, orderedStart, bulletOrDelimiter, markerWidth, remaining := parseListMarker(markdown, r)
+	if !success {
+		return nil
+	}
+
+	isBlank := strings.TrimSpace(markdown[remaining.Position:remaining.End]) == ""
+	if len(matchedBlocks) > 0 && len(unmatchedBlocks) == 0 {
+		if _, ok := matchedBlocks[len(matchedBlocks)-1].(*Paragraph); ok {
+			if isBlank || (isOrdered && orderedStart != 1) {
+				return nil
+			}
+		}
+	}
+
+	indentAfterMarker, indentBytesAfterMarker := countIndentation(markdown, remaining)
+	if !isBlank && indentAfterMarker < 1 {
+		return nil
+	}
+
+	remaining = Range{remaining.Position + indentBytesAfterMarker, remaining.End}
+	consumedIndentAfterMarker := indentAfterMarker
+	if isBlank || indentAfterMarker >= 5 {
+		consumedIndentAfterMarker = 1
+	}
+
+	listItem := &ListItem{
+		markdown:    markdown,
+		Indentation: indent + markerWidth + consumedIndentAfterMarker,
+	}
+	list := &List{
+		markdown:          markdown,
+		IsOrdered:         isOrdered,
+		OrderedStart:      orderedStart,
+		BulletOrDelimiter: bulletOrDelimiter,
+		Children:          []*ListItem{listItem},
+	}
+	ret := []Block{list, listItem}
+	if descendants := blockStartOrParagraph(markdown, indentAfterMarker-consumedIndentAfterMarker, remaining, nil, nil, depth+1); descendants != nil {
+		listItem.Children = append(listItem.Children, descendants[0])
+		ret = append(ret, descendants...)
+	}
+	return ret
+}

server/public/shared/markdown/list_test.go

@@ -0,0 +1,44 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestListStart(t *testing.T) {
+	t.Run("depth at the nesting limit is rejected even for a well-formed list item", func(t *testing.T) {
+		markdown := "- foo"
+		blocks := listStart(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth)
+		assert.Nil(t, blocks)
+	})
+
+	t.Run("nesting from a single line is capped at maxNestingDepth", func(t *testing.T) {
+		n := maxNestingDepth + 8
+		markdown := strings.Repeat("- ", n) + "x"
+		blocks := listStart(markdown, 0, Range{0, len(markdown)}, nil, nil, 0)
+		require.NotEmpty(t, blocks)
+
+		counts := countBlocksByType(blocks)
+		assert.Equal(t, maxNestingDepth, counts["*markdown.List"])
+		assert.Equal(t, maxNestingDepth, counts["*markdown.ListItem"])
+		assert.Equal(t, 1, counts["*markdown.Paragraph"])
+		assert.IsType(t, &Paragraph{}, blocks[len(blocks)-1])
+	})
+
+	t.Run("nesting is capped relative to the depth already accrued by open ancestor blocks", func(t *testing.T) {
+		markdown := "- - - x"
+		blocks := listStart(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth-2)
+		require.NotEmpty(t, blocks)
+
+		counts := countBlocksByType(blocks)
+		assert.Equal(t, 2, counts["*markdown.List"])
+		assert.Equal(t, 2, counts["*markdown.ListItem"])
+		assert.Equal(t, 1, counts["*markdown.Paragraph"])
+	})
+}

server/public/shared/markdown/markdown.go

@@ -0,0 +1,159 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+// This package implements a parser for the subset of the CommonMark spec necessary for us to do
+// server-side processing. It is not a full implementation and lacks many features. But it is
+// complete enough to efficiently and accurately allow us to do what we need to like rewrite image
+// URLs for proxying.
+package markdown
+
+import (
+	"strings"
+)
+
+func isEscapable(c rune) bool {
+	return c > ' ' && (c < '0' || (c > '9' && (c < 'A' || (c > 'Z' && (c < 'a' || (c > 'z' && c <= '~'))))))
+}
+
+func isEscapableByte(c byte) bool {
+	return isEscapable(rune(c))
+}
+
+func isWhitespace(c rune) bool {
+	switch c {
+	case ' ', '\t', '\n', '\u000b', '\u000c', '\r':
+		return true
+	}
+	return false
+}
+
+func isWhitespaceByte(c byte) bool {
+	return isWhitespace(rune(c))
+}
+
+func isNumeric(c rune) bool {
+	return c >= '0' && c <= '9'
+}
+
+func isNumericByte(c byte) bool {
+	return isNumeric(rune(c))
+}
+
+func isHex(c rune) bool {
+	return isNumeric(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')
+}
+
+func isHexByte(c byte) bool {
+	return isHex(rune(c))
+}
+
+func isAlphanumeric(c rune) bool {
+	return isNumeric(c) || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+}
+
+func isAlphanumericByte(c byte) bool {
+	return isAlphanumeric(rune(c))
+}
+
+// isWord returns true if c matches the \w regexp character class
+func isWord(c rune) bool {
+	return isAlphanumeric(c) || c == '_'
+}
+
+func isWordByte(c byte) bool {
+	return isWord(rune(c))
+}
+
+func nextNonWhitespace(markdown string, position int) int {
+	for offset, c := range []byte(markdown[position:]) {
+		if !isWhitespaceByte(c) {
+			return position + offset
+		}
+	}
+	return len(markdown)
+}
+
+func nextLine(markdown string, position int) (linePosition int, skippedNonWhitespace bool) {
+	for i := position; i < len(markdown); i++ {
+		c := markdown[i]
+		if c == '\r' {
+			if i+1 < len(markdown) && markdown[i+1] == '\n' {
+				return i + 2, skippedNonWhitespace
+			}
+			return i + 1, skippedNonWhitespace
+		} else if c == '\n' {
+			return i + 1, skippedNonWhitespace
+		} else if !isWhitespaceByte(c) {
+			skippedNonWhitespace = true
+		}
+	}
+	return len(markdown), skippedNonWhitespace
+}
+
+func countIndentation(markdown string, r Range) (spaces, bytes int) {
+	for i := r.Position; i < r.End; i++ {
+		if markdown[i] == ' ' {
+			spaces++
+			bytes++
+		} else if markdown[i] == '\t' {
+			spaces += 4
+			bytes++
+		} else {
+			break
+		}
+	}
+	return
+}
+
+func trimLeftSpace(markdown string, r Range) Range {
+	s := markdown[r.Position:r.End]
+	trimmed := strings.TrimLeftFunc(s, isWhitespace)
+	return Range{r.Position, r.End - (len(s) - len(trimmed))}
+}
+
+func trimRightSpace(markdown string, r Range) Range {
+	s := markdown[r.Position:r.End]
+	trimmed := strings.TrimRightFunc(s, isWhitespace)
+	return Range{r.Position, r.End - (len(s) - len(trimmed))}
+}
+
+func relativeToAbsolutePosition(ranges []Range, position int) int {
+	rem := position
+	for _, r := range ranges {
+		l := r.End - r.Position
+		if rem < l {
+			return r.Position + rem
+		}
+		rem -= l
+	}
+	if len(ranges) == 0 {
+		return 0
+	}
+	return ranges[len(ranges)-1].End
+}
+
+func trimBytesFromRanges(ranges []Range, bytes int) (result []Range) {
+	rem := bytes
+	for _, r := range ranges {
+		if rem == 0 {
+			result = append(result, r)
+			continue
+		}
+		l := r.End - r.Position
+		if rem < l {
+			result = append(result, Range{r.Position + rem, r.End})
+			rem = 0
+			continue
+		}
+		rem -= l
+	}
+	return
+}
+
+func Parse(markdown string) (*Document, []*ReferenceDefinition) {
+	if len(markdown) > MaxLen() {
+		return &Document{}, nil
+	}
+	lines := ParseLines(markdown)
+	return ParseBlocks(markdown, lines)
+}

server/public/shared/markdown/markdown_test.go

@@ -0,0 +1,63 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestParse(t *testing.T) {
+	t.Run("rejects input longer than maxLen bytes without parsing it", func(t *testing.T) {
+		markdown := strings.Repeat("a", MaxLen()+1)
+		document, referenceDefinitions := Parse(markdown)
+		assert.Empty(t, document.Children)
+		assert.Empty(t, referenceDefinitions)
+	})
+
+	t.Run("SetMaxPostSize raises the cap so a previously rejected input is parsed", func(t *testing.T) {
+		SetMaxPostRunes(defaultMaxPostRunes)
+		defer SetMaxPostRunes(defaultMaxPostRunes)
+
+		markdown := strings.Repeat("a", MaxLen()+1)
+
+		document, _ := Parse(markdown)
+		assert.Empty(t, document.Children)
+
+		SetMaxPostRunes(defaultMaxPostRunes + 1)
+
+		document, _ = Parse(markdown)
+		assert.NotEmpty(t, document.Children)
+
+		SetMaxPostRunes(defaultMaxPostRunes)
+	})
+
+	t.Run("nesting depth is bounded regardless of how deeply a single line nests", func(t *testing.T) {
+		// Without the depth cap in blockStart/blockQuoteStart/listStart, this would force parse
+		// work that grows with the nesting depth rather than staying bounded.
+		n := 20000
+		markdown := strings.Repeat("> ", n) + "x"
+
+		document, _ := Parse(markdown)
+		require.Len(t, document.Children, 1)
+
+		depth := 0
+		block := document.Children[0]
+		for {
+			blockQuote, ok := block.(*BlockQuote)
+			if !ok {
+				break
+			}
+			depth++
+			require.NotEmpty(t, blockQuote.Children)
+			block = blockQuote.Children[0]
+		}
+		// ParseBlocks counts the Document itself as the first ancestor, so a full parse tops out
+		// one level below the maxNestingDepth threshold used by the block-start functions directly.
+		assert.Equal(t, maxNestingDepth-1, depth)
+	})
+}

server/public/shared/markdown/paragraph.go

@@ -0,0 +1,72 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"slices"
+	"strings"
+)
+
+type Paragraph struct {
+	blockBase
+	markdown string
+
+	Text                 []Range
+	ReferenceDefinitions []*ReferenceDefinition
+}
+
+func (b *Paragraph) ParseInlines(referenceDefinitions []*ReferenceDefinition) []Inline {
+	return ParseInlines(b.markdown, b.Text, referenceDefinitions)
+}
+
+func (b *Paragraph) Continuation(indentation int, r Range) *continuation {
+	s := b.markdown[r.Position:r.End]
+	if strings.TrimSpace(s) == "" {
+		return nil
+	}
+	return &continuation{
+		Indentation: indentation,
+		Remaining:   r,
+	}
+}
+
+func (b *Paragraph) Close() {
+	for {
+		for i := range b.Text {
+			b.Text[i] = trimLeftSpace(b.markdown, b.Text[i])
+			if b.Text[i].Position < b.Text[i].End {
+				break
+			}
+		}
+
+		if len(b.Text) == 0 || b.Text[0].Position < b.Text[0].End && b.markdown[b.Text[0].Position] != '[' {
+			break
+		}
+
+		definition, remaining := parseReferenceDefinition(b.markdown, b.Text)
+		if definition == nil {
+			break
+		}
+		b.ReferenceDefinitions = append(b.ReferenceDefinitions, definition)
+		b.Text = remaining
+	}
+
+	for i, v := range slices.Backward(b.Text) {
+		b.Text[i] = trimRightSpace(b.markdown, v)
+		if b.Text[i].Position < b.Text[i].End {
+			break
+		}
+	}
+}
+
+func newParagraph(markdown string, r Range) *Paragraph {
+	s := markdown[r.Position:r.End]
+	if strings.TrimSpace(s) == "" {
+		return nil
+	}
+	return &Paragraph{
+		markdown: markdown,
+		Text:     []Range{r},
+	}
+}

server/public/shared/markdown/reference_definition.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import "strings"
+
+type ReferenceDefinition struct {
+	RawDestination Range
+
+	markdown string
+	rawLabel string
+	rawTitle string
+}
+
+func (d *ReferenceDefinition) Destination() string {
+	return Unescape(d.markdown[d.RawDestination.Position:d.RawDestination.End])
+}
+
+func (d *ReferenceDefinition) Label() string {
+	return d.rawLabel
+}
+
+func (d *ReferenceDefinition) Title() string {
+	return Unescape(d.rawTitle)
+}
+
+func parseReferenceDefinition(markdown string, ranges []Range) (*ReferenceDefinition, []Range) {
+	var rawSb strings.Builder
+	for _, r := range ranges {
+		rawSb.WriteString(markdown[r.Position:r.End])
+	}
+	raw := rawSb.String()
+
+	label, next, ok := parseLinkLabel(raw, 0)
+	if !ok {
+		return nil, nil
+	}
+	position := next
+
+	if position >= len(raw) || raw[position] != ':' {
+		return nil, nil
+	}
+	position++
+
+	destination, next, ok := parseLinkDestination(raw, nextNonWhitespace(raw, position))
+	if !ok {
+		return nil, nil
+	}
+	position = next
+
+	absoluteDestination := relativeToAbsolutePosition(ranges, destination.Position)
+	ret := &ReferenceDefinition{
+		RawDestination: Range{absoluteDestination, absoluteDestination + destination.End - destination.Position},
+		markdown:       markdown,
+		rawLabel:       raw[label.Position:label.End],
+	}
+
+	if position < len(raw) && isWhitespaceByte(raw[position]) {
+		title, next, ok := parseLinkTitle(raw, nextNonWhitespace(raw, position))
+		if !ok {
+			if nextLine, skippedNonWhitespace := nextLine(raw, position); !skippedNonWhitespace {
+				return ret, trimBytesFromRanges(ranges, nextLine)
+			}
+			return nil, nil
+		}
+		if nextLine, skippedNonWhitespace := nextLine(raw, next); !skippedNonWhitespace {
+			ret.rawTitle = raw[title.Position:title.End]
+			return ret, trimBytesFromRanges(ranges, nextLine)
+		}
+	}
+
+	if nextLine, skippedNonWhitespace := nextLine(raw, position); !skippedNonWhitespace {
+		return ret, trimBytesFromRanges(ranges, nextLine)
+	}
+
+	return nil, nil
+}

server/public/shared/markdown/text_range_test.go

@@ -0,0 +1,113 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTextRanges(t *testing.T) {
+	for name, tc := range map[string]struct {
+		Markdown       string
+		ExpectedRanges []Range
+		ExpectedValues []string
+	}{
+		"simple": {
+			Markdown:       "hello",
+			ExpectedRanges: []Range{{0, 5}},
+			ExpectedValues: []string{"hello"},
+		},
+		"simple2": {
+			Markdown:       "hello!",
+			ExpectedRanges: []Range{{0, 6}},
+			ExpectedValues: []string{"hello!"},
+		},
+		"multiline": {
+			Markdown:       "hello world\nfoobar",
+			ExpectedRanges: []Range{{0, 11}, {12, 18}},
+			ExpectedValues: []string{"hello world", "foobar"},
+		},
+		"code": {
+			Markdown:       "hello `code` world",
+			ExpectedRanges: []Range{{0, 6}, {12, 18}},
+			ExpectedValues: []string{"hello ", " world"},
+		},
+		"notcode": {
+			Markdown:       "hello ` world",
+			ExpectedRanges: []Range{{0, 13}},
+			ExpectedValues: []string{"hello ` world"},
+		},
+		"escape": {
+			Markdown:       "\\*hello\\*",
+			ExpectedRanges: []Range{{1, 7}, {8, 9}},
+			ExpectedValues: []string{"*hello", "*"},
+		},
+		"escapeescape": {
+			Markdown:       "\\\\",
+			ExpectedRanges: []Range{{1, 2}},
+			ExpectedValues: []string{"\\"},
+		},
+		"notescape": {
+			Markdown:       "foo\\x",
+			ExpectedRanges: []Range{{0, 5}},
+			ExpectedValues: []string{"foo\\x"},
+		},
+		"notlink": {
+			Markdown:       "[foo",
+			ExpectedRanges: []Range{{0, 4}},
+			ExpectedValues: []string{"[foo"},
+		},
+		"notlinkend": {
+			Markdown:       "[foo]",
+			ExpectedRanges: []Range{{0, 5}},
+			ExpectedValues: []string{"[foo]"},
+		},
+		"notimage": {
+			Markdown:       "![foo",
+			ExpectedRanges: []Range{{0, 5}},
+			ExpectedValues: []string{"![foo"},
+		},
+		"notimage2": {
+			Markdown:       "!foo",
+			ExpectedRanges: []Range{{0, 4}},
+			ExpectedValues: []string{"!foo"},
+		},
+		"charref": {
+			Markdown:       ""test",
+			ExpectedRanges: []Range{{0, 1}, {6, 10}},
+			ExpectedValues: []string{"\"", "test"},
+		},
+		"notcharref": {
+			Markdown:       "&amp test",
+			ExpectedRanges: []Range{{0, 9}},
+			ExpectedValues: []string{"&amp test"},
+		},
+		"notcharref2": {
+			Markdown:       "this is &mattermost;",
+			ExpectedRanges: []Range{{0, 20}},
+			ExpectedValues: []string{"this is &mattermost;"},
+		},
+		"standalone-ampersand": {
+			Markdown:       "Hello & World",
+			ExpectedRanges: []Range{{0, 13}},
+			ExpectedValues: []string{"Hello & World"},
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var ranges []Range
+			var values []string
+			Inspect(tc.Markdown, func(node any) bool {
+				if textNode, ok := node.(*Text); ok {
+					ranges = append(ranges, textNode.Range)
+					values = append(values, textNode.Text)
+				}
+				return true
+			})
+			assert.Equal(t, tc.ExpectedRanges, ranges)
+			assert.Equal(t, tc.ExpectedValues, values)
+		})
+	}
+}