hypersig_style/value/
generated.rs

1// @generated by tests/generate.rs from data/mdn-data-2.37.2. Do not edit by hand.
2
3use std::fmt;
4
5use super::{Angle, Color, Length, Percentage, Quoted, Raw, Time, Url};
6
7/// A value of [`accent-color`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/accent-color).
8#[derive(Debug, Clone, PartialEq)]
9#[non_exhaustive]
10pub enum AccentColor {
11    /// `auto`.
12    Auto,
13    /// A color.
14    Color(Color),
15}
16
17impl fmt::Display for AccentColor {
18    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
19        match self {
20            Self::Auto => f.write_str("auto"),
21            Self::Color(v) => v.fmt(f),
22        }
23    }
24}
25
26impl From<Color> for AccentColor {
27    fn from(v: Color) -> Self {
28        Self::Color(v)
29    }
30}
31
32/// A value of [`align-content`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/align-content).
33#[derive(Debug, Clone, PartialEq)]
34#[non_exhaustive]
35pub enum AlignContent {
36    /// `baseline`.
37    Baseline,
38    /// `center`.
39    Center,
40    /// `end`.
41    End,
42    /// `flex-end`.
43    FlexEnd,
44    /// `flex-start`.
45    FlexStart,
46    /// `normal`.
47    Normal,
48    /// `space-around`.
49    SpaceAround,
50    /// `space-between`.
51    SpaceBetween,
52    /// `space-evenly`.
53    SpaceEvenly,
54    /// `start`.
55    Start,
56    /// `stretch`.
57    Stretch,
58    /// Any other value, passed through unchecked.
59    Raw(Raw),
60}
61
62impl fmt::Display for AlignContent {
63    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
64        match self {
65            Self::Baseline => f.write_str("baseline"),
66            Self::Center => f.write_str("center"),
67            Self::End => f.write_str("end"),
68            Self::FlexEnd => f.write_str("flex-end"),
69            Self::FlexStart => f.write_str("flex-start"),
70            Self::Normal => f.write_str("normal"),
71            Self::SpaceAround => f.write_str("space-around"),
72            Self::SpaceBetween => f.write_str("space-between"),
73            Self::SpaceEvenly => f.write_str("space-evenly"),
74            Self::Start => f.write_str("start"),
75            Self::Stretch => f.write_str("stretch"),
76            Self::Raw(v) => v.fmt(f),
77        }
78    }
79}
80
81impl From<Raw> for AlignContent {
82    fn from(v: Raw) -> Self {
83        Self::Raw(v)
84    }
85}
86
87/// A value of [`align-items`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/align-items).
88#[derive(Debug, Clone, PartialEq)]
89#[non_exhaustive]
90pub enum AlignItems {
91    /// `anchor-center`.
92    AnchorCenter,
93    /// `baseline`.
94    Baseline,
95    /// `center`.
96    Center,
97    /// `end`.
98    End,
99    /// `flex-end`.
100    FlexEnd,
101    /// `flex-start`.
102    FlexStart,
103    /// `normal`.
104    Normal,
105    /// `self-end`.
106    SelfEnd,
107    /// `self-start`.
108    SelfStart,
109    /// `start`.
110    Start,
111    /// `stretch`.
112    Stretch,
113    /// Any other value, passed through unchecked.
114    Raw(Raw),
115}
116
117impl fmt::Display for AlignItems {
118    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
119        match self {
120            Self::AnchorCenter => f.write_str("anchor-center"),
121            Self::Baseline => f.write_str("baseline"),
122            Self::Center => f.write_str("center"),
123            Self::End => f.write_str("end"),
124            Self::FlexEnd => f.write_str("flex-end"),
125            Self::FlexStart => f.write_str("flex-start"),
126            Self::Normal => f.write_str("normal"),
127            Self::SelfEnd => f.write_str("self-end"),
128            Self::SelfStart => f.write_str("self-start"),
129            Self::Start => f.write_str("start"),
130            Self::Stretch => f.write_str("stretch"),
131            Self::Raw(v) => v.fmt(f),
132        }
133    }
134}
135
136impl From<Raw> for AlignItems {
137    fn from(v: Raw) -> Self {
138        Self::Raw(v)
139    }
140}
141
142/// A value of [`align-self`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/align-self).
143#[derive(Debug, Clone, PartialEq)]
144#[non_exhaustive]
145pub enum AlignSelf {
146    /// `anchor-center`.
147    AnchorCenter,
148    /// `auto`.
149    Auto,
150    /// `baseline`.
151    Baseline,
152    /// `center`.
153    Center,
154    /// `end`.
155    End,
156    /// `flex-end`.
157    FlexEnd,
158    /// `flex-start`.
159    FlexStart,
160    /// `normal`.
161    Normal,
162    /// `self-end`.
163    SelfEnd,
164    /// `self-start`.
165    SelfStart,
166    /// `start`.
167    Start,
168    /// `stretch`.
169    Stretch,
170    /// Any other value, passed through unchecked.
171    Raw(Raw),
172}
173
174impl fmt::Display for AlignSelf {
175    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
176        match self {
177            Self::AnchorCenter => f.write_str("anchor-center"),
178            Self::Auto => f.write_str("auto"),
179            Self::Baseline => f.write_str("baseline"),
180            Self::Center => f.write_str("center"),
181            Self::End => f.write_str("end"),
182            Self::FlexEnd => f.write_str("flex-end"),
183            Self::FlexStart => f.write_str("flex-start"),
184            Self::Normal => f.write_str("normal"),
185            Self::SelfEnd => f.write_str("self-end"),
186            Self::SelfStart => f.write_str("self-start"),
187            Self::Start => f.write_str("start"),
188            Self::Stretch => f.write_str("stretch"),
189            Self::Raw(v) => v.fmt(f),
190        }
191    }
192}
193
194impl From<Raw> for AlignSelf {
195    fn from(v: Raw) -> Self {
196        Self::Raw(v)
197    }
198}
199
200/// A value of [`alignment-baseline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/alignment-baseline).
201#[derive(Debug, Clone, PartialEq)]
202#[non_exhaustive]
203pub enum AlignmentBaseline {
204    /// `alphabetic`.
205    Alphabetic,
206    /// `baseline`.
207    Baseline,
208    /// `central`.
209    Central,
210    /// `ideographic`.
211    Ideographic,
212    /// `mathematical`.
213    Mathematical,
214    /// `middle`.
215    Middle,
216    /// `text-after-edge`.
217    TextAfterEdge,
218    /// `text-before-edge`.
219    TextBeforeEdge,
220}
221
222impl fmt::Display for AlignmentBaseline {
223    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
224        match self {
225            Self::Alphabetic => f.write_str("alphabetic"),
226            Self::Baseline => f.write_str("baseline"),
227            Self::Central => f.write_str("central"),
228            Self::Ideographic => f.write_str("ideographic"),
229            Self::Mathematical => f.write_str("mathematical"),
230            Self::Middle => f.write_str("middle"),
231            Self::TextAfterEdge => f.write_str("text-after-edge"),
232            Self::TextBeforeEdge => f.write_str("text-before-edge"),
233        }
234    }
235}
236
237/// A value of [`all`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/all).
238#[derive(Debug, Clone, PartialEq)]
239#[non_exhaustive]
240pub enum All {
241    /// `inherit`.
242    Inherit,
243    /// `initial`.
244    Initial,
245    /// `revert`.
246    Revert,
247    /// `revert-layer`.
248    RevertLayer,
249    /// `unset`.
250    Unset,
251}
252
253impl fmt::Display for All {
254    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
255        match self {
256            Self::Inherit => f.write_str("inherit"),
257            Self::Initial => f.write_str("initial"),
258            Self::Revert => f.write_str("revert"),
259            Self::RevertLayer => f.write_str("revert-layer"),
260            Self::Unset => f.write_str("unset"),
261        }
262    }
263}
264
265/// A value of [`anchor-name`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/anchor-name).
266#[derive(Debug, Clone, PartialEq)]
267#[non_exhaustive]
268pub enum AnchorName {
269    /// `none`.
270    None,
271    /// Any other value, passed through unchecked.
272    Raw(Raw),
273}
274
275impl fmt::Display for AnchorName {
276    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
277        match self {
278            Self::None => f.write_str("none"),
279            Self::Raw(v) => v.fmt(f),
280        }
281    }
282}
283
284impl From<Raw> for AnchorName {
285    fn from(v: Raw) -> Self {
286        Self::Raw(v)
287    }
288}
289
290/// A value of [`animation`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation).
291#[derive(Debug, Clone, PartialEq)]
292#[non_exhaustive]
293pub enum Animation {
294    /// `alternate`.
295    Alternate,
296    /// `alternate-reverse`.
297    AlternateReverse,
298    /// `auto`.
299    Auto,
300    /// `backwards`.
301    Backwards,
302    /// `both`.
303    Both,
304    /// `ease`.
305    Ease,
306    /// `ease-in`.
307    EaseIn,
308    /// `ease-in-out`.
309    EaseInOut,
310    /// `ease-out`.
311    EaseOut,
312    /// `forwards`.
313    Forwards,
314    /// `infinite`.
315    Infinite,
316    /// `linear`.
317    Linear,
318    /// `none`.
319    None,
320    /// `normal`.
321    Normal,
322    /// `paused`.
323    Paused,
324    /// `reverse`.
325    Reverse,
326    /// `running`.
327    Running,
328    /// `step-end`.
329    StepEnd,
330    /// `step-start`.
331    StepStart,
332    /// A number.
333    Number(f64),
334    /// A duration.
335    Time(Time),
336    /// A quoted string.
337    Quoted(Quoted),
338    /// Any other value, passed through unchecked.
339    Raw(Raw),
340}
341
342impl fmt::Display for Animation {
343    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
344        match self {
345            Self::Alternate => f.write_str("alternate"),
346            Self::AlternateReverse => f.write_str("alternate-reverse"),
347            Self::Auto => f.write_str("auto"),
348            Self::Backwards => f.write_str("backwards"),
349            Self::Both => f.write_str("both"),
350            Self::Ease => f.write_str("ease"),
351            Self::EaseIn => f.write_str("ease-in"),
352            Self::EaseInOut => f.write_str("ease-in-out"),
353            Self::EaseOut => f.write_str("ease-out"),
354            Self::Forwards => f.write_str("forwards"),
355            Self::Infinite => f.write_str("infinite"),
356            Self::Linear => f.write_str("linear"),
357            Self::None => f.write_str("none"),
358            Self::Normal => f.write_str("normal"),
359            Self::Paused => f.write_str("paused"),
360            Self::Reverse => f.write_str("reverse"),
361            Self::Running => f.write_str("running"),
362            Self::StepEnd => f.write_str("step-end"),
363            Self::StepStart => f.write_str("step-start"),
364            Self::Number(v) => v.fmt(f),
365            Self::Time(v) => v.fmt(f),
366            Self::Quoted(v) => v.fmt(f),
367            Self::Raw(v) => v.fmt(f),
368        }
369    }
370}
371
372impl From<f64> for Animation {
373    fn from(v: f64) -> Self {
374        Self::Number(v)
375    }
376}
377
378impl From<i32> for Animation {
379    fn from(v: i32) -> Self {
380        Self::Number(f64::from(v))
381    }
382}
383
384impl From<Time> for Animation {
385    fn from(v: Time) -> Self {
386        Self::Time(v)
387    }
388}
389
390impl From<Quoted> for Animation {
391    fn from(v: Quoted) -> Self {
392        Self::Quoted(v)
393    }
394}
395
396impl From<Raw> for Animation {
397    fn from(v: Raw) -> Self {
398        Self::Raw(v)
399    }
400}
401
402/// A value of [`animation-composition`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-composition).
403#[derive(Debug, Clone, PartialEq)]
404#[non_exhaustive]
405pub enum AnimationComposition {
406    /// `accumulate`.
407    Accumulate,
408    /// `add`.
409    Add,
410    /// `replace`.
411    Replace,
412    /// Any other value, passed through unchecked.
413    Raw(Raw),
414}
415
416impl fmt::Display for AnimationComposition {
417    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
418        match self {
419            Self::Accumulate => f.write_str("accumulate"),
420            Self::Add => f.write_str("add"),
421            Self::Replace => f.write_str("replace"),
422            Self::Raw(v) => v.fmt(f),
423        }
424    }
425}
426
427impl From<Raw> for AnimationComposition {
428    fn from(v: Raw) -> Self {
429        Self::Raw(v)
430    }
431}
432
433/// A value of [`animation-delay`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-delay).
434#[derive(Debug, Clone, PartialEq)]
435#[non_exhaustive]
436pub enum AnimationDelay {
437    /// A duration.
438    Time(Time),
439    /// Any other value, passed through unchecked.
440    Raw(Raw),
441}
442
443impl fmt::Display for AnimationDelay {
444    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
445        match self {
446            Self::Time(v) => v.fmt(f),
447            Self::Raw(v) => v.fmt(f),
448        }
449    }
450}
451
452impl From<Time> for AnimationDelay {
453    fn from(v: Time) -> Self {
454        Self::Time(v)
455    }
456}
457
458impl From<Raw> for AnimationDelay {
459    fn from(v: Raw) -> Self {
460        Self::Raw(v)
461    }
462}
463
464/// A value of [`animation-direction`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-direction).
465#[derive(Debug, Clone, PartialEq)]
466#[non_exhaustive]
467pub enum AnimationDirection {
468    /// `alternate`.
469    Alternate,
470    /// `alternate-reverse`.
471    AlternateReverse,
472    /// `normal`.
473    Normal,
474    /// `reverse`.
475    Reverse,
476    /// Any other value, passed through unchecked.
477    Raw(Raw),
478}
479
480impl fmt::Display for AnimationDirection {
481    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
482        match self {
483            Self::Alternate => f.write_str("alternate"),
484            Self::AlternateReverse => f.write_str("alternate-reverse"),
485            Self::Normal => f.write_str("normal"),
486            Self::Reverse => f.write_str("reverse"),
487            Self::Raw(v) => v.fmt(f),
488        }
489    }
490}
491
492impl From<Raw> for AnimationDirection {
493    fn from(v: Raw) -> Self {
494        Self::Raw(v)
495    }
496}
497
498/// A value of [`animation-duration`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-duration).
499#[derive(Debug, Clone, PartialEq)]
500#[non_exhaustive]
501pub enum AnimationDuration {
502    /// `auto`.
503    Auto,
504    /// A duration.
505    Time(Time),
506    /// Any other value, passed through unchecked.
507    Raw(Raw),
508}
509
510impl fmt::Display for AnimationDuration {
511    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
512        match self {
513            Self::Auto => f.write_str("auto"),
514            Self::Time(v) => v.fmt(f),
515            Self::Raw(v) => v.fmt(f),
516        }
517    }
518}
519
520impl From<Time> for AnimationDuration {
521    fn from(v: Time) -> Self {
522        Self::Time(v)
523    }
524}
525
526impl From<Raw> for AnimationDuration {
527    fn from(v: Raw) -> Self {
528        Self::Raw(v)
529    }
530}
531
532/// A value of [`animation-fill-mode`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-fill-mode).
533#[derive(Debug, Clone, PartialEq)]
534#[non_exhaustive]
535pub enum AnimationFillMode {
536    /// `backwards`.
537    Backwards,
538    /// `both`.
539    Both,
540    /// `forwards`.
541    Forwards,
542    /// `none`.
543    None,
544    /// Any other value, passed through unchecked.
545    Raw(Raw),
546}
547
548impl fmt::Display for AnimationFillMode {
549    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
550        match self {
551            Self::Backwards => f.write_str("backwards"),
552            Self::Both => f.write_str("both"),
553            Self::Forwards => f.write_str("forwards"),
554            Self::None => f.write_str("none"),
555            Self::Raw(v) => v.fmt(f),
556        }
557    }
558}
559
560impl From<Raw> for AnimationFillMode {
561    fn from(v: Raw) -> Self {
562        Self::Raw(v)
563    }
564}
565
566/// A value of [`animation-iteration-count`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-iteration-count).
567#[derive(Debug, Clone, PartialEq)]
568#[non_exhaustive]
569pub enum AnimationIterationCount {
570    /// `infinite`.
571    Infinite,
572    /// A number.
573    Number(f64),
574    /// Any other value, passed through unchecked.
575    Raw(Raw),
576}
577
578impl fmt::Display for AnimationIterationCount {
579    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
580        match self {
581            Self::Infinite => f.write_str("infinite"),
582            Self::Number(v) => v.fmt(f),
583            Self::Raw(v) => v.fmt(f),
584        }
585    }
586}
587
588impl From<f64> for AnimationIterationCount {
589    fn from(v: f64) -> Self {
590        Self::Number(v)
591    }
592}
593
594impl From<i32> for AnimationIterationCount {
595    fn from(v: i32) -> Self {
596        Self::Number(f64::from(v))
597    }
598}
599
600impl From<Raw> for AnimationIterationCount {
601    fn from(v: Raw) -> Self {
602        Self::Raw(v)
603    }
604}
605
606/// A value of [`animation-name`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-name).
607#[derive(Debug, Clone, PartialEq)]
608#[non_exhaustive]
609pub enum AnimationName {
610    /// `none`.
611    None,
612    /// A quoted string.
613    Quoted(Quoted),
614    /// Any other value, passed through unchecked.
615    Raw(Raw),
616}
617
618impl fmt::Display for AnimationName {
619    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
620        match self {
621            Self::None => f.write_str("none"),
622            Self::Quoted(v) => v.fmt(f),
623            Self::Raw(v) => v.fmt(f),
624        }
625    }
626}
627
628impl From<Quoted> for AnimationName {
629    fn from(v: Quoted) -> Self {
630        Self::Quoted(v)
631    }
632}
633
634impl From<Raw> for AnimationName {
635    fn from(v: Raw) -> Self {
636        Self::Raw(v)
637    }
638}
639
640/// A value of [`animation-play-state`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-play-state).
641#[derive(Debug, Clone, PartialEq)]
642#[non_exhaustive]
643pub enum AnimationPlayState {
644    /// `paused`.
645    Paused,
646    /// `running`.
647    Running,
648    /// Any other value, passed through unchecked.
649    Raw(Raw),
650}
651
652impl fmt::Display for AnimationPlayState {
653    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
654        match self {
655            Self::Paused => f.write_str("paused"),
656            Self::Running => f.write_str("running"),
657            Self::Raw(v) => v.fmt(f),
658        }
659    }
660}
661
662impl From<Raw> for AnimationPlayState {
663    fn from(v: Raw) -> Self {
664        Self::Raw(v)
665    }
666}
667
668/// A value of [`animation-timing-function`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-timing-function).
669#[derive(Debug, Clone, PartialEq)]
670#[non_exhaustive]
671pub enum AnimationTimingFunction {
672    /// `ease`.
673    Ease,
674    /// `ease-in`.
675    EaseIn,
676    /// `ease-in-out`.
677    EaseInOut,
678    /// `ease-out`.
679    EaseOut,
680    /// `linear`.
681    Linear,
682    /// `step-end`.
683    StepEnd,
684    /// `step-start`.
685    StepStart,
686    /// Any other value, passed through unchecked.
687    Raw(Raw),
688}
689
690impl fmt::Display for AnimationTimingFunction {
691    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
692        match self {
693            Self::Ease => f.write_str("ease"),
694            Self::EaseIn => f.write_str("ease-in"),
695            Self::EaseInOut => f.write_str("ease-in-out"),
696            Self::EaseOut => f.write_str("ease-out"),
697            Self::Linear => f.write_str("linear"),
698            Self::StepEnd => f.write_str("step-end"),
699            Self::StepStart => f.write_str("step-start"),
700            Self::Raw(v) => v.fmt(f),
701        }
702    }
703}
704
705impl From<Raw> for AnimationTimingFunction {
706    fn from(v: Raw) -> Self {
707        Self::Raw(v)
708    }
709}
710
711/// A value of [`animation-trigger`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/animation-trigger).
712#[derive(Debug, Clone, PartialEq)]
713#[non_exhaustive]
714pub enum AnimationTrigger {
715    /// `none`.
716    None,
717    /// Any other value, passed through unchecked.
718    Raw(Raw),
719}
720
721impl fmt::Display for AnimationTrigger {
722    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
723        match self {
724            Self::None => f.write_str("none"),
725            Self::Raw(v) => v.fmt(f),
726        }
727    }
728}
729
730impl From<Raw> for AnimationTrigger {
731    fn from(v: Raw) -> Self {
732        Self::Raw(v)
733    }
734}
735
736/// A value of [`appearance`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/appearance).
737#[derive(Debug, Clone, PartialEq)]
738#[non_exhaustive]
739pub enum Appearance {
740    /// `auto`.
741    Auto,
742    /// `base-select`.
743    BaseSelect,
744    /// `button`.
745    Button,
746    /// `checkbox`.
747    Checkbox,
748    /// `listbox`.
749    Listbox,
750    /// `menulist`.
751    Menulist,
752    /// `menulist-button`.
753    MenulistButton,
754    /// `meter`.
755    Meter,
756    /// `none`.
757    None,
758    /// `progress-bar`.
759    ProgressBar,
760    /// `radio`.
761    Radio,
762    /// `searchfield`.
763    Searchfield,
764    /// `textarea`.
765    Textarea,
766    /// `textfield`.
767    Textfield,
768}
769
770impl fmt::Display for Appearance {
771    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
772        match self {
773            Self::Auto => f.write_str("auto"),
774            Self::BaseSelect => f.write_str("base-select"),
775            Self::Button => f.write_str("button"),
776            Self::Checkbox => f.write_str("checkbox"),
777            Self::Listbox => f.write_str("listbox"),
778            Self::Menulist => f.write_str("menulist"),
779            Self::MenulistButton => f.write_str("menulist-button"),
780            Self::Meter => f.write_str("meter"),
781            Self::None => f.write_str("none"),
782            Self::ProgressBar => f.write_str("progress-bar"),
783            Self::Radio => f.write_str("radio"),
784            Self::Searchfield => f.write_str("searchfield"),
785            Self::Textarea => f.write_str("textarea"),
786            Self::Textfield => f.write_str("textfield"),
787        }
788    }
789}
790
791/// A value of [`aspect-ratio`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/aspect-ratio).
792#[derive(Debug, Clone, PartialEq)]
793#[non_exhaustive]
794pub enum AspectRatio {
795    /// `auto`.
796    Auto,
797    /// A number.
798    Number(f64),
799    /// Any other value, passed through unchecked.
800    Raw(Raw),
801}
802
803impl fmt::Display for AspectRatio {
804    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
805        match self {
806            Self::Auto => f.write_str("auto"),
807            Self::Number(v) => v.fmt(f),
808            Self::Raw(v) => v.fmt(f),
809        }
810    }
811}
812
813impl From<f64> for AspectRatio {
814    fn from(v: f64) -> Self {
815        Self::Number(v)
816    }
817}
818
819impl From<i32> for AspectRatio {
820    fn from(v: i32) -> Self {
821        Self::Number(f64::from(v))
822    }
823}
824
825impl From<Raw> for AspectRatio {
826    fn from(v: Raw) -> Self {
827        Self::Raw(v)
828    }
829}
830
831/// A value of [`backdrop-filter`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/backdrop-filter).
832#[derive(Debug, Clone, PartialEq)]
833#[non_exhaustive]
834pub enum BackdropFilter {
835    /// `none`.
836    None,
837    /// A URL.
838    Url(Url),
839    /// Any other value, passed through unchecked.
840    Raw(Raw),
841}
842
843impl fmt::Display for BackdropFilter {
844    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
845        match self {
846            Self::None => f.write_str("none"),
847            Self::Url(v) => v.fmt(f),
848            Self::Raw(v) => v.fmt(f),
849        }
850    }
851}
852
853impl From<Url> for BackdropFilter {
854    fn from(v: Url) -> Self {
855        Self::Url(v)
856    }
857}
858
859impl From<Raw> for BackdropFilter {
860    fn from(v: Raw) -> Self {
861        Self::Raw(v)
862    }
863}
864
865/// A value of [`backface-visibility`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/backface-visibility).
866#[derive(Debug, Clone, PartialEq)]
867#[non_exhaustive]
868pub enum BackfaceVisibility {
869    /// `hidden`.
870    Hidden,
871    /// `visible`.
872    Visible,
873}
874
875impl fmt::Display for BackfaceVisibility {
876    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
877        match self {
878            Self::Hidden => f.write_str("hidden"),
879            Self::Visible => f.write_str("visible"),
880        }
881    }
882}
883
884/// A value of [`background`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background).
885#[derive(Debug, Clone, PartialEq)]
886#[non_exhaustive]
887pub enum Background {
888    /// Any other value, passed through unchecked.
889    Raw(Raw),
890}
891
892impl fmt::Display for Background {
893    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
894        match self {
895            Self::Raw(v) => v.fmt(f),
896        }
897    }
898}
899
900impl From<Raw> for Background {
901    fn from(v: Raw) -> Self {
902        Self::Raw(v)
903    }
904}
905
906/// A value of [`background-attachment`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-attachment).
907#[derive(Debug, Clone, PartialEq)]
908#[non_exhaustive]
909pub enum BackgroundAttachment {
910    /// `fixed`.
911    Fixed,
912    /// `local`.
913    Local,
914    /// `scroll`.
915    Scroll,
916    /// Any other value, passed through unchecked.
917    Raw(Raw),
918}
919
920impl fmt::Display for BackgroundAttachment {
921    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
922        match self {
923            Self::Fixed => f.write_str("fixed"),
924            Self::Local => f.write_str("local"),
925            Self::Scroll => f.write_str("scroll"),
926            Self::Raw(v) => v.fmt(f),
927        }
928    }
929}
930
931impl From<Raw> for BackgroundAttachment {
932    fn from(v: Raw) -> Self {
933        Self::Raw(v)
934    }
935}
936
937/// A value of [`background-blend-mode`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-blend-mode).
938#[derive(Debug, Clone, PartialEq)]
939#[non_exhaustive]
940pub enum BackgroundBlendMode {
941    /// `color`.
942    Color,
943    /// `color-burn`.
944    ColorBurn,
945    /// `color-dodge`.
946    ColorDodge,
947    /// `darken`.
948    Darken,
949    /// `difference`.
950    Difference,
951    /// `exclusion`.
952    Exclusion,
953    /// `hard-light`.
954    HardLight,
955    /// `hue`.
956    Hue,
957    /// `lighten`.
958    Lighten,
959    /// `luminosity`.
960    Luminosity,
961    /// `multiply`.
962    Multiply,
963    /// `normal`.
964    Normal,
965    /// `overlay`.
966    Overlay,
967    /// `saturation`.
968    Saturation,
969    /// `screen`.
970    Screen,
971    /// `soft-light`.
972    SoftLight,
973    /// Any other value, passed through unchecked.
974    Raw(Raw),
975}
976
977impl fmt::Display for BackgroundBlendMode {
978    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
979        match self {
980            Self::Color => f.write_str("color"),
981            Self::ColorBurn => f.write_str("color-burn"),
982            Self::ColorDodge => f.write_str("color-dodge"),
983            Self::Darken => f.write_str("darken"),
984            Self::Difference => f.write_str("difference"),
985            Self::Exclusion => f.write_str("exclusion"),
986            Self::HardLight => f.write_str("hard-light"),
987            Self::Hue => f.write_str("hue"),
988            Self::Lighten => f.write_str("lighten"),
989            Self::Luminosity => f.write_str("luminosity"),
990            Self::Multiply => f.write_str("multiply"),
991            Self::Normal => f.write_str("normal"),
992            Self::Overlay => f.write_str("overlay"),
993            Self::Saturation => f.write_str("saturation"),
994            Self::Screen => f.write_str("screen"),
995            Self::SoftLight => f.write_str("soft-light"),
996            Self::Raw(v) => v.fmt(f),
997        }
998    }
999}
1000
1001impl From<Raw> for BackgroundBlendMode {
1002    fn from(v: Raw) -> Self {
1003        Self::Raw(v)
1004    }
1005}
1006
1007/// A value of [`background-clip`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-clip).
1008#[derive(Debug, Clone, PartialEq)]
1009#[non_exhaustive]
1010pub enum BackgroundClip {
1011    /// `border-area`.
1012    BorderArea,
1013    /// `border-box`.
1014    BorderBox,
1015    /// `content-box`.
1016    ContentBox,
1017    /// `padding-box`.
1018    PaddingBox,
1019    /// `text`.
1020    Text,
1021    /// Any other value, passed through unchecked.
1022    Raw(Raw),
1023}
1024
1025impl fmt::Display for BackgroundClip {
1026    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1027        match self {
1028            Self::BorderArea => f.write_str("border-area"),
1029            Self::BorderBox => f.write_str("border-box"),
1030            Self::ContentBox => f.write_str("content-box"),
1031            Self::PaddingBox => f.write_str("padding-box"),
1032            Self::Text => f.write_str("text"),
1033            Self::Raw(v) => v.fmt(f),
1034        }
1035    }
1036}
1037
1038impl From<Raw> for BackgroundClip {
1039    fn from(v: Raw) -> Self {
1040        Self::Raw(v)
1041    }
1042}
1043
1044/// A value of [`background-image`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-image).
1045#[derive(Debug, Clone, PartialEq)]
1046#[non_exhaustive]
1047pub enum BackgroundImage {
1048    /// `none`.
1049    None,
1050    /// A URL.
1051    Url(Url),
1052    /// Any other value, passed through unchecked.
1053    Raw(Raw),
1054}
1055
1056impl fmt::Display for BackgroundImage {
1057    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1058        match self {
1059            Self::None => f.write_str("none"),
1060            Self::Url(v) => v.fmt(f),
1061            Self::Raw(v) => v.fmt(f),
1062        }
1063    }
1064}
1065
1066impl From<Url> for BackgroundImage {
1067    fn from(v: Url) -> Self {
1068        Self::Url(v)
1069    }
1070}
1071
1072impl From<Raw> for BackgroundImage {
1073    fn from(v: Raw) -> Self {
1074        Self::Raw(v)
1075    }
1076}
1077
1078/// A value of [`background-origin`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-origin).
1079#[derive(Debug, Clone, PartialEq)]
1080#[non_exhaustive]
1081pub enum BackgroundOrigin {
1082    /// `border-box`.
1083    BorderBox,
1084    /// `content-box`.
1085    ContentBox,
1086    /// `padding-box`.
1087    PaddingBox,
1088    /// Any other value, passed through unchecked.
1089    Raw(Raw),
1090}
1091
1092impl fmt::Display for BackgroundOrigin {
1093    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1094        match self {
1095            Self::BorderBox => f.write_str("border-box"),
1096            Self::ContentBox => f.write_str("content-box"),
1097            Self::PaddingBox => f.write_str("padding-box"),
1098            Self::Raw(v) => v.fmt(f),
1099        }
1100    }
1101}
1102
1103impl From<Raw> for BackgroundOrigin {
1104    fn from(v: Raw) -> Self {
1105        Self::Raw(v)
1106    }
1107}
1108
1109/// A value of [`background-position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-position).
1110#[derive(Debug, Clone, PartialEq)]
1111#[non_exhaustive]
1112pub enum BackgroundPosition {
1113    /// `bottom`.
1114    Bottom,
1115    /// `center`.
1116    Center,
1117    /// `left`.
1118    Left,
1119    /// `right`.
1120    Right,
1121    /// `top`.
1122    Top,
1123    /// A length.
1124    Length(Length),
1125    /// A percentage.
1126    Percentage(Percentage),
1127    /// Any other value, passed through unchecked.
1128    Raw(Raw),
1129}
1130
1131impl fmt::Display for BackgroundPosition {
1132    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1133        match self {
1134            Self::Bottom => f.write_str("bottom"),
1135            Self::Center => f.write_str("center"),
1136            Self::Left => f.write_str("left"),
1137            Self::Right => f.write_str("right"),
1138            Self::Top => f.write_str("top"),
1139            Self::Length(v) => v.fmt(f),
1140            Self::Percentage(v) => v.fmt(f),
1141            Self::Raw(v) => v.fmt(f),
1142        }
1143    }
1144}
1145
1146impl From<Length> for BackgroundPosition {
1147    fn from(v: Length) -> Self {
1148        Self::Length(v)
1149    }
1150}
1151
1152impl From<Percentage> for BackgroundPosition {
1153    fn from(v: Percentage) -> Self {
1154        Self::Percentage(v)
1155    }
1156}
1157
1158impl From<Raw> for BackgroundPosition {
1159    fn from(v: Raw) -> Self {
1160        Self::Raw(v)
1161    }
1162}
1163
1164/// A value of [`background-position-x`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-position-x).
1165#[derive(Debug, Clone, PartialEq)]
1166#[non_exhaustive]
1167pub enum BackgroundPositionX {
1168    /// `center`.
1169    Center,
1170    /// `left`.
1171    Left,
1172    /// `right`.
1173    Right,
1174    /// `x-end`.
1175    XEnd,
1176    /// `x-start`.
1177    XStart,
1178    /// A length.
1179    Length(Length),
1180    /// A percentage.
1181    Percentage(Percentage),
1182    /// Any other value, passed through unchecked.
1183    Raw(Raw),
1184}
1185
1186impl fmt::Display for BackgroundPositionX {
1187    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1188        match self {
1189            Self::Center => f.write_str("center"),
1190            Self::Left => f.write_str("left"),
1191            Self::Right => f.write_str("right"),
1192            Self::XEnd => f.write_str("x-end"),
1193            Self::XStart => f.write_str("x-start"),
1194            Self::Length(v) => v.fmt(f),
1195            Self::Percentage(v) => v.fmt(f),
1196            Self::Raw(v) => v.fmt(f),
1197        }
1198    }
1199}
1200
1201impl From<Length> for BackgroundPositionX {
1202    fn from(v: Length) -> Self {
1203        Self::Length(v)
1204    }
1205}
1206
1207impl From<Percentage> for BackgroundPositionX {
1208    fn from(v: Percentage) -> Self {
1209        Self::Percentage(v)
1210    }
1211}
1212
1213impl From<Raw> for BackgroundPositionX {
1214    fn from(v: Raw) -> Self {
1215        Self::Raw(v)
1216    }
1217}
1218
1219/// A value of [`background-position-y`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-position-y).
1220#[derive(Debug, Clone, PartialEq)]
1221#[non_exhaustive]
1222pub enum BackgroundPositionY {
1223    /// `bottom`.
1224    Bottom,
1225    /// `center`.
1226    Center,
1227    /// `top`.
1228    Top,
1229    /// `y-end`.
1230    YEnd,
1231    /// `y-start`.
1232    YStart,
1233    /// A length.
1234    Length(Length),
1235    /// A percentage.
1236    Percentage(Percentage),
1237    /// Any other value, passed through unchecked.
1238    Raw(Raw),
1239}
1240
1241impl fmt::Display for BackgroundPositionY {
1242    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1243        match self {
1244            Self::Bottom => f.write_str("bottom"),
1245            Self::Center => f.write_str("center"),
1246            Self::Top => f.write_str("top"),
1247            Self::YEnd => f.write_str("y-end"),
1248            Self::YStart => f.write_str("y-start"),
1249            Self::Length(v) => v.fmt(f),
1250            Self::Percentage(v) => v.fmt(f),
1251            Self::Raw(v) => v.fmt(f),
1252        }
1253    }
1254}
1255
1256impl From<Length> for BackgroundPositionY {
1257    fn from(v: Length) -> Self {
1258        Self::Length(v)
1259    }
1260}
1261
1262impl From<Percentage> for BackgroundPositionY {
1263    fn from(v: Percentage) -> Self {
1264        Self::Percentage(v)
1265    }
1266}
1267
1268impl From<Raw> for BackgroundPositionY {
1269    fn from(v: Raw) -> Self {
1270        Self::Raw(v)
1271    }
1272}
1273
1274/// A value of [`background-repeat`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-repeat).
1275#[derive(Debug, Clone, PartialEq)]
1276#[non_exhaustive]
1277pub enum BackgroundRepeat {
1278    /// `no-repeat`.
1279    NoRepeat,
1280    /// `repeat`.
1281    Repeat,
1282    /// `repeat-x`.
1283    RepeatX,
1284    /// `repeat-y`.
1285    RepeatY,
1286    /// `round`.
1287    Round,
1288    /// `space`.
1289    Space,
1290    /// Any other value, passed through unchecked.
1291    Raw(Raw),
1292}
1293
1294impl fmt::Display for BackgroundRepeat {
1295    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1296        match self {
1297            Self::NoRepeat => f.write_str("no-repeat"),
1298            Self::Repeat => f.write_str("repeat"),
1299            Self::RepeatX => f.write_str("repeat-x"),
1300            Self::RepeatY => f.write_str("repeat-y"),
1301            Self::Round => f.write_str("round"),
1302            Self::Space => f.write_str("space"),
1303            Self::Raw(v) => v.fmt(f),
1304        }
1305    }
1306}
1307
1308impl From<Raw> for BackgroundRepeat {
1309    fn from(v: Raw) -> Self {
1310        Self::Raw(v)
1311    }
1312}
1313
1314/// A value of [`background-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/background-size).
1315#[derive(Debug, Clone, PartialEq)]
1316#[non_exhaustive]
1317pub enum BackgroundSize {
1318    /// `auto`.
1319    Auto,
1320    /// `contain`.
1321    Contain,
1322    /// `cover`.
1323    Cover,
1324    /// A length.
1325    Length(Length),
1326    /// A percentage.
1327    Percentage(Percentage),
1328    /// Any other value, passed through unchecked.
1329    Raw(Raw),
1330}
1331
1332impl fmt::Display for BackgroundSize {
1333    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1334        match self {
1335            Self::Auto => f.write_str("auto"),
1336            Self::Contain => f.write_str("contain"),
1337            Self::Cover => f.write_str("cover"),
1338            Self::Length(v) => v.fmt(f),
1339            Self::Percentage(v) => v.fmt(f),
1340            Self::Raw(v) => v.fmt(f),
1341        }
1342    }
1343}
1344
1345impl From<Length> for BackgroundSize {
1346    fn from(v: Length) -> Self {
1347        Self::Length(v)
1348    }
1349}
1350
1351impl From<Percentage> for BackgroundSize {
1352    fn from(v: Percentage) -> Self {
1353        Self::Percentage(v)
1354    }
1355}
1356
1357impl From<Raw> for BackgroundSize {
1358    fn from(v: Raw) -> Self {
1359        Self::Raw(v)
1360    }
1361}
1362
1363/// A value of [`baseline-shift`]().
1364#[derive(Debug, Clone, PartialEq)]
1365#[non_exhaustive]
1366pub enum BaselineShift {
1367    /// `baseline`.
1368    Baseline,
1369    /// `sub`.
1370    Sub,
1371    /// `super`.
1372    Super,
1373    /// A length.
1374    Length(Length),
1375    /// A percentage.
1376    Percentage(Percentage),
1377}
1378
1379impl fmt::Display for BaselineShift {
1380    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1381        match self {
1382            Self::Baseline => f.write_str("baseline"),
1383            Self::Sub => f.write_str("sub"),
1384            Self::Super => f.write_str("super"),
1385            Self::Length(v) => v.fmt(f),
1386            Self::Percentage(v) => v.fmt(f),
1387        }
1388    }
1389}
1390
1391impl From<Length> for BaselineShift {
1392    fn from(v: Length) -> Self {
1393        Self::Length(v)
1394    }
1395}
1396
1397impl From<Percentage> for BaselineShift {
1398    fn from(v: Percentage) -> Self {
1399        Self::Percentage(v)
1400    }
1401}
1402
1403/// A value of [`baseline-source`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/baseline-source).
1404#[derive(Debug, Clone, PartialEq)]
1405#[non_exhaustive]
1406pub enum BaselineSource {
1407    /// `auto`.
1408    Auto,
1409    /// `first`.
1410    First,
1411    /// `last`.
1412    Last,
1413}
1414
1415impl fmt::Display for BaselineSource {
1416    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1417        match self {
1418            Self::Auto => f.write_str("auto"),
1419            Self::First => f.write_str("first"),
1420            Self::Last => f.write_str("last"),
1421        }
1422    }
1423}
1424
1425/// A value of [`block-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/block-size).
1426#[derive(Debug, Clone, PartialEq)]
1427#[non_exhaustive]
1428pub enum BlockSize {
1429    /// `auto`.
1430    Auto,
1431    /// `fit-content`.
1432    FitContent,
1433    /// `max-content`.
1434    MaxContent,
1435    /// `min-content`.
1436    MinContent,
1437    /// A length.
1438    Length(Length),
1439    /// A percentage.
1440    Percentage(Percentage),
1441    /// Any other value, passed through unchecked.
1442    Raw(Raw),
1443}
1444
1445impl fmt::Display for BlockSize {
1446    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1447        match self {
1448            Self::Auto => f.write_str("auto"),
1449            Self::FitContent => f.write_str("fit-content"),
1450            Self::MaxContent => f.write_str("max-content"),
1451            Self::MinContent => f.write_str("min-content"),
1452            Self::Length(v) => v.fmt(f),
1453            Self::Percentage(v) => v.fmt(f),
1454            Self::Raw(v) => v.fmt(f),
1455        }
1456    }
1457}
1458
1459impl From<Length> for BlockSize {
1460    fn from(v: Length) -> Self {
1461        Self::Length(v)
1462    }
1463}
1464
1465impl From<Percentage> for BlockSize {
1466    fn from(v: Percentage) -> Self {
1467        Self::Percentage(v)
1468    }
1469}
1470
1471impl From<Raw> for BlockSize {
1472    fn from(v: Raw) -> Self {
1473        Self::Raw(v)
1474    }
1475}
1476
1477/// A value of [`border`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border).
1478#[derive(Debug, Clone, PartialEq)]
1479#[non_exhaustive]
1480pub enum Border {
1481    /// `dashed`.
1482    Dashed,
1483    /// `dotted`.
1484    Dotted,
1485    /// `double`.
1486    Double,
1487    /// `groove`.
1488    Groove,
1489    /// `hidden`.
1490    Hidden,
1491    /// `inset`.
1492    Inset,
1493    /// `medium`.
1494    Medium,
1495    /// `none`.
1496    None,
1497    /// `outset`.
1498    Outset,
1499    /// `ridge`.
1500    Ridge,
1501    /// `solid`.
1502    Solid,
1503    /// `thick`.
1504    Thick,
1505    /// `thin`.
1506    Thin,
1507    /// A length.
1508    Length(Length),
1509    /// A color.
1510    Color(Color),
1511    /// Any other value, passed through unchecked.
1512    Raw(Raw),
1513}
1514
1515impl fmt::Display for Border {
1516    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1517        match self {
1518            Self::Dashed => f.write_str("dashed"),
1519            Self::Dotted => f.write_str("dotted"),
1520            Self::Double => f.write_str("double"),
1521            Self::Groove => f.write_str("groove"),
1522            Self::Hidden => f.write_str("hidden"),
1523            Self::Inset => f.write_str("inset"),
1524            Self::Medium => f.write_str("medium"),
1525            Self::None => f.write_str("none"),
1526            Self::Outset => f.write_str("outset"),
1527            Self::Ridge => f.write_str("ridge"),
1528            Self::Solid => f.write_str("solid"),
1529            Self::Thick => f.write_str("thick"),
1530            Self::Thin => f.write_str("thin"),
1531            Self::Length(v) => v.fmt(f),
1532            Self::Color(v) => v.fmt(f),
1533            Self::Raw(v) => v.fmt(f),
1534        }
1535    }
1536}
1537
1538impl From<Length> for Border {
1539    fn from(v: Length) -> Self {
1540        Self::Length(v)
1541    }
1542}
1543
1544impl From<Color> for Border {
1545    fn from(v: Color) -> Self {
1546        Self::Color(v)
1547    }
1548}
1549
1550impl From<Raw> for Border {
1551    fn from(v: Raw) -> Self {
1552        Self::Raw(v)
1553    }
1554}
1555
1556/// A value of [`border-block`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block).
1557#[derive(Debug, Clone, PartialEq)]
1558#[non_exhaustive]
1559pub enum BorderBlock {
1560    /// `dashed`.
1561    Dashed,
1562    /// `dotted`.
1563    Dotted,
1564    /// `double`.
1565    Double,
1566    /// `groove`.
1567    Groove,
1568    /// `hidden`.
1569    Hidden,
1570    /// `inset`.
1571    Inset,
1572    /// `medium`.
1573    Medium,
1574    /// `none`.
1575    None,
1576    /// `outset`.
1577    Outset,
1578    /// `ridge`.
1579    Ridge,
1580    /// `solid`.
1581    Solid,
1582    /// `thick`.
1583    Thick,
1584    /// `thin`.
1585    Thin,
1586    /// A length.
1587    Length(Length),
1588    /// A color.
1589    Color(Color),
1590    /// Any other value, passed through unchecked.
1591    Raw(Raw),
1592}
1593
1594impl fmt::Display for BorderBlock {
1595    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1596        match self {
1597            Self::Dashed => f.write_str("dashed"),
1598            Self::Dotted => f.write_str("dotted"),
1599            Self::Double => f.write_str("double"),
1600            Self::Groove => f.write_str("groove"),
1601            Self::Hidden => f.write_str("hidden"),
1602            Self::Inset => f.write_str("inset"),
1603            Self::Medium => f.write_str("medium"),
1604            Self::None => f.write_str("none"),
1605            Self::Outset => f.write_str("outset"),
1606            Self::Ridge => f.write_str("ridge"),
1607            Self::Solid => f.write_str("solid"),
1608            Self::Thick => f.write_str("thick"),
1609            Self::Thin => f.write_str("thin"),
1610            Self::Length(v) => v.fmt(f),
1611            Self::Color(v) => v.fmt(f),
1612            Self::Raw(v) => v.fmt(f),
1613        }
1614    }
1615}
1616
1617impl From<Length> for BorderBlock {
1618    fn from(v: Length) -> Self {
1619        Self::Length(v)
1620    }
1621}
1622
1623impl From<Color> for BorderBlock {
1624    fn from(v: Color) -> Self {
1625        Self::Color(v)
1626    }
1627}
1628
1629impl From<Raw> for BorderBlock {
1630    fn from(v: Raw) -> Self {
1631        Self::Raw(v)
1632    }
1633}
1634
1635/// A value of [`border-block-color`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block-color).
1636#[derive(Debug, Clone, PartialEq)]
1637#[non_exhaustive]
1638pub enum BorderBlockColor {
1639    /// A color.
1640    Color(Color),
1641    /// Any other value, passed through unchecked.
1642    Raw(Raw),
1643}
1644
1645impl fmt::Display for BorderBlockColor {
1646    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1647        match self {
1648            Self::Color(v) => v.fmt(f),
1649            Self::Raw(v) => v.fmt(f),
1650        }
1651    }
1652}
1653
1654impl From<Color> for BorderBlockColor {
1655    fn from(v: Color) -> Self {
1656        Self::Color(v)
1657    }
1658}
1659
1660impl From<Raw> for BorderBlockColor {
1661    fn from(v: Raw) -> Self {
1662        Self::Raw(v)
1663    }
1664}
1665
1666/// A value of [`border-block-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block-end).
1667#[derive(Debug, Clone, PartialEq)]
1668#[non_exhaustive]
1669pub enum BorderBlockEnd {
1670    /// `dashed`.
1671    Dashed,
1672    /// `dotted`.
1673    Dotted,
1674    /// `double`.
1675    Double,
1676    /// `groove`.
1677    Groove,
1678    /// `hidden`.
1679    Hidden,
1680    /// `inset`.
1681    Inset,
1682    /// `medium`.
1683    Medium,
1684    /// `none`.
1685    None,
1686    /// `outset`.
1687    Outset,
1688    /// `ridge`.
1689    Ridge,
1690    /// `solid`.
1691    Solid,
1692    /// `thick`.
1693    Thick,
1694    /// `thin`.
1695    Thin,
1696    /// A length.
1697    Length(Length),
1698    /// A color.
1699    Color(Color),
1700    /// Any other value, passed through unchecked.
1701    Raw(Raw),
1702}
1703
1704impl fmt::Display for BorderBlockEnd {
1705    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1706        match self {
1707            Self::Dashed => f.write_str("dashed"),
1708            Self::Dotted => f.write_str("dotted"),
1709            Self::Double => f.write_str("double"),
1710            Self::Groove => f.write_str("groove"),
1711            Self::Hidden => f.write_str("hidden"),
1712            Self::Inset => f.write_str("inset"),
1713            Self::Medium => f.write_str("medium"),
1714            Self::None => f.write_str("none"),
1715            Self::Outset => f.write_str("outset"),
1716            Self::Ridge => f.write_str("ridge"),
1717            Self::Solid => f.write_str("solid"),
1718            Self::Thick => f.write_str("thick"),
1719            Self::Thin => f.write_str("thin"),
1720            Self::Length(v) => v.fmt(f),
1721            Self::Color(v) => v.fmt(f),
1722            Self::Raw(v) => v.fmt(f),
1723        }
1724    }
1725}
1726
1727impl From<Length> for BorderBlockEnd {
1728    fn from(v: Length) -> Self {
1729        Self::Length(v)
1730    }
1731}
1732
1733impl From<Color> for BorderBlockEnd {
1734    fn from(v: Color) -> Self {
1735        Self::Color(v)
1736    }
1737}
1738
1739impl From<Raw> for BorderBlockEnd {
1740    fn from(v: Raw) -> Self {
1741        Self::Raw(v)
1742    }
1743}
1744
1745/// A value of [`border-block-end-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block-end-style).
1746#[derive(Debug, Clone, PartialEq)]
1747#[non_exhaustive]
1748pub enum BorderBlockEndStyle {
1749    /// `dashed`.
1750    Dashed,
1751    /// `dotted`.
1752    Dotted,
1753    /// `double`.
1754    Double,
1755    /// `groove`.
1756    Groove,
1757    /// `hidden`.
1758    Hidden,
1759    /// `inset`.
1760    Inset,
1761    /// `none`.
1762    None,
1763    /// `outset`.
1764    Outset,
1765    /// `ridge`.
1766    Ridge,
1767    /// `solid`.
1768    Solid,
1769}
1770
1771impl fmt::Display for BorderBlockEndStyle {
1772    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1773        match self {
1774            Self::Dashed => f.write_str("dashed"),
1775            Self::Dotted => f.write_str("dotted"),
1776            Self::Double => f.write_str("double"),
1777            Self::Groove => f.write_str("groove"),
1778            Self::Hidden => f.write_str("hidden"),
1779            Self::Inset => f.write_str("inset"),
1780            Self::None => f.write_str("none"),
1781            Self::Outset => f.write_str("outset"),
1782            Self::Ridge => f.write_str("ridge"),
1783            Self::Solid => f.write_str("solid"),
1784        }
1785    }
1786}
1787
1788/// A value of [`border-block-end-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block-end-width).
1789#[derive(Debug, Clone, PartialEq)]
1790#[non_exhaustive]
1791pub enum BorderBlockEndWidth {
1792    /// `medium`.
1793    Medium,
1794    /// `thick`.
1795    Thick,
1796    /// `thin`.
1797    Thin,
1798    /// A length.
1799    Length(Length),
1800}
1801
1802impl fmt::Display for BorderBlockEndWidth {
1803    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1804        match self {
1805            Self::Medium => f.write_str("medium"),
1806            Self::Thick => f.write_str("thick"),
1807            Self::Thin => f.write_str("thin"),
1808            Self::Length(v) => v.fmt(f),
1809        }
1810    }
1811}
1812
1813impl From<Length> for BorderBlockEndWidth {
1814    fn from(v: Length) -> Self {
1815        Self::Length(v)
1816    }
1817}
1818
1819/// A value of [`border-block-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block-start).
1820#[derive(Debug, Clone, PartialEq)]
1821#[non_exhaustive]
1822pub enum BorderBlockStart {
1823    /// `dashed`.
1824    Dashed,
1825    /// `dotted`.
1826    Dotted,
1827    /// `double`.
1828    Double,
1829    /// `groove`.
1830    Groove,
1831    /// `hidden`.
1832    Hidden,
1833    /// `inset`.
1834    Inset,
1835    /// `medium`.
1836    Medium,
1837    /// `none`.
1838    None,
1839    /// `outset`.
1840    Outset,
1841    /// `ridge`.
1842    Ridge,
1843    /// `solid`.
1844    Solid,
1845    /// `thick`.
1846    Thick,
1847    /// `thin`.
1848    Thin,
1849    /// A length.
1850    Length(Length),
1851    /// A color.
1852    Color(Color),
1853    /// Any other value, passed through unchecked.
1854    Raw(Raw),
1855}
1856
1857impl fmt::Display for BorderBlockStart {
1858    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1859        match self {
1860            Self::Dashed => f.write_str("dashed"),
1861            Self::Dotted => f.write_str("dotted"),
1862            Self::Double => f.write_str("double"),
1863            Self::Groove => f.write_str("groove"),
1864            Self::Hidden => f.write_str("hidden"),
1865            Self::Inset => f.write_str("inset"),
1866            Self::Medium => f.write_str("medium"),
1867            Self::None => f.write_str("none"),
1868            Self::Outset => f.write_str("outset"),
1869            Self::Ridge => f.write_str("ridge"),
1870            Self::Solid => f.write_str("solid"),
1871            Self::Thick => f.write_str("thick"),
1872            Self::Thin => f.write_str("thin"),
1873            Self::Length(v) => v.fmt(f),
1874            Self::Color(v) => v.fmt(f),
1875            Self::Raw(v) => v.fmt(f),
1876        }
1877    }
1878}
1879
1880impl From<Length> for BorderBlockStart {
1881    fn from(v: Length) -> Self {
1882        Self::Length(v)
1883    }
1884}
1885
1886impl From<Color> for BorderBlockStart {
1887    fn from(v: Color) -> Self {
1888        Self::Color(v)
1889    }
1890}
1891
1892impl From<Raw> for BorderBlockStart {
1893    fn from(v: Raw) -> Self {
1894        Self::Raw(v)
1895    }
1896}
1897
1898/// A value of [`border-block-start-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block-start-style).
1899#[derive(Debug, Clone, PartialEq)]
1900#[non_exhaustive]
1901pub enum BorderBlockStartStyle {
1902    /// `dashed`.
1903    Dashed,
1904    /// `dotted`.
1905    Dotted,
1906    /// `double`.
1907    Double,
1908    /// `groove`.
1909    Groove,
1910    /// `hidden`.
1911    Hidden,
1912    /// `inset`.
1913    Inset,
1914    /// `none`.
1915    None,
1916    /// `outset`.
1917    Outset,
1918    /// `ridge`.
1919    Ridge,
1920    /// `solid`.
1921    Solid,
1922}
1923
1924impl fmt::Display for BorderBlockStartStyle {
1925    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1926        match self {
1927            Self::Dashed => f.write_str("dashed"),
1928            Self::Dotted => f.write_str("dotted"),
1929            Self::Double => f.write_str("double"),
1930            Self::Groove => f.write_str("groove"),
1931            Self::Hidden => f.write_str("hidden"),
1932            Self::Inset => f.write_str("inset"),
1933            Self::None => f.write_str("none"),
1934            Self::Outset => f.write_str("outset"),
1935            Self::Ridge => f.write_str("ridge"),
1936            Self::Solid => f.write_str("solid"),
1937        }
1938    }
1939}
1940
1941/// A value of [`border-block-start-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block-start-width).
1942#[derive(Debug, Clone, PartialEq)]
1943#[non_exhaustive]
1944pub enum BorderBlockStartWidth {
1945    /// `medium`.
1946    Medium,
1947    /// `thick`.
1948    Thick,
1949    /// `thin`.
1950    Thin,
1951    /// A length.
1952    Length(Length),
1953}
1954
1955impl fmt::Display for BorderBlockStartWidth {
1956    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1957        match self {
1958            Self::Medium => f.write_str("medium"),
1959            Self::Thick => f.write_str("thick"),
1960            Self::Thin => f.write_str("thin"),
1961            Self::Length(v) => v.fmt(f),
1962        }
1963    }
1964}
1965
1966impl From<Length> for BorderBlockStartWidth {
1967    fn from(v: Length) -> Self {
1968        Self::Length(v)
1969    }
1970}
1971
1972/// A value of [`border-block-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block-style).
1973#[derive(Debug, Clone, PartialEq)]
1974#[non_exhaustive]
1975pub enum BorderBlockStyle {
1976    /// `dashed`.
1977    Dashed,
1978    /// `dotted`.
1979    Dotted,
1980    /// `double`.
1981    Double,
1982    /// `groove`.
1983    Groove,
1984    /// `hidden`.
1985    Hidden,
1986    /// `inset`.
1987    Inset,
1988    /// `none`.
1989    None,
1990    /// `outset`.
1991    Outset,
1992    /// `ridge`.
1993    Ridge,
1994    /// `solid`.
1995    Solid,
1996    /// Any other value, passed through unchecked.
1997    Raw(Raw),
1998}
1999
2000impl fmt::Display for BorderBlockStyle {
2001    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2002        match self {
2003            Self::Dashed => f.write_str("dashed"),
2004            Self::Dotted => f.write_str("dotted"),
2005            Self::Double => f.write_str("double"),
2006            Self::Groove => f.write_str("groove"),
2007            Self::Hidden => f.write_str("hidden"),
2008            Self::Inset => f.write_str("inset"),
2009            Self::None => f.write_str("none"),
2010            Self::Outset => f.write_str("outset"),
2011            Self::Ridge => f.write_str("ridge"),
2012            Self::Solid => f.write_str("solid"),
2013            Self::Raw(v) => v.fmt(f),
2014        }
2015    }
2016}
2017
2018impl From<Raw> for BorderBlockStyle {
2019    fn from(v: Raw) -> Self {
2020        Self::Raw(v)
2021    }
2022}
2023
2024/// A value of [`border-block-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-block-width).
2025#[derive(Debug, Clone, PartialEq)]
2026#[non_exhaustive]
2027pub enum BorderBlockWidth {
2028    /// `medium`.
2029    Medium,
2030    /// `thick`.
2031    Thick,
2032    /// `thin`.
2033    Thin,
2034    /// A length.
2035    Length(Length),
2036    /// Any other value, passed through unchecked.
2037    Raw(Raw),
2038}
2039
2040impl fmt::Display for BorderBlockWidth {
2041    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2042        match self {
2043            Self::Medium => f.write_str("medium"),
2044            Self::Thick => f.write_str("thick"),
2045            Self::Thin => f.write_str("thin"),
2046            Self::Length(v) => v.fmt(f),
2047            Self::Raw(v) => v.fmt(f),
2048        }
2049    }
2050}
2051
2052impl From<Length> for BorderBlockWidth {
2053    fn from(v: Length) -> Self {
2054        Self::Length(v)
2055    }
2056}
2057
2058impl From<Raw> for BorderBlockWidth {
2059    fn from(v: Raw) -> Self {
2060        Self::Raw(v)
2061    }
2062}
2063
2064/// A value of [`border-bottom`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-bottom).
2065#[derive(Debug, Clone, PartialEq)]
2066#[non_exhaustive]
2067pub enum BorderBottom {
2068    /// `dashed`.
2069    Dashed,
2070    /// `dotted`.
2071    Dotted,
2072    /// `double`.
2073    Double,
2074    /// `groove`.
2075    Groove,
2076    /// `hidden`.
2077    Hidden,
2078    /// `inset`.
2079    Inset,
2080    /// `medium`.
2081    Medium,
2082    /// `none`.
2083    None,
2084    /// `outset`.
2085    Outset,
2086    /// `ridge`.
2087    Ridge,
2088    /// `solid`.
2089    Solid,
2090    /// `thick`.
2091    Thick,
2092    /// `thin`.
2093    Thin,
2094    /// A length.
2095    Length(Length),
2096    /// A color.
2097    Color(Color),
2098    /// Any other value, passed through unchecked.
2099    Raw(Raw),
2100}
2101
2102impl fmt::Display for BorderBottom {
2103    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2104        match self {
2105            Self::Dashed => f.write_str("dashed"),
2106            Self::Dotted => f.write_str("dotted"),
2107            Self::Double => f.write_str("double"),
2108            Self::Groove => f.write_str("groove"),
2109            Self::Hidden => f.write_str("hidden"),
2110            Self::Inset => f.write_str("inset"),
2111            Self::Medium => f.write_str("medium"),
2112            Self::None => f.write_str("none"),
2113            Self::Outset => f.write_str("outset"),
2114            Self::Ridge => f.write_str("ridge"),
2115            Self::Solid => f.write_str("solid"),
2116            Self::Thick => f.write_str("thick"),
2117            Self::Thin => f.write_str("thin"),
2118            Self::Length(v) => v.fmt(f),
2119            Self::Color(v) => v.fmt(f),
2120            Self::Raw(v) => v.fmt(f),
2121        }
2122    }
2123}
2124
2125impl From<Length> for BorderBottom {
2126    fn from(v: Length) -> Self {
2127        Self::Length(v)
2128    }
2129}
2130
2131impl From<Color> for BorderBottom {
2132    fn from(v: Color) -> Self {
2133        Self::Color(v)
2134    }
2135}
2136
2137impl From<Raw> for BorderBottom {
2138    fn from(v: Raw) -> Self {
2139        Self::Raw(v)
2140    }
2141}
2142
2143/// A value of [`border-bottom-left-radius`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-bottom-left-radius).
2144#[derive(Debug, Clone, PartialEq)]
2145#[non_exhaustive]
2146pub enum BorderBottomLeftRadius {
2147    /// A length.
2148    Length(Length),
2149    /// A percentage.
2150    Percentage(Percentage),
2151    /// Any other value, passed through unchecked.
2152    Raw(Raw),
2153}
2154
2155impl fmt::Display for BorderBottomLeftRadius {
2156    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2157        match self {
2158            Self::Length(v) => v.fmt(f),
2159            Self::Percentage(v) => v.fmt(f),
2160            Self::Raw(v) => v.fmt(f),
2161        }
2162    }
2163}
2164
2165impl From<Length> for BorderBottomLeftRadius {
2166    fn from(v: Length) -> Self {
2167        Self::Length(v)
2168    }
2169}
2170
2171impl From<Percentage> for BorderBottomLeftRadius {
2172    fn from(v: Percentage) -> Self {
2173        Self::Percentage(v)
2174    }
2175}
2176
2177impl From<Raw> for BorderBottomLeftRadius {
2178    fn from(v: Raw) -> Self {
2179        Self::Raw(v)
2180    }
2181}
2182
2183/// A value of [`border-bottom-right-radius`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-bottom-right-radius).
2184#[derive(Debug, Clone, PartialEq)]
2185#[non_exhaustive]
2186pub enum BorderBottomRightRadius {
2187    /// A length.
2188    Length(Length),
2189    /// A percentage.
2190    Percentage(Percentage),
2191    /// Any other value, passed through unchecked.
2192    Raw(Raw),
2193}
2194
2195impl fmt::Display for BorderBottomRightRadius {
2196    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2197        match self {
2198            Self::Length(v) => v.fmt(f),
2199            Self::Percentage(v) => v.fmt(f),
2200            Self::Raw(v) => v.fmt(f),
2201        }
2202    }
2203}
2204
2205impl From<Length> for BorderBottomRightRadius {
2206    fn from(v: Length) -> Self {
2207        Self::Length(v)
2208    }
2209}
2210
2211impl From<Percentage> for BorderBottomRightRadius {
2212    fn from(v: Percentage) -> Self {
2213        Self::Percentage(v)
2214    }
2215}
2216
2217impl From<Raw> for BorderBottomRightRadius {
2218    fn from(v: Raw) -> Self {
2219        Self::Raw(v)
2220    }
2221}
2222
2223/// A value of [`border-bottom-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-bottom-style).
2224#[derive(Debug, Clone, PartialEq)]
2225#[non_exhaustive]
2226pub enum BorderBottomStyle {
2227    /// `dashed`.
2228    Dashed,
2229    /// `dotted`.
2230    Dotted,
2231    /// `double`.
2232    Double,
2233    /// `groove`.
2234    Groove,
2235    /// `hidden`.
2236    Hidden,
2237    /// `inset`.
2238    Inset,
2239    /// `none`.
2240    None,
2241    /// `outset`.
2242    Outset,
2243    /// `ridge`.
2244    Ridge,
2245    /// `solid`.
2246    Solid,
2247}
2248
2249impl fmt::Display for BorderBottomStyle {
2250    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2251        match self {
2252            Self::Dashed => f.write_str("dashed"),
2253            Self::Dotted => f.write_str("dotted"),
2254            Self::Double => f.write_str("double"),
2255            Self::Groove => f.write_str("groove"),
2256            Self::Hidden => f.write_str("hidden"),
2257            Self::Inset => f.write_str("inset"),
2258            Self::None => f.write_str("none"),
2259            Self::Outset => f.write_str("outset"),
2260            Self::Ridge => f.write_str("ridge"),
2261            Self::Solid => f.write_str("solid"),
2262        }
2263    }
2264}
2265
2266/// A value of [`border-bottom-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-bottom-width).
2267#[derive(Debug, Clone, PartialEq)]
2268#[non_exhaustive]
2269pub enum BorderBottomWidth {
2270    /// `medium`.
2271    Medium,
2272    /// `thick`.
2273    Thick,
2274    /// `thin`.
2275    Thin,
2276    /// A length.
2277    Length(Length),
2278}
2279
2280impl fmt::Display for BorderBottomWidth {
2281    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2282        match self {
2283            Self::Medium => f.write_str("medium"),
2284            Self::Thick => f.write_str("thick"),
2285            Self::Thin => f.write_str("thin"),
2286            Self::Length(v) => v.fmt(f),
2287        }
2288    }
2289}
2290
2291impl From<Length> for BorderBottomWidth {
2292    fn from(v: Length) -> Self {
2293        Self::Length(v)
2294    }
2295}
2296
2297/// A value of [`border-collapse`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-collapse).
2298#[derive(Debug, Clone, PartialEq)]
2299#[non_exhaustive]
2300pub enum BorderCollapse {
2301    /// `collapse`.
2302    Collapse,
2303    /// `separate`.
2304    Separate,
2305}
2306
2307impl fmt::Display for BorderCollapse {
2308    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2309        match self {
2310            Self::Collapse => f.write_str("collapse"),
2311            Self::Separate => f.write_str("separate"),
2312        }
2313    }
2314}
2315
2316/// A value of [`border-color`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-color).
2317#[derive(Debug, Clone, PartialEq)]
2318#[non_exhaustive]
2319pub enum BorderColor {
2320    /// A color.
2321    Color(Color),
2322    /// Any other value, passed through unchecked.
2323    Raw(Raw),
2324}
2325
2326impl fmt::Display for BorderColor {
2327    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2328        match self {
2329            Self::Color(v) => v.fmt(f),
2330            Self::Raw(v) => v.fmt(f),
2331        }
2332    }
2333}
2334
2335impl From<Color> for BorderColor {
2336    fn from(v: Color) -> Self {
2337        Self::Color(v)
2338    }
2339}
2340
2341impl From<Raw> for BorderColor {
2342    fn from(v: Raw) -> Self {
2343        Self::Raw(v)
2344    }
2345}
2346
2347/// A value of [`border-end-end-radius`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-end-end-radius).
2348#[derive(Debug, Clone, PartialEq)]
2349#[non_exhaustive]
2350pub enum BorderEndEndRadius {
2351    /// A length.
2352    Length(Length),
2353    /// A percentage.
2354    Percentage(Percentage),
2355    /// Any other value, passed through unchecked.
2356    Raw(Raw),
2357}
2358
2359impl fmt::Display for BorderEndEndRadius {
2360    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2361        match self {
2362            Self::Length(v) => v.fmt(f),
2363            Self::Percentage(v) => v.fmt(f),
2364            Self::Raw(v) => v.fmt(f),
2365        }
2366    }
2367}
2368
2369impl From<Length> for BorderEndEndRadius {
2370    fn from(v: Length) -> Self {
2371        Self::Length(v)
2372    }
2373}
2374
2375impl From<Percentage> for BorderEndEndRadius {
2376    fn from(v: Percentage) -> Self {
2377        Self::Percentage(v)
2378    }
2379}
2380
2381impl From<Raw> for BorderEndEndRadius {
2382    fn from(v: Raw) -> Self {
2383        Self::Raw(v)
2384    }
2385}
2386
2387/// A value of [`border-end-start-radius`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-end-start-radius).
2388#[derive(Debug, Clone, PartialEq)]
2389#[non_exhaustive]
2390pub enum BorderEndStartRadius {
2391    /// A length.
2392    Length(Length),
2393    /// A percentage.
2394    Percentage(Percentage),
2395    /// Any other value, passed through unchecked.
2396    Raw(Raw),
2397}
2398
2399impl fmt::Display for BorderEndStartRadius {
2400    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2401        match self {
2402            Self::Length(v) => v.fmt(f),
2403            Self::Percentage(v) => v.fmt(f),
2404            Self::Raw(v) => v.fmt(f),
2405        }
2406    }
2407}
2408
2409impl From<Length> for BorderEndStartRadius {
2410    fn from(v: Length) -> Self {
2411        Self::Length(v)
2412    }
2413}
2414
2415impl From<Percentage> for BorderEndStartRadius {
2416    fn from(v: Percentage) -> Self {
2417        Self::Percentage(v)
2418    }
2419}
2420
2421impl From<Raw> for BorderEndStartRadius {
2422    fn from(v: Raw) -> Self {
2423        Self::Raw(v)
2424    }
2425}
2426
2427/// A value of [`border-image`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-image).
2428#[derive(Debug, Clone, PartialEq)]
2429#[non_exhaustive]
2430pub enum BorderImage {
2431    /// `none`.
2432    None,
2433    /// `repeat`.
2434    Repeat,
2435    /// `round`.
2436    Round,
2437    /// `space`.
2438    Space,
2439    /// `stretch`.
2440    Stretch,
2441    /// A URL.
2442    Url(Url),
2443    /// Any other value, passed through unchecked.
2444    Raw(Raw),
2445}
2446
2447impl fmt::Display for BorderImage {
2448    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2449        match self {
2450            Self::None => f.write_str("none"),
2451            Self::Repeat => f.write_str("repeat"),
2452            Self::Round => f.write_str("round"),
2453            Self::Space => f.write_str("space"),
2454            Self::Stretch => f.write_str("stretch"),
2455            Self::Url(v) => v.fmt(f),
2456            Self::Raw(v) => v.fmt(f),
2457        }
2458    }
2459}
2460
2461impl From<Url> for BorderImage {
2462    fn from(v: Url) -> Self {
2463        Self::Url(v)
2464    }
2465}
2466
2467impl From<Raw> for BorderImage {
2468    fn from(v: Raw) -> Self {
2469        Self::Raw(v)
2470    }
2471}
2472
2473/// A value of [`border-image-outset`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-image-outset).
2474#[derive(Debug, Clone, PartialEq)]
2475#[non_exhaustive]
2476pub enum BorderImageOutset {
2477    /// A length.
2478    Length(Length),
2479    /// A number.
2480    Number(f64),
2481    /// Any other value, passed through unchecked.
2482    Raw(Raw),
2483}
2484
2485impl fmt::Display for BorderImageOutset {
2486    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2487        match self {
2488            Self::Length(v) => v.fmt(f),
2489            Self::Number(v) => v.fmt(f),
2490            Self::Raw(v) => v.fmt(f),
2491        }
2492    }
2493}
2494
2495impl From<Length> for BorderImageOutset {
2496    fn from(v: Length) -> Self {
2497        Self::Length(v)
2498    }
2499}
2500
2501impl From<f64> for BorderImageOutset {
2502    fn from(v: f64) -> Self {
2503        Self::Number(v)
2504    }
2505}
2506
2507impl From<i32> for BorderImageOutset {
2508    fn from(v: i32) -> Self {
2509        Self::Number(f64::from(v))
2510    }
2511}
2512
2513impl From<Raw> for BorderImageOutset {
2514    fn from(v: Raw) -> Self {
2515        Self::Raw(v)
2516    }
2517}
2518
2519/// A value of [`border-image-repeat`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-image-repeat).
2520#[derive(Debug, Clone, PartialEq)]
2521#[non_exhaustive]
2522pub enum BorderImageRepeat {
2523    /// `repeat`.
2524    Repeat,
2525    /// `round`.
2526    Round,
2527    /// `space`.
2528    Space,
2529    /// `stretch`.
2530    Stretch,
2531    /// Any other value, passed through unchecked.
2532    Raw(Raw),
2533}
2534
2535impl fmt::Display for BorderImageRepeat {
2536    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2537        match self {
2538            Self::Repeat => f.write_str("repeat"),
2539            Self::Round => f.write_str("round"),
2540            Self::Space => f.write_str("space"),
2541            Self::Stretch => f.write_str("stretch"),
2542            Self::Raw(v) => v.fmt(f),
2543        }
2544    }
2545}
2546
2547impl From<Raw> for BorderImageRepeat {
2548    fn from(v: Raw) -> Self {
2549        Self::Raw(v)
2550    }
2551}
2552
2553/// A value of [`border-image-slice`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-image-slice).
2554#[derive(Debug, Clone, PartialEq)]
2555#[non_exhaustive]
2556pub enum BorderImageSlice {
2557    /// Any other value, passed through unchecked.
2558    Raw(Raw),
2559}
2560
2561impl fmt::Display for BorderImageSlice {
2562    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2563        match self {
2564            Self::Raw(v) => v.fmt(f),
2565        }
2566    }
2567}
2568
2569impl From<Raw> for BorderImageSlice {
2570    fn from(v: Raw) -> Self {
2571        Self::Raw(v)
2572    }
2573}
2574
2575/// A value of [`border-image-source`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-image-source).
2576#[derive(Debug, Clone, PartialEq)]
2577#[non_exhaustive]
2578pub enum BorderImageSource {
2579    /// `none`.
2580    None,
2581    /// A URL.
2582    Url(Url),
2583    /// Any other value, passed through unchecked.
2584    Raw(Raw),
2585}
2586
2587impl fmt::Display for BorderImageSource {
2588    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2589        match self {
2590            Self::None => f.write_str("none"),
2591            Self::Url(v) => v.fmt(f),
2592            Self::Raw(v) => v.fmt(f),
2593        }
2594    }
2595}
2596
2597impl From<Url> for BorderImageSource {
2598    fn from(v: Url) -> Self {
2599        Self::Url(v)
2600    }
2601}
2602
2603impl From<Raw> for BorderImageSource {
2604    fn from(v: Raw) -> Self {
2605        Self::Raw(v)
2606    }
2607}
2608
2609/// A value of [`border-image-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-image-width).
2610#[derive(Debug, Clone, PartialEq)]
2611#[non_exhaustive]
2612pub enum BorderImageWidth {
2613    /// `auto`.
2614    Auto,
2615    /// A length.
2616    Length(Length),
2617    /// A percentage.
2618    Percentage(Percentage),
2619    /// A number.
2620    Number(f64),
2621    /// Any other value, passed through unchecked.
2622    Raw(Raw),
2623}
2624
2625impl fmt::Display for BorderImageWidth {
2626    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2627        match self {
2628            Self::Auto => f.write_str("auto"),
2629            Self::Length(v) => v.fmt(f),
2630            Self::Percentage(v) => v.fmt(f),
2631            Self::Number(v) => v.fmt(f),
2632            Self::Raw(v) => v.fmt(f),
2633        }
2634    }
2635}
2636
2637impl From<Length> for BorderImageWidth {
2638    fn from(v: Length) -> Self {
2639        Self::Length(v)
2640    }
2641}
2642
2643impl From<Percentage> for BorderImageWidth {
2644    fn from(v: Percentage) -> Self {
2645        Self::Percentage(v)
2646    }
2647}
2648
2649impl From<f64> for BorderImageWidth {
2650    fn from(v: f64) -> Self {
2651        Self::Number(v)
2652    }
2653}
2654
2655impl From<i32> for BorderImageWidth {
2656    fn from(v: i32) -> Self {
2657        Self::Number(f64::from(v))
2658    }
2659}
2660
2661impl From<Raw> for BorderImageWidth {
2662    fn from(v: Raw) -> Self {
2663        Self::Raw(v)
2664    }
2665}
2666
2667/// A value of [`border-inline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline).
2668#[derive(Debug, Clone, PartialEq)]
2669#[non_exhaustive]
2670pub enum BorderInline {
2671    /// `dashed`.
2672    Dashed,
2673    /// `dotted`.
2674    Dotted,
2675    /// `double`.
2676    Double,
2677    /// `groove`.
2678    Groove,
2679    /// `hidden`.
2680    Hidden,
2681    /// `inset`.
2682    Inset,
2683    /// `medium`.
2684    Medium,
2685    /// `none`.
2686    None,
2687    /// `outset`.
2688    Outset,
2689    /// `ridge`.
2690    Ridge,
2691    /// `solid`.
2692    Solid,
2693    /// `thick`.
2694    Thick,
2695    /// `thin`.
2696    Thin,
2697    /// A length.
2698    Length(Length),
2699    /// A color.
2700    Color(Color),
2701    /// Any other value, passed through unchecked.
2702    Raw(Raw),
2703}
2704
2705impl fmt::Display for BorderInline {
2706    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2707        match self {
2708            Self::Dashed => f.write_str("dashed"),
2709            Self::Dotted => f.write_str("dotted"),
2710            Self::Double => f.write_str("double"),
2711            Self::Groove => f.write_str("groove"),
2712            Self::Hidden => f.write_str("hidden"),
2713            Self::Inset => f.write_str("inset"),
2714            Self::Medium => f.write_str("medium"),
2715            Self::None => f.write_str("none"),
2716            Self::Outset => f.write_str("outset"),
2717            Self::Ridge => f.write_str("ridge"),
2718            Self::Solid => f.write_str("solid"),
2719            Self::Thick => f.write_str("thick"),
2720            Self::Thin => f.write_str("thin"),
2721            Self::Length(v) => v.fmt(f),
2722            Self::Color(v) => v.fmt(f),
2723            Self::Raw(v) => v.fmt(f),
2724        }
2725    }
2726}
2727
2728impl From<Length> for BorderInline {
2729    fn from(v: Length) -> Self {
2730        Self::Length(v)
2731    }
2732}
2733
2734impl From<Color> for BorderInline {
2735    fn from(v: Color) -> Self {
2736        Self::Color(v)
2737    }
2738}
2739
2740impl From<Raw> for BorderInline {
2741    fn from(v: Raw) -> Self {
2742        Self::Raw(v)
2743    }
2744}
2745
2746/// A value of [`border-inline-color`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline-color).
2747#[derive(Debug, Clone, PartialEq)]
2748#[non_exhaustive]
2749pub enum BorderInlineColor {
2750    /// A color.
2751    Color(Color),
2752    /// Any other value, passed through unchecked.
2753    Raw(Raw),
2754}
2755
2756impl fmt::Display for BorderInlineColor {
2757    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2758        match self {
2759            Self::Color(v) => v.fmt(f),
2760            Self::Raw(v) => v.fmt(f),
2761        }
2762    }
2763}
2764
2765impl From<Color> for BorderInlineColor {
2766    fn from(v: Color) -> Self {
2767        Self::Color(v)
2768    }
2769}
2770
2771impl From<Raw> for BorderInlineColor {
2772    fn from(v: Raw) -> Self {
2773        Self::Raw(v)
2774    }
2775}
2776
2777/// A value of [`border-inline-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline-end).
2778#[derive(Debug, Clone, PartialEq)]
2779#[non_exhaustive]
2780pub enum BorderInlineEnd {
2781    /// `dashed`.
2782    Dashed,
2783    /// `dotted`.
2784    Dotted,
2785    /// `double`.
2786    Double,
2787    /// `groove`.
2788    Groove,
2789    /// `hidden`.
2790    Hidden,
2791    /// `inset`.
2792    Inset,
2793    /// `medium`.
2794    Medium,
2795    /// `none`.
2796    None,
2797    /// `outset`.
2798    Outset,
2799    /// `ridge`.
2800    Ridge,
2801    /// `solid`.
2802    Solid,
2803    /// `thick`.
2804    Thick,
2805    /// `thin`.
2806    Thin,
2807    /// A length.
2808    Length(Length),
2809    /// A color.
2810    Color(Color),
2811    /// Any other value, passed through unchecked.
2812    Raw(Raw),
2813}
2814
2815impl fmt::Display for BorderInlineEnd {
2816    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2817        match self {
2818            Self::Dashed => f.write_str("dashed"),
2819            Self::Dotted => f.write_str("dotted"),
2820            Self::Double => f.write_str("double"),
2821            Self::Groove => f.write_str("groove"),
2822            Self::Hidden => f.write_str("hidden"),
2823            Self::Inset => f.write_str("inset"),
2824            Self::Medium => f.write_str("medium"),
2825            Self::None => f.write_str("none"),
2826            Self::Outset => f.write_str("outset"),
2827            Self::Ridge => f.write_str("ridge"),
2828            Self::Solid => f.write_str("solid"),
2829            Self::Thick => f.write_str("thick"),
2830            Self::Thin => f.write_str("thin"),
2831            Self::Length(v) => v.fmt(f),
2832            Self::Color(v) => v.fmt(f),
2833            Self::Raw(v) => v.fmt(f),
2834        }
2835    }
2836}
2837
2838impl From<Length> for BorderInlineEnd {
2839    fn from(v: Length) -> Self {
2840        Self::Length(v)
2841    }
2842}
2843
2844impl From<Color> for BorderInlineEnd {
2845    fn from(v: Color) -> Self {
2846        Self::Color(v)
2847    }
2848}
2849
2850impl From<Raw> for BorderInlineEnd {
2851    fn from(v: Raw) -> Self {
2852        Self::Raw(v)
2853    }
2854}
2855
2856/// A value of [`border-inline-end-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline-end-style).
2857#[derive(Debug, Clone, PartialEq)]
2858#[non_exhaustive]
2859pub enum BorderInlineEndStyle {
2860    /// `dashed`.
2861    Dashed,
2862    /// `dotted`.
2863    Dotted,
2864    /// `double`.
2865    Double,
2866    /// `groove`.
2867    Groove,
2868    /// `hidden`.
2869    Hidden,
2870    /// `inset`.
2871    Inset,
2872    /// `none`.
2873    None,
2874    /// `outset`.
2875    Outset,
2876    /// `ridge`.
2877    Ridge,
2878    /// `solid`.
2879    Solid,
2880}
2881
2882impl fmt::Display for BorderInlineEndStyle {
2883    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2884        match self {
2885            Self::Dashed => f.write_str("dashed"),
2886            Self::Dotted => f.write_str("dotted"),
2887            Self::Double => f.write_str("double"),
2888            Self::Groove => f.write_str("groove"),
2889            Self::Hidden => f.write_str("hidden"),
2890            Self::Inset => f.write_str("inset"),
2891            Self::None => f.write_str("none"),
2892            Self::Outset => f.write_str("outset"),
2893            Self::Ridge => f.write_str("ridge"),
2894            Self::Solid => f.write_str("solid"),
2895        }
2896    }
2897}
2898
2899/// A value of [`border-inline-end-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline-end-width).
2900#[derive(Debug, Clone, PartialEq)]
2901#[non_exhaustive]
2902pub enum BorderInlineEndWidth {
2903    /// `medium`.
2904    Medium,
2905    /// `thick`.
2906    Thick,
2907    /// `thin`.
2908    Thin,
2909    /// A length.
2910    Length(Length),
2911}
2912
2913impl fmt::Display for BorderInlineEndWidth {
2914    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2915        match self {
2916            Self::Medium => f.write_str("medium"),
2917            Self::Thick => f.write_str("thick"),
2918            Self::Thin => f.write_str("thin"),
2919            Self::Length(v) => v.fmt(f),
2920        }
2921    }
2922}
2923
2924impl From<Length> for BorderInlineEndWidth {
2925    fn from(v: Length) -> Self {
2926        Self::Length(v)
2927    }
2928}
2929
2930/// A value of [`border-inline-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline-start).
2931#[derive(Debug, Clone, PartialEq)]
2932#[non_exhaustive]
2933pub enum BorderInlineStart {
2934    /// `dashed`.
2935    Dashed,
2936    /// `dotted`.
2937    Dotted,
2938    /// `double`.
2939    Double,
2940    /// `groove`.
2941    Groove,
2942    /// `hidden`.
2943    Hidden,
2944    /// `inset`.
2945    Inset,
2946    /// `medium`.
2947    Medium,
2948    /// `none`.
2949    None,
2950    /// `outset`.
2951    Outset,
2952    /// `ridge`.
2953    Ridge,
2954    /// `solid`.
2955    Solid,
2956    /// `thick`.
2957    Thick,
2958    /// `thin`.
2959    Thin,
2960    /// A length.
2961    Length(Length),
2962    /// A color.
2963    Color(Color),
2964    /// Any other value, passed through unchecked.
2965    Raw(Raw),
2966}
2967
2968impl fmt::Display for BorderInlineStart {
2969    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2970        match self {
2971            Self::Dashed => f.write_str("dashed"),
2972            Self::Dotted => f.write_str("dotted"),
2973            Self::Double => f.write_str("double"),
2974            Self::Groove => f.write_str("groove"),
2975            Self::Hidden => f.write_str("hidden"),
2976            Self::Inset => f.write_str("inset"),
2977            Self::Medium => f.write_str("medium"),
2978            Self::None => f.write_str("none"),
2979            Self::Outset => f.write_str("outset"),
2980            Self::Ridge => f.write_str("ridge"),
2981            Self::Solid => f.write_str("solid"),
2982            Self::Thick => f.write_str("thick"),
2983            Self::Thin => f.write_str("thin"),
2984            Self::Length(v) => v.fmt(f),
2985            Self::Color(v) => v.fmt(f),
2986            Self::Raw(v) => v.fmt(f),
2987        }
2988    }
2989}
2990
2991impl From<Length> for BorderInlineStart {
2992    fn from(v: Length) -> Self {
2993        Self::Length(v)
2994    }
2995}
2996
2997impl From<Color> for BorderInlineStart {
2998    fn from(v: Color) -> Self {
2999        Self::Color(v)
3000    }
3001}
3002
3003impl From<Raw> for BorderInlineStart {
3004    fn from(v: Raw) -> Self {
3005        Self::Raw(v)
3006    }
3007}
3008
3009/// A value of [`border-inline-start-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline-start-style).
3010#[derive(Debug, Clone, PartialEq)]
3011#[non_exhaustive]
3012pub enum BorderInlineStartStyle {
3013    /// `dashed`.
3014    Dashed,
3015    /// `dotted`.
3016    Dotted,
3017    /// `double`.
3018    Double,
3019    /// `groove`.
3020    Groove,
3021    /// `hidden`.
3022    Hidden,
3023    /// `inset`.
3024    Inset,
3025    /// `none`.
3026    None,
3027    /// `outset`.
3028    Outset,
3029    /// `ridge`.
3030    Ridge,
3031    /// `solid`.
3032    Solid,
3033}
3034
3035impl fmt::Display for BorderInlineStartStyle {
3036    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3037        match self {
3038            Self::Dashed => f.write_str("dashed"),
3039            Self::Dotted => f.write_str("dotted"),
3040            Self::Double => f.write_str("double"),
3041            Self::Groove => f.write_str("groove"),
3042            Self::Hidden => f.write_str("hidden"),
3043            Self::Inset => f.write_str("inset"),
3044            Self::None => f.write_str("none"),
3045            Self::Outset => f.write_str("outset"),
3046            Self::Ridge => f.write_str("ridge"),
3047            Self::Solid => f.write_str("solid"),
3048        }
3049    }
3050}
3051
3052/// A value of [`border-inline-start-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline-start-width).
3053#[derive(Debug, Clone, PartialEq)]
3054#[non_exhaustive]
3055pub enum BorderInlineStartWidth {
3056    /// `medium`.
3057    Medium,
3058    /// `thick`.
3059    Thick,
3060    /// `thin`.
3061    Thin,
3062    /// A length.
3063    Length(Length),
3064}
3065
3066impl fmt::Display for BorderInlineStartWidth {
3067    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3068        match self {
3069            Self::Medium => f.write_str("medium"),
3070            Self::Thick => f.write_str("thick"),
3071            Self::Thin => f.write_str("thin"),
3072            Self::Length(v) => v.fmt(f),
3073        }
3074    }
3075}
3076
3077impl From<Length> for BorderInlineStartWidth {
3078    fn from(v: Length) -> Self {
3079        Self::Length(v)
3080    }
3081}
3082
3083/// A value of [`border-inline-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline-style).
3084#[derive(Debug, Clone, PartialEq)]
3085#[non_exhaustive]
3086pub enum BorderInlineStyle {
3087    /// `dashed`.
3088    Dashed,
3089    /// `dotted`.
3090    Dotted,
3091    /// `double`.
3092    Double,
3093    /// `groove`.
3094    Groove,
3095    /// `hidden`.
3096    Hidden,
3097    /// `inset`.
3098    Inset,
3099    /// `none`.
3100    None,
3101    /// `outset`.
3102    Outset,
3103    /// `ridge`.
3104    Ridge,
3105    /// `solid`.
3106    Solid,
3107    /// Any other value, passed through unchecked.
3108    Raw(Raw),
3109}
3110
3111impl fmt::Display for BorderInlineStyle {
3112    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3113        match self {
3114            Self::Dashed => f.write_str("dashed"),
3115            Self::Dotted => f.write_str("dotted"),
3116            Self::Double => f.write_str("double"),
3117            Self::Groove => f.write_str("groove"),
3118            Self::Hidden => f.write_str("hidden"),
3119            Self::Inset => f.write_str("inset"),
3120            Self::None => f.write_str("none"),
3121            Self::Outset => f.write_str("outset"),
3122            Self::Ridge => f.write_str("ridge"),
3123            Self::Solid => f.write_str("solid"),
3124            Self::Raw(v) => v.fmt(f),
3125        }
3126    }
3127}
3128
3129impl From<Raw> for BorderInlineStyle {
3130    fn from(v: Raw) -> Self {
3131        Self::Raw(v)
3132    }
3133}
3134
3135/// A value of [`border-inline-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-inline-width).
3136#[derive(Debug, Clone, PartialEq)]
3137#[non_exhaustive]
3138pub enum BorderInlineWidth {
3139    /// `medium`.
3140    Medium,
3141    /// `thick`.
3142    Thick,
3143    /// `thin`.
3144    Thin,
3145    /// A length.
3146    Length(Length),
3147    /// Any other value, passed through unchecked.
3148    Raw(Raw),
3149}
3150
3151impl fmt::Display for BorderInlineWidth {
3152    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3153        match self {
3154            Self::Medium => f.write_str("medium"),
3155            Self::Thick => f.write_str("thick"),
3156            Self::Thin => f.write_str("thin"),
3157            Self::Length(v) => v.fmt(f),
3158            Self::Raw(v) => v.fmt(f),
3159        }
3160    }
3161}
3162
3163impl From<Length> for BorderInlineWidth {
3164    fn from(v: Length) -> Self {
3165        Self::Length(v)
3166    }
3167}
3168
3169impl From<Raw> for BorderInlineWidth {
3170    fn from(v: Raw) -> Self {
3171        Self::Raw(v)
3172    }
3173}
3174
3175/// A value of [`border-left`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-left).
3176#[derive(Debug, Clone, PartialEq)]
3177#[non_exhaustive]
3178pub enum BorderLeft {
3179    /// `dashed`.
3180    Dashed,
3181    /// `dotted`.
3182    Dotted,
3183    /// `double`.
3184    Double,
3185    /// `groove`.
3186    Groove,
3187    /// `hidden`.
3188    Hidden,
3189    /// `inset`.
3190    Inset,
3191    /// `medium`.
3192    Medium,
3193    /// `none`.
3194    None,
3195    /// `outset`.
3196    Outset,
3197    /// `ridge`.
3198    Ridge,
3199    /// `solid`.
3200    Solid,
3201    /// `thick`.
3202    Thick,
3203    /// `thin`.
3204    Thin,
3205    /// A length.
3206    Length(Length),
3207    /// A color.
3208    Color(Color),
3209    /// Any other value, passed through unchecked.
3210    Raw(Raw),
3211}
3212
3213impl fmt::Display for BorderLeft {
3214    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3215        match self {
3216            Self::Dashed => f.write_str("dashed"),
3217            Self::Dotted => f.write_str("dotted"),
3218            Self::Double => f.write_str("double"),
3219            Self::Groove => f.write_str("groove"),
3220            Self::Hidden => f.write_str("hidden"),
3221            Self::Inset => f.write_str("inset"),
3222            Self::Medium => f.write_str("medium"),
3223            Self::None => f.write_str("none"),
3224            Self::Outset => f.write_str("outset"),
3225            Self::Ridge => f.write_str("ridge"),
3226            Self::Solid => f.write_str("solid"),
3227            Self::Thick => f.write_str("thick"),
3228            Self::Thin => f.write_str("thin"),
3229            Self::Length(v) => v.fmt(f),
3230            Self::Color(v) => v.fmt(f),
3231            Self::Raw(v) => v.fmt(f),
3232        }
3233    }
3234}
3235
3236impl From<Length> for BorderLeft {
3237    fn from(v: Length) -> Self {
3238        Self::Length(v)
3239    }
3240}
3241
3242impl From<Color> for BorderLeft {
3243    fn from(v: Color) -> Self {
3244        Self::Color(v)
3245    }
3246}
3247
3248impl From<Raw> for BorderLeft {
3249    fn from(v: Raw) -> Self {
3250        Self::Raw(v)
3251    }
3252}
3253
3254/// A value of [`border-left-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-left-style).
3255#[derive(Debug, Clone, PartialEq)]
3256#[non_exhaustive]
3257pub enum BorderLeftStyle {
3258    /// `dashed`.
3259    Dashed,
3260    /// `dotted`.
3261    Dotted,
3262    /// `double`.
3263    Double,
3264    /// `groove`.
3265    Groove,
3266    /// `hidden`.
3267    Hidden,
3268    /// `inset`.
3269    Inset,
3270    /// `none`.
3271    None,
3272    /// `outset`.
3273    Outset,
3274    /// `ridge`.
3275    Ridge,
3276    /// `solid`.
3277    Solid,
3278}
3279
3280impl fmt::Display for BorderLeftStyle {
3281    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3282        match self {
3283            Self::Dashed => f.write_str("dashed"),
3284            Self::Dotted => f.write_str("dotted"),
3285            Self::Double => f.write_str("double"),
3286            Self::Groove => f.write_str("groove"),
3287            Self::Hidden => f.write_str("hidden"),
3288            Self::Inset => f.write_str("inset"),
3289            Self::None => f.write_str("none"),
3290            Self::Outset => f.write_str("outset"),
3291            Self::Ridge => f.write_str("ridge"),
3292            Self::Solid => f.write_str("solid"),
3293        }
3294    }
3295}
3296
3297/// A value of [`border-left-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-left-width).
3298#[derive(Debug, Clone, PartialEq)]
3299#[non_exhaustive]
3300pub enum BorderLeftWidth {
3301    /// `medium`.
3302    Medium,
3303    /// `thick`.
3304    Thick,
3305    /// `thin`.
3306    Thin,
3307    /// A length.
3308    Length(Length),
3309}
3310
3311impl fmt::Display for BorderLeftWidth {
3312    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3313        match self {
3314            Self::Medium => f.write_str("medium"),
3315            Self::Thick => f.write_str("thick"),
3316            Self::Thin => f.write_str("thin"),
3317            Self::Length(v) => v.fmt(f),
3318        }
3319    }
3320}
3321
3322impl From<Length> for BorderLeftWidth {
3323    fn from(v: Length) -> Self {
3324        Self::Length(v)
3325    }
3326}
3327
3328/// A value of [`border-radius`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-radius).
3329#[derive(Debug, Clone, PartialEq)]
3330#[non_exhaustive]
3331pub enum BorderRadius {
3332    /// A length.
3333    Length(Length),
3334    /// A percentage.
3335    Percentage(Percentage),
3336    /// Any other value, passed through unchecked.
3337    Raw(Raw),
3338}
3339
3340impl fmt::Display for BorderRadius {
3341    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3342        match self {
3343            Self::Length(v) => v.fmt(f),
3344            Self::Percentage(v) => v.fmt(f),
3345            Self::Raw(v) => v.fmt(f),
3346        }
3347    }
3348}
3349
3350impl From<Length> for BorderRadius {
3351    fn from(v: Length) -> Self {
3352        Self::Length(v)
3353    }
3354}
3355
3356impl From<Percentage> for BorderRadius {
3357    fn from(v: Percentage) -> Self {
3358        Self::Percentage(v)
3359    }
3360}
3361
3362impl From<Raw> for BorderRadius {
3363    fn from(v: Raw) -> Self {
3364        Self::Raw(v)
3365    }
3366}
3367
3368/// A value of [`border-right`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-right).
3369#[derive(Debug, Clone, PartialEq)]
3370#[non_exhaustive]
3371pub enum BorderRight {
3372    /// `dashed`.
3373    Dashed,
3374    /// `dotted`.
3375    Dotted,
3376    /// `double`.
3377    Double,
3378    /// `groove`.
3379    Groove,
3380    /// `hidden`.
3381    Hidden,
3382    /// `inset`.
3383    Inset,
3384    /// `medium`.
3385    Medium,
3386    /// `none`.
3387    None,
3388    /// `outset`.
3389    Outset,
3390    /// `ridge`.
3391    Ridge,
3392    /// `solid`.
3393    Solid,
3394    /// `thick`.
3395    Thick,
3396    /// `thin`.
3397    Thin,
3398    /// A length.
3399    Length(Length),
3400    /// A color.
3401    Color(Color),
3402    /// Any other value, passed through unchecked.
3403    Raw(Raw),
3404}
3405
3406impl fmt::Display for BorderRight {
3407    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3408        match self {
3409            Self::Dashed => f.write_str("dashed"),
3410            Self::Dotted => f.write_str("dotted"),
3411            Self::Double => f.write_str("double"),
3412            Self::Groove => f.write_str("groove"),
3413            Self::Hidden => f.write_str("hidden"),
3414            Self::Inset => f.write_str("inset"),
3415            Self::Medium => f.write_str("medium"),
3416            Self::None => f.write_str("none"),
3417            Self::Outset => f.write_str("outset"),
3418            Self::Ridge => f.write_str("ridge"),
3419            Self::Solid => f.write_str("solid"),
3420            Self::Thick => f.write_str("thick"),
3421            Self::Thin => f.write_str("thin"),
3422            Self::Length(v) => v.fmt(f),
3423            Self::Color(v) => v.fmt(f),
3424            Self::Raw(v) => v.fmt(f),
3425        }
3426    }
3427}
3428
3429impl From<Length> for BorderRight {
3430    fn from(v: Length) -> Self {
3431        Self::Length(v)
3432    }
3433}
3434
3435impl From<Color> for BorderRight {
3436    fn from(v: Color) -> Self {
3437        Self::Color(v)
3438    }
3439}
3440
3441impl From<Raw> for BorderRight {
3442    fn from(v: Raw) -> Self {
3443        Self::Raw(v)
3444    }
3445}
3446
3447/// A value of [`border-right-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-right-style).
3448#[derive(Debug, Clone, PartialEq)]
3449#[non_exhaustive]
3450pub enum BorderRightStyle {
3451    /// `dashed`.
3452    Dashed,
3453    /// `dotted`.
3454    Dotted,
3455    /// `double`.
3456    Double,
3457    /// `groove`.
3458    Groove,
3459    /// `hidden`.
3460    Hidden,
3461    /// `inset`.
3462    Inset,
3463    /// `none`.
3464    None,
3465    /// `outset`.
3466    Outset,
3467    /// `ridge`.
3468    Ridge,
3469    /// `solid`.
3470    Solid,
3471}
3472
3473impl fmt::Display for BorderRightStyle {
3474    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3475        match self {
3476            Self::Dashed => f.write_str("dashed"),
3477            Self::Dotted => f.write_str("dotted"),
3478            Self::Double => f.write_str("double"),
3479            Self::Groove => f.write_str("groove"),
3480            Self::Hidden => f.write_str("hidden"),
3481            Self::Inset => f.write_str("inset"),
3482            Self::None => f.write_str("none"),
3483            Self::Outset => f.write_str("outset"),
3484            Self::Ridge => f.write_str("ridge"),
3485            Self::Solid => f.write_str("solid"),
3486        }
3487    }
3488}
3489
3490/// A value of [`border-right-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-right-width).
3491#[derive(Debug, Clone, PartialEq)]
3492#[non_exhaustive]
3493pub enum BorderRightWidth {
3494    /// `medium`.
3495    Medium,
3496    /// `thick`.
3497    Thick,
3498    /// `thin`.
3499    Thin,
3500    /// A length.
3501    Length(Length),
3502}
3503
3504impl fmt::Display for BorderRightWidth {
3505    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3506        match self {
3507            Self::Medium => f.write_str("medium"),
3508            Self::Thick => f.write_str("thick"),
3509            Self::Thin => f.write_str("thin"),
3510            Self::Length(v) => v.fmt(f),
3511        }
3512    }
3513}
3514
3515impl From<Length> for BorderRightWidth {
3516    fn from(v: Length) -> Self {
3517        Self::Length(v)
3518    }
3519}
3520
3521/// A value of [`border-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-shape).
3522#[derive(Debug, Clone, PartialEq)]
3523#[non_exhaustive]
3524pub enum BorderShape {
3525    /// `none`.
3526    None,
3527    /// Any other value, passed through unchecked.
3528    Raw(Raw),
3529}
3530
3531impl fmt::Display for BorderShape {
3532    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3533        match self {
3534            Self::None => f.write_str("none"),
3535            Self::Raw(v) => v.fmt(f),
3536        }
3537    }
3538}
3539
3540impl From<Raw> for BorderShape {
3541    fn from(v: Raw) -> Self {
3542        Self::Raw(v)
3543    }
3544}
3545
3546/// A value of [`border-spacing`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-spacing).
3547#[derive(Debug, Clone, PartialEq)]
3548#[non_exhaustive]
3549pub enum BorderSpacing {
3550    /// A length.
3551    Length(Length),
3552    /// Any other value, passed through unchecked.
3553    Raw(Raw),
3554}
3555
3556impl fmt::Display for BorderSpacing {
3557    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3558        match self {
3559            Self::Length(v) => v.fmt(f),
3560            Self::Raw(v) => v.fmt(f),
3561        }
3562    }
3563}
3564
3565impl From<Length> for BorderSpacing {
3566    fn from(v: Length) -> Self {
3567        Self::Length(v)
3568    }
3569}
3570
3571impl From<Raw> for BorderSpacing {
3572    fn from(v: Raw) -> Self {
3573        Self::Raw(v)
3574    }
3575}
3576
3577/// A value of [`border-start-end-radius`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-start-end-radius).
3578#[derive(Debug, Clone, PartialEq)]
3579#[non_exhaustive]
3580pub enum BorderStartEndRadius {
3581    /// A length.
3582    Length(Length),
3583    /// A percentage.
3584    Percentage(Percentage),
3585    /// Any other value, passed through unchecked.
3586    Raw(Raw),
3587}
3588
3589impl fmt::Display for BorderStartEndRadius {
3590    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3591        match self {
3592            Self::Length(v) => v.fmt(f),
3593            Self::Percentage(v) => v.fmt(f),
3594            Self::Raw(v) => v.fmt(f),
3595        }
3596    }
3597}
3598
3599impl From<Length> for BorderStartEndRadius {
3600    fn from(v: Length) -> Self {
3601        Self::Length(v)
3602    }
3603}
3604
3605impl From<Percentage> for BorderStartEndRadius {
3606    fn from(v: Percentage) -> Self {
3607        Self::Percentage(v)
3608    }
3609}
3610
3611impl From<Raw> for BorderStartEndRadius {
3612    fn from(v: Raw) -> Self {
3613        Self::Raw(v)
3614    }
3615}
3616
3617/// A value of [`border-start-start-radius`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-start-start-radius).
3618#[derive(Debug, Clone, PartialEq)]
3619#[non_exhaustive]
3620pub enum BorderStartStartRadius {
3621    /// A length.
3622    Length(Length),
3623    /// A percentage.
3624    Percentage(Percentage),
3625    /// Any other value, passed through unchecked.
3626    Raw(Raw),
3627}
3628
3629impl fmt::Display for BorderStartStartRadius {
3630    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3631        match self {
3632            Self::Length(v) => v.fmt(f),
3633            Self::Percentage(v) => v.fmt(f),
3634            Self::Raw(v) => v.fmt(f),
3635        }
3636    }
3637}
3638
3639impl From<Length> for BorderStartStartRadius {
3640    fn from(v: Length) -> Self {
3641        Self::Length(v)
3642    }
3643}
3644
3645impl From<Percentage> for BorderStartStartRadius {
3646    fn from(v: Percentage) -> Self {
3647        Self::Percentage(v)
3648    }
3649}
3650
3651impl From<Raw> for BorderStartStartRadius {
3652    fn from(v: Raw) -> Self {
3653        Self::Raw(v)
3654    }
3655}
3656
3657/// A value of [`border-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-style).
3658#[derive(Debug, Clone, PartialEq)]
3659#[non_exhaustive]
3660pub enum BorderStyle {
3661    /// `dashed`.
3662    Dashed,
3663    /// `dotted`.
3664    Dotted,
3665    /// `double`.
3666    Double,
3667    /// `groove`.
3668    Groove,
3669    /// `hidden`.
3670    Hidden,
3671    /// `inset`.
3672    Inset,
3673    /// `none`.
3674    None,
3675    /// `outset`.
3676    Outset,
3677    /// `ridge`.
3678    Ridge,
3679    /// `solid`.
3680    Solid,
3681    /// Any other value, passed through unchecked.
3682    Raw(Raw),
3683}
3684
3685impl fmt::Display for BorderStyle {
3686    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3687        match self {
3688            Self::Dashed => f.write_str("dashed"),
3689            Self::Dotted => f.write_str("dotted"),
3690            Self::Double => f.write_str("double"),
3691            Self::Groove => f.write_str("groove"),
3692            Self::Hidden => f.write_str("hidden"),
3693            Self::Inset => f.write_str("inset"),
3694            Self::None => f.write_str("none"),
3695            Self::Outset => f.write_str("outset"),
3696            Self::Ridge => f.write_str("ridge"),
3697            Self::Solid => f.write_str("solid"),
3698            Self::Raw(v) => v.fmt(f),
3699        }
3700    }
3701}
3702
3703impl From<Raw> for BorderStyle {
3704    fn from(v: Raw) -> Self {
3705        Self::Raw(v)
3706    }
3707}
3708
3709/// A value of [`border-top`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-top).
3710#[derive(Debug, Clone, PartialEq)]
3711#[non_exhaustive]
3712pub enum BorderTop {
3713    /// `dashed`.
3714    Dashed,
3715    /// `dotted`.
3716    Dotted,
3717    /// `double`.
3718    Double,
3719    /// `groove`.
3720    Groove,
3721    /// `hidden`.
3722    Hidden,
3723    /// `inset`.
3724    Inset,
3725    /// `medium`.
3726    Medium,
3727    /// `none`.
3728    None,
3729    /// `outset`.
3730    Outset,
3731    /// `ridge`.
3732    Ridge,
3733    /// `solid`.
3734    Solid,
3735    /// `thick`.
3736    Thick,
3737    /// `thin`.
3738    Thin,
3739    /// A length.
3740    Length(Length),
3741    /// A color.
3742    Color(Color),
3743    /// Any other value, passed through unchecked.
3744    Raw(Raw),
3745}
3746
3747impl fmt::Display for BorderTop {
3748    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3749        match self {
3750            Self::Dashed => f.write_str("dashed"),
3751            Self::Dotted => f.write_str("dotted"),
3752            Self::Double => f.write_str("double"),
3753            Self::Groove => f.write_str("groove"),
3754            Self::Hidden => f.write_str("hidden"),
3755            Self::Inset => f.write_str("inset"),
3756            Self::Medium => f.write_str("medium"),
3757            Self::None => f.write_str("none"),
3758            Self::Outset => f.write_str("outset"),
3759            Self::Ridge => f.write_str("ridge"),
3760            Self::Solid => f.write_str("solid"),
3761            Self::Thick => f.write_str("thick"),
3762            Self::Thin => f.write_str("thin"),
3763            Self::Length(v) => v.fmt(f),
3764            Self::Color(v) => v.fmt(f),
3765            Self::Raw(v) => v.fmt(f),
3766        }
3767    }
3768}
3769
3770impl From<Length> for BorderTop {
3771    fn from(v: Length) -> Self {
3772        Self::Length(v)
3773    }
3774}
3775
3776impl From<Color> for BorderTop {
3777    fn from(v: Color) -> Self {
3778        Self::Color(v)
3779    }
3780}
3781
3782impl From<Raw> for BorderTop {
3783    fn from(v: Raw) -> Self {
3784        Self::Raw(v)
3785    }
3786}
3787
3788/// A value of [`border-top-left-radius`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-top-left-radius).
3789#[derive(Debug, Clone, PartialEq)]
3790#[non_exhaustive]
3791pub enum BorderTopLeftRadius {
3792    /// A length.
3793    Length(Length),
3794    /// A percentage.
3795    Percentage(Percentage),
3796    /// Any other value, passed through unchecked.
3797    Raw(Raw),
3798}
3799
3800impl fmt::Display for BorderTopLeftRadius {
3801    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3802        match self {
3803            Self::Length(v) => v.fmt(f),
3804            Self::Percentage(v) => v.fmt(f),
3805            Self::Raw(v) => v.fmt(f),
3806        }
3807    }
3808}
3809
3810impl From<Length> for BorderTopLeftRadius {
3811    fn from(v: Length) -> Self {
3812        Self::Length(v)
3813    }
3814}
3815
3816impl From<Percentage> for BorderTopLeftRadius {
3817    fn from(v: Percentage) -> Self {
3818        Self::Percentage(v)
3819    }
3820}
3821
3822impl From<Raw> for BorderTopLeftRadius {
3823    fn from(v: Raw) -> Self {
3824        Self::Raw(v)
3825    }
3826}
3827
3828/// A value of [`border-top-right-radius`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-top-right-radius).
3829#[derive(Debug, Clone, PartialEq)]
3830#[non_exhaustive]
3831pub enum BorderTopRightRadius {
3832    /// A length.
3833    Length(Length),
3834    /// A percentage.
3835    Percentage(Percentage),
3836    /// Any other value, passed through unchecked.
3837    Raw(Raw),
3838}
3839
3840impl fmt::Display for BorderTopRightRadius {
3841    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3842        match self {
3843            Self::Length(v) => v.fmt(f),
3844            Self::Percentage(v) => v.fmt(f),
3845            Self::Raw(v) => v.fmt(f),
3846        }
3847    }
3848}
3849
3850impl From<Length> for BorderTopRightRadius {
3851    fn from(v: Length) -> Self {
3852        Self::Length(v)
3853    }
3854}
3855
3856impl From<Percentage> for BorderTopRightRadius {
3857    fn from(v: Percentage) -> Self {
3858        Self::Percentage(v)
3859    }
3860}
3861
3862impl From<Raw> for BorderTopRightRadius {
3863    fn from(v: Raw) -> Self {
3864        Self::Raw(v)
3865    }
3866}
3867
3868/// A value of [`border-top-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-top-style).
3869#[derive(Debug, Clone, PartialEq)]
3870#[non_exhaustive]
3871pub enum BorderTopStyle {
3872    /// `dashed`.
3873    Dashed,
3874    /// `dotted`.
3875    Dotted,
3876    /// `double`.
3877    Double,
3878    /// `groove`.
3879    Groove,
3880    /// `hidden`.
3881    Hidden,
3882    /// `inset`.
3883    Inset,
3884    /// `none`.
3885    None,
3886    /// `outset`.
3887    Outset,
3888    /// `ridge`.
3889    Ridge,
3890    /// `solid`.
3891    Solid,
3892}
3893
3894impl fmt::Display for BorderTopStyle {
3895    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3896        match self {
3897            Self::Dashed => f.write_str("dashed"),
3898            Self::Dotted => f.write_str("dotted"),
3899            Self::Double => f.write_str("double"),
3900            Self::Groove => f.write_str("groove"),
3901            Self::Hidden => f.write_str("hidden"),
3902            Self::Inset => f.write_str("inset"),
3903            Self::None => f.write_str("none"),
3904            Self::Outset => f.write_str("outset"),
3905            Self::Ridge => f.write_str("ridge"),
3906            Self::Solid => f.write_str("solid"),
3907        }
3908    }
3909}
3910
3911/// A value of [`border-top-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-top-width).
3912#[derive(Debug, Clone, PartialEq)]
3913#[non_exhaustive]
3914pub enum BorderTopWidth {
3915    /// `medium`.
3916    Medium,
3917    /// `thick`.
3918    Thick,
3919    /// `thin`.
3920    Thin,
3921    /// A length.
3922    Length(Length),
3923}
3924
3925impl fmt::Display for BorderTopWidth {
3926    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3927        match self {
3928            Self::Medium => f.write_str("medium"),
3929            Self::Thick => f.write_str("thick"),
3930            Self::Thin => f.write_str("thin"),
3931            Self::Length(v) => v.fmt(f),
3932        }
3933    }
3934}
3935
3936impl From<Length> for BorderTopWidth {
3937    fn from(v: Length) -> Self {
3938        Self::Length(v)
3939    }
3940}
3941
3942/// A value of [`border-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/border-width).
3943#[derive(Debug, Clone, PartialEq)]
3944#[non_exhaustive]
3945pub enum BorderWidth {
3946    /// `medium`.
3947    Medium,
3948    /// `thick`.
3949    Thick,
3950    /// `thin`.
3951    Thin,
3952    /// A length.
3953    Length(Length),
3954    /// Any other value, passed through unchecked.
3955    Raw(Raw),
3956}
3957
3958impl fmt::Display for BorderWidth {
3959    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3960        match self {
3961            Self::Medium => f.write_str("medium"),
3962            Self::Thick => f.write_str("thick"),
3963            Self::Thin => f.write_str("thin"),
3964            Self::Length(v) => v.fmt(f),
3965            Self::Raw(v) => v.fmt(f),
3966        }
3967    }
3968}
3969
3970impl From<Length> for BorderWidth {
3971    fn from(v: Length) -> Self {
3972        Self::Length(v)
3973    }
3974}
3975
3976impl From<Raw> for BorderWidth {
3977    fn from(v: Raw) -> Self {
3978        Self::Raw(v)
3979    }
3980}
3981
3982/// A value of [`bottom`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/bottom).
3983#[derive(Debug, Clone, PartialEq)]
3984#[non_exhaustive]
3985pub enum Bottom {
3986    /// `auto`.
3987    Auto,
3988    /// A length.
3989    Length(Length),
3990    /// A percentage.
3991    Percentage(Percentage),
3992    /// Any other value, passed through unchecked.
3993    Raw(Raw),
3994}
3995
3996impl fmt::Display for Bottom {
3997    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3998        match self {
3999            Self::Auto => f.write_str("auto"),
4000            Self::Length(v) => v.fmt(f),
4001            Self::Percentage(v) => v.fmt(f),
4002            Self::Raw(v) => v.fmt(f),
4003        }
4004    }
4005}
4006
4007impl From<Length> for Bottom {
4008    fn from(v: Length) -> Self {
4009        Self::Length(v)
4010    }
4011}
4012
4013impl From<Percentage> for Bottom {
4014    fn from(v: Percentage) -> Self {
4015        Self::Percentage(v)
4016    }
4017}
4018
4019impl From<Raw> for Bottom {
4020    fn from(v: Raw) -> Self {
4021        Self::Raw(v)
4022    }
4023}
4024
4025/// A value of [`box-decoration-break`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/box-decoration-break).
4026#[derive(Debug, Clone, PartialEq)]
4027#[non_exhaustive]
4028pub enum BoxDecorationBreak {
4029    /// `clone`.
4030    Clone,
4031    /// `slice`.
4032    Slice,
4033}
4034
4035impl fmt::Display for BoxDecorationBreak {
4036    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4037        match self {
4038            Self::Clone => f.write_str("clone"),
4039            Self::Slice => f.write_str("slice"),
4040        }
4041    }
4042}
4043
4044/// A value of [`box-shadow`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/box-shadow).
4045#[derive(Debug, Clone, PartialEq)]
4046#[non_exhaustive]
4047pub enum BoxShadow {
4048    /// `none`.
4049    None,
4050    /// Any other value, passed through unchecked.
4051    Raw(Raw),
4052}
4053
4054impl fmt::Display for BoxShadow {
4055    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4056        match self {
4057            Self::None => f.write_str("none"),
4058            Self::Raw(v) => v.fmt(f),
4059        }
4060    }
4061}
4062
4063impl From<Raw> for BoxShadow {
4064    fn from(v: Raw) -> Self {
4065        Self::Raw(v)
4066    }
4067}
4068
4069/// A value of [`box-sizing`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/box-sizing).
4070#[derive(Debug, Clone, PartialEq)]
4071#[non_exhaustive]
4072pub enum BoxSizing {
4073    /// `border-box`.
4074    BorderBox,
4075    /// `content-box`.
4076    ContentBox,
4077}
4078
4079impl fmt::Display for BoxSizing {
4080    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4081        match self {
4082            Self::BorderBox => f.write_str("border-box"),
4083            Self::ContentBox => f.write_str("content-box"),
4084        }
4085    }
4086}
4087
4088/// A value of [`break-after`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/break-after).
4089#[derive(Debug, Clone, PartialEq)]
4090#[non_exhaustive]
4091pub enum BreakAfter {
4092    /// `all`.
4093    All,
4094    /// `always`.
4095    Always,
4096    /// `auto`.
4097    Auto,
4098    /// `avoid`.
4099    Avoid,
4100    /// `avoid-column`.
4101    AvoidColumn,
4102    /// `avoid-page`.
4103    AvoidPage,
4104    /// `avoid-region`.
4105    AvoidRegion,
4106    /// `column`.
4107    Column,
4108    /// `left`.
4109    Left,
4110    /// `page`.
4111    Page,
4112    /// `recto`.
4113    Recto,
4114    /// `region`.
4115    Region,
4116    /// `right`.
4117    Right,
4118    /// `verso`.
4119    Verso,
4120}
4121
4122impl fmt::Display for BreakAfter {
4123    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4124        match self {
4125            Self::All => f.write_str("all"),
4126            Self::Always => f.write_str("always"),
4127            Self::Auto => f.write_str("auto"),
4128            Self::Avoid => f.write_str("avoid"),
4129            Self::AvoidColumn => f.write_str("avoid-column"),
4130            Self::AvoidPage => f.write_str("avoid-page"),
4131            Self::AvoidRegion => f.write_str("avoid-region"),
4132            Self::Column => f.write_str("column"),
4133            Self::Left => f.write_str("left"),
4134            Self::Page => f.write_str("page"),
4135            Self::Recto => f.write_str("recto"),
4136            Self::Region => f.write_str("region"),
4137            Self::Right => f.write_str("right"),
4138            Self::Verso => f.write_str("verso"),
4139        }
4140    }
4141}
4142
4143/// A value of [`break-before`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/break-before).
4144#[derive(Debug, Clone, PartialEq)]
4145#[non_exhaustive]
4146pub enum BreakBefore {
4147    /// `all`.
4148    All,
4149    /// `always`.
4150    Always,
4151    /// `auto`.
4152    Auto,
4153    /// `avoid`.
4154    Avoid,
4155    /// `avoid-column`.
4156    AvoidColumn,
4157    /// `avoid-page`.
4158    AvoidPage,
4159    /// `avoid-region`.
4160    AvoidRegion,
4161    /// `column`.
4162    Column,
4163    /// `left`.
4164    Left,
4165    /// `page`.
4166    Page,
4167    /// `recto`.
4168    Recto,
4169    /// `region`.
4170    Region,
4171    /// `right`.
4172    Right,
4173    /// `verso`.
4174    Verso,
4175}
4176
4177impl fmt::Display for BreakBefore {
4178    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4179        match self {
4180            Self::All => f.write_str("all"),
4181            Self::Always => f.write_str("always"),
4182            Self::Auto => f.write_str("auto"),
4183            Self::Avoid => f.write_str("avoid"),
4184            Self::AvoidColumn => f.write_str("avoid-column"),
4185            Self::AvoidPage => f.write_str("avoid-page"),
4186            Self::AvoidRegion => f.write_str("avoid-region"),
4187            Self::Column => f.write_str("column"),
4188            Self::Left => f.write_str("left"),
4189            Self::Page => f.write_str("page"),
4190            Self::Recto => f.write_str("recto"),
4191            Self::Region => f.write_str("region"),
4192            Self::Right => f.write_str("right"),
4193            Self::Verso => f.write_str("verso"),
4194        }
4195    }
4196}
4197
4198/// A value of [`break-inside`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/break-inside).
4199#[derive(Debug, Clone, PartialEq)]
4200#[non_exhaustive]
4201pub enum BreakInside {
4202    /// `auto`.
4203    Auto,
4204    /// `avoid`.
4205    Avoid,
4206    /// `avoid-column`.
4207    AvoidColumn,
4208    /// `avoid-page`.
4209    AvoidPage,
4210    /// `avoid-region`.
4211    AvoidRegion,
4212}
4213
4214impl fmt::Display for BreakInside {
4215    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4216        match self {
4217            Self::Auto => f.write_str("auto"),
4218            Self::Avoid => f.write_str("avoid"),
4219            Self::AvoidColumn => f.write_str("avoid-column"),
4220            Self::AvoidPage => f.write_str("avoid-page"),
4221            Self::AvoidRegion => f.write_str("avoid-region"),
4222        }
4223    }
4224}
4225
4226/// A value of [`caption-side`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/caption-side).
4227#[derive(Debug, Clone, PartialEq)]
4228#[non_exhaustive]
4229pub enum CaptionSide {
4230    /// `bottom`.
4231    Bottom,
4232    /// `top`.
4233    Top,
4234}
4235
4236impl fmt::Display for CaptionSide {
4237    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4238        match self {
4239            Self::Bottom => f.write_str("bottom"),
4240            Self::Top => f.write_str("top"),
4241        }
4242    }
4243}
4244
4245/// A value of [`caret`]().
4246#[derive(Debug, Clone, PartialEq)]
4247#[non_exhaustive]
4248pub enum Caret {
4249    /// `auto`.
4250    Auto,
4251    /// `bar`.
4252    Bar,
4253    /// `block`.
4254    Block,
4255    /// `manual`.
4256    Manual,
4257    /// `underscore`.
4258    Underscore,
4259    /// A color.
4260    Color(Color),
4261    /// Any other value, passed through unchecked.
4262    Raw(Raw),
4263}
4264
4265impl fmt::Display for Caret {
4266    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4267        match self {
4268            Self::Auto => f.write_str("auto"),
4269            Self::Bar => f.write_str("bar"),
4270            Self::Block => f.write_str("block"),
4271            Self::Manual => f.write_str("manual"),
4272            Self::Underscore => f.write_str("underscore"),
4273            Self::Color(v) => v.fmt(f),
4274            Self::Raw(v) => v.fmt(f),
4275        }
4276    }
4277}
4278
4279impl From<Color> for Caret {
4280    fn from(v: Color) -> Self {
4281        Self::Color(v)
4282    }
4283}
4284
4285impl From<Raw> for Caret {
4286    fn from(v: Raw) -> Self {
4287        Self::Raw(v)
4288    }
4289}
4290
4291/// A value of [`caret-animation`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/caret-animation).
4292#[derive(Debug, Clone, PartialEq)]
4293#[non_exhaustive]
4294pub enum CaretAnimation {
4295    /// `auto`.
4296    Auto,
4297    /// `manual`.
4298    Manual,
4299}
4300
4301impl fmt::Display for CaretAnimation {
4302    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4303        match self {
4304            Self::Auto => f.write_str("auto"),
4305            Self::Manual => f.write_str("manual"),
4306        }
4307    }
4308}
4309
4310/// A value of [`caret-color`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/caret-color).
4311#[derive(Debug, Clone, PartialEq)]
4312#[non_exhaustive]
4313pub enum CaretColor {
4314    /// `auto`.
4315    Auto,
4316    /// A color.
4317    Color(Color),
4318}
4319
4320impl fmt::Display for CaretColor {
4321    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4322        match self {
4323            Self::Auto => f.write_str("auto"),
4324            Self::Color(v) => v.fmt(f),
4325        }
4326    }
4327}
4328
4329impl From<Color> for CaretColor {
4330    fn from(v: Color) -> Self {
4331        Self::Color(v)
4332    }
4333}
4334
4335/// A value of [`caret-shape`]().
4336#[derive(Debug, Clone, PartialEq)]
4337#[non_exhaustive]
4338pub enum CaretShape {
4339    /// `auto`.
4340    Auto,
4341    /// `bar`.
4342    Bar,
4343    /// `block`.
4344    Block,
4345    /// `underscore`.
4346    Underscore,
4347}
4348
4349impl fmt::Display for CaretShape {
4350    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4351        match self {
4352            Self::Auto => f.write_str("auto"),
4353            Self::Bar => f.write_str("bar"),
4354            Self::Block => f.write_str("block"),
4355            Self::Underscore => f.write_str("underscore"),
4356        }
4357    }
4358}
4359
4360/// A value of [`clear`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/clear).
4361#[derive(Debug, Clone, PartialEq)]
4362#[non_exhaustive]
4363pub enum Clear {
4364    /// `both`.
4365    Both,
4366    /// `inline-end`.
4367    InlineEnd,
4368    /// `inline-start`.
4369    InlineStart,
4370    /// `left`.
4371    Left,
4372    /// `none`.
4373    None,
4374    /// `right`.
4375    Right,
4376}
4377
4378impl fmt::Display for Clear {
4379    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4380        match self {
4381            Self::Both => f.write_str("both"),
4382            Self::InlineEnd => f.write_str("inline-end"),
4383            Self::InlineStart => f.write_str("inline-start"),
4384            Self::Left => f.write_str("left"),
4385            Self::None => f.write_str("none"),
4386            Self::Right => f.write_str("right"),
4387        }
4388    }
4389}
4390
4391/// A value of [`clip-path`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/clip-path).
4392#[derive(Debug, Clone, PartialEq)]
4393#[non_exhaustive]
4394pub enum ClipPath {
4395    /// `border-box`.
4396    BorderBox,
4397    /// `content-box`.
4398    ContentBox,
4399    /// `fill-box`.
4400    FillBox,
4401    /// `margin-box`.
4402    MarginBox,
4403    /// `none`.
4404    None,
4405    /// `padding-box`.
4406    PaddingBox,
4407    /// `stroke-box`.
4408    StrokeBox,
4409    /// `view-box`.
4410    ViewBox,
4411    /// A URL.
4412    Url(Url),
4413    /// Any other value, passed through unchecked.
4414    Raw(Raw),
4415}
4416
4417impl fmt::Display for ClipPath {
4418    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4419        match self {
4420            Self::BorderBox => f.write_str("border-box"),
4421            Self::ContentBox => f.write_str("content-box"),
4422            Self::FillBox => f.write_str("fill-box"),
4423            Self::MarginBox => f.write_str("margin-box"),
4424            Self::None => f.write_str("none"),
4425            Self::PaddingBox => f.write_str("padding-box"),
4426            Self::StrokeBox => f.write_str("stroke-box"),
4427            Self::ViewBox => f.write_str("view-box"),
4428            Self::Url(v) => v.fmt(f),
4429            Self::Raw(v) => v.fmt(f),
4430        }
4431    }
4432}
4433
4434impl From<Url> for ClipPath {
4435    fn from(v: Url) -> Self {
4436        Self::Url(v)
4437    }
4438}
4439
4440impl From<Raw> for ClipPath {
4441    fn from(v: Raw) -> Self {
4442        Self::Raw(v)
4443    }
4444}
4445
4446/// A value of [`clip-rule`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/clip-rule).
4447#[derive(Debug, Clone, PartialEq)]
4448#[non_exhaustive]
4449pub enum ClipRule {
4450    /// `evenodd`.
4451    Evenodd,
4452    /// `nonzero`.
4453    Nonzero,
4454}
4455
4456impl fmt::Display for ClipRule {
4457    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4458        match self {
4459            Self::Evenodd => f.write_str("evenodd"),
4460            Self::Nonzero => f.write_str("nonzero"),
4461        }
4462    }
4463}
4464
4465/// A value of [`color-interpolation-filters`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/color-interpolation-filters).
4466#[derive(Debug, Clone, PartialEq)]
4467#[non_exhaustive]
4468pub enum ColorInterpolationFilters {
4469    /// `auto`.
4470    Auto,
4471    /// `linearRGB`.
4472    LinearRGB,
4473    /// `sRGB`.
4474    SRGB,
4475}
4476
4477impl fmt::Display for ColorInterpolationFilters {
4478    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4479        match self {
4480            Self::Auto => f.write_str("auto"),
4481            Self::LinearRGB => f.write_str("linearRGB"),
4482            Self::SRGB => f.write_str("sRGB"),
4483        }
4484    }
4485}
4486
4487/// A value of [`color-scheme`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/color-scheme).
4488#[derive(Debug, Clone, PartialEq)]
4489#[non_exhaustive]
4490pub enum ColorScheme {
4491    /// `normal`.
4492    Normal,
4493    /// Any other value, passed through unchecked.
4494    Raw(Raw),
4495}
4496
4497impl fmt::Display for ColorScheme {
4498    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4499        match self {
4500            Self::Normal => f.write_str("normal"),
4501            Self::Raw(v) => v.fmt(f),
4502        }
4503    }
4504}
4505
4506impl From<Raw> for ColorScheme {
4507    fn from(v: Raw) -> Self {
4508        Self::Raw(v)
4509    }
4510}
4511
4512/// A value of [`column-count`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-count).
4513#[derive(Debug, Clone, PartialEq)]
4514#[non_exhaustive]
4515pub enum ColumnCount {
4516    /// `auto`.
4517    Auto,
4518    /// An integer.
4519    Integer(i32),
4520}
4521
4522impl fmt::Display for ColumnCount {
4523    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4524        match self {
4525            Self::Auto => f.write_str("auto"),
4526            Self::Integer(v) => v.fmt(f),
4527        }
4528    }
4529}
4530
4531impl From<i32> for ColumnCount {
4532    fn from(v: i32) -> Self {
4533        Self::Integer(v)
4534    }
4535}
4536
4537/// A value of [`column-fill`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-fill).
4538#[derive(Debug, Clone, PartialEq)]
4539#[non_exhaustive]
4540pub enum ColumnFill {
4541    /// `auto`.
4542    Auto,
4543    /// `balance`.
4544    Balance,
4545}
4546
4547impl fmt::Display for ColumnFill {
4548    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4549        match self {
4550            Self::Auto => f.write_str("auto"),
4551            Self::Balance => f.write_str("balance"),
4552        }
4553    }
4554}
4555
4556/// A value of [`column-gap`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-gap).
4557#[derive(Debug, Clone, PartialEq)]
4558#[non_exhaustive]
4559pub enum ColumnGap {
4560    /// `normal`.
4561    Normal,
4562    /// A length.
4563    Length(Length),
4564    /// A percentage.
4565    Percentage(Percentage),
4566}
4567
4568impl fmt::Display for ColumnGap {
4569    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4570        match self {
4571            Self::Normal => f.write_str("normal"),
4572            Self::Length(v) => v.fmt(f),
4573            Self::Percentage(v) => v.fmt(f),
4574        }
4575    }
4576}
4577
4578impl From<Length> for ColumnGap {
4579    fn from(v: Length) -> Self {
4580        Self::Length(v)
4581    }
4582}
4583
4584impl From<Percentage> for ColumnGap {
4585    fn from(v: Percentage) -> Self {
4586        Self::Percentage(v)
4587    }
4588}
4589
4590/// A value of [`column-height`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-height).
4591#[derive(Debug, Clone, PartialEq)]
4592#[non_exhaustive]
4593pub enum ColumnHeight {
4594    /// `auto`.
4595    Auto,
4596    /// A length.
4597    Length(Length),
4598}
4599
4600impl fmt::Display for ColumnHeight {
4601    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4602        match self {
4603            Self::Auto => f.write_str("auto"),
4604            Self::Length(v) => v.fmt(f),
4605        }
4606    }
4607}
4608
4609impl From<Length> for ColumnHeight {
4610    fn from(v: Length) -> Self {
4611        Self::Length(v)
4612    }
4613}
4614
4615/// A value of [`column-rule`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-rule).
4616#[derive(Debug, Clone, PartialEq)]
4617#[non_exhaustive]
4618pub enum ColumnRule {
4619    /// `dashed`.
4620    Dashed,
4621    /// `dotted`.
4622    Dotted,
4623    /// `double`.
4624    Double,
4625    /// `groove`.
4626    Groove,
4627    /// `hidden`.
4628    Hidden,
4629    /// `inset`.
4630    Inset,
4631    /// `medium`.
4632    Medium,
4633    /// `none`.
4634    None,
4635    /// `outset`.
4636    Outset,
4637    /// `ridge`.
4638    Ridge,
4639    /// `solid`.
4640    Solid,
4641    /// `thick`.
4642    Thick,
4643    /// `thin`.
4644    Thin,
4645    /// A length.
4646    Length(Length),
4647    /// A color.
4648    Color(Color),
4649    /// Any other value, passed through unchecked.
4650    Raw(Raw),
4651}
4652
4653impl fmt::Display for ColumnRule {
4654    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4655        match self {
4656            Self::Dashed => f.write_str("dashed"),
4657            Self::Dotted => f.write_str("dotted"),
4658            Self::Double => f.write_str("double"),
4659            Self::Groove => f.write_str("groove"),
4660            Self::Hidden => f.write_str("hidden"),
4661            Self::Inset => f.write_str("inset"),
4662            Self::Medium => f.write_str("medium"),
4663            Self::None => f.write_str("none"),
4664            Self::Outset => f.write_str("outset"),
4665            Self::Ridge => f.write_str("ridge"),
4666            Self::Solid => f.write_str("solid"),
4667            Self::Thick => f.write_str("thick"),
4668            Self::Thin => f.write_str("thin"),
4669            Self::Length(v) => v.fmt(f),
4670            Self::Color(v) => v.fmt(f),
4671            Self::Raw(v) => v.fmt(f),
4672        }
4673    }
4674}
4675
4676impl From<Length> for ColumnRule {
4677    fn from(v: Length) -> Self {
4678        Self::Length(v)
4679    }
4680}
4681
4682impl From<Color> for ColumnRule {
4683    fn from(v: Color) -> Self {
4684        Self::Color(v)
4685    }
4686}
4687
4688impl From<Raw> for ColumnRule {
4689    fn from(v: Raw) -> Self {
4690        Self::Raw(v)
4691    }
4692}
4693
4694/// A value of [`column-rule-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-rule-style).
4695#[derive(Debug, Clone, PartialEq)]
4696#[non_exhaustive]
4697pub enum ColumnRuleStyle {
4698    /// `dashed`.
4699    Dashed,
4700    /// `dotted`.
4701    Dotted,
4702    /// `double`.
4703    Double,
4704    /// `groove`.
4705    Groove,
4706    /// `hidden`.
4707    Hidden,
4708    /// `inset`.
4709    Inset,
4710    /// `none`.
4711    None,
4712    /// `outset`.
4713    Outset,
4714    /// `ridge`.
4715    Ridge,
4716    /// `solid`.
4717    Solid,
4718}
4719
4720impl fmt::Display for ColumnRuleStyle {
4721    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4722        match self {
4723            Self::Dashed => f.write_str("dashed"),
4724            Self::Dotted => f.write_str("dotted"),
4725            Self::Double => f.write_str("double"),
4726            Self::Groove => f.write_str("groove"),
4727            Self::Hidden => f.write_str("hidden"),
4728            Self::Inset => f.write_str("inset"),
4729            Self::None => f.write_str("none"),
4730            Self::Outset => f.write_str("outset"),
4731            Self::Ridge => f.write_str("ridge"),
4732            Self::Solid => f.write_str("solid"),
4733        }
4734    }
4735}
4736
4737/// A value of [`column-rule-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-rule-width).
4738#[derive(Debug, Clone, PartialEq)]
4739#[non_exhaustive]
4740pub enum ColumnRuleWidth {
4741    /// `medium`.
4742    Medium,
4743    /// `thick`.
4744    Thick,
4745    /// `thin`.
4746    Thin,
4747    /// A length.
4748    Length(Length),
4749}
4750
4751impl fmt::Display for ColumnRuleWidth {
4752    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4753        match self {
4754            Self::Medium => f.write_str("medium"),
4755            Self::Thick => f.write_str("thick"),
4756            Self::Thin => f.write_str("thin"),
4757            Self::Length(v) => v.fmt(f),
4758        }
4759    }
4760}
4761
4762impl From<Length> for ColumnRuleWidth {
4763    fn from(v: Length) -> Self {
4764        Self::Length(v)
4765    }
4766}
4767
4768/// A value of [`column-span`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-span).
4769#[derive(Debug, Clone, PartialEq)]
4770#[non_exhaustive]
4771pub enum ColumnSpan {
4772    /// `all`.
4773    All,
4774    /// `none`.
4775    None,
4776}
4777
4778impl fmt::Display for ColumnSpan {
4779    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4780        match self {
4781            Self::All => f.write_str("all"),
4782            Self::None => f.write_str("none"),
4783        }
4784    }
4785}
4786
4787/// A value of [`column-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-width).
4788#[derive(Debug, Clone, PartialEq)]
4789#[non_exhaustive]
4790pub enum ColumnWidth {
4791    /// `auto`.
4792    Auto,
4793    /// A length.
4794    Length(Length),
4795}
4796
4797impl fmt::Display for ColumnWidth {
4798    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4799        match self {
4800            Self::Auto => f.write_str("auto"),
4801            Self::Length(v) => v.fmt(f),
4802        }
4803    }
4804}
4805
4806impl From<Length> for ColumnWidth {
4807    fn from(v: Length) -> Self {
4808        Self::Length(v)
4809    }
4810}
4811
4812/// A value of [`column-wrap`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/column-wrap).
4813#[derive(Debug, Clone, PartialEq)]
4814#[non_exhaustive]
4815pub enum ColumnWrap {
4816    /// `auto`.
4817    Auto,
4818    /// `nowrap`.
4819    Nowrap,
4820    /// `wrap`.
4821    Wrap,
4822}
4823
4824impl fmt::Display for ColumnWrap {
4825    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4826        match self {
4827            Self::Auto => f.write_str("auto"),
4828            Self::Nowrap => f.write_str("nowrap"),
4829            Self::Wrap => f.write_str("wrap"),
4830        }
4831    }
4832}
4833
4834/// A value of [`columns`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/columns).
4835#[derive(Debug, Clone, PartialEq)]
4836#[non_exhaustive]
4837pub enum Columns {
4838    /// `auto`.
4839    Auto,
4840    /// A length.
4841    Length(Length),
4842    /// An integer.
4843    Integer(i32),
4844    /// Any other value, passed through unchecked.
4845    Raw(Raw),
4846}
4847
4848impl fmt::Display for Columns {
4849    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4850        match self {
4851            Self::Auto => f.write_str("auto"),
4852            Self::Length(v) => v.fmt(f),
4853            Self::Integer(v) => v.fmt(f),
4854            Self::Raw(v) => v.fmt(f),
4855        }
4856    }
4857}
4858
4859impl From<Length> for Columns {
4860    fn from(v: Length) -> Self {
4861        Self::Length(v)
4862    }
4863}
4864
4865impl From<i32> for Columns {
4866    fn from(v: i32) -> Self {
4867        Self::Integer(v)
4868    }
4869}
4870
4871impl From<Raw> for Columns {
4872    fn from(v: Raw) -> Self {
4873        Self::Raw(v)
4874    }
4875}
4876
4877/// A value of [`contain`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/contain).
4878#[derive(Debug, Clone, PartialEq)]
4879#[non_exhaustive]
4880pub enum Contain {
4881    /// `content`.
4882    Content,
4883    /// `inline-size`.
4884    InlineSize,
4885    /// `layout`.
4886    Layout,
4887    /// `none`.
4888    None,
4889    /// `paint`.
4890    Paint,
4891    /// `size`.
4892    Size,
4893    /// `strict`.
4894    Strict,
4895    /// `style`.
4896    Style,
4897    /// Any other value, passed through unchecked.
4898    Raw(Raw),
4899}
4900
4901impl fmt::Display for Contain {
4902    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4903        match self {
4904            Self::Content => f.write_str("content"),
4905            Self::InlineSize => f.write_str("inline-size"),
4906            Self::Layout => f.write_str("layout"),
4907            Self::None => f.write_str("none"),
4908            Self::Paint => f.write_str("paint"),
4909            Self::Size => f.write_str("size"),
4910            Self::Strict => f.write_str("strict"),
4911            Self::Style => f.write_str("style"),
4912            Self::Raw(v) => v.fmt(f),
4913        }
4914    }
4915}
4916
4917impl From<Raw> for Contain {
4918    fn from(v: Raw) -> Self {
4919        Self::Raw(v)
4920    }
4921}
4922
4923/// A value of [`contain-intrinsic-block-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/contain-intrinsic-block-size).
4924#[derive(Debug, Clone, PartialEq)]
4925#[non_exhaustive]
4926pub enum ContainIntrinsicBlockSize {
4927    /// `none`.
4928    None,
4929    /// A length.
4930    Length(Length),
4931    /// Any other value, passed through unchecked.
4932    Raw(Raw),
4933}
4934
4935impl fmt::Display for ContainIntrinsicBlockSize {
4936    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4937        match self {
4938            Self::None => f.write_str("none"),
4939            Self::Length(v) => v.fmt(f),
4940            Self::Raw(v) => v.fmt(f),
4941        }
4942    }
4943}
4944
4945impl From<Length> for ContainIntrinsicBlockSize {
4946    fn from(v: Length) -> Self {
4947        Self::Length(v)
4948    }
4949}
4950
4951impl From<Raw> for ContainIntrinsicBlockSize {
4952    fn from(v: Raw) -> Self {
4953        Self::Raw(v)
4954    }
4955}
4956
4957/// A value of [`contain-intrinsic-height`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/contain-intrinsic-height).
4958#[derive(Debug, Clone, PartialEq)]
4959#[non_exhaustive]
4960pub enum ContainIntrinsicHeight {
4961    /// `none`.
4962    None,
4963    /// A length.
4964    Length(Length),
4965    /// Any other value, passed through unchecked.
4966    Raw(Raw),
4967}
4968
4969impl fmt::Display for ContainIntrinsicHeight {
4970    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4971        match self {
4972            Self::None => f.write_str("none"),
4973            Self::Length(v) => v.fmt(f),
4974            Self::Raw(v) => v.fmt(f),
4975        }
4976    }
4977}
4978
4979impl From<Length> for ContainIntrinsicHeight {
4980    fn from(v: Length) -> Self {
4981        Self::Length(v)
4982    }
4983}
4984
4985impl From<Raw> for ContainIntrinsicHeight {
4986    fn from(v: Raw) -> Self {
4987        Self::Raw(v)
4988    }
4989}
4990
4991/// A value of [`contain-intrinsic-inline-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/contain-intrinsic-inline-size).
4992#[derive(Debug, Clone, PartialEq)]
4993#[non_exhaustive]
4994pub enum ContainIntrinsicInlineSize {
4995    /// `none`.
4996    None,
4997    /// A length.
4998    Length(Length),
4999    /// Any other value, passed through unchecked.
5000    Raw(Raw),
5001}
5002
5003impl fmt::Display for ContainIntrinsicInlineSize {
5004    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5005        match self {
5006            Self::None => f.write_str("none"),
5007            Self::Length(v) => v.fmt(f),
5008            Self::Raw(v) => v.fmt(f),
5009        }
5010    }
5011}
5012
5013impl From<Length> for ContainIntrinsicInlineSize {
5014    fn from(v: Length) -> Self {
5015        Self::Length(v)
5016    }
5017}
5018
5019impl From<Raw> for ContainIntrinsicInlineSize {
5020    fn from(v: Raw) -> Self {
5021        Self::Raw(v)
5022    }
5023}
5024
5025/// A value of [`contain-intrinsic-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/contain-intrinsic-size).
5026#[derive(Debug, Clone, PartialEq)]
5027#[non_exhaustive]
5028pub enum ContainIntrinsicSize {
5029    /// `none`.
5030    None,
5031    /// A length.
5032    Length(Length),
5033    /// Any other value, passed through unchecked.
5034    Raw(Raw),
5035}
5036
5037impl fmt::Display for ContainIntrinsicSize {
5038    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5039        match self {
5040            Self::None => f.write_str("none"),
5041            Self::Length(v) => v.fmt(f),
5042            Self::Raw(v) => v.fmt(f),
5043        }
5044    }
5045}
5046
5047impl From<Length> for ContainIntrinsicSize {
5048    fn from(v: Length) -> Self {
5049        Self::Length(v)
5050    }
5051}
5052
5053impl From<Raw> for ContainIntrinsicSize {
5054    fn from(v: Raw) -> Self {
5055        Self::Raw(v)
5056    }
5057}
5058
5059/// A value of [`contain-intrinsic-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/contain-intrinsic-width).
5060#[derive(Debug, Clone, PartialEq)]
5061#[non_exhaustive]
5062pub enum ContainIntrinsicWidth {
5063    /// `none`.
5064    None,
5065    /// A length.
5066    Length(Length),
5067    /// Any other value, passed through unchecked.
5068    Raw(Raw),
5069}
5070
5071impl fmt::Display for ContainIntrinsicWidth {
5072    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5073        match self {
5074            Self::None => f.write_str("none"),
5075            Self::Length(v) => v.fmt(f),
5076            Self::Raw(v) => v.fmt(f),
5077        }
5078    }
5079}
5080
5081impl From<Length> for ContainIntrinsicWidth {
5082    fn from(v: Length) -> Self {
5083        Self::Length(v)
5084    }
5085}
5086
5087impl From<Raw> for ContainIntrinsicWidth {
5088    fn from(v: Raw) -> Self {
5089        Self::Raw(v)
5090    }
5091}
5092
5093/// A value of [`container`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/container).
5094#[derive(Debug, Clone, PartialEq)]
5095#[non_exhaustive]
5096pub enum Container {
5097    /// `none`.
5098    None,
5099    /// Any other value, passed through unchecked.
5100    Raw(Raw),
5101}
5102
5103impl fmt::Display for Container {
5104    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5105        match self {
5106            Self::None => f.write_str("none"),
5107            Self::Raw(v) => v.fmt(f),
5108        }
5109    }
5110}
5111
5112impl From<Raw> for Container {
5113    fn from(v: Raw) -> Self {
5114        Self::Raw(v)
5115    }
5116}
5117
5118/// A value of [`container-name`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/container-name).
5119#[derive(Debug, Clone, PartialEq)]
5120#[non_exhaustive]
5121pub enum ContainerName {
5122    /// `none`.
5123    None,
5124    /// Any other value, passed through unchecked.
5125    Raw(Raw),
5126}
5127
5128impl fmt::Display for ContainerName {
5129    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5130        match self {
5131            Self::None => f.write_str("none"),
5132            Self::Raw(v) => v.fmt(f),
5133        }
5134    }
5135}
5136
5137impl From<Raw> for ContainerName {
5138    fn from(v: Raw) -> Self {
5139        Self::Raw(v)
5140    }
5141}
5142
5143/// A value of [`container-type`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/container-type).
5144#[derive(Debug, Clone, PartialEq)]
5145#[non_exhaustive]
5146pub enum ContainerType {
5147    /// `inline-size`.
5148    InlineSize,
5149    /// `normal`.
5150    Normal,
5151    /// `scroll-state`.
5152    ScrollState,
5153    /// `size`.
5154    Size,
5155    /// Any other value, passed through unchecked.
5156    Raw(Raw),
5157}
5158
5159impl fmt::Display for ContainerType {
5160    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5161        match self {
5162            Self::InlineSize => f.write_str("inline-size"),
5163            Self::Normal => f.write_str("normal"),
5164            Self::ScrollState => f.write_str("scroll-state"),
5165            Self::Size => f.write_str("size"),
5166            Self::Raw(v) => v.fmt(f),
5167        }
5168    }
5169}
5170
5171impl From<Raw> for ContainerType {
5172    fn from(v: Raw) -> Self {
5173        Self::Raw(v)
5174    }
5175}
5176
5177/// A value of [`content`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/content).
5178#[derive(Debug, Clone, PartialEq)]
5179#[non_exhaustive]
5180pub enum Content {
5181    /// `close-quote`.
5182    CloseQuote,
5183    /// `no-close-quote`.
5184    NoCloseQuote,
5185    /// `no-open-quote`.
5186    NoOpenQuote,
5187    /// `none`.
5188    None,
5189    /// `normal`.
5190    Normal,
5191    /// `open-quote`.
5192    OpenQuote,
5193    /// A quoted string.
5194    Quoted(Quoted),
5195    /// A URL.
5196    Url(Url),
5197    /// Any other value, passed through unchecked.
5198    Raw(Raw),
5199}
5200
5201impl fmt::Display for Content {
5202    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5203        match self {
5204            Self::CloseQuote => f.write_str("close-quote"),
5205            Self::NoCloseQuote => f.write_str("no-close-quote"),
5206            Self::NoOpenQuote => f.write_str("no-open-quote"),
5207            Self::None => f.write_str("none"),
5208            Self::Normal => f.write_str("normal"),
5209            Self::OpenQuote => f.write_str("open-quote"),
5210            Self::Quoted(v) => v.fmt(f),
5211            Self::Url(v) => v.fmt(f),
5212            Self::Raw(v) => v.fmt(f),
5213        }
5214    }
5215}
5216
5217impl From<Quoted> for Content {
5218    fn from(v: Quoted) -> Self {
5219        Self::Quoted(v)
5220    }
5221}
5222
5223impl From<Url> for Content {
5224    fn from(v: Url) -> Self {
5225        Self::Url(v)
5226    }
5227}
5228
5229impl From<Raw> for Content {
5230    fn from(v: Raw) -> Self {
5231        Self::Raw(v)
5232    }
5233}
5234
5235/// A value of [`content-visibility`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/content-visibility).
5236#[derive(Debug, Clone, PartialEq)]
5237#[non_exhaustive]
5238pub enum ContentVisibility {
5239    /// `auto`.
5240    Auto,
5241    /// `hidden`.
5242    Hidden,
5243    /// `visible`.
5244    Visible,
5245}
5246
5247impl fmt::Display for ContentVisibility {
5248    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5249        match self {
5250            Self::Auto => f.write_str("auto"),
5251            Self::Hidden => f.write_str("hidden"),
5252            Self::Visible => f.write_str("visible"),
5253        }
5254    }
5255}
5256
5257/// A value of [`corner-block-end-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-block-end-shape).
5258#[derive(Debug, Clone, PartialEq)]
5259#[non_exhaustive]
5260pub enum CornerBlockEndShape {
5261    /// `bevel`.
5262    Bevel,
5263    /// `notch`.
5264    Notch,
5265    /// `round`.
5266    Round,
5267    /// `scoop`.
5268    Scoop,
5269    /// `square`.
5270    Square,
5271    /// `squircle`.
5272    Squircle,
5273    /// Any other value, passed through unchecked.
5274    Raw(Raw),
5275}
5276
5277impl fmt::Display for CornerBlockEndShape {
5278    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5279        match self {
5280            Self::Bevel => f.write_str("bevel"),
5281            Self::Notch => f.write_str("notch"),
5282            Self::Round => f.write_str("round"),
5283            Self::Scoop => f.write_str("scoop"),
5284            Self::Square => f.write_str("square"),
5285            Self::Squircle => f.write_str("squircle"),
5286            Self::Raw(v) => v.fmt(f),
5287        }
5288    }
5289}
5290
5291impl From<Raw> for CornerBlockEndShape {
5292    fn from(v: Raw) -> Self {
5293        Self::Raw(v)
5294    }
5295}
5296
5297/// A value of [`corner-block-start-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-block-start-shape).
5298#[derive(Debug, Clone, PartialEq)]
5299#[non_exhaustive]
5300pub enum CornerBlockStartShape {
5301    /// `bevel`.
5302    Bevel,
5303    /// `notch`.
5304    Notch,
5305    /// `round`.
5306    Round,
5307    /// `scoop`.
5308    Scoop,
5309    /// `square`.
5310    Square,
5311    /// `squircle`.
5312    Squircle,
5313    /// Any other value, passed through unchecked.
5314    Raw(Raw),
5315}
5316
5317impl fmt::Display for CornerBlockStartShape {
5318    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5319        match self {
5320            Self::Bevel => f.write_str("bevel"),
5321            Self::Notch => f.write_str("notch"),
5322            Self::Round => f.write_str("round"),
5323            Self::Scoop => f.write_str("scoop"),
5324            Self::Square => f.write_str("square"),
5325            Self::Squircle => f.write_str("squircle"),
5326            Self::Raw(v) => v.fmt(f),
5327        }
5328    }
5329}
5330
5331impl From<Raw> for CornerBlockStartShape {
5332    fn from(v: Raw) -> Self {
5333        Self::Raw(v)
5334    }
5335}
5336
5337/// A value of [`corner-bottom-left-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-bottom-left-shape).
5338#[derive(Debug, Clone, PartialEq)]
5339#[non_exhaustive]
5340pub enum CornerBottomLeftShape {
5341    /// `bevel`.
5342    Bevel,
5343    /// `notch`.
5344    Notch,
5345    /// `round`.
5346    Round,
5347    /// `scoop`.
5348    Scoop,
5349    /// `square`.
5350    Square,
5351    /// `squircle`.
5352    Squircle,
5353    /// Any other value, passed through unchecked.
5354    Raw(Raw),
5355}
5356
5357impl fmt::Display for CornerBottomLeftShape {
5358    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5359        match self {
5360            Self::Bevel => f.write_str("bevel"),
5361            Self::Notch => f.write_str("notch"),
5362            Self::Round => f.write_str("round"),
5363            Self::Scoop => f.write_str("scoop"),
5364            Self::Square => f.write_str("square"),
5365            Self::Squircle => f.write_str("squircle"),
5366            Self::Raw(v) => v.fmt(f),
5367        }
5368    }
5369}
5370
5371impl From<Raw> for CornerBottomLeftShape {
5372    fn from(v: Raw) -> Self {
5373        Self::Raw(v)
5374    }
5375}
5376
5377/// A value of [`corner-bottom-right-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-bottom-right-shape).
5378#[derive(Debug, Clone, PartialEq)]
5379#[non_exhaustive]
5380pub enum CornerBottomRightShape {
5381    /// `bevel`.
5382    Bevel,
5383    /// `notch`.
5384    Notch,
5385    /// `round`.
5386    Round,
5387    /// `scoop`.
5388    Scoop,
5389    /// `square`.
5390    Square,
5391    /// `squircle`.
5392    Squircle,
5393    /// Any other value, passed through unchecked.
5394    Raw(Raw),
5395}
5396
5397impl fmt::Display for CornerBottomRightShape {
5398    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5399        match self {
5400            Self::Bevel => f.write_str("bevel"),
5401            Self::Notch => f.write_str("notch"),
5402            Self::Round => f.write_str("round"),
5403            Self::Scoop => f.write_str("scoop"),
5404            Self::Square => f.write_str("square"),
5405            Self::Squircle => f.write_str("squircle"),
5406            Self::Raw(v) => v.fmt(f),
5407        }
5408    }
5409}
5410
5411impl From<Raw> for CornerBottomRightShape {
5412    fn from(v: Raw) -> Self {
5413        Self::Raw(v)
5414    }
5415}
5416
5417/// A value of [`corner-bottom-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-bottom-shape).
5418#[derive(Debug, Clone, PartialEq)]
5419#[non_exhaustive]
5420pub enum CornerBottomShape {
5421    /// `bevel`.
5422    Bevel,
5423    /// `notch`.
5424    Notch,
5425    /// `round`.
5426    Round,
5427    /// `scoop`.
5428    Scoop,
5429    /// `square`.
5430    Square,
5431    /// `squircle`.
5432    Squircle,
5433    /// Any other value, passed through unchecked.
5434    Raw(Raw),
5435}
5436
5437impl fmt::Display for CornerBottomShape {
5438    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5439        match self {
5440            Self::Bevel => f.write_str("bevel"),
5441            Self::Notch => f.write_str("notch"),
5442            Self::Round => f.write_str("round"),
5443            Self::Scoop => f.write_str("scoop"),
5444            Self::Square => f.write_str("square"),
5445            Self::Squircle => f.write_str("squircle"),
5446            Self::Raw(v) => v.fmt(f),
5447        }
5448    }
5449}
5450
5451impl From<Raw> for CornerBottomShape {
5452    fn from(v: Raw) -> Self {
5453        Self::Raw(v)
5454    }
5455}
5456
5457/// A value of [`corner-end-end-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-end-end-shape).
5458#[derive(Debug, Clone, PartialEq)]
5459#[non_exhaustive]
5460pub enum CornerEndEndShape {
5461    /// `bevel`.
5462    Bevel,
5463    /// `notch`.
5464    Notch,
5465    /// `round`.
5466    Round,
5467    /// `scoop`.
5468    Scoop,
5469    /// `square`.
5470    Square,
5471    /// `squircle`.
5472    Squircle,
5473    /// Any other value, passed through unchecked.
5474    Raw(Raw),
5475}
5476
5477impl fmt::Display for CornerEndEndShape {
5478    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5479        match self {
5480            Self::Bevel => f.write_str("bevel"),
5481            Self::Notch => f.write_str("notch"),
5482            Self::Round => f.write_str("round"),
5483            Self::Scoop => f.write_str("scoop"),
5484            Self::Square => f.write_str("square"),
5485            Self::Squircle => f.write_str("squircle"),
5486            Self::Raw(v) => v.fmt(f),
5487        }
5488    }
5489}
5490
5491impl From<Raw> for CornerEndEndShape {
5492    fn from(v: Raw) -> Self {
5493        Self::Raw(v)
5494    }
5495}
5496
5497/// A value of [`corner-end-start-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-end-start-shape).
5498#[derive(Debug, Clone, PartialEq)]
5499#[non_exhaustive]
5500pub enum CornerEndStartShape {
5501    /// `bevel`.
5502    Bevel,
5503    /// `notch`.
5504    Notch,
5505    /// `round`.
5506    Round,
5507    /// `scoop`.
5508    Scoop,
5509    /// `square`.
5510    Square,
5511    /// `squircle`.
5512    Squircle,
5513    /// Any other value, passed through unchecked.
5514    Raw(Raw),
5515}
5516
5517impl fmt::Display for CornerEndStartShape {
5518    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5519        match self {
5520            Self::Bevel => f.write_str("bevel"),
5521            Self::Notch => f.write_str("notch"),
5522            Self::Round => f.write_str("round"),
5523            Self::Scoop => f.write_str("scoop"),
5524            Self::Square => f.write_str("square"),
5525            Self::Squircle => f.write_str("squircle"),
5526            Self::Raw(v) => v.fmt(f),
5527        }
5528    }
5529}
5530
5531impl From<Raw> for CornerEndStartShape {
5532    fn from(v: Raw) -> Self {
5533        Self::Raw(v)
5534    }
5535}
5536
5537/// A value of [`corner-inline-end-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-inline-end-shape).
5538#[derive(Debug, Clone, PartialEq)]
5539#[non_exhaustive]
5540pub enum CornerInlineEndShape {
5541    /// `bevel`.
5542    Bevel,
5543    /// `notch`.
5544    Notch,
5545    /// `round`.
5546    Round,
5547    /// `scoop`.
5548    Scoop,
5549    /// `square`.
5550    Square,
5551    /// `squircle`.
5552    Squircle,
5553    /// Any other value, passed through unchecked.
5554    Raw(Raw),
5555}
5556
5557impl fmt::Display for CornerInlineEndShape {
5558    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5559        match self {
5560            Self::Bevel => f.write_str("bevel"),
5561            Self::Notch => f.write_str("notch"),
5562            Self::Round => f.write_str("round"),
5563            Self::Scoop => f.write_str("scoop"),
5564            Self::Square => f.write_str("square"),
5565            Self::Squircle => f.write_str("squircle"),
5566            Self::Raw(v) => v.fmt(f),
5567        }
5568    }
5569}
5570
5571impl From<Raw> for CornerInlineEndShape {
5572    fn from(v: Raw) -> Self {
5573        Self::Raw(v)
5574    }
5575}
5576
5577/// A value of [`corner-inline-start-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-inline-start-shape).
5578#[derive(Debug, Clone, PartialEq)]
5579#[non_exhaustive]
5580pub enum CornerInlineStartShape {
5581    /// `bevel`.
5582    Bevel,
5583    /// `notch`.
5584    Notch,
5585    /// `round`.
5586    Round,
5587    /// `scoop`.
5588    Scoop,
5589    /// `square`.
5590    Square,
5591    /// `squircle`.
5592    Squircle,
5593    /// Any other value, passed through unchecked.
5594    Raw(Raw),
5595}
5596
5597impl fmt::Display for CornerInlineStartShape {
5598    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5599        match self {
5600            Self::Bevel => f.write_str("bevel"),
5601            Self::Notch => f.write_str("notch"),
5602            Self::Round => f.write_str("round"),
5603            Self::Scoop => f.write_str("scoop"),
5604            Self::Square => f.write_str("square"),
5605            Self::Squircle => f.write_str("squircle"),
5606            Self::Raw(v) => v.fmt(f),
5607        }
5608    }
5609}
5610
5611impl From<Raw> for CornerInlineStartShape {
5612    fn from(v: Raw) -> Self {
5613        Self::Raw(v)
5614    }
5615}
5616
5617/// A value of [`corner-left-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-left-shape).
5618#[derive(Debug, Clone, PartialEq)]
5619#[non_exhaustive]
5620pub enum CornerLeftShape {
5621    /// `bevel`.
5622    Bevel,
5623    /// `notch`.
5624    Notch,
5625    /// `round`.
5626    Round,
5627    /// `scoop`.
5628    Scoop,
5629    /// `square`.
5630    Square,
5631    /// `squircle`.
5632    Squircle,
5633    /// Any other value, passed through unchecked.
5634    Raw(Raw),
5635}
5636
5637impl fmt::Display for CornerLeftShape {
5638    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5639        match self {
5640            Self::Bevel => f.write_str("bevel"),
5641            Self::Notch => f.write_str("notch"),
5642            Self::Round => f.write_str("round"),
5643            Self::Scoop => f.write_str("scoop"),
5644            Self::Square => f.write_str("square"),
5645            Self::Squircle => f.write_str("squircle"),
5646            Self::Raw(v) => v.fmt(f),
5647        }
5648    }
5649}
5650
5651impl From<Raw> for CornerLeftShape {
5652    fn from(v: Raw) -> Self {
5653        Self::Raw(v)
5654    }
5655}
5656
5657/// A value of [`corner-right-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-right-shape).
5658#[derive(Debug, Clone, PartialEq)]
5659#[non_exhaustive]
5660pub enum CornerRightShape {
5661    /// `bevel`.
5662    Bevel,
5663    /// `notch`.
5664    Notch,
5665    /// `round`.
5666    Round,
5667    /// `scoop`.
5668    Scoop,
5669    /// `square`.
5670    Square,
5671    /// `squircle`.
5672    Squircle,
5673    /// Any other value, passed through unchecked.
5674    Raw(Raw),
5675}
5676
5677impl fmt::Display for CornerRightShape {
5678    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5679        match self {
5680            Self::Bevel => f.write_str("bevel"),
5681            Self::Notch => f.write_str("notch"),
5682            Self::Round => f.write_str("round"),
5683            Self::Scoop => f.write_str("scoop"),
5684            Self::Square => f.write_str("square"),
5685            Self::Squircle => f.write_str("squircle"),
5686            Self::Raw(v) => v.fmt(f),
5687        }
5688    }
5689}
5690
5691impl From<Raw> for CornerRightShape {
5692    fn from(v: Raw) -> Self {
5693        Self::Raw(v)
5694    }
5695}
5696
5697/// A value of [`corner-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-shape).
5698#[derive(Debug, Clone, PartialEq)]
5699#[non_exhaustive]
5700pub enum CornerShape {
5701    /// `bevel`.
5702    Bevel,
5703    /// `notch`.
5704    Notch,
5705    /// `round`.
5706    Round,
5707    /// `scoop`.
5708    Scoop,
5709    /// `square`.
5710    Square,
5711    /// `squircle`.
5712    Squircle,
5713    /// Any other value, passed through unchecked.
5714    Raw(Raw),
5715}
5716
5717impl fmt::Display for CornerShape {
5718    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5719        match self {
5720            Self::Bevel => f.write_str("bevel"),
5721            Self::Notch => f.write_str("notch"),
5722            Self::Round => f.write_str("round"),
5723            Self::Scoop => f.write_str("scoop"),
5724            Self::Square => f.write_str("square"),
5725            Self::Squircle => f.write_str("squircle"),
5726            Self::Raw(v) => v.fmt(f),
5727        }
5728    }
5729}
5730
5731impl From<Raw> for CornerShape {
5732    fn from(v: Raw) -> Self {
5733        Self::Raw(v)
5734    }
5735}
5736
5737/// A value of [`corner-start-end-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-start-end-shape).
5738#[derive(Debug, Clone, PartialEq)]
5739#[non_exhaustive]
5740pub enum CornerStartEndShape {
5741    /// `bevel`.
5742    Bevel,
5743    /// `notch`.
5744    Notch,
5745    /// `round`.
5746    Round,
5747    /// `scoop`.
5748    Scoop,
5749    /// `square`.
5750    Square,
5751    /// `squircle`.
5752    Squircle,
5753    /// Any other value, passed through unchecked.
5754    Raw(Raw),
5755}
5756
5757impl fmt::Display for CornerStartEndShape {
5758    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5759        match self {
5760            Self::Bevel => f.write_str("bevel"),
5761            Self::Notch => f.write_str("notch"),
5762            Self::Round => f.write_str("round"),
5763            Self::Scoop => f.write_str("scoop"),
5764            Self::Square => f.write_str("square"),
5765            Self::Squircle => f.write_str("squircle"),
5766            Self::Raw(v) => v.fmt(f),
5767        }
5768    }
5769}
5770
5771impl From<Raw> for CornerStartEndShape {
5772    fn from(v: Raw) -> Self {
5773        Self::Raw(v)
5774    }
5775}
5776
5777/// A value of [`corner-start-start-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-start-start-shape).
5778#[derive(Debug, Clone, PartialEq)]
5779#[non_exhaustive]
5780pub enum CornerStartStartShape {
5781    /// `bevel`.
5782    Bevel,
5783    /// `notch`.
5784    Notch,
5785    /// `round`.
5786    Round,
5787    /// `scoop`.
5788    Scoop,
5789    /// `square`.
5790    Square,
5791    /// `squircle`.
5792    Squircle,
5793    /// Any other value, passed through unchecked.
5794    Raw(Raw),
5795}
5796
5797impl fmt::Display for CornerStartStartShape {
5798    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5799        match self {
5800            Self::Bevel => f.write_str("bevel"),
5801            Self::Notch => f.write_str("notch"),
5802            Self::Round => f.write_str("round"),
5803            Self::Scoop => f.write_str("scoop"),
5804            Self::Square => f.write_str("square"),
5805            Self::Squircle => f.write_str("squircle"),
5806            Self::Raw(v) => v.fmt(f),
5807        }
5808    }
5809}
5810
5811impl From<Raw> for CornerStartStartShape {
5812    fn from(v: Raw) -> Self {
5813        Self::Raw(v)
5814    }
5815}
5816
5817/// A value of [`corner-top-left-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-top-left-shape).
5818#[derive(Debug, Clone, PartialEq)]
5819#[non_exhaustive]
5820pub enum CornerTopLeftShape {
5821    /// `bevel`.
5822    Bevel,
5823    /// `notch`.
5824    Notch,
5825    /// `round`.
5826    Round,
5827    /// `scoop`.
5828    Scoop,
5829    /// `square`.
5830    Square,
5831    /// `squircle`.
5832    Squircle,
5833    /// Any other value, passed through unchecked.
5834    Raw(Raw),
5835}
5836
5837impl fmt::Display for CornerTopLeftShape {
5838    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5839        match self {
5840            Self::Bevel => f.write_str("bevel"),
5841            Self::Notch => f.write_str("notch"),
5842            Self::Round => f.write_str("round"),
5843            Self::Scoop => f.write_str("scoop"),
5844            Self::Square => f.write_str("square"),
5845            Self::Squircle => f.write_str("squircle"),
5846            Self::Raw(v) => v.fmt(f),
5847        }
5848    }
5849}
5850
5851impl From<Raw> for CornerTopLeftShape {
5852    fn from(v: Raw) -> Self {
5853        Self::Raw(v)
5854    }
5855}
5856
5857/// A value of [`corner-top-right-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-top-right-shape).
5858#[derive(Debug, Clone, PartialEq)]
5859#[non_exhaustive]
5860pub enum CornerTopRightShape {
5861    /// `bevel`.
5862    Bevel,
5863    /// `notch`.
5864    Notch,
5865    /// `round`.
5866    Round,
5867    /// `scoop`.
5868    Scoop,
5869    /// `square`.
5870    Square,
5871    /// `squircle`.
5872    Squircle,
5873    /// Any other value, passed through unchecked.
5874    Raw(Raw),
5875}
5876
5877impl fmt::Display for CornerTopRightShape {
5878    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5879        match self {
5880            Self::Bevel => f.write_str("bevel"),
5881            Self::Notch => f.write_str("notch"),
5882            Self::Round => f.write_str("round"),
5883            Self::Scoop => f.write_str("scoop"),
5884            Self::Square => f.write_str("square"),
5885            Self::Squircle => f.write_str("squircle"),
5886            Self::Raw(v) => v.fmt(f),
5887        }
5888    }
5889}
5890
5891impl From<Raw> for CornerTopRightShape {
5892    fn from(v: Raw) -> Self {
5893        Self::Raw(v)
5894    }
5895}
5896
5897/// A value of [`corner-top-shape`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/corner-top-shape).
5898#[derive(Debug, Clone, PartialEq)]
5899#[non_exhaustive]
5900pub enum CornerTopShape {
5901    /// `bevel`.
5902    Bevel,
5903    /// `notch`.
5904    Notch,
5905    /// `round`.
5906    Round,
5907    /// `scoop`.
5908    Scoop,
5909    /// `square`.
5910    Square,
5911    /// `squircle`.
5912    Squircle,
5913    /// Any other value, passed through unchecked.
5914    Raw(Raw),
5915}
5916
5917impl fmt::Display for CornerTopShape {
5918    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5919        match self {
5920            Self::Bevel => f.write_str("bevel"),
5921            Self::Notch => f.write_str("notch"),
5922            Self::Round => f.write_str("round"),
5923            Self::Scoop => f.write_str("scoop"),
5924            Self::Square => f.write_str("square"),
5925            Self::Squircle => f.write_str("squircle"),
5926            Self::Raw(v) => v.fmt(f),
5927        }
5928    }
5929}
5930
5931impl From<Raw> for CornerTopShape {
5932    fn from(v: Raw) -> Self {
5933        Self::Raw(v)
5934    }
5935}
5936
5937/// A value of [`counter-increment`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/counter-increment).
5938#[derive(Debug, Clone, PartialEq)]
5939#[non_exhaustive]
5940pub enum CounterIncrement {
5941    /// `none`.
5942    None,
5943    /// Any other value, passed through unchecked.
5944    Raw(Raw),
5945}
5946
5947impl fmt::Display for CounterIncrement {
5948    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5949        match self {
5950            Self::None => f.write_str("none"),
5951            Self::Raw(v) => v.fmt(f),
5952        }
5953    }
5954}
5955
5956impl From<Raw> for CounterIncrement {
5957    fn from(v: Raw) -> Self {
5958        Self::Raw(v)
5959    }
5960}
5961
5962/// A value of [`counter-reset`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/counter-reset).
5963#[derive(Debug, Clone, PartialEq)]
5964#[non_exhaustive]
5965pub enum CounterReset {
5966    /// `none`.
5967    None,
5968    /// Any other value, passed through unchecked.
5969    Raw(Raw),
5970}
5971
5972impl fmt::Display for CounterReset {
5973    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5974        match self {
5975            Self::None => f.write_str("none"),
5976            Self::Raw(v) => v.fmt(f),
5977        }
5978    }
5979}
5980
5981impl From<Raw> for CounterReset {
5982    fn from(v: Raw) -> Self {
5983        Self::Raw(v)
5984    }
5985}
5986
5987/// A value of [`counter-set`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/counter-set).
5988#[derive(Debug, Clone, PartialEq)]
5989#[non_exhaustive]
5990pub enum CounterSet {
5991    /// `none`.
5992    None,
5993    /// Any other value, passed through unchecked.
5994    Raw(Raw),
5995}
5996
5997impl fmt::Display for CounterSet {
5998    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5999        match self {
6000            Self::None => f.write_str("none"),
6001            Self::Raw(v) => v.fmt(f),
6002        }
6003    }
6004}
6005
6006impl From<Raw> for CounterSet {
6007    fn from(v: Raw) -> Self {
6008        Self::Raw(v)
6009    }
6010}
6011
6012/// A value of [`cursor`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/cursor).
6013#[derive(Debug, Clone, PartialEq)]
6014#[non_exhaustive]
6015pub enum Cursor {
6016    /// `alias`.
6017    Alias,
6018    /// `all-scroll`.
6019    AllScroll,
6020    /// `auto`.
6021    Auto,
6022    /// `cell`.
6023    Cell,
6024    /// `col-resize`.
6025    ColResize,
6026    /// `context-menu`.
6027    ContextMenu,
6028    /// `copy`.
6029    Copy,
6030    /// `crosshair`.
6031    Crosshair,
6032    /// `default`.
6033    Default,
6034    /// `e-resize`.
6035    EResize,
6036    /// `ew-resize`.
6037    EwResize,
6038    /// `grab`.
6039    Grab,
6040    /// `grabbing`.
6041    Grabbing,
6042    /// `help`.
6043    Help,
6044    /// `move`.
6045    Move,
6046    /// `n-resize`.
6047    NResize,
6048    /// `ne-resize`.
6049    NeResize,
6050    /// `nesw-resize`.
6051    NeswResize,
6052    /// `no-drop`.
6053    NoDrop,
6054    /// `none`.
6055    None,
6056    /// `not-allowed`.
6057    NotAllowed,
6058    /// `ns-resize`.
6059    NsResize,
6060    /// `nw-resize`.
6061    NwResize,
6062    /// `nwse-resize`.
6063    NwseResize,
6064    /// `pointer`.
6065    Pointer,
6066    /// `progress`.
6067    Progress,
6068    /// `row-resize`.
6069    RowResize,
6070    /// `s-resize`.
6071    SResize,
6072    /// `se-resize`.
6073    SeResize,
6074    /// `sw-resize`.
6075    SwResize,
6076    /// `text`.
6077    Text,
6078    /// `vertical-text`.
6079    VerticalText,
6080    /// `w-resize`.
6081    WResize,
6082    /// `wait`.
6083    Wait,
6084    /// `zoom-in`.
6085    ZoomIn,
6086    /// `zoom-out`.
6087    ZoomOut,
6088    /// Any other value, passed through unchecked.
6089    Raw(Raw),
6090}
6091
6092impl fmt::Display for Cursor {
6093    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6094        match self {
6095            Self::Alias => f.write_str("alias"),
6096            Self::AllScroll => f.write_str("all-scroll"),
6097            Self::Auto => f.write_str("auto"),
6098            Self::Cell => f.write_str("cell"),
6099            Self::ColResize => f.write_str("col-resize"),
6100            Self::ContextMenu => f.write_str("context-menu"),
6101            Self::Copy => f.write_str("copy"),
6102            Self::Crosshair => f.write_str("crosshair"),
6103            Self::Default => f.write_str("default"),
6104            Self::EResize => f.write_str("e-resize"),
6105            Self::EwResize => f.write_str("ew-resize"),
6106            Self::Grab => f.write_str("grab"),
6107            Self::Grabbing => f.write_str("grabbing"),
6108            Self::Help => f.write_str("help"),
6109            Self::Move => f.write_str("move"),
6110            Self::NResize => f.write_str("n-resize"),
6111            Self::NeResize => f.write_str("ne-resize"),
6112            Self::NeswResize => f.write_str("nesw-resize"),
6113            Self::NoDrop => f.write_str("no-drop"),
6114            Self::None => f.write_str("none"),
6115            Self::NotAllowed => f.write_str("not-allowed"),
6116            Self::NsResize => f.write_str("ns-resize"),
6117            Self::NwResize => f.write_str("nw-resize"),
6118            Self::NwseResize => f.write_str("nwse-resize"),
6119            Self::Pointer => f.write_str("pointer"),
6120            Self::Progress => f.write_str("progress"),
6121            Self::RowResize => f.write_str("row-resize"),
6122            Self::SResize => f.write_str("s-resize"),
6123            Self::SeResize => f.write_str("se-resize"),
6124            Self::SwResize => f.write_str("sw-resize"),
6125            Self::Text => f.write_str("text"),
6126            Self::VerticalText => f.write_str("vertical-text"),
6127            Self::WResize => f.write_str("w-resize"),
6128            Self::Wait => f.write_str("wait"),
6129            Self::ZoomIn => f.write_str("zoom-in"),
6130            Self::ZoomOut => f.write_str("zoom-out"),
6131            Self::Raw(v) => v.fmt(f),
6132        }
6133    }
6134}
6135
6136impl From<Raw> for Cursor {
6137    fn from(v: Raw) -> Self {
6138        Self::Raw(v)
6139    }
6140}
6141
6142/// A value of [`cx`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/cx).
6143#[derive(Debug, Clone, PartialEq)]
6144#[non_exhaustive]
6145pub enum Cx {
6146    /// A length.
6147    Length(Length),
6148    /// A percentage.
6149    Percentage(Percentage),
6150}
6151
6152impl fmt::Display for Cx {
6153    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6154        match self {
6155            Self::Length(v) => v.fmt(f),
6156            Self::Percentage(v) => v.fmt(f),
6157        }
6158    }
6159}
6160
6161impl From<Length> for Cx {
6162    fn from(v: Length) -> Self {
6163        Self::Length(v)
6164    }
6165}
6166
6167impl From<Percentage> for Cx {
6168    fn from(v: Percentage) -> Self {
6169        Self::Percentage(v)
6170    }
6171}
6172
6173/// A value of [`cy`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/cy).
6174#[derive(Debug, Clone, PartialEq)]
6175#[non_exhaustive]
6176pub enum Cy {
6177    /// A length.
6178    Length(Length),
6179    /// A percentage.
6180    Percentage(Percentage),
6181}
6182
6183impl fmt::Display for Cy {
6184    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6185        match self {
6186            Self::Length(v) => v.fmt(f),
6187            Self::Percentage(v) => v.fmt(f),
6188        }
6189    }
6190}
6191
6192impl From<Length> for Cy {
6193    fn from(v: Length) -> Self {
6194        Self::Length(v)
6195    }
6196}
6197
6198impl From<Percentage> for Cy {
6199    fn from(v: Percentage) -> Self {
6200        Self::Percentage(v)
6201    }
6202}
6203
6204/// A value of [`d`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/d).
6205#[derive(Debug, Clone, PartialEq)]
6206#[non_exhaustive]
6207pub enum D {
6208    /// `none`.
6209    None,
6210    /// Any other value, passed through unchecked.
6211    Raw(Raw),
6212}
6213
6214impl fmt::Display for D {
6215    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6216        match self {
6217            Self::None => f.write_str("none"),
6218            Self::Raw(v) => v.fmt(f),
6219        }
6220    }
6221}
6222
6223impl From<Raw> for D {
6224    fn from(v: Raw) -> Self {
6225        Self::Raw(v)
6226    }
6227}
6228
6229/// A value of [`direction`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/direction).
6230#[derive(Debug, Clone, PartialEq)]
6231#[non_exhaustive]
6232pub enum Direction {
6233    /// `ltr`.
6234    Ltr,
6235    /// `rtl`.
6236    Rtl,
6237}
6238
6239impl fmt::Display for Direction {
6240    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6241        match self {
6242            Self::Ltr => f.write_str("ltr"),
6243            Self::Rtl => f.write_str("rtl"),
6244        }
6245    }
6246}
6247
6248/// A value of [`display`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/display).
6249#[derive(Debug, Clone, PartialEq)]
6250#[non_exhaustive]
6251pub enum Display {
6252    /// `block`.
6253    Block,
6254    /// `contents`.
6255    Contents,
6256    /// `flex`.
6257    Flex,
6258    /// `flow`.
6259    Flow,
6260    /// `flow-root`.
6261    FlowRoot,
6262    /// `grid`.
6263    Grid,
6264    /// `inline`.
6265    Inline,
6266    /// `inline-block`.
6267    InlineBlock,
6268    /// `inline-flex`.
6269    InlineFlex,
6270    /// `inline-grid`.
6271    InlineGrid,
6272    /// `inline-list-item`.
6273    InlineListItem,
6274    /// `inline-table`.
6275    InlineTable,
6276    /// `none`.
6277    None,
6278    /// `ruby`.
6279    Ruby,
6280    /// `ruby-base`.
6281    RubyBase,
6282    /// `ruby-base-container`.
6283    RubyBaseContainer,
6284    /// `ruby-text`.
6285    RubyText,
6286    /// `ruby-text-container`.
6287    RubyTextContainer,
6288    /// `run-in`.
6289    RunIn,
6290    /// `table`.
6291    Table,
6292    /// `table-caption`.
6293    TableCaption,
6294    /// `table-cell`.
6295    TableCell,
6296    /// `table-column`.
6297    TableColumn,
6298    /// `table-column-group`.
6299    TableColumnGroup,
6300    /// `table-footer-group`.
6301    TableFooterGroup,
6302    /// `table-header-group`.
6303    TableHeaderGroup,
6304    /// `table-row`.
6305    TableRow,
6306    /// `table-row-group`.
6307    TableRowGroup,
6308    /// Any other value, passed through unchecked.
6309    Raw(Raw),
6310}
6311
6312impl fmt::Display for Display {
6313    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6314        match self {
6315            Self::Block => f.write_str("block"),
6316            Self::Contents => f.write_str("contents"),
6317            Self::Flex => f.write_str("flex"),
6318            Self::Flow => f.write_str("flow"),
6319            Self::FlowRoot => f.write_str("flow-root"),
6320            Self::Grid => f.write_str("grid"),
6321            Self::Inline => f.write_str("inline"),
6322            Self::InlineBlock => f.write_str("inline-block"),
6323            Self::InlineFlex => f.write_str("inline-flex"),
6324            Self::InlineGrid => f.write_str("inline-grid"),
6325            Self::InlineListItem => f.write_str("inline-list-item"),
6326            Self::InlineTable => f.write_str("inline-table"),
6327            Self::None => f.write_str("none"),
6328            Self::Ruby => f.write_str("ruby"),
6329            Self::RubyBase => f.write_str("ruby-base"),
6330            Self::RubyBaseContainer => f.write_str("ruby-base-container"),
6331            Self::RubyText => f.write_str("ruby-text"),
6332            Self::RubyTextContainer => f.write_str("ruby-text-container"),
6333            Self::RunIn => f.write_str("run-in"),
6334            Self::Table => f.write_str("table"),
6335            Self::TableCaption => f.write_str("table-caption"),
6336            Self::TableCell => f.write_str("table-cell"),
6337            Self::TableColumn => f.write_str("table-column"),
6338            Self::TableColumnGroup => f.write_str("table-column-group"),
6339            Self::TableFooterGroup => f.write_str("table-footer-group"),
6340            Self::TableHeaderGroup => f.write_str("table-header-group"),
6341            Self::TableRow => f.write_str("table-row"),
6342            Self::TableRowGroup => f.write_str("table-row-group"),
6343            Self::Raw(v) => v.fmt(f),
6344        }
6345    }
6346}
6347
6348impl From<Raw> for Display {
6349    fn from(v: Raw) -> Self {
6350        Self::Raw(v)
6351    }
6352}
6353
6354/// A value of [`dominant-baseline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/dominant-baseline).
6355#[derive(Debug, Clone, PartialEq)]
6356#[non_exhaustive]
6357pub enum DominantBaseline {
6358    /// `alphabetic`.
6359    Alphabetic,
6360    /// `auto`.
6361    Auto,
6362    /// `central`.
6363    Central,
6364    /// `hanging`.
6365    Hanging,
6366    /// `ideographic`.
6367    Ideographic,
6368    /// `mathematical`.
6369    Mathematical,
6370    /// `middle`.
6371    Middle,
6372    /// `text-bottom`.
6373    TextBottom,
6374    /// `text-top`.
6375    TextTop,
6376}
6377
6378impl fmt::Display for DominantBaseline {
6379    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6380        match self {
6381            Self::Alphabetic => f.write_str("alphabetic"),
6382            Self::Auto => f.write_str("auto"),
6383            Self::Central => f.write_str("central"),
6384            Self::Hanging => f.write_str("hanging"),
6385            Self::Ideographic => f.write_str("ideographic"),
6386            Self::Mathematical => f.write_str("mathematical"),
6387            Self::Middle => f.write_str("middle"),
6388            Self::TextBottom => f.write_str("text-bottom"),
6389            Self::TextTop => f.write_str("text-top"),
6390        }
6391    }
6392}
6393
6394/// A value of [`dynamic-range-limit`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/dynamic-range-limit).
6395#[derive(Debug, Clone, PartialEq)]
6396#[non_exhaustive]
6397pub enum DynamicRangeLimit {
6398    /// `constrained`.
6399    Constrained,
6400    /// `no-limit`.
6401    NoLimit,
6402    /// `standard`.
6403    Standard,
6404    /// Any other value, passed through unchecked.
6405    Raw(Raw),
6406}
6407
6408impl fmt::Display for DynamicRangeLimit {
6409    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6410        match self {
6411            Self::Constrained => f.write_str("constrained"),
6412            Self::NoLimit => f.write_str("no-limit"),
6413            Self::Standard => f.write_str("standard"),
6414            Self::Raw(v) => v.fmt(f),
6415        }
6416    }
6417}
6418
6419impl From<Raw> for DynamicRangeLimit {
6420    fn from(v: Raw) -> Self {
6421        Self::Raw(v)
6422    }
6423}
6424
6425/// A value of [`empty-cells`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/empty-cells).
6426#[derive(Debug, Clone, PartialEq)]
6427#[non_exhaustive]
6428pub enum EmptyCells {
6429    /// `hide`.
6430    Hide,
6431    /// `show`.
6432    Show,
6433}
6434
6435impl fmt::Display for EmptyCells {
6436    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6437        match self {
6438            Self::Hide => f.write_str("hide"),
6439            Self::Show => f.write_str("show"),
6440        }
6441    }
6442}
6443
6444/// A value of [`fill`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/fill).
6445#[derive(Debug, Clone, PartialEq)]
6446#[non_exhaustive]
6447pub enum Fill {
6448    /// `context-fill`.
6449    ContextFill,
6450    /// `context-stroke`.
6451    ContextStroke,
6452    /// `none`.
6453    None,
6454    /// A color.
6455    Color(Color),
6456    /// A URL.
6457    Url(Url),
6458    /// Any other value, passed through unchecked.
6459    Raw(Raw),
6460}
6461
6462impl fmt::Display for Fill {
6463    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6464        match self {
6465            Self::ContextFill => f.write_str("context-fill"),
6466            Self::ContextStroke => f.write_str("context-stroke"),
6467            Self::None => f.write_str("none"),
6468            Self::Color(v) => v.fmt(f),
6469            Self::Url(v) => v.fmt(f),
6470            Self::Raw(v) => v.fmt(f),
6471        }
6472    }
6473}
6474
6475impl From<Color> for Fill {
6476    fn from(v: Color) -> Self {
6477        Self::Color(v)
6478    }
6479}
6480
6481impl From<Url> for Fill {
6482    fn from(v: Url) -> Self {
6483        Self::Url(v)
6484    }
6485}
6486
6487impl From<Raw> for Fill {
6488    fn from(v: Raw) -> Self {
6489        Self::Raw(v)
6490    }
6491}
6492
6493/// A value of [`fill-opacity`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/fill-opacity).
6494#[derive(Debug, Clone, PartialEq)]
6495#[non_exhaustive]
6496pub enum FillOpacity {
6497    /// A percentage.
6498    Percentage(Percentage),
6499    /// A number.
6500    Number(f64),
6501}
6502
6503impl fmt::Display for FillOpacity {
6504    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6505        match self {
6506            Self::Percentage(v) => v.fmt(f),
6507            Self::Number(v) => v.fmt(f),
6508        }
6509    }
6510}
6511
6512impl From<Percentage> for FillOpacity {
6513    fn from(v: Percentage) -> Self {
6514        Self::Percentage(v)
6515    }
6516}
6517
6518impl From<f64> for FillOpacity {
6519    fn from(v: f64) -> Self {
6520        Self::Number(v)
6521    }
6522}
6523
6524impl From<i32> for FillOpacity {
6525    fn from(v: i32) -> Self {
6526        Self::Number(f64::from(v))
6527    }
6528}
6529
6530/// A value of [`fill-rule`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/fill-rule).
6531#[derive(Debug, Clone, PartialEq)]
6532#[non_exhaustive]
6533pub enum FillRule {
6534    /// `evenodd`.
6535    Evenodd,
6536    /// `nonzero`.
6537    Nonzero,
6538}
6539
6540impl fmt::Display for FillRule {
6541    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6542        match self {
6543            Self::Evenodd => f.write_str("evenodd"),
6544            Self::Nonzero => f.write_str("nonzero"),
6545        }
6546    }
6547}
6548
6549/// A value of [`filter`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/filter).
6550#[derive(Debug, Clone, PartialEq)]
6551#[non_exhaustive]
6552pub enum Filter {
6553    /// `none`.
6554    None,
6555    /// A URL.
6556    Url(Url),
6557    /// Any other value, passed through unchecked.
6558    Raw(Raw),
6559}
6560
6561impl fmt::Display for Filter {
6562    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6563        match self {
6564            Self::None => f.write_str("none"),
6565            Self::Url(v) => v.fmt(f),
6566            Self::Raw(v) => v.fmt(f),
6567        }
6568    }
6569}
6570
6571impl From<Url> for Filter {
6572    fn from(v: Url) -> Self {
6573        Self::Url(v)
6574    }
6575}
6576
6577impl From<Raw> for Filter {
6578    fn from(v: Raw) -> Self {
6579        Self::Raw(v)
6580    }
6581}
6582
6583/// A value of [`flex`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/flex).
6584#[derive(Debug, Clone, PartialEq)]
6585#[non_exhaustive]
6586pub enum Flex {
6587    /// `auto`.
6588    Auto,
6589    /// `content`.
6590    Content,
6591    /// `fit-content`.
6592    FitContent,
6593    /// `max-content`.
6594    MaxContent,
6595    /// `min-content`.
6596    MinContent,
6597    /// `none`.
6598    None,
6599    /// A length.
6600    Length(Length),
6601    /// A percentage.
6602    Percentage(Percentage),
6603    /// A number.
6604    Number(f64),
6605    /// Any other value, passed through unchecked.
6606    Raw(Raw),
6607}
6608
6609impl fmt::Display for Flex {
6610    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6611        match self {
6612            Self::Auto => f.write_str("auto"),
6613            Self::Content => f.write_str("content"),
6614            Self::FitContent => f.write_str("fit-content"),
6615            Self::MaxContent => f.write_str("max-content"),
6616            Self::MinContent => f.write_str("min-content"),
6617            Self::None => f.write_str("none"),
6618            Self::Length(v) => v.fmt(f),
6619            Self::Percentage(v) => v.fmt(f),
6620            Self::Number(v) => v.fmt(f),
6621            Self::Raw(v) => v.fmt(f),
6622        }
6623    }
6624}
6625
6626impl From<Length> for Flex {
6627    fn from(v: Length) -> Self {
6628        Self::Length(v)
6629    }
6630}
6631
6632impl From<Percentage> for Flex {
6633    fn from(v: Percentage) -> Self {
6634        Self::Percentage(v)
6635    }
6636}
6637
6638impl From<f64> for Flex {
6639    fn from(v: f64) -> Self {
6640        Self::Number(v)
6641    }
6642}
6643
6644impl From<i32> for Flex {
6645    fn from(v: i32) -> Self {
6646        Self::Number(f64::from(v))
6647    }
6648}
6649
6650impl From<Raw> for Flex {
6651    fn from(v: Raw) -> Self {
6652        Self::Raw(v)
6653    }
6654}
6655
6656/// A value of [`flex-basis`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/flex-basis).
6657#[derive(Debug, Clone, PartialEq)]
6658#[non_exhaustive]
6659pub enum FlexBasis {
6660    /// `auto`.
6661    Auto,
6662    /// `content`.
6663    Content,
6664    /// `fit-content`.
6665    FitContent,
6666    /// `max-content`.
6667    MaxContent,
6668    /// `min-content`.
6669    MinContent,
6670    /// A length.
6671    Length(Length),
6672    /// A percentage.
6673    Percentage(Percentage),
6674    /// Any other value, passed through unchecked.
6675    Raw(Raw),
6676}
6677
6678impl fmt::Display for FlexBasis {
6679    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6680        match self {
6681            Self::Auto => f.write_str("auto"),
6682            Self::Content => f.write_str("content"),
6683            Self::FitContent => f.write_str("fit-content"),
6684            Self::MaxContent => f.write_str("max-content"),
6685            Self::MinContent => f.write_str("min-content"),
6686            Self::Length(v) => v.fmt(f),
6687            Self::Percentage(v) => v.fmt(f),
6688            Self::Raw(v) => v.fmt(f),
6689        }
6690    }
6691}
6692
6693impl From<Length> for FlexBasis {
6694    fn from(v: Length) -> Self {
6695        Self::Length(v)
6696    }
6697}
6698
6699impl From<Percentage> for FlexBasis {
6700    fn from(v: Percentage) -> Self {
6701        Self::Percentage(v)
6702    }
6703}
6704
6705impl From<Raw> for FlexBasis {
6706    fn from(v: Raw) -> Self {
6707        Self::Raw(v)
6708    }
6709}
6710
6711/// A value of [`flex-direction`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/flex-direction).
6712#[derive(Debug, Clone, PartialEq)]
6713#[non_exhaustive]
6714pub enum FlexDirection {
6715    /// `column`.
6716    Column,
6717    /// `column-reverse`.
6718    ColumnReverse,
6719    /// `row`.
6720    Row,
6721    /// `row-reverse`.
6722    RowReverse,
6723}
6724
6725impl fmt::Display for FlexDirection {
6726    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6727        match self {
6728            Self::Column => f.write_str("column"),
6729            Self::ColumnReverse => f.write_str("column-reverse"),
6730            Self::Row => f.write_str("row"),
6731            Self::RowReverse => f.write_str("row-reverse"),
6732        }
6733    }
6734}
6735
6736/// A value of [`flex-flow`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/flex-flow).
6737#[derive(Debug, Clone, PartialEq)]
6738#[non_exhaustive]
6739pub enum FlexFlow {
6740    /// `balance`.
6741    Balance,
6742    /// `column`.
6743    Column,
6744    /// `column-reverse`.
6745    ColumnReverse,
6746    /// `nowrap`.
6747    Nowrap,
6748    /// `row`.
6749    Row,
6750    /// `row-reverse`.
6751    RowReverse,
6752    /// `wrap`.
6753    Wrap,
6754    /// `wrap-reverse`.
6755    WrapReverse,
6756    /// Any other value, passed through unchecked.
6757    Raw(Raw),
6758}
6759
6760impl fmt::Display for FlexFlow {
6761    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6762        match self {
6763            Self::Balance => f.write_str("balance"),
6764            Self::Column => f.write_str("column"),
6765            Self::ColumnReverse => f.write_str("column-reverse"),
6766            Self::Nowrap => f.write_str("nowrap"),
6767            Self::Row => f.write_str("row"),
6768            Self::RowReverse => f.write_str("row-reverse"),
6769            Self::Wrap => f.write_str("wrap"),
6770            Self::WrapReverse => f.write_str("wrap-reverse"),
6771            Self::Raw(v) => v.fmt(f),
6772        }
6773    }
6774}
6775
6776impl From<Raw> for FlexFlow {
6777    fn from(v: Raw) -> Self {
6778        Self::Raw(v)
6779    }
6780}
6781
6782/// A value of [`flex-wrap`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/flex-wrap).
6783#[derive(Debug, Clone, PartialEq)]
6784#[non_exhaustive]
6785pub enum FlexWrap {
6786    /// `balance`.
6787    Balance,
6788    /// `nowrap`.
6789    Nowrap,
6790    /// `wrap`.
6791    Wrap,
6792    /// `wrap-reverse`.
6793    WrapReverse,
6794    /// Any other value, passed through unchecked.
6795    Raw(Raw),
6796}
6797
6798impl fmt::Display for FlexWrap {
6799    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6800        match self {
6801            Self::Balance => f.write_str("balance"),
6802            Self::Nowrap => f.write_str("nowrap"),
6803            Self::Wrap => f.write_str("wrap"),
6804            Self::WrapReverse => f.write_str("wrap-reverse"),
6805            Self::Raw(v) => v.fmt(f),
6806        }
6807    }
6808}
6809
6810impl From<Raw> for FlexWrap {
6811    fn from(v: Raw) -> Self {
6812        Self::Raw(v)
6813    }
6814}
6815
6816/// A value of [`float`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/float).
6817#[derive(Debug, Clone, PartialEq)]
6818#[non_exhaustive]
6819pub enum Float {
6820    /// `inline-end`.
6821    InlineEnd,
6822    /// `inline-start`.
6823    InlineStart,
6824    /// `left`.
6825    Left,
6826    /// `none`.
6827    None,
6828    /// `right`.
6829    Right,
6830}
6831
6832impl fmt::Display for Float {
6833    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6834        match self {
6835            Self::InlineEnd => f.write_str("inline-end"),
6836            Self::InlineStart => f.write_str("inline-start"),
6837            Self::Left => f.write_str("left"),
6838            Self::None => f.write_str("none"),
6839            Self::Right => f.write_str("right"),
6840        }
6841    }
6842}
6843
6844/// A value of [`flood-opacity`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/flood-opacity).
6845#[derive(Debug, Clone, PartialEq)]
6846#[non_exhaustive]
6847pub enum FloodOpacity {
6848    /// A percentage.
6849    Percentage(Percentage),
6850    /// A number.
6851    Number(f64),
6852}
6853
6854impl fmt::Display for FloodOpacity {
6855    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6856        match self {
6857            Self::Percentage(v) => v.fmt(f),
6858            Self::Number(v) => v.fmt(f),
6859        }
6860    }
6861}
6862
6863impl From<Percentage> for FloodOpacity {
6864    fn from(v: Percentage) -> Self {
6865        Self::Percentage(v)
6866    }
6867}
6868
6869impl From<f64> for FloodOpacity {
6870    fn from(v: f64) -> Self {
6871        Self::Number(v)
6872    }
6873}
6874
6875impl From<i32> for FloodOpacity {
6876    fn from(v: i32) -> Self {
6877        Self::Number(f64::from(v))
6878    }
6879}
6880
6881/// A value of [`font`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font).
6882#[derive(Debug, Clone, PartialEq)]
6883#[non_exhaustive]
6884pub enum Font {
6885    /// `caption`.
6886    Caption,
6887    /// `icon`.
6888    Icon,
6889    /// `menu`.
6890    Menu,
6891    /// `message-box`.
6892    MessageBox,
6893    /// `small-caption`.
6894    SmallCaption,
6895    /// `status-bar`.
6896    StatusBar,
6897    /// Any other value, passed through unchecked.
6898    Raw(Raw),
6899}
6900
6901impl fmt::Display for Font {
6902    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6903        match self {
6904            Self::Caption => f.write_str("caption"),
6905            Self::Icon => f.write_str("icon"),
6906            Self::Menu => f.write_str("menu"),
6907            Self::MessageBox => f.write_str("message-box"),
6908            Self::SmallCaption => f.write_str("small-caption"),
6909            Self::StatusBar => f.write_str("status-bar"),
6910            Self::Raw(v) => v.fmt(f),
6911        }
6912    }
6913}
6914
6915impl From<Raw> for Font {
6916    fn from(v: Raw) -> Self {
6917        Self::Raw(v)
6918    }
6919}
6920
6921/// A value of [`font-family`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-family).
6922#[derive(Debug, Clone, PartialEq)]
6923#[non_exhaustive]
6924pub enum FontFamily {
6925    /// `cursive`.
6926    Cursive,
6927    /// `emoji`.
6928    Emoji,
6929    /// `fangsong`.
6930    Fangsong,
6931    /// `fantasy`.
6932    Fantasy,
6933    /// `math`.
6934    Math,
6935    /// `monospace`.
6936    Monospace,
6937    /// `sans-serif`.
6938    SansSerif,
6939    /// `serif`.
6940    Serif,
6941    /// `system-ui`.
6942    SystemUi,
6943    /// `ui-monospace`.
6944    UiMonospace,
6945    /// `ui-rounded`.
6946    UiRounded,
6947    /// `ui-sans-serif`.
6948    UiSansSerif,
6949    /// `ui-serif`.
6950    UiSerif,
6951    /// A quoted string.
6952    Quoted(Quoted),
6953    /// Any other value, passed through unchecked.
6954    Raw(Raw),
6955}
6956
6957impl fmt::Display for FontFamily {
6958    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6959        match self {
6960            Self::Cursive => f.write_str("cursive"),
6961            Self::Emoji => f.write_str("emoji"),
6962            Self::Fangsong => f.write_str("fangsong"),
6963            Self::Fantasy => f.write_str("fantasy"),
6964            Self::Math => f.write_str("math"),
6965            Self::Monospace => f.write_str("monospace"),
6966            Self::SansSerif => f.write_str("sans-serif"),
6967            Self::Serif => f.write_str("serif"),
6968            Self::SystemUi => f.write_str("system-ui"),
6969            Self::UiMonospace => f.write_str("ui-monospace"),
6970            Self::UiRounded => f.write_str("ui-rounded"),
6971            Self::UiSansSerif => f.write_str("ui-sans-serif"),
6972            Self::UiSerif => f.write_str("ui-serif"),
6973            Self::Quoted(v) => v.fmt(f),
6974            Self::Raw(v) => v.fmt(f),
6975        }
6976    }
6977}
6978
6979impl From<Quoted> for FontFamily {
6980    fn from(v: Quoted) -> Self {
6981        Self::Quoted(v)
6982    }
6983}
6984
6985impl From<Raw> for FontFamily {
6986    fn from(v: Raw) -> Self {
6987        Self::Raw(v)
6988    }
6989}
6990
6991/// A value of [`font-feature-settings`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-feature-settings).
6992#[derive(Debug, Clone, PartialEq)]
6993#[non_exhaustive]
6994pub enum FontFeatureSettings {
6995    /// `normal`.
6996    Normal,
6997    /// A quoted string.
6998    Quoted(Quoted),
6999    /// Any other value, passed through unchecked.
7000    Raw(Raw),
7001}
7002
7003impl fmt::Display for FontFeatureSettings {
7004    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7005        match self {
7006            Self::Normal => f.write_str("normal"),
7007            Self::Quoted(v) => v.fmt(f),
7008            Self::Raw(v) => v.fmt(f),
7009        }
7010    }
7011}
7012
7013impl From<Quoted> for FontFeatureSettings {
7014    fn from(v: Quoted) -> Self {
7015        Self::Quoted(v)
7016    }
7017}
7018
7019impl From<Raw> for FontFeatureSettings {
7020    fn from(v: Raw) -> Self {
7021        Self::Raw(v)
7022    }
7023}
7024
7025/// A value of [`font-kerning`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-kerning).
7026#[derive(Debug, Clone, PartialEq)]
7027#[non_exhaustive]
7028pub enum FontKerning {
7029    /// `auto`.
7030    Auto,
7031    /// `none`.
7032    None,
7033    /// `normal`.
7034    Normal,
7035}
7036
7037impl fmt::Display for FontKerning {
7038    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7039        match self {
7040            Self::Auto => f.write_str("auto"),
7041            Self::None => f.write_str("none"),
7042            Self::Normal => f.write_str("normal"),
7043        }
7044    }
7045}
7046
7047/// A value of [`font-language-override`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-language-override).
7048#[derive(Debug, Clone, PartialEq)]
7049#[non_exhaustive]
7050pub enum FontLanguageOverride {
7051    /// `normal`.
7052    Normal,
7053    /// A quoted string.
7054    Quoted(Quoted),
7055}
7056
7057impl fmt::Display for FontLanguageOverride {
7058    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7059        match self {
7060            Self::Normal => f.write_str("normal"),
7061            Self::Quoted(v) => v.fmt(f),
7062        }
7063    }
7064}
7065
7066impl From<Quoted> for FontLanguageOverride {
7067    fn from(v: Quoted) -> Self {
7068        Self::Quoted(v)
7069    }
7070}
7071
7072/// A value of [`font-optical-sizing`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-optical-sizing).
7073#[derive(Debug, Clone, PartialEq)]
7074#[non_exhaustive]
7075pub enum FontOpticalSizing {
7076    /// `auto`.
7077    Auto,
7078    /// `none`.
7079    None,
7080}
7081
7082impl fmt::Display for FontOpticalSizing {
7083    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7084        match self {
7085            Self::Auto => f.write_str("auto"),
7086            Self::None => f.write_str("none"),
7087        }
7088    }
7089}
7090
7091/// A value of [`font-palette`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-palette).
7092#[derive(Debug, Clone, PartialEq)]
7093#[non_exhaustive]
7094pub enum FontPalette {
7095    /// `dark`.
7096    Dark,
7097    /// `light`.
7098    Light,
7099    /// `normal`.
7100    Normal,
7101    /// Any other value, passed through unchecked.
7102    Raw(Raw),
7103}
7104
7105impl fmt::Display for FontPalette {
7106    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7107        match self {
7108            Self::Dark => f.write_str("dark"),
7109            Self::Light => f.write_str("light"),
7110            Self::Normal => f.write_str("normal"),
7111            Self::Raw(v) => v.fmt(f),
7112        }
7113    }
7114}
7115
7116impl From<Raw> for FontPalette {
7117    fn from(v: Raw) -> Self {
7118        Self::Raw(v)
7119    }
7120}
7121
7122/// A value of [`font-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-size).
7123#[derive(Debug, Clone, PartialEq)]
7124#[non_exhaustive]
7125pub enum FontSize {
7126    /// `large`.
7127    Large,
7128    /// `larger`.
7129    Larger,
7130    /// `math`.
7131    Math,
7132    /// `medium`.
7133    Medium,
7134    /// `small`.
7135    Small,
7136    /// `smaller`.
7137    Smaller,
7138    /// `x-large`.
7139    XLarge,
7140    /// `x-small`.
7141    XSmall,
7142    /// `xx-large`.
7143    XxLarge,
7144    /// `xx-small`.
7145    XxSmall,
7146    /// `xxx-large`.
7147    XxxLarge,
7148    /// A length.
7149    Length(Length),
7150    /// A percentage.
7151    Percentage(Percentage),
7152}
7153
7154impl fmt::Display for FontSize {
7155    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7156        match self {
7157            Self::Large => f.write_str("large"),
7158            Self::Larger => f.write_str("larger"),
7159            Self::Math => f.write_str("math"),
7160            Self::Medium => f.write_str("medium"),
7161            Self::Small => f.write_str("small"),
7162            Self::Smaller => f.write_str("smaller"),
7163            Self::XLarge => f.write_str("x-large"),
7164            Self::XSmall => f.write_str("x-small"),
7165            Self::XxLarge => f.write_str("xx-large"),
7166            Self::XxSmall => f.write_str("xx-small"),
7167            Self::XxxLarge => f.write_str("xxx-large"),
7168            Self::Length(v) => v.fmt(f),
7169            Self::Percentage(v) => v.fmt(f),
7170        }
7171    }
7172}
7173
7174impl From<Length> for FontSize {
7175    fn from(v: Length) -> Self {
7176        Self::Length(v)
7177    }
7178}
7179
7180impl From<Percentage> for FontSize {
7181    fn from(v: Percentage) -> Self {
7182        Self::Percentage(v)
7183    }
7184}
7185
7186/// A value of [`font-size-adjust`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-size-adjust).
7187#[derive(Debug, Clone, PartialEq)]
7188#[non_exhaustive]
7189pub enum FontSizeAdjust {
7190    /// `from-font`.
7191    FromFont,
7192    /// `none`.
7193    None,
7194    /// A number.
7195    Number(f64),
7196    /// Any other value, passed through unchecked.
7197    Raw(Raw),
7198}
7199
7200impl fmt::Display for FontSizeAdjust {
7201    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7202        match self {
7203            Self::FromFont => f.write_str("from-font"),
7204            Self::None => f.write_str("none"),
7205            Self::Number(v) => v.fmt(f),
7206            Self::Raw(v) => v.fmt(f),
7207        }
7208    }
7209}
7210
7211impl From<f64> for FontSizeAdjust {
7212    fn from(v: f64) -> Self {
7213        Self::Number(v)
7214    }
7215}
7216
7217impl From<i32> for FontSizeAdjust {
7218    fn from(v: i32) -> Self {
7219        Self::Number(f64::from(v))
7220    }
7221}
7222
7223impl From<Raw> for FontSizeAdjust {
7224    fn from(v: Raw) -> Self {
7225        Self::Raw(v)
7226    }
7227}
7228
7229/// A value of [`font-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-style).
7230#[derive(Debug, Clone, PartialEq)]
7231#[non_exhaustive]
7232pub enum FontStyle {
7233    /// `italic`.
7234    Italic,
7235    /// `normal`.
7236    Normal,
7237    /// `oblique`.
7238    Oblique,
7239    /// Any other value, passed through unchecked.
7240    Raw(Raw),
7241}
7242
7243impl fmt::Display for FontStyle {
7244    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7245        match self {
7246            Self::Italic => f.write_str("italic"),
7247            Self::Normal => f.write_str("normal"),
7248            Self::Oblique => f.write_str("oblique"),
7249            Self::Raw(v) => v.fmt(f),
7250        }
7251    }
7252}
7253
7254impl From<Raw> for FontStyle {
7255    fn from(v: Raw) -> Self {
7256        Self::Raw(v)
7257    }
7258}
7259
7260/// A value of [`font-synthesis`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-synthesis).
7261#[derive(Debug, Clone, PartialEq)]
7262#[non_exhaustive]
7263pub enum FontSynthesis {
7264    /// `none`.
7265    None,
7266    /// `position`.
7267    Position,
7268    /// `small-caps`.
7269    SmallCaps,
7270    /// `style`.
7271    Style,
7272    /// `weight`.
7273    Weight,
7274    /// Any other value, passed through unchecked.
7275    Raw(Raw),
7276}
7277
7278impl fmt::Display for FontSynthesis {
7279    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7280        match self {
7281            Self::None => f.write_str("none"),
7282            Self::Position => f.write_str("position"),
7283            Self::SmallCaps => f.write_str("small-caps"),
7284            Self::Style => f.write_str("style"),
7285            Self::Weight => f.write_str("weight"),
7286            Self::Raw(v) => v.fmt(f),
7287        }
7288    }
7289}
7290
7291impl From<Raw> for FontSynthesis {
7292    fn from(v: Raw) -> Self {
7293        Self::Raw(v)
7294    }
7295}
7296
7297/// A value of [`font-synthesis-small-caps`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-synthesis-small-caps).
7298#[derive(Debug, Clone, PartialEq)]
7299#[non_exhaustive]
7300pub enum FontSynthesisSmallCaps {
7301    /// `auto`.
7302    Auto,
7303    /// `none`.
7304    None,
7305}
7306
7307impl fmt::Display for FontSynthesisSmallCaps {
7308    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7309        match self {
7310            Self::Auto => f.write_str("auto"),
7311            Self::None => f.write_str("none"),
7312        }
7313    }
7314}
7315
7316/// A value of [`font-synthesis-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-synthesis-style).
7317#[derive(Debug, Clone, PartialEq)]
7318#[non_exhaustive]
7319pub enum FontSynthesisStyle {
7320    /// `auto`.
7321    Auto,
7322    /// `none`.
7323    None,
7324}
7325
7326impl fmt::Display for FontSynthesisStyle {
7327    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7328        match self {
7329            Self::Auto => f.write_str("auto"),
7330            Self::None => f.write_str("none"),
7331        }
7332    }
7333}
7334
7335/// A value of [`font-synthesis-weight`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-synthesis-weight).
7336#[derive(Debug, Clone, PartialEq)]
7337#[non_exhaustive]
7338pub enum FontSynthesisWeight {
7339    /// `auto`.
7340    Auto,
7341    /// `none`.
7342    None,
7343}
7344
7345impl fmt::Display for FontSynthesisWeight {
7346    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7347        match self {
7348            Self::Auto => f.write_str("auto"),
7349            Self::None => f.write_str("none"),
7350        }
7351    }
7352}
7353
7354/// A value of [`font-variant`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-variant).
7355#[derive(Debug, Clone, PartialEq)]
7356#[non_exhaustive]
7357pub enum FontVariant {
7358    /// `all-petite-caps`.
7359    AllPetiteCaps,
7360    /// `all-small-caps`.
7361    AllSmallCaps,
7362    /// `common-ligatures`.
7363    CommonLigatures,
7364    /// `contextual`.
7365    Contextual,
7366    /// `diagonal-fractions`.
7367    DiagonalFractions,
7368    /// `discretionary-ligatures`.
7369    DiscretionaryLigatures,
7370    /// `full-width`.
7371    FullWidth,
7372    /// `historical-forms`.
7373    HistoricalForms,
7374    /// `historical-ligatures`.
7375    HistoricalLigatures,
7376    /// `jis04`.
7377    Jis04,
7378    /// `jis78`.
7379    Jis78,
7380    /// `jis83`.
7381    Jis83,
7382    /// `jis90`.
7383    Jis90,
7384    /// `lining-nums`.
7385    LiningNums,
7386    /// `no-common-ligatures`.
7387    NoCommonLigatures,
7388    /// `no-contextual`.
7389    NoContextual,
7390    /// `no-discretionary-ligatures`.
7391    NoDiscretionaryLigatures,
7392    /// `no-historical-ligatures`.
7393    NoHistoricalLigatures,
7394    /// `none`.
7395    None,
7396    /// `normal`.
7397    Normal,
7398    /// `oldstyle-nums`.
7399    OldstyleNums,
7400    /// `ordinal`.
7401    Ordinal,
7402    /// `petite-caps`.
7403    PetiteCaps,
7404    /// `proportional-nums`.
7405    ProportionalNums,
7406    /// `proportional-width`.
7407    ProportionalWidth,
7408    /// `ruby`.
7409    Ruby,
7410    /// `simplified`.
7411    Simplified,
7412    /// `slashed-zero`.
7413    SlashedZero,
7414    /// `small-caps`.
7415    SmallCaps,
7416    /// `stacked-fractions`.
7417    StackedFractions,
7418    /// `tabular-nums`.
7419    TabularNums,
7420    /// `titling-caps`.
7421    TitlingCaps,
7422    /// `traditional`.
7423    Traditional,
7424    /// `unicase`.
7425    Unicase,
7426    /// Any other value, passed through unchecked.
7427    Raw(Raw),
7428}
7429
7430impl fmt::Display for FontVariant {
7431    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7432        match self {
7433            Self::AllPetiteCaps => f.write_str("all-petite-caps"),
7434            Self::AllSmallCaps => f.write_str("all-small-caps"),
7435            Self::CommonLigatures => f.write_str("common-ligatures"),
7436            Self::Contextual => f.write_str("contextual"),
7437            Self::DiagonalFractions => f.write_str("diagonal-fractions"),
7438            Self::DiscretionaryLigatures => f.write_str("discretionary-ligatures"),
7439            Self::FullWidth => f.write_str("full-width"),
7440            Self::HistoricalForms => f.write_str("historical-forms"),
7441            Self::HistoricalLigatures => f.write_str("historical-ligatures"),
7442            Self::Jis04 => f.write_str("jis04"),
7443            Self::Jis78 => f.write_str("jis78"),
7444            Self::Jis83 => f.write_str("jis83"),
7445            Self::Jis90 => f.write_str("jis90"),
7446            Self::LiningNums => f.write_str("lining-nums"),
7447            Self::NoCommonLigatures => f.write_str("no-common-ligatures"),
7448            Self::NoContextual => f.write_str("no-contextual"),
7449            Self::NoDiscretionaryLigatures => f.write_str("no-discretionary-ligatures"),
7450            Self::NoHistoricalLigatures => f.write_str("no-historical-ligatures"),
7451            Self::None => f.write_str("none"),
7452            Self::Normal => f.write_str("normal"),
7453            Self::OldstyleNums => f.write_str("oldstyle-nums"),
7454            Self::Ordinal => f.write_str("ordinal"),
7455            Self::PetiteCaps => f.write_str("petite-caps"),
7456            Self::ProportionalNums => f.write_str("proportional-nums"),
7457            Self::ProportionalWidth => f.write_str("proportional-width"),
7458            Self::Ruby => f.write_str("ruby"),
7459            Self::Simplified => f.write_str("simplified"),
7460            Self::SlashedZero => f.write_str("slashed-zero"),
7461            Self::SmallCaps => f.write_str("small-caps"),
7462            Self::StackedFractions => f.write_str("stacked-fractions"),
7463            Self::TabularNums => f.write_str("tabular-nums"),
7464            Self::TitlingCaps => f.write_str("titling-caps"),
7465            Self::Traditional => f.write_str("traditional"),
7466            Self::Unicase => f.write_str("unicase"),
7467            Self::Raw(v) => v.fmt(f),
7468        }
7469    }
7470}
7471
7472impl From<Raw> for FontVariant {
7473    fn from(v: Raw) -> Self {
7474        Self::Raw(v)
7475    }
7476}
7477
7478/// A value of [`font-variant-alternates`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-variant-alternates).
7479#[derive(Debug, Clone, PartialEq)]
7480#[non_exhaustive]
7481pub enum FontVariantAlternates {
7482    /// `historical-forms`.
7483    HistoricalForms,
7484    /// `normal`.
7485    Normal,
7486    /// Any other value, passed through unchecked.
7487    Raw(Raw),
7488}
7489
7490impl fmt::Display for FontVariantAlternates {
7491    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7492        match self {
7493            Self::HistoricalForms => f.write_str("historical-forms"),
7494            Self::Normal => f.write_str("normal"),
7495            Self::Raw(v) => v.fmt(f),
7496        }
7497    }
7498}
7499
7500impl From<Raw> for FontVariantAlternates {
7501    fn from(v: Raw) -> Self {
7502        Self::Raw(v)
7503    }
7504}
7505
7506/// A value of [`font-variant-caps`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-variant-caps).
7507#[derive(Debug, Clone, PartialEq)]
7508#[non_exhaustive]
7509pub enum FontVariantCaps {
7510    /// `all-petite-caps`.
7511    AllPetiteCaps,
7512    /// `all-small-caps`.
7513    AllSmallCaps,
7514    /// `normal`.
7515    Normal,
7516    /// `petite-caps`.
7517    PetiteCaps,
7518    /// `small-caps`.
7519    SmallCaps,
7520    /// `titling-caps`.
7521    TitlingCaps,
7522    /// `unicase`.
7523    Unicase,
7524}
7525
7526impl fmt::Display for FontVariantCaps {
7527    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7528        match self {
7529            Self::AllPetiteCaps => f.write_str("all-petite-caps"),
7530            Self::AllSmallCaps => f.write_str("all-small-caps"),
7531            Self::Normal => f.write_str("normal"),
7532            Self::PetiteCaps => f.write_str("petite-caps"),
7533            Self::SmallCaps => f.write_str("small-caps"),
7534            Self::TitlingCaps => f.write_str("titling-caps"),
7535            Self::Unicase => f.write_str("unicase"),
7536        }
7537    }
7538}
7539
7540/// A value of [`font-variant-east-asian`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-variant-east-asian).
7541#[derive(Debug, Clone, PartialEq)]
7542#[non_exhaustive]
7543pub enum FontVariantEastAsian {
7544    /// `full-width`.
7545    FullWidth,
7546    /// `jis04`.
7547    Jis04,
7548    /// `jis78`.
7549    Jis78,
7550    /// `jis83`.
7551    Jis83,
7552    /// `jis90`.
7553    Jis90,
7554    /// `normal`.
7555    Normal,
7556    /// `proportional-width`.
7557    ProportionalWidth,
7558    /// `ruby`.
7559    Ruby,
7560    /// `simplified`.
7561    Simplified,
7562    /// `traditional`.
7563    Traditional,
7564    /// Any other value, passed through unchecked.
7565    Raw(Raw),
7566}
7567
7568impl fmt::Display for FontVariantEastAsian {
7569    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7570        match self {
7571            Self::FullWidth => f.write_str("full-width"),
7572            Self::Jis04 => f.write_str("jis04"),
7573            Self::Jis78 => f.write_str("jis78"),
7574            Self::Jis83 => f.write_str("jis83"),
7575            Self::Jis90 => f.write_str("jis90"),
7576            Self::Normal => f.write_str("normal"),
7577            Self::ProportionalWidth => f.write_str("proportional-width"),
7578            Self::Ruby => f.write_str("ruby"),
7579            Self::Simplified => f.write_str("simplified"),
7580            Self::Traditional => f.write_str("traditional"),
7581            Self::Raw(v) => v.fmt(f),
7582        }
7583    }
7584}
7585
7586impl From<Raw> for FontVariantEastAsian {
7587    fn from(v: Raw) -> Self {
7588        Self::Raw(v)
7589    }
7590}
7591
7592/// A value of [`font-variant-emoji`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-variant-emoji).
7593#[derive(Debug, Clone, PartialEq)]
7594#[non_exhaustive]
7595pub enum FontVariantEmoji {
7596    /// `emoji`.
7597    Emoji,
7598    /// `normal`.
7599    Normal,
7600    /// `text`.
7601    Text,
7602    /// `unicode`.
7603    Unicode,
7604}
7605
7606impl fmt::Display for FontVariantEmoji {
7607    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7608        match self {
7609            Self::Emoji => f.write_str("emoji"),
7610            Self::Normal => f.write_str("normal"),
7611            Self::Text => f.write_str("text"),
7612            Self::Unicode => f.write_str("unicode"),
7613        }
7614    }
7615}
7616
7617/// A value of [`font-variant-ligatures`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-variant-ligatures).
7618#[derive(Debug, Clone, PartialEq)]
7619#[non_exhaustive]
7620pub enum FontVariantLigatures {
7621    /// `common-ligatures`.
7622    CommonLigatures,
7623    /// `contextual`.
7624    Contextual,
7625    /// `discretionary-ligatures`.
7626    DiscretionaryLigatures,
7627    /// `historical-ligatures`.
7628    HistoricalLigatures,
7629    /// `no-common-ligatures`.
7630    NoCommonLigatures,
7631    /// `no-contextual`.
7632    NoContextual,
7633    /// `no-discretionary-ligatures`.
7634    NoDiscretionaryLigatures,
7635    /// `no-historical-ligatures`.
7636    NoHistoricalLigatures,
7637    /// `none`.
7638    None,
7639    /// `normal`.
7640    Normal,
7641    /// Any other value, passed through unchecked.
7642    Raw(Raw),
7643}
7644
7645impl fmt::Display for FontVariantLigatures {
7646    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7647        match self {
7648            Self::CommonLigatures => f.write_str("common-ligatures"),
7649            Self::Contextual => f.write_str("contextual"),
7650            Self::DiscretionaryLigatures => f.write_str("discretionary-ligatures"),
7651            Self::HistoricalLigatures => f.write_str("historical-ligatures"),
7652            Self::NoCommonLigatures => f.write_str("no-common-ligatures"),
7653            Self::NoContextual => f.write_str("no-contextual"),
7654            Self::NoDiscretionaryLigatures => f.write_str("no-discretionary-ligatures"),
7655            Self::NoHistoricalLigatures => f.write_str("no-historical-ligatures"),
7656            Self::None => f.write_str("none"),
7657            Self::Normal => f.write_str("normal"),
7658            Self::Raw(v) => v.fmt(f),
7659        }
7660    }
7661}
7662
7663impl From<Raw> for FontVariantLigatures {
7664    fn from(v: Raw) -> Self {
7665        Self::Raw(v)
7666    }
7667}
7668
7669/// A value of [`font-variant-numeric`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-variant-numeric).
7670#[derive(Debug, Clone, PartialEq)]
7671#[non_exhaustive]
7672pub enum FontVariantNumeric {
7673    /// `diagonal-fractions`.
7674    DiagonalFractions,
7675    /// `lining-nums`.
7676    LiningNums,
7677    /// `normal`.
7678    Normal,
7679    /// `oldstyle-nums`.
7680    OldstyleNums,
7681    /// `ordinal`.
7682    Ordinal,
7683    /// `proportional-nums`.
7684    ProportionalNums,
7685    /// `slashed-zero`.
7686    SlashedZero,
7687    /// `stacked-fractions`.
7688    StackedFractions,
7689    /// `tabular-nums`.
7690    TabularNums,
7691    /// Any other value, passed through unchecked.
7692    Raw(Raw),
7693}
7694
7695impl fmt::Display for FontVariantNumeric {
7696    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7697        match self {
7698            Self::DiagonalFractions => f.write_str("diagonal-fractions"),
7699            Self::LiningNums => f.write_str("lining-nums"),
7700            Self::Normal => f.write_str("normal"),
7701            Self::OldstyleNums => f.write_str("oldstyle-nums"),
7702            Self::Ordinal => f.write_str("ordinal"),
7703            Self::ProportionalNums => f.write_str("proportional-nums"),
7704            Self::SlashedZero => f.write_str("slashed-zero"),
7705            Self::StackedFractions => f.write_str("stacked-fractions"),
7706            Self::TabularNums => f.write_str("tabular-nums"),
7707            Self::Raw(v) => v.fmt(f),
7708        }
7709    }
7710}
7711
7712impl From<Raw> for FontVariantNumeric {
7713    fn from(v: Raw) -> Self {
7714        Self::Raw(v)
7715    }
7716}
7717
7718/// A value of [`font-variant-position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-variant-position).
7719#[derive(Debug, Clone, PartialEq)]
7720#[non_exhaustive]
7721pub enum FontVariantPosition {
7722    /// `normal`.
7723    Normal,
7724    /// `sub`.
7725    Sub,
7726    /// `super`.
7727    Super,
7728}
7729
7730impl fmt::Display for FontVariantPosition {
7731    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7732        match self {
7733            Self::Normal => f.write_str("normal"),
7734            Self::Sub => f.write_str("sub"),
7735            Self::Super => f.write_str("super"),
7736        }
7737    }
7738}
7739
7740/// A value of [`font-variation-settings`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-variation-settings).
7741#[derive(Debug, Clone, PartialEq)]
7742#[non_exhaustive]
7743pub enum FontVariationSettings {
7744    /// `normal`.
7745    Normal,
7746    /// Any other value, passed through unchecked.
7747    Raw(Raw),
7748}
7749
7750impl fmt::Display for FontVariationSettings {
7751    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7752        match self {
7753            Self::Normal => f.write_str("normal"),
7754            Self::Raw(v) => v.fmt(f),
7755        }
7756    }
7757}
7758
7759impl From<Raw> for FontVariationSettings {
7760    fn from(v: Raw) -> Self {
7761        Self::Raw(v)
7762    }
7763}
7764
7765/// A value of [`font-weight`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/font-weight).
7766#[derive(Debug, Clone, PartialEq)]
7767#[non_exhaustive]
7768pub enum FontWeight {
7769    /// `bold`.
7770    Bold,
7771    /// `bolder`.
7772    Bolder,
7773    /// `lighter`.
7774    Lighter,
7775    /// `normal`.
7776    Normal,
7777    /// A number.
7778    Number(f64),
7779}
7780
7781impl fmt::Display for FontWeight {
7782    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7783        match self {
7784            Self::Bold => f.write_str("bold"),
7785            Self::Bolder => f.write_str("bolder"),
7786            Self::Lighter => f.write_str("lighter"),
7787            Self::Normal => f.write_str("normal"),
7788            Self::Number(v) => v.fmt(f),
7789        }
7790    }
7791}
7792
7793impl From<f64> for FontWeight {
7794    fn from(v: f64) -> Self {
7795        Self::Number(v)
7796    }
7797}
7798
7799impl From<i32> for FontWeight {
7800    fn from(v: i32) -> Self {
7801        Self::Number(f64::from(v))
7802    }
7803}
7804
7805/// A value of [`forced-color-adjust`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/forced-color-adjust).
7806#[derive(Debug, Clone, PartialEq)]
7807#[non_exhaustive]
7808pub enum ForcedColorAdjust {
7809    /// `auto`.
7810    Auto,
7811    /// `none`.
7812    None,
7813    /// `preserve-parent-color`.
7814    PreserveParentColor,
7815}
7816
7817impl fmt::Display for ForcedColorAdjust {
7818    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7819        match self {
7820            Self::Auto => f.write_str("auto"),
7821            Self::None => f.write_str("none"),
7822            Self::PreserveParentColor => f.write_str("preserve-parent-color"),
7823        }
7824    }
7825}
7826
7827/// A value of [`frame-sizing`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/frame-sizing).
7828#[derive(Debug, Clone, PartialEq)]
7829#[non_exhaustive]
7830pub enum FrameSizing {
7831    /// `auto`.
7832    Auto,
7833    /// `content-block-size`.
7834    ContentBlockSize,
7835    /// `content-height`.
7836    ContentHeight,
7837    /// `content-inline-size`.
7838    ContentInlineSize,
7839    /// `content-width`.
7840    ContentWidth,
7841}
7842
7843impl fmt::Display for FrameSizing {
7844    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7845        match self {
7846            Self::Auto => f.write_str("auto"),
7847            Self::ContentBlockSize => f.write_str("content-block-size"),
7848            Self::ContentHeight => f.write_str("content-height"),
7849            Self::ContentInlineSize => f.write_str("content-inline-size"),
7850            Self::ContentWidth => f.write_str("content-width"),
7851        }
7852    }
7853}
7854
7855/// A value of [`gap`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/gap).
7856#[derive(Debug, Clone, PartialEq)]
7857#[non_exhaustive]
7858pub enum Gap {
7859    /// `normal`.
7860    Normal,
7861    /// A length.
7862    Length(Length),
7863    /// A percentage.
7864    Percentage(Percentage),
7865    /// Any other value, passed through unchecked.
7866    Raw(Raw),
7867}
7868
7869impl fmt::Display for Gap {
7870    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7871        match self {
7872            Self::Normal => f.write_str("normal"),
7873            Self::Length(v) => v.fmt(f),
7874            Self::Percentage(v) => v.fmt(f),
7875            Self::Raw(v) => v.fmt(f),
7876        }
7877    }
7878}
7879
7880impl From<Length> for Gap {
7881    fn from(v: Length) -> Self {
7882        Self::Length(v)
7883    }
7884}
7885
7886impl From<Percentage> for Gap {
7887    fn from(v: Percentage) -> Self {
7888        Self::Percentage(v)
7889    }
7890}
7891
7892impl From<Raw> for Gap {
7893    fn from(v: Raw) -> Self {
7894        Self::Raw(v)
7895    }
7896}
7897
7898/// A value of [`grid`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid).
7899#[derive(Debug, Clone, PartialEq)]
7900#[non_exhaustive]
7901pub enum Grid {
7902    /// `none`.
7903    None,
7904    /// A quoted string.
7905    Quoted(Quoted),
7906    /// Any other value, passed through unchecked.
7907    Raw(Raw),
7908}
7909
7910impl fmt::Display for Grid {
7911    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7912        match self {
7913            Self::None => f.write_str("none"),
7914            Self::Quoted(v) => v.fmt(f),
7915            Self::Raw(v) => v.fmt(f),
7916        }
7917    }
7918}
7919
7920impl From<Quoted> for Grid {
7921    fn from(v: Quoted) -> Self {
7922        Self::Quoted(v)
7923    }
7924}
7925
7926impl From<Raw> for Grid {
7927    fn from(v: Raw) -> Self {
7928        Self::Raw(v)
7929    }
7930}
7931
7932/// A value of [`grid-area`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-area).
7933#[derive(Debug, Clone, PartialEq)]
7934#[non_exhaustive]
7935pub enum GridArea {
7936    /// `auto`.
7937    Auto,
7938    /// Any other value, passed through unchecked.
7939    Raw(Raw),
7940}
7941
7942impl fmt::Display for GridArea {
7943    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7944        match self {
7945            Self::Auto => f.write_str("auto"),
7946            Self::Raw(v) => v.fmt(f),
7947        }
7948    }
7949}
7950
7951impl From<Raw> for GridArea {
7952    fn from(v: Raw) -> Self {
7953        Self::Raw(v)
7954    }
7955}
7956
7957/// A value of [`grid-auto-columns`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-auto-columns).
7958#[derive(Debug, Clone, PartialEq)]
7959#[non_exhaustive]
7960pub enum GridAutoColumns {
7961    /// `auto`.
7962    Auto,
7963    /// `max-content`.
7964    MaxContent,
7965    /// `min-content`.
7966    MinContent,
7967    /// A length.
7968    Length(Length),
7969    /// A percentage.
7970    Percentage(Percentage),
7971    /// Any other value, passed through unchecked.
7972    Raw(Raw),
7973}
7974
7975impl fmt::Display for GridAutoColumns {
7976    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
7977        match self {
7978            Self::Auto => f.write_str("auto"),
7979            Self::MaxContent => f.write_str("max-content"),
7980            Self::MinContent => f.write_str("min-content"),
7981            Self::Length(v) => v.fmt(f),
7982            Self::Percentage(v) => v.fmt(f),
7983            Self::Raw(v) => v.fmt(f),
7984        }
7985    }
7986}
7987
7988impl From<Length> for GridAutoColumns {
7989    fn from(v: Length) -> Self {
7990        Self::Length(v)
7991    }
7992}
7993
7994impl From<Percentage> for GridAutoColumns {
7995    fn from(v: Percentage) -> Self {
7996        Self::Percentage(v)
7997    }
7998}
7999
8000impl From<Raw> for GridAutoColumns {
8001    fn from(v: Raw) -> Self {
8002        Self::Raw(v)
8003    }
8004}
8005
8006/// A value of [`grid-auto-flow`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-auto-flow).
8007#[derive(Debug, Clone, PartialEq)]
8008#[non_exhaustive]
8009pub enum GridAutoFlow {
8010    /// `column`.
8011    Column,
8012    /// `dense`.
8013    Dense,
8014    /// `row`.
8015    Row,
8016    /// Any other value, passed through unchecked.
8017    Raw(Raw),
8018}
8019
8020impl fmt::Display for GridAutoFlow {
8021    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8022        match self {
8023            Self::Column => f.write_str("column"),
8024            Self::Dense => f.write_str("dense"),
8025            Self::Row => f.write_str("row"),
8026            Self::Raw(v) => v.fmt(f),
8027        }
8028    }
8029}
8030
8031impl From<Raw> for GridAutoFlow {
8032    fn from(v: Raw) -> Self {
8033        Self::Raw(v)
8034    }
8035}
8036
8037/// A value of [`grid-auto-rows`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-auto-rows).
8038#[derive(Debug, Clone, PartialEq)]
8039#[non_exhaustive]
8040pub enum GridAutoRows {
8041    /// `auto`.
8042    Auto,
8043    /// `max-content`.
8044    MaxContent,
8045    /// `min-content`.
8046    MinContent,
8047    /// A length.
8048    Length(Length),
8049    /// A percentage.
8050    Percentage(Percentage),
8051    /// Any other value, passed through unchecked.
8052    Raw(Raw),
8053}
8054
8055impl fmt::Display for GridAutoRows {
8056    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8057        match self {
8058            Self::Auto => f.write_str("auto"),
8059            Self::MaxContent => f.write_str("max-content"),
8060            Self::MinContent => f.write_str("min-content"),
8061            Self::Length(v) => v.fmt(f),
8062            Self::Percentage(v) => v.fmt(f),
8063            Self::Raw(v) => v.fmt(f),
8064        }
8065    }
8066}
8067
8068impl From<Length> for GridAutoRows {
8069    fn from(v: Length) -> Self {
8070        Self::Length(v)
8071    }
8072}
8073
8074impl From<Percentage> for GridAutoRows {
8075    fn from(v: Percentage) -> Self {
8076        Self::Percentage(v)
8077    }
8078}
8079
8080impl From<Raw> for GridAutoRows {
8081    fn from(v: Raw) -> Self {
8082        Self::Raw(v)
8083    }
8084}
8085
8086/// A value of [`grid-column`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-column).
8087#[derive(Debug, Clone, PartialEq)]
8088#[non_exhaustive]
8089pub enum GridColumn {
8090    /// `auto`.
8091    Auto,
8092    /// Any other value, passed through unchecked.
8093    Raw(Raw),
8094}
8095
8096impl fmt::Display for GridColumn {
8097    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8098        match self {
8099            Self::Auto => f.write_str("auto"),
8100            Self::Raw(v) => v.fmt(f),
8101        }
8102    }
8103}
8104
8105impl From<Raw> for GridColumn {
8106    fn from(v: Raw) -> Self {
8107        Self::Raw(v)
8108    }
8109}
8110
8111/// A value of [`grid-column-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-column-end).
8112#[derive(Debug, Clone, PartialEq)]
8113#[non_exhaustive]
8114pub enum GridColumnEnd {
8115    /// `auto`.
8116    Auto,
8117    /// Any other value, passed through unchecked.
8118    Raw(Raw),
8119}
8120
8121impl fmt::Display for GridColumnEnd {
8122    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8123        match self {
8124            Self::Auto => f.write_str("auto"),
8125            Self::Raw(v) => v.fmt(f),
8126        }
8127    }
8128}
8129
8130impl From<Raw> for GridColumnEnd {
8131    fn from(v: Raw) -> Self {
8132        Self::Raw(v)
8133    }
8134}
8135
8136/// A value of [`grid-column-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-column-start).
8137#[derive(Debug, Clone, PartialEq)]
8138#[non_exhaustive]
8139pub enum GridColumnStart {
8140    /// `auto`.
8141    Auto,
8142    /// Any other value, passed through unchecked.
8143    Raw(Raw),
8144}
8145
8146impl fmt::Display for GridColumnStart {
8147    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8148        match self {
8149            Self::Auto => f.write_str("auto"),
8150            Self::Raw(v) => v.fmt(f),
8151        }
8152    }
8153}
8154
8155impl From<Raw> for GridColumnStart {
8156    fn from(v: Raw) -> Self {
8157        Self::Raw(v)
8158    }
8159}
8160
8161/// A value of [`grid-row`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-row).
8162#[derive(Debug, Clone, PartialEq)]
8163#[non_exhaustive]
8164pub enum GridRow {
8165    /// `auto`.
8166    Auto,
8167    /// Any other value, passed through unchecked.
8168    Raw(Raw),
8169}
8170
8171impl fmt::Display for GridRow {
8172    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8173        match self {
8174            Self::Auto => f.write_str("auto"),
8175            Self::Raw(v) => v.fmt(f),
8176        }
8177    }
8178}
8179
8180impl From<Raw> for GridRow {
8181    fn from(v: Raw) -> Self {
8182        Self::Raw(v)
8183    }
8184}
8185
8186/// A value of [`grid-row-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-row-end).
8187#[derive(Debug, Clone, PartialEq)]
8188#[non_exhaustive]
8189pub enum GridRowEnd {
8190    /// `auto`.
8191    Auto,
8192    /// Any other value, passed through unchecked.
8193    Raw(Raw),
8194}
8195
8196impl fmt::Display for GridRowEnd {
8197    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8198        match self {
8199            Self::Auto => f.write_str("auto"),
8200            Self::Raw(v) => v.fmt(f),
8201        }
8202    }
8203}
8204
8205impl From<Raw> for GridRowEnd {
8206    fn from(v: Raw) -> Self {
8207        Self::Raw(v)
8208    }
8209}
8210
8211/// A value of [`grid-row-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-row-start).
8212#[derive(Debug, Clone, PartialEq)]
8213#[non_exhaustive]
8214pub enum GridRowStart {
8215    /// `auto`.
8216    Auto,
8217    /// Any other value, passed through unchecked.
8218    Raw(Raw),
8219}
8220
8221impl fmt::Display for GridRowStart {
8222    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8223        match self {
8224            Self::Auto => f.write_str("auto"),
8225            Self::Raw(v) => v.fmt(f),
8226        }
8227    }
8228}
8229
8230impl From<Raw> for GridRowStart {
8231    fn from(v: Raw) -> Self {
8232        Self::Raw(v)
8233    }
8234}
8235
8236/// A value of [`grid-template`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-template).
8237#[derive(Debug, Clone, PartialEq)]
8238#[non_exhaustive]
8239pub enum GridTemplate {
8240    /// `none`.
8241    None,
8242    /// A quoted string.
8243    Quoted(Quoted),
8244    /// Any other value, passed through unchecked.
8245    Raw(Raw),
8246}
8247
8248impl fmt::Display for GridTemplate {
8249    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8250        match self {
8251            Self::None => f.write_str("none"),
8252            Self::Quoted(v) => v.fmt(f),
8253            Self::Raw(v) => v.fmt(f),
8254        }
8255    }
8256}
8257
8258impl From<Quoted> for GridTemplate {
8259    fn from(v: Quoted) -> Self {
8260        Self::Quoted(v)
8261    }
8262}
8263
8264impl From<Raw> for GridTemplate {
8265    fn from(v: Raw) -> Self {
8266        Self::Raw(v)
8267    }
8268}
8269
8270/// A value of [`grid-template-areas`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-template-areas).
8271#[derive(Debug, Clone, PartialEq)]
8272#[non_exhaustive]
8273pub enum GridTemplateAreas {
8274    /// `none`.
8275    None,
8276    /// A quoted string.
8277    Quoted(Quoted),
8278    /// Any other value, passed through unchecked.
8279    Raw(Raw),
8280}
8281
8282impl fmt::Display for GridTemplateAreas {
8283    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8284        match self {
8285            Self::None => f.write_str("none"),
8286            Self::Quoted(v) => v.fmt(f),
8287            Self::Raw(v) => v.fmt(f),
8288        }
8289    }
8290}
8291
8292impl From<Quoted> for GridTemplateAreas {
8293    fn from(v: Quoted) -> Self {
8294        Self::Quoted(v)
8295    }
8296}
8297
8298impl From<Raw> for GridTemplateAreas {
8299    fn from(v: Raw) -> Self {
8300        Self::Raw(v)
8301    }
8302}
8303
8304/// A value of [`grid-template-columns`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-template-columns).
8305#[derive(Debug, Clone, PartialEq)]
8306#[non_exhaustive]
8307pub enum GridTemplateColumns {
8308    /// `auto`.
8309    Auto,
8310    /// `max-content`.
8311    MaxContent,
8312    /// `min-content`.
8313    MinContent,
8314    /// `none`.
8315    None,
8316    /// `subgrid`.
8317    Subgrid,
8318    /// A length.
8319    Length(Length),
8320    /// A percentage.
8321    Percentage(Percentage),
8322    /// Any other value, passed through unchecked.
8323    Raw(Raw),
8324}
8325
8326impl fmt::Display for GridTemplateColumns {
8327    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8328        match self {
8329            Self::Auto => f.write_str("auto"),
8330            Self::MaxContent => f.write_str("max-content"),
8331            Self::MinContent => f.write_str("min-content"),
8332            Self::None => f.write_str("none"),
8333            Self::Subgrid => f.write_str("subgrid"),
8334            Self::Length(v) => v.fmt(f),
8335            Self::Percentage(v) => v.fmt(f),
8336            Self::Raw(v) => v.fmt(f),
8337        }
8338    }
8339}
8340
8341impl From<Length> for GridTemplateColumns {
8342    fn from(v: Length) -> Self {
8343        Self::Length(v)
8344    }
8345}
8346
8347impl From<Percentage> for GridTemplateColumns {
8348    fn from(v: Percentage) -> Self {
8349        Self::Percentage(v)
8350    }
8351}
8352
8353impl From<Raw> for GridTemplateColumns {
8354    fn from(v: Raw) -> Self {
8355        Self::Raw(v)
8356    }
8357}
8358
8359/// A value of [`grid-template-rows`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/grid-template-rows).
8360#[derive(Debug, Clone, PartialEq)]
8361#[non_exhaustive]
8362pub enum GridTemplateRows {
8363    /// `auto`.
8364    Auto,
8365    /// `max-content`.
8366    MaxContent,
8367    /// `min-content`.
8368    MinContent,
8369    /// `none`.
8370    None,
8371    /// `subgrid`.
8372    Subgrid,
8373    /// A length.
8374    Length(Length),
8375    /// A percentage.
8376    Percentage(Percentage),
8377    /// Any other value, passed through unchecked.
8378    Raw(Raw),
8379}
8380
8381impl fmt::Display for GridTemplateRows {
8382    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8383        match self {
8384            Self::Auto => f.write_str("auto"),
8385            Self::MaxContent => f.write_str("max-content"),
8386            Self::MinContent => f.write_str("min-content"),
8387            Self::None => f.write_str("none"),
8388            Self::Subgrid => f.write_str("subgrid"),
8389            Self::Length(v) => v.fmt(f),
8390            Self::Percentage(v) => v.fmt(f),
8391            Self::Raw(v) => v.fmt(f),
8392        }
8393    }
8394}
8395
8396impl From<Length> for GridTemplateRows {
8397    fn from(v: Length) -> Self {
8398        Self::Length(v)
8399    }
8400}
8401
8402impl From<Percentage> for GridTemplateRows {
8403    fn from(v: Percentage) -> Self {
8404        Self::Percentage(v)
8405    }
8406}
8407
8408impl From<Raw> for GridTemplateRows {
8409    fn from(v: Raw) -> Self {
8410        Self::Raw(v)
8411    }
8412}
8413
8414/// A value of [`hanging-punctuation`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/hanging-punctuation).
8415#[derive(Debug, Clone, PartialEq)]
8416#[non_exhaustive]
8417pub enum HangingPunctuation {
8418    /// `allow-end`.
8419    AllowEnd,
8420    /// `first`.
8421    First,
8422    /// `force-end`.
8423    ForceEnd,
8424    /// `last`.
8425    Last,
8426    /// `none`.
8427    None,
8428    /// Any other value, passed through unchecked.
8429    Raw(Raw),
8430}
8431
8432impl fmt::Display for HangingPunctuation {
8433    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8434        match self {
8435            Self::AllowEnd => f.write_str("allow-end"),
8436            Self::First => f.write_str("first"),
8437            Self::ForceEnd => f.write_str("force-end"),
8438            Self::Last => f.write_str("last"),
8439            Self::None => f.write_str("none"),
8440            Self::Raw(v) => v.fmt(f),
8441        }
8442    }
8443}
8444
8445impl From<Raw> for HangingPunctuation {
8446    fn from(v: Raw) -> Self {
8447        Self::Raw(v)
8448    }
8449}
8450
8451/// A value of [`height`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/height).
8452#[derive(Debug, Clone, PartialEq)]
8453#[non_exhaustive]
8454pub enum Height {
8455    /// `auto`.
8456    Auto,
8457    /// `fit-content`.
8458    FitContent,
8459    /// `max-content`.
8460    MaxContent,
8461    /// `min-content`.
8462    MinContent,
8463    /// A length.
8464    Length(Length),
8465    /// A percentage.
8466    Percentage(Percentage),
8467    /// Any other value, passed through unchecked.
8468    Raw(Raw),
8469}
8470
8471impl fmt::Display for Height {
8472    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8473        match self {
8474            Self::Auto => f.write_str("auto"),
8475            Self::FitContent => f.write_str("fit-content"),
8476            Self::MaxContent => f.write_str("max-content"),
8477            Self::MinContent => f.write_str("min-content"),
8478            Self::Length(v) => v.fmt(f),
8479            Self::Percentage(v) => v.fmt(f),
8480            Self::Raw(v) => v.fmt(f),
8481        }
8482    }
8483}
8484
8485impl From<Length> for Height {
8486    fn from(v: Length) -> Self {
8487        Self::Length(v)
8488    }
8489}
8490
8491impl From<Percentage> for Height {
8492    fn from(v: Percentage) -> Self {
8493        Self::Percentage(v)
8494    }
8495}
8496
8497impl From<Raw> for Height {
8498    fn from(v: Raw) -> Self {
8499        Self::Raw(v)
8500    }
8501}
8502
8503/// A value of [`hyphenate-character`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/hyphenate-character).
8504#[derive(Debug, Clone, PartialEq)]
8505#[non_exhaustive]
8506pub enum HyphenateCharacter {
8507    /// `auto`.
8508    Auto,
8509    /// A quoted string.
8510    Quoted(Quoted),
8511}
8512
8513impl fmt::Display for HyphenateCharacter {
8514    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8515        match self {
8516            Self::Auto => f.write_str("auto"),
8517            Self::Quoted(v) => v.fmt(f),
8518        }
8519    }
8520}
8521
8522impl From<Quoted> for HyphenateCharacter {
8523    fn from(v: Quoted) -> Self {
8524        Self::Quoted(v)
8525    }
8526}
8527
8528/// A value of [`hyphenate-limit-chars`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/hyphenate-limit-chars).
8529#[derive(Debug, Clone, PartialEq)]
8530#[non_exhaustive]
8531pub enum HyphenateLimitChars {
8532    /// `auto`.
8533    Auto,
8534    /// An integer.
8535    Integer(i32),
8536    /// Any other value, passed through unchecked.
8537    Raw(Raw),
8538}
8539
8540impl fmt::Display for HyphenateLimitChars {
8541    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8542        match self {
8543            Self::Auto => f.write_str("auto"),
8544            Self::Integer(v) => v.fmt(f),
8545            Self::Raw(v) => v.fmt(f),
8546        }
8547    }
8548}
8549
8550impl From<i32> for HyphenateLimitChars {
8551    fn from(v: i32) -> Self {
8552        Self::Integer(v)
8553    }
8554}
8555
8556impl From<Raw> for HyphenateLimitChars {
8557    fn from(v: Raw) -> Self {
8558        Self::Raw(v)
8559    }
8560}
8561
8562/// A value of [`hyphens`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/hyphens).
8563#[derive(Debug, Clone, PartialEq)]
8564#[non_exhaustive]
8565pub enum Hyphens {
8566    /// `auto`.
8567    Auto,
8568    /// `manual`.
8569    Manual,
8570    /// `none`.
8571    None,
8572}
8573
8574impl fmt::Display for Hyphens {
8575    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8576        match self {
8577            Self::Auto => f.write_str("auto"),
8578            Self::Manual => f.write_str("manual"),
8579            Self::None => f.write_str("none"),
8580        }
8581    }
8582}
8583
8584/// A value of [`image-orientation`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/image-orientation).
8585#[derive(Debug, Clone, PartialEq)]
8586#[non_exhaustive]
8587pub enum ImageOrientation {
8588    /// `flip`.
8589    Flip,
8590    /// `from-image`.
8591    FromImage,
8592    /// An angle.
8593    Angle(Angle),
8594    /// Any other value, passed through unchecked.
8595    Raw(Raw),
8596}
8597
8598impl fmt::Display for ImageOrientation {
8599    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8600        match self {
8601            Self::Flip => f.write_str("flip"),
8602            Self::FromImage => f.write_str("from-image"),
8603            Self::Angle(v) => v.fmt(f),
8604            Self::Raw(v) => v.fmt(f),
8605        }
8606    }
8607}
8608
8609impl From<Angle> for ImageOrientation {
8610    fn from(v: Angle) -> Self {
8611        Self::Angle(v)
8612    }
8613}
8614
8615impl From<Raw> for ImageOrientation {
8616    fn from(v: Raw) -> Self {
8617        Self::Raw(v)
8618    }
8619}
8620
8621/// A value of [`image-rendering`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/image-rendering).
8622#[derive(Debug, Clone, PartialEq)]
8623#[non_exhaustive]
8624pub enum ImageRendering {
8625    /// `auto`.
8626    Auto,
8627    /// `crisp-edges`.
8628    CrispEdges,
8629    /// `pixelated`.
8630    Pixelated,
8631    /// `smooth`.
8632    Smooth,
8633}
8634
8635impl fmt::Display for ImageRendering {
8636    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8637        match self {
8638            Self::Auto => f.write_str("auto"),
8639            Self::CrispEdges => f.write_str("crisp-edges"),
8640            Self::Pixelated => f.write_str("pixelated"),
8641            Self::Smooth => f.write_str("smooth"),
8642        }
8643    }
8644}
8645
8646/// A value of [`initial-letter`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/initial-letter).
8647#[derive(Debug, Clone, PartialEq)]
8648#[non_exhaustive]
8649pub enum InitialLetter {
8650    /// `normal`.
8651    Normal,
8652    /// A number.
8653    Number(f64),
8654    /// Any other value, passed through unchecked.
8655    Raw(Raw),
8656}
8657
8658impl fmt::Display for InitialLetter {
8659    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8660        match self {
8661            Self::Normal => f.write_str("normal"),
8662            Self::Number(v) => v.fmt(f),
8663            Self::Raw(v) => v.fmt(f),
8664        }
8665    }
8666}
8667
8668impl From<f64> for InitialLetter {
8669    fn from(v: f64) -> Self {
8670        Self::Number(v)
8671    }
8672}
8673
8674impl From<i32> for InitialLetter {
8675    fn from(v: i32) -> Self {
8676        Self::Number(f64::from(v))
8677    }
8678}
8679
8680impl From<Raw> for InitialLetter {
8681    fn from(v: Raw) -> Self {
8682        Self::Raw(v)
8683    }
8684}
8685
8686/// A value of [`inline-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/inline-size).
8687#[derive(Debug, Clone, PartialEq)]
8688#[non_exhaustive]
8689pub enum InlineSize {
8690    /// `auto`.
8691    Auto,
8692    /// `fit-content`.
8693    FitContent,
8694    /// `max-content`.
8695    MaxContent,
8696    /// `min-content`.
8697    MinContent,
8698    /// A length.
8699    Length(Length),
8700    /// A percentage.
8701    Percentage(Percentage),
8702    /// Any other value, passed through unchecked.
8703    Raw(Raw),
8704}
8705
8706impl fmt::Display for InlineSize {
8707    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8708        match self {
8709            Self::Auto => f.write_str("auto"),
8710            Self::FitContent => f.write_str("fit-content"),
8711            Self::MaxContent => f.write_str("max-content"),
8712            Self::MinContent => f.write_str("min-content"),
8713            Self::Length(v) => v.fmt(f),
8714            Self::Percentage(v) => v.fmt(f),
8715            Self::Raw(v) => v.fmt(f),
8716        }
8717    }
8718}
8719
8720impl From<Length> for InlineSize {
8721    fn from(v: Length) -> Self {
8722        Self::Length(v)
8723    }
8724}
8725
8726impl From<Percentage> for InlineSize {
8727    fn from(v: Percentage) -> Self {
8728        Self::Percentage(v)
8729    }
8730}
8731
8732impl From<Raw> for InlineSize {
8733    fn from(v: Raw) -> Self {
8734        Self::Raw(v)
8735    }
8736}
8737
8738/// A value of [`inset`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/inset).
8739#[derive(Debug, Clone, PartialEq)]
8740#[non_exhaustive]
8741pub enum Inset {
8742    /// `auto`.
8743    Auto,
8744    /// A length.
8745    Length(Length),
8746    /// A percentage.
8747    Percentage(Percentage),
8748    /// Any other value, passed through unchecked.
8749    Raw(Raw),
8750}
8751
8752impl fmt::Display for Inset {
8753    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8754        match self {
8755            Self::Auto => f.write_str("auto"),
8756            Self::Length(v) => v.fmt(f),
8757            Self::Percentage(v) => v.fmt(f),
8758            Self::Raw(v) => v.fmt(f),
8759        }
8760    }
8761}
8762
8763impl From<Length> for Inset {
8764    fn from(v: Length) -> Self {
8765        Self::Length(v)
8766    }
8767}
8768
8769impl From<Percentage> for Inset {
8770    fn from(v: Percentage) -> Self {
8771        Self::Percentage(v)
8772    }
8773}
8774
8775impl From<Raw> for Inset {
8776    fn from(v: Raw) -> Self {
8777        Self::Raw(v)
8778    }
8779}
8780
8781/// A value of [`inset-block`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/inset-block).
8782#[derive(Debug, Clone, PartialEq)]
8783#[non_exhaustive]
8784pub enum InsetBlock {
8785    /// `auto`.
8786    Auto,
8787    /// A length.
8788    Length(Length),
8789    /// A percentage.
8790    Percentage(Percentage),
8791    /// Any other value, passed through unchecked.
8792    Raw(Raw),
8793}
8794
8795impl fmt::Display for InsetBlock {
8796    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8797        match self {
8798            Self::Auto => f.write_str("auto"),
8799            Self::Length(v) => v.fmt(f),
8800            Self::Percentage(v) => v.fmt(f),
8801            Self::Raw(v) => v.fmt(f),
8802        }
8803    }
8804}
8805
8806impl From<Length> for InsetBlock {
8807    fn from(v: Length) -> Self {
8808        Self::Length(v)
8809    }
8810}
8811
8812impl From<Percentage> for InsetBlock {
8813    fn from(v: Percentage) -> Self {
8814        Self::Percentage(v)
8815    }
8816}
8817
8818impl From<Raw> for InsetBlock {
8819    fn from(v: Raw) -> Self {
8820        Self::Raw(v)
8821    }
8822}
8823
8824/// A value of [`inset-block-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/inset-block-end).
8825#[derive(Debug, Clone, PartialEq)]
8826#[non_exhaustive]
8827pub enum InsetBlockEnd {
8828    /// `auto`.
8829    Auto,
8830    /// A length.
8831    Length(Length),
8832    /// A percentage.
8833    Percentage(Percentage),
8834    /// Any other value, passed through unchecked.
8835    Raw(Raw),
8836}
8837
8838impl fmt::Display for InsetBlockEnd {
8839    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8840        match self {
8841            Self::Auto => f.write_str("auto"),
8842            Self::Length(v) => v.fmt(f),
8843            Self::Percentage(v) => v.fmt(f),
8844            Self::Raw(v) => v.fmt(f),
8845        }
8846    }
8847}
8848
8849impl From<Length> for InsetBlockEnd {
8850    fn from(v: Length) -> Self {
8851        Self::Length(v)
8852    }
8853}
8854
8855impl From<Percentage> for InsetBlockEnd {
8856    fn from(v: Percentage) -> Self {
8857        Self::Percentage(v)
8858    }
8859}
8860
8861impl From<Raw> for InsetBlockEnd {
8862    fn from(v: Raw) -> Self {
8863        Self::Raw(v)
8864    }
8865}
8866
8867/// A value of [`inset-block-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/inset-block-start).
8868#[derive(Debug, Clone, PartialEq)]
8869#[non_exhaustive]
8870pub enum InsetBlockStart {
8871    /// `auto`.
8872    Auto,
8873    /// A length.
8874    Length(Length),
8875    /// A percentage.
8876    Percentage(Percentage),
8877    /// Any other value, passed through unchecked.
8878    Raw(Raw),
8879}
8880
8881impl fmt::Display for InsetBlockStart {
8882    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8883        match self {
8884            Self::Auto => f.write_str("auto"),
8885            Self::Length(v) => v.fmt(f),
8886            Self::Percentage(v) => v.fmt(f),
8887            Self::Raw(v) => v.fmt(f),
8888        }
8889    }
8890}
8891
8892impl From<Length> for InsetBlockStart {
8893    fn from(v: Length) -> Self {
8894        Self::Length(v)
8895    }
8896}
8897
8898impl From<Percentage> for InsetBlockStart {
8899    fn from(v: Percentage) -> Self {
8900        Self::Percentage(v)
8901    }
8902}
8903
8904impl From<Raw> for InsetBlockStart {
8905    fn from(v: Raw) -> Self {
8906        Self::Raw(v)
8907    }
8908}
8909
8910/// A value of [`inset-inline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/inset-inline).
8911#[derive(Debug, Clone, PartialEq)]
8912#[non_exhaustive]
8913pub enum InsetInline {
8914    /// `auto`.
8915    Auto,
8916    /// A length.
8917    Length(Length),
8918    /// A percentage.
8919    Percentage(Percentage),
8920    /// Any other value, passed through unchecked.
8921    Raw(Raw),
8922}
8923
8924impl fmt::Display for InsetInline {
8925    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8926        match self {
8927            Self::Auto => f.write_str("auto"),
8928            Self::Length(v) => v.fmt(f),
8929            Self::Percentage(v) => v.fmt(f),
8930            Self::Raw(v) => v.fmt(f),
8931        }
8932    }
8933}
8934
8935impl From<Length> for InsetInline {
8936    fn from(v: Length) -> Self {
8937        Self::Length(v)
8938    }
8939}
8940
8941impl From<Percentage> for InsetInline {
8942    fn from(v: Percentage) -> Self {
8943        Self::Percentage(v)
8944    }
8945}
8946
8947impl From<Raw> for InsetInline {
8948    fn from(v: Raw) -> Self {
8949        Self::Raw(v)
8950    }
8951}
8952
8953/// A value of [`inset-inline-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/inset-inline-end).
8954#[derive(Debug, Clone, PartialEq)]
8955#[non_exhaustive]
8956pub enum InsetInlineEnd {
8957    /// `auto`.
8958    Auto,
8959    /// A length.
8960    Length(Length),
8961    /// A percentage.
8962    Percentage(Percentage),
8963    /// Any other value, passed through unchecked.
8964    Raw(Raw),
8965}
8966
8967impl fmt::Display for InsetInlineEnd {
8968    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
8969        match self {
8970            Self::Auto => f.write_str("auto"),
8971            Self::Length(v) => v.fmt(f),
8972            Self::Percentage(v) => v.fmt(f),
8973            Self::Raw(v) => v.fmt(f),
8974        }
8975    }
8976}
8977
8978impl From<Length> for InsetInlineEnd {
8979    fn from(v: Length) -> Self {
8980        Self::Length(v)
8981    }
8982}
8983
8984impl From<Percentage> for InsetInlineEnd {
8985    fn from(v: Percentage) -> Self {
8986        Self::Percentage(v)
8987    }
8988}
8989
8990impl From<Raw> for InsetInlineEnd {
8991    fn from(v: Raw) -> Self {
8992        Self::Raw(v)
8993    }
8994}
8995
8996/// A value of [`inset-inline-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/inset-inline-start).
8997#[derive(Debug, Clone, PartialEq)]
8998#[non_exhaustive]
8999pub enum InsetInlineStart {
9000    /// `auto`.
9001    Auto,
9002    /// A length.
9003    Length(Length),
9004    /// A percentage.
9005    Percentage(Percentage),
9006    /// Any other value, passed through unchecked.
9007    Raw(Raw),
9008}
9009
9010impl fmt::Display for InsetInlineStart {
9011    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9012        match self {
9013            Self::Auto => f.write_str("auto"),
9014            Self::Length(v) => v.fmt(f),
9015            Self::Percentage(v) => v.fmt(f),
9016            Self::Raw(v) => v.fmt(f),
9017        }
9018    }
9019}
9020
9021impl From<Length> for InsetInlineStart {
9022    fn from(v: Length) -> Self {
9023        Self::Length(v)
9024    }
9025}
9026
9027impl From<Percentage> for InsetInlineStart {
9028    fn from(v: Percentage) -> Self {
9029        Self::Percentage(v)
9030    }
9031}
9032
9033impl From<Raw> for InsetInlineStart {
9034    fn from(v: Raw) -> Self {
9035        Self::Raw(v)
9036    }
9037}
9038
9039/// A value of [`interactivity`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/interactivity).
9040#[derive(Debug, Clone, PartialEq)]
9041#[non_exhaustive]
9042pub enum Interactivity {
9043    /// `auto`.
9044    Auto,
9045    /// `inert`.
9046    Inert,
9047}
9048
9049impl fmt::Display for Interactivity {
9050    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9051        match self {
9052            Self::Auto => f.write_str("auto"),
9053            Self::Inert => f.write_str("inert"),
9054        }
9055    }
9056}
9057
9058/// A value of [`interest-delay`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/interest-delay-end).
9059#[derive(Debug, Clone, PartialEq)]
9060#[non_exhaustive]
9061pub enum InterestDelay {
9062    /// `normal`.
9063    Normal,
9064    /// A duration.
9065    Time(Time),
9066    /// Any other value, passed through unchecked.
9067    Raw(Raw),
9068}
9069
9070impl fmt::Display for InterestDelay {
9071    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9072        match self {
9073            Self::Normal => f.write_str("normal"),
9074            Self::Time(v) => v.fmt(f),
9075            Self::Raw(v) => v.fmt(f),
9076        }
9077    }
9078}
9079
9080impl From<Time> for InterestDelay {
9081    fn from(v: Time) -> Self {
9082        Self::Time(v)
9083    }
9084}
9085
9086impl From<Raw> for InterestDelay {
9087    fn from(v: Raw) -> Self {
9088        Self::Raw(v)
9089    }
9090}
9091
9092/// A value of [`interest-delay-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/interest-delay-end).
9093#[derive(Debug, Clone, PartialEq)]
9094#[non_exhaustive]
9095pub enum InterestDelayEnd {
9096    /// `normal`.
9097    Normal,
9098    /// A duration.
9099    Time(Time),
9100}
9101
9102impl fmt::Display for InterestDelayEnd {
9103    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9104        match self {
9105            Self::Normal => f.write_str("normal"),
9106            Self::Time(v) => v.fmt(f),
9107        }
9108    }
9109}
9110
9111impl From<Time> for InterestDelayEnd {
9112    fn from(v: Time) -> Self {
9113        Self::Time(v)
9114    }
9115}
9116
9117/// A value of [`interest-delay-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/interest-delay-start).
9118#[derive(Debug, Clone, PartialEq)]
9119#[non_exhaustive]
9120pub enum InterestDelayStart {
9121    /// `normal`.
9122    Normal,
9123    /// A duration.
9124    Time(Time),
9125}
9126
9127impl fmt::Display for InterestDelayStart {
9128    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9129        match self {
9130            Self::Normal => f.write_str("normal"),
9131            Self::Time(v) => v.fmt(f),
9132        }
9133    }
9134}
9135
9136impl From<Time> for InterestDelayStart {
9137    fn from(v: Time) -> Self {
9138        Self::Time(v)
9139    }
9140}
9141
9142/// A value of [`isolation`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/isolation).
9143#[derive(Debug, Clone, PartialEq)]
9144#[non_exhaustive]
9145pub enum Isolation {
9146    /// `auto`.
9147    Auto,
9148    /// `isolate`.
9149    Isolate,
9150}
9151
9152impl fmt::Display for Isolation {
9153    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9154        match self {
9155            Self::Auto => f.write_str("auto"),
9156            Self::Isolate => f.write_str("isolate"),
9157        }
9158    }
9159}
9160
9161/// A value of [`justify-content`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/justify-content).
9162#[derive(Debug, Clone, PartialEq)]
9163#[non_exhaustive]
9164pub enum JustifyContent {
9165    /// `center`.
9166    Center,
9167    /// `end`.
9168    End,
9169    /// `flex-end`.
9170    FlexEnd,
9171    /// `flex-start`.
9172    FlexStart,
9173    /// `left`.
9174    Left,
9175    /// `normal`.
9176    Normal,
9177    /// `right`.
9178    Right,
9179    /// `space-around`.
9180    SpaceAround,
9181    /// `space-between`.
9182    SpaceBetween,
9183    /// `space-evenly`.
9184    SpaceEvenly,
9185    /// `start`.
9186    Start,
9187    /// `stretch`.
9188    Stretch,
9189    /// Any other value, passed through unchecked.
9190    Raw(Raw),
9191}
9192
9193impl fmt::Display for JustifyContent {
9194    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9195        match self {
9196            Self::Center => f.write_str("center"),
9197            Self::End => f.write_str("end"),
9198            Self::FlexEnd => f.write_str("flex-end"),
9199            Self::FlexStart => f.write_str("flex-start"),
9200            Self::Left => f.write_str("left"),
9201            Self::Normal => f.write_str("normal"),
9202            Self::Right => f.write_str("right"),
9203            Self::SpaceAround => f.write_str("space-around"),
9204            Self::SpaceBetween => f.write_str("space-between"),
9205            Self::SpaceEvenly => f.write_str("space-evenly"),
9206            Self::Start => f.write_str("start"),
9207            Self::Stretch => f.write_str("stretch"),
9208            Self::Raw(v) => v.fmt(f),
9209        }
9210    }
9211}
9212
9213impl From<Raw> for JustifyContent {
9214    fn from(v: Raw) -> Self {
9215        Self::Raw(v)
9216    }
9217}
9218
9219/// A value of [`justify-items`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/justify-items).
9220#[derive(Debug, Clone, PartialEq)]
9221#[non_exhaustive]
9222pub enum JustifyItems {
9223    /// `anchor-center`.
9224    AnchorCenter,
9225    /// `baseline`.
9226    Baseline,
9227    /// `center`.
9228    Center,
9229    /// `end`.
9230    End,
9231    /// `flex-end`.
9232    FlexEnd,
9233    /// `flex-start`.
9234    FlexStart,
9235    /// `left`.
9236    Left,
9237    /// `legacy`.
9238    Legacy,
9239    /// `normal`.
9240    Normal,
9241    /// `right`.
9242    Right,
9243    /// `self-end`.
9244    SelfEnd,
9245    /// `self-start`.
9246    SelfStart,
9247    /// `start`.
9248    Start,
9249    /// `stretch`.
9250    Stretch,
9251    /// Any other value, passed through unchecked.
9252    Raw(Raw),
9253}
9254
9255impl fmt::Display for JustifyItems {
9256    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9257        match self {
9258            Self::AnchorCenter => f.write_str("anchor-center"),
9259            Self::Baseline => f.write_str("baseline"),
9260            Self::Center => f.write_str("center"),
9261            Self::End => f.write_str("end"),
9262            Self::FlexEnd => f.write_str("flex-end"),
9263            Self::FlexStart => f.write_str("flex-start"),
9264            Self::Left => f.write_str("left"),
9265            Self::Legacy => f.write_str("legacy"),
9266            Self::Normal => f.write_str("normal"),
9267            Self::Right => f.write_str("right"),
9268            Self::SelfEnd => f.write_str("self-end"),
9269            Self::SelfStart => f.write_str("self-start"),
9270            Self::Start => f.write_str("start"),
9271            Self::Stretch => f.write_str("stretch"),
9272            Self::Raw(v) => v.fmt(f),
9273        }
9274    }
9275}
9276
9277impl From<Raw> for JustifyItems {
9278    fn from(v: Raw) -> Self {
9279        Self::Raw(v)
9280    }
9281}
9282
9283/// A value of [`justify-self`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/justify-self).
9284#[derive(Debug, Clone, PartialEq)]
9285#[non_exhaustive]
9286pub enum JustifySelf {
9287    /// `anchor-center`.
9288    AnchorCenter,
9289    /// `auto`.
9290    Auto,
9291    /// `baseline`.
9292    Baseline,
9293    /// `center`.
9294    Center,
9295    /// `end`.
9296    End,
9297    /// `flex-end`.
9298    FlexEnd,
9299    /// `flex-start`.
9300    FlexStart,
9301    /// `left`.
9302    Left,
9303    /// `normal`.
9304    Normal,
9305    /// `right`.
9306    Right,
9307    /// `self-end`.
9308    SelfEnd,
9309    /// `self-start`.
9310    SelfStart,
9311    /// `start`.
9312    Start,
9313    /// `stretch`.
9314    Stretch,
9315    /// Any other value, passed through unchecked.
9316    Raw(Raw),
9317}
9318
9319impl fmt::Display for JustifySelf {
9320    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9321        match self {
9322            Self::AnchorCenter => f.write_str("anchor-center"),
9323            Self::Auto => f.write_str("auto"),
9324            Self::Baseline => f.write_str("baseline"),
9325            Self::Center => f.write_str("center"),
9326            Self::End => f.write_str("end"),
9327            Self::FlexEnd => f.write_str("flex-end"),
9328            Self::FlexStart => f.write_str("flex-start"),
9329            Self::Left => f.write_str("left"),
9330            Self::Normal => f.write_str("normal"),
9331            Self::Right => f.write_str("right"),
9332            Self::SelfEnd => f.write_str("self-end"),
9333            Self::SelfStart => f.write_str("self-start"),
9334            Self::Start => f.write_str("start"),
9335            Self::Stretch => f.write_str("stretch"),
9336            Self::Raw(v) => v.fmt(f),
9337        }
9338    }
9339}
9340
9341impl From<Raw> for JustifySelf {
9342    fn from(v: Raw) -> Self {
9343        Self::Raw(v)
9344    }
9345}
9346
9347/// A value of [`left`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/left).
9348#[derive(Debug, Clone, PartialEq)]
9349#[non_exhaustive]
9350pub enum Left {
9351    /// `auto`.
9352    Auto,
9353    /// A length.
9354    Length(Length),
9355    /// A percentage.
9356    Percentage(Percentage),
9357    /// Any other value, passed through unchecked.
9358    Raw(Raw),
9359}
9360
9361impl fmt::Display for Left {
9362    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9363        match self {
9364            Self::Auto => f.write_str("auto"),
9365            Self::Length(v) => v.fmt(f),
9366            Self::Percentage(v) => v.fmt(f),
9367            Self::Raw(v) => v.fmt(f),
9368        }
9369    }
9370}
9371
9372impl From<Length> for Left {
9373    fn from(v: Length) -> Self {
9374        Self::Length(v)
9375    }
9376}
9377
9378impl From<Percentage> for Left {
9379    fn from(v: Percentage) -> Self {
9380        Self::Percentage(v)
9381    }
9382}
9383
9384impl From<Raw> for Left {
9385    fn from(v: Raw) -> Self {
9386        Self::Raw(v)
9387    }
9388}
9389
9390/// A value of [`letter-spacing`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/letter-spacing).
9391#[derive(Debug, Clone, PartialEq)]
9392#[non_exhaustive]
9393pub enum LetterSpacing {
9394    /// `normal`.
9395    Normal,
9396    /// A length.
9397    Length(Length),
9398}
9399
9400impl fmt::Display for LetterSpacing {
9401    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9402        match self {
9403            Self::Normal => f.write_str("normal"),
9404            Self::Length(v) => v.fmt(f),
9405        }
9406    }
9407}
9408
9409impl From<Length> for LetterSpacing {
9410    fn from(v: Length) -> Self {
9411        Self::Length(v)
9412    }
9413}
9414
9415/// A value of [`line-break`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/line-break).
9416#[derive(Debug, Clone, PartialEq)]
9417#[non_exhaustive]
9418pub enum LineBreak {
9419    /// `anywhere`.
9420    Anywhere,
9421    /// `auto`.
9422    Auto,
9423    /// `loose`.
9424    Loose,
9425    /// `normal`.
9426    Normal,
9427    /// `strict`.
9428    Strict,
9429}
9430
9431impl fmt::Display for LineBreak {
9432    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9433        match self {
9434            Self::Anywhere => f.write_str("anywhere"),
9435            Self::Auto => f.write_str("auto"),
9436            Self::Loose => f.write_str("loose"),
9437            Self::Normal => f.write_str("normal"),
9438            Self::Strict => f.write_str("strict"),
9439        }
9440    }
9441}
9442
9443/// A value of [`line-clamp`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/line-clamp).
9444#[derive(Debug, Clone, PartialEq)]
9445#[non_exhaustive]
9446pub enum LineClamp {
9447    /// `none`.
9448    None,
9449    /// An integer.
9450    Integer(i32),
9451}
9452
9453impl fmt::Display for LineClamp {
9454    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9455        match self {
9456            Self::None => f.write_str("none"),
9457            Self::Integer(v) => v.fmt(f),
9458        }
9459    }
9460}
9461
9462impl From<i32> for LineClamp {
9463    fn from(v: i32) -> Self {
9464        Self::Integer(v)
9465    }
9466}
9467
9468/// A value of [`line-height`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/line-height).
9469#[derive(Debug, Clone, PartialEq)]
9470#[non_exhaustive]
9471pub enum LineHeight {
9472    /// `normal`.
9473    Normal,
9474    /// A length.
9475    Length(Length),
9476    /// A percentage.
9477    Percentage(Percentage),
9478    /// A number.
9479    Number(f64),
9480}
9481
9482impl fmt::Display for LineHeight {
9483    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9484        match self {
9485            Self::Normal => f.write_str("normal"),
9486            Self::Length(v) => v.fmt(f),
9487            Self::Percentage(v) => v.fmt(f),
9488            Self::Number(v) => v.fmt(f),
9489        }
9490    }
9491}
9492
9493impl From<Length> for LineHeight {
9494    fn from(v: Length) -> Self {
9495        Self::Length(v)
9496    }
9497}
9498
9499impl From<Percentage> for LineHeight {
9500    fn from(v: Percentage) -> Self {
9501        Self::Percentage(v)
9502    }
9503}
9504
9505impl From<f64> for LineHeight {
9506    fn from(v: f64) -> Self {
9507        Self::Number(v)
9508    }
9509}
9510
9511impl From<i32> for LineHeight {
9512    fn from(v: i32) -> Self {
9513        Self::Number(f64::from(v))
9514    }
9515}
9516
9517/// A value of [`list-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/list-style).
9518#[derive(Debug, Clone, PartialEq)]
9519#[non_exhaustive]
9520pub enum ListStyle {
9521    /// `inside`.
9522    Inside,
9523    /// `none`.
9524    None,
9525    /// `outside`.
9526    Outside,
9527    /// A quoted string.
9528    Quoted(Quoted),
9529    /// A URL.
9530    Url(Url),
9531    /// Any other value, passed through unchecked.
9532    Raw(Raw),
9533}
9534
9535impl fmt::Display for ListStyle {
9536    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9537        match self {
9538            Self::Inside => f.write_str("inside"),
9539            Self::None => f.write_str("none"),
9540            Self::Outside => f.write_str("outside"),
9541            Self::Quoted(v) => v.fmt(f),
9542            Self::Url(v) => v.fmt(f),
9543            Self::Raw(v) => v.fmt(f),
9544        }
9545    }
9546}
9547
9548impl From<Quoted> for ListStyle {
9549    fn from(v: Quoted) -> Self {
9550        Self::Quoted(v)
9551    }
9552}
9553
9554impl From<Url> for ListStyle {
9555    fn from(v: Url) -> Self {
9556        Self::Url(v)
9557    }
9558}
9559
9560impl From<Raw> for ListStyle {
9561    fn from(v: Raw) -> Self {
9562        Self::Raw(v)
9563    }
9564}
9565
9566/// A value of [`list-style-image`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/list-style-image).
9567#[derive(Debug, Clone, PartialEq)]
9568#[non_exhaustive]
9569pub enum ListStyleImage {
9570    /// `none`.
9571    None,
9572    /// A URL.
9573    Url(Url),
9574    /// Any other value, passed through unchecked.
9575    Raw(Raw),
9576}
9577
9578impl fmt::Display for ListStyleImage {
9579    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9580        match self {
9581            Self::None => f.write_str("none"),
9582            Self::Url(v) => v.fmt(f),
9583            Self::Raw(v) => v.fmt(f),
9584        }
9585    }
9586}
9587
9588impl From<Url> for ListStyleImage {
9589    fn from(v: Url) -> Self {
9590        Self::Url(v)
9591    }
9592}
9593
9594impl From<Raw> for ListStyleImage {
9595    fn from(v: Raw) -> Self {
9596        Self::Raw(v)
9597    }
9598}
9599
9600/// A value of [`list-style-position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/list-style-position).
9601#[derive(Debug, Clone, PartialEq)]
9602#[non_exhaustive]
9603pub enum ListStylePosition {
9604    /// `inside`.
9605    Inside,
9606    /// `outside`.
9607    Outside,
9608}
9609
9610impl fmt::Display for ListStylePosition {
9611    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9612        match self {
9613            Self::Inside => f.write_str("inside"),
9614            Self::Outside => f.write_str("outside"),
9615        }
9616    }
9617}
9618
9619/// A value of [`list-style-type`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/list-style-type).
9620#[derive(Debug, Clone, PartialEq)]
9621#[non_exhaustive]
9622pub enum ListStyleType {
9623    /// `none`.
9624    None,
9625    /// A quoted string.
9626    Quoted(Quoted),
9627    /// Any other value, passed through unchecked.
9628    Raw(Raw),
9629}
9630
9631impl fmt::Display for ListStyleType {
9632    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9633        match self {
9634            Self::None => f.write_str("none"),
9635            Self::Quoted(v) => v.fmt(f),
9636            Self::Raw(v) => v.fmt(f),
9637        }
9638    }
9639}
9640
9641impl From<Quoted> for ListStyleType {
9642    fn from(v: Quoted) -> Self {
9643        Self::Quoted(v)
9644    }
9645}
9646
9647impl From<Raw> for ListStyleType {
9648    fn from(v: Raw) -> Self {
9649        Self::Raw(v)
9650    }
9651}
9652
9653/// A value of [`margin`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin).
9654#[derive(Debug, Clone, PartialEq)]
9655#[non_exhaustive]
9656pub enum Margin {
9657    /// `auto`.
9658    Auto,
9659    /// A length.
9660    Length(Length),
9661    /// A percentage.
9662    Percentage(Percentage),
9663    /// Any other value, passed through unchecked.
9664    Raw(Raw),
9665}
9666
9667impl fmt::Display for Margin {
9668    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9669        match self {
9670            Self::Auto => f.write_str("auto"),
9671            Self::Length(v) => v.fmt(f),
9672            Self::Percentage(v) => v.fmt(f),
9673            Self::Raw(v) => v.fmt(f),
9674        }
9675    }
9676}
9677
9678impl From<Length> for Margin {
9679    fn from(v: Length) -> Self {
9680        Self::Length(v)
9681    }
9682}
9683
9684impl From<Percentage> for Margin {
9685    fn from(v: Percentage) -> Self {
9686        Self::Percentage(v)
9687    }
9688}
9689
9690impl From<Raw> for Margin {
9691    fn from(v: Raw) -> Self {
9692        Self::Raw(v)
9693    }
9694}
9695
9696/// A value of [`margin-block`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-block).
9697#[derive(Debug, Clone, PartialEq)]
9698#[non_exhaustive]
9699pub enum MarginBlock {
9700    /// `auto`.
9701    Auto,
9702    /// A length.
9703    Length(Length),
9704    /// A percentage.
9705    Percentage(Percentage),
9706    /// Any other value, passed through unchecked.
9707    Raw(Raw),
9708}
9709
9710impl fmt::Display for MarginBlock {
9711    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9712        match self {
9713            Self::Auto => f.write_str("auto"),
9714            Self::Length(v) => v.fmt(f),
9715            Self::Percentage(v) => v.fmt(f),
9716            Self::Raw(v) => v.fmt(f),
9717        }
9718    }
9719}
9720
9721impl From<Length> for MarginBlock {
9722    fn from(v: Length) -> Self {
9723        Self::Length(v)
9724    }
9725}
9726
9727impl From<Percentage> for MarginBlock {
9728    fn from(v: Percentage) -> Self {
9729        Self::Percentage(v)
9730    }
9731}
9732
9733impl From<Raw> for MarginBlock {
9734    fn from(v: Raw) -> Self {
9735        Self::Raw(v)
9736    }
9737}
9738
9739/// A value of [`margin-block-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-block-end).
9740#[derive(Debug, Clone, PartialEq)]
9741#[non_exhaustive]
9742pub enum MarginBlockEnd {
9743    /// `auto`.
9744    Auto,
9745    /// A length.
9746    Length(Length),
9747    /// A percentage.
9748    Percentage(Percentage),
9749    /// Any other value, passed through unchecked.
9750    Raw(Raw),
9751}
9752
9753impl fmt::Display for MarginBlockEnd {
9754    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9755        match self {
9756            Self::Auto => f.write_str("auto"),
9757            Self::Length(v) => v.fmt(f),
9758            Self::Percentage(v) => v.fmt(f),
9759            Self::Raw(v) => v.fmt(f),
9760        }
9761    }
9762}
9763
9764impl From<Length> for MarginBlockEnd {
9765    fn from(v: Length) -> Self {
9766        Self::Length(v)
9767    }
9768}
9769
9770impl From<Percentage> for MarginBlockEnd {
9771    fn from(v: Percentage) -> Self {
9772        Self::Percentage(v)
9773    }
9774}
9775
9776impl From<Raw> for MarginBlockEnd {
9777    fn from(v: Raw) -> Self {
9778        Self::Raw(v)
9779    }
9780}
9781
9782/// A value of [`margin-block-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-block-start).
9783#[derive(Debug, Clone, PartialEq)]
9784#[non_exhaustive]
9785pub enum MarginBlockStart {
9786    /// `auto`.
9787    Auto,
9788    /// A length.
9789    Length(Length),
9790    /// A percentage.
9791    Percentage(Percentage),
9792    /// Any other value, passed through unchecked.
9793    Raw(Raw),
9794}
9795
9796impl fmt::Display for MarginBlockStart {
9797    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9798        match self {
9799            Self::Auto => f.write_str("auto"),
9800            Self::Length(v) => v.fmt(f),
9801            Self::Percentage(v) => v.fmt(f),
9802            Self::Raw(v) => v.fmt(f),
9803        }
9804    }
9805}
9806
9807impl From<Length> for MarginBlockStart {
9808    fn from(v: Length) -> Self {
9809        Self::Length(v)
9810    }
9811}
9812
9813impl From<Percentage> for MarginBlockStart {
9814    fn from(v: Percentage) -> Self {
9815        Self::Percentage(v)
9816    }
9817}
9818
9819impl From<Raw> for MarginBlockStart {
9820    fn from(v: Raw) -> Self {
9821        Self::Raw(v)
9822    }
9823}
9824
9825/// A value of [`margin-bottom`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-bottom).
9826#[derive(Debug, Clone, PartialEq)]
9827#[non_exhaustive]
9828pub enum MarginBottom {
9829    /// `auto`.
9830    Auto,
9831    /// A length.
9832    Length(Length),
9833    /// A percentage.
9834    Percentage(Percentage),
9835    /// Any other value, passed through unchecked.
9836    Raw(Raw),
9837}
9838
9839impl fmt::Display for MarginBottom {
9840    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9841        match self {
9842            Self::Auto => f.write_str("auto"),
9843            Self::Length(v) => v.fmt(f),
9844            Self::Percentage(v) => v.fmt(f),
9845            Self::Raw(v) => v.fmt(f),
9846        }
9847    }
9848}
9849
9850impl From<Length> for MarginBottom {
9851    fn from(v: Length) -> Self {
9852        Self::Length(v)
9853    }
9854}
9855
9856impl From<Percentage> for MarginBottom {
9857    fn from(v: Percentage) -> Self {
9858        Self::Percentage(v)
9859    }
9860}
9861
9862impl From<Raw> for MarginBottom {
9863    fn from(v: Raw) -> Self {
9864        Self::Raw(v)
9865    }
9866}
9867
9868/// A value of [`margin-inline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-inline).
9869#[derive(Debug, Clone, PartialEq)]
9870#[non_exhaustive]
9871pub enum MarginInline {
9872    /// `auto`.
9873    Auto,
9874    /// A length.
9875    Length(Length),
9876    /// A percentage.
9877    Percentage(Percentage),
9878    /// Any other value, passed through unchecked.
9879    Raw(Raw),
9880}
9881
9882impl fmt::Display for MarginInline {
9883    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9884        match self {
9885            Self::Auto => f.write_str("auto"),
9886            Self::Length(v) => v.fmt(f),
9887            Self::Percentage(v) => v.fmt(f),
9888            Self::Raw(v) => v.fmt(f),
9889        }
9890    }
9891}
9892
9893impl From<Length> for MarginInline {
9894    fn from(v: Length) -> Self {
9895        Self::Length(v)
9896    }
9897}
9898
9899impl From<Percentage> for MarginInline {
9900    fn from(v: Percentage) -> Self {
9901        Self::Percentage(v)
9902    }
9903}
9904
9905impl From<Raw> for MarginInline {
9906    fn from(v: Raw) -> Self {
9907        Self::Raw(v)
9908    }
9909}
9910
9911/// A value of [`margin-inline-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-inline-end).
9912#[derive(Debug, Clone, PartialEq)]
9913#[non_exhaustive]
9914pub enum MarginInlineEnd {
9915    /// `auto`.
9916    Auto,
9917    /// A length.
9918    Length(Length),
9919    /// A percentage.
9920    Percentage(Percentage),
9921    /// Any other value, passed through unchecked.
9922    Raw(Raw),
9923}
9924
9925impl fmt::Display for MarginInlineEnd {
9926    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9927        match self {
9928            Self::Auto => f.write_str("auto"),
9929            Self::Length(v) => v.fmt(f),
9930            Self::Percentage(v) => v.fmt(f),
9931            Self::Raw(v) => v.fmt(f),
9932        }
9933    }
9934}
9935
9936impl From<Length> for MarginInlineEnd {
9937    fn from(v: Length) -> Self {
9938        Self::Length(v)
9939    }
9940}
9941
9942impl From<Percentage> for MarginInlineEnd {
9943    fn from(v: Percentage) -> Self {
9944        Self::Percentage(v)
9945    }
9946}
9947
9948impl From<Raw> for MarginInlineEnd {
9949    fn from(v: Raw) -> Self {
9950        Self::Raw(v)
9951    }
9952}
9953
9954/// A value of [`margin-inline-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-inline-start).
9955#[derive(Debug, Clone, PartialEq)]
9956#[non_exhaustive]
9957pub enum MarginInlineStart {
9958    /// `auto`.
9959    Auto,
9960    /// A length.
9961    Length(Length),
9962    /// A percentage.
9963    Percentage(Percentage),
9964    /// Any other value, passed through unchecked.
9965    Raw(Raw),
9966}
9967
9968impl fmt::Display for MarginInlineStart {
9969    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9970        match self {
9971            Self::Auto => f.write_str("auto"),
9972            Self::Length(v) => v.fmt(f),
9973            Self::Percentage(v) => v.fmt(f),
9974            Self::Raw(v) => v.fmt(f),
9975        }
9976    }
9977}
9978
9979impl From<Length> for MarginInlineStart {
9980    fn from(v: Length) -> Self {
9981        Self::Length(v)
9982    }
9983}
9984
9985impl From<Percentage> for MarginInlineStart {
9986    fn from(v: Percentage) -> Self {
9987        Self::Percentage(v)
9988    }
9989}
9990
9991impl From<Raw> for MarginInlineStart {
9992    fn from(v: Raw) -> Self {
9993        Self::Raw(v)
9994    }
9995}
9996
9997/// A value of [`margin-left`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-left).
9998#[derive(Debug, Clone, PartialEq)]
9999#[non_exhaustive]
10000pub enum MarginLeft {
10001    /// `auto`.
10002    Auto,
10003    /// A length.
10004    Length(Length),
10005    /// A percentage.
10006    Percentage(Percentage),
10007    /// Any other value, passed through unchecked.
10008    Raw(Raw),
10009}
10010
10011impl fmt::Display for MarginLeft {
10012    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10013        match self {
10014            Self::Auto => f.write_str("auto"),
10015            Self::Length(v) => v.fmt(f),
10016            Self::Percentage(v) => v.fmt(f),
10017            Self::Raw(v) => v.fmt(f),
10018        }
10019    }
10020}
10021
10022impl From<Length> for MarginLeft {
10023    fn from(v: Length) -> Self {
10024        Self::Length(v)
10025    }
10026}
10027
10028impl From<Percentage> for MarginLeft {
10029    fn from(v: Percentage) -> Self {
10030        Self::Percentage(v)
10031    }
10032}
10033
10034impl From<Raw> for MarginLeft {
10035    fn from(v: Raw) -> Self {
10036        Self::Raw(v)
10037    }
10038}
10039
10040/// A value of [`margin-right`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-right).
10041#[derive(Debug, Clone, PartialEq)]
10042#[non_exhaustive]
10043pub enum MarginRight {
10044    /// `auto`.
10045    Auto,
10046    /// A length.
10047    Length(Length),
10048    /// A percentage.
10049    Percentage(Percentage),
10050    /// Any other value, passed through unchecked.
10051    Raw(Raw),
10052}
10053
10054impl fmt::Display for MarginRight {
10055    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10056        match self {
10057            Self::Auto => f.write_str("auto"),
10058            Self::Length(v) => v.fmt(f),
10059            Self::Percentage(v) => v.fmt(f),
10060            Self::Raw(v) => v.fmt(f),
10061        }
10062    }
10063}
10064
10065impl From<Length> for MarginRight {
10066    fn from(v: Length) -> Self {
10067        Self::Length(v)
10068    }
10069}
10070
10071impl From<Percentage> for MarginRight {
10072    fn from(v: Percentage) -> Self {
10073        Self::Percentage(v)
10074    }
10075}
10076
10077impl From<Raw> for MarginRight {
10078    fn from(v: Raw) -> Self {
10079        Self::Raw(v)
10080    }
10081}
10082
10083/// A value of [`margin-top`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/margin-top).
10084#[derive(Debug, Clone, PartialEq)]
10085#[non_exhaustive]
10086pub enum MarginTop {
10087    /// `auto`.
10088    Auto,
10089    /// A length.
10090    Length(Length),
10091    /// A percentage.
10092    Percentage(Percentage),
10093    /// Any other value, passed through unchecked.
10094    Raw(Raw),
10095}
10096
10097impl fmt::Display for MarginTop {
10098    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10099        match self {
10100            Self::Auto => f.write_str("auto"),
10101            Self::Length(v) => v.fmt(f),
10102            Self::Percentage(v) => v.fmt(f),
10103            Self::Raw(v) => v.fmt(f),
10104        }
10105    }
10106}
10107
10108impl From<Length> for MarginTop {
10109    fn from(v: Length) -> Self {
10110        Self::Length(v)
10111    }
10112}
10113
10114impl From<Percentage> for MarginTop {
10115    fn from(v: Percentage) -> Self {
10116        Self::Percentage(v)
10117    }
10118}
10119
10120impl From<Raw> for MarginTop {
10121    fn from(v: Raw) -> Self {
10122        Self::Raw(v)
10123    }
10124}
10125
10126/// A value of [`marker`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/marker).
10127#[derive(Debug, Clone, PartialEq)]
10128#[non_exhaustive]
10129pub enum Marker {
10130    /// `none`.
10131    None,
10132    /// A URL.
10133    Url(Url),
10134}
10135
10136impl fmt::Display for Marker {
10137    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10138        match self {
10139            Self::None => f.write_str("none"),
10140            Self::Url(v) => v.fmt(f),
10141        }
10142    }
10143}
10144
10145impl From<Url> for Marker {
10146    fn from(v: Url) -> Self {
10147        Self::Url(v)
10148    }
10149}
10150
10151/// A value of [`marker-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/marker-end).
10152#[derive(Debug, Clone, PartialEq)]
10153#[non_exhaustive]
10154pub enum MarkerEnd {
10155    /// `none`.
10156    None,
10157    /// A URL.
10158    Url(Url),
10159}
10160
10161impl fmt::Display for MarkerEnd {
10162    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10163        match self {
10164            Self::None => f.write_str("none"),
10165            Self::Url(v) => v.fmt(f),
10166        }
10167    }
10168}
10169
10170impl From<Url> for MarkerEnd {
10171    fn from(v: Url) -> Self {
10172        Self::Url(v)
10173    }
10174}
10175
10176/// A value of [`marker-mid`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/marker-mid).
10177#[derive(Debug, Clone, PartialEq)]
10178#[non_exhaustive]
10179pub enum MarkerMid {
10180    /// `none`.
10181    None,
10182    /// A URL.
10183    Url(Url),
10184}
10185
10186impl fmt::Display for MarkerMid {
10187    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10188        match self {
10189            Self::None => f.write_str("none"),
10190            Self::Url(v) => v.fmt(f),
10191        }
10192    }
10193}
10194
10195impl From<Url> for MarkerMid {
10196    fn from(v: Url) -> Self {
10197        Self::Url(v)
10198    }
10199}
10200
10201/// A value of [`marker-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/marker-start).
10202#[derive(Debug, Clone, PartialEq)]
10203#[non_exhaustive]
10204pub enum MarkerStart {
10205    /// `none`.
10206    None,
10207    /// A URL.
10208    Url(Url),
10209}
10210
10211impl fmt::Display for MarkerStart {
10212    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10213        match self {
10214            Self::None => f.write_str("none"),
10215            Self::Url(v) => v.fmt(f),
10216        }
10217    }
10218}
10219
10220impl From<Url> for MarkerStart {
10221    fn from(v: Url) -> Self {
10222        Self::Url(v)
10223    }
10224}
10225
10226/// A value of [`mask`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask).
10227#[derive(Debug, Clone, PartialEq)]
10228#[non_exhaustive]
10229pub enum Mask {
10230    /// `add`.
10231    Add,
10232    /// `alpha`.
10233    Alpha,
10234    /// `border-box`.
10235    BorderBox,
10236    /// `bottom`.
10237    Bottom,
10238    /// `center`.
10239    Center,
10240    /// `content-box`.
10241    ContentBox,
10242    /// `exclude`.
10243    Exclude,
10244    /// `fill-box`.
10245    FillBox,
10246    /// `intersect`.
10247    Intersect,
10248    /// `left`.
10249    Left,
10250    /// `luminance`.
10251    Luminance,
10252    /// `margin-box`.
10253    MarginBox,
10254    /// `match-source`.
10255    MatchSource,
10256    /// `no-clip`.
10257    NoClip,
10258    /// `no-repeat`.
10259    NoRepeat,
10260    /// `none`.
10261    None,
10262    /// `padding-box`.
10263    PaddingBox,
10264    /// `repeat`.
10265    Repeat,
10266    /// `repeat-x`.
10267    RepeatX,
10268    /// `repeat-y`.
10269    RepeatY,
10270    /// `right`.
10271    Right,
10272    /// `round`.
10273    Round,
10274    /// `space`.
10275    Space,
10276    /// `stroke-box`.
10277    StrokeBox,
10278    /// `subtract`.
10279    Subtract,
10280    /// `top`.
10281    Top,
10282    /// `view-box`.
10283    ViewBox,
10284    /// A length.
10285    Length(Length),
10286    /// A percentage.
10287    Percentage(Percentage),
10288    /// A URL.
10289    Url(Url),
10290    /// Any other value, passed through unchecked.
10291    Raw(Raw),
10292}
10293
10294impl fmt::Display for Mask {
10295    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10296        match self {
10297            Self::Add => f.write_str("add"),
10298            Self::Alpha => f.write_str("alpha"),
10299            Self::BorderBox => f.write_str("border-box"),
10300            Self::Bottom => f.write_str("bottom"),
10301            Self::Center => f.write_str("center"),
10302            Self::ContentBox => f.write_str("content-box"),
10303            Self::Exclude => f.write_str("exclude"),
10304            Self::FillBox => f.write_str("fill-box"),
10305            Self::Intersect => f.write_str("intersect"),
10306            Self::Left => f.write_str("left"),
10307            Self::Luminance => f.write_str("luminance"),
10308            Self::MarginBox => f.write_str("margin-box"),
10309            Self::MatchSource => f.write_str("match-source"),
10310            Self::NoClip => f.write_str("no-clip"),
10311            Self::NoRepeat => f.write_str("no-repeat"),
10312            Self::None => f.write_str("none"),
10313            Self::PaddingBox => f.write_str("padding-box"),
10314            Self::Repeat => f.write_str("repeat"),
10315            Self::RepeatX => f.write_str("repeat-x"),
10316            Self::RepeatY => f.write_str("repeat-y"),
10317            Self::Right => f.write_str("right"),
10318            Self::Round => f.write_str("round"),
10319            Self::Space => f.write_str("space"),
10320            Self::StrokeBox => f.write_str("stroke-box"),
10321            Self::Subtract => f.write_str("subtract"),
10322            Self::Top => f.write_str("top"),
10323            Self::ViewBox => f.write_str("view-box"),
10324            Self::Length(v) => v.fmt(f),
10325            Self::Percentage(v) => v.fmt(f),
10326            Self::Url(v) => v.fmt(f),
10327            Self::Raw(v) => v.fmt(f),
10328        }
10329    }
10330}
10331
10332impl From<Length> for Mask {
10333    fn from(v: Length) -> Self {
10334        Self::Length(v)
10335    }
10336}
10337
10338impl From<Percentage> for Mask {
10339    fn from(v: Percentage) -> Self {
10340        Self::Percentage(v)
10341    }
10342}
10343
10344impl From<Url> for Mask {
10345    fn from(v: Url) -> Self {
10346        Self::Url(v)
10347    }
10348}
10349
10350impl From<Raw> for Mask {
10351    fn from(v: Raw) -> Self {
10352        Self::Raw(v)
10353    }
10354}
10355
10356/// A value of [`mask-border`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-border).
10357#[derive(Debug, Clone, PartialEq)]
10358#[non_exhaustive]
10359pub enum MaskBorder {
10360    /// `alpha`.
10361    Alpha,
10362    /// `luminance`.
10363    Luminance,
10364    /// `none`.
10365    None,
10366    /// `repeat`.
10367    Repeat,
10368    /// `round`.
10369    Round,
10370    /// `space`.
10371    Space,
10372    /// `stretch`.
10373    Stretch,
10374    /// A percentage.
10375    Percentage(Percentage),
10376    /// A number.
10377    Number(f64),
10378    /// A URL.
10379    Url(Url),
10380    /// Any other value, passed through unchecked.
10381    Raw(Raw),
10382}
10383
10384impl fmt::Display for MaskBorder {
10385    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10386        match self {
10387            Self::Alpha => f.write_str("alpha"),
10388            Self::Luminance => f.write_str("luminance"),
10389            Self::None => f.write_str("none"),
10390            Self::Repeat => f.write_str("repeat"),
10391            Self::Round => f.write_str("round"),
10392            Self::Space => f.write_str("space"),
10393            Self::Stretch => f.write_str("stretch"),
10394            Self::Percentage(v) => v.fmt(f),
10395            Self::Number(v) => v.fmt(f),
10396            Self::Url(v) => v.fmt(f),
10397            Self::Raw(v) => v.fmt(f),
10398        }
10399    }
10400}
10401
10402impl From<Percentage> for MaskBorder {
10403    fn from(v: Percentage) -> Self {
10404        Self::Percentage(v)
10405    }
10406}
10407
10408impl From<f64> for MaskBorder {
10409    fn from(v: f64) -> Self {
10410        Self::Number(v)
10411    }
10412}
10413
10414impl From<i32> for MaskBorder {
10415    fn from(v: i32) -> Self {
10416        Self::Number(f64::from(v))
10417    }
10418}
10419
10420impl From<Url> for MaskBorder {
10421    fn from(v: Url) -> Self {
10422        Self::Url(v)
10423    }
10424}
10425
10426impl From<Raw> for MaskBorder {
10427    fn from(v: Raw) -> Self {
10428        Self::Raw(v)
10429    }
10430}
10431
10432/// A value of [`mask-border-mode`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-border-mode).
10433#[derive(Debug, Clone, PartialEq)]
10434#[non_exhaustive]
10435pub enum MaskBorderMode {
10436    /// `alpha`.
10437    Alpha,
10438    /// `luminance`.
10439    Luminance,
10440}
10441
10442impl fmt::Display for MaskBorderMode {
10443    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10444        match self {
10445            Self::Alpha => f.write_str("alpha"),
10446            Self::Luminance => f.write_str("luminance"),
10447        }
10448    }
10449}
10450
10451/// A value of [`mask-border-outset`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-border-outset).
10452#[derive(Debug, Clone, PartialEq)]
10453#[non_exhaustive]
10454pub enum MaskBorderOutset {
10455    /// A length.
10456    Length(Length),
10457    /// A number.
10458    Number(f64),
10459    /// Any other value, passed through unchecked.
10460    Raw(Raw),
10461}
10462
10463impl fmt::Display for MaskBorderOutset {
10464    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10465        match self {
10466            Self::Length(v) => v.fmt(f),
10467            Self::Number(v) => v.fmt(f),
10468            Self::Raw(v) => v.fmt(f),
10469        }
10470    }
10471}
10472
10473impl From<Length> for MaskBorderOutset {
10474    fn from(v: Length) -> Self {
10475        Self::Length(v)
10476    }
10477}
10478
10479impl From<f64> for MaskBorderOutset {
10480    fn from(v: f64) -> Self {
10481        Self::Number(v)
10482    }
10483}
10484
10485impl From<i32> for MaskBorderOutset {
10486    fn from(v: i32) -> Self {
10487        Self::Number(f64::from(v))
10488    }
10489}
10490
10491impl From<Raw> for MaskBorderOutset {
10492    fn from(v: Raw) -> Self {
10493        Self::Raw(v)
10494    }
10495}
10496
10497/// A value of [`mask-border-repeat`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-border-repeat).
10498#[derive(Debug, Clone, PartialEq)]
10499#[non_exhaustive]
10500pub enum MaskBorderRepeat {
10501    /// `repeat`.
10502    Repeat,
10503    /// `round`.
10504    Round,
10505    /// `space`.
10506    Space,
10507    /// `stretch`.
10508    Stretch,
10509    /// Any other value, passed through unchecked.
10510    Raw(Raw),
10511}
10512
10513impl fmt::Display for MaskBorderRepeat {
10514    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10515        match self {
10516            Self::Repeat => f.write_str("repeat"),
10517            Self::Round => f.write_str("round"),
10518            Self::Space => f.write_str("space"),
10519            Self::Stretch => f.write_str("stretch"),
10520            Self::Raw(v) => v.fmt(f),
10521        }
10522    }
10523}
10524
10525impl From<Raw> for MaskBorderRepeat {
10526    fn from(v: Raw) -> Self {
10527        Self::Raw(v)
10528    }
10529}
10530
10531/// A value of [`mask-border-slice`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-border-slice).
10532#[derive(Debug, Clone, PartialEq)]
10533#[non_exhaustive]
10534pub enum MaskBorderSlice {
10535    /// A percentage.
10536    Percentage(Percentage),
10537    /// A number.
10538    Number(f64),
10539    /// Any other value, passed through unchecked.
10540    Raw(Raw),
10541}
10542
10543impl fmt::Display for MaskBorderSlice {
10544    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10545        match self {
10546            Self::Percentage(v) => v.fmt(f),
10547            Self::Number(v) => v.fmt(f),
10548            Self::Raw(v) => v.fmt(f),
10549        }
10550    }
10551}
10552
10553impl From<Percentage> for MaskBorderSlice {
10554    fn from(v: Percentage) -> Self {
10555        Self::Percentage(v)
10556    }
10557}
10558
10559impl From<f64> for MaskBorderSlice {
10560    fn from(v: f64) -> Self {
10561        Self::Number(v)
10562    }
10563}
10564
10565impl From<i32> for MaskBorderSlice {
10566    fn from(v: i32) -> Self {
10567        Self::Number(f64::from(v))
10568    }
10569}
10570
10571impl From<Raw> for MaskBorderSlice {
10572    fn from(v: Raw) -> Self {
10573        Self::Raw(v)
10574    }
10575}
10576
10577/// A value of [`mask-border-source`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-border-source).
10578#[derive(Debug, Clone, PartialEq)]
10579#[non_exhaustive]
10580pub enum MaskBorderSource {
10581    /// `none`.
10582    None,
10583    /// A URL.
10584    Url(Url),
10585    /// Any other value, passed through unchecked.
10586    Raw(Raw),
10587}
10588
10589impl fmt::Display for MaskBorderSource {
10590    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10591        match self {
10592            Self::None => f.write_str("none"),
10593            Self::Url(v) => v.fmt(f),
10594            Self::Raw(v) => v.fmt(f),
10595        }
10596    }
10597}
10598
10599impl From<Url> for MaskBorderSource {
10600    fn from(v: Url) -> Self {
10601        Self::Url(v)
10602    }
10603}
10604
10605impl From<Raw> for MaskBorderSource {
10606    fn from(v: Raw) -> Self {
10607        Self::Raw(v)
10608    }
10609}
10610
10611/// A value of [`mask-border-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-border-width).
10612#[derive(Debug, Clone, PartialEq)]
10613#[non_exhaustive]
10614pub enum MaskBorderWidth {
10615    /// `auto`.
10616    Auto,
10617    /// A length.
10618    Length(Length),
10619    /// A percentage.
10620    Percentage(Percentage),
10621    /// A number.
10622    Number(f64),
10623    /// Any other value, passed through unchecked.
10624    Raw(Raw),
10625}
10626
10627impl fmt::Display for MaskBorderWidth {
10628    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10629        match self {
10630            Self::Auto => f.write_str("auto"),
10631            Self::Length(v) => v.fmt(f),
10632            Self::Percentage(v) => v.fmt(f),
10633            Self::Number(v) => v.fmt(f),
10634            Self::Raw(v) => v.fmt(f),
10635        }
10636    }
10637}
10638
10639impl From<Length> for MaskBorderWidth {
10640    fn from(v: Length) -> Self {
10641        Self::Length(v)
10642    }
10643}
10644
10645impl From<Percentage> for MaskBorderWidth {
10646    fn from(v: Percentage) -> Self {
10647        Self::Percentage(v)
10648    }
10649}
10650
10651impl From<f64> for MaskBorderWidth {
10652    fn from(v: f64) -> Self {
10653        Self::Number(v)
10654    }
10655}
10656
10657impl From<i32> for MaskBorderWidth {
10658    fn from(v: i32) -> Self {
10659        Self::Number(f64::from(v))
10660    }
10661}
10662
10663impl From<Raw> for MaskBorderWidth {
10664    fn from(v: Raw) -> Self {
10665        Self::Raw(v)
10666    }
10667}
10668
10669/// A value of [`mask-clip`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-clip).
10670#[derive(Debug, Clone, PartialEq)]
10671#[non_exhaustive]
10672pub enum MaskClip {
10673    /// `border-box`.
10674    BorderBox,
10675    /// `content-box`.
10676    ContentBox,
10677    /// `fill-box`.
10678    FillBox,
10679    /// `no-clip`.
10680    NoClip,
10681    /// `padding-box`.
10682    PaddingBox,
10683    /// `stroke-box`.
10684    StrokeBox,
10685    /// `view-box`.
10686    ViewBox,
10687    /// Any other value, passed through unchecked.
10688    Raw(Raw),
10689}
10690
10691impl fmt::Display for MaskClip {
10692    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10693        match self {
10694            Self::BorderBox => f.write_str("border-box"),
10695            Self::ContentBox => f.write_str("content-box"),
10696            Self::FillBox => f.write_str("fill-box"),
10697            Self::NoClip => f.write_str("no-clip"),
10698            Self::PaddingBox => f.write_str("padding-box"),
10699            Self::StrokeBox => f.write_str("stroke-box"),
10700            Self::ViewBox => f.write_str("view-box"),
10701            Self::Raw(v) => v.fmt(f),
10702        }
10703    }
10704}
10705
10706impl From<Raw> for MaskClip {
10707    fn from(v: Raw) -> Self {
10708        Self::Raw(v)
10709    }
10710}
10711
10712/// A value of [`mask-composite`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-composite).
10713#[derive(Debug, Clone, PartialEq)]
10714#[non_exhaustive]
10715pub enum MaskComposite {
10716    /// `add`.
10717    Add,
10718    /// `exclude`.
10719    Exclude,
10720    /// `intersect`.
10721    Intersect,
10722    /// `subtract`.
10723    Subtract,
10724    /// Any other value, passed through unchecked.
10725    Raw(Raw),
10726}
10727
10728impl fmt::Display for MaskComposite {
10729    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10730        match self {
10731            Self::Add => f.write_str("add"),
10732            Self::Exclude => f.write_str("exclude"),
10733            Self::Intersect => f.write_str("intersect"),
10734            Self::Subtract => f.write_str("subtract"),
10735            Self::Raw(v) => v.fmt(f),
10736        }
10737    }
10738}
10739
10740impl From<Raw> for MaskComposite {
10741    fn from(v: Raw) -> Self {
10742        Self::Raw(v)
10743    }
10744}
10745
10746/// A value of [`mask-image`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-image).
10747#[derive(Debug, Clone, PartialEq)]
10748#[non_exhaustive]
10749pub enum MaskImage {
10750    /// `none`.
10751    None,
10752    /// A URL.
10753    Url(Url),
10754    /// Any other value, passed through unchecked.
10755    Raw(Raw),
10756}
10757
10758impl fmt::Display for MaskImage {
10759    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10760        match self {
10761            Self::None => f.write_str("none"),
10762            Self::Url(v) => v.fmt(f),
10763            Self::Raw(v) => v.fmt(f),
10764        }
10765    }
10766}
10767
10768impl From<Url> for MaskImage {
10769    fn from(v: Url) -> Self {
10770        Self::Url(v)
10771    }
10772}
10773
10774impl From<Raw> for MaskImage {
10775    fn from(v: Raw) -> Self {
10776        Self::Raw(v)
10777    }
10778}
10779
10780/// A value of [`mask-mode`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-mode).
10781#[derive(Debug, Clone, PartialEq)]
10782#[non_exhaustive]
10783pub enum MaskMode {
10784    /// `alpha`.
10785    Alpha,
10786    /// `luminance`.
10787    Luminance,
10788    /// `match-source`.
10789    MatchSource,
10790    /// Any other value, passed through unchecked.
10791    Raw(Raw),
10792}
10793
10794impl fmt::Display for MaskMode {
10795    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10796        match self {
10797            Self::Alpha => f.write_str("alpha"),
10798            Self::Luminance => f.write_str("luminance"),
10799            Self::MatchSource => f.write_str("match-source"),
10800            Self::Raw(v) => v.fmt(f),
10801        }
10802    }
10803}
10804
10805impl From<Raw> for MaskMode {
10806    fn from(v: Raw) -> Self {
10807        Self::Raw(v)
10808    }
10809}
10810
10811/// A value of [`mask-origin`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-origin).
10812#[derive(Debug, Clone, PartialEq)]
10813#[non_exhaustive]
10814pub enum MaskOrigin {
10815    /// `border-box`.
10816    BorderBox,
10817    /// `content-box`.
10818    ContentBox,
10819    /// `fill-box`.
10820    FillBox,
10821    /// `padding-box`.
10822    PaddingBox,
10823    /// `stroke-box`.
10824    StrokeBox,
10825    /// `view-box`.
10826    ViewBox,
10827    /// Any other value, passed through unchecked.
10828    Raw(Raw),
10829}
10830
10831impl fmt::Display for MaskOrigin {
10832    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10833        match self {
10834            Self::BorderBox => f.write_str("border-box"),
10835            Self::ContentBox => f.write_str("content-box"),
10836            Self::FillBox => f.write_str("fill-box"),
10837            Self::PaddingBox => f.write_str("padding-box"),
10838            Self::StrokeBox => f.write_str("stroke-box"),
10839            Self::ViewBox => f.write_str("view-box"),
10840            Self::Raw(v) => v.fmt(f),
10841        }
10842    }
10843}
10844
10845impl From<Raw> for MaskOrigin {
10846    fn from(v: Raw) -> Self {
10847        Self::Raw(v)
10848    }
10849}
10850
10851/// A value of [`mask-position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-position).
10852#[derive(Debug, Clone, PartialEq)]
10853#[non_exhaustive]
10854pub enum MaskPosition {
10855    /// `bottom`.
10856    Bottom,
10857    /// `center`.
10858    Center,
10859    /// `left`.
10860    Left,
10861    /// `right`.
10862    Right,
10863    /// `top`.
10864    Top,
10865    /// A length.
10866    Length(Length),
10867    /// A percentage.
10868    Percentage(Percentage),
10869    /// Any other value, passed through unchecked.
10870    Raw(Raw),
10871}
10872
10873impl fmt::Display for MaskPosition {
10874    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10875        match self {
10876            Self::Bottom => f.write_str("bottom"),
10877            Self::Center => f.write_str("center"),
10878            Self::Left => f.write_str("left"),
10879            Self::Right => f.write_str("right"),
10880            Self::Top => f.write_str("top"),
10881            Self::Length(v) => v.fmt(f),
10882            Self::Percentage(v) => v.fmt(f),
10883            Self::Raw(v) => v.fmt(f),
10884        }
10885    }
10886}
10887
10888impl From<Length> for MaskPosition {
10889    fn from(v: Length) -> Self {
10890        Self::Length(v)
10891    }
10892}
10893
10894impl From<Percentage> for MaskPosition {
10895    fn from(v: Percentage) -> Self {
10896        Self::Percentage(v)
10897    }
10898}
10899
10900impl From<Raw> for MaskPosition {
10901    fn from(v: Raw) -> Self {
10902        Self::Raw(v)
10903    }
10904}
10905
10906/// A value of [`mask-repeat`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-repeat).
10907#[derive(Debug, Clone, PartialEq)]
10908#[non_exhaustive]
10909pub enum MaskRepeat {
10910    /// `no-repeat`.
10911    NoRepeat,
10912    /// `repeat`.
10913    Repeat,
10914    /// `repeat-x`.
10915    RepeatX,
10916    /// `repeat-y`.
10917    RepeatY,
10918    /// `round`.
10919    Round,
10920    /// `space`.
10921    Space,
10922    /// Any other value, passed through unchecked.
10923    Raw(Raw),
10924}
10925
10926impl fmt::Display for MaskRepeat {
10927    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10928        match self {
10929            Self::NoRepeat => f.write_str("no-repeat"),
10930            Self::Repeat => f.write_str("repeat"),
10931            Self::RepeatX => f.write_str("repeat-x"),
10932            Self::RepeatY => f.write_str("repeat-y"),
10933            Self::Round => f.write_str("round"),
10934            Self::Space => f.write_str("space"),
10935            Self::Raw(v) => v.fmt(f),
10936        }
10937    }
10938}
10939
10940impl From<Raw> for MaskRepeat {
10941    fn from(v: Raw) -> Self {
10942        Self::Raw(v)
10943    }
10944}
10945
10946/// A value of [`mask-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-size).
10947#[derive(Debug, Clone, PartialEq)]
10948#[non_exhaustive]
10949pub enum MaskSize {
10950    /// `auto`.
10951    Auto,
10952    /// `contain`.
10953    Contain,
10954    /// `cover`.
10955    Cover,
10956    /// A length.
10957    Length(Length),
10958    /// A percentage.
10959    Percentage(Percentage),
10960    /// Any other value, passed through unchecked.
10961    Raw(Raw),
10962}
10963
10964impl fmt::Display for MaskSize {
10965    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
10966        match self {
10967            Self::Auto => f.write_str("auto"),
10968            Self::Contain => f.write_str("contain"),
10969            Self::Cover => f.write_str("cover"),
10970            Self::Length(v) => v.fmt(f),
10971            Self::Percentage(v) => v.fmt(f),
10972            Self::Raw(v) => v.fmt(f),
10973        }
10974    }
10975}
10976
10977impl From<Length> for MaskSize {
10978    fn from(v: Length) -> Self {
10979        Self::Length(v)
10980    }
10981}
10982
10983impl From<Percentage> for MaskSize {
10984    fn from(v: Percentage) -> Self {
10985        Self::Percentage(v)
10986    }
10987}
10988
10989impl From<Raw> for MaskSize {
10990    fn from(v: Raw) -> Self {
10991        Self::Raw(v)
10992    }
10993}
10994
10995/// A value of [`mask-type`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mask-type).
10996#[derive(Debug, Clone, PartialEq)]
10997#[non_exhaustive]
10998pub enum MaskType {
10999    /// `alpha`.
11000    Alpha,
11001    /// `luminance`.
11002    Luminance,
11003}
11004
11005impl fmt::Display for MaskType {
11006    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11007        match self {
11008            Self::Alpha => f.write_str("alpha"),
11009            Self::Luminance => f.write_str("luminance"),
11010        }
11011    }
11012}
11013
11014/// A value of [`math-depth`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/math-depth).
11015#[derive(Debug, Clone, PartialEq)]
11016#[non_exhaustive]
11017pub enum MathDepth {
11018    /// `auto-add`.
11019    AutoAdd,
11020    /// An integer.
11021    Integer(i32),
11022    /// Any other value, passed through unchecked.
11023    Raw(Raw),
11024}
11025
11026impl fmt::Display for MathDepth {
11027    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11028        match self {
11029            Self::AutoAdd => f.write_str("auto-add"),
11030            Self::Integer(v) => v.fmt(f),
11031            Self::Raw(v) => v.fmt(f),
11032        }
11033    }
11034}
11035
11036impl From<i32> for MathDepth {
11037    fn from(v: i32) -> Self {
11038        Self::Integer(v)
11039    }
11040}
11041
11042impl From<Raw> for MathDepth {
11043    fn from(v: Raw) -> Self {
11044        Self::Raw(v)
11045    }
11046}
11047
11048/// A value of [`math-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/math-style).
11049#[derive(Debug, Clone, PartialEq)]
11050#[non_exhaustive]
11051pub enum MathStyle {
11052    /// `compact`.
11053    Compact,
11054    /// `normal`.
11055    Normal,
11056}
11057
11058impl fmt::Display for MathStyle {
11059    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11060        match self {
11061            Self::Compact => f.write_str("compact"),
11062            Self::Normal => f.write_str("normal"),
11063        }
11064    }
11065}
11066
11067/// A value of [`max-block-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/max-block-size).
11068#[derive(Debug, Clone, PartialEq)]
11069#[non_exhaustive]
11070pub enum MaxBlockSize {
11071    /// `fit-content`.
11072    FitContent,
11073    /// `max-content`.
11074    MaxContent,
11075    /// `min-content`.
11076    MinContent,
11077    /// `none`.
11078    None,
11079    /// A length.
11080    Length(Length),
11081    /// A percentage.
11082    Percentage(Percentage),
11083    /// Any other value, passed through unchecked.
11084    Raw(Raw),
11085}
11086
11087impl fmt::Display for MaxBlockSize {
11088    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11089        match self {
11090            Self::FitContent => f.write_str("fit-content"),
11091            Self::MaxContent => f.write_str("max-content"),
11092            Self::MinContent => f.write_str("min-content"),
11093            Self::None => f.write_str("none"),
11094            Self::Length(v) => v.fmt(f),
11095            Self::Percentage(v) => v.fmt(f),
11096            Self::Raw(v) => v.fmt(f),
11097        }
11098    }
11099}
11100
11101impl From<Length> for MaxBlockSize {
11102    fn from(v: Length) -> Self {
11103        Self::Length(v)
11104    }
11105}
11106
11107impl From<Percentage> for MaxBlockSize {
11108    fn from(v: Percentage) -> Self {
11109        Self::Percentage(v)
11110    }
11111}
11112
11113impl From<Raw> for MaxBlockSize {
11114    fn from(v: Raw) -> Self {
11115        Self::Raw(v)
11116    }
11117}
11118
11119/// A value of [`max-height`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/max-height).
11120#[derive(Debug, Clone, PartialEq)]
11121#[non_exhaustive]
11122pub enum MaxHeight {
11123    /// `fit-content`.
11124    FitContent,
11125    /// `max-content`.
11126    MaxContent,
11127    /// `min-content`.
11128    MinContent,
11129    /// `none`.
11130    None,
11131    /// A length.
11132    Length(Length),
11133    /// A percentage.
11134    Percentage(Percentage),
11135    /// Any other value, passed through unchecked.
11136    Raw(Raw),
11137}
11138
11139impl fmt::Display for MaxHeight {
11140    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11141        match self {
11142            Self::FitContent => f.write_str("fit-content"),
11143            Self::MaxContent => f.write_str("max-content"),
11144            Self::MinContent => f.write_str("min-content"),
11145            Self::None => f.write_str("none"),
11146            Self::Length(v) => v.fmt(f),
11147            Self::Percentage(v) => v.fmt(f),
11148            Self::Raw(v) => v.fmt(f),
11149        }
11150    }
11151}
11152
11153impl From<Length> for MaxHeight {
11154    fn from(v: Length) -> Self {
11155        Self::Length(v)
11156    }
11157}
11158
11159impl From<Percentage> for MaxHeight {
11160    fn from(v: Percentage) -> Self {
11161        Self::Percentage(v)
11162    }
11163}
11164
11165impl From<Raw> for MaxHeight {
11166    fn from(v: Raw) -> Self {
11167        Self::Raw(v)
11168    }
11169}
11170
11171/// A value of [`max-inline-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/max-inline-size).
11172#[derive(Debug, Clone, PartialEq)]
11173#[non_exhaustive]
11174pub enum MaxInlineSize {
11175    /// `fit-content`.
11176    FitContent,
11177    /// `max-content`.
11178    MaxContent,
11179    /// `min-content`.
11180    MinContent,
11181    /// `none`.
11182    None,
11183    /// A length.
11184    Length(Length),
11185    /// A percentage.
11186    Percentage(Percentage),
11187    /// Any other value, passed through unchecked.
11188    Raw(Raw),
11189}
11190
11191impl fmt::Display for MaxInlineSize {
11192    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11193        match self {
11194            Self::FitContent => f.write_str("fit-content"),
11195            Self::MaxContent => f.write_str("max-content"),
11196            Self::MinContent => f.write_str("min-content"),
11197            Self::None => f.write_str("none"),
11198            Self::Length(v) => v.fmt(f),
11199            Self::Percentage(v) => v.fmt(f),
11200            Self::Raw(v) => v.fmt(f),
11201        }
11202    }
11203}
11204
11205impl From<Length> for MaxInlineSize {
11206    fn from(v: Length) -> Self {
11207        Self::Length(v)
11208    }
11209}
11210
11211impl From<Percentage> for MaxInlineSize {
11212    fn from(v: Percentage) -> Self {
11213        Self::Percentage(v)
11214    }
11215}
11216
11217impl From<Raw> for MaxInlineSize {
11218    fn from(v: Raw) -> Self {
11219        Self::Raw(v)
11220    }
11221}
11222
11223/// A value of [`max-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/max-width).
11224#[derive(Debug, Clone, PartialEq)]
11225#[non_exhaustive]
11226pub enum MaxWidth {
11227    /// `fit-content`.
11228    FitContent,
11229    /// `max-content`.
11230    MaxContent,
11231    /// `min-content`.
11232    MinContent,
11233    /// `none`.
11234    None,
11235    /// A length.
11236    Length(Length),
11237    /// A percentage.
11238    Percentage(Percentage),
11239    /// Any other value, passed through unchecked.
11240    Raw(Raw),
11241}
11242
11243impl fmt::Display for MaxWidth {
11244    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11245        match self {
11246            Self::FitContent => f.write_str("fit-content"),
11247            Self::MaxContent => f.write_str("max-content"),
11248            Self::MinContent => f.write_str("min-content"),
11249            Self::None => f.write_str("none"),
11250            Self::Length(v) => v.fmt(f),
11251            Self::Percentage(v) => v.fmt(f),
11252            Self::Raw(v) => v.fmt(f),
11253        }
11254    }
11255}
11256
11257impl From<Length> for MaxWidth {
11258    fn from(v: Length) -> Self {
11259        Self::Length(v)
11260    }
11261}
11262
11263impl From<Percentage> for MaxWidth {
11264    fn from(v: Percentage) -> Self {
11265        Self::Percentage(v)
11266    }
11267}
11268
11269impl From<Raw> for MaxWidth {
11270    fn from(v: Raw) -> Self {
11271        Self::Raw(v)
11272    }
11273}
11274
11275/// A value of [`min-block-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/min-block-size).
11276#[derive(Debug, Clone, PartialEq)]
11277#[non_exhaustive]
11278pub enum MinBlockSize {
11279    /// `auto`.
11280    Auto,
11281    /// `fit-content`.
11282    FitContent,
11283    /// `max-content`.
11284    MaxContent,
11285    /// `min-content`.
11286    MinContent,
11287    /// A length.
11288    Length(Length),
11289    /// A percentage.
11290    Percentage(Percentage),
11291    /// Any other value, passed through unchecked.
11292    Raw(Raw),
11293}
11294
11295impl fmt::Display for MinBlockSize {
11296    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11297        match self {
11298            Self::Auto => f.write_str("auto"),
11299            Self::FitContent => f.write_str("fit-content"),
11300            Self::MaxContent => f.write_str("max-content"),
11301            Self::MinContent => f.write_str("min-content"),
11302            Self::Length(v) => v.fmt(f),
11303            Self::Percentage(v) => v.fmt(f),
11304            Self::Raw(v) => v.fmt(f),
11305        }
11306    }
11307}
11308
11309impl From<Length> for MinBlockSize {
11310    fn from(v: Length) -> Self {
11311        Self::Length(v)
11312    }
11313}
11314
11315impl From<Percentage> for MinBlockSize {
11316    fn from(v: Percentage) -> Self {
11317        Self::Percentage(v)
11318    }
11319}
11320
11321impl From<Raw> for MinBlockSize {
11322    fn from(v: Raw) -> Self {
11323        Self::Raw(v)
11324    }
11325}
11326
11327/// A value of [`min-height`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/min-height).
11328#[derive(Debug, Clone, PartialEq)]
11329#[non_exhaustive]
11330pub enum MinHeight {
11331    /// `auto`.
11332    Auto,
11333    /// `fit-content`.
11334    FitContent,
11335    /// `max-content`.
11336    MaxContent,
11337    /// `min-content`.
11338    MinContent,
11339    /// A length.
11340    Length(Length),
11341    /// A percentage.
11342    Percentage(Percentage),
11343    /// Any other value, passed through unchecked.
11344    Raw(Raw),
11345}
11346
11347impl fmt::Display for MinHeight {
11348    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11349        match self {
11350            Self::Auto => f.write_str("auto"),
11351            Self::FitContent => f.write_str("fit-content"),
11352            Self::MaxContent => f.write_str("max-content"),
11353            Self::MinContent => f.write_str("min-content"),
11354            Self::Length(v) => v.fmt(f),
11355            Self::Percentage(v) => v.fmt(f),
11356            Self::Raw(v) => v.fmt(f),
11357        }
11358    }
11359}
11360
11361impl From<Length> for MinHeight {
11362    fn from(v: Length) -> Self {
11363        Self::Length(v)
11364    }
11365}
11366
11367impl From<Percentage> for MinHeight {
11368    fn from(v: Percentage) -> Self {
11369        Self::Percentage(v)
11370    }
11371}
11372
11373impl From<Raw> for MinHeight {
11374    fn from(v: Raw) -> Self {
11375        Self::Raw(v)
11376    }
11377}
11378
11379/// A value of [`min-inline-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/min-inline-size).
11380#[derive(Debug, Clone, PartialEq)]
11381#[non_exhaustive]
11382pub enum MinInlineSize {
11383    /// `auto`.
11384    Auto,
11385    /// `fit-content`.
11386    FitContent,
11387    /// `max-content`.
11388    MaxContent,
11389    /// `min-content`.
11390    MinContent,
11391    /// A length.
11392    Length(Length),
11393    /// A percentage.
11394    Percentage(Percentage),
11395    /// Any other value, passed through unchecked.
11396    Raw(Raw),
11397}
11398
11399impl fmt::Display for MinInlineSize {
11400    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11401        match self {
11402            Self::Auto => f.write_str("auto"),
11403            Self::FitContent => f.write_str("fit-content"),
11404            Self::MaxContent => f.write_str("max-content"),
11405            Self::MinContent => f.write_str("min-content"),
11406            Self::Length(v) => v.fmt(f),
11407            Self::Percentage(v) => v.fmt(f),
11408            Self::Raw(v) => v.fmt(f),
11409        }
11410    }
11411}
11412
11413impl From<Length> for MinInlineSize {
11414    fn from(v: Length) -> Self {
11415        Self::Length(v)
11416    }
11417}
11418
11419impl From<Percentage> for MinInlineSize {
11420    fn from(v: Percentage) -> Self {
11421        Self::Percentage(v)
11422    }
11423}
11424
11425impl From<Raw> for MinInlineSize {
11426    fn from(v: Raw) -> Self {
11427        Self::Raw(v)
11428    }
11429}
11430
11431/// A value of [`min-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/min-width).
11432#[derive(Debug, Clone, PartialEq)]
11433#[non_exhaustive]
11434pub enum MinWidth {
11435    /// `auto`.
11436    Auto,
11437    /// `fit-content`.
11438    FitContent,
11439    /// `max-content`.
11440    MaxContent,
11441    /// `min-content`.
11442    MinContent,
11443    /// A length.
11444    Length(Length),
11445    /// A percentage.
11446    Percentage(Percentage),
11447    /// Any other value, passed through unchecked.
11448    Raw(Raw),
11449}
11450
11451impl fmt::Display for MinWidth {
11452    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11453        match self {
11454            Self::Auto => f.write_str("auto"),
11455            Self::FitContent => f.write_str("fit-content"),
11456            Self::MaxContent => f.write_str("max-content"),
11457            Self::MinContent => f.write_str("min-content"),
11458            Self::Length(v) => v.fmt(f),
11459            Self::Percentage(v) => v.fmt(f),
11460            Self::Raw(v) => v.fmt(f),
11461        }
11462    }
11463}
11464
11465impl From<Length> for MinWidth {
11466    fn from(v: Length) -> Self {
11467        Self::Length(v)
11468    }
11469}
11470
11471impl From<Percentage> for MinWidth {
11472    fn from(v: Percentage) -> Self {
11473        Self::Percentage(v)
11474    }
11475}
11476
11477impl From<Raw> for MinWidth {
11478    fn from(v: Raw) -> Self {
11479        Self::Raw(v)
11480    }
11481}
11482
11483/// A value of [`mix-blend-mode`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/mix-blend-mode).
11484#[derive(Debug, Clone, PartialEq)]
11485#[non_exhaustive]
11486pub enum MixBlendMode {
11487    /// `color`.
11488    Color,
11489    /// `color-burn`.
11490    ColorBurn,
11491    /// `color-dodge`.
11492    ColorDodge,
11493    /// `darken`.
11494    Darken,
11495    /// `difference`.
11496    Difference,
11497    /// `exclusion`.
11498    Exclusion,
11499    /// `hard-light`.
11500    HardLight,
11501    /// `hue`.
11502    Hue,
11503    /// `lighten`.
11504    Lighten,
11505    /// `luminosity`.
11506    Luminosity,
11507    /// `multiply`.
11508    Multiply,
11509    /// `normal`.
11510    Normal,
11511    /// `overlay`.
11512    Overlay,
11513    /// `plus-darker`.
11514    PlusDarker,
11515    /// `plus-lighter`.
11516    PlusLighter,
11517    /// `saturation`.
11518    Saturation,
11519    /// `screen`.
11520    Screen,
11521    /// `soft-light`.
11522    SoftLight,
11523}
11524
11525impl fmt::Display for MixBlendMode {
11526    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11527        match self {
11528            Self::Color => f.write_str("color"),
11529            Self::ColorBurn => f.write_str("color-burn"),
11530            Self::ColorDodge => f.write_str("color-dodge"),
11531            Self::Darken => f.write_str("darken"),
11532            Self::Difference => f.write_str("difference"),
11533            Self::Exclusion => f.write_str("exclusion"),
11534            Self::HardLight => f.write_str("hard-light"),
11535            Self::Hue => f.write_str("hue"),
11536            Self::Lighten => f.write_str("lighten"),
11537            Self::Luminosity => f.write_str("luminosity"),
11538            Self::Multiply => f.write_str("multiply"),
11539            Self::Normal => f.write_str("normal"),
11540            Self::Overlay => f.write_str("overlay"),
11541            Self::PlusDarker => f.write_str("plus-darker"),
11542            Self::PlusLighter => f.write_str("plus-lighter"),
11543            Self::Saturation => f.write_str("saturation"),
11544            Self::Screen => f.write_str("screen"),
11545            Self::SoftLight => f.write_str("soft-light"),
11546        }
11547    }
11548}
11549
11550/// A value of [`object-fit`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/object-fit).
11551#[derive(Debug, Clone, PartialEq)]
11552#[non_exhaustive]
11553pub enum ObjectFit {
11554    /// `contain`.
11555    Contain,
11556    /// `cover`.
11557    Cover,
11558    /// `fill`.
11559    Fill,
11560    /// `none`.
11561    None,
11562    /// `scale-down`.
11563    ScaleDown,
11564}
11565
11566impl fmt::Display for ObjectFit {
11567    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11568        match self {
11569            Self::Contain => f.write_str("contain"),
11570            Self::Cover => f.write_str("cover"),
11571            Self::Fill => f.write_str("fill"),
11572            Self::None => f.write_str("none"),
11573            Self::ScaleDown => f.write_str("scale-down"),
11574        }
11575    }
11576}
11577
11578/// A value of [`object-position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/object-position).
11579#[derive(Debug, Clone, PartialEq)]
11580#[non_exhaustive]
11581pub enum ObjectPosition {
11582    /// `bottom`.
11583    Bottom,
11584    /// `center`.
11585    Center,
11586    /// `left`.
11587    Left,
11588    /// `right`.
11589    Right,
11590    /// `top`.
11591    Top,
11592    /// A length.
11593    Length(Length),
11594    /// A percentage.
11595    Percentage(Percentage),
11596    /// Any other value, passed through unchecked.
11597    Raw(Raw),
11598}
11599
11600impl fmt::Display for ObjectPosition {
11601    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11602        match self {
11603            Self::Bottom => f.write_str("bottom"),
11604            Self::Center => f.write_str("center"),
11605            Self::Left => f.write_str("left"),
11606            Self::Right => f.write_str("right"),
11607            Self::Top => f.write_str("top"),
11608            Self::Length(v) => v.fmt(f),
11609            Self::Percentage(v) => v.fmt(f),
11610            Self::Raw(v) => v.fmt(f),
11611        }
11612    }
11613}
11614
11615impl From<Length> for ObjectPosition {
11616    fn from(v: Length) -> Self {
11617        Self::Length(v)
11618    }
11619}
11620
11621impl From<Percentage> for ObjectPosition {
11622    fn from(v: Percentage) -> Self {
11623        Self::Percentage(v)
11624    }
11625}
11626
11627impl From<Raw> for ObjectPosition {
11628    fn from(v: Raw) -> Self {
11629        Self::Raw(v)
11630    }
11631}
11632
11633/// A value of [`offset`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/offset).
11634#[derive(Debug, Clone, PartialEq)]
11635#[non_exhaustive]
11636pub enum Offset {
11637    /// `auto`.
11638    Auto,
11639    /// `border-box`.
11640    BorderBox,
11641    /// `bottom`.
11642    Bottom,
11643    /// `center`.
11644    Center,
11645    /// `content-box`.
11646    ContentBox,
11647    /// `fill-box`.
11648    FillBox,
11649    /// `left`.
11650    Left,
11651    /// `none`.
11652    None,
11653    /// `normal`.
11654    Normal,
11655    /// `padding-box`.
11656    PaddingBox,
11657    /// `right`.
11658    Right,
11659    /// `stroke-box`.
11660    StrokeBox,
11661    /// `top`.
11662    Top,
11663    /// `view-box`.
11664    ViewBox,
11665    /// A length.
11666    Length(Length),
11667    /// A percentage.
11668    Percentage(Percentage),
11669    /// Any other value, passed through unchecked.
11670    Raw(Raw),
11671}
11672
11673impl fmt::Display for Offset {
11674    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11675        match self {
11676            Self::Auto => f.write_str("auto"),
11677            Self::BorderBox => f.write_str("border-box"),
11678            Self::Bottom => f.write_str("bottom"),
11679            Self::Center => f.write_str("center"),
11680            Self::ContentBox => f.write_str("content-box"),
11681            Self::FillBox => f.write_str("fill-box"),
11682            Self::Left => f.write_str("left"),
11683            Self::None => f.write_str("none"),
11684            Self::Normal => f.write_str("normal"),
11685            Self::PaddingBox => f.write_str("padding-box"),
11686            Self::Right => f.write_str("right"),
11687            Self::StrokeBox => f.write_str("stroke-box"),
11688            Self::Top => f.write_str("top"),
11689            Self::ViewBox => f.write_str("view-box"),
11690            Self::Length(v) => v.fmt(f),
11691            Self::Percentage(v) => v.fmt(f),
11692            Self::Raw(v) => v.fmt(f),
11693        }
11694    }
11695}
11696
11697impl From<Length> for Offset {
11698    fn from(v: Length) -> Self {
11699        Self::Length(v)
11700    }
11701}
11702
11703impl From<Percentage> for Offset {
11704    fn from(v: Percentage) -> Self {
11705        Self::Percentage(v)
11706    }
11707}
11708
11709impl From<Raw> for Offset {
11710    fn from(v: Raw) -> Self {
11711        Self::Raw(v)
11712    }
11713}
11714
11715/// A value of [`offset-anchor`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/offset-anchor).
11716#[derive(Debug, Clone, PartialEq)]
11717#[non_exhaustive]
11718pub enum OffsetAnchor {
11719    /// `auto`.
11720    Auto,
11721    /// `bottom`.
11722    Bottom,
11723    /// `center`.
11724    Center,
11725    /// `left`.
11726    Left,
11727    /// `right`.
11728    Right,
11729    /// `top`.
11730    Top,
11731    /// A length.
11732    Length(Length),
11733    /// A percentage.
11734    Percentage(Percentage),
11735    /// Any other value, passed through unchecked.
11736    Raw(Raw),
11737}
11738
11739impl fmt::Display for OffsetAnchor {
11740    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11741        match self {
11742            Self::Auto => f.write_str("auto"),
11743            Self::Bottom => f.write_str("bottom"),
11744            Self::Center => f.write_str("center"),
11745            Self::Left => f.write_str("left"),
11746            Self::Right => f.write_str("right"),
11747            Self::Top => f.write_str("top"),
11748            Self::Length(v) => v.fmt(f),
11749            Self::Percentage(v) => v.fmt(f),
11750            Self::Raw(v) => v.fmt(f),
11751        }
11752    }
11753}
11754
11755impl From<Length> for OffsetAnchor {
11756    fn from(v: Length) -> Self {
11757        Self::Length(v)
11758    }
11759}
11760
11761impl From<Percentage> for OffsetAnchor {
11762    fn from(v: Percentage) -> Self {
11763        Self::Percentage(v)
11764    }
11765}
11766
11767impl From<Raw> for OffsetAnchor {
11768    fn from(v: Raw) -> Self {
11769        Self::Raw(v)
11770    }
11771}
11772
11773/// A value of [`offset-distance`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/offset-distance).
11774#[derive(Debug, Clone, PartialEq)]
11775#[non_exhaustive]
11776pub enum OffsetDistance {
11777    /// A length.
11778    Length(Length),
11779    /// A percentage.
11780    Percentage(Percentage),
11781}
11782
11783impl fmt::Display for OffsetDistance {
11784    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11785        match self {
11786            Self::Length(v) => v.fmt(f),
11787            Self::Percentage(v) => v.fmt(f),
11788        }
11789    }
11790}
11791
11792impl From<Length> for OffsetDistance {
11793    fn from(v: Length) -> Self {
11794        Self::Length(v)
11795    }
11796}
11797
11798impl From<Percentage> for OffsetDistance {
11799    fn from(v: Percentage) -> Self {
11800        Self::Percentage(v)
11801    }
11802}
11803
11804/// A value of [`offset-path`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/offset-path).
11805#[derive(Debug, Clone, PartialEq)]
11806#[non_exhaustive]
11807pub enum OffsetPath {
11808    /// `border-box`.
11809    BorderBox,
11810    /// `content-box`.
11811    ContentBox,
11812    /// `fill-box`.
11813    FillBox,
11814    /// `none`.
11815    None,
11816    /// `padding-box`.
11817    PaddingBox,
11818    /// `stroke-box`.
11819    StrokeBox,
11820    /// `view-box`.
11821    ViewBox,
11822    /// Any other value, passed through unchecked.
11823    Raw(Raw),
11824}
11825
11826impl fmt::Display for OffsetPath {
11827    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11828        match self {
11829            Self::BorderBox => f.write_str("border-box"),
11830            Self::ContentBox => f.write_str("content-box"),
11831            Self::FillBox => f.write_str("fill-box"),
11832            Self::None => f.write_str("none"),
11833            Self::PaddingBox => f.write_str("padding-box"),
11834            Self::StrokeBox => f.write_str("stroke-box"),
11835            Self::ViewBox => f.write_str("view-box"),
11836            Self::Raw(v) => v.fmt(f),
11837        }
11838    }
11839}
11840
11841impl From<Raw> for OffsetPath {
11842    fn from(v: Raw) -> Self {
11843        Self::Raw(v)
11844    }
11845}
11846
11847/// A value of [`offset-position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/offset-position).
11848#[derive(Debug, Clone, PartialEq)]
11849#[non_exhaustive]
11850pub enum OffsetPosition {
11851    /// `auto`.
11852    Auto,
11853    /// `bottom`.
11854    Bottom,
11855    /// `center`.
11856    Center,
11857    /// `left`.
11858    Left,
11859    /// `normal`.
11860    Normal,
11861    /// `right`.
11862    Right,
11863    /// `top`.
11864    Top,
11865    /// A length.
11866    Length(Length),
11867    /// A percentage.
11868    Percentage(Percentage),
11869    /// Any other value, passed through unchecked.
11870    Raw(Raw),
11871}
11872
11873impl fmt::Display for OffsetPosition {
11874    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11875        match self {
11876            Self::Auto => f.write_str("auto"),
11877            Self::Bottom => f.write_str("bottom"),
11878            Self::Center => f.write_str("center"),
11879            Self::Left => f.write_str("left"),
11880            Self::Normal => f.write_str("normal"),
11881            Self::Right => f.write_str("right"),
11882            Self::Top => f.write_str("top"),
11883            Self::Length(v) => v.fmt(f),
11884            Self::Percentage(v) => v.fmt(f),
11885            Self::Raw(v) => v.fmt(f),
11886        }
11887    }
11888}
11889
11890impl From<Length> for OffsetPosition {
11891    fn from(v: Length) -> Self {
11892        Self::Length(v)
11893    }
11894}
11895
11896impl From<Percentage> for OffsetPosition {
11897    fn from(v: Percentage) -> Self {
11898        Self::Percentage(v)
11899    }
11900}
11901
11902impl From<Raw> for OffsetPosition {
11903    fn from(v: Raw) -> Self {
11904        Self::Raw(v)
11905    }
11906}
11907
11908/// A value of [`offset-rotate`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/offset-rotate).
11909#[derive(Debug, Clone, PartialEq)]
11910#[non_exhaustive]
11911pub enum OffsetRotate {
11912    /// `auto`.
11913    Auto,
11914    /// `reverse`.
11915    Reverse,
11916    /// An angle.
11917    Angle(Angle),
11918    /// Any other value, passed through unchecked.
11919    Raw(Raw),
11920}
11921
11922impl fmt::Display for OffsetRotate {
11923    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11924        match self {
11925            Self::Auto => f.write_str("auto"),
11926            Self::Reverse => f.write_str("reverse"),
11927            Self::Angle(v) => v.fmt(f),
11928            Self::Raw(v) => v.fmt(f),
11929        }
11930    }
11931}
11932
11933impl From<Angle> for OffsetRotate {
11934    fn from(v: Angle) -> Self {
11935        Self::Angle(v)
11936    }
11937}
11938
11939impl From<Raw> for OffsetRotate {
11940    fn from(v: Raw) -> Self {
11941        Self::Raw(v)
11942    }
11943}
11944
11945/// A value of [`opacity`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/opacity).
11946#[derive(Debug, Clone, PartialEq)]
11947#[non_exhaustive]
11948pub enum Opacity {
11949    /// A percentage.
11950    Percentage(Percentage),
11951    /// A number.
11952    Number(f64),
11953}
11954
11955impl fmt::Display for Opacity {
11956    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11957        match self {
11958            Self::Percentage(v) => v.fmt(f),
11959            Self::Number(v) => v.fmt(f),
11960        }
11961    }
11962}
11963
11964impl From<Percentage> for Opacity {
11965    fn from(v: Percentage) -> Self {
11966        Self::Percentage(v)
11967    }
11968}
11969
11970impl From<f64> for Opacity {
11971    fn from(v: f64) -> Self {
11972        Self::Number(v)
11973    }
11974}
11975
11976impl From<i32> for Opacity {
11977    fn from(v: i32) -> Self {
11978        Self::Number(f64::from(v))
11979    }
11980}
11981
11982/// A value of [`outline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/outline).
11983#[derive(Debug, Clone, PartialEq)]
11984#[non_exhaustive]
11985pub enum Outline {
11986    /// `auto`.
11987    Auto,
11988    /// `dashed`.
11989    Dashed,
11990    /// `dotted`.
11991    Dotted,
11992    /// `double`.
11993    Double,
11994    /// `groove`.
11995    Groove,
11996    /// `inset`.
11997    Inset,
11998    /// `medium`.
11999    Medium,
12000    /// `none`.
12001    None,
12002    /// `outset`.
12003    Outset,
12004    /// `ridge`.
12005    Ridge,
12006    /// `solid`.
12007    Solid,
12008    /// `thick`.
12009    Thick,
12010    /// `thin`.
12011    Thin,
12012    /// A length.
12013    Length(Length),
12014    /// A color.
12015    Color(Color),
12016    /// Any other value, passed through unchecked.
12017    Raw(Raw),
12018}
12019
12020impl fmt::Display for Outline {
12021    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12022        match self {
12023            Self::Auto => f.write_str("auto"),
12024            Self::Dashed => f.write_str("dashed"),
12025            Self::Dotted => f.write_str("dotted"),
12026            Self::Double => f.write_str("double"),
12027            Self::Groove => f.write_str("groove"),
12028            Self::Inset => f.write_str("inset"),
12029            Self::Medium => f.write_str("medium"),
12030            Self::None => f.write_str("none"),
12031            Self::Outset => f.write_str("outset"),
12032            Self::Ridge => f.write_str("ridge"),
12033            Self::Solid => f.write_str("solid"),
12034            Self::Thick => f.write_str("thick"),
12035            Self::Thin => f.write_str("thin"),
12036            Self::Length(v) => v.fmt(f),
12037            Self::Color(v) => v.fmt(f),
12038            Self::Raw(v) => v.fmt(f),
12039        }
12040    }
12041}
12042
12043impl From<Length> for Outline {
12044    fn from(v: Length) -> Self {
12045        Self::Length(v)
12046    }
12047}
12048
12049impl From<Color> for Outline {
12050    fn from(v: Color) -> Self {
12051        Self::Color(v)
12052    }
12053}
12054
12055impl From<Raw> for Outline {
12056    fn from(v: Raw) -> Self {
12057        Self::Raw(v)
12058    }
12059}
12060
12061/// A value of [`outline-color`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/outline-color).
12062#[derive(Debug, Clone, PartialEq)]
12063#[non_exhaustive]
12064pub enum OutlineColor {
12065    /// `auto`.
12066    Auto,
12067    /// A color.
12068    Color(Color),
12069}
12070
12071impl fmt::Display for OutlineColor {
12072    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12073        match self {
12074            Self::Auto => f.write_str("auto"),
12075            Self::Color(v) => v.fmt(f),
12076        }
12077    }
12078}
12079
12080impl From<Color> for OutlineColor {
12081    fn from(v: Color) -> Self {
12082        Self::Color(v)
12083    }
12084}
12085
12086/// A value of [`outline-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/outline-style).
12087#[derive(Debug, Clone, PartialEq)]
12088#[non_exhaustive]
12089pub enum OutlineStyle {
12090    /// `auto`.
12091    Auto,
12092    /// `dashed`.
12093    Dashed,
12094    /// `dotted`.
12095    Dotted,
12096    /// `double`.
12097    Double,
12098    /// `groove`.
12099    Groove,
12100    /// `inset`.
12101    Inset,
12102    /// `none`.
12103    None,
12104    /// `outset`.
12105    Outset,
12106    /// `ridge`.
12107    Ridge,
12108    /// `solid`.
12109    Solid,
12110}
12111
12112impl fmt::Display for OutlineStyle {
12113    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12114        match self {
12115            Self::Auto => f.write_str("auto"),
12116            Self::Dashed => f.write_str("dashed"),
12117            Self::Dotted => f.write_str("dotted"),
12118            Self::Double => f.write_str("double"),
12119            Self::Groove => f.write_str("groove"),
12120            Self::Inset => f.write_str("inset"),
12121            Self::None => f.write_str("none"),
12122            Self::Outset => f.write_str("outset"),
12123            Self::Ridge => f.write_str("ridge"),
12124            Self::Solid => f.write_str("solid"),
12125        }
12126    }
12127}
12128
12129/// A value of [`outline-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/outline-width).
12130#[derive(Debug, Clone, PartialEq)]
12131#[non_exhaustive]
12132pub enum OutlineWidth {
12133    /// `medium`.
12134    Medium,
12135    /// `thick`.
12136    Thick,
12137    /// `thin`.
12138    Thin,
12139    /// A length.
12140    Length(Length),
12141}
12142
12143impl fmt::Display for OutlineWidth {
12144    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12145        match self {
12146            Self::Medium => f.write_str("medium"),
12147            Self::Thick => f.write_str("thick"),
12148            Self::Thin => f.write_str("thin"),
12149            Self::Length(v) => v.fmt(f),
12150        }
12151    }
12152}
12153
12154impl From<Length> for OutlineWidth {
12155    fn from(v: Length) -> Self {
12156        Self::Length(v)
12157    }
12158}
12159
12160/// A value of [`overflow`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overflow).
12161#[derive(Debug, Clone, PartialEq)]
12162#[non_exhaustive]
12163pub enum Overflow {
12164    /// `auto`.
12165    Auto,
12166    /// `clip`.
12167    Clip,
12168    /// `hidden`.
12169    Hidden,
12170    /// `scroll`.
12171    Scroll,
12172    /// `visible`.
12173    Visible,
12174    /// Any other value, passed through unchecked.
12175    Raw(Raw),
12176}
12177
12178impl fmt::Display for Overflow {
12179    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12180        match self {
12181            Self::Auto => f.write_str("auto"),
12182            Self::Clip => f.write_str("clip"),
12183            Self::Hidden => f.write_str("hidden"),
12184            Self::Scroll => f.write_str("scroll"),
12185            Self::Visible => f.write_str("visible"),
12186            Self::Raw(v) => v.fmt(f),
12187        }
12188    }
12189}
12190
12191impl From<Raw> for Overflow {
12192    fn from(v: Raw) -> Self {
12193        Self::Raw(v)
12194    }
12195}
12196
12197/// A value of [`overflow-anchor`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overflow-anchor).
12198#[derive(Debug, Clone, PartialEq)]
12199#[non_exhaustive]
12200pub enum OverflowAnchor {
12201    /// `auto`.
12202    Auto,
12203    /// `none`.
12204    None,
12205}
12206
12207impl fmt::Display for OverflowAnchor {
12208    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12209        match self {
12210            Self::Auto => f.write_str("auto"),
12211            Self::None => f.write_str("none"),
12212        }
12213    }
12214}
12215
12216/// A value of [`overflow-block`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overflow-block).
12217#[derive(Debug, Clone, PartialEq)]
12218#[non_exhaustive]
12219pub enum OverflowBlock {
12220    /// `auto`.
12221    Auto,
12222    /// `clip`.
12223    Clip,
12224    /// `hidden`.
12225    Hidden,
12226    /// `scroll`.
12227    Scroll,
12228    /// `visible`.
12229    Visible,
12230}
12231
12232impl fmt::Display for OverflowBlock {
12233    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12234        match self {
12235            Self::Auto => f.write_str("auto"),
12236            Self::Clip => f.write_str("clip"),
12237            Self::Hidden => f.write_str("hidden"),
12238            Self::Scroll => f.write_str("scroll"),
12239            Self::Visible => f.write_str("visible"),
12240        }
12241    }
12242}
12243
12244/// A value of [`overflow-clip-margin`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overflow-clip-margin).
12245#[derive(Debug, Clone, PartialEq)]
12246#[non_exhaustive]
12247pub enum OverflowClipMargin {
12248    /// `border-box`.
12249    BorderBox,
12250    /// `content-box`.
12251    ContentBox,
12252    /// `padding-box`.
12253    PaddingBox,
12254    /// A length.
12255    Length(Length),
12256    /// Any other value, passed through unchecked.
12257    Raw(Raw),
12258}
12259
12260impl fmt::Display for OverflowClipMargin {
12261    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12262        match self {
12263            Self::BorderBox => f.write_str("border-box"),
12264            Self::ContentBox => f.write_str("content-box"),
12265            Self::PaddingBox => f.write_str("padding-box"),
12266            Self::Length(v) => v.fmt(f),
12267            Self::Raw(v) => v.fmt(f),
12268        }
12269    }
12270}
12271
12272impl From<Length> for OverflowClipMargin {
12273    fn from(v: Length) -> Self {
12274        Self::Length(v)
12275    }
12276}
12277
12278impl From<Raw> for OverflowClipMargin {
12279    fn from(v: Raw) -> Self {
12280        Self::Raw(v)
12281    }
12282}
12283
12284/// A value of [`overflow-inline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overflow-inline).
12285#[derive(Debug, Clone, PartialEq)]
12286#[non_exhaustive]
12287pub enum OverflowInline {
12288    /// `auto`.
12289    Auto,
12290    /// `clip`.
12291    Clip,
12292    /// `hidden`.
12293    Hidden,
12294    /// `scroll`.
12295    Scroll,
12296    /// `visible`.
12297    Visible,
12298}
12299
12300impl fmt::Display for OverflowInline {
12301    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12302        match self {
12303            Self::Auto => f.write_str("auto"),
12304            Self::Clip => f.write_str("clip"),
12305            Self::Hidden => f.write_str("hidden"),
12306            Self::Scroll => f.write_str("scroll"),
12307            Self::Visible => f.write_str("visible"),
12308        }
12309    }
12310}
12311
12312/// A value of [`overflow-wrap`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overflow-wrap).
12313#[derive(Debug, Clone, PartialEq)]
12314#[non_exhaustive]
12315pub enum OverflowWrap {
12316    /// `anywhere`.
12317    Anywhere,
12318    /// `break-word`.
12319    BreakWord,
12320    /// `normal`.
12321    Normal,
12322}
12323
12324impl fmt::Display for OverflowWrap {
12325    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12326        match self {
12327            Self::Anywhere => f.write_str("anywhere"),
12328            Self::BreakWord => f.write_str("break-word"),
12329            Self::Normal => f.write_str("normal"),
12330        }
12331    }
12332}
12333
12334/// A value of [`overflow-x`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overflow-x).
12335#[derive(Debug, Clone, PartialEq)]
12336#[non_exhaustive]
12337pub enum OverflowX {
12338    /// `auto`.
12339    Auto,
12340    /// `clip`.
12341    Clip,
12342    /// `hidden`.
12343    Hidden,
12344    /// `scroll`.
12345    Scroll,
12346    /// `visible`.
12347    Visible,
12348}
12349
12350impl fmt::Display for OverflowX {
12351    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12352        match self {
12353            Self::Auto => f.write_str("auto"),
12354            Self::Clip => f.write_str("clip"),
12355            Self::Hidden => f.write_str("hidden"),
12356            Self::Scroll => f.write_str("scroll"),
12357            Self::Visible => f.write_str("visible"),
12358        }
12359    }
12360}
12361
12362/// A value of [`overflow-y`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overflow-y).
12363#[derive(Debug, Clone, PartialEq)]
12364#[non_exhaustive]
12365pub enum OverflowY {
12366    /// `auto`.
12367    Auto,
12368    /// `clip`.
12369    Clip,
12370    /// `hidden`.
12371    Hidden,
12372    /// `scroll`.
12373    Scroll,
12374    /// `visible`.
12375    Visible,
12376}
12377
12378impl fmt::Display for OverflowY {
12379    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12380        match self {
12381            Self::Auto => f.write_str("auto"),
12382            Self::Clip => f.write_str("clip"),
12383            Self::Hidden => f.write_str("hidden"),
12384            Self::Scroll => f.write_str("scroll"),
12385            Self::Visible => f.write_str("visible"),
12386        }
12387    }
12388}
12389
12390/// A value of [`overscroll-behavior`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overscroll-behavior).
12391#[derive(Debug, Clone, PartialEq)]
12392#[non_exhaustive]
12393pub enum OverscrollBehavior {
12394    /// `auto`.
12395    Auto,
12396    /// `contain`.
12397    Contain,
12398    /// `none`.
12399    None,
12400    /// Any other value, passed through unchecked.
12401    Raw(Raw),
12402}
12403
12404impl fmt::Display for OverscrollBehavior {
12405    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12406        match self {
12407            Self::Auto => f.write_str("auto"),
12408            Self::Contain => f.write_str("contain"),
12409            Self::None => f.write_str("none"),
12410            Self::Raw(v) => v.fmt(f),
12411        }
12412    }
12413}
12414
12415impl From<Raw> for OverscrollBehavior {
12416    fn from(v: Raw) -> Self {
12417        Self::Raw(v)
12418    }
12419}
12420
12421/// A value of [`overscroll-behavior-block`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overscroll-behavior-block).
12422#[derive(Debug, Clone, PartialEq)]
12423#[non_exhaustive]
12424pub enum OverscrollBehaviorBlock {
12425    /// `auto`.
12426    Auto,
12427    /// `contain`.
12428    Contain,
12429    /// `none`.
12430    None,
12431}
12432
12433impl fmt::Display for OverscrollBehaviorBlock {
12434    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12435        match self {
12436            Self::Auto => f.write_str("auto"),
12437            Self::Contain => f.write_str("contain"),
12438            Self::None => f.write_str("none"),
12439        }
12440    }
12441}
12442
12443/// A value of [`overscroll-behavior-inline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overscroll-behavior-inline).
12444#[derive(Debug, Clone, PartialEq)]
12445#[non_exhaustive]
12446pub enum OverscrollBehaviorInline {
12447    /// `auto`.
12448    Auto,
12449    /// `contain`.
12450    Contain,
12451    /// `none`.
12452    None,
12453}
12454
12455impl fmt::Display for OverscrollBehaviorInline {
12456    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12457        match self {
12458            Self::Auto => f.write_str("auto"),
12459            Self::Contain => f.write_str("contain"),
12460            Self::None => f.write_str("none"),
12461        }
12462    }
12463}
12464
12465/// A value of [`overscroll-behavior-x`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overscroll-behavior-x).
12466#[derive(Debug, Clone, PartialEq)]
12467#[non_exhaustive]
12468pub enum OverscrollBehaviorX {
12469    /// `auto`.
12470    Auto,
12471    /// `contain`.
12472    Contain,
12473    /// `none`.
12474    None,
12475}
12476
12477impl fmt::Display for OverscrollBehaviorX {
12478    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12479        match self {
12480            Self::Auto => f.write_str("auto"),
12481            Self::Contain => f.write_str("contain"),
12482            Self::None => f.write_str("none"),
12483        }
12484    }
12485}
12486
12487/// A value of [`overscroll-behavior-y`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overscroll-behavior-y).
12488#[derive(Debug, Clone, PartialEq)]
12489#[non_exhaustive]
12490pub enum OverscrollBehaviorY {
12491    /// `auto`.
12492    Auto,
12493    /// `contain`.
12494    Contain,
12495    /// `none`.
12496    None,
12497}
12498
12499impl fmt::Display for OverscrollBehaviorY {
12500    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12501        match self {
12502            Self::Auto => f.write_str("auto"),
12503            Self::Contain => f.write_str("contain"),
12504            Self::None => f.write_str("none"),
12505        }
12506    }
12507}
12508
12509/// A value of [`padding`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding).
12510#[derive(Debug, Clone, PartialEq)]
12511#[non_exhaustive]
12512pub enum Padding {
12513    /// A length.
12514    Length(Length),
12515    /// A percentage.
12516    Percentage(Percentage),
12517    /// Any other value, passed through unchecked.
12518    Raw(Raw),
12519}
12520
12521impl fmt::Display for Padding {
12522    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12523        match self {
12524            Self::Length(v) => v.fmt(f),
12525            Self::Percentage(v) => v.fmt(f),
12526            Self::Raw(v) => v.fmt(f),
12527        }
12528    }
12529}
12530
12531impl From<Length> for Padding {
12532    fn from(v: Length) -> Self {
12533        Self::Length(v)
12534    }
12535}
12536
12537impl From<Percentage> for Padding {
12538    fn from(v: Percentage) -> Self {
12539        Self::Percentage(v)
12540    }
12541}
12542
12543impl From<Raw> for Padding {
12544    fn from(v: Raw) -> Self {
12545        Self::Raw(v)
12546    }
12547}
12548
12549/// A value of [`padding-block`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-block).
12550#[derive(Debug, Clone, PartialEq)]
12551#[non_exhaustive]
12552pub enum PaddingBlock {
12553    /// A length.
12554    Length(Length),
12555    /// A percentage.
12556    Percentage(Percentage),
12557    /// Any other value, passed through unchecked.
12558    Raw(Raw),
12559}
12560
12561impl fmt::Display for PaddingBlock {
12562    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12563        match self {
12564            Self::Length(v) => v.fmt(f),
12565            Self::Percentage(v) => v.fmt(f),
12566            Self::Raw(v) => v.fmt(f),
12567        }
12568    }
12569}
12570
12571impl From<Length> for PaddingBlock {
12572    fn from(v: Length) -> Self {
12573        Self::Length(v)
12574    }
12575}
12576
12577impl From<Percentage> for PaddingBlock {
12578    fn from(v: Percentage) -> Self {
12579        Self::Percentage(v)
12580    }
12581}
12582
12583impl From<Raw> for PaddingBlock {
12584    fn from(v: Raw) -> Self {
12585        Self::Raw(v)
12586    }
12587}
12588
12589/// A value of [`padding-block-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-block-end).
12590#[derive(Debug, Clone, PartialEq)]
12591#[non_exhaustive]
12592pub enum PaddingBlockEnd {
12593    /// A length.
12594    Length(Length),
12595    /// A percentage.
12596    Percentage(Percentage),
12597}
12598
12599impl fmt::Display for PaddingBlockEnd {
12600    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12601        match self {
12602            Self::Length(v) => v.fmt(f),
12603            Self::Percentage(v) => v.fmt(f),
12604        }
12605    }
12606}
12607
12608impl From<Length> for PaddingBlockEnd {
12609    fn from(v: Length) -> Self {
12610        Self::Length(v)
12611    }
12612}
12613
12614impl From<Percentage> for PaddingBlockEnd {
12615    fn from(v: Percentage) -> Self {
12616        Self::Percentage(v)
12617    }
12618}
12619
12620/// A value of [`padding-block-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-block-start).
12621#[derive(Debug, Clone, PartialEq)]
12622#[non_exhaustive]
12623pub enum PaddingBlockStart {
12624    /// A length.
12625    Length(Length),
12626    /// A percentage.
12627    Percentage(Percentage),
12628}
12629
12630impl fmt::Display for PaddingBlockStart {
12631    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12632        match self {
12633            Self::Length(v) => v.fmt(f),
12634            Self::Percentage(v) => v.fmt(f),
12635        }
12636    }
12637}
12638
12639impl From<Length> for PaddingBlockStart {
12640    fn from(v: Length) -> Self {
12641        Self::Length(v)
12642    }
12643}
12644
12645impl From<Percentage> for PaddingBlockStart {
12646    fn from(v: Percentage) -> Self {
12647        Self::Percentage(v)
12648    }
12649}
12650
12651/// A value of [`padding-bottom`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-bottom).
12652#[derive(Debug, Clone, PartialEq)]
12653#[non_exhaustive]
12654pub enum PaddingBottom {
12655    /// A length.
12656    Length(Length),
12657    /// A percentage.
12658    Percentage(Percentage),
12659}
12660
12661impl fmt::Display for PaddingBottom {
12662    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12663        match self {
12664            Self::Length(v) => v.fmt(f),
12665            Self::Percentage(v) => v.fmt(f),
12666        }
12667    }
12668}
12669
12670impl From<Length> for PaddingBottom {
12671    fn from(v: Length) -> Self {
12672        Self::Length(v)
12673    }
12674}
12675
12676impl From<Percentage> for PaddingBottom {
12677    fn from(v: Percentage) -> Self {
12678        Self::Percentage(v)
12679    }
12680}
12681
12682/// A value of [`padding-inline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-inline).
12683#[derive(Debug, Clone, PartialEq)]
12684#[non_exhaustive]
12685pub enum PaddingInline {
12686    /// A length.
12687    Length(Length),
12688    /// A percentage.
12689    Percentage(Percentage),
12690    /// Any other value, passed through unchecked.
12691    Raw(Raw),
12692}
12693
12694impl fmt::Display for PaddingInline {
12695    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12696        match self {
12697            Self::Length(v) => v.fmt(f),
12698            Self::Percentage(v) => v.fmt(f),
12699            Self::Raw(v) => v.fmt(f),
12700        }
12701    }
12702}
12703
12704impl From<Length> for PaddingInline {
12705    fn from(v: Length) -> Self {
12706        Self::Length(v)
12707    }
12708}
12709
12710impl From<Percentage> for PaddingInline {
12711    fn from(v: Percentage) -> Self {
12712        Self::Percentage(v)
12713    }
12714}
12715
12716impl From<Raw> for PaddingInline {
12717    fn from(v: Raw) -> Self {
12718        Self::Raw(v)
12719    }
12720}
12721
12722/// A value of [`padding-inline-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-inline-end).
12723#[derive(Debug, Clone, PartialEq)]
12724#[non_exhaustive]
12725pub enum PaddingInlineEnd {
12726    /// A length.
12727    Length(Length),
12728    /// A percentage.
12729    Percentage(Percentage),
12730}
12731
12732impl fmt::Display for PaddingInlineEnd {
12733    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12734        match self {
12735            Self::Length(v) => v.fmt(f),
12736            Self::Percentage(v) => v.fmt(f),
12737        }
12738    }
12739}
12740
12741impl From<Length> for PaddingInlineEnd {
12742    fn from(v: Length) -> Self {
12743        Self::Length(v)
12744    }
12745}
12746
12747impl From<Percentage> for PaddingInlineEnd {
12748    fn from(v: Percentage) -> Self {
12749        Self::Percentage(v)
12750    }
12751}
12752
12753/// A value of [`padding-inline-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-inline-start).
12754#[derive(Debug, Clone, PartialEq)]
12755#[non_exhaustive]
12756pub enum PaddingInlineStart {
12757    /// A length.
12758    Length(Length),
12759    /// A percentage.
12760    Percentage(Percentage),
12761}
12762
12763impl fmt::Display for PaddingInlineStart {
12764    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12765        match self {
12766            Self::Length(v) => v.fmt(f),
12767            Self::Percentage(v) => v.fmt(f),
12768        }
12769    }
12770}
12771
12772impl From<Length> for PaddingInlineStart {
12773    fn from(v: Length) -> Self {
12774        Self::Length(v)
12775    }
12776}
12777
12778impl From<Percentage> for PaddingInlineStart {
12779    fn from(v: Percentage) -> Self {
12780        Self::Percentage(v)
12781    }
12782}
12783
12784/// A value of [`padding-left`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-left).
12785#[derive(Debug, Clone, PartialEq)]
12786#[non_exhaustive]
12787pub enum PaddingLeft {
12788    /// A length.
12789    Length(Length),
12790    /// A percentage.
12791    Percentage(Percentage),
12792}
12793
12794impl fmt::Display for PaddingLeft {
12795    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12796        match self {
12797            Self::Length(v) => v.fmt(f),
12798            Self::Percentage(v) => v.fmt(f),
12799        }
12800    }
12801}
12802
12803impl From<Length> for PaddingLeft {
12804    fn from(v: Length) -> Self {
12805        Self::Length(v)
12806    }
12807}
12808
12809impl From<Percentage> for PaddingLeft {
12810    fn from(v: Percentage) -> Self {
12811        Self::Percentage(v)
12812    }
12813}
12814
12815/// A value of [`padding-right`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-right).
12816#[derive(Debug, Clone, PartialEq)]
12817#[non_exhaustive]
12818pub enum PaddingRight {
12819    /// A length.
12820    Length(Length),
12821    /// A percentage.
12822    Percentage(Percentage),
12823}
12824
12825impl fmt::Display for PaddingRight {
12826    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12827        match self {
12828            Self::Length(v) => v.fmt(f),
12829            Self::Percentage(v) => v.fmt(f),
12830        }
12831    }
12832}
12833
12834impl From<Length> for PaddingRight {
12835    fn from(v: Length) -> Self {
12836        Self::Length(v)
12837    }
12838}
12839
12840impl From<Percentage> for PaddingRight {
12841    fn from(v: Percentage) -> Self {
12842        Self::Percentage(v)
12843    }
12844}
12845
12846/// A value of [`padding-top`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/padding-top).
12847#[derive(Debug, Clone, PartialEq)]
12848#[non_exhaustive]
12849pub enum PaddingTop {
12850    /// A length.
12851    Length(Length),
12852    /// A percentage.
12853    Percentage(Percentage),
12854}
12855
12856impl fmt::Display for PaddingTop {
12857    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12858        match self {
12859            Self::Length(v) => v.fmt(f),
12860            Self::Percentage(v) => v.fmt(f),
12861        }
12862    }
12863}
12864
12865impl From<Length> for PaddingTop {
12866    fn from(v: Length) -> Self {
12867        Self::Length(v)
12868    }
12869}
12870
12871impl From<Percentage> for PaddingTop {
12872    fn from(v: Percentage) -> Self {
12873        Self::Percentage(v)
12874    }
12875}
12876
12877/// A value of [`page`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/page).
12878#[derive(Debug, Clone, PartialEq)]
12879#[non_exhaustive]
12880pub enum Page {
12881    /// `auto`.
12882    Auto,
12883    /// Any other value, passed through unchecked.
12884    Raw(Raw),
12885}
12886
12887impl fmt::Display for Page {
12888    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12889        match self {
12890            Self::Auto => f.write_str("auto"),
12891            Self::Raw(v) => v.fmt(f),
12892        }
12893    }
12894}
12895
12896impl From<Raw> for Page {
12897    fn from(v: Raw) -> Self {
12898        Self::Raw(v)
12899    }
12900}
12901
12902/// A value of [`paint-order`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/paint-order).
12903#[derive(Debug, Clone, PartialEq)]
12904#[non_exhaustive]
12905pub enum PaintOrder {
12906    /// `fill`.
12907    Fill,
12908    /// `markers`.
12909    Markers,
12910    /// `normal`.
12911    Normal,
12912    /// `stroke`.
12913    Stroke,
12914    /// Any other value, passed through unchecked.
12915    Raw(Raw),
12916}
12917
12918impl fmt::Display for PaintOrder {
12919    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12920        match self {
12921            Self::Fill => f.write_str("fill"),
12922            Self::Markers => f.write_str("markers"),
12923            Self::Normal => f.write_str("normal"),
12924            Self::Stroke => f.write_str("stroke"),
12925            Self::Raw(v) => v.fmt(f),
12926        }
12927    }
12928}
12929
12930impl From<Raw> for PaintOrder {
12931    fn from(v: Raw) -> Self {
12932        Self::Raw(v)
12933    }
12934}
12935
12936/// A value of [`path-length`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/path-length).
12937#[derive(Debug, Clone, PartialEq)]
12938#[non_exhaustive]
12939pub enum PathLength {
12940    /// `none`.
12941    None,
12942    /// Any other value, passed through unchecked.
12943    Raw(Raw),
12944}
12945
12946impl fmt::Display for PathLength {
12947    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12948        match self {
12949            Self::None => f.write_str("none"),
12950            Self::Raw(v) => v.fmt(f),
12951        }
12952    }
12953}
12954
12955impl From<Raw> for PathLength {
12956    fn from(v: Raw) -> Self {
12957        Self::Raw(v)
12958    }
12959}
12960
12961/// A value of [`perspective`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/perspective).
12962#[derive(Debug, Clone, PartialEq)]
12963#[non_exhaustive]
12964pub enum Perspective {
12965    /// `none`.
12966    None,
12967    /// A length.
12968    Length(Length),
12969}
12970
12971impl fmt::Display for Perspective {
12972    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12973        match self {
12974            Self::None => f.write_str("none"),
12975            Self::Length(v) => v.fmt(f),
12976        }
12977    }
12978}
12979
12980impl From<Length> for Perspective {
12981    fn from(v: Length) -> Self {
12982        Self::Length(v)
12983    }
12984}
12985
12986/// A value of [`perspective-origin`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/perspective-origin).
12987#[derive(Debug, Clone, PartialEq)]
12988#[non_exhaustive]
12989pub enum PerspectiveOrigin {
12990    /// `bottom`.
12991    Bottom,
12992    /// `center`.
12993    Center,
12994    /// `left`.
12995    Left,
12996    /// `right`.
12997    Right,
12998    /// `top`.
12999    Top,
13000    /// A length.
13001    Length(Length),
13002    /// A percentage.
13003    Percentage(Percentage),
13004    /// Any other value, passed through unchecked.
13005    Raw(Raw),
13006}
13007
13008impl fmt::Display for PerspectiveOrigin {
13009    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13010        match self {
13011            Self::Bottom => f.write_str("bottom"),
13012            Self::Center => f.write_str("center"),
13013            Self::Left => f.write_str("left"),
13014            Self::Right => f.write_str("right"),
13015            Self::Top => f.write_str("top"),
13016            Self::Length(v) => v.fmt(f),
13017            Self::Percentage(v) => v.fmt(f),
13018            Self::Raw(v) => v.fmt(f),
13019        }
13020    }
13021}
13022
13023impl From<Length> for PerspectiveOrigin {
13024    fn from(v: Length) -> Self {
13025        Self::Length(v)
13026    }
13027}
13028
13029impl From<Percentage> for PerspectiveOrigin {
13030    fn from(v: Percentage) -> Self {
13031        Self::Percentage(v)
13032    }
13033}
13034
13035impl From<Raw> for PerspectiveOrigin {
13036    fn from(v: Raw) -> Self {
13037        Self::Raw(v)
13038    }
13039}
13040
13041/// A value of [`place-content`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/place-content).
13042#[derive(Debug, Clone, PartialEq)]
13043#[non_exhaustive]
13044pub enum PlaceContent {
13045    /// `baseline`.
13046    Baseline,
13047    /// `center`.
13048    Center,
13049    /// `end`.
13050    End,
13051    /// `flex-end`.
13052    FlexEnd,
13053    /// `flex-start`.
13054    FlexStart,
13055    /// `normal`.
13056    Normal,
13057    /// `space-around`.
13058    SpaceAround,
13059    /// `space-between`.
13060    SpaceBetween,
13061    /// `space-evenly`.
13062    SpaceEvenly,
13063    /// `start`.
13064    Start,
13065    /// `stretch`.
13066    Stretch,
13067    /// Any other value, passed through unchecked.
13068    Raw(Raw),
13069}
13070
13071impl fmt::Display for PlaceContent {
13072    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13073        match self {
13074            Self::Baseline => f.write_str("baseline"),
13075            Self::Center => f.write_str("center"),
13076            Self::End => f.write_str("end"),
13077            Self::FlexEnd => f.write_str("flex-end"),
13078            Self::FlexStart => f.write_str("flex-start"),
13079            Self::Normal => f.write_str("normal"),
13080            Self::SpaceAround => f.write_str("space-around"),
13081            Self::SpaceBetween => f.write_str("space-between"),
13082            Self::SpaceEvenly => f.write_str("space-evenly"),
13083            Self::Start => f.write_str("start"),
13084            Self::Stretch => f.write_str("stretch"),
13085            Self::Raw(v) => v.fmt(f),
13086        }
13087    }
13088}
13089
13090impl From<Raw> for PlaceContent {
13091    fn from(v: Raw) -> Self {
13092        Self::Raw(v)
13093    }
13094}
13095
13096/// A value of [`place-items`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/place-items).
13097#[derive(Debug, Clone, PartialEq)]
13098#[non_exhaustive]
13099pub enum PlaceItems {
13100    /// `anchor-center`.
13101    AnchorCenter,
13102    /// `baseline`.
13103    Baseline,
13104    /// `center`.
13105    Center,
13106    /// `end`.
13107    End,
13108    /// `flex-end`.
13109    FlexEnd,
13110    /// `flex-start`.
13111    FlexStart,
13112    /// `normal`.
13113    Normal,
13114    /// `self-end`.
13115    SelfEnd,
13116    /// `self-start`.
13117    SelfStart,
13118    /// `start`.
13119    Start,
13120    /// `stretch`.
13121    Stretch,
13122    /// Any other value, passed through unchecked.
13123    Raw(Raw),
13124}
13125
13126impl fmt::Display for PlaceItems {
13127    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13128        match self {
13129            Self::AnchorCenter => f.write_str("anchor-center"),
13130            Self::Baseline => f.write_str("baseline"),
13131            Self::Center => f.write_str("center"),
13132            Self::End => f.write_str("end"),
13133            Self::FlexEnd => f.write_str("flex-end"),
13134            Self::FlexStart => f.write_str("flex-start"),
13135            Self::Normal => f.write_str("normal"),
13136            Self::SelfEnd => f.write_str("self-end"),
13137            Self::SelfStart => f.write_str("self-start"),
13138            Self::Start => f.write_str("start"),
13139            Self::Stretch => f.write_str("stretch"),
13140            Self::Raw(v) => v.fmt(f),
13141        }
13142    }
13143}
13144
13145impl From<Raw> for PlaceItems {
13146    fn from(v: Raw) -> Self {
13147        Self::Raw(v)
13148    }
13149}
13150
13151/// A value of [`place-self`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/place-self).
13152#[derive(Debug, Clone, PartialEq)]
13153#[non_exhaustive]
13154pub enum PlaceSelf {
13155    /// `anchor-center`.
13156    AnchorCenter,
13157    /// `auto`.
13158    Auto,
13159    /// `baseline`.
13160    Baseline,
13161    /// `center`.
13162    Center,
13163    /// `end`.
13164    End,
13165    /// `flex-end`.
13166    FlexEnd,
13167    /// `flex-start`.
13168    FlexStart,
13169    /// `normal`.
13170    Normal,
13171    /// `self-end`.
13172    SelfEnd,
13173    /// `self-start`.
13174    SelfStart,
13175    /// `start`.
13176    Start,
13177    /// `stretch`.
13178    Stretch,
13179    /// Any other value, passed through unchecked.
13180    Raw(Raw),
13181}
13182
13183impl fmt::Display for PlaceSelf {
13184    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13185        match self {
13186            Self::AnchorCenter => f.write_str("anchor-center"),
13187            Self::Auto => f.write_str("auto"),
13188            Self::Baseline => f.write_str("baseline"),
13189            Self::Center => f.write_str("center"),
13190            Self::End => f.write_str("end"),
13191            Self::FlexEnd => f.write_str("flex-end"),
13192            Self::FlexStart => f.write_str("flex-start"),
13193            Self::Normal => f.write_str("normal"),
13194            Self::SelfEnd => f.write_str("self-end"),
13195            Self::SelfStart => f.write_str("self-start"),
13196            Self::Start => f.write_str("start"),
13197            Self::Stretch => f.write_str("stretch"),
13198            Self::Raw(v) => v.fmt(f),
13199        }
13200    }
13201}
13202
13203impl From<Raw> for PlaceSelf {
13204    fn from(v: Raw) -> Self {
13205        Self::Raw(v)
13206    }
13207}
13208
13209/// A value of [`pointer-events`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/pointer-events).
13210#[derive(Debug, Clone, PartialEq)]
13211#[non_exhaustive]
13212pub enum PointerEvents {
13213    /// `all`.
13214    All,
13215    /// `auto`.
13216    Auto,
13217    /// `fill`.
13218    Fill,
13219    /// `inherit`.
13220    Inherit,
13221    /// `none`.
13222    None,
13223    /// `painted`.
13224    Painted,
13225    /// `stroke`.
13226    Stroke,
13227    /// `visible`.
13228    Visible,
13229    /// `visibleFill`.
13230    VisibleFill,
13231    /// `visiblePainted`.
13232    VisiblePainted,
13233    /// `visibleStroke`.
13234    VisibleStroke,
13235}
13236
13237impl fmt::Display for PointerEvents {
13238    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13239        match self {
13240            Self::All => f.write_str("all"),
13241            Self::Auto => f.write_str("auto"),
13242            Self::Fill => f.write_str("fill"),
13243            Self::Inherit => f.write_str("inherit"),
13244            Self::None => f.write_str("none"),
13245            Self::Painted => f.write_str("painted"),
13246            Self::Stroke => f.write_str("stroke"),
13247            Self::Visible => f.write_str("visible"),
13248            Self::VisibleFill => f.write_str("visibleFill"),
13249            Self::VisiblePainted => f.write_str("visiblePainted"),
13250            Self::VisibleStroke => f.write_str("visibleStroke"),
13251        }
13252    }
13253}
13254
13255/// A value of [`position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/position).
13256#[derive(Debug, Clone, PartialEq)]
13257#[non_exhaustive]
13258pub enum Position {
13259    /// `absolute`.
13260    Absolute,
13261    /// `fixed`.
13262    Fixed,
13263    /// `relative`.
13264    Relative,
13265    /// `static`.
13266    Static,
13267    /// `sticky`.
13268    Sticky,
13269}
13270
13271impl fmt::Display for Position {
13272    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13273        match self {
13274            Self::Absolute => f.write_str("absolute"),
13275            Self::Fixed => f.write_str("fixed"),
13276            Self::Relative => f.write_str("relative"),
13277            Self::Static => f.write_str("static"),
13278            Self::Sticky => f.write_str("sticky"),
13279        }
13280    }
13281}
13282
13283/// A value of [`position-anchor`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/position-anchor).
13284#[derive(Debug, Clone, PartialEq)]
13285#[non_exhaustive]
13286pub enum PositionAnchor {
13287    /// `auto`.
13288    Auto,
13289    /// `match-parent`.
13290    MatchParent,
13291    /// `none`.
13292    None,
13293    /// `normal`.
13294    Normal,
13295    /// Any other value, passed through unchecked.
13296    Raw(Raw),
13297}
13298
13299impl fmt::Display for PositionAnchor {
13300    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13301        match self {
13302            Self::Auto => f.write_str("auto"),
13303            Self::MatchParent => f.write_str("match-parent"),
13304            Self::None => f.write_str("none"),
13305            Self::Normal => f.write_str("normal"),
13306            Self::Raw(v) => v.fmt(f),
13307        }
13308    }
13309}
13310
13311impl From<Raw> for PositionAnchor {
13312    fn from(v: Raw) -> Self {
13313        Self::Raw(v)
13314    }
13315}
13316
13317/// A value of [`position-area`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/position-area).
13318#[derive(Debug, Clone, PartialEq)]
13319#[non_exhaustive]
13320pub enum PositionArea {
13321    /// `none`.
13322    None,
13323    /// Any other value, passed through unchecked.
13324    Raw(Raw),
13325}
13326
13327impl fmt::Display for PositionArea {
13328    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13329        match self {
13330            Self::None => f.write_str("none"),
13331            Self::Raw(v) => v.fmt(f),
13332        }
13333    }
13334}
13335
13336impl From<Raw> for PositionArea {
13337    fn from(v: Raw) -> Self {
13338        Self::Raw(v)
13339    }
13340}
13341
13342/// A value of [`position-try-fallbacks`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/position-try-fallbacks).
13343#[derive(Debug, Clone, PartialEq)]
13344#[non_exhaustive]
13345pub enum PositionTryFallbacks {
13346    /// `flip-block`.
13347    FlipBlock,
13348    /// `flip-inline`.
13349    FlipInline,
13350    /// `flip-start`.
13351    FlipStart,
13352    /// `none`.
13353    None,
13354    /// Any other value, passed through unchecked.
13355    Raw(Raw),
13356}
13357
13358impl fmt::Display for PositionTryFallbacks {
13359    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13360        match self {
13361            Self::FlipBlock => f.write_str("flip-block"),
13362            Self::FlipInline => f.write_str("flip-inline"),
13363            Self::FlipStart => f.write_str("flip-start"),
13364            Self::None => f.write_str("none"),
13365            Self::Raw(v) => v.fmt(f),
13366        }
13367    }
13368}
13369
13370impl From<Raw> for PositionTryFallbacks {
13371    fn from(v: Raw) -> Self {
13372        Self::Raw(v)
13373    }
13374}
13375
13376/// A value of [`print-color-adjust`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/print-color-adjust).
13377#[derive(Debug, Clone, PartialEq)]
13378#[non_exhaustive]
13379pub enum PrintColorAdjust {
13380    /// `economy`.
13381    Economy,
13382    /// `exact`.
13383    Exact,
13384}
13385
13386impl fmt::Display for PrintColorAdjust {
13387    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13388        match self {
13389            Self::Economy => f.write_str("economy"),
13390            Self::Exact => f.write_str("exact"),
13391        }
13392    }
13393}
13394
13395/// A value of [`quotes`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/quotes).
13396#[derive(Debug, Clone, PartialEq)]
13397#[non_exhaustive]
13398pub enum Quotes {
13399    /// `auto`.
13400    Auto,
13401    /// `none`.
13402    None,
13403    /// Any other value, passed through unchecked.
13404    Raw(Raw),
13405}
13406
13407impl fmt::Display for Quotes {
13408    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13409        match self {
13410            Self::Auto => f.write_str("auto"),
13411            Self::None => f.write_str("none"),
13412            Self::Raw(v) => v.fmt(f),
13413        }
13414    }
13415}
13416
13417impl From<Raw> for Quotes {
13418    fn from(v: Raw) -> Self {
13419        Self::Raw(v)
13420    }
13421}
13422
13423/// A value of [`r`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/r).
13424#[derive(Debug, Clone, PartialEq)]
13425#[non_exhaustive]
13426pub enum R {
13427    /// A length.
13428    Length(Length),
13429    /// A percentage.
13430    Percentage(Percentage),
13431}
13432
13433impl fmt::Display for R {
13434    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13435        match self {
13436            Self::Length(v) => v.fmt(f),
13437            Self::Percentage(v) => v.fmt(f),
13438        }
13439    }
13440}
13441
13442impl From<Length> for R {
13443    fn from(v: Length) -> Self {
13444        Self::Length(v)
13445    }
13446}
13447
13448impl From<Percentage> for R {
13449    fn from(v: Percentage) -> Self {
13450        Self::Percentage(v)
13451    }
13452}
13453
13454/// A value of [`reading-flow`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/reading-flow).
13455#[derive(Debug, Clone, PartialEq)]
13456#[non_exhaustive]
13457pub enum ReadingFlow {
13458    /// `flex-flow`.
13459    FlexFlow,
13460    /// `flex-visual`.
13461    FlexVisual,
13462    /// `grid-columns`.
13463    GridColumns,
13464    /// `grid-order`.
13465    GridOrder,
13466    /// `grid-rows`.
13467    GridRows,
13468    /// `normal`.
13469    Normal,
13470    /// `source-order`.
13471    SourceOrder,
13472}
13473
13474impl fmt::Display for ReadingFlow {
13475    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13476        match self {
13477            Self::FlexFlow => f.write_str("flex-flow"),
13478            Self::FlexVisual => f.write_str("flex-visual"),
13479            Self::GridColumns => f.write_str("grid-columns"),
13480            Self::GridOrder => f.write_str("grid-order"),
13481            Self::GridRows => f.write_str("grid-rows"),
13482            Self::Normal => f.write_str("normal"),
13483            Self::SourceOrder => f.write_str("source-order"),
13484        }
13485    }
13486}
13487
13488/// A value of [`resize`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/resize).
13489#[derive(Debug, Clone, PartialEq)]
13490#[non_exhaustive]
13491pub enum Resize {
13492    /// `block`.
13493    Block,
13494    /// `both`.
13495    Both,
13496    /// `horizontal`.
13497    Horizontal,
13498    /// `inline`.
13499    Inline,
13500    /// `none`.
13501    None,
13502    /// `vertical`.
13503    Vertical,
13504}
13505
13506impl fmt::Display for Resize {
13507    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13508        match self {
13509            Self::Block => f.write_str("block"),
13510            Self::Both => f.write_str("both"),
13511            Self::Horizontal => f.write_str("horizontal"),
13512            Self::Inline => f.write_str("inline"),
13513            Self::None => f.write_str("none"),
13514            Self::Vertical => f.write_str("vertical"),
13515        }
13516    }
13517}
13518
13519/// A value of [`right`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/right).
13520#[derive(Debug, Clone, PartialEq)]
13521#[non_exhaustive]
13522pub enum Right {
13523    /// `auto`.
13524    Auto,
13525    /// A length.
13526    Length(Length),
13527    /// A percentage.
13528    Percentage(Percentage),
13529    /// Any other value, passed through unchecked.
13530    Raw(Raw),
13531}
13532
13533impl fmt::Display for Right {
13534    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13535        match self {
13536            Self::Auto => f.write_str("auto"),
13537            Self::Length(v) => v.fmt(f),
13538            Self::Percentage(v) => v.fmt(f),
13539            Self::Raw(v) => v.fmt(f),
13540        }
13541    }
13542}
13543
13544impl From<Length> for Right {
13545    fn from(v: Length) -> Self {
13546        Self::Length(v)
13547    }
13548}
13549
13550impl From<Percentage> for Right {
13551    fn from(v: Percentage) -> Self {
13552        Self::Percentage(v)
13553    }
13554}
13555
13556impl From<Raw> for Right {
13557    fn from(v: Raw) -> Self {
13558        Self::Raw(v)
13559    }
13560}
13561
13562/// A value of [`rotate`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/rotate).
13563#[derive(Debug, Clone, PartialEq)]
13564#[non_exhaustive]
13565pub enum Rotate {
13566    /// `none`.
13567    None,
13568    /// An angle.
13569    Angle(Angle),
13570    /// Any other value, passed through unchecked.
13571    Raw(Raw),
13572}
13573
13574impl fmt::Display for Rotate {
13575    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13576        match self {
13577            Self::None => f.write_str("none"),
13578            Self::Angle(v) => v.fmt(f),
13579            Self::Raw(v) => v.fmt(f),
13580        }
13581    }
13582}
13583
13584impl From<Angle> for Rotate {
13585    fn from(v: Angle) -> Self {
13586        Self::Angle(v)
13587    }
13588}
13589
13590impl From<Raw> for Rotate {
13591    fn from(v: Raw) -> Self {
13592        Self::Raw(v)
13593    }
13594}
13595
13596/// A value of [`row-gap`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/row-gap).
13597#[derive(Debug, Clone, PartialEq)]
13598#[non_exhaustive]
13599pub enum RowGap {
13600    /// `normal`.
13601    Normal,
13602    /// A length.
13603    Length(Length),
13604    /// A percentage.
13605    Percentage(Percentage),
13606}
13607
13608impl fmt::Display for RowGap {
13609    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13610        match self {
13611            Self::Normal => f.write_str("normal"),
13612            Self::Length(v) => v.fmt(f),
13613            Self::Percentage(v) => v.fmt(f),
13614        }
13615    }
13616}
13617
13618impl From<Length> for RowGap {
13619    fn from(v: Length) -> Self {
13620        Self::Length(v)
13621    }
13622}
13623
13624impl From<Percentage> for RowGap {
13625    fn from(v: Percentage) -> Self {
13626        Self::Percentage(v)
13627    }
13628}
13629
13630/// A value of [`ruby-align`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/ruby-align).
13631#[derive(Debug, Clone, PartialEq)]
13632#[non_exhaustive]
13633pub enum RubyAlign {
13634    /// `center`.
13635    Center,
13636    /// `space-around`.
13637    SpaceAround,
13638    /// `space-between`.
13639    SpaceBetween,
13640    /// `start`.
13641    Start,
13642}
13643
13644impl fmt::Display for RubyAlign {
13645    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13646        match self {
13647            Self::Center => f.write_str("center"),
13648            Self::SpaceAround => f.write_str("space-around"),
13649            Self::SpaceBetween => f.write_str("space-between"),
13650            Self::Start => f.write_str("start"),
13651        }
13652    }
13653}
13654
13655/// A value of [`ruby-overhang`]().
13656#[derive(Debug, Clone, PartialEq)]
13657#[non_exhaustive]
13658pub enum RubyOverhang {
13659    /// `auto`.
13660    Auto,
13661    /// `none`.
13662    None,
13663}
13664
13665impl fmt::Display for RubyOverhang {
13666    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13667        match self {
13668            Self::Auto => f.write_str("auto"),
13669            Self::None => f.write_str("none"),
13670        }
13671    }
13672}
13673
13674/// A value of [`ruby-position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/ruby-position).
13675#[derive(Debug, Clone, PartialEq)]
13676#[non_exhaustive]
13677pub enum RubyPosition {
13678    /// `alternate`.
13679    Alternate,
13680    /// `inter-character`.
13681    InterCharacter,
13682    /// `over`.
13683    Over,
13684    /// `under`.
13685    Under,
13686    /// Any other value, passed through unchecked.
13687    Raw(Raw),
13688}
13689
13690impl fmt::Display for RubyPosition {
13691    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13692        match self {
13693            Self::Alternate => f.write_str("alternate"),
13694            Self::InterCharacter => f.write_str("inter-character"),
13695            Self::Over => f.write_str("over"),
13696            Self::Under => f.write_str("under"),
13697            Self::Raw(v) => v.fmt(f),
13698        }
13699    }
13700}
13701
13702impl From<Raw> for RubyPosition {
13703    fn from(v: Raw) -> Self {
13704        Self::Raw(v)
13705    }
13706}
13707
13708/// A value of [`rx`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/rx).
13709#[derive(Debug, Clone, PartialEq)]
13710#[non_exhaustive]
13711pub enum Rx {
13712    /// `auto`.
13713    Auto,
13714    /// A length.
13715    Length(Length),
13716    /// A percentage.
13717    Percentage(Percentage),
13718}
13719
13720impl fmt::Display for Rx {
13721    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13722        match self {
13723            Self::Auto => f.write_str("auto"),
13724            Self::Length(v) => v.fmt(f),
13725            Self::Percentage(v) => v.fmt(f),
13726        }
13727    }
13728}
13729
13730impl From<Length> for Rx {
13731    fn from(v: Length) -> Self {
13732        Self::Length(v)
13733    }
13734}
13735
13736impl From<Percentage> for Rx {
13737    fn from(v: Percentage) -> Self {
13738        Self::Percentage(v)
13739    }
13740}
13741
13742/// A value of [`ry`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/ry).
13743#[derive(Debug, Clone, PartialEq)]
13744#[non_exhaustive]
13745pub enum Ry {
13746    /// `auto`.
13747    Auto,
13748    /// A length.
13749    Length(Length),
13750    /// A percentage.
13751    Percentage(Percentage),
13752}
13753
13754impl fmt::Display for Ry {
13755    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13756        match self {
13757            Self::Auto => f.write_str("auto"),
13758            Self::Length(v) => v.fmt(f),
13759            Self::Percentage(v) => v.fmt(f),
13760        }
13761    }
13762}
13763
13764impl From<Length> for Ry {
13765    fn from(v: Length) -> Self {
13766        Self::Length(v)
13767    }
13768}
13769
13770impl From<Percentage> for Ry {
13771    fn from(v: Percentage) -> Self {
13772        Self::Percentage(v)
13773    }
13774}
13775
13776/// A value of [`scale`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scale).
13777#[derive(Debug, Clone, PartialEq)]
13778#[non_exhaustive]
13779pub enum Scale {
13780    /// `none`.
13781    None,
13782    /// A percentage.
13783    Percentage(Percentage),
13784    /// A number.
13785    Number(f64),
13786    /// Any other value, passed through unchecked.
13787    Raw(Raw),
13788}
13789
13790impl fmt::Display for Scale {
13791    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13792        match self {
13793            Self::None => f.write_str("none"),
13794            Self::Percentage(v) => v.fmt(f),
13795            Self::Number(v) => v.fmt(f),
13796            Self::Raw(v) => v.fmt(f),
13797        }
13798    }
13799}
13800
13801impl From<Percentage> for Scale {
13802    fn from(v: Percentage) -> Self {
13803        Self::Percentage(v)
13804    }
13805}
13806
13807impl From<f64> for Scale {
13808    fn from(v: f64) -> Self {
13809        Self::Number(v)
13810    }
13811}
13812
13813impl From<i32> for Scale {
13814    fn from(v: i32) -> Self {
13815        Self::Number(f64::from(v))
13816    }
13817}
13818
13819impl From<Raw> for Scale {
13820    fn from(v: Raw) -> Self {
13821        Self::Raw(v)
13822    }
13823}
13824
13825/// A value of [`scroll-axis-lock`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-axis-lock).
13826#[derive(Debug, Clone, PartialEq)]
13827#[non_exhaustive]
13828pub enum ScrollAxisLock {
13829    /// `auto`.
13830    Auto,
13831    /// `none`.
13832    None,
13833}
13834
13835impl fmt::Display for ScrollAxisLock {
13836    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13837        match self {
13838            Self::Auto => f.write_str("auto"),
13839            Self::None => f.write_str("none"),
13840        }
13841    }
13842}
13843
13844/// A value of [`scroll-behavior`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-behavior).
13845#[derive(Debug, Clone, PartialEq)]
13846#[non_exhaustive]
13847pub enum ScrollBehavior {
13848    /// `auto`.
13849    Auto,
13850    /// `smooth`.
13851    Smooth,
13852}
13853
13854impl fmt::Display for ScrollBehavior {
13855    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13856        match self {
13857            Self::Auto => f.write_str("auto"),
13858            Self::Smooth => f.write_str("smooth"),
13859        }
13860    }
13861}
13862
13863/// A value of [`scroll-margin`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-margin).
13864#[derive(Debug, Clone, PartialEq)]
13865#[non_exhaustive]
13866pub enum ScrollMargin {
13867    /// A length.
13868    Length(Length),
13869    /// Any other value, passed through unchecked.
13870    Raw(Raw),
13871}
13872
13873impl fmt::Display for ScrollMargin {
13874    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13875        match self {
13876            Self::Length(v) => v.fmt(f),
13877            Self::Raw(v) => v.fmt(f),
13878        }
13879    }
13880}
13881
13882impl From<Length> for ScrollMargin {
13883    fn from(v: Length) -> Self {
13884        Self::Length(v)
13885    }
13886}
13887
13888impl From<Raw> for ScrollMargin {
13889    fn from(v: Raw) -> Self {
13890        Self::Raw(v)
13891    }
13892}
13893
13894/// A value of [`scroll-margin-block`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-margin-block).
13895#[derive(Debug, Clone, PartialEq)]
13896#[non_exhaustive]
13897pub enum ScrollMarginBlock {
13898    /// A length.
13899    Length(Length),
13900    /// Any other value, passed through unchecked.
13901    Raw(Raw),
13902}
13903
13904impl fmt::Display for ScrollMarginBlock {
13905    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13906        match self {
13907            Self::Length(v) => v.fmt(f),
13908            Self::Raw(v) => v.fmt(f),
13909        }
13910    }
13911}
13912
13913impl From<Length> for ScrollMarginBlock {
13914    fn from(v: Length) -> Self {
13915        Self::Length(v)
13916    }
13917}
13918
13919impl From<Raw> for ScrollMarginBlock {
13920    fn from(v: Raw) -> Self {
13921        Self::Raw(v)
13922    }
13923}
13924
13925/// A value of [`scroll-margin-inline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-margin-inline).
13926#[derive(Debug, Clone, PartialEq)]
13927#[non_exhaustive]
13928pub enum ScrollMarginInline {
13929    /// A length.
13930    Length(Length),
13931    /// Any other value, passed through unchecked.
13932    Raw(Raw),
13933}
13934
13935impl fmt::Display for ScrollMarginInline {
13936    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13937        match self {
13938            Self::Length(v) => v.fmt(f),
13939            Self::Raw(v) => v.fmt(f),
13940        }
13941    }
13942}
13943
13944impl From<Length> for ScrollMarginInline {
13945    fn from(v: Length) -> Self {
13946        Self::Length(v)
13947    }
13948}
13949
13950impl From<Raw> for ScrollMarginInline {
13951    fn from(v: Raw) -> Self {
13952        Self::Raw(v)
13953    }
13954}
13955
13956/// A value of [`scroll-marker-group`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-marker-group).
13957#[derive(Debug, Clone, PartialEq)]
13958#[non_exhaustive]
13959pub enum ScrollMarkerGroup {
13960    /// `after`.
13961    After,
13962    /// `before`.
13963    Before,
13964    /// `none`.
13965    None,
13966}
13967
13968impl fmt::Display for ScrollMarkerGroup {
13969    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13970        match self {
13971            Self::After => f.write_str("after"),
13972            Self::Before => f.write_str("before"),
13973            Self::None => f.write_str("none"),
13974        }
13975    }
13976}
13977
13978/// A value of [`scroll-padding`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding).
13979#[derive(Debug, Clone, PartialEq)]
13980#[non_exhaustive]
13981pub enum ScrollPadding {
13982    /// `auto`.
13983    Auto,
13984    /// A length.
13985    Length(Length),
13986    /// A percentage.
13987    Percentage(Percentage),
13988    /// Any other value, passed through unchecked.
13989    Raw(Raw),
13990}
13991
13992impl fmt::Display for ScrollPadding {
13993    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
13994        match self {
13995            Self::Auto => f.write_str("auto"),
13996            Self::Length(v) => v.fmt(f),
13997            Self::Percentage(v) => v.fmt(f),
13998            Self::Raw(v) => v.fmt(f),
13999        }
14000    }
14001}
14002
14003impl From<Length> for ScrollPadding {
14004    fn from(v: Length) -> Self {
14005        Self::Length(v)
14006    }
14007}
14008
14009impl From<Percentage> for ScrollPadding {
14010    fn from(v: Percentage) -> Self {
14011        Self::Percentage(v)
14012    }
14013}
14014
14015impl From<Raw> for ScrollPadding {
14016    fn from(v: Raw) -> Self {
14017        Self::Raw(v)
14018    }
14019}
14020
14021/// A value of [`scroll-padding-block`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-block).
14022#[derive(Debug, Clone, PartialEq)]
14023#[non_exhaustive]
14024pub enum ScrollPaddingBlock {
14025    /// `auto`.
14026    Auto,
14027    /// A length.
14028    Length(Length),
14029    /// A percentage.
14030    Percentage(Percentage),
14031    /// Any other value, passed through unchecked.
14032    Raw(Raw),
14033}
14034
14035impl fmt::Display for ScrollPaddingBlock {
14036    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14037        match self {
14038            Self::Auto => f.write_str("auto"),
14039            Self::Length(v) => v.fmt(f),
14040            Self::Percentage(v) => v.fmt(f),
14041            Self::Raw(v) => v.fmt(f),
14042        }
14043    }
14044}
14045
14046impl From<Length> for ScrollPaddingBlock {
14047    fn from(v: Length) -> Self {
14048        Self::Length(v)
14049    }
14050}
14051
14052impl From<Percentage> for ScrollPaddingBlock {
14053    fn from(v: Percentage) -> Self {
14054        Self::Percentage(v)
14055    }
14056}
14057
14058impl From<Raw> for ScrollPaddingBlock {
14059    fn from(v: Raw) -> Self {
14060        Self::Raw(v)
14061    }
14062}
14063
14064/// A value of [`scroll-padding-block-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-block-end).
14065#[derive(Debug, Clone, PartialEq)]
14066#[non_exhaustive]
14067pub enum ScrollPaddingBlockEnd {
14068    /// `auto`.
14069    Auto,
14070    /// A length.
14071    Length(Length),
14072    /// A percentage.
14073    Percentage(Percentage),
14074}
14075
14076impl fmt::Display for ScrollPaddingBlockEnd {
14077    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14078        match self {
14079            Self::Auto => f.write_str("auto"),
14080            Self::Length(v) => v.fmt(f),
14081            Self::Percentage(v) => v.fmt(f),
14082        }
14083    }
14084}
14085
14086impl From<Length> for ScrollPaddingBlockEnd {
14087    fn from(v: Length) -> Self {
14088        Self::Length(v)
14089    }
14090}
14091
14092impl From<Percentage> for ScrollPaddingBlockEnd {
14093    fn from(v: Percentage) -> Self {
14094        Self::Percentage(v)
14095    }
14096}
14097
14098/// A value of [`scroll-padding-block-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-block-start).
14099#[derive(Debug, Clone, PartialEq)]
14100#[non_exhaustive]
14101pub enum ScrollPaddingBlockStart {
14102    /// `auto`.
14103    Auto,
14104    /// A length.
14105    Length(Length),
14106    /// A percentage.
14107    Percentage(Percentage),
14108}
14109
14110impl fmt::Display for ScrollPaddingBlockStart {
14111    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14112        match self {
14113            Self::Auto => f.write_str("auto"),
14114            Self::Length(v) => v.fmt(f),
14115            Self::Percentage(v) => v.fmt(f),
14116        }
14117    }
14118}
14119
14120impl From<Length> for ScrollPaddingBlockStart {
14121    fn from(v: Length) -> Self {
14122        Self::Length(v)
14123    }
14124}
14125
14126impl From<Percentage> for ScrollPaddingBlockStart {
14127    fn from(v: Percentage) -> Self {
14128        Self::Percentage(v)
14129    }
14130}
14131
14132/// A value of [`scroll-padding-bottom`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-bottom).
14133#[derive(Debug, Clone, PartialEq)]
14134#[non_exhaustive]
14135pub enum ScrollPaddingBottom {
14136    /// `auto`.
14137    Auto,
14138    /// A length.
14139    Length(Length),
14140    /// A percentage.
14141    Percentage(Percentage),
14142}
14143
14144impl fmt::Display for ScrollPaddingBottom {
14145    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14146        match self {
14147            Self::Auto => f.write_str("auto"),
14148            Self::Length(v) => v.fmt(f),
14149            Self::Percentage(v) => v.fmt(f),
14150        }
14151    }
14152}
14153
14154impl From<Length> for ScrollPaddingBottom {
14155    fn from(v: Length) -> Self {
14156        Self::Length(v)
14157    }
14158}
14159
14160impl From<Percentage> for ScrollPaddingBottom {
14161    fn from(v: Percentage) -> Self {
14162        Self::Percentage(v)
14163    }
14164}
14165
14166/// A value of [`scroll-padding-inline`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-inline).
14167#[derive(Debug, Clone, PartialEq)]
14168#[non_exhaustive]
14169pub enum ScrollPaddingInline {
14170    /// `auto`.
14171    Auto,
14172    /// A length.
14173    Length(Length),
14174    /// A percentage.
14175    Percentage(Percentage),
14176    /// Any other value, passed through unchecked.
14177    Raw(Raw),
14178}
14179
14180impl fmt::Display for ScrollPaddingInline {
14181    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14182        match self {
14183            Self::Auto => f.write_str("auto"),
14184            Self::Length(v) => v.fmt(f),
14185            Self::Percentage(v) => v.fmt(f),
14186            Self::Raw(v) => v.fmt(f),
14187        }
14188    }
14189}
14190
14191impl From<Length> for ScrollPaddingInline {
14192    fn from(v: Length) -> Self {
14193        Self::Length(v)
14194    }
14195}
14196
14197impl From<Percentage> for ScrollPaddingInline {
14198    fn from(v: Percentage) -> Self {
14199        Self::Percentage(v)
14200    }
14201}
14202
14203impl From<Raw> for ScrollPaddingInline {
14204    fn from(v: Raw) -> Self {
14205        Self::Raw(v)
14206    }
14207}
14208
14209/// A value of [`scroll-padding-inline-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-inline-end).
14210#[derive(Debug, Clone, PartialEq)]
14211#[non_exhaustive]
14212pub enum ScrollPaddingInlineEnd {
14213    /// `auto`.
14214    Auto,
14215    /// A length.
14216    Length(Length),
14217    /// A percentage.
14218    Percentage(Percentage),
14219}
14220
14221impl fmt::Display for ScrollPaddingInlineEnd {
14222    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14223        match self {
14224            Self::Auto => f.write_str("auto"),
14225            Self::Length(v) => v.fmt(f),
14226            Self::Percentage(v) => v.fmt(f),
14227        }
14228    }
14229}
14230
14231impl From<Length> for ScrollPaddingInlineEnd {
14232    fn from(v: Length) -> Self {
14233        Self::Length(v)
14234    }
14235}
14236
14237impl From<Percentage> for ScrollPaddingInlineEnd {
14238    fn from(v: Percentage) -> Self {
14239        Self::Percentage(v)
14240    }
14241}
14242
14243/// A value of [`scroll-padding-inline-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-inline-start).
14244#[derive(Debug, Clone, PartialEq)]
14245#[non_exhaustive]
14246pub enum ScrollPaddingInlineStart {
14247    /// `auto`.
14248    Auto,
14249    /// A length.
14250    Length(Length),
14251    /// A percentage.
14252    Percentage(Percentage),
14253}
14254
14255impl fmt::Display for ScrollPaddingInlineStart {
14256    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14257        match self {
14258            Self::Auto => f.write_str("auto"),
14259            Self::Length(v) => v.fmt(f),
14260            Self::Percentage(v) => v.fmt(f),
14261        }
14262    }
14263}
14264
14265impl From<Length> for ScrollPaddingInlineStart {
14266    fn from(v: Length) -> Self {
14267        Self::Length(v)
14268    }
14269}
14270
14271impl From<Percentage> for ScrollPaddingInlineStart {
14272    fn from(v: Percentage) -> Self {
14273        Self::Percentage(v)
14274    }
14275}
14276
14277/// A value of [`scroll-padding-left`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-left).
14278#[derive(Debug, Clone, PartialEq)]
14279#[non_exhaustive]
14280pub enum ScrollPaddingLeft {
14281    /// `auto`.
14282    Auto,
14283    /// A length.
14284    Length(Length),
14285    /// A percentage.
14286    Percentage(Percentage),
14287}
14288
14289impl fmt::Display for ScrollPaddingLeft {
14290    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14291        match self {
14292            Self::Auto => f.write_str("auto"),
14293            Self::Length(v) => v.fmt(f),
14294            Self::Percentage(v) => v.fmt(f),
14295        }
14296    }
14297}
14298
14299impl From<Length> for ScrollPaddingLeft {
14300    fn from(v: Length) -> Self {
14301        Self::Length(v)
14302    }
14303}
14304
14305impl From<Percentage> for ScrollPaddingLeft {
14306    fn from(v: Percentage) -> Self {
14307        Self::Percentage(v)
14308    }
14309}
14310
14311/// A value of [`scroll-padding-right`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-right).
14312#[derive(Debug, Clone, PartialEq)]
14313#[non_exhaustive]
14314pub enum ScrollPaddingRight {
14315    /// `auto`.
14316    Auto,
14317    /// A length.
14318    Length(Length),
14319    /// A percentage.
14320    Percentage(Percentage),
14321}
14322
14323impl fmt::Display for ScrollPaddingRight {
14324    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14325        match self {
14326            Self::Auto => f.write_str("auto"),
14327            Self::Length(v) => v.fmt(f),
14328            Self::Percentage(v) => v.fmt(f),
14329        }
14330    }
14331}
14332
14333impl From<Length> for ScrollPaddingRight {
14334    fn from(v: Length) -> Self {
14335        Self::Length(v)
14336    }
14337}
14338
14339impl From<Percentage> for ScrollPaddingRight {
14340    fn from(v: Percentage) -> Self {
14341        Self::Percentage(v)
14342    }
14343}
14344
14345/// A value of [`scroll-padding-top`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-padding-top).
14346#[derive(Debug, Clone, PartialEq)]
14347#[non_exhaustive]
14348pub enum ScrollPaddingTop {
14349    /// `auto`.
14350    Auto,
14351    /// A length.
14352    Length(Length),
14353    /// A percentage.
14354    Percentage(Percentage),
14355}
14356
14357impl fmt::Display for ScrollPaddingTop {
14358    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14359        match self {
14360            Self::Auto => f.write_str("auto"),
14361            Self::Length(v) => v.fmt(f),
14362            Self::Percentage(v) => v.fmt(f),
14363        }
14364    }
14365}
14366
14367impl From<Length> for ScrollPaddingTop {
14368    fn from(v: Length) -> Self {
14369        Self::Length(v)
14370    }
14371}
14372
14373impl From<Percentage> for ScrollPaddingTop {
14374    fn from(v: Percentage) -> Self {
14375        Self::Percentage(v)
14376    }
14377}
14378
14379/// A value of [`scroll-snap-align`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-snap-align).
14380#[derive(Debug, Clone, PartialEq)]
14381#[non_exhaustive]
14382pub enum ScrollSnapAlign {
14383    /// `center`.
14384    Center,
14385    /// `end`.
14386    End,
14387    /// `none`.
14388    None,
14389    /// `start`.
14390    Start,
14391    /// Any other value, passed through unchecked.
14392    Raw(Raw),
14393}
14394
14395impl fmt::Display for ScrollSnapAlign {
14396    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14397        match self {
14398            Self::Center => f.write_str("center"),
14399            Self::End => f.write_str("end"),
14400            Self::None => f.write_str("none"),
14401            Self::Start => f.write_str("start"),
14402            Self::Raw(v) => v.fmt(f),
14403        }
14404    }
14405}
14406
14407impl From<Raw> for ScrollSnapAlign {
14408    fn from(v: Raw) -> Self {
14409        Self::Raw(v)
14410    }
14411}
14412
14413/// A value of [`scroll-snap-stop`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-snap-stop).
14414#[derive(Debug, Clone, PartialEq)]
14415#[non_exhaustive]
14416pub enum ScrollSnapStop {
14417    /// `always`.
14418    Always,
14419    /// `normal`.
14420    Normal,
14421}
14422
14423impl fmt::Display for ScrollSnapStop {
14424    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14425        match self {
14426            Self::Always => f.write_str("always"),
14427            Self::Normal => f.write_str("normal"),
14428        }
14429    }
14430}
14431
14432/// A value of [`scroll-snap-type`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-snap-type).
14433#[derive(Debug, Clone, PartialEq)]
14434#[non_exhaustive]
14435pub enum ScrollSnapType {
14436    /// `block`.
14437    Block,
14438    /// `both`.
14439    Both,
14440    /// `inline`.
14441    Inline,
14442    /// `none`.
14443    None,
14444    /// `x`.
14445    X,
14446    /// `y`.
14447    Y,
14448    /// Any other value, passed through unchecked.
14449    Raw(Raw),
14450}
14451
14452impl fmt::Display for ScrollSnapType {
14453    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14454        match self {
14455            Self::Block => f.write_str("block"),
14456            Self::Both => f.write_str("both"),
14457            Self::Inline => f.write_str("inline"),
14458            Self::None => f.write_str("none"),
14459            Self::X => f.write_str("x"),
14460            Self::Y => f.write_str("y"),
14461            Self::Raw(v) => v.fmt(f),
14462        }
14463    }
14464}
14465
14466impl From<Raw> for ScrollSnapType {
14467    fn from(v: Raw) -> Self {
14468        Self::Raw(v)
14469    }
14470}
14471
14472/// A value of [`scroll-target-group`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scroll-target-group).
14473#[derive(Debug, Clone, PartialEq)]
14474#[non_exhaustive]
14475pub enum ScrollTargetGroup {
14476    /// `auto`.
14477    Auto,
14478    /// `none`.
14479    None,
14480}
14481
14482impl fmt::Display for ScrollTargetGroup {
14483    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14484        match self {
14485            Self::Auto => f.write_str("auto"),
14486            Self::None => f.write_str("none"),
14487        }
14488    }
14489}
14490
14491/// A value of [`scrollbar-color`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scrollbar-color).
14492#[derive(Debug, Clone, PartialEq)]
14493#[non_exhaustive]
14494pub enum ScrollbarColor {
14495    /// `auto`.
14496    Auto,
14497    /// A color.
14498    Color(Color),
14499    /// Any other value, passed through unchecked.
14500    Raw(Raw),
14501}
14502
14503impl fmt::Display for ScrollbarColor {
14504    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14505        match self {
14506            Self::Auto => f.write_str("auto"),
14507            Self::Color(v) => v.fmt(f),
14508            Self::Raw(v) => v.fmt(f),
14509        }
14510    }
14511}
14512
14513impl From<Color> for ScrollbarColor {
14514    fn from(v: Color) -> Self {
14515        Self::Color(v)
14516    }
14517}
14518
14519impl From<Raw> for ScrollbarColor {
14520    fn from(v: Raw) -> Self {
14521        Self::Raw(v)
14522    }
14523}
14524
14525/// A value of [`scrollbar-gutter`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scrollbar-gutter).
14526#[derive(Debug, Clone, PartialEq)]
14527#[non_exhaustive]
14528pub enum ScrollbarGutter {
14529    /// `auto`.
14530    Auto,
14531    /// Any other value, passed through unchecked.
14532    Raw(Raw),
14533}
14534
14535impl fmt::Display for ScrollbarGutter {
14536    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14537        match self {
14538            Self::Auto => f.write_str("auto"),
14539            Self::Raw(v) => v.fmt(f),
14540        }
14541    }
14542}
14543
14544impl From<Raw> for ScrollbarGutter {
14545    fn from(v: Raw) -> Self {
14546        Self::Raw(v)
14547    }
14548}
14549
14550/// A value of [`scrollbar-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/scrollbar-width).
14551#[derive(Debug, Clone, PartialEq)]
14552#[non_exhaustive]
14553pub enum ScrollbarWidth {
14554    /// `auto`.
14555    Auto,
14556    /// `none`.
14557    None,
14558    /// `thin`.
14559    Thin,
14560}
14561
14562impl fmt::Display for ScrollbarWidth {
14563    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14564        match self {
14565            Self::Auto => f.write_str("auto"),
14566            Self::None => f.write_str("none"),
14567            Self::Thin => f.write_str("thin"),
14568        }
14569    }
14570}
14571
14572/// A value of [`shape-image-threshold`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/shape-image-threshold).
14573#[derive(Debug, Clone, PartialEq)]
14574#[non_exhaustive]
14575pub enum ShapeImageThreshold {
14576    /// A percentage.
14577    Percentage(Percentage),
14578    /// A number.
14579    Number(f64),
14580}
14581
14582impl fmt::Display for ShapeImageThreshold {
14583    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14584        match self {
14585            Self::Percentage(v) => v.fmt(f),
14586            Self::Number(v) => v.fmt(f),
14587        }
14588    }
14589}
14590
14591impl From<Percentage> for ShapeImageThreshold {
14592    fn from(v: Percentage) -> Self {
14593        Self::Percentage(v)
14594    }
14595}
14596
14597impl From<f64> for ShapeImageThreshold {
14598    fn from(v: f64) -> Self {
14599        Self::Number(v)
14600    }
14601}
14602
14603impl From<i32> for ShapeImageThreshold {
14604    fn from(v: i32) -> Self {
14605        Self::Number(f64::from(v))
14606    }
14607}
14608
14609/// A value of [`shape-margin`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/shape-margin).
14610#[derive(Debug, Clone, PartialEq)]
14611#[non_exhaustive]
14612pub enum ShapeMargin {
14613    /// A length.
14614    Length(Length),
14615    /// A percentage.
14616    Percentage(Percentage),
14617}
14618
14619impl fmt::Display for ShapeMargin {
14620    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14621        match self {
14622            Self::Length(v) => v.fmt(f),
14623            Self::Percentage(v) => v.fmt(f),
14624        }
14625    }
14626}
14627
14628impl From<Length> for ShapeMargin {
14629    fn from(v: Length) -> Self {
14630        Self::Length(v)
14631    }
14632}
14633
14634impl From<Percentage> for ShapeMargin {
14635    fn from(v: Percentage) -> Self {
14636        Self::Percentage(v)
14637    }
14638}
14639
14640/// A value of [`shape-outside`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/shape-outside).
14641#[derive(Debug, Clone, PartialEq)]
14642#[non_exhaustive]
14643pub enum ShapeOutside {
14644    /// `border-box`.
14645    BorderBox,
14646    /// `content-box`.
14647    ContentBox,
14648    /// `margin-box`.
14649    MarginBox,
14650    /// `none`.
14651    None,
14652    /// `padding-box`.
14653    PaddingBox,
14654    /// A URL.
14655    Url(Url),
14656    /// Any other value, passed through unchecked.
14657    Raw(Raw),
14658}
14659
14660impl fmt::Display for ShapeOutside {
14661    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14662        match self {
14663            Self::BorderBox => f.write_str("border-box"),
14664            Self::ContentBox => f.write_str("content-box"),
14665            Self::MarginBox => f.write_str("margin-box"),
14666            Self::None => f.write_str("none"),
14667            Self::PaddingBox => f.write_str("padding-box"),
14668            Self::Url(v) => v.fmt(f),
14669            Self::Raw(v) => v.fmt(f),
14670        }
14671    }
14672}
14673
14674impl From<Url> for ShapeOutside {
14675    fn from(v: Url) -> Self {
14676        Self::Url(v)
14677    }
14678}
14679
14680impl From<Raw> for ShapeOutside {
14681    fn from(v: Raw) -> Self {
14682        Self::Raw(v)
14683    }
14684}
14685
14686/// A value of [`shape-rendering`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/shape-rendering).
14687#[derive(Debug, Clone, PartialEq)]
14688#[non_exhaustive]
14689pub enum ShapeRendering {
14690    /// `auto`.
14691    Auto,
14692    /// `crispEdges`.
14693    CrispEdges,
14694    /// `geometricPrecision`.
14695    GeometricPrecision,
14696    /// `optimizeSpeed`.
14697    OptimizeSpeed,
14698}
14699
14700impl fmt::Display for ShapeRendering {
14701    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14702        match self {
14703            Self::Auto => f.write_str("auto"),
14704            Self::CrispEdges => f.write_str("crispEdges"),
14705            Self::GeometricPrecision => f.write_str("geometricPrecision"),
14706            Self::OptimizeSpeed => f.write_str("optimizeSpeed"),
14707        }
14708    }
14709}
14710
14711/// A value of [`stop-opacity`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/stop-opacity).
14712#[derive(Debug, Clone, PartialEq)]
14713#[non_exhaustive]
14714pub enum StopOpacity {
14715    /// A percentage.
14716    Percentage(Percentage),
14717    /// A number.
14718    Number(f64),
14719}
14720
14721impl fmt::Display for StopOpacity {
14722    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14723        match self {
14724            Self::Percentage(v) => v.fmt(f),
14725            Self::Number(v) => v.fmt(f),
14726        }
14727    }
14728}
14729
14730impl From<Percentage> for StopOpacity {
14731    fn from(v: Percentage) -> Self {
14732        Self::Percentage(v)
14733    }
14734}
14735
14736impl From<f64> for StopOpacity {
14737    fn from(v: f64) -> Self {
14738        Self::Number(v)
14739    }
14740}
14741
14742impl From<i32> for StopOpacity {
14743    fn from(v: i32) -> Self {
14744        Self::Number(f64::from(v))
14745    }
14746}
14747
14748/// A value of [`stroke`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/stroke).
14749#[derive(Debug, Clone, PartialEq)]
14750#[non_exhaustive]
14751pub enum Stroke {
14752    /// `context-fill`.
14753    ContextFill,
14754    /// `context-stroke`.
14755    ContextStroke,
14756    /// `none`.
14757    None,
14758    /// A color.
14759    Color(Color),
14760    /// A URL.
14761    Url(Url),
14762    /// Any other value, passed through unchecked.
14763    Raw(Raw),
14764}
14765
14766impl fmt::Display for Stroke {
14767    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14768        match self {
14769            Self::ContextFill => f.write_str("context-fill"),
14770            Self::ContextStroke => f.write_str("context-stroke"),
14771            Self::None => f.write_str("none"),
14772            Self::Color(v) => v.fmt(f),
14773            Self::Url(v) => v.fmt(f),
14774            Self::Raw(v) => v.fmt(f),
14775        }
14776    }
14777}
14778
14779impl From<Color> for Stroke {
14780    fn from(v: Color) -> Self {
14781        Self::Color(v)
14782    }
14783}
14784
14785impl From<Url> for Stroke {
14786    fn from(v: Url) -> Self {
14787        Self::Url(v)
14788    }
14789}
14790
14791impl From<Raw> for Stroke {
14792    fn from(v: Raw) -> Self {
14793        Self::Raw(v)
14794    }
14795}
14796
14797/// A value of [`stroke-dasharray`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/stroke-dasharray).
14798#[derive(Debug, Clone, PartialEq)]
14799#[non_exhaustive]
14800pub enum StrokeDasharray {
14801    /// `none`.
14802    None,
14803    /// A length.
14804    Length(Length),
14805    /// A percentage.
14806    Percentage(Percentage),
14807    /// A number.
14808    Number(f64),
14809    /// Any other value, passed through unchecked.
14810    Raw(Raw),
14811}
14812
14813impl fmt::Display for StrokeDasharray {
14814    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14815        match self {
14816            Self::None => f.write_str("none"),
14817            Self::Length(v) => v.fmt(f),
14818            Self::Percentage(v) => v.fmt(f),
14819            Self::Number(v) => v.fmt(f),
14820            Self::Raw(v) => v.fmt(f),
14821        }
14822    }
14823}
14824
14825impl From<Length> for StrokeDasharray {
14826    fn from(v: Length) -> Self {
14827        Self::Length(v)
14828    }
14829}
14830
14831impl From<Percentage> for StrokeDasharray {
14832    fn from(v: Percentage) -> Self {
14833        Self::Percentage(v)
14834    }
14835}
14836
14837impl From<f64> for StrokeDasharray {
14838    fn from(v: f64) -> Self {
14839        Self::Number(v)
14840    }
14841}
14842
14843impl From<i32> for StrokeDasharray {
14844    fn from(v: i32) -> Self {
14845        Self::Number(f64::from(v))
14846    }
14847}
14848
14849impl From<Raw> for StrokeDasharray {
14850    fn from(v: Raw) -> Self {
14851        Self::Raw(v)
14852    }
14853}
14854
14855/// A value of [`stroke-dashoffset`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/stroke-dashoffset).
14856#[derive(Debug, Clone, PartialEq)]
14857#[non_exhaustive]
14858pub enum StrokeDashoffset {
14859    /// A length.
14860    Length(Length),
14861    /// A percentage.
14862    Percentage(Percentage),
14863    /// A number.
14864    Number(f64),
14865}
14866
14867impl fmt::Display for StrokeDashoffset {
14868    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14869        match self {
14870            Self::Length(v) => v.fmt(f),
14871            Self::Percentage(v) => v.fmt(f),
14872            Self::Number(v) => v.fmt(f),
14873        }
14874    }
14875}
14876
14877impl From<Length> for StrokeDashoffset {
14878    fn from(v: Length) -> Self {
14879        Self::Length(v)
14880    }
14881}
14882
14883impl From<Percentage> for StrokeDashoffset {
14884    fn from(v: Percentage) -> Self {
14885        Self::Percentage(v)
14886    }
14887}
14888
14889impl From<f64> for StrokeDashoffset {
14890    fn from(v: f64) -> Self {
14891        Self::Number(v)
14892    }
14893}
14894
14895impl From<i32> for StrokeDashoffset {
14896    fn from(v: i32) -> Self {
14897        Self::Number(f64::from(v))
14898    }
14899}
14900
14901/// A value of [`stroke-linecap`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/stroke-linecap).
14902#[derive(Debug, Clone, PartialEq)]
14903#[non_exhaustive]
14904pub enum StrokeLinecap {
14905    /// `butt`.
14906    Butt,
14907    /// `round`.
14908    Round,
14909    /// `square`.
14910    Square,
14911}
14912
14913impl fmt::Display for StrokeLinecap {
14914    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14915        match self {
14916            Self::Butt => f.write_str("butt"),
14917            Self::Round => f.write_str("round"),
14918            Self::Square => f.write_str("square"),
14919        }
14920    }
14921}
14922
14923/// A value of [`stroke-linejoin`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/stroke-linejoin).
14924#[derive(Debug, Clone, PartialEq)]
14925#[non_exhaustive]
14926pub enum StrokeLinejoin {
14927    /// `arcs`.
14928    Arcs,
14929    /// `bevel`.
14930    Bevel,
14931    /// `miter`.
14932    Miter,
14933    /// `miter-clip`.
14934    MiterClip,
14935    /// `round`.
14936    Round,
14937}
14938
14939impl fmt::Display for StrokeLinejoin {
14940    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14941        match self {
14942            Self::Arcs => f.write_str("arcs"),
14943            Self::Bevel => f.write_str("bevel"),
14944            Self::Miter => f.write_str("miter"),
14945            Self::MiterClip => f.write_str("miter-clip"),
14946            Self::Round => f.write_str("round"),
14947        }
14948    }
14949}
14950
14951/// A value of [`stroke-opacity`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/stroke-opacity).
14952#[derive(Debug, Clone, PartialEq)]
14953#[non_exhaustive]
14954pub enum StrokeOpacity {
14955    /// A percentage.
14956    Percentage(Percentage),
14957    /// A number.
14958    Number(f64),
14959}
14960
14961impl fmt::Display for StrokeOpacity {
14962    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14963        match self {
14964            Self::Percentage(v) => v.fmt(f),
14965            Self::Number(v) => v.fmt(f),
14966        }
14967    }
14968}
14969
14970impl From<Percentage> for StrokeOpacity {
14971    fn from(v: Percentage) -> Self {
14972        Self::Percentage(v)
14973    }
14974}
14975
14976impl From<f64> for StrokeOpacity {
14977    fn from(v: f64) -> Self {
14978        Self::Number(v)
14979    }
14980}
14981
14982impl From<i32> for StrokeOpacity {
14983    fn from(v: i32) -> Self {
14984        Self::Number(f64::from(v))
14985    }
14986}
14987
14988/// A value of [`stroke-width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/stroke-width).
14989#[derive(Debug, Clone, PartialEq)]
14990#[non_exhaustive]
14991pub enum StrokeWidth {
14992    /// A length.
14993    Length(Length),
14994    /// A percentage.
14995    Percentage(Percentage),
14996    /// A number.
14997    Number(f64),
14998}
14999
15000impl fmt::Display for StrokeWidth {
15001    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15002        match self {
15003            Self::Length(v) => v.fmt(f),
15004            Self::Percentage(v) => v.fmt(f),
15005            Self::Number(v) => v.fmt(f),
15006        }
15007    }
15008}
15009
15010impl From<Length> for StrokeWidth {
15011    fn from(v: Length) -> Self {
15012        Self::Length(v)
15013    }
15014}
15015
15016impl From<Percentage> for StrokeWidth {
15017    fn from(v: Percentage) -> Self {
15018        Self::Percentage(v)
15019    }
15020}
15021
15022impl From<f64> for StrokeWidth {
15023    fn from(v: f64) -> Self {
15024        Self::Number(v)
15025    }
15026}
15027
15028impl From<i32> for StrokeWidth {
15029    fn from(v: i32) -> Self {
15030        Self::Number(f64::from(v))
15031    }
15032}
15033
15034/// A value of [`tab-size`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/tab-size).
15035#[derive(Debug, Clone, PartialEq)]
15036#[non_exhaustive]
15037pub enum TabSize {
15038    /// A length.
15039    Length(Length),
15040    /// An integer.
15041    Integer(i32),
15042}
15043
15044impl fmt::Display for TabSize {
15045    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15046        match self {
15047            Self::Length(v) => v.fmt(f),
15048            Self::Integer(v) => v.fmt(f),
15049        }
15050    }
15051}
15052
15053impl From<Length> for TabSize {
15054    fn from(v: Length) -> Self {
15055        Self::Length(v)
15056    }
15057}
15058
15059impl From<i32> for TabSize {
15060    fn from(v: i32) -> Self {
15061        Self::Integer(v)
15062    }
15063}
15064
15065/// A value of [`table-layout`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/table-layout).
15066#[derive(Debug, Clone, PartialEq)]
15067#[non_exhaustive]
15068pub enum TableLayout {
15069    /// `auto`.
15070    Auto,
15071    /// `fixed`.
15072    Fixed,
15073}
15074
15075impl fmt::Display for TableLayout {
15076    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15077        match self {
15078            Self::Auto => f.write_str("auto"),
15079            Self::Fixed => f.write_str("fixed"),
15080        }
15081    }
15082}
15083
15084/// A value of [`text-align`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-align).
15085#[derive(Debug, Clone, PartialEq)]
15086#[non_exhaustive]
15087pub enum TextAlign {
15088    /// `center`.
15089    Center,
15090    /// `end`.
15091    End,
15092    /// `justify`.
15093    Justify,
15094    /// `left`.
15095    Left,
15096    /// `match-parent`.
15097    MatchParent,
15098    /// `right`.
15099    Right,
15100    /// `start`.
15101    Start,
15102}
15103
15104impl fmt::Display for TextAlign {
15105    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15106        match self {
15107            Self::Center => f.write_str("center"),
15108            Self::End => f.write_str("end"),
15109            Self::Justify => f.write_str("justify"),
15110            Self::Left => f.write_str("left"),
15111            Self::MatchParent => f.write_str("match-parent"),
15112            Self::Right => f.write_str("right"),
15113            Self::Start => f.write_str("start"),
15114        }
15115    }
15116}
15117
15118/// A value of [`text-align-last`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-align-last).
15119#[derive(Debug, Clone, PartialEq)]
15120#[non_exhaustive]
15121pub enum TextAlignLast {
15122    /// `auto`.
15123    Auto,
15124    /// `center`.
15125    Center,
15126    /// `end`.
15127    End,
15128    /// `justify`.
15129    Justify,
15130    /// `left`.
15131    Left,
15132    /// `right`.
15133    Right,
15134    /// `start`.
15135    Start,
15136}
15137
15138impl fmt::Display for TextAlignLast {
15139    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15140        match self {
15141            Self::Auto => f.write_str("auto"),
15142            Self::Center => f.write_str("center"),
15143            Self::End => f.write_str("end"),
15144            Self::Justify => f.write_str("justify"),
15145            Self::Left => f.write_str("left"),
15146            Self::Right => f.write_str("right"),
15147            Self::Start => f.write_str("start"),
15148        }
15149    }
15150}
15151
15152/// A value of [`text-anchor`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-anchor).
15153#[derive(Debug, Clone, PartialEq)]
15154#[non_exhaustive]
15155pub enum TextAnchor {
15156    /// `end`.
15157    End,
15158    /// `middle`.
15159    Middle,
15160    /// `start`.
15161    Start,
15162}
15163
15164impl fmt::Display for TextAnchor {
15165    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15166        match self {
15167            Self::End => f.write_str("end"),
15168            Self::Middle => f.write_str("middle"),
15169            Self::Start => f.write_str("start"),
15170        }
15171    }
15172}
15173
15174/// A value of [`text-autospace`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-autospace).
15175#[derive(Debug, Clone, PartialEq)]
15176#[non_exhaustive]
15177pub enum TextAutospace {
15178    /// `auto`.
15179    Auto,
15180    /// `normal`.
15181    Normal,
15182    /// Any other value, passed through unchecked.
15183    Raw(Raw),
15184}
15185
15186impl fmt::Display for TextAutospace {
15187    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15188        match self {
15189            Self::Auto => f.write_str("auto"),
15190            Self::Normal => f.write_str("normal"),
15191            Self::Raw(v) => v.fmt(f),
15192        }
15193    }
15194}
15195
15196impl From<Raw> for TextAutospace {
15197    fn from(v: Raw) -> Self {
15198        Self::Raw(v)
15199    }
15200}
15201
15202/// A value of [`text-box`]().
15203#[derive(Debug, Clone, PartialEq)]
15204#[non_exhaustive]
15205pub enum TextBox {
15206    /// `auto`.
15207    Auto,
15208    /// `cap`.
15209    Cap,
15210    /// `ex`.
15211    Ex,
15212    /// `ideographic`.
15213    Ideographic,
15214    /// `ideographic-ink`.
15215    IdeographicInk,
15216    /// `none`.
15217    None,
15218    /// `normal`.
15219    Normal,
15220    /// `text`.
15221    Text,
15222    /// `trim-both`.
15223    TrimBoth,
15224    /// `trim-end`.
15225    TrimEnd,
15226    /// `trim-start`.
15227    TrimStart,
15228    /// Any other value, passed through unchecked.
15229    Raw(Raw),
15230}
15231
15232impl fmt::Display for TextBox {
15233    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15234        match self {
15235            Self::Auto => f.write_str("auto"),
15236            Self::Cap => f.write_str("cap"),
15237            Self::Ex => f.write_str("ex"),
15238            Self::Ideographic => f.write_str("ideographic"),
15239            Self::IdeographicInk => f.write_str("ideographic-ink"),
15240            Self::None => f.write_str("none"),
15241            Self::Normal => f.write_str("normal"),
15242            Self::Text => f.write_str("text"),
15243            Self::TrimBoth => f.write_str("trim-both"),
15244            Self::TrimEnd => f.write_str("trim-end"),
15245            Self::TrimStart => f.write_str("trim-start"),
15246            Self::Raw(v) => v.fmt(f),
15247        }
15248    }
15249}
15250
15251impl From<Raw> for TextBox {
15252    fn from(v: Raw) -> Self {
15253        Self::Raw(v)
15254    }
15255}
15256
15257/// A value of [`text-box-edge`]().
15258#[derive(Debug, Clone, PartialEq)]
15259#[non_exhaustive]
15260pub enum TextBoxEdge {
15261    /// `auto`.
15262    Auto,
15263    /// `cap`.
15264    Cap,
15265    /// `ex`.
15266    Ex,
15267    /// `ideographic`.
15268    Ideographic,
15269    /// `ideographic-ink`.
15270    IdeographicInk,
15271    /// `text`.
15272    Text,
15273    /// Any other value, passed through unchecked.
15274    Raw(Raw),
15275}
15276
15277impl fmt::Display for TextBoxEdge {
15278    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15279        match self {
15280            Self::Auto => f.write_str("auto"),
15281            Self::Cap => f.write_str("cap"),
15282            Self::Ex => f.write_str("ex"),
15283            Self::Ideographic => f.write_str("ideographic"),
15284            Self::IdeographicInk => f.write_str("ideographic-ink"),
15285            Self::Text => f.write_str("text"),
15286            Self::Raw(v) => v.fmt(f),
15287        }
15288    }
15289}
15290
15291impl From<Raw> for TextBoxEdge {
15292    fn from(v: Raw) -> Self {
15293        Self::Raw(v)
15294    }
15295}
15296
15297/// A value of [`text-box-trim`]().
15298#[derive(Debug, Clone, PartialEq)]
15299#[non_exhaustive]
15300pub enum TextBoxTrim {
15301    /// `none`.
15302    None,
15303    /// `trim-both`.
15304    TrimBoth,
15305    /// `trim-end`.
15306    TrimEnd,
15307    /// `trim-start`.
15308    TrimStart,
15309}
15310
15311impl fmt::Display for TextBoxTrim {
15312    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15313        match self {
15314            Self::None => f.write_str("none"),
15315            Self::TrimBoth => f.write_str("trim-both"),
15316            Self::TrimEnd => f.write_str("trim-end"),
15317            Self::TrimStart => f.write_str("trim-start"),
15318        }
15319    }
15320}
15321
15322/// A value of [`text-combine-upright`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-combine-upright).
15323#[derive(Debug, Clone, PartialEq)]
15324#[non_exhaustive]
15325pub enum TextCombineUpright {
15326    /// `all`.
15327    All,
15328    /// `digits`.
15329    Digits,
15330    /// `none`.
15331    None,
15332    /// Any other value, passed through unchecked.
15333    Raw(Raw),
15334}
15335
15336impl fmt::Display for TextCombineUpright {
15337    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15338        match self {
15339            Self::All => f.write_str("all"),
15340            Self::Digits => f.write_str("digits"),
15341            Self::None => f.write_str("none"),
15342            Self::Raw(v) => v.fmt(f),
15343        }
15344    }
15345}
15346
15347impl From<Raw> for TextCombineUpright {
15348    fn from(v: Raw) -> Self {
15349        Self::Raw(v)
15350    }
15351}
15352
15353/// A value of [`text-decoration`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-decoration).
15354#[derive(Debug, Clone, PartialEq)]
15355#[non_exhaustive]
15356pub enum TextDecoration {
15357    /// `auto`.
15358    Auto,
15359    /// `blink`.
15360    Blink,
15361    /// `dashed`.
15362    Dashed,
15363    /// `dotted`.
15364    Dotted,
15365    /// `double`.
15366    Double,
15367    /// `from-font`.
15368    FromFont,
15369    /// `grammar-error`.
15370    GrammarError,
15371    /// `line-through`.
15372    LineThrough,
15373    /// `none`.
15374    None,
15375    /// `overline`.
15376    Overline,
15377    /// `solid`.
15378    Solid,
15379    /// `spelling-error`.
15380    SpellingError,
15381    /// `underline`.
15382    Underline,
15383    /// `wavy`.
15384    Wavy,
15385    /// A length.
15386    Length(Length),
15387    /// A percentage.
15388    Percentage(Percentage),
15389    /// A color.
15390    Color(Color),
15391    /// Any other value, passed through unchecked.
15392    Raw(Raw),
15393}
15394
15395impl fmt::Display for TextDecoration {
15396    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15397        match self {
15398            Self::Auto => f.write_str("auto"),
15399            Self::Blink => f.write_str("blink"),
15400            Self::Dashed => f.write_str("dashed"),
15401            Self::Dotted => f.write_str("dotted"),
15402            Self::Double => f.write_str("double"),
15403            Self::FromFont => f.write_str("from-font"),
15404            Self::GrammarError => f.write_str("grammar-error"),
15405            Self::LineThrough => f.write_str("line-through"),
15406            Self::None => f.write_str("none"),
15407            Self::Overline => f.write_str("overline"),
15408            Self::Solid => f.write_str("solid"),
15409            Self::SpellingError => f.write_str("spelling-error"),
15410            Self::Underline => f.write_str("underline"),
15411            Self::Wavy => f.write_str("wavy"),
15412            Self::Length(v) => v.fmt(f),
15413            Self::Percentage(v) => v.fmt(f),
15414            Self::Color(v) => v.fmt(f),
15415            Self::Raw(v) => v.fmt(f),
15416        }
15417    }
15418}
15419
15420impl From<Length> for TextDecoration {
15421    fn from(v: Length) -> Self {
15422        Self::Length(v)
15423    }
15424}
15425
15426impl From<Percentage> for TextDecoration {
15427    fn from(v: Percentage) -> Self {
15428        Self::Percentage(v)
15429    }
15430}
15431
15432impl From<Color> for TextDecoration {
15433    fn from(v: Color) -> Self {
15434        Self::Color(v)
15435    }
15436}
15437
15438impl From<Raw> for TextDecoration {
15439    fn from(v: Raw) -> Self {
15440        Self::Raw(v)
15441    }
15442}
15443
15444/// A value of [`text-decoration-inset`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-decoration-inset).
15445#[derive(Debug, Clone, PartialEq)]
15446#[non_exhaustive]
15447pub enum TextDecorationInset {
15448    /// `auto`.
15449    Auto,
15450    /// A length.
15451    Length(Length),
15452    /// A percentage.
15453    Percentage(Percentage),
15454    /// Any other value, passed through unchecked.
15455    Raw(Raw),
15456}
15457
15458impl fmt::Display for TextDecorationInset {
15459    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15460        match self {
15461            Self::Auto => f.write_str("auto"),
15462            Self::Length(v) => v.fmt(f),
15463            Self::Percentage(v) => v.fmt(f),
15464            Self::Raw(v) => v.fmt(f),
15465        }
15466    }
15467}
15468
15469impl From<Length> for TextDecorationInset {
15470    fn from(v: Length) -> Self {
15471        Self::Length(v)
15472    }
15473}
15474
15475impl From<Percentage> for TextDecorationInset {
15476    fn from(v: Percentage) -> Self {
15477        Self::Percentage(v)
15478    }
15479}
15480
15481impl From<Raw> for TextDecorationInset {
15482    fn from(v: Raw) -> Self {
15483        Self::Raw(v)
15484    }
15485}
15486
15487/// A value of [`text-decoration-line`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-decoration-line).
15488#[derive(Debug, Clone, PartialEq)]
15489#[non_exhaustive]
15490pub enum TextDecorationLine {
15491    /// `blink`.
15492    Blink,
15493    /// `grammar-error`.
15494    GrammarError,
15495    /// `line-through`.
15496    LineThrough,
15497    /// `none`.
15498    None,
15499    /// `overline`.
15500    Overline,
15501    /// `spelling-error`.
15502    SpellingError,
15503    /// `underline`.
15504    Underline,
15505    /// Any other value, passed through unchecked.
15506    Raw(Raw),
15507}
15508
15509impl fmt::Display for TextDecorationLine {
15510    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15511        match self {
15512            Self::Blink => f.write_str("blink"),
15513            Self::GrammarError => f.write_str("grammar-error"),
15514            Self::LineThrough => f.write_str("line-through"),
15515            Self::None => f.write_str("none"),
15516            Self::Overline => f.write_str("overline"),
15517            Self::SpellingError => f.write_str("spelling-error"),
15518            Self::Underline => f.write_str("underline"),
15519            Self::Raw(v) => v.fmt(f),
15520        }
15521    }
15522}
15523
15524impl From<Raw> for TextDecorationLine {
15525    fn from(v: Raw) -> Self {
15526        Self::Raw(v)
15527    }
15528}
15529
15530/// A value of [`text-decoration-skip-ink`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-decoration-skip-ink).
15531#[derive(Debug, Clone, PartialEq)]
15532#[non_exhaustive]
15533pub enum TextDecorationSkipInk {
15534    /// `all`.
15535    All,
15536    /// `auto`.
15537    Auto,
15538    /// `none`.
15539    None,
15540}
15541
15542impl fmt::Display for TextDecorationSkipInk {
15543    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15544        match self {
15545            Self::All => f.write_str("all"),
15546            Self::Auto => f.write_str("auto"),
15547            Self::None => f.write_str("none"),
15548        }
15549    }
15550}
15551
15552/// A value of [`text-decoration-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-decoration-style).
15553#[derive(Debug, Clone, PartialEq)]
15554#[non_exhaustive]
15555pub enum TextDecorationStyle {
15556    /// `dashed`.
15557    Dashed,
15558    /// `dotted`.
15559    Dotted,
15560    /// `double`.
15561    Double,
15562    /// `solid`.
15563    Solid,
15564    /// `wavy`.
15565    Wavy,
15566}
15567
15568impl fmt::Display for TextDecorationStyle {
15569    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15570        match self {
15571            Self::Dashed => f.write_str("dashed"),
15572            Self::Dotted => f.write_str("dotted"),
15573            Self::Double => f.write_str("double"),
15574            Self::Solid => f.write_str("solid"),
15575            Self::Wavy => f.write_str("wavy"),
15576        }
15577    }
15578}
15579
15580/// A value of [`text-decoration-thickness`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-decoration-thickness).
15581#[derive(Debug, Clone, PartialEq)]
15582#[non_exhaustive]
15583pub enum TextDecorationThickness {
15584    /// `auto`.
15585    Auto,
15586    /// `from-font`.
15587    FromFont,
15588    /// A length.
15589    Length(Length),
15590    /// A percentage.
15591    Percentage(Percentage),
15592}
15593
15594impl fmt::Display for TextDecorationThickness {
15595    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15596        match self {
15597            Self::Auto => f.write_str("auto"),
15598            Self::FromFont => f.write_str("from-font"),
15599            Self::Length(v) => v.fmt(f),
15600            Self::Percentage(v) => v.fmt(f),
15601        }
15602    }
15603}
15604
15605impl From<Length> for TextDecorationThickness {
15606    fn from(v: Length) -> Self {
15607        Self::Length(v)
15608    }
15609}
15610
15611impl From<Percentage> for TextDecorationThickness {
15612    fn from(v: Percentage) -> Self {
15613        Self::Percentage(v)
15614    }
15615}
15616
15617/// A value of [`text-emphasis`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-emphasis).
15618#[derive(Debug, Clone, PartialEq)]
15619#[non_exhaustive]
15620pub enum TextEmphasis {
15621    /// `circle`.
15622    Circle,
15623    /// `dot`.
15624    Dot,
15625    /// `double-circle`.
15626    DoubleCircle,
15627    /// `filled`.
15628    Filled,
15629    /// `none`.
15630    None,
15631    /// `open`.
15632    Open,
15633    /// `sesame`.
15634    Sesame,
15635    /// `triangle`.
15636    Triangle,
15637    /// A color.
15638    Color(Color),
15639    /// A quoted string.
15640    Quoted(Quoted),
15641    /// Any other value, passed through unchecked.
15642    Raw(Raw),
15643}
15644
15645impl fmt::Display for TextEmphasis {
15646    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15647        match self {
15648            Self::Circle => f.write_str("circle"),
15649            Self::Dot => f.write_str("dot"),
15650            Self::DoubleCircle => f.write_str("double-circle"),
15651            Self::Filled => f.write_str("filled"),
15652            Self::None => f.write_str("none"),
15653            Self::Open => f.write_str("open"),
15654            Self::Sesame => f.write_str("sesame"),
15655            Self::Triangle => f.write_str("triangle"),
15656            Self::Color(v) => v.fmt(f),
15657            Self::Quoted(v) => v.fmt(f),
15658            Self::Raw(v) => v.fmt(f),
15659        }
15660    }
15661}
15662
15663impl From<Color> for TextEmphasis {
15664    fn from(v: Color) -> Self {
15665        Self::Color(v)
15666    }
15667}
15668
15669impl From<Quoted> for TextEmphasis {
15670    fn from(v: Quoted) -> Self {
15671        Self::Quoted(v)
15672    }
15673}
15674
15675impl From<Raw> for TextEmphasis {
15676    fn from(v: Raw) -> Self {
15677        Self::Raw(v)
15678    }
15679}
15680
15681/// A value of [`text-emphasis-position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-emphasis-position).
15682#[derive(Debug, Clone, PartialEq)]
15683#[non_exhaustive]
15684pub enum TextEmphasisPosition {
15685    /// `auto`.
15686    Auto,
15687    /// Any other value, passed through unchecked.
15688    Raw(Raw),
15689}
15690
15691impl fmt::Display for TextEmphasisPosition {
15692    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15693        match self {
15694            Self::Auto => f.write_str("auto"),
15695            Self::Raw(v) => v.fmt(f),
15696        }
15697    }
15698}
15699
15700impl From<Raw> for TextEmphasisPosition {
15701    fn from(v: Raw) -> Self {
15702        Self::Raw(v)
15703    }
15704}
15705
15706/// A value of [`text-emphasis-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-emphasis-style).
15707#[derive(Debug, Clone, PartialEq)]
15708#[non_exhaustive]
15709pub enum TextEmphasisStyle {
15710    /// `circle`.
15711    Circle,
15712    /// `dot`.
15713    Dot,
15714    /// `double-circle`.
15715    DoubleCircle,
15716    /// `filled`.
15717    Filled,
15718    /// `none`.
15719    None,
15720    /// `open`.
15721    Open,
15722    /// `sesame`.
15723    Sesame,
15724    /// `triangle`.
15725    Triangle,
15726    /// A quoted string.
15727    Quoted(Quoted),
15728    /// Any other value, passed through unchecked.
15729    Raw(Raw),
15730}
15731
15732impl fmt::Display for TextEmphasisStyle {
15733    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15734        match self {
15735            Self::Circle => f.write_str("circle"),
15736            Self::Dot => f.write_str("dot"),
15737            Self::DoubleCircle => f.write_str("double-circle"),
15738            Self::Filled => f.write_str("filled"),
15739            Self::None => f.write_str("none"),
15740            Self::Open => f.write_str("open"),
15741            Self::Sesame => f.write_str("sesame"),
15742            Self::Triangle => f.write_str("triangle"),
15743            Self::Quoted(v) => v.fmt(f),
15744            Self::Raw(v) => v.fmt(f),
15745        }
15746    }
15747}
15748
15749impl From<Quoted> for TextEmphasisStyle {
15750    fn from(v: Quoted) -> Self {
15751        Self::Quoted(v)
15752    }
15753}
15754
15755impl From<Raw> for TextEmphasisStyle {
15756    fn from(v: Raw) -> Self {
15757        Self::Raw(v)
15758    }
15759}
15760
15761/// A value of [`text-fit`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-fit).
15762#[derive(Debug, Clone, PartialEq)]
15763#[non_exhaustive]
15764pub enum TextFit {
15765    /// `grow`.
15766    Grow,
15767    /// `none`.
15768    None,
15769    /// `shrink`.
15770    Shrink,
15771    /// Any other value, passed through unchecked.
15772    Raw(Raw),
15773}
15774
15775impl fmt::Display for TextFit {
15776    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15777        match self {
15778            Self::Grow => f.write_str("grow"),
15779            Self::None => f.write_str("none"),
15780            Self::Shrink => f.write_str("shrink"),
15781            Self::Raw(v) => v.fmt(f),
15782        }
15783    }
15784}
15785
15786impl From<Raw> for TextFit {
15787    fn from(v: Raw) -> Self {
15788        Self::Raw(v)
15789    }
15790}
15791
15792/// A value of [`text-indent`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-indent).
15793#[derive(Debug, Clone, PartialEq)]
15794#[non_exhaustive]
15795pub enum TextIndent {
15796    /// Any other value, passed through unchecked.
15797    Raw(Raw),
15798}
15799
15800impl fmt::Display for TextIndent {
15801    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15802        match self {
15803            Self::Raw(v) => v.fmt(f),
15804        }
15805    }
15806}
15807
15808impl From<Raw> for TextIndent {
15809    fn from(v: Raw) -> Self {
15810        Self::Raw(v)
15811    }
15812}
15813
15814/// A value of [`text-justify`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-justify).
15815#[derive(Debug, Clone, PartialEq)]
15816#[non_exhaustive]
15817pub enum TextJustify {
15818    /// `auto`.
15819    Auto,
15820    /// `inter-character`.
15821    InterCharacter,
15822    /// `inter-word`.
15823    InterWord,
15824    /// `none`.
15825    None,
15826}
15827
15828impl fmt::Display for TextJustify {
15829    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15830        match self {
15831            Self::Auto => f.write_str("auto"),
15832            Self::InterCharacter => f.write_str("inter-character"),
15833            Self::InterWord => f.write_str("inter-word"),
15834            Self::None => f.write_str("none"),
15835        }
15836    }
15837}
15838
15839/// A value of [`text-orientation`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-orientation).
15840#[derive(Debug, Clone, PartialEq)]
15841#[non_exhaustive]
15842pub enum TextOrientation {
15843    /// `mixed`.
15844    Mixed,
15845    /// `sideways`.
15846    Sideways,
15847    /// `upright`.
15848    Upright,
15849}
15850
15851impl fmt::Display for TextOrientation {
15852    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15853        match self {
15854            Self::Mixed => f.write_str("mixed"),
15855            Self::Sideways => f.write_str("sideways"),
15856            Self::Upright => f.write_str("upright"),
15857        }
15858    }
15859}
15860
15861/// A value of [`text-overflow`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-overflow).
15862#[derive(Debug, Clone, PartialEq)]
15863#[non_exhaustive]
15864pub enum TextOverflow {
15865    /// `clip`.
15866    Clip,
15867    /// `ellipsis`.
15868    Ellipsis,
15869    /// A quoted string.
15870    Quoted(Quoted),
15871    /// Any other value, passed through unchecked.
15872    Raw(Raw),
15873}
15874
15875impl fmt::Display for TextOverflow {
15876    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15877        match self {
15878            Self::Clip => f.write_str("clip"),
15879            Self::Ellipsis => f.write_str("ellipsis"),
15880            Self::Quoted(v) => v.fmt(f),
15881            Self::Raw(v) => v.fmt(f),
15882        }
15883    }
15884}
15885
15886impl From<Quoted> for TextOverflow {
15887    fn from(v: Quoted) -> Self {
15888        Self::Quoted(v)
15889    }
15890}
15891
15892impl From<Raw> for TextOverflow {
15893    fn from(v: Raw) -> Self {
15894        Self::Raw(v)
15895    }
15896}
15897
15898/// A value of [`text-rendering`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-rendering).
15899#[derive(Debug, Clone, PartialEq)]
15900#[non_exhaustive]
15901pub enum TextRendering {
15902    /// `auto`.
15903    Auto,
15904    /// `geometricPrecision`.
15905    GeometricPrecision,
15906    /// `optimizeLegibility`.
15907    OptimizeLegibility,
15908    /// `optimizeSpeed`.
15909    OptimizeSpeed,
15910}
15911
15912impl fmt::Display for TextRendering {
15913    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15914        match self {
15915            Self::Auto => f.write_str("auto"),
15916            Self::GeometricPrecision => f.write_str("geometricPrecision"),
15917            Self::OptimizeLegibility => f.write_str("optimizeLegibility"),
15918            Self::OptimizeSpeed => f.write_str("optimizeSpeed"),
15919        }
15920    }
15921}
15922
15923/// A value of [`text-shadow`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-shadow).
15924#[derive(Debug, Clone, PartialEq)]
15925#[non_exhaustive]
15926pub enum TextShadow {
15927    /// `none`.
15928    None,
15929    /// Any other value, passed through unchecked.
15930    Raw(Raw),
15931}
15932
15933impl fmt::Display for TextShadow {
15934    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15935        match self {
15936            Self::None => f.write_str("none"),
15937            Self::Raw(v) => v.fmt(f),
15938        }
15939    }
15940}
15941
15942impl From<Raw> for TextShadow {
15943    fn from(v: Raw) -> Self {
15944        Self::Raw(v)
15945    }
15946}
15947
15948/// A value of [`text-transform`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-transform).
15949#[derive(Debug, Clone, PartialEq)]
15950#[non_exhaustive]
15951pub enum TextTransform {
15952    /// `capitalize`.
15953    Capitalize,
15954    /// `full-size-kana`.
15955    FullSizeKana,
15956    /// `full-width`.
15957    FullWidth,
15958    /// `lowercase`.
15959    Lowercase,
15960    /// `math-auto`.
15961    MathAuto,
15962    /// `none`.
15963    None,
15964    /// `uppercase`.
15965    Uppercase,
15966    /// Any other value, passed through unchecked.
15967    Raw(Raw),
15968}
15969
15970impl fmt::Display for TextTransform {
15971    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15972        match self {
15973            Self::Capitalize => f.write_str("capitalize"),
15974            Self::FullSizeKana => f.write_str("full-size-kana"),
15975            Self::FullWidth => f.write_str("full-width"),
15976            Self::Lowercase => f.write_str("lowercase"),
15977            Self::MathAuto => f.write_str("math-auto"),
15978            Self::None => f.write_str("none"),
15979            Self::Uppercase => f.write_str("uppercase"),
15980            Self::Raw(v) => v.fmt(f),
15981        }
15982    }
15983}
15984
15985impl From<Raw> for TextTransform {
15986    fn from(v: Raw) -> Self {
15987        Self::Raw(v)
15988    }
15989}
15990
15991/// A value of [`text-underline-offset`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-underline-offset).
15992#[derive(Debug, Clone, PartialEq)]
15993#[non_exhaustive]
15994pub enum TextUnderlineOffset {
15995    /// `auto`.
15996    Auto,
15997    /// A length.
15998    Length(Length),
15999    /// A percentage.
16000    Percentage(Percentage),
16001}
16002
16003impl fmt::Display for TextUnderlineOffset {
16004    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16005        match self {
16006            Self::Auto => f.write_str("auto"),
16007            Self::Length(v) => v.fmt(f),
16008            Self::Percentage(v) => v.fmt(f),
16009        }
16010    }
16011}
16012
16013impl From<Length> for TextUnderlineOffset {
16014    fn from(v: Length) -> Self {
16015        Self::Length(v)
16016    }
16017}
16018
16019impl From<Percentage> for TextUnderlineOffset {
16020    fn from(v: Percentage) -> Self {
16021        Self::Percentage(v)
16022    }
16023}
16024
16025/// A value of [`text-underline-position`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-underline-position).
16026#[derive(Debug, Clone, PartialEq)]
16027#[non_exhaustive]
16028pub enum TextUnderlinePosition {
16029    /// `auto`.
16030    Auto,
16031    /// `from-font`.
16032    FromFont,
16033    /// `left`.
16034    Left,
16035    /// `right`.
16036    Right,
16037    /// `under`.
16038    Under,
16039    /// Any other value, passed through unchecked.
16040    Raw(Raw),
16041}
16042
16043impl fmt::Display for TextUnderlinePosition {
16044    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16045        match self {
16046            Self::Auto => f.write_str("auto"),
16047            Self::FromFont => f.write_str("from-font"),
16048            Self::Left => f.write_str("left"),
16049            Self::Right => f.write_str("right"),
16050            Self::Under => f.write_str("under"),
16051            Self::Raw(v) => v.fmt(f),
16052        }
16053    }
16054}
16055
16056impl From<Raw> for TextUnderlinePosition {
16057    fn from(v: Raw) -> Self {
16058        Self::Raw(v)
16059    }
16060}
16061
16062/// A value of [`text-wrap`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-wrap).
16063#[derive(Debug, Clone, PartialEq)]
16064#[non_exhaustive]
16065pub enum TextWrap {
16066    /// `auto`.
16067    Auto,
16068    /// `balance`.
16069    Balance,
16070    /// `nowrap`.
16071    Nowrap,
16072    /// `pretty`.
16073    Pretty,
16074    /// `stable`.
16075    Stable,
16076    /// `wrap`.
16077    Wrap,
16078    /// Any other value, passed through unchecked.
16079    Raw(Raw),
16080}
16081
16082impl fmt::Display for TextWrap {
16083    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16084        match self {
16085            Self::Auto => f.write_str("auto"),
16086            Self::Balance => f.write_str("balance"),
16087            Self::Nowrap => f.write_str("nowrap"),
16088            Self::Pretty => f.write_str("pretty"),
16089            Self::Stable => f.write_str("stable"),
16090            Self::Wrap => f.write_str("wrap"),
16091            Self::Raw(v) => v.fmt(f),
16092        }
16093    }
16094}
16095
16096impl From<Raw> for TextWrap {
16097    fn from(v: Raw) -> Self {
16098        Self::Raw(v)
16099    }
16100}
16101
16102/// A value of [`text-wrap-mode`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-wrap-mode).
16103#[derive(Debug, Clone, PartialEq)]
16104#[non_exhaustive]
16105pub enum TextWrapMode {
16106    /// `nowrap`.
16107    Nowrap,
16108    /// `wrap`.
16109    Wrap,
16110}
16111
16112impl fmt::Display for TextWrapMode {
16113    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16114        match self {
16115            Self::Nowrap => f.write_str("nowrap"),
16116            Self::Wrap => f.write_str("wrap"),
16117        }
16118    }
16119}
16120
16121/// A value of [`text-wrap-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/text-wrap-style).
16122#[derive(Debug, Clone, PartialEq)]
16123#[non_exhaustive]
16124pub enum TextWrapStyle {
16125    /// `auto`.
16126    Auto,
16127    /// `balance`.
16128    Balance,
16129    /// `pretty`.
16130    Pretty,
16131    /// `stable`.
16132    Stable,
16133}
16134
16135impl fmt::Display for TextWrapStyle {
16136    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16137        match self {
16138            Self::Auto => f.write_str("auto"),
16139            Self::Balance => f.write_str("balance"),
16140            Self::Pretty => f.write_str("pretty"),
16141            Self::Stable => f.write_str("stable"),
16142        }
16143    }
16144}
16145
16146/// A value of [`timeline-trigger`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/timeline-trigger).
16147#[derive(Debug, Clone, PartialEq)]
16148#[non_exhaustive]
16149pub enum TimelineTrigger {
16150    /// `none`.
16151    None,
16152    /// Any other value, passed through unchecked.
16153    Raw(Raw),
16154}
16155
16156impl fmt::Display for TimelineTrigger {
16157    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16158        match self {
16159            Self::None => f.write_str("none"),
16160            Self::Raw(v) => v.fmt(f),
16161        }
16162    }
16163}
16164
16165impl From<Raw> for TimelineTrigger {
16166    fn from(v: Raw) -> Self {
16167        Self::Raw(v)
16168    }
16169}
16170
16171/// A value of [`timeline-trigger-activation-range`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/timeline-trigger-activation-range).
16172#[derive(Debug, Clone, PartialEq)]
16173#[non_exhaustive]
16174pub enum TimelineTriggerActivationRange {
16175    /// `contain`.
16176    Contain,
16177    /// `cover`.
16178    Cover,
16179    /// `entry`.
16180    Entry,
16181    /// `entry-crossing`.
16182    EntryCrossing,
16183    /// `exit`.
16184    Exit,
16185    /// `exit-crossing`.
16186    ExitCrossing,
16187    /// `normal`.
16188    Normal,
16189    /// A length.
16190    Length(Length),
16191    /// A percentage.
16192    Percentage(Percentage),
16193    /// Any other value, passed through unchecked.
16194    Raw(Raw),
16195}
16196
16197impl fmt::Display for TimelineTriggerActivationRange {
16198    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16199        match self {
16200            Self::Contain => f.write_str("contain"),
16201            Self::Cover => f.write_str("cover"),
16202            Self::Entry => f.write_str("entry"),
16203            Self::EntryCrossing => f.write_str("entry-crossing"),
16204            Self::Exit => f.write_str("exit"),
16205            Self::ExitCrossing => f.write_str("exit-crossing"),
16206            Self::Normal => f.write_str("normal"),
16207            Self::Length(v) => v.fmt(f),
16208            Self::Percentage(v) => v.fmt(f),
16209            Self::Raw(v) => v.fmt(f),
16210        }
16211    }
16212}
16213
16214impl From<Length> for TimelineTriggerActivationRange {
16215    fn from(v: Length) -> Self {
16216        Self::Length(v)
16217    }
16218}
16219
16220impl From<Percentage> for TimelineTriggerActivationRange {
16221    fn from(v: Percentage) -> Self {
16222        Self::Percentage(v)
16223    }
16224}
16225
16226impl From<Raw> for TimelineTriggerActivationRange {
16227    fn from(v: Raw) -> Self {
16228        Self::Raw(v)
16229    }
16230}
16231
16232/// A value of [`timeline-trigger-activation-range-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/timeline-trigger-activation-range-end).
16233#[derive(Debug, Clone, PartialEq)]
16234#[non_exhaustive]
16235pub enum TimelineTriggerActivationRangeEnd {
16236    /// `contain`.
16237    Contain,
16238    /// `cover`.
16239    Cover,
16240    /// `entry`.
16241    Entry,
16242    /// `entry-crossing`.
16243    EntryCrossing,
16244    /// `exit`.
16245    Exit,
16246    /// `exit-crossing`.
16247    ExitCrossing,
16248    /// `normal`.
16249    Normal,
16250    /// A length.
16251    Length(Length),
16252    /// A percentage.
16253    Percentage(Percentage),
16254    /// Any other value, passed through unchecked.
16255    Raw(Raw),
16256}
16257
16258impl fmt::Display for TimelineTriggerActivationRangeEnd {
16259    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16260        match self {
16261            Self::Contain => f.write_str("contain"),
16262            Self::Cover => f.write_str("cover"),
16263            Self::Entry => f.write_str("entry"),
16264            Self::EntryCrossing => f.write_str("entry-crossing"),
16265            Self::Exit => f.write_str("exit"),
16266            Self::ExitCrossing => f.write_str("exit-crossing"),
16267            Self::Normal => f.write_str("normal"),
16268            Self::Length(v) => v.fmt(f),
16269            Self::Percentage(v) => v.fmt(f),
16270            Self::Raw(v) => v.fmt(f),
16271        }
16272    }
16273}
16274
16275impl From<Length> for TimelineTriggerActivationRangeEnd {
16276    fn from(v: Length) -> Self {
16277        Self::Length(v)
16278    }
16279}
16280
16281impl From<Percentage> for TimelineTriggerActivationRangeEnd {
16282    fn from(v: Percentage) -> Self {
16283        Self::Percentage(v)
16284    }
16285}
16286
16287impl From<Raw> for TimelineTriggerActivationRangeEnd {
16288    fn from(v: Raw) -> Self {
16289        Self::Raw(v)
16290    }
16291}
16292
16293/// A value of [`timeline-trigger-activation-range-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/timeline-trigger-activation-range-start).
16294#[derive(Debug, Clone, PartialEq)]
16295#[non_exhaustive]
16296pub enum TimelineTriggerActivationRangeStart {
16297    /// `contain`.
16298    Contain,
16299    /// `cover`.
16300    Cover,
16301    /// `entry`.
16302    Entry,
16303    /// `entry-crossing`.
16304    EntryCrossing,
16305    /// `exit`.
16306    Exit,
16307    /// `exit-crossing`.
16308    ExitCrossing,
16309    /// `normal`.
16310    Normal,
16311    /// A length.
16312    Length(Length),
16313    /// A percentage.
16314    Percentage(Percentage),
16315    /// Any other value, passed through unchecked.
16316    Raw(Raw),
16317}
16318
16319impl fmt::Display for TimelineTriggerActivationRangeStart {
16320    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16321        match self {
16322            Self::Contain => f.write_str("contain"),
16323            Self::Cover => f.write_str("cover"),
16324            Self::Entry => f.write_str("entry"),
16325            Self::EntryCrossing => f.write_str("entry-crossing"),
16326            Self::Exit => f.write_str("exit"),
16327            Self::ExitCrossing => f.write_str("exit-crossing"),
16328            Self::Normal => f.write_str("normal"),
16329            Self::Length(v) => v.fmt(f),
16330            Self::Percentage(v) => v.fmt(f),
16331            Self::Raw(v) => v.fmt(f),
16332        }
16333    }
16334}
16335
16336impl From<Length> for TimelineTriggerActivationRangeStart {
16337    fn from(v: Length) -> Self {
16338        Self::Length(v)
16339    }
16340}
16341
16342impl From<Percentage> for TimelineTriggerActivationRangeStart {
16343    fn from(v: Percentage) -> Self {
16344        Self::Percentage(v)
16345    }
16346}
16347
16348impl From<Raw> for TimelineTriggerActivationRangeStart {
16349    fn from(v: Raw) -> Self {
16350        Self::Raw(v)
16351    }
16352}
16353
16354/// A value of [`timeline-trigger-active-range`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/timeline-trigger-active-range).
16355#[derive(Debug, Clone, PartialEq)]
16356#[non_exhaustive]
16357pub enum TimelineTriggerActiveRange {
16358    /// `auto`.
16359    Auto,
16360    /// `contain`.
16361    Contain,
16362    /// `cover`.
16363    Cover,
16364    /// `entry`.
16365    Entry,
16366    /// `entry-crossing`.
16367    EntryCrossing,
16368    /// `exit`.
16369    Exit,
16370    /// `exit-crossing`.
16371    ExitCrossing,
16372    /// `normal`.
16373    Normal,
16374    /// A length.
16375    Length(Length),
16376    /// A percentage.
16377    Percentage(Percentage),
16378    /// Any other value, passed through unchecked.
16379    Raw(Raw),
16380}
16381
16382impl fmt::Display for TimelineTriggerActiveRange {
16383    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16384        match self {
16385            Self::Auto => f.write_str("auto"),
16386            Self::Contain => f.write_str("contain"),
16387            Self::Cover => f.write_str("cover"),
16388            Self::Entry => f.write_str("entry"),
16389            Self::EntryCrossing => f.write_str("entry-crossing"),
16390            Self::Exit => f.write_str("exit"),
16391            Self::ExitCrossing => f.write_str("exit-crossing"),
16392            Self::Normal => f.write_str("normal"),
16393            Self::Length(v) => v.fmt(f),
16394            Self::Percentage(v) => v.fmt(f),
16395            Self::Raw(v) => v.fmt(f),
16396        }
16397    }
16398}
16399
16400impl From<Length> for TimelineTriggerActiveRange {
16401    fn from(v: Length) -> Self {
16402        Self::Length(v)
16403    }
16404}
16405
16406impl From<Percentage> for TimelineTriggerActiveRange {
16407    fn from(v: Percentage) -> Self {
16408        Self::Percentage(v)
16409    }
16410}
16411
16412impl From<Raw> for TimelineTriggerActiveRange {
16413    fn from(v: Raw) -> Self {
16414        Self::Raw(v)
16415    }
16416}
16417
16418/// A value of [`timeline-trigger-active-range-end`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/timeline-trigger-active-range-end).
16419#[derive(Debug, Clone, PartialEq)]
16420#[non_exhaustive]
16421pub enum TimelineTriggerActiveRangeEnd {
16422    /// `auto`.
16423    Auto,
16424    /// `contain`.
16425    Contain,
16426    /// `cover`.
16427    Cover,
16428    /// `entry`.
16429    Entry,
16430    /// `entry-crossing`.
16431    EntryCrossing,
16432    /// `exit`.
16433    Exit,
16434    /// `exit-crossing`.
16435    ExitCrossing,
16436    /// `normal`.
16437    Normal,
16438    /// A length.
16439    Length(Length),
16440    /// A percentage.
16441    Percentage(Percentage),
16442    /// Any other value, passed through unchecked.
16443    Raw(Raw),
16444}
16445
16446impl fmt::Display for TimelineTriggerActiveRangeEnd {
16447    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16448        match self {
16449            Self::Auto => f.write_str("auto"),
16450            Self::Contain => f.write_str("contain"),
16451            Self::Cover => f.write_str("cover"),
16452            Self::Entry => f.write_str("entry"),
16453            Self::EntryCrossing => f.write_str("entry-crossing"),
16454            Self::Exit => f.write_str("exit"),
16455            Self::ExitCrossing => f.write_str("exit-crossing"),
16456            Self::Normal => f.write_str("normal"),
16457            Self::Length(v) => v.fmt(f),
16458            Self::Percentage(v) => v.fmt(f),
16459            Self::Raw(v) => v.fmt(f),
16460        }
16461    }
16462}
16463
16464impl From<Length> for TimelineTriggerActiveRangeEnd {
16465    fn from(v: Length) -> Self {
16466        Self::Length(v)
16467    }
16468}
16469
16470impl From<Percentage> for TimelineTriggerActiveRangeEnd {
16471    fn from(v: Percentage) -> Self {
16472        Self::Percentage(v)
16473    }
16474}
16475
16476impl From<Raw> for TimelineTriggerActiveRangeEnd {
16477    fn from(v: Raw) -> Self {
16478        Self::Raw(v)
16479    }
16480}
16481
16482/// A value of [`timeline-trigger-active-range-start`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/timeline-trigger-active-range-start).
16483#[derive(Debug, Clone, PartialEq)]
16484#[non_exhaustive]
16485pub enum TimelineTriggerActiveRangeStart {
16486    /// `auto`.
16487    Auto,
16488    /// `contain`.
16489    Contain,
16490    /// `cover`.
16491    Cover,
16492    /// `entry`.
16493    Entry,
16494    /// `entry-crossing`.
16495    EntryCrossing,
16496    /// `exit`.
16497    Exit,
16498    /// `exit-crossing`.
16499    ExitCrossing,
16500    /// `normal`.
16501    Normal,
16502    /// A length.
16503    Length(Length),
16504    /// A percentage.
16505    Percentage(Percentage),
16506    /// Any other value, passed through unchecked.
16507    Raw(Raw),
16508}
16509
16510impl fmt::Display for TimelineTriggerActiveRangeStart {
16511    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16512        match self {
16513            Self::Auto => f.write_str("auto"),
16514            Self::Contain => f.write_str("contain"),
16515            Self::Cover => f.write_str("cover"),
16516            Self::Entry => f.write_str("entry"),
16517            Self::EntryCrossing => f.write_str("entry-crossing"),
16518            Self::Exit => f.write_str("exit"),
16519            Self::ExitCrossing => f.write_str("exit-crossing"),
16520            Self::Normal => f.write_str("normal"),
16521            Self::Length(v) => v.fmt(f),
16522            Self::Percentage(v) => v.fmt(f),
16523            Self::Raw(v) => v.fmt(f),
16524        }
16525    }
16526}
16527
16528impl From<Length> for TimelineTriggerActiveRangeStart {
16529    fn from(v: Length) -> Self {
16530        Self::Length(v)
16531    }
16532}
16533
16534impl From<Percentage> for TimelineTriggerActiveRangeStart {
16535    fn from(v: Percentage) -> Self {
16536        Self::Percentage(v)
16537    }
16538}
16539
16540impl From<Raw> for TimelineTriggerActiveRangeStart {
16541    fn from(v: Raw) -> Self {
16542        Self::Raw(v)
16543    }
16544}
16545
16546/// A value of [`timeline-trigger-name`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/timeline-trigger-name).
16547#[derive(Debug, Clone, PartialEq)]
16548#[non_exhaustive]
16549pub enum TimelineTriggerName {
16550    /// `none`.
16551    None,
16552    /// Any other value, passed through unchecked.
16553    Raw(Raw),
16554}
16555
16556impl fmt::Display for TimelineTriggerName {
16557    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16558        match self {
16559            Self::None => f.write_str("none"),
16560            Self::Raw(v) => v.fmt(f),
16561        }
16562    }
16563}
16564
16565impl From<Raw> for TimelineTriggerName {
16566    fn from(v: Raw) -> Self {
16567        Self::Raw(v)
16568    }
16569}
16570
16571/// A value of [`timeline-trigger-source`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/timeline-trigger-source).
16572#[derive(Debug, Clone, PartialEq)]
16573#[non_exhaustive]
16574pub enum TimelineTriggerSource {
16575    /// `auto`.
16576    Auto,
16577    /// `none`.
16578    None,
16579    /// Any other value, passed through unchecked.
16580    Raw(Raw),
16581}
16582
16583impl fmt::Display for TimelineTriggerSource {
16584    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16585        match self {
16586            Self::Auto => f.write_str("auto"),
16587            Self::None => f.write_str("none"),
16588            Self::Raw(v) => v.fmt(f),
16589        }
16590    }
16591}
16592
16593impl From<Raw> for TimelineTriggerSource {
16594    fn from(v: Raw) -> Self {
16595        Self::Raw(v)
16596    }
16597}
16598
16599/// A value of [`top`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/top).
16600#[derive(Debug, Clone, PartialEq)]
16601#[non_exhaustive]
16602pub enum Top {
16603    /// `auto`.
16604    Auto,
16605    /// A length.
16606    Length(Length),
16607    /// A percentage.
16608    Percentage(Percentage),
16609    /// Any other value, passed through unchecked.
16610    Raw(Raw),
16611}
16612
16613impl fmt::Display for Top {
16614    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16615        match self {
16616            Self::Auto => f.write_str("auto"),
16617            Self::Length(v) => v.fmt(f),
16618            Self::Percentage(v) => v.fmt(f),
16619            Self::Raw(v) => v.fmt(f),
16620        }
16621    }
16622}
16623
16624impl From<Length> for Top {
16625    fn from(v: Length) -> Self {
16626        Self::Length(v)
16627    }
16628}
16629
16630impl From<Percentage> for Top {
16631    fn from(v: Percentage) -> Self {
16632        Self::Percentage(v)
16633    }
16634}
16635
16636impl From<Raw> for Top {
16637    fn from(v: Raw) -> Self {
16638        Self::Raw(v)
16639    }
16640}
16641
16642/// A value of [`touch-action`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/touch-action).
16643#[derive(Debug, Clone, PartialEq)]
16644#[non_exhaustive]
16645pub enum TouchAction {
16646    /// `auto`.
16647    Auto,
16648    /// `manipulation`.
16649    Manipulation,
16650    /// `none`.
16651    None,
16652    /// `pan-down`.
16653    PanDown,
16654    /// `pan-left`.
16655    PanLeft,
16656    /// `pan-right`.
16657    PanRight,
16658    /// `pan-up`.
16659    PanUp,
16660    /// `pan-x`.
16661    PanX,
16662    /// `pan-y`.
16663    PanY,
16664    /// `pinch-zoom`.
16665    PinchZoom,
16666    /// Any other value, passed through unchecked.
16667    Raw(Raw),
16668}
16669
16670impl fmt::Display for TouchAction {
16671    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16672        match self {
16673            Self::Auto => f.write_str("auto"),
16674            Self::Manipulation => f.write_str("manipulation"),
16675            Self::None => f.write_str("none"),
16676            Self::PanDown => f.write_str("pan-down"),
16677            Self::PanLeft => f.write_str("pan-left"),
16678            Self::PanRight => f.write_str("pan-right"),
16679            Self::PanUp => f.write_str("pan-up"),
16680            Self::PanX => f.write_str("pan-x"),
16681            Self::PanY => f.write_str("pan-y"),
16682            Self::PinchZoom => f.write_str("pinch-zoom"),
16683            Self::Raw(v) => v.fmt(f),
16684        }
16685    }
16686}
16687
16688impl From<Raw> for TouchAction {
16689    fn from(v: Raw) -> Self {
16690        Self::Raw(v)
16691    }
16692}
16693
16694/// A value of [`transform`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transform).
16695#[derive(Debug, Clone, PartialEq)]
16696#[non_exhaustive]
16697pub enum Transform {
16698    /// `none`.
16699    None,
16700    /// Any other value, passed through unchecked.
16701    Raw(Raw),
16702}
16703
16704impl fmt::Display for Transform {
16705    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16706        match self {
16707            Self::None => f.write_str("none"),
16708            Self::Raw(v) => v.fmt(f),
16709        }
16710    }
16711}
16712
16713impl From<Raw> for Transform {
16714    fn from(v: Raw) -> Self {
16715        Self::Raw(v)
16716    }
16717}
16718
16719/// A value of [`transform-box`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transform-box).
16720#[derive(Debug, Clone, PartialEq)]
16721#[non_exhaustive]
16722pub enum TransformBox {
16723    /// `border-box`.
16724    BorderBox,
16725    /// `content-box`.
16726    ContentBox,
16727    /// `fill-box`.
16728    FillBox,
16729    /// `stroke-box`.
16730    StrokeBox,
16731    /// `view-box`.
16732    ViewBox,
16733}
16734
16735impl fmt::Display for TransformBox {
16736    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16737        match self {
16738            Self::BorderBox => f.write_str("border-box"),
16739            Self::ContentBox => f.write_str("content-box"),
16740            Self::FillBox => f.write_str("fill-box"),
16741            Self::StrokeBox => f.write_str("stroke-box"),
16742            Self::ViewBox => f.write_str("view-box"),
16743        }
16744    }
16745}
16746
16747/// A value of [`transform-origin`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transform-origin).
16748#[derive(Debug, Clone, PartialEq)]
16749#[non_exhaustive]
16750pub enum TransformOrigin {
16751    /// `bottom`.
16752    Bottom,
16753    /// `center`.
16754    Center,
16755    /// `left`.
16756    Left,
16757    /// `right`.
16758    Right,
16759    /// `top`.
16760    Top,
16761    /// A length.
16762    Length(Length),
16763    /// A percentage.
16764    Percentage(Percentage),
16765    /// Any other value, passed through unchecked.
16766    Raw(Raw),
16767}
16768
16769impl fmt::Display for TransformOrigin {
16770    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16771        match self {
16772            Self::Bottom => f.write_str("bottom"),
16773            Self::Center => f.write_str("center"),
16774            Self::Left => f.write_str("left"),
16775            Self::Right => f.write_str("right"),
16776            Self::Top => f.write_str("top"),
16777            Self::Length(v) => v.fmt(f),
16778            Self::Percentage(v) => v.fmt(f),
16779            Self::Raw(v) => v.fmt(f),
16780        }
16781    }
16782}
16783
16784impl From<Length> for TransformOrigin {
16785    fn from(v: Length) -> Self {
16786        Self::Length(v)
16787    }
16788}
16789
16790impl From<Percentage> for TransformOrigin {
16791    fn from(v: Percentage) -> Self {
16792        Self::Percentage(v)
16793    }
16794}
16795
16796impl From<Raw> for TransformOrigin {
16797    fn from(v: Raw) -> Self {
16798        Self::Raw(v)
16799    }
16800}
16801
16802/// A value of [`transform-style`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transform-style).
16803#[derive(Debug, Clone, PartialEq)]
16804#[non_exhaustive]
16805pub enum TransformStyle {
16806    /// `flat`.
16807    Flat,
16808    /// `preserve-3d`.
16809    Preserve3d,
16810}
16811
16812impl fmt::Display for TransformStyle {
16813    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16814        match self {
16815            Self::Flat => f.write_str("flat"),
16816            Self::Preserve3d => f.write_str("preserve-3d"),
16817        }
16818    }
16819}
16820
16821/// A value of [`transition`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transition).
16822#[derive(Debug, Clone, PartialEq)]
16823#[non_exhaustive]
16824pub enum Transition {
16825    /// `all`.
16826    All,
16827    /// `allow-discrete`.
16828    AllowDiscrete,
16829    /// `ease`.
16830    Ease,
16831    /// `ease-in`.
16832    EaseIn,
16833    /// `ease-in-out`.
16834    EaseInOut,
16835    /// `ease-out`.
16836    EaseOut,
16837    /// `linear`.
16838    Linear,
16839    /// `none`.
16840    None,
16841    /// `normal`.
16842    Normal,
16843    /// `step-end`.
16844    StepEnd,
16845    /// `step-start`.
16846    StepStart,
16847    /// A duration.
16848    Time(Time),
16849    /// Any other value, passed through unchecked.
16850    Raw(Raw),
16851}
16852
16853impl fmt::Display for Transition {
16854    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16855        match self {
16856            Self::All => f.write_str("all"),
16857            Self::AllowDiscrete => f.write_str("allow-discrete"),
16858            Self::Ease => f.write_str("ease"),
16859            Self::EaseIn => f.write_str("ease-in"),
16860            Self::EaseInOut => f.write_str("ease-in-out"),
16861            Self::EaseOut => f.write_str("ease-out"),
16862            Self::Linear => f.write_str("linear"),
16863            Self::None => f.write_str("none"),
16864            Self::Normal => f.write_str("normal"),
16865            Self::StepEnd => f.write_str("step-end"),
16866            Self::StepStart => f.write_str("step-start"),
16867            Self::Time(v) => v.fmt(f),
16868            Self::Raw(v) => v.fmt(f),
16869        }
16870    }
16871}
16872
16873impl From<Time> for Transition {
16874    fn from(v: Time) -> Self {
16875        Self::Time(v)
16876    }
16877}
16878
16879impl From<Raw> for Transition {
16880    fn from(v: Raw) -> Self {
16881        Self::Raw(v)
16882    }
16883}
16884
16885/// A value of [`transition-behavior`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transition-behavior).
16886#[derive(Debug, Clone, PartialEq)]
16887#[non_exhaustive]
16888pub enum TransitionBehavior {
16889    /// `allow-discrete`.
16890    AllowDiscrete,
16891    /// `normal`.
16892    Normal,
16893    /// Any other value, passed through unchecked.
16894    Raw(Raw),
16895}
16896
16897impl fmt::Display for TransitionBehavior {
16898    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16899        match self {
16900            Self::AllowDiscrete => f.write_str("allow-discrete"),
16901            Self::Normal => f.write_str("normal"),
16902            Self::Raw(v) => v.fmt(f),
16903        }
16904    }
16905}
16906
16907impl From<Raw> for TransitionBehavior {
16908    fn from(v: Raw) -> Self {
16909        Self::Raw(v)
16910    }
16911}
16912
16913/// A value of [`transition-delay`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transition-delay).
16914#[derive(Debug, Clone, PartialEq)]
16915#[non_exhaustive]
16916pub enum TransitionDelay {
16917    /// A duration.
16918    Time(Time),
16919    /// Any other value, passed through unchecked.
16920    Raw(Raw),
16921}
16922
16923impl fmt::Display for TransitionDelay {
16924    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16925        match self {
16926            Self::Time(v) => v.fmt(f),
16927            Self::Raw(v) => v.fmt(f),
16928        }
16929    }
16930}
16931
16932impl From<Time> for TransitionDelay {
16933    fn from(v: Time) -> Self {
16934        Self::Time(v)
16935    }
16936}
16937
16938impl From<Raw> for TransitionDelay {
16939    fn from(v: Raw) -> Self {
16940        Self::Raw(v)
16941    }
16942}
16943
16944/// A value of [`transition-duration`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transition-duration).
16945#[derive(Debug, Clone, PartialEq)]
16946#[non_exhaustive]
16947pub enum TransitionDuration {
16948    /// A duration.
16949    Time(Time),
16950    /// Any other value, passed through unchecked.
16951    Raw(Raw),
16952}
16953
16954impl fmt::Display for TransitionDuration {
16955    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16956        match self {
16957            Self::Time(v) => v.fmt(f),
16958            Self::Raw(v) => v.fmt(f),
16959        }
16960    }
16961}
16962
16963impl From<Time> for TransitionDuration {
16964    fn from(v: Time) -> Self {
16965        Self::Time(v)
16966    }
16967}
16968
16969impl From<Raw> for TransitionDuration {
16970    fn from(v: Raw) -> Self {
16971        Self::Raw(v)
16972    }
16973}
16974
16975/// A value of [`transition-property`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transition-property).
16976#[derive(Debug, Clone, PartialEq)]
16977#[non_exhaustive]
16978pub enum TransitionProperty {
16979    /// `all`.
16980    All,
16981    /// `none`.
16982    None,
16983    /// Any other value, passed through unchecked.
16984    Raw(Raw),
16985}
16986
16987impl fmt::Display for TransitionProperty {
16988    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16989        match self {
16990            Self::All => f.write_str("all"),
16991            Self::None => f.write_str("none"),
16992            Self::Raw(v) => v.fmt(f),
16993        }
16994    }
16995}
16996
16997impl From<Raw> for TransitionProperty {
16998    fn from(v: Raw) -> Self {
16999        Self::Raw(v)
17000    }
17001}
17002
17003/// A value of [`transition-timing-function`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/transition-timing-function).
17004#[derive(Debug, Clone, PartialEq)]
17005#[non_exhaustive]
17006pub enum TransitionTimingFunction {
17007    /// `ease`.
17008    Ease,
17009    /// `ease-in`.
17010    EaseIn,
17011    /// `ease-in-out`.
17012    EaseInOut,
17013    /// `ease-out`.
17014    EaseOut,
17015    /// `linear`.
17016    Linear,
17017    /// `step-end`.
17018    StepEnd,
17019    /// `step-start`.
17020    StepStart,
17021    /// Any other value, passed through unchecked.
17022    Raw(Raw),
17023}
17024
17025impl fmt::Display for TransitionTimingFunction {
17026    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17027        match self {
17028            Self::Ease => f.write_str("ease"),
17029            Self::EaseIn => f.write_str("ease-in"),
17030            Self::EaseInOut => f.write_str("ease-in-out"),
17031            Self::EaseOut => f.write_str("ease-out"),
17032            Self::Linear => f.write_str("linear"),
17033            Self::StepEnd => f.write_str("step-end"),
17034            Self::StepStart => f.write_str("step-start"),
17035            Self::Raw(v) => v.fmt(f),
17036        }
17037    }
17038}
17039
17040impl From<Raw> for TransitionTimingFunction {
17041    fn from(v: Raw) -> Self {
17042        Self::Raw(v)
17043    }
17044}
17045
17046/// A value of [`translate`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/translate).
17047#[derive(Debug, Clone, PartialEq)]
17048#[non_exhaustive]
17049pub enum Translate {
17050    /// `none`.
17051    None,
17052    /// A length.
17053    Length(Length),
17054    /// A percentage.
17055    Percentage(Percentage),
17056    /// Any other value, passed through unchecked.
17057    Raw(Raw),
17058}
17059
17060impl fmt::Display for Translate {
17061    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17062        match self {
17063            Self::None => f.write_str("none"),
17064            Self::Length(v) => v.fmt(f),
17065            Self::Percentage(v) => v.fmt(f),
17066            Self::Raw(v) => v.fmt(f),
17067        }
17068    }
17069}
17070
17071impl From<Length> for Translate {
17072    fn from(v: Length) -> Self {
17073        Self::Length(v)
17074    }
17075}
17076
17077impl From<Percentage> for Translate {
17078    fn from(v: Percentage) -> Self {
17079        Self::Percentage(v)
17080    }
17081}
17082
17083impl From<Raw> for Translate {
17084    fn from(v: Raw) -> Self {
17085        Self::Raw(v)
17086    }
17087}
17088
17089/// A value of [`trigger-scope`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/trigger-scope).
17090#[derive(Debug, Clone, PartialEq)]
17091#[non_exhaustive]
17092pub enum TriggerScope {
17093    /// `all`.
17094    All,
17095    /// `none`.
17096    None,
17097    /// Any other value, passed through unchecked.
17098    Raw(Raw),
17099}
17100
17101impl fmt::Display for TriggerScope {
17102    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17103        match self {
17104            Self::All => f.write_str("all"),
17105            Self::None => f.write_str("none"),
17106            Self::Raw(v) => v.fmt(f),
17107        }
17108    }
17109}
17110
17111impl From<Raw> for TriggerScope {
17112    fn from(v: Raw) -> Self {
17113        Self::Raw(v)
17114    }
17115}
17116
17117/// A value of [`unicode-bidi`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/unicode-bidi).
17118#[derive(Debug, Clone, PartialEq)]
17119#[non_exhaustive]
17120pub enum UnicodeBidi {
17121    /// `bidi-override`.
17122    BidiOverride,
17123    /// `embed`.
17124    Embed,
17125    /// `isolate`.
17126    Isolate,
17127    /// `isolate-override`.
17128    IsolateOverride,
17129    /// `normal`.
17130    Normal,
17131    /// `plaintext`.
17132    Plaintext,
17133}
17134
17135impl fmt::Display for UnicodeBidi {
17136    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17137        match self {
17138            Self::BidiOverride => f.write_str("bidi-override"),
17139            Self::Embed => f.write_str("embed"),
17140            Self::Isolate => f.write_str("isolate"),
17141            Self::IsolateOverride => f.write_str("isolate-override"),
17142            Self::Normal => f.write_str("normal"),
17143            Self::Plaintext => f.write_str("plaintext"),
17144        }
17145    }
17146}
17147
17148/// A value of [`user-select`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/user-select).
17149#[derive(Debug, Clone, PartialEq)]
17150#[non_exhaustive]
17151pub enum UserSelect {
17152    /// `all`.
17153    All,
17154    /// `auto`.
17155    Auto,
17156    /// `none`.
17157    None,
17158    /// `text`.
17159    Text,
17160}
17161
17162impl fmt::Display for UserSelect {
17163    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17164        match self {
17165            Self::All => f.write_str("all"),
17166            Self::Auto => f.write_str("auto"),
17167            Self::None => f.write_str("none"),
17168            Self::Text => f.write_str("text"),
17169        }
17170    }
17171}
17172
17173/// A value of [`vector-effect`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/vector-effect).
17174#[derive(Debug, Clone, PartialEq)]
17175#[non_exhaustive]
17176pub enum VectorEffect {
17177    /// `fixed-position`.
17178    FixedPosition,
17179    /// `non-rotation`.
17180    NonRotation,
17181    /// `non-scaling-size`.
17182    NonScalingSize,
17183    /// `non-scaling-stroke`.
17184    NonScalingStroke,
17185    /// `none`.
17186    None,
17187}
17188
17189impl fmt::Display for VectorEffect {
17190    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17191        match self {
17192            Self::FixedPosition => f.write_str("fixed-position"),
17193            Self::NonRotation => f.write_str("non-rotation"),
17194            Self::NonScalingSize => f.write_str("non-scaling-size"),
17195            Self::NonScalingStroke => f.write_str("non-scaling-stroke"),
17196            Self::None => f.write_str("none"),
17197        }
17198    }
17199}
17200
17201/// A value of [`vertical-align`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/vertical-align).
17202#[derive(Debug, Clone, PartialEq)]
17203#[non_exhaustive]
17204pub enum VerticalAlign {
17205    /// `baseline`.
17206    Baseline,
17207    /// `bottom`.
17208    Bottom,
17209    /// `middle`.
17210    Middle,
17211    /// `sub`.
17212    Sub,
17213    /// `super`.
17214    Super,
17215    /// `text-bottom`.
17216    TextBottom,
17217    /// `text-top`.
17218    TextTop,
17219    /// `top`.
17220    Top,
17221    /// A length.
17222    Length(Length),
17223    /// A percentage.
17224    Percentage(Percentage),
17225}
17226
17227impl fmt::Display for VerticalAlign {
17228    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17229        match self {
17230            Self::Baseline => f.write_str("baseline"),
17231            Self::Bottom => f.write_str("bottom"),
17232            Self::Middle => f.write_str("middle"),
17233            Self::Sub => f.write_str("sub"),
17234            Self::Super => f.write_str("super"),
17235            Self::TextBottom => f.write_str("text-bottom"),
17236            Self::TextTop => f.write_str("text-top"),
17237            Self::Top => f.write_str("top"),
17238            Self::Length(v) => v.fmt(f),
17239            Self::Percentage(v) => v.fmt(f),
17240        }
17241    }
17242}
17243
17244impl From<Length> for VerticalAlign {
17245    fn from(v: Length) -> Self {
17246        Self::Length(v)
17247    }
17248}
17249
17250impl From<Percentage> for VerticalAlign {
17251    fn from(v: Percentage) -> Self {
17252        Self::Percentage(v)
17253    }
17254}
17255
17256/// A value of [`view-transition-class`]().
17257#[derive(Debug, Clone, PartialEq)]
17258#[non_exhaustive]
17259pub enum ViewTransitionClass {
17260    /// `none`.
17261    None,
17262    /// Any other value, passed through unchecked.
17263    Raw(Raw),
17264}
17265
17266impl fmt::Display for ViewTransitionClass {
17267    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17268        match self {
17269            Self::None => f.write_str("none"),
17270            Self::Raw(v) => v.fmt(f),
17271        }
17272    }
17273}
17274
17275impl From<Raw> for ViewTransitionClass {
17276    fn from(v: Raw) -> Self {
17277        Self::Raw(v)
17278    }
17279}
17280
17281/// A value of [`view-transition-name`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/view-transition-name).
17282#[derive(Debug, Clone, PartialEq)]
17283#[non_exhaustive]
17284pub enum ViewTransitionName {
17285    /// `match-element`.
17286    MatchElement,
17287    /// `none`.
17288    None,
17289    /// Any other value, passed through unchecked.
17290    Raw(Raw),
17291}
17292
17293impl fmt::Display for ViewTransitionName {
17294    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17295        match self {
17296            Self::MatchElement => f.write_str("match-element"),
17297            Self::None => f.write_str("none"),
17298            Self::Raw(v) => v.fmt(f),
17299        }
17300    }
17301}
17302
17303impl From<Raw> for ViewTransitionName {
17304    fn from(v: Raw) -> Self {
17305        Self::Raw(v)
17306    }
17307}
17308
17309/// A value of [`view-transition-scope`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/view-transition-scope).
17310#[derive(Debug, Clone, PartialEq)]
17311#[non_exhaustive]
17312pub enum ViewTransitionScope {
17313    /// `all`.
17314    All,
17315    /// `none`.
17316    None,
17317}
17318
17319impl fmt::Display for ViewTransitionScope {
17320    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17321        match self {
17322            Self::All => f.write_str("all"),
17323            Self::None => f.write_str("none"),
17324        }
17325    }
17326}
17327
17328/// A value of [`visibility`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/visibility).
17329#[derive(Debug, Clone, PartialEq)]
17330#[non_exhaustive]
17331pub enum Visibility {
17332    /// `collapse`.
17333    Collapse,
17334    /// `hidden`.
17335    Hidden,
17336    /// `visible`.
17337    Visible,
17338}
17339
17340impl fmt::Display for Visibility {
17341    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17342        match self {
17343            Self::Collapse => f.write_str("collapse"),
17344            Self::Hidden => f.write_str("hidden"),
17345            Self::Visible => f.write_str("visible"),
17346        }
17347    }
17348}
17349
17350/// A value of [`white-space`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/white-space).
17351#[derive(Debug, Clone, PartialEq)]
17352#[non_exhaustive]
17353pub enum WhiteSpace {
17354    /// `break-spaces`.
17355    BreakSpaces,
17356    /// `collapse`.
17357    Collapse,
17358    /// `normal`.
17359    Normal,
17360    /// `nowrap`.
17361    Nowrap,
17362    /// `pre`.
17363    Pre,
17364    /// `pre-line`.
17365    PreLine,
17366    /// `pre-wrap`.
17367    PreWrap,
17368    /// `preserve`.
17369    Preserve,
17370    /// `preserve-breaks`.
17371    PreserveBreaks,
17372    /// `preserve-spaces`.
17373    PreserveSpaces,
17374    /// `wrap`.
17375    Wrap,
17376    /// Any other value, passed through unchecked.
17377    Raw(Raw),
17378}
17379
17380impl fmt::Display for WhiteSpace {
17381    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17382        match self {
17383            Self::BreakSpaces => f.write_str("break-spaces"),
17384            Self::Collapse => f.write_str("collapse"),
17385            Self::Normal => f.write_str("normal"),
17386            Self::Nowrap => f.write_str("nowrap"),
17387            Self::Pre => f.write_str("pre"),
17388            Self::PreLine => f.write_str("pre-line"),
17389            Self::PreWrap => f.write_str("pre-wrap"),
17390            Self::Preserve => f.write_str("preserve"),
17391            Self::PreserveBreaks => f.write_str("preserve-breaks"),
17392            Self::PreserveSpaces => f.write_str("preserve-spaces"),
17393            Self::Wrap => f.write_str("wrap"),
17394            Self::Raw(v) => v.fmt(f),
17395        }
17396    }
17397}
17398
17399impl From<Raw> for WhiteSpace {
17400    fn from(v: Raw) -> Self {
17401        Self::Raw(v)
17402    }
17403}
17404
17405/// A value of [`white-space-collapse`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/white-space-collapse).
17406#[derive(Debug, Clone, PartialEq)]
17407#[non_exhaustive]
17408pub enum WhiteSpaceCollapse {
17409    /// `break-spaces`.
17410    BreakSpaces,
17411    /// `collapse`.
17412    Collapse,
17413    /// `preserve`.
17414    Preserve,
17415    /// `preserve-breaks`.
17416    PreserveBreaks,
17417    /// `preserve-spaces`.
17418    PreserveSpaces,
17419}
17420
17421impl fmt::Display for WhiteSpaceCollapse {
17422    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17423        match self {
17424            Self::BreakSpaces => f.write_str("break-spaces"),
17425            Self::Collapse => f.write_str("collapse"),
17426            Self::Preserve => f.write_str("preserve"),
17427            Self::PreserveBreaks => f.write_str("preserve-breaks"),
17428            Self::PreserveSpaces => f.write_str("preserve-spaces"),
17429        }
17430    }
17431}
17432
17433/// A value of [`width`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/width).
17434#[derive(Debug, Clone, PartialEq)]
17435#[non_exhaustive]
17436pub enum Width {
17437    /// `auto`.
17438    Auto,
17439    /// `fit-content`.
17440    FitContent,
17441    /// `max-content`.
17442    MaxContent,
17443    /// `min-content`.
17444    MinContent,
17445    /// A length.
17446    Length(Length),
17447    /// A percentage.
17448    Percentage(Percentage),
17449    /// Any other value, passed through unchecked.
17450    Raw(Raw),
17451}
17452
17453impl fmt::Display for Width {
17454    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17455        match self {
17456            Self::Auto => f.write_str("auto"),
17457            Self::FitContent => f.write_str("fit-content"),
17458            Self::MaxContent => f.write_str("max-content"),
17459            Self::MinContent => f.write_str("min-content"),
17460            Self::Length(v) => v.fmt(f),
17461            Self::Percentage(v) => v.fmt(f),
17462            Self::Raw(v) => v.fmt(f),
17463        }
17464    }
17465}
17466
17467impl From<Length> for Width {
17468    fn from(v: Length) -> Self {
17469        Self::Length(v)
17470    }
17471}
17472
17473impl From<Percentage> for Width {
17474    fn from(v: Percentage) -> Self {
17475        Self::Percentage(v)
17476    }
17477}
17478
17479impl From<Raw> for Width {
17480    fn from(v: Raw) -> Self {
17481        Self::Raw(v)
17482    }
17483}
17484
17485/// A value of [`will-change`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/will-change).
17486#[derive(Debug, Clone, PartialEq)]
17487#[non_exhaustive]
17488pub enum WillChange {
17489    /// `auto`.
17490    Auto,
17491    /// `contents`.
17492    Contents,
17493    /// `scroll-position`.
17494    ScrollPosition,
17495    /// Any other value, passed through unchecked.
17496    Raw(Raw),
17497}
17498
17499impl fmt::Display for WillChange {
17500    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17501        match self {
17502            Self::Auto => f.write_str("auto"),
17503            Self::Contents => f.write_str("contents"),
17504            Self::ScrollPosition => f.write_str("scroll-position"),
17505            Self::Raw(v) => v.fmt(f),
17506        }
17507    }
17508}
17509
17510impl From<Raw> for WillChange {
17511    fn from(v: Raw) -> Self {
17512        Self::Raw(v)
17513    }
17514}
17515
17516/// A value of [`window-drag`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/window-drag).
17517#[derive(Debug, Clone, PartialEq)]
17518#[non_exhaustive]
17519pub enum WindowDrag {
17520    /// `move`.
17521    Move,
17522    /// `none`.
17523    None,
17524}
17525
17526impl fmt::Display for WindowDrag {
17527    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17528        match self {
17529            Self::Move => f.write_str("move"),
17530            Self::None => f.write_str("none"),
17531        }
17532    }
17533}
17534
17535/// A value of [`word-break`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/word-break).
17536#[derive(Debug, Clone, PartialEq)]
17537#[non_exhaustive]
17538pub enum WordBreak {
17539    /// `auto-phrase`.
17540    AutoPhrase,
17541    /// `break-all`.
17542    BreakAll,
17543    /// `break-word`.
17544    BreakWord,
17545    /// `keep-all`.
17546    KeepAll,
17547    /// `normal`.
17548    Normal,
17549}
17550
17551impl fmt::Display for WordBreak {
17552    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17553        match self {
17554            Self::AutoPhrase => f.write_str("auto-phrase"),
17555            Self::BreakAll => f.write_str("break-all"),
17556            Self::BreakWord => f.write_str("break-word"),
17557            Self::KeepAll => f.write_str("keep-all"),
17558            Self::Normal => f.write_str("normal"),
17559        }
17560    }
17561}
17562
17563/// A value of [`word-spacing`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/word-spacing).
17564#[derive(Debug, Clone, PartialEq)]
17565#[non_exhaustive]
17566pub enum WordSpacing {
17567    /// `normal`.
17568    Normal,
17569    /// A length.
17570    Length(Length),
17571}
17572
17573impl fmt::Display for WordSpacing {
17574    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17575        match self {
17576            Self::Normal => f.write_str("normal"),
17577            Self::Length(v) => v.fmt(f),
17578        }
17579    }
17580}
17581
17582impl From<Length> for WordSpacing {
17583    fn from(v: Length) -> Self {
17584        Self::Length(v)
17585    }
17586}
17587
17588/// A value of [`word-wrap`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/overflow-wrap).
17589#[derive(Debug, Clone, PartialEq)]
17590#[non_exhaustive]
17591pub enum WordWrap {
17592    /// `break-word`.
17593    BreakWord,
17594    /// `normal`.
17595    Normal,
17596}
17597
17598impl fmt::Display for WordWrap {
17599    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17600        match self {
17601            Self::BreakWord => f.write_str("break-word"),
17602            Self::Normal => f.write_str("normal"),
17603        }
17604    }
17605}
17606
17607/// A value of [`writing-mode`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/writing-mode).
17608#[derive(Debug, Clone, PartialEq)]
17609#[non_exhaustive]
17610pub enum WritingMode {
17611    /// `horizontal-tb`.
17612    HorizontalTb,
17613    /// `sideways-lr`.
17614    SidewaysLr,
17615    /// `sideways-rl`.
17616    SidewaysRl,
17617    /// `vertical-lr`.
17618    VerticalLr,
17619    /// `vertical-rl`.
17620    VerticalRl,
17621}
17622
17623impl fmt::Display for WritingMode {
17624    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17625        match self {
17626            Self::HorizontalTb => f.write_str("horizontal-tb"),
17627            Self::SidewaysLr => f.write_str("sideways-lr"),
17628            Self::SidewaysRl => f.write_str("sideways-rl"),
17629            Self::VerticalLr => f.write_str("vertical-lr"),
17630            Self::VerticalRl => f.write_str("vertical-rl"),
17631        }
17632    }
17633}
17634
17635/// A value of [`x`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/x).
17636#[derive(Debug, Clone, PartialEq)]
17637#[non_exhaustive]
17638pub enum X {
17639    /// A length.
17640    Length(Length),
17641    /// A percentage.
17642    Percentage(Percentage),
17643}
17644
17645impl fmt::Display for X {
17646    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17647        match self {
17648            Self::Length(v) => v.fmt(f),
17649            Self::Percentage(v) => v.fmt(f),
17650        }
17651    }
17652}
17653
17654impl From<Length> for X {
17655    fn from(v: Length) -> Self {
17656        Self::Length(v)
17657    }
17658}
17659
17660impl From<Percentage> for X {
17661    fn from(v: Percentage) -> Self {
17662        Self::Percentage(v)
17663    }
17664}
17665
17666/// A value of [`y`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/y).
17667#[derive(Debug, Clone, PartialEq)]
17668#[non_exhaustive]
17669pub enum Y {
17670    /// A length.
17671    Length(Length),
17672    /// A percentage.
17673    Percentage(Percentage),
17674}
17675
17676impl fmt::Display for Y {
17677    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17678        match self {
17679            Self::Length(v) => v.fmt(f),
17680            Self::Percentage(v) => v.fmt(f),
17681        }
17682    }
17683}
17684
17685impl From<Length> for Y {
17686    fn from(v: Length) -> Self {
17687        Self::Length(v)
17688    }
17689}
17690
17691impl From<Percentage> for Y {
17692    fn from(v: Percentage) -> Self {
17693        Self::Percentage(v)
17694    }
17695}
17696
17697/// A value of [`z-index`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/z-index).
17698#[derive(Debug, Clone, PartialEq)]
17699#[non_exhaustive]
17700pub enum ZIndex {
17701    /// `auto`.
17702    Auto,
17703    /// An integer.
17704    Integer(i32),
17705}
17706
17707impl fmt::Display for ZIndex {
17708    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17709        match self {
17710            Self::Auto => f.write_str("auto"),
17711            Self::Integer(v) => v.fmt(f),
17712        }
17713    }
17714}
17715
17716impl From<i32> for ZIndex {
17717    fn from(v: i32) -> Self {
17718        Self::Integer(v)
17719    }
17720}
17721
17722/// A value of [`zoom`](https://developer.mozilla.org/docs/Web/CSS/Reference/Properties/zoom).
17723#[derive(Debug, Clone, PartialEq)]
17724#[non_exhaustive]
17725pub enum Zoom {
17726    /// `normal`.
17727    Normal,
17728    /// `reset`.
17729    Reset,
17730    /// A percentage.
17731    Percentage(Percentage),
17732    /// A number.
17733    Number(f64),
17734    /// Any other value, passed through unchecked.
17735    Raw(Raw),
17736}
17737
17738impl fmt::Display for Zoom {
17739    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17740        match self {
17741            Self::Normal => f.write_str("normal"),
17742            Self::Reset => f.write_str("reset"),
17743            Self::Percentage(v) => v.fmt(f),
17744            Self::Number(v) => v.fmt(f),
17745            Self::Raw(v) => v.fmt(f),
17746        }
17747    }
17748}
17749
17750impl From<Percentage> for Zoom {
17751    fn from(v: Percentage) -> Self {
17752        Self::Percentage(v)
17753    }
17754}
17755
17756impl From<f64> for Zoom {
17757    fn from(v: f64) -> Self {
17758        Self::Number(v)
17759    }
17760}
17761
17762impl From<i32> for Zoom {
17763    fn from(v: i32) -> Self {
17764        Self::Number(f64::from(v))
17765    }
17766}
17767
17768impl From<Raw> for Zoom {
17769    fn from(v: Raw) -> Self {
17770        Self::Raw(v)
17771    }
17772}
17773
17774impl Color {
17775    /// The named color `aliceblue`.
17776    pub const ALICEBLUE: Self = Self::named("aliceblue");
17777    /// The named color `antiquewhite`.
17778    pub const ANTIQUEWHITE: Self = Self::named("antiquewhite");
17779    /// The named color `aqua`.
17780    pub const AQUA: Self = Self::named("aqua");
17781    /// The named color `aquamarine`.
17782    pub const AQUAMARINE: Self = Self::named("aquamarine");
17783    /// The named color `azure`.
17784    pub const AZURE: Self = Self::named("azure");
17785    /// The named color `beige`.
17786    pub const BEIGE: Self = Self::named("beige");
17787    /// The named color `bisque`.
17788    pub const BISQUE: Self = Self::named("bisque");
17789    /// The named color `black`.
17790    pub const BLACK: Self = Self::named("black");
17791    /// The named color `blanchedalmond`.
17792    pub const BLANCHEDALMOND: Self = Self::named("blanchedalmond");
17793    /// The named color `blue`.
17794    pub const BLUE: Self = Self::named("blue");
17795    /// The named color `blueviolet`.
17796    pub const BLUEVIOLET: Self = Self::named("blueviolet");
17797    /// The named color `brown`.
17798    pub const BROWN: Self = Self::named("brown");
17799    /// The named color `burlywood`.
17800    pub const BURLYWOOD: Self = Self::named("burlywood");
17801    /// The named color `cadetblue`.
17802    pub const CADETBLUE: Self = Self::named("cadetblue");
17803    /// The named color `chartreuse`.
17804    pub const CHARTREUSE: Self = Self::named("chartreuse");
17805    /// The named color `chocolate`.
17806    pub const CHOCOLATE: Self = Self::named("chocolate");
17807    /// The named color `coral`.
17808    pub const CORAL: Self = Self::named("coral");
17809    /// The named color `cornflowerblue`.
17810    pub const CORNFLOWERBLUE: Self = Self::named("cornflowerblue");
17811    /// The named color `cornsilk`.
17812    pub const CORNSILK: Self = Self::named("cornsilk");
17813    /// The named color `crimson`.
17814    pub const CRIMSON: Self = Self::named("crimson");
17815    /// The named color `cyan`.
17816    pub const CYAN: Self = Self::named("cyan");
17817    /// The named color `darkblue`.
17818    pub const DARKBLUE: Self = Self::named("darkblue");
17819    /// The named color `darkcyan`.
17820    pub const DARKCYAN: Self = Self::named("darkcyan");
17821    /// The named color `darkgoldenrod`.
17822    pub const DARKGOLDENROD: Self = Self::named("darkgoldenrod");
17823    /// The named color `darkgray`.
17824    pub const DARKGRAY: Self = Self::named("darkgray");
17825    /// The named color `darkgreen`.
17826    pub const DARKGREEN: Self = Self::named("darkgreen");
17827    /// The named color `darkgrey`.
17828    pub const DARKGREY: Self = Self::named("darkgrey");
17829    /// The named color `darkkhaki`.
17830    pub const DARKKHAKI: Self = Self::named("darkkhaki");
17831    /// The named color `darkmagenta`.
17832    pub const DARKMAGENTA: Self = Self::named("darkmagenta");
17833    /// The named color `darkolivegreen`.
17834    pub const DARKOLIVEGREEN: Self = Self::named("darkolivegreen");
17835    /// The named color `darkorange`.
17836    pub const DARKORANGE: Self = Self::named("darkorange");
17837    /// The named color `darkorchid`.
17838    pub const DARKORCHID: Self = Self::named("darkorchid");
17839    /// The named color `darkred`.
17840    pub const DARKRED: Self = Self::named("darkred");
17841    /// The named color `darksalmon`.
17842    pub const DARKSALMON: Self = Self::named("darksalmon");
17843    /// The named color `darkseagreen`.
17844    pub const DARKSEAGREEN: Self = Self::named("darkseagreen");
17845    /// The named color `darkslateblue`.
17846    pub const DARKSLATEBLUE: Self = Self::named("darkslateblue");
17847    /// The named color `darkslategray`.
17848    pub const DARKSLATEGRAY: Self = Self::named("darkslategray");
17849    /// The named color `darkslategrey`.
17850    pub const DARKSLATEGREY: Self = Self::named("darkslategrey");
17851    /// The named color `darkturquoise`.
17852    pub const DARKTURQUOISE: Self = Self::named("darkturquoise");
17853    /// The named color `darkviolet`.
17854    pub const DARKVIOLET: Self = Self::named("darkviolet");
17855    /// The named color `deeppink`.
17856    pub const DEEPPINK: Self = Self::named("deeppink");
17857    /// The named color `deepskyblue`.
17858    pub const DEEPSKYBLUE: Self = Self::named("deepskyblue");
17859    /// The named color `dimgray`.
17860    pub const DIMGRAY: Self = Self::named("dimgray");
17861    /// The named color `dimgrey`.
17862    pub const DIMGREY: Self = Self::named("dimgrey");
17863    /// The named color `dodgerblue`.
17864    pub const DODGERBLUE: Self = Self::named("dodgerblue");
17865    /// The named color `firebrick`.
17866    pub const FIREBRICK: Self = Self::named("firebrick");
17867    /// The named color `floralwhite`.
17868    pub const FLORALWHITE: Self = Self::named("floralwhite");
17869    /// The named color `forestgreen`.
17870    pub const FORESTGREEN: Self = Self::named("forestgreen");
17871    /// The named color `fuchsia`.
17872    pub const FUCHSIA: Self = Self::named("fuchsia");
17873    /// The named color `gainsboro`.
17874    pub const GAINSBORO: Self = Self::named("gainsboro");
17875    /// The named color `ghostwhite`.
17876    pub const GHOSTWHITE: Self = Self::named("ghostwhite");
17877    /// The named color `gold`.
17878    pub const GOLD: Self = Self::named("gold");
17879    /// The named color `goldenrod`.
17880    pub const GOLDENROD: Self = Self::named("goldenrod");
17881    /// The named color `gray`.
17882    pub const GRAY: Self = Self::named("gray");
17883    /// The named color `green`.
17884    pub const GREEN: Self = Self::named("green");
17885    /// The named color `greenyellow`.
17886    pub const GREENYELLOW: Self = Self::named("greenyellow");
17887    /// The named color `grey`.
17888    pub const GREY: Self = Self::named("grey");
17889    /// The named color `honeydew`.
17890    pub const HONEYDEW: Self = Self::named("honeydew");
17891    /// The named color `hotpink`.
17892    pub const HOTPINK: Self = Self::named("hotpink");
17893    /// The named color `indianred`.
17894    pub const INDIANRED: Self = Self::named("indianred");
17895    /// The named color `indigo`.
17896    pub const INDIGO: Self = Self::named("indigo");
17897    /// The named color `ivory`.
17898    pub const IVORY: Self = Self::named("ivory");
17899    /// The named color `khaki`.
17900    pub const KHAKI: Self = Self::named("khaki");
17901    /// The named color `lavender`.
17902    pub const LAVENDER: Self = Self::named("lavender");
17903    /// The named color `lavenderblush`.
17904    pub const LAVENDERBLUSH: Self = Self::named("lavenderblush");
17905    /// The named color `lawngreen`.
17906    pub const LAWNGREEN: Self = Self::named("lawngreen");
17907    /// The named color `lemonchiffon`.
17908    pub const LEMONCHIFFON: Self = Self::named("lemonchiffon");
17909    /// The named color `lightblue`.
17910    pub const LIGHTBLUE: Self = Self::named("lightblue");
17911    /// The named color `lightcoral`.
17912    pub const LIGHTCORAL: Self = Self::named("lightcoral");
17913    /// The named color `lightcyan`.
17914    pub const LIGHTCYAN: Self = Self::named("lightcyan");
17915    /// The named color `lightgoldenrodyellow`.
17916    pub const LIGHTGOLDENRODYELLOW: Self = Self::named("lightgoldenrodyellow");
17917    /// The named color `lightgray`.
17918    pub const LIGHTGRAY: Self = Self::named("lightgray");
17919    /// The named color `lightgreen`.
17920    pub const LIGHTGREEN: Self = Self::named("lightgreen");
17921    /// The named color `lightgrey`.
17922    pub const LIGHTGREY: Self = Self::named("lightgrey");
17923    /// The named color `lightpink`.
17924    pub const LIGHTPINK: Self = Self::named("lightpink");
17925    /// The named color `lightsalmon`.
17926    pub const LIGHTSALMON: Self = Self::named("lightsalmon");
17927    /// The named color `lightseagreen`.
17928    pub const LIGHTSEAGREEN: Self = Self::named("lightseagreen");
17929    /// The named color `lightskyblue`.
17930    pub const LIGHTSKYBLUE: Self = Self::named("lightskyblue");
17931    /// The named color `lightslategray`.
17932    pub const LIGHTSLATEGRAY: Self = Self::named("lightslategray");
17933    /// The named color `lightslategrey`.
17934    pub const LIGHTSLATEGREY: Self = Self::named("lightslategrey");
17935    /// The named color `lightsteelblue`.
17936    pub const LIGHTSTEELBLUE: Self = Self::named("lightsteelblue");
17937    /// The named color `lightyellow`.
17938    pub const LIGHTYELLOW: Self = Self::named("lightyellow");
17939    /// The named color `lime`.
17940    pub const LIME: Self = Self::named("lime");
17941    /// The named color `limegreen`.
17942    pub const LIMEGREEN: Self = Self::named("limegreen");
17943    /// The named color `linen`.
17944    pub const LINEN: Self = Self::named("linen");
17945    /// The named color `magenta`.
17946    pub const MAGENTA: Self = Self::named("magenta");
17947    /// The named color `maroon`.
17948    pub const MAROON: Self = Self::named("maroon");
17949    /// The named color `mediumaquamarine`.
17950    pub const MEDIUMAQUAMARINE: Self = Self::named("mediumaquamarine");
17951    /// The named color `mediumblue`.
17952    pub const MEDIUMBLUE: Self = Self::named("mediumblue");
17953    /// The named color `mediumorchid`.
17954    pub const MEDIUMORCHID: Self = Self::named("mediumorchid");
17955    /// The named color `mediumpurple`.
17956    pub const MEDIUMPURPLE: Self = Self::named("mediumpurple");
17957    /// The named color `mediumseagreen`.
17958    pub const MEDIUMSEAGREEN: Self = Self::named("mediumseagreen");
17959    /// The named color `mediumslateblue`.
17960    pub const MEDIUMSLATEBLUE: Self = Self::named("mediumslateblue");
17961    /// The named color `mediumspringgreen`.
17962    pub const MEDIUMSPRINGGREEN: Self = Self::named("mediumspringgreen");
17963    /// The named color `mediumturquoise`.
17964    pub const MEDIUMTURQUOISE: Self = Self::named("mediumturquoise");
17965    /// The named color `mediumvioletred`.
17966    pub const MEDIUMVIOLETRED: Self = Self::named("mediumvioletred");
17967    /// The named color `midnightblue`.
17968    pub const MIDNIGHTBLUE: Self = Self::named("midnightblue");
17969    /// The named color `mintcream`.
17970    pub const MINTCREAM: Self = Self::named("mintcream");
17971    /// The named color `mistyrose`.
17972    pub const MISTYROSE: Self = Self::named("mistyrose");
17973    /// The named color `moccasin`.
17974    pub const MOCCASIN: Self = Self::named("moccasin");
17975    /// The named color `navajowhite`.
17976    pub const NAVAJOWHITE: Self = Self::named("navajowhite");
17977    /// The named color `navy`.
17978    pub const NAVY: Self = Self::named("navy");
17979    /// The named color `oldlace`.
17980    pub const OLDLACE: Self = Self::named("oldlace");
17981    /// The named color `olive`.
17982    pub const OLIVE: Self = Self::named("olive");
17983    /// The named color `olivedrab`.
17984    pub const OLIVEDRAB: Self = Self::named("olivedrab");
17985    /// The named color `orange`.
17986    pub const ORANGE: Self = Self::named("orange");
17987    /// The named color `orangered`.
17988    pub const ORANGERED: Self = Self::named("orangered");
17989    /// The named color `orchid`.
17990    pub const ORCHID: Self = Self::named("orchid");
17991    /// The named color `palegoldenrod`.
17992    pub const PALEGOLDENROD: Self = Self::named("palegoldenrod");
17993    /// The named color `palegreen`.
17994    pub const PALEGREEN: Self = Self::named("palegreen");
17995    /// The named color `paleturquoise`.
17996    pub const PALETURQUOISE: Self = Self::named("paleturquoise");
17997    /// The named color `palevioletred`.
17998    pub const PALEVIOLETRED: Self = Self::named("palevioletred");
17999    /// The named color `papayawhip`.
18000    pub const PAPAYAWHIP: Self = Self::named("papayawhip");
18001    /// The named color `peachpuff`.
18002    pub const PEACHPUFF: Self = Self::named("peachpuff");
18003    /// The named color `peru`.
18004    pub const PERU: Self = Self::named("peru");
18005    /// The named color `pink`.
18006    pub const PINK: Self = Self::named("pink");
18007    /// The named color `plum`.
18008    pub const PLUM: Self = Self::named("plum");
18009    /// The named color `powderblue`.
18010    pub const POWDERBLUE: Self = Self::named("powderblue");
18011    /// The named color `purple`.
18012    pub const PURPLE: Self = Self::named("purple");
18013    /// The named color `rebeccapurple`.
18014    pub const REBECCAPURPLE: Self = Self::named("rebeccapurple");
18015    /// The named color `red`.
18016    pub const RED: Self = Self::named("red");
18017    /// The named color `rosybrown`.
18018    pub const ROSYBROWN: Self = Self::named("rosybrown");
18019    /// The named color `royalblue`.
18020    pub const ROYALBLUE: Self = Self::named("royalblue");
18021    /// The named color `saddlebrown`.
18022    pub const SADDLEBROWN: Self = Self::named("saddlebrown");
18023    /// The named color `salmon`.
18024    pub const SALMON: Self = Self::named("salmon");
18025    /// The named color `sandybrown`.
18026    pub const SANDYBROWN: Self = Self::named("sandybrown");
18027    /// The named color `seagreen`.
18028    pub const SEAGREEN: Self = Self::named("seagreen");
18029    /// The named color `seashell`.
18030    pub const SEASHELL: Self = Self::named("seashell");
18031    /// The named color `sienna`.
18032    pub const SIENNA: Self = Self::named("sienna");
18033    /// The named color `silver`.
18034    pub const SILVER: Self = Self::named("silver");
18035    /// The named color `skyblue`.
18036    pub const SKYBLUE: Self = Self::named("skyblue");
18037    /// The named color `slateblue`.
18038    pub const SLATEBLUE: Self = Self::named("slateblue");
18039    /// The named color `slategray`.
18040    pub const SLATEGRAY: Self = Self::named("slategray");
18041    /// The named color `slategrey`.
18042    pub const SLATEGREY: Self = Self::named("slategrey");
18043    /// The named color `snow`.
18044    pub const SNOW: Self = Self::named("snow");
18045    /// The named color `springgreen`.
18046    pub const SPRINGGREEN: Self = Self::named("springgreen");
18047    /// The named color `steelblue`.
18048    pub const STEELBLUE: Self = Self::named("steelblue");
18049    /// The named color `tan`.
18050    pub const TAN: Self = Self::named("tan");
18051    /// The named color `teal`.
18052    pub const TEAL: Self = Self::named("teal");
18053    /// The named color `thistle`.
18054    pub const THISTLE: Self = Self::named("thistle");
18055    /// The named color `tomato`.
18056    pub const TOMATO: Self = Self::named("tomato");
18057    /// The named color `turquoise`.
18058    pub const TURQUOISE: Self = Self::named("turquoise");
18059    /// The named color `violet`.
18060    pub const VIOLET: Self = Self::named("violet");
18061    /// The named color `wheat`.
18062    pub const WHEAT: Self = Self::named("wheat");
18063    /// The named color `white`.
18064    pub const WHITE: Self = Self::named("white");
18065    /// The named color `whitesmoke`.
18066    pub const WHITESMOKE: Self = Self::named("whitesmoke");
18067    /// The named color `yellow`.
18068    pub const YELLOW: Self = Self::named("yellow");
18069    /// The named color `yellowgreen`.
18070    pub const YELLOWGREEN: Self = Self::named("yellowgreen");
18071}
hypersig_style/value/generated.rs

hypersig_style/value/
generated.rs
