ComputedStyleBase.cpp

// Copyright (c) 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "core/ComputedStyleBase.h"
#include "core/style/ComputedStyle.h"
#include "platform/wtf/SizeAssertions.h"

namespace blink {

struct SameSizeAsComputedStyleBase {
  void* dataRefs[7];
  unsigned m_bit_fields[4];
};

// If this fails, the packing algorithm in make_computed_style_base.py has
// failed to produce the optimal packed size. To fix, update the algorithm to
// ensure that the buckets are placed so that each takes up at most 1 word.
ASSERT_SIZE(ComputedStyleBase, SameSizeAsComputedStyleBase);

// Constructor and destructor are protected so that only the parent class ComputedStyle
// can instantiate this class.
ComputedStyleBase::ComputedStyleBase() :
    pseudo_bits_(static_cast<unsigned>(kPseudoIdNone))
    , cursor_(static_cast<unsigned>(ECursor::kAuto))
    , list_style_type_(static_cast<unsigned>(EListStyleType::kDisc))
    , style_type_(static_cast<unsigned>(PseudoId::kPseudoIdNone))
    , display_(static_cast<unsigned>(EDisplay::kInline))
    , affected_by_active_(static_cast<unsigned>(false))
    , original_display_(static_cast<unsigned>(EDisplay::kInline))
    , break_after_(static_cast<unsigned>(EBreakBetween::kAuto))
    , break_before_(static_cast<unsigned>(EBreakBetween::kAuto))
    , pointer_events_(static_cast<unsigned>(EPointerEvents::kAuto))
    , text_align_(static_cast<unsigned>(ETextAlign::kStart))
    , vertical_align_(static_cast<unsigned>(EVerticalAlign::kBaseline))
    , overflow_x_(static_cast<unsigned>(EOverflow::kVisible))
    , overflow_y_(static_cast<unsigned>(EOverflow::kVisible))
    , affected_by_drag_(static_cast<unsigned>(false))
    , position_(static_cast<unsigned>(EPosition::kStatic))
    , unicode_bidi_(static_cast<unsigned>(UnicodeBidi::kNormal))
    , white_space_(static_cast<unsigned>(EWhiteSpace::kNormal))
    , break_inside_(static_cast<unsigned>(EBreakInside::kAuto))
    , clear_(static_cast<unsigned>(EClear::kNone))
    , floating_(static_cast<unsigned>(EFloat::kNone))
    , inside_link_(static_cast<unsigned>(EInsideLink::kNotInsideLink))
    , overflow_anchor_(static_cast<unsigned>(EOverflowAnchor::kAuto))
    , text_transform_(static_cast<unsigned>(ETextTransform::kNone))
    , transform_box_(static_cast<unsigned>(ETransformBox::kBorderBox))
    , visibility_(static_cast<unsigned>(EVisibility::kVisible))
    , writing_mode_(static_cast<unsigned>(WritingMode::kHorizontalTb))
    , affected_by_focus_within_(static_cast<unsigned>(false))
    , affected_by_hover_(static_cast<unsigned>(false))
    , border_collapse_(static_cast<unsigned>(EBorderCollapse::kSeparate))
    , border_collapse_is_inherited_(static_cast<unsigned>(true))
    , box_direction_(static_cast<unsigned>(EBoxDirection::kNormal))
    , box_direction_is_inherited_(static_cast<unsigned>(true))
    , caption_side_(static_cast<unsigned>(ECaptionSide::kTop))
    , caption_side_is_inherited_(static_cast<unsigned>(true))
    , direction_(static_cast<unsigned>(TextDirection::kLtr))
    , empty_cells_(static_cast<unsigned>(EEmptyCells::kShow))
    , empty_cells_is_inherited_(static_cast<unsigned>(true))
    , empty_state_(static_cast<unsigned>(false))
    , has_explicitly_inherited_properties_(static_cast<unsigned>(false))
    , has_rem_units_(static_cast<unsigned>(false))
    , has_simple_underline_(static_cast<unsigned>(false))
    , has_variable_reference_from_non_inherited_property_(static_cast<unsigned>(false))
    , has_viewport_units_(static_cast<unsigned>(false))
    , is_link_(static_cast<unsigned>(false))
    , list_style_position_(static_cast<unsigned>(EListStylePosition::kOutside))
    , list_style_position_is_inherited_(static_cast<unsigned>(true))
    , pointer_events_is_inherited_(static_cast<unsigned>(true))
    , print_color_adjust_(static_cast<unsigned>(EPrintColorAdjust::kEconomy))
    , print_color_adjust_is_inherited_(static_cast<unsigned>(true))
    , rtl_ordering_(static_cast<unsigned>(EOrder::kLogical))
    , rtl_ordering_is_inherited_(static_cast<unsigned>(true))
    , scroll_snap_stop_(static_cast<unsigned>(EScrollSnapStop::kNormal))
    , table_layout_(static_cast<unsigned>(ETableLayout::kAuto))
    , text_transform_is_inherited_(static_cast<unsigned>(true))
    , unique_(static_cast<unsigned>(false))
    , visibility_is_inherited_(static_cast<unsigned>(true))
    , white_space_is_inherited_(static_cast<unsigned>(true))
{
  box_data_.Init();
  rare_inherited_data_.Init();
  rare_non_inherited_data_.Init();
  surround_data_.Init();
  visual_data_.Init();
  background_data_.Init();
  inherited_data_.Init();
}

void ComputedStyleBase::InheritFrom(const ComputedStyleBase& other,
                                    IsAtShadowBoundary isAtShadowBoundary) {
  rare_inherited_data_ = other.rare_inherited_data_;
  inherited_data_ = other.inherited_data_;
  cursor_ = other.cursor_;
  list_style_type_ = other.list_style_type_;
  pointer_events_ = other.pointer_events_;
  text_align_ = other.text_align_;
  white_space_ = other.white_space_;
  inside_link_ = other.inside_link_;
  text_transform_ = other.text_transform_;
  visibility_ = other.visibility_;
  writing_mode_ = other.writing_mode_;
  border_collapse_ = other.border_collapse_;
  box_direction_ = other.box_direction_;
  caption_side_ = other.caption_side_;
  direction_ = other.direction_;
  empty_cells_ = other.empty_cells_;
  has_simple_underline_ = other.has_simple_underline_;
  list_style_position_ = other.list_style_position_;
  print_color_adjust_ = other.print_color_adjust_;
  rtl_ordering_ = other.rtl_ordering_;
}

void ComputedStyleBase::CopyNonInheritedFromCached(
    const ComputedStyleBase& other) {
  box_data_ = other.box_data_;
  rare_non_inherited_data_ = other.rare_non_inherited_data_;
  surround_data_ = other.surround_data_;
  visual_data_ = other.visual_data_;
  background_data_ = other.background_data_;
  display_ = other.display_;
  original_display_ = other.original_display_;
  break_after_ = other.break_after_;
  break_before_ = other.break_before_;
  vertical_align_ = other.vertical_align_;
  overflow_x_ = other.overflow_x_;
  overflow_y_ = other.overflow_y_;
  position_ = other.position_;
  unicode_bidi_ = other.unicode_bidi_;
  break_inside_ = other.break_inside_;
  clear_ = other.clear_;
  floating_ = other.floating_;
  overflow_anchor_ = other.overflow_anchor_;
  transform_box_ = other.transform_box_;
  border_collapse_is_inherited_ = other.border_collapse_is_inherited_;
  box_direction_is_inherited_ = other.box_direction_is_inherited_;
  caption_side_is_inherited_ = other.caption_side_is_inherited_;
  empty_cells_is_inherited_ = other.empty_cells_is_inherited_;
  has_rem_units_ = other.has_rem_units_;
  has_viewport_units_ = other.has_viewport_units_;
  list_style_position_is_inherited_ = other.list_style_position_is_inherited_;
  pointer_events_is_inherited_ = other.pointer_events_is_inherited_;
  print_color_adjust_is_inherited_ = other.print_color_adjust_is_inherited_;
  rtl_ordering_is_inherited_ = other.rtl_ordering_is_inherited_;
  scroll_snap_stop_ = other.scroll_snap_stop_;
  table_layout_ = other.table_layout_;
  text_transform_is_inherited_ = other.text_transform_is_inherited_;
  visibility_is_inherited_ = other.visibility_is_inherited_;
  white_space_is_inherited_ = other.white_space_is_inherited_;
}

void ComputedStyleBase::PropagateIndependentInheritedProperties(
    const ComputedStyleBase& parentStyle) {
  if (PointerEventsIsInherited())
    pointer_events_ = parentStyle.pointer_events_;
  if (WhiteSpaceIsInherited())
    white_space_ = parentStyle.white_space_;
  if (TextTransformIsInherited())
    text_transform_ = parentStyle.text_transform_;
  if (VisibilityIsInherited())
    visibility_ = parentStyle.visibility_;
  if (BorderCollapseIsInherited())
    border_collapse_ = parentStyle.border_collapse_;
  if (BoxDirectionIsInherited())
    box_direction_ = parentStyle.box_direction_;
  if (CaptionSideIsInherited())
    caption_side_ = parentStyle.caption_side_;
  if (EmptyCellsIsInherited())
    empty_cells_ = parentStyle.empty_cells_;
  if (ListStylePositionIsInherited())
    list_style_position_ = parentStyle.list_style_position_;
  if (PrintColorAdjustIsInherited())
    print_color_adjust_ = parentStyle.print_color_adjust_;
  if (RtlOrderingIsInherited())
    rtl_ordering_ = parentStyle.rtl_ordering_;
}

bool ComputedStyleBase::DiffNeedsVisualRectUpdate(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.Resize() != b.Resize())
        return true;
    }
    if (a.Visibility() != b.Visibility())
      return true;
  return false;
}

bool ComputedStyleBase::DiffTransformData(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->transform_data_.Get() != b.rare_non_inherited_data_->transform_data_.Get()) {
        if (a.rare_non_inherited_data_->transform_data_->transform_ != b.rare_non_inherited_data_->transform_data_->transform_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->translate_ != b.rare_non_inherited_data_->transform_data_->translate_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->rotate_ != b.rare_non_inherited_data_->transform_data_->rotate_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->scale_ != b.rare_non_inherited_data_->transform_data_->scale_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_path_ != b.rare_non_inherited_data_->transform_data_->offset_path_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_rotate_ != b.rare_non_inherited_data_->transform_data_->offset_rotate_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->transform_origin_ != b.rare_non_inherited_data_->transform_data_->transform_origin_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_position_ != b.rare_non_inherited_data_->transform_data_->offset_position_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_anchor_ != b.rare_non_inherited_data_->transform_data_->offset_anchor_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_distance_ != b.rare_non_inherited_data_->transform_data_->offset_distance_)
          return true;
      }
    }
  return false;
}

bool ComputedStyleBase::UpdatePropertySpecificDifferencesOpacity(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->opacity_ != b.rare_non_inherited_data_->opacity_)
        return true;
    }
  return false;
}

bool ComputedStyleBase::UpdatePropertySpecificDifferencesFilter(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->filter_ops_data_.Get() != b.rare_non_inherited_data_->filter_ops_data_.Get()) {
        if (!a.FilterDataEquivalent(b))
          return true;
      }
      if (!a.ReflectionDataEquivalent(b))
        return true;
    }
  return false;
}

bool ComputedStyleBase::UpdatePropertySpecificDifferencesTextDecorationOrColor(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_inherited_data_.Get() != b.rare_inherited_data_.Get()) {
      if (a.rare_inherited_data_->text_emphasis_fill_ != b.rare_inherited_data_->text_emphasis_fill_)
        return true;
      if (a.rare_inherited_data_->text_underline_position_ != b.rare_inherited_data_->text_underline_position_)
        return true;
      if (a.rare_inherited_data_->text_decoration_skip_ != b.rare_inherited_data_->text_decoration_skip_)
        return true;
      if (a.rare_inherited_data_->applied_text_decorations_ != b.rare_inherited_data_->applied_text_decorations_)
        return true;
      if (a.TextFillColor() != b.TextFillColor())
        return true;
      if (a.TextStrokeColor() != b.TextStrokeColor())
        return true;
      if (a.TextEmphasisColor() != b.TextEmphasisColor())
        return true;
      if (a.VisitedLinkTextFillColor() != b.VisitedLinkTextFillColor())
        return true;
      if (a.VisitedLinkTextStrokeColor() != b.VisitedLinkTextStrokeColor())
        return true;
      if (a.VisitedLinkTextEmphasisColor() != b.VisitedLinkTextEmphasisColor())
        return true;
      if (a.CaretColor() != b.CaretColor())
        return true;
      if (a.VisitedLinkCaretColor() != b.VisitedLinkCaretColor())
        return true;
    }
    if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->text_decoration_style_ != b.rare_non_inherited_data_->text_decoration_style_)
        return true;
      if (a.rare_non_inherited_data_->text_decoration_color_ != b.rare_non_inherited_data_->text_decoration_color_)
        return true;
      if (a.rare_non_inherited_data_->visited_link_text_decoration_color_ != b.rare_non_inherited_data_->visited_link_text_decoration_color_)
        return true;
    }
    if (a.visual_data_.Get() != b.visual_data_.Get()) {
      if (a.visual_data_->text_decoration_ != b.visual_data_->text_decoration_)
        return true;
    }
    if (a.inherited_data_.Get() != b.inherited_data_.Get()) {
      if (a.inherited_data_->color_ != b.inherited_data_->color_)
        return true;
      if (a.inherited_data_->visited_link_color_ != b.inherited_data_->visited_link_color_)
        return true;
    }
    if (a.HasSimpleUnderlineInternal() != b.HasSimpleUnderlineInternal())
      return true;
  return false;
}

bool ComputedStyleBase::UpdatePropertySpecificDifferencesTransform(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->transform_data_.Get() != b.rare_non_inherited_data_->transform_data_.Get()) {
        if (a.rare_non_inherited_data_->transform_data_->transform_ != b.rare_non_inherited_data_->transform_data_->transform_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->translate_ != b.rare_non_inherited_data_->transform_data_->translate_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->rotate_ != b.rare_non_inherited_data_->transform_data_->rotate_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->scale_ != b.rare_non_inherited_data_->transform_data_->scale_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_path_ != b.rare_non_inherited_data_->transform_data_->offset_path_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_rotate_ != b.rare_non_inherited_data_->transform_data_->offset_rotate_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->transform_origin_ != b.rare_non_inherited_data_->transform_data_->transform_origin_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_position_ != b.rare_non_inherited_data_->transform_data_->offset_position_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_anchor_ != b.rare_non_inherited_data_->transform_data_->offset_anchor_)
          return true;
        if (a.rare_non_inherited_data_->transform_data_->offset_distance_ != b.rare_non_inherited_data_->transform_data_->offset_distance_)
          return true;
        if (a.HasTransform() != b.HasTransform())
          return true;
      }
      if (a.rare_non_inherited_data_->perspective_ != b.rare_non_inherited_data_->perspective_)
        return true;
      if (a.rare_non_inherited_data_->perspective_origin_ != b.rare_non_inherited_data_->perspective_origin_)
        return true;
      if (a.HasTransform() != b.HasTransform())
        return true;
    }
  return false;
}

bool ComputedStyleBase::DiffNeedsFullLayout(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.box_data_.Get() != b.box_data_.Get()) {
      if (a.box_data_->width_ != b.box_data_->width_)
        return true;
      if (a.box_data_->min_width_ != b.box_data_->min_width_)
        return true;
      if (a.box_data_->max_width_ != b.box_data_->max_width_)
        return true;
      if (a.box_data_->height_ != b.box_data_->height_)
        return true;
      if (a.box_data_->min_height_ != b.box_data_->min_height_)
        return true;
      if (a.box_data_->max_height_ != b.box_data_->max_height_)
        return true;
      if (a.box_data_->vertical_align_length_ != b.box_data_->vertical_align_length_)
        return true;
      if (a.box_data_->box_sizing_ != b.box_data_->box_sizing_)
        return true;
    }
    if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->align_content_ != b.rare_non_inherited_data_->align_content_)
        return true;
      if (a.rare_non_inherited_data_->align_items_ != b.rare_non_inherited_data_->align_items_)
        return true;
      if (a.rare_non_inherited_data_->align_self_ != b.rare_non_inherited_data_->align_self_)
        return true;
      if (a.rare_non_inherited_data_->justify_content_ != b.rare_non_inherited_data_->justify_content_)
        return true;
      if (a.rare_non_inherited_data_->justify_items_ != b.rare_non_inherited_data_->justify_items_)
        return true;
      if (a.rare_non_inherited_data_->justify_self_ != b.rare_non_inherited_data_->justify_self_)
        return true;
      if (a.rare_non_inherited_data_->contain_ != b.rare_non_inherited_data_->contain_)
        return true;
    }
    if (a.VerticalAlign() != b.VerticalAlign())
      return true;
    if (a.GetPosition() != b.GetPosition())
      return true;
  return false;
}

bool ComputedStyleBase::UpdatePropertySpecificDifferencesZIndex(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.box_data_.Get() != b.box_data_.Get()) {
      if (a.box_data_->z_index_ != b.box_data_->z_index_)
        return true;
    }
    if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.IsStackingContext() != b.IsStackingContext())
        return true;
    }
  return false;
}

bool ComputedStyleBase::DiffNeedsFullLayoutAndPaintInvalidationDisplayListItem(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.ListStyleType() != b.ListStyleType())
      return true;
    if (a.ListStylePosition() != b.ListStylePosition())
      return true;
  return false;
}

bool ComputedStyleBase::UpdatePropertySpecificDifferencesNeedsRecomputeOverflow(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (!a.BoxShadowDataEquivalent(b))
        return true;
      if (!a.OutlineVisuallyEqual(b))
        return true;
    }
    if (a.surround_data_.Get() != b.surround_data_.Get()) {
      if (!a.BorderVisualOverflowEqual(b))
        return true;
    }
  return false;
}

bool ComputedStyleBase::DiffNeedsPaintInvalidationSubtree(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->blend_mode_ != b.rare_non_inherited_data_->blend_mode_)
        return true;
      if (a.rare_non_inherited_data_->isolation_ != b.rare_non_inherited_data_->isolation_)
        return true;
      if (a.rare_non_inherited_data_->mask_ != b.rare_non_inherited_data_->mask_)
        return true;
      if (a.rare_non_inherited_data_->mask_box_image_ != b.rare_non_inherited_data_->mask_box_image_)
        return true;
    }
  return false;
}

bool ComputedStyleBase::DiffNeedsPaintInvalidationObject(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_inherited_data_.Get() != b.rare_inherited_data_.Get()) {
      if (a.rare_inherited_data_->user_modify_ != b.rare_inherited_data_->user_modify_)
        return true;
      if (a.rare_inherited_data_->user_select_ != b.rare_inherited_data_->user_select_)
        return true;
      if (a.rare_inherited_data_->image_rendering_ != b.rare_inherited_data_->image_rendering_)
        return true;
    }
    if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->user_drag_ != b.rare_non_inherited_data_->user_drag_)
        return true;
      if (a.rare_non_inherited_data_->object_fit_ != b.rare_non_inherited_data_->object_fit_)
        return true;
      if (a.rare_non_inherited_data_->object_position_ != b.rare_non_inherited_data_->object_position_)
        return true;
      if (a.VisitedLinkBackgroundColor() != b.VisitedLinkBackgroundColor())
        return true;
      if (a.Resize() != b.Resize())
        return true;
      if (!a.BoxShadowDataEquivalent(b))
        return true;
      if (!a.ShapeOutsideDataEquivalent(b))
        return true;
      if (!a.ClipPathDataEquivalent(b))
        return true;
      if (!a.OutlineVisuallyEqual(b))
        return true;
      if (!a.VisitedLinkBorderLeftColorHasNotChanged(b))
        return true;
      if (!a.VisitedLinkBorderRightColorHasNotChanged(b))
        return true;
      if (!a.VisitedLinkBorderBottomColorHasNotChanged(b))
        return true;
      if (!a.VisitedLinkBorderTopColorHasNotChanged(b))
        return true;
      if (!a.VisitedLinkOutlineColorHasNotChanged(b))
        return true;
    }
    if (a.Visibility() != b.Visibility())
      return true;
    if (a.PrintColorAdjust() != b.PrintColorAdjust())
      return true;
    if (a.InsideLink() != b.InsideLink())
      return true;
  return false;
}

bool ComputedStyleBase::ScrollAnchorDisablingPropertyChanged(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.box_data_.Get() != b.box_data_.Get()) {
      if (a.box_data_->width_ != b.box_data_->width_)
        return true;
      if (a.box_data_->min_width_ != b.box_data_->min_width_)
        return true;
      if (a.box_data_->max_width_ != b.box_data_->max_width_)
        return true;
      if (a.box_data_->height_ != b.box_data_->height_)
        return true;
      if (a.box_data_->min_height_ != b.box_data_->min_height_)
        return true;
      if (a.box_data_->max_height_ != b.box_data_->max_height_)
        return true;
    }
    if (a.surround_data_.Get() != b.surround_data_.Get()) {
      if (a.surround_data_->margin_top_ != b.surround_data_->margin_top_)
        return true;
      if (a.surround_data_->margin_left_ != b.surround_data_->margin_left_)
        return true;
      if (a.surround_data_->margin_right_ != b.surround_data_->margin_right_)
        return true;
      if (a.surround_data_->margin_bottom_ != b.surround_data_->margin_bottom_)
        return true;
      if (a.surround_data_->left_ != b.surround_data_->left_)
        return true;
      if (a.surround_data_->right_ != b.surround_data_->right_)
        return true;
      if (a.surround_data_->top_ != b.surround_data_->top_)
        return true;
      if (a.surround_data_->bottom_ != b.surround_data_->bottom_)
        return true;
      if (a.surround_data_->padding_top_ != b.surround_data_->padding_top_)
        return true;
      if (a.surround_data_->padding_left_ != b.surround_data_->padding_left_)
        return true;
      if (a.surround_data_->padding_right_ != b.surround_data_->padding_right_)
        return true;
      if (a.surround_data_->padding_bottom_ != b.surround_data_->padding_bottom_)
        return true;
    }
    if (a.GetPosition() != b.GetPosition())
      return true;
  return false;
}

bool ComputedStyleBase::DiffNeedsFullLayoutAndPaintInvalidation(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_inherited_data_.Get() != b.rare_inherited_data_.Get()) {
      if (a.rare_inherited_data_->highlight_ != b.rare_inherited_data_->highlight_)
        return true;
      if (a.rare_inherited_data_->text_indent_ != b.rare_inherited_data_->text_indent_)
        return true;
      if (a.rare_inherited_data_->text_align_last_ != b.rare_inherited_data_->text_align_last_)
        return true;
      if (a.rare_inherited_data_->text_indent_line_ != b.rare_inherited_data_->text_indent_line_)
        return true;
      if (a.rare_inherited_data_->effective_zoom_ != b.rare_inherited_data_->effective_zoom_)
        return true;
      if (a.rare_inherited_data_->word_break_ != b.rare_inherited_data_->word_break_)
        return true;
      if (a.rare_inherited_data_->overflow_wrap_ != b.rare_inherited_data_->overflow_wrap_)
        return true;
      if (a.rare_inherited_data_->line_break_ != b.rare_inherited_data_->line_break_)
        return true;
      if (a.rare_inherited_data_->text_security_ != b.rare_inherited_data_->text_security_)
        return true;
      if (a.rare_inherited_data_->hyphens_ != b.rare_inherited_data_->hyphens_)
        return true;
      if (a.rare_inherited_data_->hyphenation_limit_before_ != b.rare_inherited_data_->hyphenation_limit_before_)
        return true;
      if (a.rare_inherited_data_->hyphenation_limit_after_ != b.rare_inherited_data_->hyphenation_limit_after_)
        return true;
      if (a.rare_inherited_data_->hyphenation_string_ != b.rare_inherited_data_->hyphenation_string_)
        return true;
      if (a.rare_inherited_data_->respect_image_orientation_ != b.rare_inherited_data_->respect_image_orientation_)
        return true;
      if (a.rare_inherited_data_->ruby_position_ != b.rare_inherited_data_->ruby_position_)
        return true;
      if (a.rare_inherited_data_->text_emphasis_mark_ != b.rare_inherited_data_->text_emphasis_mark_)
        return true;
      if (a.rare_inherited_data_->text_emphasis_position_ != b.rare_inherited_data_->text_emphasis_position_)
        return true;
      if (a.rare_inherited_data_->text_emphasis_custom_mark_ != b.rare_inherited_data_->text_emphasis_custom_mark_)
        return true;
      if (a.rare_inherited_data_->text_justify_ != b.rare_inherited_data_->text_justify_)
        return true;
      if (a.rare_inherited_data_->text_orientation_ != b.rare_inherited_data_->text_orientation_)
        return true;
      if (a.rare_inherited_data_->text_combine_ != b.rare_inherited_data_->text_combine_)
        return true;
      if (a.rare_inherited_data_->tab_size_ != b.rare_inherited_data_->tab_size_)
        return true;
      if (a.rare_inherited_data_->text_size_adjust_ != b.rare_inherited_data_->text_size_adjust_)
        return true;
      if (a.rare_inherited_data_->list_style_image_ != b.rare_inherited_data_->list_style_image_)
        return true;
      if (a.rare_inherited_data_->line_height_step_ != b.rare_inherited_data_->line_height_step_)
        return true;
      if (a.rare_inherited_data_->text_stroke_width_ != b.rare_inherited_data_->text_stroke_width_)
        return true;
      if (!a.TextShadowDataEquivalent(b))
        return true;
      if (!a.QuotesDataEquivalent(b))
        return true;
    }
    if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->flexible_box_data_.Get() != b.rare_non_inherited_data_->flexible_box_data_.Get()) {
        if (a.rare_non_inherited_data_->flexible_box_data_->flex_basis_ != b.rare_non_inherited_data_->flexible_box_data_->flex_basis_)
          return true;
        if (a.rare_non_inherited_data_->flexible_box_data_->flex_shrink_ != b.rare_non_inherited_data_->flexible_box_data_->flex_shrink_)
          return true;
        if (a.rare_non_inherited_data_->flexible_box_data_->flex_grow_ != b.rare_non_inherited_data_->flexible_box_data_->flex_grow_)
          return true;
        if (a.rare_non_inherited_data_->flexible_box_data_->flex_direction_ != b.rare_non_inherited_data_->flexible_box_data_->flex_direction_)
          return true;
        if (a.rare_non_inherited_data_->flexible_box_data_->flex_wrap_ != b.rare_non_inherited_data_->flexible_box_data_->flex_wrap_)
          return true;
      }
      if (a.rare_non_inherited_data_->grid_item_data_.Get() != b.rare_non_inherited_data_->grid_item_data_.Get()) {
        if (a.rare_non_inherited_data_->grid_item_data_->grid_row_start_ != b.rare_non_inherited_data_->grid_item_data_->grid_row_start_)
          return true;
        if (a.rare_non_inherited_data_->grid_item_data_->grid_row_end_ != b.rare_non_inherited_data_->grid_item_data_->grid_row_end_)
          return true;
        if (a.rare_non_inherited_data_->grid_item_data_->grid_column_start_ != b.rare_non_inherited_data_->grid_item_data_->grid_column_start_)
          return true;
        if (a.rare_non_inherited_data_->grid_item_data_->grid_column_end_ != b.rare_non_inherited_data_->grid_item_data_->grid_column_end_)
          return true;
      }
      if (a.rare_non_inherited_data_->multi_col_data_.Get() != b.rare_non_inherited_data_->multi_col_data_.Get()) {
        if (a.rare_non_inherited_data_->multi_col_data_->column_gap_ != b.rare_non_inherited_data_->multi_col_data_->column_gap_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_width_ != b.rare_non_inherited_data_->multi_col_data_->column_width_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_rule_style_ != b.rare_non_inherited_data_->multi_col_data_->column_rule_style_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_rule_width_ != b.rare_non_inherited_data_->multi_col_data_->column_rule_width_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_rule_color_ != b.rare_non_inherited_data_->multi_col_data_->column_rule_color_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_rule_color_is_current_color_ != b.rare_non_inherited_data_->multi_col_data_->column_rule_color_is_current_color_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->visited_link_column_rule_color_ != b.rare_non_inherited_data_->multi_col_data_->visited_link_column_rule_color_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_count_ != b.rare_non_inherited_data_->multi_col_data_->column_count_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_auto_count_ != b.rare_non_inherited_data_->multi_col_data_->column_auto_count_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_auto_width_ != b.rare_non_inherited_data_->multi_col_data_->column_auto_width_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_fill_ != b.rare_non_inherited_data_->multi_col_data_->column_fill_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_normal_gap_ != b.rare_non_inherited_data_->multi_col_data_->column_normal_gap_)
          return true;
        if (a.rare_non_inherited_data_->multi_col_data_->column_span_ != b.rare_non_inherited_data_->multi_col_data_->column_span_)
          return true;
      }
      if (a.rare_non_inherited_data_->grid_data_.Get() != b.rare_non_inherited_data_->grid_data_.Get()) {
        if (a.rare_non_inherited_data_->grid_data_->named_grid_column_lines_ != b.rare_non_inherited_data_->grid_data_->named_grid_column_lines_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->named_grid_row_lines_ != b.rare_non_inherited_data_->grid_data_->named_grid_row_lines_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->ordered_named_grid_column_lines_ != b.rare_non_inherited_data_->grid_data_->ordered_named_grid_column_lines_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->ordered_named_grid_row_lines_ != b.rare_non_inherited_data_->grid_data_->ordered_named_grid_row_lines_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_column_lines_ != b.rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_column_lines_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_row_lines_ != b.rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_row_lines_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_column_lines_ != b.rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_column_lines_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_row_lines_ != b.rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_row_lines_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->named_grid_area_ != b.rare_non_inherited_data_->grid_data_->named_grid_area_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_auto_rows_ != b.rare_non_inherited_data_->grid_data_->grid_auto_rows_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_template_rows_ != b.rare_non_inherited_data_->grid_data_->grid_template_rows_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_template_columns_ != b.rare_non_inherited_data_->grid_data_->grid_template_columns_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_auto_columns_ != b.rare_non_inherited_data_->grid_data_->grid_auto_columns_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_row_gap_ != b.rare_non_inherited_data_->grid_data_->grid_row_gap_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_column_gap_ != b.rare_non_inherited_data_->grid_data_->grid_column_gap_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->named_grid_area_row_count_ != b.rare_non_inherited_data_->grid_data_->named_grid_area_row_count_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->named_grid_area_column_count_ != b.rare_non_inherited_data_->grid_data_->named_grid_area_column_count_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_ != b.rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_ != b.rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_insertion_point_ != b.rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_insertion_point_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_insertion_point_ != b.rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_insertion_point_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_auto_flow_ != b.rare_non_inherited_data_->grid_data_->grid_auto_flow_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_type_ != b.rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_type_)
          return true;
        if (a.rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_type_ != b.rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_type_)
          return true;
      }
      if (a.rare_non_inherited_data_->filter_ops_data_.Get() != b.rare_non_inherited_data_->filter_ops_data_.Get()) {
        if (a.HasFilters() != b.HasFilters())
          return true;
      }
      if (a.rare_non_inherited_data_->deprecated_flexible_box_data_.Get() != b.rare_non_inherited_data_->deprecated_flexible_box_data_.Get()) {
        if (a.rare_non_inherited_data_->deprecated_flexible_box_data_->box_flex_ != b.rare_non_inherited_data_->deprecated_flexible_box_data_->box_flex_)
          return true;
        if (a.rare_non_inherited_data_->deprecated_flexible_box_data_->box_ordinal_group_ != b.rare_non_inherited_data_->deprecated_flexible_box_data_->box_ordinal_group_)
          return true;
        if (a.rare_non_inherited_data_->deprecated_flexible_box_data_->box_flex_group_ != b.rare_non_inherited_data_->deprecated_flexible_box_data_->box_flex_group_)
          return true;
        if (a.rare_non_inherited_data_->deprecated_flexible_box_data_->box_align_ != b.rare_non_inherited_data_->deprecated_flexible_box_data_->box_align_)
          return true;
        if (a.rare_non_inherited_data_->deprecated_flexible_box_data_->box_pack_ != b.rare_non_inherited_data_->deprecated_flexible_box_data_->box_pack_)
          return true;
        if (a.rare_non_inherited_data_->deprecated_flexible_box_data_->box_lines_ != b.rare_non_inherited_data_->deprecated_flexible_box_data_->box_lines_)
          return true;
        if (a.rare_non_inherited_data_->deprecated_flexible_box_data_->box_orient_ != b.rare_non_inherited_data_->deprecated_flexible_box_data_->box_orient_)
          return true;
      }
      if (a.rare_non_inherited_data_->appearance_ != b.rare_non_inherited_data_->appearance_)
        return true;
      if (a.rare_non_inherited_data_->margin_before_collapse_ != b.rare_non_inherited_data_->margin_before_collapse_)
        return true;
      if (a.rare_non_inherited_data_->margin_after_collapse_ != b.rare_non_inherited_data_->margin_after_collapse_)
        return true;
      if (a.rare_non_inherited_data_->line_clamp_ != b.rare_non_inherited_data_->line_clamp_)
        return true;
      if (a.rare_non_inherited_data_->text_overflow_ != b.rare_non_inherited_data_->text_overflow_)
        return true;
      if (a.rare_non_inherited_data_->shape_margin_ != b.rare_non_inherited_data_->shape_margin_)
        return true;
      if (a.rare_non_inherited_data_->order_ != b.rare_non_inherited_data_->order_)
        return true;
      if (!a.OpacityChangedStackingContext(b))
        return true;
      if (!a.CounterDirectivesEqual(b))
        return true;
    }
    if (a.surround_data_.Get() != b.surround_data_.Get()) {
      if (a.surround_data_->padding_top_ != b.surround_data_->padding_top_)
        return true;
      if (a.surround_data_->padding_left_ != b.surround_data_->padding_left_)
        return true;
      if (a.surround_data_->padding_right_ != b.surround_data_->padding_right_)
        return true;
      if (a.surround_data_->padding_bottom_ != b.surround_data_->padding_bottom_)
        return true;
      if (a.BorderLeftWidth() != b.BorderLeftWidth())
        return true;
      if (a.BorderTopWidth() != b.BorderTopWidth())
        return true;
      if (a.BorderBottomWidth() != b.BorderBottomWidth())
        return true;
      if (a.BorderRightWidth() != b.BorderRightWidth())
        return true;
    }
    if (a.inherited_data_.Get() != b.inherited_data_.Get()) {
      if (a.inherited_data_->line_height_ != b.inherited_data_->line_height_)
        return true;
      if (a.inherited_data_->font_ != b.inherited_data_->font_)
        return true;
      if (a.inherited_data_->horizontal_border_spacing_ != b.inherited_data_->horizontal_border_spacing_)
        return true;
      if (a.inherited_data_->vertical_border_spacing_ != b.inherited_data_->vertical_border_spacing_)
        return true;
      if (a.inherited_data_->text_autosizing_multiplier_ != b.inherited_data_->text_autosizing_multiplier_)
        return true;
      if (a.FontInternal().LoadingCustomFonts() != b.FontInternal().LoadingCustomFonts())
        return true;
    }
    if (a.HasPseudoStyle(kPseudoIdScrollbar) != b.HasPseudoStyle(kPseudoIdScrollbar))
      return true;
    if (a.BoxDirection() != b.BoxDirection())
      return true;
    if (a.RtlOrdering() != b.RtlOrdering())
      return true;
    if (a.GetTextAlign() != b.GetTextAlign())
      return true;
    if (a.TextTransform() != b.TextTransform())
      return true;
    if (a.Direction() != b.Direction())
      return true;
    if (a.WhiteSpace() != b.WhiteSpace())
      return true;
    if (a.GetWritingMode() != b.GetWritingMode())
      return true;
    if (a.OverflowX() != b.OverflowX())
      return true;
    if (a.OverflowY() != b.OverflowY())
      return true;
    if (a.Clear() != b.Clear())
      return true;
    if (a.GetUnicodeBidi() != b.GetUnicodeBidi())
      return true;
    if (a.Floating() != b.Floating())
      return true;
    if (a.OriginalDisplay() != b.OriginalDisplay())
      return true;
  return false;
}

bool ComputedStyleBase::DiffNeedsFullLayoutAndPaintInvalidationDisplayTableType(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.BorderCollapse() != b.BorderCollapse())
      return true;
    if (a.EmptyCells() != b.EmptyCells())
      return true;
    if (a.CaptionSide() != b.CaptionSide())
      return true;
    if (a.TableLayout() != b.TableLayout())
      return true;
  return false;
}

bool ComputedStyleBase::UpdatePropertySpecificDifferencesBackdropFilter(const ComputedStyle& a, const ComputedStyle& b) {
  if (a.rare_non_inherited_data_.Get() != b.rare_non_inherited_data_.Get()) {
      if (a.rare_non_inherited_data_->backdrop_filter_ops_data_.Get() != b.rare_non_inherited_data_->backdrop_filter_ops_data_.Get()) {
        if (!a.BackdropFilterDataEquivalent(b))
          return true;
      }
    }
  return false;
}


ComputedStyleBase::StyleBoxData::StyleBoxData() :
      height_(Length())
      , max_width_(Length(kMaxSizeNone))
      , width_(Length())
      , min_height_(Length())
      , max_height_(Length(kMaxSizeNone))
      , min_width_(Length())
      , vertical_align_length_(Length())
      , z_index_(0)
      , box_decoration_break_(static_cast<unsigned>(EBoxDecorationBreak::kSlice))
      , box_sizing_(static_cast<unsigned>(EBoxSizing::kContentBox))
      , has_auto_z_index_(static_cast<unsigned>(true))
  {
  }

ComputedStyleBase::StyleBoxData::StyleBoxData(const StyleBoxData& other) :
      height_(other.height_)
      , max_width_(other.max_width_)
      , width_(other.width_)
      , min_height_(other.min_height_)
      , max_height_(other.max_height_)
      , min_width_(other.min_width_)
      , vertical_align_length_(other.vertical_align_length_)
      , z_index_(other.z_index_)
      , box_decoration_break_(other.box_decoration_break_)
      , box_sizing_(other.box_sizing_)
      , has_auto_z_index_(other.has_auto_z_index_)
  {}

ComputedStyleBase::StyleRareInheritedData::StyleRareInheritedData() :
      hyphenation_string_(AtomicString())
      , highlight_(g_null_atom)
      , text_emphasis_custom_mark_(AtomicString())
      , quotes_(nullptr)
      , text_shadow_(nullptr)
      , applied_text_decorations_(nullptr)
      , inherited_variables_(nullptr)
      , list_style_image_(nullptr)
      , cursor_data_(nullptr)
      , text_indent_(Length(kFixed))
      , text_size_adjust_(TextSizeAdjust::AdjustAuto())
      , tab_size_(TabSize(8))
      , text_stroke_width_(0)
      , effective_zoom_(1.0f)
      , text_fill_color_(Color())
      , tap_highlight_color_(LayoutTheme::TapHighlightColor())
      , text_stroke_color_(Color())
      , caret_color_(Color())
      , text_emphasis_color_(Color())
      , visited_link_text_stroke_color_(Color())
      , visited_link_text_fill_color_(Color())
      , visited_link_text_emphasis_color_(Color())
      , visited_link_caret_color_(Color())
      , widows_(2)
      , orphans_(2)
      , hyphenation_limit_before_(-1)
      , hyphenation_limit_after_(-1)
      , hyphenation_limit_lines_(-1)
      , line_height_step_(0)
      , image_rendering_(static_cast<unsigned>(EImageRendering::kAuto))
      , line_break_(static_cast<unsigned>(LineBreak::kAuto))
      , speak_(static_cast<unsigned>(ESpeak::kNormal))
      , text_align_last_(static_cast<unsigned>(ETextAlignLast::kAuto))
      , text_decoration_skip_(static_cast<unsigned>(TextDecorationSkip::kObjects))
      , text_emphasis_mark_(static_cast<unsigned>(TextEmphasisMark::kNone))
      , hyphens_(static_cast<unsigned>(Hyphens::kManual))
      , text_justify_(static_cast<unsigned>(TextJustify::kAuto))
      , text_orientation_(static_cast<unsigned>(ETextOrientation::kMixed))
      , text_security_(static_cast<unsigned>(ETextSecurity::kNone))
      , user_modify_(static_cast<unsigned>(EUserModify::kReadOnly))
      , user_select_(static_cast<unsigned>(EUserSelect::kText))
      , word_break_(static_cast<unsigned>(EWordBreak::kNormal))
      , caret_color_is_auto_(static_cast<unsigned>(true))
      , caret_color_is_current_color_(static_cast<unsigned>(false))
      , overflow_wrap_(static_cast<unsigned>(EOverflowWrap::kNormal))
      , respect_image_orientation_(static_cast<unsigned>(false))
      , ruby_position_(static_cast<unsigned>(RubyPosition::kBefore))
      , self_or_ancestor_has_dir_auto_attribute_(static_cast<unsigned>(false))
      , subtree_is_sticky_(static_cast<unsigned>(false))
      , subtree_will_change_contents_(static_cast<unsigned>(false))
      , text_combine_(static_cast<unsigned>(ETextCombine::kNone))
      , text_emphasis_color_is_current_color_(static_cast<unsigned>(true))
      , text_emphasis_fill_(static_cast<unsigned>(TextEmphasisFill::kFilled))
      , text_emphasis_position_(static_cast<unsigned>(TextEmphasisPosition::kOver))
      , text_fill_color_is_current_color_(static_cast<unsigned>(true))
      , text_indent_line_(static_cast<unsigned>(TextIndentLine::kFirstLine))
      , text_indent_type_(static_cast<unsigned>(TextIndentType::kNormal))
      , text_stroke_color_is_current_color_(static_cast<unsigned>(true))
      , text_underline_position_(static_cast<unsigned>(TextUnderlinePosition::kAuto))
      , visited_link_caret_color_is_auto_(static_cast<unsigned>(true))
      , visited_link_caret_color_is_current_color_(static_cast<unsigned>(false))
      , visited_link_text_emphasis_color_is_current_color_(static_cast<unsigned>(true))
      , visited_link_text_fill_color_is_current_color_(static_cast<unsigned>(true))
      , visited_link_text_stroke_color_is_current_color_(static_cast<unsigned>(true))
  {
  }

ComputedStyleBase::StyleRareInheritedData::StyleRareInheritedData(const StyleRareInheritedData& other) :
      hyphenation_string_(other.hyphenation_string_)
      , highlight_(other.highlight_)
      , text_emphasis_custom_mark_(other.text_emphasis_custom_mark_)
      , quotes_(MemberCopy(other.quotes_))
      , text_shadow_(MemberCopy(other.text_shadow_))
      , applied_text_decorations_(MemberCopy(other.applied_text_decorations_))
      , inherited_variables_(MemberCopy(other.inherited_variables_))
      , list_style_image_(MemberCopy(other.list_style_image_))
      , cursor_data_(MemberCopy(other.cursor_data_))
      , text_indent_(other.text_indent_)
      , text_size_adjust_(other.text_size_adjust_)
      , tab_size_(other.tab_size_)
      , text_stroke_width_(other.text_stroke_width_)
      , effective_zoom_(other.effective_zoom_)
      , text_fill_color_(other.text_fill_color_)
      , tap_highlight_color_(other.tap_highlight_color_)
      , text_stroke_color_(other.text_stroke_color_)
      , caret_color_(other.caret_color_)
      , text_emphasis_color_(other.text_emphasis_color_)
      , visited_link_text_stroke_color_(other.visited_link_text_stroke_color_)
      , visited_link_text_fill_color_(other.visited_link_text_fill_color_)
      , visited_link_text_emphasis_color_(other.visited_link_text_emphasis_color_)
      , visited_link_caret_color_(other.visited_link_caret_color_)
      , widows_(other.widows_)
      , orphans_(other.orphans_)
      , hyphenation_limit_before_(other.hyphenation_limit_before_)
      , hyphenation_limit_after_(other.hyphenation_limit_after_)
      , hyphenation_limit_lines_(other.hyphenation_limit_lines_)
      , line_height_step_(other.line_height_step_)
      , image_rendering_(other.image_rendering_)
      , line_break_(other.line_break_)
      , speak_(other.speak_)
      , text_align_last_(other.text_align_last_)
      , text_decoration_skip_(other.text_decoration_skip_)
      , text_emphasis_mark_(other.text_emphasis_mark_)
      , hyphens_(other.hyphens_)
      , text_justify_(other.text_justify_)
      , text_orientation_(other.text_orientation_)
      , text_security_(other.text_security_)
      , user_modify_(other.user_modify_)
      , user_select_(other.user_select_)
      , word_break_(other.word_break_)
      , caret_color_is_auto_(other.caret_color_is_auto_)
      , caret_color_is_current_color_(other.caret_color_is_current_color_)
      , overflow_wrap_(other.overflow_wrap_)
      , respect_image_orientation_(other.respect_image_orientation_)
      , ruby_position_(other.ruby_position_)
      , self_or_ancestor_has_dir_auto_attribute_(other.self_or_ancestor_has_dir_auto_attribute_)
      , subtree_is_sticky_(other.subtree_is_sticky_)
      , subtree_will_change_contents_(other.subtree_will_change_contents_)
      , text_combine_(other.text_combine_)
      , text_emphasis_color_is_current_color_(other.text_emphasis_color_is_current_color_)
      , text_emphasis_fill_(other.text_emphasis_fill_)
      , text_emphasis_position_(other.text_emphasis_position_)
      , text_fill_color_is_current_color_(other.text_fill_color_is_current_color_)
      , text_indent_line_(other.text_indent_line_)
      , text_indent_type_(other.text_indent_type_)
      , text_stroke_color_is_current_color_(other.text_stroke_color_is_current_color_)
      , text_underline_position_(other.text_underline_position_)
      , visited_link_caret_color_is_auto_(other.visited_link_caret_color_is_auto_)
      , visited_link_caret_color_is_current_color_(other.visited_link_caret_color_is_current_color_)
      , visited_link_text_emphasis_color_is_current_color_(other.visited_link_text_emphasis_color_is_current_color_)
      , visited_link_text_fill_color_is_current_color_(other.visited_link_text_fill_color_is_current_color_)
      , visited_link_text_stroke_color_is_current_color_(other.visited_link_text_stroke_color_is_current_color_)
  {}

ComputedStyleBase::StyleFlexibleBoxData::StyleFlexibleBoxData() :
      flex_basis_(Length(kAuto))
      , flex_shrink_(1.0f)
      , flex_grow_(0.0f)
      , flex_direction_(static_cast<unsigned>(EFlexDirection::kRow))
      , flex_wrap_(static_cast<unsigned>(EFlexWrap::kNowrap))
  {
  }

ComputedStyleBase::StyleFlexibleBoxData::StyleFlexibleBoxData(const StyleFlexibleBoxData& other) :
      flex_basis_(other.flex_basis_)
      , flex_shrink_(other.flex_shrink_)
      , flex_grow_(other.flex_grow_)
      , flex_direction_(other.flex_direction_)
      , flex_wrap_(other.flex_wrap_)
  {}

ComputedStyleBase::StyleWillChangeData::StyleWillChangeData() :
      will_change_properties_(Vector<CSSPropertyID>())
      , will_change_contents_(static_cast<unsigned>(false))
      , will_change_scroll_position_(static_cast<unsigned>(false))
  {
  }

ComputedStyleBase::StyleWillChangeData::StyleWillChangeData(const StyleWillChangeData& other) :
      will_change_properties_(other.will_change_properties_)
      , will_change_contents_(other.will_change_contents_)
      , will_change_scroll_position_(other.will_change_scroll_position_)
  {}

ComputedStyleBase::StyleBackdropFilterOpsData::StyleBackdropFilterOpsData() :
      backdrop_filter_(StyleFilterData::Create())
  {
  }

ComputedStyleBase::StyleBackdropFilterOpsData::StyleBackdropFilterOpsData(const StyleBackdropFilterOpsData& other) :
      backdrop_filter_(MemberCopy(other.backdrop_filter_))
  {}

ComputedStyleBase::StyleGridItemData::StyleGridItemData() :
      grid_row_start_(GridPosition())
      , grid_row_end_(GridPosition())
      , grid_column_start_(GridPosition())
      , grid_column_end_(GridPosition())
  {
  }

ComputedStyleBase::StyleGridItemData::StyleGridItemData(const StyleGridItemData& other) :
      grid_row_start_(other.grid_row_start_)
      , grid_row_end_(other.grid_row_end_)
      , grid_column_start_(other.grid_column_start_)
      , grid_column_end_(other.grid_column_end_)
  {}

ComputedStyleBase::StyleScrollSnapData::StyleScrollSnapData() :
      scroll_snap_margin_right_(Length())
      , scroll_snap_margin_left_(Length())
      , scroll_padding_bottom_(Length())
      , scroll_padding_top_(Length())
      , scroll_snap_margin_top_(Length())
      , scroll_snap_margin_bottom_(Length())
      , scroll_padding_left_(Length())
      , scroll_padding_right_(Length())
      , scroll_snap_type_(ScrollSnapType())
      , scroll_snap_align_(ScrollSnapAlign())
  {
  }

ComputedStyleBase::StyleScrollSnapData::StyleScrollSnapData(const StyleScrollSnapData& other) :
      scroll_snap_margin_right_(other.scroll_snap_margin_right_)
      , scroll_snap_margin_left_(other.scroll_snap_margin_left_)
      , scroll_padding_bottom_(other.scroll_padding_bottom_)
      , scroll_padding_top_(other.scroll_padding_top_)
      , scroll_snap_margin_top_(other.scroll_snap_margin_top_)
      , scroll_snap_margin_bottom_(other.scroll_snap_margin_bottom_)
      , scroll_padding_left_(other.scroll_padding_left_)
      , scroll_padding_right_(other.scroll_padding_right_)
      , scroll_snap_type_(other.scroll_snap_type_)
      , scroll_snap_align_(other.scroll_snap_align_)
  {}

ComputedStyleBase::StyleTransformData::StyleTransformData() :
      transform_(EmptyTransformOperations())
      , scale_(nullptr)
      , offset_path_(nullptr)
      , rotate_(nullptr)
      , translate_(nullptr)
      , offset_rotate_(StyleOffsetRotation(0, kOffsetRotationAuto))
      , transform_origin_(TransformOrigin(Length(50.0, kPercent), Length(50.0, kPercent), 0))
      , offset_position_(LengthPoint(Length(kAuto), Length(kAuto)))
      , offset_anchor_(LengthPoint(Length(kAuto), Length(kAuto)))
      , offset_distance_(Length(0, kFixed))
  {
  }

ComputedStyleBase::StyleTransformData::StyleTransformData(const StyleTransformData& other) :
      transform_(other.transform_)
      , scale_(MemberCopy(other.scale_))
      , offset_path_(MemberCopy(other.offset_path_))
      , rotate_(MemberCopy(other.rotate_))
      , translate_(MemberCopy(other.translate_))
      , offset_rotate_(other.offset_rotate_)
      , transform_origin_(other.transform_origin_)
      , offset_position_(other.offset_position_)
      , offset_anchor_(other.offset_anchor_)
      , offset_distance_(other.offset_distance_)
  {}

ComputedStyleBase::StyleMultiColData::StyleMultiColData() :
      column_gap_(0.0f)
      , column_width_(0.0f)
      , visited_link_column_rule_color_(StyleColor::CurrentColor())
      , column_rule_color_(0)
      , column_rule_width_(LayoutUnit(3))
      , column_count_(1)
      , column_rule_style_(static_cast<unsigned>(EBorderStyle::kNone))
      , column_auto_count_(static_cast<unsigned>(true))
      , column_auto_width_(static_cast<unsigned>(true))
      , column_fill_(static_cast<unsigned>(EColumnFill::kBalance))
      , column_normal_gap_(static_cast<unsigned>(true))
      , column_rule_color_is_current_color_(static_cast<unsigned>(true))
      , column_span_(static_cast<unsigned>(EColumnSpan::kNone))
  {
  }

ComputedStyleBase::StyleMultiColData::StyleMultiColData(const StyleMultiColData& other) :
      column_gap_(other.column_gap_)
      , column_width_(other.column_width_)
      , visited_link_column_rule_color_(other.visited_link_column_rule_color_)
      , column_rule_color_(other.column_rule_color_)
      , column_rule_width_(other.column_rule_width_)
      , column_count_(other.column_count_)
      , column_rule_style_(other.column_rule_style_)
      , column_auto_count_(other.column_auto_count_)
      , column_auto_width_(other.column_auto_width_)
      , column_fill_(other.column_fill_)
      , column_normal_gap_(other.column_normal_gap_)
      , column_rule_color_is_current_color_(other.column_rule_color_is_current_color_)
      , column_span_(other.column_span_)
  {}

ComputedStyleBase::StyleGridData::StyleGridData() :
      named_grid_column_lines_(NamedGridLinesMap())
      , named_grid_row_lines_(NamedGridLinesMap())
      , auto_repeat_named_grid_column_lines_(NamedGridLinesMap())
      , auto_repeat_named_grid_row_lines_(NamedGridLinesMap())
      , ordered_named_grid_column_lines_(OrderedNamedGridLines())
      , ordered_named_grid_row_lines_(OrderedNamedGridLines())
      , auto_repeat_ordered_named_grid_column_lines_(OrderedNamedGridLines())
      , auto_repeat_ordered_named_grid_row_lines_(OrderedNamedGridLines())
      , named_grid_area_(NamedGridAreaMap())
      , grid_auto_rows_(Vector<GridTrackSize>(1, GridTrackSize(Length(kAuto))))
      , grid_template_rows_(Vector<GridTrackSize>())
      , grid_template_columns_(Vector<GridTrackSize>())
      , grid_auto_columns_(Vector<GridTrackSize>(1, GridTrackSize(Length(kAuto))))
      , grid_auto_repeat_columns_(Vector<GridTrackSize>())
      , grid_auto_repeat_rows_(Vector<GridTrackSize>())
      , grid_row_gap_(Length(kFixed))
      , grid_column_gap_(Length(kFixed))
      , named_grid_area_row_count_(0)
      , named_grid_area_column_count_(0)
      , grid_auto_repeat_columns_insertion_point_(0)
      , grid_auto_repeat_rows_insertion_point_(0)
      , grid_auto_flow_(static_cast<unsigned>(kAutoFlowRow))
      , grid_auto_repeat_columns_type_(static_cast<unsigned>(AutoRepeatType::kNoAutoRepeat))
      , grid_auto_repeat_rows_type_(static_cast<unsigned>(AutoRepeatType::kNoAutoRepeat))
  {
  }

ComputedStyleBase::StyleGridData::StyleGridData(const StyleGridData& other) :
      named_grid_column_lines_(other.named_grid_column_lines_)
      , named_grid_row_lines_(other.named_grid_row_lines_)
      , auto_repeat_named_grid_column_lines_(other.auto_repeat_named_grid_column_lines_)
      , auto_repeat_named_grid_row_lines_(other.auto_repeat_named_grid_row_lines_)
      , ordered_named_grid_column_lines_(other.ordered_named_grid_column_lines_)
      , ordered_named_grid_row_lines_(other.ordered_named_grid_row_lines_)
      , auto_repeat_ordered_named_grid_column_lines_(other.auto_repeat_ordered_named_grid_column_lines_)
      , auto_repeat_ordered_named_grid_row_lines_(other.auto_repeat_ordered_named_grid_row_lines_)
      , named_grid_area_(other.named_grid_area_)
      , grid_auto_rows_(other.grid_auto_rows_)
      , grid_template_rows_(other.grid_template_rows_)
      , grid_template_columns_(other.grid_template_columns_)
      , grid_auto_columns_(other.grid_auto_columns_)
      , grid_auto_repeat_columns_(other.grid_auto_repeat_columns_)
      , grid_auto_repeat_rows_(other.grid_auto_repeat_rows_)
      , grid_row_gap_(other.grid_row_gap_)
      , grid_column_gap_(other.grid_column_gap_)
      , named_grid_area_row_count_(other.named_grid_area_row_count_)
      , named_grid_area_column_count_(other.named_grid_area_column_count_)
      , grid_auto_repeat_columns_insertion_point_(other.grid_auto_repeat_columns_insertion_point_)
      , grid_auto_repeat_rows_insertion_point_(other.grid_auto_repeat_rows_insertion_point_)
      , grid_auto_flow_(other.grid_auto_flow_)
      , grid_auto_repeat_columns_type_(other.grid_auto_repeat_columns_type_)
      , grid_auto_repeat_rows_type_(other.grid_auto_repeat_rows_type_)
  {}

ComputedStyleBase::StyleFilterOpsData::StyleFilterOpsData() :
      filter_(StyleFilterData::Create())
  {
  }

ComputedStyleBase::StyleFilterOpsData::StyleFilterOpsData(const StyleFilterOpsData& other) :
      filter_(MemberCopy(other.filter_))
  {}

ComputedStyleBase::StyleDeprecatedFlexibleBoxData::StyleDeprecatedFlexibleBoxData() :
      box_flex_(0.0f)
      , box_ordinal_group_(1)
      , box_flex_group_(1)
      , box_align_(static_cast<unsigned>(EBoxAlignment::kStretch))
      , box_pack_(static_cast<unsigned>(EBoxPack::kStart))
      , box_lines_(static_cast<unsigned>(EBoxLines::kSingle))
      , box_orient_(static_cast<unsigned>(EBoxOrient::kHorizontal))
  {
  }

ComputedStyleBase::StyleDeprecatedFlexibleBoxData::StyleDeprecatedFlexibleBoxData(const StyleDeprecatedFlexibleBoxData& other) :
      box_flex_(other.box_flex_)
      , box_ordinal_group_(other.box_ordinal_group_)
      , box_flex_group_(other.box_flex_group_)
      , box_align_(other.box_align_)
      , box_pack_(other.box_pack_)
      , box_lines_(other.box_lines_)
      , box_orient_(other.box_orient_)
  {}

ComputedStyleBase::StyleRareNonInheritedData::StyleRareNonInheritedData() :
      clip_path_(nullptr)
      , box_reflect_(nullptr)
      , box_shadow_(nullptr)
      , shape_outside_(nullptr)
      , content_(nullptr)
      , counter_directives_(nullptr)
      , animations_(nullptr)
      , transitions_(nullptr)
      , paint_images_(nullptr)
      , non_inherited_variables_(nullptr)
      , callback_selectors_(Vector<String>())
      , mask_(FillLayer(kMaskFillLayer, true))
      , mask_box_image_(NinePieceImage::MaskDefaults())
      , page_size_(FloatSize())
      , perspective_origin_(LengthPoint(Length(50.0, kPercent), Length(50.0, kPercent)))
      , object_position_(LengthPoint(Length(50.0, kPercent), Length(50.0, kPercent)))
      , shape_margin_(Length(0, kFixed))
      , shape_image_threshold_(0.0)
      , opacity_(1.0)
      , perspective_(0.0)
      , text_decoration_color_(StyleColor::CurrentColor())
      , visited_link_text_decoration_color_(StyleColor::CurrentColor())
      , visited_link_background_color_(StyleColor(Color::kTransparent))
      , visited_link_outline_color_(StyleColor::CurrentColor())
      , visited_link_border_left_color_(StyleColor::CurrentColor())
      , visited_link_border_right_color_(StyleColor::CurrentColor())
      , visited_link_border_top_color_(StyleColor::CurrentColor())
      , visited_link_border_bottom_color_(StyleColor::CurrentColor())
      , outline_color_(0)
      , outline_width_(LayoutUnit(3))
      , line_clamp_(LineClampValue())
      , order_(0)
      , outline_offset_(0)
      , align_self_(StyleSelfAlignmentData(kItemPositionAuto, kOverflowAlignmentDefault))
      , justify_self_(StyleSelfAlignmentData(kItemPositionAuto, kOverflowAlignmentDefault))
      , justify_items_(StyleSelfAlignmentData(kItemPositionAuto, kOverflowAlignmentDefault))
      , align_items_(StyleSelfAlignmentData(RuntimeEnabledFeatures::CSSGridLayoutEnabled() ? kItemPositionNormal : kItemPositionStretch, kOverflowAlignmentDefault))
      , align_content_(StyleContentAlignmentData(kContentPositionNormal, kContentDistributionDefault, kOverflowAlignmentDefault))
      , justify_content_(StyleContentAlignmentData(kContentPositionNormal, kContentDistributionDefault, kOverflowAlignmentDefault))
      , appearance_(static_cast<unsigned>(kNoControlPart))
      , touch_action_(static_cast<unsigned>(TouchAction::kTouchActionAuto))
      , blend_mode_(static_cast<unsigned>(WebBlendMode::kNormal))
      , contain_(static_cast<unsigned>(kContainsNone))
      , outline_style_(static_cast<unsigned>(EBorderStyle::kNone))
      , object_fit_(static_cast<unsigned>(EObjectFit::kFill))
      , text_decoration_style_(static_cast<unsigned>(ETextDecorationStyle::kSolid))
      , draggable_region_mode_(static_cast<unsigned>(EDraggableRegionMode::kNone))
      , margin_after_collapse_(static_cast<unsigned>(EMarginCollapse::kCollapse))
      , margin_before_collapse_(static_cast<unsigned>(EMarginCollapse::kCollapse))
      , page_size_type_(static_cast<unsigned>(EPageSizeType::kAuto))
      , resize_(static_cast<unsigned>(EResize::kNone))
      , scroll_behavior_(static_cast<unsigned>(kScrollBehaviorAuto))
      , user_drag_(static_cast<unsigned>(EUserDrag::kAuto))
      , backface_visibility_(static_cast<unsigned>(EBackfaceVisibility::kVisible))
      , has_author_background_(static_cast<unsigned>(false))
      , has_author_border_(static_cast<unsigned>(false))
      , has_current_backdrop_filter_animation_(static_cast<unsigned>(false))
      , has_current_filter_animation_(static_cast<unsigned>(false))
      , has_current_opacity_animation_(static_cast<unsigned>(false))
      , has_current_transform_animation_(static_cast<unsigned>(false))
      , has_inline_transform_(static_cast<unsigned>(false))
      , is_running_backdrop_filter_animation_on_compositor_(static_cast<unsigned>(false))
      , is_running_filter_animation_on_compositor_(static_cast<unsigned>(false))
      , is_running_opacity_animation_on_compositor_(static_cast<unsigned>(false))
      , is_running_transform_animation_on_compositor_(static_cast<unsigned>(false))
      , is_stacking_context_(static_cast<unsigned>(false))
      , isolation_(static_cast<unsigned>(EIsolation::kAuto))
      , outline_color_is_current_color_(static_cast<unsigned>(true))
      , outline_style_is_auto_(static_cast<unsigned>(false))
      , requires_accelerated_compositing_for_external_reasons_(static_cast<unsigned>(false))
      , text_overflow_(static_cast<unsigned>(ETextOverflow::kClip))
      , transform_style_3d_(static_cast<unsigned>(ETransformStyle3D::kFlat))
  {
    flexible_box_data_.Init();
    will_change_data_.Init();
    backdrop_filter_ops_data_.Init();
    grid_item_data_.Init();
    scroll_snap_data_.Init();
    transform_data_.Init();
    multi_col_data_.Init();
    grid_data_.Init();
    filter_ops_data_.Init();
    deprecated_flexible_box_data_.Init();
  }

ComputedStyleBase::StyleRareNonInheritedData::StyleRareNonInheritedData(const StyleRareNonInheritedData& other) :
      flexible_box_data_(other.flexible_box_data_)
      , will_change_data_(other.will_change_data_)
      , backdrop_filter_ops_data_(other.backdrop_filter_ops_data_)
      , grid_item_data_(other.grid_item_data_)
      , scroll_snap_data_(other.scroll_snap_data_)
      , transform_data_(other.transform_data_)
      , multi_col_data_(other.multi_col_data_)
      , grid_data_(other.grid_data_)
      , filter_ops_data_(other.filter_ops_data_)
      , deprecated_flexible_box_data_(other.deprecated_flexible_box_data_)
      , clip_path_(MemberCopy(other.clip_path_))
      , box_reflect_(MemberCopy(other.box_reflect_))
      , box_shadow_(MemberCopy(other.box_shadow_))
      , shape_outside_(MemberCopy(other.shape_outside_))
      , content_(MemberCopy(other.content_))
      , counter_directives_(MemberCopy(other.counter_directives_))
      , animations_(MemberCopy(other.animations_))
      , transitions_(MemberCopy(other.transitions_))
      , paint_images_(MemberCopy(other.paint_images_))
      , non_inherited_variables_(MemberCopy(other.non_inherited_variables_))
      , callback_selectors_(other.callback_selectors_)
      , mask_(other.mask_)
      , mask_box_image_(other.mask_box_image_)
      , page_size_(other.page_size_)
      , perspective_origin_(other.perspective_origin_)
      , object_position_(other.object_position_)
      , shape_margin_(other.shape_margin_)
      , shape_image_threshold_(other.shape_image_threshold_)
      , opacity_(other.opacity_)
      , perspective_(other.perspective_)
      , text_decoration_color_(other.text_decoration_color_)
      , visited_link_text_decoration_color_(other.visited_link_text_decoration_color_)
      , visited_link_background_color_(other.visited_link_background_color_)
      , visited_link_outline_color_(other.visited_link_outline_color_)
      , visited_link_border_left_color_(other.visited_link_border_left_color_)
      , visited_link_border_right_color_(other.visited_link_border_right_color_)
      , visited_link_border_top_color_(other.visited_link_border_top_color_)
      , visited_link_border_bottom_color_(other.visited_link_border_bottom_color_)
      , outline_color_(other.outline_color_)
      , outline_width_(other.outline_width_)
      , line_clamp_(other.line_clamp_)
      , order_(other.order_)
      , outline_offset_(other.outline_offset_)
      , align_self_(other.align_self_)
      , justify_self_(other.justify_self_)
      , justify_items_(other.justify_items_)
      , align_items_(other.align_items_)
      , align_content_(other.align_content_)
      , justify_content_(other.justify_content_)
      , appearance_(other.appearance_)
      , touch_action_(other.touch_action_)
      , blend_mode_(other.blend_mode_)
      , contain_(other.contain_)
      , outline_style_(other.outline_style_)
      , object_fit_(other.object_fit_)
      , text_decoration_style_(other.text_decoration_style_)
      , draggable_region_mode_(other.draggable_region_mode_)
      , margin_after_collapse_(other.margin_after_collapse_)
      , margin_before_collapse_(other.margin_before_collapse_)
      , page_size_type_(other.page_size_type_)
      , resize_(other.resize_)
      , scroll_behavior_(other.scroll_behavior_)
      , user_drag_(other.user_drag_)
      , backface_visibility_(other.backface_visibility_)
      , has_author_background_(other.has_author_background_)
      , has_author_border_(other.has_author_border_)
      , has_current_backdrop_filter_animation_(other.has_current_backdrop_filter_animation_)
      , has_current_filter_animation_(other.has_current_filter_animation_)
      , has_current_opacity_animation_(other.has_current_opacity_animation_)
      , has_current_transform_animation_(other.has_current_transform_animation_)
      , has_inline_transform_(other.has_inline_transform_)
      , is_running_backdrop_filter_animation_on_compositor_(other.is_running_backdrop_filter_animation_on_compositor_)
      , is_running_filter_animation_on_compositor_(other.is_running_filter_animation_on_compositor_)
      , is_running_opacity_animation_on_compositor_(other.is_running_opacity_animation_on_compositor_)
      , is_running_transform_animation_on_compositor_(other.is_running_transform_animation_on_compositor_)
      , is_stacking_context_(other.is_stacking_context_)
      , isolation_(other.isolation_)
      , outline_color_is_current_color_(other.outline_color_is_current_color_)
      , outline_style_is_auto_(other.outline_style_is_auto_)
      , requires_accelerated_compositing_for_external_reasons_(other.requires_accelerated_compositing_for_external_reasons_)
      , text_overflow_(other.text_overflow_)
      , transform_style_3d_(other.transform_style_3d_)
  {}

ComputedStyleBase::StyleSurroundData::StyleSurroundData() :
      border_image_(NinePieceImage())
      , border_bottom_left_radius_(LengthSize(Length(0, kFixed), Length(0, kFixed)))
      , border_top_right_radius_(LengthSize(Length(0, kFixed), Length(0, kFixed)))
      , border_bottom_right_radius_(LengthSize(Length(0, kFixed), Length(0, kFixed)))
      , border_top_left_radius_(LengthSize(Length(0, kFixed), Length(0, kFixed)))
      , padding_bottom_(Length(kFixed))
      , margin_right_(Length(kFixed))
      , padding_right_(Length(kFixed))
      , bottom_(Length())
      , top_(Length())
      , margin_top_(Length(kFixed))
      , padding_left_(Length(kFixed))
      , left_(Length())
      , margin_bottom_(Length(kFixed))
      , right_(Length())
      , margin_left_(Length(kFixed))
      , padding_top_(Length(kFixed))
      , border_right_color_(0)
      , border_left_color_(0)
      , border_top_color_(0)
      , border_bottom_color_(0)
      , border_right_width_(LayoutUnit(3))
      , border_left_width_(LayoutUnit(3))
      , border_top_width_(LayoutUnit(3))
      , border_bottom_width_(LayoutUnit(3))
      , border_bottom_style_(static_cast<unsigned>(EBorderStyle::kNone))
      , border_left_style_(static_cast<unsigned>(EBorderStyle::kNone))
      , border_right_style_(static_cast<unsigned>(EBorderStyle::kNone))
      , border_top_style_(static_cast<unsigned>(EBorderStyle::kNone))
      , border_bottom_color_is_current_color_(static_cast<unsigned>(true))
      , border_left_color_is_current_color_(static_cast<unsigned>(true))
      , border_right_color_is_current_color_(static_cast<unsigned>(true))
      , border_top_color_is_current_color_(static_cast<unsigned>(true))
  {
  }

ComputedStyleBase::StyleSurroundData::StyleSurroundData(const StyleSurroundData& other) :
      border_image_(other.border_image_)
      , border_bottom_left_radius_(other.border_bottom_left_radius_)
      , border_top_right_radius_(other.border_top_right_radius_)
      , border_bottom_right_radius_(other.border_bottom_right_radius_)
      , border_top_left_radius_(other.border_top_left_radius_)
      , padding_bottom_(other.padding_bottom_)
      , margin_right_(other.margin_right_)
      , padding_right_(other.padding_right_)
      , bottom_(other.bottom_)
      , top_(other.top_)
      , margin_top_(other.margin_top_)
      , padding_left_(other.padding_left_)
      , left_(other.left_)
      , margin_bottom_(other.margin_bottom_)
      , right_(other.right_)
      , margin_left_(other.margin_left_)
      , padding_top_(other.padding_top_)
      , border_right_color_(other.border_right_color_)
      , border_left_color_(other.border_left_color_)
      , border_top_color_(other.border_top_color_)
      , border_bottom_color_(other.border_bottom_color_)
      , border_right_width_(other.border_right_width_)
      , border_left_width_(other.border_left_width_)
      , border_top_width_(other.border_top_width_)
      , border_bottom_width_(other.border_bottom_width_)
      , border_bottom_style_(other.border_bottom_style_)
      , border_left_style_(other.border_left_style_)
      , border_right_style_(other.border_right_style_)
      , border_top_style_(other.border_top_style_)
      , border_bottom_color_is_current_color_(other.border_bottom_color_is_current_color_)
      , border_left_color_is_current_color_(other.border_left_color_is_current_color_)
      , border_right_color_is_current_color_(other.border_right_color_is_current_color_)
      , border_top_color_is_current_color_(other.border_top_color_is_current_color_)
  {}

ComputedStyleBase::StyleVisualData::StyleVisualData() :
      clip_(LengthBox())
      , zoom_(1.0)
      , text_decoration_(static_cast<unsigned>(TextDecoration::kNone))
      , has_auto_clip_(static_cast<unsigned>(true))
  {
  }

ComputedStyleBase::StyleVisualData::StyleVisualData(const StyleVisualData& other) :
      clip_(other.clip_)
      , zoom_(other.zoom_)
      , text_decoration_(other.text_decoration_)
      , has_auto_clip_(other.has_auto_clip_)
  {}

ComputedStyleBase::StyleBackgroundData::StyleBackgroundData() :
      background_(FillLayer(kBackgroundFillLayer, true))
      , background_color_(StyleColor(Color::kTransparent))
  {
  }

ComputedStyleBase::StyleBackgroundData::StyleBackgroundData(const StyleBackgroundData& other) :
      background_(other.background_)
      , background_color_(other.background_color_)
  {}

ComputedStyleBase::StyleInheritedData::StyleInheritedData() :
      font_(Font())
      , line_height_(Length(-100.0, kPercent))
      , text_autosizing_multiplier_(1.0)
      , color_(Color::kBlack)
      , visited_link_color_(Color::kBlack)
      , horizontal_border_spacing_(0)
      , vertical_border_spacing_(0)
  {
  }

ComputedStyleBase::StyleInheritedData::StyleInheritedData(const StyleInheritedData& other) :
      font_(other.font_)
      , line_height_(other.line_height_)
      , text_autosizing_multiplier_(other.text_autosizing_multiplier_)
      , color_(other.color_)
      , visited_link_color_(other.visited_link_color_)
      , horizontal_border_spacing_(other.horizontal_border_spacing_)
      , vertical_border_spacing_(other.vertical_border_spacing_)
  {}


} // namespace blink

ComputedStyleBase.h

// Copyright (c) 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef ComputedStyleBase_h
#define ComputedStyleBase_h

#include "core/CoreExport.h"
#include "core/layout/LayoutTheme.h"
#include "core/style/ComputedStyleConstants.h"
#include "core/style/DataRef.h"
#include "core/style/MemberCopy.h"
#include "core/CSSPropertyNames.h"
#include "core/animation/css/CSSAnimationData.h"
#include "core/animation/css/CSSTransitionData.h"
#include "core/css/StyleColor.h"
#include "core/style/AppliedTextDecorationList.h"
#include "core/style/BasicShapes.h"
#include "core/style/ClipPathOperation.h"
#include "core/style/ContentData.h"
#include "core/style/CounterDirectives.h"
#include "core/style/CursorList.h"
#include "core/style/FillLayer.h"
#include "core/style/GridArea.h"
#include "core/style/GridPosition.h"
#include "core/style/GridTrackSize.h"
#include "core/style/LineClampValue.h"
#include "core/style/NamedGridLinesMap.h"
#include "core/style/NinePieceImage.h"
#include "core/style/OrderedNamedGridLines.h"
#include "core/style/PaintImages.h"
#include "core/style/QuotesData.h"
#include "core/style/ScrollSnap.h"
#include "core/style/ShadowList.h"
#include "core/style/ShapeValue.h"
#include "core/style/StyleContentAlignmentData.h"
#include "core/style/StyleFilterData.h"
#include "core/style/StyleImage.h"
#include "core/style/StyleInheritedVariables.h"
#include "core/style/StyleNonInheritedVariables.h"
#include "core/style/StyleOffsetRotation.h"
#include "core/style/StyleReflection.h"
#include "core/style/StyleSelfAlignmentData.h"
#include "core/style/TextSizeAdjust.h"
#include "core/style/TransformOrigin.h"
#include "platform/LayoutUnit.h"
#include "platform/Length.h"
#include "platform/LengthBox.h"
#include "platform/LengthPoint.h"
#include "platform/LengthSize.h"
#include "platform/fonts/Font.h"
#include "platform/geometry/FloatSize.h"
#include "platform/graphics/Color.h"
#include "platform/graphics/TouchAction.h"
#include "platform/text/TabSize.h"
#include "platform/text/TextDirection.h"
#include "platform/text/TextJustify.h"
#include "platform/text/UnicodeBidi.h"
#include "platform/text/WritingMode.h"
#include "platform/transforms/RotateTransformOperation.h"
#include "platform/transforms/ScaleTransformOperation.h"
#include "platform/transforms/TransformOperations.h"
#include "platform/transforms/TranslateTransformOperation.h"
#include "platform/wtf/Vector.h"
#include "platform/wtf/text/AtomicString.h"
#include "platform/wtf/text/WTFString.h"
#include "public/platform/WebBlendMode.h"


namespace blink {

// Forward declaration for diff functions.
class ComputedStyle;

// The generated portion of ComputedStyle. For more info, see the header comment
// in ComputedStyle.h.
//
// ComputedStyleBase is a generated class that stores data members or 'fields'
// used in ComputedStyle. These fields can represent CSS properties or internal
// style information.
//
// STORAGE:
//
// Fields are organised in a tree structure, where a node (called a 'group')
// stores a set of fields and a set of pointers to child nodes (called
// 'subgroups'). We can visualise the tree structure with ComputedStyleBase as
// the root node:
//
// ComputedStyleBase (fields: display, vertical-align, ...)
//  |- StyleSurroundData (fields: padding, border, ...)
//  |- StyleBoxData (fields: width, height, ...)
//  |- ...
//  |- StyleRareNonInheritedData (fields: box-shadow, text-overflow, ...)
//      |- StyleFlexibleBoxData (fields: flex-direction, flex-wrap, ...)
//      |- ...
//
// This design saves memory by allowing multiple ComputedStyleBases to share the
// same instance of a subgroup. For example, if a page never uses flex box
// properties, then every ComputedStyleBase can share the same instance of
// StyleFlexibleBoxData. Without this sharing, we would need to allocate a copy
// of all the flex box fields for every ComputedStyleBase. Similarly, when an
// element inherits from its parent, its ComputedStyleBase can simply share all
// of its subgroups with the parent's.
//
// INTERFACE:
//
// The functions generated for a field is determined by its 'template'. For
// example, a field with the 'keyword' template has only one setter, whereas an
// 'external' field has an extra setter that takes an rvalue reference. A list
// of the available templates can be found in CSSProperties.json5.
class CORE_EXPORT ComputedStyleBase {
 public:
  inline bool IndependentInheritedEqual(const ComputedStyleBase& o) const {
    return (
        pointer_events_ == o.pointer_events_
        && white_space_ == o.white_space_
        && text_transform_ == o.text_transform_
        && visibility_ == o.visibility_
        && border_collapse_ == o.border_collapse_
        && box_direction_ == o.box_direction_
        && caption_side_ == o.caption_side_
        && empty_cells_ == o.empty_cells_
        && list_style_position_ == o.list_style_position_
        && print_color_adjust_ == o.print_color_adjust_
        && rtl_ordering_ == o.rtl_ordering_
    );
  }

  inline bool NonIndependentInheritedEqual(const ComputedStyleBase& o) const {
    return (
        rare_inherited_data_ == o.rare_inherited_data_
        && inherited_data_ == o.inherited_data_
        && cursor_ == o.cursor_
        && list_style_type_ == o.list_style_type_
        && text_align_ == o.text_align_
        && inside_link_ == o.inside_link_
        && writing_mode_ == o.writing_mode_
        && direction_ == o.direction_
        && has_simple_underline_ == o.has_simple_underline_
    );
  }

  inline bool InheritedEqual(const ComputedStyleBase& o) const {
    return IndependentInheritedEqual(o) && NonIndependentInheritedEqual(o);
  }

  inline bool NonInheritedEqual(const ComputedStyleBase& o) const {
    return (
        box_data_ == o.box_data_
        && rare_non_inherited_data_ == o.rare_non_inherited_data_
        && surround_data_ == o.surround_data_
        && visual_data_ == o.visual_data_
        && background_data_ == o.background_data_
        && display_ == o.display_
        && original_display_ == o.original_display_
        && break_after_ == o.break_after_
        && break_before_ == o.break_before_
        && vertical_align_ == o.vertical_align_
        && overflow_x_ == o.overflow_x_
        && overflow_y_ == o.overflow_y_
        && position_ == o.position_
        && unicode_bidi_ == o.unicode_bidi_
        && break_inside_ == o.break_inside_
        && clear_ == o.clear_
        && floating_ == o.floating_
        && overflow_anchor_ == o.overflow_anchor_
        && transform_box_ == o.transform_box_
        && scroll_snap_stop_ == o.scroll_snap_stop_
        && table_layout_ == o.table_layout_
    );
  }

  inline bool InheritedDataShared(const ComputedStyleBase& o) const {
    return (
        rare_inherited_data_.Get() == o.rare_inherited_data_.Get()
        && inherited_data_.Get() == o.inherited_data_.Get()
        && cursor_ == o.cursor_
        && list_style_type_ == o.list_style_type_
        && pointer_events_ == o.pointer_events_
        && text_align_ == o.text_align_
        && white_space_ == o.white_space_
        && inside_link_ == o.inside_link_
        && text_transform_ == o.text_transform_
        && visibility_ == o.visibility_
        && writing_mode_ == o.writing_mode_
        && border_collapse_ == o.border_collapse_
        && box_direction_ == o.box_direction_
        && caption_side_ == o.caption_side_
        && direction_ == o.direction_
        && empty_cells_ == o.empty_cells_
        && has_simple_underline_ == o.has_simple_underline_
        && list_style_position_ == o.list_style_position_
        && print_color_adjust_ == o.print_color_adjust_
        && rtl_ordering_ == o.rtl_ordering_
    );
  }

  enum IsAtShadowBoundary {
    kAtShadowBoundary,
    kNotAtShadowBoundary,
  };

  void InheritFrom(const ComputedStyleBase& other,
                                      IsAtShadowBoundary isAtShadowBoundary);

  void CopyNonInheritedFromCached(
      const ComputedStyleBase& other);

  // Copies the values of any independent inherited properties from the parent
  // style that are marked as inherited by this style.
  void PropagateIndependentInheritedProperties(
      const ComputedStyleBase& parentStyle);

  static bool DiffNeedsVisualRectUpdate(const ComputedStyle& a, const ComputedStyle& b);
  static bool DiffTransformData(const ComputedStyle& a, const ComputedStyle& b);
  static bool UpdatePropertySpecificDifferencesOpacity(const ComputedStyle& a, const ComputedStyle& b);
  static bool UpdatePropertySpecificDifferencesFilter(const ComputedStyle& a, const ComputedStyle& b);
  static bool UpdatePropertySpecificDifferencesTextDecorationOrColor(const ComputedStyle& a, const ComputedStyle& b);
  static bool UpdatePropertySpecificDifferencesTransform(const ComputedStyle& a, const ComputedStyle& b);
  static bool DiffNeedsFullLayout(const ComputedStyle& a, const ComputedStyle& b);
  static bool UpdatePropertySpecificDifferencesZIndex(const ComputedStyle& a, const ComputedStyle& b);
  static bool DiffNeedsFullLayoutAndPaintInvalidationDisplayListItem(const ComputedStyle& a, const ComputedStyle& b);
  static bool UpdatePropertySpecificDifferencesNeedsRecomputeOverflow(const ComputedStyle& a, const ComputedStyle& b);
  static bool DiffNeedsPaintInvalidationSubtree(const ComputedStyle& a, const ComputedStyle& b);
  static bool DiffNeedsPaintInvalidationObject(const ComputedStyle& a, const ComputedStyle& b);
  static bool ScrollAnchorDisablingPropertyChanged(const ComputedStyle& a, const ComputedStyle& b);
  static bool DiffNeedsFullLayoutAndPaintInvalidation(const ComputedStyle& a, const ComputedStyle& b);
  static bool DiffNeedsFullLayoutAndPaintInvalidationDisplayTableType(const ComputedStyle& a, const ComputedStyle& b);
  static bool UpdatePropertySpecificDifferencesBackdropFilter(const ComputedStyle& a, const ComputedStyle& b);

  // Fields.
  // TODO(sashab): Remove initialFoo() static methods and update callers to
  // use resetFoo(), which can be more efficient.

  // AffectedByActive
  bool AffectedByActive() const {
    return static_cast<bool>(affected_by_active_);
  }
  void SetAffectedByActive() {
    affected_by_active_ = static_cast<unsigned>(true);
  }

  // AffectedByDrag
  bool AffectedByDrag() const {
    return static_cast<bool>(affected_by_drag_);
  }
  void SetAffectedByDrag() {
    affected_by_drag_ = static_cast<unsigned>(true);
  }

  // AffectedByFocusWithin
  bool AffectedByFocusWithin() const {
    return static_cast<bool>(affected_by_focus_within_);
  }
  void SetAffectedByFocusWithin() {
    affected_by_focus_within_ = static_cast<unsigned>(true);
  }

  // AffectedByHover
  bool AffectedByHover() const {
    return static_cast<bool>(affected_by_hover_);
  }
  void SetAffectedByHover() {
    affected_by_hover_ = static_cast<unsigned>(true);
  }

  // align-content
  inline static StyleContentAlignmentData InitialAlignContent() {
    return StyleContentAlignmentData(kContentPositionNormal, kContentDistributionDefault, kOverflowAlignmentDefault);
  }
  const StyleContentAlignmentData& AlignContent() const {
    return rare_non_inherited_data_->align_content_;
  }
  void SetAlignContent(const StyleContentAlignmentData& v) {
    if (!(rare_non_inherited_data_->align_content_ == v))
      rare_non_inherited_data_.Access()->align_content_ = v;
  }
  void SetAlignContent(StyleContentAlignmentData&& v) {
    if (!(rare_non_inherited_data_->align_content_ == v))
      rare_non_inherited_data_.Access()->align_content_ = std::move(v);
  }
  inline void ResetAlignContent() {
    rare_non_inherited_data_.Access()->align_content_ = StyleContentAlignmentData(kContentPositionNormal, kContentDistributionDefault, kOverflowAlignmentDefault);
  }

  // align-items
  inline static StyleSelfAlignmentData InitialAlignItems() {
    return StyleSelfAlignmentData(RuntimeEnabledFeatures::CSSGridLayoutEnabled() ? kItemPositionNormal : kItemPositionStretch, kOverflowAlignmentDefault);
  }
  const StyleSelfAlignmentData& AlignItems() const {
    return rare_non_inherited_data_->align_items_;
  }
  void SetAlignItems(const StyleSelfAlignmentData& v) {
    if (!(rare_non_inherited_data_->align_items_ == v))
      rare_non_inherited_data_.Access()->align_items_ = v;
  }
  void SetAlignItems(StyleSelfAlignmentData&& v) {
    if (!(rare_non_inherited_data_->align_items_ == v))
      rare_non_inherited_data_.Access()->align_items_ = std::move(v);
  }
  inline void ResetAlignItems() {
    rare_non_inherited_data_.Access()->align_items_ = StyleSelfAlignmentData(RuntimeEnabledFeatures::CSSGridLayoutEnabled() ? kItemPositionNormal : kItemPositionStretch, kOverflowAlignmentDefault);
  }

  // align-self
  inline static StyleSelfAlignmentData InitialAlignSelf() {
    return StyleSelfAlignmentData(kItemPositionAuto, kOverflowAlignmentDefault);
  }
  const StyleSelfAlignmentData& AlignSelf() const {
    return rare_non_inherited_data_->align_self_;
  }
  void SetAlignSelf(const StyleSelfAlignmentData& v) {
    if (!(rare_non_inherited_data_->align_self_ == v))
      rare_non_inherited_data_.Access()->align_self_ = v;
  }
  void SetAlignSelf(StyleSelfAlignmentData&& v) {
    if (!(rare_non_inherited_data_->align_self_ == v))
      rare_non_inherited_data_.Access()->align_self_ = std::move(v);
  }
  inline void ResetAlignSelf() {
    rare_non_inherited_data_.Access()->align_self_ = StyleSelfAlignmentData(kItemPositionAuto, kOverflowAlignmentDefault);
  }

  // Animations
  inline static std::unique_ptr<CSSAnimationData> InitialAnimations() {
    return nullptr;
  }
  // Getters and setters not generated

  // -webkit-appearance
  inline static ControlPart InitialAppearance() {
    return kNoControlPart;
  }
  // Getters and setters not generated

  // AppliedTextDecorations
  inline static RefPtr<AppliedTextDecorationList> InitialAppliedTextDecorations() {
    return nullptr;
  }
  // Getters and setters not generated

  // AutoRepeatNamedGridColumnLines
  inline static NamedGridLinesMap InitialAutoRepeatNamedGridColumnLines() {
    return NamedGridLinesMap();
  }
  const NamedGridLinesMap& AutoRepeatNamedGridColumnLines() const {
    return rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_column_lines_;
  }
  void SetAutoRepeatNamedGridColumnLines(const NamedGridLinesMap& v) {
    if (!(rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_column_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_named_grid_column_lines_ = v;
  }
  void SetAutoRepeatNamedGridColumnLines(NamedGridLinesMap&& v) {
    if (!(rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_column_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_named_grid_column_lines_ = std::move(v);
  }
  inline void ResetAutoRepeatNamedGridColumnLines() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_named_grid_column_lines_ = NamedGridLinesMap();
  }

  // AutoRepeatNamedGridRowLines
  inline static NamedGridLinesMap InitialAutoRepeatNamedGridRowLines() {
    return NamedGridLinesMap();
  }
  const NamedGridLinesMap& AutoRepeatNamedGridRowLines() const {
    return rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_row_lines_;
  }
  void SetAutoRepeatNamedGridRowLines(const NamedGridLinesMap& v) {
    if (!(rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_row_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_named_grid_row_lines_ = v;
  }
  void SetAutoRepeatNamedGridRowLines(NamedGridLinesMap&& v) {
    if (!(rare_non_inherited_data_->grid_data_->auto_repeat_named_grid_row_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_named_grid_row_lines_ = std::move(v);
  }
  inline void ResetAutoRepeatNamedGridRowLines() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_named_grid_row_lines_ = NamedGridLinesMap();
  }

  // AutoRepeatOrderedNamedGridColumnLines
  inline static OrderedNamedGridLines InitialAutoRepeatOrderedNamedGridColumnLines() {
    return OrderedNamedGridLines();
  }
  const OrderedNamedGridLines& AutoRepeatOrderedNamedGridColumnLines() const {
    return rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_column_lines_;
  }
  void SetAutoRepeatOrderedNamedGridColumnLines(const OrderedNamedGridLines& v) {
    if (!(rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_column_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_ordered_named_grid_column_lines_ = v;
  }
  void SetAutoRepeatOrderedNamedGridColumnLines(OrderedNamedGridLines&& v) {
    if (!(rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_column_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_ordered_named_grid_column_lines_ = std::move(v);
  }
  inline void ResetAutoRepeatOrderedNamedGridColumnLines() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_ordered_named_grid_column_lines_ = OrderedNamedGridLines();
  }

  // AutoRepeatOrderedNamedGridRowLines
  inline static OrderedNamedGridLines InitialAutoRepeatOrderedNamedGridRowLines() {
    return OrderedNamedGridLines();
  }
  const OrderedNamedGridLines& AutoRepeatOrderedNamedGridRowLines() const {
    return rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_row_lines_;
  }
  void SetAutoRepeatOrderedNamedGridRowLines(const OrderedNamedGridLines& v) {
    if (!(rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_row_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_ordered_named_grid_row_lines_ = v;
  }
  void SetAutoRepeatOrderedNamedGridRowLines(OrderedNamedGridLines&& v) {
    if (!(rare_non_inherited_data_->grid_data_->auto_repeat_ordered_named_grid_row_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_ordered_named_grid_row_lines_ = std::move(v);
  }
  inline void ResetAutoRepeatOrderedNamedGridRowLines() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_ordered_named_grid_row_lines_ = OrderedNamedGridLines();
  }

  // backdrop-filter
  inline static Persistent<StyleFilterData> InitialBackdropFilter() {
    return StyleFilterData::Create();
  }
  // Getters and setters not generated

  // backface-visibility
  inline static EBackfaceVisibility InitialBackfaceVisibility() {
    return EBackfaceVisibility::kVisible;
  }
  EBackfaceVisibility BackfaceVisibility() const {
    return static_cast<EBackfaceVisibility>(rare_non_inherited_data_->backface_visibility_);
  }
  void SetBackfaceVisibility(EBackfaceVisibility v) {
    if (!(rare_non_inherited_data_->backface_visibility_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->backface_visibility_ = static_cast<unsigned>(v);
  }
  inline void ResetBackfaceVisibility() {
    rare_non_inherited_data_.Access()->backface_visibility_ = static_cast<unsigned>(EBackfaceVisibility::kVisible);
  }

  // Background
  inline static FillLayer InitialBackground() {
    return FillLayer(kBackgroundFillLayer, true);
  }
  // Getters and setters not generated

  // background-color
  inline static StyleColor InitialBackgroundColor() {
    return StyleColor(Color::kTransparent);
  }
  // Getters and setters not generated

  // mix-blend-mode
  inline static WebBlendMode InitialBlendMode() {
    return WebBlendMode::kNormal;
  }
  WebBlendMode BlendMode() const {
    return static_cast<WebBlendMode>(rare_non_inherited_data_->blend_mode_);
  }
  void SetBlendMode(WebBlendMode v) {
    if (!(rare_non_inherited_data_->blend_mode_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->blend_mode_ = static_cast<unsigned>(v);
  }
  inline void ResetBlendMode() {
    rare_non_inherited_data_.Access()->blend_mode_ = static_cast<unsigned>(WebBlendMode::kNormal);
  }

  // border-bottom-color
  inline static Color InitialBorderBottomColor() {
    return 0;
  }
  // Getters and setters not generated

  // BorderBottomColorIsCurrentColor
  inline static bool InitialBorderBottomColorIsCurrentColor() {
    return true;
  }
  bool BorderBottomColorIsCurrentColor() const {
    return static_cast<bool>(surround_data_->border_bottom_color_is_current_color_);
  }
  void SetBorderBottomColorIsCurrentColor(bool v) {
    if (!(surround_data_->border_bottom_color_is_current_color_ == static_cast<unsigned>(v)))
      surround_data_.Access()->border_bottom_color_is_current_color_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderBottomColorIsCurrentColor() {
    surround_data_.Access()->border_bottom_color_is_current_color_ = static_cast<unsigned>(true);
  }

  // border-bottom-left-radius
  inline static LengthSize InitialBorderBottomLeftRadius() {
    return LengthSize(Length(0, kFixed), Length(0, kFixed));
  }
  const LengthSize& BorderBottomLeftRadius() const {
    return surround_data_->border_bottom_left_radius_;
  }
  void SetBorderBottomLeftRadius(const LengthSize& v) {
    if (!(surround_data_->border_bottom_left_radius_ == v))
      surround_data_.Access()->border_bottom_left_radius_ = v;
  }
  void SetBorderBottomLeftRadius(LengthSize&& v) {
    if (!(surround_data_->border_bottom_left_radius_ == v))
      surround_data_.Access()->border_bottom_left_radius_ = std::move(v);
  }
  inline void ResetBorderBottomLeftRadius() {
    surround_data_.Access()->border_bottom_left_radius_ = LengthSize(Length(0, kFixed), Length(0, kFixed));
  }

  // border-bottom-right-radius
  inline static LengthSize InitialBorderBottomRightRadius() {
    return LengthSize(Length(0, kFixed), Length(0, kFixed));
  }
  const LengthSize& BorderBottomRightRadius() const {
    return surround_data_->border_bottom_right_radius_;
  }
  void SetBorderBottomRightRadius(const LengthSize& v) {
    if (!(surround_data_->border_bottom_right_radius_ == v))
      surround_data_.Access()->border_bottom_right_radius_ = v;
  }
  void SetBorderBottomRightRadius(LengthSize&& v) {
    if (!(surround_data_->border_bottom_right_radius_ == v))
      surround_data_.Access()->border_bottom_right_radius_ = std::move(v);
  }
  inline void ResetBorderBottomRightRadius() {
    surround_data_.Access()->border_bottom_right_radius_ = LengthSize(Length(0, kFixed), Length(0, kFixed));
  }

  // border-bottom-style
  inline static EBorderStyle InitialBorderBottomStyle() {
    return EBorderStyle::kNone;
  }
  EBorderStyle BorderBottomStyle() const {
    return static_cast<EBorderStyle>(surround_data_->border_bottom_style_);
  }
  void SetBorderBottomStyle(EBorderStyle v) {
    if (!(surround_data_->border_bottom_style_ == static_cast<unsigned>(v)))
      surround_data_.Access()->border_bottom_style_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderBottomStyle() {
    surround_data_.Access()->border_bottom_style_ = static_cast<unsigned>(EBorderStyle::kNone);
  }

  // border-bottom-width
  inline static LayoutUnit InitialBorderBottomWidth() {
    return LayoutUnit(3);
  }
  // Getters and setters not generated

  // border-collapse
  inline static EBorderCollapse InitialBorderCollapse() {
    return EBorderCollapse::kSeparate;
  }
  EBorderCollapse BorderCollapse() const {
    return static_cast<EBorderCollapse>(border_collapse_);
  }
  void SetBorderCollapse(EBorderCollapse v) {
    border_collapse_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderCollapse() {
    border_collapse_ = static_cast<unsigned>(EBorderCollapse::kSeparate);
  }

  // border-collapse
  inline static bool InitialBorderCollapseIsInherited() {
    return true;
  }
  bool BorderCollapseIsInherited() const {
    return static_cast<bool>(border_collapse_is_inherited_);
  }
  void SetBorderCollapseIsInherited(bool v) {
    border_collapse_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderCollapseIsInherited() {
    border_collapse_is_inherited_ = static_cast<unsigned>(true);
  }

  // border-image
  inline static NinePieceImage InitialBorderImage() {
    return NinePieceImage();
  }
  const NinePieceImage& BorderImage() const {
    return surround_data_->border_image_;
  }
  void SetBorderImage(const NinePieceImage& v) {
    if (!(surround_data_->border_image_ == v))
      surround_data_.Access()->border_image_ = v;
  }
  void SetBorderImage(NinePieceImage&& v) {
    if (!(surround_data_->border_image_ == v))
      surround_data_.Access()->border_image_ = std::move(v);
  }
  inline void ResetBorderImage() {
    surround_data_.Access()->border_image_ = NinePieceImage();
  }

  // border-left-color
  inline static Color InitialBorderLeftColor() {
    return 0;
  }
  // Getters and setters not generated

  // BorderLeftColorIsCurrentColor
  inline static bool InitialBorderLeftColorIsCurrentColor() {
    return true;
  }
  bool BorderLeftColorIsCurrentColor() const {
    return static_cast<bool>(surround_data_->border_left_color_is_current_color_);
  }
  void SetBorderLeftColorIsCurrentColor(bool v) {
    if (!(surround_data_->border_left_color_is_current_color_ == static_cast<unsigned>(v)))
      surround_data_.Access()->border_left_color_is_current_color_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderLeftColorIsCurrentColor() {
    surround_data_.Access()->border_left_color_is_current_color_ = static_cast<unsigned>(true);
  }

  // border-left-style
  inline static EBorderStyle InitialBorderLeftStyle() {
    return EBorderStyle::kNone;
  }
  EBorderStyle BorderLeftStyle() const {
    return static_cast<EBorderStyle>(surround_data_->border_left_style_);
  }
  void SetBorderLeftStyle(EBorderStyle v) {
    if (!(surround_data_->border_left_style_ == static_cast<unsigned>(v)))
      surround_data_.Access()->border_left_style_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderLeftStyle() {
    surround_data_.Access()->border_left_style_ = static_cast<unsigned>(EBorderStyle::kNone);
  }

  // border-left-width
  inline static LayoutUnit InitialBorderLeftWidth() {
    return LayoutUnit(3);
  }
  // Getters and setters not generated

  // border-right-color
  inline static Color InitialBorderRightColor() {
    return 0;
  }
  // Getters and setters not generated

  // BorderRightColorIsCurrentColor
  inline static bool InitialBorderRightColorIsCurrentColor() {
    return true;
  }
  bool BorderRightColorIsCurrentColor() const {
    return static_cast<bool>(surround_data_->border_right_color_is_current_color_);
  }
  void SetBorderRightColorIsCurrentColor(bool v) {
    if (!(surround_data_->border_right_color_is_current_color_ == static_cast<unsigned>(v)))
      surround_data_.Access()->border_right_color_is_current_color_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderRightColorIsCurrentColor() {
    surround_data_.Access()->border_right_color_is_current_color_ = static_cast<unsigned>(true);
  }

  // border-right-style
  inline static EBorderStyle InitialBorderRightStyle() {
    return EBorderStyle::kNone;
  }
  EBorderStyle BorderRightStyle() const {
    return static_cast<EBorderStyle>(surround_data_->border_right_style_);
  }
  void SetBorderRightStyle(EBorderStyle v) {
    if (!(surround_data_->border_right_style_ == static_cast<unsigned>(v)))
      surround_data_.Access()->border_right_style_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderRightStyle() {
    surround_data_.Access()->border_right_style_ = static_cast<unsigned>(EBorderStyle::kNone);
  }

  // border-right-width
  inline static LayoutUnit InitialBorderRightWidth() {
    return LayoutUnit(3);
  }
  // Getters and setters not generated

  // border-top-color
  inline static Color InitialBorderTopColor() {
    return 0;
  }
  // Getters and setters not generated

  // BorderTopColorIsCurrentColor
  inline static bool InitialBorderTopColorIsCurrentColor() {
    return true;
  }
  bool BorderTopColorIsCurrentColor() const {
    return static_cast<bool>(surround_data_->border_top_color_is_current_color_);
  }
  void SetBorderTopColorIsCurrentColor(bool v) {
    if (!(surround_data_->border_top_color_is_current_color_ == static_cast<unsigned>(v)))
      surround_data_.Access()->border_top_color_is_current_color_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderTopColorIsCurrentColor() {
    surround_data_.Access()->border_top_color_is_current_color_ = static_cast<unsigned>(true);
  }

  // border-top-left-radius
  inline static LengthSize InitialBorderTopLeftRadius() {
    return LengthSize(Length(0, kFixed), Length(0, kFixed));
  }
  const LengthSize& BorderTopLeftRadius() const {
    return surround_data_->border_top_left_radius_;
  }
  void SetBorderTopLeftRadius(const LengthSize& v) {
    if (!(surround_data_->border_top_left_radius_ == v))
      surround_data_.Access()->border_top_left_radius_ = v;
  }
  void SetBorderTopLeftRadius(LengthSize&& v) {
    if (!(surround_data_->border_top_left_radius_ == v))
      surround_data_.Access()->border_top_left_radius_ = std::move(v);
  }
  inline void ResetBorderTopLeftRadius() {
    surround_data_.Access()->border_top_left_radius_ = LengthSize(Length(0, kFixed), Length(0, kFixed));
  }

  // border-top-right-radius
  inline static LengthSize InitialBorderTopRightRadius() {
    return LengthSize(Length(0, kFixed), Length(0, kFixed));
  }
  const LengthSize& BorderTopRightRadius() const {
    return surround_data_->border_top_right_radius_;
  }
  void SetBorderTopRightRadius(const LengthSize& v) {
    if (!(surround_data_->border_top_right_radius_ == v))
      surround_data_.Access()->border_top_right_radius_ = v;
  }
  void SetBorderTopRightRadius(LengthSize&& v) {
    if (!(surround_data_->border_top_right_radius_ == v))
      surround_data_.Access()->border_top_right_radius_ = std::move(v);
  }
  inline void ResetBorderTopRightRadius() {
    surround_data_.Access()->border_top_right_radius_ = LengthSize(Length(0, kFixed), Length(0, kFixed));
  }

  // border-top-style
  inline static EBorderStyle InitialBorderTopStyle() {
    return EBorderStyle::kNone;
  }
  EBorderStyle BorderTopStyle() const {
    return static_cast<EBorderStyle>(surround_data_->border_top_style_);
  }
  void SetBorderTopStyle(EBorderStyle v) {
    if (!(surround_data_->border_top_style_ == static_cast<unsigned>(v)))
      surround_data_.Access()->border_top_style_ = static_cast<unsigned>(v);
  }
  inline void ResetBorderTopStyle() {
    surround_data_.Access()->border_top_style_ = static_cast<unsigned>(EBorderStyle::kNone);
  }

  // border-top-width
  inline static LayoutUnit InitialBorderTopWidth() {
    return LayoutUnit(3);
  }
  // Getters and setters not generated

  // bottom
  inline static Length InitialBottom() {
    return Length();
  }
  const Length& Bottom() const {
    return surround_data_->bottom_;
  }
  void SetBottom(const Length& v) {
    if (!(surround_data_->bottom_ == v))
      surround_data_.Access()->bottom_ = v;
  }
  void SetBottom(Length&& v) {
    if (!(surround_data_->bottom_ == v))
      surround_data_.Access()->bottom_ = std::move(v);
  }
  inline void ResetBottom() {
    surround_data_.Access()->bottom_ = Length();
  }

  // -webkit-box-align
  inline static EBoxAlignment InitialBoxAlign() {
    return EBoxAlignment::kStretch;
  }
  EBoxAlignment BoxAlign() const {
    return static_cast<EBoxAlignment>(rare_non_inherited_data_->deprecated_flexible_box_data_->box_align_);
  }
  void SetBoxAlign(EBoxAlignment v) {
    if (!(rare_non_inherited_data_->deprecated_flexible_box_data_->box_align_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_align_ = static_cast<unsigned>(v);
  }
  inline void ResetBoxAlign() {
    rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_align_ = static_cast<unsigned>(EBoxAlignment::kStretch);
  }

  // -webkit-box-decoration-break
  inline static EBoxDecorationBreak InitialBoxDecorationBreak() {
    return EBoxDecorationBreak::kSlice;
  }
  EBoxDecorationBreak BoxDecorationBreak() const {
    return static_cast<EBoxDecorationBreak>(box_data_->box_decoration_break_);
  }
  void SetBoxDecorationBreak(EBoxDecorationBreak v) {
    if (!(box_data_->box_decoration_break_ == static_cast<unsigned>(v)))
      box_data_.Access()->box_decoration_break_ = static_cast<unsigned>(v);
  }
  inline void ResetBoxDecorationBreak() {
    box_data_.Access()->box_decoration_break_ = static_cast<unsigned>(EBoxDecorationBreak::kSlice);
  }

  // -webkit-box-direction
  inline static EBoxDirection InitialBoxDirection() {
    return EBoxDirection::kNormal;
  }
  EBoxDirection BoxDirection() const {
    return static_cast<EBoxDirection>(box_direction_);
  }
  void SetBoxDirection(EBoxDirection v) {
    box_direction_ = static_cast<unsigned>(v);
  }
  inline void ResetBoxDirection() {
    box_direction_ = static_cast<unsigned>(EBoxDirection::kNormal);
  }

  // -webkit-box-direction
  inline static bool InitialBoxDirectionIsInherited() {
    return true;
  }
  bool BoxDirectionIsInherited() const {
    return static_cast<bool>(box_direction_is_inherited_);
  }
  void SetBoxDirectionIsInherited(bool v) {
    box_direction_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetBoxDirectionIsInherited() {
    box_direction_is_inherited_ = static_cast<unsigned>(true);
  }

  // -webkit-box-flex
  inline static float InitialBoxFlex() {
    return 0.0f;
  }
  float BoxFlex() const {
    return rare_non_inherited_data_->deprecated_flexible_box_data_->box_flex_;
  }
  void SetBoxFlex(float v) {
    if (!(rare_non_inherited_data_->deprecated_flexible_box_data_->box_flex_ == v))
      rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_flex_ = v;
  }
  inline void ResetBoxFlex() {
    rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_flex_ = 0.0f;
  }

  // -webkit-box-flex-group
  inline static unsigned InitialBoxFlexGroup() {
    return 1;
  }
  unsigned BoxFlexGroup() const {
    return rare_non_inherited_data_->deprecated_flexible_box_data_->box_flex_group_;
  }
  void SetBoxFlexGroup(unsigned v) {
    if (!(rare_non_inherited_data_->deprecated_flexible_box_data_->box_flex_group_ == v))
      rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_flex_group_ = v;
  }
  inline void ResetBoxFlexGroup() {
    rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_flex_group_ = 1;
  }

  // -webkit-box-lines
  inline static EBoxLines InitialBoxLines() {
    return EBoxLines::kSingle;
  }
  EBoxLines BoxLines() const {
    return static_cast<EBoxLines>(rare_non_inherited_data_->deprecated_flexible_box_data_->box_lines_);
  }
  void SetBoxLines(EBoxLines v) {
    if (!(rare_non_inherited_data_->deprecated_flexible_box_data_->box_lines_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_lines_ = static_cast<unsigned>(v);
  }
  inline void ResetBoxLines() {
    rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_lines_ = static_cast<unsigned>(EBoxLines::kSingle);
  }

  // -webkit-box-ordinal-group
  inline static unsigned InitialBoxOrdinalGroup() {
    return 1;
  }
  // Getters and setters not generated

  // -webkit-box-orient
  inline static EBoxOrient InitialBoxOrient() {
    return EBoxOrient::kHorizontal;
  }
  EBoxOrient BoxOrient() const {
    return static_cast<EBoxOrient>(rare_non_inherited_data_->deprecated_flexible_box_data_->box_orient_);
  }
  void SetBoxOrient(EBoxOrient v) {
    if (!(rare_non_inherited_data_->deprecated_flexible_box_data_->box_orient_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_orient_ = static_cast<unsigned>(v);
  }
  inline void ResetBoxOrient() {
    rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_orient_ = static_cast<unsigned>(EBoxOrient::kHorizontal);
  }

  // -webkit-box-pack
  inline static EBoxPack InitialBoxPack() {
    return EBoxPack::kStart;
  }
  EBoxPack BoxPack() const {
    return static_cast<EBoxPack>(rare_non_inherited_data_->deprecated_flexible_box_data_->box_pack_);
  }
  void SetBoxPack(EBoxPack v) {
    if (!(rare_non_inherited_data_->deprecated_flexible_box_data_->box_pack_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_pack_ = static_cast<unsigned>(v);
  }
  inline void ResetBoxPack() {
    rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_pack_ = static_cast<unsigned>(EBoxPack::kStart);
  }

  // -webkit-box-reflect
  static StyleReflection* InitialBoxReflect() {
    return nullptr;
  }
  StyleReflection* BoxReflect() const {
    return rare_non_inherited_data_->box_reflect_.Get();
  }
  
  void SetBoxReflect(RefPtr<StyleReflection> v) {
    rare_non_inherited_data_.Access()->box_reflect_ = std::move(v);
  }

  // box-shadow
  static ShadowList* InitialBoxShadow() {
    return nullptr;
  }
  ShadowList* BoxShadow() const {
    return rare_non_inherited_data_->box_shadow_.Get();
  }
  
  void SetBoxShadow(RefPtr<ShadowList> v) {
    rare_non_inherited_data_.Access()->box_shadow_ = std::move(v);
  }

  // box-sizing
  inline static EBoxSizing InitialBoxSizing() {
    return EBoxSizing::kContentBox;
  }
  EBoxSizing BoxSizing() const {
    return static_cast<EBoxSizing>(box_data_->box_sizing_);
  }
  void SetBoxSizing(EBoxSizing v) {
    if (!(box_data_->box_sizing_ == static_cast<unsigned>(v)))
      box_data_.Access()->box_sizing_ = static_cast<unsigned>(v);
  }
  inline void ResetBoxSizing() {
    box_data_.Access()->box_sizing_ = static_cast<unsigned>(EBoxSizing::kContentBox);
  }

  // break-after
  inline static EBreakBetween InitialBreakAfter() {
    return EBreakBetween::kAuto;
  }
  EBreakBetween BreakAfter() const {
    return static_cast<EBreakBetween>(break_after_);
  }
  void SetBreakAfter(EBreakBetween v) {
    break_after_ = static_cast<unsigned>(v);
  }
  inline void ResetBreakAfter() {
    break_after_ = static_cast<unsigned>(EBreakBetween::kAuto);
  }

  // break-before
  inline static EBreakBetween InitialBreakBefore() {
    return EBreakBetween::kAuto;
  }
  EBreakBetween BreakBefore() const {
    return static_cast<EBreakBetween>(break_before_);
  }
  void SetBreakBefore(EBreakBetween v) {
    break_before_ = static_cast<unsigned>(v);
  }
  inline void ResetBreakBefore() {
    break_before_ = static_cast<unsigned>(EBreakBetween::kAuto);
  }

  // break-inside
  inline static EBreakInside InitialBreakInside() {
    return EBreakInside::kAuto;
  }
  EBreakInside BreakInside() const {
    return static_cast<EBreakInside>(break_inside_);
  }
  void SetBreakInside(EBreakInside v) {
    break_inside_ = static_cast<unsigned>(v);
  }
  inline void ResetBreakInside() {
    break_inside_ = static_cast<unsigned>(EBreakInside::kAuto);
  }

  // CallbackSelectors
  inline static Vector<String> InitialCallbackSelectors() {
    return Vector<String>();
  }
  // Getters and setters not generated

  // caption-side
  inline static ECaptionSide InitialCaptionSide() {
    return ECaptionSide::kTop;
  }
  ECaptionSide CaptionSide() const {
    return static_cast<ECaptionSide>(caption_side_);
  }
  void SetCaptionSide(ECaptionSide v) {
    caption_side_ = static_cast<unsigned>(v);
  }
  inline void ResetCaptionSide() {
    caption_side_ = static_cast<unsigned>(ECaptionSide::kTop);
  }

  // caption-side
  inline static bool InitialCaptionSideIsInherited() {
    return true;
  }
  bool CaptionSideIsInherited() const {
    return static_cast<bool>(caption_side_is_inherited_);
  }
  void SetCaptionSideIsInherited(bool v) {
    caption_side_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetCaptionSideIsInherited() {
    caption_side_is_inherited_ = static_cast<unsigned>(true);
  }

  // caret-color
  inline static Color InitialCaretColor() {
    return Color();
  }
  // Getters and setters not generated

  // CaretColorIsAuto
  inline static bool InitialCaretColorIsAuto() {
    return true;
  }
  // Getters and setters not generated

  // CaretColorIsCurrentColor
  inline static bool InitialCaretColorIsCurrentColor() {
    return false;
  }
  // Getters and setters not generated

  // clear
  inline static EClear InitialClear() {
    return EClear::kNone;
  }
  EClear Clear() const {
    return static_cast<EClear>(clear_);
  }
  void SetClear(EClear v) {
    clear_ = static_cast<unsigned>(v);
  }
  inline void ResetClear() {
    clear_ = static_cast<unsigned>(EClear::kNone);
  }

  // clip
  inline static LengthBox InitialClip() {
    return LengthBox();
  }
  // Getters and setters not generated

  // clip-path
  static ClipPathOperation* InitialClipPath() {
    return nullptr;
  }
  ClipPathOperation* ClipPath() const {
    return rare_non_inherited_data_->clip_path_.Get();
  }
  
  void SetClipPath(RefPtr<ClipPathOperation> v) {
    rare_non_inherited_data_.Access()->clip_path_ = std::move(v);
  }

  // color
  inline static Color InitialColor() {
    return Color::kBlack;
  }
  // Getters and setters not generated

  // ColumnAutoCount
  inline static bool InitialColumnAutoCount() {
    return true;
  }
  // Getters and setters not generated

  // ColumnAutoWidth
  inline static bool InitialColumnAutoWidth() {
    return true;
  }
  // Getters and setters not generated

  // column-count
  inline static unsigned short InitialColumnCount() {
    return 1;
  }
  // Getters and setters not generated

  // column-fill
  inline static EColumnFill InitialColumnFill() {
    return EColumnFill::kBalance;
  }
  EColumnFill GetColumnFill() const {
    return static_cast<EColumnFill>(rare_non_inherited_data_->multi_col_data_->column_fill_);
  }
  void SetColumnFill(EColumnFill v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_fill_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_fill_ = static_cast<unsigned>(v);
  }
  inline void ResetColumnFill() {
    rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_fill_ = static_cast<unsigned>(EColumnFill::kBalance);
  }

  // column-gap
  inline static float InitialColumnGap() {
    return 0.0f;
  }
  // Getters and setters not generated

  // ColumnNormalGap
  inline static bool InitialColumnNormalGap() {
    return true;
  }
  // Getters and setters not generated

  // column-rule-color
  inline static Color InitialColumnRuleColor() {
    return 0;
  }
  // Getters and setters not generated

  // ColumnRuleColorIsCurrentColor
  inline static bool InitialColumnRuleColorIsCurrentColor() {
    return true;
  }
  bool ColumnRuleColorIsCurrentColor() const {
    return static_cast<bool>(rare_non_inherited_data_->multi_col_data_->column_rule_color_is_current_color_);
  }
  void SetColumnRuleColorIsCurrentColor(bool v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_rule_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_color_is_current_color_ = static_cast<unsigned>(v);
  }
  inline void ResetColumnRuleColorIsCurrentColor() {
    rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_color_is_current_color_ = static_cast<unsigned>(true);
  }

  // column-rule-style
  inline static EBorderStyle InitialColumnRuleStyle() {
    return EBorderStyle::kNone;
  }
  EBorderStyle ColumnRuleStyle() const {
    return static_cast<EBorderStyle>(rare_non_inherited_data_->multi_col_data_->column_rule_style_);
  }
  void SetColumnRuleStyle(EBorderStyle v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_rule_style_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_style_ = static_cast<unsigned>(v);
  }
  inline void ResetColumnRuleStyle() {
    rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_style_ = static_cast<unsigned>(EBorderStyle::kNone);
  }

  // column-rule-width
  inline static LayoutUnit InitialColumnRuleWidth() {
    return LayoutUnit(3);
  }
  // Getters and setters not generated

  // column-span
  inline static EColumnSpan InitialColumnSpan() {
    return EColumnSpan::kNone;
  }
  EColumnSpan GetColumnSpan() const {
    return static_cast<EColumnSpan>(rare_non_inherited_data_->multi_col_data_->column_span_);
  }
  void SetColumnSpan(EColumnSpan v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_span_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_span_ = static_cast<unsigned>(v);
  }
  inline void ResetColumnSpan() {
    rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_span_ = static_cast<unsigned>(EColumnSpan::kNone);
  }

  // column-width
  inline static float InitialColumnWidth() {
    return 0.0f;
  }
  // Getters and setters not generated

  // contain
  inline static Containment InitialContain() {
    return kContainsNone;
  }
  // Getters and setters not generated

  // content
  inline static Persistent<ContentData> InitialContent() {
    return nullptr;
  }
  // Getters and setters not generated

  // CounterDirectives
  inline static std::unique_ptr<CounterDirectiveMap> InitialCounterDirectives() {
    return nullptr;
  }
  // Getters and setters not generated

  // cursor
  inline static ECursor InitialCursor() {
    return ECursor::kAuto;
  }
  ECursor Cursor() const {
    return static_cast<ECursor>(cursor_);
  }
  void SetCursor(ECursor v) {
    cursor_ = static_cast<unsigned>(v);
  }
  inline void ResetCursor() {
    cursor_ = static_cast<unsigned>(ECursor::kAuto);
  }

  // CursorData
  inline static Persistent<CursorList> InitialCursorData() {
    return nullptr;
  }
  // Getters and setters not generated

  // direction
  inline static TextDirection InitialDirection() {
    return TextDirection::kLtr;
  }
  TextDirection Direction() const {
    return static_cast<TextDirection>(direction_);
  }
  void SetDirection(TextDirection v) {
    direction_ = static_cast<unsigned>(v);
  }
  inline void ResetDirection() {
    direction_ = static_cast<unsigned>(TextDirection::kLtr);
  }

  // display
  inline static EDisplay InitialDisplay() {
    return EDisplay::kInline;
  }
  EDisplay Display() const {
    return static_cast<EDisplay>(display_);
  }
  void SetDisplay(EDisplay v) {
    display_ = static_cast<unsigned>(v);
  }
  inline void ResetDisplay() {
    display_ = static_cast<unsigned>(EDisplay::kInline);
  }

  // -webkit-app-region
  inline static EDraggableRegionMode InitialDraggableRegionMode() {
    return EDraggableRegionMode::kNone;
  }
  EDraggableRegionMode DraggableRegionMode() const {
    return static_cast<EDraggableRegionMode>(rare_non_inherited_data_->draggable_region_mode_);
  }
  void SetDraggableRegionMode(EDraggableRegionMode v) {
    if (!(rare_non_inherited_data_->draggable_region_mode_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->draggable_region_mode_ = static_cast<unsigned>(v);
  }
  inline void ResetDraggableRegionMode() {
    rare_non_inherited_data_.Access()->draggable_region_mode_ = static_cast<unsigned>(EDraggableRegionMode::kNone);
  }

  // EffectiveZoom
  inline static float InitialEffectiveZoom() {
    return 1.0f;
  }
  // Getters and setters not generated

  // empty-cells
  inline static EEmptyCells InitialEmptyCells() {
    return EEmptyCells::kShow;
  }
  EEmptyCells EmptyCells() const {
    return static_cast<EEmptyCells>(empty_cells_);
  }
  void SetEmptyCells(EEmptyCells v) {
    empty_cells_ = static_cast<unsigned>(v);
  }
  inline void ResetEmptyCells() {
    empty_cells_ = static_cast<unsigned>(EEmptyCells::kShow);
  }

  // empty-cells
  inline static bool InitialEmptyCellsIsInherited() {
    return true;
  }
  bool EmptyCellsIsInherited() const {
    return static_cast<bool>(empty_cells_is_inherited_);
  }
  void SetEmptyCellsIsInherited(bool v) {
    empty_cells_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetEmptyCellsIsInherited() {
    empty_cells_is_inherited_ = static_cast<unsigned>(true);
  }

  // EmptyState
  inline static bool InitialEmptyState() {
    return false;
  }
  // Getters and setters not generated

  // filter
  inline static Persistent<StyleFilterData> InitialFilter() {
    return StyleFilterData::Create();
  }
  // Getters and setters not generated

  // flex-basis
  inline static Length InitialFlexBasis() {
    return Length(kAuto);
  }
  const Length& FlexBasis() const {
    return rare_non_inherited_data_->flexible_box_data_->flex_basis_;
  }
  void SetFlexBasis(const Length& v) {
    if (!(rare_non_inherited_data_->flexible_box_data_->flex_basis_ == v))
      rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_basis_ = v;
  }
  void SetFlexBasis(Length&& v) {
    if (!(rare_non_inherited_data_->flexible_box_data_->flex_basis_ == v))
      rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_basis_ = std::move(v);
  }
  inline void ResetFlexBasis() {
    rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_basis_ = Length(kAuto);
  }

  // flex-direction
  inline static EFlexDirection InitialFlexDirection() {
    return EFlexDirection::kRow;
  }
  EFlexDirection FlexDirection() const {
    return static_cast<EFlexDirection>(rare_non_inherited_data_->flexible_box_data_->flex_direction_);
  }
  void SetFlexDirection(EFlexDirection v) {
    if (!(rare_non_inherited_data_->flexible_box_data_->flex_direction_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_direction_ = static_cast<unsigned>(v);
  }
  inline void ResetFlexDirection() {
    rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_direction_ = static_cast<unsigned>(EFlexDirection::kRow);
  }

  // flex-grow
  inline static float InitialFlexGrow() {
    return 0.0f;
  }
  float FlexGrow() const {
    return rare_non_inherited_data_->flexible_box_data_->flex_grow_;
  }
  void SetFlexGrow(float v) {
    if (!(rare_non_inherited_data_->flexible_box_data_->flex_grow_ == v))
      rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_grow_ = v;
  }
  inline void ResetFlexGrow() {
    rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_grow_ = 0.0f;
  }

  // flex-shrink
  inline static float InitialFlexShrink() {
    return 1.0f;
  }
  float FlexShrink() const {
    return rare_non_inherited_data_->flexible_box_data_->flex_shrink_;
  }
  void SetFlexShrink(float v) {
    if (!(rare_non_inherited_data_->flexible_box_data_->flex_shrink_ == v))
      rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_shrink_ = v;
  }
  inline void ResetFlexShrink() {
    rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_shrink_ = 1.0f;
  }

  // flex-wrap
  inline static EFlexWrap InitialFlexWrap() {
    return EFlexWrap::kNowrap;
  }
  EFlexWrap FlexWrap() const {
    return static_cast<EFlexWrap>(rare_non_inherited_data_->flexible_box_data_->flex_wrap_);
  }
  void SetFlexWrap(EFlexWrap v) {
    if (!(rare_non_inherited_data_->flexible_box_data_->flex_wrap_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_wrap_ = static_cast<unsigned>(v);
  }
  inline void ResetFlexWrap() {
    rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_wrap_ = static_cast<unsigned>(EFlexWrap::kNowrap);
  }

  // float
  inline static EFloat InitialFloating() {
    return EFloat::kNone;
  }
  EFloat Floating() const {
    return static_cast<EFloat>(floating_);
  }
  void SetFloating(EFloat v) {
    floating_ = static_cast<unsigned>(v);
  }
  inline void ResetFloating() {
    floating_ = static_cast<unsigned>(EFloat::kNone);
  }

  // font
  inline static Font InitialFont() {
    return Font();
  }
  // Getters and setters not generated

  // grid-auto-columns
  inline static Vector<GridTrackSize> InitialGridAutoColumns() {
    return Vector<GridTrackSize>(1, GridTrackSize(Length(kAuto)));
  }
  const Vector<GridTrackSize>& GridAutoColumns() const {
    return rare_non_inherited_data_->grid_data_->grid_auto_columns_;
  }
  void SetGridAutoColumns(const Vector<GridTrackSize>& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_columns_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_columns_ = v;
  }
  void SetGridAutoColumns(Vector<GridTrackSize>&& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_columns_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_columns_ = std::move(v);
  }
  inline void ResetGridAutoColumns() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_columns_ = Vector<GridTrackSize>(1, GridTrackSize(Length(kAuto)));
  }

  // grid-auto-flow
  inline static GridAutoFlow InitialGridAutoFlow() {
    return kAutoFlowRow;
  }
  // Getters and setters not generated

  // GridAutoRepeatColumns
  inline static Vector<GridTrackSize> InitialGridAutoRepeatColumns() {
    return Vector<GridTrackSize>();
  }
  const Vector<GridTrackSize>& GridAutoRepeatColumns() const {
    return rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_;
  }
  void SetGridAutoRepeatColumns(const Vector<GridTrackSize>& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_columns_ = v;
  }
  void SetGridAutoRepeatColumns(Vector<GridTrackSize>&& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_columns_ = std::move(v);
  }
  inline void ResetGridAutoRepeatColumns() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_columns_ = Vector<GridTrackSize>();
  }

  // GridAutoRepeatColumnsInsertionPoint
  inline static size_t InitialGridAutoRepeatColumnsInsertionPoint() {
    return 0;
  }
  size_t GridAutoRepeatColumnsInsertionPoint() const {
    return rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_insertion_point_;
  }
  void SetGridAutoRepeatColumnsInsertionPoint(size_t v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_insertion_point_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_columns_insertion_point_ = v;
  }
  inline void ResetGridAutoRepeatColumnsInsertionPoint() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_columns_insertion_point_ = 0;
  }

  // GridAutoRepeatColumnsType
  inline static AutoRepeatType InitialGridAutoRepeatColumnsType() {
    return AutoRepeatType::kNoAutoRepeat;
  }
  AutoRepeatType GridAutoRepeatColumnsType() const {
    return static_cast<AutoRepeatType>(rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_type_);
  }
  void SetGridAutoRepeatColumnsType(AutoRepeatType v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_repeat_columns_type_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_columns_type_ = static_cast<unsigned>(v);
  }
  inline void ResetGridAutoRepeatColumnsType() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_columns_type_ = static_cast<unsigned>(AutoRepeatType::kNoAutoRepeat);
  }

  // GridAutoRepeatRows
  inline static Vector<GridTrackSize> InitialGridAutoRepeatRows() {
    return Vector<GridTrackSize>();
  }
  const Vector<GridTrackSize>& GridAutoRepeatRows() const {
    return rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_;
  }
  void SetGridAutoRepeatRows(const Vector<GridTrackSize>& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_rows_ = v;
  }
  void SetGridAutoRepeatRows(Vector<GridTrackSize>&& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_rows_ = std::move(v);
  }
  inline void ResetGridAutoRepeatRows() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_rows_ = Vector<GridTrackSize>();
  }

  // GridAutoRepeatRowsInsertionPoint
  inline static size_t InitialGridAutoRepeatRowsInsertionPoint() {
    return 0;
  }
  size_t GridAutoRepeatRowsInsertionPoint() const {
    return rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_insertion_point_;
  }
  void SetGridAutoRepeatRowsInsertionPoint(size_t v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_insertion_point_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_rows_insertion_point_ = v;
  }
  inline void ResetGridAutoRepeatRowsInsertionPoint() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_rows_insertion_point_ = 0;
  }

  // GridAutoRepeatRowsType
  inline static AutoRepeatType InitialGridAutoRepeatRowsType() {
    return AutoRepeatType::kNoAutoRepeat;
  }
  AutoRepeatType GridAutoRepeatRowsType() const {
    return static_cast<AutoRepeatType>(rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_type_);
  }
  void SetGridAutoRepeatRowsType(AutoRepeatType v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_repeat_rows_type_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_rows_type_ = static_cast<unsigned>(v);
  }
  inline void ResetGridAutoRepeatRowsType() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_rows_type_ = static_cast<unsigned>(AutoRepeatType::kNoAutoRepeat);
  }

  // grid-auto-rows
  inline static Vector<GridTrackSize> InitialGridAutoRows() {
    return Vector<GridTrackSize>(1, GridTrackSize(Length(kAuto)));
  }
  const Vector<GridTrackSize>& GridAutoRows() const {
    return rare_non_inherited_data_->grid_data_->grid_auto_rows_;
  }
  void SetGridAutoRows(const Vector<GridTrackSize>& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_rows_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_rows_ = v;
  }
  void SetGridAutoRows(Vector<GridTrackSize>&& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_rows_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_rows_ = std::move(v);
  }
  inline void ResetGridAutoRows() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_rows_ = Vector<GridTrackSize>(1, GridTrackSize(Length(kAuto)));
  }

  // grid-column-end
  inline static GridPosition InitialGridColumnEnd() {
    return GridPosition();
  }
  const GridPosition& GridColumnEnd() const {
    return rare_non_inherited_data_->grid_item_data_->grid_column_end_;
  }
  void SetGridColumnEnd(const GridPosition& v) {
    if (!(rare_non_inherited_data_->grid_item_data_->grid_column_end_ == v))
      rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_column_end_ = v;
  }
  void SetGridColumnEnd(GridPosition&& v) {
    if (!(rare_non_inherited_data_->grid_item_data_->grid_column_end_ == v))
      rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_column_end_ = std::move(v);
  }
  inline void ResetGridColumnEnd() {
    rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_column_end_ = GridPosition();
  }

  // grid-column-gap
  inline static Length InitialGridColumnGap() {
    return Length(kFixed);
  }
  const Length& GridColumnGap() const {
    return rare_non_inherited_data_->grid_data_->grid_column_gap_;
  }
  void SetGridColumnGap(const Length& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_column_gap_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_column_gap_ = v;
  }
  void SetGridColumnGap(Length&& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_column_gap_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_column_gap_ = std::move(v);
  }
  inline void ResetGridColumnGap() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_column_gap_ = Length(kFixed);
  }

  // grid-column-start
  inline static GridPosition InitialGridColumnStart() {
    return GridPosition();
  }
  const GridPosition& GridColumnStart() const {
    return rare_non_inherited_data_->grid_item_data_->grid_column_start_;
  }
  void SetGridColumnStart(const GridPosition& v) {
    if (!(rare_non_inherited_data_->grid_item_data_->grid_column_start_ == v))
      rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_column_start_ = v;
  }
  void SetGridColumnStart(GridPosition&& v) {
    if (!(rare_non_inherited_data_->grid_item_data_->grid_column_start_ == v))
      rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_column_start_ = std::move(v);
  }
  inline void ResetGridColumnStart() {
    rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_column_start_ = GridPosition();
  }

  // grid-row-end
  inline static GridPosition InitialGridRowEnd() {
    return GridPosition();
  }
  const GridPosition& GridRowEnd() const {
    return rare_non_inherited_data_->grid_item_data_->grid_row_end_;
  }
  void SetGridRowEnd(const GridPosition& v) {
    if (!(rare_non_inherited_data_->grid_item_data_->grid_row_end_ == v))
      rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_row_end_ = v;
  }
  void SetGridRowEnd(GridPosition&& v) {
    if (!(rare_non_inherited_data_->grid_item_data_->grid_row_end_ == v))
      rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_row_end_ = std::move(v);
  }
  inline void ResetGridRowEnd() {
    rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_row_end_ = GridPosition();
  }

  // grid-row-gap
  inline static Length InitialGridRowGap() {
    return Length(kFixed);
  }
  const Length& GridRowGap() const {
    return rare_non_inherited_data_->grid_data_->grid_row_gap_;
  }
  void SetGridRowGap(const Length& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_row_gap_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_row_gap_ = v;
  }
  void SetGridRowGap(Length&& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_row_gap_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_row_gap_ = std::move(v);
  }
  inline void ResetGridRowGap() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_row_gap_ = Length(kFixed);
  }

  // grid-row-start
  inline static GridPosition InitialGridRowStart() {
    return GridPosition();
  }
  const GridPosition& GridRowStart() const {
    return rare_non_inherited_data_->grid_item_data_->grid_row_start_;
  }
  void SetGridRowStart(const GridPosition& v) {
    if (!(rare_non_inherited_data_->grid_item_data_->grid_row_start_ == v))
      rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_row_start_ = v;
  }
  void SetGridRowStart(GridPosition&& v) {
    if (!(rare_non_inherited_data_->grid_item_data_->grid_row_start_ == v))
      rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_row_start_ = std::move(v);
  }
  inline void ResetGridRowStart() {
    rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_row_start_ = GridPosition();
  }

  // grid-template-columns
  inline static Vector<GridTrackSize> InitialGridTemplateColumns() {
    return Vector<GridTrackSize>();
  }
  const Vector<GridTrackSize>& GridTemplateColumns() const {
    return rare_non_inherited_data_->grid_data_->grid_template_columns_;
  }
  void SetGridTemplateColumns(const Vector<GridTrackSize>& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_template_columns_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_template_columns_ = v;
  }
  void SetGridTemplateColumns(Vector<GridTrackSize>&& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_template_columns_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_template_columns_ = std::move(v);
  }
  inline void ResetGridTemplateColumns() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_template_columns_ = Vector<GridTrackSize>();
  }

  // grid-template-rows
  inline static Vector<GridTrackSize> InitialGridTemplateRows() {
    return Vector<GridTrackSize>();
  }
  const Vector<GridTrackSize>& GridTemplateRows() const {
    return rare_non_inherited_data_->grid_data_->grid_template_rows_;
  }
  void SetGridTemplateRows(const Vector<GridTrackSize>& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_template_rows_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_template_rows_ = v;
  }
  void SetGridTemplateRows(Vector<GridTrackSize>&& v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_template_rows_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_template_rows_ = std::move(v);
  }
  inline void ResetGridTemplateRows() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->grid_template_rows_ = Vector<GridTrackSize>();
  }

  // HasAuthorBackground
  inline static bool InitialHasAuthorBackground() {
    return false;
  }
  bool HasAuthorBackground() const {
    return static_cast<bool>(rare_non_inherited_data_->has_author_background_);
  }
  void SetHasAuthorBackground(bool v) {
    if (!(rare_non_inherited_data_->has_author_background_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->has_author_background_ = static_cast<unsigned>(v);
  }
  inline void ResetHasAuthorBackground() {
    rare_non_inherited_data_.Access()->has_author_background_ = static_cast<unsigned>(false);
  }

  // HasAuthorBorder
  inline static bool InitialHasAuthorBorder() {
    return false;
  }
  bool HasAuthorBorder() const {
    return static_cast<bool>(rare_non_inherited_data_->has_author_border_);
  }
  void SetHasAuthorBorder(bool v) {
    if (!(rare_non_inherited_data_->has_author_border_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->has_author_border_ = static_cast<unsigned>(v);
  }
  inline void ResetHasAuthorBorder() {
    rare_non_inherited_data_.Access()->has_author_border_ = static_cast<unsigned>(false);
  }

  // HasAutoClip
  inline static bool InitialHasAutoClip() {
    return true;
  }
  // Getters and setters not generated

  // HasAutoZIndex
  inline static bool InitialHasAutoZIndex() {
    return true;
  }
  // Getters and setters not generated

  // HasCurrentBackdropFilterAnimation
  inline static bool InitialHasCurrentBackdropFilterAnimation() {
    return false;
  }
  bool HasCurrentBackdropFilterAnimation() const {
    return static_cast<bool>(rare_non_inherited_data_->has_current_backdrop_filter_animation_);
  }
  void SetHasCurrentBackdropFilterAnimation(bool v) {
    if (!(rare_non_inherited_data_->has_current_backdrop_filter_animation_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->has_current_backdrop_filter_animation_ = static_cast<unsigned>(v);
  }
  inline void ResetHasCurrentBackdropFilterAnimation() {
    rare_non_inherited_data_.Access()->has_current_backdrop_filter_animation_ = static_cast<unsigned>(false);
  }

  // HasCurrentFilterAnimation
  inline static bool InitialHasCurrentFilterAnimation() {
    return false;
  }
  bool HasCurrentFilterAnimation() const {
    return static_cast<bool>(rare_non_inherited_data_->has_current_filter_animation_);
  }
  void SetHasCurrentFilterAnimation(bool v) {
    if (!(rare_non_inherited_data_->has_current_filter_animation_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->has_current_filter_animation_ = static_cast<unsigned>(v);
  }
  inline void ResetHasCurrentFilterAnimation() {
    rare_non_inherited_data_.Access()->has_current_filter_animation_ = static_cast<unsigned>(false);
  }

  // HasCurrentOpacityAnimation
  inline static bool InitialHasCurrentOpacityAnimation() {
    return false;
  }
  bool HasCurrentOpacityAnimation() const {
    return static_cast<bool>(rare_non_inherited_data_->has_current_opacity_animation_);
  }
  void SetHasCurrentOpacityAnimation(bool v) {
    if (!(rare_non_inherited_data_->has_current_opacity_animation_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->has_current_opacity_animation_ = static_cast<unsigned>(v);
  }
  inline void ResetHasCurrentOpacityAnimation() {
    rare_non_inherited_data_.Access()->has_current_opacity_animation_ = static_cast<unsigned>(false);
  }

  // HasCurrentTransformAnimation
  inline static bool InitialHasCurrentTransformAnimation() {
    return false;
  }
  bool HasCurrentTransformAnimation() const {
    return static_cast<bool>(rare_non_inherited_data_->has_current_transform_animation_);
  }
  void SetHasCurrentTransformAnimation(bool v) {
    if (!(rare_non_inherited_data_->has_current_transform_animation_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->has_current_transform_animation_ = static_cast<unsigned>(v);
  }
  inline void ResetHasCurrentTransformAnimation() {
    rare_non_inherited_data_.Access()->has_current_transform_animation_ = static_cast<unsigned>(false);
  }

  // HasExplicitlyInheritedProperties
  bool HasExplicitlyInheritedProperties() const {
    return static_cast<bool>(has_explicitly_inherited_properties_);
  }
  void SetHasExplicitlyInheritedProperties() const {
    has_explicitly_inherited_properties_ = static_cast<unsigned>(true);
  }

  // HasInlineTransform
  inline static bool InitialHasInlineTransform() {
    return false;
  }
  bool HasInlineTransform() const {
    return static_cast<bool>(rare_non_inherited_data_->has_inline_transform_);
  }
  void SetHasInlineTransform(bool v) {
    if (!(rare_non_inherited_data_->has_inline_transform_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->has_inline_transform_ = static_cast<unsigned>(v);
  }
  inline void ResetHasInlineTransform() {
    rare_non_inherited_data_.Access()->has_inline_transform_ = static_cast<unsigned>(false);
  }

  // HasRemUnits
  bool HasRemUnits() const {
    return static_cast<bool>(has_rem_units_);
  }
  void SetHasRemUnits() {
    has_rem_units_ = static_cast<unsigned>(true);
  }

  // HasSimpleUnderline
  inline static bool InitialHasSimpleUnderline() {
    return false;
  }
  // Getters and setters not generated

  // HasVariableReferenceFromNonInheritedProperty
  bool HasVariableReferenceFromNonInheritedProperty() const {
    return static_cast<bool>(has_variable_reference_from_non_inherited_property_);
  }
  void SetHasVariableReferenceFromNonInheritedProperty() {
    has_variable_reference_from_non_inherited_property_ = static_cast<unsigned>(true);
  }

  // HasViewportUnits
  inline static bool InitialHasViewportUnits() {
    return false;
  }
  bool HasViewportUnits() const {
    return static_cast<bool>(has_viewport_units_);
  }
  void SetHasViewportUnits(bool v) {
    has_viewport_units_ = static_cast<unsigned>(v);
  }
  inline void ResetHasViewportUnits() {
    has_viewport_units_ = static_cast<unsigned>(false);
  }

  // height
  inline static Length InitialHeight() {
    return Length();
  }
  const Length& Height() const {
    return box_data_->height_;
  }
  void SetHeight(const Length& v) {
    if (!(box_data_->height_ == v))
      box_data_.Access()->height_ = v;
  }
  void SetHeight(Length&& v) {
    if (!(box_data_->height_ == v))
      box_data_.Access()->height_ = std::move(v);
  }
  inline void ResetHeight() {
    box_data_.Access()->height_ = Length();
  }

  // -webkit-highlight
  inline static AtomicString InitialHighlight() {
    return g_null_atom;
  }
  const AtomicString& Highlight() const {
    return rare_inherited_data_->highlight_;
  }
  void SetHighlight(const AtomicString& v) {
    if (!(rare_inherited_data_->highlight_ == v))
      rare_inherited_data_.Access()->highlight_ = v;
  }
  void SetHighlight(AtomicString&& v) {
    if (!(rare_inherited_data_->highlight_ == v))
      rare_inherited_data_.Access()->highlight_ = std::move(v);
  }
  inline void ResetHighlight() {
    rare_inherited_data_.Access()->highlight_ = g_null_atom;
  }

  // -webkit-border-horizontal-spacing
  inline static short InitialHorizontalBorderSpacing() {
    return 0;
  }
  short HorizontalBorderSpacing() const {
    return inherited_data_->horizontal_border_spacing_;
  }
  void SetHorizontalBorderSpacing(short v) {
    if (!(inherited_data_->horizontal_border_spacing_ == v))
      inherited_data_.Access()->horizontal_border_spacing_ = v;
  }
  inline void ResetHorizontalBorderSpacing() {
    inherited_data_.Access()->horizontal_border_spacing_ = 0;
  }

  // HyphenationLimitAfter
  inline static short InitialHyphenationLimitAfter() {
    return -1;
  }
  // Getters and setters not generated

  // HyphenationLimitBefore
  inline static short InitialHyphenationLimitBefore() {
    return -1;
  }
  // Getters and setters not generated

  // HyphenationLimitLines
  inline static short InitialHyphenationLimitLines() {
    return -1;
  }
  // Getters and setters not generated

  // -webkit-hyphenate-character
  inline static AtomicString InitialHyphenationString() {
    return AtomicString();
  }
  const AtomicString& HyphenationString() const {
    return rare_inherited_data_->hyphenation_string_;
  }
  void SetHyphenationString(const AtomicString& v) {
    if (!(rare_inherited_data_->hyphenation_string_ == v))
      rare_inherited_data_.Access()->hyphenation_string_ = v;
  }
  void SetHyphenationString(AtomicString&& v) {
    if (!(rare_inherited_data_->hyphenation_string_ == v))
      rare_inherited_data_.Access()->hyphenation_string_ = std::move(v);
  }
  inline void ResetHyphenationString() {
    rare_inherited_data_.Access()->hyphenation_string_ = AtomicString();
  }

  // hyphens
  inline static Hyphens InitialHyphens() {
    return Hyphens::kManual;
  }
  Hyphens GetHyphens() const {
    return static_cast<Hyphens>(rare_inherited_data_->hyphens_);
  }
  void SetHyphens(Hyphens v) {
    if (!(rare_inherited_data_->hyphens_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->hyphens_ = static_cast<unsigned>(v);
  }
  inline void ResetHyphens() {
    rare_inherited_data_.Access()->hyphens_ = static_cast<unsigned>(Hyphens::kManual);
  }

  // image-rendering
  inline static EImageRendering InitialImageRendering() {
    return EImageRendering::kAuto;
  }
  EImageRendering ImageRendering() const {
    return static_cast<EImageRendering>(rare_inherited_data_->image_rendering_);
  }
  void SetImageRendering(EImageRendering v) {
    if (!(rare_inherited_data_->image_rendering_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->image_rendering_ = static_cast<unsigned>(v);
  }
  inline void ResetImageRendering() {
    rare_inherited_data_.Access()->image_rendering_ = static_cast<unsigned>(EImageRendering::kAuto);
  }

  // InheritedVariables
  inline static RefPtr<StyleInheritedVariables> InitialInheritedVariables() {
    return nullptr;
  }
  // Getters and setters not generated

  // InsideLink
  inline static EInsideLink InitialInsideLink() {
    return EInsideLink::kNotInsideLink;
  }
  EInsideLink InsideLink() const {
    return static_cast<EInsideLink>(inside_link_);
  }
  void SetInsideLink(EInsideLink v) {
    inside_link_ = static_cast<unsigned>(v);
  }
  inline void ResetInsideLink() {
    inside_link_ = static_cast<unsigned>(EInsideLink::kNotInsideLink);
  }

  // IsLink
  bool IsLink() const {
    return static_cast<bool>(is_link_);
  }
  void SetIsLink() {
    is_link_ = static_cast<unsigned>(true);
  }

  // IsRunningBackdropFilterAnimationOnCompositor
  inline static bool InitialIsRunningBackdropFilterAnimationOnCompositor() {
    return false;
  }
  bool IsRunningBackdropFilterAnimationOnCompositor() const {
    return static_cast<bool>(rare_non_inherited_data_->is_running_backdrop_filter_animation_on_compositor_);
  }
  void SetIsRunningBackdropFilterAnimationOnCompositor(bool v) {
    if (!(rare_non_inherited_data_->is_running_backdrop_filter_animation_on_compositor_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->is_running_backdrop_filter_animation_on_compositor_ = static_cast<unsigned>(v);
  }
  inline void ResetIsRunningBackdropFilterAnimationOnCompositor() {
    rare_non_inherited_data_.Access()->is_running_backdrop_filter_animation_on_compositor_ = static_cast<unsigned>(false);
  }

  // IsRunningFilterAnimationOnCompositor
  inline static bool InitialIsRunningFilterAnimationOnCompositor() {
    return false;
  }
  bool IsRunningFilterAnimationOnCompositor() const {
    return static_cast<bool>(rare_non_inherited_data_->is_running_filter_animation_on_compositor_);
  }
  void SetIsRunningFilterAnimationOnCompositor(bool v) {
    if (!(rare_non_inherited_data_->is_running_filter_animation_on_compositor_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->is_running_filter_animation_on_compositor_ = static_cast<unsigned>(v);
  }
  inline void ResetIsRunningFilterAnimationOnCompositor() {
    rare_non_inherited_data_.Access()->is_running_filter_animation_on_compositor_ = static_cast<unsigned>(false);
  }

  // IsRunningOpacityAnimationOnCompositor
  inline static bool InitialIsRunningOpacityAnimationOnCompositor() {
    return false;
  }
  bool IsRunningOpacityAnimationOnCompositor() const {
    return static_cast<bool>(rare_non_inherited_data_->is_running_opacity_animation_on_compositor_);
  }
  void SetIsRunningOpacityAnimationOnCompositor(bool v) {
    if (!(rare_non_inherited_data_->is_running_opacity_animation_on_compositor_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->is_running_opacity_animation_on_compositor_ = static_cast<unsigned>(v);
  }
  inline void ResetIsRunningOpacityAnimationOnCompositor() {
    rare_non_inherited_data_.Access()->is_running_opacity_animation_on_compositor_ = static_cast<unsigned>(false);
  }

  // IsRunningTransformAnimationOnCompositor
  inline static bool InitialIsRunningTransformAnimationOnCompositor() {
    return false;
  }
  bool IsRunningTransformAnimationOnCompositor() const {
    return static_cast<bool>(rare_non_inherited_data_->is_running_transform_animation_on_compositor_);
  }
  void SetIsRunningTransformAnimationOnCompositor(bool v) {
    if (!(rare_non_inherited_data_->is_running_transform_animation_on_compositor_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->is_running_transform_animation_on_compositor_ = static_cast<unsigned>(v);
  }
  inline void ResetIsRunningTransformAnimationOnCompositor() {
    rare_non_inherited_data_.Access()->is_running_transform_animation_on_compositor_ = static_cast<unsigned>(false);
  }

  // IsStackingContext
  inline static bool InitialIsStackingContext() {
    return false;
  }
  bool IsStackingContext() const {
    return static_cast<bool>(rare_non_inherited_data_->is_stacking_context_);
  }
  void SetIsStackingContext(bool v) {
    if (!(rare_non_inherited_data_->is_stacking_context_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->is_stacking_context_ = static_cast<unsigned>(v);
  }
  inline void ResetIsStackingContext() {
    rare_non_inherited_data_.Access()->is_stacking_context_ = static_cast<unsigned>(false);
  }

  // isolation
  inline static EIsolation InitialIsolation() {
    return EIsolation::kAuto;
  }
  EIsolation Isolation() const {
    return static_cast<EIsolation>(rare_non_inherited_data_->isolation_);
  }
  void SetIsolation(EIsolation v) {
    if (!(rare_non_inherited_data_->isolation_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->isolation_ = static_cast<unsigned>(v);
  }
  inline void ResetIsolation() {
    rare_non_inherited_data_.Access()->isolation_ = static_cast<unsigned>(EIsolation::kAuto);
  }

  // justify-content
  inline static StyleContentAlignmentData InitialJustifyContent() {
    return StyleContentAlignmentData(kContentPositionNormal, kContentDistributionDefault, kOverflowAlignmentDefault);
  }
  const StyleContentAlignmentData& JustifyContent() const {
    return rare_non_inherited_data_->justify_content_;
  }
  void SetJustifyContent(const StyleContentAlignmentData& v) {
    if (!(rare_non_inherited_data_->justify_content_ == v))
      rare_non_inherited_data_.Access()->justify_content_ = v;
  }
  void SetJustifyContent(StyleContentAlignmentData&& v) {
    if (!(rare_non_inherited_data_->justify_content_ == v))
      rare_non_inherited_data_.Access()->justify_content_ = std::move(v);
  }
  inline void ResetJustifyContent() {
    rare_non_inherited_data_.Access()->justify_content_ = StyleContentAlignmentData(kContentPositionNormal, kContentDistributionDefault, kOverflowAlignmentDefault);
  }

  // justify-items
  inline static StyleSelfAlignmentData InitialJustifyItems() {
    return StyleSelfAlignmentData(kItemPositionAuto, kOverflowAlignmentDefault);
  }
  const StyleSelfAlignmentData& JustifyItems() const {
    return rare_non_inherited_data_->justify_items_;
  }
  void SetJustifyItems(const StyleSelfAlignmentData& v) {
    if (!(rare_non_inherited_data_->justify_items_ == v))
      rare_non_inherited_data_.Access()->justify_items_ = v;
  }
  void SetJustifyItems(StyleSelfAlignmentData&& v) {
    if (!(rare_non_inherited_data_->justify_items_ == v))
      rare_non_inherited_data_.Access()->justify_items_ = std::move(v);
  }
  inline void ResetJustifyItems() {
    rare_non_inherited_data_.Access()->justify_items_ = StyleSelfAlignmentData(kItemPositionAuto, kOverflowAlignmentDefault);
  }

  // justify-self
  inline static StyleSelfAlignmentData InitialJustifySelf() {
    return StyleSelfAlignmentData(kItemPositionAuto, kOverflowAlignmentDefault);
  }
  const StyleSelfAlignmentData& JustifySelf() const {
    return rare_non_inherited_data_->justify_self_;
  }
  void SetJustifySelf(const StyleSelfAlignmentData& v) {
    if (!(rare_non_inherited_data_->justify_self_ == v))
      rare_non_inherited_data_.Access()->justify_self_ = v;
  }
  void SetJustifySelf(StyleSelfAlignmentData&& v) {
    if (!(rare_non_inherited_data_->justify_self_ == v))
      rare_non_inherited_data_.Access()->justify_self_ = std::move(v);
  }
  inline void ResetJustifySelf() {
    rare_non_inherited_data_.Access()->justify_self_ = StyleSelfAlignmentData(kItemPositionAuto, kOverflowAlignmentDefault);
  }

  // left
  inline static Length InitialLeft() {
    return Length();
  }
  const Length& Left() const {
    return surround_data_->left_;
  }
  void SetLeft(const Length& v) {
    if (!(surround_data_->left_ == v))
      surround_data_.Access()->left_ = v;
  }
  void SetLeft(Length&& v) {
    if (!(surround_data_->left_ == v))
      surround_data_.Access()->left_ = std::move(v);
  }
  inline void ResetLeft() {
    surround_data_.Access()->left_ = Length();
  }

  // -webkit-line-break
  inline static LineBreak InitialLineBreak() {
    return LineBreak::kAuto;
  }
  LineBreak GetLineBreak() const {
    return static_cast<LineBreak>(rare_inherited_data_->line_break_);
  }
  void SetLineBreak(LineBreak v) {
    if (!(rare_inherited_data_->line_break_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->line_break_ = static_cast<unsigned>(v);
  }
  inline void ResetLineBreak() {
    rare_inherited_data_.Access()->line_break_ = static_cast<unsigned>(LineBreak::kAuto);
  }

  // -webkit-line-clamp
  inline static LineClampValue InitialLineClamp() {
    return LineClampValue();
  }
  // Getters and setters not generated

  // line-height
  inline static Length InitialLineHeight() {
    return Length(-100.0, kPercent);
  }
  // Getters and setters not generated

  // line-height-step
  inline static uint8_t InitialLineHeightStep() {
    return 0;
  }
  uint8_t LineHeightStep() const {
    return rare_inherited_data_->line_height_step_;
  }
  void SetLineHeightStep(uint8_t v) {
    if (!(rare_inherited_data_->line_height_step_ == v))
      rare_inherited_data_.Access()->line_height_step_ = v;
  }
  inline void ResetLineHeightStep() {
    rare_inherited_data_.Access()->line_height_step_ = 0;
  }

  // list-style-image
  inline static Persistent<StyleImage> InitialListStyleImage() {
    return nullptr;
  }
  // Getters and setters not generated

  // list-style-position
  inline static EListStylePosition InitialListStylePosition() {
    return EListStylePosition::kOutside;
  }
  EListStylePosition ListStylePosition() const {
    return static_cast<EListStylePosition>(list_style_position_);
  }
  void SetListStylePosition(EListStylePosition v) {
    list_style_position_ = static_cast<unsigned>(v);
  }
  inline void ResetListStylePosition() {
    list_style_position_ = static_cast<unsigned>(EListStylePosition::kOutside);
  }

  // list-style-position
  inline static bool InitialListStylePositionIsInherited() {
    return true;
  }
  bool ListStylePositionIsInherited() const {
    return static_cast<bool>(list_style_position_is_inherited_);
  }
  void SetListStylePositionIsInherited(bool v) {
    list_style_position_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetListStylePositionIsInherited() {
    list_style_position_is_inherited_ = static_cast<unsigned>(true);
  }

  // list-style-type
  inline static EListStyleType InitialListStyleType() {
    return EListStyleType::kDisc;
  }
  EListStyleType ListStyleType() const {
    return static_cast<EListStyleType>(list_style_type_);
  }
  void SetListStyleType(EListStyleType v) {
    list_style_type_ = static_cast<unsigned>(v);
  }
  inline void ResetListStyleType() {
    list_style_type_ = static_cast<unsigned>(EListStyleType::kDisc);
  }

  // -webkit-margin-after-collapse
  inline static EMarginCollapse InitialMarginAfterCollapse() {
    return EMarginCollapse::kCollapse;
  }
  EMarginCollapse MarginAfterCollapse() const {
    return static_cast<EMarginCollapse>(rare_non_inherited_data_->margin_after_collapse_);
  }
  void SetMarginAfterCollapse(EMarginCollapse v) {
    if (!(rare_non_inherited_data_->margin_after_collapse_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->margin_after_collapse_ = static_cast<unsigned>(v);
  }
  inline void ResetMarginAfterCollapse() {
    rare_non_inherited_data_.Access()->margin_after_collapse_ = static_cast<unsigned>(EMarginCollapse::kCollapse);
  }

  // -webkit-margin-before-collapse
  inline static EMarginCollapse InitialMarginBeforeCollapse() {
    return EMarginCollapse::kCollapse;
  }
  EMarginCollapse MarginBeforeCollapse() const {
    return static_cast<EMarginCollapse>(rare_non_inherited_data_->margin_before_collapse_);
  }
  void SetMarginBeforeCollapse(EMarginCollapse v) {
    if (!(rare_non_inherited_data_->margin_before_collapse_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->margin_before_collapse_ = static_cast<unsigned>(v);
  }
  inline void ResetMarginBeforeCollapse() {
    rare_non_inherited_data_.Access()->margin_before_collapse_ = static_cast<unsigned>(EMarginCollapse::kCollapse);
  }

  // margin-bottom
  inline static Length InitialMarginBottom() {
    return Length(kFixed);
  }
  const Length& MarginBottom() const {
    return surround_data_->margin_bottom_;
  }
  void SetMarginBottom(const Length& v) {
    if (!(surround_data_->margin_bottom_ == v))
      surround_data_.Access()->margin_bottom_ = v;
  }
  void SetMarginBottom(Length&& v) {
    if (!(surround_data_->margin_bottom_ == v))
      surround_data_.Access()->margin_bottom_ = std::move(v);
  }
  inline void ResetMarginBottom() {
    surround_data_.Access()->margin_bottom_ = Length(kFixed);
  }

  // margin-left
  inline static Length InitialMarginLeft() {
    return Length(kFixed);
  }
  const Length& MarginLeft() const {
    return surround_data_->margin_left_;
  }
  void SetMarginLeft(const Length& v) {
    if (!(surround_data_->margin_left_ == v))
      surround_data_.Access()->margin_left_ = v;
  }
  void SetMarginLeft(Length&& v) {
    if (!(surround_data_->margin_left_ == v))
      surround_data_.Access()->margin_left_ = std::move(v);
  }
  inline void ResetMarginLeft() {
    surround_data_.Access()->margin_left_ = Length(kFixed);
  }

  // margin-right
  inline static Length InitialMarginRight() {
    return Length(kFixed);
  }
  const Length& MarginRight() const {
    return surround_data_->margin_right_;
  }
  void SetMarginRight(const Length& v) {
    if (!(surround_data_->margin_right_ == v))
      surround_data_.Access()->margin_right_ = v;
  }
  void SetMarginRight(Length&& v) {
    if (!(surround_data_->margin_right_ == v))
      surround_data_.Access()->margin_right_ = std::move(v);
  }
  inline void ResetMarginRight() {
    surround_data_.Access()->margin_right_ = Length(kFixed);
  }

  // margin-top
  inline static Length InitialMarginTop() {
    return Length(kFixed);
  }
  const Length& MarginTop() const {
    return surround_data_->margin_top_;
  }
  void SetMarginTop(const Length& v) {
    if (!(surround_data_->margin_top_ == v))
      surround_data_.Access()->margin_top_ = v;
  }
  void SetMarginTop(Length&& v) {
    if (!(surround_data_->margin_top_ == v))
      surround_data_.Access()->margin_top_ = std::move(v);
  }
  inline void ResetMarginTop() {
    surround_data_.Access()->margin_top_ = Length(kFixed);
  }

  // Mask
  inline static FillLayer InitialMask() {
    return FillLayer(kMaskFillLayer, true);
  }
  // Getters and setters not generated

  // MaskBoxImage
  inline static NinePieceImage InitialMaskBoxImage() {
    return NinePieceImage::MaskDefaults();
  }
  // Getters and setters not generated

  // max-height
  inline static Length InitialMaxHeight() {
    return Length(kMaxSizeNone);
  }
  const Length& MaxHeight() const {
    return box_data_->max_height_;
  }
  void SetMaxHeight(const Length& v) {
    if (!(box_data_->max_height_ == v))
      box_data_.Access()->max_height_ = v;
  }
  void SetMaxHeight(Length&& v) {
    if (!(box_data_->max_height_ == v))
      box_data_.Access()->max_height_ = std::move(v);
  }
  inline void ResetMaxHeight() {
    box_data_.Access()->max_height_ = Length(kMaxSizeNone);
  }

  // max-width
  inline static Length InitialMaxWidth() {
    return Length(kMaxSizeNone);
  }
  const Length& MaxWidth() const {
    return box_data_->max_width_;
  }
  void SetMaxWidth(const Length& v) {
    if (!(box_data_->max_width_ == v))
      box_data_.Access()->max_width_ = v;
  }
  void SetMaxWidth(Length&& v) {
    if (!(box_data_->max_width_ == v))
      box_data_.Access()->max_width_ = std::move(v);
  }
  inline void ResetMaxWidth() {
    box_data_.Access()->max_width_ = Length(kMaxSizeNone);
  }

  // min-height
  inline static Length InitialMinHeight() {
    return Length();
  }
  const Length& MinHeight() const {
    return box_data_->min_height_;
  }
  void SetMinHeight(const Length& v) {
    if (!(box_data_->min_height_ == v))
      box_data_.Access()->min_height_ = v;
  }
  void SetMinHeight(Length&& v) {
    if (!(box_data_->min_height_ == v))
      box_data_.Access()->min_height_ = std::move(v);
  }
  inline void ResetMinHeight() {
    box_data_.Access()->min_height_ = Length();
  }

  // min-width
  inline static Length InitialMinWidth() {
    return Length();
  }
  const Length& MinWidth() const {
    return box_data_->min_width_;
  }
  void SetMinWidth(const Length& v) {
    if (!(box_data_->min_width_ == v))
      box_data_.Access()->min_width_ = v;
  }
  void SetMinWidth(Length&& v) {
    if (!(box_data_->min_width_ == v))
      box_data_.Access()->min_width_ = std::move(v);
  }
  inline void ResetMinWidth() {
    box_data_.Access()->min_width_ = Length();
  }

  // NamedGridArea
  inline static NamedGridAreaMap InitialNamedGridArea() {
    return NamedGridAreaMap();
  }
  const NamedGridAreaMap& NamedGridArea() const {
    return rare_non_inherited_data_->grid_data_->named_grid_area_;
  }
  void SetNamedGridArea(const NamedGridAreaMap& v) {
    if (!(rare_non_inherited_data_->grid_data_->named_grid_area_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_area_ = v;
  }
  void SetNamedGridArea(NamedGridAreaMap&& v) {
    if (!(rare_non_inherited_data_->grid_data_->named_grid_area_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_area_ = std::move(v);
  }
  inline void ResetNamedGridArea() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_area_ = NamedGridAreaMap();
  }

  // NamedGridAreaColumnCount
  inline static size_t InitialNamedGridAreaColumnCount() {
    return 0;
  }
  size_t NamedGridAreaColumnCount() const {
    return rare_non_inherited_data_->grid_data_->named_grid_area_column_count_;
  }
  void SetNamedGridAreaColumnCount(size_t v) {
    if (!(rare_non_inherited_data_->grid_data_->named_grid_area_column_count_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_area_column_count_ = v;
  }
  inline void ResetNamedGridAreaColumnCount() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_area_column_count_ = 0;
  }

  // NamedGridAreaRowCount
  inline static size_t InitialNamedGridAreaRowCount() {
    return 0;
  }
  size_t NamedGridAreaRowCount() const {
    return rare_non_inherited_data_->grid_data_->named_grid_area_row_count_;
  }
  void SetNamedGridAreaRowCount(size_t v) {
    if (!(rare_non_inherited_data_->grid_data_->named_grid_area_row_count_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_area_row_count_ = v;
  }
  inline void ResetNamedGridAreaRowCount() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_area_row_count_ = 0;
  }

  // NamedGridColumnLines
  inline static NamedGridLinesMap InitialNamedGridColumnLines() {
    return NamedGridLinesMap();
  }
  const NamedGridLinesMap& NamedGridColumnLines() const {
    return rare_non_inherited_data_->grid_data_->named_grid_column_lines_;
  }
  void SetNamedGridColumnLines(const NamedGridLinesMap& v) {
    if (!(rare_non_inherited_data_->grid_data_->named_grid_column_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_column_lines_ = v;
  }
  void SetNamedGridColumnLines(NamedGridLinesMap&& v) {
    if (!(rare_non_inherited_data_->grid_data_->named_grid_column_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_column_lines_ = std::move(v);
  }
  inline void ResetNamedGridColumnLines() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_column_lines_ = NamedGridLinesMap();
  }

  // NamedGridRowLines
  inline static NamedGridLinesMap InitialNamedGridRowLines() {
    return NamedGridLinesMap();
  }
  const NamedGridLinesMap& NamedGridRowLines() const {
    return rare_non_inherited_data_->grid_data_->named_grid_row_lines_;
  }
  void SetNamedGridRowLines(const NamedGridLinesMap& v) {
    if (!(rare_non_inherited_data_->grid_data_->named_grid_row_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_row_lines_ = v;
  }
  void SetNamedGridRowLines(NamedGridLinesMap&& v) {
    if (!(rare_non_inherited_data_->grid_data_->named_grid_row_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_row_lines_ = std::move(v);
  }
  inline void ResetNamedGridRowLines() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_row_lines_ = NamedGridLinesMap();
  }

  // NonInheritedVariables
  inline static std::unique_ptr<StyleNonInheritedVariables> InitialNonInheritedVariables() {
    return nullptr;
  }
  // Getters and setters not generated

  // object-fit
  inline static EObjectFit InitialObjectFit() {
    return EObjectFit::kFill;
  }
  EObjectFit GetObjectFit() const {
    return static_cast<EObjectFit>(rare_non_inherited_data_->object_fit_);
  }
  void SetObjectFit(EObjectFit v) {
    if (!(rare_non_inherited_data_->object_fit_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->object_fit_ = static_cast<unsigned>(v);
  }
  inline void ResetObjectFit() {
    rare_non_inherited_data_.Access()->object_fit_ = static_cast<unsigned>(EObjectFit::kFill);
  }

  // object-position
  inline static LengthPoint InitialObjectPosition() {
    return LengthPoint(Length(50.0, kPercent), Length(50.0, kPercent));
  }
  const LengthPoint& ObjectPosition() const {
    return rare_non_inherited_data_->object_position_;
  }
  void SetObjectPosition(const LengthPoint& v) {
    if (!(rare_non_inherited_data_->object_position_ == v))
      rare_non_inherited_data_.Access()->object_position_ = v;
  }
  void SetObjectPosition(LengthPoint&& v) {
    if (!(rare_non_inherited_data_->object_position_ == v))
      rare_non_inherited_data_.Access()->object_position_ = std::move(v);
  }
  inline void ResetObjectPosition() {
    rare_non_inherited_data_.Access()->object_position_ = LengthPoint(Length(50.0, kPercent), Length(50.0, kPercent));
  }

  // offset-anchor
  inline static LengthPoint InitialOffsetAnchor() {
    return LengthPoint(Length(kAuto), Length(kAuto));
  }
  const LengthPoint& OffsetAnchor() const {
    return rare_non_inherited_data_->transform_data_->offset_anchor_;
  }
  void SetOffsetAnchor(const LengthPoint& v) {
    if (!(rare_non_inherited_data_->transform_data_->offset_anchor_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->offset_anchor_ = v;
  }
  void SetOffsetAnchor(LengthPoint&& v) {
    if (!(rare_non_inherited_data_->transform_data_->offset_anchor_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->offset_anchor_ = std::move(v);
  }
  inline void ResetOffsetAnchor() {
    rare_non_inherited_data_.Access()->transform_data_.Access()->offset_anchor_ = LengthPoint(Length(kAuto), Length(kAuto));
  }

  // offset-distance
  inline static Length InitialOffsetDistance() {
    return Length(0, kFixed);
  }
  const Length& OffsetDistance() const {
    return rare_non_inherited_data_->transform_data_->offset_distance_;
  }
  void SetOffsetDistance(const Length& v) {
    if (!(rare_non_inherited_data_->transform_data_->offset_distance_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->offset_distance_ = v;
  }
  void SetOffsetDistance(Length&& v) {
    if (!(rare_non_inherited_data_->transform_data_->offset_distance_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->offset_distance_ = std::move(v);
  }
  inline void ResetOffsetDistance() {
    rare_non_inherited_data_.Access()->transform_data_.Access()->offset_distance_ = Length(0, kFixed);
  }

  // offset-path
  static BasicShape* InitialOffsetPath() {
    return nullptr;
  }
  BasicShape* OffsetPath() const {
    return rare_non_inherited_data_->transform_data_->offset_path_.Get();
  }
  
  void SetOffsetPath(RefPtr<BasicShape> v) {
    rare_non_inherited_data_.Access()->transform_data_.Access()->offset_path_ = std::move(v);
  }

  // offset-position
  inline static LengthPoint InitialOffsetPosition() {
    return LengthPoint(Length(kAuto), Length(kAuto));
  }
  const LengthPoint& OffsetPosition() const {
    return rare_non_inherited_data_->transform_data_->offset_position_;
  }
  void SetOffsetPosition(const LengthPoint& v) {
    if (!(rare_non_inherited_data_->transform_data_->offset_position_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->offset_position_ = v;
  }
  void SetOffsetPosition(LengthPoint&& v) {
    if (!(rare_non_inherited_data_->transform_data_->offset_position_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->offset_position_ = std::move(v);
  }
  inline void ResetOffsetPosition() {
    rare_non_inherited_data_.Access()->transform_data_.Access()->offset_position_ = LengthPoint(Length(kAuto), Length(kAuto));
  }

  // offset-rotate
  inline static StyleOffsetRotation InitialOffsetRotate() {
    return StyleOffsetRotation(0, kOffsetRotationAuto);
  }
  const StyleOffsetRotation& OffsetRotate() const {
    return rare_non_inherited_data_->transform_data_->offset_rotate_;
  }
  void SetOffsetRotate(const StyleOffsetRotation& v) {
    if (!(rare_non_inherited_data_->transform_data_->offset_rotate_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->offset_rotate_ = v;
  }
  void SetOffsetRotate(StyleOffsetRotation&& v) {
    if (!(rare_non_inherited_data_->transform_data_->offset_rotate_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->offset_rotate_ = std::move(v);
  }
  inline void ResetOffsetRotate() {
    rare_non_inherited_data_.Access()->transform_data_.Access()->offset_rotate_ = StyleOffsetRotation(0, kOffsetRotationAuto);
  }

  // opacity
  inline static float InitialOpacity() {
    return 1.0;
  }
  // Getters and setters not generated

  // order
  inline static int InitialOrder() {
    return 0;
  }
  // Getters and setters not generated

  // OrderedNamedGridColumnLines
  inline static OrderedNamedGridLines InitialOrderedNamedGridColumnLines() {
    return OrderedNamedGridLines();
  }
  const OrderedNamedGridLines& OrderedNamedGridColumnLines() const {
    return rare_non_inherited_data_->grid_data_->ordered_named_grid_column_lines_;
  }
  void SetOrderedNamedGridColumnLines(const OrderedNamedGridLines& v) {
    if (!(rare_non_inherited_data_->grid_data_->ordered_named_grid_column_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->ordered_named_grid_column_lines_ = v;
  }
  void SetOrderedNamedGridColumnLines(OrderedNamedGridLines&& v) {
    if (!(rare_non_inherited_data_->grid_data_->ordered_named_grid_column_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->ordered_named_grid_column_lines_ = std::move(v);
  }
  inline void ResetOrderedNamedGridColumnLines() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->ordered_named_grid_column_lines_ = OrderedNamedGridLines();
  }

  // OrderedNamedGridRowLines
  inline static OrderedNamedGridLines InitialOrderedNamedGridRowLines() {
    return OrderedNamedGridLines();
  }
  const OrderedNamedGridLines& OrderedNamedGridRowLines() const {
    return rare_non_inherited_data_->grid_data_->ordered_named_grid_row_lines_;
  }
  void SetOrderedNamedGridRowLines(const OrderedNamedGridLines& v) {
    if (!(rare_non_inherited_data_->grid_data_->ordered_named_grid_row_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->ordered_named_grid_row_lines_ = v;
  }
  void SetOrderedNamedGridRowLines(OrderedNamedGridLines&& v) {
    if (!(rare_non_inherited_data_->grid_data_->ordered_named_grid_row_lines_ == v))
      rare_non_inherited_data_.Access()->grid_data_.Access()->ordered_named_grid_row_lines_ = std::move(v);
  }
  inline void ResetOrderedNamedGridRowLines() {
    rare_non_inherited_data_.Access()->grid_data_.Access()->ordered_named_grid_row_lines_ = OrderedNamedGridLines();
  }

  // OriginalDisplay
  inline static EDisplay InitialOriginalDisplay() {
    return EDisplay::kInline;
  }
  EDisplay OriginalDisplay() const {
    return static_cast<EDisplay>(original_display_);
  }
  void SetOriginalDisplay(EDisplay v) {
    original_display_ = static_cast<unsigned>(v);
  }
  inline void ResetOriginalDisplay() {
    original_display_ = static_cast<unsigned>(EDisplay::kInline);
  }

  // orphans
  inline static short InitialOrphans() {
    return 2;
  }
  short Orphans() const {
    return rare_inherited_data_->orphans_;
  }
  void SetOrphans(short v) {
    if (!(rare_inherited_data_->orphans_ == v))
      rare_inherited_data_.Access()->orphans_ = v;
  }
  inline void ResetOrphans() {
    rare_inherited_data_.Access()->orphans_ = 2;
  }

  // outline-color
  inline static Color InitialOutlineColor() {
    return 0;
  }
  // Getters and setters not generated

  // OutlineColorIsCurrentColor
  inline static bool InitialOutlineColorIsCurrentColor() {
    return true;
  }
  bool OutlineColorIsCurrentColor() const {
    return static_cast<bool>(rare_non_inherited_data_->outline_color_is_current_color_);
  }
  void SetOutlineColorIsCurrentColor(bool v) {
    if (!(rare_non_inherited_data_->outline_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->outline_color_is_current_color_ = static_cast<unsigned>(v);
  }
  inline void ResetOutlineColorIsCurrentColor() {
    rare_non_inherited_data_.Access()->outline_color_is_current_color_ = static_cast<unsigned>(true);
  }

  // outline-offset
  inline static int InitialOutlineOffset() {
    return 0;
  }
  // Getters and setters not generated

  // outline-style
  inline static EBorderStyle InitialOutlineStyle() {
    return EBorderStyle::kNone;
  }
  EBorderStyle OutlineStyle() const {
    return static_cast<EBorderStyle>(rare_non_inherited_data_->outline_style_);
  }
  void SetOutlineStyle(EBorderStyle v) {
    if (!(rare_non_inherited_data_->outline_style_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->outline_style_ = static_cast<unsigned>(v);
  }
  inline void ResetOutlineStyle() {
    rare_non_inherited_data_.Access()->outline_style_ = static_cast<unsigned>(EBorderStyle::kNone);
  }

  // OutlineStyleIsAuto
  inline static bool InitialOutlineStyleIsAuto() {
    return false;
  }
  bool OutlineStyleIsAuto() const {
    return static_cast<bool>(rare_non_inherited_data_->outline_style_is_auto_);
  }
  void SetOutlineStyleIsAuto(bool v) {
    if (!(rare_non_inherited_data_->outline_style_is_auto_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->outline_style_is_auto_ = static_cast<unsigned>(v);
  }
  inline void ResetOutlineStyleIsAuto() {
    rare_non_inherited_data_.Access()->outline_style_is_auto_ = static_cast<unsigned>(false);
  }

  // outline-width
  inline static LayoutUnit InitialOutlineWidth() {
    return LayoutUnit(3);
  }
  // Getters and setters not generated

  // overflow-anchor
  inline static EOverflowAnchor InitialOverflowAnchor() {
    return EOverflowAnchor::kAuto;
  }
  EOverflowAnchor OverflowAnchor() const {
    return static_cast<EOverflowAnchor>(overflow_anchor_);
  }
  void SetOverflowAnchor(EOverflowAnchor v) {
    overflow_anchor_ = static_cast<unsigned>(v);
  }
  inline void ResetOverflowAnchor() {
    overflow_anchor_ = static_cast<unsigned>(EOverflowAnchor::kAuto);
  }

  // overflow-wrap
  inline static EOverflowWrap InitialOverflowWrap() {
    return EOverflowWrap::kNormal;
  }
  EOverflowWrap OverflowWrap() const {
    return static_cast<EOverflowWrap>(rare_inherited_data_->overflow_wrap_);
  }
  void SetOverflowWrap(EOverflowWrap v) {
    if (!(rare_inherited_data_->overflow_wrap_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->overflow_wrap_ = static_cast<unsigned>(v);
  }
  inline void ResetOverflowWrap() {
    rare_inherited_data_.Access()->overflow_wrap_ = static_cast<unsigned>(EOverflowWrap::kNormal);
  }

  // overflow-x
  inline static EOverflow InitialOverflowX() {
    return EOverflow::kVisible;
  }
  EOverflow OverflowX() const {
    return static_cast<EOverflow>(overflow_x_);
  }
  void SetOverflowX(EOverflow v) {
    overflow_x_ = static_cast<unsigned>(v);
  }
  inline void ResetOverflowX() {
    overflow_x_ = static_cast<unsigned>(EOverflow::kVisible);
  }

  // overflow-y
  inline static EOverflow InitialOverflowY() {
    return EOverflow::kVisible;
  }
  EOverflow OverflowY() const {
    return static_cast<EOverflow>(overflow_y_);
  }
  void SetOverflowY(EOverflow v) {
    overflow_y_ = static_cast<unsigned>(v);
  }
  inline void ResetOverflowY() {
    overflow_y_ = static_cast<unsigned>(EOverflow::kVisible);
  }

  // padding-bottom
  inline static Length InitialPaddingBottom() {
    return Length(kFixed);
  }
  const Length& PaddingBottom() const {
    return surround_data_->padding_bottom_;
  }
  void SetPaddingBottom(const Length& v) {
    if (!(surround_data_->padding_bottom_ == v))
      surround_data_.Access()->padding_bottom_ = v;
  }
  void SetPaddingBottom(Length&& v) {
    if (!(surround_data_->padding_bottom_ == v))
      surround_data_.Access()->padding_bottom_ = std::move(v);
  }
  inline void ResetPaddingBottom() {
    surround_data_.Access()->padding_bottom_ = Length(kFixed);
  }

  // padding-left
  inline static Length InitialPaddingLeft() {
    return Length(kFixed);
  }
  const Length& PaddingLeft() const {
    return surround_data_->padding_left_;
  }
  void SetPaddingLeft(const Length& v) {
    if (!(surround_data_->padding_left_ == v))
      surround_data_.Access()->padding_left_ = v;
  }
  void SetPaddingLeft(Length&& v) {
    if (!(surround_data_->padding_left_ == v))
      surround_data_.Access()->padding_left_ = std::move(v);
  }
  inline void ResetPaddingLeft() {
    surround_data_.Access()->padding_left_ = Length(kFixed);
  }

  // padding-right
  inline static Length InitialPaddingRight() {
    return Length(kFixed);
  }
  const Length& PaddingRight() const {
    return surround_data_->padding_right_;
  }
  void SetPaddingRight(const Length& v) {
    if (!(surround_data_->padding_right_ == v))
      surround_data_.Access()->padding_right_ = v;
  }
  void SetPaddingRight(Length&& v) {
    if (!(surround_data_->padding_right_ == v))
      surround_data_.Access()->padding_right_ = std::move(v);
  }
  inline void ResetPaddingRight() {
    surround_data_.Access()->padding_right_ = Length(kFixed);
  }

  // padding-top
  inline static Length InitialPaddingTop() {
    return Length(kFixed);
  }
  const Length& PaddingTop() const {
    return surround_data_->padding_top_;
  }
  void SetPaddingTop(const Length& v) {
    if (!(surround_data_->padding_top_ == v))
      surround_data_.Access()->padding_top_ = v;
  }
  void SetPaddingTop(Length&& v) {
    if (!(surround_data_->padding_top_ == v))
      surround_data_.Access()->padding_top_ = std::move(v);
  }
  inline void ResetPaddingTop() {
    surround_data_.Access()->padding_top_ = Length(kFixed);
  }

  // PageSize
  inline static FloatSize InitialPageSize() {
    return FloatSize();
  }
  const FloatSize& PageSize() const {
    return rare_non_inherited_data_->page_size_;
  }
  void SetPageSize(const FloatSize& v) {
    if (!(rare_non_inherited_data_->page_size_ == v))
      rare_non_inherited_data_.Access()->page_size_ = v;
  }
  void SetPageSize(FloatSize&& v) {
    if (!(rare_non_inherited_data_->page_size_ == v))
      rare_non_inherited_data_.Access()->page_size_ = std::move(v);
  }
  inline void ResetPageSize() {
    rare_non_inherited_data_.Access()->page_size_ = FloatSize();
  }

  // PageSizeType
  inline static EPageSizeType InitialPageSizeType() {
    return EPageSizeType::kAuto;
  }
  EPageSizeType PageSizeType() const {
    return static_cast<EPageSizeType>(rare_non_inherited_data_->page_size_type_);
  }
  void SetPageSizeType(EPageSizeType v) {
    if (!(rare_non_inherited_data_->page_size_type_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->page_size_type_ = static_cast<unsigned>(v);
  }
  inline void ResetPageSizeType() {
    rare_non_inherited_data_.Access()->page_size_type_ = static_cast<unsigned>(EPageSizeType::kAuto);
  }

  // PaintImages
  inline static std::unique_ptr<PaintImages> InitialPaintImages() {
    return nullptr;
  }
  // Getters and setters not generated

  // perspective
  inline static float InitialPerspective() {
    return 0.0;
  }
  float Perspective() const {
    return rare_non_inherited_data_->perspective_;
  }
  void SetPerspective(float v) {
    if (!(rare_non_inherited_data_->perspective_ == v))
      rare_non_inherited_data_.Access()->perspective_ = v;
  }
  inline void ResetPerspective() {
    rare_non_inherited_data_.Access()->perspective_ = 0.0;
  }

  // perspective-origin
  inline static LengthPoint InitialPerspectiveOrigin() {
    return LengthPoint(Length(50.0, kPercent), Length(50.0, kPercent));
  }
  const LengthPoint& PerspectiveOrigin() const {
    return rare_non_inherited_data_->perspective_origin_;
  }
  void SetPerspectiveOrigin(const LengthPoint& v) {
    if (!(rare_non_inherited_data_->perspective_origin_ == v))
      rare_non_inherited_data_.Access()->perspective_origin_ = v;
  }
  void SetPerspectiveOrigin(LengthPoint&& v) {
    if (!(rare_non_inherited_data_->perspective_origin_ == v))
      rare_non_inherited_data_.Access()->perspective_origin_ = std::move(v);
  }
  inline void ResetPerspectiveOrigin() {
    rare_non_inherited_data_.Access()->perspective_origin_ = LengthPoint(Length(50.0, kPercent), Length(50.0, kPercent));
  }

  // pointer-events
  inline static EPointerEvents InitialPointerEvents() {
    return EPointerEvents::kAuto;
  }
  EPointerEvents PointerEvents() const {
    return static_cast<EPointerEvents>(pointer_events_);
  }
  void SetPointerEvents(EPointerEvents v) {
    pointer_events_ = static_cast<unsigned>(v);
  }
  inline void ResetPointerEvents() {
    pointer_events_ = static_cast<unsigned>(EPointerEvents::kAuto);
  }

  // pointer-events
  inline static bool InitialPointerEventsIsInherited() {
    return true;
  }
  bool PointerEventsIsInherited() const {
    return static_cast<bool>(pointer_events_is_inherited_);
  }
  void SetPointerEventsIsInherited(bool v) {
    pointer_events_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetPointerEventsIsInherited() {
    pointer_events_is_inherited_ = static_cast<unsigned>(true);
  }

  // position
  inline static EPosition InitialPosition() {
    return EPosition::kStatic;
  }
  EPosition GetPosition() const {
    return static_cast<EPosition>(position_);
  }
  void SetPosition(EPosition v) {
    position_ = static_cast<unsigned>(v);
  }
  inline void ResetPosition() {
    position_ = static_cast<unsigned>(EPosition::kStatic);
  }

  // -webkit-print-color-adjust
  inline static EPrintColorAdjust InitialPrintColorAdjust() {
    return EPrintColorAdjust::kEconomy;
  }
  EPrintColorAdjust PrintColorAdjust() const {
    return static_cast<EPrintColorAdjust>(print_color_adjust_);
  }
  void SetPrintColorAdjust(EPrintColorAdjust v) {
    print_color_adjust_ = static_cast<unsigned>(v);
  }
  inline void ResetPrintColorAdjust() {
    print_color_adjust_ = static_cast<unsigned>(EPrintColorAdjust::kEconomy);
  }

  // -webkit-print-color-adjust
  inline static bool InitialPrintColorAdjustIsInherited() {
    return true;
  }
  bool PrintColorAdjustIsInherited() const {
    return static_cast<bool>(print_color_adjust_is_inherited_);
  }
  void SetPrintColorAdjustIsInherited(bool v) {
    print_color_adjust_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetPrintColorAdjustIsInherited() {
    print_color_adjust_is_inherited_ = static_cast<unsigned>(true);
  }

  // PseudoBits
  inline static PseudoId InitialPseudoBits() {
    return kPseudoIdNone;
  }
  // Getters and setters not generated

  // quotes
  static QuotesData* InitialQuotes() {
    return nullptr;
  }
  QuotesData* Quotes() const {
    return rare_inherited_data_->quotes_.Get();
  }
  
  void SetQuotes(RefPtr<QuotesData> v) {
    rare_inherited_data_.Access()->quotes_ = std::move(v);
  }

  // RequiresAcceleratedCompositingForExternalReasons
  inline static bool InitialRequiresAcceleratedCompositingForExternalReasons() {
    return false;
  }
  bool RequiresAcceleratedCompositingForExternalReasons() const {
    return static_cast<bool>(rare_non_inherited_data_->requires_accelerated_compositing_for_external_reasons_);
  }
  void SetRequiresAcceleratedCompositingForExternalReasons(bool v) {
    if (!(rare_non_inherited_data_->requires_accelerated_compositing_for_external_reasons_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->requires_accelerated_compositing_for_external_reasons_ = static_cast<unsigned>(v);
  }
  inline void ResetRequiresAcceleratedCompositingForExternalReasons() {
    rare_non_inherited_data_.Access()->requires_accelerated_compositing_for_external_reasons_ = static_cast<unsigned>(false);
  }

  // resize
  inline static EResize InitialResize() {
    return EResize::kNone;
  }
  EResize Resize() const {
    return static_cast<EResize>(rare_non_inherited_data_->resize_);
  }
  void SetResize(EResize v) {
    if (!(rare_non_inherited_data_->resize_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->resize_ = static_cast<unsigned>(v);
  }
  inline void ResetResize() {
    rare_non_inherited_data_.Access()->resize_ = static_cast<unsigned>(EResize::kNone);
  }

  // image-orientation
  inline static bool InitialRespectImageOrientation() {
    return false;
  }
  bool RespectImageOrientation() const {
    return static_cast<bool>(rare_inherited_data_->respect_image_orientation_);
  }
  void SetRespectImageOrientation(bool v) {
    if (!(rare_inherited_data_->respect_image_orientation_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->respect_image_orientation_ = static_cast<unsigned>(v);
  }
  inline void ResetRespectImageOrientation() {
    rare_inherited_data_.Access()->respect_image_orientation_ = static_cast<unsigned>(false);
  }

  // right
  inline static Length InitialRight() {
    return Length();
  }
  const Length& Right() const {
    return surround_data_->right_;
  }
  void SetRight(const Length& v) {
    if (!(surround_data_->right_ == v))
      surround_data_.Access()->right_ = v;
  }
  void SetRight(Length&& v) {
    if (!(surround_data_->right_ == v))
      surround_data_.Access()->right_ = std::move(v);
  }
  inline void ResetRight() {
    surround_data_.Access()->right_ = Length();
  }

  // rotate
  static RotateTransformOperation* InitialRotate() {
    return nullptr;
  }
  RotateTransformOperation* Rotate() const {
    return rare_non_inherited_data_->transform_data_->rotate_.Get();
  }
  
  void SetRotate(RefPtr<RotateTransformOperation> v) {
    rare_non_inherited_data_.Access()->transform_data_.Access()->rotate_ = std::move(v);
  }

  // -webkit-rtl-ordering
  inline static EOrder InitialRtlOrdering() {
    return EOrder::kLogical;
  }
  EOrder RtlOrdering() const {
    return static_cast<EOrder>(rtl_ordering_);
  }
  void SetRtlOrdering(EOrder v) {
    rtl_ordering_ = static_cast<unsigned>(v);
  }
  inline void ResetRtlOrdering() {
    rtl_ordering_ = static_cast<unsigned>(EOrder::kLogical);
  }

  // -webkit-rtl-ordering
  inline static bool InitialRtlOrderingIsInherited() {
    return true;
  }
  bool RtlOrderingIsInherited() const {
    return static_cast<bool>(rtl_ordering_is_inherited_);
  }
  void SetRtlOrderingIsInherited(bool v) {
    rtl_ordering_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetRtlOrderingIsInherited() {
    rtl_ordering_is_inherited_ = static_cast<unsigned>(true);
  }

  // -webkit-ruby-position
  inline static RubyPosition InitialRubyPosition() {
    return RubyPosition::kBefore;
  }
  RubyPosition GetRubyPosition() const {
    return static_cast<RubyPosition>(rare_inherited_data_->ruby_position_);
  }
  void SetRubyPosition(RubyPosition v) {
    if (!(rare_inherited_data_->ruby_position_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->ruby_position_ = static_cast<unsigned>(v);
  }
  inline void ResetRubyPosition() {
    rare_inherited_data_.Access()->ruby_position_ = static_cast<unsigned>(RubyPosition::kBefore);
  }

  // scale
  static ScaleTransformOperation* InitialScale() {
    return nullptr;
  }
  ScaleTransformOperation* Scale() const {
    return rare_non_inherited_data_->transform_data_->scale_.Get();
  }
  
  void SetScale(RefPtr<ScaleTransformOperation> v) {
    rare_non_inherited_data_.Access()->transform_data_.Access()->scale_ = std::move(v);
  }

  // scroll-behavior
  inline static ScrollBehavior InitialScrollBehavior() {
    return kScrollBehaviorAuto;
  }
  // Getters and setters not generated

  // scroll-padding-bottom
  inline static Length InitialScrollPaddingBottom() {
    return Length();
  }
  const Length& ScrollPaddingBottom() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_padding_bottom_;
  }
  void SetScrollPaddingBottom(const Length& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_padding_bottom_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_bottom_ = v;
  }
  void SetScrollPaddingBottom(Length&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_padding_bottom_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_bottom_ = std::move(v);
  }
  inline void ResetScrollPaddingBottom() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_bottom_ = Length();
  }

  // scroll-padding-left
  inline static Length InitialScrollPaddingLeft() {
    return Length();
  }
  const Length& ScrollPaddingLeft() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_padding_left_;
  }
  void SetScrollPaddingLeft(const Length& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_padding_left_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_left_ = v;
  }
  void SetScrollPaddingLeft(Length&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_padding_left_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_left_ = std::move(v);
  }
  inline void ResetScrollPaddingLeft() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_left_ = Length();
  }

  // scroll-padding-right
  inline static Length InitialScrollPaddingRight() {
    return Length();
  }
  const Length& ScrollPaddingRight() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_padding_right_;
  }
  void SetScrollPaddingRight(const Length& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_padding_right_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_right_ = v;
  }
  void SetScrollPaddingRight(Length&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_padding_right_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_right_ = std::move(v);
  }
  inline void ResetScrollPaddingRight() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_right_ = Length();
  }

  // scroll-padding-top
  inline static Length InitialScrollPaddingTop() {
    return Length();
  }
  const Length& ScrollPaddingTop() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_padding_top_;
  }
  void SetScrollPaddingTop(const Length& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_padding_top_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_top_ = v;
  }
  void SetScrollPaddingTop(Length&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_padding_top_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_top_ = std::move(v);
  }
  inline void ResetScrollPaddingTop() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_top_ = Length();
  }

  // scroll-snap-align
  inline static ScrollSnapAlign InitialScrollSnapAlign() {
    return ScrollSnapAlign();
  }
  const ScrollSnapAlign& GetScrollSnapAlign() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_snap_align_;
  }
  void SetScrollSnapAlign(const ScrollSnapAlign& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_align_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_align_ = v;
  }
  void SetScrollSnapAlign(ScrollSnapAlign&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_align_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_align_ = std::move(v);
  }
  inline void ResetScrollSnapAlign() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_align_ = ScrollSnapAlign();
  }

  // scroll-snap-margin-bottom
  inline static Length InitialScrollSnapMarginBottom() {
    return Length();
  }
  const Length& ScrollSnapMarginBottom() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_bottom_;
  }
  void SetScrollSnapMarginBottom(const Length& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_bottom_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_bottom_ = v;
  }
  void SetScrollSnapMarginBottom(Length&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_bottom_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_bottom_ = std::move(v);
  }
  inline void ResetScrollSnapMarginBottom() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_bottom_ = Length();
  }

  // scroll-snap-margin-left
  inline static Length InitialScrollSnapMarginLeft() {
    return Length();
  }
  const Length& ScrollSnapMarginLeft() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_left_;
  }
  void SetScrollSnapMarginLeft(const Length& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_left_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_left_ = v;
  }
  void SetScrollSnapMarginLeft(Length&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_left_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_left_ = std::move(v);
  }
  inline void ResetScrollSnapMarginLeft() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_left_ = Length();
  }

  // scroll-snap-margin-right
  inline static Length InitialScrollSnapMarginRight() {
    return Length();
  }
  const Length& ScrollSnapMarginRight() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_right_;
  }
  void SetScrollSnapMarginRight(const Length& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_right_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_right_ = v;
  }
  void SetScrollSnapMarginRight(Length&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_right_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_right_ = std::move(v);
  }
  inline void ResetScrollSnapMarginRight() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_right_ = Length();
  }

  // scroll-snap-margin-top
  inline static Length InitialScrollSnapMarginTop() {
    return Length();
  }
  const Length& ScrollSnapMarginTop() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_top_;
  }
  void SetScrollSnapMarginTop(const Length& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_top_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_top_ = v;
  }
  void SetScrollSnapMarginTop(Length&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_margin_top_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_top_ = std::move(v);
  }
  inline void ResetScrollSnapMarginTop() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_top_ = Length();
  }

  // scroll-snap-stop
  inline static EScrollSnapStop InitialScrollSnapStop() {
    return EScrollSnapStop::kNormal;
  }
  EScrollSnapStop ScrollSnapStop() const {
    return static_cast<EScrollSnapStop>(scroll_snap_stop_);
  }
  void SetScrollSnapStop(EScrollSnapStop v) {
    scroll_snap_stop_ = static_cast<unsigned>(v);
  }
  inline void ResetScrollSnapStop() {
    scroll_snap_stop_ = static_cast<unsigned>(EScrollSnapStop::kNormal);
  }

  // scroll-snap-type
  inline static ScrollSnapType InitialScrollSnapType() {
    return ScrollSnapType();
  }
  const ScrollSnapType& GetScrollSnapType() const {
    return rare_non_inherited_data_->scroll_snap_data_->scroll_snap_type_;
  }
  void SetScrollSnapType(const ScrollSnapType& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_type_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_type_ = v;
  }
  void SetScrollSnapType(ScrollSnapType&& v) {
    if (!(rare_non_inherited_data_->scroll_snap_data_->scroll_snap_type_ == v))
      rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_type_ = std::move(v);
  }
  inline void ResetScrollSnapType() {
    rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_type_ = ScrollSnapType();
  }

  // SelfOrAncestorHasDirAutoAttribute
  inline static bool InitialSelfOrAncestorHasDirAutoAttribute() {
    return false;
  }
  bool SelfOrAncestorHasDirAutoAttribute() const {
    return static_cast<bool>(rare_inherited_data_->self_or_ancestor_has_dir_auto_attribute_);
  }
  void SetSelfOrAncestorHasDirAutoAttribute(bool v) {
    if (!(rare_inherited_data_->self_or_ancestor_has_dir_auto_attribute_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->self_or_ancestor_has_dir_auto_attribute_ = static_cast<unsigned>(v);
  }
  inline void ResetSelfOrAncestorHasDirAutoAttribute() {
    rare_inherited_data_.Access()->self_or_ancestor_has_dir_auto_attribute_ = static_cast<unsigned>(false);
  }

  // shape-image-threshold
  inline static float InitialShapeImageThreshold() {
    return 0.0;
  }
  // Getters and setters not generated

  // shape-margin
  inline static Length InitialShapeMargin() {
    return Length(0, kFixed);
  }
  const Length& ShapeMargin() const {
    return rare_non_inherited_data_->shape_margin_;
  }
  void SetShapeMargin(const Length& v) {
    if (!(rare_non_inherited_data_->shape_margin_ == v))
      rare_non_inherited_data_.Access()->shape_margin_ = v;
  }
  void SetShapeMargin(Length&& v) {
    if (!(rare_non_inherited_data_->shape_margin_ == v))
      rare_non_inherited_data_.Access()->shape_margin_ = std::move(v);
  }
  inline void ResetShapeMargin() {
    rare_non_inherited_data_.Access()->shape_margin_ = Length(0, kFixed);
  }

  // shape-outside
  inline static Persistent<ShapeValue> InitialShapeOutside() {
    return nullptr;
  }
  // Getters and setters not generated

  // speak
  inline static ESpeak InitialSpeak() {
    return ESpeak::kNormal;
  }
  ESpeak Speak() const {
    return static_cast<ESpeak>(rare_inherited_data_->speak_);
  }
  void SetSpeak(ESpeak v) {
    if (!(rare_inherited_data_->speak_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->speak_ = static_cast<unsigned>(v);
  }
  inline void ResetSpeak() {
    rare_inherited_data_.Access()->speak_ = static_cast<unsigned>(ESpeak::kNormal);
  }

  // StyleType
  inline static PseudoId InitialStyleType() {
    return PseudoId::kPseudoIdNone;
  }
  // Getters and setters not generated

  // SubtreeIsSticky
  inline static bool InitialSubtreeIsSticky() {
    return false;
  }
  bool SubtreeIsSticky() const {
    return static_cast<bool>(rare_inherited_data_->subtree_is_sticky_);
  }
  void SetSubtreeIsSticky(bool v) {
    if (!(rare_inherited_data_->subtree_is_sticky_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->subtree_is_sticky_ = static_cast<unsigned>(v);
  }
  inline void ResetSubtreeIsSticky() {
    rare_inherited_data_.Access()->subtree_is_sticky_ = static_cast<unsigned>(false);
  }

  // SubtreeWillChangeContents
  inline static bool InitialSubtreeWillChangeContents() {
    return false;
  }
  bool SubtreeWillChangeContents() const {
    return static_cast<bool>(rare_inherited_data_->subtree_will_change_contents_);
  }
  void SetSubtreeWillChangeContents(bool v) {
    if (!(rare_inherited_data_->subtree_will_change_contents_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->subtree_will_change_contents_ = static_cast<unsigned>(v);
  }
  inline void ResetSubtreeWillChangeContents() {
    rare_inherited_data_.Access()->subtree_will_change_contents_ = static_cast<unsigned>(false);
  }

  // tab-size
  inline static TabSize InitialTabSize() {
    return TabSize(8);
  }
  const TabSize& GetTabSize() const {
    return rare_inherited_data_->tab_size_;
  }
  void SetTabSize(const TabSize& v) {
    if (!(rare_inherited_data_->tab_size_ == v))
      rare_inherited_data_.Access()->tab_size_ = v;
  }
  void SetTabSize(TabSize&& v) {
    if (!(rare_inherited_data_->tab_size_ == v))
      rare_inherited_data_.Access()->tab_size_ = std::move(v);
  }
  inline void ResetTabSize() {
    rare_inherited_data_.Access()->tab_size_ = TabSize(8);
  }

  // table-layout
  inline static ETableLayout InitialTableLayout() {
    return ETableLayout::kAuto;
  }
  ETableLayout TableLayout() const {
    return static_cast<ETableLayout>(table_layout_);
  }
  void SetTableLayout(ETableLayout v) {
    table_layout_ = static_cast<unsigned>(v);
  }
  inline void ResetTableLayout() {
    table_layout_ = static_cast<unsigned>(ETableLayout::kAuto);
  }

  // -webkit-tap-highlight-color
  inline static Color InitialTapHighlightColor() {
    return LayoutTheme::TapHighlightColor();
  }
  const Color& TapHighlightColor() const {
    return rare_inherited_data_->tap_highlight_color_;
  }
  void SetTapHighlightColor(const Color& v) {
    if (!(rare_inherited_data_->tap_highlight_color_ == v))
      rare_inherited_data_.Access()->tap_highlight_color_ = v;
  }
  void SetTapHighlightColor(Color&& v) {
    if (!(rare_inherited_data_->tap_highlight_color_ == v))
      rare_inherited_data_.Access()->tap_highlight_color_ = std::move(v);
  }
  inline void ResetTapHighlightColor() {
    rare_inherited_data_.Access()->tap_highlight_color_ = LayoutTheme::TapHighlightColor();
  }

  // text-align
  inline static ETextAlign InitialTextAlign() {
    return ETextAlign::kStart;
  }
  ETextAlign GetTextAlign() const {
    return static_cast<ETextAlign>(text_align_);
  }
  void SetTextAlign(ETextAlign v) {
    text_align_ = static_cast<unsigned>(v);
  }
  inline void ResetTextAlign() {
    text_align_ = static_cast<unsigned>(ETextAlign::kStart);
  }

  // text-align-last
  inline static ETextAlignLast InitialTextAlignLast() {
    return ETextAlignLast::kAuto;
  }
  ETextAlignLast TextAlignLast() const {
    return static_cast<ETextAlignLast>(rare_inherited_data_->text_align_last_);
  }
  void SetTextAlignLast(ETextAlignLast v) {
    if (!(rare_inherited_data_->text_align_last_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_align_last_ = static_cast<unsigned>(v);
  }
  inline void ResetTextAlignLast() {
    rare_inherited_data_.Access()->text_align_last_ = static_cast<unsigned>(ETextAlignLast::kAuto);
  }

  // TextAutosizingMultiplier
  inline static float InitialTextAutosizingMultiplier() {
    return 1.0;
  }
  // Getters and setters not generated

  // text-combine-upright
  inline static ETextCombine InitialTextCombine() {
    return ETextCombine::kNone;
  }
  ETextCombine TextCombine() const {
    return static_cast<ETextCombine>(rare_inherited_data_->text_combine_);
  }
  void SetTextCombine(ETextCombine v) {
    if (!(rare_inherited_data_->text_combine_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_combine_ = static_cast<unsigned>(v);
  }
  inline void ResetTextCombine() {
    rare_inherited_data_.Access()->text_combine_ = static_cast<unsigned>(ETextCombine::kNone);
  }

  // text-decoration-line
  inline static TextDecoration InitialTextDecoration() {
    return TextDecoration::kNone;
  }
  TextDecoration GetTextDecoration() const {
    return static_cast<TextDecoration>(visual_data_->text_decoration_);
  }
  void SetTextDecoration(TextDecoration v) {
    if (!(visual_data_->text_decoration_ == static_cast<unsigned>(v)))
      visual_data_.Access()->text_decoration_ = static_cast<unsigned>(v);
  }
  inline void ResetTextDecoration() {
    visual_data_.Access()->text_decoration_ = static_cast<unsigned>(TextDecoration::kNone);
  }

  // text-decoration-color
  inline static StyleColor InitialTextDecorationColor() {
    return StyleColor::CurrentColor();
  }
  const StyleColor& TextDecorationColor() const {
    return rare_non_inherited_data_->text_decoration_color_;
  }
  void SetTextDecorationColor(const StyleColor& v) {
    if (!(rare_non_inherited_data_->text_decoration_color_ == v))
      rare_non_inherited_data_.Access()->text_decoration_color_ = v;
  }
  void SetTextDecorationColor(StyleColor&& v) {
    if (!(rare_non_inherited_data_->text_decoration_color_ == v))
      rare_non_inherited_data_.Access()->text_decoration_color_ = std::move(v);
  }
  inline void ResetTextDecorationColor() {
    rare_non_inherited_data_.Access()->text_decoration_color_ = StyleColor::CurrentColor();
  }

  // text-decoration-skip
  inline static TextDecorationSkip InitialTextDecorationSkip() {
    return TextDecorationSkip::kObjects;
  }
  // Getters and setters not generated

  // text-decoration-style
  inline static ETextDecorationStyle InitialTextDecorationStyle() {
    return ETextDecorationStyle::kSolid;
  }
  ETextDecorationStyle TextDecorationStyle() const {
    return static_cast<ETextDecorationStyle>(rare_non_inherited_data_->text_decoration_style_);
  }
  void SetTextDecorationStyle(ETextDecorationStyle v) {
    if (!(rare_non_inherited_data_->text_decoration_style_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->text_decoration_style_ = static_cast<unsigned>(v);
  }
  inline void ResetTextDecorationStyle() {
    rare_non_inherited_data_.Access()->text_decoration_style_ = static_cast<unsigned>(ETextDecorationStyle::kSolid);
  }

  // -webkit-text-emphasis-color
  inline static Color InitialTextEmphasisColor() {
    return Color();
  }
  // Getters and setters not generated

  // TextEmphasisColorIsCurrentColor
  inline static bool InitialTextEmphasisColorIsCurrentColor() {
    return true;
  }
  // Getters and setters not generated

  // TextEmphasisCustomMark
  inline static AtomicString InitialTextEmphasisCustomMark() {
    return AtomicString();
  }
  const AtomicString& TextEmphasisCustomMark() const {
    return rare_inherited_data_->text_emphasis_custom_mark_;
  }
  void SetTextEmphasisCustomMark(const AtomicString& v) {
    if (!(rare_inherited_data_->text_emphasis_custom_mark_ == v))
      rare_inherited_data_.Access()->text_emphasis_custom_mark_ = v;
  }
  void SetTextEmphasisCustomMark(AtomicString&& v) {
    if (!(rare_inherited_data_->text_emphasis_custom_mark_ == v))
      rare_inherited_data_.Access()->text_emphasis_custom_mark_ = std::move(v);
  }
  inline void ResetTextEmphasisCustomMark() {
    rare_inherited_data_.Access()->text_emphasis_custom_mark_ = AtomicString();
  }

  // TextEmphasisFill
  inline static TextEmphasisFill InitialTextEmphasisFill() {
    return TextEmphasisFill::kFilled;
  }
  TextEmphasisFill GetTextEmphasisFill() const {
    return static_cast<TextEmphasisFill>(rare_inherited_data_->text_emphasis_fill_);
  }
  void SetTextEmphasisFill(TextEmphasisFill v) {
    if (!(rare_inherited_data_->text_emphasis_fill_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_emphasis_fill_ = static_cast<unsigned>(v);
  }
  inline void ResetTextEmphasisFill() {
    rare_inherited_data_.Access()->text_emphasis_fill_ = static_cast<unsigned>(TextEmphasisFill::kFilled);
  }

  // TextEmphasisMark
  inline static TextEmphasisMark InitialTextEmphasisMark() {
    return TextEmphasisMark::kNone;
  }
  // Getters and setters not generated

  // -webkit-text-emphasis-position
  inline static TextEmphasisPosition InitialTextEmphasisPosition() {
    return TextEmphasisPosition::kOver;
  }
  TextEmphasisPosition GetTextEmphasisPosition() const {
    return static_cast<TextEmphasisPosition>(rare_inherited_data_->text_emphasis_position_);
  }
  void SetTextEmphasisPosition(TextEmphasisPosition v) {
    if (!(rare_inherited_data_->text_emphasis_position_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_emphasis_position_ = static_cast<unsigned>(v);
  }
  inline void ResetTextEmphasisPosition() {
    rare_inherited_data_.Access()->text_emphasis_position_ = static_cast<unsigned>(TextEmphasisPosition::kOver);
  }

  // -webkit-text-fill-color
  inline static Color InitialTextFillColor() {
    return Color();
  }
  // Getters and setters not generated

  // TextFillColorIsCurrentColor
  inline static bool InitialTextFillColorIsCurrentColor() {
    return true;
  }
  // Getters and setters not generated

  // text-indent
  inline static Length InitialTextIndent() {
    return Length(kFixed);
  }
  const Length& TextIndent() const {
    return rare_inherited_data_->text_indent_;
  }
  void SetTextIndent(const Length& v) {
    if (!(rare_inherited_data_->text_indent_ == v))
      rare_inherited_data_.Access()->text_indent_ = v;
  }
  void SetTextIndent(Length&& v) {
    if (!(rare_inherited_data_->text_indent_ == v))
      rare_inherited_data_.Access()->text_indent_ = std::move(v);
  }
  inline void ResetTextIndent() {
    rare_inherited_data_.Access()->text_indent_ = Length(kFixed);
  }

  // TextIndentLine
  inline static TextIndentLine InitialTextIndentLine() {
    return TextIndentLine::kFirstLine;
  }
  TextIndentLine GetTextIndentLine() const {
    return static_cast<TextIndentLine>(rare_inherited_data_->text_indent_line_);
  }
  void SetTextIndentLine(TextIndentLine v) {
    if (!(rare_inherited_data_->text_indent_line_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_indent_line_ = static_cast<unsigned>(v);
  }
  inline void ResetTextIndentLine() {
    rare_inherited_data_.Access()->text_indent_line_ = static_cast<unsigned>(TextIndentLine::kFirstLine);
  }

  // TextIndentType
  inline static TextIndentType InitialTextIndentType() {
    return TextIndentType::kNormal;
  }
  TextIndentType GetTextIndentType() const {
    return static_cast<TextIndentType>(rare_inherited_data_->text_indent_type_);
  }
  void SetTextIndentType(TextIndentType v) {
    if (!(rare_inherited_data_->text_indent_type_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_indent_type_ = static_cast<unsigned>(v);
  }
  inline void ResetTextIndentType() {
    rare_inherited_data_.Access()->text_indent_type_ = static_cast<unsigned>(TextIndentType::kNormal);
  }

  // text-justify
  inline static TextJustify InitialTextJustify() {
    return TextJustify::kAuto;
  }
  TextJustify GetTextJustify() const {
    return static_cast<TextJustify>(rare_inherited_data_->text_justify_);
  }
  void SetTextJustify(TextJustify v) {
    if (!(rare_inherited_data_->text_justify_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_justify_ = static_cast<unsigned>(v);
  }
  inline void ResetTextJustify() {
    rare_inherited_data_.Access()->text_justify_ = static_cast<unsigned>(TextJustify::kAuto);
  }

  // text-orientation
  inline static ETextOrientation InitialTextOrientation() {
    return ETextOrientation::kMixed;
  }
  ETextOrientation GetTextOrientation() const {
    return static_cast<ETextOrientation>(rare_inherited_data_->text_orientation_);
  }
  void SetTextOrientation(ETextOrientation v) {
    if (!(rare_inherited_data_->text_orientation_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_orientation_ = static_cast<unsigned>(v);
  }
  inline void ResetTextOrientation() {
    rare_inherited_data_.Access()->text_orientation_ = static_cast<unsigned>(ETextOrientation::kMixed);
  }

  // text-overflow
  inline static ETextOverflow InitialTextOverflow() {
    return ETextOverflow::kClip;
  }
  ETextOverflow TextOverflow() const {
    return static_cast<ETextOverflow>(rare_non_inherited_data_->text_overflow_);
  }
  void SetTextOverflow(ETextOverflow v) {
    if (!(rare_non_inherited_data_->text_overflow_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->text_overflow_ = static_cast<unsigned>(v);
  }
  inline void ResetTextOverflow() {
    rare_non_inherited_data_.Access()->text_overflow_ = static_cast<unsigned>(ETextOverflow::kClip);
  }

  // -webkit-text-security
  inline static ETextSecurity InitialTextSecurity() {
    return ETextSecurity::kNone;
  }
  ETextSecurity TextSecurity() const {
    return static_cast<ETextSecurity>(rare_inherited_data_->text_security_);
  }
  void SetTextSecurity(ETextSecurity v) {
    if (!(rare_inherited_data_->text_security_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_security_ = static_cast<unsigned>(v);
  }
  inline void ResetTextSecurity() {
    rare_inherited_data_.Access()->text_security_ = static_cast<unsigned>(ETextSecurity::kNone);
  }

  // text-shadow
  static ShadowList* InitialTextShadow() {
    return nullptr;
  }
  ShadowList* TextShadow() const {
    return rare_inherited_data_->text_shadow_.Get();
  }
  
  void SetTextShadow(RefPtr<ShadowList> v) {
    rare_inherited_data_.Access()->text_shadow_ = std::move(v);
  }

  // text-size-adjust
  inline static TextSizeAdjust InitialTextSizeAdjust() {
    return TextSizeAdjust::AdjustAuto();
  }
  const TextSizeAdjust& GetTextSizeAdjust() const {
    return rare_inherited_data_->text_size_adjust_;
  }
  void SetTextSizeAdjust(const TextSizeAdjust& v) {
    if (!(rare_inherited_data_->text_size_adjust_ == v))
      rare_inherited_data_.Access()->text_size_adjust_ = v;
  }
  void SetTextSizeAdjust(TextSizeAdjust&& v) {
    if (!(rare_inherited_data_->text_size_adjust_ == v))
      rare_inherited_data_.Access()->text_size_adjust_ = std::move(v);
  }
  inline void ResetTextSizeAdjust() {
    rare_inherited_data_.Access()->text_size_adjust_ = TextSizeAdjust::AdjustAuto();
  }

  // -webkit-text-stroke-color
  inline static Color InitialTextStrokeColor() {
    return Color();
  }
  // Getters and setters not generated

  // TextStrokeColorIsCurrentColor
  inline static bool InitialTextStrokeColorIsCurrentColor() {
    return true;
  }
  // Getters and setters not generated

  // -webkit-text-stroke-width
  inline static float InitialTextStrokeWidth() {
    return 0;
  }
  float TextStrokeWidth() const {
    return rare_inherited_data_->text_stroke_width_;
  }
  void SetTextStrokeWidth(float v) {
    if (!(rare_inherited_data_->text_stroke_width_ == v))
      rare_inherited_data_.Access()->text_stroke_width_ = v;
  }
  inline void ResetTextStrokeWidth() {
    rare_inherited_data_.Access()->text_stroke_width_ = 0;
  }

  // text-transform
  inline static ETextTransform InitialTextTransform() {
    return ETextTransform::kNone;
  }
  ETextTransform TextTransform() const {
    return static_cast<ETextTransform>(text_transform_);
  }
  void SetTextTransform(ETextTransform v) {
    text_transform_ = static_cast<unsigned>(v);
  }
  inline void ResetTextTransform() {
    text_transform_ = static_cast<unsigned>(ETextTransform::kNone);
  }

  // text-transform
  inline static bool InitialTextTransformIsInherited() {
    return true;
  }
  bool TextTransformIsInherited() const {
    return static_cast<bool>(text_transform_is_inherited_);
  }
  void SetTextTransformIsInherited(bool v) {
    text_transform_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetTextTransformIsInherited() {
    text_transform_is_inherited_ = static_cast<unsigned>(true);
  }

  // text-underline-position
  inline static TextUnderlinePosition InitialTextUnderlinePosition() {
    return TextUnderlinePosition::kAuto;
  }
  TextUnderlinePosition GetTextUnderlinePosition() const {
    return static_cast<TextUnderlinePosition>(rare_inherited_data_->text_underline_position_);
  }
  void SetTextUnderlinePosition(TextUnderlinePosition v) {
    if (!(rare_inherited_data_->text_underline_position_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_underline_position_ = static_cast<unsigned>(v);
  }
  inline void ResetTextUnderlinePosition() {
    rare_inherited_data_.Access()->text_underline_position_ = static_cast<unsigned>(TextUnderlinePosition::kAuto);
  }

  // top
  inline static Length InitialTop() {
    return Length();
  }
  const Length& Top() const {
    return surround_data_->top_;
  }
  void SetTop(const Length& v) {
    if (!(surround_data_->top_ == v))
      surround_data_.Access()->top_ = v;
  }
  void SetTop(Length&& v) {
    if (!(surround_data_->top_ == v))
      surround_data_.Access()->top_ = std::move(v);
  }
  inline void ResetTop() {
    surround_data_.Access()->top_ = Length();
  }

  // touch-action
  inline static TouchAction InitialTouchAction() {
    return TouchAction::kTouchActionAuto;
  }
  // Getters and setters not generated

  // transform
  inline static TransformOperations InitialTransform() {
    return EmptyTransformOperations();
  }
  // Getters and setters not generated

  // transform-box
  inline static ETransformBox InitialTransformBox() {
    return ETransformBox::kBorderBox;
  }
  ETransformBox TransformBox() const {
    return static_cast<ETransformBox>(transform_box_);
  }
  void SetTransformBox(ETransformBox v) {
    transform_box_ = static_cast<unsigned>(v);
  }
  inline void ResetTransformBox() {
    transform_box_ = static_cast<unsigned>(ETransformBox::kBorderBox);
  }

  // transform-origin
  inline static TransformOrigin InitialTransformOrigin() {
    return TransformOrigin(Length(50.0, kPercent), Length(50.0, kPercent), 0);
  }
  const TransformOrigin& GetTransformOrigin() const {
    return rare_non_inherited_data_->transform_data_->transform_origin_;
  }
  void SetTransformOrigin(const TransformOrigin& v) {
    if (!(rare_non_inherited_data_->transform_data_->transform_origin_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->transform_origin_ = v;
  }
  void SetTransformOrigin(TransformOrigin&& v) {
    if (!(rare_non_inherited_data_->transform_data_->transform_origin_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->transform_origin_ = std::move(v);
  }
  inline void ResetTransformOrigin() {
    rare_non_inherited_data_.Access()->transform_data_.Access()->transform_origin_ = TransformOrigin(Length(50.0, kPercent), Length(50.0, kPercent), 0);
  }

  // transform-style
  inline static ETransformStyle3D InitialTransformStyle3D() {
    return ETransformStyle3D::kFlat;
  }
  ETransformStyle3D TransformStyle3D() const {
    return static_cast<ETransformStyle3D>(rare_non_inherited_data_->transform_style_3d_);
  }
  void SetTransformStyle3D(ETransformStyle3D v) {
    if (!(rare_non_inherited_data_->transform_style_3d_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->transform_style_3d_ = static_cast<unsigned>(v);
  }
  inline void ResetTransformStyle3D() {
    rare_non_inherited_data_.Access()->transform_style_3d_ = static_cast<unsigned>(ETransformStyle3D::kFlat);
  }

  // Transitions
  inline static std::unique_ptr<CSSTransitionData> InitialTransitions() {
    return nullptr;
  }
  // Getters and setters not generated

  // translate
  static TranslateTransformOperation* InitialTranslate() {
    return nullptr;
  }
  TranslateTransformOperation* Translate() const {
    return rare_non_inherited_data_->transform_data_->translate_.Get();
  }
  
  void SetTranslate(RefPtr<TranslateTransformOperation> v) {
    rare_non_inherited_data_.Access()->transform_data_.Access()->translate_ = std::move(v);
  }

  // unicode-bidi
  inline static UnicodeBidi InitialUnicodeBidi() {
    return UnicodeBidi::kNormal;
  }
  UnicodeBidi GetUnicodeBidi() const {
    return static_cast<UnicodeBidi>(unicode_bidi_);
  }
  void SetUnicodeBidi(UnicodeBidi v) {
    unicode_bidi_ = static_cast<unsigned>(v);
  }
  inline void ResetUnicodeBidi() {
    unicode_bidi_ = static_cast<unsigned>(UnicodeBidi::kNormal);
  }

  // Unique
  bool Unique() const {
    return static_cast<bool>(unique_);
  }
  void SetUnique() const {
    unique_ = static_cast<unsigned>(true);
  }

  // -webkit-user-drag
  inline static EUserDrag InitialUserDrag() {
    return EUserDrag::kAuto;
  }
  EUserDrag UserDrag() const {
    return static_cast<EUserDrag>(rare_non_inherited_data_->user_drag_);
  }
  void SetUserDrag(EUserDrag v) {
    if (!(rare_non_inherited_data_->user_drag_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->user_drag_ = static_cast<unsigned>(v);
  }
  inline void ResetUserDrag() {
    rare_non_inherited_data_.Access()->user_drag_ = static_cast<unsigned>(EUserDrag::kAuto);
  }

  // -webkit-user-modify
  inline static EUserModify InitialUserModify() {
    return EUserModify::kReadOnly;
  }
  EUserModify UserModify() const {
    return static_cast<EUserModify>(rare_inherited_data_->user_modify_);
  }
  void SetUserModify(EUserModify v) {
    if (!(rare_inherited_data_->user_modify_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->user_modify_ = static_cast<unsigned>(v);
  }
  inline void ResetUserModify() {
    rare_inherited_data_.Access()->user_modify_ = static_cast<unsigned>(EUserModify::kReadOnly);
  }

  // user-select
  inline static EUserSelect InitialUserSelect() {
    return EUserSelect::kText;
  }
  EUserSelect UserSelect() const {
    return static_cast<EUserSelect>(rare_inherited_data_->user_select_);
  }
  void SetUserSelect(EUserSelect v) {
    if (!(rare_inherited_data_->user_select_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->user_select_ = static_cast<unsigned>(v);
  }
  inline void ResetUserSelect() {
    rare_inherited_data_.Access()->user_select_ = static_cast<unsigned>(EUserSelect::kText);
  }

  // VerticalAlign
  inline static EVerticalAlign InitialVerticalAlign() {
    return EVerticalAlign::kBaseline;
  }
  // Getters and setters not generated

  // VerticalAlignLength
  inline static Length InitialVerticalAlignLength() {
    return Length();
  }
  // Getters and setters not generated

  // -webkit-border-vertical-spacing
  inline static short InitialVerticalBorderSpacing() {
    return 0;
  }
  short VerticalBorderSpacing() const {
    return inherited_data_->vertical_border_spacing_;
  }
  void SetVerticalBorderSpacing(short v) {
    if (!(inherited_data_->vertical_border_spacing_ == v))
      inherited_data_.Access()->vertical_border_spacing_ = v;
  }
  inline void ResetVerticalBorderSpacing() {
    inherited_data_.Access()->vertical_border_spacing_ = 0;
  }

  // visibility
  inline static EVisibility InitialVisibility() {
    return EVisibility::kVisible;
  }
  EVisibility Visibility() const {
    return static_cast<EVisibility>(visibility_);
  }
  void SetVisibility(EVisibility v) {
    visibility_ = static_cast<unsigned>(v);
  }
  inline void ResetVisibility() {
    visibility_ = static_cast<unsigned>(EVisibility::kVisible);
  }

  // visibility
  inline static bool InitialVisibilityIsInherited() {
    return true;
  }
  bool VisibilityIsInherited() const {
    return static_cast<bool>(visibility_is_inherited_);
  }
  void SetVisibilityIsInherited(bool v) {
    visibility_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetVisibilityIsInherited() {
    visibility_is_inherited_ = static_cast<unsigned>(true);
  }

  // VisitedLinkBackgroundColor
  inline static StyleColor InitialVisitedLinkBackgroundColor() {
    return StyleColor(Color::kTransparent);
  }
  // Getters and setters not generated

  // VisitedLinkBorderBottomColor
  inline static StyleColor InitialVisitedLinkBorderBottomColor() {
    return StyleColor::CurrentColor();
  }
  // Getters and setters not generated

  // VisitedLinkBorderLeftColor
  inline static StyleColor InitialVisitedLinkBorderLeftColor() {
    return StyleColor::CurrentColor();
  }
  // Getters and setters not generated

  // VisitedLinkBorderRightColor
  inline static StyleColor InitialVisitedLinkBorderRightColor() {
    return StyleColor::CurrentColor();
  }
  // Getters and setters not generated

  // VisitedLinkBorderTopColor
  inline static StyleColor InitialVisitedLinkBorderTopColor() {
    return StyleColor::CurrentColor();
  }
  // Getters and setters not generated

  // VisitedLinkCaretColor
  inline static Color InitialVisitedLinkCaretColor() {
    return Color();
  }
  // Getters and setters not generated

  // VisitedLinkCaretColorIsAuto
  inline static bool InitialVisitedLinkCaretColorIsAuto() {
    return true;
  }
  // Getters and setters not generated

  // VisitedLinkCaretColorIsCurrentColor
  inline static bool InitialVisitedLinkCaretColorIsCurrentColor() {
    return false;
  }
  // Getters and setters not generated

  // VisitedLinkColor
  inline static Color InitialVisitedLinkColor() {
    return Color::kBlack;
  }
  const Color& VisitedLinkColor() const {
    return inherited_data_->visited_link_color_;
  }
  void SetVisitedLinkColor(const Color& v) {
    if (!(inherited_data_->visited_link_color_ == v))
      inherited_data_.Access()->visited_link_color_ = v;
  }
  void SetVisitedLinkColor(Color&& v) {
    if (!(inherited_data_->visited_link_color_ == v))
      inherited_data_.Access()->visited_link_color_ = std::move(v);
  }
  inline void ResetVisitedLinkColor() {
    inherited_data_.Access()->visited_link_color_ = Color::kBlack;
  }

  // VisitedLinkColumnRuleColor
  inline static StyleColor InitialVisitedLinkColumnRuleColor() {
    return StyleColor::CurrentColor();
  }
  // Getters and setters not generated

  // VisitedLinkOutlineColor
  inline static StyleColor InitialVisitedLinkOutlineColor() {
    return StyleColor::CurrentColor();
  }
  // Getters and setters not generated

  // VisitedLinkTextDecorationColor
  inline static StyleColor InitialVisitedLinkTextDecorationColor() {
    return StyleColor::CurrentColor();
  }
  // Getters and setters not generated

  // VisitedLinkTextEmphasisColor
  inline static Color InitialVisitedLinkTextEmphasisColor() {
    return Color();
  }
  // Getters and setters not generated

  // VisitedLinkTextEmphasisColorIsCurrentColor
  inline static bool InitialVisitedLinkTextEmphasisColorIsCurrentColor() {
    return true;
  }
  // Getters and setters not generated

  // VisitedLinkTextFillColor
  inline static Color InitialVisitedLinkTextFillColor() {
    return Color();
  }
  // Getters and setters not generated

  // VisitedLinkTextFillColorIsCurrentColor
  inline static bool InitialVisitedLinkTextFillColorIsCurrentColor() {
    return true;
  }
  // Getters and setters not generated

  // VisitedLinkTextStrokeColor
  inline static Color InitialVisitedLinkTextStrokeColor() {
    return Color();
  }
  // Getters and setters not generated

  // VisitedLinkTextStrokeColorIsCurrentColor
  inline static bool InitialVisitedLinkTextStrokeColorIsCurrentColor() {
    return true;
  }
  // Getters and setters not generated

  // white-space
  inline static EWhiteSpace InitialWhiteSpace() {
    return EWhiteSpace::kNormal;
  }
  EWhiteSpace WhiteSpace() const {
    return static_cast<EWhiteSpace>(white_space_);
  }
  void SetWhiteSpace(EWhiteSpace v) {
    white_space_ = static_cast<unsigned>(v);
  }
  inline void ResetWhiteSpace() {
    white_space_ = static_cast<unsigned>(EWhiteSpace::kNormal);
  }

  // white-space
  inline static bool InitialWhiteSpaceIsInherited() {
    return true;
  }
  bool WhiteSpaceIsInherited() const {
    return static_cast<bool>(white_space_is_inherited_);
  }
  void SetWhiteSpaceIsInherited(bool v) {
    white_space_is_inherited_ = static_cast<unsigned>(v);
  }
  inline void ResetWhiteSpaceIsInherited() {
    white_space_is_inherited_ = static_cast<unsigned>(true);
  }

  // widows
  inline static short InitialWidows() {
    return 2;
  }
  short Widows() const {
    return rare_inherited_data_->widows_;
  }
  void SetWidows(short v) {
    if (!(rare_inherited_data_->widows_ == v))
      rare_inherited_data_.Access()->widows_ = v;
  }
  inline void ResetWidows() {
    rare_inherited_data_.Access()->widows_ = 2;
  }

  // width
  inline static Length InitialWidth() {
    return Length();
  }
  const Length& Width() const {
    return box_data_->width_;
  }
  void SetWidth(const Length& v) {
    if (!(box_data_->width_ == v))
      box_data_.Access()->width_ = v;
  }
  void SetWidth(Length&& v) {
    if (!(box_data_->width_ == v))
      box_data_.Access()->width_ = std::move(v);
  }
  inline void ResetWidth() {
    box_data_.Access()->width_ = Length();
  }

  // WillChangeContents
  inline static bool InitialWillChangeContents() {
    return false;
  }
  bool WillChangeContents() const {
    return static_cast<bool>(rare_non_inherited_data_->will_change_data_->will_change_contents_);
  }
  void SetWillChangeContents(bool v) {
    if (!(rare_non_inherited_data_->will_change_data_->will_change_contents_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->will_change_data_.Access()->will_change_contents_ = static_cast<unsigned>(v);
  }
  inline void ResetWillChangeContents() {
    rare_non_inherited_data_.Access()->will_change_data_.Access()->will_change_contents_ = static_cast<unsigned>(false);
  }

  // WillChangeProperties
  inline static Vector<CSSPropertyID> InitialWillChangeProperties() {
    return Vector<CSSPropertyID>();
  }
  const Vector<CSSPropertyID>& WillChangeProperties() const {
    return rare_non_inherited_data_->will_change_data_->will_change_properties_;
  }
  void SetWillChangeProperties(const Vector<CSSPropertyID>& v) {
    if (!(rare_non_inherited_data_->will_change_data_->will_change_properties_ == v))
      rare_non_inherited_data_.Access()->will_change_data_.Access()->will_change_properties_ = v;
  }
  void SetWillChangeProperties(Vector<CSSPropertyID>&& v) {
    if (!(rare_non_inherited_data_->will_change_data_->will_change_properties_ == v))
      rare_non_inherited_data_.Access()->will_change_data_.Access()->will_change_properties_ = std::move(v);
  }
  inline void ResetWillChangeProperties() {
    rare_non_inherited_data_.Access()->will_change_data_.Access()->will_change_properties_ = Vector<CSSPropertyID>();
  }

  // WillChangeScrollPosition
  inline static bool InitialWillChangeScrollPosition() {
    return false;
  }
  bool WillChangeScrollPosition() const {
    return static_cast<bool>(rare_non_inherited_data_->will_change_data_->will_change_scroll_position_);
  }
  void SetWillChangeScrollPosition(bool v) {
    if (!(rare_non_inherited_data_->will_change_data_->will_change_scroll_position_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->will_change_data_.Access()->will_change_scroll_position_ = static_cast<unsigned>(v);
  }
  inline void ResetWillChangeScrollPosition() {
    rare_non_inherited_data_.Access()->will_change_data_.Access()->will_change_scroll_position_ = static_cast<unsigned>(false);
  }

  // word-break
  inline static EWordBreak InitialWordBreak() {
    return EWordBreak::kNormal;
  }
  EWordBreak WordBreak() const {
    return static_cast<EWordBreak>(rare_inherited_data_->word_break_);
  }
  void SetWordBreak(EWordBreak v) {
    if (!(rare_inherited_data_->word_break_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->word_break_ = static_cast<unsigned>(v);
  }
  inline void ResetWordBreak() {
    rare_inherited_data_.Access()->word_break_ = static_cast<unsigned>(EWordBreak::kNormal);
  }

  // writing-mode
  inline static WritingMode InitialWritingMode() {
    return WritingMode::kHorizontalTb;
  }
  WritingMode GetWritingMode() const {
    return static_cast<WritingMode>(writing_mode_);
  }
  void SetWritingMode(WritingMode v) {
    writing_mode_ = static_cast<unsigned>(v);
  }
  inline void ResetWritingMode() {
    writing_mode_ = static_cast<unsigned>(WritingMode::kHorizontalTb);
  }

  // z-index
  inline static int InitialZIndex() {
    return 0;
  }
  // Getters and setters not generated

  // zoom
  inline static float InitialZoom() {
    return 1.0;
  }
  // Getters and setters not generated

 private:
  class StyleBoxData : public RefCounted<StyleBoxData> {
   public:
    static PassRefPtr<StyleBoxData> Create() {
      return AdoptRef(new StyleBoxData);
    }
    PassRefPtr<StyleBoxData> Copy() const {
      return AdoptRef(new StyleBoxData(*this));
    }
  
    bool operator==(const StyleBoxData& other) const {
      return (
        height_ == other.height_
        && max_width_ == other.max_width_
        && width_ == other.width_
        && min_height_ == other.min_height_
        && max_height_ == other.max_height_
        && min_width_ == other.min_width_
        && vertical_align_length_ == other.vertical_align_length_
        && z_index_ == other.z_index_
        && box_decoration_break_ == other.box_decoration_break_
        && box_sizing_ == other.box_sizing_
        && has_auto_z_index_ == other.has_auto_z_index_
      );
    }
    bool operator!=(const StyleBoxData& other) const { return !(*this == other); }
  
    Length height_;
    Length max_width_;
    Length width_;
    Length min_height_;
    Length max_height_;
    Length min_width_;
    Length vertical_align_length_;
    int z_index_;
    unsigned box_decoration_break_ : 1; // EBoxDecorationBreak
    unsigned box_sizing_ : 1; // EBoxSizing
    unsigned has_auto_z_index_ : 1; // bool
  
   private:
    StyleBoxData();
    StyleBoxData(const StyleBoxData&);
  };

  class StyleRareInheritedData : public RefCounted<StyleRareInheritedData> {
   public:
    static PassRefPtr<StyleRareInheritedData> Create() {
      return AdoptRef(new StyleRareInheritedData);
    }
    PassRefPtr<StyleRareInheritedData> Copy() const {
      return AdoptRef(new StyleRareInheritedData(*this));
    }
  
    bool operator==(const StyleRareInheritedData& other) const {
      return (
        hyphenation_string_ == other.hyphenation_string_
        && highlight_ == other.highlight_
        && text_emphasis_custom_mark_ == other.text_emphasis_custom_mark_
        && DataEquivalent(quotes_, other.quotes_)
        && DataEquivalent(text_shadow_, other.text_shadow_)
        && DataEquivalent(applied_text_decorations_, other.applied_text_decorations_)
        && DataEquivalent(inherited_variables_, other.inherited_variables_)
        && DataEquivalent(list_style_image_, other.list_style_image_)
        && DataEquivalent(cursor_data_, other.cursor_data_)
        && text_indent_ == other.text_indent_
        && text_size_adjust_ == other.text_size_adjust_
        && tab_size_ == other.tab_size_
        && text_stroke_width_ == other.text_stroke_width_
        && effective_zoom_ == other.effective_zoom_
        && text_fill_color_ == other.text_fill_color_
        && tap_highlight_color_ == other.tap_highlight_color_
        && text_stroke_color_ == other.text_stroke_color_
        && caret_color_ == other.caret_color_
        && text_emphasis_color_ == other.text_emphasis_color_
        && visited_link_text_stroke_color_ == other.visited_link_text_stroke_color_
        && visited_link_text_fill_color_ == other.visited_link_text_fill_color_
        && visited_link_text_emphasis_color_ == other.visited_link_text_emphasis_color_
        && visited_link_caret_color_ == other.visited_link_caret_color_
        && widows_ == other.widows_
        && orphans_ == other.orphans_
        && hyphenation_limit_before_ == other.hyphenation_limit_before_
        && hyphenation_limit_after_ == other.hyphenation_limit_after_
        && hyphenation_limit_lines_ == other.hyphenation_limit_lines_
        && line_height_step_ == other.line_height_step_
        && image_rendering_ == other.image_rendering_
        && line_break_ == other.line_break_
        && speak_ == other.speak_
        && text_align_last_ == other.text_align_last_
        && text_decoration_skip_ == other.text_decoration_skip_
        && text_emphasis_mark_ == other.text_emphasis_mark_
        && hyphens_ == other.hyphens_
        && text_justify_ == other.text_justify_
        && text_orientation_ == other.text_orientation_
        && text_security_ == other.text_security_
        && user_modify_ == other.user_modify_
        && user_select_ == other.user_select_
        && word_break_ == other.word_break_
        && caret_color_is_auto_ == other.caret_color_is_auto_
        && caret_color_is_current_color_ == other.caret_color_is_current_color_
        && overflow_wrap_ == other.overflow_wrap_
        && respect_image_orientation_ == other.respect_image_orientation_
        && ruby_position_ == other.ruby_position_
        && self_or_ancestor_has_dir_auto_attribute_ == other.self_or_ancestor_has_dir_auto_attribute_
        && subtree_is_sticky_ == other.subtree_is_sticky_
        && subtree_will_change_contents_ == other.subtree_will_change_contents_
        && text_combine_ == other.text_combine_
        && text_emphasis_color_is_current_color_ == other.text_emphasis_color_is_current_color_
        && text_emphasis_fill_ == other.text_emphasis_fill_
        && text_emphasis_position_ == other.text_emphasis_position_
        && text_fill_color_is_current_color_ == other.text_fill_color_is_current_color_
        && text_indent_line_ == other.text_indent_line_
        && text_indent_type_ == other.text_indent_type_
        && text_stroke_color_is_current_color_ == other.text_stroke_color_is_current_color_
        && text_underline_position_ == other.text_underline_position_
        && visited_link_caret_color_is_auto_ == other.visited_link_caret_color_is_auto_
        && visited_link_caret_color_is_current_color_ == other.visited_link_caret_color_is_current_color_
        && visited_link_text_emphasis_color_is_current_color_ == other.visited_link_text_emphasis_color_is_current_color_
        && visited_link_text_fill_color_is_current_color_ == other.visited_link_text_fill_color_is_current_color_
        && visited_link_text_stroke_color_is_current_color_ == other.visited_link_text_stroke_color_is_current_color_
      );
    }
    bool operator!=(const StyleRareInheritedData& other) const { return !(*this == other); }
  
    AtomicString hyphenation_string_;
    AtomicString highlight_;
    AtomicString text_emphasis_custom_mark_;
    RefPtr<QuotesData> quotes_;
    RefPtr<ShadowList> text_shadow_;
    RefPtr<AppliedTextDecorationList> applied_text_decorations_;
    RefPtr<StyleInheritedVariables> inherited_variables_;
    Persistent<StyleImage> list_style_image_;
    Persistent<CursorList> cursor_data_;
    Length text_indent_;
    TextSizeAdjust text_size_adjust_;
    TabSize tab_size_;
    float text_stroke_width_;
    float effective_zoom_;
    Color text_fill_color_;
    Color tap_highlight_color_;
    Color text_stroke_color_;
    Color caret_color_;
    Color text_emphasis_color_;
    Color visited_link_text_stroke_color_;
    Color visited_link_text_fill_color_;
    Color visited_link_text_emphasis_color_;
    Color visited_link_caret_color_;
    short widows_;
    short orphans_;
    short hyphenation_limit_before_;
    short hyphenation_limit_after_;
    short hyphenation_limit_lines_;
    uint8_t line_height_step_;
    unsigned image_rendering_ : 3; // EImageRendering
    unsigned line_break_ : 3; // LineBreak
    unsigned speak_ : 3; // ESpeak
    unsigned text_align_last_ : 3; // ETextAlignLast
    unsigned text_decoration_skip_ : 3; // TextDecorationSkip
    unsigned text_emphasis_mark_ : 3; // TextEmphasisMark
    unsigned hyphens_ : 2; // Hyphens
    unsigned text_justify_ : 2; // TextJustify
    unsigned text_orientation_ : 2; // ETextOrientation
    unsigned text_security_ : 2; // ETextSecurity
    unsigned user_modify_ : 2; // EUserModify
    unsigned user_select_ : 2; // EUserSelect
    unsigned word_break_ : 2; // EWordBreak
    unsigned caret_color_is_auto_ : 1; // bool
    unsigned caret_color_is_current_color_ : 1; // bool
    unsigned overflow_wrap_ : 1; // EOverflowWrap
    unsigned respect_image_orientation_ : 1; // bool
    unsigned ruby_position_ : 1; // RubyPosition
    unsigned self_or_ancestor_has_dir_auto_attribute_ : 1; // bool
    unsigned subtree_is_sticky_ : 1; // bool
    unsigned subtree_will_change_contents_ : 1; // bool
    unsigned text_combine_ : 1; // ETextCombine
    unsigned text_emphasis_color_is_current_color_ : 1; // bool
    unsigned text_emphasis_fill_ : 1; // TextEmphasisFill
    unsigned text_emphasis_position_ : 1; // TextEmphasisPosition
    unsigned text_fill_color_is_current_color_ : 1; // bool
    unsigned text_indent_line_ : 1; // TextIndentLine
    unsigned text_indent_type_ : 1; // TextIndentType
    unsigned text_stroke_color_is_current_color_ : 1; // bool
    unsigned text_underline_position_ : 1; // TextUnderlinePosition
    unsigned visited_link_caret_color_is_auto_ : 1; // bool
    unsigned visited_link_caret_color_is_current_color_ : 1; // bool
    unsigned visited_link_text_emphasis_color_is_current_color_ : 1; // bool
    unsigned visited_link_text_fill_color_is_current_color_ : 1; // bool
    unsigned visited_link_text_stroke_color_is_current_color_ : 1; // bool
  
   private:
    StyleRareInheritedData();
    StyleRareInheritedData(const StyleRareInheritedData&);
  };

  class StyleFlexibleBoxData : public RefCounted<StyleFlexibleBoxData> {
   public:
    static PassRefPtr<StyleFlexibleBoxData> Create() {
      return AdoptRef(new StyleFlexibleBoxData);
    }
    PassRefPtr<StyleFlexibleBoxData> Copy() const {
      return AdoptRef(new StyleFlexibleBoxData(*this));
    }
  
    bool operator==(const StyleFlexibleBoxData& other) const {
      return (
        flex_basis_ == other.flex_basis_
        && flex_shrink_ == other.flex_shrink_
        && flex_grow_ == other.flex_grow_
        && flex_direction_ == other.flex_direction_
        && flex_wrap_ == other.flex_wrap_
      );
    }
    bool operator!=(const StyleFlexibleBoxData& other) const { return !(*this == other); }
  
    Length flex_basis_;
    float flex_shrink_;
    float flex_grow_;
    unsigned flex_direction_ : 2; // EFlexDirection
    unsigned flex_wrap_ : 2; // EFlexWrap
  
   private:
    StyleFlexibleBoxData();
    StyleFlexibleBoxData(const StyleFlexibleBoxData&);
  };
  
  class StyleWillChangeData : public RefCounted<StyleWillChangeData> {
   public:
    static PassRefPtr<StyleWillChangeData> Create() {
      return AdoptRef(new StyleWillChangeData);
    }
    PassRefPtr<StyleWillChangeData> Copy() const {
      return AdoptRef(new StyleWillChangeData(*this));
    }
  
    bool operator==(const StyleWillChangeData& other) const {
      return (
        will_change_properties_ == other.will_change_properties_
        && will_change_contents_ == other.will_change_contents_
        && will_change_scroll_position_ == other.will_change_scroll_position_
      );
    }
    bool operator!=(const StyleWillChangeData& other) const { return !(*this == other); }
  
    Vector<CSSPropertyID> will_change_properties_;
    unsigned will_change_contents_ : 1; // bool
    unsigned will_change_scroll_position_ : 1; // bool
  
   private:
    StyleWillChangeData();
    StyleWillChangeData(const StyleWillChangeData&);
  };
  
  class StyleBackdropFilterOpsData : public RefCounted<StyleBackdropFilterOpsData> {
   public:
    static PassRefPtr<StyleBackdropFilterOpsData> Create() {
      return AdoptRef(new StyleBackdropFilterOpsData);
    }
    PassRefPtr<StyleBackdropFilterOpsData> Copy() const {
      return AdoptRef(new StyleBackdropFilterOpsData(*this));
    }
  
    bool operator==(const StyleBackdropFilterOpsData& other) const {
      return (
        DataEquivalent(backdrop_filter_, other.backdrop_filter_)
      );
    }
    bool operator!=(const StyleBackdropFilterOpsData& other) const { return !(*this == other); }
  
    Persistent<StyleFilterData> backdrop_filter_;
  
   private:
    StyleBackdropFilterOpsData();
    StyleBackdropFilterOpsData(const StyleBackdropFilterOpsData&);
  };
  
  class StyleGridItemData : public RefCounted<StyleGridItemData> {
   public:
    static PassRefPtr<StyleGridItemData> Create() {
      return AdoptRef(new StyleGridItemData);
    }
    PassRefPtr<StyleGridItemData> Copy() const {
      return AdoptRef(new StyleGridItemData(*this));
    }
  
    bool operator==(const StyleGridItemData& other) const {
      return (
        grid_row_start_ == other.grid_row_start_
        && grid_row_end_ == other.grid_row_end_
        && grid_column_start_ == other.grid_column_start_
        && grid_column_end_ == other.grid_column_end_
      );
    }
    bool operator!=(const StyleGridItemData& other) const { return !(*this == other); }
  
    GridPosition grid_row_start_;
    GridPosition grid_row_end_;
    GridPosition grid_column_start_;
    GridPosition grid_column_end_;
  
   private:
    StyleGridItemData();
    StyleGridItemData(const StyleGridItemData&);
  };
  
  class StyleScrollSnapData : public RefCounted<StyleScrollSnapData> {
   public:
    static PassRefPtr<StyleScrollSnapData> Create() {
      return AdoptRef(new StyleScrollSnapData);
    }
    PassRefPtr<StyleScrollSnapData> Copy() const {
      return AdoptRef(new StyleScrollSnapData(*this));
    }
  
    bool operator==(const StyleScrollSnapData& other) const {
      return (
        scroll_snap_margin_right_ == other.scroll_snap_margin_right_
        && scroll_snap_margin_left_ == other.scroll_snap_margin_left_
        && scroll_padding_bottom_ == other.scroll_padding_bottom_
        && scroll_padding_top_ == other.scroll_padding_top_
        && scroll_snap_margin_top_ == other.scroll_snap_margin_top_
        && scroll_snap_margin_bottom_ == other.scroll_snap_margin_bottom_
        && scroll_padding_left_ == other.scroll_padding_left_
        && scroll_padding_right_ == other.scroll_padding_right_
        && scroll_snap_type_ == other.scroll_snap_type_
        && scroll_snap_align_ == other.scroll_snap_align_
      );
    }
    bool operator!=(const StyleScrollSnapData& other) const { return !(*this == other); }
  
    Length scroll_snap_margin_right_;
    Length scroll_snap_margin_left_;
    Length scroll_padding_bottom_;
    Length scroll_padding_top_;
    Length scroll_snap_margin_top_;
    Length scroll_snap_margin_bottom_;
    Length scroll_padding_left_;
    Length scroll_padding_right_;
    ScrollSnapType scroll_snap_type_;
    ScrollSnapAlign scroll_snap_align_;
  
   private:
    StyleScrollSnapData();
    StyleScrollSnapData(const StyleScrollSnapData&);
  };
  
  class StyleTransformData : public RefCounted<StyleTransformData> {
   public:
    static PassRefPtr<StyleTransformData> Create() {
      return AdoptRef(new StyleTransformData);
    }
    PassRefPtr<StyleTransformData> Copy() const {
      return AdoptRef(new StyleTransformData(*this));
    }
  
    bool operator==(const StyleTransformData& other) const {
      return (
        transform_ == other.transform_
        && DataEquivalent(scale_, other.scale_)
        && DataEquivalent(offset_path_, other.offset_path_)
        && DataEquivalent(rotate_, other.rotate_)
        && DataEquivalent(translate_, other.translate_)
        && offset_rotate_ == other.offset_rotate_
        && transform_origin_ == other.transform_origin_
        && offset_position_ == other.offset_position_
        && offset_anchor_ == other.offset_anchor_
        && offset_distance_ == other.offset_distance_
      );
    }
    bool operator!=(const StyleTransformData& other) const { return !(*this == other); }
  
    TransformOperations transform_;
    RefPtr<ScaleTransformOperation> scale_;
    RefPtr<BasicShape> offset_path_;
    RefPtr<RotateTransformOperation> rotate_;
    RefPtr<TranslateTransformOperation> translate_;
    StyleOffsetRotation offset_rotate_;
    TransformOrigin transform_origin_;
    LengthPoint offset_position_;
    LengthPoint offset_anchor_;
    Length offset_distance_;
  
   private:
    StyleTransformData();
    StyleTransformData(const StyleTransformData&);
  };
  
  class StyleMultiColData : public RefCounted<StyleMultiColData> {
   public:
    static PassRefPtr<StyleMultiColData> Create() {
      return AdoptRef(new StyleMultiColData);
    }
    PassRefPtr<StyleMultiColData> Copy() const {
      return AdoptRef(new StyleMultiColData(*this));
    }
  
    bool operator==(const StyleMultiColData& other) const {
      return (
        column_gap_ == other.column_gap_
        && column_width_ == other.column_width_
        && visited_link_column_rule_color_ == other.visited_link_column_rule_color_
        && column_rule_color_ == other.column_rule_color_
        && column_rule_width_ == other.column_rule_width_
        && column_count_ == other.column_count_
        && column_rule_style_ == other.column_rule_style_
        && column_auto_count_ == other.column_auto_count_
        && column_auto_width_ == other.column_auto_width_
        && column_fill_ == other.column_fill_
        && column_normal_gap_ == other.column_normal_gap_
        && column_rule_color_is_current_color_ == other.column_rule_color_is_current_color_
        && column_span_ == other.column_span_
      );
    }
    bool operator!=(const StyleMultiColData& other) const { return !(*this == other); }
  
    float column_gap_;
    float column_width_;
    StyleColor visited_link_column_rule_color_;
    Color column_rule_color_;
    LayoutUnit column_rule_width_;
    unsigned short column_count_;
    unsigned column_rule_style_ : 4; // EBorderStyle
    unsigned column_auto_count_ : 1; // bool
    unsigned column_auto_width_ : 1; // bool
    unsigned column_fill_ : 1; // EColumnFill
    unsigned column_normal_gap_ : 1; // bool
    unsigned column_rule_color_is_current_color_ : 1; // bool
    unsigned column_span_ : 1; // EColumnSpan
  
   private:
    StyleMultiColData();
    StyleMultiColData(const StyleMultiColData&);
  };
  
  class StyleGridData : public RefCounted<StyleGridData> {
   public:
    static PassRefPtr<StyleGridData> Create() {
      return AdoptRef(new StyleGridData);
    }
    PassRefPtr<StyleGridData> Copy() const {
      return AdoptRef(new StyleGridData(*this));
    }
  
    bool operator==(const StyleGridData& other) const {
      return (
        named_grid_column_lines_ == other.named_grid_column_lines_
        && named_grid_row_lines_ == other.named_grid_row_lines_
        && auto_repeat_named_grid_column_lines_ == other.auto_repeat_named_grid_column_lines_
        && auto_repeat_named_grid_row_lines_ == other.auto_repeat_named_grid_row_lines_
        && ordered_named_grid_column_lines_ == other.ordered_named_grid_column_lines_
        && ordered_named_grid_row_lines_ == other.ordered_named_grid_row_lines_
        && auto_repeat_ordered_named_grid_column_lines_ == other.auto_repeat_ordered_named_grid_column_lines_
        && auto_repeat_ordered_named_grid_row_lines_ == other.auto_repeat_ordered_named_grid_row_lines_
        && named_grid_area_ == other.named_grid_area_
        && grid_auto_rows_ == other.grid_auto_rows_
        && grid_template_rows_ == other.grid_template_rows_
        && grid_template_columns_ == other.grid_template_columns_
        && grid_auto_columns_ == other.grid_auto_columns_
        && grid_auto_repeat_columns_ == other.grid_auto_repeat_columns_
        && grid_auto_repeat_rows_ == other.grid_auto_repeat_rows_
        && grid_row_gap_ == other.grid_row_gap_
        && grid_column_gap_ == other.grid_column_gap_
        && named_grid_area_row_count_ == other.named_grid_area_row_count_
        && named_grid_area_column_count_ == other.named_grid_area_column_count_
        && grid_auto_repeat_columns_insertion_point_ == other.grid_auto_repeat_columns_insertion_point_
        && grid_auto_repeat_rows_insertion_point_ == other.grid_auto_repeat_rows_insertion_point_
        && grid_auto_flow_ == other.grid_auto_flow_
        && grid_auto_repeat_columns_type_ == other.grid_auto_repeat_columns_type_
        && grid_auto_repeat_rows_type_ == other.grid_auto_repeat_rows_type_
      );
    }
    bool operator!=(const StyleGridData& other) const { return !(*this == other); }
  
    NamedGridLinesMap named_grid_column_lines_;
    NamedGridLinesMap named_grid_row_lines_;
    NamedGridLinesMap auto_repeat_named_grid_column_lines_;
    NamedGridLinesMap auto_repeat_named_grid_row_lines_;
    OrderedNamedGridLines ordered_named_grid_column_lines_;
    OrderedNamedGridLines ordered_named_grid_row_lines_;
    OrderedNamedGridLines auto_repeat_ordered_named_grid_column_lines_;
    OrderedNamedGridLines auto_repeat_ordered_named_grid_row_lines_;
    NamedGridAreaMap named_grid_area_;
    Vector<GridTrackSize> grid_auto_rows_;
    Vector<GridTrackSize> grid_template_rows_;
    Vector<GridTrackSize> grid_template_columns_;
    Vector<GridTrackSize> grid_auto_columns_;
    Vector<GridTrackSize> grid_auto_repeat_columns_;
    Vector<GridTrackSize> grid_auto_repeat_rows_;
    Length grid_row_gap_;
    Length grid_column_gap_;
    size_t named_grid_area_row_count_;
    size_t named_grid_area_column_count_;
    size_t grid_auto_repeat_columns_insertion_point_;
    size_t grid_auto_repeat_rows_insertion_point_;
    unsigned grid_auto_flow_ : 4; // GridAutoFlow
    unsigned grid_auto_repeat_columns_type_ : 2; // AutoRepeatType
    unsigned grid_auto_repeat_rows_type_ : 2; // AutoRepeatType
  
   private:
    StyleGridData();
    StyleGridData(const StyleGridData&);
  };
  
  class StyleFilterOpsData : public RefCounted<StyleFilterOpsData> {
   public:
    static PassRefPtr<StyleFilterOpsData> Create() {
      return AdoptRef(new StyleFilterOpsData);
    }
    PassRefPtr<StyleFilterOpsData> Copy() const {
      return AdoptRef(new StyleFilterOpsData(*this));
    }
  
    bool operator==(const StyleFilterOpsData& other) const {
      return (
        DataEquivalent(filter_, other.filter_)
      );
    }
    bool operator!=(const StyleFilterOpsData& other) const { return !(*this == other); }
  
    Persistent<StyleFilterData> filter_;
  
   private:
    StyleFilterOpsData();
    StyleFilterOpsData(const StyleFilterOpsData&);
  };
  
  class StyleDeprecatedFlexibleBoxData : public RefCounted<StyleDeprecatedFlexibleBoxData> {
   public:
    static PassRefPtr<StyleDeprecatedFlexibleBoxData> Create() {
      return AdoptRef(new StyleDeprecatedFlexibleBoxData);
    }
    PassRefPtr<StyleDeprecatedFlexibleBoxData> Copy() const {
      return AdoptRef(new StyleDeprecatedFlexibleBoxData(*this));
    }
  
    bool operator==(const StyleDeprecatedFlexibleBoxData& other) const {
      return (
        box_flex_ == other.box_flex_
        && box_ordinal_group_ == other.box_ordinal_group_
        && box_flex_group_ == other.box_flex_group_
        && box_align_ == other.box_align_
        && box_pack_ == other.box_pack_
        && box_lines_ == other.box_lines_
        && box_orient_ == other.box_orient_
      );
    }
    bool operator!=(const StyleDeprecatedFlexibleBoxData& other) const { return !(*this == other); }
  
    float box_flex_;
    unsigned box_ordinal_group_;
    unsigned box_flex_group_;
    unsigned box_align_ : 3; // EBoxAlignment
    unsigned box_pack_ : 2; // EBoxPack
    unsigned box_lines_ : 1; // EBoxLines
    unsigned box_orient_ : 1; // EBoxOrient
  
   private:
    StyleDeprecatedFlexibleBoxData();
    StyleDeprecatedFlexibleBoxData(const StyleDeprecatedFlexibleBoxData&);
  };
  
  class StyleRareNonInheritedData : public RefCounted<StyleRareNonInheritedData> {
   public:
    static PassRefPtr<StyleRareNonInheritedData> Create() {
      return AdoptRef(new StyleRareNonInheritedData);
    }
    PassRefPtr<StyleRareNonInheritedData> Copy() const {
      return AdoptRef(new StyleRareNonInheritedData(*this));
    }
  
    bool operator==(const StyleRareNonInheritedData& other) const {
      return (
        flexible_box_data_ == other.flexible_box_data_
        && will_change_data_ == other.will_change_data_
        && backdrop_filter_ops_data_ == other.backdrop_filter_ops_data_
        && grid_item_data_ == other.grid_item_data_
        && scroll_snap_data_ == other.scroll_snap_data_
        && transform_data_ == other.transform_data_
        && multi_col_data_ == other.multi_col_data_
        && grid_data_ == other.grid_data_
        && filter_ops_data_ == other.filter_ops_data_
        && deprecated_flexible_box_data_ == other.deprecated_flexible_box_data_
        && DataEquivalent(clip_path_, other.clip_path_)
        && DataEquivalent(box_reflect_, other.box_reflect_)
        && DataEquivalent(box_shadow_, other.box_shadow_)
        && DataEquivalent(shape_outside_, other.shape_outside_)
        && DataEquivalent(content_, other.content_)
        && DataEquivalent(counter_directives_, other.counter_directives_)
        && DataEquivalent(animations_, other.animations_)
        && DataEquivalent(transitions_, other.transitions_)
        && DataEquivalent(non_inherited_variables_, other.non_inherited_variables_)
        && callback_selectors_ == other.callback_selectors_
        && mask_ == other.mask_
        && mask_box_image_ == other.mask_box_image_
        && page_size_ == other.page_size_
        && perspective_origin_ == other.perspective_origin_
        && object_position_ == other.object_position_
        && shape_margin_ == other.shape_margin_
        && shape_image_threshold_ == other.shape_image_threshold_
        && opacity_ == other.opacity_
        && perspective_ == other.perspective_
        && text_decoration_color_ == other.text_decoration_color_
        && visited_link_text_decoration_color_ == other.visited_link_text_decoration_color_
        && visited_link_background_color_ == other.visited_link_background_color_
        && visited_link_outline_color_ == other.visited_link_outline_color_
        && visited_link_border_left_color_ == other.visited_link_border_left_color_
        && visited_link_border_right_color_ == other.visited_link_border_right_color_
        && visited_link_border_top_color_ == other.visited_link_border_top_color_
        && visited_link_border_bottom_color_ == other.visited_link_border_bottom_color_
        && outline_color_ == other.outline_color_
        && outline_width_ == other.outline_width_
        && line_clamp_ == other.line_clamp_
        && order_ == other.order_
        && outline_offset_ == other.outline_offset_
        && align_self_ == other.align_self_
        && justify_self_ == other.justify_self_
        && justify_items_ == other.justify_items_
        && align_items_ == other.align_items_
        && align_content_ == other.align_content_
        && justify_content_ == other.justify_content_
        && appearance_ == other.appearance_
        && touch_action_ == other.touch_action_
        && blend_mode_ == other.blend_mode_
        && contain_ == other.contain_
        && outline_style_ == other.outline_style_
        && object_fit_ == other.object_fit_
        && text_decoration_style_ == other.text_decoration_style_
        && draggable_region_mode_ == other.draggable_region_mode_
        && margin_after_collapse_ == other.margin_after_collapse_
        && margin_before_collapse_ == other.margin_before_collapse_
        && page_size_type_ == other.page_size_type_
        && resize_ == other.resize_
        && scroll_behavior_ == other.scroll_behavior_
        && user_drag_ == other.user_drag_
        && backface_visibility_ == other.backface_visibility_
        && has_author_background_ == other.has_author_background_
        && has_author_border_ == other.has_author_border_
        && has_current_backdrop_filter_animation_ == other.has_current_backdrop_filter_animation_
        && has_current_filter_animation_ == other.has_current_filter_animation_
        && has_current_opacity_animation_ == other.has_current_opacity_animation_
        && has_current_transform_animation_ == other.has_current_transform_animation_
        && has_inline_transform_ == other.has_inline_transform_
        && is_stacking_context_ == other.is_stacking_context_
        && isolation_ == other.isolation_
        && outline_color_is_current_color_ == other.outline_color_is_current_color_
        && outline_style_is_auto_ == other.outline_style_is_auto_
        && requires_accelerated_compositing_for_external_reasons_ == other.requires_accelerated_compositing_for_external_reasons_
        && text_overflow_ == other.text_overflow_
        && transform_style_3d_ == other.transform_style_3d_
      );
    }
    bool operator!=(const StyleRareNonInheritedData& other) const { return !(*this == other); }
  
    DataRef<StyleFlexibleBoxData> flexible_box_data_;
    DataRef<StyleWillChangeData> will_change_data_;
    DataRef<StyleBackdropFilterOpsData> backdrop_filter_ops_data_;
    DataRef<StyleGridItemData> grid_item_data_;
    DataRef<StyleScrollSnapData> scroll_snap_data_;
    DataRef<StyleTransformData> transform_data_;
    DataRef<StyleMultiColData> multi_col_data_;
    DataRef<StyleGridData> grid_data_;
    DataRef<StyleFilterOpsData> filter_ops_data_;
    DataRef<StyleDeprecatedFlexibleBoxData> deprecated_flexible_box_data_;
    RefPtr<ClipPathOperation> clip_path_;
    RefPtr<StyleReflection> box_reflect_;
    RefPtr<ShadowList> box_shadow_;
    Persistent<ShapeValue> shape_outside_;
    Persistent<ContentData> content_;
    std::unique_ptr<CounterDirectiveMap> counter_directives_;
    std::unique_ptr<CSSAnimationData> animations_;
    std::unique_ptr<CSSTransitionData> transitions_;
    std::unique_ptr<PaintImages> paint_images_;
    std::unique_ptr<StyleNonInheritedVariables> non_inherited_variables_;
    Vector<String> callback_selectors_;
    FillLayer mask_;
    NinePieceImage mask_box_image_;
    FloatSize page_size_;
    LengthPoint perspective_origin_;
    LengthPoint object_position_;
    Length shape_margin_;
    float shape_image_threshold_;
    float opacity_;
    float perspective_;
    StyleColor text_decoration_color_;
    StyleColor visited_link_text_decoration_color_;
    StyleColor visited_link_background_color_;
    StyleColor visited_link_outline_color_;
    StyleColor visited_link_border_left_color_;
    StyleColor visited_link_border_right_color_;
    StyleColor visited_link_border_top_color_;
    StyleColor visited_link_border_bottom_color_;
    Color outline_color_;
    LayoutUnit outline_width_;
    LineClampValue line_clamp_;
    int order_;
    int outline_offset_;
    StyleSelfAlignmentData align_self_;
    StyleSelfAlignmentData justify_self_;
    StyleSelfAlignmentData justify_items_;
    StyleSelfAlignmentData align_items_;
    StyleContentAlignmentData align_content_;
    StyleContentAlignmentData justify_content_;
    unsigned appearance_ : 6; // ControlPart
    unsigned touch_action_ : 6; // TouchAction
    unsigned blend_mode_ : 4; // WebBlendMode
    unsigned contain_ : 4; // Containment
    unsigned outline_style_ : 4; // EBorderStyle
    unsigned object_fit_ : 3; // EObjectFit
    unsigned text_decoration_style_ : 3; // ETextDecorationStyle
    unsigned draggable_region_mode_ : 2; // EDraggableRegionMode
    unsigned margin_after_collapse_ : 2; // EMarginCollapse
    unsigned margin_before_collapse_ : 2; // EMarginCollapse
    unsigned page_size_type_ : 2; // EPageSizeType
    unsigned resize_ : 2; // EResize
    unsigned scroll_behavior_ : 2; // ScrollBehavior
    unsigned user_drag_ : 2; // EUserDrag
    unsigned backface_visibility_ : 1; // EBackfaceVisibility
    unsigned has_author_background_ : 1; // bool
    unsigned has_author_border_ : 1; // bool
    unsigned has_current_backdrop_filter_animation_ : 1; // bool
    unsigned has_current_filter_animation_ : 1; // bool
    unsigned has_current_opacity_animation_ : 1; // bool
    unsigned has_current_transform_animation_ : 1; // bool
    unsigned has_inline_transform_ : 1; // bool
    unsigned is_running_backdrop_filter_animation_on_compositor_ : 1; // bool
    unsigned is_running_filter_animation_on_compositor_ : 1; // bool
    unsigned is_running_opacity_animation_on_compositor_ : 1; // bool
    unsigned is_running_transform_animation_on_compositor_ : 1; // bool
    unsigned is_stacking_context_ : 1; // bool
    unsigned isolation_ : 1; // EIsolation
    unsigned outline_color_is_current_color_ : 1; // bool
    unsigned outline_style_is_auto_ : 1; // bool
    unsigned requires_accelerated_compositing_for_external_reasons_ : 1; // bool
    unsigned text_overflow_ : 1; // ETextOverflow
    unsigned transform_style_3d_ : 1; // ETransformStyle3D
  
   private:
    StyleRareNonInheritedData();
    StyleRareNonInheritedData(const StyleRareNonInheritedData&);
  };

  class StyleSurroundData : public RefCounted<StyleSurroundData> {
   public:
    static PassRefPtr<StyleSurroundData> Create() {
      return AdoptRef(new StyleSurroundData);
    }
    PassRefPtr<StyleSurroundData> Copy() const {
      return AdoptRef(new StyleSurroundData(*this));
    }
  
    bool operator==(const StyleSurroundData& other) const {
      return (
        border_image_ == other.border_image_
        && border_bottom_left_radius_ == other.border_bottom_left_radius_
        && border_top_right_radius_ == other.border_top_right_radius_
        && border_bottom_right_radius_ == other.border_bottom_right_radius_
        && border_top_left_radius_ == other.border_top_left_radius_
        && padding_bottom_ == other.padding_bottom_
        && margin_right_ == other.margin_right_
        && padding_right_ == other.padding_right_
        && bottom_ == other.bottom_
        && top_ == other.top_
        && margin_top_ == other.margin_top_
        && padding_left_ == other.padding_left_
        && left_ == other.left_
        && margin_bottom_ == other.margin_bottom_
        && right_ == other.right_
        && margin_left_ == other.margin_left_
        && padding_top_ == other.padding_top_
        && border_right_color_ == other.border_right_color_
        && border_left_color_ == other.border_left_color_
        && border_top_color_ == other.border_top_color_
        && border_bottom_color_ == other.border_bottom_color_
        && border_right_width_ == other.border_right_width_
        && border_left_width_ == other.border_left_width_
        && border_top_width_ == other.border_top_width_
        && border_bottom_width_ == other.border_bottom_width_
        && border_bottom_style_ == other.border_bottom_style_
        && border_left_style_ == other.border_left_style_
        && border_right_style_ == other.border_right_style_
        && border_top_style_ == other.border_top_style_
        && border_bottom_color_is_current_color_ == other.border_bottom_color_is_current_color_
        && border_left_color_is_current_color_ == other.border_left_color_is_current_color_
        && border_right_color_is_current_color_ == other.border_right_color_is_current_color_
        && border_top_color_is_current_color_ == other.border_top_color_is_current_color_
      );
    }
    bool operator!=(const StyleSurroundData& other) const { return !(*this == other); }
  
    NinePieceImage border_image_;
    LengthSize border_bottom_left_radius_;
    LengthSize border_top_right_radius_;
    LengthSize border_bottom_right_radius_;
    LengthSize border_top_left_radius_;
    Length padding_bottom_;
    Length margin_right_;
    Length padding_right_;
    Length bottom_;
    Length top_;
    Length margin_top_;
    Length padding_left_;
    Length left_;
    Length margin_bottom_;
    Length right_;
    Length margin_left_;
    Length padding_top_;
    Color border_right_color_;
    Color border_left_color_;
    Color border_top_color_;
    Color border_bottom_color_;
    LayoutUnit border_right_width_;
    LayoutUnit border_left_width_;
    LayoutUnit border_top_width_;
    LayoutUnit border_bottom_width_;
    unsigned border_bottom_style_ : 4; // EBorderStyle
    unsigned border_left_style_ : 4; // EBorderStyle
    unsigned border_right_style_ : 4; // EBorderStyle
    unsigned border_top_style_ : 4; // EBorderStyle
    unsigned border_bottom_color_is_current_color_ : 1; // bool
    unsigned border_left_color_is_current_color_ : 1; // bool
    unsigned border_right_color_is_current_color_ : 1; // bool
    unsigned border_top_color_is_current_color_ : 1; // bool
  
   private:
    StyleSurroundData();
    StyleSurroundData(const StyleSurroundData&);
  };

  class StyleVisualData : public RefCounted<StyleVisualData> {
   public:
    static PassRefPtr<StyleVisualData> Create() {
      return AdoptRef(new StyleVisualData);
    }
    PassRefPtr<StyleVisualData> Copy() const {
      return AdoptRef(new StyleVisualData(*this));
    }
  
    bool operator==(const StyleVisualData& other) const {
      return (
        clip_ == other.clip_
        && zoom_ == other.zoom_
        && text_decoration_ == other.text_decoration_
        && has_auto_clip_ == other.has_auto_clip_
      );
    }
    bool operator!=(const StyleVisualData& other) const { return !(*this == other); }
  
    LengthBox clip_;
    float zoom_;
    unsigned text_decoration_ : 4; // TextDecoration
    unsigned has_auto_clip_ : 1; // bool
  
   private:
    StyleVisualData();
    StyleVisualData(const StyleVisualData&);
  };

  class StyleBackgroundData : public RefCounted<StyleBackgroundData> {
   public:
    static PassRefPtr<StyleBackgroundData> Create() {
      return AdoptRef(new StyleBackgroundData);
    }
    PassRefPtr<StyleBackgroundData> Copy() const {
      return AdoptRef(new StyleBackgroundData(*this));
    }
  
    bool operator==(const StyleBackgroundData& other) const {
      return (
        background_ == other.background_
        && background_color_ == other.background_color_
      );
    }
    bool operator!=(const StyleBackgroundData& other) const { return !(*this == other); }
  
    FillLayer background_;
    StyleColor background_color_;
  
   private:
    StyleBackgroundData();
    StyleBackgroundData(const StyleBackgroundData&);
  };

  class StyleInheritedData : public RefCounted<StyleInheritedData> {
   public:
    static PassRefPtr<StyleInheritedData> Create() {
      return AdoptRef(new StyleInheritedData);
    }
    PassRefPtr<StyleInheritedData> Copy() const {
      return AdoptRef(new StyleInheritedData(*this));
    }
  
    bool operator==(const StyleInheritedData& other) const {
      return (
        font_ == other.font_
        && line_height_ == other.line_height_
        && text_autosizing_multiplier_ == other.text_autosizing_multiplier_
        && color_ == other.color_
        && visited_link_color_ == other.visited_link_color_
        && horizontal_border_spacing_ == other.horizontal_border_spacing_
        && vertical_border_spacing_ == other.vertical_border_spacing_
      );
    }
    bool operator!=(const StyleInheritedData& other) const { return !(*this == other); }
  
    Font font_;
    Length line_height_;
    float text_autosizing_multiplier_;
    Color color_;
    Color visited_link_color_;
    short horizontal_border_spacing_;
    short vertical_border_spacing_;
  
   private:
    StyleInheritedData();
    StyleInheritedData(const StyleInheritedData&);
  };


 protected:
  // Constructor and destructor are protected so that only the parent class ComputedStyle
  // can instantiate this class.
  ComputedStyleBase();

  // AffectedByActive
  void SetAffectedByActiveInternal(bool v) {
    affected_by_active_ = static_cast<unsigned>(v);
  }

  // AffectedByDrag
  void SetAffectedByDragInternal(bool v) {
    affected_by_drag_ = static_cast<unsigned>(v);
  }

  // AffectedByFocusWithin
  void SetAffectedByFocusWithinInternal(bool v) {
    affected_by_focus_within_ = static_cast<unsigned>(v);
  }

  // AffectedByHover
  void SetAffectedByHoverInternal(bool v) {
    affected_by_hover_ = static_cast<unsigned>(v);
  }

  // align-content
  StyleContentAlignmentData& MutableAlignContentInternal() {
    return rare_non_inherited_data_.Access()->align_content_;
  }

  // align-items
  StyleSelfAlignmentData& MutableAlignItemsInternal() {
    return rare_non_inherited_data_.Access()->align_items_;
  }

  // align-self
  StyleSelfAlignmentData& MutableAlignSelfInternal() {
    return rare_non_inherited_data_.Access()->align_self_;
  }

  // Animations
  const std::unique_ptr<CSSAnimationData>& AnimationsInternal() const {
    return rare_non_inherited_data_->animations_;
  }
  void SetAnimationsInternal(std::unique_ptr<CSSAnimationData>&& v) {
    if (!(rare_non_inherited_data_->animations_ == v))
      rare_non_inherited_data_.Access()->animations_ = std::move(v);
  }
  std::unique_ptr<CSSAnimationData>& MutableAnimationsInternal() {
    return rare_non_inherited_data_.Access()->animations_;
  }

  // -webkit-appearance
  ControlPart AppearanceInternal() const {
    return static_cast<ControlPart>(rare_non_inherited_data_->appearance_);
  }
  void SetAppearanceInternal(ControlPart v) {
    if (!(rare_non_inherited_data_->appearance_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->appearance_ = static_cast<unsigned>(v);
  }

  // AppliedTextDecorations
  const RefPtr<AppliedTextDecorationList>& AppliedTextDecorationsInternal() const {
    return rare_inherited_data_->applied_text_decorations_;
  }
  void SetAppliedTextDecorationsInternal(RefPtr<AppliedTextDecorationList>&& v) {
    if (!(rare_inherited_data_->applied_text_decorations_ == v))
      rare_inherited_data_.Access()->applied_text_decorations_ = std::move(v);
  }
  RefPtr<AppliedTextDecorationList>& MutableAppliedTextDecorationsInternal() {
    return rare_inherited_data_.Access()->applied_text_decorations_;
  }

  // AutoRepeatNamedGridColumnLines
  NamedGridLinesMap& MutableAutoRepeatNamedGridColumnLinesInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_named_grid_column_lines_;
  }

  // AutoRepeatNamedGridRowLines
  NamedGridLinesMap& MutableAutoRepeatNamedGridRowLinesInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_named_grid_row_lines_;
  }

  // AutoRepeatOrderedNamedGridColumnLines
  OrderedNamedGridLines& MutableAutoRepeatOrderedNamedGridColumnLinesInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_ordered_named_grid_column_lines_;
  }

  // AutoRepeatOrderedNamedGridRowLines
  OrderedNamedGridLines& MutableAutoRepeatOrderedNamedGridRowLinesInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->auto_repeat_ordered_named_grid_row_lines_;
  }

  // backdrop-filter
  const Persistent<StyleFilterData>& BackdropFilterInternal() const {
    return rare_non_inherited_data_->backdrop_filter_ops_data_->backdrop_filter_;
  }
  void SetBackdropFilterInternal(Persistent<StyleFilterData>&& v) {
    if (!(rare_non_inherited_data_->backdrop_filter_ops_data_->backdrop_filter_ == v))
      rare_non_inherited_data_.Access()->backdrop_filter_ops_data_.Access()->backdrop_filter_ = std::move(v);
  }
  Persistent<StyleFilterData>& MutableBackdropFilterInternal() {
    return rare_non_inherited_data_.Access()->backdrop_filter_ops_data_.Access()->backdrop_filter_;
  }

  // Background
  const FillLayer& BackgroundInternal() const {
    return background_data_->background_;
  }
  void SetBackgroundInternal(const FillLayer& v) {
    if (!(background_data_->background_ == v))
      background_data_.Access()->background_ = v;
  }
  void SetBackgroundInternal(FillLayer&& v) {
    if (!(background_data_->background_ == v))
      background_data_.Access()->background_ = std::move(v);
  }
  FillLayer& MutableBackgroundInternal() {
    return background_data_.Access()->background_;
  }

  // background-color
  const StyleColor& BackgroundColorInternal() const {
    return background_data_->background_color_;
  }
  void SetBackgroundColorInternal(const StyleColor& v) {
    if (!(background_data_->background_color_ == v))
      background_data_.Access()->background_color_ = v;
  }
  void SetBackgroundColorInternal(StyleColor&& v) {
    if (!(background_data_->background_color_ == v))
      background_data_.Access()->background_color_ = std::move(v);
  }
  StyleColor& MutableBackgroundColorInternal() {
    return background_data_.Access()->background_color_;
  }

  // border-bottom-color
  const Color& BorderBottomColorInternal() const {
    return surround_data_->border_bottom_color_;
  }
  void SetBorderBottomColorInternal(const Color& v) {
    if (!(surround_data_->border_bottom_color_ == v))
      surround_data_.Access()->border_bottom_color_ = v;
  }
  void SetBorderBottomColorInternal(Color&& v) {
    if (!(surround_data_->border_bottom_color_ == v))
      surround_data_.Access()->border_bottom_color_ = std::move(v);
  }
  Color& MutableBorderBottomColorInternal() {
    return surround_data_.Access()->border_bottom_color_;
  }

  // border-bottom-left-radius
  LengthSize& MutableBorderBottomLeftRadiusInternal() {
    return surround_data_.Access()->border_bottom_left_radius_;
  }

  // border-bottom-right-radius
  LengthSize& MutableBorderBottomRightRadiusInternal() {
    return surround_data_.Access()->border_bottom_right_radius_;
  }

  // border-bottom-width
  const LayoutUnit& BorderBottomWidthInternal() const {
    return surround_data_->border_bottom_width_;
  }
  void SetBorderBottomWidthInternal(const LayoutUnit& v) {
    if (!(surround_data_->border_bottom_width_ == v))
      surround_data_.Access()->border_bottom_width_ = v;
  }
  void SetBorderBottomWidthInternal(LayoutUnit&& v) {
    if (!(surround_data_->border_bottom_width_ == v))
      surround_data_.Access()->border_bottom_width_ = std::move(v);
  }
  LayoutUnit& MutableBorderBottomWidthInternal() {
    return surround_data_.Access()->border_bottom_width_;
  }

  // border-image
  NinePieceImage& MutableBorderImageInternal() {
    return surround_data_.Access()->border_image_;
  }

  // border-left-color
  const Color& BorderLeftColorInternal() const {
    return surround_data_->border_left_color_;
  }
  void SetBorderLeftColorInternal(const Color& v) {
    if (!(surround_data_->border_left_color_ == v))
      surround_data_.Access()->border_left_color_ = v;
  }
  void SetBorderLeftColorInternal(Color&& v) {
    if (!(surround_data_->border_left_color_ == v))
      surround_data_.Access()->border_left_color_ = std::move(v);
  }
  Color& MutableBorderLeftColorInternal() {
    return surround_data_.Access()->border_left_color_;
  }

  // border-left-width
  const LayoutUnit& BorderLeftWidthInternal() const {
    return surround_data_->border_left_width_;
  }
  void SetBorderLeftWidthInternal(const LayoutUnit& v) {
    if (!(surround_data_->border_left_width_ == v))
      surround_data_.Access()->border_left_width_ = v;
  }
  void SetBorderLeftWidthInternal(LayoutUnit&& v) {
    if (!(surround_data_->border_left_width_ == v))
      surround_data_.Access()->border_left_width_ = std::move(v);
  }
  LayoutUnit& MutableBorderLeftWidthInternal() {
    return surround_data_.Access()->border_left_width_;
  }

  // border-right-color
  const Color& BorderRightColorInternal() const {
    return surround_data_->border_right_color_;
  }
  void SetBorderRightColorInternal(const Color& v) {
    if (!(surround_data_->border_right_color_ == v))
      surround_data_.Access()->border_right_color_ = v;
  }
  void SetBorderRightColorInternal(Color&& v) {
    if (!(surround_data_->border_right_color_ == v))
      surround_data_.Access()->border_right_color_ = std::move(v);
  }
  Color& MutableBorderRightColorInternal() {
    return surround_data_.Access()->border_right_color_;
  }

  // border-right-width
  const LayoutUnit& BorderRightWidthInternal() const {
    return surround_data_->border_right_width_;
  }
  void SetBorderRightWidthInternal(const LayoutUnit& v) {
    if (!(surround_data_->border_right_width_ == v))
      surround_data_.Access()->border_right_width_ = v;
  }
  void SetBorderRightWidthInternal(LayoutUnit&& v) {
    if (!(surround_data_->border_right_width_ == v))
      surround_data_.Access()->border_right_width_ = std::move(v);
  }
  LayoutUnit& MutableBorderRightWidthInternal() {
    return surround_data_.Access()->border_right_width_;
  }

  // border-top-color
  const Color& BorderTopColorInternal() const {
    return surround_data_->border_top_color_;
  }
  void SetBorderTopColorInternal(const Color& v) {
    if (!(surround_data_->border_top_color_ == v))
      surround_data_.Access()->border_top_color_ = v;
  }
  void SetBorderTopColorInternal(Color&& v) {
    if (!(surround_data_->border_top_color_ == v))
      surround_data_.Access()->border_top_color_ = std::move(v);
  }
  Color& MutableBorderTopColorInternal() {
    return surround_data_.Access()->border_top_color_;
  }

  // border-top-left-radius
  LengthSize& MutableBorderTopLeftRadiusInternal() {
    return surround_data_.Access()->border_top_left_radius_;
  }

  // border-top-right-radius
  LengthSize& MutableBorderTopRightRadiusInternal() {
    return surround_data_.Access()->border_top_right_radius_;
  }

  // border-top-width
  const LayoutUnit& BorderTopWidthInternal() const {
    return surround_data_->border_top_width_;
  }
  void SetBorderTopWidthInternal(const LayoutUnit& v) {
    if (!(surround_data_->border_top_width_ == v))
      surround_data_.Access()->border_top_width_ = v;
  }
  void SetBorderTopWidthInternal(LayoutUnit&& v) {
    if (!(surround_data_->border_top_width_ == v))
      surround_data_.Access()->border_top_width_ = std::move(v);
  }
  LayoutUnit& MutableBorderTopWidthInternal() {
    return surround_data_.Access()->border_top_width_;
  }

  // bottom
  Length& MutableBottomInternal() {
    return surround_data_.Access()->bottom_;
  }

  // -webkit-box-ordinal-group
  const unsigned& BoxOrdinalGroupInternal() const {
    return rare_non_inherited_data_->deprecated_flexible_box_data_->box_ordinal_group_;
  }
  void SetBoxOrdinalGroupInternal(const unsigned& v) {
    if (!(rare_non_inherited_data_->deprecated_flexible_box_data_->box_ordinal_group_ == v))
      rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_ordinal_group_ = v;
  }
  void SetBoxOrdinalGroupInternal(unsigned&& v) {
    if (!(rare_non_inherited_data_->deprecated_flexible_box_data_->box_ordinal_group_ == v))
      rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_ordinal_group_ = std::move(v);
  }
  unsigned& MutableBoxOrdinalGroupInternal() {
    return rare_non_inherited_data_.Access()->deprecated_flexible_box_data_.Access()->box_ordinal_group_;
  }

  // CallbackSelectors
  const Vector<String>& CallbackSelectorsInternal() const {
    return rare_non_inherited_data_->callback_selectors_;
  }
  void SetCallbackSelectorsInternal(const Vector<String>& v) {
    if (!(rare_non_inherited_data_->callback_selectors_ == v))
      rare_non_inherited_data_.Access()->callback_selectors_ = v;
  }
  void SetCallbackSelectorsInternal(Vector<String>&& v) {
    if (!(rare_non_inherited_data_->callback_selectors_ == v))
      rare_non_inherited_data_.Access()->callback_selectors_ = std::move(v);
  }
  Vector<String>& MutableCallbackSelectorsInternal() {
    return rare_non_inherited_data_.Access()->callback_selectors_;
  }

  // caret-color
  const Color& CaretColorInternal() const {
    return rare_inherited_data_->caret_color_;
  }
  void SetCaretColorInternal(const Color& v) {
    if (!(rare_inherited_data_->caret_color_ == v))
      rare_inherited_data_.Access()->caret_color_ = v;
  }
  void SetCaretColorInternal(Color&& v) {
    if (!(rare_inherited_data_->caret_color_ == v))
      rare_inherited_data_.Access()->caret_color_ = std::move(v);
  }
  Color& MutableCaretColorInternal() {
    return rare_inherited_data_.Access()->caret_color_;
  }

  // CaretColorIsAuto
  bool CaretColorIsAutoInternal() const {
    return static_cast<bool>(rare_inherited_data_->caret_color_is_auto_);
  }
  void SetCaretColorIsAutoInternal(bool v) {
    if (!(rare_inherited_data_->caret_color_is_auto_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->caret_color_is_auto_ = static_cast<unsigned>(v);
  }

  // CaretColorIsCurrentColor
  bool CaretColorIsCurrentColorInternal() const {
    return static_cast<bool>(rare_inherited_data_->caret_color_is_current_color_);
  }
  void SetCaretColorIsCurrentColorInternal(bool v) {
    if (!(rare_inherited_data_->caret_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->caret_color_is_current_color_ = static_cast<unsigned>(v);
  }

  // clip
  const LengthBox& ClipInternal() const {
    return visual_data_->clip_;
  }
  void SetClipInternal(const LengthBox& v) {
    if (!(visual_data_->clip_ == v))
      visual_data_.Access()->clip_ = v;
  }
  void SetClipInternal(LengthBox&& v) {
    if (!(visual_data_->clip_ == v))
      visual_data_.Access()->clip_ = std::move(v);
  }
  LengthBox& MutableClipInternal() {
    return visual_data_.Access()->clip_;
  }

  // color
  const Color& ColorInternal() const {
    return inherited_data_->color_;
  }
  void SetColorInternal(const Color& v) {
    if (!(inherited_data_->color_ == v))
      inherited_data_.Access()->color_ = v;
  }
  void SetColorInternal(Color&& v) {
    if (!(inherited_data_->color_ == v))
      inherited_data_.Access()->color_ = std::move(v);
  }
  Color& MutableColorInternal() {
    return inherited_data_.Access()->color_;
  }

  // ColumnAutoCount
  bool ColumnAutoCountInternal() const {
    return static_cast<bool>(rare_non_inherited_data_->multi_col_data_->column_auto_count_);
  }
  void SetColumnAutoCountInternal(bool v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_auto_count_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_auto_count_ = static_cast<unsigned>(v);
  }

  // ColumnAutoWidth
  bool ColumnAutoWidthInternal() const {
    return static_cast<bool>(rare_non_inherited_data_->multi_col_data_->column_auto_width_);
  }
  void SetColumnAutoWidthInternal(bool v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_auto_width_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_auto_width_ = static_cast<unsigned>(v);
  }

  // column-count
  const unsigned short& ColumnCountInternal() const {
    return rare_non_inherited_data_->multi_col_data_->column_count_;
  }
  void SetColumnCountInternal(const unsigned short& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_count_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_count_ = v;
  }
  void SetColumnCountInternal(unsigned short&& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_count_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_count_ = std::move(v);
  }
  unsigned short& MutableColumnCountInternal() {
    return rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_count_;
  }

  // column-gap
  const float& ColumnGapInternal() const {
    return rare_non_inherited_data_->multi_col_data_->column_gap_;
  }
  void SetColumnGapInternal(const float& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_gap_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_gap_ = v;
  }
  void SetColumnGapInternal(float&& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_gap_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_gap_ = std::move(v);
  }
  float& MutableColumnGapInternal() {
    return rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_gap_;
  }

  // ColumnNormalGap
  bool ColumnNormalGapInternal() const {
    return static_cast<bool>(rare_non_inherited_data_->multi_col_data_->column_normal_gap_);
  }
  void SetColumnNormalGapInternal(bool v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_normal_gap_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_normal_gap_ = static_cast<unsigned>(v);
  }

  // column-rule-color
  const Color& ColumnRuleColorInternal() const {
    return rare_non_inherited_data_->multi_col_data_->column_rule_color_;
  }
  void SetColumnRuleColorInternal(const Color& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_rule_color_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_color_ = v;
  }
  void SetColumnRuleColorInternal(Color&& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_rule_color_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_color_ = std::move(v);
  }
  Color& MutableColumnRuleColorInternal() {
    return rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_color_;
  }

  // column-rule-width
  const LayoutUnit& ColumnRuleWidthInternal() const {
    return rare_non_inherited_data_->multi_col_data_->column_rule_width_;
  }
  void SetColumnRuleWidthInternal(const LayoutUnit& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_rule_width_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_width_ = v;
  }
  void SetColumnRuleWidthInternal(LayoutUnit&& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_rule_width_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_width_ = std::move(v);
  }
  LayoutUnit& MutableColumnRuleWidthInternal() {
    return rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_rule_width_;
  }

  // column-width
  const float& ColumnWidthInternal() const {
    return rare_non_inherited_data_->multi_col_data_->column_width_;
  }
  void SetColumnWidthInternal(const float& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_width_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_width_ = v;
  }
  void SetColumnWidthInternal(float&& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->column_width_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_width_ = std::move(v);
  }
  float& MutableColumnWidthInternal() {
    return rare_non_inherited_data_.Access()->multi_col_data_.Access()->column_width_;
  }

  // contain
  Containment ContainInternal() const {
    return static_cast<Containment>(rare_non_inherited_data_->contain_);
  }
  void SetContainInternal(Containment v) {
    if (!(rare_non_inherited_data_->contain_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->contain_ = static_cast<unsigned>(v);
  }

  // content
  const Persistent<ContentData>& ContentInternal() const {
    return rare_non_inherited_data_->content_;
  }
  void SetContentInternal(Persistent<ContentData>&& v) {
    if (!(rare_non_inherited_data_->content_ == v))
      rare_non_inherited_data_.Access()->content_ = std::move(v);
  }
  Persistent<ContentData>& MutableContentInternal() {
    return rare_non_inherited_data_.Access()->content_;
  }

  // CounterDirectives
  const std::unique_ptr<CounterDirectiveMap>& CounterDirectivesInternal() const {
    return rare_non_inherited_data_->counter_directives_;
  }
  void SetCounterDirectivesInternal(std::unique_ptr<CounterDirectiveMap>&& v) {
    if (!(rare_non_inherited_data_->counter_directives_ == v))
      rare_non_inherited_data_.Access()->counter_directives_ = std::move(v);
  }
  std::unique_ptr<CounterDirectiveMap>& MutableCounterDirectivesInternal() {
    return rare_non_inherited_data_.Access()->counter_directives_;
  }

  // CursorData
  const Persistent<CursorList>& CursorDataInternal() const {
    return rare_inherited_data_->cursor_data_;
  }
  void SetCursorDataInternal(Persistent<CursorList>&& v) {
    if (!(rare_inherited_data_->cursor_data_ == v))
      rare_inherited_data_.Access()->cursor_data_ = std::move(v);
  }
  Persistent<CursorList>& MutableCursorDataInternal() {
    return rare_inherited_data_.Access()->cursor_data_;
  }

  // EffectiveZoom
  const float& EffectiveZoomInternal() const {
    return rare_inherited_data_->effective_zoom_;
  }
  void SetEffectiveZoomInternal(const float& v) {
    if (!(rare_inherited_data_->effective_zoom_ == v))
      rare_inherited_data_.Access()->effective_zoom_ = v;
  }
  void SetEffectiveZoomInternal(float&& v) {
    if (!(rare_inherited_data_->effective_zoom_ == v))
      rare_inherited_data_.Access()->effective_zoom_ = std::move(v);
  }
  float& MutableEffectiveZoomInternal() {
    return rare_inherited_data_.Access()->effective_zoom_;
  }

  // EmptyState
  bool EmptyStateInternal() const {
    return static_cast<bool>(empty_state_);
  }
  void SetEmptyStateInternal(bool v) {
    empty_state_ = static_cast<unsigned>(v);
  }

  // filter
  const Persistent<StyleFilterData>& FilterInternal() const {
    return rare_non_inherited_data_->filter_ops_data_->filter_;
  }
  void SetFilterInternal(Persistent<StyleFilterData>&& v) {
    if (!(rare_non_inherited_data_->filter_ops_data_->filter_ == v))
      rare_non_inherited_data_.Access()->filter_ops_data_.Access()->filter_ = std::move(v);
  }
  Persistent<StyleFilterData>& MutableFilterInternal() {
    return rare_non_inherited_data_.Access()->filter_ops_data_.Access()->filter_;
  }

  // flex-basis
  Length& MutableFlexBasisInternal() {
    return rare_non_inherited_data_.Access()->flexible_box_data_.Access()->flex_basis_;
  }

  // font
  const Font& FontInternal() const {
    return inherited_data_->font_;
  }
  void SetFontInternal(const Font& v) {
    if (!(inherited_data_->font_ == v))
      inherited_data_.Access()->font_ = v;
  }
  void SetFontInternal(Font&& v) {
    if (!(inherited_data_->font_ == v))
      inherited_data_.Access()->font_ = std::move(v);
  }
  Font& MutableFontInternal() {
    return inherited_data_.Access()->font_;
  }

  // grid-auto-columns
  Vector<GridTrackSize>& MutableGridAutoColumnsInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_columns_;
  }

  // grid-auto-flow
  GridAutoFlow GridAutoFlowInternal() const {
    return static_cast<GridAutoFlow>(rare_non_inherited_data_->grid_data_->grid_auto_flow_);
  }
  void SetGridAutoFlowInternal(GridAutoFlow v) {
    if (!(rare_non_inherited_data_->grid_data_->grid_auto_flow_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_flow_ = static_cast<unsigned>(v);
  }

  // GridAutoRepeatColumns
  Vector<GridTrackSize>& MutableGridAutoRepeatColumnsInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_columns_;
  }

  // GridAutoRepeatRows
  Vector<GridTrackSize>& MutableGridAutoRepeatRowsInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_repeat_rows_;
  }

  // grid-auto-rows
  Vector<GridTrackSize>& MutableGridAutoRowsInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->grid_auto_rows_;
  }

  // grid-column-end
  GridPosition& MutableGridColumnEndInternal() {
    return rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_column_end_;
  }

  // grid-column-gap
  Length& MutableGridColumnGapInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->grid_column_gap_;
  }

  // grid-column-start
  GridPosition& MutableGridColumnStartInternal() {
    return rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_column_start_;
  }

  // grid-row-end
  GridPosition& MutableGridRowEndInternal() {
    return rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_row_end_;
  }

  // grid-row-gap
  Length& MutableGridRowGapInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->grid_row_gap_;
  }

  // grid-row-start
  GridPosition& MutableGridRowStartInternal() {
    return rare_non_inherited_data_.Access()->grid_item_data_.Access()->grid_row_start_;
  }

  // grid-template-columns
  Vector<GridTrackSize>& MutableGridTemplateColumnsInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->grid_template_columns_;
  }

  // grid-template-rows
  Vector<GridTrackSize>& MutableGridTemplateRowsInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->grid_template_rows_;
  }

  // HasAutoClip
  bool HasAutoClipInternal() const {
    return static_cast<bool>(visual_data_->has_auto_clip_);
  }
  void SetHasAutoClipInternal(bool v) {
    if (!(visual_data_->has_auto_clip_ == static_cast<unsigned>(v)))
      visual_data_.Access()->has_auto_clip_ = static_cast<unsigned>(v);
  }

  // HasAutoZIndex
  bool HasAutoZIndexInternal() const {
    return static_cast<bool>(box_data_->has_auto_z_index_);
  }
  void SetHasAutoZIndexInternal(bool v) {
    if (!(box_data_->has_auto_z_index_ == static_cast<unsigned>(v)))
      box_data_.Access()->has_auto_z_index_ = static_cast<unsigned>(v);
  }

  // HasExplicitlyInheritedProperties
  void SetHasExplicitlyInheritedPropertiesInternal(bool v) {
    has_explicitly_inherited_properties_ = static_cast<unsigned>(v);
  }

  // HasRemUnits
  void SetHasRemUnitsInternal(bool v) {
    has_rem_units_ = static_cast<unsigned>(v);
  }

  // HasSimpleUnderline
  bool HasSimpleUnderlineInternal() const {
    return static_cast<bool>(has_simple_underline_);
  }
  void SetHasSimpleUnderlineInternal(bool v) {
    has_simple_underline_ = static_cast<unsigned>(v);
  }

  // HasVariableReferenceFromNonInheritedProperty
  void SetHasVariableReferenceFromNonInheritedPropertyInternal(bool v) {
    has_variable_reference_from_non_inherited_property_ = static_cast<unsigned>(v);
  }

  // height
  Length& MutableHeightInternal() {
    return box_data_.Access()->height_;
  }

  // -webkit-highlight
  AtomicString& MutableHighlightInternal() {
    return rare_inherited_data_.Access()->highlight_;
  }

  // HyphenationLimitAfter
  const short& HyphenationLimitAfterInternal() const {
    return rare_inherited_data_->hyphenation_limit_after_;
  }
  void SetHyphenationLimitAfterInternal(const short& v) {
    if (!(rare_inherited_data_->hyphenation_limit_after_ == v))
      rare_inherited_data_.Access()->hyphenation_limit_after_ = v;
  }
  void SetHyphenationLimitAfterInternal(short&& v) {
    if (!(rare_inherited_data_->hyphenation_limit_after_ == v))
      rare_inherited_data_.Access()->hyphenation_limit_after_ = std::move(v);
  }
  short& MutableHyphenationLimitAfterInternal() {
    return rare_inherited_data_.Access()->hyphenation_limit_after_;
  }

  // HyphenationLimitBefore
  const short& HyphenationLimitBeforeInternal() const {
    return rare_inherited_data_->hyphenation_limit_before_;
  }
  void SetHyphenationLimitBeforeInternal(const short& v) {
    if (!(rare_inherited_data_->hyphenation_limit_before_ == v))
      rare_inherited_data_.Access()->hyphenation_limit_before_ = v;
  }
  void SetHyphenationLimitBeforeInternal(short&& v) {
    if (!(rare_inherited_data_->hyphenation_limit_before_ == v))
      rare_inherited_data_.Access()->hyphenation_limit_before_ = std::move(v);
  }
  short& MutableHyphenationLimitBeforeInternal() {
    return rare_inherited_data_.Access()->hyphenation_limit_before_;
  }

  // HyphenationLimitLines
  const short& HyphenationLimitLinesInternal() const {
    return rare_inherited_data_->hyphenation_limit_lines_;
  }
  void SetHyphenationLimitLinesInternal(const short& v) {
    if (!(rare_inherited_data_->hyphenation_limit_lines_ == v))
      rare_inherited_data_.Access()->hyphenation_limit_lines_ = v;
  }
  void SetHyphenationLimitLinesInternal(short&& v) {
    if (!(rare_inherited_data_->hyphenation_limit_lines_ == v))
      rare_inherited_data_.Access()->hyphenation_limit_lines_ = std::move(v);
  }
  short& MutableHyphenationLimitLinesInternal() {
    return rare_inherited_data_.Access()->hyphenation_limit_lines_;
  }

  // -webkit-hyphenate-character
  AtomicString& MutableHyphenationStringInternal() {
    return rare_inherited_data_.Access()->hyphenation_string_;
  }

  // InheritedVariables
  const RefPtr<StyleInheritedVariables>& InheritedVariablesInternal() const {
    return rare_inherited_data_->inherited_variables_;
  }
  void SetInheritedVariablesInternal(RefPtr<StyleInheritedVariables>&& v) {
    if (!(rare_inherited_data_->inherited_variables_ == v))
      rare_inherited_data_.Access()->inherited_variables_ = std::move(v);
  }
  RefPtr<StyleInheritedVariables>& MutableInheritedVariablesInternal() {
    return rare_inherited_data_.Access()->inherited_variables_;
  }

  // IsLink
  void SetIsLinkInternal(bool v) {
    is_link_ = static_cast<unsigned>(v);
  }

  // justify-content
  StyleContentAlignmentData& MutableJustifyContentInternal() {
    return rare_non_inherited_data_.Access()->justify_content_;
  }

  // justify-items
  StyleSelfAlignmentData& MutableJustifyItemsInternal() {
    return rare_non_inherited_data_.Access()->justify_items_;
  }

  // justify-self
  StyleSelfAlignmentData& MutableJustifySelfInternal() {
    return rare_non_inherited_data_.Access()->justify_self_;
  }

  // left
  Length& MutableLeftInternal() {
    return surround_data_.Access()->left_;
  }

  // -webkit-line-clamp
  const LineClampValue& LineClampInternal() const {
    return rare_non_inherited_data_->line_clamp_;
  }
  void SetLineClampInternal(const LineClampValue& v) {
    if (!(rare_non_inherited_data_->line_clamp_ == v))
      rare_non_inherited_data_.Access()->line_clamp_ = v;
  }
  void SetLineClampInternal(LineClampValue&& v) {
    if (!(rare_non_inherited_data_->line_clamp_ == v))
      rare_non_inherited_data_.Access()->line_clamp_ = std::move(v);
  }
  LineClampValue& MutableLineClampInternal() {
    return rare_non_inherited_data_.Access()->line_clamp_;
  }

  // line-height
  const Length& LineHeightInternal() const {
    return inherited_data_->line_height_;
  }
  void SetLineHeightInternal(const Length& v) {
    if (!(inherited_data_->line_height_ == v))
      inherited_data_.Access()->line_height_ = v;
  }
  void SetLineHeightInternal(Length&& v) {
    if (!(inherited_data_->line_height_ == v))
      inherited_data_.Access()->line_height_ = std::move(v);
  }
  Length& MutableLineHeightInternal() {
    return inherited_data_.Access()->line_height_;
  }

  // list-style-image
  const Persistent<StyleImage>& ListStyleImageInternal() const {
    return rare_inherited_data_->list_style_image_;
  }
  void SetListStyleImageInternal(Persistent<StyleImage>&& v) {
    if (!(rare_inherited_data_->list_style_image_ == v))
      rare_inherited_data_.Access()->list_style_image_ = std::move(v);
  }
  Persistent<StyleImage>& MutableListStyleImageInternal() {
    return rare_inherited_data_.Access()->list_style_image_;
  }

  // margin-bottom
  Length& MutableMarginBottomInternal() {
    return surround_data_.Access()->margin_bottom_;
  }

  // margin-left
  Length& MutableMarginLeftInternal() {
    return surround_data_.Access()->margin_left_;
  }

  // margin-right
  Length& MutableMarginRightInternal() {
    return surround_data_.Access()->margin_right_;
  }

  // margin-top
  Length& MutableMarginTopInternal() {
    return surround_data_.Access()->margin_top_;
  }

  // Mask
  const FillLayer& MaskInternal() const {
    return rare_non_inherited_data_->mask_;
  }
  void SetMaskInternal(const FillLayer& v) {
    if (!(rare_non_inherited_data_->mask_ == v))
      rare_non_inherited_data_.Access()->mask_ = v;
  }
  void SetMaskInternal(FillLayer&& v) {
    if (!(rare_non_inherited_data_->mask_ == v))
      rare_non_inherited_data_.Access()->mask_ = std::move(v);
  }
  FillLayer& MutableMaskInternal() {
    return rare_non_inherited_data_.Access()->mask_;
  }

  // MaskBoxImage
  const NinePieceImage& MaskBoxImageInternal() const {
    return rare_non_inherited_data_->mask_box_image_;
  }
  void SetMaskBoxImageInternal(const NinePieceImage& v) {
    if (!(rare_non_inherited_data_->mask_box_image_ == v))
      rare_non_inherited_data_.Access()->mask_box_image_ = v;
  }
  void SetMaskBoxImageInternal(NinePieceImage&& v) {
    if (!(rare_non_inherited_data_->mask_box_image_ == v))
      rare_non_inherited_data_.Access()->mask_box_image_ = std::move(v);
  }
  NinePieceImage& MutableMaskBoxImageInternal() {
    return rare_non_inherited_data_.Access()->mask_box_image_;
  }

  // max-height
  Length& MutableMaxHeightInternal() {
    return box_data_.Access()->max_height_;
  }

  // max-width
  Length& MutableMaxWidthInternal() {
    return box_data_.Access()->max_width_;
  }

  // min-height
  Length& MutableMinHeightInternal() {
    return box_data_.Access()->min_height_;
  }

  // min-width
  Length& MutableMinWidthInternal() {
    return box_data_.Access()->min_width_;
  }

  // NamedGridArea
  NamedGridAreaMap& MutableNamedGridAreaInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_area_;
  }

  // NamedGridColumnLines
  NamedGridLinesMap& MutableNamedGridColumnLinesInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_column_lines_;
  }

  // NamedGridRowLines
  NamedGridLinesMap& MutableNamedGridRowLinesInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->named_grid_row_lines_;
  }

  // NonInheritedVariables
  const std::unique_ptr<StyleNonInheritedVariables>& NonInheritedVariablesInternal() const {
    return rare_non_inherited_data_->non_inherited_variables_;
  }
  void SetNonInheritedVariablesInternal(std::unique_ptr<StyleNonInheritedVariables>&& v) {
    if (!(rare_non_inherited_data_->non_inherited_variables_ == v))
      rare_non_inherited_data_.Access()->non_inherited_variables_ = std::move(v);
  }
  std::unique_ptr<StyleNonInheritedVariables>& MutableNonInheritedVariablesInternal() {
    return rare_non_inherited_data_.Access()->non_inherited_variables_;
  }

  // object-position
  LengthPoint& MutableObjectPositionInternal() {
    return rare_non_inherited_data_.Access()->object_position_;
  }

  // offset-anchor
  LengthPoint& MutableOffsetAnchorInternal() {
    return rare_non_inherited_data_.Access()->transform_data_.Access()->offset_anchor_;
  }

  // offset-distance
  Length& MutableOffsetDistanceInternal() {
    return rare_non_inherited_data_.Access()->transform_data_.Access()->offset_distance_;
  }

  // offset-position
  LengthPoint& MutableOffsetPositionInternal() {
    return rare_non_inherited_data_.Access()->transform_data_.Access()->offset_position_;
  }

  // offset-rotate
  StyleOffsetRotation& MutableOffsetRotateInternal() {
    return rare_non_inherited_data_.Access()->transform_data_.Access()->offset_rotate_;
  }

  // opacity
  const float& OpacityInternal() const {
    return rare_non_inherited_data_->opacity_;
  }
  void SetOpacityInternal(const float& v) {
    if (!(rare_non_inherited_data_->opacity_ == v))
      rare_non_inherited_data_.Access()->opacity_ = v;
  }
  void SetOpacityInternal(float&& v) {
    if (!(rare_non_inherited_data_->opacity_ == v))
      rare_non_inherited_data_.Access()->opacity_ = std::move(v);
  }
  float& MutableOpacityInternal() {
    return rare_non_inherited_data_.Access()->opacity_;
  }

  // order
  const int& OrderInternal() const {
    return rare_non_inherited_data_->order_;
  }
  void SetOrderInternal(const int& v) {
    if (!(rare_non_inherited_data_->order_ == v))
      rare_non_inherited_data_.Access()->order_ = v;
  }
  void SetOrderInternal(int&& v) {
    if (!(rare_non_inherited_data_->order_ == v))
      rare_non_inherited_data_.Access()->order_ = std::move(v);
  }
  int& MutableOrderInternal() {
    return rare_non_inherited_data_.Access()->order_;
  }

  // OrderedNamedGridColumnLines
  OrderedNamedGridLines& MutableOrderedNamedGridColumnLinesInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->ordered_named_grid_column_lines_;
  }

  // OrderedNamedGridRowLines
  OrderedNamedGridLines& MutableOrderedNamedGridRowLinesInternal() {
    return rare_non_inherited_data_.Access()->grid_data_.Access()->ordered_named_grid_row_lines_;
  }

  // outline-color
  const Color& OutlineColorInternal() const {
    return rare_non_inherited_data_->outline_color_;
  }
  void SetOutlineColorInternal(const Color& v) {
    if (!(rare_non_inherited_data_->outline_color_ == v))
      rare_non_inherited_data_.Access()->outline_color_ = v;
  }
  void SetOutlineColorInternal(Color&& v) {
    if (!(rare_non_inherited_data_->outline_color_ == v))
      rare_non_inherited_data_.Access()->outline_color_ = std::move(v);
  }
  Color& MutableOutlineColorInternal() {
    return rare_non_inherited_data_.Access()->outline_color_;
  }

  // outline-offset
  const int& OutlineOffsetInternal() const {
    return rare_non_inherited_data_->outline_offset_;
  }
  void SetOutlineOffsetInternal(const int& v) {
    if (!(rare_non_inherited_data_->outline_offset_ == v))
      rare_non_inherited_data_.Access()->outline_offset_ = v;
  }
  void SetOutlineOffsetInternal(int&& v) {
    if (!(rare_non_inherited_data_->outline_offset_ == v))
      rare_non_inherited_data_.Access()->outline_offset_ = std::move(v);
  }
  int& MutableOutlineOffsetInternal() {
    return rare_non_inherited_data_.Access()->outline_offset_;
  }

  // outline-width
  const LayoutUnit& OutlineWidthInternal() const {
    return rare_non_inherited_data_->outline_width_;
  }
  void SetOutlineWidthInternal(const LayoutUnit& v) {
    if (!(rare_non_inherited_data_->outline_width_ == v))
      rare_non_inherited_data_.Access()->outline_width_ = v;
  }
  void SetOutlineWidthInternal(LayoutUnit&& v) {
    if (!(rare_non_inherited_data_->outline_width_ == v))
      rare_non_inherited_data_.Access()->outline_width_ = std::move(v);
  }
  LayoutUnit& MutableOutlineWidthInternal() {
    return rare_non_inherited_data_.Access()->outline_width_;
  }

  // padding-bottom
  Length& MutablePaddingBottomInternal() {
    return surround_data_.Access()->padding_bottom_;
  }

  // padding-left
  Length& MutablePaddingLeftInternal() {
    return surround_data_.Access()->padding_left_;
  }

  // padding-right
  Length& MutablePaddingRightInternal() {
    return surround_data_.Access()->padding_right_;
  }

  // padding-top
  Length& MutablePaddingTopInternal() {
    return surround_data_.Access()->padding_top_;
  }

  // PageSize
  FloatSize& MutablePageSizeInternal() {
    return rare_non_inherited_data_.Access()->page_size_;
  }

  // PaintImages
  const std::unique_ptr<PaintImages>& PaintImagesInternal() const {
    return rare_non_inherited_data_->paint_images_;
  }
  void SetPaintImagesInternal(std::unique_ptr<PaintImages>&& v) {
    if (!(rare_non_inherited_data_->paint_images_ == v))
      rare_non_inherited_data_.Access()->paint_images_ = std::move(v);
  }
  std::unique_ptr<PaintImages>& MutablePaintImagesInternal() {
    return rare_non_inherited_data_.Access()->paint_images_;
  }

  // perspective-origin
  LengthPoint& MutablePerspectiveOriginInternal() {
    return rare_non_inherited_data_.Access()->perspective_origin_;
  }

  // PseudoBits
  PseudoId PseudoBitsInternal() const {
    return static_cast<PseudoId>(pseudo_bits_);
  }
  void SetPseudoBitsInternal(PseudoId v) {
    pseudo_bits_ = static_cast<unsigned>(v);
  }

  // right
  Length& MutableRightInternal() {
    return surround_data_.Access()->right_;
  }

  // scroll-behavior
  ScrollBehavior ScrollBehaviorInternal() const {
    return static_cast<ScrollBehavior>(rare_non_inherited_data_->scroll_behavior_);
  }
  void SetScrollBehaviorInternal(ScrollBehavior v) {
    if (!(rare_non_inherited_data_->scroll_behavior_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->scroll_behavior_ = static_cast<unsigned>(v);
  }

  // scroll-padding-bottom
  Length& MutableScrollPaddingBottomInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_bottom_;
  }

  // scroll-padding-left
  Length& MutableScrollPaddingLeftInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_left_;
  }

  // scroll-padding-right
  Length& MutableScrollPaddingRightInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_right_;
  }

  // scroll-padding-top
  Length& MutableScrollPaddingTopInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_padding_top_;
  }

  // scroll-snap-align
  ScrollSnapAlign& MutableScrollSnapAlignInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_align_;
  }

  // scroll-snap-margin-bottom
  Length& MutableScrollSnapMarginBottomInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_bottom_;
  }

  // scroll-snap-margin-left
  Length& MutableScrollSnapMarginLeftInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_left_;
  }

  // scroll-snap-margin-right
  Length& MutableScrollSnapMarginRightInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_right_;
  }

  // scroll-snap-margin-top
  Length& MutableScrollSnapMarginTopInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_margin_top_;
  }

  // scroll-snap-type
  ScrollSnapType& MutableScrollSnapTypeInternal() {
    return rare_non_inherited_data_.Access()->scroll_snap_data_.Access()->scroll_snap_type_;
  }

  // shape-image-threshold
  const float& ShapeImageThresholdInternal() const {
    return rare_non_inherited_data_->shape_image_threshold_;
  }
  void SetShapeImageThresholdInternal(const float& v) {
    if (!(rare_non_inherited_data_->shape_image_threshold_ == v))
      rare_non_inherited_data_.Access()->shape_image_threshold_ = v;
  }
  void SetShapeImageThresholdInternal(float&& v) {
    if (!(rare_non_inherited_data_->shape_image_threshold_ == v))
      rare_non_inherited_data_.Access()->shape_image_threshold_ = std::move(v);
  }
  float& MutableShapeImageThresholdInternal() {
    return rare_non_inherited_data_.Access()->shape_image_threshold_;
  }

  // shape-margin
  Length& MutableShapeMarginInternal() {
    return rare_non_inherited_data_.Access()->shape_margin_;
  }

  // shape-outside
  const Persistent<ShapeValue>& ShapeOutsideInternal() const {
    return rare_non_inherited_data_->shape_outside_;
  }
  void SetShapeOutsideInternal(Persistent<ShapeValue>&& v) {
    if (!(rare_non_inherited_data_->shape_outside_ == v))
      rare_non_inherited_data_.Access()->shape_outside_ = std::move(v);
  }
  Persistent<ShapeValue>& MutableShapeOutsideInternal() {
    return rare_non_inherited_data_.Access()->shape_outside_;
  }

  // StyleType
  PseudoId StyleTypeInternal() const {
    return static_cast<PseudoId>(style_type_);
  }
  void SetStyleTypeInternal(PseudoId v) {
    style_type_ = static_cast<unsigned>(v);
  }

  // tab-size
  TabSize& MutableTabSizeInternal() {
    return rare_inherited_data_.Access()->tab_size_;
  }

  // -webkit-tap-highlight-color
  Color& MutableTapHighlightColorInternal() {
    return rare_inherited_data_.Access()->tap_highlight_color_;
  }

  // TextAutosizingMultiplier
  const float& TextAutosizingMultiplierInternal() const {
    return inherited_data_->text_autosizing_multiplier_;
  }
  void SetTextAutosizingMultiplierInternal(const float& v) {
    if (!(inherited_data_->text_autosizing_multiplier_ == v))
      inherited_data_.Access()->text_autosizing_multiplier_ = v;
  }
  void SetTextAutosizingMultiplierInternal(float&& v) {
    if (!(inherited_data_->text_autosizing_multiplier_ == v))
      inherited_data_.Access()->text_autosizing_multiplier_ = std::move(v);
  }
  float& MutableTextAutosizingMultiplierInternal() {
    return inherited_data_.Access()->text_autosizing_multiplier_;
  }

  // text-decoration-color
  StyleColor& MutableTextDecorationColorInternal() {
    return rare_non_inherited_data_.Access()->text_decoration_color_;
  }

  // text-decoration-skip
  TextDecorationSkip TextDecorationSkipInternal() const {
    return static_cast<TextDecorationSkip>(rare_inherited_data_->text_decoration_skip_);
  }
  void SetTextDecorationSkipInternal(TextDecorationSkip v) {
    if (!(rare_inherited_data_->text_decoration_skip_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_decoration_skip_ = static_cast<unsigned>(v);
  }

  // -webkit-text-emphasis-color
  const Color& TextEmphasisColorInternal() const {
    return rare_inherited_data_->text_emphasis_color_;
  }
  void SetTextEmphasisColorInternal(const Color& v) {
    if (!(rare_inherited_data_->text_emphasis_color_ == v))
      rare_inherited_data_.Access()->text_emphasis_color_ = v;
  }
  void SetTextEmphasisColorInternal(Color&& v) {
    if (!(rare_inherited_data_->text_emphasis_color_ == v))
      rare_inherited_data_.Access()->text_emphasis_color_ = std::move(v);
  }
  Color& MutableTextEmphasisColorInternal() {
    return rare_inherited_data_.Access()->text_emphasis_color_;
  }

  // TextEmphasisColorIsCurrentColor
  bool TextEmphasisColorIsCurrentColorInternal() const {
    return static_cast<bool>(rare_inherited_data_->text_emphasis_color_is_current_color_);
  }
  void SetTextEmphasisColorIsCurrentColorInternal(bool v) {
    if (!(rare_inherited_data_->text_emphasis_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_emphasis_color_is_current_color_ = static_cast<unsigned>(v);
  }

  // TextEmphasisCustomMark
  AtomicString& MutableTextEmphasisCustomMarkInternal() {
    return rare_inherited_data_.Access()->text_emphasis_custom_mark_;
  }

  // TextEmphasisMark
  TextEmphasisMark TextEmphasisMarkInternal() const {
    return static_cast<TextEmphasisMark>(rare_inherited_data_->text_emphasis_mark_);
  }
  void SetTextEmphasisMarkInternal(TextEmphasisMark v) {
    if (!(rare_inherited_data_->text_emphasis_mark_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_emphasis_mark_ = static_cast<unsigned>(v);
  }

  // -webkit-text-fill-color
  const Color& TextFillColorInternal() const {
    return rare_inherited_data_->text_fill_color_;
  }
  void SetTextFillColorInternal(const Color& v) {
    if (!(rare_inherited_data_->text_fill_color_ == v))
      rare_inherited_data_.Access()->text_fill_color_ = v;
  }
  void SetTextFillColorInternal(Color&& v) {
    if (!(rare_inherited_data_->text_fill_color_ == v))
      rare_inherited_data_.Access()->text_fill_color_ = std::move(v);
  }
  Color& MutableTextFillColorInternal() {
    return rare_inherited_data_.Access()->text_fill_color_;
  }

  // TextFillColorIsCurrentColor
  bool TextFillColorIsCurrentColorInternal() const {
    return static_cast<bool>(rare_inherited_data_->text_fill_color_is_current_color_);
  }
  void SetTextFillColorIsCurrentColorInternal(bool v) {
    if (!(rare_inherited_data_->text_fill_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_fill_color_is_current_color_ = static_cast<unsigned>(v);
  }

  // text-indent
  Length& MutableTextIndentInternal() {
    return rare_inherited_data_.Access()->text_indent_;
  }

  // text-size-adjust
  TextSizeAdjust& MutableTextSizeAdjustInternal() {
    return rare_inherited_data_.Access()->text_size_adjust_;
  }

  // -webkit-text-stroke-color
  const Color& TextStrokeColorInternal() const {
    return rare_inherited_data_->text_stroke_color_;
  }
  void SetTextStrokeColorInternal(const Color& v) {
    if (!(rare_inherited_data_->text_stroke_color_ == v))
      rare_inherited_data_.Access()->text_stroke_color_ = v;
  }
  void SetTextStrokeColorInternal(Color&& v) {
    if (!(rare_inherited_data_->text_stroke_color_ == v))
      rare_inherited_data_.Access()->text_stroke_color_ = std::move(v);
  }
  Color& MutableTextStrokeColorInternal() {
    return rare_inherited_data_.Access()->text_stroke_color_;
  }

  // TextStrokeColorIsCurrentColor
  bool TextStrokeColorIsCurrentColorInternal() const {
    return static_cast<bool>(rare_inherited_data_->text_stroke_color_is_current_color_);
  }
  void SetTextStrokeColorIsCurrentColorInternal(bool v) {
    if (!(rare_inherited_data_->text_stroke_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->text_stroke_color_is_current_color_ = static_cast<unsigned>(v);
  }

  // top
  Length& MutableTopInternal() {
    return surround_data_.Access()->top_;
  }

  // touch-action
  TouchAction TouchActionInternal() const {
    return static_cast<TouchAction>(rare_non_inherited_data_->touch_action_);
  }
  void SetTouchActionInternal(TouchAction v) {
    if (!(rare_non_inherited_data_->touch_action_ == static_cast<unsigned>(v)))
      rare_non_inherited_data_.Access()->touch_action_ = static_cast<unsigned>(v);
  }

  // transform
  const TransformOperations& TransformInternal() const {
    return rare_non_inherited_data_->transform_data_->transform_;
  }
  void SetTransformInternal(const TransformOperations& v) {
    if (!(rare_non_inherited_data_->transform_data_->transform_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->transform_ = v;
  }
  void SetTransformInternal(TransformOperations&& v) {
    if (!(rare_non_inherited_data_->transform_data_->transform_ == v))
      rare_non_inherited_data_.Access()->transform_data_.Access()->transform_ = std::move(v);
  }
  TransformOperations& MutableTransformInternal() {
    return rare_non_inherited_data_.Access()->transform_data_.Access()->transform_;
  }

  // transform-origin
  TransformOrigin& MutableTransformOriginInternal() {
    return rare_non_inherited_data_.Access()->transform_data_.Access()->transform_origin_;
  }

  // Transitions
  const std::unique_ptr<CSSTransitionData>& TransitionsInternal() const {
    return rare_non_inherited_data_->transitions_;
  }
  void SetTransitionsInternal(std::unique_ptr<CSSTransitionData>&& v) {
    if (!(rare_non_inherited_data_->transitions_ == v))
      rare_non_inherited_data_.Access()->transitions_ = std::move(v);
  }
  std::unique_ptr<CSSTransitionData>& MutableTransitionsInternal() {
    return rare_non_inherited_data_.Access()->transitions_;
  }

  // Unique
  void SetUniqueInternal(bool v) {
    unique_ = static_cast<unsigned>(v);
  }

  // VerticalAlign
  EVerticalAlign VerticalAlignInternal() const {
    return static_cast<EVerticalAlign>(vertical_align_);
  }
  void SetVerticalAlignInternal(EVerticalAlign v) {
    vertical_align_ = static_cast<unsigned>(v);
  }

  // VerticalAlignLength
  const Length& VerticalAlignLengthInternal() const {
    return box_data_->vertical_align_length_;
  }
  void SetVerticalAlignLengthInternal(const Length& v) {
    if (!(box_data_->vertical_align_length_ == v))
      box_data_.Access()->vertical_align_length_ = v;
  }
  void SetVerticalAlignLengthInternal(Length&& v) {
    if (!(box_data_->vertical_align_length_ == v))
      box_data_.Access()->vertical_align_length_ = std::move(v);
  }
  Length& MutableVerticalAlignLengthInternal() {
    return box_data_.Access()->vertical_align_length_;
  }

  // VisitedLinkBackgroundColor
  const StyleColor& VisitedLinkBackgroundColorInternal() const {
    return rare_non_inherited_data_->visited_link_background_color_;
  }
  void SetVisitedLinkBackgroundColorInternal(const StyleColor& v) {
    if (!(rare_non_inherited_data_->visited_link_background_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_background_color_ = v;
  }
  void SetVisitedLinkBackgroundColorInternal(StyleColor&& v) {
    if (!(rare_non_inherited_data_->visited_link_background_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_background_color_ = std::move(v);
  }
  StyleColor& MutableVisitedLinkBackgroundColorInternal() {
    return rare_non_inherited_data_.Access()->visited_link_background_color_;
  }

  // VisitedLinkBorderBottomColor
  const StyleColor& VisitedLinkBorderBottomColorInternal() const {
    return rare_non_inherited_data_->visited_link_border_bottom_color_;
  }
  void SetVisitedLinkBorderBottomColorInternal(const StyleColor& v) {
    if (!(rare_non_inherited_data_->visited_link_border_bottom_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_border_bottom_color_ = v;
  }
  void SetVisitedLinkBorderBottomColorInternal(StyleColor&& v) {
    if (!(rare_non_inherited_data_->visited_link_border_bottom_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_border_bottom_color_ = std::move(v);
  }
  StyleColor& MutableVisitedLinkBorderBottomColorInternal() {
    return rare_non_inherited_data_.Access()->visited_link_border_bottom_color_;
  }

  // VisitedLinkBorderLeftColor
  const StyleColor& VisitedLinkBorderLeftColorInternal() const {
    return rare_non_inherited_data_->visited_link_border_left_color_;
  }
  void SetVisitedLinkBorderLeftColorInternal(const StyleColor& v) {
    if (!(rare_non_inherited_data_->visited_link_border_left_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_border_left_color_ = v;
  }
  void SetVisitedLinkBorderLeftColorInternal(StyleColor&& v) {
    if (!(rare_non_inherited_data_->visited_link_border_left_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_border_left_color_ = std::move(v);
  }
  StyleColor& MutableVisitedLinkBorderLeftColorInternal() {
    return rare_non_inherited_data_.Access()->visited_link_border_left_color_;
  }

  // VisitedLinkBorderRightColor
  const StyleColor& VisitedLinkBorderRightColorInternal() const {
    return rare_non_inherited_data_->visited_link_border_right_color_;
  }
  void SetVisitedLinkBorderRightColorInternal(const StyleColor& v) {
    if (!(rare_non_inherited_data_->visited_link_border_right_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_border_right_color_ = v;
  }
  void SetVisitedLinkBorderRightColorInternal(StyleColor&& v) {
    if (!(rare_non_inherited_data_->visited_link_border_right_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_border_right_color_ = std::move(v);
  }
  StyleColor& MutableVisitedLinkBorderRightColorInternal() {
    return rare_non_inherited_data_.Access()->visited_link_border_right_color_;
  }

  // VisitedLinkBorderTopColor
  const StyleColor& VisitedLinkBorderTopColorInternal() const {
    return rare_non_inherited_data_->visited_link_border_top_color_;
  }
  void SetVisitedLinkBorderTopColorInternal(const StyleColor& v) {
    if (!(rare_non_inherited_data_->visited_link_border_top_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_border_top_color_ = v;
  }
  void SetVisitedLinkBorderTopColorInternal(StyleColor&& v) {
    if (!(rare_non_inherited_data_->visited_link_border_top_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_border_top_color_ = std::move(v);
  }
  StyleColor& MutableVisitedLinkBorderTopColorInternal() {
    return rare_non_inherited_data_.Access()->visited_link_border_top_color_;
  }

  // VisitedLinkCaretColor
  const Color& VisitedLinkCaretColorInternal() const {
    return rare_inherited_data_->visited_link_caret_color_;
  }
  void SetVisitedLinkCaretColorInternal(const Color& v) {
    if (!(rare_inherited_data_->visited_link_caret_color_ == v))
      rare_inherited_data_.Access()->visited_link_caret_color_ = v;
  }
  void SetVisitedLinkCaretColorInternal(Color&& v) {
    if (!(rare_inherited_data_->visited_link_caret_color_ == v))
      rare_inherited_data_.Access()->visited_link_caret_color_ = std::move(v);
  }
  Color& MutableVisitedLinkCaretColorInternal() {
    return rare_inherited_data_.Access()->visited_link_caret_color_;
  }

  // VisitedLinkCaretColorIsAuto
  bool VisitedLinkCaretColorIsAutoInternal() const {
    return static_cast<bool>(rare_inherited_data_->visited_link_caret_color_is_auto_);
  }
  void SetVisitedLinkCaretColorIsAutoInternal(bool v) {
    if (!(rare_inherited_data_->visited_link_caret_color_is_auto_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->visited_link_caret_color_is_auto_ = static_cast<unsigned>(v);
  }

  // VisitedLinkCaretColorIsCurrentColor
  bool VisitedLinkCaretColorIsCurrentColorInternal() const {
    return static_cast<bool>(rare_inherited_data_->visited_link_caret_color_is_current_color_);
  }
  void SetVisitedLinkCaretColorIsCurrentColorInternal(bool v) {
    if (!(rare_inherited_data_->visited_link_caret_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->visited_link_caret_color_is_current_color_ = static_cast<unsigned>(v);
  }

  // VisitedLinkColor
  Color& MutableVisitedLinkColorInternal() {
    return inherited_data_.Access()->visited_link_color_;
  }

  // VisitedLinkColumnRuleColor
  const StyleColor& VisitedLinkColumnRuleColorInternal() const {
    return rare_non_inherited_data_->multi_col_data_->visited_link_column_rule_color_;
  }
  void SetVisitedLinkColumnRuleColorInternal(const StyleColor& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->visited_link_column_rule_color_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->visited_link_column_rule_color_ = v;
  }
  void SetVisitedLinkColumnRuleColorInternal(StyleColor&& v) {
    if (!(rare_non_inherited_data_->multi_col_data_->visited_link_column_rule_color_ == v))
      rare_non_inherited_data_.Access()->multi_col_data_.Access()->visited_link_column_rule_color_ = std::move(v);
  }
  StyleColor& MutableVisitedLinkColumnRuleColorInternal() {
    return rare_non_inherited_data_.Access()->multi_col_data_.Access()->visited_link_column_rule_color_;
  }

  // VisitedLinkOutlineColor
  const StyleColor& VisitedLinkOutlineColorInternal() const {
    return rare_non_inherited_data_->visited_link_outline_color_;
  }
  void SetVisitedLinkOutlineColorInternal(const StyleColor& v) {
    if (!(rare_non_inherited_data_->visited_link_outline_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_outline_color_ = v;
  }
  void SetVisitedLinkOutlineColorInternal(StyleColor&& v) {
    if (!(rare_non_inherited_data_->visited_link_outline_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_outline_color_ = std::move(v);
  }
  StyleColor& MutableVisitedLinkOutlineColorInternal() {
    return rare_non_inherited_data_.Access()->visited_link_outline_color_;
  }

  // VisitedLinkTextDecorationColor
  const StyleColor& VisitedLinkTextDecorationColorInternal() const {
    return rare_non_inherited_data_->visited_link_text_decoration_color_;
  }
  void SetVisitedLinkTextDecorationColorInternal(const StyleColor& v) {
    if (!(rare_non_inherited_data_->visited_link_text_decoration_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_text_decoration_color_ = v;
  }
  void SetVisitedLinkTextDecorationColorInternal(StyleColor&& v) {
    if (!(rare_non_inherited_data_->visited_link_text_decoration_color_ == v))
      rare_non_inherited_data_.Access()->visited_link_text_decoration_color_ = std::move(v);
  }
  StyleColor& MutableVisitedLinkTextDecorationColorInternal() {
    return rare_non_inherited_data_.Access()->visited_link_text_decoration_color_;
  }

  // VisitedLinkTextEmphasisColor
  const Color& VisitedLinkTextEmphasisColorInternal() const {
    return rare_inherited_data_->visited_link_text_emphasis_color_;
  }
  void SetVisitedLinkTextEmphasisColorInternal(const Color& v) {
    if (!(rare_inherited_data_->visited_link_text_emphasis_color_ == v))
      rare_inherited_data_.Access()->visited_link_text_emphasis_color_ = v;
  }
  void SetVisitedLinkTextEmphasisColorInternal(Color&& v) {
    if (!(rare_inherited_data_->visited_link_text_emphasis_color_ == v))
      rare_inherited_data_.Access()->visited_link_text_emphasis_color_ = std::move(v);
  }
  Color& MutableVisitedLinkTextEmphasisColorInternal() {
    return rare_inherited_data_.Access()->visited_link_text_emphasis_color_;
  }

  // VisitedLinkTextEmphasisColorIsCurrentColor
  bool VisitedLinkTextEmphasisColorIsCurrentColorInternal() const {
    return static_cast<bool>(rare_inherited_data_->visited_link_text_emphasis_color_is_current_color_);
  }
  void SetVisitedLinkTextEmphasisColorIsCurrentColorInternal(bool v) {
    if (!(rare_inherited_data_->visited_link_text_emphasis_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->visited_link_text_emphasis_color_is_current_color_ = static_cast<unsigned>(v);
  }

  // VisitedLinkTextFillColor
  const Color& VisitedLinkTextFillColorInternal() const {
    return rare_inherited_data_->visited_link_text_fill_color_;
  }
  void SetVisitedLinkTextFillColorInternal(const Color& v) {
    if (!(rare_inherited_data_->visited_link_text_fill_color_ == v))
      rare_inherited_data_.Access()->visited_link_text_fill_color_ = v;
  }
  void SetVisitedLinkTextFillColorInternal(Color&& v) {
    if (!(rare_inherited_data_->visited_link_text_fill_color_ == v))
      rare_inherited_data_.Access()->visited_link_text_fill_color_ = std::move(v);
  }
  Color& MutableVisitedLinkTextFillColorInternal() {
    return rare_inherited_data_.Access()->visited_link_text_fill_color_;
  }

  // VisitedLinkTextFillColorIsCurrentColor
  bool VisitedLinkTextFillColorIsCurrentColorInternal() const {
    return static_cast<bool>(rare_inherited_data_->visited_link_text_fill_color_is_current_color_);
  }
  void SetVisitedLinkTextFillColorIsCurrentColorInternal(bool v) {
    if (!(rare_inherited_data_->visited_link_text_fill_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->visited_link_text_fill_color_is_current_color_ = static_cast<unsigned>(v);
  }

  // VisitedLinkTextStrokeColor
  const Color& VisitedLinkTextStrokeColorInternal() const {
    return rare_inherited_data_->visited_link_text_stroke_color_;
  }
  void SetVisitedLinkTextStrokeColorInternal(const Color& v) {
    if (!(rare_inherited_data_->visited_link_text_stroke_color_ == v))
      rare_inherited_data_.Access()->visited_link_text_stroke_color_ = v;
  }
  void SetVisitedLinkTextStrokeColorInternal(Color&& v) {
    if (!(rare_inherited_data_->visited_link_text_stroke_color_ == v))
      rare_inherited_data_.Access()->visited_link_text_stroke_color_ = std::move(v);
  }
  Color& MutableVisitedLinkTextStrokeColorInternal() {
    return rare_inherited_data_.Access()->visited_link_text_stroke_color_;
  }

  // VisitedLinkTextStrokeColorIsCurrentColor
  bool VisitedLinkTextStrokeColorIsCurrentColorInternal() const {
    return static_cast<bool>(rare_inherited_data_->visited_link_text_stroke_color_is_current_color_);
  }
  void SetVisitedLinkTextStrokeColorIsCurrentColorInternal(bool v) {
    if (!(rare_inherited_data_->visited_link_text_stroke_color_is_current_color_ == static_cast<unsigned>(v)))
      rare_inherited_data_.Access()->visited_link_text_stroke_color_is_current_color_ = static_cast<unsigned>(v);
  }

  // width
  Length& MutableWidthInternal() {
    return box_data_.Access()->width_;
  }

  // WillChangeProperties
  Vector<CSSPropertyID>& MutableWillChangePropertiesInternal() {
    return rare_non_inherited_data_.Access()->will_change_data_.Access()->will_change_properties_;
  }

  // z-index
  const int& ZIndexInternal() const {
    return box_data_->z_index_;
  }
  void SetZIndexInternal(const int& v) {
    if (!(box_data_->z_index_ == v))
      box_data_.Access()->z_index_ = v;
  }
  void SetZIndexInternal(int&& v) {
    if (!(box_data_->z_index_ == v))
      box_data_.Access()->z_index_ = std::move(v);
  }
  int& MutableZIndexInternal() {
    return box_data_.Access()->z_index_;
  }

  // zoom
  const float& ZoomInternal() const {
    return visual_data_->zoom_;
  }
  void SetZoomInternal(const float& v) {
    if (!(visual_data_->zoom_ == v))
      visual_data_.Access()->zoom_ = v;
  }
  void SetZoomInternal(float&& v) {
    if (!(visual_data_->zoom_ == v))
      visual_data_.Access()->zoom_ = std::move(v);
  }
  float& MutableZoomInternal() {
    return visual_data_.Access()->zoom_;
  }


  ~ComputedStyleBase() = default;

 private:
  // Storage.
  DataRef<StyleBoxData> box_data_;
  DataRef<StyleRareInheritedData> rare_inherited_data_;
  DataRef<StyleRareNonInheritedData> rare_non_inherited_data_;
  DataRef<StyleSurroundData> surround_data_;
  DataRef<StyleVisualData> visual_data_;
  DataRef<StyleBackgroundData> background_data_;
  DataRef<StyleInheritedData> inherited_data_;

  unsigned pseudo_bits_ : 8; // PseudoId
  unsigned cursor_ : 6; // ECursor
  unsigned list_style_type_ : 6; // EListStyleType
  unsigned style_type_ : 6; // PseudoId
  unsigned display_ : 5; // EDisplay
  unsigned affected_by_active_ : 1; // bool
  unsigned original_display_ : 5; // EDisplay
  unsigned break_after_ : 4; // EBreakBetween
  unsigned break_before_ : 4; // EBreakBetween
  unsigned pointer_events_ : 4; // EPointerEvents
  unsigned text_align_ : 4; // ETextAlign
  unsigned vertical_align_ : 4; // EVerticalAlign
  unsigned overflow_x_ : 3; // EOverflow
  unsigned overflow_y_ : 3; // EOverflow
  unsigned affected_by_drag_ : 1; // bool
  unsigned position_ : 3; // EPosition
  unsigned unicode_bidi_ : 3; // UnicodeBidi
  unsigned white_space_ : 3; // EWhiteSpace
  unsigned break_inside_ : 2; // EBreakInside
  unsigned clear_ : 2; // EClear
  unsigned floating_ : 2; // EFloat
  unsigned inside_link_ : 2; // EInsideLink
  unsigned overflow_anchor_ : 2; // EOverflowAnchor
  unsigned text_transform_ : 2; // ETextTransform
  unsigned transform_box_ : 2; // ETransformBox
  unsigned visibility_ : 2; // EVisibility
  unsigned writing_mode_ : 2; // WritingMode
  unsigned affected_by_focus_within_ : 1; // bool
  unsigned affected_by_hover_ : 1; // bool
  unsigned border_collapse_ : 1; // EBorderCollapse
  unsigned border_collapse_is_inherited_ : 1; // bool
  unsigned box_direction_ : 1; // EBoxDirection
  unsigned box_direction_is_inherited_ : 1; // bool
  unsigned caption_side_ : 1; // ECaptionSide
  unsigned caption_side_is_inherited_ : 1; // bool
  unsigned direction_ : 1; // TextDirection
  unsigned empty_cells_ : 1; // EEmptyCells
  unsigned empty_cells_is_inherited_ : 1; // bool
  unsigned empty_state_ : 1; // bool
  mutable unsigned has_explicitly_inherited_properties_ : 1; // bool
  unsigned has_rem_units_ : 1; // bool
  unsigned has_simple_underline_ : 1; // bool
  unsigned has_variable_reference_from_non_inherited_property_ : 1; // bool
  unsigned has_viewport_units_ : 1; // bool
  unsigned is_link_ : 1; // bool
  unsigned list_style_position_ : 1; // EListStylePosition
  unsigned list_style_position_is_inherited_ : 1; // bool
  unsigned pointer_events_is_inherited_ : 1; // bool
  unsigned print_color_adjust_ : 1; // EPrintColorAdjust
  unsigned print_color_adjust_is_inherited_ : 1; // bool
  unsigned rtl_ordering_ : 1; // EOrder
  unsigned rtl_ordering_is_inherited_ : 1; // bool
  unsigned scroll_snap_stop_ : 1; // EScrollSnapStop
  unsigned table_layout_ : 1; // ETableLayout
  unsigned text_transform_is_inherited_ : 1; // bool
  mutable unsigned unique_ : 1; // bool
  unsigned visibility_is_inherited_ : 1; // bool
  unsigned white_space_is_inherited_ : 1; // bool
};

} // namespace blink

#endif // ComputedStyleBase_h