🥮 mooncakes.io

    lampclaw/moonstyle/ir does not have a README file

    AnimationName

    source
    pub(all) struct AnimationName {
      keyframes : Keyframes
    } derive(Eq, 
    Debug    )

    AnimationName::equal

    source

    AnimationName::not_equal

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

    AnimationName::to_repr

    source

    AttributeCase

    source
    pub(all) enum AttributeCase {
      DefaultCase
      Insensitive
      Sensitive
    } derive(Eq, 
    Debug    )

    AttributeCase::equal

    source

    AttributeCase::not_equal

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

    AttributeCase::to_repr

    source

    AttributeOperator

    source
    pub(all) enum AttributeOperator {
      Present
      Equals
      IncludesWord
      DashPrefix
      Prefix
      Suffix
      Substring
    } derive(Eq, 
    Debug    )

    AttributeOperator::equal

    source

    AttributeOperator::not_equal

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

    AttributeOperator::to_repr

    source

    AttributeSelector

    source
    pub(all) struct AttributeSelector {
      name : String
      operator : AttributeOperator
      value : String
      case_mode : AttributeCase
    } derive(Eq, 
    Debug    )

    AttributeSelector::equal

    source

    AttributeSelector::not_equal

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

    AttributeSelector::to_repr

    source

    Condition

    source
    pub(all) enum Condition {
      Pseudo(PseudoClass)
      PseudoElement(PseudoElement)
      UnsafePseudo(String)
      UnsafePseudoElement(String)
      UnsafeAtRule(String)
      Media(MediaQuery)
      Supports(SupportsCondition)
      Container(ContainerQuery)
      ContainerStyle(ContainerStyleCondition)
      Relational(SelectorMarkerRef, MarkerRelation)
      Layer(String)
    } derive(Eq, 
    Debug    )

    Condition::equal

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

    Condition::not_equal

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

    Condition::to_repr

    source

    ContainerQuery

    source
    pub(all) struct ContainerQuery {
      name : String?
      features : Array[MediaFeature]
    } derive(Eq, 
    Debug    )

    ContainerQuery::equal

    source

    ContainerQuery::not_equal

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

    ContainerQuery::to_repr

    source

    ContainerStyleCondition

    source
    pub(all) enum ContainerStyleCondition {
      StyleEquals(
    VariableUse    , String)
      StyleNot(ContainerStyleCondition)
      StyleAll(Array[ContainerStyleCondition])
      StyleAny(Array[ContainerStyleCondition])
    } derive(Eq, 
    Debug    )

    ContainerStyleCondition::equal

    source

    ContainerStyleCondition::not_equal

    source

    ContainerStyleCondition::to_repr

    source

    ContainerStyleCondition::variables

    source

    ContractProperty

    source
    pub(all) struct ContractProperty {
      name : String
      policy : ContractValuePolicy
    } derive(Eq, 
    Debug    )

    ContractProperty::equal

    source

    ContractProperty::not_equal

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

    ContractProperty::to_repr

    source

    ContractValuePolicy

    source
    pub(all) enum ContractValuePolicy {
      AnySafe
      Exact(Array[String], Array[ContractVariable], Array[ContractVariable], Array[String])
    } derive(Eq, 
    Debug    )

    ContractValuePolicy::equal

    source

    ContractValuePolicy::not_equal

    source

    ContractValuePolicy::to_repr

    source

    ContractVariable

    source
    pub(all) struct ContractVariable {
      variable : String
      category : String
    } derive(Eq, 
    Debug    )

    Canonical identity for a token or dynamic slot admitted by a component contract. The custom-property name is the cross-package identity; category prevents a value channel from being reused through an incompatible type.

    ContractVariable::equal

    source

    ContractVariable::not_equal

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

    ContractVariable::to_repr

    source

    Declaration

    source
    pub(all) struct Declaration {
      property : String
      atomic_properties : Array[String]
      unsafe_raw : Bool
      value : StyleValue
      value_origin : DeclarationValueOrigin
      conditions : Array[Condition]
      source : SourceSpan?
      keyframe_allowed : Bool
    } derive(Eq, 
    Debug    )

    Declaration::equal

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

    Declaration::not_equal

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

    Declaration::to_repr

    source

    Declaration::with_source

    source
    fn Declaration::with_source(self : Declaration, source : SourceSpan) -> Declaration

    DeclarationValueOrigin

    source
    pub(all) enum DeclarationValueOrigin {
      LiteralOrigin(Array[String])
      TokenOrigin(ContractVariable)
      DynamicSlotOrigin(ContractVariable)
      ExpressionOrigin(String)
      ExpressionFallbackOrigin(Array[String])
      MixedFallbackOrigin(Array[DeclarationValueOrigin])
      AnimationOrigin
      ClearOrigin
      UnsafeOrigin
    } derive(Eq, 
    Debug    )

    Records how a declaration obtained its value. Contract checks use this provenance so a literal equal to a token default cannot impersonate that token, and a runtime slot remains a typed channel rather than a literal.

    DeclarationValueOrigin::equal

    source

    DeclarationValueOrigin::not_equal

    source

    DeclarationValueOrigin::to_repr

    source

    DependencyRef

    source
    pub struct DependencyRef {
      module_name : String
      semantic_digest : String
    } derive(Eq, 
    Debug    )

    DependencyRef::equal

    source

    DependencyRef::module_name

    source
    fn DependencyRef::module_name(self : DependencyRef) -> String

    DependencyRef::not_equal

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

    DependencyRef::semantic_digest

    source
    fn DependencyRef::semantic_digest(self : DependencyRef) -> String

    DependencyRef::to_repr

    source

    KeyframeDeclaration

    source
    pub(all) struct KeyframeDeclaration {
      expressions : Array[
    Expression    ]
      property : String
      values : Array[String]
      conditions : Array[Condition]
      dynamic : Bool
      keyframe_allowed : Bool
      source : SourceSpan?
    } derive(Eq, 
    Debug    )

    KeyframeDeclaration::equal

    source

    KeyframeDeclaration::not_equal

    source

    KeyframeDeclaration::to_repr

    source

    KeyframeFrame

    source
    pub(all) struct KeyframeFrame {
      step : KeyframeStep
      declarations : Array[KeyframeDeclaration]
    } derive(Eq, 
    Debug    )

    KeyframeFrame::equal

    source

    KeyframeFrame::not_equal

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

    KeyframeFrame::to_repr

    source

    KeyframeStep

    source
    pub(all) enum KeyframeStep {
      From
      To
      Percent(Int)
    } derive(Eq, 
    Debug    )

    KeyframeStep::equal

    source

    KeyframeStep::not_equal

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

    KeyframeStep::to_repr

    source

    Keyframes

    source
    pub(all) struct Keyframes {
      name_hint : String
      frames : Array[KeyframeFrame]
    } derive(Eq, 
    Debug    )

    Keyframes::equal

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

    Keyframes::not_equal

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

    Keyframes::to_repr

    source

    MarkerDefinition

    source
    pub(all) struct MarkerDefinition {
      name : String
    } derive(Eq, 
    Debug    )

    MarkerDefinition::equal

    source

    MarkerDefinition::not_equal

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

    MarkerDefinition::to_repr

    source

    MarkerRelation

    source
    pub(all) enum MarkerRelation {
      MarkerAncestor
      MarkerDescendant
      MarkerSiblingBefore
      MarkerSiblingAfter
      MarkerAnySibling
    } derive(Eq, 
    Debug    )

    MarkerRelation::equal

    source

    MarkerRelation::not_equal

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

    MarkerRelation::to_repr

    source

    MediaFeature

    source
    pub(all) struct MediaFeature {
      name : String
      operator : MediaFeatureOperator
      value : String
    } derive(Eq, 
    Debug    )

    MediaFeature::equal

    source

    MediaFeature::not_equal

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

    MediaFeature::to_repr

    source

    MediaFeatureOperator

    source
    pub(all) enum MediaFeatureOperator {
      Min
      Max
      Equal
      LessThan
      GreaterThan
    } derive(Eq, 
    Debug    )

    MediaFeatureOperator::equal

    source

    MediaFeatureOperator::not_equal

    source

    MediaFeatureOperator::to_repr

    source

    MediaQuery

    source
    pub(all) struct MediaQuery {
      negated : Bool
      media_type : MediaType?
      features : Array[MediaFeature]
    } derive(Eq, 
    Debug    )

    MediaQuery::equal

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

    MediaQuery::not_equal

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

    MediaQuery::to_repr

    source

    MediaType

    source
    pub(all) enum MediaType {
      All
      Screen
      Print
      Speech
    } derive(Eq, 
    Debug    )

    MediaType::equal

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

    MediaType::not_equal

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

    MediaType::to_repr

    source

    Namespace

    source
    pub(all) struct Namespace {
      name : String
      declarations : Array[Declaration]
    } derive(Eq, 
    Debug    )

    Namespace::equal

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

    Namespace::not_equal

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

    Namespace::to_repr

    source

    PositionTryDefinition

    source
    pub(all) struct PositionTryDefinition {
      name : String
      descriptors : Array[PositionTryDescriptor]
    } derive(Eq, 
    Debug    )

    PositionTryDefinition::equal

    source

    PositionTryDefinition::not_equal

    source

    PositionTryDefinition::to_repr

    source

    PositionTryDescriptor

    source
    pub(all) struct PositionTryDescriptor {
      name : String
      value : String
    } derive(Eq, 
    Debug    )

    PositionTryDescriptor::equal

    source

    PositionTryDescriptor::not_equal

    source

    PositionTryDescriptor::to_repr

    source

    PseudoClass

    source
    pub(all) enum PseudoClass {
      Hover
      Focus
      FocusVisible
      FocusWithin
      Active
      Disabled
      Enabled
      Checked
      Required
      Optional
      ReadOnly
      ReadWrite
      PlaceholderShown
      FirstChild
      LastChild
      OnlyChild
      Empty
      Link
      Visited
      Valid
      Invalid
      InRange
      OutOfRange
      Indeterminate
      Target
      Autofill
      NthChild(Int, Int)
      NthLastChild(Int, Int)
      NthOfType(Int, Int)
      NthLastOfType(Int, Int)
      Is(Array[SelectorState])
      Not(Array[SelectorState])
      Where(Array[SelectorState])
      MatchAttribute(AttributeSelector)
    } derive(Eq, 
    Debug    )

    PseudoClass::equal

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

    PseudoClass::not_equal

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

    PseudoClass::to_repr

    source

    PseudoElement

    source
    pub(all) enum PseudoElement {
      Before
      After
      Placeholder
      Selection
      Marker
      FirstLetter
      FirstLine
      Backdrop
      FileSelectorButton
    } derive(Eq, 
    Debug    )

    PseudoElement::equal

    source

    PseudoElement::not_equal

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

    PseudoElement::to_repr

    source

    Recipe

    source
    pub(all) struct Recipe {
      name : String
      base : Array[String]
      variants : Array[RecipeVariantAxis]
      compounds : Array[RecipeCompound]
      contract : String?
    } derive(Eq, 
    Debug    )

    Recipe::equal

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

    Recipe::not_equal

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

    Recipe::to_repr

    source

    RecipeCompound

    source
    pub(all) struct RecipeCompound {
      matches : Array[RecipeVariantMatch]
      rules : Array[String]
    } derive(Eq, 
    Debug    )

    RecipeCompound::equal

    source

    RecipeCompound::not_equal

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

    RecipeCompound::to_repr

    source

    RecipeVariantAxis

    source
    pub(all) struct RecipeVariantAxis {
      name : String
      choices : Array[RecipeVariantChoice]
      default_value : String?
      boolean : Bool
    } derive(Eq, 
    Debug    )

    RecipeVariantAxis::equal

    source

    RecipeVariantAxis::not_equal

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

    RecipeVariantAxis::to_repr

    source

    RecipeVariantChoice

    source
    pub(all) struct RecipeVariantChoice {
      value : String
      rules : Array[String]
    } derive(Eq, 
    Debug    )

    RecipeVariantChoice::equal

    source

    RecipeVariantChoice::not_equal

    source

    RecipeVariantChoice::to_repr

    source

    RecipeVariantMatch

    source
    pub(all) struct RecipeVariantMatch {
      axis : String
      value : String
    } derive(Eq, 
    Debug    )

    RecipeVariantMatch::equal

    source

    RecipeVariantMatch::not_equal

    source

    RecipeVariantMatch::to_repr

    source

    Registry

    source
    pub(all) struct Registry {
      module_name : String
      styles : Array[StyleSet]
      contracts : Array[StyleContract]
      variable_sets : Array[VariableSet]
      themes : Array[Theme]
      recipes : Array[Recipe]
      markers : Array[MarkerDefinition]
      position_tries : Array[PositionTryDefinition]
      view_transition_classes : Array[ViewTransitionClassDefinition]
      direct_dependencies : Array[DependencyRef]
    } derive(Eq, 
    Debug    )

    Registry::equal

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

    Registry::not_equal

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

    Registry::to_repr

    source

    SelectorMarkerRef

    source
    pub(all) struct SelectorMarkerRef {
      module_name : String
      name : String
      class_name : String
      states : Array[SelectorState]
    } derive(Eq, 
    Debug    )

    SelectorMarkerRef::equal

    source

    SelectorMarkerRef::not_equal

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

    SelectorMarkerRef::to_repr

    source

    SelectorState

    source
    pub(all) enum SelectorState {
      SelectorPseudo(PseudoClass)
      SelectorAttribute(String)
      SelectorAttributeEquals(String, String)
      SelectorAttributeMatch(AttributeSelector)
    } derive(Eq, 
    Debug    )

    SelectorState::equal

    source

    SelectorState::not_equal

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

    SelectorState::to_repr

    source

    SourceSpan

    source
    pub(all) struct SourceSpan {
      file : String
      line : Int
      column : Int
      end_line : Int
      end_column : Int
      symbol : String
    } derive(Eq, 
    Debug    )

    SourceSpan::equal

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

    SourceSpan::not_equal

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

    SourceSpan::to_repr

    source

    StyleContract

    source
    pub(all) struct StyleContract {
      name : String
      properties : Array[ContractProperty]
    } derive(Eq, 
    Debug    )

    StyleContract::equal

    source

    StyleContract::not_equal

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

    StyleContract::to_repr

    source

    StyleSet

    source
    pub(all) struct StyleSet {
      export_name : String
      namespaces : Array[Namespace]
    } derive(Eq, 
    Debug    )

    StyleSet::equal

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

    StyleSet::not_equal

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

    StyleSet::to_repr

    source

    StyleValue

    source
    pub(all) enum StyleValue {
      Text(String)
      Fallbacks(Array[String])
      Dynamic(String, String, String)
      Expression(
    Expression    )
      ExpressionFallbacks(Array[
    Expression    ])
      Animation(AnimationName)
      AnimationList(Array[AnimationName?])
      Clear
    } derive(Eq, 
    Debug    )

    StyleValue::animations

    source
    fn StyleValue::animations(self : StyleValue) -> Array[AnimationName]

    StyleValue::equal

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

    StyleValue::not_equal

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

    StyleValue::to_repr

    source

    SupportsCondition

    source
    pub(all) enum SupportsCondition {
      Declaration(String, String)
      Not(SupportsCondition)
      All(Array[SupportsCondition])
      Any(Array[SupportsCondition])
    } derive(Eq, 
    Debug    )

    SupportsCondition::equal

    source

    SupportsCondition::not_equal

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

    SupportsCondition::to_repr

    source

    Theme

    source
    pub(all) struct Theme {
      name : String
      base : VariableSet
      overrides : Array[
    VarOverride    ]
    } derive(Eq, 
    Debug    )

    Theme::equal

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

    Theme::not_equal

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

    Theme::to_repr

    source

    VariableSet

    source
    pub(all) struct VariableSet {
      scope : String
      definitions : Array[
    VarDefinition    ]
    } derive(Eq, 
    Debug    )

    VariableSet::equal

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

    VariableSet::not_equal

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

    VariableSet::to_repr

    source

    ViewTransitionClassDefinition

    source
    pub(all) struct ViewTransitionClassDefinition {
      name : String
      styles : Array[ViewTransitionStyle]
    } derive(Eq, 
    Debug    )

    ViewTransitionClassDefinition::equal

    source

    ViewTransitionClassDefinition::not_equal

    source

    ViewTransitionClassDefinition::to_repr

    source

    ViewTransitionStyle

    source
    pub(all) struct ViewTransitionStyle {
      group : String
      declarations : Array[Declaration]
    } derive(Eq, 
    Debug    )

    ViewTransitionStyle::equal

    source

    ViewTransitionStyle::not_equal

    source

    ViewTransitionStyle::to_repr

    source

    animation

    source
    fn animation(value : AnimationName) -> StyleValue

    animation_list_identity

    source
    fn animation_list_identity(values : Array[AnimationName?]) -> String

    any_contract_property

    source
    fn any_contract_property(name : String) -> ContractProperty

    clear_value

    source
    fn clear_value() -> StyleValue

    container

    source
    fn container(query : ContainerQuery) -> Condition

    container_query

    source
    fn container_query(features : Array[MediaFeature], name? : String?) -> ContainerQuery

    container_style_condition

    source
    fn container_style_condition(condition : ContainerStyleCondition) -> Condition

    contract_variable

    source
    fn contract_variable(variable : String, category : String) -> ContractVariable

    create_theme

    source
    fn create_theme(name : String, base : VariableSet, overrides : Array[
    VarOverride    ]) -> Theme

    declaration

    source
    fn declaration(property : String, value : StyleValue, conditions? : Array[Condition], source? : SourceSpan?, atomic_properties? : Array[String], keyframe_allowed? : Bool, unsafe_raw? : Bool, value_origin? : DeclarationValueOrigin?) -> Declaration

    define_vars

    source
    fn define_vars(scope : String, definitions : Array[
    VarDefinition    ]) -> VariableSet

    dependency_ref

    source
    fn dependency_ref(module_name : String, semantic_digest : String) -> DependencyRef

    dynamic

    source
    fn dynamic(variable : String, suffix : String, category? : String) -> StyleValue

    exact_contract_property

    source
    fn exact_contract_property(name : String, values? : Array[String], tokens? : Array[ContractVariable], slots? : Array[ContractVariable], expressions? : Array[String]) -> ContractProperty

    fallbacks

    source
    fn fallbacks(values : Array[String]) -> StyleValue

    keyframe_frame

    source
    fn keyframe_frame(step : KeyframeStep, declarations : Array[Declaration]) -> KeyframeFrame

    keyframes

    source
    fn keyframes(name_hint : String, frames : Array[KeyframeFrame]) -> AnimationName

    layer

    source
    fn layer(name : String) -> Condition

    media

    source
    fn media(query : MediaQuery) -> Condition

    media_feature

    source
    fn media_feature(name : String, operator : MediaFeatureOperator, value : String) -> MediaFeature

    media_query

    source
    fn media_query(features : Array[MediaFeature], negated? : Bool, media_type? : MediaType?) -> MediaQuery

    pseudo

    source
    fn pseudo(value : PseudoClass) -> Condition

    pseudo_element

    source
    fn pseudo_element(value : PseudoElement) -> Condition

    registry

    source
    fn registry(module_name : String, styles : Array[StyleSet], contracts? : Array[StyleContract], variable_sets? : Array[VariableSet], themes? : Array[Theme], recipes? : Array[Recipe], markers? : Array[MarkerDefinition], position_tries? : Array[PositionTryDefinition], view_transition_classes? : Array[ViewTransitionClassDefinition], direct_dependencies? : Array[DependencyRef]) -> Registry

    relational

    source
    fn relational(marker : SelectorMarkerRef, relation : MarkerRelation) -> Condition

    selector_marker_ref

    source
    fn selector_marker_ref(module_name : String, name : String, class_name : String, states? : Array[SelectorState]) -> SelectorMarkerRef

    source_span

    source
    fn source_span(file : String, line : Int, column : Int, end_line? : Int, end_column? : Int, symbol? : String) -> SourceSpan

    style_contract

    source
    fn style_contract(name : String, properties : Array[ContractProperty]) -> StyleContract

    style_namespace

    source
    fn style_namespace(name : String, declarations : Array[Declaration]) -> Namespace

    style_set

    source
    fn style_set(export_name : String, namespaces : Array[Namespace]) -> StyleSet

    supports

    source
    fn supports(condition : SupportsCondition) -> Condition

    supports_all

    source
    fn supports_all(conditions : Array[SupportsCondition]) -> SupportsCondition

    supports_any

    source
    fn supports_any(conditions : Array[SupportsCondition]) -> SupportsCondition

    supports_declaration

    source
    fn supports_declaration(property : String, value : String) -> SupportsCondition

    supports_not

    source
    fn supports_not(condition : SupportsCondition) -> SupportsCondition

    text

    source
    fn text(value : String) -> StyleValue

    unsafe_at_rule

    source
    fn unsafe_at_rule(value : String) -> Condition

    unsafe_pseudo

    source
    fn unsafe_pseudo(value : String) -> Condition

    unsafe_pseudo_element

    source
    fn unsafe_pseudo_element(value : String) -> Condition

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io