Update server dependencies

build/manifest/vendor/github.com/mattermost/mattermost-server/utils/markdown/autolink.go

@@ -16,27 +16,27 @@ var (
 	DefaultUrlSchemes = []string{"http", "https", "ftp", "mailto", "tel"}
 )
 
-// Given a string with a w at the given position, tries to parse and return a link starting with "www."
+// 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) string {
+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 ""
+			return Range{}, false
 		}
 	}
 
 	// Check that this starts with www
 	if len(data)-position < 4 || !regexp.MustCompile(`^www\d{0,3}\.`).MatchString(data[position:]) {
-		return ""
+		return Range{}, false
 	}
 
 	end := checkDomain(data[position:], false)
 	if end == 0 {
-		return ""
+		return Range{}, false
 	}
 
 	end += position
@@ -47,12 +47,12 @@ func parseWWWAutolink(data string, position int) string {
 	}
 
 	// Trim trailing punctuation
-	link := trimTrailingCharactersFromLink(data[position:end])
-	if link == "" {
-		return ""
+	end = trimTrailingCharactersFromLink(data, position, end)
+	if position == end {
+		return Range{}, false
 	}
 
-	return link
+	return Range{position, end}, true
 }
 
 func isAllowedBeforeWWWLink(c byte) bool {
@@ -64,13 +64,13 @@ func isAllowedBeforeWWWLink(c byte) bool {
 	}
 }
 
-// Given a string with a : at the given position, tried to parse and return a link starting with a URL scheme
+// 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) string {
+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 ""
+		return Range{}, false
 	}
 
 	start := position - 1
@@ -81,12 +81,12 @@ func parseURLAutolink(data string, position int) string {
 	// 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 ""
+		return Range{}, false
 	}
 
 	end := checkDomain(data[position+3:], true)
 	if end == 0 {
-		return ""
+		return Range{}, false
 	}
 
 	end += position
@@ -97,12 +97,12 @@ func parseURLAutolink(data string, position int) string {
 	}
 
 	// Trim trailing punctuation
