oxc-css-parser 0.0.5

// This file is generated by removing the old proc-macro derives. Keep the lists in sync with the AST/token definitions.

// Span accessors
impl<'a> AtRule<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> AtRulePrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Charset(value) => value.span(),
            Self::ColorProfile(value) => value.span(),
            Self::Container(value) => value.span(),
            Self::CounterStyle(value) => value.span(),
            Self::CustomMedia(value) => value.span(),
            Self::CustomSelector(value) => value.span(),
            Self::Document(value) => value.span(),
            Self::FontFeatureValues(value) => value.span(),
            Self::FontPaletteValues(value) => value.span(),
            Self::Import(value) => value.span(),
            Self::Keyframes(value) => value.span(),
            Self::Layer(value) => value.span(),
            Self::LessImport(value) => value.span(),
            Self::LessPlugin(value) => value.span(),
            Self::Media(value) => value.span(),
            Self::Namespace(value) => value.span(),
            Self::Nest(value) => value.span(),
            Self::Page(value) => value.span(),
            Self::PositionTry(value) => value.span(),
            Self::Property(value) => value.span(),
            Self::SassAtRoot(value) => value.span(),
            Self::SassContent(value) => value.span(),
            Self::SassEach(value) => value.span(),
            Self::SassExpr(value) => value.span(),
            Self::SassExtend(value) => value.span(),
            Self::SassFor(value) => value.span(),
            Self::SassForward(value) => value.span(),
            Self::SassFunction(value) => value.span(),
            Self::SassImport(value) => value.span(),
            Self::SassInclude(value) => value.span(),
            Self::SassMixin(value) => value.span(),
            Self::SassUse(value) => value.span(),
            Self::Scope(value) => value.span(),
            Self::ScrollTimeline(value) => value.span(),
            Self::Supports(value) => value.span(),
            Self::Unknown(value) => value.span(),
        }
    }
}

impl<'a> AttributeSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> AttributeSelectorValue<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::Str(value) => value.span(),
            Self::Number(value) => value.span(),
            Self::Dimension(value) => value.span(),
            Self::Percentage(value) => value.span(),
            Self::LessEscapedStr(value) => value.span(),
            Self::TokenSeq(value) => value.span(),
        }
    }
}

impl<'a> BracketBlock<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> Calc<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ColorProfilePrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::DashedIdent(value) => value.span(),
            Self::DeviceCmyk(value) => value.span(),
        }
    }
}

impl<'a> ComplexSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ComplexSelectorChild<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::CompoundSelector(value) => value.span(),
            Self::Combinator(value) => &value.span,
        }
    }
}

impl<'a> ComponentValue<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::BracketBlock(value) => value.span(),
            Self::Calc(value) => value.span(),
            Self::Delimiter(value) => &value.span,
            Self::Dimension(value) => value.span(),
            Self::Function(value) => value.span(),
            Self::HexColor(value) => &value.span,
            Self::IdSelector(value) => value.span(),
            Self::ImportantAnnotation(value) => value.span(),
            Self::InterpolableIdent(value) => value.span(),
            Self::InterpolableStr(value) => value.span(),
            Self::LayerName(value) => value.span(),
            Self::LessAnonymousMixin(value) => value.span(),
            Self::LessBinaryOperation(value) => value.span(),
            Self::LessCondition(value) => value.span(),
            Self::LessDetachedRuleset(value) => value.span(),
            Self::LessEscapedStr(value) => value.span(),
            Self::LessJavaScriptSnippet(value) => value.span(),
            Self::LessList(value) => value.span(),
            Self::LessMixinCall(value) => value.span(),
            Self::LessNamespaceValue(value) => value.span(),
            Self::LessVariableCall(value) => value.span(),
            Self::LessNegativeValue(value) => value.span(),
            Self::LessParenthesizedOperation(value) => value.span(),
            Self::LessPercentKeyword(value) => &value.span,
            Self::LessPropertyVariable(value) => value.span(),
            Self::LessVariable(value) => value.span(),
            Self::LessVariableVariable(value) => value.span(),
            Self::Number(value) => value.span(),
            Self::Percentage(value) => value.span(),
            Self::Placeholder(value) => &value.span,
            Self::PostcssSimpleVar(value) => value.span(),
            Self::Ratio(value) => value.span(),
            Self::SassArbitraryArgument(value) => value.span(),
            Self::SassBinaryExpression(value) => value.span(),
            Self::SassKeywordArgument(value) => value.span(),
            Self::SassList(value) => value.span(),
            Self::SassMap(value) => value.span(),
            Self::SassQualifiedName(value) => value.span(),
            Self::SassNestingDeclaration(value) => value.span(),
            Self::SassParenthesizedExpression(value) => value.span(),
            Self::SassParentSelector(value) => value.span(),
            Self::SassUnaryExpression(value) => value.span(),
            Self::SassVariable(value) => value.span(),
            Self::TokenWithSpan(value) => &value.span,
            Self::UnicodeRange(value) => value.span(),
            Self::Url(value) => value.span(),
        }
    }
}

