sass-embedded 1.79.3-aarch64-linux-gnu → 1.79.4-aarch64-linux-gnu

data/lib/sass/value/color/interpolation_method.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/interpolation_method.dart
+      class InterpolationMethod
+        # @return [Space]
+        attr_reader :space
+
+        # @return [Symbol, nil]
+        attr_reader :hue
+
+        # @param space [Space]
+        # @param hue [Symbol]
+        def initialize(space, hue = nil)
+          @space = space
+          @hue = if space.polar?
+                   hue.nil? ? :shorter : hue
+                 end
+
+          return unless !space.polar? && !hue.nil?
+
+          raise Sass::ScriptError,
+                "Hue interpolation method may not be set for rectangular color space #{space.name}."
+        end
+      end
+
+      private_constant :InterpolationMethod
+
+      # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/interpolation_method.dart
+      module HueInterpolationMethod
+        class << self
+          # @param name [::String]
+          # @param argument_name [::String]
+          # @return [Symbol]
+          def from_name(name, argument_name = nil)
+            case name
+            when 'decreasing', 'increasing', 'longer', 'shorter'
+              name.to_sym
+            else
+              raise Sass::ScriptError.new("Unknown hue interpolation method \"#{name}\".", argument_name)
+            end
+          end
+        end
+      end
+
+      private_constant :HueInterpolationMethod
+    end
+  end
+end

data/lib/sass/value/color/space/a98_rgb.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/a98_rgb.dart
+        class A98Rgb
+          include Space
+
+          def bounded?
+            true
+          end
+
+          def initialize
+            super('a98-rgb', Utils::RGB_CHANNELS)
+          end
+
+          def to_linear(channel)
+            FuzzyMath.sign(channel) * (channel.abs**(563 / 256.0))
+          end
+
+          def from_linear(channel)
+            FuzzyMath.sign(channel) * (channel.abs**(256 / 563.0))
+          end
+
+          private
+
+          def transformation_matrix(dest)
+            case dest
+            when DISPLAY_P3
+              Conversions::LINEAR_A98_RGB_TO_LINEAR_DISPLAY_P3
+            when LMS
+              Conversions::LINEAR_A98_RGB_TO_LMS
+            when PROPHOTO_RGB
+              Conversions::LINEAR_A98_RGB_TO_LINEAR_PROPHOTO_RGB
+            when REC2020
+              Conversions::LINEAR_A98_RGB_TO_LINEAR_REC2020
+            when RGB, SRGB, SRGB_LINEAR
+              Conversions::LINEAR_A98_RGB_TO_LINEAR_SRGB
+            when XYZ_D50
+              Conversions::LINEAR_A98_RGB_TO_XYZ_D50
+            when XYZ_D65
+              Conversions::LINEAR_A98_RGB_TO_XYZ_D65
+            else
+              super
+            end
+          end
+        end
+
+        private_constant :A98Rgb
+
+        A98_RGB = A98Rgb.new
+      end
+    end
+  end
+end

