Trait swc_css_visit::FoldWithPath

pub trait FoldWithPath<V: ?Sized + FoldAstPath> {
    // Required methods
    fn fold_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self;
    fn fold_children_with_path(
        self,
        v: &mut V,
        ast_path: &mut AstKindPath
    ) -> Self;
}

Available on crate feature path only.

A utility trait implemented for ast nodes, and allow to visit them with a visitor.

Required Methods

fn fold_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self

Calls a visitor method (v.fold_xxx) with self and the ast path.

fn fold_children_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self

Visit children nodes with v and ast path appended [AstKind] of self. The ast path will be resotred when this method returns.

This is the default implementaton of a handler method in FoldAstPath.

Implementations on Foreign Types

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Rule>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaQueryList

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportHref

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Token

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for KeyframeSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for DocumentPreludeMatchingFunction

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ComplexSelectorChildren

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaAnd

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SupportsAnd

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SimpleBlock

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Function

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Namespace>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<PseudoClassSelectorChildren>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<NestingSelector>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ContainerQueryAnd

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PseudoElementSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SupportsNot

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ExtensionName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Angle

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Atom>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Ident

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<MediaConditionAllType>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TagNameSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CompoundSelectorList

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<NamespacePrefix>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SizeFeatureName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaConditionWithoutOr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ForgivingRelativeSelectorList

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for WqName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CalcProductOrOperator

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<PageSelectorType>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Vec<PseudoElementSelectorChildren>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AttributeSelectorModifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Number>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<ContainerName>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaConditionAllType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CalcOperator

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Flex

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<AttributeSelectorMatcher>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for i32

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<RelativeSelector>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<DocumentPreludeMatchingFunction>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Length

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ForgivingRelativeSelector>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UniversalSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<ImportConditions>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ClassSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<CustomIdent>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<LayerName>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<SimpleBlock>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for IdSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Ident>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ForgivingComplexSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SubclassSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for KeyframesPseudoPrefix

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Atom

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<UrlValue>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AttributeSelectorMatcher

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AbsoluteColorBase

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportPrelude

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<AttributeSelectorValue>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for QualifiedRule

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for DocumentPrelude

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<PageSelectorPseudo>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for DelimiterValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaFeatureRange

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SelectorList

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<AttributeSelectorModifier>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<MediaConditionWithoutOrType>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for KeyframesPseudoFunction

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaOr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ForgivingSelectorList

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaFeatureRangeComparison

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Str

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SupportsOr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ForgivingRelativeSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<KeyframeSelector>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ContainerQueryType>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for DeclarationName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<ImportantFlag>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<CompoundSelector>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for RelativeSelectorList

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SupportsCondition

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Hue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaFeaturePlain

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Vec<PageSelectorPseudo>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CustomMediaQuery

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PageSelectorType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for KeyframeBlock

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CmykComponent

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<UrlModifier>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CustomMediaQueryMediaType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Stylesheet

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportConditions

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for FrequencyPercentage

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AttributeSelectorValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<PageSelector>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AnPlusBNotation

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<AtRulePrelude>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for JsWord

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaInParens

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CalcValueOrOperator

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UnicodeRange

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<Function>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportantFlag

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaFeatureRangeInterval

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for GeneralEnclosed

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<CalcProductOrOperator>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PageSelectorPseudo

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<MediaQuery>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SupportsInParens

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for LayerName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AtRulePrelude

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Vec<PseudoClassSelectorChildren>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaConditionWithoutOrType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaQuery

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for LayerPrelude

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<MediaQueryList>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AnPlusB

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<JsWord>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Combinator

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaFeatureName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for NamespacePrelude

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Span

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ContainerQueryOr

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CustomHighlightName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AtRuleName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SequenceOfCustomIdents

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Time

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TimePercentage

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaConditionType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AttributeSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Color

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for FamilyName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CustomIdent

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaFeatureValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for RelativeSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaFeatureBoolean

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UrlModifier

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for NestingSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ComplexSelector>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ContainerQueryNot

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<SubclassSelector>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ComponentValue>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for HexColor

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UrlValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<TypeSelector>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Ratio

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<MediaConditionType>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for NamedNamespace

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaNot

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PseudoElementSelectorChildren

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaCondition

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V, T> FoldWithPath<V> for Box<T>where V: ?Sized + FoldAstPath, T: 'static + FoldWithPath<V>,

fn fold_children_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self

Visit children nodes of self with v

fn fold_with_path(self, v: &mut V, ast_path: &mut AstKindPath) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PseudoClassSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Integer

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PseudoClassSelectorChildren

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CalcProduct

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for LayerNameList

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for NamespacePrefix

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ContainerName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AlphaValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ContainerQuery

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ContainerCondition

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for QueryInParens

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CalcSum

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Rule

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ComplexSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SizeFeatureRangeInterval

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CompoundSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Vec<UrlModifier>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Box<ImportLayerName>>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AnglePercentage

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SizeFeatureRangeComparison

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for DeclarationOrAtRule

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CombinatorValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AttributeSelectorMatcherValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SizeFeatureRange

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for StyleBlock

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for MediaFeature

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CalcOperatorType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Namespace

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SupportsFeature

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<SupportsConditionType>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for QualifiedRulePrelude

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SizeFeatureBoolean

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ContainerQueryType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ComplexSelectorChildren>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SizeFeatureValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Declaration

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SizeFeaturePlain

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for FunctionName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UrlValueRaw

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<Combinator>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<CalcValueOrOperator>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ColorProfileName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ImportLayerName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for DashedIdent

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SizeFeature

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Dimension

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<PseudoElementSelectorChildren>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for SupportsConditionType

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CustomPropertyName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AnyNamespace

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Delimiter

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for UnknownDimension

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<FamilyName>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for NamespacePreludeUri

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Resolution

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Frequency

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for LengthPercentage

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for KeyframesName

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<ForgivingComplexSelector>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Percentage

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for CalcValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<i32>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Url

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Option<MediaType>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TypeSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ComponentValue

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for AtRule

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Number

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for TokenAndSpan

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PageSelector

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for Vec<Ident>

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for PageSelectorList

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for ListOfComponentValues

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

impl<V: ?Sized + FoldAstPath> FoldWithPath<V> for FontFeatureValuesPrelude

fn fold_with_path(self, v: &mut V, __ast_path: &mut AstKindPath) -> Self

fn fold_children_with_path( self, v: &mut V, __ast_path: &mut AstKindPath ) -> Self

Implementors