flex.rs

//! CSS properties related to flexbox layout.

use super::align::{
  AlignContent, AlignItems, AlignSelf, ContentDistribution, ContentPosition, JustifyContent, SelfPosition,
};
use super::{Property, PropertyId};
use crate::context::PropertyHandlerContext;
use crate::declaration::{DeclarationBlock, DeclarationList};
use crate::error::{ParserError, PrinterError};
use crate::macros::*;
use crate::prefixes::{is_flex_2009, Feature};
use crate::printer::Printer;
use crate::targets::Browsers;
use crate::traits::{FromStandard, Parse, PropertyHandler, Shorthand, ToCss, Zero};
use crate::values::number::{CSSInteger, CSSNumber};
use crate::values::{
  length::{LengthPercentage, LengthPercentageOrAuto},
  percentage::Percentage,
};
use crate::vendor_prefix::VendorPrefix;
#[cfg(feature = "visitor")]
use crate::visitor::Visit;
use cssparser::*;

enum_property! {
  /// A value for the [flex-direction](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#propdef-flex-direction) property.
  pub enum FlexDirection {
    /// Flex items are laid out in a row.
    "row": Row,
    /// Flex items are laid out in a row, and reversed.
    "row-reverse": RowReverse,
    /// Flex items are laid out in a column.
    "column": Column,
    /// Flex items are laid out in a column, and reversed.
    "column-reverse": ColumnReverse,
  }
}

impl Default for FlexDirection {
  fn default() -> FlexDirection {
    FlexDirection::Row
  }
}

enum_property! {
  /// A value for the [flex-wrap](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-wrap-property) property.
  pub enum FlexWrap {
    /// The flex items do not wrap.
    "nowrap": NoWrap,
    /// The flex items wrap.
    "wrap": Wrap,
    /// The flex items wrap, in reverse.
    "wrap-reverse": WrapReverse,
  }
}

impl Default for FlexWrap {
  fn default() -> FlexWrap {
    FlexWrap::NoWrap
  }
}

impl FromStandard<FlexWrap> for FlexWrap {
  fn from_standard(wrap: &FlexWrap) -> Option<FlexWrap> {
    Some(wrap.clone())
  }
}

define_shorthand! {
  /// A value for the [flex-flow](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-flow-property) shorthand property.
  pub struct FlexFlow(VendorPrefix) {
    /// The direction that flex items flow.
    direction: FlexDirection(FlexDirection, VendorPrefix),
    /// How the flex items wrap.
    wrap: FlexWrap(FlexWrap, VendorPrefix),
  }
}

impl<'i> Parse<'i> for FlexFlow {
  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
    let mut direction = None;
    let mut wrap = None;
    loop {
      if direction.is_none() {
        if let Ok(value) = input.try_parse(FlexDirection::parse) {
          direction = Some(value);
          continue;
        }
      }
      if wrap.is_none() {
        if let Ok(value) = input.try_parse(FlexWrap::parse) {
          wrap = Some(value);
          continue;
        }
      }
      break;
    }

    Ok(FlexFlow {
      direction: direction.unwrap_or_default(),
      wrap: wrap.unwrap_or_default(),
    })
  }
}

impl ToCss for FlexFlow {
  fn to_css<W>(&self, dest: &mut Printer<W>) -> Result<(), PrinterError>
  where
    W: std::fmt::Write,
  {
    let mut needs_space = false;
    if self.direction != FlexDirection::default() || self.wrap == FlexWrap::default() {
      self.direction.to_css(dest)?;
      needs_space = true;
    }

    if self.wrap != FlexWrap::default() {
      if needs_space {
        dest.write_str(" ")?;
      }
      self.wrap.to_css(dest)?;
    }

    Ok(())
  }
}

define_shorthand! {
/// A value for the [flex](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-property) shorthand property.
  pub struct Flex(VendorPrefix) {
    /// The flex grow factor.
    grow: FlexGrow(CSSNumber, VendorPrefix),
    /// The flex shrink factor.
    shrink: FlexShrink(CSSNumber, VendorPrefix),
    /// The flex basis.
    basis: FlexBasis(LengthPercentageOrAuto, VendorPrefix),
  }
}

