ast

package
v1.1.33-0...-16f4919 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 16, 2021 License: MIT Imports: 6 Imported by: 0

Documentation

Overview

Package ast defines AST nodes that represent markdown elements.

Index

Constants

View Source 
const (
	// LinkNoReference indicates that a link is not a reference.
	LinkNoReference = iota

	// LinkFullReference indicates a full reference.
	LinkFullReference

	// LinkCollapsedReference indicates a collapsed reference.
	LinkCollapsedReference

	// LinkShortcutReference indicates a shortcut reference.
	LinkShortcutReference
)

Variables

View Source 
var KindAutoLink = NewNodeKind("AutoLink")

KindAutoLink is a NodeKind of the AutoLink node.

View Source 
var KindBlockquote = NewNodeKind("Blockquote")

KindBlockquote is a NodeKind of the Blockquote node.

View Source 
var KindCodeBlock = NewNodeKind("CodeBlock")

KindCodeBlock is a NodeKind of the CodeBlock node.

View Source 
var KindCodeSpan = NewNodeKind("CodeSpan")

KindCodeSpan is a NodeKind of the CodeSpan node.

View Source 
var KindDocument = NewNodeKind("Document")

KindDocument is a NodeKind of the Document node.

View Source 
var KindEmphasis = NewNodeKind("Emphasis")

KindEmphasis is a NodeKind of the Emphasis node.

View Source 
var KindFencedCodeBlock = NewNodeKind("FencedCodeBlock")

KindFencedCodeBlock is a NodeKind of the FencedCodeBlock node.

View Source 
var KindHTMLBlock = NewNodeKind("HTMLBlock")

KindHTMLBlock is a NodeKind of the HTMLBlock node.

View Source 
var KindHeading = NewNodeKind("Heading")

KindHeading is a NodeKind of the Heading node.

View Source 
var KindImage = NewNodeKind("Image")

KindImage is a NodeKind of the Image node.

View Source 
var KindLink = NewNodeKind("Link")

KindLink is a NodeKind of the Link node.

View Source 
var KindLinkReferenceDefinition = NewNodeKind("LinkReferenceDefinition")

KindLinkReferenceDefinition is a NodeKind of the LinkReferenceDefinition node.

View Source 
var KindList = NewNodeKind("List")

KindList is a NodeKind of the List node.

View Source 
var KindListItem = NewNodeKind("ListItem")

KindListItem is a NodeKind of the ListItem node.

View Source 
var KindParagraph = NewNodeKind("Paragraph")

KindParagraph is a NodeKind of the Paragraph node.

View Source 
var KindRawHTML = NewNodeKind("RawHTML")

KindRawHTML is a NodeKind of the RawHTML node.

View Source 
var KindString = NewNodeKind("String")

KindString is a NodeKind of the String node.

View Source 
var KindText = NewNodeKind("Text")

KindText is a NodeKind of the Text node.

View Source 
var KindTextBlock = NewNodeKind("TextBlock")

KindTextBlock is a NodeKind of the TextBlock node.

View Source 
var KindThematicBreak = NewNodeKind("ThematicBreak")

KindThematicBreak is a NodeKind of the ThematicBreak node.

View Source 
var KindWhitespace = NewNodeKind("Whitespace")

KindWhitespace is a NodeKind of the Whitespace node.

Functions

func DumpHelper 

func DumpHelper(w io.Writer, 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 

func IsParagraph(node Node) bool

IsParagraph returns true if the given node implements the Paragraph interface, otherwise false.

func MergeOrAppendTextSegment 

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 

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 

func Walk(n Node, walker Walker) error

Walk walks a AST tree by the depth first search algorithm.

Types

type Attribute 

type Attribute struct {
	Name  []byte
	Value interface{}
}

An Attribute is an attribute of the Node 

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
}

An AutoLink struct represents an autolink of the Markdown text. 

func NewAutoLink(typ AutoLinkType, value *Text) *AutoLink

NewAutoLink returns a new AutoLink node.

func (*AutoLink) Dump 

func (n *AutoLink) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump

func (*AutoLink) Inline 

func (n *AutoLink) Inline()

Inline implements Inline.Inline.

func (*AutoLink) Kind 

func (n *AutoLink) Kind() NodeKind

Kind implements Node.Kind.

func (*AutoLink) Label 

func (n *AutoLink) Label(source []byte) []byte

Label returns a label of this node.

