grmenu 3.0.0 → 4.0.2

data/{GRmenu.rb → grmenu.rb}

@@ -6,12 +6,15 @@ require 'zlib'
 require 'open3'
 
 class GRmenu
+  VERSION               = "4.0.2"
   CLEAR_SCREEN_SEQUENCE = "\e[H\e[2J\e[3J"
   HIDE_CURSOR           = "\e[?25l"
   SHOW_CURSOR           = "\e[?25h"
   CURSOR_HOME           = "\e[H"
   CLEAR_TO_EOL          = "\e[K"
   CLEAR_TO_EOS          = "\e[J"
+  ENABLE_MOUSE          = "\e[?1000h\e[?1002h\e[?1006h"
+  DISABLE_MOUSE         = "\e[?1006l\e[?1002l\e[?1000l"
 
   def self.find_data_file(filename)
     local_path = File.expand_path("data/#{filename}", __dir__)
@@ -21,6 +24,30 @@ class GRmenu
     nil
   end
 
+  def self.enable_windows_vt
+    return unless Gem.win_platform? || RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+    require 'fiddle'
+    kernel32 = Fiddle.dlopen('kernel32')
+    get_std_handle = Fiddle::Function.new(kernel32['GetStdHandle'], [Fiddle::TYPE_INT], Fiddle::TYPE_VOIDP)
+    get_console_mode = Fiddle::Function.new(kernel32['GetConsoleMode'], [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+    set_console_mode = Fiddle::Function.new(kernel32['SetConsoleMode'], [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+
+    h_out = get_std_handle.call(-11)
+    out_mode = ' ' * 4
+    if get_console_mode.call(h_out, out_mode) != 0
+      m = out_mode.unpack1('L')
+      set_console_mode.call(h_out, m | 0x0004)
+    end
+
+    h_in = get_std_handle.call(-10)
+    in_mode = ' ' * 4
+    if get_console_mode.call(h_in, in_mode) != 0
+      m = in_mode.unpack1('L')
+      set_console_mode.call(h_in, m | 0x0200)
+    end
+  rescue StandardError
+  end
+
   def self.load_json_data(filename)
     path = find_data_file(filename)
     return {} unless path && File.exist?(path)
@@ -30,9 +57,37 @@ class GRmenu
   end
 
   COLORS  = load_json_data('colors.json').freeze
-  BORDERS = load_json_data('borders.json').transform_keys(&:to_i).transform_values { |v| v.transform_keys(&:to_sym) }.freeze
+  BORDERS = load_json_data('borders.json').transform_keys(&:to_i).transform_values { |v| v.is_a?(Hash) ? v.transform_keys(&:to_sym) : { h: v.to_s, v: v.to_s, tl: v.to_s, tr: v.to_s, bl: v.to_s, br: v.to_s } }.freeze
   FONTS   = load_json_data('fonts.json').transform_keys(&:to_i).freeze
 
+  BASE_RGB = COLORS.each_with_object({}) do |(name, val), h|
+    next if name == "reset"
+    code = val.is_a?(Hash) ? (val["2"] || val[2] || val["1"] || val[1]) : val.to_s
+    if code =~ /38;2;(\d+);(\d+);(\d+)/
+      h[name] = [$1.to_i, $2.to_i, $3.to_i]
+    elsif code == "90m" || code == "30m"
+      h[name] = [100, 100, 100]
+    elsif code == "91m" || code == "31m"
+      h[name] = [255, 60, 60]
+    elsif code == "92m" || code == "32m"
+      h[name] = [60, 255, 60]
+    elsif code == "93m" || code == "33m"
+      h[name] = [255, 255, 60]
+    elsif code == "94m" || code == "34m"
+      h[name] = [60, 120, 255]
+    elsif code == "95m" || code == "35m"
+      h[name] = [255, 60, 255]
+    elsif code == "96m" || code == "36m"
+      h[name] = [60, 255, 255]
+    elsif code == "97m" || code == "37m"
+      h[name] = [250, 250, 250]
+    elsif code =~ /38;5;(\d+)/
+      h[name] = [150, 150, 150]
+    else
+      h[name] = [220, 220, 220]
+    end
+  end.freeze
+
   FONT_1  = FONTS[1] || {}
   FONT_2  = FONTS[2] || {}
   FONT_3  = FONTS[3] || {}
@@ -53,8 +108,26 @@ class GRmenu
   end
 
   def self.ansi_color(color_name, level = 1)
-    name = color_name.to_s.downcase
+    name = color_name.to_s.downcase.strip
+    if name.include?(":")
+      parts = name.split(":")
+      name = parts[0].strip
+      level = parts[1].to_i if parts[1] && !parts[1].empty?
+    end
     return rgb_color(0.0) if name == "rgb" || name == "rainbow" || name == "chroma"
+    if name =~ /\A#?([0-9a-f]{6})\z/i
+      hex = $1
+      r = hex[0..1].to_i(16)
+      g = hex[2..3].to_i(16)
+      b = hex[4..5].to_i(16)
+      return "\e[38;2;#{r};#{g};#{b}m"
+    elsif name =~ /\A#?([0-9a-f]{3})\z/i
+      hex = $1
+      r = (hex[0] * 2).to_i(16)
+      g = (hex[1] * 2).to_i(16)
+      b = (hex[2] * 2).to_i(16)
+      return "\e[38;2;#{r};#{g};#{b}m"
+    end
     lvl_str = level.to_s
     code_raw = COLORS.dig(name, lvl_str) || COLORS.dig(name, level.to_i) || COLORS[name]
     return "\e[#{code_raw}" if code_raw
@@ -68,24 +141,6 @@ class GRmenu
   module Color
     RESET = "\e[0m"
     BOLD  = "\e[1m"
-
-    CODES = {
-      black:          { 1 => "\e[30m", 2 => "\e[90m" },
-      gray:           { 1 => "\e[90m", 2 => "\e[38;5;245m" },
-      grey:           { 1 => "\e[90m", 2 => "\e[38;5;245m" },
-      red:            { 1 => "\e[31m", 2 => "\e[91m" },
-      green:          { 1 => "\e[32m", 2 => "\e[92m" },
-      yellow:         { 1 => "\e[33m", 2 => "\e[93m" },
-      blue:           { 1 => "\e[34m", 2 => "\e[94m" },
-      magenta:        { 1 => "\e[35m", 2 => "\e[95m" },
-      purple:         { 1 => "\e[38;5;129m", 2 => "\e[38;5;141m" },
-      pink:           { 1 => "\e[38;5;205m", 2 => "\e[38;5;218m" },
-      cyan:           { 1 => "\e[36m", 2 => "\e[96m" },
-      aqua:           { 1 => "\e[38;5;45m",  2 => "\e[38;5;51m" },
-      orange:         { 1 => "\e[38;5;208m", 2 => "\e[38;5;214m" },
-      white:          { 1 => "\e[37m", 2 => "\e[97m" }
-    }.freeze
-
     module_function
 
     def paint(text, color_name, level = 1)
@@ -93,7 +148,7 @@ class GRmenu
       if c_str == "rgb" || c_str == "rainbow" || c_str == "chroma"
         return rgb(text)
       end
-      code = CODES.dig(color_name.to_sym, level) || "\e[37m"
+      code = GRmenu.ansi_color(color_name, level) || "\e[37m"
       "#{code}#{text}#{RESET}"
     end
 
@@ -174,6 +229,19 @@ class GRmenu
     def bright_gray(s);    paint(s, :gray, 2);    end
     def grey(s);           gray(s);               end
 
+    def neon_red(s);       paint(s, :neon_red, 2);    end
+    def neon_green(s);     paint(s, :neon_green, 2);  end
+    def neon_cyan(s);      paint(s, :neon_cyan, 2);   end
+    def neon_blue(s);      paint(s, :neon_blue, 2);   end
+    def neon_pink(s);      paint(s, :neon_pink, 2);   end
+    def neon_yellow(s);    paint(s, :neon_yellow, 2); end
+    def neon_orange(s);    paint(s, :neon_orange, 2); end
+    def neon_purple(s);    paint(s, :neon_purple, 2); end
+    def neon_magenta(s);   paint(s, :neon_magenta, 2); end
+    def neon_aqua(s);      paint(s, :neon_aqua, 2);    end
+    def neon_lime(s);      paint(s, :neon_lime, 2);    end
+    def neon_white(s);     paint(s, :neon_white, 2);   end
+
     def r(s);  bright_red(s);     end
     def dr(s); dark_red(s);       end
     def g(s);  bright_green(s);   end
@@ -183,6 +251,26 @@ class GRmenu
     def cy(s); bright_cyan(s);    end
     def mg(s); bright_magenta(s); end
     def bl(s); bright_blue(s);    end
+
+    def hex(code, text)
+      c = GRmenu.ansi_color(code.to_s)
+      "#{c}#{text}#{RESET}"
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      GRmenu::COLORS.key?(method_name.to_s) || super
+    end
+
+    def method_missing(method_name, *args, &block)
+      m_str = method_name.to_s
+      if GRmenu::COLORS.key?(m_str)
+        text = args[0].to_s
+        lvl = args[1] || 2
+        paint(text, m_str, lvl)
+      else
+        super
+      end
+    end
   end
   C = Color
 
@@ -596,6 +684,9 @@ class GRmenu
         lines << Color.rgb("#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}", tick)
         if @title && !@title.empty?
           t_str = @title.to_s
+          if GRmenu.display_width(t_str) > inner_w
+            t_str = t_str[0...[inner_w - 3, 1].max] + "..."
+          end
           pad_t = [inner_w - GRmenu.display_width(t_str), 0].max
           l_p = " " * (pad_t / 2)
           r_p = " " * (pad_t - (pad_t / 2))
@@ -612,6 +703,9 @@ class GRmenu
         lines << "#{Color.rgb(v_l, tick)} #{bar_line} #{Color.rgb(v_r, tick)}"
         if @status && !@status.empty?
           st_str = @status.to_s
+          if GRmenu.display_width(st_str) > inner_w
+            st_str = st_str[0...[inner_w - 3, 1].max] + "..."
+          end
           pad_st = [inner_w - GRmenu.display_width(st_str), 0].max
           st_line = st_str + (" " * pad_st)
           lines << "#{Color.rgb(v_l, tick)} #{Color.gray(st_line)} #{Color.rgb(v_r, tick)}"
@@ -628,6 +722,9 @@ class GRmenu
         lines << "#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}"
         if @title && !@title.empty?
           t_str = @title.to_s
+          if GRmenu.display_width(t_str) > inner_w
+            t_str = t_str[0...[inner_w - 3, 1].max] + "..."
+          end
           pad_t = [inner_w - GRmenu.display_width(t_str), 0].max
           l_p = " " * (pad_t / 2)
           r_p = " " * (pad_t - (pad_t / 2))
@@ -637,6 +734,9 @@ class GRmenu
         lines << "#{color_code}#{v_l}#{reset_code} #{color_code}#{bar_line}#{reset_code} #{color_code}#{v_r}#{reset_code}"
         if @status && !@status.empty?
           st_str = @status.to_s
+          if GRmenu.display_width(st_str) > inner_w
+            st_str = st_str[0...[inner_w - 3, 1].max] + "..."
+          end
           pad_st = [inner_w - GRmenu.display_width(st_str), 0].max
           st_line = st_str + (" " * pad_st)
           lines << "#{color_code}#{v_l}#{reset_code} #{Color.gray(st_line)} #{color_code}#{v_r}#{reset_code}"
@@ -662,7 +762,8 @@ class GRmenu
     end
   end
 
-  def self.spinner(message = "Cargando...", color: "cyan", level: 2, delay: 0.08, &block)
+  def self.spinner(message_arg = nil, message: nil, color: "cyan", level: 2, delay: 0.08, &block)
+    actual_message = message || message_arg || "Cargando..."
     frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
     is_rgb = (color.to_s.downcase == "rgb" || color.to_s.downcase == "rainbow" || color.to_s.downcase == "chroma")
     color_code = is_rgb ? "" : ansi_color(color, level)
@@ -674,7 +775,7 @@ class GRmenu
       while !stop_spinner
         f = frames[frame_idx % frames.length]
         f_color = is_rgb ? rgb_color(frame_idx * 0.3) : color_code
-        msg_out = is_rgb ? Color.rgb(message, frame_idx * 0.1) : message
+        msg_out = is_rgb ? Color.rgb(actual_message, frame_idx * 0.1) : actual_message
         Kernel.print("\r\e[K#{f_color}#{f}#{reset_code} #{msg_out}")
         $stdout.flush
         frame_idx += 1
@@ -688,13 +789,13 @@ class GRmenu
       stop_spinner = true
       spinner_thread.join
       success_color = ansi_color("green", 2)
-      Kernel.print("\r\e[K#{success_color}[OK]#{reset_code} #{message} #{Color.gray("Listo!")}\r\n")
+      Kernel.print("\r\e[K#{success_color}[OK]#{reset_code} #{actual_message} #{Color.gray("Listo!")}\r\n")
       result
     rescue Exception => e
       stop_spinner = true
       spinner_thread.join rescue nil
       error_color = ansi_color("red", 2)
-      Kernel.print("\r\e[K#{error_color}[ERROR]#{reset_code} #{message} #{Color.bright_red("(Error: #{e.message})")}\r\n")
+      Kernel.print("\r\e[K#{error_color}[ERROR]#{reset_code} #{actual_message} #{Color.bright_red("(Error: #{e.message})")}\r\n")
       raise e
     ensure
       stop_spinner = true
@@ -702,8 +803,9 @@ class GRmenu
     end
   end
 
-  def self.progress(total = 100, title: nil, color: "cyan", level: 2, style: 3, width: nil, &block)
-    bar = ProgressBar.new(total, title: title, color: color, level: level, style: style, width: width)
+  def self.progress(total_arg = nil, total: nil, title: nil, color: "cyan", level: 2, style: 3, width: nil, &block)
+    actual_total = total || total_arg || 100
+    bar = ProgressBar.new(actual_total, title: title, color: color, level: level, style: style, width: width)
     Kernel.print(HIDE_CURSOR)
     bar.render
     begin
@@ -715,10 +817,11 @@ class GRmenu
     end
   end
 
-  def self.confirm(question = "¿Confirmar acción?", default: true, color: "cyan", style: 3)
+  def self.confirm(question_arg = nil, question: nil, default: true, color: "cyan", style: 3)
+    actual_question = question || question_arg || "¿Confirmar acción?"
     choice = default ? 0 : 1
     term_w = terminal_width
-    q_w = display_width(question)
+    q_w = display_width(actual_question)
     box_w = [q_w + 8, term_w - 4, 38].max
     box_w = [box_w, 64].min
     inner_w = box_w - 4
@@ -748,20 +851,24 @@ class GRmenu
       right_p = " " * (pad_total - (pad_total / 2))
       btn_formatted_line = "#{left_p}#{btn_yes}      #{btn_no}#{right_p}"
 
-      pad_q = [inner_w - display_width(question), 0].max
+      q_clean = actual_question.to_s
+      if display_width(q_clean) > inner_w
+        q_clean = q_clean[0...[inner_w - 3, 1].max] + "..."
+      end
+      pad_q = [inner_w - display_width(q_clean), 0].max
       q_left = " " * (pad_q / 2)
       q_right = " " * (pad_q - (pad_q / 2))
 
       lines = []
       if is_rgb
         lines << Color.rgb("#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}")
-        lines << "#{Color.rgb(v_l)} #{q_left}#{question}#{q_right} #{Color.rgb(v_r)}"
+        lines << "#{Color.rgb(v_l)} #{q_left}#{q_clean}#{q_right} #{Color.rgb(v_r)}"
         lines << "#{Color.rgb(v_l)} #{' ' * inner_w} #{Color.rgb(v_r)}"
         lines << "#{Color.rgb(v_l)} #{btn_formatted_line} #{Color.rgb(v_r)}"
         lines << Color.rgb("#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}")
       else
         lines << "#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}"
-        lines << "#{color_code}#{v_l}#{reset_code} #{q_left}#{question}#{q_right} #{color_code}#{v_r}#{reset_code}"
+        lines << "#{color_code}#{v_l}#{reset_code} #{q_left}#{q_clean}#{q_right} #{color_code}#{v_r}#{reset_code}"
         lines << "#{color_code}#{v_l}#{reset_code} #{' ' * inner_w} #{color_code}#{v_r}#{reset_code}"
         lines << "#{color_code}#{v_l}#{reset_code} #{btn_formatted_line} #{color_code}#{v_r}#{reset_code}"
         lines << "#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}"
@@ -812,54 +919,98 @@ class GRmenu
     result
   end
 
-  def self.input(prompt_text = "Ingresa un valor:", default: "", password: false, color: "cyan", style: 3)
-    text = String.new(default.to_s)
-    term_w = terminal_width
-    p_w = display_width(prompt_text)
-    box_w = [p_w + 8, term_w - 4, 42].max
-    box_w = [box_w, 64].min
-    inner_w = box_w - 4
+  def self.input(prompt_or_title = nil, title: nil, label: nil, default: "", password: false, color: nil, border_color: nil, title_color: nil, label_color: nil, style: nil, width: nil)
+    c_sec = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "input")) || {}
+    style_num = (style || c_sec["style"] || 3).to_i
+    border_cfg = BORDERS[style_num] || BORDERS[3]
 
-    border_cfg = BORDERS[style] || BORDERS[3]
     h_top = border_cfg[:ht] || border_cfg[:h]
     h_bot = border_cfg[:hb] || border_cfg[:h]
     v_l   = border_cfg[:vl] || border_cfg[:v]
     v_r   = border_cfg[:vr] || border_cfg[:v]
 
-    is_rgb = (color.to_s.downcase == "rgb" || color.to_s.downcase == "rainbow" || color.to_s.downcase == "chroma")
-    color_code = is_rgb ? "" : ansi_color(color, 2)
-    reset_code = ansi_reset
+    box_title = if title && !title.to_s.empty?
+                  title.to_s
+                elsif prompt_or_title && !label
+                  prompt_or_title.to_s
+                else
+                  c_sec["title"] || "Entrada de Datos"
+                end
+
+    input_label = if label && !label.to_s.empty?
+                    label.to_s
+                  elsif prompt_or_title && title
+                    prompt_or_title.to_s
+                  elsif c_sec["label"]
+                    c_sec["label"].to_s
+                  else
+                    "Valor:"
+                  end
+
+    brd_col_name = (border_color || color || c_sec["border_color"] || c_sec["color"] || "cyan").to_s
+    tit_col_name = (title_color || c_sec["title_color"] || "yellow").to_s
+    lbl_col_name = (label_color || c_sec["label_color"] || "white").to_s
+
+    is_rgb = (brd_col_name.downcase == "rgb" || brd_col_name.downcase == "rainbow" || brd_col_name.downcase == "chroma")
 
-    top_fill = (h_top * ((box_w - 2).to_f / h_top.length).ceil)[0...(box_w - 2)]
-    bot_fill = (h_bot * ((box_w - 2).to_f / h_bot.length).ceil)[0...(box_w - 2)]
+    text = String.new(default.to_s)
+    term_w = terminal_width
+    p_len = display_width(box_title) + 6
+    c_len = display_width(input_label) + display_width(text) + 12
+    box_w = width ? width.to_i : [p_len, c_len, 48].max
+    box_w = [box_w, term_w - 4].min
+    inner_w = [box_w - 2, 20].max
 
     drawn_lines = 0
 
     render_input = lambda do
       display_str = password ? ("*" * text.length) : text
-      input_raw = "> #{display_str}█"
-      pad_in = [inner_w - display_width(input_raw), 0].max
-      input_padded = input_raw + (" " * pad_in)
+      avail_inp_w = [inner_w - display_width(input_label) - 4, 4].max
+      if display_width(display_str) > avail_inp_w
+        display_str = "..." + display_str[-[avail_inp_w - 3, 1].max..-1]
+      end
 
-      pad_p = [inner_w - display_width(prompt_text), 0].max
-      p_left = " " * (pad_p / 2)
-      p_right = " " * (pad_p - (pad_p / 2))
+      brd_code = is_rgb ? "" : ansi_color(brd_col_name, 1)
+      tit_code = ansi_color(tit_col_name, 2)
+      lbl_code = ansi_color(lbl_col_name, 2)
+      rst = ansi_reset
 
-      lines = []
-      if is_rgb
-        lines << Color.rgb("#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}")
-        lines << "#{Color.rgb(v_l)} #{Color.bright_yellow(p_left + prompt_text + p_right)} #{Color.rgb(v_r)}"
-        lines << "#{Color.rgb(v_l)} #{' ' * inner_w} #{Color.rgb(v_r)}"
-        lines << "#{Color.rgb(v_l)} #{Color.bright_white(input_padded)} #{Color.rgb(v_r)}"
-        lines << Color.rgb("#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}")
-      else
-        lines << "#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}"
-        lines << "#{color_code}#{v_l}#{reset_code} #{Color.bright_yellow(p_left + prompt_text + p_right)} #{color_code}#{v_r}#{reset_code}"
-        lines << "#{color_code}#{v_l}#{reset_code} #{' ' * inner_w} #{color_code}#{v_r}#{reset_code}"
-        lines << "#{color_code}#{v_l}#{reset_code} #{Color.bright_white(input_padded)} #{color_code}#{v_r}#{reset_code}"
-        lines << "#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}"
-      end
+      t_clean = " #{box_title} "
+      t_w = display_width(t_clean)
+      l_pad = [(inner_w - t_w) / 2, 0].max
+      r_pad = [inner_w - t_w - l_pad, 0].max
+
+      top_fill_l = (h_top * l_pad)[0...l_pad]
+      top_fill_r = (h_top * r_pad)[0...r_pad]
+      bot_fill = (h_bot * inner_w)[0...inner_w]
+
+      top_line = if is_rgb
+                   Color.rgb("#{border_cfg[:tl]}#{top_fill_l}") + tit_code + t_clean + Color.rgb("#{top_fill_r}#{border_cfg[:tr]}")
+                 else
+                   "#{brd_code}#{border_cfg[:tl]}#{top_fill_l}#{rst}#{tit_code}#{t_clean}#{rst}#{brd_code}#{top_fill_r}#{border_cfg[:tr]}#{rst}"
+                 end
 
+      empty_line = if is_rgb
+                     Color.rgb("#{v_l}#{' ' * inner_w}#{v_r}")
+                   else
+                     "#{brd_code}#{v_l}#{rst}#{' ' * inner_w}#{brd_code}#{v_r}#{rst}"
+                   end
+
+      raw_content = " #{input_label}  #{display_str}█"
+      content_pad = [inner_w - display_width(raw_content), 0].max
+      content_line = if is_rgb
+                       "#{Color.rgb(v_l)} #{lbl_code}#{input_label}#{rst}  #{Color.bright_white(display_str)}█#{' ' * content_pad}#{Color.rgb(v_r)}"
+                     else
+                       "#{brd_code}#{v_l}#{rst} #{lbl_code}#{input_label}#{rst}  #{Color.bright_white(display_str)}█#{' ' * content_pad}#{brd_code}#{v_r}#{rst}"
+                     end
+
+      bot_line = if is_rgb
+                   Color.rgb("#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}")
+                 else
+                   "#{brd_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{rst}"
+                 end
+
+      lines = [top_line, empty_line, content_line, empty_line, bot_line]
       frame = lines.join("\r\n") + "\r\n"
       Kernel.print("\e[#{drawn_lines}A\e[J") if drawn_lines > 0
       Kernel.print(frame)
@@ -885,7 +1036,7 @@ class GRmenu
             text.clear
             render_input.call
           elsif key =~ /^[[:print:]]$/
-            text << key if text.length < (inner_w - 4)
+            text << key if display_width(text) < (inner_w - display_width(input_label) - 6)
             render_input.call
           end
         end
@@ -903,9 +1054,13 @@ class GRmenu
     text
   end
 
-  def self.checkbox(items, title: "Selección Múltiple", subtitle: "Espacio: Marcar/Desmarcar | a: Todos | n: Ninguno | i: Invertir | Enter: Confirmar", color: "cyan", style: 3, page_size: 8, min_width: nil, preselected: [])
-    item_list = items.is_a?(Array) ? items : Array(items)
+  def self.checkbox(items_arg = nil, items: nil, title: "Selección Múltiple", subtitle: "Espacio: Marcar/Desmarcar | a: Todos | n: Ninguno | i: Invertir | Enter: Confirmar", color: nil, style: nil, page_size: nil, min_width: nil, preselected: [])
+    cb_sec = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "checkbox")) || {}
+    actual_items = items || items_arg || []
+    item_list = actual_items.is_a?(Array) ? actual_items : Array(actual_items)
     return [] if item_list.empty?
+    chk_mark = cb_sec["checked_mark"] || "[X]"
+    unchk_mark = cb_sec["unchecked_mark"] || "[ ]"
 
     parsed_items = item_list.map do |it|
       case it
@@ -936,8 +1091,10 @@ class GRmenu
     index = 0
     rgb_tick = 0.0
     drawn_lines = 0
-    is_rgb = (color.to_s.downcase == "rgb" || color.to_s.downcase == "rainbow" || color.to_s.downcase == "chroma")
-    border_cfg = BORDERS[style] || BORDERS[3]
+    cb_color = (color || cb_sec["color"] || "cyan").to_s
+    style_num = (style || cb_sec["style"] || 3).to_i
+    is_rgb = (cb_color.downcase == "rgb" || cb_color.downcase == "rainbow" || cb_color.downcase == "chroma")
+    border_cfg = BORDERS[style_num] || BORDERS[3]
     h_top = border_cfg[:ht] || border_cfg[:h]
     h_bot = border_cfg[:hb] || border_cfg[:h]
     v_l = border_cfg[:vl] || border_cfg[:v]
@@ -972,8 +1129,10 @@ class GRmenu
       if is_rgb
         lines << Color.rgb("#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}", rgb_tick)
         unless title.to_s.empty?
-          pad_t = [inner_w - display_width(title), 0].max
-          t_line = (" " * (pad_t / 2)) + title + (" " * (pad_t - (pad_t / 2)))
+          t_clean = title.to_s
+          t_clean = t_clean[0...[inner_w - 3, 1].max] + "..." if display_width(t_clean) > inner_w
+          pad_t = [inner_w - display_width(t_clean), 0].max
+          t_line = (" " * (pad_t / 2)) + t_clean + (" " * (pad_t - (pad_t / 2)))
           lines << "#{Color.rgb(v_l, rgb_tick)} #{Color.rgb(t_line, rgb_tick + 0.2)} #{Color.rgb(v_r, rgb_tick)}"
           lines << Color.rgb("#{v_l}#{mid_fill}#{v_r}", rgb_tick)
         end
@@ -984,11 +1143,13 @@ class GRmenu
         end
         (start_idx..end_idx).each do |i|
           it = parsed_items[i]
-          mark = it[:checked] ? "[X]" : "[ ]"
+          mark = it[:checked] ? chk_mark : unchk_mark
           is_active = (i == index)
-          raw_line = "#{is_active ? '> ' : '  '}#{mark} #{it[:name]}"
-          pad_l = [inner_w - display_width(raw_line), 0].max
-          line_padded = raw_line + (" " * pad_l)
+          max_name_w = [inner_w - display_width(mark) - 4, 4].max
+          name_str = it[:name].to_s
+          name_str = name_str[0...[max_name_w - 3, 1].max] + "..." if display_width(name_str) > max_name_w
+          raw_line = "#{is_active ? '> ' : '  '}#{mark} #{name_str}"
+          line_padded = pad_to_width(raw_line, inner_w)
           if is_active
             lines << "#{Color.rgb(v_l, rgb_tick)} #{Color.rgb(line_padded, rgb_tick + 0.4)} #{Color.rgb(v_r, rgb_tick)}"
           elsif it[:checked]
@@ -1005,18 +1166,22 @@ class GRmenu
         end
         unless subtitle.to_s.empty?
           lines << Color.rgb("#{v_l}#{mid_fill}#{v_r}", rgb_tick)
-          pad_sub = [inner_w - display_width(subtitle), 0].max
-          sub_padded = (" " * (pad_sub / 2)) + subtitle + (" " * (pad_sub - (pad_sub / 2)))
+          s_clean = subtitle.to_s
+          s_clean = s_clean[0...[inner_w - 3, 1].max] + "..." if display_width(s_clean) > inner_w
+          pad_sub = [inner_w - display_width(s_clean), 0].max
+          sub_padded = (" " * (pad_sub / 2)) + s_clean + (" " * (pad_sub - (pad_sub / 2)))
           lines << "#{Color.rgb(v_l, rgb_tick)} #{Color.gray(sub_padded)} #{Color.rgb(v_r, rgb_tick)}"
         end
         lines << Color.rgb("#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}", rgb_tick)
       else
-        color_code = ansi_color(color, 2)
+        color_code = ansi_color(cb_color, 2)
         reset_code = ansi_reset
         lines << "#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}"
         unless title.to_s.empty?
-          pad_t = [inner_w - display_width(title), 0].max
-          t_line = (" " * (pad_t / 2)) + title + (" " * (pad_t - (pad_t / 2)))
+          t_clean = title.to_s
+          t_clean = t_clean[0...[inner_w - 3, 1].max] + "..." if display_width(t_clean) > inner_w
+          pad_t = [inner_w - display_width(t_clean), 0].max
+          t_line = (" " * (pad_t / 2)) + t_clean + (" " * (pad_t - (pad_t / 2)))
           lines << "#{color_code}#{v_l}#{reset_code} #{Color.bright_yellow(t_line)} #{color_code}#{v_r}#{reset_code}"
           lines << "#{color_code}#{v_l}#{top_fill}#{v_r}#{reset_code}"
         end
@@ -1027,15 +1192,17 @@ class GRmenu
         end
         (start_idx..end_idx).each do |i|
           it = parsed_items[i]
-          mark = it[:checked] ? "[X]" : "[ ]"
+          mark = it[:checked] ? chk_mark : unchk_mark
           is_active = (i == index)
-          raw_line = "#{is_active ? '> ' : '  '}#{mark} #{it[:name]}"
-          pad_l = [inner_w - display_width(raw_line), 0].max
-          line_padded = raw_line + (" " * pad_l)
+          max_name_w = [inner_w - display_width(mark) - 4, 4].max
+          name_str = it[:name].to_s
+          name_str = name_str[0...[max_name_w - 3, 1].max] + "..." if display_width(name_str) > max_name_w
+          raw_line = "#{is_active ? '> ' : '  '}#{mark} #{name_str}"
+          line_padded = pad_to_width(raw_line, inner_w)
           if is_active
-            lines << "#{color_code}#{v_l}#{reset_code} #{Color.bright_green(line_padded)} #{color_code}#{v_r}#{reset_code}"
+            lines << "#{color_code}#{v_l}#{reset_code} #{Color.bright_yellow(line_padded)} #{color_code}#{v_r}#{reset_code}"
           elsif it[:checked]
-            lines << "#{color_code}#{v_l}#{reset_code} #{Color.green(line_padded)} #{color_code}#{v_r}#{reset_code}"
+            lines << "#{color_code}#{v_l}#{reset_code} #{Color.bright_green(line_padded)} #{color_code}#{v_r}#{reset_code}"
           else
             lines << "#{color_code}#{v_l}#{reset_code} #{Color.white(line_padded)} #{color_code}#{v_r}#{reset_code}"
           end
@@ -1048,8 +1215,10 @@ class GRmenu
         end
         unless subtitle.to_s.empty?
           lines << "#{color_code}#{v_l}#{top_fill}#{v_r}#{reset_code}"
-          pad_sub = [inner_w - display_width(subtitle), 0].max
-          sub_padded = (" " * (pad_sub / 2)) + subtitle + (" " * (pad_sub - (pad_sub / 2)))
+          s_clean = subtitle.to_s
+          s_clean = s_clean[0...[inner_w - 3, 1].max] + "..." if display_width(s_clean) > inner_w
+          pad_sub = [inner_w - display_width(s_clean), 0].max
+          sub_padded = (" " * (pad_sub / 2)) + s_clean + (" " * (pad_sub - (pad_sub / 2)))
           lines << "#{color_code}#{v_l}#{reset_code} #{Color.gray(sub_padded)} #{color_code}#{v_r}#{reset_code}"
         end
         lines << "#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}"
@@ -1139,14 +1308,18 @@ class GRmenu
     alias_method :multiselect, :checkbox
   end
 
-  def self.slider(prompt = "Selecciona un valor:", min: 0, max: 100, step: 1, default: nil, unit: "", color: "cyan", style: 3, width: 46)
+  def self.slider(prompt_arg = nil, prompt: nil, min: 0, max: 100, step: 1, default: nil, unit: "", color: nil, style: nil, width: 46)
+    actual_prompt = prompt || prompt_arg || "Selecciona un valor:"
+    sl_sec = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "slider")) || {}
     val = (default || min).to_f.clamp(min.to_f, max.to_f)
     step_val = [step.to_f, 0.001].max
     drawn_lines = 0
     rgb_tick = 0.0
-    is_rgb = (color.to_s.downcase == "rgb" || color.to_s.downcase == "rainbow" || color.to_s.downcase == "chroma")
+    sl_color = (color || sl_sec["color"] || "cyan").to_s
+    style_num = (style || sl_sec["style"] || 3).to_i
+    is_rgb = (sl_color.downcase == "rgb" || sl_color.downcase == "rainbow" || sl_color.downcase == "chroma")
 
-    border_cfg = BORDERS[style] || BORDERS[3]
+    border_cfg = BORDERS[style_num] || BORDERS[3]
     h_top = border_cfg[:ht] || border_cfg[:h]
     h_bot = border_cfg[:hb] || border_cfg[:h]
     v_l = border_cfg[:vl] || border_cfg[:v]
@@ -1154,7 +1327,7 @@ class GRmenu
 
     render_slider = lambda do
       term_w = terminal_width
-      box_w = [width, term_w - 4, display_width(prompt) + 8, 38].max
+      box_w = [width, term_w - 4, display_width(actual_prompt) + 8, 38].max
       box_w = [box_w, term_w - 2].min
       inner_w = box_w - 4
 
@@ -1168,14 +1341,21 @@ class GRmenu
       range_span = 1.0 if range_span <= 0
       fraction = ((val - min).to_f / range_span).clamp(0.0, 1.0)
 
-      bar_w = [inner_w - val_str.length - 5, 10].max
-      filled_len = (fraction * bar_w).round
-      empty_len = bar_w - filled_len
+      avail_bar_w = [inner_w - display_width(val_str) - 4, 6].max
+      filled_len = (fraction * avail_bar_w).round
+      empty_len = [avail_bar_w - filled_len, 0].max
 
-      pad_p = [inner_w - display_width(prompt), 0].max
-      p_line = (" " * (pad_p / 2)) + prompt + (" " * (pad_p - (pad_p / 2)))
+      p_clean = actual_prompt.to_s
+      if display_width(p_clean) > inner_w
+        p_clean = p_clean[0...[inner_w - 3, 1].max] + "..."
+      end
+      pad_p = [inner_w - display_width(p_clean), 0].max
+      p_line = (" " * (pad_p / 2)) + p_clean + (" " * (pad_p - (pad_p / 2)))
 
-      instr = "← / → Ajustar | Enter Guardar"
+      instr = (inner_w >= 30) ? "← / → Ajustar | Enter Guardar" : "←/→: Ajustar | Enter: Ok"
+      if display_width(instr) > inner_w
+        instr = instr[0...[inner_w - 3, 1].max] + "..."
+      end
       pad_i = [inner_w - display_width(instr), 0].max
       i_line = (" " * (pad_i / 2)) + instr + (" " * (pad_i - (pad_i / 2)))
 
@@ -1188,22 +1368,24 @@ class GRmenu
         filled_part = Color.rgb("█" * filled_len, rgb_tick + 0.5)
         empty_part  = Color.gray("░" * empty_len)
         bar_raw = "[#{filled_part}#{empty_part}] #{Color.bright_white(val_str)}"
-        pad_b = [inner_w - (bar_w + 3 + val_str.length), 0].max
+        bar_vis_w = 2 + filled_len + empty_len + 1 + display_width(val_str)
+        pad_b = [inner_w - bar_vis_w, 0].max
         lines << "#{Color.rgb(v_l, rgb_tick)} #{bar_raw}#{' ' * pad_b} #{Color.rgb(v_r, rgb_tick)}"
         lines << "#{Color.rgb(v_l, rgb_tick)} #{' ' * inner_w} #{Color.rgb(v_r, rgb_tick)}"
         lines << "#{Color.rgb(v_l, rgb_tick)} #{Color.gray(i_line)} #{Color.rgb(v_r, rgb_tick)}"
         lines << Color.rgb("#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}", rgb_tick)
       else
-        color_code = ansi_color(color, 2)
+        color_code = ansi_color(sl_color, 2)
         reset_code = ansi_reset
 
         bar_raw = "[#{"█" * filled_len}#{"░" * empty_len}] #{val_str}"
         pad_b = [inner_w - display_width(bar_raw), 0].max
+        bar_line = bar_raw + (" " * pad_b)
 
         lines << "#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}"
         lines << "#{color_code}#{v_l}#{reset_code} #{Color.bright_yellow(p_line)} #{color_code}#{v_r}#{reset_code}"
         lines << "#{color_code}#{v_l}#{reset_code} #{' ' * inner_w} #{color_code}#{v_r}#{reset_code}"
-        lines << "#{color_code}#{v_l}#{reset_code} #{Color.bright_cyan(bar_raw)}#{' ' * pad_b} #{color_code}#{v_r}#{reset_code}"
+        lines << "#{color_code}#{v_l}#{reset_code} #{bar_line} #{color_code}#{v_r}#{reset_code}"
         lines << "#{color_code}#{v_l}#{reset_code} #{' ' * inner_w} #{color_code}#{v_r}#{reset_code}"
         lines << "#{color_code}#{v_l}#{reset_code} #{Color.gray(i_line)} #{color_code}#{v_r}#{reset_code}"
         lines << "#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}"
@@ -1280,32 +1462,47 @@ class GRmenu
   end
 
   def self.read_key_raw(input_stream)
-    unless input_stream.respond_to?(:tty?) && input_stream.tty?
-      begin
-        return input_stream.sysread(3) if input_stream.respond_to?(:sysread)
-        return input_stream.read(1)
-      rescue EOFError, Errno::EPIPE
-        return nil
-      end
+    is_tty = input_stream.respond_to?(:tty?) && input_stream.tty?
+    first_char = nil
+    begin
+      first_char = is_tty ? input_stream.getch : input_stream.read(1)
+    rescue EOFError, Errno::EPIPE
+      return nil
     end
-
-    first_char = input_stream.getch
     return nil if first_char.nil?
 
     if first_char == "\e"
-      begin
-        extra_chars = input_stream.read_nonblock(2)
-        first_char << extra_chars
-      rescue IO::WaitReadable, IO::EAGAINWaitReadable, EOFError
+      seq = first_char.dup
+      if is_tty
+        while (ch = (input_stream.getch(min: 0, time: 0.1) rescue nil))
+          seq << ch
+          break if seq =~ /[a-zA-Z~]\z/
+        end
+      else
+        while (IO.select([input_stream], nil, nil, 0.05) rescue nil)
+          ch = (input_stream.read(1) rescue nil)
+          break if ch.nil?
+          seq << ch
+          break if seq =~ /[a-zA-Z~]\z/
+        end
       end
-    elsif first_char == "\x00" || first_char == "\xe0"
-      begin
-        second_char = input_stream.read_nonblock(1)
-        first_char << second_char
-      rescue IO::WaitReadable, IO::EAGAINWaitReadable, EOFError
-        second_char = input_stream.getch rescue nil
-        first_char << second_char if second_char
+
+      if seq == "\e[M"
+        cb = is_tty ? (input_stream.getch(min: 0, time: 0.1) rescue nil) : (input_stream.read(1) rescue nil)
+        cx = is_tty ? (input_stream.getch(min: 0, time: 0.1) rescue nil) : (input_stream.read(1) rescue nil)
+        cy = is_tty ? (input_stream.getch(min: 0, time: 0.1) rescue nil) : (input_stream.read(1) rescue nil)
+        if cb && cx && cy
+          btn_c = cb.ord - 32
+          col_c = cx.ord - 32
+          row_c = cy.ord - 32
+          return "\e[<#{btn_c};#{col_c};#{row_c}M"
+        end
       end
+
+      return seq
+    elsif first_char == "\x00" || first_char == "\xe0"
+      second_char = is_tty ? (input_stream.getch(min: 0, time: 0.1) rescue nil) : (input_stream.read(1) rescue nil)
+      return first_char + second_char if second_char
     end
 
     first_char
@@ -1322,7 +1519,8 @@ class GRmenu
       banner:   { color: "magenta", level: 2 },
       subtitle: { color: "cyan",    level: 2 },
       divider:  { color: "blue",    level: 1 },
-      font:     1
+      font:     1,
+      desc_prefix: "[i]"
     )
       @border   = border.dup
       @options  = options.dup
@@ -1332,11 +1530,22 @@ class GRmenu
       @subtitle = subtitle.dup
       @divider  = divider.dup
       @font     = font.to_i
+      @desc_prefix = desc_prefix.to_s
+    end
+
+    def desc_prefix(prefix_str = nil)
+      return @desc_prefix if prefix_str.nil?
+      @desc_prefix = prefix_str.to_s
+      self
     end
+    alias_method :description_prefix, :desc_prefix
+    alias_method :desc_prefix=, :desc_prefix
+    alias_method :description_prefix=, :desc_prefix
 
     def border(color_name = nil, brightness_level = 1)
       return @border if color_name.nil?
       @border = parse_color(color_name, brightness_level)
+      self
     end
     alias_method :Border, :border
     alias_method :set_border, :border
@@ -1345,6 +1554,7 @@ class GRmenu
     def options(color_name = nil, brightness_level = 1)
       return @options if color_name.nil?
       @options = parse_color(color_name, brightness_level)
+      self
     end
     alias_method :Options, :options
     alias_method :set_options, :options
@@ -1353,6 +1563,7 @@ class GRmenu
     def focus(color_name = nil, brightness_level = 2)
       return @focus if color_name.nil?
       @focus = parse_color(color_name, brightness_level)
+      self
     end
     alias_method :Focus, :focus
     alias_method :set_focus, :focus
@@ -1361,6 +1572,7 @@ class GRmenu
     def title(color_name = nil, brightness_level = 2)
       return @title if color_name.nil?
       @title = parse_color(color_name, brightness_level)
+      self
     end
     alias_method :Title, :title
     alias_method :set_title, :title
@@ -1369,6 +1581,7 @@ class GRmenu
     def banner(color_name = nil, brightness_level = 2)
       return @banner if color_name.nil?
       @banner = parse_color(color_name, brightness_level)
+      self
     end
     alias_method :Banner, :banner
     alias_method :set_banner, :banner
@@ -1377,6 +1590,7 @@ class GRmenu
     def subtitle(color_name = nil, brightness_level = 2)
       return @subtitle if color_name.nil?
       @subtitle = parse_color(color_name, brightness_level)
+      self
     end
     alias_method :Subtitle, :subtitle
     alias_method :set_subtitle, :subtitle
@@ -1385,6 +1599,7 @@ class GRmenu
     def divider(color_name = nil, brightness_level = 1)
       return @divider if color_name.nil?
       @divider = parse_color(color_name, brightness_level)
+      self
     end
     alias_method :Divider, :divider
     alias_method :set_divider, :divider
@@ -1393,6 +1608,7 @@ class GRmenu
     def font(font_id = nil)
       return @font if font_id.nil?
       @font = font_id.to_i
+      self
     end
     alias_method :Font, :font
     alias_method :set_font, :font
@@ -1473,6 +1689,15 @@ class GRmenu
       alias_method :Font, :font
       alias_method :set_font, :font
       alias_method :font=, :font
+
+      def desc_prefix(prefix_str = nil)
+        @default_desc_prefix ||= "[i]"
+        return @default_desc_prefix if prefix_str.nil?
+        @default_desc_prefix = prefix_str.to_s
+      end
+      alias_method :description_prefix, :desc_prefix
+      alias_method :desc_prefix=, :desc_prefix
+      alias_method :description_prefix=, :desc_prefix
     end
   end
 
@@ -1524,6 +1749,713 @@ class GRmenu
     alias_method :clr, :clear_screen
   end
 
+  @@global_theme = {}
+
+  def self.current_theme
+    @@global_theme
+  end
+
+  def self.parse_config_text(text)
+    data = { global: {}, sections: {} }
+    current_sec = nil
+    current_sec_data = {}
+
+    text.to_s.each_line do |line|
+      line = line.strip
+      next if line.empty? || line.start_with?("#")
+      next if line.start_with?("GRmenu::config")
+
+      if line.start_with?("<<")
+        sec_name = line[2..-1].strip.downcase
+        current_sec = sec_name
+        current_sec_data = {}
+      elsif line == ">>"
+        if current_sec
+          data[:sections][current_sec] = current_sec_data
+          current_sec = nil
+        end
+      elsif line.include?("::")
+        key, _, val = line.partition("::")
+        key = key.strip.sub(/^@/, '').downcase
+        val = val.strip.sub(/^["']/, '').sub(/["']$/, '')
+        if current_sec
+          current_sec_data[key] = val
+        else
+          data[:global][key] = val
+        end
+      end
+    end
+    data
+  end
+
+  def self.find_theme_file(path_or_name)
+    name = path_or_name.to_s
+    candidates = [
+      name,
+      "#{name}.gr",
+      find_data_file("themes/#{name}.gr"),
+      find_data_file("themes/#{name}"),
+      File.expand_path("data/themes/#{name}.gr", __dir__),
+      File.expand_path("data/themes/#{name}", __dir__),
+      File.expand_path("../data/themes/#{name}.gr", __dir__),
+      File.expand_path("../data/themes/#{name}", __dir__)
+    ].compact
+    candidates.find { |p| File.exist?(p) }
+  end
+
+  def self.import_config(path_or_name)
+    path = find_theme_file(path_or_name)
+    raise "No se encontro el tema: #{path_or_name}" unless path && File.exist?(path)
+    text = File.read(path)
+    parsed = parse_config_text(text)
+    apply_parsed_theme(parsed)
+    @@global_theme = parsed
+    path
+  end
+
+  def self.theme(name)
+    import_config(name)
+  end
+
+  def self.extract_color_and_level(val, default_level = 1)
+    return ["white", default_level] if val.nil?
+    parts = val.to_s.split(":")
+    c_name = parts[0].to_s.strip
+    lvl = parts[1] ? parts[1].to_i : default_level
+    [c_name, lvl]
+  end
+
+  def self.apply_parsed_theme(parsed)
+    sec = parsed[:sections] || {}
+    glob = parsed[:global] || {}
+    m = (sec["menu"] || {}).merge(glob)
+
+    if m && !m.empty?
+      if m["border"] || m["border_color"]
+        c, l = extract_color_and_level(m["border"] || m["border_color"], 1)
+        SetStyle.border(c, l)
+      end
+      if m["title"] || m["title_color"]
+        c, l = extract_color_and_level(m["title"] || m["title_color"], 2)
+        SetStyle.title(c, l)
+      end
+      if m["focus"] || m["focus_color"]
+        c, l = extract_color_and_level(m["focus"] || m["focus_color"], 2)
+        SetStyle.focus(c, l)
+      end
+      if m["options"] || m["options_color"]
+        c, l = extract_color_and_level(m["options"] || m["options_color"], 1)
+        SetStyle.options(c, l)
+      end
+      if m["banner"] || m["banner_color"]
+        c, l = extract_color_and_level(m["banner"] || m["banner_color"], 2)
+        SetStyle.banner(c, l)
+      end
+      if m["subtitle"] || m["subtitle_color"]
+        c, l = extract_color_and_level(m["subtitle"] || m["subtitle_color"], 1)
+        SetStyle.subtitle(c, l)
+      end
+      if m["divider"] || m["divider_color"]
+        c, l = extract_color_and_level(m["divider"] || m["divider_color"], 1)
+        SetStyle.divider(c, l)
+      end
+      if m["desc_prefix"] || m["description_prefix"] || m["prefix"]
+        SetStyle.desc_prefix(m["desc_prefix"] || m["description_prefix"] || m["prefix"])
+      end
+      SetStyle.font(m["font"].to_i) if m["font"]
+    end
+
+    sec.each do |k, v|
+      next unless v.is_a?(Hash)
+      c_val = v["color"] || v["border"] || v["options"] || v["focus"] || v["title"] || v["banner"] || v["subtitle"] || v["divider"]
+      c, l = extract_color_and_level(c_val, (v["level"] || 1).to_i)
+      case k
+      when "border"
+        SetStyle.border(c, l)
+      when "options"
+        SetStyle.options(c, l)
+      when "focus"
+        SetStyle.focus(c, l)
+      when "title"
+        SetStyle.title(c, l)
+      when "banner"
+        SetStyle.banner(c, l)
+      when "subtitle"
+        SetStyle.subtitle(c, l)
+      when "divider"
+        SetStyle.divider(c, l)
+      end
+    end
+    SetStyle.font(glob["font"].to_i) if glob["font"]
+  end
+
+  def self.style(css_content)
+    parsed = parse_config_text(css_content)
+    apply_parsed_theme(parsed)
+    parsed
+  end
+
+  def self.export_config(path = nil)
+    if path.nil?
+      caller_loc = caller_locations.find { |c| !c.path.include?(__FILE__) }
+      base = caller_loc ? caller_loc.path.sub(/\.rb$/, '') : "theme"
+      path = "#{base}.gr"
+    end
+    lines = ["GRmenu::config<-1->", ""]
+    lines << "@theme:: \"#{File.basename(path, '.gr').capitalize}\""
+    lines << "@author:: \"grcode\""
+    lines << "@version:: \"1.0\""
+    lines << ""
+    lines << "<<menu"
+    lines << "  style:: 3"
+    lines << "  banner_style:: 3"
+    lines << "  font:: #{SetStyle.font}"
+    lines << "  animate:: rgb"
+    lines << "  center:: true"
+    lines << "  border:: #{SetStyle.border[:color]}:#{SetStyle.border[:level]}"
+    lines << "  title:: #{SetStyle.title[:color]}:#{SetStyle.title[:level]}"
+    lines << "  focus:: #{SetStyle.focus[:color]}:#{SetStyle.focus[:level]}"
+    lines << "  options:: #{SetStyle.options[:color]}:#{SetStyle.options[:level]}"
+    lines << "  banner:: #{SetStyle.banner[:color]}:#{SetStyle.banner[:level]}"
+    lines << "  subtitle:: #{SetStyle.subtitle[:color]}:#{SetStyle.subtitle[:level]}"
+    lines << "  divider:: #{SetStyle.divider[:color]}:#{SetStyle.divider[:level]}"
+    lines << ">>"
+    lines << ""
+    lines << "<<table"
+    lines << "  style:: 3"
+    lines << "  header_color:: yellow:2"
+    lines << "  border_color:: rgb:2"
+    lines << "  selected_row:: green:2"
+    lines << "  row_color:: white:1"
+    lines << "  zebra_striping:: true"
+    lines << ">>"
+    lines << ""
+    lines << "<<card"
+    lines << "  style:: 7"
+    lines << "  border_color:: cyan:2"
+    lines << "  title_color:: yellow:2"
+    lines << "  content_color:: white:1"
+    lines << ">>"
+    lines << ""
+    lines << "<<slider"
+    lines << "  style:: 3"
+    lines << "  color:: rgb:2"
+    lines << "  fill_char:: █"
+    lines << "  empty_char:: ░"
+    lines << ">>"
+    lines << ""
+    lines << "<<checkbox"
+    lines << "  style:: 3"
+    lines << "  color:: rgb:2"
+    lines << "  checked_mark:: [X]"
+    lines << "  unchecked_mark:: [ ]"
+    lines << ">>"
+    lines << ""
+    File.write(path, lines.join("\n") + "\n")
+    path
+  end
+
+  def self.export_from_file(source_file, target_path = nil)
+    raise "No existe #{source_file}" unless File.exist?(source_file)
+    orig_draw = instance_method(:draw) rescue nil
+    extracted = nil
+    define_method(:draw) do |*|
+      extracted = {
+        style: @style,
+        banner_style: @banner_style,
+        font: @style_config&.font,
+        animate: @animate,
+        border: @style_config&.border,
+        title: @style_config&.title,
+        focus: @style_config&.focus,
+        options: @style_config&.options,
+        banner: @style_config&.banner,
+        subtitle: @style_config&.subtitle,
+        divider: @style_config&.divider
+      }
+      throw :grmenu_export_completed
+    end
+    begin
+      catch(:grmenu_export_completed) do
+        load(File.expand_path(source_file))
+      end
+    ensure
+      define_method(:draw, orig_draw) if orig_draw
+    end
+    out = target_path || source_file.sub(/\.rb$/, '') + ".gr"
+    if extracted && extracted[:border]
+      lines = ["GRmenu::config<-1->", ""]
+      lines << "@theme:: \"#{File.basename(out, '.gr').capitalize}\""
+      lines << "@author:: \"grcode\""
+      lines << "@version:: \"1.0\""
+      lines << ""
+      lines << "<<menu"
+      lines << "  style:: #{extracted[:style] || 3}"
+      lines << "  banner_style:: #{extracted[:banner_style] || 3}"
+      lines << "  font:: #{extracted[:font] || 1}"
+      lines << "  animate:: #{extracted[:animate] || 'rgb'}"
+      lines << "  center:: true"
+      lines << "  border:: #{extracted[:border][:color]}:#{extracted[:border][:level]}"
+      lines << "  title:: #{extracted[:title][:color]}:#{extracted[:title][:level]}"
+      lines << "  focus:: #{extracted[:focus][:color]}:#{extracted[:focus][:level]}"
+      lines << "  options:: #{extracted[:options][:color]}:#{extracted[:options][:level]}"
+      lines << "  banner:: #{extracted[:banner][:color]}:#{extracted[:banner][:level]}"
+      lines << "  subtitle:: #{extracted[:subtitle][:color]}:#{extracted[:subtitle][:level]}"
+      lines << "  divider:: #{extracted[:divider][:color]}:#{extracted[:divider][:level]}"
+      lines << ">>"
+      lines << ""
+      lines << "<<table"
+      lines << "  style:: #{extracted[:style] || 3}"
+      lines << "  header_color:: yellow:2"
+      lines << "  border_color:: rgb:2"
+      lines << "  selected_row:: green:2"
+      lines << "  row_color:: white:1"
+      lines << "  zebra_striping:: true"
+      lines << ">>"
+      lines << ""
+      lines << "<<card"
+      lines << "  style:: 7"
+      lines << "  border_color:: cyan:2"
+      lines << "  title_color:: yellow:2"
+      lines << "  content_color:: white:1"
+      lines << ">>"
+      lines << ""
+      lines << "<<slider"
+      lines << "  style:: 3"
+      lines << "  color:: rgb:2"
+      lines << "  fill_char:: █"
+      lines << "  empty_char:: ░"
+      lines << ">>"
+      lines << ""
+      lines << "<<checkbox"
+      lines << "  style:: 3"
+      lines << "  color:: rgb:2"
+      lines << "  checked_mark:: [X]"
+      lines << "  unchecked_mark:: [ ]"
+      lines << ">>"
+      lines << ""
+      File.write(out, lines.join("\n") + "\n")
+      out
+    else
+      export_config(out)
+    end
+  end
+
+  def self.split_ansi_chars(str)
+    segments = []
+    current_style = String.new("")
+    in_escape = false
+    escape_buf = String.new("")
+
+    str.to_s.each_char do |ch|
+      if ch == "\e"
+        in_escape = true
+        escape_buf << ch
+        next
+      end
+      if in_escape
+        escape_buf << ch
+        if ch =~ /[a-zA-Z]/
+          in_escape = false
+          current_style = escape_buf.dup
+          escape_buf.clear
+        end
+        next
+      end
+      segments << { char: ch, style: current_style.dup }
+    end
+    segments
+  end
+
+  def self.animate_render(lines, type = :diagonal, delay = 0.012)
+    type_str = type.to_s.downcase
+    return if lines.nil? || lines.empty?
+    rst = ansi_reset
+
+    case type_str
+    when "diagonal"
+      parsed_rows = lines.map { |l| split_ansi_chars(l) }
+      max_len = parsed_rows.map(&:length).max || 0
+      total_steps = max_len + (parsed_rows.length * 2)
+      step = 0
+      while step <= total_steps
+        buffer = String.new(CURSOR_HOME)
+        parsed_rows.each_with_index do |row_segs, y|
+          rendered_row = String.new("")
+          row_segs.each_with_index do |seg, x|
+            if (x + y * 2) <= step
+              rendered_row << seg[:style] << seg[:char] << rst
+            else
+              rendered_row << " "
+            end
+          end
+          buffer << rendered_row << CLEAR_TO_EOL << "\r\n"
+        end
+        buffer << CLEAR_TO_EOS
+        Kernel.print(buffer)
+        $stdout.flush
+        sleep(delay)
+        step += 4
+      end
+    when "linear"
+      buffer = String.new(CURSOR_HOME)
+      lines.each do |line|
+        Kernel.print("#{line}#{CLEAR_TO_EOL}\r\n")
+        $stdout.flush
+        sleep(delay * 3)
+      end
+    when "fade"
+      [1, 2].each do |lvl|
+        buffer = String.new(CURSOR_HOME)
+        lines.each do |line|
+          clean = line.gsub(/\e\[[0-9;]*m/, '')
+          buffer << ansi_color("white", lvl) << clean << rst << CLEAR_TO_EOL << "\r\n"
+        end
+        buffer << CLEAR_TO_EOS
+        Kernel.print(buffer)
+        $stdout.flush
+        sleep(delay * 8)
+      end
+    end
+  end
+
+  def self.alert(type, message, title: nil, style: 3, color: nil, border_color: nil, title_color: nil, pause: true)
+    type_sym = type.to_sym rescue :info
+    tag, def_col, def_title = case type_sym
+                              when :success, :ok
+                                ["[✔ EXITO]", "green", "Operacion Exitosa"]
+                              when :error, :fail, :danger
+                                ["[✖ ERROR]", "red", "Error en el Sistema"]
+                              when :warning, :warn
+                                ["[⚠ AVISO]", "yellow", "Advertencia"]
+                              else
+                                ["[ℹ INFO]", "cyan", "Informacion"]
+                              end
+    card_col = border_color || color || def_col
+    card_title = title || "#{tag} #{def_title}"
+    card(title: card_title, content: message, style: style, color: card_col, title_color: title_color, pause: pause)
+  end
+
+  def self.card(title_or_content = nil, content_arg = nil, title: nil, content: nil, style: nil, color: nil, border_color: nil, title_color: nil, content_color: nil, width: nil, pause: false)
+    c_sec = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "card")) || {}
+    actual_title = title || (content_arg ? title_or_content : nil)
+    actual_content = (content || (content_arg ? content_arg : title_or_content) || "").to_s
+    style_num = (style || c_sec["style"] || 7).to_i
+    border_cfg = BORDERS[style_num] || BORDERS[7]
+    card_color = (border_color || color || c_sec["border_color"] || c_sec["color"] || "cyan").to_s
+    actual_title_color = (title_color || c_sec["title_color"] || "yellow").to_s
+    actual_content_color = (content_color || c_sec["content_color"] || "white").to_s
+    is_rgb = card_color.downcase == "rgb" || card_color.downcase == "rainbow" || card_color.downcase == "chroma"
+
+    lines = actual_content.split("\n")
+    content_max = lines.map { |l| display_width(l) }.max || 0
+    box_w = width || [content_max + 6, actual_title ? display_width(actual_title) + 6 : 0, 46].max
+    box_w = [box_w, terminal_width - 2].min
+    inner_w = box_w - 2
+
+    wrapped_lines = []
+    lines.each do |raw_l|
+      if display_width(raw_l) <= (inner_w - 2)
+        wrapped_lines << raw_l
+      else
+        cur = String.new("")
+        raw_l.split(" ").each do |w|
+          if cur.empty?
+            cur << w
+          elsif display_width("#{cur} #{w}") <= (inner_w - 2)
+            cur << " " << w
+          else
+            wrapped_lines << cur
+            cur = String.new(w)
+          end
+        end
+        wrapped_lines << cur unless cur.empty?
+      end
+    end
+
+    tl = border_cfg[:tl] || "#"
+    tr = border_cfg[:tr] || "#"
+    bl = border_cfg[:bl] || "#"
+    br = border_cfg[:br] || "#"
+    h_char = border_cfg[:h] || "─"
+    v_char = border_cfg[:v] || "│"
+
+    brd_col = is_rgb ? Color.rgb("").sub(/\e\[0m$/, '') : ansi_color(card_color, 1)
+    rst = ansi_reset
+
+    top_str = if actual_title && !actual_title.empty?
+                t_clean = " #{actual_title} "
+                t_len = display_width(t_clean)
+                if t_len > inner_w
+                  t_clean = " #{actual_title[0...[inner_w - 6, 1].max]}... "
+                  t_len = display_width(t_clean)
+                end
+                l_len = [(inner_w - t_len) / 2, 0].max
+                r_len = [inner_w - t_len - l_len, 0].max
+                h_char * l_len + ansi_color(actual_title_color, 2) + t_clean + brd_col + h_char * r_len
+              else
+                h_char * inner_w
+              end
+
+    out = +""
+    out << "#{brd_col}#{tl}#{top_str}#{tr}#{rst}\r\n"
+    wrapped_lines.each do |line|
+      pad_line = " " + line
+      out << "#{brd_col}#{v_char}#{rst}#{ansi_color(actual_content_color, 1)}#{pad_to_width(pad_line, inner_w)}#{rst}#{brd_col}#{v_char}#{rst}\r\n"
+    end
+    out << "#{brd_col}#{bl}#{h_char * inner_w}#{br}#{rst}\r\n"
+
+    Kernel.print(out)
+    self.continue if pause
+  end
+
+  def self.table(headers_arg = nil, rows_arg = nil, headers: nil, rows: nil, title: nil, style: nil, color: nil, header_color: nil, border_color: nil, selected_row: nil, page_size: nil, search: false, sort: false, animate: nil, width: nil, **kwargs)
+    t_sec = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "table")) || {}
+    input_stream = $stdin
+    output_stream = $stdout
+    style_num = (style || t_sec["style"] || 3).to_i
+    border_cfg = BORDERS[style_num] || BORDERS[3]
+    tbl_color = (border_color || color || t_sec["border_color"] || t_sec["border"] || t_sec["color"] || "cyan").to_s
+    header_color = header_color || t_sec["header_color"] || "yellow"
+    focus_color = selected_row || t_sec["selected_row"] || t_sec["focus"] || "green"
+    page_size ||= (t_sec["page_size"] || 8).to_i
+
+    resolved_headers = (headers || headers_arg || []).map(&:to_s)
+    resolved_raw_rows = (rows || rows_arg || []).map { |r| r.is_a?(Array) ? r.map(&:to_s) : r.values.map(&:to_s) }
+    headers = resolved_headers
+    raw_rows = resolved_raw_rows
+    filtered_rows = raw_rows.dup
+    selected_idx = 0
+    query = String.new("")
+    sort_col = nil
+    sort_asc = true
+    tick = 0.0
+
+    calc_widths = lambda do
+      col_counts = [headers.length, raw_rows.map(&:length).max || 0].max
+      widths = Array.new(col_counts, 0)
+      headers.each_with_index { |h, i| widths[i] = [widths[i], display_width(h)].max }
+      filtered_rows.each do |row|
+        row.each_with_index { |cell, i| widths[i] = [widths[i], display_width(cell)].max }
+      end
+      widths.map { |w| w + 2 }
+    end
+
+    draw_table = lambda do |t_tick|
+      is_rgb = tbl_color.downcase == "rgb" || tbl_color.downcase == "rainbow" || tbl_color.downcase == "chroma"
+      brd_color = is_rgb ? rgb_color(t_tick, 0.0) : ansi_color(tbl_color, 1)
+      hdr_color = is_rgb ? rgb_color(t_tick, 0.8) : ansi_color(header_color, 2)
+      foc_color = is_rgb ? rgb_color(t_tick, 1.4) : ansi_color(focus_color, 2)
+      rst = ansi_reset
+
+      col_w = calc_widths.call
+      help_line = " ↑/↓: Moverse | Enter: Elegir | s: Ordenar | Esc: Salir"
+      tot_w = [col_w.sum + (col_w.length - 1) + 4, title ? display_width(title) + 8 : 0, display_width(help_line) + 4, 46].max
+      tot_w = [tot_w, terminal_width - 2].min
+      inner_w = tot_w - 2
+
+      if inner_w < display_width(help_line)
+        help_line = " ↑/↓: Mover | Enter: Ok | Esc: Salir"
+      end
+
+      tl = border_cfg[:tl] || "#"
+      tr = border_cfg[:tr] || "#"
+      bl = border_cfg[:bl] || "#"
+      br = border_cfg[:br] || "#"
+      h_char = border_cfg[:h] || "─"
+      v_char = border_cfg[:v] || "│"
+
+      top_str = if title && !title.empty?
+                  t_clean = " #{title} "
+                  t_len = display_width(t_clean)
+                  if t_len > inner_w
+                    t_clean = " #{title[0...[(inner_w - 6), 1].max]}... "
+                    t_len = display_width(t_clean)
+                  end
+                  left_len = [(inner_w - t_len) / 2, 0].max
+                  right_len = [inner_w - t_len - left_len, 0].max
+                  h_char * left_len + t_clean + h_char * right_len
+                else
+                  h_char * inner_w
+                end
+
+      out = String.new(CURSOR_HOME)
+      out << HIDE_CURSOR
+      out << "#{brd_color}#{tl}#{top_str}#{tr}#{rst}#{CLEAR_TO_EOL}\r\n"
+
+      if search
+        s_line = " Buscar: #{query}█"
+        out << "#{brd_color}#{v_char}#{rst}#{pad_to_width(s_line, inner_w)}#{brd_color}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+        out << "#{brd_color}#{v_char}#{h_char * inner_w}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+      end
+
+      hdr_cells = headers.each_with_index.map do |h, i|
+        w = col_w[i] || 10
+        sort_indicator = sort_col == i ? (sort_asc ? " ▲" : " ▼") : ""
+        h_str = "#{h}#{sort_indicator}"
+        max_c = [w - 2, 2].max
+        h_str = h_str[0...[max_c - 2, 1].max] + ".." if display_width(h_str) > max_c
+        pad_to_width(" #{h_str}", w)
+      end
+      hdr_row_str = " " + hdr_cells.join("│")
+      hdr_row_str = hdr_row_str[0...inner_w] if display_width(hdr_row_str) > inner_w
+      out << "#{brd_color}#{v_char}#{rst}#{hdr_color}#{pad_to_width(hdr_row_str, inner_w)}#{rst}#{brd_color}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+      out << "#{brd_color}#{v_char}#{h_char * inner_w}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+
+      max_visible = page_size || 8
+      total_rows = filtered_rows.length
+      if total_rows == 0
+        empty_msg = " (Sin registros que coincidan con '#{query}')"
+        out << "#{brd_color}#{v_char}#{rst}#{pad_to_width(empty_msg, inner_w)}#{brd_color}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+      else
+        start_idx = [(selected_idx - max_visible / 2), 0].max
+        start_idx = [start_idx, [total_rows - max_visible, 0].max].min
+        end_idx = [start_idx + max_visible - 1, total_rows - 1].min
+
+        if start_idx > 0
+          up_str = " ▲ (+#{start_idx} arriba)"
+          out << "#{brd_color}#{v_char}#{rst}#{ansi_color('gray', 1)}#{pad_to_width(up_str, inner_w)}#{rst}#{brd_color}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+        end
+
+        (start_idx..end_idx).each do |r_i|
+          row = filtered_rows[r_i]
+          is_active = (r_i == selected_idx)
+          prefix = is_active ? "> " : "  "
+
+          row_cells = row.each_with_index.map do |cell, c_i|
+            w = col_w[c_i] || 10
+            c_str = cell.to_s
+            max_c = [w - 2, 2].max
+            c_str = c_str[0...[max_c - 2, 1].max] + ".." if display_width(c_str) > max_c
+            pad_to_width(" #{c_str}", w)
+          end
+          row_str = prefix + row_cells.join("│")[1..-1].to_s
+          row_str = row_str[0...inner_w] if display_width(row_str) > inner_w
+
+          if is_active
+            out << "#{brd_color}#{v_char}#{rst}#{foc_color}#{pad_to_width(row_str, inner_w)}#{rst}#{brd_color}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+          else
+            out << "#{brd_color}#{v_char}#{rst}#{pad_to_width(row_str, inner_w)}#{brd_color}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+          end
+        end
+
+        remaining_down = total_rows - 1 - end_idx
+        if remaining_down > 0
+          down_str = " ▼ (+#{remaining_down} abajo)"
+          out << "#{brd_color}#{v_char}#{rst}#{ansi_color('gray', 1)}#{pad_to_width(down_str, inner_w)}#{rst}#{brd_color}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+        end
+      end
+
+      out << "#{brd_color}#{v_char}#{h_char * inner_w}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+      out << "#{brd_color}#{v_char}#{rst}#{ansi_color('gray', 1)}#{pad_to_width(help_line, inner_w)}#{rst}#{brd_color}#{v_char}#{rst}#{CLEAR_TO_EOL}\r\n"
+      out << "#{brd_color}#{bl}#{h_char * inner_w}#{br}#{rst}#{CLEAR_TO_EOL}\r\n"
+      out << CLEAR_TO_EOS
+      output_stream.print(out)
+      output_stream.flush
+    end
+
+    loop_res = nil
+    reader = lambda do |stream|
+      loop do
+        draw_table.call(tick)
+        is_anim = color.to_s.downcase == "rgb" || color.to_s.downcase == "rainbow" || color.to_s.downcase == "chroma"
+        if is_anim
+          ready = false
+          if stream.respond_to?(:to_io) || stream.is_a?(IO)
+            begin
+              res = IO.select([stream], nil, nil, 0.035)
+              ready = true if res && res[0] && !res[0].empty?
+            rescue StandardError
+              ready = true
+            end
+          else
+            ready = true
+          end
+          unless ready
+            tick += 0.08
+            next
+          end
+        end
+
+        key = read_key_raw(stream)
+        break if key.nil? || key == "\x03" || key == "\x04"
+
+        if key == "\e[A" || key == "\eOA" || key == "\xe0H" || key == "\x00H"
+          if filtered_rows.length > 0
+            selected_idx = (selected_idx - 1) % filtered_rows.length
+          end
+        elsif key == "\e[B" || key == "\eOB" || key == "\xe0P" || key == "\x00P"
+          if filtered_rows.length > 0
+            selected_idx = (selected_idx + 1) % filtered_rows.length
+          end
+        elsif key == "\e[5~" || key == "\e[D"
+          if filtered_rows.length > 0
+            selected_idx = [(selected_idx - (page_size || 8)), 0].max
+          end
+        elsif key == "\e[6~" || key == "\e[C"
+          if filtered_rows.length > 0
+            selected_idx = [(selected_idx + (page_size || 8)), filtered_rows.length - 1].min
+          end
+        elsif key == "\r" || key == "\n"
+          if filtered_rows.length > 0
+            loop_res = filtered_rows[selected_idx]
+          end
+          break
+        elsif key == "\e"
+          if search && !query.empty?
+            query.clear
+            filtered_rows = raw_rows.dup
+            selected_idx = 0
+          else
+            loop_res = nil
+            break
+          end
+        elsif key == "\x7f" || key == "\b" || key == "\x08"
+          if search && !query.empty?
+            query.chop!
+            if query.empty?
+              filtered_rows = raw_rows.dup
+            else
+              filtered_rows = raw_rows.select { |r| r.any? { |c| c.downcase.include?(query.downcase) } }
+            end
+            selected_idx = 0
+          end
+        elsif key == "\x15"
+          if search
+            query.clear
+            filtered_rows = raw_rows.dup
+            selected_idx = 0
+          end
+        elsif (!search || query.empty?) && (key == "s" || key == "S")
+          if sort
+            sort_col = ((sort_col || -1) + 1) % [headers.length, 1].max
+            filtered_rows.sort_by! { |r| r[sort_col] || "" }
+            selected_idx = 0
+          end
+        elsif (!search || query.empty?) && (key == "q" || key == "Q")
+          loop_res = nil
+          break
+        elsif search && key =~ /^[[:print:]]$/
+          query << key
+          filtered_rows = raw_rows.select { |r| r.any? { |c| c.downcase.include?(query.downcase) } }
+          selected_idx = 0
+        end
+      end
+    end
+
+    begin
+      output_stream.print("#{HIDE_CURSOR}#{CLEAR_SCREEN_SEQUENCE}")
+      if input_stream.respond_to?(:raw) && input_stream.respond_to?(:tty?) && input_stream.tty?
+        input_stream.raw { |s| reader.call(s) }
+      else
+        reader.call(input_stream)
+      end
+    ensure
+      output_stream.print("#{SHOW_CURSOR}#{CLEAR_SCREEN_SEQUENCE}")
+    end
+    loop_res
+  end
+
   def self.div(long = nil, color = "blue", level = 1, char = "─")
     width = long || [terminal_width - 2, 64].min
     if color.to_s.downcase == "rgb" || color.to_s.downcase == "rainbow" || color.to_s.downcase == "chroma"
@@ -1648,10 +2580,25 @@ class GRmenu
   class << self
     alias_method :message, :banner
     alias_method :logo, :banner
+
+    def tabs(tabs_hash, *args, **kwargs)
+      new([], *args, tabs: tabs_hash, **kwargs)
+    end
   end
 
-  def initialize(functions, *positional_arguments, title: nil, banner: nil, subtitle: nil, description: nil, divider: nil, style: nil, banner_style: nil, center: true, font: nil, page_size: nil, search: false, columns: 1, image: nil, image_width: nil, **keyword_arguments)
-    @functions = functions.is_a?(Array) ? functions : Array(functions)
+  def initialize(functions = [], *positional_arguments, title: nil, banner: nil, subtitle: nil, description: nil, divider: nil, style: nil, banner_style: nil, center: true, font: nil, page_size: nil, search: false, columns: 1, image: nil, image_width: nil, mouse: nil, tabs: nil, active_tab_color: nil, tab_color: nil, **keyword_arguments)
+    tabs_data = tabs || keyword_arguments[:tabs] || (functions.is_a?(Hash) ? functions : nil)
+    if tabs_data.is_a?(Hash) && !tabs_data.empty?
+      @tabs = tabs_data.keys.map(&:to_s)
+      @tab_contents = tabs_data.transform_keys(&:to_s)
+      @active_tab_idx = 0
+      @functions = @tab_contents[@tabs[@active_tab_idx]] || []
+    else
+      @tabs = nil
+      @tab_contents = nil
+      @active_tab_idx = nil
+      @functions = functions.is_a?(Array) ? functions : Array(functions)
+    end
 
     pos_title = positional_arguments[0]
     pos_style = positional_arguments[1]
@@ -1660,22 +2607,60 @@ class GRmenu
     @banner       = (banner || keyword_arguments[:banner] || "").to_s
     @subtitle     = (subtitle || description || keyword_arguments[:subtitle] || keyword_arguments[:description] || "").to_s
     @divider      = divider.nil? ? (!@banner.empty? || !@subtitle.empty?) : divider
-    @style        = (style || pos_style || keyword_arguments[:style] || 19).to_i
-    @banner_style = (banner_style || keyword_arguments[:banner_style] || 3).to_i
-    @center       = center.nil? ? true : center
+
+    theme_menu_sec = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, 'menu')) || {}
+    th_style       = theme_menu_sec['style']&.to_i
+    th_bstyle      = theme_menu_sec['banner_style']&.to_i
+
+    @style        = (style || pos_style || keyword_arguments[:style] || th_style || 19).to_i
+    @banner_style = (banner_style || keyword_arguments[:banner_style] || th_bstyle || 3).to_i
+    @center       = center.nil? ? (theme_menu_sec.key?('center') ? (theme_menu_sec['center'].to_s != 'false') : true) : center
     @page_size    = (page_size || keyword_arguments[:page_size])&.to_i
     @search       = search || keyword_arguments[:search] || false
     @columns      = [(columns || keyword_arguments[:columns] || 1).to_i, 1].max
     @image        = image || keyword_arguments[:image]
     @image_width  = (image_width || keyword_arguments[:image_width])&.to_i