impl<'i> Parse<'i> for Flex {
  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
    if input.try_parse(|input| input.expect_ident_matching("none")).is_ok() {
      return Ok(Flex {
        grow: 0.0,
        shrink: 0.0,
        basis: LengthPercentageOrAuto::Auto,
      });
    }

    let mut grow = None;
    let mut shrink = None;
    let mut basis = None;

    loop {
      if grow.is_none() {
        if let Ok(val) = input.try_parse(CSSNumber::parse) {
          grow = Some(val);
          shrink = input.try_parse(CSSNumber::parse).ok();
          continue;
        }
      }

      if basis.is_none() {
        if let Ok(val) = input.try_parse(LengthPercentageOrAuto::parse) {
          basis = Some(val);
          continue;
        }
      }

      break;
    }

    Ok(Flex {
      grow: grow.unwrap_or(1.0),
      shrink: shrink.unwrap_or(1.0),
      basis: basis.unwrap_or(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::Percentage(
        Percentage(0.0),
      ))),
    })
  }
}

impl ToCss for Flex {
  fn to_css<W>(&self, dest: &mut Printer<W>) -> Result<(), PrinterError>
  where
    W: std::fmt::Write,
  {
    if self.grow == 0.0 && self.shrink == 0.0 && self.basis == LengthPercentageOrAuto::Auto {
      dest.write_str("none")?;
      return Ok(());
    }

    #[derive(PartialEq)]
    enum ZeroKind {
      NonZero,
      Length,
      Percentage,
    }

    // If the basis is unitless 0, we must write all three components to disambiguate.
    // If the basis is 0%, we can omit the basis.
    let basis_kind = match &self.basis {
      LengthPercentageOrAuto::LengthPercentage(lp) => match lp {
        LengthPercentage::Dimension(l) if l.is_zero() => ZeroKind::Length,
        LengthPercentage::Percentage(p) if p.is_zero() => ZeroKind::Percentage,
        _ => ZeroKind::NonZero,
      },
      _ => ZeroKind::NonZero,
    };

    if self.grow != 1.0 || self.shrink != 1.0 || basis_kind != ZeroKind::NonZero {
      self.grow.to_css(dest)?;
      if self.shrink != 1.0 || basis_kind == ZeroKind::Length {
        dest.write_str(" ")?;
        self.shrink.to_css(dest)?;
      }
    }

    if basis_kind != ZeroKind::Percentage {
      if self.grow != 1.0 || self.shrink != 1.0 || basis_kind == ZeroKind::Length {
        dest.write_str(" ")?;
      }
      self.basis.to_css(dest)?;
    }

    Ok(())
  }
}

// Old flex (2009): https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/

enum_property! {
  /// A value for the legacy (prefixed) [box-orient](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#orientation) property.
  /// Partially equivalent to `flex-direction` in the standard syntax.
  pub enum BoxOrient {
    /// Items are laid out horizontally.
    "horizontal": Horizontal,
    /// Items are laid out vertically.
    "vertical": Vertical,
    /// Items are laid out along the inline axis, according to the writing direction.
    "inline-axis": InlineAxis,
    /// Items are laid out along the block axis, according to the writing direction.
    "block-axis": BlockAxis,
  }
}

impl FlexDirection {
  fn to_2009(&self) -> (BoxOrient, BoxDirection) {
    match self {
      FlexDirection::Row => (BoxOrient::Horizontal, BoxDirection::Normal),
      FlexDirection::Column => (BoxOrient::Vertical, BoxDirection::Normal),
      FlexDirection::RowReverse => (BoxOrient::Horizontal, BoxDirection::Reverse),
      FlexDirection::ColumnReverse => (BoxOrient::Vertical, BoxDirection::Reverse),
    }
  }
}

enum_property! {
  /// A value for the legacy (prefixed) [box-direction](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#displayorder) property.
  /// Partially equivalent to the `flex-direction` property in the standard syntax.
  pub enum BoxDirection {
    /// Items flow in the natural direction.
    Normal,
    /// Items flow in the reverse direction.
    Reverse,
  }
}

