sass-embedded 1.6.2 → 1.83.1

data/lib/sass/value/color/gamut_map_method/local_minde.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      module GamutMapMethod
+        # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/gamut_map_method/local_minde.dart
+        class LocalMinde
+          include GamutMapMethod
+
+          # A constant from the gamut-mapping algorithm.
+          JND = 0.02
+
+          private_constant :JND
+
+          # A constant from the gamut-mapping algorithm.
+          EPSILON = 0.0001
+
+          private_constant :EPSILON
+
+          def initialize
+            super('local-minde')
+          end
+
+          def map(color)
+            original_oklch = color.send(:_to_space, Space::OKLCH)
+            lightness = original_oklch.send(:channel0_or_nil)
+            hue = original_oklch.send(:channel2_or_nil)
+            alpha = original_oklch.send(:alpha_or_nil)
+
+            if FuzzyMath.greater_than_or_equals(lightness.nil? ? 0 : lightness, 1)
+              if color.legacy?
+                return Color.send(:_for_space,
+                                  Space::RGB, 255, 255, 255, color.send(:alpha_or_nil))
+                            .send(:_to_space, color.send(:_space))
+              else
+                return Color.send(:for_space_internal,
+                                  color.send(:_space), 1, 1, 1, color.send(:alpha_or_nil))
+              end
+            elsif FuzzyMath.less_than_or_equals(lightness.nil? ? 0 : lightness, 0)
+              return Color.send(:_for_space,
+                                Space::RGB, 0, 0, 0, color.send(:alpha_or_nil))
+                          .send(:_to_space, color.send(:_space))
+            end
+
+            clipped = color.send(:_to_gamut, CLIP)
+            return clipped if _delta_eok(clipped, color) < JND
+
+            min = 0.0
+            max = original_oklch.send(:channel1)
+            min_in_gamut = true
+            while max - min > EPSILON
+              chroma = (min + max) / 2
+
+              current = Space::OKLCH.convert(color.send(:_space), lightness, chroma, hue, alpha)
+
+              if min_in_gamut && current.in_gamut?
+                min = chroma
+                next
+              end
+
+              clipped = current.send(:_to_gamut, CLIP)
+              e = _delta_eok(clipped, current)
+
+              if e < JND
+                return clipped if JND - e < EPSILON
+
+                min_in_gamut = false
+                min = chroma
+              else
+                max = chroma
+              end
+            end
+            clipped
+          end
+
+          private
+
+          def _delta_eok(color1, color2)
+            lab1 = color1.send(:_to_space, Space::OKLAB)
+            lab2 = color2.send(:_to_space, Space::OKLAB)
+            Math.sqrt(((lab1.send(:channel0) - lab2.send(:channel0))**2) +
+                        ((lab1.send(:channel1) - lab2.send(:channel1))**2) +
+                        ((lab1.send(:channel2) - lab2.send(:channel2))**2))
+          end
+        end
+
+        private_constant :LocalMinde
+
+        LOCAL_MINDE = LocalMinde.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Sass
+  module Value
+    class Color
+      # @see https://github.com/sass/dart-sass/blob/main/lib/src/value/color/gamut_map_method.dart
+      module GamutMapMethod
+        # @return [::String]
+        attr_reader :name
+
+        # @param name [::String]
+        def initialize(name)
+          @name = name
+        end
+
+        class << self
+          # @param name [::String]
+          # @param argument_name [::String]
+          # @return [GamutMapMethod]
+          def from_name(name, argument_name = nil)
+            case name
+            when 'clip'
+              CLIP
+            when 'local-minde'
+              LOCAL_MINDE
+            else
+              raise Sass::ScriptError.new("Unknown gamut map method \"#{name}\".", argument_name)
+            end
+          end
+        end
+
+        # @param color [Color]
+        # @return [Color]
+        def map(color)
+          raise NotImplementedError, "[BUG] gamut map method #{name} doesn't implement map."
+        end
+      end
+
+      private_constant :GamutMapMethod
+    end
+  end
+end
+
+require_relative 'gamut_map_method/clip'
+require_relative 'gamut_map_method/local_minde'

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)
+            (channel <=> 0) * (channel.abs**(563 / 256.0))
+          end
+
+          def from_linear(channel)
+            (channel <=> 0) * (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