anchor.diff:              "filter" => T<Dom.Element> ^-> TSelf
               "filter" => TSelf ^-> TSelf
               "find" => T<string> ^-> TSelf
  -            "find" => T<Dom.Element> ^-> TSelf
  +            "find" => T<Dom.Node> ^-> TSelf
               "find" => TSelf ^-> TSelf
               "first" => T<unit> ^-> TSelf
  -            "has" => (T<string> + T<Dom.Element>) ^-> TSelf
  +            "has" => (T<string> + T<Dom.Node>) ^-> TSelf
               "is" => T<string> ^-> T<bool>
               "is" => (T<int> * T<Dom.Element> ^-> T<bool>) ^-> T<bool>
  -            "is" => T<Dom.Element> ^-> T<bool>
  +            "is" => T<Dom.Node> ^-> T<bool>
               "is" => TSelf ^-> T<bool>
               "last" => T<unit> ^-> TSelf
  -            "map" => ((T<int> * T<Dom.Element>) ^-> T<obj>) ^-> TSelf
  +            "map" => (T<int> * T<Dom.Element> ^-> T<obj>) ^-> TSelf
               "next" => !?T<string> ^-> TSelf
               "nextAll" => !?T<string> ^-> TSelf
               "nextUntil" => T<unit> ^-> TSelf
               "nextUntil" => T<string> * !?T<string> ^-> TSelf
  -            "nextUntil" => (T<Dom.Element> + TSelf) * !?T<string> ^-> TSelf
  +            "nextUntil" => (T<Dom.Node> + TSelf) * !?T<string> ^-> TSelf
               "not" => T<string> ^-> TSelf
               "not" => (T<int> * T<Dom.Element> ^-> T<bool>) ^-> TSelf
  -            "not" => T<Dom.Element> ^-> TSelf
  -            "not" => (Type.ArrayOf T<Dom.Element>) ^-> TSelf
  +            "not" => T<Dom.Node> ^-> TSelf
  +            "not" => (Type.ArrayOf T<Dom.Node>) ^-> TSelf
               "not" => TSelf ^-> TSelf
               "parent" => !?T<string> ^-> TSelf
               "parents" => !?T<string> ^-> TSelf
               "parentsUntil" => T<unit> ^-> TSelf
               "parentsUntil" => T<string> * !?T<string> ^-> TSelf
  -            "parentsUntil" => (T<Dom.Element> + TSelf) * !?T<string> ^-> TSelf
  +            "parentsUntil" => (T<Dom.Node> + TSelf) * !?T<string> ^-> TSelf
               "prev" => !?T<string> ^-> TSelf
               "prevAll" => !?T<string> ^-> TSelf
               "prevUntil" => T<unit> ^-> TSelf
               "prevUntil" => T<string> * !?T<string> ^-> TSelf
  -            "prevUntil" => (T<Dom.Element> + TSelf) * !?T<string> ^-> TSelf
  +            "prevUntil" => (T<Dom.Node> + TSelf) * !?T<string> ^-> TSelf
               "siblings" => !?T<string> ^-> TSelf
               "slice" => T<int> * !?T<int> ^-> TSelf
           ]
  
positive.code:             "length" =? T<int>
  
              // Traversing
              "add" => T<string> + T<Dom.Element> + TSelf ^-> TSelf
              "add" => T<string> * T<Dom.Element> ^-> TSelf
              "addBack" => !?T<string> ^-> TSelf
              "children" => !?T<string> ^-> TSelf
              "closest" => T<string> * !?T<Dom.Element> ^-> TSelf
  
negative.code:             "insertBefore" => Content ^-> TSelf
              "prepend" => Content *+ T<obj> ^-> TSelf
              "prepend" => FuncWithHTML ^-> TSelf
              "prependTo" => Content ^-> TSelf
              "remove" => !?T<string> ^-> TSelf
              "replaceAll" => Content ^-> TSelf
              "replaceWith" => Content ^-> TSelf
              "replaceWith" => (T<Dom.Element> -* Type.Parameters.Empty ^-> Content) ^-> TSelf
              "text" => T<unit> ^-> T<string>
              "text" => T<string> ^-> TSelf
              "text" => ((T<int> + T<string>) ^-> T<string>) ^-> TSelf
  