reline 0.1.5 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb0a1da0d5f51d50b82a78a3084a69ca37821b541e3c362bcb2b9a10a04664a3
-  data.tar.gz: bc1860cf76efa34984aef1dbafb60d1f7781b86ba44a9392dc5fbd8025631121
+  metadata.gz: 99b4f2cf521a3b774a0c763517fc373fdc2bf1603e64ab8e853513ed64946074
+  data.tar.gz: 4665d8f6c3db58c573186b4fb245478a1190fdb5da5f9c5f0d569bcfb2cba2f4
 SHA512:
-  metadata.gz: 4691bf1855429c5f1c25b16f66bc1e4793290579ae9a7345d1dd97c2694863bec59bab30edb232665b38a1f302a4e601c99111c84e5c277651ab2e53d4353982
-  data.tar.gz: 9ba7b27a82ce1d823f394c78ba1d995b6c4f71ddecb13c17c27fb39a13b7503c3b84402feb0239eb33d19d87f00d06c0608e35439413f6c72d2bdea50e84d10e
+  metadata.gz: 7b66388f8b9008f5008902e662133312006263622cf7d12d458f5611446b536baf7ff66197209e7b82ada8d34d1b0c8d6eb40c6be35315134c289ded8cc421f7
+  data.tar.gz: 74ce2b03a99eb548c25050f606140a9fd62351e2cbe20037977f416cc20153f3d711e946c84c4857e66b078a33b7dd12a359f429a2c31091ece7e8f776204931

data/lib/reline.rb

@@ -44,6 +44,7 @@ module Reline
       self.output = STDOUT
       yield self
       @completion_quote_character = nil
+      @bracketed_paste_finished = false
     end
 
     def encoding
@@ -199,7 +200,11 @@ module Reline
 
     private def inner_readline(prompt, add_hist, multiline, &confirm_multiline_termination)
       if ENV['RELINE_STDERR_TTY']
-        $stderr.reopen(ENV['RELINE_STDERR_TTY'], 'w')
+        if Reline::IOGate.win?
+          $stderr = File.open(ENV['RELINE_STDERR_TTY'], 'a')
+        else
+          $stderr.reopen(ENV['RELINE_STDERR_TTY'], 'w')
+        end
         $stderr.sync = true
         $stderr.puts "Reline is used by #{Process.pid}"
       end
@@ -235,13 +240,23 @@ module Reline
       line_editor.rerender
 
       begin
+        prev_pasting_state = false
         loop do
+          prev_pasting_state = Reline::IOGate.in_pasting?
           read_io(config.keyseq_timeout) { |inputs|
             inputs.each { |c|
               line_editor.input_key(c)
               line_editor.rerender
             }
+            if @bracketed_paste_finished
+              line_editor.rerender_all
+              @bracketed_paste_finished = false
+            end
           }
+          if prev_pasting_state == true and not Reline::IOGate.in_pasting? and not line_editor.finished?
+            prev_pasting_state = false
+            line_editor.rerender_all
+          end
           break if line_editor.finished?
         end
         Reline::IOGate.move_cursor_column(0)
@@ -269,8 +284,13 @@ module Reline
       buffer = []
       loop do
         c = Reline::IOGate.getc
-        buffer << c
-        result = key_stroke.match_status(buffer)
+        if c == -1
+          result = :unmatched
+          @bracketed_paste_finished = true
+        else
+          buffer << c
+          result = key_stroke.match_status(buffer)
+        end
         case result
         when :matched
           expanded = key_stroke.expand(buffer).map{ |expanded_c|

data/lib/reline/ansi.rb

@@ -1,4 +1,5 @@
 require 'io/console'
+require 'timeout'
 
 class Reline::ANSI
   def self.encoding
@@ -67,7 +68,7 @@ class Reline::ANSI
   end
 
   @@buf = []
-  def self.getc
+  def self.inner_getc
     unless @@buf.empty?
       return @@buf.shift
     end
@@ -80,6 +81,62 @@ class Reline::ANSI
     nil
   end
 
+  @@in_bracketed_paste_mode = false
+  START_BRACKETED_PASTE = String.new("\e[200~,", encoding: Encoding::ASCII_8BIT)
+  END_BRACKETED_PASTE = String.new("\e[200~.", encoding: Encoding::ASCII_8BIT)
+  def self.getc_with_bracketed_paste
+    buffer = String.new(encoding: Encoding::ASCII_8BIT)
+    buffer << inner_getc
+    while START_BRACKETED_PASTE.start_with?(buffer) or END_BRACKETED_PASTE.start_with?(buffer) do
+      if START_BRACKETED_PASTE == buffer
+        @@in_bracketed_paste_mode = true
+        return inner_getc
+      elsif END_BRACKETED_PASTE == buffer
+        @@in_bracketed_paste_mode = false
+        ungetc(-1)
+        return inner_getc
+      end
+      begin
+        succ_c = nil
+        Timeout.timeout(Reline.core.config.keyseq_timeout * 100) {
+          succ_c = inner_getc
+        }
+      rescue Timeout::Error
+        break
+      else
+        buffer << succ_c
+      end
+    end
+    buffer.bytes.reverse_each do |ch|
+      ungetc ch
+    end
+    inner_getc
+  end
+
+  def self.getc
+    if Reline.core.config.enable_bracketed_paste
+      getc_with_bracketed_paste
+    else
+      inner_getc
+    end
+  end
+
+  def self.in_pasting?
+    @@in_bracketed_paste_mode or (not Reline::IOGate.empty_buffer?)
+  end
+
+  def self.empty_buffer?
+    unless @@buf.empty?
+      return false
+    end
+    rs, = IO.select([@@input], [], [], 0.00001)
+    if rs and rs[0]
+      false
+    else
+      true
+    end
+  end
+
   def self.ungetc(c)
     @@buf.unshift(c)
   end
@@ -115,7 +172,7 @@ class Reline::ANSI
 
   def self.cursor_pos
     begin
-      res = ''
+      res = +''
       m = nil
       @@input.raw do |stdin|
         @@output << "\e[6n"

data/lib/reline/config.rb

@@ -37,6 +37,7 @@ class Reline::Config
     vi-cmd-mode-icon
     vi-ins-mode-icon
     emacs-mode-string
+    enable-bracketed-paste
   }
   VARIABLE_NAME_SYMBOLS = VARIABLE_NAMES.map { |v| :"#{v.tr(?-, ?_)}" }
   VARIABLE_NAME_SYMBOLS.each do |v|

data/lib/reline/general_io.rb

@@ -1,6 +1,10 @@
 require 'timeout'
 
 class Reline::GeneralIO
