sbox-public/engine/Sandbox.Engine/Systems/UI/Styles/BaseStyles.Generated.cs

using System;

namespace Sandbox.UI;

/// <summary>
/// Auto generated container class for majority of CSS properties available.
/// </summary>
public abstract partial class BaseStyles
{	

	internal string _content;
	
	/// <summary>
	/// Represents the <c>content</c> CSS property.
	/// </summary>
	public string Content
	{
		get => _content;
		set
		{
			if ( _content == value ) return;
			_content = value;
			Dirty();
		}
	}

	internal Length? _width;
	
	/// <summary>
	/// Represents the <c>width</c> CSS property.
	/// </summary>
	public Length? Width
	{
		get => _width;
		set
		{
			if ( _width == value ) return;
			_width = value;
			Dirty();
		}
	}

	internal Length? _minwidth;
	
	/// <summary>
	/// Represents the <c>min-width</c> CSS property.
	/// </summary>
	public Length? MinWidth
	{
		get => _minwidth;
		set
		{
			if ( _minwidth == value ) return;
			_minwidth = value;
			Dirty();
		}
	}

	internal Length? _maxwidth;
	
	/// <summary>
	/// Represents the <c>max-width</c> CSS property.
	/// </summary>
	public Length? MaxWidth
	{
		get => _maxwidth;
		set
		{
			if ( _maxwidth == value ) return;
			_maxwidth = value;
			Dirty();
		}
	}

	internal Length? _height;
	
	/// <summary>
	/// Represents the <c>height</c> CSS property.
	/// </summary>
	public Length? Height
	{
		get => _height;
		set
		{
			if ( _height == value ) return;
			_height = value;
			Dirty();
		}
	}

	internal Length? _minheight;
	
	/// <summary>
	/// Represents the <c>min-height</c> CSS property.
	/// </summary>
	public Length? MinHeight
	{
		get => _minheight;
		set
		{
			if ( _minheight == value ) return;
			_minheight = value;
			Dirty();
		}
	}

	internal Length? _maxheight;
	
	/// <summary>
	/// Represents the <c>max-height</c> CSS property.
	/// </summary>
	public Length? MaxHeight
	{
		get => _maxheight;
		set
		{
			if ( _maxheight == value ) return;
			_maxheight = value;
			Dirty();
		}
	}

	internal Length? _left;
	
	/// <summary>
	/// Represents the <c>left</c> CSS property.
	/// </summary>
	public Length? Left
	{
		get => _left;
		set
		{
			if ( _left == value ) return;
			_left = value;
			Dirty();
		}
	}

	internal Length? _top;
	
	/// <summary>
	/// Represents the <c>top</c> CSS property.
	/// </summary>
	public Length? Top
	{
		get => _top;
		set
		{
			if ( _top == value ) return;
			_top = value;
			Dirty();
		}
	}

	internal Length? _right;
	
	/// <summary>
	/// Represents the <c>right</c> CSS property.
	/// </summary>
	public Length? Right
	{
		get => _right;
		set
		{
			if ( _right == value ) return;
			_right = value;
			Dirty();
		}
	}

	internal Length? _bottom;
	
	/// <summary>
	/// Represents the <c>bottom</c> CSS property.
	/// </summary>
	public Length? Bottom
	{
		get => _bottom;
		set
		{
			if ( _bottom == value ) return;
			_bottom = value;
			Dirty();
		}
	}

	internal float? _opacity;
	
	/// <summary>
	/// Represents the <c>opacity</c> CSS property.
	/// </summary>
	public float? Opacity
	{
		get => _opacity;
		set
		{
			if ( _opacity == value ) return;
			_opacity = value;
			Dirty();
		}
	}

	internal Color? _backgroundcolor;
	
	/// <summary>
	/// Represents the <c>background-color</c> CSS property.
	/// </summary>
	public Color? BackgroundColor
	{
		get => _backgroundcolor;
		set
		{
			if ( _backgroundcolor == value ) return;
			_backgroundcolor = value;
			Dirty();
		}
	}

	internal Length? _paddingleft;
	
	/// <summary>
	/// Represents the <c>padding-left</c> CSS property.
	/// </summary>
	public Length? PaddingLeft
	{
		get => _paddingleft;
		set
		{
			if ( _paddingleft == value ) return;
			_paddingleft = value;
			Dirty();
		}
	}

	internal Length? _paddingtop;
	
	/// <summary>
	/// Represents the <c>padding-top</c> CSS property.
	/// </summary>
	public Length? PaddingTop
	{
		get => _paddingtop;
		set
		{
			if ( _paddingtop == value ) return;
			_paddingtop = value;
			Dirty();
		}
	}

	internal Length? _paddingright;
	
	/// <summary>
	/// Represents the <c>padding-right</c> CSS property.
	/// </summary>
	public Length? PaddingRight
	{
		get => _paddingright;
		set
		{
			if ( _paddingright == value ) return;
			_paddingright = value;
			Dirty();
		}
	}

	internal Length? _paddingbottom;
	
	/// <summary>
	/// Represents the <c>padding-bottom</c> CSS property.
	/// </summary>
	public Length? PaddingBottom
	{
		get => _paddingbottom;
		set
		{
			if ( _paddingbottom == value ) return;
			_paddingbottom = value;
			Dirty();
		}
	}

	internal Length? _marginleft;
	
	/// <summary>
	/// Represents the <c>margin-left</c> CSS property.
	/// </summary>
	public Length? MarginLeft
	{
		get => _marginleft;
		set
		{
			if ( _marginleft == value ) return;
			_marginleft = value;
			Dirty();
		}
	}

	internal Length? _margintop;
	
	/// <summary>
	/// Represents the <c>margin-top</c> CSS property.
	/// </summary>
	public Length? MarginTop
	{
		get => _margintop;
		set
		{
			if ( _margintop == value ) return;
			_margintop = value;
			Dirty();
		}
	}

	internal Length? _marginright;
	
	/// <summary>
	/// Represents the <c>margin-right</c> CSS property.
	/// </summary>
	public Length? MarginRight
	{
		get => _marginright;
		set
		{
			if ( _marginright == value ) return;
			_marginright = value;
			Dirty();
		}
	}

	internal Length? _marginbottom;
	
	/// <summary>
	/// Represents the <c>margin-bottom</c> CSS property.
	/// </summary>
	public Length? MarginBottom
	{
		get => _marginbottom;
		set
		{
			if ( _marginbottom == value ) return;
			_marginbottom = value;
			Dirty();
		}
	}

	internal Length? _bordertopleftradius;
	
	/// <summary>
	/// Represents the <c>border-top-left-radius</c> CSS property.
	/// </summary>
	public Length? BorderTopLeftRadius
	{
		get => _bordertopleftradius;
		set
		{
			if ( _bordertopleftradius == value ) return;
			_bordertopleftradius = value;
			Dirty();
		}
	}

	internal Length? _bordertoprightradius;
	
	/// <summary>
	/// Represents the <c>border-top-right-radius</c> CSS property.
	/// </summary>
	public Length? BorderTopRightRadius
	{
		get => _bordertoprightradius;
		set
		{
			if ( _bordertoprightradius == value ) return;
			_bordertoprightradius = value;
			Dirty();
		}
	}

	internal Length? _borderbottomrightradius;
	
	/// <summary>
	/// Represents the <c>border-bottom-right-radius</c> CSS property.
	/// </summary>
	public Length? BorderBottomRightRadius
	{
		get => _borderbottomrightradius;
		set
		{
			if ( _borderbottomrightradius == value ) return;
			_borderbottomrightradius = value;
			Dirty();
		}
	}

	internal Length? _borderbottomleftradius;
	
	/// <summary>
	/// Represents the <c>border-bottom-left-radius</c> CSS property.
	/// </summary>
	public Length? BorderBottomLeftRadius
	{
		get => _borderbottomleftradius;
		set
		{
			if ( _borderbottomleftradius == value ) return;
			_borderbottomleftradius = value;
			Dirty();
		}
	}

	internal Length? _borderleftwidth;
	
	/// <summary>
	/// Represents the <c>border-left-width</c> CSS property.
	/// </summary>
	public Length? BorderLeftWidth
	{
		get => _borderleftwidth;
		set
		{
			if ( _borderleftwidth == value ) return;
			_borderleftwidth = value;
			Dirty();
		}
	}

	internal Length? _bordertopwidth;
	
	/// <summary>
	/// Represents the <c>border-top-width</c> CSS property.
	/// </summary>
	public Length? BorderTopWidth
	{
		get => _bordertopwidth;
		set
		{
			if ( _bordertopwidth == value ) return;
			_bordertopwidth = value;
			Dirty();
		}
	}

	internal Length? _borderrightwidth;
	
	/// <summary>
	/// Represents the <c>border-right-width</c> CSS property.
	/// </summary>
	public Length? BorderRightWidth
	{
		get => _borderrightwidth;
		set
		{
			if ( _borderrightwidth == value ) return;
			_borderrightwidth = value;
			Dirty();
		}
	}

	internal Length? _borderbottomwidth;
	
	/// <summary>
	/// Represents the <c>border-bottom-width</c> CSS property.
	/// </summary>
	public Length? BorderBottomWidth
	{
		get => _borderbottomwidth;
		set
		{
			if ( _borderbottomwidth == value ) return;
			_borderbottomwidth = value;
			Dirty();
		}
	}

	internal Color? _borderleftcolor;
	
	/// <summary>
	/// Represents the <c>border-left-color</c> CSS property.
	/// </summary>
	public Color? BorderLeftColor
	{
		get => _borderleftcolor;
		set
		{
			if ( _borderleftcolor == value ) return;
			_borderleftcolor = value;
			Dirty();
		}
	}

	internal Color? _bordertopcolor;
	
	/// <summary>
	/// Represents the <c>border-top-color</c> CSS property.
	/// </summary>
	public Color? BorderTopColor
	{
		get => _bordertopcolor;
		set
		{
			if ( _bordertopcolor == value ) return;
			_bordertopcolor = value;
			Dirty();
		}
	}

	internal Color? _borderrightcolor;
	
	/// <summary>
	/// Represents the <c>border-right-color</c> CSS property.
	/// </summary>
	public Color? BorderRightColor
	{
		get => _borderrightcolor;
		set
		{
			if ( _borderrightcolor == value ) return;
			_borderrightcolor = value;
			Dirty();
		}
	}

	internal Color? _borderbottomcolor;
	
	/// <summary>
	/// Represents the <c>border-bottom-color</c> CSS property.
	/// </summary>
	public Color? BorderBottomColor
	{
		get => _borderbottomcolor;
		set
		{
			if ( _borderbottomcolor == value ) return;
			_borderbottomcolor = value;
			Dirty();
		}
	}

	internal Length? _fontsize;
	
	/// <summary>
	/// Represents the <c>font-size</c> CSS property.
	/// </summary>
	public Length? FontSize
	{
		get => _fontsize;
		set
		{
			if ( _fontsize == value ) return;
			_fontsize = value;
			Dirty();
		}
	}

	internal Color? _fontcolor;
	
	/// <summary>
	/// Represents the <c>font-color</c> CSS property.
	/// </summary>
	public Color? FontColor
	{
		get => _fontcolor;
		set
		{
			if ( _fontcolor == value ) return;
			_fontcolor = value;
			Dirty();
		}
	}

	internal int? _fontweight;
	
	/// <summary>
	/// Represents the <c>font-weight</c> CSS property.
	/// </summary>
	public int? FontWeight
	{
		get => _fontweight;
		set
		{
			if ( _fontweight == value ) return;
			_fontweight = value;
			Dirty();
		}
	}

	internal string _fontfamily;
	
	/// <summary>
	/// Represents the <c>font-family</c> CSS property.
	/// </summary>
	public string FontFamily
	{
		get => _fontfamily;
		set
		{
			if ( _fontfamily == value ) return;
			_fontfamily = value;
			Dirty();
		}
	}

	internal Color? _caretcolor;
	
	/// <summary>
	/// Represents the <c>caret-color</c> CSS property.
	/// </summary>
	public Color? CaretColor
	{
		get => _caretcolor;
		set
		{
			if ( _caretcolor == value ) return;
			_caretcolor = value;
			Dirty();
		}
	}

	internal string _cursor;
	
	/// <summary>
	/// Represents the <c>cursor</c> CSS property.
	/// </summary>
	public string Cursor
	{
		get => _cursor;
		set
		{
			if ( _cursor == value ) return;
			_cursor = value;
			Dirty();
		}
	}

	internal PointerEvents? _pointerevents;
	
	/// <summary>
	/// Represents the <c>pointer-events</c> CSS property.
	/// </summary>
	public PointerEvents? PointerEvents
	{
		get => _pointerevents;
		set
		{
			if ( _pointerevents == value ) return;
			_pointerevents = value;
			Dirty();
		}
	}

	internal string _mixblendmode;
	
	/// <summary>
	/// Represents the <c>mix-blend-mode</c> CSS property.
	/// </summary>
	public string MixBlendMode
	{
		get => _mixblendmode;
		set
		{
			if ( _mixblendmode == value ) return;
			_mixblendmode = value;
			Dirty();
		}
	}

	internal PositionMode? _position;
	
	/// <summary>
	/// Represents the <c>position</c> CSS property.
	/// </summary>
	public PositionMode? Position
	{
		get => _position;
		set
		{
			if ( _position == value ) return;
			_position = value;
			Dirty();
		}
	}

	internal OverflowMode? _overflowx;
	
	/// <summary>
	/// Represents the <c>overflow-x</c> CSS property.
	/// </summary>
	public OverflowMode? OverflowX
	{
		get => _overflowx;
		set
		{
			if ( _overflowx == value ) return;
			_overflowx = value;
			Dirty();
		}
	}

	internal OverflowMode? _overflowy;
	
	/// <summary>
	/// Represents the <c>overflow-y</c> CSS property.
	/// </summary>
	public OverflowMode? OverflowY
	{
		get => _overflowy;
		set
		{
			if ( _overflowy == value ) return;
			_overflowy = value;
			Dirty();
		}
	}

	internal FlexDirection? _flexdirection;
	
	/// <summary>
	/// Represents the <c>flex-direction</c> CSS property.
	/// </summary>
	public FlexDirection? FlexDirection
	{
		get => _flexdirection;
		set
		{
			if ( _flexdirection == value ) return;
			_flexdirection = value;
			Dirty();
		}
	}

	internal Justify? _justifycontent;
	
	/// <summary>
	/// Represents the <c>justify-content</c> CSS property.
	/// </summary>
	public Justify? JustifyContent
	{
		get => _justifycontent;
		set
		{
			if ( _justifycontent == value ) return;
			_justifycontent = value;
			Dirty();
		}
	}

	internal DisplayMode? _display;
	
	/// <summary>
	/// Represents the <c>display</c> CSS property.
	/// </summary>
	public DisplayMode? Display
	{
		get => _display;
		set
		{
			if ( _display == value ) return;
			_display = value;
			Dirty();
		}
	}

	internal Wrap? _flexwrap;
	
	/// <summary>
	/// Represents the <c>flex-wrap</c> CSS property.
	/// </summary>
	public Wrap? FlexWrap
	{
		get => _flexwrap;
		set
		{
			if ( _flexwrap == value ) return;
			_flexwrap = value;
			Dirty();
		}
	}

	internal Align? _aligncontent;
	
	/// <summary>
	/// Represents the <c>align-content</c> CSS property.
	/// </summary>
	public Align? AlignContent
	{
		get => _aligncontent;
		set
		{
			if ( _aligncontent == value ) return;
			_aligncontent = value;
			Dirty();
		}
	}

	internal Align? _alignself;
	
	/// <summary>
	/// Represents the <c>align-self</c> CSS property.
	/// </summary>
	public Align? AlignSelf
	{
		get => _alignself;
		set
		{
			if ( _alignself == value ) return;
			_alignself = value;
			Dirty();
		}
	}

	internal Align? _alignitems;
	
	/// <summary>
	/// Represents the <c>align-items</c> CSS property.
	/// </summary>
	public Align? AlignItems
	{
		get => _alignitems;
		set
		{
			if ( _alignitems == value ) return;
			_alignitems = value;
			Dirty();
		}
	}

	internal Length? _flexbasis;
	
	/// <summary>
	/// Represents the <c>flex-basis</c> CSS property.
	/// </summary>
	public Length? FlexBasis
	{
		get => _flexbasis;
		set
		{
			if ( _flexbasis == value ) return;
			_flexbasis = value;
			Dirty();
		}
	}

	internal float? _flexgrow;
	
