color_converters 0.1.3 → 0.1.4

data/lib/color_converters/converters/rgb_converter.rb

@@ -1,106 +1,109 @@
-module ColorConverters
-  class RgbConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
-
-      color_input.keys - [:r, :g, :b] == [] || color_input.keys - [:r, :g, :b, :a] == []
-    end
-
-    def self.bounds
-      { r: [0.0, 255.0], g: [0.0, 255.0], b: [0.0, 255.0] }
-    end
-
-    private
-
-    def validate_input(color_input)
-      bounds = RgbConverter.bounds
-      color_input[:r].to_f.between?(*bounds[:r]) && color_input[:g].to_f.between?(*bounds[:g]) && color_input[:b].to_f.between?(*bounds[:b])
-    end
-
-    def input_to_rgba(color_input)
-      r = color_input[:r].to_f
-      g = color_input[:g].to_f
-      b = color_input[:b].to_f
-      a = (color_input[:a] || 1.0).to_f
-
-      [r, g, b, a]
-    end
-
-    def self.rgb_to_lrgb(rgb_array_frac)
-      # [0, 1]
-      r, g, b = rgb_array_frac
-
-      # Inverse sRGB companding. Linearizes RGB channels with respect to energy.
-      # Assumption that r, g, b are always positive
-      rr, gg, bb = [r, g, b].map do
-        if _1.to_d <= 0.04045.to_d
-          _1.to_d / 12.92.to_d
-        else
-          # sRGB Inverse Companding (Non-linear to Linear RGB)
-          # The sRGB specification (IEC 61966-2-1) defines the exponent as 2.4.
-          #
-          (((_1.to_d + 0.055.to_d) / 1.055.to_d)**2.4.to_d)
-
-          # IMPORTANT NUMERICAL NOTE:
-          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
-          # the power function for val**2.4 yields a result that deviates from the value expected by widely-used color science libraries (like Bruce Lindbloom's).
-          #
-          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
-          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
-          #
-          # Choose 2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
-          # or choose 2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
-          #
-          # ((_1 + 0.055) / 1.055)**2.5
-        end
-      end
-
-      # [0, 1]
-      [rr, gg, bb]
-    end
-
-    def self.lrgb_to_rgb(lrgb_array)
-      rr, gg, bb = lrgb_array
-
-      # Apply sRGB Companding (gamma correction) to convert from Linear RGB to non-linear sRGB.
-      # This is defined by the sRGB specification (IEC 61966-2-1).
-      # The exponent for the non-linear segment is 1/2.4 (approximately 0.41666...).
-      # Assumption that rr, gg, bb are always positive
-      r, g, b = [rr, gg, bb].map do
-        if _1.to_d <= 0.0031308.to_d
-          # Linear portion of the sRGB curve
-          _1.to_d * 12.92.to_d
-        else
-          # Non-linear (gamma-corrected) portion of the sRGB curve
-          # The sRGB specification uses an exponent of 1/2.4.
-          #
-          (1.055.to_d * (_1.to_d**(1.0.to_d / 2.4.to_d))) - 0.055.to_d
-
-          # IMPORTANT NUMERICAL NOTE:
-          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
-          # the inverse power function for val**2.4 yields a result that deviates from the value expected by widely-used color science libraries (like Bruce Lindbloom's).
-          #
-          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
-          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
-          #
-          # Choose 1/2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
-          # or choose 1/2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
-          #
-          # (1.055 * (_1**(1.0 / 2.5))) - 0.055
-        end
-      end
-
-      # Scale the 0-1 sRGB value to the 0-255 range for 8-bit color components.
-      r *= 255.0.to_d
-      g *= 255.0.to_d
-      b *= 255.0.to_d
-
-      # Clamping RGB values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
-      r = r.clamp(0.0..255.0)
-      g = g.clamp(0.0..255.0)
-      b = b.clamp(0.0..255.0)
-
-      [r, g, b]
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class RgbConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:r, :g, :b] == [] || colour_input.keys - [:r, :g, :b, :a] == []
+    end
+
+    def self.bounds
+      { r: [0.0, 255.0], g: [0.0, 255.0], b: [0.0, 255.0], a: [0.0, 1.0] }
+    end
+
+    private
+
+    def validate_input(colour_input)
+      RgbConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      r = colour_input[:r].to_f
+      g = colour_input[:g].to_f
+      b = colour_input[:b].to_f
+      a = (colour_input[:a] || 1.0).to_f
+
+      [r, g, b, a]
+    end
+
+    def self.rgb_to_lrgb(rgb_array_frac)
+      # [0, 1]
+      r, g, b = rgb_array_frac
+
+      # Inverse sRGB companding. Linearizes RGB channels with respect to energy.
+      # Assumption that r, g, b are always positive
+      rr, gg, bb = [r, g, b].map do
+        if _1.to_d <= 0.04045.to_d
+          _1.to_d / 12.92.to_d
+        else
+          # sRGB Inverse Companding (Non-linear to Linear RGB)
+          # The sRGB specification (IEC 61966-2-1) defines the exponent as 2.4.
+          #
+          (((_1.to_d + 0.055.to_d) / 1.055.to_d)**2.4.to_d)
+
+          # IMPORTANT NUMERICAL NOTE:
+          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
+          # the power function for val**2.4 yields a result that deviates from the value expected by widely-used colour science libraries (like Bruce Lindbloom's).
+          #
+          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
+          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
+          #
+          # Choose 2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
+          # or choose 2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
+          #
+          # ((_1 + 0.055) / 1.055)**2.5
+        end
+      end
+
+      # [0, 1]
+      [rr, gg, bb]
+    end
+
+    def self.lrgb_to_rgb(lrgb_array)
+      rr, gg, bb = lrgb_array
+
+      # Apply sRGB Companding (gamma correction) to convert from Linear RGB to non-linear sRGB.
+      # This is defined by the sRGB specification (IEC 61966-2-1).
+      # The exponent for the non-linear segment is 1/2.4 (approximately 0.41666...).
+      # Assumption that rr, gg, bb are always positive
+      r, g, b = [rr, gg, bb].map do
+        if _1.to_d <= 0.0031308.to_d
+          # Linear portion of the sRGB curve
+          _1.to_d * 12.92.to_d
+        else
+          # Non-linear (gamma-corrected) portion of the sRGB curve
+          # The sRGB specification uses an exponent of 1/2.4.
+          #
+          (1.055.to_d * (_1.to_d**(1.0.to_d / 2.4.to_d))) - 0.055.to_d
+
+          # IMPORTANT NUMERICAL NOTE:
+          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
+          # the inverse power function for val**2.4 yields a result that deviates from the value expected by widely-used colour science libraries (like Bruce Lindbloom's).
+          #
+          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
+          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
+          #
+          # Choose 1/2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
+          # or choose 1/2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
+          #
+          # (1.055 * (_1**(1.0 / 2.5))) - 0.055
+        end
+      end
+
+      # Scale the 0-1 sRGB value to the 0-255 range for 8-bit colour components.
+      r *= 255.0.to_d
+      g *= 255.0.to_d
+      b *= 255.0.to_d
+
+      # Clamping RGB values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
+      r = r.clamp(0.0..255.0)
+      g = g.clamp(0.0..255.0)
+      b = b.clamp(0.0..255.0)
+
+      [r, g, b]
+    end
+  end
+end