+  def self.reset
+    @@pasting = false
+  end
+
   def self.encoding
     RUBY_PLATFORM =~ /mswin|mingw/ ? Encoding::UTF_8 : Encoding::default_external
   end
@@ -67,6 +71,20 @@ class Reline::GeneralIO
   def self.set_winch_handler(&handler)
   end
 
+  @@pasting = false
+
+  def self.in_pasting?
+    @@pasting
+  end
+
+  def self.start_pasting
+    @@pasting = true
+  end
+
+  def self.finish_pasting
+    @@pasting = false
+  end
+
   def self.prep
   end
 

data/lib/reline/key_actor/emacs.rb

@@ -307,7 +307,7 @@ class Reline::KeyActor::Emacs < Reline::KeyActor::Base
     # 152 M-^X
     :ed_unassigned,
     # 153 M-^Y
-    :ed_unassigned,
+    :em_yank_pop,
     # 154 M-^Z
     :ed_unassigned,
     # 155 M-^[

data/lib/reline/key_actor/vi_command.rb

@@ -17,7 +17,7 @@ class Reline::KeyActor::ViCommand < Reline::KeyActor::Base
     #   7 ^G
     :ed_unassigned,
     #   8 ^H
-    :ed_delete_prev_char,
+    :ed_unassigned,
     #   9 ^I
     :ed_unassigned,
     #  10 ^J
@@ -255,7 +255,7 @@ class Reline::KeyActor::ViCommand < Reline::KeyActor::Base
     # 126 ~
     :vi_change_case,
     # 127 ^?
-    :ed_delete_prev_char,
+    :ed_unassigned,
     # 128 M-^@
     :ed_unassigned,
     # 129 M-^A

data/lib/reline/kill_ring.rb

@@ -1,4 +1,6 @@
 class Reline::KillRing
+  include Enumerable
+
   module State
     FRESH = :fresh
     CONTINUED = :continued
@@ -110,4 +112,14 @@ class Reline::KillRing
       nil
     end
   end
+
+  def each
+    start = head = @ring.head
+    loop do
+      break if head.nil?
+      yield head.str
+      head = head.backward
+      break if head == start
+    end
+  end
 end

data/lib/reline/line_editor.rb

@@ -50,12 +50,24 @@ class Reline::LineEditor
   CompletionJourneyData = Struct.new('CompletionJourneyData', :preposing, :postposing, :list, :pointer)
   MenuInfo = Struct.new('MenuInfo', :target, :list)
 
+  PROMPT_LIST_CACHE_TIMEOUT = 0.5
+
   def initialize(config, encoding)
     @config = config
     @completion_append_character = ''
     reset_variables(encoding: encoding)
   end
 
+  def simplified_rendering?
+    if finished?
+      false
+    elsif @just_cursor_moving and not @rerender_all
+      true
+    else
+      not @rerender_all and not finished? and Reline::IOGate.in_pasting?
+    end
+  end
+
   private def check_multiline_prompt(buffer, prompt)
     if @vi_arg
       prompt = "(arg: #{@vi_arg}) "
@@ -66,8 +78,22 @@ class Reline::LineEditor
     else
       prompt = @prompt
     end
+    return [prompt, calculate_width(prompt, true), [prompt] * buffer.size] if simplified_rendering?
     if @prompt_proc
-      prompt_list = @prompt_proc.(buffer)
+      use_cached_prompt_list = false
+      if @cached_prompt_list
+        if @just_cursor_moving
+          use_cached_prompt_list = true
+        elsif Time.now.to_f < (@prompt_cache_time + PROMPT_LIST_CACHE_TIMEOUT) and buffer.size == @cached_prompt_list.size
+          use_cached_prompt_list = true
+        end
+      end
+      if use_cached_prompt_list
+        prompt_list = @cached_prompt_list
+      else
+        prompt_list = @cached_prompt_list = @prompt_proc.(buffer)
+        @prompt_cache_time = Time.now.to_f
+      end
       prompt_list.map!{ prompt } if @vi_arg or @searching_prompt
       if @config.show_mode_in_prompt
         if @config.editing_mode_is?(:vi_command)
@@ -105,6 +131,7 @@ class Reline::LineEditor
   def reset(prompt = '', encoding:)
     @rest_height = (Reline::IOGate.get_screen_size.first - 1) - Reline::IOGate.cursor_pos.y
     @screen_size = Reline::IOGate.get_screen_size