enum_property! {
  /// A value for the legacy (prefixed) [box-align](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment) property.
  /// Equivalent to the `align-items` property in the standard syntax.
  pub enum BoxAlign {
    /// Items are aligned to the start.
    Start,
    /// Items are aligned to the end.
    End,
    /// Items are centered.
    Center,
    /// Items are aligned to the baseline.
    Baseline,
    /// Items are stretched.
    Stretch,
  }
}

impl FromStandard<AlignItems> for BoxAlign {
  fn from_standard(align: &AlignItems) -> Option<BoxAlign> {
    match align {
      AlignItems::SelfPosition { overflow: None, value } => match value {
        SelfPosition::Start | SelfPosition::FlexStart => Some(BoxAlign::Start),
        SelfPosition::End | SelfPosition::FlexEnd => Some(BoxAlign::End),
        SelfPosition::Center => Some(BoxAlign::Center),
        _ => None,
      },
      AlignItems::Stretch => Some(BoxAlign::Stretch),
      _ => None,
    }
  }
}

enum_property! {
  /// A value for the legacy (prefixed) [box-pack](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#packing) property.
  /// Equivalent to the `justify-content` property in the standard syntax.
  pub enum BoxPack {
    /// Items are justified to the start.
    Start,
    /// Items are justified to the end.
    End,
    /// Items are centered.
    Center,
    /// Items are justifed to the start and end.
    Justify,
  }
}

impl FromStandard<JustifyContent> for BoxPack {
  fn from_standard(justify: &JustifyContent) -> Option<BoxPack> {
    match justify {
      JustifyContent::ContentDistribution(cd) => match cd {
        ContentDistribution::SpaceBetween => Some(BoxPack::Justify),
        _ => None,
      },
      JustifyContent::ContentPosition { overflow: None, value } => match value {
        ContentPosition::Start | ContentPosition::FlexStart => Some(BoxPack::Start),
        ContentPosition::End | ContentPosition::FlexEnd => Some(BoxPack::End),
        ContentPosition::Center => Some(BoxPack::Center),
      },
      _ => None,
    }
  }
}

enum_property! {
  /// A value for the legacy (prefixed) [box-lines](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#multiple) property.
  /// Equivalent to the `flex-wrap` property in the standard syntax.
  pub enum BoxLines {
    /// Items are laid out in a single line.
    Single,
    /// Items may wrap into multiple lines.
    Multiple,
  }
}

impl FromStandard<FlexWrap> for BoxLines {
  fn from_standard(wrap: &FlexWrap) -> Option<BoxLines> {
    match wrap {
      FlexWrap::NoWrap => Some(BoxLines::Single),
      FlexWrap::Wrap => Some(BoxLines::Multiple),
      _ => None,
    }
  }
}

type BoxOrdinalGroup = CSSInteger;
impl FromStandard<CSSInteger> for BoxOrdinalGroup {
  fn from_standard(order: &CSSInteger) -> Option<BoxOrdinalGroup> {
    Some(*order)
  }
}

// Old flex (2012): https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/

enum_property! {
  /// A value for the legacy (prefixed) [flex-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack) property.
  /// Equivalent to the `justify-content` property in the standard syntax.
  pub enum FlexPack {
    /// Items are justified to the start.
    Start,
    /// Items are justified to the end.
    End,
    /// Items are centered.
    Center,
    /// Items are justified to the start and end.
    Justify,
    /// Items are distributed evenly, with half size spaces on either end.
    Distribute,
  }
}

impl FromStandard<JustifyContent> for FlexPack {
  fn from_standard(justify: &JustifyContent) -> Option<FlexPack> {
    match justify {
      JustifyContent::ContentDistribution(cd) => match cd {
        ContentDistribution::SpaceBetween => Some(FlexPack::Justify),
        ContentDistribution::SpaceAround => Some(FlexPack::Distribute),
        _ => None,
      },
      JustifyContent::ContentPosition { overflow: None, value } => match value {
        ContentPosition::Start | ContentPosition::FlexStart => Some(FlexPack::Start),
        ContentPosition::End | ContentPosition::FlexEnd => Some(FlexPack::End),
        ContentPosition::Center => Some(FlexPack::Center),
      },
      _ => None,
    }
  }
}