	/// <summary>
	/// Represents the <c>flex-grow</c> CSS property.
	/// </summary>
	public float? FlexGrow
	{
		get => _flexgrow;
		set
		{
			if ( _flexgrow == value ) return;
			_flexgrow = value;
			Dirty();
		}
	}

	internal float? _flexshrink;
	
	/// <summary>
	/// Represents the <c>flex-shrink</c> CSS property.
	/// </summary>
	public float? FlexShrink
	{
		get => _flexshrink;
		set
		{
			if ( _flexshrink == value ) return;
			_flexshrink = value;
			Dirty();
		}
	}

	internal Length? _rowgap;
	
	/// <summary>
	/// Represents the <c>row-gap</c> CSS property.
	/// </summary>
	public Length? RowGap
	{
		get => _rowgap;
		set
		{
			if ( _rowgap == value ) return;
			_rowgap = value;
			Dirty();
		}
	}

	internal Length? _columngap;
	
	/// <summary>
	/// Represents the <c>column-gap</c> CSS property.
	/// </summary>
	public Length? ColumnGap
	{
		get => _columngap;
		set
		{
			if ( _columngap == value ) return;
			_columngap = value;
			Dirty();
		}
	}

	internal float? _aspectratio;
	
	/// <summary>
	/// Represents the <c>aspect-ratio</c> CSS property.
	/// </summary>
	public float? AspectRatio
	{
		get => _aspectratio;
		set
		{
			if ( _aspectratio == value ) return;
			_aspectratio = value;
			Dirty();
		}
	}

	internal TextAlign? _textalign;
	
	/// <summary>
	/// Represents the <c>text-align</c> CSS property.
	/// </summary>
	public TextAlign? TextAlign
	{
		get => _textalign;
		set
		{
			if ( _textalign == value ) return;
			_textalign = value;
			Dirty();
		}
	}

	internal TextOverflow? _textoverflow;
	
	/// <summary>
	/// Represents the <c>text-overflow</c> CSS property.
	/// </summary>
	public TextOverflow? TextOverflow
	{
		get => _textoverflow;
		set
		{
			if ( _textoverflow == value ) return;
			_textoverflow = value;
			Dirty();
		}
	}

	internal Rendering.FilterMode? _textfilter;
	
	/// <summary>
	/// Represents the <c>text-filter</c> CSS property.
	/// </summary>
	public Rendering.FilterMode? TextFilter
	{
		get => _textfilter;
		set
		{
			if ( _textfilter == value ) return;
			_textfilter = value;
			Dirty();
		}
	}

	internal WordBreak? _wordbreak;
	
	/// <summary>
	/// Represents the <c>word-break</c> CSS property.
	/// </summary>
	public WordBreak? WordBreak
	{
		get => _wordbreak;
		set
		{
			if ( _wordbreak == value ) return;
			_wordbreak = value;
			Dirty();
		}
	}

	internal TextDecoration? _textdecorationline;
	
	/// <summary>
	/// Represents the <c>text-decoration-line</c> CSS property.
	/// </summary>
	public TextDecoration? TextDecorationLine
	{
		get => _textdecorationline;
		set
		{
			if ( _textdecorationline == value ) return;
			_textdecorationline = value;
			Dirty();
		}
	}

	internal Color? _textdecorationcolor;
	
	/// <summary>
	/// Represents the <c>text-decoration-color</c> CSS property.
	/// </summary>
	public Color? TextDecorationColor
	{
		get => _textdecorationcolor;
		set
		{
			if ( _textdecorationcolor == value ) return;
			_textdecorationcolor = value;
			Dirty();
		}
	}

	internal Length? _textdecorationthickness;
	
	/// <summary>
	/// Represents the <c>text-decoration-thickness</c> CSS property.
	/// </summary>
	public Length? TextDecorationThickness
	{
		get => _textdecorationthickness;
		set
		{
			if ( _textdecorationthickness == value ) return;
			_textdecorationthickness = value;
			Dirty();
		}
	}

	internal TextSkipInk? _textdecorationskipink;
	
	/// <summary>
	/// Represents the <c>text-decoration-skip-ink</c> CSS property.
	/// </summary>
	public TextSkipInk? TextDecorationSkipInk
	{
		get => _textdecorationskipink;
		set
		{
			if ( _textdecorationskipink == value ) return;
			_textdecorationskipink = value;
			Dirty();
		}
	}

	internal TextDecorationStyle? _textdecorationstyle;
	
	/// <summary>
	/// Represents the <c>text-decoration-style</c> CSS property.
	/// </summary>
	public TextDecorationStyle? TextDecorationStyle
	{
		get => _textdecorationstyle;
		set
		{
			if ( _textdecorationstyle == value ) return;
			_textdecorationstyle = value;
			Dirty();
		}
	}

	internal Length? _textunderlineoffset;
	
	/// <summary>
	/// Represents the <c>text-underline-offset</c> CSS property.
	/// </summary>
	public Length? TextUnderlineOffset
	{
		get => _textunderlineoffset;
		set
		{
			if ( _textunderlineoffset == value ) return;
			_textunderlineoffset = value;
			Dirty();
		}
	}

	internal Length? _textoverlineoffset;
	
	/// <summary>
	/// Represents the <c>text-overline-offset</c> CSS property.
	/// </summary>
	public Length? TextOverlineOffset
	{
		get => _textoverlineoffset;
		set
		{
			if ( _textoverlineoffset == value ) return;
			_textoverlineoffset = value;
			Dirty();
		}
	}

	internal Length? _textlinethroughoffset;
	
	/// <summary>
	/// Represents the <c>text-line-through-offset</c> CSS property.
	/// </summary>
	public Length? TextLineThroughOffset
	{
		get => _textlinethroughoffset;
		set
		{
			if ( _textlinethroughoffset == value ) return;
			_textlinethroughoffset = value;
			Dirty();
		}
	}

	internal FontStyle? _fontstyle;
	
	/// <summary>
	/// Represents the <c>font-style</c> CSS property.
	/// </summary>
	public FontStyle? FontStyle
	{
		get => _fontstyle;
		set
		{
			if ( _fontstyle == value ) return;
			_fontstyle = value;
			Dirty();
		}
	}

	internal FontVariantNumeric? _fontvariantnumeric;
	
	/// <summary>
	/// Represents the <c>font-variant-numeric</c> CSS property.
	/// </summary>
	public FontVariantNumeric? FontVariantNumeric
	{
		get => _fontvariantnumeric;
		set
		{
			if ( _fontvariantnumeric == value ) return;
			_fontvariantnumeric = value;
			Dirty();
		}
	}

	internal PanelTransform? _transform;
	
	/// <summary>
	/// Represents the <c>transform</c> CSS property.
	/// </summary>
	public PanelTransform? Transform
	{
		get => _transform;
		set
		{
			if ( _transform == value ) return;
			_transform = value;
			Dirty();
		}
	}

	internal TextTransform? _texttransform;
	
	/// <summary>
	/// Represents the <c>text-transform</c> CSS property.
	/// </summary>
	public TextTransform? TextTransform
	{
		get => _texttransform;
		set
		{
			if ( _texttransform == value ) return;
			_texttransform = value;
			Dirty();
		}
	}

	internal Length? _transformoriginx;
	
	/// <summary>
	/// Represents the <c>transform-origin-x</c> CSS property.
	/// </summary>
	public Length? TransformOriginX
	{
		get => _transformoriginx;
		set
		{
			if ( _transformoriginx == value ) return;
			_transformoriginx = value;
			Dirty();
		}
	}

	internal Length? _transformoriginy;
	
	/// <summary>
	/// Represents the <c>transform-origin-y</c> CSS property.
	/// </summary>
	public Length? TransformOriginY
	{
		get => _transformoriginy;
		set
		{
			if ( _transformoriginy == value ) return;
			_transformoriginy = value;
			Dirty();
		}
	}

	internal Length? _letterspacing;
	
	/// <summary>
	/// Represents the <c>letter-spacing</c> CSS property.
	/// </summary>
	public Length? LetterSpacing
	{
		get => _letterspacing;
		set
		{
			if ( _letterspacing == value ) return;
			_letterspacing = value;
			Dirty();
		}
	}

	internal Length? _lineheight;
	
	/// <summary>
	/// Represents the <c>line-height</c> CSS property.
	/// </summary>
	public Length? LineHeight
	{
		get => _lineheight;
		set
		{
			if ( _lineheight == value ) return;
			_lineheight = value;
			Dirty();
		}
	}

	internal Length? _wordspacing;
	
	/// <summary>
	/// Represents the <c>word-spacing</c> CSS property.
	/// </summary>
	public Length? WordSpacing
	{
		get => _wordspacing;
		set
		{
			if ( _wordspacing == value ) return;
			_wordspacing = value;
			Dirty();
		}
	}

	internal WhiteSpace? _whitespace;
	
	/// <summary>
	/// Represents the <c>white-space</c> CSS property.
	/// </summary>
	public WhiteSpace? WhiteSpace
	{
		get => _whitespace;
		set
		{
			if ( _whitespace == value ) return;
			_whitespace = value;
			Dirty();
		}
	}

	internal int? _zindex;
	
	/// <summary>
	/// Represents the <c>z-index</c> CSS property.
	/// </summary>
	public int? ZIndex
	{
		get => _zindex;
		set
		{
			if ( _zindex == value ) return;
			_zindex = value;
			Dirty();
		}
	}

	internal int? _order;
	
	/// <summary>
	/// Represents the <c>order</c> CSS property.
	/// </summary>
	public int? Order
	{
		get => _order;
		set
		{
			if ( _order == value ) return;
			_order = value;
			Dirty();
		}
	}

	internal string _soundin;
	
	/// <summary>
	/// Represents the <c>sound-in</c> CSS property.
	/// </summary>
	public string SoundIn
	{
		get => _soundin;
		set
		{
			if ( _soundin == value ) return;
			_soundin = value;
			Dirty();
		}
	}

	internal string _soundout;
	
	/// <summary>
	/// Represents the <c>sound-out</c> CSS property.
	/// </summary>
	public string SoundOut
	{
		get => _soundout;
		set
		{
			if ( _soundout == value ) return;
			_soundout = value;
			Dirty();
		}
	}

	internal Length? _backdropfilterblur;
	
	/// <summary>
	/// Represents the <c>backdrop-filter-blur</c> CSS property.
	/// </summary>
	public Length? BackdropFilterBlur
	{
		get => _backdropfilterblur;
		set
		{
			if ( _backdropfilterblur == value ) return;
			_backdropfilterblur = value;
			Dirty();
		}
	}

	internal Length? _backdropfilterbrightness;
	
	/// <summary>
	/// Represents the <c>backdrop-filter-brightness</c> CSS property.
	/// </summary>
	public Length? BackdropFilterBrightness
	{
		get => _backdropfilterbrightness;
		set
		{
			if ( _backdropfilterbrightness == value ) return;
			_backdropfilterbrightness = value;
			Dirty();
		}
	}

	internal Length? _backdropfiltercontrast;
	
	/// <summary>
	/// Represents the <c>backdrop-filter-contrast</c> CSS property.
	/// </summary>
	public Length? BackdropFilterContrast
	{
		get => _backdropfiltercontrast;
		set
		{
			if ( _backdropfiltercontrast == value ) return;
			_backdropfiltercontrast = value;
			Dirty();
		}
	}

	internal Length? _backdropfiltersaturate;
	
	/// <summary>
	/// Represents the <c>backdrop-filter-saturate</c> CSS property.
	/// </summary>
	public Length? BackdropFilterSaturate
	{
		get => _backdropfiltersaturate;
		set
		{
			if ( _backdropfiltersaturate == value ) return;
			_backdropfiltersaturate = value;
			Dirty();
		}
	}

	internal Length? _backdropfiltersepia;
	
	/// <summary>
	/// Represents the <c>backdrop-filter-sepia</c> CSS property.
	/// </summary>
	public Length? BackdropFilterSepia
	{
		get => _backdropfiltersepia;
		set
		{
			if ( _backdropfiltersepia == value ) return;
			_backdropfiltersepia = value;
			Dirty();
		}
	}

	internal Length? _backdropfilterinvert;
	
	/// <summary>
	/// Represents the <c>backdrop-filter-invert</c> CSS property.
	/// </summary>
	public Length? BackdropFilterInvert
	{
		get => _backdropfilterinvert;
		set
		{
			if ( _backdropfilterinvert == value ) return;
			_backdropfilterinvert = value;
			Dirty();
		}
	}

	internal Length? _backdropfilterhuerotate;
	
	/// <summary>
	/// Represents the <c>backdrop-filter-hue-rotate</c> CSS property.
	/// </summary>
	public Length? BackdropFilterHueRotate
	{
		get => _backdropfilterhuerotate;
		set
		{
			if ( _backdropfilterhuerotate == value ) return;
			_backdropfilterhuerotate = value;
			Dirty();
		}
	}

	internal Length? _filterblur;
	
	/// <summary>
	/// Represents the <c>filter-blur</c> CSS property.
	/// </summary>
	public Length? FilterBlur
	{
		get => _filterblur;
		set
		{
			if ( _filterblur == value ) return;
			_filterblur = value;
			Dirty();
		}
	}

	internal Length? _filtersaturate;
	
	/// <summary>
	/// Represents the <c>filter-saturate</c> CSS property.
	/// </summary>
	public Length? FilterSaturate
	{
		get => _filtersaturate;
		set
		{
			if ( _filtersaturate == value ) return;
			_filtersaturate = value;
			Dirty();
		}
	}

	internal Length? _filtersepia;
	
	/// <summary>
	/// Represents the <c>filter-sepia</c> CSS property.
	/// </summary>
	public Length? FilterSepia
	{
		get => _filtersepia;
		set
		{
			if ( _filtersepia == value ) return;
			_filtersepia = value;
			Dirty();
		}
	}

	internal Length? _filterbrightness;
	
	/// <summary>
	/// Represents the <c>filter-brightness</c> CSS property.
	/// </summary>
	public Length? FilterBrightness
	{
		get => _filterbrightness;
		set
		{
			if ( _filterbrightness == value ) return;
			_filterbrightness = value;
			Dirty();
		}
	}

	internal Length? _filterhuerotate;
	
	/// <summary>
	/// Represents the <c>filter-hue-rotate</c> CSS property.
	/// </summary>
	public Length? FilterHueRotate
	{
		get => _filterhuerotate;
		set
		{
			if ( _filterhuerotate == value ) return;
			_filterhuerotate = value;
			Dirty();
		}
	}

	internal Length? _filterinvert;
	
	/// <summary>
	/// Represents the <c>filter-invert</c> CSS property.
	/// </summary>
	public Length? FilterInvert
	{
		get => _filterinvert;
		set
		{
			if ( _filterinvert == value ) return;
			_filterinvert = value;
			Dirty();
		}
	}

	internal Length? _filtercontrast;
	
	/// <summary>
	/// Represents the <c>filter-contrast</c> CSS property.
	/// </summary>
	public Length? FilterContrast
	{
		get => _filtercontrast;
		set
		{
			if ( _filtercontrast == value ) return;
			_filtercontrast = value;
			Dirty();
		}
	}

	internal Color? _filtertint;
	
	/// <summary>
	/// Represents the <c>filter-tint</c> CSS property.
	/// </summary>
	public Color? FilterTint
	{
		get => _filtertint;
		set
		{
			if ( _filtertint == value ) return;
			_filtertint = value;
			Dirty();
		}
	}

	internal Length? _filterborderwidth;
	
	/// <summary>
	/// Represents the <c>filter-border-width</c> CSS property.
	/// </summary>
	public Length? FilterBorderWidth
	{
		get => _filterborderwidth;
		set
		{
			if ( _filterborderwidth == value ) return;
			_filterborderwidth = value;
			Dirty();
		}
	}

	internal Color? _filterbordercolor;
	
	/// <summary>
	/// Represents the <c>filter-border-color</c> CSS property.
	/// </summary>
	public Color? FilterBorderColor
	{
		get => _filterbordercolor;
		set
		{
			if ( _filterbordercolor == value ) return;
			_filterbordercolor = value;
			Dirty();
		}
	}

	internal MaskMode? _maskmode;
	
	/// <summary>
	/// Represents the <c>mask-mode</c> CSS property.
	/// </summary>
	public MaskMode? MaskMode
	{
		get => _maskmode;
		set
		{
			if ( _maskmode == value ) return;
			_maskmode = value;
			Dirty();
		}
	}

	internal BackgroundRepeat? _maskrepeat;
	
	/// <summary>
	/// Represents the <c>mask-repeat</c> CSS property.
	/// </summary>
	public BackgroundRepeat? MaskRepeat
	{
		get => _maskrepeat;
		set
		{
			if ( _maskrepeat == value ) return;
			_maskrepeat = value;
			Dirty();
		}
	}

