sass-embedded 1.79.3-x86-mingw-ucrt → 1.79.4-x86-mingw-ucrt

data/lib/sass/value/color/space/prophoto_rgb.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      module Space
+        # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/space/prophoto_rgb.dart
+        class ProphotoRgb
+          include Space
+
+          def bounded?
+            true
+          end
+
+          def initialize
+            super('prophoto-rgb', Utils::RGB_CHANNELS)
+          end
+
+          def to_linear(channel)
+            abs = channel.abs
+            abs <= 16 / 512.0 ? channel / 16.0 : FuzzyMath.sign(channel) * (abs**1.8)
+          end
+
+          def from_linear(channel)
+            abs = channel.abs
+            abs >= 1 / 512.0 ? FuzzyMath.sign(channel) * (abs**(1 / 1.8)) : 16 * channel
+          end
+
+          private
+
+          def transformation_matrix(dest)
+            case dest
+            when A98_RGB
+              Conversions::LINEAR_PROPHOTO_RGB_TO_LINEAR_A98_RGB
+            when DISPLAY_P3
+              Conversions::LINEAR_PROPHOTO_RGB_TO_LINEAR_DISPLAY_P3
+            when LMS
+              Conversions::LINEAR_PROPHOTO_RGB_TO_LMS
+            when REC2020
+              Conversions::LINEAR_PROPHOTO_RGB_TO_LINEAR_REC2020
+            when RGB, SRGB, SRGB_LINEAR
+              Conversions::LINEAR_PROPHOTO_RGB_TO_LINEAR_SRGB
+            when XYZ_D50
+              Conversions::LINEAR_PROPHOTO_RGB_TO_XYZ_D50
+            when XYZ_D65
+              Conversions::LINEAR_PROPHOTO_RGB_TO_XYZ_D65
+            else
+              super
+            end
+          end
+        end
+
+        private_constant :ProphotoRgb
+
+        PROPHOTO_RGB = ProphotoRgb.new
+      end
+    end
+  end
+end

data/lib/sass/value/color/space/rec2020.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      module Space
+        # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/space/rec2020.dart
+        class Rec2020
+          include Space
+
+          # A constant used in the rec2020 gamma encoding/decoding functions.
+          ALPHA = 1.09929682680944
+
+          private_constant :ALPHA
+
+          # A constant used in the rec2020 gamma encoding/decoding functions.
+          BETA = 0.018053968510807
+
+          private_constant :BETA
+
+          def bounded?
+            true
+          end
+
+          def initialize
+            super('rec2020', Utils::RGB_CHANNELS)
+          end
+
+          def to_linear(channel)
+            abs = channel.abs
+            abs < BETA * 4.5 ? channel / 4.5 : FuzzyMath.sign(channel) * (((abs + ALPHA - 1) / ALPHA)**(1 / 0.45))
+          end
+
+          def from_linear(channel)
+            abs = channel.abs
+            abs > BETA ? FuzzyMath.sign(channel) * ((ALPHA * (abs**0.45)) - (ALPHA - 1)) : 4.5 * channel
+          end
+
+          private
+
+          def transformation_matrix(dest)
+            case dest
+            when A98_RGB
+              Conversions::LINEAR_REC2020_TO_LINEAR_A98_RGB
+            when DISPLAY_P3
+              Conversions::LINEAR_REC2020_TO_LINEAR_DISPLAY_P3
+            when LMS
+              Conversions::LINEAR_REC2020_TO_LMS
+            when PROPHOTO_RGB
+              Conversions::LINEAR_REC2020_TO_LINEAR_PROPHOTO_RGB
+            when RGB, SRGB, SRGB_LINEAR
+              Conversions::LINEAR_REC2020_TO_LINEAR_SRGB
+            when XYZ_D50
+              Conversions::LINEAR_REC2020_TO_XYZ_D50
+            when XYZ_D65
+              Conversions::LINEAR_REC2020_TO_XYZ_D65
+            else
+              super
+            end
+          end
+        end
+
+        private_constant :Rec2020
+
+        REC2020 = Rec2020.new
+      end
+    end
+  end
+end