/// A value for the legacy (prefixed) [flex-align](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align) property.
pub type FlexAlign = BoxAlign;

enum_property! {
  /// A value for the legacy (prefixed) [flex-item-align](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align) property.
  /// Equivalent to the `align-self` property in the standard syntax.
  pub enum FlexItemAlign {
    /// Equivalent to the value of `flex-align`.
    Auto,
    /// The item is aligned to the start.
    Start,
    /// The item is aligned to the end.
    End,
    /// The item is centered.
    Center,
    /// The item is aligned to the baseline.
    Baseline,
    /// The item is stretched.
    Stretch,
  }
}

impl FromStandard<AlignSelf> for FlexItemAlign {
  fn from_standard(justify: &AlignSelf) -> Option<FlexItemAlign> {
    match justify {
      AlignSelf::Auto => Some(FlexItemAlign::Auto),
      AlignSelf::Stretch => Some(FlexItemAlign::Stretch),
      AlignSelf::SelfPosition { overflow: None, value } => match value {
        SelfPosition::Start | SelfPosition::FlexStart => Some(FlexItemAlign::Start),
        SelfPosition::End | SelfPosition::FlexEnd => Some(FlexItemAlign::End),
        SelfPosition::Center => Some(FlexItemAlign::Center),
        _ => None,
      },
      _ => None,
    }
  }
}

enum_property! {
  /// A value for the legacy (prefixed) [flex-line-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack) property.
  /// Equivalent to the `align-content` property in the standard syntax.
  pub enum FlexLinePack {
    /// Content is aligned to the start.
    Start,
    /// Content is aligned to the end.
    End,
    /// Content is centered.
    Center,
    /// Content is justified.
    Justify,
    /// Content is distributed evenly, with half size spaces on either end.
    Distribute,
    /// Content is stretched.
    Stretch,
  }
}

impl FromStandard<AlignContent> for FlexLinePack {
  fn from_standard(justify: &AlignContent) -> Option<FlexLinePack> {
    match justify {
      AlignContent::ContentDistribution(cd) => match cd {
        ContentDistribution::SpaceBetween => Some(FlexLinePack::Justify),
        ContentDistribution::SpaceAround => Some(FlexLinePack::Distribute),
        ContentDistribution::Stretch => Some(FlexLinePack::Stretch),
        _ => None,
      },
      AlignContent::ContentPosition { overflow: None, value } => match value {
        ContentPosition::Start | ContentPosition::FlexStart => Some(FlexLinePack::Start),
        ContentPosition::End | ContentPosition::FlexEnd => Some(FlexLinePack::End),
        ContentPosition::Center => Some(FlexLinePack::Center),
      },
      _ => None,
    }
  }
}

#[derive(Default, Debug)]
pub(crate) struct FlexHandler {
  targets: Option<Browsers>,
  direction: Option<(FlexDirection, VendorPrefix)>,
  box_orient: Option<(BoxOrient, VendorPrefix)>,
  box_direction: Option<(BoxDirection, VendorPrefix)>,
  wrap: Option<(FlexWrap, VendorPrefix)>,
  box_lines: Option<(BoxLines, VendorPrefix)>,
  grow: Option<(CSSNumber, VendorPrefix)>,
  box_flex: Option<(CSSNumber, VendorPrefix)>,
  flex_positive: Option<(CSSNumber, VendorPrefix)>,
  shrink: Option<(CSSNumber, VendorPrefix)>,
  flex_negative: Option<(CSSNumber, VendorPrefix)>,
  basis: Option<(LengthPercentageOrAuto, VendorPrefix)>,
  preferred_size: Option<(LengthPercentageOrAuto, VendorPrefix)>,
  order: Option<(CSSInteger, VendorPrefix)>,
  box_ordinal_group: Option<(BoxOrdinalGroup, VendorPrefix)>,
  flex_order: Option<(CSSInteger, VendorPrefix)>,
  has_any: bool,
}