data/lib/color_converters/converters/rgb_string_converter.rb

@@ -1,32 +1,49 @@
-module ColorConverters
-  class RgbStringConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(String)
-
-      color_input.include?('rgb(') || color_input.include?('rgba(')
-    end
-
-    private
-
-    def validate_input(_color_input)
-      true
-    end
-
-    def input_to_rgba(color_input)
-      matches = color_input.match(/rgba?\(([0-9.,\s]+)\)/)
-      raise InvalidColorError unless matches
-
-      r, g, b, a = matches[1].split(',').map(&:strip)
-      raise InvalidColorError unless r.present? && g.present? && b.present?
-
-      a ||= 1.0
-
-      r = r.to_f
-      g = g.to_f
-      b = b.to_f
-      a = a.to_f
-
-      [r, g, b, a]
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class RgbStringConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(String)
+
+      colour_input.include?('rgb(') || colour_input.include?('rgba(')
+    end
+
+    def self.bounds
+      RgbConverter.bounds
+    end
+
+    private
+
+    def validate_input(colour_input)
+      keys = colour_input.include?('rgba(') ? [:r, :g, :b, :a] : [:r, :g, :b]
+      colour_input = RgbStringConverter.sanitize_input(colour_input)
+
+      errors = keys.collect do |key|
+        "#{key} must be present" if colour_input[key].blank?
+      end.compact
+
+      return errors if errors.present?
+
+      RgbStringConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      colour_input = RgbStringConverter.sanitize_input(colour_input)
+
+      r = colour_input[:r].to_f
+      g = colour_input[:g].to_f
+      b = colour_input[:b].to_f
+      a = (colour_input[:a] || 1.0).to_f
+
+      [r, g, b, a]
+    end
+
+    def self.sanitize_input(colour_input)
+      matches = colour_input.match(/rgba?\(([0-9.,%\s]+)\)/) || []
+      r, g, b, a = matches[1]&.split(',')&.map(&:strip)
+      { r: r, g: g, b: b, a: a }
+    end
+  end
+end

