sass-embedded 1.54.6-x86_64-darwin

data/lib/sass/value/function.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's function type.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/SassFunction
+    class Function
+      include Value
+
+      # @overload initialize(id)
+      #   @param id [Numeric]
+      # @overload initialize(signature, callback)
+      #   @param signature [::String]
+      #   @param callback [Proc]
+      def initialize(id_or_signature, callback = nil)
+        if id_or_signature.is_a? Numeric
+          @id = id_or_signature
+        else
+          @signature = id_or_signature
+          @callback = callback
+        end
+      end
+
+      # @return [Integer, nil]
+      attr_reader :id
+
+      # @return [::String, nil]
+      attr_reader :signature
+
+      # @return [Proc, nil]
+      attr_reader :callback
+
+      # @return [::Boolean]
+      def ==(other)
+        if id.nil?
+          other.equal? self
+        else
+          other.is_a?(Sass::Value::Function) && other.id == id
+        end
+      end
+
+      # @return [Integer]
+      def hash
+        id.nil? ? signature.hash : id.hash
+      end
+
+      # @return [Function]
+      def assert_function(_name = nil)
+        self
+      end
+    end
+  end
+end

data/lib/sass/value/fuzzy_math.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's {FuzzyMath} module.
+    module FuzzyMath
+      PRECISION = 10
+
+      EPSILON = 10.pow(-PRECISION - 1)
+
+      INVERSE_EPSILON = 1 / EPSILON
+
+      module_function
+
+      def equals(number1, number2)
+        (number1 - number2).abs < EPSILON
+      end
+
+      def less_than(number1, number2)
+        number1 < number2 && !equals(number1, number2)
+      end
+
+      def less_than_or_equals(number1, number2)
+        number1 < number2 || equals(number1, number2)
+      end
+
+      def greater_than(number1, number2)
+        number1 > number2 && !equals(number1, number2)
+      end
+
+      def greater_than_or_equals(number1, number2)
+        number1 > number2 || equals(number1, number2)
+      end
+
+      def integer?(number)
+        return false unless number.finite?
+        return true if number.integer?
+
+        equals((number - 0.5).abs % 1, 0.5)
+      end
+
+      def to_i(number)
+        integer?(number) ? number.round : nil
+      end
+
+      def round(number)
+        if number.positive?
+          less_than(number % 1, 0.5) ? number.floor : number.ceil
+        else
+          less_than_or_equals(number % 1, 0.5) ? number.floor : number.ceil
+        end
+      end
+
+      def between(number, min, max)
+        return min if equals(number, min)
+        return max if equals(number, max)
+        return number if number > min && number < max
+
+        nil
+      end
+
+      def assert_between(number, min, max, name)
+        result = between(number, min, max)
+        return result unless result.nil?
+
+        message = "#{number} must be between #{min} and #{max}."
+        raise Sass::ScriptError, name.nil? ? message : "$#{name}: #{message}"
+      end
+
+      def hash(number)
+        @hash ||= if number.finite?
+                    (number * INVERSE_EPSILON).round.hash
+                  else
+                    number.hash
+                  end
+      end
+    end
+
+    private_constant :FuzzyMath
+  end
+end

data/lib/sass/value/list.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's list type.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/SassList
+    class List
+      include Value
+
+      # @param contents [Array<Value>]
+      # @param separator [::String]
+      # @param bracketed [::Boolean]
+      def initialize(contents = [], separator: ',', bracketed: false)
+        if separator.nil? && contents.length > 1
+          raise error 'A list with more than one element must have an explicit separator'
+        end
+
+        @contents = contents.freeze
+        @separator = separator.freeze
+        @bracketed = bracketed.freeze
+      end
+
+      # @return [Array<Value>]
+      attr_reader :contents
+
+      # @return [::String, nil]
+      attr_reader :separator
+
+      # @return [::Boolean]
+      def bracketed?
+        @bracketed
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        (other.is_a?(Sass::Value::List) &&
+         other.contents == contents &&
+         other.separator == separator &&
+         other.bracketed? == bracketed?) ||
+          (to_a.empty? && other.is_a?(Sass::Value::Map) && other.to_a.empty?)
+      end
+
+      # @param index [Numeric]
+      # @return [Value]
+      def at(index)
+        index = index.floor
+        index = to_a.length + index if index.negative?
+        return nil if index.negative? || index >= to_a.length
+
+        to_a[index]
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= contents.hash
+      end
+
+      alias to_a contents
+
+      # @return [Map, nil]
+      def to_map
+        to_a.empty? ? Sass::Value::Map.new({}) : nil
+      end
+
+      # @return [Map]
+      # @raise [ScriptError]
+      def assert_map(name = nil)
+        to_a.empty? ? Sass::Value::Map.new({}) : super.assert_map(name)
+      end
+
+      private
+
+      def to_a_length
+        to_a.length
+      end
+    end
+  end
+end

