oreorenasass 3.4.4 → 3.4.5

data/lib/sass/script/string.rb

@@ -0,0 +1,51 @@
+require 'sass/script/literal'
+
+module Sass::Script
+  # A SassScript object representing a CSS string *or* a CSS identifier.
+  class String < Literal
+    # The Ruby value of the string.
+    #
+    # @return [String]
+    attr_reader :value
+
+    # Whether this is a CSS string or a CSS identifier.
+    # The difference is that strings are written with double-quotes,
+    # while identifiers aren't.
+    #
+    # @return [Symbol] `:string` or `:identifier`
+    attr_reader :type
+
+    # Creates a new string.
+    #
+    # @param value [String] See \{#value}
+    # @param type [Symbol] See \{#type}
+    def initialize(value, type = :identifier)
+      super(value)
+      @type = type
+    end
+
+    # @see Literal#plus
+    def plus(other)
+      other_str = other.is_a?(Sass::Script::String) ? other.value : other.to_s
+      Sass::Script::String.new(self.value + other_str, self.type)
+    end
+
+    # @see Node#to_s
+    def to_s(opts = {})
+      if @type == :identifier
+        return @value.gsub(/\n\s*/, " ")
+      end
+
+      return "\"#{value.gsub('"', "\\\"")}\"" if opts[:quote] == %q{"}
+      return "'#{value.gsub("'", "\\'")}'" if opts[:quote] == %q{'}
+      return "\"#{value}\"" unless value.include?('"')
+      return "'#{value}'" unless value.include?("'")
+      "\"#{value.gsub('"', "\\\"")}\"" #'
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      to_s
+    end
+  end
+end

data/lib/sass/script/{tree/string_interpolation.rb → string_interpolation.rb}

@@ -1,4 +1,4 @@
-module Sass::Script::Tree
+module Sass::Script
   # A SassScript object representing `#{}` interpolation within a string.
   #
   # @see Interpolation
@@ -74,16 +74,15 @@ module Sass::Script::Tree
     # Evaluates the interpolation.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Sass::Script::Value::String]
-    #   The SassScript string that is the value of the interpolation
+    # @return [Sass::Script::String] The SassScript string that is the value of the interpolation
     def _perform(environment)
       res = ""
       before = @before.perform(environment)
       res << before.value
       mid = @mid.perform(environment)
-      res << (mid.is_a?(Sass::Script::Value::String) ? mid.value : mid.to_s(:quote => :none))
+      res << (mid.is_a?(Sass::Script::String) ? mid.value : mid.to_s)
       res << @after.perform(environment).value
-      opts(Sass::Script::Value::String.new(res, before.type))
+      opts(Sass::Script::String.new(res, before.type))
     end
 
     private

data/lib/sass/script/{tree/unary_operation.rb → unary_operation.rb}

@@ -1,4 +1,4 @@
-module Sass::Script::Tree
+module Sass::Script
   # A SassScript parse node representing a unary operation,
   # such as `-$b` or `not true`.
   #
@@ -31,7 +31,7 @@ module Sass::Script::Tree
            (operand =~ Sass::SCSS::RX::IDENT) == 0)
         operand = "(#{@operand.to_sass(opts)})"
       end
-      op = Sass::Script::Lexer::OPERATORS_REVERSE[@operator]
+      op = Lexer::OPERATORS_REVERSE[@operator]
       op + (op =~ /[a-z]/ ? " " : "") + operand
     end
 
@@ -55,15 +55,15 @@ module Sass::Script::Tree
     # Evaluates the operation.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Sass::Script::Value] The SassScript object that is the value of the operation
+    # @return [Literal] The SassScript object that is the value of the operation
     # @raise [Sass::SyntaxError] if the operation is undefined for the operand
     def _perform(environment)
       operator = "unary_#{@operator}"
-      value = @operand.perform(environment)
-      value.send(operator)
+      literal = @operand.perform(environment)
+      literal.send(operator)
     rescue NoMethodError => e
       raise e unless e.name.to_s == operator.to_s
-      raise Sass::SyntaxError.new("Undefined unary operation: \"#{@operator} #{value}\".")
+      raise Sass::SyntaxError.new("Undefined unary operation: \"#{@operator} #{literal}\".")
     end
   end
 end

data/lib/sass/script/variable.rb

@@ -0,0 +1,58 @@
+module Sass
+  module Script
+    # A SassScript parse node representing a variable.
+    class Variable < Node
+      # The name of the variable.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # The underscored name of the variable.
+      #
+      # @return [String]
+      attr_reader :underscored_name
+
+      # @param name [String] See \{#name}
+      def initialize(name)
+        @name = name
+        @underscored_name = name.gsub(/-/,"_")
+        super()
+      end
+
+      # @return [String] A string representation of the variable
+      def inspect(opts = {})
+        "$#{dasherize(name, opts)}"
+      end
+      alias_method :to_sass, :inspect
+
+      # Returns an empty array.
+      #
+      # @return [Array<Node>] empty
+      # @see Node#children
+      def children
+        []
+      end
+
+      # @see Node#deep_copy
+      def deep_copy
+        dup
+      end
+
+      protected
+
+      # Evaluates the variable.
+      #
+      # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+      # @return [Literal] The SassScript object that is the value of the variable
+      # @raise [Sass::SyntaxError] if the variable is undefined
+      def _perform(environment)
+        raise SyntaxError.new("Undefined variable: \"$#{name}\".") unless val = environment.var(name)
+        if val.is_a?(Number)
+          val = val.dup
+          val.original = nil
+        end
+        return val
+      end
+    end
+  end
+end

data/lib/sass/scss/css_parser.rb

@@ -11,7 +11,7 @@ module Sass
 
       def placeholder_selector; nil; end
       def parent_selector; nil; end
-      def interpolation(warn_for_color = false); nil; end
+      def interpolation; nil; end
       def use_css_import?; true; end
 
       def block_child(context)
@@ -25,14 +25,8 @@ module Sass
         end
       end
 
-      def nested_properties!(node)
-        expected('expression (e.g. 1px, bold)')
-      end
-
-      def ruleset
-        start_pos = source_position
-        return unless (selector = selector_comma_sequence)
-        block(node(Sass::Tree::RuleNode.new(selector, range(start_pos)), start_pos), :ruleset)
+      def nested_properties!(node, space)
+        expected('expression (e.g. 1px, bold)');
       end
 
       @sass_script_parser = Class.new(Sass::Script::CssParser)

data/lib/sass/scss/parser.rb

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 require 'set'
 
 module Sass
