Trait swc_css_visit::FoldAstPath

pub trait FoldAstPath {
    // Provided methods
    fn fold_absolute_color_base(
        &mut self,
        node: AbsoluteColorBase,
        __ast_path: &mut AstKindPath,
    ) -> AbsoluteColorBase { ... }
    fn fold_alpha_value(
        &mut self,
        node: AlphaValue,
        __ast_path: &mut AstKindPath,
    ) -> AlphaValue { ... }
    fn fold_an_plus_b(
        &mut self,
        node: AnPlusB,
        __ast_path: &mut AstKindPath,
    ) -> AnPlusB { ... }
    fn fold_an_plus_b_notation(
        &mut self,
        node: AnPlusBNotation,
        __ast_path: &mut AstKindPath,
    ) -> AnPlusBNotation { ... }
    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle { ... }
    fn fold_angle_percentage(
        &mut self,
        node: AnglePercentage,
        __ast_path: &mut AstKindPath,
    ) -> AnglePercentage { ... }
    fn fold_any_namespace(
        &mut self,
        node: AnyNamespace,
        __ast_path: &mut AstKindPath,
    ) -> AnyNamespace { ... }
    fn fold_at_rule(
        &mut self,
        node: AtRule,
        __ast_path: &mut AstKindPath,
    ) -> AtRule { ... }
    fn fold_at_rule_name(
        &mut self,
        node: AtRuleName,
        __ast_path: &mut AstKindPath,
    ) -> AtRuleName { ... }
    fn fold_at_rule_prelude(
        &mut self,
        node: AtRulePrelude,
        __ast_path: &mut AstKindPath,
    ) -> AtRulePrelude { ... }
    fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom { ... }
    fn fold_attribute_selector(
        &mut self,
        node: AttributeSelector,
        __ast_path: &mut AstKindPath,
    ) -> AttributeSelector { ... }
    fn fold_attribute_selector_matcher(
        &mut self,
        node: AttributeSelectorMatcher,
        __ast_path: &mut AstKindPath,
    ) -> AttributeSelectorMatcher { ... }
    fn fold_attribute_selector_matcher_value(
        &mut self,
        node: AttributeSelectorMatcherValue,
        __ast_path: &mut AstKindPath,
    ) -> AttributeSelectorMatcherValue { ... }
    fn fold_attribute_selector_modifier(
        &mut self,
        node: AttributeSelectorModifier,
        __ast_path: &mut AstKindPath,
    ) -> AttributeSelectorModifier { ... }
    fn fold_attribute_selector_value(
        &mut self,
        node: AttributeSelectorValue,
        __ast_path: &mut AstKindPath,
    ) -> AttributeSelectorValue { ... }
    fn fold_bin_op(
        &mut self,
        node: BinOp,
        __ast_path: &mut AstKindPath,
    ) -> BinOp { ... }
    fn fold_calc_operator(
        &mut self,
        node: CalcOperator,
        __ast_path: &mut AstKindPath,
    ) -> CalcOperator { ... }
    fn fold_calc_operator_type(
        &mut self,
        node: CalcOperatorType,
        __ast_path: &mut AstKindPath,
    ) -> CalcOperatorType { ... }
    fn fold_calc_product(
        &mut self,
        node: CalcProduct,
        __ast_path: &mut AstKindPath,
    ) -> CalcProduct { ... }
    fn fold_calc_product_or_operator(
        &mut self,
        node: CalcProductOrOperator,
        __ast_path: &mut AstKindPath,
    ) -> CalcProductOrOperator { ... }
    fn fold_calc_product_or_operators(
        &mut self,
        node: Vec<CalcProductOrOperator>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<CalcProductOrOperator> { ... }
    fn fold_calc_sum(
        &mut self,
        node: CalcSum,
        __ast_path: &mut AstKindPath,
    ) -> CalcSum { ... }
    fn fold_calc_value(
        &mut self,
        node: CalcValue,
        __ast_path: &mut AstKindPath,
    ) -> CalcValue { ... }
    fn fold_calc_value_or_operator(
        &mut self,
        node: CalcValueOrOperator,
        __ast_path: &mut AstKindPath,
    ) -> CalcValueOrOperator { ... }
    fn fold_calc_value_or_operators(
        &mut self,
        node: Vec<CalcValueOrOperator>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<CalcValueOrOperator> { ... }
    fn fold_class_selector(
        &mut self,
        node: ClassSelector,
        __ast_path: &mut AstKindPath,
    ) -> ClassSelector { ... }
    fn fold_cmyk_component(
        &mut self,
        node: CmykComponent,
        __ast_path: &mut AstKindPath,
    ) -> CmykComponent { ... }
    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color { ... }
    fn fold_color_profile_name(
        &mut self,
        node: ColorProfileName,
        __ast_path: &mut AstKindPath,
    ) -> ColorProfileName { ... }
    fn fold_combinator(
        &mut self,
        node: Combinator,
        __ast_path: &mut AstKindPath,
    ) -> Combinator { ... }
    fn fold_combinator_value(
        &mut self,
        node: CombinatorValue,
        __ast_path: &mut AstKindPath,
    ) -> CombinatorValue { ... }
    fn fold_complex_selector(
        &mut self,
        node: ComplexSelector,
        __ast_path: &mut AstKindPath,
    ) -> ComplexSelector { ... }
    fn fold_complex_selector_children(
        &mut self,
        node: ComplexSelectorChildren,
        __ast_path: &mut AstKindPath,
    ) -> ComplexSelectorChildren { ... }
    fn fold_complex_selector_childrens(
        &mut self,
        node: Vec<ComplexSelectorChildren>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ComplexSelectorChildren> { ... }
    fn fold_complex_selectors(
        &mut self,
        node: Vec<ComplexSelector>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ComplexSelector> { ... }
    fn fold_component_value(
        &mut self,
        node: ComponentValue,
        __ast_path: &mut AstKindPath,
    ) -> ComponentValue { ... }
    fn fold_component_values(
        &mut self,
        node: Vec<ComponentValue>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ComponentValue> { ... }
    fn fold_compound_selector(
        &mut self,
        node: CompoundSelector,
        __ast_path: &mut AstKindPath,
    ) -> CompoundSelector { ... }
    fn fold_compound_selector_list(
        &mut self,
        node: CompoundSelectorList,
        __ast_path: &mut AstKindPath,
    ) -> CompoundSelectorList { ... }
    fn fold_compound_selectors(
        &mut self,
        node: Vec<CompoundSelector>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<CompoundSelector> { ... }
    fn fold_container_condition(
        &mut self,
        node: ContainerCondition,
        __ast_path: &mut AstKindPath,
    ) -> ContainerCondition { ... }
    fn fold_container_name(
        &mut self,
        node: ContainerName,
        __ast_path: &mut AstKindPath,
    ) -> ContainerName { ... }
    fn fold_container_query(
        &mut self,
        node: ContainerQuery,
        __ast_path: &mut AstKindPath,
    ) -> ContainerQuery { ... }
    fn fold_container_query_and(
        &mut self,
        node: ContainerQueryAnd,
        __ast_path: &mut AstKindPath,
    ) -> ContainerQueryAnd { ... }
    fn fold_container_query_not(
        &mut self,
        node: ContainerQueryNot,
        __ast_path: &mut AstKindPath,
    ) -> ContainerQueryNot { ... }
    fn fold_container_query_or(
        &mut self,
        node: ContainerQueryOr,
        __ast_path: &mut AstKindPath,
    ) -> ContainerQueryOr { ... }
    fn fold_container_query_type(
        &mut self,
        node: ContainerQueryType,
        __ast_path: &mut AstKindPath,
    ) -> ContainerQueryType { ... }
    fn fold_container_query_types(
        &mut self,
        node: Vec<ContainerQueryType>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ContainerQueryType> { ... }
    fn fold_custom_highlight_name(
        &mut self,
        node: CustomHighlightName,
        __ast_path: &mut AstKindPath,
    ) -> CustomHighlightName { ... }
    fn fold_custom_ident(
        &mut self,
        node: CustomIdent,
        __ast_path: &mut AstKindPath,
    ) -> CustomIdent { ... }
    fn fold_custom_idents(
        &mut self,
        node: Vec<CustomIdent>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<CustomIdent> { ... }
    fn fold_custom_media_query(
        &mut self,
        node: CustomMediaQuery,
        __ast_path: &mut AstKindPath,
    ) -> CustomMediaQuery { ... }
    fn fold_custom_media_query_media_type(
        &mut self,
        node: CustomMediaQueryMediaType,
        __ast_path: &mut AstKindPath,
    ) -> CustomMediaQueryMediaType { ... }
    fn fold_custom_property_name(
        &mut self,
        node: CustomPropertyName,
        __ast_path: &mut AstKindPath,
    ) -> CustomPropertyName { ... }
    fn fold_dashed_ident(
        &mut self,
        node: DashedIdent,
        __ast_path: &mut AstKindPath,
    ) -> DashedIdent { ... }
    fn fold_declaration(
        &mut self,
        node: Declaration,
        __ast_path: &mut AstKindPath,
    ) -> Declaration { ... }
    fn fold_declaration_name(
        &mut self,
        node: DeclarationName,
        __ast_path: &mut AstKindPath,
    ) -> DeclarationName { ... }
    fn fold_declaration_or_at_rule(
        &mut self,
        node: DeclarationOrAtRule,
        __ast_path: &mut AstKindPath,
    ) -> DeclarationOrAtRule { ... }
    fn fold_delimiter(
        &mut self,
        node: Delimiter,
        __ast_path: &mut AstKindPath,
    ) -> Delimiter { ... }
    fn fold_delimiter_value(
        &mut self,
        node: DelimiterValue,
        __ast_path: &mut AstKindPath,
    ) -> DelimiterValue { ... }
    fn fold_dimension(
        &mut self,
        node: Dimension,
        __ast_path: &mut AstKindPath,
    ) -> Dimension { ... }
    fn fold_dimension_token(
        &mut self,
        node: DimensionToken,
        __ast_path: &mut AstKindPath,
    ) -> DimensionToken { ... }
    fn fold_document_prelude(
        &mut self,
        node: DocumentPrelude,
        __ast_path: &mut AstKindPath,
    ) -> DocumentPrelude { ... }
    fn fold_document_prelude_matching_function(
        &mut self,
        node: DocumentPreludeMatchingFunction,
        __ast_path: &mut AstKindPath,
    ) -> DocumentPreludeMatchingFunction { ... }
    fn fold_document_prelude_matching_functions(
        &mut self,
        node: Vec<DocumentPreludeMatchingFunction>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<DocumentPreludeMatchingFunction> { ... }
    fn fold_extension_name(
        &mut self,
        node: ExtensionName,
        __ast_path: &mut AstKindPath,
    ) -> ExtensionName { ... }
    fn fold_family_name(
        &mut self,
        node: FamilyName,
        __ast_path: &mut AstKindPath,
    ) -> FamilyName { ... }
    fn fold_family_names(
        &mut self,
        node: Vec<FamilyName>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<FamilyName> { ... }
    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex { ... }
    fn fold_font_feature_values_prelude(
        &mut self,
        node: FontFeatureValuesPrelude,
        __ast_path: &mut AstKindPath,
    ) -> FontFeatureValuesPrelude { ... }
    fn fold_forgiving_complex_selector(
        &mut self,
        node: ForgivingComplexSelector,
        __ast_path: &mut AstKindPath,
    ) -> ForgivingComplexSelector { ... }
    fn fold_forgiving_complex_selectors(
        &mut self,
        node: Vec<ForgivingComplexSelector>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ForgivingComplexSelector> { ... }
    fn fold_forgiving_relative_selector(
        &mut self,
        node: ForgivingRelativeSelector,
        __ast_path: &mut AstKindPath,
    ) -> ForgivingRelativeSelector { ... }
    fn fold_forgiving_relative_selector_list(
        &mut self,
        node: ForgivingRelativeSelectorList,
        __ast_path: &mut AstKindPath,
    ) -> ForgivingRelativeSelectorList { ... }
    fn fold_forgiving_relative_selectors(
        &mut self,
        node: Vec<ForgivingRelativeSelector>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ForgivingRelativeSelector> { ... }
    fn fold_forgiving_selector_list(
        &mut self,
        node: ForgivingSelectorList,
        __ast_path: &mut AstKindPath,
    ) -> ForgivingSelectorList { ... }
    fn fold_frequency(
        &mut self,
        node: Frequency,
        __ast_path: &mut AstKindPath,
    ) -> Frequency { ... }
    fn fold_frequency_percentage(
        &mut self,
        node: FrequencyPercentage,
        __ast_path: &mut AstKindPath,
    ) -> FrequencyPercentage { ... }
    fn fold_function(
        &mut self,
        node: Function,
        __ast_path: &mut AstKindPath,
    ) -> Function { ... }
    fn fold_function_name(
        &mut self,
        node: FunctionName,
        __ast_path: &mut AstKindPath,
    ) -> FunctionName { ... }
    fn fold_general_enclosed(
        &mut self,
        node: GeneralEnclosed,
        __ast_path: &mut AstKindPath,
    ) -> GeneralEnclosed { ... }
    fn fold_hex_color(
        &mut self,
        node: HexColor,
        __ast_path: &mut AstKindPath,
    ) -> HexColor { ... }
    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue { ... }
    fn fold_id_selector(
        &mut self,
        node: IdSelector,
        __ast_path: &mut AstKindPath,
    ) -> IdSelector { ... }
    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident { ... }
    fn fold_idents(
        &mut self,
        node: Vec<Ident>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Ident> { ... }
    fn fold_import_conditions(
        &mut self,
        node: ImportConditions,
        __ast_path: &mut AstKindPath,
    ) -> ImportConditions { ... }
    fn fold_import_href(
        &mut self,
        node: ImportHref,
        __ast_path: &mut AstKindPath,
    ) -> ImportHref { ... }
    fn fold_import_layer_name(
        &mut self,
        node: ImportLayerName,
        __ast_path: &mut AstKindPath,
    ) -> ImportLayerName { ... }
    fn fold_import_prelude(
        &mut self,
        node: ImportPrelude,
        __ast_path: &mut AstKindPath,
    ) -> ImportPrelude { ... }
    fn fold_important_flag(
        &mut self,
        node: ImportantFlag,
        __ast_path: &mut AstKindPath,
    ) -> ImportantFlag { ... }
    fn fold_integer(
        &mut self,
        node: Integer,
        __ast_path: &mut AstKindPath,
    ) -> Integer { ... }
    fn fold_keyframe_block(
        &mut self,
        node: KeyframeBlock,
        __ast_path: &mut AstKindPath,
    ) -> KeyframeBlock { ... }
    fn fold_keyframe_selector(
        &mut self,
        node: KeyframeSelector,
        __ast_path: &mut AstKindPath,
    ) -> KeyframeSelector { ... }
    fn fold_keyframe_selectors(
        &mut self,
        node: Vec<KeyframeSelector>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<KeyframeSelector> { ... }
    fn fold_keyframes_name(
        &mut self,
        node: KeyframesName,
        __ast_path: &mut AstKindPath,
    ) -> KeyframesName { ... }
    fn fold_keyframes_pseudo_function(
        &mut self,
        node: KeyframesPseudoFunction,
        __ast_path: &mut AstKindPath,
    ) -> KeyframesPseudoFunction { ... }
    fn fold_keyframes_pseudo_prefix(
        &mut self,
        node: KeyframesPseudoPrefix,
        __ast_path: &mut AstKindPath,
    ) -> KeyframesPseudoPrefix { ... }
    fn fold_layer_name(
        &mut self,
        node: LayerName,
        __ast_path: &mut AstKindPath,
    ) -> LayerName { ... }
    fn fold_layer_name_list(
        &mut self,
        node: LayerNameList,
        __ast_path: &mut AstKindPath,
    ) -> LayerNameList { ... }
    fn fold_layer_names(
        &mut self,
        node: Vec<LayerName>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<LayerName> { ... }
    fn fold_layer_prelude(
        &mut self,
        node: LayerPrelude,
        __ast_path: &mut AstKindPath,
    ) -> LayerPrelude { ... }
    fn fold_length(
        &mut self,
        node: Length,
        __ast_path: &mut AstKindPath,
    ) -> Length { ... }
    fn fold_length_percentage(
        &mut self,
        node: LengthPercentage,
        __ast_path: &mut AstKindPath,
    ) -> LengthPercentage { ... }
    fn fold_list_of_component_values(
        &mut self,
        node: ListOfComponentValues,
        __ast_path: &mut AstKindPath,
    ) -> ListOfComponentValues { ... }
    fn fold_media_and(
        &mut self,
        node: MediaAnd,
        __ast_path: &mut AstKindPath,
    ) -> MediaAnd { ... }
    fn fold_media_condition(
        &mut self,
        node: MediaCondition,
        __ast_path: &mut AstKindPath,
    ) -> MediaCondition { ... }
    fn fold_media_condition_all_type(
        &mut self,
        node: MediaConditionAllType,
        __ast_path: &mut AstKindPath,
    ) -> MediaConditionAllType { ... }
    fn fold_media_condition_all_types(
        &mut self,
        node: Vec<MediaConditionAllType>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<MediaConditionAllType> { ... }
    fn fold_media_condition_type(
        &mut self,
        node: MediaConditionType,
        __ast_path: &mut AstKindPath,
    ) -> MediaConditionType { ... }
    fn fold_media_condition_without_or(
        &mut self,
        node: MediaConditionWithoutOr,
        __ast_path: &mut AstKindPath,
    ) -> MediaConditionWithoutOr { ... }
    fn fold_media_condition_without_or_type(
        &mut self,
        node: MediaConditionWithoutOrType,
        __ast_path: &mut AstKindPath,
    ) -> MediaConditionWithoutOrType { ... }
    fn fold_media_condition_without_or_types(
        &mut self,
        node: Vec<MediaConditionWithoutOrType>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<MediaConditionWithoutOrType> { ... }
    fn fold_media_feature(
        &mut self,
        node: MediaFeature,
        __ast_path: &mut AstKindPath,
    ) -> MediaFeature { ... }
    fn fold_media_feature_boolean(
        &mut self,
        node: MediaFeatureBoolean,
        __ast_path: &mut AstKindPath,
    ) -> MediaFeatureBoolean { ... }
    fn fold_media_feature_name(
        &mut self,
        node: MediaFeatureName,
        __ast_path: &mut AstKindPath,
    ) -> MediaFeatureName { ... }
    fn fold_media_feature_plain(
        &mut self,
        node: MediaFeaturePlain,
        __ast_path: &mut AstKindPath,
    ) -> MediaFeaturePlain { ... }
    fn fold_media_feature_range(
        &mut self,
        node: MediaFeatureRange,
        __ast_path: &mut AstKindPath,
    ) -> MediaFeatureRange { ... }
    fn fold_media_feature_range_comparison(
        &mut self,
        node: MediaFeatureRangeComparison,
        __ast_path: &mut AstKindPath,
    ) -> MediaFeatureRangeComparison { ... }
    fn fold_media_feature_range_interval(
        &mut self,
        node: MediaFeatureRangeInterval,
        __ast_path: &mut AstKindPath,
    ) -> MediaFeatureRangeInterval { ... }
    fn fold_media_feature_value(
        &mut self,
        node: MediaFeatureValue,
        __ast_path: &mut AstKindPath,
    ) -> MediaFeatureValue { ... }
    fn fold_media_in_parens(
        &mut self,
        node: MediaInParens,
        __ast_path: &mut AstKindPath,
    ) -> MediaInParens { ... }
    fn fold_media_not(
        &mut self,
        node: MediaNot,
        __ast_path: &mut AstKindPath,
    ) -> MediaNot { ... }
    fn fold_media_or(
        &mut self,
        node: MediaOr,
        __ast_path: &mut AstKindPath,
    ) -> MediaOr { ... }
    fn fold_media_query(
        &mut self,
        node: MediaQuery,
        __ast_path: &mut AstKindPath,
    ) -> MediaQuery { ... }
    fn fold_media_query_list(
        &mut self,
        node: MediaQueryList,
        __ast_path: &mut AstKindPath,
    ) -> MediaQueryList { ... }
    fn fold_media_querys(
        &mut self,
        node: Vec<MediaQuery>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<MediaQuery> { ... }
    fn fold_media_type(
        &mut self,
        node: MediaType,
        __ast_path: &mut AstKindPath,
    ) -> MediaType { ... }
    fn fold_named_namespace(
        &mut self,
        node: NamedNamespace,
        __ast_path: &mut AstKindPath,
    ) -> NamedNamespace { ... }
    fn fold_namespace(
        &mut self,
        node: Namespace,
        __ast_path: &mut AstKindPath,
    ) -> Namespace { ... }
    fn fold_namespace_prefix(
        &mut self,
        node: NamespacePrefix,
        __ast_path: &mut AstKindPath,
    ) -> NamespacePrefix { ... }
    fn fold_namespace_prelude(
        &mut self,
        node: NamespacePrelude,
        __ast_path: &mut AstKindPath,
    ) -> NamespacePrelude { ... }
    fn fold_namespace_prelude_uri(
        &mut self,
        node: NamespacePreludeUri,
        __ast_path: &mut AstKindPath,
    ) -> NamespacePreludeUri { ... }
    fn fold_nesting_selector(
        &mut self,
        node: NestingSelector,
        __ast_path: &mut AstKindPath,
    ) -> NestingSelector { ... }
    fn fold_number(
        &mut self,
        node: Number,
        __ast_path: &mut AstKindPath,
    ) -> Number { ... }
    fn fold_number_type(
        &mut self,
        node: NumberType,
        __ast_path: &mut AstKindPath,
    ) -> NumberType { ... }
    fn fold_opt_at_rule_prelude(
        &mut self,
        node: Option<Box<AtRulePrelude>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<AtRulePrelude>> { ... }
    fn fold_opt_atom(
        &mut self,
        node: Option<Atom>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Atom> { ... }
    fn fold_opt_attribute_selector_matcher(
        &mut self,
        node: Option<AttributeSelectorMatcher>,
        __ast_path: &mut AstKindPath,
    ) -> Option<AttributeSelectorMatcher> { ... }
    fn fold_opt_attribute_selector_modifier(
        &mut self,
        node: Option<AttributeSelectorModifier>,
        __ast_path: &mut AstKindPath,
    ) -> Option<AttributeSelectorModifier> { ... }
    fn fold_opt_attribute_selector_value(
        &mut self,
        node: Option<AttributeSelectorValue>,
        __ast_path: &mut AstKindPath,
    ) -> Option<AttributeSelectorValue> { ... }
    fn fold_opt_combinator(
        &mut self,
        node: Option<Combinator>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Combinator> { ... }
    fn fold_opt_container_name(
        &mut self,
        node: Option<ContainerName>,
        __ast_path: &mut AstKindPath,
    ) -> Option<ContainerName> { ... }
    fn fold_opt_forgiving_selector_list(
        &mut self,
        node: Option<ForgivingSelectorList>,
        __ast_path: &mut AstKindPath,
    ) -> Option<ForgivingSelectorList> { ... }
    fn fold_opt_function(
        &mut self,
        node: Option<Box<Function>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<Function>> { ... }
    fn fold_opt_ident(
        &mut self,
        node: Option<Ident>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Ident> { ... }
    fn fold_opt_import_conditions(
        &mut self,
        node: Option<Box<ImportConditions>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<ImportConditions>> { ... }
    fn fold_opt_import_layer_name(
        &mut self,
        node: Option<Box<ImportLayerName>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<ImportLayerName>> { ... }
    fn fold_opt_important_flag(
        &mut self,
        node: Option<ImportantFlag>,
        __ast_path: &mut AstKindPath,
    ) -> Option<ImportantFlag> { ... }
    fn fold_opt_media_condition_type(
        &mut self,
        node: Option<Box<MediaConditionType>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<MediaConditionType>> { ... }
    fn fold_opt_media_query_list(
        &mut self,
        node: Option<Box<MediaQueryList>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<MediaQueryList>> { ... }
    fn fold_opt_media_type(
        &mut self,
        node: Option<MediaType>,
        __ast_path: &mut AstKindPath,
    ) -> Option<MediaType> { ... }
    fn fold_opt_namespace(
        &mut self,
        node: Option<Namespace>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Namespace> { ... }
    fn fold_opt_namespace_prefix(
        &mut self,
        node: Option<NamespacePrefix>,
        __ast_path: &mut AstKindPath,
    ) -> Option<NamespacePrefix> { ... }
    fn fold_opt_nesting_selector(
        &mut self,
        node: Option<NestingSelector>,
        __ast_path: &mut AstKindPath,
    ) -> Option<NestingSelector> { ... }
    fn fold_opt_number(
        &mut self,
        node: Option<Number>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Number> { ... }
    fn fold_opt_page_selector_pseudos(
        &mut self,
        node: Option<Vec<PageSelectorPseudo>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Vec<PageSelectorPseudo>> { ... }
    fn fold_opt_page_selector_type(
        &mut self,
        node: Option<PageSelectorType>,
        __ast_path: &mut AstKindPath,
    ) -> Option<PageSelectorType> { ... }
    fn fold_opt_pseudo_class_selector_childrens(
        &mut self,
        node: Option<Vec<PseudoClassSelectorChildren>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Vec<PseudoClassSelectorChildren>> { ... }
    fn fold_opt_pseudo_element_selector_childrens(
        &mut self,
        node: Option<Vec<PseudoElementSelectorChildren>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Vec<PseudoElementSelectorChildren>> { ... }
    fn fold_opt_simple_block(
        &mut self,
        node: Option<SimpleBlock>,
        __ast_path: &mut AstKindPath,
    ) -> Option<SimpleBlock> { ... }
    fn fold_opt_type_selector(
        &mut self,
        node: Option<Box<TypeSelector>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<TypeSelector>> { ... }
    fn fold_opt_url_modifiers(
        &mut self,
        node: Option<Vec<UrlModifier>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Vec<UrlModifier>> { ... }
    fn fold_opt_url_value(
        &mut self,
        node: Option<Box<UrlValue>>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Box<UrlValue>> { ... }
    fn fold_page_selector(
        &mut self,
        node: PageSelector,
        __ast_path: &mut AstKindPath,
    ) -> PageSelector { ... }
    fn fold_page_selector_list(
        &mut self,
        node: PageSelectorList,
        __ast_path: &mut AstKindPath,
    ) -> PageSelectorList { ... }
    fn fold_page_selector_pseudo(
        &mut self,
        node: PageSelectorPseudo,
        __ast_path: &mut AstKindPath,
    ) -> PageSelectorPseudo { ... }
    fn fold_page_selector_pseudos(
        &mut self,
        node: Vec<PageSelectorPseudo>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<PageSelectorPseudo> { ... }
    fn fold_page_selector_type(
        &mut self,
        node: PageSelectorType,
        __ast_path: &mut AstKindPath,
    ) -> PageSelectorType { ... }
    fn fold_page_selectors(
        &mut self,
        node: Vec<PageSelector>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<PageSelector> { ... }
    fn fold_percentage(
        &mut self,
        node: Percentage,
        __ast_path: &mut AstKindPath,
    ) -> Percentage { ... }
    fn fold_pseudo_class_selector(
        &mut self,
        node: PseudoClassSelector,
        __ast_path: &mut AstKindPath,
    ) -> PseudoClassSelector { ... }
    fn fold_pseudo_class_selector_children(
        &mut self,
        node: PseudoClassSelectorChildren,
        __ast_path: &mut AstKindPath,
    ) -> PseudoClassSelectorChildren { ... }
    fn fold_pseudo_class_selector_childrens(
        &mut self,
        node: Vec<PseudoClassSelectorChildren>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<PseudoClassSelectorChildren> { ... }
    fn fold_pseudo_element_selector(
        &mut self,
        node: PseudoElementSelector,
        __ast_path: &mut AstKindPath,
    ) -> PseudoElementSelector { ... }
    fn fold_pseudo_element_selector_children(
        &mut self,
        node: PseudoElementSelectorChildren,
        __ast_path: &mut AstKindPath,
    ) -> PseudoElementSelectorChildren { ... }
    fn fold_pseudo_element_selector_childrens(
        &mut self,
        node: Vec<PseudoElementSelectorChildren>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<PseudoElementSelectorChildren> { ... }
    fn fold_qualified_rule(
        &mut self,
        node: QualifiedRule,
        __ast_path: &mut AstKindPath,
    ) -> QualifiedRule { ... }
    fn fold_qualified_rule_prelude(
        &mut self,
        node: QualifiedRulePrelude,
        __ast_path: &mut AstKindPath,
    ) -> QualifiedRulePrelude { ... }
    fn fold_query_in_parens(
        &mut self,
        node: QueryInParens,
        __ast_path: &mut AstKindPath,
    ) -> QueryInParens { ... }
    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio { ... }
    fn fold_relative_selector(
        &mut self,
        node: RelativeSelector,
        __ast_path: &mut AstKindPath,
    ) -> RelativeSelector { ... }
    fn fold_relative_selector_list(
        &mut self,
        node: RelativeSelectorList,
        __ast_path: &mut AstKindPath,
    ) -> RelativeSelectorList { ... }
    fn fold_relative_selectors(
        &mut self,
        node: Vec<RelativeSelector>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<RelativeSelector> { ... }
    fn fold_resolution(
        &mut self,
        node: Resolution,
        __ast_path: &mut AstKindPath,
    ) -> Resolution { ... }
    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule { ... }
    fn fold_rules(
        &mut self,
        node: Vec<Rule>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Rule> { ... }
    fn fold_scope_range(
        &mut self,
        node: ScopeRange,
        __ast_path: &mut AstKindPath,
    ) -> ScopeRange { ... }
    fn fold_selector_list(
        &mut self,
        node: SelectorList,
        __ast_path: &mut AstKindPath,
    ) -> SelectorList { ... }
    fn fold_sequence_of_custom_idents(
        &mut self,
        node: SequenceOfCustomIdents,
        __ast_path: &mut AstKindPath,
    ) -> SequenceOfCustomIdents { ... }
    fn fold_simple_block(
        &mut self,
        node: SimpleBlock,
        __ast_path: &mut AstKindPath,
    ) -> SimpleBlock { ... }
    fn fold_size_feature(
        &mut self,
        node: SizeFeature,
        __ast_path: &mut AstKindPath,
    ) -> SizeFeature { ... }
    fn fold_size_feature_boolean(
        &mut self,
        node: SizeFeatureBoolean,
        __ast_path: &mut AstKindPath,
    ) -> SizeFeatureBoolean { ... }
    fn fold_size_feature_name(
        &mut self,
        node: SizeFeatureName,
        __ast_path: &mut AstKindPath,
    ) -> SizeFeatureName { ... }
    fn fold_size_feature_plain(
        &mut self,
        node: SizeFeaturePlain,
        __ast_path: &mut AstKindPath,
    ) -> SizeFeaturePlain { ... }
    fn fold_size_feature_range(
        &mut self,
        node: SizeFeatureRange,
        __ast_path: &mut AstKindPath,
    ) -> SizeFeatureRange { ... }
    fn fold_size_feature_range_comparison(
        &mut self,
        node: SizeFeatureRangeComparison,
        __ast_path: &mut AstKindPath,
    ) -> SizeFeatureRangeComparison { ... }
    fn fold_size_feature_range_interval(
        &mut self,
        node: SizeFeatureRangeInterval,
        __ast_path: &mut AstKindPath,
    ) -> SizeFeatureRangeInterval { ... }
    fn fold_size_feature_value(
        &mut self,
        node: SizeFeatureValue,
        __ast_path: &mut AstKindPath,
    ) -> SizeFeatureValue { ... }
    fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span { ... }
    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str { ... }
    fn fold_style_block(
        &mut self,
        node: StyleBlock,
        __ast_path: &mut AstKindPath,
    ) -> StyleBlock { ... }
    fn fold_stylesheet(
        &mut self,
        node: Stylesheet,
        __ast_path: &mut AstKindPath,
    ) -> Stylesheet { ... }
    fn fold_subclass_selector(
        &mut self,
        node: SubclassSelector,
        __ast_path: &mut AstKindPath,
    ) -> SubclassSelector { ... }
    fn fold_subclass_selectors(
        &mut self,
        node: Vec<SubclassSelector>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<SubclassSelector> { ... }
    fn fold_supports_and(
        &mut self,
        node: SupportsAnd,
        __ast_path: &mut AstKindPath,
    ) -> SupportsAnd { ... }
    fn fold_supports_condition(
        &mut self,
        node: SupportsCondition,
        __ast_path: &mut AstKindPath,
    ) -> SupportsCondition { ... }
    fn fold_supports_condition_type(
        &mut self,
        node: SupportsConditionType,
        __ast_path: &mut AstKindPath,
    ) -> SupportsConditionType { ... }
    fn fold_supports_condition_types(
        &mut self,
        node: Vec<SupportsConditionType>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<SupportsConditionType> { ... }
    fn fold_supports_feature(
        &mut self,
        node: SupportsFeature,
        __ast_path: &mut AstKindPath,
    ) -> SupportsFeature { ... }
    fn fold_supports_in_parens(
        &mut self,
        node: SupportsInParens,
        __ast_path: &mut AstKindPath,
    ) -> SupportsInParens { ... }
    fn fold_supports_not(
        &mut self,
        node: SupportsNot,
        __ast_path: &mut AstKindPath,
    ) -> SupportsNot { ... }
    fn fold_supports_or(
        &mut self,
        node: SupportsOr,
        __ast_path: &mut AstKindPath,
    ) -> SupportsOr { ... }
    fn fold_tag_name_selector(
        &mut self,
        node: TagNameSelector,
        __ast_path: &mut AstKindPath,
    ) -> TagNameSelector { ... }
    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time { ... }
    fn fold_time_percentage(
        &mut self,
        node: TimePercentage,
        __ast_path: &mut AstKindPath,
    ) -> TimePercentage { ... }
    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token { ... }
    fn fold_token_and_span(
        &mut self,
        node: TokenAndSpan,
        __ast_path: &mut AstKindPath,
    ) -> TokenAndSpan { ... }
    fn fold_type_selector(
        &mut self,
        node: TypeSelector,
        __ast_path: &mut AstKindPath,
    ) -> TypeSelector { ... }
    fn fold_unicode_range(
        &mut self,
        node: UnicodeRange,
        __ast_path: &mut AstKindPath,
    ) -> UnicodeRange { ... }
    fn fold_universal_selector(
        &mut self,
        node: UniversalSelector,
        __ast_path: &mut AstKindPath,
    ) -> UniversalSelector { ... }
    fn fold_unknown_dimension(
        &mut self,
        node: UnknownDimension,
        __ast_path: &mut AstKindPath,
    ) -> UnknownDimension { ... }
    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url { ... }
    fn fold_url_key_value(
        &mut self,
        node: UrlKeyValue,
        __ast_path: &mut AstKindPath,
    ) -> UrlKeyValue { ... }
    fn fold_url_modifier(
        &mut self,
        node: UrlModifier,
        __ast_path: &mut AstKindPath,
    ) -> UrlModifier { ... }
    fn fold_url_modifiers(
        &mut self,
        node: Vec<UrlModifier>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<UrlModifier> { ... }
    fn fold_url_value(
        &mut self,
        node: UrlValue,
        __ast_path: &mut AstKindPath,
    ) -> UrlValue { ... }
    fn fold_url_value_raw(
        &mut self,
        node: UrlValueRaw,
        __ast_path: &mut AstKindPath,
    ) -> UrlValueRaw { ... }
    fn fold_wq_name(
        &mut self,
        node: WqName,
        __ast_path: &mut AstKindPath,
    ) -> WqName { ... }
}

Available on crate feature path only.

A visitor trait for traversing the AST.

Provided Methods

fn fold_absolute_color_base( &mut self, node: AbsoluteColorBase, __ast_path: &mut AstKindPath, ) -> AbsoluteColorBase

Visit a node of type AbsoluteColorBase.

By default, this method calls [AbsoluteColorBase::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_alpha_value( &mut self, node: AlphaValue, __ast_path: &mut AstKindPath, ) -> AlphaValue

Visit a node of type AlphaValue.

By default, this method calls [AlphaValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_an_plus_b( &mut self, node: AnPlusB, __ast_path: &mut AstKindPath, ) -> AnPlusB

Visit a node of type AnPlusB.

By default, this method calls [AnPlusB::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_an_plus_b_notation( &mut self, node: AnPlusBNotation, __ast_path: &mut AstKindPath, ) -> AnPlusBNotation

Visit a node of type AnPlusBNotation.

By default, this method calls [AnPlusBNotation::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle

Visit a node of type Angle.

By default, this method calls [Angle::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_angle_percentage( &mut self, node: AnglePercentage, __ast_path: &mut AstKindPath, ) -> AnglePercentage

Visit a node of type AnglePercentage.

By default, this method calls [AnglePercentage::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_any_namespace( &mut self, node: AnyNamespace, __ast_path: &mut AstKindPath, ) -> AnyNamespace

Visit a node of type AnyNamespace.

By default, this method calls [AnyNamespace::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule

Visit a node of type AtRule.

By default, this method calls [AtRule::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_at_rule_name( &mut self, node: AtRuleName, __ast_path: &mut AstKindPath, ) -> AtRuleName

Visit a node of type AtRuleName.

By default, this method calls [AtRuleName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_at_rule_prelude( &mut self, node: AtRulePrelude, __ast_path: &mut AstKindPath, ) -> AtRulePrelude

Visit a node of type AtRulePrelude.

By default, this method calls [AtRulePrelude::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

Visit a node of type swc_atoms :: Atom.

By default, this method calls [swc_atoms :: Atom::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_attribute_selector( &mut self, node: AttributeSelector, __ast_path: &mut AstKindPath, ) -> AttributeSelector

Visit a node of type AttributeSelector.

By default, this method calls [AttributeSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_attribute_selector_matcher( &mut self, node: AttributeSelectorMatcher, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcher

Visit a node of type AttributeSelectorMatcher.

By default, this method calls [AttributeSelectorMatcher::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_attribute_selector_matcher_value( &mut self, node: AttributeSelectorMatcherValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcherValue

Visit a node of type AttributeSelectorMatcherValue.

By default, this method calls [AttributeSelectorMatcherValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_attribute_selector_modifier( &mut self, node: AttributeSelectorModifier, __ast_path: &mut AstKindPath, ) -> AttributeSelectorModifier

Visit a node of type AttributeSelectorModifier.

By default, this method calls [AttributeSelectorModifier::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_attribute_selector_value( &mut self, node: AttributeSelectorValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorValue

Visit a node of type AttributeSelectorValue.

By default, this method calls [AttributeSelectorValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp

Visit a node of type BinOp.

By default, this method calls [BinOp::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_calc_operator( &mut self, node: CalcOperator, __ast_path: &mut AstKindPath, ) -> CalcOperator

Visit a node of type CalcOperator.

By default, this method calls [CalcOperator::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_calc_operator_type( &mut self, node: CalcOperatorType, __ast_path: &mut AstKindPath, ) -> CalcOperatorType

Visit a node of type CalcOperatorType.

By default, this method calls [CalcOperatorType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_calc_product( &mut self, node: CalcProduct, __ast_path: &mut AstKindPath, ) -> CalcProduct

Visit a node of type CalcProduct.

By default, this method calls [CalcProduct::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_calc_product_or_operator( &mut self, node: CalcProductOrOperator, __ast_path: &mut AstKindPath, ) -> CalcProductOrOperator

Visit a node of type CalcProductOrOperator.

By default, this method calls [CalcProductOrOperator::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_calc_product_or_operators( &mut self, node: Vec<CalcProductOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcProductOrOperator>

Visit a node of type Vec < CalcProductOrOperator >.

By default, this method calls [Vec < CalcProductOrOperator >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_calc_sum( &mut self, node: CalcSum, __ast_path: &mut AstKindPath, ) -> CalcSum

Visit a node of type CalcSum.

By default, this method calls [CalcSum::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_calc_value( &mut self, node: CalcValue, __ast_path: &mut AstKindPath, ) -> CalcValue

Visit a node of type CalcValue.

By default, this method calls [CalcValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_calc_value_or_operator( &mut self, node: CalcValueOrOperator, __ast_path: &mut AstKindPath, ) -> CalcValueOrOperator

Visit a node of type CalcValueOrOperator.

By default, this method calls [CalcValueOrOperator::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_calc_value_or_operators( &mut self, node: Vec<CalcValueOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcValueOrOperator>

Visit a node of type Vec < CalcValueOrOperator >.

By default, this method calls [Vec < CalcValueOrOperator >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_class_selector( &mut self, node: ClassSelector, __ast_path: &mut AstKindPath, ) -> ClassSelector

Visit a node of type ClassSelector.

By default, this method calls [ClassSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_cmyk_component( &mut self, node: CmykComponent, __ast_path: &mut AstKindPath, ) -> CmykComponent

Visit a node of type CmykComponent.

By default, this method calls [CmykComponent::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color

Visit a node of type Color.

By default, this method calls [Color::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_color_profile_name( &mut self, node: ColorProfileName, __ast_path: &mut AstKindPath, ) -> ColorProfileName

Visit a node of type ColorProfileName.

By default, this method calls [ColorProfileName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_combinator( &mut self, node: Combinator, __ast_path: &mut AstKindPath, ) -> Combinator

Visit a node of type Combinator.

By default, this method calls [Combinator::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_combinator_value( &mut self, node: CombinatorValue, __ast_path: &mut AstKindPath, ) -> CombinatorValue

Visit a node of type CombinatorValue.

By default, this method calls [CombinatorValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_complex_selector( &mut self, node: ComplexSelector, __ast_path: &mut AstKindPath, ) -> ComplexSelector

Visit a node of type ComplexSelector.

By default, this method calls [ComplexSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_complex_selector_children( &mut self, node: ComplexSelectorChildren, __ast_path: &mut AstKindPath, ) -> ComplexSelectorChildren

Visit a node of type ComplexSelectorChildren.

By default, this method calls [ComplexSelectorChildren::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_complex_selector_childrens( &mut self, node: Vec<ComplexSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelectorChildren>

Visit a node of type Vec < ComplexSelectorChildren >.

By default, this method calls [Vec < ComplexSelectorChildren >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_complex_selectors( &mut self, node: Vec<ComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelector>

Visit a node of type Vec < ComplexSelector >.

By default, this method calls [Vec < ComplexSelector >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_component_value( &mut self, node: ComponentValue, __ast_path: &mut AstKindPath, ) -> ComponentValue

Visit a node of type ComponentValue.

By default, this method calls [ComponentValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_component_values( &mut self, node: Vec<ComponentValue>, __ast_path: &mut AstKindPath, ) -> Vec<ComponentValue>

Visit a node of type Vec < ComponentValue >.

By default, this method calls [Vec < ComponentValue >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_compound_selector( &mut self, node: CompoundSelector, __ast_path: &mut AstKindPath, ) -> CompoundSelector

Visit a node of type CompoundSelector.

By default, this method calls [CompoundSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_compound_selector_list( &mut self, node: CompoundSelectorList, __ast_path: &mut AstKindPath, ) -> CompoundSelectorList

Visit a node of type CompoundSelectorList.

By default, this method calls [CompoundSelectorList::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_compound_selectors( &mut self, node: Vec<CompoundSelector>, __ast_path: &mut AstKindPath, ) -> Vec<CompoundSelector>

Visit a node of type Vec < CompoundSelector >.

By default, this method calls [Vec < CompoundSelector >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_container_condition( &mut self, node: ContainerCondition, __ast_path: &mut AstKindPath, ) -> ContainerCondition

Visit a node of type ContainerCondition.

By default, this method calls [ContainerCondition::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_container_name( &mut self, node: ContainerName, __ast_path: &mut AstKindPath, ) -> ContainerName

Visit a node of type ContainerName.

By default, this method calls [ContainerName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_container_query( &mut self, node: ContainerQuery, __ast_path: &mut AstKindPath, ) -> ContainerQuery

Visit a node of type ContainerQuery.

By default, this method calls [ContainerQuery::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_container_query_and( &mut self, node: ContainerQueryAnd, __ast_path: &mut AstKindPath, ) -> ContainerQueryAnd

Visit a node of type ContainerQueryAnd.

By default, this method calls [ContainerQueryAnd::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_container_query_not( &mut self, node: ContainerQueryNot, __ast_path: &mut AstKindPath, ) -> ContainerQueryNot

Visit a node of type ContainerQueryNot.

By default, this method calls [ContainerQueryNot::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_container_query_or( &mut self, node: ContainerQueryOr, __ast_path: &mut AstKindPath, ) -> ContainerQueryOr

Visit a node of type ContainerQueryOr.

By default, this method calls [ContainerQueryOr::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_container_query_type( &mut self, node: ContainerQueryType, __ast_path: &mut AstKindPath, ) -> ContainerQueryType

Visit a node of type ContainerQueryType.

By default, this method calls [ContainerQueryType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_container_query_types( &mut self, node: Vec<ContainerQueryType>, __ast_path: &mut AstKindPath, ) -> Vec<ContainerQueryType>

Visit a node of type Vec < ContainerQueryType >.

By default, this method calls [Vec < ContainerQueryType >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_custom_highlight_name( &mut self, node: CustomHighlightName, __ast_path: &mut AstKindPath, ) -> CustomHighlightName

Visit a node of type CustomHighlightName.

By default, this method calls [CustomHighlightName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_custom_ident( &mut self, node: CustomIdent, __ast_path: &mut AstKindPath, ) -> CustomIdent

Visit a node of type CustomIdent.

By default, this method calls [CustomIdent::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_custom_idents( &mut self, node: Vec<CustomIdent>, __ast_path: &mut AstKindPath, ) -> Vec<CustomIdent>

Visit a node of type Vec < CustomIdent >.

By default, this method calls [Vec < CustomIdent >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_custom_media_query( &mut self, node: CustomMediaQuery, __ast_path: &mut AstKindPath, ) -> CustomMediaQuery

Visit a node of type CustomMediaQuery.

By default, this method calls [CustomMediaQuery::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_custom_media_query_media_type( &mut self, node: CustomMediaQueryMediaType, __ast_path: &mut AstKindPath, ) -> CustomMediaQueryMediaType

Visit a node of type CustomMediaQueryMediaType.

By default, this method calls [CustomMediaQueryMediaType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_custom_property_name( &mut self, node: CustomPropertyName, __ast_path: &mut AstKindPath, ) -> CustomPropertyName

Visit a node of type CustomPropertyName.

By default, this method calls [CustomPropertyName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_dashed_ident( &mut self, node: DashedIdent, __ast_path: &mut AstKindPath, ) -> DashedIdent

Visit a node of type DashedIdent.

By default, this method calls [DashedIdent::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_declaration( &mut self, node: Declaration, __ast_path: &mut AstKindPath, ) -> Declaration

Visit a node of type Declaration.

By default, this method calls [Declaration::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_declaration_name( &mut self, node: DeclarationName, __ast_path: &mut AstKindPath, ) -> DeclarationName

Visit a node of type DeclarationName.

By default, this method calls [DeclarationName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_declaration_or_at_rule( &mut self, node: DeclarationOrAtRule, __ast_path: &mut AstKindPath, ) -> DeclarationOrAtRule

Visit a node of type DeclarationOrAtRule.

By default, this method calls [DeclarationOrAtRule::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_delimiter( &mut self, node: Delimiter, __ast_path: &mut AstKindPath, ) -> Delimiter

Visit a node of type Delimiter.

By default, this method calls [Delimiter::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_delimiter_value( &mut self, node: DelimiterValue, __ast_path: &mut AstKindPath, ) -> DelimiterValue

Visit a node of type DelimiterValue.

By default, this method calls [DelimiterValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_dimension( &mut self, node: Dimension, __ast_path: &mut AstKindPath, ) -> Dimension

Visit a node of type Dimension.

By default, this method calls [Dimension::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_dimension_token( &mut self, node: DimensionToken, __ast_path: &mut AstKindPath, ) -> DimensionToken

Visit a node of type DimensionToken.

By default, this method calls [DimensionToken::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_document_prelude( &mut self, node: DocumentPrelude, __ast_path: &mut AstKindPath, ) -> DocumentPrelude

Visit a node of type DocumentPrelude.

By default, this method calls [DocumentPrelude::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_document_prelude_matching_function( &mut self, node: DocumentPreludeMatchingFunction, __ast_path: &mut AstKindPath, ) -> DocumentPreludeMatchingFunction

Visit a node of type DocumentPreludeMatchingFunction.

By default, this method calls [DocumentPreludeMatchingFunction::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_document_prelude_matching_functions( &mut self, node: Vec<DocumentPreludeMatchingFunction>, __ast_path: &mut AstKindPath, ) -> Vec<DocumentPreludeMatchingFunction>

Visit a node of type Vec < DocumentPreludeMatchingFunction >.

By default, this method calls [Vec < DocumentPreludeMatchingFunction >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_extension_name( &mut self, node: ExtensionName, __ast_path: &mut AstKindPath, ) -> ExtensionName

Visit a node of type ExtensionName.

By default, this method calls [ExtensionName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_family_name( &mut self, node: FamilyName, __ast_path: &mut AstKindPath, ) -> FamilyName

Visit a node of type FamilyName.

By default, this method calls [FamilyName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_family_names( &mut self, node: Vec<FamilyName>, __ast_path: &mut AstKindPath, ) -> Vec<FamilyName>

Visit a node of type Vec < FamilyName >.

By default, this method calls [Vec < FamilyName >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex

Visit a node of type Flex.

By default, this method calls [Flex::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_font_feature_values_prelude( &mut self, node: FontFeatureValuesPrelude, __ast_path: &mut AstKindPath, ) -> FontFeatureValuesPrelude

Visit a node of type FontFeatureValuesPrelude.

By default, this method calls [FontFeatureValuesPrelude::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_forgiving_complex_selector( &mut self, node: ForgivingComplexSelector, __ast_path: &mut AstKindPath, ) -> ForgivingComplexSelector

Visit a node of type ForgivingComplexSelector.

By default, this method calls [ForgivingComplexSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_forgiving_complex_selectors( &mut self, node: Vec<ForgivingComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingComplexSelector>

Visit a node of type Vec < ForgivingComplexSelector >.

By default, this method calls [Vec < ForgivingComplexSelector >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_forgiving_relative_selector( &mut self, node: ForgivingRelativeSelector, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelector

Visit a node of type ForgivingRelativeSelector.

By default, this method calls [ForgivingRelativeSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_forgiving_relative_selector_list( &mut self, node: ForgivingRelativeSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelectorList

Visit a node of type ForgivingRelativeSelectorList.

By default, this method calls [ForgivingRelativeSelectorList::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_forgiving_relative_selectors( &mut self, node: Vec<ForgivingRelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingRelativeSelector>

Visit a node of type Vec < ForgivingRelativeSelector >.

By default, this method calls [Vec < ForgivingRelativeSelector >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_forgiving_selector_list( &mut self, node: ForgivingSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingSelectorList

Visit a node of type ForgivingSelectorList.

By default, this method calls [ForgivingSelectorList::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_frequency( &mut self, node: Frequency, __ast_path: &mut AstKindPath, ) -> Frequency

Visit a node of type Frequency.

By default, this method calls [Frequency::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_frequency_percentage( &mut self, node: FrequencyPercentage, __ast_path: &mut AstKindPath, ) -> FrequencyPercentage

Visit a node of type FrequencyPercentage.

By default, this method calls [FrequencyPercentage::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

Visit a node of type Function.

By default, this method calls [Function::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_function_name( &mut self, node: FunctionName, __ast_path: &mut AstKindPath, ) -> FunctionName

Visit a node of type FunctionName.

By default, this method calls [FunctionName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_general_enclosed( &mut self, node: GeneralEnclosed, __ast_path: &mut AstKindPath, ) -> GeneralEnclosed

Visit a node of type GeneralEnclosed.

By default, this method calls [GeneralEnclosed::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_hex_color( &mut self, node: HexColor, __ast_path: &mut AstKindPath, ) -> HexColor

Visit a node of type HexColor.

By default, this method calls [HexColor::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue

Visit a node of type Hue.

By default, this method calls [Hue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_id_selector( &mut self, node: IdSelector, __ast_path: &mut AstKindPath, ) -> IdSelector

Visit a node of type IdSelector.

By default, this method calls [IdSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

Visit a node of type Ident.

By default, this method calls [Ident::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_idents( &mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath, ) -> Vec<Ident>

Visit a node of type Vec < Ident >.

By default, this method calls [Vec < Ident >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_import_conditions( &mut self, node: ImportConditions, __ast_path: &mut AstKindPath, ) -> ImportConditions

Visit a node of type ImportConditions.

By default, this method calls [ImportConditions::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_import_href( &mut self, node: ImportHref, __ast_path: &mut AstKindPath, ) -> ImportHref

Visit a node of type ImportHref.

By default, this method calls [ImportHref::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_import_layer_name( &mut self, node: ImportLayerName, __ast_path: &mut AstKindPath, ) -> ImportLayerName

Visit a node of type ImportLayerName.

By default, this method calls [ImportLayerName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_import_prelude( &mut self, node: ImportPrelude, __ast_path: &mut AstKindPath, ) -> ImportPrelude

Visit a node of type ImportPrelude.

By default, this method calls [ImportPrelude::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_important_flag( &mut self, node: ImportantFlag, __ast_path: &mut AstKindPath, ) -> ImportantFlag

Visit a node of type ImportantFlag.

By default, this method calls [ImportantFlag::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_integer( &mut self, node: Integer, __ast_path: &mut AstKindPath, ) -> Integer

Visit a node of type Integer.

By default, this method calls [Integer::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_keyframe_block( &mut self, node: KeyframeBlock, __ast_path: &mut AstKindPath, ) -> KeyframeBlock

Visit a node of type KeyframeBlock.

By default, this method calls [KeyframeBlock::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_keyframe_selector( &mut self, node: KeyframeSelector, __ast_path: &mut AstKindPath, ) -> KeyframeSelector

Visit a node of type KeyframeSelector.

By default, this method calls [KeyframeSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_keyframe_selectors( &mut self, node: Vec<KeyframeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<KeyframeSelector>

Visit a node of type Vec < KeyframeSelector >.

By default, this method calls [Vec < KeyframeSelector >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_keyframes_name( &mut self, node: KeyframesName, __ast_path: &mut AstKindPath, ) -> KeyframesName

Visit a node of type KeyframesName.

By default, this method calls [KeyframesName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_keyframes_pseudo_function( &mut self, node: KeyframesPseudoFunction, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoFunction

Visit a node of type KeyframesPseudoFunction.

By default, this method calls [KeyframesPseudoFunction::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_keyframes_pseudo_prefix( &mut self, node: KeyframesPseudoPrefix, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoPrefix

Visit a node of type KeyframesPseudoPrefix.

By default, this method calls [KeyframesPseudoPrefix::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_layer_name( &mut self, node: LayerName, __ast_path: &mut AstKindPath, ) -> LayerName

Visit a node of type LayerName.

By default, this method calls [LayerName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_layer_name_list( &mut self, node: LayerNameList, __ast_path: &mut AstKindPath, ) -> LayerNameList

Visit a node of type LayerNameList.

By default, this method calls [LayerNameList::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_layer_names( &mut self, node: Vec<LayerName>, __ast_path: &mut AstKindPath, ) -> Vec<LayerName>

Visit a node of type Vec < LayerName >.

By default, this method calls [Vec < LayerName >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_layer_prelude( &mut self, node: LayerPrelude, __ast_path: &mut AstKindPath, ) -> LayerPrelude

Visit a node of type LayerPrelude.

By default, this method calls [LayerPrelude::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length

Visit a node of type Length.

By default, this method calls [Length::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_length_percentage( &mut self, node: LengthPercentage, __ast_path: &mut AstKindPath, ) -> LengthPercentage

Visit a node of type LengthPercentage.

By default, this method calls [LengthPercentage::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_list_of_component_values( &mut self, node: ListOfComponentValues, __ast_path: &mut AstKindPath, ) -> ListOfComponentValues

Visit a node of type ListOfComponentValues.

By default, this method calls [ListOfComponentValues::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_and( &mut self, node: MediaAnd, __ast_path: &mut AstKindPath, ) -> MediaAnd

Visit a node of type MediaAnd.

By default, this method calls [MediaAnd::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_condition( &mut self, node: MediaCondition, __ast_path: &mut AstKindPath, ) -> MediaCondition

Visit a node of type MediaCondition.

By default, this method calls [MediaCondition::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_condition_all_type( &mut self, node: MediaConditionAllType, __ast_path: &mut AstKindPath, ) -> MediaConditionAllType

Visit a node of type MediaConditionAllType.

By default, this method calls [MediaConditionAllType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_condition_all_types( &mut self, node: Vec<MediaConditionAllType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionAllType>

Visit a node of type Vec < MediaConditionAllType >.

By default, this method calls [Vec < MediaConditionAllType >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_condition_type( &mut self, node: MediaConditionType, __ast_path: &mut AstKindPath, ) -> MediaConditionType

Visit a node of type MediaConditionType.

By default, this method calls [MediaConditionType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_condition_without_or( &mut self, node: MediaConditionWithoutOr, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOr

Visit a node of type MediaConditionWithoutOr.

By default, this method calls [MediaConditionWithoutOr::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_condition_without_or_type( &mut self, node: MediaConditionWithoutOrType, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOrType

Visit a node of type MediaConditionWithoutOrType.

By default, this method calls [MediaConditionWithoutOrType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_condition_without_or_types( &mut self, node: Vec<MediaConditionWithoutOrType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionWithoutOrType>

Visit a node of type Vec < MediaConditionWithoutOrType >.

By default, this method calls [Vec < MediaConditionWithoutOrType >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_feature( &mut self, node: MediaFeature, __ast_path: &mut AstKindPath, ) -> MediaFeature

Visit a node of type MediaFeature.

By default, this method calls [MediaFeature::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_feature_boolean( &mut self, node: MediaFeatureBoolean, __ast_path: &mut AstKindPath, ) -> MediaFeatureBoolean

Visit a node of type MediaFeatureBoolean.

By default, this method calls [MediaFeatureBoolean::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_feature_name( &mut self, node: MediaFeatureName, __ast_path: &mut AstKindPath, ) -> MediaFeatureName

Visit a node of type MediaFeatureName.

By default, this method calls [MediaFeatureName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_feature_plain( &mut self, node: MediaFeaturePlain, __ast_path: &mut AstKindPath, ) -> MediaFeaturePlain

Visit a node of type MediaFeaturePlain.

By default, this method calls [MediaFeaturePlain::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_feature_range( &mut self, node: MediaFeatureRange, __ast_path: &mut AstKindPath, ) -> MediaFeatureRange

Visit a node of type MediaFeatureRange.

By default, this method calls [MediaFeatureRange::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_feature_range_comparison( &mut self, node: MediaFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeComparison

Visit a node of type MediaFeatureRangeComparison.

By default, this method calls [MediaFeatureRangeComparison::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_feature_range_interval( &mut self, node: MediaFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeInterval

Visit a node of type MediaFeatureRangeInterval.

By default, this method calls [MediaFeatureRangeInterval::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_feature_value( &mut self, node: MediaFeatureValue, __ast_path: &mut AstKindPath, ) -> MediaFeatureValue

Visit a node of type MediaFeatureValue.

By default, this method calls [MediaFeatureValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_in_parens( &mut self, node: MediaInParens, __ast_path: &mut AstKindPath, ) -> MediaInParens

Visit a node of type MediaInParens.

By default, this method calls [MediaInParens::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_not( &mut self, node: MediaNot, __ast_path: &mut AstKindPath, ) -> MediaNot

Visit a node of type MediaNot.

By default, this method calls [MediaNot::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_or( &mut self, node: MediaOr, __ast_path: &mut AstKindPath, ) -> MediaOr

Visit a node of type MediaOr.

By default, this method calls [MediaOr::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_query( &mut self, node: MediaQuery, __ast_path: &mut AstKindPath, ) -> MediaQuery

Visit a node of type MediaQuery.

By default, this method calls [MediaQuery::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_query_list( &mut self, node: MediaQueryList, __ast_path: &mut AstKindPath, ) -> MediaQueryList

Visit a node of type MediaQueryList.

By default, this method calls [MediaQueryList::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_querys( &mut self, node: Vec<MediaQuery>, __ast_path: &mut AstKindPath, ) -> Vec<MediaQuery>

Visit a node of type Vec < MediaQuery >.

By default, this method calls [Vec < MediaQuery >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_media_type( &mut self, node: MediaType, __ast_path: &mut AstKindPath, ) -> MediaType

Visit a node of type MediaType.

By default, this method calls [MediaType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_named_namespace( &mut self, node: NamedNamespace, __ast_path: &mut AstKindPath, ) -> NamedNamespace

Visit a node of type NamedNamespace.

By default, this method calls [NamedNamespace::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

Visit a node of type Namespace.

By default, this method calls [Namespace::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_namespace_prefix( &mut self, node: NamespacePrefix, __ast_path: &mut AstKindPath, ) -> NamespacePrefix

Visit a node of type NamespacePrefix.

By default, this method calls [NamespacePrefix::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_namespace_prelude( &mut self, node: NamespacePrelude, __ast_path: &mut AstKindPath, ) -> NamespacePrelude

Visit a node of type NamespacePrelude.

By default, this method calls [NamespacePrelude::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_namespace_prelude_uri( &mut self, node: NamespacePreludeUri, __ast_path: &mut AstKindPath, ) -> NamespacePreludeUri

Visit a node of type NamespacePreludeUri.

By default, this method calls [NamespacePreludeUri::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_nesting_selector( &mut self, node: NestingSelector, __ast_path: &mut AstKindPath, ) -> NestingSelector

Visit a node of type NestingSelector.

By default, this method calls [NestingSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

Visit a node of type Number.

By default, this method calls [Number::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_number_type( &mut self, node: NumberType, __ast_path: &mut AstKindPath, ) -> NumberType

Visit a node of type NumberType.

By default, this method calls [NumberType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_at_rule_prelude( &mut self, node: Option<Box<AtRulePrelude>>, __ast_path: &mut AstKindPath, ) -> Option<Box<AtRulePrelude>>

Visit a node of type Option < Box < AtRulePrelude > >.

By default, this method calls [Option < Box < AtRulePrelude > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

Visit a node of type Option < swc_atoms :: Atom >.

By default, this method calls [Option < swc_atoms :: Atom >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_attribute_selector_matcher( &mut self, node: Option<AttributeSelectorMatcher>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorMatcher>

Visit a node of type Option < AttributeSelectorMatcher >.

By default, this method calls [Option < AttributeSelectorMatcher >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_attribute_selector_modifier( &mut self, node: Option<AttributeSelectorModifier>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorModifier>

Visit a node of type Option < AttributeSelectorModifier >.

By default, this method calls [Option < AttributeSelectorModifier >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_attribute_selector_value( &mut self, node: Option<AttributeSelectorValue>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorValue>

Visit a node of type Option < AttributeSelectorValue >.

By default, this method calls [Option < AttributeSelectorValue >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_combinator( &mut self, node: Option<Combinator>, __ast_path: &mut AstKindPath, ) -> Option<Combinator>

Visit a node of type Option < Combinator >.

By default, this method calls [Option < Combinator >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_container_name( &mut self, node: Option<ContainerName>, __ast_path: &mut AstKindPath, ) -> Option<ContainerName>

Visit a node of type Option < ContainerName >.

By default, this method calls [Option < ContainerName >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_forgiving_selector_list( &mut self, node: Option<ForgivingSelectorList>, __ast_path: &mut AstKindPath, ) -> Option<ForgivingSelectorList>

Visit a node of type Option < ForgivingSelectorList >.

By default, this method calls [Option < ForgivingSelectorList >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_function( &mut self, node: Option<Box<Function>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Function>>

Visit a node of type Option < Box < Function > >.

By default, this method calls [Option < Box < Function > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

Visit a node of type Option < Ident >.

By default, this method calls [Option < Ident >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_import_conditions( &mut self, node: Option<Box<ImportConditions>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportConditions>>

Visit a node of type Option < Box < ImportConditions > >.

By default, this method calls [Option < Box < ImportConditions > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_import_layer_name( &mut self, node: Option<Box<ImportLayerName>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportLayerName>>

Visit a node of type Option < Box < ImportLayerName > >.

By default, this method calls [Option < Box < ImportLayerName > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_important_flag( &mut self, node: Option<ImportantFlag>, __ast_path: &mut AstKindPath, ) -> Option<ImportantFlag>

Visit a node of type Option < ImportantFlag >.

By default, this method calls [Option < ImportantFlag >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_media_condition_type( &mut self, node: Option<Box<MediaConditionType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaConditionType>>

Visit a node of type Option < Box < MediaConditionType > >.

By default, this method calls [Option < Box < MediaConditionType > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_media_query_list( &mut self, node: Option<Box<MediaQueryList>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaQueryList>>

Visit a node of type Option < Box < MediaQueryList > >.

By default, this method calls [Option < Box < MediaQueryList > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_media_type( &mut self, node: Option<MediaType>, __ast_path: &mut AstKindPath, ) -> Option<MediaType>

Visit a node of type Option < MediaType >.

By default, this method calls [Option < MediaType >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

Visit a node of type Option < Namespace >.

By default, this method calls [Option < Namespace >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_namespace_prefix( &mut self, node: Option<NamespacePrefix>, __ast_path: &mut AstKindPath, ) -> Option<NamespacePrefix>

Visit a node of type Option < NamespacePrefix >.

By default, this method calls [Option < NamespacePrefix >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_nesting_selector( &mut self, node: Option<NestingSelector>, __ast_path: &mut AstKindPath, ) -> Option<NestingSelector>

Visit a node of type Option < NestingSelector >.

By default, this method calls [Option < NestingSelector >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_number( &mut self, node: Option<Number>, __ast_path: &mut AstKindPath, ) -> Option<Number>

Visit a node of type Option < Number >.

By default, this method calls [Option < Number >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_page_selector_pseudos( &mut self, node: Option<Vec<PageSelectorPseudo>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PageSelectorPseudo>>

Visit a node of type Option < Vec < PageSelectorPseudo > >.

By default, this method calls [Option < Vec < PageSelectorPseudo > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_page_selector_type( &mut self, node: Option<PageSelectorType>, __ast_path: &mut AstKindPath, ) -> Option<PageSelectorType>

Visit a node of type Option < PageSelectorType >.

By default, this method calls [Option < PageSelectorType >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_pseudo_class_selector_childrens( &mut self, node: Option<Vec<PseudoClassSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoClassSelectorChildren>>

Visit a node of type Option < Vec < PseudoClassSelectorChildren > >.

By default, this method calls [Option < Vec < PseudoClassSelectorChildren > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_pseudo_element_selector_childrens( &mut self, node: Option<Vec<PseudoElementSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoElementSelectorChildren>>

Visit a node of type Option < Vec < PseudoElementSelectorChildren > >.

By default, this method calls [Option < Vec < PseudoElementSelectorChildren > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_simple_block( &mut self, node: Option<SimpleBlock>, __ast_path: &mut AstKindPath, ) -> Option<SimpleBlock>

Visit a node of type Option < SimpleBlock >.

By default, this method calls [Option < SimpleBlock >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_type_selector( &mut self, node: Option<Box<TypeSelector>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TypeSelector>>

Visit a node of type Option < Box < TypeSelector > >.

By default, this method calls [Option < Box < TypeSelector > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_url_modifiers( &mut self, node: Option<Vec<UrlModifier>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<UrlModifier>>

Visit a node of type Option < Vec < UrlModifier > >.

By default, this method calls [Option < Vec < UrlModifier > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_url_value( &mut self, node: Option<Box<UrlValue>>, __ast_path: &mut AstKindPath, ) -> Option<Box<UrlValue>>

Visit a node of type Option < Box < UrlValue > >.

By default, this method calls [Option < Box < UrlValue > >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_page_selector( &mut self, node: PageSelector, __ast_path: &mut AstKindPath, ) -> PageSelector

Visit a node of type PageSelector.

By default, this method calls [PageSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_page_selector_list( &mut self, node: PageSelectorList, __ast_path: &mut AstKindPath, ) -> PageSelectorList

Visit a node of type PageSelectorList.

By default, this method calls [PageSelectorList::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_page_selector_pseudo( &mut self, node: PageSelectorPseudo, __ast_path: &mut AstKindPath, ) -> PageSelectorPseudo

Visit a node of type PageSelectorPseudo.

By default, this method calls [PageSelectorPseudo::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_page_selector_pseudos( &mut self, node: Vec<PageSelectorPseudo>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelectorPseudo>

Visit a node of type Vec < PageSelectorPseudo >.

By default, this method calls [Vec < PageSelectorPseudo >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_page_selector_type( &mut self, node: PageSelectorType, __ast_path: &mut AstKindPath, ) -> PageSelectorType

Visit a node of type PageSelectorType.

By default, this method calls [PageSelectorType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_page_selectors( &mut self, node: Vec<PageSelector>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelector>

Visit a node of type Vec < PageSelector >.

By default, this method calls [Vec < PageSelector >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_percentage( &mut self, node: Percentage, __ast_path: &mut AstKindPath, ) -> Percentage

Visit a node of type Percentage.

By default, this method calls [Percentage::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_pseudo_class_selector( &mut self, node: PseudoClassSelector, __ast_path: &mut AstKindPath, ) -> PseudoClassSelector

Visit a node of type PseudoClassSelector.

By default, this method calls [PseudoClassSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_pseudo_class_selector_children( &mut self, node: PseudoClassSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoClassSelectorChildren

Visit a node of type PseudoClassSelectorChildren.

By default, this method calls [PseudoClassSelectorChildren::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_pseudo_class_selector_childrens( &mut self, node: Vec<PseudoClassSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoClassSelectorChildren>

Visit a node of type Vec < PseudoClassSelectorChildren >.

By default, this method calls [Vec < PseudoClassSelectorChildren >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_pseudo_element_selector( &mut self, node: PseudoElementSelector, __ast_path: &mut AstKindPath, ) -> PseudoElementSelector

Visit a node of type PseudoElementSelector.

By default, this method calls [PseudoElementSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_pseudo_element_selector_children( &mut self, node: PseudoElementSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoElementSelectorChildren

Visit a node of type PseudoElementSelectorChildren.

By default, this method calls [PseudoElementSelectorChildren::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_pseudo_element_selector_childrens( &mut self, node: Vec<PseudoElementSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoElementSelectorChildren>

Visit a node of type Vec < PseudoElementSelectorChildren >.

By default, this method calls [Vec < PseudoElementSelectorChildren >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_qualified_rule( &mut self, node: QualifiedRule, __ast_path: &mut AstKindPath, ) -> QualifiedRule

Visit a node of type QualifiedRule.

By default, this method calls [QualifiedRule::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_qualified_rule_prelude( &mut self, node: QualifiedRulePrelude, __ast_path: &mut AstKindPath, ) -> QualifiedRulePrelude

Visit a node of type QualifiedRulePrelude.

By default, this method calls [QualifiedRulePrelude::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_query_in_parens( &mut self, node: QueryInParens, __ast_path: &mut AstKindPath, ) -> QueryInParens

Visit a node of type QueryInParens.

By default, this method calls [QueryInParens::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio

Visit a node of type Ratio.

By default, this method calls [Ratio::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_relative_selector( &mut self, node: RelativeSelector, __ast_path: &mut AstKindPath, ) -> RelativeSelector

Visit a node of type RelativeSelector.

By default, this method calls [RelativeSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_relative_selector_list( &mut self, node: RelativeSelectorList, __ast_path: &mut AstKindPath, ) -> RelativeSelectorList

Visit a node of type RelativeSelectorList.

By default, this method calls [RelativeSelectorList::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_relative_selectors( &mut self, node: Vec<RelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<RelativeSelector>

Visit a node of type Vec < RelativeSelector >.

By default, this method calls [Vec < RelativeSelector >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_resolution( &mut self, node: Resolution, __ast_path: &mut AstKindPath, ) -> Resolution

Visit a node of type Resolution.

By default, this method calls [Resolution::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule

Visit a node of type Rule.

By default, this method calls [Rule::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_rules( &mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath, ) -> Vec<Rule>

Visit a node of type Vec < Rule >.

By default, this method calls [Vec < Rule >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_scope_range( &mut self, node: ScopeRange, __ast_path: &mut AstKindPath, ) -> ScopeRange

Visit a node of type ScopeRange.

By default, this method calls [ScopeRange::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_selector_list( &mut self, node: SelectorList, __ast_path: &mut AstKindPath, ) -> SelectorList

Visit a node of type SelectorList.

By default, this method calls [SelectorList::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_sequence_of_custom_idents( &mut self, node: SequenceOfCustomIdents, __ast_path: &mut AstKindPath, ) -> SequenceOfCustomIdents

Visit a node of type SequenceOfCustomIdents.

By default, this method calls [SequenceOfCustomIdents::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_simple_block( &mut self, node: SimpleBlock, __ast_path: &mut AstKindPath, ) -> SimpleBlock

Visit a node of type SimpleBlock.

By default, this method calls [SimpleBlock::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_size_feature( &mut self, node: SizeFeature, __ast_path: &mut AstKindPath, ) -> SizeFeature

Visit a node of type SizeFeature.

By default, this method calls [SizeFeature::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_size_feature_boolean( &mut self, node: SizeFeatureBoolean, __ast_path: &mut AstKindPath, ) -> SizeFeatureBoolean

Visit a node of type SizeFeatureBoolean.

By default, this method calls [SizeFeatureBoolean::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_size_feature_name( &mut self, node: SizeFeatureName, __ast_path: &mut AstKindPath, ) -> SizeFeatureName

Visit a node of type SizeFeatureName.

By default, this method calls [SizeFeatureName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_size_feature_plain( &mut self, node: SizeFeaturePlain, __ast_path: &mut AstKindPath, ) -> SizeFeaturePlain

Visit a node of type SizeFeaturePlain.

By default, this method calls [SizeFeaturePlain::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_size_feature_range( &mut self, node: SizeFeatureRange, __ast_path: &mut AstKindPath, ) -> SizeFeatureRange

Visit a node of type SizeFeatureRange.

By default, this method calls [SizeFeatureRange::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_size_feature_range_comparison( &mut self, node: SizeFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeComparison

Visit a node of type SizeFeatureRangeComparison.

By default, this method calls [SizeFeatureRangeComparison::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_size_feature_range_interval( &mut self, node: SizeFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeInterval

Visit a node of type SizeFeatureRangeInterval.

By default, this method calls [SizeFeatureRangeInterval::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_size_feature_value( &mut self, node: SizeFeatureValue, __ast_path: &mut AstKindPath, ) -> SizeFeatureValue

Visit a node of type SizeFeatureValue.

By default, this method calls [SizeFeatureValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

Visit a node of type swc_common :: Span.

By default, this method calls [swc_common :: Span::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

Visit a node of type Str.

By default, this method calls [Str::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_style_block( &mut self, node: StyleBlock, __ast_path: &mut AstKindPath, ) -> StyleBlock

Visit a node of type StyleBlock.

By default, this method calls [StyleBlock::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_stylesheet( &mut self, node: Stylesheet, __ast_path: &mut AstKindPath, ) -> Stylesheet

Visit a node of type Stylesheet.

By default, this method calls [Stylesheet::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_subclass_selector( &mut self, node: SubclassSelector, __ast_path: &mut AstKindPath, ) -> SubclassSelector

Visit a node of type SubclassSelector.

By default, this method calls [SubclassSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_subclass_selectors( &mut self, node: Vec<SubclassSelector>, __ast_path: &mut AstKindPath, ) -> Vec<SubclassSelector>

Visit a node of type Vec < SubclassSelector >.

By default, this method calls [Vec < SubclassSelector >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_supports_and( &mut self, node: SupportsAnd, __ast_path: &mut AstKindPath, ) -> SupportsAnd

Visit a node of type SupportsAnd.

By default, this method calls [SupportsAnd::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_supports_condition( &mut self, node: SupportsCondition, __ast_path: &mut AstKindPath, ) -> SupportsCondition

Visit a node of type SupportsCondition.

By default, this method calls [SupportsCondition::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_supports_condition_type( &mut self, node: SupportsConditionType, __ast_path: &mut AstKindPath, ) -> SupportsConditionType

Visit a node of type SupportsConditionType.

By default, this method calls [SupportsConditionType::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_supports_condition_types( &mut self, node: Vec<SupportsConditionType>, __ast_path: &mut AstKindPath, ) -> Vec<SupportsConditionType>

Visit a node of type Vec < SupportsConditionType >.

By default, this method calls [Vec < SupportsConditionType >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_supports_feature( &mut self, node: SupportsFeature, __ast_path: &mut AstKindPath, ) -> SupportsFeature

Visit a node of type SupportsFeature.

By default, this method calls [SupportsFeature::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_supports_in_parens( &mut self, node: SupportsInParens, __ast_path: &mut AstKindPath, ) -> SupportsInParens

Visit a node of type SupportsInParens.

By default, this method calls [SupportsInParens::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_supports_not( &mut self, node: SupportsNot, __ast_path: &mut AstKindPath, ) -> SupportsNot

Visit a node of type SupportsNot.

By default, this method calls [SupportsNot::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_supports_or( &mut self, node: SupportsOr, __ast_path: &mut AstKindPath, ) -> SupportsOr

Visit a node of type SupportsOr.

By default, this method calls [SupportsOr::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_tag_name_selector( &mut self, node: TagNameSelector, __ast_path: &mut AstKindPath, ) -> TagNameSelector

Visit a node of type TagNameSelector.

By default, this method calls [TagNameSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time

Visit a node of type Time.

By default, this method calls [Time::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_time_percentage( &mut self, node: TimePercentage, __ast_path: &mut AstKindPath, ) -> TimePercentage

Visit a node of type TimePercentage.

By default, this method calls [TimePercentage::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

Visit a node of type Token.

By default, this method calls [Token::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

Visit a node of type TokenAndSpan.

By default, this method calls [TokenAndSpan::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_type_selector( &mut self, node: TypeSelector, __ast_path: &mut AstKindPath, ) -> TypeSelector

Visit a node of type TypeSelector.

By default, this method calls [TypeSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_unicode_range( &mut self, node: UnicodeRange, __ast_path: &mut AstKindPath, ) -> UnicodeRange

Visit a node of type UnicodeRange.

By default, this method calls [UnicodeRange::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_universal_selector( &mut self, node: UniversalSelector, __ast_path: &mut AstKindPath, ) -> UniversalSelector

Visit a node of type UniversalSelector.

By default, this method calls [UniversalSelector::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_unknown_dimension( &mut self, node: UnknownDimension, __ast_path: &mut AstKindPath, ) -> UnknownDimension

Visit a node of type UnknownDimension.

By default, this method calls [UnknownDimension::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url

Visit a node of type Url.

By default, this method calls [Url::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_url_key_value( &mut self, node: UrlKeyValue, __ast_path: &mut AstKindPath, ) -> UrlKeyValue

Visit a node of type UrlKeyValue.

By default, this method calls [UrlKeyValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_url_modifier( &mut self, node: UrlModifier, __ast_path: &mut AstKindPath, ) -> UrlModifier

Visit a node of type UrlModifier.

By default, this method calls [UrlModifier::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_url_modifiers( &mut self, node: Vec<UrlModifier>, __ast_path: &mut AstKindPath, ) -> Vec<UrlModifier>

Visit a node of type Vec < UrlModifier >.

By default, this method calls [Vec < UrlModifier >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_url_value( &mut self, node: UrlValue, __ast_path: &mut AstKindPath, ) -> UrlValue

Visit a node of type UrlValue.

By default, this method calls [UrlValue::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_url_value_raw( &mut self, node: UrlValueRaw, __ast_path: &mut AstKindPath, ) -> UrlValueRaw

Visit a node of type UrlValueRaw.

By default, this method calls [UrlValueRaw::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName

Visit a node of type WqName.

By default, this method calls [WqName::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

Implementations on Foreign Types

impl<A, B> FoldAstPath for Either<A, B>

where A: FoldAstPath, B: FoldAstPath,

fn fold_absolute_color_base( &mut self, node: AbsoluteColorBase, __ast_path: &mut AstKindPath, ) -> AbsoluteColorBase

fn fold_alpha_value( &mut self, node: AlphaValue, __ast_path: &mut AstKindPath, ) -> AlphaValue

fn fold_an_plus_b( &mut self, node: AnPlusB, __ast_path: &mut AstKindPath, ) -> AnPlusB

fn fold_an_plus_b_notation( &mut self, node: AnPlusBNotation, __ast_path: &mut AstKindPath, ) -> AnPlusBNotation

fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle

fn fold_angle_percentage( &mut self, node: AnglePercentage, __ast_path: &mut AstKindPath, ) -> AnglePercentage

fn fold_any_namespace( &mut self, node: AnyNamespace, __ast_path: &mut AstKindPath, ) -> AnyNamespace

fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule

fn fold_at_rule_name( &mut self, node: AtRuleName, __ast_path: &mut AstKindPath, ) -> AtRuleName

fn fold_at_rule_prelude( &mut self, node: AtRulePrelude, __ast_path: &mut AstKindPath, ) -> AtRulePrelude

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_attribute_selector( &mut self, node: AttributeSelector, __ast_path: &mut AstKindPath, ) -> AttributeSelector

fn fold_attribute_selector_matcher( &mut self, node: AttributeSelectorMatcher, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcher

fn fold_attribute_selector_matcher_value( &mut self, node: AttributeSelectorMatcherValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcherValue

fn fold_attribute_selector_modifier( &mut self, node: AttributeSelectorModifier, __ast_path: &mut AstKindPath, ) -> AttributeSelectorModifier

fn fold_attribute_selector_value( &mut self, node: AttributeSelectorValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorValue

fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp

fn fold_calc_operator( &mut self, node: CalcOperator, __ast_path: &mut AstKindPath, ) -> CalcOperator

fn fold_calc_operator_type( &mut self, node: CalcOperatorType, __ast_path: &mut AstKindPath, ) -> CalcOperatorType

fn fold_calc_product( &mut self, node: CalcProduct, __ast_path: &mut AstKindPath, ) -> CalcProduct

fn fold_calc_product_or_operator( &mut self, node: CalcProductOrOperator, __ast_path: &mut AstKindPath, ) -> CalcProductOrOperator

fn fold_calc_product_or_operators( &mut self, node: Vec<CalcProductOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcProductOrOperator>

fn fold_calc_sum( &mut self, node: CalcSum, __ast_path: &mut AstKindPath, ) -> CalcSum

fn fold_calc_value( &mut self, node: CalcValue, __ast_path: &mut AstKindPath, ) -> CalcValue

fn fold_calc_value_or_operator( &mut self, node: CalcValueOrOperator, __ast_path: &mut AstKindPath, ) -> CalcValueOrOperator

fn fold_calc_value_or_operators( &mut self, node: Vec<CalcValueOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcValueOrOperator>

fn fold_class_selector( &mut self, node: ClassSelector, __ast_path: &mut AstKindPath, ) -> ClassSelector

fn fold_cmyk_component( &mut self, node: CmykComponent, __ast_path: &mut AstKindPath, ) -> CmykComponent

fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color

fn fold_color_profile_name( &mut self, node: ColorProfileName, __ast_path: &mut AstKindPath, ) -> ColorProfileName

fn fold_combinator( &mut self, node: Combinator, __ast_path: &mut AstKindPath, ) -> Combinator

fn fold_combinator_value( &mut self, node: CombinatorValue, __ast_path: &mut AstKindPath, ) -> CombinatorValue

fn fold_complex_selector( &mut self, node: ComplexSelector, __ast_path: &mut AstKindPath, ) -> ComplexSelector

fn fold_complex_selector_children( &mut self, node: ComplexSelectorChildren, __ast_path: &mut AstKindPath, ) -> ComplexSelectorChildren

fn fold_complex_selector_childrens( &mut self, node: Vec<ComplexSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelectorChildren>

fn fold_complex_selectors( &mut self, node: Vec<ComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelector>

fn fold_component_value( &mut self, node: ComponentValue, __ast_path: &mut AstKindPath, ) -> ComponentValue

fn fold_component_values( &mut self, node: Vec<ComponentValue>, __ast_path: &mut AstKindPath, ) -> Vec<ComponentValue>

fn fold_compound_selector( &mut self, node: CompoundSelector, __ast_path: &mut AstKindPath, ) -> CompoundSelector

fn fold_compound_selector_list( &mut self, node: CompoundSelectorList, __ast_path: &mut AstKindPath, ) -> CompoundSelectorList

fn fold_compound_selectors( &mut self, node: Vec<CompoundSelector>, __ast_path: &mut AstKindPath, ) -> Vec<CompoundSelector>

fn fold_container_condition( &mut self, node: ContainerCondition, __ast_path: &mut AstKindPath, ) -> ContainerCondition

fn fold_container_name( &mut self, node: ContainerName, __ast_path: &mut AstKindPath, ) -> ContainerName

fn fold_container_query( &mut self, node: ContainerQuery, __ast_path: &mut AstKindPath, ) -> ContainerQuery

fn fold_container_query_and( &mut self, node: ContainerQueryAnd, __ast_path: &mut AstKindPath, ) -> ContainerQueryAnd

fn fold_container_query_not( &mut self, node: ContainerQueryNot, __ast_path: &mut AstKindPath, ) -> ContainerQueryNot

fn fold_container_query_or( &mut self, node: ContainerQueryOr, __ast_path: &mut AstKindPath, ) -> ContainerQueryOr

fn fold_container_query_type( &mut self, node: ContainerQueryType, __ast_path: &mut AstKindPath, ) -> ContainerQueryType

fn fold_container_query_types( &mut self, node: Vec<ContainerQueryType>, __ast_path: &mut AstKindPath, ) -> Vec<ContainerQueryType>

fn fold_custom_highlight_name( &mut self, node: CustomHighlightName, __ast_path: &mut AstKindPath, ) -> CustomHighlightName

fn fold_custom_ident( &mut self, node: CustomIdent, __ast_path: &mut AstKindPath, ) -> CustomIdent

fn fold_custom_idents( &mut self, node: Vec<CustomIdent>, __ast_path: &mut AstKindPath, ) -> Vec<CustomIdent>

fn fold_custom_media_query( &mut self, node: CustomMediaQuery, __ast_path: &mut AstKindPath, ) -> CustomMediaQuery

fn fold_custom_media_query_media_type( &mut self, node: CustomMediaQueryMediaType, __ast_path: &mut AstKindPath, ) -> CustomMediaQueryMediaType

fn fold_custom_property_name( &mut self, node: CustomPropertyName, __ast_path: &mut AstKindPath, ) -> CustomPropertyName

fn fold_dashed_ident( &mut self, node: DashedIdent, __ast_path: &mut AstKindPath, ) -> DashedIdent

fn fold_declaration( &mut self, node: Declaration, __ast_path: &mut AstKindPath, ) -> Declaration

fn fold_declaration_name( &mut self, node: DeclarationName, __ast_path: &mut AstKindPath, ) -> DeclarationName

fn fold_declaration_or_at_rule( &mut self, node: DeclarationOrAtRule, __ast_path: &mut AstKindPath, ) -> DeclarationOrAtRule

fn fold_delimiter( &mut self, node: Delimiter, __ast_path: &mut AstKindPath, ) -> Delimiter

fn fold_delimiter_value( &mut self, node: DelimiterValue, __ast_path: &mut AstKindPath, ) -> DelimiterValue

fn fold_dimension( &mut self, node: Dimension, __ast_path: &mut AstKindPath, ) -> Dimension

fn fold_dimension_token( &mut self, node: DimensionToken, __ast_path: &mut AstKindPath, ) -> DimensionToken

fn fold_document_prelude( &mut self, node: DocumentPrelude, __ast_path: &mut AstKindPath, ) -> DocumentPrelude

fn fold_document_prelude_matching_function( &mut self, node: DocumentPreludeMatchingFunction, __ast_path: &mut AstKindPath, ) -> DocumentPreludeMatchingFunction

fn fold_document_prelude_matching_functions( &mut self, node: Vec<DocumentPreludeMatchingFunction>, __ast_path: &mut AstKindPath, ) -> Vec<DocumentPreludeMatchingFunction>

fn fold_extension_name( &mut self, node: ExtensionName, __ast_path: &mut AstKindPath, ) -> ExtensionName

fn fold_family_name( &mut self, node: FamilyName, __ast_path: &mut AstKindPath, ) -> FamilyName

fn fold_family_names( &mut self, node: Vec<FamilyName>, __ast_path: &mut AstKindPath, ) -> Vec<FamilyName>

fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex

fn fold_font_feature_values_prelude( &mut self, node: FontFeatureValuesPrelude, __ast_path: &mut AstKindPath, ) -> FontFeatureValuesPrelude

fn fold_forgiving_complex_selector( &mut self, node: ForgivingComplexSelector, __ast_path: &mut AstKindPath, ) -> ForgivingComplexSelector

fn fold_forgiving_complex_selectors( &mut self, node: Vec<ForgivingComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingComplexSelector>

fn fold_forgiving_relative_selector( &mut self, node: ForgivingRelativeSelector, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelector

fn fold_forgiving_relative_selector_list( &mut self, node: ForgivingRelativeSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelectorList

fn fold_forgiving_relative_selectors( &mut self, node: Vec<ForgivingRelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingRelativeSelector>

fn fold_forgiving_selector_list( &mut self, node: ForgivingSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingSelectorList

fn fold_frequency( &mut self, node: Frequency, __ast_path: &mut AstKindPath, ) -> Frequency

fn fold_frequency_percentage( &mut self, node: FrequencyPercentage, __ast_path: &mut AstKindPath, ) -> FrequencyPercentage

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

fn fold_function_name( &mut self, node: FunctionName, __ast_path: &mut AstKindPath, ) -> FunctionName

fn fold_general_enclosed( &mut self, node: GeneralEnclosed, __ast_path: &mut AstKindPath, ) -> GeneralEnclosed

fn fold_hex_color( &mut self, node: HexColor, __ast_path: &mut AstKindPath, ) -> HexColor

fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue

fn fold_id_selector( &mut self, node: IdSelector, __ast_path: &mut AstKindPath, ) -> IdSelector

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

fn fold_idents( &mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath, ) -> Vec<Ident>

fn fold_import_conditions( &mut self, node: ImportConditions, __ast_path: &mut AstKindPath, ) -> ImportConditions

fn fold_import_href( &mut self, node: ImportHref, __ast_path: &mut AstKindPath, ) -> ImportHref

fn fold_import_layer_name( &mut self, node: ImportLayerName, __ast_path: &mut AstKindPath, ) -> ImportLayerName

fn fold_import_prelude( &mut self, node: ImportPrelude, __ast_path: &mut AstKindPath, ) -> ImportPrelude

fn fold_important_flag( &mut self, node: ImportantFlag, __ast_path: &mut AstKindPath, ) -> ImportantFlag

fn fold_integer( &mut self, node: Integer, __ast_path: &mut AstKindPath, ) -> Integer

fn fold_keyframe_block( &mut self, node: KeyframeBlock, __ast_path: &mut AstKindPath, ) -> KeyframeBlock

fn fold_keyframe_selector( &mut self, node: KeyframeSelector, __ast_path: &mut AstKindPath, ) -> KeyframeSelector

fn fold_keyframe_selectors( &mut self, node: Vec<KeyframeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<KeyframeSelector>

fn fold_keyframes_name( &mut self, node: KeyframesName, __ast_path: &mut AstKindPath, ) -> KeyframesName

fn fold_keyframes_pseudo_function( &mut self, node: KeyframesPseudoFunction, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoFunction

fn fold_keyframes_pseudo_prefix( &mut self, node: KeyframesPseudoPrefix, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoPrefix

fn fold_layer_name( &mut self, node: LayerName, __ast_path: &mut AstKindPath, ) -> LayerName

fn fold_layer_name_list( &mut self, node: LayerNameList, __ast_path: &mut AstKindPath, ) -> LayerNameList

fn fold_layer_names( &mut self, node: Vec<LayerName>, __ast_path: &mut AstKindPath, ) -> Vec<LayerName>

fn fold_layer_prelude( &mut self, node: LayerPrelude, __ast_path: &mut AstKindPath, ) -> LayerPrelude

fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length

fn fold_length_percentage( &mut self, node: LengthPercentage, __ast_path: &mut AstKindPath, ) -> LengthPercentage

fn fold_list_of_component_values( &mut self, node: ListOfComponentValues, __ast_path: &mut AstKindPath, ) -> ListOfComponentValues

fn fold_media_and( &mut self, node: MediaAnd, __ast_path: &mut AstKindPath, ) -> MediaAnd

fn fold_media_condition( &mut self, node: MediaCondition, __ast_path: &mut AstKindPath, ) -> MediaCondition

fn fold_media_condition_all_type( &mut self, node: MediaConditionAllType, __ast_path: &mut AstKindPath, ) -> MediaConditionAllType

fn fold_media_condition_all_types( &mut self, node: Vec<MediaConditionAllType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionAllType>

fn fold_media_condition_type( &mut self, node: MediaConditionType, __ast_path: &mut AstKindPath, ) -> MediaConditionType

fn fold_media_condition_without_or( &mut self, node: MediaConditionWithoutOr, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOr

fn fold_media_condition_without_or_type( &mut self, node: MediaConditionWithoutOrType, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOrType

fn fold_media_condition_without_or_types( &mut self, node: Vec<MediaConditionWithoutOrType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionWithoutOrType>

fn fold_media_feature( &mut self, node: MediaFeature, __ast_path: &mut AstKindPath, ) -> MediaFeature

fn fold_media_feature_boolean( &mut self, node: MediaFeatureBoolean, __ast_path: &mut AstKindPath, ) -> MediaFeatureBoolean

fn fold_media_feature_name( &mut self, node: MediaFeatureName, __ast_path: &mut AstKindPath, ) -> MediaFeatureName

fn fold_media_feature_plain( &mut self, node: MediaFeaturePlain, __ast_path: &mut AstKindPath, ) -> MediaFeaturePlain

fn fold_media_feature_range( &mut self, node: MediaFeatureRange, __ast_path: &mut AstKindPath, ) -> MediaFeatureRange

fn fold_media_feature_range_comparison( &mut self, node: MediaFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeComparison

fn fold_media_feature_range_interval( &mut self, node: MediaFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeInterval

fn fold_media_feature_value( &mut self, node: MediaFeatureValue, __ast_path: &mut AstKindPath, ) -> MediaFeatureValue

fn fold_media_in_parens( &mut self, node: MediaInParens, __ast_path: &mut AstKindPath, ) -> MediaInParens

fn fold_media_not( &mut self, node: MediaNot, __ast_path: &mut AstKindPath, ) -> MediaNot

fn fold_media_or( &mut self, node: MediaOr, __ast_path: &mut AstKindPath, ) -> MediaOr

fn fold_media_query( &mut self, node: MediaQuery, __ast_path: &mut AstKindPath, ) -> MediaQuery

fn fold_media_query_list( &mut self, node: MediaQueryList, __ast_path: &mut AstKindPath, ) -> MediaQueryList

fn fold_media_querys( &mut self, node: Vec<MediaQuery>, __ast_path: &mut AstKindPath, ) -> Vec<MediaQuery>

fn fold_media_type( &mut self, node: MediaType, __ast_path: &mut AstKindPath, ) -> MediaType

fn fold_named_namespace( &mut self, node: NamedNamespace, __ast_path: &mut AstKindPath, ) -> NamedNamespace

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

fn fold_namespace_prefix( &mut self, node: NamespacePrefix, __ast_path: &mut AstKindPath, ) -> NamespacePrefix

fn fold_namespace_prelude( &mut self, node: NamespacePrelude, __ast_path: &mut AstKindPath, ) -> NamespacePrelude

fn fold_namespace_prelude_uri( &mut self, node: NamespacePreludeUri, __ast_path: &mut AstKindPath, ) -> NamespacePreludeUri

fn fold_nesting_selector( &mut self, node: NestingSelector, __ast_path: &mut AstKindPath, ) -> NestingSelector

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

fn fold_number_type( &mut self, node: NumberType, __ast_path: &mut AstKindPath, ) -> NumberType

fn fold_opt_at_rule_prelude( &mut self, node: Option<Box<AtRulePrelude>>, __ast_path: &mut AstKindPath, ) -> Option<Box<AtRulePrelude>>

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_attribute_selector_matcher( &mut self, node: Option<AttributeSelectorMatcher>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorMatcher>

fn fold_opt_attribute_selector_modifier( &mut self, node: Option<AttributeSelectorModifier>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorModifier>

fn fold_opt_attribute_selector_value( &mut self, node: Option<AttributeSelectorValue>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorValue>

fn fold_opt_combinator( &mut self, node: Option<Combinator>, __ast_path: &mut AstKindPath, ) -> Option<Combinator>

fn fold_opt_container_name( &mut self, node: Option<ContainerName>, __ast_path: &mut AstKindPath, ) -> Option<ContainerName>

fn fold_opt_forgiving_selector_list( &mut self, node: Option<ForgivingSelectorList>, __ast_path: &mut AstKindPath, ) -> Option<ForgivingSelectorList>

fn fold_opt_function( &mut self, node: Option<Box<Function>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Function>>

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

fn fold_opt_import_conditions( &mut self, node: Option<Box<ImportConditions>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportConditions>>

fn fold_opt_import_layer_name( &mut self, node: Option<Box<ImportLayerName>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportLayerName>>

fn fold_opt_important_flag( &mut self, node: Option<ImportantFlag>, __ast_path: &mut AstKindPath, ) -> Option<ImportantFlag>

fn fold_opt_media_condition_type( &mut self, node: Option<Box<MediaConditionType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaConditionType>>

fn fold_opt_media_query_list( &mut self, node: Option<Box<MediaQueryList>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaQueryList>>

fn fold_opt_media_type( &mut self, node: Option<MediaType>, __ast_path: &mut AstKindPath, ) -> Option<MediaType>

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

fn fold_opt_namespace_prefix( &mut self, node: Option<NamespacePrefix>, __ast_path: &mut AstKindPath, ) -> Option<NamespacePrefix>

fn fold_opt_nesting_selector( &mut self, node: Option<NestingSelector>, __ast_path: &mut AstKindPath, ) -> Option<NestingSelector>

fn fold_opt_number( &mut self, node: Option<Number>, __ast_path: &mut AstKindPath, ) -> Option<Number>

fn fold_opt_page_selector_pseudos( &mut self, node: Option<Vec<PageSelectorPseudo>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PageSelectorPseudo>>

fn fold_opt_page_selector_type( &mut self, node: Option<PageSelectorType>, __ast_path: &mut AstKindPath, ) -> Option<PageSelectorType>

fn fold_opt_pseudo_class_selector_childrens( &mut self, node: Option<Vec<PseudoClassSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoClassSelectorChildren>>

fn fold_opt_pseudo_element_selector_childrens( &mut self, node: Option<Vec<PseudoElementSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoElementSelectorChildren>>

fn fold_opt_simple_block( &mut self, node: Option<SimpleBlock>, __ast_path: &mut AstKindPath, ) -> Option<SimpleBlock>

fn fold_opt_type_selector( &mut self, node: Option<Box<TypeSelector>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TypeSelector>>

fn fold_opt_url_modifiers( &mut self, node: Option<Vec<UrlModifier>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<UrlModifier>>

fn fold_opt_url_value( &mut self, node: Option<Box<UrlValue>>, __ast_path: &mut AstKindPath, ) -> Option<Box<UrlValue>>

fn fold_page_selector( &mut self, node: PageSelector, __ast_path: &mut AstKindPath, ) -> PageSelector

fn fold_page_selector_list( &mut self, node: PageSelectorList, __ast_path: &mut AstKindPath, ) -> PageSelectorList

fn fold_page_selector_pseudo( &mut self, node: PageSelectorPseudo, __ast_path: &mut AstKindPath, ) -> PageSelectorPseudo

fn fold_page_selector_pseudos( &mut self, node: Vec<PageSelectorPseudo>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelectorPseudo>

fn fold_page_selector_type( &mut self, node: PageSelectorType, __ast_path: &mut AstKindPath, ) -> PageSelectorType

fn fold_page_selectors( &mut self, node: Vec<PageSelector>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelector>

fn fold_percentage( &mut self, node: Percentage, __ast_path: &mut AstKindPath, ) -> Percentage

fn fold_pseudo_class_selector( &mut self, node: PseudoClassSelector, __ast_path: &mut AstKindPath, ) -> PseudoClassSelector

fn fold_pseudo_class_selector_children( &mut self, node: PseudoClassSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoClassSelectorChildren

fn fold_pseudo_class_selector_childrens( &mut self, node: Vec<PseudoClassSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoClassSelectorChildren>

fn fold_pseudo_element_selector( &mut self, node: PseudoElementSelector, __ast_path: &mut AstKindPath, ) -> PseudoElementSelector

fn fold_pseudo_element_selector_children( &mut self, node: PseudoElementSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoElementSelectorChildren

fn fold_pseudo_element_selector_childrens( &mut self, node: Vec<PseudoElementSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoElementSelectorChildren>

fn fold_qualified_rule( &mut self, node: QualifiedRule, __ast_path: &mut AstKindPath, ) -> QualifiedRule

fn fold_qualified_rule_prelude( &mut self, node: QualifiedRulePrelude, __ast_path: &mut AstKindPath, ) -> QualifiedRulePrelude

fn fold_query_in_parens( &mut self, node: QueryInParens, __ast_path: &mut AstKindPath, ) -> QueryInParens

fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio

fn fold_relative_selector( &mut self, node: RelativeSelector, __ast_path: &mut AstKindPath, ) -> RelativeSelector

fn fold_relative_selector_list( &mut self, node: RelativeSelectorList, __ast_path: &mut AstKindPath, ) -> RelativeSelectorList

fn fold_relative_selectors( &mut self, node: Vec<RelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<RelativeSelector>

fn fold_resolution( &mut self, node: Resolution, __ast_path: &mut AstKindPath, ) -> Resolution

fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule

fn fold_rules( &mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath, ) -> Vec<Rule>

fn fold_scope_range( &mut self, node: ScopeRange, __ast_path: &mut AstKindPath, ) -> ScopeRange

fn fold_selector_list( &mut self, node: SelectorList, __ast_path: &mut AstKindPath, ) -> SelectorList

fn fold_sequence_of_custom_idents( &mut self, node: SequenceOfCustomIdents, __ast_path: &mut AstKindPath, ) -> SequenceOfCustomIdents

fn fold_simple_block( &mut self, node: SimpleBlock, __ast_path: &mut AstKindPath, ) -> SimpleBlock

fn fold_size_feature( &mut self, node: SizeFeature, __ast_path: &mut AstKindPath, ) -> SizeFeature

fn fold_size_feature_boolean( &mut self, node: SizeFeatureBoolean, __ast_path: &mut AstKindPath, ) -> SizeFeatureBoolean

fn fold_size_feature_name( &mut self, node: SizeFeatureName, __ast_path: &mut AstKindPath, ) -> SizeFeatureName

fn fold_size_feature_plain( &mut self, node: SizeFeaturePlain, __ast_path: &mut AstKindPath, ) -> SizeFeaturePlain

fn fold_size_feature_range( &mut self, node: SizeFeatureRange, __ast_path: &mut AstKindPath, ) -> SizeFeatureRange

fn fold_size_feature_range_comparison( &mut self, node: SizeFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeComparison

fn fold_size_feature_range_interval( &mut self, node: SizeFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeInterval

fn fold_size_feature_value( &mut self, node: SizeFeatureValue, __ast_path: &mut AstKindPath, ) -> SizeFeatureValue

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

fn fold_style_block( &mut self, node: StyleBlock, __ast_path: &mut AstKindPath, ) -> StyleBlock

fn fold_stylesheet( &mut self, node: Stylesheet, __ast_path: &mut AstKindPath, ) -> Stylesheet

fn fold_subclass_selector( &mut self, node: SubclassSelector, __ast_path: &mut AstKindPath, ) -> SubclassSelector

fn fold_subclass_selectors( &mut self, node: Vec<SubclassSelector>, __ast_path: &mut AstKindPath, ) -> Vec<SubclassSelector>

fn fold_supports_and( &mut self, node: SupportsAnd, __ast_path: &mut AstKindPath, ) -> SupportsAnd

fn fold_supports_condition( &mut self, node: SupportsCondition, __ast_path: &mut AstKindPath, ) -> SupportsCondition

fn fold_supports_condition_type( &mut self, node: SupportsConditionType, __ast_path: &mut AstKindPath, ) -> SupportsConditionType

fn fold_supports_condition_types( &mut self, node: Vec<SupportsConditionType>, __ast_path: &mut AstKindPath, ) -> Vec<SupportsConditionType>

fn fold_supports_feature( &mut self, node: SupportsFeature, __ast_path: &mut AstKindPath, ) -> SupportsFeature

fn fold_supports_in_parens( &mut self, node: SupportsInParens, __ast_path: &mut AstKindPath, ) -> SupportsInParens

fn fold_supports_not( &mut self, node: SupportsNot, __ast_path: &mut AstKindPath, ) -> SupportsNot

fn fold_supports_or( &mut self, node: SupportsOr, __ast_path: &mut AstKindPath, ) -> SupportsOr

fn fold_tag_name_selector( &mut self, node: TagNameSelector, __ast_path: &mut AstKindPath, ) -> TagNameSelector

fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time

fn fold_time_percentage( &mut self, node: TimePercentage, __ast_path: &mut AstKindPath, ) -> TimePercentage

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

fn fold_type_selector( &mut self, node: TypeSelector, __ast_path: &mut AstKindPath, ) -> TypeSelector

fn fold_unicode_range( &mut self, node: UnicodeRange, __ast_path: &mut AstKindPath, ) -> UnicodeRange

fn fold_universal_selector( &mut self, node: UniversalSelector, __ast_path: &mut AstKindPath, ) -> UniversalSelector

fn fold_unknown_dimension( &mut self, node: UnknownDimension, __ast_path: &mut AstKindPath, ) -> UnknownDimension

fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url

fn fold_url_key_value( &mut self, node: UrlKeyValue, __ast_path: &mut AstKindPath, ) -> UrlKeyValue

fn fold_url_modifier( &mut self, node: UrlModifier, __ast_path: &mut AstKindPath, ) -> UrlModifier

fn fold_url_modifiers( &mut self, node: Vec<UrlModifier>, __ast_path: &mut AstKindPath, ) -> Vec<UrlModifier>

fn fold_url_value( &mut self, node: UrlValue, __ast_path: &mut AstKindPath, ) -> UrlValue

fn fold_url_value_raw( &mut self, node: UrlValueRaw, __ast_path: &mut AstKindPath, ) -> UrlValueRaw

fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName

impl<V> FoldAstPath for &mut V

where V: ?Sized + FoldAstPath,

fn fold_absolute_color_base( &mut self, node: AbsoluteColorBase, __ast_path: &mut AstKindPath, ) -> AbsoluteColorBase

fn fold_alpha_value( &mut self, node: AlphaValue, __ast_path: &mut AstKindPath, ) -> AlphaValue

fn fold_an_plus_b( &mut self, node: AnPlusB, __ast_path: &mut AstKindPath, ) -> AnPlusB

fn fold_an_plus_b_notation( &mut self, node: AnPlusBNotation, __ast_path: &mut AstKindPath, ) -> AnPlusBNotation

fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle

fn fold_angle_percentage( &mut self, node: AnglePercentage, __ast_path: &mut AstKindPath, ) -> AnglePercentage

fn fold_any_namespace( &mut self, node: AnyNamespace, __ast_path: &mut AstKindPath, ) -> AnyNamespace

fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule

fn fold_at_rule_name( &mut self, node: AtRuleName, __ast_path: &mut AstKindPath, ) -> AtRuleName

fn fold_at_rule_prelude( &mut self, node: AtRulePrelude, __ast_path: &mut AstKindPath, ) -> AtRulePrelude

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_attribute_selector( &mut self, node: AttributeSelector, __ast_path: &mut AstKindPath, ) -> AttributeSelector

fn fold_attribute_selector_matcher( &mut self, node: AttributeSelectorMatcher, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcher

fn fold_attribute_selector_matcher_value( &mut self, node: AttributeSelectorMatcherValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcherValue

fn fold_attribute_selector_modifier( &mut self, node: AttributeSelectorModifier, __ast_path: &mut AstKindPath, ) -> AttributeSelectorModifier

fn fold_attribute_selector_value( &mut self, node: AttributeSelectorValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorValue

fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp

fn fold_calc_operator( &mut self, node: CalcOperator, __ast_path: &mut AstKindPath, ) -> CalcOperator

fn fold_calc_operator_type( &mut self, node: CalcOperatorType, __ast_path: &mut AstKindPath, ) -> CalcOperatorType

fn fold_calc_product( &mut self, node: CalcProduct, __ast_path: &mut AstKindPath, ) -> CalcProduct

fn fold_calc_product_or_operator( &mut self, node: CalcProductOrOperator, __ast_path: &mut AstKindPath, ) -> CalcProductOrOperator

fn fold_calc_product_or_operators( &mut self, node: Vec<CalcProductOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcProductOrOperator>

fn fold_calc_sum( &mut self, node: CalcSum, __ast_path: &mut AstKindPath, ) -> CalcSum

fn fold_calc_value( &mut self, node: CalcValue, __ast_path: &mut AstKindPath, ) -> CalcValue

fn fold_calc_value_or_operator( &mut self, node: CalcValueOrOperator, __ast_path: &mut AstKindPath, ) -> CalcValueOrOperator

fn fold_calc_value_or_operators( &mut self, node: Vec<CalcValueOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcValueOrOperator>

fn fold_class_selector( &mut self, node: ClassSelector, __ast_path: &mut AstKindPath, ) -> ClassSelector

fn fold_cmyk_component( &mut self, node: CmykComponent, __ast_path: &mut AstKindPath, ) -> CmykComponent

fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color

fn fold_color_profile_name( &mut self, node: ColorProfileName, __ast_path: &mut AstKindPath, ) -> ColorProfileName

fn fold_combinator( &mut self, node: Combinator, __ast_path: &mut AstKindPath, ) -> Combinator

fn fold_combinator_value( &mut self, node: CombinatorValue, __ast_path: &mut AstKindPath, ) -> CombinatorValue

fn fold_complex_selector( &mut self, node: ComplexSelector, __ast_path: &mut AstKindPath, ) -> ComplexSelector

fn fold_complex_selector_children( &mut self, node: ComplexSelectorChildren, __ast_path: &mut AstKindPath, ) -> ComplexSelectorChildren

fn fold_complex_selector_childrens( &mut self, node: Vec<ComplexSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelectorChildren>

fn fold_complex_selectors( &mut self, node: Vec<ComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelector>

fn fold_component_value( &mut self, node: ComponentValue, __ast_path: &mut AstKindPath, ) -> ComponentValue

fn fold_component_values( &mut self, node: Vec<ComponentValue>, __ast_path: &mut AstKindPath, ) -> Vec<ComponentValue>

fn fold_compound_selector( &mut self, node: CompoundSelector, __ast_path: &mut AstKindPath, ) -> CompoundSelector

fn fold_compound_selector_list( &mut self, node: CompoundSelectorList, __ast_path: &mut AstKindPath, ) -> CompoundSelectorList

fn fold_compound_selectors( &mut self, node: Vec<CompoundSelector>, __ast_path: &mut AstKindPath, ) -> Vec<CompoundSelector>

fn fold_container_condition( &mut self, node: ContainerCondition, __ast_path: &mut AstKindPath, ) -> ContainerCondition

fn fold_container_name( &mut self, node: ContainerName, __ast_path: &mut AstKindPath, ) -> ContainerName

fn fold_container_query( &mut self, node: ContainerQuery, __ast_path: &mut AstKindPath, ) -> ContainerQuery

fn fold_container_query_and( &mut self, node: ContainerQueryAnd, __ast_path: &mut AstKindPath, ) -> ContainerQueryAnd

fn fold_container_query_not( &mut self, node: ContainerQueryNot, __ast_path: &mut AstKindPath, ) -> ContainerQueryNot

fn fold_container_query_or( &mut self, node: ContainerQueryOr, __ast_path: &mut AstKindPath, ) -> ContainerQueryOr

fn fold_container_query_type( &mut self, node: ContainerQueryType, __ast_path: &mut AstKindPath, ) -> ContainerQueryType

fn fold_container_query_types( &mut self, node: Vec<ContainerQueryType>, __ast_path: &mut AstKindPath, ) -> Vec<ContainerQueryType>

fn fold_custom_highlight_name( &mut self, node: CustomHighlightName, __ast_path: &mut AstKindPath, ) -> CustomHighlightName

fn fold_custom_ident( &mut self, node: CustomIdent, __ast_path: &mut AstKindPath, ) -> CustomIdent

fn fold_custom_idents( &mut self, node: Vec<CustomIdent>, __ast_path: &mut AstKindPath, ) -> Vec<CustomIdent>

fn fold_custom_media_query( &mut self, node: CustomMediaQuery, __ast_path: &mut AstKindPath, ) -> CustomMediaQuery

fn fold_custom_media_query_media_type( &mut self, node: CustomMediaQueryMediaType, __ast_path: &mut AstKindPath, ) -> CustomMediaQueryMediaType

fn fold_custom_property_name( &mut self, node: CustomPropertyName, __ast_path: &mut AstKindPath, ) -> CustomPropertyName

fn fold_dashed_ident( &mut self, node: DashedIdent, __ast_path: &mut AstKindPath, ) -> DashedIdent

fn fold_declaration( &mut self, node: Declaration, __ast_path: &mut AstKindPath, ) -> Declaration

fn fold_declaration_name( &mut self, node: DeclarationName, __ast_path: &mut AstKindPath, ) -> DeclarationName

fn fold_declaration_or_at_rule( &mut self, node: DeclarationOrAtRule, __ast_path: &mut AstKindPath, ) -> DeclarationOrAtRule

fn fold_delimiter( &mut self, node: Delimiter, __ast_path: &mut AstKindPath, ) -> Delimiter

fn fold_delimiter_value( &mut self, node: DelimiterValue, __ast_path: &mut AstKindPath, ) -> DelimiterValue

fn fold_dimension( &mut self, node: Dimension, __ast_path: &mut AstKindPath, ) -> Dimension

fn fold_dimension_token( &mut self, node: DimensionToken, __ast_path: &mut AstKindPath, ) -> DimensionToken

fn fold_document_prelude( &mut self, node: DocumentPrelude, __ast_path: &mut AstKindPath, ) -> DocumentPrelude

fn fold_document_prelude_matching_function( &mut self, node: DocumentPreludeMatchingFunction, __ast_path: &mut AstKindPath, ) -> DocumentPreludeMatchingFunction

fn fold_document_prelude_matching_functions( &mut self, node: Vec<DocumentPreludeMatchingFunction>, __ast_path: &mut AstKindPath, ) -> Vec<DocumentPreludeMatchingFunction>

fn fold_extension_name( &mut self, node: ExtensionName, __ast_path: &mut AstKindPath, ) -> ExtensionName

fn fold_family_name( &mut self, node: FamilyName, __ast_path: &mut AstKindPath, ) -> FamilyName

fn fold_family_names( &mut self, node: Vec<FamilyName>, __ast_path: &mut AstKindPath, ) -> Vec<FamilyName>

fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex

fn fold_font_feature_values_prelude( &mut self, node: FontFeatureValuesPrelude, __ast_path: &mut AstKindPath, ) -> FontFeatureValuesPrelude

fn fold_forgiving_complex_selector( &mut self, node: ForgivingComplexSelector, __ast_path: &mut AstKindPath, ) -> ForgivingComplexSelector

fn fold_forgiving_complex_selectors( &mut self, node: Vec<ForgivingComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingComplexSelector>

fn fold_forgiving_relative_selector( &mut self, node: ForgivingRelativeSelector, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelector

fn fold_forgiving_relative_selector_list( &mut self, node: ForgivingRelativeSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelectorList

fn fold_forgiving_relative_selectors( &mut self, node: Vec<ForgivingRelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingRelativeSelector>

fn fold_forgiving_selector_list( &mut self, node: ForgivingSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingSelectorList

fn fold_frequency( &mut self, node: Frequency, __ast_path: &mut AstKindPath, ) -> Frequency

fn fold_frequency_percentage( &mut self, node: FrequencyPercentage, __ast_path: &mut AstKindPath, ) -> FrequencyPercentage

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

fn fold_function_name( &mut self, node: FunctionName, __ast_path: &mut AstKindPath, ) -> FunctionName

fn fold_general_enclosed( &mut self, node: GeneralEnclosed, __ast_path: &mut AstKindPath, ) -> GeneralEnclosed

fn fold_hex_color( &mut self, node: HexColor, __ast_path: &mut AstKindPath, ) -> HexColor

fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue

fn fold_id_selector( &mut self, node: IdSelector, __ast_path: &mut AstKindPath, ) -> IdSelector

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

fn fold_idents( &mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath, ) -> Vec<Ident>

fn fold_import_conditions( &mut self, node: ImportConditions, __ast_path: &mut AstKindPath, ) -> ImportConditions

fn fold_import_href( &mut self, node: ImportHref, __ast_path: &mut AstKindPath, ) -> ImportHref

fn fold_import_layer_name( &mut self, node: ImportLayerName, __ast_path: &mut AstKindPath, ) -> ImportLayerName

fn fold_import_prelude( &mut self, node: ImportPrelude, __ast_path: &mut AstKindPath, ) -> ImportPrelude

fn fold_important_flag( &mut self, node: ImportantFlag, __ast_path: &mut AstKindPath, ) -> ImportantFlag

fn fold_integer( &mut self, node: Integer, __ast_path: &mut AstKindPath, ) -> Integer

fn fold_keyframe_block( &mut self, node: KeyframeBlock, __ast_path: &mut AstKindPath, ) -> KeyframeBlock

fn fold_keyframe_selector( &mut self, node: KeyframeSelector, __ast_path: &mut AstKindPath, ) -> KeyframeSelector

fn fold_keyframe_selectors( &mut self, node: Vec<KeyframeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<KeyframeSelector>

fn fold_keyframes_name( &mut self, node: KeyframesName, __ast_path: &mut AstKindPath, ) -> KeyframesName

fn fold_keyframes_pseudo_function( &mut self, node: KeyframesPseudoFunction, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoFunction

fn fold_keyframes_pseudo_prefix( &mut self, node: KeyframesPseudoPrefix, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoPrefix

fn fold_layer_name( &mut self, node: LayerName, __ast_path: &mut AstKindPath, ) -> LayerName

fn fold_layer_name_list( &mut self, node: LayerNameList, __ast_path: &mut AstKindPath, ) -> LayerNameList

fn fold_layer_names( &mut self, node: Vec<LayerName>, __ast_path: &mut AstKindPath, ) -> Vec<LayerName>

fn fold_layer_prelude( &mut self, node: LayerPrelude, __ast_path: &mut AstKindPath, ) -> LayerPrelude

fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length

fn fold_length_percentage( &mut self, node: LengthPercentage, __ast_path: &mut AstKindPath, ) -> LengthPercentage

fn fold_list_of_component_values( &mut self, node: ListOfComponentValues, __ast_path: &mut AstKindPath, ) -> ListOfComponentValues

fn fold_media_and( &mut self, node: MediaAnd, __ast_path: &mut AstKindPath, ) -> MediaAnd

fn fold_media_condition( &mut self, node: MediaCondition, __ast_path: &mut AstKindPath, ) -> MediaCondition

fn fold_media_condition_all_type( &mut self, node: MediaConditionAllType, __ast_path: &mut AstKindPath, ) -> MediaConditionAllType

fn fold_media_condition_all_types( &mut self, node: Vec<MediaConditionAllType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionAllType>

fn fold_media_condition_type( &mut self, node: MediaConditionType, __ast_path: &mut AstKindPath, ) -> MediaConditionType

fn fold_media_condition_without_or( &mut self, node: MediaConditionWithoutOr, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOr

fn fold_media_condition_without_or_type( &mut self, node: MediaConditionWithoutOrType, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOrType

fn fold_media_condition_without_or_types( &mut self, node: Vec<MediaConditionWithoutOrType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionWithoutOrType>

fn fold_media_feature( &mut self, node: MediaFeature, __ast_path: &mut AstKindPath, ) -> MediaFeature

fn fold_media_feature_boolean( &mut self, node: MediaFeatureBoolean, __ast_path: &mut AstKindPath, ) -> MediaFeatureBoolean

fn fold_media_feature_name( &mut self, node: MediaFeatureName, __ast_path: &mut AstKindPath, ) -> MediaFeatureName

fn fold_media_feature_plain( &mut self, node: MediaFeaturePlain, __ast_path: &mut AstKindPath, ) -> MediaFeaturePlain

fn fold_media_feature_range( &mut self, node: MediaFeatureRange, __ast_path: &mut AstKindPath, ) -> MediaFeatureRange

fn fold_media_feature_range_comparison( &mut self, node: MediaFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeComparison

fn fold_media_feature_range_interval( &mut self, node: MediaFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeInterval

fn fold_media_feature_value( &mut self, node: MediaFeatureValue, __ast_path: &mut AstKindPath, ) -> MediaFeatureValue

fn fold_media_in_parens( &mut self, node: MediaInParens, __ast_path: &mut AstKindPath, ) -> MediaInParens

fn fold_media_not( &mut self, node: MediaNot, __ast_path: &mut AstKindPath, ) -> MediaNot

fn fold_media_or( &mut self, node: MediaOr, __ast_path: &mut AstKindPath, ) -> MediaOr

fn fold_media_query( &mut self, node: MediaQuery, __ast_path: &mut AstKindPath, ) -> MediaQuery

fn fold_media_query_list( &mut self, node: MediaQueryList, __ast_path: &mut AstKindPath, ) -> MediaQueryList

fn fold_media_querys( &mut self, node: Vec<MediaQuery>, __ast_path: &mut AstKindPath, ) -> Vec<MediaQuery>

fn fold_media_type( &mut self, node: MediaType, __ast_path: &mut AstKindPath, ) -> MediaType

fn fold_named_namespace( &mut self, node: NamedNamespace, __ast_path: &mut AstKindPath, ) -> NamedNamespace

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

fn fold_namespace_prefix( &mut self, node: NamespacePrefix, __ast_path: &mut AstKindPath, ) -> NamespacePrefix

fn fold_namespace_prelude( &mut self, node: NamespacePrelude, __ast_path: &mut AstKindPath, ) -> NamespacePrelude

fn fold_namespace_prelude_uri( &mut self, node: NamespacePreludeUri, __ast_path: &mut AstKindPath, ) -> NamespacePreludeUri

fn fold_nesting_selector( &mut self, node: NestingSelector, __ast_path: &mut AstKindPath, ) -> NestingSelector

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

fn fold_number_type( &mut self, node: NumberType, __ast_path: &mut AstKindPath, ) -> NumberType

fn fold_opt_at_rule_prelude( &mut self, node: Option<Box<AtRulePrelude>>, __ast_path: &mut AstKindPath, ) -> Option<Box<AtRulePrelude>>

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_attribute_selector_matcher( &mut self, node: Option<AttributeSelectorMatcher>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorMatcher>

fn fold_opt_attribute_selector_modifier( &mut self, node: Option<AttributeSelectorModifier>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorModifier>

fn fold_opt_attribute_selector_value( &mut self, node: Option<AttributeSelectorValue>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorValue>

fn fold_opt_combinator( &mut self, node: Option<Combinator>, __ast_path: &mut AstKindPath, ) -> Option<Combinator>

fn fold_opt_container_name( &mut self, node: Option<ContainerName>, __ast_path: &mut AstKindPath, ) -> Option<ContainerName>

fn fold_opt_forgiving_selector_list( &mut self, node: Option<ForgivingSelectorList>, __ast_path: &mut AstKindPath, ) -> Option<ForgivingSelectorList>

fn fold_opt_function( &mut self, node: Option<Box<Function>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Function>>

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

fn fold_opt_import_conditions( &mut self, node: Option<Box<ImportConditions>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportConditions>>

fn fold_opt_import_layer_name( &mut self, node: Option<Box<ImportLayerName>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportLayerName>>

fn fold_opt_important_flag( &mut self, node: Option<ImportantFlag>, __ast_path: &mut AstKindPath, ) -> Option<ImportantFlag>

fn fold_opt_media_condition_type( &mut self, node: Option<Box<MediaConditionType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaConditionType>>

fn fold_opt_media_query_list( &mut self, node: Option<Box<MediaQueryList>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaQueryList>>

fn fold_opt_media_type( &mut self, node: Option<MediaType>, __ast_path: &mut AstKindPath, ) -> Option<MediaType>

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

fn fold_opt_namespace_prefix( &mut self, node: Option<NamespacePrefix>, __ast_path: &mut AstKindPath, ) -> Option<NamespacePrefix>

fn fold_opt_nesting_selector( &mut self, node: Option<NestingSelector>, __ast_path: &mut AstKindPath, ) -> Option<NestingSelector>

fn fold_opt_number( &mut self, node: Option<Number>, __ast_path: &mut AstKindPath, ) -> Option<Number>

fn fold_opt_page_selector_pseudos( &mut self, node: Option<Vec<PageSelectorPseudo>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PageSelectorPseudo>>

fn fold_opt_page_selector_type( &mut self, node: Option<PageSelectorType>, __ast_path: &mut AstKindPath, ) -> Option<PageSelectorType>

fn fold_opt_pseudo_class_selector_childrens( &mut self, node: Option<Vec<PseudoClassSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoClassSelectorChildren>>

fn fold_opt_pseudo_element_selector_childrens( &mut self, node: Option<Vec<PseudoElementSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoElementSelectorChildren>>

fn fold_opt_simple_block( &mut self, node: Option<SimpleBlock>, __ast_path: &mut AstKindPath, ) -> Option<SimpleBlock>

fn fold_opt_type_selector( &mut self, node: Option<Box<TypeSelector>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TypeSelector>>

fn fold_opt_url_modifiers( &mut self, node: Option<Vec<UrlModifier>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<UrlModifier>>

fn fold_opt_url_value( &mut self, node: Option<Box<UrlValue>>, __ast_path: &mut AstKindPath, ) -> Option<Box<UrlValue>>

fn fold_page_selector( &mut self, node: PageSelector, __ast_path: &mut AstKindPath, ) -> PageSelector

fn fold_page_selector_list( &mut self, node: PageSelectorList, __ast_path: &mut AstKindPath, ) -> PageSelectorList

fn fold_page_selector_pseudo( &mut self, node: PageSelectorPseudo, __ast_path: &mut AstKindPath, ) -> PageSelectorPseudo

fn fold_page_selector_pseudos( &mut self, node: Vec<PageSelectorPseudo>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelectorPseudo>

fn fold_page_selector_type( &mut self, node: PageSelectorType, __ast_path: &mut AstKindPath, ) -> PageSelectorType

fn fold_page_selectors( &mut self, node: Vec<PageSelector>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelector>

fn fold_percentage( &mut self, node: Percentage, __ast_path: &mut AstKindPath, ) -> Percentage

fn fold_pseudo_class_selector( &mut self, node: PseudoClassSelector, __ast_path: &mut AstKindPath, ) -> PseudoClassSelector

fn fold_pseudo_class_selector_children( &mut self, node: PseudoClassSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoClassSelectorChildren

fn fold_pseudo_class_selector_childrens( &mut self, node: Vec<PseudoClassSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoClassSelectorChildren>

fn fold_pseudo_element_selector( &mut self, node: PseudoElementSelector, __ast_path: &mut AstKindPath, ) -> PseudoElementSelector

fn fold_pseudo_element_selector_children( &mut self, node: PseudoElementSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoElementSelectorChildren

fn fold_pseudo_element_selector_childrens( &mut self, node: Vec<PseudoElementSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoElementSelectorChildren>

fn fold_qualified_rule( &mut self, node: QualifiedRule, __ast_path: &mut AstKindPath, ) -> QualifiedRule

fn fold_qualified_rule_prelude( &mut self, node: QualifiedRulePrelude, __ast_path: &mut AstKindPath, ) -> QualifiedRulePrelude

fn fold_query_in_parens( &mut self, node: QueryInParens, __ast_path: &mut AstKindPath, ) -> QueryInParens

fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio

fn fold_relative_selector( &mut self, node: RelativeSelector, __ast_path: &mut AstKindPath, ) -> RelativeSelector

fn fold_relative_selector_list( &mut self, node: RelativeSelectorList, __ast_path: &mut AstKindPath, ) -> RelativeSelectorList

fn fold_relative_selectors( &mut self, node: Vec<RelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<RelativeSelector>

fn fold_resolution( &mut self, node: Resolution, __ast_path: &mut AstKindPath, ) -> Resolution

fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule

fn fold_rules( &mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath, ) -> Vec<Rule>

fn fold_scope_range( &mut self, node: ScopeRange, __ast_path: &mut AstKindPath, ) -> ScopeRange

fn fold_selector_list( &mut self, node: SelectorList, __ast_path: &mut AstKindPath, ) -> SelectorList

fn fold_sequence_of_custom_idents( &mut self, node: SequenceOfCustomIdents, __ast_path: &mut AstKindPath, ) -> SequenceOfCustomIdents

fn fold_simple_block( &mut self, node: SimpleBlock, __ast_path: &mut AstKindPath, ) -> SimpleBlock

fn fold_size_feature( &mut self, node: SizeFeature, __ast_path: &mut AstKindPath, ) -> SizeFeature

fn fold_size_feature_boolean( &mut self, node: SizeFeatureBoolean, __ast_path: &mut AstKindPath, ) -> SizeFeatureBoolean

fn fold_size_feature_name( &mut self, node: SizeFeatureName, __ast_path: &mut AstKindPath, ) -> SizeFeatureName

fn fold_size_feature_plain( &mut self, node: SizeFeaturePlain, __ast_path: &mut AstKindPath, ) -> SizeFeaturePlain

fn fold_size_feature_range( &mut self, node: SizeFeatureRange, __ast_path: &mut AstKindPath, ) -> SizeFeatureRange

fn fold_size_feature_range_comparison( &mut self, node: SizeFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeComparison

fn fold_size_feature_range_interval( &mut self, node: SizeFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeInterval

fn fold_size_feature_value( &mut self, node: SizeFeatureValue, __ast_path: &mut AstKindPath, ) -> SizeFeatureValue

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

fn fold_style_block( &mut self, node: StyleBlock, __ast_path: &mut AstKindPath, ) -> StyleBlock

fn fold_stylesheet( &mut self, node: Stylesheet, __ast_path: &mut AstKindPath, ) -> Stylesheet

fn fold_subclass_selector( &mut self, node: SubclassSelector, __ast_path: &mut AstKindPath, ) -> SubclassSelector

fn fold_subclass_selectors( &mut self, node: Vec<SubclassSelector>, __ast_path: &mut AstKindPath, ) -> Vec<SubclassSelector>

fn fold_supports_and( &mut self, node: SupportsAnd, __ast_path: &mut AstKindPath, ) -> SupportsAnd

fn fold_supports_condition( &mut self, node: SupportsCondition, __ast_path: &mut AstKindPath, ) -> SupportsCondition

fn fold_supports_condition_type( &mut self, node: SupportsConditionType, __ast_path: &mut AstKindPath, ) -> SupportsConditionType

fn fold_supports_condition_types( &mut self, node: Vec<SupportsConditionType>, __ast_path: &mut AstKindPath, ) -> Vec<SupportsConditionType>

fn fold_supports_feature( &mut self, node: SupportsFeature, __ast_path: &mut AstKindPath, ) -> SupportsFeature

fn fold_supports_in_parens( &mut self, node: SupportsInParens, __ast_path: &mut AstKindPath, ) -> SupportsInParens

fn fold_supports_not( &mut self, node: SupportsNot, __ast_path: &mut AstKindPath, ) -> SupportsNot

fn fold_supports_or( &mut self, node: SupportsOr, __ast_path: &mut AstKindPath, ) -> SupportsOr

fn fold_tag_name_selector( &mut self, node: TagNameSelector, __ast_path: &mut AstKindPath, ) -> TagNameSelector

fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time

fn fold_time_percentage( &mut self, node: TimePercentage, __ast_path: &mut AstKindPath, ) -> TimePercentage

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

fn fold_type_selector( &mut self, node: TypeSelector, __ast_path: &mut AstKindPath, ) -> TypeSelector

fn fold_unicode_range( &mut self, node: UnicodeRange, __ast_path: &mut AstKindPath, ) -> UnicodeRange

fn fold_universal_selector( &mut self, node: UniversalSelector, __ast_path: &mut AstKindPath, ) -> UniversalSelector

fn fold_unknown_dimension( &mut self, node: UnknownDimension, __ast_path: &mut AstKindPath, ) -> UnknownDimension

fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url

fn fold_url_key_value( &mut self, node: UrlKeyValue, __ast_path: &mut AstKindPath, ) -> UrlKeyValue

fn fold_url_modifier( &mut self, node: UrlModifier, __ast_path: &mut AstKindPath, ) -> UrlModifier

fn fold_url_modifiers( &mut self, node: Vec<UrlModifier>, __ast_path: &mut AstKindPath, ) -> Vec<UrlModifier>

fn fold_url_value( &mut self, node: UrlValue, __ast_path: &mut AstKindPath, ) -> UrlValue

fn fold_url_value_raw( &mut self, node: UrlValueRaw, __ast_path: &mut AstKindPath, ) -> UrlValueRaw

fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName

impl<V> FoldAstPath for Box<V>

where V: ?Sized + FoldAstPath,

fn fold_absolute_color_base( &mut self, node: AbsoluteColorBase, __ast_path: &mut AstKindPath, ) -> AbsoluteColorBase

fn fold_alpha_value( &mut self, node: AlphaValue, __ast_path: &mut AstKindPath, ) -> AlphaValue

fn fold_an_plus_b( &mut self, node: AnPlusB, __ast_path: &mut AstKindPath, ) -> AnPlusB

fn fold_an_plus_b_notation( &mut self, node: AnPlusBNotation, __ast_path: &mut AstKindPath, ) -> AnPlusBNotation

fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle

fn fold_angle_percentage( &mut self, node: AnglePercentage, __ast_path: &mut AstKindPath, ) -> AnglePercentage

fn fold_any_namespace( &mut self, node: AnyNamespace, __ast_path: &mut AstKindPath, ) -> AnyNamespace

fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule

fn fold_at_rule_name( &mut self, node: AtRuleName, __ast_path: &mut AstKindPath, ) -> AtRuleName

fn fold_at_rule_prelude( &mut self, node: AtRulePrelude, __ast_path: &mut AstKindPath, ) -> AtRulePrelude

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_attribute_selector( &mut self, node: AttributeSelector, __ast_path: &mut AstKindPath, ) -> AttributeSelector

fn fold_attribute_selector_matcher( &mut self, node: AttributeSelectorMatcher, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcher

fn fold_attribute_selector_matcher_value( &mut self, node: AttributeSelectorMatcherValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcherValue

fn fold_attribute_selector_modifier( &mut self, node: AttributeSelectorModifier, __ast_path: &mut AstKindPath, ) -> AttributeSelectorModifier

fn fold_attribute_selector_value( &mut self, node: AttributeSelectorValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorValue

fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp

fn fold_calc_operator( &mut self, node: CalcOperator, __ast_path: &mut AstKindPath, ) -> CalcOperator

fn fold_calc_operator_type( &mut self, node: CalcOperatorType, __ast_path: &mut AstKindPath, ) -> CalcOperatorType

fn fold_calc_product( &mut self, node: CalcProduct, __ast_path: &mut AstKindPath, ) -> CalcProduct

fn fold_calc_product_or_operator( &mut self, node: CalcProductOrOperator, __ast_path: &mut AstKindPath, ) -> CalcProductOrOperator

fn fold_calc_product_or_operators( &mut self, node: Vec<CalcProductOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcProductOrOperator>

fn fold_calc_sum( &mut self, node: CalcSum, __ast_path: &mut AstKindPath, ) -> CalcSum

fn fold_calc_value( &mut self, node: CalcValue, __ast_path: &mut AstKindPath, ) -> CalcValue

fn fold_calc_value_or_operator( &mut self, node: CalcValueOrOperator, __ast_path: &mut AstKindPath, ) -> CalcValueOrOperator

fn fold_calc_value_or_operators( &mut self, node: Vec<CalcValueOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcValueOrOperator>

fn fold_class_selector( &mut self, node: ClassSelector, __ast_path: &mut AstKindPath, ) -> ClassSelector

fn fold_cmyk_component( &mut self, node: CmykComponent, __ast_path: &mut AstKindPath, ) -> CmykComponent

fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color

fn fold_color_profile_name( &mut self, node: ColorProfileName, __ast_path: &mut AstKindPath, ) -> ColorProfileName

fn fold_combinator( &mut self, node: Combinator, __ast_path: &mut AstKindPath, ) -> Combinator

fn fold_combinator_value( &mut self, node: CombinatorValue, __ast_path: &mut AstKindPath, ) -> CombinatorValue

fn fold_complex_selector( &mut self, node: ComplexSelector, __ast_path: &mut AstKindPath, ) -> ComplexSelector

fn fold_complex_selector_children( &mut self, node: ComplexSelectorChildren, __ast_path: &mut AstKindPath, ) -> ComplexSelectorChildren

fn fold_complex_selector_childrens( &mut self, node: Vec<ComplexSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelectorChildren>

fn fold_complex_selectors( &mut self, node: Vec<ComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelector>

fn fold_component_value( &mut self, node: ComponentValue, __ast_path: &mut AstKindPath, ) -> ComponentValue

fn fold_component_values( &mut self, node: Vec<ComponentValue>, __ast_path: &mut AstKindPath, ) -> Vec<ComponentValue>

fn fold_compound_selector( &mut self, node: CompoundSelector, __ast_path: &mut AstKindPath, ) -> CompoundSelector

fn fold_compound_selector_list( &mut self, node: CompoundSelectorList, __ast_path: &mut AstKindPath, ) -> CompoundSelectorList

fn fold_compound_selectors( &mut self, node: Vec<CompoundSelector>, __ast_path: &mut AstKindPath, ) -> Vec<CompoundSelector>

fn fold_container_condition( &mut self, node: ContainerCondition, __ast_path: &mut AstKindPath, ) -> ContainerCondition

fn fold_container_name( &mut self, node: ContainerName, __ast_path: &mut AstKindPath, ) -> ContainerName

fn fold_container_query( &mut self, node: ContainerQuery, __ast_path: &mut AstKindPath, ) -> ContainerQuery

fn fold_container_query_and( &mut self, node: ContainerQueryAnd, __ast_path: &mut AstKindPath, ) -> ContainerQueryAnd

fn fold_container_query_not( &mut self, node: ContainerQueryNot, __ast_path: &mut AstKindPath, ) -> ContainerQueryNot

fn fold_container_query_or( &mut self, node: ContainerQueryOr, __ast_path: &mut AstKindPath, ) -> ContainerQueryOr

fn fold_container_query_type( &mut self, node: ContainerQueryType, __ast_path: &mut AstKindPath, ) -> ContainerQueryType

fn fold_container_query_types( &mut self, node: Vec<ContainerQueryType>, __ast_path: &mut AstKindPath, ) -> Vec<ContainerQueryType>

fn fold_custom_highlight_name( &mut self, node: CustomHighlightName, __ast_path: &mut AstKindPath, ) -> CustomHighlightName

fn fold_custom_ident( &mut self, node: CustomIdent, __ast_path: &mut AstKindPath, ) -> CustomIdent

fn fold_custom_idents( &mut self, node: Vec<CustomIdent>, __ast_path: &mut AstKindPath, ) -> Vec<CustomIdent>

fn fold_custom_media_query( &mut self, node: CustomMediaQuery, __ast_path: &mut AstKindPath, ) -> CustomMediaQuery

fn fold_custom_media_query_media_type( &mut self, node: CustomMediaQueryMediaType, __ast_path: &mut AstKindPath, ) -> CustomMediaQueryMediaType

fn fold_custom_property_name( &mut self, node: CustomPropertyName, __ast_path: &mut AstKindPath, ) -> CustomPropertyName

fn fold_dashed_ident( &mut self, node: DashedIdent, __ast_path: &mut AstKindPath, ) -> DashedIdent

fn fold_declaration( &mut self, node: Declaration, __ast_path: &mut AstKindPath, ) -> Declaration

fn fold_declaration_name( &mut self, node: DeclarationName, __ast_path: &mut AstKindPath, ) -> DeclarationName

fn fold_declaration_or_at_rule( &mut self, node: DeclarationOrAtRule, __ast_path: &mut AstKindPath, ) -> DeclarationOrAtRule

fn fold_delimiter( &mut self, node: Delimiter, __ast_path: &mut AstKindPath, ) -> Delimiter

fn fold_delimiter_value( &mut self, node: DelimiterValue, __ast_path: &mut AstKindPath, ) -> DelimiterValue

fn fold_dimension( &mut self, node: Dimension, __ast_path: &mut AstKindPath, ) -> Dimension

fn fold_dimension_token( &mut self, node: DimensionToken, __ast_path: &mut AstKindPath, ) -> DimensionToken

fn fold_document_prelude( &mut self, node: DocumentPrelude, __ast_path: &mut AstKindPath, ) -> DocumentPrelude

fn fold_document_prelude_matching_function( &mut self, node: DocumentPreludeMatchingFunction, __ast_path: &mut AstKindPath, ) -> DocumentPreludeMatchingFunction

fn fold_document_prelude_matching_functions( &mut self, node: Vec<DocumentPreludeMatchingFunction>, __ast_path: &mut AstKindPath, ) -> Vec<DocumentPreludeMatchingFunction>

fn fold_extension_name( &mut self, node: ExtensionName, __ast_path: &mut AstKindPath, ) -> ExtensionName

fn fold_family_name( &mut self, node: FamilyName, __ast_path: &mut AstKindPath, ) -> FamilyName

fn fold_family_names( &mut self, node: Vec<FamilyName>, __ast_path: &mut AstKindPath, ) -> Vec<FamilyName>

fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex

fn fold_font_feature_values_prelude( &mut self, node: FontFeatureValuesPrelude, __ast_path: &mut AstKindPath, ) -> FontFeatureValuesPrelude

fn fold_forgiving_complex_selector( &mut self, node: ForgivingComplexSelector, __ast_path: &mut AstKindPath, ) -> ForgivingComplexSelector

fn fold_forgiving_complex_selectors( &mut self, node: Vec<ForgivingComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingComplexSelector>

fn fold_forgiving_relative_selector( &mut self, node: ForgivingRelativeSelector, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelector

fn fold_forgiving_relative_selector_list( &mut self, node: ForgivingRelativeSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelectorList

fn fold_forgiving_relative_selectors( &mut self, node: Vec<ForgivingRelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingRelativeSelector>

fn fold_forgiving_selector_list( &mut self, node: ForgivingSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingSelectorList

fn fold_frequency( &mut self, node: Frequency, __ast_path: &mut AstKindPath, ) -> Frequency

fn fold_frequency_percentage( &mut self, node: FrequencyPercentage, __ast_path: &mut AstKindPath, ) -> FrequencyPercentage

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

fn fold_function_name( &mut self, node: FunctionName, __ast_path: &mut AstKindPath, ) -> FunctionName

fn fold_general_enclosed( &mut self, node: GeneralEnclosed, __ast_path: &mut AstKindPath, ) -> GeneralEnclosed

fn fold_hex_color( &mut self, node: HexColor, __ast_path: &mut AstKindPath, ) -> HexColor

fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue

fn fold_id_selector( &mut self, node: IdSelector, __ast_path: &mut AstKindPath, ) -> IdSelector

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

fn fold_idents( &mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath, ) -> Vec<Ident>

fn fold_import_conditions( &mut self, node: ImportConditions, __ast_path: &mut AstKindPath, ) -> ImportConditions

fn fold_import_href( &mut self, node: ImportHref, __ast_path: &mut AstKindPath, ) -> ImportHref

fn fold_import_layer_name( &mut self, node: ImportLayerName, __ast_path: &mut AstKindPath, ) -> ImportLayerName

fn fold_import_prelude( &mut self, node: ImportPrelude, __ast_path: &mut AstKindPath, ) -> ImportPrelude

fn fold_important_flag( &mut self, node: ImportantFlag, __ast_path: &mut AstKindPath, ) -> ImportantFlag

fn fold_integer( &mut self, node: Integer, __ast_path: &mut AstKindPath, ) -> Integer

fn fold_keyframe_block( &mut self, node: KeyframeBlock, __ast_path: &mut AstKindPath, ) -> KeyframeBlock

fn fold_keyframe_selector( &mut self, node: KeyframeSelector, __ast_path: &mut AstKindPath, ) -> KeyframeSelector

fn fold_keyframe_selectors( &mut self, node: Vec<KeyframeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<KeyframeSelector>

fn fold_keyframes_name( &mut self, node: KeyframesName, __ast_path: &mut AstKindPath, ) -> KeyframesName

fn fold_keyframes_pseudo_function( &mut self, node: KeyframesPseudoFunction, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoFunction

fn fold_keyframes_pseudo_prefix( &mut self, node: KeyframesPseudoPrefix, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoPrefix

fn fold_layer_name( &mut self, node: LayerName, __ast_path: &mut AstKindPath, ) -> LayerName

fn fold_layer_name_list( &mut self, node: LayerNameList, __ast_path: &mut AstKindPath, ) -> LayerNameList

fn fold_layer_names( &mut self, node: Vec<LayerName>, __ast_path: &mut AstKindPath, ) -> Vec<LayerName>

fn fold_layer_prelude( &mut self, node: LayerPrelude, __ast_path: &mut AstKindPath, ) -> LayerPrelude

fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length

fn fold_length_percentage( &mut self, node: LengthPercentage, __ast_path: &mut AstKindPath, ) -> LengthPercentage

fn fold_list_of_component_values( &mut self, node: ListOfComponentValues, __ast_path: &mut AstKindPath, ) -> ListOfComponentValues

fn fold_media_and( &mut self, node: MediaAnd, __ast_path: &mut AstKindPath, ) -> MediaAnd

fn fold_media_condition( &mut self, node: MediaCondition, __ast_path: &mut AstKindPath, ) -> MediaCondition

fn fold_media_condition_all_type( &mut self, node: MediaConditionAllType, __ast_path: &mut AstKindPath, ) -> MediaConditionAllType

fn fold_media_condition_all_types( &mut self, node: Vec<MediaConditionAllType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionAllType>

fn fold_media_condition_type( &mut self, node: MediaConditionType, __ast_path: &mut AstKindPath, ) -> MediaConditionType

fn fold_media_condition_without_or( &mut self, node: MediaConditionWithoutOr, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOr

fn fold_media_condition_without_or_type( &mut self, node: MediaConditionWithoutOrType, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOrType

fn fold_media_condition_without_or_types( &mut self, node: Vec<MediaConditionWithoutOrType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionWithoutOrType>

fn fold_media_feature( &mut self, node: MediaFeature, __ast_path: &mut AstKindPath, ) -> MediaFeature

fn fold_media_feature_boolean( &mut self, node: MediaFeatureBoolean, __ast_path: &mut AstKindPath, ) -> MediaFeatureBoolean

fn fold_media_feature_name( &mut self, node: MediaFeatureName, __ast_path: &mut AstKindPath, ) -> MediaFeatureName

fn fold_media_feature_plain( &mut self, node: MediaFeaturePlain, __ast_path: &mut AstKindPath, ) -> MediaFeaturePlain

fn fold_media_feature_range( &mut self, node: MediaFeatureRange, __ast_path: &mut AstKindPath, ) -> MediaFeatureRange

fn fold_media_feature_range_comparison( &mut self, node: MediaFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeComparison

fn fold_media_feature_range_interval( &mut self, node: MediaFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeInterval

fn fold_media_feature_value( &mut self, node: MediaFeatureValue, __ast_path: &mut AstKindPath, ) -> MediaFeatureValue

fn fold_media_in_parens( &mut self, node: MediaInParens, __ast_path: &mut AstKindPath, ) -> MediaInParens

fn fold_media_not( &mut self, node: MediaNot, __ast_path: &mut AstKindPath, ) -> MediaNot

fn fold_media_or( &mut self, node: MediaOr, __ast_path: &mut AstKindPath, ) -> MediaOr

fn fold_media_query( &mut self, node: MediaQuery, __ast_path: &mut AstKindPath, ) -> MediaQuery

fn fold_media_query_list( &mut self, node: MediaQueryList, __ast_path: &mut AstKindPath, ) -> MediaQueryList

fn fold_media_querys( &mut self, node: Vec<MediaQuery>, __ast_path: &mut AstKindPath, ) -> Vec<MediaQuery>

fn fold_media_type( &mut self, node: MediaType, __ast_path: &mut AstKindPath, ) -> MediaType

fn fold_named_namespace( &mut self, node: NamedNamespace, __ast_path: &mut AstKindPath, ) -> NamedNamespace

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

fn fold_namespace_prefix( &mut self, node: NamespacePrefix, __ast_path: &mut AstKindPath, ) -> NamespacePrefix

fn fold_namespace_prelude( &mut self, node: NamespacePrelude, __ast_path: &mut AstKindPath, ) -> NamespacePrelude

fn fold_namespace_prelude_uri( &mut self, node: NamespacePreludeUri, __ast_path: &mut AstKindPath, ) -> NamespacePreludeUri

fn fold_nesting_selector( &mut self, node: NestingSelector, __ast_path: &mut AstKindPath, ) -> NestingSelector

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

fn fold_number_type( &mut self, node: NumberType, __ast_path: &mut AstKindPath, ) -> NumberType

fn fold_opt_at_rule_prelude( &mut self, node: Option<Box<AtRulePrelude>>, __ast_path: &mut AstKindPath, ) -> Option<Box<AtRulePrelude>>

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_attribute_selector_matcher( &mut self, node: Option<AttributeSelectorMatcher>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorMatcher>

fn fold_opt_attribute_selector_modifier( &mut self, node: Option<AttributeSelectorModifier>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorModifier>

fn fold_opt_attribute_selector_value( &mut self, node: Option<AttributeSelectorValue>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorValue>

fn fold_opt_combinator( &mut self, node: Option<Combinator>, __ast_path: &mut AstKindPath, ) -> Option<Combinator>

fn fold_opt_container_name( &mut self, node: Option<ContainerName>, __ast_path: &mut AstKindPath, ) -> Option<ContainerName>

fn fold_opt_forgiving_selector_list( &mut self, node: Option<ForgivingSelectorList>, __ast_path: &mut AstKindPath, ) -> Option<ForgivingSelectorList>

fn fold_opt_function( &mut self, node: Option<Box<Function>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Function>>

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

fn fold_opt_import_conditions( &mut self, node: Option<Box<ImportConditions>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportConditions>>

fn fold_opt_import_layer_name( &mut self, node: Option<Box<ImportLayerName>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportLayerName>>

fn fold_opt_important_flag( &mut self, node: Option<ImportantFlag>, __ast_path: &mut AstKindPath, ) -> Option<ImportantFlag>

fn fold_opt_media_condition_type( &mut self, node: Option<Box<MediaConditionType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaConditionType>>

fn fold_opt_media_query_list( &mut self, node: Option<Box<MediaQueryList>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaQueryList>>

fn fold_opt_media_type( &mut self, node: Option<MediaType>, __ast_path: &mut AstKindPath, ) -> Option<MediaType>

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

fn fold_opt_namespace_prefix( &mut self, node: Option<NamespacePrefix>, __ast_path: &mut AstKindPath, ) -> Option<NamespacePrefix>

fn fold_opt_nesting_selector( &mut self, node: Option<NestingSelector>, __ast_path: &mut AstKindPath, ) -> Option<NestingSelector>

fn fold_opt_number( &mut self, node: Option<Number>, __ast_path: &mut AstKindPath, ) -> Option<Number>

fn fold_opt_page_selector_pseudos( &mut self, node: Option<Vec<PageSelectorPseudo>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PageSelectorPseudo>>

fn fold_opt_page_selector_type( &mut self, node: Option<PageSelectorType>, __ast_path: &mut AstKindPath, ) -> Option<PageSelectorType>

fn fold_opt_pseudo_class_selector_childrens( &mut self, node: Option<Vec<PseudoClassSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoClassSelectorChildren>>

fn fold_opt_pseudo_element_selector_childrens( &mut self, node: Option<Vec<PseudoElementSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoElementSelectorChildren>>

fn fold_opt_simple_block( &mut self, node: Option<SimpleBlock>, __ast_path: &mut AstKindPath, ) -> Option<SimpleBlock>

fn fold_opt_type_selector( &mut self, node: Option<Box<TypeSelector>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TypeSelector>>

fn fold_opt_url_modifiers( &mut self, node: Option<Vec<UrlModifier>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<UrlModifier>>

fn fold_opt_url_value( &mut self, node: Option<Box<UrlValue>>, __ast_path: &mut AstKindPath, ) -> Option<Box<UrlValue>>

fn fold_page_selector( &mut self, node: PageSelector, __ast_path: &mut AstKindPath, ) -> PageSelector

fn fold_page_selector_list( &mut self, node: PageSelectorList, __ast_path: &mut AstKindPath, ) -> PageSelectorList

fn fold_page_selector_pseudo( &mut self, node: PageSelectorPseudo, __ast_path: &mut AstKindPath, ) -> PageSelectorPseudo

fn fold_page_selector_pseudos( &mut self, node: Vec<PageSelectorPseudo>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelectorPseudo>

fn fold_page_selector_type( &mut self, node: PageSelectorType, __ast_path: &mut AstKindPath, ) -> PageSelectorType

fn fold_page_selectors( &mut self, node: Vec<PageSelector>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelector>

fn fold_percentage( &mut self, node: Percentage, __ast_path: &mut AstKindPath, ) -> Percentage

fn fold_pseudo_class_selector( &mut self, node: PseudoClassSelector, __ast_path: &mut AstKindPath, ) -> PseudoClassSelector

fn fold_pseudo_class_selector_children( &mut self, node: PseudoClassSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoClassSelectorChildren

fn fold_pseudo_class_selector_childrens( &mut self, node: Vec<PseudoClassSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoClassSelectorChildren>

fn fold_pseudo_element_selector( &mut self, node: PseudoElementSelector, __ast_path: &mut AstKindPath, ) -> PseudoElementSelector

fn fold_pseudo_element_selector_children( &mut self, node: PseudoElementSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoElementSelectorChildren

fn fold_pseudo_element_selector_childrens( &mut self, node: Vec<PseudoElementSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoElementSelectorChildren>

fn fold_qualified_rule( &mut self, node: QualifiedRule, __ast_path: &mut AstKindPath, ) -> QualifiedRule

fn fold_qualified_rule_prelude( &mut self, node: QualifiedRulePrelude, __ast_path: &mut AstKindPath, ) -> QualifiedRulePrelude

fn fold_query_in_parens( &mut self, node: QueryInParens, __ast_path: &mut AstKindPath, ) -> QueryInParens

fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio

fn fold_relative_selector( &mut self, node: RelativeSelector, __ast_path: &mut AstKindPath, ) -> RelativeSelector

fn fold_relative_selector_list( &mut self, node: RelativeSelectorList, __ast_path: &mut AstKindPath, ) -> RelativeSelectorList

fn fold_relative_selectors( &mut self, node: Vec<RelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<RelativeSelector>

fn fold_resolution( &mut self, node: Resolution, __ast_path: &mut AstKindPath, ) -> Resolution

fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule

fn fold_rules( &mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath, ) -> Vec<Rule>

fn fold_scope_range( &mut self, node: ScopeRange, __ast_path: &mut AstKindPath, ) -> ScopeRange

fn fold_selector_list( &mut self, node: SelectorList, __ast_path: &mut AstKindPath, ) -> SelectorList

fn fold_sequence_of_custom_idents( &mut self, node: SequenceOfCustomIdents, __ast_path: &mut AstKindPath, ) -> SequenceOfCustomIdents

fn fold_simple_block( &mut self, node: SimpleBlock, __ast_path: &mut AstKindPath, ) -> SimpleBlock

fn fold_size_feature( &mut self, node: SizeFeature, __ast_path: &mut AstKindPath, ) -> SizeFeature

fn fold_size_feature_boolean( &mut self, node: SizeFeatureBoolean, __ast_path: &mut AstKindPath, ) -> SizeFeatureBoolean

fn fold_size_feature_name( &mut self, node: SizeFeatureName, __ast_path: &mut AstKindPath, ) -> SizeFeatureName

fn fold_size_feature_plain( &mut self, node: SizeFeaturePlain, __ast_path: &mut AstKindPath, ) -> SizeFeaturePlain

fn fold_size_feature_range( &mut self, node: SizeFeatureRange, __ast_path: &mut AstKindPath, ) -> SizeFeatureRange

fn fold_size_feature_range_comparison( &mut self, node: SizeFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeComparison

fn fold_size_feature_range_interval( &mut self, node: SizeFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeInterval

fn fold_size_feature_value( &mut self, node: SizeFeatureValue, __ast_path: &mut AstKindPath, ) -> SizeFeatureValue

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

fn fold_style_block( &mut self, node: StyleBlock, __ast_path: &mut AstKindPath, ) -> StyleBlock

fn fold_stylesheet( &mut self, node: Stylesheet, __ast_path: &mut AstKindPath, ) -> Stylesheet

fn fold_subclass_selector( &mut self, node: SubclassSelector, __ast_path: &mut AstKindPath, ) -> SubclassSelector

fn fold_subclass_selectors( &mut self, node: Vec<SubclassSelector>, __ast_path: &mut AstKindPath, ) -> Vec<SubclassSelector>

fn fold_supports_and( &mut self, node: SupportsAnd, __ast_path: &mut AstKindPath, ) -> SupportsAnd

fn fold_supports_condition( &mut self, node: SupportsCondition, __ast_path: &mut AstKindPath, ) -> SupportsCondition

fn fold_supports_condition_type( &mut self, node: SupportsConditionType, __ast_path: &mut AstKindPath, ) -> SupportsConditionType

fn fold_supports_condition_types( &mut self, node: Vec<SupportsConditionType>, __ast_path: &mut AstKindPath, ) -> Vec<SupportsConditionType>

fn fold_supports_feature( &mut self, node: SupportsFeature, __ast_path: &mut AstKindPath, ) -> SupportsFeature

fn fold_supports_in_parens( &mut self, node: SupportsInParens, __ast_path: &mut AstKindPath, ) -> SupportsInParens

fn fold_supports_not( &mut self, node: SupportsNot, __ast_path: &mut AstKindPath, ) -> SupportsNot

fn fold_supports_or( &mut self, node: SupportsOr, __ast_path: &mut AstKindPath, ) -> SupportsOr

fn fold_tag_name_selector( &mut self, node: TagNameSelector, __ast_path: &mut AstKindPath, ) -> TagNameSelector

fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time

fn fold_time_percentage( &mut self, node: TimePercentage, __ast_path: &mut AstKindPath, ) -> TimePercentage

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

fn fold_type_selector( &mut self, node: TypeSelector, __ast_path: &mut AstKindPath, ) -> TypeSelector

fn fold_unicode_range( &mut self, node: UnicodeRange, __ast_path: &mut AstKindPath, ) -> UnicodeRange

fn fold_universal_selector( &mut self, node: UniversalSelector, __ast_path: &mut AstKindPath, ) -> UniversalSelector

fn fold_unknown_dimension( &mut self, node: UnknownDimension, __ast_path: &mut AstKindPath, ) -> UnknownDimension

fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url

fn fold_url_key_value( &mut self, node: UrlKeyValue, __ast_path: &mut AstKindPath, ) -> UrlKeyValue

fn fold_url_modifier( &mut self, node: UrlModifier, __ast_path: &mut AstKindPath, ) -> UrlModifier

fn fold_url_modifiers( &mut self, node: Vec<UrlModifier>, __ast_path: &mut AstKindPath, ) -> Vec<UrlModifier>

fn fold_url_value( &mut self, node: UrlValue, __ast_path: &mut AstKindPath, ) -> UrlValue

fn fold_url_value_raw( &mut self, node: UrlValueRaw, __ast_path: &mut AstKindPath, ) -> UrlValueRaw

fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName

impl<V> FoldAstPath for Optional<V>

where V: FoldAstPath,

fn fold_absolute_color_base( &mut self, node: AbsoluteColorBase, __ast_path: &mut AstKindPath, ) -> AbsoluteColorBase

fn fold_alpha_value( &mut self, node: AlphaValue, __ast_path: &mut AstKindPath, ) -> AlphaValue

fn fold_an_plus_b( &mut self, node: AnPlusB, __ast_path: &mut AstKindPath, ) -> AnPlusB

fn fold_an_plus_b_notation( &mut self, node: AnPlusBNotation, __ast_path: &mut AstKindPath, ) -> AnPlusBNotation

fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle

fn fold_angle_percentage( &mut self, node: AnglePercentage, __ast_path: &mut AstKindPath, ) -> AnglePercentage

fn fold_any_namespace( &mut self, node: AnyNamespace, __ast_path: &mut AstKindPath, ) -> AnyNamespace

fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule

fn fold_at_rule_name( &mut self, node: AtRuleName, __ast_path: &mut AstKindPath, ) -> AtRuleName

fn fold_at_rule_prelude( &mut self, node: AtRulePrelude, __ast_path: &mut AstKindPath, ) -> AtRulePrelude

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_attribute_selector( &mut self, node: AttributeSelector, __ast_path: &mut AstKindPath, ) -> AttributeSelector

fn fold_attribute_selector_matcher( &mut self, node: AttributeSelectorMatcher, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcher

fn fold_attribute_selector_matcher_value( &mut self, node: AttributeSelectorMatcherValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorMatcherValue

fn fold_attribute_selector_modifier( &mut self, node: AttributeSelectorModifier, __ast_path: &mut AstKindPath, ) -> AttributeSelectorModifier

fn fold_attribute_selector_value( &mut self, node: AttributeSelectorValue, __ast_path: &mut AstKindPath, ) -> AttributeSelectorValue

fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp

fn fold_calc_operator( &mut self, node: CalcOperator, __ast_path: &mut AstKindPath, ) -> CalcOperator

fn fold_calc_operator_type( &mut self, node: CalcOperatorType, __ast_path: &mut AstKindPath, ) -> CalcOperatorType

fn fold_calc_product( &mut self, node: CalcProduct, __ast_path: &mut AstKindPath, ) -> CalcProduct

fn fold_calc_product_or_operator( &mut self, node: CalcProductOrOperator, __ast_path: &mut AstKindPath, ) -> CalcProductOrOperator

fn fold_calc_product_or_operators( &mut self, node: Vec<CalcProductOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcProductOrOperator>

fn fold_calc_sum( &mut self, node: CalcSum, __ast_path: &mut AstKindPath, ) -> CalcSum

fn fold_calc_value( &mut self, node: CalcValue, __ast_path: &mut AstKindPath, ) -> CalcValue

fn fold_calc_value_or_operator( &mut self, node: CalcValueOrOperator, __ast_path: &mut AstKindPath, ) -> CalcValueOrOperator

fn fold_calc_value_or_operators( &mut self, node: Vec<CalcValueOrOperator>, __ast_path: &mut AstKindPath, ) -> Vec<CalcValueOrOperator>

fn fold_class_selector( &mut self, node: ClassSelector, __ast_path: &mut AstKindPath, ) -> ClassSelector

fn fold_cmyk_component( &mut self, node: CmykComponent, __ast_path: &mut AstKindPath, ) -> CmykComponent

fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color

fn fold_color_profile_name( &mut self, node: ColorProfileName, __ast_path: &mut AstKindPath, ) -> ColorProfileName

fn fold_combinator( &mut self, node: Combinator, __ast_path: &mut AstKindPath, ) -> Combinator

fn fold_combinator_value( &mut self, node: CombinatorValue, __ast_path: &mut AstKindPath, ) -> CombinatorValue

fn fold_complex_selector( &mut self, node: ComplexSelector, __ast_path: &mut AstKindPath, ) -> ComplexSelector

fn fold_complex_selector_children( &mut self, node: ComplexSelectorChildren, __ast_path: &mut AstKindPath, ) -> ComplexSelectorChildren

fn fold_complex_selector_childrens( &mut self, node: Vec<ComplexSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelectorChildren>

fn fold_complex_selectors( &mut self, node: Vec<ComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ComplexSelector>

fn fold_component_value( &mut self, node: ComponentValue, __ast_path: &mut AstKindPath, ) -> ComponentValue

fn fold_component_values( &mut self, node: Vec<ComponentValue>, __ast_path: &mut AstKindPath, ) -> Vec<ComponentValue>

fn fold_compound_selector( &mut self, node: CompoundSelector, __ast_path: &mut AstKindPath, ) -> CompoundSelector

fn fold_compound_selector_list( &mut self, node: CompoundSelectorList, __ast_path: &mut AstKindPath, ) -> CompoundSelectorList

fn fold_compound_selectors( &mut self, node: Vec<CompoundSelector>, __ast_path: &mut AstKindPath, ) -> Vec<CompoundSelector>

fn fold_container_condition( &mut self, node: ContainerCondition, __ast_path: &mut AstKindPath, ) -> ContainerCondition

fn fold_container_name( &mut self, node: ContainerName, __ast_path: &mut AstKindPath, ) -> ContainerName

fn fold_container_query( &mut self, node: ContainerQuery, __ast_path: &mut AstKindPath, ) -> ContainerQuery

fn fold_container_query_and( &mut self, node: ContainerQueryAnd, __ast_path: &mut AstKindPath, ) -> ContainerQueryAnd

fn fold_container_query_not( &mut self, node: ContainerQueryNot, __ast_path: &mut AstKindPath, ) -> ContainerQueryNot

fn fold_container_query_or( &mut self, node: ContainerQueryOr, __ast_path: &mut AstKindPath, ) -> ContainerQueryOr

fn fold_container_query_type( &mut self, node: ContainerQueryType, __ast_path: &mut AstKindPath, ) -> ContainerQueryType

fn fold_container_query_types( &mut self, node: Vec<ContainerQueryType>, __ast_path: &mut AstKindPath, ) -> Vec<ContainerQueryType>

fn fold_custom_highlight_name( &mut self, node: CustomHighlightName, __ast_path: &mut AstKindPath, ) -> CustomHighlightName

fn fold_custom_ident( &mut self, node: CustomIdent, __ast_path: &mut AstKindPath, ) -> CustomIdent

fn fold_custom_idents( &mut self, node: Vec<CustomIdent>, __ast_path: &mut AstKindPath, ) -> Vec<CustomIdent>

fn fold_custom_media_query( &mut self, node: CustomMediaQuery, __ast_path: &mut AstKindPath, ) -> CustomMediaQuery

fn fold_custom_media_query_media_type( &mut self, node: CustomMediaQueryMediaType, __ast_path: &mut AstKindPath, ) -> CustomMediaQueryMediaType

fn fold_custom_property_name( &mut self, node: CustomPropertyName, __ast_path: &mut AstKindPath, ) -> CustomPropertyName

fn fold_dashed_ident( &mut self, node: DashedIdent, __ast_path: &mut AstKindPath, ) -> DashedIdent

fn fold_declaration( &mut self, node: Declaration, __ast_path: &mut AstKindPath, ) -> Declaration

fn fold_declaration_name( &mut self, node: DeclarationName, __ast_path: &mut AstKindPath, ) -> DeclarationName

fn fold_declaration_or_at_rule( &mut self, node: DeclarationOrAtRule, __ast_path: &mut AstKindPath, ) -> DeclarationOrAtRule

fn fold_delimiter( &mut self, node: Delimiter, __ast_path: &mut AstKindPath, ) -> Delimiter

fn fold_delimiter_value( &mut self, node: DelimiterValue, __ast_path: &mut AstKindPath, ) -> DelimiterValue

fn fold_dimension( &mut self, node: Dimension, __ast_path: &mut AstKindPath, ) -> Dimension

fn fold_dimension_token( &mut self, node: DimensionToken, __ast_path: &mut AstKindPath, ) -> DimensionToken

fn fold_document_prelude( &mut self, node: DocumentPrelude, __ast_path: &mut AstKindPath, ) -> DocumentPrelude

fn fold_document_prelude_matching_function( &mut self, node: DocumentPreludeMatchingFunction, __ast_path: &mut AstKindPath, ) -> DocumentPreludeMatchingFunction

fn fold_document_prelude_matching_functions( &mut self, node: Vec<DocumentPreludeMatchingFunction>, __ast_path: &mut AstKindPath, ) -> Vec<DocumentPreludeMatchingFunction>

fn fold_extension_name( &mut self, node: ExtensionName, __ast_path: &mut AstKindPath, ) -> ExtensionName

fn fold_family_name( &mut self, node: FamilyName, __ast_path: &mut AstKindPath, ) -> FamilyName

fn fold_family_names( &mut self, node: Vec<FamilyName>, __ast_path: &mut AstKindPath, ) -> Vec<FamilyName>

fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex

fn fold_font_feature_values_prelude( &mut self, node: FontFeatureValuesPrelude, __ast_path: &mut AstKindPath, ) -> FontFeatureValuesPrelude

fn fold_forgiving_complex_selector( &mut self, node: ForgivingComplexSelector, __ast_path: &mut AstKindPath, ) -> ForgivingComplexSelector

fn fold_forgiving_complex_selectors( &mut self, node: Vec<ForgivingComplexSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingComplexSelector>

fn fold_forgiving_relative_selector( &mut self, node: ForgivingRelativeSelector, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelector

fn fold_forgiving_relative_selector_list( &mut self, node: ForgivingRelativeSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingRelativeSelectorList

fn fold_forgiving_relative_selectors( &mut self, node: Vec<ForgivingRelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<ForgivingRelativeSelector>

fn fold_forgiving_selector_list( &mut self, node: ForgivingSelectorList, __ast_path: &mut AstKindPath, ) -> ForgivingSelectorList

fn fold_frequency( &mut self, node: Frequency, __ast_path: &mut AstKindPath, ) -> Frequency

fn fold_frequency_percentage( &mut self, node: FrequencyPercentage, __ast_path: &mut AstKindPath, ) -> FrequencyPercentage

fn fold_function( &mut self, node: Function, __ast_path: &mut AstKindPath, ) -> Function

fn fold_function_name( &mut self, node: FunctionName, __ast_path: &mut AstKindPath, ) -> FunctionName

fn fold_general_enclosed( &mut self, node: GeneralEnclosed, __ast_path: &mut AstKindPath, ) -> GeneralEnclosed

fn fold_hex_color( &mut self, node: HexColor, __ast_path: &mut AstKindPath, ) -> HexColor

fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue

fn fold_id_selector( &mut self, node: IdSelector, __ast_path: &mut AstKindPath, ) -> IdSelector

fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident

fn fold_idents( &mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath, ) -> Vec<Ident>

fn fold_import_conditions( &mut self, node: ImportConditions, __ast_path: &mut AstKindPath, ) -> ImportConditions

fn fold_import_href( &mut self, node: ImportHref, __ast_path: &mut AstKindPath, ) -> ImportHref

fn fold_import_layer_name( &mut self, node: ImportLayerName, __ast_path: &mut AstKindPath, ) -> ImportLayerName

fn fold_import_prelude( &mut self, node: ImportPrelude, __ast_path: &mut AstKindPath, ) -> ImportPrelude

fn fold_important_flag( &mut self, node: ImportantFlag, __ast_path: &mut AstKindPath, ) -> ImportantFlag

fn fold_integer( &mut self, node: Integer, __ast_path: &mut AstKindPath, ) -> Integer

fn fold_keyframe_block( &mut self, node: KeyframeBlock, __ast_path: &mut AstKindPath, ) -> KeyframeBlock

fn fold_keyframe_selector( &mut self, node: KeyframeSelector, __ast_path: &mut AstKindPath, ) -> KeyframeSelector

fn fold_keyframe_selectors( &mut self, node: Vec<KeyframeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<KeyframeSelector>

fn fold_keyframes_name( &mut self, node: KeyframesName, __ast_path: &mut AstKindPath, ) -> KeyframesName

fn fold_keyframes_pseudo_function( &mut self, node: KeyframesPseudoFunction, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoFunction

fn fold_keyframes_pseudo_prefix( &mut self, node: KeyframesPseudoPrefix, __ast_path: &mut AstKindPath, ) -> KeyframesPseudoPrefix

fn fold_layer_name( &mut self, node: LayerName, __ast_path: &mut AstKindPath, ) -> LayerName

fn fold_layer_name_list( &mut self, node: LayerNameList, __ast_path: &mut AstKindPath, ) -> LayerNameList

fn fold_layer_names( &mut self, node: Vec<LayerName>, __ast_path: &mut AstKindPath, ) -> Vec<LayerName>

fn fold_layer_prelude( &mut self, node: LayerPrelude, __ast_path: &mut AstKindPath, ) -> LayerPrelude

fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length

fn fold_length_percentage( &mut self, node: LengthPercentage, __ast_path: &mut AstKindPath, ) -> LengthPercentage

fn fold_list_of_component_values( &mut self, node: ListOfComponentValues, __ast_path: &mut AstKindPath, ) -> ListOfComponentValues

fn fold_media_and( &mut self, node: MediaAnd, __ast_path: &mut AstKindPath, ) -> MediaAnd

fn fold_media_condition( &mut self, node: MediaCondition, __ast_path: &mut AstKindPath, ) -> MediaCondition

fn fold_media_condition_all_type( &mut self, node: MediaConditionAllType, __ast_path: &mut AstKindPath, ) -> MediaConditionAllType

fn fold_media_condition_all_types( &mut self, node: Vec<MediaConditionAllType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionAllType>

fn fold_media_condition_type( &mut self, node: MediaConditionType, __ast_path: &mut AstKindPath, ) -> MediaConditionType

fn fold_media_condition_without_or( &mut self, node: MediaConditionWithoutOr, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOr

fn fold_media_condition_without_or_type( &mut self, node: MediaConditionWithoutOrType, __ast_path: &mut AstKindPath, ) -> MediaConditionWithoutOrType

fn fold_media_condition_without_or_types( &mut self, node: Vec<MediaConditionWithoutOrType>, __ast_path: &mut AstKindPath, ) -> Vec<MediaConditionWithoutOrType>

fn fold_media_feature( &mut self, node: MediaFeature, __ast_path: &mut AstKindPath, ) -> MediaFeature

fn fold_media_feature_boolean( &mut self, node: MediaFeatureBoolean, __ast_path: &mut AstKindPath, ) -> MediaFeatureBoolean

fn fold_media_feature_name( &mut self, node: MediaFeatureName, __ast_path: &mut AstKindPath, ) -> MediaFeatureName

fn fold_media_feature_plain( &mut self, node: MediaFeaturePlain, __ast_path: &mut AstKindPath, ) -> MediaFeaturePlain

fn fold_media_feature_range( &mut self, node: MediaFeatureRange, __ast_path: &mut AstKindPath, ) -> MediaFeatureRange

fn fold_media_feature_range_comparison( &mut self, node: MediaFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeComparison

fn fold_media_feature_range_interval( &mut self, node: MediaFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> MediaFeatureRangeInterval

fn fold_media_feature_value( &mut self, node: MediaFeatureValue, __ast_path: &mut AstKindPath, ) -> MediaFeatureValue

fn fold_media_in_parens( &mut self, node: MediaInParens, __ast_path: &mut AstKindPath, ) -> MediaInParens

fn fold_media_not( &mut self, node: MediaNot, __ast_path: &mut AstKindPath, ) -> MediaNot

fn fold_media_or( &mut self, node: MediaOr, __ast_path: &mut AstKindPath, ) -> MediaOr

fn fold_media_query( &mut self, node: MediaQuery, __ast_path: &mut AstKindPath, ) -> MediaQuery

fn fold_media_query_list( &mut self, node: MediaQueryList, __ast_path: &mut AstKindPath, ) -> MediaQueryList

fn fold_media_querys( &mut self, node: Vec<MediaQuery>, __ast_path: &mut AstKindPath, ) -> Vec<MediaQuery>

fn fold_media_type( &mut self, node: MediaType, __ast_path: &mut AstKindPath, ) -> MediaType

fn fold_named_namespace( &mut self, node: NamedNamespace, __ast_path: &mut AstKindPath, ) -> NamedNamespace

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

fn fold_namespace_prefix( &mut self, node: NamespacePrefix, __ast_path: &mut AstKindPath, ) -> NamespacePrefix

fn fold_namespace_prelude( &mut self, node: NamespacePrelude, __ast_path: &mut AstKindPath, ) -> NamespacePrelude

fn fold_namespace_prelude_uri( &mut self, node: NamespacePreludeUri, __ast_path: &mut AstKindPath, ) -> NamespacePreludeUri

fn fold_nesting_selector( &mut self, node: NestingSelector, __ast_path: &mut AstKindPath, ) -> NestingSelector

fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number

fn fold_number_type( &mut self, node: NumberType, __ast_path: &mut AstKindPath, ) -> NumberType

fn fold_opt_at_rule_prelude( &mut self, node: Option<Box<AtRulePrelude>>, __ast_path: &mut AstKindPath, ) -> Option<Box<AtRulePrelude>>

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_attribute_selector_matcher( &mut self, node: Option<AttributeSelectorMatcher>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorMatcher>

fn fold_opt_attribute_selector_modifier( &mut self, node: Option<AttributeSelectorModifier>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorModifier>

fn fold_opt_attribute_selector_value( &mut self, node: Option<AttributeSelectorValue>, __ast_path: &mut AstKindPath, ) -> Option<AttributeSelectorValue>

fn fold_opt_combinator( &mut self, node: Option<Combinator>, __ast_path: &mut AstKindPath, ) -> Option<Combinator>

fn fold_opt_container_name( &mut self, node: Option<ContainerName>, __ast_path: &mut AstKindPath, ) -> Option<ContainerName>

fn fold_opt_forgiving_selector_list( &mut self, node: Option<ForgivingSelectorList>, __ast_path: &mut AstKindPath, ) -> Option<ForgivingSelectorList>

fn fold_opt_function( &mut self, node: Option<Box<Function>>, __ast_path: &mut AstKindPath, ) -> Option<Box<Function>>

fn fold_opt_ident( &mut self, node: Option<Ident>, __ast_path: &mut AstKindPath, ) -> Option<Ident>

fn fold_opt_import_conditions( &mut self, node: Option<Box<ImportConditions>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportConditions>>

fn fold_opt_import_layer_name( &mut self, node: Option<Box<ImportLayerName>>, __ast_path: &mut AstKindPath, ) -> Option<Box<ImportLayerName>>

fn fold_opt_important_flag( &mut self, node: Option<ImportantFlag>, __ast_path: &mut AstKindPath, ) -> Option<ImportantFlag>

fn fold_opt_media_condition_type( &mut self, node: Option<Box<MediaConditionType>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaConditionType>>

fn fold_opt_media_query_list( &mut self, node: Option<Box<MediaQueryList>>, __ast_path: &mut AstKindPath, ) -> Option<Box<MediaQueryList>>

fn fold_opt_media_type( &mut self, node: Option<MediaType>, __ast_path: &mut AstKindPath, ) -> Option<MediaType>

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

fn fold_opt_namespace_prefix( &mut self, node: Option<NamespacePrefix>, __ast_path: &mut AstKindPath, ) -> Option<NamespacePrefix>

fn fold_opt_nesting_selector( &mut self, node: Option<NestingSelector>, __ast_path: &mut AstKindPath, ) -> Option<NestingSelector>

fn fold_opt_number( &mut self, node: Option<Number>, __ast_path: &mut AstKindPath, ) -> Option<Number>

fn fold_opt_page_selector_pseudos( &mut self, node: Option<Vec<PageSelectorPseudo>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PageSelectorPseudo>>

fn fold_opt_page_selector_type( &mut self, node: Option<PageSelectorType>, __ast_path: &mut AstKindPath, ) -> Option<PageSelectorType>

fn fold_opt_pseudo_class_selector_childrens( &mut self, node: Option<Vec<PseudoClassSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoClassSelectorChildren>>

fn fold_opt_pseudo_element_selector_childrens( &mut self, node: Option<Vec<PseudoElementSelectorChildren>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<PseudoElementSelectorChildren>>

fn fold_opt_simple_block( &mut self, node: Option<SimpleBlock>, __ast_path: &mut AstKindPath, ) -> Option<SimpleBlock>

fn fold_opt_type_selector( &mut self, node: Option<Box<TypeSelector>>, __ast_path: &mut AstKindPath, ) -> Option<Box<TypeSelector>>

fn fold_opt_url_modifiers( &mut self, node: Option<Vec<UrlModifier>>, __ast_path: &mut AstKindPath, ) -> Option<Vec<UrlModifier>>

fn fold_opt_url_value( &mut self, node: Option<Box<UrlValue>>, __ast_path: &mut AstKindPath, ) -> Option<Box<UrlValue>>

fn fold_page_selector( &mut self, node: PageSelector, __ast_path: &mut AstKindPath, ) -> PageSelector

fn fold_page_selector_list( &mut self, node: PageSelectorList, __ast_path: &mut AstKindPath, ) -> PageSelectorList

fn fold_page_selector_pseudo( &mut self, node: PageSelectorPseudo, __ast_path: &mut AstKindPath, ) -> PageSelectorPseudo

fn fold_page_selector_pseudos( &mut self, node: Vec<PageSelectorPseudo>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelectorPseudo>

fn fold_page_selector_type( &mut self, node: PageSelectorType, __ast_path: &mut AstKindPath, ) -> PageSelectorType

fn fold_page_selectors( &mut self, node: Vec<PageSelector>, __ast_path: &mut AstKindPath, ) -> Vec<PageSelector>

fn fold_percentage( &mut self, node: Percentage, __ast_path: &mut AstKindPath, ) -> Percentage

fn fold_pseudo_class_selector( &mut self, node: PseudoClassSelector, __ast_path: &mut AstKindPath, ) -> PseudoClassSelector

fn fold_pseudo_class_selector_children( &mut self, node: PseudoClassSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoClassSelectorChildren

fn fold_pseudo_class_selector_childrens( &mut self, node: Vec<PseudoClassSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoClassSelectorChildren>

fn fold_pseudo_element_selector( &mut self, node: PseudoElementSelector, __ast_path: &mut AstKindPath, ) -> PseudoElementSelector

fn fold_pseudo_element_selector_children( &mut self, node: PseudoElementSelectorChildren, __ast_path: &mut AstKindPath, ) -> PseudoElementSelectorChildren

fn fold_pseudo_element_selector_childrens( &mut self, node: Vec<PseudoElementSelectorChildren>, __ast_path: &mut AstKindPath, ) -> Vec<PseudoElementSelectorChildren>

fn fold_qualified_rule( &mut self, node: QualifiedRule, __ast_path: &mut AstKindPath, ) -> QualifiedRule

fn fold_qualified_rule_prelude( &mut self, node: QualifiedRulePrelude, __ast_path: &mut AstKindPath, ) -> QualifiedRulePrelude

fn fold_query_in_parens( &mut self, node: QueryInParens, __ast_path: &mut AstKindPath, ) -> QueryInParens

fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio

fn fold_relative_selector( &mut self, node: RelativeSelector, __ast_path: &mut AstKindPath, ) -> RelativeSelector

fn fold_relative_selector_list( &mut self, node: RelativeSelectorList, __ast_path: &mut AstKindPath, ) -> RelativeSelectorList

fn fold_relative_selectors( &mut self, node: Vec<RelativeSelector>, __ast_path: &mut AstKindPath, ) -> Vec<RelativeSelector>

fn fold_resolution( &mut self, node: Resolution, __ast_path: &mut AstKindPath, ) -> Resolution

fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule

fn fold_rules( &mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath, ) -> Vec<Rule>

fn fold_scope_range( &mut self, node: ScopeRange, __ast_path: &mut AstKindPath, ) -> ScopeRange

fn fold_selector_list( &mut self, node: SelectorList, __ast_path: &mut AstKindPath, ) -> SelectorList

fn fold_sequence_of_custom_idents( &mut self, node: SequenceOfCustomIdents, __ast_path: &mut AstKindPath, ) -> SequenceOfCustomIdents

fn fold_simple_block( &mut self, node: SimpleBlock, __ast_path: &mut AstKindPath, ) -> SimpleBlock

fn fold_size_feature( &mut self, node: SizeFeature, __ast_path: &mut AstKindPath, ) -> SizeFeature

fn fold_size_feature_boolean( &mut self, node: SizeFeatureBoolean, __ast_path: &mut AstKindPath, ) -> SizeFeatureBoolean

fn fold_size_feature_name( &mut self, node: SizeFeatureName, __ast_path: &mut AstKindPath, ) -> SizeFeatureName

fn fold_size_feature_plain( &mut self, node: SizeFeaturePlain, __ast_path: &mut AstKindPath, ) -> SizeFeaturePlain

fn fold_size_feature_range( &mut self, node: SizeFeatureRange, __ast_path: &mut AstKindPath, ) -> SizeFeatureRange

fn fold_size_feature_range_comparison( &mut self, node: SizeFeatureRangeComparison, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeComparison

fn fold_size_feature_range_interval( &mut self, node: SizeFeatureRangeInterval, __ast_path: &mut AstKindPath, ) -> SizeFeatureRangeInterval

fn fold_size_feature_value( &mut self, node: SizeFeatureValue, __ast_path: &mut AstKindPath, ) -> SizeFeatureValue

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str

fn fold_style_block( &mut self, node: StyleBlock, __ast_path: &mut AstKindPath, ) -> StyleBlock

fn fold_stylesheet( &mut self, node: Stylesheet, __ast_path: &mut AstKindPath, ) -> Stylesheet

fn fold_subclass_selector( &mut self, node: SubclassSelector, __ast_path: &mut AstKindPath, ) -> SubclassSelector

fn fold_subclass_selectors( &mut self, node: Vec<SubclassSelector>, __ast_path: &mut AstKindPath, ) -> Vec<SubclassSelector>

fn fold_supports_and( &mut self, node: SupportsAnd, __ast_path: &mut AstKindPath, ) -> SupportsAnd

fn fold_supports_condition( &mut self, node: SupportsCondition, __ast_path: &mut AstKindPath, ) -> SupportsCondition

fn fold_supports_condition_type( &mut self, node: SupportsConditionType, __ast_path: &mut AstKindPath, ) -> SupportsConditionType

fn fold_supports_condition_types( &mut self, node: Vec<SupportsConditionType>, __ast_path: &mut AstKindPath, ) -> Vec<SupportsConditionType>

fn fold_supports_feature( &mut self, node: SupportsFeature, __ast_path: &mut AstKindPath, ) -> SupportsFeature

fn fold_supports_in_parens( &mut self, node: SupportsInParens, __ast_path: &mut AstKindPath, ) -> SupportsInParens

fn fold_supports_not( &mut self, node: SupportsNot, __ast_path: &mut AstKindPath, ) -> SupportsNot

fn fold_supports_or( &mut self, node: SupportsOr, __ast_path: &mut AstKindPath, ) -> SupportsOr

fn fold_tag_name_selector( &mut self, node: TagNameSelector, __ast_path: &mut AstKindPath, ) -> TagNameSelector

fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time

fn fold_time_percentage( &mut self, node: TimePercentage, __ast_path: &mut AstKindPath, ) -> TimePercentage

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

fn fold_type_selector( &mut self, node: TypeSelector, __ast_path: &mut AstKindPath, ) -> TypeSelector

fn fold_unicode_range( &mut self, node: UnicodeRange, __ast_path: &mut AstKindPath, ) -> UnicodeRange

fn fold_universal_selector( &mut self, node: UniversalSelector, __ast_path: &mut AstKindPath, ) -> UniversalSelector

fn fold_unknown_dimension( &mut self, node: UnknownDimension, __ast_path: &mut AstKindPath, ) -> UnknownDimension

fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url

fn fold_url_key_value( &mut self, node: UrlKeyValue, __ast_path: &mut AstKindPath, ) -> UrlKeyValue

fn fold_url_modifier( &mut self, node: UrlModifier, __ast_path: &mut AstKindPath, ) -> UrlModifier

fn fold_url_modifiers( &mut self, node: Vec<UrlModifier>, __ast_path: &mut AstKindPath, ) -> Vec<UrlModifier>

fn fold_url_value( &mut self, node: UrlValue, __ast_path: &mut AstKindPath, ) -> UrlValue

fn fold_url_value_raw( &mut self, node: UrlValueRaw, __ast_path: &mut AstKindPath, ) -> UrlValueRaw

fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName

Implementors