0.17.0

Make --expect additive
Similarly to --bind or --color. --expect used to replace the previously specified keys, and fzf#wrap({'options': '--expect=f1'}) wouldn't work as expected. It forced us to come up with some ugly hacks like the following: 13b27c45c8/autoload/fzf/vim.vim (L1086)
2025-11-15 14:53:47 -05:00 · 2017-08-27 03:32:21 +09:00 · 2017-08-27 02:19:56 +09:00 · 2017-08-27 01:46:11 +09:00 · 2017-08-26 20:09:46 +09:00 · 2017-08-26 03:24:42 +09:00
47 changed files with 1597 additions and 986 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@ Gemfile.lock
 .DS_Store
 doc/tags
 vendor
+gopath
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,19 +1,18 @@
 language: ruby
+dist: trusty
+sudo: required
 matrix:
  include:
    - env: TAGS=
      rvm: 2.3.3
 #   - env: TAGS=tcell
-#     rvm: 2.2.0
+#     rvm: 2.3.3

 install:
- sudo apt-get update
- sudo apt-get install -y libncurses-dev lib32ncurses5-dev libgpm-dev
 - sudo add-apt-repository -y ppa:pi-rho/dev
 - sudo apt-add-repository -y ppa:fish-shell/release-2
 - sudo apt-get update
- sudo apt-get install -y tmux=1.9a-1~ppa1~p
- sudo apt-get install -y zsh fish
+- sudo apt-get install -y tmux zsh fish

 script: |
  make test install &&
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,13 +1,42 @@
 CHANGELOG
 =========

+0.17.0
+------
+- Performance optimization
+- One can match literal spaces in extended-search mode with a space prepended
+  by a backslash.
+- `--expect` is now additive and can be specified multiple times.
+
+0.16.11
+-------
+- Performance optimization
+- Fixed missing preview update
+
+0.16.10
+-------
+- Fixed invalid handling of ANSI colors in preview window
+- Further improved `--ansi` performance
+
+0.16.9
+------
+- Memory and performance optimization
+    - Around 20% performance improvement for general use cases
+    - Up to 5x faster processing of `--ansi`
+    - Up to 50% reduction of memory usage
+- Bug fixes and usability improvements
+    - Fixed handling of bracketed paste mode
+    - [ERROR] on info line when the default command failed
+    - More efficient rendering of preview window
+    - `--no-clear` updated for repetitive relaunching scenarios
+
 0.16.8
 ------
 - New `change` event and `top` action for `--bind`
    - `fzf --bind change:top`
        - Move cursor to the top result whenever the query string is changed
-    - `fzf --bind ctrl-u:unix-word-rubout+top`
-        - `top` combined with `unix-word-rubout`
+    - `fzf --bind 'ctrl-w:unix-word-rubout+top,ctrl-u:unix-line-discard+top'`
+        - `top` combined with `unix-word-rubout` and `unix-line-discard`
 - Fixed inconsistent tiebreak scores when `--nth` is used
 - Proper display of tab characters in `--prompt`
 - Fixed not to `--cycle` on page-up/page-down to prevent overshoot
--- a/README-VIM.md
+++ b/README-VIM.md
@@ -55,6 +55,19 @@ let g:fzf_action = {
  \ 'ctrl-x': 'split',
  \ 'ctrl-v': 'vsplit' }

+" An action can be a reference to a function that processes selected lines
+function! s:build_quickfix_list(lines)
+  call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
+  copen
+  cc
+endfunction
+
+let g:fzf_action = {
+  \ 'ctrl-q': function('s:build_quickfix_list'),
+  \ 'ctrl-t': 'tab split',
+  \ 'ctrl-x': 'split',
+  \ 'ctrl-v': 'vsplit' }
+
 " Default fzf layout
 " - down / up / left / right
 let g:fzf_layout = { 'down': '~40%' }
--- a/README.md
+++ b/README.md
@@ -3,15 +3,19 @@

 fzf is a general-purpose command-line fuzzy finder.

