textview

type Alert uint8

type Block interface {
	// Kind names the block's type ("paragraph", "codeBlock"), or a custom
	// node's name.
	Kind() string
	// contains filtered or unexported methods
}

type Blockquote struct {
	Children []Block
	Alert    Alert
}

type Break struct{}

type Classes map[Part]string

type Code struct{ Code string }

type CodeAction struct{ ID, Label string }

type CodeActionEvent struct {
	ID   string
	Code CodeBlock
}

type CodeBlock struct {
	Language, Meta string
	Code           string
}

type CodeBlockAction struct {
	ID, Label string
	Code      CodeBlock
	// Done reports, tracked, that the action just ran: the copy action's
	// check, for 1.6 seconds.
	Done func() bool
}

type ColumnAlign uint8

type Custom struct {
	// Name is the extension's ("mention", "chart").
	Name string
	// Attributes are a pattern's groups ("1", or by name), a container's
	// label and attributes, a fence's "meta".
	Attributes map[string]string
	// Text is a pattern's match, or a fence's code.
	Text string
	// Data is the app's own.
	Data any
	// Children are a container's blocks; Content inline content.
	Children []Block
	Content  []Inline
}

type Details struct {
	Open     bool
	Summary  []Inline
	Children []Block
}

type Document struct {
	Blocks []Block
	// Footnotes are the notes the blocks refer to, in the order of their
	// first reference.
	Footnotes []Footnote
}

type Emphasis struct{ Content []Inline }

type Extension struct {
	Name string
	// Pattern is inline syntax matched in text, outside code and links
	// (`@(\w+)` for mentions). Each match is an inline node: its Text the
	// match, its groups the attributes "1", "2", ... and by name.
	Pattern *regexp.Regexp
	// Language makes fenced code of this language (“`chart) a block
	// node: its Text the code, the rest of the info string the attribute
	// "meta".
	Language string
	// Container makes containers of this name (:::note … :::, as
	// remark-directive writes them) block nodes of the Markdown inside:
	// the label after the name (:::note[Heads up]) is the attribute
	// "label", {key=value .class #id} the other attributes. A container
	// inside another closes with fewer colons than the outer one.
	Container string
	// Tag makes HTML elements of this name, in any case (<Callout>), custom
	// nodes: their attributes the node's, their text its Text, and what
	// they hold its blocks when they stand alone, else its inline content.
	// An element may close itself as JSX writes it (<Callout />).
	Tag string
}

type Footnote struct {
	Label    string
	Index    int
	Children []Block
}

type FootnoteReference struct {
	Label string
	Index int
}

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

type Highlight struct {
	Start, End int
	Class      string
	Style      core.Style
}

type Highlighter func(code CodeBlock) []Highlight

type Image struct {
	Src, Alt, Title string
	Width, Height   core.Length
}

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

type Keyboard struct{ Text string }

type Link struct {
	URL, Title string
	Content    []Inline
}

type LinkPressEvent struct{ URL string }

type List struct {
	Ordered bool
	Start   int
	Loose   bool
	Items   []ListItem
}

type ListItem struct {
	Task, Done bool
	Children   []Block
}

type Mark struct {
	Content []Inline
	Color   core.Color
}

type Math struct {
	TeX string
	// Display is set on a formula that is a block of its own, as
	// RenderMath gets it.
	Display bool
}

type Options struct {
	// NoMath reads dollars and \( \[ as text and math fences as code.
	NoMath bool
	// NoHTML shows HTML in the Markdown as text.
	NoHTML bool
	// NoAlerts reads > [!NOTE] and its kin as plain quotations.
	NoAlerts bool
	// Frontmatter reads YAML front matter (--- … --- first) as a Custom
	// block "frontmatter" whose Text is the YAML, rather than a rule and
	// text.
	Frontmatter bool
	// MDX reads JSX elements as Custom nodes named by their tag, with
	// their attributes and content, and {expressions} as Custom nodes
	// "expression" whose Text is the expression; HTML is then read as
	// elements too.
	MDX bool
	// Streaming repairs the syntax the last block leaves open before
	// parsing (RepairStreaming), for a document still arriving.
	Streaming bool
}

type Paragraph struct{ Content []Inline }

type Part uint8

type Plugin struct {
	Extension Extension
	Render    func(cx *core.Scope, node Custom) core.Node
}

type Rule struct{}

type Small struct{ Content []Inline }

