xpath

type Axis int

type BinaryOp struct {
	Op          string
	Left, Right Expr
	// ResolveQName binds a prefix in the static context of this operator, for
	// the one conversion that needs it. A general comparison casts an
	// untypedAtomic operand to the *other* operand's type, and when that type
	// is xs:QName the lexical form carries a prefix whose namespace lives in
	// the static context -- which the runtime Context deliberately does not
	// carry, since namespaces are a static property. Capturing the resolver
	// on the node is what makes the binding available where the cast happens.
	// Nil for every operator other than a comparison, and for a comparison
	// parsed without a namespace resolver.
	ResolveQName func(prefix string) (string, bool)
}

type Binding struct {
	Var xdm.QName
	Seq Expr
}

type CastExpr struct {
	Operand  Expr
	Type     SequenceType
	Castable bool // true for "castable as", which yields a boolean
}

type Collation interface {
	Compare(a, b string) int
	Contains(s, sub string) bool
	StartsWith(s, prefix string) bool
	EndsWith(s, suffix string) bool
	IndexOf(s, sub string) int
}

type CollectionResolver interface {
	// ResolveCollection returns the documents in uri, resolved against base.
	//
	// The result is a sequence rather than a []*xdm.Tree because a collection
	// is permitted to contain items that are not document nodes.
	ResolveCollection(uri, base string) (xdm.Sequence, error)
}

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

type Context struct {
	// Item is the context item. It is nil where there is no context item,
	// which is an error to reference rather than an empty sequence.
	Item xdm.Item
	// Position is the context position, 1-based. Zero means "no focus".
	Position int
	// Size is the context size.
	Size int

	// Vars holds in-scope variable bindings, keyed by expanded name.
	// Lookups walk to Parent, so a nested scope does not copy the map.
	Vars   map[string]xdm.Sequence
	Parent *Context

	// Funcs resolves function calls. Supplied by the caller so that XSLT can
	// add xsl:function declarations and extension functions without this
	// package knowing about them.
	Funcs FunctionLibrary

	// StaticBaseURI is the base URI of the expression itself — the stylesheet
	// or query it was written in — which is what fn:static-base-uri returns
	// and what fn:resolve-uri resolves against by default.
	//
	// It is distinct from a *node's* base URI, which comes from the document
	// the node was parsed from. Returning the context node's was the nearest
	// thing available before this existed, and it is a different value: a
	// stylesheet in one place can perfectly well be applied to a document
	// from another.
	StaticBaseURI string

	// ImplicitTimezone is the offset in minutes applied to date/time values
	// that carry no timezone. The spec requires the dynamic context to supply
	// one; defaulting to UTC keeps results reproducible across machines,
	// which matters more for a validator than matching local time.
	ImplicitTimezone int

	// Ctx carries cancellation. A stylesheet can loop for a long time on
	// pathological input, and the caller needs a way out that does not
	// involve killing the process.
	Ctx context.Context

	// Docs resolves fn:doc and fn:document URIs. Nil disables them, which is
	// the safe default: a stylesheet that can open arbitrary URIs is an SSRF
	// and file-disclosure vector.
	Docs DocumentResolver

	// Collections resolves fn:collection URIs. Nil disables it, for the same
	// reason nil disables Docs, and setting Docs does not set this: see
	// CollectionResolver.
	Collections CollectionResolver

	// Texts resolves fn:unparsed-text URIs. Nil disables it, and setting
	// Docs does not set this: reading a file as raw text is a wider grant
	// than reading it as a parsed document. See TextResolver.
	Texts TextResolver

	// Compat is XPath 1.0 compatibility mode, which XSLT 3.8 puts in force for
	// expressions written on an element whose effective [xsl:]version is below
	// 2.0. Under it the coercion rules of XPath 2.0 appendix B.1 apply: a
	// multi-item argument to a parameter expecting a string, a number or a
	// node is truncated to its first item instead of raising XPTY0004,
	// arithmetic on a non-numeric operand yields NaN rather than a type error,
	// and a general comparison converts its operands the way XPath 1.0 did.
	//
	// It defaults to false and is set only by a Compiled that was given it, so
	// ordinary 2.0 evaluation never sees it.
	Compat bool

	// Depth guards against unbounded recursion in user-defined functions and
	// named templates, which the spec does not bound.
	Depth int

	// Now is the value fn:current-dateTime and its siblings return.
	//
	// The spec requires these to be stable for the whole of one evaluation:
	// calling current-dateTime() twice must give the same answer, or a
	// stylesheet that stamps a document and then checks the stamp against
	// "now" can disagree with itself. Reading the clock here once, rather
	// than per call, is what guarantees that. A zero value means the caller
	// did not set one and the functions are unavailable.
	Now time.Time
	// HasNow distinguishes an unset clock from a legitimately zero time.
	HasNow bool
	// contains filtered or unexported fields
}

