sassc 2.1.0.pre3 → 2.4.0

data/ext/libsass/src/ast_helpers.hpp

@@ -0,0 +1,292 @@
+#ifndef SASS_AST_HELPERS_H
+#define SASS_AST_HELPERS_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+#include <algorithm>
+#include <functional>
+#include "util_string.hpp"
+
+namespace Sass {
+
+  // ###########################################################################
+  // ###########################################################################
+
+  // easier to search with name
+  const bool DELAYED = true;
+
+  // ToDo: should this really be hardcoded
+  // Note: most methods follow precision option
+  const double NUMBER_EPSILON = 1e-12;
+
+  // macro to test if numbers are equal within a small error margin
+  #define NEAR_EQUAL(lhs, rhs) std::fabs(lhs - rhs) < NUMBER_EPSILON
+
+  // ###########################################################################
+  // We define various functions and functors here.
+  // Functions satisfy the BinaryPredicate requirement
+  // Functors are structs used for e.g. unordered_map
+  // ###########################################################################
+
+  // ###########################################################################
+  // Implement compare and hashing operations for raw pointers
+  // ###########################################################################
+
+  template <class T>
+  size_t PtrHashFn(const T* ptr) {
+    return std::hash<std::size_t>()((size_t)ptr);
+  }
+
+  struct PtrHash {
+    template <class T>
+    size_t operator() (const T* ptr) const {
+      return PtrHashFn(ptr);
+    }
+  };
+
+  template <class T>
+  bool PtrEqualityFn(const T* lhs, const T* rhs) {
+    return lhs == rhs; // compare raw pointers
+  }
+
+  struct PtrEquality {
+    template <class T>
+    bool operator() (const T* lhs, const T* rhs) const {
+      return PtrEqualityFn<T>(lhs, rhs);
+    }
+  };
+
+  // ###########################################################################
+  // Implement compare and hashing operations for AST Nodes
+  // ###########################################################################
+
+  // TODO: get rid of funtions and use ObjEquality<T>
+
+  template <class T>
+  // Hash the raw pointer instead of object
+  size_t ObjPtrHashFn(const T& obj) {
+    return PtrHashFn(obj.ptr());
+  }
+
+  struct ObjPtrHash {
+    template <class T>
+    // Hash the raw pointer instead of object
+    size_t operator() (const T& obj) const {
+      return ObjPtrHashFn(obj);
+    }
+  };
+
+  template <class T>
+  // Hash the object and its content
+  size_t ObjHashFn(const T& obj) {
+    return obj ? obj->hash() : 0;
+  }
+
+  struct ObjHash {
+    template <class T>
+    // Hash the object and its content
+    size_t operator() (const T& obj) const {
+      return ObjHashFn(obj);
+    }
+  };
+
+  template <class T>
+  // Hash the object behind pointer
+  size_t PtrObjHashFn(const T* obj) {
+    return obj ? obj->hash() : 0;
+  }
+
+  struct PtrObjHash {
+    template <class T>
+    // Hash the object behind pointer
+    size_t operator() (const T* obj) const {
+      return PtrObjHashFn(obj);
+    }
+  };
+
+  template <class T>
+  // Compare raw pointers to the object
+  bool ObjPtrEqualityFn(const T& lhs, const T& rhs) {
+    return PtrEqualityFn(lhs.ptr(), rhs.ptr());
+  }
+
+  struct ObjPtrEquality {
+    template <class T>
+    // Compare raw pointers to the object
+    bool operator() (const T& lhs, const T& rhs) const {
+      return ObjPtrEqualityFn<T>(lhs, rhs);
+    }
+  };
+
+  template <class T>
+  // Compare the objects behind the pointers
+  bool PtrObjEqualityFn(const T* lhs, const T* rhs) {
+    if (lhs == nullptr) return rhs == nullptr;
+    else if (rhs == nullptr) return false;
+    else return *lhs == *rhs;
+  }
+
+  struct PtrObjEquality {
+    template <class T>
+    // Compare the objects behind the pointers
+    bool operator() (const T* lhs, const T* rhs) const {
+      return PtrObjEqualityFn<T>(lhs, rhs);
+    }
+  };
+
+  template <class T>
+  // Compare the objects and its contents
+  bool ObjEqualityFn(const T& lhs, const T& rhs) {
+    return PtrObjEqualityFn(lhs.ptr(), rhs.ptr());
+  }
+
+  struct ObjEquality {
+    template <class T>
+    // Compare the objects and its contents
+    bool operator() (const T& lhs, const T& rhs) const {
+      return ObjEqualityFn<T>(lhs, rhs);
+    }
+  };
+
+  // ###########################################################################
+  // Implement ordering operations for AST Nodes
+  // ###########################################################################
+
+  template <class T>
+  // Compare the objects behind pointers
+  bool PtrObjLessThanFn(const T* lhs, const T* rhs) {
+    if (lhs == nullptr) return rhs != nullptr;
+    else if (rhs == nullptr) return false;
+    else return *lhs < *rhs;
+  }
+
+  struct PtrObjLessThan {
+    template <class T>
+    // Compare the objects behind pointers
+    bool operator() (const T* lhs, const T* rhs) const {
+      return PtrObjLessThanFn<T>(lhs, rhs);
+    }
+  };
+
+  template <class T>
+  // Compare the objects and its content
+  bool ObjLessThanFn(const T& lhs, const T& rhs) {
+    return PtrObjLessThanFn(lhs.ptr(), rhs.ptr());
+  };
+
+  struct ObjLessThan {
+    template <class T>
+    // Compare the objects and its content
+    bool operator() (const T& lhs, const T& rhs) const {
+      return ObjLessThanFn<T>(lhs, rhs);
+    }
+  };
+
+  // ###########################################################################
+  // Some STL helper functions
+  // ###########################################################################
+
+  // Check if all elements are equal
+  template <class X, class Y,
+    typename XT = typename X::value_type,
+    typename YT = typename Y::value_type>
+  bool ListEquality(const X& lhs, const Y& rhs,
+    bool(*cmp)(const XT*, const YT*))
+  {
+    return lhs.size() == rhs.size() &&
+      std::equal(lhs.begin(), lhs.end(),
+        rhs.begin(), cmp);
+  }
+
+  // Return if Vector is empty
+  template <class T>
+  bool listIsEmpty(T* cnt) {
+    return cnt && cnt->empty();
+  }
+
+  // Erase items from vector that match predicate
+  template<class T, class UnaryPredicate>
+  void listEraseItemIf(T& vec, UnaryPredicate* predicate)
+  {
+    vec.erase(std::remove_if(vec.begin(), vec.end(), predicate), vec.end());
+  }
+
+  // Check that every item in `lhs` is also in `rhs`
+  // Note: this works by comparing the raw pointers
+  template <typename T>
+  bool listIsSubsetOrEqual(const T& lhs, const T& rhs) {
+    for (const auto& item : lhs) {
+      if (std::find(rhs.begin(), rhs.end(), item) == rhs.end())
+        return false;
+    }
+    return true;
+  }
+
+  // ##########################################################################
+  // Returns whether [name] is the name of a pseudo-element
+  // that can be written with pseudo-class syntax (CSS2 vs CSS3):
+  // `:before`, `:after`, `:first-line`, or `:first-letter`
+  // ##########################################################################
+  inline bool isFakePseudoElement(const sass::string& name)
+  {
+    return Util::equalsLiteral("after", name)
+      || Util::equalsLiteral("before", name)
+      || Util::equalsLiteral("first-line", name)
+      || Util::equalsLiteral("first-letter", name);
+  }
+
+  // ##########################################################################
+  // Names of pseudo selectors that take selectors as arguments,
+  // and that are subselectors of their arguments.
+  // For example, `.foo` is a superselector of `:matches(.foo)`.
+  // ##########################################################################
+  inline bool isSubselectorPseudo(const sass::string& norm)
+  {
+    return Util::equalsLiteral("any", norm)
+      || Util::equalsLiteral("matches", norm)
+      || Util::equalsLiteral("nth-child", norm)
+      || Util::equalsLiteral("nth-last-child", norm);
+  }
+  // EO isSubselectorPseudo
+
+  // ###########################################################################
+  // Pseudo-class selectors that take unadorned selectors as arguments.
+  // ###########################################################################
+  inline bool isSelectorPseudoClass(const sass::string& test)
+  {
+    return Util::equalsLiteral("not", test)
+      || Util::equalsLiteral("matches", test)
+      || Util::equalsLiteral("current", test)
+      || Util::equalsLiteral("any", test)
+      || Util::equalsLiteral("has", test)
+      || Util::equalsLiteral("host", test)
+      || Util::equalsLiteral("host-context", test);
+  }
+  // EO isSelectorPseudoClass
+
+  // ###########################################################################
+  // Pseudo-element selectors that take unadorned selectors as arguments.
+  // ###########################################################################
+  inline bool isSelectorPseudoElement(const sass::string& test)
+  {
+    return Util::equalsLiteral("slotted", test);
+  }
+  // EO isSelectorPseudoElement
+
+  // ###########################################################################
+  // Pseudo-element selectors that has binominals
+  // ###########################################################################
+  inline bool isSelectorPseudoBinominal(const sass::string& test)
+  {
+    return Util::equalsLiteral("nth-child", test)
+      || Util::equalsLiteral("nth-last-child", test);
+  }
+  // isSelectorPseudoBinominal
+
+  // ###########################################################################
+  // ###########################################################################
+
+}
+
+#endif

