model

type Anchor ¶

type Anchor string

type Asset ¶

type Asset struct {
	ID         AssetID
	MediaType  string
	OriginPart string
	Bytes      []byte
}

type AssetID ¶

type AssetID int

type Block ¶

type Block interface {
	// contains filtered or unexported methods
}

type Cell ¶

type Cell struct {
	Blocks  []Block
	ColSpan int
	RowSpan int
}

Cell spans below 1 count as 1.

func (c Cell) IsEmpty() bool

type Checkbox ¶

type Checkbox bool

type CodeBlock ¶

type CodeBlock struct {
	Lang string
	Text string
}

type Document ¶

type Document struct {
	Blocks []Block
	Notes  []Note
	Assets []Asset
}

type GridBuilder ¶

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

GridBuilder is the sole constructor of table grids. The zero value is ready to use.

func (b *GridBuilder) Covered() bool

func (b *GridBuilder) Finish(kind TableKind) Table

func (b *GridBuilder) KeepCoveredTail()

func (b *GridBuilder) NextRow()

func (b *GridBuilder) Place(cell Cell) error

type Heading ¶

type Heading struct {
	Level   int
	Anchor  string
	Content []Inline
}

Heading levels are the source's outline depth, 1-based and unclamped. Anchor is the id the document targets this heading by, "" when none.

type Image ¶

type Image struct {
	Alt    string
	Source ImageSource
}

type ImageSource ¶

type ImageSource struct {
	Kind  SourceKind
	URL   string
	Asset AssetID
}

type Inline ¶

type Inline interface {
	// contains filtered or unexported methods
}

type LimitError ¶

type LimitError struct {
	Limit  string
	Detail string
}

func (e *LimitError) Error() string

type LineBreak ¶

type LineBreak struct{}

type Link ¶

type Link struct {
	Content []Inline
	Target  Target
}

type List ¶

type List struct {
	Marker MarkerKind
	Start  int
	Items  []ListItem
}

List is fully resolved: frontends split runs wherever the list instance or marker kind changes, and Start is the source's own ordinal for the first item.

type ListItem ¶

type ListItem struct {
	Blocks []Block
	Label  string
}

ListItem is one list entry. Label overrides the level marker with literal source number text when marker kind and position cannot reproduce it (composite labels such as "1-a)"); "" means none.

type MarkerKind ¶

type MarkerKind int

const (
	Bullet MarkerKind = iota
	Decimal
	LowerAlpha
	UpperAlpha
	LowerRoman
	UpperRoman
)

func (k MarkerKind) Label(n int) string

func (k MarkerKind) Ordered() bool

func (k MarkerKind) Ordinal(n int) string

type Math ¶

type Math string

Math is an inline formula as LaTeX without delimiters.

type MathBlock ¶

type MathBlock string

MathBlock is a displayed formula as LaTeX without delimiters.

type Note ¶

type Note struct {
	ID     string
	Kind   NoteKind
	Blocks []Block
}

type NoteKind ¶

type NoteKind int

const (
	Footnote NoteKind = iota
	Endnote
)

type NoteRef ¶

type NoteRef string

type Paragraph ¶

type Paragraph []Inline

type Quote ¶

type Quote []Block

type Rule ¶

type Rule struct{}

type Slot ¶

type Slot struct {
	Covered   bool
	OriginRow int
	OriginCol int
	Cell      Cell
}

Slot is one grid position: an origin holding the cell, or a position covered by the span of the origin at (OriginRow, OriginCol).

type SourceKind ¶

type SourceKind int

const (
	SourceUnavailable SourceKind = iota
	SourceExternal
	SourceAsset
)

type Style ¶

type Style struct {
	Bold   bool
	Italic bool
	Strike bool
	Code   bool
}

type Table ¶

type Table struct {
	HeaderRows int
	Kind       TableKind
	// contains filtered or unexported fields
}

Table is a canonical grid: every logical position appears exactly once, content and spans live only on origins, and each position a span claims holds a covered slot pointing back at its origin. Grids are built only by GridBuilder or TableFromRows. Rows may be ragged.

func TableFromRows(rows [][]Cell, headerRows int, kind TableKind) Table

func (t Table) Grid() [][]Slot

func (t Table) IsSingleCell() bool

type TableKind ¶

type TableKind int

const (
	DataTable TableKind = iota
	LayoutTable
)

type Target ¶

type Target struct {
	Kind TargetKind
	Ref  string
}

Target is an absolute URL, a scheme-less relative reference kept as written, or a document-scoped anchor id (a heading anchor or Anchor node).

type TargetKind ¶

type TargetKind int

const (
	TargetExternal TargetKind = iota
	TargetRelative
	TargetAnchor
)

type Text ¶

type Text struct {
	Text  string
	Style Style
}