+    @animate      = (keyword_arguments[:animate] || (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, 'menu', 'animate')) || false).to_s
+    m_val = mouse.nil? ? keyword_arguments[:mouse] : mouse
+    if m_val.nil?
+      @mouse = theme_menu_sec.key?('mouse') ? (theme_menu_sec['mouse'].to_s != 'false') : true
+    else
+      @mouse = (m_val == true || m_val.to_s == 'true')
+    end
+
+    t_sec = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "tabs")) || {}
+    @active_tab_color = (active_tab_color || keyword_arguments[:active_tab_color] || t_sec["active_tab"] || t_sec["active_tab_color"] || "yellow").to_s
+    @tab_color        = (tab_color || keyword_arguments[:tab_color] || t_sec["tab_color"] || t_sec["inactive_tab"] || t_sec["color"] || "gray").to_s
+
     @query        = String.new("")
     @index        = 0
     @rgb_tick     = 0.0
 
+    @level          = 0
+    @open_level     = 0
+    @sub_index_1    = 0
+    @sub_index_2    = 0
+    @sub_1_hit_map  = {}
+    @sub_2_hit_map  = {}
+    @sub_1_col_rng  = nil
+    @sub_2_col_rng  = nil
+
+    @active_panel   = :main
+    @sub_index      = 0
+    @submenu_open   = false
+
+    @row_hit_map    = {}
+    @tab_ranges     = {}
+    @tabs_row       = nil
+    @up_arrow_row   = nil
+    @down_arrow_row = nil
+    @sub_hit_map    = {}
+
     @cached_image_lines = nil
     @cached_image_cols  = nil
 
     init_font = font || keyword_arguments[:font_style] || SetStyle.font || 1