	internal Length? _masksizex;
	
	/// <summary>
	/// Represents the <c>mask-size-x</c> CSS property.
	/// </summary>
	public Length? MaskSizeX
	{
		get => _masksizex;
		set
		{
			if ( _masksizex == value ) return;
			_masksizex = value;
			Dirty();
		}
	}

	internal Length? _masksizey;
	
	/// <summary>
	/// Represents the <c>mask-size-y</c> CSS property.
	/// </summary>
	public Length? MaskSizeY
	{
		get => _masksizey;
		set
		{
			if ( _masksizey == value ) return;
			_masksizey = value;
			Dirty();
		}
	}

	internal Length? _maskpositionx;
	
	/// <summary>
	/// Represents the <c>mask-position-x</c> CSS property.
	/// </summary>
	public Length? MaskPositionX
	{
		get => _maskpositionx;
		set
		{
			if ( _maskpositionx == value ) return;
			_maskpositionx = value;
			Dirty();
		}
	}

	internal Length? _maskpositiony;
	
	/// <summary>
	/// Represents the <c>mask-position-y</c> CSS property.
	/// </summary>
	public Length? MaskPositionY
	{
		get => _maskpositiony;
		set
		{
			if ( _maskpositiony == value ) return;
			_maskpositiony = value;
			Dirty();
		}
	}

	internal Length? _maskangle;
	
	/// <summary>
	/// Represents the <c>mask-angle</c> CSS property.
	/// </summary>
	public Length? MaskAngle
	{
		get => _maskangle;
		set
		{
			if ( _maskangle == value ) return;
			_maskangle = value;
			Dirty();
		}
	}

	internal MaskScope? _maskscope;
	
	/// <summary>
	/// Represents the <c>mask-scope</c> CSS property.
	/// </summary>
	public MaskScope? MaskScope
	{
		get => _maskscope;
		set
		{
			if ( _maskscope == value ) return;
			_maskscope = value;
			Dirty();
		}
	}

	internal Length? _backgroundsizex;
	
	/// <summary>
	/// Represents the <c>background-size-x</c> CSS property.
	/// </summary>
	public Length? BackgroundSizeX
	{
		get => _backgroundsizex;
		set
		{
			if ( _backgroundsizex == value ) return;
			_backgroundsizex = value;
			Dirty();
		}
	}

	internal Length? _backgroundsizey;
	
	/// <summary>
	/// Represents the <c>background-size-y</c> CSS property.
	/// </summary>
	public Length? BackgroundSizeY
	{
		get => _backgroundsizey;
		set
		{
			if ( _backgroundsizey == value ) return;
			_backgroundsizey = value;
			Dirty();
		}
	}

	internal Length? _backgroundpositionx;
	
	/// <summary>
	/// Represents the <c>background-position-x</c> CSS property.
	/// </summary>
	public Length? BackgroundPositionX
	{
		get => _backgroundpositionx;
		set
		{
			if ( _backgroundpositionx == value ) return;
			_backgroundpositionx = value;
			Dirty();
		}
	}

	internal Length? _backgroundpositiony;
	
	/// <summary>
	/// Represents the <c>background-position-y</c> CSS property.
	/// </summary>
	public Length? BackgroundPositionY
	{
		get => _backgroundpositiony;
		set
		{
			if ( _backgroundpositiony == value ) return;
			_backgroundpositiony = value;
			Dirty();
		}
	}

	internal BackgroundRepeat? _backgroundrepeat;
	
	/// <summary>
	/// Represents the <c>background-repeat</c> CSS property.
	/// </summary>
	public BackgroundRepeat? BackgroundRepeat
	{
		get => _backgroundrepeat;
		set
		{
			if ( _backgroundrepeat == value ) return;
			_backgroundrepeat = value;
			Dirty();
		}
	}

	internal Length? _borderimagewidthleft;
	
	/// <summary>
	/// Represents the <c>border-image-width-left</c> CSS property.
	/// </summary>
	public Length? BorderImageWidthLeft
	{
		get => _borderimagewidthleft;
		set
		{
			if ( _borderimagewidthleft == value ) return;
			_borderimagewidthleft = value;
			Dirty();
		}
	}

	internal Length? _borderimagewidthright;
	
	/// <summary>
	/// Represents the <c>border-image-width-right</c> CSS property.
	/// </summary>
	public Length? BorderImageWidthRight
	{
		get => _borderimagewidthright;
		set
		{
			if ( _borderimagewidthright == value ) return;
			_borderimagewidthright = value;
			Dirty();
		}
	}

	internal Length? _borderimagewidthtop;
	
	/// <summary>
	/// Represents the <c>border-image-width-top</c> CSS property.
	/// </summary>
	public Length? BorderImageWidthTop
	{
		get => _borderimagewidthtop;
		set
		{
			if ( _borderimagewidthtop == value ) return;
			_borderimagewidthtop = value;
			Dirty();
		}
	}

	internal Length? _borderimagewidthbottom;
	
	/// <summary>
	/// Represents the <c>border-image-width-bottom</c> CSS property.
	/// </summary>
	public Length? BorderImageWidthBottom
	{
		get => _borderimagewidthbottom;
		set
		{
			if ( _borderimagewidthbottom == value ) return;
			_borderimagewidthbottom = value;
			Dirty();
		}
	}

	internal BorderImageFill? _borderimagefill;
	
	/// <summary>
	/// Represents the <c>border-image-fill</c> CSS property.
	/// </summary>
	public BorderImageFill? BorderImageFill
	{
		get => _borderimagefill;
		set
		{
			if ( _borderimagefill == value ) return;
			_borderimagefill = value;
			Dirty();
		}
	}

	internal BorderImageRepeat? _borderimagerepeat;
	
	/// <summary>
	/// Represents the <c>border-image-repeat</c> CSS property.
	/// </summary>
	public BorderImageRepeat? BorderImageRepeat
	{
		get => _borderimagerepeat;
		set
		{
			if ( _borderimagerepeat == value ) return;
			_borderimagerepeat = value;
			Dirty();
		}
	}

	internal Color? _borderimagetint;
	
	/// <summary>
	/// Represents the <c>border-image-tint</c> CSS property.
	/// </summary>
	public Color? BorderImageTint
	{
		get => _borderimagetint;
		set
		{
			if ( _borderimagetint == value ) return;
			_borderimagetint = value;
			Dirty();
		}
	}

	internal string _backgroundblendmode;
	
	/// <summary>
	/// Represents the <c>background-blend-mode</c> CSS property.
	/// </summary>
	public string BackgroundBlendMode
	{
		get => _backgroundblendmode;
		set
		{
			if ( _backgroundblendmode == value ) return;
			_backgroundblendmode = value;
			Dirty();
		}
	}

	internal Color? _backgroundtint;
	
	/// <summary>
	/// Represents the <c>background-tint</c> CSS property.
	/// </summary>
	public Color? BackgroundTint
	{
		get => _backgroundtint;
		set
		{
			if ( _backgroundtint == value ) return;
			_backgroundtint = value;
			Dirty();
		}
	}

	internal Length? _backgroundangle;
	
	/// <summary>
	/// Represents the <c>background-angle</c> CSS property.
	/// </summary>
	public Length? BackgroundAngle
	{
		get => _backgroundangle;
		set
		{
			if ( _backgroundangle == value ) return;
			_backgroundangle = value;
			Dirty();
		}
	}

	internal Length? _textbackgroundangle;
	
	/// <summary>
	/// Represents the <c>text-background-angle</c> CSS property.
	/// </summary>
	public Length? TextBackgroundAngle
	{
		get => _textbackgroundangle;
		set
		{
			if ( _textbackgroundangle == value ) return;
			_textbackgroundangle = value;
			Dirty();
		}
	}

	internal Length? _perspectiveoriginx;
	
	/// <summary>
	/// Represents the <c>perspective-origin-x</c> CSS property.
	/// </summary>
	public Length? PerspectiveOriginX
	{
		get => _perspectiveoriginx;
		set
		{
			if ( _perspectiveoriginx == value ) return;
			_perspectiveoriginx = value;
			Dirty();
		}
	}

	internal Length? _perspectiveoriginy;
	
	/// <summary>
	/// Represents the <c>perspective-origin-y</c> CSS property.
	/// </summary>
	public Length? PerspectiveOriginY
	{
		get => _perspectiveoriginy;
		set
		{
			if ( _perspectiveoriginy == value ) return;
			_perspectiveoriginy = value;
			Dirty();
		}
	}

	internal Color? _textstrokecolor;
	
	/// <summary>
	/// Represents the <c>text-stroke-color</c> CSS property.
	/// </summary>
	public Color? TextStrokeColor
	{
		get => _textstrokecolor;
		set
		{
			if ( _textstrokecolor == value ) return;
			_textstrokecolor = value;
			Dirty();
		}
	}

	internal Length? _textstrokewidth;
	
	/// <summary>
	/// Represents the <c>text-stroke-width</c> CSS property.
	/// </summary>
	public Length? TextStrokeWidth
	{
		get => _textstrokewidth;
		set
		{
			if ( _textstrokewidth == value ) return;
			_textstrokewidth = value;
			Dirty();
		}
	}

	internal ImageRendering? _imagerendering;
	
	/// <summary>
	/// Represents the <c>image-rendering</c> CSS property.
	/// </summary>
	public ImageRendering? ImageRendering
	{
		get => _imagerendering;
		set
		{
			if ( _imagerendering == value ) return;
			_imagerendering = value;
			Dirty();
		}
	}

	internal float? _animationdelay;
	
	/// <summary>
	/// Represents the <c>animation-delay</c> CSS property.
	/// </summary>
	public float? AnimationDelay
	{
		get => _animationdelay;
		set
		{
			if ( _animationdelay == value ) return;
			_animationdelay = value;
			Dirty();
		}
	}

	internal string _animationdirection;
	
	/// <summary>
	/// Represents the <c>animation-direction</c> CSS property.
	/// </summary>
	public string AnimationDirection
	{
		get => _animationdirection;
		set
		{
			if ( _animationdirection == value ) return;
			_animationdirection = value;
			Dirty();
		}
	}

	internal float? _animationduration;
	
	/// <summary>
	/// Represents the <c>animation-duration</c> CSS property.
	/// </summary>
	public float? AnimationDuration
	{
		get => _animationduration;
		set
		{
			if ( _animationduration == value ) return;
			_animationduration = value;
			Dirty();
		}
	}

	internal string _animationfillmode;
	
	/// <summary>
	/// Represents the <c>animation-fill-mode</c> CSS property.
	/// </summary>
	public string AnimationFillMode
	{
		get => _animationfillmode;
		set
		{
			if ( _animationfillmode == value ) return;
			_animationfillmode = value;
			Dirty();
		}
	}

	internal float? _animationiterationcount;
	
	/// <summary>
	/// Represents the <c>animation-iteration-count</c> CSS property.
	/// </summary>
	public float? AnimationIterationCount
	{
		get => _animationiterationcount;
		set
		{
			if ( _animationiterationcount == value ) return;
			_animationiterationcount = value;
			Dirty();
		}
	}

	internal string _animationname;
	
	/// <summary>
	/// Represents the <c>animation-name</c> CSS property.
	/// </summary>
	public string AnimationName
	{
		get => _animationname;
		set
		{
			if ( _animationname == value ) return;
			_animationname = value;
			Dirty();
		}
	}

	internal string _animationplaystate;
	
	/// <summary>
	/// Represents the <c>animation-play-state</c> CSS property.
	/// </summary>
	public string AnimationPlayState
	{
		get => _animationplaystate;
		set
		{
			if ( _animationplaystate == value ) return;
			_animationplaystate = value;
			Dirty();
		}
	}

	internal string _animationtimingfunction;
	
	/// <summary>
	/// Represents the <c>animation-timing-function</c> CSS property.
	/// </summary>
	public string AnimationTimingFunction
	{
		get => _animationtimingfunction;
		set
		{
			if ( _animationtimingfunction == value ) return;
			_animationtimingfunction = value;
			Dirty();
		}
	}

	internal FontSmooth? _fontsmooth;
	
	/// <summary>
	/// Represents the <c>font-smooth</c> CSS property.
	/// </summary>
	public FontSmooth? FontSmooth
	{
		get => _fontsmooth;
		set
		{
			if ( _fontsmooth == value ) return;
			_fontsmooth = value;
			Dirty();
		}
	}

	internal ObjectFit? _objectfit;
	
	/// <summary>
	/// Represents the <c>object-fit</c> CSS property.
	/// </summary>
	public ObjectFit? ObjectFit
	{
		get => _objectfit;
		set
		{
			if ( _objectfit == value ) return;
			_objectfit = value;
			Dirty();
		}
	}

	internal Length? _outlinewidth;
	
	/// <summary>
	/// Represents the <c>outline-width</c> CSS property.
	/// </summary>
	public Length? OutlineWidth
	{
		get => _outlinewidth;
		set
		{
			if ( _outlinewidth == value ) return;
			_outlinewidth = value;
			Dirty();
		}
	}

	internal Color? _outlinecolor;
	
	/// <summary>
	/// Represents the <c>outline-color</c> CSS property.
	/// </summary>
	public Color? OutlineColor
	{
		get => _outlinecolor;
		set
		{
			if ( _outlinecolor == value ) return;
			_outlinecolor = value;
			Dirty();
		}
	}

	internal Length? _outlineoffset;
	
	/// <summary>
	/// Represents the <c>outline-offset</c> CSS property.
	/// </summary>
	public Length? OutlineOffset
	{
		get => _outlineoffset;
		set
		{
			if ( _outlineoffset == value ) return;
			_outlineoffset = value;
			Dirty();
		}
	}