data/lib/color_converters/converters/xyz_converter.rb

@@ -1,107 +1,110 @@
-module ColorConverters
-  class XyzConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
-
-      color_input.keys - [:x, :y, :z] == []
-    end
-
-    def self.d65
-      { x: 95.047, y: 100.0, z: 108.883 }
-    end
-
-    def self.bounds
-      { x: [0.0, 100.0], y: [0.0, 100.0], z: [0.0, 110.0] }
-    end
-
-    private
-
-    def validate_input(color_input)
-      bounds = XyzConverter.bounds
-      color_input[:x].to_f.between?(*bounds[:x]) && color_input[:y].to_f.between?(*bounds[:y]) && color_input[:z].to_f.between?(*bounds[:z])
-    end
-
-    def input_to_rgba(color_input)
-      r, g, b = XyzConverter.xyz_to_rgb(color_input)
-
-      [r, g, b, 1.0]
-    end
-
-    def self.xyz_to_rgb(xyz_hash)
-      # [0, 100]
-      x = xyz_hash[:x].to_d
-      y = xyz_hash[:y].to_d
-      z = xyz_hash[:z].to_d
-
-      # Convert XYZ (typically with Y=100 for white) to normalized XYZ (Y=1 for white).
-      # The transformation matrix expects X, Y, Z values in the 0-1 range.
-      x /= 100.0.to_d
-      y /= 100.0.to_d
-      z /= 100.0.to_d
-
-      # Convert normalized XYZ to Linear sRGB values using sRGB's own white, D65 (no chromatic adaptation)
-      # https://www.w3.org/TR/css-color-4/#color-conversion-code
-      conversion_matrix = ::Matrix[
-        [BigDecimal('3.2409699419045213'), BigDecimal('-1.5373831775700935'), BigDecimal('-0.4986107602930033')],
-        [BigDecimal('-0.9692436362808798'), BigDecimal('1.8759675015077206'), BigDecimal('0.04155505740717561')],
-        [BigDecimal('0.05563007969699361'), BigDecimal('-0.20397695888897657'), BigDecimal('1.0569715142428786')]
-      ]
-
-      rr, gg, bb = (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
-
-      # [0, 1]
-      RgbConverter.lrgb_to_rgb([rr, gg, bb])
-    end
-
-    # http://www.brucelindbloom.com/index.html?Eqn_RGB_to_XYZ.html
-    def self.rgb_to_xyz(rgb_array_frac)
-      rr, gg, bb = RgbConverter.rgb_to_lrgb(rgb_array_frac)
-
-      # Convert using the RGB/XYZ matrix and sRGB's own white, D65 (no chromatic adaptation)
-      # https://www.w3.org/TR/css-color-4/#color-conversion-code
-      conversion_matrix = ::Matrix[
-        [BigDecimal('0.4123907992659595'), BigDecimal('0.35758433938387796'), BigDecimal('0.1804807884018343')],
-        [BigDecimal('0.21263900587151036'), BigDecimal('0.7151686787677559'), BigDecimal('0.07219231536073371')],
-        [BigDecimal('0.01933081871559185'), BigDecimal('0.11919477979462599'), BigDecimal('0.9505321522496606')]
-      ]
-
-      x, y, z = (conversion_matrix * ::Matrix.column_vector([rr, gg, bb])).to_a.flatten
-
-      # Now, scale X, Y, Z so that Y for D65 white would be 100.
-      x *= 100.0
-      y *= 100.0
-      z *= 100.0
-
-      # Clamping XYZ values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
-      # x = x.clamp(0.0..95.047)
-      # y = y.clamp(0.0..100.0)
-      # z = z.clamp(0.0..108.883)
-
-      [x, y, z]
-    end
-
-    def self.d50_to_d65(xyz_array)
-      x, y, z = xyz_array
-
-      conversion_matrix = ::Matrix[
-        [BigDecimal('0.955473421488075'), BigDecimal('-0.02309845494876471'), BigDecimal('0.06325924320057072')],
-        [BigDecimal('-0.0283697093338637'), BigDecimal('1.0099953980813041'), BigDecimal('0.021041441191917323')],
-        [BigDecimal('0.012314014864481998'), BigDecimal('-0.020507649298898964'), BigDecimal('1.330365926242124')]
-      ]
-
-      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
-    end
-
-    def self.d65_to_d50(xyz_array)
-      x, y, z = xyz_array
-
-      conversion_matrix = ::Matrix[
-        [BigDecimal('1.0479297925449969'), BigDecimal('0.022946870601609652'), BigDecimal('-0.05019226628920524')],
-        [BigDecimal('0.02962780877005599'), BigDecimal('0.9904344267538799'), BigDecimal('-0.017073799063418826')],
-        [BigDecimal('-0.009243040646204504'), BigDecimal('0.015055191490298152'), BigDecimal('0.7518742814281371')]
-      ]
-
-      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class XyzConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:x, :y, :z] == []
+    end
+
+    def self.d65
+      { x: 95.047, y: 100.0, z: 108.883 }
+    end
+
+    def self.bounds
+      { x: [0.0, 100.0], y: [0.0, 100.0], z: [0.0, 110.0] }
+    end
+
+    private
+
+    def validate_input(colour_input)
+      XyzConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      r, g, b = XyzConverter.xyz_to_rgb(colour_input)
+
+      [r, g, b, 1.0]
+    end
+
+    def self.xyz_to_rgb(xyz_hash)
+      # [0, 100]
+      x = xyz_hash[:x].to_d
+      y = xyz_hash[:y].to_d
+      z = xyz_hash[:z].to_d
+
+      # Convert XYZ (typically with Y=100 for white) to normalized XYZ (Y=1 for white).
+      # The transformation matrix expects X, Y, Z values in the 0-1 range.
+      x /= 100.0.to_d
+      y /= 100.0.to_d
+      z /= 100.0.to_d
+
+      # Convert normalized XYZ to Linear sRGB values using sRGB's own white, D65 (no chromatic adaptation)
+      # https://www.w3.org/TR/css-color-4/#color-conversion-code
+      conversion_matrix = ::Matrix[
+        [BigDecimal('3.2409699419045213'), BigDecimal('-1.5373831775700935'), BigDecimal('-0.4986107602930033')],
+        [BigDecimal('-0.9692436362808798'), BigDecimal('1.8759675015077206'), BigDecimal('0.04155505740717561')],
+        [BigDecimal('0.05563007969699361'), BigDecimal('-0.20397695888897657'), BigDecimal('1.0569715142428786')]
+      ]
+
+      rr, gg, bb = (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+
+      # [0, 1]
+      RgbConverter.lrgb_to_rgb([rr, gg, bb])
+    end
+
+    # http://www.brucelindbloom.com/index.html?Eqn_RGB_to_XYZ.html
+    def self.rgb_to_xyz(rgb_array_frac)
+      rr, gg, bb = RgbConverter.rgb_to_lrgb(rgb_array_frac)
+
+      # Convert using the RGB/XYZ matrix and sRGB's own white, D65 (no chromatic adaptation)
+      # https://www.w3.org/TR/css-color-4/#color-conversion-code
+      conversion_matrix = ::Matrix[
+        [BigDecimal('0.4123907992659595'), BigDecimal('0.35758433938387796'), BigDecimal('0.1804807884018343')],
+        [BigDecimal('0.21263900587151036'), BigDecimal('0.7151686787677559'), BigDecimal('0.07219231536073371')],
+        [BigDecimal('0.01933081871559185'), BigDecimal('0.11919477979462599'), BigDecimal('0.9505321522496606')]
+      ]
+
+      x, y, z = (conversion_matrix * ::Matrix.column_vector([rr, gg, bb])).to_a.flatten
+
+      # Now, scale X, Y, Z so that Y for D65 white would be 100.
+      x *= 100.0
+      y *= 100.0
+      z *= 100.0
+
+      # Clamping XYZ values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
+      # x = x.clamp(0.0..95.047)
+      # y = y.clamp(0.0..100.0)
+      # z = z.clamp(0.0..108.883)
+
+      [x, y, z]
+    end
+
+    def self.d50_to_d65(xyz_array)
+      x, y, z = xyz_array
+
+      conversion_matrix = ::Matrix[
+        [BigDecimal('0.955473421488075'), BigDecimal('-0.02309845494876471'), BigDecimal('0.06325924320057072')],
+        [BigDecimal('-0.0283697093338637'), BigDecimal('1.0099953980813041'), BigDecimal('0.021041441191917323')],
+        [BigDecimal('0.012314014864481998'), BigDecimal('-0.020507649298898964'), BigDecimal('1.330365926242124')]
+      ]
+
+      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+    end
+
+    def self.d65_to_d50(xyz_array)
+      x, y, z = xyz_array
+
+      conversion_matrix = ::Matrix[
+        [BigDecimal('1.0479297925449969'), BigDecimal('0.022946870601609652'), BigDecimal('-0.05019226628920524')],
+        [BigDecimal('0.02962780877005599'), BigDecimal('0.9904344267538799'), BigDecimal('-0.017073799063418826')],
+        [BigDecimal('-0.009243040646204504'), BigDecimal('0.015055191490298152'), BigDecimal('0.7518742814281371')]
+      ]
+
+      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+    end
+  end
+end

data/lib/color_converters/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ColorConverters
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/lib/color_converters.rb

@@ -1,30 +1,31 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-require 'color_converters/version'
-
-require 'color_converters/color'
-require 'color_converters/base_converter'
-
-require 'color_converters/converters/rgb_converter'
-require 'color_converters/converters/rgb_string_converter'
-require 'color_converters/converters/hex_converter'
-require 'color_converters/converters/hsl_converter'
-require 'color_converters/converters/hsl_string_converter'
-require 'color_converters/converters/hsv_converter'
-require 'color_converters/converters/cmyk_converter'
-require 'color_converters/converters/xyz_converter'
-require 'color_converters/converters/cielab_converter'
-require 'color_converters/converters/cielch_converter'
-require 'color_converters/converters/oklab_converter'
-require 'color_converters/converters/oklch_converter'
-
-require 'color_converters/converters/name_converter'
-require 'color_converters/converters/null_converter'
-
-module ColorConverters
-  class Error < StandardError; end
-  class InvalidColorError < Error; end
-  # Your code goes here...
-end
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require 'color_converters/version'
+
+require 'color_converters/color'
+require 'color_converters/base_converter'
+
+# Converters
+require 'color_converters/converters/rgb_converter'
+require 'color_converters/converters/rgb_string_converter'
+require 'color_converters/converters/hex_converter'
+require 'color_converters/converters/hsl_converter'
+require 'color_converters/converters/hsl_string_converter'
+require 'color_converters/converters/hsv_converter'
+require 'color_converters/converters/cmyk_converter'
+require 'color_converters/converters/xyz_converter'
+require 'color_converters/converters/cielab_converter'
+require 'color_converters/converters/cielch_converter'
+require 'color_converters/converters/oklab_converter'
+require 'color_converters/converters/oklch_converter'
+
+require 'color_converters/converters/name_converter'
+require 'color_converters/converters/null_converter'
+
+module ColorConverters
+  class Error < StandardError; end
+  class InvalidColorError < Error; end
+  # Your code goes here...
+end

metadata

@@ -1,28 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: color_converters
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Louis Davis
 bindir: bin
 cert_chain: []
-date: 2025-08-18 00:00:00.000000000 Z
+date: 2025-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+- !ruby/object:Gem::Dependency
+  name: color_swatch_collection
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 8.0.2
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 8.0.2
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: matrix
   requirement: !ruby/object:Gem::Requirement