+    init_pfx  = @desc_prefix || (@@global_theme.is_a?(Hash) && (@@global_theme.dig(:sections, 'menu', 'desc_prefix') || @@global_theme.dig(:sections, 'menu', 'prefix'))) || SetStyle.desc_prefix || "[i]"
 
     @style_config = SetStyle.new(
       border:   SetStyle.border.dup,
@@ -1685,7 +2670,8 @@ class GRmenu
       banner:   SetStyle.banner.dup,
       subtitle: SetStyle.subtitle.dup,
       divider:  SetStyle.divider.dup,
-      font:     init_font
+      font:     init_font,
+      desc_prefix: init_pfx
     )
   end
 
@@ -1776,10 +2762,20 @@ class GRmenu
   def colorize(text, color_config, phase_offset = 0.0)
     return text.to_s if color_config.nil? || color_config.empty?
 
-    color_name = (color_config[:color] || color_config["color"]).to_s.downcase
+    color_name = (color_config[:color] || color_config["color"]).to_s.downcase.strip
     brightness_level = (color_config[:level] || color_config["level"] || 1).to_i
 
-    if color_name == "rgb" || color_name == "rainbow" || color_name == "chroma"
+    if color_name.include?(":")
+      parts = color_name.split(":")
+      color_name = parts[0].strip
+      brightness_level = parts[1].to_i if parts[1] && !parts[1].empty?
+    end
+
+    is_neon_color = color_name.start_with?("neon")
+    is_anim_active = is_neon_color || (@animate && ["diagonal", "linear", "fade", "rgb", "rainbow", "chroma", "neon"].include?(@animate.to_s.downcase))
+    is_chroma = color_name == "rgb" || color_name == "rainbow" || color_name == "chroma" || @animate.to_s.downcase == "rgb"
+
+    if is_chroma
       tick = @rgb_tick || 0.0
       out = String.new("")
       char_count = 0