data/lib/sass/value/map.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's map type.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/SassMap
+    class Map
+      include Value
+
+      # @param contents [Hash<Value, Value>]
+      def initialize(contents = {})
+        @contents = contents.freeze
+      end
+
+      # @return [Hash<Value, Value>]
+      attr_reader :contents
+
+      # @return [::String, nil]
+      def separator
+        contents.empty? ? nil : ','
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        (other.is_a?(Sass::Value::Map) && other.contents == contents) ||
+          (contents.empty? && other.is_a?(Sass::Value::List) && other.to_a.empty?)
+      end
+
+      # @param index [Numeric, Value]
+      # @return [List<(Value, Value)>, Value]
+      def at(index)
+        if index.is_a? Numeric
+          index = index.floor
+          index = to_a.length + index if index.negative?
+          return nil if index.negative? || index >= to_a.length
+
+          to_a[index]
+        else
+          contents[index]
+        end
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= contents.hash
+      end
+
+      # @return [Array<List<(Value, Value)>>]
+      def to_a
+        contents.to_a.map { |entry| Sass::Value::List.new(entry, separator: ' ') }
+      end
+
+      # @return [Map]
+      def to_map
+        self
+      end
+
+      # @return [Map]
+      def assert_map(_name = nil)
+        self
+      end
+
+      private
+
+      def to_a_length
+        contents.length
+      end
+    end
+  end
+end

data/lib/sass/value/null.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's null type.
+    #
+    # @see https://sass-lang.com/documentation/js-api/modules#sassNull
+    class Null
+      include Value
+
+      def initialize
+        @value = nil
+      end
+
+      # @return [nil]
+      attr_reader :value
+
+      # @return [Boolean]
+      def !
+        Boolean::TRUE
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::Value::Null)
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= value.hash
+      end
+
+      # @return [::Boolean]
+      def to_bool
+        false
+      end
+
+      alias to_nil value
+
+      # Sass's null value.
+      NULL = Null.new
+
+      def self.new
+        NULL
+      end
+    end
+  end
+end

