oxc-css-parser 0.0.3

// This file is generated by removing the old proc-macro derives. Keep the lists in sync with the AST/token definitions.
macro_rules! impl_spanned_struct {
    ($name:ident $(<$lifetime:lifetime>)?) => {
        impl$(<$lifetime>)? crate::pos::Spanned for $name$(<$lifetime>)? {
            #[inline]
            fn span(&self) -> &Span {
                &self.span
            }
        }
    };
}

macro_rules! impl_spanned_enum {
    ($name:ident $(<$lifetime:lifetime>)? { tuple: [$($tuple:ident,)*], unit: [$($unit:ident,)*], }) => {
        impl$(<$lifetime>)? crate::pos::Spanned for $name$(<$lifetime>)? {
            #[inline]
            fn span(&self) -> &Span {
                match self {
                    $(Self::$tuple(value) => value.span(),)*
                    $(Self::$unit => panic!("not implemented"),)*
                }
            }
        }
    };
}

#[cfg(feature = "span_ignored_eq")]
macro_rules! impl_span_ignored_eq_struct {
    ($name:ident $(<$lifetime:lifetime>)? {}) => {
        impl$(<$lifetime>)? crate::SpanIgnoredEq for $name$(<$lifetime>)? {
            #[inline]
            fn span_ignored_eq(&self, _other: &Self) -> bool {
                true
            }
        }
    };
    ($name:ident $(<$lifetime:lifetime>)? { $first:ident $(, $field:ident)* $(,)? }) => {
        impl$(<$lifetime>)? crate::SpanIgnoredEq for $name$(<$lifetime>)? {
            #[inline]
            fn span_ignored_eq(&self, other: &Self) -> bool {
                crate::SpanIgnoredEq::span_ignored_eq(&self.$first, &other.$first)
                    $(&& crate::SpanIgnoredEq::span_ignored_eq(&self.$field, &other.$field))*
            }
        }
    };
}

#[cfg(feature = "span_ignored_eq")]
macro_rules! impl_span_ignored_eq_enum {
    ($name:ident $(<$lifetime:lifetime>)? { tuple: [$($tuple:ident,)*], unit: [$($unit:ident,)*], }) => {
        impl$(<$lifetime>)? crate::SpanIgnoredEq for $name$(<$lifetime>)? {
            #[inline]
            fn span_ignored_eq(&self, other: &Self) -> bool {
                match (self, other) {
                    $((Self::$tuple(left), Self::$tuple(right)) => crate::SpanIgnoredEq::span_ignored_eq(left, right),)*
                    $((Self::$unit, Self::$unit) => true,)*
                    _ => false,
                }
            }
        }
    };
}

#[cfg(feature = "variant_helpers")]
macro_rules! impl_enum_as_is {
    ($name:ident $(<$lifetime:lifetime>)? { tuple: [$($tuple:ident($tuple_ty:ty) => $is_tuple:ident, $as_tuple:ident,)*], unit: [$($unit:ident => $is_unit:ident,)*], }) => {
        impl$(<$lifetime>)? $name$(<$lifetime>)? {
            $(
                #[doc = concat!("Checks whether this is [`", stringify!($tuple), "`](Self::", stringify!($tuple), ").")]
                #[inline]
                pub fn $is_tuple(&self) -> bool {
                    matches!(self, Self::$tuple(..))
                }

                #[doc = concat!("Returns [`Some`] with a reference to [`", stringify!($tuple), "`](Self::", stringify!($tuple), "), otherwise [`None`].")]
                #[inline]
                pub fn $as_tuple(&self) -> Option<&$tuple_ty> {
                    match self {
                        Self::$tuple(value) => Some(value),
                        _ => None,
                    }
                }
            )*
            $(
                #[doc = concat!("Checks whether this is [`", stringify!($unit), "`](Self::", stringify!($unit), ").")]
                #[inline]
                pub fn $is_unit(&self) -> bool {
                    matches!(self, Self::$unit)
                }
            )*
        }
    };
}

