MM-39315: Bump dependencies (#19039)

Note: We keep splitio/go-client untouched
because the dependency is broken.

See https://github.com/mattermost/mattermost-server/pull/18604

```release-note
NONE
```

vendor/github.com/yuin/goldmark/extension/linkify.go

@@ -273,9 +273,20 @@ func (s *linkifyParser) Parse(parent ast.Node, block text.Reader, pc parser.Cont
 		s := segment.WithStop(segment.Start + 1)
 		ast.MergeOrAppendTextSegment(parent, s)
 	}
-	consumes += m[1]
+	i := m[1] - 1
+	for ; i > 0; i-- {
+		c := line[i]
+		switch c {
+		case '?', '!', '.', ',', ':', '*', '_', '~':
+		default:
+			goto endfor
+		}
+	}
+endfor:
+	i++
+	consumes += i
 	block.Advance(consumes)
-	n := ast.NewTextSegment(text.NewSegment(start, start+m[1]))
+	n := ast.NewTextSegment(text.NewSegment(start, start+i))
 	link := ast.NewAutoLink(typ, n)
 	link.Protocol = protocol
 	return link

vendor/github.com/yuin/goldmark/go.mod

@@ -1,3 +1,3 @@
 module github.com/yuin/goldmark
 
-go 1.15
+go 1.16

vendor/github.com/yuin/goldmark/parser/delimiter.go

@@ -162,15 +162,11 @@ func ProcessDelimiters(bottom ast.Node, pc Context) {
 	var closer *Delimiter
 	if bottom != nil {
 		if bottom != lastDelimiter {
-			for c := lastDelimiter.PreviousSibling(); c != nil; {
+			for c := lastDelimiter.PreviousSibling(); c != nil && c != bottom; {
 				if d, ok := c.(*Delimiter); ok {
 					closer = d
 				}
-				prev := c.PreviousSibling()
-				if prev == bottom {
-					break
-				}
-				c = prev
+				c = c.PreviousSibling()
 			}
 		}
 	} else {
@@ -189,7 +185,7 @@ func ProcessDelimiters(bottom ast.Node, pc Context) {
 		found := false
 		maybeOpener := false
 		var opener *Delimiter
-		for opener = closer.PreviousDelimiter; opener != nil; opener = opener.PreviousDelimiter {
+		for opener = closer.PreviousDelimiter; opener != nil && opener != bottom; opener = opener.PreviousDelimiter {
 			if opener.CanOpen && opener.Processor.CanOpenCloser(opener, closer) {
 				maybeOpener = true
 				consume = opener.CalcComsumption(closer)

vendor/github.com/yuin/goldmark/parser/fcode_block.go

@@ -87,8 +87,14 @@ func (b *fencedCodeBlockParser) Continue(node ast.Node, reader text.Reader, pc C
 			return Close
 		}
 	}
-	pos, padding := util.DedentPositionPadding(line, reader.LineOffset(), segment.Padding, fdata.indent)
-
+	pos, padding := util.IndentPositionPadding(line, reader.LineOffset(), segment.Padding, fdata.indent)
+	if pos < 0 {
+		pos = util.FirstNonSpacePosition(line)
+		if pos < 0 {
+			pos = 0
+		}
+		padding = 0
+	}
 	seg := text.NewSegmentPadding(segment.Start+pos, segment.Stop, padding)
 	// if code block line starts with a tab, keep a tab as it is.
 	if padding != 0 {

vendor/github.com/yuin/goldmark/parser/html_block.go

@@ -76,7 +76,7 @@ var allowedBlockTags = map[string]bool{
 	"ul":         true,
 }
 
-var htmlBlockType1OpenRegexp = regexp.MustCompile(`(?i)^[ ]{0,3}<(script|pre|style|textarea)(?:\s.*|>.*|/>.*|)\n?$`)
+var htmlBlockType1OpenRegexp = regexp.MustCompile(`(?i)^[ ]{0,3}<(script|pre|style|textarea)(?:\s.*|>.*|/>.*|)(?:\r\n|\n)?$`)
 var htmlBlockType1CloseRegexp = regexp.MustCompile(`(?i)^.*</(?:script|pre|style|textarea)>.*`)
 
 var htmlBlockType2OpenRegexp = regexp.MustCompile(`^[ ]{0,3}<!\-\-`)
@@ -85,15 +85,15 @@ var htmlBlockType2Close = []byte{'-', '-', '>'}
 var htmlBlockType3OpenRegexp = regexp.MustCompile(`^[ ]{0,3}<\?`)
 var htmlBlockType3Close = []byte{'?', '>'}
 
-var htmlBlockType4OpenRegexp = regexp.MustCompile(`^[ ]{0,3}<![A-Z]+.*\n?$`)
+var htmlBlockType4OpenRegexp = regexp.MustCompile(`^[ ]{0,3}<![A-Z]+.*(?:\r\n|\n)?$`)
 var htmlBlockType4Close = []byte{'>'}
 
 var htmlBlockType5OpenRegexp = regexp.MustCompile(`^[ ]{0,3}<\!\[CDATA\[`)
 var htmlBlockType5Close = []byte{']', ']', '>'}
 
-var htmlBlockType6Regexp = regexp.MustCompile(`^[ ]{0,3}</?([a-zA-Z0-9]+)(?:\s.*|>.*|/>.*|)\n?$`)
+var htmlBlockType6Regexp = regexp.MustCompile(`^[ ]{0,3}<(?:/[ ]*)?([a-zA-Z]+[a-zA-Z0-9\-]*)(?:[ ].*|>.*|/>.*|)(?:\r\n|\n)?$`)
 
-var htmlBlockType7Regexp = regexp.MustCompile(`^[ ]{0,3}<(/)?\s*([a-zA-Z0-9\-]+)(` + attributePattern + `*)\s*(:?>|/>)\s*\n?$`)
+var htmlBlockType7Regexp = regexp.MustCompile(`^[ ]{0,3}<(/[ ]*)?([a-zA-Z]+[a-zA-Z0-9\-]*)(` + attributePattern + `*)[ ]*(?:>|/>)[ ]*(?:\r\n|\n)?$`)
 
 type htmlBlockParser struct {
 }

vendor/github.com/yuin/goldmark/parser/link.go

@@ -140,7 +140,7 @@ func (s *linkParser) Parse(parent ast.Node, block text.Reader, pc Context) ast.N
 	}
 	block.Advance(1)
 	removeLinkLabelState(pc, last)
-	if s.containsLink(last) { // a link in a link text is not allowed
+	if !last.IsImage && s.containsLink(last) { // a link in a link text is not allowed
 		ast.MergeOrReplaceTextSegment(last.Parent(), last, last.Segment)
 		return nil
 	}
@@ -182,15 +182,17 @@ func (s *linkParser) Parse(parent ast.Node, block text.Reader, pc Context) ast.N
 	return link
 }
 
-func (s *linkParser) containsLink(last *linkLabelState) bool {
-	if last.IsImage {
+func (s *linkParser) containsLink(n ast.Node) bool {
+	if n == nil {
 		return false
 	}
-	var c ast.Node
-	for c = last; c != nil; c = c.NextSibling() {
+	for c := n; c != nil; c = c.NextSibling() {
 		if _, ok := c.(*ast.Link); ok {
 			return true
 		}
+		if s.containsLink(c.FirstChild()) {
+			return true
+		}
 	}
 	return false
 }

vendor/github.com/yuin/goldmark/parser/link_ref.go

@@ -84,7 +84,6 @@ func parseLinkReferenceDefinition(block text.Reader, pc Context) (int, int) {
 	if util.IsBlank(label) {
 		return -1, -1
 	}
-	block.SkipSpaces()
 	if block.Peek() != ':' {
 		return -1, -1
 	}
@@ -123,7 +122,8 @@ func parseLinkReferenceDefinition(block text.Reader, pc Context) (int, int) {
 		}
 		ref := NewReference(label, destination, nil)
 		pc.AddReference(ref)
-		return startLine, endLine
+		block.AdvanceLine()
+		return startLine, endLine + 1
 	}
 	var title []byte
 	if segments.Len() == 1 {

vendor/github.com/yuin/goldmark/parser/list.go

@@ -16,6 +16,10 @@ const (
 	orderedList
 )
 
+var skipListParserKey = NewContextKey()
+var emptyListItemWithBlankLines = NewContextKey()
+var listItemFlagValue interface{} = true
+
 // Same as
 // `^(([ ]*)([\-\*\+]))(\s+.*)?\n?$`.FindSubmatchIndex or
 // `^(([ ]*)(\d{1,9}[\.\)]))(\s+.*)?\n?$`.FindSubmatchIndex
@@ -123,8 +127,8 @@ func (b *listParser) Trigger() []byte {
 
 func (b *listParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
 	last := pc.LastOpenedBlock().Node
-	if _, lok := last.(*ast.List); lok || pc.Get(skipListParser) != nil {
-		pc.Set(skipListParser, nil)
+	if _, lok := last.(*ast.List); lok || pc.Get(skipListParserKey) != nil {
+		pc.Set(skipListParserKey, nil)
 		return nil, NoChildren
 	}
 	line, _ := reader.PeekLine()
@@ -144,7 +148,7 @@ func (b *listParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.
 			return nil, NoChildren
 		}
 		//an empty list item cannot interrupt a paragraph:
-		if match[5]-match[4] <= 1 {
+		if match[4] < 0 || util.IsBlank(line[match[4]:match[5]]) {
 			return nil, NoChildren
 		}
 	}
@@ -154,6 +158,7 @@ func (b *listParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.
 	if start > -1 {
 		node.Start = start
 	}
+	pc.Set(emptyListItemWithBlankLines, nil)
 	return node, HasChildren
 }
 
@@ -161,12 +166,9 @@ func (b *listParser) Continue(node ast.Node, reader text.Reader, pc Context) Sta
 	list := node.(*ast.List)
 	line, _ := reader.PeekLine()
 	if util.IsBlank(line) {
-		// A list item can begin with at most one blank line
-		if node.ChildCount() == 1 && node.LastChild().ChildCount() == 0 {
-			return Close
+		if node.LastChild().ChildCount() == 0 {
+			pc.Set(emptyListItemWithBlankLines, listItemFlagValue)
 		}
-
-		reader.Advance(len(line) - 1)
 		return Continue | HasChildren
 	}
 
@@ -178,10 +180,23 @@ func (b *listParser) Continue(node ast.Node, reader text.Reader, pc Context) Sta
 	// - a
 	//  - b          <--- current line
 	// it maybe a new child of the list.
+	//
+	// Empty list items can have multiple blanklines
+	//
+	// -             <--- 1st item is an empty thus "offset" is unknown
+	//
+	//
+	//   -           <--- current line
+	//
+	// -> 1 list with 2 blank items
+	//
+	// So if the last item is an empty, it maybe a new child of the list.
+	//
 	offset := lastOffset(node)
+	lastIsEmpty := node.LastChild().ChildCount() == 0
 	indent, _ := util.IndentWidth(line, reader.LineOffset())
 
-	if indent < offset {
+	if indent < offset || lastIsEmpty {
 		if indent < 4 {
 			match, typ := matchesListItem(line, false) // may have a leading spaces more than 3
 			if typ != notList && match[1]-offset < 4 {
@@ -203,10 +218,23 @@ func (b *listParser) Continue(node ast.Node, reader text.Reader, pc Context) Sta
 						return Close
 					}
 				}
-
 				return Continue | HasChildren
 			}
 		}
+		if !lastIsEmpty {
+			return Close
+		}
+	}
+
+	// Non empty items can not exist next to an empty list item
+	// with blank lines. So we need to close the current list
+	//
+	// -
+	//
+	//   foo
+	//
+	// -> 1 list with 1 blank items and 1 paragraph
+	if pc.Get(emptyListItemWithBlankLines) != nil {
 		return Close
 	}
 	return Continue | HasChildren
@@ -233,8 +261,9 @@ func (b *listParser) Close(node ast.Node, reader text.Reader, pc Context) {
 
 	if list.IsTight {
 		for child := node.FirstChild(); child != nil; child = child.NextSibling() {
-			for gc := child.FirstChild(); gc != nil; gc = gc.NextSibling() {
+			for gc := child.FirstChild(); gc != nil; {
 				paragraph, ok := gc.(*ast.Paragraph)
+				gc = gc.NextSibling()
 				if ok {
 					textBlock := ast.NewTextBlock()
 					textBlock.SetLines(paragraph.Lines())

vendor/github.com/yuin/goldmark/parser/list_item.go

@@ -17,9 +17,6 @@ func NewListItemParser() BlockParser {
 	return defaultListItemParser
 }
 
-var skipListParser = NewContextKey()
-var skipListParserValue interface{} = true
-
 func (b *listItemParser) Trigger() []byte {
 	return []byte{'-', '+', '*', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
 }
@@ -38,9 +35,12 @@ func (b *listItemParser) Open(parent ast.Node, reader text.Reader, pc Context) (
 	if match[1]-offset > 3 {
 		return nil, NoChildren
 	}
+
+	pc.Set(emptyListItemWithBlankLines, nil)
+
 	itemOffset := calcListOffset(line, match)
 	node := ast.NewListItem(match[3] + itemOffset)
-	if match[4] < 0 || match[5]-match[4] == 1 {
+	if match[4] < 0 || util.IsBlank(line[match[4]:match[5]]) {
 		return node, NoChildren
 	}
 
@@ -54,19 +54,22 @@ func (b *listItemParser) Continue(node ast.Node, reader text.Reader, pc Context)
 	line, _ := reader.PeekLine()
 	if util.IsBlank(line) {
 		reader.Advance(len(line) - 1)
-
 		return Continue | HasChildren
 	}
 
-	indent, _ := util.IndentWidth(line, reader.LineOffset())
 	offset := lastOffset(node.Parent())
-	if indent < offset && indent < 4 {
+	isEmpty := node.ChildCount() == 0
+	indent, _ := util.IndentWidth(line, reader.LineOffset())
+	if (isEmpty || indent < offset) && indent < 4 {
 		_, typ := matchesListItem(line, true)
 		// new list item found
 		if typ != notList {
-			pc.Set(skipListParser, skipListParserValue)
+			pc.Set(skipListParserKey, listItemFlagValue)
+			return Close
+		}
+		if !isEmpty {
+			return Close
 		}
-		return Close
 	}
 	pos, padding := util.IndentPosition(line, reader.LineOffset(), offset)
 	reader.AdvanceAndSetPadding(pos, padding)

vendor/github.com/yuin/goldmark/parser/parser.go

@@ -1115,6 +1115,12 @@ func (p *parser) walkBlock(block ast.Node, cb func(node ast.Node)) {
 	cb(block)
 }
 
+const (
+	lineBreakHard uint8 = 1 << iota
+	lineBreakSoft
+	lineBreakVisible
+)
+
 func (p *parser) parseBlock(block text.BlockReader, parent ast.Node, pc Context) {
 	if parent.IsRaw() {
 		return
@@ -1129,27 +1135,25 @@ func (p *parser) parseBlock(block text.BlockReader, parent ast.Node, pc Context)
 			break
 		}
 		lineLength := len(line)
-		softLinebreak := false
-		hardlineBreak := false
+		var lineBreakFlags uint8 = 0
 		hasNewLine := line[lineLength-1] == '\n'
-		if lineLength >= 2 && line[lineLength-2] == '\\' && hasNewLine { // ends with \\n
+		if ((lineLength >= 3 && line[lineLength-2] == '\\' && line[lineLength-3] != '\\') || (lineLength == 2 && line[lineLength-2] == '\\')) && hasNewLine { // ends with \\n
 			lineLength -= 2
-			hardlineBreak = true
-
-		} else if lineLength >= 3 && line[lineLength-3] == '\\' && line[lineLength-2] == '\r' && hasNewLine { // ends with \\r\n
+			lineBreakFlags |= lineBreakHard | lineBreakVisible
+		} else if ((lineLength >= 4 && line[lineLength-3] == '\\' && line[lineLength-2] == '\r' && line[lineLength-4] != '\\') || (lineLength == 3 && line[lineLength-3] == '\\' && line[lineLength-2] == '\r')) && hasNewLine { // ends with \\r\n
 			lineLength -= 3
-			hardlineBreak = true
+			lineBreakFlags |= lineBreakHard | lineBreakVisible
 		} else if lineLength >= 3 && line[lineLength-3] == ' ' && line[lineLength-2] == ' ' && hasNewLine { // ends with [space][space]\n
 			lineLength -= 3
-			hardlineBreak = true
+			lineBreakFlags |= lineBreakHard
 		} else if lineLength >= 4 && line[lineLength-4] == ' ' && line[lineLength-3] == ' ' && line[lineLength-2] == '\r' && hasNewLine { // ends with [space][space]\r\n
 			lineLength -= 4
-			hardlineBreak = true
+			lineBreakFlags |= lineBreakHard
 		} else if hasNewLine {
 			// If the line ends with a newline character, but it is not a hardlineBreak, then it is a softLinebreak
 			// If the line ends with a hardlineBreak, then it cannot end with a softLinebreak
 			// See https://spec.commonmark.org/0.30/#soft-line-breaks
-			softLinebreak = true
+			lineBreakFlags |= lineBreakSoft
 		}
 
 		l, startPosition := block.Position()
@@ -1213,11 +1217,14 @@ func (p *parser) parseBlock(block text.BlockReader, parent ast.Node, pc Context)
 			continue
 		}
 		diff := startPosition.Between(currentPosition)
-		stop := diff.Stop
-		rest := diff.WithStop(stop)
-		text := ast.NewTextSegment(rest.TrimRightSpace(source))
-		text.SetSoftLineBreak(softLinebreak)
-		text.SetHardLineBreak(hardlineBreak)
+		var text *ast.Text
+		if lineBreakFlags&(lineBreakHard|lineBreakVisible) == lineBreakHard|lineBreakVisible {
+			text = ast.NewTextSegment(diff)
+		} else {
+			text = ast.NewTextSegment(diff.TrimRightSpace(source))
+		}
+		text.SetSoftLineBreak(lineBreakFlags&lineBreakSoft != 0)
+		text.SetHardLineBreak(lineBreakFlags&lineBreakHard != 0)
 		parent.AppendChild(parent, text)
 		block.AdvanceLine()
 	}

vendor/github.com/yuin/goldmark/parser/raw_html.go

@@ -48,8 +48,9 @@ func (s *rawHTMLParser) Parse(parent ast.Node, block text.Reader, pc Context) as
 }
 
 var tagnamePattern = `([A-Za-z][A-Za-z0-9-]*)`
-var attributePattern = `(?:\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\s*=\s*(?:[^\"'=<>` + "`" + `\x00-\x20]+|'[^']*'|"[^"]*"))?)`
-var openTagRegexp = regexp.MustCompile("^<" + tagnamePattern + attributePattern + `*\s*/?>`)
+
+var attributePattern = `(?:[\r\n \t]+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:[\r\n \t]*=[\r\n \t]*(?:[^\"'=<>` + "`" + `\x00-\x20]+|'[^']*'|"[^"]*"))?)`
+var openTagRegexp = regexp.MustCompile("^<" + tagnamePattern + attributePattern + `*[ \t]*/?>`)
 var closeTagRegexp = regexp.MustCompile("^</" + tagnamePattern + `\s*>`)
 var commentRegexp = regexp.MustCompile(`^<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->`)
 var processingInstructionRegexp = regexp.MustCompile(`^(?:<\?).*?(?:\?>)`)

vendor/github.com/yuin/goldmark/renderer/html/html.go

@@ -296,7 +296,7 @@ func (r *Renderer) renderHTMLBlock(w util.BufWriter, source []byte, node ast.Nod
 			l := n.Lines().Len()
 			for i := 0; i < l; i++ {
 				line := n.Lines().At(i)
-				_, _ = w.Write(line.Value(source))
+				r.Writer.SecureWrite(w, line.Value(source))
 			}
 		} else {
 			_, _ = w.WriteString("<!-- raw HTML omitted -->\n")
@@ -305,7 +305,7 @@ func (r *Renderer) renderHTMLBlock(w util.BufWriter, source []byte, node ast.Nod
 		if n.HasClosure() {
 			if r.Unsafe {
 				closure := n.ClosureLine
-				_, _ = w.Write(closure.Value(source))
+				r.Writer.SecureWrite(w, closure.Value(source))
 			} else {
 				_, _ = w.WriteString("<!-- raw HTML omitted -->\n")
 			}
@@ -668,8 +668,13 @@ type Writer interface {
 	// RawWrite writes the given source to writer without resolving references and
 	// unescaping backslash escaped characters.
 	RawWrite(writer util.BufWriter, source []byte)
+
+	// SecureWrite writes the given source to writer with replacing insecure characters.
+	SecureWrite(writer util.BufWriter, source []byte)
 }
 
+var replacementCharacter = []byte("\ufffd")
+
 type defaultWriter struct {
 }
 
@@ -684,6 +689,23 @@ func escapeRune(writer util.BufWriter, r rune) {
 	_, _ = writer.WriteRune(util.ToValidRune(r))
 }
 
+func (d *defaultWriter) SecureWrite(writer util.BufWriter, source []byte) {
+	n := 0
+	l := len(source)
+	for i := 0; i < l; i++ {
+		if source[i] == '\u0000' {
+			_, _ = writer.Write(source[i-n : i])
+			n = 0
+			_, _ = writer.Write(replacementCharacter)
+			continue
+		}
+		n++
+	}
+	if n != 0 {
+		_, _ = writer.Write(source[l-n:])
+	}
+}
+
 func (d *defaultWriter) RawWrite(writer util.BufWriter, source []byte) {
 	n := 0
 	l := len(source)
@@ -719,7 +741,7 @@ func (d *defaultWriter) Write(writer util.BufWriter, source []byte) {
 		}
 		if c == '\x00' {
 			d.RawWrite(writer, source[n:i])
-			d.RawWrite(writer, []byte("\ufffd"))
+			d.RawWrite(writer, replacementCharacter)
 			n = i + 1
 			continue
 		}
@@ -745,8 +767,8 @@ func (d *defaultWriter) Write(writer util.BufWriter, source []byte) {
 					} else if nc >= '0' && nc <= '9' {
 						start := nnext
 						i, ok = util.ReadWhile(source, [2]int{start, limit}, util.IsNumeric)
-						if ok && i < limit && i-start < 8 && source[i] == ';' && i-start < 7 {
-							v, _ := strconv.ParseUint(util.BytesToReadOnlyString(source[start:i]), 0, 32)
+						if ok && i < limit && i-start < 8 && source[i] == ';' {
+							v, _ := strconv.ParseUint(util.BytesToReadOnlyString(source[start:i]), 10, 32)
 							d.RawWrite(writer, source[n:pos])
 							n = i + 1
 							escapeRune(writer, rune(v))

vendor/github.com/yuin/goldmark/util/util.go

@@ -130,6 +130,7 @@ func VisualizeSpaces(bs []byte) []byte {
 	bs = bytes.Replace(bs, []byte("\t"), []byte("[TAB]"), -1)
 	bs = bytes.Replace(bs, []byte("\n"), []byte("[NEWLINE]\n"), -1)
 	bs = bytes.Replace(bs, []byte("\r"), []byte("[CR]"), -1)
+	bs = bytes.Replace(bs, []byte("\v"), []byte("[VTAB]"), -1)
 	bs = bytes.Replace(bs, []byte("\x00"), []byte("[NUL]"), -1)
 	bs = bytes.Replace(bs, []byte("\ufffd"), []byte("[U+FFFD]"), -1)
 	return bs
@@ -151,30 +152,7 @@ func TabWidth(currentPos int) int {
 // width=2 is in the tab character. In this case, IndentPosition returns
 // (pos=1, padding=2)
 func IndentPosition(bs []byte, currentPos, width int) (pos, padding int) {
-	if width == 0 {
-		return 0, 0
-	}
-	w := 0
-	l := len(bs)
-	i := 0
-	hasTab := false
-	for ; i < l; i++ {
-		if bs[i] == '\t' {
-			w += TabWidth(currentPos + w)
-			hasTab = true
-		} else if bs[i] == ' ' {
-			w++
-		} else {
-			break
-		}
-	}
-	if w >= width {
-		if !hasTab {
-			return width, 0
-		}
-		return i, w - width
-	}
-	return -1, -1
+	return IndentPositionPadding(bs, currentPos, 0, width)
 }
 
 // IndentPositionPadding searches an indent position with the given width for the given line.
@@ -188,9 +166,9 @@ func IndentPositionPadding(bs []byte, currentPos, paddingv, width int) (pos, pad
 	i := 0
 	l := len(bs)
 	for ; i < l; i++ {
-		if bs[i] == '\t' {
+		if bs[i] == '\t' && w < width {
 			w += TabWidth(currentPos + w)
-		} else if bs[i] == ' ' {
+		} else if bs[i] == ' ' && w < width {
 			w++
 		} else {
 			break
@@ -203,52 +181,56 @@ func IndentPositionPadding(bs []byte, currentPos, paddingv, width int) (pos, pad
 }
 
 // DedentPosition dedents lines by the given width.
+//
+// Deprecated: This function has bugs. Use util.IndentPositionPadding and util.FirstNonSpacePosition.
 func DedentPosition(bs []byte, currentPos, width int) (pos, padding int) {
-	if width == 0 {
-		return 0, 0
-	}
-	w := 0
-	l := len(bs)
-	i := 0
-	for ; i < l; i++ {
-		if bs[i] == '\t' {
-			w += TabWidth(currentPos + w)
-		} else if bs[i] == ' ' {
-			w++
-		} else {
-			break
-		}
-	}
-	if w >= width {
-		return i, w - width
-	}
-	return i, 0
+       if width == 0 {
+               return 0, 0
+       }
+       w := 0
+       l := len(bs)
+       i := 0
+       for ; i < l; i++ {
+               if bs[i] == '\t' {
+                       w += TabWidth(currentPos + w)
+               } else if bs[i] == ' ' {
+                       w++
+               } else {
+                       break
+               }
+       }
+       if w >= width {
+               return i, w - width
+       }
+       return i, 0
 }
 
 // DedentPositionPadding dedents lines by the given width.
 // This function is mostly same as DedentPosition except this function
 // takes account into additional paddings.
+//
+// Deprecated: This function has bugs. Use util.IndentPositionPadding and util.FirstNonSpacePosition.
 func DedentPositionPadding(bs []byte, currentPos, paddingv, width int) (pos, padding int) {
-	if width == 0 {
-		return 0, paddingv
-	}
+       if width == 0 {
+               return 0, paddingv
+       }
 
-	w := 0
-	i := 0
-	l := len(bs)
-	for ; i < l; i++ {
-		if bs[i] == '\t' {
-			w += TabWidth(currentPos + w)
-		} else if bs[i] == ' ' {
-			w++
-		} else {
-			break
-		}
-	}
-	if w >= width {
-		return i - paddingv, w - width
-	}
-	return i - paddingv, 0
+       w := 0
+       i := 0
+       l := len(bs)
+       for ; i < l; i++ {
+               if bs[i] == '\t' {
+                       w += TabWidth(currentPos + w)
+               } else if bs[i] == ' ' {
+                       w++
+               } else {
+                       break
+               }
+       }
+       if w >= width {
+               return i - paddingv, w - width
+       }
+       return i - paddingv, 0
 }
 
 // IndentWidth calculate an indent width for the given line.
@@ -799,7 +781,7 @@ func FindEmailIndex(b []byte) int {
 
 var spaces = []byte(" \t\n\x0b\x0c\x0d")
 
-var spaceTable = [256]int8{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+var spaceTable = [256]int8{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 
 var punctTable = [256]int8{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}