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: 
              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) =
  
negative.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"
  