@@ -6,30 +5,16 @@ module Sass
     # The parser for SCSS.
     # It parses a string of code into a tree of {Sass::Tree::Node}s.
     class Parser
-      # Expose for the SASS parser.
-      attr_accessor :offset
-
       # @param str [String, StringScanner] The source document to parse.
       #   Note that `Parser` *won't* raise a nice error message if this isn't properly parsed;
       #   for that, you should use the higher-level {Sass::Engine} or {Sass::CSS}.
-      # @param filename [String] The name of the file being parsed. Used for
-      #   warnings and source maps.
-      # @param importer [Sass::Importers::Base] The importer used to import the
-      #   file being parsed. Used for source maps.
-      # @param line [Fixnum] The 1-based line on which the source string appeared,
+      # @param filename [String] The name of the file being parsed. Used for warnings.
+      # @param line [Fixnum] The line on which the source string appeared,
       #   if it's part of another document.
-      # @param offset [Fixnum] The 1-based character (not byte) offset in the line on
-      #   which the source string starts. Used for error reporting and sourcemap
-      #   building.
-      # @comment
-      #   rubocop:disable ParameterLists
-      def initialize(str, filename, importer, line = 1, offset = 1)
-        # rubocop:enable ParameterLists
+      def initialize(str, filename, line = 1)
         @template = str
         @filename = filename
-        @importer = importer
         @line = line
-        @offset = offset
         @strs = []
       end
 
@@ -40,7 +25,7 @@ module Sass
       def parse
         init_scanner!
         root = stylesheet
-        expected("selector or at-rule") unless root && @scanner.eos?
+        expected("selector or at-rule") unless @scanner.eos?
         root
       end
 
@@ -48,7 +33,7 @@ module Sass
       # Note that this won't assert that the identifier takes up the entire input string;
       # it's meant to be used with `StringScanner`s as part of other parsers.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>, nil]
+      # @return [Array<String, Sass::Script::Node>, nil]
       #   The interpolated identifier, or nil if none could be parsed
       def parse_interp_ident
         init_scanner!
@@ -63,22 +48,10 @@ module Sass
       def parse_media_query_list
         init_scanner!
         ql = media_query_list
-        expected("media query list") unless ql && @scanner.eos?
+        expected("media query list") unless @scanner.eos?
         ql
       end
 
-      # Parses an at-root query.
-      #
-      # @return [Array<String, Sass::Script;:Tree::Node>] The interpolated query.
-      # @raise [Sass::SyntaxError] if there's a syntax error in the query,
-      #   or if it doesn't take up the entire input string.
-      def parse_at_root_query
-        init_scanner!
-        query = at_root_query
-        expected("@at-root query list") unless query && @scanner.eos?
-        query
-      end
-
       # Parses a supports query condition.
       #
       # @return [Sass::Supports::Condition] The parsed condition
@@ -87,7 +60,7 @@ module Sass
       def parse_supports_condition
         init_scanner!
         condition = supports_condition
-        expected("supports condition") unless condition && @scanner.eos?
+        expected("supports condition") unless @scanner.eos?
         condition
       end
 
@@ -95,14 +68,6 @@ module Sass
 
       include Sass::SCSS::RX
 
-      def source_position
-        Sass::Source::Position.new(@line, @offset)
-      end
-
-      def range(start_pos, end_pos = source_position)
-        Sass::Source::Range.new(start_pos, end_pos, @filename, @importer)
-      end
-
       def init_scanner!
         @scanner =
           if @template.is_a?(StringScanner)
@@ -113,7 +78,7 @@ module Sass
       end
 
       def stylesheet
-        node = node(Sass::Tree::RootNode.new(@scanner.string), source_position)
+        node = node(Sass::Tree::RootNode.new(@scanner.string))
         block_contents(node, :stylesheet) {s(node)}
       end
 
@@ -147,33 +112,21 @@ module Sass
       end
 
       def process_comment(text, node)
