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

oxc_css_parser/
ast.rs
