oreorenasass 3.4.4 → 3.4.5

data/lib/sass/script/css_lexer.rb

@@ -12,20 +12,16 @@ module Sass
 
       def string(re, *args)
         if re == :uri
-          uri = scan(URI)
-          return unless uri
-          return [:string, Script::Value::String.new(uri)]
+          return unless uri = scan(URI)
+          return [:string, Script::String.new(uri)]
         end
 
         return unless scan(STRING)
-        string_value = Sass::Script::Value::String.value(@scanner[1] || @scanner[2])
-        value = Script::Value::String.new(string_value, :string)
-        [:string, value]
+        [:string, Script::String.new((@scanner[1] || @scanner[2]).gsub(/\\(['"])/, '\1'), :string)]
       end
 
       def important
-        s = scan(IMPORTANT)
-        return unless s
+        return unless s = scan(IMPORTANT)
         [:raw, s]
       end
     end

data/lib/sass/script/css_parser.rb

@@ -17,11 +17,8 @@ module Sass
       production :div, :unary_plus, :div
 
       def string
-        tok = try_tok(:string)
-        return number unless tok
-        unless @lexer.peek && @lexer.peek.type == :begin_interpolation
-          return literal_node(tok.value, tok.source_range)
-        end
+        return number unless tok = try_tok(:string)
+        return tok.value unless @lexer.peek && @lexer.peek.type == :begin_interpolation
       end
 
       # Short-circuit all the SassScript-only productions

data/lib/sass/script/funcall.rb

@@ -0,0 +1,245 @@
+require 'sass/script/functions'
+
+module Sass
+  module Script
+    # A SassScript parse node representing a function call.
+    #
+    # A function call either calls one of the functions in {Script::Functions},
+    # or if no function with the given name exists
+    # it returns a string representation of the function call.
+    class Funcall < Node
+      # The name of the function.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # The arguments to the function.
+      #
+      # @return [Array<Script::Node>]
+      attr_reader :args
+
+      # The keyword arguments to the function.
+      #
+      # @return [{String => Script::Node}]
+      attr_reader :keywords
+
+      # The splat argument for this function, if one exists.
+      #
+      # @return [Script::Node?]
+      attr_accessor :splat
+
+      # @param name [String] See \{#name}
+      # @param args [Array<Script::Node>] See \{#args}
+      # @param splat [Script::Node] See \{#splat}
+      # @param keywords [{String => Script::Node}] See \{#keywords}
+      def initialize(name, args, keywords, splat)
+        @name = name
+        @args = args
+        @keywords = keywords
+        @splat = splat
+        super()
+      end
+
+      # @return [String] A string representation of the function call
+      def inspect
+        args = @args.map {|a| a.inspect}.join(', ')
+        keywords = Sass::Util.hash_to_a(@keywords).
+            map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
+        if self.splat
+          splat = (args.empty? && keywords.empty?) ? "" : ", "
+          splat = "#{splat}#{self.splat.inspect}..."
+        end
+        "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
+      end
+
+      # @see Node#to_sass
+      def to_sass(opts = {})
+        arg_to_sass = lambda do |arg|
+          sass = arg.to_sass(opts)
+          sass = "(#{sass})" if arg.is_a?(Sass::Script::List) && arg.separator == :comma
+          sass
+        end
+
+        args = @args.map(&arg_to_sass).join(', ')
+        keywords = Sass::Util.hash_to_a(@keywords).
+          map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}.join(', ')
+        if self.splat
+          splat = (args.empty? && keywords.empty?) ? "" : ", "
+          splat = "#{splat}#{arg_to_sass[self.splat]}..."
+        end
+        "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
+      end
+
+      # Returns the arguments to the function.
+      #
+      # @return [Array<Node>]
+      # @see Node#children
+      def children
+        res = @args + @keywords.values
+        res << @splat if @splat
+        res
+      end
+
+      # @see Node#deep_copy
+      def deep_copy
+        node = dup
+        node.instance_variable_set('@args', args.map {|a| a.deep_copy})
+        node.instance_variable_set('@keywords', Hash[keywords.map {|k, v| [k, v.deep_copy]}])
+        node
+      end
+
+      protected
+
+      # Evaluates the function call.
+      #
+      # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+      # @return [Literal] The SassScript object that is the value of the function call
+      # @raise [Sass::SyntaxError] if the function call raises an ArgumentError
+      def _perform(environment)
+        args = @args.map {|a| a.perform(environment)}
+        splat = @splat.perform(environment) if @splat
+        if fn = environment.function(@name)
+          keywords = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
+          return without_original(perform_sass_fn(fn, args, keywords, splat))
+        end
+
+        ruby_name = @name.tr('-', '_')
+        args = construct_ruby_args(ruby_name, args, splat, environment)
+
+        unless Functions.callable?(ruby_name)
+          without_original(opts(to_literal(args)))
+        else
+          without_original(opts(Functions::EvaluationContext.new(environment.options).
+              send(ruby_name, *args)))
+        end
+      rescue ArgumentError => e
+        message = e.message
+
+        # If this is a legitimate Ruby-raised argument error, re-raise it.
+        # Otherwise, it's an error in the user's stylesheet, so wrap it.
+        if Sass::Util.rbx?
+          # Rubinius has a different error report string than vanilla Ruby. It
+          # also doesn't put the actual method for which the argument error was
+          # thrown in the backtrace, nor does it include `send`, so we look for
+          # `_perform`.
+          if e.message =~ /^method '([^']+)': given (\d+), expected (\d+)/
+            error_name, given, expected = $1, $2, $3
+            raise e if error_name != ruby_name || e.backtrace[0] !~ /:in `_perform'$/
+            message = "wrong number of arguments (#{given} for #{expected})"
+          end
+        elsif Sass::Util.jruby?
+          if Sass::Util.jruby1_6?
+            should_maybe_raise = e.message =~ /^wrong number of arguments \((\d+) for (\d+)\)/ &&
+              # The one case where JRuby does include the Ruby name of the function
+              # is manually-thrown ArgumentErrors, which are indistinguishable from
+              # legitimate ArgumentErrors. We treat both of these as
+              # Sass::SyntaxErrors even though it can hide Ruby errors.
+              e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
+          else
+            should_maybe_raise = e.message =~ /^wrong number of arguments calling `[^`]+` \((\d+) for (\d+)\)/
+            given, expected = $1, $2
+          end
+
+          if should_maybe_raise
+            # JRuby 1.7 includes __send__ before send and _perform.
+            trace = e.backtrace.dup
+            raise e if !Sass::Util.jruby1_6? && trace.shift !~ /:in `__send__'$/
+
+            # JRuby (as of 1.7.2) doesn't put the actual method
+            # for which the argument error was thrown in the backtrace, so we
+            # detect whether our send threw an argument error.
+            if !(trace[0] =~ /:in `send'$/ && trace[1] =~ /:in `_perform'$/)
+              raise e
+            elsif !Sass::Util.jruby1_6?
+              # JRuby 1.7 doesn't use standard formatting for its ArgumentErrors.
+              message = "wrong number of arguments (#{given} for #{expected})"
+            end
+          end
+        elsif e.message =~ /^wrong number of arguments \(\d+ for \d+\)/ &&
+            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
+          raise e
+        end
+        raise Sass::SyntaxError.new("#{message} for `#{name}'")
+      end
+
+      # This method is factored out from `_perform` so that compass can override
+      # it with a cross-browser implementation for functions that require vendor prefixes
+      # in the generated css.
+      def to_literal(args)
+        Script::String.new("#{name}(#{args.join(', ')})")
+      end
+
+      private
+
+      def without_original(value)
+        return value unless value.is_a?(Number)
+        value = value.dup
+        value.original = nil
+        return value
+      end
+
+      def construct_ruby_args(name, args, splat, environment)
+        args += splat.to_a if splat
+
+        # If variable arguments were passed, there won't be any explicit keywords.
+        if splat.is_a?(Sass::Script::ArgList)
+          kwargs_size = splat.keywords.size
+          splat.keywords_accessed = false
+        else
+          kwargs_size = @keywords.size
+        end
+
+        unless signature = Functions.signature(name.to_sym, args.size, kwargs_size)
+          return args if @keywords.empty?
+          raise Sass::SyntaxError.new("Function #{name} doesn't support keyword arguments")
+        end
+        keywords = splat.is_a?(Sass::Script::ArgList) ? splat.keywords :
+          Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
+
+        # If the user passes more non-keyword args than the function expects,
+        # but it does expect keyword args, Ruby's arg handling won't raise an error.
+        # Since we don't want to make functions think about this,
+        # we'll handle it for them here.
+        if signature.var_kwargs && !signature.var_args && args.size > signature.args.size
+          raise Sass::SyntaxError.new(
+            "#{args[signature.args.size].inspect} is not a keyword argument for `#{name}'")
+        elsif keywords.empty?
+          return args 
+        end
+
+        args = args + signature.args[args.size..-1].map do |argname|
+          if keywords.has_key?(argname)
+            keywords.delete(argname)
+          else
+            raise Sass::SyntaxError.new("Function #{name} requires an argument named $#{argname}")
+          end
+        end
+
+        if keywords.size > 0
+          if signature.var_kwargs
+            args << keywords
+          else
+            argname = keywords.keys.sort.first
+            if signature.args.include?(argname)
+              raise Sass::SyntaxError.new("Function #{name} was passed argument $#{argname} both by position and by name")
+            else
+              raise Sass::SyntaxError.new("Function #{name} doesn't have an argument named $#{argname}")
+            end
+          end
+        end
+
+        args
+      end
+
+      def perform_sass_fn(function, args, keywords, splat)
+        Sass::Tree::Visitors::Perform.perform_arguments(function, args, keywords, splat) do |env|
+          val = catch :_sass_return do
+            function.tree.each {|c| Sass::Tree::Visitors::Perform.visit(c, env)}
+            raise Sass::SyntaxError.new("Function #{@name} finished without @return")
+          end
+          val
+        end
+      end
+    end
+  end
+end

data/lib/sass/script/functions.rb

@@ -1,15 +1,10 @@
-require 'sass/script/value/helpers'
-
 module Sass::Script
-  # @comment
-  #   YARD can't handle some multiline tags, and we need really long tags for function declarations.
-  #   rubocop:disable LineLength
   # Methods in this module are accessible from the SassScript context.
   # For example, you can write
   #
   #     $color: hsl(120deg, 100%, 50%)
   #
-  # and it will call {Functions#hsl}.
+  # and it will call {Sass::Script::Functions#hsl}.
   #
   # The following functions are provided:
   #
@@ -18,12 +13,10 @@ module Sass::Script
   # ## RGB Functions
   #
   # \{#rgb rgb($red, $green, $blue)}
-  # : Creates a {Sass::Script::Value::Color Color} from red, green, and blue
-  #   values.
+  # : Creates a {Color} from red, green, and blue values.
   #
   # \{#rgba rgba($red, $green, $blue, $alpha)}
-  # : Creates a {Sass::Script::Value::Color Color} from red, green, blue, and
-  #   alpha values.
+  # : Creates a {Color} from red, green, blue, and alpha values.
   #
   # \{#red red($color)}
   # : Gets the red component of a color.
@@ -34,18 +27,17 @@ module Sass::Script
   # \{#blue blue($color)}
   # : Gets the blue component of a color.
   #
-  # \{#mix mix($color1, $color2, \[$weight\])}
+  # \{#mix mix($color-1, $color-2, \[$weight\])}
   # : Mixes two colors together.
   #
   # ## HSL Functions
   #
   # \{#hsl hsl($hue, $saturation, $lightness)}
-  # : Creates a {Sass::Script::Value::Color Color} from hue, saturation, and
-  #   lightness values.
+  # : Creates a {Color} from hue, saturation, and lightness values.
   #
   # \{#hsla hsla($hue, $saturation, $lightness, $alpha)}
-  # : Creates a {Sass::Script::Value::Color Color} from hue, saturation,
-  #   lightness, and alpha values.
+  # : Creates a {Color} from hue, saturation, lightness, and alpha
+  #   values.
   #
   # \{#hue hue($color)}
   # : Gets the hue component of a color.
@@ -116,39 +108,21 @@ module Sass::Script
   # \{#quote quote($string)}
   # : Adds quotes to a string.
   #
-  # \{#str_length str-length($string)}
-  # : Returns the number of characters in a string.
-  #
-  # \{#str_insert str-insert($string, $insert, $index)}
-  # : Inserts `$insert` into `$string` at `$index`.
-  #
-  # \{#str_index str-index($string, $substring)}
-  # : Returns the index of the first occurance of `$substring` in `$string`.
-  #
-  # \{#str_slice str-slice($string, $start-at, [$end-at])}
-  # : Extracts a substring from `$string`.
-  #
-  # \{#to_upper_case to-upper-case($string)}
-  # : Converts a string to upper case.
-  #
-  # \{#to_lower_case to-lower-case($string)}
-  # : Converts a string to lower case.
-  #
   # ## Number Functions
   #
-  # \{#percentage percentage($number)}
+  # \{#percentage percentage($value)}
   # : Converts a unitless number to a percentage.
   #
-  # \{#round round($number)}
+  # \{#round round($value)}
   # : Rounds a number to the nearest whole number.
   #
-  # \{#ceil ceil($number)}
+  # \{#ceil ceil($value)}
   # : Rounds a number up to the next whole number.
   #
-  # \{#floor floor($number)}
+  # \{#floor floor($value)}
   # : Rounds a number down to the previous whole number.
   #
-  # \{#abs abs($number)}
+  # \{#abs abs($value)}
   # : Returns the absolute value of a number.
   #
   # \{#min min($numbers...)\}
@@ -157,13 +131,8 @@ module Sass::Script
   # \{#max max($numbers...)\}
   # : Finds the maximum of several numbers.
   #
-  # \{#random random([$limit])\}
-  # : Returns a random number.
-  #
   # ## List Functions {#list-functions}
   #
-  # All list functions work for maps as well, treating them as lists of pairs.
-  #
   # \{#length length($list)}
   # : Returns the length of a list.
   #
@@ -182,94 +151,8 @@ module Sass::Script
   # \{#index index($list, $value)}
   # : Returns the position of a value within a list.
   #
-  # \{#list_separator list-separator(#list)}
-  # : Returns the separator of a list.
-  #
-  # ## Map Functions {#map-functions}
-  #
-  # \{#map_get map-get($map, $key)}
-  # : Returns the value in a map associated with a given key.
-  #
-  # \{#map_merge map-merge($map1, $map2)}
-  # : Merges two maps together into a new map.
-  #
-  # \{#map_remove map-remove($map, $keys...)}
-  # : Returns a new map with keys removed.
-  #
-  # \{#map_keys map-keys($map)}
-  # : Returns a list of all keys in a map.
-  #
-  # \{#map_values map-values($map)}
-  # : Returns a list of all values in a map.
-  #
-  # \{#map_has_key map-has-key($map, $key)}
-  # : Returns whether a map has a value associated with a given key.
-  #
-  # \{#keywords keywords($args)}
-  # : Returns the keywords passed to a function that takes variable arguments.
-  #
-  # ## Selector Functions
-  #
-  # Selector functions are very liberal in the formats they support
-  # for selector arguments. They can take a plain string, a list of
-  # lists as returned by `&` or anything in between:
-  #
-  # * A plain sring, such as `".foo .bar, .baz .bang"`.
-  # * A space-separated list of strings such as `(".foo" ".bar")`.
-  # * A comma-separated list of strings such as `(".foo .bar", ".baz .bang")`.
-  # * A comma-separated list of space-separated lists of strings such
-  #   as `((".foo" ".bar"), (".baz" ".bang"))`.
-  #
-  # In general, selector functions allow placeholder selectors
-  # (`%foo`) but disallow parent-reference selectors (`&`).
-  #
-  # \{#selector_nest selector-nest($selectors...)}
-  # : Nests selector beneath one another like they would be nested in the
-  #   stylesheet.
-  #
-  # \{#selector_append selector-append($selectors...)}
-  # : Appends selectors to one another without spaces in between.
-  #
-  # \{#selector_extend selector-extend($selector, $extendee, $extender)}
-  # : Extends `$extendee` with `$extender` within `$selector`.
-  #
-  # \{#selector_replace selector-replace($selector, $original, $replacement)}
-  # : Replaces `$original` with `$replacement` within `$selector`.
-  #
-  # \{#selector_unify selector-unify($selector1, $selector2)}
-  # : Unifies two selectors to produce a selector that matches
-  #   elements matched by both.
-  #
-  # \{#is_superselector is-superselector($super, $sub)}
-  # : Returns whether `$super` matches all the elements `$sub` does, and
-  #   possibly more.
-  #
-  # \{#simple_selectors simple-selectors($selector)}
-  # : Returns the simple selectors that comprise a compound selector.
-  #
-  # \{#selector_parse selector-parse($selector)}
-  # : Parses a selector into the format returned by `&`.
-  #
   # ## Introspection Functions
   #
-  # \{#feature_exists feature-exists($feature)}
-  # : Returns whether a feature exists in the current Sass runtime.
-  #
-  # \{#variable_exists variable-exists($name)}
-  # : Returns whether a variable with the given name exists in the current scope.
-  #
-  # \{#global_variable_exists global-variable-exists($name)}
-  # : Returns whether a variable with the given name exists in the global scope.
-  #
-  # \{#function_exists function-exists($name)}
-  # : Returns whether a function with the given name exists.
-  #
-  # \{#mixin_exists mixin-exists($name)}
-  # : Returns whether a mixin with the given name exists.
-  #
-  # \{#inspect inspect($value)}
-  # : Returns the string representation of a value as it would be represented in Sass.
-  #
   # \{#type_of type-of($value)}
   # : Returns the type of a value.
   #
@@ -279,21 +162,15 @@ module Sass::Script
   # \{#unitless unitless($number)}
   # : Returns whether a number has units.
   #
-  # \{#comparable comparable($number1, $number2)}
+  # \{#comparable comparable($number-1, $number-2)}
   # : Returns whether two numbers can be added, subtracted, or compared.
   #
-  # \{#call call($name, $args...)}
-  # : Dynamically calls a Sass function.
-  #
   # ## Miscellaneous Functions
   #
   # \{#if if($condition, $if-true, $if-false)}
   # : Returns one of two values, depending on whether or not `$condition` is
   #   true.
   #
-  # \{#unique_id unique-id()}
-  # : Returns a unique CSS identifier.
-  #
   # ## Adding Custom Functions
   #
   # New Sass functions can be added by adding Ruby methods to this module.
@@ -302,9 +179,9 @@ module Sass::Script
   #     module Sass::Script::Functions
   #       def reverse(string)
   #         assert_type string, :String
-  #         Sass::Script::Value::String.new(string.value.reverse)
+  #         Sass::Script::String.new(string.value.reverse)
   #       end
-  #       declare :reverse, [:string]
+  #       declare :reverse, :args => [:string]
   #     end
   #
   # Calling {declare} tells Sass the argument names for your function.
@@ -312,15 +189,14 @@ module Sass::Script
   # {declare} can also allow your function to take arbitrary keyword arguments.
   #
   # There are a few things to keep in mind when modifying this module.
-  # First of all, the arguments passed are {Value} objects.
-  # Value objects are also expected to be returned.
+  # First of all, the arguments passed are {Sass::Script::Literal} objects.
+  # Literal objects are also expected to be returned.
   # This means that Ruby values must be unwrapped and wrapped.
   #
-  # Most Value objects support the {Value::Base#value value} accessor for getting
-  # their Ruby values. Color objects, though, must be accessed using
-  # {Sass::Script::Value::Color#rgb rgb}, {Sass::Script::Value::Color#red red},
-  # {Sass::Script::Value::Color#blue green}, or {Sass::Script::Value::Color#blue
-  # blue}.
+  # Most Literal objects support the {Sass::Script::Literal#value value} accessor
+  # for getting their Ruby values.
+  # Color objects, though, must be accessed using {Sass::Script::Color#rgb rgb},
+  # {Sass::Script::Color#red red}, {Sass::Script::Color#blue green}, or {Sass::Script::Color#blue blue}.
   #
   # Second, making Ruby functions accessible from Sass introduces the temptation
   # to do things like database access within stylesheets.
@@ -340,24 +216,19 @@ module Sass::Script
   #
   # ### Caveats
   #
-  # When creating new {Value} objects within functions, be aware that it's not
-  # safe to call {Value::Base#to_s #to_s} (or other methods that use the string
-  # representation) on those objects without first setting {Tree::Node#options=
-  # the #options attribute}.
-  #
-  # @comment
-  #   rubocop:enable LineLength
+  # When creating new {Literal} objects within functions,
+  # be aware that it's not safe to call {Literal#to_s #to_s}
+  # (or other methods that use the string representation)
+  # on those objects without first setting {Node#options= the #options attribute}.
   module Functions
     @signatures = {}
 
     # A class representing a Sass function signature.
     #
-    # @attr args [Array<String>] The names of the arguments to the function.
-    # @attr delayed_args [Array<String>] The names of the arguments whose evaluation should be
-    #   delayed.
+    # @attr args [Array<Symbol>] The names of the arguments to the function.
     # @attr var_args [Boolean] Whether the function takes a variable number of arguments.
     # @attr var_kwargs [Boolean] Whether the function takes an arbitrary set of keyword arguments.
-    Signature = Struct.new(:args, :delayed_args, :var_args, :var_kwargs, :deprecated)
+    Signature = Struct.new(:args, :var_args, :var_kwargs)
 
     # Declare a Sass signature for a Ruby-defined function.
     # This includes the names of the arguments,
@@ -390,30 +261,15 @@ module Sass::Script
     #   Whether the function accepts other keyword arguments
     #   in addition to those in `:args`.
     #   If this is true, the Ruby function will be passed a hash from strings
-    #   to {Value}s as the last argument.
+    #   to {Sass::Script::Literal}s as the last argument.
     #   In addition, if this is true and `:var_args` is not,
     #   Sass will ensure that the last argument passed is a hash.
     def self.declare(method_name, args, options = {})
-      delayed_args = []
-      args = args.map do |a|
-        a = a.to_s
-        if a[0] == ?&
-          a = a[1..-1]
-          delayed_args << a
-        end
-        a
-      end
-      # We don't expose this functionality except to certain builtin methods.
-      if delayed_args.any? && method_name != :if
-        raise ArgumentError.new("Delayed arguments are not allowed for method #{method_name}")
-      end
       @signatures[method_name] ||= []
       @signatures[method_name] << Signature.new(
-        args,
-        delayed_args,
+        args.map {|s| s.to_s},
         options[:var_args],
-        options[:var_kwargs],
-        options[:deprecated] && options[:deprecated].map {|a| a.to_s})
+        options[:var_kwargs])
     end
 
     # Determine the correct signature for the number of arguments
@@ -421,8 +277,8 @@ module Sass::Script
     # If no signatures match, the first signature is returned for error messaging.
     #
     # @param method_name [Symbol] The name of the Ruby function to be called.
-    # @param arg_arity [Fixnum] The number of unnamed arguments the function was passed.
-    # @param kwarg_arity [Fixnum] The number of keyword arguments the function was passed.
+    # @param arg_arity [Number] The number of unnamed arguments the function was passed.
+    # @param kwarg_arity [Number] The number of keyword arguments the function was passed.
     #
     # @return [{Symbol => Object}, nil]
     #   The signature options for the matching signature,
@@ -430,76 +286,42 @@ module Sass::Script
     def self.signature(method_name, arg_arity, kwarg_arity)
       return unless @signatures[method_name]
       @signatures[method_name].each do |signature|
-        sig_arity = signature.args.size
-        return signature if sig_arity == arg_arity + kwarg_arity
-        next unless sig_arity < arg_arity + kwarg_arity
+        return signature if signature.args.size == arg_arity + kwarg_arity
+        next unless signature.args.size < arg_arity + kwarg_arity
 
         # We have enough args.
         # Now we need to figure out which args are varargs
         # and if the signature allows them.
         t_arg_arity, t_kwarg_arity = arg_arity, kwarg_arity
-        if sig_arity > t_arg_arity
+        if signature.args.size > t_arg_arity
           # we transfer some kwargs arity to args arity
           # if it does not have enough args -- assuming the names will work out.
-          t_kwarg_arity -= (sig_arity - t_arg_arity)
-          t_arg_arity = sig_arity
+          t_kwarg_arity -= (signature.args.size - t_arg_arity)
+          t_arg_arity = signature.args.size
         end
 
-        if   (t_arg_arity == sig_arity ||   t_arg_arity > sig_arity && signature.var_args) &&
-           (t_kwarg_arity == 0         || t_kwarg_arity > 0         && signature.var_kwargs)
+        if (  t_arg_arity == signature.args.size ||   t_arg_arity > signature.args.size && signature.var_args  ) &&
+           (t_kwarg_arity == 0                   || t_kwarg_arity > 0                   && signature.var_kwargs)
           return signature
         end
       end
       @signatures[method_name].first
     end
 
-    # Sets the random seed used by Sass's internal random number generator.
-    #
-    # This can be used to ensure consistent random number sequences which
-    # allows for consistent results when testing, etc.
-    #
-    # @param seed [Integer]
-    # @return [Integer] The same seed.
-    def self.random_seed=(seed)
-      @random_number_generator = Sass::Util::CrossPlatformRandom.new(seed)
-    end
-
-    # Get Sass's internal random number generator.
-    #
-    # @return [Random]
-    def self.random_number_generator
-      @random_number_generator ||= Sass::Util::CrossPlatformRandom.new
-    end
-
     # The context in which methods in {Script::Functions} are evaluated.
     # That means that all instance methods of {EvaluationContext}
     # are available to use in functions.
     class EvaluationContext
       include Functions
-      include Value::Helpers
-
-      # The human-readable names for [Sass::Script::Value::Base]. The default is
-      # just the downcased name of the type. The default is the downcased type
-      # name.
-      TYPE_NAMES = {:ArgList => 'variable argument list'}
-
-      # The environment for this function. This environment's
-      # {Environment#parent} is the global environment, and its
-      # {Environment#caller} is a read-only view of the local environment of the
-      # caller of this function.
-      #
-      # @return [Environment]
-      attr_reader :environment
 
       # The options hash for the {Sass::Engine} that is processing the function call
       #
       # @return [{Symbol => Object}]
       attr_reader :options
 
-      # @param environment [Environment] See \{#environment}
-      def initialize(environment)
-        @environment = environment
-        @options = environment.options
+      # @param options [{Symbol => Object}] See \{#options}
+      def initialize(options)
+        @options = options
       end
 
       # Asserts that the type of a given SassScript value
@@ -512,79 +334,15 @@ module Sass::Script
       # @example
       #   assert_type value, :String
       #   assert_type value, :Number
-      # @param value [Sass::Script::Value::Base] A SassScript value
+      # @param value [Sass::Script::Literal] A SassScript value
       # @param type [Symbol] The name of the type the value is expected to be
       # @param name [String, Symbol, nil] The name of the argument.
-      # @raise [ArgumentError] if value is not of the correct type.
       def assert_type(value, type, name = nil)
-        klass = Sass::Script::Value.const_get(type)
-        return if value.is_a?(klass)
-        return if value.is_a?(Sass::Script::Value::List) && type == :Map && value.value.empty?
-        err = "#{value.inspect} is not a #{TYPE_NAMES[type] || type.to_s.downcase}"
+        return if value.is_a?(Sass::Script.const_get(type))
+        err = "#{value.inspect} is not a #{type.to_s.downcase}"
         err = "$#{name.to_s.gsub('_', '-')}: " + err if name
         raise ArgumentError.new(err)
       end
-
-      # Asserts that the unit of the number is as expected.
-      #
-      # @example
-      #   assert_unit number, "px"
-      #   assert_unit number, nil
-      # @param number [Sass::Script::Value::Number] The number to be validated.
-      # @param unit [::String]
-      #   The unit that the number must have.
-      #   If nil, the number must be unitless.
-      # @param name [::String] The name of the parameter being validated.
-      # @raise [ArgumentError] if number is not of the correct unit or is not a number.
-      def assert_unit(number, unit, name = nil)
-        assert_type number, :Number, name
-        return if number.is_unit?(unit)
-        expectation = unit ? "have a unit of #{unit}" : "be unitless"
-        if name
-          raise ArgumentError.new("Expected $#{name} to #{expectation} but got #{number}")
-        else
-          raise ArgumentError.new("Expected #{number} to #{expectation}")
-        end
-      end
-
-      # Asserts that the value is an integer.
-      #
-      # @example
-      #   assert_integer 2px
-      #   assert_integer 2.5px
-      #     => SyntaxError: "Expected 2.5px to be an integer"
-      #   assert_integer 2.5px, "width"
-      #     => SyntaxError: "Expected width to be an integer but got 2.5px"
-      # @param number [Sass::Script::Value::Base] The value to be validated.
-      # @param name [::String] The name of the parameter being validated.
-      # @raise [ArgumentError] if number is not an integer or is not a number.
-      def assert_integer(number, name = nil)
-        assert_type number, :Number, name
-        return if number.int?
-        if name
-          raise ArgumentError.new("Expected $#{name} to be an integer but got #{number}")
-        else
-          raise ArgumentError.new("Expected #{number} to be an integer")
-        end
-      end
-
-      # Performs a node that has been delayed for execution.
-      #
-      # @private
-      # @param node [Sass::Script::Tree::Node,
-      #   Sass::Script::Value::Base] When this is a tree node, it's
-      #   performed in the caller's environment. When it's a value
-      #   (which can happen when the value had to be performed already
-      #   -- like for a splat), it's returned as-is.
-      # @param env [Sass::Environment] The environment within which to perform the node.
-      #   Defaults to the (read-only) environment of the caller.
-      def perform(node, env = environment.caller)
-        if node.is_a?(Sass::Script::Value::Base)
-          node
-        else
-          node.perform(env)
-        end
-      end
     end
 
     class << self
@@ -595,7 +353,6 @@ module Sass::Script
       alias_method :callable?, :public_method_defined?
 
       private
-
       def include(*args)
         r = super
         # We have to re-include ourselves into EvaluationContext to work around
@@ -605,58 +362,48 @@ module Sass::Script
       end
     end
 
-    # Creates a {Sass::Script::Value::Color Color} object from red, green, and
-    # blue values.
+    # Creates a {Color} object from red, green, and blue values.
     #
     # @see #rgba
     # @overload rgb($red, $green, $blue)
-    #   @param $red [Sass::Script::Value::Number] The amount of red in the color.
-    #     Must be between 0 and 255 inclusive, or between `0%` and `100%`
-    #     inclusive
-    #   @param $green [Sass::Script::Value::Number] The amount of green in the
-    #     color. Must be between 0 and 255 inclusive, or between `0%` and `100%`
-    #     inclusive
-    #   @param $blue [Sass::Script::Value::Number] The amount of blue in the
-    #     color. Must be between 0 and 255 inclusive, or between `0%` and `100%`
-    #     inclusive
-    # @return [Sass::Script::Value::Color]
+    # @param $red [Number] The amount of red in the color. Must be between 0 and
+    #   255 inclusive, or between `0%` and `100%` inclusive
+    # @param $green [Number] The amount of green in the color. Must be between 0
+    #   and 255 inclusive, or between `0%` and `100%` inclusive
+    # @param $blue [Number] The amount of blue in the color. Must be between 0
+    #   and 255 inclusive, or between `0%` and `100%` inclusive
+    # @return [Color]
     # @raise [ArgumentError] if any parameter is the wrong type or out of bounds
     def rgb(red, green, blue)
       assert_type red, :Number, :red
       assert_type green, :Number, :green
       assert_type blue, :Number, :blue
 
-      color_attrs = [[red, :red], [green, :green], [blue, :blue]].map do |(c, name)|
-        if c.is_unit?("%")
-          c.value * 255 / 100.0
-        elsif c.unitless?
-          c.value
-        else
-          raise ArgumentError.new("Expected #{c} to be unitless or have a unit of % but got #{c}")
-        end
-      end
-
-      # Don't store the string representation for function-created colors, both
-      # because it's not very useful and because some functions aren't supported
-      # on older browsers.
-      Sass::Script::Value::Color.new(color_attrs)
+      Color.new([[red, :red], [green, :green], [blue, :blue]].map do |(c, name)|
+          v = c.value
+          if c.numerator_units == ["%"] && c.denominator_units.empty?
+            v = Sass::Util.check_range("$#{name}: Color value", 0..100, c, '%')
+            v * 255 / 100.0
+          else
+            Sass::Util.check_range("$#{name}: Color value", 0..255, c)
+          end
+        end)
     end
     declare :rgb, [:red, :green, :blue]
 
-    # Creates a {Sass::Script::Value::Color Color} from red, green, blue, and
-    # alpha values.
+    # Creates a {Color} from red, green, blue, and alpha values.
     # @see #rgb
     #
     # @overload rgba($red, $green, $blue, $alpha)
-    #   @param $red [Sass::Script::Value::Number] The amount of red in the
-    #     color. Must be between 0 and 255 inclusive
-    #   @param $green [Sass::Script::Value::Number] The amount of green in the
-    #     color. Must be between 0 and 255 inclusive
-    #   @param $blue [Sass::Script::Value::Number] The amount of blue in the
-    #     color. Must be between 0 and 255 inclusive
-    #   @param $alpha [Sass::Script::Value::Number] The opacity of the color.
-    #     Must be between 0 and 1 inclusive
-    #   @return [Sass::Script::Value::Color]
+    #   @param $red [Number] The amount of red in the color. Must be between 0
+    #     and 255 inclusive
+    #   @param $green [Number] The amount of green in the color. Must be between
+    #     0 and 255 inclusive
+    #   @param $blue [Number] The amount of blue in the color. Must be between 0
+    #     and 255 inclusive
+    #   @param $alpha [Number] The opacity of the color. Must be between 0 and 1
+    #     inclusive
+    #   @return [Color]
     #   @raise [ArgumentError] if any parameter is the wrong type or out of
     #     bounds
     #
@@ -667,11 +414,10 @@ module Sass::Script
     #     rgba(#102030, 0.5) => rgba(16, 32, 48, 0.5)
     #     rgba(blue, 0.2)    => rgba(0, 0, 255, 0.2)
     #
-    #   @param $color [Sass::Script::Value::Color] The color whose opacity will
-    #     be changed.
-    #   @param $alpha [Sass::Script::Value::Number] The new opacity of the
-    #     color. Must be between 0 and 1 inclusive
-    #   @return [Sass::Script::Value::Color]
+    #   @param $color [Color] The color whose opacity will be changed.
+    #   @param $alpha [Number] The new opacity of the color. Must be between 0
+    #     and 1 inclusive
+    #   @return [Color]
     #   @raise [ArgumentError] if `$alpha` is out of bounds or either parameter
     #     is the wrong type
     def rgba(*args)
@@ -682,6 +428,7 @@ module Sass::Script
         assert_type color, :Color, :color
         assert_type alpha, :Number, :alpha
 
+        Sass::Util.check_range('Alpha channel', 0..1, alpha)
         color.with(:alpha => alpha.value)
       when 4
         red, green, blue, alpha = args
@@ -693,44 +440,43 @@ module Sass::Script
     declare :rgba, [:red, :green, :blue, :alpha]
     declare :rgba, [:color, :alpha]
 
-    # Creates a {Sass::Script::Value::Color Color} from hue, saturation, and
-    # lightness values. Uses the algorithm from the [CSS3 spec][].
+    # Creates a {Color} from hue, saturation, and lightness values. Uses the
+    # algorithm from the [CSS3 spec][].
     #
     # [CSS3 spec]: http://www.w3.org/TR/css3-color/#hsl-color
     #
     # @see #hsla
     # @overload hsl($hue, $saturation, $lightness)
-    #   @param $hue [Sass::Script::Value::Number] The hue of the color. Should be
-    #     between 0 and 360 degrees, inclusive
-    #   @param $saturation [Sass::Script::Value::Number] The saturation of the
-    #     color. Must be between `0%` and `100%`, inclusive
-    #   @param $lightness [Sass::Script::Value::Number] The lightness of the
-    #     color. Must be between `0%` and `100%`, inclusive
-    # @return [Sass::Script::Value::Color]
+    # @param $hue [Number] The hue of the color. Should be between 0 and 360
+    #   degrees, inclusive
+    # @param $saturation [Number] The saturation of the color. Must be between
+    #   `0%` and `100%`, inclusive
+    # @param $lightness [Number] The lightness of the color. Must be between
+    #   `0%` and `100%`, inclusive
+    # @return [Color]
     # @raise [ArgumentError] if `$saturation` or `$lightness` are out of bounds
     #   or any parameter is the wrong type
     def hsl(hue, saturation, lightness)
-      hsla(hue, saturation, lightness, number(1))
+      hsla(hue, saturation, lightness, Number.new(1))
     end
     declare :hsl, [:hue, :saturation, :lightness]
 
-    # Creates a {Sass::Script::Value::Color Color} from hue,
-    # saturation, lightness, and alpha values. Uses the algorithm from
-    # the [CSS3 spec][].
+    # Creates a {Color} from hue, saturation, lightness, and alpha
+    # values. Uses the algorithm from the [CSS3 spec][].
     #
     # [CSS3 spec]: http://www.w3.org/TR/css3-color/#hsl-color
     #
     # @see #hsl
     # @overload hsla($hue, $saturation, $lightness, $alpha)
-    #   @param $hue [Sass::Script::Value::Number] The hue of the color. Should be
-    #     between 0 and 360 degrees, inclusive
-    #   @param $saturation [Sass::Script::Value::Number] The saturation of the
-    #     color. Must be between `0%` and `100%`, inclusive
-    #   @param $lightness [Sass::Script::Value::Number] The lightness of the
-    #     color. Must be between `0%` and `100%`, inclusive
-    #   @param $alpha [Sass::Script::Value::Number] The opacity of the color. Must
-    #     be between 0 and 1, inclusive
-    # @return [Sass::Script::Value::Color]
+    # @param $hue [Number] The hue of the color. Should be between 0 and 360
+    #   degrees, inclusive
+    # @param $saturation [Number] The saturation of the color. Must be between
+    #   `0%` and `100%`, inclusive
+    # @param $lightness [Number] The lightness of the color. Must be between
+    #   `0%` and `100%`, inclusive
+    # @param $alpha [Number] The opacity of the color. Must be between 0 and 1,
+    #   inclusive
+    # @return [Color]
     # @raise [ArgumentError] if `$saturation`, `$lightness`, or `$alpha` are out
     #   of bounds or any parameter is the wrong type
     def hsla(hue, saturation, lightness, alpha)
@@ -739,15 +485,13 @@ module Sass::Script
       assert_type lightness, :Number, :lightness
       assert_type alpha, :Number, :alpha
 
+      Sass::Util.check_range('Alpha channel', 0..1, alpha)
+
       h = hue.value
-      s = saturation.value
-      l = lightness.value
-
-      # Don't store the string representation for function-created colors, both
-      # because it's not very useful and because some functions aren't supported
-      # on older browsers.
-      Sass::Script::Value::Color.new(
-        :hue => h, :saturation => s, :lightness => l, :alpha => alpha.value)
+      s = Sass::Util.check_range('Saturation', 0..100, saturation, '%')
+      l = Sass::Util.check_range('Lightness', 0..100, lightness, '%')
+
+      Color.new(:hue => h, :saturation => s, :lightness => l, :alpha => alpha.value)
     end
     declare :hsla, [:hue, :saturation, :lightness, :alpha]
 
@@ -757,13 +501,12 @@ module Sass::Script
     # [hsl-to-rgb]: http://www.w3.org/TR/css3-color/#hsl-color
     #
     # @overload red($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Number] The red component, between 0 and 255
-    #   inclusive
+    # @param $color [Color]
+    # @return [Number] The red component, between 0 and 255 inclusive
     # @raise [ArgumentError] if `$color` isn't a color
     def red(color)
       assert_type color, :Color, :color
-      number(color.red)
+      Sass::Script::Number.new(color.red)
     end
     declare :red, [:color]
 
@@ -773,13 +516,12 @@ module Sass::Script
     # [hsl-to-rgb]: http://www.w3.org/TR/css3-color/#hsl-color
     #
     # @overload green($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Number] The green component, between 0 and
-    #   255 inclusive
+    # @param $color [Color]
+    # @return [Number] The green component, between 0 and 255 inclusive
     # @raise [ArgumentError] if `$color` isn't a color
     def green(color)
       assert_type color, :Color, :color
-      number(color.green)
+      Sass::Script::Number.new(color.green)
     end
     declare :green, [:color]
 
@@ -789,13 +531,12 @@ module Sass::Script
     # [hsl-to-rgb]: http://www.w3.org/TR/css3-color/#hsl-color
     #
     # @overload blue($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Number] The blue component, between 0 and
-    #   255 inclusive
+    # @param $color [Color]
+    # @return [Number] The blue component, between 0 and 255 inclusive
     # @raise [ArgumentError] if `$color` isn't a color
     def blue(color)
       assert_type color, :Color, :color
-      number(color.blue)
+      Sass::Script::Number.new(color.blue)
     end
     declare :blue, [:color]
 
@@ -807,13 +548,12 @@ module Sass::Script
     # [rgb-to-hsl]: http://en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV
     #
     # @overload hue($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Number] The hue component, between 0deg and
-    #   360deg
+    # @param $color [Color]
+    # @return [Number] The hue component, between 0deg and 360deg
     # @raise [ArgumentError] if `$color` isn't a color
     def hue(color)
       assert_type color, :Color, :color
-      number(color.hue, "deg")
+      Sass::Script::Number.new(color.hue, ["deg"])
     end
     declare :hue, [:color]
 
@@ -825,13 +565,12 @@ module Sass::Script
     # [rgb-to-hsl]: http://en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV
     #
     # @overload saturation($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Number] The saturation component, between 0%
-    #   and 100%
+    # @param $color [Color]
+    # @return [Number] The saturation component, between 0% and 100%
     # @raise [ArgumentError] if `$color` isn't a color
     def saturation(color)
       assert_type color, :Color, :color
-      number(color.saturation, "%")
+      Sass::Script::Number.new(color.saturation, ["%"])
     end
     declare :saturation, [:color]
 
@@ -843,13 +582,12 @@ module Sass::Script
     # [rgb-to-hsl]: http://en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV
     #
     # @overload lightness($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Number] The lightness component, between 0%
-    #   and 100%
+    # @param $color [Color]
+    # @return [Number] The lightness component, between 0% and 100%
     # @raise [ArgumentError] if `$color` isn't a color
     def lightness(color)
       assert_type color, :Color, :color
-      number(color.lightness, "%")
+      Sass::Script::Number.new(color.lightness, ["%"])
     end
     declare :lightness, [:color]
 
@@ -860,22 +598,22 @@ module Sass::Script
     # syntax as a special case.
     #
     # @overload alpha($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Number] The alpha component, between 0 and 1
+    # @param $color [Color]
+    # @return [Number] The alpha component, between 0 and 1
     # @raise [ArgumentError] if `$color` isn't a color
     def alpha(*args)
       if args.all? do |a|
-           a.is_a?(Sass::Script::Value::String) && a.type == :identifier &&
-             a.value =~ /^[a-zA-Z]+\s*=/
-         end
+          a.is_a?(Sass::Script::String) && a.type == :identifier &&
+            a.value =~ /^[a-zA-Z]+\s*=/
+        end
         # Support the proprietary MS alpha() function
-        return identifier("alpha(#{args.map {|a| a.to_s}.join(", ")})")
+        return Sass::Script::String.new("alpha(#{args.map {|a| a.to_s}.join(", ")})")
       end
 
       raise ArgumentError.new("wrong number of arguments (#{args.size} for 1)") if args.size != 1
 
       assert_type args.first, :Color, :color
-      number(args.first.alpha)
+      Sass::Script::Number.new(args.first.alpha)
     end
     declare :alpha, [:color]
 
@@ -883,15 +621,13 @@ module Sass::Script
     # otherwise specified.
     #
     # @overload opacity($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Number] The alpha component, between 0 and 1
+    # @param $color [Color]
+    # @return [Number] The alpha component, between 0 and 1
     # @raise [ArgumentError] if `$color` isn't a color
     def opacity(color)
-      if color.is_a?(Sass::Script::Value::Number)
-        return identifier("opacity(#{color})")
-      end
+      return Sass::Script::String.new("opacity(#{color})") if color.is_a?(Sass::Script::Number)
       assert_type color, :Color, :color
-      number(color.alpha)
+      Sass::Script::Number.new(color.alpha)
     end
     declare :opacity, [:color]
 
@@ -903,10 +639,10 @@ module Sass::Script
     #   opacify(rgba(0, 0, 0, 0.5), 0.1) => rgba(0, 0, 0, 0.6)
     #   opacify(rgba(0, 0, 17, 0.8), 0.2) => #001
     # @overload opacify($color, $amount)
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $amount [Sass::Script::Value::Number] The amount to increase the
-    #     opacity by, between 0 and 1
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $amount [Number] The amount to increase the opacity by, between 0
+    #   and 1
+    # @return [Color]
     # @raise [ArgumentError] if `$amount` is out of bounds, or either parameter
     #   is the wrong type
     def opacify(color, amount)
@@ -925,10 +661,10 @@ module Sass::Script
     #   transparentize(rgba(0, 0, 0, 0.5), 0.1) => rgba(0, 0, 0, 0.4)
     #   transparentize(rgba(0, 0, 0, 0.8), 0.2) => rgba(0, 0, 0, 0.6)
     # @overload transparentize($color, $amount)
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $amount [Sass::Script::Value::Number] The amount to decrease the
-    #     opacity by, between 0 and 1
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $amount [Number] The amount to decrease the opacity by, between 0
+    #   and 1
+    # @return [Color]
     # @raise [ArgumentError] if `$amount` is out of bounds, or either parameter
     #   is the wrong type
     def transparentize(color, amount)
@@ -947,10 +683,10 @@ module Sass::Script
     #   lighten(hsl(0, 0%, 0%), 30%) => hsl(0, 0, 30)
     #   lighten(#800, 20%) => #e00
     # @overload lighten($color, $amount)
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $amount [Sass::Script::Value::Number] The amount to increase the
-    #     lightness by, between `0%` and `100%`
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $amount [Number] The amount to increase the lightness by, between
+    #   `0%` and `100%`
+    # @return [Color]
     # @raise [ArgumentError] if `$amount` is out of bounds, or either parameter
     #   is the wrong type
     def lighten(color, amount)
@@ -966,10 +702,10 @@ module Sass::Script
     #   darken(hsl(25, 100%, 80%), 30%) => hsl(25, 100%, 50%)
     #   darken(#800, 20%) => #200
     # @overload darken($color, $amount)
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $amount [Sass::Script::Value::Number] The amount to decrease the
-    #     lightness by, between `0%` and `100%`
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $amount [Number] The amount to dencrease the lightness by, between
+    #   `0%` and `100%`
+    # @return [Color]
     # @raise [ArgumentError] if `$amount` is out of bounds, or either parameter
     #   is the wrong type
     def darken(color, amount)
@@ -985,16 +721,16 @@ module Sass::Script
     #   saturate(hsl(120, 30%, 90%), 20%) => hsl(120, 50%, 90%)
     #   saturate(#855, 20%) => #9e3f3f
     # @overload saturate($color, $amount)
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $amount [Sass::Script::Value::Number] The amount to increase the
-    #     saturation by, between `0%` and `100%`
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $amount [Number] The amount to increase the saturation by, between
+    #   `0%` and `100%`
+    # @return [Color]
     # @raise [ArgumentError] if `$amount` is out of bounds, or either parameter
     #   is the wrong type
     def saturate(color, amount = nil)
       # Support the filter effects definition of saturate.
       # https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html
-      return identifier("saturate(#{color})") if amount.nil?
+      return Sass::Script::String.new("saturate(#{color})") if amount.nil?
       _adjust(color, amount, :saturation, 0..100, :+, "%")
     end
     declare :saturate, [:color, :amount]
@@ -1008,10 +744,10 @@ module Sass::Script
     #   desaturate(hsl(120, 30%, 90%), 20%) => hsl(120, 10%, 90%)
     #   desaturate(#855, 20%) => #726b6b
     # @overload desaturate($color, $amount)
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $amount [Sass::Script::Value::Number] The amount to decrease the
-    #     saturation by, between `0%` and `100%`
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $amount [Number] The amount to decrease the saturation by, between
+    #   `0%` and `100%`
+    # @return [Color]
     # @raise [ArgumentError] if `$amount` is out of bounds, or either parameter
     #   is the wrong type
     def desaturate(color, amount)
@@ -1025,13 +761,12 @@ module Sass::Script
     #
     # @example
     #   adjust-hue(hsl(120, 30%, 90%), 60deg) => hsl(180, 30%, 90%)
-    #   adjust-hue(hsl(120, 30%, 90%), -60deg) => hsl(60, 30%, 90%)
+    #   adjust-hue(hsl(120, 30%, 90%), 060deg) => hsl(60, 30%, 90%)
     #   adjust-hue(#811, 45deg) => #886a11
     # @overload adjust_hue($color, $degrees)
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $degrees [Sass::Script::Value::Number] The number of degrees to
-    #     rotate the hue
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $degrees [Number] The number of degrees to rotate the hue
+    # @return [Color]
     # @raise [ArgumentError] if either parameter is the wrong type
     def adjust_hue(color, degrees)
       assert_type color, :Color, :color
@@ -1047,14 +782,13 @@ module Sass::Script
     #   ie-hex-str(#3322BB) => #FF3322BB
     #   ie-hex-str(rgba(0, 255, 0, 0.5)) => #8000FF00
     # @overload ie_hex_str($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::String] The IE-formatted string
-    #   representation of the color
+    # @param $color [Color]
+    # @return [String] The IE-formatted string representation of the color
     # @raise [ArgumentError] if `$color` isn't a color
     def ie_hex_str(color)
       assert_type color, :Color, :color
       alpha = (color.alpha * 255).round.to_s(16).rjust(2, '0')
-      identifier("##{alpha}#{color.send(:hex_str)[1..-1]}".upcase)
+      Sass::Script::String.new("##{alpha}#{color.send(:hex_str)[1..-1]}".upcase)
     end
     declare :ie_hex_str, [:color]
 
@@ -1071,33 +805,29 @@ module Sass::Script
     #   adjust-color(#102030, $blue: 5) => #102035
     #   adjust-color(#102030, $red: -5, $blue: 5) => #0b2035
     #   adjust-color(hsl(25, 100%, 80%), $lightness: -30%, $alpha: -0.4) => hsla(25, 100%, 50%, 0.6)
-    # @comment
-    #   rubocop:disable LineLength
     # @overload adjust_color($color, [$red], [$green], [$blue], [$hue], [$saturation], [$lightness], [$alpha])
-    #   @comment
-    #     rubocop:disable LineLength
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $red [Sass::Script::Value::Number] The adjustment to make on the
-    #     red component, between -255 and 255 inclusive
-    #   @param $green [Sass::Script::Value::Number] The adjustment to make on the
-    #     green component, between -255 and 255 inclusive
-    #   @param $blue [Sass::Script::Value::Number] The adjustment to make on the
-    #     blue component, between -255 and 255 inclusive
-    #   @param $hue [Sass::Script::Value::Number] The adjustment to make on the
-    #     hue component, in degrees
-    #   @param $saturation [Sass::Script::Value::Number] The adjustment to make on
-    #     the saturation component, between `-100%` and `100%` inclusive
-    #   @param $lightness [Sass::Script::Value::Number] The adjustment to make on
-    #     the lightness component, between `-100%` and `100%` inclusive
-    #   @param $alpha [Sass::Script::Value::Number] The adjustment to make on the
-    #     alpha component, between -1 and 1 inclusive
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $red [Number] The adjustment to make on the red component, between
+    #   -255 and 255 inclusive
+    # @param $green [Number] The adjustment to make on the green component,
+    #   between -255 and 255 inclusive
+    # @param $blue [Number] The adjustment to make on the blue component, between
+    #   -255 and 255 inclusive
+    # @param $hue [Number] The adjustment to make on the hue component, in
+    #   degrees
+    # @param $saturation [Number] The adjustment to make on the saturation
+    #   component, between `-100%` and `100%` inclusive
+    # @param $lightness [Number] The adjustment to make on the lightness
+    #   component, between `-100%` and `100%` inclusive
+    # @param $alpha [Number] The adjustment to make on the alpha component,
+    #   between -1 and 1 inclusive
+    # @return [Color]
     # @raise [ArgumentError] if any parameter is the wrong type or out-of
     #   bounds, or if RGB properties and HSL properties are adjusted at the
     #   same time
     def adjust_color(color, kwargs)
       assert_type color, :Color, :color
-      with = Sass::Util.map_hash(
+      with = Sass::Util.map_hash({
           "red" => [-255..255, ""],
           "green" => [-255..255, ""],
           "blue" => [-255..255, ""],
@@ -1105,10 +835,9 @@ module Sass::Script
           "saturation" => [-100..100, "%"],
           "lightness" => [-100..100, "%"],
           "alpha" => [-1..1, ""]
-        ) do |name, (range, units)|
+        }) do |name, (range, units)|
 
-        val = kwargs.delete(name)
-        next unless val
+        next unless val = kwargs.delete(name)
         assert_type val, :Number, name
         Sass::Util.check_range("$#{name}: Amount", range, val, units) if range
         adjusted = color.send(name) + val.value
@@ -1152,43 +881,41 @@ module Sass::Script
     #   scale-color(hsl(120, 70%, 80%), $lightness: 50%) => hsl(120, 70%, 90%)
     #   scale-color(rgb(200, 150%, 170%), $green: -40%, $blue: 70%) => rgb(200, 90, 229)
     #   scale-color(hsl(200, 70%, 80%), $saturation: -90%, $alpha: -30%) => hsla(200, 7%, 80%, 0.7)
-    # @comment
-    #   rubocop:disable LineLength
     # @overload scale_color($color, [$red], [$green], [$blue], [$saturation], [$lightness], [$alpha])
-    #   @comment
-    #     rubocop:disable LineLength
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $red [Sass::Script::Value::Number]
-    #   @param $green [Sass::Script::Value::Number]
-    #   @param $blue [Sass::Script::Value::Number]
-    #   @param $saturation [Sass::Script::Value::Number]
-    #   @param $lightness [Sass::Script::Value::Number]
-    #   @param $alpha [Sass::Script::Value::Number]
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $red [Number]
+    # @param $green [Number]
+    # @param $blue [Number]
+    # @param $saturation [Number]
+    # @param $lightness [Number]
+    # @param $alpha [Number]
+    # @return [Color]
     # @raise [ArgumentError] if any parameter is the wrong type or out-of
     #   bounds, or if RGB properties and HSL properties are adjusted at the
     #   same time
     def scale_color(color, kwargs)
       assert_type color, :Color, :color
-      with = Sass::Util.map_hash(
+      with = Sass::Util.map_hash({
           "red" => 255,
           "green" => 255,
           "blue" => 255,
           "saturation" => 100,
           "lightness" => 100,
           "alpha" => 1
-        ) do |name, max|
+        }) do |name, max|
 
-        val = kwargs.delete(name)
-        next unless val
+        next unless val = kwargs.delete(name)
         assert_type val, :Number, name
-        assert_unit val, '%', name
-        Sass::Util.check_range("$#{name}: Amount", -100..100, val, '%')
+        if !(val.numerator_units == ['%'] && val.denominator_units.empty?)
+          raise ArgumentError.new("$#{name}: Amount #{val} must be a % (e.g. #{val.value}%)")
+        else
+          Sass::Util.check_range("$#{name}: Amount", -100..100, val, '%')
+        end
 
         current = color.send(name)
-        scale = val.value / 100.0
+        scale = val.value/100.0
         diff = scale > 0 ? max - current : current
-        [name.to_sym, current + diff * scale]
+        [name.to_sym, current + diff*scale]
       end
 
       unless kwargs.empty?
@@ -1213,52 +940,31 @@ module Sass::Script
     #   change-color(#102030, $blue: 5) => #102005
     #   change-color(#102030, $red: 120, $blue: 5) => #782005
     #   change-color(hsl(25, 100%, 80%), $lightness: 40%, $alpha: 0.8) => hsla(25, 100%, 40%, 0.8)
-    # @comment
-    #   rubocop:disable LineLength
     # @overload change_color($color, [$red], [$green], [$blue], [$hue], [$saturation], [$lightness], [$alpha])
-    #   @comment
-    #     rubocop:disable LineLength
-    #   @param $color [Sass::Script::Value::Color]
-    #   @param $red [Sass::Script::Value::Number] The new red component for the
-    #     color, within 0 and 255 inclusive
-    #   @param $green [Sass::Script::Value::Number] The new green component for
-    #     the color, within 0 and 255 inclusive
-    #   @param $blue [Sass::Script::Value::Number] The new blue component for the
-    #     color, within 0 and 255 inclusive
-    #   @param $hue [Sass::Script::Value::Number] The new hue component for the
-    #     color, in degrees
-    #   @param $saturation [Sass::Script::Value::Number] The new saturation
-    #     component for the color, between `0%` and `100%` inclusive
-    #   @param $lightness [Sass::Script::Value::Number] The new lightness
-    #     component for the color, within `0%` and `100%` inclusive
-    #   @param $alpha [Sass::Script::Value::Number] The new alpha component for
-    #     the color, within 0 and 1 inclusive
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @param $red [Number] The new red component for the color, within 0 and 255
+    #   inclusive
+    # @param $green [Number] The new green component for the color, within 0 and
+    #   255 inclusive
+    # @param $blue [Number] The new blue component for the color, within 0 and
+    #   255 inclusive
+    # @param $hue [Number] The new hue component for the color, in degrees
+    # @param $saturation [Number] The new saturation component for the color,
+    #   between `0%` and `100%` inclusive
+    # @param $lightness [Number] The new lightness component for the color,
+    #   within `0%` and `100%` inclusive
+    # @param $alpha [Number] The new alpha component for the color, within 0 and
+    #   1 inclusive
+    # @return [Color]
     # @raise [ArgumentError] if any parameter is the wrong type or out-of
     #   bounds, or if RGB properties and HSL properties are adjusted at the
     #   same time
     def change_color(color, kwargs)
       assert_type color, :Color, :color
-      with = Sass::Util.map_hash(
-        'red' => ['Red value', 0..255],
-        'green' => ['Green value', 0..255],
-        'blue' => ['Blue value', 0..255],
-        'hue' => [],
-        'saturation' => ['Saturation', 0..100, '%'],
-        'lightness' => ['Lightness', 0..100, '%'],
-        'alpha' => ['Alpha channel', 0..1]
-      ) do |name, (desc, range, unit)|
-        val = kwargs.delete(name)
-        next unless val
+      with = Sass::Util.map_hash(%w[red green blue hue saturation lightness alpha]) do |name, max|
+        next unless val = kwargs.delete(name)
         assert_type val, :Number, name
-
-        if range
-          val = Sass::Util.check_range(desc, range, val, unit)
-        else
-          val = val.value
-        end
-
-        [name.to_sym, val]
+        [name.to_sym, val.value]
       end
 
       unless kwargs.empty?
@@ -1283,18 +989,18 @@ module Sass::Script
     #   mix(#f00, #00f) => #7f007f
     #   mix(#f00, #00f, 25%) => #3f00bf
     #   mix(rgba(255, 0, 0, 0.5), #00f) => rgba(63, 0, 191, 0.75)
-    # @overload mix($color1, $color2, $weight: 50%)
-    #   @param $color1 [Sass::Script::Value::Color]
-    #   @param $color2 [Sass::Script::Value::Color]
-    #   @param $weight [Sass::Script::Value::Number] The relative weight of each
-    #     color. Closer to `0%` gives more weight to `$color`, closer to `100%`
-    #     gives more weight to `$color2`
-    # @return [Sass::Script::Value::Color]
+    # @overload mix($color-1, $color-2, $weight: 50%)
+    # @param $color-1 [Color]
+    # @param $color-2 [Color]
+    # @param $weight [Number] The relative weight of each color. Closer to `0%`
+    #   gives more weight to `$color`, closer to `100%` gives more weight to
+    #   `$color2`
+    # @return [Color]
     # @raise [ArgumentError] if `$weight` is out of bounds or any parameter is
     #   the wrong type
-    def mix(color1, color2, weight = number(50))
-      assert_type color1, :Color, :color1
-      assert_type color2, :Color, :color2
+    def mix(color_1, color_2, weight = Number.new(50))
+      assert_type color_1, :Color, :color_1
+      assert_type color_2, :Color, :color_2
       assert_type weight, :Number, :weight
 
       Sass::Util.check_range("Weight", 0..100, weight, '%')
@@ -1304,11 +1010,11 @@ module Sass::Script
       # to perform the weighted average of the two RGB values.
       #
       # It works by first normalizing both parameters to be within [-1, 1],
-      # where 1 indicates "only use color1", -1 indicates "only use color2", and
+      # where 1 indicates "only use color_1", -1 indicates "only use color_2", and
       # all values in between indicated a proportionately weighted average.
       #
       # Once we have the normalized variables w and a, we apply the formula
-      # (w + a)/(1 + w*a) to get the combined weight (in [-1, 1]) of color1.
+      # (w + a)/(1 + w*a) to get the combined weight (in [-1, 1]) of color_1.
       # This formula has two especially nice properties:
       #
       #   * When either w or a are -1 or 1, the combined weight is also that number
@@ -1316,35 +1022,33 @@ module Sass::Script
       #
       #   * When a is 0, the combined weight is w, and vice versa.
       #
-      # Finally, the weight of color1 is renormalized to be within [0, 1]
-      # and the weight of color2 is given by 1 minus the weight of color1.
-      p = (weight.value / 100.0).to_f
-      w = p * 2 - 1
-      a = color1.alpha - color2.alpha
+      # Finally, the weight of color_1 is renormalized to be within [0, 1]
+      # and the weight of color_2 is given by 1 minus the weight of color_1.
+      p = (weight.value/100.0).to_f
+      w = p*2 - 1
+      a = color_1.alpha - color_2.alpha
 
-      w1 = ((w * a == -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0
+      w1 = (((w * a == -1) ? w : (w + a)/(1 + w*a)) + 1)/2.0
       w2 = 1 - w1
 
-      rgba = color1.rgb.zip(color2.rgb).map {|v1, v2| v1 * w1 + v2 * w2}
-      rgba << color1.alpha * p + color2.alpha * (1 - p)
-      rgb_color(*rgba)
+      rgb = color_1.rgb.zip(color_2.rgb).map {|v1, v2| v1*w1 + v2*w2}
+      alpha = color_1.alpha*p + color_2.alpha*(1-p)
+      Color.new(rgb + [alpha])
     end
-    declare :mix, [:color1, :color2]
-    declare :mix, [:color1, :color2, :weight]
+    declare :mix, [:color_1, :color_2]
+    declare :mix, [:color_1, :color_2, :weight]
 
     # Converts a color to grayscale. This is identical to `desaturate(color,
     # 100%)`.
     #
     # @see #desaturate
     # @overload grayscale($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @return [Color]
     # @raise [ArgumentError] if `$color` isn't a color
     def grayscale(color)
-      if color.is_a?(Sass::Script::Value::Number)
-        return identifier("grayscale(#{color})")
-      end
-      desaturate color, number(100)
+      return Sass::Script::String.new("grayscale(#{color})") if color.is_a?(Sass::Script::Number)
+      desaturate color, Number.new(100)
     end
     declare :grayscale, [:color]
 
@@ -1353,11 +1057,11 @@ module Sass::Script
     #
     # @see #adjust_hue #adjust-hue
     # @overload complement($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @return [Color]
     # @raise [ArgumentError] if `$color` isn't a color
     def complement(color)
-      adjust_hue color, number(180)
+      adjust_hue color, Number.new(180)
     end
     declare :complement, [:color]
 
@@ -1365,13 +1069,11 @@ module Sass::Script
     # are inverted, while the opacity is left alone.
     #
     # @overload invert($color)
-    #   @param $color [Sass::Script::Value::Color]
-    # @return [Sass::Script::Value::Color]
+    # @param $color [Color]
+    # @return [Color]
     # @raise [ArgumentError] if `$color` isn't a color
     def invert(color)
-      if color.is_a?(Sass::Script::Value::Number)
-        return identifier("invert(#{color})")
-      end
+      return Sass::Script::String.new("invert(#{color})") if color.is_a?(Sass::Script::Number)
 
       assert_type color, :Color, :color
       color.with(
@@ -1389,12 +1091,12 @@ module Sass::Script
     #   unquote("foo") => foo
     #   unquote(foo) => foo
     # @overload unquote($string)
-    #   @param $string [Sass::Script::Value::String]
-    # @return [Sass::Script::Value::String]
+    # @param $string [String]
+    # @return [String]
     # @raise [ArgumentError] if `$string` isn't a string
     def unquote(string)
-      if string.is_a?(Sass::Script::Value::String) && string.type != :identifier
-        identifier(string.value)
+      if string.is_a?(Sass::Script::String)
+        Sass::Script::String.new(string.value, :identifier)
       else
         string
       end
@@ -1409,165 +1111,15 @@ module Sass::Script
     #   quote("foo") => "foo"
     #   quote(foo) => "foo"
     # @overload quote($string)
-    #   @param $string [Sass::Script::Value::String]
-    # @return [Sass::Script::Value::String]
+    # @param $string [String]
+    # @return [String]
     # @raise [ArgumentError] if `$string` isn't a string
     def quote(string)
       assert_type string, :String, :string
-      if string.type != :string
-        quoted_string(string.value)
-      else
-        string
-      end
+      Sass::Script::String.new(string.value, :string)
     end
     declare :quote, [:string]
 
-    # Returns the number of characters in a string.
-    #
-    # @example
-    #   str-length("foo") => 3
-    # @overload str_length($string)
-    #   @param $string [Sass::Script::Value::String]
-    # @return [Sass::Script::Value::Number]
-    # @raise [ArgumentError] if `$string` isn't a string
-    def str_length(string)
-      assert_type string, :String, :string
-      number(string.value.size)
-    end
-    declare :str_length, [:string]
-
-    # Inserts `$insert` into `$string` at `$index`.
-    #
-    # Note that unlike some languages, the first character in a Sass string is
-    # number 1, the second number 2, and so forth.
-    #
-    # @example
-    #   str-insert("abcd", "X", 1) => "Xabcd"
-    #   str-insert("abcd", "X", 4) => "abcXd"
-    #   str-insert("abcd", "X", 5) => "abcdX"
-    #
-    # @overload str_insert($string, $insert, $index)
-    #   @param $string [Sass::Script::Value::String]
-    #   @param $insert [Sass::Script::Value::String]
-    #   @param $index [Sass::Script::Value::Number] The position at which
-    #     `$insert` will be inserted. Negative indices count from the end of
-    #     `$string`. An index that's outside the bounds of the string will insert
-    #     `$insert` at the front or back of the string
-    # @return [Sass::Script::Value::String] The result string. This will be
-    #   quoted if and only if `$string` was quoted
-    # @raise [ArgumentError] if any parameter is the wrong type
-    def str_insert(original, insert, index)
-      assert_type original, :String, :string
-      assert_type insert, :String, :insert
-      assert_integer index, :index
-      assert_unit index, nil, :index
-      insertion_point = if index.value > 0
-                          [index.value - 1, original.value.size].min
-                        else
-                          [index.value, -original.value.size - 1].max
-                        end
-      result = original.value.dup.insert(insertion_point, insert.value)
-      Sass::Script::Value::String.new(result, original.type)
-    end
-    declare :str_insert, [:string, :insert, :index]
-
-    # Returns the index of the first occurrence of `$substring` in `$string`. If
-    # there is no such occurrence, returns `null`.
-    #
-    # Note that unlike some languages, the first character in a Sass string is
-    # number 1, the second number 2, and so forth.
-    #
-    # @example
-    #   str-index(abcd, a)  => 1
-    #   str-index(abcd, ab) => 1
-    #   str-index(abcd, X)  => null
-    #   str-index(abcd, c)  => 3
-    #
-    # @overload str_index($string, $substring)
-    #   @param $string [Sass::Script::Value::String]
-    #   @param $substring [Sass::Script::Value::String]
-    # @return [Sass::Script::Value::Number, Sass::Script::Value::Null]
-    # @raise [ArgumentError] if any parameter is the wrong type
-    def str_index(string, substring)
-      assert_type string, :String, :string
-      assert_type substring, :String, :substring
-      index = string.value.index(substring.value)
-      index ? number(index + 1) : null
-    end
-    declare :str_index, [:string, :substring]
-
-    # Extracts a substring from `$string`. The substring will begin at index
-    # `$start-at` and ends at index `$end-at`.
-    #
-    # Note that unlike some languages, the first character in a Sass string is
-    # number 1, the second number 2, and so forth.
-    #
-    # @example
-    #  str-slice("abcd", 2, 3)   => "bc"
-    #  str-slice("abcd", 2)      => "bcd"
-    #  str-slice("abcd", -3, -2) => "bc"
-    #  str-slice("abcd", 2, -2)  => "bc"
-    #
-    # @overload str_slice($string, $start-at, $end-at: -1)
-    #   @param $start-at [Sass::Script::Value::Number] The index of the first
-    #     character of the substring. If this is negative, it counts from the end
-    #     of `$string`
-    #   @param $end-before [Sass::Script::Value::Number] The index of the last
-    #     character of the substring. If this is negative, it counts from the end
-    #     of `$string`. Defaults to -1
-    #   @return [Sass::Script::Value::String] The substring. This will be quoted
-    #     if and only if `$string` was quoted
-    # @raise [ArgumentError] if any parameter is the wrong type
-    def str_slice(string, start_at, end_at = nil)
-      assert_type string, :String, :string
-      assert_unit start_at, nil, "start-at"
-
-      end_at = number(-1) if end_at.nil?
-      assert_unit end_at, nil, "end-at"
-
-      return Sass::Script::Value::String.new("", string.type) if end_at.value == 0
-      s = start_at.value > 0 ? start_at.value - 1 : start_at.value
-      e = end_at.value > 0 ? end_at.value - 1 : end_at.value
-      s = string.value.length + s if s < 0
-      s = 0 if s < 0
-      e = string.value.length + e if e < 0
-      e = 0 if s < 0
-      extracted = string.value.slice(s..e)
-      Sass::Script::Value::String.new(extracted || "", string.type)
-    end
-    declare :str_slice, [:string, :start_at]
-    declare :str_slice, [:string, :start_at, :end_at]
-
-    # Converts a string to upper case.
-    #
-    # @example
-    #   to-upper-case(abcd) => ABCD
-    #
-    # @overload to_upper_case($string)
-    #   @param $string [Sass::Script::Value::String]
-    # @return [Sass::Script::Value::String]
-    # @raise [ArgumentError] if `$string` isn't a string
-    def to_upper_case(string)
-      assert_type string, :String, :string
-      Sass::Script::Value::String.new(string.value.upcase, string.type)
-    end
-    declare :to_upper_case, [:string]
-
-    # Convert a string to lower case,
-    #
-    # @example
-    #   to-lower-case(ABCD) => abcd
-    #
-    # @overload to_lower_case($string)
-    #   @param $string [Sass::Script::Value::String]
-    # @return [Sass::Script::Value::String]
-    # @raise [ArgumentError] if `$string` isn't a string
-    def to_lower_case(string)
-      assert_type string, :String, :string
-      Sass::Script::Value::String.new(string.value.downcase, string.type)
-    end
-    declare :to_lower_case, [:string]
-
     # Returns the type of a value.
     #
     # @example
@@ -1578,45 +1130,13 @@ module Sass::Script
     #   type-of(#fff)   => color
     #   type-of(blue)   => color
     # @overload type_of($value)
-    #   @param $value [Sass::Script::Value::Base] The value to inspect
-    # @return [Sass::Script::Value::String] The unquoted string name of the
-    #   value's type
+    # @param $value [Literal] The value to inspect
+    # @return [String] The unquoted string name of the value's type
     def type_of(value)
-      identifier(value.class.name.gsub(/Sass::Script::Value::/, '').downcase)
+      Sass::Script::String.new(value.class.name.gsub(/Sass::Script::/,'').downcase)
     end
     declare :type_of, [:value]
 
-    # Returns whether a feature exists in the current Sass runtime.
-    #
-    # The following features are supported:
-    #
-    # * `global-variable-shadowing` indicates that a local variable will shadow
-    #   a global variable unless `!global` is used.
-    #
-    # * `extend-selector-pseudoclass` indicates that `@extend` will reach into
-    #   selector pseudoclasses like `:not`.
-    #
-    # * `units-level-3` indicates full support for unit arithmetic using units
-    #   defined in the [Values and Units Level 3][] spec.
-    #
-    # [Values and Units Level 3]: http://www.w3.org/TR/css3-values/
-    #
-    # * `at-error` indicates that the Sass `@error` directive is supported.
-    #
-    # @example
-    #   feature-exists(some-feature-that-exists) => true
-    #   feature-exists(what-is-this-i-dont-know) => false
-    #
-    # @overload feature_exists($feature)
-    #   @param $feature [Sass::Script::Value::String] The name of the feature
-    # @return [Sass::Script::Value::Bool] Whether the feature is supported in this version of Sass
-    # @raise [ArgumentError] if `$feature` isn't a string
-    def feature_exists(feature)
-      assert_type feature, :String, :feature
-      bool(Sass.has_feature?(feature.value))
-    end
-    declare :feature_exists, [:feature]
-
     # Returns the unit(s) associated with a number. Complex units are sorted in
     # alphabetical order by numerator and denominator.
     #
@@ -1627,13 +1147,12 @@ module Sass::Script
     #   unit(10px * 5em) => "em*px"
     #   unit(10px * 5em / 30cm / 1rem) => "em*px/cm*rem"
     # @overload unit($number)
-    #   @param $number [Sass::Script::Value::Number]
-    # @return [Sass::Script::Value::String] The unit(s) of the number, as a
-    #   quoted string
+    # @param $number [Number]
+    # @return [String] The unit(s) of the number, as a quoted string
     # @raise [ArgumentError] if `$number` isn't a number
     def unit(number)
       assert_type number, :Number, :number
-      quoted_string(number.unit_str)
+      Sass::Script::String.new(number.unit_str, :string)
     end
     declare :unit, [:number]
 
@@ -1643,12 +1162,12 @@ module Sass::Script
     #   unitless(100) => true
     #   unitless(100px) => false
     # @overload unitless($number)
-    #   @param $number [Sass::Script::Value::Number]
-    # @return [Sass::Script::Value::Bool]
+    # @param $number [Number]
+    # @return [Bool]
     # @raise [ArgumentError] if `$number` isn't a number
     def unitless(number)
       assert_type number, :Number, :number
-      bool(number.unitless?)
+      Sass::Script::Bool.new(number.unitless?)
     end
     declare :unitless, [:number]
 
@@ -1658,90 +1177,90 @@ module Sass::Script
     #   comparable(2px, 1px) => true
     #   comparable(100px, 3em) => false
     #   comparable(10cm, 3mm) => true
-    # @overload comparable($number1, $number2)
-    #   @param $number1 [Sass::Script::Value::Number]
-    #   @param $number2 [Sass::Script::Value::Number]
-    # @return [Sass::Script::Value::Bool]
+    # @overload comparable($number-1, $number-2)
+    # @param $number-1 [Number]
+    # @param $number-2 [Number]
+    # @return [Bool]
     # @raise [ArgumentError] if either parameter is the wrong type
-    def comparable(number1, number2)
-      assert_type number1, :Number, :number1
-      assert_type number2, :Number, :number2
-      bool(number1.comparable_to?(number2))
+    def comparable(number_1, number_2)
+      assert_type number_1, :Number, :number_1
+      assert_type number_2, :Number, :number_2
+      Sass::Script::Bool.new(number_1.comparable_to?(number_2))
     end
-    declare :comparable, [:number1, :number2]
+    declare :comparable, [:number_1, :number_2]
 
     # Converts a unitless number to a percentage.
     #
     # @example
     #   percentage(0.2) => 20%
     #   percentage(100px / 50px) => 200%
-    # @overload percentage($number)
-    #   @param $number [Sass::Script::Value::Number]
-    # @return [Sass::Script::Value::Number]
-    # @raise [ArgumentError] if `$number` isn't a unitless number
-    def percentage(number)
-      unless number.is_a?(Sass::Script::Value::Number) && number.unitless?
-        raise ArgumentError.new("$number: #{number.inspect} is not a unitless number")
+    # @overload percentage($value)
+    # @param $value [Number]
+    # @return [Number]
+    # @raise [ArgumentError] if `$value` isn't a unitless number
+    def percentage(value)
+      unless value.is_a?(Sass::Script::Number) && value.unitless?
+        raise ArgumentError.new("$value: #{value.inspect} is not a unitless number")
       end
-      number(number.value * 100, '%')
+      Sass::Script::Number.new(value.value * 100, ['%'])
     end
-    declare :percentage, [:number]
+    declare :percentage, [:value]
 
     # Rounds a number to the nearest whole number.
     #
     # @example
     #   round(10.4px) => 10px
     #   round(10.6px) => 11px
-    # @overload round($number)
-    #   @param $number [Sass::Script::Value::Number]
-    # @return [Sass::Script::Value::Number]
-    # @raise [ArgumentError] if `$number` isn't a number
-    def round(number)
-      numeric_transformation(number) {|n| n.round}
+    # @overload round($value)
+    # @param $value [Number]
+    # @return [Number]
+    # @raise [ArgumentError] if `$value` isn't a number
+    def round(value)
+      numeric_transformation(value) {|n| n.round}
     end
-    declare :round, [:number]
+    declare :round, [:value]
 
     # Rounds a number up to the next whole number.
     #
     # @example
     #   ceil(10.4px) => 11px
     #   ceil(10.6px) => 11px
-    # @overload ceil($number)
-    #   @param $number [Sass::Script::Value::Number]
-    # @return [Sass::Script::Value::Number]
-    # @raise [ArgumentError] if `$number` isn't a number
-    def ceil(number)
-      numeric_transformation(number) {|n| n.ceil}
+    # @overload ceil($value)
+    # @param $value [Number]
+    # @return [Number]
+    # @raise [ArgumentError] if `$value` isn't a number
+    def ceil(value)
+      numeric_transformation(value) {|n| n.ceil}
     end
-    declare :ceil, [:number]
+    declare :ceil, [:value]
 
     # Rounds a number down to the previous whole number.
     #
     # @example
     #   floor(10.4px) => 10px
     #   floor(10.6px) => 10px
-    # @overload floor($number)
-    #   @param $number [Sass::Script::Value::Number]
-    # @return [Sass::Script::Value::Number]
-    # @raise [ArgumentError] if `$number` isn't a number
-    def floor(number)
-      numeric_transformation(number) {|n| n.floor}
+    # @overload floor($value)
+    # @param $value [Number]
+    # @return [Number]
+    # @raise [ArgumentError] if `$value` isn't a number
+    def floor(value)
+      numeric_transformation(value) {|n| n.floor}
     end
-    declare :floor, [:number]
+    declare :floor, [:value]
 
     # Returns the absolute value of a number.
     #
     # @example
     #   abs(10px) => 10px
     #   abs(-10px) => 10px
-    # @overload abs($number)
-    #   @param $number [Sass::Script::Value::Number]
-    # @return [Sass::Script::Value::Number]
-    # @raise [ArgumentError] if `$number` isn't a number
-    def abs(number)
-      numeric_transformation(number) {|n| n.abs}
+    # @overload abs($value)
+    # @param $value [Number]
+    # @return [Number]
+    # @raise [ArgumentError] if `$value` isn't a number
+    def abs(value)
+      numeric_transformation(value) {|n| n.abs}
     end
-    declare :abs, [:number]
+    declare :abs, [:value]
 
     # Finds the minimum of several numbers. This function takes any number of
     # arguments.
@@ -1750,8 +1269,8 @@ module Sass::Script
     #   min(1px, 4px) => 1px
     #   min(5em, 3em, 4em) => 3em
     # @overload min($numbers...)
-    #   @param $numbers [[Sass::Script::Value::Number]]
-    # @return [Sass::Script::Value::Number]
+    # @param $numbers [[Number]]
+    # @return [Number]
     # @raise [ArgumentError] if any argument isn't a number, or if not all of
     #   the arguments have comparable units
     def min(*numbers)
@@ -1767,8 +1286,8 @@ module Sass::Script
     #   max(1px, 4px) => 4px
     #   max(5em, 3em, 4em) => 5em
     # @overload max($numbers...)
-    #   @param $numbers [[Sass::Script::Value::Number]]
-    # @return [Sass::Script::Value::Number]
+    # @param $numbers [[Number]]
+    # @return [Number]
     # @raise [ArgumentError] if any argument isn't a number, or if not all of
     #   the arguments have comparable units
     def max(*values)
@@ -1779,77 +1298,44 @@ module Sass::Script
 
     # Return the length of a list.
     #
-    # This can return the number of pairs in a map as well.
-    #
     # @example
     #   length(10px) => 1
     #   length(10px 20px 30px) => 3
-    #   length((width: 10px, height: 20px)) => 2
     # @overload length($list)
-    #   @param $list [Sass::Script::Value::Base]
-    # @return [Sass::Script::Value::Number]
+    # @param $list [Literal]
+    # @return [Number]
     def length(list)
-      number(list.to_a.size)
+      Sass::Script::Number.new(list.to_a.size)
     end
     declare :length, [:list]
 
-    # Return a new list, based on the list provided, but with the nth
-    # element changed to the value given.
-    #
-    # Note that unlike some languages, the first item in a Sass list is number
-    # 1, the second number 2, and so forth.
-    #
-    # Negative index values address elements in reverse order, starting with the last element
-    # in the list.
-    #
-    # @example
-    #   set-nth($list: 10px 20px 30px, $n: 2, $value: -20px) => 10px -20px 30px
-    # @overload set-nth($list, $n, $value)
-    #   @param $list [Sass::Script::Value::Base] The list that will be copied, having the element
-    #     at index `$n` changed.
-    #   @param $n [Sass::Script::Value::Number] The index of the item to set.
-    #     Negative indices count from the end of the list.
-    #   @param $value [Sass::Script::Value::Base] The new value at index `$n`.
-    # @return [Sass::Script::Value::List]
-    # @raise [ArgumentError] if `$n` isn't an integer between 1 and the length
-    #   of `$list`
-    def set_nth(list, n, value)
-      assert_type n, :Number, :n
-      Sass::Script::Value::List.assert_valid_index(list, n)
-      index = n.to_i > 0 ? n.to_i - 1 : n.to_i
-      new_list = list.to_a.dup
-      new_list[index] = value
-      Sass::Script::Value::List.new(new_list, list.separator)
-    end
-    declare :set_nth, [:list, :n, :value]
-
     # Gets the nth item in a list.
     #
     # Note that unlike some languages, the first item in a Sass list is number
     # 1, the second number 2, and so forth.
     #
-    # This can return the nth pair in a map as well.
-    #
-    # Negative index values address elements in reverse order, starting with the last element in
-    # the list.
-    #
     # @example
     #   nth(10px 20px 30px, 1) => 10px
     #   nth((Helvetica, Arial, sans-serif), 3) => sans-serif
-    #   nth((width: 10px, length: 20px), 2) => length, 20px
     # @overload nth($list, $n)
-    #   @param $list [Sass::Script::Value::Base]
-    #   @param $n [Sass::Script::Value::Number] The index of the item to get.
-    #     Negative indices count from the end of the list.
-    # @return [Sass::Script::Value::Base]
+    # @param $list [Literal]
+    # @param $n [Number] The index of the item to get
+    # @return [Literal]
     # @raise [ArgumentError] if `$n` isn't an integer between 1 and the length
     #   of `$list`
     def nth(list, n)
       assert_type n, :Number, :n
-      Sass::Script::Value::List.assert_valid_index(list, n)
+      if !n.int?
+        raise ArgumentError.new("List index #{n} must be an integer")
+      elsif n.to_i < 1
+        raise ArgumentError.new("List index #{n} must be greater than or equal to 1")
+      elsif list.to_a.size == 0
+        raise ArgumentError.new("List index is #{n} but list has no items")
+      elsif n.to_i > (size = list.to_a.size)
+        raise ArgumentError.new("List index is #{n} but list is only #{size} item#{'s' if size != 1} long")
+      end
 
-      index = n.to_i > 0 ? n.to_i - 1 : n.to_i
-      list.to_a[index]
+      list.to_a[n.to_i - 1]
     end
     declare :nth, [:list, :n]
 
@@ -1867,23 +1353,26 @@ module Sass::Script
     #   join(10px, 20px, comma) => 10px, 20px
     #   join((blue, red), (#abc, #def), space) => blue red #abc #def
     # @overload join($list1, $list2, $separator: auto)
-    #   @param $list1 [Sass::Script::Value::Base]
-    #   @param $list2 [Sass::Script::Value::Base]
-    #   @param $separator [Sass::Script::Value::String] The list separator to use.
-    #     If this is `comma` or `space`, that separator will be used. If this is
-    #     `auto` (the default), the separator is determined as explained above.
-    # @return [Sass::Script::Value::List]
-    def join(list1, list2, separator = identifier("auto"))
+    # @param $list1 [Literal]
+    # @param $list2 [Literal]
+    # @param $separator [String] The list separator to use. If this is `comma`
+    #   or `space`, that separator will be used. If this is `auto` (the
+    #   default), the separator is determined as explained above.
+    # @return [List]
+    def join(list1, list2, separator = Sass::Script::String.new("auto"))
       assert_type separator, :String, :separator
       unless %w[auto space comma].include?(separator.value)
         raise ArgumentError.new("Separator name must be space, comma, or auto")
       end
-      sep = if separator.value == 'auto'
-              list1.separator || list2.separator || :space
-            else
-              separator.value.to_sym
-            end
-      list(list1.to_a + list2.to_a, sep)
+      sep1 = list1.separator if list1.is_a?(Sass::Script::List) && !list1.value.empty?
+      sep2 = list2.separator if list2.is_a?(Sass::Script::List) && !list2.value.empty?
+      Sass::Script::List.new(
+        list1.to_a + list2.to_a,
+        if separator.value == 'auto'
+          sep1 || sep2 || :space
+        else
+          separator.value.to_sym
+        end)
     end
     declare :join, [:list1, :list2]
     declare :join, [:list1, :list2, :separator]
@@ -1900,23 +1389,25 @@ module Sass::Script
     #   append(10px, 20px, comma) => 10px, 20px
     #   append((blue, red), green, space) => blue red green
     # @overload append($list, $val, $separator: auto)
-    #   @param $list [Sass::Script::Value::Base]
-    #   @param $val [Sass::Script::Value::Base]
-    #   @param $separator [Sass::Script::Value::String] The list separator to use.
-    #     If this is `comma` or `space`, that separator will be used. If this is
-    #     `auto` (the default), the separator is determined as explained above.
-    # @return [Sass::Script::Value::List]
-    def append(list, val, separator = identifier("auto"))
+    # @param $list [Literal]
+    # @param $val [Literal]
+    # @param $separator [String] The list separator to use. If this is `comma`
+    #   or `space`, that separator will be used. If this is `auto` (the
+    #   default), the separator is determined as explained above.
+    # @return [List]
+    def append(list, val, separator = Sass::Script::String.new("auto"))
       assert_type separator, :String, :separator
       unless %w[auto space comma].include?(separator.value)
         raise ArgumentError.new("Separator name must be space, comma, or auto")
       end
-      sep = if separator.value == 'auto'
-              list.separator || :space
-            else
-              separator.value.to_sym
-            end
-      list(list.to_a + [val], sep)
+      sep = list.separator if list.is_a?(Sass::Script::List)
+      Sass::Script::List.new(
+        list.to_a + [val],
+        if separator.value == 'auto'
+          sep || :space
+        else
+          separator.value.to_sym
+        end)
     end
     declare :append, [:list, :val]
     declare :append, [:list, :val, :separator]
@@ -1932,8 +1423,8 @@ module Sass::Script
     #   zip(1px 1px 3px, solid dashed solid, red green blue)
     #   => 1px solid red, 1px dashed green, 3px solid blue
     # @overload zip($lists...)
-    #   @param $lists [[Sass::Script::Value::Base]]
-    # @return [Sass::Script::Value::List]
+    # @param $lists [[Literal]]
+    # @return [List]
     def zip(*lists)
       length = nil
       values = []
@@ -1946,176 +1437,35 @@ module Sass::Script
         value.slice!(length)
       end
       new_list_value = values.first.zip(*values[1..-1])
-      list(new_list_value.map {|list| list(list, :space)}, :comma)
+      List.new(new_list_value.map{|list| List.new(list, :space)}, :comma)
     end
     declare :zip, [], :var_args => true
 
+
     # Returns the position of a value within a list. If the value isn't found,
-    # returns `null` instead.
+    # returns false instead.
     #
     # Note that unlike some languages, the first item in a Sass list is number
     # 1, the second number 2, and so forth.
     #
-    # This can return the position of a pair in a map as well.
-    #
     # @example
     #   index(1px solid red, solid) => 2
-    #   index(1px solid red, dashed) => null
-    #   index((width: 10px, height: 20px), (height 20px)) => 2
+    #   index(1px solid red, dashed) => false
     # @overload index($list, $value)
-    #   @param $list [Sass::Script::Value::Base]
-    #   @param $value [Sass::Script::Value::Base]
-    # @return [Sass::Script::Value::Number, Sass::Script::Value::Null] The
-    #   1-based index of `$value` in `$list`, or `null`
+    # @param $list [Literal]
+    # @param $value [Literal]
+    # @return [Number, Bool] The 1-based index of `$value` in `$list`, or
+    #   `false`
     def index(list, value)
-      index = list.to_a.index {|e| e.eq(value).to_bool}
-      index ? number(index + 1) : null
+      index = list.to_a.index {|e| e.eq(value).to_bool }
+      if index
+        Number.new(index + 1)
+      else
+        Bool.new(false)
+      end
     end
     declare :index, [:list, :value]
 
-    # Returns the separator of a list. If the list doesn't have a separator due
-    # to having fewer than two elements, returns `space`.
-    #
-    # @example
-    #   list-separator(1px 2px 3px) => space
-    #   list-separator(1px, 2px, 3px) => comma
-    #   list-separator('foo') => space
-    # @overload list_separator($list)
-    #   @param $list [Sass::Script::Value::Base]
-    # @return [Sass::Script::Value::String] `comma` or `space`
-    def list_separator(list)
-      identifier((list.separator || :space).to_s)
-    end
-    declare :separator, [:list]
-
-    # Returns the value in a map associated with the given key. If the map
-    # doesn't have such a key, returns `null`.
-    #
-    # @example
-    #   map-get(("foo": 1, "bar": 2), "foo") => 1
-    #   map-get(("foo": 1, "bar": 2), "bar") => 2
-    #   map-get(("foo": 1, "bar": 2), "baz") => null
-    # @overload map_get($map, $key)
-    #   @param $map [Sass::Script::Value::Map]
-    #   @param $key [Sass::Script::Value::Base]
-    # @return [Sass::Script::Value::Base] The value indexed by `$key`, or `null`
-    #   if the map doesn't contain the given key
-    # @raise [ArgumentError] if `$map` is not a map
-    def map_get(map, key)
-      assert_type map, :Map, :map
-      map.to_h[key] || null
-    end
-    declare :map_get, [:map, :key]
-
-    # Merges two maps together into a new map. Keys in `$map2` will take
-    # precedence over keys in `$map1`.
-    #
-    # This is the best way to add new values to a map.
-    #
-    # All keys in the returned map that also appear in `$map1` will have the
-    # same order as in `$map1`. New keys from `$map2` will be placed at the end
-    # of the map.
-    #
-    # @example
-    #   map-merge(("foo": 1), ("bar": 2)) => ("foo": 1, "bar": 2)
-    #   map-merge(("foo": 1, "bar": 2), ("bar": 3)) => ("foo": 1, "bar": 3)
-    # @overload map_merge($map1, $map2)
-    #   @param $map1 [Sass::Script::Value::Map]
-    #   @param $map2 [Sass::Script::Value::Map]
-    # @return [Sass::Script::Value::Map]
-    # @raise [ArgumentError] if either parameter is not a map
-    def map_merge(map1, map2)
-      assert_type map1, :Map, :map1
-      assert_type map2, :Map, :map2
-      map(map1.to_h.merge(map2.to_h))
-    end
-    declare :map_merge, [:map1, :map2]
-
-    # Returns a new map with keys removed.
-    #
-    # @example
-    #   map-remove(("foo": 1, "bar": 2), "bar") => ("foo": 1)
-    #   map-remove(("foo": 1, "bar": 2, "baz": 3), "bar", "baz") => ("foo": 1)
-    #   map-remove(("foo": 1, "bar": 2), "baz") => ("foo": 1, "bar": 2)
-    # @overload map_remove($map, $keys...)
-    #   @param $map  [Sass::Script::Value::Map]
-    #   @param $keys [[Sass::Script::Value::Base]]
-    # @return [Sass::Script::Value::Map]
-    # @raise [ArgumentError] if `$map` is not a map
-    def map_remove(map, *keys)
-      assert_type map, :Map, :map
-      hash = map.to_h.dup
-      hash.delete_if {|key, _| keys.include?(key)}
-      map(hash)
-    end
-    declare :map_remove, [:map, :key], :var_args => true
-
-    # Returns a list of all keys in a map.
-    #
-    # @example
-    #   map-keys(("foo": 1, "bar": 2)) => "foo", "bar"
-    # @overload map_keys($map)
-    #   @param $map [Map]
-    # @return [List] the list of keys, comma-separated
-    # @raise [ArgumentError] if `$map` is not a map
-    def map_keys(map)
-      assert_type map, :Map, :map
-      list(map.to_h.keys, :comma)
-    end
-    declare :map_keys, [:map]
-
-    # Returns a list of all values in a map. This list may include duplicate
-    # values, if multiple keys have the same value.
-    #
-    # @example
-    #   map-values(("foo": 1, "bar": 2)) => 1, 2
-    #   map-values(("foo": 1, "bar": 2, "baz": 1)) => 1, 2, 1
-    # @overload map_values($map)
-    #   @param $map [Map]
-    # @return [List] the list of values, comma-separated
-    # @raise [ArgumentError] if `$map` is not a map
-    def map_values(map)
-      assert_type map, :Map, :map
-      list(map.to_h.values, :comma)
-    end
-    declare :map_values, [:map]
-
-    # Returns whether a map has a value associated with a given key.
-    #
-    # @example
-    #   map-has-key(("foo": 1, "bar": 2), "foo") => true
-    #   map-has-key(("foo": 1, "bar": 2), "baz") => false
-    # @overload map_has_key($map, $key)
-    #   @param $map [Sass::Script::Value::Map]
-    #   @param $key [Sass::Script::Value::Base]
-    # @return [Sass::Script::Value::Bool]
-    # @raise [ArgumentError] if `$map` is not a map
-    def map_has_key(map, key)
-      assert_type map, :Map, :map
-      bool(map.to_h.has_key?(key))
-    end
-    declare :map_has_key, [:map, :key]
-
-    # Returns the map of named arguments passed to a function or mixin that
-    # takes a variable argument list. The argument names are strings, and they
-    # do not contain the leading `$`.
-    #
-    # @example
-    #   @mixin foo($args...) {
-    #     @debug keywords($args); //=> (arg1: val, arg2: val)
-    #   }
-    #
-    #   @include foo($arg1: val, $arg2: val);
-    # @overload keywords($args)
-    #   @param $args [Sass::Script::Value::ArgList]
-    # @return [Sass::Script::Value::Map]
-    # @raise [ArgumentError] if `$args` isn't a variable argument list
-    def keywords(args)
-      assert_type args, :ArgList, :args
-      map(Sass::Util.map_keys(args.keywords.as_stored) {|k| Sass::Script::Value::String.new(k)})
-    end
-    declare :keywords, [:args]
-
     # Returns one of two values, depending on whether or not `$condition` is
     # true. Just like in `@if`, all values other than `false` and `null` are
     # considered to be true.
@@ -2124,483 +1474,50 @@ module Sass::Script
     #   if(true, 1px, 2px) => 1px
     #   if(false, 1px, 2px) => 2px
     # @overload if($condition, $if-true, $if-false)
-    #   @param $condition [Sass::Script::Value::Base] Whether the `$if-true` or
-    #     `$if-false` will be returned
-    #   @param $if-true [Sass::Script::Tree::Node]
-    #   @param $if-false [Sass::Script::Tree::Node]
-    # @return [Sass::Script::Value::Base] `$if-true` or `$if-false`
+    # @param $condition [Literal] Whether the `$if-true` or `$if-false` will be
+    #   returned
+    # @param $if-true [Literal]
+    # @param $if-false [Literal]
+    # @return [Literal] `$if-true` or `$if-false`
     def if(condition, if_true, if_false)
       if condition.to_bool
-        perform(if_true)
+        if_true
       else
-        perform(if_false)
+        if_false
       end
     end
-    declare :if, [:condition, :"&if_true", :"&if_false"]
-
-    # Returns a unique CSS identifier. The identifier is returned as an unquoted
-    # string. The identifier returned is only guaranteed to be unique within the
-    # scope of a single Sass run.
-    #
-    # @overload unique_id()
-    # @return [Sass::Script::Value::String]
-    def unique_id
-      generator = Sass::Script::Functions.random_number_generator
-      Thread.current[:sass_last_unique_id] ||= generator.rand(36**8)
-      # avoid the temptation of trying to guess the next unique value.
-      value = (Thread.current[:sass_last_unique_id] += (generator.rand(10) + 1))
-      # the u makes this a legal identifier if it would otherwise start with a number.
-      identifier("u" + value.to_s(36).rjust(8, '0'))
-    end
-    declare :unique_id, []
+    declare :if, [:condition, :if_true, :if_false]
 
-    # Dynamically calls a function. This can call user-defined
-    # functions, built-in functions, or plain CSS functions. It will
-    # pass along all arguments, including keyword arguments, to the
-    # called function.
-    #
-    # @example
-    #   call(rgb, 10, 100, 255) => #0a64ff
-    #   call(scale-color, #0a64ff, $lightness: -10%) => #0058ef
-    #
-    #   $fn: nth;
-    #   call($fn, (a b c), 2) => b
-    #
-    # @overload call($name, $args...)
-    #   @param $name [String] The name of the function to call.
-    def call(name, *args)
-      assert_type name, :String, :name
-      kwargs = args.last.is_a?(Hash) ? args.pop : {}
-      funcall = Sass::Script::Tree::Funcall.new(
-        name.value,
-        args.map {|a| Sass::Script::Tree::Literal.new(a)},
-        Sass::Util.map_vals(kwargs) {|v| Sass::Script::Tree::Literal.new(v)},
-        nil,
-        nil)
-      funcall.options = options
-      perform(funcall)
-    end
-    declare :call, [:name], :var_args => true, :var_kwargs => true
-
-    # This function only exists as a workaround for IE7's [`content:
-    # counter` bug](http://jes.st/2013/ie7s-css-breaking-content-counter-bug/).
-    # It works identically to any other plain-CSS function, except it
+    # This function only exists as a workaround for IE7's [`content: counter`
+    # bug][bug]. It works identically to any other plain-CSS function, except it
     # avoids adding spaces between the argument commas.
     #
+    # [bug]: http://jes.st/2013/ie7s-css-breaking-content-counter-bug/
+    #
     # @example
     #   counter(item, ".") => counter(item,".")
     # @overload counter($args...)
-    # @return [Sass::Script::Value::String]
+    # @return [String]
     def counter(*args)
-      identifier("counter(#{args.map {|a| a.to_s(options)}.join(',')})")
+      Sass::Script::String.new("counter(#{args.map {|a| a.to_s(options)}.join(',')})")
     end
     declare :counter, [], :var_args => true
 
-    # This function only exists as a workaround for IE7's [`content:
-    # counter` bug](http://jes.st/2013/ie7s-css-breaking-content-counter-bug/).
-    # It works identically to any other plain-CSS function, except it
+    # This function only exists as a workaround for IE7's [`content: counters`
+    # bug][bug]. It works identically to any other plain-CSS function, except it
     # avoids adding spaces between the argument commas.
     #
+    # [bug]: http://jes.st/2013/ie7s-css-breaking-content-counter-bug/
+    #
     # @example
     #   counters(item, ".") => counters(item,".")
     # @overload counters($args...)
-    # @return [Sass::Script::Value::String]
+    # @return [String]
     def counters(*args)
-      identifier("counters(#{args.map {|a| a.to_s(options)}.join(',')})")
+      Sass::Script::String.new("counters(#{args.map {|a| a.to_s(options)}.join(',')})")
     end
     declare :counters, [], :var_args => true
 
-    # Check whether a variable with the given name exists in the current
-    # scope or in the global scope.
-    #
-    # @example
-    #   $a-false-value: false;
-    #   variable-exists(a-false-value) => true
-    #
-    #   variable-exists(nonexistent) => false
-    #
-    # @overload variable_exists($name)
-    #   @param $name [Sass::Script::Value::String] The name of the variable to
-    #     check. The name should not include the `$`.
-    # @return [Sass::Script::Value::Bool] Whether the variable is defined in
-    #   the current scope.
-    def variable_exists(name)
-      assert_type name, :String, :name
-      bool(environment.caller.var(name.value))
-    end
-    declare :variable_exists, [:name]
-
-    # Check whether a variable with the given name exists in the global
-    # scope (at the top level of the file).
-    #
-    # @example
-    #   $a-false-value: false;
-    #   global-variable-exists(a-false-value) => true
-    #
-    #   .foo {
-    #     $some-var: false;
-    #     @if global-variable-exists(some-var) { /* false, doesn't run */ }
-    #   }
-    #
-    # @overload global_variable_exists($name)
-    #   @param $name [Sass::Script::Value::String] The name of the variable to
-    #     check. The name should not include the `$`.
-    # @return [Sass::Script::Value::Bool] Whether the variable is defined in
-    #   the global scope.
-    def global_variable_exists(name)
-      assert_type name, :String, :name
-      bool(environment.global_env.var(name.value))
-    end
-    declare :global_variable_exists, [:name]
-
-    # Check whether a function with the given name exists.
-    #
-    # @example
-    #   function-exists(lighten) => true
-    #
-    #   @function myfunc { @return "something"; }
-    #   function-exists(myfunc) => true
-    #
-    # @overload function_exists($name)
-    #   @param name [Sass::Script::Value::String] The name of the function to
-    #     check.
-    # @return [Sass::Script::Value::Bool] Whether the function is defined.
-    def function_exists(name)
-      assert_type name, :String, :name
-      exists = Sass::Script::Functions.callable?(name.value.tr("-", "_"))
-      exists ||= environment.function(name.value)
-      bool(exists)
-    end
-    declare :function_exists, [:name]
-
-    # Check whether a mixin with the given name exists.
-    #
-    # @example
-    #   mixin-exists(nonexistent) => false
-    #
-    #   @mixin red-text { color: red; }
-    #   mixin-exists(red-text) => true
-    #
-    # @overload mixin_exists($name)
-    #   @param name [Sass::Script::Value::String] The name of the mixin to
-    #     check.
-    # @return [Sass::Script::Value::Bool] Whether the mixin is defined.
-    def mixin_exists(name)
-      assert_type name, :String, :name
-      bool(environment.mixin(name.value))
-    end
-    declare :mixin_exists, [:name]
-
-    # Return a string containing the value as its Sass representation.
-    #
-    # @overload inspect($value)
-    #   @param $value [Sass::Script::Value::Base] The value to inspect.
-    # @return [Sass::Script::Value::String] A representation of the value as
-    #   it would be written in Sass.
-    def inspect(value)
-      unquoted_string(value.to_sass)
-    end
-    declare :inspect, [:value]
-
-    # @overload random()
-    #   Return a decimal between 0 and 1, inclusive of 0 but not 1.
-    #   @return [Sass::Script::Value::Number] A decimal value.
-    # @overload random($limit)
-    #   Return an integer between 1 and `$limit`, inclusive of 1 but not `$limit`.
-    #   @param $limit [Sass::Script::Value::Number] The maximum of the random integer to be
-    #     returned, a positive integer.
-    #   @return [Sass::Script::Value::Number] An integer.
-    #   @raise [ArgumentError] if the `$limit` is not 1 or greater
-    def random(limit = nil)
-      generator = Sass::Script::Functions.random_number_generator
-      if limit
-        assert_integer limit, "limit"
-        if limit.value < 1
-          raise ArgumentError.new("$limit #{limit} must be greater than or equal to 1")
-        end
-        number(1 + generator.rand(limit.value))
-      else
-        number(generator.rand)
-      end
-    end
-    declare :random, []
-    declare :random, [:limit]
-
-    # Parses a user-provided selector into a list of lists of strings
-    # as returned by `&`.
-    #
-    # @example
-    #   selector-parse(".foo .bar, .baz .bang") => ('.foo' '.bar', '.baz' '.bang')
-    #
-    # @overload selector_parse($selector)
-    #   @param $selector [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The selector to parse. This can be either a string, a list of
-    #     strings, or a list of lists of strings as returned by `&`.
-    #   @return [Sass::Script::Value::List]
-    #     A list of lists of strings representing `$selector`. This is
-    #     in the same format as a selector returned by `&`.
-    def selector_parse(selector)
-      parse_selector(selector, :selector).to_sass_script
-    end
-    declare :selector_parse, [:selector]
-
-    # Return a new selector with all selectors in `$selectors` nested beneath
-    # one another as though they had been nested in the stylesheet as
-    # `$selector1 { $selector2 { ... } }`.
-    #
-    # Unlike most selector functions, `selector-nest` allows the
-    # parent selector `&` to be used in any selector but the first.
-    #
-    # @example
-    #   selector-nest(".foo", ".bar", ".baz") => .foo .bar .baz
-    #   selector-nest(".a .foo", ".b .bar") => .a .foo .b .bar
-    #   selector-nest(".foo", "&.bar") => .foo.bar
-    #
-    # @overload selector_nest($selectors...)
-    #   @param $selectors [[Sass::Script::Value::String, Sass::Script::Value::List]]
-    #     The selectors to nest. At least one selector must be passed. Each of
-    #     these can be either a string, a list of strings, or a list of lists of
-    #     strings as returned by `&`.
-    #   @return [Sass::Script::Value::List]
-    #     A list of lists of strings representing the result of nesting
-    #     `$selectors`. This is in the same format as a selector returned by
-    #     `&`.
-    def selector_nest(*selectors)
-      if selectors.empty?
-        raise ArgumentError.new("$selectors: At least one selector must be passed")
-      end
-
-      parsed = [parse_selector(selectors.first, :selectors)]
-      parsed += selectors[1..-1].map {|sel| parse_selector(sel, :selectors, !!:parse_parent_ref)}
-      parsed.inject {|result, child| child.resolve_parent_refs(result)}.to_sass_script
-    end
-    declare :selector_nest, [], :var_args => true
-
-    # Return a new selector with all selectors in `$selectors` appended one
-    # another as though they had been nested in the stylesheet as `$selector1 {
-    # &$selector2 { ... } }`.
-    #
-    # @example
-    #   selector-append(".foo", ".bar", ".baz") => .foo.bar.baz
-    #   selector-append(".a .foo", ".b .bar") => "a .foo.b .bar"
-    #   selector-append(".foo", "-suffix") => ".foo-suffix"
-    #
-    # @overload selector_append($selectors...)
-    #   @param $selectors [[Sass::Script::Value::String, Sass::Script::Value::List]]
-    #     The selectors to append. At least one selector must be passed. Each of
-    #     these can be either a string, a list of strings, or a list of lists of
-    #     strings as returned by `&`.
-    #   @return [Sass::Script::Value::List]
-    #     A list of lists of strings representing the result of appending
-    #     `$selectors`. This is in the same format as a selector returned by
-    #     `&`.
-    #   @raise [ArgumentError] if a selector could not be appended.
-    def selector_append(*selectors)
-      if selectors.empty?
-        raise ArgumentError.new("$selectors: At least one selector must be passed")
-      end
-
-      selectors.map {|sel| parse_selector(sel, :selectors)}.inject do |parent, child|
-        child.members.each do |seq|
-          sseq = seq.members.first
-          unless sseq.is_a?(Sass::Selector::SimpleSequence)
-            raise ArgumentError.new("Can't append \"#{seq}\" to \"#{parent}\"")
-          end
-
-          base = sseq.base
-          case base
-          when Sass::Selector::Universal
-            raise ArgumentError.new("Can't append \"#{seq}\" to \"#{parent}\"")
-          when Sass::Selector::Element
-            unless base.namespace.nil?
-              raise ArgumentError.new("Can't append \"#{seq}\" to \"#{parent}\"")
-            end
-            sseq.members[0] = Sass::Selector::Parent.new(base.name)
-          else
-            sseq.members.unshift Sass::Selector::Parent.new
-          end
-        end
-        child.resolve_parent_refs(parent)
-      end.to_sass_script
-    end
-    declare :selector_append, [], :var_args => true
-
-    # Returns a new version of `$selector` with `$extendee` extended
-    # with `$extender`. This works just like the result of
-    #
-    #     $selector { ... }
-    #     $extender { @extend $extendee }
-    #
-    # @example
-    #   selector-extend(".a .b", ".b", ".foo .bar") => .a .b, .a .foo .bar, .foo .a .bar
-    #
-    # @overload selector_extend($selector, $extendee, $extender)
-    #   @param $selector [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The selector within which `$extendee` is extended with
-    #     `$extender`. This can be either a string, a list of strings,
-    #     or a list of lists of strings as returned by `&`.
-    #   @param $extendee [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The selector being extended. This can be either a string, a
-    #     list of strings, or a list of lists of strings as returned
-    #     by `&`.
-    #   @param $extender [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The selector being injected into `$selector`. This can be
-    #     either a string, a list of strings, or a list of lists of
-    #     strings as returned by `&`.
-    #   @return [Sass::Script::Value::List]
-    #     A list of lists of strings representing the result of the
-    #     extension. This is in the same format as a selector returned
-    #     by `&`.
-    #   @raise [ArgumentError] if the extension fails
-    def selector_extend(selector, extendee, extender)
-      selector = parse_selector(selector, :selector)
-      extendee = parse_selector(extendee, :extendee)
-      extender = parse_selector(extender, :extender)
-
-      extends = Sass::Util::SubsetMap.new
-      begin
-        extender.populate_extends(extends, extendee)
-        selector.do_extend(extends).to_sass_script
-      rescue Sass::SyntaxError => e
-        raise ArgumentError.new(e.to_s)
-      end
-    end
-    declare :selector_extend, [:selector, :extendee, :extender]
-
-    # Replaces all instances of `$original` with `$replacement` in `$selector`
-    #
-    # This works by using `@extend` and throwing away the original
-    # selector. This means that it can be used to do very advanced
-    # replacements; see the examples below.
-    #
-    # @example
-    #   selector-replace(".foo .bar", ".bar", ".baz") => ".foo .baz"
-    #   selector-replace(".foo.bar.baz", ".foo.baz", ".qux") => ".bar.qux"
-    #
-    # @overload selector_replace($selector, $original, $replacement)
-    #   @param $selector [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The selector within which `$original` is replaced with
-    #     `$replacement`. This can be either a string, a list of
-    #     strings, or a list of lists of strings as returned by `&`.
-    #   @param $original [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The selector being replaced. This can be either a string, a
-    #     list of strings, or a list of lists of strings as returned
-    #     by `&`.
-    #   @param $replacement [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The selector that `$original` is being replaced with. This
-    #     can be either a string, a list of strings, or a list of
-    #     lists of strings as returned by `&`.
-    #   @return [Sass::Script::Value::List]
-    #     A list of lists of strings representing the result of the
-    #     extension. This is in the same format as a selector returned
-    #     by `&`.
-    #   @raise [ArgumentError] if the replacement fails
-    def selector_replace(selector, original, replacement)
-      selector = parse_selector(selector, :selector)
-      original = parse_selector(original, :original)
-      replacement = parse_selector(replacement, :replacement)
-
-      extends = Sass::Util::SubsetMap.new
-      begin
-        replacement.populate_extends(extends, original)
-        selector.do_extend(extends, [], !!:replace).to_sass_script
-      rescue Sass::SyntaxError => e
-        raise ArgumentError.new(e.to_s)
-      end
-    end
-    declare :selector_replace, [:selector, :original, :replacement]
-
-    # Unifies two selectors into a single selector that matches only
-    # elements matched by both input selectors. Returns `null` if
-    # there is no such selector.
-    #
-    # Like the selector unification done for `@extend`, this doesn't
-    # guarantee that the output selector will match *all* elements
-    # matched by both input selectors. For example, if `.a .b` is
-    # unified with `.x .y`, `.a .x .b.y, .x .a .b.y` will be returned,
-    # but `.a.x .b.y` will not. This avoids exponential output size
-    # while matching all elements that are likely to exist in
-    # practice.
-    #
-    # @example
-    #   selector-unify(".a", ".b") => .a.b
-    #   selector-unify(".a .b", ".x .y") => .a .x .b.y, .x .a .b.y
-    #   selector-unify(".a.b", ".b.c") => .a.b.c
-    #   selector-unify("#a", "#b") => null
-    #
-    # @overload selector_unify($selector1, $selector2)
-    #   @param $selector1 [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The first selector to be unified. This can be either a
-    #     string, a list of strings, or a list of lists of strings as
-    #     returned by `&`.
-    #   @param $selector2 [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The second selector to be unified. This can be either a
-    #     string, a list of strings, or a list of lists of strings as
-    #     returned by `&`.
-    #   @return [Sass::Script::Value::List, Sass::Script::Value::Null]
-    #     A list of lists of strings representing the result of the
-    #     unification, or null if no unification exists. This is in
-    #     the same format as a selector returned by `&`.
-    def selector_unify(selector1, selector2)
-      selector1 = parse_selector(selector1, :selector1)
-      selector2 = parse_selector(selector2, :selector2)
-      return null unless (unified = selector1.unify(selector2))
-      unified.to_sass_script
-    end
-    declare :selector_unify, [:selector1, :selector2]
-
-    # Returns the [simple
-    # selectors](http://dev.w3.org/csswg/selectors4/#simple) that
-    # comprise the compound selector `$selector`.
-    #
-    # Note that `$selector` **must be** a [compound
-    # selector](http://dev.w3.org/csswg/selectors4/#compound). That
-    # means it cannot contain commas or spaces. It also means that
-    # unlike other selector functions, this takes only strings, not
-    # lists.
-    #
-    # @example
-    #   simple-selectors(".foo.bar") => ".foo", ".bar"
-    #   simple-selectors(".foo.bar.baz") => ".foo", ".bar", ".baz"
-    #
-    # @overload simple_selectors($selector)
-    #   @param $selector [Sass::Script::Value::String]
-    #     The compound selector whose simple selectors will be extracted.
-    #   @return [Sass::Script::Value::List]
-    #     A list of simple selectors in the compound selector.
-    def simple_selectors(selector)
-      selector = parse_compound_selector(selector, :selector)
-      list(selector.members.map {|simple| unquoted_string(simple.to_s)}, :comma)
-    end
-    declare :simple_selectors, [:selector]
-
-    # Returns whether `$super` is a superselector of `$sub`. This means that
-    # `$super` matches all the elements that `$sub` matches, as well as possibly
-    # additional elements. In general, simpler selectors tend to be
-    # superselectors of more complex oned.
-    #
-    # @example
-    #   is-superselector(".foo", ".foo.bar") => true
-    #   is-superselector(".foo.bar", ".foo") => false
-    #   is-superselector(".bar", ".foo .bar") => true
-    #   is-superselector(".foo .bar", ".bar") => false
-    #
-    # @overload is_superselector($super, $sub)
-    #   @param $super [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The potential superselector. This can be either a string, a list of
-    #     strings, or a list of lists of strings as returned by `&`.
-    #   @param $sub [Sass::Script::Value::String, Sass::Script::Value::List]
-    #     The potential subselector. This can be either a string, a list of
-    #     strings, or a list of lists of strings as returned by `&`.
-    #   @return [Sass::Script::Value::Bool]
-    #     Whether `$selector1` is a superselector of `$selector2`.
-    def is_superselector(sup, sub)
-      sup = parse_selector(sup, :super)
-      sub = parse_selector(sub, :sub)
-      bool(sup.superselector?(sub))
-    end
-    declare :is_superselector, [:super, :sub]
-
     private
 
     # This method implements the pattern of transforming a numeric value into
@@ -2608,19 +1525,19 @@ module Sass::Script
     # It yields a number to a block to perform the operation and return a number
     def numeric_transformation(value)
       assert_type value, :Number, :value
-      Sass::Script::Value::Number.new(
-        yield(value.value), value.numerator_units, value.denominator_units)
+      Sass::Script::Number.new(yield(value.value), value.numerator_units, value.denominator_units)
     end
 
-    # @comment
-    #   rubocop:disable ParameterLists
     def _adjust(color, amount, attr, range, op, units = "")
-      # rubocop:enable ParameterLists
       assert_type color, :Color, :color
       assert_type amount, :Number, :amount
       Sass::Util.check_range('Amount', range, amount, units)
 
-      color.with(attr => color.send(attr).send(op, amount.value))
+      # TODO: is it worth restricting here,
+      # or should we do so in the Color constructor itself,
+      # and allow clipping in rgb() et al?
+      color.with(attr => Sass::Util.restrict(
+          color.send(attr).send(op, amount.value), range))
     end
   end
 end