Skip to main content

css_ast/values/
ms.rs

1//! Microsoft-prefixed CSS property value types.
2//!
3//! Non-standard aliases for standardised properties, kept for compatibility
4//! with legacy stylesheets targeting IE/Edge Legacy.
5
6use super::prelude::*;
7use crate::{CalcableValue, FilterValueList, Length, PositionOne, PositionTwo};
8use css_parse::{Cursor, Parse, Parser, Result as ParseResult, T};
9
10/// `-ms-overflow-style` — IE/Edge scrollbar display behaviour.
11#[syntax(" auto | none | scrollbar | -ms-autohiding-scrollbar ")]
12#[derive(
13	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
14)]
15#[declaration_metadata(
16    initial = "auto",
17    inherits,
18    applies_to = Elements,
19    animation_type = Discrete,
20    property_group = Scrollbars,
21    computed_value_type = AsSpecified,
22    canonical_order = "per grammar",
23)]
24#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
25#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
26#[derive(csskit_derives::NodeWithMetadata)]
27pub enum MsOverflowStyleStyleValue<'a> {}
28
29/// `-ms-interpolation-mode` - IE image scaling algorithm.
30#[syntax(" nearest-neighbor | bicubic ")]
31#[derive(
32	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
33)]
34#[declaration_metadata(
35    initial = "undefined",
36    applies_to = Elements,
37    animation_type = Discrete,
38    property_group = Images,
39    computed_value_type = AsSpecified,
40    canonical_order = "per grammar",
41)]
42#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
43#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
44#[derive(csskit_derives::NodeWithMetadata)]
45pub enum MsInterpolationModeStyleValue<'a> {}
46
47/// `-ms-box-sizing` — alias for `box-sizing`.
48#[syntax(" content-box | border-box ")]
49#[derive(
50	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
51)]
52#[declaration_metadata(
53    initial = "content-box",
54    applies_to = Unknown,
55    animation_type = Discrete,
56    property_group = Sizing,
57    computed_value_type = Unknown,
58    canonical_order = "per grammar",
59)]
60#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
61#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
62#[derive(csskit_derives::NodeWithMetadata)]
63pub enum MsBoxSizingStyleValue<'a> {}
64
65/// `-ms-touch-action` — alias for `touch-action`.
66#[syntax(
67	" auto | none | [ [ pan-x | pan-left | pan-right ] || [ pan-y | pan-up | pan-down ] || pinch-zoom ] | manipulation "
68)]
69#[derive(
70	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
71)]
72#[declaration_metadata(
73    initial = "auto",
74    applies_to = Elements,
75    animation_type = Discrete,
76    property_group = PointerAnimations,
77    computed_value_type = AsSpecified,
78    canonical_order = "per grammar",
79)]
80#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
81#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
82#[derive(csskit_derives::NodeWithMetadata)]
83pub enum MsTouchActionStyleValue<'a> {}
84
85/// `-ms-user-select` — alias for `user-select`.
86#[syntax(" auto | text | none | all ")]
87#[derive(
88	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
89)]
90#[declaration_metadata(
91    initial = "auto",
92    applies_to = Elements,
93    animation_type = Discrete,
94    property_group = Ui,
95    computed_value_type = AsSpecified,
96    canonical_order = "per grammar",
97)]
98#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
99#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
100#[derive(csskit_derives::NodeWithMetadata)]
101pub enum MsUserSelectStyleValue<'a> {}
102
103/// `-ms-text-size-adjust` — alias for `text-size-adjust`.
104#[syntax(" auto | none | <percentage [0,∞]> ")]
105#[derive(
106	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
107)]
108#[declaration_metadata(
109    initial = "auto",
110    inherits,
111    applies_to = Elements,
112    animation_type = ByComputedValue,
113    percentages = Unknown,
114    property_group = SizeAdjust,
115    computed_value_type = Unknown,
116    canonical_order = "N/A",
117)]
118#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
119#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
120#[derive(csskit_derives::NodeWithMetadata)]
121pub struct MsTextSizeAdjustStyleValue<'a>;
122
123/// `-ms-flex` — IE10 alias for `flex`.
124#[syntax(" none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ] ")]
125#[derive(
126	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
127)]
128#[declaration_metadata(
129    initial = "0 1 auto",
130    applies_to = Elements,
131    animation_type = Unknown,
132    property_group = Flexbox,
133    computed_value_type = Unknown,
134    canonical_order = "per grammar",
135)]
136#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
137#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
138#[derive(csskit_derives::NodeWithMetadata)]
139pub struct MsFlexStyleValue<'a>;
140
141/// `-ms-flex-order` — IE10 alias for `order`.
142#[syntax(" <integer> ")]
143#[derive(
144	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
145)]
146#[declaration_metadata(
147    initial = "0",
148    applies_to = Elements,
149    animation_type = ByComputedValue,
150    property_group = Flexbox,
151    computed_value_type = AsSpecified,
152    canonical_order = "per grammar",
153)]
154#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
155#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
156#[derive(csskit_derives::NodeWithMetadata)]
157pub struct MsFlexOrderStyleValue<'a>;
158
159/// `-ms-flex-direction` — IE10 alias for `flex-direction`.
160#[syntax(" row | row-reverse | column | column-reverse ")]
161#[derive(
162	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
163)]
164#[declaration_metadata(
165    initial = "row",
166    applies_to = Elements,
167    animation_type = Discrete,
168    property_group = Flexbox,
169    computed_value_type = AsSpecified,
170    canonical_order = "per grammar",
171)]
172#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
173#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
174#[derive(csskit_derives::NodeWithMetadata)]
175pub enum MsFlexDirectionStyleValue<'a> {}
176
177/// `-ms-flex-wrap` — IE10 alias for `flex-wrap`.
178#[syntax(" nowrap | wrap | wrap-reverse ")]
179#[derive(
180	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
181)]
182#[declaration_metadata(
183    initial = "nowrap",
184    applies_to = Elements,
185    animation_type = Discrete,
186    property_group = Flexbox,
187    computed_value_type = AsSpecified,
188    canonical_order = "per grammar",
189)]
190#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
191#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
192#[derive(csskit_derives::NodeWithMetadata)]
193pub enum MsFlexWrapStyleValue<'a> {}
194
195/// `-ms-flex-flow` — IE10 alias for `flex-flow`.
196#[syntax(" <'flex-direction'> || <'flex-wrap'> ")]
197#[derive(
198	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
199)]
200#[declaration_metadata(
201    initial = "see individual properties",
202    applies_to = Elements,
203    property_group = Flexbox,
204    computed_value_type = Unknown,
205    canonical_order = "per grammar",
206)]
207#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
208#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
209#[derive(csskit_derives::NodeWithMetadata)]
210pub struct MsFlexFlowStyleValue<'a>;
211
212/// `-ms-flex-positive` — IE10 alias for `flex-grow`.
213#[syntax(" <number [0,∞]> ")]
214#[derive(
215	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
216)]
217#[declaration_metadata(
218    initial = "0",
219    applies_to = Elements,
220    animation_type = ByComputedValue,
221    property_group = Flexbox,
222    computed_value_type = AsSpecified,
223    canonical_order = "per grammar",
224)]
225#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
226#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
227#[derive(csskit_derives::NodeWithMetadata)]
228pub struct MsFlexPositiveStyleValue<'a>;
229
230/// `-ms-flex-negative` — IE10 alias for `flex-shrink`.
231#[syntax(" <number [0,∞]> ")]
232#[derive(
233	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
234)]
235#[declaration_metadata(
236    initial = "1",
237    applies_to = Elements,
238    animation_type = ByComputedValue,
239    property_group = Flexbox,
240    computed_value_type = AsSpecified,
241    canonical_order = "per grammar",
242)]
243#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
244#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
245#[derive(csskit_derives::NodeWithMetadata)]
246pub struct MsFlexNegativeStyleValue<'a>;
247
248/// `-ms-flex-preferred-size` — IE10 alias for `flex-basis`.
249#[syntax(" content | <'width'> ")]
250#[derive(
251	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
252)]
253#[declaration_metadata(
254    initial = "auto",
255    applies_to = Elements,
256    animation_type = ByComputedValue,
257    property_group = Flexbox,
258    computed_value_type = Unknown,
259    canonical_order = "per grammar",
260)]
261#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
262#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
263#[derive(csskit_derives::NodeWithMetadata)]
264pub enum MsFlexPreferredSizeStyleValue<'a> {}
265
266/// `-ms-flex-pack` — IE10 alias for `justify-content`.
267///
268/// Uses legacy IE10 value names: `start`=`flex-start`, `end`=`flex-end`,
269/// `center`=`center`, `justify`=`space-between`, `distribute`=`space-around`.
270#[syntax(" start | end | center | justify | distribute ")]
271#[derive(
272	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
273)]
274#[declaration_metadata(
275    initial = "start",
276    applies_to = Elements,
277    animation_type = Discrete,
278    property_group = Flexbox,
279    computed_value_type = AsSpecified,
280    canonical_order = "per grammar",
281)]
282#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
283#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
284#[derive(csskit_derives::NodeWithMetadata)]
285pub enum MsFlexPackStyleValue<'a> {}
286
287/// `-ms-flex-align` — IE10 alias for `align-items`.
288///
289/// Uses legacy IE10 value names: `start`=`flex-start`, `end`=`flex-end`,
290/// `center`=`center`, `stretch`=`stretch`, `baseline`=`baseline`.
291#[syntax(" start | end | center | stretch | baseline ")]
292#[derive(
293	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
294)]
295#[declaration_metadata(
296    initial = "stretch",
297    applies_to = Elements,
298    animation_type = Discrete,
299    property_group = Flexbox,
300    computed_value_type = AsSpecified,
301    canonical_order = "per grammar",
302)]
303#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
304#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
305#[derive(csskit_derives::NodeWithMetadata)]
306pub enum MsFlexAlignStyleValue<'a> {}
307
308/// `-ms-flex-item-align` — IE10 alias for `align-self`.
309///
310/// Uses legacy IE10 value names: `auto`, `start`, `end`, `center`,
311/// `stretch`, `baseline`.
312#[syntax(" auto | start | end | center | stretch | baseline ")]
313#[derive(
314	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
315)]
316#[declaration_metadata(
317    initial = "auto",
318    applies_to = Elements,
319    animation_type = Discrete,
320    property_group = Flexbox,
321    computed_value_type = AsSpecified,
322    canonical_order = "per grammar",
323)]
324#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
325#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
326#[derive(csskit_derives::NodeWithMetadata)]
327pub enum MsFlexItemAlignStyleValue<'a> {}
328
329/// `-ms-flex-line-pack` — IE10 alias for `align-content`.
330///
331/// Uses legacy IE10 value names: `start`, `end`, `center`, `justify`,
332/// `distribute`, `stretch`.
333#[syntax(" start | end | center | justify | distribute | stretch ")]
334#[derive(
335	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
336)]
337#[declaration_metadata(
338    initial = "stretch",
339    applies_to = Elements,
340    animation_type = Discrete,
341    property_group = Flexbox,
342    computed_value_type = AsSpecified,
343    canonical_order = "per grammar",
344)]
345#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
346#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
347#[derive(csskit_derives::NodeWithMetadata)]
348pub enum MsFlexLinePackStyleValue<'a> {}
349
350/// `-ms-transform` — IE9 alias for `transform`.
351#[syntax(" none | <transform-list> ")]
352#[derive(
353	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
354)]
355#[declaration_metadata(
356    initial = "none",
357    applies_to = Elements,
358    animation_type = Unknown,
359    property_group = Transforms,
360    computed_value_type = AsSpecified,
361    canonical_order = "per grammar",
362)]
363#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
364#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
365#[derive(csskit_derives::NodeWithMetadata)]
366pub struct MsTransformStyleValue<'a>;
367
368/// Represents the style value for `-ms-transform-origin`.
369///
370/// Legacy alias for `transform-origin`. Accepts the same grammar.
371///
372/// The grammar is defined as:
373///
374/// ```text,ignore
375/// <position-one> | <position-two> <length>?
376/// ```
377#[syntax(" <position-one> | <position-two> <length>? ")]
378#[derive(
379	Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
380)]
381#[declaration_metadata(
382    initial = "none",
383    applies_to = Unknown,
384    animation_type = Unknown,
385    property_group = FilterEffects,
386    computed_value_type = AsSpecified,
387    canonical_order = "per grammar",
388)]
389#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
390#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
391#[derive(csskit_derives::NodeWithMetadata)]
392pub enum MsTransformOriginStyleValue<'a> {}
393
394impl<'a> Parse<'a> for MsTransformOriginStyleValue<'a> {
395	fn parse<I>(p: &mut Parser<'a, I>) -> ParseResult<Self>
396	where
397		I: Iterator<Item = Cursor> + Clone,
398	{
399		let first = p.parse::<PositionOne>()?;
400		if !p.peek::<PositionOne>() {
401			return Ok(Self::PositionOne(crate::Value::Literal(first)));
402		}
403		let second_c = p.peek_n(1);
404		let second = p.parse::<PositionOne>()?;
405		let two = PositionTwo::from_two(p, first, second, second_c)?;
406		Ok(Self::PositionTwo(crate::Value::Literal(two), p.parse_if_peek::<CalcableValue<Length>>()?))
407	}
408}
409
410/// `-ms-filter` — IE8/IE9 `filter` alias.
411///
412/// IE8 used a quoted string with proprietary `progid:DXImageTransform` syntax.
413/// IE9+ accepted the same CSS filter functions as the standard `filter` property.
414///
415/// The grammar is:
416///
417/// ```text,ignore
418/// none | <string> | <filter-value-list>
419/// ```
420#[node]
421#[derive(
422	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
423)]
424#[declaration_metadata(
425    initial = "none",
426    applies_to = Elements,
427    animation_type = Unknown,
428    property_group = FilterEffects,
429    computed_value_type = AsSpecified,
430    canonical_order = "per grammar",
431)]
432#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
433#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
434#[derive(csskit_derives::NodeWithMetadata)]
435pub enum MsFilterStyleValue<'a> {
436	None(#[atom(CssAtomSet::None)] T![Ident]),
437	String(T![String]),
438	FilterValueList(FilterValueList<'a>),
439}
440
441/// `-ms-word-break` — IE alias for `word-break`.
442#[syntax(" normal | break-all | keep-all | manual | auto-phrase | break-word ")]
443#[derive(
444	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
445)]
446#[declaration_metadata(
447    initial = "normal",
448    inherits,
449    applies_to = Text,
450    animation_type = Discrete,
451    property_group = Text,
452    computed_value_type = Unknown,
453    canonical_order = "n/a",
454)]
455#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
456#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
457#[derive(csskit_derives::NodeWithMetadata)]
458pub enum MsWordBreakStyleValue<'a> {}
459
460/// `-ms-transition` — IE10 alias for `transition`.
461#[syntax(" <single-transition># ")]
462#[derive(
463	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
464)]
465#[declaration_metadata(
466    initial = "see individual properties",
467    applies_to = Elements,
468    property_group = Transitions,
469    computed_value_type = Unknown,
470    canonical_order = "per grammar",
471)]
472#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
473#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
474#[derive(csskit_derives::NodeWithMetadata)]
475pub struct MsTransitionStyleValue<'a>;
476
477#[cfg(test)]
478mod tests {
479	use super::*;
480	use crate::CssAtomSet;
481	use css_parse::{assert_parse, assert_parse_error, assert_peek_false};
482
483	#[test]
484	fn test_ms_interpolation_mode_parses() {
485		assert_parse!(CssAtomSet::ATOMS, MsInterpolationModeStyleValue, "nearest-neighbor");
486		assert_parse!(CssAtomSet::ATOMS, MsInterpolationModeStyleValue, "bicubic");
487	}
488
489	#[test]
490	fn test_ms_interpolation_mode_errors() {
491		assert_peek_false!(CssAtomSet::ATOMS, MsInterpolationModeStyleValue, "auto");
492		assert_peek_false!(CssAtomSet::ATOMS, MsInterpolationModeStyleValue, "invalid");
493	}
494
495	#[test]
496	fn test_ms_box_sizing_parses() {
497		assert_parse!(CssAtomSet::ATOMS, MsBoxSizingStyleValue, "content-box");
498		assert_parse!(CssAtomSet::ATOMS, MsBoxSizingStyleValue, "border-box");
499	}
500
501	#[test]
502	fn test_ms_box_sizing_errors() {
503		assert_peek_false!(CssAtomSet::ATOMS, MsBoxSizingStyleValue, "invalid");
504	}
505
506	#[test]
507	fn test_ms_overflow_style_parses() {
508		assert_parse!(CssAtomSet::ATOMS, MsOverflowStyleStyleValue, "auto");
509		assert_parse!(CssAtomSet::ATOMS, MsOverflowStyleStyleValue, "none");
510		assert_parse!(CssAtomSet::ATOMS, MsOverflowStyleStyleValue, "scrollbar");
511		assert_parse!(CssAtomSet::ATOMS, MsOverflowStyleStyleValue, "-ms-autohiding-scrollbar");
512	}
513
514	#[test]
515	fn test_ms_overflow_style_errors() {
516		assert_peek_false!(CssAtomSet::ATOMS, MsOverflowStyleStyleValue, "invalid");
517	}
518
519	#[test]
520	fn test_ms_touch_action_parses() {
521		assert_parse!(CssAtomSet::ATOMS, MsTouchActionStyleValue, "auto");
522		assert_parse!(CssAtomSet::ATOMS, MsTouchActionStyleValue, "none");
523		assert_parse!(CssAtomSet::ATOMS, MsTouchActionStyleValue, "manipulation");
524		assert_parse!(CssAtomSet::ATOMS, MsTouchActionStyleValue, "pan-y");
525		assert_parse!(CssAtomSet::ATOMS, MsTouchActionStyleValue, "pan-x pan-y");
526	}
527
528	#[test]
529	fn test_ms_touch_action_errors() {
530		assert_peek_false!(CssAtomSet::ATOMS, MsTouchActionStyleValue, "invalid");
531	}
532
533	#[test]
534	fn test_ms_user_select_parses() {
535		assert_parse!(CssAtomSet::ATOMS, MsUserSelectStyleValue, "none");
536		assert_parse!(CssAtomSet::ATOMS, MsUserSelectStyleValue, "auto");
537		assert_parse!(CssAtomSet::ATOMS, MsUserSelectStyleValue, "all");
538	}
539
540	#[test]
541	fn test_ms_user_select_errors() {
542		assert_peek_false!(CssAtomSet::ATOMS, MsUserSelectStyleValue, "invalid");
543	}
544
545	#[test]
546	fn test_ms_text_size_adjust_parses() {
547		assert_parse!(CssAtomSet::ATOMS, MsTextSizeAdjustStyleValue, "auto");
548		assert_parse!(CssAtomSet::ATOMS, MsTextSizeAdjustStyleValue, "none");
549		assert_parse!(CssAtomSet::ATOMS, MsTextSizeAdjustStyleValue, "100%");
550	}
551
552	#[test]
553	fn test_ms_text_size_adjust_errors() {
554		assert_peek_false!(CssAtomSet::ATOMS, MsTextSizeAdjustStyleValue, "invalid");
555	}
556
557	#[test]
558	fn test_ms_flex_parses() {
559		assert_parse!(CssAtomSet::ATOMS, MsFlexStyleValue, "none");
560		assert_parse!(CssAtomSet::ATOMS, MsFlexStyleValue, "1");
561		assert_parse!(CssAtomSet::ATOMS, MsFlexStyleValue, "0 0 auto");
562		assert_parse!(CssAtomSet::ATOMS, MsFlexStyleValue, "0 0 100%");
563	}
564
565	#[test]
566	fn test_ms_flex_errors() {
567		assert_peek_false!(CssAtomSet::ATOMS, MsFlexStyleValue, "invalid");
568	}
569
570	#[test]
571	fn test_ms_flex_order_parses() {
572		assert_parse!(CssAtomSet::ATOMS, MsFlexOrderStyleValue, "0");
573		assert_parse!(CssAtomSet::ATOMS, MsFlexOrderStyleValue, "-1");
574		assert_parse!(CssAtomSet::ATOMS, MsFlexOrderStyleValue, "8");
575	}
576
577	#[test]
578	fn test_ms_flex_direction_parses() {
579		assert_parse!(CssAtomSet::ATOMS, MsFlexDirectionStyleValue, "row");
580		assert_parse!(CssAtomSet::ATOMS, MsFlexDirectionStyleValue, "column");
581		assert_parse!(CssAtomSet::ATOMS, MsFlexDirectionStyleValue, "row-reverse");
582		assert_parse!(CssAtomSet::ATOMS, MsFlexDirectionStyleValue, "column-reverse");
583	}
584
585	#[test]
586	fn test_ms_flex_direction_errors() {
587		assert_peek_false!(CssAtomSet::ATOMS, MsFlexDirectionStyleValue, "invalid");
588	}
589
590	#[test]
591	fn test_ms_flex_wrap_parses() {
592		assert_parse!(CssAtomSet::ATOMS, MsFlexWrapStyleValue, "nowrap");
593		assert_parse!(CssAtomSet::ATOMS, MsFlexWrapStyleValue, "wrap");
594		assert_parse!(CssAtomSet::ATOMS, MsFlexWrapStyleValue, "wrap-reverse");
595	}
596
597	#[test]
598	fn test_ms_flex_wrap_errors() {
599		assert_peek_false!(CssAtomSet::ATOMS, MsFlexWrapStyleValue, "invalid");
600	}
601
602	#[test]
603	fn test_ms_flex_pack_parses() {
604		assert_parse!(CssAtomSet::ATOMS, MsFlexPackStyleValue, "start");
605		assert_parse!(CssAtomSet::ATOMS, MsFlexPackStyleValue, "end");
606		assert_parse!(CssAtomSet::ATOMS, MsFlexPackStyleValue, "center");
607		assert_parse!(CssAtomSet::ATOMS, MsFlexPackStyleValue, "justify");
608		assert_parse!(CssAtomSet::ATOMS, MsFlexPackStyleValue, "distribute");
609	}
610
611	#[test]
612	fn test_ms_flex_pack_errors() {
613		assert_peek_false!(CssAtomSet::ATOMS, MsFlexPackStyleValue, "invalid");
614	}
615
616	#[test]
617	fn test_ms_flex_align_parses() {
618		assert_parse!(CssAtomSet::ATOMS, MsFlexAlignStyleValue, "start");
619		assert_parse!(CssAtomSet::ATOMS, MsFlexAlignStyleValue, "end");
620		assert_parse!(CssAtomSet::ATOMS, MsFlexAlignStyleValue, "center");
621		assert_parse!(CssAtomSet::ATOMS, MsFlexAlignStyleValue, "stretch");
622		assert_parse!(CssAtomSet::ATOMS, MsFlexAlignStyleValue, "baseline");
623	}
624
625	#[test]
626	fn test_ms_flex_align_errors() {
627		assert_peek_false!(CssAtomSet::ATOMS, MsFlexAlignStyleValue, "invalid");
628	}
629
630	#[test]
631	fn test_ms_flex_item_align_parses() {
632		assert_parse!(CssAtomSet::ATOMS, MsFlexItemAlignStyleValue, "auto");
633		assert_parse!(CssAtomSet::ATOMS, MsFlexItemAlignStyleValue, "start");
634		assert_parse!(CssAtomSet::ATOMS, MsFlexItemAlignStyleValue, "end");
635		assert_parse!(CssAtomSet::ATOMS, MsFlexItemAlignStyleValue, "center");
636		assert_parse!(CssAtomSet::ATOMS, MsFlexItemAlignStyleValue, "stretch");
637		assert_parse!(CssAtomSet::ATOMS, MsFlexItemAlignStyleValue, "baseline");
638	}
639
640	#[test]
641	fn test_ms_flex_item_align_errors() {
642		assert_peek_false!(CssAtomSet::ATOMS, MsFlexItemAlignStyleValue, "invalid");
643	}
644
645	#[test]
646	fn test_ms_flex_line_pack_parses() {
647		assert_parse!(CssAtomSet::ATOMS, MsFlexLinePackStyleValue, "start");
648		assert_parse!(CssAtomSet::ATOMS, MsFlexLinePackStyleValue, "end");
649		assert_parse!(CssAtomSet::ATOMS, MsFlexLinePackStyleValue, "center");
650		assert_parse!(CssAtomSet::ATOMS, MsFlexLinePackStyleValue, "justify");
651		assert_parse!(CssAtomSet::ATOMS, MsFlexLinePackStyleValue, "distribute");
652		assert_parse!(CssAtomSet::ATOMS, MsFlexLinePackStyleValue, "stretch");
653	}
654
655	#[test]
656	fn test_ms_flex_line_pack_errors() {
657		assert_peek_false!(CssAtomSet::ATOMS, MsFlexLinePackStyleValue, "invalid");
658	}
659
660	#[test]
661	fn test_ms_transform_parses() {
662		assert_parse!(CssAtomSet::ATOMS, MsTransformStyleValue, "none");
663		assert_parse!(CssAtomSet::ATOMS, MsTransformStyleValue, "rotate(45deg)");
664		assert_parse!(CssAtomSet::ATOMS, MsTransformStyleValue, "scale(-1, 1)");
665	}
666
667	#[test]
668	fn test_ms_transform_errors() {
669		assert_peek_false!(CssAtomSet::ATOMS, MsTransformStyleValue, "invalid");
670	}
671
672	#[test]
673	fn test_ms_filter_parses() {
674		assert_parse!(CssAtomSet::ATOMS, MsFilterStyleValue, "none");
675		assert_parse!(CssAtomSet::ATOMS, MsFilterStyleValue, "blur(4px)");
676		assert_parse!(
677			CssAtomSet::ATOMS,
678			MsFilterStyleValue,
679			"\"progid:DXImageTransform.Microsoft.blur(pixelradius=2)\""
680		);
681	}
682
683	#[test]
684	fn test_ms_filter_errors() {
685		assert_peek_false!(CssAtomSet::ATOMS, MsFilterStyleValue, "invalid");
686	}
687
688	#[test]
689	fn test_ms_word_break_parses() {
690		assert_parse!(CssAtomSet::ATOMS, MsWordBreakStyleValue, "normal");
691		assert_parse!(CssAtomSet::ATOMS, MsWordBreakStyleValue, "break-all");
692		assert_parse!(CssAtomSet::ATOMS, MsWordBreakStyleValue, "keep-all");
693	}
694
695	#[test]
696	fn test_ms_word_break_errors() {
697		assert_peek_false!(CssAtomSet::ATOMS, MsWordBreakStyleValue, "invalid");
698	}
699
700	#[test]
701	fn test_ms_transition_parses() {
702		assert_parse!(CssAtomSet::ATOMS, MsTransitionStyleValue, "none");
703		assert_parse!(CssAtomSet::ATOMS, MsTransitionStyleValue, "all 0.3s ease");
704	}
705
706	#[test]
707	fn test_ms_transition_errors() {
708		assert_parse_error!(CssAtomSet::ATOMS, MsTransitionStyleValue, "invalid!!!!");
709	}
710}