Added vendor lock on depsHEADmaster

1 files changed, 508 insertions, 0 deletions

diff --git a/vendor/github.com/yuin/goldmark/ast/block.go b/vendor/github.com/yuin/goldmark/ast/block.go
new file mode 100644
index 0000000..02e9d51
--- /dev/null
+++ b/vendor/github.com/yuin/goldmark/ast/block.go
@@ -0,0 +1,508 @@
+package ast
+
+import (
+        "fmt"
+        "strings"
+
+        textm "github.com/yuin/goldmark/text"
+)
+
+// A BaseBlock struct implements the Node interface partialliy.
+type BaseBlock struct {
+        BaseNode
+        blankPreviousLines bool
+        lines              *textm.Segments
+}
+
+// Type implements Node.Type
+func (b *BaseBlock) Type() NodeType {
+        return TypeBlock
+}
+
+// IsRaw implements Node.IsRaw
+func (b *BaseBlock) IsRaw() bool {
+        return false
+}
+
+// HasBlankPreviousLines implements Node.HasBlankPreviousLines.
+func (b *BaseBlock) HasBlankPreviousLines() bool {
+        return b.blankPreviousLines
+}
+
+// SetBlankPreviousLines implements Node.SetBlankPreviousLines.
+func (b *BaseBlock) SetBlankPreviousLines(v bool) {
+        b.blankPreviousLines = v
+}
+
+// Lines implements Node.Lines
+func (b *BaseBlock) Lines() *textm.Segments {
+        if b.lines == nil {
+                b.lines = textm.NewSegments()
+        }
+        return b.lines
+}
+
+// SetLines implements Node.SetLines
+func (b *BaseBlock) SetLines(v *textm.Segments) {
+        b.lines = v
+}
+
+// A Document struct is a root node of Markdown text.
+type Document struct {
+        BaseBlock
+
+        meta map[string]interface{}
+}
+
+// KindDocument is a NodeKind of the Document node.
+var KindDocument = NewNodeKind("Document")
+
+// Dump implements Node.Dump .
+func (n *Document) Dump(source []byte, level int) {
+        DumpHelper(n, source, level, nil, nil)
+}
+
+// Type implements Node.Type .
+func (n *Document) Type() NodeType {
+        return TypeDocument
+}
+
+// Kind implements Node.Kind.
+func (n *Document) Kind() NodeKind {
+        return KindDocument
+}
+
+// OwnerDocument implements Node.OwnerDocument
+func (n *Document) OwnerDocument() *Document {
+        return n
+}
+
+// Meta returns metadata of this document.
+func (n *Document) Meta() map[string]interface{} {
+        if n.meta == nil {
+                n.meta = map[string]interface{}{}
+        }
+        return n.meta
+}
+
+// SetMeta sets given metadata to this document.
+func (n *Document) SetMeta(meta map[string]interface{}) {
+        if n.meta == nil {
+                n.meta = map[string]interface{}{}
+        }
+        for k, v := range meta {
+                n.meta[k] = v
+        }
+}
+
+// AddMeta adds given metadata to this document.
+func (n *Document) AddMeta(key string, value interface{}) {
+        if n.meta == nil {
+                n.meta = map[string]interface{}{}
+        }
+        n.meta[key] = value
+}
+
+// NewDocument returns a new Document node.
+func NewDocument() *Document {
+        return &Document{
+                BaseBlock: BaseBlock{},
+                meta:      nil,
+        }
+}
+
+// A TextBlock struct is a node whose lines
+// should be rendered without any containers.
+type TextBlock struct {
+        BaseBlock
+}
+
+// Dump implements Node.Dump .
+func (n *TextBlock) Dump(source []byte, level int) {
+        DumpHelper(n, source, level, nil, nil)
+}
+
+// KindTextBlock is a NodeKind of the TextBlock node.
+var KindTextBlock = NewNodeKind("TextBlock")
+
+// Kind implements Node.Kind.
+func (n *TextBlock) Kind() NodeKind {
+        return KindTextBlock
+}
+
+// NewTextBlock returns a new TextBlock node.
+func NewTextBlock() *TextBlock {
+        return &TextBlock{
+                BaseBlock: BaseBlock{},
+        }
+}
+
+// A Paragraph struct represents a paragraph of Markdown text.
+type Paragraph struct {
+        BaseBlock
+}
+
+// Dump implements Node.Dump .
+func (n *Paragraph) Dump(source []byte, level int) {
+        DumpHelper(n, source, level, nil, nil)
+}
+
+// KindParagraph is a NodeKind of the Paragraph node.
+var KindParagraph = NewNodeKind("Paragraph")
+
+// Kind implements Node.Kind.
+func (n *Paragraph) Kind() NodeKind {
+        return KindParagraph
+}
+
+// NewParagraph returns a new Paragraph node.
+func NewParagraph() *Paragraph {
+        return &Paragraph{
+                BaseBlock: BaseBlock{},
+        }
+}
+
+// IsParagraph returns true if the given node implements the Paragraph interface,
+// otherwise false.
+func IsParagraph(node Node) bool {
+        _, ok := node.(*Paragraph)
+        return ok
+}
+
+// A Heading struct represents headings like SetextHeading and ATXHeading.
+type Heading struct {
+        BaseBlock
+        // Level returns a level of this heading.
+        // This value is between 1 and 6.
+        Level int
+}
+
+// Dump implements Node.Dump .
+func (n *Heading) Dump(source []byte, level int) {
+        m := map[string]string{
+                "Level": fmt.Sprintf("%d", n.Level),
+        }
+        DumpHelper(n, source, level, m, nil)
+}
+
+// KindHeading is a NodeKind of the Heading node.
+var KindHeading = NewNodeKind("Heading")
+
+// Kind implements Node.Kind.
+func (n *Heading) Kind() NodeKind {
+        return KindHeading
+}
+
+// NewHeading returns a new Heading node.
+func NewHeading(level int) *Heading {
+        return &Heading{
+                BaseBlock: BaseBlock{},
+                Level:     level,
+        }
+}
+
+// A ThematicBreak struct represents a thematic break of Markdown text.
+type ThematicBreak struct {
+        BaseBlock
+}
+
+// Dump implements Node.Dump .
+func (n *ThematicBreak) Dump(source []byte, level int) {
+        DumpHelper(n, source, level, nil, nil)
+}
+
+// KindThematicBreak is a NodeKind of the ThematicBreak node.
+var KindThematicBreak = NewNodeKind("ThematicBreak")
+
+// Kind implements Node.Kind.
+func (n *ThematicBreak) Kind() NodeKind {
+        return KindThematicBreak
+}
+
+// NewThematicBreak returns a new ThematicBreak node.
+func NewThematicBreak() *ThematicBreak {
+        return &ThematicBreak{
+                BaseBlock: BaseBlock{},
+        }
+}
+
+// A CodeBlock interface represents an indented code block of Markdown text.
+type CodeBlock struct {
+        BaseBlock
+}
+
+// IsRaw implements Node.IsRaw.
+func (n *CodeBlock) IsRaw() bool {
+        return true
+}
+
+// Dump implements Node.Dump .
+func (n *CodeBlock) Dump(source []byte, level int) {
+        DumpHelper(n, source, level, nil, nil)
+}
+
+// KindCodeBlock is a NodeKind of the CodeBlock node.
+var KindCodeBlock = NewNodeKind("CodeBlock")
+
+// Kind implements Node.Kind.
+func (n *CodeBlock) Kind() NodeKind {
+        return KindCodeBlock
+}
+
+// NewCodeBlock returns a new CodeBlock node.
+func NewCodeBlock() *CodeBlock {
+        return &CodeBlock{
+                BaseBlock: BaseBlock{},
+        }
+}
+
+// A FencedCodeBlock struct represents a fenced code block of Markdown text.
+type FencedCodeBlock struct {
+        BaseBlock
+        // Info returns a info text of this fenced code block.
+        Info *Text
+
+        language []byte
+}
+
+// Language returns an language in an info string.
+// Language returns nil if this node does not have an info string.
+func (n *FencedCodeBlock) Language(source []byte) []byte {
+        if n.language == nil && n.Info != nil {
+                segment := n.Info.Segment
+                info := segment.Value(source)
+                i := 0
+                for ; i < len(info); i++ {
+                        if info[i] == ' ' {
+                                break
+                        }
+                }
+                n.language = info[:i]
+        }
+        return n.language
+}
+
+// IsRaw implements Node.IsRaw.
+func (n *FencedCodeBlock) IsRaw() bool {
+        return true
+}
+
+// Dump implements Node.Dump .
+func (n *FencedCodeBlock) Dump(source []byte, level int) {
+        m := map[string]string{}
+        if n.Info != nil {
+                m["Info"] = fmt.Sprintf("\"%s\"", n.Info.Text(source))
+        }
+        DumpHelper(n, source, level, m, nil)
+}
+
+// KindFencedCodeBlock is a NodeKind of the FencedCodeBlock node.
+var KindFencedCodeBlock = NewNodeKind("FencedCodeBlock")
+
+// Kind implements Node.Kind.
+func (n *FencedCodeBlock) Kind() NodeKind {
+        return KindFencedCodeBlock
+}
+
+// NewFencedCodeBlock return a new FencedCodeBlock node.
+func NewFencedCodeBlock(info *Text) *FencedCodeBlock {
+        return &FencedCodeBlock{
+                BaseBlock: BaseBlock{},
+                Info:      info,
+        }
+}
+
+// A Blockquote struct represents an blockquote block of Markdown text.
+type Blockquote struct {
+        BaseBlock
+}
+
+// Dump implements Node.Dump .
+func (n *Blockquote) Dump(source []byte, level int) {
+        DumpHelper(n, source, level, nil, nil)
+}
+
+// KindBlockquote is a NodeKind of the Blockquote node.
+var KindBlockquote = NewNodeKind("Blockquote")
+
+// Kind implements Node.Kind.
+func (n *Blockquote) Kind() NodeKind {
+        return KindBlockquote
+}
+
+// NewBlockquote returns a new Blockquote node.
+func NewBlockquote() *Blockquote {
+        return &Blockquote{
+                BaseBlock: BaseBlock{},
+        }
+}
+
+// A List struct represents a list of Markdown text.
+type List struct {
+        BaseBlock
+
+        // Marker is a marker character like '-', '+', ')' and '.'.
+        Marker byte
+
+        // IsTight is a true if this list is a 'tight' list.
+        // See https://spec.commonmark.org/0.30/#loose for details.
+        IsTight bool
+
+        // Start is an initial number of this ordered list.
+        // If this list is not an ordered list, Start is 0.
+        Start int
+}
+
+// IsOrdered returns true if this list is an ordered list, otherwise false.
+func (l *List) IsOrdered() bool {
+        return l.Marker == '.' || l.Marker == ')'
+}
+
+// CanContinue returns true if this list can continue with
+// the given mark and a list type, otherwise false.
+func (l *List) CanContinue(marker byte, isOrdered bool) bool {
+        return marker == l.Marker && isOrdered == l.IsOrdered()
+}
+
+// Dump implements Node.Dump.
+func (l *List) Dump(source []byte, level int) {
+        m := map[string]string{
+                "Ordered": fmt.Sprintf("%v", l.IsOrdered()),
+                "Marker":  fmt.Sprintf("%c", l.Marker),
+                "Tight":   fmt.Sprintf("%v", l.IsTight),
+        }
+        if l.IsOrdered() {
+                m["Start"] = fmt.Sprintf("%d", l.Start)
+        }
+        DumpHelper(l, source, level, m, nil)
+}
+
+// KindList is a NodeKind of the List node.
+var KindList = NewNodeKind("List")
+
+// Kind implements Node.Kind.
+func (l *List) Kind() NodeKind {
+        return KindList
+}
+
+// NewList returns a new List node.
+func NewList(marker byte) *List {
+        return &List{
+                BaseBlock: BaseBlock{},
+                Marker:    marker,
+                IsTight:   true,
+        }
+}
+
+// A ListItem struct represents a list item of Markdown text.
+type ListItem struct {
+        BaseBlock
+
+        // Offset is an offset position of this item.
+        Offset int
+}
+
+// Dump implements Node.Dump.
+func (n *ListItem) Dump(source []byte, level int) {
+        m := map[string]string{
+                "Offset": fmt.Sprintf("%d", n.Offset),
+        }
+        DumpHelper(n, source, level, m, nil)
+}
+
+// KindListItem is a NodeKind of the ListItem node.
+var KindListItem = NewNodeKind("ListItem")
+
+// Kind implements Node.Kind.
+func (n *ListItem) Kind() NodeKind {
+        return KindListItem
+}
+
+// NewListItem returns a new ListItem node.
+func NewListItem(offset int) *ListItem {
+        return &ListItem{
+                BaseBlock: BaseBlock{},
+                Offset:    offset,
+        }
+}
+
+// HTMLBlockType represents kinds of an html blocks.
+// See https://spec.commonmark.org/0.30/#html-blocks
+type HTMLBlockType int
+
+const (
+        // HTMLBlockType1 represents type 1 html blocks
+        HTMLBlockType1 HTMLBlockType = iota + 1
+        // HTMLBlockType2 represents type 2 html blocks
+        HTMLBlockType2
+        // HTMLBlockType3 represents type 3 html blocks
+        HTMLBlockType3
+        // HTMLBlockType4 represents type 4 html blocks
+        HTMLBlockType4
+        // HTMLBlockType5 represents type 5 html blocks
+        HTMLBlockType5
+        // HTMLBlockType6 represents type 6 html blocks
+        HTMLBlockType6
+        // HTMLBlockType7 represents type 7 html blocks
+        HTMLBlockType7
+)
+
+// An HTMLBlock struct represents an html block of Markdown text.
+type HTMLBlock struct {
+        BaseBlock
+
+        // Type is a type of this html block.
+        HTMLBlockType HTMLBlockType
+
+        // ClosureLine is a line that closes this html block.
+        ClosureLine textm.Segment
+}
+
+// IsRaw implements Node.IsRaw.
+func (n *HTMLBlock) IsRaw() bool {
+        return true
+}
+
+// HasClosure returns true if this html block has a closure line,
+// otherwise false.
+func (n *HTMLBlock) HasClosure() bool {
+        return n.ClosureLine.Start >= 0
+}
+
+// Dump implements Node.Dump.
+func (n *HTMLBlock) Dump(source []byte, level int) {
+        indent := strings.Repeat("    ", level)
+        fmt.Printf("%s%s {\n", indent, "HTMLBlock")
+        indent2 := strings.Repeat("    ", level+1)
+        fmt.Printf("%sRawText: \"", indent2)
+        for i := 0; i < n.Lines().Len(); i++ {
+                s := n.Lines().At(i)
+                fmt.Print(string(source[s.Start:s.Stop]))
+        }
+        fmt.Printf("\"\n")
+        for c := n.FirstChild(); c != nil; c = c.NextSibling() {
+                c.Dump(source, level+1)
+        }
+        if n.HasClosure() {
+                cl := n.ClosureLine
+                fmt.Printf("%sClosure: \"%s\"\n", indent2, string(cl.Value(source)))
+        }
+        fmt.Printf("%s}\n", indent)
+}
+
+// KindHTMLBlock is a NodeKind of the HTMLBlock node.
+var KindHTMLBlock = NewNodeKind("HTMLBlock")
+
+// Kind implements Node.Kind.
+func (n *HTMLBlock) Kind() NodeKind {
+        return KindHTMLBlock
+}
+
+// NewHTMLBlock returns a new HTMLBlock node.
+func NewHTMLBlock(typ HTMLBlockType) *HTMLBlock {
+        return &HTMLBlock{
+                BaseBlock:     BaseBlock{},
+                HTMLBlockType: typ,
+                ClosureLine:   textm.NewSegment(-1, -1),
+        }
+}