	/// <summary>
	/// Copy over only the styles that are set.
	/// </summary>
	private void AddGenerated( BaseStyles a )
	{
		if ( a._content != null ) _content = a._content;
		if ( a._width != null ) _width = a._width;
		if ( a._minwidth != null ) _minwidth = a._minwidth;
		if ( a._maxwidth != null ) _maxwidth = a._maxwidth;
		if ( a._height != null ) _height = a._height;
		if ( a._minheight != null ) _minheight = a._minheight;
		if ( a._maxheight != null ) _maxheight = a._maxheight;
		if ( a._left != null ) _left = a._left;
		if ( a._top != null ) _top = a._top;
		if ( a._right != null ) _right = a._right;
		if ( a._bottom != null ) _bottom = a._bottom;
		if ( a._opacity != null ) _opacity = a._opacity;
		if ( a._backgroundcolor != null ) _backgroundcolor = a._backgroundcolor;
		if ( a._paddingleft != null ) _paddingleft = a._paddingleft;
		if ( a._paddingtop != null ) _paddingtop = a._paddingtop;
		if ( a._paddingright != null ) _paddingright = a._paddingright;
		if ( a._paddingbottom != null ) _paddingbottom = a._paddingbottom;
		if ( a._marginleft != null ) _marginleft = a._marginleft;
		if ( a._margintop != null ) _margintop = a._margintop;
		if ( a._marginright != null ) _marginright = a._marginright;
		if ( a._marginbottom != null ) _marginbottom = a._marginbottom;
		if ( a._bordertopleftradius != null ) _bordertopleftradius = a._bordertopleftradius;
		if ( a._bordertoprightradius != null ) _bordertoprightradius = a._bordertoprightradius;
		if ( a._borderbottomrightradius != null ) _borderbottomrightradius = a._borderbottomrightradius;
		if ( a._borderbottomleftradius != null ) _borderbottomleftradius = a._borderbottomleftradius;
		if ( a._borderleftwidth != null ) _borderleftwidth = a._borderleftwidth;
		if ( a._bordertopwidth != null ) _bordertopwidth = a._bordertopwidth;
		if ( a._borderrightwidth != null ) _borderrightwidth = a._borderrightwidth;
		if ( a._borderbottomwidth != null ) _borderbottomwidth = a._borderbottomwidth;
		if ( a._borderleftcolor != null ) _borderleftcolor = a._borderleftcolor;
		if ( a._bordertopcolor != null ) _bordertopcolor = a._bordertopcolor;
		if ( a._borderrightcolor != null ) _borderrightcolor = a._borderrightcolor;
		if ( a._borderbottomcolor != null ) _borderbottomcolor = a._borderbottomcolor;
		if ( a._fontsize != null ) _fontsize = a._fontsize;
		if ( a._fontcolor != null ) _fontcolor = a._fontcolor;
		if ( a._fontweight != null ) _fontweight = a._fontweight;
		if ( a._fontfamily != null ) _fontfamily = a._fontfamily;
		if ( a._caretcolor != null ) _caretcolor = a._caretcolor;
		if ( a._cursor != null ) _cursor = a._cursor;
		if ( a._pointerevents != null ) _pointerevents = a._pointerevents;
		if ( a._mixblendmode != null ) _mixblendmode = a._mixblendmode;
		if ( a._position != null ) _position = a._position;
		if ( a._overflowx != null ) _overflowx = a._overflowx;
		if ( a._overflowy != null ) _overflowy = a._overflowy;
		if ( a._flexdirection != null ) _flexdirection = a._flexdirection;
		if ( a._justifycontent != null ) _justifycontent = a._justifycontent;
		if ( a._display != null ) _display = a._display;
		if ( a._flexwrap != null ) _flexwrap = a._flexwrap;
		if ( a._aligncontent != null ) _aligncontent = a._aligncontent;
		if ( a._alignself != null ) _alignself = a._alignself;
		if ( a._alignitems != null ) _alignitems = a._alignitems;
		if ( a._flexbasis != null ) _flexbasis = a._flexbasis;
		if ( a._flexgrow != null ) _flexgrow = a._flexgrow;
		if ( a._flexshrink != null ) _flexshrink = a._flexshrink;
		if ( a._rowgap != null ) _rowgap = a._rowgap;
		if ( a._columngap != null ) _columngap = a._columngap;
		if ( a._aspectratio != null ) _aspectratio = a._aspectratio;
		if ( a._textalign != null ) _textalign = a._textalign;
		if ( a._textoverflow != null ) _textoverflow = a._textoverflow;
		if ( a._textfilter != null ) _textfilter = a._textfilter;
		if ( a._wordbreak != null ) _wordbreak = a._wordbreak;
		if ( a._textdecorationline != null ) _textdecorationline = a._textdecorationline;
		if ( a._textdecorationcolor != null ) _textdecorationcolor = a._textdecorationcolor;
		if ( a._textdecorationthickness != null ) _textdecorationthickness = a._textdecorationthickness;
		if ( a._textdecorationskipink != null ) _textdecorationskipink = a._textdecorationskipink;
		if ( a._textdecorationstyle != null ) _textdecorationstyle = a._textdecorationstyle;
		if ( a._textunderlineoffset != null ) _textunderlineoffset = a._textunderlineoffset;
		if ( a._textoverlineoffset != null ) _textoverlineoffset = a._textoverlineoffset;
		if ( a._textlinethroughoffset != null ) _textlinethroughoffset = a._textlinethroughoffset;
		if ( a._fontstyle != null ) _fontstyle = a._fontstyle;
		if ( a._fontvariantnumeric != null ) _fontvariantnumeric = a._fontvariantnumeric;
		if ( a._transform != null ) _transform = a._transform;
		if ( a._texttransform != null ) _texttransform = a._texttransform;
		if ( a._transformoriginx != null ) _transformoriginx = a._transformoriginx;
		if ( a._transformoriginy != null ) _transformoriginy = a._transformoriginy;
		if ( a._letterspacing != null ) _letterspacing = a._letterspacing;
		if ( a._lineheight != null ) _lineheight = a._lineheight;
		if ( a._wordspacing != null ) _wordspacing = a._wordspacing;
		if ( a._whitespace != null ) _whitespace = a._whitespace;
		if ( a._zindex != null ) _zindex = a._zindex;
		if ( a._order != null ) _order = a._order;
		if ( a._soundin != null ) _soundin = a._soundin;
		if ( a._soundout != null ) _soundout = a._soundout;
		if ( a._backdropfilterblur != null ) _backdropfilterblur = a._backdropfilterblur;
		if ( a._backdropfilterbrightness != null ) _backdropfilterbrightness = a._backdropfilterbrightness;
		if ( a._backdropfiltercontrast != null ) _backdropfiltercontrast = a._backdropfiltercontrast;
		if ( a._backdropfiltersaturate != null ) _backdropfiltersaturate = a._backdropfiltersaturate;
		if ( a._backdropfiltersepia != null ) _backdropfiltersepia = a._backdropfiltersepia;
		if ( a._backdropfilterinvert != null ) _backdropfilterinvert = a._backdropfilterinvert;
		if ( a._backdropfilterhuerotate != null ) _backdropfilterhuerotate = a._backdropfilterhuerotate;
		if ( a._filterblur != null ) _filterblur = a._filterblur;
		if ( a._filtersaturate != null ) _filtersaturate = a._filtersaturate;
		if ( a._filtersepia != null ) _filtersepia = a._filtersepia;
		if ( a._filterbrightness != null ) _filterbrightness = a._filterbrightness;
		if ( a._filterhuerotate != null ) _filterhuerotate = a._filterhuerotate;
		if ( a._filterinvert != null ) _filterinvert = a._filterinvert;
		if ( a._filtercontrast != null ) _filtercontrast = a._filtercontrast;
		if ( a._filtertint != null ) _filtertint = a._filtertint;
		if ( a._filterborderwidth != null ) _filterborderwidth = a._filterborderwidth;
		if ( a._filterbordercolor != null ) _filterbordercolor = a._filterbordercolor;
		if ( a._maskmode != null ) _maskmode = a._maskmode;
		if ( a._maskrepeat != null ) _maskrepeat = a._maskrepeat;
		if ( a._masksizex != null ) _masksizex = a._masksizex;
		if ( a._masksizey != null ) _masksizey = a._masksizey;
		if ( a._maskpositionx != null ) _maskpositionx = a._maskpositionx;
		if ( a._maskpositiony != null ) _maskpositiony = a._maskpositiony;
		if ( a._maskangle != null ) _maskangle = a._maskangle;
		if ( a._maskscope != null ) _maskscope = a._maskscope;
		if ( a._backgroundsizex != null ) _backgroundsizex = a._backgroundsizex;
		if ( a._backgroundsizey != null ) _backgroundsizey = a._backgroundsizey;
		if ( a._backgroundpositionx != null ) _backgroundpositionx = a._backgroundpositionx;
		if ( a._backgroundpositiony != null ) _backgroundpositiony = a._backgroundpositiony;
		if ( a._backgroundrepeat != null ) _backgroundrepeat = a._backgroundrepeat;
		if ( a._borderimagewidthleft != null ) _borderimagewidthleft = a._borderimagewidthleft;
		if ( a._borderimagewidthright != null ) _borderimagewidthright = a._borderimagewidthright;
		if ( a._borderimagewidthtop != null ) _borderimagewidthtop = a._borderimagewidthtop;
		if ( a._borderimagewidthbottom != null ) _borderimagewidthbottom = a._borderimagewidthbottom;
		if ( a._borderimagefill != null ) _borderimagefill = a._borderimagefill;
		if ( a._borderimagerepeat != null ) _borderimagerepeat = a._borderimagerepeat;
		if ( a._borderimagetint != null ) _borderimagetint = a._borderimagetint;
		if ( a._backgroundblendmode != null ) _backgroundblendmode = a._backgroundblendmode;
		if ( a._backgroundtint != null ) _backgroundtint = a._backgroundtint;
		if ( a._backgroundangle != null ) _backgroundangle = a._backgroundangle;
		if ( a._textbackgroundangle != null ) _textbackgroundangle = a._textbackgroundangle;
		if ( a._perspectiveoriginx != null ) _perspectiveoriginx = a._perspectiveoriginx;
		if ( a._perspectiveoriginy != null ) _perspectiveoriginy = a._perspectiveoriginy;
		if ( a._textstrokecolor != null ) _textstrokecolor = a._textstrokecolor;
		if ( a._textstrokewidth != null ) _textstrokewidth = a._textstrokewidth;
		if ( a._imagerendering != null ) _imagerendering = a._imagerendering;
		if ( a._animationdelay != null ) _animationdelay = a._animationdelay;
		if ( a._animationdirection != null ) _animationdirection = a._animationdirection;
		if ( a._animationduration != null ) _animationduration = a._animationduration;
		if ( a._animationfillmode != null ) _animationfillmode = a._animationfillmode;
		if ( a._animationiterationcount != null ) _animationiterationcount = a._animationiterationcount;
		if ( a._animationname != null ) _animationname = a._animationname;
		if ( a._animationplaystate != null ) _animationplaystate = a._animationplaystate;
		if ( a._animationtimingfunction != null ) _animationtimingfunction = a._animationtimingfunction;
		if ( a._fontsmooth != null ) _fontsmooth = a._fontsmooth;
		if ( a._objectfit != null ) _objectfit = a._objectfit;
		if ( a._outlinewidth != null ) _outlinewidth = a._outlinewidth;
		if ( a._outlinecolor != null ) _outlinecolor = a._outlinecolor;
		if ( a._outlineoffset != null ) _outlineoffset = a._outlineoffset;
	}

	/// <summary>
	/// Copy all styles from given style set.
	/// </summary>
	private void FromGenerated( BaseStyles a )
	{
		_content = a._content;
		_width = a._width;
		_minwidth = a._minwidth;
		_maxwidth = a._maxwidth;
		_height = a._height;
		_minheight = a._minheight;
		_maxheight = a._maxheight;
		_left = a._left;
		_top = a._top;
		_right = a._right;
		_bottom = a._bottom;
		_opacity = a._opacity;
		_backgroundcolor = a._backgroundcolor;
		_paddingleft = a._paddingleft;
		_paddingtop = a._paddingtop;
		_paddingright = a._paddingright;
		_paddingbottom = a._paddingbottom;
		_marginleft = a._marginleft;
		_margintop = a._margintop;
		_marginright = a._marginright;
		_marginbottom = a._marginbottom;
		_bordertopleftradius = a._bordertopleftradius;
		_bordertoprightradius = a._bordertoprightradius;
		_borderbottomrightradius = a._borderbottomrightradius;
		_borderbottomleftradius = a._borderbottomleftradius;
		_borderleftwidth = a._borderleftwidth;
		_bordertopwidth = a._bordertopwidth;
		_borderrightwidth = a._borderrightwidth;
		_borderbottomwidth = a._borderbottomwidth;
		_borderleftcolor = a._borderleftcolor;
		_bordertopcolor = a._bordertopcolor;
		_borderrightcolor = a._borderrightcolor;
		_borderbottomcolor = a._borderbottomcolor;
		_fontsize = a._fontsize;
		_fontcolor = a._fontcolor;
		_fontweight = a._fontweight;
		_fontfamily = a._fontfamily;
		_caretcolor = a._caretcolor;
		_cursor = a._cursor;
		_pointerevents = a._pointerevents;
		_mixblendmode = a._mixblendmode;
		_position = a._position;
		_overflowx = a._overflowx;
		_overflowy = a._overflowy;
		_flexdirection = a._flexdirection;
		_justifycontent = a._justifycontent;
		_display = a._display;
		_flexwrap = a._flexwrap;
		_aligncontent = a._aligncontent;
		_alignself = a._alignself;
		_alignitems = a._alignitems;
		_flexbasis = a._flexbasis;
		_flexgrow = a._flexgrow;
		_flexshrink = a._flexshrink;
		_rowgap = a._rowgap;
		_columngap = a._columngap;
		_aspectratio = a._aspectratio;
		_textalign = a._textalign;
		_textoverflow = a._textoverflow;
		_textfilter = a._textfilter;
		_wordbreak = a._wordbreak;
		_textdecorationline = a._textdecorationline;
		_textdecorationcolor = a._textdecorationcolor;
		_textdecorationthickness = a._textdecorationthickness;
		_textdecorationskipink = a._textdecorationskipink;
		_textdecorationstyle = a._textdecorationstyle;
		_textunderlineoffset = a._textunderlineoffset;
		_textoverlineoffset = a._textoverlineoffset;
		_textlinethroughoffset = a._textlinethroughoffset;
		_fontstyle = a._fontstyle;
		_fontvariantnumeric = a._fontvariantnumeric;
		_transform = a._transform;
		_texttransform = a._texttransform;
		_transformoriginx = a._transformoriginx;
		_transformoriginy = a._transformoriginy;
		_letterspacing = a._letterspacing;
		_lineheight = a._lineheight;
		_wordspacing = a._wordspacing;
		_whitespace = a._whitespace;
		_zindex = a._zindex;
		_order = a._order;
		_soundin = a._soundin;
		_soundout = a._soundout;
		_backdropfilterblur = a._backdropfilterblur;
		_backdropfilterbrightness = a._backdropfilterbrightness;
		_backdropfiltercontrast = a._backdropfiltercontrast;
		_backdropfiltersaturate = a._backdropfiltersaturate;
		_backdropfiltersepia = a._backdropfiltersepia;
		_backdropfilterinvert = a._backdropfilterinvert;
		_backdropfilterhuerotate = a._backdropfilterhuerotate;
		_filterblur = a._filterblur;
		_filtersaturate = a._filtersaturate;
		_filtersepia = a._filtersepia;
		_filterbrightness = a._filterbrightness;
		_filterhuerotate = a._filterhuerotate;
		_filterinvert = a._filterinvert;
		_filtercontrast = a._filtercontrast;
		_filtertint = a._filtertint;
		_filterborderwidth = a._filterborderwidth;
		_filterbordercolor = a._filterbordercolor;
		_maskmode = a._maskmode;
		_maskrepeat = a._maskrepeat;
		_masksizex = a._masksizex;
		_masksizey = a._masksizey;
		_maskpositionx = a._maskpositionx;
		_maskpositiony = a._maskpositiony;
		_maskangle = a._maskangle;
		_maskscope = a._maskscope;
		_backgroundsizex = a._backgroundsizex;
		_backgroundsizey = a._backgroundsizey;
		_backgroundpositionx = a._backgroundpositionx;
		_backgroundpositiony = a._backgroundpositiony;
		_backgroundrepeat = a._backgroundrepeat;
		_borderimagewidthleft = a._borderimagewidthleft;
		_borderimagewidthright = a._borderimagewidthright;
		_borderimagewidthtop = a._borderimagewidthtop;
		_borderimagewidthbottom = a._borderimagewidthbottom;
		_borderimagefill = a._borderimagefill;
		_borderimagerepeat = a._borderimagerepeat;
		_borderimagetint = a._borderimagetint;
		_backgroundblendmode = a._backgroundblendmode;
		_backgroundtint = a._backgroundtint;
		_backgroundangle = a._backgroundangle;
		_textbackgroundangle = a._textbackgroundangle;
		_perspectiveoriginx = a._perspectiveoriginx;
		_perspectiveoriginy = a._perspectiveoriginy;
		_textstrokecolor = a._textstrokecolor;
		_textstrokewidth = a._textstrokewidth;
		_imagerendering = a._imagerendering;
		_animationdelay = a._animationdelay;
		_animationdirection = a._animationdirection;
		_animationduration = a._animationduration;
		_animationfillmode = a._animationfillmode;
		_animationiterationcount = a._animationiterationcount;
		_animationname = a._animationname;
		_animationplaystate = a._animationplaystate;
		_animationtimingfunction = a._animationtimingfunction;
		_fontsmooth = a._fontsmooth;
		_objectfit = a._objectfit;
		_outlinewidth = a._outlinewidth;
		_outlinecolor = a._outlinecolor;
		_outlineoffset = a._outlineoffset;
	}

