gouache 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b882f0ae8489aa7349e5bdc4ffbd4057c5d10db0269fb6ea2af2251e133cb399
+  data.tar.gz: 8d8bd255f7110d76f0a70447ea26c9a5531f2a1da35f7385484a4be0f70dca5d
+SHA512:
+  metadata.gz: 29ff0da15b2c84db40051c822b6dfeebf1cd274250c3249066a3d30a92683fe2323457db6e01afd7c2c720e9079d0552ff35737fae0376b8938ca247e59727cf
+  data.tar.gz: eb30d3abeb27b3e21c5002587d339755f51fb7890e3238ce89b941b0e8bfc7c48a83c34ae64687632aff0409a914ba853ce85ad4f16191a8bf38d608740202bc

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Caio Chassot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/gouache.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/gouache/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "gouache"
+  spec.version       = Gouache::VERSION
+  spec.authors       = ["Caio Chassot"]
+  spec.email         = ["dev@caiochassot.com"]
+
+  spec.summary       = "A flexible terminal color library for Ruby"
+  spec.description   = "Gouache provides a powerful and flexible way to add colors and styling to terminal output in Ruby applications. It supports multiple color formats (RGB, OKLCH, 256-color, basic), fallback modes, custom stylesheets, refinements for String, and advanced features like color shifting and effects."
+  spec.homepage      = "https://github.com/kch/gouache"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 3.4.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/kch/gouache"
+  # spec.metadata["changelog_uri"] = "https://github.com/kch/gouache/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Runtime dependencies
+  spec.add_dependency "matrix", "~> 0.4.2"
+
+  # Development dependencies
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+end

data/lib/gouache/base.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class Gouache
+
+  BASE_STYLES = {
+    reset:              0,
+    black:              30,
+    red:                31,
+    green:              32,
+    yellow:             33,
+    blue:               34,
+    magenta:            35,
+    cyan:               36,
+    white:              37,
+    default:            39,
+    black!:             90,
+    red!:               91,
+    green!:             92,
+    yellow!:            93,
+    blue!:              94,
+    magenta!:           95,
+    cyan!:              96,
+    white!:             97,
+    on_black:           40,
+    on_red:             41,
+    on_green:           42,
+    on_yellow:          43,
+    on_blue:            44,
+    on_magenta:         45,
+    on_cyan:            46,
+    on_white:           47,
+    on_default:         49,
+    on_black!:         100,
+    on_red!:           101,
+    on_green!:         102,
+    on_yellow!:        103,
+    on_blue!:          104,
+    on_magenta!:       105,
+    on_cyan!:          106,
+    on_white!:         107,
+    bold:                1,
+    dim:                 2,
+    faint:               2,
+    italic:              3,
+    underline:           4,
+    double_underline:   21,
+    overline:           53,
+    blink:               5,
+    invert:              7,
+    inverse:             7,
+    reverse:             7,
+    hidden:              8,
+    hide:                8,
+    conceal:             8,
+    strike:              9,
+    strikeout:           9,
+    strikethrough:       9,
+    intensity_off:      22, # dim+bold
+    dim_off:            ->{ it.dim = false },
+    bold_off:           ->{ it.bold = false },
+    italic_off:         23,
+    underlines_off:     24, # under+double
+    blink_off:          25,
+    invert_off:         27,
+    inverse_off:        27,
+    reverse_off:        27,
+    hidden_off:         28,
+    hide_off:           28,
+    reveal:             28,
+    strike_off:         29,
+    strikeout_off:      29,
+    strikethrough_off:  29,
+    overline_off:       55,
+  }
+
+end

