sassc-embedded 1.64.2 → 1.68.1

data/vendor/github.com/sass/sassc-ruby/lib/sassc/native/native_functions_api.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    # Creators for sass function list and function descriptors
+    # ADDAPI Sass_C_Function_List ADDCALL sass_make_function_list (size_t length);
+    # ADDAPI Sass_C_Function_Callback ADDCALL sass_make_function (const char* signature, Sass_C_Function fn, void* cookie);
+    attach_function :sass_make_function_list, [:size_t], :sass_c_function_list_ptr
+    attach_function :sass_make_function, [:string, :sass_c_function, :pointer], :sass_c_function_callback_ptr
+
+    # Setters and getters for callbacks on function lists
+    # ADDAPI Sass_C_Function_Callback ADDCALL sass_function_get_list_entry(Sass_C_Function_List list, size_t pos);
+    # ADDAPI void ADDCALL sass_function_set_list_entry(Sass_C_Function_List list, size_t pos, Sass_C_Function_Callback cb);
+    attach_function :sass_function_get_list_entry, [:sass_c_function_list_ptr, :size_t], :sass_c_function_callback_ptr
+    attach_function :sass_function_set_list_entry, [:sass_c_function_list_ptr, :size_t, :sass_c_function_callback_ptr], :void
+
+    # ADDAPI union Sass_Value* ADDCALL sass_make_number  (double val, const char* unit);
+    attach_function :sass_make_number, [:double, :string], :sass_value_ptr
+
+    # ADDAPI union Sass_Value* ADDCALL sass_make_string  (const char* val);
+    attach_function :sass_make_string, [:string], :sass_value_ptr
+
+    # ADDAPI union Sass_Value* ADDCALL sass_make_qstring (const char* val);
+    attach_function :sass_make_qstring, [:string], :sass_value_ptr
+
+    # ADDAPI union Sass_Value* ADDCALL sass_make_color   (double r, double g, double b, double a);
+    attach_function :sass_make_color, [:double, :double, :double, :double], :sass_value_ptr
+
+    # ADDAPI union Sass_Value* ADDCALL sass_make_map     (size_t len);
+    attach_function :sass_make_map, [:size_t], :sass_value_ptr
+
+    # ADDAPI union Sass_Value* ADDCALL sass_make_list     (size_t len, enum Sass_Separator sep)
+    attach_function :sass_make_list, [:size_t, SassSeparator], :sass_value_ptr
+
+    # ADDAPI union Sass_Value* ADDCALL sass_make_boolean (boolean val);
+    attach_function :sass_make_boolean, [:bool], :sass_value_ptr
+
+    # ADDAPI void ADDCALL sass_map_set_key (union Sass_Value* v, size_t i, union Sass_Value*);
+    attach_function :sass_map_set_key, [:sass_value_ptr, :size_t, :sass_value_ptr], :void
+
+    # ADDAPI union Sass_Value* ADDCALL sass_map_get_key (const union Sass_Value* v, size_t i);
+    attach_function :sass_map_get_key, [:sass_value_ptr, :size_t], :sass_value_ptr
+
+    # ADDAPI void ADDCALL sass_map_set_value (union Sass_Value* v, size_t i, union Sass_Value*);
+    attach_function :sass_map_set_value, [:sass_value_ptr, :size_t, :sass_value_ptr], :void
+
+    # ADDAPI union Sass_Value* ADDCALL sass_map_get_value (const union Sass_Value* v, size_t i);
+    attach_function :sass_map_get_value, [:sass_value_ptr, :size_t], :sass_value_ptr
+
+    # ADDAPI size_t ADDCALL sass_map_get_length (const union Sass_Value* v);
+    attach_function :sass_map_get_length, [:sass_value_ptr], :size_t
+
+    # ADDAPI union Sass_Value* ADDCALL sass_list_get_value (const union Sass_Value* v, size_t i);
+    attach_function :sass_list_get_value, [:sass_value_ptr, :size_t], :sass_value_ptr
+
+    # ADDAPI void ADDCALL sass_list_set_value (union Sass_Value* v, size_t i, union Sass_Value* value);
+    attach_function :sass_list_set_value, [:sass_value_ptr, :size_t, :sass_value_ptr], :void
+
+    # ADDAPI size_t ADDCALL sass_list_get_length (const union Sass_Value* v);
+    attach_function :sass_list_get_length, [:sass_value_ptr], :size_t
+
+    # ADDAPI union Sass_Value* ADDCALL sass_make_error   (const char* msg);
+    attach_function :sass_make_error, [:string], :sass_value_ptr
+
+    # ADDAPI enum Sass_Tag ADDCALL sass_value_get_tag (const union Sass_Value* v);
+    attach_function :sass_value_get_tag, [:sass_value_ptr], SassTag
+    attach_function :sass_value_is_null, [:sass_value_ptr], :bool
+
+    # ADDAPI const char* ADDCALL sass_string_get_value (const union Sass_Value* v);
+    attach_function :sass_string_get_value, [:sass_value_ptr], :string
+
+    # ADDAPI bool ADDCALL sass_string_is_quoted(const union Sass_Value* v);
+    attach_function :sass_string_is_quoted, [:sass_value_ptr], :bool
+
+    # ADDAPI const char* ADDCALL sass_number_get_value (const union Sass_Value* v);
+    attach_function :sass_number_get_value, [:sass_value_ptr], :double
+
+    # ADDAPI const char* ADDCALL sass_number_get_unit (const union Sass_Value* v);
+    attach_function :sass_number_get_unit, [:sass_value_ptr], :string
+    
+    # ADDAPI const char* ADDCALL sass_boolean_get_value (const union Sass_Value* v);
+    attach_function :sass_boolean_get_value, [:sass_value_ptr], :bool
+
+    def self.string_get_type(native_value)
+      string_is_quoted(native_value) ? :string : :identifier
+    end
+
+    # ADDAPI double ADDCALL sass_color_get_r (const union Sass_Value* v);
+    # ADDAPI void ADDCALL sass_color_set_r (union Sass_Value* v, double r);
+    # ADDAPI double ADDCALL sass_color_get_g (const union Sass_Value* v);
+    # ADDAPI void ADDCALL sass_color_set_g (union Sass_Value* v, double g);
+    # ADDAPI double ADDCALL sass_color_get_b (const union Sass_Value* v);
+    # ADDAPI void ADDCALL sass_color_set_b (union Sass_Value* v, double b);
+    # ADDAPI double ADDCALL sass_color_get_a (const union Sass_Value* v);
+    # ADDAPI void ADDCALL sass_color_set_a (union Sass_Value* v, double a);
+    ['r', 'g', 'b', 'a'].each do |color_channel|
+      attach_function "sass_color_get_#{color_channel}".to_sym, [:sass_value_ptr], :double
+      attach_function "sass_color_set_#{color_channel}".to_sym, [:sass_value_ptr, :double], :void
+    end
+
+    # ADDAPI char* ADDCALL sass_error_get_message (const union Sass_Value* v);
+    # ADDAPI void ADDCALL sass_error_set_message (union Sass_Value* v, char* msg);
+    attach_function :sass_error_get_message, [:sass_value_ptr], :string
+    attach_function :sass_error_set_message, [:sass_value_ptr, :pointer], :void
+
+    # Getters for custom function descriptors
+    # ADDAPI const char* ADDCALL sass_function_get_signature (Sass_C_Function_Callback fn);
+    # ADDAPI Sass_C_Function ADDCALL sass_function_get_function (Sass_C_Function_Callback fn);
+    # ADDAPI void* ADDCALL sass_function_get_cookie (Sass_C_Function_Callback fn);
+    attach_function :sass_function_get_signature, [:sass_c_function_callback_ptr], :string
+    attach_function :sass_function_get_function, [:sass_c_function_callback_ptr], :sass_c_function
+    attach_function :sass_function_get_cookie, [:sass_c_function_callback_ptr], :pointer
+
+    # Creators for custom importer callback (with some additional pointer)
+    # The pointer is mostly used to store the callback into the actual binding
+    # ADDAPI Sass_C_Import_Callback ADDCALL sass_make_importer (Sass_C_Import_Fn, void* cookie);
+    attach_function :sass_make_importer, [:sass_c_import_function, :pointer], :sass_importer
+
+    # Getters for import function descriptors
+    # ADDAPI Sass_C_Import_Fn ADDCALL sass_import_get_function (Sass_C_Import_Callback fn);
+    # ADDAPI void* ADDCALL sass_import_get_cookie (Sass_C_Import_Callback fn);
+
+    # Deallocator for associated memory
+    # ADDAPI void ADDCALL sass_delete_importer (Sass_C_Import_Callback fn);
+
+    # Creator for sass custom importer return argument list
+    # ADDAPI struct Sass_Import** ADDCALL sass_make_import_list (size_t length);
+    attach_function :sass_make_import_list, [:size_t], :sass_import_list_ptr
+
+    # Creator for a single import entry returned by the custom importer inside the list
+    # ADDAPI struct Sass_Import* ADDCALL sass_make_import_entry (const char* path, char* source, char* srcmap);
+    # ADDAPI struct Sass_Import* ADDCALL sass_make_import (const char* path, const char* base, char* source, char* srcmap);
+    attach_function :sass_make_import_entry, [:string, :pointer, :pointer], :sass_import_ptr
+
+    # Setters to insert an entry into the import list (you may also use [] access directly)
+    # Since we are dealing with pointers they should have a guaranteed and fixed size
+    # ADDAPI void ADDCALL sass_import_set_list_entry (struct Sass_Import** list, size_t idx, struct Sass_Import* entry);
+    attach_function :sass_import_set_list_entry, [:sass_import_list_ptr, :size_t, :sass_import_ptr], :void
+    # ADDAPI struct Sass_Import* ADDCALL sass_import_get_list_entry (struct Sass_Import** list, size_t idx);
+
+    # Getters for import entry
+    # ADDAPI const char* ADDCALL sass_import_get_imp_path (struct Sass_Import*);
+    attach_function :sass_import_get_imp_path, [:sass_import_ptr], :string
+    # ADDAPI const char* ADDCALL sass_import_get_abs_path (struct Sass_Import*);
+    attach_function :sass_import_get_abs_path, [:sass_import_ptr], :string
+    # ADDAPI const char* ADDCALL sass_import_get_source (struct Sass_Import*);
+    attach_function :sass_import_get_source, [:sass_import_ptr], :string
+    # ADDAPI const char* ADDCALL sass_import_get_srcmap (struct Sass_Import*);
+    # Explicit functions to take ownership of these items
+    # The property on our struct will be reset to NULL
+    # ADDAPI char* ADDCALL sass_import_take_source (struct Sass_Import*);
+    # ADDAPI char* ADDCALL sass_import_take_srcmap (struct Sass_Import*);
+
+    # Deallocator for associated memory (incl. entries)
+    # ADDAPI void ADDCALL sass_delete_import_list (struct Sass_Import**);
+    # Just in case we have some stray import structs
+    # ADDAPI void ADDCALL sass_delete_import (struct Sass_Import*);
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/native/sass2scss_api.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    # ADDAPI char* ADDCALL sass2scss (const char* sass, const int options);
+    attach_function :sass2scss, [:string, :int], :string
+
+    # ADDAPI const char* ADDCALL sass2scss_version(void);
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/native/sass_input_style.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    SassInputStyle = enum(
+      :sass_context_null,
+      :sass_context_file,
+      :sass_context_data,
+      :sass_context_folder
+    )
+  end
+end
+

