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::CompoundSelector(value) => value.span(),
1215 Self::CompoundSelectorList(value) => value.span(),
1216 Self::Ident(value) => value.span(),
1217 Self::LanguageRangeList(value) => value.span(),
1218 Self::Nth(value) => value.span(),
1219 Self::Number(value) => value.span(),
1220 Self::RelativeSelectorList(value) => value.span(),
1221 Self::SelectorList(value) => value.span(),
1222 Self::LessExtendList(value) => value.span(),
1223 Self::TokenSeq(value) => value.span(),
1224 }
1225 }
1226}
1227
1228impl<'a> PseudoElementSelector<'a> {
1229 #[inline]
1230 pub fn span(&self) -> &Span {
1231 &self.span
1232 }
1233}
1234
1235impl<'a> PseudoElementSelectorArg<'a> {
1236 #[inline]
1237 pub fn span(&self) -> &Span {
1238 &self.span
1239 }
1240}
1241
1242impl<'a> PseudoElementSelectorArgKind<'a> {
1243 #[inline]
1244 pub fn span(&self) -> &Span {
1245 match self {
1246 Self::CompoundSelector(value) => value.span(),
1247 Self::CompoundSelectorList(value) => value.span(),
1248 Self::Ident(value) => value.span(),
1249 Self::IdentList(value) => value.span(),
1250 Self::TokenSeq(value) => value.span(),
1251 }
1252 }
1253}
1254
1255impl<'a> IdentList<'a> {
1256 #[inline]
1257 pub fn span(&self) -> &Span {
1258 &self.span
1259 }
1260}
1261
1262impl<'a> PseudoPage<'a> {
1263 #[inline]
1264 pub fn span(&self) -> &Span {
1265 &self.span
1266 }
1267}
1268
1269impl<'a> QualifiedRule<'a> {
1270 #[inline]
1271 pub fn span(&self) -> &Span {
1272 &self.span
1273 }
1274}
1275
1276impl<'a> QueryInParens<'a> {
1277 #[inline]
1278 pub fn span(&self) -> &Span {
1279 &self.span
1280 }
1281}
1282
1283impl<'a> QueryInParensKind<'a> {
1284 #[inline]
1285 pub fn span(&self) -> &Span {
1286 match self {
1287 Self::ContainerCondition(value) => value.span(),
1288 Self::SizeFeature(value) => value.span(),
1289 Self::StyleQuery(value) => value.span(),
1290 Self::ScrollState(value) => value.span(),
1291 Self::GeneralEnclosed(value) => value.span(),
1292 }
1293 }
1294}
1295
1296impl<'a> Ratio<'a> {
1297 #[inline]
1298 pub fn span(&self) -> &Span {
1299 &self.span
1300 }
1301}
1302
1303impl<'a> RelativeSelector<'a> {
1304 #[inline]
1305 pub fn span(&self) -> &Span {
1306 &self.span
1307 }
1308}
1309
1310impl<'a> RelativeSelectorList<'a> {
1311 #[inline]
1312 pub fn span(&self) -> &Span {
1313 &self.span
1314 }
1315}
1316
1317impl<'a> SassArbitraryArgument<'a> {
1318 #[inline]
1319 pub fn span(&self) -> &Span {
1320 &self.span
1321 }
1322}
1323
1324impl<'a> SassArbitraryParameter<'a> {
1325 #[inline]
1326 pub fn span(&self) -> &Span {
1327 &self.span
1328 }
1329}
1330
1331impl<'a> SassAtRoot<'a> {
1332 #[inline]
1333 pub fn span(&self) -> &Span {
1334 &self.span
1335 }
1336}
1337
1338impl<'a> SassAtRootKind<'a> {
1339 #[inline]
1340 pub fn span(&self) -> &Span {
1341 match self {
1342 Self::Selector(value) => value.span(),
1343 Self::Query(value) => value.span(),
1344 }
1345 }
1346}
1347
1348impl<'a> SassAtRootQuery<'a> {
1349 #[inline]
1350 pub fn span(&self) -> &Span {
1351 &self.span
1352 }
1353}
1354
1355impl<'a> SassAtRootQueryRule<'a> {
1356 #[inline]
1357 pub fn span(&self) -> &Span {
1358 match self {
1359 Self::Ident(value) => value.span(),
1360 Self::Str(value) => value.span(),
1361 }
1362 }
1363}
1364
1365impl<'a> SassBinaryExpression<'a> {
1366 #[inline]
1367 pub fn span(&self) -> &Span {
1368 &self.span
1369 }
1370}
1371
1372impl<'a> SassConditionalClause<'a> {
1373 #[inline]
1374 pub fn span(&self) -> &Span {
1375 &self.span
1376 }
1377}
1378
1379impl<'a> SassContent<'a> {
1380 #[inline]
1381 pub fn span(&self) -> &Span {
1382 &self.span
1383 }
1384}
1385
1386impl<'a> SassEach<'a> {
1387 #[inline]
1388 pub fn span(&self) -> &Span {
1389 &self.span
1390 }
1391}
1392
1393impl<'a> SassExtend<'a> {
1394 #[inline]
1395 pub fn span(&self) -> &Span {
1396 &self.span
1397 }
1398}
1399
1400impl<'a> SassFlag<'a> {
1401 #[inline]
1402 pub fn span(&self) -> &Span {
1403 &self.span
1404 }
1405}
1406
1407impl<'a> SassFor<'a> {
1408 #[inline]
1409 pub fn span(&self) -> &Span {
1410 &self.span
1411 }
1412}
1413
1414impl SassForBoundary {
1415 #[inline]
1416 pub fn span(&self) -> &Span {
1417 &self.span
1418 }
1419}
1420
1421impl<'a> SassForward<'a> {
1422 #[inline]
1423 pub fn span(&self) -> &Span {
1424 &self.span
1425 }
1426}
1427
1428impl<'a> SassForwardMember<'a> {
1429 #[inline]
1430 pub fn span(&self) -> &Span {
1431 match self {
1432 Self::Ident(value) => value.span(),
1433 Self::Variable(value) => value.span(),
1434 }
1435 }
1436}
1437
1438impl<'a> SassForwardPrefix<'a> {
1439 #[inline]
1440 pub fn span(&self) -> &Span {
1441 &self.span
1442 }
1443}
1444
1445impl<'a> SassForwardVisibility<'a> {
1446 #[inline]
1447 pub fn span(&self) -> &Span {
1448 &self.span
1449 }
1450}
1451
1452impl<'a> SassFunction<'a> {
1453 #[inline]
1454 pub fn span(&self) -> &Span {
1455 &self.span
1456 }
1457}
1458
1459impl<'a> SassIfAtRule<'a> {
1460 #[inline]
1461 pub fn span(&self) -> &Span {
1462 &self.span
1463 }
1464}
1465
1466impl<'a> SassImportPrelude<'a> {
1467 #[inline]
1468 pub fn span(&self) -> &Span {
1469 &self.span
1470 }
1471}
1472
1473impl<'a> SassInclude<'a> {
1474 #[inline]
1475 pub fn span(&self) -> &Span {
1476 &self.span
1477 }
1478}
1479
1480impl<'a> SassIncludeArgs<'a> {
1481 #[inline]
1482 pub fn span(&self) -> &Span {
1483 &self.span
1484 }
1485}
1486
1487impl<'a> SassIncludeContentBlockParams<'a> {
1488 #[inline]
1489 pub fn span(&self) -> &Span {
1490 &self.span
1491 }
1492}
1493
1494impl<'a> SassInterpolatedIdent<'a> {
1495 #[inline]
1496 pub fn span(&self) -> &Span {
1497 &self.span
1498 }
1499}
1500
1501impl<'a> SassInterpolatedIdentElement<'a> {
1502 #[inline]
1503 pub fn span(&self) -> &Span {
1504 match self {
1505 Self::Expression(value) => value.span(),
1506 Self::Static(value) => value.span(),
1507 }
1508 }
1509}
1510
1511impl<'a> SassInterpolatedStr<'a> {
1512 #[inline]
1513 pub fn span(&self) -> &Span {
1514 &self.span
1515 }
1516}
1517
1518impl<'a> SassInterpolatedStrElement<'a> {
1519 #[inline]
1520 pub fn span(&self) -> &Span {
1521 match self {
1522 Self::Expression(value) => value.span(),
1523 Self::Static(value) => value.span(),
1524 }
1525 }
1526}
1527
1528impl<'a> SassInterpolatedUrl<'a> {
1529 #[inline]
1530 pub fn span(&self) -> &Span {
1531 &self.span
1532 }
1533}
1534
1535impl<'a> SassInterpolatedUrlElement<'a> {
1536 #[inline]
1537 pub fn span(&self) -> &Span {
1538 match self {
1539 Self::Expression(value) => value.span(),
1540 Self::Static(value) => value.span(),
1541 }
1542 }
1543}
1544
1545impl<'a> SassKeywordArgument<'a> {
1546 #[inline]
1547 pub fn span(&self) -> &Span {
1548 &self.span
1549 }
1550}
1551
1552impl<'a> SassList<'a> {
1553 #[inline]
1554 pub fn span(&self) -> &Span {
1555 &self.span
1556 }
1557}
1558
1559impl<'a> SassMap<'a> {
1560 #[inline]
1561 pub fn span(&self) -> &Span {
1562 &self.span
1563 }
1564}
1565
1566impl<'a> SassMapItem<'a> {
1567 #[inline]
1568 pub fn span(&self) -> &Span {
1569 &self.span
1570 }
1571}
1572
1573impl<'a> SassMixin<'a> {
1574 #[inline]
1575 pub fn span(&self) -> &Span {
1576 &self.span
1577 }
1578}
1579
1580impl<'a> SassModuleConfig<'a> {
1581 #[inline]
1582 pub fn span(&self) -> &Span {
1583 &self.span
1584 }
1585}
1586
1587impl<'a> SassModuleConfigItem<'a> {
1588 #[inline]
1589 pub fn span(&self) -> &Span {
1590 &self.span
1591 }
1592}
1593
1594impl<'a> SassModuleMemberName<'a> {
1595 #[inline]
1596 pub fn span(&self) -> &Span {
1597 match self {
1598 Self::Ident(value) => value.span(),
1599 Self::Variable(value) => value.span(),
1600 }
1601 }
1602}
1603
1604impl<'a> SassNestingDeclaration<'a> {
1605 #[inline]
1606 pub fn span(&self) -> &Span {
1607 &self.span
1608 }
1609}
1610
1611impl<'a> SassParameter<'a> {
1612 #[inline]
1613 pub fn span(&self) -> &Span {
1614 &self.span
1615 }
1616}
1617
1618impl<'a> SassParameterDefaultValue<'a> {
1619 #[inline]
1620 pub fn span(&self) -> &Span {
1621 &self.span
1622 }
1623}
1624
1625impl<'a> SassParameters<'a> {
1626 #[inline]
1627 pub fn span(&self) -> &Span {
1628 &self.span
1629 }
1630}
1631
1632impl<'a> SassParenthesizedExpression<'a> {
1633 #[inline]
1634 pub fn span(&self) -> &Span {
1635 &self.span
1636 }
1637}
1638
1639impl<'a> SassPlaceholderSelector<'a> {
1640 #[inline]
1641 pub fn span(&self) -> &Span {
1642 &self.span
1643 }
1644}
1645
1646impl<'a> SassQualifiedName<'a> {
1647 #[inline]
1648 pub fn span(&self) -> &Span {
1649 &self.span
1650 }
1651}
1652
1653impl<'a> SassUnaryExpression<'a> {
1654 #[inline]
1655 pub fn span(&self) -> &Span {
1656 &self.span
1657 }
1658}
1659
1660impl SassUnnamedNamespace {
1661 #[inline]
1662 pub fn span(&self) -> &Span {
1663 &self.span
1664 }
1665}
1666
1667impl<'a> SassUse<'a> {
1668 #[inline]
1669 pub fn span(&self) -> &Span {
1670 &self.span
1671 }
1672}
1673
1674impl<'a> SassUseNamespace<'a> {
1675 #[inline]
1676 pub fn span(&self) -> &Span {
1677 &self.span
1678 }
1679}
1680
1681impl<'a> SassUseNamespaceKind<'a> {
1682 #[inline]
1683 pub fn span(&self) -> &Span {
1684 match self {
1685 Self::Named(value) => value.span(),
1686 Self::Unnamed(value) => value.span(),
1687 }
1688 }
1689}
1690
1691impl<'a> SassVariable<'a> {
1692 #[inline]
1693 pub fn span(&self) -> &Span {
1694 &self.span
1695 }
1696}
1697
1698impl<'a> SassVariableDeclaration<'a> {
1699 #[inline]
1700 pub fn span(&self) -> &Span {
1701 &self.span
1702 }
1703}
1704
1705impl<'a> ScopeEnd<'a> {
1706 #[inline]
1707 pub fn span(&self) -> &Span {
1708 &self.span
1709 }
1710}
1711
1712impl<'a> ScopePrelude<'a> {
1713 #[inline]
1714 pub fn span(&self) -> &Span {
1715 match self {
1716 Self::StartOnly(value) => value.span(),
1717 Self::EndOnly(value) => value.span(),
1718 Self::Both(value) => value.span(),
1719 }
1720 }
1721}
1722
1723impl<'a> ScopeStart<'a> {
1724 #[inline]
1725 pub fn span(&self) -> &Span {
1726 &self.span
1727 }
1728}
1729
1730impl<'a> ScopeStartWithEnd<'a> {
1731 #[inline]
1732 pub fn span(&self) -> &Span {
1733 &self.span
1734 }
1735}
1736
1737impl<'a> SelectorList<'a> {
1738 #[inline]
1739 pub fn span(&self) -> &Span {
1740 &self.span
1741 }
1742}
1743
1744impl<'a> SimpleBlock<'a> {
1745 #[inline]
1746 pub fn span(&self) -> &Span {
1747 &self.span
1748 }
1749}
1750
1751impl<'a> SimpleSelector<'a> {
1752 #[inline]
1753 pub fn span(&self) -> &Span {
1754 match self {
1755 Self::Class(value) => &value.span,
1756 Self::Id(value) => value.span(),
1757 Self::Type(value) => value.span(),
1758 Self::Attribute(value) => value.span(),
1759 Self::PseudoClass(value) => value.span(),
1760 Self::PseudoElement(value) => value.span(),
1761 Self::Nesting(value) => value.span(),
1762 Self::SassPlaceholder(value) => value.span(),
1763 }
1764 }
1765}
1766
1767impl<'a> Statement<'a> {
1768 #[inline]
1769 pub fn span(&self) -> &Span {
1770 match self {
1771 Self::AtRule(value) => value.span(),
1772 Self::Declaration(value) => value.span(),
1773 Self::KeyframeBlock(value) => value.span(),
1774 Self::LessConditionalQualifiedRule(value) => value.span(),
1775 Self::LessExtendRule(value) => value.span(),
1776 Self::LessFunctionCall(value) => value.span(),
1777 Self::LessMixinCall(value) => value.span(),
1778 Self::LessMixinDefinition(value) => value.span(),
1779 Self::LessVariableCall(value) => value.span(),
1780 Self::LessVariableDeclaration(value) => value.span(),
1781 Self::Placeholder(value) => &value.span,
1782 Self::PostcssSimpleVarDeclaration(value) => value.span(),
1783 Self::QualifiedRule(value) => value.span(),
1784 Self::SassIfAtRule(value) => value.span(),
1785 Self::SassVariableDeclaration(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> UnknownSassAtRule<'a> {
1990 #[inline]
1991 pub fn span(&self) -> &Span {
1992 &self.span
1993 }
1994}
1995
1996impl<'a> UnquotedFontFamilyName<'a> {
1997 #[inline]
1998 pub fn span(&self) -> &Span {
1999 &self.span
2000 }
2001}
2002
2003impl<'a> Url<'a> {
2004 #[inline]
2005 pub fn span(&self) -> &Span {
2006 &self.span
2007 }
2008}
2009
2010impl<'a> UrlModifier<'a> {
2011 #[inline]
2012 pub fn span(&self) -> &Span {
2013 match self {
2014 Self::Ident(value) => value.span(),
2015 Self::Function(value) => value.span(),
2016 }
2017 }
2018}
2019
2020impl<'a> UrlValue<'a> {
2021 #[inline]
2022 pub fn span(&self) -> &Span {
2023 match self {
2024 Self::Raw(value) => &value.span,
2025 Self::SassInterpolated(value) => value.span(),
2026 Self::Str(value) => value.span(),
2027 Self::LessEscapedStr(value) => value.span(),
2028 }
2029 }
2030}
2031
2032impl<'a> WqName<'a> {
2033 #[inline]
2034 pub fn span(&self) -> &Span {
2035 &self.span
2036 }
2037}