data/lib/sass/value/number/unit.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Number
+      # The {Unit} module.
+      module Unit
+        CONVERSIONS = {
+          # Length
+          'in' => {
+            'in' => Rational(1),
+            'cm' => Rational(1, 2.54),
+            'pc' => Rational(1, 6),
+            'mm' => Rational(1, 25.4),
+            'q' => Rational(1, 101.6),
+            'pt' => Rational(1, 72),
+            'px' => Rational(1, 96)
+          },
+          'cm' => {
+            'in' => Rational(2.54),
+            'cm' => Rational(1),
+            'pc' => Rational(2.54, 6),
+            'mm' => Rational(1, 10),
+            'q' => Rational(1, 40),
+            'pt' => Rational(2.54, 72),
+            'px' => Rational(2.54, 96)
+          },
+          'pc' => {
+            'in' => Rational(6),
+            'cm' => Rational(6, 2.54),
+            'pc' => Rational(1),
+            'mm' => Rational(6, 25.4),
+            'q' => Rational(6, 101.6),
+            'pt' => Rational(1, 12),
+            'px' => Rational(1, 16)
+          },
+          'mm' => {
+            'in' => Rational(25.4),
+            'cm' => Rational(10),
+            'pc' => Rational(25.4, 6),
+            'mm' => Rational(1),
+            'q' => Rational(1, 4),
+            'pt' => Rational(25.4, 72),
+            'px' => Rational(25.4, 96)
+          },
+          'q' => {
+            'in' => Rational(101.6),
+            'cm' => Rational(40),
+            'pc' => Rational(101.6, 6),
+            'mm' => Rational(4),
+            'q' => Rational(1),
+            'pt' => Rational(101.6, 72),
+            'px' => Rational(101.6, 96)
+          },
+          'pt' => {
+            'in' => Rational(72),
+            'cm' => Rational(72, 2.54),
+            'pc' => Rational(12),
+            'mm' => Rational(72, 25.4),
+            'q' => Rational(72, 101.6),
+            'pt' => Rational(1),
+            'px' => Rational(3, 4)
+          },
+          'px' => {
+            'in' => Rational(96),
+            'cm' => Rational(96, 2.54),
+            'pc' => Rational(16),
+            'mm' => Rational(96, 25.4),
+            'q' => Rational(96, 101.6),
+            'pt' => Rational(4, 3),
+            'px' => Rational(1)
+          },
+
+          # Rotation
+          'deg' => {
+            'deg' => Rational(1),
+            'grad' => Rational(9, 10),
+            'rad' => Rational(180, Math::PI),
+            'turn' => Rational(360)
+          },
+          'grad' => {
+            'deg' => Rational(10, 9),
+            'grad' => Rational(1),
+            'rad' => Rational(200, Math::PI),
+            'turn' => Rational(400)
+          },
+          'rad' => {
+            'deg' => Rational(Math::PI, 180),
+            'grad' => Rational(Math::PI, 200),
+            'rad' => Rational(1),
+            'turn' => Rational(2 * Math::PI)
+          },
+          'turn' => {
+            'deg' => Rational(1, 360),
+            'grad' => Rational(1, 400),
+            'rad' => Rational(1, 2 * Math::PI),
+            'turn' => Rational(1)
+          },
+
+          # Time
+          's' => {
+            's' => Rational(1),
+            'ms' => Rational(1, 1000)
+          },
+          'ms' => {
+            's' => Rational(1000),
+            'ms' => Rational(1)
+          },
+
+          # Frequency
+          'Hz' => {
+            'Hz' => Rational(1),
+            'kHz' => Rational(1000)
+          },
+          'kHz' => {
+            'Hz' => Rational(1, 1000),
+            'kHz' => Rational(1)
+          },
+
+          # Pixel density
+          'dpi' => {
+            'dpi' => Rational(1),
+            'dpcm' => Rational(2.54),
+            'dppx' => Rational(96)
+          },
+          'dpcm' => {
+            'dpi' => Rational(1, 2.54),
+            'dpcm' => Rational(1),
+            'dppx' => Rational(96, 2.54)
+          },
+          'dppx' => {
+            'dpi' => Rational(1, 96),
+            'dpcm' => Rational(2.54, 96),
+            'dppx' => Rational(1)
+          }
+        }.freeze
+
+        UNITS_BY_TYPE = {
+          time: %w[s ms],
+          frequency: %w[Hz kHz],
+          'pixel density': %w[dpi dpcm dppx]
+        }.freeze
+
+        TYPES_BY_UNIT = UNITS_BY_TYPE.invert
+                                     .to_a
+                                     .flat_map { |pair| pair[0].map { |key| [key, pair[1]] } }
+                                     .to_h
+
+        module_function
+
+        def conversion_factor(unit1, unit2)
+          return 1 if unit1 == unit2
+
+          CONVERSIONS.dig(unit1, unit2)
+        end
+
+        def canonicalize_units(units)
+          return units if units.empty?
+
+          if units.length == 1
+            type = TYPES_BY_UNIT[units.first]
+            return type.nil? ? units : [UNITS_BY_TYPE[type].first]
+          end
+
+          units.map do |unit|
+            type = TYPES_BY_UNIT[unit]
+            type.nil? ? units : [UNITS_BY_TYPE[type].first]
+          end.sort
+        end
+
+        def canonical_multiplier(units)
+          units.reduce(1) do |multiplier, unit|
+            multiplier * canonical_multiplier_for_unit(unit)
+          end
+        end
+
+        def canonical_multiplier_for_unit(unit)
+          inner_map = CONVERSIONS[unit]
+          inner_map.nil? ? 1 : 1 / inner_map.values.first
+        end
+      end
+
+      private_constant :Unit
+    end
+  end
+end