+    @screen_height = @screen_size.first
     reset_variables(prompt, encoding: encoding)
     @old_trap = Signal.trap('SIGINT') {
       @old_trap.call if @old_trap.respond_to?(:call) # can also be string, ex: "DEFAULT"
@@ -114,6 +141,7 @@ class Reline::LineEditor
       @rest_height = (Reline::IOGate.get_screen_size.first - 1) - Reline::IOGate.cursor_pos.y
       old_screen_size = @screen_size
       @screen_size = Reline::IOGate.get_screen_size
+      @screen_height = @screen_size.first
       if old_screen_size.last < @screen_size.last # columns increase
         @rerender_all = true
         rerender
@@ -165,11 +193,12 @@ class Reline::LineEditor
     @cleared = false
     @rerender_all = false
     @history_pointer = nil
-    @kill_ring = Reline::KillRing.new
+    @kill_ring ||= Reline::KillRing.new
     @vi_clipboard = ''
     @vi_arg = nil
     @waiting_proc = nil
     @waiting_operator_proc = nil
+    @waiting_operator_vi_arg = nil
     @completion_journey_data = nil
     @completion_state = CompletionState::NORMAL
     @perfect_matched = nil
@@ -177,7 +206,13 @@ class Reline::LineEditor
     @first_prompt = true
     @searching_prompt = nil
     @first_char = true
+    @add_newline_to_end_of_buffer = false
+    @just_cursor_moving = nil
+    @cached_prompt_list = nil
+    @prompt_cache_time = nil
     @eof = false
+    @continuous_insertion_buffer = String.new(encoding: @encoding)
+    @scroll_partial_screen = nil
     reset_line
   end
 
@@ -222,6 +257,7 @@ class Reline::LineEditor
     @buffer_of_lines.insert(@line_index + 1, String.new(next_line, encoding: @encoding))
     @previous_line_index = @line_index
     @line_index += 1
+    @just_cursor_moving = false
   end
 
   private def calculate_height_by_width(width)
@@ -262,28 +298,28 @@ class Reline::LineEditor
     end
   end
 
-  private def calculate_nearest_cursor
-    @cursor_max = calculate_width(line)
+  private def calculate_nearest_cursor(line_to_calc = @line, cursor = @cursor, started_from = @started_from, byte_pointer = @byte_pointer, update = true)
+    new_cursor_max = calculate_width(line_to_calc)
     new_cursor = 0
     new_byte_pointer = 0
     height = 1
     max_width = @screen_size.last
     if @config.editing_mode_is?(:vi_command)
-      last_byte_size = Reline::Unicode.get_prev_mbchar_size(@line, @line.bytesize)
+      last_byte_size = Reline::Unicode.get_prev_mbchar_size(line_to_calc, line_to_calc.bytesize)
       if last_byte_size > 0
-        last_mbchar = @line.byteslice(@line.bytesize - last_byte_size, last_byte_size)
+        last_mbchar = line_to_calc.byteslice(line_to_calc.bytesize - last_byte_size, last_byte_size)
         last_width = Reline::Unicode.get_mbchar_width(last_mbchar)
-        cursor_max = @cursor_max - last_width
+        end_of_line_cursor = new_cursor_max - last_width
       else
-        cursor_max = @cursor_max
+      end_of_line_cursor = new_cursor_max
       end
     else
-      cursor_max = @cursor_max
+    end_of_line_cursor = new_cursor_max
     end
-    @line.encode(Encoding::UTF_8).grapheme_clusters.each do |gc|
+    line_to_calc.encode(Encoding::UTF_8).grapheme_clusters.each do |gc|
       mbchar_width = Reline::Unicode.get_mbchar_width(gc)
       now = new_cursor + mbchar_width
-      if now > cursor_max or now > @cursor
+      if now > end_of_line_cursor or now > cursor
         break
       end
       new_cursor += mbchar_width
@@ -292,9 +328,21 @@ class Reline::LineEditor
       end
       new_byte_pointer += gc.bytesize
     end
-    @started_from = height - 1
-    @cursor = new_cursor
-    @byte_pointer = new_byte_pointer
+    new_started_from = height - 1
+    if update
+      @cursor = new_cursor
+      @cursor_max = new_cursor_max
+      @started_from = new_started_from
+      @byte_pointer = new_byte_pointer
+    else
+      [new_cursor, new_cursor_max, new_started_from, new_byte_pointer]
+    end
+  end
+
+  def rerender_all
+    @rerender_all = true
+    process_insert(force: true)
+    rerender
   end
 
   def rerender
@@ -302,168 +350,53 @@ class Reline::LineEditor
     if @menu_info
       scroll_down(@highest_in_all - @first_line_started_from)
       @rerender_all = true
-      @menu_info.list.sort!.each do |item|
-        Reline::IOGate.move_cursor_column(0)
-        @output.write item
-        @output.flush
-        scroll_down(1)
-      end
-      scroll_down(@highest_in_all - 1)
-      move_cursor_up(@highest_in_all - 1 - @first_line_started_from)
+    end
+    if @menu_info
+      show_menu
       @menu_info = nil
     end
     prompt, prompt_width, prompt_list = check_multiline_prompt(whole_lines, prompt)
     if @cleared
-      Reline::IOGate.clear_screen
+      clear_screen_buffer(prompt, prompt_list, prompt_width)
       @cleared = false
-      back = 0
-      modify_lines(whole_lines).each_with_index do |line, index|
-        if @prompt_proc
-          pr = prompt_list[index]
-          height = render_partial(pr, calculate_width(pr), line, false)
-        else
-          height = render_partial(prompt, prompt_width, line, false)
-        end
-        if index < (@buffer_of_lines.size - 1)
-          move_cursor_down(height)
-          back += height
-        end
-      end
-      move_cursor_up(back)
-      move_cursor_down(@first_line_started_from + @started_from)
-      Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
       return
     end
     new_highest_in_this = calculate_height_by_width(prompt_width + calculate_width(@line.nil? ? '' : @line))
     # FIXME: end of logical line sometimes breaks
-    if @previous_line_index or new_highest_in_this != @highest_in_this
-      if @previous_line_index
-        new_lines = whole_lines(index: @previous_line_index, line: @line)
-      else
-        new_lines = whole_lines
-      end
-      prompt, prompt_width, prompt_list = check_multiline_prompt(new_lines, prompt)
-      all_height = calculate_height_by_lines(new_lines, prompt_list || prompt)
-      diff = all_height - @highest_in_all
-      move_cursor_down(@highest_in_all - @first_line_started_from - @started_from - 1)
-      if diff > 0
-        scroll_down(diff)
-        move_cursor_up(all_height - 1)
-      elsif diff < 0
-        (-diff).times do
-          Reline::IOGate.move_cursor_column(0)
-          Reline::IOGate.erase_after_cursor
-          move_cursor_up(1)
-        end
-        move_cursor_up(all_height - 1)
+    if @add_newline_to_end_of_buffer
+      rerender_added_newline
+      @add_newline_to_end_of_buffer = false
+    else
+      if @just_cursor_moving and not @rerender_all
+        rendered = just_move_cursor
+        @just_cursor_moving = false
+        return
+      elsif @previous_line_index or new_highest_in_this != @highest_in_this
+        rerender_changed_current_line
+        @previous_line_index = nil
+        rendered = true
+      elsif @rerender_all
+        rerender_all_lines
+        @rerender_all = false
+        rendered = true
       else
-        move_cursor_up(all_height - 1)
-      end
-      @highest_in_all = all_height
-      back = 0
-      modify_lines(new_lines).each_with_index do |line, index|
-        if @prompt_proc
-          prompt = prompt_list[index]
-          prompt_width = calculate_width(prompt, true)
-        end
-        height = render_partial(prompt, prompt_width, line, false)
-        if index < (new_lines.size - 1)
-          scroll_down(1)
-          back += height
-        else
-          back += height - 1
-        end
-      end
-      move_cursor_up(back)
-      if @previous_line_index
-        @buffer_of_lines[@previous_line_index] = @line
-        @line = @buffer_of_lines[@line_index]
-      end
-      @first_line_started_from =
-        if @line_index.zero?
-          0
-        else
-          calculate_height_by_lines(@buffer_of_lines[0..(@line_index - 1)], prompt_list || prompt)
-        end
-      if @prompt_proc
-        prompt = prompt_list[@line_index]
-        prompt_width = calculate_width(prompt, true)
-      end
-      move_cursor_down(@first_line_started_from)
-      calculate_nearest_cursor
-      @started_from = calculate_height_by_width(prompt_width + @cursor) - 1
-      move_cursor_down(@started_from)
-      Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
-      @highest_in_this = calculate_height_by_width(prompt_width + @cursor_max)
-      @previous_line_index = nil
-      rendered = true
-    elsif @rerender_all
-      move_cursor_up(@first_line_started_from + @started_from)
-      Reline::IOGate.move_cursor_column(0)
-      back = 0
-      new_buffer = whole_lines
-      prompt, prompt_width, prompt_list = check_multiline_prompt(new_buffer, prompt)
-      new_buffer.each_with_index do |line, index|
-        prompt_width = calculate_width(prompt_list[index], true) if @prompt_proc
-        width = prompt_width + calculate_width(line)
-        height = calculate_height_by_width(width)
-        back += height
-      end
-      if back > @highest_in_all
-        scroll_down(back - 1)
-        move_cursor_up(back - 1)
-      elsif back < @highest_in_all
-        scroll_down(back)
-        Reline::IOGate.erase_after_cursor
-        (@highest_in_all - back - 1).times do
-          scroll_down(1)
-          Reline::IOGate.erase_after_cursor
-        end
-        move_cursor_up(@highest_in_all - 1)
-      end
-      modify_lines(new_buffer).each_with_index do |line, index|
-        if @prompt_proc
-          prompt = prompt_list[index]
-          prompt_width = calculate_width(prompt, true)
-        end
-        render_partial(prompt, prompt_width, line, false)
-        if index < (new_buffer.size - 1)
-          move_cursor_down(1)
-        end
       end
-      move_cursor_up(back - 1)
-      if @prompt_proc
-        prompt = prompt_list[@line_index]
-        prompt_width = calculate_width(prompt, true)
-      end
-      @highest_in_all = back
-      @highest_in_this = calculate_height_by_width(prompt_width + @cursor_max)
-      @first_line_started_from =
-        if @line_index.zero?
-          0
-        else
-          calculate_height_by_lines(new_buffer[0..(@line_index - 1)], prompt_list || prompt)
-        end
-      @started_from = calculate_height_by_width(prompt_width + @cursor) - 1
-      move_cursor_down(@first_line_started_from + @started_from)
-      Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
-      @rerender_all = false
-      rendered = true
     end
     line = modify_lines(whole_lines)[@line_index]
     if @is_multiline
       prompt, prompt_width, prompt_list = check_multiline_prompt(whole_lines, prompt)
       if finished?
         # Always rerender on finish because output_modifier_proc may return a different output.
-        render_partial(prompt, prompt_width, line)
+        render_partial(prompt, prompt_width, line, @first_line_started_from)
         scroll_down(1)
         Reline::IOGate.move_cursor_column(0)
         Reline::IOGate.erase_after_cursor
       elsif not rendered
-        render_partial(prompt, prompt_width, line)
+        render_partial(prompt, prompt_width, line, @first_line_started_from)
       end
+      @buffer_of_lines[@line_index] = @line
     else
-      render_partial(prompt, prompt_width, line)
+      render_partial(prompt, prompt_width, line, 0)
       if finished?
         scroll_down(1)
         Reline::IOGate.move_cursor_column(0)
@@ -472,8 +405,237 @@ class Reline::LineEditor
     end
   end
 
-  private def render_partial(prompt, prompt_width, line_to_render, with_control = true)
+  private def calculate_scroll_partial_screen(highest_in_all, cursor_y)
+    if @screen_height < highest_in_all
+      old_scroll_partial_screen = @scroll_partial_screen
+      if cursor_y == 0
+        @scroll_partial_screen = 0
+      elsif cursor_y == (highest_in_all - 1)
+        @scroll_partial_screen = highest_in_all - @screen_height
+      else
+        if @scroll_partial_screen
+          if cursor_y <= @scroll_partial_screen
+            @scroll_partial_screen = cursor_y
+          elsif (@scroll_partial_screen + @screen_height - 1) < cursor_y
+            @scroll_partial_screen = cursor_y - (@screen_height - 1)
+          end
+        else
+          if cursor_y > (@screen_height - 1)
+            @scroll_partial_screen = cursor_y - (@screen_height - 1)
+          else
+            @scroll_partial_screen = 0
+          end
+        end
+      end
+      if @scroll_partial_screen != old_scroll_partial_screen
+        @rerender_all = true
+      end
+    else
+      if @scroll_partial_screen
+        @rerender_all = true
+      end
+      @scroll_partial_screen = nil
+    end
+  end
+
+  private def rerender_added_newline
+    scroll_down(1)
+    new_lines = whole_lines(index: @previous_line_index, line: @line)
+    prompt, prompt_width, = check_multiline_prompt(new_lines, prompt)
+    @buffer_of_lines[@previous_line_index] = @line
+    @line = @buffer_of_lines[@line_index]
+    render_partial(prompt, prompt_width, @line, @first_line_started_from + @started_from + 1, with_control: false)
+    @cursor = @cursor_max = calculate_width(@line)
+    @byte_pointer = @line.bytesize
+    @highest_in_all += @highest_in_this
+    @highest_in_this = calculate_height_by_width(prompt_width + @cursor_max)
+    @first_line_started_from += @started_from + 1
+    @started_from = calculate_height_by_width(prompt_width + @cursor) - 1
+    @previous_line_index = nil
+  end
+
+  def just_move_cursor
+    prompt, prompt_width, prompt_list = check_multiline_prompt(@buffer_of_lines, prompt)
+    move_cursor_up(@started_from)
+    new_first_line_started_from =
+      if @line_index.zero?
+        0
+      else
+        calculate_height_by_lines(@buffer_of_lines[0..(@line_index - 1)], prompt_list || prompt)
+      end
+    first_line_diff = new_first_line_started_from - @first_line_started_from
+    new_cursor, _, new_started_from, _ = calculate_nearest_cursor(@line, @cursor, @started_from, @byte_pointer, false)
+    new_started_from = calculate_height_by_width(prompt_width + new_cursor) - 1
+    calculate_scroll_partial_screen(@highest_in_all, new_first_line_started_from + new_started_from)
+    @previous_line_index = nil
+    if @rerender_all
+      @line = @buffer_of_lines[@line_index]
+      rerender_all_lines
+      @rerender_all = false
+      true
+    else
+      @line = @buffer_of_lines[@line_index]
+      @first_line_started_from = new_first_line_started_from
+      @started_from = new_started_from
+      @cursor = new_cursor
+      move_cursor_down(first_line_diff + @started_from)
+      Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
+      false
+    end
+  end
+
+  private def rerender_changed_current_line
+    if @previous_line_index
+      new_lines = whole_lines(index: @previous_line_index, line: @line)
+    else
+      new_lines = whole_lines
+    end
+    prompt, prompt_width, prompt_list = check_multiline_prompt(new_lines, prompt)
+    all_height = calculate_height_by_lines(new_lines, prompt_list || prompt)
+    diff = all_height - @highest_in_all
+    move_cursor_down(@highest_in_all - @first_line_started_from - @started_from - 1)
+    if diff > 0
+      scroll_down(diff)
+      move_cursor_up(all_height - 1)
+    elsif diff < 0
+      (-diff).times do
+        Reline::IOGate.move_cursor_column(0)
+        Reline::IOGate.erase_after_cursor
+        move_cursor_up(1)
+      end
+      move_cursor_up(all_height - 1)
+    else
+      move_cursor_up(all_height - 1)
+    end
+    @highest_in_all = all_height
+    back = render_whole_lines(new_lines, prompt_list || prompt, prompt_width)
+    move_cursor_up(back)
+    if @previous_line_index
+      @buffer_of_lines[@previous_line_index] = @line
+      @line = @buffer_of_lines[@line_index]
+    end
+    @first_line_started_from =
+      if @line_index.zero?
+        0
+      else
+        calculate_height_by_lines(@buffer_of_lines[0..(@line_index - 1)], prompt_list || prompt)
+      end
+    if @prompt_proc
+      prompt = prompt_list[@line_index]
+      prompt_width = calculate_width(prompt, true)
+    end
+    move_cursor_down(@first_line_started_from)
+    calculate_nearest_cursor
+    @started_from = calculate_height_by_width(prompt_width + @cursor) - 1
+    move_cursor_down(@started_from)
+    Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
+    @highest_in_this = calculate_height_by_width(prompt_width + @cursor_max)
+  end
+
+  private def rerender_all_lines
+    move_cursor_up(@first_line_started_from + @started_from)
+    Reline::IOGate.move_cursor_column(0)
+    back = 0
+    new_buffer = whole_lines
+    prompt, prompt_width, prompt_list = check_multiline_prompt(new_buffer, prompt)
+    new_buffer.each_with_index do |line, index|
+      prompt_width = calculate_width(prompt_list[index], true) if @prompt_proc
+      width = prompt_width + calculate_width(line)
+      height = calculate_height_by_width(width)
+      back += height
+    end
+    old_highest_in_all = @highest_in_all
+    if @line_index.zero?
+      new_first_line_started_from = 0
+    else
+      new_first_line_started_from = calculate_height_by_lines(new_buffer[0..(@line_index - 1)], prompt_list || prompt)
+    end
+    new_started_from = calculate_height_by_width(prompt_width + @cursor) - 1
+    if back > old_highest_in_all
+      scroll_down(back - 1)
+      move_cursor_up(back - 1)
+    elsif back < old_highest_in_all
+      scroll_down(back)
+      Reline::IOGate.erase_after_cursor
+      (old_highest_in_all - back - 1).times do
+        scroll_down(1)
+        Reline::IOGate.erase_after_cursor
+      end
+      move_cursor_up(old_highest_in_all - 1)
+    end
+    calculate_scroll_partial_screen(back, new_first_line_started_from + new_started_from)
+    render_whole_lines(new_buffer, prompt_list || prompt, prompt_width)
+    if @prompt_proc
+      prompt = prompt_list[@line_index]
+      prompt_width = calculate_width(prompt, true)
+    end
+    @highest_in_this = calculate_height_by_width(prompt_width + @cursor_max)
+    @highest_in_all = back
+    @first_line_started_from = new_first_line_started_from
+    @started_from = new_started_from
+    if @scroll_partial_screen
+      Reline::IOGate.move_cursor_up(@screen_height - (@first_line_started_from + @started_from - @scroll_partial_screen) - 1)
+      Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
+    else
+      move_cursor_down(@first_line_started_from + @started_from - back + 1)
+      Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
+    end
+  end
+
+  private def render_whole_lines(lines, prompt, prompt_width)
+    rendered_height = 0
+    modify_lines(lines).each_with_index do |line, index|
+      if prompt.is_a?(Array)
+        line_prompt = prompt[index]
+        prompt_width = calculate_width(line_prompt, true)
+      else
+        line_prompt = prompt
+      end
+      height = render_partial(line_prompt, prompt_width, line, rendered_height, with_control: false)
+      if index < (lines.size - 1)
+        if @scroll_partial_screen
+          if (@scroll_partial_screen - height) < rendered_height and (@scroll_partial_screen + @screen_height - 1) >= (rendered_height + height)
+            move_cursor_down(1)
+          end
+        else
+          scroll_down(1)
+        end
+        rendered_height += height
+      else
+        rendered_height += height - 1
+      end
+    end
+    rendered_height
+  end
+
+  private def render_partial(prompt, prompt_width, line_to_render, this_started_from, with_control: true)
     visual_lines, height = split_by_width(line_to_render.nil? ? prompt : prompt + line_to_render, @screen_size.last)
+    cursor_up_from_last_line = 0
+    # TODO: This logic would be sometimes buggy if this logical line isn't the current @line_index.
+    if @scroll_partial_screen
+      last_visual_line = this_started_from + (height - 1)
+      last_screen_line = @scroll_partial_screen + (@screen_height - 1)
+      if (@scroll_partial_screen - this_started_from) >= height
+        # Render nothing because this line is before the screen.
+        visual_lines = []
+      elsif this_started_from > last_screen_line
+        # Render nothing because this line is after the screen.
+        visual_lines = []
+      else
+        deleted_lines_before_screen = []
+        if @scroll_partial_screen > this_started_from and last_visual_line >= @scroll_partial_screen
+          # A part of visual lines are before the screen.
+          deleted_lines_before_screen = visual_lines.shift((@scroll_partial_screen - this_started_from) * 2)
+          deleted_lines_before_screen.compact!
+        end
+        if this_started_from <= last_screen_line and last_screen_line < last_visual_line
+          # A part of visual lines are after the screen.
+          visual_lines.pop((last_visual_line - last_screen_line) * 2)
+        end
+        move_cursor_up(deleted_lines_before_screen.size - @started_from)
+        cursor_up_from_last_line = @started_from - deleted_lines_before_screen.size
+      end
+    end
     if with_control
       if height > @highest_in_this
         diff = height - @highest_in_this
@@ -487,10 +649,14 @@ class Reline::LineEditor
         @highest_in_this = height
       end
       move_cursor_up(@started_from)
+      cursor_up_from_last_line = height - 1 - @started_from
       @started_from = calculate_height_by_width(prompt_width + @cursor) - 1
     end
-    Reline::IOGate.move_cursor_column(0)
+    if Reline::Unicode::CSI_REGEXP.match?(prompt + line_to_render)
+      @output.write "\e[0m" # clear character decorations
+    end
     visual_lines.each_with_index do |line, index|
+      Reline::IOGate.move_cursor_column(0)
       if line.nil?
         if calculate_width(visual_lines[index - 1], true) == Reline::IOGate.get_screen_size.last
           # reaches the end of line
@@ -522,14 +688,18 @@ class Reline::LineEditor
         @pre_input_hook&.call
       end
     end
-    Reline::IOGate.erase_after_cursor
+    unless visual_lines.empty?
+      Reline::IOGate.erase_after_cursor
+      Reline::IOGate.move_cursor_column(0)
+    end
     if with_control
       # Just after rendring, so the cursor is on the last line.
       if finished?
         Reline::IOGate.move_cursor_column(0)
       else
         # Moves up from bottom of lines to the cursor position.
-        move_cursor_up(height - 1 - @started_from)
+        move_cursor_up(cursor_up_from_last_line)
+        # This logic is buggy if a fullwidth char is wrapped because there is only one halfwidth at end of a line.
         Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
       end
     end
@@ -537,7 +707,7 @@ class Reline::LineEditor
   end
 
   private def modify_lines(before)
-    return before if before.nil? || before.empty?
+    return before if before.nil? || before.empty? || simplified_rendering?
 
     if after = @output_modifier_proc&.call("#{before.join("\n")}\n", complete: finished?)
       after.lines("\n").map { |l| l.chomp('') }
@@ -546,6 +716,39 @@ class Reline::LineEditor
     end
   end
 
+  private def show_menu
+    scroll_down(@highest_in_all - @first_line_started_from)
+    @rerender_all = true
+    @menu_info.list.sort!.each do |item|
+      Reline::IOGate.move_cursor_column(0)
+      @output.write item
+      @output.flush
+      scroll_down(1)
+    end
+    scroll_down(@highest_in_all - 1)
+    move_cursor_up(@highest_in_all - 1 - @first_line_started_from)
+  end
+
+  private def clear_screen_buffer(prompt, prompt_list, prompt_width)
+    Reline::IOGate.clear_screen
+    back = 0
+    modify_lines(whole_lines).each_with_index do |line, index|
+      if @prompt_proc
+        pr = prompt_list[index]
+        height = render_partial(pr, calculate_width(pr), line, back, with_control: false)
+      else
+        height = render_partial(prompt, prompt_width, line, back, with_control: false)
+      end
+      if index < (@buffer_of_lines.size - 1)
+        move_cursor_down(height)
+        back += height
+      end
+    end
+    move_cursor_up(back)
+    move_cursor_down(@first_line_started_from + @started_from)
+    Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
+  end
+
   def editing_mode
     @config.editing_mode
   end
@@ -565,7 +768,7 @@ class Reline::LineEditor
       else
         i&.start_with?(target)
       end
-    }
+    }.uniq
     if is_menu
       menu(target, list)
       return nil
