sassc 2.0.0 → 2.4.0

data/ext/libsass/src/operators.cpp

@@ -1,4 +1,8 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
+#include <cmath>
 #include "operators.hpp"
 
 namespace Sass {
@@ -27,7 +31,7 @@ namespace Sass {
     };
 
     /* static function, has no pstate or traces */
-    bool eq(Expression_Obj lhs, Expression_Obj rhs)
+    bool eq(ExpressionObj lhs, ExpressionObj rhs)
     {
       // operation is undefined if one is not a number
       if (!lhs || !rhs) throw Exception::UndefinedOperation(lhs, rhs, Sass_OP::EQ);
@@ -36,7 +40,7 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no pstate or traces */
-    bool cmp(Expression_Obj lhs, Expression_Obj rhs, const Sass_OP op)
+    bool cmp(ExpressionObj lhs, ExpressionObj rhs, const Sass_OP op)
     {
       // can only compare numbers!?
       Number_Obj l = Cast<Number>(lhs);
@@ -48,27 +52,38 @@ namespace Sass {
     }
 
     /* static functions, throws OperationError, has no pstate or traces */
-    bool lt(Expression_Obj lhs, Expression_Obj rhs) { return cmp(lhs, rhs, Sass_OP::LT); }
-    bool neq(Expression_Obj lhs, Expression_Obj rhs) { return eq(lhs, rhs) == false; }
-    bool gt(Expression_Obj lhs, Expression_Obj rhs) { return !cmp(lhs, rhs, Sass_OP::GT) && neq(lhs, rhs); }
-    bool lte(Expression_Obj lhs, Expression_Obj rhs) { return cmp(lhs, rhs, Sass_OP::LTE) || eq(lhs, rhs); }
-    bool gte(Expression_Obj lhs, Expression_Obj rhs) { return !cmp(lhs, rhs, Sass_OP::GTE) || eq(lhs, rhs); }
+    bool lt(ExpressionObj lhs, ExpressionObj rhs) { return cmp(lhs, rhs, Sass_OP::LT); }
+    bool neq(ExpressionObj lhs, ExpressionObj rhs) { return eq(lhs, rhs) == false; }
+    bool gt(ExpressionObj lhs, ExpressionObj rhs) { return !cmp(lhs, rhs, Sass_OP::GT) && neq(lhs, rhs); }
+    bool lte(ExpressionObj lhs, ExpressionObj rhs) { return cmp(lhs, rhs, Sass_OP::LTE) || eq(lhs, rhs); }
+    bool gte(ExpressionObj lhs, ExpressionObj rhs) { return !cmp(lhs, rhs, Sass_OP::GTE) || eq(lhs, rhs); }
+
+    /* colour math deprecation warning */
+    void op_color_deprecation(enum Sass_OP op, sass::string lsh, sass::string rhs, const SourceSpan& pstate)
+    {
+      deprecated(
+        "The operation `" + lsh + " " + sass_op_to_name(op) + " " + rhs +
+        "` is deprecated and will be an error in future versions.",
+        "Consider using Sass's color functions instead.\n"
+        "https://sass-lang.com/documentation/Sass/Script/Functions.html#other_color_functions",
+        /*with_column=*/false, pstate);
+    }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
       enum Sass_OP op = operand.operand;
 
-      String_Quoted_Ptr lqstr = Cast<String_Quoted>(&lhs);
-      String_Quoted_Ptr rqstr = Cast<String_Quoted>(&rhs);
+      String_Quoted* lqstr = Cast<String_Quoted>(&lhs);
+      String_Quoted* rqstr = Cast<String_Quoted>(&rhs);
 
-      std::string lstr(lqstr ? lqstr->value() : lhs.to_string(opt));
-      std::string rstr(rqstr ? rqstr->value() : rhs.to_string(opt));
+      sass::string lstr(lqstr ? lqstr->value() : lhs.to_string(opt));
+      sass::string rstr(rqstr ? rqstr->value() : rhs.to_string(opt));
 
       if (Cast<Null>(&lhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);
       if (Cast<Null>(&rhs)) throw Exception::InvalidNullOperation(&lhs, &rhs, op);
 
-      std::string sep;
+      sass::string sep;
       switch (op) {
         case Sass_OP::ADD: sep = "";   break;
         case Sass_OP::SUB: sep = "-";  break;
@@ -104,16 +119,21 @@ namespace Sass {
       return SASS_MEMORY_NEW(String_Constant, pstate, lstr + sep + rstr);
     }
 
+    /* ToDo: allow to operate also with hsla colors */
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_colors(enum Sass_OP op, const Color& lhs, const Color& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_colors(enum Sass_OP op, const Color_RGBA& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
+
       if (lhs.a() != rhs.a()) {
         throw Exception::AlphaChannelsNotEqual(&lhs, &rhs, op);
       }
-      if (op == Sass_OP::DIV && (!rhs.r() || !rhs.g() || !rhs.b())) {
+      if ((op == Sass_OP::DIV || op == Sass_OP::MOD) && (!rhs.r() || !rhs.g() || !rhs.b())) {
         throw Exception::ZeroDivisionError(lhs, rhs);
       }
-      return SASS_MEMORY_NEW(Color,
+
+      op_color_deprecation(op, lhs.to_string(), rhs.to_string(), pstate);
+
+      return SASS_MEMORY_NEW(Color_RGBA,
                              pstate,
                              ops[op](lhs.r(), rhs.r()),
                              ops[op](lhs.g(), rhs.g()),
@@ -122,18 +142,18 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_numbers(enum Sass_OP op, const Number& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_numbers(enum Sass_OP op, const Number& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
       double lval = lhs.value();
       double rval = rhs.value();
 
-      if (op == Sass_OP::DIV && rval == 0) {
-        std::string result(lval ? "Infinity" : "NaN");
-        return SASS_MEMORY_NEW(String_Quoted, pstate, result);
+      if (op == Sass_OP::MOD && rval == 0) {
+        return SASS_MEMORY_NEW(String_Quoted, pstate, "NaN");
       }
 
-      if (op == Sass_OP::MOD && rval == 0) {
-        throw Exception::ZeroDivisionError(lhs, rhs);
+      if (op == Sass_OP::DIV && rval == 0) {
+        sass::string result(lval ? "Infinity" : "NaN");
+        return SASS_MEMORY_NEW(String_Quoted, pstate, result);
       }
 
       size_t l_n_units = lhs.numerators.size();
@@ -145,7 +165,7 @@ namespace Sass {
         if (l_n_units + l_d_units <= 1 && r_n_units + r_d_units <= 1) {
           if (lhs.numerators == rhs.numerators) {
             if (lhs.denominators == rhs.denominators) {
-              Number_Ptr v = SASS_MEMORY_COPY(&lhs);
+              Number* v = SASS_MEMORY_COPY(&lhs);
               v->value(ops[op](lval, rval));
               return v;
             }
@@ -192,13 +212,15 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_number_color(enum Sass_OP op, const Number& lhs, const Color& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_number_color(enum Sass_OP op, const Number& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
       double lval = lhs.value();
+
       switch (op) {
         case Sass_OP::ADD:
         case Sass_OP::MUL: {
-          return SASS_MEMORY_NEW(Color,
+          op_color_deprecation(op, lhs.to_string(), rhs.to_string(opt), pstate);
+          return SASS_MEMORY_NEW(Color_RGBA,
                                 pstate,
                                 ops[op](lval, rhs.r()),
                                 ops[op](lval, rhs.g()),
@@ -207,7 +229,8 @@ namespace Sass {
         }
         case Sass_OP::SUB:
         case Sass_OP::DIV: {
-          std::string color(rhs.to_string(opt));
+          sass::string color(rhs.to_string(opt));
+          op_color_deprecation(op, lhs.to_string(), color, pstate);
           return SASS_MEMORY_NEW(String_Quoted,
                                 pstate,
                                 lhs.to_string(opt)
@@ -220,14 +243,18 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_color_number(enum Sass_OP op, const Color& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_color_number(enum Sass_OP op, const Color_RGBA& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed)
     {
       double rval = rhs.value();
-      if (op == Sass_OP::DIV && rval == 0) {
+
+      if ((op == Sass_OP::DIV || op == Sass_OP::DIV) && rval == 0) {
         // comparison of Fixnum with Float failed?
         throw Exception::ZeroDivisionError(lhs, rhs);
       }
-      return SASS_MEMORY_NEW(Color,
+
+      op_color_deprecation(op, lhs.to_string(), rhs.to_string(), pstate);
+
+      return SASS_MEMORY_NEW(Color_RGBA,
                             pstate,
                             ops[op](lhs.r(), rval),
                             ops[op](lhs.g(), rval),

data/ext/libsass/src/operators.hpp

@@ -9,19 +9,19 @@ namespace Sass {
   namespace Operators {
 
     // equality operator using AST Node operator==
-    bool eq(Expression_Obj, Expression_Obj);
-    bool neq(Expression_Obj, Expression_Obj);
+    bool eq(ExpressionObj, ExpressionObj);
+    bool neq(ExpressionObj, ExpressionObj);
     // specific operators based on cmp and eq
-    bool lt(Expression_Obj, Expression_Obj);
-    bool gt(Expression_Obj, Expression_Obj);
-    bool lte(Expression_Obj, Expression_Obj);
-    bool gte(Expression_Obj, Expression_Obj);
+    bool lt(ExpressionObj, ExpressionObj);
+    bool gt(ExpressionObj, ExpressionObj);
+    bool lte(ExpressionObj, ExpressionObj);
+    bool gte(ExpressionObj, ExpressionObj);
     // arithmetic for all the combinations that matter
-    Value_Ptr op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value_Ptr op_colors(enum Sass_OP, const Color&, const Color&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value_Ptr op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value_Ptr op_number_color(enum Sass_OP, const Number&, const Color&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value_Ptr op_color_number(enum Sass_OP, const Color&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
+    Value* op_colors(enum Sass_OP, const Color_RGBA&, const Color_RGBA&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
+    Value* op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
+    Value* op_number_color(enum Sass_OP, const Number&, const Color_RGBA&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
+    Value* op_color_number(enum Sass_OP, const Color_RGBA&, const Number&, struct Sass_Inspect_Options opt, const SourceSpan& pstate, bool delayed = false);
 
   };
 

data/ext/libsass/src/ordered_map.hpp

@@ -0,0 +1,112 @@
+#ifndef SASS_ORDERED_MAP_H
+#define SASS_ORDERED_MAP_H
+
+namespace Sass {
+
+  // ##########################################################################
+  // Very simple and limited container for insert ordered hash map.
+  // Piggy-back implementation on std::unordered_map and sass::vector
+  // ##########################################################################
+  template<
+    class Key,
+    class T,
+    class Hash = std::hash<Key>,
+    class KeyEqual = std::equal_to<Key>,
+    class Allocator = std::allocator<std::pair<const Key, T>>
+  >
+  class ordered_map {
+
+  private:
+
+    using map_type = typename std::unordered_map< Key, T, Hash, KeyEqual, Allocator>;
+    using map_iterator = typename std::unordered_map< Key, T, Hash, KeyEqual, Allocator>::iterator;
+    using map_const_iterator = typename std::unordered_map< Key, T, Hash, KeyEqual, Allocator>::const_iterator;
+
+    // The main unordered map
+    map_type _map;
+
+    // Keep insertion order
+    sass::vector<Key> _keys;
+    sass::vector<T> _values;
+
+    const KeyEqual _keyEqual;
+
+  public:
+
+    ordered_map() :
+      _keyEqual(KeyEqual())
+    {
+    }
+
+    ordered_map& operator= (const ordered_map& other) {
+      _map = other._map;
+      _keys = other._keys;
+      _values = other._values;
+      return *this;
+    }
+
+    std::pair<Key, T> front() {
+      return std::make_pair(
+        _keys.front(),
+        _values.front()
+      );
+    }
+
+    bool empty() const {
+      return _keys.empty();
+    }
+
+    void insert(const Key& key, const T& val) {
+      if (!hasKey(key)) {
+        _values.push_back(val);
+        _keys.push_back(key);
+      }
+      _map[key] = val;
+    }
+
+    bool hasKey(const Key& key) const {
+      return _map.find(key) != _map.end();
+    }
+
+    bool erase(const Key& key) {
+      _map.erase(key);
+      // find the position in the array
+      for (size_t i = 0; i < _keys.size(); i += 1) {
+        if (_keyEqual(key, _keys[i])) {
+          _keys.erase(_keys.begin() + i);
+          _values.erase(_values.begin() + i);
+          return true;
+        }
+      }
+      return false;
+    }
+
+    const sass::vector<Key>& keys() const { return _keys; }
+    const sass::vector<T>& values() const { return _values; }
+
+    const T& get(const Key& key) {
+      if (hasKey(key)) {
+        return _map[key];
+      }
+      throw std::runtime_error("Key does not exist");
+    }
+
+    using iterator = typename sass::vector<Key>::iterator;
+    using const_iterator = typename sass::vector<Key>::const_iterator;
+    using reverse_iterator = typename sass::vector<Key>::reverse_iterator;
+    using const_reverse_iterator = typename sass::vector<Key>::const_reverse_iterator;
+
+    typename sass::vector<Key>::iterator end() { return _keys.end(); }
+    typename sass::vector<Key>::iterator begin() { return _keys.begin(); }
+    typename sass::vector<Key>::reverse_iterator rend() { return _keys.rend(); }
+    typename sass::vector<Key>::reverse_iterator rbegin() { return _keys.rbegin(); }
+    typename sass::vector<Key>::const_iterator end() const { return _keys.end(); }
+    typename sass::vector<Key>::const_iterator begin() const { return _keys.begin(); }
+    typename sass::vector<Key>::const_reverse_iterator rend() const { return _keys.rend(); }
+    typename sass::vector<Key>::const_reverse_iterator rbegin() const { return _keys.rbegin(); }
+
+  };
+
+}
+
+#endif

data/ext/libsass/src/output.cpp

@@ -1,6 +1,10 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "ast.hpp"
 #include "output.hpp"
+#include "util.hpp"
 
 namespace Sass {
 
@@ -12,12 +16,12 @@ namespace Sass {
 
   Output::~Output() { }
 
-  void Output::fallback_impl(AST_Node_Ptr n)
+  void Output::fallback_impl(AST_Node* n)
   {
     return n->perform(this);
   }
 
-  void Output::operator()(Number_Ptr n)
+  void Output::operator()(Number* n)
   {
     // check for a valid unit here
     // includes result for reporting
@@ -26,17 +30,17 @@ namespace Sass {
       throw Exception::InvalidValue({}, *n);
     }
     // use values to_string facility
-    std::string res = n->to_string(opt);
+    sass::string res = n->to_string(opt);
     // output the final token
     append_token(res, n);
   }
 
-  void Output::operator()(Import_Ptr imp)
+  void Output::operator()(Import* imp)
   {
     top_nodes.push_back(imp);
   }
 
-  void Output::operator()(Map_Ptr m)
+  void Output::operator()(Map* m)
   {
     // should be handle in check_expression
     throw Exception::InvalidValue({}, *m);
@@ -73,7 +77,7 @@ namespace Sass {
       // declare the charset
       if (output_style() != COMPRESSED)
         charset = "@charset \"UTF-8\";"
-                + std::string(opt.linefeed);
+                + sass::string(opt.linefeed);
       else charset = "\xEF\xBB\xBF";
       // abort search
       break;
@@ -86,9 +90,8 @@ namespace Sass {
 
   }
 
-  void Output::operator()(Comment_Ptr c)
+  void Output::operator()(Comment* c)
   {
-    std::string txt = c->text()->to_string(opt);
     // if (indentation && txt == "/**/") return;
     bool important = c->is_important();
     if (output_style() != COMPRESSED || important) {
@@ -108,16 +111,18 @@ namespace Sass {
     }
   }
 
-  void Output::operator()(Ruleset_Ptr r)
+  void Output::operator()(StyleRule* r)
   {
-    Selector_Obj s     = r->selector();
-    Block_Obj    b     = r->block();
+    Block_Obj b = r->block();
+    SelectorListObj s = r->selector();
+
+    if (!s || s->empty()) return;
 
     // Filter out rulesets that aren't printable (process its children though)
     if (!Util::isPrintable(r, output_style())) {
       for (size_t i = 0, L = b->length(); i < L; ++i) {
-        const Statement_Obj& stm = b->at(i);
-        if (Cast<Has_Block>(stm)) {
+        const Statement_Obj& stm = b->get(i);
+        if (Cast<ParentStatement>(stm)) {
           if (!Cast<Declaration>(stm)) {
             stm->perform(this);
           }
@@ -126,12 +131,14 @@ namespace Sass {
       return;
     }
 
-    if (output_style() == NESTED) indentation += r->tabs();
+    if (output_style() == NESTED) {
+      indentation += r->tabs();
+    }
     if (opt.source_comments) {
-      std::stringstream ss;
+      sass::ostream ss;
       append_indentation();
-      std::string path(File::abs2rel(r->pstate().path));
-      ss << "/* line " << r->pstate().line + 1 << ", " << path << " */";
+      sass::string path(File::abs2rel(r->pstate().getPath()));
+      ss << "/* line " << r->pstate().getLine() << ", " << path << " */";
       append_string(ss.str());
       append_optional_linefeed();
     }
@@ -139,22 +146,22 @@ namespace Sass {
     if (s) s->perform(this);
     append_scope_opener(b);
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement_Obj stm = b->at(i);
+      Statement_Obj stm = b->get(i);
       bool bPrintExpression = true;
       // Check print conditions
-      if (Declaration_Ptr dec = Cast<Declaration>(stm)) {
-        if (String_Constant_Ptr valConst = Cast<String_Constant>(dec->value())) {
-          std::string val(valConst->value());
-          if (String_Quoted_Ptr qstr = Cast<String_Quoted>(valConst)) {
+      if (Declaration* dec = Cast<Declaration>(stm)) {
+        if (const String_Constant* valConst = Cast<String_Constant>(dec->value())) {
+          const sass::string& val = valConst->value();
+          if (const String_Quoted* qstr = Cast<const String_Quoted>(valConst)) {
             if (!qstr->quote_mark() && val.empty()) {
               bPrintExpression = false;
             }
           }
         }
-        else if (List_Ptr list = Cast<List>(dec->value())) {
+        else if (List* list = Cast<List>(dec->value())) {
           bool all_invisible = true;
           for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
-            Expression_Ptr item = list->at(list_i);
+            Expression* item = list->get(list_i);
             if (!item->is_invisible()) all_invisible = false;
           }
           if (all_invisible && !list->is_bracketed()) bPrintExpression = false;
@@ -169,7 +176,7 @@ namespace Sass {
     append_scope_closer(b);
 
   }
-  void Output::operator()(Keyframe_Rule_Ptr r)
+  void Output::operator()(Keyframe_Rule* r)
   {
     Block_Obj b = r->block();
     Selector_Obj v = r->name();
@@ -185,25 +192,25 @@ namespace Sass {
 
     append_scope_opener();
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement_Obj stm = b->at(i);
+      Statement_Obj stm = b->get(i);
       stm->perform(this);
       if (i < L - 1) append_special_linefeed();
     }
     append_scope_closer();
   }
 
-  void Output::operator()(Supports_Block_Ptr f)
+  void Output::operator()(SupportsRule* f)
   {
     if (f->is_invisible()) return;
 
-    Supports_Condition_Obj c = f->condition();
+    SupportsConditionObj c = f->condition();
     Block_Obj b              = f->block();
 
     // Filter out feature blocks that aren't printable (process its children though)
     if (!Util::isPrintable(f, output_style())) {
       for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement_Obj stm = b->at(i);
-        if (Cast<Has_Block>(stm)) {
+        Statement_Obj stm = b->get(i);
+        if (Cast<ParentStatement>(stm)) {
           stm->perform(this);
         }
       }
@@ -218,7 +225,7 @@ namespace Sass {
     append_scope_opener();
 
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement_Obj stm = b->at(i);
+      Statement_Obj stm = b->get(i);
       stm->perform(this);
       if (i < L - 1) append_special_linefeed();
     }
@@ -229,48 +236,28 @@ namespace Sass {
 
   }
 
-  void Output::operator()(Media_Block_Ptr m)
+  void Output::operator()(CssMediaRule* rule)
   {
-    if (m->is_invisible()) return;
-
-    Block_Obj b     = m->block();
-
-    // Filter out media blocks that aren't printable (process its children though)
-    if (!Util::isPrintable(m, output_style())) {
-      for (size_t i = 0, L = b->length(); i < L; ++i) {
-        Statement_Obj stm = b->at(i);
-        if (Cast<Has_Block>(stm)) {
-          stm->perform(this);
-        }
-      }
-      return;
-    }
-    if (output_style() == NESTED) indentation += m->tabs();
-    append_indentation();
-    append_token("@media", m);
-    append_mandatory_space();
-    in_media_block = true;
-    m->media_queries()->perform(this);
-    in_media_block = false;
-    append_scope_opener();
-
-    for (size_t i = 0, L = b->length(); i < L; ++i) {
-      if (b->at(i)) {
-      Statement_Obj stm = b->at(i);
-        stm->perform(this);
-      }
-      if (i < L - 1) append_special_linefeed();
+    // Avoid null pointer exception
+    if (rule == nullptr) return;
+    // Skip empty/invisible rule
+    if (rule->isInvisible()) return;
+    // Avoid null pointer exception
+    if (rule->block() == nullptr) return;
+    // Skip empty/invisible rule
+    if (rule->block()->isInvisible()) return;
+    // Skip if block is empty/invisible
+    if (Util::isPrintable(rule, output_style())) {
+      // Let inspect do its magic
+      Inspect::operator()(rule);
     }
-
-    if (output_style() == NESTED) indentation -= m->tabs();
-    append_scope_closer();
   }
 
-  void Output::operator()(Directive_Ptr a)
+  void Output::operator()(AtRule* a)
   {
-    std::string      kwd   = a->keyword();
+    sass::string      kwd   = a->keyword();
     Selector_Obj   s     = a->selector();
-    Expression_Obj v     = a->value();
+    ExpressionObj v     = a->value();
     Block_Obj      b     = a->block();
 
     append_indentation();
@@ -301,15 +288,15 @@ namespace Sass {
     bool format = kwd != "@font-face";;
 
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement_Obj stm = b->at(i);
-      stm->perform(this);
+      Statement_Obj stm = b->get(i);
+      if (stm) stm->perform(this);
       if (i < L - 1 && format) append_special_linefeed();
     }
 
     append_scope_closer();
   }
 
-  void Output::operator()(String_Quoted_Ptr s)
+  void Output::operator()(String_Quoted* s)
   {
     if (s->quote_mark()) {
       append_token(quote(s->value(), s->quote_mark()), s);
@@ -320,12 +307,9 @@ namespace Sass {
     }
   }
 
-  void Output::operator()(String_Constant_Ptr s)
+  void Output::operator()(String_Constant* s)
   {
-    std::string value(s->value());
-    if (s->can_compress_whitespace() && output_style() == COMPRESSED) {
-      value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
-    }
+    sass::string value(s->value());
     if (!in_comment && !in_custom_property) {
       append_token(string_to_output(value), s);
     } else {