data/lib/sass/value/color/space/rgb.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      module Space
+        # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/space/rgb.dart
+        class Rgb
+          include Space
+
+          def bounded?
+            true
+          end
+
+          def legacy?
+            true
+          end
+
+          def initialize
+            super('rgb', [
+              LinearChannel.new('red', 0, 255, lower_clamped: true, upper_clamped: true).freeze,
+              LinearChannel.new('green', 0, 255, lower_clamped: true, upper_clamped: true).freeze,
+              LinearChannel.new('blue', 0, 255, lower_clamped: true, upper_clamped: true).freeze
+            ].freeze)
+          end
+
+          def convert(dest, red, green, blue, alpha)
+            SRGB.convert(
+              dest,
+              red.nil? ? nil : red / 255.0,
+              green.nil? ? nil : green / 255.0,
+              blue.nil? ? nil : blue / 255.0,
+              alpha
+            )
+          end
+
+          def to_linear(channel)
+            Utils.srgb_and_display_p3_to_linear(channel / 255.0)
+          end
+
+          def from_linear(channel)
+            Utils.srgb_and_display_p3_from_linear(channel) * 255
+          end
+        end
+
+        private_constant :Rgb
+
+        RGB = Rgb.new
+      end
+    end
+  end
+end

data/lib/sass/value/color/space/srgb.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      module Space
+        # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/space/srgb.dart
+        class Srgb
+          include Space
+
+          def bounded?
+            true
+          end
+
+          def initialize
+            super('srgb', Utils::RGB_CHANNELS)
+          end
+
+          def convert(dest, red, green, blue, alpha,
+                      missing_lightness: false,
+                      missing_chroma: false,
+                      missing_hue: false)
+            case dest
+            when HSL, HWB
+              red = 0 if red.nil?
+              green = 0 if green.nil?
+              blue = 0 if blue.nil?
+
+              max = [red, green, blue].max
+              min = [red, green, blue].min
+              delta = max - min
+
+              hue = if max == min
+                      0.0
+                    elsif max == red
+                      (60.0 * (green - blue) / delta) + 360
+                    elsif max == green
+                      (60.0 * (blue - red) / delta) + 120
+                    else # max == blue
+                      (60.0 * (red - green) / delta) + 240
+                    end
+
+              if dest == HSL
+                lightness = (min + max) / 2.0
+
+                saturation = if [0, 1].include?(lightness)
+                               0.0
+                             else
+                               100.0 * (max - lightness) / [lightness, 1 - lightness].min
+                             end
+                if saturation.negative?
+                  hue += 180
+                  saturation = saturation.abs
+                end
+
+                Color.send(
+                  :for_space_internal,
+                  dest,
+                  missing_hue || FuzzyMath.equals(saturation, 0) ? nil : hue % 360,
+                  missing_chroma ? nil : saturation,
+                  missing_lightness ? nil : lightness * 100,
+                  alpha
+                )
+              else
+                whiteness = min * 100
+                blackness = 100 - (max * 100)
+
+                Color.send(
+                  :for_space_internal,
+                  dest,
+                  missing_hue || FuzzyMath.greater_than_or_equals(whiteness + blackness, 100) ? nil : hue % 360,
+                  whiteness,
+                  blackness,
+                  alpha
+                )
+              end
+            when RGB
+              Color.send(
+                :_for_space,
+                dest,
+                red.nil? ? nil : red * 255,
+                green.nil? ? nil : green * 255,
+                blue.nil? ? nil : blue * 255,
+                alpha
+              )
+            when SRGB_LINEAR
+              Color.send(
+                :_for_space,
+                dest,
+                red.nil? ? nil : to_linear(red),
+                green.nil? ? nil : to_linear(green),
+                blue.nil? ? nil : to_linear(blue),
+                alpha
+              )
+            else
+              convert_linear(dest, red, green, blue, alpha,
+                             missing_lightness:,
+                             missing_chroma:,
+                             missing_hue:)
+            end
+          end
+
+          def to_linear(channel)
+            Utils.srgb_and_display_p3_to_linear(channel)
+          end
+
+          def from_linear(channel)
+            Utils.srgb_and_display_p3_from_linear(channel)
+          end
+
+          private
+
+          def transformation_matrix(dest)
+            case dest
+            when A98_RGB
+              Conversions::LINEAR_SRGB_TO_LINEAR_A98_RGB
+            when DISPLAY_P3
+              Conversions::LINEAR_SRGB_TO_LINEAR_DISPLAY_P3
+            when LMS
+              Conversions::LINEAR_SRGB_TO_LMS
+            when PROPHOTO_RGB
+              Conversions::LINEAR_SRGB_TO_LINEAR_PROPHOTO_RGB
+            when REC2020
+              Conversions::LINEAR_SRGB_TO_LINEAR_REC2020
+            when XYZ_D50
+              Conversions::LINEAR_SRGB_TO_XYZ_D50
+            when XYZ_D65
+              Conversions::LINEAR_SRGB_TO_XYZ_D65
+            else
+              super
+            end
+          end
+        end
+
+        private_constant :Srgb
+
+        SRGB = Srgb.new
+      end
+    end
+  end
+end