impl<'a> ComponentValues<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> CompoundSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> CompoundSelectorList<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ContainerCondition<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ContainerConditionKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::QueryInParens(value) => value.span(),
            Self::And(value) => value.span(),
            Self::Or(value) => value.span(),
            Self::Not(value) => value.span(),
        }
    }
}

impl<'a> ContainerConditionAnd<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ContainerConditionNot<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ContainerConditionOr<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ContainerPrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> CustomMedia<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> CustomMediaValue<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::MediaQueryList(value) => value.span(),
            Self::True(value) => value.span(),
            Self::False(value) => value.span(),
        }
    }
}

impl<'a> CustomSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> CustomSelectorArg<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> CustomSelectorArgs<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> CustomSelectorPrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> Declaration<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> Dimension<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> DocumentPrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> DocumentPreludeMatcher<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Url(value) => value.span(),
            Self::Function(value) => value.span(),
        }
    }
}

impl<'a> FontFamilyName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Str(value) => value.span(),
            Self::Unquoted(value) => value.span(),
        }
    }
}

impl<'a> Function<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> FunctionName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::SassQualifiedName(value) => value.span(),
            Self::LessListFunction(value) => &value.span,
            Self::LessFormatFunction(value) => &value.span,
        }
    }
}

impl<'a> Ident<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ImportPrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ImportPreludeHref<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Str(value) => value.span(),
            Self::Url(value) => value.span(),
            Self::Function(value) => value.span(),
        }
    }
}

impl<'a> ImportPreludeLayer<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Empty(value) => value.span(),
            Self::WithName(value) => value.span(),
        }
    }
}

impl<'a> ImportPreludeSupports<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ImportPreludeSupportsKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::SupportsCondition(value) => value.span(),
            Self::Declaration(value) => value.span(),
        }
    }
}

impl<'a> InterpolableIdent<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Literal(value) => value.span(),
            Self::SassInterpolated(value) => value.span(),
            Self::LessInterpolated(value) => value.span(),
            Self::Placeholder(value) => &value.span,
        }
    }
}

impl<'a> InterpolableIdentStaticPart<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> InterpolableStr<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Literal(value) => value.span(),
            Self::SassInterpolated(value) => value.span(),
            Self::LessInterpolated(value) => value.span(),
        }
    }
}

impl<'a> InterpolableStrStaticPart<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> InterpolableUrlStaticPart<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> IdSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ImportantAnnotation<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> KeyframeBlock<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> KeyframeSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::Percentage(value) => value.span(),
        }
    }
}

impl<'a> KeyframesName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::Str(value) => value.span(),
            Self::LessVariable(value) => value.span(),
            Self::LessEscapedStr(value) => value.span(),
        }
    }
}

impl<'a> LanguageRange<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Str(value) => value.span(),
            Self::Ident(value) => value.span(),
        }
    }
}

impl<'a> LanguageRangeList<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LayerName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LayerNames<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessBinaryCondition<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessBinaryOperation<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessCondition<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Binary(value) => value.span(),
            Self::Negated(value) => value.span(),
            Self::Parenthesized(value) => value.span(),
            Self::Value(value) => value.span(),
        }
    }
}

