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 }
472 }
473}
474
475impl<'a> KeyframesName<'a> {
476 #[inline]
477 pub fn span(&self) -> &Span {
478 match self {
479 Self::Ident(value) => value.span(),
480 Self::Str(value) => value.span(),
481 Self::LessVariable(value) => value.span(),
482 Self::LessEscapedStr(value) => value.span(),
483 }
484 }
485}
486
487impl<'a> LanguageRange<'a> {
488 #[inline]
489 pub fn span(&self) -> &Span {
490 match self {
491 Self::Str(value) => value.span(),
492 Self::Ident(value) => value.span(),
493 }
494 }
495}
496
497impl<'a> LanguageRangeList<'a> {
498 #[inline]
499 pub fn span(&self) -> &Span {
500 &self.span
501 }
502}
503
504impl<'a> LayerName<'a> {
505 #[inline]
506 pub fn span(&self) -> &Span {
507 &self.span
508 }
509}
510
511impl<'a> LayerNames<'a> {
512 #[inline]
513 pub fn span(&self) -> &Span {
514 &self.span
515 }
516}
517
518impl<'a> LessBinaryCondition<'a> {
519 #[inline]
520 pub fn span(&self) -> &Span {
521 &self.span
522 }
523}
524
525impl<'a> LessBinaryOperation<'a> {
526 #[inline]
527 pub fn span(&self) -> &Span {
528 &self.span
529 }
530}
531
532impl<'a> LessCondition<'a> {
533 #[inline]
534 pub fn span(&self) -> &Span {
535 match self {
536 Self::Binary(value) => value.span(),
537 Self::Negated(value) => value.span(),
538 Self::Parenthesized(value) => value.span(),
539 Self::Value(value) => value.span(),
540 }
541 }
542}
543
544impl<'a> LessAnonymousMixin<'a> {
545 #[inline]
546 pub fn span(&self) -> &Span {
547 &self.span
548 }
549}
550
551impl<'a> LessConditionalQualifiedRule<'a> {
552 #[inline]
553 pub fn span(&self) -> &Span {
554 &self.span
555 }
556}
557
558impl<'a> LessConditions<'a> {
559 #[inline]
560 pub fn span(&self) -> &Span {
561 &self.span
562 }
563}
564
565impl<'a> LessDetachedRuleset<'a> {
566 #[inline]
567 pub fn span(&self) -> &Span {
568 &self.span
569 }
570}
571
572impl<'a> LessEscapedStr<'a> {
573 #[inline]
574 pub fn span(&self) -> &Span {
575 &self.span
576 }
577}
578
579impl<'a> LessExtend<'a> {
580 #[inline]
581 pub fn span(&self) -> &Span {
582 &self.span
583 }
584}
585
586impl<'a> LessExtendList<'a> {
587 #[inline]
588 pub fn span(&self) -> &Span {
589 &self.span
590 }
591}
592
593impl<'a> LessExtendRule<'a> {
594 #[inline]
595 pub fn span(&self) -> &Span {
596 &self.span
597 }
598}
599
600impl<'a> LessImportOptions<'a> {
601 #[inline]
602 pub fn span(&self) -> &Span {
603 &self.span
604 }
605}
606
607impl<'a> LessImportPrelude<'a> {
608 #[inline]
609 pub fn span(&self) -> &Span {
610 &self.span
611 }
612}
613
614impl<'a> LessInterpolatedIdent<'a> {
615 #[inline]
616 pub fn span(&self) -> &Span {
617 &self.span
618 }
619}
620
621impl<'a> LessInterpolatedIdentElement<'a> {
622 #[inline]
623 pub fn span(&self) -> &Span {
624 match self {
625 Self::Variable(value) => value.span(),
626 Self::Property(value) => value.span(),
627 Self::Static(value) => value.span(),
628 }
629 }
630}
631
632impl<'a> LessInterpolatedStr<'a> {
633 #[inline]
634 pub fn span(&self) -> &Span {
635 &self.span
636 }
637}
638
639impl<'a> LessInterpolatedStrElement<'a> {
640 #[inline]
641 pub fn span(&self) -> &Span {
642 match self {
643 Self::Variable(value) => value.span(),
644 Self::Property(value) => value.span(),
645 Self::Static(value) => value.span(),
646 }
647 }
648}
649
650impl<'a> LessJavaScriptSnippet<'a> {
651 #[inline]
652 pub fn span(&self) -> &Span {
653 &self.span
654 }
655}
656
657impl<'a> LessList<'a> {
658 #[inline]
659 pub fn span(&self) -> &Span {
660 &self.span
661 }
662}
663
664impl<'a> LessLookup<'a> {
665 #[inline]
666 pub fn span(&self) -> &Span {
667 &self.span
668 }
669}
670
671impl<'a> LessLookupName<'a> {
672 #[inline]
673 pub fn span(&self) -> &Span {
674 match self {
675 Self::LessVariable(value) => value.span(),
676 Self::LessVariableVariable(value) => value.span(),
677 Self::LessPropertyVariable(value) => value.span(),
678 Self::LessPropertyInterpolation(value) => value.span(),
679 Self::Ident(value) => value.span(),
680 }
681 }
682}
683
684impl<'a> LessLookups<'a> {
685 #[inline]
686 pub fn span(&self) -> &Span {
687 &self.span
688 }
689}
690
691impl<'a> LessMixinArgument<'a> {
692 #[inline]
693 pub fn span(&self) -> &Span {
694 match self {
695 Self::Named(value) => value.span(),
696 Self::Value(value) => value.span(),
697 Self::Variadic(value) => value.span(),
698 }
699 }
700}
701
702impl<'a> LessMixinArguments<'a> {
703 #[inline]
704 pub fn span(&self) -> &Span {
705 &self.span
706 }
707}
708
709impl<'a> LessMixinCall<'a> {
710 #[inline]
711 pub fn span(&self) -> &Span {
712 &self.span
713 }
714}
715
716impl<'a> LessMixinCallee<'a> {
717 #[inline]
718 pub fn span(&self) -> &Span {
719 &self.span
720 }
721}
722
723impl<'a> LessMixinCalleeChild<'a> {
724 #[inline]
725 pub fn span(&self) -> &Span {
726 &self.span
727 }
728}
729
730impl<'a> LessMixinDefinition<'a> {
731 #[inline]
732 pub fn span(&self) -> &Span {
733 &self.span
734 }
735}
736
737impl<'a> LessMixinName<'a> {
738 #[inline]
739 pub fn span(&self) -> &Span {
740 match self {
741 Self::ClassSelector(value) => &value.span,
742 Self::IdSelector(value) => value.span(),
743 }
744 }
745}
746
747impl<'a> LessMixinNamedArgument<'a> {
748 #[inline]
749 pub fn span(&self) -> &Span {
750 &self.span
751 }
752}
753
754impl<'a> LessMixinNamedParameter<'a> {
755 #[inline]
756 pub fn span(&self) -> &Span {
757 &self.span
758 }
759}
760
761impl<'a> LessMixinNamedParameterDefaultValue<'a> {
762 #[inline]
763 pub fn span(&self) -> &Span {
764 &self.span
765 }
766}
767
768impl<'a> LessMixinParameter<'a> {
769 #[inline]
770 pub fn span(&self) -> &Span {
771 match self {
772 Self::Named(value) => value.span(),
773 Self::Unnamed(value) => value.span(),
774 Self::Variadic(value) => value.span(),
775 }
776 }
777}
778
779impl<'a> LessMixinParameters<'a> {
780 #[inline]
781 pub fn span(&self) -> &Span {
782 &self.span
783 }
784}
785
786impl<'a> LessMixinParameterName<'a> {
787 #[inline]
788 pub fn span(&self) -> &Span {
789 match self {
790 Self::Variable(value) => value.span(),
791 Self::PropertyVariable(value) => value.span(),
792 }
793 }
794}
795
796impl<'a> LessMixinUnnamedParameter<'a> {
797 #[inline]
798 pub fn span(&self) -> &Span {
799 &self.span
800 }
801}
802
803impl<'a> LessMixinVariadicArgument<'a> {
804 #[inline]
805 pub fn span(&self) -> &Span {
806 &self.span
807 }
808}
809
810impl<'a> LessMixinVariadicParameter<'a> {
811 #[inline]
812 pub fn span(&self) -> &Span {
813 &self.span
814 }
815}
816
817impl<'a> LessNamespaceValue<'a> {
818 #[inline]
819 pub fn span(&self) -> &Span {
820 &self.span
821 }
822}
823
824impl<'a> LessNamespaceValueCallee<'a> {
825 #[inline]
826 pub fn span(&self) -> &Span {
827 match self {
828 Self::LessMixinCall(value) => value.span(),
829 Self::LessVariable(value) => value.span(),
830 }
831 }
832}
833
834impl<'a> LessNegatedCondition<'a> {
835 #[inline]
836 pub fn span(&self) -> &Span {
837 &self.span
838 }
839}
840
841impl<'a> LessNegativeValue<'a> {
842 #[inline]
843 pub fn span(&self) -> &Span {
844 &self.span
845 }
846}
847
848impl<'a> LessParenthesizedCondition<'a> {
849 #[inline]
850 pub fn span(&self) -> &Span {
851 &self.span
852 }
853}
854
855impl<'a> LessParenthesizedOperation<'a> {
856 #[inline]
857 pub fn span(&self) -> &Span {
858 &self.span
859 }
860}
861
862impl<'a> LessPlugin<'a> {
863 #[inline]
864 pub fn span(&self) -> &Span {
865 &self.span
866 }
867}
868
869impl<'a> LessPluginPath<'a> {
870 #[inline]
871 pub fn span(&self) -> &Span {
872 match self {
873 Self::Str(value) => value.span(),
874 Self::Url(value) => value.span(),
875 }
876 }
877}
878
879impl<'a> LessPropertyInterpolation<'a> {
880 #[inline]
881 pub fn span(&self) -> &Span {
882 &self.span
883 }
884}
885
886impl LessPropertyMerge {
887 #[inline]
888 pub fn span(&self) -> &Span {
889 &self.span
890 }
891}
892
893impl<'a> LessPropertyVariable<'a> {
894 #[inline]
895 pub fn span(&self) -> &Span {
896 &self.span
897 }
898}
899
900impl<'a> LessVariable<'a> {
901 #[inline]
902 pub fn span(&self) -> &Span {
903 &self.span
904 }
905}
906
907impl<'a> LessVariableCall<'a> {
908 #[inline]
909 pub fn span(&self) -> &Span {
910 &self.span
911 }
912}
913
914impl<'a> LessVariableDeclaration<'a> {
915 #[inline]
916 pub fn span(&self) -> &Span {
917 &self.span
918 }
919}
920
921impl<'a> LessVariableInterpolation<'a> {
922 #[inline]
923 pub fn span(&self) -> &Span {
924 &self.span
925 }
926}
927
928impl<'a> LessVariableVariable<'a> {
929 #[inline]
930 pub fn span(&self) -> &Span {
931 &self.span
932 }
933}
934
935impl<'a> MediaAnd<'a> {
936 #[inline]
937 pub fn span(&self) -> &Span {
938 &self.span
939 }
940}
941
942impl<'a> MediaCondition<'a> {
943 #[inline]
944 pub fn span(&self) -> &Span {
945 &self.span
946 }
947}
948
949impl<'a> MediaConditionAfterMediaType<'a> {
950 #[inline]
951 pub fn span(&self) -> &Span {
952 &self.span
953 }
954}
955
956impl<'a> MediaConditionKind<'a> {
957 #[inline]
958 pub fn span(&self) -> &Span {
959 match self {
960 Self::MediaInParens(value) => value.span(),
961 Self::And(value) => value.span(),
962 Self::Or(value) => value.span(),
963 Self::Not(value) => value.span(),
964 }
965 }
966}
967
968impl<'a> MediaFeature<'a> {
969 #[inline]
970 pub fn span(&self) -> &Span {
971 match self {
972 Self::Plain(value) => value.span(),
973 Self::Boolean(value) => value.span(),
974 Self::Range(value) => value.span(),
975 Self::RangeInterval(value) => value.span(),
976 }
977 }
978}
979
980impl<'a> MediaFeatureName<'a> {
981 #[inline]
982 pub fn span(&self) -> &Span {
983 match self {
984 Self::Ident(value) => value.span(),
985 Self::PostcssSimpleVar(value) => value.span(),
986 Self::SassVariable(value) => value.span(),
987 }
988 }
989}
990
991impl<'a> MediaFeatureBoolean<'a> {
992 #[inline]
993 pub fn span(&self) -> &Span {
994 &self.span
995 }
996}
997
998impl<'a> MediaFeaturePlain<'a> {
999 #[inline]
1000 pub fn span(&self) -> &Span {
1001 &self.span
1002 }
1003}
1004
1005impl<'a> MediaFeatureRange<'a> {
1006 #[inline]
1007 pub fn span(&self) -> &Span {
1008 &self.span
1009 }
1010}
1011
1012impl<'a> MediaFeatureRangeInterval<'a> {
1013 #[inline]
1014 pub fn span(&self) -> &Span {
1015 &self.span
1016 }
1017}
1018
1019impl<'a> MediaInParens<'a> {
1020 #[inline]
1021 pub fn span(&self) -> &Span {
1022 &self.span
1023 }
1024}
1025
1026impl<'a> MediaInParensKind<'a> {
1027 #[inline]
1028 pub fn span(&self) -> &Span {
1029 match self {
1030 Self::MediaCondition(value) => value.span(),
1031 Self::MediaFeature(value) => value.span(),
1032 Self::GeneralEnclosed(value) => value.span(),
1033 Self::SassInterpolation(value) => value.span(),
1034 }
1035 }
1036}
1037
1038impl<'a> MediaNot<'a> {
1039 #[inline]
1040 pub fn span(&self) -> &Span {
1041 &self.span
1042 }
1043}
1044
1045impl<'a> MediaOr<'a> {
1046 #[inline]
1047 pub fn span(&self) -> &Span {
1048 &self.span
1049 }
1050}
1051
1052impl<'a> MediaQuery<'a> {
1053 #[inline]
1054 pub fn span(&self) -> &Span {
1055 match self {
1056 Self::ConditionOnly(value) => value.span(),
1057 Self::WithType(value) => value.span(),
1058 Self::Function(value) => value.span(),
1059 Self::LessVariable(value) => value.span(),
1060 Self::LessNamespaceValue(value) => value.span(),
1061 }
1062 }
1063}
1064
1065impl<'a> MediaQueryList<'a> {
1066 #[inline]
1067 pub fn span(&self) -> &Span {
1068 &self.span
1069 }
1070}
1071
1072impl<'a> MediaQueryWithType<'a> {
1073 #[inline]
1074 pub fn span(&self) -> &Span {
1075 &self.span
1076 }
1077}
1078
1079impl<'a> NamespacePrelude<'a> {
1080 #[inline]
1081 pub fn span(&self) -> &Span {
1082 &self.span
1083 }
1084}
1085
1086impl<'a> NamespacePreludeUri<'a> {
1087 #[inline]
1088 pub fn span(&self) -> &Span {
1089 match self {
1090 Self::Str(value) => value.span(),
1091 Self::Url(value) => value.span(),
1092 }
1093 }
1094}
1095
1096impl<'a> NestingSelector<'a> {
1097 #[inline]
1098 pub fn span(&self) -> &Span {
1099 &self.span
1100 }
1101}
1102
1103impl<'a> NsPrefix<'a> {
1104 #[inline]
1105 pub fn span(&self) -> &Span {
1106 &self.span
1107 }
1108}
1109
1110impl<'a> NsPrefixKind<'a> {
1111 #[inline]
1112 pub fn span(&self) -> &Span {
1113 match self {
1114 Self::Ident(value) => value.span(),
1115 Self::Universal(value) => value.span(),
1116 }
1117 }
1118}
1119
1120impl NsPrefixUniversal {
1121 #[inline]
1122 pub fn span(&self) -> &Span {
1123 &self.span
1124 }
1125}
1126
1127impl<'a> Nth<'a> {
1128 #[inline]
1129 pub fn span(&self) -> &Span {
1130 &self.span
1131 }
1132}
1133
1134impl<'a> NthIndex<'a> {
1135 #[inline]
1136 pub fn span(&self) -> &Span {
1137 match self {
1138 Self::Odd(value) => value.span(),
1139 Self::Even(value) => value.span(),
1140 Self::Integer(value) => value.span(),
1141 Self::AnPlusB(value) => &value.span,
1142 }
1143 }
1144}
1145
1146impl<'a> Number<'a> {
1147 #[inline]
1148 pub fn span(&self) -> &Span {
1149 &self.span
1150 }
1151}
1152
1153impl<'a> PageSelector<'a> {
1154 #[inline]
1155 pub fn span(&self) -> &Span {
1156 &self.span
1157 }
1158}
1159
1160impl<'a> PageSelectorList<'a> {
1161 #[inline]
1162 pub fn span(&self) -> &Span {
1163 &self.span
1164 }
1165}
1166
1167impl<'a> Percentage<'a> {
1168 #[inline]
1169 pub fn span(&self) -> &Span {
1170 &self.span
1171 }
1172}
1173
1174impl<'a> PostcssSimpleVar<'a> {
1175 #[inline]
1176 pub fn span(&self) -> &Span {
1177 &self.span
1178 }
1179}
1180
1181impl<'a> PostcssSimpleVarDeclaration<'a> {
1182 #[inline]
1183 pub fn span(&self) -> &Span {
1184 &self.span
1185 }
1186}
1187
1188impl<'a> PseudoClassSelector<'a> {
1189 #[inline]
1190 pub fn span(&self) -> &Span {
1191 &self.span
1192 }
1193}
1194
1195impl<'a> PseudoClassSelectorArg<'a> {
1196 #[inline]
1197 pub fn span(&self) -> &Span {
1198 &self.span
1199 }
1200}
1201
1202impl<'a> PseudoClassSelectorArgKind<'a> {
1203 #[inline]
1204 pub fn span(&self) -> &Span {
1205 match self {
1206 Self::CompoundSelector(value) => value.span(),
1207 Self::CompoundSelectorList(value) => value.span(),
1208 Self::Ident(value) => value.span(),
1209 Self::LanguageRangeList(value) => value.span(),
1210 Self::Nth(value) => value.span(),
1211 Self::Number(value) => value.span(),
1212 Self::RelativeSelectorList(value) => value.span(),
1213 Self::SelectorList(value) => value.span(),
1214 Self::LessExtendList(value) => value.span(),
1215 Self::TokenSeq(value) => value.span(),
1216 }
1217 }
1218}
1219
1220impl<'a> PseudoElementSelector<'a> {
1221 #[inline]
1222 pub fn span(&self) -> &Span {
1223 &self.span
1224 }
1225}
1226
1227impl<'a> PseudoElementSelectorArg<'a> {
1228 #[inline]
1229 pub fn span(&self) -> &Span {
1230 &self.span
1231 }
1232}
1233
1234impl<'a> PseudoElementSelectorArgKind<'a> {
1235 #[inline]
1236 pub fn span(&self) -> &Span {
1237 match self {
1238 Self::CompoundSelector(value) => value.span(),
1239 Self::CompoundSelectorList(value) => value.span(),
1240 Self::Ident(value) => value.span(),
1241 Self::TokenSeq(value) => value.span(),
1242 }
1243 }
1244}
1245
1246impl<'a> PseudoPage<'a> {
1247 #[inline]
1248 pub fn span(&self) -> &Span {
1249 &self.span
1250 }
1251}
1252
1253impl<'a> QualifiedRule<'a> {
1254 #[inline]
1255 pub fn span(&self) -> &Span {
1256 &self.span
1257 }
1258}
1259
1260impl<'a> QueryInParens<'a> {
1261 #[inline]
1262 pub fn span(&self) -> &Span {
1263 &self.span
1264 }
1265}
1266
1267impl<'a> QueryInParensKind<'a> {
1268 #[inline]
1269 pub fn span(&self) -> &Span {
1270 match self {
1271 Self::ContainerCondition(value) => value.span(),
1272 Self::SizeFeature(value) => value.span(),
1273 Self::StyleQuery(value) => value.span(),
1274 Self::ScrollState(value) => value.span(),
1275 }
1276 }
1277}
1278
1279impl<'a> Ratio<'a> {
1280 #[inline]
1281 pub fn span(&self) -> &Span {
1282 &self.span
1283 }
1284}
1285
1286impl<'a> RelativeSelector<'a> {
1287 #[inline]
1288 pub fn span(&self) -> &Span {
1289 &self.span
1290 }
1291}
1292
1293impl<'a> RelativeSelectorList<'a> {
1294 #[inline]
1295 pub fn span(&self) -> &Span {
1296 &self.span
1297 }
1298}
1299
1300impl<'a> SassArbitraryArgument<'a> {
1301 #[inline]
1302 pub fn span(&self) -> &Span {
1303 &self.span
1304 }
1305}
1306
1307impl<'a> SassArbitraryParameter<'a> {
1308 #[inline]
1309 pub fn span(&self) -> &Span {
1310 &self.span
1311 }
1312}
1313
1314impl<'a> SassAtRoot<'a> {
1315 #[inline]
1316 pub fn span(&self) -> &Span {
1317 &self.span
1318 }
1319}
1320
1321impl<'a> SassAtRootKind<'a> {
1322 #[inline]
1323 pub fn span(&self) -> &Span {
1324 match self {
1325 Self::Selector(value) => value.span(),
1326 Self::Query(value) => value.span(),
1327 }
1328 }
1329}
1330
1331impl<'a> SassAtRootQuery<'a> {
1332 #[inline]
1333 pub fn span(&self) -> &Span {
1334 &self.span
1335 }
1336}
1337
1338impl<'a> SassAtRootQueryRule<'a> {
1339 #[inline]
1340 pub fn span(&self) -> &Span {
1341 match self {
1342 Self::Ident(value) => value.span(),
1343 Self::Str(value) => value.span(),
1344 }
1345 }
1346}
1347
1348impl<'a> SassBinaryExpression<'a> {
1349 #[inline]
1350 pub fn span(&self) -> &Span {
1351 &self.span
1352 }
1353}
1354
1355impl<'a> SassConditionalClause<'a> {
1356 #[inline]
1357 pub fn span(&self) -> &Span {
1358 &self.span
1359 }
1360}
1361
1362impl<'a> SassContent<'a> {
1363 #[inline]
1364 pub fn span(&self) -> &Span {
1365 &self.span
1366 }
1367}
1368
1369impl<'a> SassEach<'a> {
1370 #[inline]
1371 pub fn span(&self) -> &Span {
1372 &self.span
1373 }
1374}
1375
1376impl<'a> SassExtend<'a> {
1377 #[inline]
1378 pub fn span(&self) -> &Span {
1379 &self.span
1380 }
1381}
1382
1383impl<'a> SassFlag<'a> {
1384 #[inline]
1385 pub fn span(&self) -> &Span {
1386 &self.span
1387 }
1388}
1389
1390impl<'a> SassFor<'a> {
1391 #[inline]
1392 pub fn span(&self) -> &Span {
1393 &self.span
1394 }
1395}
1396
1397impl SassForBoundary {
1398 #[inline]
1399 pub fn span(&self) -> &Span {
1400 &self.span
1401 }
1402}
1403
1404impl<'a> SassForward<'a> {
1405 #[inline]
1406 pub fn span(&self) -> &Span {
1407 &self.span
1408 }
1409}
1410
1411impl<'a> SassForwardMember<'a> {
1412 #[inline]
1413 pub fn span(&self) -> &Span {
1414 match self {
1415 Self::Ident(value) => value.span(),
1416 Self::Variable(value) => value.span(),
1417 }
1418 }
1419}
1420
1421impl<'a> SassForwardPrefix<'a> {
1422 #[inline]
1423 pub fn span(&self) -> &Span {
1424 &self.span
1425 }
1426}
1427
1428impl<'a> SassForwardVisibility<'a> {
1429 #[inline]
1430 pub fn span(&self) -> &Span {
1431 &self.span
1432 }
1433}
1434
1435impl<'a> SassFunction<'a> {
1436 #[inline]
1437 pub fn span(&self) -> &Span {
1438 &self.span
1439 }
1440}
1441
1442impl<'a> SassIfAtRule<'a> {
1443 #[inline]
1444 pub fn span(&self) -> &Span {
1445 &self.span
1446 }
1447}
1448
1449impl<'a> SassImportPrelude<'a> {
1450 #[inline]
1451 pub fn span(&self) -> &Span {
1452 &self.span
1453 }
1454}
1455
1456impl<'a> SassInclude<'a> {
1457 #[inline]
1458 pub fn span(&self) -> &Span {
1459 &self.span
1460 }
1461}
1462
1463impl<'a> SassIncludeArgs<'a> {
1464 #[inline]
1465 pub fn span(&self) -> &Span {
1466 &self.span
1467 }
1468}
1469
1470impl<'a> SassIncludeContentBlockParams<'a> {
1471 #[inline]
1472 pub fn span(&self) -> &Span {
1473 &self.span
1474 }
1475}
1476
1477impl<'a> SassInterpolatedIdent<'a> {
1478 #[inline]
1479 pub fn span(&self) -> &Span {
1480 &self.span
1481 }
1482}
1483
1484impl<'a> SassInterpolatedIdentElement<'a> {
1485 #[inline]
1486 pub fn span(&self) -> &Span {
1487 match self {
1488 Self::Expression(value) => value.span(),
1489 Self::Static(value) => value.span(),
1490 }
1491 }
1492}
1493
1494impl<'a> SassInterpolatedStr<'a> {
1495 #[inline]
1496 pub fn span(&self) -> &Span {
1497 &self.span
1498 }
1499}
1500
1501impl<'a> SassInterpolatedStrElement<'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> SassInterpolatedUrl<'a> {
1512 #[inline]
1513 pub fn span(&self) -> &Span {
1514 &self.span
1515 }
1516}
1517
1518impl<'a> SassInterpolatedUrlElement<'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> SassKeywordArgument<'a> {
1529 #[inline]
1530 pub fn span(&self) -> &Span {
1531 &self.span
1532 }
1533}
1534
1535impl<'a> SassList<'a> {
1536 #[inline]
1537 pub fn span(&self) -> &Span {
1538 &self.span
1539 }
1540}
1541
1542impl<'a> SassMap<'a> {
1543 #[inline]
1544 pub fn span(&self) -> &Span {
1545 &self.span
1546 }
1547}
1548
1549impl<'a> SassMapItem<'a> {
1550 #[inline]
1551 pub fn span(&self) -> &Span {
1552 &self.span
1553 }
1554}
1555
1556impl<'a> SassMixin<'a> {
1557 #[inline]
1558 pub fn span(&self) -> &Span {
1559 &self.span
1560 }
1561}
1562
1563impl<'a> SassModuleConfig<'a> {
1564 #[inline]
1565 pub fn span(&self) -> &Span {
1566 &self.span
1567 }
1568}
1569
1570impl<'a> SassModuleConfigItem<'a> {
1571 #[inline]
1572 pub fn span(&self) -> &Span {
1573 &self.span
1574 }
1575}
1576
1577impl<'a> SassModuleMemberName<'a> {
1578 #[inline]
1579 pub fn span(&self) -> &Span {
1580 match self {
1581 Self::Ident(value) => value.span(),
1582 Self::Variable(value) => value.span(),
1583 }
1584 }
1585}
1586
1587impl<'a> SassNestingDeclaration<'a> {
1588 #[inline]
1589 pub fn span(&self) -> &Span {
1590 &self.span
1591 }
1592}
1593
1594impl<'a> SassParameter<'a> {
1595 #[inline]
1596 pub fn span(&self) -> &Span {
1597 &self.span
1598 }
1599}
1600
1601impl<'a> SassParameterDefaultValue<'a> {
1602 #[inline]
1603 pub fn span(&self) -> &Span {
1604 &self.span
1605 }
1606}
1607
1608impl<'a> SassParameters<'a> {
1609 #[inline]
1610 pub fn span(&self) -> &Span {
1611 &self.span
1612 }
1613}
1614
1615impl<'a> SassParenthesizedExpression<'a> {
1616 #[inline]
1617 pub fn span(&self) -> &Span {
1618 &self.span
1619 }
1620}
1621
1622impl<'a> SassPlaceholderSelector<'a> {
1623 #[inline]
1624 pub fn span(&self) -> &Span {
1625 &self.span
1626 }
1627}
1628
1629impl<'a> SassQualifiedName<'a> {
1630 #[inline]
1631 pub fn span(&self) -> &Span {
1632 &self.span
1633 }
1634}
1635
1636impl<'a> SassUnaryExpression<'a> {
1637 #[inline]
1638 pub fn span(&self) -> &Span {
1639 &self.span
1640 }
1641}
1642
1643impl SassUnnamedNamespace {
1644 #[inline]
1645 pub fn span(&self) -> &Span {
1646 &self.span
1647 }
1648}
1649
1650impl<'a> SassUse<'a> {
1651 #[inline]
1652 pub fn span(&self) -> &Span {
1653 &self.span
1654 }
1655}
1656
1657impl<'a> SassUseNamespace<'a> {
1658 #[inline]
1659 pub fn span(&self) -> &Span {
1660 &self.span
1661 }
1662}
1663
1664impl<'a> SassUseNamespaceKind<'a> {
1665 #[inline]
1666 pub fn span(&self) -> &Span {
1667 match self {
1668 Self::Named(value) => value.span(),
1669 Self::Unnamed(value) => value.span(),
1670 }
1671 }
1672}
1673
1674impl<'a> SassVariable<'a> {
1675 #[inline]
1676 pub fn span(&self) -> &Span {
1677 &self.span
1678 }
1679}
1680
1681impl<'a> SassVariableDeclaration<'a> {
1682 #[inline]
1683 pub fn span(&self) -> &Span {
1684 &self.span
1685 }
1686}
1687
1688impl<'a> ScopeEnd<'a> {
1689 #[inline]
1690 pub fn span(&self) -> &Span {
1691 &self.span
1692 }
1693}
1694
1695impl<'a> ScopePrelude<'a> {
1696 #[inline]
1697 pub fn span(&self) -> &Span {
1698 match self {
1699 Self::StartOnly(value) => value.span(),
1700 Self::EndOnly(value) => value.span(),
1701 Self::Both(value) => value.span(),
1702 }
1703 }
1704}
1705
1706impl<'a> ScopeStart<'a> {
1707 #[inline]
1708 pub fn span(&self) -> &Span {
1709 &self.span
1710 }
1711}
1712
1713impl<'a> ScopeStartWithEnd<'a> {
1714 #[inline]
1715 pub fn span(&self) -> &Span {
1716 &self.span
1717 }
1718}
1719
1720impl<'a> SelectorList<'a> {
1721 #[inline]
1722 pub fn span(&self) -> &Span {
1723 &self.span
1724 }
1725}
1726
1727impl<'a> SimpleBlock<'a> {
1728 #[inline]
1729 pub fn span(&self) -> &Span {
1730 &self.span
1731 }
1732}
1733
1734impl<'a> SimpleSelector<'a> {
1735 #[inline]
1736 pub fn span(&self) -> &Span {
1737 match self {
1738 Self::Class(value) => &value.span,
1739 Self::Id(value) => value.span(),
1740 Self::Type(value) => value.span(),
1741 Self::Attribute(value) => value.span(),
1742 Self::PseudoClass(value) => value.span(),
1743 Self::PseudoElement(value) => value.span(),
1744 Self::Nesting(value) => value.span(),
1745 Self::SassPlaceholder(value) => value.span(),
1746 }
1747 }
1748}
1749
1750impl<'a> Statement<'a> {
1751 #[inline]
1752 pub fn span(&self) -> &Span {
1753 match self {
1754 Self::AtRule(value) => value.span(),
1755 Self::Declaration(value) => value.span(),
1756 Self::KeyframeBlock(value) => value.span(),
1757 Self::LessConditionalQualifiedRule(value) => value.span(),
1758 Self::LessExtendRule(value) => value.span(),
1759 Self::LessFunctionCall(value) => value.span(),
1760 Self::LessMixinCall(value) => value.span(),
1761 Self::LessMixinDefinition(value) => value.span(),
1762 Self::LessVariableCall(value) => value.span(),
1763 Self::LessVariableDeclaration(value) => value.span(),
1764 Self::Placeholder(value) => &value.span,
1765 Self::PostcssSimpleVarDeclaration(value) => value.span(),
1766 Self::QualifiedRule(value) => value.span(),
1767 Self::SassIfAtRule(value) => value.span(),
1768 Self::SassVariableDeclaration(value) => value.span(),
1769 Self::UnknownSassAtRule(value) => value.span(),
1770 }
1771 }
1772}
1773
1774impl<'a> Str<'a> {
1775 #[inline]
1776 pub fn span(&self) -> &Span {
1777 &self.span
1778 }
1779}
1780
1781impl<'a> StyleCondition<'a> {
1782 #[inline]
1783 pub fn span(&self) -> &Span {
1784 &self.span
1785 }
1786}
1787
1788impl<'a> StyleConditionKind<'a> {
1789 #[inline]
1790 pub fn span(&self) -> &Span {
1791 match self {
1792 Self::StyleInParens(value) => value.span(),
1793 Self::And(value) => value.span(),
1794 Self::Or(value) => value.span(),
1795 Self::Not(value) => value.span(),
1796 }
1797 }
1798}
1799
1800impl<'a> StyleConditionAnd<'a> {
1801 #[inline]
1802 pub fn span(&self) -> &Span {
1803 &self.span
1804 }
1805}
1806
1807impl<'a> StyleConditionNot<'a> {
1808 #[inline]
1809 pub fn span(&self) -> &Span {
1810 &self.span
1811 }
1812}
1813
1814impl<'a> StyleConditionOr<'a> {
1815 #[inline]
1816 pub fn span(&self) -> &Span {
1817 &self.span
1818 }
1819}
1820
1821impl<'a> StyleInParens<'a> {
1822 #[inline]
1823 pub fn span(&self) -> &Span {
1824 &self.span
1825 }
1826}
1827
1828impl<'a> StyleInParensKind<'a> {
1829 #[inline]
1830 pub fn span(&self) -> &Span {
1831 match self {
1832 Self::Condition(value) => value.span(),
1833 Self::Feature(value) => value.span(),
1834 }
1835 }
1836}
1837
1838impl<'a> StyleQuery<'a> {
1839 #[inline]
1840 pub fn span(&self) -> &Span {
1841 match self {
1842 Self::Condition(value) => value.span(),
1843 Self::Feature(value) => value.span(),
1844 Self::FeatureName(value) => value.span(),
1845 }
1846 }
1847}
1848
1849impl<'a> Stylesheet<'a> {
1850 #[inline]
1851 pub fn span(&self) -> &Span {
1852 &self.span
1853 }
1854}
1855
1856impl<'a> SupportsAnd<'a> {
1857 #[inline]
1858 pub fn span(&self) -> &Span {
1859 &self.span
1860 }
1861}
1862
1863impl<'a> SupportsCondition<'a> {
1864 #[inline]
1865 pub fn span(&self) -> &Span {
1866 &self.span
1867 }
1868}
1869
1870impl<'a> SupportsConditionKind<'a> {
1871 #[inline]
1872 pub fn span(&self) -> &Span {
1873 match self {
1874 Self::Not(value) => value.span(),
1875 Self::And(value) => value.span(),
1876 Self::Or(value) => value.span(),
1877 Self::SupportsInParens(value) => value.span(),
1878 }
1879 }
1880}
1881
1882impl<'a> SupportsDecl<'a> {
1883 #[inline]
1884 pub fn span(&self) -> &Span {
1885 &self.span
1886 }
1887}
1888
1889impl<'a> SupportsInParens<'a> {
1890 #[inline]
1891 pub fn span(&self) -> &Span {
1892 &self.span
1893 }
1894}
1895
1896impl<'a> SupportsInParensKind<'a> {
1897 #[inline]
1898 pub fn span(&self) -> &Span {
1899 match self {
1900 Self::SupportsCondition(value) => value.span(),
1901 Self::Feature(value) => value.span(),
1902 Self::Selector(value) => value.span(),
1903 Self::Function(value) => value.span(),
1904 Self::GeneralEnclosed(value) => value.span(),
1905 Self::Interpolation(value) => value.span(),
1906 }
1907 }
1908}
1909
1910impl<'a> SupportsNot<'a> {
1911 #[inline]
1912 pub fn span(&self) -> &Span {
1913 &self.span
1914 }
1915}
1916
1917impl<'a> SupportsOr<'a> {
1918 #[inline]
1919 pub fn span(&self) -> &Span {
1920 &self.span
1921 }
1922}
1923
1924impl<'a> TagNameSelector<'a> {
1925 #[inline]
1926 pub fn span(&self) -> &Span {
1927 &self.span
1928 }
1929}
1930
1931impl<'a> TokenSeq<'a> {
1932 #[inline]
1933 pub fn span(&self) -> &Span {
1934 &self.span
1935 }
1936}
1937
1938impl<'a> TypeSelector<'a> {
1939 #[inline]
1940 pub fn span(&self) -> &Span {
1941 match self {
1942 Self::TagName(value) => value.span(),
1943 Self::Universal(value) => value.span(),
1944 }
1945 }
1946}
1947
1948impl<'a> UnicodeRange<'a> {
1949 #[inline]
1950 pub fn span(&self) -> &Span {
1951 &self.span
1952 }
1953}
1954
1955impl<'a> UniversalSelector<'a> {
1956 #[inline]
1957 pub fn span(&self) -> &Span {
1958 &self.span
1959 }
1960}
1961
1962impl<'a> UnknownAtRulePrelude<'a> {
1963 #[inline]
1964 pub fn span(&self) -> &Span {
1965 match self {
1966 Self::ComponentValue(value) => value.span(),
1967 Self::TokenSeq(value) => value.span(),
1968 }
1969 }
1970}
1971
1972impl<'a> UnknownSassAtRule<'a> {
1973 #[inline]
1974 pub fn span(&self) -> &Span {
1975 &self.span
1976 }
1977}
1978
1979impl<'a> UnquotedFontFamilyName<'a> {
1980 #[inline]
1981 pub fn span(&self) -> &Span {
1982 &self.span
1983 }
1984}
1985
1986impl<'a> Url<'a> {
1987 #[inline]
1988 pub fn span(&self) -> &Span {
1989 &self.span
1990 }
1991}
1992
1993impl<'a> UrlModifier<'a> {
1994 #[inline]
1995 pub fn span(&self) -> &Span {
1996 match self {
1997 Self::Ident(value) => value.span(),
1998 Self::Function(value) => value.span(),
1999 }
2000 }
2001}
2002
2003impl<'a> UrlValue<'a> {
2004 #[inline]
2005 pub fn span(&self) -> &Span {
2006 match self {
2007 Self::Raw(value) => &value.span,
2008 Self::SassInterpolated(value) => value.span(),
2009 Self::Str(value) => value.span(),
2010 Self::LessEscapedStr(value) => value.span(),
2011 }
2012 }
2013}
2014
2015impl<'a> WqName<'a> {
2016 #[inline]
2017 pub fn span(&self) -> &Span {
2018 &self.span
2019 }
2020}