@@ -682,7 +885,8 @@ class Reline::LineEditor
     if @waiting_operator_proc
       if VI_MOTIONS.include?(method_symbol)
         old_cursor, old_byte_pointer = @cursor, @byte_pointer
-        block.()
+        @vi_arg = @waiting_operator_vi_arg if @waiting_operator_vi_arg > 1
+        block.(true)
         unless @waiting_proc
           cursor_diff, byte_pointer_diff = @cursor - old_cursor, @byte_pointer - old_byte_pointer
           @cursor, @byte_pointer = old_cursor, old_byte_pointer
@@ -690,27 +894,56 @@ class Reline::LineEditor
         else
           old_waiting_proc = @waiting_proc
           old_waiting_operator_proc = @waiting_operator_proc
+          current_waiting_operator_proc = @waiting_operator_proc
           @waiting_proc = proc { |k|
             old_cursor, old_byte_pointer = @cursor, @byte_pointer
             old_waiting_proc.(k)
             cursor_diff, byte_pointer_diff = @cursor - old_cursor, @byte_pointer - old_byte_pointer
             @cursor, @byte_pointer = old_cursor, old_byte_pointer
-            @waiting_operator_proc.(cursor_diff, byte_pointer_diff)
+            current_waiting_operator_proc.(cursor_diff, byte_pointer_diff)
             @waiting_operator_proc = old_waiting_operator_proc
           }
         end
       else
         # Ignores operator when not motion is given.
