pub trait Fold {
Show 145 methods
fn fold_an_plus_b(&mut self, n: AnPlusB) -> AnPlusB { ... }
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_matcher(
&mut self,
n: AttrSelectorMatcher
) -> AttrSelectorMatcher { ... }
fn fold_attr_selector_value(
&mut self,
n: AttrSelectorValue
) -> AttrSelectorValue { ... }
fn fold_bin_op(&mut self, n: BinOp) -> BinOp { ... }
fn fold_bin_value(&mut self, n: BinValue) -> BinValue { ... }
fn fold_block(&mut self, n: Block) -> Block { ... }
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_combinator(&mut self, n: Combinator) -> Combinator { ... }
fn fold_combinator_value(&mut self, n: CombinatorValue) -> CombinatorValue { ... }
fn fold_comma_values(&mut self, n: CommaValues) -> CommaValues { ... }
fn fold_complex_selector(&mut self, n: ComplexSelector) -> ComplexSelector { ... }
fn fold_complex_selector_children(
&mut self,
n: ComplexSelectorChildren
) -> ComplexSelectorChildren { ... }
fn fold_complex_selector_children_vec(
&mut self,
n: Vec<ComplexSelectorChildren>
) -> Vec<ComplexSelectorChildren> { ... }
fn fold_complex_selectors(
&mut self,
n: Vec<ComplexSelector>
) -> Vec<ComplexSelector> { ... }
fn fold_compound_selector(
&mut self,
n: CompoundSelector
) -> CompoundSelector { ... }
fn fold_declaration(&mut self, n: Declaration) -> Declaration { ... }
fn fold_declaration_block_item(
&mut self,
n: DeclarationBlockItem
) -> DeclarationBlockItem { ... }
fn fold_declaration_block_items(
&mut self,
n: Vec<DeclarationBlockItem>
) -> Vec<DeclarationBlockItem> { ... }
fn fold_document_rule(&mut self, n: DocumentRule) -> DocumentRule { ... }
fn fold_font_face_rule(&mut self, n: FontFaceRule) -> FontFaceRule { ... }
fn fold_function(&mut self, n: Function) -> Function { ... }
fn fold_functions(&mut self, n: Vec<Function>) -> Vec<Function> { ... }
fn fold_hash_value(&mut self, n: HashValue) -> HashValue { ... }
fn fold_i_32(&mut self, n: i32) -> i32 { ... }
fn fold_id_selector(&mut self, n: IdSelector) -> IdSelector { ... }
fn fold_ident(&mut self, n: Ident) -> Ident { ... }
fn fold_idents(&mut self, n: Vec<Ident>) -> Vec<Ident> { ... }
fn fold_import_href(&mut self, n: ImportHref) -> ImportHref { ... }
fn fold_import_layer_name(&mut self, n: ImportLayerName) -> ImportLayerName { ... }
fn fold_import_rule(&mut self, n: ImportRule) -> ImportRule { ... }
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_name(&mut self, n: KeyframesName) -> KeyframesName { ... }
fn fold_keyframes_rule(&mut self, n: KeyframesRule) -> KeyframesRule { ... }
fn fold_layer_name(&mut self, n: LayerName) -> LayerName { ... }
fn fold_layer_name_list(&mut self, n: LayerNameList) -> LayerNameList { ... }
fn fold_layer_names(&mut self, n: Vec<LayerName>) -> Vec<LayerName> { ... }
fn fold_layer_prelude(&mut self, n: LayerPrelude) -> LayerPrelude { ... }
fn fold_layer_rule(&mut self, n: LayerRule) -> LayerRule { ... }
fn fold_media_and(&mut self, n: MediaAnd) -> MediaAnd { ... }
fn fold_media_condition(&mut self, n: MediaCondition) -> MediaCondition { ... }
fn fold_media_condition_all_type(
&mut self,
n: MediaConditionAllType
) -> MediaConditionAllType { ... }
fn fold_media_condition_all_types(
&mut self,
n: Vec<MediaConditionAllType>
) -> Vec<MediaConditionAllType> { ... }
fn fold_media_condition_type(
&mut self,
n: MediaConditionType
) -> MediaConditionType { ... }
fn fold_media_condition_without_or(
&mut self,
n: MediaConditionWithoutOr
) -> MediaConditionWithoutOr { ... }
fn fold_media_condition_without_or_type(
&mut self,
n: MediaConditionWithoutOrType
) -> MediaConditionWithoutOrType { ... }
fn fold_media_condition_without_or_types(
&mut self,
n: Vec<MediaConditionWithoutOrType>
) -> Vec<MediaConditionWithoutOrType> { ... }
fn fold_media_feature(&mut self, n: MediaFeature) -> MediaFeature { ... }
fn fold_media_feature_boolean(
&mut self,
n: MediaFeatureBoolean
) -> MediaFeatureBoolean { ... }
fn fold_media_feature_name(
&mut self,
n: MediaFeatureName
) -> MediaFeatureName { ... }
fn fold_media_feature_plain(
&mut self,
n: MediaFeaturePlain
) -> MediaFeaturePlain { ... }
fn fold_media_feature_range(
&mut self,
n: MediaFeatureRange
) -> MediaFeatureRange { ... }
fn fold_media_feature_range_comparison(
&mut self,
n: MediaFeatureRangeComparison
) -> MediaFeatureRangeComparison { ... }
fn fold_media_feature_range_interval(
&mut self,
n: MediaFeatureRangeInterval
) -> MediaFeatureRangeInterval { ... }
fn fold_media_feature_value(
&mut self,
n: MediaFeatureValue
) -> MediaFeatureValue { ... }
fn fold_media_in_parens(&mut self, n: MediaInParens) -> MediaInParens { ... }
fn fold_media_not(&mut self, n: MediaNot) -> MediaNot { ... }
fn fold_media_or(&mut self, n: MediaOr) -> MediaOr { ... }
fn fold_media_queries(&mut self, n: Vec<MediaQuery>) -> Vec<MediaQuery> { ... }
fn fold_media_query(&mut self, n: MediaQuery) -> MediaQuery { ... }
fn fold_media_query_list(&mut self, n: MediaQueryList) -> MediaQueryList { ... }
fn fold_media_rule(&mut self, n: MediaRule) -> MediaRule { ... }
fn fold_namespace_rule(&mut self, n: NamespaceRule) -> NamespaceRule { ... }
fn fold_namespace_uri(&mut self, n: NamespaceUri) -> NamespaceUri { ... }
fn fold_nested_page_rule(&mut self, n: NestedPageRule) -> NestedPageRule { ... }
fn fold_nesting_selector(&mut self, n: NestingSelector) -> NestingSelector { ... }
fn fold_nth(&mut self, n: Nth) -> Nth { ... }
fn fold_nth_value(&mut self, n: NthValue) -> NthValue { ... }
fn fold_num(&mut self, n: Num) -> Num { ... }
fn fold_opt_attr_selector_matcher(
&mut self,
n: Option<AttrSelectorMatcher>
) -> Option<AttrSelectorMatcher> { ... }
fn fold_opt_attr_selector_value(
&mut self,
n: Option<AttrSelectorValue>
) -> Option<AttrSelectorValue> { ... }
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_i_32(&mut self, n: Option<i32>) -> Option<i32> { ... }
fn fold_opt_ident(&mut self, n: Option<Ident>) -> Option<Ident> { ... }
fn fold_opt_import_layer_name(
&mut self,
n: Option<ImportLayerName>
) -> Option<ImportLayerName> { ... }
fn fold_opt_js_word(&mut self, n: Option<JsWord>) -> Option<JsWord> { ... }
fn fold_opt_layer_prelude(
&mut self,
n: Option<LayerPrelude>
) -> Option<LayerPrelude> { ... }
fn fold_opt_media_condition_type(
&mut self,
n: Option<MediaConditionType>
) -> Option<MediaConditionType> { ... }
fn fold_opt_media_query_list(
&mut self,
n: Option<MediaQueryList>
) -> Option<MediaQueryList> { ... }
fn fold_opt_nesting_selector(
&mut self,
n: Option<NestingSelector>
) -> Option<NestingSelector> { ... }
fn fold_opt_pseudo_selector_children(
&mut self,
n: Option<PseudoSelectorChildren>
) -> Option<PseudoSelectorChildren> { ... }
fn fold_opt_rules(&mut self, n: Option<Vec<Rule>>) -> Option<Vec<Rule>> { ... }
fn fold_opt_selector_list(
&mut self,
n: Option<SelectorList>
) -> Option<SelectorList> { ... }
fn fold_opt_simple_block(
&mut self,
n: Option<SimpleBlock>
) -> Option<SimpleBlock> { ... }
fn fold_opt_span(&mut self, n: Option<Span>) -> Option<Span> { ... }
fn fold_opt_tokens(&mut self, n: Option<Tokens>) -> Option<Tokens> { ... }
fn fold_opt_type_selector(
&mut self,
n: Option<TypeSelector>
) -> Option<TypeSelector> { ... }
fn fold_opt_values(&mut self, n: Option<Vec<Value>>) -> Option<Vec<Value>> { ... }
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_percent_value(&mut self, n: PercentValue) -> PercentValue { ... }
fn fold_pseudo_class_selector(
&mut self,
n: PseudoClassSelector
) -> PseudoClassSelector { ... }
fn fold_pseudo_element_selector(
&mut self,
n: PseudoElementSelector
) -> PseudoElementSelector { ... }
fn fold_pseudo_selector_children(
&mut self,
n: PseudoSelectorChildren
) -> PseudoSelectorChildren { ... }
fn fold_qualified_rule(&mut self, n: QualifiedRule) -> QualifiedRule { ... }
fn fold_round_bracket_block(
&mut self,
n: RoundBracketBlock
) -> RoundBracketBlock { ... }
fn fold_rule(&mut self, n: Rule) -> Rule { ... }
fn fold_rules(&mut self, n: Vec<Rule>) -> Vec<Rule> { ... }
fn fold_selector_list(&mut self, n: SelectorList) -> SelectorList { ... }
fn fold_simple_block(&mut self, n: SimpleBlock) -> SimpleBlock { ... }
fn fold_space_values(&mut self, n: SpaceValues) -> SpaceValues { ... }
fn fold_span(&mut self, n: Span) -> Span { ... }
fn fold_square_bracket_block(
&mut self,
n: SquareBracketBlock
) -> SquareBracketBlock { ... }
fn fold_str(&mut self, n: Str) -> Str { ... }
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_supports_and(&mut self, n: SupportsAnd) -> SupportsAnd { ... }
fn fold_supports_condition(
&mut self,
n: SupportsCondition
) -> SupportsCondition { ... }
fn fold_supports_condition_type(
&mut self,
n: SupportsConditionType
) -> SupportsConditionType { ... }
fn fold_supports_condition_types(
&mut self,
n: Vec<SupportsConditionType>
) -> Vec<SupportsConditionType> { ... }
fn fold_supports_feature(&mut self, n: SupportsFeature) -> SupportsFeature { ... }
fn fold_supports_in_parens(
&mut self,
n: SupportsInParens
) -> SupportsInParens { ... }
fn fold_supports_not(&mut self, n: SupportsNot) -> SupportsNot { ... }
fn fold_supports_or(&mut self, n: SupportsOr) -> SupportsOr { ... }
fn fold_supports_rule(&mut self, n: SupportsRule) -> SupportsRule { ... }
fn fold_tag_selector(&mut self, n: TagSelector) -> TagSelector { ... }
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_type_selector(&mut self, n: TypeSelector) -> TypeSelector { ... }
fn fold_unit(&mut self, n: Unit) -> Unit { ... }
fn fold_unit_value(&mut self, n: UnitValue) -> UnitValue { ... }
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 { ... }