type ContextItem struct{}

type DocumentResolver interface {
	// ResolveDocument returns the tree for uri, resolved against base.
	ResolveDocument(uri, base string) (*xdm.Tree, error)
}

type Expr interface {
	// Eval evaluates the expression in ctx and returns a sequence.
	Eval(ctx *Context) (xdm.Sequence, error)
	// String returns a source-like rendering, used in error messages and to
	// make test failures readable.
	String() string
}

type FilterExpr struct {
	Base       Expr
	Predicates []Expr
}

type ForExpr struct {
	Bindings []Binding
	Return   Expr
}

type FuncCall struct {
	Name xdm.QName
	Args []Expr
}

type Function struct {
	Name  xdm.QName
	Arity int
	// Call receives the already-evaluated arguments. Functions that need the
	// context item (fn:string with no argument, fn:position) read it from ctx.
	Call func(ctx *Context, args []xdm.Sequence) (xdm.Sequence, error)
}

type FunctionLibrary interface {
	// Lookup returns the function with the given name and arity.
	Lookup(name xdm.QName, arity int) (Function, bool)
}

type IfExpr struct {
	Cond, Then, Else Expr
}

type InstanceOfExpr struct {
	Operand Expr
	Type    SequenceType
}

type KindTest struct {
	Kind xdm.NodeKind
	// Any matches every kind: the node() test.
	Any bool
	// Name constrains element()/attribute()/processing-instruction() tests
	// that name a target.
	Name    *xdm.QName
	HasName bool
	// Content constrains the root element of a document-node() test:
	// document-node(element(invoice)) matches only a document whose element
	// child satisfies the inner test. Nil means the document's content is
	// unconstrained.
	Content NodeTest
	// TypeName is the second argument of element(name, type) and its
	// attribute() counterpart, resolved to the key the data model records
	// type annotations under: a namespace-qualified {uri}local for a schema
	// type, the bare local name for a built-in. The empty string means the
	// test carried no type argument and constrains only the name.
	//
	// It is resolved at parse time because the prefix binding lives in the
	// static context, which is gone by the time the test runs. Comparing the
	// lexical form instead forced the comparison down to local parts, and two
	// types sharing a local name in different namespaces then matched each
	// other.
	TypeName string
	// TypeNameLexical is TypeName as the author wrote it, kept only so that
	// String() renders the test back in the syntax it was parsed from.
	TypeNameLexical string
	// TypeNillable records the "?" of element(name, type?), which lets a
	// nilled element match even though its content is absent.
	TypeNillable bool
	// SchemaDeclared marks a schema-element() or schema-attribute() test,
	// which names a global declaration rather than an element name. It
	// matches the named declaration and, for an element, the members of its
	// substitution group.
	SchemaDeclared bool
	// SubstitutionGroup holds the other names schema-element(E) admits: the
	// members of E's substitution group, resolved from the imported schema
	// when the test was parsed.
	//
	// It is resolved at parse time because nothing carries a schema into the
	// evaluator, and the group is fixed once the schema is imported. Nil for
	// every test that is not a schema-element(), and for a declaration that
	// heads no group.
	SubstitutionGroup []xdm.QName
	// DeclaredType is the local name of the type the schema-element() or
	// schema-attribute() declaration names, resolved at parse time for the
	// same reason SubstitutionGroup is. A node whose annotation is neither
	// that type nor derived from it was validated against some *other*
	// declaration of the same name — a local one — and does not match.
	//
	// Empty when the declaration's type is anonymous, in which case there is
	// no name to compare and the test checks only that the node was
	// validated.
	DeclaredType string
}

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

