#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>

namespace Sass {

  static Null sass_null(ParserState("null"));

  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);

  }

  bool Selector_List::find ( bool (*f)(AST_Node_Obj) )

  {

    // check children first

    for (Complex_Selector_Obj sel : elements()) {

      if (sel->find(f)) return true;

    }

    // execute last

    return f(this);

  }

  bool Compound_Selector::find ( bool (*f)(AST_Node_Obj) )

  {

    // check children first

    for (Simple_Selector_Obj sel : elements()) {

      if (sel->find(f)) return true;

    }

    // execute last

    return f(this);

  }

  bool Complex_Selector::find ( bool (*f)(AST_Node_Obj) )

  {

    // check children first

    if (head_ && head_->find(f)) return true;

    if (tail_ && tail_->find(f)) return true;

    // execute last

    return f(this);

  }

  bool Supports_Operator::needs_parens(Supports_Condition_Obj cond) const {

    if (Supports_Operator_Obj op = Cast<Supports_Operator>(cond)) {

      return op->operand() != operand();

    }

    return Cast<Supports_Negation>(cond) != NULL;

  }

  bool Supports_Negation::needs_parens(Supports_Condition_Obj cond) const {

    return Cast<Supports_Negation>(cond) ||

           Cast<Supports_Operator>(cond);

  }

  void str_rtrim(std::string& str, const std::string& delimiters = " \f\n\r\t\v")

  {

    str.erase( str.find_last_not_of( delimiters ) + 1 );

  }

  void String_Constant::rtrim()

  {

    str_rtrim(value_);

  }

  void String_Schema::rtrim()

  {

    if (!empty()) {

      if (String_Ptr str = Cast<String>(last())) str->rtrim();

    }

  }

  void Argument::set_delayed(bool delayed)

  {

    if (value_) value_->set_delayed(delayed);

    is_delayed(delayed);

  }

  void Arguments::set_delayed(bool delayed)

  {

    for (Argument_Obj arg : elements()) {

      if (arg) arg->set_delayed(delayed);

    }

    is_delayed(delayed);

  }

  bool At_Root_Query::exclude(std::string str)

  {

    bool with = feature() && unquote(feature()->to_string()).compare("with") == 0;

    List_Ptr l = static_cast<List_Ptr>(value().ptr());

    std::string v;

    if (with)

    {

      if (!l || l->length() == 0) return str.compare("rule") != 0;

      for (size_t i = 0, L = l->length(); i < L; ++i)

      {

        v = unquote((*l)[i]->to_string());

        if (v.compare("all") == 0 || v == str) return false;

      }

      return true;

    }

    else

    {

      if (!l || !l->length()) return str.compare("rule") == 0;

      for (size_t i = 0, L = l->length(); i < L; ++i)

      {

        v = unquote((*l)[i]->to_string());

        if (v.compare("all") == 0 || v == str) return true;

      }

      return false;

    }

  }

  void AST_Node::update_pstate(const ParserState& pstate)

  {

    pstate_.offset += pstate - pstate_ + pstate.offset;

  }

  bool Simple_Selector::is_ns_eq(const Simple_Selector& r) const

  {

    // https://github.com/sass/sass/issues/2229

    if ((has_ns_ == r.has_ns_) ||

        (has_ns_ && ns_.empty()) ||

        (r.has_ns_ && r.ns_.empty())

    ) {

      if (ns_.empty() && r.ns() == "*") return false;

      else if (r.ns().empty() && ns() == "*") return false;

      else return ns() == r.ns();

    }

    return false;

  }

  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_Obj l = (*this)[i];

      Simple_Selector_Obj 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::has_parent_ref() const

  {

    for (Simple_Selector_Obj s : *this) {

      if (s && s->has_parent_ref()) return true;

    }

    return false;

  }

  bool Compound_Selector::has_real_parent_ref() const

  {

    for (Simple_Selector_Obj s : *this) {

      if (s && s->has_real_parent_ref()) return true;

    }

    return false;

  }

  bool Complex_Selector::has_parent_ref() const

  {

    return (head() && head()->has_parent_ref()) ||

           (tail() && tail()->has_parent_ref());

  }

  bool Complex_Selector::has_real_parent_ref() const

  {

    return (head() && head()->has_real_parent_ref()) ||

           (tail() && tail()->has_real_parent_ref());

  }

  bool Complex_Selector::operator< (const Complex_Selector& rhs) const

  {

    // const iterators for tails

    Complex_Selector_Ptr_Const l = this;

    Complex_Selector_Ptr_Const r = &rhs;

    Compound_Selector_Ptr l_h = NULL;

    Compound_Selector_Ptr 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

    Complex_Selector_Ptr_Const l = this;

    Complex_Selector_Ptr_Const r = &rhs;

    Compound_Selector_Ptr l_h = NULL;

    Compound_Selector_Ptr 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 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;

  }

  Compound_Selector_Ptr Compound_Selector::unify_with(Compound_Selector_Ptr rhs)

  {

    if (empty()) return rhs;

    Compound_Selector_Obj unified = SASS_MEMORY_COPY(rhs);

    for (size_t i = 0, L = length(); i < L; ++i)

    {

      if (unified.isNull()) break;

      unified = at(i)->unify_with(unified);

    }

    return unified.detach();

  }

  bool Complex_Selector::operator== (const Selector& rhs) const

  {

    if (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this == *sl;

    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this == *sp;

    if (const Complex_Selector* cs = Cast<Complex_Selector>(&rhs)) return *this == *cs;

    if (const Compound_Selector* 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 (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this < *sl;

    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this < *sp;

    if (const Complex_Selector* cs = Cast<Complex_Selector>(&rhs)) return *this < *cs;

    if (const Compound_Selector* 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

  {

    if (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this == *sl;

    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this == *sp;

    if (const Complex_Selector* cs = Cast<Complex_Selector>(&rhs)) return *this == *cs;

    if (const Compound_Selector* 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

  {

    if (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this < *sl;

    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this < *sp;

    if (const Complex_Selector* cs = Cast<Complex_Selector>(&rhs)) return *this < *cs;

    if (const Compound_Selector* 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 (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this == *sl;

    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this == *sp;

    if (const Complex_Selector* cs = Cast<Complex_Selector>(&rhs)) return *this == *cs;

    if (const Compound_Selector* 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 (const Selector_List* sl = Cast<Selector_List>(&rhs)) return *this < *sl;

    if (const Simple_Selector* sp = Cast<Simple_Selector>(&rhs)) return *this < *sp;

    if (const Complex_Selector* cs = Cast<Complex_Selector>(&rhs)) return *this < *cs;

    if (const Compound_Selector* ch = Cast<Compound_Selector>(&rhs)) return *this < *ch;

    throw std::runtime_error("invalid selector base classes to compare");

  }

  bool Simple_Selector::operator== (const Selector& rhs) const

  {

    if (Simple_Selector_Ptr_Const sp = Cast<Simple_Selector>(&rhs)) return *this == *sp;

    return false;

  }

  bool Simple_Selector::operator< (const Selector& rhs) const

  {

    if (Simple_Selector_Ptr_Const sp = Cast<Simple_Selector>(&rhs)) return *this < *sp;

    return false;

  }

  bool Simple_Selector::operator== (const Simple_Selector& rhs) const

  {

    // solve the double dispatch problem by using RTTI information via dynamic cast

    if (const Pseudo_Selector* lhs = Cast<Pseudo_Selector>(this)) {return *lhs == rhs; }

    else if (const Wrapped_Selector* lhs = Cast<Wrapped_Selector>(this)) {return *lhs == rhs; }

    else if (const Element_Selector* lhs = Cast<Element_Selector>(this)) {return *lhs == rhs; }

    else if (const Attribute_Selector* lhs = Cast<Attribute_Selector>(this)) {return *lhs == rhs; }

    else if (name_ == rhs.name_)

    { return is_ns_eq(rhs); }

    else return false;

  }

  bool Simple_Selector::operator< (const Simple_Selector& rhs) const

  {

    // solve the double dispatch problem by using RTTI information via dynamic cast

    if (const Pseudo_Selector* lhs = Cast<Pseudo_Selector>(this)) {return *lhs < rhs; }

    else if (const Wrapped_Selector* lhs = Cast<Wrapped_Selector>(this)) {return *lhs < rhs; }

    else if (const Element_Selector* lhs = Cast<Element_Selector>(this)) {return *lhs < rhs; }

    else if (const Attribute_Selector* lhs = Cast<Attribute_Selector>(this)) {return *lhs < rhs; }

    if (is_ns_eq(rhs))

    { return name_ < rhs.name_; }

    return ns_ < rhs.ns_;

  }

  bool Selector_List::operator== (const Selector& rhs) const

  {

    // solve the double dispatch problem by using RTTI information via dynamic cast

    if (Selector_List_Ptr_Const sl = Cast<Selector_List>(&rhs)) { return *this == *sl; }

    else if (Complex_Selector_Ptr_Const cpx = Cast<Complex_Selector>(&rhs)) { return *this == *cpx; }

    else if (Compound_Selector_Ptr_Const cpd = Cast<Compound_Selector>(&rhs)) { return *this == *cpd; }

    // no compare method

    return this == &rhs;

  }

  // Selector lists can be compared to comma lists

  bool Selector_List::operator==(const Expression& rhs) const

  {

    // solve the double dispatch problem by using RTTI information via dynamic cast

    if (List_Ptr_Const ls = Cast<List>(&rhs)) { return *this == *ls; }

    if (Selector_Ptr_Const ls = Cast<Selector>(&rhs)) { return *this == *ls; }

    // compare invalid (maybe we should error?)

    return false;

  }

  bool Selector_List::operator== (const Selector_List& rhs) const

  {

    // for array access

    size_t i = 0, n = 0;

    size_t iL = length();

    size_t nL = rhs.length();

    // create temporary vectors and sort them

    std::vector<Complex_Selector_Obj> l_lst = this->elements();

    std::vector<Complex_Selector_Obj> r_lst = rhs.elements();

    std::sort(l_lst.begin(), l_lst.end(), OrderNodes());

    std::sort(r_lst.begin(), r_lst.end(), OrderNodes());

    // process loop

    while (true)

    {

      // first check for valid index

      if (i == iL) return iL == nL;

      else if (n == nL) return iL == nL;

      // the access the vector items

      Complex_Selector_Obj l = l_lst[i];

      Complex_Selector_Obj r = r_lst[n];

      // skip nulls

      if (!l) ++i;

      else if (!r) ++n;

      // do the check

      else if (*l != *r)

      { return false; }

      // advance

      ++i; ++n;

    }

    // there is no break?!

  }

  bool Selector_List::operator< (const Selector& rhs) const

  {

    if (Selector_List_Ptr_Const sp = Cast<Selector_List>(&rhs)) return *this < *sp;

    return false;

  }

  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;

    }

    return false;

  }

  Compound_Selector_Ptr Simple_Selector::unify_with(Compound_Selector_Ptr rhs)

  {

    for (size_t i = 0, L = rhs->length(); i < L; ++i)

    { if (to_string() == rhs->at(i)->to_string()) return rhs; }

    // check for pseudo elements because they are always last

    size_t i, L;

    bool found = false;

    if (typeid(*this) == typeid(Pseudo_Selector) || typeid(*this) == typeid(Wrapped_Selector))

    {

      for (i = 0, L = rhs->length(); i < L; ++i)

      {

        if ((Cast<Pseudo_Selector>((*rhs)[i]) || Cast<Wrapped_Selector>((*rhs)[i])) && (*rhs)[L-1]->is_pseudo_element())

        { found = true; break; }

      }

    }

    else

    {

      for (i = 0, L = rhs->length(); i < L; ++i)

      {

        if (Cast<Pseudo_Selector>((*rhs)[i]) || Cast<Wrapped_Selector>((*rhs)[i]))

        { found = true; break; }

      }

    }

    if (!found)

    {

      rhs->append(this);

      return rhs;

    }

    rhs->elements().insert(rhs->elements().begin() + i, this);

    return rhs;

  }

  Simple_Selector_Ptr Element_Selector::unify_with(Simple_Selector_Ptr rhs)

  {

    // check if ns can be extended

    // true for no ns or universal

    if (has_universal_ns())

    {

      // but dont extend with universal

      // true for valid ns and universal

      if (!rhs->is_universal_ns())

      {

        // overwrite the name if star is given as name

        if (this->name() == "*") { this->name(rhs->name()); }

        // now overwrite the namespace name and flag

        this->ns(rhs->ns()); this->has_ns(rhs->has_ns());

        // return copy

        return this;

      }

    }

    // namespace may changed, check the name now

    // overwrite star (but not with another star)

    if (name() == "*" && rhs->name() != "*")

    {

      // simply set the new name

      this->name(rhs->name());

      // return copy

      return this;

    }

    // return original

    return this;

  }

  Compound_Selector_Ptr Element_Selector::unify_with(Compound_Selector_Ptr rhs)

  {

    // TODO: handle namespaces

    // if the rhs is empty, just return a copy of this

    if (rhs->length() == 0) {

      rhs->append(this);

      return rhs;

    }

    Simple_Selector_Ptr rhs_0 = rhs->at(0);

    // otherwise, this is a tag name

    if (name() == "*")

    {

      if (typeid(*rhs_0) == typeid(Element_Selector))

      {

        // if rhs is universal, just return this tagname + rhs's qualifiers

        Element_Selector_Ptr ts = Cast<Element_Selector>(rhs_0);

        rhs->at(0) = this->unify_with(ts);

        return rhs;

      }

      else if (Cast<Class_Selector>(rhs_0) || Cast<Id_Selector>(rhs_0)) {

        // qualifier is `.class`, so we can prefix with `ns|*.class`

        if (has_ns() && !rhs_0->has_ns()) {

          if (ns() != "*") rhs->elements().insert(rhs->begin(), this);

        }

        return rhs;

      }

      return rhs;

    }

    if (typeid(*rhs_0) == typeid(Element_Selector))

    {

      // if rhs is universal, just return this tagname + rhs's qualifiers

      if (rhs_0->name() != "*" && rhs_0->ns() != "*" && rhs_0->name() != name()) return 0;

      // otherwise create new compound and unify first simple selector

      rhs->at(0) = this->unify_with(rhs_0);

      return rhs;

    }

    // else it's a tag name and a bunch of qualifiers -- just append them

    if (name() != "*") rhs->elements().insert(rhs->begin(), this);

    return rhs;

  }

  Compound_Selector_Ptr Class_Selector::unify_with(Compound_Selector_Ptr rhs)

  {

    rhs->has_line_break(has_line_break());

    return Simple_Selector::unify_with(rhs);

  }

  Compound_Selector_Ptr Id_Selector::unify_with(Compound_Selector_Ptr rhs)

  {

    for (size_t i = 0, L = rhs->length(); i < L; ++i)

    {

      if (Id_Selector_Ptr sel = Cast<Id_Selector>(rhs->at(i))) {

        if (sel->name() != name()) return 0;

      }

    }

    rhs->has_line_break(has_line_break());

    return Simple_Selector::unify_with(rhs);

  }

  Compound_Selector_Ptr Pseudo_Selector::unify_with(Compound_Selector_Ptr rhs)

  {

    if (is_pseudo_element())

    {

      for (size_t i = 0, L = rhs->length(); i < L; ++i)

      {

        if (Pseudo_Selector_Ptr sel = Cast<Pseudo_Selector>(rhs->at(i))) {

          if (sel->is_pseudo_element() && sel->name() != name()) return 0;

        }

      }

    }

    return Simple_Selector::unify_with(rhs);

  }

  bool Attribute_Selector::operator< (const Attribute_Selector& rhs) const

  {

    if (is_ns_eq(rhs)) {

      if (name() == rhs.name()) {

        if (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 matcher() < rhs.matcher(); }

      } else { return name() < rhs.name(); }

    } else { return ns() < rhs.ns(); }

  }

  bool Attribute_Selector::operator< (const Simple_Selector& rhs) const

  {

    if (Attribute_Selector_Ptr_Const w = Cast<Attribute_Selector>(&rhs))

    {

      return *this < *w;

    }

    if (is_ns_eq(rhs))

    { return name() < rhs.name(); }

    return ns() < rhs.ns();

  }

  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 Attribute_Selector::operator== (const Simple_Selector& rhs) const

  {

    if (Attribute_Selector_Ptr_Const w = Cast<Attribute_Selector>(&rhs))

    {

      return is_ns_eq(rhs) &&

             name() == rhs.name() &&

             *this == *w;

    }

    return false;

  }

  bool Element_Selector::operator< (const Element_Selector& rhs) const

  {

    if (is_ns_eq(rhs))

    { return name() < rhs.name(); }

    return ns() < rhs.ns();

  }

  bool Element_Selector::operator< (const Simple_Selector& rhs) const

  {

    if (Element_Selector_Ptr_Const w = Cast<Element_Selector>(&rhs))

    {

      return *this < *w;

    }

    if (is_ns_eq(rhs))

    { return name() < rhs.name(); }

    return ns() < rhs.ns();

  }

  bool Element_Selector::operator== (const Element_Selector& rhs) const

  {

    return is_ns_eq(rhs) &&

           name() == rhs.name();

  }

  bool Element_Selector::operator== (const Simple_Selector& rhs) const

  {

    if (Element_Selector_Ptr_Const w = Cast<Element_Selector>(&rhs))

    {

      return is_ns_eq(rhs) &&

             name() == rhs.name() &&

             *this == *w;

    }

    return false;

  }

  bool Pseudo_Selector::operator== (const Pseudo_Selector& rhs) const

  {

    if (is_ns_eq(rhs) && name() == rhs.name())

    {

      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();

    }

    else return false;

  }

  bool Pseudo_Selector::operator== (const Simple_Selector& rhs) const

  {

    if (Pseudo_Selector_Ptr_Const w = Cast<Pseudo_Selector>(&rhs))

    {

      return *this == *w;

    }

    return is_ns_eq(rhs) &&

           name() == rhs.name();

  }

  bool Pseudo_Selector::operator< (const Pseudo_Selector& rhs) const

  {

    if (is_ns_eq(rhs) && name() == rhs.name())

    {

      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();

    }

    if (is_ns_eq(rhs))

    { return name() < rhs.name(); }

    return ns() < rhs.ns();

  }

  bool Pseudo_Selector::operator< (const Simple_Selector& rhs) const

  {

    if (Pseudo_Selector_Ptr_Const w = Cast<Pseudo_Selector>(&rhs))

    {

      return *this < *w;

    }

    if (is_ns_eq(rhs))

    { return name() < rhs.name(); }

    return ns() < rhs.ns();

  }

  bool Wrapped_Selector::operator== (const Wrapped_Selector& rhs) const

  {

    if (is_ns_eq(rhs) && name() == rhs.name())

    { return *(selector()) == *(rhs.selector()); }

    else return false;

  }

  bool Wrapped_Selector::operator== (const Simple_Selector& rhs) const

  {

    if (Wrapped_Selector_Ptr_Const w = Cast<Wrapped_Selector>(&rhs))

    {

      return *this == *w;

    }

    return is_ns_eq(rhs) &&

           name() == rhs.name();

  }

  bool Wrapped_Selector::operator< (const Wrapped_Selector& rhs) const

  {

    if (is_ns_eq(rhs) && name() == rhs.name())

    { return *(selector()) < *(rhs.selector()); }

    if (is_ns_eq(rhs))

    { return name() < rhs.name(); }

    return ns() < rhs.ns();

  }

  bool Wrapped_Selector::operator< (const Simple_Selector& rhs) const

  {

    if (Wrapped_Selector_Ptr_Const w = Cast<Wrapped_Selector>(&rhs))

    {

      return *this < *w;

    }

    if (is_ns_eq(rhs))

    { return name() < rhs.name(); }

    return ns() < rhs.ns();

  }

  bool Wrapped_Selector::is_superselector_of(Wrapped_Selector_Obj sub)

  {

    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);

      }

    }

    error("is_superselector expected a Selector_List", sub->pstate());

    return false;

  }

  bool Compound_Selector::is_superselector_of(Selector_List_Obj rhs, std::string wrapped)

  {

    for (Complex_Selector_Obj item : rhs->elements()) {

      if (is_superselector_of(item, wrapped)) return true;

    }

    return false;

  }

  bool Compound_Selector::is_superselector_of(Complex_Selector_Obj rhs, std::string wrapped)

  {

    if (rhs->head()) return is_superselector_of(rhs->head(), wrapped);

    return false;

  }

  bool Compound_Selector::is_superselector_of(Compound_Selector_Obj rhs, std::string wrapping)

  {

    Compound_Selector_Ptr lhs = this;

    Simple_Selector_Ptr lbase = lhs->base();

    Simple_Selector_Ptr rbase = rhs->base();

    // Check if pseudo-elements are the same between the selectors

    std::set<std::string> lpsuedoset, rpsuedoset;

    for (size_t i = 0, L = length(); i < L; ++i)

    {

      if ((*this)[i]->is_pseudo_element()) {

        std::string pseudo((*this)[i]->to_string());

        pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving

        lpsuedoset.insert(pseudo);

      }

    }

    for (size_t i = 0, L = rhs->length(); i < L; ++i)

    {

      if ((*rhs)[i]->is_pseudo_element()) {

        std::string pseudo((*rhs)[i]->to_string());

        pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving

        rpsuedoset.insert(pseudo);