@@ -1814,6 +2810,67 @@ class GRmenu
       return out
     end
 
+    if is_anim_active
+      tick = @rgb_tick || 0.0
+      base = if color_name =~ /\A#?([0-9a-f]{6})\z/i
+               h = $1
+               [h[0..1].to_i(16), h[2..3].to_i(16), h[4..5].to_i(16)]
+             elsif color_name =~ /\A#?([0-9a-f]{3})\z/i
+               h = $1
+               [(h[0] * 2).to_i(16), (h[1] * 2).to_i(16), (h[2] * 2).to_i(16)]
+             else
+               BASE_RGB[color_name] || [255, 255, 255]
+             end
+
+      if @animate.to_s.downcase == "fade"
+        factor = (Math.sin(tick + phase_offset) + 1.0) / 2.0
+        f = 0.35 + 0.65 * factor
+        r = (base[0] * f).clamp(0, 255).to_i
+        g = (base[1] * f).clamp(0, 255).to_i
+        b = (base[2] * f).clamp(0, 255).to_i
+        glow = (factor > 0.85) ? ";1" : ""
+        return "\e[38;2;#{r};#{g};#{b}#{glow}m#{text}#{self.class.ansi_reset}"
+      else
+        out = String.new("")
+        char_count = 0
+        in_escape = false
+        escape_buf = String.new("")
+
+        text.to_s.each_char do |ch|
+          if ch == "\e"
+            in_escape = true
+            escape_buf << ch
+            next
+          end
+          if in_escape
+            escape_buf << ch
+            if ch =~ /[a-zA-Z]/
+              in_escape = false
+              out << escape_buf
+              escape_buf.clear
+            end
+            next
+          end
+
+          if ch == " " || ch == "\t" || ch == "\r" || ch == "\n"
+            out << ch
+          else
+            phase = char_count * 0.22 + phase_offset
+            factor = (Math.sin(tick + phase) + 1.0) / 2.0
+            f = 0.35 + 0.65 * factor
+            r = (base[0] * f).clamp(0, 255).to_i
+            g = (base[1] * f).clamp(0, 255).to_i
+            b = (base[2] * f).clamp(0, 255).to_i
+            glow = (factor > 0.85) ? ";1" : ""
+            out << "\e[38;2;#{r};#{g};#{b}#{glow}m#{ch}"
+            char_count += 1
+          end
+        end
+        out << self.class.ansi_reset
+        return out
+      end
+    end
+
     color_code = self.class.ansi_color(color_name, brightness_level)
     return text.to_s unless color_code
 
