1use crate::{ast::*, pos::Span};
4
5impl<'a> AtRule<'a> {
7 #[inline]
8 pub fn span(&self) -> &Span {
9 &self.span
10 }
11}
12
13impl<'a> AtRulePrelude<'a> {
14 #[inline]
15 pub fn span(&self) -> &Span {
16 match self {
17 Self::Charset(value) => value.span(),
18 Self::ColorProfile(value) => value.span(),
19 Self::Container(value) => value.span(),
20 Self::CounterStyle(value) => value.span(),
21 Self::CustomMedia(value) => value.span(),
22 Self::CustomSelector(value) => value.span(),
23 Self::Document(value) => value.span(),
24 Self::FontFeatureValues(value) => value.span(),
25 Self::FontPaletteValues(value) => value.span(),
26 Self::Import(value) => value.span(),
27 Self::Keyframes(value) => value.span(),
28 Self::Layer(value) => value.span(),
29 Self::LessImport(value) => value.span(),
30 Self::LessPlugin(value) => value.span(),
31 Self::Media(value) => value.span(),
32 Self::Namespace(value) => value.span(),
33 Self::Nest(value) => value.span(),
34 Self::Page(value) => value.span(),
35 Self::PositionTry(value) => value.span(),
36 Self::Property(value) => value.span(),
37 Self::SassAtRoot(value) => value.span(),
38 Self::SassContent(value) => value.span(),
39 Self::SassEach(value) => value.span(),
40 Self::SassExpr(value) => value.span(),
41 Self::SassExtend(value) => value.span(),
42 Self::SassFor(value) => value.span(),
43 Self::SassForward(value) => value.span(),
44 Self::SassFunction(value) => value.span(),
45 Self::SassImport(value) => value.span(),
46 Self::SassInclude(value) => value.span(),
47 Self::SassMixin(value) => value.span(),
48 Self::SassUse(value) => value.span(),
49 Self::Scope(value) => value.span(),
50 Self::ScrollTimeline(value) => value.span(),
51 Self::Supports(value) => value.span(),
52 Self::Unknown(value) => value.span(),
53 }
54 }
55}
56
57impl<'a> AttributeSelector<'a> {
58 #[inline]
59 pub fn span(&self) -> &Span {
60 &self.span
61 }
62}
63
64impl<'a> AttributeSelectorValue<'a> {
65 #[inline]
66 pub fn span(&self) -> &Span {
67 match self {
68 Self::Ident(value) => value.span(),
69 Self::Str(value) => value.span(),
70 Self::Number(value) => value.span(),
71 Self::Dimension(value) => value.span(),
72 Self::Percentage(value) => value.span(),
73 Self::LessEscapedStr(value) => value.span(),
74 Self::TokenSeq(value) => value.span(),
75 }
76 }
77}
78
79impl<'a> BracketBlock<'a> {
80 #[inline]
81 pub fn span(&self) -> &Span {
82 &self.span
83 }
84}
85
86impl<'a> Calc<'a> {
87 #[inline]
88 pub fn span(&self) -> &Span {
89 &self.span
90 }
91}
92
93impl<'a> ColorProfilePrelude<'a> {
94 #[inline]
95 pub fn span(&self) -> &Span {
96 match self {
97 Self::DashedIdent(value) => value.span(),
98 Self::DeviceCmyk(value) => value.span(),
99 }
100 }
101}
102
103impl<'a> ComplexSelector<'a> {
104 #[inline]
105 pub fn span(&self) -> &Span {
106 &self.span
107 }
108}
109
110impl<'a> ComplexSelectorChild<'a> {
111 #[inline]
112 pub fn span(&self) -> &Span {
113 match self {
114 Self::CompoundSelector(value) => value.span(),
115 Self::Combinator(value) => &value.span,
116 }
117 }
118}
119
120impl<'a> ComponentValue<'a> {
121 #[inline]
122 pub fn span(&self) -> &Span {
123 match self {
124 Self::BracketBlock(value) => value.span(),
125 Self::Calc(value) => value.span(),
126 Self::Delimiter(value) => &value.span,
127 Self::Dimension(value) => value.span(),
128 Self::Function(value) => value.span(),
129 Self::HexColor(value) => &value.span,
130 Self::IdSelector(value) => value.span(),
131 Self::ImportantAnnotation(value) => value.span(),
132 Self::InterpolableIdent(value) => value.span(),
133 Self::InterpolableStr(value) => value.span(),
134 Self::LayerName(value) => value.span(),
135 Self::LessAnonymousMixin(value) => value.span(),
136 Self::LessBinaryOperation(value) => value.span(),
137 Self::LessCondition(value) => value.span(),
138 Self::LessDetachedRuleset(value) => value.span(),
139 Self::LessEscapedStr(value) => value.span(),
140 Self::LessJavaScriptSnippet(value) => value.span(),
141 Self::LessList(value) => value.span(),
142 Self::LessMixinCall(value) => value.span(),
143 Self::LessNamespaceValue(value) => value.span(),
144 Self::LessVariableCall(value) => value.span(),
145 Self::LessNegativeValue(value) => value.span(),
146 Self::LessParenthesizedOperation(value) => value.span(),
147 Self::LessPercentKeyword(value) => &value.span,
148 Self::LessPropertyVariable(value) => value.span(),
149 Self::LessVariable(value) => value.span(),
150 Self::LessVariableVariable(value) => value.span(),
151 Self::Number(value) => value.span(),
152 Self::Percentage(value) => value.span(),
153 Self::Placeholder(value) => &value.span,
154 Self::PostcssSimpleVar(value) => value.span(),
155 Self::Ratio(value) => value.span(),
156 Self::SassArbitraryArgument(value) => value.span(),
157 Self::SassBinaryExpression(value) => value.span(),
158 Self::SassKeywordArgument(value) => value.span(),
159 Self::SassList(value) => value.span(),
160 Self::SassMap(value) => value.span(),
161 Self::SassQualifiedName(value) => value.span(),
162 Self::SassNestingDeclaration(value) => value.span(),
163 Self::SassParenthesizedExpression(value) => value.span(),
164 Self::SassParentSelector(value) => value.span(),
165 Self::SassUnaryExpression(value) => value.span(),
166 Self::SassVariable(value) => value.span(),
167 Self::TokenWithSpan(value) => &value.span,
168 Self::UnicodeRange(value) => value.span(),
169 Self::Url(value) => value.span(),
170 }
171 }
172}
173
174impl<'a> ComponentValues<'a> {
175 #[inline]
176 pub fn span(&self) -> &Span {
177 &self.span
178 }
179}
180
181impl<'a> CompoundSelector<'a> {
182 #[inline]
183 pub fn span(&self) -> &Span {
184 &self.span
185 }
186}
187
188impl<'a> CompoundSelectorList<'a> {
189 #[inline]
190 pub fn span(&self) -> &Span {
191 &self.span
192 }
193}
194
195impl<'a> ContainerCondition<'a> {
196 #[inline]
197 pub fn span(&self) -> &Span {
198 &self.span
199 }
200}
201
202impl<'a> ContainerConditionKind<'a> {
203 #[inline]
204 pub fn span(&self) -> &Span {
205 match self {
206 Self::QueryInParens(value) => value.span(),
207 Self::And(value) => value.span(),
208 Self::Or(value) => value.span(),
209 Self::Not(value) => value.span(),
210 }
211 }
212}
213
214impl<'a> ContainerConditionAnd<'a> {
215 #[inline]
216 pub fn span(&self) -> &Span {
217 &self.span
218 }
219}
220
221impl<'a> ContainerConditionNot<'a> {
222 #[inline]
223 pub fn span(&self) -> &Span {
224 &self.span
225 }
226}
227
228impl<'a> ContainerConditionOr<'a> {
229 #[inline]
230 pub fn span(&self) -> &Span {
231 &self.span
232 }
233}
234
235impl<'a> ContainerPrelude<'a> {
236 #[inline]
237 pub fn span(&self) -> &Span {
238 &self.span
239 }
240}
241
242impl<'a> CustomMedia<'a> {
243 #[inline]
244 pub fn span(&self) -> &Span {
245 &self.span
246 }
247}
248
249impl<'a> CustomMediaValue<'a> {
250 #[inline]
251 pub fn span(&self) -> &Span {
252 match self {
253 Self::MediaQueryList(value) => value.span(),
254 Self::True(value) => value.span(),
255 Self::False(value) => value.span(),
256 }
257 }
258}
259
260impl<'a> CustomSelector<'a> {
261 #[inline]
262 pub fn span(&self) -> &Span {
263 &self.span
264 }
265}
266
267impl<'a> CustomSelectorArg<'a> {
268 #[inline]
269 pub fn span(&self) -> &Span {
270 &self.span
271 }
272}
273
274impl<'a> CustomSelectorArgs<'a> {
275 #[inline]
276 pub fn span(&self) -> &Span {
277 &self.span
278 }
279}
280
281impl<'a> CustomSelectorPrelude<'a> {
282 #[inline]
283 pub fn span(&self) -> &Span {
284 &self.span
285 }
286}
287
288impl<'a> Declaration<'a> {
289 #[inline]
290 pub fn span(&self) -> &Span {
291 &self.span
292 }
293}
294
295impl<'a> Dimension<'a> {
296 #[inline]
297 pub fn span(&self) -> &Span {
298 &self.span
299 }
300}
301
302impl<'a> DocumentPrelude<'a> {
303 #[inline]
304 pub fn span(&self) -> &Span {
305 &self.span
306 }
307}
308
309impl<'a> DocumentPreludeMatcher<'a> {
310 #[inline]
311 pub fn span(&self) -> &Span {
312 match self {
313 Self::Url(value) => value.span(),
314 Self::Function(value) => value.span(),
315 }
316 }
317}
318
319impl<'a> FontFamilyName<'a> {
320 #[inline]
321 pub fn span(&self) -> &Span {
322 match self {
323 Self::Str(value) => value.span(),
324 Self::Unquoted(value) => value.span(),
325 }
326 }
327}
328
329impl<'a> Function<'a> {
330 #[inline]
331 pub fn span(&self) -> &Span {
332 &self.span
333 }
334}
335
336impl<'a> FunctionName<'a> {
337 #[inline]
338 pub fn span(&self) -> &Span {
339 match self {
340 Self::Ident(value) => value.span(),
341 Self::SassQualifiedName(value) => value.span(),
342 Self::LessListFunction(value) => &value.span,
343 Self::LessFormatFunction(value) => &value.span,
344 }
345 }
346}
347
348impl<'a> Ident<'a> {
349 #[inline]
350 pub fn span(&self) -> &Span {
351 &self.span
352 }
353}
354
355impl<'a> ImportPrelude<'a> {
356 #[inline]
357 pub fn span(&self) -> &Span {
358 &self.span
359 }
360}
361
362impl<'a> ImportPreludeHref<'a> {
363 #[inline]
364 pub fn span(&self) -> &Span {
365 match self {
366 Self::Str(value) => value.span(),
367 Self::Url(value) => value.span(),
368 Self::Function(value) => value.span(),
369 }
370 }
371}
372
373impl<'a> ImportPreludeLayer<'a> {
374 #[inline]
375 pub fn span(&self) -> &Span {
376 match self {
377 Self::Empty(value) => value.span(),
378 Self::WithName(value) => value.span(),
379 }
380 }
381}
382
383impl<'a> ImportPreludeSupports<'a> {
384 #[inline]
385 pub fn span(&self) -> &Span {
386 &self.span
387 }
388}
389
390impl<'a> ImportPreludeSupportsKind<'a> {
391 #[inline]
392 pub fn span(&self) -> &Span {
393 match self {
394 Self::SupportsCondition(value) => value.span(),
395 Self::Declaration(value) => value.span(),
396 }
397 }
398}
399
400impl<'a> InterpolableIdent<'a> {
401 #[inline]
402 pub fn span(&self) -> &Span {
403 match self {
404 Self::Literal(value) => value.span(),
405 Self::SassInterpolated(value) => value.span(),
406 Self::LessInterpolated(value) => value.span(),
407 Self::Placeholder(value) => &value.span,
408 }
409 }
410}
411
412impl<'a> InterpolableIdentStaticPart<'a> {
413 #[inline]
414 pub fn span(&self) -> &Span {
415 &self.span
416 }
417}
418
419impl<'a> InterpolableStr<'a> {
420 #[inline]
421 pub fn span(&self) -> &Span {
422 match self {
423 Self::Literal(value) => value.span(),
424 Self::SassInterpolated(value) => value.span(),
425 Self::LessInterpolated(value) => value.span(),
426 }
427 }
428}
429
430impl<'a> InterpolableStrStaticPart<'a> {
431 #[inline]
432 pub fn span(&self) -> &Span {
433 &self.span
434 }
435}
436
437impl<'a> InterpolableUrlStaticPart<'a> {
438 #[inline]
439 pub fn span(&self) -> &Span {
440 &self.span
441 }
442}
443
444impl<'a> IdSelector<'a> {
445 #[inline]
446 pub fn span(&self) -> &Span {
447 &self.span
448 }
449}
450
451impl<'a> ImportantAnnotation<'a> {
452 #[inline]
453 pub fn span(&self) -> &Span {
454 &self.span
455 }
456}
457
458impl<'a> KeyframeBlock<'a> {
459 #[inline]
460 pub fn span(&self) -> &Span {
461 &self.span
462 }
463}
464
465impl<'a> KeyframeSelector<'a> {
466 #[inline]
467 pub fn span(&self) -> &Span {
468 match self {
469 Self::Ident(value) => value.span(),
470 Self::Percentage(value) => value.span(),
471 Self::TimelineRange(value) => value.span(),
472 }
473 }
474}
475
476impl<'a> KeyframeTimelineRange<'a> {
477 #[inline]
478 pub fn span(&self) -> &Span {
479 &self.span
480 }
481}
482
483impl<'a> KeyframesName<'a> {
484 #[inline]
485 pub fn span(&self) -> &Span {
486 match self {
487 Self::Ident(value) => value.span(),
488 Self::Str(value) => value.span(),
489 Self::LessVariable(value) => value.span(),
490 Self::LessEscapedStr(value) => value.span(),
491 }
492 }
493}
494
495impl<'a> LanguageRange<'a> {
496 #[inline]
497 pub fn span(&self) -> &Span {
498 match self {
499 Self::Str(value) => value.span(),
500 Self::Ident(value) => value.span(),
501 }
502 }
503}
504
505impl<'a> LanguageRangeList<'a> {
506 #[inline]
507 pub fn span(&self) -> &Span {
508 &self.span
509 }
510}
511
512impl<'a> LayerName<'a> {
513 #[inline]
514 pub fn span(&self) -> &Span {
515 &self.span
516 }
517}
518
519impl<'a> LayerNames<'a> {
520 #[inline]
521 pub fn span(&self) -> &Span {
522 &self.span
523 }
524}
525
526impl<'a> LessBinaryCondition<'a> {
527 #[inline]
528 pub fn span(&self) -> &Span {
529 &self.span
530 }
531}
532
533impl<'a> LessBinaryOperation<'a> {
534 #[inline]
535 pub fn span(&self) -> &Span {
536 &self.span
537 }
538}
539
540impl<'a> LessCondition<'a> {
541 #[inline]
542 pub fn span(&self) -> &Span {
543 match self {
544 Self::Binary(value) => value.span(),
545 Self::Negated(value) => value.span(),
546 Self::Parenthesized(value) => value.span(),
547 Self::Value(value) => value.span(),
548 }
549 }
550}
551
552impl<'a> LessAnonymousMixin<'a> {
553 #[inline]
554 pub fn span(&self) -> &Span {
555 &self.span
556 }
557}
558
559impl<'a> LessConditionalQualifiedRule<'a> {
560 #[inline]
561 pub fn span(&self) -> &Span {
562 &self.span
563 }
564}
565
566impl<'a> LessConditions<'a> {
567 #[inline]
568 pub fn span(&self) -> &Span {
569 &self.span
570 }
571}
572
573impl<'a> LessDetachedRuleset<'a> {
574 #[inline]
575 pub fn span(&self) -> &Span {
576 &self.span
577 }
578}
579
580impl<'a> LessEscapedStr<'a> {
581 #[inline]
582 pub fn span(&self) -> &Span {
583 &self.span
584 }
585}
586
587impl<'a> LessExtend<'a> {
588 #[inline]
589 pub fn span(&self) -> &Span {
590 &self.span
591 }
592}
593
594impl<'a> LessExtendList<'a> {
595 #[inline]
596 pub fn span(&self) -> &Span {
597 &self.span
598 }
599}
600
601impl<'a> LessExtendRule<'a> {
602 #[inline]
603 pub fn span(&self) -> &Span {
604 &self.span
605 }
606}
607
608impl<'a> LessImportOptions<'a> {
609 #[inline]
610 pub fn span(&self) -> &Span {
611 &self.span
612 }
613}
614
615impl<'a> LessImportPrelude<'a> {
616 #[inline]
617 pub fn span(&self) -> &Span {
618 &self.span
619 }
620}
621
622impl<'a> LessInterpolatedIdent<'a> {
623 #[inline]
624 pub fn span(&self) -> &Span {
625 &self.span
626 }
627}
628
629impl<'a> LessInterpolatedIdentElement<'a> {
630 #[inline]
631 pub fn span(&self) -> &Span {
632 match self {
633 Self::Variable(value) => value.span(),
634 Self::Property(value) => value.span(),
635 Self::Static(value) => value.span(),
636 }
637 }
638}
639
640impl<'a> LessInterpolatedStr<'a> {
641 #[inline]
642 pub fn span(&self) -> &Span {
643 &self.span
644 }
645}
646
647impl<'a> LessInterpolatedStrElement<'a> {
648 #[inline]
649 pub fn span(&self) -> &Span {
650 match self {
651 Self::Variable(value) => value.span(),
652 Self::Property(value) => value.span(),
653 Self::Static(value) => value.span(),
654 }
655 }
656}
657
658impl<'a> LessJavaScriptSnippet<'a> {
659 #[inline]
660 pub fn span(&self) -> &Span {
661 &self.span
662 }
663}
664
665impl<'a> LessList<'a> {
666 #[inline]
667 pub fn span(&self) -> &Span {
668 &self.span
669 }
670}
671
672impl<'a> LessLookup<'a> {
673 #[inline]
674 pub fn span(&self) -> &Span {
675 &self.span
676 }
677}
678
679impl<'a> LessLookupName<'a> {
680 #[inline]
681 pub fn span(&self) -> &Span {
682 match self {
683 Self::LessVariable(value) => value.span(),
684 Self::LessVariableVariable(value) => value.span(),
685 Self::LessPropertyVariable(value) => value.span(),
686 Self::LessPropertyInterpolation(value) => value.span(),
687 Self::Ident(value) => value.span(),
688 }
689 }
690}
691
692impl<'a> LessLookups<'a> {
693 #[inline]
694 pub fn span(&self) -> &Span {
695 &self.span
696 }
697}
698
699impl<'a> LessMixinArgument<'a> {
700 #[inline]
701 pub fn span(&self) -> &Span {
702 match self {
703 Self::Named(value) => value.span(),
704 Self::Value(value) => value.span(),
705 Self::Variadic(value) => value.span(),
706 }
707 }
708}
709
710impl<'a> LessMixinArguments<'a> {
711 #[inline]
712 pub fn span(&self) -> &Span {
713 &self.span
714 }
715}
716
717impl<'a> LessMixinCall<'a> {
718 #[inline]
719 pub fn span(&self) -> &Span {
720 &self.span
721 }
722}
723
724impl<'a> LessMixinCallee<'a> {
725 #[inline]
726 pub fn span(&self) -> &Span {
727 &self.span
728 }
729}
730
731impl<'a> LessMixinCalleeChild<'a> {
732 #[inline]
733 pub fn span(&self) -> &Span {
734 &self.span
735 }
736}
737
738impl<'a> LessMixinDefinition<'a> {
739 #[inline]
740 pub fn span(&self) -> &Span {
741 &self.span
742 }
743}
744
745impl<'a> LessMixinName<'a> {
746 #[inline]
747 pub fn span(&self) -> &Span {
748 match self {
749 Self::ClassSelector(value) => &value.span,
750 Self::IdSelector(value) => value.span(),
751 }
752 }
753}
754
755impl<'a> LessMixinNamedArgument<'a> {
756 #[inline]
757 pub fn span(&self) -> &Span {
758 &self.span
759 }
760}
761
762impl<'a> LessMixinNamedParameter<'a> {
763 #[inline]
764 pub fn span(&self) -> &Span {
765 &self.span
766 }
767}
768
769impl<'a> LessMixinNamedParameterDefaultValue<'a> {
770 #[inline]
771 pub fn span(&self) -> &Span {
772 &self.span
773 }
774}
775
776impl<'a> LessMixinParameter<'a> {
777 #[inline]
778 pub fn span(&self) -> &Span {
779 match self {
780 Self::Named(value) => value.span(),
781 Self::Unnamed(value) => value.span(),
782 Self::Variadic(value) => value.span(),
783 }
784 }
785}
786
787impl<'a> LessMixinParameters<'a> {
788 #[inline]
789 pub fn span(&self) -> &Span {
790 &self.span
791 }
792}
793
794impl<'a> LessMixinParameterName<'a> {
795 #[inline]
796 pub fn span(&self) -> &Span {
797 match self {
798 Self::Variable(value) => value.span(),
799 Self::PropertyVariable(value) => value.span(),
800 }
801 }
802}
803
804impl<'a> LessMixinUnnamedParameter<'a> {
805 #[inline]
806 pub fn span(&self) -> &Span {
807 &self.span
808 }
809}
810
811impl<'a> LessMixinVariadicArgument<'a> {
812 #[inline]
813 pub fn span(&self) -> &Span {
814 &self.span
815 }
816}
817
818impl<'a> LessMixinVariadicParameter<'a> {
819 #[inline]
820 pub fn span(&self) -> &Span {
821 &self.span
822 }
823}
824
825impl<'a> LessNamespaceValue<'a> {
826 #[inline]
827 pub fn span(&self) -> &Span {
828 &self.span
829 }
830}
831
832impl<'a> LessNamespaceValueCallee<'a> {
833 #[inline]
834 pub fn span(&self) -> &Span {
835 match self {
836 Self::LessMixinCall(value) => value.span(),
837 Self::LessVariable(value) => value.span(),
838 }
839 }
840}
841
842impl<'a> LessNegatedCondition<'a> {
843 #[inline]
844 pub fn span(&self) -> &Span {
845 &self.span
846 }
847}
848
849impl<'a> LessNegativeValue<'a> {
850 #[inline]
851 pub fn span(&self) -> &Span {
852 &self.span
853 }
854}
855
856impl<'a> LessParenthesizedCondition<'a> {
857 #[inline]
858 pub fn span(&self) -> &Span {
859 &self.span
860 }
861}
862
863impl<'a> LessParenthesizedOperation<'a> {
864 #[inline]
865 pub fn span(&self) -> &Span {
866 &self.span
867 }
868}
869
870impl<'a> LessPlugin<'a> {
871 #[inline]
872 pub fn span(&self) -> &Span {
873 &self.span
874 }
875}
876
877impl<'a> LessPluginPath<'a> {
878 #[inline]
879 pub fn span(&self) -> &Span {
880 match self {
881 Self::Str(value) => value.span(),
882 Self::Url(value) => value.span(),
883 }
884 }
885}
886
887impl<'a> LessPropertyInterpolation<'a> {
888 #[inline]
889 pub fn span(&self) -> &Span {
890 &self.span
891 }
892}
893
894impl LessPropertyMerge {
895 #[inline]
896 pub fn span(&self) -> &Span {
897 &self.span
898 }
899}
900
901impl<'a> LessPropertyVariable<'a> {
902 #[inline]
903 pub fn span(&self) -> &Span {
904 &self.span
905 }
906}
907
908impl<'a> LessVariable<'a> {
909 #[inline]
910 pub fn span(&self) -> &Span {
911 &self.span
912 }
913}
914
915impl<'a> LessVariableCall<'a> {
916 #[inline]
917 pub fn span(&self) -> &Span {
918 &self.span
919 }
920}
921
922impl<'a> LessVariableDeclaration<'a> {
923 #[inline]
924 pub fn span(&self) -> &Span {
925 &self.span
926 }
927}
928
929impl<'a> LessVariableInterpolation<'a> {
930 #[inline]
931 pub fn span(&self) -> &Span {
932 &self.span
933 }
934}
935
936impl<'a> LessVariableVariable<'a> {
937 #[inline]
938 pub fn span(&self) -> &Span {
939 &self.span
940 }
941}
942
943impl<'a> MediaAnd<'a> {
944 #[inline]
945 pub fn span(&self) -> &Span {
946 &self.span
947 }
948}
949
950impl<'a> MediaCondition<'a> {
951 #[inline]
952 pub fn span(&self) -> &Span {
953 &self.span
954 }
955}
956
957impl<'a> MediaConditionAfterMediaType<'a> {
958 #[inline]
959 pub fn span(&self) -> &Span {
960 &self.span
961 }
962}
963
964impl<'a> MediaConditionKind<'a> {
965 #[inline]
966 pub fn span(&self) -> &Span {
967 match self {
968 Self::MediaInParens(value) => value.span(),
969 Self::And(value) => value.span(),
970 Self::Or(value) => value.span(),
971 Self::Not(value) => value.span(),
972 }
973 }
974}
975
976impl<'a> MediaFeature<'a> {
977 #[inline]
978 pub fn span(&self) -> &Span {
979 match self {
980 Self::Plain(value) => value.span(),
981 Self::Boolean(value) => value.span(),
982 Self::Range(value) => value.span(),
983 Self::RangeInterval(value) => value.span(),
984 }
985 }
986}
987
988impl<'a> MediaFeatureName<'a> {
989 #[inline]
990 pub fn span(&self) -> &Span {
991 match self {
992 Self::Ident(value) => value.span(),
993 Self::PostcssSimpleVar(value) => value.span(),
994 Self::SassVariable(value) => value.span(),
995 }
996 }
997}
998
999impl<'a> MediaFeatureBoolean<'a> {
1000 #[inline]
1001 pub fn span(&self) -> &Span {
1002 &self.span
1003 }
1004}
1005
1006impl<'a> MediaFeaturePlain<'a> {
1007 #[inline]
1008 pub fn span(&self) -> &Span {
1009 &self.span
1010 }
1011}
1012
1013impl<'a> MediaFeatureRange<'a> {
1014 #[inline]
1015 pub fn span(&self) -> &Span {
1016 &self.span
1017 }
1018}
1019
1020impl<'a> MediaFeatureRangeInterval<'a> {
1021 #[inline]
1022 pub fn span(&self) -> &Span {
1023 &self.span
1024 }
1025}
1026
1027impl<'a> MediaInParens<'a> {
1028 #[inline]
1029 pub fn span(&self) -> &Span {
1030 &self.span
1031 }
1032}
1033
1034impl<'a> MediaInParensKind<'a> {
1035 #[inline]
1036 pub fn span(&self) -> &Span {
1037 match self {
1038 Self::MediaCondition(value) => value.span(),
1039 Self::MediaFeature(value) => value.span(),
1040 Self::GeneralEnclosed(value) => value.span(),
1041 Self::SassInterpolation(value) => value.span(),
1042 }
1043 }
1044}
1045
1046impl<'a> MediaNot<'a> {
1047 #[inline]
1048 pub fn span(&self) -> &Span {
1049 &self.span
1050 }
1051}
1052
1053impl<'a> MediaOr<'a> {
1054 #[inline]
1055 pub fn span(&self) -> &Span {
1056 &self.span
1057 }
1058}
1059
1060impl<'a> MediaQuery<'a> {
1061 #[inline]
1062 pub fn span(&self) -> &Span {
1063 match self {
1064 Self::ConditionOnly(value) => value.span(),
1065 Self::WithType(value) => value.span(),
1066 Self::Function(value) => value.span(),
1067 Self::LessVariable(value) => value.span(),
1068 Self::LessNamespaceValue(value) => value.span(),
1069 }
1070 }
1071}
1072
1073impl<'a> MediaQueryList<'a> {
1074 #[inline]
1075 pub fn span(&self) -> &Span {
1076 &self.span
1077 }
1078}
1079
1080impl<'a> MediaQueryWithType<'a> {
1081 #[inline]
1082 pub fn span(&self) -> &Span {
1083 &self.span
1084 }
1085}
1086
1087impl<'a> NamespacePrelude<'a> {
1088 #[inline]
1089 pub fn span(&self) -> &Span {
1090 &self.span
1091 }
1092}
1093
1094impl<'a> NamespacePreludeUri<'a> {
1095 #[inline]
1096 pub fn span(&self) -> &Span {
1097 match self {
1098 Self::Str(value) => value.span(),
1099 Self::Url(value) => value.span(),
1100 }
1101 }
1102}
1103
1104impl<'a> NestingSelector<'a> {
1105 #[inline]
1106 pub fn span(&self) -> &Span {
1107 &self.span
1108 }
1109}
1110
1111impl<'a> NsPrefix<'a> {
1112 #[inline]
1113 pub fn span(&self) -> &Span {
1114 &self.span
1115 }
1116}
1117
1118impl<'a> NsPrefixKind<'a> {
1119 #[inline]
1120 pub fn span(&self) -> &Span {
1121 match self {
1122 Self::Ident(value) => value.span(),
1123 Self::Universal(value) => value.span(),
1124 }
1125 }
1126}
1127
1128impl NsPrefixUniversal {
1129 #[inline]
1130 pub fn span(&self) -> &Span {
1131 &self.span
1132 }
1133}
1134
1135impl<'a> Nth<'a> {
1136 #[inline]
1137 pub fn span(&self) -> &Span {
1138 &self.span
1139 }
1140}
1141
1142impl<'a> NthIndex<'a> {
1143 #[inline]
1144 pub fn span(&self) -> &Span {
1145 match self {
1146 Self::Odd(value) => value.span(),
1147 Self::Even(value) => value.span(),
1148 Self::Integer(value) => value.span(),
1149 Self::AnPlusB(value) => &value.span,
1150 }
1151 }
1152}
1153
1154impl<'a> Number<'a> {
1155 #[inline]
1156 pub fn span(&self) -> &Span {
1157 &self.span
1158 }
1159}
1160
1161impl<'a> PageSelector<'a> {
1162 #[inline]
1163 pub fn span(&self) -> &Span {
1164 &self.span
1165 }
1166}
1167
1168impl<'a> PageSelectorList<'a> {
1169 #[inline]
1170 pub fn span(&self) -> &Span {
1171 &self.span
1172 }
1173}
1174
1175impl<'a> Percentage<'a> {
1176 #[inline]
1177 pub fn span(&self) -> &Span {
1178 &self.span
1179 }
1180}
1181
1182impl<'a> PostcssSimpleVar<'a> {
1183 #[inline]
1184 pub fn span(&self) -> &Span {
1185 &self.span
1186 }
1187}
1188
1189impl<'a> PostcssSimpleVarDeclaration<'a> {
1190 #[inline]
1191 pub fn span(&self) -> &Span {
1192 &self.span
1193 }
1194}
1195
1196impl<'a> PseudoClassSelector<'a> {
1197 #[inline]
1198 pub fn span(&self) -> &Span {
1199 &self.span
1200 }
1201}
1202
1203impl<'a> PseudoClassSelectorArg<'a> {
1204 #[inline]
1205 pub fn span(&self) -> &Span {
1206 &self.span
1207 }
1208}
1209
1210impl<'a> PseudoClassSelectorArgKind<'a> {
1211 #[inline]
1212 pub fn span(&self) -> &Span {
1213 match self {
1214 Self::CompoundSelectorList(value) => value.span(),
1215 Self::Ident(value) => value.span(),
1216 Self::LanguageRangeList(value) => value.span(),
1217 Self::Nth(value) => value.span(),
1218 Self::Number(value) => value.span(),
1219 Self::RelativeSelectorList(value) => value.span(),
1220 Self::SelectorList(value) => value.span(),
1221 Self::LessExtendList(value) => value.span(),
1222 Self::TokenSeq(value) => value.span(),
1223 }
1224 }
1225}
1226
1227impl<'a> PseudoElementSelector<'a> {
1228 #[inline]
1229 pub fn span(&self) -> &Span {
1230 &self.span
1231 }
1232}
1233
1234impl<'a> PseudoElementSelectorArg<'a> {
1235 #[inline]
1236 pub fn span(&self) -> &Span {
1237 &self.span
1238 }
1239}
1240
1241impl<'a> PseudoElementSelectorArgKind<'a> {
1242 #[inline]
1243 pub fn span(&self) -> &Span {
1244 match self {
1245 Self::CompoundSelector(value) => value.span(),
1246 Self::CompoundSelectorList(value) => value.span(),
1247 Self::Ident(value) => value.span(),
1248 Self::IdentList(value) => value.span(),
1249 Self::TokenSeq(value) => value.span(),
1250 }
1251 }
1252}
1253
1254impl<'a> IdentList<'a> {
1255 #[inline]
1256 pub fn span(&self) -> &Span {
1257 &self.span
1258 }
1259}
1260
1261impl<'a> PseudoPage<'a> {
1262 #[inline]
1263 pub fn span(&self) -> &Span {
1264 &self.span
1265 }
1266}
1267
1268impl<'a> QualifiedRule<'a> {
1269 #[inline]
1270 pub fn span(&self) -> &Span {
1271 &self.span
1272 }
1273}
1274
1275impl<'a> QueryInParens<'a> {
1276 #[inline]
1277 pub fn span(&self) -> &Span {
1278 &self.span
1279 }
1280}
1281
1282impl<'a> QueryInParensKind<'a> {
1283 #[inline]
1284 pub fn span(&self) -> &Span {
1285 match self {
1286 Self::ContainerCondition(value) => value.span(),
1287 Self::SizeFeature(value) => value.span(),
1288 Self::StyleQuery(value) => value.span(),
1289 Self::ScrollState(value) => value.span(),
1290 Self::GeneralEnclosed(value) => value.span(),
1291 }
1292 }
1293}
1294
1295impl<'a> Ratio<'a> {
1296 #[inline]
1297 pub fn span(&self) -> &Span {
1298 &self.span
1299 }
1300}
1301
1302impl<'a> RelativeSelector<'a> {
1303 #[inline]
1304 pub fn span(&self) -> &Span {
1305 &self.span
1306 }
1307}
1308
1309impl<'a> RelativeSelectorList<'a> {
1310 #[inline]
1311 pub fn span(&self) -> &Span {
1312 &self.span
1313 }
1314}
1315
1316impl<'a> SassArbitraryArgument<'a> {
1317 #[inline]
1318 pub fn span(&self) -> &Span {
1319 &self.span
1320 }
1321}
1322
1323impl<'a> SassArbitraryParameter<'a> {
1324 #[inline]
1325 pub fn span(&self) -> &Span {
1326 &self.span
1327 }
1328}
1329
1330impl<'a> SassAtRoot<'a> {
1331 #[inline]
1332 pub fn span(&self) -> &Span {
1333 &self.span
1334 }
1335}
1336
1337impl<'a> SassAtRootKind<'a> {
1338 #[inline]
1339 pub fn span(&self) -> &Span {
1340 match self {
1341 Self::Selector(value) => value.span(),
1342 Self::Query(value) => value.span(),
1343 }
1344 }
1345}
1346
1347impl<'a> SassAtRootQuery<'a> {
1348 #[inline]
1349 pub fn span(&self) -> &Span {
1350 &self.span
1351 }
1352}
1353
1354impl<'a> SassAtRootQueryRule<'a> {
1355 #[inline]
1356 pub fn span(&self) -> &Span {
1357 match self {
1358 Self::Ident(value) => value.span(),
1359 Self::Str(value) => value.span(),
1360 }
1361 }
1362}
1363
1364impl<'a> SassBinaryExpression<'a> {
1365 #[inline]
1366 pub fn span(&self) -> &Span {
1367 &self.span
1368 }
1369}
1370
1371impl<'a> SassConditionalClause<'a> {
1372 #[inline]
1373 pub fn span(&self) -> &Span {
1374 &self.span
1375 }
1376}
1377
1378impl<'a> SassContent<'a> {
1379 #[inline]
1380 pub fn span(&self) -> &Span {
1381 &self.span
1382 }
1383}
1384
1385impl<'a> SassEach<'a> {
1386 #[inline]
1387 pub fn span(&self) -> &Span {
1388 &self.span
1389 }
1390}
1391
1392impl<'a> SassExtend<'a> {
1393 #[inline]
1394 pub fn span(&self) -> &Span {
1395 &self.span
1396 }
1397}
1398
1399impl<'a> SassFlag<'a> {
1400 #[inline]
1401 pub fn span(&self) -> &Span {
1402 &self.span
1403 }
1404}
1405
1406impl<'a> SassFor<'a> {
1407 #[inline]
1408 pub fn span(&self) -> &Span {
1409 &self.span
1410 }
1411}
1412
1413impl SassForBoundary {
1414 #[inline]
1415 pub fn span(&self) -> &Span {
1416 &self.span
1417 }
1418}
1419
1420impl<'a> SassForward<'a> {
1421 #[inline]
1422 pub fn span(&self) -> &Span {
1423 &self.span
1424 }
1425}
1426
1427impl<'a> SassForwardMember<'a> {
1428 #[inline]
1429 pub fn span(&self) -> &Span {
1430 match self {
1431 Self::Ident(value) => value.span(),
1432 Self::Variable(value) => value.span(),
1433 }
1434 }
1435}
1436
1437impl<'a> SassForwardPrefix<'a> {
1438 #[inline]
1439 pub fn span(&self) -> &Span {
1440 &self.span
1441 }
1442}
1443
1444impl<'a> SassForwardVisibility<'a> {
1445 #[inline]
1446 pub fn span(&self) -> &Span {
1447 &self.span
1448 }
1449}
1450
1451impl<'a> SassFunction<'a> {
1452 #[inline]
1453 pub fn span(&self) -> &Span {
1454 &self.span
1455 }
1456}
1457
1458impl<'a> SassIfAtRule<'a> {
1459 #[inline]
1460 pub fn span(&self) -> &Span {
1461 &self.span
1462 }
1463}
1464
1465impl<'a> SassImportPrelude<'a> {
1466 #[inline]
1467 pub fn span(&self) -> &Span {
1468 &self.span
1469 }
1470}
1471
1472impl<'a> SassInclude<'a> {
1473 #[inline]
1474 pub fn span(&self) -> &Span {
1475 &self.span
1476 }
1477}
1478
1479impl<'a> SassIncludeArgs<'a> {
1480 #[inline]
1481 pub fn span(&self) -> &Span {
1482 &self.span
1483 }
1484}
1485
1486impl<'a> SassIncludeContentBlockParams<'a> {
1487 #[inline]
1488 pub fn span(&self) -> &Span {
1489 &self.span
1490 }
1491}
1492
1493impl<'a> SassInterpolatedIdent<'a> {
1494 #[inline]
1495 pub fn span(&self) -> &Span {
1496 &self.span
1497 }
1498}
1499
1500impl<'a> SassInterpolatedIdentElement<'a> {
1501 #[inline]
1502 pub fn span(&self) -> &Span {
1503 match self {
1504 Self::Expression(value) => value.span(),
1505 Self::Static(value) => value.span(),
1506 }
1507 }
1508}
1509
1510impl<'a> SassInterpolatedStr<'a> {
1511 #[inline]
1512 pub fn span(&self) -> &Span {
1513 &self.span
1514 }
1515}
1516
1517impl<'a> SassInterpolatedStrElement<'a> {
1518 #[inline]
1519 pub fn span(&self) -> &Span {
1520 match self {
1521 Self::Expression(value) => value.span(),
1522 Self::Static(value) => value.span(),
1523 }
1524 }
1525}
1526
1527impl<'a> SassInterpolatedUrl<'a> {
1528 #[inline]
1529 pub fn span(&self) -> &Span {
1530 &self.span
1531 }
1532}
1533
1534impl<'a> SassInterpolatedUrlElement<'a> {
1535 #[inline]
1536 pub fn span(&self) -> &Span {
1537 match self {
1538 Self::Expression(value) => value.span(),
1539 Self::Static(value) => value.span(),
1540 }
1541 }
1542}
1543
1544impl<'a> SassKeywordArgument<'a> {
1545 #[inline]
1546 pub fn span(&self) -> &Span {
1547 &self.span
1548 }
1549}
1550
1551impl<'a> SassList<'a> {
1552 #[inline]
1553 pub fn span(&self) -> &Span {
1554 &self.span
1555 }
1556}
1557
1558impl<'a> SassMap<'a> {
1559 #[inline]
1560 pub fn span(&self) -> &Span {
1561 &self.span
1562 }
1563}
1564
1565impl<'a> SassMapItem<'a> {
1566 #[inline]
1567 pub fn span(&self) -> &Span {
1568 &self.span
1569 }
1570}
1571
1572impl<'a> SassMixin<'a> {
1573 #[inline]
1574 pub fn span(&self) -> &Span {
1575 &self.span
1576 }
1577}
1578
1579impl<'a> SassModuleConfig<'a> {
1580 #[inline]
1581 pub fn span(&self) -> &Span {
1582 &self.span
1583 }
1584}
1585
1586impl<'a> SassModuleConfigItem<'a> {
1587 #[inline]
1588 pub fn span(&self) -> &Span {
1589 &self.span
1590 }
1591}
1592
1593impl<'a> SassModuleMemberName<'a> {
1594 #[inline]
1595 pub fn span(&self) -> &Span {
1596 match self {
1597 Self::Ident(value) => value.span(),
1598 Self::Variable(value) => value.span(),
1599 }
1600 }
1601}
1602
1603impl<'a> SassNestingDeclaration<'a> {
1604 #[inline]
1605 pub fn span(&self) -> &Span {
1606 &self.span
1607 }
1608}
1609
1610impl<'a> SassParameter<'a> {
1611 #[inline]
1612 pub fn span(&self) -> &Span {
1613 &self.span
1614 }
1615}
1616
1617impl<'a> SassParameterDefaultValue<'a> {
1618 #[inline]
1619 pub fn span(&self) -> &Span {
1620 &self.span
1621 }
1622}
1623
1624impl<'a> SassParameters<'a> {
1625 #[inline]
1626 pub fn span(&self) -> &Span {
1627 &self.span
1628 }
1629}
1630
1631impl<'a> SassParenthesizedExpression<'a> {
1632 #[inline]
1633 pub fn span(&self) -> &Span {
1634 &self.span
1635 }
1636}
1637
1638impl<'a> SassPlaceholderSelector<'a> {
1639 #[inline]
1640 pub fn span(&self) -> &Span {
1641 &self.span
1642 }
1643}
1644
1645impl<'a> SassQualifiedName<'a> {
1646 #[inline]
1647 pub fn span(&self) -> &Span {
1648 &self.span
1649 }
1650}
1651
1652impl<'a> SassUnaryExpression<'a> {
1653 #[inline]
1654 pub fn span(&self) -> &Span {
1655 &self.span
1656 }
1657}
1658
1659impl SassUnnamedNamespace {
1660 #[inline]
1661 pub fn span(&self) -> &Span {
1662 &self.span
1663 }
1664}
1665
1666impl<'a> SassUse<'a> {
1667 #[inline]
1668 pub fn span(&self) -> &Span {
1669 &self.span
1670 }
1671}
1672
1673impl<'a> SassUseNamespace<'a> {
1674 #[inline]
1675 pub fn span(&self) -> &Span {
1676 &self.span
1677 }
1678}
1679
1680impl<'a> SassUseNamespaceKind<'a> {
1681 #[inline]
1682 pub fn span(&self) -> &Span {
1683 match self {
1684 Self::Named(value) => value.span(),
1685 Self::Unnamed(value) => value.span(),
1686 }
1687 }
1688}
1689
1690impl<'a> SassVariable<'a> {
1691 #[inline]
1692 pub fn span(&self) -> &Span {
1693 &self.span
1694 }
1695}
1696
1697impl<'a> SassVariableDeclaration<'a> {
1698 #[inline]
1699 pub fn span(&self) -> &Span {
1700 &self.span
1701 }
1702}
1703
1704impl<'a> ScopeEnd<'a> {
1705 #[inline]
1706 pub fn span(&self) -> &Span {
1707 &self.span
1708 }
1709}
1710
1711impl<'a> ScopePrelude<'a> {
1712 #[inline]
1713 pub fn span(&self) -> &Span {
1714 match self {
1715 Self::StartOnly(value) => value.span(),
1716 Self::EndOnly(value) => value.span(),
1717 Self::Both(value) => value.span(),
1718 }
1719 }
1720}
1721
1722impl<'a> ScopeStart<'a> {
1723 #[inline]
1724 pub fn span(&self) -> &Span {
1725 &self.span
1726 }
1727}
1728
1729impl<'a> ScopeStartWithEnd<'a> {
1730 #[inline]
1731 pub fn span(&self) -> &Span {
1732 &self.span
1733 }
1734}
1735
1736impl<'a> SelectorList<'a> {
1737 #[inline]
1738 pub fn span(&self) -> &Span {
1739 &self.span
1740 }
1741}
1742
1743impl<'a> SimpleBlock<'a> {
1744 #[inline]
1745 pub fn span(&self) -> &Span {
1746 &self.span
1747 }
1748}
1749
1750impl<'a> SimpleSelector<'a> {
1751 #[inline]
1752 pub fn span(&self) -> &Span {
1753 match self {
1754 Self::Class(value) => &value.span,
1755 Self::Id(value) => value.span(),
1756 Self::Type(value) => value.span(),
1757 Self::Attribute(value) => value.span(),
1758 Self::PseudoClass(value) => value.span(),
1759 Self::PseudoElement(value) => value.span(),
1760 Self::Nesting(value) => value.span(),
1761 Self::SassPlaceholder(value) => value.span(),
1762 }
1763 }
1764}
1765
1766impl<'a> Statement<'a> {
1767 #[inline]
1768 pub fn span(&self) -> &Span {
1769 match self {
1770 Self::AtRule(value) => value.span(),
1771 Self::Declaration(value) => value.span(),
1772 Self::KeyframeBlock(value) => value.span(),
1773 Self::LessConditionalQualifiedRule(value) => value.span(),
1774 Self::LessExtendRule(value) => value.span(),
1775 Self::LessFunctionCall(value) => value.span(),
1776 Self::LessMixinCall(value) => value.span(),
1777 Self::LessMixinDefinition(value) => value.span(),
1778 Self::LessVariableCall(value) => value.span(),
1779 Self::LessVariableDeclaration(value) => value.span(),
1780 Self::Placeholder(value) => &value.span,
1781 Self::PostcssSimpleVarDeclaration(value) => value.span(),
1782 Self::QualifiedRule(value) => value.span(),
1783 Self::SassIfAtRule(value) => value.span(),
1784 Self::SassVariableDeclaration(value) => value.span(),
1785 Self::UnknownQualifiedRule(value) => value.span(),
1786 Self::UnknownSassAtRule(value) => value.span(),
1787 }
1788 }
1789}
1790
1791impl<'a> Str<'a> {
1792 #[inline]
1793 pub fn span(&self) -> &Span {
1794 &self.span
1795 }
1796}
1797
1798impl<'a> StyleCondition<'a> {
1799 #[inline]
1800 pub fn span(&self) -> &Span {
1801 &self.span
1802 }
1803}
1804
1805impl<'a> StyleConditionKind<'a> {
1806 #[inline]
1807 pub fn span(&self) -> &Span {
1808 match self {
1809 Self::StyleInParens(value) => value.span(),
1810 Self::And(value) => value.span(),
1811 Self::Or(value) => value.span(),
1812 Self::Not(value) => value.span(),
1813 }
1814 }
1815}
1816
1817impl<'a> StyleConditionAnd<'a> {
1818 #[inline]
1819 pub fn span(&self) -> &Span {
1820 &self.span
1821 }
1822}
1823
1824impl<'a> StyleConditionNot<'a> {
1825 #[inline]
1826 pub fn span(&self) -> &Span {
1827 &self.span
1828 }
1829}
1830
1831impl<'a> StyleConditionOr<'a> {
1832 #[inline]
1833 pub fn span(&self) -> &Span {
1834 &self.span
1835 }
1836}
1837
1838impl<'a> StyleInParens<'a> {
1839 #[inline]
1840 pub fn span(&self) -> &Span {
1841 &self.span
1842 }
1843}
1844
1845impl<'a> StyleInParensKind<'a> {
1846 #[inline]
1847 pub fn span(&self) -> &Span {
1848 match self {
1849 Self::Condition(value) => value.span(),
1850 Self::Feature(value) => value.span(),
1851 }
1852 }
1853}
1854
1855impl<'a> StyleQuery<'a> {
1856 #[inline]
1857 pub fn span(&self) -> &Span {
1858 match self {
1859 Self::Condition(value) => value.span(),
1860 Self::Feature(value) => value.span(),
1861 Self::FeatureName(value) => value.span(),
1862 }
1863 }
1864}
1865
1866impl<'a> Stylesheet<'a> {
1867 #[inline]
1868 pub fn span(&self) -> &Span {
1869 &self.span
1870 }
1871}
1872
1873impl<'a> SupportsAnd<'a> {
1874 #[inline]
1875 pub fn span(&self) -> &Span {
1876 &self.span
1877 }
1878}
1879
1880impl<'a> SupportsCondition<'a> {
1881 #[inline]
1882 pub fn span(&self) -> &Span {
1883 &self.span
1884 }
1885}
1886
1887impl<'a> SupportsConditionKind<'a> {
1888 #[inline]
1889 pub fn span(&self) -> &Span {
1890 match self {
1891 Self::Not(value) => value.span(),
1892 Self::And(value) => value.span(),
1893 Self::Or(value) => value.span(),
1894 Self::SupportsInParens(value) => value.span(),
1895 }
1896 }
1897}
1898
1899impl<'a> SupportsDecl<'a> {
1900 #[inline]
1901 pub fn span(&self) -> &Span {
1902 &self.span
1903 }
1904}
1905
1906impl<'a> SupportsInParens<'a> {
1907 #[inline]
1908 pub fn span(&self) -> &Span {
1909 &self.span
1910 }
1911}
1912
1913impl<'a> SupportsInParensKind<'a> {
1914 #[inline]
1915 pub fn span(&self) -> &Span {
1916 match self {
1917 Self::SupportsCondition(value) => value.span(),
1918 Self::Feature(value) => value.span(),
1919 Self::Selector(value) => value.span(),
1920 Self::Function(value) => value.span(),
1921 Self::GeneralEnclosed(value) => value.span(),
1922 Self::Interpolation(value) => value.span(),
1923 }
1924 }
1925}
1926
1927impl<'a> SupportsNot<'a> {
1928 #[inline]
1929 pub fn span(&self) -> &Span {
1930 &self.span
1931 }
1932}
1933
1934impl<'a> SupportsOr<'a> {
1935 #[inline]
1936 pub fn span(&self) -> &Span {
1937 &self.span
1938 }
1939}
1940
1941impl<'a> TagNameSelector<'a> {
1942 #[inline]
1943 pub fn span(&self) -> &Span {
1944 &self.span
1945 }
1946}
1947
1948impl<'a> TokenSeq<'a> {
1949 #[inline]
1950 pub fn span(&self) -> &Span {
1951 &self.span
1952 }
1953}
1954
1955impl<'a> TypeSelector<'a> {
1956 #[inline]
1957 pub fn span(&self) -> &Span {
1958 match self {
1959 Self::TagName(value) => value.span(),
1960 Self::Universal(value) => value.span(),
1961 }
1962 }
1963}
1964
1965impl<'a> UnicodeRange<'a> {
1966 #[inline]
1967 pub fn span(&self) -> &Span {
1968 &self.span
1969 }
1970}
1971
1972impl<'a> UniversalSelector<'a> {
1973 #[inline]
1974 pub fn span(&self) -> &Span {
1975 &self.span
1976 }
1977}
1978
1979impl<'a> UnknownAtRulePrelude<'a> {
1980 #[inline]
1981 pub fn span(&self) -> &Span {
1982 match self {
1983 Self::ComponentValue(value) => value.span(),
1984 Self::TokenSeq(value) => value.span(),
1985 }
1986 }
1987}
1988
1989impl<'a> UnknownQualifiedRule<'a> {
1990 #[inline]
1991 pub fn span(&self) -> &Span {
1992 &self.span
1993 }
1994}
1995
1996impl<'a> UnknownSassAtRule<'a> {
1997 #[inline]
1998 pub fn span(&self) -> &Span {
1999 &self.span
2000 }
2001}
2002
2003impl<'a> UnquotedFontFamilyName<'a> {
2004 #[inline]
2005 pub fn span(&self) -> &Span {
2006 &self.span
2007 }
2008}
2009
2010impl<'a> Url<'a> {
2011 #[inline]
2012 pub fn span(&self) -> &Span {
2013 &self.span
2014 }
2015}
2016
2017impl<'a> UrlModifier<'a> {
2018 #[inline]
2019 pub fn span(&self) -> &Span {
2020 match self {
2021 Self::Ident(value) => value.span(),
2022 Self::Function(value) => value.span(),
2023 }
2024 }
2025}
2026
2027impl<'a> UrlValue<'a> {
2028 #[inline]
2029 pub fn span(&self) -> &Span {
2030 match self {
2031 Self::Raw(value) => &value.span,
2032 Self::SassInterpolated(value) => value.span(),
2033 Self::Str(value) => value.span(),
2034 Self::LessEscapedStr(value) => value.span(),
2035 }
2036 }
2037}
2038
2039impl<'a> WqName<'a> {
2040 #[inline]
2041 pub fn span(&self) -> &Span {
2042 &self.span
2043 }
2044}