data/ext/libsass/src/ast_sel_cmp.cpp

@@ -2,51 +2,17 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
-#include "ast.hpp"
-#include "context.hpp"
-#include "node.hpp"
-#include "eval.hpp"
-#include "extend.hpp"
-#include "emitter.hpp"
-#include "color_maps.hpp"
-#include "ast_fwd_decl.hpp"
-#include <set>
-#include <iomanip>
-#include <iostream>
-#include <algorithm>
-#include <functional>
-#include <cctype>
-#include <locale>
-
 #include "ast_selectors.hpp"
 
 namespace Sass {
 
   /*#########################################################################*/
+  // Compare against base class on right hand side
+  // try to find the most specialized implementation
   /*#########################################################################*/
 
-  bool Selector_List::operator== (const Selector& rhs) const
-  {
-    if (auto sl = Cast<Selector_List>(&rhs)) { return *this == *sl; }
-    else if (auto ss = Cast<Simple_Selector>(&rhs)) { return *this == *ss; }
-    else if (auto cpx = Cast<Complex_Selector>(&rhs)) { return *this == *cpx; }
-    else if (auto cpd = Cast<Compound_Selector>(&rhs)) { return *this == *cpd; }
-    else if (auto ls = Cast<List>(&rhs)) { return *this == *ls; }
-    throw std::runtime_error("invalid selector base classes to compare");
-  }
-
-  bool Selector_List::operator< (const Selector& rhs) const
-  {
-    if (auto sl = Cast<Selector_List>(&rhs)) { return *this < *sl; }
-    else if (auto ss = Cast<Simple_Selector>(&rhs)) { return *this < *ss; }
-    else if (auto cpx = Cast<Complex_Selector>(&rhs)) { return *this < *cpx; }
-    else if (auto cpd = Cast<Compound_Selector>(&rhs)) { return *this < *cpd; }
-    else if (auto ls = Cast<List>(&rhs)) { return *this < *ls; }
-    throw std::runtime_error("invalid selector base classes to compare");
-  }
-
   // Selector lists can be compared to comma lists
-  bool Selector_List::operator== (const Expression& rhs) const
+  bool SelectorList::operator== (const Expression& rhs) const
   {
     if (auto l = Cast<List>(&rhs)) { return *this == *l; }
     if (auto s = Cast<Selector>(&rhs)) { return *this == *s; }
@@ -55,852 +21,373 @@ namespace Sass {
   }
 
   // Selector lists can be compared to comma lists
-  bool Selector_List::operator< (const Expression& rhs) const
-  {
-    if (auto l = Cast<List>(&rhs)) { return *this < *l; }
-    if (auto s = Cast<Selector>(&rhs)) { return *this < *s; }
-    if (Cast<String>(&rhs) || Cast<Null>(&rhs)) { return true; }
-    throw std::runtime_error("invalid selector base classes to compare");
-  }
-
-  bool Complex_Selector::operator== (const Selector& rhs) const
-  {
-    if (auto sl = Cast<Selector_List>(&rhs)) return *this == *sl;
-    if (auto ss = Cast<Simple_Selector>(&rhs)) return *this == *ss;
-    if (auto cs = Cast<Complex_Selector>(&rhs)) return *this == *cs;
-    if (auto ch = Cast<Compound_Selector>(&rhs)) return *this == *ch;
-    throw std::runtime_error("invalid selector base classes to compare");
-  }
-
-  bool Complex_Selector::operator< (const Selector& rhs) const
-  {
-    if (auto sl = Cast<Selector_List>(&rhs)) return *this < *sl;
-    if (auto ss = Cast<Simple_Selector>(&rhs)) return *this < *ss;
-    if (auto cs = Cast<Complex_Selector>(&rhs)) return *this < *cs;
-    if (auto ch = Cast<Compound_Selector>(&rhs)) return *this < *ch;
-    throw std::runtime_error("invalid selector base classes to compare");
-  }
-
-  bool Compound_Selector::operator== (const Selector& rhs) const
+  bool SelectorList::operator== (const Selector& rhs) const
   {
-    if (auto sl = Cast<Selector_List>(&rhs)) return *this == *sl;
-    if (auto ss = Cast<Simple_Selector>(&rhs)) return *this == *ss;
-    if (auto cs = Cast<Complex_Selector>(&rhs)) return *this == *cs;
-    if (auto ch = Cast<Compound_Selector>(&rhs)) return *this == *ch;
+    if (auto sel = Cast<SelectorList>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<ComplexSelector>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<CompoundSelector>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<SimpleSelector>(&rhs)) { return *this == *sel; }
+    if (auto list = Cast<List>(&rhs)) { return *this == *list; }
     throw std::runtime_error("invalid selector base classes to compare");
   }
 
-  bool Compound_Selector::operator< (const Selector& rhs) const
+  bool ComplexSelector::operator== (const Selector& rhs) const
   {
-    if (auto sl = Cast<Selector_List>(&rhs)) return *this < *sl;
-    if (auto ss = Cast<Simple_Selector>(&rhs)) return *this < *ss;
-    if (auto cs = Cast<Complex_Selector>(&rhs)) return *this < *cs;
-    if (auto ch = Cast<Compound_Selector>(&rhs)) return *this < *ch;
+    if (auto sel = Cast<SelectorList>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<ComplexSelector>(&rhs)) { return *sel == *this; }
+    if (auto sel = Cast<CompoundSelector>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<SimpleSelector>(&rhs)) { return *this == *sel; }
     throw std::runtime_error("invalid selector base classes to compare");
   }
 
-  bool Selector_Schema::operator== (const Selector& rhs) const
+  bool SelectorCombinator::operator== (const Selector& rhs) const
   {
-    if (auto sl = Cast<Selector_List>(&rhs)) return *this == *sl;
-    if (auto ss = Cast<Simple_Selector>(&rhs)) return *this == *ss;
-    if (auto cs = Cast<Complex_Selector>(&rhs)) return *this == *cs;
-    if (auto ch = Cast<Compound_Selector>(&rhs)) return *this == *ch;
-    throw std::runtime_error("invalid selector base classes to compare");
-  }
-
-  bool Selector_Schema::operator< (const Selector& rhs) const
-  {
-    if (auto sl = Cast<Selector_List>(&rhs)) return *this < *sl;
-    if (auto ss = Cast<Simple_Selector>(&rhs)) return *this < *ss;
-    if (auto cs = Cast<Complex_Selector>(&rhs)) return *this < *cs;
-    if (auto ch = Cast<Compound_Selector>(&rhs)) return *this < *ch;
-    throw std::runtime_error("invalid selector base classes to compare");
+    if (auto cpx = Cast<SelectorCombinator>(&rhs)) { return *this == *cpx; }
+    return false;
   }
 
-  bool Simple_Selector::operator== (const Selector& rhs) const
+  bool CompoundSelector::operator== (const Selector& rhs) const
   {
-    if (auto sl = Cast<Selector_List>(&rhs)) return *this == *sl;
-    if (auto ss = Cast<Simple_Selector>(&rhs)) return *this == *ss;
-    if (auto cs = Cast<Complex_Selector>(&rhs)) return *this == *cs;
-    if (auto ch = Cast<Compound_Selector>(&rhs)) return *this == *ch;
+    if (auto sel = Cast<SimpleSelector>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<SelectorList>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<ComplexSelector>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<CompoundSelector>(&rhs)) { return *this == *sel; }
     throw std::runtime_error("invalid selector base classes to compare");
   }
 
-  bool Simple_Selector::operator< (const Selector& rhs) const
+  bool SimpleSelector::operator== (const Selector& rhs) const
   {
-    if (auto sl = Cast<Selector_List>(&rhs)) return *this < *sl;
-    if (auto ss = Cast<Simple_Selector>(&rhs)) return *this < *ss;
-    if (auto cs = Cast<Complex_Selector>(&rhs)) return *this < *cs;
-    if (auto ch = Cast<Compound_Selector>(&rhs)) return *this < *ch;
+    if (auto sel = Cast<SelectorList>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<ComplexSelector>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<CompoundSelector>(&rhs)) { return *this == *sel; }
+    if (auto sel = Cast<SimpleSelector>(&rhs)) return *this == *sel;
     throw std::runtime_error("invalid selector base classes to compare");
   }
 
   /*#########################################################################*/
   /*#########################################################################*/
 
-  bool Selector_List::operator< (const Selector_List& rhs) const
-  {
-    size_t l = rhs.length();
-    if (length() < l) l = length();
-    for (size_t i = 0; i < l; i ++) {
-      if (*at(i) < *rhs.at(i)) return true;
-      if (*at(i) != *rhs.at(i)) return false;
-    }
-    return false;
-  }
-
-  bool Selector_List::operator== (const Selector_List& rhs) const
+  bool SelectorList::operator== (const SelectorList& rhs) const
   {
     if (&rhs == this) return true;
     if (rhs.length() != length()) return false;
-    std::unordered_set<const Complex_Selector *, HashPtr, ComparePtrs> lhs_set;
+    std::unordered_set<const ComplexSelector*, PtrObjHash, PtrObjEquality> lhs_set;
     lhs_set.reserve(length());
-    for (const Complex_Selector_Obj &element : elements()) {
+    for (const ComplexSelectorObj& element : elements()) {
       lhs_set.insert(element.ptr());
     }
-    for (const Complex_Selector_Obj &element : rhs.elements()) {
-        if (lhs_set.find(element.ptr()) == lhs_set.end()) return false;
-    }
-    return true;
-  }
-
-  bool Compound_Selector::operator< (const Compound_Selector& rhs) const
-  {
-    size_t L = std::min(length(), rhs.length());
-    for (size_t i = 0; i < L; ++i)
-    {
-      Simple_Selector* l = (*this)[i];
-      Simple_Selector* r = rhs[i];
-      if (!l && !r) return false;
-      else if (!r) return false;
-      else if (!l) return true;
-      else if (*l != *r)
-      { return *l < *r; }
-    }
-    // just compare the length now
-    return length() < rhs.length();
-  }
-
-  bool Compound_Selector::operator== (const Compound_Selector& rhs) const
-  {
-    if (&rhs == this) return true;
-    if (rhs.length() != length()) return false;
-    std::unordered_set<const Simple_Selector *, HashPtr, ComparePtrs> lhs_set;
-    lhs_set.reserve(length());
-    for (const Simple_Selector_Obj &element : elements()) {
-      lhs_set.insert(element.ptr());
-    }
-    // there is no break?!
-    for (const Simple_Selector_Obj &element : rhs.elements()) {
+    for (const ComplexSelectorObj& element : rhs.elements()) {
       if (lhs_set.find(element.ptr()) == lhs_set.end()) return false;
     }
     return true;
   }
 
-  bool Complex_Selector::operator< (const Complex_Selector& rhs) const
-  {
-    // const iterators for tails
-    const Complex_Selector* l = this;
-    const Complex_Selector* r = &rhs;
-    Compound_Selector* l_h = NULL;
-    Compound_Selector* r_h = NULL;
-    if (l) l_h = l->head();
-    if (r) r_h = r->head();
-    // process all tails
-    while (true)
-    {
-      #ifdef DEBUG
-      // skip empty ancestor first
-      if (l && l->is_empty_ancestor())
-      {
-        l_h = NULL;
-        l = l->tail();
-        if(l) l_h = l->head();
-        continue;
-      }
-      // skip empty ancestor first
-      if (r && r->is_empty_ancestor())
-      {
-        r_h = NULL;
-        r = r->tail();
-        if (r) r_h = r->head();
-        continue;
-      }
-      #endif
-      // check for valid selectors
-      if (!l) return !!r;
-      if (!r) return false;
-      // both are null
-      else if (!l_h && !r_h)
-      {
-        // check combinator after heads
-        if (l->combinator() != r->combinator())
-        { return l->combinator() < r->combinator(); }
-        // advance to next tails
-        l = l->tail();
-        r = r->tail();
-        // fetch the next headers
-        l_h = NULL; r_h = NULL;
-        if (l) l_h = l->head();
-        if (r) r_h = r->head();
-      }
-      // one side is null
-      else if (!r_h) return true;
-      else if (!l_h) return false;
-      // heads ok and equal
-      else if (*l_h == *r_h)
-      {
-        // check combinator after heads
-        if (l->combinator() != r->combinator())
-        { return l->combinator() < r->combinator(); }
-        // advance to next tails
-        l = l->tail();
-        r = r->tail();
-        // fetch the next headers
-        l_h = NULL; r_h = NULL;
-        if (l) l_h = l->head();
-        if (r) r_h = r->head();
-      }
-      // heads are not equal
-      else return *l_h < *r_h;
-    }
-  }
 
-  bool Complex_Selector::operator== (const Complex_Selector& rhs) const
-  {
-    // const iterators for tails
-    const Complex_Selector* l = this;
-    const Complex_Selector* r = &rhs;
-    Compound_Selector* l_h = NULL;
-    Compound_Selector* r_h = NULL;
-    if (l) l_h = l->head();
-    if (r) r_h = r->head();
-    // process all tails
-    while (true)
-    {
-      // check the pointers
-      if (!r) return !l;
-      if (!l) return !r;
-      // both are null
-      if (!l_h && !r_h)
-      {
-        // check combinator after heads
-        if (l->combinator() != r->combinator())
-        { return l->combinator() < r->combinator(); }
-        // advance to next tails
-        l = l->tail();
-        r = r->tail();
-        // fetch the next heads
-        l_h = NULL; r_h = NULL;
-        if (l) l_h = l->head();
-        if (r) r_h = r->head();
-      }
-      // equals if other head is empty
-      else if ((!l_h && !r_h) ||
-               (!l_h && r_h->empty()) ||
-               (!r_h && l_h->empty()) ||
-               (l_h && r_h && *l_h == *r_h))
-      {
-        // check combinator after heads
-        if (l->combinator() != r->combinator())
-        { return l->combinator() == r->combinator(); }
-        // advance to next tails
-        l = l->tail();
-        r = r->tail();
-        // fetch the next heads
-        l_h = NULL; r_h = NULL;
-        if (l) l_h = l->head();
-        if (r) r_h = r->head();
-      }
-      // abort
-      else break;
-    }
-    // unreachable
-    return false;
-  }
 
   /*#########################################################################*/
+  // Compare SelectorList against all other selector types
   /*#########################################################################*/
 
-  bool Selector_List::operator== (const Complex_Selector& rhs) const
-  {
-    size_t len = length();
-    if (len > 1) return false;
-    if (len == 0) return rhs.empty();
-    return *at(0) == rhs;
-  }
-
-  bool Selector_List::operator< (const Complex_Selector& rhs) const
+  bool SelectorList::operator== (const ComplexSelector& rhs) const
   {
-    size_t len = length();
-    if (len > 1) return false;
-    if (len == 0) return !rhs.empty();
-    return *at(0) < rhs;
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (length() != 1) return false;
+    // Compare simple selectors
+    return *get(0) == rhs;
   }
 
-  bool Selector_List::operator== (const Compound_Selector& rhs) const
+  bool SelectorList::operator== (const CompoundSelector& rhs) const
   {
-    size_t len = length();
-    if (len > 1) return false;
-    if (len == 0) return rhs.empty();
-    return *at(0) == rhs;
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (length() != 1) return false;
+    // Compare simple selectors
+    return *get(0) == rhs;
   }
 
-  bool Selector_List::operator< (const Compound_Selector& rhs) const
+  bool SelectorList::operator== (const SimpleSelector& rhs) const
   {
-    size_t len = length();
-    if (len > 1) return false;
-    if (len == 0) return !rhs.empty();
-    return *at(0) < rhs;
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (length() != 1) return false;
+    // Compare simple selectors
+    return *get(0) == rhs;
   }
 
-  bool Selector_List::operator== (const Simple_Selector& rhs) const
-  {
-    size_t len = length();
-    if (len > 1) return false;
-    if (len == 0) return rhs.empty();
-    return *at(0) == rhs;
-  }
+  /*#########################################################################*/
+  // Compare ComplexSelector against itself
+  /*#########################################################################*/
 
-  bool Selector_List::operator< (const Simple_Selector& rhs) const
+  bool ComplexSelector::operator== (const ComplexSelector& rhs) const
   {
     size_t len = length();
-    if (len > 1) return false;
-    if (len == 0) return !rhs.empty();
-    return *at(0) < rhs;
-  }
-
-  /***************************************************************************/
-  /***************************************************************************/
-
-  bool Complex_Selector::operator== (const Selector_List& rhs) const
-  {
-    size_t len = rhs.length();
-    if (len > 1) return false;
-    if (len == 0) return empty();
-    return *this == *rhs.at(0);
-  }
-
-  bool Complex_Selector::operator< (const Selector_List& rhs) const
-  {
-    size_t len = rhs.length();
-    if (len > 1) return true;
-    if (len == 0) return false;
-    return *this < *rhs.at(0);
+    size_t rlen = rhs.length();
+    if (len != rlen) return false;
+    for (size_t i = 0; i < len; i += 1) {
+      if (*get(i) != *rhs.get(i)) return false;
+    }
+    return true;
   }
 
-  bool Complex_Selector::operator== (const Compound_Selector& rhs) const
-  {
-    if (tail()) return false;
-    if (!head()) return rhs.empty();
-    return *head() == rhs;
-  }
+  /*#########################################################################*/
+  // Compare ComplexSelector against all other selector types
+  /*#########################################################################*/
 
-  bool Complex_Selector::operator< (const Compound_Selector& rhs) const
+  bool ComplexSelector::operator== (const SelectorList& rhs) const
   {
-    if (tail()) return false;
-    if (!head()) return !rhs.empty();
-    return *head() < rhs;
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (rhs.length() != 1) return false;
+    // Compare complex selector
+    return *this == *rhs.get(0);
   }
 
-  bool Complex_Selector::operator== (const Simple_Selector& rhs) const
+  bool ComplexSelector::operator== (const CompoundSelector& rhs) const
   {
-    if (tail()) return false;
-    if (!head()) return rhs.empty();
-    return *head() == rhs;
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (length() != 1) return false;
+    // Compare compound selector
+    return *get(0) == rhs;
   }
 
-  bool Complex_Selector::operator< (const Simple_Selector& rhs) const
+  bool ComplexSelector::operator== (const SimpleSelector& rhs) const
   {
-    if (tail()) return false;
-    if (!head()) return !rhs.empty();
-    return *head() < rhs;
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (length() != 1) return false;
+    // Compare simple selectors
+    return *get(0) == rhs;
   }
 
-  /***************************************************************************/
-  /***************************************************************************/
+  /*#########################################################################*/
+  // Compare SelectorCombinator against itself
+  /*#########################################################################*/
 
-  bool Compound_Selector::operator== (const Selector_List& rhs) const
+  bool SelectorCombinator::operator==(const SelectorCombinator& rhs) const
   {
-    size_t len = rhs.length();
-    if (len > 1) return false;
-    if (len == 0) return empty();
-    return *this == *rhs.at(0);
+    return combinator() == rhs.combinator();
   }
 
-  bool Compound_Selector::operator< (const Selector_List& rhs) const
-  {
-    size_t len = rhs.length();
-    if (len > 1) return true;
-    if (len == 0) return false;
-    return *this < *rhs.at(0);
-  }
+  /*#########################################################################*/
+  // Compare SelectorCombinator against SelectorComponent
+  /*#########################################################################*/
 
-  bool Compound_Selector::operator== (const Complex_Selector& rhs) const
+  bool SelectorCombinator::operator==(const SelectorComponent& rhs) const
   {
-    if (rhs.tail()) return false;
-    if (!rhs.head()) return empty();
-    return *this == *rhs.head();
+    if (const SelectorCombinator * sel = rhs.getCombinator()) {
+      return *this == *sel;
+    }
+    return false;
   }
 
-  bool Compound_Selector::operator< (const Complex_Selector& rhs) const
+  bool CompoundSelector::operator==(const SelectorComponent& rhs) const
   {
-    if (rhs.tail()) return true;
-    if (!rhs.head()) return false;
-    return *this < *rhs.head();
+    if (const CompoundSelector * sel = rhs.getCompound()) {
+      return *this == *sel;
+    }
+    return false;
   }
 
-  bool Compound_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    size_t len = length();
-    if (len > 1) return false;
-    if (len == 0) return rhs.empty();
-    return *at(0) == rhs;
-  }
+  /*#########################################################################*/
+  // Compare CompoundSelector against itself
+  /*#########################################################################*/
+  // ToDo: Verifiy implementation
+  /*#########################################################################*/
 
-  bool Compound_Selector::operator== (const Simple_Selector& rhs) const
+  bool CompoundSelector::operator== (const CompoundSelector& rhs) const
   {
-    size_t len = length();
-    if (len > 1) return false;
-    if (len == 0) return !rhs.empty();
-    return *at(0) < rhs;
+    // std::cerr << "comp vs comp\n";
+    if (&rhs == this) return true;
+    if (rhs.length() != length()) return false;
+    std::unordered_set<const SimpleSelector*, PtrObjHash, PtrObjEquality> lhs_set;
+    lhs_set.reserve(length());
+    for (const SimpleSelectorObj& element : elements()) {
+      lhs_set.insert(element.ptr());
+    }
+    // there is no break?!
+    for (const SimpleSelectorObj& element : rhs.elements()) {
+      if (lhs_set.find(element.ptr()) == lhs_set.end()) return false;
+    }
+    return true;
   }
 
-  /***************************************************************************/
-  /***************************************************************************/
 
-  bool Simple_Selector::operator== (const Selector_List& rhs) const
-  {
-    return rhs.length() == 1 && *this == *rhs.at(0);
-  }
+  /*#########################################################################*/
+  // Compare CompoundSelector against all other selector types
+  /*#########################################################################*/
 
-  bool Simple_Selector::operator< (const Selector_List& rhs) const
+  bool CompoundSelector::operator== (const SelectorList& rhs) const
   {
-    size_t len = rhs.length();
-    if (len > 1) return true;
-    if (len == 0) return false;
-    return *this < *rhs.at(0);
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (rhs.length() != 1) return false;
+    // Compare complex selector
+    return *this == *rhs.get(0);
   }
 
-  bool Simple_Selector::operator== (const Complex_Selector& rhs) const
+  bool CompoundSelector::operator== (const ComplexSelector& rhs) const
   {
-    return !rhs.tail() && rhs.head() &&
-           rhs.combinator() == Complex_Selector::ANCESTOR_OF &&
-           *this == *rhs.head();
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (rhs.length() != 1) return false;
+    // Compare compound selector
+    return *this == *rhs.get(0);
   }
 
-  bool Simple_Selector::operator< (const Complex_Selector& rhs) const
+  bool CompoundSelector::operator== (const SimpleSelector& rhs) const
   {
-    if (rhs.tail()) return true;
-    if (!rhs.head()) return false;
-    return *this < *rhs.head();
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return false;
+    // Must have exactly one item
+    size_t rlen = length();
+    if (rlen > 1) return false;
+    if (rlen == 0) return true;
+    // Compare simple selectors
+    return *get(0) < rhs;
   }
 
-  bool Simple_Selector::operator== (const Compound_Selector& rhs) const
-  {
-    return rhs.length() == 1 && *this == *rhs.at(0);
-  }
+  /*#########################################################################*/
+  // Compare SimpleSelector against itself (upcast from abstract base)
+  /*#########################################################################*/
 
-  bool Simple_Selector::operator< (const Compound_Selector& rhs) const
-  {
-    size_t len = rhs.length();
-    if (len > 1) return true;
-    if (len == 0) return false;
-    return *this < *rhs.at(0);
-  }
+  // DOES NOT EXIST FOR ABSTRACT BASE CLASS
 
   /*#########################################################################*/
+  // Compare SimpleSelector against all other selector types
   /*#########################################################################*/
 
-  bool Simple_Selector::operator== (const Simple_Selector& rhs) const
-  {
-    switch (simple_type()) {
-      case ID_SEL: return (const Id_Selector&) *this == rhs; break;
-      case TYPE_SEL: return (const Type_Selector&) *this == rhs; break;
-      case CLASS_SEL: return (const Class_Selector&) *this == rhs; break;
-      case PARENT_SEL: return (const Parent_Selector&) *this == rhs; break;
-      case PSEUDO_SEL: return (const Pseudo_Selector&) *this == rhs; break;
-      case WRAPPED_SEL: return (const Wrapped_Selector&) *this == rhs; break;
-      case ATTRIBUTE_SEL: return (const Attribute_Selector&) *this == rhs; break;
-      case PLACEHOLDER_SEL: return (const Placeholder_Selector&) *this == rhs; break;
-    }
-    return false;
+  bool SimpleSelector::operator== (const SelectorList& rhs) const
+  {
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (rhs.length() != 1) return false;
+    // Compare complex selector
+    return *this == *rhs.get(0);
   }
 
-  /***************************************************************************/
-  /***************************************************************************/
-
-  bool Id_Selector::operator== (const Simple_Selector& rhs) const
+  bool SimpleSelector::operator== (const ComplexSelector& rhs) const
   {
-    auto sel = Cast<Id_Selector>(&rhs);
-    return sel ? *this == *sel : false;
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return true;
+    // Must have exactly one item
+    if (rhs.length() != 1) return false;
+    // Compare compound selector
+    return *this == *rhs.get(0);
   }
 
-  bool Type_Selector::operator== (const Simple_Selector& rhs) const
+  bool SimpleSelector::operator== (const CompoundSelector& rhs) const
   {
-    auto sel = Cast<Type_Selector>(&rhs);
-    return sel ? *this == *sel : false;
+    // If both are empty they are equal
+    if (empty() && rhs.empty()) return false;
+    // Must have exactly one item
+    if (rhs.length() != 1) return false;
+    // Compare simple selector
+    return *this == *rhs.get(0);
   }
 
-  bool Class_Selector::operator== (const Simple_Selector& rhs) const
+  /*#########################################################################*/
+  /*#########################################################################*/
+
+  bool IDSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Class_Selector>(&rhs);
+    auto sel = Cast<IDSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Parent_Selector::operator== (const Simple_Selector& rhs) const
+  bool TypeSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Parent_Selector>(&rhs);
+    auto sel = Cast<TypeSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Pseudo_Selector::operator== (const Simple_Selector& rhs) const
+  bool ClassSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Pseudo_Selector>(&rhs);
+    auto sel = Cast<ClassSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Wrapped_Selector::operator== (const Simple_Selector& rhs) const
+  bool PseudoSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Wrapped_Selector>(&rhs);
+    auto sel = Cast<PseudoSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Attribute_Selector::operator== (const Simple_Selector& rhs) const
+  bool AttributeSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Attribute_Selector>(&rhs);
+    auto sel = Cast<AttributeSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  bool Placeholder_Selector::operator== (const Simple_Selector& rhs) const
+  bool PlaceholderSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Placeholder_Selector>(&rhs);
+    auto sel = Cast<PlaceholderSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
-  /***************************************************************************/
-  /***************************************************************************/
+  /*#########################################################################*/
+  /*#########################################################################*/
 
-  bool Id_Selector::operator== (const Id_Selector& rhs) const
+  bool IDSelector::operator== (const IDSelector& rhs) const
   {
     // ID has no namespacing
     return name() == rhs.name();
   }
 
-  bool Type_Selector::operator== (const Type_Selector& rhs) const
+  bool TypeSelector::operator== (const TypeSelector& rhs) const
   {
     return is_ns_eq(rhs) && name() == rhs.name();
   }
 
-  bool Class_Selector::operator== (const Class_Selector& rhs) const
+  bool ClassSelector::operator== (const ClassSelector& rhs) const
   {
     // Class has no namespacing
     return name() == rhs.name();
   }
 
-  bool Parent_Selector::operator== (const Parent_Selector& rhs) const
-  {
-    // Parent has no namespacing
-    return name() == rhs.name();
-  }
-
-  bool Pseudo_Selector::operator== (const Pseudo_Selector& rhs) const
-  {
-    std::string lname = name();
-    std::string rname = rhs.name();
-    if (is_pseudo_class_element(lname)) {
-      if (rname[0] == ':' && rname[1] == ':') {
-        lname = lname.substr(1, std::string::npos);
-      }
-    }
-    // right hand is special pseudo (single colon)
-    if (is_pseudo_class_element(rname)) {
-      if (lname[0] == ':' && lname[1] == ':') {
-        lname = lname.substr(1, std::string::npos);
-      }
-    }
-    // Pseudo has no namespacing
-    if (lname != rname) return false;
-    String_Obj lhs_ex = expression();
-    String_Obj rhs_ex = rhs.expression();
-    if (rhs_ex && lhs_ex) return *lhs_ex == *rhs_ex;
-    else return lhs_ex.ptr() == rhs_ex.ptr();
-  }
-
-  bool Wrapped_Selector::operator== (const Wrapped_Selector& rhs) const
-  {
-    // Wrapped has no namespacing
-    if (name() != rhs.name()) return false;
-    return *(selector()) == *(rhs.selector());
-  }
-
-  bool Attribute_Selector::operator== (const Attribute_Selector& rhs) const
-  {
-    // get optional value state
-    bool no_lhs_val = value().isNull();
-    bool no_rhs_val = rhs.value().isNull();
-    // both are null, therefore equal
-    if (no_lhs_val && no_rhs_val) {
-      return (name() == rhs.name())
-        && (matcher() == rhs.matcher())
-        && (is_ns_eq(rhs));
-    }
-    // both are defined, evaluate
-    if (no_lhs_val == no_rhs_val) {
-      return (name() == rhs.name())
-        && (matcher() == rhs.matcher())
-        && (is_ns_eq(rhs))
-        && (*value() == *rhs.value());
-    }
-    // not equal
-    return false;
-  }
-
-  bool Placeholder_Selector::operator== (const Placeholder_Selector& rhs) const
+  bool PlaceholderSelector::operator== (const PlaceholderSelector& rhs) const
   {
     // Placeholder has no namespacing
     return name() == rhs.name();
   }
 
-  /*#########################################################################*/
-  /*#########################################################################*/
-
-  bool Simple_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    switch (simple_type()) {
-      case ID_SEL: return (const Id_Selector&) *this < rhs; break;
-      case TYPE_SEL: return (const Type_Selector&) *this < rhs; break;
-      case CLASS_SEL: return (const Class_Selector&) *this < rhs; break;
-      case PARENT_SEL: return (const Parent_Selector&) *this < rhs; break;
-      case PSEUDO_SEL: return (const Pseudo_Selector&) *this < rhs; break;
-      case WRAPPED_SEL: return (const Wrapped_Selector&) *this < rhs; break;
-      case ATTRIBUTE_SEL: return (const Attribute_Selector&) *this < rhs; break;
-      case PLACEHOLDER_SEL: return (const Placeholder_Selector&) *this < rhs; break;
-    }
-    return false;
-  }
-
-  /***************************************************************************/
-  /***************************************************************************/
-
-  bool Id_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    switch (rhs.simple_type()) {
-      case TYPE_SEL: return '#' < 's'; break;
-      case CLASS_SEL: return '#' < '.'; break;
-      case PARENT_SEL: return '#' < '&'; break;
-      case PSEUDO_SEL: return '#' < ':'; break;
-      case WRAPPED_SEL: return '#' < '('; break;
-      case ATTRIBUTE_SEL: return '#' < '['; break;
-      case PLACEHOLDER_SEL: return '#' < '%'; break;
-      case ID_SEL: /* let if fall through */ break;
-    }
-    const Id_Selector& sel =
-      (const Id_Selector&) rhs;
-    return *this < sel;
-  }
-
-  bool Type_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    switch (rhs.simple_type()) {
-      case ID_SEL: return 'e' < '#'; break;
-      case CLASS_SEL: return 'e' < '.'; break;
-      case PARENT_SEL: return 'e' < '&'; break;
-      case PSEUDO_SEL: return 'e' < ':'; break;
-      case WRAPPED_SEL: return 'e' < '('; break;
-      case ATTRIBUTE_SEL: return 'e' < '['; break;
-      case PLACEHOLDER_SEL: return 'e' < '%'; break;
-      case TYPE_SEL: /* let if fall through */ break;
-    }
-    const Type_Selector& sel =
-      (const Type_Selector&) rhs;
-    return *this < sel;
-  }
-
-  bool Class_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    switch (rhs.simple_type()) {
-      case ID_SEL: return '.' < '#'; break;
-      case TYPE_SEL: return '.' < 's'; break;
-      case PARENT_SEL: return '.' < '&'; break;
-      case PSEUDO_SEL: return '.' < ':'; break;
-      case WRAPPED_SEL: return '.' < '('; break;
-      case ATTRIBUTE_SEL: return '.' < '['; break;
-      case PLACEHOLDER_SEL: return '.' < '%'; break;
-      case CLASS_SEL: /* let if fall through */ break;
-    }
-    const Class_Selector& sel =
-      (const Class_Selector&) rhs;
-    return *this < sel;
-  }
-
-  bool Pseudo_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    switch (rhs.simple_type()) {
-      case ID_SEL: return ':' < '#'; break;
-      case TYPE_SEL: return ':' < 's'; break;
-      case CLASS_SEL: return ':' < '.'; break;
-      case PARENT_SEL: return ':' < '&'; break;
-      case WRAPPED_SEL: return ':' < '('; break;
-      case ATTRIBUTE_SEL: return ':' < '['; break;
-      case PLACEHOLDER_SEL: return ':' < '%'; break;
-      case PSEUDO_SEL: /* let if fall through */ break;
-    }
-    const Pseudo_Selector& sel =
-      (const Pseudo_Selector&) rhs;
-    return *this < sel;
-  }
-
-  bool Wrapped_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    switch (rhs.simple_type()) {
-      case ID_SEL: return '(' < '#'; break;
-      case TYPE_SEL: return '(' < 's'; break;
-      case CLASS_SEL: return '(' < '.'; break;
-      case PARENT_SEL: return '(' < '&'; break;
-      case PSEUDO_SEL: return '(' < ':'; break;
-      case ATTRIBUTE_SEL: return '(' < '['; break;
-      case PLACEHOLDER_SEL: return '(' < '%'; break;
-      case WRAPPED_SEL: /* let if fall through */ break;
-    }
-    const Wrapped_Selector& sel =
-      (const Wrapped_Selector&) rhs;
-    return *this < sel;
-  }
-
-  bool Parent_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    switch (rhs.simple_type()) {
-      case ID_SEL: return '&' < '#'; break;
-      case TYPE_SEL: return '&' < 's'; break;
-      case CLASS_SEL: return '&' < '.'; break;
-      case PSEUDO_SEL: return '&' < ':'; break;
-      case WRAPPED_SEL: return '&' < '('; break;
-      case ATTRIBUTE_SEL: return '&' < '['; break;
-      case PLACEHOLDER_SEL: return '&' < '%'; break;
-      case PARENT_SEL: /* let if fall through */ break;
-    }
-    const Parent_Selector& sel =
-      (const Parent_Selector&) rhs;
-    return *this < sel;
-  }
-
-  bool Attribute_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    switch (rhs.simple_type()) {
-      case ID_SEL: return '[' < '#'; break;
-      case TYPE_SEL: return '[' < 'e'; break;
-      case CLASS_SEL: return '[' < '.'; break;
-      case PARENT_SEL: return '[' < '&'; break;
-      case PSEUDO_SEL: return '[' < ':'; break;
-      case WRAPPED_SEL: return '[' < '('; break;
-      case PLACEHOLDER_SEL: return '[' < '%'; break;
-      case ATTRIBUTE_SEL: /* let if fall through */ break;
-    }
-    const Attribute_Selector& sel =
-      (const Attribute_Selector&) rhs;
-    return *this < sel;
-  }
-
-  bool Placeholder_Selector::operator< (const Simple_Selector& rhs) const
-  {
-    switch (rhs.simple_type()) {
-      case ID_SEL: return '%' < '#'; break;
-      case TYPE_SEL: return '%' < 's'; break;
-      case CLASS_SEL: return '%' < '.'; break;
-      case PARENT_SEL: return '%' < '&'; break;
-      case PSEUDO_SEL: return '%' < ':'; break;
-      case WRAPPED_SEL: return '%' < '('; break;
-      case ATTRIBUTE_SEL: return '%' < '['; break;
-      case PLACEHOLDER_SEL: /* let if fall through */ break;
-    }
-    const Placeholder_Selector& sel =
-      (const Placeholder_Selector&) rhs;
-    return *this < sel;
-  }
-
-  /***************************************************************************/
-  /***************************************************************************/
-
-  bool Id_Selector::operator< (const Id_Selector& rhs) const
-  {
-    // ID has no namespacing
-    return name() < rhs.name();
-  }
-
-  bool Type_Selector::operator< (const Type_Selector& rhs) const
-  {
-    return has_ns_ == rhs.has_ns_
-      ? (ns_ == rhs.ns_
-         ? name_ < rhs.name_
-         : ns_ < rhs.ns_)
-      : has_ns_ < rhs.has_ns_;
-  }
-
-  bool Class_Selector::operator< (const Class_Selector& rhs) const
+  bool AttributeSelector::operator== (const AttributeSelector& rhs) const
   {
-    // Class has no namespacing
-    return name() < rhs.name();
-  }
-
-  bool Parent_Selector::operator< (const Parent_Selector& rhs) const
-  {
-    // Parent has no namespacing
-    return name() < rhs.name();
-  }
-
-  bool Pseudo_Selector::operator< (const Pseudo_Selector& rhs) const
-  {
-    std::string lname = name();
-    std::string rname = rhs.name();
-    if (is_pseudo_class_element(lname)) {
-      if (rname[0] == ':' && rname[1] == ':') {
-        lname = lname.substr(1, std::string::npos);
-      }
-    }
-    // right hand is special pseudo (single colon)
-    if (is_pseudo_class_element(rname)) {
-      if (lname[0] == ':' && lname[1] == ':') {
-        lname = lname.substr(1, std::string::npos);
-      }
+    // smaller return, equal go on, bigger abort
+    if (is_ns_eq(rhs)) {
+      if (name() != rhs.name()) return false;
+      if (matcher() != rhs.matcher()) return false;
+      if (modifier() != rhs.modifier()) return false;
+      const String* lhs_val = value();
+      const String* rhs_val = rhs.value();
+      return PtrObjEquality()(lhs_val, rhs_val);
     }
-    // Peudo has no namespacing
-    if (lname != rname)
-    { return lname < rname; }
-    String_Obj lhs_ex = expression();
-    String_Obj rhs_ex = rhs.expression();
-    if (rhs_ex && lhs_ex) return *lhs_ex < *rhs_ex;
-    else return lhs_ex.ptr() < rhs_ex.ptr();
-  }
-
-  bool Wrapped_Selector::operator< (const Wrapped_Selector& rhs) const
-  {
-    // Wrapped has no namespacing
-    if (name() != rhs.name())
-    { return name() < rhs.name(); }
-    return *(selector()) < *(rhs.selector());
+    else { return false; }
   }
 
-  bool Attribute_Selector::operator< (const Attribute_Selector& rhs) const
+  bool PseudoSelector::operator== (const PseudoSelector& rhs) const
   {
     if (is_ns_eq(rhs)) {
-      if (name() != rhs.name())
-      { return name() < rhs.name(); }
-      if (matcher() != rhs.matcher())
-      { return matcher() < rhs.matcher(); }
-      bool no_lhs_val = value().isNull();
-      bool no_rhs_val = rhs.value().isNull();
-      if (no_lhs_val && no_rhs_val) return false; // equal
-      else if (no_lhs_val) return true; // lhs is null
-      else if (no_rhs_val) return false; // rhs is null
-      return *value() < *rhs.value(); // both are given
-    } else { return ns() < rhs.ns(); }
-  }
-
-  bool Placeholder_Selector::operator< (const Placeholder_Selector& rhs) const
-  {
-    // Placeholder has no namespacing
-    return name() < rhs.name();
+      if (name() != rhs.name()) return false;
+      if (isElement() != rhs.isElement()) return false;
+      const String* lhs_arg = argument();
+      const String* rhs_arg = rhs.argument();
+      if (!PtrObjEquality()(lhs_arg, rhs_arg)) return false;
+      const SelectorList* lhs_sel = selector();
+      const SelectorList* rhs_sel = rhs.selector();
+      return PtrObjEquality()(lhs_sel, rhs_sel);
+    }
+    else { return false; }
   }
 
   /*#########################################################################*/