-        block.()
+        block.(false)
       end
       @waiting_operator_proc = nil
+      @waiting_operator_vi_arg = nil
+      @vi_arg = nil
     else
-      block.()
+      block.(false)
     end
   end
 
   private def argumentable?(method_obj)
-    method_obj and method_obj.parameters.length != 1
+    method_obj and method_obj.parameters.any? { |param| param[0] == :key and param[1] == :arg }
+  end
+
+  private def inclusive?(method_obj)
+    # If a motion method with the keyword argument "inclusive" follows the
+    # operator, it must contain the character at the cursor position.
+    method_obj and method_obj.parameters.any? { |param| param[0] == :key and param[1] == :inclusive }
+  end
+
+  def wrap_method_call(method_symbol, method_obj, key, with_operator = false)
+    if @config.editing_mode_is?(:emacs, :vi_insert) and @waiting_proc.nil? and @waiting_operator_proc.nil?
+      not_insertion = method_symbol != :ed_insert
+      process_insert(force: not_insertion)
+    end
+    if @vi_arg and argumentable?(method_obj)
+      if with_operator and inclusive?(method_obj)
+        method_obj.(key, arg: @vi_arg, inclusive: true)
+      else
+        method_obj.(key, arg: @vi_arg)
+      end
+    else
+      if with_operator and inclusive?(method_obj)
+        method_obj.(key, inclusive: true)
+      else
+        method_obj.(key)
+      end
+    end
   end
 
   private def process_key(key, method_symbol)