func (*AutoLink) URL 

func (n *AutoLink) URL(source []byte) []byte

URL returns an url of this node.

type AutoLinkType 

type AutoLinkType int

AutoLinkType defines kind of auto links. 

const (
	// AutoLinkEmail indicates that an autolink is an email address.
	AutoLinkEmail AutoLinkType = iota + 1
	// AutoLinkURL indicates that an autolink is a generic URL.
	AutoLinkURL
)

type BaseBlock 

type BaseBlock struct {
	BaseNode
	// contains filtered or unexported fields
}

A BaseBlock struct implements the Node interface.

func (*BaseBlock) HasBlankPreviousLines 

func (b *BaseBlock) HasBlankPreviousLines() bool

HasBlankPreviousLines implements Node.HasBlankPreviousLines.

func (*BaseBlock) IsRaw 

func (b *BaseBlock) IsRaw() bool

IsRaw implements Node.IsRaw

func (*BaseBlock) LeadingWhitespace 

func (b *BaseBlock) LeadingWhitespace() textm.Segment

LeadingWhitespace returns the leading whitespace for this block, if any.

func (*BaseBlock) Lines 

func (b *BaseBlock) Lines() *textm.Segments

Lines implements Node.Lines

func (*BaseBlock) SetBlankPreviousLines 

func (b *BaseBlock) SetBlankPreviousLines(v bool)

SetBlankPreviousLines implements Node.SetBlankPreviousLines.

func (*BaseBlock) SetLeadingWhitespace 

func (b *BaseBlock) SetLeadingWhitespace(v textm.Segment)

SetLeadingWhitespace sets the leading whitespace for this block.

func (*BaseBlock) SetLines 

func (b *BaseBlock) SetLines(v *textm.Segments)

SetLines implements Node.SetLines

func (*BaseBlock) Type 

func (b *BaseBlock) Type() NodeType

Type implements Node.Type

type BaseInline 

type BaseInline struct {
	BaseNode
}

A BaseInline struct implements the Node interface.

func (*BaseInline) HasBlankPreviousLines 

func (b *BaseInline) HasBlankPreviousLines() bool

HasBlankPreviousLines implements Node.HasBlankPreviousLines.

func (*BaseInline) IsRaw 

func (b *BaseInline) IsRaw() bool

IsRaw implements Node.IsRaw

func (*BaseInline) LeadingWhitespace 

func (b *BaseInline) LeadingWhitespace() textm.Segment

LeadingWhitespace implements Node.LeadingWhitespace.

func (*BaseInline) Lines 

func (b *BaseInline) Lines() *textm.Segments

Lines implements Node.Lines

func (*BaseInline) SetBlankPreviousLines 

func (b *BaseInline) SetBlankPreviousLines(v bool)

SetBlankPreviousLines implements Node.SetBlankPreviousLines.

func (*BaseInline) SetLeadingWhitespace 

func (b *BaseInline) SetLeadingWhitespace(v textm.Segment)

SetLeadingWhitespace implements Node.SetLeadingWhitespace.

func (*BaseInline) SetLines 

func (b *BaseInline) SetLines(v *textm.Segments)

SetLines implements Node.SetLines

func (*BaseInline) Type 

func (b *BaseInline) Type() NodeType

Type implements Node.Type

type BaseNode 

type BaseNode struct {
	// contains filtered or unexported fields
}

A BaseNode struct implements the Node interface.

func (*BaseNode) AppendChild 

func (n *BaseNode) AppendChild(self, v Node)

AppendChild implements Node.AppendChild .

func (*BaseNode) Attribute 

func (n *BaseNode) Attribute(name []byte) (interface{}, bool)

Attribute implements Node.Attribute.

func (*BaseNode) AttributeString 

func (n *BaseNode) AttributeString(s string) (interface{}, bool)

AttributeString implements Node.AttributeString.

func (*BaseNode) Attributes 

func (n *BaseNode) Attributes() []Attribute

Attributes implements Node.Attributes

func (*BaseNode) ChildCount 

func (n *BaseNode) ChildCount() int

ChildCount implements Node.ChildCount .

func (*BaseNode) FirstChild 

func (n *BaseNode) FirstChild() Node

FirstChild implements Node.FirstChild .

func (*BaseNode) HasChildren 

func (n *BaseNode) HasChildren() bool

HasChildren implements Node.HasChildren .

