pub trait Fold {
Show 191 methods
fn fold_an_plus_b(&mut self, n: AnPlusB) -> AnPlusB { ... }
fn fold_an_plus_b_notation(&mut self, n: AnPlusBNotation) -> AnPlusBNotation { ... }
fn fold_angle(&mut self, n: Angle) -> Angle { ... }
fn fold_at_rule(&mut self, n: AtRule) -> AtRule { ... }
fn fold_at_rule_name(&mut self, n: AtRuleName) -> AtRuleName { ... }
fn fold_attribute_selector(
&mut self,
n: AttributeSelector
) -> AttributeSelector { ... }
fn fold_attribute_selector_matcher(
&mut self,
n: AttributeSelectorMatcher
) -> AttributeSelectorMatcher { ... }
fn fold_attribute_selector_matcher_value(
&mut self,
n: AttributeSelectorMatcherValue
) -> AttributeSelectorMatcherValue { ... }
fn fold_attribute_selector_modifier(
&mut self,
n: AttributeSelectorModifier
) -> AttributeSelectorModifier { ... }
fn fold_attribute_selector_value(
&mut self,
n: AttributeSelectorValue
) -> AttributeSelectorValue { ... }
fn fold_calc_operator(&mut self, n: CalcOperator) -> CalcOperator { ... }
fn fold_calc_operator_type(
&mut self,
n: CalcOperatorType
) -> CalcOperatorType { ... }
fn fold_calc_product(&mut self, n: CalcProduct) -> CalcProduct { ... }
fn fold_calc_product_or_operator(
&mut self,
n: CalcProductOrOperator
) -> CalcProductOrOperator { ... }
fn fold_calc_product_or_operators(
&mut self,
n: Vec<CalcProductOrOperator>
) -> Vec<CalcProductOrOperator> { ... }
fn fold_calc_sum(&mut self, n: CalcSum) -> CalcSum { ... }
fn fold_calc_value(&mut self, n: CalcValue) -> CalcValue { ... }
fn fold_calc_value_or_operator(
&mut self,
n: CalcValueOrOperator
) -> CalcValueOrOperator { ... }
fn fold_calc_value_or_operators(
&mut self,
n: Vec<CalcValueOrOperator>
) -> Vec<CalcValueOrOperator> { ... }
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_color(&mut self, n: Color) -> Color { ... }
fn fold_color_profile_name(
&mut self,
n: ColorProfileName
) -> ColorProfileName { ... }
fn fold_color_profile_rule(
&mut self,
n: ColorProfileRule
) -> ColorProfileRule { ... }
fn fold_combinator(&mut self, n: Combinator) -> Combinator { ... }
fn fold_combinator_value(&mut self, n: CombinatorValue) -> CombinatorValue { ... }
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_component_value(&mut self, n: ComponentValue) -> ComponentValue { ... }
fn fold_component_values(
&mut self,
n: Vec<ComponentValue>
) -> Vec<ComponentValue> { ... }
fn fold_compound_selector(
&mut self,
n: CompoundSelector
) -> CompoundSelector { ... }
fn fold_compound_selector_list(
&mut self,
n: CompoundSelectorList
) -> CompoundSelectorList { ... }
fn fold_compound_selectors(
&mut self,
n: Vec<CompoundSelector>
) -> Vec<CompoundSelector> { ... }
fn fold_counter_style_rule(
&mut self,
n: CounterStyleRule
) -> CounterStyleRule { ... }
fn fold_custom_ident(&mut self, n: CustomIdent) -> CustomIdent { ... }
fn fold_dashed_ident(&mut self, n: DashedIdent) -> DashedIdent { ... }
fn fold_declaration(&mut self, n: Declaration) -> Declaration { ... }
fn fold_declaration_name(&mut self, n: DeclarationName) -> DeclarationName { ... }
fn fold_declaration_or_at_rule(
&mut self,
n: DeclarationOrAtRule
) -> DeclarationOrAtRule { ... }
fn fold_delimiter(&mut self, n: Delimiter) -> Delimiter { ... }
fn fold_delimiter_value(&mut self, n: DelimiterValue) -> DelimiterValue { ... }
fn fold_dimension(&mut self, n: Dimension) -> Dimension { ... }
fn fold_document_rule(&mut self, n: DocumentRule) -> DocumentRule { ... }
fn fold_document_rule_matching_function(
&mut self,
n: DocumentRuleMatchingFunction
) -> DocumentRuleMatchingFunction { ... }
fn fold_document_rule_matching_functions(
&mut self,
n: Vec<DocumentRuleMatchingFunction>
) -> Vec<DocumentRuleMatchingFunction> { ... }
fn fold_f_64(&mut self, n: f64) -> f64 { ... }
fn fold_flex(&mut self, n: Flex) -> Flex { ... }
fn fold_font_face_rule(&mut self, n: FontFaceRule) -> FontFaceRule { ... }
fn fold_frequency(&mut self, n: Frequency) -> Frequency { ... }
fn fold_function(&mut self, n: Function) -> Function { ... }
fn fold_general_enclosed(&mut self, n: GeneralEnclosed) -> GeneralEnclosed { ... }
fn fold_hex_color(&mut self, n: HexColor) -> HexColor { ... }
fn fold_i_32(&mut self, n: i32) -> i32 { ... }
fn fold_i_64(&mut self, n: i64) -> i64 { ... }
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_import_supports_type(
&mut self,
n: ImportSupportsType
) -> ImportSupportsType { ... }
fn fold_important_flag(&mut self, n: ImportantFlag) -> ImportantFlag { ... }
fn fold_integer(&mut self, n: Integer) -> Integer { ... }
fn fold_js_word(&mut self, n: JsWord) -> JsWord { ... }
fn fold_keyframe_block(&mut self, n: KeyframeBlock) -> 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_length(&mut self, n: Length) -> Length { ... }
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_nest_rule(&mut self, n: NestRule) -> NestRule { ... }
fn fold_nesting_selector(&mut self, n: NestingSelector) -> NestingSelector { ... }
fn fold_ns_prefix(&mut self, n: NsPrefix) -> NsPrefix { ... }
fn fold_number(&mut self, n: Number) -> Number { ... }
fn fold_opt_attribute_selector_matcher(
&mut self,
n: Option<AttributeSelectorMatcher>
) -> Option<AttributeSelectorMatcher> { ... }
fn fold_opt_attribute_selector_modifier(
&mut self,
n: Option<AttributeSelectorModifier>
) -> Option<AttributeSelectorModifier> { ... }
fn fold_opt_attribute_selector_value(
&mut self,
n: Option<AttributeSelectorValue>
) -> Option<AttributeSelectorValue> { ... }
fn fold_opt_combinator(
&mut self,
n: Option<Combinator>
) -> Option<Combinator> { ... }
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_import_supports_type(
&mut self,
n: Option<ImportSupportsType>
) -> Option<ImportSupportsType> { ... }
fn fold_opt_important_flag(
&mut self,
n: Option<ImportantFlag>
) -> Option<ImportantFlag> { ... }
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_ns_prefix(&mut self, n: Option<NsPrefix>) -> Option<NsPrefix> { ... }
fn fold_opt_number(&mut self, n: Option<Number>) -> Option<Number> { ... }
fn fold_opt_page_selector_list(
&mut self,
n: Option<PageSelectorList>
) -> Option<PageSelectorList> { ... }
fn fold_opt_page_selector_pseudos(
&mut self,
n: Option<Vec<PageSelectorPseudo>>
) -> Option<Vec<PageSelectorPseudo>> { ... }
fn fold_opt_page_selector_type(
&mut self,
n: Option<PageSelectorType>
) -> Option<PageSelectorType> { ... }
fn fold_opt_pseudo_class_selector_children_vec(
&mut self,
n: Option<Vec<PseudoClassSelectorChildren>>
) -> Option<Vec<PseudoClassSelectorChildren>> { ... }
fn fold_opt_pseudo_element_selector_children_vec(
&mut self,
n: Option<Vec<PseudoElementSelectorChildren>>
) -> Option<Vec<PseudoElementSelectorChildren>> { ... }
fn fold_opt_simple_block(
&mut self,
n: Option<SimpleBlock>
) -> Option<SimpleBlock> { ... }
fn fold_opt_type_selector(
&mut self,
n: Option<TypeSelector>
) -> Option<TypeSelector> { ... }
fn fold_opt_url_modifiers(
&mut self,
n: Option<Vec<UrlModifier>>
) -> Option<Vec<UrlModifier>> { ... }
fn fold_opt_url_value(&mut self, n: Option<UrlValue>) -> Option<UrlValue> { ... }
fn fold_page_margin_rule(&mut self, n: PageMarginRule) -> PageMarginRule { ... }
fn fold_page_rule(&mut self, n: PageRule) -> PageRule { ... }
fn fold_page_selector(&mut self, n: PageSelector) -> PageSelector { ... }
fn fold_page_selector_list(
&mut self,
n: PageSelectorList
) -> PageSelectorList { ... }
fn fold_page_selector_pseudo(
&mut self,
n: PageSelectorPseudo
) -> PageSelectorPseudo { ... }
fn fold_page_selector_pseudos(
&mut self,
n: Vec<PageSelectorPseudo>
) -> Vec<PageSelectorPseudo> { ... }
fn fold_page_selector_type(
&mut self,
n: PageSelectorType
) -> PageSelectorType { ... }
fn fold_page_selectors(&mut self, n: Vec<PageSelector>) -> Vec<PageSelector> { ... }
fn fold_percentage(&mut self, n: Percentage) -> Percentage { ... }
fn fold_property_rule(&mut self, n: PropertyRule) -> PropertyRule { ... }
fn fold_pseudo_class_selector(
&mut self,
n: PseudoClassSelector
) -> PseudoClassSelector { ... }
fn fold_pseudo_class_selector_children(
&mut self,
n: PseudoClassSelectorChildren
) -> PseudoClassSelectorChildren { ... }
fn fold_pseudo_class_selector_children_vec(
&mut self,
n: Vec<PseudoClassSelectorChildren>
) -> Vec<PseudoClassSelectorChildren> { ... }
fn fold_pseudo_element_selector(
&mut self,
n: PseudoElementSelector
) -> PseudoElementSelector { ... }
fn fold_pseudo_element_selector_children(
&mut self,
n: PseudoElementSelectorChildren
) -> PseudoElementSelectorChildren { ... }
fn fold_pseudo_element_selector_children_vec(
&mut self,
n: Vec<PseudoElementSelectorChildren>
) -> Vec<PseudoElementSelectorChildren> { ... }
fn fold_qualified_rule(&mut self, n: QualifiedRule) -> QualifiedRule { ... }
fn fold_ratio(&mut self, n: Ratio) -> Ratio { ... }
fn fold_relative_selector(
&mut self,
n: RelativeSelector
) -> RelativeSelector { ... }
fn fold_relative_selector_list(
&mut self,
n: RelativeSelectorList
) -> RelativeSelectorList { ... }
fn fold_relative_selectors(
&mut self,
n: Vec<RelativeSelector>
) -> Vec<RelativeSelector> { ... }
fn fold_resolution(&mut self, n: Resolution) -> Resolution { ... }
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_span(&mut self, n: Span) -> Span { ... }
fn fold_str(&mut self, n: Str) -> Str { ... }
fn fold_style_block(&mut self, n: StyleBlock) -> StyleBlock { ... }
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_name_selector(&mut self, n: TagNameSelector) -> TagNameSelector { ... }
fn fold_time(&mut self, n: Time) -> Time { ... }
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_unicode_range(&mut self, n: UnicodeRange) -> UnicodeRange { ... }
fn fold_universal_selector(
&mut self,
n: UniversalSelector
) -> UniversalSelector { ... }
fn fold_unknown_at_rule(&mut self, n: UnknownAtRule) -> UnknownAtRule { ... }
fn fold_unknown_dimension(
&mut self,
n: UnknownDimension
) -> UnknownDimension { ... }
fn fold_url(&mut self, n: Url) -> Url { ... }
fn fold_url_modifier(&mut self, n: UrlModifier) -> UrlModifier { ... }
fn fold_url_modifiers(&mut self, n: Vec<UrlModifier>) -> Vec<UrlModifier> { ... }
fn fold_url_value(&mut self, n: UrlValue) -> UrlValue { ... }
fn fold_url_value_raw(&mut self, n: UrlValueRaw) -> UrlValueRaw { ... }
fn fold_viewport_rule(&mut self, n: ViewportRule) -> ViewportRule { ... }
fn fold_wq_name(&mut self, n: WqName) -> WqName { ... }