-	link := trimTrailingCharactersFromLink(data[start:end])
-	if link == "" {
-		return ""
+	end = trimTrailingCharactersFromLink(data, start, end)
+	if start == end {
+		return Range{}, false
 	}
 
-	return link
+	return Range{start, end}, true
 }
 
 func isSchemeAllowed(scheme string) bool {
@@ -166,9 +166,9 @@ func isValidHostCharacter(link string) bool {
 }
 
 // Removes any trailing characters such as punctuation or stray brackets that shouldn't be part of the link.
-// Equivalent to autolink_delim from the reference code.
-func trimTrailingCharactersFromLink(link string) string {
-	runes := []rune(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
@@ -240,7 +240,7 @@ func trimTrailingCharactersFromLink(link string) string {
 		}
 	}
 
-	return string(runes[:linkEnd])
+	return start + len(string(runes[:linkEnd]))
 }
 
 func canEndAutolink(c rune) bool {

build/manifest/vendor/github.com/mattermost/mattermost-server/utils/markdown/html.go

@@ -157,7 +157,7 @@ func RenderInlineHTML(inline Inline) (result string) {
 		}
 		result += "</a>"
 	case *Autolink:
-		result += `<a href="` + htmlEscaper.Replace(escapeURL(v.Link)) + `">`
+		result += `<a href="` + htmlEscaper.Replace(escapeURL(v.Destination())) + `">`
 		for _, inline := range v.Children {
 			result += RenderInlineHTML(inline)
 		}

build/manifest/vendor/github.com/mattermost/mattermost-server/utils/markdown/inlines.go

@@ -86,7 +86,19 @@ type Autolink struct {
 
 	Children []Inline
 
-	Link string
+	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
@@ -254,7 +266,7 @@ func (p *inlineParser) parseLinkOrImageDelimiter() {
 	}
 }
 
-func (p *inlineParser) peekAtInlineLinkDestinationAndTitle(position int) (destination, title Range, end int, ok bool) {
+func (p *inlineParser) peekAtInlineLinkDestinationAndTitle(position int, isImage bool) (destination, title Range, end int, ok bool) {
 	if position >= len(p.raw) || p.raw[position] != '(' {
 		return
 	}
@@ -273,6 +285,23 @@ func (p *inlineParser) peekAtInlineLinkDestinationAndTitle(position int) (destin
 	}
 	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) {
@@ -281,11 +310,13 @@ func (p *inlineParser) peekAtInlineLinkDestinationAndTitle(position int) (destin
 			return destination, Range{titleStart, titleStart}, titleStart + 1, true
 		}
 
-		title, end, ok = parseLinkTitle(p.raw, titleStart)
-		if !ok {
-			return
+		if p.raw[titleStart] == '"' || p.raw[titleStart] == '\'' || p.raw[titleStart] == '(' {
+			title, end, ok = parseLinkTitle(p.raw, titleStart)
+			if !ok {
+				return
+			}
+			position = end
 		}
-		position = end
 	}
 
 	closingPosition := nextNonWhitespace(p.raw, position)
@@ -317,9 +348,11 @@ func (p *inlineParser) lookForLinkOrImage() {
 			break
 		}
 
+		isImage := d.Type == imageOpeningDelimiter
+
 		var inline Inline
 
-		if destination, title, next, ok := p.peekAtInlineLinkDestinationAndTitle(p.position + 1); ok {
+		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:]...),
@@ -465,15 +498,18 @@ func (p *inlineParser) parseAutolink(c rune) bool {
 		}
 	}
 
-	link := ""
-	text := ""
+	var link Range
 	if c == ':' {
-		text = parseURLAutolink(p.raw, p.position)
-		link = text
+		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(text, ":")
+		rewind := strings.Index(p.raw[link.Position:link.End], ":")
 		if rewind != -1 {
 			lastInline := p.inlines[len(p.inlines)-1]
 			lastText, ok := lastInline.(*Text)
@@ -491,22 +527,30 @@ func (p *inlineParser) parseAutolink(c rune) bool {
 				Range: Range{lastText.Range.Position, lastText.Range.End - rewind},
 			})
 			p.position -= rewind
-
 		}
-	} else if c == 'w' {
-		text = parseWWWAutolink(p.raw, p.position)
-		link = "http://" + text
+	} else if c == 'w' || c == 'W' {
+		var ok bool
+		link, ok = parseWWWAutolink(p.raw, p.position)
+
+		if !ok {
+			return false
+		}
 	}
 
-	if text == "" {
-		return false
-	}
+	linkMarkdownPosition := relativeToAbsolutePosition(p.ranges, link.Position)
+	linkRange := Range{linkMarkdownPosition, linkMarkdownPosition + link.End - link.Position}
 
 	p.inlines = append(p.inlines, &Autolink{
-		Link:     link,
-		Children: []Inline{&Text{Text: text}},
+		Children: []Inline{
+			&Text{
+				Text:  p.raw[link.Position:link.End],
+				Range: linkRange,
+			},
+		},
+		RawDestination: linkRange,
+		markdown:       p.markdown,
 	})
-	p.position += len(text)
+	p.position += (link.End - link.Position)
 
 	return true
 }

build/manifest/vendor/github.com/mattermost/mattermost-server/utils/markdown/links.go

@@ -128,3 +128,57 @@ func parseLinkLabel(markdown string, position int) (raw Range, next int, ok bool
 
 	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 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' {
+		return
+	}
+	position += 1
+
+	// Read height
+	hasHeight := false
+	for 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
+}

build/manifest/vendor/github.com/mattermost/mattermost-server/utils/markdown/markdown.go

@@ -32,8 +32,16 @@ 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 (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')
+	return isNumeric(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')
 }
 
 func isHexByte(c byte) bool {
@@ -41,7 +49,7 @@ func isHexByte(c byte) bool {
 }
 
 func isAlphanumeric(c rune) bool {
-	return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+	return isNumeric(c) || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
 }
 
 func isAlphanumericByte(c byte) bool {