@@ -721,11 +954,11 @@ class Reline::LineEditor
     end
     if method_symbol and key.is_a?(Symbol)
       if @vi_arg and argumentable?(method_obj)
-        run_for_operators(key, method_symbol) do
-          method_obj.(key, arg: @vi_arg)
+        run_for_operators(key, method_symbol) do |with_operator|
+          wrap_method_call(method_symbol, method_obj, key, with_operator)
         end
       else
-        method_obj&.(key)
+        wrap_method_call(method_symbol, method_obj, key) if method_obj
       end
       @kill_ring.process
       @vi_arg = nil
@@ -734,15 +967,15 @@ class Reline::LineEditor
         ed_argument_digit(key)
       else
         if argumentable?(method_obj)
-          run_for_operators(key, method_symbol) do
-            method_obj.(key, arg: @vi_arg)
+          run_for_operators(key, method_symbol) do |with_operator|
+            wrap_method_call(method_symbol, method_obj, key, with_operator)
           end
         elsif @waiting_proc
           @waiting_proc.(key)
         elsif method_obj
-          method_obj.(key)
+          wrap_method_call(method_symbol, method_obj, key)
         else
-          ed_insert(key)
+          ed_insert(key) unless @config.editing_mode_is?(:vi_command)
         end
         @kill_ring.process
         @vi_arg = nil
@@ -752,15 +985,15 @@ class Reline::LineEditor
       @kill_ring.process
     elsif method_obj
       if method_symbol == :ed_argument_digit