	/// <summary>
	/// Set a CSS property via its string name.
	/// </summary>
	private bool SetGenerated( string property, string value )
	{
		switch ( property )
		{
		case "content":
			Content = value.TrimQuoted( true );
			return true;
		case "width":
			Width = Length.Parse( value );
			return Width.HasValue;
		case "min-width":
			MinWidth = Length.Parse( value );
			return MinWidth.HasValue;
		case "max-width":
			MaxWidth = Length.Parse( value );
			return MaxWidth.HasValue;
		case "height":
			Height = Length.Parse( value );
			return Height.HasValue;
		case "min-height":
			MinHeight = Length.Parse( value );
			return MinHeight.HasValue;
		case "max-height":
			MaxHeight = Length.Parse( value );
			return MaxHeight.HasValue;
		case "left":
			Left = Length.Parse( value );
			return Left.HasValue;
		case "top":
			Top = Length.Parse( value );
			return Top.HasValue;
		case "right":
			Right = Length.Parse( value );
			return Right.HasValue;
		case "bottom":
			Bottom = Length.Parse( value );
			return Bottom.HasValue;
		case "opacity":
			Opacity = ParseFloat( value );
			return Opacity.HasValue;
		case "background-color":
			BackgroundColor = Color.Parse( value );
			return BackgroundColor.HasValue;
		case "padding-left":
			PaddingLeft = Length.Parse( value );
			return PaddingLeft.HasValue;
		case "padding-top":
			PaddingTop = Length.Parse( value );
			return PaddingTop.HasValue;
		case "padding-right":
			PaddingRight = Length.Parse( value );
			return PaddingRight.HasValue;
		case "padding-bottom":
			PaddingBottom = Length.Parse( value );
			return PaddingBottom.HasValue;
		case "margin-left":
			MarginLeft = Length.Parse( value );
			return MarginLeft.HasValue;
		case "margin-top":
			MarginTop = Length.Parse( value );
			return MarginTop.HasValue;
		case "margin-right":
			MarginRight = Length.Parse( value );
			return MarginRight.HasValue;
		case "margin-bottom":
			MarginBottom = Length.Parse( value );
			return MarginBottom.HasValue;
		case "border-top-left-radius":
			BorderTopLeftRadius = Length.Parse( value );
			return BorderTopLeftRadius.HasValue;
		case "border-top-right-radius":
			BorderTopRightRadius = Length.Parse( value );
			return BorderTopRightRadius.HasValue;
		case "border-bottom-right-radius":
			BorderBottomRightRadius = Length.Parse( value );
			return BorderBottomRightRadius.HasValue;
		case "border-bottom-left-radius":
			BorderBottomLeftRadius = Length.Parse( value );
			return BorderBottomLeftRadius.HasValue;
		case "border-left-width":
			BorderLeftWidth = Length.Parse( value );
			return BorderLeftWidth.HasValue;
		case "border-top-width":
			BorderTopWidth = Length.Parse( value );
			return BorderTopWidth.HasValue;
		case "border-right-width":
			BorderRightWidth = Length.Parse( value );
			return BorderRightWidth.HasValue;
		case "border-bottom-width":
			BorderBottomWidth = Length.Parse( value );
			return BorderBottomWidth.HasValue;
		case "border-left-color":
			BorderLeftColor = Color.Parse( value );
			return BorderLeftColor.HasValue;
		case "border-top-color":
			BorderTopColor = Color.Parse( value );
			return BorderTopColor.HasValue;
		case "border-right-color":
			BorderRightColor = Color.Parse( value );
			return BorderRightColor.HasValue;
		case "border-bottom-color":
			BorderBottomColor = Color.Parse( value );
			return BorderBottomColor.HasValue;
		case "font-size":
			FontSize = Length.Parse( value );
			return FontSize.HasValue;
		case "font-color":
			FontColor = Color.Parse( value );
			return FontColor.HasValue;
		case "font-weight":
			FontWeight = ParseInt( value );
			return FontWeight.HasValue;
		case "font-family":
			FontFamily = value.TrimQuoted( true );
			return true;
		case "caret-color":
			CaretColor = Color.Parse( value );
			return CaretColor.HasValue;
		case "cursor":
			Cursor = value.TrimQuoted( true );
			return true;
		case "mix-blend-mode":
			MixBlendMode = value.TrimQuoted( true );
			return true;
		case "flex-basis":
			FlexBasis = Length.Parse( value );
			return FlexBasis.HasValue;
		case "flex-grow":
			FlexGrow = ParseFloat( value );
			return FlexGrow.HasValue;
		case "flex-shrink":
			FlexShrink = ParseFloat( value );
			return FlexShrink.HasValue;
		case "row-gap":
			RowGap = Length.Parse( value );
			return RowGap.HasValue;
		case "column-gap":
			ColumnGap = Length.Parse( value );
			return ColumnGap.HasValue;
		case "aspect-ratio":
			AspectRatio = ParseAspectRatio( value );
			return true;
		case "text-decoration-color":
			TextDecorationColor = Color.Parse( value );
			return TextDecorationColor.HasValue;
		case "text-decoration-thickness":
			TextDecorationThickness = Length.Parse( value );
			return TextDecorationThickness.HasValue;
		case "text-underline-offset":
			TextUnderlineOffset = Length.Parse( value );
			return TextUnderlineOffset.HasValue;
		case "text-overline-offset":
			TextOverlineOffset = Length.Parse( value );
			return TextOverlineOffset.HasValue;
		case "text-line-through-offset":
			TextLineThroughOffset = Length.Parse( value );
			return TextLineThroughOffset.HasValue;
		case "transform-origin-x":
			TransformOriginX = Length.Parse( value );
			return TransformOriginX.HasValue;
		case "transform-origin-y":
			TransformOriginY = Length.Parse( value );
			return TransformOriginY.HasValue;
		case "letter-spacing":
			LetterSpacing = Length.Parse( value );
			return LetterSpacing.HasValue;
		case "line-height":
			LineHeight = Length.Parse( value );
			return LineHeight.HasValue;
		case "word-spacing":
			WordSpacing = Length.Parse( value );
			return WordSpacing.HasValue;
		case "z-index":
			ZIndex = ParseInt( value );
			return ZIndex.HasValue;
		case "order":
			Order = ParseInt( value );
			return Order.HasValue;
		case "sound-in":
			SoundIn = value.TrimQuoted( true );
			return true;
		case "sound-out":
			SoundOut = value.TrimQuoted( true );
			return true;
		case "backdrop-filter-blur":
			BackdropFilterBlur = Length.Parse( value );
			return BackdropFilterBlur.HasValue;
		case "backdrop-filter-brightness":
			BackdropFilterBrightness = Length.Parse( value );
			return BackdropFilterBrightness.HasValue;
		case "backdrop-filter-contrast":
			BackdropFilterContrast = Length.Parse( value );
			return BackdropFilterContrast.HasValue;
		case "backdrop-filter-saturate":
			BackdropFilterSaturate = Length.Parse( value );
			return BackdropFilterSaturate.HasValue;
		case "backdrop-filter-sepia":
			BackdropFilterSepia = Length.Parse( value );
			return BackdropFilterSepia.HasValue;
		case "backdrop-filter-invert":
			BackdropFilterInvert = Length.Parse( value );
			return BackdropFilterInvert.HasValue;
		case "backdrop-filter-hue-rotate":
			BackdropFilterHueRotate = Length.Parse( value );
			return BackdropFilterHueRotate.HasValue;
		case "filter-blur":
			FilterBlur = Length.Parse( value );
			return FilterBlur.HasValue;
		case "filter-saturate":
			FilterSaturate = Length.Parse( value );
			return FilterSaturate.HasValue;
		case "filter-sepia":
			FilterSepia = Length.Parse( value );
			return FilterSepia.HasValue;
		case "filter-brightness":
			FilterBrightness = Length.Parse( value );
			return FilterBrightness.HasValue;
		case "filter-hue-rotate":
			FilterHueRotate = Length.Parse( value );
			return FilterHueRotate.HasValue;
		case "filter-invert":
			FilterInvert = Length.Parse( value );
			return FilterInvert.HasValue;
		case "filter-contrast":
			FilterContrast = Length.Parse( value );
			return FilterContrast.HasValue;
		case "filter-tint":
			FilterTint = Color.Parse( value );
			return FilterTint.HasValue;
		case "filter-border-width":
			FilterBorderWidth = Length.Parse( value );
			return FilterBorderWidth.HasValue;
		case "filter-border-color":
			FilterBorderColor = Color.Parse( value );
			return FilterBorderColor.HasValue;
		case "mask-size-x":
			MaskSizeX = Length.Parse( value );
			return MaskSizeX.HasValue;
		case "mask-size-y":
			MaskSizeY = Length.Parse( value );
			return MaskSizeY.HasValue;
		case "mask-position-x":
			MaskPositionX = Length.Parse( value );
			return MaskPositionX.HasValue;
		case "mask-position-y":
			MaskPositionY = Length.Parse( value );
			return MaskPositionY.HasValue;
		case "mask-angle":
			MaskAngle = Length.Parse( value );
			return MaskAngle.HasValue;
		case "background-size-x":
			BackgroundSizeX = Length.Parse( value );
			return BackgroundSizeX.HasValue;
		case "background-size-y":
			BackgroundSizeY = Length.Parse( value );
			return BackgroundSizeY.HasValue;
		case "background-position-x":
			BackgroundPositionX = Length.Parse( value );
			return BackgroundPositionX.HasValue;
		case "background-position-y":
			BackgroundPositionY = Length.Parse( value );
			return BackgroundPositionY.HasValue;
		case "border-image-width-left":
			BorderImageWidthLeft = Length.Parse( value );
			return BorderImageWidthLeft.HasValue;
		case "border-image-width-right":
			BorderImageWidthRight = Length.Parse( value );
			return BorderImageWidthRight.HasValue;
		case "border-image-width-top":
			BorderImageWidthTop = Length.Parse( value );
			return BorderImageWidthTop.HasValue;
		case "border-image-width-bottom":
			BorderImageWidthBottom = Length.Parse( value );
			return BorderImageWidthBottom.HasValue;
		case "border-image-tint":
			BorderImageTint = Color.Parse( value );
			return BorderImageTint.HasValue;
		case "background-blend-mode":
			BackgroundBlendMode = value.TrimQuoted( true );
			return true;
		case "background-tint":
			BackgroundTint = Color.Parse( value );
			return BackgroundTint.HasValue;
		case "background-angle":
			BackgroundAngle = Length.Parse( value );
			return BackgroundAngle.HasValue;
		case "text-background-angle":
			TextBackgroundAngle = Length.Parse( value );
			return TextBackgroundAngle.HasValue;
		case "perspective-origin-x":
			PerspectiveOriginX = Length.Parse( value );
			return PerspectiveOriginX.HasValue;
		case "perspective-origin-y":
			PerspectiveOriginY = Length.Parse( value );
			return PerspectiveOriginY.HasValue;
		case "text-stroke-color":
			TextStrokeColor = Color.Parse( value );
			return TextStrokeColor.HasValue;
		case "text-stroke-width":
			TextStrokeWidth = Length.Parse( value );
			return TextStrokeWidth.HasValue;
		case "animation-delay":
			AnimationDelay = ParseSeconds( value );
			return true;
		case "animation-direction":
			AnimationDirection = value.TrimQuoted( true );
			return true;
		case "animation-duration":
			AnimationDuration = ParseSeconds( value );
			return true;
		case "animation-fill-mode":
			AnimationFillMode = value.TrimQuoted( true );
			return true;
		case "animation-iteration-count":
			AnimationIterationCount = ParseFloat( value );
			return AnimationIterationCount.HasValue;
		case "animation-name":
			AnimationName = value.TrimQuoted( true );
			return true;
		case "animation-play-state":
			AnimationPlayState = value.TrimQuoted( true );
			return true;
		case "animation-timing-function":
			AnimationTimingFunction = value.TrimQuoted( true );
			return true;
		case "outline-width":
			OutlineWidth = Length.Parse( value );
			return OutlineWidth.HasValue;
		case "outline-color":
			OutlineColor = Color.Parse( value );
			return OutlineColor.HasValue;
		case "outline-offset":
			OutlineOffset = Length.Parse( value );
			return OutlineOffset.HasValue;
		default:
			return false;
		}
	}

	private int GetHashCodeGenerated()
	{
		var hash = new HashCode();

		hash.Add( _content );
		hash.Add( _width );
		hash.Add( _minwidth );
		hash.Add( _maxwidth );
		hash.Add( _height );
		hash.Add( _minheight );
		hash.Add( _maxheight );
		hash.Add( _left );
		hash.Add( _top );
		hash.Add( _right );
		hash.Add( _bottom );
		hash.Add( _opacity );
		hash.Add( _backgroundcolor );
		hash.Add( _paddingleft );
		hash.Add( _paddingtop );
		hash.Add( _paddingright );
		hash.Add( _paddingbottom );
		hash.Add( _marginleft );
		hash.Add( _margintop );
		hash.Add( _marginright );
		hash.Add( _marginbottom );
		hash.Add( _bordertopleftradius );
		hash.Add( _bordertoprightradius );
		hash.Add( _borderbottomrightradius );
		hash.Add( _borderbottomleftradius );
		hash.Add( _borderleftwidth );
		hash.Add( _bordertopwidth );
		hash.Add( _borderrightwidth );
		hash.Add( _borderbottomwidth );
		hash.Add( _borderleftcolor );
		hash.Add( _bordertopcolor );
		hash.Add( _borderrightcolor );
		hash.Add( _borderbottomcolor );
		hash.Add( _fontsize );
		hash.Add( _fontcolor );
		hash.Add( _fontweight );
		hash.Add( _fontfamily );
		hash.Add( _caretcolor );
		hash.Add( _cursor );
		hash.Add( _pointerevents );
		hash.Add( _mixblendmode );
		hash.Add( _position );
		hash.Add( _overflowx );
		hash.Add( _overflowy );
		hash.Add( _flexdirection );
		hash.Add( _justifycontent );
		hash.Add( _display );
		hash.Add( _flexwrap );
		hash.Add( _aligncontent );
		hash.Add( _alignself );
		hash.Add( _alignitems );
		hash.Add( _flexbasis );
		hash.Add( _flexgrow );
		hash.Add( _flexshrink );
		hash.Add( _rowgap );
		hash.Add( _columngap );
		hash.Add( _aspectratio );
		hash.Add( _textalign );
		hash.Add( _textoverflow );
		hash.Add( _textfilter );
		hash.Add( _wordbreak );
		hash.Add( _textdecorationline );
		hash.Add( _textdecorationcolor );
		hash.Add( _textdecorationthickness );
		hash.Add( _textdecorationskipink );
		hash.Add( _textdecorationstyle );
		hash.Add( _textunderlineoffset );
		hash.Add( _textoverlineoffset );
		hash.Add( _textlinethroughoffset );
		hash.Add( _fontstyle );
		hash.Add( _fontvariantnumeric );
		hash.Add( _transform );
		hash.Add( _texttransform );
		hash.Add( _transformoriginx );
		hash.Add( _transformoriginy );
		hash.Add( _letterspacing );
		hash.Add( _lineheight );
		hash.Add( _wordspacing );
		hash.Add( _whitespace );
		hash.Add( _zindex );
		hash.Add( _order );
		hash.Add( _soundin );
		hash.Add( _soundout );
		hash.Add( _backdropfilterblur );
		hash.Add( _backdropfilterbrightness );
		hash.Add( _backdropfiltercontrast );
		hash.Add( _backdropfiltersaturate );
		hash.Add( _backdropfiltersepia );
		hash.Add( _backdropfilterinvert );
		hash.Add( _backdropfilterhuerotate );
		hash.Add( _filterblur );
		hash.Add( _filtersaturate );
		hash.Add( _filtersepia );
		hash.Add( _filterbrightness );
		hash.Add( _filterhuerotate );
		hash.Add( _filterinvert );
		hash.Add( _filtercontrast );
		hash.Add( _filtertint );
		hash.Add( _filterborderwidth );
		hash.Add( _filterbordercolor );
		hash.Add( _maskmode );
		hash.Add( _maskrepeat );
		hash.Add( _masksizex );
		hash.Add( _masksizey );
		hash.Add( _maskpositionx );
		hash.Add( _maskpositiony );
		hash.Add( _maskangle );
		hash.Add( _maskscope );
		hash.Add( _backgroundsizex );
		hash.Add( _backgroundsizey );
		hash.Add( _backgroundpositionx );
		hash.Add( _backgroundpositiony );
		hash.Add( _backgroundrepeat );
		hash.Add( _borderimagewidthleft );
		hash.Add( _borderimagewidthright );
		hash.Add( _borderimagewidthtop );
		hash.Add( _borderimagewidthbottom );
		hash.Add( _borderimagefill );
		hash.Add( _borderimagerepeat );
		hash.Add( _borderimagetint );
		hash.Add( _backgroundblendmode );
		hash.Add( _backgroundtint );
		hash.Add( _backgroundangle );
		hash.Add( _textbackgroundangle );
		hash.Add( _perspectiveoriginx );
		hash.Add( _perspectiveoriginy );
		hash.Add( _textstrokecolor );
		hash.Add( _textstrokewidth );
		hash.Add( _imagerendering );
		hash.Add( _animationdelay );
		hash.Add( _animationdirection );
		hash.Add( _animationduration );
		hash.Add( _animationfillmode );
		hash.Add( _animationiterationcount );
		hash.Add( _animationname );
		hash.Add( _animationplaystate );
		hash.Add( _animationtimingfunction );
		hash.Add( _fontsmooth );
		hash.Add( _objectfit );
		hash.Add( _outlinewidth );
		hash.Add( _outlinecolor );
		hash.Add( _outlineoffset );
		return hash.ToHashCode();
	}

