Skip to main content

oxc_css_parser/
ast.rs

1//! All kinds of AST nodes are here.
2
3use crate::{pos::Span, tokenizer::TokenWithSpan};
4use oxc_allocator::{Box, Vec};
5#[cfg(feature = "serialize")]
6use serde::Serialize;
7
8#[derive(Debug)]
9#[cfg_attr(feature = "serialize", derive(Serialize))]
10#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
11pub struct AnPlusB {
12    pub a: i32,
13    pub b: i32,
14    pub span: Span,
15}
16
17#[derive(Debug)]
18#[cfg_attr(feature = "serialize", derive(Serialize))]
19#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
20pub struct AtRule<'a> {
21    pub name: Ident<'a>,
22    pub prelude: Option<AtRulePrelude<'a>>,
23    pub block: Option<SimpleBlock<'a>>,
24    pub span: Span,
25}
26
27#[derive(Debug)]
28#[cfg_attr(feature = "serialize", derive(Serialize))]
29#[cfg_attr(feature = "serialize", serde(untagged))]
30pub enum AtRulePrelude<'a> {
31    Charset(Str<'a>),
32    ColorProfile(ColorProfilePrelude<'a>),
33    Container(ContainerPrelude<'a>),
34    CounterStyle(InterpolableIdent<'a>),
35    CustomMedia(Box<'a, CustomMedia<'a>>),
36    CustomSelector(Box<'a, CustomSelectorPrelude<'a>>),
37    Document(DocumentPrelude<'a>),
38    FontFeatureValues(FontFamilyName<'a>),
39    FontPaletteValues(InterpolableIdent<'a>),
40    Import(Box<'a, ImportPrelude<'a>>),
41    Keyframes(KeyframesName<'a>),
42    Layer(LayerNames<'a>),
43    LessImport(Box<'a, LessImportPrelude<'a>>),
44    LessPlugin(Box<'a, LessPlugin<'a>>),
45    Media(MediaQueryList<'a>),
46    Namespace(Box<'a, NamespacePrelude<'a>>),
47    Nest(SelectorList<'a>),
48    Page(PageSelectorList<'a>),
49    PositionTry(InterpolableIdent<'a>),
50    Property(InterpolableIdent<'a>),
51    SassAtRoot(SassAtRoot<'a>),
52    SassContent(SassContent<'a>),
53    SassEach(Box<'a, SassEach<'a>>),
54    SassExpr(Box<'a, ComponentValue<'a>>),
55    SassExtend(Box<'a, SassExtend<'a>>),
56    SassFor(Box<'a, SassFor<'a>>),
57    SassForward(Box<'a, SassForward<'a>>),
58    SassFunction(Box<'a, SassFunction<'a>>),
59    SassImport(SassImportPrelude<'a>),
60    SassInclude(Box<'a, SassInclude<'a>>),
61    SassMixin(Box<'a, SassMixin<'a>>),
62    SassUse(Box<'a, SassUse<'a>>),
63    Scope(Box<'a, ScopePrelude<'a>>),
64    ScrollTimeline(InterpolableIdent<'a>),
65    Supports(SupportsCondition<'a>),
66    Unknown(Box<'a, UnknownAtRulePrelude<'a>>),
67}
68
69#[derive(Debug)]
70#[cfg_attr(feature = "serialize", derive(Serialize))]
71#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
72pub struct AttributeSelector<'a> {
73    pub name: WqName<'a>,
74    pub matcher: Option<AttributeSelectorMatcher>,
75    pub value: Option<AttributeSelectorValue<'a>>,
76    pub modifier: Option<AttributeSelectorModifier<'a>>,
77    pub span: Span,
78}
79
80#[derive(Debug)]
81#[cfg_attr(feature = "serialize", derive(Serialize))]
82#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
83pub struct AttributeSelectorMatcher {
84    pub kind: AttributeSelectorMatcherKind,
85    pub span: Span,
86}
87
88#[derive(Debug)]
89#[cfg_attr(feature = "serialize", derive(Serialize))]
90pub enum AttributeSelectorMatcherKind {
91    /// `=`
92    Exact,
93    /// `~=`
94    MatchWord,
95    /// `|=`
96    ExactOrPrefixThenHyphen,
97    /// `^=`
98    Prefix,
99    /// `$=`
100    Suffix,
101    /// `*=`
102    Substring,
103}
104
105#[derive(Debug)]
106#[cfg_attr(feature = "serialize", derive(Serialize))]
107#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
108pub struct AttributeSelectorModifier<'a> {
109    pub ident: InterpolableIdent<'a>,
110    pub span: Span,
111}
112
113#[derive(Debug)]
114#[cfg_attr(feature = "serialize", derive(Serialize))]
115#[cfg_attr(feature = "serialize", serde(untagged))]
116pub enum AttributeSelectorValue<'a> {
117    Ident(InterpolableIdent<'a>),
118    Str(InterpolableStr<'a>),
119    Number(Number<'a>),
120    Dimension(Dimension<'a>),
121    Percentage(Percentage<'a>),
122    LessEscapedStr(LessEscapedStr<'a>),
123}
124
125#[derive(Debug)]
126#[cfg_attr(feature = "serialize", derive(Serialize))]
127#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
128pub struct BracketBlock<'a> {
129    pub value: Vec<'a, ComponentValue<'a>>,
130    pub span: Span,
131}
132
133#[derive(Debug)]
134#[cfg_attr(feature = "serialize", derive(Serialize))]
135#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
136pub struct Calc<'a> {
137    pub left: Box<'a, ComponentValue<'a>>,
138    pub op: CalcOperator,
139    pub right: Box<'a, ComponentValue<'a>>,
140    pub span: Span,
141}
142
143#[derive(Debug)]
144#[cfg_attr(feature = "serialize", derive(Serialize))]
145#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
146pub struct CalcOperator {
147    pub kind: CalcOperatorKind,
148    pub span: Span,
149}
150
151#[derive(Debug)]
152#[cfg_attr(feature = "serialize", derive(Serialize))]
153pub enum CalcOperatorKind {
154    Plus,
155    Minus,
156    Multiply,
157    Division,
158}
159
160#[derive(Debug)]
161#[cfg_attr(feature = "serialize", derive(Serialize))]
162#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
163pub struct ClassSelector<'a> {
164    pub name: InterpolableIdent<'a>,
165    pub span: Span,
166}
167
168#[derive(Debug)]
169#[cfg_attr(feature = "serialize", derive(Serialize))]
170#[cfg_attr(feature = "serialize", serde(untagged))]
171pub enum ColorProfilePrelude<'a> {
172    DashedIdent(InterpolableIdent<'a>),
173    DeviceCmyk(Ident<'a>),
174}
175
176#[derive(Debug)]
177#[cfg_attr(feature = "serialize", derive(Serialize))]
178#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
179pub struct Combinator {
180    pub kind: CombinatorKind,
181    pub span: Span,
182}
183
184#[derive(Debug, PartialEq, Eq)]
185#[cfg_attr(feature = "serialize", derive(Serialize))]
186pub enum CombinatorKind {
187    /// ` `
188    Descendant,
189    /// `+`
190    NextSibling,
191    /// `>`
192    Child,
193    /// `~`
194    LaterSibling,
195    /// `||`
196    Column,
197}
198
199#[derive(Debug)]
200#[cfg_attr(feature = "serialize", derive(Serialize))]
201#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
202pub struct ComplexSelector<'a> {
203    pub children: Vec<'a, ComplexSelectorChild<'a>>,
204    pub span: Span,
205}
206
207#[derive(Debug)]
208#[cfg_attr(feature = "serialize", derive(Serialize))]
209#[cfg_attr(feature = "serialize", serde(untagged))]
210pub enum ComplexSelectorChild<'a> {
211    CompoundSelector(CompoundSelector<'a>),
212    Combinator(Combinator),
213}
214
215#[derive(Debug)]
216#[cfg_attr(feature = "serialize", derive(Serialize))]
217#[cfg_attr(feature = "serialize", serde(untagged))]
218pub enum ComponentValue<'a> {
219    BracketBlock(BracketBlock<'a>),
220    Calc(Calc<'a>),
221    Delimiter(Delimiter),
222    Dimension(Dimension<'a>),
223    Function(Function<'a>),
224    HexColor(HexColor<'a>),
225    IdSelector(IdSelector<'a>),
226    ImportantAnnotation(ImportantAnnotation<'a>),
227    InterpolableIdent(InterpolableIdent<'a>),
228    InterpolableStr(InterpolableStr<'a>),
229    LayerName(LayerName<'a>),
230    LessBinaryOperation(LessBinaryOperation<'a>),
231    LessCondition(Box<'a, LessCondition<'a>>),
232    LessDetachedRuleset(LessDetachedRuleset<'a>),
233    LessEscapedStr(LessEscapedStr<'a>),
234    LessJavaScriptSnippet(LessJavaScriptSnippet<'a>),
235    LessList(LessList<'a>),
236    LessMixinCall(Box<'a, LessMixinCall<'a>>),
237    LessNamespaceValue(Box<'a, LessNamespaceValue<'a>>),
238    LessNegativeValue(LessNegativeValue<'a>),
239    LessParenthesizedOperation(LessParenthesizedOperation<'a>),
240    LessPercentKeyword(LessPercentKeyword),
241    LessPropertyVariable(LessPropertyVariable<'a>),
242    LessVariable(LessVariable<'a>),
243    LessVariableVariable(LessVariableVariable<'a>),
244    Number(Number<'a>),
245    Percentage(Percentage<'a>),
246    Placeholder(Placeholder<'a>),
247    PostcssSimpleVar(PostcssSimpleVar<'a>),
248    Ratio(Ratio<'a>),
249    SassArbitraryArgument(SassArbitraryArgument<'a>),
250    SassBinaryExpression(SassBinaryExpression<'a>),
251    SassKeywordArgument(SassKeywordArgument<'a>),
252    SassList(SassList<'a>),
253    SassMap(SassMap<'a>),
254    SassQualifiedName(Box<'a, SassQualifiedName<'a>>),
255    SassNestingDeclaration(SassNestingDeclaration<'a>),
256    SassParenthesizedExpression(SassParenthesizedExpression<'a>),
257    SassParentSelector(NestingSelector<'a>),
258    SassUnaryExpression(SassUnaryExpression<'a>),
259    SassVariable(SassVariable<'a>),
260    TokenWithSpan(TokenWithSpan<'a>),
261    UnicodeRange(UnicodeRange<'a>),
262    Url(Box<'a, Url<'a>>),
263}
264
265#[derive(Debug)]
266#[cfg_attr(feature = "serialize", derive(Serialize))]
267#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
268pub struct ComponentValues<'a> {
269    pub values: Vec<'a, ComponentValue<'a>>,
270    pub span: Span,
271}
272
273#[derive(Debug)]
274#[cfg_attr(feature = "serialize", derive(Serialize))]
275#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
276pub struct CompoundSelector<'a> {
277    pub children: Vec<'a, SimpleSelector<'a>>,
278    pub span: Span,
279}
280
281#[derive(Debug)]
282#[cfg_attr(feature = "serialize", derive(Serialize))]
283#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
284pub struct CompoundSelectorList<'a> {
285    pub selectors: Vec<'a, CompoundSelector<'a>>,
286    pub comma_spans: Vec<'a, Span>,
287    pub span: Span,
288}
289
290#[derive(Debug)]
291#[cfg_attr(feature = "serialize", derive(Serialize))]
292#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
293pub struct ContainerCondition<'a> {
294    pub conditions: Vec<'a, ContainerConditionKind<'a>>,
295    pub span: Span,
296}
297
298#[derive(Debug)]
299#[cfg_attr(feature = "serialize", derive(Serialize))]
300#[cfg_attr(feature = "serialize", serde(untagged))]
301pub enum ContainerConditionKind<'a> {
302    QueryInParens(QueryInParens<'a>),
303    And(ContainerConditionAnd<'a>),
304    Or(ContainerConditionOr<'a>),
305    Not(ContainerConditionNot<'a>),
306}
307
308#[derive(Debug)]
309#[cfg_attr(feature = "serialize", derive(Serialize))]
310#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
311pub struct ContainerConditionAnd<'a> {
312    pub keyword: Ident<'a>,
313    pub query_in_parens: QueryInParens<'a>,
314    pub span: Span,
315}
316
317#[derive(Debug)]
318#[cfg_attr(feature = "serialize", derive(Serialize))]
319#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
320pub struct ContainerConditionNot<'a> {
321    pub keyword: Ident<'a>,
322    pub query_in_parens: QueryInParens<'a>,
323    pub span: Span,
324}
325
326#[derive(Debug)]
327#[cfg_attr(feature = "serialize", derive(Serialize))]
328#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
329pub struct ContainerConditionOr<'a> {
330    pub keyword: Ident<'a>,
331    pub query_in_parens: QueryInParens<'a>,
332    pub span: Span,
333}
334
335#[derive(Debug)]
336#[cfg_attr(feature = "serialize", derive(Serialize))]
337#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
338pub struct ContainerPrelude<'a> {
339    pub name: Option<InterpolableIdent<'a>>,
340    pub condition: ContainerCondition<'a>,
341    pub span: Span,
342}
343
344#[derive(Debug)]
345#[cfg_attr(feature = "serialize", derive(Serialize))]
346#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
347pub struct CustomMedia<'a> {
348    pub name: InterpolableIdent<'a>,
349    pub value: CustomMediaValue<'a>,
350    pub span: Span,
351}
352
353#[derive(Debug)]
354#[cfg_attr(feature = "serialize", derive(Serialize))]
355#[cfg_attr(feature = "serialize", serde(untagged))]
356pub enum CustomMediaValue<'a> {
357    MediaQueryList(MediaQueryList<'a>),
358    True(Ident<'a>),
359    False(Ident<'a>),
360}
361
362#[derive(Debug)]
363#[cfg_attr(feature = "serialize", derive(Serialize))]
364#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
365pub struct CustomSelector<'a> {
366    pub prefix_arg: Option<CustomSelectorArg<'a>>,
367    pub name: Ident<'a>,
368    pub args: Option<CustomSelectorArgs<'a>>,
369    pub span: Span,
370}
371
372#[derive(Debug)]
373#[cfg_attr(feature = "serialize", derive(Serialize))]
374#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
375pub struct CustomSelectorArg<'a> {
376    pub name: Ident<'a>,
377    pub span: Span,
378}
379
380#[derive(Debug)]
381#[cfg_attr(feature = "serialize", derive(Serialize))]
382#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
383pub struct CustomSelectorArgs<'a> {
384    pub args: Vec<'a, CustomSelectorArg<'a>>,
385    pub comma_spans: Vec<'a, Span>,
386    pub span: Span,
387}
388
389#[derive(Debug)]
390#[cfg_attr(feature = "serialize", derive(Serialize))]
391#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
392pub struct CustomSelectorPrelude<'a> {
393    pub custom_selector: CustomSelector<'a>,
394    pub selector: SelectorList<'a>,
395    pub span: Span,
396}
397
398#[derive(Debug)]
399#[cfg_attr(feature = "serialize", derive(Serialize))]
400#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
401pub struct Declaration<'a> {
402    pub name: InterpolableIdent<'a>,
403    pub name_suffix: Option<char>,
404    pub colon_span: Span,
405    pub value: Vec<'a, ComponentValue<'a>>,
406    pub important: Option<ImportantAnnotation<'a>>,
407    pub less_property_merge: Option<LessPropertyMerge>,
408    pub span: Span,
409}
410
411#[derive(Debug)]
412#[cfg_attr(feature = "serialize", derive(Serialize))]
413#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
414pub struct Delimiter {
415    pub kind: DelimiterKind,
416    pub span: Span,
417}
418
419#[derive(Debug)]
420#[cfg_attr(feature = "serialize", derive(Serialize))]
421pub enum DelimiterKind {
422    Comma,
423    Solidus,
424    Semicolon,
425}
426
427#[derive(Debug)]
428#[cfg_attr(feature = "serialize", derive(Serialize))]
429#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
430pub struct Dimension<'a> {
431    pub value: Number<'a>,
432    pub unit: Ident<'a>,
433    pub kind: DimensionKind,
434    pub span: Span,
435}
436
437#[derive(Debug)]
438#[cfg_attr(feature = "serialize", derive(Serialize))]
439pub enum DimensionKind {
440    Length,
441    Angle,
442    Duration,
443    Frequency,
444    Resolution,
445    Flex,
446    Unknown,
447}
448
449#[derive(Debug)]
450#[cfg_attr(feature = "serialize", derive(Serialize))]
451#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
452pub struct DocumentPrelude<'a> {
453    pub matchers: Vec<'a, DocumentPreludeMatcher<'a>>,
454    pub comma_spans: Vec<'a, Span>,
455    pub span: Span,
456}
457
458#[derive(Debug)]
459#[cfg_attr(feature = "serialize", derive(Serialize))]
460#[cfg_attr(feature = "serialize", serde(untagged))]
461pub enum DocumentPreludeMatcher<'a> {
462    Url(Url<'a>),
463    Function(Function<'a>),
464}
465
466#[derive(Debug)]
467#[cfg_attr(feature = "serialize", derive(Serialize))]
468#[cfg_attr(feature = "serialize", serde(untagged))]
469pub enum FontFamilyName<'a> {
470    Str(InterpolableStr<'a>),
471    Unquoted(UnquotedFontFamilyName<'a>),
472}
473
474#[derive(Debug)]
475#[cfg_attr(feature = "serialize", derive(Serialize))]
476#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
477pub struct Function<'a> {
478    pub name: FunctionName<'a>,
479    pub args: Vec<'a, ComponentValue<'a>>,
480    pub span: Span,
481}
482
483#[derive(Debug)]
484#[cfg_attr(feature = "serialize", derive(Serialize))]
485#[cfg_attr(feature = "serialize", serde(untagged))]
486pub enum FunctionName<'a> {
487    Ident(InterpolableIdent<'a>),
488    SassQualifiedName(Box<'a, SassQualifiedName<'a>>),
489    LessListFunction(LessListFunction),
490    LessFormatFunction(LessFormatFunction),
491}
492
493#[derive(Debug)]
494#[cfg_attr(feature = "serialize", derive(Serialize))]
495#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
496pub struct HexColor<'a> {
497    pub value: &'a str,
498    pub raw: &'a str,
499    pub span: Span,
500}
501
502#[derive(Debug)]
503#[cfg_attr(feature = "serialize", derive(Serialize))]
504#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
505pub struct Ident<'a> {
506    pub name: &'a str,
507    pub raw: &'a str,
508    pub span: Span,
509}
510
511#[derive(Debug)]
512#[cfg_attr(feature = "serialize", derive(Serialize))]
513#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
514pub struct ImportPrelude<'a> {
515    pub href: ImportPreludeHref<'a>,
516    pub layer: Option<ImportPreludeLayer<'a>>,
517    pub supports: Option<ImportPreludeSupports<'a>>,
518    pub media: Option<MediaQueryList<'a>>,
519    pub span: Span,
520}
521
522#[derive(Debug)]
523#[cfg_attr(feature = "serialize", derive(Serialize))]
524#[cfg_attr(feature = "serialize", serde(untagged))]
525pub enum ImportPreludeHref<'a> {
526    Str(InterpolableStr<'a>),
527    Url(Url<'a>),
528    /// Sass only: `url(...)` whose content is not a parsable URL but is
529    /// valid SassScript, e.g. `@import url($dir+"/path");`.
530    Function(Function<'a>),
531}
532
533#[derive(Debug)]
534#[cfg_attr(feature = "serialize", derive(Serialize))]
535#[cfg_attr(feature = "serialize", serde(untagged))]
536pub enum ImportPreludeLayer<'a> {
537    Empty(Ident<'a>),
538    WithName(Function<'a>),
539}
540
541#[derive(Debug)]
542#[cfg_attr(feature = "serialize", derive(Serialize))]
543#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
544pub struct ImportPreludeSupports<'a> {
545    pub kind: ImportPreludeSupportsKind<'a>,
546    pub span: Span,
547}
548
549#[derive(Debug)]
550#[cfg_attr(feature = "serialize", derive(Serialize))]
551#[cfg_attr(feature = "serialize", serde(untagged))]
552pub enum ImportPreludeSupportsKind<'a> {
553    SupportsCondition(SupportsCondition<'a>),
554    Declaration(Declaration<'a>),
555}
556
557#[derive(Debug)]
558#[cfg_attr(feature = "serialize", derive(Serialize))]
559#[cfg_attr(feature = "serialize", serde(untagged))]
560pub enum InterpolableIdent<'a> {
561    Literal(Ident<'a>),
562    SassInterpolated(SassInterpolatedIdent<'a>),
563    LessInterpolated(LessInterpolatedIdent<'a>),
564    Placeholder(Placeholder<'a>),
565}
566
567/// An atomic backtick-delimited template placeholder node (see
568/// [`ParserOptions::template_placeholder`](crate::config::ParserOptions)),
569/// carrying the parsed decimal index. Appears in value, selector, and
570/// statement positions where a downstream formatter substitutes interpolations.
571#[derive(Debug)]
572#[cfg_attr(feature = "serialize", derive(Serialize))]
573#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
574pub struct Placeholder<'a> {
575    pub index: u32,
576    /// An ident-continuation run glued directly after the placeholder
577    /// (`` `PLACEHOLDER-0`px `` -> index 0, suffix `"px"`), empty when none.
578    /// Mirrors `#{$x}px` being a single identifier rather than two tokens.
579    pub suffix: &'a str,
580    pub span: Span,
581}
582
583#[derive(Debug)]
584#[cfg_attr(feature = "serialize", derive(Serialize))]
585#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
586pub struct InterpolableIdentStaticPart<'a> {
587    pub value: &'a str,
588    pub raw: &'a str,
589    pub span: Span,
590}
591
592#[derive(Debug)]
593#[cfg_attr(feature = "serialize", derive(Serialize))]
594#[cfg_attr(feature = "serialize", serde(untagged))]
595pub enum InterpolableStr<'a> {
596    Literal(Str<'a>),
597    SassInterpolated(SassInterpolatedStr<'a>),
598    LessInterpolated(LessInterpolatedStr<'a>),
599}
600
601#[derive(Debug)]
602#[cfg_attr(feature = "serialize", derive(Serialize))]
603#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
604pub struct InterpolableStrStaticPart<'a> {
605    pub value: &'a str,
606    pub raw: &'a str,
607    pub span: Span,
608}
609
610#[derive(Debug)]
611#[cfg_attr(feature = "serialize", derive(Serialize))]
612#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
613pub struct InterpolableUrlStaticPart<'a> {
614    pub value: &'a str,
615    pub raw: &'a str,
616    pub span: Span,
617}
618
619#[derive(Debug)]
620#[cfg_attr(feature = "serialize", derive(Serialize))]
621#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
622pub struct IdSelector<'a> {
623    pub name: InterpolableIdent<'a>,
624    pub span: Span,
625}
626
627#[derive(Debug)]
628#[cfg_attr(feature = "serialize", derive(Serialize))]
629#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
630pub struct ImportantAnnotation<'a> {
631    pub ident: Ident<'a>,
632    pub span: Span,
633}
634
635#[derive(Debug)]
636#[cfg_attr(feature = "serialize", derive(Serialize))]
637#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
638pub struct KeyframeBlock<'a> {
639    pub selectors: Vec<'a, KeyframeSelector<'a>>,
640    pub comma_spans: Vec<'a, Span>,
641    pub block: SimpleBlock<'a>,
642    pub span: Span,
643}
644
645#[derive(Debug)]
646#[cfg_attr(feature = "serialize", derive(Serialize))]
647#[cfg_attr(feature = "serialize", serde(untagged))]
648pub enum KeyframeSelector<'a> {
649    Ident(InterpolableIdent<'a>),
650    Percentage(Percentage<'a>),
651}
652
653#[derive(Debug)]
654#[cfg_attr(feature = "serialize", derive(Serialize))]
655#[cfg_attr(feature = "serialize", serde(untagged))]
656pub enum KeyframesName<'a> {
657    Ident(InterpolableIdent<'a>),
658    Str(InterpolableStr<'a>),
659    LessVariable(LessVariable<'a>),
660    LessEscapedStr(LessEscapedStr<'a>),
661}
662
663#[derive(Debug)]
664#[cfg_attr(feature = "serialize", derive(Serialize))]
665#[cfg_attr(feature = "serialize", serde(untagged))]
666pub enum LanguageRange<'a> {
667    Str(InterpolableStr<'a>),
668    Ident(InterpolableIdent<'a>),
669}
670
671#[derive(Debug)]
672#[cfg_attr(feature = "serialize", derive(Serialize))]
673#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
674pub struct LanguageRangeList<'a> {
675    pub ranges: Vec<'a, LanguageRange<'a>>,
676    pub comma_spans: Vec<'a, Span>,
677    pub span: Span,
678}
679
680#[derive(Debug)]
681#[cfg_attr(feature = "serialize", derive(Serialize))]
682#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
683pub struct LayerName<'a> {
684    pub idents: Vec<'a, InterpolableIdent<'a>>,
685    pub span: Span,
686}
687
688#[derive(Debug)]
689#[cfg_attr(feature = "serialize", derive(Serialize))]
690#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
691pub struct LayerNames<'a> {
692    pub names: Vec<'a, LayerName<'a>>,
693    pub comma_spans: Vec<'a, Span>,
694    pub span: Span,
695}
696
697#[derive(Debug)]
698#[cfg_attr(feature = "serialize", derive(Serialize))]
699#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
700pub struct LessBinaryCondition<'a> {
701    pub left: Box<'a, LessCondition<'a>>,
702    pub op: LessBinaryConditionOperator,
703    pub right: Box<'a, LessCondition<'a>>,
704    pub span: Span,
705}
706
707#[derive(Debug)]
708#[cfg_attr(feature = "serialize", derive(Serialize))]
709#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
710pub struct LessBinaryConditionOperator {
711    pub kind: LessBinaryConditionOperatorKind,
712    pub span: Span,
713}
714
715#[derive(Debug)]
716#[cfg_attr(feature = "serialize", derive(Serialize))]
717pub enum LessBinaryConditionOperatorKind {
718    GreaterThan,
719    GreaterThanOrEqual,
720    LessThan,
721    LessThanOrEqual,
722    Equal,
723    EqualOrGreaterThan,
724    EqualOrLessThan,
725    And,
726    Or,
727}
728
729#[derive(Debug)]
730#[cfg_attr(feature = "serialize", derive(Serialize))]
731#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
732pub struct LessBinaryOperation<'a> {
733    pub left: Box<'a, ComponentValue<'a>>,
734    pub op: LessOperationOperator,
735    pub right: Box<'a, ComponentValue<'a>>,
736    pub span: Span,
737}
738
739#[derive(Debug)]
740#[cfg_attr(feature = "serialize", derive(Serialize))]
741#[cfg_attr(feature = "serialize", serde(untagged))]
742pub enum LessCondition<'a> {
743    Binary(LessBinaryCondition<'a>),
744    Negated(LessNegatedCondition<'a>),
745    Parenthesized(LessParenthesizedCondition<'a>),
746    Value(ComponentValue<'a>),
747}
748
749#[derive(Debug)]
750#[cfg_attr(feature = "serialize", derive(Serialize))]
751#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
752pub struct LessConditionalQualifiedRule<'a> {
753    pub selector: SelectorList<'a>,
754    pub guard: LessConditions<'a>,
755    pub block: SimpleBlock<'a>,
756    pub span: Span,
757}
758
759#[derive(Debug)]
760#[cfg_attr(feature = "serialize", derive(Serialize))]
761#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
762pub struct LessConditions<'a> {
763    pub conditions: Vec<'a, LessCondition<'a>>,
764    pub when_span: Span,
765    pub comma_spans: Vec<'a, Span>,
766    pub span: Span,
767}
768
769#[derive(Debug)]
770#[cfg_attr(feature = "serialize", derive(Serialize))]
771#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
772pub struct LessDetachedRuleset<'a> {
773    pub block: SimpleBlock<'a>,
774    pub span: Span,
775}
776
777#[derive(Debug)]
778#[cfg_attr(feature = "serialize", derive(Serialize))]
779#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
780pub struct LessEscapedStr<'a> {
781    pub str: Str<'a>,
782    pub span: Span,
783}
784
785#[derive(Debug)]
786#[cfg_attr(feature = "serialize", derive(Serialize))]
787#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
788pub struct LessExtend<'a> {
789    pub selector: ComplexSelector<'a>,
790    pub all: Option<Ident<'a>>,
791    pub span: Span,
792}
793
794#[derive(Debug)]
795#[cfg_attr(feature = "serialize", derive(Serialize))]
796#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
797pub struct LessExtendList<'a> {
798    pub elements: Vec<'a, LessExtend<'a>>,
799    pub comma_spans: Vec<'a, Span>,
800    pub span: Span,
801}
802
803#[derive(Debug)]
804#[cfg_attr(feature = "serialize", derive(Serialize))]
805#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
806pub struct LessExtendRule<'a> {
807    pub nesting_selector: NestingSelector<'a>,
808    pub name_of_extend: Ident<'a>,
809    pub extend: LessExtendList<'a>,
810    pub span: Span,
811}
812
813#[derive(Debug)]
814#[cfg_attr(feature = "serialize", derive(Serialize))]
815#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
816pub struct LessFormatFunction {
817    pub span: Span,
818}
819
820#[derive(Debug)]
821#[cfg_attr(feature = "serialize", derive(Serialize))]
822#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
823pub struct LessImportOptions<'a> {
824    pub names: Vec<'a, Ident<'a>>,
825    pub comma_spans: Vec<'a, Span>,
826    pub span: Span,
827}
828
829#[derive(Debug)]
830#[cfg_attr(feature = "serialize", derive(Serialize))]
831#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
832pub struct LessImportPrelude<'a> {
833    pub href: ImportPreludeHref<'a>,
834    pub options: LessImportOptions<'a>,
835    pub media: Option<MediaQueryList<'a>>,
836    pub span: Span,
837}
838
839#[derive(Debug)]
840#[cfg_attr(feature = "serialize", derive(Serialize))]
841#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
842pub struct LessInterpolatedIdent<'a> {
843    pub elements: Vec<'a, LessInterpolatedIdentElement<'a>>,
844    pub span: Span,
845}
846
847#[derive(Debug)]
848#[cfg_attr(feature = "serialize", derive(Serialize))]
849#[cfg_attr(feature = "serialize", serde(untagged))]
850pub enum LessInterpolatedIdentElement<'a> {
851    Variable(LessVariableInterpolation<'a>),
852    Property(LessPropertyInterpolation<'a>),
853    Static(InterpolableIdentStaticPart<'a>),
854}
855
856#[derive(Debug)]
857#[cfg_attr(feature = "serialize", derive(Serialize))]
858#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
859pub struct LessInterpolatedStr<'a> {
860    pub elements: Vec<'a, LessInterpolatedStrElement<'a>>,
861    pub span: Span,
862}
863
864#[derive(Debug)]
865#[cfg_attr(feature = "serialize", derive(Serialize))]
866#[cfg_attr(feature = "serialize", serde(untagged))]
867pub enum LessInterpolatedStrElement<'a> {
868    Variable(LessVariableInterpolation<'a>),
869    Property(LessPropertyInterpolation<'a>),
870    Static(InterpolableStrStaticPart<'a>),
871}
872
873#[derive(Debug)]
874#[cfg_attr(feature = "serialize", derive(Serialize))]
875#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
876pub struct LessJavaScriptSnippet<'a> {
877    pub code: &'a str,
878    pub raw: &'a str,
879    pub escaped: bool,
880    pub span: Span,
881}
882
883#[derive(Debug)]
884#[cfg_attr(feature = "serialize", derive(Serialize))]
885#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
886pub struct LessList<'a> {
887    pub elements: Vec<'a, ComponentValue<'a>>,
888    pub comma_spans: Option<Vec<'a, Span>>,
889    pub span: Span,
890}
891
892#[derive(Debug)]
893#[cfg_attr(feature = "serialize", derive(Serialize))]
894#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
895pub struct LessListFunction {
896    pub span: Span,
897}
898
899#[derive(Debug)]
900#[cfg_attr(feature = "serialize", derive(Serialize))]
901#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
902pub struct LessLookup<'a> {
903    pub name: Option<LessLookupName<'a>>,
904    pub span: Span,
905}
906
907#[derive(Debug)]
908#[cfg_attr(feature = "serialize", derive(Serialize))]
909#[cfg_attr(feature = "serialize", serde(untagged))]
910pub enum LessLookupName<'a> {
911    LessVariable(LessVariable<'a>),
912    LessVariableVariable(LessVariableVariable<'a>),
913    LessPropertyVariable(LessPropertyVariable<'a>),
914    Ident(Ident<'a>),
915}
916
917#[derive(Debug)]
918#[cfg_attr(feature = "serialize", derive(Serialize))]
919#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
920pub struct LessLookups<'a> {
921    pub lookups: Vec<'a, LessLookup<'a>>,
922    pub span: Span,
923}
924
925#[derive(Debug)]
926#[cfg_attr(feature = "serialize", derive(Serialize))]
927#[cfg_attr(feature = "serialize", serde(untagged))]
928pub enum LessMixinArgument<'a> {
929    Named(LessMixinNamedArgument<'a>),
930    Value(ComponentValue<'a>),
931    Variadic(LessMixinVariadicArgument<'a>),
932}
933
934#[derive(Debug)]
935#[cfg_attr(feature = "serialize", derive(Serialize))]
936#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
937pub struct LessMixinArguments<'a> {
938    pub args: Vec<'a, LessMixinArgument<'a>>,
939    pub is_comma_separated: bool,
940    pub separator_spans: Vec<'a, Span>,
941    pub span: Span,
942}
943
944#[derive(Debug)]
945#[cfg_attr(feature = "serialize", derive(Serialize))]
946#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
947pub struct LessMixinCall<'a> {
948    pub callee: LessMixinCallee<'a>,
949    pub args: Option<LessMixinArguments<'a>>,
950    pub important: Option<ImportantAnnotation<'a>>,
951    pub span: Span,
952}
953
954#[derive(Debug)]
955#[cfg_attr(feature = "serialize", derive(Serialize))]
956#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
957pub struct LessMixinCallee<'a> {
958    pub children: Vec<'a, LessMixinCalleeChild<'a>>,
959    pub span: Span,
960}
961
962#[derive(Debug)]
963#[cfg_attr(feature = "serialize", derive(Serialize))]
964#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
965pub struct LessMixinCalleeChild<'a> {
966    pub name: LessMixinName<'a>,
967    pub combinator: Option<Combinator>,
968    pub span: Span,
969}
970
971#[derive(Debug)]
972#[cfg_attr(feature = "serialize", derive(Serialize))]
973#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
974pub struct LessMixinDefinition<'a> {
975    pub name: LessMixinName<'a>,
976    pub params: LessMixinParameters<'a>,
977    pub guard: Option<LessConditions<'a>>,
978    pub block: SimpleBlock<'a>,
979    pub span: Span,
980}
981
982#[derive(Debug)]
983#[cfg_attr(feature = "serialize", derive(Serialize))]
984#[cfg_attr(feature = "serialize", serde(untagged))]
985pub enum LessMixinName<'a> {
986    ClassSelector(ClassSelector<'a>),
987    IdSelector(IdSelector<'a>),
988}
989
990#[derive(Debug)]
991#[cfg_attr(feature = "serialize", derive(Serialize))]
992#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
993pub struct LessMixinNamedArgument<'a> {
994    pub name: LessMixinParameterName<'a>,
995    pub colon_span: Span,
996    pub value: ComponentValue<'a>,
997    pub span: Span,
998}
999
1000#[derive(Debug)]
1001#[cfg_attr(feature = "serialize", derive(Serialize))]
1002#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1003pub struct LessMixinNamedParameter<'a> {
1004    pub name: LessMixinParameterName<'a>,
1005    pub value: Option<LessMixinNamedParameterDefaultValue<'a>>,
1006    pub span: Span,
1007}
1008
1009#[derive(Debug)]
1010#[cfg_attr(feature = "serialize", derive(Serialize))]
1011#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1012pub struct LessMixinNamedParameterDefaultValue<'a> {
1013    pub colon_span: Span,
1014    pub value: ComponentValue<'a>,
1015    pub span: Span,
1016}
1017
1018#[derive(Debug)]
1019#[cfg_attr(feature = "serialize", derive(Serialize))]
1020#[cfg_attr(feature = "serialize", serde(untagged))]
1021pub enum LessMixinParameter<'a> {
1022    Named(LessMixinNamedParameter<'a>),
1023    Unnamed(LessMixinUnnamedParameter<'a>),
1024    Variadic(LessMixinVariadicParameter<'a>),
1025}
1026
1027#[derive(Debug)]
1028#[cfg_attr(feature = "serialize", derive(Serialize))]
1029#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1030pub struct LessMixinParameters<'a> {
1031    pub params: Vec<'a, LessMixinParameter<'a>>,
1032    pub is_comma_separated: bool,
1033    pub separator_spans: Vec<'a, Span>,
1034    pub span: Span,
1035}
1036
1037#[derive(Debug)]
1038#[cfg_attr(feature = "serialize", derive(Serialize))]
1039#[cfg_attr(feature = "serialize", serde(untagged))]
1040pub enum LessMixinParameterName<'a> {
1041    Variable(LessVariable<'a>),
1042    PropertyVariable(LessPropertyVariable<'a>),
1043}
1044
1045#[derive(Debug)]
1046#[cfg_attr(feature = "serialize", derive(Serialize))]
1047#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1048pub struct LessMixinUnnamedParameter<'a> {
1049    pub value: ComponentValue<'a>,
1050    pub span: Span,
1051}
1052
1053#[derive(Debug)]
1054#[cfg_attr(feature = "serialize", derive(Serialize))]
1055#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1056pub struct LessMixinVariadicArgument<'a> {
1057    pub name: LessMixinParameterName<'a>,
1058    pub span: Span,
1059}
1060
1061#[derive(Debug)]
1062#[cfg_attr(feature = "serialize", derive(Serialize))]
1063#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1064pub struct LessMixinVariadicParameter<'a> {
1065    pub name: Option<LessMixinParameterName<'a>>,
1066    pub span: Span,
1067}
1068
1069#[derive(Debug)]
1070#[cfg_attr(feature = "serialize", derive(Serialize))]
1071#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1072pub struct LessNamespaceValue<'a> {
1073    pub callee: LessNamespaceValueCallee<'a>,
1074    pub lookups: LessLookups<'a>,
1075    pub span: Span,
1076}
1077
1078#[derive(Debug)]
1079#[cfg_attr(feature = "serialize", derive(Serialize))]
1080#[cfg_attr(feature = "serialize", serde(untagged))]
1081pub enum LessNamespaceValueCallee<'a> {
1082    LessMixinCall(LessMixinCall<'a>),
1083    LessVariable(LessVariable<'a>),
1084}
1085
1086#[derive(Debug)]
1087#[cfg_attr(feature = "serialize", derive(Serialize))]
1088#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1089pub struct LessNegatedCondition<'a> {
1090    pub condition: Box<'a, LessCondition<'a>>,
1091    pub span: Span,
1092}
1093
1094#[derive(Debug)]
1095#[cfg_attr(feature = "serialize", derive(Serialize))]
1096#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1097pub struct LessNegativeValue<'a> {
1098    pub value: Box<'a, ComponentValue<'a>>,
1099    pub span: Span,
1100}
1101
1102#[derive(Debug)]
1103#[cfg_attr(feature = "serialize", derive(Serialize))]
1104#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1105pub struct LessOperationOperator {
1106    pub kind: LessOperationOperatorKind,
1107    pub span: Span,
1108}
1109
1110#[derive(Debug)]
1111#[cfg_attr(feature = "serialize", derive(Serialize))]
1112pub enum LessOperationOperatorKind {
1113    Multiply,
1114    Division,
1115    Plus,
1116    Minus,
1117}
1118
1119#[derive(Debug)]
1120#[cfg_attr(feature = "serialize", derive(Serialize))]
1121#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1122pub struct LessParenthesizedCondition<'a> {
1123    pub condition: Box<'a, LessCondition<'a>>,
1124    pub span: Span,
1125}
1126
1127#[derive(Debug)]
1128#[cfg_attr(feature = "serialize", derive(Serialize))]
1129#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1130pub struct LessParenthesizedOperation<'a> {
1131    pub operation: Box<'a, ComponentValue<'a>>,
1132    pub span: Span,
1133}
1134
1135#[derive(Debug)]
1136#[cfg_attr(feature = "serialize", derive(Serialize))]
1137#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1138pub struct LessPercentKeyword {
1139    pub span: Span,
1140}
1141
1142#[derive(Debug)]
1143#[cfg_attr(feature = "serialize", derive(Serialize))]
1144#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1145pub struct LessPlugin<'a> {
1146    pub path: LessPluginPath<'a>,
1147    pub args: Option<TokenSeq<'a>>,
1148    pub span: Span,
1149}
1150
1151#[derive(Debug)]
1152#[cfg_attr(feature = "serialize", derive(Serialize))]
1153#[cfg_attr(feature = "serialize", serde(untagged))]
1154pub enum LessPluginPath<'a> {
1155    Str(Str<'a>),
1156    Url(Url<'a>),
1157}
1158
1159#[derive(Debug)]
1160#[cfg_attr(feature = "serialize", derive(Serialize))]
1161#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1162pub struct LessPropertyInterpolation<'a> {
1163    pub name: Ident<'a>,
1164    pub span: Span,
1165}
1166
1167#[derive(Debug)]
1168#[cfg_attr(feature = "serialize", derive(Serialize))]
1169#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1170pub struct LessPropertyMerge {
1171    pub kind: LessPropertyMergeKind,
1172    pub span: Span,
1173}
1174
1175#[derive(Debug)]
1176#[cfg_attr(feature = "serialize", derive(Serialize))]
1177pub enum LessPropertyMergeKind {
1178    Comma,
1179    Space,
1180}
1181
1182#[derive(Debug)]
1183#[cfg_attr(feature = "serialize", derive(Serialize))]
1184#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1185pub struct LessPropertyVariable<'a> {
1186    pub name: Ident<'a>,
1187    pub span: Span,
1188}
1189
1190#[derive(Debug)]
1191#[cfg_attr(feature = "serialize", derive(Serialize))]
1192#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1193pub struct LessVariable<'a> {
1194    pub name: Ident<'a>,
1195    pub span: Span,
1196}
1197
1198#[derive(Debug)]
1199#[cfg_attr(feature = "serialize", derive(Serialize))]
1200#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1201pub struct LessVariableCall<'a> {
1202    pub variable: LessVariable<'a>,
1203    pub span: Span,
1204}
1205
1206#[derive(Debug)]
1207#[cfg_attr(feature = "serialize", derive(Serialize))]
1208#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1209pub struct LessVariableDeclaration<'a> {
1210    pub name: LessVariable<'a>,
1211    pub colon_span: Span,
1212    pub value: ComponentValue<'a>,
1213    pub span: Span,
1214}
1215
1216#[derive(Debug)]
1217#[cfg_attr(feature = "serialize", derive(Serialize))]
1218#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1219pub struct LessVariableInterpolation<'a> {
1220    pub name: Ident<'a>,
1221    pub span: Span,
1222}
1223
1224#[derive(Debug)]
1225#[cfg_attr(feature = "serialize", derive(Serialize))]
1226#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1227pub struct LessVariableVariable<'a> {
1228    pub variable: LessVariable<'a>,
1229    pub span: Span,
1230}
1231
1232#[derive(Debug)]
1233#[cfg_attr(feature = "serialize", derive(Serialize))]
1234#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1235pub struct MediaAnd<'a> {
1236    pub keyword: Ident<'a>,
1237    pub media_in_parens: MediaInParens<'a>,
1238    pub span: Span,
1239}
1240
1241#[derive(Debug)]
1242#[cfg_attr(feature = "serialize", derive(Serialize))]
1243#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1244pub struct MediaCondition<'a> {
1245    pub conditions: Vec<'a, MediaConditionKind<'a>>,
1246    pub span: Span,
1247}
1248
1249#[derive(Debug)]
1250#[cfg_attr(feature = "serialize", derive(Serialize))]
1251#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1252pub struct MediaConditionAfterMediaType<'a> {
1253    pub and: Ident<'a>,
1254    pub condition: MediaCondition<'a>,
1255    pub span: Span,
1256}
1257
1258#[derive(Debug)]
1259#[cfg_attr(feature = "serialize", derive(Serialize))]
1260#[cfg_attr(feature = "serialize", serde(untagged))]
1261pub enum MediaConditionKind<'a> {
1262    MediaInParens(MediaInParens<'a>),
1263    And(MediaAnd<'a>),
1264    Or(MediaOr<'a>),
1265    Not(MediaNot<'a>),
1266}
1267
1268#[derive(Debug)]
1269#[cfg_attr(feature = "serialize", derive(Serialize))]
1270#[cfg_attr(feature = "serialize", serde(untagged))]
1271pub enum MediaFeature<'a> {
1272    Plain(MediaFeaturePlain<'a>),
1273    Boolean(MediaFeatureBoolean<'a>),
1274    Range(MediaFeatureRange<'a>),
1275    RangeInterval(MediaFeatureRangeInterval<'a>),
1276}
1277
1278#[derive(Debug)]
1279#[cfg_attr(feature = "serialize", derive(Serialize))]
1280#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1281pub struct MediaFeatureComparison {
1282    pub kind: MediaFeatureComparisonKind,
1283    pub span: Span,
1284}
1285
1286#[derive(Debug)]
1287#[cfg_attr(feature = "serialize", derive(Serialize))]
1288pub enum MediaFeatureComparisonKind {
1289    LessThan,
1290    LessThanOrEqual,
1291    GreaterThan,
1292    GreaterThanOrEqual,
1293    Equal,
1294}
1295
1296#[derive(Debug)]
1297#[cfg_attr(feature = "serialize", derive(Serialize))]
1298#[cfg_attr(feature = "serialize", serde(untagged))]
1299pub enum MediaFeatureName<'a> {
1300    Ident(InterpolableIdent<'a>),
1301    PostcssSimpleVar(PostcssSimpleVar<'a>),
1302    SassVariable(SassVariable<'a>),
1303}
1304
1305#[derive(Debug)]
1306#[cfg_attr(feature = "serialize", derive(Serialize))]
1307#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1308pub struct MediaFeatureBoolean<'a> {
1309    pub name: MediaFeatureName<'a>,
1310    pub span: Span,
1311}
1312
1313#[derive(Debug)]
1314#[cfg_attr(feature = "serialize", derive(Serialize))]
1315#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1316pub struct MediaFeaturePlain<'a> {
1317    pub name: MediaFeatureName<'a>,
1318    pub colon_span: Span,
1319    pub value: ComponentValue<'a>,
1320    pub span: Span,
1321}
1322
1323#[derive(Debug)]
1324#[cfg_attr(feature = "serialize", derive(Serialize))]
1325#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1326pub struct MediaFeatureRange<'a> {
1327    pub left: ComponentValue<'a>,
1328    pub comparison: MediaFeatureComparison,
1329    pub right: ComponentValue<'a>,
1330    pub span: Span,
1331}
1332
1333#[derive(Debug)]
1334#[cfg_attr(feature = "serialize", derive(Serialize))]
1335#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1336pub struct MediaFeatureRangeInterval<'a> {
1337    pub left: ComponentValue<'a>,
1338    pub left_comparison: MediaFeatureComparison,
1339    pub name: MediaFeatureName<'a>,
1340    pub right_comparison: MediaFeatureComparison,
1341    pub right: ComponentValue<'a>,
1342    pub span: Span,
1343}
1344
1345#[derive(Debug)]
1346#[cfg_attr(feature = "serialize", derive(Serialize))]
1347#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1348pub struct MediaInParens<'a> {
1349    pub kind: MediaInParensKind<'a>,
1350    pub span: Span,
1351}
1352
1353#[derive(Debug)]
1354#[cfg_attr(feature = "serialize", derive(Serialize))]
1355#[cfg_attr(feature = "serialize", serde(untagged))]
1356pub enum MediaInParensKind<'a> {
1357    MediaCondition(MediaCondition<'a>),
1358    MediaFeature(Box<'a, MediaFeature<'a>>),
1359    GeneralEnclosed(TokenSeq<'a>),
1360    SassInterpolation(SassInterpolatedIdent<'a>),
1361}
1362
1363#[derive(Debug)]
1364#[cfg_attr(feature = "serialize", derive(Serialize))]
1365#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1366pub struct MediaNot<'a> {
1367    pub keyword: Ident<'a>,
1368    pub media_in_parens: MediaInParens<'a>,
1369    pub span: Span,
1370}
1371
1372#[derive(Debug)]
1373#[cfg_attr(feature = "serialize", derive(Serialize))]
1374#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1375pub struct MediaOr<'a> {
1376    pub keyword: Ident<'a>,
1377    pub media_in_parens: MediaInParens<'a>,
1378    pub span: Span,
1379}
1380
1381#[derive(Debug)]
1382#[cfg_attr(feature = "serialize", derive(Serialize))]
1383#[cfg_attr(feature = "serialize", serde(untagged))]
1384pub enum MediaQuery<'a> {
1385    ConditionOnly(MediaCondition<'a>),
1386    WithType(MediaQueryWithType<'a>),
1387    Function(Function<'a>),
1388    LessVariable(LessVariable<'a>),
1389    LessNamespaceValue(Box<'a, LessNamespaceValue<'a>>),
1390}
1391
1392#[derive(Debug)]
1393#[cfg_attr(feature = "serialize", derive(Serialize))]
1394#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1395pub struct MediaQueryList<'a> {
1396    pub queries: Vec<'a, MediaQuery<'a>>,
1397    pub comma_spans: Vec<'a, Span>,
1398    pub span: Span,
1399}
1400
1401#[derive(Debug)]
1402#[cfg_attr(feature = "serialize", derive(Serialize))]
1403#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1404pub struct MediaQueryWithType<'a> {
1405    pub modifier: Option<Ident<'a>>,
1406    pub media_type: InterpolableIdent<'a>,
1407    pub condition: Option<MediaConditionAfterMediaType<'a>>,
1408    pub span: Span,
1409}
1410
1411#[derive(Debug)]
1412#[cfg_attr(feature = "serialize", derive(Serialize))]
1413#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1414pub struct NamespacePrelude<'a> {
1415    pub prefix: Option<InterpolableIdent<'a>>,
1416    pub uri: NamespacePreludeUri<'a>,
1417    pub span: Span,
1418}
1419
1420#[derive(Debug)]
1421#[cfg_attr(feature = "serialize", derive(Serialize))]
1422#[cfg_attr(feature = "serialize", serde(untagged))]
1423pub enum NamespacePreludeUri<'a> {
1424    Str(InterpolableStr<'a>),
1425    Url(Url<'a>),
1426}
1427
1428#[derive(Debug)]
1429#[cfg_attr(feature = "serialize", derive(Serialize))]
1430#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1431pub struct NestingSelector<'a> {
1432    pub suffix: Option<InterpolableIdent<'a>>,
1433    pub span: Span,
1434}
1435
1436#[derive(Debug)]
1437#[cfg_attr(feature = "serialize", derive(Serialize))]
1438#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1439pub struct NsPrefix<'a> {
1440    pub kind: Option<NsPrefixKind<'a>>,
1441    pub span: Span,
1442}
1443
1444#[derive(Debug)]
1445#[cfg_attr(feature = "serialize", derive(Serialize))]
1446#[cfg_attr(feature = "serialize", serde(untagged))]
1447pub enum NsPrefixKind<'a> {
1448    Ident(InterpolableIdent<'a>),
1449    Universal(NsPrefixUniversal),
1450}
1451
1452#[derive(Debug)]
1453#[cfg_attr(feature = "serialize", derive(Serialize))]
1454#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1455pub struct NsPrefixUniversal {
1456    pub span: Span,
1457}
1458
1459#[derive(Debug)]
1460#[cfg_attr(feature = "serialize", derive(Serialize))]
1461#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1462pub struct Nth<'a> {
1463    pub index: NthIndex<'a>,
1464    pub matcher: Option<NthMatcher<'a>>,
1465    pub span: Span,
1466}
1467
1468#[derive(Debug)]
1469#[cfg_attr(feature = "serialize", derive(Serialize))]
1470#[cfg_attr(feature = "serialize", serde(untagged))]
1471pub enum NthIndex<'a> {
1472    Odd(Ident<'a>),
1473    Even(Ident<'a>),
1474    Integer(Number<'a>),
1475    AnPlusB(AnPlusB),
1476}
1477
1478#[derive(Debug)]
1479#[cfg_attr(feature = "serialize", derive(Serialize))]
1480#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1481pub struct NthMatcher<'a> {
1482    pub selector: Option<SelectorList<'a>>,
1483    pub span: Span,
1484}
1485
1486#[derive(Debug)]
1487#[cfg_attr(feature = "serialize", derive(Serialize))]
1488#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1489pub struct Number<'a> {
1490    pub value: f32,
1491    pub raw: &'a str,
1492    pub span: Span,
1493}
1494
1495#[derive(Debug)]
1496#[cfg_attr(feature = "serialize", derive(Serialize))]
1497#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1498pub struct PageSelector<'a> {
1499    pub name: Option<InterpolableIdent<'a>>,
1500    pub pseudo: Vec<'a, PseudoPage<'a>>,
1501    pub span: Span,
1502}
1503
1504#[derive(Debug)]
1505#[cfg_attr(feature = "serialize", derive(Serialize))]
1506#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1507pub struct PageSelectorList<'a> {
1508    pub selectors: Vec<'a, PageSelector<'a>>,
1509    pub comma_spans: Vec<'a, Span>,
1510    pub span: Span,
1511}
1512
1513#[derive(Debug)]
1514#[cfg_attr(feature = "serialize", derive(Serialize))]
1515#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1516pub struct Percentage<'a> {
1517    pub value: Number<'a>,
1518    pub span: Span,
1519}
1520
1521#[derive(Debug)]
1522#[cfg_attr(feature = "serialize", derive(Serialize))]
1523#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1524pub struct PostcssSimpleVar<'a> {
1525    pub name: Ident<'a>,
1526    pub span: Span,
1527}
1528
1529#[derive(Debug)]
1530#[cfg_attr(feature = "serialize", derive(Serialize))]
1531#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1532pub struct PostcssSimpleVarDeclaration<'a> {
1533    pub name: PostcssSimpleVar<'a>,
1534    pub colon_span: Span,
1535    pub value: Vec<'a, ComponentValue<'a>>,
1536    pub span: Span,
1537}
1538
1539#[derive(Debug)]
1540#[cfg_attr(feature = "serialize", derive(Serialize))]
1541#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1542pub struct PseudoClassSelector<'a> {
1543    pub name: InterpolableIdent<'a>,
1544    pub arg: Option<PseudoClassSelectorArg<'a>>,
1545    pub span: Span,
1546}
1547
1548#[derive(Debug)]
1549#[cfg_attr(feature = "serialize", derive(Serialize))]
1550#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1551pub struct PseudoClassSelectorArg<'a> {
1552    pub kind: PseudoClassSelectorArgKind<'a>,
1553    pub l_paren: Span,
1554    pub r_paren: Span,
1555    pub span: Span,
1556}
1557
1558#[derive(Debug)]
1559#[cfg_attr(feature = "serialize", derive(Serialize))]
1560#[cfg_attr(feature = "serialize", serde(untagged))]
1561pub enum PseudoClassSelectorArgKind<'a> {
1562    CompoundSelector(CompoundSelector<'a>),
1563    CompoundSelectorList(CompoundSelectorList<'a>),
1564    Ident(InterpolableIdent<'a>),
1565    LanguageRangeList(LanguageRangeList<'a>),
1566    Nth(Nth<'a>),
1567    Number(Number<'a>),
1568    RelativeSelectorList(RelativeSelectorList<'a>),
1569    SelectorList(SelectorList<'a>),
1570    LessExtendList(LessExtendList<'a>),
1571    TokenSeq(TokenSeq<'a>),
1572}
1573
1574#[derive(Debug)]
1575#[cfg_attr(feature = "serialize", derive(Serialize))]
1576#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1577pub struct PseudoElementSelector<'a> {
1578    pub name: InterpolableIdent<'a>,
1579    pub arg: Option<PseudoElementSelectorArg<'a>>,
1580    pub span: Span,
1581}
1582
1583#[derive(Debug)]
1584#[cfg_attr(feature = "serialize", derive(Serialize))]
1585#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1586pub struct PseudoElementSelectorArg<'a> {
1587    pub kind: PseudoElementSelectorArgKind<'a>,
1588    pub l_paren: Span,
1589    pub r_paren: Span,
1590    pub span: Span,
1591}
1592
1593#[derive(Debug)]
1594#[cfg_attr(feature = "serialize", derive(Serialize))]
1595#[cfg_attr(feature = "serialize", serde(untagged))]
1596pub enum PseudoElementSelectorArgKind<'a> {
1597    CompoundSelector(CompoundSelector<'a>),
1598    Ident(InterpolableIdent<'a>),
1599    TokenSeq(TokenSeq<'a>),
1600}
1601
1602#[derive(Debug)]
1603#[cfg_attr(feature = "serialize", derive(Serialize))]
1604#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1605pub struct PseudoPage<'a> {
1606    pub name: InterpolableIdent<'a>,
1607    pub span: Span,
1608}
1609
1610#[derive(Debug)]
1611#[cfg_attr(feature = "serialize", derive(Serialize))]
1612#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1613pub struct QualifiedRule<'a> {
1614    pub selector: SelectorList<'a>,
1615    pub block: SimpleBlock<'a>,
1616    pub span: Span,
1617}
1618
1619#[derive(Debug)]
1620#[cfg_attr(feature = "serialize", derive(Serialize))]
1621#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1622pub struct QueryInParens<'a> {
1623    pub kind: QueryInParensKind<'a>,
1624    pub span: Span,
1625}
1626
1627#[derive(Debug)]
1628#[cfg_attr(feature = "serialize", derive(Serialize))]
1629#[cfg_attr(feature = "serialize", serde(untagged))]
1630pub enum QueryInParensKind<'a> {
1631    ContainerCondition(ContainerCondition<'a>),
1632    SizeFeature(Box<'a, MediaFeature<'a>>),
1633    StyleQuery(StyleQuery<'a>),
1634    ScrollState(Box<'a, MediaFeature<'a>>),
1635}
1636
1637#[derive(Debug)]
1638#[cfg_attr(feature = "serialize", derive(Serialize))]
1639#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1640pub struct Ratio<'a> {
1641    pub numerator: Number<'a>,
1642    pub solidus_span: Span,
1643    pub denominator: Number<'a>,
1644    pub span: Span,
1645}
1646
1647#[derive(Debug)]
1648#[cfg_attr(feature = "serialize", derive(Serialize))]
1649#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1650pub struct RelativeSelector<'a> {
1651    pub combinator: Option<Combinator>,
1652    pub complex_selector: ComplexSelector<'a>,
1653    pub span: Span,
1654}
1655
1656#[derive(Debug)]
1657#[cfg_attr(feature = "serialize", derive(Serialize))]
1658#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1659pub struct RelativeSelectorList<'a> {
1660    pub selectors: Vec<'a, RelativeSelector<'a>>,
1661    pub comma_spans: Vec<'a, Span>,
1662    pub span: Span,
1663}
1664
1665#[derive(Debug)]
1666#[cfg_attr(feature = "serialize", derive(Serialize))]
1667#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1668pub struct SassArbitraryArgument<'a> {
1669    pub value: Box<'a, ComponentValue<'a>>,
1670    pub span: Span,
1671}
1672
1673#[derive(Debug)]
1674#[cfg_attr(feature = "serialize", derive(Serialize))]
1675#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1676pub struct SassArbitraryParameter<'a> {
1677    pub name: SassVariable<'a>,
1678    pub span: Span,
1679}
1680
1681#[derive(Debug)]
1682#[cfg_attr(feature = "serialize", derive(Serialize))]
1683#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1684pub struct SassAtRoot<'a> {
1685    pub kind: SassAtRootKind<'a>,
1686    pub span: Span,
1687}
1688
1689#[derive(Debug)]
1690#[cfg_attr(feature = "serialize", derive(Serialize))]
1691#[cfg_attr(feature = "serialize", serde(untagged))]
1692pub enum SassAtRootKind<'a> {
1693    Selector(SelectorList<'a>),
1694    Query(SassAtRootQuery<'a>),
1695}
1696
1697#[derive(Debug)]
1698#[cfg_attr(feature = "serialize", derive(Serialize))]
1699#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1700pub struct SassAtRootQuery<'a> {
1701    pub modifier: SassAtRootQueryModifier,
1702    pub colon_span: Span,
1703    /// space-separated rule names
1704    pub rules: Vec<'a, SassAtRootQueryRule<'a>>,
1705    pub span: Span,
1706}
1707
1708#[derive(Debug)]
1709#[cfg_attr(feature = "serialize", derive(Serialize))]
1710#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1711pub struct SassAtRootQueryModifier {
1712    pub kind: SassAtRootQueryModifierKind,
1713    pub span: Span,
1714}
1715
1716#[derive(Debug)]
1717#[cfg_attr(feature = "serialize", derive(Serialize))]
1718pub enum SassAtRootQueryModifierKind {
1719    With,
1720    Without,
1721}
1722
1723#[derive(Debug)]
1724#[cfg_attr(feature = "serialize", derive(Serialize))]
1725#[cfg_attr(feature = "serialize", serde(untagged))]
1726pub enum SassAtRootQueryRule<'a> {
1727    Ident(InterpolableIdent<'a>),
1728    Str(InterpolableStr<'a>),
1729}
1730
1731#[derive(Debug)]
1732#[cfg_attr(feature = "serialize", derive(Serialize))]
1733#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1734pub struct SassBinaryExpression<'a> {
1735    pub left: Box<'a, ComponentValue<'a>>,
1736    pub op: SassBinaryOperator,
1737    pub right: Box<'a, ComponentValue<'a>>,
1738    pub span: Span,
1739}
1740
1741#[derive(Debug)]
1742#[cfg_attr(feature = "serialize", derive(Serialize))]
1743#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1744pub struct SassBinaryOperator {
1745    pub kind: SassBinaryOperatorKind,
1746    pub span: Span,
1747}
1748
1749#[derive(Debug)]
1750#[cfg_attr(feature = "serialize", derive(Serialize))]
1751pub enum SassBinaryOperatorKind {
1752    Multiply,
1753    Division,
1754    Modulo,
1755    Plus,
1756    Minus,
1757    GreaterThan,
1758    GreaterThanOrEqual,
1759    LessThan,
1760    LessThanOrEqual,
1761    EqualsEquals,
1762    ExclamationEquals,
1763    And,
1764    Or,
1765}
1766
1767#[derive(Debug)]
1768#[cfg_attr(feature = "serialize", derive(Serialize))]
1769#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1770pub struct SassConditionalClause<'a> {
1771    pub condition: ComponentValue<'a>,
1772    pub block: SimpleBlock<'a>,
1773    pub span: Span,
1774}
1775
1776#[derive(Debug)]
1777#[cfg_attr(feature = "serialize", derive(Serialize))]
1778#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1779pub struct SassContent<'a> {
1780    pub args: Vec<'a, ComponentValue<'a>>,
1781    pub comma_spans: Vec<'a, Span>,
1782    pub span: Span,
1783}
1784
1785#[derive(Debug)]
1786#[cfg_attr(feature = "serialize", derive(Serialize))]
1787#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1788pub struct SassEach<'a> {
1789    pub bindings: Vec<'a, SassVariable<'a>>,
1790    pub comma_spans: Vec<'a, Span>,
1791    pub in_span: Span,
1792    pub expr: ComponentValue<'a>,
1793    pub span: Span,
1794}
1795
1796#[derive(Debug)]
1797#[cfg_attr(feature = "serialize", derive(Serialize))]
1798#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1799pub struct SassExtend<'a> {
1800    pub selectors: CompoundSelectorList<'a>,
1801    pub optional: Option<SassFlag<'a>>,
1802    pub span: Span,
1803}
1804
1805#[derive(Debug)]
1806#[cfg_attr(feature = "serialize", derive(Serialize))]
1807#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1808pub struct SassFlag<'a> {
1809    pub keyword: Ident<'a>,
1810    pub span: Span,
1811}
1812
1813#[derive(Debug)]
1814#[cfg_attr(feature = "serialize", derive(Serialize))]
1815#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1816pub struct SassFor<'a> {
1817    pub binding: SassVariable<'a>,
1818    pub from_span: Span,
1819    pub start: ComponentValue<'a>,
1820    pub end: ComponentValue<'a>,
1821    pub boundary: SassForBoundary,
1822    pub span: Span,
1823}
1824
1825#[derive(Debug)]
1826#[cfg_attr(feature = "serialize", derive(Serialize))]
1827#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1828pub struct SassForBoundary {
1829    pub kind: SassForBoundaryKind,
1830    pub span: Span,
1831}
1832
1833#[derive(Debug)]
1834#[cfg_attr(feature = "serialize", derive(Serialize))]
1835pub enum SassForBoundaryKind {
1836    Inclusive,
1837    Exclusive,
1838}
1839
1840#[derive(Debug)]
1841#[cfg_attr(feature = "serialize", derive(Serialize))]
1842#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1843pub struct SassForward<'a> {
1844    pub path: InterpolableStr<'a>,
1845    pub prefix: Option<SassForwardPrefix<'a>>,
1846    pub visibility: Option<SassForwardVisibility<'a>>,
1847    pub config: Option<SassModuleConfig<'a>>,
1848    pub span: Span,
1849}
1850
1851#[derive(Debug)]
1852#[cfg_attr(feature = "serialize", derive(Serialize))]
1853#[cfg_attr(feature = "serialize", serde(untagged))]
1854pub enum SassForwardMember<'a> {
1855    Ident(Ident<'a>),
1856    Variable(SassVariable<'a>),
1857}
1858
1859#[derive(Debug)]
1860#[cfg_attr(feature = "serialize", derive(Serialize))]
1861#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1862pub struct SassForwardPrefix<'a> {
1863    pub as_span: Span,
1864    pub name: Ident<'a>,
1865    pub span: Span,
1866}
1867
1868#[derive(Debug)]
1869#[cfg_attr(feature = "serialize", derive(Serialize))]
1870#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1871pub struct SassForwardVisibility<'a> {
1872    pub modifier: SassForwardVisibilityModifier,
1873    pub members: Vec<'a, SassForwardMember<'a>>,
1874    pub comma_spans: Vec<'a, Span>,
1875    pub span: Span,
1876}
1877
1878#[derive(Debug)]
1879#[cfg_attr(feature = "serialize", derive(Serialize))]
1880#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1881pub struct SassForwardVisibilityModifier {
1882    pub kind: SassForwardVisibilityModifierKind,
1883    pub span: Span,
1884}
1885
1886#[derive(Debug)]
1887#[cfg_attr(feature = "serialize", derive(Serialize))]
1888pub enum SassForwardVisibilityModifierKind {
1889    Hide,
1890    Show,
1891}
1892
1893#[derive(Debug)]
1894#[cfg_attr(feature = "serialize", derive(Serialize))]
1895#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1896pub struct SassFunction<'a> {
1897    pub name: Ident<'a>,
1898    pub parameters: SassParameters<'a>,
1899    pub span: Span,
1900}
1901
1902#[derive(Debug)]
1903#[cfg_attr(feature = "serialize", derive(Serialize))]
1904#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1905pub struct SassIfAtRule<'a> {
1906    pub if_clause: SassConditionalClause<'a>,
1907    pub else_if_clauses: Vec<'a, SassConditionalClause<'a>>,
1908    pub else_clause: Option<SimpleBlock<'a>>,
1909    pub else_spans: Vec<'a, Span>,
1910    pub span: Span,
1911}
1912
1913#[derive(Debug)]
1914#[cfg_attr(feature = "serialize", derive(Serialize))]
1915#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1916pub struct SassImportPrelude<'a> {
1917    pub paths: Vec<'a, Str<'a>>,
1918    pub comma_spans: Vec<'a, Span>,
1919    pub span: Span,
1920}
1921
1922#[derive(Debug)]
1923#[cfg_attr(feature = "serialize", derive(Serialize))]
1924#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1925pub struct SassInclude<'a> {
1926    pub name: FunctionName<'a>,
1927    pub arguments: Option<SassIncludeArgs<'a>>,
1928    pub content_block_params: Option<SassIncludeContentBlockParams<'a>>,
1929    pub span: Span,
1930}
1931
1932#[derive(Debug)]
1933#[cfg_attr(feature = "serialize", derive(Serialize))]
1934#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1935pub struct SassIncludeArgs<'a> {
1936    pub args: Vec<'a, ComponentValue<'a>>,
1937    pub comma_spans: Vec<'a, Span>,
1938    pub span: Span,
1939}
1940
1941#[derive(Debug)]
1942#[cfg_attr(feature = "serialize", derive(Serialize))]
1943#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1944pub struct SassIncludeContentBlockParams<'a> {
1945    pub using_span: Span,
1946    pub params: SassParameters<'a>,
1947    pub span: Span,
1948}
1949
1950#[derive(Debug)]
1951#[cfg_attr(feature = "serialize", derive(Serialize))]
1952#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1953pub struct SassInterpolatedIdent<'a> {
1954    pub elements: Vec<'a, SassInterpolatedIdentElement<'a>>,
1955    pub span: Span,
1956}
1957
1958#[derive(Debug)]
1959#[cfg_attr(feature = "serialize", derive(Serialize))]
1960#[cfg_attr(feature = "serialize", serde(untagged))]
1961pub enum SassInterpolatedIdentElement<'a> {
1962    Expression(ComponentValue<'a>),
1963    Static(InterpolableIdentStaticPart<'a>),
1964}
1965
1966#[derive(Debug)]
1967#[cfg_attr(feature = "serialize", derive(Serialize))]
1968#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1969pub struct SassInterpolatedStr<'a> {
1970    pub elements: Vec<'a, SassInterpolatedStrElement<'a>>,
1971    pub span: Span,
1972}
1973
1974#[derive(Debug)]
1975#[cfg_attr(feature = "serialize", derive(Serialize))]
1976#[cfg_attr(feature = "serialize", serde(untagged))]
1977pub enum SassInterpolatedStrElement<'a> {
1978    Expression(ComponentValue<'a>),
1979    Static(InterpolableStrStaticPart<'a>),
1980}
1981
1982#[derive(Debug)]
1983#[cfg_attr(feature = "serialize", derive(Serialize))]
1984#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
1985pub struct SassInterpolatedUrl<'a> {
1986    pub elements: Vec<'a, SassInterpolatedUrlElement<'a>>,
1987    pub span: Span,
1988}
1989
1990#[derive(Debug)]
1991#[cfg_attr(feature = "serialize", derive(Serialize))]
1992#[cfg_attr(feature = "serialize", serde(untagged))]
1993pub enum SassInterpolatedUrlElement<'a> {
1994    Expression(ComponentValue<'a>),
1995    Static(InterpolableUrlStaticPart<'a>),
1996}
1997
1998#[derive(Debug)]
1999#[cfg_attr(feature = "serialize", derive(Serialize))]
2000#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2001pub struct SassKeywordArgument<'a> {
2002    pub name: SassVariable<'a>,
2003    pub colon_span: Span,
2004    pub value: Box<'a, ComponentValue<'a>>,
2005    pub span: Span,
2006}
2007
2008#[derive(Debug)]
2009#[cfg_attr(feature = "serialize", derive(Serialize))]
2010#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2011pub struct SassList<'a> {
2012    pub elements: Vec<'a, ComponentValue<'a>>,
2013    pub comma_spans: Option<Vec<'a, Span>>,
2014    pub span: Span,
2015}
2016
2017#[derive(Debug)]
2018#[cfg_attr(feature = "serialize", derive(Serialize))]
2019#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2020pub struct SassMap<'a> {
2021    pub items: Vec<'a, SassMapItem<'a>>,
2022    pub comma_spans: Vec<'a, Span>,
2023    pub span: Span,
2024}
2025
2026#[derive(Debug)]
2027#[cfg_attr(feature = "serialize", derive(Serialize))]
2028#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2029pub struct SassMapItem<'a> {
2030    pub key: ComponentValue<'a>,
2031    pub colon_span: Span,
2032    pub value: ComponentValue<'a>,
2033    pub span: Span,
2034}
2035
2036#[derive(Debug)]
2037#[cfg_attr(feature = "serialize", derive(Serialize))]
2038#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2039pub struct SassMixin<'a> {
2040    pub name: Ident<'a>,
2041    pub parameters: Option<SassParameters<'a>>,
2042    pub span: Span,
2043}
2044
2045#[derive(Debug)]
2046#[cfg_attr(feature = "serialize", derive(Serialize))]
2047#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2048pub struct SassModuleConfig<'a> {
2049    pub with_span: Span,
2050    pub lparen_span: Span,
2051    pub items: Vec<'a, SassModuleConfigItem<'a>>,
2052    pub comma_spans: Vec<'a, Span>,
2053    pub span: Span,
2054}
2055
2056#[derive(Debug)]
2057#[cfg_attr(feature = "serialize", derive(Serialize))]
2058#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2059pub struct SassModuleConfigItem<'a> {
2060    pub variable: SassVariable<'a>,
2061    pub colon_span: Span,
2062    pub value: ComponentValue<'a>,
2063    pub flags: Vec<'a, SassFlag<'a>>,
2064    pub span: Span,
2065}
2066
2067#[derive(Debug)]
2068#[cfg_attr(feature = "serialize", derive(Serialize))]
2069#[cfg_attr(feature = "serialize", serde(untagged))]
2070pub enum SassModuleMemberName<'a> {
2071    Ident(Ident<'a>),
2072    Variable(SassVariable<'a>),
2073}
2074
2075#[derive(Debug)]
2076#[cfg_attr(feature = "serialize", derive(Serialize))]
2077#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2078pub struct SassNestingDeclaration<'a> {
2079    pub block: SimpleBlock<'a>,
2080    pub span: Span,
2081}
2082
2083#[derive(Debug)]
2084#[cfg_attr(feature = "serialize", derive(Serialize))]
2085#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2086pub struct SassParameter<'a> {
2087    pub name: SassVariable<'a>,
2088    pub default_value: Option<SassParameterDefaultValue<'a>>,
2089    pub span: Span,
2090}
2091
2092#[derive(Debug)]
2093#[cfg_attr(feature = "serialize", derive(Serialize))]
2094#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2095pub struct SassParameterDefaultValue<'a> {
2096    pub colon_span: Span,
2097    pub value: ComponentValue<'a>,
2098    pub span: Span,
2099}
2100
2101#[derive(Debug)]
2102#[cfg_attr(feature = "serialize", derive(Serialize))]
2103#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2104pub struct SassParameters<'a> {
2105    pub params: Vec<'a, SassParameter<'a>>,
2106    pub arbitrary_param: Option<SassArbitraryParameter<'a>>,
2107    pub comma_spans: Vec<'a, Span>,
2108    pub span: Span,
2109}
2110
2111#[derive(Debug)]
2112#[cfg_attr(feature = "serialize", derive(Serialize))]
2113#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2114pub struct SassParenthesizedExpression<'a> {
2115    pub expr: Box<'a, ComponentValue<'a>>,
2116    pub span: Span,
2117}
2118
2119#[derive(Debug)]
2120#[cfg_attr(feature = "serialize", derive(Serialize))]
2121#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2122pub struct SassPlaceholderSelector<'a> {
2123    pub name: InterpolableIdent<'a>,
2124    pub span: Span,
2125}
2126
2127#[derive(Debug)]
2128#[cfg_attr(feature = "serialize", derive(Serialize))]
2129#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2130pub struct SassQualifiedName<'a> {
2131    pub module: Ident<'a>,
2132    pub member: SassModuleMemberName<'a>,
2133    pub span: Span,
2134}
2135
2136#[derive(Debug)]
2137#[cfg_attr(feature = "serialize", derive(Serialize))]
2138#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2139pub struct SassUnaryExpression<'a> {
2140    pub op: SassUnaryOperator,
2141    pub expr: Box<'a, ComponentValue<'a>>,
2142    pub span: Span,
2143}
2144
2145#[derive(Debug)]
2146#[cfg_attr(feature = "serialize", derive(Serialize))]
2147#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2148pub struct SassUnaryOperator {
2149    pub kind: SassUnaryOperatorKind,
2150    pub span: Span,
2151}
2152
2153#[derive(Debug)]
2154#[cfg_attr(feature = "serialize", derive(Serialize))]
2155pub enum SassUnaryOperatorKind {
2156    Plus,
2157    Minus,
2158    Not,
2159}
2160
2161#[derive(Debug)]
2162#[cfg_attr(feature = "serialize", derive(Serialize))]
2163#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2164pub struct SassUnnamedNamespace {
2165    pub span: Span,
2166}
2167
2168#[derive(Debug)]
2169#[cfg_attr(feature = "serialize", derive(Serialize))]
2170#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2171pub struct SassUse<'a> {
2172    pub path: InterpolableStr<'a>,
2173    pub namespace: Option<SassUseNamespace<'a>>,
2174    pub config: Option<SassModuleConfig<'a>>,
2175    pub span: Span,
2176}
2177
2178#[derive(Debug)]
2179#[cfg_attr(feature = "serialize", derive(Serialize))]
2180#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2181pub struct SassUseNamespace<'a> {
2182    pub as_span: Span,
2183    pub kind: SassUseNamespaceKind<'a>,
2184    pub span: Span,
2185}
2186
2187#[derive(Debug)]
2188#[cfg_attr(feature = "serialize", derive(Serialize))]
2189#[cfg_attr(feature = "serialize", serde(untagged))]
2190pub enum SassUseNamespaceKind<'a> {
2191    Named(Ident<'a>),
2192    Unnamed(SassUnnamedNamespace),
2193}
2194
2195#[derive(Debug)]
2196#[cfg_attr(feature = "serialize", derive(Serialize))]
2197#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2198pub struct SassVariable<'a> {
2199    pub name: Ident<'a>,
2200    pub span: Span,
2201}
2202
2203#[derive(Debug)]
2204#[cfg_attr(feature = "serialize", derive(Serialize))]
2205#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2206pub struct SassVariableDeclaration<'a> {
2207    pub namespace: Option<Ident<'a>>,
2208    pub name: SassVariable<'a>,
2209    pub colon_span: Span,
2210    pub value: ComponentValue<'a>,
2211    pub flags: Vec<'a, SassFlag<'a>>,
2212    pub span: Span,
2213}
2214
2215#[derive(Debug)]
2216#[cfg_attr(feature = "serialize", derive(Serialize))]
2217#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2218pub struct ScopeEnd<'a> {
2219    pub to_span: Span,
2220    pub lparen_span: Span,
2221    pub selector: SelectorList<'a>,
2222    pub span: Span,
2223}
2224
2225#[derive(Debug)]
2226#[cfg_attr(feature = "serialize", derive(Serialize))]
2227#[cfg_attr(feature = "serialize", serde(untagged))]
2228pub enum ScopePrelude<'a> {
2229    StartOnly(ScopeStart<'a>),
2230    EndOnly(ScopeEnd<'a>),
2231    Both(ScopeStartWithEnd<'a>),
2232}
2233
2234#[derive(Debug)]
2235#[cfg_attr(feature = "serialize", derive(Serialize))]
2236#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2237pub struct ScopeStart<'a> {
2238    pub selector: SelectorList<'a>,
2239    pub span: Span,
2240}
2241
2242#[derive(Debug)]
2243#[cfg_attr(feature = "serialize", derive(Serialize))]
2244#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2245pub struct ScopeStartWithEnd<'a> {
2246    pub start: ScopeStart<'a>,
2247    pub end: ScopeEnd<'a>,
2248    pub span: Span,
2249}
2250
2251#[derive(Debug)]
2252#[cfg_attr(feature = "serialize", derive(Serialize))]
2253#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2254pub struct SelectorList<'a> {
2255    pub selectors: Vec<'a, ComplexSelector<'a>>,
2256    pub comma_spans: Vec<'a, Span>,
2257    pub span: Span,
2258}
2259
2260#[derive(Debug)]
2261#[cfg_attr(feature = "serialize", derive(Serialize))]
2262#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2263pub struct SimpleBlock<'a> {
2264    pub statements: Vec<'a, Statement<'a>>,
2265    pub span: Span,
2266}
2267
2268#[derive(Debug)]
2269#[cfg_attr(feature = "serialize", derive(Serialize))]
2270#[cfg_attr(feature = "serialize", serde(untagged))]
2271pub enum SimpleSelector<'a> {
2272    Class(ClassSelector<'a>),
2273    Id(IdSelector<'a>),
2274    Type(TypeSelector<'a>),
2275    Attribute(AttributeSelector<'a>),
2276    PseudoClass(PseudoClassSelector<'a>),
2277    PseudoElement(PseudoElementSelector<'a>),
2278    Nesting(NestingSelector<'a>),
2279    SassPlaceholder(SassPlaceholderSelector<'a>),
2280}
2281
2282#[derive(Debug)]
2283#[cfg_attr(feature = "serialize", derive(Serialize))]
2284#[cfg_attr(feature = "serialize", serde(untagged))]
2285pub enum Statement<'a> {
2286    AtRule(AtRule<'a>),
2287    Declaration(Declaration<'a>),
2288    KeyframeBlock(KeyframeBlock<'a>),
2289    LessConditionalQualifiedRule(LessConditionalQualifiedRule<'a>),
2290    LessExtendRule(LessExtendRule<'a>),
2291    LessFunctionCall(Function<'a>),
2292    LessMixinCall(LessMixinCall<'a>),
2293    LessMixinDefinition(Box<'a, LessMixinDefinition<'a>>),
2294    LessVariableCall(LessVariableCall<'a>),
2295    LessVariableDeclaration(Box<'a, LessVariableDeclaration<'a>>),
2296    Placeholder(Placeholder<'a>),
2297    PostcssSimpleVarDeclaration(Box<'a, PostcssSimpleVarDeclaration<'a>>),
2298    QualifiedRule(QualifiedRule<'a>),
2299    SassIfAtRule(Box<'a, SassIfAtRule<'a>>),
2300    SassVariableDeclaration(Box<'a, SassVariableDeclaration<'a>>),
2301    UnknownSassAtRule(Box<'a, UnknownSassAtRule<'a>>),
2302}
2303
2304#[derive(Debug)]
2305#[cfg_attr(feature = "serialize", derive(Serialize))]
2306#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2307pub struct Str<'a> {
2308    pub value: &'a str,
2309    pub raw: &'a str,
2310    pub span: Span,
2311}
2312
2313#[derive(Debug)]
2314#[cfg_attr(feature = "serialize", derive(Serialize))]
2315#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2316pub struct StyleCondition<'a> {
2317    pub conditions: Vec<'a, StyleConditionKind<'a>>,
2318    pub span: Span,
2319}
2320
2321#[derive(Debug)]
2322#[cfg_attr(feature = "serialize", derive(Serialize))]
2323#[cfg_attr(feature = "serialize", serde(untagged))]
2324pub enum StyleConditionKind<'a> {
2325    StyleInParens(StyleInParens<'a>),
2326    And(StyleConditionAnd<'a>),
2327    Or(StyleConditionOr<'a>),
2328    Not(StyleConditionNot<'a>),
2329}
2330
2331#[derive(Debug)]
2332#[cfg_attr(feature = "serialize", derive(Serialize))]
2333#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2334pub struct StyleConditionAnd<'a> {
2335    pub keyword: Ident<'a>,
2336    pub style_in_parens: StyleInParens<'a>,
2337    pub span: Span,
2338}
2339
2340#[derive(Debug)]
2341#[cfg_attr(feature = "serialize", derive(Serialize))]
2342#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2343pub struct StyleConditionNot<'a> {
2344    pub keyword: Ident<'a>,
2345    pub style_in_parens: StyleInParens<'a>,
2346    pub span: Span,
2347}
2348
2349#[derive(Debug)]
2350#[cfg_attr(feature = "serialize", derive(Serialize))]
2351#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2352pub struct StyleConditionOr<'a> {
2353    pub keyword: Ident<'a>,
2354    pub style_in_parens: StyleInParens<'a>,
2355    pub span: Span,
2356}
2357
2358#[derive(Debug)]
2359#[cfg_attr(feature = "serialize", derive(Serialize))]
2360#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2361pub struct StyleInParens<'a> {
2362    pub kind: StyleInParensKind<'a>,
2363    pub span: Span,
2364}
2365
2366#[derive(Debug)]
2367#[cfg_attr(feature = "serialize", derive(Serialize))]
2368#[cfg_attr(feature = "serialize", serde(untagged))]
2369pub enum StyleInParensKind<'a> {
2370    Condition(StyleCondition<'a>),
2371    Feature(Declaration<'a>),
2372}
2373
2374#[derive(Debug)]
2375#[cfg_attr(feature = "serialize", derive(Serialize))]
2376#[cfg_attr(feature = "serialize", serde(untagged))]
2377pub enum StyleQuery<'a> {
2378    Condition(StyleCondition<'a>),
2379    Feature(Declaration<'a>),
2380}
2381
2382#[derive(Debug)]
2383#[cfg_attr(feature = "serialize", derive(Serialize))]
2384#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2385pub struct Stylesheet<'a> {
2386    pub statements: Vec<'a, Statement<'a>>,
2387    pub span: Span,
2388}
2389
2390#[derive(Debug)]
2391#[cfg_attr(feature = "serialize", derive(Serialize))]
2392#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2393pub struct SupportsAnd<'a> {
2394    pub keyword: Ident<'a>,
2395    pub condition: SupportsInParens<'a>,
2396    pub span: Span,
2397}
2398
2399#[derive(Debug)]
2400#[cfg_attr(feature = "serialize", derive(Serialize))]
2401#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2402pub struct SupportsCondition<'a> {
2403    pub conditions: Vec<'a, SupportsConditionKind<'a>>,
2404    pub span: Span,
2405}
2406
2407#[derive(Debug)]
2408#[cfg_attr(feature = "serialize", derive(Serialize))]
2409#[cfg_attr(feature = "serialize", serde(untagged))]
2410pub enum SupportsConditionKind<'a> {
2411    Not(SupportsNot<'a>),
2412    And(SupportsAnd<'a>),
2413    Or(SupportsOr<'a>),
2414    SupportsInParens(SupportsInParens<'a>),
2415}
2416
2417#[derive(Debug)]
2418#[cfg_attr(feature = "serialize", derive(Serialize))]
2419#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2420pub struct SupportsDecl<'a> {
2421    pub decl: Declaration<'a>,
2422    pub span: Span,
2423}
2424
2425#[derive(Debug)]
2426#[cfg_attr(feature = "serialize", derive(Serialize))]
2427#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2428pub struct SupportsInParens<'a> {
2429    pub kind: SupportsInParensKind<'a>,
2430    pub span: Span,
2431}
2432
2433#[derive(Debug)]
2434#[cfg_attr(feature = "serialize", derive(Serialize))]
2435#[cfg_attr(feature = "serialize", serde(untagged))]
2436pub enum SupportsInParensKind<'a> {
2437    SupportsCondition(SupportsCondition<'a>),
2438    Feature(Box<'a, SupportsDecl<'a>>),
2439    Selector(SelectorList<'a>),
2440    Function(Function<'a>),
2441    GeneralEnclosed(TokenSeq<'a>),
2442}
2443
2444#[derive(Debug)]
2445#[cfg_attr(feature = "serialize", derive(Serialize))]
2446#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2447pub struct SupportsNot<'a> {
2448    pub keyword: Ident<'a>,
2449    pub condition: SupportsInParens<'a>,
2450    pub span: Span,
2451}
2452
2453#[derive(Debug)]
2454#[cfg_attr(feature = "serialize", derive(Serialize))]
2455#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2456pub struct SupportsOr<'a> {
2457    pub keyword: Ident<'a>,
2458    pub condition: SupportsInParens<'a>,
2459    pub span: Span,
2460}
2461
2462#[derive(Debug)]
2463#[cfg_attr(feature = "serialize", derive(Serialize))]
2464#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2465pub struct TagNameSelector<'a> {
2466    pub name: WqName<'a>,
2467    pub span: Span,
2468}
2469
2470#[derive(Debug)]
2471#[cfg_attr(feature = "serialize", derive(Serialize))]
2472#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2473pub struct TokenSeq<'a> {
2474    pub tokens: Vec<'a, TokenWithSpan<'a>>,
2475    pub span: Span,
2476}
2477
2478#[derive(Debug)]
2479#[cfg_attr(feature = "serialize", derive(Serialize))]
2480#[cfg_attr(feature = "serialize", serde(untagged))]
2481pub enum TypeSelector<'a> {
2482    TagName(TagNameSelector<'a>),
2483    Universal(UniversalSelector<'a>),
2484}
2485
2486#[derive(Debug)]
2487#[cfg_attr(feature = "serialize", derive(Serialize))]
2488#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2489pub struct UnicodeRange<'a> {
2490    pub prefix: char,
2491    pub start: u32,
2492    pub start_raw: &'a str,
2493    pub end: u32,
2494    pub end_raw: Option<&'a str>,
2495    pub span: Span,
2496}
2497
2498#[derive(Debug)]
2499#[cfg_attr(feature = "serialize", derive(Serialize))]
2500#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2501pub struct UniversalSelector<'a> {
2502    pub prefix: Option<NsPrefix<'a>>,
2503    pub span: Span,
2504}
2505
2506#[derive(Debug)]
2507#[cfg_attr(feature = "serialize", derive(Serialize))]
2508#[cfg_attr(feature = "serialize", serde(untagged))]
2509pub enum UnknownAtRulePrelude<'a> {
2510    ComponentValue(ComponentValue<'a>),
2511    TokenSeq(TokenSeq<'a>),
2512}
2513
2514#[derive(Debug)]
2515#[cfg_attr(feature = "serialize", derive(Serialize))]
2516#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2517pub struct UnknownSassAtRule<'a> {
2518    pub name: InterpolableIdent<'a>,
2519    pub prelude: Option<UnknownAtRulePrelude<'a>>,
2520    pub block: Option<SimpleBlock<'a>>,
2521    pub span: Span,
2522}
2523
2524#[derive(Debug)]
2525#[cfg_attr(feature = "serialize", derive(Serialize))]
2526#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2527pub struct UnquotedFontFamilyName<'a> {
2528    pub idents: Vec<'a, InterpolableIdent<'a>>,
2529    pub span: Span,
2530}
2531
2532#[derive(Debug)]
2533#[cfg_attr(feature = "serialize", derive(Serialize))]
2534#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2535pub struct Url<'a> {
2536    pub name: Ident<'a>,
2537    pub value: Option<UrlValue<'a>>,
2538    pub modifiers: Vec<'a, UrlModifier<'a>>,
2539    pub span: Span,
2540}
2541
2542#[derive(Debug)]
2543#[cfg_attr(feature = "serialize", derive(Serialize))]
2544#[cfg_attr(feature = "serialize", serde(untagged))]
2545pub enum UrlModifier<'a> {
2546    Ident(InterpolableIdent<'a>),
2547    Function(Function<'a>),
2548}
2549
2550/// `)` is excluded
2551#[derive(Debug)]
2552#[cfg_attr(feature = "serialize", derive(Serialize))]
2553#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2554pub struct UrlRaw<'a> {
2555    pub value: &'a str,
2556    pub raw: &'a str,
2557    pub span: Span,
2558}
2559
2560#[derive(Debug)]
2561#[cfg_attr(feature = "serialize", derive(Serialize))]
2562#[cfg_attr(feature = "serialize", serde(untagged))]
2563pub enum UrlValue<'a> {
2564    Raw(UrlRaw<'a>),
2565    SassInterpolated(SassInterpolatedUrl<'a>),
2566    Str(InterpolableStr<'a>),
2567    LessEscapedStr(LessEscapedStr<'a>),
2568}
2569
2570#[derive(Debug)]
2571#[cfg_attr(feature = "serialize", derive(Serialize))]
2572#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
2573pub struct WqName<'a> {
2574    pub name: InterpolableIdent<'a>,
2575    pub prefix: Option<NsPrefix<'a>>,
2576    pub span: Span,
2577}
2578
2579include!("ast_generated.rs");