-        method_obj.(key)
+        wrap_method_call(method_symbol, method_obj, key)
       else
-        run_for_operators(key, method_symbol) do
-          method_obj.(key)
+        run_for_operators(key, method_symbol) do |with_operator|
+          wrap_method_call(method_symbol, method_obj, key, with_operator)
         end
       end
       @kill_ring.process
     else
-      ed_insert(key)
+      ed_insert(key) unless @config.editing_mode_is?(:vi_command)
     end
   end
 
@@ -803,6 +1036,7 @@ class Reline::LineEditor
   end
 
   def input_key(key)
+    @just_cursor_moving = nil
     if key.char.nil?
       if @first_char
         @line = nil
@@ -810,6 +1044,7 @@ class Reline::LineEditor
       finish
       return
     end
+    old_line = @line.dup
     @first_char = false
     completion_occurs = false
     if @config.editing_mode_is?(:emacs, :vi_insert) and key.char == "\C-i".ord
@@ -817,6 +1052,7 @@ class Reline::LineEditor
         result = call_completion_proc
         if result.is_a?(Array)
           completion_occurs = true
+          process_insert
           complete(result)
         end
       end
@@ -825,6 +1061,7 @@ class Reline::LineEditor
         result = call_completion_proc
         if result.is_a?(Array)
           completion_occurs = true
+          process_insert
           move_completed_list(result, "\C-p".ord == key.char ? :up : :down)
         end
       end
@@ -836,7 +1073,18 @@ class Reline::LineEditor
     unless completion_occurs
       @completion_state = CompletionState::NORMAL
     end
-    if @is_multiline and @auto_indent_proc
+    if not Reline::IOGate.in_pasting? and @just_cursor_moving.nil?
+      if @previous_line_index and @buffer_of_lines[@previous_line_index] == @line
+        @just_cursor_moving = true
+      elsif @previous_line_index.nil? and @buffer_of_lines[@line_index] == @line and old_line == @line
+        @just_cursor_moving = true
+      else
+        @just_cursor_moving = false
+      end
+    else
+      @just_cursor_moving = false
+    end
+    if @is_multiline and @auto_indent_proc and not simplified_rendering?
       process_auto_indent
     end
   end
@@ -1038,6 +1286,7 @@ class Reline::LineEditor
 
   def finish
     @finished = true
+    @rerender_all = true
     @config.reset
   end
 
@@ -1066,6 +1315,9 @@ class Reline::LineEditor
 
   private def key_newline(key)
     if @is_multiline
+      if (@buffer_of_lines.size - 1) == @line_index and @line.bytesize == @byte_pointer
+        @add_newline_to_end_of_buffer = true
+      end
       next_line = @line.byteslice(@byte_pointer, @line.bytesize - @byte_pointer)
       cursor_line = @line.byteslice(0, @byte_pointer)
       insert_new_line(cursor_line, next_line)
@@ -1076,38 +1328,62 @@ class Reline::LineEditor
 
   private def ed_unassigned(key) end # do nothing
 
+  private def process_insert(force: false)
+    return if @continuous_insertion_buffer.empty? or (Reline::IOGate.in_pasting? and not force)
+    width = Reline::Unicode.calculate_width(@continuous_insertion_buffer)
+    bytesize = @continuous_insertion_buffer.bytesize
+    if @cursor == @cursor_max
+      @line += @continuous_insertion_buffer
+    else
+      @line = byteinsert(@line, @byte_pointer, @continuous_insertion_buffer)
+    end
+    @byte_pointer += bytesize
+    @cursor += width
+    @cursor_max += width
+    @continuous_insertion_buffer.clear
+  end
+
   private def ed_insert(key)
+    str = nil
+    width = nil
+    bytesize = nil
     if key.instance_of?(String)
       begin
         key.encode(Encoding::UTF_8)
       rescue Encoding::UndefinedConversionError
         return
       end
-      width = Reline::Unicode.get_mbchar_width(key)
-      if @cursor == @cursor_max
-        @line += key
-      else
-        @line = byteinsert(@line, @byte_pointer, key)
-      end
-      @byte_pointer += key.bytesize
-      @cursor += width
-      @cursor_max += width
+      str = key
+      bytesize = key.bytesize
     else
       begin
         key.chr.encode(Encoding::UTF_8)
       rescue Encoding::UndefinedConversionError
         return
       end
-      if @cursor == @cursor_max
-        @line += key.chr
-      else
-        @line = byteinsert(@line, @byte_pointer, key.chr)
-      end
-      width = Reline::Unicode.get_mbchar_width(key.chr)
-      @byte_pointer += 1
-      @cursor += width
-      @cursor_max += width
+      str = key.chr
+      bytesize = 1
+    end
+    if Reline::IOGate.in_pasting?
+      @continuous_insertion_buffer << str
+      return
+    elsif not @continuous_insertion_buffer.empty?
+      process_insert
+    end
+    width = Reline::Unicode.get_mbchar_width(str)
+    if @cursor == @cursor_max
+      @line += str
+    else
+      @line = byteinsert(@line, @byte_pointer, str)
+    end
+    last_byte_size = Reline::Unicode.get_prev_mbchar_size(@line, @byte_pointer)
+    @byte_pointer += bytesize
+    last_mbchar = @line.byteslice((@byte_pointer - bytesize - last_byte_size), last_byte_size)
+    if last_byte_size != 0 and (last_mbchar + str).grapheme_clusters.size == 1
+      width = 0
     end
+    @cursor += width
+    @cursor_max += width
   end
   alias_method :ed_digit, :ed_insert
   alias_method :self_insert, :ed_insert
@@ -1164,6 +1440,7 @@ class Reline::LineEditor
     arg -= 1
     ed_prev_char(key, arg: arg) if arg > 0
   end
+  alias_method :backward_char, :ed_prev_char
 
   private def vi_first_print(key)
     @byte_pointer, @cursor = Reline::Unicode.vi_first_print(@line)
@@ -1593,6 +1870,7 @@ class Reline::LineEditor
   end
 
   private def ed_newline(key)
+    process_insert(force: true)
     if @is_multiline
       if @config.editing_mode_is?(:vi_command)
         if @line_index < (@buffer_of_lines.size - 1)
@@ -1671,6 +1949,7 @@ class Reline::LineEditor
       @cursor = 0
     end
   end
+  alias_method :kill_line, :em_kill_line
 
   private def em_delete(key)
     if (not @is_multiline and @line.empty?) or (@is_multiline and @line.empty? and @buffer_of_lines.size == 1)
@@ -1721,6 +2000,7 @@ class Reline::LineEditor
       @byte_pointer += yanked.bytesize
     end
   end
+  alias_method :yank, :em_yank
 
   private def em_yank_pop(key)
     yanked, prev_yank = @kill_ring.yank_pop