type Library struct {

	// Parent is consulted when a name is not found locally, so a stylesheet's
	// own functions can shadow and extend the builtins without copying them.
	Parent FunctionLibrary
	// contains filtered or unexported fields
}

type Literal struct{ Val *xdm.Atomic }

type NameTest struct {
	// Name is the expanded name to match. Wildcards leave one or both parts
	// unconstrained; see AnyURI and AnyLocal.
	Name xdm.QName
	// AnyURI matches any namespace ("*" and "*:local").
	AnyURI bool
	// AnyLocal matches any local name ("*" and "prefix:*").
	AnyLocal bool
}

type NamespaceResolver interface {
	// ResolvePrefix returns the URI bound to prefix, or false if unbound.
	ResolvePrefix(prefix string) (string, bool)
	// DefaultElementNamespace returns the namespace applied to unprefixed
	// element name tests. XSLT sets this from xpath-default-namespace; it is
	// empty by default, and it never applies to attribute names or function
	// names.
	DefaultElementNamespace() string
	// DefaultFunctionNamespace returns the namespace for unprefixed function
	// names, which is the fn: namespace in XPath and XSLT.
	DefaultFunctionNamespace() string
}

type NodeTest interface {
	// Matches reports whether n is selected on an axis whose principal node
	// kind is principal.
	Matches(n *xdm.Node, principal xdm.NodeKind) bool
	String() string
}

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

type PathExpr struct {
	// Root marks a path that starts at the document root ("/foo" rather
	// than "foo").
	Root  bool
	Steps []Expr // Step, or an arbitrary expression in "(...)/foo" form
}

type QuantifiedExpr struct {
	Every    bool
	Bindings []Binding
	Test     Expr
}

type Regexp interface {
	MatchString(s string) bool
	FindAllStringSubmatchIndex(s string, n int) [][]int
	NumSubexp() int
}

type SchemaTypes interface {
	// LookupSchemaType reports whether name is a type in the static context,
	// and which primitive an atomic value of it erases to.
	//
	// The primitive is what the type *system* needs: "instance of" and "treat
	// as" compare against the type hierarchy, and a value of a derived atomic
	// type is a value of its primitive with facets applied. A complex type,
	// or a list or union with no single primitive, returns ok with a zero
	// code and false for atomic — enough to stop XPST0051 without claiming
	// the value is comparable as an atomic.
	LookupSchemaType(name xdm.QName) (prim xdm.TypeCode, atomic, ok bool)

	// LookupSchemaDeclaration reports whether name is a global element or
	// attribute declaration in the static context.
	//
	// It is what schema-element() and schema-attribute() need: both name a
	// *declaration* rather than a type, and both are XPST0008 when no schema
	// declares the name.
	LookupSchemaDeclaration(name xdm.QName, attribute bool) bool

	// SubstitutionGroupMembers returns the global element declarations that
	// may substitute for name, transitively and not including name itself.
	//
	// schema-element(E) matches E and every member of E's substitution
	// group, so a schema that declares "surname" as substitutable for "last"
	// makes schema-element(z:last) match a z:surname element. Resolving the
	// members here rather than at match time is what keeps the node test
	// self-contained: nothing carries a schema into the evaluator, and the
	// group is fixed once the schema is imported.
	//
	// An implementation with no schema, or a name with no members, returns
	// nil.
	SubstitutionGroupMembers(name xdm.QName) []xdm.QName

	// SchemaDeclarationType returns the local name of the type a global
	// element or attribute declaration names, and whether there is one.
	//
	// It is a LOCAL name, unlike the type name in an element() test, which is
	// resolved to a namespace-qualified annotation key at parse time. The
	// difference is deliberate: this string is produced by an implementation
	// of this interface, which has no obligation to know about annotation
	// keys, so the comparison against it (in nodeTypeMatches, reached through
	// KindTest.DeclaredType) accepts a bare name as a local-part match. That
	// is narrower ground than it sounds: the check exists only to tell a
	// global declaration from a LOCAL declaration of the same name in the
	// same schema, where the namespace is not in question.
	//
	// schema-element(E) matches a node only when it was validated against
	// E's *declaration*, and a node may carry E's name while having been
	// validated against a local declaration of a different type — which is
	// the case the suite draws the line on. The evaluator sees only the
	// compiled test, so the declared type is resolved here, while the schema
	// is still reachable, and compared against the node's annotation at
	// match time.
	//
	// An anonymous type has no name to return, so a declaration using one
	// returns false and the test falls back to checking only that the node
	// was validated at all.
	SchemaDeclarationType(name xdm.QName, attribute bool) (string, bool)

	// ValidateSchemaValue checks a lexical value against a named simple type
	// in the static context, reporting whether the name is a simple type at
	// all and, if so, whether the value is in its value space.
	//
	// "castable as my:hatsize" is that question. The engine can cast to the
	// built-in the type derives from, but the facets the schema author wrote
	// live only in the schema — so without asking, a cast to a restriction of
	// xs:integer accepted every integer and the restriction meant nothing.
	ValidateSchemaValue(name xdm.QName, value string) (known bool, err error)
}

