anchor.diff:                  | FaStack2x
   
               type IconOption =
  -                | Size          of IIconSize
  -                | Border        of IBorder
  -                | Pull          of IPull
  -                | Rotation      of IRotation
  -                | Flip          of IFLip
  -                | Color         of IColor
  -                | Icon          of IFontAwesomeIcon
  -                | Animation     of IAnimation
  +                | Size of IIconSize
  +                | Border of IBorder
  +                | Pull of IPull
  +                | Rotation of IRotation
  +                | Flip of IFLip
  +                | Color of IColor
  +                | Icon of IFontAwesomeIcon
  +                | Animation of IAnimation
                   | IsLi
   
               type StackParentOption =
                   | ParentSize of IIconSize
   
               type StackChildOption =
  -                | ChildSize       of IStackChildSize
  -                | ChildColor      of IColor
  -                | ChildIcon       of IFontAwesomeIcon
  +                | ChildSize of IStackChildSize
  +                | ChildColor of IColor
  +                | ChildIcon of IFontAwesomeIcon
   
               let ofSize =
                   function
  -                | FaLarge   -> Classes.IconSizes.FaLarge
  -                | Fa2x      -> Classes.IconSizes.Fa2x
  -                | Fa3x      -> Classes.IconSizes.Fa3x
  -                | Fa4x      -> Classes.IconSizes.Fa4x
  -                | Fa5x      -> Classes.IconSizes.Fa5x
  -                | Fw        -> Classes.IconSizes.Fw
  +                | FaLarge -> Classes.IconSizes.FaLarge
  +                | Fa2x -> Classes.IconSizes.Fa2x
  +                | Fa3x -> Classes.IconSizes.Fa3x
  +                | Fa4x -> Classes.IconSizes.Fa4x
  +                | Fa5x -> Classes.IconSizes.Fa5x
  +                | Fw -> Classes.IconSizes.Fw
   
               let ofChildSize =
                   function
  -                | FaStack1x   -> Classes.ChildSizes.FaStack1x
  -                | FaStack2x   -> Classes.ChildSizes.FaStack2x
  +                | FaStack1x -> Classes.ChildSizes.FaStack1x
  +                | FaStack2x -> Classes.ChildSizes.FaStack2x
   
               let ofBorder =
                   function
  
positive.code:             module Animations =
                  let [<Literal>] Spin = "fa-spin"
                  let [<Literal>] Pulse = "fa-pulse"
              module Rotations =
                  let [<Literal>] Rotate90 = "fa-rotate-90"
                  let [<Literal>] Rotate180 = "fa-rotate-180"
                  let [<Literal>] Rotate270 = "fa-rotate-270"
  
  
              module Flips =
                  let [<Literal>] Horizontal = "fa-flip-horizontal"
                  let [<Literal>] Vertical = "fa-flip-vertical"
  
negative.code: 
              let ofPull =
                  function
                  | PullLeft -> Classes.Pulls.PullLeft
                  | PullRight -> Classes.Pulls.PullRight
  
              let ofAnimation =
                  function
                  | Spin -> Classes.Animations.Spin
                  | Pulse -> Classes.Animations.Pulse
  
              let ofRotation =
                  function
                  | Rotate90 -> Classes.Rotations.Rotate90
                  | Rotate180 -> Classes.Rotations.Rotate180
                  | Rotate270 -> Classes.Rotations.Rotate270
  
              let ofFlip =
                  function
                  | Horizontal -> Classes.Flips.Horizontal
                  | Vertical -> Classes.Flips.Vertical
  
              let ofColor =
                  function
                  | Inverse -> Classes.Colors.Inverse
  
              type IconOptions =
                  { Icon : string option
                    Size : string option
                    Border : string option
                    Pull : string option
                    Animation : string option
                    Rotation : string option
                    Flip : string option
                    Color : string option
                    IsLi : bool }
                  with
                  static member Empty =
                      { Icon = None
                        Size = None
                        Border = None
                        Pull = None
                        Animation = None
                        Rotation = None
                        Flip = None
                        Color = None
                        IsLi = false }
  
              type StackParentOptions = { Size : string option }
                  with static member Empty = { Size = None }
  
              type StackChildOptions =
                  { Size : string option
                    Color : string option
                    Icon : string option }
                  with
                  static member Empty =
                      { Size = None
                        Color = None
                        Icon = None }
  
          open Types
  
          let icon (i: I.IFontAwesomeIcon) = IconOption.Icon i
          let faLg = IconOption.Size FaLarge
          let fa2x = IconOption.Size Fa2x
          let fa3x = IconOption.Size Fa3x
          let fa4x = IconOption.Size Fa4x
          let fa5x = IconOption.Size Fa5x
          let fw = IconOption.Size Fw
          let border = IconOption.Border FaBorder
          let pullLeft = IconOption.Pull PullLeft
          let pullRight = IconOption.Pull PullRight
          let rotate90 = IconOption.Rotation Rotate90
          let rotate180 = IconOption.Rotation Rotate180
          let rotate270 = IconOption.Rotation Rotate270
          let spin = IconOption.Animation Spin
          let pulse = IconOption.Animation Pulse
          let flipHorizontal = IconOption.Flip Horizontal
          let flipVertical = IconOption.Flip Vertical
          let colorInverse = IconOption.Color Inverse
          let isLi = IconOption.IsLi
  
          //Stack Child Functions
          module Child =
              let faStack2x = StackChildOption.ChildSize FaStack2x
              let faStack1x = StackChildOption.ChildSize FaStack1x
              let colorInverse = StackChildOption.ChildColor Inverse
              let icon (i: I.IFontAwesomeIcon) = StackChildOption.ChildIcon i
  
          //Stack Parent Functions
          module Parent =
              let faLg      = StackParentOption.ParentSize FaLarge
  
      module Icon =
  
          open Fa.Types
  
          let stackChild (faOptions: StackChildOption list ) =
              let parseOptions (result: StackChildOptions) (option: StackChildOption) =
                      match option with
                      | ChildSize s -> { result with Size = ofChildSize  s |> Some }
                      | ChildColor c -> { result with Color = ofColor c |> Some }
                      | ChildIcon faIcon -> { result with Icon = unbox<string> faIcon |> Some }
  
              let opts = faOptions |> List.fold parseOptions StackChildOptions.Empty
              i [ Helpers.classes "fa" [ opts.Icon; opts.Size; opts.Color ] [] ] []
  
          let stackParent (faOptions: StackParentOption list) children =
              let parseOptions (result: StackParentOptions) (option: StackParentOption) =
  