MM-37186: Update dependencies (#18604)

* MM-37186: Update dependencies

The split client libraries were excluded from being upgraded.

See: https://github.com/splitio/go-split-commons/issues/56

https://mattermost.atlassian.net/browse/MM-37186

```release-note
NONE
```

* Ignore staticcheck deprecation warnings

```release-note
NONE
```

vendor/github.com/yuin/goldmark/README.md

@@ -8,7 +8,7 @@ goldmark
 
 > A Markdown parser written in Go. Easy to extend, standards-compliant, well-structured.
 
-goldmark is compliant with CommonMark 0.29.
+goldmark is compliant with CommonMark 0.30.
 
 Motivation
 ----------------------
@@ -424,6 +424,10 @@ Extensions
   extension for the goldmark Markdown parser.
 - [goldmark-mathjax](https://github.com/litao91/goldmark-mathjax): Mathjax support for the goldmark markdown parser
 - [goldmark-pdf](https://github.com/stephenafamo/goldmark-pdf): A PDF renderer that can be passed to `goldmark.WithRenderer()`.
+- [goldmark-hashtag](https://github.com/abhinav/goldmark-hashtag): Adds support for `#hashtag`-based tagging to goldmark.
+- [goldmark-wikilink](https://github.com/abhinav/goldmark-wikilink): Adds support for `[[wiki]]`-style links to goldmark.
+- [goldmark-toc](https://github.com/abhinav/goldmark-toc): Adds support for generating tables-of-contents for goldmark documents.
+- [goldmark-mermaid](https://github.com/abhinav/goldmark-mermaid): Adds support for renderng [Mermaid](https://mermaid-js.github.io/mermaid/) diagrams in goldmark documents.
 
 goldmark internal(for extension developers)
 ----------------------------------------------

vendor/github.com/yuin/goldmark/ast/block.go

@@ -332,7 +332,7 @@ type List struct {
 	Marker byte
 
 	// IsTight is a true if this list is a 'tight' list.
-	// See https://spec.commonmark.org/0.29/#loose for details.
+	// See https://spec.commonmark.org/0.30/#loose for details.
 	IsTight bool
 
 	// Start is an initial number of this ordered list.
@@ -414,7 +414,7 @@ func NewListItem(offset int) *ListItem {
 }
 
 // HTMLBlockType represents kinds of an html blocks.
-// See https://spec.commonmark.org/0.29/#html-blocks
+// See https://spec.commonmark.org/0.30/#html-blocks
 type HTMLBlockType int
 
 const (

vendor/github.com/yuin/goldmark/ast/inline.go

@@ -111,7 +111,7 @@ func (n *Text) SetRaw(v bool) {
 }
 
 // HardLineBreak returns true if this node ends with a hard line break.
-// See https://spec.commonmark.org/0.29/#hard-line-breaks for details.
+// See https://spec.commonmark.org/0.30/#hard-line-breaks for details.
 func (n *Text) HardLineBreak() bool {
 	return n.flags&textHardLineBreak != 0
 }

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

@@ -91,6 +91,9 @@ func (b *atxHeadingParser) Open(parent ast.Node, reader text.Reader, pc Context)
 	if i == pos || level > 6 {
 		return nil, NoChildren
 	}
+	if i == len(line) { // alone '#' (without a new line character)
+		return ast.NewHeading(level), NoChildren
+	}
 	l := util.TrimLeftSpaceLength(line[i:])
 	if l == 0 {
 		return nil, NoChildren

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

@@ -31,6 +31,10 @@ func (b *codeBlockParser) Open(parent ast.Node, reader text.Reader, pc Context)
 	node := ast.NewCodeBlock()
 	reader.AdvanceAndSetPadding(pos, padding)
 	_, segment = reader.PeekLine()
+	// if code block line starts with a tab, keep a tab as it is.
+	if segment.Padding != 0 {
+		preserveLeadingTabInCodeBlock(&segment, reader, 0)
+	}
 	node.Lines().Append(segment)
 	reader.Advance(segment.Len() - 1)
 	return node, NoChildren

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

@@ -3,7 +3,6 @@ package parser
 import (
 	"github.com/yuin/goldmark/ast"
 	"github.com/yuin/goldmark/text"
-	"github.com/yuin/goldmark/util"
 )
 
 type codeSpanParser struct {
@@ -52,9 +51,7 @@ func (s *codeSpanParser) Parse(parent ast.Node, block text.Reader, pc Context) a
 				}
 			}
 		}
-		if !util.IsBlank(line) {
-			node.AppendChild(node, ast.NewRawTextSegment(segment))
-		}
+		node.AppendChild(node, ast.NewRawTextSegment(segment))
 		block.AdvanceLine()
 	}
 end:
@@ -62,11 +59,11 @@ end:
 		// trim first halfspace and last halfspace
 		segment := node.FirstChild().(*ast.Text).Segment
 		shouldTrimmed := true
-		if !(!segment.IsEmpty() && block.Source()[segment.Start] == ' ') {
+		if !(!segment.IsEmpty() && isSpaceOrNewline(block.Source()[segment.Start])) {
 			shouldTrimmed = false
 		}
 		segment = node.LastChild().(*ast.Text).Segment
-		if !(!segment.IsEmpty() && block.Source()[segment.Stop-1] == ' ') {
+		if !(!segment.IsEmpty() && isSpaceOrNewline(block.Source()[segment.Stop-1])) {
 			shouldTrimmed = false
 		}
 		if shouldTrimmed {
@@ -81,3 +78,7 @@ end:
 	}
 	return node
 }
+
+func isSpaceOrNewline(c byte) bool {
+	return c == ' ' || c == '\n'
+}

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

@@ -30,11 +30,11 @@ type Delimiter struct {
 	Segment text.Segment
 
 	// CanOpen is set true if this delimiter can open a span for a new node.
-	// See https://spec.commonmark.org/0.29/#can-open-emphasis for details.
+	// See https://spec.commonmark.org/0.30/#can-open-emphasis for details.
 	CanOpen bool
 
 	// CanClose is set true if this delimiter can close a span for a new node.
-	// See https://spec.commonmark.org/0.29/#can-open-emphasis for details.
+	// See https://spec.commonmark.org/0.30/#can-open-emphasis for details.
 	CanClose bool
 
 	// Length is a remaining length of this delimiter.
@@ -200,10 +200,11 @@ func ProcessDelimiters(bottom ast.Node, pc Context) {
 			}
 		}
 		if !found {
+			next := closer.NextDelimiter
 			if !maybeOpener && !closer.CanOpen {
 				pc.RemoveDelimiter(closer)
 			}
-			closer = closer.NextDelimiter
+			closer = next
 			continue
 		}
 		opener.ConsumeCharacters(consume)

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

@@ -72,10 +72,6 @@ func (b *fencedCodeBlockParser) Continue(node ast.Node, reader text.Reader, pc C
 	line, segment := reader.PeekLine()
 	fdata := pc.Get(fencedCodeBlockInfoKey).(*fenceData)
 
-	// if code block line starts with a tab, keep a tab as it is.
-	if segment.Padding != 0 {
-		preserveLeadingTabInCodeBlock(&segment, reader, fdata.indent)
-	}
 	w, pos := util.IndentWidth(line, reader.LineOffset())
 	if w < 4 {
 		i := pos
@@ -94,6 +90,10 @@ func (b *fencedCodeBlockParser) Continue(node ast.Node, reader text.Reader, pc C
 	pos, padding := util.DedentPositionPadding(line, reader.LineOffset(), segment.Padding, fdata.indent)
 
 	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 {
+		preserveLeadingTabInCodeBlock(&seg, reader, fdata.indent)
+	}
 	node.Lines().Append(seg)
 	reader.AdvanceAndSetPadding(segment.Stop-segment.Start-pos-1, padding)
 	return Continue | NoChildren

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

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

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

@@ -221,21 +221,33 @@ func (s *linkParser) processLinkLabel(parent ast.Node, link *ast.Link, last *lin
 	}
 }
 
+var linkFindClosureOptions text.FindClosureOptions = text.FindClosureOptions{
+	Nesting: false,
+	Newline: true,
+	Advance: true,
+}
+
 func (s *linkParser) parseReferenceLink(parent ast.Node, last *linkLabelState, block text.Reader, pc Context) (*ast.Link, bool) {
 	_, orgpos := block.Position()
 	block.Advance(1) // skip '['
-	line, segment := block.PeekLine()
-	endIndex := util.FindClosure(line, '[', ']', false, true)
-	if endIndex < 0 {
+	segments, found := block.FindClosure('[', ']', linkFindClosureOptions)
+	if !found {
 		return nil, false
 	}
 
-	block.Advance(endIndex + 1)
-	ssegment := segment.WithStop(segment.Start + endIndex)
-	maybeReference := block.Value(ssegment)
+	var maybeReference []byte
+	if segments.Len() == 1 { // avoid allocate a new byte slice
+		maybeReference = block.Value(segments.At(0))
+	} else {
+		maybeReference = []byte{}
+		for i := 0; i < segments.Len(); i++ {
+			s := segments.At(i)
+			maybeReference = append(maybeReference, block.Value(s)...)
+		}
+	}
 	if util.IsBlank(maybeReference) { // collapsed reference link
-		ssegment = text.NewSegment(last.Segment.Stop, orgpos.Start-1)
-		maybeReference = block.Value(ssegment)
+		s := text.NewSegment(last.Segment.Stop, orgpos.Start-1)
+		maybeReference = block.Value(s)
 	}
 
 	ref, ok := pc.Reference(util.ToLinkReference(maybeReference))
@@ -338,31 +350,20 @@ func parseLinkTitle(block text.Reader) ([]byte, bool) {
 	if opener == '(' {
 		closer = ')'
 	}
-	savedLine, savedPosition := block.Position()
-	var title []byte
-	for i := 0; ; i++ {
-		line, _ := block.PeekLine()
-		if line == nil {
-			block.SetPosition(savedLine, savedPosition)
-			return nil, false
+	block.Advance(1)
+	segments, found := block.FindClosure(opener, closer, linkFindClosureOptions)
+	if found {
+		if segments.Len() == 1 {
+			return block.Value(segments.At(0)), true
 		}
-		offset := 0
-		if i == 0 {
-			offset = 1
+		var title []byte
+		for i := 0; i < segments.Len(); i++ {
+			s := segments.At(i)
+			title = append(title, block.Value(s)...)
 		}
-		pos := util.FindClosure(line[offset:], opener, closer, false, true)
-		if pos < 0 {
-			title = append(title, line[offset:]...)
-			block.AdvanceLine()
-			continue
-		}
-		pos += offset + 1 // 1: closer
-		block.Advance(pos)
-		if i == 0 { // avoid allocating new slice
-			return line[offset : pos-1], true
-		}
-		return append(title, line[offset:pos-1]...), true
+		return title, true
 	}
+	return nil, false
 }
 
 func (s *linkParser) CloseBlock(parent ast.Node, block text.Reader, pc Context) {

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

@@ -52,7 +52,7 @@ func (p *linkReferenceParagraphTransformer) Transform(node *ast.Paragraph, reade
 
 func parseLinkReferenceDefinition(block text.Reader, pc Context) (int, int) {
 	block.SkipSpaces()
-	line, segment := block.PeekLine()
+	line, _ := block.PeekLine()
 	if line == nil {
 		return -1, -1
 	}
@@ -67,39 +67,34 @@ func parseLinkReferenceDefinition(block text.Reader, pc Context) (int, int) {
 	if line[pos] != '[' {
 		return -1, -1
 	}
-	open := segment.Start + pos + 1
-	closes := -1
 	block.Advance(pos + 1)
-	for {
-		line, segment = block.PeekLine()
-		if line == nil {
-			return -1, -1
-		}
-		closure := util.FindClosure(line, '[', ']', false, false)
-		if closure > -1 {
-			closes = segment.Start + closure
-			next := closure + 1
-			if next >= len(line) || line[next] != ':' {
-				return -1, -1
-			}
-			block.Advance(next + 1)
-			break
-		}
-		block.AdvanceLine()
-	}
-	if closes < 0 {
+	segments, found := block.FindClosure('[', ']', linkFindClosureOptions)
+	if !found {
 		return -1, -1
 	}
-	label := block.Value(text.NewSegment(open, closes))
+	var label []byte
+	if segments.Len() == 1 {
+		label = block.Value(segments.At(0))
+	} else {
+		for i := 0; i < segments.Len(); i++ {
+			s := segments.At(i)
+			label = append(label, block.Value(s)...)
+		}
+	}
 	if util.IsBlank(label) {
 		return -1, -1
 	}
 	block.SkipSpaces()
+	if block.Peek() != ':' {
+		return -1, -1
+	}
+	block.Advance(1)
+	block.SkipSpaces()
 	destination, ok := parseLinkDestination(block)
 	if !ok {
 		return -1, -1
 	}
-	line, segment = block.PeekLine()
+	line, _ = block.PeekLine()
 	isNewLine := line == nil || util.IsBlank(line)
 
 	endLine, _ := block.Position()
@@ -117,45 +112,39 @@ func parseLinkReferenceDefinition(block text.Reader, pc Context) (int, int) {
 		return -1, -1
 	}
 	block.Advance(1)
-	open = -1
-	closes = -1
 	closer := opener
 	if opener == '(' {
 		closer = ')'
 	}
-	for {
-		line, segment = block.PeekLine()
-		if line == nil {
+	segments, found = block.FindClosure(opener, closer, linkFindClosureOptions)
+	if !found {
+		if !isNewLine {
 			return -1, -1
 		}
-		if open < 0 {
-			open = segment.Start
-		}
-		closure := util.FindClosure(line, opener, closer, false, true)
-		if closure > -1 {
-			closes = segment.Start + closure
-			block.Advance(closure + 1)
-			break
-		}
-		block.AdvanceLine()
+		ref := NewReference(label, destination, nil)
+		pc.AddReference(ref)
+		return startLine, endLine
 	}
-	if closes < 0 {
-		return -1, -1
+	var title []byte
+	if segments.Len() == 1 {
+		title = block.Value(segments.At(0))
+	} else {
+		for i := 0; i < segments.Len(); i++ {
+			s := segments.At(i)
+			title = append(title, block.Value(s)...)
+		}
 	}
 
-	line, segment = block.PeekLine()
+	line, _ = block.PeekLine()
 	if line != nil && !util.IsBlank(line) {
 		if !isNewLine {
 			return -1, -1
 		}
-		title := block.Value(text.NewSegment(open, closes))
 		ref := NewReference(label, destination, title)
 		pc.AddReference(ref)
 		return startLine, endLine
 	}
 
-	title := block.Value(text.NewSegment(open, closes))
-
 	endLine, _ = block.Position()
 	ref := NewReference(label, destination, title)
 	pc.AddReference(ref)

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

@@ -1,10 +1,11 @@
 package parser
 
 import (
+	"strconv"
+
 	"github.com/yuin/goldmark/ast"
 	"github.com/yuin/goldmark/text"
 	"github.com/yuin/goldmark/util"
-	"strconv"
 )
 
 type listItemType int
@@ -143,7 +144,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[5]-match[4] <= 1 {
 			return nil, NoChildren
 		}
 	}
@@ -165,7 +166,7 @@ func (b *listParser) Continue(node ast.Node, reader text.Reader, pc Context) Sta
 			return Close
 		}
 
-		reader.Advance(len(line)-1)
+		reader.Advance(len(line) - 1)
 		return Continue | HasChildren
 	}
 

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

@@ -53,7 +53,7 @@ func (b *listItemParser) Open(parent ast.Node, reader text.Reader, pc Context) (
 func (b *listItemParser) Continue(node ast.Node, reader text.Reader, pc Context) State {
 	line, _ := reader.PeekLine()
 	if util.IsBlank(line) {
-		reader.Advance(len(line)-1)
+		reader.Advance(len(line) - 1)
 
 		return Continue | HasChildren
 	}

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

@@ -1148,7 +1148,7 @@ func (p *parser) parseBlock(block text.BlockReader, parent ast.Node, pc Context)
 		} 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.29/#soft-line-breaks
+			// See https://spec.commonmark.org/0.30/#soft-line-breaks
 			softLinebreak = true
 		}
 

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

@@ -477,9 +477,7 @@ func (r *Renderer) renderCodeSpan(w util.BufWriter, source []byte, n ast.Node, e
 			value := segment.Value(source)
 			if bytes.HasSuffix(value, []byte("\n")) {
 				r.Writer.RawWrite(w, value[:len(value)-1])
-				if c != n.LastChild() {
-					r.Writer.RawWrite(w, []byte(" "))
-				}
+				r.Writer.RawWrite(w, []byte(" "))
 			} else {
 				r.Writer.RawWrite(w, value)
 			}
@@ -719,6 +717,12 @@ func (d *defaultWriter) Write(writer util.BufWriter, source []byte) {
 				continue
 			}
 		}
+		if c == '\x00' {
+			d.RawWrite(writer, source[n:i])
+			d.RawWrite(writer, []byte("\ufffd"))
+			n = i + 1
+			continue
+		}
 		if c == '&' {
 			pos := i
 			next := i + 1
@@ -730,7 +734,7 @@ func (d *defaultWriter) Write(writer util.BufWriter, source []byte) {
 					if nnext < limit && nc == 'x' || nc == 'X' {
 						start := nnext + 1
 						i, ok = util.ReadWhile(source, [2]int{start, limit}, util.IsHexDecimal)
-						if ok && i < limit && source[i] == ';' {
+						if ok && i < limit && source[i] == ';' && i-start < 7 {
 							v, _ := strconv.ParseUint(util.BytesToReadOnlyString(source[start:i]), 16, 32)
 							d.RawWrite(writer, source[n:pos])
 							n = i + 1
@@ -741,7 +745,7 @@ 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] == ';' {
+						if ok && i < limit && i-start < 8 && source[i] == ';' && i-start < 7 {
 							v, _ := strconv.ParseUint(util.BytesToReadOnlyString(source[start:i]), 0, 32)
 							d.RawWrite(writer, source[n:pos])
 							n = i + 1

vendor/github.com/yuin/goldmark/text/reader.go

@@ -70,6 +70,28 @@ type Reader interface {
 
 	// Match performs regular expression searching to current line.
 	FindSubMatch(reg *regexp.Regexp) [][]byte
+
+	// FindClosure finds corresponding closure.
+	FindClosure(opener, closer byte, options FindClosureOptions) (*Segments, bool)
+}
+
+// FindClosureOptions is options for Reader.FindClosure
+type FindClosureOptions struct {
+	// CodeSpan is a flag for the FindClosure. If this is set to true,
+	// FindClosure ignores closers in codespans.
+	CodeSpan bool
+
+	// Nesting is a flag for the FindClosure. If this is set to true,
+	// FindClosure allows nesting.
+	Nesting bool
+
+	// Newline is a flag for the FindClosure. If this is set to true,
+	// FindClosure searches for a closer over multiple lines.
+	Newline bool
+
+	// Advance is a flag for the FindClosure. If this is set to true,
+	// FindClosure advances pointers when closer is found.
+	Advance bool
 }
 
 type reader struct {
@@ -92,6 +114,10 @@ func NewReader(source []byte) Reader {
 	return r
 }
 
+func (r *reader) FindClosure(opener, closer byte, options FindClosureOptions) (*Segments, bool) {
+	return findClosureReader(r, opener, closer, options)
+}
+
 func (r *reader) ResetPosition() {
 	r.line = -1
 	r.head = 0
@@ -272,6 +298,10 @@ func NewBlockReader(source []byte, segments *Segments) BlockReader {
 	return r
 }
 
+func (r *blockReader) FindClosure(opener, closer byte, options FindClosureOptions) (*Segments, bool) {
+	return findClosureReader(r, opener, closer, options)
+}
+
 func (r *blockReader) ResetPosition() {
 	r.line = -1
 	r.head = 0
@@ -541,3 +571,83 @@ func readRuneReader(r Reader) (rune, int, error) {
 	r.Advance(size)
 	return rn, size, nil
 }
+
+func findClosureReader(r Reader, opener, closer byte, opts FindClosureOptions) (*Segments, bool) {
+	opened := 1
+	codeSpanOpener := 0
+	closed := false
+	orgline, orgpos := r.Position()
+	var ret *Segments
+
+	for {
+		bs, seg := r.PeekLine()
+		if bs == nil {
+			goto end
+		}
+		i := 0
+		for i < len(bs) {
+			c := bs[i]
+			if opts.CodeSpan && codeSpanOpener != 0 && c == '`' {
+				codeSpanCloser := 0
+				for ; i < len(bs); i++ {
+					if bs[i] == '`' {
+						codeSpanCloser++
+					} else {
+						i--
+						break
+					}
+				}
+				if codeSpanCloser == codeSpanOpener {
+					codeSpanOpener = 0
+				}
+			} else if codeSpanOpener == 0 && c == '\\' && i < len(bs)-1 && util.IsPunct(bs[i+1]) {
+				i += 2
+				continue
+			} else if opts.CodeSpan && codeSpanOpener == 0 && c == '`' {
+				for ; i < len(bs); i++ {
+					if bs[i] == '`' {
+						codeSpanOpener++
+					} else {
+						i--
+						break
+					}
+				}
+			} else if (opts.CodeSpan && codeSpanOpener == 0) || !opts.CodeSpan {
+				if c == closer {
+					opened--
+					if opened == 0 {
+						if ret == nil {
+							ret = NewSegments()
+						}
+						ret.Append(seg.WithStop(seg.Start + i))
+						r.Advance(i + 1)
+						closed = true
+						goto end
+					}
+				} else if c == opener {
+					if !opts.Nesting {
+						goto end
+					}
+					opened++
+				}
+			}
+			i++
+		}
+		if !opts.Newline {
+			goto end
+		}
+		r.AdvanceLine()
+		if ret == nil {
+			ret = NewSegments()
+		}
+		ret.Append(seg)
+	}
+end:
+	if !opts.Advance {
+		r.SetPosition(orgline, orgpos)
+	}
+	if closed {
+		return ret, true
+	}
+	return nil, false
+}

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

@@ -130,6 +130,8 @@ 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("\x00"), []byte("[NUL]"), -1)
+	bs = bytes.Replace(bs, []byte("\ufffd"), []byte("[U+FFFD]"), -1)
 	return bs
 }
 
@@ -288,6 +290,10 @@ func FirstNonSpacePosition(bs []byte) int {
 // If codeSpan is set true, it ignores characters in code spans.
 // If allowNesting is set true, closures correspond to nested opener will be
 // ignored.
+//
+// Deprecated: This function can not handle newlines. Many elements
+// can be existed over multiple lines(e.g. link labels).
+// Use text.Reader.FindClosure.
 func FindClosure(bs []byte, opener, closure byte, codeSpan, allowNesting bool) int {
 	i := 0
 	opened := 1
@@ -707,7 +713,7 @@ func URLEscape(v []byte, resolveReference bool) []byte {
 			n = i
 			continue
 		}
-		if int(u8len) >= len(v) {
+		if int(u8len) > len(v) {
 			u8len = int8(len(v) - 1)
 		}
 		if u8len == 0 {
@@ -793,7 +799,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, 1, 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, 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 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}