Mono repo -> Master (#22553)

Combines the following repositories into one:

https://github.com/mattermost/mattermost-server
https://github.com/mattermost/mattermost-webapp
https://github.com/mattermost/focalboard
https://github.com/mattermost/mattermost-plugin-playbooks

server/platform/shared/markdown/autolink.go

@@ -0,0 +1,255 @@
+// 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 open angle bracket if it contains one
+	for i, c := range runes {
+		if c == '<' {
+			linkEnd = i
+			break
+		}
+	}
+
+	for linkEnd > 0 {
+		c := runes[linkEnd-1]
+
+		if !canEndAutolink(c) {
+			// Trim trailing quotes, periods, etc
+			linkEnd = 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] == '&' {
+				linkEnd = newEnd
+			} else {
+				// This isn't actually an HTML entity, so just trim the semicolon
+				linkEnd = 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
+
+			numClosing := 0
+			numOpening := 0
+
+			// 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))
+
+			for i := 0; i < linkEnd; i++ {
+				if runes[i] == '(' {
+					numOpening += 1
+				} else if runes[i] == ')' {
+					numClosing += 1
+				}
+			}
+
+			if numClosing <= numOpening {
+				// There's fewer or equal closing brackets, so we've found the end of the link
+				break
+			}
+
+			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/platform/shared/markdown/autolink_test.go

@@ -0,0 +1,701 @@
+// 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 TestParseURLAutolink(t *testing.T) {
+	testCases := []struct {
+		Description string
+		Input       string
+		Position    int
+		Expected    string
+	}{
+		{
+			Description: "no link",
+			Input:       "This is an :emoji:",
+			Position:    11,
+			Expected:    "",
+		},
+		{
+			Description: "no link 2",
+			Input:       "These are two things: apple and orange",
+			Position:    20,
+			Expected:    "",
+		},
+		{
+			Description: "link with http",
+			Input:       "http://example.com and some text",
+			Position:    4,
+			Expected:    "http://example.com",
+		},
+		{
+			Description: "link with https",
+			Input:       "https://example.com and some text",
+			Position:    5,
+			Expected:    "https://example.com",
+		},
+		{
+			Description: "link with ftp",
+			Input:       "ftp://example.com and some text",
+			Position:    3,
+			Expected:    "ftp://example.com",
+		},
+		{
+			Description: "link with a path",
+			Input:       "https://example.com/abcd and some text",
+			Position:    5,
+			Expected:    "https://example.com/abcd",
+		},
+		{
+			Description: "link with parameters",
+			Input:       "ftp://example.com/abcd?foo=bar and some text",
+			Position:    3,
+			Expected:    "ftp://example.com/abcd?foo=bar",
+		},
+		{
+			Description: "link, not at start",
+			Input:       "This is https://example.com and some text",
+			Position:    13,
+			Expected:    "https://example.com",
+		},
+		{
+			Description: "link with a path, not at start",
+			Input:       "This is also http://www.example.com/abcd and some text",
+			Position:    17,
+			Expected:    "http://www.example.com/abcd",
+		},
+		{
+			Description: "link with parameters, not at start",
+			Input:       "These are https://www.example.com/abcd?foo=bar and some text",
+			Position:    15,
+			Expected:    "https://www.example.com/abcd?foo=bar",
+		},
+		{
+			Description: "link with trailing characters",
+			Input:       "This is ftp://www.example.com??",
+			Position:    11,
+			Expected:    "ftp://www.example.com",
+		},
+		{
+			Description: "multiple links",
+			Input:       "This is https://example.com/abcd and ftp://www.example.com/1234",
+			Position:    13,
+			Expected:    "https://example.com/abcd",
+		},
+		{
+			Description: "second of multiple links",
+			Input:       "This is https://example.com/abcd and ftp://www.example.com/1234",
+			Position:    40,
+			Expected:    "ftp://www.example.com/1234",
+		},
+		{
+			Description: "link with brackets",
+			Input:       "Go to ftp://www.example.com/my/page_(disambiguation) and some text",
+			Position:    9,
+			Expected:    "ftp://www.example.com/my/page_(disambiguation)",
+		},
+		{
+			Description: "link in brackets",
+			Input:       "(https://www.example.com/foo/bar)",
+			Position:    6,
+			Expected:    "https://www.example.com/foo/bar",
+		},
+		{
+			Description: "link in underscores",
+			Input:       "_http://www.example.com_",
+			Position:    5,
+			Expected:    "http://www.example.com",
+		},
+		{
+			Description: "link in asterisks",
+			Input:       "This is **ftp://example.com**",
+			Position:    13,
+			Expected:    "ftp://example.com",
+		},
+		{
+			Description: "link in strikethrough",
+			Input:       "Those were ~~https://example.com~~",
+			Position:    18,
+			Expected:    "https://example.com",
+		},
+		{
+			Description: "link with angle brackets",
+			Input:       "<b>We use http://example.com</b>",
+			Position:    14,
+			Expected:    "http://example.com",
+		},
+		{
+			Description: "bad link protocol",
+			Input:       "://///",
+			Position:    0,
+			Expected:    "",
+		},
+		{
+			Description: "position greater than input length",
+			Input:       "there is no colon",
+			Position:    1000,
+			Expected:    "",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.Description, func(t *testing.T) {
+			rawRange, ok := parseURLAutolink(testCase.Input, testCase.Position)
+
+			if testCase.Expected == "" {
+				assert.False(t, ok)
+				assert.Equal(t, Range{0, 0}, rawRange)
+			} else {
+				assert.True(t, ok)
+				assert.Equal(t, testCase.Expected, testCase.Input[rawRange.Position:rawRange.End])
+			}
+		})
+	}
+}
+
+func TestParseWWWAutolink(t *testing.T) {
+	testCases := []struct {
+		Description string
+		Input       string
+		Position    int
+		Expected    string
+	}{
+		{
+			Description: "no link",
+			Input:       "This is some text",
+			Position:    0,
+			Expected:    "",
+		},
+		{
+			Description: "link",
+			Input:       "www.example.com and some text",
+			Position:    0,
+			Expected:    "www.example.com",
+		},
+		{
+			Description: "link with a path",
+			Input:       "www.example.com/abcd and some text",
+			Position:    0,
+			Expected:    "www.example.com/abcd",
+		},
+		{
+			Description: "link with parameters",
+			Input:       "www.example.com/abcd?foo=bar and some text",
+			Position:    0,
+			Expected:    "www.example.com/abcd?foo=bar",
+		},
+		{
+			Description: "link, not at start",
+			Input:       "This is www.example.com and some text",
+			Position:    8,
+			Expected:    "www.example.com",
+		},
+		{
+			Description: "link with a path, not at start",
+			Input:       "This is also www.example.com/abcd and some text",
+			Position:    13,
+			Expected:    "www.example.com/abcd",
+		},
+		{
+			Description: "link with parameters, not at start",
+			Input:       "These are www.example.com/abcd?foo=bar and some text",
+			Position:    10,
+			Expected:    "www.example.com/abcd?foo=bar",
+		},
+		{
+			Description: "link with trailing characters",
+			Input:       "This is www.example.com??",
+			Position:    8,
+			Expected:    "www.example.com",
+		},
+		{
+			Description: "link after current position",
+			Input:       "This is some text and www.example.com",
+			Position:    0,
+			Expected:    "",
+		},
+		{
+			Description: "multiple links",
+			Input:       "This is www.example.com/abcd and www.example.com/1234",
+			Position:    8,
+			Expected:    "www.example.com/abcd",
+		},
+		{
+			Description: "multiple links 2",
+			Input:       "This is www.example.com/abcd and www.example.com/1234",
+			Position:    33,
+			Expected:    "www.example.com/1234",
+		},
+		{
+			Description: "link with brackets",
+			Input:       "Go to www.example.com/my/page_(disambiguation) and some text",
+			Position:    6,
+			Expected:    "www.example.com/my/page_(disambiguation)",
+		},
+		{
+			Description: "link following other letters",
+			Input:       "aaawww.example.com and some text",
+			Position:    3,
+			Expected:    "",
+		},
+		{
+			Description: "link in brackets",
+			Input:       "(www.example.com)",
+			Position:    1,
+			Expected:    "www.example.com",
+		},
+		{
+			Description: "link in underscores",
+			Input:       "_www.example.com_",
+			Position:    1,
+			Expected:    "www.example.com",
+		},
+		{
+			Description: "link in asterisks",
+			Input:       "This is **www.example.com**",
+			Position:    10,
+			Expected:    "www.example.com",
+		},
+		{
+			Description: "link in strikethrough",
+			Input:       "Those were ~~www.example.com~~",
+			Position:    13,
+			Expected:    "www.example.com",
+		},
+		{
+			Description: "using www1",
+			Input:       "Our backup site is at www1.example.com/foo",
+			Position:    22,
+			Expected:    "www1.example.com/foo",
+		},
+		{
+			Description: "link with angle brackets",
+			Input:       "<b>We use www2.example.com</b>",
+			Position:    10,
+			Expected:    "www2.example.com",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.Description, func(t *testing.T) {
+			rawRange, ok := parseWWWAutolink(testCase.Input, testCase.Position)
+
+			if testCase.Expected == "" {
+				assert.False(t, ok)
+				assert.Equal(t, Range{0, 0}, rawRange)
+			} else {
+				assert.True(t, ok)
+				assert.Equal(t, testCase.Expected, testCase.Input[rawRange.Position:rawRange.End])
+			}
+		})
+	}
+}
+
+func TestTrimTrailingCharactersFromLink(t *testing.T) {
+	testCases := []struct {
+		Input       string
+		Start       int
+		End         int
+		ExpectedEnd int
+	}{
+		{
+			Input:       "http://www.example.com",
+			ExpectedEnd: 22,
+		},
+		{
+			Input:       "http://www.example.com/abcd",
+			ExpectedEnd: 27,
+		},
+		{
+			Input:       "http://www.example.com/abcd/",
+			ExpectedEnd: 28,
+		},
+		{
+			Input:       "http://www.example.com/1234",
+			ExpectedEnd: 27,
+		},
+		{
+			Input:       "http://www.example.com/abcd?foo=bar",
+			ExpectedEnd: 35,
+		},
+		{
+			Input:       "http://www.example.com/abcd#heading",
+			ExpectedEnd: 35,
+		},
+		{
+			Input:       "http://www.example.com.",
+			ExpectedEnd: 22,
+		},
+		{
+			Input:       "http://www.example.com,",
+			ExpectedEnd: 22,
+		},
+		{
+			Input:       "http://www.example.com?",
+			ExpectedEnd: 22,
+		},
+		{
+			Input:       "http://www.example.com)",
+			ExpectedEnd: 22,
+		},
+		{
+			Input:       "http://www.example.com",
+			ExpectedEnd: 22,
+		},
+		{
+			Input:       "https://en.wikipedia.org/wiki/Dolphin_(disambiguation)",
+			ExpectedEnd: 54,
+		},
+		{
+			Input:       "https://en.wikipedia.org/wiki/Dolphin_(disambiguation",
+			ExpectedEnd: 53,
+		},
+		{
+			Input:       "https://en.wikipedia.org/wiki/Dolphin_(disambiguation))",
+			ExpectedEnd: 54,
+		},
+		{
+			Input:       "https://en.wikipedia.org/wiki/Dolphin_(disambiguation)_(disambiguation)",
+			ExpectedEnd: 71,
+		},
+		{
+			Input:       "https://en.wikipedia.org/wiki/Dolphin_(disambiguation_(disambiguation))",
+			ExpectedEnd: 71,
+		},
+		{
+			Input:       "http://www.example.com&quot;",
+			ExpectedEnd: 22,
+		},
+		{
+			Input:       "this is a sentence containing http://www.example.com in it",
+			Start:       30,
+			End:         52,
+			ExpectedEnd: 52,
+		},
+		{
+			Input:       "this is a sentence containing http://www.example.com???",
+			Start:       30,
+			End:         55,
+			ExpectedEnd: 52,
+		},
+		{
+			Input:       "http://google.com/å",
+			ExpectedEnd: len("http://google.com/å"),
+		},
+		{
+			Input:       "http://google.com/å...",
+			ExpectedEnd: len("http://google.com/å"),
+		},
+		{
+			Input:       "This is http://google.com/å, a link, and http://google.com/å",
+			Start:       8,
+			End:         len("This is http://google.com/å,"),
+			ExpectedEnd: len("This is http://google.com/å"),
+		},
+		{
+			Input:       "This is http://google.com/å, a link, and http://google.com/å",
+			Start:       41,
+			End:         len("This is http://google.com/å, a link, and http://google.com/å"),
+			ExpectedEnd: len("This is http://google.com/å, a link, and http://google.com/å"),
+		},
+		{
+			Input:       "This is http://google.com/å, a link, and http://google.com/å.",
+			Start:       41,
+			End:         len("This is http://google.com/å, a link, and http://google.com/å."),
+			ExpectedEnd: len("This is http://google.com/å, a link, and http://google.com/å"),
+		},
+		{
+			Input:       "http://🍄.ga/ http://x🍄.ga/",
+			Start:       0,
+			End:         len("http://🍄.ga/"),
+			ExpectedEnd: len("http://🍄.ga/"),
+		},
+		{
+			Input:       "http://🍄.ga/ http://x🍄.ga/",
+			Start:       len("http://🍄.ga/ "),
+			End:         len("http://🍄.ga/ http://x🍄.ga/"),
+			ExpectedEnd: len("http://🍄.ga/ http://x🍄.ga/"),
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.Input, func(t *testing.T) {
+			if testCase.End == 0 {
+				testCase.End = len(testCase.Input) - testCase.Start
+			}
+
+			assert.Equal(t, testCase.ExpectedEnd, trimTrailingCharactersFromLink(testCase.Input, testCase.Start, testCase.End))
+		})
+	}
+}
+
+func TestAutolinking(t *testing.T) {
+	// These tests are adapted from https://github.com/mattermost/commonmark.js/test/mattermost.txt.
+	// It is missing tests for:
+	// 1. Links surrounded by emphasis (emphasis not implemented on the server)
+	// 2. IPv6 addresses (not implemented on the server or by GitHub)
+	// 3. Custom URL schemes (not implemented)
+
+	for name, tc := range map[string]struct {
+		Markdown     string
+		ExpectedHTML string
+	}{
+		"valid-link-1": {
+			Markdown:     `http://example.com`,
+			ExpectedHTML: `<p><a href="http://example.com">http://example.com</a></p>`,
+		},
+		"valid-link-2": {
+			Markdown:     `https://example.com`,
+			ExpectedHTML: `<p><a href="https://example.com">https://example.com</a></p>`,
+		},
+		"valid-link-3": {
+			Markdown:     `ftp://example.com`,
+			ExpectedHTML: `<p><a href="ftp://example.com">ftp://example.com</a></p>`,
+		},
+		// "valid-link-4": {
+		// 	Markdown:     `ts3server://example.com?port=9000`,
+		// 	ExpectedHTML: `<p><a href="ts3server://example.com?port=9000">ts3server://example.com?port=9000</a></p>`,
+		// },
+		"valid-link-5": {
+			Markdown:     `www.example.com`,
+			ExpectedHTML: `<p><a href="http://www.example.com">www.example.com</a></p>`,
+		},
+		"valid-link-6": {
+			Markdown:     `www.example.com/index`,
+			ExpectedHTML: `<p><a href="http://www.example.com/index">www.example.com/index</a></p>`,
+		},
+		"valid-link-7": {
+			Markdown:     `www.example.com/index.html`,
+			ExpectedHTML: `<p><a href="http://www.example.com/index.html">www.example.com/index.html</a></p>`,
+		},
+		"valid-link-8": {
+			Markdown:     `http://example.com/index/sub`,
+			ExpectedHTML: `<p><a href="http://example.com/index/sub">http://example.com/index/sub</a></p>`,
+		},
+		"valid-link-9": {
+			Markdown:     `www1.example.com`,
+			ExpectedHTML: `<p><a href="http://www1.example.com">www1.example.com</a></p>`,
+		},
+		"valid-link-10": {
+			Markdown:     `https://en.wikipedia.org/wiki/URLs#Syntax`,
+			ExpectedHTML: `<p><a href="https://en.wikipedia.org/wiki/URLs#Syntax">https://en.wikipedia.org/wiki/URLs#Syntax</a></p>`,
+		},
+		"valid-link-11": {
+			Markdown:     `https://groups.google.com/forum/#!msg`,
+			ExpectedHTML: `<p><a href="https://groups.google.com/forum/#!msg">https://groups.google.com/forum/#!msg</a></p>`,
+		},
+		"valid-link-12": {
+			Markdown:     `www.example.com/index?params=1`,
+			ExpectedHTML: `<p><a href="http://www.example.com/index?params=1">www.example.com/index?params=1</a></p>`,
+		},
+		"valid-link-13": {
+			Markdown:     `www.example.com/index?params=1&other=2`,
+			ExpectedHTML: `<p><a href="http://www.example.com/index?params=1&amp;other=2">www.example.com/index?params=1&amp;other=2</a></p>`,
+		},
+		"valid-link-14": {
+			Markdown:     `www.example.com/index?params=1;other=2`,
+			ExpectedHTML: `<p><a href="http://www.example.com/index?params=1;other=2">www.example.com/index?params=1;other=2</a></p>`,
+		},
+		"valid-link-15": {
+			Markdown:     `http://www.example.com/_/page`,
+			ExpectedHTML: `<p><a href="http://www.example.com/_/page">http://www.example.com/_/page</a></p>`,
+		},
+		"valid-link-16": {
+			Markdown:     `https://en.wikipedia.org/wiki/🐬`,
+			ExpectedHTML: `<p><a href="https://en.wikipedia.org/wiki/%F0%9F%90%AC">https://en.wikipedia.org/wiki/🐬</a></p>`,
+		},
+		"valid-link-17": {
+			Markdown:     `http://✪df.ws/1234`,
+			ExpectedHTML: `<p><a href="http://%E2%9C%AAdf.ws/1234">http://✪df.ws/1234</a></p>`,
+		},
+		"valid-link-18": {
+			Markdown:     `https://groups.google.com/forum/#!msg`,
+			ExpectedHTML: `<p><a href="https://groups.google.com/forum/#!msg">https://groups.google.com/forum/#!msg</a></p>`,
+		},
+		"valid-link-19": {
+			Markdown:     `https://пример.срб/пример-26/`,
+			ExpectedHTML: `<p><a href="https://%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80.%D1%81%D1%80%D0%B1/%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80-26/">https://пример.срб/пример-26/</a></p>`,
+		},
+		"valid-link-20": {
+			Markdown:     `mailto://test@example.com`,
+			ExpectedHTML: `<p><a href="mailto://test@example.com">mailto://test@example.com</a></p>`,
+		},
+		"valid-link-21": {
+			Markdown:     `tel://555-123-4567`,
+			ExpectedHTML: `<p><a href="tel://555-123-4567">tel://555-123-4567</a></p>`,
+		},
+
+		"ip-address-1": {
+			Markdown:     `http://127.0.0.1`,
+			ExpectedHTML: `<p><a href="http://127.0.0.1">http://127.0.0.1</a></p>`,
+		},
+		"ip-address-2": {
+			Markdown:     `http://192.168.1.1:4040`,
+			ExpectedHTML: `<p><a href="http://192.168.1.1:4040">http://192.168.1.1:4040</a></p>`,
+		},
+		"ip-address-3": {
+			Markdown:     `http://username:password@127.0.0.1`,
+			ExpectedHTML: `<p><a href="http://username:password@127.0.0.1">http://username:password@127.0.0.1</a></p>`,
+		},
+		"ip-address-4": {
+			Markdown:     `http://username:password@[2001:0:5ef5:79fb:303a:62d5:3312:ff42]:80`,
+			ExpectedHTML: `<p><a href="http://username:password@%5B2001:0:5ef5:79fb:303a:62d5:3312:ff42%5D:80">http://username:password@[2001:0:5ef5:79fb:303a:62d5:3312:ff42]:80</a></p>`,
+		},
+
+		"link-with-brackets-1": {
+			Markdown:     `https://en.wikipedia.org/wiki/Rendering_(computer_graphics)`,
+			ExpectedHTML: `<p><a href="https://en.wikipedia.org/wiki/Rendering_(computer_graphics)">https://en.wikipedia.org/wiki/Rendering_(computer_graphics)</a></p>`,
+		},
+		"link-with-brackets-2": {
+			Markdown:     `http://example.com/more_(than)_one_(parens)`,
+			ExpectedHTML: `<p><a href="http://example.com/more_(than)_one_(parens)">http://example.com/more_(than)_one_(parens)</a></p>`,
+		},
+		"link-with-brackets-3": {
+			Markdown:     `http://example.com/(something)?after=parens`,
+			ExpectedHTML: `<p><a href="http://example.com/(something)?after=parens">http://example.com/(something)?after=parens</a></p>`,
+		},
+		"link-with-brackets-4": {
+			Markdown:     `http://foo.com/unicode_(✪)_in_parens`,
+			ExpectedHTML: `<p><a href="http://foo.com/unicode_(%E2%9C%AA)_in_parens">http://foo.com/unicode_(✪)_in_parens</a></p>`,
+		},
+
+		"inside-another-link-1": {
+			Markdown:     `[www.example.com](https://example.com)`,
+			ExpectedHTML: `<p><a href="https://example.com">www.example.com</a></p>`,
+		},
+		"inside-another-link-2": {
+			Markdown:     `[http://www.example.com](https://example.com)`,
+			ExpectedHTML: `<p><a href="https://example.com">http://www.example.com</a></p>`,
+		},
+
+		"link-in-sentence-1": {
+			Markdown:     `(http://example.com)`,
+			ExpectedHTML: `<p>(<a href="http://example.com">http://example.com</a>)</p>`,
+		},
+		"link-in-sentence-2": {
+			Markdown:     `(see http://example.com)`,
+			ExpectedHTML: `<p>(see <a href="http://example.com">http://example.com</a>)</p>`,
+		},
+		"link-in-sentence-3": {
+			Markdown:     `(http://example.com watch this)`,
+			ExpectedHTML: `<p>(<a href="http://example.com">http://example.com</a> watch this)</p>`,
+		},
+		"link-in-sentence-4": {
+			Markdown:     `This is a sentence with a http://example.com in it.`,
+			ExpectedHTML: `<p>This is a sentence with a <a href="http://example.com">http://example.com</a> in it.</p>`,
+		},
+		"link-in-sentence-5": {
+			Markdown:     `This is a sentence with a [link](http://example.com) in it.`,
+			ExpectedHTML: `<p>This is a sentence with a <a href="http://example.com">link</a> in it.</p>`,
+		},
+		"link-in-sentence-6": {
+			Markdown:     `This is a sentence with a http://example.com/_/underscore in it.`,
+			ExpectedHTML: `<p>This is a sentence with a <a href="http://example.com/_/underscore">http://example.com/_/underscore</a> in it.</p>`,
+		},
+		"link-in-sentence-7": {
+			Markdown:     `This is a sentence with a link (http://example.com) in it.`,
+			ExpectedHTML: `<p>This is a sentence with a link (<a href="http://example.com">http://example.com</a>) in it.</p>`,
+		},
+		"link-in-sentence-8": {
+			Markdown:     `This is a sentence with a (https://en.wikipedia.org/wiki/Rendering_(computer_graphics)) in it.`,
+			ExpectedHTML: `<p>This is a sentence with a (<a href="https://en.wikipedia.org/wiki/Rendering_(computer_graphics)">https://en.wikipedia.org/wiki/Rendering_(computer_graphics)</a>) in it.</p>`,
+		},
+		"link-in-sentence-9": {
+			Markdown:     `This is a sentence with a http://192.168.1.1:4040 in it.`,
+			ExpectedHTML: `<p>This is a sentence with a <a href="http://192.168.1.1:4040">http://192.168.1.1:4040</a> in it.</p>`,
+		},
+		"link-in-sentence-10": {
+			Markdown:     `This is a link to http://example.com.`,
+			ExpectedHTML: `<p>This is a link to <a href="http://example.com">http://example.com</a>.</p>`,
+		},
+		"link-in-sentence-11": {
+			Markdown:     `This is a link to http://example.com*`,
+			ExpectedHTML: `<p>This is a link to <a href="http://example.com">http://example.com</a>*</p>`,
+		},
+		"link-in-sentence-12": {
+			Markdown:     `This is a link to http://example.com_`,
+			ExpectedHTML: `<p>This is a link to <a href="http://example.com">http://example.com</a>_</p>`,
+		},
+		"link-in-sentence-13": {
+			Markdown:     `This is a link containing http://example.com/something?with,commas,in,url, but not at the end`,
+			ExpectedHTML: `<p>This is a link containing <a href="http://example.com/something?with,commas,in,url">http://example.com/something?with,commas,in,url</a>, but not at the end</p>`,
+		},
+		"link-in-sentence-14": {
+			Markdown:     `This is a question about a link http://example.com?`,
+			ExpectedHTML: `<p>This is a question about a link <a href="http://example.com">http://example.com</a>?</p>`,
+		},
+
+		"plt-7250-link-with-trailing-periods-1": {
+			Markdown:     `http://example.com.`,
+			ExpectedHTML: `<p><a href="http://example.com">http://example.com</a>.</p>`,
+		},
+		"plt-7250-link-with-trailing-periods-2": {
+			Markdown:     `http://example.com...`,
+			ExpectedHTML: `<p><a href="http://example.com">http://example.com</a>...</p>`,
+		},
+		"plt-7250-link-with-trailing-periods-3": {
+			Markdown:     `http://example.com/foo.`,
+			ExpectedHTML: `<p><a href="http://example.com/foo">http://example.com/foo</a>.</p>`,
+		},
+		"plt-7250-link-with-trailing-periods-4": {
+			Markdown:     `http://example.com/foo...`,
+			ExpectedHTML: `<p><a href="http://example.com/foo">http://example.com/foo</a>...</p>`,
+		},
+		"plt-7250-link-with-trailing-periods-5": {
+			Markdown:     `http://example.com/foo.bar`,
+			ExpectedHTML: `<p><a href="http://example.com/foo.bar">http://example.com/foo.bar</a></p>`,
+		},
+		"plt-7250-link-with-trailing-periods-6": {
+			Markdown:     `http://example.com/foo...bar`,
+			ExpectedHTML: `<p><a href="http://example.com/foo...bar">http://example.com/foo...bar</a></p>`,
+		},
+
+		"rn-319-www-link-as-part-of-word-1": {
+			Markdown:     `testwww.example.com`,
+			ExpectedHTML: `<p>testwww.example.com</p>`,
+		},
+
+		"mm-10180-link-containing-period-followed-by-non-letter-1": {
+			Markdown:     `https://example.com/123.+Pagetitle`,
+			ExpectedHTML: `<p><a href="https://example.com/123.+Pagetitle">https://example.com/123.+Pagetitle</a></p>`,
+		},
+		"mm-10180-link-containing-period-followed-by-non-letter-2": {
+			Markdown:     `https://example.com/123.?Pagetitle`,
+			ExpectedHTML: `<p><a href="https://example.com/123.?Pagetitle">https://example.com/123.?Pagetitle</a></p>`,
+		},
+		"mm-10180-link-containing-period-followed-by-non-letter-3": {
+			Markdown:     `https://example.com/123.-Pagetitle`,
+			ExpectedHTML: `<p><a href="https://example.com/123.-Pagetitle">https://example.com/123.-Pagetitle</a></p>`,
+		},
+		"mm-10180-link-containing-period-followed-by-non-letter-4": {
+			Markdown:     `https://example.com/123._Pagetitle`,
+			ExpectedHTML: `<p><a href="https://example.com/123._Pagetitle">https://example.com/123._Pagetitle</a></p>`,
+		},
+		"mm-10180-link-containing-period-followed-by-non-letter-5": {
+			Markdown:     `https://example.com/123.+`,
+			ExpectedHTML: `<p><a href="https://example.com/123.+">https://example.com/123.+</a></p>`,
+		},
+		"mm-10180-link-containing-period-followed-by-non-letter-6": {
+			Markdown:     `https://example.com/123.?`,
+			ExpectedHTML: `<p><a href="https://example.com/123">https://example.com/123</a>.?</p>`,
+		},
+		"mm-10180-link-containing-period-followed-by-non-letter-7": {
+			Markdown:     `https://example.com/123.-`,
+			ExpectedHTML: `<p><a href="https://example.com/123.-">https://example.com/123.-</a></p>`,
+		},
+		"mm-10180-link-containing-period-followed-by-non-letter-8": {
+			Markdown:     `https://example.com/123._`,
+			ExpectedHTML: `<p><a href="https://example.com/123">https://example.com/123</a>._</p>`,
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			assert.Equal(t, tc.ExpectedHTML, RenderHTML(tc.Markdown))
+		})
+	}
+}

server/platform/shared/markdown/block_quote.go

@@ -0,0 +1,62 @@
+// 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) []Block {
+	if indent > 3 {
+		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); descendants != nil {
+		block.Children = append(block.Children, descendants[0])
+		ret = append(ret, descendants...)
+	}
+	return ret
+}