// Spanned
impl_spanned_struct!(AnPlusB);
impl_spanned_struct!(AtRule<'a>);
impl_spanned_enum!(AtRulePrelude<'a> {
    tuple: [Charset, ColorProfile, Container, CounterStyle, CustomMedia, CustomSelector, Document, FontFeatureValues, FontPaletteValues, Import, Keyframes, Layer, LessImport, LessPlugin, Media, Namespace, Nest, Page, PositionTry, Property, SassAtRoot, SassContent, SassEach, SassExpr, SassExtend, SassFor, SassForward, SassFunction, SassImport, SassInclude, SassMixin, SassUse, Scope, ScrollTimeline, Supports, Unknown, ],
    unit: [],
});
impl_spanned_struct!(AttributeSelector<'a>);
impl_spanned_struct!(AttributeSelectorMatcher);
impl_spanned_struct!(AttributeSelectorModifier<'a>);
impl_spanned_enum!(AttributeSelectorValue<'a> {
    tuple: [Ident, Str, Number, Dimension, Percentage, LessEscapedStr, ],
    unit: [],
});
impl_spanned_struct!(BracketBlock<'a>);
impl_spanned_struct!(Calc<'a>);
impl_spanned_struct!(CalcOperator);
impl_spanned_enum!(CalcOperatorKind {
    tuple: [],
    unit: [Plus, Minus, Multiply, Division, ],
});
impl_spanned_struct!(ClassSelector<'a>);
impl_spanned_enum!(ColorProfilePrelude<'a> {
    tuple: [DashedIdent, DeviceCmyk, ],
    unit: [],
});
impl_spanned_struct!(Combinator);
impl_spanned_struct!(ComplexSelector<'a>);
impl_spanned_enum!(ComplexSelectorChild<'a> {
    tuple: [CompoundSelector, Combinator, ],
    unit: [],
});
impl_spanned_enum!(ComponentValue<'a> {
    tuple: [BracketBlock, Calc, Delimiter, Dimension, Function, HexColor, IdSelector, ImportantAnnotation, InterpolableIdent, InterpolableStr, LayerName, LessBinaryOperation, LessCondition, LessDetachedRuleset, LessEscapedStr, LessJavaScriptSnippet, LessList, LessMixinCall, LessNamespaceValue, LessNegativeValue, LessParenthesizedOperation, LessPercentKeyword, LessPropertyVariable, LessVariable, LessVariableVariable, Number, Percentage, Placeholder, PostcssSimpleVar, Ratio, SassArbitraryArgument, SassBinaryExpression, SassKeywordArgument, SassList, SassMap, SassQualifiedName, SassNestingDeclaration, SassParenthesizedExpression, SassParentSelector, SassUnaryExpression, SassVariable, TokenWithSpan, UnicodeRange, Url, ],
    unit: [],
});
impl_spanned_struct!(ComponentValues<'a>);
impl_spanned_struct!(CompoundSelector<'a>);
impl_spanned_struct!(CompoundSelectorList<'a>);
impl_spanned_struct!(ContainerCondition<'a>);
impl_spanned_enum!(ContainerConditionKind<'a> {
    tuple: [QueryInParens, And, Or, Not, ],
    unit: [],
});
impl_spanned_struct!(ContainerConditionAnd<'a>);
impl_spanned_struct!(ContainerConditionNot<'a>);
impl_spanned_struct!(ContainerConditionOr<'a>);
impl_spanned_struct!(ContainerPrelude<'a>);
impl_spanned_struct!(CustomMedia<'a>);
impl_spanned_enum!(CustomMediaValue<'a> {
    tuple: [MediaQueryList, True, False, ],
    unit: [],
});
impl_spanned_struct!(CustomSelector<'a>);
impl_spanned_struct!(CustomSelectorArg<'a>);
impl_spanned_struct!(CustomSelectorArgs<'a>);
impl_spanned_struct!(CustomSelectorPrelude<'a>);
impl_spanned_struct!(Declaration<'a>);
impl_spanned_struct!(Delimiter);
impl_spanned_struct!(Dimension<'a>);
impl_spanned_enum!(DimensionKind {
    tuple: [],
    unit: [Length, Angle, Duration, Frequency, Resolution, Flex, Unknown, ],
});
impl_spanned_struct!(DocumentPrelude<'a>);
impl_spanned_enum!(DocumentPreludeMatcher<'a> {
    tuple: [Url, Function, ],
    unit: [],
});
impl_spanned_enum!(FontFamilyName<'a> {
    tuple: [Str, Unquoted, ],
    unit: [],
});
impl_spanned_struct!(Function<'a>);
impl_spanned_enum!(FunctionName<'a> {
    tuple: [Ident, SassQualifiedName, LessListFunction, LessFormatFunction, ],
    unit: [],
});
impl_spanned_struct!(HexColor<'a>);
impl_spanned_struct!(Ident<'a>);
impl_spanned_struct!(ImportPrelude<'a>);
impl_spanned_enum!(ImportPreludeHref<'a> {
    tuple: [Str, Url, Function, ],
    unit: [],
});
impl_spanned_enum!(ImportPreludeLayer<'a> {
    tuple: [Empty, WithName, ],
    unit: [],
});
impl_spanned_struct!(ImportPreludeSupports<'a>);
impl_spanned_enum!(ImportPreludeSupportsKind<'a> {
    tuple: [SupportsCondition, Declaration, ],
    unit: [],
});
impl_spanned_enum!(InterpolableIdent<'a> {
    tuple: [Literal, SassInterpolated, LessInterpolated, Placeholder, ],
    unit: [],
});
impl_spanned_struct!(Placeholder<'a>);
impl_spanned_struct!(InterpolableIdentStaticPart<'a>);
impl_spanned_enum!(InterpolableStr<'a> {
    tuple: [Literal, SassInterpolated, LessInterpolated, ],
    unit: [],
});
impl_spanned_struct!(InterpolableStrStaticPart<'a>);
impl_spanned_struct!(InterpolableUrlStaticPart<'a>);
impl_spanned_struct!(IdSelector<'a>);
impl_spanned_struct!(ImportantAnnotation<'a>);
impl_spanned_struct!(KeyframeBlock<'a>);
impl_spanned_enum!(KeyframeSelector<'a> {
    tuple: [Ident, Percentage, ],
    unit: [],
});
impl_spanned_enum!(KeyframesName<'a> {
    tuple: [Ident, Str, LessVariable, LessEscapedStr, ],
    unit: [],
});
impl_spanned_enum!(LanguageRange<'a> {
    tuple: [Str, Ident, ],
    unit: [],
});
impl_spanned_struct!(LanguageRangeList<'a>);
impl_spanned_struct!(LayerName<'a>);
impl_spanned_struct!(LayerNames<'a>);
impl_spanned_struct!(LessBinaryCondition<'a>);
impl_spanned_struct!(LessBinaryConditionOperator);
impl_spanned_struct!(LessBinaryOperation<'a>);
impl_spanned_enum!(LessCondition<'a> {
    tuple: [Binary, Negated, Parenthesized, Value, ],
    unit: [],
});
impl_spanned_struct!(LessConditionalQualifiedRule<'a>);
impl_spanned_struct!(LessConditions<'a>);
impl_spanned_struct!(LessDetachedRuleset<'a>);
impl_spanned_struct!(LessEscapedStr<'a>);
impl_spanned_struct!(LessExtend<'a>);
impl_spanned_struct!(LessExtendList<'a>);
impl_spanned_struct!(LessExtendRule<'a>);
impl_spanned_struct!(LessFormatFunction);
impl_spanned_struct!(LessImportOptions<'a>);
impl_spanned_struct!(LessImportPrelude<'a>);
impl_spanned_struct!(LessInterpolatedIdent<'a>);
impl_spanned_enum!(LessInterpolatedIdentElement<'a> {
    tuple: [Variable, Property, Static, ],
    unit: [],
});
impl_spanned_struct!(LessInterpolatedStr<'a>);
impl_spanned_enum!(LessInterpolatedStrElement<'a> {
    tuple: [Variable, Property, Static, ],
    unit: [],
});
impl_spanned_struct!(LessJavaScriptSnippet<'a>);
impl_spanned_struct!(LessList<'a>);
impl_spanned_struct!(LessListFunction);
impl_spanned_struct!(LessLookup<'a>);
impl_spanned_enum!(LessLookupName<'a> {
    tuple: [LessVariable, LessVariableVariable, LessPropertyVariable, Ident, ],
    unit: [],
});
impl_spanned_struct!(LessLookups<'a>);
impl_spanned_enum!(LessMixinArgument<'a> {
    tuple: [Named, Value, Variadic, ],
    unit: [],
});
impl_spanned_struct!(LessMixinArguments<'a>);
impl_spanned_struct!(LessMixinCall<'a>);
impl_spanned_struct!(LessMixinCallee<'a>);
impl_spanned_struct!(LessMixinCalleeChild<'a>);
impl_spanned_struct!(LessMixinDefinition<'a>);
impl_spanned_enum!(LessMixinName<'a> {
    tuple: [ClassSelector, IdSelector, ],
    unit: [],
});
impl_spanned_struct!(LessMixinNamedArgument<'a>);
impl_spanned_struct!(LessMixinNamedParameter<'a>);
impl_spanned_struct!(LessMixinNamedParameterDefaultValue<'a>);
impl_spanned_enum!(LessMixinParameter<'a> {
    tuple: [Named, Unnamed, Variadic, ],
    unit: [],
});
impl_spanned_struct!(LessMixinParameters<'a>);
impl_spanned_enum!(LessMixinParameterName<'a> {
    tuple: [Variable, PropertyVariable, ],
    unit: [],
});
impl_spanned_struct!(LessMixinUnnamedParameter<'a>);
impl_spanned_struct!(LessMixinVariadicArgument<'a>);
impl_spanned_struct!(LessMixinVariadicParameter<'a>);
impl_spanned_struct!(LessNamespaceValue<'a>);
impl_spanned_enum!(LessNamespaceValueCallee<'a> {
    tuple: [LessMixinCall, LessVariable, ],
    unit: [],
});
impl_spanned_struct!(LessNegatedCondition<'a>);
impl_spanned_struct!(LessNegativeValue<'a>);
impl_spanned_struct!(LessOperationOperator);
impl_spanned_struct!(LessParenthesizedCondition<'a>);
impl_spanned_struct!(LessParenthesizedOperation<'a>);
impl_spanned_struct!(LessPercentKeyword);
impl_spanned_struct!(LessPlugin<'a>);
impl_spanned_enum!(LessPluginPath<'a> {
    tuple: [Str, Url, ],
    unit: [],
});
impl_spanned_struct!(LessPropertyInterpolation<'a>);
impl_spanned_struct!(LessPropertyMerge);
impl_spanned_enum!(LessPropertyMergeKind {
    tuple: [],
    unit: [Comma, Space, ],
});
impl_spanned_struct!(LessPropertyVariable<'a>);
impl_spanned_struct!(LessVariable<'a>);
impl_spanned_struct!(LessVariableCall<'a>);
impl_spanned_struct!(LessVariableDeclaration<'a>);
impl_spanned_struct!(LessVariableInterpolation<'a>);
impl_spanned_struct!(LessVariableVariable<'a>);
impl_spanned_struct!(MediaAnd<'a>);
impl_spanned_struct!(MediaCondition<'a>);
impl_spanned_struct!(MediaConditionAfterMediaType<'a>);
impl_spanned_enum!(MediaConditionKind<'a> {
    tuple: [MediaInParens, And, Or, Not, ],
    unit: [],
});
impl_spanned_enum!(MediaFeature<'a> {
    tuple: [Plain, Boolean, Range, RangeInterval, ],
    unit: [],
});
impl_spanned_struct!(MediaFeatureComparison);
impl_spanned_enum!(MediaFeatureName<'a> {
    tuple: [Ident, PostcssSimpleVar, SassVariable, ],
    unit: [],
});
impl_spanned_struct!(MediaFeatureBoolean<'a>);
impl_spanned_struct!(MediaFeaturePlain<'a>);
impl_spanned_struct!(MediaFeatureRange<'a>);
impl_spanned_struct!(MediaFeatureRangeInterval<'a>);
impl_spanned_struct!(MediaInParens<'a>);
impl_spanned_enum!(MediaInParensKind<'a> {
    tuple: [MediaCondition, MediaFeature, GeneralEnclosed, SassInterpolation, ],
    unit: [],
});
impl_spanned_struct!(MediaNot<'a>);
impl_spanned_struct!(MediaOr<'a>);
impl_spanned_enum!(MediaQuery<'a> {
    tuple: [ConditionOnly, WithType, Function, LessVariable, LessNamespaceValue, ],
    unit: [],
});
impl_spanned_struct!(MediaQueryList<'a>);
impl_spanned_struct!(MediaQueryWithType<'a>);
impl_spanned_struct!(NamespacePrelude<'a>);
impl_spanned_enum!(NamespacePreludeUri<'a> {
    tuple: [Str, Url, ],
    unit: [],
});
impl_spanned_struct!(NestingSelector<'a>);
impl_spanned_struct!(NsPrefix<'a>);
impl_spanned_enum!(NsPrefixKind<'a> {
    tuple: [Ident, Universal, ],
    unit: [],
});
impl_spanned_struct!(NsPrefixUniversal);
impl_spanned_struct!(Nth<'a>);
impl_spanned_enum!(NthIndex<'a> {
    tuple: [Odd, Even, Integer, AnPlusB, ],
    unit: [],
});
impl_spanned_struct!(NthMatcher<'a>);
impl_spanned_struct!(Number<'a>);
impl_spanned_struct!(PageSelector<'a>);
impl_spanned_struct!(PageSelectorList<'a>);
impl_spanned_struct!(Percentage<'a>);
impl_spanned_struct!(PostcssSimpleVar<'a>);
impl_spanned_struct!(PostcssSimpleVarDeclaration<'a>);
impl_spanned_struct!(PseudoClassSelector<'a>);
impl_spanned_struct!(PseudoClassSelectorArg<'a>);
impl_spanned_enum!(PseudoClassSelectorArgKind<'a> {
    tuple: [CompoundSelector, CompoundSelectorList, Ident, LanguageRangeList, Nth, Number, RelativeSelectorList, SelectorList, LessExtendList, TokenSeq, ],
    unit: [],
});
impl_spanned_struct!(PseudoElementSelector<'a>);
impl_spanned_struct!(PseudoElementSelectorArg<'a>);
impl_spanned_enum!(PseudoElementSelectorArgKind<'a> {
    tuple: [CompoundSelector, Ident, TokenSeq, ],
    unit: [],
});
impl_spanned_struct!(PseudoPage<'a>);
impl_spanned_struct!(QualifiedRule<'a>);
impl_spanned_struct!(QueryInParens<'a>);
impl_spanned_enum!(QueryInParensKind<'a> {
    tuple: [ContainerCondition, SizeFeature, StyleQuery, ScrollState, ],
    unit: [],
});
impl_spanned_struct!(Ratio<'a>);
impl_spanned_struct!(RelativeSelector<'a>);
impl_spanned_struct!(RelativeSelectorList<'a>);
impl_spanned_struct!(SassArbitraryArgument<'a>);
impl_spanned_struct!(SassArbitraryParameter<'a>);
impl_spanned_struct!(SassAtRoot<'a>);
impl_spanned_enum!(SassAtRootKind<'a> {
    tuple: [Selector, Query, ],
    unit: [],
});
impl_spanned_struct!(SassAtRootQuery<'a>);
impl_spanned_struct!(SassAtRootQueryModifier);
impl_spanned_enum!(SassAtRootQueryRule<'a> {
    tuple: [Ident, Str, ],
    unit: [],
});
impl_spanned_struct!(SassBinaryExpression<'a>);
impl_spanned_struct!(SassBinaryOperator);
impl_spanned_struct!(SassConditionalClause<'a>);
impl_spanned_struct!(SassContent<'a>);
impl_spanned_struct!(SassEach<'a>);
impl_spanned_struct!(SassExtend<'a>);
impl_spanned_struct!(SassFlag<'a>);
impl_spanned_struct!(SassFor<'a>);
impl_spanned_struct!(SassForBoundary);
impl_spanned_enum!(SassForBoundaryKind {
    tuple: [],
    unit: [Inclusive, Exclusive, ],
});
impl_spanned_struct!(SassForward<'a>);
impl_spanned_enum!(SassForwardMember<'a> {
    tuple: [Ident, Variable, ],
    unit: [],
});
impl_spanned_struct!(SassForwardPrefix<'a>);
impl_spanned_struct!(SassForwardVisibility<'a>);
impl_spanned_struct!(SassForwardVisibilityModifier);
impl_spanned_enum!(SassForwardVisibilityModifierKind {
    tuple: [],
    unit: [Hide, Show, ],
});
impl_spanned_struct!(SassFunction<'a>);
impl_spanned_struct!(SassIfAtRule<'a>);
impl_spanned_struct!(SassImportPrelude<'a>);
impl_spanned_struct!(SassInclude<'a>);
impl_spanned_struct!(SassIncludeArgs<'a>);
impl_spanned_struct!(SassIncludeContentBlockParams<'a>);
impl_spanned_struct!(SassInterpolatedIdent<'a>);
impl_spanned_enum!(SassInterpolatedIdentElement<'a> {
    tuple: [Expression, Static, ],
    unit: [],
});
impl_spanned_struct!(SassInterpolatedStr<'a>);
impl_spanned_enum!(SassInterpolatedStrElement<'a> {
    tuple: [Expression, Static, ],
    unit: [],
});
impl_spanned_struct!(SassInterpolatedUrl<'a>);
impl_spanned_enum!(SassInterpolatedUrlElement<'a> {
    tuple: [Expression, Static, ],
    unit: [],
});
impl_spanned_struct!(SassKeywordArgument<'a>);
impl_spanned_struct!(SassList<'a>);
impl_spanned_struct!(SassMap<'a>);
impl_spanned_struct!(SassMapItem<'a>);
impl_spanned_struct!(SassMixin<'a>);
impl_spanned_struct!(SassModuleConfig<'a>);
impl_spanned_struct!(SassModuleConfigItem<'a>);
impl_spanned_enum!(SassModuleMemberName<'a> {
    tuple: [Ident, Variable, ],
    unit: [],
});
impl_spanned_struct!(SassNestingDeclaration<'a>);
impl_spanned_struct!(SassParameter<'a>);
impl_spanned_struct!(SassParameterDefaultValue<'a>);
impl_spanned_struct!(SassParameters<'a>);
impl_spanned_struct!(SassParenthesizedExpression<'a>);
impl_spanned_struct!(SassPlaceholderSelector<'a>);
impl_spanned_struct!(SassQualifiedName<'a>);
impl_spanned_struct!(SassUnaryExpression<'a>);
impl_spanned_struct!(SassUnaryOperator);
impl_spanned_struct!(SassUnnamedNamespace);
impl_spanned_struct!(SassUse<'a>);
impl_spanned_struct!(SassUseNamespace<'a>);
impl_spanned_enum!(SassUseNamespaceKind<'a> {
    tuple: [Named, Unnamed, ],
    unit: [],
});
impl_spanned_struct!(SassVariable<'a>);
impl_spanned_struct!(SassVariableDeclaration<'a>);
impl_spanned_struct!(ScopeEnd<'a>);
impl_spanned_enum!(ScopePrelude<'a> {
    tuple: [StartOnly, EndOnly, Both, ],
    unit: [],
});
impl_spanned_struct!(ScopeStart<'a>);
impl_spanned_struct!(ScopeStartWithEnd<'a>);
impl_spanned_struct!(SelectorList<'a>);
impl_spanned_struct!(SimpleBlock<'a>);
impl_spanned_enum!(SimpleSelector<'a> {
    tuple: [Class, Id, Type, Attribute, PseudoClass, PseudoElement, Nesting, SassPlaceholder, ],
    unit: [],
});
impl_spanned_enum!(Statement<'a> {
    tuple: [AtRule, Declaration, KeyframeBlock, LessConditionalQualifiedRule, LessExtendRule, LessFunctionCall, LessMixinCall, LessMixinDefinition, LessVariableCall, LessVariableDeclaration, Placeholder, PostcssSimpleVarDeclaration, QualifiedRule, SassIfAtRule, SassVariableDeclaration, UnknownSassAtRule, ],
    unit: [],
});
impl_spanned_struct!(Str<'a>);
impl_spanned_struct!(StyleCondition<'a>);
impl_spanned_enum!(StyleConditionKind<'a> {
    tuple: [StyleInParens, And, Or, Not, ],
    unit: [],
});
impl_spanned_struct!(StyleConditionAnd<'a>);
impl_spanned_struct!(StyleConditionNot<'a>);
impl_spanned_struct!(StyleConditionOr<'a>);
impl_spanned_struct!(StyleInParens<'a>);
impl_spanned_enum!(StyleInParensKind<'a> {
    tuple: [Condition, Feature, ],
    unit: [],
});
impl_spanned_enum!(StyleQuery<'a> {
    tuple: [Condition, Feature, ],
    unit: [],
});
impl_spanned_struct!(Stylesheet<'a>);
impl_spanned_struct!(SupportsAnd<'a>);
impl_spanned_struct!(SupportsCondition<'a>);
impl_spanned_enum!(SupportsConditionKind<'a> {
    tuple: [Not, And, Or, SupportsInParens, ],
    unit: [],
});
impl_spanned_struct!(SupportsDecl<'a>);
impl_spanned_struct!(SupportsInParens<'a>);
impl_spanned_enum!(SupportsInParensKind<'a> {
    tuple: [SupportsCondition, Feature, Selector, Function, GeneralEnclosed, ],
    unit: [],
});
impl_spanned_struct!(SupportsNot<'a>);
impl_spanned_struct!(SupportsOr<'a>);
impl_spanned_struct!(TagNameSelector<'a>);
impl_spanned_struct!(TokenSeq<'a>);
impl_spanned_enum!(TypeSelector<'a> {
    tuple: [TagName, Universal, ],
    unit: [],
});
impl_spanned_struct!(UnicodeRange<'a>);
impl_spanned_struct!(UniversalSelector<'a>);
impl_spanned_enum!(UnknownAtRulePrelude<'a> {
    tuple: [ComponentValue, TokenSeq, ],
    unit: [],
});
impl_spanned_struct!(UnknownSassAtRule<'a>);
impl_spanned_struct!(UnquotedFontFamilyName<'a>);
impl_spanned_struct!(Url<'a>);
impl_spanned_enum!(UrlModifier<'a> {
    tuple: [Ident, Function, ],
    unit: [],
});
impl_spanned_struct!(UrlRaw<'a>);
impl_spanned_enum!(UrlValue<'a> {
    tuple: [Raw, SassInterpolated, Str, LessEscapedStr, ],
    unit: [],
});
impl_spanned_struct!(WqName<'a>);

// SpanIgnoredEq
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(AnPlusB { a, b, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(AtRule<'a> { name, prelude, block, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(AtRulePrelude<'a> {
    tuple: [Charset, ColorProfile, Container, CounterStyle, CustomMedia, CustomSelector, Document, FontFeatureValues, FontPaletteValues, Import, Keyframes, Layer, LessImport, LessPlugin, Media, Namespace, Nest, Page, PositionTry, Property, SassAtRoot, SassContent, SassEach, SassExpr, SassExtend, SassFor, SassForward, SassFunction, SassImport, SassInclude, SassMixin, SassUse, Scope, ScrollTimeline, Supports, Unknown, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(AttributeSelector<'a> { name, matcher, value, modifier, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(AttributeSelectorMatcher { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(AttributeSelectorMatcherKind {
    tuple: [],
    unit: [Exact, MatchWord, ExactOrPrefixThenHyphen, Prefix, Suffix, Substring, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(AttributeSelectorModifier<'a> { ident, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(AttributeSelectorValue<'a> {
    tuple: [Ident, Str, Number, Dimension, Percentage, LessEscapedStr, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(BracketBlock<'a> { value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Calc<'a> { left, op, right, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(CalcOperator { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(CalcOperatorKind {
    tuple: [],
    unit: [Plus, Minus, Multiply, Division, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ClassSelector<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(ColorProfilePrelude<'a> {
    tuple: [DashedIdent, DeviceCmyk, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Combinator { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(CombinatorKind {
    tuple: [],
    unit: [Descendant, NextSibling, Child, LaterSibling, Column, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ComplexSelector<'a> { children, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(ComplexSelectorChild<'a> {
    tuple: [CompoundSelector, Combinator, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(ComponentValue<'a> {
    tuple: [BracketBlock, Calc, Delimiter, Dimension, Function, HexColor, IdSelector, ImportantAnnotation, InterpolableIdent, InterpolableStr, LayerName, LessBinaryOperation, LessCondition, LessDetachedRuleset, LessEscapedStr, LessJavaScriptSnippet, LessList, LessMixinCall, LessNamespaceValue, LessNegativeValue, LessParenthesizedOperation, LessPercentKeyword, LessPropertyVariable, LessVariable, LessVariableVariable, Number, Percentage, Placeholder, PostcssSimpleVar, Ratio, SassArbitraryArgument, SassBinaryExpression, SassKeywordArgument, SassList, SassMap, SassQualifiedName, SassNestingDeclaration, SassParenthesizedExpression, SassParentSelector, SassUnaryExpression, SassVariable, TokenWithSpan, UnicodeRange, Url, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ComponentValues<'a> { values, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(CompoundSelector<'a> { children, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(CompoundSelectorList<'a> { selectors, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ContainerCondition<'a> { conditions, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(ContainerConditionKind<'a> {
    tuple: [QueryInParens, And, Or, Not, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ContainerConditionAnd<'a> { keyword, query_in_parens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ContainerConditionNot<'a> { keyword, query_in_parens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ContainerConditionOr<'a> { keyword, query_in_parens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ContainerPrelude<'a> { name, condition, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(CustomMedia<'a> { name, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(CustomMediaValue<'a> {
    tuple: [MediaQueryList, True, False, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(CustomSelector<'a> { prefix_arg, name, args, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(CustomSelectorArg<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(CustomSelectorArgs<'a> { args, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(CustomSelectorPrelude<'a> { custom_selector, selector, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Declaration<'a> { name, name_suffix, colon_span, value, important, less_property_merge, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Delimiter { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(DelimiterKind {
    tuple: [],
    unit: [Comma, Solidus, Semicolon, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Dimension<'a> { value, unit, kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(DimensionKind {
    tuple: [],
    unit: [Length, Angle, Duration, Frequency, Resolution, Flex, Unknown, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(DocumentPrelude<'a> { matchers, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(DocumentPreludeMatcher<'a> {
    tuple: [Url, Function, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(FontFamilyName<'a> {
    tuple: [Str, Unquoted, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Function<'a> { name, args, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(FunctionName<'a> {
    tuple: [Ident, SassQualifiedName, LessListFunction, LessFormatFunction, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(HexColor<'a> { value, raw, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Ident<'a> { name, raw, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ImportPrelude<'a> { href, layer, supports, media, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(ImportPreludeHref<'a> {
    tuple: [Str, Url, Function, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(ImportPreludeLayer<'a> {
    tuple: [Empty, WithName, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ImportPreludeSupports<'a> { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(ImportPreludeSupportsKind<'a> {
    tuple: [SupportsCondition, Declaration, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(InterpolableIdent<'a> {
    tuple: [Literal, SassInterpolated, LessInterpolated, Placeholder, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Placeholder<'a> { index, suffix, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(InterpolableIdentStaticPart<'a> { value, raw, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(InterpolableStr<'a> {
    tuple: [Literal, SassInterpolated, LessInterpolated, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(InterpolableStrStaticPart<'a> { value, raw, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(InterpolableUrlStaticPart<'a> { value, raw, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(IdSelector<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ImportantAnnotation<'a> { ident, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(KeyframeBlock<'a> { selectors, comma_spans, block, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(KeyframeSelector<'a> {
    tuple: [Ident, Percentage, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(KeyframesName<'a> {
    tuple: [Ident, Str, LessVariable, LessEscapedStr, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LanguageRange<'a> {
    tuple: [Str, Ident, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LanguageRangeList<'a> { ranges, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LayerName<'a> { idents, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LayerNames<'a> { names, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessBinaryCondition<'a> { left, op, right, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessBinaryConditionOperator { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessBinaryConditionOperatorKind {
    tuple: [],
    unit: [GreaterThan, GreaterThanOrEqual, LessThan, LessThanOrEqual, Equal, EqualOrGreaterThan, EqualOrLessThan, And, Or, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessBinaryOperation<'a> { left, op, right, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessCondition<'a> {
    tuple: [Binary, Negated, Parenthesized, Value, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessConditionalQualifiedRule<'a> { selector, guard, block, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessConditions<'a> { conditions, when_span, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessDetachedRuleset<'a> { block, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessEscapedStr<'a> { str, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessExtend<'a> { selector, all, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessExtendList<'a> { elements, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessExtendRule<'a> { nesting_selector, name_of_extend, extend, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessFormatFunction {});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessImportOptions<'a> { names, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessImportPrelude<'a> { href, options, media, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessInterpolatedIdent<'a> { elements, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessInterpolatedIdentElement<'a> {
    tuple: [Variable, Property, Static, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessInterpolatedStr<'a> { elements, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessInterpolatedStrElement<'a> {
    tuple: [Variable, Property, Static, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessJavaScriptSnippet<'a> { code, raw, escaped, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessList<'a> { elements, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessListFunction {});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessLookup<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessLookupName<'a> {
    tuple: [LessVariable, LessVariableVariable, LessPropertyVariable, Ident, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessLookups<'a> { lookups, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessMixinArgument<'a> {
    tuple: [Named, Value, Variadic, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinArguments<'a> { args, is_comma_separated, separator_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinCall<'a> { callee, args, important, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinCallee<'a> { children, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinCalleeChild<'a> { name, combinator, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinDefinition<'a> { name, params, guard, block, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessMixinName<'a> {
    tuple: [ClassSelector, IdSelector, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinNamedArgument<'a> { name, colon_span, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinNamedParameter<'a> { name, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinNamedParameterDefaultValue<'a> { colon_span, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessMixinParameter<'a> {
    tuple: [Named, Unnamed, Variadic, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinParameters<'a> { params, is_comma_separated, separator_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessMixinParameterName<'a> {
    tuple: [Variable, PropertyVariable, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinUnnamedParameter<'a> { value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinVariadicArgument<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessMixinVariadicParameter<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessNamespaceValue<'a> { callee, lookups, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessNamespaceValueCallee<'a> {
    tuple: [LessMixinCall, LessVariable, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessNegatedCondition<'a> { condition, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessNegativeValue<'a> { value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessOperationOperator { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessOperationOperatorKind {
    tuple: [],
    unit: [Multiply, Division, Plus, Minus, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessParenthesizedCondition<'a> { condition, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessParenthesizedOperation<'a> { operation, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessPercentKeyword {});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessPlugin<'a> { path, args, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessPluginPath<'a> {
    tuple: [Str, Url, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessPropertyInterpolation<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessPropertyMerge { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(LessPropertyMergeKind {
    tuple: [],
    unit: [Comma, Space, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessPropertyVariable<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessVariable<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessVariableCall<'a> { variable, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessVariableDeclaration<'a> { name, colon_span, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessVariableInterpolation<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(LessVariableVariable<'a> { variable, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaAnd<'a> { keyword, media_in_parens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaCondition<'a> { conditions, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaConditionAfterMediaType<'a> { and, condition, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(MediaConditionKind<'a> {
    tuple: [MediaInParens, And, Or, Not, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(MediaFeature<'a> {
    tuple: [Plain, Boolean, Range, RangeInterval, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaFeatureComparison { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(MediaFeatureComparisonKind {
    tuple: [],
    unit: [LessThan, LessThanOrEqual, GreaterThan, GreaterThanOrEqual, Equal, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(MediaFeatureName<'a> {
    tuple: [Ident, PostcssSimpleVar, SassVariable, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaFeatureBoolean<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaFeaturePlain<'a> { name, colon_span, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaFeatureRange<'a> { left, comparison, right, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaFeatureRangeInterval<'a> { left, left_comparison, name, right_comparison, right, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaInParens<'a> { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(MediaInParensKind<'a> {
    tuple: [MediaCondition, MediaFeature, GeneralEnclosed, SassInterpolation, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaNot<'a> { keyword, media_in_parens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaOr<'a> { keyword, media_in_parens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(MediaQuery<'a> {
    tuple: [ConditionOnly, WithType, Function, LessVariable, LessNamespaceValue, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaQueryList<'a> { queries, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(MediaQueryWithType<'a> { modifier, media_type, condition, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(NamespacePrelude<'a> { prefix, uri, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(NamespacePreludeUri<'a> {
    tuple: [Str, Url, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(NestingSelector<'a> { suffix, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(NsPrefix<'a> { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(NsPrefixKind<'a> {
    tuple: [Ident, Universal, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(NsPrefixUniversal {});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Nth<'a> { index, matcher, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(NthIndex<'a> {
    tuple: [Odd, Even, Integer, AnPlusB, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(NthMatcher<'a> { selector, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Number<'a> { value, raw, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(PageSelector<'a> { name, pseudo, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(PageSelectorList<'a> { selectors, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Percentage<'a> { value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(PostcssSimpleVar<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(PostcssSimpleVarDeclaration<'a> { name, colon_span, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(PseudoClassSelector<'a> { name, arg, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(PseudoClassSelectorArg<'a> { kind, l_paren, r_paren, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(PseudoClassSelectorArgKind<'a> {
    tuple: [CompoundSelector, CompoundSelectorList, Ident, LanguageRangeList, Nth, Number, RelativeSelectorList, SelectorList, LessExtendList, TokenSeq, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(PseudoElementSelector<'a> { name, arg, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(PseudoElementSelectorArg<'a> { kind, l_paren, r_paren, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(PseudoElementSelectorArgKind<'a> {
    tuple: [CompoundSelector, Ident, TokenSeq, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(PseudoPage<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(QualifiedRule<'a> { selector, block, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(QueryInParens<'a> { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(QueryInParensKind<'a> {
    tuple: [ContainerCondition, SizeFeature, StyleQuery, ScrollState, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Ratio<'a> { numerator, solidus_span, denominator, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(RelativeSelector<'a> { combinator, complex_selector, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(RelativeSelectorList<'a> { selectors, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassArbitraryArgument<'a> { value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassArbitraryParameter<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassAtRoot<'a> { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassAtRootKind<'a> {
    tuple: [Selector, Query, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassAtRootQuery<'a> { modifier, colon_span, rules, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassAtRootQueryModifier { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassAtRootQueryModifierKind {
    tuple: [],
    unit: [With, Without, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassAtRootQueryRule<'a> {
    tuple: [Ident, Str, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassBinaryExpression<'a> { left, op, right, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassBinaryOperator { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassBinaryOperatorKind {
    tuple: [],
    unit: [Multiply, Division, Modulo, Plus, Minus, GreaterThan, GreaterThanOrEqual, LessThan, LessThanOrEqual, EqualsEquals, ExclamationEquals, And, Or, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassConditionalClause<'a> { condition, block, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassContent<'a> { args, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassEach<'a> { bindings, comma_spans, in_span, expr, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassExtend<'a> { selectors, optional, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassFlag<'a> { keyword, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassFor<'a> { binding, from_span, start, end, boundary, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassForBoundary { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassForBoundaryKind {
    tuple: [],
    unit: [Inclusive, Exclusive, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassForward<'a> { path, prefix, visibility, config, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassForwardMember<'a> {
    tuple: [Ident, Variable, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassForwardPrefix<'a> { as_span, name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassForwardVisibility<'a> { modifier, members, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassForwardVisibilityModifier { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassForwardVisibilityModifierKind {
    tuple: [],
    unit: [Hide, Show, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassFunction<'a> { name, parameters, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassIfAtRule<'a> { if_clause, else_if_clauses, else_clause, else_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassImportPrelude<'a> { paths, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassInclude<'a> { name, arguments, content_block_params, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassIncludeArgs<'a> { args, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassIncludeContentBlockParams<'a> { using_span, params, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassInterpolatedIdent<'a> { elements, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassInterpolatedIdentElement<'a> {
    tuple: [Expression, Static, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassInterpolatedStr<'a> { elements, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassInterpolatedStrElement<'a> {
    tuple: [Expression, Static, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassInterpolatedUrl<'a> { elements, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassInterpolatedUrlElement<'a> {
    tuple: [Expression, Static, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassKeywordArgument<'a> { name, colon_span, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassList<'a> { elements, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassMap<'a> { items, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassMapItem<'a> { key, colon_span, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassMixin<'a> { name, parameters, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassModuleConfig<'a> { with_span, lparen_span, items, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassModuleConfigItem<'a> { variable, colon_span, value, flags, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassModuleMemberName<'a> {
    tuple: [Ident, Variable, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassNestingDeclaration<'a> { block, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassParameter<'a> { name, default_value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassParameterDefaultValue<'a> { colon_span, value, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassParameters<'a> { params, arbitrary_param, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassParenthesizedExpression<'a> { expr, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassPlaceholderSelector<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassQualifiedName<'a> { module, member, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassUnaryExpression<'a> { op, expr, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassUnaryOperator { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassUnaryOperatorKind {
    tuple: [],
    unit: [Plus, Minus, Not, ],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassUnnamedNamespace {});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassUse<'a> { path, namespace, config, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassUseNamespace<'a> { as_span, kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SassUseNamespaceKind<'a> {
    tuple: [Named, Unnamed, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassVariable<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SassVariableDeclaration<'a> { namespace, name, colon_span, value, flags, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ScopeEnd<'a> { to_span, lparen_span, selector, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(ScopePrelude<'a> {
    tuple: [StartOnly, EndOnly, Both, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ScopeStart<'a> { selector, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(ScopeStartWithEnd<'a> { start, end, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SelectorList<'a> { selectors, comma_spans, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SimpleBlock<'a> { statements, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SimpleSelector<'a> {
    tuple: [Class, Id, Type, Attribute, PseudoClass, PseudoElement, Nesting, SassPlaceholder, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(Statement<'a> {
    tuple: [AtRule, Declaration, KeyframeBlock, LessConditionalQualifiedRule, LessExtendRule, LessFunctionCall, LessMixinCall, LessMixinDefinition, LessVariableCall, LessVariableDeclaration, Placeholder, PostcssSimpleVarDeclaration, QualifiedRule, SassIfAtRule, SassVariableDeclaration, UnknownSassAtRule, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Str<'a> { value, raw, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(StyleCondition<'a> { conditions, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(StyleConditionKind<'a> {
    tuple: [StyleInParens, And, Or, Not, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(StyleConditionAnd<'a> { keyword, style_in_parens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(StyleConditionNot<'a> { keyword, style_in_parens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(StyleConditionOr<'a> { keyword, style_in_parens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(StyleInParens<'a> { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(StyleInParensKind<'a> {
    tuple: [Condition, Feature, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(StyleQuery<'a> {
    tuple: [Condition, Feature, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Stylesheet<'a> { statements, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SupportsAnd<'a> { keyword, condition, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SupportsCondition<'a> { conditions, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SupportsConditionKind<'a> {
    tuple: [Not, And, Or, SupportsInParens, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SupportsDecl<'a> { decl, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SupportsInParens<'a> { kind, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(SupportsInParensKind<'a> {
    tuple: [SupportsCondition, Feature, Selector, Function, GeneralEnclosed, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SupportsNot<'a> { keyword, condition, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(SupportsOr<'a> { keyword, condition, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(TagNameSelector<'a> { name, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(TokenSeq<'a> { tokens, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(TypeSelector<'a> {
    tuple: [TagName, Universal, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(UnicodeRange<'a> { prefix, start, start_raw, end, end_raw, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(UniversalSelector<'a> { prefix, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(UnknownAtRulePrelude<'a> {
    tuple: [ComponentValue, TokenSeq, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(UnknownSassAtRule<'a> { name, prelude, block, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(UnquotedFontFamilyName<'a> { idents, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(Url<'a> { name, value, modifiers, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(UrlModifier<'a> {
    tuple: [Ident, Function, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(UrlRaw<'a> { value, raw, });
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_enum!(UrlValue<'a> {
    tuple: [Raw, SassInterpolated, Str, LessEscapedStr, ],
    unit: [],
});
#[cfg(feature = "span_ignored_eq")]
impl_span_ignored_eq_struct!(WqName<'a> { name, prefix, });

// EnumAsIs
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(AtRulePrelude<'a> {
    tuple: [
        Charset(Str<'a>) => is_charset, as_charset,
        ColorProfile(ColorProfilePrelude<'a>) => is_color_profile, as_color_profile,
        Container(ContainerPrelude<'a>) => is_container, as_container,
        CounterStyle(InterpolableIdent<'a>) => is_counter_style, as_counter_style,
        CustomMedia(Box<'a, CustomMedia<'a>>) => is_custom_media, as_custom_media,
        CustomSelector(Box<'a, CustomSelectorPrelude<'a>>) => is_custom_selector, as_custom_selector,
        Document(DocumentPrelude<'a>) => is_document, as_document,
        FontFeatureValues(FontFamilyName<'a>) => is_font_feature_values, as_font_feature_values,
        FontPaletteValues(InterpolableIdent<'a>) => is_font_palette_values, as_font_palette_values,
        Import(Box<'a, ImportPrelude<'a>>) => is_import, as_import,
        Keyframes(KeyframesName<'a>) => is_keyframes, as_keyframes,
        Layer(LayerNames<'a>) => is_layer, as_layer,
        LessImport(Box<'a, LessImportPrelude<'a>>) => is_less_import, as_less_import,
        LessPlugin(Box<'a, LessPlugin<'a>>) => is_less_plugin, as_less_plugin,
        Media(MediaQueryList<'a>) => is_media, as_media,
        Namespace(Box<'a, NamespacePrelude<'a>>) => is_namespace, as_namespace,
        Nest(SelectorList<'a>) => is_nest, as_nest,
        Page(PageSelectorList<'a>) => is_page, as_page,
        PositionTry(InterpolableIdent<'a>) => is_position_try, as_position_try,
        Property(InterpolableIdent<'a>) => is_property, as_property,
        SassAtRoot(SassAtRoot<'a>) => is_sass_at_root, as_sass_at_root,
        SassContent(SassContent<'a>) => is_sass_content, as_sass_content,
        SassEach(Box<'a, SassEach<'a>>) => is_sass_each, as_sass_each,
        SassExpr(Box<'a, ComponentValue<'a>>) => is_sass_expr, as_sass_expr,
        SassExtend(Box<'a, SassExtend<'a>>) => is_sass_extend, as_sass_extend,
        SassFor(Box<'a, SassFor<'a>>) => is_sass_for, as_sass_for,
        SassForward(Box<'a, SassForward<'a>>) => is_sass_forward, as_sass_forward,
        SassFunction(Box<'a, SassFunction<'a>>) => is_sass_function, as_sass_function,
        SassImport(SassImportPrelude<'a>) => is_sass_import, as_sass_import,
        SassInclude(Box<'a, SassInclude<'a>>) => is_sass_include, as_sass_include,
        SassMixin(Box<'a, SassMixin<'a>>) => is_sass_mixin, as_sass_mixin,
        SassUse(Box<'a, SassUse<'a>>) => is_sass_use, as_sass_use,
        Scope(Box<'a, ScopePrelude<'a>>) => is_scope, as_scope,
        ScrollTimeline(InterpolableIdent<'a>) => is_scroll_timeline, as_scroll_timeline,
        Supports(SupportsCondition<'a>) => is_supports, as_supports,
        Unknown(Box<'a, UnknownAtRulePrelude<'a>>) => is_unknown, as_unknown,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(AttributeSelectorValue<'a> {
    tuple: [
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        Str(InterpolableStr<'a>) => is_str, as_str,
        Number(Number<'a>) => is_number, as_number,
        Dimension(Dimension<'a>) => is_dimension, as_dimension,
        Percentage(Percentage<'a>) => is_percentage, as_percentage,
        LessEscapedStr(LessEscapedStr<'a>) => is_less_escaped_str, as_less_escaped_str,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(ColorProfilePrelude<'a> {
    tuple: [
        DashedIdent(InterpolableIdent<'a>) => is_dashed_ident, as_dashed_ident,
        DeviceCmyk(Ident<'a>) => is_device_cmyk, as_device_cmyk,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(ComplexSelectorChild<'a> {
    tuple: [
        CompoundSelector(CompoundSelector<'a>) => is_compound_selector, as_compound_selector,
        Combinator(Combinator) => is_combinator, as_combinator,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(ComponentValue<'a> {
    tuple: [
        BracketBlock(BracketBlock<'a>) => is_bracket_block, as_bracket_block,
        Calc(Calc<'a>) => is_calc, as_calc,
        Delimiter(Delimiter) => is_delimiter, as_delimiter,
        Dimension(Dimension<'a>) => is_dimension, as_dimension,
        Function(Function<'a>) => is_function, as_function,
        HexColor(HexColor<'a>) => is_hex_color, as_hex_color,
        IdSelector(IdSelector<'a>) => is_id_selector, as_id_selector,
        ImportantAnnotation(ImportantAnnotation<'a>) => is_important_annotation, as_important_annotation,
        InterpolableIdent(InterpolableIdent<'a>) => is_interpolable_ident, as_interpolable_ident,
        InterpolableStr(InterpolableStr<'a>) => is_interpolable_str, as_interpolable_str,
        LayerName(LayerName<'a>) => is_layer_name, as_layer_name,
        LessBinaryOperation(LessBinaryOperation<'a>) => is_less_binary_operation, as_less_binary_operation,
        LessCondition(Box<'a, LessCondition<'a>>) => is_less_condition, as_less_condition,
        LessDetachedRuleset(LessDetachedRuleset<'a>) => is_less_detached_ruleset, as_less_detached_ruleset,
        LessEscapedStr(LessEscapedStr<'a>) => is_less_escaped_str, as_less_escaped_str,
        LessJavaScriptSnippet(LessJavaScriptSnippet<'a>) => is_less_java_script_snippet, as_less_java_script_snippet,
        LessList(LessList<'a>) => is_less_list, as_less_list,
        LessMixinCall(LessMixinCall<'a>) => is_less_mixin_call, as_less_mixin_call,
        LessNamespaceValue(Box<'a, LessNamespaceValue<'a>>) => is_less_namespace_value, as_less_namespace_value,
        LessNegativeValue(LessNegativeValue<'a>) => is_less_negative_value, as_less_negative_value,
        LessParenthesizedOperation(LessParenthesizedOperation<'a>) => is_less_parenthesized_operation, as_less_parenthesized_operation,
        LessPercentKeyword(LessPercentKeyword) => is_less_percent_keyword, as_less_percent_keyword,
        LessPropertyVariable(LessPropertyVariable<'a>) => is_less_property_variable, as_less_property_variable,
        LessVariable(LessVariable<'a>) => is_less_variable, as_less_variable,
        LessVariableVariable(LessVariableVariable<'a>) => is_less_variable_variable, as_less_variable_variable,
        Number(Number<'a>) => is_number, as_number,
        Percentage(Percentage<'a>) => is_percentage, as_percentage,
        Placeholder(Placeholder<'a>) => is_placeholder, as_placeholder,
        PostcssSimpleVar(PostcssSimpleVar<'a>) => is_postcss_simple_var, as_postcss_simple_var,
        Ratio(Ratio<'a>) => is_ratio, as_ratio,
        SassArbitraryArgument(SassArbitraryArgument<'a>) => is_sass_arbitrary_argument, as_sass_arbitrary_argument,
        SassBinaryExpression(SassBinaryExpression<'a>) => is_sass_binary_expression, as_sass_binary_expression,
        SassKeywordArgument(SassKeywordArgument<'a>) => is_sass_keyword_argument, as_sass_keyword_argument,
        SassList(SassList<'a>) => is_sass_list, as_sass_list,
        SassMap(SassMap<'a>) => is_sass_map, as_sass_map,
        SassQualifiedName(SassQualifiedName<'a>) => is_sass_qualified_name, as_sass_qualified_name,
        SassNestingDeclaration(SassNestingDeclaration<'a>) => is_sass_nesting_declaration, as_sass_nesting_declaration,
        SassParenthesizedExpression(SassParenthesizedExpression<'a>) => is_sass_parenthesized_expression, as_sass_parenthesized_expression,
        SassParentSelector(NestingSelector<'a>) => is_sass_parent_selector, as_sass_parent_selector,
        SassUnaryExpression(SassUnaryExpression<'a>) => is_sass_unary_expression, as_sass_unary_expression,
        SassVariable(SassVariable<'a>) => is_sass_variable, as_sass_variable,
        TokenWithSpan(TokenWithSpan<'a>) => is_token_with_span, as_token_with_span,
        UnicodeRange(UnicodeRange<'a>) => is_unicode_range, as_unicode_range,
        Url(Url<'a>) => is_url, as_url,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(ContainerConditionKind<'a> {
    tuple: [
        QueryInParens(QueryInParens<'a>) => is_query_in_parens, as_query_in_parens,
        And(ContainerConditionAnd<'a>) => is_and, as_and,
        Or(ContainerConditionOr<'a>) => is_or, as_or,
        Not(ContainerConditionNot<'a>) => is_not, as_not,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(CustomMediaValue<'a> {
    tuple: [
        MediaQueryList(MediaQueryList<'a>) => is_media_query_list, as_media_query_list,
        True(Ident<'a>) => is_true, as_true,
        False(Ident<'a>) => is_false, as_false,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(DocumentPreludeMatcher<'a> {
    tuple: [
        Url(Url<'a>) => is_url, as_url,
        Function(Function<'a>) => is_function, as_function,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(FontFamilyName<'a> {
    tuple: [
        Str(InterpolableStr<'a>) => is_str, as_str,
        Unquoted(UnquotedFontFamilyName<'a>) => is_unquoted, as_unquoted,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(FunctionName<'a> {
    tuple: [
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        SassQualifiedName(Box<'a, SassQualifiedName<'a>>) => is_sass_qualified_name, as_sass_qualified_name,
        LessListFunction(LessListFunction) => is_less_list_function, as_less_list_function,
        LessFormatFunction(LessFormatFunction) => is_less_format_function, as_less_format_function,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(ImportPreludeHref<'a> {
    tuple: [
        Str(InterpolableStr<'a>) => is_str, as_str,
        Url(Url<'a>) => is_url, as_url,
        Function(Function<'a>) => is_function, as_function,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(ImportPreludeLayer<'a> {
    tuple: [
        Empty(Ident<'a>) => is_empty, as_empty,
        WithName(Function<'a>) => is_with_name, as_with_name,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(ImportPreludeSupportsKind<'a> {
    tuple: [
        SupportsCondition(SupportsCondition<'a>) => is_supports_condition, as_supports_condition,
        Declaration(Declaration<'a>) => is_declaration, as_declaration,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(InterpolableIdent<'a> {
    tuple: [
        Literal(Ident<'a>) => is_literal, as_literal,
        SassInterpolated(SassInterpolatedIdent<'a>) => is_sass_interpolated, as_sass_interpolated,
        LessInterpolated(LessInterpolatedIdent<'a>) => is_less_interpolated, as_less_interpolated,
        Placeholder(Placeholder<'a>) => is_placeholder, as_placeholder,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(InterpolableStr<'a> {
    tuple: [
        Literal(Str<'a>) => is_literal, as_literal,
        SassInterpolated(SassInterpolatedStr<'a>) => is_sass_interpolated, as_sass_interpolated,
        LessInterpolated(LessInterpolatedStr<'a>) => is_less_interpolated, as_less_interpolated,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(KeyframeSelector<'a> {
    tuple: [
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        Percentage(Percentage<'a>) => is_percentage, as_percentage,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(KeyframesName<'a> {
    tuple: [
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        Str(InterpolableStr<'a>) => is_str, as_str,
        LessVariable(LessVariable<'a>) => is_less_variable, as_less_variable,
        LessEscapedStr(LessEscapedStr<'a>) => is_less_escaped_str, as_less_escaped_str,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LanguageRange<'a> {
    tuple: [
        Str(InterpolableStr<'a>) => is_str, as_str,
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessCondition<'a> {
    tuple: [
        Binary(LessBinaryCondition<'a>) => is_binary, as_binary,
        Negated(LessNegatedCondition<'a>) => is_negated, as_negated,
        Parenthesized(LessParenthesizedCondition<'a>) => is_parenthesized, as_parenthesized,
        Value(ComponentValue<'a>) => is_value, as_value,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessInterpolatedIdentElement<'a> {
    tuple: [
        Variable(LessVariableInterpolation<'a>) => is_variable, as_variable,
        Property(LessPropertyInterpolation<'a>) => is_property, as_property,
        Static(InterpolableIdentStaticPart<'a>) => is_static, as_static,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessInterpolatedStrElement<'a> {
    tuple: [
        Variable(LessVariableInterpolation<'a>) => is_variable, as_variable,
        Property(LessPropertyInterpolation<'a>) => is_property, as_property,
        Static(InterpolableStrStaticPart<'a>) => is_static, as_static,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessLookupName<'a> {
    tuple: [
        LessVariable(LessVariable<'a>) => is_less_variable, as_less_variable,
        LessVariableVariable(LessVariableVariable<'a>) => is_less_variable_variable, as_less_variable_variable,
        LessPropertyVariable(LessPropertyVariable<'a>) => is_less_property_variable, as_less_property_variable,
        Ident(Ident<'a>) => is_ident, as_ident,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessMixinArgument<'a> {
    tuple: [
        Named(LessMixinNamedArgument<'a>) => is_named, as_named,
        Value(ComponentValue<'a>) => is_value, as_value,
        Variadic(LessMixinVariadicArgument<'a>) => is_variadic, as_variadic,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessMixinName<'a> {
    tuple: [
        ClassSelector(ClassSelector<'a>) => is_class_selector, as_class_selector,
        IdSelector(IdSelector<'a>) => is_id_selector, as_id_selector,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessMixinParameter<'a> {
    tuple: [
        Named(LessMixinNamedParameter<'a>) => is_named, as_named,
        Unnamed(LessMixinUnnamedParameter<'a>) => is_unnamed, as_unnamed,
        Variadic(LessMixinVariadicParameter<'a>) => is_variadic, as_variadic,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessMixinParameterName<'a> {
    tuple: [
        Variable(LessVariable<'a>) => is_variable, as_variable,
        PropertyVariable(LessPropertyVariable<'a>) => is_property_variable, as_property_variable,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessNamespaceValueCallee<'a> {
    tuple: [
        LessMixinCall(LessMixinCall<'a>) => is_less_mixin_call, as_less_mixin_call,
        LessVariable(LessVariable<'a>) => is_less_variable, as_less_variable,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(LessPluginPath<'a> {
    tuple: [
        Str(Str<'a>) => is_str, as_str,
        Url(Url<'a>) => is_url, as_url,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(MediaConditionKind<'a> {
    tuple: [
        MediaInParens(MediaInParens<'a>) => is_media_in_parens, as_media_in_parens,
        And(MediaAnd<'a>) => is_and, as_and,
        Or(MediaOr<'a>) => is_or, as_or,
        Not(MediaNot<'a>) => is_not, as_not,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(MediaFeature<'a> {
    tuple: [
        Plain(MediaFeaturePlain<'a>) => is_plain, as_plain,
        Boolean(MediaFeatureBoolean<'a>) => is_boolean, as_boolean,
        Range(MediaFeatureRange<'a>) => is_range, as_range,
        RangeInterval(MediaFeatureRangeInterval<'a>) => is_range_interval, as_range_interval,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(MediaFeatureName<'a> {
    tuple: [
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        PostcssSimpleVar(PostcssSimpleVar<'a>) => is_postcss_simple_var, as_postcss_simple_var,
        SassVariable(SassVariable<'a>) => is_sass_variable, as_sass_variable,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(MediaInParensKind<'a> {
    tuple: [
        MediaCondition(MediaCondition<'a>) => is_media_condition, as_media_condition,
        MediaFeature(Box<'a, MediaFeature<'a>>) => is_media_feature, as_media_feature,
        GeneralEnclosed(TokenSeq<'a>) => is_general_enclosed, as_general_enclosed,
        SassInterpolation(SassInterpolatedIdent<'a>) => is_sass_interpolation, as_sass_interpolation,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(MediaQuery<'a> {
    tuple: [
        ConditionOnly(MediaCondition<'a>) => is_condition_only, as_condition_only,
        WithType(MediaQueryWithType<'a>) => is_with_type, as_with_type,
        Function(Function<'a>) => is_function, as_function,
        LessVariable(LessVariable<'a>) => is_less_variable, as_less_variable,
        LessNamespaceValue(Box<'a, LessNamespaceValue<'a>>) => is_less_namespace_value, as_less_namespace_value,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(NamespacePreludeUri<'a> {
    tuple: [
        Str(InterpolableStr<'a>) => is_str, as_str,
        Url(Url<'a>) => is_url, as_url,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(NsPrefixKind<'a> {
    tuple: [
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        Universal(NsPrefixUniversal) => is_universal, as_universal,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(NthIndex<'a> {
    tuple: [
        Odd(Ident<'a>) => is_odd, as_odd,
        Even(Ident<'a>) => is_even, as_even,
        Integer(Number<'a>) => is_integer, as_integer,
        AnPlusB(AnPlusB) => is_an_plus_b, as_an_plus_b,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(PseudoClassSelectorArgKind<'a> {
    tuple: [
        CompoundSelector(CompoundSelector<'a>) => is_compound_selector, as_compound_selector,
        CompoundSelectorList(CompoundSelectorList<'a>) => is_compound_selector_list, as_compound_selector_list,
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        LanguageRangeList(LanguageRangeList<'a>) => is_language_range_list, as_language_range_list,
        Nth(Nth<'a>) => is_nth, as_nth,
        Number(Number<'a>) => is_number, as_number,
        RelativeSelectorList(RelativeSelectorList<'a>) => is_relative_selector_list, as_relative_selector_list,
        SelectorList(SelectorList<'a>) => is_selector_list, as_selector_list,
        LessExtendList(LessExtendList<'a>) => is_less_extend_list, as_less_extend_list,
        TokenSeq(TokenSeq<'a>) => is_token_seq, as_token_seq,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(PseudoElementSelectorArgKind<'a> {
    tuple: [
        CompoundSelector(CompoundSelector<'a>) => is_compound_selector, as_compound_selector,
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        TokenSeq(TokenSeq<'a>) => is_token_seq, as_token_seq,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(QueryInParensKind<'a> {
    tuple: [
        ContainerCondition(ContainerCondition<'a>) => is_container_condition, as_container_condition,
        SizeFeature(Box<'a, MediaFeature<'a>>) => is_size_feature, as_size_feature,
        StyleQuery(StyleQuery<'a>) => is_style_query, as_style_query,
        ScrollState(Box<'a, MediaFeature<'a>>) => is_scroll_state, as_scroll_state,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SassAtRootKind<'a> {
    tuple: [
        Selector(SelectorList<'a>) => is_selector, as_selector,
        Query(SassAtRootQuery<'a>) => is_query, as_query,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SassAtRootQueryRule<'a> {
    tuple: [
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        Str(InterpolableStr<'a>) => is_str, as_str,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SassForwardMember<'a> {
    tuple: [
        Ident(Ident<'a>) => is_ident, as_ident,
        Variable(SassVariable<'a>) => is_variable, as_variable,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SassInterpolatedIdentElement<'a> {
    tuple: [
        Expression(ComponentValue<'a>) => is_expression, as_expression,
        Static(InterpolableIdentStaticPart<'a>) => is_static, as_static,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SassInterpolatedStrElement<'a> {
    tuple: [
        Expression(ComponentValue<'a>) => is_expression, as_expression,
        Static(InterpolableStrStaticPart<'a>) => is_static, as_static,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SassInterpolatedUrlElement<'a> {
    tuple: [
        Expression(ComponentValue<'a>) => is_expression, as_expression,
        Static(InterpolableUrlStaticPart<'a>) => is_static, as_static,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SassModuleMemberName<'a> {
    tuple: [
        Ident(Ident<'a>) => is_ident, as_ident,
        Variable(SassVariable<'a>) => is_variable, as_variable,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SassUseNamespaceKind<'a> {
    tuple: [
        Named(Ident<'a>) => is_named, as_named,
        Unnamed(SassUnnamedNamespace) => is_unnamed, as_unnamed,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(ScopePrelude<'a> {
    tuple: [
        StartOnly(ScopeStart<'a>) => is_start_only, as_start_only,
        EndOnly(ScopeEnd<'a>) => is_end_only, as_end_only,
        Both(ScopeStartWithEnd<'a>) => is_both, as_both,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SimpleSelector<'a> {
    tuple: [
        Class(ClassSelector<'a>) => is_class, as_class,
        Id(IdSelector<'a>) => is_id, as_id,
        Type(TypeSelector<'a>) => is_type, as_type,
        Attribute(AttributeSelector<'a>) => is_attribute, as_attribute,
        PseudoClass(PseudoClassSelector<'a>) => is_pseudo_class, as_pseudo_class,
        PseudoElement(PseudoElementSelector<'a>) => is_pseudo_element, as_pseudo_element,
        Nesting(NestingSelector<'a>) => is_nesting, as_nesting,
        SassPlaceholder(SassPlaceholderSelector<'a>) => is_sass_placeholder, as_sass_placeholder,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(Statement<'a> {
    tuple: [
        AtRule(AtRule<'a>) => is_at_rule, as_at_rule,
        Declaration(Declaration<'a>) => is_declaration, as_declaration,
        KeyframeBlock(KeyframeBlock<'a>) => is_keyframe_block, as_keyframe_block,
        LessConditionalQualifiedRule(LessConditionalQualifiedRule<'a>) => is_less_conditional_qualified_rule, as_less_conditional_qualified_rule,
        LessExtendRule(LessExtendRule<'a>) => is_less_extend_rule, as_less_extend_rule,
        LessFunctionCall(Function<'a>) => is_less_function_call, as_less_function_call,
        LessMixinCall(LessMixinCall<'a>) => is_less_mixin_call, as_less_mixin_call,
        LessMixinDefinition(LessMixinDefinition<'a>) => is_less_mixin_definition, as_less_mixin_definition,
        LessVariableCall(LessVariableCall<'a>) => is_less_variable_call, as_less_variable_call,
        LessVariableDeclaration(LessVariableDeclaration<'a>) => is_less_variable_declaration, as_less_variable_declaration,
        Placeholder(Placeholder<'a>) => is_placeholder, as_placeholder,
        PostcssSimpleVarDeclaration(PostcssSimpleVarDeclaration<'a>) => is_postcss_simple_var_declaration, as_postcss_simple_var_declaration,
        QualifiedRule(QualifiedRule<'a>) => is_qualified_rule, as_qualified_rule,
        SassIfAtRule(SassIfAtRule<'a>) => is_sass_if_at_rule, as_sass_if_at_rule,
        SassVariableDeclaration(SassVariableDeclaration<'a>) => is_sass_variable_declaration, as_sass_variable_declaration,
        UnknownSassAtRule(Box<'a, UnknownSassAtRule<'a>>) => is_unknown_sass_at_rule, as_unknown_sass_at_rule,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(StyleConditionKind<'a> {
    tuple: [
        StyleInParens(StyleInParens<'a>) => is_style_in_parens, as_style_in_parens,
        And(StyleConditionAnd<'a>) => is_and, as_and,
        Or(StyleConditionOr<'a>) => is_or, as_or,
        Not(StyleConditionNot<'a>) => is_not, as_not,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(StyleInParensKind<'a> {
    tuple: [
        Condition(StyleCondition<'a>) => is_condition, as_condition,
        Feature(Declaration<'a>) => is_feature, as_feature,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(StyleQuery<'a> {
    tuple: [
        Condition(StyleCondition<'a>) => is_condition, as_condition,
        Feature(Declaration<'a>) => is_feature, as_feature,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SupportsConditionKind<'a> {
    tuple: [
        Not(SupportsNot<'a>) => is_not, as_not,
        And(SupportsAnd<'a>) => is_and, as_and,
        Or(SupportsOr<'a>) => is_or, as_or,
        SupportsInParens(SupportsInParens<'a>) => is_supports_in_parens, as_supports_in_parens,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(SupportsInParensKind<'a> {
    tuple: [
        SupportsCondition(SupportsCondition<'a>) => is_supports_condition, as_supports_condition,
        Feature(Box<'a, SupportsDecl<'a>>) => is_feature, as_feature,
        Selector(SelectorList<'a>) => is_selector, as_selector,
        Function(Function<'a>) => is_function, as_function,
        GeneralEnclosed(TokenSeq<'a>) => is_general_enclosed, as_general_enclosed,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(TypeSelector<'a> {
    tuple: [
        TagName(TagNameSelector<'a>) => is_tag_name, as_tag_name,
        Universal(UniversalSelector<'a>) => is_universal, as_universal,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(UnknownAtRulePrelude<'a> {
    tuple: [
        ComponentValue(ComponentValue<'a>) => is_component_value, as_component_value,
        TokenSeq(TokenSeq<'a>) => is_token_seq, as_token_seq,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(UrlModifier<'a> {
    tuple: [
        Ident(InterpolableIdent<'a>) => is_ident, as_ident,
        Function(Function<'a>) => is_function, as_function,
    ],
    unit: [],
});
#[cfg(feature = "variant_helpers")]
impl_enum_as_is!(UrlValue<'a> {
    tuple: [
        Raw(UrlRaw<'a>) => is_raw, as_raw,
        SassInterpolated(SassInterpolatedUrl<'a>) => is_sass_interpolated, as_sass_interpolated,
        Str(InterpolableStr<'a>) => is_str, as_str,
        LessEscapedStr(LessEscapedStr<'a>) => is_less_escaped_str, as_less_escaped_str,
    ],
    unit: [],
});