type SequenceExpr struct{ Items []Expr }

type SequenceType struct {
	// Empty is the empty-sequence() type.
	Empty bool
	// ItemType is nil for item(), which matches anything.
	ItemType NodeTest
	// AtomicType names an atomic type when the item type is one.
	AtomicType    xdm.TypeCode
	HasAtomicType bool
	// FacetName is the derived type actually written, when it differs from
	// AtomicType — "byte" for xs:byte, which is an xs:integer with a range.
	// The code alone cannot express the bound, and dropping it made
	// "128 castable as xs:byte" answer true.
	FacetName string
	// SchemaType is the lexical name of a type that came from an imported
	// schema rather than from the built-in table.
	//
	// It is kept as written because that is what the schema's own type table
	// is keyed by: matching a value against it means asking the schema, not
	// the type codes here, and a derived type's identity is exactly its name.
	SchemaType string

	// SchemaValueValid checks a lexical value against the imported schema
	// type SchemaType names, when that name is a simple type. It is captured
	// at parse time, while the schema is still reachable through the
	// resolver, for the same reason a schema-element() test's substitution
	// group is: nothing carries a schema into the evaluator.
	//
	// nil when the type is not an imported simple type, in which case a cast
	// is decided entirely by the built-in the type derives from.
	SchemaValueValid func(value string) error
	// Occurrence is "", "?", "*" or "+".
	Occurrence string
}

type SimpleMap struct {
	Left  Expr
	Right Expr
}

type Step struct {
	Axis       Axis
	Test       NodeTest
	Predicates []Expr

	// Explicit records that the axis was written out ("child::x") rather
	// than abbreviated ("x"). Section 5.5.3 gives the abbreviated child axis
	// in a pattern a wider reach than the written one — it is evaluated on
	// the child-or-top axis, so "document-node()" alone matches the document
	// node while "child::document-node()" is legal but matches nothing,
	// since a document node is never a child.
	Explicit bool
}

type StringConcat struct {
	Left  Expr
	Right Expr
}

type TextResolver interface {
	// ResolveText returns the text of uri, resolved against base, decoded
	// using encoding when one is named and as UTF-8 when it is empty.
	ResolveText(uri, base, encoding string) (string, error)
}

type Token struct {
	Kind TokenKind
	Val  string
	Pos  int

	// Num holds the parsed numeric value and NumType its XPath type, so the
	// parser does not re-parse the literal. A numeric literal's type is fixed
	// by its lexical form: no dot or E means integer, a dot means decimal, an
	// E means double.
	Num float64
	// contains filtered or unexported fields
}

type TokenKind int

type TreatExpr struct {
	Operand Expr
	Type    SequenceType
}

type UnaryOp struct {
	Op      string
	Operand Expr
}

type VarRef struct{ Name xdm.QName }