sassc 2.2.1 → 2.3.0

data/ext/libsass/src/ast_selectors.cpp

@@ -1,21 +1,10 @@
+// sass.hpp must go before all system headers to get the
+// __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 "ast_selectors.hpp"
-#include <array>
-#include <set>
-#include <iomanip>
-#include <iostream>
-#include <algorithm>
-#include <functional>
-#include <cctype>
-#include <locale>
+#include "permutate.hpp"
+#include "util_string.hpp"
 
 namespace Sass {
 
@@ -24,31 +13,14 @@ namespace Sass {
 
   Selector::Selector(ParserState pstate)
   : Expression(pstate),
-    has_line_feed_(false),
-    has_line_break_(false),
-    is_optional_(false),
-    media_block_(0),
     hash_(0)
   { concrete_type(SELECTOR); }
 
   Selector::Selector(const Selector* ptr)
   : Expression(ptr),
-    has_line_feed_(ptr->has_line_feed_),
-    has_line_break_(ptr->has_line_break_),
-    is_optional_(ptr->is_optional_),
-    media_block_(ptr->media_block_),
     hash_(ptr->hash_)
   { concrete_type(SELECTOR); }
 
-  void Selector::set_media_block(Media_Block* mb)
-  {
-    media_block(mb);
-  }
-
-  bool Selector::has_parent_ref() const
-  {
-    return false;
-  }
 
   bool Selector::has_real_parent_ref() const
   {
@@ -62,14 +34,12 @@ namespace Sass {
   : AST_Node(pstate),
     contents_(c),
     connect_parent_(true),
-    media_block_(NULL),
     hash_(0)
   { }
   Selector_Schema::Selector_Schema(const Selector_Schema* ptr)
   : AST_Node(ptr),
     contents_(ptr->contents_),
     connect_parent_(ptr->connect_parent_),
-    media_block_(ptr->media_block_),
     hash_(ptr->hash_)
   { }
 
@@ -85,30 +55,21 @@ namespace Sass {
     return hash_;
   }
 
-  bool Selector_Schema::has_parent_ref() const
-  {
-    if (String_Schema_Obj schema = Cast<String_Schema>(contents())) {
-      if (schema->empty()) return false;
-      const auto& first = *schema->at(0);
-      return typeid(first) == typeid(Parent_Selector);
-    }
-    return false;
-  }
-
   bool Selector_Schema::has_real_parent_ref() const
   {
-    if (String_Schema_Obj schema = Cast<String_Schema>(contents())) {
-      if (schema->empty()) return false;
-      const auto& first = *schema->at(0);
-      return typeid(first) == typeid(Parent_Reference);
-    }
+    // Note: disabled since it does not seem to do anything?
+    // if (String_Schema_Obj schema = Cast<String_Schema>(contents())) {
+    // if (schema->empty()) return false;
+    // const auto first = schema->first();
+    // return Cast<Parent_Reference>(first);
+    // }
     return false;
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Simple_Selector::Simple_Selector(ParserState pstate, std::string n)
+  SimpleSelector::SimpleSelector(ParserState pstate, std::string n)
   : Selector(pstate), ns_(""), name_(n), has_ns_(false)
   {
     size_t pos = n.find('|');
@@ -119,127 +80,105 @@ namespace Sass {
       name_ = n.substr(pos + 1);
     }
   }
-  Simple_Selector::Simple_Selector(const Simple_Selector* ptr)
+  SimpleSelector::SimpleSelector(const SimpleSelector* ptr)
   : Selector(ptr),
     ns_(ptr->ns_),
     name_(ptr->name_),
     has_ns_(ptr->has_ns_)
   { }
 
-  std::string Simple_Selector::ns_name() const
+  std::string SimpleSelector::ns_name() const
   {
-    std::string name("");
-    if (has_ns_)
-      name += ns_ + "|";
-    return name + name_;
+    if (!has_ns_) return name_;
+    else return ns_ + "|" + name_;
   }
 
-  size_t Simple_Selector::hash() const
+  size_t SimpleSelector::hash() const
   {
     if (hash_ == 0) {
-      hash_combine(hash_, std::hash<int>()(SELECTOR));
-      hash_combine(hash_, std::hash<int>()(simple_type()));
-      if (!name_.empty()) hash_combine(hash_, std::hash<std::string>()(name()));
-      if (has_ns_) hash_combine(hash_, std::hash<std::string>()(ns()));
+      hash_combine(hash_, name());
+      hash_combine(hash_, (int)SELECTOR);
+      hash_combine(hash_, (int)simple_type());
+      if (has_ns_) hash_combine(hash_, ns());
     }
     return hash_;
   }
 
-  bool Simple_Selector::empty() const {
+  bool SimpleSelector::empty() const {
     return ns().empty() && name().empty();
   }
 
   // namespace compare functions
-  bool Simple_Selector::is_ns_eq(const Simple_Selector& r) const
+  bool SimpleSelector::is_ns_eq(const SimpleSelector& r) const
   {
     return has_ns_ == r.has_ns_ && ns_ == r.ns_;
   }
 
   // namespace query functions
-  bool Simple_Selector::is_universal_ns() const
+  bool SimpleSelector::is_universal_ns() const
   {
     return has_ns_ && ns_ == "*";
   }
 
-  bool Simple_Selector::is_empty_ns() const
+  bool SimpleSelector::is_empty_ns() const
   {
     return !has_ns_ || ns_ == "";
   }
 
-  bool Simple_Selector::has_empty_ns() const
+  bool SimpleSelector::has_empty_ns() const
   {
     return has_ns_ && ns_ == "";
   }
 
-  bool Simple_Selector::has_qualified_ns() const
+  bool SimpleSelector::has_qualified_ns() const
   {
     return has_ns_ && ns_ != "" && ns_ != "*";
   }
 
   // name query functions
-  bool Simple_Selector::is_universal() const
+  bool SimpleSelector::is_universal() const
   {
     return name_ == "*";
   }
 
-  bool Simple_Selector::has_placeholder()
+  bool SimpleSelector::has_placeholder()
   {
     return false;
   }
 
-  bool Simple_Selector::has_parent_ref() const
-  {
-    return false;
-  };
-
-  bool Simple_Selector::has_real_parent_ref() const
+  bool SimpleSelector::has_real_parent_ref() const
   {
     return false;
   };
 
-  bool Simple_Selector::is_pseudo_element() const
+  bool SimpleSelector::is_pseudo_element() const
   {
     return false;
   }
 
-  bool Simple_Selector::is_superselector_of(const Compound_Selector* sub) const
+  CompoundSelectorObj SimpleSelector::wrapInCompound()
   {
-    return false;
+    CompoundSelectorObj selector =
+      SASS_MEMORY_NEW(CompoundSelector, pstate());
+    selector->append(this);
+    return selector;
   }
-
-  /////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////
-
-  Parent_Selector::Parent_Selector(ParserState pstate, bool r)
-  : Simple_Selector(pstate, "&"), real_(r)
-  { simple_type(PARENT_SEL); }
-  Parent_Selector::Parent_Selector(const Parent_Selector* ptr)
-  : Simple_Selector(ptr), real_(ptr->real_)
-  { simple_type(PARENT_SEL); }
-
-  bool Parent_Selector::has_parent_ref() const
-  {
-    return true;
-  };
-
-  bool Parent_Selector::has_real_parent_ref() const
+  ComplexSelectorObj SimpleSelector::wrapInComplex()
   {
-    return real();
-  };
-
-  unsigned long Parent_Selector::specificity() const
-  {
-    return 0;
+    ComplexSelectorObj selector =
+      SASS_MEMORY_NEW(ComplexSelector, pstate());
+    selector->append(wrapInCompound());
+    return selector;
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
   Placeholder_Selector::Placeholder_Selector(ParserState pstate, std::string n)
-  : Simple_Selector(pstate, n)
+  : SimpleSelector(pstate, n)
   { simple_type(PLACEHOLDER_SEL); }
   Placeholder_Selector::Placeholder_Selector(const Placeholder_Selector* ptr)
-  : Simple_Selector(ptr)
+  : SimpleSelector(ptr)
   { simple_type(PLACEHOLDER_SEL); }
   unsigned long Placeholder_Selector::specificity() const
   {
@@ -253,10 +192,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Type_Selector::Type_Selector(ParserState pstate, std::string n)
-  : Simple_Selector(pstate, n)
+  : SimpleSelector(pstate, n)
   { simple_type(TYPE_SEL); }
   Type_Selector::Type_Selector(const Type_Selector* ptr)
-  : Simple_Selector(ptr)
+  : SimpleSelector(ptr)
   { simple_type(TYPE_SEL); }
 
   unsigned long Type_Selector::specificity() const
@@ -269,10 +208,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Class_Selector::Class_Selector(ParserState pstate, std::string n)
-  : Simple_Selector(pstate, n)
+  : SimpleSelector(pstate, n)
   { simple_type(CLASS_SEL); }
   Class_Selector::Class_Selector(const Class_Selector* ptr)
-  : Simple_Selector(ptr)
+  : SimpleSelector(ptr)
   { simple_type(CLASS_SEL); }
 
   unsigned long Class_Selector::specificity() const
@@ -284,10 +223,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Id_Selector::Id_Selector(ParserState pstate, std::string n)
-  : Simple_Selector(pstate, n)
+  : SimpleSelector(pstate, n)
   { simple_type(ID_SEL); }
   Id_Selector::Id_Selector(const Id_Selector* ptr)
-  : Simple_Selector(ptr)
+  : SimpleSelector(ptr)
   { simple_type(ID_SEL); }
 
   unsigned long Id_Selector::specificity() const
@@ -299,10 +238,10 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
 
   Attribute_Selector::Attribute_Selector(ParserState pstate, std::string n, std::string m, String_Obj v, char o)
-  : Simple_Selector(pstate, n), matcher_(m), value_(v), modifier_(o)
+  : SimpleSelector(pstate, n), matcher_(m), value_(v), modifier_(o)
   { simple_type(ATTRIBUTE_SEL); }
   Attribute_Selector::Attribute_Selector(const Attribute_Selector* ptr)
-  : Simple_Selector(ptr),
+  : SimpleSelector(ptr),
     matcher_(ptr->matcher_),
     value_(ptr->value_),
     modifier_(ptr->modifier_)
@@ -311,7 +250,7 @@ namespace Sass {
   size_t Attribute_Selector::hash() const
   {
     if (hash_ == 0) {
-      hash_combine(hash_, Simple_Selector::hash());
+      hash_combine(hash_, SimpleSelector::hash());
       hash_combine(hash_, std::hash<std::string>()(matcher()));
       if (value_) hash_combine(hash_, value_->hash());
     }
@@ -326,11 +265,21 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Pseudo_Selector::Pseudo_Selector(ParserState pstate, std::string n, String_Obj expr)
-  : Simple_Selector(pstate, n), expression_(expr)
+  Pseudo_Selector::Pseudo_Selector(ParserState pstate, std::string name, bool element)
+  : SimpleSelector(pstate, name),
+    normalized_(Util::unvendor(name)),
+    argument_({}),
+    selector_({}),
+    isSyntacticClass_(!element),
+    isClass_(!element && !isFakePseudoElement(normalized_))
   { simple_type(PSEUDO_SEL); }
   Pseudo_Selector::Pseudo_Selector(const Pseudo_Selector* ptr)
-  : Simple_Selector(ptr), expression_(ptr->expression_)
+  : SimpleSelector(ptr),
+    normalized_(ptr->normalized()),
+    argument_(ptr->argument()),
+    selector_(ptr->selector()),
+    isSyntacticClass_(ptr->isSyntacticClass()),
+    isClass_(ptr->isClass())
   { simple_type(PSEUDO_SEL); }
 
   // A pseudo-element is made of two colons (::) followed by the name.
@@ -343,15 +292,15 @@ namespace Sass {
   // introduced in this specification.
   bool Pseudo_Selector::is_pseudo_element() const
   {
-    return (name_[0] == ':' && name_[1] == ':')
-            || is_pseudo_class_element(name_);
+    return isElement();
   }
 
   size_t Pseudo_Selector::hash() const
   {
     if (hash_ == 0) {
-      hash_combine(hash_, Simple_Selector::hash());
-      if (expression_) hash_combine(hash_, expression_->hash());
+      hash_combine(hash_, SimpleSelector::hash());
+      if (selector_) hash_combine(hash_, selector_->hash());
+      if (argument_) hash_combine(hash_, argument_->hash());
     }
     return hash_;
   }
@@ -363,1097 +312,707 @@ namespace Sass {
     return Constants::Specificity_Pseudo;
   }
 
-  /////////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////////
-
-  Wrapped_Selector::Wrapped_Selector(ParserState pstate, std::string n, Selector_List_Obj sel)
-  : Simple_Selector(pstate, n), selector_(sel)
-  { simple_type(WRAPPED_SEL); }
-  Wrapped_Selector::Wrapped_Selector(const Wrapped_Selector* ptr)
-  : Simple_Selector(ptr), selector_(ptr->selector_)
-  { simple_type(WRAPPED_SEL); }
-
-  bool Wrapped_Selector::is_superselector_of(const Wrapped_Selector* sub) const
+  Pseudo_Selector_Obj Pseudo_Selector::withSelector(SelectorListObj selector)
   {
-    if (this->name() != sub->name()) return false;
-    if (this->name() == ":current") return false;
-    if (Selector_List_Obj rhs_list = Cast<Selector_List>(sub->selector())) {
-      if (Selector_List_Obj lhs_list = Cast<Selector_List>(selector())) {
-        return lhs_list->is_superselector_of(rhs_list);
-      }
-    }
-    coreError("is_superselector expected a Selector_List", sub->pstate());
-    return false;
+    Pseudo_Selector_Obj pseudo = SASS_MEMORY_COPY(this);
+    pseudo->selector(selector);
+    return pseudo;
   }
 
-  // Selectors inside the negation pseudo-class are counted like any
-  // other, but the negation itself does not count as a pseudo-class.
-
-  void Wrapped_Selector::cloneChildren()
+  bool Pseudo_Selector::empty() const
   {
-    selector(SASS_MEMORY_CLONE(selector()));
+    // Only considered empty if selector is
+    // available but has no items in it.
+    return selector() && selector()->empty();
   }
 
-  size_t Wrapped_Selector::hash() const
+  void Pseudo_Selector::cloneChildren()
   {
-    if (hash_ == 0) {
-      hash_combine(hash_, Simple_Selector::hash());
-      if (selector_) hash_combine(hash_, selector_->hash());
-    }
-    return hash_;
-  }
-
-  bool Wrapped_Selector::has_parent_ref() const {
-    if (!selector()) return false;
-    return selector()->has_parent_ref();
+    if (selector().isNull()) selector({});
+    else selector(SASS_MEMORY_CLONE(selector()));
   }
 
-  bool Wrapped_Selector::has_real_parent_ref() const {
+  bool Pseudo_Selector::has_real_parent_ref() const {
     if (!selector()) return false;
     return selector()->has_real_parent_ref();
   }
 
-  unsigned long Wrapped_Selector::specificity() const
-  {
-    return selector_ ? selector_->specificity() : 0;
-  }
-
-  bool Wrapped_Selector::find ( bool (*f)(AST_Node_Obj) )
-  {
-    // check children first
-    if (selector_) {
-      if (selector_->find(f)) return true;
-    }
-    // execute last
-    return f(this);
-  }
-
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Compound_Selector::Compound_Selector(ParserState pstate, size_t s)
+  SelectorList::SelectorList(ParserState pstate, size_t s)
   : Selector(pstate),
-    Vectorized<Simple_Selector_Obj>(s),
-    extended_(false),
-    has_parent_reference_(false)
+    Vectorized<ComplexSelectorObj>(s),
+    is_optional_(false)
   { }
-
-  Compound_Selector::Compound_Selector(const Compound_Selector* ptr)
-  : Selector(ptr),
-    Vectorized<Simple_Selector_Obj>(*ptr),
-    extended_(ptr->extended_),
-    has_parent_reference_(ptr->has_parent_reference_)
+  SelectorList::SelectorList(const SelectorList* ptr)
+    : Selector(ptr),
+    Vectorized<ComplexSelectorObj>(*ptr),
+    is_optional_(ptr->is_optional_)
   { }
 
-  bool Compound_Selector::contains_placeholder() {
-    for (size_t i = 0, L = length(); i < L; ++i) {
-      if ((*this)[i]->has_placeholder()) return true;
-    }
-    return false;
-  };
-
-  void Compound_Selector::cloneChildren()
+  size_t SelectorList::hash() const
   {
-    for (size_t i = 0, l = length(); i < l; i++) {
-      at(i) = SASS_MEMORY_CLONE(at(i));
+    if (Selector::hash_ == 0) {
+      hash_combine(Selector::hash_, Vectorized::hash());
     }
+    return Selector::hash_;
   }
 
-  bool Compound_Selector::find ( bool (*f)(AST_Node_Obj) )
+  bool SelectorList::has_real_parent_ref() const
   {
-    // check children first
-    for (Simple_Selector_Obj sel : elements()) {
-      if (sel->find(f)) return true;
+    for (ComplexSelectorObj s : elements()) {
+      if (s && s->has_real_parent_ref()) return true;
     }
-    // execute last
-    return f(this);
+    return false;
   }
 
-  bool Compound_Selector::has_parent_ref() const
+  void SelectorList::cloneChildren()
   {
-    for (Simple_Selector_Obj s : *this) {
-      if (s && s->has_parent_ref()) return true;
+    for (size_t i = 0, l = length(); i < l; i++) {
+      at(i) = SASS_MEMORY_CLONE(at(i));
     }
-    return false;
   }
 
-  bool Compound_Selector::has_real_parent_ref() const
+  unsigned long SelectorList::specificity() const
   {
-    for (Simple_Selector_Obj s : *this) {
-      if (s && s->has_real_parent_ref()) return true;
-    }
-    return false;
+    return 0;
   }
 
-  bool Compound_Selector::is_superselector_of(const Selector_List* rhs, std::string wrapped) const
+  bool SelectorList::isInvisible() const
   {
-    for (Complex_Selector_Obj item : rhs->elements()) {
-      if (is_superselector_of(item, wrapped)) return true;
+    if (length() == 0) return true;
+    for (size_t i = 0; i < length(); i += 1) {
+      if (get(i)->isInvisible()) return true;
     }
     return false;
   }
 
-  bool Compound_Selector::is_superselector_of(const Complex_Selector* rhs, std::string wrapped) const
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  ComplexSelector::ComplexSelector(ParserState pstate)
+  : Selector(pstate),
+    Vectorized<SelectorComponentObj>(),
+    chroots_(false),
+    hasPreLineFeed_(false)
   {
-    if (rhs->head()) return is_superselector_of(rhs->head(), wrapped);
-    return false;
   }
-
-  bool Compound_Selector::is_superselector_of(const Compound_Selector* rhs, std::string wrapping) const
+  ComplexSelector::ComplexSelector(const ComplexSelector* ptr)
+  : Selector(ptr),
+    Vectorized<SelectorComponentObj>(ptr->elements()),
+    chroots_(ptr->chroots()),
+    hasPreLineFeed_(ptr->hasPreLineFeed())
   {
-    // Check if pseudo-elements are the same between the selectors
-    {
-      std::array<std::set<std::string>, 2> pseudosets;
-      std::array<const Compound_Selector*, 2> compounds = {{this, rhs}};
-      for (int i = 0; i < 2; ++i) {
-        for (const Simple_Selector_Obj& el : compounds[i]->elements()) {
-          if (el->is_pseudo_element()) {
-            std::string pseudo(el->to_string());
-            // strip off colons to ensure :after matches ::after since ruby sass is forgiving
-            pseudosets[i].insert(pseudo.substr(pseudo.find_first_not_of(":")));
-          }
-        }
-      }
-      if (pseudosets[0] != pseudosets[1]) return false;
-    }
-
-    {
-      const Simple_Selector* lbase = this->base();
-      const Simple_Selector* rbase = rhs->base();
-      if (lbase && rbase) {
-        return *lbase == *rbase &&
-               contains_all(std::unordered_set<const Simple_Selector*, HashPtr, ComparePtrs>(rhs->begin(), rhs->end()),
-                            std::unordered_set<const Simple_Selector*, HashPtr, ComparePtrs>(this->begin(), this->end()));
-      }
-    }
-
-    std::unordered_set<const Selector*, HashPtr, ComparePtrs> lset;
-    for (size_t i = 0, iL = length(); i < iL; ++i)
-    {
-      const Selector* wlhs = (*this)[i].ptr();
-      // very special case for wrapped matches selector
-      if (const Wrapped_Selector* wrapped = Cast<Wrapped_Selector>(wlhs)) {
-        if (wrapped->name() == ":not") {
-          if (Selector_List_Obj not_list = Cast<Selector_List>(wrapped->selector())) {
-            if (not_list->is_superselector_of(rhs, wrapped->name())) return false;
-          } else {
-            throw std::runtime_error("wrapped not selector is not a list");
-          }
-        }
-        if (wrapped->name() == ":matches" || wrapped->name() == ":-moz-any") {
-          wlhs = wrapped->selector();
-          if (Selector_List_Obj list = Cast<Selector_List>(wrapped->selector())) {
-            if (const Compound_Selector* comp = Cast<Compound_Selector>(rhs)) {
-              if (!wrapping.empty() && wrapping != wrapped->name()) return false;
-              if (wrapping.empty() || wrapping != wrapped->name()) {;
-                if (list->is_superselector_of(comp, wrapped->name())) return true;
-              }
-            }
-          }
-        }
-        Simple_Selector* rhs_sel = nullptr;
-        if (rhs->elements().size() > i) rhs_sel = (*rhs)[i];
-        if (Wrapped_Selector* wrapped_r = Cast<Wrapped_Selector>(rhs_sel)) {
-          if (wrapped->name() == wrapped_r->name()) {
-          if (wrapped->is_superselector_of(wrapped_r)) {
-             continue;
-          }}
-        }
-      }
-      lset.insert(wlhs);
-    }
+  }
 
-    if (lset.empty()) return true;
-
-    std::unordered_set<const Selector*, HashPtr, ComparePtrs> rset;
-    for (size_t n = 0, nL = rhs->length(); n < nL; ++n)
-    {
-      Selector_Obj r = (*rhs)[n];
-      if (Wrapped_Selector_Obj wrapped = Cast<Wrapped_Selector>(r)) {
-        if (wrapped->name() == ":not") {
-          if (Selector_List_Obj ls = Cast<Selector_List>(wrapped->selector())) {
-            ls->remove_parent_selectors(); // unverified
-            if (is_superselector_of(ls, wrapped->name())) return false;
-          }
-        }
-        if (wrapped->name() == ":matches" || wrapped->name() == ":-moz-any") {
-          if (!wrapping.empty()) {
-            if (wrapping != wrapped->name()) return false;
-          }
-          if (Selector_List_Obj ls = Cast<Selector_List>(wrapped->selector())) {
-            ls->remove_parent_selectors(); // unverified
-            return (is_superselector_of(ls, wrapped->name()));
-          }
-        }
-      }
-      rset.insert(r);
+  void ComplexSelector::cloneChildren()
+  {
+    for (size_t i = 0, l = length(); i < l; i++) {
+      at(i) = SASS_MEMORY_CLONE(at(i));
     }
-
-    return contains_all(rset, lset);
   }
 
-  bool Compound_Selector::is_universal() const
+  unsigned long ComplexSelector::specificity() const
   {
-    return length() == 1 && (*this)[0]->is_universal();
+    int sum = 0;
+    for (auto component : elements()) {
+      sum += component->specificity();
+    }
+    return sum;
   }
 
-  // create complex selector (ancestor of) from compound selector
-  Complex_Selector_Obj Compound_Selector::to_complex()
+  bool ComplexSelector::isInvisible() const
   {
-    // create an intermediate complex selector
-    return SASS_MEMORY_NEW(Complex_Selector,
-                           pstate(),
-                           Complex_Selector::ANCESTOR_OF,
-                           this,
-                           {});
+    if (length() == 0) return true;
+    for (size_t i = 0; i < length(); i += 1) {
+      if (CompoundSelectorObj compound = get(i)->getCompound()) {
+        if (compound->isInvisible()) return true;
+      }
+    }
+    return false;
   }
 
-  Simple_Selector* Compound_Selector::base() const {
-    if (length() == 0) return 0;
-    // ToDo: why is this needed?
-    if (Cast<Type_Selector>((*this)[0]))
-      return (*this)[0];
-    return 0;
+  SelectorListObj ComplexSelector::wrapInList()
+  {
+    SelectorListObj selector =
+      SASS_MEMORY_NEW(SelectorList, pstate());
+    selector->append(this);
+    return selector;
   }
 
-  size_t Compound_Selector::hash() const
+  size_t ComplexSelector::hash() const
   {
     if (Selector::hash_ == 0) {
-      hash_combine(Selector::hash_, std::hash<int>()(SELECTOR));
-      if (length()) hash_combine(Selector::hash_, Vectorized::hash());
+      hash_combine(Selector::hash_, Vectorized::hash());
+      // ToDo: this breaks some extend lookup
+      // hash_combine(Selector::hash_, chroots_);
     }
     return Selector::hash_;
   }
 
-  unsigned long Compound_Selector::specificity() const
-  {
-    int sum = 0;
-    for (size_t i = 0, L = length(); i < L; ++i)
-    { sum += (*this)[i]->specificity(); }
-    return sum;
+  bool ComplexSelector::has_placeholder() const {
+    for (size_t i = 0, L = length(); i < L; ++i) {
+      if (get(i)->has_placeholder()) return true;
+    }
+    return false;
   }
 
-  bool Compound_Selector::has_placeholder()
+  bool ComplexSelector::has_real_parent_ref() const
   {
-    if (length() == 0) return false;
-    if (Simple_Selector_Obj ss = elements().front()) {
-      if (ss->has_placeholder()) return true;
+    for (auto item : elements()) {
+      if (item->has_real_parent_ref()) return true;
     }
     return false;
   }
 
-  bool Compound_Selector::is_empty_reference()
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  SelectorComponent::SelectorComponent(ParserState pstate, bool postLineBreak)
+  : Selector(pstate),
+    hasPostLineBreak_(postLineBreak)
   {
-    return length() == 1 &&
-            Cast<Parent_Selector>((*this)[0]);
   }
 
-  void Compound_Selector::append(Simple_Selector_Obj element)
+  SelectorComponent::SelectorComponent(const SelectorComponent* ptr)
+  : Selector(ptr),
+    hasPostLineBreak_(ptr->hasPostLineBreak())
+  { }
+
+  void SelectorComponent::cloneChildren()
   {
-    Vectorized<Simple_Selector_Obj>::append(element);
-    pstate_.offset += element->pstate().offset;
   }
 
-  Compound_Selector* Compound_Selector::minus(Compound_Selector* rhs)
+  unsigned long SelectorComponent::specificity() const
   {
-    Compound_Selector* result = SASS_MEMORY_NEW(Compound_Selector, pstate());
-    // result->has_parent_reference(has_parent_reference());
-
-    // not very efficient because it needs to preserve order
-    for (size_t i = 0, L = length(); i < L; ++i)
-    {
-      bool found = false;
-      for (size_t j = 0, M = rhs->length(); j < M; ++j)
-      {
-        if (*get(i) == *rhs->get(j))
-        {
-          found = true;
-          break;
-        }
-      }
-      if (!found) result->append(get(i));
-    }
-
-    return result;
+    return 0;
   }
 
-  void Compound_Selector::mergeSources(ComplexSelectorSet& sources)
+  // Wrap the compound selector with a complex selector
+  ComplexSelector* SelectorComponent::wrapInComplex()
   {
-    for (ComplexSelectorSet::iterator iterator = sources.begin(), endIterator = sources.end(); iterator != endIterator; ++iterator) {
-      this->sources_.insert(SASS_MEMORY_CLONE(*iterator));
-    }
+    auto complex = SASS_MEMORY_NEW(ComplexSelector, pstate());
+    complex->append(this);
+    return complex;
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Complex_Selector::Complex_Selector(ParserState pstate,
-                    Combinator c,
-                    Compound_Selector_Obj h,
-                    Complex_Selector_Obj t,
-                    String_Obj r)
-  : Selector(pstate),
-    combinator_(c),
-    head_(h), tail_(t),
-    reference_(r)
-  {}
-  Complex_Selector::Complex_Selector(const Complex_Selector* ptr)
-  : Selector(ptr),
-    combinator_(ptr->combinator_),
-    head_(ptr->head_), tail_(ptr->tail_),
-    reference_(ptr->reference_)
-  {}
-
-  bool Complex_Selector::empty() const {
-    return (!tail() || tail()->empty())
-      && (!head() || head()->empty())
-      && combinator_ == ANCESTOR_OF;
-  }
-
-  Complex_Selector_Obj Complex_Selector::skip_empty_reference()
-  {
-    if ((!head_ || !head_->length() || head_->is_empty_reference()) &&
-        combinator() == Combinator::ANCESTOR_OF)
-    {
-      if (!tail_) return {};
-      tail_->has_line_feed_ = this->has_line_feed_;
-      // tail_->has_line_break_ = this->has_line_break_;
-      return tail_->skip_empty_reference();
-    }
-    return this;
+  SelectorCombinator::SelectorCombinator(ParserState pstate, SelectorCombinator::Combinator combinator, bool postLineBreak)
+    : SelectorComponent(pstate, postLineBreak),
+    combinator_(combinator)
+  {
   }
+  SelectorCombinator::SelectorCombinator(const SelectorCombinator* ptr)
+    : SelectorComponent(ptr->pstate(), false),
+      combinator_(ptr->combinator())
+  { }
 
-  bool Complex_Selector::is_empty_ancestor() const
+  void SelectorCombinator::cloneChildren()
   {
-    return (!head() || head()->length() == 0) &&
-            combinator() == Combinator::ANCESTOR_OF;
   }
 
-  size_t Complex_Selector::hash() const
+  unsigned long SelectorCombinator::specificity() const
   {
-    if (hash_ == 0) {
-      if (head_) {
-        hash_combine(hash_, head_->hash());
-      } else {
-        hash_combine(hash_, std::hash<int>()(SELECTOR));
-      }
-      if (tail_) hash_combine(hash_, tail_->hash());
-      if (combinator_ != ANCESTOR_OF) hash_combine(hash_, std::hash<int>()(combinator_));
-    }
-    return hash_;
+    return 0;
   }
 
-  unsigned long Complex_Selector::specificity() const
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  CompoundSelector::CompoundSelector(ParserState pstate, bool postLineBreak)
+    : SelectorComponent(pstate, postLineBreak),
+      Vectorized<SimpleSelectorObj>(),
+      hasRealParent_(false),
+      extended_(false)
   {
-    int sum = 0;
-    if (head()) sum += head()->specificity();
-    if (tail()) sum += tail()->specificity();
-    return sum;
   }
+  CompoundSelector::CompoundSelector(const CompoundSelector* ptr)
+    : SelectorComponent(ptr),
+      Vectorized<SimpleSelectorObj>(*ptr),
+      hasRealParent_(ptr->hasRealParent()),
+      extended_(ptr->extended())
+  { }
 
-  void Complex_Selector::set_media_block(Media_Block* mb) {
-    media_block(mb);
-    if (tail_) tail_->set_media_block(mb);
-    if (head_) head_->set_media_block(mb);
+  size_t CompoundSelector::hash() const
+  {
+    if (Selector::hash_ == 0) {
+      hash_combine(Selector::hash_, Vectorized::hash());
+      hash_combine(Selector::hash_, hasRealParent_);
+    }
+    return Selector::hash_;
   }
 
-  bool Complex_Selector::has_placeholder() {
-    if (head_ && head_->has_placeholder()) return true;
-    if (tail_ && tail_->has_placeholder()) return true;
+  bool CompoundSelector::has_real_parent_ref() const
+  {
+    if (hasRealParent()) return true;
+    // ToDo: dart sass has another check?
+    // if (Cast<Type_Selector>(front)) {
+    //  if (front->ns() != "") return false;
+    // }
+    for (const SimpleSelector* s : elements()) {
+      if (s && s->has_real_parent_ref()) return true;
+    }
     return false;
   }
 
-  const ComplexSelectorSet Complex_Selector::sources()
+  bool CompoundSelector::has_placeholder() const
   {
-    //s = Set.new
-    //seq.map {|sseq_or_op| s.merge sseq_or_op.sources if sseq_or_op.is_a?(SimpleSequence)}
-    //s
-
-    ComplexSelectorSet srcs;
-
-    Compound_Selector_Obj pHead = head();
-    Complex_Selector_Obj  pTail = tail();
-
-    if (pHead) {
-      const ComplexSelectorSet& headSources = pHead->sources();
-      srcs.insert(headSources.begin(), headSources.end());
-    }
-
-    if (pTail) {
-      const ComplexSelectorSet& tailSources = pTail->sources();
-      srcs.insert(tailSources.begin(), tailSources.end());
+    if (length() == 0) return false;
+    for (SimpleSelectorObj ss : elements()) {
+      if (ss->has_placeholder()) return true;
     }
-
-    return srcs;
+    return false;
   }
 
-  void Complex_Selector::addSources(ComplexSelectorSet& sources)
+  void CompoundSelector::cloneChildren()
   {
-    // members.map! {|m| m.is_a?(SimpleSequence) ? m.with_more_sources(sources) : m}
-    Complex_Selector* pIter = this;
-    while (pIter) {
-      Compound_Selector* pHead = pIter->head();
-
-      if (pHead) {
-        pHead->mergeSources(sources);
-      }
-
-      pIter = pIter->tail();
+    for (size_t i = 0, l = length(); i < l; i++) {
+      at(i) = SASS_MEMORY_CLONE(at(i));
     }
   }
 
-  void Complex_Selector::clearSources()
+  unsigned long CompoundSelector::specificity() const
   {
-    Complex_Selector* pIter = this;
-    while (pIter) {
-      Compound_Selector* pHead = pIter->head();
-
-      if (pHead) {
-        pHead->clearSources();
-      }
+    int sum = 0;
+    for (size_t i = 0, L = length(); i < L; ++i)
+    { sum += get(i)->specificity(); }
+    return sum;
+  }
 
-      pIter = pIter->tail();
+  bool CompoundSelector::isInvisible() const
+  {
+    for (size_t i = 0; i < length(); i += 1) {
+      if (!get(i)->isInvisible()) return false;
     }
+    return true;
   }
 
-  bool Complex_Selector::find ( bool (*f)(AST_Node_Obj) )
+  bool CompoundSelector::isSuperselectorOf(const CompoundSelector* sub, std::string wrapped) const
   {
-    // check children first
-    if (head_ && head_->find(f)) return true;
-    if (tail_ && tail_->find(f)) return true;
-    // execute last
-    return f(this);
+    CompoundSelector* rhs2 = const_cast<CompoundSelector*>(sub);
+    CompoundSelector* lhs2 = const_cast<CompoundSelector*>(this);
+    return compoundIsSuperselector(lhs2, rhs2, {});
   }
 
-  bool Complex_Selector::has_parent_ref() const
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  MediaRule::MediaRule(ParserState pstate, Block_Obj block) :
+    Has_Block(pstate, block),
+    schema_({})
   {
-    return (head() && head()->has_parent_ref()) ||
-           (tail() && tail()->has_parent_ref());
+    statement_type(MEDIA);
   }
 
-  bool Complex_Selector::has_real_parent_ref() const
+  MediaRule::MediaRule(const MediaRule* ptr) :
+    Has_Block(ptr),
+    schema_(ptr->schema_)
   {
-    return (head() && head()->has_real_parent_ref()) ||
-           (tail() && tail()->has_real_parent_ref());
+    statement_type(MEDIA);
   }
 
-  bool Complex_Selector::is_superselector_of(const Compound_Selector* rhs, std::string wrapping) const
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
+
+  CssMediaRule::CssMediaRule(ParserState pstate, Block_Obj block) :
+    Has_Block(pstate, block),
+    Vectorized()
   {
-    return last()->head() && last()->head()->is_superselector_of(rhs, wrapping);
+    statement_type(MEDIA);
   }
 
-  bool Complex_Selector::is_superselector_of(const Complex_Selector* rhs, std::string wrapping) const
+  CssMediaRule::CssMediaRule(const CssMediaRule* ptr) :
+    Has_Block(ptr),
+    Vectorized(*ptr)
   {
-    const Complex_Selector* lhs = this;
-    // check for selectors with leading or trailing combinators
-    if (!lhs->head() || !rhs->head())
-    { return false; }
-    const Complex_Selector* l_innermost = lhs->last();
-    if (l_innermost->combinator() != Complex_Selector::ANCESTOR_OF)
-    { return false; }
-    const Complex_Selector* r_innermost = rhs->last();
-    if (r_innermost->combinator() != Complex_Selector::ANCESTOR_OF)
-    { return false; }
-    // more complex (i.e., longer) selectors are always more specific
-    size_t l_len = lhs->length(), r_len = rhs->length();
-    if (l_len > r_len)
-    { return false; }
-
-    if (l_len == 1)
-    { return lhs->head()->is_superselector_of(rhs->last()->head(), wrapping); }
-
-    // we have to look one tail deeper, since we cary the
-    // combinator around for it (which is important here)
-    if (rhs->tail() && lhs->tail() && combinator() != Complex_Selector::ANCESTOR_OF) {
-      Complex_Selector_Obj lhs_tail = lhs->tail();
-      Complex_Selector_Obj rhs_tail = rhs->tail();
-      if (lhs_tail->combinator() != rhs_tail->combinator()) return false;
-      if (lhs_tail->head() && !rhs_tail->head()) return false;
-      if (!lhs_tail->head() && rhs_tail->head()) return false;
-      if (lhs_tail->head() && rhs_tail->head()) {
-        if (!lhs_tail->head()->is_superselector_of(rhs_tail->head())) return false;
-      }
-    }
+    statement_type(MEDIA);
+  }
 
-    bool found = false;
-    const Complex_Selector* marker = rhs;
-    for (size_t i = 0, L = rhs->length(); i < L; ++i) {
-      if (i == L-1)
-      { return false; }
-      if (lhs->head() && marker->head() && lhs->head()->is_superselector_of(marker->head(), wrapping))
-      { found = true; break; }
-      marker = marker->tail();
-    }
-    if (!found)
-    { return false; }
-
-    /*
-      Hmm, I hope I have the logic right:
-
-      if lhs has a combinator:
-        if !(marker has a combinator) return false
-        if !(lhs.combinator == '~' ? marker.combinator != '>' : lhs.combinator == marker.combinator) return false
-        return lhs.tail-without-innermost.is_superselector_of(marker.tail-without-innermost)
-      else if marker has a combinator:
-        if !(marker.combinator == ">") return false
-        return lhs.tail.is_superselector_of(marker.tail)
-      else
-        return lhs.tail.is_superselector_of(marker.tail)
-    */
-    if (lhs->combinator() != Complex_Selector::ANCESTOR_OF)
-    {
-      if (marker->combinator() == Complex_Selector::ANCESTOR_OF)
-      { return false; }
-      if (!(lhs->combinator() == Complex_Selector::PRECEDES ? marker->combinator() != Complex_Selector::PARENT_OF : lhs->combinator() == marker->combinator()))
-      { return false; }
-      return lhs->tail()->is_superselector_of(marker->tail());
-    }
-    else if (marker->combinator() != Complex_Selector::ANCESTOR_OF)
-    {
-      if (marker->combinator() != Complex_Selector::PARENT_OF)
-      { return false; }
-      return lhs->tail()->is_superselector_of(marker->tail());
-    }
-    return lhs->tail()->is_superselector_of(marker->tail());
-  }
-
-  size_t Complex_Selector::length() const
-  {
-    // TODO: make this iterative
-    if (!tail()) return 1;
-    return 1 + tail()->length();
-  }
-
-  // append another complex selector at the end
-  // check if we need to append some headers
-  // then we need to check for the combinator
-  // only then we can safely set the new tail
-  void Complex_Selector::append(Complex_Selector_Obj ss, Backtraces& traces)
-  {
-
-    Complex_Selector_Obj t = ss->tail();
-    Combinator c = ss->combinator();
-    String_Obj r = ss->reference();
-    Compound_Selector_Obj h = ss->head();
-
-    if (ss->has_line_feed()) has_line_feed(true);
-    if (ss->has_line_break()) has_line_break(true);
-
-    // append old headers
-    if (h && h->length()) {
-      if (last()->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {
-        traces.push_back(Backtrace(pstate()));
-        throw Exception::InvalidParent(this, traces, ss);
-      } else if (last()->head_ && last()->head_->length()) {
-        Compound_Selector_Obj rh = last()->head();
-        size_t i;
-        size_t L = h->length();
-        if (Cast<Type_Selector>(h->first())) {
-          if (Class_Selector* cs = Cast<Class_Selector>(rh->last())) {
-            Class_Selector* sqs = SASS_MEMORY_COPY(cs);
-            sqs->name(sqs->name() + (*h)[0]->name());
-            sqs->pstate((*h)[0]->pstate());
-            (*rh)[rh->length()-1] = sqs;
-            rh->pstate(h->pstate());
-            for (i = 1; i < L; ++i) rh->append((*h)[i]);
-          } else if (Id_Selector* is = Cast<Id_Selector>(rh->last())) {
-            Id_Selector* sqs = SASS_MEMORY_COPY(is);
-            sqs->name(sqs->name() + (*h)[0]->name());
-            sqs->pstate((*h)[0]->pstate());
-            (*rh)[rh->length()-1] = sqs;
-            rh->pstate(h->pstate());
-            for (i = 1; i < L; ++i) rh->append((*h)[i]);
-          } else if (Type_Selector* ts = Cast<Type_Selector>(rh->last())) {
-            Type_Selector* tss = SASS_MEMORY_COPY(ts);
-            tss->name(tss->name() + (*h)[0]->name());
-            tss->pstate((*h)[0]->pstate());
-            (*rh)[rh->length()-1] = tss;
-            rh->pstate(h->pstate());
-            for (i = 1; i < L; ++i) rh->append((*h)[i]);
-          } else if (Placeholder_Selector* ps = Cast<Placeholder_Selector>(rh->last())) {
-            Placeholder_Selector* pss = SASS_MEMORY_COPY(ps);
-            pss->name(pss->name() + (*h)[0]->name());
-            pss->pstate((*h)[0]->pstate());
-            (*rh)[rh->length()-1] = pss;
-            rh->pstate(h->pstate());
-            for (i = 1; i < L; ++i) rh->append((*h)[i]);
-          } else {
-            last()->head_->concat(h);
-          }
-        } else {
-          last()->head_->concat(h);
-        }
-      } else if (last()->head_) {
-        last()->head_->concat(h);
-      }
-    } else {
-      // std::cerr << "has no or empty head\n";
-    }
+  CssMediaQuery::CssMediaQuery(ParserState pstate) :
+    AST_Node(pstate),
+    modifier_(""),
+    type_(""),
+    features_()
+  {
+  }
 
-    Complex_Selector* last = mutable_last();
-    if (last) {
-      if (last->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {
-        Complex_Selector* inter = SASS_MEMORY_NEW(Complex_Selector, pstate());
-        inter->reference(r);
-        inter->combinator(c);
-        inter->tail(t);
-        last->tail(inter);
-      } else {
-        if (last->combinator() == ANCESTOR_OF) {
-          last->combinator(c);
-          last->reference(r);
-        }
-        last->tail(t);
-      }
-    }
+  /////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////////
 
+  bool CssMediaQuery::operator==(const CssMediaQuery& rhs) const
+  {
+    return type_ == rhs.type_
+      && modifier_ == rhs.modifier_
+      && features_ == rhs.features_;
   }
 
-  Selector_List* Complex_Selector::resolve_parent_refs(SelectorStack& pstack, Backtraces& traces, bool implicit_parent)
+  // Implemented after dart-sass (maybe move to other class?)
+  CssMediaQuery_Obj CssMediaQuery::merge(CssMediaQuery_Obj& other)
   {
-    Complex_Selector_Obj tail = this->tail();
-    Compound_Selector_Obj head = this->head();
-    Selector_List* parents = pstack.back();
 
-    if (!this->has_real_parent_ref() && !implicit_parent) {
-      Selector_List* retval = SASS_MEMORY_NEW(Selector_List, pstate(), 1);
-      retval->append(this);
-      return retval;
-    }
+    std::string ourType = this->type();
+    Util::ascii_str_tolower(&ourType);
 
-    // first resolve_parent_refs the tail (which may return an expanded list)
-    Selector_List_Obj tails = tail ? tail->resolve_parent_refs(pstack, traces, implicit_parent) : 0;
+    std::string theirType = other->type();
+    Util::ascii_str_tolower(&theirType);
 
-    if (head && head->length() > 0) {
+    std::string ourModifier = this->modifier();
+    Util::ascii_str_tolower(&ourModifier);
 
-      Selector_List_Obj retval;
-      // we have a parent selector in a simple compound list
-      // mix parent complex selector into the compound list
-      if (Cast<Parent_Selector>((*head)[0])) {
-        retval = SASS_MEMORY_NEW(Selector_List, pstate());
+    std::string theirModifier = other->modifier();
+    Util::ascii_str_tolower(&theirModifier);
 
-        // it turns out that real parent references reach
-        // across @at-root rules, which comes unexpected
-        if (parents == NULL && head->has_real_parent_ref()) {
-          int i = pstack.size() - 1;
-          while (!parents && i > -1) {
-            parents = pstack.at(i--);
-          }
-        }
+    std::string type;
+    std::string modifier;
+    std::vector<std::string> features;
 
-        if (parents && parents->length()) {
-          if (tails && tails->length() > 0) {
-            for (size_t n = 0, nL = tails->length(); n < nL; ++n) {
-              for (size_t i = 0, iL = parents->length(); i < iL; ++i) {
-                Complex_Selector_Obj t = (*tails)[n];
-                Complex_Selector_Obj parent = (*parents)[i];
-                Complex_Selector_Obj s = SASS_MEMORY_CLONE(parent);
-                Complex_Selector_Obj ss = SASS_MEMORY_CLONE(this);
-                ss->tail(t ? SASS_MEMORY_CLONE(t) : NULL);
-                Compound_Selector_Obj h = SASS_MEMORY_COPY(head_);
-                // remove parent selector from sequence
-                if (h->length()) {
-                  h->erase(h->begin());
-                  ss->head(h);
-                } else {
-                  ss->head({});
-                }
-                // adjust for parent selector (1 char)
-                // if (h->length()) {
-                //   ParserState state(h->at(0)->pstate());
-                //   state.offset.column += 1;
-                //   state.column -= 1;
-                //   (*h)[0]->pstate(state);
-                // }
-                // keep old parser state
-                s->pstate(pstate());
-                // append new tail
-                s->append(ss, traces);
-                retval->append(s);
-              }
-            }
-          }
-          // have no tails but parents
-          // loop above is inside out
-          else {
-            for (size_t i = 0, iL = parents->length(); i < iL; ++i) {
-              Complex_Selector_Obj parent = (*parents)[i];
-              Complex_Selector_Obj s = SASS_MEMORY_CLONE(parent);
-              Complex_Selector_Obj ss = SASS_MEMORY_CLONE(this);
-              // this is only if valid if the parent has no trailing op
-              // otherwise we cannot append more simple selectors to head
-              if (parent->last()->combinator() != ANCESTOR_OF) {
-                traces.push_back(Backtrace(pstate()));
-                throw Exception::InvalidParent(parent, traces, ss);
-              }
-              ss->tail(tail ? SASS_MEMORY_CLONE(tail) : NULL);
-              Compound_Selector_Obj h = SASS_MEMORY_COPY(head_);
-              // remove parent selector from sequence
-              if (h->length()) {
-                h->erase(h->begin());
-                ss->head(h);
-              } else {
-                ss->head({});
-              }
-              // \/ IMO ruby sass bug \/
-              ss->has_line_feed(false);
-              // adjust for parent selector (1 char)
-              // if (h->length()) {
-              //   ParserState state(h->at(0)->pstate());
-              //   state.offset.column += 1;
-              //   state.column -= 1;
-              //   (*h)[0]->pstate(state);
-              // }
-              // keep old parser state
-              s->pstate(pstate());
-              // append new tail
-              s->append(ss, traces);
-              retval->append(s);
-            }
-          }
+    if (ourType.empty() && theirType.empty()) {
+      CssMediaQuery_Obj query = SASS_MEMORY_NEW(CssMediaQuery, pstate());
+      std::vector<std::string> f1(this->features());
+      std::vector<std::string> f2(other->features());
+      features.insert(features.end(), f1.begin(), f1.end());
+      features.insert(features.end(), f2.begin(), f2.end());
+      query->features(features);
+      return query;
+    }
+
+    if ((ourModifier == "not") != (theirModifier == "not")) {
+      if (ourType == theirType) {
+        std::vector<std::string> negativeFeatures =
+          ourModifier == "not" ? this->features() : other->features();
+        std::vector<std::string> positiveFeatures =
+          ourModifier == "not" ? other->features() : this->features();
+
+        // If the negative features are a subset of the positive features, the
+        // query is empty. For example, `not screen and (color)` has no
+        // intersection with `screen and (color) and (grid)`.
+        // However, `not screen and (color)` *does* intersect with `screen and
+        // (grid)`, because it means `not (screen and (color))` and so it allows
+        // a screen with no color but with a grid.
+        if (listIsSubsetOrEqual(negativeFeatures, positiveFeatures)) {
+          return SASS_MEMORY_NEW(CssMediaQuery, pstate());
         }
-        // have no parent but some tails
         else {
-          if (tails && tails->length() > 0) {
-            for (size_t n = 0, nL = tails->length(); n < nL; ++n) {
-              Complex_Selector_Obj cpy = SASS_MEMORY_CLONE(this);
-              cpy->tail(SASS_MEMORY_CLONE(tails->at(n)));
-              cpy->head(SASS_MEMORY_NEW(Compound_Selector, head->pstate()));
-              for (size_t i = 1, L = this->head()->length(); i < L; ++i)
-                cpy->head()->append((*this->head())[i]);
-              if (!cpy->head()->length()) cpy->head({});
-              retval->append(cpy->skip_empty_reference());
-            }
-          }
-          // have no parent nor tails
-          else {
-            Complex_Selector_Obj cpy = SASS_MEMORY_CLONE(this);
-            cpy->head(SASS_MEMORY_NEW(Compound_Selector, head->pstate()));
-            for (size_t i = 1, L = this->head()->length(); i < L; ++i)
-              cpy->head()->append((*this->head())[i]);
-            if (!cpy->head()->length()) cpy->head({});
-            retval->append(cpy->skip_empty_reference());
-          }
+          return {};
         }
       }
-      // no parent selector in head
-      else {
-        retval = this->tails(tails);
+      else if (this->matchesAllTypes() || other->matchesAllTypes()) {
+        return {};
       }
 
-      for (Simple_Selector_Obj ss : head->elements()) {
-        if (Wrapped_Selector* ws = Cast<Wrapped_Selector>(ss)) {
-          if (Selector_List* sl = Cast<Selector_List>(ws->selector())) {
-            if (parents) ws->selector(sl->resolve_parent_refs(pstack, traces, implicit_parent));
-          }
-        }
+      if (ourModifier == "not") {
+        modifier = theirModifier;
+        type = theirType;
+        features = other->features();
+      }
+      else {
+        modifier = ourModifier;
+        type = ourType;
+        features = this->features();
       }
-
-      return retval.detach();
-
     }
-    // has no head
-    return this->tails(tails);
-  }
-
-  Selector_List* Complex_Selector::tails(Selector_List* tails)
-  {
-    Selector_List* rv = SASS_MEMORY_NEW(Selector_List, pstate_);
-    if (tails && tails->length()) {
-      for (size_t i = 0, iL = tails->length(); i < iL; ++i) {
-        Complex_Selector_Obj pr = SASS_MEMORY_CLONE(this);
-        pr->tail(tails->at(i));
-        rv->append(pr);
+    else if (ourModifier == "not") {
+      SASS_ASSERT(theirModifier == "not", "modifiers not is sync");
+
+      // CSS has no way of representing "neither screen nor print".
+      if (ourType != theirType) return {};
+
+      auto moreFeatures = this->features().size() > other->features().size()
+        ? this->features()
+        : other->features();
+      auto fewerFeatures = this->features().size() > other->features().size()
+        ? other->features()
+        : this->features();
+
+      // If one set of features is a superset of the other,
+      // use those features because they're strictly narrower.
+      if (listIsSubsetOrEqual(fewerFeatures, moreFeatures)) {
+        modifier = ourModifier; // "not"
+        type = ourType;
+        features = moreFeatures;
       }
+      else {
+        // Otherwise, there's no way to
+        // represent the intersection.
+        return {};
+      }
+
     }
     else {
-      rv->append(this);
-    }
-    return rv;
-  }
-
-  // return the last tail that is defined
-  const Complex_Selector* Complex_Selector::first() const
-  {
-    // declare variables used in loop
-    const Complex_Selector* cur = this;
-    const Compound_Selector* head;
-    // processing loop
-    while (cur)
-    {
-      // get the head
-      head = cur->head_.ptr();
-      // abort (and return) if it is not a parent selector
-      if (!head || head->length() != 1 || !Cast<Parent_Selector>((*head)[0])) {
-        break;
+      if (this->matchesAllTypes()) {
+        modifier = theirModifier;
+        // Omit the type if either input query did, since that indicates that they
+        // aren't targeting a browser that requires "all and".
+        type = (other->matchesAllTypes() && ourType.empty()) ? "" : theirType;
+        std::vector<std::string> f1(this->features());
+        std::vector<std::string> f2(other->features());
+        features.insert(features.end(), f1.begin(), f1.end());
+        features.insert(features.end(), f2.begin(), f2.end());
+      }
+      else if (other->matchesAllTypes()) {
+        modifier = ourModifier;
+        type = ourType;
+        std::vector<std::string> f1(this->features());
+        std::vector<std::string> f2(other->features());
+        features.insert(features.end(), f1.begin(), f1.end());
+        features.insert(features.end(), f2.begin(), f2.end());
+      }
+      else if (ourType != theirType) {
+        return SASS_MEMORY_NEW(CssMediaQuery, pstate());
+      }
+      else {
+        modifier = ourModifier.empty() ? theirModifier : ourModifier;
+        type = ourType;
+        std::vector<std::string> f1(this->features());
+        std::vector<std::string> f2(other->features());
+        features.insert(features.end(), f1.begin(), f1.end());
+        features.insert(features.end(), f2.begin(), f2.end());
       }
-      // advance to next
-      cur = cur->tail_;
     }
-    // result
-    return cur;
+
+    CssMediaQuery_Obj query = SASS_MEMORY_NEW(CssMediaQuery, pstate());
+    query->modifier(modifier == ourModifier ? this->modifier() : other->modifier());
+    query->type(ourType.empty() ? other->type() : this->type());
+    query->features(features);
+    return query;
   }
 
-  Complex_Selector* Complex_Selector::mutable_first()
+  CssMediaQuery::CssMediaQuery(const CssMediaQuery* ptr) :
+    AST_Node(*ptr),
+    modifier_(ptr->modifier_),
+    type_(ptr->type_),
+    features_(ptr->features_)
   {
-    return const_cast<Complex_Selector*>(first());
   }
 
-  // return the last tail that is defined
-  const Complex_Selector* Complex_Selector::last() const
+  /////////////////////////////////////////////////////////////////////////
+  // ToDo: finalize specificity implementation
+  /////////////////////////////////////////////////////////////////////////
+
+  size_t SelectorList::maxSpecificity() const
   {
-    const Complex_Selector* cur = this;
-    const Complex_Selector* nxt = cur;
-    // loop until last
-    while (nxt) {
-      cur = nxt;
-      nxt = cur->tail_.ptr();
+    size_t specificity = 0;
+    for (auto complex : elements()) {
+      specificity = std::max(specificity, complex->maxSpecificity());
     }
-    return cur;
+    return specificity;
   }
 
-  Complex_Selector* Complex_Selector::mutable_last()
+  size_t SelectorList::minSpecificity() const
   {
-    return const_cast<Complex_Selector*>(last());
+    size_t specificity = 0;
+    for (auto complex : elements()) {
+      specificity = std::min(specificity, complex->minSpecificity());
+    }
+    return specificity;
   }
 
-  Complex_Selector::Combinator Complex_Selector::clear_innermost()
+  size_t CompoundSelector::maxSpecificity() const
   {
-    Combinator c;
-    if (!tail() || tail()->tail() == nullptr)
-    { c = combinator(); combinator(ANCESTOR_OF); tail({}); }
-    else
-    { c = tail_->clear_innermost(); }
-    return c;
+    size_t specificity = 0;
+    for (auto simple : elements()) {
+      specificity += simple->maxSpecificity();
+    }
+    return specificity;
   }
 
-  void Complex_Selector::set_innermost(Complex_Selector_Obj val, Combinator c)
+  size_t CompoundSelector::minSpecificity() const
   {
-    if (!tail_)
-    { tail_ = val; combinator(c); }
-    else
-    { tail_->set_innermost(val, c); }
+    size_t specificity = 0;
+    for (auto simple : elements()) {
+      specificity += simple->minSpecificity();
+    }
+    return specificity;
   }
 
-  void Complex_Selector::cloneChildren()
+  size_t ComplexSelector::maxSpecificity() const
   {
-    if (head()) head(SASS_MEMORY_CLONE(head()));
-    if (tail()) tail(SASS_MEMORY_CLONE(tail()));
+    size_t specificity = 0;
+    for (auto component : elements()) {
+      specificity += component->maxSpecificity();
+    }
+    return specificity;
   }
 
-  // it's a superselector if every selector of the right side
-  // list is a superselector of the given left side selector
-  bool Complex_Selector::is_superselector_of(const Selector_List* sub, std::string wrapping) const
+  size_t ComplexSelector::minSpecificity() const
   {
-    // Check every rhs selector against left hand list
-    for(size_t i = 0, L = sub->length(); i < L; ++i) {
-      if (!is_superselector_of((*sub)[i], wrapping)) return false;
+    size_t specificity = 0;
+    for (auto component : elements()) {
+      specificity += component->minSpecificity();
     }
-    return true;
+    return specificity;
   }
 
   /////////////////////////////////////////////////////////////////////////
+  // ToDo: this might be done easier with new selector format
   /////////////////////////////////////////////////////////////////////////
 
-  Selector_List::Selector_List(ParserState pstate, size_t s)
-  : Selector(pstate),
-    Vectorized<Complex_Selector_Obj>(s),
-    schema_({}),
-    wspace_(0)
-  { }
-  Selector_List::Selector_List(const Selector_List* ptr)
-  : Selector(ptr),
-    Vectorized<Complex_Selector_Obj>(*ptr),
-    schema_(ptr->schema_),
-    wspace_(ptr->wspace_)
-  { }
-
-  bool Selector_List::find ( bool (*f)(AST_Node_Obj) )
+  std::vector<ComplexSelectorObj>
+    CompoundSelector::resolve_parent_refs(SelectorStack pstack, Backtraces& traces, bool implicit_parent)
   {
-    // check children first
-    for (Complex_Selector_Obj sel : elements()) {
-      if (sel->find(f)) return true;
-    }
-    // execute last
-    return f(this);
-  }
 
-  Selector_List_Obj Selector_List::eval(Eval& eval)
-  {
-    Selector_List_Obj list = schema() ?
-      eval(schema()) : eval(this);
-    list->schema(schema());
-    return list;
-  }
+    auto parent = pstack.back();
+    std::vector<ComplexSelectorObj> rv;
 
-  Selector_List* Selector_List::resolve_parent_refs(SelectorStack& pstack, Backtraces& traces, bool implicit_parent)
-  {
-    if (!this->has_parent_ref()) return this;
-    Selector_List* ss = SASS_MEMORY_NEW(Selector_List, pstate());
-    for (size_t si = 0, sL = this->length(); si < sL; ++si) {
-      Selector_List_Obj rv = at(si)->resolve_parent_refs(pstack, traces, implicit_parent);
-      ss->concat(rv);
+    for (SimpleSelectorObj simple : elements()) {
+      if (Pseudo_Selector * pseudo = Cast<Pseudo_Selector>(simple)) {
+        if (SelectorList* sel = Cast<SelectorList>(pseudo->selector())) {
+          if (parent) {
+            pseudo->selector(sel->resolve_parent_refs(
+              pstack, traces, implicit_parent));
+          }
+        }
+      }
     }
-    return ss;
-  }
 
-  void Selector_List::cloneChildren()
-  {
-    for (size_t i = 0, l = length(); i < l; i++) {
-      at(i) = SASS_MEMORY_CLONE(at(i));
-    }
-  }
+    // Mix with parents from stack
+    if (hasRealParent()) {
 
-  // remove parent selector references
-  // basically unwraps parsed selectors
-  void Selector_List::remove_parent_selectors()
-  {
-    // Check every rhs selector against left hand list
-    for(size_t i = 0, L = length(); i < L; ++i) {
-      if (!(*this)[i]->head()) continue;
-      if ((*this)[i]->head()->is_empty_reference()) {
-        // simply move to the next tail if we have "no" combinator
-        if ((*this)[i]->combinator() == Complex_Selector::ANCESTOR_OF) {
-          if ((*this)[i]->tail()) {
-            if ((*this)[i]->has_line_feed()) {
-              (*this)[i]->tail()->has_line_feed(true);
+      if (parent.isNull()) {
+        return { wrapInComplex() };
+      }
+      else {
+        for (auto complex : parent->elements()) {
+          // The parent complex selector has a compound selector
+          if (CompoundSelectorObj tail = Cast<CompoundSelector>(complex->last())) {
+            // Create a copy to alter it
+            complex = SASS_MEMORY_COPY(complex);
+            tail = SASS_MEMORY_COPY(tail);
+
+            // Check if we can merge front with back
+            if (length() > 0 && tail->length() > 0) {
+              SimpleSelectorObj back = tail->last();
+              SimpleSelectorObj front = first();
+              auto simple_back = Cast<SimpleSelector>(back);
+              auto simple_front = Cast<Type_Selector>(front);
+              if (simple_front && simple_back) {
+                simple_back = SASS_MEMORY_COPY(simple_back);
+                auto name = simple_back->name();
+                name += simple_front->name();
+                simple_back->name(name);
+                tail->elements().back() = simple_back;
+                tail->elements().insert(tail->end(),
+                  begin() + 1, end());
+              }
+              else {
+                tail->concat(this);
+              }
+            }
+            else {
+              tail->concat(this);
             }
-            (*this)[i] = (*this)[i]->tail();
+
+            complex->elements().back() = tail;
+            // Append to results
+            rv.push_back(complex);
+          }
+          else {
+            // Can't insert parent that ends with a combinator
+            // where the parent selector is followed by something
+            if (parent && length() > 0) {
+              throw Exception::InvalidParent(parent, traces, this);
+            }
+            // Create a copy to alter it
+            complex = SASS_MEMORY_COPY(complex);
+            // Just append ourself
+            complex->append(this);
+            // Append to results
+            rv.push_back(complex);
           }
-        }
-        // otherwise remove the first item from head
-        else {
-          (*this)[i]->head()->erase((*this)[i]->head()->begin());
         }
       }
     }
-  }
-
-  bool Selector_List::has_parent_ref() const
-  {
-    for (Complex_Selector_Obj s : elements()) {
-      if (s && s->has_parent_ref()) return true;
-    }
-    return false;
-  }
-
-  bool Selector_List::has_real_parent_ref() const
-  {
-    for (Complex_Selector_Obj s : elements()) {
-      if (s && s->has_real_parent_ref()) return true;
-    }
-    return false;
-  }
 
-  void Selector_List::adjust_after_pushing(Complex_Selector_Obj c)
-  {
-    // if (c->has_reference())   has_reference(true);
-  }
-
-  // it's a superselector if every selector of the right side
-  // list is a superselector of the given left side selector
-  bool Selector_List::is_superselector_of(const Selector_List* sub, std::string wrapping) const
-  {
-    // Check every rhs selector against left hand list
-    for(size_t i = 0, L = sub->length(); i < L; ++i) {
-      if (!is_superselector_of((*sub)[i], wrapping)) return false;
+    // No parents
+    else {
+      // Create a new wrapper to wrap ourself
+      auto complex = SASS_MEMORY_NEW(ComplexSelector, pstate());
+      // Just append ourself
+      complex->append(this);
+      // Append to results
+      rv.push_back(complex);
     }
-    return true;
-  }
 
-  // it's a superselector if every selector on the right side
-  // is a superselector of any one of the left side selectors
-  bool Selector_List::is_superselector_of(const Compound_Selector* sub, std::string wrapping) const
-  {
-    // Check every lhs selector against right hand
-    for(size_t i = 0, L = length(); i < L; ++i) {
-      if ((*this)[i]->is_superselector_of(sub, wrapping)) return true;
-    }
-    return false;
-  }
+    return rv;
 
-  // it's a superselector if every selector on the right side
-  // is a superselector of any one of the left side selectors
-  bool Selector_List::is_superselector_of(const Complex_Selector* sub, std::string wrapping) const
-  {
-    // Check every lhs selector against right hand
-    for(size_t i = 0, L = length(); i < L; ++i) {
-      if ((*this)[i]->is_superselector_of(sub)) return true;
-    }
-    return false;
   }
 
-  void Selector_List::populate_extends(Selector_List_Obj extendee, Subset_Map& extends)
+  /* better return std::vector? only - is empty container anyway? */
+  SelectorList* ComplexSelector::resolve_parent_refs(SelectorStack pstack, Backtraces& traces, bool implicit_parent)
   {
 
-    Selector_List* extender = this;
-    for (auto complex_sel : extendee->elements()) {
-      Complex_Selector_Obj c = complex_sel;
+    std::vector<std::vector<ComplexSelectorObj>> vars;
 
+    auto parent = pstack.back();
 
-      // Ignore any parent selectors, until we find the first non Selectorerence head
-      Compound_Selector_Obj compound_sel = c->head();
-      Complex_Selector_Obj pIter = complex_sel;
-      while (pIter) {
-        Compound_Selector_Obj pHead = pIter->head();
-        if (pHead && Cast<Parent_Selector>(pHead->elements()[0]) == NULL) {
-          compound_sel = pHead;
-          break;
-        }
+    if (has_real_parent_ref() && !parent) {
+      throw Exception::TopLevelParent(traces, pstate());
+    }
 
-        pIter = pIter->tail();
-      }
+    if (!chroots() && parent) {
 
-      if (!pIter->head() || pIter->tail()) {
-        coreError("nested selectors may not be extended", c->pstate());
+      if (!has_real_parent_ref() && !implicit_parent) {
+        SelectorList* retval = SASS_MEMORY_NEW(SelectorList, pstate(), 1);
+        retval->append(this);
+        return retval;
       }
 
-      compound_sel->is_optional(extendee->is_optional());
+      vars.push_back(parent->elements());
+    }
 
-      for (size_t i = 0, L = extender->length(); i < L; ++i) {
-        extends.put(compound_sel, std::make_pair((*extender)[i], compound_sel));
+    for (auto sel : elements()) {
+      if (CompoundSelectorObj comp = Cast<CompoundSelector>(sel)) {
+        auto asd = comp->resolve_parent_refs(pstack, traces, implicit_parent);
+        if (asd.size() > 0) vars.push_back(asd);
+      }
+      else {
+        // ToDo: merge together sequences whenever possible
+        auto cont = SASS_MEMORY_NEW(ComplexSelector, pstate());
+        cont->append(sel);
+        vars.push_back({ cont });
       }
     }
-  };
 
-  size_t Selector_List::hash() const
-  {
-    if (Selector::hash_ == 0) {
-      if (empty()) {
-        hash_combine(Selector::hash_, std::hash<int>()(SELECTOR));
-      } else {
-        hash_combine(Selector::hash_, Vectorized::hash());
+    // Need complex selectors to preserve linefeeds
+    std::vector<std::vector<ComplexSelectorObj>> res = permutateAlt(vars);
+
+    // std::reverse(std::begin(res), std::end(res));
+
+    auto lst = SASS_MEMORY_NEW(SelectorList, pstate());
+    for (auto items : res) {
+      if (items.size() > 0) {
+        ComplexSelectorObj first = SASS_MEMORY_COPY(items[0]);
+        first->hasPreLineFeed(first->hasPreLineFeed() || (!has_real_parent_ref() && hasPreLineFeed()));
+        // ToDo: remove once we know how to handle line feeds
+        // ToDo: currently a mashup between ruby and dart sass
+        // if (has_real_parent_ref()) first->has_line_feed(false);
+        // first->has_line_break(first->has_line_break() || has_line_break());
+        first->chroots(true); // has been resolved by now
+        for (size_t i = 1; i < items.size(); i += 1) {
+          first->concat(items[i]);
+        }
+        lst->append(first);
       }
     }
-    return Selector::hash_;
-  }
 
-  unsigned long Selector_List::specificity() const
-  {
-    unsigned long sum = 0;
-    unsigned long specificity;
-    for (size_t i = 0, L = length(); i < L; ++i)
-    {
-      specificity = (*this)[i]->specificity();
-      if (sum < specificity) sum = specificity;
-    }
-    return sum;
-  }
+    return lst;
 
-  void Selector_List::set_media_block(Media_Block* mb)
-  {
-    media_block(mb);
-    for (Complex_Selector_Obj cs : elements()) {
-      cs->set_media_block(mb);
-    }
   }
 
-  bool Selector_List::has_placeholder()
+  SelectorList* SelectorList::resolve_parent_refs(SelectorStack pstack, Backtraces& traces, bool implicit_parent)
   {
-    for (Complex_Selector_Obj cs : elements()) {
-      if (cs->has_placeholder()) return true;
+    SelectorList* rv = SASS_MEMORY_NEW(SelectorList, pstate());
+    for (auto sel : elements()) {
+      // Note: this one is tricky as we get back a pointer from resolve parents ...
+      SelectorListObj res = sel->resolve_parent_refs(pstack, traces, implicit_parent);
+      // Note: ... and concat will only append the items in elements
+      // Therefore by passing it directly, the container will leak!
+      rv->concat(res);
     }
-    return false;
+    return rv;
   }
 
   /////////////////////////////////////////////////////////////////////////
@@ -1461,15 +1020,14 @@ namespace Sass {
 
   IMPLEMENT_AST_OPERATORS(Selector_Schema);
   IMPLEMENT_AST_OPERATORS(Placeholder_Selector);
-  IMPLEMENT_AST_OPERATORS(Parent_Selector);
   IMPLEMENT_AST_OPERATORS(Attribute_Selector);
-  IMPLEMENT_AST_OPERATORS(Compound_Selector);
-  IMPLEMENT_AST_OPERATORS(Complex_Selector);
   IMPLEMENT_AST_OPERATORS(Type_Selector);
   IMPLEMENT_AST_OPERATORS(Class_Selector);
   IMPLEMENT_AST_OPERATORS(Id_Selector);
   IMPLEMENT_AST_OPERATORS(Pseudo_Selector);
-  IMPLEMENT_AST_OPERATORS(Wrapped_Selector);
-  IMPLEMENT_AST_OPERATORS(Selector_List);
+  IMPLEMENT_AST_OPERATORS(SelectorCombinator);
+  IMPLEMENT_AST_OPERATORS(CompoundSelector);
+  IMPLEMENT_AST_OPERATORS(ComplexSelector);
+  IMPLEMENT_AST_OPERATORS(SelectorList);
 
 }