server/platform/shared/markdown/blocks.go

@@ -0,0 +1,154 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"strings"
+)
+
+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:]); 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) []Block {
+	if r.Position >= r.End {
+		return nil
+	}
+
+	if start := blockQuoteStart(markdown, indentation, r); start != nil {
+		return start
+	} else if start := listStart(markdown, indentation, r, matchedBlocks, unmatchedBlocks); 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) []Block {
+	if start := blockStart(markdown, indentation, r, matchedBlocks, unmatchedBlocks); start != nil {
+		return start
+	}
+	if paragraph := newParagraph(markdown, r); paragraph != nil {
+		return []Block{paragraph}
+	}
+	return nil
+}

server/platform/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/platform/shared/markdown/fenced_code.go

@@ -0,0 +1,112 @@
+// 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() (result string) {
+	for _, code := range b.RawCode {
+		result += strings.Repeat(" ", code.Indentation) + b.markdown[code.Range.Position:code.Range.End]
+	}
+	return
+}
+
+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/platform/shared/markdown/html.go

@@ -0,0 +1,192 @@
+// 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) (result string) {
+	switch v := block.(type) {
+	case *Document:
+		for _, block := range v.Children {
+			result += RenderBlockHTML(block, referenceDefinitions)
+		}
+	case *Paragraph:
+		if len(v.Text) == 0 {
+			return
+		}
+		if !isTightList {
+			result += "<p>"
+		}
+		for _, inline := range v.ParseInlines(referenceDefinitions) {
+			result += RenderInlineHTML(inline)
+		}
+		if !isTightList {
+			result += "</p>"
+		}
+	case *List:
+		if v.IsOrdered {
+			if v.OrderedStart != 1 {
+				result += fmt.Sprintf(`<ol start="%v">`, v.OrderedStart)
+			} else {
+				result += "<ol>"
+			}
+		} else {
+			result += "<ul>"
+		}
+		for _, block := range v.Children {
+			result += renderBlockHTML(block, referenceDefinitions, !v.IsLoose)
+		}
+		if v.IsOrdered {
+			result += "</ol>"
+		} else {
+			result += "</ul>"
+		}
+	case *ListItem:
+		result += "<li>"
+		for _, block := range v.Children {
+			result += renderBlockHTML(block, referenceDefinitions, isTightList)
+		}
+		result += "</li>"
+	case *BlockQuote:
+		result += "<blockquote>"
+		for _, block := range v.Children {
+			result += RenderBlockHTML(block, referenceDefinitions)
+		}
+		result += "</blockquote>"
+	case *FencedCode:
+		if info := v.Info(); info != "" {
+			language := strings.Fields(info)[0]
+			result += `<pre><code class="language-` + htmlEscaper.Replace(language) + `">`
+		} else {
+			result += "<pre><code>"
+		}
+		result += htmlEscaper.Replace(v.Code()) + "</code></pre>"
+	case *IndentedCode:
+		result += "<pre><code>" + htmlEscaper.Replace(v.Code()) + "</code></pre>"
+	default:
+		panic(fmt.Sprintf("missing case for type %T", v))
+	}
+	return
+}
+
+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:
+		result += `<a href="` + htmlEscaper.Replace(escapeURL(v.Destination())) + `"`
+		if title := v.Title(); title != "" {
+			result += ` title="` + htmlEscaper.Replace(title) + `"`
+		}
+		result += `>`
+		for _, inline := range v.Children {
+			result += RenderInlineHTML(inline)
+		}
+		result += "</a>"
+	case *ReferenceLink:
+		result += `<a href="` + htmlEscaper.Replace(escapeURL(v.Destination())) + `"`
+		if title := v.Title(); title != "" {
+			result += ` title="` + htmlEscaper.Replace(title) + `"`
+		}
+		result += `>`
+		for _, inline := range v.Children {
+			result += RenderInlineHTML(inline)
+		}
+		result += "</a>"
+	case *Autolink:
+		result += `<a href="` + htmlEscaper.Replace(escapeURL(v.Destination())) + `">`
+		for _, inline := range v.Children {
+			result += RenderInlineHTML(inline)
+		}
+		result += "</a>"
+	default:
+		panic(fmt.Sprintf("missing case for type %T", v))
+	}
+	return
+}
+
+func renderImageAltText(children []Inline) (result string) {
+	for _, inline := range children {
+		result += renderImageChildAltText(inline)
+	}
+	return
+}
+
+func renderImageChildAltText(inline Inline) (result string) {
+	switch v := inline.(type) {
+	case *Text:
+		return v.Text
+	case *InlineImage:
+		for _, inline := range v.Children {
+			result += renderImageChildAltText(inline)
+		}
+	case *InlineLink:
+		for _, inline := range v.Children {
+			result += renderImageChildAltText(inline)
+		}
+	}
+	return
+}