impl<'a> LessAnonymousMixin<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessConditionalQualifiedRule<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessConditions<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessDetachedRuleset<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessEscapedStr<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessExtend<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessExtendList<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessExtendRule<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessImportOptions<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessImportPrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessInterpolatedIdent<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessInterpolatedIdentElement<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Variable(value) => value.span(),
            Self::Property(value) => value.span(),
            Self::Static(value) => value.span(),
        }
    }
}

impl<'a> LessInterpolatedStr<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessInterpolatedStrElement<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Variable(value) => value.span(),
            Self::Property(value) => value.span(),
            Self::Static(value) => value.span(),
        }
    }
}

impl<'a> LessJavaScriptSnippet<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessList<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessLookup<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessLookupName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::LessVariable(value) => value.span(),
            Self::LessVariableVariable(value) => value.span(),
            Self::LessPropertyVariable(value) => value.span(),
            Self::LessPropertyInterpolation(value) => value.span(),
            Self::Ident(value) => value.span(),
        }
    }
}

impl<'a> LessLookups<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinArgument<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Named(value) => value.span(),
            Self::Value(value) => value.span(),
            Self::Variadic(value) => value.span(),
        }
    }
}

impl<'a> LessMixinArguments<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinCall<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinCallee<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinCalleeChild<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinDefinition<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::ClassSelector(value) => &value.span,
            Self::IdSelector(value) => value.span(),
        }
    }
}

impl<'a> LessMixinNamedArgument<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinNamedParameter<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinNamedParameterDefaultValue<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinParameter<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Named(value) => value.span(),
            Self::Unnamed(value) => value.span(),
            Self::Variadic(value) => value.span(),
        }
    }
}

impl<'a> LessMixinParameters<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinParameterName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Variable(value) => value.span(),
            Self::PropertyVariable(value) => value.span(),
        }
    }
}

impl<'a> LessMixinUnnamedParameter<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinVariadicArgument<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessMixinVariadicParameter<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessNamespaceValue<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessNamespaceValueCallee<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::LessMixinCall(value) => value.span(),
            Self::LessVariable(value) => value.span(),
        }
    }
}

impl<'a> LessNegatedCondition<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessNegativeValue<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessParenthesizedCondition<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessParenthesizedOperation<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessPlugin<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessPluginPath<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Str(value) => value.span(),
            Self::Url(value) => value.span(),
        }
    }
}

impl<'a> LessPropertyInterpolation<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl LessPropertyMerge {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessPropertyVariable<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessVariable<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessVariableCall<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessVariableDeclaration<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessVariableInterpolation<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> LessVariableVariable<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaAnd<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaCondition<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaConditionAfterMediaType<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaConditionKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::MediaInParens(value) => value.span(),
            Self::And(value) => value.span(),
            Self::Or(value) => value.span(),
            Self::Not(value) => value.span(),
        }
    }
}

impl<'a> MediaFeature<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Plain(value) => value.span(),
            Self::Boolean(value) => value.span(),
            Self::Range(value) => value.span(),
            Self::RangeInterval(value) => value.span(),
        }
    }
}

impl<'a> MediaFeatureName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::PostcssSimpleVar(value) => value.span(),
            Self::SassVariable(value) => value.span(),
        }
    }
}

impl<'a> MediaFeatureBoolean<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaFeaturePlain<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaFeatureRange<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaFeatureRangeInterval<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaInParens<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaInParensKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::MediaCondition(value) => value.span(),
            Self::MediaFeature(value) => value.span(),
            Self::GeneralEnclosed(value) => value.span(),
            Self::SassInterpolation(value) => value.span(),
        }
    }
}

impl<'a> MediaNot<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaOr<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaQuery<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::ConditionOnly(value) => value.span(),
            Self::WithType(value) => value.span(),
            Self::Function(value) => value.span(),
            Self::LessVariable(value) => value.span(),
            Self::LessNamespaceValue(value) => value.span(),
        }
    }
}

