sassc 2.0.0 → 2.4.0

data/ext/libsass/src/ast_sel_unify.cpp

@@ -0,0 +1,275 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast.hpp"
+
+namespace Sass {
+
+  // ##########################################################################
+  // Returns the contents of a [SelectorList] that matches only 
+  // elements that are matched by both [complex1] and [complex2].
+  // If no such list can be produced, returns `null`.
+  // ##########################################################################
+  // ToDo: fine-tune API to avoid unnecessary wrapper allocations
+  // ##########################################################################
+  sass::vector<sass::vector<SelectorComponentObj>> unifyComplex(
+    const sass::vector<sass::vector<SelectorComponentObj>>& complexes)
+  {
+
+    SASS_ASSERT(!complexes.empty(), "Can't unify empty list");
+    if (complexes.size() == 1) return complexes;
+
+    CompoundSelectorObj unifiedBase = SASS_MEMORY_NEW(CompoundSelector, SourceSpan("[phony]"));
+    for (auto complex : complexes) {
+      SelectorComponentObj base = complex.back();
+      if (CompoundSelector * comp = base->getCompound()) {
+        if (unifiedBase->empty()) {
+          unifiedBase->concat(comp);
+        }
+        else {
+          for (SimpleSelectorObj simple : comp->elements()) {
+            unifiedBase = simple->unifyWith(unifiedBase);
+            if (unifiedBase.isNull()) return {};
+          }
+        }
+      }
+      else {
+        return {};
+      }
+    }
+
+    sass::vector<sass::vector<SelectorComponentObj>> complexesWithoutBases;
+    for (size_t i = 0; i < complexes.size(); i += 1) {
+      sass::vector<SelectorComponentObj> sel = complexes[i];
+      sel.pop_back(); // remove last item (base) from the list
+      complexesWithoutBases.push_back(std::move(sel));
+    }
+
+    complexesWithoutBases.back().push_back(unifiedBase);
+
+    return weave(complexesWithoutBases);
+
+  }
+  // EO unifyComplex
+
+  // ##########################################################################
+  // Returns a [CompoundSelector] that matches only elements
+  // that are matched by both [compound1] and [compound2].
+  // If no such selector can be produced, returns `null`.
+  // ##########################################################################
+  CompoundSelector* CompoundSelector::unifyWith(CompoundSelector* rhs)
+  {
+    if (empty()) return rhs;
+    CompoundSelectorObj unified = SASS_MEMORY_COPY(rhs);
+    for (const SimpleSelectorObj& sel : elements()) {
+      unified = sel->unifyWith(unified);
+      if (unified.isNull()) break;
+    }
+    return unified.detach();
+  }
+  // EO CompoundSelector::unifyWith(CompoundSelector*)
+
+  // ##########################################################################
+  // Returns the compoments of a [CompoundSelector] that matches only elements
+  // matched by both this and [compound]. By default, this just returns a copy
+  // of [compound] with this selector added to the end, or returns the original
+  // array if this selector already exists in it. Returns `null` if unification
+  // is impossible—for example, if there are multiple ID selectors.
+  // ##########################################################################
+  // This is implemented in `selector/simple.dart` as `SimpleSelector::unify`
+  // ##########################################################################
+  CompoundSelector* SimpleSelector::unifyWith(CompoundSelector* rhs)
+  {
+
+    if (rhs->length() == 1) {
+      if (rhs->get(0)->is_universal()) {
+        CompoundSelector* this_compound = SASS_MEMORY_NEW(CompoundSelector, pstate());
+        this_compound->append(SASS_MEMORY_COPY(this));
+        CompoundSelector* unified = rhs->get(0)->unifyWith(this_compound);
+        if (unified == nullptr || unified != this_compound) delete this_compound;
+        return unified;
+      }
+    }
+    for (const SimpleSelectorObj& sel : rhs->elements()) {
+      if (*this == *sel) {
+        return rhs;
+      }
+    }
+
+    CompoundSelectorObj result = SASS_MEMORY_NEW(CompoundSelector, rhs->pstate());
+
+    bool addedThis = false;
+    for (auto simple : rhs->elements()) {
+      // Make sure pseudo selectors always come last.
+      if (!addedThis && simple->getPseudoSelector()) {
+        result->append(this);
+        addedThis = true;
+      }
+      result->append(simple);
+    }
+
+    if (!addedThis) {
+      result->append(this);
+    }
+    return result.detach();
+
+  }
+  // EO SimpleSelector::unifyWith(CompoundSelector*)
+
+  // ##########################################################################
+  // This is implemented in `selector/type.dart` as `PseudoSelector::unify`
+  // ##########################################################################
+  CompoundSelector* TypeSelector::unifyWith(CompoundSelector* rhs)
+  {
+    if (rhs->empty()) {
+      rhs->append(this);
+      return rhs;
+    }
+    TypeSelector* type = Cast<TypeSelector>(rhs->at(0));
+    if (type != nullptr) {
+      SimpleSelector* unified = unifyWith(type);
+      if (unified == nullptr) {
+        return nullptr;
+      }
+      rhs->elements()[0] = unified;
+    }
+    else if (!is_universal() || (has_ns_ && ns_ != "*")) {
+      rhs->insert(rhs->begin(), this);
+    }
+    return rhs;
+  }
+
+  // ##########################################################################
+  // This is implemented in `selector/id.dart` as `PseudoSelector::unify`
+  // ##########################################################################
+  CompoundSelector* IDSelector::unifyWith(CompoundSelector* rhs)
+  {
+    for (const SimpleSelector* sel : rhs->elements()) {
+      if (const IDSelector* id_sel = Cast<IDSelector>(sel)) {
+        if (id_sel->name() != name()) return nullptr;
+      }
+    }
+    return SimpleSelector::unifyWith(rhs);
+  }
+
+  // ##########################################################################
+  // This is implemented in `selector/pseudo.dart` as `PseudoSelector::unify`
+  // ##########################################################################
+  CompoundSelector* PseudoSelector::unifyWith(CompoundSelector* compound)
+  {
+
+    if (compound->length() == 1 && compound->first()->is_universal()) {
+      // std::cerr << "implement universal pseudo\n";
+    }
+
+    for (const SimpleSelectorObj& sel : compound->elements()) {
+      if (*this == *sel) {
+        return compound;
+      }
+    }
+
+    CompoundSelectorObj result = SASS_MEMORY_NEW(CompoundSelector, compound->pstate());
+
+    bool addedThis = false;
+    for (auto simple : compound->elements()) {
+      // Make sure pseudo selectors always come last.
+      if (PseudoSelectorObj pseudo = simple->getPseudoSelector()) {
+        if (pseudo->isElement()) {
+          // A given compound selector may only contain one pseudo element. If
+          // [compound] has a different one than [this], unification fails.
+          if (isElement()) {
+            return {};
+          }
+          // Otherwise, this is a pseudo selector and
+          // should come before pseduo elements.
+          result->append(this);
+          addedThis = true;
+        }
+      }
+      result->append(simple);
+    }
+
+    if (!addedThis) {
+      result->append(this);
+    }
+
+    return result.detach();
+
+  }
+  // EO PseudoSelector::unifyWith(CompoundSelector*
+
+  // ##########################################################################
+  // This is implemented in `extend/functions.dart` as `unifyUniversalAndElement`
+  // Returns a [SimpleSelector] that matches only elements that are matched by
+  // both [selector1] and [selector2], which must both be either [UniversalSelector]s
+  // or [TypeSelector]s. If no such selector can be produced, returns `null`.
+  // Note: libsass handles universal selector directly within the type selector
+  // ##########################################################################
+  SimpleSelector* TypeSelector::unifyWith(const SimpleSelector* rhs)
+  {
+    bool rhs_ns = false;
+    if (!(is_ns_eq(*rhs) || rhs->is_universal_ns())) {
+      if (!is_universal_ns()) {
+        return nullptr;
+      }
+      rhs_ns = true;
+    }
+    bool rhs_name = false;
+    if (!(name_ == rhs->name() || rhs->is_universal())) {
+      if (!(is_universal())) {
+        return nullptr;
+      }
+      rhs_name = true;
+    }
+    if (rhs_ns) {
+      ns(rhs->ns());
+      has_ns(rhs->has_ns());
+    }
+    if (rhs_name) name(rhs->name());
+    return this;
+  }
+  // EO TypeSelector::unifyWith(const SimpleSelector*)
+
+  // ##########################################################################
+  // Unify two complex selectors. Internally calls `unifyComplex`
+  // and then wraps the result in newly create ComplexSelectors.
+  // ##########################################################################
+  SelectorList* ComplexSelector::unifyWith(ComplexSelector* rhs)
+  {
+    SelectorListObj list = SASS_MEMORY_NEW(SelectorList, pstate());
+    sass::vector<sass::vector<SelectorComponentObj>> rv =
+       unifyComplex({ elements(), rhs->elements() });
+    for (sass::vector<SelectorComponentObj> items : rv) {
+      ComplexSelectorObj sel = SASS_MEMORY_NEW(ComplexSelector, pstate());
+      sel->elements() = std::move(items);
+      list->append(sel);
+    }
+    return list.detach();
+  }
+  // EO ComplexSelector::unifyWith(ComplexSelector*)
+
+  // ##########################################################################
+  // only called from the sass function `selector-unify`
+  // ##########################################################################
+  SelectorList* SelectorList::unifyWith(SelectorList* rhs)
+  {
+    SelectorList* slist = SASS_MEMORY_NEW(SelectorList, pstate());
+    // Unify all of children with RHS's children,
+    // storing the results in `unified_complex_selectors`
+    for (ComplexSelectorObj& seq1 : elements()) {
+      for (ComplexSelectorObj& seq2 : rhs->elements()) {
+        if (SelectorListObj unified = seq1->unifyWith(seq2)) {
+          std::move(unified->begin(), unified->end(),
+            std::inserter(slist->elements(), slist->end()));
+        }
+      }
+    }
+    return slist;
+  }
+  // EO SelectorList::unifyWith(SelectorList*)
+
+  // ##########################################################################
+  // ##########################################################################
+
+}

