package cascadia

Import Path
	github.com/andybalholm/cascadia (on go.dev)

Dependency Relation
	imports 8 packages, and imported by one package

Involved Source Files

	  d parser.go
		Package cascadia is an implementation of CSS selectors.

	    pseudo_classes.go
	    selector.go
	    serialize.go
	    specificity.go
Package-Level Type Names (total 5)

	/* sort by: alphabet | popularity */
	 type Matcher (interface)
		Matcher is the interface for basic selector functionality.
		Match returns whether a selector matches n.

		Methods (only one)
			( Matcher) Match(n *html.Node) bool
		Implemented By (at least 4)
			 Sel (interface)
			 Selector
			 SelectorGroup
			 github.com/PuerkitoBio/goquery.Matcher (interface)
		As Inputs Of (at least 3)
			func Filter(nodes []*html.Node, m Matcher) (result []*html.Node)
			func Query(n *html.Node, m Matcher) *html.Node
			func QueryAll(n *html.Node, m Matcher) []*html.Node

	 type Sel (interface)
		Sel is the interface for all the functionality provided by selectors.

		Methods (total 4)
			( Sel) Match(n *html.Node) bool
			( Sel) PseudoElement() string
				Returns a pseudo-element, or an empty string.

			( Sel) Specificity() Specificity
			( Sel) String() string
				Returns a CSS input compiling to this selector.

		Implements (at least 3)
			 Sel : Matcher
			 Sel : expvar.Var
			 Sel : fmt.Stringer
		As Outputs Of (at least 2)
			func Parse(sel string) (Sel, error)
			func ParseWithPseudoElement(sel string) (Sel, error)

	 type Selector (func)
		A Selector is a function which tells whether a node matches or not.
		
		This type is maintained for compatibility; I recommend using the newer and
		more idiomatic interfaces Sel and Matcher.

		Methods (total 4)
			( Selector) Filter(nodes []*html.Node) (result []*html.Node)
				Filter returns the nodes in nodes that match the selector.

			( Selector) Match(n *html.Node) bool
				Match returns true if the node matches the selector.

			( Selector) MatchAll(n *html.Node) []*html.Node
				MatchAll returns a slice of the nodes that match the selector,
				from n and its children.

			( Selector) MatchFirst(n *html.Node) *html.Node
				MatchFirst returns the first node that matches s, from n and its children.

		Implements (at least 2)
			 Selector : Matcher
			 Selector : github.com/PuerkitoBio/goquery.Matcher
		As Outputs Of (at least 2)
			func Compile(sel string) (Selector, error)
			func MustCompile(sel string) Selector

	 type SelectorGroup ([])
		A SelectorGroup is a list of selectors, which matches if any of the
		individual selectors matches.

		Methods (total 2)
			( SelectorGroup) Match(n *html.Node) bool
				Match returns true if the node matches one of the single selectors.

			( SelectorGroup) String() string
		Implements (at least 3)
			 SelectorGroup : Matcher
			 SelectorGroup : expvar.Var
			 SelectorGroup : fmt.Stringer
		As Outputs Of (at least 2)
			func ParseGroup(sel string) (SelectorGroup, error)
			func ParseGroupWithPseudoElements(sel string) (SelectorGroup, error)

	 type Specificity ([...])
		Specificity is the CSS specificity as defined in
		https://www.w3.org/TR/selectors/#specificity-rules
		with the convention Specificity = [A,B,C].

		Methods (total 2)
			( Specificity) Add(other Specificity) Specificity
			( Specificity) Less(other Specificity) bool
				returns `true` if s < other (strictly), false otherwise

		As Outputs Of (at least 2)
			func Sel.Specificity() Specificity
			func Specificity.Add(other Specificity) Specificity
		As Inputs Of (at least 2)
			func Specificity.Add(other Specificity) Specificity
			func Specificity.Less(other Specificity) bool


Package-Level Functions (total 9)

	 func Compile(sel string) (Selector, error)
		Compile parses a selector and returns, if successful, a Selector object
		that can be used to match against html.Node objects.

	 func Filter(nodes []*html.Node, m Matcher) (result []*html.Node)
		Filter returns the nodes that match m.

	 func MustCompile(sel string) Selector
		MustCompile is like Compile, but panics instead of returning an error.

	 func Parse(sel string) (Sel, error)
		Parse parses a selector. Use `ParseWithPseudoElement`
		if you need support for pseudo-elements.

	 func ParseGroup(sel string) (SelectorGroup, error)
		ParseGroup parses a selector, or a group of selectors separated by commas.
		Use `ParseGroupWithPseudoElements`
		if you need support for pseudo-elements.

	 func ParseGroupWithPseudoElements(sel string) (SelectorGroup, error)
		ParseGroupWithPseudoElements parses a selector, or a group of selectors separated by commas.
		It supports pseudo-elements.

	 func ParseWithPseudoElement(sel string) (Sel, error)
		ParseWithPseudoElement parses a single selector,
		with support for pseudo-element.

	 func Query(n *html.Node, m Matcher) *html.Node
		Query returns the first node that matches m, from the descendants of n.
		If none matches, it returns nil.

	 func QueryAll(n *html.Node, m Matcher) []*html.Node
		QueryAll returns a slice of all the nodes that match m, from the descendants
		of n.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.