data/lib/sass/value/color/space/display_p3.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/display_p3.dart
+        class DisplayP3
+          include Space
+
+          def bounded?
+            true
+          end
+
+          def initialize
+            super('display-p3', Utils::RGB_CHANNELS)
+          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_DISPLAY_P3_TO_LINEAR_A98_RGB
+            when LMS
+              Conversions::LINEAR_DISPLAY_P3_TO_LMS
+            when PROPHOTO_RGB
+              Conversions::LINEAR_DISPLAY_P3_TO_LINEAR_PROPHOTO_RGB
+            when REC2020
+              Conversions::LINEAR_DISPLAY_P3_TO_LINEAR_REC2020
+            when RGB, SRGB, SRGB_LINEAR
+              Conversions::LINEAR_DISPLAY_P3_TO_LINEAR_SRGB
+            when XYZ_D50
+              Conversions::LINEAR_DISPLAY_P3_TO_XYZ_D50
+            when XYZ_D65
+              Conversions::LINEAR_DISPLAY_P3_TO_XYZ_D65
+            else
+              super
+            end
+          end
+        end
+
+        private_constant :DisplayP3
+
+        DISPLAY_P3 = DisplayP3.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# 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/hsl.dart
+        class Hsl
+          include Space
+
+          def bounded?
+            true
+          end
+
+          def legacy?
+            true
+          end
+
+          def polar?
+            true
+          end
+
+          def initialize
+            super('hsl', [
+              Utils::HUE_CHANNEL,
+              LinearChannel.new('saturation', 0, 100, requires_percent: true, lower_clamped: true).freeze,
+              LinearChannel.new('lightness', 0, 100, requires_percent: true).freeze
+            ].freeze)
+          end
+
+          def convert(dest, hue, saturation, lightness, alpha)
+            missing_lightness = lightness.nil?
+            missing_chroma = saturation.nil?
+            missing_hue = hue.nil?
+
+            hue = ((hue.nil? ? 0 : hue) % 360) / 30.0
+            saturation = (saturation.nil? ? 0 : saturation) / 100.0
+            lightness = (lightness.nil? ? 0 : lightness) / 100.0
+
+            a = saturation * [lightness, 1 - lightness].min
+            f = lambda do |n|
+              k = (n + hue) % 12
+              lightness - (a * [-1, [k - 3, 9 - k, 1].min].max)
+            end
+
+            SRGB.convert(
+              dest,
+              f.call(0),
+              f.call(8),
+              f.call(4),
+              alpha,
+              missing_lightness:,
+              missing_chroma:,
+              missing_hue:
+            )
+          end
+        end
+
+        private_constant :Hsl
+
+        HSL = Hsl.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# 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/hwb.dart
+        class Hwb
+          include Space
+
+          def bounded?
+            true
+          end
+
+          def legacy?
+            true
+          end
+
+          def polar?
+            true
+          end
+
+          def initialize
+            super('hwb', [
+              Utils::HUE_CHANNEL,
+              LinearChannel.new('whiteness', 0, 100, requires_percent: true).freeze,
+              LinearChannel.new('blackness', 0, 100, requires_percent: true).freeze
+            ].freeze)
+          end
+
+          def convert(dest, hue, whiteness, blackness, alpha)
+            missing_hue = hue.nil?
+
+            hue = ((hue.nil? ? 0 : hue) % 360) / 30.0
+            whiteness = (whiteness.nil? ? 0 : whiteness) / 100.0
+            blackness = (blackness.nil? ? 0 : blackness) / 100.0
+
+            sum = whiteness + blackness
+            if sum > 1
+              gray = whiteness / sum
+              SRGB.convert(dest,
+                           gray,
+                           gray,
+                           gray,
+                           alpha,
+                           missing_hue:)
+            else
+              f = lambda do |n|
+                k = (n + hue) % 12
+                0.5 - ([-1, [k - 3, 9 - k, 1].min].max / 2.0)
+              end
+
+              factor = 1 - sum
+              SRGB.convert(dest,
+                           (f.call(0) * factor) + whiteness,
+                           (f.call(8) * factor) + whiteness,
+                           (f.call(4) * factor) + whiteness,
+                           alpha,
+                           missing_hue:)
+            end
+          end
+        end
+
+        private_constant :Hwb
+
+        HWB = Hwb.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# 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/lab.dart
+        class Lab
+          include Space
+
+          def bounded?
+            false
+          end
+
+          def initialize
+            super('lab', [
+              LinearChannel.new('lightness', 0, 100, lower_clamped: true, upper_clamped: true).freeze,
+              LinearChannel.new('a', -125, 125).freeze,
+              LinearChannel.new('b', -125, 125).freeze
+            ].freeze)
+          end
+
+          def convert(dest, lightness, a, b, alpha, # rubocop:disable Naming/MethodParameterName
+                      missing_chroma: false, missing_hue: false)
+            case dest
+            when LAB
+              powerless_ab = lightness.nil? || FuzzyMath.equals(lightness, 0)
+              Color.send(
+                :_for_space,
+                dest,
+                lightness,
+                a.nil? || powerless_ab ? nil : a,
+                b.nil? || powerless_ab ? nil : b,
+                alpha
+              )
+            when LCH
+              Utils.lab_to_lch(dest, lightness, a, b, alpha)
+            else
+              missing_lightness = lightness.nil?
+              lightness = 0 if missing_lightness
+
+              f1 = (lightness + 16) / 116.0
+
+              XYZ_D50.convert(
+                dest,
+                _convert_f_to_x_or_z(((a.nil? ? 0 : a) / 500.0) + f1) * Conversions::D50[0],
+                (if lightness > Utils::LAB_KAPPA * Utils::LAB_EPSILON
+                   (((lightness + 16) / 116.0)**3)
+                 else
+                   lightness / Utils::LAB_KAPPA
+                 end) * Conversions::D50[1],
+                _convert_f_to_x_or_z(f1 - ((b.nil? ? 0 : b) / 200.0)) * Conversions::D50[2],
+                alpha,
+                missing_lightness:,
+                missing_chroma:,
+                missing_hue:,
+                missing_a: a.nil?,
+                missing_b: b.nil?
+              )
+            end
+          end
+
+          private
+
+          def _convert_f_to_x_or_z(component)
+            cubed = component**3
+            cubed > Utils::LAB_EPSILON ? cubed : ((116 * component) - 16) / Utils::LAB_KAPPA
+          end
+        end
+
+        private_constant :Lab
+
+        LAB = Lab.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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/lch.dart
+        class Lch
+          include Space
+
+          def bounded?
+            false
+          end
+
+          def polar?
+            true
+          end
+
+          def initialize
+            super('lch', [
+              LinearChannel.new('lightness', 0, 100, lower_clamped: true, upper_clamped: true).freeze,
+              LinearChannel.new('chroma', 0, 150, lower_clamped: true).freeze,
+              Utils::HUE_CHANNEL
+            ].freeze)
+          end
+
+          def convert(dest, lightness, chroma, hue, alpha)
+            missing_chroma = chroma.nil?
+            missing_hue = hue.nil?
+
+            chroma = 0 if missing_chroma
+            hue = 0 if missing_hue
+
+            hue_radians = hue * Math::PI / 180
+            LAB.convert(
+              dest,
+              lightness,
+              chroma * Math.cos(hue_radians),
+              chroma * Math.sin(hue_radians),
+              alpha,
+              missing_chroma:,
+              missing_hue:
+            )
+          end
+        end
+
+        private_constant :Lch
+
+        LCH = Lch.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# 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/lms.dart
+        class Lms
+          include Space
+
+          def bounded?
+            false
+          end
+
+          def initialize
+            super('lms', [
+              LinearChannel.new('long', 0, 1).freeze,
+              LinearChannel.new('medium', 0, 1).freeze,
+              LinearChannel.new('short', 0, 1).freeze
+            ].freeze)
+          end
+
+          def convert(dest, long, medium, short, alpha,
+                      missing_lightness: false,
+                      missing_chroma: false,
+                      missing_hue: false,
+                      missing_a: false,
+                      missing_b: false)
+            case dest
+            when OKLAB
+              long_scaled = Math.cbrt(long.nil? ? 0 : long)
+              medium_scaled = Math.cbrt(medium.nil? ? 0 : medium)
+              short_scaled = Math.cbrt(short.nil? ? 0 : short)
+
+              Color.send(
+                :_for_space,
+                dest,
+                unless missing_lightness
+                  (Conversions::LMS_TO_OKLAB[0] * long_scaled) +
+                    (Conversions::LMS_TO_OKLAB[1] * medium_scaled) +
+                    (Conversions::LMS_TO_OKLAB[2] * short_scaled)
+                end,
+                unless missing_a
+                  (Conversions::LMS_TO_OKLAB[3] * long_scaled) +
+                    (Conversions::LMS_TO_OKLAB[4] * medium_scaled) +
+                    (Conversions::LMS_TO_OKLAB[5] * short_scaled)
+                end,
+                unless missing_b
+                  (Conversions::LMS_TO_OKLAB[6] * long_scaled) +
+                    (Conversions::LMS_TO_OKLAB[7] * medium_scaled) +
+                    (Conversions::LMS_TO_OKLAB[8] * short_scaled)
+                end,
+                alpha
+              )
+            when OKLCH
+              long_scaled = Math.cbrt(long.nil? ? 0 : long)
+              medium_scaled = Math.cbrt(medium.nil? ? 0 : medium)
+              short_scaled = Math.cbrt(short.nil? ? 0 : short)
+
+              Utils.lab_to_lch(
+                dest,
+                unless missing_lightness
+                  (Conversions::LMS_TO_OKLAB[0] * long_scaled) +
+                    (Conversions::LMS_TO_OKLAB[1] * medium_scaled) +
+                    (Conversions::LMS_TO_OKLAB[2] * short_scaled)
+                end,
+                unless missing_a
+                  (Conversions::LMS_TO_OKLAB[3] * long_scaled) +
+                    (Conversions::LMS_TO_OKLAB[4] * medium_scaled) +
+                    (Conversions::LMS_TO_OKLAB[5] * short_scaled)
+                end,
+                unless missing_b
+                  (Conversions::LMS_TO_OKLAB[6] * long_scaled) +
+                    (Conversions::LMS_TO_OKLAB[7] * medium_scaled) +
+                    (Conversions::LMS_TO_OKLAB[8] * short_scaled)
+                end,
+                alpha
+              )
+            else
+              convert_linear(dest, long, medium, short, 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 transformation_matrix(dest)
+            case dest
+            when A98_RGB
+              Conversions::LMS_TO_LINEAR_A98_RGB
+            when DISPLAY_P3
+              Conversions::LMS_TO_LINEAR_DISPLAY_P3
+            when PROPHOTO_RGB
+              Conversions::LMS_TO_LINEAR_PROPHOTO_RGB
+            when REC2020
+              Conversions::LMS_TO_LINEAR_REC2020
+            when RGB, SRGB, SRGB_LINEAR
+              Conversions::LMS_TO_LINEAR_SRGB
+            when XYZ_D50
+              Conversions::LMS_TO_XYZ_D50
+            when XYZ_D65
+              Conversions::LMS_TO_XYZ_D65
+            else
+              super
+            end
+          end
+        end
+
+        private_constant :Lms
+
+        LMS = Lms.new
+
+        private_constant :LMS
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# 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/oklab.dart
+        class Oklab
+          include Space
+
+          def bounded?
+            false
+          end
+
+          def initialize
+            super('oklab', [
+              LinearChannel.new('lightness', 0, 1,
+                                conventionally_percent: true, lower_clamped: true, upper_clamped: true).freeze,
+              LinearChannel.new('a', -0.4, 0.4).freeze,
+              LinearChannel.new('b', -0.4, 0.4).freeze
+            ].freeze)
+          end
+
+          def convert(dest, lightness, a, b, alpha, # rubocop:disable Naming/MethodParameterName
+                      missing_chroma: false, missing_hue: false)
+            case dest
+            when OKLCH
+              Utils.lab_to_lch(dest, lightness, a, b, alpha)
+            else
+              missing_lightness = lightness.nil?
+              missing_a = a.nil?
+              missing_b = b.nil?
+
+              lightness = 0 if missing_lightness
+              a = 0 if missing_a
+              b = 0 if missing_b
+
+              LMS.convert(
+                dest,
+                ((Conversions::OKLAB_TO_LMS[0] * lightness) +
+                 (Conversions::OKLAB_TO_LMS[1] * a) +
+                 (Conversions::OKLAB_TO_LMS[2] * b))**3,
+                ((Conversions::OKLAB_TO_LMS[3] * lightness) +
+                 (Conversions::OKLAB_TO_LMS[4] * a) +
+                 (Conversions::OKLAB_TO_LMS[5] * b))**3,
+                ((Conversions::OKLAB_TO_LMS[6] * lightness) +
+                 (Conversions::OKLAB_TO_LMS[7] * a) +
+                 (Conversions::OKLAB_TO_LMS[8] * b))**3,
+                alpha,
+                missing_lightness:,
+                missing_chroma:,
+                missing_hue:,
+                missing_a:,
+                missing_b:
+              )
+            end
+          end
+        end
+
+        private_constant :Oklab
+
+        OKLAB = Oklab.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# 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/oklch.dart
+        class Oklch
+          include Space
+
+          def bounded?
+            false
+          end
+
+          def polar?
+            true
+          end
+
+          def initialize
+            super('oklch', [
+              LinearChannel.new('lightness', 0, 1,
+                                conventionally_percent: true, lower_clamped: true, upper_clamped: true).freeze,
+              LinearChannel.new('chroma', 0, 0.4, lower_clamped: true).freeze,
+              Utils::HUE_CHANNEL
+            ].freeze)
+          end
+
+          def convert(dest, lightness, chroma, hue, alpha)
+            missing_chroma = chroma.nil?
+            missing_hue = hue.nil?
+
+            chroma = 0 if missing_chroma
+            hue = 0 if missing_hue
+
+            hue_radians = hue * Math::PI / 180
+            OKLAB.convert(
+              dest,
+              lightness,
+              chroma * Math.cos(hue_radians),
+              chroma * Math.sin(hue_radians),
+              alpha,
+              missing_chroma:,
+              missing_hue:
+            )
+          end
+        end
+
+        private_constant :Oklch
+
+        OKLCH = Oklch.new
+      end
+    end
+  end
+end