sass-embedded 1.74.1-x64-mswin64

data/lib/sass/value/boolean.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's boolean type.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/sassboolean/
+    class Boolean
+      include Value
+
+      # @param value [::Boolean]
+      def initialize(value)
+        @value = value
+      end
+
+      # @return [::Boolean]
+      attr_reader :value
+
+      # @return [Boolean]
+      def !
+        value ? Boolean::FALSE : Boolean::TRUE
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::Value::Boolean) && other.value == value
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= value.hash
+      end
+
+      alias to_bool value
+
+      # @return [Boolean]
+      def assert_boolean(_name = nil)
+        self
+      end
+
+      # Sass's true value.
+      TRUE = Boolean.new(true)
+
+      # Sass's false value.
+      FALSE = Boolean.new(false)
+
+      def self.new(value)
+        value ? Boolean::TRUE : Boolean::FALSE
+      end
+    end
+  end
+end

data/lib/sass/value/calculation.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's calculation type.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/sasscalculation/
+    class Calculation
+      include Value
+      include CalculationValue
+
+      class << self
+        private :new
+
+        # @param argument [CalculationValue]
+        # @return [Calculation]
+        def calc(argument)
+          new('calc', [argument])
+        end
+
+        # @param arguments [Array<CalculationValue>]
+        # @return [Calculation]
+        def min(arguments)
+          new('min', arguments)
+        end
+
+        # @param arguments [Array<CalculationValue>]
+        # @return [Calculation]
+        def max(arguments)
+          new('max', arguments)
+        end
+
+        # @param min [CalculationValue]
+        # @param value [CalculationValue]
+        # @param max [CalculationValue]
+        # @return [Calculation]
+        def clamp(min, value = nil, max = nil)
+          if (value.nil? && !valid_clamp_arg?(min)) ||
+             (max.nil? && [min, value].none? { |x| x && valid_clamp_arg?(x) })
+            raise Sass::ScriptError, 'Argument must be an unquoted SassString.'
+          end
+
+          new('clamp', [min, value, max].compact)
+        end
+
+        private
+
+        def valid_clamp_arg?(value)
+          value.is_a?(Sass::Value::String) && !value.quoted?
+        end
+      end
+
+      private
+
+      def initialize(name, arguments)
+        arguments.each do |value|
+          assert_calculation_value(value)
+        end
+
+        @name = name.freeze
+        @arguments = arguments.freeze
+      end
+
+      public
+
+      # @return [::String]
+      attr_reader :name
+
+      # @return [Array<CalculationValue>]
+      attr_reader :arguments
+
+      # @return [Calculation]
+      def assert_calculation(_name = nil)
+        self
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::Value::Calculation) &&
+          other.name == name &&
+          other.arguments == arguments
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= [name, *arguments].hash
+      end
+    end
+  end
+end