@@ -1737,6 +2017,7 @@ class Reline::LineEditor
       @byte_pointer += yanked.bytesize
     end
   end
+  alias_method :yank_pop, :em_yank_pop
 
   private def ed_clear_screen(key)
     @cleared = true
@@ -1867,9 +2148,10 @@ class Reline::LineEditor
       @byte_pointer -= byte_size
       @cursor -= width
       @cursor_max -= width
-      @kill_ring.append(deleted)
+      @kill_ring.append(deleted, true)
     end
   end
+  alias_method :unix_word_rubout, :em_kill_region
 
   private def copy_for_vi(text)
     if @config.editing_mode_is?(:vi_insert) or @config.editing_mode_is?(:vi_command)
@@ -1890,7 +2172,7 @@ class Reline::LineEditor
     ed_prev_char(key)
     @config.editing_mode = :vi_command
   end
-  alias_method :backward_char, :ed_prev_char
+  alias_method :vi_movement_mode, :vi_command_mode
 
   private def vi_next_word(key, arg: 1)
     if @line.bytesize > @byte_pointer
@@ -1912,13 +2194,22 @@ class Reline::LineEditor
     vi_prev_word(key, arg: arg) if arg > 0
   end
 
-  private def vi_end_word(key, arg: 1)
+  private def vi_end_word(key, arg: 1, inclusive: false)
     if @line.bytesize > @byte_pointer
       byte_size, width = Reline::Unicode.vi_forward_end_word(@line, @byte_pointer)
       @byte_pointer += byte_size
       @cursor += width
     end
     arg -= 1
+    if inclusive and arg.zero?
+      byte_size = Reline::Unicode.get_next_mbchar_size(@line, @byte_pointer)
+      if byte_size > 0
+        c = @line.byteslice(@byte_pointer, byte_size)
+        width = Reline::Unicode.get_mbchar_width(c)
+        @byte_pointer += byte_size
+        @cursor += width
+      end
+    end
     vi_end_word(key, arg: arg) if arg > 0
   end
 
@@ -1942,13 +2233,22 @@ class Reline::LineEditor
     vi_prev_big_word(key, arg: arg) if arg > 0
   end
 
-  private def vi_end_big_word(key, arg: 1)
+  private def vi_end_big_word(key, arg: 1, inclusive: false)
     if @line.bytesize > @byte_pointer
       byte_size, width = Reline::Unicode.vi_big_forward_end_word(@line, @byte_pointer)
       @byte_pointer += byte_size
       @cursor += width
     end
     arg -= 1
+    if inclusive and arg.zero?
+      byte_size = Reline::Unicode.get_next_mbchar_size(@line, @byte_pointer)
+      if byte_size > 0
+        c = @line.byteslice(@byte_pointer, byte_size)
+        width = Reline::Unicode.get_mbchar_width(c)
+        @byte_pointer += byte_size
+        @cursor += width
+      end
+    end
     vi_end_big_word(key, arg: arg) if arg > 0
   end
 
@@ -2003,7 +2303,7 @@ class Reline::LineEditor
     @cursor = 0
   end
 
-  private def vi_change_meta(key)
+  private def vi_change_meta(key, arg: 1)
     @waiting_operator_proc = proc { |cursor_diff, byte_pointer_diff|
       if byte_pointer_diff > 0
         @line, cut = byteslice!(@line, @byte_pointer, byte_pointer_diff)
@@ -2016,9 +2316,10 @@ class Reline::LineEditor
       @byte_pointer += byte_pointer_diff if byte_pointer_diff < 0
       @config.editing_mode = :vi_insert
     }
+    @waiting_operator_vi_arg = arg
   end
 
-  private def vi_delete_meta(key)
+  private def vi_delete_meta(key, arg: 1)
     @waiting_operator_proc = proc { |cursor_diff, byte_pointer_diff|
       if byte_pointer_diff > 0
         @line, cut = byteslice!(@line, @byte_pointer, byte_pointer_diff)
@@ -2030,9 +2331,19 @@ class Reline::LineEditor
       @cursor_max -= cursor_diff.abs
       @byte_pointer += byte_pointer_diff if byte_pointer_diff < 0
     }
+    @waiting_operator_vi_arg = arg
   end
 
-  private def vi_yank(key)
+  private def vi_yank(key, arg: 1)
+    @waiting_operator_proc = proc { |cursor_diff, byte_pointer_diff|
+      if byte_pointer_diff > 0
+        cut = @line.byteslice(@byte_pointer, byte_pointer_diff)
+      elsif byte_pointer_diff < 0
+        cut = @line.byteslice(@byte_pointer + byte_pointer_diff, -byte_pointer_diff)
+      end
+      copy_for_vi(cut)
+    }
+    @waiting_operator_vi_arg = arg
   end
 
   private def vi_list_or_eof(key)
@@ -2177,15 +2488,15 @@ class Reline::LineEditor
     }
   end
 
-  private def vi_next_char(key, arg: 1)
-    @waiting_proc = ->(key_for_proc) { search_next_char(key_for_proc, arg) }
+  private def vi_next_char(key, arg: 1, inclusive: false)
+    @waiting_proc = ->(key_for_proc) { search_next_char(key_for_proc, arg, inclusive: inclusive) }
   end
 
-  private def vi_to_next_char(key, arg: 1)
-    @waiting_proc = ->(key_for_proc) { search_next_char(key_for_proc, arg, true) }
+  private def vi_to_next_char(key, arg: 1, inclusive: false)
+    @waiting_proc = ->(key_for_proc) { search_next_char(key_for_proc, arg, need_prev_char: true, inclusive: inclusive) }
   end
 
-  private def search_next_char(key, arg, need_prev_char = false)
+  private def search_next_char(key, arg, need_prev_char: false, inclusive: false)
     if key.instance_of?(String)
       inputed_char = key
     else
@@ -2222,6 +2533,15 @@ class Reline::LineEditor
       @byte_pointer += byte_size
       @cursor += width
     end
+    if inclusive
+      byte_size = Reline::Unicode.get_next_mbchar_size(@line, @byte_pointer)
+      if byte_size > 0
+        c = @line.byteslice(@byte_pointer, byte_size)
+        width = Reline::Unicode.get_mbchar_width(c)
+        @byte_pointer += byte_size
+        @cursor += width
+      end
+    end
     @waiting_proc = nil
   end
 
@@ -2293,6 +2613,7 @@ class Reline::LineEditor
   alias_method :set_mark, :em_set_mark
 
   private def em_exchange_mark(key)
+    return unless @mark_pointer
     new_pointer = [@byte_pointer, @line_index]
     @previous_line_index = @line_index
     @byte_pointer, @line_index = @mark_pointer