@@ -1870,7 +2927,7 @@ class GRmenu
 
       lines << colorize("#{banner_border[:tl]}#{top_fill}#{banner_border[:tr]}", banner_color_cfg, 0.0)
       lines << colorize("#{v_l} #{l_p}#{clean_b}#{r_p} #{v_r}", banner_color_cfg, 0.4)
-      lines << colorize("#{banner_border[:bl]}#{bot_fill}#{border_cfg[:br]}", banner_color_cfg, 0.8)
+      lines << colorize("#{banner_border[:bl]}#{bot_fill}#{banner_border[:br]}", banner_color_cfg, 0.8)
     end
     [lines, box_w]
   end
@@ -1908,10 +2965,115 @@ class GRmenu
     @cached_image_lines
   end
 
+  def is_submenu_item?(action)
+    if action.is_a?(Array)
+      target = action[1]
+      return true if target.is_a?(Array) && (target.empty? || target.first.is_a?(Array) || target.first.is_a?(Proc) || target.first.is_a?(Method) || target.first.is_a?(Symbol))
+      return true if target.is_a?(GRmenu)
+    elsif action.is_a?(Hash)
+      return true if action[:submenu] || action["submenu"]
+    end
+    false
+  end
+
+  def get_submenu_actions(action)
+    if action.is_a?(Array)
+      action[1].is_a?(GRmenu) ? action[1].instance_variable_get(:@functions) : action[1]
+    elsif action.is_a?(Hash)
+      action[:submenu] || action["submenu"]
+    end
+  end
+
+  def render_submenu_box(sub_actions, parent_title = "", is_active: false, selected_idx: 0)
+    sub_names = sub_actions.map { |a| extract_name_from_action(a) }
+    max_name_len = sub_names.empty? ? 10 : sub_names.map { |n| GRmenu.display_width(n) }.max
+    sub_title = parent_title.to_s
+    sub_w = [max_name_len + 8, GRmenu.display_width(sub_title) + 6, 20].max
+    sub_w = [sub_w, 36].min
+    inner_w = [sub_w - 2, 8].max
+
+    s_sec = (@@global_theme.is_a?(Hash) && @@global_theme.dig(:sections, "submenu")) || {}
+    sub_style = (s_sec["style"] || @style || 3).to_i
+    sub_border = BORDERS[sub_style] || BORDERS[3]
+    h_top = sub_border[:ht] || sub_border[:h]
+    h_bot = sub_border[:hb] || sub_border[:h]
+    v_l = sub_border[:vl] || sub_border[:v]
+    v_r = sub_border[:vr] || sub_border[:v]
+
+    s_brd_col = s_sec["border"] || s_sec["border_color"] || @style_config.border[:color] || "cyan"
+    s_foc_col = s_sec["focus"] || s_sec["focus_color"] || @style_config.focus[:color] || "yellow"
+    s_opt_col = s_sec["options"] || s_sec["options_color"] || @style_config.options[:color] || "white"
+
+    s_brd_cfg = { color: s_brd_col, level: 1 }
+    s_foc_cfg = { color: s_foc_col, level: 2 }
+    s_opt_cfg = { color: s_opt_col, level: 1 }
+    s_held_cfg = { color: "yellow", level: 1 }
+
+    lines = []
+    top_fill = build_horizontal_line(h_top, inner_w)
+    bot_fill = build_horizontal_line(h_bot, inner_w)
+
+    top_border_line = sub_border[:tl] + top_fill + sub_border[:tr]
+    lines << colorize(top_border_line, s_brd_cfg, 0.0)
+
+    unless sub_title.empty?
+      pad_t = [inner_w - 2 - GRmenu.display_width(sub_title), 0].max
+      t_padded = " " * (pad_t / 2) + sub_title + " " * (pad_t - (pad_t / 2))
+      c_title = colorize(t_padded, s_foc_cfg, 0.2)
+      v_l_col = colorize(v_l, s_brd_cfg, 0.2)
+      v_r_col = colorize(v_r, s_brd_cfg, 0.2)
+      lines << "#{v_l_col} #{c_title} #{v_r_col}"
+      mid_fill = build_horizontal_line(h_top, inner_w)
+      lines << colorize(v_l + mid_fill + v_r, s_brd_cfg, 0.4)
+    end
+
+    parent_item_row = nil
+    sub_names.each_with_index do |s_name, s_idx|
+      is_sub = is_submenu_item?(sub_actions[s_idx])
+      arrow = is_sub ? "▶" : ""
+      is_selected = (s_idx == selected_idx)
+      parent_item_row = lines.length if is_selected
+
+      prefix = is_selected ? "> " : "  "
+      pad_s = [inner_w - 2 - prefix.length - GRmenu.display_width(s_name) - (is_sub ? 2 : 0), 0].max
+      raw_item = if is_sub
+                   "#{prefix}#{s_name}#{' ' * pad_s} #{arrow}"
+                 else
+                   "#{prefix}#{s_name}#{' ' * pad_s}"
+                 end
+
+      item_cfg = if is_selected
+                   is_active ? s_foc_cfg : s_held_cfg
+                 else
+                   s_opt_cfg
+                 end
+
+      colored_item = colorize(raw_item, item_cfg, s_idx * 0.2)
+      v_l_col = colorize(v_l, s_brd_cfg, 0.2)
+      v_r_col = colorize(v_r, s_brd_cfg, 0.8)
+      lines << "#{v_l_col} #{colored_item} #{v_r_col}"
+    end
+
+    bot_border_line = sub_border[:bl] + bot_fill + sub_border[:br]
+    lines << colorize(bot_border_line, s_brd_cfg, 0.6)
+
+    [lines, sub_w, parent_item_row]
+  end
+
   def render_lines(size_max = 20)
     term_cols = self.class.terminal_width
     term_rows = self.class.terminal_height
     rendered_lines = []