data/lib/sass/value/color.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's color type.
+    #
+    # No matter what representation was originally used to create this color, all of its channels are accessible.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/sasscolor/
+    class Color
+      include Value
+
+      # @param red [Numeric]
+      # @param green [Numeric]
+      # @param blue [Numeric]
+      # @param hue [Numeric]
+      # @param saturation [Numeric]
+      # @param lightness [Numeric]
+      # @param whiteness [Numeric]
+      # @param blackness [Numeric]
+      # @param alpha [Numeric]
+      def initialize(red: nil,
+                     green: nil,
+                     blue: nil,
+                     hue: nil,
+                     saturation: nil,
+                     lightness: nil,
+                     whiteness: nil,
+                     blackness: nil,
+                     alpha: 1)
+        @alpha = alpha.nil? ? 1 : FuzzyMath.assert_between(alpha, 0, 1, 'alpha')
+        if red && green && blue
+          @red = FuzzyMath.assert_between(FuzzyMath.round(red), 0, 255, 'red')
+          @green = FuzzyMath.assert_between(FuzzyMath.round(green), 0, 255, 'green')
+          @blue = FuzzyMath.assert_between(FuzzyMath.round(blue), 0, 255, 'blue')
+        elsif hue && saturation && lightness
+          @hue = hue % 360
+          @saturation = FuzzyMath.assert_between(saturation, 0, 100, 'saturation')
+          @lightness = FuzzyMath.assert_between(lightness, 0, 100, 'lightness')
+        elsif hue && whiteness && blackness
+          @hue = hue % 360
+          @whiteness = FuzzyMath.assert_between(whiteness, 0, 100, 'whiteness')
+          @blackness = FuzzyMath.assert_between(blackness, 0, 100, 'blackness')
+          hwb_to_rgb
+          @whiteness = @blackness = nil
+        else
+          raise Sass::ScriptError, 'Invalid Color'
+        end
+      end
+
+      # @return [Integer]
+      def red
+        hsl_to_rgb unless defined?(@red)
+
+        @red
+      end
+
+      # @return [Integer]
+      def green
+        hsl_to_rgb unless defined?(@green)
+
+        @green
+      end
+
+      # @return [Integer]
+      def blue
+        hsl_to_rgb unless defined?(@blue)
+
+        @blue
+      end
+
+      # @return [Numeric]
+      def hue
+        rgb_to_hsl unless defined?(@hue)
+
+        @hue
+      end
+
+      # @return [Numeric]
+      def saturation
+        rgb_to_hsl unless defined?(@saturation)
+
+        @saturation
+      end
+
+      # @return [Numeric]
+      def lightness
+        rgb_to_hsl unless defined?(@lightness)
+
+        @lightness
+      end
+
+      # @return [Numeric]
+      def whiteness
+        @whiteness ||= Rational([red, green, blue].min, 255) * 100
+      end
+
+      # @return [Numeric]
+      def blackness
+        @blackness ||= 100 - (Rational([red, green, blue].max, 255) * 100)
+      end
+
+      # @return [Numeric]
+      attr_reader :alpha
+
+      # @param red [Numeric]
+      # @param green [Numeric]
+      # @param blue [Numeric]
+      # @param hue [Numeric]
+      # @param saturation [Numeric]
+      # @param lightness [Numeric]
+      # @param whiteness [Numeric]
+      # @param blackness [Numeric]
+      # @param alpha [Numeric]
+      # @return [Color]
+      def change(red: nil,
+                 green: nil,
+                 blue: nil,
+                 hue: nil,
+                 saturation: nil,
+                 lightness: nil,
+                 whiteness: nil,
+                 blackness: nil,
+                 alpha: nil)
+        if whiteness || blackness
+          Sass::Value::Color.new(hue: hue || self.hue,
+                                 whiteness: whiteness || self.whiteness,
+                                 blackness: blackness || self.blackness,
+                                 alpha: alpha || self.alpha)
+        elsif hue || saturation || lightness
+          Sass::Value::Color.new(hue: hue || self.hue,
+                                 saturation: saturation || self.saturation,
+                                 lightness: lightness || self.lightness,
+                                 alpha: alpha || self.alpha)
+        elsif red || green || blue
+          Sass::Value::Color.new(red: red ? FuzzyMath.round(red) : self.red,
+                                 green: green ? FuzzyMath.round(green) : self.green,
+                                 blue: blue ? FuzzyMath.round(blue) : self.blue,
+                                 alpha: alpha || self.alpha)
+        else
+          dup.instance_eval do
+            @alpha = FuzzyMath.assert_between(alpha, 0, 1, 'alpha')
+            self
+          end
+        end
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::Value::Color) &&
+          other.red == red &&
+          other.green == green &&
+          other.blue == blue &&
+          other.alpha == alpha
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= [red, green, blue, alpha].hash
+      end
+
+      # @return [Color]
+      def assert_color(_name = nil)
+        self
+      end
+
+      private
+
+      def rgb_to_hsl
+        scaled_red = Rational(red, 255)
+        scaled_green = Rational(green, 255)
+        scaled_blue = Rational(blue, 255)
+
+        max = [scaled_red, scaled_green, scaled_blue].max
+        min = [scaled_red, scaled_green, scaled_blue].min
+        delta = max - min
+
+        if max == min
+          @hue = 0
+        elsif max == scaled_red
+          @hue = ((scaled_green - scaled_blue) * 60 / delta) % 360
+        elsif max == scaled_green
+          @hue = (((scaled_blue - scaled_red) * 60 / delta) + 120) % 360
+        elsif max == scaled_blue
+          @hue = (((scaled_red - scaled_green) * 60 / delta) + 240) % 360
+        end
+
+        lightness = @lightness = (max + min) * 50
+
+        @saturation = if max == min
+                        0
+                      elsif lightness < 50
+                        delta * 100 / (max + min)
+                      else
+                        delta * 100 / (2 - max - min)
+                      end
+      end
+
+      def hsl_to_rgb
+        scaled_hue = Rational(hue, 360)
+        scaled_saturation = Rational(saturation, 100)
+        scaled_lightness = Rational(lightness, 100)
+
+        tmp2 = if scaled_lightness <= 0.5
+                 scaled_lightness * (scaled_saturation + 1)
+               else
+                 scaled_lightness + scaled_saturation - (scaled_lightness * scaled_saturation)
+               end
+        tmp1 = (scaled_lightness * 2) - tmp2
+        @red = FuzzyMath.round(hsl_hue_to_rgb(tmp1, tmp2, scaled_hue + Rational(1, 3)) * 255)
+        @green = FuzzyMath.round(hsl_hue_to_rgb(tmp1, tmp2, scaled_hue) * 255)
+        @blue = FuzzyMath.round(hsl_hue_to_rgb(tmp1, tmp2, scaled_hue - Rational(1, 3)) * 255)
+      end
+
+      def hsl_hue_to_rgb(tmp1, tmp2, hue)
+        hue += 1 if hue.negative?
+        hue -= 1 if hue > 1
+
+        if hue < Rational(1, 6)
+          tmp1 + ((tmp2 - tmp1) * hue * 6)
+        elsif hue < Rational(1, 2)
+          tmp2
+        elsif hue < Rational(2, 3)
+          tmp1 + ((tmp2 - tmp1) * (Rational(2, 3) - hue) * 6)
+        else
+          tmp1
+        end
+      end
+
+      def hwb_to_rgb
+        scaled_hue = Rational(hue, 360)
+        scaled_whiteness = Rational(whiteness, 100)
+        scaled_blackness = Rational(blackness, 100)
+
+        sum = scaled_whiteness + scaled_blackness
+        if sum > 1
+          scaled_whiteness /= sum
+          scaled_blackness /= sum
+        end
+
+        factor = 1 - scaled_whiteness - scaled_blackness
+        @red = hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue + Rational(1, 3))
+        @green = hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue)
+        @blue = hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue - Rational(1, 3))
+      end
+
+      def hwb_hue_to_rgb(factor, scaled_whiteness, scaled_hue)
+        channel = (hsl_hue_to_rgb(0, 1, scaled_hue) * factor) + scaled_whiteness
+        FuzzyMath.round(channel * 255)
+      end
+    end
+  end
+end