func (*BaseNode) InsertAfter 

func (n *BaseNode) InsertAfter(self, v1, insertee Node)

InsertAfter implements Node.InsertAfter .

func (*BaseNode) InsertBefore 

func (n *BaseNode) InsertBefore(self, v1, insertee Node)

InsertBefore implements Node.InsertBefore .

func (*BaseNode) LastChild 

func (n *BaseNode) LastChild() Node

LastChild implements Node.LastChild .

func (*BaseNode) NextSibling 

func (n *BaseNode) NextSibling() Node

NextSibling implements Node.NextSibling .

func (*BaseNode) Parent 

func (n *BaseNode) Parent() Node

Parent implements Node.Parent .

func (*BaseNode) PreviousSibling 

func (n *BaseNode) PreviousSibling() Node

PreviousSibling implements Node.PreviousSibling .

func (*BaseNode) RemoveAttributes 

func (n *BaseNode) RemoveAttributes()

RemoveAttributes implements Node.RemoveAttributes

func (*BaseNode) RemoveChild 

func (n *BaseNode) RemoveChild(self, v Node)

RemoveChild implements Node.RemoveChild .

func (*BaseNode) RemoveChildren 

func (n *BaseNode) RemoveChildren(self Node)

RemoveChildren implements Node.RemoveChildren .

func (*BaseNode) ReplaceChild 

func (n *BaseNode) ReplaceChild(self, v1, insertee Node)

ReplaceChild implements Node.ReplaceChild .

func (*BaseNode) SetAttribute 

func (n *BaseNode) SetAttribute(name []byte, value interface{})

SetAttribute implements Node.SetAttribute.

func (*BaseNode) SetAttributeString 

func (n *BaseNode) SetAttributeString(name string, value interface{})

SetAttributeString implements Node.SetAttributeString

func (*BaseNode) SetNextSibling 

func (n *BaseNode) SetNextSibling(v Node)

SetNextSibling implements Node.SetNextSibling .

func (*BaseNode) SetParent 

func (n *BaseNode) SetParent(v Node)

SetParent implements Node.SetParent .

func (*BaseNode) SetPreviousSibling 

func (n *BaseNode) SetPreviousSibling(v Node)

SetPreviousSibling implements Node.SetPreviousSibling .

func (*BaseNode) SortChildren 

func (n *BaseNode) SortChildren(comparator func(n1, n2 Node) int)

SortChildren implements Node.SortChildren

func (*BaseNode) Text 

func (n *BaseNode) Text(source []byte) []byte

Text implements Node.Text .

type Blockquote 

type Blockquote struct {
	BaseBlock
}

A Blockquote struct represents an blockquote block of Markdown text.

func NewBlockquote 

func NewBlockquote() *Blockquote

NewBlockquote returns a new Blockquote node.

func (*Blockquote) Dump 

func (n *Blockquote) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump .

func (*Blockquote) Kind 

func (n *Blockquote) Kind() NodeKind

Kind implements Node.Kind.

type CodeBlock 

type CodeBlock struct {
	BaseBlock
}

A CodeBlock interface represents an indented code block of Markdown text.

func NewCodeBlock 

func NewCodeBlock() *CodeBlock

NewCodeBlock returns a new CodeBlock node.

func (*CodeBlock) Dump 

func (n *CodeBlock) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump .

func (*CodeBlock) IsRaw 

func (n *CodeBlock) IsRaw() bool

IsRaw implements Node.IsRaw.

func (*CodeBlock) Kind 

func (n *CodeBlock) Kind() NodeKind

Kind implements Node.Kind.

func (*CodeBlock) SetLeadingWhitespace 

func (n *CodeBlock) SetLeadingWhitespace(v textm.Segment)

SetLeadingWhitespace implements Node.SetLeadingWhitespace.

type CodeSpan 

type CodeSpan struct {
	BaseInline

	// Backticks is the number of backticks used to open and close this code span.
	Backticks int
}

A CodeSpan struct represents a code span of Markdown text.

func NewCodeSpan 

func NewCodeSpan(backticks int) *CodeSpan

NewCodeSpan returns a new CodeSpan node.

func (*CodeSpan) Dump 

func (n *CodeSpan) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump

func (*CodeSpan) Inline 

func (n *CodeSpan) Inline()

Inline implements Inline.Inline .

func (*CodeSpan) IsBlank 

func (n *CodeSpan) IsBlank(source []byte) bool