data/vendor/github.com/sass/sassc-ruby/lib/sassc/native/sass_output_style.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    SassOutputStyle = enum(
+      :sass_style_nested,
+      :sass_style_expanded,
+      :sass_style_compact,
+      :sass_style_compressed
+    )
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/native/sass_value.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    class SassValue < FFI::Union; end
+
+    SassTag = enum(
+      :sass_boolean,
+      :sass_number,
+      :sass_color,
+      :sass_string,
+      :sass_list,
+      :sass_map,
+      :sass_null,
+      :sass_error,
+      :sass_warning
+    )
+
+    SassSeparator = enum(
+      :sass_comma,
+      :sass_space
+    )
+
+    class SassUnknown < FFI::Struct
+      layout :tag, SassTag
+    end
+
+    class SassBoolean < FFI::Struct
+      layout :tag, SassTag,
+             :value, :bool
+    end
+
+    class SassNumber < FFI::Struct
+      layout :tag, SassTag,
+             :value, :double,
+             :unit, :string
+    end
+
+    class SassColor < FFI::Struct
+      layout :tag, SassTag,
+             :r, :double,
+             :g, :double,
+             :b, :double,
+             :a, :double
+    end
+
+    class SassString < FFI::Struct
+      layout :tag, SassTag,
+             :value, :string
+    end
+
+    class SassList < FFI::Struct
+      layout :tag, SassTag,
+             :separator, SassSeparator,
+             :length, :size_t,
+             :values, :pointer
+    end
+
+    class SassMapPair < FFI::Struct
+      layout :key, SassValue.ptr,
+             :value, SassValue.ptr
+    end
+
+    class SassMap < FFI::Struct
+      layout :tag, SassTag,
+             :length, :size_t,
+             :pairs, SassMapPair.ptr
+    end
+
+    class SassNull < FFI::Struct
+      layout :tag, SassTag
+    end
+
+    class SassError < FFI::Struct
+      layout :tag, SassTag,
+             :message, :string
+    end
+
+    class SassWarning < FFI::Struct
+      layout :tag, SassTag,
+             :message, :string
+    end
+
+    class SassValue # < FFI::Union
+      layout :unknown, SassUnknown,
+             :boolean, SassBoolean,
+             :number, SassNumber,
+             :color, SassColor,
+             :string, SassString,
+             :list, SassList,
+             :map, SassMap,
+             :null, SassNull,
+             :error, SassError,
+             :warning, SassWarning
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/native/string_list.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    class StringList < FFI::Struct
+      layout :string_list, StringList.ptr,
+             :string, :string
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/native.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module SassC
+  module Native
+    extend FFI::Library
+
+    dl_ext = RbConfig::MAKEFILE_CONFIG['DLEXT']
+    begin
+      ffi_lib File.expand_path("libsass.#{dl_ext}", __dir__)
+    rescue LoadError # Some non-rvm environments don't copy a shared object over to lib/sassc
+      ffi_lib File.expand_path("libsass.#{dl_ext}", "#{__dir__}/../../ext")
+    end
+
+    require_relative "native/sass_value"
+
+    typedef :pointer, :sass_options_ptr
+    typedef :pointer, :sass_context_ptr
+    typedef :pointer, :sass_file_context_ptr
+    typedef :pointer, :sass_data_context_ptr
+
+    typedef :pointer, :sass_c_function_list_ptr
+    typedef :pointer, :sass_c_function_callback_ptr
+    typedef :pointer, :sass_value_ptr
+
+    typedef :pointer, :sass_import_list_ptr
+    typedef :pointer, :sass_importer
+    typedef :pointer, :sass_import_ptr
+
+    callback :sass_c_function, [:pointer, :pointer], :pointer
+    callback :sass_c_import_function, [:pointer, :pointer, :pointer], :pointer
+
+    require_relative "native/sass_input_style"
+    require_relative "native/sass_output_style"
+    require_relative "native/string_list"
+
+    # Remove the redundant "sass_" from the beginning of every method name
+    def self.attach_function(*args)
+      return super if args.size != 3
+
+      if args[0] =~ /^sass_/
+        args.unshift args[0].to_s.sub(/^sass_/, "")
+      end
+
+      super(*args)
+    end
+
+    # https://github.com/ffi/ffi/wiki/Examples#array-of-strings
+    def self.return_string_array(ptr)
+      ptr.null? ? [] : ptr.get_array_of_string(0).compact
+    end
+
+    def self.native_string(string)
+      m = FFI::MemoryPointer.from_string(string)
+      m.autorelease = false
+      m
+    end
+
+    require_relative "native/native_context_api"
+    require_relative "native/native_functions_api"
+    require_relative "native/sass2scss_api"
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/sass_2_scss.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SassC
+  class Sass2Scss
+    def self.convert(sass)
+      Native.sass2scss(sass, 0)
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/functions.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module Functions
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value/bool.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# A SassScript object representing a boolean (true or false) value.
+
+class SassC::Script::Value::Bool < SassC::Script::Value
+
+  # The true value in SassScript.
+  # This is assigned before new is overridden below so that we use the default implementation.
+  TRUE = new(true)
+
+  # The false value in SassScript.
+  # This is assigned before new is overridden below so that we use the default implementation.
+  FALSE = new(false)
+
+  # We override object creation so that users of the core API
+  # will not need to know that booleans are specific constants.
+  # Tests `value` for truthiness and returns the TRUE or FALSE constant.
+  def self.new(value)
+    value ? TRUE : FALSE
+  end
+
+  # The pure Ruby value of this Boolean
+  attr_reader :value
+  alias_method :to_bool, :value
+
+  # Returns the string "true" or "false" for this value
+  def to_s(opts = {})
+    @value.to_s
+  end
+  alias_method :to_sass, :to_s
+
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value/color.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# A SassScript object representing a CSS color.
+# This class provides a very bare-bones system for storing a RGB(A) or HSL(A)
+# color and converting it to a CSS color function.
+#
+# If your Sass method accepts a  color you will need to perform any
+# needed color mathematics or transformations yourself.
+
+class SassC::Script::Value::Color < SassC::Script::Value
+
+  attr_reader :red
+  attr_reader :green
+  attr_reader :blue
+  attr_reader :hue
+  attr_reader :saturation
+  attr_reader :lightness
+  attr_reader :alpha
+
+  # Creates a new color with (`red`, `green`, `blue`) or (`hue`, `saturation`, `lightness`
+  # values, plus an optional `alpha` transparency value.
+  def initialize(red:nil, green:nil, blue:nil, hue:nil, saturation:nil, lightness:nil, alpha:1.0)
+    if red && green && blue && alpha
+      @mode = :rgba
+      @red = SassC::Util.clamp(red.to_i, 0, 255)
+      @green = SassC::Util.clamp(green.to_i, 0, 255)
+      @blue = SassC::Util.clamp(blue.to_i, 0, 255)
+      @alpha = SassC::Util.clamp(alpha.to_f, 0.0, 1.0)
+    elsif hue && saturation && lightness && alpha
+      @mode = :hsla
+      @hue = SassC::Util.clamp(hue.to_i, 0, 360)
+      @saturation = SassC::Util.clamp(saturation.to_i, 0, 100)
+      @lightness = SassC::Util.clamp(lightness.to_i, 0, 100)
+      @alpha = SassC::Util.clamp(alpha.to_f, 0.0, 1.0)
+    else
+      raise SassC::UnsupportedValue, "Unable to determine color configuration for "
+    end
+  end
+
+  # Returns a CSS color declaration in the form
+  # `rgb(…)`, `rgba(…)`, `hsl(…)`, or `hsla(…)`.
+  def to_s
+    if rgba? && @alpha == 1.0
+      return "rgb(#{@red}, #{@green}, #{@blue})"
+    elsif rgba?
+      return "rgba(#{@red}, #{@green}, #{@blue}, #{alpha_string})"
+    elsif hsla? && @alpha == 1.0
+      return "hsl(#{@hue}, #{@saturation}%, #{@lightness}%)"
+    else # hsla?
+      return "hsla(#{@hue}, #{@saturation}%, #{@lightness}%, #{alpha_string})"
+    end
+  end
+
+  # True if this color has RGBA values
+  def rgba?
+    @mode == :rgba
+  end
+
+  # True if this color has HSLA values
+  def hlsa?
+    @mode == :hlsa
+  end
+
+  # Returns the alpha value of this color as a string
+  # and rounded to 8 decimal places.
+  def alpha_string
+    alpha.round(8).to_s
+  end
+
+  # Returns the values of this color in an array.
+  # Provided for compatibility between different SassC::Script::Value classes
+  def value
+    return [
+      red, green, blue,
+      hue, saturation, lightness,
+      alpha,
+    ].compact
+  end
+
+  # True if this Color is equal to `other_color`
+  def eql?(other_color)
+    unless other_color.is_a?(self.class)
+      raise ArgumentError, "No implicit conversion of #{other_color.class} to #{self.class}"
+    end
+    self.value == other_color.value
+  end
+  alias_method :==, :eql?
+
+  # Returns a numeric value for comparing two Color objects
+  # This method is used internally by the Hash class and is not the same as `.to_h`
+  def hash
+    value.hash
+  end
+
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value/list.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# A SassScript object representing a CSS list.
+# This includes both comma-separated lists and space-separated lists.
+
+class SassC::Script::Value::List < SassC::Script::Value
+
+  # The Ruby array containing the contents of the list.
+  #
+  # @return [Array<Value>]
+  attr_reader :value
+  alias_method :to_a, :value
+
+  # The operator separating the values of the list.
+  # Either `:comma` or `:space`.
+  #
+  # @return [Symbol]
+  attr_reader :separator
+
+  # Whether the list is surrounded by square brackets.
+  #
+  # @return [Boolean]
+  attr_reader :bracketed
+
+  # Creates a new list.
+  #
+  # @param value [Array<Value>] See \{#value}
+  # @param separator [Symbol] See \{#separator}
+  # @param bracketed [Boolean] See \{#bracketed}
+  def initialize(value, separator: nil, bracketed: false)
+    super(value)
+    @separator = separator
+    @bracketed = bracketed
+  end
+
+  # @see Value#options=
+  def options=(options)
+    super
+    value.each {|v| v.options = options}
+  end
+
+  # @see Value#eq
+  def eq(other)
+    SassC::Script::Value::Bool.new(
+      other.is_a?(List) && value == other.value &&
+      separator == other.separator && bracketed == other.bracketed
+    )
+  end
+
+  def hash
+    @hash ||= [value, separator, bracketed].hash
+  end
+
+  # @see Value#to_s
+  def to_s(opts = {})
+    if !bracketed && value.empty?
+      raise SassC::SyntaxError.new("#{inspect} isn't a valid CSS value.")
+    end
+
+    members = value.
+      reject {|e| e.is_a?(Null) || e.is_a?(List) && e.value.empty?}.
+      map {|e| e.to_s(opts)}
+
+    contents = members.join(sep_str)
+    bracketed ? "[#{contents}]" : contents
+  end
+
+  # @see Value#to_sass
+  def to_sass(opts = {})
+    return bracketed ? "[]" : "()" if value.empty?
+    members = value.map do |v|
+      if element_needs_parens?(v)
+        "(#{v.to_sass(opts)})"
+      else
+        v.to_sass(opts)
+      end
+    end
+
+    if separator == :comma && members.length == 1
+      return "#{bracketed ? '[' : '('}#{members.first},#{bracketed ? ']' : ')'}"
+    end
+
+    contents = members.join(sep_str(nil))
+    bracketed ? "[#{contents}]" : contents
+  end
+
+  # @see Value#to_h
+  def to_h
+    return {} if value.empty?
+    super
+  end
+
+  # @see Value#inspect
+  def inspect
+    (bracketed ? '[' : '(') + value.map {|e| e.inspect}.join(sep_str(nil)) + (bracketed ? ']' : ')')
+  end
+
+  # Asserts an index is within the list.
+  #
+  # @private
+  #
+  # @param list [Sass::Script::Value::List] The list for which the index should be checked.
+  # @param n [Sass::Script::Value::Number] The index being checked.
+  def self.assert_valid_index(list, n)
+    if !n.int? || n.to_i == 0
+      raise ArgumentError.new("List index #{n} must be a non-zero integer")
+    elsif list.to_a.size == 0
+      raise ArgumentError.new("List index is #{n} but list has no items")
+    elsif n.to_i.abs > (size = list.to_a.size)
+      raise ArgumentError.new(
+        "List index is #{n} but list is only #{size} item#{'s' if size != 1} long")
+    end
+  end
+
+  private
+
+  def element_needs_parens?(element)
+    if element.is_a?(List)
+      return false if element.value.length < 2
+      return false if element.bracketed
+      precedence = Sass::Script::Parser.precedence_of(separator || :space)
+      return Sass::Script::Parser.precedence_of(element.separator || :space) <= precedence
+    end
+
+    return false unless separator == :space
+    return false unless element.is_a?(Sass::Script::Tree::UnaryOperation)
+    element.operator == :minus || element.operator == :plus
+  end
+
+  def sep_str(opts = options)
+    return ' ' if separator == :space
+    return ',' if opts && opts[:style] == :compressed
+    ', '
+  end
+
+end