type Strikethrough struct{ Content []Inline }

type Strong struct{ Content []Inline }

type Styles map[Part]core.Style

type Subscript struct{ Content []Inline }

type Superscript struct{ Content []Inline }

type Table struct {
	Align []ColumnAlign
	Head  []TableCell
	Rows  [][]TableCell
}

type TableCell struct {
	Content []Inline
	ColSpan int
}

type Text struct{ Text string }

type TextView struct {
	// Markdown is the document, read by Parse with Extensions.
	Markdown     string
	MarkdownFunc func() string
	// HTML is the document as HTML, read by ParseHTML with Extensions,
	// when no Markdown is given.
	HTML     string
	HTMLFunc func() string
	// Document is the document as blocks the app made, when neither
	// Markdown nor HTML is given.
	Document     Document
	DocumentFunc func() Document
	// Extensions go after those Provide gives the views below it.
	Extensions []Extension
	// Options say what the Markdown reads, Streaming among them.
	Options Options
	// StreamingCaret, as a document streams in, follows its end: inline
	// after the last text of the last block (into quotes, lists and
	// custom nodes' content, after a code block's code, in a table's last
	// cell), else on a line of its own after it.
	StreamingCaret core.Node

	// Styles style the parts; StyleOf's result for a part goes under
	// them, again when what it reads changes, and Classes under both.
	Classes Classes
	Styles  Styles
	StyleOf func(Part) core.Style
	// Selectable makes the view a selectable view: one selection runs
	// across its blocks, and on into the texts around inside an outer
	// selectable view.
	Selectable bool
	// Highlighter colors code blocks; without one their code is plain.
	Highlighter Highlighter

	// OnLinkPress receives a pressed link's URL: a heading's anchor is
	// "#<anchor>", a footnote reference "#footnote-<label>". Nothing opens
	// a URL unless OpenLinks; the app decides.
	OnLinkPress func(LinkPressEvent)
	// OpenLinks also opens a pressed link to another site or app (a URL
	// with a scheme: https:, mailto:) outside the app with Scope.OpenURL,
	// after OnLinkPress; anchors are only reported.
	OpenLinks bool
	// OnImagePress receives an image pressed that is in no link, for the
	// app to show it larger.
	OnImagePress func(image Image)
	// RenderCustom shows a custom node: a block, or an inline node as an
	// attachment in its text unless CustomSpan shows it. Without either, a
	// node shows its content.
	RenderCustom func(cx *core.Scope, node Custom) core.Node
	// CustomSpan shows a custom node in text as a span.
	CustomSpan func(node Custom) core.Span
	// RenderMath shows a formula: a block of its own when its Display is
	// set ($$…$$ on lines of its own), else as an attachment in its text.
	// Without it a formula shows its TeX in PartMath or PartMathBlock.
	RenderMath func(cx *core.Scope, math Math) core.Node
	// RenderCodeBlock shows a code block in place of the default: the code
	// in a horizontal scroll view.
	RenderCodeBlock func(cx *core.Scope, code CodeBlock) core.Node
	// CodeBlockActions are buttons over each code block's top right
	// corner, in PartCodeBlockHeader, each a PartCodeBlockAction showing
	// RenderCodeBlockAction (its label, else its ID, as text without it).
	// CopyAction copies the code, and reports itself done for 1.6
	// seconds; a press on any reports OnCodeBlockAction.
	CodeBlockActions      []CodeAction
	RenderCodeBlockAction func(cx *core.Scope, action CodeBlockAction) core.Node
	OnCodeBlockAction     func(CodeActionEvent)
	// RenderTableActions shows content above each table, in
	// PartTableActions.
	RenderTableActions func(cx *core.Scope, table Table) core.Node
	// NoTableScroll lets a table shrink past its columns' floors rather
	// than scroll; NoTableScrollbar and NoCodeBlockScrollbar hide the
	// scroll bars of tables and code blocks.
	NoTableScroll, NoTableScrollbar, NoCodeBlockScrollbar bool
	// RenderImage shows an image in place of the default: alone in a
	// paragraph, a block; in a line of text, an attachment.
	RenderImage func(cx *core.Scope, image Image) core.Node
	TestID      string
	// OnLayout and Tooltip are its view's, as a core.View's.
	OnLayout func(core.Bounds)
	Tooltip  core.Node
}

type Underline struct{ Content []Inline }