impl<'a> MediaQueryList<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> MediaQueryWithType<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> NamespacePrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> NamespacePreludeUri<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Str(value) => value.span(),
            Self::Url(value) => value.span(),
        }
    }
}

impl<'a> NestingSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> NsPrefix<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> NsPrefixKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::Universal(value) => value.span(),
        }
    }
}

impl NsPrefixUniversal {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> Nth<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> NthIndex<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Odd(value) => value.span(),
            Self::Even(value) => value.span(),
            Self::Integer(value) => value.span(),
            Self::AnPlusB(value) => &value.span,
        }
    }
}

impl<'a> Number<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> PageSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> PageSelectorList<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> Percentage<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> PostcssSimpleVar<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> PostcssSimpleVarDeclaration<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> PseudoClassSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> PseudoClassSelectorArg<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> PseudoClassSelectorArgKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::CompoundSelector(value) => value.span(),
            Self::CompoundSelectorList(value) => value.span(),
            Self::Ident(value) => value.span(),
            Self::LanguageRangeList(value) => value.span(),
            Self::Nth(value) => value.span(),
            Self::Number(value) => value.span(),
            Self::RelativeSelectorList(value) => value.span(),
            Self::SelectorList(value) => value.span(),
            Self::LessExtendList(value) => value.span(),
            Self::TokenSeq(value) => value.span(),
        }
    }
}

impl<'a> PseudoElementSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> PseudoElementSelectorArg<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> PseudoElementSelectorArgKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::CompoundSelector(value) => value.span(),
            Self::CompoundSelectorList(value) => value.span(),
            Self::Ident(value) => value.span(),
            Self::TokenSeq(value) => value.span(),
        }
    }
}

impl<'a> PseudoPage<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> QualifiedRule<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> QueryInParens<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> QueryInParensKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::ContainerCondition(value) => value.span(),
            Self::SizeFeature(value) => value.span(),
            Self::StyleQuery(value) => value.span(),
            Self::ScrollState(value) => value.span(),
        }
    }
}

impl<'a> Ratio<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> RelativeSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> RelativeSelectorList<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassArbitraryArgument<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassArbitraryParameter<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassAtRoot<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassAtRootKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Selector(value) => value.span(),
            Self::Query(value) => value.span(),
        }
    }
}

impl<'a> SassAtRootQuery<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassAtRootQueryRule<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::Str(value) => value.span(),
        }
    }
}

impl<'a> SassBinaryExpression<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassConditionalClause<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassContent<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassEach<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassExtend<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassFlag<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassFor<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl SassForBoundary {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassForward<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassForwardMember<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::Variable(value) => value.span(),
        }
    }
}

impl<'a> SassForwardPrefix<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassForwardVisibility<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassFunction<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassIfAtRule<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassImportPrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassInclude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassIncludeArgs<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassIncludeContentBlockParams<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassInterpolatedIdent<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassInterpolatedIdentElement<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Expression(value) => value.span(),
            Self::Static(value) => value.span(),
        }
    }
}

impl<'a> SassInterpolatedStr<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassInterpolatedStrElement<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Expression(value) => value.span(),
            Self::Static(value) => value.span(),
        }
    }
}

impl<'a> SassInterpolatedUrl<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassInterpolatedUrlElement<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Expression(value) => value.span(),
            Self::Static(value) => value.span(),
        }
    }
}

impl<'a> SassKeywordArgument<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassList<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassMap<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassMapItem<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassMixin<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassModuleConfig<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassModuleConfigItem<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassModuleMemberName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::Variable(value) => value.span(),
        }
    }
}

impl<'a> SassNestingDeclaration<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassParameter<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassParameterDefaultValue<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassParameters<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassParenthesizedExpression<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassPlaceholderSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassQualifiedName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassUnaryExpression<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl SassUnnamedNamespace {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassUse<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassUseNamespace<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassUseNamespaceKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Named(value) => value.span(),
            Self::Unnamed(value) => value.span(),
        }
    }
}

