KindAutoLink is a NodeKind of the AutoLink node.
var KindAutoLink = NewNodeKind("AutoLink")
KindBlockquote is a NodeKind of the Blockquote node.
var KindBlockquote = NewNodeKind("Blockquote")
KindCodeBlock is a NodeKind of the CodeBlock node.
var KindCodeBlock = NewNodeKind("CodeBlock")
KindCodeSpan is a NodeKind of the CodeSpan node.
var KindCodeSpan = NewNodeKind("CodeSpan")
KindDocument is a NodeKind of the Document node.
var KindDocument = NewNodeKind("Document")
KindEmphasis is a NodeKind of the Emphasis node.
var KindEmphasis = NewNodeKind("Emphasis")
KindFencedCodeBlock is a NodeKind of the FencedCodeBlock node.
var KindFencedCodeBlock = NewNodeKind("FencedCodeBlock")
KindHTMLBlock is a NodeKind of the HTMLBlock node.
var KindHTMLBlock = NewNodeKind("HTMLBlock")
KindHeading is a NodeKind of the Heading node.
var KindHeading = NewNodeKind("Heading")
KindImage is a NodeKind of the Image node.
var KindImage = NewNodeKind("Image")
KindLink is a NodeKind of the Link node.
var KindLink = NewNodeKind("Link")
KindList is a NodeKind of the List node.
var KindList = NewNodeKind("List")
KindListItem is a NodeKind of the ListItem node.
var KindListItem = NewNodeKind("ListItem")
KindParagraph is a NodeKind of the Paragraph node.
var KindParagraph = NewNodeKind("Paragraph")
KindRawHTML is a NodeKind of the RawHTML node.
var KindRawHTML = NewNodeKind("RawHTML")
KindString is a NodeKind of the String node.
var KindString = NewNodeKind("String")
KindText is a NodeKind of the Text node.
var KindText = NewNodeKind("Text")
KindTextBlock is a NodeKind of the TextBlock node.
var KindTextBlock = NewNodeKind("TextBlock")
KindThematicBreak is a NodeKind of the ThematicBreak node.
var KindThematicBreak = NewNodeKind("ThematicBreak")
func DumpHelper(v Node, source []byte, level int, kv map[string]string, cb func(int))
DumpHelper is a helper function to implement Node.Dump. kv is pairs of an attribute name and an attribute value. cb is a function called after wrote a name and attributes.
func IsParagraph(node Node) bool
IsParagraph returns true if the given node implements the Paragraph interface, otherwise false.
func MergeOrAppendTextSegment(parent Node, s textm.Segment)
MergeOrAppendTextSegment merges a given s into the last child of the parent if it can be merged, otherwise creates a new Text node and appends it to after current last child.
func MergeOrReplaceTextSegment(parent Node, n Node, s textm.Segment)
MergeOrReplaceTextSegment merges a given s into a previous sibling of the node n if a previous sibling of the node n is *Text, otherwise replaces Node n with s.
func Walk(n Node, walker Walker) error
Walk walks a AST tree by the depth first search algorithm.
An Attribute is an attribute of the Node.
type Attribute struct {
Name []byte
Value interface{}
}
An AutoLink struct represents an autolink of the Markdown text.
type AutoLink struct {
BaseInline
// Type is a type of this autolink.
AutoLinkType AutoLinkType
// Protocol specified a protocol of the link.
Protocol []byte
// contains filtered or unexported fields
}
func NewAutoLink(typ AutoLinkType, value *Text) *AutoLink
NewAutoLink returns a new AutoLink node.
func (n *AutoLink) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *AutoLink) Inline()
Inline implements Inline.Inline.
func (n *AutoLink) Kind() NodeKind
Kind implements Node.Kind.
func (n *AutoLink) Label(source []byte) []byte
Label returns a label of this node.
func (n *AutoLink) URL(source []byte) []byte
URL returns an url of this node.
AutoLinkType defines kind of auto links.
type AutoLinkType int
const (
// AutoLinkEmail indicates that an autolink is an email address.
AutoLinkEmail AutoLinkType = iota + 1
// AutoLinkURL indicates that an autolink is a generic URL.
AutoLinkURL
)
A BaseBlock struct implements the Node interface partialliy.
type BaseBlock struct {
BaseNode
// contains filtered or unexported fields
}
func (b *BaseBlock) HasBlankPreviousLines() bool
HasBlankPreviousLines implements Node.HasBlankPreviousLines.
func (b *BaseBlock) IsRaw() bool
IsRaw implements Node.IsRaw.
func (b *BaseBlock) Lines() *textm.Segments
Lines implements Node.Lines.
func (b *BaseBlock) SetBlankPreviousLines(v bool)
SetBlankPreviousLines implements Node.SetBlankPreviousLines.
func (b *BaseBlock) SetLines(v *textm.Segments)
SetLines implements Node.SetLines.
func (b *BaseBlock) Type() NodeType
Type implements Node.Type.
A BaseInline struct implements the Node interface partialliy.
type BaseInline struct {
BaseNode
}
func (b *BaseInline) HasBlankPreviousLines() bool
HasBlankPreviousLines implements Node.HasBlankPreviousLines.
func (b *BaseInline) IsRaw() bool
IsRaw implements Node.IsRaw.
func (b *BaseInline) Lines() *textm.Segments
Lines implements Node.Lines.
func (b *BaseInline) SetBlankPreviousLines(v bool)
SetBlankPreviousLines implements Node.SetBlankPreviousLines.
func (b *BaseInline) SetLines(v *textm.Segments)
SetLines implements Node.SetLines.
func (b *BaseInline) Type() NodeType
Type implements Node.Type.
A BaseNode struct implements the Node interface partialliy.
type BaseNode struct {
// contains filtered or unexported fields
}
func (n *BaseNode) AppendChild(self, v Node)
AppendChild implements Node.AppendChild .
func (n *BaseNode) Attribute(name []byte) (interface{}, bool)
Attribute implements Node.Attribute.
func (n *BaseNode) AttributeString(s string) (interface{}, bool)
AttributeString implements Node.AttributeString.
func (n *BaseNode) Attributes() []Attribute
Attributes implements Node.Attributes.
func (n *BaseNode) ChildCount() int
ChildCount implements Node.ChildCount .
func (n *BaseNode) FirstChild() Node
FirstChild implements Node.FirstChild .
func (n *BaseNode) HasChildren() bool
HasChildren implements Node.HasChildren .
func (n *BaseNode) InsertAfter(self, v1, insertee Node)
InsertAfter implements Node.InsertAfter .
func (n *BaseNode) InsertBefore(self, v1, insertee Node)
InsertBefore implements Node.InsertBefore .
func (n *BaseNode) LastChild() Node
LastChild implements Node.LastChild .
func (n *BaseNode) NextSibling() Node
NextSibling implements Node.NextSibling .
func (n *BaseNode) OwnerDocument() *Document
OwnerDocument implements Node.OwnerDocument.
func (n *BaseNode) Parent() Node
Parent implements Node.Parent .
func (n *BaseNode) PreviousSibling() Node
PreviousSibling implements Node.PreviousSibling .
func (n *BaseNode) RemoveAttributes()
RemoveAttributes implements Node.RemoveAttributes.
func (n *BaseNode) RemoveChild(self, v Node)
RemoveChild implements Node.RemoveChild .
func (n *BaseNode) RemoveChildren(self Node)
RemoveChildren implements Node.RemoveChildren .
func (n *BaseNode) ReplaceChild(self, v1, insertee Node)
ReplaceChild implements Node.ReplaceChild .
func (n *BaseNode) SetAttribute(name []byte, value interface{})
SetAttribute implements Node.SetAttribute.
func (n *BaseNode) SetAttributeString(name string, value interface{})
SetAttributeString implements Node.SetAttributeString.
func (n *BaseNode) SetNextSibling(v Node)
SetNextSibling implements Node.SetNextSibling .
func (n *BaseNode) SetParent(v Node)
SetParent implements Node.SetParent .
func (n *BaseNode) SetPreviousSibling(v Node)
SetPreviousSibling implements Node.SetPreviousSibling .
func (n *BaseNode) SortChildren(comparator func(n1, n2 Node) int)
SortChildren implements Node.SortChildren.
func (n *BaseNode) Text(source []byte) []byte
Text implements Node.Text .
A Blockquote struct represents an blockquote block of Markdown text.
type Blockquote struct {
BaseBlock
}
func NewBlockquote() *Blockquote
NewBlockquote returns a new Blockquote node.
func (n *Blockquote) Dump(source []byte, level int)
Dump implements Node.Dump .
func (n *Blockquote) Kind() NodeKind
Kind implements Node.Kind.
A CodeBlock interface represents an indented code block of Markdown text.
type CodeBlock struct {
BaseBlock
}
func NewCodeBlock() *CodeBlock
NewCodeBlock returns a new CodeBlock node.
func (n *CodeBlock) Dump(source []byte, level int)
Dump implements Node.Dump .
func (n *CodeBlock) IsRaw() bool
IsRaw implements Node.IsRaw.
func (n *CodeBlock) Kind() NodeKind
Kind implements Node.Kind.
A CodeSpan struct represents a code span of Markdown text.
type CodeSpan struct {
BaseInline
}
func NewCodeSpan() *CodeSpan
NewCodeSpan returns a new CodeSpan node.
func (n *CodeSpan) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *CodeSpan) Inline()
Inline implements Inline.Inline .
func (n *CodeSpan) IsBlank(source []byte) bool
IsBlank returns true if this node consists of spaces, otherwise false.
func (n *CodeSpan) Kind() NodeKind
Kind implements Node.Kind.
A Document struct is a root node of Markdown text.
type Document struct {
BaseBlock
// contains filtered or unexported fields
}
func NewDocument() *Document
NewDocument returns a new Document node.
func (n *Document) AddMeta(key string, value interface{})
AddMeta adds given metadata to this document.
func (n *Document) Dump(source []byte, level int)
Dump implements Node.Dump .
func (n *Document) Kind() NodeKind
Kind implements Node.Kind.
func (n *Document) Meta() map[string]interface{}
Meta returns metadata of this document.
func (n *Document) OwnerDocument() *Document
OwnerDocument implements Node.OwnerDocument.
func (n *Document) SetMeta(meta map[string]interface{})
SetMeta sets given metadata to this document.
func (n *Document) Type() NodeType
Type implements Node.Type .
An Emphasis struct represents an emphasis of Markdown text.
type Emphasis struct {
BaseInline
// Level is a level of the emphasis.
Level int
}
func NewEmphasis(level int) *Emphasis
NewEmphasis returns a new Emphasis node with the given level.
func (n *Emphasis) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *Emphasis) Kind() NodeKind
Kind implements Node.Kind.
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
// contains filtered or unexported fields
}
func NewFencedCodeBlock(info *Text) *FencedCodeBlock
NewFencedCodeBlock return a new FencedCodeBlock node.
func (n *FencedCodeBlock) Dump(source []byte, level int)
Dump implements Node.Dump .
func (n *FencedCodeBlock) IsRaw() bool
IsRaw implements Node.IsRaw.
func (n *FencedCodeBlock) Kind() NodeKind
Kind implements Node.Kind.
func (n *FencedCodeBlock) Language(source []byte) []byte
Language returns an language in an info string. Language returns nil if this node does not have an info string.
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
}
func NewHTMLBlock(typ HTMLBlockType) *HTMLBlock
NewHTMLBlock returns a new HTMLBlock node.
func (n *HTMLBlock) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *HTMLBlock) HasClosure() bool
HasClosure returns true if this html block has a closure line, otherwise false.
func (n *HTMLBlock) IsRaw() bool
IsRaw implements Node.IsRaw.
func (n *HTMLBlock) Kind() NodeKind
Kind implements Node.Kind.
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
)
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
}
func NewHeading(level int) *Heading
NewHeading returns a new Heading node.
func (n *Heading) Dump(source []byte, level int)
Dump implements Node.Dump .
func (n *Heading) Kind() NodeKind
Kind implements Node.Kind.
An Image struct represents an image of the Markdown text.
type Image struct {
// contains filtered or unexported fields
}
func NewImage(link *Link) *Image
NewImage returns a new Image node.
func (n *Image) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *Image) Inline()
Inline implements Inline.Inline.
func (n *Image) Kind() NodeKind
Kind implements Node.Kind.
A Link struct represents a link of the Markdown text.
type Link struct {
// contains filtered or unexported fields
}
func NewLink() *Link
NewLink returns a new Link node.
func (n *Link) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *Link) Inline()
Inline implements Inline.Inline.
func (n *Link) Kind() NodeKind
Kind implements Node.Kind.
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
}
func NewList(marker byte) *List
NewList returns a new List node.
func (l *List) CanContinue(marker byte, isOrdered bool) bool
CanContinue returns true if this list can continue with the given mark and a list type, otherwise false.
func (l *List) Dump(source []byte, level int)
Dump implements Node.Dump.
func (l *List) IsOrdered() bool
IsOrdered returns true if this list is an ordered list, otherwise false.
func (l *List) Kind() NodeKind
Kind implements Node.Kind.
A ListItem struct represents a list item of Markdown text.
type ListItem struct {
BaseBlock
// Offset is an offset position of this item.
Offset int
}
func NewListItem(offset int) *ListItem
NewListItem returns a new ListItem node.
func (n *ListItem) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *ListItem) Kind() NodeKind
Kind implements Node.Kind.
A Node interface defines basic AST node functionalities.
type Node interface {
// Type returns a type of this node.
Type() NodeType
// Kind returns a kind of this node.
Kind() NodeKind
// NextSibling returns a next sibling node of this node.
NextSibling() Node
// PreviousSibling returns a previous sibling node of this node.
PreviousSibling() Node
// Parent returns a parent node of this node.
Parent() Node
// SetParent sets a parent node to this node.
SetParent(Node)
// SetPreviousSibling sets a previous sibling node to this node.
SetPreviousSibling(Node)
// SetNextSibling sets a next sibling node to this node.
SetNextSibling(Node)
// HasChildren returns true if this node has any children, otherwise false.
HasChildren() bool
// ChildCount returns a total number of children.
ChildCount() int
// FirstChild returns a first child of this node.
FirstChild() Node
// LastChild returns a last child of this node.
LastChild() Node
// AppendChild append a node child to the tail of the children.
AppendChild(self, child Node)
// RemoveChild removes a node child from this node.
// If a node child is not children of this node, RemoveChild nothing to do.
RemoveChild(self, child Node)
// RemoveChildren removes all children from this node.
RemoveChildren(self Node)
// SortChildren sorts childrens by comparator.
SortChildren(comparator func(n1, n2 Node) int)
// ReplaceChild replace a node v1 with a node insertee.
// If v1 is not children of this node, ReplaceChild append a insetee to the
// tail of the children.
ReplaceChild(self, v1, insertee Node)
// InsertBefore inserts a node insertee before a node v1.
// If v1 is not children of this node, InsertBefore append a insetee to the
// tail of the children.
InsertBefore(self, v1, insertee Node)
// InsertAfterinserts a node insertee after a node v1.
// If v1 is not children of this node, InsertBefore append a insetee to the
// tail of the children.
InsertAfter(self, v1, insertee Node)
// OwnerDocument returns this node's owner document.
// If this node is not a child of the Document node, OwnerDocument
// returns nil.
OwnerDocument() *Document
// Dump dumps an AST tree structure to stdout.
// This function completely aimed for debugging.
// level is a indent level. Implementer should indent informations with
// 2 * level spaces.
Dump(source []byte, level int)
// Text returns text values of this node.
Text(source []byte) []byte
// HasBlankPreviousLines returns true if the row before this node is blank,
// otherwise false.
// This method is valid only for block nodes.
HasBlankPreviousLines() bool
// SetBlankPreviousLines sets whether the row before this node is blank.
// This method is valid only for block nodes.
SetBlankPreviousLines(v bool)
// Lines returns text segments that hold positions in a source.
// This method is valid only for block nodes.
Lines() *textm.Segments
// SetLines sets text segments that hold positions in a source.
// This method is valid only for block nodes.
SetLines(*textm.Segments)
// IsRaw returns true if contents should be rendered as 'raw' contents.
IsRaw() bool
// SetAttribute sets the given value to the attributes.
SetAttribute(name []byte, value interface{})
// SetAttributeString sets the given value to the attributes.
SetAttributeString(name string, value interface{})
// Attribute returns a (attribute value, true) if an attribute
// associated with the given name is found, otherwise
// (nil, false)
Attribute(name []byte) (interface{}, bool)
// AttributeString returns a (attribute value, true) if an attribute
// associated with the given name is found, otherwise
// (nil, false)
AttributeString(name string) (interface{}, bool)
// Attributes returns a list of attributes.
// This may be a nil if there are no attributes.
Attributes() []Attribute
// RemoveAttributes removes all attributes from this node.
RemoveAttributes()
}
NodeKind indicates more specific type than NodeType.
type NodeKind int
func NewNodeKind(name string) NodeKind
NewNodeKind returns a new Kind value.
func (k NodeKind) String() string
A NodeType indicates what type a node belongs to.
type NodeType int
const (
// TypeBlock indicates that a node is kind of block nodes.
TypeBlock NodeType = iota + 1
// TypeInline indicates that a node is kind of inline nodes.
TypeInline
// TypeDocument indicates that a node is kind of document nodes.
TypeDocument
)
A Paragraph struct represents a paragraph of Markdown text.
type Paragraph struct {
BaseBlock
}
func NewParagraph() *Paragraph
NewParagraph returns a new Paragraph node.
func (n *Paragraph) Dump(source []byte, level int)
Dump implements Node.Dump .
func (n *Paragraph) Kind() NodeKind
Kind implements Node.Kind.
A RawHTML struct represents an inline raw HTML of the Markdown text.
type RawHTML struct {
BaseInline
Segments *textm.Segments
}
func NewRawHTML() *RawHTML
NewRawHTML returns a new RawHTML node.
func (n *RawHTML) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *RawHTML) Inline()
Inline implements Inline.Inline.
func (n *RawHTML) Kind() NodeKind
Kind implements Node.Kind.
A String struct is a textual content that has a concrete value.
type String struct {
BaseInline
Value []byte
// contains filtered or unexported fields
}
func NewString(v []byte) *String
NewString returns a new String node.
func (n *String) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *String) Inline()
Inline implements Inline.Inline.
func (n *String) IsCode() bool
IsCode returns true if this text should be rendered without any modifications.
func (n *String) IsRaw() bool
IsRaw returns true if this text should be rendered without unescaping back slash escapes and resolving references.
func (n *String) Kind() NodeKind
Kind implements Node.Kind.
func (n *String) SetCode(v bool)
SetCode sets whether this text should be rendered without any modifications.
func (n *String) SetRaw(v bool)
SetRaw sets whether this text should be rendered as raw contents.
func (n *String) Text(source []byte) []byte
Text implements Node.Text.
A Text struct represents a textual content of the Markdown text.
type Text struct {
BaseInline
// Segment is a position in a source text.
Segment textm.Segment
// contains filtered or unexported fields
}
func NewRawTextSegment(v textm.Segment) *Text
NewRawTextSegment returns a new Text node with the given source position. The new node should be rendered as raw contents.
func NewText() *Text
NewText returns a new Text node.
func NewTextSegment(v textm.Segment) *Text
NewTextSegment returns a new Text node with the given source position.
func (n *Text) Dump(source []byte, level int)
Dump implements Node.Dump.
func (n *Text) HardLineBreak() bool
HardLineBreak returns true if this node ends with a hard line break. See https://spec.commonmark.org/0.30/#hard-line-breaks for details.
func (n *Text) Inline()
Inline implements Inline.Inline.
func (n *Text) IsRaw() bool
IsRaw returns true if this text should be rendered without unescaping back slash escapes and resolving references.
func (n *Text) Kind() NodeKind
Kind implements Node.Kind.
func (n *Text) Merge(node Node, source []byte) bool
Merge merges a Node n into this node. Merge returns true if the given node has been merged, otherwise false.
func (n *Text) SetHardLineBreak(v bool)
SetHardLineBreak sets whether this node ends with a hard line break.
func (n *Text) SetRaw(v bool)
SetRaw sets whether this text should be rendered as raw contents.
func (n *Text) SetSoftLineBreak(v bool)
SetSoftLineBreak sets whether this node ends with a new line.
func (n *Text) SoftLineBreak() bool
SoftLineBreak returns true if this node ends with a new line, otherwise false.
func (n *Text) Text(source []byte) []byte
Text implements Node.Text.
A TextBlock struct is a node whose lines should be rendered without any containers.
type TextBlock struct {
BaseBlock
}
func NewTextBlock() *TextBlock
NewTextBlock returns a new TextBlock node.
func (n *TextBlock) Dump(source []byte, level int)
Dump implements Node.Dump .
func (n *TextBlock) Kind() NodeKind
Kind implements Node.Kind.
A ThematicBreak struct represents a thematic break of Markdown text.
type ThematicBreak struct {
BaseBlock
}
func NewThematicBreak() *ThematicBreak
NewThematicBreak returns a new ThematicBreak node.
func (n *ThematicBreak) Dump(source []byte, level int)
Dump implements Node.Dump .
func (n *ThematicBreak) Kind() NodeKind
Kind implements Node.Kind.
WalkStatus represents a current status of the Walk function.
type WalkStatus int
const (
// WalkStop indicates no more walking needed.
WalkStop WalkStatus = iota + 1
// WalkSkipChildren indicates that Walk wont walk on children of current
// node.
WalkSkipChildren
// WalkContinue indicates that Walk can continue to walk.
WalkContinue
)
Walker is a function that will be called when Walk find a new node. entering is set true before walks children, false after walked children. If Walker returns error, Walk function immediately stop walking.
type Walker func(n Node, entering bool) (WalkStatus, error)