-![](https://raw.github.com/junegunn/i/master/fzf.gif)
+<img src="https://raw.githubusercontent.com/junegunn/i/master/fzf-preview.png" width=640>
+
+It's an interactive Unix filter for command-line that can be used with any
+list; files, command history, processes, hostnames, bookmarks, git commits,
+etc.

 Pros
 ----

- No dependencies
+- Portable, no dependencies
 - Blazingly fast
 - The most comprehensive feature set
- Flexible layout using tmux panes
+- Flexible layout
 - Batteries included
    - Vim/Neovim plugin, key bindings and fuzzy auto-completion

@@ -20,7 +24,7 @@ Table of Contents

   * [Installation](#installation)
      * [Using git](#using-git)
-      * [Using Homebrew](#using-homebrew)
+      * [Using Homebrew or Linuxbrew](#using-homebrew-or-linuxbrew)
      * [As Vim plugin](#as-vim-plugin)
      * [Windows](#windows)
   * [Upgrading fzf](#upgrading-fzf)
@@ -42,6 +46,10 @@ Table of Contents
      * [Settings](#settings)
      * [Supported commands](#supported-commands)
   * [Vim plugin](#vim-plugin)
+   * [Advanced topics](#advanced-topics)
+      * [Performance](#performance)
+      * [Executing external programs](#executing-external-programs)
+      * [Preview window](#preview-window)
   * [Tips](#tips)
      * [Respecting .gitignore, <code>.hgignore</code>, and <code>svn:ignore</code>](#respecting-gitignore-hgignore-and-svnignore)
      * [git ls-tree for fast traversal](#git-ls-tree-for-fast-traversal)
@@ -75,9 +83,10 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```

-### Using Homebrew
+### Using Homebrew or Linuxbrew

-On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.
+Alternatively, you can use [Homebrew](http://brew.sh/) or
+[Linuxbrew](http://linuxbrew.sh/) to install fzf.

 ```sh
 brew install fzf
@@ -383,13 +392,94 @@ Vim plugin

 See [README-VIM.md](README-VIM.md).

+Advanced topics
+---------------
+
+### Performance
+
+fzf is fast, and is [getting even faster][perf]. Performance should not be
+a problem in most use cases. However, you might want to be aware of the
+options that affect the performance.
+
+- `--ansi` tells fzf to extract and parse ANSI color codes in the input and it
+  makes the initial scanning slower. So it's not recommended that you add it
+  to your `$FZF_DEFAULT_OPTS`.
+- `--nth` makes fzf slower as fzf has to tokenize each line.
+- `--with-nth` makes fzf slower as fzf has to tokenize and reassemble each
+  line.
+- If you absolutely need better performance, you can consider using
+  `--algo=v1` (the default being `v2`) to make fzf use faster greedy
+  algorithm. However, this algorithm is not guaranteed to find the optimal
+  ordering of the matches and is not recommended.
+
+[perf]: https://junegunn.kr/images/fzf-0.16.11.png
+
+### Executing external programs
+
+You can set up key bindings for starting external processes without leaving
+fzf (`execute`, `execute-silent`).
+
+```bash
+# Press F1 to open the file with less without leaving fzf
+# Press CTRL-Y to copy the line to clipboard and aborts fzf (requires pbcopy)
+fzf --bind 'f1:execute(less -f {}),ctrl-y:execute-silent(echo {} | pbcopy)+abort'
+```
+
+See *KEY BINDINGS* section of the man page for details.
+
+### Preview window
+
+When `--preview` option is set, fzf automatically starts external process with
+the current line as the argument and shows the result in the split window.
+
+```bash
+# {} is replaced to the single-quoted string of the focused line
+fzf --preview 'cat {}'
+```
+
+Since preview window is updated only after the process is complete, it's
+important that the command finishes quickly.
+
+```bash
+# Use head instead of cat so that the command doesn't take too long to finish
+fzf --preview 'head -100 {}'
+```
+
+Preview window supports ANSI colors, so you can use programs that
+syntax-highlights the content of a file.
+
+- Highlight: http://www.andre-simon.de/doku/highlight/en/highlight.php
+- CodeRay: http://coderay.rubychan.de/
+- Rouge: https://github.com/jneen/rouge
+
+```bash
+# Try highlight, coderay, rougify in turn, then fall back to cat
+fzf --preview '[[ $(file --mime {}) =~ binary ]] &&
+                 echo {} is a binary file ||
+                 (highlight -O ansi -l {} ||
+                  coderay {} ||
+                  rougify {} ||
+                  cat {}) 2> /dev/null | head -500'
+```
+
+You can customize the size and position of the preview window using
+`--preview-window` option. For example,
+
+```bash
+fzf --height 40% --reverse --preview 'file {}' --preview-window down:1
+```
+
+For more advanced examples, see [Key bindings for git with fzf][fzf-git].
+
+[fzf-git]: https://junegunn.kr/2016/07/fzf-git/
+
 Tips
 ----

 #### Respecting `.gitignore`, `.hgignore`, and `svn:ignore`

 [ag](https://github.com/ggreer/the_silver_searcher) or
-[pt](https://github.com/monochromegane/the_platinum_searcher) will do the
+[rg](https://github.com/BurntSushi/ripgrep) will do the
 filtering:

 ```sh
@@ -426,10 +516,10 @@ export FZF_DEFAULT_COMMAND='

 #### Fish shell

-It's [a known bug of fish](https://github.com/fish-shell/fish-shell/issues/1362)
-(will be fixed in 2.6.0) that it doesn't allow reading from STDIN in command
-substitution, which means simple `vim (fzf)` won't work as expected. The
-workaround is to use the `read` fish command:
+Fish shell before version 2.6.0 [doesn't allow](https://github.com/fish-shell/fish-shell/issues/1362)
+reading from STDIN in command substitution, which means simple `vim (fzf)`
+doesn't work as expected. The workaround for fish 2.5.0 and earlier is to use
+the `read` fish command:

 ```sh
 fzf | read -l result; and vim $result
@@ -457,7 +547,7 @@ make use of this feature. `$dir` defaults to `.` when the last token is not a
 valid directory. Example:

 ```sh
-set -l FZF_CTRL_T_COMMAND "command find -L \$dir -type f 2> /dev/null | sed '1d; s#^\./##'"
+set -g FZF_CTRL_T_COMMAND "command find -L \$dir -type f 2> /dev/null | sed '1d; s#^\./##'"
 ```

 [License](LICENSE)
--- a/bin/fzf-tmux
+++ b/bin/fzf-tmux
@@ -146,6 +146,7 @@ cleanup() {
  fi

  if [ $# -gt 0 ]; then
+    trap - EXIT
    exit 130
  fi
 }
@@ -170,21 +171,22 @@ for arg in "${args[@]}"; do
 done

 pppid=$$
-trap_set="trap 'kill -SIGUSR1 -$pppid' EXIT SIGINT SIGTERM"
-trap_unset="trap - EXIT SIGINT SIGTERM"
+echo -n "trap 'kill -SIGUSR1 -$pppid' EXIT SIGINT SIGTERM;" > $argsf
+close="; trap - EXIT SIGINT SIGTERM $close"

 if [[ -n "$term" ]] || [[ -t 0 ]]; then
-  cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" > $argsf
+  cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" >> $argsf
+  cat $argsf
  TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
    set-window-option remain-on-exit off \;\
-    split-window $opt "$trap_set;cd $(printf %q "$PWD");$envs bash $argsf;$trap_unset" $swap \
+    split-window $opt "cd $(printf %q "$PWD");$envs bash $argsf" $swap \
    > /dev/null 2>&1
 else
  mkfifo $fifo1
-  cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" > $argsf
+  cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" >> $argsf
  TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
    set-window-option remain-on-exit off \;\
-    split-window $opt "$trap_set;$envs bash $argsf;$trap_unset" $swap \
+    split-window $opt "$envs bash $argsf" $swap \
    > /dev/null 2>&1
  cat <&0 > $fifo1 &
 fi
--- a/doc/fzf.txt
+++ b/doc/fzf.txt
@@ -1,4 +1,4 @@
-fzf.txt	fzf	Last change: April 28 2017
+fzf.txt	fzf	Last change: August 14 2017
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================

@@ -80,6 +80,19 @@ Examples~
      \ 'ctrl-x': 'split',
      \ 'ctrl-v': 'vsplit' }

+    " An action can be a reference to a function that processes selected lines
+    function! s:build_quickfix_list(lines)
+      call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
+      copen
+      cc
+    endfunction
+
+    let g:fzf_action = {
+      \ 'ctrl-q': function('s:build_quickfix_list'),
+      \ 'ctrl-t': 'tab split',
+      \ 'ctrl-x': 'split',
+      \ 'ctrl-v': 'vsplit' }
+
    " Default fzf layout
    " - down / up / left / right
    let g:fzf_layout = { 'down': '~40%' }
--- a/4
+++ b/4
@@ -2,7 +2,7 @@

 set -u

-version=0.16.8
+version=0.17.0
 auto_completion=
 key_bindings=
 update_config=2
@@ -171,6 +171,8 @@ case "$archi" in
  OpenBSD\ *64)  download fzf-$version-openbsd_${binary_arch:-amd64}.tgz ;;
  OpenBSD\ *86)  download fzf-$version-openbsd_${binary_arch:-386}.tgz   ;;
  CYGWIN*\ *64)  download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
+  MINGW*\ *86)   download fzf-$version-windows_${binary_arch:-386}.zip   ;;
+  MINGW*\ *64)   download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
  *)             binary_available=0 binary_error=1 ;;
 esac

--- a/man/man1/fzf-tmux.1
+++ b/man/man1/fzf-tmux.1
@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf-tmux 1 "Jun 2017" "fzf 0.16.8" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Aug 2017" "fzf 0.17.0" "fzf-tmux - open fzf in tmux split pane"

 .SH NAME
 fzf-tmux - open fzf in tmux split pane
--- a/man/man1/fzf.1
+++ b/man/man1/fzf.1
@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf 1 "Jun 2017" "fzf 0.16.8" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Aug 2017" "fzf 0.17.0" "fzf - a command-line fuzzy finder"

 .SH NAME
 fzf - a command-line fuzzy finder
@@ -111,6 +111,9 @@ Comma-separated list of sort criteria to apply when the scores are tied.
 .B "-m, --multi"
 Enable multi-select with tab/shift-tab
 .TP
+.B "+m, --no-multi"
+Disable multi-select
+.TP
 .B "--no-mouse"
 Disable mouse
 .TP
@@ -236,6 +239,7 @@ e.g. \fBfzf --color=bg+:24\fR
    \fBbg+     \fRBackground (current line)
    \fBhl+     \fRHighlighted substrings (current line)
    \fBinfo    \fRInfo
+    \fBborder  \fRBorder of the preview window and horizontal separators (\fB--border\fR)
    \fBprompt  \fRPrompt
    \fBpointer \fRPointer to the current line
    \fBmarker  \fRMulti-select marker
@@ -327,10 +331,12 @@ Comma-separated list of keys that can be used to complete fzf in addition to
 the default enter key. When this option is set, fzf will print the name of the
 key pressed as the first line of its output (or as the second line if
 \fB--print-query\fR is also used). The line will be empty if fzf is completed
-with the default enter key.
+with the default enter key. If \fB--expect\fR option is specified multiple
+times, fzf will expect the union of the keys. \fB--no-expect\fR will clear the
+list.

 .RS
-e.g. \fBfzf --expect=ctrl-v,ctrl-t,alt-s,f1,f2,~,@\fR
+e.g. \fBfzf --expect=ctrl-v,ctrl-t,alt-s --expect=f1,f2,~,@\fR
 .RE
 .TP
 .B "--read0"
@@ -356,6 +362,9 @@ e.g. \fBfzf --multi | fzf --sync\fR
 .B "--version"
 Display version information and exit

+.TP
+Note that most options have the opposite versions with \fB--no-\fR prefix.
+
 .SH ENVIRONMENT VARIABLES
 .TP
 .B FZF_DEFAULT_COMMAND
@@ -403,6 +412,9 @@ Unless specified otherwise, fzf will start in "extended-search mode". In this
 mode, you can specify multiple patterns delimited by spaces, such as: \fB'wild
 ^music .mp3$ sbtrkt !rmx\fR

+You can prepend a backslash to a space (\fB\\ \fR) to match a literal space
+character.
+
 .SS Exact-match (quoted)
 A term that is prefixed by a single-quote character (\fB'\fR) is interpreted as
 an "exact-match" (or "non-fuzzy") term. fzf will search for the exact
--- a/plugin/fzf.vim
+++ b/plugin/fzf.vim
@@ -66,8 +66,8 @@ function! s:shellesc_cmd(arg)
  let escaped = substitute(a:arg, '[&|<>()@^]', '^&', 'g')
  let escaped = substitute(escaped, '%', '%%', 'g')
  let escaped = substitute(escaped, '"', '\\^&', 'g')
-  let escaped = substitute(escaped, '\\\+\(\\^\)', '\\\\\1', 'g')
-  return '^"'.substitute(escaped, '[^\\]\zs\\$', '\\\\', '').'^"'
+  let escaped = substitute(escaped, '\(\\\+\)\(\\^\)', '\1\1\2', 'g')
+  return '^"'.substitute(escaped, '\(\\\+\)$', '\1\1', '').'^"'
 endfunction

 function! fzf#shellescape(arg, ...)
@@ -149,13 +149,8 @@ function! s:tmux_enabled()
 endfunction

 function! s:escape(path)
-  let escaped_chars = '$%#''"'
-
-  if has('unix')
-    let escaped_chars .= ' \'
-  endif
-
-  return escape(a:path, escaped_chars)
+  let path = fnameescape(a:path)
+  return s:is_win ? escape(path, '$') : path
 endfunction

 " Upgrade legacy options
@@ -206,7 +201,10 @@ function! s:common_sink(action, lines) abort
    return
  endif
  let key = remove(a:lines, 0)
-  let cmd = get(a:action, key, 'e')
+  let Cmd = get(a:action, key, 'e')
+  if type(Cmd) == type(function('call'))
+    return Cmd(a:lines)
+  endif
  if len(a:lines) > 1
    augroup fzf_swap
      autocmd SwapExists * let v:swapchoice='o'
@@ -222,7 +220,7 @@ function! s:common_sink(action, lines) abort
        execute 'e' s:escape(item)
        let empty = 0
      else
-        call s:open(cmd, item)
+        call s:open(Cmd, item)
      endif
      if !has('patch-8.0.0177') && !has('nvim-0.2') && exists('#BufEnter')
            \ && isdirectory(item)
@@ -342,13 +340,6 @@ try
    set shell=sh
  endif

-  if has('nvim')
-    let running = filter(range(1, bufnr('$')), "bufname(v:val) =~# ';#FZF'")
-    if len(running)
-      call s:warn('FZF is already running (in buffer '.join(running, ', ').')!')
-      return []
-    endif
-  endif
  let dict   = exists('a:1') ? s:upgrade(a:1) : {}
  let temps  = { 'result': s:fzf_tempname() }
  let optstr = s:evaluate_opts(get(dict, 'options', ''))
@@ -361,11 +352,14 @@ try
  if has('nvim') && !has_key(dict, 'dir')
    let dict.dir = s:fzf_getcwd()
  endif
+  if has('win32unix') && has_key(dict, 'dir')
+    let dict.dir = fnamemodify(dict.dir, ':p')
+  endif

-  if !has_key(dict, 'source') && !empty($FZF_DEFAULT_COMMAND)
-    let temps.source = s:fzf_tempname().(s:is_win ? '.bat' : '')
+  if !has_key(dict, 'source') && !empty($FZF_DEFAULT_COMMAND) && !s:is_win
+    let temps.source = s:fzf_tempname()
    call writefile(s:wrap_cmds(split($FZF_DEFAULT_COMMAND, "\n")), temps.source)
-    let dict.source = (empty($SHELL) ? &shell : $SHELL) . (s:is_win ? ' /c ' : ' ') . fzf#shellescape(temps.source)
+    let dict.source = (empty($SHELL) ? &shell : $SHELL).' '.fzf#shellescape(temps.source)
  endif

  if has_key(dict, 'source')
@@ -468,11 +462,11 @@ augroup fzf_popd
 augroup END

 function! s:dopopd()
-  if !exists('w:fzf_prev_dir') || exists('*haslocaldir') && !haslocaldir()
+  if !exists('w:fzf_dir') || s:fzf_getcwd() != w:fzf_dir[1]
    return
  endif
-  execute 'lcd' s:escape(w:fzf_prev_dir)
-  unlet w:fzf_prev_dir
+  execute 'lcd' s:escape(w:fzf_dir[0])
+  unlet w:fzf_dir
 endfunction

 function! s:xterm_launcher()
@@ -526,12 +520,15 @@ function! s:execute(dict, command, use_height, temps) abort
    let command = batchfile
    let a:temps.batchfile = batchfile
    if has('nvim')
-      let s:dict = a:dict
-      let s:temps = a:temps
      let fzf = {}
+      let fzf.dict = a:dict
+      let fzf.temps = a:temps
      function! fzf.on_exit(job_id, exit_status, event) dict
-        let lines = s:collect(s:temps)
-        call s:callback(s:dict, lines)
+        if s:present(self.dict, 'dir')
+          execute 'lcd' s:escape(self.dict.dir)
+        endif
+        let lines = s:collect(self.temps)
+        call s:callback(self.dict, lines)
      endfunction
      let cmd = 'start /wait cmd /c '.command
      call jobstart(cmd, fzf)
@@ -687,7 +684,7 @@ function! s:execute_term(dict, command, temps) abort
      lcd -
    endif
  endtry
-  setlocal nospell bufhidden=wipe nobuflisted
+  setlocal nospell bufhidden=wipe nobuflisted nonumber
  setf fzf
  startinsert
  return []
@@ -718,7 +715,7 @@ function! s:callback(dict, lines) abort
  let popd = has_key(a:dict, 'prev_dir') &&
        \ (!&autochdir || (empty(a:lines) || len(a:lines) == 1 && empty(a:lines[0])))
  if popd
-    let w:fzf_prev_dir = a:dict.prev_dir
+    let w:fzf_dir = [a:dict.prev_dir, a:dict.dir]
  endif

  try
@@ -742,7 +739,7 @@ function! s:callback(dict, lines) abort

  " We may have opened a new window or tab
  if popd
-    let w:fzf_prev_dir = a:dict.prev_dir
+    let w:fzf_dir = [a:dict.prev_dir, a:dict.dir]
    call s:dopopd()
  endif
 endfunction
@@ -755,7 +752,7 @@ let s:default_action = {
 function! s:shortpath()
  let short = pathshorten(fnamemodify(getcwd(), ':~:.'))
  let slash = (s:is_win && !&shellslash) ? '\' : '/'
-  return empty(short) ? '~'.slash : short . (short =~ slash.'$' ? '' : slash)
+  return empty(short) ? '~'.slash : short . (short =~ escape(slash, '\').'$' ? '' : slash)
 endfunction

 function! s:cmd(bang, ...) abort
@@ -765,8 +762,6 @@ function! s:cmd(bang, ...) abort
    let opts.dir = substitute(substitute(remove(args, -1), '\\\(["'']\)', '\1', 'g'), '[/\\]*$', '/', '')
    if s:is_win && !&shellslash
      let opts.dir = substitute(opts.dir, '/', '\\', 'g')
-    elseif has('win32unix')
-      let opts.dir = fnamemodify(opts.dir, ':p')
    endif
    let prompt = opts.dir
  else
--- a/shell/key-bindings.fish
+++ b/shell/key-bindings.fish
@@ -4,14 +4,9 @@ function fzf_key_bindings

  # Store current token in $dir as root for the 'find' command
  function fzf-file-widget -d "List files and folders"
-    set -l dir (commandline -t)
-    # The commandline token might be escaped, we need to unescape it.
-    set dir (eval "printf '%s' $dir")
-    if [ ! -d "$dir" ]
-      set dir .
-    end
-    # Some 'find' versions print undesired duplicated slashes if the path ends with slashes.
-    set dir (string replace --regex '(.)/+$' '$1' "$dir")
+    set -l commandline (__fzf_parse_commandline)
+    set -l dir $commandline[1]
+    set -l fzf_query $commandline[2]

    # "-path \$dir'*/\\.*'" matches hidden files/folders inside $dir but not
    # $dir itself, even if hidden.
@@ -19,19 +14,17 @@ function fzf_key_bindings
    command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
    -o -type f -print \
    -o -type d -print \
-    -o -type l -print 2> /dev/null | cut -b3-"
+    -o -type l -print 2> /dev/null | sed 's@^\./@@'"

    set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
    begin
      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS"
-      eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)" -m" | while read -l r; set result $result $r; end
+      eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)' -m --query "'$fzf_query'"' | while read -l r; set result $result $r; end
    end
    if [ -z "$result" ]
      commandline -f repaint
      return
-    end
-
-    if [ "$dir" != . ]
+    else
      # Remove last token from commandline.
      commandline -t ""
    end
@@ -46,22 +39,45 @@ function fzf_key_bindings
    set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
    begin
      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT $FZF_DEFAULT_OPTS --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m"
-      history | eval (__fzfcmd) -q '(commandline)' | read -l result
-      and commandline -- $result
+
+      set -l FISH_MAJOR (echo $FISH_VERSION | cut -f1 -d.)
+      set -l FISH_MINOR (echo $FISH_VERSION | cut -f2 -d.)
+
+      # history's -z flag is needed for multi-line support.
+      # history's -z flag was added in fish 2.4.0, so don't use it for versions
+      # before 2.4.0.
+      if [ "$FISH_MAJOR" -gt 2 -o \( "$FISH_MAJOR" -eq 2 -a "$FISH_MINOR" -ge 4 \) ];
+        history -z | eval (__fzfcmd) --read0 -q '(commandline)' | perl -pe 'chomp if eof' | read -lz result
+        and commandline -- $result
+      else
+        history | eval (__fzfcmd) -q '(commandline)' | read -l result
+        and commandline -- $result
+      end
    end
    commandline -f repaint
  end

  function fzf-cd-widget -d "Change directory"
+    set -l commandline (__fzf_parse_commandline)
+    set -l dir $commandline[1]
+    set -l fzf_query $commandline[2]
+
    set -q FZF_ALT_C_COMMAND; or set -l FZF_ALT_C_COMMAND "
-    command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
-    -o -type d -print 2> /dev/null | cut -b3-"
+    command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
+    -o -type d -print 2> /dev/null | sed 's@^\./@@'"
    set -q FZF_TMUX_HEIGHT; or set FZF_TMUX_HEIGHT 40%
    begin
      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS"
-      eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)" +m" | read -l result
-      [ "$result" ]; and cd $result
+      eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)' +m --query "'$fzf_query'"' | read -l result
+
+      if [ -n "$result" ]
+        cd $result
+
+        # Remove last token from commandline.
+        commandline -t ""
+      end
    end
+
    commandline -f repaint
  end

@@ -84,4 +100,47 @@ function fzf_key_bindings
    bind -M insert \cr fzf-history-widget
    bind -M insert \ec fzf-cd-widget
  end
+
+  function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath and rest of token'
+    # eval is used to do shell expansion on paths
+    set -l commandline (eval "printf '%s' "(commandline -t))
+
+    if [ -z $commandline ]
+      # Default to current directory with no --query
+      set dir '.'
+      set fzf_query ''
+    else
+      set dir (__fzf_get_dir $commandline)
+
+      if [ "$dir" = "." -a (string sub -l 1 $commandline) != '.' ]
+        # if $dir is "." but commandline is not a relative path, this means no file path found
+        set fzf_query $commandline
+      else
+        # Also remove trailing slash after dir, to "split" input properly
+        set fzf_query (string replace -r "^$dir/?" '' "$commandline")
+      end
+    end
+
+    echo $dir
+    echo $fzf_query
+  end
+
+  function __fzf_get_dir -d 'Find the longest existing filepath from input string'
+    set dir $argv
+
+    # Strip all trailing slashes. Ignore if $dir is root dir (/)
+    if [ (string length $dir) -gt 1 ]
+      set dir (string replace -r '/*$' '' $dir)
+    end
+
+    # Iteratively check if dir exists and strip tail end of path
+    while [ ! -d "$dir" ]
+      # If path is absolute, this can keep going until ends up at /
+      # If path is relative, this can keep going until entire input is consumed, dirname returns "."
+      set dir (dirname "$dir")
+    end
+
+    echo $dir
+  end
+
 end
--- a/src/algo/algo.go
+++ b/src/algo/algo.go
@@ -78,9 +78,11 @@ Scoring criteria
 */

 import (
+	"bytes"
 	"fmt"
 	"strings"
 	"unicode"
+	"unicode/utf8"

 	"github.com/junegunn/fzf/src/util"
 )
@@ -156,27 +158,17 @@ func posArray(withPos bool, len int) *[]int {
 	return nil
 }

-func alloc16(offset int, slab *util.Slab, size int, clear bool) (int, []int16) {
+func alloc16(offset int, slab *util.Slab, size int) (int, []int16) {
 	if slab != nil && cap(slab.I16) > offset+size {
 		slice := slab.I16[offset : offset+size]
-		if clear {
-			for idx := range slice {
-				slice[idx] = 0
-			}
-		}
 		return offset + size, slice
 	}
 	return offset, make([]int16, size)
 }

-func alloc32(offset int, slab *util.Slab, size int, clear bool) (int, []int32) {
+func alloc32(offset int, slab *util.Slab, size int) (int, []int32) {
 	if slab != nil && cap(slab.I32) > offset+size {
 		slice := slab.I32[offset : offset+size]
-		if clear {
-			for idx := range slice {
-				slice[idx] = 0
-			}
-		}
 		return offset + size, slice
 	}
 	return offset, make([]int32, size)
@@ -227,7 +219,7 @@ func bonusFor(prevClass charClass, class charClass) int16 {
 	return 0
 }

-func bonusAt(input util.Chars, idx int) int16 {
+func bonusAt(input *util.Chars, idx int) int16 {
 	if idx == 0 {
 		return bonusBoundary
 	}
@@ -249,21 +241,113 @@ func normalizeRune(r rune) rune {
 // Algo functions make two assumptions
 // 1. "pattern" is given in lowercase if "caseSensitive" is false
 // 2. "pattern" is already normalized if "normalize" is true
-type Algo func(caseSensitive bool, normalize bool, forward bool, input util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int)
+type Algo func(caseSensitive bool, normalize bool, forward bool, input *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int)

-func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func trySkip(input *util.Chars, caseSensitive bool, b byte, from int) int {
+	byteArray := input.Bytes()[from:]
+	idx := bytes.IndexByte(byteArray, b)
+	if idx == 0 {
+		// Can't skip any further
+		return from
+	}
+	// We may need to search for the uppercase letter again. We don't have to
+	// consider normalization as we can be sure that this is an ASCII string.
+	if !caseSensitive && b >= 'a' && b <= 'z' {
+		if idx > 0 {
+			byteArray = byteArray[:idx]
+		}
+		uidx := bytes.IndexByte(byteArray, b-32)
+		if uidx >= 0 {
+			idx = uidx
+		}
+	}
+	if idx < 0 {
+		return -1
+	}
+	return from + idx
+}
+
+func isAscii(runes []rune) bool {
+	for _, r := range runes {
+		if r >= utf8.RuneSelf {
+			return false
+		}
+	}
+	return true
+}
+
+func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) int {
+	// Can't determine
+	if !input.IsBytes() {
+		return 0
+	}
+
+	// Not possible
+	if !isAscii(pattern) {
+		return -1
+	}
+
+	firstIdx, idx := 0, 0
+	for pidx := 0; pidx < len(pattern); pidx++ {
+		idx = trySkip(input, caseSensitive, byte(pattern[pidx]), idx)
+		if idx < 0 {
+			return -1
+		}
+		if pidx == 0 && idx > 0 {
+			// Step back to find the right bonus point
+			firstIdx = idx - 1
+		}
+		idx++
+	}
+	return firstIdx
+}
+
+func debugV2(T []rune, pattern []rune, F []int32, lastIdx int, H []int16, C []int16) {
+	width := lastIdx - int(F[0]) + 1
+
+	for i, f := range F {
+		I := i * width
+		if i == 0 {
+			fmt.Print("  ")
+			for j := int(f); j <= lastIdx; j++ {
+				fmt.Printf(" " + string(T[j]) + " ")
+			}
+			fmt.Println()
+		}
+		fmt.Print(string(pattern[i]) + " ")
+		for idx := int(F[0]); idx < int(f); idx++ {
+			fmt.Print(" 0 ")
+		}
+		for idx := int(f); idx <= lastIdx; idx++ {
+			fmt.Printf("%2d ", H[i*width+idx-int(F[0])])
+		}
+		fmt.Println()
+
+		fmt.Print("  ")
+		for idx, p := range C[I : I+width] {
+			if idx+int(F[0]) < int(F[i]) {
+				p = 0
+			}
+			if p > 0 {
+				fmt.Printf("%2d ", p)
+			} else {
+				fmt.Print("   ")
+			}
+		}
+		fmt.Println()
+	}
+}
+
+func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	// Assume that pattern is given in lowercase if case-insensitive.
 	// First check if there's a match and calculate bonus for each position.
 	// If the input string is too long, consider finding the matching chars in
 	// this phase as well (non-optimal alignment).
-	N := input.Length()
 	M := len(pattern)
-	switch M {
-	case 0:
+	if M == 0 {
 		return Result{0, 0, 0}, posArray(withPos, M)
-	case 1:
-		return ExactMatchNaive(caseSensitive, normalize, forward, input, pattern[0:1], withPos, slab)
 	}
+	N := input.Length()

 	// Since O(nm) algorithm can be prohibitively expensive for large input,
 	// we fall back to the greedy algorithm.
@@ -271,158 +355,175 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input util.C
 		return FuzzyMatchV1(caseSensitive, normalize, forward, input, pattern, withPos, slab)
 	}

+	// Phase 1. Optimized search for ASCII string
+	idx := asciiFuzzyIndex(input, pattern, caseSensitive)
+	if idx < 0 {
+		return Result{-1, -1, 0}, nil
+	}
+
 	// Reuse pre-allocated integer slice to avoid unnecessary sweeping of garbages
 	offset16 := 0
 	offset32 := 0
+	offset16, H0 := alloc16(offset16, slab, N)
+	offset16, C0 := alloc16(offset16, slab, N)
 	// Bonus point for each position
-	offset16, B := alloc16(offset16, slab, N, false)
+	offset16, B := alloc16(offset16, slab, N)
 	// The first occurrence of each character in the pattern
-	offset32, F := alloc32(offset32, slab, M, false)
+	offset32, F := alloc32(offset32, slab, M)
 	// Rune array
-	offset32, T := alloc32(offset32, slab, N, false)
+	offset32, T := alloc32(offset32, slab, N)
+	input.CopyRunes(T)

-	// Phase 1. Check if there's a match and calculate bonus for each point
-	pidx, lastIdx, prevClass := 0, 0, charNonWord
-	for idx := 0; idx < N; idx++ {
-		char := input.Get(idx)
+	// Phase 2. Calculate bonus for each point
+	maxScore, maxScorePos := int16(0), 0
+	pidx, lastIdx := 0, 0
+	pchar0, pchar, prevH0, prevClass, inGap := pattern[0], pattern[0], int16(0), charNonWord, false
+	Tsub := T[idx:]
+	H0sub, C0sub, Bsub := H0[idx:][:len(Tsub)], C0[idx:][:len(Tsub)], B[idx:][:len(Tsub)]
+	for off, char := range Tsub {
 		var class charClass
 		if char <= unicode.MaxASCII {
 			class = charClassOfAscii(char)
+			if !caseSensitive && class == charUpper {
+				char += 32
+			}
 		} else {
 			class = charClassOfNonAscii(char)
-		}
-
-		if !caseSensitive && class == charUpper {
-			if char <= unicode.MaxASCII {
-				char += 32
-			} else {
+			if !caseSensitive && class == charUpper {
 				char = unicode.To(unicode.LowerCase, char)
 			}
+			if normalize {
+				char = normalizeRune(char)
+			}
 		}

-		if normalize {
-			char = normalizeRune(char)
-		}
-
-		T[idx] = char
-		B[idx] = bonusFor(prevClass, class)
+		Tsub[off] = char
+		bonus := bonusFor(prevClass, class)
+		Bsub[off] = bonus
 		prevClass = class

-		if pidx < M {
-			if char == pattern[pidx] {
-				lastIdx = idx
-				F[pidx] = int32(idx)
+		if char == pchar {
+			if pidx < M {
+				F[pidx] = int32(idx + off)
 				pidx++
+				pchar = pattern[util.Min(pidx, M-1)]
 			}
-		} else {
-			if char == pattern[M-1] {
-				lastIdx = idx
-			}
+			lastIdx = idx + off
 		}
+
+		if char == pchar0 {
+			score := scoreMatch + bonus*bonusFirstCharMultiplier
+			H0sub[off] = score
+			C0sub[off] = 1
+			if M == 1 && (forward && score > maxScore || !forward && score >= maxScore) {
+				maxScore, maxScorePos = score, idx+off
+				if forward && bonus == bonusBoundary {
+					break
+				}
+			}
+			inGap = false
+		} else {
+			if inGap {
+				H0sub[off] = util.Max16(prevH0+scoreGapExtention, 0)
+			} else {
+				H0sub[off] = util.Max16(prevH0+scoreGapStart, 0)
+			}
+			C0sub[off] = 0
+			inGap = true
+		}
+		prevH0 = H0sub[off]
 	}
 	if pidx != M {
 		return Result{-1, -1, 0}, nil
 	}
+	if M == 1 {
+		result := Result{maxScorePos, maxScorePos + 1, int(maxScore)}
+		if !withPos {
+			return result, nil
+		}
+		pos := []int{maxScorePos}
+		return result, &pos
+	}

-	// Phase 2. Fill in score matrix (H)
+	// Phase 3. Fill in score matrix (H)
 	// Unlike the original algorithm, we do not allow omission.
-	width := lastIdx - int(F[0]) + 1
-	offset16, H := alloc16(offset16, slab, width*M, false)
+	f0 := int(F[0])
+	width := lastIdx - f0 + 1
+	offset16, H := alloc16(offset16, slab, width*M)
+	copy(H, H0[f0:lastIdx+1])

 	// Possible length of consecutive chunk at each position.
-	offset16, C := alloc16(offset16, slab, width*M, false)
+	offset16, C := alloc16(offset16, slab, width*M)
+	copy(C, C0[f0:lastIdx+1])

-	maxScore, maxScorePos := int16(0), 0
-	for i := 0; i < M; i++ {
-		I := i * width
+	Fsub := F[1:]
+	Psub := pattern[1:][:len(Fsub)]
+	for off, f := range Fsub {
+		f := int(f)
+		pchar := Psub[off]
+		pidx := off + 1
+		row := pidx * width
 		inGap := false
-		for j := int(F[i]); j <= lastIdx; j++ {
-			j0 := j - int(F[0])
+		Tsub := T[f : lastIdx+1]
+		Bsub := B[f:][:len(Tsub)]
+		Csub := C[row+f-f0:][:len(Tsub)]
+		Cdiag := C[row+f-f0-1-width:][:len(Tsub)]
+		Hsub := H[row+f-f0:][:len(Tsub)]
+		Hdiag := H[row+f-f0-1-width:][:len(Tsub)]
+		Hleft := H[row+f-f0-1:][:len(Tsub)]
+		Hleft[0] = 0
+		for off, char := range Tsub {
+			col := off + f
 			var s1, s2, consecutive int16

-			if j > int(F[i]) {
-				if inGap {
-					s2 = H[I+j0-1] + scoreGapExtention
-				} else {
-					s2 = H[I+j0-1] + scoreGapStart
-				}
+			if inGap {
+				s2 = Hleft[off] + scoreGapExtention
+			} else {
+				s2 = Hleft[off] + scoreGapStart
 			}

-			if pattern[i] == T[j] {
-				var diag int16
-				if i > 0 && j0 > 0 {
-					diag = H[I-width+j0-1]
-				}
-				s1 = diag + scoreMatch
-				b := B[j]
-				if i > 0 {
-					// j > 0 if i > 0
-					consecutive = C[I-width+j0-1] + 1
-					// Break consecutive chunk
-					if b == bonusBoundary {
-						consecutive = 1
-					} else if consecutive > 1 {
-						b = util.Max16(b, util.Max16(bonusConsecutive, B[j-int(consecutive)+1]))
-					}
-				} else {
+			if pchar == char {
+				s1 = Hdiag[off] + scoreMatch
+				b := Bsub[off]
+				consecutive = Cdiag[off] + 1
+				// Break consecutive chunk
+				if b == bonusBoundary {
 					consecutive = 1
-					b *= bonusFirstCharMultiplier
+				} else if consecutive > 1 {
+					b = util.Max16(b, util.Max16(bonusConsecutive, B[col-int(consecutive)+1]))
 				}
 				if s1+b < s2 {
-					s1 += B[j]
+					s1 += Bsub[off]
 					consecutive = 0
 				} else {
 					s1 += b
 				}
 			}
-			C[I+j0] = consecutive
+			Csub[off] = consecutive

 			inGap = s1 < s2
 			score := util.Max16(util.Max16(s1, s2), 0)
-			if i == M-1 && (forward && score > maxScore || !forward && score >= maxScore) {
-				maxScore, maxScorePos = score, j
+			if pidx == M-1 && (forward && score > maxScore || !forward && score >= maxScore) {
+				maxScore, maxScorePos = score, col
 			}
-			H[I+j0] = score
-		}
-
-		if DEBUG {
-			if i == 0 {
-				fmt.Print("  ")
-				for j := int(F[i]); j <= lastIdx; j++ {
-					fmt.Printf(" " + string(input.Get(j)) + " ")
-				}
-				fmt.Println()
-			}
-			fmt.Print(string(pattern[i]) + " ")
-			for idx := int(F[0]); idx < int(F[i]); idx++ {
-				fmt.Print(" 0 ")
-			}
-			for idx := int(F[i]); idx <= lastIdx; idx++ {
-				fmt.Printf("%2d ", H[i*width+idx-int(F[0])])
-			}
-			fmt.Println()
-
-			fmt.Print("  ")
-			for idx, p := range C[I : I+width] {
-				if idx+int(F[0]) < int(F[i]) {
-					p = 0
-				}
-				fmt.Printf("%2d ", p)
-			}
-			fmt.Println()
+			Hsub[off] = score
 		}
 	}

-	// Phase 3. (Optional) Backtrace to find character positions
+	if DEBUG {
+		debugV2(T, pattern, F, lastIdx, H, C)
+	}
+
+	// Phase 4. (Optional) Backtrace to find character positions
 	pos := posArray(withPos, M)
-	j := int(F[0])
+	j := f0
 	if withPos {
 		i := M - 1
 		j = maxScorePos
 		preferMatch := true
 		for {
 			I := i * width
-			j0 := j - int(F[0])
+			j0 := j - f0
 			s := H[I+j0]

 			var s1, s2 int16
@@ -451,7 +552,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input util.C
 }

 // Implement the same sorting criteria as V2
-func calculateScore(caseSensitive bool, normalize bool, text util.Chars, pattern []rune, sidx int, eidx int, withPos bool) (int, *[]int) {
+func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, pattern []rune, sidx int, eidx int, withPos bool) (int, *[]int) {
 	pidx, score, inGap, consecutive, firstBonus := 0, 0, false, 0, int16(0)
 	pos := posArray(withPos, len(pattern))
 	prevClass := charNonWord
@@ -511,10 +612,13 @@ func calculateScore(caseSensitive bool, normalize bool, text util.Chars, pattern
 }

 // FuzzyMatchV1 performs fuzzy-match
-func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
+	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
+		return Result{-1, -1, 0}, nil
+	}

 	pidx := 0
 	sidx := -1
@@ -594,7 +698,7 @@ func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text util.Ch
 // bonus point, instead of stopping immediately after finding the first match.
 // The solution is much cheaper since there is only one possible alignment of
 // the pattern.
-func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
@@ -606,6 +710,10 @@ func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text util
 		return Result{-1, -1, 0}, nil
 	}

+	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
+		return Result{-1, -1, 0}, nil
+	}
+
 	// For simplicity, only look at the bonus at the first character position
 	pidx := 0
 	bestPos, bonus, bestBonus := -1, int16(0), int16(-1)
@@ -660,7 +768,7 @@ func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text util
 }

 // PrefixMatch performs prefix-match
-func PrefixMatch(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func PrefixMatch(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
@@ -687,7 +795,7 @@ func PrefixMatch(caseSensitive bool, normalize bool, forward bool, text util.Cha
 }

 // SuffixMatch performs suffix-match
-func SuffixMatch(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func SuffixMatch(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	lenRunes := text.Length()
 	trimmedLen := lenRunes - text.TrailingWhitespaces()
 	if len(pattern) == 0 {
@@ -718,7 +826,7 @@ func SuffixMatch(caseSensitive bool, normalize bool, forward bool, text util.Cha
 }

 // EqualMatch performs equal-match
-func EqualMatch(caseSensitive bool, normalize bool, forward bool, text util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
+func EqualMatch(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	lenPattern := len(pattern)
 	if text.Length() != lenPattern {
 		return Result{-1, -1, 0}, nil
--- a/src/algo/algo_test.go
+++ b/src/algo/algo_test.go
@@ -17,7 +17,8 @@ func assertMatch2(t *testing.T, fun Algo, caseSensitive, normalize, forward bool
 	if !caseSensitive {
 		pattern = strings.ToLower(pattern)
 	}
-	res, pos := fun(caseSensitive, normalize, forward, util.RunesToChars([]rune(input)), []rune(pattern), true, nil)
+	chars := util.ToChars([]byte(input))
+	res, pos := fun(caseSensitive, normalize, forward, &chars, []rune(pattern), true, nil)
 	var start, end int
 	if pos == nil || len(*pos) == 0 {
 		start = res.Start
--- a/src/ansi.go
+++ b/src/ansi.go
@@ -44,7 +44,21 @@ func init() {
 	*/
 	// The following regular expression will include not all but most of the
 	// frequently used ANSI sequences
-	ansiRegex = regexp.MustCompile("\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b.|[\x0e\x0f]|.\x08")
+	ansiRegex = regexp.MustCompile("(?:\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b.|[\x0e\x0f]|.\x08)")
+}
+
+func findAnsiStart(str string) int {
+	idx := 0
+	for ; idx < len(str); idx++ {
+		b := str[idx]
+		if b == 0x1b || b == 0x0e || b == 0x0f {
+			return idx
+		}
+		if b == 0x08 && idx > 0 {
+			return idx - 1
+		}
+	}
+	return idx
 }

 func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, *[]ansiOffset, *ansiState) {
@@ -55,50 +69,76 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo
 		offsets = append(offsets, ansiOffset{[2]int32{0, 0}, *state})
 	}

-	idx := 0
-	for _, offset := range ansiRegex.FindAllStringIndex(str, -1) {
-		prev := str[idx:offset[0]]
-		output.WriteString(prev)
+	prevIdx := 0
+	runeCount := 0
+	for idx := 0; idx < len(str); {
+		idx += findAnsiStart(str[idx:])
+		if idx == len(str) {
+			break
+		}
+
+		// Make sure that we found an ANSI code
+		offset := ansiRegex.FindStringIndex(str[idx:])
+		if len(offset) < 2 {
+			idx++
+			continue
+		}
+		offset[0] += idx
+		offset[1] += idx
+		idx = offset[1]
+
+		// Check if we should continue
+		prev := str[prevIdx:offset[0]]
 		if proc != nil && !proc(prev, state) {
 			return "", nil, nil
 		}
-		newState := interpretCode(str[offset[0]:offset[1]], state)

+		prevIdx = offset[1]
+		runeCount += utf8.RuneCountInString(prev)
+		output.WriteString(prev)
+
+		newState := interpretCode(str[offset[0]:offset[1]], state)
 		if !newState.equals(state) {
 			if state != nil {
 				// Update last offset
-				(&offsets[len(offsets)-1]).offset[1] = int32(utf8.RuneCount(output.Bytes()))
+				(&offsets[len(offsets)-1]).offset[1] = int32(runeCount)
 			}

 			if newState.colored() {
 				// Append new offset
 				state = newState
-				newLen := int32(utf8.RuneCount(output.Bytes()))
-				offsets = append(offsets, ansiOffset{[2]int32{newLen, newLen}, *state})
+				offsets = append(offsets, ansiOffset{[2]int32{int32(runeCount), int32(runeCount)}, *state})
 			} else {
 				// Discard state
 				state = nil
 			}
 		}
-
-		idx = offset[1]
 	}

-	rest := str[idx:]
-	if len(rest) > 0 {
+	var rest string
+	var trimmed string
+
+	if prevIdx == 0 {
+		// No ANSI code found
+		rest = str
+		trimmed = str
+	} else {
+		rest = str[prevIdx:]
 		output.WriteString(rest)
-		if state != nil {
-			// Update last offset
-			(&offsets[len(offsets)-1]).offset[1] = int32(utf8.RuneCount(output.Bytes()))
-		}
+		trimmed = output.String()
+	}
+	if len(rest) > 0 && state != nil {
+		// Update last offset
+		runeCount += utf8.RuneCountInString(rest)
+		(&offsets[len(offsets)-1]).offset[1] = int32(runeCount)
 	}
 	if proc != nil {
 		proc(rest, state)
 	}
 	if len(offsets) == 0 {
-		return output.String(), nil, state
+		return trimmed, nil, state
 	}
-	return output.String(), &offsets, state
+	return trimmed, &offsets, state
 }

 func interpretCode(ansiCode string, prevState *ansiState) *ansiState {
--- a/src/cache.go
+++ b/src/cache.go
@@ -3,7 +3,7 @@ package fzf
 import "sync"

 // queryCache associates strings to lists of items
-type queryCache map[string][]*Result
+type queryCache map[string][]Result

 // ChunkCache associates Chunk and query string to lists of items
 type ChunkCache struct {
@@ -17,7 +17,7 @@ func NewChunkCache() ChunkCache {
 }

 // Add adds the list to the cache
-func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Result) {
+func (cc *ChunkCache) Add(chunk *Chunk, key string, list []Result) {
 	if len(key) == 0 || !chunk.IsFull() || len(list) > queryCacheMax {
 		return
 	}
@@ -33,10 +33,10 @@ func (cc *ChunkCache) Add(chunk *Chunk, key string, list []*Result) {
 	(*qc)[key] = list
 }

-// Find is called to lookup ChunkCache
-func (cc *ChunkCache) Find(chunk *Chunk, key string) ([]*Result, bool) {
+// Lookup is called to lookup ChunkCache
+func (cc *ChunkCache) Lookup(chunk *Chunk, key string) []Result {
 	if len(key) == 0 || !chunk.IsFull() {
-		return nil, false
+		return nil
 	}

 	cc.mutex.Lock()
@@ -46,8 +46,36 @@ func (cc *ChunkCache) Find(chunk *Chunk, key string) ([]*Result, bool) {
 	if ok {
 		list, ok := (*qc)[key]
 		if ok {
-			return list, true
+			return list
 		}
 	}
-	return nil, false
+	return nil
+}
+
+func (cc *ChunkCache) Search(chunk *Chunk, key string) []Result {
+	if len(key) == 0 || !chunk.IsFull() {
+		return nil
+	}
+
+	cc.mutex.Lock()
+	defer cc.mutex.Unlock()
+
+	qc, ok := cc.cache[chunk]
+	if !ok {
+		return nil
+	}
+
+	for idx := 1; idx < len(key); idx++ {
+		// [---------| ] | [ |---------]
+		// [--------|  ] | [  |--------]
+		// [-------|   ] | [   |-------]
+		prefix := key[:len(key)-idx]
+		suffix := key[idx:]
+		for _, substr := range [2]string{prefix, suffix} {
+			if cached, found := (*qc)[substr]; found {
+				return cached
+			}
+		}
+	}
+	return nil
 }
--- a/src/cache_test.go
+++ b/src/cache_test.go
@@ -4,37 +4,36 @@ import "testing"

 func TestChunkCache(t *testing.T) {
 	cache := NewChunkCache()
-	chunk2 := make(Chunk, chunkSize)
 	chunk1p := &Chunk{}
-	chunk2p := &chunk2
-	items1 := []*Result{&Result{}}
-	items2 := []*Result{&Result{}, &Result{}}
+	chunk2p := &Chunk{count: chunkSize}
+	items1 := []Result{Result{}}
+	items2 := []Result{Result{}, Result{}}
 	cache.Add(chunk1p, "foo", items1)
 	cache.Add(chunk2p, "foo", items1)
 	cache.Add(chunk2p, "bar", items2)

 	{ // chunk1 is not full
-		cached, found := cache.Find(chunk1p, "foo")
-		if found {
-			t.Error("Cached disabled for non-empty chunks", found, cached)
+		cached := cache.Lookup(chunk1p, "foo")
+		if cached != nil {
+			t.Error("Cached disabled for non-empty chunks", cached)
 		}
 	}
 	{
-		cached, found := cache.Find(chunk2p, "foo")
-		if !found || len(cached) != 1 {
-			t.Error("Expected 1 item cached", found, cached)
+		cached := cache.Lookup(chunk2p, "foo")
+		if cached == nil || len(cached) != 1 {
+			t.Error("Expected 1 item cached", cached)
 		}
 	}
 	{
-		cached, found := cache.Find(chunk2p, "bar")
-		if !found || len(cached) != 2 {
-			t.Error("Expected 2 items cached", found, cached)
+		cached := cache.Lookup(chunk2p, "bar")
+		if cached == nil || len(cached) != 2 {
+			t.Error("Expected 2 items cached", cached)
 		}
 	}
 	{
-		cached, found := cache.Find(chunk1p, "foobar")
-		if found {
-			t.Error("Expected 0 item cached", found, cached)
+		cached := cache.Lookup(chunk1p, "foobar")
+		if cached != nil {
+			t.Error("Expected 0 item cached", cached)
 		}
 	}
 }
--- a/src/chunklist.go
+++ b/src/chunklist.go
@@ -2,17 +2,18 @@ package fzf

 import "sync"

-// Chunk is a list of Item pointers whose size has the upper limit of chunkSize
-type Chunk []*Item // >>> []Item
+// Chunk is a list of Items whose size has the upper limit of chunkSize
+type Chunk struct {
+	items [chunkSize]Item
+	count int
+}

-// ItemBuilder is a closure type that builds Item object from a pointer to a
-// string and an integer
-type ItemBuilder func([]byte, int) *Item
+// ItemBuilder is a closure type that builds Item object from byte array
+type ItemBuilder func(*Item, []byte) bool

 // ChunkList is a list of Chunks
 type ChunkList struct {
 	chunks []*Chunk
-	count  int
 	mutex  sync.Mutex
 	trans  ItemBuilder
 }
@@ -21,15 +22,13 @@ type ChunkList struct {
 func NewChunkList(trans ItemBuilder) *ChunkList {
 	return &ChunkList{
 		chunks: []*Chunk{},
-		count:  0,
 		mutex:  sync.Mutex{},
 		trans:  trans}
 }

-func (c *Chunk) push(trans ItemBuilder, data []byte, index int) bool {
-	item := trans(data, index)
-	if item != nil {
-		*c = append(*c, item)
+func (c *Chunk) push(trans ItemBuilder, data []byte) bool {
+	if trans(&c.items[c.count], data) {
+		c.count++
 		return true
 	}
 	return false
@@ -37,7 +36,7 @@ func (c *Chunk) push(trans ItemBuilder, data []byte, index int) bool {

 // IsFull returns true if the Chunk is full
 func (c *Chunk) IsFull() bool {
-	return len(*c) == chunkSize
+	return c.count == chunkSize
 }

 func (cl *ChunkList) lastChunk() *Chunk {
@@ -49,45 +48,35 @@ func CountItems(cs []*Chunk) int {
 	if len(cs) == 0 {
 		return 0
 	}
-	return chunkSize*(len(cs)-1) + len(*(cs[len(cs)-1]))
+	return chunkSize*(len(cs)-1) + cs[len(cs)-1].count
 }

 // Push adds the item to the list
 func (cl *ChunkList) Push(data []byte) bool {
 	cl.mutex.Lock()
-	defer cl.mutex.Unlock()

 	if len(cl.chunks) == 0 || cl.lastChunk().IsFull() {
-		newChunk := Chunk(make([]*Item, 0, chunkSize))
-		cl.chunks = append(cl.chunks, &newChunk)
+		cl.chunks = append(cl.chunks, &Chunk{})
 	}

-	if cl.lastChunk().push(cl.trans, data, cl.count) {
-		cl.count++
-		return true
-	}
-	return false
+	ret := cl.lastChunk().push(cl.trans, data)
+	cl.mutex.Unlock()
+	return ret
 }

 // Snapshot returns immutable snapshot of the ChunkList
 func (cl *ChunkList) Snapshot() ([]*Chunk, int) {
 	cl.mutex.Lock()
-	defer cl.mutex.Unlock()

 	ret := make([]*Chunk, len(cl.chunks))
 	copy(ret, cl.chunks)

 	// Duplicate the last chunk
 	if cnt := len(ret); cnt > 0 {
-		ret[cnt-1] = ret[cnt-1].dupe()
+		newChunk := *ret[cnt-1]
+		ret[cnt-1] = &newChunk
 	}
-	return ret, cl.count
-}

-func (c *Chunk) dupe() *Chunk {
-	newChunk := make(Chunk, len(*c))
-	for idx, ptr := range *c {
-		newChunk[idx] = ptr
-	}
-	return &newChunk
+	cl.mutex.Unlock()
+	return ret, CountItems(ret)
 }
--- a/src/chunklist_test.go
+++ b/src/chunklist_test.go
@@ -11,8 +11,9 @@ func TestChunkList(t *testing.T) {
 	// FIXME global
 	sortCriteria = []criterion{byScore, byLength}

-	cl := NewChunkList(func(s []byte, i int) *Item {
-		return &Item{text: util.ToChars(s), index: int32(i * 2)}
+	cl := NewChunkList(func(item *Item, s []byte) bool {
+		item.text = util.ToChars(s)
+		return true
 	})

 	// Snapshot
@@ -38,11 +39,11 @@ func TestChunkList(t *testing.T) {

 	// Check the content of the ChunkList
 	chunk1 := snapshot[0]
-	if len(*chunk1) != 2 {
+	if chunk1.count != 2 {
 		t.Error("Snapshot should contain only two items")
 	}
-	if (*chunk1)[0].text.ToString() != "hello" || (*chunk1)[0].index != 0 ||
-		(*chunk1)[1].text.ToString() != "world" || (*chunk1)[1].index != 2 {
+	if chunk1.items[0].text.ToString() != "hello" ||
+		chunk1.items[1].text.ToString() != "world" {
 		t.Error("Invalid data")
 	}
 	if chunk1.IsFull() {
@@ -65,14 +66,14 @@ func TestChunkList(t *testing.T) {
 		!snapshot[1].IsFull() || snapshot[2].IsFull() || count != chunkSize*2+2 {
 		t.Error("Expected two full chunks and one more chunk")
 	}
-	if len(*snapshot[2]) != 2 {
+	if snapshot[2].count != 2 {
 		t.Error("Unexpected number of items")
 	}

 	cl.Push([]byte("hello"))
 	cl.Push([]byte("world"))

-	lastChunkCount := len(*snapshot[len(snapshot)-1])
+	lastChunkCount := snapshot[len(snapshot)-1].count
 	if lastChunkCount != 2 {
 		t.Error("Unexpected number of items:", lastChunkCount)
 	}
--- a/src/constants.go
+++ b/src/constants.go
@@ -9,14 +9,17 @@ import (

 const (
 	// Current version
-	version = "0.16.8"
+	version = "0.17.0"

 	// Core
 	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
 	coordinatorDelayStep time.Duration = 10 * time.Millisecond

 	// Reader
-	readerBufferSize = 64 * 1024
+	readerBufferSize       = 64 * 1024
+	readerPollIntervalMin  = 10 * time.Millisecond
+	readerPollIntervalStep = 5 * time.Millisecond
+	readerPollIntervalMax  = 50 * time.Millisecond

 	// Terminal
 	initialDelay    = 20 * time.Millisecond
@@ -68,7 +71,7 @@ const (
 	EvtSearchProgress
 	EvtSearchFin
 	EvtHeader
-	EvtClose
+	EvtReady
 )

 const (
--- a/src/core.go
+++ b/src/core.go
@@ -63,76 +63,64 @@ func Run(opts *Options, revision string) {
 	ansiProcessor := func(data []byte) (util.Chars, *[]ansiOffset) {
 		return util.ToChars(data), nil
 	}
-	ansiProcessorRunes := func(data []rune) (util.Chars, *[]ansiOffset) {
-		return util.RunesToChars(data), nil
-	}
 	if opts.Ansi {
 		if opts.Theme != nil {
 			var state *ansiState
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				trimmed, offsets, newState := extractColor(string(data), state, nil)
 				state = newState
-				return util.RunesToChars([]rune(trimmed)), offsets
+				return util.ToChars([]byte(trimmed)), offsets
 			}
 		} else {
 			// When color is disabled but ansi option is given,
 			// we simply strip out ANSI codes from the input
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				trimmed, _, _ := extractColor(string(data), nil, nil)
-				return util.RunesToChars([]rune(trimmed)), nil
+				return util.ToChars([]byte(trimmed)), nil
 			}
 		}
-		ansiProcessorRunes = func(data []rune) (util.Chars, *[]ansiOffset) {
-			return ansiProcessor([]byte(string(data)))
-		}
 	}

 	// Chunk list
 	var chunkList *ChunkList
+	var itemIndex int32
 	header := make([]string, 0, opts.HeaderLines)
 	if len(opts.WithNth) == 0 {
-		chunkList = NewChunkList(func(data []byte, index int) *Item {
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
 			if len(header) < opts.HeaderLines {
 				header = append(header, string(data))
 				eventBox.Set(EvtHeader, header)
-				return nil
+				return false
 			}
-			chars, colors := ansiProcessor(data)
-			return &Item{
-				index:      int32(index),
-				trimLength: -1,
-				text:       chars,
-				colors:     colors}
+			item.text, item.colors = ansiProcessor(data)
+			item.text.Index = itemIndex
+			itemIndex++
+			return true
 		})
 	} else {
-		chunkList = NewChunkList(func(data []byte, index int) *Item {
-			tokens := Tokenize(util.ToChars(data), opts.Delimiter)
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
+			tokens := Tokenize(string(data), opts.Delimiter)
 			trans := Transform(tokens, opts.WithNth)
+			transformed := joinTokens(trans)
 			if len(header) < opts.HeaderLines {
-				header = append(header, string(joinTokens(trans)))
+				header = append(header, transformed)
 				eventBox.Set(EvtHeader, header)
-				return nil
+				return false
 			}
-			textRunes := joinTokens(trans)
-			item := Item{
-				index:      int32(index),
-				trimLength: -1,
-				origText:   &data,
-				colors:     nil}
-
-			trimmed, colors := ansiProcessorRunes(textRunes)
-			item.text = trimmed
-			item.colors = colors
-			return &item
+			item.text, item.colors = ansiProcessor([]byte(transformed))
+			item.text.Index = itemIndex
+			item.origText = &data
+			itemIndex++
+			return true
 		})
 	}

 	// Reader
 	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
 	if !streamingFilter {
-		reader := Reader{func(data []byte) bool {
+		reader := NewReader(func(data []byte) bool {
 			return chunkList.Push(data)
-		}, eventBox, opts.ReadZero}
+		}, eventBox, opts.ReadZero)
 		go reader.ReadSource()
 	}

@@ -165,17 +153,17 @@ func Run(opts *Options, revision string) {
 		found := false
 		if streamingFilter {
 			slab := util.MakeSlab(slab16Size, slab32Size)
-			reader := Reader{
+			reader := NewReader(
 				func(runes []byte) bool {
-					item := chunkList.trans(runes, 0)
-					if item != nil {
-						if result, _, _ := pattern.MatchItem(item, false, slab); result != nil {
+					item := Item{}
+					if chunkList.trans(&item, runes) {
+						if result, _, _ := pattern.MatchItem(&item, false, slab); result != nil {
 							opts.Printer(item.text.ToString())
 							found = true
 						}
 					}
 					return false
-				}, eventBox, opts.ReadZero}
+				}, eventBox, opts.ReadZero)
 			reader.ReadSource()
 		} else {
 			eventBox.Unwatch(EvtReadNew)
@@ -221,14 +209,19 @@ func Run(opts *Options, revision string) {
 		delay := true
 		ticks++
 		eventBox.Wait(func(events *util.Events) {
-			defer events.Clear()
+			if _, fin := (*events)[EvtReadFin]; fin {
+				delete(*events, EvtReadNew)
+			}
 			for evt, value := range *events {
 				switch evt {

 				case EvtReadNew, EvtReadFin:
 					reading = reading && evt == EvtReadNew
 					snapshot, count := chunkList.Snapshot()
-					terminal.UpdateCount(count, !reading)
+					terminal.UpdateCount(count, !reading, value.(bool))
+					if opts.Sync {
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac))
+					}
 					matcher.Reset(snapshot, terminal.Input(), false, !reading, sort)

 				case EvtSearchNew:
@@ -281,6 +274,7 @@ func Run(opts *Options, revision string) {
 					}
 				}
 			}
+			events.Clear()
 		})
 		if delay && reading {
 			dur := util.DurWithin(
--- a/src/item.go
+++ b/src/item.go
@@ -4,27 +4,23 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )

-// Item represents each input line
+// Item represents each input line. 56 bytes.
 type Item struct {
-	index       int32
-	trimLength  int32
-	text        util.Chars
-	origText    *[]byte
-	colors      *[]ansiOffset
-	transformed []Token
+	text        util.Chars    // 32 = 24 + 1 + 1 + 2 + 4
+	transformed *[]Token      // 8
+	origText    *[]byte       // 8
+	colors      *[]ansiOffset // 8
 }

 // Index returns ordinal index of the Item
 func (item *Item) Index() int32 {
-	return item.index
+	return item.text.Index
 }

-func (item *Item) TrimLength() int32 {
-	if item.trimLength >= 0 {
-		return item.trimLength
-	}
-	item.trimLength = int32(item.text.TrimLength())
-	return item.trimLength
+var minItem = Item{text: util.Chars{Index: -1}}
+
+func (item *Item) TrimLength() uint16 {
+	return item.text.TrimLength()
 }

 // Colors returns ansiOffsets of the Item
--- a/src/matcher.go
+++ b/src/matcher.go
@@ -131,7 +131,7 @@ func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {

 type partialResult struct {
 	index   int
-	matches []*Result
+	matches []Result
 }

 func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
@@ -162,7 +162,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		go func(idx int, slab *util.Slab, chunks []*Chunk) {
 			defer func() { waitGroup.Done() }()
 			count := 0
-			allMatches := make([][]*Result, len(chunks))
+			allMatches := make([][]Result, len(chunks))
 			for idx, chunk := range chunks {
 				matches := request.pattern.Match(chunk, slab)
 				allMatches[idx] = matches
@@ -172,7 +172,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 				}
 				countChan <- len(matches)
 			}
-			sliceMatches := make([]*Result, 0, count)
+			sliceMatches := make([]Result, 0, count)
 			for _, matches := range allMatches {
 				sliceMatches = append(sliceMatches, matches...)
 			}
@@ -212,7 +212,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		}
 	}

-	partialResults := make([][]*Result, numSlices)
+	partialResults := make([][]Result, numSlices)
 	for _ = range slices {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
--- a/src/merger.go
+++ b/src/merger.go
@@ -3,14 +3,14 @@ package fzf
 import "fmt"

 // EmptyMerger is a Merger with no data
-var EmptyMerger = NewMerger(nil, [][]*Result{}, false, false)
+var EmptyMerger = NewMerger(nil, [][]Result{}, false, false)

 // Merger holds a set of locally sorted lists of items and provides the view of
 // a single, globally-sorted list
 type Merger struct {
 	pattern *Pattern
-	lists   [][]*Result
-	merged  []*Result
+	lists   [][]Result
+	merged  []Result
 	chunks  *[]*Chunk
 	cursors []int
 	sorted  bool
@@ -29,17 +29,17 @@ func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
 		count:   0}

 	for _, chunk := range *mg.chunks {
-		mg.count += len(*chunk)
+		mg.count += chunk.count
 	}
 	return &mg
 }

 // NewMerger returns a new Merger
-func NewMerger(pattern *Pattern, lists [][]*Result, sorted bool, tac bool) *Merger {
+func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool) *Merger {
 	mg := Merger{
 		pattern: pattern,
 		lists:   lists,
-		merged:  []*Result{},
+		merged:  []Result{},
 		chunks:  nil,
 		cursors: make([]int, len(lists)),
 		sorted:  sorted,
@@ -59,13 +59,13 @@ func (mg *Merger) Length() int {
 }

 // Get returns the pointer to the Result object indexed by the given integer
-func (mg *Merger) Get(idx int) *Result {
+func (mg *Merger) Get(idx int) Result {
 	if mg.chunks != nil {
 		if mg.tac {
 			idx = mg.count - idx - 1
 		}
 		chunk := (*mg.chunks)[idx/chunkSize]
-		return &Result{item: (*chunk)[idx%chunkSize]}
+		return Result{item: &chunk.items[idx%chunkSize]}
 	}

 	if mg.sorted {
@@ -89,7 +89,7 @@ func (mg *Merger) cacheable() bool {
 	return mg.count < mergerCacheMax
 }

-func (mg *Merger) mergedGet(idx int) *Result {
+func (mg *Merger) mergedGet(idx int) Result {
 	for i := len(mg.merged); i <= idx; i++ {
 		minRank := minRank()
 		minIdx := -1
@@ -100,7 +100,7 @@ func (mg *Merger) mergedGet(idx int) *Result {
 				continue
 			}
 			if cursor >= 0 {
-				rank := list[cursor].rank
+				rank := list[cursor]
 				if minIdx < 0 || compareRanks(rank, minRank, mg.tac) {
 					minRank = rank
 					minIdx = listIdx
--- a/src/merger_test.go
+++ b/src/merger_test.go
@@ -15,11 +15,11 @@ func assert(t *testing.T, cond bool, msg ...string) {
 	}
 }

-func randResult() *Result {
+func randResult() Result {
 	str := fmt.Sprintf("%d", rand.Uint32())
-	return &Result{
-		item: &Item{text: util.RunesToChars([]rune(str))},
-		rank: rank{index: rand.Int31()}}
+	chars := util.ToChars([]byte(str))
+	chars.Index = rand.Int31()
+	return Result{item: &Item{text: chars}}
 }

 func TestEmptyMerger(t *testing.T) {
@@ -29,14 +29,14 @@ func TestEmptyMerger(t *testing.T) {
 	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
 }

-func buildLists(partiallySorted bool) ([][]*Result, []*Result) {
+func buildLists(partiallySorted bool) ([][]Result, []Result) {
 	numLists := 4
-	lists := make([][]*Result, numLists)
+	lists := make([][]Result, numLists)
 	cnt := 0
 	for i := 0; i < numLists; i++ {
 		numResults := rand.Int() % 20
 		cnt += numResults
-		lists[i] = make([]*Result, numResults)
+		lists[i] = make([]Result, numResults)
 		for j := 0; j < numResults; j++ {
 			item := randResult()
 			lists[i][j] = item
@@ -45,7 +45,7 @@ func buildLists(partiallySorted bool) ([][]*Result, []*Result) {
 			sort.Sort(ByRelevance(lists[i]))
 		}
 	}
-	items := []*Result{}
+	items := []Result{}
 	for _, list := range lists {
 		items = append(items, list...)
 	}
--- a/src/options.go
+++ b/src/options.go
@@ -962,7 +962,11 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--algo":
 			opts.FuzzyAlgo = parseAlgo(nextString(allArgs, &i, "algorithm required (v1|v2)"))
 		case "--expect":
-			opts.Expect = parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required")
+			for k, v := range parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required") {
+				opts.Expect[k] = v
+			}
+		case "--no-expect":
+			opts.Expect = make(map[int]string)
 		case "--tiebreak":
 			opts.Criteria = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
 		case "--bind":
@@ -1138,7 +1142,9 @@ func parseOptions(opts *Options, allArgs []string) {
 			} else if match, value := optString(arg, "--toggle-sort="); match {
 				parseToggleSort(opts.Keymap, value)
 			} else if match, value := optString(arg, "--expect="); match {
-				opts.Expect = parseKeyChords(value, "key names required")
+				for k, v := range parseKeyChords(value, "key names required") {
+					opts.Expect[k] = v
+				}
 			} else if match, value := optString(arg, "--tiebreak="); match {
 				opts.Criteria = parseTiebreak(value)
 			} else if match, value := optString(arg, "--color="); match {
--- a/src/options_test.go
+++ b/src/options_test.go
@@ -6,7 +6,6 @@ import (
 	"testing"

 	"github.com/junegunn/fzf/src/tui"
-	"github.com/junegunn/fzf/src/util"
 )

 func TestDelimiterRegex(t *testing.T) {
@@ -44,7 +43,7 @@ func TestDelimiterRegex(t *testing.T) {

 func TestDelimiterRegexString(t *testing.T) {
 	delim := delimiterRegexp("*")
-	tokens := Tokenize(util.RunesToChars([]rune("-*--*---**---")), delim)
+	tokens := Tokenize("-*--*---**---", delim)
 	if delim.regex != nil ||
 		tokens[0].text.ToString() != "-*" ||
 		tokens[1].text.ToString() != "--*" ||
@@ -57,7 +56,7 @@ func TestDelimiterRegexString(t *testing.T) {

 func TestDelimiterRegexRegex(t *testing.T) {
 	delim := delimiterRegexp("--\\*")
-	tokens := Tokenize(util.RunesToChars([]rune("-*--*---**---")), delim)
+	tokens := Tokenize("-*--*---**---", delim)
 	if delim.str != nil ||
 		tokens[0].text.ToString() != "-*--*" ||
 		tokens[1].text.ToString() != "---*" ||
@@ -415,3 +414,10 @@ func TestPreviewOpts(t *testing.T) {
 		t.Error(opts.Preview)
 	}
 }
+
+func TestAdditiveExpect(t *testing.T) {
+	opts := optsFor("--expect=a", "--expect", "b", "--expect=c")
+	if len(opts.Expect) != 3 {
+		t.Error(opts.Expect)
+	}
+}
--- a/src/pattern.go
+++ b/src/pattern.go
@@ -10,12 +10,12 @@ import (

 // fuzzy
 // 'exact
-// ^exact-prefix
-// exact-suffix$
-// !not-fuzzy
-// !'not-exact
-// !^not-exact-prefix
-// !not-exact-suffix$
+// ^prefix-exact
+// suffix-exact$
+// !inverse-exact
+// !'inverse-fuzzy
+// !^inverse-prefix-exact
+// !inverse-suffix-exact$

 type termType int

@@ -32,7 +32,6 @@ type term struct {
 	inv           bool
 	text          []rune
 	caseSensitive bool
-	origText      []rune
 }

 type termSet []term
@@ -48,6 +47,7 @@ type Pattern struct {
 	text          []rune
 	termSets      []termSet
 	cacheable     bool
+	cacheKey      string
 	delimiter     Delimiter
 	nth           []Range
 	procFun       map[termType]algo.Algo
@@ -60,7 +60,7 @@ var (
 )

 func init() {
-	_splitRegex = regexp.MustCompile("\\s+")
+	_splitRegex = regexp.MustCompile(" +")
 	clearPatternCache()
 	clearChunkCache()
 }
@@ -81,7 +81,10 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,

 	var asString string
 	if extended {
-		asString = strings.Trim(string(runes), " ")
+		asString = strings.TrimLeft(string(runes), " ")
+		for strings.HasSuffix(asString, " ") && !strings.HasSuffix(asString, "\\ ") {
+			asString = asString[:len(asString)-1]
+		}
 	} else {
 		asString = string(runes)
 	}
@@ -101,7 +104,7 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 			for idx, term := range termSet {
 				// If the query contains inverse search terms or OR operators,
 				// we cannot cache the search scope
-				if !cacheable || idx > 0 || term.inv || !fuzzy && term.typ != termExact {
+				if !cacheable || idx > 0 || term.inv || fuzzy && term.typ != termFuzzy || !fuzzy && term.typ != termExact {
 					cacheable = false
 					break Loop
 				}
@@ -130,6 +133,7 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 		delimiter:     delimiter,
 		procFun:       make(map[termType]algo.Algo)}

+	ptr.cacheKey = ptr.buildCacheKey()
 	ptr.procFun[termFuzzy] = fuzzyAlgo
 	ptr.procFun[termEqual] = algo.EqualMatch
 	ptr.procFun[termExact] = algo.ExactMatchNaive
@@ -141,27 +145,30 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 }

 func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet {
+	str = strings.Replace(str, "\\ ", "\t", -1)
 	tokens := _splitRegex.Split(str, -1)
 	sets := []termSet{}
 	set := termSet{}
 	switchSet := false
+	afterBar := false
 	for _, token := range tokens {
-		typ, inv, text := termFuzzy, false, token
+		typ, inv, text := termFuzzy, false, strings.Replace(token, "\t", " ", -1)
 		lowerText := strings.ToLower(text)
 		caseSensitive := caseMode == CaseRespect ||
 			caseMode == CaseSmart && text != lowerText
 		if !caseSensitive {
 			text = lowerText
 		}
-		origText := []rune(text)
 		if !fuzzy {
 			typ = termExact
 		}

-		if text == "|" {
+		if len(set) > 0 && !afterBar && text == "|" {
 			switchSet = false
+			afterBar = true
 			continue
 		}
+		afterBar = false

 		if strings.HasPrefix(text, "!") {
 			inv = true
@@ -169,6 +176,11 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 			text = text[1:]
 		}

+		if text != "$" && strings.HasSuffix(text, "$") {
+			typ = termSuffix
+			text = text[:len(text)-1]
+		}
+
 		if strings.HasPrefix(text, "'") {
 			// Flip exactness
 			if fuzzy && !inv {
@@ -179,16 +191,12 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 				text = text[1:]
 			}
 		} else if strings.HasPrefix(text, "^") {
-			if strings.HasSuffix(text, "$") {
+			if typ == termSuffix {
 				typ = termEqual
-				text = text[1 : len(text)-1]
 			} else {
 				typ = termPrefix
-				text = text[1:]
 			}
-		} else if strings.HasSuffix(text, "$") {
-			typ = termSuffix
-			text = text[:len(text)-1]
+			text = text[1:]
 		}

 		if len(text) > 0 {
@@ -204,8 +212,7 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 				typ:           typ,
 				inv:           inv,
 				text:          textRunes,
-				caseSensitive: caseSensitive,
-				origText:      origText})
+				caseSensitive: caseSensitive})
 			switchSet = true
 		}
 	}
@@ -228,46 +235,36 @@ func (p *Pattern) AsString() string {
 	return string(p.text)
 }

-// CacheKey is used to build string to be used as the key of result cache
-func (p *Pattern) CacheKey() string {
+func (p *Pattern) buildCacheKey() string {
 	if !p.extended {
 		return p.AsString()
 	}
 	cacheableTerms := []string{}
 	for _, termSet := range p.termSets {
 		if len(termSet) == 1 && !termSet[0].inv && (p.fuzzy || termSet[0].typ == termExact) {
-			cacheableTerms = append(cacheableTerms, string(termSet[0].origText))
+			cacheableTerms = append(cacheableTerms, string(termSet[0].text))
 		}
 	}
-	return strings.Join(cacheableTerms, " ")
+	return strings.Join(cacheableTerms, "\t")
+}
+
+// CacheKey is used to build string to be used as the key of result cache
+func (p *Pattern) CacheKey() string {
+	return p.cacheKey
 }

 // Match returns the list of matches Items in the given Chunk
-func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []*Result {
+func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []Result {
 	// ChunkCache: Exact match
 	cacheKey := p.CacheKey()
 	if p.cacheable {
-		if cached, found := _cache.Find(chunk, cacheKey); found {
+		if cached := _cache.Lookup(chunk, cacheKey); cached != nil {
 			return cached
 		}
 	}

 	// Prefix/suffix cache
-	var space []*Result
-Loop:
-	for idx := 1; idx < len(cacheKey); idx++ {
-		// [---------| ] | [ |---------]
-		// [--------|  ] | [  |--------]
-		// [-------|   ] | [   |-------]
-		prefix := cacheKey[:len(cacheKey)-idx]
-		suffix := cacheKey[idx:]
-		for _, substr := range [2]*string{&prefix, &suffix} {
-			if cached, found := _cache.Find(chunk, *substr); found {
-				space = cached
-				break Loop
-			}
-		}
-	}
+	space := _cache.Search(chunk, cacheKey)

 	matches := p.matchChunk(chunk, space, slab)

@@ -277,19 +274,19 @@ Loop:
 	return matches
 }

-func (p *Pattern) matchChunk(chunk *Chunk, space []*Result, slab *util.Slab) []*Result {
-	matches := []*Result{}
+func (p *Pattern) matchChunk(chunk *Chunk, space []Result, slab *util.Slab) []Result {
+	matches := []Result{}

 	if space == nil {
-		for _, item := range *chunk {
-			if match, _, _ := p.MatchItem(item, false, slab); match != nil {
-				matches = append(matches, match)
+		for idx := 0; idx < chunk.count; idx++ {
+			if match, _, _ := p.MatchItem(&chunk.items[idx], false, slab); match != nil {
+				matches = append(matches, *match)
 			}
 		}
 	} else {
 		for _, result := range space {
 			if match, _, _ := p.MatchItem(result.item, false, slab); match != nil {
-				matches = append(matches, match)
+				matches = append(matches, *match)
 			}
 		}
 	}
@@ -300,20 +297,27 @@ func (p *Pattern) matchChunk(chunk *Chunk, space []*Result, slab *util.Slab) []*
 func (p *Pattern) MatchItem(item *Item, withPos bool, slab *util.Slab) (*Result, []Offset, *[]int) {
 	if p.extended {
 		if offsets, bonus, pos := p.extendedMatch(item, withPos, slab); len(offsets) == len(p.termSets) {
-			return buildResult(item, offsets, bonus), offsets, pos
+			result := buildResult(item, offsets, bonus)
+			return &result, offsets, pos
 		}
 		return nil, nil, nil
 	}
 	offset, bonus, pos := p.basicMatch(item, withPos, slab)
 	if sidx := offset[0]; sidx >= 0 {
 		offsets := []Offset{offset}
-		return buildResult(item, offsets, bonus), offsets, pos
+		result := buildResult(item, offsets, bonus)
+		return &result, offsets, pos
 	}
 	return nil, nil, nil
 }

 func (p *Pattern) basicMatch(item *Item, withPos bool, slab *util.Slab) (Offset, int, *[]int) {
-	input := p.prepareInput(item)
+	var input []Token
+	if len(p.nth) == 0 {
+		input = []Token{Token{text: &item.text, prefixLength: 0}}
+	} else {
+		input = p.transformInput(item)
+	}
 	if p.fuzzy {
 		return p.iter(p.fuzzyAlgo, input, p.caseSensitive, p.normalize, p.forward, p.text, withPos, slab)
 	}
@@ -321,7 +325,12 @@ func (p *Pattern) basicMatch(item *Item, withPos bool, slab *util.Slab) (Offset,
 }

 func (p *Pattern) extendedMatch(item *Item, withPos bool, slab *util.Slab) ([]Offset, int, *[]int) {
-	input := p.prepareInput(item)
+	var input []Token
+	if len(p.nth) == 0 {
+		input = []Token{Token{text: &item.text, prefixLength: 0}}
+	} else {
+		input = p.transformInput(item)
+	}
 	offsets := []Offset{}
 	var totalScore int
 	var allPos *[]int
@@ -365,25 +374,20 @@ func (p *Pattern) extendedMatch(item *Item, withPos bool, slab *util.Slab) ([]Of
 	return offsets, totalScore, allPos
 }

-func (p *Pattern) prepareInput(item *Item) []Token {
+func (p *Pattern) transformInput(item *Item) []Token {
 	if item.transformed != nil {
-		return item.transformed
+		return *item.transformed
 	}

-	var ret []Token
-	if len(p.nth) == 0 {
-		ret = []Token{Token{text: &item.text, prefixLength: 0}}
-	} else {
-		tokens := Tokenize(item.text, p.delimiter)
-		ret = Transform(tokens, p.nth)
-	}
-	item.transformed = ret
+	tokens := Tokenize(item.text.ToString(), p.delimiter)
+	ret := Transform(tokens, p.nth)
+	item.transformed = &ret
 	return ret
 }

 func (p *Pattern) iter(pfun algo.Algo, tokens []Token, caseSensitive bool, normalize bool, forward bool, pattern []rune, withPos bool, slab *util.Slab) (Offset, int, *[]int) {
 	for _, part := range tokens {
-		if res, pos := pfun(caseSensitive, normalize, forward, *part.text, pattern, withPos, slab); res.Start >= 0 {
+		if res, pos := pfun(caseSensitive, normalize, forward, part.text, pattern, withPos, slab); res.Start >= 0 {
 			sidx := int32(res.Start) + part.prefixLength
 			eidx := int32(res.End) + part.prefixLength
 			if pos != nil {
--- a/src/pattern_test.go
+++ b/src/pattern_test.go
@@ -16,7 +16,7 @@ func init() {

 func TestParseTermsExtended(t *testing.T) {
 	terms := parseTerms(true, CaseSmart, false,
-		"| aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$ | ^iii$ ^xxx | 'yyy | | zzz$ | !ZZZ |")
+		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$ | ^iii$ ^xxx | 'yyy | zzz$ | !ZZZ |")
 	if len(terms) != 9 ||
 		terms[0][0].typ != termFuzzy || terms[0][0].inv ||
 		terms[1][0].typ != termExact || terms[1][0].inv ||
@@ -33,19 +33,11 @@ func TestParseTermsExtended(t *testing.T) {
 		terms[8][3].typ != termExact || !terms[8][3].inv {
 		t.Errorf("%s", terms)
 	}
-	for idx, termSet := range terms[:8] {
+	for _, termSet := range terms[:8] {
 		term := termSet[0]
 		if len(term.text) != 3 {
 			t.Errorf("%s", term)
 		}
-		if idx > 0 && len(term.origText) != 4+idx/5 {
-			t.Errorf("%s", term)
-		}
-	}
-	for _, term := range terms[8] {
-		if len(term.origText) != 4 {
-			t.Errorf("%s", term)
-		}
 	}
 }

@@ -66,7 +58,7 @@ func TestParseTermsExtendedExact(t *testing.T) {
 }

 func TestParseTermsEmpty(t *testing.T) {
-	terms := parseTerms(true, CaseSmart, false, "' $ ^ !' !^ !$")
+	terms := parseTerms(true, CaseSmart, false, "' ^ !' !^")
 	if len(terms) != 0 {
 		t.Errorf("%s", terms)
 	}
@@ -77,8 +69,9 @@ func TestExact(t *testing.T) {
 	clearPatternCache()
 	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true,
 		[]Range{}, Delimiter{}, []rune("'abc"))
+	chars := util.ToChars([]byte("aabbcc abc"))
 	res, pos := algo.ExactMatchNaive(
-		pattern.caseSensitive, pattern.normalize, pattern.forward, util.RunesToChars([]rune("aabbcc abc")), pattern.termSets[0][0].text, true, nil)
+		pattern.caseSensitive, pattern.normalize, pattern.forward, &chars, pattern.termSets[0][0].text, true, nil)
 	if res.Start != 7 || res.End != 10 {
 		t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
 	}
@@ -93,8 +86,9 @@ func TestEqual(t *testing.T) {
 	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("^AbC$"))

 	match := func(str string, sidxExpected int, eidxExpected int) {
+		chars := util.ToChars([]byte(str))
 		res, pos := algo.EqualMatch(
-			pattern.caseSensitive, pattern.normalize, pattern.forward, util.RunesToChars([]rune(str)), pattern.termSets[0][0].text, true, nil)
+			pattern.caseSensitive, pattern.normalize, pattern.forward, &chars, pattern.termSets[0][0].text, true, nil)
 		if res.Start != sidxExpected || res.End != eidxExpected {
 			t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
 		}
@@ -133,30 +127,29 @@ func TestCaseSensitivity(t *testing.T) {

 func TestOrigTextAndTransformed(t *testing.T) {
 	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("jg"))
-	tokens := Tokenize(util.RunesToChars([]rune("junegunn")), Delimiter{})
+	tokens := Tokenize("junegunn", Delimiter{})
 	trans := Transform(tokens, []Range{Range{1, 1}})

 	origBytes := []byte("junegunn.choi")
 	for _, extended := range []bool{false, true} {
-		chunk := Chunk{
-			&Item{
-				text:        util.RunesToChars([]rune("junegunn")),
-				origText:    &origBytes,
-				transformed: trans},
-		}
+		chunk := Chunk{count: 1}
+		chunk.items[0] = Item{
+			text:        util.ToChars([]byte("junegunn")),
+			origText:    &origBytes,
+			transformed: &trans}
 		pattern.extended = extended
 		matches := pattern.matchChunk(&chunk, nil, slab) // No cache
 		if !(matches[0].item.text.ToString() == "junegunn" &&
 			string(*matches[0].item.origText) == "junegunn.choi" &&
-			reflect.DeepEqual(matches[0].item.transformed, trans)) {
+			reflect.DeepEqual(*matches[0].item.transformed, trans)) {
 			t.Error("Invalid match result", matches)
 		}

-		match, offsets, pos := pattern.MatchItem(chunk[0], true, slab)
+		match, offsets, pos := pattern.MatchItem(&chunk.items[0], true, slab)
 		if !(match.item.text.ToString() == "junegunn" &&
 			string(*match.item.origText) == "junegunn.choi" &&
 			offsets[0][0] == 0 && offsets[0][1] == 5 &&
-			reflect.DeepEqual(match.item.transformed, trans)) {
+			reflect.DeepEqual(*match.item.transformed, trans)) {
 			t.Error("Invalid match result", match, offsets, extended)
 		}
 		if !((*pos)[0] == 4 && (*pos)[1] == 0) {
@@ -167,40 +160,47 @@ func TestOrigTextAndTransformed(t *testing.T) {

 func TestCacheKey(t *testing.T) {
 	test := func(extended bool, patStr string, expected string, cacheable bool) {
+		clearPatternCache()
 		pat := BuildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune(patStr))
 		if pat.CacheKey() != expected {
 			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
 		}
 		if pat.cacheable != cacheable {
-			t.Errorf("Expected: %s, actual: %s (%s)", cacheable, pat.cacheable, patStr)
+			t.Errorf("Expected: %t, actual: %t (%s)", cacheable, pat.cacheable, patStr)
 		}
 		clearPatternCache()
 	}
 	test(false, "foo !bar", "foo !bar", true)
 	test(false, "foo | bar !baz", "foo | bar !baz", true)
-	test(true, "foo  bar  baz", "foo bar baz", true)
+	test(true, "foo  bar  baz", "foo\tbar\tbaz", true)
 	test(true, "foo !bar", "foo", false)
-	test(true, "foo !bar   baz", "foo baz", false)
+	test(true, "foo !bar   baz", "foo\tbaz", false)
 	test(true, "foo | bar baz", "baz", false)
 	test(true, "foo | bar | baz", "", false)
 	test(true, "foo | bar !baz", "", false)
-	test(true, "| | | foo", "foo", true)
+	test(true, "| | foo", "", false)
+	test(true, "| | | foo", "foo", false)
 }

 func TestCacheable(t *testing.T) {
-	test := func(fuzzy bool, str string, cacheable bool) {
+	test := func(fuzzy bool, str string, expected string, cacheable bool) {
 		clearPatternCache()
 		pat := BuildPattern(fuzzy, algo.FuzzyMatchV2, true, CaseSmart, true, true, true, []Range{}, Delimiter{}, []rune(str))
+		if pat.CacheKey() != expected {
+			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
+		}
 		if cacheable != pat.cacheable {
 			t.Errorf("Invalid Pattern.cacheable for \"%s\": %v (expected: %v)", str, pat.cacheable, cacheable)
 		}
+		clearPatternCache()
 	}
-	test(true, "foo bar", true)
-	test(true, "foo 'bar", true)
-	test(true, "foo !bar", false)
+	test(true, "foo bar", "foo\tbar", true)
+	test(true, "foo 'bar", "foo\tbar", false)
+	test(true, "foo !bar", "foo", false)

-	test(false, "foo bar", true)
-	test(false, "foo '", true)
-	test(false, "foo 'bar", false)
-	test(false, "foo !bar", false)
+	test(false, "foo bar", "foo\tbar", true)
+	test(false, "foo 'bar", "foo", false)
+	test(false, "foo '", "foo", true)
+	test(false, "foo 'bar", "foo", false)
+	test(false, "foo !bar", "foo", false)
 }
--- a/src/reader.go
+++ b/src/reader.go
@@ -4,6 +4,8 @@ import (
 	"bufio"
 	"io"
 	"os"
+	"sync/atomic"
+	"time"

 	"github.com/junegunn/fzf/src/util"
 )
@@ -13,20 +15,54 @@ type Reader struct {
 	pusher   func([]byte) bool
 	eventBox *util.EventBox
 	delimNil bool
+	event    int32
+}
+
+// NewReader returns new Reader object
+func NewReader(pusher func([]byte) bool, eventBox *util.EventBox, delimNil bool) *Reader {
+	return &Reader{pusher, eventBox, delimNil, int32(EvtReady)}
+}
+
+func (r *Reader) startEventPoller() {
+	go func() {
+		ptr := &r.event
+		pollInterval := readerPollIntervalMin
+		for {
+			if atomic.CompareAndSwapInt32(ptr, int32(EvtReadNew), int32(EvtReady)) {
+				r.eventBox.Set(EvtReadNew, true)
+				pollInterval = readerPollIntervalMin
+			} else if atomic.LoadInt32(ptr) == int32(EvtReadFin) {
+				return
+			} else {
+				pollInterval += readerPollIntervalStep
+				if pollInterval > readerPollIntervalMax {
+					pollInterval = readerPollIntervalMax
+				}
+			}
+			time.Sleep(pollInterval)
+		}
+	}()
+}
+
+func (r *Reader) fin(success bool) {
+	atomic.StoreInt32(&r.event, int32(EvtReadFin))
+	r.eventBox.Set(EvtReadFin, success)
 }

 // ReadSource reads data from the default command or from standard input
 func (r *Reader) ReadSource() {
+	r.startEventPoller()
+	var success bool
 	if util.IsTty() {
 		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
 		if len(cmd) == 0 {
 			cmd = defaultCommand
 		}
-		r.readFromCommand(cmd)
+		success = r.readFromCommand(cmd)
 	} else {
-		r.readFromStdin()
+		success = r.readFromStdin()
 	}
-	r.eventBox.Set(EvtReadFin, nil)
+	r.fin(success)
 }

 func (r *Reader) feed(src io.Reader) {
@@ -40,7 +76,7 @@ func (r *Reader) feed(src io.Reader) {
 		// end in delim.
 		bytea, err := reader.ReadBytes(delim)
 		byteaLen := len(bytea)
-		if len(bytea) > 0 {
+		if byteaLen > 0 {
 			if err == nil {
 				// get rid of carriage return if under Windows:
 				if util.IsWindows() && byteaLen >= 2 && bytea[byteaLen-2] == byte('\r') {
@@ -50,7 +86,7 @@ func (r *Reader) feed(src io.Reader) {
 				}
 			}
 			if r.pusher(bytea) {
-				r.eventBox.Set(EvtReadNew, nil)
+				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}
 		if err != nil {
@@ -59,20 +95,21 @@ func (r *Reader) feed(src io.Reader) {
 	}
 }

-func (r *Reader) readFromStdin() {
+func (r *Reader) readFromStdin() bool {
 	r.feed(os.Stdin)
+	return true
 }

-func (r *Reader) readFromCommand(cmd string) {
+func (r *Reader) readFromCommand(cmd string) bool {
 	listCommand := util.ExecCommand(cmd)
 	out, err := listCommand.StdoutPipe()
 	if err != nil {
-		return
+		return false
 	}
 	err = listCommand.Start()
 	if err != nil {
-		return
+		return false
 	}
-	defer listCommand.Wait()
 	r.feed(out)
+	return listCommand.Wait() == nil
 }
--- a/src/reader_test.go
+++ b/src/reader_test.go
@@ -2,6 +2,7 @@ package fzf

 import (
 	"testing"
+	"time"

 	"github.com/junegunn/fzf/src/util"
 )
@@ -11,7 +12,10 @@ func TestReadFromCommand(t *testing.T) {
 	eb := util.NewEventBox()
 	reader := Reader{
 		pusher:   func(s []byte) bool { strs = append(strs, string(s)); return true },
-		eventBox: eb}
+		eventBox: eb,
+		event:    int32(EvtReady)}
+
+	reader.startEventPoller()

 	// Check EventBox
 	if eb.Peek(EvtReadNew) {
@@ -19,21 +23,16 @@ func TestReadFromCommand(t *testing.T) {
 	}

 	// Normal command
-	reader.readFromCommand(`echo abc && echo def`)
+	reader.fin(reader.readFromCommand(`echo abc && echo def`))
 	if len(strs) != 2 || strs[0] != "abc" || strs[1] != "def" {
 		t.Errorf("%s", strs)
 	}

 	// Check EventBox again
-	if !eb.Peek(EvtReadNew) {
-		t.Error("EvtReadNew should be set yet")
-	}
+	eb.WaitFor(EvtReadFin)

 	// Wait should return immediately
 	eb.Wait(func(events *util.Events) {
-		if _, found := (*events)[EvtReadNew]; !found {
-			t.Errorf("%s", events)
-		}
 		events.Clear()
 	})

@@ -42,8 +41,14 @@ func TestReadFromCommand(t *testing.T) {
 		t.Error("EvtReadNew should not be set yet")
 	}

+	// Make sure that event poller is finished
+	time.Sleep(readerPollIntervalMax)
+
+	// Restart event poller
+	reader.startEventPoller()
+
 	// Failing command
-	reader.readFromCommand(`no-such-command`)
+	reader.fin(reader.readFromCommand(`no-such-command`))
 	strs = []string{}
 	if len(strs) > 0 {
 		t.Errorf("%s", strs)
@@ -51,6 +56,9 @@ func TestReadFromCommand(t *testing.T) {

 	// Check EventBox again
 	if eb.Peek(EvtReadNew) {
-		t.Error("Command failed. EvtReadNew should be set")
+		t.Error("Command failed. EvtReadNew should not be set")
+	}
+	if !eb.Peek(EvtReadFin) {
+		t.Error("EvtReadFin should be set")
 	}
 }
--- a/src/result.go
+++ b/src/result.go
@@ -19,22 +19,17 @@ type colorOffset struct {
 	index  int32
 }

-type rank struct {
-	points [4]uint16
-	index  int32
-}
-
 type Result struct {
-	item *Item
-	rank rank
+	item   *Item
+	points [4]uint16
 }

-func buildResult(item *Item, offsets []Offset, score int) *Result {
+func buildResult(item *Item, offsets []Offset, score int) Result {
 	if len(offsets) > 1 {
 		sort.Sort(ByOrder(offsets))
 	}

-	result := Result{item: item, rank: rank{index: item.index}}
+	result := Result{item: item}
 	numChars := item.text.Length()
 	minBegin := math.MaxUint16
 	minEnd := math.MaxUint16
@@ -57,7 +52,7 @@ func buildResult(item *Item, offsets []Offset, score int) *Result {
 			// Higher is better
 			val = math.MaxUint16 - util.AsUint16(score)
 		case byLength:
-			val = util.AsUint16(int(item.TrimLength()))
+			val = item.TrimLength()
 		case byBegin, byEnd:
 			if validOffsetFound {
 				whitePrefixLen := 0
@@ -75,10 +70,10 @@ func buildResult(item *Item, offsets []Offset, score int) *Result {
 				}
 			}
 		}
-		result.rank.points[idx] = val
+		result.points[3-idx] = val
 	}

-	return &result
+	return result
 }

 // Sort criteria to use. Never changes once fzf is started.
@@ -86,11 +81,11 @@ var sortCriteria []criterion

 // Index returns ordinal index of the Item
 func (result *Result) Index() int32 {
-	return result.item.index
+	return result.item.Index()
 }

-func minRank() rank {
-	return rank{index: 0, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
+func minRank() Result {
+	return Result{item: &minItem, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
 }

 func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme, color tui.ColorPair, attr tui.Attr, current bool) []colorOffset {
@@ -201,7 +196,7 @@ func (a ByOrder) Less(i, j int) bool {
 }

 // ByRelevance is for sorting Items
-type ByRelevance []*Result
+type ByRelevance []Result

 func (a ByRelevance) Len() int {
 	return len(a)
@@ -212,11 +207,11 @@ func (a ByRelevance) Swap(i, j int) {
 }

 func (a ByRelevance) Less(i, j int) bool {
-	return compareRanks((*a[i]).rank, (*a[j]).rank, false)
+	return compareRanks(a[i], a[j], false)
 }

 // ByRelevanceTac is for sorting Items
-type ByRelevanceTac []*Result
+type ByRelevanceTac []Result

 func (a ByRelevanceTac) Len() int {
 	return len(a)
@@ -227,18 +222,5 @@ func (a ByRelevanceTac) Swap(i, j int) {
 }

 func (a ByRelevanceTac) Less(i, j int) bool {
-	return compareRanks((*a[i]).rank, (*a[j]).rank, true)
-}
-
-func compareRanks(irank rank, jrank rank, tac bool) bool {
-	for idx := 0; idx < 4; idx++ {
-		left := irank.points[idx]
-		right := jrank.points[idx]
-		if left < right {
-			return true
-		} else if left > right {
-			return false
-		}
-	}
-	return (irank.index <= jrank.index) != tac
+	return compareRanks(a[i], a[j], true)
 }
--- a/src/result_others.go
+++ b/src/result_others.go
@@ -0,0 +1,16 @@
+// +build !386,!amd64
+
+package fzf
+
+func compareRanks(irank Result, jrank Result, tac bool) bool {
+	for idx := 3; idx >= 0; idx-- {
+		left := irank.points[idx]
+		right := jrank.points[idx]
+		if left < right {
+			return true
+		} else if left > right {
+			return false
+		}
+	}
+	return (irank.item.Index() <= jrank.item.Index()) != tac
+}
--- a/src/result_test.go
+++ b/src/result_test.go
@@ -11,6 +11,11 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )

+func withIndex(i *Item, index int) *Item {
+	(*i).text.Index = int32(index)
+	return i
+}
+
 func TestOffsetSort(t *testing.T) {
 	offsets := []Offset{
 		Offset{3, 5}, Offset{2, 7},
@@ -26,10 +31,10 @@ func TestOffsetSort(t *testing.T) {
 }

 func TestRankComparison(t *testing.T) {
-	rank := func(vals ...uint16) rank {
-		return rank{
+	rank := func(vals ...uint16) Result {
+		return Result{
 			points: [4]uint16{vals[0], vals[1], vals[2], vals[3]},
-			index:  int32(vals[4])}
+			item:   &Item{text: util.Chars{Index: int32(vals[4])}}}
 	}
 	if compareRanks(rank(3, 0, 0, 0, 5), rank(2, 0, 0, 0, 7), false) ||
 		!compareRanks(rank(3, 0, 0, 0, 5), rank(3, 0, 0, 0, 6), false) ||
@@ -52,36 +57,41 @@ func TestResultRank(t *testing.T) {
 	sortCriteria = []criterion{byScore, byLength}

 	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
-	item1 := buildResult(&Item{text: util.RunesToChars(strs[0]), index: 1, trimLength: -1}, []Offset{}, 2)
-	if item1.rank.points[0] != math.MaxUint16-2 || // Bonus
-		item1.rank.points[1] != 3 || // Length
-		item1.rank.points[2] != 0 || // Unused
-		item1.rank.points[3] != 0 || // Unused
-		item1.item.index != 1 {
-		t.Error(item1.rank)
+	item1 := buildResult(
+		withIndex(&Item{text: util.RunesToChars(strs[0])}, 1), []Offset{}, 2)
+	if item1.points[3] != math.MaxUint16-2 || // Bonus
+		item1.points[2] != 3 || // Length
+		item1.points[1] != 0 || // Unused
+		item1.points[0] != 0 || // Unused
+		item1.item.Index() != 1 {
+		t.Error(item1)
 	}
 	// Only differ in index
 	item2 := buildResult(&Item{text: util.RunesToChars(strs[0])}, []Offset{}, 2)

-	items := []*Result{item1, item2}
+	items := []Result{item1, item2}
 	sort.Sort(ByRelevance(items))
 	if items[0] != item2 || items[1] != item1 {
 		t.Error(items)
 	}

-	items = []*Result{item2, item1, item1, item2}
+	items = []Result{item2, item1, item1, item2}
 	sort.Sort(ByRelevance(items))
 	if items[0] != item2 || items[1] != item2 ||
 		items[2] != item1 || items[3] != item1 {
-		t.Error(items, item1, item1.item.index, item2, item2.item.index)
+		t.Error(items, item1, item1.item.Index(), item2, item2.item.Index())
 	}

 	// Sort by relevance
-	item3 := buildResult(&Item{index: 2}, []Offset{Offset{1, 3}, Offset{5, 7}}, 3)
-	item4 := buildResult(&Item{index: 2}, []Offset{Offset{1, 2}, Offset{6, 7}}, 4)
-	item5 := buildResult(&Item{index: 2}, []Offset{Offset{1, 3}, Offset{5, 7}}, 5)
-	item6 := buildResult(&Item{index: 2}, []Offset{Offset{1, 2}, Offset{6, 7}}, 6)
-	items = []*Result{item1, item2, item3, item4, item5, item6}
+	item3 := buildResult(
+		withIndex(&Item{}, 2), []Offset{Offset{1, 3}, Offset{5, 7}}, 3)
+	item4 := buildResult(
+		withIndex(&Item{}, 2), []Offset{Offset{1, 2}, Offset{6, 7}}, 4)
+	item5 := buildResult(
+		withIndex(&Item{}, 2), []Offset{Offset{1, 3}, Offset{5, 7}}, 5)
+	item6 := buildResult(
+		withIndex(&Item{}, 2), []Offset{Offset{1, 2}, Offset{6, 7}}, 6)
+	items = []Result{item1, item2, item3, item4, item5, item6}
 	sort.Sort(ByRelevance(items))
 	if !(items[0] == item6 && items[1] == item5 &&
 		items[2] == item4 && items[3] == item3 &&
--- a/src/result_x86.go
+++ b/src/result_x86.go
@@ -0,0 +1,16 @@
+// +build 386 amd64
+
+package fzf
+
+import "unsafe"
+
+func compareRanks(irank Result, jrank Result, tac bool) bool {
+	left := *(*uint64)(unsafe.Pointer(&irank.points[0]))
+	right := *(*uint64)(unsafe.Pointer(&jrank.points[0]))
+	if left < right {
+		return true
+	} else if left > right {
+		return false
+	}
+	return (irank.item.Index() <= jrank.item.Index()) != tac
+}
--- a/src/terminal.go
+++ b/src/terminal.go
@@ -87,6 +87,7 @@ type Terminal struct {
 	margin     [4]sizeSpec
 	strong     tui.Attr
 	bordered   bool
+	cleanExit  bool
 	border     tui.Window
 	window     tui.Window
 	pborder    tui.Window
@@ -94,11 +95,13 @@ type Terminal struct {
 	count      int
 	progress   int
 	reading    bool
+	success    bool
 	jumping    jumpMode
 	jumpLabels string
 	printer    func(string)
 	merger     *Merger
 	selected   map[int32]selectedItem
+	version    int64
 	reqBox     *util.EventBox
 	preview    previewOpts
 	previewer  previewer
@@ -278,9 +281,13 @@ func defaultKeymap() map[int][]action {
 	return keymap
 }

+func trimQuery(query string) []rune {
+	return []rune(strings.Replace(query, "\t", " ", -1))
+}
+
 // NewTerminal returns new Terminal object
 func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
-	input := []rune(opts.Query)
+	input := trimQuery(opts.Query)
 	var header []string
 	if opts.Reverse {
 		header = opts.Header
@@ -365,6 +372,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		history:    opts.History,
 		margin:     opts.Margin,
 		bordered:   opts.Bordered,
+		cleanExit:  opts.ClearOnExit,
 		strong:     strongAttr,
 		cycle:      opts.Cycle,
 		header:     header,
@@ -372,6 +380,7 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		ansi:       opts.Ansi,
 		tabstop:    opts.Tabstop,
 		reading:    true,
+		success:    true,
 		jumping:    jumpDisabled,
 		jumpLabels: opts.JumpLabels,
 		printer:    opts.Printer,
@@ -401,10 +410,11 @@ func (t *Terminal) Input() []rune {
 }

 // UpdateCount updates the count information
-func (t *Terminal) UpdateCount(cnt int, final bool) {
+func (t *Terminal) UpdateCount(cnt int, final bool, success bool) {
 	t.mutex.Lock()
 	t.count = cnt
 	t.reading = !final
+	t.success = success
 	t.mutex.Unlock()
 	t.reqBox.Set(reqInfo, nil)
 	if final {
@@ -682,6 +692,9 @@ func (t *Terminal) printInfo() {
 	if t.progress > 0 && t.progress < 100 {
 		output += fmt.Sprintf(" (%d%%)", t.progress)
 	}
+	if !t.success && t.count == 0 {
+		output += " [ERROR]"
+	}
 	if pos+len(output) <= t.window.Width() {
 		t.window.CPrint(tui.ColInfo, 0, output)
 	}
@@ -704,11 +717,11 @@ func (t *Terminal) printHeader() {
 		trimmed, colors, newState := extractColor(lineStr, state, nil)
 		state = newState
 		item := &Item{
-			text:   util.RunesToChars([]rune(trimmed)),
+			text:   util.ToChars([]byte(trimmed)),
 			colors: colors}

 		t.move(line, 2, true)
-		t.printHighlighted(&Result{item: item},
+		t.printHighlighted(Result{item: item},
 			tui.AttrRegular, tui.ColHeader, tui.ColDefault, false, false)
 	}
 }
@@ -736,7 +749,7 @@ func (t *Terminal) printList() {
 	}
 }

-func (t *Terminal) printItem(result *Result, line int, i int, current bool) {
+func (t *Terminal) printItem(result Result, line int, i int, current bool) {
 	item := result.item
 	_, selected := t.selected[item.Index()]
 	label := " "
@@ -752,7 +765,7 @@ func (t *Terminal) printItem(result *Result, line int, i int, current bool) {

 	// Avoid unnecessary redraw
 	newLine := itemLine{current: current, selected: selected, label: label,
-		result: *result, queryLen: len(t.input), width: 0}
+		result: result, queryLen: len(t.input), width: 0}
 	prevLine := t.prevLines[i]
 	if prevLine.current == newLine.current &&
 		prevLine.selected == newLine.selected &&
@@ -834,7 +847,7 @@ func (t *Terminal) overflow(runes []rune, max int) bool {
 	return t.displayWidthWithLimit(runes, 0, max) > max
 }

-func (t *Terminal) printHighlighted(result *Result, attr tui.Attr, col1 tui.ColorPair, col2 tui.ColorPair, current bool, match bool) int {
+func (t *Terminal) printHighlighted(result Result, attr tui.Attr, col1 tui.ColorPair, col2 tui.ColorPair, current bool, match bool) int {
 	item := result.item

 	// Overflow
@@ -954,6 +967,7 @@ func (t *Terminal) printPreview() {
 	}
 	reader := bufio.NewReader(strings.NewReader(t.previewer.text))
 	lineNo := -t.previewer.offset
+	height := t.pwindow.Height()
 	var ansi *ansiState
 	for {
 		line, err := reader.ReadString('\n')
@@ -962,7 +976,8 @@ func (t *Terminal) printPreview() {
 			line = line[:len(line)-1]
 		}
 		lineNo++
-		if lineNo > t.pwindow.Height() {
+		if lineNo > height ||
+			t.pwindow.Y() == height-1 && t.pwindow.X() > 0 {
 			break
 		} else if lineNo > 0 {
 			var fillRet tui.FillReturn
@@ -992,7 +1007,7 @@ func (t *Terminal) printPreview() {
 		}
 	}
 	t.pwindow.FinishFill()
-	if t.previewer.lines > t.pwindow.Height() {
+	if t.previewer.lines > height {
 		offset := fmt.Sprintf("%d/%d", t.previewer.offset+1, t.previewer.lines)
 		pos := t.pwindow.Width() - len(offset)
 		if t.tui.DoesAutoWrap() {
@@ -1163,8 +1178,7 @@ func replacePlaceholder(template string, stripAnsi bool, delimiter Delimiter, fo
 		}

 		for idx, item := range items {
-			chars := util.RunesToChars([]rune(item.AsString(stripAnsi)))
-			tokens := Tokenize(chars, delimiter)
+			tokens := Tokenize(item.AsString(stripAnsi), delimiter)
 			trans := Transform(tokens, ranges)
 			str := string(joinTokens(trans))
 			if delimiter.str != nil {
@@ -1248,6 +1262,24 @@ func (t *Terminal) truncateQuery() {
 	t.cx = util.Constrain(t.cx, 0, len(t.input))
 }

+func (t *Terminal) selectItem(item *Item) {
+	t.selected[item.Index()] = selectedItem{time.Now(), item}
+	t.version++
+}
+
+func (t *Terminal) deselectItem(item *Item) {
+	delete(t.selected, item.Index())
+	t.version++
+}
+
+func (t *Terminal) toggleItem(item *Item) {
+	if _, found := t.selected[item.Index()]; !found {
+		t.selectItem(item)
+	} else {
+		t.deselectItem(item)
+	}
+}
+
 // Loop is called to start Terminal I/O
 func (t *Terminal) Loop() {
 	// prof := profile.Start(profile.ProfilePath("/tmp/"))
@@ -1335,7 +1367,12 @@ func (t *Terminal) Loop() {
 		}()
 	}

-	exit := func(code int) {
+	exit := func(getCode func() int) {
+		if !t.cleanExit && t.fullscreen && t.inlineInfo {
+			t.placeCursor()
+		}
+		t.tui.Close()
+		code := getCode()
 		if code <= exitNoMatch && t.history != nil {
 			t.history.append(string(t.input))
 		}
@@ -1345,6 +1382,7 @@ func (t *Terminal) Loop() {

 	go func() {
 		var focused *Item
+		var version int64
 		for {
 			t.reqBox.Wait(func(events *util.Events) {
 				defer events.Clear()
@@ -1361,7 +1399,8 @@ func (t *Terminal) Loop() {
 					case reqList:
 						t.printList()
 						currentFocus := t.currentItem()
-						if currentFocus != focused {
+						if currentFocus != focused || version != t.version {
+							version = t.version
 							focused = currentFocus
 							if t.isPreviewEnabled() {
 								_, list := t.buildPlusList(t.preview.command, false)
@@ -1383,11 +1422,12 @@ func (t *Terminal) Loop() {
 					case reqRedraw:
 						t.redraw()
 					case reqClose:
-						t.tui.Close()
-						if t.output() {
-							exit(exitOk)
-						}
-						exit(exitNoMatch)
+						exit(func() int {
+							if t.output() {
+								return exitOk
+							}
+							return exitNoMatch
+						})
 					case reqPreviewDisplay:
 						t.previewer.text = value.(string)
 						t.previewer.lines = strings.Count(t.previewer.text, "\n")
@@ -1396,12 +1436,12 @@ func (t *Terminal) Loop() {
 					case reqPreviewRefresh:
 						t.printPreview()
 					case reqPrintQuery:
-						t.tui.Close()
-						t.printer(string(t.input))
-						exit(exitOk)
+						exit(func() int {
+							t.printer(string(t.input))
+							return exitOk
+						})
 					case reqQuit:
-						t.tui.Close()
-						exit(exitInterrupt)
+						exit(func() int { return exitInterrupt })
 					}
 				}
 				t.placeCursor()
@@ -1426,22 +1466,9 @@ func (t *Terminal) Loop() {
 				}
 			}
 		}
-		selectItem := func(item *Item) bool {
-			if _, found := t.selected[item.Index()]; !found {
-				t.selected[item.Index()] = selectedItem{time.Now(), item}
-				return true
-			}
-			return false
-		}
-		toggleY := func(y int) {
-			item := t.merger.Get(y).item
-			if !selectItem(item) {
-				delete(t.selected, item.Index())
-			}
-		}
 		toggle := func() {
 			if t.cy < t.merger.Length() {
-				toggleY(t.cy)
+				t.toggleItem(t.merger.Get(t.cy).item)
 				req(reqInfo)
 			}
 		}
@@ -1555,17 +1582,14 @@ func (t *Terminal) Loop() {
 			case actSelectAll:
 				if t.multi {
 					for i := 0; i < t.merger.Length(); i++ {
-						item := t.merger.Get(i).item
-						selectItem(item)
+						t.selectItem(t.merger.Get(i).item)
 					}
 					req(reqList, reqInfo)
 				}
 			case actDeselectAll:
 				if t.multi {
-					for i := 0; i < t.merger.Length(); i++ {
-						item := t.merger.Get(i)
-						delete(t.selected, item.Index())
-					}
+					t.selected = make(map[int32]selectedItem)
+					t.version++
 					req(reqList, reqInfo)
 				}
 			case actToggle:
@@ -1576,7 +1600,7 @@ func (t *Terminal) Loop() {
 			case actToggleAll:
 				if t.multi {
 					for i := 0; i < t.merger.Length(); i++ {
-						toggleY(i)
+						t.toggleItem(t.merger.Get(i).item)
 					}
 					req(reqList, reqInfo)
 				}
@@ -1674,13 +1698,13 @@ func (t *Terminal) Loop() {
 			case actPreviousHistory:
 				if t.history != nil {
 					t.history.override(string(t.input))
-					t.input = []rune(t.history.previous())
+					t.input = trimQuery(t.history.previous())
 					t.cx = len(t.input)
 				}
 			case actNextHistory:
 				if t.history != nil {
 					t.history.override(string(t.input))
-					t.input = []rune(t.history.next())
+					t.input = trimQuery(t.history.next())
 					t.cx = len(t.input)
 				}
 			case actSigStop:
--- a/src/terminal_test.go
+++ b/src/terminal_test.go
@@ -10,7 +10,7 @@ import (
 func newItem(str string) *Item {
 	bytes := []byte(str)
 	trimmed, _, _ := extractColor(str, nil, nil)
-	return &Item{origText: &bytes, text: util.RunesToChars([]rune(trimmed))}
+	return &Item{origText: &bytes, text: util.ToChars([]byte(trimmed))}
 }

 func TestReplacePlaceholder(t *testing.T) {
--- a/src/tokenizer.go
+++ b/src/tokenizer.go
@@ -1,6 +1,7 @@
 package fzf

 import (
+	"bytes"
 	"regexp"
 	"strconv"
 	"strings"
@@ -74,14 +75,14 @@ func ParseRange(str *string) (Range, bool) {
 	return newRange(n, n), true
 }

-func withPrefixLengths(tokens []util.Chars, begin int) []Token {
+func withPrefixLengths(tokens []string, begin int) []Token {
 	ret := make([]Token, len(tokens))

 	prefixLength := begin
-	for idx, token := range tokens {
-		// NOTE: &tokens[idx] instead of &tokens
-		ret[idx] = Token{&tokens[idx], int32(prefixLength)}
-		prefixLength += token.Length()
+	for idx := range tokens {
+		chars := util.ToChars([]byte(tokens[idx]))
+		ret[idx] = Token{&chars, int32(prefixLength)}
+		prefixLength += chars.Length()
 	}
 	return ret
 }
@@ -92,16 +93,15 @@ const (
 	awkWhite
 )

-func awkTokenizer(input util.Chars) ([]util.Chars, int) {
+func awkTokenizer(input string) ([]string, int) {
 	// 9, 32
-	ret := []util.Chars{}
+	ret := []string{}
 	prefixLength := 0
 	state := awkNil
-	numChars := input.Length()
 	begin := 0
 	end := 0
-	for idx := 0; idx < numChars; idx++ {
-		r := input.Get(idx)
+	for idx := 0; idx < len(input); idx++ {
+		r := input[idx]
 		white := r == 9 || r == 32
 		switch state {
 		case awkNil:
@@ -119,19 +119,19 @@ func awkTokenizer(input util.Chars) ([]util.Chars, int) {
 			if white {
 				end = idx + 1
 			} else {
-				ret = append(ret, input.Slice(begin, end))
+				ret = append(ret, input[begin:end])
 				state, begin, end = awkBlack, idx, idx+1
 			}
 		}
 	}
 	if begin < end {
-		ret = append(ret, input.Slice(begin, end))
+		ret = append(ret, input[begin:end])
 	}
 	return ret, prefixLength
 }

 // Tokenize tokenizes the given string with the delimiter
-func Tokenize(text util.Chars, delimiter Delimiter) []Token {
+func Tokenize(text string, delimiter Delimiter) []Token {
 	if delimiter.str == nil && delimiter.regex == nil {
 		// AWK-style (\S+\s*)
 		tokens, prefixLength := awkTokenizer(text)
@@ -139,36 +139,31 @@ func Tokenize(text util.Chars, delimiter Delimiter) []Token {
 	}

 	if delimiter.str != nil {
-		return withPrefixLengths(text.Split(*delimiter.str), 0)
+		return withPrefixLengths(strings.SplitAfter(text, *delimiter.str), 0)
 	}

 	// FIXME performance
 	var tokens []string
 	if delimiter.regex != nil {
-		str := text.ToString()
-		for len(str) > 0 {
-			loc := delimiter.regex.FindStringIndex(str)
-			if loc == nil {
-				loc = []int{0, len(str)}
+		for len(text) > 0 {
+			loc := delimiter.regex.FindStringIndex(text)
+			if len(loc) < 2 {
+				loc = []int{0, len(text)}
 			}
 			last := util.Max(loc[1], 1)
-			tokens = append(tokens, str[:last])
-			str = str[last:]
+			tokens = append(tokens, text[:last])
+			text = text[last:]
 		}
 	}
-	asRunes := make([]util.Chars, len(tokens))
-	for i, token := range tokens {
-		asRunes[i] = util.RunesToChars([]rune(token))
-	}
-	return withPrefixLengths(asRunes, 0)
+	return withPrefixLengths(tokens, 0)
 }

-func joinTokens(tokens []Token) []rune {
-	ret := []rune{}
+func joinTokens(tokens []Token) string {
+	var output bytes.Buffer
 	for _, token := range tokens {
-		ret = append(ret, token.text.ToRunes()...)
+		output.WriteString(token.text.ToString())
 	}
-	return ret
+	return output.String()
 }

 // Transform is used to transform the input when --with-nth option is given
@@ -181,7 +176,7 @@ func Transform(tokens []Token, withNth []Range) []Token {
 		if r.begin == r.end {
 			idx := r.begin
 			if idx == rangeEllipsis {
-				chars := util.RunesToChars(joinTokens(tokens))
+				chars := util.ToChars([]byte(joinTokens(tokens)))
 				parts = append(parts, &chars)
 			} else {
 				if idx < 0 {
@@ -224,15 +219,15 @@ func Transform(tokens []Token, withNth []Range) []Token {
 		var merged util.Chars
 		switch len(parts) {
 		case 0:
-			merged = util.RunesToChars([]rune{})
+			merged = util.ToChars([]byte{})
 		case 1:
 			merged = *parts[0]
 		default:
-			runes := []rune{}
+			var output bytes.Buffer
 			for _, part := range parts {
-				runes = append(runes, part.ToRunes()...)
+				output.WriteString(part.ToString())
 			}
-			merged = util.RunesToChars(runes)
+			merged = util.ToChars([]byte(output.String()))
 		}

 		var prefixLength int32
--- a/src/tokenizer_test.go
+++ b/src/tokenizer_test.go
@@ -2,8 +2,6 @@ package fzf

 import (
 	"testing"
-
-	"github.com/junegunn/fzf/src/util"
 )

 func TestParseRange(t *testing.T) {
@@ -47,19 +45,19 @@ func TestParseRange(t *testing.T) {
 func TestTokenize(t *testing.T) {
 	// AWK-style
 	input := "  abc:  def:  ghi  "
-	tokens := Tokenize(util.RunesToChars([]rune(input)), Delimiter{})
+	tokens := Tokenize(input, Delimiter{})
 	if tokens[0].text.ToString() != "abc:  " || tokens[0].prefixLength != 2 {
 		t.Errorf("%s", tokens)
 	}

 	// With delimiter
-	tokens = Tokenize(util.RunesToChars([]rune(input)), delimiterRegexp(":"))
+	tokens = Tokenize(input, delimiterRegexp(":"))
 	if tokens[0].text.ToString() != "  abc:" || tokens[0].prefixLength != 0 {
-		t.Errorf("%s", tokens)
+		t.Error(tokens[0].text.ToString(), tokens[0].prefixLength)
 	}

 	// With delimiter regex
-	tokens = Tokenize(util.RunesToChars([]rune(input)), delimiterRegexp("\\s+"))
+	tokens = Tokenize(input, delimiterRegexp("\\s+"))
 	if tokens[0].text.ToString() != "  " || tokens[0].prefixLength != 0 ||
 		tokens[1].text.ToString() != "abc:  " || tokens[1].prefixLength != 2 ||
 		tokens[2].text.ToString() != "def:  " || tokens[2].prefixLength != 8 ||
@@ -71,7 +69,7 @@ func TestTokenize(t *testing.T) {
 func TestTransform(t *testing.T) {
 	input := "  abc:  def:  ghi:  jkl"
 	{
-		tokens := Tokenize(util.RunesToChars([]rune(input)), Delimiter{})
+		tokens := Tokenize(input, Delimiter{})
 		{
 			ranges := splitNth("1,2,3")
 			tx := Transform(tokens, ranges)
@@ -93,7 +91,7 @@ func TestTransform(t *testing.T) {
 		}
 	}
 	{
-		tokens := Tokenize(util.RunesToChars([]rune(input)), delimiterRegexp(":"))
+		tokens := Tokenize(input, delimiterRegexp(":"))
 		{
 			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
--- a/src/tui/light.go
+++ b/src/tui/light.go
@@ -32,7 +32,8 @@ var offsetRegexp *regexp.Regexp = regexp.MustCompile("\x1b\\[([0-9]+);([0-9]+)R"
 func openTtyIn() *os.File {
 	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
 	if err != nil {
-		panic("Failed to open " + consoleDevice)
+		fmt.Fprintln(os.Stderr, "Failed to open "+consoleDevice)
+		os.Exit(2)
 	}
 	return in
 }
@@ -182,10 +183,18 @@ func (r *LightRenderer) Init() {
 	if r.fullscreen {
 		r.smcup()
 	} else {
-		r.csi("J")
+		// We assume that --no-clear is used for repetitive relaunching of fzf.
+		// So we do not clear the lower bottom of the screen.
+		if r.clearOnExit {
+			r.csi("J")
+		}
 		y, x := r.findOffset()
 		r.mouse = r.mouse && y >= 0
-		if x > 0 {
+		// When --no-clear is used for repetitive relaunching, there is a small
+		// time frame between fzf processes where the user keystrokes are not
+		// captured by either of fzf process which can cause x offset to be
+		// increased and we're left with unwanted extra new line.
+		if x > 0 && r.clearOnExit {
 			r.upOneLine = true
 			r.makeSpace()
 		}
@@ -200,7 +209,9 @@ func (r *LightRenderer) Init() {
 	r.csi(fmt.Sprintf("%dA", r.MaxY()-1))
 	r.csi("G")
 	r.csi("K")
-	// r.csi("s")
+	if !r.clearOnExit && !r.fullscreen {
+		r.csi("s")
+	}
 	if !r.fullscreen && r.mouse {
 		r.yoffset, _ = r.findOffset()
 	}
@@ -411,10 +422,12 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 						return Event{F12, 0, nil}
 					}
 				}
-				// Bracketed paste mode \e[200~ / \e[201
-				if r.buffer[3] == 48 && (r.buffer[4] == 48 || r.buffer[4] == 49) && r.buffer[5] == 126 {
-					*sz = 6
-					return Event{Invalid, 0, nil}
+				// Bracketed paste mode: \e[200~ ... \e[201~
+				if r.buffer[3] == '0' && (r.buffer[4] == '0' || r.buffer[4] == '1') && r.buffer[5] == '~' {
+					// Immediately discard the sequence from the buffer and reread input
+					r.buffer = r.buffer[6:]
+					*sz = 0
+					return r.GetChar()
 				}
 				return Event{Invalid, 0, nil} // INS
 			case 51:
@@ -584,10 +597,8 @@ func (r *LightRenderer) Close() {
 			}
 			r.csi("J")
 		}
-	} else if r.fullscreen {
-		r.csi("G")
-	} else {
-		r.move(r.height, 0)
+	} else if !r.fullscreen {
+		r.csi("u")
 	}
 	if r.mouse {
 		r.csi("?1000l")
@@ -697,6 +708,10 @@ func (w *LightWindow) X() int {
 	return w.posx
 }

+func (w *LightWindow) Y() int {
+	return w.posy
+}
+
 func (w *LightWindow) Enclose(y int, x int) bool {
 	return x >= w.left && x < (w.left+w.width) &&
 		y >= w.top && y < (w.top+w.height)
@@ -831,17 +846,20 @@ func (w *LightWindow) fill(str string, onMove func()) FillReturn {
 		for j, wl := range lines {
 			if w.posx >= w.Width()-1 && wl.displayWidth == 0 {
 				if w.posy < w.height-1 {
-					w.MoveAndClear(w.posy+1, 0)
+					w.Move(w.posy+1, 0)
 				}
 				return FillNextLine
 			}
 			w.stderrInternal(wl.text, false)
 			w.posx += wl.displayWidth
+
+			// Wrap line
 			if j < len(lines)-1 || i < len(allLines)-1 {
 				if w.posy+1 >= w.height {
 					return FillSuspend
 				}
-				w.MoveAndClear(w.posy+1, 0)
+				w.MoveAndClear(w.posy, w.posx)
+				w.Move(w.posy+1, 0)
 				onMove()
 			}
 		}
@@ -856,24 +874,25 @@ func (w *LightWindow) setBg() {
 }

 func (w *LightWindow) Fill(text string) FillReturn {
-	w.MoveAndClear(w.posy, w.posx)
+	w.Move(w.posy, w.posx)
 	w.setBg()
 	return w.fill(text, w.setBg)
 }

 func (w *LightWindow) CFill(fg Color, bg Color, attr Attr, text string) FillReturn {
-	w.MoveAndClear(w.posy, w.posx)
+	w.Move(w.posy, w.posx)
 	if bg == colDefault {
 		bg = w.bg
 	}
 	if w.csiColor(fg, bg, attr) {
-		return w.fill(text, func() { w.csiColor(fg, bg, attr) })
 		defer w.csi("m")
+		return w.fill(text, func() { w.csiColor(fg, bg, attr) })
 	}
 	return w.fill(text, w.setBg)
 }

 func (w *LightWindow) FinishFill() {
+	w.MoveAndClear(w.posy, w.posx)
 	for y := w.posy + 1; y < w.height; y++ {
 		w.MoveAndClear(y, 0)
 	}
--- a/src/tui/tcell.go
+++ b/src/tui/tcell.go
@@ -164,6 +164,10 @@ func (w *TcellWindow) X() int {
 	return w.lastX
 }

+func (w *TcellWindow) Y() int {
+	return w.lastY
+}
+
 func (r *FullscreenRenderer) DoesAutoWrap() bool {
 	return false
 }
--- a/src/tui/tui.go
+++ b/src/tui/tui.go
@@ -236,6 +236,7 @@ type Window interface {
 	Close()

 	X() int
+	Y() int
 	Enclose(y int, x int) bool

 	Move(y int, x int)
--- a/src/util/chars.go
+++ b/src/util/chars.go
@@ -3,63 +3,103 @@ package util
 import (
 	"unicode"
 	"unicode/utf8"
+	"unsafe"
+)
+
+const (
+	overflow64 uint64 = 0x8080808080808080
+	overflow32 uint32 = 0x80808080
 )

 type Chars struct {
-	runes []rune
-	bytes []byte
+	slice           []byte // or []rune
+	inBytes         bool
+	trimLengthKnown bool
+	trimLength      uint16
+
+	// XXX Piggybacking item index here is a horrible idea. But I'm trying to
+	// minimize the memory footprint by not wasting padded spaces.
+	Index int32
+}
+
+func checkAscii(bytes []byte) (bool, int) {
+	i := 0
+	for ; i <= len(bytes)-8; i += 8 {
+		if (overflow64 & *(*uint64)(unsafe.Pointer(&bytes[i]))) > 0 {
+			return false, i
+		}
+	}
+	for ; i <= len(bytes)-4; i += 4 {
+		if (overflow32 & *(*uint32)(unsafe.Pointer(&bytes[i]))) > 0 {
+			return false, i
+		}
+	}
+	for ; i < len(bytes); i++ {
+		if bytes[i] >= utf8.RuneSelf {
+			return false, i
+		}
+	}
+	return true, 0
 }

 // ToChars converts byte array into rune array
-func ToChars(bytea []byte) Chars {
-	var runes []rune
-	ascii := true
-	numBytes := len(bytea)
-	for i := 0; i < numBytes; {
-		if bytea[i] < utf8.RuneSelf {
-			if !ascii {
-				runes = append(runes, rune(bytea[i]))
-			}
-			i++
-		} else {
-			if ascii {
-				ascii = false
-				runes = make([]rune, i, numBytes)
-				for j := 0; j < i; j++ {
-					runes[j] = rune(bytea[j])
-				}
-			}
-			r, sz := utf8.DecodeRune(bytea[i:])
-			i += sz
-			runes = append(runes, r)
-		}
+func ToChars(bytes []byte) Chars {
+	inBytes, bytesUntil := checkAscii(bytes)
+	if inBytes {
+		return Chars{slice: bytes, inBytes: inBytes}
 	}
-	if ascii {
-		return Chars{bytes: bytea}
+
+	runes := make([]rune, bytesUntil, len(bytes))
+	for i := 0; i < bytesUntil; i++ {
+		runes[i] = rune(bytes[i])
 	}
-	return Chars{runes: runes}
+	for i := bytesUntil; i < len(bytes); {
+		r, sz := utf8.DecodeRune(bytes[i:])
+		i += sz
+		runes = append(runes, r)
+	}
+	return RunesToChars(runes)
 }

 func RunesToChars(runes []rune) Chars {
-	return Chars{runes: runes}
+	return Chars{slice: *(*[]byte)(unsafe.Pointer(&runes)), inBytes: false}
+}
+
+func (chars *Chars) IsBytes() bool {
+	return chars.inBytes
+}
+
+func (chars *Chars) Bytes() []byte {
+	return chars.slice
+}
+
+func (chars *Chars) optionalRunes() []rune {
+	if chars.inBytes {
+		return nil
+	}
+	return *(*[]rune)(unsafe.Pointer(&chars.slice))
 }

 func (chars *Chars) Get(i int) rune {
-	if chars.runes != nil {
-		return chars.runes[i]
+	if runes := chars.optionalRunes(); runes != nil {
+		return runes[i]
 	}
-	return rune(chars.bytes[i])
+	return rune(chars.slice[i])
 }

 func (chars *Chars) Length() int {
-	if chars.runes != nil {
-		return len(chars.runes)
+	if runes := chars.optionalRunes(); runes != nil {
+		return len(runes)
 	}
-	return len(chars.bytes)
+	return len(chars.slice)
 }

 // TrimLength returns the length after trimming leading and trailing whitespaces
-func (chars *Chars) TrimLength() int {
+func (chars *Chars) TrimLength() uint16 {
+	if chars.trimLengthKnown {
+		return chars.trimLength
+	}
+	chars.trimLengthKnown = true
 	var i int
 	len := chars.Length()
 	for i = len - 1; i >= 0; i-- {
@@ -80,7 +120,8 @@ func (chars *Chars) TrimLength() int {
 			break
 		}
 	}
-	return i - j + 1
+	chars.trimLength = AsUint16(i - j + 1)
+	return chars.trimLength
 }

 func (chars *Chars) TrailingWhitespaces() int {
@@ -96,62 +137,31 @@ func (chars *Chars) TrailingWhitespaces() int {
 }

 func (chars *Chars) ToString() string {
-	if chars.runes != nil {
-		return string(chars.runes)
+	if runes := chars.optionalRunes(); runes != nil {
+		return string(runes)
 	}
-	return string(chars.bytes)
+	return string(chars.slice)
 }

 func (chars *Chars) ToRunes() []rune {
-	if chars.runes != nil {
-		return chars.runes
+	if runes := chars.optionalRunes(); runes != nil {
+		return runes
 	}
-	runes := make([]rune, len(chars.bytes))
-	for idx, b := range chars.bytes {
+	bytes := chars.slice
+	runes := make([]rune, len(bytes))
+	for idx, b := range bytes {
 		runes[idx] = rune(b)
 	}
 	return runes
 }

-func (chars *Chars) Slice(b int, e int) Chars {
-	if chars.runes != nil {
-		return Chars{runes: chars.runes[b:e]}
+func (chars *Chars) CopyRunes(dest []rune) {
+	if runes := chars.optionalRunes(); runes != nil {
+		copy(dest, runes)
+		return
 	}
-	return Chars{bytes: chars.bytes[b:e]}
-}
-
-func (chars *Chars) Split(delimiter string) []Chars {
-	delim := []rune(delimiter)
-	numChars := chars.Length()
-	numDelim := len(delim)
-	begin := 0
-	ret := make([]Chars, 0, 1)
-
-	for index := 0; index < numChars; {
-		if index+numDelim <= numChars {
-			match := true
-			for off, d := range delim {
-				if chars.Get(index+off) != d {
-					match = false
-					break
-				}
-			}
-			// Found the delimiter
-			if match {
-				incr := Max(numDelim, 1)
-				ret = append(ret, chars.Slice(begin, index+incr))
-				index += incr
-				begin = index
-				continue
-			}
-		} else {
-			// Impossible to find the delimiter in the remaining substring
-			break
-		}
-		index++
-	}
-	if begin < numChars || len(ret) == 0 {
-		ret = append(ret, chars.Slice(begin, numChars))
-	}
-	return ret
+	for idx, b := range chars.slice[:len(dest)] {
+		dest[idx] = rune(b)
+	}
+	return
 }
--- a/src/util/chars_test.go
+++ b/src/util/chars_test.go
@@ -2,27 +2,16 @@ package util

 import "testing"

-func TestToCharsNil(t *testing.T) {
-	bs := Chars{bytes: []byte{}}
-	if bs.bytes == nil || bs.runes != nil {
-		t.Error()
-	}
-	rs := RunesToChars([]rune{})
-	if rs.bytes != nil || rs.runes == nil {
-		t.Error()
-	}
-}
-
 func TestToCharsAscii(t *testing.T) {
 	chars := ToChars([]byte("foobar"))
-	if chars.ToString() != "foobar" || chars.runes != nil {
+	if !chars.inBytes || chars.ToString() != "foobar" || !chars.inBytes {
 		t.Error()
 	}
 }

 func TestCharsLength(t *testing.T) {
 	chars := ToChars([]byte("\tabc한글  "))
-	if chars.Length() != 8 || chars.TrimLength() != 5 {
+	if chars.inBytes || chars.Length() != 8 || chars.TrimLength() != 5 {
 		t.Error()
 	}
 }
@@ -36,7 +25,7 @@ func TestCharsToString(t *testing.T) {
 }

 func TestTrimLength(t *testing.T) {
-	check := func(str string, exp int) {
+	check := func(str string, exp uint16) {
 		chars := ToChars([]byte(str))
 		trimmed := chars.TrimLength()
 		if trimmed != exp {
@@ -55,28 +44,3 @@ func TestTrimLength(t *testing.T) {
 	check("  h   o  ", 5)
 	check("         ", 0)
 }
-
-func TestSplit(t *testing.T) {
-	check := func(str string, delim string, tokens ...string) {
-		input := ToChars([]byte(str))
-		result := input.Split(delim)
-		if len(result) != len(tokens) {
-			t.Errorf("Invalid Split result for '%s': %d tokens found (expected %d): %s",
-				str, len(result), len(tokens), result)
-		}
-		for idx, token := range tokens {
-			if result[idx].ToString() != token {
-				t.Errorf("Invalid Split result for '%s': %s (expected %s)",
-					str, result[idx].ToString(), token)
-			}
-		}
-	}
-	check("abc:def::", ":", "abc:", "def:", ":")
-	check("abc:def::", "-", "abc:def::")
-	check("abc", "", "a", "b", "c")
-	check("abc", "a", "a", "bc")
-	check("abc", "ab", "ab", "c")
-	check("abc", "abc", "abc")
-	check("abc", "abcd", "abc")
-	check("", "abcd", "")
-}
--- a/src/util/eventbox.go
+++ b/src/util/eventbox.go
@@ -26,23 +26,23 @@ func NewEventBox() *EventBox {
 // Wait blocks the goroutine until signaled
 func (b *EventBox) Wait(callback func(*Events)) {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()

 	if len(b.events) == 0 {
 		b.cond.Wait()
 	}

 	callback(&b.events)
+	b.cond.L.Unlock()
 }

 // Set turns on the event type on the box
 func (b *EventBox) Set(event EventType, value interface{}) {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()
 	b.events[event] = value
 	if _, found := b.ignore[event]; !found {
 		b.cond.Broadcast()
 	}
+	b.cond.L.Unlock()
 }

 // Clear clears the events
@@ -56,27 +56,27 @@ func (events *Events) Clear() {
 // Peek peeks at the event box if the given event is set
 func (b *EventBox) Peek(event EventType) bool {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()
 	_, ok := b.events[event]
+	b.cond.L.Unlock()
 	return ok
 }

 // Watch deletes the events from the ignore list
 func (b *EventBox) Watch(events ...EventType) {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()
 	for _, event := range events {
 		delete(b.ignore, event)
 	}
+	b.cond.L.Unlock()
 }

 // Unwatch adds the events to the ignore list
 func (b *EventBox) Unwatch(events ...EventType) {
 	b.cond.L.Lock()
-	defer b.cond.L.Unlock()
 	for _, event := range events {
 		b.ignore[event] = true
 	}
+	b.cond.L.Unlock()
 }

 // WaitFor blocks the execution until the event is received
--- a/test/fzf.vader
+++ b/test/fzf.vader
@@ -6,11 +6,11 @@ Execute (Setup):

 Execute (fzf#run with dir option):
  let cwd = getcwd()
-  let result = fzf#run({ 'options': '--filter=vdr', 'dir': g:dir })
+  let result = fzf#run({ 'source': 'git ls-files', 'options': '--filter=vdr', 'dir': g:dir })
  AssertEqual ['fzf.vader'], result
  AssertEqual getcwd(), cwd

-  let result = sort(fzf#run({ 'options': '--filter e', 'dir': g:dir }))
+  let result = sort(fzf#run({ 'source': 'git ls-files', 'options': '--filter e', 'dir': g:dir }))
  AssertEqual ['fzf.vader', 'test_go.rb'], result
  AssertEqual getcwd(), cwd

@@ -19,7 +19,7 @@ Execute (fzf#run with Funcref command):
  function! g:FzfTest(e)
    call add(g:ret, a:e)
  endfunction
-  let result = sort(fzf#run({ 'sink': function('g:FzfTest'), 'options': '--filter e', 'dir': g:dir }))
+  let result = sort(fzf#run({ 'source': 'git ls-files', 'sink': function('g:FzfTest'), 'options': '--filter e', 'dir': g:dir }))
  AssertEqual ['fzf.vader', 'test_go.rb'], result
  AssertEqual ['fzf.vader', 'test_go.rb'], sort(g:ret)

@@ -140,7 +140,7 @@ Execute (fzf#wrap):
  let g:fzf_history_dir = '/tmp'
  let opts = fzf#wrap('foobar', {'options': '--color light'})
  Log opts
-  Assert opts.options =~ '--history /tmp/foobar'
+  Assert opts.options =~ "--history '/tmp/foobar'"
  Assert opts.options =~ '--color light'

  let g:fzf_colors = { 'fg': ['fg', 'Error'] }
@@ -149,21 +149,23 @@ Execute (fzf#wrap):

 Execute (fzf#shellescape with sh):
  AssertEqual '''''', fzf#shellescape('', 'sh')
+  AssertEqual '''\''', fzf#shellescape('\', 'sh')
  AssertEqual '''""''', fzf#shellescape('""', 'sh')
  AssertEqual '''foobar>''', fzf#shellescape('foobar>', 'sh')
-  AssertEqual '''\"''', fzf#shellescape('\"', 'sh')
+  AssertEqual '''\\\"\\\''', fzf#shellescape('\\\"\\\', 'sh')
  AssertEqual '''echo ''\''''a''\'''' && echo ''\''''b''\''''''', fzf#shellescape('echo ''a'' && echo ''b''', 'sh')

 Execute (fzf#shellescape with cmd.exe):
  AssertEqual '^"^"', fzf#shellescape('', 'cmd.exe')
+  AssertEqual '^"\\^"', fzf#shellescape('\', 'cmd.exe')
  AssertEqual '^"\^"\^"^"', fzf#shellescape('""', 'cmd.exe')
  AssertEqual '^"foobar^>^"', fzf#shellescape('foobar>', 'cmd.exe')
-  AssertEqual '^"\\\^"\\^"', fzf#shellescape('\\\\\\\\"\', 'cmd.exe')
+  AssertEqual '^"\\\\\\\^"\\\\\\^"', fzf#shellescape('\\\"\\\', 'cmd.exe')
  AssertEqual '^"echo ''a'' ^&^& echo ''b''^"', fzf#shellescape('echo ''a'' && echo ''b''', 'cmd.exe')

  AssertEqual '^"C:\Program Files ^(x86^)\\^"', fzf#shellescape('C:\Program Files (x86)\', 'cmd.exe')
  AssertEqual '^"C:/Program Files ^(x86^)/^"', fzf#shellescape('C:/Program Files (x86)/', 'cmd.exe')
-  " AssertEqual '^"%%USERPROFILE%%^", fzf#shellescape('%USERPROFILE%', 'cmd.exe')
+  AssertEqual '^"%%USERPROFILE%%^"', fzf#shellescape('%USERPROFILE%', 'cmd.exe')

 Execute (Cleanup):
  unlet g:dir
--- a/test/test_go.rb
+++ b/test/test_go.rb
Author	SHA1	Message	Date
Junegunn Choi	e89eebb7ba	0.17.0	2017-08-27 03:32:21 +09:00
Junegunn Choi	fee404399a	Make --expect additive Similarly to --bind or --color. --expect used to replace the previously specified keys, and fzf#wrap({'options': '--expect=f1'}) wouldn't work as expected. It forced us to come up with some ugly hacks like the following: `13b27c45c8/autoload/fzf/vim.vim (L1086)`	2017-08-27 02:19:56 +09:00
Junegunn Choi	6b4805ca1a	Optimize rank comparison on x86 (little-endian)	2017-08-27 01:46:11 +09:00
Junegunn Choi	159699b5d7	Remove an unnecessary code branch	2017-08-26 20:09:46 +09:00
Junegunn Choi	af809c9661	Minor refactorings	2017-08-26 03:24:42 +09:00
Junegunn Choi	329de8f416	[fzf-tmux] Execute trap with bash instead of the default shell Close #1007	2017-08-26 02:51:19 +09:00
Junegunn Choi	e825b07e85	[neovim] Allow running FZF in multiple windows Close #1023	2017-08-26 01:56:49 +09:00
Junegunn Choi	71fdb99a07	Remove bound checkings in inner loops	2017-08-26 01:28:39 +09:00
Junegunn Choi	55ee4186aa	Ignore EvtReadNew if EvtReadFin is already set	2017-08-20 14:30:17 +09:00
Junegunn Choi	941b0a0ff7	Minor optimization of FuzzyMatchV2 Calculate the first row of the score matrix during phase 2	2017-08-20 12:29:11 +09:00
Junegunn Choi	6aae12288e	Extract debug code from FuzzyMatchV2	2017-08-20 12:29:11 +09:00
Junegunn Choi	302cc552ef	Remove unused clear arguments of alloc16 and alloc32	2017-08-20 12:29:11 +09:00
Junegunn Choi	a2a4df0886	Pass util.Chars by pointer	2017-08-20 12:29:11 +09:00
Jan Edmund Lazo	3399e39968	[vim] Escape backslashes in fzf#shellescape (#1021 )	2017-08-20 12:28:36 +09:00
Junegunn Choi	87874bba88	Remove redundant read event when --sync is used	2017-08-20 01:58:51 +09:00
Junegunn Choi	c304fc4333	Delay slab allocation	2017-08-19 12:14:48 +09:00
Junegunn Choi	6977cf268f	Limit search scope of uppercase letter	2017-08-18 05:30:13 +09:00
Junegunn Choi	931c78a70c	Short-circuit ANSI processing if no ANSI codes are found Rework of `656963e`. Makes --ansi processing around 20% faster on plain strings without ANSI codes.	2017-08-18 03:04:11 +09:00
Junegunn Choi	8d23646fe6	Revert "Short-circuit ANSI processing if no ANSI codes are found" This reverts commit `656963e018`.	2017-08-17 19:12:44 +09:00
Junegunn Choi	656963e018	Short-circuit ANSI processing if no ANSI codes are found	2017-08-17 19:12:06 +09:00
Junegunn Choi	644277faf1	Linuxbrew can install fzf Close #1017	2017-08-17 16:57:02 +09:00
Junegunn Choi	0558dfee79	Remove count field from ChunkList	2017-08-16 12:26:06 +09:00
Junegunn Choi	487c8fe88f	Make Reader event notification asynchronous Instead of notifying the event coordinator (EventBox) whenever a new line is arrived, start a background goroutine that periodically does the task. Atomic.StoreInt32 is much cheaper than mutex synchronization that happens during EventBox update.	2017-08-16 03:33:48 +09:00
Junegunn Choi	0d171ba1d8	Remove special nilItem	2017-08-15 01:10:41 +09:00
Junegunn Choi	2069bbc8b5	[vim] Allow Funcref in g:fzf_action https://github.com/junegunn/fzf.vim/issues/185	2017-08-14 16:23:18 +09:00
Jan Edmund Lazo	053d628b53	Add MinGW 64 to install fzf in Windows 64-bit (#1015 )	2017-08-13 23:20:06 +09:00
Junegunn Choi	6bc592e6c9	Update FuzzyMatchV1 to use skip optimization used in V2	2017-08-12 00:28:30 +09:00
Junegunn Choi	6c76d8cd1c	Disallow escaping of meta characters except for spaces https://github.com/junegunn/fzf/issues/444#issuecomment-321719604	2017-08-11 13:09:33 +09:00
Junegunn Choi	a09e411936	Treat \| as proper query when it can't be an OR operator	2017-08-11 00:07:18 +09:00
Junegunn Choi	02a7b96f33	Treat $ as proper search query When $ is the leading character in a query, it's probably not meant to be an anchor.	2017-08-10 23:59:52 +09:00
Junegunn Choi	e55e029ae8	Build cache key for a pattern only once	2017-08-10 23:18:52 +09:00
Junegunn Choi	6b18b144cf	Fix escaping of meta characters after ' or ! prefix https://github.com/junegunn/fzf/issues/444#issuecomment-321432803	2017-08-10 12:40:53 +09:00
Junegunn Choi	6d53089cc1	Allow escaping term starting with \| Close #444	2017-08-09 23:33:37 +09:00
Junegunn Choi	e85a8a68d0	Allow escaping meta characters with backslashes One can escape meta characters in extended-search mode with backslashes. Prefixes: \' \! \^ Suffix: \$ Term separator: \<SPACE> To keep things simple, we are not going to support escaping of escaped sequences (e.g. \\') for matching them literally. Since this is a breaking change, we will bump the minor version. Close #444	2017-08-09 23:28:47 +09:00
Junegunn Choi	dc55e68524	Remove unnecessary SCP (Save Cursor Position) It is reported that it can have an unwanted side effect of clearing the screen on terminal emulators that do not properly support it. Patch suggested by @arya. Close #1011	2017-08-09 01:58:29 +09:00
Junegunn Choi	462c68b625	[vim] Fix issues with other plugins changing working directory Close #1005	2017-08-09 01:54:01 +09:00
Junegunn Choi	999d374f0c	Fix invalid cache lookups	2017-08-08 13:23:33 +09:00
Junegunn Choi	b208aa675e	Update Travis build to run on Trusty	2017-08-05 04:28:43 +09:00
Junegunn Choi	2b98fee136	Fix Travis CI build tcell build is commented out as it doesn't reliably respond to tmux send-keys.	2017-08-05 04:01:17 +09:00
Junegunn Choi	e5e75efebc	[vim] Fix vader test cases	2017-08-04 19:25:06 +09:00
Junegunn Choi	4a4fef2daf	Update performance comparison chart	2017-08-04 09:28:29 +09:00
Junegunn Choi	ecb6b234cc	0.16.11	2017-08-02 02:50:28 +09:00
Junegunn Choi	39dbc8acdb	Exit 2 instead of panic when failed to open /dev/tty	2017-08-02 02:50:26 +09:00
Junegunn Choi	a56489bc7f	Remove non-exclusive access to ChunkList field	2017-08-02 00:09:00 +09:00
Junegunn Choi	99927c7071	Modify loop conditions in checkAscii function	2017-08-01 22:04:42 +09:00
Junegunn Choi	3e28403978	[man] Add note on `--no-` convention Close #1003	2017-08-01 21:34:44 +09:00
Junegunn Choi	37370f057f	Do not use defer in performance-sensitive contexts	2017-08-01 03:44:55 +09:00
Junegunn Choi	f4b46fad27	Inline function calls in a tight loop Manually inline function calls in a tight loop as Go compiler does not inline non-leaf functions. It is observed that this unpleasant code change resulted up to 10% performance improvement.	2017-08-01 03:44:38 +09:00
Junegunn Choi	9d2c6a95f4	Revert "[bash] Do not append space when path completion is cancelled" This reverts commit `376a76d1d3` as it affects normal completion	2017-07-31 14:08:17 +09:00
Junegunn Choi	376a76d1d3	[bash] Do not append space when path completion is cancelled Close #990	2017-07-30 21:51:44 +09:00
Jan Edmund Lazo	1fcc07e54e	[vim] Fix escape of backslash in s:shortpath Close #1000	2017-07-30 20:05:01 +09:00
Junegunn Choi	8db3345c2f	Optimize exact match by applying the same trick for fuzzy match	2017-07-30 18:16:54 +09:00
Junegunn Choi	69aa2fea68	Optimize fuzzy search performance for ASCII strings	2017-07-30 17:31:50 +09:00
Junegunn Choi	298749bfcd	Update README	2017-07-29 17:12:46 +09:00
Junegunn Choi	f1f31baae1	Update README: Missing TOC	2017-07-29 17:10:00 +09:00
Junegunn Choi	e1c8f19e8f	Update README: Advanced topics	2017-07-29 17:09:05 +09:00
Junegunn Choi	5e302c70e9	Update README: rg intead of pt	2017-07-29 17:09:05 +09:00
Junegunn Choi	4c5a679066	Make deselect-all instantaneous	2017-07-28 13:13:03 +09:00
Andrew Halberstadt	41f0b2c354	Add MinGW on Windows to install script (#998 ) Running uname -sm yields: MINGW32_NT-6.2 i686	2017-07-28 12:22:33 +09:00
Junegunn Choi	a0a3c349c9	Update preview window when selection has changed Close #995	2017-07-28 01:39:25 +09:00
Alexey Shamrin	bc3983181d	Update fish comments, because 2.6.0 was released (#991 )	2017-07-25 19:10:34 +09:00
Junegunn Choi	980b58ef5a	Update README Removed outdated animated GIF.	2017-07-23 22:07:24 +09:00
Junegunn Choi	a2604c0963	[nvim] Disable number in fzf buffer https://github.com/junegunn/fzf.vim/issues/396#issuecomment-317214036 One can override the setting on FileType fzf autocmd.	2017-07-23 13:12:15 +09:00
Junegunn Choi	6dbc108da2	0.16.10	2017-07-21 18:41:11 +09:00
Junegunn Choi	bd98f988f0	Further reduce unnecessary rune array conversion I was too quick to release 0.16.9, this commit makes --ansi processing even faster.	2017-07-21 17:31:11 +09:00
Junegunn Choi	06301c7847	Fix regression: ANSI color in preview window not cleared	2017-07-21 16:44:59 +09:00
Junegunn Choi	18a1aeaa91	0.16.9	2017-07-21 00:08:55 +09:00
Junegunn Choi	c9f16b6430	Avoid unconditionally storsing input as runes When --with-nth is used, fzf used to preprocess each line and store the result as rune array, which was wasteful if the line only contains ascii characters.	2017-07-20 02:44:30 +09:00
Junegunn Choi	bc9d2abdb6	Improve preview window rendering - Fix incorrect display of the last line when more than a line is wrapped above - Avoid unnecessary flickering of the window	2017-07-19 22:47:15 +09:00
Junegunn Choi	28810c178f	Optimize ANSI code scanner This change gives 5x speed improvement	2017-07-19 21:49:41 +09:00
Junegunn Choi	a9e64efe45	Fix regression: output printed on alternate screen	2017-07-19 13:17:06 +09:00
Junegunn Choi	6b5886c034	Adjust --no-clear option for repetitive relaunching Related: https://gist.github.com/junegunn/4963bab6ace453f7f529d2d0e01b1d85 Close #974	2017-07-18 21:10:49 +09:00
Junegunn Choi	7727ad43af	[vim] Use fnameescape to escape command line arguments Fix https://github.com/junegunn/fzf.vim/issues/404 Thanks to @janlazo.	2017-07-18 16:33:58 +09:00
Junegunn Choi	bbe10f4f77	Consolidate Result and rank structs By not storing item index twice, we can cut down the size of Result struct and now it makes more sense to store and pass Results by values. Benchmarks show no degradation of performance by additional pointer indirection for looking up index.	2017-07-18 03:14:33 +09:00
Junegunn Choi	5e72709613	Speed up initial scanning with bitwise AND operation	2017-07-18 02:17:05 +09:00
Junegunn Choi	9e85cba0d0	Reduce memory footprint of Item struct	2017-07-16 23:34:32 +09:00
Junegunn Choi	4b59ced08f	Add gopath to gitignore	2017-07-16 23:34:32 +09:00
Junegunn Choi	8dbdd55730	Refactor cache lookup - Remove multiple mutex locks in partial cache lookup - Simplify return values	2017-07-16 23:34:32 +09:00
Junegunn Choi	6725151a99	Remove unnecessary copy of Chunk slice	2017-07-16 23:34:32 +09:00
Junegunn Choi	d4f3d5a164	Remove pointer indirection by changing Chunk definition	2017-07-16 23:34:32 +09:00
Tom Fitzhenry	7b5ccc45bc	[fish] Fix ctrl-r regression in versions <2.4 (#972 ) Close #966	2017-07-15 18:50:23 +09:00
Jan Edmund Lazo	940214a1a2	[neovim] Fix lcd when fzf job exits on Windows (#970 ) Related: #960 (relative filepaths)	2017-07-10 02:06:13 +09:00
Jan Edmund Lazo	68bd410159	[vim] Don't pipe FZF_DEFAULT_COMMAND in Windows (#969 ) Related #960, #552	2017-07-09 13:08:16 +09:00
Junegunn Choi	b13fcfd831	Add missing --no-expect flag	2017-07-04 23:02:15 +09:00
Junegunn Choi	07ef2b051c	Print [ERROR] on info line when the default command failed With zero result. Related: https://github.com/junegunn/fzf.vim/issues/22#issuecomment-311869805	2017-07-01 01:13:15 +09:00
Junegunn Choi	3fc795340d	Fix test failulre with non-zero pane-base-index	2017-07-01 01:05:47 +09:00
John Nguyen	70cfa6af13	[fish] Accept starting dir for <M-c> key binding (#944 ) This also modifies <C-t> behaviour. The longest file path in the input is used as root directory for `find` command. The remainder of the input is passed to fzf's --query as a initial search parameters.	2017-06-25 21:16:15 +09:00
Tom Fitzhenry	dbcaec59ae	[fish] Support multiline commands (#954 ) Fix found by @amosbird at https://github.com/junegunn/fzf/issues/953#issuecomment-310309055 closes #440	2017-06-25 21:09:51 +09:00
Junegunn Choi	faedae708e	Fix FZF_CTRL_T_COMMAND example for fish See #944	2017-06-23 01:50:45 +09:00
Junegunn Choi	0c66521b23	Fix handling of bracketed paste mode fzf should immediately continue consuming the buffer after discarding bracketed paste mode sequence. Close #951	2017-06-22 02:35:57 +09:00
Junegunn Choi	bf92862459	Update man page: missing name "border" for --color	2017-06-20 14:15:11 +09:00
John Nguyen	1a68698d76	[fish] Fix <C-t> completion for current dir search (#946 ) If "." is given as the argument to begin <C-t> completion, the leading "." is not correctly removed. In general, if user selects a fzf completion, the current token should be "consumed".	2017-06-12 18:24:45 +09:00
Junegunn Choi	842a73357c	[fish] Fix CTRL-T with paths that don't start with ./ Close #943	2017-06-10 13:35:24 +09:00
Junegunn Choi	5efdeccdbb	[vim] Expand 'dir' on Cygwin to handle Windows-style paths See https://github.com/junegunn/fzf/pull/933#discussion_r120011934 Close https://github.com/junegunn/fzf.vim/pull/386	2017-06-09 12:00:59 +09:00
Jan Edmund Lazo	050777b8c4	[vim] Uncomment test case to escape % in cmd.exe (#941 )	2017-06-08 10:25:35 +09:00
Uri Gorelik	a4d78e2200	Update CHANGELOG with unix-line-discard+top (#940 ) Also change the example binding for `unix-word-rubout` to ctrl-w instead of ctrl-u	2017-06-08 10:02:34 +09:00