impl FlexHandler {
  pub fn new(targets: Option<Browsers>) -> FlexHandler {
    FlexHandler {
      targets,
      ..FlexHandler::default()
    }
  }
}

impl<'i> PropertyHandler<'i> for FlexHandler {
  fn handle_property(
    &mut self,
    property: &Property<'i>,
    dest: &mut DeclarationList<'i>,
    _: &mut PropertyHandlerContext<'i, '_>,
  ) -> bool {
    use Property::*;

    macro_rules! maybe_flush {
      ($prop: ident, $val: expr, $vp: ident) => {{
        // If two vendor prefixes for the same property have different
        // values, we need to flush what we have immediately to preserve order.
        if let Some((val, prefixes)) = &self.$prop {
          if val != $val && !prefixes.contains(*$vp) {
            self.flush(dest);
          }
        }
      }};
    }

    macro_rules! property {
      ($prop: ident, $val: expr, $vp: ident) => {{
        maybe_flush!($prop, $val, $vp);

        // Otherwise, update the value and add the prefix.
        if let Some((val, prefixes)) = &mut self.$prop {
          *val = $val.clone();
          *prefixes |= *$vp;
        } else {
          self.$prop = Some(($val.clone(), *$vp));
          self.has_any = true;
        }
      }};
    }

    match property {
      FlexDirection(val, vp) => {
        if self.targets.is_some() {
          self.box_direction = None;
          self.box_orient = None;
        }
        property!(direction, val, vp);
      }
      BoxOrient(val, vp) => property!(box_orient, val, vp),
      BoxDirection(val, vp) => property!(box_direction, val, vp),
      FlexWrap(val, vp) => {
        if self.targets.is_some() {
          self.box_lines = None;
        }
        property!(wrap, val, vp);
      }
      BoxLines(val, vp) => property!(box_lines, val, vp),
      FlexFlow(val, vp) => {
        if self.targets.is_some() {
          self.box_direction = None;
          self.box_orient = None;
        }
        property!(direction, &val.direction, vp);
        property!(wrap, &val.wrap, vp);
      }
      FlexGrow(val, vp) => {
        if self.targets.is_some() {
          self.box_flex = None;
          self.flex_positive = None;
        }
        property!(grow, val, vp);
      }
      BoxFlex(val, vp) => property!(box_flex, val, vp),
      FlexPositive(val, vp) => property!(flex_positive, val, vp),
      FlexShrink(val, vp) => {
        if self.targets.is_some() {
          self.flex_negative = None;
        }
        property!(shrink, val, vp);
      }
      FlexNegative(val, vp) => property!(flex_negative, val, vp),
      FlexBasis(val, vp) => {
        if self.targets.is_some() {
          self.preferred_size = None;
        }
        property!(basis, val, vp);
      }
      FlexPreferredSize(val, vp) => property!(preferred_size, val, vp),
      Flex(val, vp) => {
        if self.targets.is_some() {
          self.box_flex = None;
          self.flex_positive = None;
          self.flex_negative = None;
          self.preferred_size = None;
        }
        maybe_flush!(grow, &val.grow, vp);
        maybe_flush!(shrink, &val.shrink, vp);
        maybe_flush!(basis, &val.basis, vp);
        property!(grow, &val.grow, vp);
        property!(shrink, &val.shrink, vp);
        property!(basis, &val.basis, vp);
      }
      Order(val, vp) => {
        if self.targets.is_some() {
          self.box_ordinal_group = None;
          self.flex_order = None;
        }
        property!(order, val, vp);
      }
      BoxOrdinalGroup(val, vp) => property!(box_ordinal_group, val, vp),
      FlexOrder(val, vp) => property!(flex_order, val, vp),
      Unparsed(val) if is_flex_property(&val.property_id) => {
        self.flush(dest);
        dest.push(property.clone()) // TODO: prefix?
      }
      _ => return false,
    }

    true
  }