IsBlank returns true if this node consists of spaces, otherwise false.

func (*CodeSpan) Kind 

func (n *CodeSpan) Kind() NodeKind

Kind implements Node.Kind.

type Document 

type Document struct {
	BaseBlock
}

A Document struct is a root node of Markdown text.

func NewDocument 

func NewDocument() *Document

NewDocument returns a new Document node.

func (*Document) Dump 

func (n *Document) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump .

func (*Document) Kind 

func (n *Document) Kind() NodeKind

Kind implements Node.Kind.

func (*Document) Type 

func (n *Document) Type() NodeType

Type implements Node.Type .

type Emphasis 

type Emphasis struct {
	BaseInline

	// Marker is the character used to indicate emphasis.
	Marker byte

	// Level is a level of the emphasis.
	Level int
}

An Emphasis struct represents an emphasis of Markdown text.

func NewEmphasis 

func NewEmphasis(marker byte, level int) *Emphasis

NewEmphasis returns a new Emphasis node with the given level.

func (*Emphasis) Dump 

func (n *Emphasis) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*Emphasis) Kind 

func (n *Emphasis) Kind() NodeKind

Kind implements Node.Kind.

type FencedCodeBlock 

type FencedCodeBlock struct {
	BaseBlock

	// Fence returns the fence used for this code block.
	Fence []byte

	// Info returns a info text of this fenced code block.
	Info *Text
	// contains filtered or unexported fields
}

A FencedCodeBlock struct represents a fenced code block of Markdown text.

func NewFencedCodeBlock 

func NewFencedCodeBlock(fence []byte, info *Text) *FencedCodeBlock

NewFencedCodeBlock return a new FencedCodeBlock node.

func (*FencedCodeBlock) Dump 

func (n *FencedCodeBlock) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump .

func (*FencedCodeBlock) IsRaw 

func (n *FencedCodeBlock) IsRaw() bool

IsRaw implements Node.IsRaw.

func (*FencedCodeBlock) Kind 

func (n *FencedCodeBlock) Kind() NodeKind

Kind implements Node.Kind.

func (*FencedCodeBlock) Language 

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.

type HTMLBlock 

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
}

An HTMLBlock struct represents an html block of Markdown text.

func NewHTMLBlock 

func NewHTMLBlock(typ HTMLBlockType) *HTMLBlock

NewHTMLBlock returns a new HTMLBlock node.

func (*HTMLBlock) Dump 

func (n *HTMLBlock) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*HTMLBlock) HasClosure 

func (n *HTMLBlock) HasClosure() bool

HasClosure returns true if this html block has a closure line, otherwise false.

func (*HTMLBlock) IsRaw 

func (n *HTMLBlock) IsRaw() bool

IsRaw implements Node.IsRaw.

func (*HTMLBlock) Kind 

func (n *HTMLBlock) Kind() NodeKind

Kind implements Node.Kind.

func (*HTMLBlock) SetLeadingWhitespace 

func (n *HTMLBlock) SetLeadingWhitespace(v textm.Segment)

SetLeadingWhitespace implements Node.SetLeadingWhitespace.

type HTMLBlockType 

type HTMLBlockType int

HTMLBlockType represents kinds of an html blocks. See https://spec.commonmark.org/0.29/#html-blocks 

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
)

type Heading 

type Heading struct {
	BaseBlock

	// IsSetext is true if the heading is a setext heading.
	IsSetext bool

	// Level returns a level of this heading.
	// This value is between 1 and 6.
	Level int
}

A Heading struct represents headings like SetextHeading and ATXHeading.

func NewHeading 

func NewHeading(isSetext bool, level int) *Heading

NewHeading returns a new Heading node.

func (*Heading) Dump 

func (n *Heading) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump .

func (*Heading) Kind 

func (n *Heading) Kind() NodeKind

Kind implements Node.Kind.

type Image 

type Image struct {
	// contains filtered or unexported fields
}

An Image struct represents an image of the Markdown text.

func NewImage 

func NewImage(link *Link) *Image

NewImage returns a new Image node.

func (*Image) Dump 

func (n *Image) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*Image) Inline 

func (n *Image) Inline()

Inline implements Inline.Inline.

func (*Image) Kind 

func (n *Image) Kind() NodeKind

Kind implements Node.Kind. 

type Link struct {
	// contains filtered or unexported fields
}

