anchor.diff:          let whiteSpaces = [|' '; '\t'; '\r'; '\n'|]            
           let rec selectElements' level (acc:HtmlNode list) source =
   
  +            // if we already have an empty list, terminate early
  +            if acc.Length = 0 then [] else 
  +
               let selectDescendantOfType ty t = 
                   let selectedNodes = filterByAttr level acc "type" (fun v -> v = ty)
                   selectElements' FilterLevel.Root selectedNodes t
   
               let selectEvenOdd (isEven:bool) =
                   acc 
  -                |> Seq.mapi(fun i n -> (i,n))
  -                |> Seq.filter(
  +                |> List.mapi(fun i n -> (i,n))
  +                |> List.filter(
                       fun (i,_) -> 
                           match isEven with
                           | true -> i%2 = 0
                           | false -> i%2 <> 0
                   )
  -                |> Seq.map (fun (_,n) -> n)
  -                |> Seq.toList
  +                |> List.map (fun (_,n) -> n)
  +
  +            let containsIgnoreCase (value:string) (word:string) = word.IndexOf(value, StringComparison.OrdinalIgnoreCase) <> -1
  +            let equalsIgnoreCase (value:string) (word:string) = word.Equals(value, StringComparison.OrdinalIgnoreCase)
   
               match source with
               | TagName(_, name) :: t -> 
                   let selectedNodes = searchTag level acc name
                   selectElements' FilterLevel.Root selectedNodes t
               | ClassPrefix _ :: CssClass(_, className) :: t -> 
  -                let selectedNodes = filterByAttr level acc "class" (fun v -> v.Split(whiteSpaces) |> Seq.exists (fun c -> c = className))
  +                let selectedNodes = filterByAttr level acc "class" (fun v -> v.Split(whiteSpaces) |> Array.exists ((=) className))
                   selectElements' FilterLevel.Root selectedNodes t
   
               | IdPrefix _ :: CssId(_, id) :: t ->
  
positive.code:                 selectElements' FilterLevel.Root selectedNodes t
  
              | OpenAttribute _ :: AttributeName(_, name) :: AttributeContains _ :: AttributeValue(_, value) :: CloseAttribute _ :: t ->
                  let selectedNodes = filterByAttr level acc name (fun v -> v.ToLowerInvariant().Contains(value.ToLowerInvariant()))
                  selectElements' FilterLevel.Root selectedNodes t
                  
              | OpenAttribute _ :: AttributeName(_, name) :: AttributeContainsWord _ :: AttributeValue(_, value) :: CloseAttribute _ :: t ->
                  let selectedNodes = filterByAttr level acc name (fun v -> v.Split(whiteSpaces) |> Seq.exists(fun word -> word.ToLowerInvariant() = value.ToLowerInvariant()))
                  selectElements' FilterLevel.Root selectedNodes t
  
              | OpenAttribute _ :: AttributeName(_, name) :: AttributeNotEqual _ :: AttributeValue(_, value) :: CloseAttribute _ :: t ->
  
negative.code:                     None
  
          let (|TokenStr|_|) (s:string) x  =
              let chars = s.ToCharArray() |> Array.toList
  
              let rec equal x s =
                  match x, s with
  