sassc 0.0.1

data/ext/libsass/node.hpp

@@ -0,0 +1,122 @@
+#define SASS_NODE
+
+
+#include <deque>
+#include <iostream>
+#include <memory>
+
+#ifndef SASS_AST
+#include "ast.hpp"
+#endif
+
+
+namespace Sass {
+
+  
+  using namespace std;
+
+
+  struct Context;
+
+  /*
+   There are a lot of stumbling blocks when trying to port the ruby extend code to C++. The biggest is the choice of
+   data type. The ruby code will pretty seamlessly switch types between an Array<SimpleSequence or Op> (libsass'
+   equivalent is the Complex_Selector) to a Sequence, which contains more metadata about the sequence than just the
+   selector info. They also have the ability to have arbitrary nestings of arrays like [1, [2]], which is hard to
+   implement using Array equivalents in C++ (like the deque or vector). They also have the ability to include nil
+   in the arrays, like [1, nil, 3], which has potential semantic differences than an empty array [1, [], 3]. To be
+   able to represent all of these as unique cases, we need to create a tree of variant objects. The tree nature allows
+   the inconsistent nesting levels. The variant nature (while making some of the C++ code uglier) allows the code to
+   more closely match the ruby code, which is a huge benefit when attempting to implement an complex algorithm like
+   the Extend operator.
+   
+   Note that the current libsass data model also pairs the combinator with the Complex_Selector that follows it, but
+   ruby sass has no such restriction, so we attempt to create a data structure that can handle them split apart.
+   */
+  
+  class Node;
+  typedef deque<Node> NodeDeque;
+  typedef shared_ptr<NodeDeque> NodeDequePtr;
+
+  class Node {
+  public:
+    enum TYPE {
+      SELECTOR,
+      COMBINATOR,
+      COLLECTION,
+      NIL
+    };
+
+		TYPE type() const { return mType; }
+    bool isCombinator() const { return mType == COMBINATOR; }
+    bool isSelector() const { return mType == SELECTOR; }
+    bool isCollection() const { return mType == COLLECTION; }
+    bool isNil() const { return mType == NIL; }
+    
+    Complex_Selector::Combinator combinator() const { return mCombinator; }
+    
+    Complex_Selector* selector() { return mpSelector; }
+    const Complex_Selector* selector() const { return mpSelector; }
+    
+    NodeDequePtr collection() { return mpCollection; }
+    const NodeDequePtr collection() const { return mpCollection; }
+    
+    static Node createCombinator(const Complex_Selector::Combinator& combinator);
+
+    // This method will clone the selector, stripping off the tail and combinator
+    static Node createSelector(Complex_Selector* pSelector, Context& ctx);
+    
+    static Node createCollection();
+    static Node createCollection(const NodeDeque& values);
+
+    static Node createNil();
+    
+    Node clone(Context& ctx) const;
+    
+    bool operator==(const Node& rhs) const;
+    inline bool operator!=(const Node& rhs) const { return !(*this == rhs); }
+    
+    
+    /*
+    COLLECTION FUNCTIONS
+    
+    Most types don't need any helper methods (nil and combinator due to their simplicity and
+    selector due to the fact that we leverage the non-node selector code on the Complex_Selector
+    whereever possible). The following methods are intended to be called on Node objects whose
+    type is COLLECTION only.
+    */
+    
+    // rhs and this must be node collections. Shallow copy the nodes from rhs to the end of this.
+    // This function DOES NOT remove the nodes from rhs.
+    void plus(Node& rhs);
+    
+    // potentialChild must be a node collection of selectors/combinators. this must be a collection
+    // of collections of nodes/combinators. This method checks if potentialChild is a child of this
+    // Node.
+    bool contains(const Node& potentialChild, bool simpleSelectorOrderDependent) const;
+    
+  private:
+    // Private constructor; Use the static methods (like createCombinator and createSelector)
+    // to instantiate this object. This is more expressive, and it allows us to break apart each
+    // case into separate functions.
+    Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector* pSelector, NodeDequePtr& pCollection);
+
+    TYPE mType;
+    
+    // TODO: can we union these to save on memory?
+    Complex_Selector::Combinator mCombinator;
+    Complex_Selector* mpSelector; // this is an AST_Node, so it will be handled by the Memory_Manager
+    NodeDequePtr mpCollection;
+  };
+  
+  
+  ostream& operator<<(ostream& os, const Node& node);
+  
+
+  Node complexSelectorToNode(Complex_Selector* pToConvert, Context& ctx);
+  Complex_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx);
+
+  
+  bool nodesEqual(const Node& one, const Node& two, bool simpleSelectorOrderDependent);
+
+}