data/lib/gouache/builder.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "emitter"
+require_relative "wrap"
+require "strscan"
+
+class Gouache
+  module Builder
+
+    using Wrap
+
+    ### helpers
+
+    def self.safe_emit_sgr s, emitter:
+      unless s.has_sgr?
+        emitter << s
+        return nil
+      end
+
+      ss = StringScanner.new s.wrap
+      wraps = 0
+      while text = ss.scan_until(RX_ESC_LA)
+        emitter << text
+        case
+        when ss.skip(WRAP_OPEN)
+          wraps += 1
+          emitter.begin_sgr
+          emitter << ss.scan_until(RX_ESC_LA)
+        when ss.skip(WRAP_CLOSE)
+          next if wraps == 0
+          wraps -= 1
+          emitter.end_sgr
+        when sgr = ss.scan(RX_SGR)
+          emitter.push_sgr sgr
+        else emitter << ss.scan(?\e)
+        end
+      end
+      wraps.times{ emitter.end_sgr }
+      emitter << ss.rest
+      nil
+    end
+
+    def self.emit_content(x, emitter:)
+      case x
+      in Array  then _compile(x, emitter:)
+      in String then safe_emit_sgr(x, emitter:)
+      in _      then emitter << x
+      end
+    end
+
+    ### compile
+
+    def self._compile node, emitter:
+      return unless node&.any?                                   # stop recursing
+      first, *rest = *node.slice_before{ it in Symbol | Color }  # each symbol marks a new tag/node
+      head, *first = first if first in [Symbol | Color, *]       # node may begin with tag|color or not
+      rest  = rest.reverse_each.inject{|b,a| a << b }            # nest symbol chains [:a,:b,:c] -> [:a,[:b,[:c]]]
+      tag   = head if head in Symbol
+      color = head if head in Color
+      emitter.open_tag tag if tag
+      emitter.begin_sgr.push_sgr color.to_s(fallback: true) if color
+      first.each{ emit_content(it, emitter:) }
+      _compile(rest, emitter:)
+      emitter.end_sgr if color
+      emitter.close_tag if tag
+      nil
+    end
+
+    def self.compile root, instance:
+      emitter = instance.mk_emitter
+      _compile(root, emitter:)
+      emitter.emit!
+    end
+
+    ### block/chains
+
+    class UnfinishedChain < RuntimeError
+      def initialize(chain) = super "call chain #{chain.instance_exec{@tags}*?.} left dangling with no arguments"
+    end
+
+    class ChainProxy < BasicObject
+      def initialize parent, tag
+        @tags = [tag]
+        @parent = parent
+      end
+
+      private def method_missing(m, *a, &b)
+        return super if %i[ to_s to_str to_ary ].include? m # prevent confusion if proxy leaks
+
+        if a.empty? && b.nil?
+          @tags << m
+          return self
+        end
+
+        @parent.instance_exec{ @chain = nil }
+        # inject tags into nested blocks and send to owner proxy
+        buildme = @tags.reverse_each.inject(->{ __send__(:_build!, m, *a, &b) }){|b, t| ->{ __send__(:_build!, t, &b) }}
+        @parent.instance_exec(&buildme)
+      end
+    end
+
+
+    class Proxy < BasicObject
+
+      def self.for(instance, m, ...)
+        return unless m.nil? || instance.rules.tag?(m)
+        new(instance).__send__(:_build!, m, ...)
+      end
+
+      def initialize(instance)
+        # @instance = instance
+        @emitter  = instance.mk_emitter
+        @tags     = []
+        @nesting  = 0
+      end
+
+      # def call(...) = _build!(nil, ...) # TODO: Do we want this?
+
+      def <<(s) = ::Gouache::Builder.emit_content(s, emitter: @emitter)
+
+      private def method_missing(m, ...)
+        return super if %i[ to_s to_str to_ary ].include? m # prevent confusion if proxy leaks
+        # return super unless @instance.rules.tag? m  # TODO: optional?
+        _build!(m, ...)
+      end
+
+      private def _build!(m, *content, &builder)
+        ::Kernel.raise UnfinishedChain, @chain if @chain
+        if content.empty? && builder.nil?
+          @chain = ChainProxy.new(self, m)
+          return @chain
+        end
+
+        @emitter.open_tag m if m
+        content.each{ ::Gouache::Builder.emit_content(it, emitter: @emitter) }
+
+        @nesting += 1
+        case builder&.arity
+        in nil
+        in 1 then builder[self]            # {|x| x.tag ... } or { it.tag ... } form
+        in 0 then instance_exec(&builder)  # { tag ... } form
+        in _ then ::Kernel.raise ::ArgumentError
+        end
+        @nesting -= 1
+        ::Kernel.raise UnfinishedChain, @chain if @chain
+        @emitter.close_tag if m
+        @nesting == 0 ? @emitter.emit! : nil
+      end
+
+    end # Proxy
+
+  end # Builder
+end # Gouache