  fn finalize(&mut self, dest: &mut DeclarationList, _: &mut PropertyHandlerContext<'i, '_>) {
    self.flush(dest);
  }
}

impl FlexHandler {
  fn flush(&mut self, dest: &mut DeclarationList) {
    if !self.has_any {
      return;
    }

    self.has_any = false;

    let mut direction = std::mem::take(&mut self.direction);
    let mut wrap = std::mem::take(&mut self.wrap);
    let mut grow = std::mem::take(&mut self.grow);
    let mut shrink = std::mem::take(&mut self.shrink);
    let mut basis = std::mem::take(&mut self.basis);
    let box_orient = std::mem::take(&mut self.box_orient);
    let box_direction = std::mem::take(&mut self.box_direction);
    let box_flex = std::mem::take(&mut self.box_flex);
    let box_ordinal_group = std::mem::take(&mut self.box_ordinal_group);
    let box_lines = std::mem::take(&mut self.box_lines);
    let flex_positive = std::mem::take(&mut self.flex_positive);
    let flex_negative = std::mem::take(&mut self.flex_negative);
    let preferred_size = std::mem::take(&mut self.preferred_size);
    let order = std::mem::take(&mut self.order);
    let flex_order = std::mem::take(&mut self.flex_order);

    macro_rules! single_property {
      ($prop: ident, $key: ident $(, 2012: $prop_2012: ident )? $(, 2009: $prop_2009: ident )?) => {
        if let Some((val, prefix)) = $key {
          if !prefix.is_empty() {
            let mut prefix = prefix;
            if prefix.contains(VendorPrefix::None) {
              if let Some(targets) = self.targets {
                prefix = Feature::$prop.prefixes_for(targets);

                // 2009 spec, implemented by webkit and firefox.
                $(
                  let mut prefixes_2009 = VendorPrefix::empty();
                  if is_flex_2009(targets) {
                    prefixes_2009 |= VendorPrefix::WebKit;
                  }
                  if prefix.contains(VendorPrefix::Moz) {
                    prefixes_2009 |= VendorPrefix::Moz;
                  }
                  if !prefixes_2009.is_empty() {
                    if let Some(v) = $prop_2009::from_standard(&val) {
                      dest.push(Property::$prop_2009(v, prefixes_2009));
                    }
                  }
                )?

                $(
                  let mut ms = true;
                  if prefix.contains(VendorPrefix::Ms) {
                    dest.push(Property::$prop_2012(val.clone(), VendorPrefix::Ms));
                    ms = false;
                  }
                  if !ms {
                    prefix.remove(VendorPrefix::Ms);
                  }
                )?

                // Firefox only implemented the 2009 spec prefixed.
                prefix.remove(VendorPrefix::Moz);
              }
            }
            dest.push(Property::$prop(val, prefix))
          }
        }
      };
    }

    macro_rules! legacy_property {
      ($prop: ident, $key: expr) => {
        if let Some((val, prefix)) = $key {
          if !prefix.is_empty() {
            dest.push(Property::$prop(val, prefix))
          }
        }
      };
    }

    // Legacy properties. These are only set if the final standard properties were unset.
    legacy_property!(BoxOrient, box_orient);
    legacy_property!(BoxDirection, box_direction);
    legacy_property!(BoxOrdinalGroup, box_ordinal_group);
    legacy_property!(BoxFlex, box_flex);
    legacy_property!(BoxLines, box_lines);
    legacy_property!(FlexPositive, flex_positive);
    legacy_property!(FlexNegative, flex_negative);
    legacy_property!(FlexPreferredSize, preferred_size.clone());
    legacy_property!(FlexOrder, flex_order.clone());

    if let Some((direction, _)) = direction {
      if let Some(targets) = self.targets {
        let prefixes = Feature::FlexDirection.prefixes_for(targets);
        let mut prefixes_2009 = VendorPrefix::empty();
        if is_flex_2009(targets) {
          prefixes_2009 |= VendorPrefix::WebKit;
        }
        if prefixes.contains(VendorPrefix::Moz) {
          prefixes_2009 |= VendorPrefix::Moz;
        }
        if !prefixes_2009.is_empty() {
          let (orient, dir) = direction.to_2009();
          dest.push(Property::BoxOrient(orient, prefixes_2009));
          dest.push(Property::BoxDirection(dir, prefixes_2009));
        }
      }
    }

    if let (Some((direction, dir_prefix)), Some((wrap, wrap_prefix))) = (&mut direction, &mut wrap) {
      let intersection = *dir_prefix & *wrap_prefix;
      if !intersection.is_empty() {
        let mut prefix = intersection;
        if prefix.contains(VendorPrefix::None) {
          if let Some(targets) = self.targets {
            prefix = Feature::FlexFlow.prefixes_for(targets);
            // Firefox only implemented the 2009 spec prefixed.
            prefix.remove(VendorPrefix::Moz);
          }
        }
        dest.push(Property::FlexFlow(
          FlexFlow {
            direction: *direction,
            wrap: *wrap,
          },
          prefix,
        ));
        dir_prefix.remove(intersection);
        wrap_prefix.remove(intersection);
      }
    }

    single_property!(FlexDirection, direction);
    single_property!(FlexWrap, wrap, 2009: BoxLines);

    if let Some(targets) = self.targets {
      if let Some((grow, _)) = grow {
        let prefixes = Feature::FlexGrow.prefixes_for(targets);
        let mut prefixes_2009 = VendorPrefix::empty();
        if is_flex_2009(targets) {
          prefixes_2009 |= VendorPrefix::WebKit;
        }
        if prefixes.contains(VendorPrefix::Moz) {
          prefixes_2009 |= VendorPrefix::Moz;
        }
        if !prefixes_2009.is_empty() {
          dest.push(Property::BoxFlex(grow, prefixes_2009));
        }
      }
    }

    if let (Some((grow, grow_prefix)), Some((shrink, shrink_prefix)), Some((basis, basis_prefix))) =
      (&mut grow, &mut shrink, &mut basis)
    {
      let intersection = *grow_prefix & *shrink_prefix & *basis_prefix;
      if !intersection.is_empty() {
        let mut prefix = intersection;
        if prefix.contains(VendorPrefix::None) {
          if let Some(targets) = self.targets {
            prefix = Feature::Flex.prefixes_for(targets);
            // Firefox only implemented the 2009 spec prefixed.
            prefix.remove(VendorPrefix::Moz);
          }
        }
        dest.push(Property::Flex(
          Flex {
            grow: *grow,
            shrink: *shrink,
            basis: basis.clone(),
          },
          prefix,
        ));
        grow_prefix.remove(intersection);
        shrink_prefix.remove(intersection);
        basis_prefix.remove(intersection);
      }
    }

    single_property!(FlexGrow, grow, 2012: FlexPositive);
    single_property!(FlexShrink, shrink, 2012: FlexNegative);
    single_property!(FlexBasis, basis, 2012: FlexPreferredSize);
    single_property!(Order, order, 2012: FlexOrder, 2009: BoxOrdinalGroup);
  }
}

#[inline]
fn is_flex_property(property_id: &PropertyId) -> bool {
  match property_id {
    PropertyId::FlexDirection(_)
    | PropertyId::BoxOrient(_)
    | PropertyId::BoxDirection(_)
    | PropertyId::FlexWrap(_)
    | PropertyId::BoxLines(_)
    | PropertyId::FlexFlow(_)
    | PropertyId::FlexGrow(_)
    | PropertyId::BoxFlex(_)
    | PropertyId::FlexPositive(_)
    | PropertyId::FlexShrink(_)
    | PropertyId::FlexNegative(_)
    | PropertyId::FlexBasis(_)
    | PropertyId::FlexPreferredSize(_)
    | PropertyId::Flex(_)
    | PropertyId::Order(_)
    | PropertyId::BoxOrdinalGroup(_)
    | PropertyId::FlexOrder(_) => true,
    _ => false,
  }
}