	/// <summary>
	/// Lerp every property in this stylesheet
	/// </summary>
	public virtual void FromLerp( BaseStyles from, BaseStyles to, float delta )
	{
		LerpProperty( "width", from, to, delta );
		LerpProperty( "min-width", from, to, delta );
		LerpProperty( "max-width", from, to, delta );
		LerpProperty( "height", from, to, delta );
		LerpProperty( "min-height", from, to, delta );
		LerpProperty( "max-height", from, to, delta );
		LerpProperty( "left", from, to, delta );
		LerpProperty( "top", from, to, delta );
		LerpProperty( "right", from, to, delta );
		LerpProperty( "bottom", from, to, delta );
		LerpProperty( "opacity", from, to, delta );
		LerpProperty( "background-color", from, to, delta );
		LerpProperty( "padding-left", from, to, delta );
		LerpProperty( "padding-top", from, to, delta );
		LerpProperty( "padding-right", from, to, delta );
		LerpProperty( "padding-bottom", from, to, delta );
		LerpProperty( "margin-left", from, to, delta );
		LerpProperty( "margin-top", from, to, delta );
		LerpProperty( "margin-right", from, to, delta );
		LerpProperty( "margin-bottom", from, to, delta );
		LerpProperty( "border-top-left-radius", from, to, delta );
		LerpProperty( "border-top-right-radius", from, to, delta );
		LerpProperty( "border-bottom-right-radius", from, to, delta );
		LerpProperty( "border-bottom-left-radius", from, to, delta );
		LerpProperty( "border-left-width", from, to, delta );
		LerpProperty( "border-top-width", from, to, delta );
		LerpProperty( "border-right-width", from, to, delta );
		LerpProperty( "border-bottom-width", from, to, delta );
		LerpProperty( "border-left-color", from, to, delta );
		LerpProperty( "border-top-color", from, to, delta );
		LerpProperty( "border-right-color", from, to, delta );
		LerpProperty( "border-bottom-color", from, to, delta );
		LerpProperty( "font-size", from, to, delta );
		LerpProperty( "font-color", from, to, delta );
		LerpProperty( "font-weight", from, to, delta );
		LerpProperty( "caret-color", from, to, delta );
		LerpProperty( "flex-basis", from, to, delta );
		LerpProperty( "flex-grow", from, to, delta );
		LerpProperty( "flex-shrink", from, to, delta );
		LerpProperty( "row-gap", from, to, delta );
		LerpProperty( "column-gap", from, to, delta );
		LerpProperty( "text-decoration-color", from, to, delta );
		LerpProperty( "text-decoration-thickness", from, to, delta );
		LerpProperty( "text-underline-offset", from, to, delta );
		LerpProperty( "text-overline-offset", from, to, delta );
		LerpProperty( "text-line-through-offset", from, to, delta );
		LerpProperty( "transform", from, to, delta );
		LerpProperty( "transform-origin-x", from, to, delta );
		LerpProperty( "transform-origin-y", from, to, delta );
		LerpProperty( "letter-spacing", from, to, delta );
		LerpProperty( "line-height", from, to, delta );
		LerpProperty( "word-spacing", from, to, delta );
		LerpProperty( "z-index", from, to, delta );
		LerpProperty( "order", from, to, delta );
		LerpProperty( "backdrop-filter-blur", from, to, delta );
		LerpProperty( "backdrop-filter-brightness", from, to, delta );
		LerpProperty( "backdrop-filter-contrast", from, to, delta );
		LerpProperty( "backdrop-filter-saturate", from, to, delta );
		LerpProperty( "backdrop-filter-sepia", from, to, delta );
		LerpProperty( "backdrop-filter-invert", from, to, delta );
		LerpProperty( "backdrop-filter-hue-rotate", from, to, delta );
		LerpProperty( "filter-blur", from, to, delta );
		LerpProperty( "filter-saturate", from, to, delta );
		LerpProperty( "filter-sepia", from, to, delta );
		LerpProperty( "filter-brightness", from, to, delta );
		LerpProperty( "filter-hue-rotate", from, to, delta );
		LerpProperty( "filter-invert", from, to, delta );
		LerpProperty( "filter-contrast", from, to, delta );
		LerpProperty( "filter-tint", from, to, delta );
		LerpProperty( "filter-border-width", from, to, delta );
		LerpProperty( "filter-border-color", from, to, delta );
		LerpProperty( "mask-size-x", from, to, delta );
		LerpProperty( "mask-size-y", from, to, delta );
		LerpProperty( "mask-position-x", from, to, delta );
		LerpProperty( "mask-position-y", from, to, delta );
		LerpProperty( "mask-angle", from, to, delta );
		LerpProperty( "background-size-x", from, to, delta );
		LerpProperty( "background-size-y", from, to, delta );
		LerpProperty( "background-position-x", from, to, delta );
		LerpProperty( "background-position-y", from, to, delta );
		LerpProperty( "border-image-width-left", from, to, delta );
		LerpProperty( "border-image-width-right", from, to, delta );
		LerpProperty( "border-image-width-top", from, to, delta );
		LerpProperty( "border-image-width-bottom", from, to, delta );
		LerpProperty( "border-image-tint", from, to, delta );
		LerpProperty( "background-tint", from, to, delta );
		LerpProperty( "background-angle", from, to, delta );
		LerpProperty( "text-background-angle", from, to, delta );
		LerpProperty( "perspective-origin-x", from, to, delta );
		LerpProperty( "perspective-origin-y", from, to, delta );
		LerpProperty( "text-stroke-color", from, to, delta );
		LerpProperty( "text-stroke-width", from, to, delta );
		LerpProperty( "animation-iteration-count", from, to, delta );
		LerpProperty( "outline-width", from, to, delta );
		LerpProperty( "outline-color", from, to, delta );
		LerpProperty( "outline-offset", from, to, delta );
	}
	
	/// <summary>
	/// Lerp a specific property by name
	/// </summary>
	public virtual void LerpProperty( string name, BaseStyles from, BaseStyles to, float delta )
	{
		switch ( name )
		{
			case "width":
				Lerp( ref _width, from._width, to._width, Length.Undefined, delta );
				break;
			case "min-width":
				Lerp( ref _minwidth, from._minwidth, to._minwidth, 0, delta );
				break;
			case "max-width":
				Lerp( ref _maxwidth, from._maxwidth, to._maxwidth, Length.Undefined, delta );
				break;
			case "height":
				Lerp( ref _height, from._height, to._height, Length.Undefined, delta );
				break;
			case "min-height":
				Lerp( ref _minheight, from._minheight, to._minheight, 0, delta );
				break;
			case "max-height":
				Lerp( ref _maxheight, from._maxheight, to._maxheight, Length.Undefined, delta );
				break;
			case "left":
				Lerp( ref _left, from._left, to._left, Length.Undefined, delta );
				break;
			case "top":
				Lerp( ref _top, from._top, to._top, Length.Undefined, delta );
				break;
			case "right":
				Lerp( ref _right, from._right, to._right, Length.Undefined, delta );
				break;
			case "bottom":
				Lerp( ref _bottom, from._bottom, to._bottom, Length.Undefined, delta );
				break;
			case "opacity":
				Lerp( ref _opacity, from._opacity, to._opacity, 1, delta );
				break;
			case "background-color":
				Lerp( ref _backgroundcolor, from._backgroundcolor, to._backgroundcolor, Color.Transparent, delta );
				break;
			case "padding-left":
				Lerp( ref _paddingleft, from._paddingleft, to._paddingleft, 0, delta );
				break;
			case "padding-top":
				Lerp( ref _paddingtop, from._paddingtop, to._paddingtop, 0, delta );
				break;
			case "padding-right":
				Lerp( ref _paddingright, from._paddingright, to._paddingright, 0, delta );
				break;
			case "padding-bottom":
				Lerp( ref _paddingbottom, from._paddingbottom, to._paddingbottom, 0, delta );
				break;
			case "margin-left":
				Lerp( ref _marginleft, from._marginleft, to._marginleft, 0, delta );
				break;
			case "margin-top":
				Lerp( ref _margintop, from._margintop, to._margintop, 0, delta );
				break;
			case "margin-right":
				Lerp( ref _marginright, from._marginright, to._marginright, 0, delta );
				break;
			case "margin-bottom":
				Lerp( ref _marginbottom, from._marginbottom, to._marginbottom, 0, delta );
				break;
			case "border-top-left-radius":
				Lerp( ref _bordertopleftradius, from._bordertopleftradius, to._bordertopleftradius, 0, delta );
				break;
			case "border-top-right-radius":
				Lerp( ref _bordertoprightradius, from._bordertoprightradius, to._bordertoprightradius, 0, delta );
				break;
			case "border-bottom-right-radius":
				Lerp( ref _borderbottomrightradius, from._borderbottomrightradius, to._borderbottomrightradius, 0, delta );
				break;
			case "border-bottom-left-radius":
				Lerp( ref _borderbottomleftradius, from._borderbottomleftradius, to._borderbottomleftradius, 0, delta );
				break;
			case "border-left-width":
				Lerp( ref _borderleftwidth, from._borderleftwidth, to._borderleftwidth, 0, delta );
				break;
			case "border-top-width":
				Lerp( ref _bordertopwidth, from._bordertopwidth, to._bordertopwidth, 0, delta );
				break;
			case "border-right-width":
				Lerp( ref _borderrightwidth, from._borderrightwidth, to._borderrightwidth, 0, delta );
				break;
			case "border-bottom-width":
				Lerp( ref _borderbottomwidth, from._borderbottomwidth, to._borderbottomwidth, 0, delta );
				break;
			case "border-left-color":
				Lerp( ref _borderleftcolor, from._borderleftcolor, to._borderleftcolor, Color.White, delta );
				break;
			case "border-top-color":
				Lerp( ref _bordertopcolor, from._bordertopcolor, to._bordertopcolor, Color.White, delta );
				break;
			case "border-right-color":
				Lerp( ref _borderrightcolor, from._borderrightcolor, to._borderrightcolor, Color.White, delta );
				break;
			case "border-bottom-color":
				Lerp( ref _borderbottomcolor, from._borderbottomcolor, to._borderbottomcolor, Color.White, delta );
				break;
			case "font-size":
				Lerp( ref _fontsize, from._fontsize, to._fontsize, from._fontsize ?? Length.Pixels( 13 ).Value, delta );
				break;
			case "font-color":
				Lerp( ref _fontcolor, from._fontcolor, to._fontcolor, from._fontcolor ?? Color.Black, delta );
				break;
			case "font-weight":
				Lerp( ref _fontweight, from._fontweight, to._fontweight, from._fontweight ?? 400, delta );
				break;
			case "caret-color":
				Lerp( ref _caretcolor, from._caretcolor, to._caretcolor, null, delta );
				break;
			case "flex-basis":
				Lerp( ref _flexbasis, from._flexbasis, to._flexbasis, Length.Auto, delta );
				break;
			case "flex-grow":
				Lerp( ref _flexgrow, from._flexgrow, to._flexgrow, 0, delta );
				break;
			case "flex-shrink":
				Lerp( ref _flexshrink, from._flexshrink, to._flexshrink, 1, delta );
				break;
			case "row-gap":
				Lerp( ref _rowgap, from._rowgap, to._rowgap, Length.Auto, delta );
				break;
			case "column-gap":
				Lerp( ref _columngap, from._columngap, to._columngap, Length.Auto, delta );
				break;
			case "text-decoration-color":
				Lerp( ref _textdecorationcolor, from._textdecorationcolor, to._textdecorationcolor, from._textdecorationcolor ?? Color.White, delta );
				break;
			case "text-decoration-thickness":
				Lerp( ref _textdecorationthickness, from._textdecorationthickness, to._textdecorationthickness, from._textdecorationthickness ?? 1, delta );
				break;
			case "text-underline-offset":
				Lerp( ref _textunderlineoffset, from._textunderlineoffset, to._textunderlineoffset, from._textunderlineoffset ?? 0, delta );
				break;
			case "text-overline-offset":
				Lerp( ref _textoverlineoffset, from._textoverlineoffset, to._textoverlineoffset, from._textoverlineoffset ?? 0, delta );
				break;
			case "text-line-through-offset":
				Lerp( ref _textlinethroughoffset, from._textlinethroughoffset, to._textlinethroughoffset, from._textlinethroughoffset ?? 0, delta );
				break;
			case "transform":
				Lerp( ref _transform, from._transform, to._transform, new UI.PanelTransform(), delta );
				break;
			case "transform-origin-x":
				Lerp( ref _transformoriginx, from._transformoriginx, to._transformoriginx, Length.Percent( 50 ).Value, delta );
				break;
			case "transform-origin-y":
				Lerp( ref _transformoriginy, from._transformoriginy, to._transformoriginy, Length.Percent( 50 ).Value, delta );
				break;
			case "letter-spacing":
				Lerp( ref _letterspacing, from._letterspacing, to._letterspacing, from._letterspacing ?? Length.Percent( 0 ).Value, delta );
				break;
			case "line-height":
				Lerp( ref _lineheight, from._lineheight, to._lineheight, from._lineheight ?? Length.Percent( 100 ).Value, delta );
				break;
			case "word-spacing":
				Lerp( ref _wordspacing, from._wordspacing, to._wordspacing, from._wordspacing ?? Length.Percent( 0 ).Value, delta );
				break;
			case "z-index":
				Lerp( ref _zindex, from._zindex, to._zindex, 0, delta );
				break;
			case "order":
				Lerp( ref _order, from._order, to._order, 0, delta );
				break;
			case "backdrop-filter-blur":
				Lerp( ref _backdropfilterblur, from._backdropfilterblur, to._backdropfilterblur, 0, delta );
				break;
			case "backdrop-filter-brightness":
				Lerp( ref _backdropfilterbrightness, from._backdropfilterbrightness, to._backdropfilterbrightness, 1, delta );
				break;
			case "backdrop-filter-contrast":
				Lerp( ref _backdropfiltercontrast, from._backdropfiltercontrast, to._backdropfiltercontrast, 1, delta );
				break;
			case "backdrop-filter-saturate":
				Lerp( ref _backdropfiltersaturate, from._backdropfiltersaturate, to._backdropfiltersaturate, 1, delta );
				break;
			case "backdrop-filter-sepia":
				Lerp( ref _backdropfiltersepia, from._backdropfiltersepia, to._backdropfiltersepia, 0, delta );
				break;
			case "backdrop-filter-invert":
				Lerp( ref _backdropfilterinvert, from._backdropfilterinvert, to._backdropfilterinvert, 0, delta );
				break;
			case "backdrop-filter-hue-rotate":
				Lerp( ref _backdropfilterhuerotate, from._backdropfilterhuerotate, to._backdropfilterhuerotate, 0, delta );
				break;
			case "filter-blur":
				Lerp( ref _filterblur, from._filterblur, to._filterblur, 0, delta );
				break;
			case "filter-saturate":
				Lerp( ref _filtersaturate, from._filtersaturate, to._filtersaturate, 1, delta );
				break;
			case "filter-sepia":
				Lerp( ref _filtersepia, from._filtersepia, to._filtersepia, 0, delta );
				break;
			case "filter-brightness":
				Lerp( ref _filterbrightness, from._filterbrightness, to._filterbrightness, 1, delta );
				break;
			case "filter-hue-rotate":
				Lerp( ref _filterhuerotate, from._filterhuerotate, to._filterhuerotate, 0, delta );
				break;
			case "filter-invert":
				Lerp( ref _filterinvert, from._filterinvert, to._filterinvert, 0, delta );
				break;
			case "filter-contrast":
				Lerp( ref _filtercontrast, from._filtercontrast, to._filtercontrast, 1, delta );
				break;
			case "filter-tint":
				Lerp( ref _filtertint, from._filtertint, to._filtertint, Color.White, delta );
				break;
			case "filter-border-width":
				Lerp( ref _filterborderwidth, from._filterborderwidth, to._filterborderwidth, 0, delta );
				break;
			case "filter-border-color":
				Lerp( ref _filterbordercolor, from._filterbordercolor, to._filterbordercolor, Color.White, delta );
				break;
			case "mask-size-x":
				Lerp( ref _masksizex, from._masksizex, to._masksizex, Length.Undefined, delta );
				break;
			case "mask-size-y":
				Lerp( ref _masksizey, from._masksizey, to._masksizey, Length.Undefined, delta );
				break;
			case "mask-position-x":
				Lerp( ref _maskpositionx, from._maskpositionx, to._maskpositionx, Length.Percent( 0 ).Value, delta );
				break;
			case "mask-position-y":
				Lerp( ref _maskpositiony, from._maskpositiony, to._maskpositiony, Length.Percent( 0 ).Value, delta );
				break;
			case "mask-angle":
				Lerp( ref _maskangle, from._maskangle, to._maskangle, 0, delta );
				break;
			case "background-size-x":
				Lerp( ref _backgroundsizex, from._backgroundsizex, to._backgroundsizex, Length.Undefined, delta );
				break;
			case "background-size-y":
				Lerp( ref _backgroundsizey, from._backgroundsizey, to._backgroundsizey, Length.Undefined, delta );
				break;
			case "background-position-x":
				Lerp( ref _backgroundpositionx, from._backgroundpositionx, to._backgroundpositionx, Length.Percent( 0 ).Value, delta );
				break;
			case "background-position-y":
				Lerp( ref _backgroundpositiony, from._backgroundpositiony, to._backgroundpositiony, Length.Percent( 0 ).Value, delta );
				break;
			case "border-image-width-left":
				Lerp( ref _borderimagewidthleft, from._borderimagewidthleft, to._borderimagewidthleft, 1, delta );
				break;
			case "border-image-width-right":
				Lerp( ref _borderimagewidthright, from._borderimagewidthright, to._borderimagewidthright, 1, delta );
				break;
			case "border-image-width-top":
				Lerp( ref _borderimagewidthtop, from._borderimagewidthtop, to._borderimagewidthtop, 1, delta );
				break;
			case "border-image-width-bottom":
				Lerp( ref _borderimagewidthbottom, from._borderimagewidthbottom, to._borderimagewidthbottom, 1, delta );
				break;
			case "border-image-tint":
				Lerp( ref _borderimagetint, from._borderimagetint, to._borderimagetint, Color.White, delta );
				break;
			case "background-tint":
				Lerp( ref _backgroundtint, from._backgroundtint, to._backgroundtint, Color.White, delta );
				break;
			case "background-angle":
				Lerp( ref _backgroundangle, from._backgroundangle, to._backgroundangle, 0, delta );
				break;
			case "text-background-angle":
				Lerp( ref _textbackgroundangle, from._textbackgroundangle, to._textbackgroundangle, 0, delta );
				break;
			case "perspective-origin-x":
				Lerp( ref _perspectiveoriginx, from._perspectiveoriginx, to._perspectiveoriginx, Length.Percent( 50 ).Value, delta );
				break;
			case "perspective-origin-y":
				Lerp( ref _perspectiveoriginy, from._perspectiveoriginy, to._perspectiveoriginy, Length.Percent( 50 ).Value, delta );
				break;
			case "text-stroke-color":
				Lerp( ref _textstrokecolor, from._textstrokecolor, to._textstrokecolor, from._textstrokecolor ?? Color.White, delta );
				break;
			case "text-stroke-width":
				Lerp( ref _textstrokewidth, from._textstrokewidth, to._textstrokewidth, from._textstrokewidth ?? 0, delta );
				break;
			case "animation-iteration-count":
				Lerp( ref _animationiterationcount, from._animationiterationcount, to._animationiterationcount, 1, delta );
				break;
			case "outline-width":
				Lerp( ref _outlinewidth, from._outlinewidth, to._outlinewidth, 0, delta );
				break;
			case "outline-color":
				Lerp( ref _outlinecolor, from._outlinecolor, to._outlinecolor, Color.Transparent, delta );
				break;
			case "outline-offset":
				Lerp( ref _outlineoffset, from._outlineoffset, to._outlineoffset, 0, delta );
				break;
		}
	}
	