data/lib/gouache/color.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative "color_utils"
+require_relative "term"
+require_relative "utils"
+
+class Gouache
+  class Color
+    using RegexpWrap  # enable .w below. wrap it in \A\z
+
+    FG = 38      # foreground role
+    BG = 48      # background role
+    I8 = 0..255  # 8bit int range, for 256 colors and rgb channels
+    IC = 0..5    # 216 color cube channel range
+    D8       = / 1?\d?\d | 2[0-4]\d | 25[0-5]              /x   # 0..255 string
+    RX_BASIC = / (?: 3|4|9|10 ) [0-7] | [34]9              /x.w # sgr basic ranges
+    RX_256   = / ([34]8) ; 5 ; (#{D8})                     /x.w # sgr 256 color
+    RX_RGB   = / ([34]8) ; 2 ; (#{D8}) ; (#{D8}) ; (#{D8}) /x.w # sgr truecolor
+    RX_HEX   = / \#? (\h\h) (\h\h) (\h\h)                  /x.w # hex syntax for truecolor
+
+    def initialize(**kva)
+      # very unforgiving as public use
+      case kva
+      in sgr: 39 | 49 | 30..37 | 40..47 | 90..97 | 100..107 => n then @sgr_basic = n
+      in sgr: RX_BASIC => s                                      then @sgr_basic = s.to_i
+      in sgr: RX_256   => s                                      then @sgr = s; @role, @_256 = $~[1..].map(&:to_i)
+      in sgr: RX_RGB   => s                                      then @sgr = s; @role, *@rgb = $~[1..].map(&:to_i)
+      in role: FG|BG => rl, rgb: [I8, I8, I8] => rgb             then @role = rl; @rgb = rgb
+      in role: FG|BG => rl, rgb: RX_HEX                          then @role = rl; @rgb = $~[1..].map{it.to_i(16)}
+      in role: FG|BG => rl, oklch: [0..1, 0.., Numeric] => lch   then @role = rl; @oklch = lch
+      in role: FG|BG => rl, gray: 0..23 => gray                  then @role = rl; @_256 = 232 + gray
+      in role: FG|BG => rl, cube: [IC => r, IC => g, IC => b]    then @role = rl; @_256 = 16 + 36*r + 6*g + b
+      in __private: [rl, sgr, _256, rgb, oklch]                  then @role, @sgr_basic, @_256, @rgb, @oklch = rl, sgr, _256, rgb, oklch
+      else raise ArgumentError, kva.inspect
+      end
+      raise ArgumentError, kva.inspect unless @role in 38 | 48 | nil
+    end
+
+    private_class_method def self.parse_rgb(args)
+      case args
+      in [ I8 => r, I8 => g, I8 => b ] then [r,g,b]
+      in [[I8 => r, I8 => g, I8 => b]] then [r,g,b]
+      in [RX_HEX]                      then $~[1..].map{it.to_i(16)}
+      else raise ArgumentError, args.inspect
+      end
+    end
+
+    # constructors for styles
+    def self.sgr(sgr)        = new(sgr:)
+    def self.ansi(sgr)       = new(sgr:)
+    def self.rgb(*rgb)       = new(role: FG, rgb: parse_rgb(rgb))
+    def self.on_rgb(*rgb)    = new(role: BG, rgb: parse_rgb(rgb))
+    def self.hex(hs)         = new(role: FG, rgb: hs)
+    def self.on_hex(hs)      = new(role: BG, rgb: hs)
+    def self.cube(r,g,b)     = new(role: FG, cube: [r,g,b])
+    def self.on_cube(r,g,b)  = new(role: BG, cube: [r,g,b])
+    def self.gray(n)         = new(role: FG, gray: n)
+    def self.on_gray(n)      = new(role: BG, gray: n)
+    def self.oklch(l,c,h)    = new(role: FG, oklch: [l,c,h])
+    def self.on_oklch(l,c,h) = new(role: BG, oklch: [l,c,h])
+
+    def role
+      @role || case @sgr_basic
+      in /\A38;/ | 39 | 30..37 | 90..97   then FG
+      in /\A48;/ | 49 | 40..47 | 100..107 then BG
+      end
+    end
+
+    def rgb
+      @rgb ||= case
+      when @oklch then ColorUtils.srgb8_from_oklch @oklch
+      when @_256  then Term.colors[@_256]
+      when (n = @sgr_basic)
+        case n
+        in 39       then Term.fg_color                # fg default
+        in 49       then Term.bg_color                # bg default
+        in 30..37   then Term.colors[n - 30]          # fg basic color
+        in 40..47   then Term.colors[n - 30 - 10]     # bg basic color
+        in 90..97   then Term.colors[n - 90 + 8]      # fg bright color
+        in 100..107 then Term.colors[n - 90 - 10 + 8] # bg bright color
+        end
+      else raise
+      end
+    end
+
+    def oklch = @oklch || ColorUtils.oklch_from_srgb8(rgb)
+
+    def sgr
+      @sgr ||= case
+      when @oklch     then [role, 2, *rgb]*?;
+      when @rgb       then [role, 2, *rgb]*?;
+      when @_256      then [role, 5, @_256]*?;
+      when @sgr_basic then @sgr_basic
+      else raise
+      end
+    end
+
+    def _256 = @_256 || Term.nearest256(rgb)
+
+    def basic
+      return @sgr_basic if @sgr_basic
+      i = Term.nearest16(rgb)     # get the nearest to rgb
+      x =  30 + i                 # go to 30 range for system colors
+      x += 60 - 8 if i > 7        # jump to 90 range for bright (≥8), -offset
+      x += 10 if role == 48       # jump to background ranges if bg
+      x                           # a plain basic color sgr
+    end
+
+    def to_sgr(fallback: false)
+      return sgr unless fallback
+      fallback = Term.color_level if fallback == true # allow passing the fallback level explicity or true to determine from Term
+      case fallback
+      in :truecolor then sgr
+      in :_256      then (!@_256 && @sgr_basic) || [role, 5, @_256 || _256]*?;
+      in :basic     then basic
+      end
+    end
+
+    def to_s(...) = to_sgr(...).to_s
+
+    def change_role(new_role)
+      return self unless new_role != role
+      sgr_basic = @sgr_basic + { FG => -10, BG => 10 }[new_role] if @sgr_basic
+      Color.new __private: [new_role, sgr_basic, @_256, @rgb, @oklch]
+    end
+
+    def self.merge(*colors) = colors.group_by(&:role).transform_values{|cs| cs.inject(&:merge) }.values_at(FG, BG)
+
+    def merge(other)
+      raise ArgumentError, "different roles" if role != other.role
+      merge_vars = ->{ [@role, @sgr_basic, @_256, @rgb, @oklch] }
+      Color.new __private: merge_vars[].zip(other.instance_exec(&merge_vars)).map{ _1 || _2 }
+    end
+
+    def to_i = sgr.to_i
+
+    def apply_deltas(xs, ds)
+      raise ArgumentError unless ds in [Numeric | [Numeric], Numeric | [Numeric], Numeric | [Numeric]]
+      xs.zip(ds).map{|x,d| (d in [d_]) ? d_ : x + d }
+    end
+
+    def oklch_shift(*ds)
+      l, c, h = apply_deltas(oklch, ds)
+      Color.new role:, oklch: [l.clamp(0.0, 1.0), [0.0, c].max, h]
+    end
+
+    def rgb_shift(*ds)
+      Color.new role:, rgb: apply_deltas(rgb, ds).map{ it.clamp(0, 255).round }
+    end
+
+    def == x
+      case x
+      in Color   then sgr == x.sgr
+      in Integer then sgr == x
+      in String  then sgr.to_s == x
+      else super
+      end
+    end
+
+  end
+end

data/lib/gouache/color_utils.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "matrix"
+
+class Gouache
+  module ColorUtils
+    extend self
+
+    # constants
+
+    SRGB_MAX = 255.0
+
+    SRGB_GAMMA_THRESHOLD  = 0.04045
+    SRGB_GAMMA_FACTOR     = 12.92
+    SRGB_GAMMA_A          = 0.055
+    SRGB_GAMMA_DIV        = 1.055
+    SRGB_GAMMA_GAMMA      = 2.4
+
+    LINEAR_SRGB_THRESHOLD = 0.0031308
+    LINEAR_SRGB_FACTOR    = 12.92
+    LINEAR_SRGB_A         = 0.055
+    LINEAR_SRGB_SCALE     = 1.055
+    LINEAR_SRGB_GAMMA_INV = 1.0 / 2.4
+
+    DEG_PER_RAD = 180.0 / Math::PI
+
+    # matrices
+
+    LMS_FROM_LINEAR_SRGB = Matrix[
+      [0.4122214708, 0.5363325363, 0.0514459929],
+      [0.2119034982, 0.6806995451, 0.1073969566],
+      [0.0883024619, 0.2817188376, 0.6299787005]]
+
+    OKLAB_FROM_LMS = Matrix[
+      [0.2104542553,  0.7936177850, -0.0040720468],
+      [1.9779984951, -2.4285922050,  0.4505937099],
+      [0.0259040371,  0.7827717662, -0.8086757660]]
+
+    LMS_FROM_OKLAB = Matrix[
+      [1.0,  0.3963377774,  0.2158037573],
+      [1.0, -0.1055613458, -0.0638541728],
+      [1.0, -0.0894841775, -1.2914855480]]
+
+    LINEAR_SRGB_FROM_LMS = Matrix[
+      [ 4.0767416621, -3.3077115913,  0.2309699292],
+      [-1.2684380046,  2.6097574011, -0.3413193965],
+      [-0.0041960863, -0.7034186147,  1.7076147010]]
+
+    # helpers
+
+    def cbrt_vec(v)
+      Vector[*v.map{|x| x < 0 ? -(-x)**(1.0 / 3.0) : x**(1.0 / 3.0) }]
+    end
+
+    def linear_rgb_from_srgb8(srgb8)
+      Vector[*srgb8.map do |c|
+        c /= SRGB_MAX
+        next c / SRGB_GAMMA_FACTOR if c <= SRGB_GAMMA_THRESHOLD
+        ((c + SRGB_GAMMA_A) / SRGB_GAMMA_DIV) ** SRGB_GAMMA_GAMMA
+      end]
+    end
+
+    def srgb8_from_linear_rgb(lin)
+      lin.map do |c|
+        c = c.clamp(0.0, 1.0)
+        next (c * LINEAR_SRGB_FACTOR * SRGB_MAX).round if c <= LINEAR_SRGB_THRESHOLD
+        ((LINEAR_SRGB_SCALE * c**LINEAR_SRGB_GAMMA_INV - LINEAR_SRGB_A) * SRGB_MAX).round
+      end
+    end
+
+    # conversions
+
+    def oklab_from_srgb8(srgb8)
+      lin = linear_rgb_from_srgb8(srgb8)
+      lms = LMS_FROM_LINEAR_SRGB * lin
+      (OKLAB_FROM_LMS * cbrt_vec(lms)).to_a
+    end
+
+    def srgb8_from_oklab(oklab)
+      lms = LMS_FROM_OKLAB * Vector[*oklab]
+      lin = LINEAR_SRGB_FROM_LMS * Vector[*lms.map{ it**3 }]
+      srgb8_from_linear_rgb(lin.to_a)
+    end
+
+    def oklch_from_oklab((l,a,b))
+      c = Math.sqrt(a*a + b*b)
+      h = Math.atan2(b, a) * DEG_PER_RAD
+      h += 360 if h < 0
+      [l, c, h]
+    end
+
+    def oklab_from_oklch((l,c,h))
+      r = h / DEG_PER_RAD
+      [l, c * Math.cos(r), c * Math.sin(r)]
+    end
+
+    def oklch_from_srgb8(srgb8) = oklch_from_oklab oklab_from_srgb8 srgb8
+
+    def srgb8_from_oklch(oklch) = srgb8_from_oklab oklab_from_oklch oklch
+
+    # distance
+
+    DIST_WEIGHTS = [1.5, 1.0, 1.0]
+    def oklab_distance_from_srgb8(srgb8_a, srgb8_b, weights: DIST_WEIGHTS)
+      a = oklab_from_srgb8(srgb8_a)
+      b = oklab_from_srgb8(srgb8_b)
+      Math.sqrt a.zip(b, weights).sum{|a,b,w| ((b-a)*w)**2 }
+    end
+
+  end
+end

data/lib/gouache/emitter.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "layer_stack"
+require_relative "stylesheet"
+
+class Gouache
+  class Emitter
+
+    def initialize(instance:)
+      @rules   = instance.rules # stylesheet
+      @enabled = instance.enabled?
+      @layers  = LayerStack.new # each tag or bare sgr emitted generates a layer
+      @flushed = @layers.base   # keep layer state after each flush so next flush can diff against it
+      @queue   = []             # accumulate sgr params to emit until we have text to style (we collapse to minimal set then)
+      @got_sgr = false          # did we emit sgr at all? used to determine if reset in the end
+      @out     = +""
+      enqueue @layers.diffpush @rules[:_base] if @rules.tag? :_base # special rule _base applies to all
+    end
+
+    def enqueue(sgr)       = (@queue << sgr; self)
+    def open_tag(tag)      = enqueue @layers.diffpush(@rules[tag], tag)
+    def begin_sgr          = enqueue @layers.diffpush(nil, :@@sgr)
+    def push_sgr(sgr_text) = enqueue @layers.diffpush(Layer.from Gouache.scan_sgr sgr_text)
+
+    def end_sgr
+      sgr_begun = @layers.reverse_each.find{ it.tag != nil }&.tag == :@@sgr
+      enqueue @layers.diffpop_until{ it.top.tag == :@@sgr } if sgr_begun
+      enqueue @layers.diffpop if @layers.top.tag == :@@sgr
+      self
+    end
+
+    def close_tag
+      top_is_tag = ->{ not it.top.tag in nil | :@@sgr }
+      top_is_tag[@layers] or enqueue @layers.diffpop_until(&top_is_tag)
+      top_is_tag[@layers] or raise "attempted to close tag without open tag"
+      enqueue @layers.diffpop
+    end
+
+    def << s
+      s = s.to_s
+      return self if s.empty?
+      flush
+      @out << s
+      self
+    end
+
+    private def flush
+      return self unless @enabled
+      return self unless @queue.any?
+      @flushed = Layer.from Layer.from(@queue).diff(@flushed)
+      sgr = @flushed.to_sgr(fallback: true)
+      @queue.clear
+      return self if sgr.empty?
+      @got_sgr = true
+      @out << CSI << sgr << ?m
+      self
+    end
+
+    def emit!
+      return @emitted if @emitted
+      @out << CSI << "0m" if @got_sgr # this replaces the final flush. if no sgr emitted, don't bother resetting
+      @emitted, @out = @out, nil
+      @emitted
+    end
+
+    alias to_s emit!
+
+    # for debugging
+    def pretty_print(pp)
+      fmt_layer = ->l{ "   [ %s ] %s" % [l.map{ "%2s" % it.to_s }.join(" "), l.tag] }
+      pp.group(1, "#<#{self.class}", ">") do
+        pp.breakable
+        pp.text "@layers =\n"
+        pp.text @layers.map(&fmt_layer).join("\n")
+        pp.breakable
+        pp.text "@flushed =\n"
+        pp.text fmt_layer[@flushed]
+        pp.breakable
+        pp.text "@queue = "
+        pp.pp @queue
+        pp.breakable
+        pp.text "@out = "
+        pp.pp @out
+      end
+    end
+
+  end
+end

data/lib/gouache/layer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "utils"
+require_relative "color"
+
+class Gouache
+
+  class Layer < Array
+    attr_accessor :effects
+
+    class LayerRange < RangeUnion
+      attr :label, :index, :off, :on
+
+      def initialize(xs, label:, index:)
+        @label = label
+        @index = index
+        @off   = xs.last
+        @on    = xs.first if xs.first.is_a? Integer
+        super(*xs)
+        freeze
+      end
+    end
+
+    RANGES = { # ends as { k: LayerRange, ... }; keys get used for label too
+      fg:              [30..39, 90..97, 39],
+      bg:              [40..49, 100..107, 49],
+      italic:          [ 3, 23],
+      blink:           [ 5, 25],
+      inverse:         [ 7, 27],
+      hidden:          [ 8, 28],
+      strike:          [ 9, 29],
+      overline:        [53, 55],
+      underline:       [ 4, 21, 24], # underline + double_underline
+      underline_color: [58, 59],     # affects underline + double_underline
+      bold:            [ 1, 22],
+      dim:             [ 2, 22],
+    }.zip(0..).to_h do |(k, xs), i|
+      [k, LayerRange.new(xs, index: i, label: k)]
+    end
+
+    # return array of RANGE indices that cover sgr code x
+    def RANGES.for(x) = values.filter_map{|r| r.index if r.member? x }.then{ it if it.any? }
+    RANGES.freeze
+
+    BASE = new(RANGES.values.map(&:off).tap{ it[0,2] = it[0,2].map{ Color.sgr it }}).freeze
+
+    # transforms xs into a valid array of sgr codes
+    # special handling for dim/bold:
+    # - dim/bold turn on independently but are both turned off by 22
+    # - so we move 22 in front, off code goes first so any on code that follows actually applies
+    # also convert Color to sgr
+    def self.prepare_sgr(xs, fallback: false)
+      xs = xs.compact.uniq
+      sgr22 = xs.delete(22)
+      xs.map!{ it.respond_to?(:to_sgr) ? it.to_sgr(fallback:) : it }
+      [*sgr22, *xs]
+    end
+
+    def self.empty = new(RANGES.size, nil)
+
+    # create a new layer from the given sgr codes
+    def self.from(*sgr_codes)
+      layer = empty
+      effects, sgr_codes = sgr_codes.flatten.partition { it in Proc }
+      sgr_codes.each do |sgr|
+        case sgr
+        in 0 then layer.replace BASE
+        in _ then RANGES.for(sgr.to_i)&.each{|i| layer[i] = sgr }
+        end
+      end
+      layer.effects = effects
+      layer
+    end
+
+    # return a new layer with 'top' applied on top of 'self'
+    def overlay(top)
+      case top
+      in nil   then overlay Layer.empty
+      in Layer then Layer.new zip(top).map{ _2 || _1 }
+      in _     then raise TypeError, "must be a Layer"
+      end
+    end
+
+    # return sgr codes to turn on self after other
+    def diff(other)
+      # special case: last 2 elems are bold/dim, compare as unit as both are turned off by SGR 22
+      group22 = ->a{ [*a[...-2], a[-2..]] }  # => [..., [bold, dim]]
+      diff = group22[self].zip(group22[other]).filter_map{|a,b| a if a != b }
+      diff[-1, 1] = self.class.prepare_sgr diff[-1] if diff[-1] in Array
+      diff
+    end
+
+    # return array of codes to emit for layer
+    def to_sgr(fallback: false) = self.class.prepare_sgr(self, fallback:)*?;
+
+  end
+end

data/lib/gouache/layer_proxy.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Gouache
+  class LayerProxy
+
+    Layer::RANGES.each do |k, r|
+      if k in :fg | :bg
+        define_method(k) { @layer[r.index] }
+        define_method("#{k}=") do |v|
+          @layer[r.index] = \
+          case v
+          in Color            then v
+          in String | Integer then Color.sgr(v)
+          in nil              then nil
+          end&.change_role(Color.const_get(k.to_s.upcase))
+        end
+      else # not fg bg:
+        define_method("#{k}=") {|v| @layer[r.index] = v ? r.on : r.off }
+        if k != :underline
+          define_method("#{k}?") { not @layer[r.index] in nil | ^(r.off) }
+        else # is underline:
+          define_method(:double_underline=) { @layer[r.index] = it ? 21 : r.off }
+          define_method(:underline?)        { @layer[r.index] ==  4 }
+          define_method(:double_underline?) { @layer[r.index] == 21 }
+        end # if k underline
+      end # if k fg bg
+    end # RANGES.each
+
+    def initialize(layer) = (@layer = layer)
+    def __layer = @layer
+
+  end # LayerProxy
+end # Gouache

data/lib/gouache/layer_stack.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "layer"
+require_relative "layer_proxy"
+
+class Gouache
+
+  module LayerTags
+    attr_accessor :tag
+  end
+
+  class LayerStack < Array
+    alias top last
+    alias base first
+    def base? = size == 1
+    def under = self[-2]
+
+    def initialize
+      super [Layer::BASE.dup.extend(LayerTags).freeze]
+    end
+
+    def diffpush layer, tag=nil
+      self << top.overlay(layer)
+      top.extend LayerTags
+      top.tag = tag
+      layer&.effects&.each do
+        it.arity in 1..2 or raise ArgumentError
+        it.(*[top, under].take(it.arity).map{ LayerProxy.new it })
+      end
+      top.freeze
+      top.diff(under)
+    end
+
+    def diffpop
+      return base.to_sgr if base?
+      oldpop = pop
+      top.diff(oldpop)
+    end
+
+    # pops until but not including cond
+    def diffpop_until(&cond)
+      return [] if cond[self]
+      oldtop = top
+      pop until base? || cond[self]
+      top.diff(oldtop)
+    end
+
+  end
+end

data/lib/gouache/stylesheet.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+require_relative "base"
+require_relative "layer"
+require_relative "color"
+require_relative "utils"
+
+class Gouache
+  class Stylesheet
+    attr :layer_map
+
+    def initialize styles, base:
+      raise TypeError unless base in Stylesheet | nil
+      @layer_map = base&.then{ it.layer_map.dup } || {} # styles computed into sgr code seqs spread into Layer instances for overlaying
+      @styles    = styles&.dup || {}                    # hash with declarations in many formats; will clear this as we compute rules
+      @sels      = []                                   # selector stack to avoid circular refs
+      @styles.transform_keys!(&:to_sym)
+      compute_rule(@styles.first.first) until @styles.empty?
+    end
+
+    def merge(*styles) = self.class.new(styles.inject(&:merge), base: self)
+
+    using RegexpWrap  # enable .w below. wrap it in \A\z
+    D8           = /1?\d?\d|2[0-4]\d|25[0-5]/
+    D24          = /1?\d|2[0-3]/
+    RX_INT       = /(?:#{D8})/.w
+    RX_SGR       = /[\d;]+/.w
+    RX_SEL       = /[a-z]\w*[?!]?/i.w
+    RU_BASIC     = RangeUnion.new 39, 49, 30..37, 40..47, 90..97, 100..107 # sgr basic ranges
+    RX_BASIC     = / (?: 3|4|9|10 ) [0-7] | [34]9  /x.w                    # same as above but for strings
+    RU_SGR_NC    = RangeExclusion.new 0..107, RU_BASIC, 38, 48             # no-color, valid SGRs
+    RX_EXT_COLOR = /([34]8) ; (?: 5; (#{D8}) | 2; (#{D8}) ; (#{D8}) ; (#{D8}) )/x.w
+    RX_FN_CUBE   = /(on)?#[0-5]{3}/.w
+    RX_FN_HEX    = /(on)?#(\h{6})/.w
+    RX_FN_RGB    = /(on_)? rgb  \(\s* (#{D8})  \s*,\s* (#{D8}) \s*,\s* (#{D8}) \s*\)/x.w
+    RX_FN_256    = /(on_)? 256  \(\s* (#{D8})  \s* \)/x.w
+    RX_FN_GRAY   = /(on_)? gray \(\s* (#{D24}) \s* \)/x.w
+
+    private def compute_decl(x)
+      Layer.from _compute_decl(x)
+    end
+
+    private def _compute_decl(x)
+      role = ->{ $1 ? 48 : 38 }
+      case x
+      in nil          then []
+      in Proc         then x
+      in Color        then x
+      in Layer        then x
+      in Symbol       then compute_rule(x)
+      in Array        then x.flat_map{ _compute_decl it }.partition{ Color === it }
+                            .then{|cs,rs| [*Color.merge(*cs).flatten.compact, *rs] }
+      in RU_BASIC     then Color.sgr x
+      in RX_BASIC     then Color.sgr x
+      in RX_EXT_COLOR then Color.sgr x
+      in RX_FN_HEX    then Color.new role: role[], rgb: $2
+      in RX_FN_RGB    then Color.new role: role[], rgb: $~[2..].map(&:to_i)
+      in RX_FN_CUBE   then Color.new role: role[], cube: x.scan(/\d/).map(&:to_i)
+      in RX_FN_GRAY   then Color.new role: role[], gray: $2.to_i
+      in RX_FN_256    then Color.sgr [role[], 5, $2]*?;
+      in RU_SGR_NC    then x
+      in RX_INT       then _compute_decl(x.to_i)
+      in RX_SGR       then Gouache.scan_sgr(x).map{ _compute_decl it }
+      in RX_SEL       then compute_rule(x.to_sym)
+      end
+    end
+
+    private def compute_rule(sym)
+      return @layer_map[sym] if @layer_map.key?(sym) && !@styles.key?(sym)
+      raise "circular reference for '#{sym}'" if @sels.member? sym
+      @sels << sym
+      @layer_map[sym] = compute_decl(@styles.delete sym)
+      @sels.delete sym
+      @layer_map[sym]
+    end
+
+    def tag?(key) = @layer_map.key?(key.to_sym)
+    def [](tag)   = @layer_map[tag.to_sym]
+
+    # for inspection purposes mainly
+    def tags = @layer_map.keys
+    def to_h
+      @layer_map.transform_values do |decl|
+        decl.compact.uniq.map do |slot|
+          next slot.to_sgr if slot.is_a? Color
+          slot
+        end.then{ it.size == 1 ? it[0] : it }
+      end
+    end
+
+    BASE = new BASE_STYLES, base: nil
+  end
+end

data/lib/gouache/term.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "io/console"
+require_relative "color_utils"
+
+class Gouache
+  module Term
+    extend self
+
+    RG_BASIC = (0..15)
+    RG_CUBE  = (16..231)
+    RG_GRAY  = (232..255)
+
+    ANSI16 = [ # default fallback, xterm defaults
+      [0,   0,   0],     # 0 black
+      [205, 0,   0],     # 1 red
+      [0,   205, 0],     # 2 green
+      [205, 205, 0],     # 3 yellow
+      [0,   0,   238],   # 4 blue
+      [205, 0,   205],   # 5 magenta
+      [0,   205, 205],   # 6 cyan
+      [229, 229, 229],   # 7 white
+      [127, 127, 127],   # 8 bright black
+      [255, 0,   0],     # 9 bright red
+      [0,   255, 0],     # 10 bright green
+      [255, 255, 0],     # 11 bright yellow
+      [92,  92,  255],   # 12 bright blue
+      [255, 0,   255],   # 13 bright magenta
+      [0,   255, 255],   # 14 bright cyan
+      [255, 255, 255],   # 15 bright white
+      ].freeze
+
+    def rgb8_from_ansi_cube(i)
+      raise IndexError unless RG_CUBE.cover?(i)
+      n = i - 16
+      r = n / 36
+      g = (n / 6) % 6
+      b = n % 6
+      c = ->x { x == 0 ? 0 : 55 + x * 40 }
+      [r, g, b].map(&c)
+    end
+
+    def rgb8_from_the_grays(g)
+      r1 = (0..23)  # 0-based gray index
+      r2 = RG_GRAY  # ansi index
+      g = g - r2.begin if r2.cover?(g)
+      raise IndexError, "#{g}" unless r1.cover?(g)
+      [8 + g*10] * 3
+    end
+
+    COLORS256 = (
+      ANSI16 +
+      RG_CUBE.map{ rgb8_from_ansi_cube it } +
+      RG_GRAY.map{ rgb8_from_the_grays it }
+      ).freeze
+
+    def term_seq(*seq)
+      buf = +""
+      IO.console.raw do |tty|
+        tty << seq.join
+        tty.flush
+        loop do
+          break unless tty.wait_readable(0.05)
+          buf << tty.read_nonblock(4096)
+        rescue IO::WaitReadable, EOFError
+        end
+      end
+      buf
+    end
+
+    OSC_RGB = %r_\e\]\d{1,2}(?:;(\d{1,3}))?;rgb:(\h{2})\h{2}?/(\h{2})\h{2}?/(\h{2})\h{2}?(?:\a|\e\\)_
+    def scan_colors(s, len) = s.scan(OSC_RGB).to_h{|k,*rgb| [k&.to_i, rgb.map{ it&.to_i 16 }] }.then{ it.size == len ? it : nil }
+    def scan_color(s)  = scan_colors(s, 1).values.first
+    def osc(*xs)       = term_seq OSC, xs*?;, ST
+    def rgb_for(n)     = scan_color osc(4, n, ??) # currently unused
+    def fg_color       = (@fg_color ||= scan_color osc(10, ??))
+    def bg_color       = (@bg_color ||= scan_color osc(11, ??))
+    def colors         = (@colors   ||= COLORS256.dup.tap{ it[RG_BASIC] = basic_colors }.freeze)
+    def basic_colors
+      return @basic_colors if @basic_colors
+      h = scan_colors(osc(4, *RG_BASIC.zip(Enumerator.produce{??})), RG_BASIC.size)
+      @basic_colors = (h ? RG_BASIC.map{ h[it] or raise } : ANSI16.dup).freeze
+    end
+
+    def color_level=(level)
+      raise ArgumentError unless level in :basic | :_256 | :truecolor | nil
+      @color_level = level
+    end
+
+    def color_level
+      return @color_level if @color_level
+      return :truecolor if /truecolor/i =~ ENV["COLORTERM"]
+      case ENV["TERM"]
+      when /-256color$/                 then :_256
+      when /^(xterm|screen|vt100|ansi)/ then :basic
+      else :basic # assume basic
+      # dumb term is handled by Gouache being disabled entirely
+      end
+    end
+
+    @@color_indices = {}
+    private def nearest_color(rgb, list)
+      @@color_indices[rgb] ||= list.zip(0..).sort_by do |color, i|
+        ColorUtils.oklab_distance_from_srgb8 rgb, color
+      end.first.last # first of sort, last is index
+    end
+
+    def nearest16(rgb)  = nearest_color(rgb, basic_colors)
+    def nearest256(rgb) = nearest_color(rgb, colors)
+
+  end
+end

data/lib/gouache/utils.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Gouache
+
+  module RegexpWrap
+    refine Regexp do
+      def w = /\A#{self}\z/ # wrap it in \A\z
+    end
+  end
+
+  class RangeExclusion
+    def initialize range, *excludes
+      @range = range
+      @excludes = RangeUnion.new(*excludes)
+    end
+
+    def member?(x) = @range.member?(x) && !@excludes.member?(x)
+    alias === member?
+  end
+
+  class RangeUnion
+    def initialize *xs
+      @ranges = xs.map do |x|
+        case x
+        in RangeUnion then x
+        in Range      then x
+        in Numeric    then x..x
+        end
+      end
+    end
+
+    def member?(x) = @ranges.any?{ it.member? x }
+    alias === member?
+  end
+
+end

data/lib/gouache/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Gouache
+  VERSION = "0.0.1"
+end

data/lib/gouache/wrap.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Gouache
+  module Wrap
+    refine String do
+
+      def has_sgr? = match?(/\e\[[;\d]*m/)
+      def wrapped? = start_with?(WRAP_OPEN) && end_with?(WRAP_CLOSE)
+      def wrap!    = [WRAP_OPEN, self, WRAP_CLOSE].join
+      def wrap     = has_sgr? && !wrapped? ? wrap! : self
+
+    end
+  end
+end

data/lib/gouache.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "gouache/version"
+require_relative "gouache/base"
+require_relative "gouache/layer"
+require_relative "gouache/layer_stack"
+require_relative "gouache/stylesheet"
+require_relative "gouache/emitter"
+require_relative "gouache/builder"
+require_relative "gouache/wrap"
+require_relative "gouache/term"
+require_relative "gouache/color"
+require_relative "gouache/layer_proxy"
+require "forwardable"
+
+class Gouache
+  OSC        = "\e]"
+  CSI        = "\e["
+  ST         = "\e\\"
+  CODE       = "971" # meaningless magic number
+  WRAP_SEQ   = [OSC, CODE].join
+  WRAP_OPEN  = [OSC, CODE, 1, ST].join
+  WRAP_CLOSE = [OSC, CODE, 2, ST].join
+  RX_ESC_LA  = /(?=\e)/
+  RX_SGR     = /#{Regexp.escape(CSI)}[;\d]*m/
+  RX_UNPAINT = Regexp.union RX_SGR, WRAP_OPEN, WRAP_CLOSE
+  D8         = / 1?\d?\d | 2[0-4]\d | 25[0-5] /x  # 0..255 string
+  RX_SGR_SEQ = /(?<=^|;|\[)(?: ( [34]8 ;  (?: 5 ; #{D8} | 2 (?: ; #{D8} ){3} ))  |  (#{D8}) )(?=;|m|$)/x
+
+  attr :rules
+
+  class << self
+    using Wrap
+    def scan_sgr(s) = s.scan(RX_SGR_SEQ).map{|s,d| s ? s : d.to_i }
+    def unpaint(s)  = s.gsub(RX_UNPAINT, "")
+    def wrap(s)     = s.wrap
+    alias embed wrap
+
+    extend Forwardable
+    def_delegators "::Gouache::MAIN", :enable, :disable, :reopen, :enabled?, :puts, :print, :refinement
+
+    def method_missing(m, ...)   = Builder::Proxy.for(MAIN, m, ...) || super
+    def [](*args, **styles, &b)  = (styles.empty? ? MAIN : MAIN.dup(styles:))[*args, &b]
+    def new(*args, **kvargs, &b) = (go = super and block_given? ? go.(&b) : go)
+  end
+
+  def initialize(styles:{}, io:nil, enabled:nil, **kvstyles)
+    @io      = io
+    @enabled = enabled
+    @rules   = Stylesheet::BASE.merge(styles, kvstyles)
+  end
+
+  MAIN = new # global instance
+
+  def dup(styles: nil)
+    go = self.class.new(io: @io, enabled: @enabled)
+    go.instance_variable_set(:@rules, @rules.merge(styles))
+    go
+  end
+
+  def io         = @io || $stdout
+  def enable     = tap{ @enabled = true }
+  def disable    = tap{ @enabled = false }
+  def enabled?   = !@enabled.nil? ? @enabled : io.tty? && ENV["TERM"] != "dumb"
+  def reopen(io) = tap{ @io = io }
+  def puts(*x)   = io.puts(*x.map{  printable it })
+  def print(*x)  = io.print(*x.map{ printable it })
+
+  private def printable(x)
+    return x unless x.is_a? String
+    return unpaint(x) unless enabled?
+    return repaint(x) if x.include?(WRAP_SEQ)
+    return x
+  end
+
+  def mk_emitter = Emitter.new(instance: self)
+  def repaint(s) = !enabled? ? unpaint(s) : mk_emitter.tap{ Builder.safe_emit_sgr(s, emitter: it) }.emit!
+  def unpaint(s) = self.class.unpaint(s)
+  def wrap(s)    = self.class.wrap(s)
+  alias embed wrap
+
+  def method_missing(m, ...) = Builder::Proxy.for(self, m, ...) || super
+  def [](*args, &b)          = b ? call(args, &b) : Builder.compile(args, instance: self)
+
+  def call(...)
+    raise ArgumentError unless block_given?
+    Builder::Proxy.for(self, nil, ...)
+  end
+
+  def refinement
+    instance = self
+    style_methods = instance.rules.tags
+    other_methods = %i[ unpaint repaint wrap ]
+    Module.new do
+      refine String do
+        style_methods.each{|m| define_method(m) { instance[m, self] } unless method_defined? m }
+        other_methods.each{|m| define_method(m) { instance.send m, self } unless method_defined? m }
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: gouache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Caio Chassot
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: matrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Gouache provides a powerful and flexible way to add colors and styling
+  to terminal output in Ruby applications. It supports multiple color formats (RGB,
+  OKLCH, 256-color, basic), fallback modes, custom stylesheets, refinements for String,
+  and advanced features like color shifting and effects.
+email:
+- dev@caiochassot.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- gouache.gemspec
+- lib/gouache.rb
+- lib/gouache/base.rb
+- lib/gouache/builder.rb
+- lib/gouache/color.rb
+- lib/gouache/color_utils.rb
+- lib/gouache/emitter.rb
+- lib/gouache/layer.rb
+- lib/gouache/layer_proxy.rb
+- lib/gouache/layer_stack.rb
+- lib/gouache/stylesheet.rb
+- lib/gouache/term.rb
+- lib/gouache/utils.rb
+- lib/gouache/version.rb
+- lib/gouache/wrap.rb
+homepage: https://github.com/kch/gouache
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/kch/gouache
+  source_code_uri: https://github.com/kch/gouache
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A flexible terminal color library for Ruby
+test_files: []