A Link struct represents a link of the Markdown text. 

func NewLink() *Link

NewLink returns a new Link node.

func (*Link) Dump 

func (n *Link) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*Link) Inline 

func (n *Link) Inline()

Inline implements Inline.Inline.

func (*Link) Kind 

func (n *Link) Kind() NodeKind

Kind implements Node.Kind.

type LinkReferenceDefinition 

type LinkReferenceDefinition struct {
	BaseBlock

	// Label is the label of this link reference definition.
	Label []byte

	// Destination is the destination(URL) of this link reference definition.
	Destination []byte

	// Title is the title of this link reference definition.
	Title []byte
}

A LinkReferenceDefinition struct represents a link reference definition in the Markdown text.

func NewLinkReferenceDefinition 

func NewLinkReferenceDefinition() *LinkReferenceDefinition

NewLinkReferenceDefinition returns a new LinkReferenceDefinition node.

func (*LinkReferenceDefinition) Dump 

func (n *LinkReferenceDefinition) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*LinkReferenceDefinition) IsRaw 

func (n *LinkReferenceDefinition) IsRaw() bool

IsRaw implements Node.IsRaw.

func (*LinkReferenceDefinition) Kind 

func (n *LinkReferenceDefinition) Kind() NodeKind

Kind implements Node.Kind.

type LinkReferenceType 

type LinkReferenceType int

LinkReferenceType defines the kinds of references used by links.

type List 

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.29/#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
}

A List struct represents a list of Markdown text.

func NewList 

func NewList(marker byte) *List

NewList returns a new List node.

func (*List) CanContinue 

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 (*List) Dump 

func (l *List) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*List) IsOrdered 

func (l *List) IsOrdered() bool

IsOrdered returns true if this list is an ordered list, otherwise false.

func (*List) Kind 

func (l *List) Kind() NodeKind

Kind implements Node.Kind.

type ListItem 

type ListItem struct {
	BaseBlock

	// Offset is an offset position of this item.
	Offset int
}

A ListItem struct represents a list item of Markdown text.

func NewListItem 

func NewListItem(offset int) *ListItem

NewListItem returns a new ListItem node.

func (*ListItem) Dump 

func (n *ListItem) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*ListItem) Kind 

func (n *ListItem) Kind() NodeKind

Kind implements Node.Kind.

type Node 

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)

	// 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(w io.Writer, 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)

	// LeadingWhitespace returns the leading whitespace for this node, if any.
	// This method is valid only for block nodes.
	LeadingWhitespace() textm.Segment

	// SetLeadingWhitespace sets the leading whitespace for this node.
	// This method is valid only for block nodes.
	SetLeadingWhitespace(v textm.Segment)

	// 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()
}

A Node interface defines basic AST node functionalities.

type NodeKind 

type NodeKind int

NodeKind indicates more specific type than NodeType.

func NewNodeKind 

func NewNodeKind(name string) NodeKind

NewNodeKind returns a new Kind value.

func (NodeKind) String 

func (k NodeKind) String() string

type NodeType 

type NodeType int

A NodeType indicates what type a node belongs to. 

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
)

type Paragraph 

type Paragraph struct {
	BaseBlock
}

A Paragraph struct represents a paragraph of Markdown text.

func NewParagraph 

func NewParagraph() *Paragraph

NewParagraph returns a new Paragraph node.

func (*Paragraph) Dump 

func (n *Paragraph) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump .

func (*Paragraph) Kind 

func (n *Paragraph) Kind() NodeKind

Kind implements Node.Kind.

type RawHTML 

type RawHTML struct {
	BaseInline
	Segments *textm.Segments
}

A RawHTML struct represents an inline raw HTML of the Markdown text.

func NewRawHTML 

func NewRawHTML() *RawHTML

NewRawHTML returns a new RawHTML node.

func (*RawHTML) Dump 

func (n *RawHTML) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*RawHTML) Inline 

func (n *RawHTML) Inline()

Inline implements Inline.Inline.

func (*RawHTML) Kind 

func (n *RawHTML) Kind() NodeKind

Kind implements Node.Kind.

type String 

type String struct {
	BaseInline

	Value []byte
	// contains filtered or unexported fields
}

A String struct is a textual content that has a concrete value

func NewString 

func NewString(v []byte) *String

NewString returns a new String node.

func (*String) Dump 

func (n *String) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*String) Inline 

func (n *String) Inline()

