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

oxc_css_parser/
ast.rs