-        silent = text =~ %r{\A//}
-        loud = !silent && text =~ %r{\A/[/*]!}
+        silent = text =~ /^\/\//
+        loud = !silent && text =~ %r{^/[/*]!}
         line = @line - text.count("\n")
 
         if silent
-          value = [text.sub(%r{\A\s*//}, '/*').gsub(%r{^\s*//}, ' *') + ' */']
+          value = [text.sub(/^\s*\/\//, '/*').gsub(/^\s*\/\//, ' *') + ' */']
         else
-          value = Sass::Engine.parse_interp(
-            text, line, @scanner.pos - text.size, :filename => @filename)
-          string_before_comment = @scanner.string[0...@scanner.pos - text.length]
-          newline_before_comment = string_before_comment.rindex("\n")
-          last_line_before_comment =
-            if newline_before_comment
-              string_before_comment[newline_before_comment + 1..-1]
-            else
-              string_before_comment
-            end
-          value.unshift(last_line_before_comment.gsub(/[^\s]/, ' '))
+          value = Sass::Engine.parse_interp(text, line, @scanner.pos - text.size, :filename => @filename)
+          value.unshift(@scanner.
+            string[0...@scanner.pos].
+            reverse[/.*?\*\/(.*?)($|\Z)/, 1].
+            reverse.gsub(/[^\s]/, ' '))
         end
 
-        type = if silent
-                 :silent
-               elsif loud
-                 :loud
-               else
-                 :normal
-               end
+        type = if silent then :silent elsif loud then :loud else :normal end
         comment = Sass::Tree::CommentNode.new(value, type)
         comment.line = line
         node << comment
@@ -181,29 +134,31 @@ module Sass
 
       DIRECTIVES = Set[:mixin, :include, :function, :return, :debug, :warn, :for,
         :each, :while, :if, :else, :extend, :import, :media, :charset, :content,
-        :_moz_document, :at_root, :error]
+        :_moz_document]
 
       PREFIXED_DIRECTIVES = Set[:supports]
 
       def directive
-        start_pos = source_position
         return unless tok(/@/)
         name = tok!(IDENT)
         ss
 
-        if (dir = special_directive(name, start_pos))
+        if dir = special_directive(name)
           return dir
-        elsif (dir = prefixed_directive(name, start_pos))
+        elsif dir = prefixed_directive(name)
           return dir
         end
 
-        val = almost_any_value
+        # Most at-rules take expressions (e.g. @import),
+        # but some (e.g. @page) take selector-like arguments.
+        # Some take no arguments at all.
+        val = expr || selector
         val = val ? ["@#{name} "] + Sass::Util.strip_string_array(val) : ["@#{name}"]
-        directive_body(val, start_pos)
+        directive_body(val)
       end
 
-      def directive_body(value, start_pos)
-        node = Sass::Tree::DirectiveNode.new(value)
+      def directive_body(value)
+        node = node(Sass::Tree::DirectiveNode.new(value))
 
         if tok(/\{/)
           node.has_children = true
@@ -211,32 +166,31 @@ module Sass
           tok!(/\}/)
         end
 
-        node(node, start_pos)
+        node
       end
 
-      def special_directive(name, start_pos)
+      def special_directive(name)
         sym = name.gsub('-', '_').to_sym
-        DIRECTIVES.include?(sym) && send("#{sym}_directive", start_pos)
+        DIRECTIVES.include?(sym) && send("#{sym}_directive")
       end
 
-      def prefixed_directive(name, start_pos)
-        sym = deprefix(name).gsub('-', '_').to_sym
-        PREFIXED_DIRECTIVES.include?(sym) && send("#{sym}_directive", name, start_pos)
+      def prefixed_directive(name)
+        sym = name.gsub(/^-[a-z0-9]+-/i, '').gsub('-', '_').to_sym
+        PREFIXED_DIRECTIVES.include?(sym) && send("#{sym}_directive", name)
       end
 
-      def mixin_directive(start_pos)
+      def mixin_directive
         name = tok! IDENT
         args, splat = sass_script(:parse_mixin_definition_arglist)
         ss
-        block(node(Sass::Tree::MixinDefNode.new(name, args, splat), start_pos), :directive)
+        block(node(Sass::Tree::MixinDefNode.new(name, args, splat)), :directive)
       end
 
-      def include_directive(start_pos)
+      def include_directive
         name = tok! IDENT
-        args, keywords, splat, kwarg_splat = sass_script(:parse_mixin_include_arglist)
+        args, keywords, splat = sass_script(:parse_mixin_include_arglist)
         ss
-        include_node = node(
-          Sass::Tree::MixinNode.new(name, args, keywords, splat, kwarg_splat), start_pos)
+        include_node = node(Sass::Tree::MixinNode.new(name, args, keywords, splat))
         if tok?(/\{/)
           include_node.has_children = true
           block(include_node, :directive)
@@ -245,31 +199,31 @@ module Sass
         end
       end
 
-      def content_directive(start_pos)
+      def content_directive
         ss
-        node(Sass::Tree::ContentNode.new, start_pos)
+        node(Sass::Tree::ContentNode.new)
       end
 
-      def function_directive(start_pos)
+      def function_directive
         name = tok! IDENT
         args, splat = sass_script(:parse_function_definition_arglist)
         ss
-        block(node(Sass::Tree::FunctionNode.new(name, args, splat), start_pos), :function)
+        block(node(Sass::Tree::FunctionNode.new(name, args, splat)), :function)
       end
 
-      def return_directive(start_pos)
-        node(Sass::Tree::ReturnNode.new(sass_script(:parse)), start_pos)
+      def return_directive
+        node(Sass::Tree::ReturnNode.new(sass_script(:parse)))
       end
 
-      def debug_directive(start_pos)
-        node(Sass::Tree::DebugNode.new(sass_script(:parse)), start_pos)
+      def debug_directive
+        node(Sass::Tree::DebugNode.new(sass_script(:parse)))
       end
 
-      def warn_directive(start_pos)
-        node(Sass::Tree::WarnNode.new(sass_script(:parse)), start_pos)
+      def warn_directive
+        node(Sass::Tree::WarnNode.new(sass_script(:parse)))
       end
 
-      def for_directive(start_pos)
+      def for_directive
         tok!(/\$/)
         var = tok! IDENT
         ss
@@ -283,37 +237,31 @@ module Sass
         to = sass_script(:parse)
         ss
 
-        block(node(Sass::Tree::ForNode.new(var, from, to, exclusive), start_pos), :directive)
+        block(node(Sass::Tree::ForNode.new(var, from, to, exclusive)), :directive)
       end
 
-      def each_directive(start_pos)
+      def each_directive
         tok!(/\$/)
-        vars = [tok!(IDENT)]
+        var = tok! IDENT
         ss
-        while tok(/,/)
-          ss
-          tok!(/\$/)
-          vars << tok!(IDENT)
-          ss
-        end
 
         tok!(/in/)
         list = sass_script(:parse)
         ss
 
-        block(node(Sass::Tree::EachNode.new(vars, list), start_pos), :directive)
+        block(node(Sass::Tree::EachNode.new(var, list)), :directive)
       end
 
-      def while_directive(start_pos)
+      def while_directive
         expr = sass_script(:parse)
         ss
-        block(node(Sass::Tree::WhileNode.new(expr), start_pos), :directive)
+        block(node(Sass::Tree::WhileNode.new(expr)), :directive)
       end
 
-      def if_directive(start_pos)
+      def if_directive
         expr = sass_script(:parse)
         ss
-        node = block(node(Sass::Tree::IfNode.new(expr), start_pos), :directive)
+        node = block(node(Sass::Tree::IfNode.new(expr)), :directive)
         pos = @scanner.pos
         line = @line
         ss
@@ -328,11 +276,10 @@ module Sass
       end
 
       def else_block(node)
-        start_pos = source_position
         return unless tok(/@else/)
         ss
         else_node = block(
-          node(Sass::Tree::IfNode.new((sass_script(:parse) if tok(/if/))), start_pos),
+          Sass::Tree::IfNode.new((sass_script(:parse) if tok(/if/))),
           :directive)
         node.add_else(else_node)
         pos = @scanner.pos
@@ -348,20 +295,18 @@ module Sass
           end
       end
 
-      def else_directive(start_pos)
+      def else_directive
         err("Invalid CSS: @else must come after @if")
       end
 
-      def extend_directive(start_pos)
-        selector_start_pos = source_position
-        @expected = "selector"
-        selector = Sass::Util.strip_string_array(expr!(:almost_any_value))
+      def extend_directive
+        selector = expr!(:selector_sequence)
         optional = tok(OPTIONAL)
         ss
-        node(Sass::Tree::ExtendNode.new(selector, !!optional, range(selector_start_pos)), start_pos)
+        node(Sass::Tree::ExtendNode.new(selector, !!optional))
       end
 
-      def import_directive(start_pos)
+      def import_directive
         values = []
 
         loop do
@@ -371,40 +316,42 @@ module Sass
           ss
         end
 
-        values
+        return values
       end
 
       def import_arg
-        start_pos = source_position
-        return unless (str = string) || (uri = tok?(/url\(/i))
+        line = @line
+        return unless (str = tok(STRING)) || (uri = tok?(/url\(/i))
         if uri
           str = sass_script(:parse_string)
           ss
           media = media_query_list
           ss
-          return node(Tree::CssImportNode.new(str, media.to_a), start_pos)
+          return node(Tree::CssImportNode.new(str, media.to_a))
         end
+
+        path = @scanner[1] || @scanner[2]
         ss
 
         media = media_query_list
-        if str =~ %r{^(https?:)?//} || media || use_css_import?
-          return node(Sass::Tree::CssImportNode.new(
-              Sass::Script::Value::String.quote(str), media.to_a), start_pos)
+        if path =~ /^(https?:)?\/\// || media || use_css_import?
+          node = Sass::Tree::CssImportNode.new(str, media.to_a)
+        else
+          node = Sass::Tree::ImportNode.new(path.strip)
         end
-
-        node(Sass::Tree::ImportNode.new(str.strip), start_pos)
+        node.line = line
+        node
       end
 
       def use_css_import?; false; end
 
-      def media_directive(start_pos)
-        block(node(Sass::Tree::MediaNode.new(expr!(:media_query_list).to_a), start_pos), :directive)
+      def media_directive
+        block(node(Sass::Tree::MediaNode.new(expr!(:media_query_list).to_a)), :directive)
       end
 
       # http://www.w3.org/TR/css3-mediaqueries/#syntax
       def media_query_list
-        query = media_query
-        return unless query
+        return unless query = media_query
         queries = [query]
 
         ss
@@ -417,7 +364,7 @@ module Sass
       end
 
       def media_query
-        if (ident1 = interp_ident)
+        if ident1 = interp_ident
           ss
           ident2 = interp_ident
           ss
@@ -437,8 +384,7 @@ module Sass
         if query
           expr = expr!(:media_expr)
         else
-          expr = media_expr
-          return unless expr
+          return unless expr = media_expr
         end
         query ||= Sass::Media::Query.new([], [], [])
         query.expressions << expr
@@ -451,9 +397,8 @@ module Sass
         query
       end
 
-      def query_expr
-        interp = interpolation
-        return interp if interp
+      def media_expr
+        interp = interpolation and return interp
         return unless tok(/\(/)
         res = ['(']
         ss
@@ -469,15 +414,11 @@ module Sass
         res
       end
 
-      # Aliases allow us to use different descriptions if the same
-      # expression fails in different contexts.
-      alias_method :media_expr, :query_expr
-      alias_method :at_root_query, :query_expr
-
-      def charset_directive(start_pos)
-        name = expr!(:string)
+      def charset_directive
+        tok! STRING
+        name = @scanner[1] || @scanner[2]
         ss
-        node(Sass::Tree::CharsetNode.new(name), start_pos)
+        node(Sass::Tree::CharsetNode.new(name))
       end
 
       # The document directive is specified in
@@ -488,65 +429,34 @@ module Sass
       # We could parse all document directives according to Mozilla's syntax,
       # but if someone's using e.g. @-webkit-document we don't want them to
       # think WebKit works sans quotes.
-      def _moz_document_directive(start_pos)
+      def _moz_document_directive
         res = ["@-moz-document "]
         loop do
-          res << str {ss} << expr!(:moz_document_function)
-          if (c = tok(/,/))
-            res << c
-          else
-            break
-          end
+          res << str{ss} << expr!(:moz_document_function)
+          break unless c = tok(/,/)
+          res << c
         end
-        directive_body(res.flatten, start_pos)
+        directive_body(res.flatten)
       end
 
       def moz_document_function
-        val = interp_uri || _interp_string(:url_prefix) ||
+        return unless val = interp_uri || _interp_string(:url_prefix) ||
           _interp_string(:domain) || function(!:allow_var) || interpolation
-        return unless val
         ss
         val
       end
 
-      def at_root_directive(start_pos)
-        if tok?(/\(/) && (expr = at_root_query)
-          return block(node(Sass::Tree::AtRootNode.new(expr), start_pos), :directive)
-        end
-
-        at_root_node = node(Sass::Tree::AtRootNode.new, start_pos)
-        rule_node = ruleset
-        return block(at_root_node, :stylesheet) unless rule_node
-        at_root_node << rule_node
-        at_root_node
-      end
-
-      def at_root_directive_list
-        return unless (first = tok(IDENT))
-        arr = [first]
-        ss
-        while (e = tok(IDENT))
-          arr << e
-          ss
-        end
-        arr
-      end
-
-      def error_directive(start_pos)
-        node(Sass::Tree::ErrorNode.new(sass_script(:parse)), start_pos)
-      end
-
       # http://www.w3.org/TR/css3-conditional/
-      def supports_directive(name, start_pos)
+      def supports_directive(name)
         condition = expr!(:supports_condition)
-        node = Sass::Tree::SupportsNode.new(name, condition)
+        node = node(Sass::Tree::SupportsNode.new(name, condition))
 
         tok!(/\{/)
         node.has_children = true
         block_contents(node, :directive)
         tok!(/\}/)
 
-        node(node, start_pos)
+        node
       end
 
       def supports_condition
@@ -560,21 +470,20 @@ module Sass
       end
 
       def supports_operator
-        cond = supports_condition_in_parens
-        return unless cond
-        while (op = tok(/and|or/i))
+        return unless cond = supports_condition_in_parens
+        return cond unless op = tok(/and|or/i)
+        begin
           ss
           cond = Sass::Supports::Operator.new(
             cond, expr!(:supports_condition_in_parens), op)
-        end
+        end while op = tok(/and|or/i)
         cond
       end
 
       def supports_condition_in_parens
-        interp = supports_interpolation
-        return interp if interp
+        interp = supports_interpolation and return interp
         return unless tok(/\(/); ss
-        if (cond = supports_condition)
+        if cond = supports_condition
           tok!(/\)/); ss
           cond
         else
@@ -592,33 +501,19 @@ module Sass
       end
 
       def supports_interpolation
-        interp = interpolation
-        return unless interp
+        return unless interp = interpolation
         ss
         Sass::Supports::Interpolation.new(interp)
       end
 
       def variable
         return unless tok(/\$/)
-        start_pos = source_position
         name = tok!(IDENT)
         ss; tok!(/:/); ss
 
         expr = sass_script(:parse)
-        while tok(/!/)
-          flag_name = tok!(IDENT)
-          if flag_name == 'default'
-            guarded ||= true
-          elsif flag_name == 'global'
-            global ||= true
-          else
-            raise Sass::SyntaxError.new("Invalid flag \"!#{flag_name}\".", :line => @line)
-          end
-          ss
-        end
-
-        result = Sass::Tree::VariableNode.new(name, expr, guarded, global)
-        node(result, start_pos)
+        guarded = tok(DEFAULT)
+        node(Sass::Tree::VariableNode.new(name, expr, guarded))
       end
 
       def operator
@@ -630,10 +525,8 @@ module Sass
       end
 
       def ruleset
-        start_pos = source_position
-        return unless (rules = almost_any_value)
-        block(node(
-          Sass::Tree::RuleNode.new(rules, range(start_pos)), start_pos), :ruleset)
+        return unless rules = selector_sequence
+        block(node(Sass::Tree::RuleNode.new(rules.flatten.compact)), :ruleset)
       end
 
       def block(node, context)
@@ -664,239 +557,355 @@ module Sass
       def has_children?(child_or_array)
         return false unless child_or_array
         return child_or_array.last.has_children if child_or_array.is_a?(Array)
-        child_or_array.has_children
+        return child_or_array.has_children
       end
 
-      # When parsing the contents of a ruleset, it can be difficult to tell
-      # declarations apart from nested rulesets. Since we don't thoroughly parse
-      # selectors until after resolving interpolation, we can share a bunch of
-      # the parsing of the two, but we need to disambiguate them first. We use
-      # the following criteria:
-      #
-      # * If the entity doesn't start with an identifier followed by a colon,
-      #   it's a selector. There are some additional mostly-unimportant cases
-      #   here to support various declaration hacks.
-      #
-      # * If the colon is followed by another colon, it's a selector.
+      # This is a nasty hack, and the only place in the parser
+      # that requires a large amount of backtracking.
+      # The reason is that we can't figure out if certain strings
+      # are declarations or rulesets with fixed finite lookahead.
+      # For example, "foo:bar baz baz baz..." could be either a property
+      # or a selector.
       #
-      # * Otherwise, if the colon is followed by anything other than
-      #   interpolation or a character that's valid as the beginning of an
-      #   identifier, it's a declaration.
+      # To handle this, we simply check if it works as a property
+      # (which is the most common case)
+      # and, if it doesn't, try it as a ruleset.
       #
-      # * If the colon is followed by interpolation or a valid identifier, try
-      #   parsing it as a declaration value. If this fails, backtrack and parse
-      #   it as a selector.
-      #
-      # * If the declaration value value valid but is followed by "{", backtrack
-      #   and parse it as a selector anyway. This ensures that ".foo:bar {" is
-      #   always parsed as a selector and never as a property with nested
-      #   properties beneath it.
+      # We could eke some more efficiency out of this
+      # by handling some easy cases (first token isn't an identifier,
+      # no colon after the identifier, whitespace after the colon),
+      # but I'm not sure the gains would be worth the added complexity.
       def declaration_or_ruleset
-        start_pos = source_position
-        declaration = try_declaration
+        old_use_property_exception, @use_property_exception =
+          @use_property_exception, false
+        decl_err = catch_error do
+          decl = declaration
+          unless decl && decl.has_children
+            # We want an exception if it's not there,
+            # but we don't want to consume if it is
+            tok!(/[;}]/) unless tok?(/[;}]/)
+          end
+          return decl
+        end
 
-        if declaration.nil?
-          return unless (selector = almost_any_value)
-        elsif declaration.is_a?(Array)
-          selector = declaration
-        else
-          # Declaration should be a PropNode.
-          return declaration
+        ruleset_err = catch_error {return ruleset}
+        rethrow(@use_property_exception ? decl_err : ruleset_err)
+      ensure
+        @use_property_exception = old_use_property_exception
+      end
+
+      def selector_sequence
+        if sel = tok(STATIC_SELECTOR, true)
+          return [sel]
         end
 
-        if (additional_selector = almost_any_value)
-          selector << additional_selector
+        rules = []
+        return unless v = selector
+        rules.concat v
+
+        ws = ''
+        while tok(/,/)
+          ws << str {ss}
+          if v = selector
+            rules << ',' << ws
+            rules.concat v
+            ws = ''
+          end
         end
+        rules
+      end
 
-        block(node(
-          Sass::Tree::RuleNode.new(merge(selector), range(start_pos)), start_pos), :ruleset)
+      def selector
+        return unless sel = _selector
+        sel.to_a
       end
 
-      # Tries to parse a declaration, and returns the value parsed so far if it
-      # fails.
-      #
-      # This has three possible return types. It can return `nil`, indicating
-      # that parsing failed completely and the scanner hasn't moved forward at
-      # all. It can return an Array, indicating that parsing failed after
-      # consuming some text (possibly containing interpolation), which is
-      # returned. Or it can return a PropNode, indicating that parsing
-      # succeeded.
-      def try_declaration
-        # This allows the "*prop: val", ":prop: val", "#prop: val", and ".prop:
-        # val" hacks.
-        name_start_pos = source_position
-        if (s = tok(/[:\*\.]|\#(?!\{)/))
-          name = [s, str {ss}]
-          return name unless (ident = interp_ident)
-          name << ident
-        else
-          return unless (name = interp_ident)
-          name = Array(name)
+      def selector_comma_sequence
+        return unless sel = _selector
+        selectors = [sel]
+        ws = ''
+        while tok(/,/)
+          ws << str{ss}
+          if sel = _selector
+            selectors << sel
+            selectors[-1] = Selector::Sequence.new(["\n"] + selectors.last.members) if ws.include?("\n")
+            ws = ''
+          end
         end
+        Selector::CommaSequence.new(selectors)
+      end
 
-        if (comment = tok(COMMENT))
-          name << comment
+      def _selector
+        # The combinator here allows the "> E" hack
+        return unless val = combinator || simple_selector_sequence
+        nl = str{ss}.include?("\n")
+        res = []
+        res << val
+        res << "\n" if nl
+
+        while val = combinator || simple_selector_sequence
+          res << val
+          res << "\n" if str{ss}.include?("\n")
+        end
+        Selector::Sequence.new(res.compact)
+      end
+
+      def combinator
+        tok(PLUS) || tok(GREATER) || tok(TILDE) || reference_combinator
+      end
+
+      def reference_combinator
+        return unless tok(/\//)
+        res = ['/']
+        ns, name = expr!(:qualified_name)
+        res << ns << '|' if ns
+        res << name << tok!(/\//)
+        res = res.flatten
+        res = res.join '' if res.all? {|e| e.is_a?(String)}
+        res
+      end
+
+      def simple_selector_sequence
+        # Returning expr by default allows for stuff like
+        # http://www.w3.org/TR/css3-animations/#keyframes-
+        return expr(!:allow_var) unless e = element_name || id_selector ||
+          class_selector || placeholder_selector || attrib || pseudo ||
+          parent_selector || interpolation_selector
+        res = [e]
+
+        # The tok(/\*/) allows the "E*" hack
+        while v = id_selector || class_selector || placeholder_selector || attrib ||
+            pseudo || interpolation_selector ||
+            (tok(/\*/) && Selector::Universal.new(nil))
+          res << v
         end
-        name_end_pos = source_position
-
-        mid = [str {ss}]
-        return name + mid unless tok(/:/)
-        mid << ':'
-        return name + mid + [':'] if tok(/:/)
-        mid << str {ss}
-        post_colon_whitespace = !mid.last.empty?
-        could_be_selector = !post_colon_whitespace && (tok?(IDENT_START) || tok?(INTERP_START))
-
-        value_start_pos = source_position
-        value = nil
-        error = catch_error do
-          value = value!
-          if tok?(/\{/)
-            # Properties that are ambiguous with selectors can't have additional
-            # properties nested beneath them.
-            tok!(/;/) if could_be_selector
-          elsif !tok?(/[;{}]/)
-            # We want an exception if there's no valid end-of-property character
-            # exists, but we don't want to consume it if it does.
-            tok!(/[;{}]/)
+
+        pos = @scanner.pos
+        line = @line
+        if sel = str? {simple_selector_sequence}
+          @scanner.pos = pos
+          @line = line
+          begin
+            # If we see "*E", don't force a throw because this could be the
+            # "*prop: val" hack.
+            expected('"{"') if res.length == 1 && res[0].is_a?(Selector::Universal)
+            throw_error {expected('"{"')}
+          rescue Sass::SyntaxError => e
+            e.message << "\n\n\"#{sel}\" may only be used at the beginning of a compound selector."
+            raise e
           end
         end
 
-        if error
-          rethrow error unless could_be_selector
+        Selector::SimpleSequence.new(res, tok(/!/))
+      end
+
+      def parent_selector
+        return unless tok(/&/)
+        Selector::Parent.new
+      end
+
+      def class_selector
+        return unless tok(/\./)
+        @expected = "class name"
+        Selector::Class.new(merge(expr!(:interp_ident)))
+      end
 
-          # If the value would be followed by a semicolon, it's definitely
-          # supposed to be a property, not a selector.
-          additional_selector = almost_any_value
-          rethrow error if tok?(/;/)
+      def id_selector
+        return unless tok(/#(?!\{)/)
+        @expected = "id name"
+        Selector::Id.new(merge(expr!(:interp_name)))
+      end
+
+      def placeholder_selector
+        return unless tok(/%/)
+        @expected = "placeholder name"
+        Selector::Placeholder.new(merge(expr!(:interp_ident)))
+      end
 
-          return name + mid + (additional_selector || [])
+      def element_name
+        ns, name = Sass::Util.destructure(qualified_name(:allow_star_name))
+        return unless ns || name
+
+        if name == '*'
+          Selector::Universal.new(merge(ns))
+        else
+          Selector::Element.new(merge(name), merge(ns))
         end
+      end
+
+      def qualified_name(allow_star_name=false)
+        return unless name = interp_ident || tok(/\*/) || (tok?(/\|/) && "")
+        return nil, name unless tok(/\|/)
 
-        value_end_pos = source_position
+        return name, expr!(:interp_ident) unless allow_star_name
+        @expected = "identifier or *"
+        return name, interp_ident || tok!(/\*/)
+      end
+
+      def interpolation_selector
+        return unless script = interpolation
+        Selector::Interpolation.new(script)
+      end
+
+      def attrib
+        return unless tok(/\[/)
+        ss
+        ns, name = attrib_name!
         ss
-        require_block = tok?(/\{/)
 
-        node = node(Sass::Tree::PropNode.new(name.flatten.compact, value, :new),
-                    name_start_pos, value_end_pos)
-        node.name_source_range = range(name_start_pos, name_end_pos)
-        node.value_source_range = range(value_start_pos, value_end_pos)
+        if op = tok(/=/) ||
+            tok(INCLUDES) ||
+            tok(DASHMATCH) ||
+            tok(PREFIXMATCH) ||
+            tok(SUFFIXMATCH) ||
+            tok(SUBSTRINGMATCH)
+          @expected = "identifier or string"
+          ss
+          val = interp_ident || expr!(:interp_string)
+          ss
+        end
+        flags = interp_ident || interp_string
+        tok!(/\]/)
 
-        return node unless require_block
-        nested_properties! node
+        Selector::Attribute.new(merge(name), merge(ns), op, merge(val), merge(flags))
       end
 
-      # This production is similar to the CSS [`<any-value>`][any-value]
-      # production, but as the name implies, not quite the same. It's meant to
-      # consume values that could be a selector, an expression, or a combination
-      # of both. It respects strings and comments and supports interpolation. It
-      # will consume up to "{", "}", ";", or "!".
-      #
-      # [any-value]: http://dev.w3.org/csswg/css-variables/#typedef-any-value
-      #
-      # Values consumed by this production will usually be parsed more
-      # thoroughly once interpolation has been resolved.
-      def almost_any_value
-        return unless (tok = almost_any_value_token)
-        sel = [tok]
-        while (tok = almost_any_value_token)
-          sel << tok
+      def attrib_name!
+        if name_or_ns = interp_ident
+          # E, E|E
+          if tok(/\|(?!=)/)
+            ns = name_or_ns
+            name = interp_ident
+          else
+            name = name_or_ns
+          end
+        else
+          # *|E or |E
+          ns = [tok(/\*/) || ""]
+          tok!(/\|/)
+          name = expr!(:interp_ident)
         end
-        merge(sel)
+        return ns, name
       end
 
-      def almost_any_value_token
-        tok(%r{
-          (
-            (?!url\()
-            [^"/\#!;\{\}] # "
-          |
-            /(?![/*])
-          |
-            \#(?!\{)
-          |
-            !(?![a-z]) # TODO: never consume "!" when issue 1126 is fixed.
-          )+
-        }xi) || tok(COMMENT) || tok(SINGLE_LINE_COMMENT) || interp_string || interp_uri ||
-                interpolation(:warn_for_color)
+      def pseudo
+        return unless s = tok(/::?/)
+        @expected = "pseudoclass or pseudoelement"
+        name = expr!(:interp_ident)
+        if tok(/\(/)
+          ss
+          arg = expr!(:pseudo_arg)
+          while tok(/,/)
+            arg << ',' << str{ss}
+            arg.concat expr!(:pseudo_arg)
+          end
+          tok!(/\)/)
+        end
+        Selector::Pseudo.new(s == ':' ? :class : :element, merge(name), merge(arg))
+      end
+
+      def pseudo_arg
+        # In the CSS spec, every pseudo-class/element either takes a pseudo
+        # expression or a selector comma sequence as an argument. However, we
+        # don't want to have to know which takes which, so we handle both at
+        # once.
+        #
+        # However, there are some ambiguities between the two. For instance, "n"
+        # could start a pseudo expression like "n+1", or it could start a
+        # selector like "n|m". In order to handle this, we must regrettably
+        # backtrack.
+        expr, sel = nil, nil
+        pseudo_err = catch_error do
+          expr = pseudo_expr
+          next if tok?(/[,)]/)
+          expr = nil
+          expected '")"'
+        end
+
+        return expr if expr
+        sel_err = catch_error {sel = selector}
+        return sel if sel
+        rethrow pseudo_err if pseudo_err
+        rethrow sel_err if sel_err
+        return
+      end
+
+      def pseudo_expr
+        return unless e = tok(PLUS) || tok(/[-*]/) || tok(NUMBER) ||
+          interp_string || tok(IDENT) || interpolation
+        res = [e, str{ss}]
+        while e = tok(PLUS) || tok(/[-*]/) || tok(NUMBER) ||
+            interp_string || tok(IDENT) || interpolation
+          res << e << str{ss}
+        end
+        res
       end
 
       def declaration
-        # This allows the "*prop: val", ":prop: val", "#prop: val", and ".prop:
-        # val" hacks.
-        name_start_pos = source_position
-        if (s = tok(/[:\*\.]|\#(?!\{)/))
-          name = [s, str {ss}, *expr!(:interp_ident)]
+        # This allows the "*prop: val", ":prop: val", and ".prop: val" hacks
+        if s = tok(/[:\*\.]|\#(?!\{)/)
+          @use_property_exception = s !~ /[\.\#]/
+          name = [s, str{ss}, *expr!(:interp_ident)]
         else
-          return unless (name = interp_ident)
-          name = Array(name)
+          return unless name = interp_ident
+          name = [name] if name.is_a?(String)
         end
-
-        if (comment = tok(COMMENT))
+        if comment = tok(COMMENT)
           name << comment
         end
-        name_end_pos = source_position
         ss
 
         tok!(/:/)
-        ss
-        value_start_pos = source_position
-        value = value!
-        value_end_pos = source_position
+        space, value = value!
         ss
         require_block = tok?(/\{/)
 
-        node = node(Sass::Tree::PropNode.new(name.flatten.compact, value, :new),
-                    name_start_pos, value_end_pos)
-        node.name_source_range = range(name_start_pos, name_end_pos)
-        node.value_source_range = range(value_start_pos, value_end_pos)
+        node = node(Sass::Tree::PropNode.new(name.flatten.compact, value, :new))
 
         return node unless require_block
-        nested_properties! node
+        nested_properties! node, space
       end
 
       def value!
-        if tok?(/\{/)
-          str = Sass::Script::Tree::Literal.new(Sass::Script::Value::String.new(""))
-          str.line = source_position.line
-          str.source_range = range(source_position)
-          return str
-        end
+        space = !str {ss}.empty?
+        @use_property_exception ||= space || !tok?(IDENT)
 
-        start_pos = source_position
+        return true, Sass::Script::String.new("") if tok?(/\{/)
         # This is a bit of a dirty trick:
         # if the value is completely static,
         # we don't parse it at all, and instead return a plain old string
         # containing the value.
         # This results in a dramatic speed increase.
-        if (val = tok(STATIC_VALUE, true))
-          str = Sass::Script::Tree::Literal.new(Sass::Script::Value::String.new(val.strip))
-          str.line = start_pos.line
-          str.source_range = range(start_pos)
-          return str
+        if val = tok(STATIC_VALUE, true)
+          return space, Sass::Script::String.new(val.strip)
         end
-        sass_script(:parse)
+        return space, sass_script(:parse)
       end
 
-      def nested_properties!(node)
+      def nested_properties!(node, space)
+        err(<<MESSAGE) unless space
+Invalid CSS: a space is required between a property and its definition
+when it has other properties nested beneath it.
+MESSAGE
+
+        @use_property_exception = true
         @expected = 'expression (e.g. 1px, bold) or "{"'
         block(node, :property)
       end
 
       def expr(allow_var = true)
-        t = term(allow_var)
-        return unless t
-        res = [t, str {ss}]
+        return unless t = term(allow_var)
+        res = [t, str{ss}]
 
         while (o = operator) && (t = term(allow_var))
-          res << o << t << str {ss}
+          res << o << t << str{ss}
         end
 
         res.flatten
       end
 
       def term(allow_var)
-        e = tok(NUMBER) ||
+        if e = tok(NUMBER) ||
             interp_uri ||
             function(allow_var) ||
             interp_string ||
@@ -904,42 +913,36 @@ module Sass
             interp_ident ||
             tok(HEXCOLOR) ||
             (allow_var && var_expr)
-        return e if e
+          return e
+        end
 
-        op = tok(/[+-]/)
-        return unless op
+        return unless op = tok(/[+-]/)
         @expected = "number or function"
-        [op,
-         tok(NUMBER) || function(allow_var) || (allow_var && var_expr) || expr!(:interpolation)]
+        return [op, tok(NUMBER) || function(allow_var) ||
+          (allow_var && var_expr) || expr!(:interpolation)]
       end
 
       def function(allow_var)
-        name = tok(FUNCTION)
-        return unless name
+        return unless name = tok(FUNCTION)
         if name == "expression(" || name == "calc("
           str, _ = Sass::Shared.balance(@scanner, ?(, ?), 1)
           [name, str]
         else
-          [name, str {ss}, expr(allow_var), tok!(/\)/)]
+          [name, str{ss}, expr(allow_var), tok!(/\)/)]
         end
       end
 
       def var_expr
         return unless tok(/\$/)
         line = @line
-        var = Sass::Script::Tree::Variable.new(tok!(IDENT))
+        var = Sass::Script::Variable.new(tok!(IDENT))
         var.line = line
         var
       end
 
-      def interpolation(warn_for_color = false)
+      def interpolation
         return unless tok(INTERP_START)
-        sass_script(:parse_interpolated, warn_for_color)
-      end
-
-      def string
-        return unless tok(STRING)
-        Sass::Script::Value::String.value(@scanner[1] || @scanner[2])
+        sass_script(:parse_interpolated)
       end
 
       def interp_string
@@ -951,8 +954,7 @@ module Sass
       end
 
       def _interp_string(type)
-        start = tok(Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[type][false])
-        return unless start
+        return unless start = tok(Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[type][false])
         res = [start]
 
         mid_re = Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[type][true]
@@ -966,20 +968,21 @@ module Sass
       end
 
       def interp_ident(start = IDENT)
-        val = tok(start) || interpolation(:warn_for_color) || tok(IDENT_HYPHEN_INTERP, true)
-        return unless val
+        return unless val = tok(start) || interpolation || tok(IDENT_HYPHEN_INTERP, true)
         res = [val]
-        while (val = tok(NAME) || interpolation(:warn_for_color))
+        while val = tok(NAME) || interpolation
           res << val
         end
         res
       end
 
       def interp_ident_or_var
-        id = interp_ident
-        return id if id
-        var = var_expr
-        return [var] if var
+        (id = interp_ident) and return id
+        (var = var_expr) and return [var]
+      end
+
+      def interp_name
+        interp_ident NAME
       end
 
       def str
@@ -993,35 +996,29 @@ module Sass
       def str?
         pos = @scanner.pos
         line = @line
-        offset = @offset
         @strs.push ""
         throw_error {yield} && @strs.last
       rescue Sass::SyntaxError
         @scanner.pos = pos
         @line = line
-        @offset = offset
         nil
       ensure
         @strs.pop
       end
 
-      def node(node, start_pos, end_pos = source_position)
-        node.line = start_pos.line
-        node.source_range = range(start_pos, end_pos)
+      def node(node)
+        node.line = @line
         node
       end
 
       @sass_script_parser = Class.new(Sass::Script::Parser)
       @sass_script_parser.send(:include, ScriptParser)
-
-      class << self
-        # @private
-        attr_accessor :sass_script_parser
-      end
+      # @private
+      def self.sass_script_parser; @sass_script_parser; end
 
       def sass_script(*args)
-        parser = self.class.sass_script_parser.new(@scanner, @line, @offset,
-                                                   :filename => @filename, :importer => @importer)
+        parser = self.class.sass_script_parser.new(@scanner, @line,
+          @scanner.pos - (@scanner.string[0...@scanner.pos].rindex("\n") || 0))
         result = parser.send(*args)
         unless @strs.empty?
           # Convert to CSS manually so that comments are ignored.
@@ -1029,7 +1026,6 @@ module Sass
           @strs.each {|s| s << src}
         end
         @line = parser.line
-        @offset = parser.offset
         result
       rescue Sass::SyntaxError => e
         throw(:_sass_parser_error, true) if @throw_error
@@ -1044,51 +1040,41 @@ module Sass
         :media_query => "media query (e.g. print, screen, print and screen)",
         :media_query_list => "media query (e.g. print, screen, print and screen)",
         :media_expr => "media expression (e.g. (min-device-width: 800px))",
-        :at_root_query => "@at-root query (e.g. (without: media))",
-        :at_root_directive_list => '* or identifier',
-        :pseudo_args => "expression (e.g. fr, 2n+1)",
+        :pseudo_arg => "expression (e.g. fr, 2n+1)",
         :interp_ident => "identifier",
+        :interp_name => "identifier",
         :qualified_name => "identifier",
         :expr => "expression (e.g. 1px, bold)",
+        :_selector => "selector",
         :selector_comma_sequence => "selector",
-        :string => "string",
+        :simple_selector_sequence => "selector",
         :import_arg => "file to import (string or url())",
         :moz_document_function => "matching function (e.g. url-prefix(), domain())",
         :supports_condition => "@supports condition (e.g. (display: flexbox))",
         :supports_condition_in_parens => "@supports condition (e.g. (display: flexbox))",
-        :a_n_plus_b => "An+B expression",
-        :keyframes_selector_component => "from, to, or a percentage",
-        :keyframes_selector => "keyframes selector (e.g. 10%)"
       }
 
-      TOK_NAMES = Sass::Util.to_hash(Sass::SCSS::RX.constants.map do |c|
-        [Sass::SCSS::RX.const_get(c), c.downcase]
-      end).merge(
-        IDENT => "identifier",
-        /[;{}]/ => '";"',
-        /\b(without|with)\b/ => '"with" or "without"'
-      )
+      TOK_NAMES = Sass::Util.to_hash(
+        Sass::SCSS::RX.constants.map {|c| [Sass::SCSS::RX.const_get(c), c.downcase]}).
+        merge(IDENT => "identifier", /[;}]/ => '";"')
 
       def tok?(rx)
         @scanner.match?(rx)
       end
 
       def expr!(name)
-        e = send(name)
-        return e if e
+        (e = send(name)) && (return e)
         expected(EXPR_NAMES[name] || name.to_s)
       end
 
       def tok!(rx)
-        t = tok(rx)
-        return t if t
+        (t = tok(rx)) && (return t)
         name = TOK_NAMES[rx]
 
         unless name
           # Display basic regexps as plain old strings
-          source = rx.source.gsub(/\\\//, '/')
           string = rx.source.gsub(/\\(.)/, '\1')
-          name = source == Regexp.escape(string) ? string.inspect : rx.inspect
+          name = rx.source == Regexp.escape(string) ? string.inspect : rx.inspect
         end
 
         expected(name)
@@ -1115,12 +1101,10 @@ module Sass
         old_throw_error, @throw_error = @throw_error, true
         pos = @scanner.pos
         line = @line
-        offset = @offset
         expected = @expected
         if catch(:_sass_parser_error) {yield; false}
           @scanner.pos = pos
           @line = line
-          @offset = offset
           @expected = expected
           {:pos => pos, :line => line, :expected => @expected, :block => block}
         end
@@ -1183,15 +1167,7 @@ module Sass
             @scanner.pos -= @scanner[-1].length
             res.slice!(-@scanner[-1].length..-1)
           end
-
-          newline_count = res.count(NEWLINE)
-          if newline_count > 0
-            @line += newline_count
-            @offset = res[res.rindex(NEWLINE)..-1].size
-          else
-            @offset += res.size
-          end
-
+          @line += res.count(NEWLINE)
           @expected = nil
           if !@strs.empty? && rx != COMMENT && rx != SINGLE_LINE_COMMENT
             @strs.each {|s| s << res}
@@ -1199,11 +1175,6 @@ module Sass
           res
         end
       end
-
-      # Remove a vendor prefix from `str`.
-      def deprefix(str)
-        str.gsub(/^-[a-zA-Z0-9]+-/, '')
-      end
     end
   end
 end