+    @row_hit_map    = {}
+    @tab_ranges     = {}
+    @tabs_row       = nil
+    @up_arrow_row   = nil
+    @down_arrow_row = nil
+    @sub_hit_map    = {}
+    @sub_1_hit_map  = {}
+    @sub_2_hit_map  = {}
+    @sub_1_col_rng  = nil
+    @sub_2_col_rng  = nil
 
     header_box_width = 0
     header_lines_count = 0
@@ -2019,6 +3181,39 @@ class GRmenu
     avail_w = [total_width - 4, 1].max
     col_w = [(avail_w - (cols - 1) * 2) / cols, 1].max
 
+    if @tabs && !@tabs.empty?
+      tab_strs = []
+      raw_tab_strs = []
+      @tab_ranges = {}
+      @tabs.each_with_index do |t_name, t_i|
+        is_active = (t_i == @active_tab_idx)
+        raw_t = is_active ? "[ #{t_name} ]" : "  #{t_name}  "
+        colored_t = if is_active
+                      colorize(raw_t, { color: @active_tab_color, level: 2 }, 0.0)
+                    else
+                      colorize(raw_t, { color: @tab_color, level: 1 }, 0.0)
+                    end
+        tab_strs << colored_t
+        raw_tab_strs << raw_t
+      end
+      raw_tabs_joined = raw_tab_strs.join("   ")
+      tabs_w = GRmenu.display_width(raw_tabs_joined)
+      l_tabs_pad = [(total_width - tabs_w) / 2, 0].max
+      formatted_tabs = (" " * l_tabs_pad) + tab_strs.join("   ")
+
+      start_col = margin_left.length + l_tabs_pad
+      cur_x = start_col
+      @tabs.each_with_index do |_t_name, t_i|
+        t_len = GRmenu.display_width(raw_tab_strs[t_i])
+        @tab_ranges[t_i] = (cur_x + 1)..(cur_x + t_len)
+        cur_x += t_len + 3
+      end
+
+      @tabs_row = rendered_lines.length + 1
+      rendered_lines << "#{margin_left}#{formatted_tabs}"
+      rendered_lines << ""
+    end
+
     if box_border
       h_top = box_border[:ht] || box_border[:h]
       h_bot = box_border[:hb] || box_border[:h]
@@ -2055,12 +3250,14 @@ class GRmenu
       end
 
       if has_more_above
+        @up_arrow_row = rendered_lines.length + 1
         up_text = "▲ (+#{start_row} #{cols > 1 ? 'filas' : 'arriba'})"
         pad_up = [avail_w - GRmenu.display_width(up_text), 0].max
         up_indicator = colorize(" " * (pad_up / 2) + up_text + " " * (pad_up - (pad_up / 2)), { color: "gray", level: 2 })
         rendered_lines << "#{margin_left}#{v_left} #{up_indicator} #{v_right}"
       end
 
+      parent_row_idx = nil
       if rows_data.empty?
         no_res_txt = "(Sin resultados)"
         pad_no = [avail_w - GRmenu.display_width(no_res_txt), 0].max
@@ -2073,12 +3270,25 @@ class GRmenu
             item_idx = row_indices[c_idx]
             if item_idx
               op_name = all_names[item_idx]
+              is_sub = is_submenu_item?(@functions[item_idx])
+              arrow = is_sub ? "▶" : ""
               if @index == item_idx
-                cell_raw = "> #{op_name}"
+                parent_row_idx = rendered_lines.length
+                cell_raw = if is_sub
+                             pad_sub = [col_w - 2 - GRmenu.display_width(op_name) - 2, 0].max
+                             "> #{op_name}#{' ' * pad_sub}#{arrow}"
+                           else
+                             "> #{op_name}"
+                           end
                 pad_c = [col_w - GRmenu.display_width(cell_raw), 0].max
                 cells << colorize(cell_raw + (" " * pad_c), focus_color_cfg, r_idx * 0.3)
               else
-                cell_raw = "  #{op_name}"
+                cell_raw = if is_sub
+                             pad_sub = [col_w - 2 - GRmenu.display_width(op_name) - 2, 0].max
+                             "  #{op_name}#{' ' * pad_sub}#{arrow}"
+                           else
+                             "  #{op_name}"
+                           end
                 pad_c = [col_w - GRmenu.display_width(cell_raw), 0].max
                 cells << colorize(cell_raw + (" " * pad_c), options_color_cfg, r_idx * 0.2)
               end
@@ -2089,11 +3299,14 @@ class GRmenu
           row_str = cells.join("  ")
           pad_r = [avail_w - (col_w * cols + (cols - 1) * 2), 0].max
           row_padded = row_str + (" " * pad_r)
+          cur_line_num = rendered_lines.length + 1
+          @row_hit_map[cur_line_num] = { row_indices: row_indices, cols: cols, col_w: col_w, margin_left: margin_left.length }
           rendered_lines << "#{margin_left}#{v_left} #{row_padded} #{v_right}"
         end
       end
 
       if has_more_below
+        @down_arrow_row = rendered_lines.length + 1
         remaining_below = total_rows - 1 - end_row
         down_text = "▼ (+#{remaining_below} #{cols > 1 ? 'filas' : 'abajo'})"
         pad_down = [avail_w - GRmenu.display_width(down_text), 0].max
@@ -2104,7 +3317,9 @@ class GRmenu
       unless active_desc.empty?
         separator_line = v_l_raw + mid_fill + v_r_raw
         rendered_lines << "#{margin_left}#{colorize(separator_line, border_color_cfg, 1.0)}"
-        raw_desc = "* #{active_desc}"
+        pfx = (@style_config&.desc_prefix || @desc_prefix || SetStyle.desc_prefix || "[i]").to_s
+        pfx = "#{pfx} " unless pfx.end_with?(" ")
+        raw_desc = "#{pfx}#{active_desc}"
         pad_d = [avail_w - GRmenu.display_width(raw_desc), 0].max
         desc_text = colorize(raw_desc + (" " * pad_d), { color: "cyan", level: 1 })
         rendered_lines << "#{margin_left}#{v_left} #{desc_text} #{v_right}"
@@ -2136,12 +3351,14 @@ class GRmenu
       end
 
       if has_more_above
+        @up_arrow_row = rendered_lines.length + 1
         up_text = "▲ (+#{start_row} #{cols > 1 ? 'filas' : 'arriba'})"
         pad_up = [avail_w - GRmenu.display_width(up_text), 0].max
         up_indicator = colorize(" " * (pad_up / 2) + up_text + " " * (pad_up - (pad_up / 2)), { color: "gray", level: 2 })
         rendered_lines << "#{margin_left}#{solid_border} #{up_indicator} #{solid_border}"
       end
 
+      parent_row_idx = nil
       if rows_data.empty?
         no_res_txt = "(Sin resultados)"
         pad_no = [avail_w - GRmenu.display_width(no_res_txt), 0].max
@@ -2154,12 +3371,25 @@ class GRmenu
             item_idx = row_indices[c_idx]
             if item_idx
               op_name = all_names[item_idx]
+              is_sub = is_submenu_item?(@functions[item_idx])
+              arrow = is_sub ? "▶" : ""
               if @index == item_idx
