🥮 mooncakes.io

    Milky2018/css/selector does not have a README file

    Attribute

    source
    pub(all) struct Attribute {
      name : String
      value : String
    }

    Attribute value on an element

    AttributeMatch

    source
    pub enum AttributeMatch {
      Exists
      Exact(String)
      Includes(String)
      DashMatch(String)
      Prefix(String)
      Suffix(String)
      Substring(String)
    }

    Attribute matching mode

    AttributeMatch::output

    source
    fn AttributeMatch::output(self : AttributeMatch, logger : &Logger) -> Unit

    AttributeMatch::to_string

    source
    fn AttributeMatch::to_string(self : AttributeMatch) -> String

    AttributeSelector

    source
    pub struct AttributeSelector {
      name : String
      match_type : AttributeMatch
      case_insensitive : Bool
      any_namespace : Bool
    }

    Attribute selector

    AttributeSelector::output

    source
    fn AttributeSelector::output(self : AttributeSelector, logger : &Logger) -> Unit

    AttributeSelector::to_string

    source
    fn AttributeSelector::to_string(self : AttributeSelector) -> String

    Combinator

    source
    pub enum Combinator {
      Descendant
      Child
      NextSibling
      SubsequentSibling
    }

    Combinator between compound selectors
    impl Show for Combinator

    Combinator::output

    source
    fn Combinator::output(self : Combinator, logger : &Logger) -> Unit

    Combinator::to_string

    source
    fn Combinator::to_string(self : Combinator) -> String

    ComplexSelector

    source
    pub struct ComplexSelector {
      head : CompoundSelector
      tail : Array[ComplexSelectorStep]
    }

    Complex selector - compound selectors joined by combinators e.g., div > p.intro + span

    ComplexSelector::output

    source
    fn ComplexSelector::output(self : ComplexSelector, logger : &Logger) -> Unit

    ComplexSelector::simple

    source

    Create a complex selector from a single compound

    ComplexSelector::to_string

    source
    fn ComplexSelector::to_string(self : ComplexSelector) -> String

    ComplexSelectorStep

    source
    pub struct ComplexSelectorStep {
      combinator : Combinator
      selector : CompoundSelector
    }

    A step in a complex selector: combinator + compound selector

    CompoundSelector

    source
    pub struct CompoundSelector {
      type_selector : SimpleSelector?
      subclasses : Array[SimpleSelector]
      any_ns_universal : Bool
    }

    Compound selector - a sequence of simple selectors without combinator e.g., div.foo#bar:hover

    CompoundSelector::from_class

    source
    fn CompoundSelector::from_class(class_name : String) -> CompoundSelector

    Create a simple compound selector with just a class selector

    CompoundSelector::from_id

    source
    fn CompoundSelector::from_id(id : String) -> CompoundSelector

    Create a simple compound selector with just an ID selector

    CompoundSelector::from_type

    source
    fn CompoundSelector::from_type(tag_name : String) -> CompoundSelector

    Create a simple compound selector with just a type selector

    CompoundSelector::output

    source
    fn CompoundSelector::output(self : CompoundSelector, logger : &Logger) -> Unit

    CompoundSelector::to_string

    source
    fn CompoundSelector::to_string(self : CompoundSelector) -> String

    CompoundSelector::universal

    source

    Create a simple compound selector with universal selector

    Element

    source
    pub(all) struct Element {
      tag_name : String
      id : String?
      classes : Array[String]
      attributes : Array[Attribute]
      custom_states : Array[String]
      parent : Element?
      prev_sibling : Element?
      next_sibling : Element?
      children : Array[Element]
      sibling_index : Int
      sibling_count : Int
    }

    Element data for selector matching This is a concrete type that can be used with or without a real DOM

    Element::add_class

    source
    fn Element::add_class(self : Element, class_name : String) -> Element

    Element::add_custom_state

    source
    fn Element::add_custom_state(self : Element, state : String) -> Element

    Element::get_attribute

    source
    fn Element::get_attribute(self : Element, name : String) -> String?

    Get attribute value by name

    Element::has_class

    source
    fn Element::has_class(self : Element, class_name : String) -> Bool

    Check if element has a specific class

    Element::is_first_child

    source
    fn Element::is_first_child(self : Element) -> Bool

    Check if element is first child

    Element::is_last_child

    source
    fn Element::is_last_child(self : Element) -> Bool

    Check if element is last child

    Element::new

    source
    fn Element::new(tag_name : String) -> Element

    Create a new element with minimal information

    Element::set_attribute

    source
    fn Element::set_attribute(self : Element, name : String, value : String) -> Element

    Element::set_id

    source
    fn Element::set_id(self : Element, id : String) -> Element

    Builder for creating elements with fluent API

    Element::set_parent

    source
    fn Element::set_parent(self : Element, parent : Element) -> Element

    Element::set_sibling_info

    source
    fn Element::set_sibling_info(self : Element, index : Int, count : Int) -> Element

    Element::with_classes

    source
    fn Element::with_classes(tag_name : String, classes : Array[String]) -> Element

    Create an element with classes

    Element::with_id

    source
    fn Element::with_id(tag_name : String, id : String) -> Element

    Create an element with id

    ForcedPseudoStates

    source
    pub(all) struct ForcedPseudoStates {
      hover : Bool
      focus : Bool
      active : Bool
      focus_visible : Bool
      focus_within : Bool
    } derive(Eq, 
    Debug    )

    ForcedPseudoStates::equal

    source

    ForcedPseudoStates::is_empty

    source
    fn ForcedPseudoStates::is_empty(self : ForcedPseudoStates) -> Bool

    ForcedPseudoStates::none

    source

    ForcedPseudoStates::not_equal

    source

    ForcedPseudoStates::output

    source
    fn ForcedPseudoStates::output(self : ForcedPseudoStates, logger : &Logger) -> Unit

    ForcedPseudoStates::to_repr

    source

    ForcedPseudoStates::to_string

    source
    fn ForcedPseudoStates::to_string(self : ForcedPseudoStates) -> String

    NthExpr

    source
    pub struct NthExpr {
      a : Int
      b : Int
    }

    Nth expression: An+B
    impl Show for NthExpr

    NthExpr::output

    source
    fn NthExpr::output(self : NthExpr, logger : &Logger) -> Unit

    NthExpr::to_string

    source
    fn NthExpr::to_string(self : NthExpr) -> String

    PseudoClass

    source
    pub enum PseudoClass {
      FirstChild
      LastChild
      OnlyChild
      NthChild(NthExpr)
      NthLastChild(NthExpr)
      FirstOfType
      LastOfType
      OnlyOfType
      NthOfType(NthExpr)
      NthLastOfType(NthExpr)
      Root
      Empty
      Not(Array[ComplexSelector])
      Is(Array[ComplexSelector])
      Where(Array[ComplexSelector])
      Has(Array[RelativeSelector])
      State(String)
      Host
      HostFunc(CompoundSelector)
      HostContextFunc(CompoundSelector)
      Heading(Array[Int])
      Dir(String)
      Lang(Array[String])
      Hover
      Active
      Focus
      FocusVisible
      FocusWithin
      Link
      Visited
      AnyLink
      Enabled
      Disabled
      Checked
      Indeterminate
      Required
      Optional
      Valid
      Invalid
      ReadOnly
      ReadWrite
    }

    Pseudo-class selector
    impl Show for PseudoClass

    PseudoClass::output

    source
    fn PseudoClass::output(self : PseudoClass, logger : &Logger) -> Unit

    PseudoClass::to_string

    source
    fn PseudoClass::to_string(self : PseudoClass) -> String

    PseudoElement

    source
    pub enum PseudoElement {
      Before
      After
      FirstLine
      FirstLetter
      Marker
      Placeholder
      Selection
      Backdrop
      FileSelectorButton
      PlaceholderShown
      TargetText
      SpellingError
      GrammarError
      Cue
      Part(Array[String])
      Slotted(Array[CompoundSelector])
    }

    Pseudo-element selector

    PseudoElement::output

    source
    fn PseudoElement::output(self : PseudoElement, logger : &Logger) -> Unit

    PseudoElement::to_string

    source
    fn PseudoElement::to_string(self : PseudoElement) -> String

    RelativeSelector

    source
    pub struct RelativeSelector {
      combinator : Combinator?
      selector : ComplexSelector
    }

    Relative selector for :has()

    SelectorList

    source
    pub struct SelectorList {
      selectors : Array[ComplexSelector]
    }

    Selector list - comma-separated selectors

    SelectorList::output

    source
    fn SelectorList::output(self : SelectorList, logger : &Logger) -> Unit

    SelectorList::to_string

    source
    fn SelectorList::to_string(self : SelectorList) -> String

    ShadowContext

    source
    pub(all) struct ShadowContext {
      host : Element
      host_ancestors : Array[Element]
      assigned_slot : Element?
    }

    Shadow DOM scoping information for selector matching.

    host is the shadow host for the current styling scope. host_ancestors is the light-tree ancestor chain used by :host-context(). If it is empty, the matcher falls back to walking host.parent. assigned_slot is the slot assigned to the element currently being matched by ::slotted().

    ShadowContext::new

    source

    ShadowContext::set_assigned_slot

    source
    fn ShadowContext::set_assigned_slot(self : ShadowContext, assigned_slot : Element) -> ShadowContext

    ShadowContext::set_host_ancestors

    source
    fn ShadowContext::set_host_ancestors(self : ShadowContext, host_ancestors : Array[Element]) -> ShadowContext

    SimpleSelector

    source
    pub enum SimpleSelector {
      Type(String)
      Universal
      Id(String)
      Class(String)
      Attribute(AttributeSelector)
      PseudoClass(PseudoClass)
      PseudoElement(PseudoElement)
    }

    Simple selector - a single component

    SimpleSelector::output

    source
    fn SimpleSelector::output(self : SimpleSelector, logger : &Logger) -> Unit

    SimpleSelector::to_string

    source
    fn SimpleSelector::to_string(self : SimpleSelector) -> String

    Specificity

    source
    pub(all) struct Specificity {
      a : Int
      b : Int
      c : Int
    } derive(Compare, Eq)

    Specificity as (a, b, c) tuple a: ID selectors count b: class selectors, attribute selectors, pseudo-classes count c: type selectors, pseudo-elements count
    impl Show for Specificity

    Specificity::add

    source
    fn Specificity::add(self : Specificity, other : Specificity) -> Specificity

    Specificity::compare

    source
    fn Specificity::compare(Specificity, Specificity) -> Int

    Specificity::compare_to

    source
    fn Specificity::compare_to(self : Specificity, other : Specificity) -> Int

    Compare specificities for cascade ordering Returns positive if self > other, negative if self < other, 0 if equal

    Specificity::equal

    source
    fn Specificity::equal(Specificity, Specificity) -> Bool

    Specificity::not_equal

    source
    fn Specificity::not_equal(x : Specificity, y : Specificity) -> Bool

    Specificity::op_ge

    source
    fn Specificity::op_ge(x : Specificity, y : Specificity) -> Bool

    Specificity::op_gt

    source
    fn Specificity::op_gt(x : Specificity, y : Specificity) -> Bool

    Specificity::op_le

    source
    fn Specificity::op_le(x : Specificity, y : Specificity) -> Bool

    Specificity::op_lt

    source
    fn Specificity::op_lt(x : Specificity, y : Specificity) -> Bool

    Specificity::output

    source
    fn Specificity::output(self : Specificity, logger : &Logger) -> Unit

    Specificity::to_string

    source
    fn Specificity::to_string(self : Specificity) -> String

    Specificity::zero

    source
    fn Specificity::zero() -> Specificity

    complex_specificity

    source
    fn complex_specificity(sel : ComplexSelector) -> Specificity

    Calculate specificity of a complex selector

    matches_complex

    source
    fn matches_complex(element : Element, selector : ComplexSelector) -> Bool

    Check if an element matches a complex selector

    matches_complex_with_forced_states

    source
    fn matches_complex_with_forced_states(element : Element, selector : ComplexSelector, forced : ForcedPseudoStates) -> Bool

    Check if an element matches a complex selector with forced states. Forced states only apply to the subject element (the head/rightmost selector).

    matches_complex_with_shadow_context

    source
    fn matches_complex_with_shadow_context(element : Element, selector : ComplexSelector, context : ShadowContext?) -> Bool

    matches_pseudo_class_with_forced_states

    source
    fn matches_pseudo_class_with_forced_states(element : Element, pc : PseudoClass, forced : ForcedPseudoStates) -> Bool

    Check if an element matches a pseudo-class with forced states applied.

    matches_selector_list

    source
    fn matches_selector_list(element : Element, list : SelectorList) -> Bool

    Check if an element matches any selector in a list

    matches_selector_list_with_shadow_context

    source
    fn matches_selector_list_with_shadow_context(element : Element, list : SelectorList, context : ShadowContext?) -> Bool

    parse_selector_list_from_tokens

    source
    fn parse_selector_list_from_tokens(tokens : Array[
    Token    ], start : Int, end : Int) -> Array[ComplexSelector]

    Parse a selector-list from an existing token stream in-place (tokens[start..end]). This is the fast path used by parser/stylesheet: callers reuse tokens they have already lexed instead of stringifying + re-tokenizing the slice.

    Returns (text, selector) pairs because the stylesheet parser stores both the original source text and the parsed selector for every rule; we synthesize the text from the same slice.

    parse_selector_list_text

    source
    fn parse_selector_list_text(css : String) -> SelectorList?

    Convenience function to parse a selector list from CSS text

    parse_selector_text

    source
    fn parse_selector_text(css : String) -> ComplexSelector?

    Convenience function to parse a selector from CSS text

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io