impl<'a> SassVariable<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SassVariableDeclaration<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ScopeEnd<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ScopePrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::StartOnly(value) => value.span(),
            Self::EndOnly(value) => value.span(),
            Self::Both(value) => value.span(),
        }
    }
}

impl<'a> ScopeStart<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> ScopeStartWithEnd<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SelectorList<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SimpleBlock<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SimpleSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Class(value) => &value.span,
            Self::Id(value) => value.span(),
            Self::Type(value) => value.span(),
            Self::Attribute(value) => value.span(),
            Self::PseudoClass(value) => value.span(),
            Self::PseudoElement(value) => value.span(),
            Self::Nesting(value) => value.span(),
            Self::SassPlaceholder(value) => value.span(),
        }
    }
}

impl<'a> Statement<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::AtRule(value) => value.span(),
            Self::Declaration(value) => value.span(),
            Self::KeyframeBlock(value) => value.span(),
            Self::LessConditionalQualifiedRule(value) => value.span(),
            Self::LessExtendRule(value) => value.span(),
            Self::LessFunctionCall(value) => value.span(),
            Self::LessMixinCall(value) => value.span(),
            Self::LessMixinDefinition(value) => value.span(),
            Self::LessVariableCall(value) => value.span(),
            Self::LessVariableDeclaration(value) => value.span(),
            Self::Placeholder(value) => &value.span,
            Self::PostcssSimpleVarDeclaration(value) => value.span(),
            Self::QualifiedRule(value) => value.span(),
            Self::SassIfAtRule(value) => value.span(),
            Self::SassVariableDeclaration(value) => value.span(),
            Self::UnknownSassAtRule(value) => value.span(),
        }
    }
}

impl<'a> Str<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> StyleCondition<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> StyleConditionKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::StyleInParens(value) => value.span(),
            Self::And(value) => value.span(),
            Self::Or(value) => value.span(),
            Self::Not(value) => value.span(),
        }
    }
}

impl<'a> StyleConditionAnd<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> StyleConditionNot<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> StyleConditionOr<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> StyleInParens<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> StyleInParensKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Condition(value) => value.span(),
            Self::Feature(value) => value.span(),
        }
    }
}

impl<'a> StyleQuery<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Condition(value) => value.span(),
            Self::Feature(value) => value.span(),
            Self::FeatureName(value) => value.span(),
        }
    }
}

impl<'a> Stylesheet<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SupportsAnd<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SupportsCondition<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SupportsConditionKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Not(value) => value.span(),
            Self::And(value) => value.span(),
            Self::Or(value) => value.span(),
            Self::SupportsInParens(value) => value.span(),
        }
    }
}

impl<'a> SupportsDecl<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SupportsInParens<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SupportsInParensKind<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::SupportsCondition(value) => value.span(),
            Self::Feature(value) => value.span(),
            Self::Selector(value) => value.span(),
            Self::Function(value) => value.span(),
            Self::GeneralEnclosed(value) => value.span(),
            Self::Interpolation(value) => value.span(),
        }
    }
}

impl<'a> SupportsNot<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> SupportsOr<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> TagNameSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> TokenSeq<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> TypeSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::TagName(value) => value.span(),
            Self::Universal(value) => value.span(),
        }
    }
}

impl<'a> UnicodeRange<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> UniversalSelector<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> UnknownAtRulePrelude<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::ComponentValue(value) => value.span(),
            Self::TokenSeq(value) => value.span(),
        }
    }
}

impl<'a> UnknownSassAtRule<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> UnquotedFontFamilyName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> Url<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}

impl<'a> UrlModifier<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Ident(value) => value.span(),
            Self::Function(value) => value.span(),
        }
    }
}

impl<'a> UrlValue<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        match self {
            Self::Raw(value) => &value.span,
            Self::SassInterpolated(value) => value.span(),
            Self::Str(value) => value.span(),
            Self::LessEscapedStr(value) => value.span(),
        }
    }
}

impl<'a> WqName<'a> {
    #[inline]
    pub fn span(&self) -> &Span {
        &self.span
    }
}