data/ext/libsass/operation.hpp

@@ -0,0 +1,153 @@
+#define SASS_OPERATION
+
+#include "ast_fwd_decl.hpp"
+
+#include <iostream>
+using namespace std;
+#include <typeinfo>
+
+namespace Sass {
+
+  template<typename T>
+  class Operation {
+  public:
+    virtual T operator()(AST_Node* x)               = 0;
+    virtual ~Operation()                            { }
+    // statements
+    virtual T operator()(Block* x)                  = 0;
+    virtual T operator()(Ruleset* x)                = 0;
+    virtual T operator()(Propset* x)                = 0;
+    virtual T operator()(Feature_Block* x)          = 0;
+    virtual T operator()(Media_Block* x)            = 0;
+    virtual T operator()(At_Rule* x)                = 0;
+    virtual T operator()(Declaration* x)            = 0;
+    virtual T operator()(Assignment* x)             = 0;
+    virtual T operator()(Import* x)                 = 0;
+    virtual T operator()(Import_Stub* x)            = 0;
+    virtual T operator()(Warning* x)                = 0;
+    virtual T operator()(Error* x)                  = 0;
+    virtual T operator()(Debug* x)                  = 0;
+    virtual T operator()(Comment* x)                = 0;
+    virtual T operator()(If* x)                     = 0;
+    virtual T operator()(For* x)                    = 0;
+    virtual T operator()(Each* x)                   = 0;
+    virtual T operator()(While* x)                  = 0;
+    virtual T operator()(Return* x)                 = 0;
+    virtual T operator()(Content* x)                = 0;
+    virtual T operator()(Extension* x)              = 0;
+    virtual T operator()(Definition* x)             = 0;
+    virtual T operator()(Mixin_Call* x)             = 0;
+    // expressions
+    virtual T operator()(List* x)                   = 0;
+    virtual T operator()(Map* x)                    = 0;
+    virtual T operator()(Binary_Expression* x)      = 0;
+    virtual T operator()(Unary_Expression* x)       = 0;
+    virtual T operator()(Function_Call* x)          = 0;
+    virtual T operator()(Function_Call_Schema* x)   = 0;
+    virtual T operator()(Variable* x)               = 0;
+    virtual T operator()(Textual* x)                = 0;
+    virtual T operator()(Number* x)                 = 0;
+    virtual T operator()(Color* x)                  = 0;
+    virtual T operator()(Boolean* x)                = 0;
+    virtual T operator()(String_Schema* x)          = 0;
+    virtual T operator()(String_Constant* x)        = 0;
+    virtual T operator()(Feature_Query* x)          = 0;
+    virtual T operator()(Feature_Query_Condition* x)= 0;
+    virtual T operator()(Media_Query* x)            = 0;
+    virtual T operator()(Media_Query_Expression* x) = 0;
+    virtual T operator()(Null* x)                   = 0;
+    // parameters and arguments
+    virtual T operator()(Parameter* x)              = 0;
+    virtual T operator()(Parameters* x)             = 0;
+    virtual T operator()(Argument* x)               = 0;
+    virtual T operator()(Arguments* x)              = 0;
+    // selectors
+    virtual T operator()(Selector_Schema* x)        = 0;
+    virtual T operator()(Selector_Reference* x)     = 0;
+    virtual T operator()(Selector_Placeholder* x)   = 0;
+    virtual T operator()(Type_Selector* x)          = 0;
+    virtual T operator()(Selector_Qualifier* x)     = 0;
+    virtual T operator()(Attribute_Selector* x)     = 0;
+    virtual T operator()(Pseudo_Selector* x)        = 0;
+    virtual T operator()(Wrapped_Selector* x)       = 0;
+    virtual T operator()(Compound_Selector* x)      = 0;
+    virtual T operator()(Complex_Selector* x)       = 0;
+    virtual T operator()(Selector_List* x)          = 0;
+
+    template <typename U>
+    T fallback(U x) { return T(); }
+  };
+
+  template <typename T, typename D>
+  class Operation_CRTP : public Operation<T> {
+  public:
+    virtual T operator()(AST_Node* x)               { return static_cast<D*>(this)->fallback(x); }
+    virtual ~Operation_CRTP()                       = 0;
+    // statements
+    virtual T operator()(Block* x)                  { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Ruleset* x)                { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Propset* x)                { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Feature_Block* x)          { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Media_Block* x)            { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(At_Rule* x)                { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Declaration* x)            { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Assignment* x)             { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Import* x)                 { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Import_Stub* x)            { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Warning* x)                { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Error* x)                  { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Debug* x)                  { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Comment* x)                { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(If* x)                     { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(For* x)                    { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Each* x)                   { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(While* x)                  { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Return* x)                 { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Content* x)                { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Extension* x)              { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Definition* x)             { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Mixin_Call* x)             { return static_cast<D*>(this)->fallback(x); }
+    // expressions
+    virtual T operator()(List* x)                   { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Map* x)                    { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Binary_Expression* x)      { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Unary_Expression* x)       { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Function_Call* x)          { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Function_Call_Schema* x)   { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Variable* x)               { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Textual* x)                { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Number* x)                 { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Color* x)                  { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Boolean* x)                { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(String_Schema* x)          { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(String_Constant* x)        { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Feature_Query* x)          { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Feature_Query_Condition* x){ return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Media_Query* x)            { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Media_Query_Expression* x) { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Null* x)                   { return static_cast<D*>(this)->fallback(x); }
+    // parameters and arguments
+    virtual T operator()(Parameter* x)              { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Parameters* x)             { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Argument* x)               { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Arguments* x)              { return static_cast<D*>(this)->fallback(x); }
+    // selectors
+    virtual T operator()(Selector_Schema* x)        { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Selector_Reference* x)     { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Selector_Placeholder* x)   { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Type_Selector* x)          { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Selector_Qualifier* x)     { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Attribute_Selector* x)     { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Pseudo_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Wrapped_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Compound_Selector* x)      { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Complex_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
+    virtual T operator()(Selector_List* x)          { return static_cast<D*>(this)->fallback(x); }
+
+    template <typename U>
+    T fallback(U x)                                 { return T(); }
+  };
+  template<typename T, typename D>
+  inline Operation_CRTP<T, D>::~Operation_CRTP()    { }
+
+}

data/ext/libsass/output_compressed.cpp

@@ -0,0 +1,401 @@
+#include "output_compressed.hpp"
+#include "inspect.hpp"
+#include "ast.hpp"
+#include "context.hpp"
+#include "to_string.hpp"
+#include "util.hpp"
+#include <cmath>
+#include <iomanip>
+
+namespace Sass {
+  using namespace std;
+
+  Output_Compressed::Output_Compressed(Context* ctx) : buffer(""), rendered_imports(""), ctx(ctx), seen_utf8(false) { }
+  Output_Compressed::~Output_Compressed() { }
+
+  inline void Output_Compressed::fallback_impl(AST_Node* n)
+  {
+    Inspect i(ctx);
+    n->perform(&i);
+    const string& text = i.get_buffer();
+    for(const char& chr : text) {
+      // abort clause
+      if (seen_utf8) break;
+      // skip all normal ascii chars
+      if (Util::isAscii(chr)) continue;
+      // singleton
+      seen_utf8 = true;
+    }
+    buffer += text;
+    if (ctx && !ctx->_skip_source_map_update)
+      ctx->source_map.update_column(text);
+  }
+
+  void Output_Compressed::operator()(Import* imp)
+  {
+    Inspect insp(ctx);
+    imp->perform(&insp);
+    rendered_imports += insp.get_buffer();
+  }
+
+  void Output_Compressed::operator()(Block* b)
+  {
+    if (!b->is_root()) return;
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      (*b)[i]->perform(this);
+    }
+  }
+
+  void Output_Compressed::operator()(Ruleset* r)
+  {
+    Selector* s     = r->selector();
+    Block*    b     = r->block();
+
+    // Filter out rulesets that aren't printable (process its children though)
+    if (!Util::isPrintable(r)) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (dynamic_cast<Has_Block*>(stm)) {
+          stm->perform(this);
+        }
+      }
+      return;
+    }
+
+    if (b->has_non_hoistable()) {
+      s->perform(this);
+      append_singleline_part_to_buffer("{");
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (!stm->is_hoistable()) {
+          stm->perform(this);
+        }
+      }
+      size_t l = buffer.length();
+      if (l > 0 && buffer.at(l - 1) == ';') buffer.erase(l - 1);
+      append_singleline_part_to_buffer("}");
+    }
+
+    if (b->has_hoistable()) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (stm->is_hoistable()) {
+          stm->perform(this);
+        }
+      }
+    }
+  }
+
+  void Output_Compressed::operator()(Media_Block* m)
+  {
+    List*  q     = m->media_queries();
+    Block* b     = m->block();
+
+    // Filter out media blocks that aren't printable (process its children though)
+    if (!Util::isPrintable(m)) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (dynamic_cast<Has_Block*>(stm)) {
+          stm->perform(this);
+        }
+      }
+      return;
+    }
+
+    ctx->source_map.add_mapping(m);
+    append_singleline_part_to_buffer("@media ");
+    q->perform(this);
+    append_singleline_part_to_buffer("{");
+
+    Selector* e = m->selector();
+    if (e && b->has_non_hoistable()) {
+      // JMA - hoisted, output the non-hoistable in a nested block, followed by the hoistable
+      e->perform(this);
+      append_singleline_part_to_buffer("{");
+
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (!stm->is_hoistable()) {
+          stm->perform(this);
+        }
+      }
+
+      append_singleline_part_to_buffer("}");
+
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (stm->is_hoistable()) {
+          stm->perform(this);
+        }
+      }
+    }
+    else {
+      // JMA - not hoisted, just output in order
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        stm->perform(this);
+      }
+    }
+
+    append_singleline_part_to_buffer("}");
+  }
+
+  void Output_Compressed::operator()(At_Rule* a)
+  {
+    string      kwd   = a->keyword();
+    Selector*   s     = a->selector();
+    Expression* v     = a->value();
+    Block*      b     = a->block();
+
+    append_singleline_part_to_buffer(kwd);
+    if (s) {
+      append_singleline_part_to_buffer(" ");
+      s->perform(this);
+    }
+    else if (v) {
+      append_singleline_part_to_buffer(" ");
+      v->perform(this);
+    }
+
+    if (!b) {
+      append_singleline_part_to_buffer(";");
+      return;
+    }
+
+    append_singleline_part_to_buffer("{");
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement* stm = (*b)[i];
+      if (!stm->is_hoistable()) {
+        stm->perform(this);
+      }
+    }
+
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement* stm = (*b)[i];
+      if (stm->is_hoistable()) {
+        stm->perform(this);
+      }
+    }
+
+    append_singleline_part_to_buffer("}");
+  }
+
+  void Output_Compressed::operator()(Declaration* d)
+  {
+    bool bPrintExpression = true;
+    // Check print conditions
+    if (d->value()->concrete_type() == Expression::NULL_VAL) {
+      bPrintExpression = false;
+    }
+    if (d->value()->concrete_type() == Expression::STRING) {
+      String_Constant* valConst = static_cast<String_Constant*>(d->value());
+      string val(valConst->value());
+      if (val.empty()) {
+        bPrintExpression = false;
+      }
+    }
+    // Print if OK
+    if(bPrintExpression) {
+      if (ctx) ctx->source_map.add_mapping(d->property());
+      d->property()->perform(this);
+      append_singleline_part_to_buffer(":");
+      if (ctx) ctx->source_map.add_mapping(d->value());
+      d->value()->perform(this);
+      if (d->is_important()) append_singleline_part_to_buffer("!important");
+      append_singleline_part_to_buffer(";");
+    }
+  }
+
+  void Output_Compressed::operator()(Comment* c)
+  {
+    To_String to_string;
+    string txt = c->text()->perform(&to_string);
+    if(txt[2] != '!') {
+      return;
+    }
+    else {
+      Inspect i(ctx);
+      c->perform(&i);
+      const string& text = i.get_buffer();
+      for(const char& chr : text) {
+        // abort clause
+        if (seen_utf8) break;
+        // skip all normal ascii chars
+        if (Util::isAscii(chr)) continue;
+        // singleton
+        seen_utf8 = true;
+      }
+      buffer += text;
+      if (ctx && !ctx->_skip_source_map_update)
+       ctx->source_map.update_column(text);
+    }
+  }
+
+  void Output_Compressed::operator()(List* list)
+  {
+    string sep(list->separator() == List::SPACE ? " " : ",");
+    if (list->empty()) return;
+    Expression* first = (*list)[0];
+    bool first_invisible = first->is_invisible();
+    if (!first_invisible) first->perform(this);
+    for (size_t i = 1, L = list->length(); i < L; ++i) {
+      Expression* next = (*list)[i];
+      bool next_invisible = next->is_invisible();
+      if (i == 1 && !first_invisible && !next_invisible) append_singleline_part_to_buffer(sep);
+      else if (!next_invisible)                          append_singleline_part_to_buffer(sep);
+      next->perform(this);
+    }
+  }
+
+  // helper function for serializing colors
+  template <size_t range>
+  static double cap_channel(double c) {
+    if      (c > range) return range;
+    else if (c < 0)     return 0;
+    else                return c;
+  }
+
+  void Output_Compressed::operator()(Color* c)
+  {
+    stringstream ss;
+    double r = round(cap_channel<0xff>(c->r()));
+    double g = round(cap_channel<0xff>(c->g()));
+    double b = round(cap_channel<0xff>(c->b()));
+    double a = cap_channel<1>   (c->a());
+
+    // retain the originally specified color definition if unchanged
+    if (!c->disp().empty()) {
+      ss << c->disp();
+    }
+    else if (r == 0 && g == 0 && b == 0 && a == 0) {
+        ss << "transparent";
+    }
+    else if (a >= 1) {
+      // see if it's a named color
+      int numval = r * 0x10000;
+      numval += g * 0x100;
+      numval += b;
+      if (ctx && ctx->colors_to_names.count(numval)) {
+        ss << ctx->colors_to_names[numval];
+      }
+      else {
+        // otherwise output the hex triplet
+        ss << '#' << setw(2) << setfill('0');
+        ss << hex << setw(2) << static_cast<unsigned long>(r);
+        ss << hex << setw(2) << static_cast<unsigned long>(g);
+        ss << hex << setw(2) << static_cast<unsigned long>(b);
+      }
+    }
+    else {
+      ss << "rgba(";
+      ss << static_cast<unsigned long>(r) << ",";
+      ss << static_cast<unsigned long>(g) << ",";
+      ss << static_cast<unsigned long>(b) << ",";
+      ss << a << ')';
+    }
+    append_singleline_part_to_buffer(ss.str());
+  }
+
+  void Output_Compressed::operator()(Media_Query_Expression* mqe)
+  {
+    if (mqe->is_interpolated()) {
+      mqe->feature()->perform(this);
+    }
+    else {
+      append_singleline_part_to_buffer("(");
+      mqe->feature()->perform(this);
+      if (mqe->value()) {
+        append_singleline_part_to_buffer(":");
+        mqe->value()->perform(this);
+      }
+      append_singleline_part_to_buffer(")");
+    }
+  }
+
+  void Output_Compressed::operator()(Null* n)
+  {
+    // noop
+  }
+
+  void Output_Compressed::operator()(Argument* a)
+  {
+    if (!a->name().empty()) {
+      append_singleline_part_to_buffer(a->name());
+      append_singleline_part_to_buffer(":");
+    }
+    a->value()->perform(this);
+    if (a->is_rest_argument()) {
+      append_singleline_part_to_buffer("...");
+    }
+  }
+
+  void Output_Compressed::operator()(Arguments* a)
+  {
+    append_singleline_part_to_buffer("(");
+    if (!a->empty()) {
+      (*a)[0]->perform(this);
+      for (size_t i = 1, L = a->length(); i < L; ++i) {
+        append_singleline_part_to_buffer(",");
+        (*a)[i]->perform(this);
+      }
+    }
+    append_singleline_part_to_buffer(")");
+  }
+
+  void Output_Compressed::operator()(Complex_Selector* c)
+  {
+    Compound_Selector*           head = c->head();
+    Complex_Selector*            tail = c->tail();
+    Complex_Selector::Combinator comb = c->combinator();
+    if (head && head->is_empty_reference() && tail)
+    {
+      tail->perform(this);
+      return;
+    }
+    if (head && !head->is_empty_reference()) head->perform(this);
+    switch (comb) {
+      case Complex_Selector::ANCESTOR_OF:
+        if (tail) append_singleline_part_to_buffer(" ");
+        break;
+      case Complex_Selector::PARENT_OF:
+        append_singleline_part_to_buffer(">");
+        break;
+      case Complex_Selector::PRECEDES:
+        // Apparently need to preserve spaces around this combinator?
+        if (head && !head->is_empty_reference()) append_singleline_part_to_buffer(" ");
+        append_singleline_part_to_buffer("~");
+        if (tail) append_singleline_part_to_buffer(" ");
+        break;
+      case Complex_Selector::ADJACENT_TO:
+        append_singleline_part_to_buffer("+");
+        break;
+    }
+    if (tail) tail->perform(this);
+  }
+
+  void Output_Compressed::operator()(Selector_List* g)
+  {
+    if (g->empty()) return;
+    (*g)[0]->perform(this);
+    for (size_t i = 1, L = g->length(); i < L; ++i) {
+      append_singleline_part_to_buffer(",");
+      (*g)[i]->perform(this);
+    }
+  }
+
+  void Output_Compressed::append_singleline_part_to_buffer(const string& text)
+  {
+    buffer += text;
+    if (ctx && !ctx->_skip_source_map_update)
+      ctx->source_map.update_column(text);
+    for(const char& chr : text) {
+      // abort clause
+      if (seen_utf8) break;
+      // skip all normal ascii chars
+      if (Util::isAscii(chr)) continue;
+      // singleton
+      seen_utf8 = true;
+    }
+  }
+
+}