	/// <summary>
	/// Perform a deep copy of this stylesheet
	/// </summary>
	public object Clone()
	{
		var copy = this.MemberwiseClone() as BaseStyles;
		copy._content = _content;
		copy._width = _width;
		copy._minwidth = _minwidth;
		copy._maxwidth = _maxwidth;
		copy._height = _height;
		copy._minheight = _minheight;
		copy._maxheight = _maxheight;
		copy._left = _left;
		copy._top = _top;
		copy._right = _right;
		copy._bottom = _bottom;
		copy._opacity = _opacity;
		copy._backgroundcolor = _backgroundcolor;
		copy._paddingleft = _paddingleft;
		copy._paddingtop = _paddingtop;
		copy._paddingright = _paddingright;
		copy._paddingbottom = _paddingbottom;
		copy._marginleft = _marginleft;
		copy._margintop = _margintop;
		copy._marginright = _marginright;
		copy._marginbottom = _marginbottom;
		copy._bordertopleftradius = _bordertopleftradius;
		copy._bordertoprightradius = _bordertoprightradius;
		copy._borderbottomrightradius = _borderbottomrightradius;
		copy._borderbottomleftradius = _borderbottomleftradius;
		copy._borderleftwidth = _borderleftwidth;
		copy._bordertopwidth = _bordertopwidth;
		copy._borderrightwidth = _borderrightwidth;
		copy._borderbottomwidth = _borderbottomwidth;
		copy._borderleftcolor = _borderleftcolor;
		copy._bordertopcolor = _bordertopcolor;
		copy._borderrightcolor = _borderrightcolor;
		copy._borderbottomcolor = _borderbottomcolor;
		copy._fontsize = _fontsize;
		copy._fontcolor = _fontcolor;
		copy._fontweight = _fontweight;
		copy._fontfamily = _fontfamily;
		copy._caretcolor = _caretcolor;
		copy._cursor = _cursor;
		copy._pointerevents = _pointerevents;
		copy._mixblendmode = _mixblendmode;
		copy._position = _position;
		copy._overflowx = _overflowx;
		copy._overflowy = _overflowy;
		copy._flexdirection = _flexdirection;
		copy._justifycontent = _justifycontent;
		copy._display = _display;
		copy._flexwrap = _flexwrap;
		copy._aligncontent = _aligncontent;
		copy._alignself = _alignself;
		copy._alignitems = _alignitems;
		copy._flexbasis = _flexbasis;
		copy._flexgrow = _flexgrow;
		copy._flexshrink = _flexshrink;
		copy._rowgap = _rowgap;
		copy._columngap = _columngap;
		copy._aspectratio = _aspectratio;
		copy._textalign = _textalign;
		copy._textoverflow = _textoverflow;
		copy._textfilter = _textfilter;
		copy._wordbreak = _wordbreak;
		copy._textdecorationline = _textdecorationline;
		copy._textdecorationcolor = _textdecorationcolor;
		copy._textdecorationthickness = _textdecorationthickness;
		copy._textdecorationskipink = _textdecorationskipink;
		copy._textdecorationstyle = _textdecorationstyle;
		copy._textunderlineoffset = _textunderlineoffset;
		copy._textoverlineoffset = _textoverlineoffset;
		copy._textlinethroughoffset = _textlinethroughoffset;
		copy._fontstyle = _fontstyle;
		copy._fontvariantnumeric = _fontvariantnumeric;
		copy._transform = _transform;
		copy._texttransform = _texttransform;
		copy._transformoriginx = _transformoriginx;
		copy._transformoriginy = _transformoriginy;
		copy._letterspacing = _letterspacing;
		copy._lineheight = _lineheight;
		copy._wordspacing = _wordspacing;
		copy._whitespace = _whitespace;
		copy._zindex = _zindex;
		copy._order = _order;
		copy._soundin = _soundin;
		copy._soundout = _soundout;
		copy._backdropfilterblur = _backdropfilterblur;
		copy._backdropfilterbrightness = _backdropfilterbrightness;
		copy._backdropfiltercontrast = _backdropfiltercontrast;
		copy._backdropfiltersaturate = _backdropfiltersaturate;
		copy._backdropfiltersepia = _backdropfiltersepia;
		copy._backdropfilterinvert = _backdropfilterinvert;
		copy._backdropfilterhuerotate = _backdropfilterhuerotate;
		copy._filterblur = _filterblur;
		copy._filtersaturate = _filtersaturate;
		copy._filtersepia = _filtersepia;
		copy._filterbrightness = _filterbrightness;
		copy._filterhuerotate = _filterhuerotate;
		copy._filterinvert = _filterinvert;
		copy._filtercontrast = _filtercontrast;
		copy._filtertint = _filtertint;
		copy._filterborderwidth = _filterborderwidth;
		copy._filterbordercolor = _filterbordercolor;
		copy._maskmode = _maskmode;
		copy._maskrepeat = _maskrepeat;
		copy._masksizex = _masksizex;
		copy._masksizey = _masksizey;
		copy._maskpositionx = _maskpositionx;
		copy._maskpositiony = _maskpositiony;
		copy._maskangle = _maskangle;
		copy._maskscope = _maskscope;
		copy._backgroundsizex = _backgroundsizex;
		copy._backgroundsizey = _backgroundsizey;
		copy._backgroundpositionx = _backgroundpositionx;
		copy._backgroundpositiony = _backgroundpositiony;
		copy._backgroundrepeat = _backgroundrepeat;
		copy._borderimagewidthleft = _borderimagewidthleft;
		copy._borderimagewidthright = _borderimagewidthright;
		copy._borderimagewidthtop = _borderimagewidthtop;
		copy._borderimagewidthbottom = _borderimagewidthbottom;
		copy._borderimagefill = _borderimagefill;
		copy._borderimagerepeat = _borderimagerepeat;
		copy._borderimagetint = _borderimagetint;
		copy._backgroundblendmode = _backgroundblendmode;
		copy._backgroundtint = _backgroundtint;
		copy._backgroundangle = _backgroundangle;
		copy._textbackgroundangle = _textbackgroundangle;
		copy._perspectiveoriginx = _perspectiveoriginx;
		copy._perspectiveoriginy = _perspectiveoriginy;
		copy._textstrokecolor = _textstrokecolor;
		copy._textstrokewidth = _textstrokewidth;
		copy._imagerendering = _imagerendering;
		copy._animationdelay = _animationdelay;
		copy._animationdirection = _animationdirection;
		copy._animationduration = _animationduration;
		copy._animationfillmode = _animationfillmode;
		copy._animationiterationcount = _animationiterationcount;
		copy._animationname = _animationname;
		copy._animationplaystate = _animationplaystate;
		copy._animationtimingfunction = _animationtimingfunction;
		copy._fontsmooth = _fontsmooth;
		copy._objectfit = _objectfit;
		copy._outlinewidth = _outlinewidth;
		copy._outlinecolor = _outlinecolor;
		copy._outlineoffset = _outlineoffset;
		copy.CssWide = CssWide == null ? null : new System.Collections.Generic.Dictionary<string, CssWideKeyword>( CssWide );
		return copy;
	}

	public void ApplyCascading( BaseStyles parent )
	{
		if ( _fontsize == null ) _fontsize = parent._fontsize;
		if ( _fontcolor == null ) _fontcolor = parent._fontcolor;
		if ( _fontweight == null ) _fontweight = parent._fontweight;
		if ( _fontfamily == null ) _fontfamily = parent._fontfamily;
		if ( _cursor == null ) _cursor = parent._cursor;
		if ( _pointerevents == null ) _pointerevents = parent._pointerevents;
		if ( _mixblendmode == null ) _mixblendmode = parent._mixblendmode;
		if ( _textalign == null ) _textalign = parent._textalign;
		if ( _textoverflow == null ) _textoverflow = parent._textoverflow;
		if ( _textfilter == null ) _textfilter = parent._textfilter;
		if ( _wordbreak == null ) _wordbreak = parent._wordbreak;
		if ( _textdecorationline == null ) _textdecorationline = parent._textdecorationline;
		if ( _textdecorationcolor == null ) _textdecorationcolor = parent._textdecorationcolor;
		if ( _textdecorationthickness == null ) _textdecorationthickness = parent._textdecorationthickness;
		if ( _textdecorationskipink == null ) _textdecorationskipink = parent._textdecorationskipink;
		if ( _textdecorationstyle == null ) _textdecorationstyle = parent._textdecorationstyle;
		if ( _textunderlineoffset == null ) _textunderlineoffset = parent._textunderlineoffset;
		if ( _textoverlineoffset == null ) _textoverlineoffset = parent._textoverlineoffset;
		if ( _textlinethroughoffset == null ) _textlinethroughoffset = parent._textlinethroughoffset;
		if ( _fontstyle == null ) _fontstyle = parent._fontstyle;
		if ( _fontvariantnumeric == null ) _fontvariantnumeric = parent._fontvariantnumeric;
		if ( _texttransform == null ) _texttransform = parent._texttransform;
		if ( _letterspacing == null ) _letterspacing = parent._letterspacing;
		if ( _lineheight == null ) _lineheight = parent._lineheight;
		if ( _wordspacing == null ) _wordspacing = parent._wordspacing;
		if ( _whitespace == null ) _whitespace = parent._whitespace;
		if ( _textstrokecolor == null ) _textstrokecolor = parent._textstrokecolor;
		if ( _textstrokewidth == null ) _textstrokewidth = parent._textstrokewidth;
		if ( _imagerendering == null ) _imagerendering = parent._imagerendering;
		if ( _fontsmooth == null ) _fontsmooth = parent._fontsmooth;
	}