data/lib/sass/value/function.rb

@@ -0,0 +1,51 @@
+# 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
+
+      # @param signature [::String]
+      # @param callback [Proc]
+      def initialize(signature, &callback)
+        raise Sass::ScriptError, 'no block given' unless signature.nil? || callback
+
+        @signature = signature.freeze
+        @callback = callback.freeze
+      end
+
+      # @return [Integer, nil]
+      attr_reader :id
+
+      protected :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
+        @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,80 @@
+# 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?
+
+        raise Sass::ScriptError.new("#{number} must be between #{min} and #{max}.", name)
+      end
+
+      def hash(number)
+        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 Sass::ScriptError, 'A list with more than one element must have an explicit separator'
+        end
+
+        @contents = contents.freeze
+        @separator = separator.freeze
+        @bracketed = bracketed.freeze
+      end
+
+      # @return [::String, nil]
+      attr_reader :separator
+
+      # @return [::Boolean]
+      def bracketed?
+        @bracketed
+      end
+
+      # @return [::Boolean]
+      def ==(other)
+        (other.is_a?(Sass::Value::List) &&
+         other.to_a == to_a &&
+         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
+
+      # @return [Array<Value>]
+      def to_a
+        @contents
+      end
+
+      # @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
+
+          Sass::Value::List.new(contents.to_a[index], separator: ' ')
+        else
+          contents[index]
+        end
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= contents.hash
+      end
+
+      # @return [Array<List<(Value, Value)>>]
+      def to_a
+        contents.map { |key, value| Sass::Value::List.new([key, value], 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/mixin.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    # Sass's mixin type.
+    #
+    # @see https://sass-lang.com/documentation/js-api/classes/sassmixin/
+    class Mixin
+      include Value
+
+      class << self
+        private :new
+      end
+
+      # @return [Integer]
+      attr_reader :id
+
+      protected :id
+
+      # @return [::Boolean]
+      def ==(other)
+        other.is_a?(Sass::Value::Mixin) && other.id == id
+      end
+
+      # @return [Integer]
+      def hash
+        @hash ||= id.hash
+      end
+
+      # @return [Mixin]
+      def assert_mixin(_name = nil)
+        self
+      end
+    end
+  end
+end