server/platform/shared/markdown/indented_code.go

@@ -0,0 +1,98 @@
+// 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() (result string) {
+	for _, code := range b.RawCode {
+		result += strings.Repeat(" ", code.Indentation) + b.markdown[code.Range.Position:code.Range.End]
+	}
+	return
+}
+
+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/platform/shared/markdown/inlines.go

@@ -0,0 +1,663 @@
+// 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 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()
+			}
+		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 {
+	ret := ""
+
+	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 += string(markdown[position+1])
+				position += 2
+			} else {
+				ret += `\`
+				position++
+			}
+		case '&':
+			position++
+			if semicolon := strings.IndexByte(markdown[position:], ';'); semicolon == -1 {
+				ret += "&"
+			} else if s := CharacterReference(markdown[position : position+semicolon]); s != "" {
+				position += semicolon + 1
+				ret += s
+			} else {
+				ret += "&"
+			}
+		default:
+			ret += string(c)
+			position += cSize
+		}
+	}
+
+	return ret
+}

server/platform/shared/markdown/inspect.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+// 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) {
+	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) {
+	if !f(block) {
+		return
+	}
+	switch v := block.(type) {
+	case *Document:
+		for _, child := range v.Children {
+			InspectBlock(child, f)
+		}
+	case *List:
+		for _, child := range v.Children {
+			InspectBlock(child, f)
+		}
+	case *ListItem:
+		for _, child := range v.Children {
+			InspectBlock(child, f)
+		}
+	case *BlockQuote:
+		for _, child := range v.Children {
+			InspectBlock(child, f)
+		}
+	}
+	f(nil)
+}
+
+// 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) {
+	if !f(inline) {
+		return
+	}
+	switch v := inline.(type) {
+	case *InlineImage:
+		for _, child := range v.Children {
+			InspectInline(child, f)
+		}
+	case *InlineLink:
+		for _, child := range v.Children {
+			InspectInline(child, f)
+		}
+	case *ReferenceImage:
+		for _, child := range v.Children {
+			InspectInline(child, f)
+		}
+	case *ReferenceLink:
+		for _, child := range v.Children {
+			InspectInline(child, f)
+		}
+	}
+	f(nil)
+}

server/platform/shared/markdown/inspect_test.go

@@ -0,0 +1,75 @@
+// 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) {
+	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)
+}
+
+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 i := 0; i < b.N; i++ {
+		Inspect(text, func(_ any) bool {
+			counterSink++
+			return true
+		})
+	}
+}

server/platform/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/platform/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/platform/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/platform/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/platform/shared/markdown/list.go

@@ -0,0 +1,220 @@
+// 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) []Block {
+	afterList := false
+	if len(matchedBlocks) > 0 {
+		_, afterList = matchedBlocks[len(matchedBlocks)-1].(*List)
+	}
+	if !afterList && indent > 3 {
+		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); descendants != nil {
+		listItem.Children = append(listItem.Children, descendants[0])
+		ret = append(ret, descendants...)
+	}
+	return ret
+}

server/platform/shared/markdown/markdown.go

@@ -0,0 +1,147 @@
+// 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))
+}
+
+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) {
+	lines := ParseLines(markdown)
+	return ParseBlocks(markdown, lines)
+}

server/platform/shared/markdown/paragraph.go

@@ -0,0 +1,71 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+import (
+	"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 := 0; i < len(b.Text); i++ {
+			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 := len(b.Text) - 1; i >= 0; i-- {
+		b.Text[i] = trimRightSpace(b.markdown, b.Text[i])
+		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/platform/shared/markdown/reference_definition.go

@@ -0,0 +1,75 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package markdown
+
+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) {
+	raw := ""
+	for _, r := range ranges {
+		raw += markdown[r.Position:r.End]
+	}
+
+	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/platform/shared/markdown/text_range_test.go

@@ -0,0 +1,115 @@
+// 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)
+
+		})
+	}
+
+}