-                cell_raw = "> #{op_name}"
+                parent_row_idx = rendered_lines.length
+                cell_raw = if is_sub
+                             pad_sub = [col_w - 2 - GRmenu.display_width(op_name) - 2, 0].max
+                             "> #{op_name}#{' ' * pad_sub}#{arrow}"
+                           else
+                             "> #{op_name}"
+                           end
                 pad_c = [col_w - GRmenu.display_width(cell_raw), 0].max
                 cells << colorize(cell_raw + (" " * pad_c), focus_color_cfg, r_idx * 0.3)
               else
-                cell_raw = "  #{op_name}"
+                cell_raw = if is_sub
+                             pad_sub = [col_w - 2 - GRmenu.display_width(op_name) - 2, 0].max
+                             "  #{op_name}#{' ' * pad_sub}#{arrow}"
+                           else
+                             "  #{op_name}"
+                           end
                 pad_c = [col_w - GRmenu.display_width(cell_raw), 0].max
                 cells << colorize(cell_raw + (" " * pad_c), options_color_cfg, r_idx * 0.2)
               end
@@ -2170,11 +3400,14 @@ class GRmenu
           row_str = cells.join("  ")
           pad_r = [avail_w - (col_w * cols + (cols - 1) * 2), 0].max
           row_padded = row_str + (" " * pad_r)
+          cur_line_num = rendered_lines.length + 1
+          @row_hit_map[cur_line_num] = { row_indices: row_indices, cols: cols, col_w: col_w, margin_left: margin_left.length }
           rendered_lines << "#{margin_left}#{solid_border} #{row_padded} #{solid_border}"
         end
       end
 
       if has_more_below
+        @down_arrow_row = rendered_lines.length + 1
         remaining_below = total_rows - 1 - end_row
         down_text = "▼ (+#{remaining_below} #{cols > 1 ? 'filas' : 'abajo'})"
         pad_down = [avail_w - GRmenu.display_width(down_text), 0].max
@@ -2184,7 +3417,9 @@ class GRmenu
 
       unless active_desc.empty?
         rendered_lines << "#{margin_left}#{colorize(solid_line, border_color_cfg)}"
-        raw_desc = "* #{active_desc}"
+        pfx = (@style_config&.desc_prefix || @desc_prefix || SetStyle.desc_prefix || "[i]").to_s
+        pfx = "#{pfx} " unless pfx.end_with?(" ")
+        raw_desc = "#{pfx}#{active_desc}"
         pad_d = [avail_w - GRmenu.display_width(raw_desc), 0].max
         desc_text = colorize(raw_desc + (" " * pad_d), { color: "cyan", level: 1 })
         rendered_lines << "#{margin_left}#{solid_border} #{desc_text} #{solid_border}"
@@ -2193,6 +3428,152 @@ class GRmenu
       rendered_lines << "#{margin_left}#{colorize(solid_line, border_color_cfg)}"
     end
 
+    if @open_level >= 1 && is_submenu_item?(@functions[@index]) && parent_row_idx
+      sub_1_acts = get_submenu_actions(@functions[@index])
+      if sub_1_acts && !sub_1_acts.empty?
+        sub_1_title = all_names[@index] || "Submenu"
+        sub_1_lines, sub_1_w, p_row_1 = render_submenu_box(sub_1_acts, sub_1_title, is_active: (@level == 1), selected_idx: @sub_index_1)
+
+        sub_2_acts = nil
+        sub_2_lines = nil
+        sub_2_w = 0
+        p_row_2 = nil
+        if @open_level >= 2 && is_submenu_item?(sub_1_acts[@sub_index_1])
+          sub_2_acts = get_submenu_actions(sub_1_acts[@sub_index_1])
+          if sub_2_acts && !sub_2_acts.empty?
+            sub_2_title = extract_name_from_action(sub_1_acts[@sub_index_1]) || "Submenu"
+            sub_2_lines, sub_2_w, p_row_2 = render_submenu_box(sub_2_acts, sub_2_title, is_active: (@level == 2), selected_idx: @sub_index_2)
+          end
+        end
+
+        if sub_2_lines
+          total_3_w = margin_left.length + total_width + 2 + sub_1_w + 2 + sub_2_w
+          if total_3_w <= term_cols
+            sub_1_start = [[parent_row_idx - 1, 0].max, [rendered_lines.length - sub_1_lines.length, 0].max].min
+            p1_abs_row = sub_1_start + (p_row_1 || 1)
+            sub_2_start = [[p1_abs_row - 1, 0].max, [rendered_lines.length - sub_2_lines.length, 0].max].min
+            max_3_lines = [rendered_lines.length, sub_1_start + sub_1_lines.length, sub_2_start + sub_2_lines.length].max
+
+            x1_start = margin_left.length + total_width + 2
+            x1_end   = x1_start + sub_1_w
+            x2_start = x1_end + 2
+            x2_end   = x2_start + sub_2_w
+            @sub_1_col_rng = (x1_start..x1_end)
+            @sub_2_col_rng = (x2_start..x2_end)
+
+            sub_1_offset = sub_1_title.empty? ? 1 : 3
+            sub_2_offset = sub_2_title.empty? ? 1 : 3
+
+            stitched_lines = []
+            max_3_lines.times do |i|
+              l0 = rendered_lines[i] || ("#{margin_left}#{' ' * total_width}")
+
+              l1 = " " * sub_1_w
+              br1 = "  "
+              if i >= sub_1_start && i < (sub_1_start + sub_1_lines.length)
+                s1_idx = i - sub_1_start
+                l1 = sub_1_lines[s1_idx]
+                br1 = (i == parent_row_idx) ? "──" : "  "
+                s1_item = s1_idx - sub_1_offset
+                if s1_item >= 0 && s1_item < sub_1_acts.length
+                  @sub_1_hit_map[i + 1] = s1_item
+                  @sub_hit_map[i + 1] = s1_item
+                end
+              end
+
+              l2 = ""
+              br2 = ""
+              if i >= sub_2_start && i < (sub_2_start + sub_2_lines.length)
+                s2_idx = i - sub_2_start
+                l2 = sub_2_lines[s2_idx]
+                br2 = (i == p1_abs_row) ? "──" : "  "
+                s2_item = s2_idx - sub_2_offset
+                if s2_item >= 0 && s2_item < sub_2_acts.length
+                  @sub_2_hit_map[i + 1] = s2_item
+                end
+              end
+
+              stitched_lines << "#{l0}#{br1}#{l1}#{br2}#{l2}".rstrip
+            end
+            rendered_lines = stitched_lines
+          elsif (sub_1_w + 2 + sub_2_w) <= term_cols
+            p1_abs_row = (p_row_1 || 1)
+            sub_2_start = [[p1_abs_row - 1, 0].max, [sub_1_lines.length - sub_2_lines.length, 0].max].min
+            max_2_lines = [sub_1_lines.length, sub_2_start + sub_2_lines.length].max
+
+            x1_start = margin_left.length
+            x1_end   = x1_start + sub_1_w
+            x2_start = x1_end + 2
+            x2_end   = x2_start + sub_2_w
+            @sub_1_col_rng = (x1_start..x1_end)
+            @sub_2_col_rng = (x2_start..x2_end)
+
+            sub_1_offset = sub_1_title.empty? ? 1 : 3
+            sub_2_offset = sub_2_title.empty? ? 1 : 3
+
+            stitched_lines = []
+            max_2_lines.times do |i|
+              l1 = sub_1_lines[i] || (" " * sub_1_w)
+              l2 = ""
+              br2 = ""
+              if i >= sub_2_start && i < (sub_2_start + sub_2_lines.length)
+                s2_idx = i - sub_2_start
+                l2 = sub_2_lines[s2_idx]
+                br2 = (i == p1_abs_row) ? "──" : "  "
+                s2_item = s2_idx - sub_2_offset
+                @sub_2_hit_map[i + 1] = s2_item if s2_item >= 0 && s2_item < sub_2_acts.length
+              end
+              s1_item = i - sub_1_offset
+              if s1_item >= 0 && s1_item < sub_1_acts.length
+                @sub_1_hit_map[i + 1] = s1_item
+                @sub_hit_map[i + 1] = s1_item
+              end
+              stitched_lines << "#{margin_left}#{l1}#{br2}#{l2}".rstrip
+            end
+            rendered_lines = stitched_lines
+          else
+            active_box = (@level == 2) ? sub_2_lines : sub_1_lines
+            rendered_lines = active_box.map { |l| "#{margin_left}#{l}" }
+          end
+        else
+          total_2_w = margin_left.length + total_width + 2 + sub_1_w
+          if total_2_w <= term_cols
+            sub_start_line = [[parent_row_idx - 1, 0].max, [rendered_lines.length - sub_1_lines.length, 0].max].min
+            max_total_lines = [rendered_lines.length, sub_start_line + sub_1_lines.length].max
+
+            x1_start = margin_left.length + total_width + 2
+            x1_end   = x1_start + sub_1_w
+            @sub_1_col_rng = (x1_start..x1_end)
+
+            sub_item_offset = sub_1_title.empty? ? 1 : 3
+
+            stitched_lines = []
+            max_total_lines.times do |i|
+              main_line = rendered_lines[i] || ("#{margin_left}#{' ' * total_width}")
+              if i >= sub_start_line && i < (sub_start_line + sub_1_lines.length)
+                sub_idx = i - sub_start_line
+                sub_l = sub_1_lines[sub_idx]
+                bridge = (i == parent_row_idx) ? "──" : "  "
+                stitched_lines << "#{main_line}#{bridge}#{sub_l}"
+
+                s_item_idx = sub_idx - sub_item_offset
+                if s_item_idx >= 0 && s_item_idx < sub_1_acts.length
+                  @sub_1_hit_map[i + 1] = s_item_idx
+                  @sub_hit_map[i + 1] = s_item_idx
+                end
+              else
+                stitched_lines << main_line
+              end
+            end
+            rendered_lines = stitched_lines
+          else
+            active_box = (@level == 1) ? sub_1_lines : rendered_lines
+            rendered_lines = active_box.map { |l| "#{margin_left}#{l}" }
+          end
+        end
+      end
+    end
+
     rendered_lines
   end
 
@@ -2216,14 +3597,197 @@ class GRmenu
     end
   end
 
+  def has_active_animation?
+    return true if @animate && ["diagonal", "linear", "fade", "rgb", "rainbow", "chroma", "neon"].include?(@animate.to_s.downcase)
+    return true if has_rgb_animation?
+    return true if @active_tab_color && @active_tab_color.to_s.downcase.start_with?("neon")
+    configs = [
+      @style_config.border,
+      @style_config.options,
+      @style_config.focus,
+      @style_config.title,
+      @style_config.banner,
+      @style_config.subtitle,
+      @style_config.divider
+    ]
+    configs.any? do |c|
+      if c.is_a?(Hash)
+        val = (c[:color] || c["color"]).to_s.downcase.strip
+        val.start_with?("neon")
+      else
+        false
+      end
+    end
+  end
+
+  def style(css_content)
+    parsed = self.class.parse_config_text(css_content)
+    m = ((parsed[:sections] && parsed[:sections]["menu"]) || {}).merge(parsed[:global] || {})
+    if m["style"]
+      @style = m["style"].to_i
+      @border_config = BORDERS[@style] || BORDERS[3]
+    end
+    @banner_style = m["banner_style"].to_i if m["banner_style"]
+    @animate = m["animate"].to_s if m["animate"]
+    @center = (m["center"].to_s != "false") if m.key?("center")
+    if m["border"] || m["border_color"]
+      c, l = self.class.extract_color_and_level(m["border"] || m["border_color"], 1)
+      @style_config.border(c, l)
+    end
+    if m["options"] || m["options_color"]
+      c, l = self.class.extract_color_and_level(m["options"] || m["options_color"], 1)
+      @style_config.options(c, l)
+    end
+    if m["focus"] || m["focus_color"]
+      c, l = self.class.extract_color_and_level(m["focus"] || m["focus_color"], 2)
+      @style_config.focus(c, l)
+    end
+    if m["title"] || m["title_color"]
+      c, l = self.class.extract_color_and_level(m["title"] || m["title_color"], 2)
+      @style_config.title(c, l)
+    end
+    if m["banner"] || m["banner_color"]
+      c, l = self.class.extract_color_and_level(m["banner"] || m["banner_color"], 2)
+      @style_config.banner(c, l)
+    end
+    if m["subtitle"] || m["subtitle_color"]
+      c, l = self.class.extract_color_and_level(m["subtitle"] || m["subtitle_color"], 1)
+      @style_config.subtitle(c, l)
+    end
+    if m["divider"] || m["divider_color"]
+      c, l = self.class.extract_color_and_level(m["divider"] || m["divider_color"], 1)
+      @style_config.divider(c, l)
+    end
+    if m["desc_prefix"] || m["description_prefix"] || m["prefix"]
+      @style_config.desc_prefix(m["desc_prefix"] || m["description_prefix"] || m["prefix"])
+    end
+    @style_config.font(m["font"].to_i) if m["font"]
+    @mouse = (m["mouse"].to_s == "true") if m.key?("mouse")
+    if parsed[:sections] && parsed[:sections]["tabs"]
+      t_sec = parsed[:sections]["tabs"]
+      @active_tab_color = t_sec["active_tab"] || t_sec["active_tab_color"] || @active_tab_color if (t_sec["active_tab"] || t_sec["active_tab_color"])
+      @tab_color = t_sec["tab_color"] || t_sec["inactive_tab"] || t_sec["color"] || @tab_color if (t_sec["tab_color"] || t_sec["inactive_tab"] || t_sec["color"])
+    end
+    self
+  end
+
+  def export_config(path = nil)
+    if path.nil?
+      caller_loc = caller_locations.find { |c| !c.path.include?(__FILE__) }
+      base = caller_loc ? caller_loc.path.sub(/\.rb$/, '') : "theme"
+      path = "#{base}.gr"
+    end
+    b_cfg = @style_config&.border || SetStyle.border
+    t_cfg = @style_config&.title || SetStyle.title
+    f_cfg = @style_config&.focus || SetStyle.focus
+    o_cfg = @style_config&.options || SetStyle.options
+    bn_cfg = @style_config&.banner || SetStyle.banner
+    s_cfg = @style_config&.subtitle || SetStyle.subtitle
+    d_cfg = @style_config&.divider || SetStyle.divider
+    dp_val = @style_config&.desc_prefix || SetStyle.desc_prefix
+
+    lines = ["GRmenu::config<-1->", ""]
+    lines << "@theme:: \"#{File.basename(path, '.gr').capitalize}\""
+    lines << "@author:: \"grcode\""
+    lines << "@version:: \"1.0\""
+    lines << ""
+    lines << "<<menu"
+    lines << "  style:: #{@style || 3}"
+    lines << "  banner_style:: #{@banner_style || 3}"
+    lines << "  font:: #{@style_config&.font || SetStyle.font}"
+    lines << "  animate:: #{@animate || 'rgb'}"
+    lines << "  center:: #{@center.nil? ? true : @center}"
+    lines << "  desc_prefix:: #{dp_val}"
+    lines << "  mouse:: #{@mouse}" if @mouse
+    lines << "  border:: #{b_cfg[:color]}:#{b_cfg[:level]}"
+    lines << "  title:: #{t_cfg[:color]}:#{t_cfg[:level]}"
+    lines << "  focus:: #{f_cfg[:color]}:#{f_cfg[:level]}"
+    lines << "  options:: #{o_cfg[:color]}:#{o_cfg[:level]}"
+    lines << "  banner:: #{bn_cfg[:color]}:#{bn_cfg[:level]}"
+    lines << "  subtitle:: #{s_cfg[:color]}:#{s_cfg[:level]}"
+    lines << "  divider:: #{d_cfg[:color]}:#{d_cfg[:level]}"
+    lines << ">>"
+    lines << ""
+    lines << "<<submenu"
+    lines << "  style:: #{@style || 3}"
+    lines << "  border:: #{b_cfg[:color]}:#{b_cfg[:level]}"
+    lines << "  focus:: #{f_cfg[:color]}:#{f_cfg[:level]}"
+    lines << "  options:: #{o_cfg[:color]}:#{o_cfg[:level]}"
+    lines << ">>"
+    lines << ""
+    lines << "<<tabs"
+    lines << "  active_tab:: #{@active_tab_color || 'yellow'}:2"
+    lines << "  tab_color:: #{@tab_color || 'gray'}:1"
+    lines << ">>"
+    lines << ""
+    lines << "<<input"
+    lines << "  style:: 3"
+    lines << "  border_color:: #{b_cfg[:color]}:#{b_cfg[:level]}"
+    lines << "  title_color:: #{t_cfg[:color]}:#{t_cfg[:level]}"
+    lines << "  label_color:: white:1"
+    lines << ">>"
+    lines << ""
+    lines << "<<table"
+    lines << "  style:: #{@style || 3}"
+    lines << "  header_color:: yellow:2"
+    lines << "  border_color:: #{b_cfg[:color]}:#{b_cfg[:level]}"
+    lines << "  selected_row:: #{f_cfg[:color]}:#{f_cfg[:level]}"
+    lines << "  row_color:: white:1"
+    lines << "  zebra_striping:: true"
+    lines << ">>"
+    lines << ""
+    lines << "<<card"
+    lines << "  style:: 7"
+    lines << "  border_color:: #{b_cfg[:color]}:#{b_cfg[:level]}"
+    lines << "  title_color:: #{t_cfg[:color]}:#{t_cfg[:level]}"
+    lines << "  content_color:: white:1"
+    lines << ">>"
+    lines << ""
+    lines << "<<slider"
+    lines << "  style:: #{@style || 3}"
+    lines << "  color:: #{b_cfg[:color]}:#{b_cfg[:level]}"
+    lines << "  fill_char:: █"
+    lines << "  empty_char:: ░"
+    lines << ">>"
+    lines << ""
+    lines << "<<checkbox"
+    lines << "  style:: #{@style || 3}"
+    lines << "  color:: #{b_cfg[:color]}:#{b_cfg[:level]}"
+    lines << "  checked_mark:: [X]"
+    lines << "  unchecked_mark:: [ ]"
+    lines << ">>"
+    lines << ""
+    File.write(path, lines.join("\n") + "\n")
+    path
+  end
+  alias_method :export_theme, :export_config
+
   def draw(size_max: 20, min_width: nil)
