pub trait Fold {
Show 99 methods
fn fold_and_media_query(&mut self, n: AndMediaQuery) -> AndMediaQuery { ... }
fn fold_and_support_query(&mut self, n: AndSupportQuery) -> AndSupportQuery { ... }
fn fold_array_value(&mut self, n: ArrayValue) -> ArrayValue { ... }
fn fold_at_rule(&mut self, n: AtRule) -> AtRule { ... }
fn fold_at_selector(&mut self, n: AtSelector) -> AtSelector { ... }
fn fold_at_text_value(&mut self, n: AtTextValue) -> AtTextValue { ... }
fn fold_attr_selector(&mut self, n: AttrSelector) -> AttrSelector { ... }
fn fold_attr_selector_op(&mut self, n: AttrSelectorOp) -> AttrSelectorOp { ... }
fn fold_bin_op(&mut self, n: BinOp) -> BinOp { ... }
fn fold_bin_value(&mut self, n: BinValue) -> BinValue { ... }
fn fold_brace_value(&mut self, n: BraceValue) -> BraceValue { ... }
fn fold_char(&mut self, n: char) -> char { ... }
fn fold_charset_rule(&mut self, n: CharsetRule) -> CharsetRule { ... }
fn fold_class_selector(&mut self, n: ClassSelector) -> ClassSelector { ... }
fn fold_comma_media_query(&mut self, n: CommaMediaQuery) -> CommaMediaQuery { ... }
fn fold_comma_values(&mut self, n: CommaValues) -> CommaValues { ... }
fn fold_complex_selector(&mut self, n: ComplexSelector) -> ComplexSelector { ... }
fn fold_complex_selectors(
&mut self,
n: Vec<ComplexSelector>
) -> Vec<ComplexSelector> { ... }
fn fold_compound_selector(
&mut self,
n: CompoundSelector
) -> CompoundSelector { ... }
fn fold_compound_selectors(
&mut self,
n: Vec<CompoundSelector>
) -> Vec<CompoundSelector> { ... }
fn fold_decl_block(&mut self, n: DeclBlock) -> DeclBlock { ... }
fn fold_decl_block_item(&mut self, n: DeclBlockItem) -> DeclBlockItem { ... }
fn fold_decl_block_items(
&mut self,
n: Vec<DeclBlockItem>
) -> Vec<DeclBlockItem> { ... }
fn fold_document_rule(&mut self, n: DocumentRule) -> DocumentRule { ... }
fn fold_fn_value(&mut self, n: FnValue) -> FnValue { ... }
fn fold_fn_values(&mut self, n: Vec<FnValue>) -> Vec<FnValue> { ... }
fn fold_font_face_rule(&mut self, n: FontFaceRule) -> FontFaceRule { ... }
fn fold_hash_value(&mut self, n: HashValue) -> HashValue { ... }
fn fold_id_selector(&mut self, n: IdSelector) -> IdSelector { ... }
fn fold_import_rule(&mut self, n: ImportRule) -> ImportRule { ... }
fn fold_import_source(&mut self, n: ImportSource) -> ImportSource { ... }
fn fold_invalid(&mut self, n: Invalid) -> Invalid { ... }
fn fold_js_word(&mut self, n: JsWord) -> JsWord { ... }
fn fold_keyframe_block(&mut self, n: KeyframeBlock) -> KeyframeBlock { ... }
fn fold_keyframe_block_rule(
&mut self,
n: KeyframeBlockRule
) -> KeyframeBlockRule { ... }
fn fold_keyframe_blocks(
&mut self,
n: Vec<KeyframeBlock>
) -> Vec<KeyframeBlock> { ... }
fn fold_keyframe_selector(
&mut self,
n: KeyframeSelector
) -> KeyframeSelector { ... }
fn fold_keyframe_selectors(
&mut self,
n: Vec<KeyframeSelector>
) -> Vec<KeyframeSelector> { ... }
fn fold_keyframes_rule(&mut self, n: KeyframesRule) -> KeyframesRule { ... }
fn fold_media_queries(&mut self, n: Vec<MediaQuery>) -> Vec<MediaQuery> { ... }
fn fold_media_query(&mut self, n: MediaQuery) -> MediaQuery { ... }
fn fold_media_rule(&mut self, n: MediaRule) -> MediaRule { ... }
fn fold_namespace_rule(&mut self, n: NamespaceRule) -> NamespaceRule { ... }
fn fold_namespaced_name(&mut self, n: NamespacedName) -> NamespacedName { ... }
fn fold_nested_page_rule(&mut self, n: NestedPageRule) -> NestedPageRule { ... }
fn fold_not_media_query(&mut self, n: NotMediaQuery) -> NotMediaQuery { ... }
fn fold_not_support_query(&mut self, n: NotSupportQuery) -> NotSupportQuery { ... }
fn fold_num(&mut self, n: Num) -> Num { ... }
fn fold_only_media_query(&mut self, n: OnlyMediaQuery) -> OnlyMediaQuery { ... }
fn fold_opt_attr_selector_op(
&mut self,
n: Option<AttrSelectorOp>
) -> Option<AttrSelectorOp> { ... }
fn fold_opt_brace_value(
&mut self,
n: Option<BraceValue>
) -> Option<BraceValue> { ... }
fn fold_opt_char(&mut self, n: Option<char>) -> Option<char> { ... }
fn fold_opt_media_query(
&mut self,
n: Option<MediaQuery>
) -> Option<MediaQuery> { ... }
fn fold_opt_namespaced_name(
&mut self,
n: Option<NamespacedName>
) -> Option<NamespacedName> { ... }
fn fold_opt_selector_combinator(
&mut self,
n: Option<SelectorCombinator>
) -> Option<SelectorCombinator> { ... }
fn fold_opt_span(&mut self, n: Option<Span>) -> Option<Span> { ... }
fn fold_opt_str(&mut self, n: Option<Str>) -> Option<Str> { ... }
fn fold_opt_text(&mut self, n: Option<Text>) -> Option<Text> { ... }
fn fold_opt_value(&mut self, n: Option<Box<Value>>) -> Option<Box<Value>> { ... }
fn fold_or_media_query(&mut self, n: OrMediaQuery) -> OrMediaQuery { ... }
fn fold_or_support_query(&mut self, n: OrSupportQuery) -> OrSupportQuery { ... }
fn fold_page_rule(&mut self, n: PageRule) -> PageRule { ... }
fn fold_page_rule_block(&mut self, n: PageRuleBlock) -> PageRuleBlock { ... }
fn fold_page_rule_block_item(
&mut self,
n: PageRuleBlockItem
) -> PageRuleBlockItem { ... }
fn fold_page_rule_block_items(
&mut self,
n: Vec<PageRuleBlockItem>
) -> Vec<PageRuleBlockItem> { ... }
fn fold_page_selector(&mut self, n: PageSelector) -> PageSelector { ... }
fn fold_page_selectors(&mut self, n: Vec<PageSelector>) -> Vec<PageSelector> { ... }
fn fold_paren_support_query(
&mut self,
n: ParenSupportQuery
) -> ParenSupportQuery { ... }
fn fold_paren_value(&mut self, n: ParenValue) -> ParenValue { ... }
fn fold_percent_value(&mut self, n: PercentValue) -> PercentValue { ... }
fn fold_property(&mut self, n: Property) -> Property { ... }
fn fold_pseudo_selector(&mut self, n: PseudoSelector) -> PseudoSelector { ... }
fn fold_rule(&mut self, n: Rule) -> Rule { ... }
fn fold_rules(&mut self, n: Vec<Rule>) -> Vec<Rule> { ... }
fn fold_selector_combinator(
&mut self,
n: SelectorCombinator
) -> SelectorCombinator { ... }
fn fold_space_values(&mut self, n: SpaceValues) -> SpaceValues { ... }
fn fold_span(&mut self, n: Span) -> Span { ... }
fn fold_str(&mut self, n: Str) -> Str { ... }
fn fold_style_rule(&mut self, n: StyleRule) -> StyleRule { ... }
fn fold_stylesheet(&mut self, n: Stylesheet) -> Stylesheet { ... }
fn fold_subclass_selector(
&mut self,
n: SubclassSelector
) -> SubclassSelector { ... }
fn fold_subclass_selectors(
&mut self,
n: Vec<SubclassSelector>
) -> Vec<SubclassSelector> { ... }
fn fold_support_query(&mut self, n: SupportQuery) -> SupportQuery { ... }
fn fold_supports_rule(&mut self, n: SupportsRule) -> SupportsRule { ... }
fn fold_tag_selector(&mut self, n: TagSelector) -> TagSelector { ... }
fn fold_text(&mut self, n: Text) -> Text { ... }
fn fold_token(&mut self, n: Token) -> Token { ... }
fn fold_token_and_span(&mut self, n: TokenAndSpan) -> TokenAndSpan { ... }
fn fold_token_and_spans(
&mut self,
n: Vec<TokenAndSpan>
) -> Vec<TokenAndSpan> { ... }
fn fold_tokens(&mut self, n: Tokens) -> Tokens { ... }
fn fold_unit(&mut self, n: Unit) -> Unit { ... }
fn fold_unit_kind(&mut self, n: UnitKind) -> UnitKind { ... }
fn fold_unit_value(&mut self, n: UnitValue) -> UnitValue { ... }
fn fold_universal_selector(
&mut self,
n: UniversalSelector
) -> UniversalSelector { ... }
fn fold_unknown_at_rule(&mut self, n: UnknownAtRule) -> UnknownAtRule { ... }
fn fold_url_value(&mut self, n: UrlValue) -> UrlValue { ... }
fn fold_value(&mut self, n: Value) -> Value { ... }
fn fold_values(&mut self, n: Vec<Value>) -> Vec<Value> { ... }
fn fold_viewport_rule(&mut self, n: ViewportRule) -> ViewportRule { ... }