1 files changed, 132 insertions, 0 deletions
diff --git a/utils/markdown/markdown.go b/utils/markdown/markdown.go
new file mode 100644
index 000000000..3061ba4bb
--- /dev/null
+++ b/utils/markdown/markdown.go
@@ -0,0 +1,132 @@
+// Copyright (c) 2017-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
+	default:
+		return false
+	}
+}
+
+func isWhitespaceByte(c byte) bool {
+	return isWhitespace(rune(c))
+}
+
+func isHex(c rune) bool {
+	return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')
+}
+
+func isHexByte(c byte) bool {
+	return isHex(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)
+}