data/lib/sass/value/color/space/srgb_linear.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      module Space
+        # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/space/srgb_linear.dart
+        class SrgbLinear
+          include Space
+
+          def bounded?
+            true
+          end
+
+          def initialize
+            super('srgb-linear', Utils::RGB_CHANNELS)
+          end
+
+          def convert(dest, red, green, blue, alpha)
+            case dest
+            when HSL, HWB, RGB, SRGB
+              SRGB.convert(
+                dest,
+                red.nil? ? nil : Utils.srgb_and_display_p3_from_linear(red),
+                green.nil? ? nil : Utils.srgb_and_display_p3_from_linear(green),
+                blue.nil? ? nil : Utils.srgb_and_display_p3_from_linear(blue),
+                alpha
+              )
+            else
+              super
+            end
+          end
+
+          def to_linear(channel)
+            channel
+          end
+
+          def from_linear(channel)
+            channel
+          end
+
+          private
+
+          def transformation_matrix(dest)
+            case dest
+            when A98_RGB
+              Conversions::LINEAR_SRGB_TO_LINEAR_A98_RGB
+            when DISPLAY_P3
+              Conversions::LINEAR_SRGB_TO_LINEAR_DISPLAY_P3
+            when PROPHOTO_RGB
+              Conversions::LINEAR_SRGB_TO_LINEAR_PROPHOTO_RGB
+            when REC2020
+              Conversions::LINEAR_SRGB_TO_LINEAR_REC2020
+            when XYZ_D65
+              Conversions::LINEAR_SRGB_TO_XYZ_D65
+            when XYZ_D50
+              Conversions::LINEAR_SRGB_TO_XYZ_D50
+            when LMS
+              Conversions::LINEAR_SRGB_TO_LMS
+            else
+              super
+            end
+          end
+        end
+
+        private_constant :SrgbLinear
+
+        SRGB_LINEAR = SrgbLinear.new
+      end
+    end
+  end
+end

data/lib/sass/value/color/space/utils.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      module Space
+        # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/space/utils.dart
+        module Utils
+          module_function
+
+          # A constant used to convert Lab to/from XYZ.
+          LAB_KAPPA = Rational(24_389, 27) # 29^3/3^3
+
+          # A constant used to convert Lab to/from XYZ.
+          LAB_EPSILON = Rational(216, 24_389) # 6^3/29^3
+
+          # The hue channel shared across all polar color spaces.
+          HUE_CHANNEL = ColorChannel.new('hue', polar_angle: true, associated_unit: 'deg').freeze
+
+          # The color channels shared across all RGB color spaces (except the legacy RGB space).
+          RGB_CHANNELS = [
+            LinearChannel.new('red', 0, 1).freeze,
+            LinearChannel.new('green', 0, 1).freeze,
+            LinearChannel.new('blue', 0, 1).freeze
+          ].freeze
+
+          # The color channels shared across both XYZ color spaces.
+          XYZ_CHANNELS = [
+            LinearChannel.new('x', 0, 1).freeze,
+            LinearChannel.new('y', 0, 1).freeze,
+            LinearChannel.new('z', 0, 1).freeze
+          ].freeze
+
+          # The algorithm for converting a single `srgb` or `display-p3` channel to
+          # linear-light form.
+          # @param [Numeric]
+          # @return [Numeric]
+          def srgb_and_display_p3_to_linear(channel)
+            abs = channel.abs
+            abs < 0.04045 ? channel / 12.92 : FuzzyMath.sign(channel) * (((abs + 0.055) / 1.055)**2.4)
+          end
+
+          # The algorithm for converting a single `srgb` or `display-p3` channel to
+          # gamma-corrected form.
+          # @param [Numeric]
+          # @return [Numeric]
+          def srgb_and_display_p3_from_linear(channel)
+            abs = channel.abs
+            abs <= 0.0031308 ? channel * 12.92 : FuzzyMath.sign(channel) * ((1.055 * (abs**(1 / 2.4))) - 0.055)
+          end
+
+          # Converts a Lab or OKLab color to LCH or OKLCH, respectively.
+          #
+          # The [missing_chroma] and [missing_hue] arguments indicate whether this came
+          # from a color that was missing its chroma or hue channels, respectively.
+          # @param dest [Space]
+          # @param lightness [Numeric]
+          # @param a [Numeric]
+          # @param b [Numeric]
+          # @param alpha [Numeric]
+          # @return [Color]
+          def lab_to_lch(dest, lightness, a, b, alpha, # rubocop:disable Naming/MethodParameterName
+                         missing_chroma: false, missing_hue: false)
+            chroma = Math.sqrt(((a.nil? ? 0 : a)**2) + ((b.nil? ? 0 : b)**2))
+            hue = if missing_hue || FuzzyMath.equals(chroma, 0)
+                    nil
+                  else
+                    Math.atan2(b.nil? ? 0 : b, a.nil? ? 0 : a) * 180 / Math::PI
+                  end
+
+            Color.send(
+              :for_space_internal,
+              dest,
+              lightness,
+              missing_chroma ? nil : chroma,
+              hue.nil? || hue >= 0 ? hue : hue + 360,
+              alpha
+            )
+          end
+        end
+
+        private_constant :Utils
+      end
+    end
+  end
+end