Inline implements Inline.Inline.

func (*String) IsCode 

func (n *String) IsCode() bool

IsCode returns true if this text should be rendered without any modifications.

func (*String) IsRaw 

func (n *String) IsRaw() bool

IsRaw returns true if this text should be rendered without unescaping back slash escapes and resolving references.

func (*String) Kind 

func (n *String) Kind() NodeKind

Kind implements Node.Kind.

func (*String) SetCode 

func (n *String) SetCode(v bool)

SetCode sets whether this text should be rendered without any modifications.

func (*String) SetRaw 

func (n *String) SetRaw(v bool)

SetRaw sets whether this text should be rendered as raw contents.

func (*String) Text 

func (n *String) Text(source []byte) []byte

Text implements Node.Text.

type Text 

type Text struct {
	BaseInline
	// Segment is a position in a source text.
	Segment textm.Segment
	// contains filtered or unexported fields
}

A Text struct represents a textual content of the Markdown text.

func NewRawTextSegment 

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 

func NewText() *Text

NewText returns a new Text node.

func NewTextSegment 

func NewTextSegment(v textm.Segment) *Text

NewTextSegment returns a new Text node with the given source position.

func (*Text) Dump 

func (n *Text) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*Text) HardLineBreak 

func (n *Text) HardLineBreak() 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.

func (*Text) Inline 

func (n *Text) Inline()

Inline implements Inline.Inline.

func (*Text) IsRaw 

func (n *Text) IsRaw() bool

IsRaw returns true if this text should be rendered without unescaping back slash escapes and resolving references.

func (*Text) Kind 

func (n *Text) Kind() NodeKind

Kind implements Node.Kind.

func (*Text) Merge 

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 (*Text) SetHardLineBreak 

func (n *Text) SetHardLineBreak(v bool)

SetHardLineBreak sets whether this node ends with a hard line break.

func (*Text) SetRaw 

func (n *Text) SetRaw(v bool)

SetRaw sets whether this text should be rendered as raw contents.

func (*Text) SetSoftLineBreak 

func (n *Text) SetSoftLineBreak(v bool)

SetSoftLineBreak sets whether this node ends with a new line.

func (*Text) SoftLineBreak 

func (n *Text) SoftLineBreak() bool

SoftLineBreak returns true if this node ends with a new line, otherwise false.

func (*Text) Text 

func (n *Text) Text(source []byte) []byte

Text implements Node.Text.

type TextBlock 

type TextBlock struct {
	BaseBlock
}

A TextBlock struct is a node whose lines should be rendered without any containers.

func NewTextBlock 

func NewTextBlock() *TextBlock

NewTextBlock returns a new TextBlock node.

func (*TextBlock) Dump 

func (n *TextBlock) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump .

func (*TextBlock) Kind 

func (n *TextBlock) Kind() NodeKind

Kind implements Node.Kind.

type ThematicBreak 

type ThematicBreak struct {
	BaseBlock
}

A ThematicBreak struct represents a thematic break of Markdown text.

func NewThematicBreak 

func NewThematicBreak() *ThematicBreak

NewThematicBreak returns a new ThematicBreak node.

func (*ThematicBreak) Dump 

func (n *ThematicBreak) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump .

func (*ThematicBreak) Kind 

func (n *ThematicBreak) Kind() NodeKind

Kind implements Node.Kind.

type WalkStatus 

type WalkStatus int

WalkStatus represents a current status of the Walk function. 

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
)

type Walker 

type Walker func(n Node, entering bool) (WalkStatus, error)

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 Whitespace 

type Whitespace struct {
	BaseInline

	// Segment is the position of the whitespace in the source text.
	Segment textm.Segment
}

Whitespace represents leading whitespace for lines inside a Markdown paragraph.

func NewWhitespace 

func NewWhitespace(v textm.Segment) *Whitespace

NewWhitespace returns a new Whitespace node.

func (*Whitespace) Dump 

func (n *Whitespace) Dump(w io.Writer, source []byte, level int)

Dump implements Node.Dump.

func (*Whitespace) Inline 

func (n *Whitespace) Inline()

Inline implements Inline.Inline.

func (*Whitespace) Kind 

func (n *Whitespace) Kind() NodeKind

Kind implements Node.Kind.

func (*Whitespace) Text 

func (n *Whitespace) Text(source []byte) []byte

Text implements Node.Text.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.