render

type BlockCompiler func(BlockNode) (func(io.Writer, Context) error, error)

type BlockNode struct {
	parser.Token

	Body    []Node
	Clauses []*BlockNode
	// contains filtered or unexported fields
}

type Config struct {
	parser.Config

	Cache           map[string][]byte
	StrictVariables bool
	TemplateStore   TemplateStore
	// contains filtered or unexported fields
}

type Context interface {
	// Bindings returns the current lexical environment.
	Bindings() map[string]any
	// Get retrieves the value of a variable from the current lexical environment.
	Get(name string) any
	// Errorf creates a SourceError, that includes the source location.
	// Use this to distinguish errors in the template from implementation errors
	// in the template engine.
	Errorf(format string, a ...any) Error
	// Evaluate evaluates a compiled expression within the current lexical context.
	Evaluate(expressions.Expression) (any, error)
	// EvaluateString compiles and evaluates a string expression such as “x”, “x < 10", or “a.b | split | first | default: 10”, within the current lexical context.
	EvaluateString(string) (any, error)
	// ExpandTagArg renders the current tag argument string as a Liquid template.
	// It enables the implementation of tags such as Jekyll's "{% include {{ page.my_variable }} %}" andjekyll-avatar's  "{% avatar {{page.author}} %}".
	ExpandTagArg() (string, error)
	// InnerString is the rendered content of the current block.
	// It's used in the implementation of the Liquid "capture" tag and the Jekyll "highlght" tag.
	InnerString() (string, error)
	// RenderBlock is used in the implementation of the built-in control flow tags.
	// It's not guaranteed stable.
	RenderBlock(io.Writer, *BlockNode) error
	// RenderChildren is used in the implementation of the built-in control flow tags.
	// It's not guaranteed stable.
	RenderChildren(io.Writer) Error
	// RenderFile parses and renders a template. It's used in the implementation of the {% include %} tag.
	// RenderFile does not cache the compiled template.
	RenderFile(string, map[string]any) (string, error)
	// Set updates the value of a variable in the current lexical environment.
	// It's used in the implementation of the {% assign %} and {% capture %} tags.
	Set(name string, value any)
	// SourceFile retrieves the value set by template.SetSourcePath.
	// It's used in the implementation of the {% include %} tag.
	SourceFile() string
	// TagArgs returns the text of the current tag, not including its name.
	// For example, the arguments to {% my_tag a b c %} would be “a b c”.
	TagArgs() string
	// TagName returns the name of the current tag; for example "my_tag" for {% my_tag a b c %}.
	TagName() string
	// WrapError creates a new error that records the source location from the current context.
	WrapError(err error) Error
}

type Error interface {
	Path() string
	LineNumber() int
	Cause() error
	Error() string
}

type FileTemplateStore struct{}

type Node interface {
	SourceLocation() parser.SourceLoc // for error reporting
	SourceText() string               // for error reporting
	// contains filtered or unexported methods
}

type ObjectNode struct {
	parser.Token
	// contains filtered or unexported fields
}

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

type SeqNode struct {
	Children []Node
	// contains filtered or unexported fields
}

type TagCompiler func(expr string) (func(io.Writer, Context) error, error)

type TagNode struct {
	parser.Token
	// contains filtered or unexported fields
}

type TemplateStore interface {
	ReadTemplate(templatename string) ([]byte, error)
}

type TextNode struct {
	parser.Token
}

type TrimNode struct {
	parser.TrimDirection
	// contains filtered or unexported fields
}