data/lib/sass/value/color/space/xyz_d50.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      module Space
+        # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/space/xyz_d50.dart
+        class XyzD50
+          include Space
+
+          def bounded?
+            false
+          end
+
+          def initialize
+            super('xyz-d50', Utils::XYZ_CHANNELS)
+          end
+
+          def convert(dest, x, y, z, alpha, # rubocop:disable Naming/MethodParameterName
+                      missing_lightness: false,
+                      missing_chroma: false,
+                      missing_hue: false,
+                      missing_a: false,
+                      missing_b: false)
+            case dest
+            when LAB, LCH
+              f0 = _convert_component_to_lab_f((x.nil? ? 0 : x) / Conversions::D50[0])
+              f1 = _convert_component_to_lab_f((y.nil? ? 0 : y) / Conversions::D50[1])
+              f2 = _convert_component_to_lab_f((z.nil? ? 0 : z) / Conversions::D50[2])
+              lightness = missing_lightness ? nil : (116 * f1) - 16
+              a = 500 * (f0 - f1)
+              b = 200 * (f1 - f2)
+
+              if dest == LAB
+                Color.send(:_for_space,
+                           dest,
+                           lightness,
+                           missing_a ? nil : a,
+                           missing_b ? nil : b,
+                           alpha)
+              else
+                Utils.lab_to_lch(dest, lightness, a, b, alpha, missing_chroma:, missing_hue:)
+              end
+            else
+              convert_linear(dest, x, y, z, alpha,
+                             missing_lightness:,
+                             missing_chroma:,
+                             missing_hue:,
+                             missing_a:,
+                             missing_b:)
+            end
+          end
+
+          def to_linear(channel)
+            channel
+          end
+
+          def from_linear(channel)
+            channel
+          end
+
+          private
+
+          def _convert_component_to_lab_f(component)
+            if component > Utils::LAB_EPSILON
+              Math.cbrt(component)
+            else
+              ((Utils::LAB_KAPPA * component) + 16) / 116.0
+            end
+          end
+
+          def transformation_matrix(dest)
+            case dest
+            when A98_RGB
+              Conversions::XYZ_D50_TO_LINEAR_A98_RGB
+            when DISPLAY_P3
+              Conversions::XYZ_D50_TO_LINEAR_DISPLAY_P3
+            when LMS
+              Conversions::XYZ_D50_TO_LMS
+            when PROPHOTO_RGB
+              Conversions::XYZ_D50_TO_LINEAR_PROPHOTO_RGB
+            when REC2020
+              Conversions::XYZ_D50_TO_LINEAR_REC2020
+            when RGB, SRGB, SRGB_LINEAR
+              Conversions::XYZ_D50_TO_LINEAR_SRGB
+            when XYZ_D65
+              Conversions::XYZ_D50_TO_XYZ_D65
+            else
+              super
+            end
+          end
+        end
+
+        private_constant :XyzD50
+
+        XYZ_D50 = XyzD50.new
+      end
+    end
+  end
+end

data/lib/sass/value/color/space/xyz_d65.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      module Space
+        # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/space/xyz_d65.dart
+        class XyzD65
+          include Space
+
+          def bounded?
+            false
+          end
+
+          def initialize
+            super('xyz', Utils::XYZ_CHANNELS)
+          end
+
+          def to_linear(channel)
+            channel
+          end
+
+          def from_linear(channel)
+            channel
+          end
+
+          private
+
+          def transformation_matrix(dest)
+            case dest
+            when A98_RGB
+              Conversions::XYZ_D65_TO_LINEAR_A98_RGB
+            when DISPLAY_P3
+              Conversions::XYZ_D65_TO_LINEAR_DISPLAY_P3
+            when LMS
+              Conversions::XYZ_D65_TO_LMS
+            when PROPHOTO_RGB
+              Conversions::XYZ_D65_TO_LINEAR_PROPHOTO_RGB
+            when REC2020
+              Conversions::XYZ_D65_TO_LINEAR_REC2020
+            when RGB, SRGB, SRGB_LINEAR
+              Conversions::XYZ_D65_TO_LINEAR_SRGB
+            when XYZ_D50
+              Conversions::XYZ_D65_TO_XYZ_D50
+            else
+              super
+            end
+          end
+        end
+
+        private_constant :XyzD65
+
+        XYZ_D65 = XyzD65.new
+      end
+    end
+  end
+end