data/ext/libsass/src/ast_sel_weave.cpp

@@ -0,0 +1,616 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast.hpp"
+#include "permutate.hpp"
+#include "dart_helpers.hpp"
+
+namespace Sass {
+
+  // ##########################################################################
+  // Returns whether or not [compound] contains a `::root` selector.
+  // ##########################################################################
+  bool hasRoot(const CompoundSelector* compound)
+  {
+    // Libsass does not yet know the root selector
+    return false;
+  }
+  // EO hasRoot
+
+  // ##########################################################################
+  // Returns whether a [CompoundSelector] may contain only
+  // one simple selector of the same type as [simple].
+  // ##########################################################################
+  bool isUnique(const SimpleSelector* simple)
+  {
+    if (Cast<IDSelector>(simple)) return true;
+    if (const PseudoSelector * pseudo = Cast<PseudoSelector>(simple)) {
+      if (pseudo->is_pseudo_element()) return true;
+    }
+    return false;
+  }
+  // EO isUnique
+
+  // ##########################################################################
+  // Returns whether [complex1] and [complex2] need to be unified to
+  // produce a valid combined selector. This is necessary when both
+  // selectors contain the same unique simple selector, such as an ID.
+  // ##########################################################################
+  bool mustUnify(
+    const sass::vector<SelectorComponentObj>& complex1,
+    const sass::vector<SelectorComponentObj>& complex2)
+  {
+
+    sass::vector<const SimpleSelector*> uniqueSelectors1;
+    for (const SelectorComponent* component : complex1) {
+      if (const CompoundSelector * compound = component->getCompound()) {
+        for (const SimpleSelector* sel : compound->elements()) {
+          if (isUnique(sel)) {
+            uniqueSelectors1.push_back(sel);
+          }
+        }
+      }
+    }
+    if (uniqueSelectors1.empty()) return false;
+
+    // ToDo: unsure if this is correct
+    for (const SelectorComponent* component : complex2) {
+      if (const CompoundSelector * compound = component->getCompound()) {
+        for (const SimpleSelector* sel : compound->elements()) {
+          if (isUnique(sel)) {
+            for (auto check : uniqueSelectors1) {
+              if (*check == *sel) return true;
+            }
+          }
+        }
+      }
+    }
+
+    return false;
+
+  }
+  // EO isUnique
+
+  // ##########################################################################
+  // Helper function used by `weaveParents`
+  // ##########################################################################
+  bool cmpGroups(
+    const sass::vector<SelectorComponentObj>& group1,
+    const sass::vector<SelectorComponentObj>& group2,
+    sass::vector<SelectorComponentObj>& select)
+  {
+
+    if (group1.size() == group2.size() && std::equal(group1.begin(), group1.end(), group2.begin(), PtrObjEqualityFn<SelectorComponent>)) {
+      select = group1;
+      return true;
+    }
+
+    if (!Cast<CompoundSelector>(group1.front())) {
+      select = {};
+      return false;
+    }
+    if (!Cast<CompoundSelector>(group2.front())) {
+      select = {};
+      return false;
+    }
+
+    if (complexIsParentSuperselector(group1, group2)) {
+      select = group2;
+      return true;
+    }
+    if (complexIsParentSuperselector(group2, group1)) {
+      select = group1;
+      return true;
+    }
+
+    if (!mustUnify(group1, group2)) {
+      select = {};
+      return false;
+    }
+
+    sass::vector<sass::vector<SelectorComponentObj>> unified
+      = unifyComplex({ group1, group2 });
+    if (unified.empty()) return false;
+    if (unified.size() > 1) return false;
+    select = unified.front();
+    return true;
+  }
+  // EO cmpGroups
+
+  // ##########################################################################
+  // Helper function used by `weaveParents`
+  // ##########################################################################
+  template <class T>
+  bool checkForEmptyChild(const T& item) {
+    return item.empty();
+  }
+  // EO checkForEmptyChild
+
+  // ##########################################################################
+  // Helper function used by `weaveParents`
+  // ##########################################################################
+  bool cmpChunkForEmptySequence(
+    const sass::vector<sass::vector<SelectorComponentObj>>& seq,
+    const sass::vector<SelectorComponentObj>& group)
+  {
+    return seq.empty();
+  }
+  // EO cmpChunkForEmptySequence
+
+  // ##########################################################################
+  // Helper function used by `weaveParents`
+  // ##########################################################################
+  bool cmpChunkForParentSuperselector(
+    const sass::vector<sass::vector<SelectorComponentObj>>& seq,
+    const sass::vector<SelectorComponentObj>& group)
+  {
+    return seq.empty() || complexIsParentSuperselector(seq.front(), group);
+  }
+   // EO cmpChunkForParentSuperselector
+
+  // ##########################################################################
+  // Returns all orderings of initial subseqeuences of [queue1] and [queue2].
+  // The [done] callback is used to determine the extent of the initial
+  // subsequences. It's called with each queue until it returns `true`.
+  // Destructively removes the initial subsequences of [queue1] and [queue2].
+  // For example, given `(A B C | D E)` and `(1 2 | 3 4 5)` (with `|` denoting
+  // the boundary of the initial subsequence), this would return `[(A B C 1 2),
+  // (1 2 A B C)]`. The queues would then contain `(D E)` and `(3 4 5)`.
+  // ##########################################################################
+  template <class T>
+  sass::vector<sass::vector<T>> getChunks(
+    sass::vector<T>& queue1, sass::vector<T>& queue2,
+    const T& group, bool(*done)(const sass::vector<T>&, const T&)
+  ) {
+
+    sass::vector<T> chunk1;
+    while (!done(queue1, group)) {
+      chunk1.push_back(queue1.front());
+      queue1.erase(queue1.begin());
+    }
+
+    sass::vector<T> chunk2;
+    while (!done(queue2, group)) {
+      chunk2.push_back(queue2.front());
+      queue2.erase(queue2.begin());
+    }
+
+    if (chunk1.empty() && chunk2.empty()) return {};
+    else if (chunk1.empty()) return { chunk2 };
+    else if (chunk2.empty()) return { chunk1 };
+
+    sass::vector<T> choice1(chunk1), choice2(chunk2);
+    std::move(std::begin(chunk2), std::end(chunk2),
+      std::inserter(choice1, std::end(choice1)));
+    std::move(std::begin(chunk1), std::end(chunk1),
+      std::inserter(choice2, std::end(choice2)));
+    return { choice1, choice2 };
+  }
+  // EO getChunks
+
+  // ##########################################################################
+  // If the first element of [queue] has a `::root` 
+  // selector, removes and returns that element.
+  // ##########################################################################
+  CompoundSelectorObj getFirstIfRoot(sass::vector<SelectorComponentObj>& queue) {
+    if (queue.empty()) return {};
+    SelectorComponent* first = queue.front();
+    if (CompoundSelector* sel = Cast<CompoundSelector>(first)) {
+      if (!hasRoot(sel)) return {};
+      queue.erase(queue.begin());
+      return sel;
+    }
+    return {};
+  }
+  // EO getFirstIfRoot
+
+  // ##########################################################################
+  // Returns [complex], grouped into sub-lists such that no sub-list
+  // contains two adjacent [ComplexSelector]s. For example,
+  // `(A B > C D + E ~ > G)` is grouped into `[(A) (B > C) (D + E ~ > G)]`.
+  // ##########################################################################
+  sass::vector<sass::vector<SelectorComponentObj>> groupSelectors(
+    const sass::vector<SelectorComponentObj>& components)
+  {
+    bool lastWasCompound = false;
+    sass::vector<SelectorComponentObj> group;
+    sass::vector<sass::vector<SelectorComponentObj>> groups;
+    for (size_t i = 0; i < components.size(); i += 1) {
+      if (CompoundSelector* compound = components[i]->getCompound()) {
+        if (lastWasCompound) {
+          groups.push_back(group);
+          group.clear();
+        }
+        group.push_back(compound);
+        lastWasCompound = true;
+      }
+      else if (SelectorCombinator* combinator = components[i]->getCombinator()) {
+        group.push_back(combinator);
+        lastWasCompound = false;
+      }
+    }
+    if (!group.empty()) {
+      groups.push_back(group);
+    }
+    return groups;
+  }
+  // EO groupSelectors
+
+  // ##########################################################################
+  // Extracts leading [Combinator]s from [components1] and [components2]
+  // and merges them together into a single list of combinators.
+  // If there are no combinators to be merged, returns an empty list.
+  // If the combinators can't be merged, returns `null`.
+  // ##########################################################################
+  bool mergeInitialCombinators(
+    sass::vector<SelectorComponentObj>& components1,
+    sass::vector<SelectorComponentObj>& components2,
+    sass::vector<SelectorComponentObj>& result)
+  {
+
+    sass::vector<SelectorComponentObj> combinators1;
+    while (!components1.empty() && Cast<SelectorCombinator>(components1.front())) {
+      SelectorCombinatorObj front = Cast<SelectorCombinator>(components1.front());
+      components1.erase(components1.begin());
+      combinators1.push_back(front);
+    }
+
+    sass::vector<SelectorComponentObj> combinators2;
+    while (!components2.empty() && Cast<SelectorCombinator>(components2.front())) {
+      SelectorCombinatorObj front = Cast<SelectorCombinator>(components2.front());
+      components2.erase(components2.begin());
+      combinators2.push_back(front);
+    }
+
+    // If neither sequence of combinators is a subsequence
+    // of the other, they cannot be merged successfully.
+    sass::vector<SelectorComponentObj> LCS = lcs<SelectorComponentObj>(combinators1, combinators2);
+
+    if (ListEquality(LCS, combinators1, PtrObjEqualityFn<SelectorComponent>)) {
+      result = combinators2;
+      return true;
+    }
+    if (ListEquality(LCS, combinators2, PtrObjEqualityFn<SelectorComponent>)) {
+      result = combinators1;
+      return true;
+    }
+
+    return false;
+
+  }
+  // EO mergeInitialCombinators
+
+  // ##########################################################################
+  // Extracts trailing [Combinator]s, and the selectors to which they apply,
+  // from [components1] and [components2] and merges them together into a
+  // single list. If there are no combinators to be merged, returns an
+  // empty list. If the sequences can't be merged, returns `null`.
+  // ##########################################################################
+  bool mergeFinalCombinators(
+    sass::vector<SelectorComponentObj>& components1,
+    sass::vector<SelectorComponentObj>& components2,
+    sass::vector<sass::vector<sass::vector<SelectorComponentObj>>>& result)
+  {
+
+    if (components1.empty() || !Cast<SelectorCombinator>(components1.back())) {
+      if (components2.empty() || !Cast<SelectorCombinator>(components2.back())) {
+        return true;
+      }
+    }
+    
+    sass::vector<SelectorComponentObj> combinators1;
+    while (!components1.empty() && Cast<SelectorCombinator>(components1.back())) {
+      SelectorCombinatorObj back = Cast<SelectorCombinator>(components1.back());
+      components1.erase(components1.end() - 1);
+      combinators1.push_back(back);
+    }
+
+    sass::vector<SelectorComponentObj> combinators2;
+    while (!components2.empty() && Cast<SelectorCombinator>(components2.back())) {
+      SelectorCombinatorObj back = Cast<SelectorCombinator>(components2.back());
+      components2.erase(components2.end() - 1);
+      combinators2.push_back(back);
+    }
+
+    // reverse now as we used push_back (faster than new alloc)
+    std::reverse(combinators1.begin(), combinators1.end());
+    std::reverse(combinators2.begin(), combinators2.end());
+
+    if (combinators1.size() > 1 || combinators2.size() > 1) {
+      // If there are multiple combinators, something hacky's going on. If one
+      // is a supersequence of the other, use that, otherwise give up.
+      auto LCS = lcs<SelectorComponentObj>(combinators1, combinators2);
+      if (ListEquality(LCS, combinators1, PtrObjEqualityFn<SelectorComponent>)) {
+        result.push_back({ combinators2 });
+      }
+      else if (ListEquality(LCS, combinators2, PtrObjEqualityFn<SelectorComponent>)) {
+        result.push_back({ combinators1 });
+      }
+      else {
+        return false;
+      }
+      return true;
+    }
+
+    // This code looks complicated, but it's actually just a bunch of special
+    // cases for interactions between different combinators.
+    SelectorCombinatorObj combinator1, combinator2;
+    if (!combinators1.empty()) combinator1 = combinators1.back();
+    if (!combinators2.empty()) combinator2 = combinators2.back();
+
+    if (!combinator1.isNull() && !combinator2.isNull()) {
+
+      CompoundSelector* compound1 = Cast<CompoundSelector>(components1.back());
+      CompoundSelector* compound2 = Cast<CompoundSelector>(components2.back());
+
+      components1.pop_back();
+      components2.pop_back();
+
+      if (combinator1->isGeneralCombinator() && combinator2->isGeneralCombinator()) {
+
+        if (compound1->isSuperselectorOf(compound2)) {
+          result.push_back({ { compound2, combinator2 } });
+        }
+        else if (compound2->isSuperselectorOf(compound1)) {
+          result.push_back({ { compound1, combinator1 } });
+        }
+        else {
+          sass::vector<sass::vector<SelectorComponentObj>> choices;
+          choices.push_back({ compound1, combinator1, compound2, combinator2 });
+          choices.push_back({ compound2, combinator2, compound1, combinator1 });
+          if (CompoundSelector* unified = compound1->unifyWith(compound2)) {
+            choices.push_back({ unified, combinator1 });
+          }
+          result.push_back(choices);
+        }
+      }
+      else if ((combinator1->isGeneralCombinator() && combinator2->isAdjacentCombinator()) ||
+        (combinator1->isAdjacentCombinator() && combinator2->isGeneralCombinator())) {
+
+        CompoundSelector* followingSiblingSelector = combinator1->isGeneralCombinator() ? compound1 : compound2;
+        CompoundSelector* nextSiblingSelector = combinator1->isGeneralCombinator() ? compound2 : compound1;
+        SelectorCombinator* followingSiblingCombinator = combinator1->isGeneralCombinator() ? combinator1 : combinator2;
+        SelectorCombinator* nextSiblingCombinator = combinator1->isGeneralCombinator() ? combinator2 : combinator1;
+
+        if (followingSiblingSelector->isSuperselectorOf(nextSiblingSelector)) {
+          result.push_back({ { nextSiblingSelector, nextSiblingCombinator } });
+        }
+        else {
+          CompoundSelectorObj unified = compound1->unifyWith(compound2);
+          sass::vector<sass::vector<SelectorComponentObj>> items;
+          
+          if (!unified.isNull()) {
+            items.push_back({
+              unified, nextSiblingCombinator
+            });
+          }
+
+          items.insert(items.begin(), {
+            followingSiblingSelector,
+            followingSiblingCombinator,
+            nextSiblingSelector,
+            nextSiblingCombinator,
+          });
+
+          result.push_back(items);
+        }
+
+      }
+      else if (combinator1->isChildCombinator() && (combinator2->isAdjacentCombinator() || combinator2->isGeneralCombinator())) {
+        result.push_back({ { compound2, combinator2 } });
+        components1.push_back(compound1);
+        components1.push_back(combinator1);
+      }
+      else if (combinator2->isChildCombinator() && (combinator1->isAdjacentCombinator() || combinator1->isGeneralCombinator())) {
+        result.push_back({ { compound1, combinator1 } });
+        components2.push_back(compound2);
+        components2.push_back(combinator2);
+      }
+      else if (*combinator1 == *combinator2) {
+        CompoundSelectorObj unified = compound1->unifyWith(compound2);
+        if (unified.isNull()) return false;
+        result.push_back({ { unified, combinator1 } });
+      }
+      else {
+        return false;
+      }
+
+      return mergeFinalCombinators(components1, components2, result);
+
+    }
+    else if (!combinator1.isNull()) {
+
+      if (combinator1->isChildCombinator() && !components2.empty()) {
+        const CompoundSelector* back1 = Cast<CompoundSelector>(components1.back());
+        const CompoundSelector* back2 = Cast<CompoundSelector>(components2.back());
+        if (back1 && back2 && back2->isSuperselectorOf(back1)) {
+          components2.pop_back();
+        }
+      }
+
+      result.push_back({ { components1.back(), combinator1 } });
+
+      components1.pop_back();
+
+      return mergeFinalCombinators(components1, components2, result);
+
+    }
+
+    if (combinator2->isChildCombinator() && !components1.empty()) {
+      const CompoundSelector* back1 = Cast<CompoundSelector>(components1.back());
+      const CompoundSelector* back2 = Cast<CompoundSelector>(components2.back());
+      if (back1 && back2 && back1->isSuperselectorOf(back2)) {
+        components1.pop_back();
+      }
+    }
+
+    result.push_back({ { components2.back(), combinator2 } });
+
+    components2.pop_back();
+
+    return mergeFinalCombinators(components1, components2, result);
+
+  }
+  // EO mergeFinalCombinators
+
+  // ##########################################################################
+  // Expands "parenthesized selectors" in [complexes]. That is, if
+  // we have `.A .B {@extend .C}` and `.D .C {...}`, this conceptually
+  // expands into `.D .C, .D (.A .B)`, and this function translates
+  // `.D (.A .B)` into `.D .A .B, .A .D .B`. For thoroughness, `.A.D .B`
+  // would also be required, but including merged selectors results in
+  // exponential output for very little gain. The selector `.D (.A .B)`
+  // is represented as the list `[[.D], [.A, .B]]`.
+  // ##########################################################################
+  sass::vector<sass::vector<SelectorComponentObj>> weave(
+    const sass::vector<sass::vector<SelectorComponentObj>>& complexes) {
+
+    sass::vector<sass::vector<SelectorComponentObj>> prefixes;
+
+    prefixes.push_back(complexes.at(0));
+
+    for (size_t i = 1; i < complexes.size(); i += 1) {
+
+      if (complexes[i].empty()) {
+        continue;
+      }
+      const sass::vector<SelectorComponentObj>& complex = complexes[i];
+      SelectorComponent* target = complex.back();
+      if (complex.size() == 1) {
+        for (auto& prefix : prefixes) {
+          prefix.push_back(target);
+        }
+        continue;
+      }
+
+      sass::vector<SelectorComponentObj> parents(complex);
+
+      parents.pop_back();
+
+      sass::vector<sass::vector<SelectorComponentObj>> newPrefixes;
+      for (sass::vector<SelectorComponentObj> prefix : prefixes) {
+        sass::vector<sass::vector<SelectorComponentObj>>
+          parentPrefixes = weaveParents(prefix, parents);
+        if (parentPrefixes.empty()) continue;
+        for (auto& parentPrefix : parentPrefixes) {
+          parentPrefix.push_back(target);
+          newPrefixes.push_back(parentPrefix);
+        }
+      }
+      prefixes = newPrefixes;
+
+    }
+    return prefixes;
+
+  }
+  // EO weave
+
+  // ##########################################################################
+  // Interweaves [parents1] and [parents2] as parents of the same target
+  // selector. Returns all possible orderings of the selectors in the
+  // inputs (including using unification) that maintain the relative
+  // ordering of the input. For example, given `.foo .bar` and `.baz .bang`,
+  // this would return `.foo .bar .baz .bang`, `.foo .bar.baz .bang`,
+  // `.foo .baz .bar .bang`, `.foo .baz .bar.bang`, `.foo .baz .bang .bar`,
+  // and so on until `.baz .bang .foo .bar`. Semantically, for selectors A
+  // and B, this returns all selectors `AB_i` such that the union over all i
+  // of elements matched by `AB_i X` is identical to the intersection of all
+  // elements matched by `A X` and all elements matched by `B X`. Some `AB_i`
+  // are elided to reduce the size of the output.
+  // ##########################################################################
+  sass::vector<sass::vector<SelectorComponentObj>> weaveParents(
+    sass::vector<SelectorComponentObj> queue1,
+    sass::vector<SelectorComponentObj> queue2)
+  {
+
+    sass::vector<SelectorComponentObj> leads;
+    sass::vector<sass::vector<sass::vector<SelectorComponentObj>>> trails;
+    if (!mergeInitialCombinators(queue1, queue2, leads)) return {};
+    if (!mergeFinalCombinators(queue1, queue2, trails)) return {};
+    // list comes out in reverse order for performance
+    std::reverse(trails.begin(), trails.end());
+
+    // Make sure there's at most one `:root` in the output.
+    // Note: does not yet do anything in libsass (no root selector)
+    CompoundSelectorObj root1 = getFirstIfRoot(queue1);
+    CompoundSelectorObj root2 = getFirstIfRoot(queue2);
+
+    if (!root1.isNull() && !root2.isNull()) {
+      CompoundSelectorObj root = root1->unifyWith(root2);
+      if (root.isNull()) return {}; // null
+      queue1.insert(queue1.begin(), root);
+      queue2.insert(queue2.begin(), root);
+    }
+    else if (!root1.isNull()) {
+      queue2.insert(queue2.begin(), root1);
+    }
+    else if (!root2.isNull()) {
+      queue1.insert(queue1.begin(), root2);
+    }
+
+    // group into sub-lists so no sub-list contains two adjacent ComplexSelectors.
+    sass::vector<sass::vector<SelectorComponentObj>> groups1 = groupSelectors(queue1);
+    sass::vector<sass::vector<SelectorComponentObj>> groups2 = groupSelectors(queue2);
+
+    // The main array to store our choices that will be permutated
+    sass::vector<sass::vector<sass::vector<SelectorComponentObj>>> choices;
+
+    // append initial combinators
+    choices.push_back({ leads });
+
+    sass::vector<sass::vector<SelectorComponentObj>> LCS =
+      lcs<sass::vector<SelectorComponentObj>>(groups1, groups2, cmpGroups);
+
+    for (auto group : LCS) {
+
+      // Create junks from groups1 and groups2
+      sass::vector<sass::vector<sass::vector<SelectorComponentObj>>>
+        chunks = getChunks<sass::vector<SelectorComponentObj>>(
+          groups1, groups2, group, cmpChunkForParentSuperselector);
+
+      // Create expanded array by flattening chunks2 inner
+      sass::vector<sass::vector<SelectorComponentObj>>
+        expanded = flattenInner(chunks);
+
+      // Prepare data structures
+      choices.push_back(expanded);
+      choices.push_back({ group });
+      if (!groups1.empty()) {
+        groups1.erase(groups1.begin());
+      }
+      if (!groups2.empty()) {
+        groups2.erase(groups2.begin());
+      }
+
+    }
+
+    // Create junks from groups1 and groups2
+    sass::vector<sass::vector<sass::vector<SelectorComponentObj>>>
+      chunks = getChunks<sass::vector<SelectorComponentObj>>(
+        groups1, groups2, {}, cmpChunkForEmptySequence);
+
+    // Append chunks with inner arrays flattened
+    choices.emplace_back(flattenInner(chunks));
+
+    // append all trailing selectors to choices
+    std::move(std::begin(trails), std::end(trails),
+      std::inserter(choices, std::end(choices)));
+
+    // move all non empty items to the front, then erase the trailing ones
+    choices.erase(std::remove_if(choices.begin(), choices.end(), checkForEmptyChild
+      <sass::vector<sass::vector<SelectorComponentObj>>>), choices.end());
+
+    // permutate all possible paths through selectors
+    sass::vector<sass::vector<SelectorComponentObj>>
+      results = flattenInner(permutate(choices));
+
+    return results;
+
+  }
+  // EO weaveParents
+
+  // ##########################################################################
+  // ##########################################################################
+
+}