+    if ARGV.any? { |a| ["-theme", "--theme", "-ex", "--export-theme"].include?(a.to_s.downcase) }
+      out_idx = ARGV.index { |a| ["-o", "--out", "--output"].include?(a.to_s.downcase) }
+      target_file = out_idx ? ARGV[out_idx + 1] : "tema_exportado.gr"
+      export_config(target_file)
+      Kernel.puts Color.bright_green("[OK] Tema exportado exitosamente a: #{target_file}")
+      exit(0)
+    end
+
     target_width = min_width || size_max || 20
     action_to_execute = nil
 
+    self.class.enable_windows_vt
+    $stdout.sync = true
+
     is_tty = $stdin.respond_to?(:tty?) && $stdin.tty?
 
     begin
       Kernel.print("#{HIDE_CURSOR}#{CLEAR_SCREEN_SEQUENCE}")
+      Kernel.print(ENABLE_MOUSE) if @mouse
+      $stdout.flush
+
+      if @animate && !["false", "rgb", "", "nil"].include?(@animate.downcase)
+        intro_lines = render_lines(target_width)
+        self.class.animate_render(intro_lines, @animate)
+      end
 
       if is_tty
         $stdin.raw do |raw_input_stream|
@@ -2233,17 +3797,23 @@ class GRmenu
         action_to_execute = run_interactive_loop($stdin, target_width)
       end
     ensure
+      Kernel.print(DISABLE_MOUSE) if @mouse
       Kernel.print(SHOW_CURSOR)
+      $stdout.flush
     end
 
     if action_to_execute
       Kernel.print(CLEAR_SCREEN_SEQUENCE)
+      $stdout.flush
       execute_action(action_to_execute)
     else
       Kernel.print(CLEAR_SCREEN_SEQUENCE)
+      $stdout.flush
     end
   rescue Interrupt
+    Kernel.print(DISABLE_MOUSE) if @mouse
     Kernel.print("#{SHOW_CURSOR}#{CLEAR_SCREEN_SEQUENCE}")
+    $stdout.flush
     nil
   end
 
@@ -2258,6 +3828,7 @@ class GRmenu
     end
     buffer << CLEAR_TO_EOS
     Kernel.print(buffer)
+    $stdout.flush
   end
 
   def run_interactive_loop(input_stream, target_width)
@@ -2266,7 +3837,7 @@ class GRmenu
     @rgb_tick = 0.0
     draw_frame(target_width)
 
-    animating = has_rgb_animation?
+    animating = has_active_animation?
 
     while true
       if animating
@@ -2292,6 +3863,228 @@ class GRmenu
       key = read_single_key(input_stream)
       break if key.nil? || key == "\x03" || key == "\x04"
 
+      if key =~ /\A\e\[<(\d+);(\d+);(\d+)([Mm])\z/
+        btn = $1.to_i
+        col = $2.to_i
+        row = $3.to_i
+        act = $4
+
+        if btn == 64
+          if @open_level >= 2 && @sub_2_col_rng && @sub_2_col_rng.cover?(col) && is_submenu_item?(@functions[@index])
+            s1_acts = get_submenu_actions(@functions[@index])
+            s2_acts = get_submenu_actions(s1_acts[@sub_index_1]) if s1_acts
+            @sub_index_2 = (@sub_index_2 - 1) % s2_acts.length if s2_acts && !s2_acts.empty?
+            @level = 2
+          elsif @open_level >= 1 && @sub_1_col_rng && @sub_1_col_rng.cover?(col) && is_submenu_item?(@functions[@index])
+            s1_acts = get_submenu_actions(@functions[@index])
+            @sub_index_1 = (@sub_index_1 - 1) % s1_acts.length if s1_acts && !s1_acts.empty?
+            @sub_index_2 = 0
+            @level = 1
+          else
+            move_up
+            @sub_index_1 = 0
+            @sub_index_2 = 0
+            @level = 0
+          end
+          draw_frame(target_width)
+          next
+        elsif btn == 65
+          if @open_level >= 2 && @sub_2_col_rng && @sub_2_col_rng.cover?(col) && is_submenu_item?(@functions[@index])
+            s1_acts = get_submenu_actions(@functions[@index])
+            s2_acts = get_submenu_actions(s1_acts[@sub_index_1]) if s1_acts
+            @sub_index_2 = (@sub_index_2 + 1) % s2_acts.length if s2_acts && !s2_acts.empty?
+            @level = 2
+          elsif @open_level >= 1 && @sub_1_col_rng && @sub_1_col_rng.cover?(col) && is_submenu_item?(@functions[@index])
+            s1_acts = get_submenu_actions(@functions[@index])
+            @sub_index_1 = (@sub_index_1 + 1) % s1_acts.length if s1_acts && !s1_acts.empty?
+            @sub_index_2 = 0
+            @level = 1
+          else
+            move_down
+            @sub_index_1 = 0
+            @sub_index_2 = 0
+            @level = 0
+          end
+          draw_frame(target_width)
+          next
+        elsif btn == 0 && act == "M"
+          if @tabs && !@tabs.empty? && @tabs_row && row == @tabs_row
+            clicked_tab = @tab_ranges.find { |_idx, rng| rng.cover?(col) }
+            if clicked_tab
+              @active_tab_idx = clicked_tab[0]
+              @functions = @tab_contents[@tabs[@active_tab_idx]] || []
+              @index = 0
+              @level = 0
+              @open_level = 0
+              @sub_index_1 = 0
+              @sub_index_2 = 0
+              @active_panel = :main
+              @submenu_open = false
+              draw_frame(target_width)
+              next
+            end
+          end
+
+          if @up_arrow_row && row == @up_arrow_row
+            move_up
+            draw_frame(target_width)
+            next
+          end
+
+          if @down_arrow_row && row == @down_arrow_row
+            move_down
+            draw_frame(target_width)
+            next
+          end
+
+          if @open_level >= 2 && @sub_2_col_rng && @sub_2_col_rng.cover?(col) && @sub_2_hit_map[row]
+            s2_clicked = @sub_2_hit_map[row]
+            s1_acts = get_submenu_actions(@functions[@index])
+            s2_acts = get_submenu_actions(s1_acts[@sub_index_1]) if s1_acts
+            if s2_acts && s2_clicked < s2_acts.length
+              @level = 2
+              @sub_index_2 = s2_clicked
+              return s2_acts[s2_clicked]
+            end
+          end
+
+          if @open_level >= 1 && @sub_1_col_rng && @sub_1_col_rng.cover?(col) && @sub_1_hit_map[row]
+            s1_clicked = @sub_1_hit_map[row]
+            s1_acts = get_submenu_actions(@functions[@index])
+            if s1_acts && s1_clicked < s1_acts.length
+              t_act = s1_acts[s1_clicked]
+              @level = 1
+              @sub_index_1 = s1_clicked
+              if is_submenu_item?(t_act)
+                @open_level = 2
+                @level = 2
+                @sub_index_2 = 0
+                draw_frame(target_width)
+                next
+              else
+                return t_act
+              end
+            end
+          end
+
+          if @row_hit_map && @row_hit_map[row]
+            hit = @row_hit_map[row]
+            x_in_box = col - hit[:margin_left]
+            if x_in_box > 0 && (hit[:total_w].nil? || x_in_box <= hit[:total_w])
+              c_idx = [[((x_in_box - 2) / ([hit[:col_w], 1].max + 2)).to_i, 0].max, hit[:cols] - 1].min
+              clicked_item = hit[:row_indices][c_idx]
+              if clicked_item
+                @index = clicked_item
+                if is_submenu_item?(@functions[clicked_item])
+                  @open_level = 1
+                  @level = 1
+                  @sub_index_1 = 0
+                  @sub_index_2 = 0
+                  @active_panel = :sub
+                  @submenu_open = true
+                  draw_frame(target_width)
+                  next
+                else
+                  return @functions[clicked_item]
+                end
+              end
+            end
+          end
+        end
+        next
+      end
+
+      if @tabs && !@tabs.empty?
+        if key == "\t"
+          @active_tab_idx = (@active_tab_idx + 1) % @tabs.length
+          @functions = @tab_contents[@tabs[@active_tab_idx]] || []
+          @index = 0
+          @level = 0
+          @open_level = 0
+          @sub_index_1 = 0
+          @sub_index_2 = 0
+          @active_panel = :main
+          @submenu_open = false
+          draw_frame(target_width)
+          next
+        elsif key == "\e[Z"
+          @active_tab_idx = (@active_tab_idx - 1) % @tabs.length
+          @functions = @tab_contents[@tabs[@active_tab_idx]] || []
+          @index = 0
+          @level = 0
+          @open_level = 0
+          @sub_index_1 = 0
+          @sub_index_2 = 0
+          @active_panel = :main
+          @submenu_open = false
+          draw_frame(target_width)
+          next
+        end
+      end
+
+      if @level == 2 && @open_level >= 2 && is_submenu_item?(@functions[@index])
+        s1_acts = get_submenu_actions(@functions[@index])
+        s2_acts = get_submenu_actions(s1_acts[@sub_index_1]) if s1_acts
+        if key == "\e[A" || key == "\eOA" || key == "\xe0H" || key == "\x00H"
+          @sub_index_2 = (@sub_index_2 - 1) % s2_acts.length if s2_acts && !s2_acts.empty?
+          draw_frame(target_width)
+          next
+        elsif key == "\e[B" || key == "\eOB" || key == "\xe0P" || key == "\x00P"
+          @sub_index_2 = (@sub_index_2 + 1) % s2_acts.length if s2_acts && !s2_acts.empty?
+          draw_frame(target_width)
+          next
+        elsif key == "\e[D" || key == "\eOD" || key == "\xe0K" || key == "\x00K" || key == "\e"
+          @open_level = 1
+          @level = 1
+          draw_frame(target_width)
+          next
+        elsif key == "\r" || key == "\n"
+          return s2_acts[@sub_index_2] if s2_acts && @sub_index_2 < s2_acts.length
+        end
+      end
+
+      if @level == 1 && @open_level >= 1 && is_submenu_item?(@functions[@index])
+        s1_acts = get_submenu_actions(@functions[@index])
+        if key == "\e[A" || key == "\eOA" || key == "\xe0H" || key == "\x00H"
+          @sub_index_1 = (@sub_index_1 - 1) % s1_acts.length if s1_acts && !s1_acts.empty?
+          @sub_index_2 = 0
+          draw_frame(target_width)
+          next
+        elsif key == "\e[B" || key == "\eOB" || key == "\xe0P" || key == "\x00P"
+          @sub_index_1 = (@sub_index_1 + 1) % s1_acts.length if s1_acts && !s1_acts.empty?
+          @sub_index_2 = 0
+          draw_frame(target_width)
+          next
+        elsif key == "\e[D" || key == "\eOD" || key == "\xe0K" || key == "\x00K" || key == "\e"
+          @open_level = 0
+          @level = 0
+          @active_panel = :main
+          @submenu_open = false
+          draw_frame(target_width)
+          next
+        elsif key == "\e[C" || key == "\eOC" || key == "\xe0M" || key == "\x00M"
+          cur_l1 = s1_acts[@sub_index_1] if s1_acts
+          if is_submenu_item?(cur_l1)
+            @open_level = 2
+            @level = 2
+            @sub_index_2 = 0
+            draw_frame(target_width)
+            next
+          end
+        elsif key == "\r" || key == "\n"
+          cur_l1 = s1_acts[@sub_index_1] if s1_acts
+          if is_submenu_item?(cur_l1)
+            @open_level = 2
+            @level = 2
+            @sub_index_2 = 0
+            draw_frame(target_width)
+            next
+          else
+            return cur_l1
+          end
+        end
+      end
+
       if !@search && (key == "q" || key == "Q")
         break
       end
@@ -2307,16 +4100,38 @@ class GRmenu
         end
       elsif key == "\e[A" || key == "\eOA" || key == "\xe0H" || key == "\x00H"
         move_up
+        @sub_index_1 = 0
+        @sub_index_2 = 0
         draw_frame(target_width)
       elsif key == "\e[B" || key == "\eOB" || key == "\xe0P" || key == "\x00P"
         move_down
+        @sub_index_1 = 0
+        @sub_index_2 = 0
         draw_frame(target_width)
       elsif key == "\e[D" || key == "\eOD" || key == "\xe0K" || key == "\x00K"
-        move_left
-        draw_frame(target_width)
+        if @open_level > 0
+          @open_level = 0
+          @level = 0
+          @active_panel = :main
+          @submenu_open = false
+          draw_frame(target_width)
+        else
+          move_left
+          draw_frame(target_width)
+        end
       elsif key == "\e[C" || key == "\eOC" || key == "\xe0M" || key == "\x00M"
-        move_right
-        draw_frame(target_width)
+        if is_submenu_item?(@functions[@index])
+          @open_level = 1
+          @level = 1
+          @sub_index_1 = 0
+          @sub_index_2 = 0
+          @active_panel = :sub
+          @submenu_open = true
+          draw_frame(target_width)
+        else
+          move_right
+          draw_frame(target_width)
+        end
       elsif key == "\x7f" || key == "\b" || key == "\x08"
         if @search && !@query.empty?
           @query.chop!
@@ -2333,7 +4148,19 @@ class GRmenu
         end
       elsif key == "\r" || key == "\n"
         matching = current_matching_indices
-        return @functions[@index] if matching.include?(@index)
+        if matching.include?(@index)
+          if is_submenu_item?(@functions[@index])
+            @open_level = 1
+            @level = 1
+            @sub_index_1 = 0
+            @sub_index_2 = 0
+            @active_panel = :sub
+            @submenu_open = true
+            draw_frame(target_width)
+          else
+            return @functions[@index]
+          end
+        end
       elsif @search && key =~ /^[[:print:]]$/
         @query << key
         matching = current_matching_indices