	private void FillDefaultsGenerated()
	{
		if ( !_width.HasValue ) _width = Length.Undefined;
		if ( !_minwidth.HasValue ) _minwidth = 0;
		if ( !_maxwidth.HasValue ) _maxwidth = Length.Undefined;
		if ( !_height.HasValue ) _height = Length.Undefined;
		if ( !_minheight.HasValue ) _minheight = 0;
		if ( !_maxheight.HasValue ) _maxheight = Length.Undefined;
		if ( !_left.HasValue ) _left = Length.Undefined;
		if ( !_top.HasValue ) _top = Length.Undefined;
		if ( !_right.HasValue ) _right = Length.Undefined;
		if ( !_bottom.HasValue ) _bottom = Length.Undefined;
		if ( !_opacity.HasValue ) _opacity = 1;
		if ( !_backgroundcolor.HasValue ) _backgroundcolor = Color.Transparent;
		if ( !_paddingleft.HasValue ) _paddingleft = 0;
		if ( !_paddingtop.HasValue ) _paddingtop = 0;
		if ( !_paddingright.HasValue ) _paddingright = 0;
		if ( !_paddingbottom.HasValue ) _paddingbottom = 0;
		if ( !_marginleft.HasValue ) _marginleft = 0;
		if ( !_margintop.HasValue ) _margintop = 0;
		if ( !_marginright.HasValue ) _marginright = 0;
		if ( !_marginbottom.HasValue ) _marginbottom = 0;
		if ( !_bordertopleftradius.HasValue ) _bordertopleftradius = 0;
		if ( !_bordertoprightradius.HasValue ) _bordertoprightradius = 0;
		if ( !_borderbottomrightradius.HasValue ) _borderbottomrightradius = 0;
		if ( !_borderbottomleftradius.HasValue ) _borderbottomleftradius = 0;
		if ( !_borderleftwidth.HasValue ) _borderleftwidth = 0;
		if ( !_bordertopwidth.HasValue ) _bordertopwidth = 0;
		if ( !_borderrightwidth.HasValue ) _borderrightwidth = 0;
		if ( !_borderbottomwidth.HasValue ) _borderbottomwidth = 0;
		if ( !_borderleftcolor.HasValue ) _borderleftcolor = Color.White;
		if ( !_bordertopcolor.HasValue ) _bordertopcolor = Color.White;
		if ( !_borderrightcolor.HasValue ) _borderrightcolor = Color.White;
		if ( !_borderbottomcolor.HasValue ) _borderbottomcolor = Color.White;
		if ( !_fontsize.HasValue ) _fontsize = Length.Pixels( 13 ).Value;
		if ( !_fontcolor.HasValue ) _fontcolor = Color.Black;
		if ( !_fontweight.HasValue ) _fontweight = 400;
		if ( !_caretcolor.HasValue ) _caretcolor = null;
		if ( !_pointerevents.HasValue ) _pointerevents = UI.PointerEvents.None;
		if ( !_position.HasValue ) _position = UI.PositionMode.Static;
		if ( !_overflowx.HasValue ) _overflowx = OverflowMode.Visible;
		if ( !_overflowy.HasValue ) _overflowy = OverflowMode.Visible;
		if ( !_flexdirection.HasValue ) _flexdirection = UI.FlexDirection.Row;
		if ( !_justifycontent.HasValue ) _justifycontent = Justify.FlexStart;
		if ( !_display.HasValue ) _display = DisplayMode.Flex;
		if ( !_flexwrap.HasValue ) _flexwrap = Wrap.NoWrap;
		if ( !_aligncontent.HasValue ) _aligncontent = Align.Auto;
		if ( !_alignself.HasValue ) _alignself = Align.Auto;
		if ( !_alignitems.HasValue ) _alignitems = Align.Stretch;
		if ( !_flexbasis.HasValue ) _flexbasis = Length.Auto;
		if ( !_flexgrow.HasValue ) _flexgrow = 0;
		if ( !_flexshrink.HasValue ) _flexshrink = 1;
		if ( !_rowgap.HasValue ) _rowgap = Length.Auto;
		if ( !_columngap.HasValue ) _columngap = Length.Auto;
		if ( !_textalign.HasValue ) _textalign = UI.TextAlign.Left;
		if ( !_textoverflow.HasValue ) _textoverflow = UI.TextOverflow.None;
		if ( !_textfilter.HasValue ) _textfilter = Rendering.FilterMode.Bilinear;
		if ( !_wordbreak.HasValue ) _wordbreak = UI.WordBreak.Normal;
		if ( !_textdecorationline.HasValue ) _textdecorationline = TextDecoration.None;
		if ( !_textdecorationcolor.HasValue ) _textdecorationcolor = Color.White;
		if ( !_textdecorationthickness.HasValue ) _textdecorationthickness = 1;
		if ( !_textdecorationskipink.HasValue ) _textdecorationskipink = 0;
		if ( !_textdecorationstyle.HasValue ) _textdecorationstyle = UI.TextDecorationStyle.Solid;
		if ( !_textunderlineoffset.HasValue ) _textunderlineoffset = 0;
		if ( !_textoverlineoffset.HasValue ) _textoverlineoffset = 0;
		if ( !_textlinethroughoffset.HasValue ) _textlinethroughoffset = 0;
		if ( !_fontstyle.HasValue ) _fontstyle = UI.FontStyle.None;
		if ( !_fontvariantnumeric.HasValue ) _fontvariantnumeric = UI.FontVariantNumeric.Normal;
		if ( !_transform.HasValue ) _transform = new UI.PanelTransform();
		if ( !_texttransform.HasValue ) _texttransform = UI.TextTransform.None;
		if ( !_transformoriginx.HasValue ) _transformoriginx = Length.Percent( 50 ).Value;
		if ( !_transformoriginy.HasValue ) _transformoriginy = Length.Percent( 50 ).Value;
		if ( !_letterspacing.HasValue ) _letterspacing = Length.Percent( 0 ).Value;
		if ( !_lineheight.HasValue ) _lineheight = Length.Percent( 100 ).Value;
		if ( !_wordspacing.HasValue ) _wordspacing = Length.Percent( 0 ).Value;
		if ( !_whitespace.HasValue ) _whitespace = UI.WhiteSpace.Normal;
		if ( !_zindex.HasValue ) _zindex = 0;
		if ( !_order.HasValue ) _order = 0;
		if ( !_backdropfilterblur.HasValue ) _backdropfilterblur = 0;
		if ( !_backdropfilterbrightness.HasValue ) _backdropfilterbrightness = 1;
		if ( !_backdropfiltercontrast.HasValue ) _backdropfiltercontrast = 1;
		if ( !_backdropfiltersaturate.HasValue ) _backdropfiltersaturate = 1;
		if ( !_backdropfiltersepia.HasValue ) _backdropfiltersepia = 0;
		if ( !_backdropfilterinvert.HasValue ) _backdropfilterinvert = 0;
		if ( !_backdropfilterhuerotate.HasValue ) _backdropfilterhuerotate = 0;
		if ( !_filterblur.HasValue ) _filterblur = 0;
		if ( !_filtersaturate.HasValue ) _filtersaturate = 1;
		if ( !_filtersepia.HasValue ) _filtersepia = 0;
		if ( !_filterbrightness.HasValue ) _filterbrightness = 1;
		if ( !_filterhuerotate.HasValue ) _filterhuerotate = 0;
		if ( !_filterinvert.HasValue ) _filterinvert = 0;
		if ( !_filtercontrast.HasValue ) _filtercontrast = 1;
		if ( !_filtertint.HasValue ) _filtertint = Color.White;
		if ( !_filterborderwidth.HasValue ) _filterborderwidth = 0;
		if ( !_filterbordercolor.HasValue ) _filterbordercolor = Color.White;
		if ( !_maskmode.HasValue ) _maskmode = UI.MaskMode.MatchSource;
		if ( !_maskrepeat.HasValue ) _maskrepeat = UI.BackgroundRepeat.Repeat;
		if ( !_masksizex.HasValue ) _masksizex = Length.Undefined;
		if ( !_masksizey.HasValue ) _masksizey = Length.Undefined;
		if ( !_maskpositionx.HasValue ) _maskpositionx = Length.Percent( 0 ).Value;
		if ( !_maskpositiony.HasValue ) _maskpositiony = Length.Percent( 0 ).Value;
		if ( !_maskangle.HasValue ) _maskangle = 0;
		if ( !_maskscope.HasValue ) _maskscope = UI.MaskScope.Default;
		if ( !_backgroundsizex.HasValue ) _backgroundsizex = Length.Undefined;
		if ( !_backgroundsizey.HasValue ) _backgroundsizey = Length.Undefined;
		if ( !_backgroundpositionx.HasValue ) _backgroundpositionx = Length.Percent( 0 ).Value;
		if ( !_backgroundpositiony.HasValue ) _backgroundpositiony = Length.Percent( 0 ).Value;
		if ( !_backgroundrepeat.HasValue ) _backgroundrepeat = UI.BackgroundRepeat.Repeat;
		if ( !_borderimagewidthleft.HasValue ) _borderimagewidthleft = 1;
		if ( !_borderimagewidthright.HasValue ) _borderimagewidthright = 1;
		if ( !_borderimagewidthtop.HasValue ) _borderimagewidthtop = 1;
		if ( !_borderimagewidthbottom.HasValue ) _borderimagewidthbottom = 1;
		if ( !_borderimagefill.HasValue ) _borderimagefill = UI.BorderImageFill.Unfilled;
		if ( !_borderimagerepeat.HasValue ) _borderimagerepeat = UI.BorderImageRepeat.Stretch;
		if ( !_borderimagetint.HasValue ) _borderimagetint = Color.White;
		if ( !_backgroundtint.HasValue ) _backgroundtint = Color.White;
		if ( !_backgroundangle.HasValue ) _backgroundangle = 0;
		if ( !_textbackgroundangle.HasValue ) _textbackgroundangle = 0;
		if ( !_perspectiveoriginx.HasValue ) _perspectiveoriginx = Length.Percent( 50 ).Value;
		if ( !_perspectiveoriginy.HasValue ) _perspectiveoriginy = Length.Percent( 50 ).Value;
		if ( !_textstrokecolor.HasValue ) _textstrokecolor = Color.White;
		if ( !_textstrokewidth.HasValue ) _textstrokewidth = 0;
		if ( !_imagerendering.HasValue ) _imagerendering = UI.ImageRendering.Anisotropic;
		if ( !_animationiterationcount.HasValue ) _animationiterationcount = 1;
		if ( !_fontsmooth.HasValue ) _fontsmooth = UI.FontSmooth.Auto;
		if ( !_objectfit.HasValue ) _objectfit = UI.ObjectFit.Cover;
		if ( !_outlinewidth.HasValue ) _outlinewidth = 0;
		if ( !_outlinecolor.HasValue ) _outlinecolor = Color.Transparent;
		if ( !_outlineoffset.HasValue ) _outlineoffset = 0;
	}

	internal bool IsDefault( string name )
	{
		switch ( name )
		{
			case "content": return (_content == "");
			case "width": return (_width == Length.Undefined);
			case "min-width": return (_minwidth == 0);
			case "max-width": return (_maxwidth == Length.Undefined);
			case "height": return (_height == Length.Undefined);
			case "min-height": return (_minheight == 0);
			case "max-height": return (_maxheight == Length.Undefined);
			case "left": return (_left == Length.Undefined);
			case "top": return (_top == Length.Undefined);
			case "right": return (_right == Length.Undefined);
			case "bottom": return (_bottom == Length.Undefined);
			case "opacity": return (_opacity == 1);
			case "background-color": return (_backgroundcolor == Color.Transparent);
			case "padding-left": return (_paddingleft == 0);
			case "padding-top": return (_paddingtop == 0);
			case "padding-right": return (_paddingright == 0);
			case "padding-bottom": return (_paddingbottom == 0);
			case "margin-left": return (_marginleft == 0);
			case "margin-top": return (_margintop == 0);
			case "margin-right": return (_marginright == 0);
			case "margin-bottom": return (_marginbottom == 0);
			case "border-top-left-radius": return (_bordertopleftradius == 0);
			case "border-top-right-radius": return (_bordertoprightradius == 0);
			case "border-bottom-right-radius": return (_borderbottomrightradius == 0);
			case "border-bottom-left-radius": return (_borderbottomleftradius == 0);
			case "border-left-width": return (_borderleftwidth == 0);
			case "border-top-width": return (_bordertopwidth == 0);
			case "border-right-width": return (_borderrightwidth == 0);
			case "border-bottom-width": return (_borderbottomwidth == 0);
			case "border-left-color": return (_borderleftcolor == Color.White);
			case "border-top-color": return (_bordertopcolor == Color.White);
			case "border-right-color": return (_borderrightcolor == Color.White);
			case "border-bottom-color": return (_borderbottomcolor == Color.White);
			case "font-size": return (_fontsize == Length.Pixels( 13 ).Value);
			case "font-color": return (_fontcolor == Color.Black);
			case "font-weight": return (_fontweight == 400);
			case "font-family": return (_fontfamily == "Arial");
			case "caret-color": return (_caretcolor == null);
			case "cursor": return (_cursor == "auto");
			case "pointer-events": return (_pointerevents == UI.PointerEvents.None);
			case "mix-blend-mode": return (_mixblendmode == "default");
			case "position": return (_position == UI.PositionMode.Static);
			case "overflow-x": return (_overflowx == OverflowMode.Visible);
			case "overflow-y": return (_overflowy == OverflowMode.Visible);
			case "flex-direction": return (_flexdirection == UI.FlexDirection.Row);
			case "justify-content": return (_justifycontent == Justify.FlexStart);
			case "display": return (_display == DisplayMode.Flex);
			case "flex-wrap": return (_flexwrap == Wrap.NoWrap);
			case "align-content": return (_aligncontent == Align.Auto);
			case "align-self": return (_alignself == Align.Auto);
			case "align-items": return (_alignitems == Align.Stretch);
			case "flex-basis": return (_flexbasis == Length.Auto);
			case "flex-grow": return (_flexgrow == 0);
			case "flex-shrink": return (_flexshrink == 1);
			case "row-gap": return (_rowgap == Length.Auto);
			case "column-gap": return (_columngap == Length.Auto);
			case "aspect-ratio": return (_aspectratio == float.NaN);
			case "text-align": return (_textalign == UI.TextAlign.Left);
			case "text-overflow": return (_textoverflow == UI.TextOverflow.None);
			case "text-filter": return (_textfilter == Rendering.FilterMode.Bilinear);
			case "word-break": return (_wordbreak == UI.WordBreak.Normal);
			case "text-decoration-line": return (_textdecorationline == TextDecoration.None);
			case "text-decoration-color": return (_textdecorationcolor == Color.White);
			case "text-decoration-thickness": return (_textdecorationthickness == 1);
			case "text-decoration-skip-ink": return (_textdecorationskipink == 0);
			case "text-decoration-style": return (_textdecorationstyle == UI.TextDecorationStyle.Solid);
			case "text-underline-offset": return (_textunderlineoffset == 0);
			case "text-overline-offset": return (_textoverlineoffset == 0);
			case "text-line-through-offset": return (_textlinethroughoffset == 0);
			case "font-style": return (_fontstyle == UI.FontStyle.None);
			case "font-variant-numeric": return (_fontvariantnumeric == UI.FontVariantNumeric.Normal);
			case "transform": return (_transform == new UI.PanelTransform());
			case "text-transform": return (_texttransform == UI.TextTransform.None);
			case "transform-origin-x": return (_transformoriginx == Length.Percent( 50 ).Value);
			case "transform-origin-y": return (_transformoriginy == Length.Percent( 50 ).Value);
			case "letter-spacing": return (_letterspacing == Length.Percent( 0 ).Value);
			case "line-height": return (_lineheight == Length.Percent( 100 ).Value);
			case "word-spacing": return (_wordspacing == Length.Percent( 0 ).Value);
			case "white-space": return (_whitespace == UI.WhiteSpace.Normal);
			case "z-index": return (_zindex == 0);
			case "order": return (_order == 0);
			case "sound-in": return (_soundin == "");
			case "sound-out": return (_soundout == "");
			case "backdrop-filter-blur": return (_backdropfilterblur == 0);
			case "backdrop-filter-brightness": return (_backdropfilterbrightness == 1);
			case "backdrop-filter-contrast": return (_backdropfiltercontrast == 1);
			case "backdrop-filter-saturate": return (_backdropfiltersaturate == 1);
			case "backdrop-filter-sepia": return (_backdropfiltersepia == 0);
			case "backdrop-filter-invert": return (_backdropfilterinvert == 0);
			case "backdrop-filter-hue-rotate": return (_backdropfilterhuerotate == 0);
			case "filter-blur": return (_filterblur == 0);
			case "filter-saturate": return (_filtersaturate == 1);
			case "filter-sepia": return (_filtersepia == 0);
			case "filter-brightness": return (_filterbrightness == 1);
			case "filter-hue-rotate": return (_filterhuerotate == 0);
			case "filter-invert": return (_filterinvert == 0);
			case "filter-contrast": return (_filtercontrast == 1);
			case "filter-tint": return (_filtertint == Color.White);
			case "filter-border-width": return (_filterborderwidth == 0);
			case "filter-border-color": return (_filterbordercolor == Color.White);
			case "mask-mode": return (_maskmode == UI.MaskMode.MatchSource);
			case "mask-repeat": return (_maskrepeat == UI.BackgroundRepeat.Repeat);
			case "mask-size-x": return (_masksizex == Length.Undefined);
			case "mask-size-y": return (_masksizey == Length.Undefined);
			case "mask-position-x": return (_maskpositionx == Length.Percent( 0 ).Value);
			case "mask-position-y": return (_maskpositiony == Length.Percent( 0 ).Value);
			case "mask-angle": return (_maskangle == 0);
			case "mask-scope": return (_maskscope == UI.MaskScope.Default);
			case "background-size-x": return (_backgroundsizex == Length.Undefined);
			case "background-size-y": return (_backgroundsizey == Length.Undefined);
			case "background-position-x": return (_backgroundpositionx == Length.Percent( 0 ).Value);
			case "background-position-y": return (_backgroundpositiony == Length.Percent( 0 ).Value);
			case "background-repeat": return (_backgroundrepeat == UI.BackgroundRepeat.Repeat);
			case "border-image-width-left": return (_borderimagewidthleft == 1);
			case "border-image-width-right": return (_borderimagewidthright == 1);
			case "border-image-width-top": return (_borderimagewidthtop == 1);
			case "border-image-width-bottom": return (_borderimagewidthbottom == 1);
			case "border-image-fill": return (_borderimagefill == UI.BorderImageFill.Unfilled);
			case "border-image-repeat": return (_borderimagerepeat == UI.BorderImageRepeat.Stretch);
			case "border-image-tint": return (_borderimagetint == Color.White);
			case "background-blend-mode": return (_backgroundblendmode == "normal");
			case "background-tint": return (_backgroundtint == Color.White);
			case "background-angle": return (_backgroundangle == 0);
			case "text-background-angle": return (_textbackgroundangle == 0);
			case "perspective-origin-x": return (_perspectiveoriginx == Length.Percent( 50 ).Value);
			case "perspective-origin-y": return (_perspectiveoriginy == Length.Percent( 50 ).Value);
			case "text-stroke-color": return (_textstrokecolor == Color.White);
			case "text-stroke-width": return (_textstrokewidth == 0);
			case "image-rendering": return (_imagerendering == UI.ImageRendering.Anisotropic);
			case "animation-delay": return (_animationdelay == 0);
			case "animation-direction": return (_animationdirection == "normal");
			case "animation-duration": return (_animationduration == 0);
			case "animation-fill-mode": return (_animationfillmode == "none");
			case "animation-iteration-count": return (_animationiterationcount == 1);
			case "animation-name": return (_animationname == "none");
			case "animation-play-state": return (_animationplaystate == "running");
			case "animation-timing-function": return (_animationtimingfunction == "ease");
			case "font-smooth": return (_fontsmooth == UI.FontSmooth.Auto);
			case "object-fit": return (_objectfit == UI.ObjectFit.Cover);
			case "outline-width": return (_outlinewidth == 0);
			case "outline-color": return (_outlinecolor == Color.Transparent);
			case "outline-offset": return (_outlineoffset == 0);
		}
		
		throw new Exception( $"Invalid property name '{name}'" );
	}
}