0.29.0

Fix #2692

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: ["https://paypal.me/junegunn", "https://www.buymeacoffee.com/junegunn"]

.github/ISSUE_TEMPLATE.md

@@ -1,12 +1,13 @@
+<!-- ISSUES NOT FOLLOWING THIS TEMPLATE WILL BE CLOSED AND DELETED -->
+
 <!-- Check all that apply [x] -->
-- Category
+
-    - [ ] fzf binary
+- [ ] I have read through the manual page (`man fzf`)
-    - [ ] fzf-tmux script
+- [ ] I have the latest version of fzf
-    - [ ] Key bindings
+- [ ] I have searched through the existing issues
-    - [ ] Completion
+
-    - [ ] Vim
+## Info
-    - [ ] Neovim
+
-    - [ ] Etc.
 - OS
     - [ ] Linux
     - [ ] Mac OS X
@@ -17,13 +18,5 @@
     - [ ] zsh
     - [ ] fish
 
-<!--
+## Problem / Steps to reproduce
-### Before submitting
-
-- Make sure that you have the latest version of fzf
-- If you use tmux, make sure $TERM is set to screen or screen-256color
-- For more Vim stuff, check out https://github.com/junegunn/fzf.vim
-
-Describe your problem or suggestion from here ...
--->
 

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "gomod"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,37 @@
+# https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning
+name: CodeQL
+
+on:
+  push:
+    branches: [ master, devel ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ['go']
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/linux.yml

@@ -0,0 +1,45 @@
+---
+name: Test fzf on Linux
+
+on:
+  push:
+    branches: [ master, devel ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go: [1.14, 1.16]
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+
+    - name: Set up Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: ${{ matrix.go }}
+
+    - name: Setup Ruby
+      uses: ruby/setup-ruby@v1.62.0
+      with:
+        ruby-version: 3.0.0
+
+    - name: Install packages
+      run: sudo apt-get install --yes zsh fish tmux
+
+    - name: Install Ruby gems
+      run: sudo gem install --no-document minitest:5.14.2 rubocop:1.0.0 rubocop-minitest:0.10.1 rubocop-performance:1.8.1
+
+    - name: Rubocop
+      run: rubocop --require rubocop-minitest --require rubocop-performance
+
+    - name: Unit test
+      run: make test
+
+    - name: Integration test
+      run: make install && ./install --all && LC_ALL=C tmux new-session -d && ruby test/test_go.rb --verbose

.github/workflows/macos.yml

@@ -0,0 +1,45 @@
+---
+name: Test fzf on macOS
+
+on:
+  push:
+    branches: [ master, devel ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        go: [1.14, 1.16]
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+
+    - name: Set up Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: ${{ matrix.go }}
+
+    - name: Setup Ruby
+      uses: ruby/setup-ruby@v1.62.0
+      with:
+        ruby-version: 3.0.0
+
+    - name: Install packages
+      run: HOMEBREW_NO_INSTALL_CLEANUP=1 brew install fish zsh tmux
+
+    - name: Install Ruby gems
+      run: gem install --no-document minitest:5.14.2 rubocop:1.0.0 rubocop-minitest:0.10.1 rubocop-performance:1.8.1
+
+    - name: Rubocop
+      run: rubocop --require rubocop-minitest --require rubocop-performance
+
+    - name: Unit test
+      run: make test
+
+    - name: Integration test
+      run: make install && ./install --all && LC_ALL=C tmux new-session -d && ruby test/test_go.rb --verbose

.gitignore

@@ -1,6 +1,14 @@
-bin
+bin/fzf
-src/fzf/fzf-*
+bin/fzf.exe
-gopath
+dist
+target
 pkg
 Gemfile.lock
 .DS_Store
+doc/tags
+vendor
+gopath
+*.zwc
+fzf
+tmp
+*.patch

.goreleaser.yml

@@ -0,0 +1,119 @@
+---
+project_name: fzf
+
+before:
+  hooks:
+    - go mod download
+
+builds:
+  - id: fzf-macos
+    binary: fzf
+    goos:
+      - darwin
+    goarch:
+      - amd64
+    ldflags:
+      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
+    hooks:
+      post: |
+        sh -c '
+        cat > /tmp/fzf-gon-amd64.hcl << EOF
+        source = ["./dist/fzf-macos_darwin_amd64/fzf"]
+        bundle_id = "kr.junegunn.fzf"
+        apple_id {
+          username = "junegunn.c@gmail.com"
+          password = "@env:AC_PASSWORD"
+        }
+        sign {
+          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
+        }
+        zip {
+          output_path = "./dist/fzf-{{ .Version }}-darwin_amd64.zip"
+        }
+        EOF
+        gon /tmp/fzf-gon-amd64.hcl
+        '
+
+  - id: fzf-macos-arm
+    binary: fzf
+    goos:
+      - darwin
+    goarch:
+      - arm64
+    ldflags:
+      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
+    hooks:
+      post: |
+        sh -c '
+        cat > /tmp/fzf-gon-arm64.hcl << EOF
+        source = ["./dist/fzf-macos-arm_darwin_arm64/fzf"]
+        bundle_id = "kr.junegunn.fzf"
+        apple_id {
+          username = "junegunn.c@gmail.com"
+          password = "@env:AC_PASSWORD"
+        }
+        sign {
+          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
+        }
+        zip {
+          output_path = "./dist/fzf-{{ .Version }}-darwin_arm64.zip"
+        }
+        EOF
+        gon /tmp/fzf-gon-arm64.hcl
+        '
+
+  - id: fzf
+    goos:
+      - linux
+      - windows
+      - freebsd
+      - openbsd
+    goarch:
+      - amd64
+      - arm
+      - arm64
+    goarm:
+      - 5
+      - 6
+      - 7
+    ldflags:
+      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
+    ignore:
+      - goos: freebsd
+        goarch: arm
+      - goos: openbsd
+        goarch: arm
+      - goos: freebsd
+        goarch: arm64
+      - goos: openbsd
+        goarch: arm64
+
+archives:
+  - name_template: "{{ .ProjectName }}-{{ .Version }}-{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
+    builds:
+      - fzf
+    format: tar.gz
+    format_overrides:
+      - goos: windows
+        format: zip
+    files:
+      - non-existent*
+
+release:
+  github:
+    owner: junegunn
+    name: fzf
+  prerelease: auto
+  name_template: '{{ .Tag }}'
+  extra_files:
+    - glob: ./dist/fzf-*darwin*.zip
+
+snapshot:
+  name_template: "{{ .Tag }}-devel"
+
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - README
+      - test

.rubocop.yml

@@ -0,0 +1,28 @@
+Layout/LineLength:
+  Enabled: false
+Metrics:
+  Enabled: false
+Lint/ShadowingOuterLocalVariable:
+  Enabled: false
+Style/MethodCallWithArgsParentheses:
+  Enabled: true
+  IgnoredMethods:
+    - assert
+    - exit
+    - paste
+    - puts
+    - raise
+    - refute
+    - require
+    - send_keys
+  IgnoredPatterns:
+    - ^assert_
+    - ^refute_
+Style/NumericPredicate:
+  Enabled: false
+Style/StringConcatenation:
+  Enabled: false
+Style/OptionalBooleanParameter:
+  Enabled: false
+Style/WordArray:
+  MinSize: 1

.travis.yml

@@ -1,24 +0,0 @@
-language: ruby
-rvm:
-- 2.2.0
-
-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
-
-script: |
-  export GOPATH=~/go
-  export FZF_BASE=$GOPATH/src/github.com/junegunn/fzf
-
-  mkdir -p $GOPATH/src/github.com/junegunn
-  ln -s $(pwd) $FZF_BASE
-
-  cd $FZF_BASE/src && make test fzf/fzf-linux_amd64 install &&
-  cd $FZF_BASE/bin && ln -sf fzf-linux_amd64 fzf-$(./fzf --version)-linux_amd64 &&
-  cd $FZF_BASE && yes | ./install && rm -f fzf &&
-  tmux new "ruby test/test_go.rb > out && touch ok" && cat out && [ -e ok ]

ADVANCED.md

@@ -0,0 +1,569 @@
+Advanced fzf examples
+======================
+
+*(Last update: 2021/05/22)*
+
+<!-- vim-markdown-toc GFM -->
+
+* [Introduction](#introduction)
+* [Screen Layout](#screen-layout)
+  * [`--height`](#--height)
+  * [`fzf-tmux`](#fzf-tmux)
+    * [Popup window support](#popup-window-support)
+* [Dynamic reloading of the list](#dynamic-reloading-of-the-list)
+  * [Updating the list of processes by pressing CTRL-R](#updating-the-list-of-processes-by-pressing-ctrl-r)
+  * [Toggling between data sources](#toggling-between-data-sources)
+* [Ripgrep integration](#ripgrep-integration)
+  * [Using fzf as the secondary filter](#using-fzf-as-the-secondary-filter)
+  * [Using fzf as interative Ripgrep launcher](#using-fzf-as-interative-ripgrep-launcher)
+  * [Switching to fzf-only search mode](#switching-to-fzf-only-search-mode)
+* [Log tailing](#log-tailing)
+* [Key bindings for git objects](#key-bindings-for-git-objects)
+  * [Files listed in `git status`](#files-listed-in-git-status)
+  * [Branches](#branches)
+  * [Commit hashes](#commit-hashes)
+* [Color themes](#color-themes)
+  * [Generating fzf color theme from Vim color schemes](#generating-fzf-color-theme-from-vim-color-schemes)
+
+<!-- vim-markdown-toc -->
+
+Introduction
+------------
+
+fzf is an interactive [Unix filter][filter] program that is designed to be
+used with other Unix tools. It reads a list of items from the standard input,
+allows you to select a subset of the items, and prints the selected ones to
+the standard output. You can think of it as an interactive version of *grep*,
+and it's already useful even if you don't know any of its options.
+
+```sh
+# 1. ps:   Feed the list of processes to fzf
+# 2. fzf:  Interactively select a process using fuzzy matching algorithm
+# 3. awk:  Take the PID from the selected line
+# 3. kill: Kill the process with the PID
+ps -ef | fzf | awk '{print $2}' | xargs kill -9
+```
+
+[filter]: https://en.wikipedia.org/wiki/Filter_(software)
+
+While the above example succinctly summarizes the fundamental concept of fzf,
+you can build much more sophisticated interactive workflows using fzf once you
+learn its wide variety of features.
+
+- To see the full list of options and features, see `man fzf`
+- To see the latest additions, see [CHANGELOG.md](CHANGELOG.md)
+
+This document will guide you through some examples that will familiarize you
+with the advanced features of fzf.
+
+Screen Layout
+-------------
+
+### `--height`
+
+fzf by default opens in fullscreen mode, but it's not always desirable.
+Oftentimes, you want to see the current context of the terminal while using
+fzf. `--height` is an option for opening fzf below the cursor in
+non-fullscreen mode so you can still see the previous commands and their
+results above it.
+
+```sh
+fzf --height=40%
+```
+
+![image](https://user-images.githubusercontent.com/700826/113379893-c184c680-93b5-11eb-9676-c7c0a2f01748.png)
+
+You might also want to experiment with other layout options such as
+`--layout=reverse`, `--info=inline`, `--border`, `--margin`, etc.
+
+```sh
+fzf --height=40% --layout=reverse
+fzf --height=40% --layout=reverse --info=inline
+fzf --height=40% --layout=reverse --info=inline --border
+fzf --height=40% --layout=reverse --info=inline --border --margin=1
+fzf --height=40% --layout=reverse --info=inline --border --margin=1 --padding=1
+```
+
+![image](https://user-images.githubusercontent.com/700826/113379932-dfeac200-93b5-11eb-9e28-df1a2ee71f90.png)
+
+*(See `Layout` section of the man page to see the full list of options)*
+
+But you definitely don't want to repeat `--height=40% --layout=reverse
+--info=inline --border --margin=1 --padding=1` every time you use fzf. You
+could write a wrapper script or shell alias, but there is an easier option.
+Define `$FZF_DEFAULT_OPTS` like so:
+
+```sh
+export FZF_DEFAULT_OPTS="--height=40% --layout=reverse --info=inline --border --margin=1 --padding=1"
+```
+
+### `fzf-tmux`
+
+Before fzf had `--height` option, we would open fzf in a tmux split pane not
+to take up the whole screen. This is done using `fzf-tmux` script.
+
+```sh
+# Open fzf on a tmux split pane below the current pane.
+# Takes the same set of options.
+fzf-tmux --layout=reverse
+```
+
+![image](https://user-images.githubusercontent.com/700826/113379973-f1cc6500-93b5-11eb-8860-c9bc4498aadf.png)
+
+The limitation of `fzf-tmux` is that it only works when you're on tmux unlike
+`--height` option. But the advantage of it is that it's more flexible.
+(See `man fzf-tmux` for available options.)
+
+```sh
+# On the right (50%)
+fzf-tmux -r
+
+# On the left (30%)
+fzf-tmux -l30%
+
+# Above the cursor
+fzf-tmux -u30%
+```
+
+![image](https://user-images.githubusercontent.com/700826/113379983-fa24a000-93b5-11eb-93eb-8a3d39b2f163.png)
+
+![image](https://user-images.githubusercontent.com/700826/113380001-0577cb80-93b6-11eb-95d0-2ba453866882.png)
+
+![image](https://user-images.githubusercontent.com/700826/113380040-1d4f4f80-93b6-11eb-9bef-737fb120aafe.png)
+
+#### Popup window support
+
+But here's the really cool part; tmux 3.2 added support for popup windows. So
+you can open fzf in a popup window, which is quite useful if you frequently
+use split panes.
+
+```sh
+# Open tmux in a tmux popup window (default size: 50% of the screen)
+fzf-tmux -p
+
+# 80% width, 60% height
+fzf-tmux -p 80%,60%
+```
+
+![image](https://user-images.githubusercontent.com/700826/113380106-4a9bfd80-93b6-11eb-8cee-aeb1c4ce1a1f.png)
+
+> You might also want to check out my tmux plugins which support this popup
+> window layout.
+>
+> - https://github.com/junegunn/tmux-fzf-url
+> - https://github.com/junegunn/tmux-fzf-maccy
+
+Dynamic reloading of the list
+-----------------------------
+
+fzf can dynamically update the candidate list using an arbitrary program with
+`reload` bindings (The design document for `reload` can be found
+[here][reload]).
+
+[reload]: https://github.com/junegunn/fzf/issues/1750
+
+### Updating the list of processes by pressing CTRL-R
+
+This example shows how you can set up a binding for dynamically updating the
+list without restarting fzf.
+
+```sh
+(date; ps -ef) |
+  fzf --bind='ctrl-r:reload(date; ps -ef)' \
+      --header=$'Press CTRL-R to reload\n\n' --header-lines=2 \
+      --preview='echo {}' --preview-window=down,3,wrap \
+      --layout=reverse --height=80% | awk '{print $2}' | xargs kill -9
+```
+
+![image](https://user-images.githubusercontent.com/700826/113465047-200c7c00-946c-11eb-918c-268f37a900c8.png)
+
+- The initial command is `(date; ps -ef)`. It prints the current date and
+  time, and the list of the processes.
+- With `--header` option, you can show any message as the fixed header.
+- To disallow selecting the first two lines (`date` and `ps` header), we use
+  `--header-lines=2` option.
+- `--bind='ctrl-r:reload(date; ps -ef)'` binds CTRL-R to `reload` action that
+  runs `date; ps -ef`, so we can update the list of the processes by pressing
+  CTRL-R.
+- We use simple `echo {}` preview option, so we can see the entire line on the
+  preview window below even if it's too long
+
+### Toggling between data sources
+
+You're not limited to just one reload binding. Set up multiple bindings so
+you can switch between data sources.
+
+```sh
+find * | fzf --prompt 'All> ' \
+             --header 'CTRL-D: Directories / CTRL-F: Files' \
+             --bind 'ctrl-d:change-prompt(Directories> )+reload(find * -type d)' \
+             --bind 'ctrl-f:change-prompt(Files> )+reload(find * -type f)'
+```
+
+![image](https://user-images.githubusercontent.com/700826/113465073-4af6d000-946c-11eb-858f-2372c0955f67.png)
+
+![image](https://user-images.githubusercontent.com/700826/113465072-46321c00-946c-11eb-9b6f-cda3951df579.png)
+
+Ripgrep integration
+-------------------
+
+### Using fzf as the secondary filter
+
+* Requires [bat][bat]
+* Requires [Ripgrep][rg]
+
+[bat]: https://github.com/sharkdp/bat
+[rg]: https://github.com/BurntSushi/ripgrep
+
+fzf is pretty fast for filtering a list that you will rarely have to think
+about its performance. But it is not the right tool for searching for text
+inside many large files, and in that case you should definitely use something
+like [Ripgrep][rg].
+
+In the next example, Ripgrep is the primary filter that searches for the given
+text in files, and fzf is used as the secondary fuzzy filter that adds
+interactivity to the workflow. And we use [bat][bat] to show the matching line in
+the preview window.
+
+This is a bash script and it will not run as expected on other non-compliant
+shells. To avoid the compatibility issue, let's save this snippet as a script
+file called `rfv`.
+
+```bash
+#!/usr/bin/env bash
+
+# 1. Search for text in files using Ripgrep
+# 2. Interactively narrow down the list using fzf
+# 3. Open the file in Vim
+IFS=: read -ra selected < <(
+  rg --color=always --line-number --no-heading --smart-case "${*:-}" |
+    fzf --ansi \
+        --color "hl:-1:underline,hl+:-1:underline:reverse" \
+        --delimiter : \
+        --preview 'bat --color=always {1} --highlight-line {2}' \
+        --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
+)
+[ -n "${selected[0]}" ] && vim "${selected[0]}" "+${selected[1]}"
+```
+
+And run it with an initial query string.
+
+```sh
+# Make the script executable
+chmod +x rfv
+
+# Run it with the initial query "algo"
+./rfv algo
+```
+
+> Ripgrep will perform the initial search and list all the lines that contain
+`algo`. Then we further narrow down the list on fzf.
+
+![image](https://user-images.githubusercontent.com/700826/113683873-a42a6200-96ff-11eb-9666-26ce4091b0e4.png)
+
+I know it's a lot to digest, let's try to break down the code.
+
+- Ripgrep prints the matching lines in the following format
+  ```
+  man/man1/fzf.1:54:.BI "--algo=" TYPE
+  man/man1/fzf.1:55:Fuzzy matching algorithm (default: v2)
+  man/man1/fzf.1:58:.BR v2 "     Optimal scoring algorithm (quality)"
+  src/pattern_test.go:7:  "github.com/junegunn/fzf/src/algo"
+  ```
+  The first token delimited by `:` is the file path, and the second token is
+  the line number of the matching line. They respectively correspond to `{1}`
+  and `{2}` in the preview command.
+    - `--preview 'bat --color=always {1} --highlight-line {2}'`
+- As we run `rg` with `--color=always` option, we should tell fzf to parse
+  ANSI color codes in the input by setting `--ansi`.
+- We customize how fzf colors various text elements using `--color` option.
+  `-1` tells fzf to keep the original color from the input. See `man fzf` for
+  available color options.
+- The value of `--preview-window` option consists of 5 components delimited
+  by `,`
+    1. `up` — Position of the preview window
+    1. `60%` — Size of the preview window
+    1. `border-bottom` — Preview window border only on the bottom side
+    1. `+{2}+3/3` — Scroll offset of the preview contents
+    1. `~3` — Fixed header
+- Let's break down the latter two. We want to display the bat output in the
+  preview window with a certain scroll offset so that the matching line is
+  positioned near the center of the preview window.
+    - `+{2}` — The base offset is extracted from the second token
+    - `+3` — We add 3 lines to the base offset to compensate for the header
+      part of `bat` output
+        - ```
+          ───────┬──────────────────────────────────────────────────────────
+                 │ File: CHANGELOG.md
+          ───────┼──────────────────────────────────────────────────────────
+             1   │ CHANGELOG
+             2   │ =========
+             3   │
+             4   │ 0.26.0
+             5   │ ------
+          ```
+    - `/3` adjusts the offset so that the matching line is shown at a third
+      position in the window
+    - `~3` makes the top three lines fixed header so that they are always
+      visible regardless of the scroll offset
+- Once we selected a line, we open the file with `vim` (`vim
+  "${selected[0]}"`) and move the cursor to the line (`+${selected[1]}`).
+
+### Using fzf as interative Ripgrep launcher
+
+We have learned that we can bind `reload` action to a key (e.g.
+`--bind=ctrl-r:execute(ps -ef)`). In the next example, we are going to **bind
+`reload` action to `change` event** so that whenever the user *changes* the
+query string on fzf, `reload` action is triggered.
+
+Here is a variation of the above `rfv` script. fzf will restart Ripgrep every
+time the user updates the query string on fzf. Searching and filtering is
+completely done by Ripgrep, and fzf merely provides the interactive interface.
+So we lose the "fuzziness", but the performance will be better on larger
+projects, and it will free up memory as you narrow down the results.
+
+```bash
+#!/usr/bin/env bash
+
+# 1. Search for text in files using Ripgrep
+# 2. Interactively restart Ripgrep with reload action
+# 3. Open the file in Vim
+RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+INITIAL_QUERY="${*:-}"
+IFS=: read -ra selected < <(
+  FZF_DEFAULT_COMMAND="$RG_PREFIX $(printf %q "$INITIAL_QUERY")" \
+  fzf --ansi \
+      --disabled --query "$INITIAL_QUERY" \
+      --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
+      --delimiter : \
+      --preview 'bat --color=always {1} --highlight-line {2}' \
+      --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
+)
+[ -n "${selected[0]}" ] && vim "${selected[0]}" "+${selected[1]}"
+```
+
+![image](https://user-images.githubusercontent.com/700826/113684212-f9ff0a00-96ff-11eb-8737-7bb571d320cc.png)
+
+- Instead of starting fzf in `rg ... | fzf` form, we start fzf without an
+  explicit input, but with a custom `FZF_DEFAULT_COMMAND` variable. This way
+  fzf can kill the initial Ripgrep process it starts with the initial query.
+  Otherwise, the initial Ripgrep process will keep consuming system resources
+  even after `reload` is triggered.
+- Filtering is no longer a responsibility of fzf; hence `--disabled`
+- `{q}` in the reload command evaluates to the query string on fzf prompt.
+- `sleep 0.1` in the reload command is for "debouncing". This small delay will
+  reduce the number of intermediate Ripgrep processes while we're typing in
+  a query.
+
+### Switching to fzf-only search mode
+
+*(Requires fzf 0.27.1 or above)*
+
+In the previous example, we lost fuzzy matching capability as we completely
+delegated search functionality to Ripgrep. But we can dynamically switch to
+fzf-only search mode by *"unbinding"* `reload` action from `change` event.
+
+```sh
+#!/usr/bin/env bash
+
+# Two-phase filtering with Ripgrep and fzf
+#
+# 1. Search for text in files using Ripgrep
+# 2. Interactively restart Ripgrep with reload action
+#    * Press alt-enter to switch to fzf-only filtering
+# 3. Open the file in Vim
+RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+INITIAL_QUERY="${*:-}"
+IFS=: read -ra selected < <(
+  FZF_DEFAULT_COMMAND="$RG_PREFIX $(printf %q "$INITIAL_QUERY")" \
+  fzf --ansi \
+      --color "hl:-1:underline,hl+:-1:underline:reverse" \
+      --disabled --query "$INITIAL_QUERY" \
+      --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
+      --bind "alt-enter:unbind(change,alt-enter)+change-prompt(2. fzf> )+enable-search+clear-query" \
+      --prompt '1. ripgrep> ' \
+      --delimiter : \
+      --preview 'bat --color=always {1} --highlight-line {2}' \
+      --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
+)
+[ -n "${selected[0]}" ] && vim "${selected[0]}" "+${selected[1]}"
+```
+
+* Phase 1. Filtering with Ripgrep
+![image](https://user-images.githubusercontent.com/700826/119213880-735e8a80-bafd-11eb-8493-123e4be24fbc.png)
+* Phase 2. Filtering with fzf
+![image](https://user-images.githubusercontent.com/700826/119213887-7e191f80-bafd-11eb-98c9-71a1af9d7aab.png)
+
+- We added `--prompt` option to show that fzf is initially running in "Ripgrep
+  launcher mode".
+- We added `alt-enter` binding that
+    1. unbinds `change` event, so Ripgrep is no longer restarted on key press
+    2. changes the prompt to `2. fzf>`
+    3. enables search functionality of fzf
+    4. clears the current query string that was used to start Ripgrep process
+    5. and unbinds `alt-enter` itself as this is a one-off event
+- We reverted `--color` option for customizing how the matching chunks are
+  displayed in the second phase
+
+Log tailing
+-----------
+
+fzf can run long-running preview commands and render partial results before
+completion. And when you specify `follow` flag in `--preview-window` option,
+fzf will "`tail -f`" the result, automatically scrolling to the bottom.
+
+```bash
+# With "follow", preview window will automatically scroll to the bottom.
+# "\033[2J" is an ANSI escape sequence for clearing the screen.
+# When fzf reads this code it clears the previous preview contents.
+fzf --preview-window follow --preview 'for i in $(seq 100000); do
+  echo "$i"
+  sleep 0.01
+  (( i % 300 == 0 )) && printf "\033[2J"
+done'
+```
+
+![image](https://user-images.githubusercontent.com/700826/113473303-dd669600-94a3-11eb-88a9-1f61b996bb0e.png)
+
+Admittedly, that was a silly example. Here's a practical one for browsing
+Kubernetes pods.
+
+```bash
+pods() {
+  FZF_DEFAULT_COMMAND="kubectl get pods --all-namespaces" \
+    fzf --info=inline --layout=reverse --header-lines=1 \
+        --prompt "$(kubectl config current-context | sed 's/-context$//')> " \
+        --header $'╱ Enter (kubectl exec) ╱ CTRL-O (open log in editor) ╱ CTRL-R (reload) ╱\n\n' \
+        --bind 'ctrl-/:change-preview-window(80%,border-bottom|hidden|)' \
+        --bind 'enter:execute:kubectl exec -it --namespace {1} {2} -- bash > /dev/tty' \
+        --bind 'ctrl-o:execute:${EDITOR:-vim} <(kubectl logs --all-containers --namespace {1} {2}) > /dev/tty' \
+        --bind 'ctrl-r:reload:$FZF_DEFAULT_COMMAND' \
+        --preview-window up:follow \
+        --preview 'kubectl logs --follow --all-containers --tail=10000 --namespace {1} {2}' "$@"
+}
+```
+
+![image](https://user-images.githubusercontent.com/700826/113473547-1d7a4880-94a5-11eb-98ef-9aa6f0ed215a.png)
+
+- The preview window will *"log tail"* the pod
+    - Holding on to a large amount of log will consume a lot of memory. So we
+      limited the initial log amount with `--tail=10000`.
+- `execute` bindings allow you to run any command without leaving fzf
+    - Press enter key on a pod to `kubectl exec` into it
+    - Press CTRL-O to open the log in your editor
+- Press CTRL-R to reload the pod list
+- Press CTRL-/ repeatedly to to rotate through a different sets of preview
+  window options
+    1. `80%,border-bottom`
+    1. `hidden`
+    1. Empty string after `|` translates to the default options from `--preview-window`
+
+Key bindings for git objects
+----------------------------
+
+I have [blogged](https://junegunn.kr/2016/07/fzf-git) about my fzf+git key
+bindings a few years ago. I'm going to show them here again, because they are
+seriously useful.
+
+### Files listed in `git status`
+
+<kbd>CTRL-G</kbd><kbd>CTRL-F</kbd>
+
+![image](https://user-images.githubusercontent.com/700826/113473779-a9d93b00-94a6-11eb-87b5-f62a8d0a0efc.png)
+
+### Branches
+
+<kbd>CTRL-G</kbd><kbd>CTRL-B</kbd>
+
+![image](https://user-images.githubusercontent.com/700826/113473758-87dfb880-94a6-11eb-82f4-9218103f10bd.png)
+
+### Commit hashes
+
+<kbd>CTRL-G</kbd><kbd>CTRL-H</kbd>
+
+![image](https://user-images.githubusercontent.com/700826/113473765-91692080-94a6-11eb-8d38-ed4d41f27ac1.png)
+
+
+The full source code can be found [here](https://gist.github.com/junegunn/8b572b8d4b5eddd8b85e5f4d40f17236).
+
+Color themes
+------------
+
+You can customize how fzf colors the text elements with `--color` option. Here
+are a few color themes. Note that you need a terminal emulator that can
+display 24-bit colors.
+
+```sh
+# junegunn/seoul256.vim (dark)
+export FZF_DEFAULT_OPTS='--color=bg+:#3F3F3F,bg:#4B4B4B,border:#6B6B6B,spinner:#98BC99,hl:#719872,fg:#D9D9D9,header:#719872,info:#BDBB72,pointer:#E12672,marker:#E17899,fg+:#D9D9D9,preview-bg:#3F3F3F,prompt:#98BEDE,hl+:#98BC99'
+```
+
+![seoul256](https://user-images.githubusercontent.com/700826/113475011-2c192d80-94ae-11eb-9d17-1e5867bae01f.png)
+
+```sh
+# junegunn/seoul256.vim (light)
+export FZF_DEFAULT_OPTS='--color=bg+:#D9D9D9,bg:#E1E1E1,border:#C8C8C8,spinner:#719899,hl:#719872,fg:#616161,header:#719872,info:#727100,pointer:#E12672,marker:#E17899,fg+:#616161,preview-bg:#D9D9D9,prompt:#0099BD,hl+:#719899'
+```
+
+![seoul256-light](https://user-images.githubusercontent.com/700826/113475022-389d8600-94ae-11eb-905f-0939dd535837.png)
+
+```sh
+# morhetz/gruvbox
+export FZF_DEFAULT_OPTS='--color=bg+:#3c3836,bg:#32302f,spinner:#fb4934,hl:#928374,fg:#ebdbb2,header:#928374,info:#8ec07c,pointer:#fb4934,marker:#fb4934,fg+:#ebdbb2,prompt:#fb4934,hl+:#fb4934'
+```
+
+![gruvbox](https://user-images.githubusercontent.com/700826/113475042-494dfc00-94ae-11eb-9322-cd03a027305a.png)
+
+```sh
+# arcticicestudio/nord-vim
+export FZF_DEFAULT_OPTS='--color=bg+:#3B4252,bg:#2E3440,spinner:#81A1C1,hl:#616E88,fg:#D8DEE9,header:#616E88,info:#81A1C1,pointer:#81A1C1,marker:#81A1C1,fg+:#D8DEE9,prompt:#81A1C1,hl+:#81A1C1'
+```
+
+![nord](https://user-images.githubusercontent.com/700826/113475063-67b3f780-94ae-11eb-9b24-5f0d22b63399.png)
+
+```sh
+# tomasr/molokai
+export FZF_DEFAULT_OPTS='--color=bg+:#293739,bg:#1B1D1E,border:#808080,spinner:#E6DB74,hl:#7E8E91,fg:#F8F8F2,header:#7E8E91,info:#A6E22E,pointer:#A6E22E,marker:#F92672,fg+:#F8F8F2,prompt:#F92672,hl+:#F92672'
+```
+
+![molokai](https://user-images.githubusercontent.com/700826/113475085-8619f300-94ae-11eb-85e4-2766fc3246bf.png)
+
+### Generating fzf color theme from Vim color schemes
+
+The Vim plugin of fzf can generate `--color` option from the current color
+scheme according to `g:fzf_colors` variable. You can find the detailed
+explanation [here](https://github.com/junegunn/fzf/blob/master/README-VIM.md#explanation-of-gfzf_colors).
+
+Here is an example. Add this to your Vim configuration file.
+
+```vim
+let g:fzf_colors =
+\ { 'fg':         ['fg', 'Normal'],
+  \ 'bg':         ['bg', 'Normal'],
+  \ 'preview-bg': ['bg', 'NormalFloat'],
+  \ 'hl':         ['fg', 'Comment'],
+  \ 'fg+':        ['fg', 'CursorLine', 'CursorColumn', 'Normal'],
+  \ 'bg+':        ['bg', 'CursorLine', 'CursorColumn'],
+  \ 'hl+':        ['fg', 'Statement'],
+  \ 'info':       ['fg', 'PreProc'],
+  \ 'border':     ['fg', 'Ignore'],
+  \ 'prompt':     ['fg', 'Conditional'],
+  \ 'pointer':    ['fg', 'Exception'],
+  \ 'marker':     ['fg', 'Keyword'],
+  \ 'spinner':    ['fg', 'Label'],
+  \ 'header':     ['fg', 'Comment'] }
+```
+
+Then you can see how the `--color` option is generated by printing the result
+of `fzf#wrap()`.
+
+```vim
+:echo fzf#wrap()
+```
+
+Use this command to append `export FZF_DEFAULT_OPTS="..."` line to the end of
+the current file.
+
+```vim
+:call append('$', printf('export FZF_DEFAULT_OPTS="%s"', matchstr(fzf#wrap().options, "--color[^']*")))
+```

BUILD.md

@@ -0,0 +1,49 @@
+Building fzf
+============
+
+Build instructions
+------------------
+
+### Prerequisites
+
+- Go 1.13 or above
+
+### Using Makefile
+
+```sh
+# Build fzf binary for your platform in target
+make
+
+# Build fzf binary and copy it to bin directory
+make install
+
+# Build fzf binaries and archives for all platforms using goreleaser
+make build
+
+# Publish GitHub release
+make release
+```
+
+> :warning: Makefile uses git commands to determine the version and the
+> revision information for `fzf --version`. So if you're building fzf from an
+> environment where its git information is not available, you have to manually
+> set `$FZF_VERSION` and `$FZF_REVISION`.
+>
+> e.g. `FZF_VERSION=0.24.0 FZF_REVISION=tarball make`
+
+Third-party libraries used
+--------------------------
+
+- [mattn/go-runewidth](https://github.com/mattn/go-runewidth)
+    - Licensed under [MIT](http://mattn.mit-license.org)
+- [mattn/go-shellwords](https://github.com/mattn/go-shellwords)
+    - Licensed under [MIT](http://mattn.mit-license.org)
+- [mattn/go-isatty](https://github.com/mattn/go-isatty)
+    - Licensed under [MIT](http://mattn.mit-license.org)
+- [tcell](https://github.com/gdamore/tcell)
+    - Licensed under [Apache License 2.0](https://github.com/gdamore/tcell/blob/master/LICENSE)
+
+License
+-------
+
+[MIT](LICENSE)

CHANGELOG.md

@@ -1,6 +1,791 @@
 CHANGELOG
 =========
 
+0.29.0
+------
+- Added `change-preview(...)` action to change the `--preview` command
+    - cf. `preview(...)` is a one-off action that doesn't change the default
+      preview command
+- Added `change-preview-window(...)` action
+    - You can rotate through the different options separated by `|`
+      ```sh
+      fzf --preview 'cat {}' --preview-window right:40% \
+          --bind 'ctrl-/:change-preview-window(right,70%|down,40%,border-top|hidden|)'
+      ```
+- Fixed rendering of the prompt line when overflow occurs with `--info=inline`
+
+0.28.0
+------
+- Added `--header-first` option to print header before the prompt line
+  ```sh
+  fzf --header $'Welcome to fzf\n▔▔▔▔▔▔▔▔▔▔▔▔▔▔' --reverse --height 30% --border --header-first
+  ```
+- Added `--scroll-off=LINES` option (similar to `scrolloff` option of Vim)
+    - You can set it to a very large number so that the cursor stays in the
+      middle of the screen while scrolling
+      ```sh
+      fzf --scroll-off=5
+      fzf --scroll-off=999
+      ```
+- Fixed bug where preview window is not updated on `reload` (#2644)
+- fzf on Windows will also use `$SHELL` to execute external programs
+    - See #2638 and #2647
+    - Thanks to @rashil2000, @vovcacik, and @janlazo
+
+0.27.3
+------
+- Preview window is `hidden` by default when there are `preview` bindings but
+  `--preview` command is not given
+- Fixed bug where `{n}` is not properly reset on `reload`
+- Fixed bug where spinner is not displayed on `reload`
+- Enhancements in tcell renderer for Windows (#2616)
+- Vim plugin
+    - `sinklist` is added as a synonym to `sink*` so that it's easier to add
+      a function to a spec dictionary
+      ```vim
+      let spec = { 'source': 'ls', 'options': ['--multi', '--preview', 'cat {}'] }
+      function spec.sinklist(matches)
+        echom string(a:matches)
+      endfunction
+
+      call fzf#run(fzf#wrap(spec))
+      ```
+    - Vim 7 compatibility
+
+0.27.2
+------
+- 16 base ANSI colors can be specified by their names
+  ```sh
+  fzf --color fg:3,fg+:11
+  fzf --color fg:yellow,fg+:bright-yellow
+  ```
+- Fix bug where `--read0` not properly displaying long lines
+
+0.27.1
+------
+- Added `unbind` action. In the following Ripgrep launcher example, you can
+  use `unbind(reload)` to switch to fzf-only filtering mode.
+    - See https://github.com/junegunn/fzf/blob/master/ADVANCED.md#switching-to-fzf-only-search-mode
+- Vim plugin
+    - Vim plugin will stop immediately even when the source command hasn't finished
+      ```vim
+      " fzf will read the stream file while allowing other processes to append to it
+      call fzf#run({'source': 'cat /dev/null > /tmp/stream; tail -f /tmp/stream'})
+      ```
+    - It is now possible to open popup window relative to the current window
+      ```vim
+      let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true, 'yoffset': 1.0 } }
+      ```
+
+0.27.0
+------
+- More border options for `--preview-window`
+  ```sh
+  fzf --preview 'cat {}' --preview-window border-left
+  fzf --preview 'cat {}' --preview-window border-left --border horizontal
+  fzf --preview 'cat {}' --preview-window top:border-bottom
+  fzf --preview 'cat {}' --preview-window top:border-horizontal
+  ```
+- Automatically set `/dev/tty` as STDIN on execute action
+  ```sh
+  # Redirect /dev/tty to suppress "Vim: Warning: Input is not from a terminal"
+  # ls | fzf --bind "enter:execute(vim {} < /dev/tty)"
+
+  # "< /dev/tty" part is no longer needed
+  ls | fzf --bind "enter:execute(vim {})"
+  ```
+- Bug fixes and improvements
+- Signed and notarized macOS binaries
+  (Huge thanks to [BACKERS.md](https://github.com/junegunn/junegunn/blob/main/BACKERS.md)!)
+
+0.26.0
+------
+- Added support for fixed header in preview window
+  ```sh
+  # Display top 3 lines as the fixed header
+  fzf --preview 'bat --style=header,grid --color=always {}' --preview-window '~3'
+  ```
+- More advanced preview offset expression to better support the fixed header
+  ```sh
+  # Preview with bat, matching line in the middle of the window below
+  # the fixed header of the top 3 lines
+  #
+  #   ~3    Top 3 lines as the fixed header
+  #   +{2}  Base scroll offset extracted from the second field
+  #   +3    Extra offset to compensate for the 3-line header
+  #   /2    Put in the middle of the preview area
+  #
+  git grep --line-number '' |
+    fzf --delimiter : \
+        --preview 'bat --style=full --color=always --highlight-line {2} {1}' \
+        --preview-window '~3:+{2}+3/2'
+  ```
+- Added `select` and `deselect` action for unconditionally selecting or
+  deselecting a single item in `--multi` mode. Complements `toggle` action.
+- Significant performance improvement in ANSI code processing
+- Bug fixes and improvements
+- Built with Go 1.16
+
+0.25.1
+------
+- Added `close` action
+    - Close preview window if open, abort fzf otherwise
+- Bug fixes and improvements
+
+0.25.0
+------
+- Text attributes set in `--color` are not reset when fzf sees another
+  `--color` option for the same element. This allows you to put custom text
+  attributes in your `$FZF_DEFAULT_OPTS` and still have those attributes
+  even when you override the colors.
+
+  ```sh
+  # Default colors and attributes
+  fzf
+
+  # Apply custom text attributes
+  export FZF_DEFAULT_OPTS='--color fg+:italic,hl:-1:underline,hl+:-1:reverse:underline'
+
+  fzf
+
+  # Different colors but you still have the attributes
+  fzf --color hl:176,hl+:177
+
+  # Write "regular" if you want to clear the attributes
+  fzf --color hl:176:regular,hl+:177:regular
+  ```
+- Renamed `--phony` to `--disabled`
+- You can dynamically enable and disable the search functionality using the
+  new `enable-search`, `disable-search`, and `toggle-search` actions
+- You can assign a different color to the query string for when search is disabled
+  ```sh
+  fzf --color query:#ffffff,disabled:#999999 --bind space:toggle-search
+  ```
+- Added `last` action to move the cursor to the last match
+    - The opposite action `top` is renamed to `first`, but `top` is still
+      recognized as a synonym for backward compatibility
+- Added `preview-top` and `preview-bottom` actions
+- Extended support for alt key chords: alt with any case-sensitive single character
+  ```sh
+  fzf --bind alt-,:first,alt-.:last
+  ```
+
+0.24.4
+------
+- Added `--preview-window` option `follow`
+  ```sh
+  # Preview window will automatically scroll to the bottom
+  fzf --preview-window follow --preview 'for i in $(seq 100000); do
+    echo "$i"
+    sleep 0.01
+    (( i % 300 == 0 )) && printf "\033[2J"
+  done'
+  ```
+- Added `change-prompt` action
+  ```sh
+  fzf --prompt 'foo> ' --bind $'a:change-prompt:\x1b[31mbar> '
+  ```
+- Bug fixes and improvements
+
+0.24.3
+------
+- Added `--padding` option
+  ```sh
+  fzf --margin 5% --padding 5% --border --preview 'cat {}' \
+      --color bg:#222222,preview-bg:#333333
+  ```
+
+0.24.2
+------
+- Bug fixes and improvements
+
+0.24.1
+------
+- Fixed broken `--color=[bw|no]` option
+
+0.24.0
+------
+- Real-time rendering of preview window
+  ```sh
+  # fzf can render preview window before the command completes
+  fzf --preview 'sleep 1; for i in $(seq 100); do echo $i; sleep 0.01; done'
+
+  # Preview window can process ANSI escape sequence (CSI 2 J) for clearing the display
+  fzf --preview 'for i in $(seq 100000); do
+    (( i % 200 == 0 )) && printf "\033[2J"
+    echo "$i"
+    sleep 0.01
+  done'
+  ```
+- Updated `--color` option to support text styles
+  - `regular` / `bold` / `dim` / `underline` / `italic` / `reverse` / `blink`
+    ```sh
+    # * Set -1 to keep the original color
+    # * Multiple style attributes can be combined
+    # * Italic style may not be supported by some terminals
+    rg --line-number --no-heading --color=always "" |
+      fzf --ansi --prompt "Rg: " \
+          --color fg+:italic,hl:underline:-1,hl+:italic:underline:reverse:-1 \
+          --color pointer:reverse,prompt:reverse,input:159 \
+          --pointer '  '
+    ```
+- More `--border` options
+  - `vertical`, `top`, `bottom`, `left`, `right`
+  - Updated Vim plugin to use these new `--border` options
+    ```vim
+    " Floating popup window in the center of the screen
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+
+    " Popup with 100% width
+    let g:fzf_layout = { 'window': { 'width': 1.0, 'height': 0.5, 'border': 'horizontal' } }
+
+    " Popup with 100% height
+    let g:fzf_layout = { 'window': { 'width': 0.5, 'height': 1.0, 'border': 'vertical' } }
+
+    " Similar to 'down' layout, but it uses a popup window and doesn't affect the window layout
+    let g:fzf_layout = { 'window': { 'width': 1.0, 'height': 0.5, 'yoffset': 1.0, 'border': 'top' } }
+
+    " Opens on the right;
+    "   'highlight' option is still supported but it will only take the foreground color of the group
+    let g:fzf_layout = { 'window': { 'width': 0.5, 'height': 1.0, 'xoffset': 1.0, 'border': 'left', 'highlight': 'Comment' } }
+    ```
+- To indicate if `--multi` mode is enabled, fzf will print the number of
+  selected items even when no item is selected
+  ```sh
+  seq 100 | fzf
+    # 100/100
+  seq 100 | fzf --multi
+    # 100/100 (0)
+  seq 100 | fzf --multi 5
+    # 100/100 (0/5)
+  ```
+- Since 0.24.0, release binaries will be uploaded to https://github.com/junegunn/fzf/releases
+
+0.23.1
+------
+- Added `--preview-window` options for disabling flags
+    - `nocycle`
+    - `nohidden`
+    - `nowrap`
+    - `default`
+- Built with Go 1.14.9 due to performance regression
+    - https://github.com/golang/go/issues/40727
+
+0.23.0
+------
+- Support preview scroll offset relative to window height
+  ```sh
+  git grep --line-number '' |
+    fzf --delimiter : \
+        --preview 'bat --style=numbers --color=always --highlight-line {2} {1}' \
+        --preview-window +{2}-/2
+  ```
+- Added `--preview-window` option for sharp edges (`--preview-window sharp`)
+- Added `--preview-window` option for cyclic scrolling (`--preview-window cycle`)
+- Reduced vertical padding around the preview window when `--preview-window
+  noborder` is used
+- Added actions for preview window
+    - `preview-half-page-up`
+    - `preview-half-page-down`
+- Vim
+    - Popup width and height can be given in absolute integer values
+    - Added `fzf#exec()` function for getting the path of fzf executable
+        - It also downloads the latest binary if it's not available by running
+          `./install --bin`
+- Built with Go 1.15.2
+    - We no longer provide 32-bit binaries
+
+0.22.0
+------
+- Added more options for `--bind`
+    - `backward-eof` event
+      ```sh
+      # Aborts when you delete backward when the query prompt is already empty
+      fzf --bind backward-eof:abort
+      ```
+    - `refresh-preview` action
+      ```sh
+      # Rerun preview command when you hit '?'
+      fzf --preview 'echo $RANDOM' --bind '?:refresh-preview'
+      ```
+    - `preview` action
+      ```sh
+      # Default preview command with an extra preview binding
+      fzf --preview 'file {}' --bind '?:preview:cat {}'
+
+      # A preview binding with no default preview command
+      # (Preview window is initially empty)
+      fzf --bind '?:preview:cat {}'
+
+      # Preview window hidden by default, it appears when you first hit '?'
+      fzf --bind '?:preview:cat {}' --preview-window hidden
+      ```
+- Added preview window option for setting the initial scroll offset
+  ```sh
+  # Initial scroll offset is set to the line number of each line of
+  # git grep output *minus* 5 lines
+  git grep --line-number '' |
+    fzf --delimiter : --preview 'nl {1}' --preview-window +{2}-5
+  ```
+- Added support for ANSI colors in `--prompt` string
+- Smart match of accented characters
+    - An unaccented character in the query string will match both accented and
+      unaccented characters, while an accented character will only match
+      accented characters. This is similar to how "smart-case" match works.
+- Vim plugin
+    - `tmux` layout option for using fzf-tmux
+      ```vim
+      let g:fzf_layout = { 'tmux': '-p90%,60%' }
+      ```
+
+0.21.1
+------
+- Shell extension
+    - CTRL-R will remove duplicate commands
+- fzf-tmux
+    - Supports tmux popup window (require tmux 3.2 or above)
+        - ```sh
+          # 50% width and height
+          fzf-tmux -p
+
+          # 80% width and height
+          fzf-tmux -p 80%
+
+          # 80% width and 40% height
+          fzf-tmux -p 80%,40%
+          fzf-tmux -w 80% -h 40%
+
+          # Window position
+          fzf-tmux -w 80% -h 40% -x 0 -y 0
+          fzf-tmux -w 80% -h 40% -y 1000
+
+          # Write ordinary fzf options after --
+          fzf-tmux -p -- --reverse --info=inline --margin 2,4 --border
+          ```
+        - On macOS, you can build the latest tmux from the source with
+          `brew install tmux --HEAD`
+- Bug fixes
+    - Fixed Windows file traversal not to include directories
+    - Fixed ANSI colors with `--keep-right`
+    - Fixed _fzf_complete for zsh
+- Built with Go 1.14.1
+
+0.21.0
+------
+- `--height` option is now available on Windows as well (@kelleyma49)
+- Added `--pointer` and `--marker` options
+- Added `--keep-right` option that keeps the right end of the line visible
+  when it's too long
+- Style changes
+    - `--border` will now print border with rounded corners around the
+      finder instead of printing horizontal lines above and below it.
+      The previous style is available via `--border=horizontal`
+    - Unicode spinner
+- More keys and actions for `--bind`
+- Added PowerShell script for downloading Windows binary
+- Vim plugin: Built-in floating windows support
+  ```vim
+  let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+  ```
+- bash: Various improvements in key bindings (CTRL-T, CTRL-R, ALT-C)
+    - CTRL-R will start with the current command-line as the initial query
+    - CTRL-R properly supports multi-line commands
+- Fuzzy completion API changed
+  ```sh
+  # Previous: fzf arguments given as a single string argument
+  # - This style is still supported, but it's deprecated
+  _fzf_complete "--multi --reverse --prompt=\"doge> \"" "$@" < <(
+    echo foo
+  )
+
+  # New API: multiple fzf arguments before "--"
+  # - Easier to write multiple options
+  _fzf_complete --multi --reverse --prompt="doge> " -- "$@" < <(
+    echo foo
+  )
+  ```
+- Bug fixes and improvements
+
+0.20.0
+------
+- Customizable preview window color (`preview-fg` and `preview-bg` for `--color`)
+  ```sh
+  fzf --preview 'cat {}' \
+      --color 'fg:#bbccdd,fg+:#ddeeff,bg:#334455,preview-bg:#223344,border:#778899' \
+      --border --height 20 --layout reverse --info inline
+  ```
+- Removed the immediate flicking of the screen on `reload` action.
+  ```sh
+  : | fzf --bind 'change:reload:seq {q}' --phony
+  ```
+- Added `clear-query` and `clear-selection` actions for `--bind`
+- It is now possible to split a composite bind action over multiple `--bind`
+  expressions by prefixing the later ones with `+`.
+  ```sh
+  fzf --bind 'ctrl-a:up+up'
+
+  # Can be now written as
+  fzf --bind 'ctrl-a:up' --bind 'ctrl-a:+up'
+
+  # This is useful when you need to write special execute/reload form (i.e. `execute:...`)
+  # to avoid parse errors and add more actions to the same key
+  fzf --multi --bind 'ctrl-l:select-all+execute:less {+f}' --bind 'ctrl-l:+deselect-all'
+  ```
+- Fixed parse error of `--bind` expression where concatenated execute/reload
+  action contains `+` character.
+  ```sh
+  fzf --multi --bind 'ctrl-l:select-all+execute(less {+f})+deselect-all'
+  ```
+- Fixed bugs of reload action
+    - Not triggered when there's no match even when the command doesn't have
+      any placeholder expressions
+    - Screen not properly cleared when `--header-lines` not filled on reload
+
+0.19.0
+------
+
+- Added `--phony` option which completely disables search functionality.
+  Useful when you want to use fzf only as a selector interface. See below.
+- Added "reload" action for dynamically updating the input list without
+  restarting fzf. See https://github.com/junegunn/fzf/issues/1750 to learn
+  more about it.
+  ```sh
+  # Using fzf as the selector interface for ripgrep
+  RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+  INITIAL_QUERY="foo"
+  FZF_DEFAULT_COMMAND="$RG_PREFIX '$INITIAL_QUERY' || true" \
+    fzf --bind "change:reload:$RG_PREFIX {q} || true" \
+        --ansi --phony --query "$INITIAL_QUERY"
+  ```
+- `--multi` now takes an optional integer argument which indicates the maximum
+  number of items that can be selected
+  ```sh
+  seq 100 | fzf --multi 3 --reverse --height 50%
+  ```
+- If a placeholder expression for `--preview` and `execute` action (and the
+  new `reload` action) contains `f` flag, it is replaced to the
+  path of a temporary file that holds the evaluated list. This is useful
+  when you multi-select a large number of items and the length of the
+  evaluated string may exceed [`ARG_MAX`][argmax].
+  ```sh
+  # Press CTRL-A to select 100K items and see the sum of all the numbers
+  seq 100000 | fzf --multi --bind ctrl-a:select-all \
+                   --preview "awk '{sum+=\$1} END {print sum}' {+f}"
+  ```
+- `deselect-all` no longer deselects unmatched items. It is now consistent
+  with `select-all` and `toggle-all` in that it only affects matched items.
+- Due to the limitation of bash, fuzzy completion is enabled by default for
+  a fixed set of commands. A helper function for easily setting up fuzzy
+  completion for any command is now provided.
+  ```sh
+  # usage: _fzf_setup_completion path|dir COMMANDS...
+  _fzf_setup_completion path git kubectl
+  ```
+- Info line style can be changed by `--info=STYLE`
+    - `--info=default`
+    - `--info=inline` (same as old `--inline-info`)
+    - `--info=hidden`
+- Preview window border can be disabled by adding `noborder` to
+  `--preview-window`.
+- When you transform the input with `--with-nth`, the trailing white spaces
+  are removed.
+- `ctrl-\`, `ctrl-]`, `ctrl-^`, and `ctrl-/` can now be used with `--bind`
+- See https://github.com/junegunn/fzf/milestone/15?closed=1 for more details
+
+[argmax]: https://unix.stackexchange.com/questions/120642/what-defines-the-maximum-size-for-a-command-single-argument
+
+0.18.0
+------
+
+- Added placeholder expression for zero-based item index: `{n}` and `{+n}`
+    - `fzf --preview 'echo {n}: {}'`
+- Added color option for the gutter: `--color gutter:-1`
+- Added `--no-unicode` option for drawing borders in non-Unicode, ASCII
+  characters
+- `FZF_PREVIEW_LINES` and `FZF_PREVIEW_COLUMNS` are exported to preview process
+    - fzf still overrides `LINES` and `COLUMNS` as before, but they may be
+      reset by the default shell.
+- Bug fixes and improvements
+    - See https://github.com/junegunn/fzf/milestone/14?closed=1
+- Built with Go 1.12.1
+
+0.17.5
+------
+
+- Bug fixes and improvements
+    - See https://github.com/junegunn/fzf/milestone/13?closed=1
+- Search query longer than the screen width is allowed (up to 300 chars)
+- Built with Go 1.11.1
+
+0.17.4
+------
+
+- Added `--layout` option with a new layout called `reverse-list`.
+    - `--layout=reverse` is a synonym for `--reverse`
+    - `--layout=default` is a synonym for `--no-reverse`
+- Preview window will be updated even when there is no match for the query
+  if any of the placeholder expressions (e.g. `{q}`, `{+}`) evaluates to
+  a non-empty string.
+- More keys for binding: `shift-{up,down}`, `alt-{up,down,left,right}`
+- fzf can now start even when `/dev/tty` is not available by making an
+  educated guess.
+- Updated the default command for Windows.
+- Fixes and improvements on bash/zsh completion
+- install and uninstall scripts now supports generating files under
+  `XDG_CONFIG_HOME` on `--xdg` flag.
+
+See https://github.com/junegunn/fzf/milestone/12?closed=1 for the full list of
+changes.
+
+0.17.3
+------
+- `$LINES` and `$COLUMNS` are exported to preview command so that the command
+  knows the exact size of the preview window.
+- Better error messages when the default command or `$FZF_DEFAULT_COMMAND`
+  fails.
+- Reverted #1061 to avoid having duplicate entries in the list when find
+  command detected a file system loop (#1120). The default command now
+  requires that find supports `-fstype` option.
+- fzf now distinguishes mouse left click and right click (#1130)
+    - Right click is now bound to `toggle` action by default
+    - `--bind` understands `left-click` and `right-click`
+- Added `replace-query` action (#1137)
+    - Replaces query string with the current selection
+- Added `accept-non-empty` action (#1162)
+    - Same as accept, except that it prevents fzf from exiting without any
+      selection
+
+0.17.1
+------
+
+- Fixed custom background color of preview window (#1046)
+- Fixed background color issues of Windows binary
+- Fixed Windows binary to execute command using cmd.exe with no parsing and
+  escaping (#1072)
+- Added support for `window` layout on Vim 8 using Vim 8 terminal (#1055)
+
+0.17.0-2
+--------
+
+A maintenance release for auxiliary scripts. fzf binaries are not updated.
+
+- Experimental support for the builtin terminal of Vim 8
+    - fzf can now run inside GVim
+- Updated Vim plugin to better handle `&shell` issue on fish
+- Fixed a bug of fzf-tmux where invalid output is generated
+- Fixed fzf-tmux to work even when `tput` does not work
+
+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-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
+- Git revision in `--version` output
+- Basic support for Cygwin environment
+- Many fixes in Vim plugin on Windows/Cygwin (thanks to @janlazo)
+
+0.16.7
+------
+- Added support for `ctrl-alt-[a-z]` key chords
+- CTRL-Z (SIGSTOP) now works with fzf
+- fzf will export `$FZF_PREVIEW_WINDOW` so that the scripts can use it
+- Bug fixes and improvements in Vim plugin and shell extensions
+
+0.16.6
+------
+- Minor bug fixes and improvements
+- Added `--no-clear` option for scripting purposes
+
+0.16.5
+------
+- Minor bug fixes
+- Added `toggle-preview-wrap` action
+- Built with Go 1.8
+
+0.16.4
+------
+- Added `--border` option to draw border above and below the finder
+- Bug fixes and improvements
+
+0.16.3
+------
+- Fixed a bug where fzf incorrectly display the lines when straddling tab
+  characters are trimmed
+- Placeholder expression used in `--preview` and `execute` action can
+  optionally take `+` flag to be used with multiple selections
+    - e.g. `git log --oneline | fzf --multi --preview 'git show {+1}'`
+- Added `execute-silent` action for executing a command silently without
+  switching to the alternate screen. This is useful when the process is
+  short-lived and you're not interested in its output.
+    - e.g. `fzf --bind 'ctrl-y:execute!(echo -n {} | pbcopy)'`
+- `ctrl-space` is allowed in `--bind`
+
+0.16.2
+------
+- Dropped ncurses dependency
+- Binaries for freebsd, openbsd, arm5, arm6, arm7, and arm8
+- Official 24-bit color support
+- Added support for composite actions in `--bind`. Multiple actions can be
+  chained using `+` separator.
+    - e.g. `fzf --bind 'ctrl-y:execute(echo -n {} | pbcopy)+abort'`
+- `--preview-window` with size 0 is allowed. This is used to make fzf execute
+  preview command in the background without displaying the result.
+- Minor bug fixes and improvements
+
+0.16.1
+------
+- Fixed `--height` option to properly fill the window with the background
+  color
+- Added `half-page-up` and `half-page-down` actions
+- Added `-L` flag to the default find command
+
+0.16.0
+------
+- *Added `--height HEIGHT[%]` option*
+    - fzf can now display finder without occupying the full screen
+- Preview window will truncate long lines by default. Line wrap can be enabled
+  by `:wrap` flag in `--preview-window`.
+- Latin script letters will be normalized before matching so that it's easier
+  to match against accented letters. e.g. `sodanco` can match `Só Danço Samba`.
+    - Normalization can be disabled via `--literal`
+- Added `--filepath-word` to make word-wise movements/actions (`alt-b`,
+  `alt-f`, `alt-bs`, `alt-d`) respect path separators
+
+0.15.9
+------
+- Fixed rendering glitches introduced in 0.15.8
+- The default escape delay is reduced to 50ms and is configurable via
+  `$ESCDELAY`
+- Scroll indicator at the top-right corner of the preview window is always
+  displayed when there's overflow
+- Can now be built with ncurses 6 or tcell to support extra features
+    - *ncurses 6*
+        - Supports more than 256 color pairs
+        - Supports italics
+    - *tcell*
+        - 24-bit color support
+    - See https://github.com/junegunn/fzf/blob/master/BUILD.md
+
+0.15.8
+------
+- Updated ANSI processor to handle more VT-100 escape sequences
+- Added `--no-bold` (and `--bold`) option
+- Improved escape sequence processing for WSL
+- Added support for `alt-[0-9]`, `f11`, and `f12` for `--bind` and `--expect`
+
+0.15.7
+------
+- Fixed panic when color is disabled and header lines contain ANSI colors
+
+0.15.6
+------
+- Windows binaries! (@kelleyma49)
+- Fixed the bug where header lines are cleared when preview window is toggled
+- Fixed not to display ^N and ^O on screen
+- Fixed cursor keys (or any key sequence that starts with ESC) on WSL by
+  making fzf wait for additional keystrokes after ESC for up to 100ms
+
+0.15.5
+------
+- Setting foreground color will no longer set background color to black
+    - e.g. `fzf --color fg:153`
+- `--tiebreak=end` will consider relative position instead of absolute distance
+- Updated `fzf#wrap` function to respect `g:fzf_colors`
+
+0.15.4
+------
+- Added support for range expression in preview and execute action
+    - e.g. `ls -l | fzf --preview="echo user={3} when={-4..-2}; cat {-1}" --header-lines=1`
+    - `{q}` will be replaced to the single-quoted string of the current query
+- Fixed to properly handle unicode whitespace characters
+- Display scroll indicator in preview window
+- Inverse search term will use exact matcher by default
+    - This is a breaking change, but I believe it makes much more sense. It is
+      almost impossible to predict which entries will be filtered out due to
+      a fuzzy inverse term. You can still perform inverse-fuzzy-match by
+      prepending `!'` to the term.
+
+0.15.3
+------
+- Added support for more ANSI attributes: dim, underline, blink, and reverse
+- Fixed race condition in `toggle-preview`
+
+0.15.2
+------
+- Preview window is now scrollable
+    - With mouse scroll or with bindable actions
+        - `preview-up`
+        - `preview-down`
+        - `preview-page-up`
+        - `preview-page-down`
+- Updated ANSI processor to support high intensity colors and ignore
+  some VT100-related escape sequences
+
+0.15.1
+------
+- Fixed panic when the pattern occurs after 2^15-th column
+- Fixed rendering delay when displaying extremely long lines
+
+0.15.0
+------
+- Improved fuzzy search algorithm
+    - Added `--algo=[v1|v2]` option so one can still choose the old algorithm
+      which values the search performance over the quality of the result
+- Advanced scoring criteria
+- `--read0` to read input delimited by ASCII NUL character
+- `--print0` to print output delimited by ASCII NUL character
+
+0.13.5
+------
+- Memory and performance optimization
+    - Up to 2x performance with half the amount of memory
+
+0.13.4
+------
+- Performance optimization
+    - Memory footprint for ascii string is reduced by 60%
+    - 15 to 20% improvement of query performance
+    - Up to 45% better performance of `--nth` with non-regex delimiters
+- Fixed invalid handling of `hidden` property of `--preview-window`
+
+0.13.3
+------
+- Fixed duplicate rendering of the last line in preview window
+
 0.13.2
 ------
 - Fixed race condition where preview window is not properly cleared
@@ -419,4 +1204,3 @@ add `--sync` option to re-enable buffering.
 ### Improvements
 - `--select-1` and `--exit-0` will start finder immediately when the condition
   cannot be met
-

Dockerfile

@@ -0,0 +1,11 @@
+FROM archlinux
+RUN pacman -Sy && pacman --noconfirm -S awk git tmux zsh fish ruby procps go make gcc
+RUN gem install --no-document -v 5.14.2 minitest
+RUN echo '. /usr/share/bash-completion/completions/git' >> ~/.bashrc
+RUN echo '. ~/.bashrc' >> ~/.bash_profile
+
+# Do not set default PS1
+RUN rm -f /etc/bash.bashrc
+COPY . /fzf
+RUN cd /fzf && make install && ./install --all
+CMD tmux new 'set -o pipefail; ruby /fzf/test/test_go.rb | tee out && touch ok' && cat out && [ -e ok ]

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -0,0 +1,166 @@
+SHELL          := bash
+GO             ?= go
+GOOS           ?= $(word 1, $(subst /, " ", $(word 4, $(shell go version))))
+
+MAKEFILE       := $(realpath $(lastword $(MAKEFILE_LIST)))
+ROOT_DIR       := $(shell dirname $(MAKEFILE))
+SOURCES        := $(wildcard *.go src/*.go src/*/*.go) $(MAKEFILE)
+
+ifdef FZF_VERSION
+VERSION        := $(FZF_VERSION)
+else
+VERSION        := $(shell git describe --abbrev=0 2> /dev/null)
+endif
+ifeq ($(VERSION),)
+$(error Not on git repository; cannot determine $$FZF_VERSION)
+endif
+VERSION_TRIM   := $(shell sed "s/-.*//" <<< $(VERSION))
+VERSION_REGEX  := $(subst .,\.,$(VERSION_TRIM))
+
+ifdef FZF_REVISION
+REVISION       := $(FZF_REVISION)
+else
+REVISION       := $(shell git log -n 1 --pretty=format:%h -- $(SOURCES) 2> /dev/null)
+endif
+ifeq ($(REVISION),)
+$(error Not on git repository; cannot determine $$FZF_REVISION)
+endif
+BUILD_FLAGS    := -a -ldflags "-s -w -X main.version=$(VERSION) -X main.revision=$(REVISION)" -tags "$(TAGS)"
+
+BINARY32       := fzf-$(GOOS)_386
+BINARY64       := fzf-$(GOOS)_amd64
+BINARYARM5     := fzf-$(GOOS)_arm5
+BINARYARM6     := fzf-$(GOOS)_arm6
+BINARYARM7     := fzf-$(GOOS)_arm7
+BINARYARM8     := fzf-$(GOOS)_arm8
+BINARYPPC64LE  := fzf-$(GOOS)_ppc64le
+BINARYRISCV64  := fzf-$(GOOS)_riscv64
+
+# https://en.wikipedia.org/wiki/Uname
+UNAME_M := $(shell uname -m)
+ifeq ($(UNAME_M),x86_64)
+	BINARY := $(BINARY64)
+else ifeq ($(UNAME_M),amd64)
+	BINARY := $(BINARY64)
+else ifeq ($(UNAME_M),i686)
+	BINARY := $(BINARY32)
+else ifeq ($(UNAME_M),i386)
+	BINARY := $(BINARY32)
+else ifeq ($(UNAME_M),armv5l)
+	BINARY := $(BINARYARM5)
+else ifeq ($(UNAME_M),armv6l)
+	BINARY := $(BINARYARM6)
+else ifeq ($(UNAME_M),armv7l)
+	BINARY := $(BINARYARM7)
+else ifeq ($(UNAME_M),armv8l)
+	BINARY := $(BINARYARM8)
+else ifeq ($(UNAME_M),arm64)
+	BINARY := $(BINARYARM8)
+else ifeq ($(UNAME_M),aarch64)
+	BINARY := $(BINARYARM8)
+else ifeq ($(UNAME_M),ppc64le)
+	BINARY := $(BINARYPPC64LE)
+else ifeq ($(UNAME_M),riscv64)
+	BINARY := $(BINARYRISCV64)
+else
+$(error Build on $(UNAME_M) is not supported, yet.)
+endif
+
+all: target/$(BINARY)
+
+test: $(SOURCES)
+	[ -z "$$(gofmt -s -d src)" ] || (gofmt -s -d src; exit 1)
+	SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" \
+				github.com/junegunn/fzf/src \
+				github.com/junegunn/fzf/src/algo \
+				github.com/junegunn/fzf/src/tui \
+				github.com/junegunn/fzf/src/util
+
+bench:
+	cd src && SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" -run=Bench -bench=. -benchmem
+
+install: bin/fzf
+
+build:
+	goreleaser --rm-dist --snapshot
+
+release:
+ifndef GITHUB_TOKEN
+	$(error GITHUB_TOKEN is not defined)
+endif
+
+	# Check if we are on master branch
+ifneq ($(shell git symbolic-ref --short HEAD),master)
+	$(error Not on master branch)
+endif
+
+	# Check if version numbers are properly updated
+	grep -q ^$(VERSION_REGEX)$$ CHANGELOG.md
+	grep -qF '"fzf $(VERSION_TRIM)"' man/man1/fzf.1
+	grep -qF '"fzf $(VERSION_TRIM)"' man/man1/fzf-tmux.1
+	grep -qF $(VERSION) install
+	grep -qF $(VERSION) install.ps1
+
+	# Make release note out of CHANGELOG.md
+	mkdir -p tmp
+	sed -n '/^$(VERSION_REGEX)$$/,/^[0-9]/p' CHANGELOG.md | tail -r | \
+		sed '1,/^ *$$/d' | tail -r | sed 1,2d | tee tmp/release-note
+
+	# Push to temp branch first so that install scripts always works on master branch
+	git checkout -B temp master
+	git push origin temp --follow-tags --force
+
+	# Make a GitHub release
+	goreleaser --rm-dist --release-notes tmp/release-note
+
+	# Push to master
+	git checkout master
+	git push origin master
+
+	# Delete temp branch
+	git push origin --delete temp
+
+clean:
+	$(RM) -r dist target
+
+target/$(BINARY32): $(SOURCES)
+	GOARCH=386 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARY64): $(SOURCES)
+	GOARCH=amd64 $(GO) build $(BUILD_FLAGS) -o $@
+
+# https://github.com/golang/go/wiki/GoArm
+target/$(BINARYARM5): $(SOURCES)
+	GOARCH=arm GOARM=5 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYARM6): $(SOURCES)
+	GOARCH=arm GOARM=6 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYARM7): $(SOURCES)
+	GOARCH=arm GOARM=7 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYARM8): $(SOURCES)
+	GOARCH=arm64 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYPPC64LE): $(SOURCES)
+	GOARCH=ppc64le $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYRISCV64): $(SOURCES)
+	GOARCH=riscv64 $(GO) build $(BUILD_FLAGS) -o $@
+
+bin/fzf: target/$(BINARY) | bin
+	cp -f target/$(BINARY) bin/fzf
+
+docker:
+	docker build -t fzf-arch .
+	docker run -it fzf-arch tmux
+
+docker-test:
+	docker build -t fzf-arch .
+	docker run -it fzf-arch
+
+update:
+	$(GO) get -u
+	$(GO) mod tidy
+
+.PHONY: all build release test bench install clean docker docker-test update

README-VIM.md

@@ -0,0 +1,486 @@
+FZF Vim integration
+===================
+
+Installation
+------------
+
+Once you have fzf installed, you can enable it inside Vim simply by adding the
+directory to `&runtimepath` in your Vim configuration file. The path may
+differ depending on the package manager.
+
+```vim
+" If installed using Homebrew
+set rtp+=/usr/local/opt/fzf
+
+" If installed using git
+set rtp+=~/.fzf
+```
+
+If you use [vim-plug](https://github.com/junegunn/vim-plug), the same can be
+written as:
+
+```vim
+" If installed using Homebrew
+Plug '/usr/local/opt/fzf'
+
+" If installed using git
+Plug '~/.fzf'
+```
+
+But if you want the latest Vim plugin file from GitHub rather than the one
+included in the package, write:
+
+```vim
+Plug 'junegunn/fzf'
+```
+
+The Vim plugin will pick up fzf binary available on the system. If fzf is not
+found on `$PATH`, it will ask you if it should download the latest binary for
+you.
+
+To make sure that you have the latest version of the binary, set up
+post-update hook like so:
+
+```vim
+Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+```
+
+Summary
+-------
+
+The Vim plugin of fzf provides two core functions, and `:FZF` command which is
+the basic file selector command built on top of them.
+
+1. **`fzf#run([spec dict])`**
+    - Starts fzf inside Vim with the given spec
+    - `:call fzf#run({'source': 'ls'})`
+2. **`fzf#wrap([spec dict]) -> (dict)`**
+    - Takes a spec for `fzf#run` and returns an extended version of it with
+      additional options for addressing global preferences (`g:fzf_xxx`)
+        - `:echo fzf#wrap({'source': 'ls'})`
+    - We usually *wrap* a spec with `fzf#wrap` before passing it to `fzf#run`
+        - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
+3. **`:FZF [fzf_options string] [path string]`**
+    - Basic fuzzy file selector
+    - A reference implementation for those who don't want to write VimScript
+      to implement custom commands
+    - If you're looking for more such commands, check out [fzf.vim](https://github.com/junegunn/fzf.vim) project.
+
+The most important of all is `fzf#run`, but it would be easier to understand
+the whole if we start off with `:FZF` command.
+
+`:FZF[!]`
+---------
+
+```vim
+" Look for files under current directory
+:FZF
+
+" Look for files under your home directory
+:FZF ~
+
+" With fzf command-line options
+:FZF --reverse --info=inline /tmp
+
+" Bang version starts fzf in fullscreen mode
+:FZF!
+```
+
+Similarly to [ctrlp.vim](https://github.com/kien/ctrlp.vim), use enter key,
+`CTRL-T`, `CTRL-X` or `CTRL-V` to open selected files in the current window,
+in new tabs, in horizontal splits, or in vertical splits respectively.
+
+Note that the environment variables `FZF_DEFAULT_COMMAND` and
+`FZF_DEFAULT_OPTS` also apply here.
+
+### Configuration
+
+- `g:fzf_action`
+    - Customizable extra key bindings for opening selected files in different ways
+- `g:fzf_layout`
+    - Determines the size and position of fzf window
+- `g:fzf_colors`
+    - Customizes fzf colors to match the current color scheme
+- `g:fzf_history_dir`
+    - Enables history feature
+
+#### Examples
+
+```vim
+" This is the default extra key bindings
+let g:fzf_action = {
+  \ 'ctrl-t': 'tab split',
+  \ '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
+" - Popup window (center of the screen)
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+
+" - Popup window (center of the current window)
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true } }
+
+" - Popup window (anchored to the bottom of the current window)
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true, 'yoffset': 1.0 } }
+
+" - down / up / left / right
+let g:fzf_layout = { 'down': '40%' }
+
+" - Window using a Vim command
+let g:fzf_layout = { 'window': 'enew' }
+let g:fzf_layout = { 'window': '-tabnew' }
+let g:fzf_layout = { 'window': '10new' }
+
+" Customize fzf colors to match your color scheme
+" - fzf#wrap translates this to a set of `--color` options
+let g:fzf_colors =
+\ { 'fg':      ['fg', 'Normal'],
+  \ 'bg':      ['bg', 'Normal'],
+  \ 'hl':      ['fg', 'Comment'],
+  \ 'fg+':     ['fg', 'CursorLine', 'CursorColumn', 'Normal'],
+  \ 'bg+':     ['bg', 'CursorLine', 'CursorColumn'],
+  \ 'hl+':     ['fg', 'Statement'],
+  \ 'info':    ['fg', 'PreProc'],
+  \ 'border':  ['fg', 'Ignore'],
+  \ 'prompt':  ['fg', 'Conditional'],
+  \ 'pointer': ['fg', 'Exception'],
+  \ 'marker':  ['fg', 'Keyword'],
+  \ 'spinner': ['fg', 'Label'],
+  \ 'header':  ['fg', 'Comment'] }
+
+" Enable per-command history
+" - History files will be stored in the specified directory
+" - When set, CTRL-N and CTRL-P will be bound to 'next-history' and
+"   'previous-history' instead of 'down' and 'up'.
+let g:fzf_history_dir = '~/.local/share/fzf-history'
+```
+
+##### Explanation of `g:fzf_colors`
+
+`g:fzf_colors` is a dictionary mapping fzf elements to a color specification
+list:
+
+    element: [ component, group1 [, group2, ...] ]
+
+- `element` is an fzf element to apply a color to:
+
+  | Element                     | Description                                           |
+  | ---                         | ---                                                   |
+  | `fg`  / `bg`  / `hl`        | Item (foreground / background / highlight)            |
+  | `fg+` / `bg+` / `hl+`       | Current item (foreground / background / highlight)    |
+  | `preview-fg` / `preview-bg` | Preview window text and background                    |
+  | `hl`  / `hl+`               | Highlighted substrings (normal / current)             |
+  | `gutter`                    | Background of the gutter on the left                  |
+  | `pointer`                   | Pointer to the current line (`>`)                     |
+  | `marker`                    | Multi-select marker (`>`)                             |
+  | `border`                    | Border around the window (`--border` and `--preview`) |
+  | `header`                    | Header (`--header` or `--header-lines`)               |
+  | `info`                      | Info line (match counters)                            |
+  | `spinner`                   | Streaming input indicator                             |
+  | `query`                     | Query string                                          |
+  | `disabled`                  | Query string when search is disabled                  |
+  | `prompt`                    | Prompt before query (`> `)                            |
+  | `pointer`                   | Pointer to the current line (`>`)                     |
+
+- `component` specifies the component (`fg` / `bg`) from which to extract the
+  color when considering each of the following highlight groups
+
+- `group1 [, group2, ...]` is a list of highlight groups that are searched (in
+  order) for a matching color definition
+
+For example, consider the following specification:
+
+```vim
+  'prompt':  ['fg', 'Conditional', 'Comment'],
+```
+
+This means we color the **prompt**
+- using the `fg` attribute of the `Conditional` if it exists,
+- otherwise use the `fg` attribute of the `Comment` highlight group if it exists,
+- otherwise fall back to the default color settings for the **prompt**.
+
+You can examine the color option generated according the setting by printing
+the result of `fzf#wrap()` function like so:
+
+```vim
+:echo fzf#wrap()
+```
+
+`fzf#run`
+---------
+
+`fzf#run()` function is the core of Vim integration. It takes a single
+dictionary argument, *a spec*, and starts fzf process accordingly. At the very
+least, specify `sink` option to tell what it should do with the selected
+entry.
+
+```vim
+call fzf#run({'sink': 'e'})
+```
+
+We haven't specified the `source`, so this is equivalent to starting fzf on
+command line without standard input pipe; fzf will use find command (or
+`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
+directory. When you select one, it will open it with the sink, `:e` command.
+If you want to open it in a new tab, you can pass `:tabedit` command instead
+as the sink.
+
+```vim
+call fzf#run({'sink': 'tabedit'})
+```
+
+Instead of using the default find command, you can use any shell command as
+the source. The following example will list the files managed by git. It's
+equivalent to running `git ls-files | fzf` on shell.
+
+```vim
+call fzf#run({'source': 'git ls-files', 'sink': 'e'})
+```
+
+fzf options can be specified as `options` entry in spec dictionary.
+
+```vim
+call fzf#run({'sink': 'tabedit', 'options': '--multi --reverse'})
+```
+
+You can also pass a layout option if you don't want fzf window to take up the
+entire screen.
+
+```vim
+" up / down / left / right / window are allowed
+call fzf#run({'source': 'git ls-files', 'sink': 'e', 'left': '40%'})
+call fzf#run({'source': 'git ls-files', 'sink': 'e', 'window': '30vnew'})
+```
+
+`source` doesn't have to be an external shell command, you can pass a Vim
+array as the source. In the next example, we pass the names of color
+schemes as the source to implement a color scheme selector.
+
+```vim
+call fzf#run({'source': map(split(globpath(&rtp, 'colors/*.vim')),
+            \               'fnamemodify(v:val, ":t:r")'),
+            \ 'sink': 'colo', 'left': '25%'})
+```
+
+The following table summarizes the available options.
+
+| Option name                | Type          | Description                                                           |
+| -------------------------- | ------------- | ----------------------------------------------------------------      |
+| `source`                   | string        | External command to generate input to fzf (e.g. `find .`)             |
+| `source`                   | list          | Vim list as input to fzf                                              |
+| `sink`                     | string        | Vim command to handle the selected item (e.g. `e`, `tabe`)            |
+| `sink`                     | funcref       | Reference to function to process each selected item                   |
+| `sinklist` (or `sink*`)    | funcref       | Similar to `sink`, but takes the list of output lines at once         |
+| `options`                  | string/list   | Options to fzf                                                        |
+| `dir`                      | string        | Working directory                                                     |
+| `up`/`down`/`left`/`right` | number/string | (Layout) Window position and size (e.g. `20`, `50%`)                  |
+| `tmux`                     | string        | (Layout) fzf-tmux options (e.g. `-p90%,60%`)                          |
+| `window` (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g. `vertical aboveleft 30new`) |
+| `window` (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g. `{'width': 0.9, 'height': 0.6}`) |
+
+`options` entry can be either a string or a list. For simple cases, string
+should suffice, but prefer to use list type to avoid escaping issues.
+
+```vim
+call fzf#run({'options': '--reverse --prompt "C:\\Program Files\\"'})
+call fzf#run({'options': ['--reverse', '--prompt', 'C:\Program Files\']})
+```
+
+When `window` entry is a dictionary, fzf will start in a popup window. The
+following options are allowed:
+
+- Required:
+    - `width` [float range [0 ~ 1]] or [integer range [8 ~ ]]
+    - `height` [float range [0 ~ 1]] or [integer range [4 ~ ]]
+- Optional:
+    - `yoffset` [float default 0.5 range [0 ~ 1]]
+    - `xoffset` [float default 0.5 range [0 ~ 1]]
+    - `relative` [boolean default v:false]
+    - `border` [string default `rounded`]: Border style
+        - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right` / `no[ne]`
+
+`fzf#wrap`
+----------
+
+We have seen that several aspects of `:FZF` command can be configured with
+a set of global option variables; different ways to open files
+(`g:fzf_action`), window position and size (`g:fzf_layout`), color palette
+(`g:fzf_colors`), etc.
+
+So how can we make our custom `fzf#run` calls also respect those variables?
+Simply by *"wrapping"* the spec dictionary with `fzf#wrap` before passing it
+to `fzf#run`.
+
+- **`fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`**
+    - All arguments are optional. Usually we only need to pass a spec dictionary.
+    - `name` is for managing history files. It is ignored if
+      `g:fzf_history_dir` is not defined.
+    - `fullscreen` can be either `0` or `1` (default: 0).
+
+`fzf#wrap` takes a spec and returns an extended version of it (also
+a dictionary) with additional options for addressing global preferences. You
+can examine the return value of it like so:
+
+```vim
+echo fzf#wrap({'source': 'ls'})
+```
+
+After we *"wrap"* our spec, we pass it to `fzf#run`.
+
+```vim
+call fzf#run(fzf#wrap({'source': 'ls'}))
+```
+
+Now it supports `CTRL-T`, `CTRL-V`, and `CTRL-X` key bindings (configurable
+via `g:fzf_action`) and it opens fzf window according to `g:fzf_layout`
+setting.
+
+To make it easier to use, let's define `LS` command.
+
+```vim
+command! LS call fzf#run(fzf#wrap({'source': 'ls'}))
+```
+
+Type `:LS` and see how it works.
+
+We would like to make `:LS!` (bang version) open fzf in fullscreen, just like
+`:FZF!`. Add `-bang` to command definition, and use `<bang>` value to set
+the last `fullscreen` argument of `fzf#wrap` (see `:help <bang>`).
+
+```vim
+" On :LS!, <bang> evaluates to '!', and '!0' becomes 1
+command! -bang LS call fzf#run(fzf#wrap({'source': 'ls'}, <bang>0))
+```
+
+Our `:LS` command will be much more useful if we can pass a directory argument
+to it, so that something like `:LS /tmp` is possible.
+
+```vim
+command! -bang -complete=dir -nargs=? LS
+    \ call fzf#run(fzf#wrap({'source': 'ls', 'dir': <q-args>}, <bang>0))
+```
+
+Lastly, if you have enabled `g:fzf_history_dir`, you might want to assign
+a unique name to our command and pass it as the first argument to `fzf#wrap`.
+
+```vim
+" The query history for this command will be stored as 'ls' inside g:fzf_history_dir.
+" The name is ignored if g:fzf_history_dir is not defined.
+command! -bang -complete=dir -nargs=? LS
+    \ call fzf#run(fzf#wrap('ls', {'source': 'ls', 'dir': <q-args>}, <bang>0))
+```
+
+### Global options supported by `fzf#wrap`
+
+- `g:fzf_layout`
+- `g:fzf_action`
+    - **Works only when no custom `sink` (or `sinklist`) is provided**
+        - Having custom sink usually means that each entry is not an ordinary
+          file path (e.g. name of color scheme), so we can't blindly apply the
+          same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
+- `g:fzf_colors`
+- `g:fzf_history_dir`
+
+Tips
+----
+
+### fzf inside terminal buffer
+
+On the latest versions of Vim and Neovim, fzf will start in a terminal buffer.
+If you find the default ANSI colors to be different, consider configuring the
+colors using `g:terminal_ansi_colors` in regular Vim or `g:terminal_color_x`
+in Neovim.
+
+```vim
+" Terminal colors for seoul256 color scheme
+if has('nvim')
+  let g:terminal_color_0 = '#4e4e4e'
+  let g:terminal_color_1 = '#d68787'
+  let g:terminal_color_2 = '#5f865f'
+  let g:terminal_color_3 = '#d8af5f'
+  let g:terminal_color_4 = '#85add4'
+  let g:terminal_color_5 = '#d7afaf'
+  let g:terminal_color_6 = '#87afaf'
+  let g:terminal_color_7 = '#d0d0d0'
+  let g:terminal_color_8 = '#626262'
+  let g:terminal_color_9 = '#d75f87'
+  let g:terminal_color_10 = '#87af87'
+  let g:terminal_color_11 = '#ffd787'
+  let g:terminal_color_12 = '#add4fb'
+  let g:terminal_color_13 = '#ffafaf'
+  let g:terminal_color_14 = '#87d7d7'
+  let g:terminal_color_15 = '#e4e4e4'
+else
+  let g:terminal_ansi_colors = [
+    \ '#4e4e4e', '#d68787', '#5f865f', '#d8af5f',
+    \ '#85add4', '#d7afaf', '#87afaf', '#d0d0d0',
+    \ '#626262', '#d75f87', '#87af87', '#ffd787',
+    \ '#add4fb', '#ffafaf', '#87d7d7', '#e4e4e4'
+  \ ]
+endif
+```
+
+### Starting fzf in a popup window
+
+```vim
+" Required:
+" - width [float range [0 ~ 1]] or [integer range [8 ~ ]]
+" - height [float range [0 ~ 1]] or [integer range [4 ~ ]]
+"
+" Optional:
+" - xoffset [float default 0.5 range [0 ~ 1]]
+" - yoffset [float default 0.5 range [0 ~ 1]]
+" - relative [boolean default v:false]
+" - border [string default 'rounded']: Border style
+"   - 'rounded' / 'sharp' / 'horizontal' / 'vertical' / 'top' / 'bottom' / 'left' / 'right'
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+```
+
+Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
+or above) by putting fzf-tmux options in `tmux` key.
+
+```vim
+" See `man fzf-tmux` for available options
+if exists('$TMUX')
+  let g:fzf_layout = { 'tmux': '-p90%,60%' }
+else
+  let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+endif
+```
+
+### Hide statusline
+
+When fzf starts in a terminal buffer, the file type of the buffer is set to
+`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
+the window.
+
+For example, if you open fzf on the bottom on the screen (e.g. `{'down':
+'40%'}`), you might want to temporarily disable the statusline for a cleaner
+look.
+
+```vim
+let g:fzf_layout = { 'down': '30%' }
+autocmd! FileType fzf
+autocmd  FileType fzf set laststatus=0 noshowmode noruler
+  \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
+```
+
+[License](LICENSE)
+------------------
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2021 Junegunn Choi

README.md

@@ -1,27 +1,76 @@
-<img src="https://raw.githubusercontent.com/junegunn/i/master/fzf.png" height="170" alt="fzf - a command-line fuzzy finder"> [![travis-ci](https://travis-ci.org/junegunn/fzf.svg?branch=master)](https://travis-ci.org/junegunn/fzf)
+<img src="https://raw.githubusercontent.com/junegunn/i/master/fzf.png" height="170" alt="fzf - a command-line fuzzy finder"> [![github-actions](https://github.com/junegunn/fzf/workflows/Test%20fzf%20on%20Linux/badge.svg)](https://github.com/junegunn/fzf/actions)
 ===
 
 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
-    - e.g. `locate / | fzf`
-- Flexible layout
-    - Runs in fullscreen or in horizontal/vertical split using tmux
 - The most comprehensive feature set
-    - Try `fzf --help` and be surprised
+- Flexible layout
 - Batteries included
-    - Vim/Neovim plugin, key bindings and fuzzy auto-completion
+    - Vim/Neovim plugin, key bindings, and fuzzy auto-completion
+
+Table of Contents
+-----------------
+
+<!-- vim-markdown-toc GFM -->
+
+* [Installation](#installation)
+  * [Using Homebrew](#using-homebrew)
+  * [Using git](#using-git)
+  * [Using Linux package managers](#using-linux-package-managers)
+  * [Windows](#windows)
+  * [As Vim plugin](#as-vim-plugin)
+* [Upgrading fzf](#upgrading-fzf)
+* [Building fzf](#building-fzf)
+* [Usage](#usage)
+    * [Using the finder](#using-the-finder)
+    * [Layout](#layout)
+    * [Search syntax](#search-syntax)
+    * [Environment variables](#environment-variables)
+    * [Options](#options)
+    * [Demo](#demo)
+* [Examples](#examples)
+* [`fzf-tmux` script](#fzf-tmux-script)
+* [Key bindings for command-line](#key-bindings-for-command-line)
+* [Fuzzy completion for bash and zsh](#fuzzy-completion-for-bash-and-zsh)
+    * [Files and directories](#files-and-directories)
+    * [Process IDs](#process-ids)
+    * [Host names](#host-names)
+    * [Environment variables / Aliases](#environment-variables--aliases)
+    * [Settings](#settings)
+    * [Supported commands](#supported-commands)
+    * [Custom fuzzy completion](#custom-fuzzy-completion)
+* [Vim plugin](#vim-plugin)
+* [Advanced topics](#advanced-topics)
+  * [Performance](#performance)
+  * [Executing external programs](#executing-external-programs)
+  * [Reloading the candidate list](#reloading-the-candidate-list)
+    * [1. Update the list of processes by pressing CTRL-R](#1-update-the-list-of-processes-by-pressing-ctrl-r)
+    * [2. Switch between sources by pressing CTRL-D or CTRL-F](#2-switch-between-sources-by-pressing-ctrl-d-or-ctrl-f)
+    * [3. Interactive ripgrep integration](#3-interactive-ripgrep-integration)
+  * [Preview window](#preview-window)
+* [Tips](#tips)
+    * [Respecting `.gitignore`](#respecting-gitignore)
+    * [Fish shell](#fish-shell)
+* [Related projects](#related-projects)
+* [License](#license)
+
+<!-- vim-markdown-toc -->
 
 Installation
 ------------
 
-fzf project consists of the following:
+fzf project consists of the following components:
 
 - `fzf` executable
 - `fzf-tmux` script for launching fzf in a tmux pane
@@ -30,14 +79,30 @@ fzf project consists of the following:
     - Fuzzy auto-completion (bash, zsh)
 - Vim/Neovim plugin
 
-You can [download fzf executable][bin] alone, but it's recommended that you
+You can [download fzf executable][bin] alone if you don't need the extra
-install the extra stuff using the attached install script.
+stuff.
 
-[bin]: https://github.com/junegunn/fzf-bin/releases
+[bin]: https://github.com/junegunn/fzf/releases
 
-#### Using git (recommended)
+### Using Homebrew
 
-Clone this repository and run
+You can use [Homebrew](https://brew.sh/) (on macOS or Linux)
+to install fzf.
+
+```sh
+brew install fzf
+
+# To install useful key bindings and fuzzy completion:
+$(brew --prefix)/opt/fzf/install
+```
+
+fzf is also available [via MacPorts][portfile]: `sudo port install fzf`
+
+[portfile]: https://github.com/macports/macports-ports/blob/master/sysutils/fzf/Portfile
+
+### Using git
+
+Alternatively, you can "git clone" this repository to any directory and run
 [install](https://github.com/junegunn/fzf/blob/master/install) script.
 
 ```sh
@@ -45,46 +110,84 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 ~/.fzf/install
 ```
 
-#### Using Homebrew
+### Using Linux package managers
 
-On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.
+| Package Manager | Linux Distribution      | Command                            |
+| ---             | ---                     | ---                                |
+| APK             | Alpine Linux            | `sudo apk add fzf`                 |
+| APT             | Debian 9+/Ubuntu 19.10+ | `sudo apt-get install fzf`         |
+| Conda           |                         | `conda install -c conda-forge fzf` |
+| DNF             | Fedora                  | `sudo dnf install fzf`             |
+| Nix             | NixOS, etc.             | `nix-env -iA nixpkgs.fzf`          |
+| Pacman          | Arch Linux              | `sudo pacman -S fzf`               |
+| pkg             | FreeBSD                 | `pkg install fzf`                  |
+| pkgin           | NetBSD                  | `pkgin install fzf`                |
+| pkg_add         | OpenBSD                 | `pkg_add fzf`                      |
+| XBPS            | Void Linux              | `sudo xbps-install -S fzf`         |
+| Zypper          | openSUSE                | `sudo zypper install fzf`          |
 
-```sh
+> :warning: **Key bindings (CTRL-T / CTRL-R / ALT-C) and fuzzy auto-completion
-brew install fzf
+> may not be enabled by default.**
+>
+> Refer to the package documentation for more information. (e.g. `apt-cache show fzf`)
 
-# Install shell extensions
+[![Packaging status](https://repology.org/badge/vertical-allrepos/fzf.svg)](https://repology.org/project/fzf/versions)
-/usr/local/opt/fzf/install
-```
 
-#### Install as Vim plugin
+### Windows
 
-Once you have cloned the repository, add the following line to your .vimrc.
+Pre-built binaries for Windows can be downloaded [here][bin]. fzf is also
+available via [Chocolatey][choco] and [Scoop][scoop]:
+
+| Package manager | Command             |
+| ---             | ---                 |
+| Chocolatey      | `choco install fzf` |
+| Scoop           | `scoop install fzf` |
+
+[choco]: https://chocolatey.org/packages/fzf
+[scoop]: https://github.com/ScoopInstaller/Main/blob/master/bucket/fzf.json
+
+Known issues and limitations on Windows can be found on [the wiki
+page][windows-wiki].
+
+[windows-wiki]: https://github.com/junegunn/fzf/wiki/Windows
+
+### As Vim plugin
+
+If you use
+[vim-plug](https://github.com/junegunn/vim-plug), add this line to your Vim
+configuration file:
 
 ```vim
-set rtp+=~/.fzf
+Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
 ```
 
-Or you can have [vim-plug](https://github.com/junegunn/vim-plug) manage fzf
+`fzf#install()` makes sure that you have the latest binary, but it's optional,
-(recommended):
+so you can omit it if you use a plugin manager that doesn't support hooks.
 
-```vim
+For more installation options, see [README-VIM.md](README-VIM.md).
-Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
-```
 
-#### Upgrading fzf
+Upgrading fzf
+-------------
 
-fzf is being actively developed and you might want to upgrade it once in a
+fzf is being actively developed, and you might want to upgrade it once in a
 while. Please follow the instruction below depending on the installation
-method.
+method used.
 
 - git: `cd ~/.fzf && git pull && ./install`
-- brew: `brew update; brew reinstall fzf`
+- brew: `brew update; brew upgrade fzf`
+- macports: `sudo port upgrade fzf`
+- chocolatey: `choco upgrade fzf`
 - vim-plug: `:PlugUpdate fzf`
 
+Building fzf
+------------
+
+See [BUILD.md](BUILD.md).
+
 Usage
 -----
 
-fzf will launch curses-based finder, read the list from STDIN, and write the
+fzf will launch interactive finder, read the list from STDIN, and write the
 selected item to STDOUT.
 
 ```sh
@@ -101,27 +204,51 @@ vim $(fzf)
 
 #### Using the finder
 
-- `CTRL-J` / `CTRL-K` (or `CTRL-N` / `CTRL-P)` to move cursor up and down
+- `CTRL-K` / `CTRL-J` (or `CTRL-P` / `CTRL-N`) to move cursor up and down
 - `Enter` key to select the item, `CTRL-C` / `CTRL-G` / `ESC` to exit
 - On multi-select mode (`-m`), `TAB` and `Shift-TAB` to mark multiple items
 - Emacs style key bindings
 - Mouse: scroll, click, double-click; shift-click and shift-scroll on
   multi-select mode
 
+#### Layout
+
+fzf by default starts in fullscreen mode, but you can make it start below the
+cursor with `--height` option.
+
+```sh
+vim $(fzf --height 40%)
+```
+
+Also, check out `--reverse` and `--layout` options if you prefer
+"top-down" layout instead of the default "bottom-up" layout.
+
+```sh
+vim $(fzf --height 40% --reverse)
+```
+
+You can add these options to `$FZF_DEFAULT_OPTS` so that they're applied by
+default. For example,
+
+```sh
+export FZF_DEFAULT_OPTS='--height 40% --layout=reverse --border'
+```
+
 #### Search syntax
 
 Unless otherwise specified, fzf starts in "extended-search mode" where you can
 type in multiple search terms delimited by spaces. e.g. `^music .mp3$ sbtrkt
-!rmx`
+!fire`
 
-| Token    | Match type           | Description                      |
+| Token     | Match type                 | Description                          |
-| -------- | -------------------- | -------------------------------- |
+| --------- | -------------------------- | ------------------------------------ |
-| `sbtrkt` | fuzzy-match          | Items that match `sbtrkt`        |
+| `sbtrkt`  | fuzzy-match                | Items that match `sbtrkt`            |
-| `^music` | prefix-exact-match   | Items that start with `music`    |
+| `'wild`   | exact-match (quoted)       | Items that include `wild`            |
-| `.mp3$`  | suffix-exact-match   | Items that end with `.mp3`       |
+| `^music`  | prefix-exact-match         | Items that start with `music`        |
-| `'wild`  | exact-match (quoted) | Items that include `wild`        |
+| `.mp3$`   | suffix-exact-match         | Items that end with `.mp3`           |
-| `!rmx`   | inverse-fuzzy-match  | Items that do not match `rmx`    |
+| `!fire`   | inverse-exact-match        | Items that do not include `fire`     |
-| `!'fire` | inverse-exact-match  | Items that do not include `fire` |
+| `!^music` | inverse-prefix-exact-match | Items that do not start with `music` |
+| `!.mp3$`  | inverse-suffix-exact-match | Items that do not end with `.mp3`    |
 
 If you don't prefer fuzzy matching and do not wish to "quote" every word,
 start fzf with `-e` or `--exact` option. Note that when  `--exact` is set,
@@ -139,17 +266,36 @@ or `py`.
 
 - `FZF_DEFAULT_COMMAND`
     - Default command to use when input is tty
-    - e.g. `export FZF_DEFAULT_COMMAND='ag -g ""'`
+    - e.g. `export FZF_DEFAULT_COMMAND='fd --type f'`
+    - > :warning: This variable is not used by shell extensions due to the
+      > slight difference in requirements.
+      >
+      > (e.g. `CTRL-T` runs `$FZF_CTRL_T_COMMAND` instead, `vim **<tab>` runs
+      > `_fzf_compgen_path()`, and `cd **<tab>` runs `_fzf_compgen_dir()`)
+      >
+      > The available options are described later in this document.
 - `FZF_DEFAULT_OPTS`
     - Default options
-    - e.g. `export FZF_DEFAULT_OPTS="--reverse --inline-info"`
+    - e.g. `export FZF_DEFAULT_OPTS="--layout=reverse --inline-info"`
+
+#### Options
+
+See the man page (`man fzf`) for the full list of options.
+
+#### Demo
+If you learn by watching videos, check out this screencast by [@samoshkin](https://github.com/samoshkin) to explore `fzf` features.
+
+<a title="fzf - command-line fuzzy finder" href="https://www.youtube.com/watch?v=qgG5Jhi_Els">
+  <img src="https://i.imgur.com/vtG8olE.png" width="640">
+</a>
 
 Examples
 --------
 
-Many useful examples can be found on [the wiki
+* [Wiki page of examples](https://github.com/junegunn/fzf/wiki/examples)
-page](https://github.com/junegunn/fzf/wiki/examples). Feel free to add your
+    * *Disclaimer: The examples on this page are maintained by the community
-own as well.
+      and are not thoroughly tested*
+* [Advanced fzf examples](https://github.com/junegunn/fzf/blob/master/ADVANCED.md)
 
 `fzf-tmux` script
 -----------------
@@ -157,8 +303,10 @@ own as well.
 [fzf-tmux](bin/fzf-tmux) is a bash script that opens fzf in a tmux pane.
 
 ```sh
-# usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
+# usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
-#        (-[udlr]: up/down/left/right)
+
+# See available options
+fzf-tmux --help
 
 # select git branches in horizontal split below (15 lines)
 git branch | fzf-tmux -d 15
@@ -167,33 +315,38 @@ git branch | fzf-tmux -d 15
 cat /usr/share/dict/words | fzf-tmux -l 20% --multi --reverse
 ```
 
-It will still work even when you're not on tmux, silently ignoring `-[udlr]`
+It will still work even when you're not on tmux, silently ignoring `-[pudlr]`
 options, so you can invariably use `fzf-tmux` in your scripts.
 
-Key bindings for command line
+Alternatively, you can use `--height HEIGHT[%]` option not to start fzf in
+fullscreen mode.
+
+```sh
+fzf --height 40%
+```
+
+Key bindings for command-line
 -----------------------------
 
 The install script will setup the following key bindings for bash, zsh, and
 fish.
 
-- `CTRL-T` - Paste the selected files and directories onto the command line
+- `CTRL-T` - Paste the selected files and directories onto the command-line
     - Set `FZF_CTRL_T_COMMAND` to override the default command
     - Set `FZF_CTRL_T_OPTS` to pass additional options
-- `CTRL-R` - Paste the selected command from history onto the command line
+- `CTRL-R` - Paste the selected command from history onto the command-line
-    - Sort is disabled by default to respect chronological ordering
+    - If you want to see the commands in chronological order, press `CTRL-R`
-    - Press `CTRL-R` again to toggle sort
+      again which toggles sorting by relevance
     - Set `FZF_CTRL_R_OPTS` to pass additional options
 - `ALT-C` - cd into the selected directory
     - Set `FZF_ALT_C_COMMAND` to override the default command
     - Set `FZF_ALT_C_OPTS` to pass additional options
 
-If you're on a tmux session, fzf will start in a split pane. You may disable
+If you're on a tmux session, you can start fzf in a tmux split-pane or in
-this tmux integration by setting `FZF_TMUX` to 0, or change the height of the
+a tmux popup window by setting `FZF_TMUX_OPTS` (e.g. `-d 40%`).
-pane with `FZF_TMUX_HEIGHT` (e.g. `20`, `50%`).
+See `fzf-tmux --help` for available options.
 
-If you use vi mode on bash, you need to add `set -o vi` *before* `source
+More tips can be found on [the wiki page](https://github.com/junegunn/fzf/wiki/Configuring-shell-key-bindings).
-~/.fzf.bash` in your .bashrc, so that it correctly sets up key bindings for vi
-mode.
 
 Fuzzy completion for bash and zsh
 ---------------------------------
@@ -201,12 +354,12 @@ Fuzzy completion for bash and zsh
 #### Files and directories
 
 Fuzzy completion for files and directories can be triggered if the word before
-the cursor ends with the trigger sequence which is by default `**`.
+the cursor ends with the trigger sequence, which is by default `**`.
 
 - `COMMAND [DIRECTORY/][FUZZY_PATTERN]**<TAB>`
 
 ```sh
-# Files under current directory
+# Files under the current directory
 # - You can select multiple items with TAB key
 vim **<TAB>
 
@@ -229,8 +382,8 @@ cd ~/github/fzf**<TAB>
 
 #### Process IDs
 
-Fuzzy completion for PIDs is provided for kill command. In this case
+Fuzzy completion for PIDs is provided for kill command. In this case,
-there is no trigger sequence, just press tab key after kill command.
+there is no trigger sequence; just press the tab key after the kill command.
 
 ```sh
 # Can select multiple processes with <TAB> or <Shift-TAB> keys
@@ -239,7 +392,7 @@ kill -9 <TAB>
 
 #### Host names
 
-For ssh and telnet commands, fuzzy completion for host names is provided. The
+For ssh and telnet commands, fuzzy completion for hostnames is provided. The
 names are extracted from /etc/hosts and ~/.ssh/config.
 
 ```sh
@@ -262,14 +415,34 @@ unalias **<TAB>
 export FZF_COMPLETION_TRIGGER='~~'
 
 # Options to fzf command
-export FZF_COMPLETION_OPTS='+c -x'
+export FZF_COMPLETION_OPTS='--border --info=inline'
 
-# Use ag instead of the default find command for listing candidates.
+# Use fd (https://github.com/sharkdp/fd) instead of the default find
-# - The first argument to the function is the base path to start traversal
+# command for listing path candidates.
-# - Note that ag only lists files not directories
+# - The first argument to the function ($1) is the base path to start traversal
 # - See the source code (completion.{bash,zsh}) for the details.
 _fzf_compgen_path() {
-  ag -g "" "$1"
+  fd --hidden --follow --exclude ".git" . "$1"
+}
+
+# Use fd to generate the list for directory completion
+_fzf_compgen_dir() {
+  fd --type d --hidden --follow --exclude ".git" . "$1"
+}
+
+# (EXPERIMENTAL) Advanced customization of fzf options via _fzf_comprun function
+# - The first argument to the function is the name of the command.
+# - You should make sure to pass the rest of the arguments to fzf.
+_fzf_comprun() {
+  local command=$1
+  shift
+
+  case "$command" in
+    cd)           fzf "$@" --preview 'tree -C {} | head -200' ;;
+    export|unset) fzf "$@" --preview "eval 'echo \$'{}" ;;
+    ssh)          fzf "$@" --preview 'dig {}' ;;
+    *)            fzf "$@" ;;
+  esac
 }
 ```
 
@@ -277,137 +450,263 @@ _fzf_compgen_path() {
 
 On bash, fuzzy completion is enabled only for a predefined set of commands
 (`complete | grep _fzf` to see the list). But you can enable it for other
-commands as well like follows.
+commands as well by using `_fzf_setup_completion` helper function.
 
 ```sh
-# There are also _fzf_path_completion and _fzf_dir_completion
+# usage: _fzf_setup_completion path|dir|var|alias|host COMMANDS...
-complete -F _fzf_file_completion -o default -o bashdefault doge
+_fzf_setup_completion path ag git kubectl
+_fzf_setup_completion dir tree
 ```
 
-Usage as Vim plugin
+#### Custom fuzzy completion
--------------------
 
-This repository only enables basic integration with Vim. If you're looking for
+_**(Custom completion API is experimental and subject to change)**_
-more, check out [fzf.vim](https://github.com/junegunn/fzf.vim) project.
 
-(Note: To use fzf in GVim, an external terminal emulator is required.)
+For a command named _"COMMAND"_, define `_fzf_complete_COMMAND` function using
+`_fzf_complete` helper.
 
-#### `:FZF[!]`
+```sh
-
+# Custom fuzzy completion for "doge" command
-If you have set up fzf for Vim, `:FZF` command will be added.
+#   e.g. doge **<TAB>
-
+_fzf_complete_doge() {
-```vim
+  _fzf_complete --multi --reverse --prompt="doge> " -- "$@" < <(
-" Look for files under current directory
+    echo very
-:FZF
+    echo wow
-
+    echo such
-" Look for files under your home directory
+    echo doge
-:FZF ~
+  )
-
+}
-" With options
-:FZF --no-sort -m /tmp
-
-" Bang version starts in fullscreen instead of using tmux pane or Neovim split
-:FZF!
 ```
 
-Similarly to [ctrlp.vim](https://github.com/kien/ctrlp.vim), use enter key,
+- The arguments before `--` are the options to fzf.
-`CTRL-T`, `CTRL-X` or `CTRL-V` to open selected files in the current window,
+- After `--`, simply pass the original completion arguments unchanged (`"$@"`).
-in new tabs, in horizontal splits, or in vertical splits respectively.
+- Then, write a set of commands that generates the completion candidates and
+  feed its output to the function using process substitution (`< <(...)`).
 
-Note that the environment variables `FZF_DEFAULT_COMMAND` and
+zsh will automatically pick up the function using the naming convention but in
-`FZF_DEFAULT_OPTS` also apply here. Refer to [the wiki page][fzf-config] for
+bash you have to manually associate the function with the command using the
-customization.
+`complete` command.
 
-[fzf-config]: https://github.com/junegunn/fzf/wiki/Configuring-FZF-command-(vim)
+```sh
+[ -n "$BASH" ] && complete -F _fzf_complete_doge -o default -o bashdefault doge
+```
 
-#### `fzf#run([options])`
+If you need to post-process the output from fzf, define
+`_fzf_complete_COMMAND_post` as follows.
 
-For more advanced uses, you can use `fzf#run()` function with the following
+```sh
-options.
+_fzf_complete_foo() {
+  _fzf_complete --multi --reverse --header-lines=3 -- "$@" < <(
+    ls -al
+  )
+}
 
-| Option name                | Type          | Description                                                      |
+_fzf_complete_foo_post() {
-| -------------------------- | ------------- | ---------------------------------------------------------------- |
+  awk '{print $NF}'
-| `source`                   | string        | External command to generate input to fzf (e.g. `find .`)        |
+}
-| `source`                   | list          | Vim list as input to fzf                                         |
-| `sink`                     | string        | Vim command to handle the selected item (e.g. `e`, `tabe`)       |
-| `sink`                     | funcref       | Reference to function to process each selected item              |
-| `sink*`                    | funcref       | Similar to `sink`, but takes the list of output lines at once    |
-| `options`                  | string        | Options to fzf                                                   |
-| `dir`                      | string        | Working directory                                                |
-| `up`/`down`/`left`/`right` | number/string | Use tmux pane with the given size (e.g. `20`, `50%`)             |
-| `window` (*Neovim only*)   | string        | Command to open fzf window (e.g. `vertical aboveleft 30new`)     |
-| `launcher`                 | string        | External terminal emulator to start fzf with (GVim only)         |
-| `launcher`                 | funcref       | Function for generating `launcher` string (GVim only)            |
 
-Examples can be found on [the wiki
+[ -n "$BASH" ] && complete -F _fzf_complete_foo -o default -o bashdefault foo
-page](https://github.com/junegunn/fzf/wiki/Examples-(vim)).
+```
+
+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 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 because it 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 a 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.17.0.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.
+
+### Reloading the candidate list
+
+By binding `reload` action to a key or an event, you can make fzf dynamically
+reload the candidate list. See https://github.com/junegunn/fzf/issues/1750 for
+more details.
+
+#### 1. Update the list of processes by pressing CTRL-R
+
+```sh
+FZF_DEFAULT_COMMAND='ps -ef' \
+  fzf --bind 'ctrl-r:reload($FZF_DEFAULT_COMMAND)' \
+      --header 'Press CTRL-R to reload' --header-lines=1 \
+      --height=50% --layout=reverse
+```
+
+#### 2. Switch between sources by pressing CTRL-D or CTRL-F
+
+```sh
+FZF_DEFAULT_COMMAND='find . -type f' \
+  fzf --bind 'ctrl-d:reload(find . -type d),ctrl-f:reload($FZF_DEFAULT_COMMAND)' \
+      --height=50% --layout=reverse
+```
+
+#### 3. Interactive ripgrep integration
+
+The following example uses fzf as the selector interface for ripgrep. We bound
+`reload` action to `change` event, so every time you type on fzf, the ripgrep
+process will restart with the updated query string denoted by the placeholder
+expression `{q}`. Also, note that we used `--disabled` option so that fzf
+doesn't perform any secondary filtering.
+
+```sh
+INITIAL_QUERY=""
+RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+FZF_DEFAULT_COMMAND="$RG_PREFIX '$INITIAL_QUERY'" \
+  fzf --bind "change:reload:$RG_PREFIX {q} || true" \
+      --ansi --disabled --query "$INITIAL_QUERY" \
+      --height=50% --layout=reverse
+```
+
+If ripgrep doesn't find any matches, it will exit with a non-zero exit status,
+and fzf will warn you about it. To suppress the warning message, we added
+`|| true` to the command, so that it always exits with 0.
+
+### Preview window
+
+When the `--preview` option is set, fzf automatically starts an external process
+with the current line as the argument and shows the result in the split window.
+Your `$SHELL` is used to execute the command with `$SHELL -c COMMAND`.
+The window can be scrolled using the mouse or custom key bindings.
+
+```bash
+# {} is replaced with the single-quoted string of the focused line
+fzf --preview 'cat {}'
+```
+
+Preview window supports ANSI colors, so you can use any program that
+syntax-highlights the content of a file, such as
+[Bat](https://github.com/sharkdp/bat) or
+[Highlight](http://www.andre-simon.de/doku/highlight/en/highlight.php):
+
+```bash
+fzf --preview 'bat --style=numbers --color=always --line-range :500 {}'
+```
+
+You can customize the size, position, and border of the preview window using
+`--preview-window` option, and the foreground and background color of it with
+`--color` option. For example,
+
+```bash
+fzf --height 40% --layout reverse --info inline --border \
+    --preview 'file {}' --preview-window up,1,border-horizontal \
+    --color 'fg:#bbccdd,fg+:#ddeeff,bg:#334455,preview-bg:#223344,border:#778899'
+```
+
+See the man page (`man fzf`) for the full list of options.
+
+For more advanced examples, see [Key bindings for git with fzf][fzf-git]
+([code](https://gist.github.com/junegunn/8b572b8d4b5eddd8b85e5f4d40f17236)).
+
+[fzf-git]: https://junegunn.kr/2016/07/fzf-git/
+
+----
+
+Since fzf is a general-purpose text filter rather than a file finder, **it is
+not a good idea to add `--preview` option to your `$FZF_DEFAULT_OPTS`**.
+
+```sh
+# *********************
+# ** DO NOT DO THIS! **
+# *********************
+export FZF_DEFAULT_OPTS='--preview "bat --style=numbers --color=always --line-range :500 {}"'
+
+# bat doesn't work with any input other than the list of files
+ps -ef | fzf
+seq 100 | fzf
+history | fzf
+```
 
 Tips
 ----
 
-#### Rendering issues
+#### Respecting `.gitignore`
 
-If you have any rendering issues, check the following:
+You can use [fd](https://github.com/sharkdp/fd),
-
+[ripgrep](https://github.com/BurntSushi/ripgrep), or [the silver
-1. Make sure `$TERM` is correctly set. fzf will use 256-color only if it
+searcher](https://github.com/ggreer/the_silver_searcher) instead of the
-   contains `256` (e.g. `xterm-256color`)
+default find command to traverse the file system while respecting
-2. If you're on screen or tmux, `$TERM` should be either `screen` or
+`.gitignore`.
-   `screen-256color`
-3. Some terminal emulators (e.g. mintty) have problem displaying default
-   background color and make some text unable to read. In that case, try
-   `--black` option. And if it solves your problem, I recommend including it
-   in `FZF_DEFAULT_OPTS` for further convenience.
-4. If you still have problem, try `--no-256` option or even `--no-color`.
-
-#### 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
-filtering:
 
 ```sh
-# Feed the output of ag into fzf
+# Feed the output of fd into fzf
-ag -g "" | fzf
+fd --type f | fzf
 
-# Setting ag as the default source for fzf
+# Setting fd as the default source for fzf
-export FZF_DEFAULT_COMMAND='ag -g ""'
+export FZF_DEFAULT_COMMAND='fd --type f'
 
-# Now fzf (w/o pipe) will use ag instead of find
+# Now fzf (w/o pipe) will use fd instead of find
 fzf
 
 # To apply the command to CTRL-T as well
 export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"
 ```
 
-#### `git ls-tree` for fast traversal
+If you want the command to follow symbolic links and don't want it to exclude
-
+hidden files, use the following command:
-If you're running fzf in a large git repository, `git ls-tree` can boost up the
-speed of the traversal.
 
 ```sh
-export FZF_DEFAULT_COMMAND='
+export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
-  (git ls-tree -r --name-only HEAD ||
-   find . -path "*/\.*" -prune -o -type f -print -o -type l -print |
-      sed s/^..//) 2> /dev/null'
 ```
 
 #### Fish shell
 
-It's [a known bug of fish](https://github.com/fish-shell/fish-shell/issues/1362)
+`CTRL-T` key binding of fish, unlike those of bash and zsh, will use the last
-that it doesn't allow reading from STDIN in command substitution, which means
+token on the command-line as the root directory for the recursive search. For
-simple `vim (fzf)` won't work as expected. The workaround is to store the result
+instance, hitting `CTRL-T` at the end of the following command-line
-of fzf to a temporary file.
 
 ```sh
-fzf > $TMPDIR/fzf.result; and vim (cat $TMPDIR/fzf.result)
+ls /var/
 ```
 
-License
+will list all files and directories under `/var/`.
--------
 
-[MIT](LICENSE)
+When using a custom `FZF_CTRL_T_COMMAND`, use the unexpanded `$dir` variable to
+make use of this feature. `$dir` defaults to `.` when the last token is not a
+valid directory. Example:
 
-Author
+```sh
-------
+set -g FZF_CTRL_T_COMMAND "command find -L \$dir -type f 2> /dev/null | sed '1d; s#^\./##'"
+```
 
-Junegunn Choi
+Related projects
+----------------
+
+https://github.com/junegunn/fzf/wiki/Related-projects
+
+[License](LICENSE)
+------------------
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2021 Junegunn Choi

bin/fzf-tmux

@@ -1,27 +1,65 @@
 #!/usr/bin/env bash
 # fzf-tmux: starts fzf in a tmux pane
-# usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
+# usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
 
+fail() {
+  >&2 echo "$1"
+  exit 2
+}
+
+fzf="$(command -v fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
+[[ -x "$fzf" ]] || fail 'fzf executable not found'
+
+tmux_args=()
 args=()
 opt=""
 skip=""
 swap=""
 close=""
 term=""
-[ -n "$LINES" ] && lines=$LINES || lines=$(tput lines)
+[[ -n "$LINES" ]] && lines=$LINES || lines=$(tput lines) || lines=$(tmux display-message -p "#{pane_height}")
-while [ $# -gt 0 ]; do
+[[ -n "$COLUMNS" ]] && columns=$COLUMNS || columns=$(tput cols) || columns=$(tmux display-message -p "#{pane_width}")
+
+help() {
+  >&2 echo 'usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
+
+  LAYOUT OPTIONS:
+    (default layout: -d 50%)
+
+    Popup window (requires tmux 3.2 or above):
+      -p [WIDTH[%][,HEIGHT[%]]]  (default: 50%)
+      -w WIDTH[%]
+      -h HEIGHT[%]
+      -x COL
+      -y ROW
+
+    Split pane:
+      -u [HEIGHT[%]]             Split above (up)
+      -d [HEIGHT[%]]             Split below (down)
+      -l [WIDTH[%]]              Split left
+      -r [WIDTH[%]]              Split right
+'
+  exit
+}
+
+while [[ $# -gt 0 ]]; do
   arg="$1"
-  case "$arg" in
+  shift
+  [[ -z "$skip" ]] && case "$arg" in
     -)
       term=1
       ;;
-    -w*|-h*|-d*|-u*|-r*|-l*)
+    --help)
-      if [ -n "$skip" ]; then
+      help
-        args+=("$1")
+      ;;
-        shift
+    --version)
-        continue
+      echo "fzf-tmux (with fzf $("$fzf" --version))"
-      fi
+      exit
-      if [[ "$arg" =~ ^.[lrw] ]]; then
+      ;;
+    -p*|-w*|-h*|-x*|-y*|-d*|-u*|-r*|-l*)
+      if [[ "$arg" =~ ^-[pwhxy] ]]; then
+        [[ "$opt" =~ "-K -E" ]] || opt="-K -E"
+      elif [[ "$arg" =~ ^.[lr] ]]; then
         opt="-h"
         if [[ "$arg" =~ ^.l ]]; then
           opt="$opt -d"
@@ -36,35 +74,41 @@ while [ $# -gt 0 ]; do
           close="; tmux swap-pane -D"
         fi
       fi
-      if [ ${#arg} -gt 2 ]; then
+      if [[ ${#arg} -gt 2 ]]; then
         size="${arg:2}"
       else
-        shift
+        if [[ "$1" =~ ^[0-9%,]+$ ]] || [[ "$1" =~ ^[A-Z]$ ]]; then
-        if [[ "$1" =~ ^[0-9]+%?$ ]]; then
           size="$1"
-        else
-          [ -n "$1" -a "$1" != "--" ] && args+=("$1")
           shift
+        else
           continue
         fi
       fi
 
-      if [[ "$size" =~ %$ ]]; then
+      if [[ "$arg" =~ ^-p ]]; then
+        if [[ -n "$size" ]]; then
+          w=${size%%,*}
+          h=${size##*,}
+          opt="$opt -w$w -h$h"
+        fi
+      elif [[ "$arg" =~ ^-[whxy] ]]; then
+        opt="$opt ${arg:0:2}$size"
+      elif [[ "$size" =~ %$ ]]; then
         size=${size:0:((${#size}-1))}
-        if [ -n "$swap" ]; then
+        if [[ -n "$swap" ]]; then
           opt="$opt -p $(( 100 - size ))"
         else
           opt="$opt -p $size"
         fi
       else
-        if [ -n "$swap" ]; then
+        if [[ -n "$swap" ]]; then
           if [[ "$arg" =~ ^.l ]]; then
-            [ -n "$COLUMNS" ] && max=$COLUMNS || max=$(tput cols)
+            max=$columns
           else
             max=$lines
           fi
           size=$(( max - size ))
-          [ $size -lt 0 ] && size=0
+          [[ $size -lt 0 ]] && size=0
           opt="$opt -l $size"
         else
           opt="$opt -l $size"
@@ -75,24 +119,30 @@ while [ $# -gt 0 ]; do
       # "--" can be used to separate fzf-tmux options from fzf options to
       # avoid conflicts
       skip=1
+      tmux_args=("${args[@]}")
+      args=()
+      continue
       ;;
     *)
-      args+=("$1")
+      args+=("$arg")
       ;;
   esac
-  shift
+  [[ -n "$skip" ]] && args+=("$arg")
 done
 
-if ! [ -n "$TMUX" -a "$lines" -gt 15 ]; then
+if [[ -z "$TMUX" ]]; then
-  fzf "${args[@]}"
+  "$fzf" "${args[@]}"
   exit $?
 fi
 
-# Handle zoomed tmux pane by moving it to a temp window
+# --height option is not allowed. CTRL-Z is also disabled.
-if tmux list-panes -F '#F' | grep -q Z; then
+args=("${args[@]}" "--no-height" "--bind=ctrl-z:ignore")
-  zoomed=1
+
+# Handle zoomed tmux pane without popup options by moving it to a temp window
+if [[ ! "$opt" =~ "-K -E" ]] && tmux list-panes -F '#F' | grep -q Z; then
+  zoomed_without_popup=1
   original_window=$(tmux display-message -p "#{window_id}")
-  tmp_window=$(tmux new-window -d -P -F "#{window_id}" "bash -c 'while :; do for c in \\| / - \\\\; do sleep 0.2; printf \"\\r\$c fzf-tmux is running\\r\"; done; done'")
+  tmp_window=$(tmux new-window -d -P -F "#{window_id}" "bash -c 'while :; do for c in \\| / - '\\;' do sleep 0.2; printf \"\\r\$c fzf-tmux is running\\r\"; done; done'")
   tmux swap-pane -t $tmp_window \; select-window -t $tmp_window
 fi
 
@@ -104,58 +154,80 @@ argsf="${TMPDIR:-/tmp}/fzf-args-$id"
 fifo1="${TMPDIR:-/tmp}/fzf-fifo1-$id"
 fifo2="${TMPDIR:-/tmp}/fzf-fifo2-$id"
 fifo3="${TMPDIR:-/tmp}/fzf-fifo3-$id"
+tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
 cleanup() {
-  rm -f $argsf $fifo1 $fifo2 $fifo3
+  \rm -f $argsf $fifo1 $fifo2 $fifo3
 
-  # Remove temp window if we were zoomed
+  # Restore tmux window options
-  if [ -n "$zoomed" ]; then
+  if [[ "${#tmux_win_opts[@]}" -gt 0 ]]; then
+    eval "tmux ${tmux_win_opts[*]}"
+  fi
+
+  # Remove temp window if we were zoomed without popup options
+  if [[ -n "$zoomed_without_popup" ]]; then
+    tmux display-message -p "#{window_id}" > /dev/null
     tmux swap-pane -t $original_window \; \
       select-window -t $original_window \; \
       kill-window -t $tmp_window \; \
       resize-pane -Z
   fi
+
+  if [[ $# -gt 0 ]]; then
+    trap - EXIT
+    exit 130
+  fi
 }
-trap cleanup EXIT SIGINT SIGTERM
+trap 'cleanup 1' SIGUSR1
+trap 'cleanup' EXIT
 
-fail() {
+envs="export TERM=$TERM "
-  >&2 echo "$1"
+[[ "$opt" =~ "-K -E" ]] && FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
-  exit 2
+[[ -n "$FZF_DEFAULT_OPTS"    ]] && envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
-}
+[[ -n "$FZF_DEFAULT_COMMAND" ]] && envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
-fzf="$(which fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
+echo "$envs;" > "$argsf"
-[ -x "$fzf" ] || fail "fzf executable not found"
-
-envs="env TERM=$TERM "
-[ -n "$FZF_DEFAULT_OPTS"    ] && envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
-[ -n "$FZF_DEFAULT_COMMAND" ] && envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
-
-mkfifo -m o+w $fifo2
-mkfifo -m o+w $fifo3
 
 # Build arguments to fzf
-opts=""
+opts=$(printf "%q " "${args[@]}")
-for arg in "${args[@]}"; do
-  arg="${arg//\\/\\\\}"
-  arg="${arg//\"/\\\"}"
-  arg="${arg//\`/\\\`}"
-  arg="${arg//$/\\$}"
-  opts="$opts \"$arg\""
-done
 
-if [ -n "$term" -o -t 0 ]; then
+pppid=$$
-  cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" > $argsf
+echo -n "trap 'kill -SIGUSR1 -$pppid' EXIT SIGINT SIGTERM;" >> $argsf
-  tmux set-window-option synchronize-panes off \;\
+close="; trap - EXIT SIGINT SIGTERM $close"
-    set-window-option remain-on-exit off \;\
+
-    split-window $opt "cd $(printf %q "$PWD");$envs bash $argsf" $swap \
+export TMUX=$(cut -d , -f 1,2 <<< "$TMUX")
-    > /dev/null 2>&1
+mkfifo -m o+w $fifo2
+if [[ "$opt" =~ "-K -E" ]]; then
+  cat $fifo2 &
+  if [[ -n "$term" ]] || [[ -t 0 ]]; then
+    cat <<< "\"$fzf\" $opts > $fifo2; out=\$? $close; exit \$out" >> $argsf
+  else
+    mkfifo $fifo1
+    cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; out=\$? $close; exit \$out" >> $argsf
+    cat <&0 > $fifo1 &
+  fi
+
+  # tmux dropped the support for `-K`, `-R` to popup command
+  #   TODO: We can remove this once tmux 3.2 is released
+  if [[ ! "$(tmux popup --help 2>&1)" =~ '-R shell-command' ]]; then
+    opt="${opt/-K/}"
+  else
+    opt="${opt} -R"
+  fi
+
+  tmux popup -d "$PWD" "${tmux_args[@]}" $opt "bash $argsf" > /dev/null 2>&1
+  exit $?
+fi
+
+mkfifo -m o+w $fifo3
+if [[ -n "$term" ]] || [[ -t 0 ]]; then
+  cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" >> $argsf
 else
   mkfifo $fifo1
-  cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" > $argsf
+  cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" >> $argsf
-  tmux set-window-option synchronize-panes off \;\
-    set-window-option remain-on-exit off \;\
-    split-window $opt "$envs bash $argsf" $swap \
-    > /dev/null 2>&1
   cat <&0 > $fifo1 &
 fi
+tmux set-window-option synchronize-panes off \;\
+  set-window-option remain-on-exit off \;\
+  split-window -c "$PWD" $opt "${tmux_args[@]}" "bash -c 'exec -a fzf bash $argsf'" $swap \
+  > /dev/null 2>&1 || { "$fzf" "${args[@]}"; exit $?; }
 cat $fifo2
 exit "$(cat $fifo3)"
-

doc/fzf.txt

@@ -0,0 +1,512 @@
+fzf.txt	fzf	Last change: May 19 2021
+FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
+==============================================================================
+
+  FZF Vim integration                       |fzf-vim-integration|
+    Installation                            |fzf-installation|
+    Summary                                 |fzf-summary|
+    :FZF[!]                                 |:FZF|
+      Configuration                         |fzf-configuration|
+        Examples                            |fzf-examples|
+          Explanation of g:fzf_colors       |fzf-explanation-of-gfzfcolors|
+    fzf#run                                 |fzf#run|
+    fzf#wrap                                |fzf#wrap|
+      Global options supported by fzf#wrap  |fzf-global-options-supported-by-fzf#wrap|
+    Tips                                    |fzf-tips|
+      fzf inside terminal buffer            |fzf-inside-terminal-buffer|
+      Starting fzf in a popup window        |fzf-starting-fzf-in-a-popup-window|
+      Hide statusline                       |fzf-hide-statusline|
+    License                                 |fzf-license|
+
+FZF VIM INTEGRATION                                        *fzf-vim-integration*
+==============================================================================
+
+
+INSTALLATION                                                  *fzf-installation*
+==============================================================================
+
+Once you have fzf installed, you can enable it inside Vim simply by adding the
+directory to 'runtimepath' in your Vim configuration file. The path may differ
+depending on the package manager.
+>
+    " If installed using Homebrew
+    set rtp+=/usr/local/opt/fzf
+
+    " If installed using git
+    set rtp+=~/.fzf
+<
+If you use {vim-plug}{1}, the same can be written as:
+>
+    " If installed using Homebrew
+    Plug '/usr/local/opt/fzf'
+
+    " If installed using git
+    Plug '~/.fzf'
+<
+But if you want the latest Vim plugin file from GitHub rather than the one
+included in the package, write:
+>
+    Plug 'junegunn/fzf'
+<
+The Vim plugin will pick up fzf binary available on the system. If fzf is not
+found on `$PATH`, it will ask you if it should download the latest binary for
+you.
+
+To make sure that you have the latest version of the binary, set up
+post-update hook like so:
+
+                                                                   *fzf#install*
+>
+    Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+<
+                                      {1} https://github.com/junegunn/vim-plug
+
+
+SUMMARY                                                            *fzf-summary*
+==============================================================================
+
+The Vim plugin of fzf provides two core functions, and `:FZF` command which is
+the basic file selector command built on top of them.
+
+ 1. `fzf#run([spec dict])`
+   - Starts fzf inside Vim with the given spec
+   - `:call fzf#run({'source': 'ls'})`
+ 2. `fzf#wrap([spec dict]) -> (dict)`
+   - Takes a spec for `fzf#run` and returns an extended version of it with
+     additional options for addressing global preferences (`g:fzf_xxx`)
+     - `:echo fzf#wrap({'source': 'ls'})`
+   - We usually wrap a spec with `fzf#wrap` before passing it to `fzf#run`
+     - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
+ 3. `:FZF [fzf_options string] [path string]`
+   - Basic fuzzy file selector
+   - A reference implementation for those who don't want to write VimScript to
+     implement custom commands
+   - If you're looking for more such commands, check out {fzf.vim}{2} project.
+
+The most important of all is `fzf#run`, but it would be easier to understand
+the whole if we start off with `:FZF` command.
+
+                                       {2} https://github.com/junegunn/fzf.vim
+
+
+:FZF[!]
+==============================================================================
+
+                                                                          *:FZF*
+>
+    " Look for files under current directory
+    :FZF
+
+    " Look for files under your home directory
+    :FZF ~
+
+    " With fzf command-line options
+    :FZF --reverse --info=inline /tmp
+
+    " Bang version starts fzf in fullscreen mode
+    :FZF!
+<
+Similarly to {ctrlp.vim}{3}, use enter key, CTRL-T, CTRL-X or CTRL-V to open
+selected files in the current window, in new tabs, in horizontal splits, or in
+vertical splits respectively.
+
+Note that the environment variables `FZF_DEFAULT_COMMAND` and
+`FZF_DEFAULT_OPTS` also apply here.
+
+                                         {3} https://github.com/kien/ctrlp.vim
+
+
+< Configuration >_____________________________________________________________~
+                                                             *fzf-configuration*
+
+                      *g:fzf_action* *g:fzf_layout* *g:fzf_colors* *g:fzf_history_dir*
+
+ - `g:fzf_action`
+   - Customizable extra key bindings for opening selected files in different
+     ways
+ - `g:fzf_layout`
+   - Determines the size and position of fzf window
+ - `g:fzf_colors`
+   - Customizes fzf colors to match the current color scheme
+ - `g:fzf_history_dir`
+   - Enables history feature
+
+
+Examples~
+                                                                  *fzf-examples*
+>
+    " This is the default extra key bindings
+    let g:fzf_action = {
+      \ 'ctrl-t': 'tab split',
+      \ '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
+    " - Popup window (center of the screen)
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+
+    " - Popup window (center of the current window)
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true } }
+
+    " - Popup window (anchored to the bottom of the current window)
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true, 'yoffset': 1.0 } }
+
+    " - down / up / left / right
+    let g:fzf_layout = { 'down': '40%' }
+
+    " - Window using a Vim command
+    let g:fzf_layout = { 'window': 'enew' }
+    let g:fzf_layout = { 'window': '-tabnew' }
+    let g:fzf_layout = { 'window': '10new' }
+
+    " Customize fzf colors to match your color scheme
+    " - fzf#wrap translates this to a set of `--color` options
+    let g:fzf_colors =
+    \ { 'fg':      ['fg', 'Normal'],
+      \ 'bg':      ['bg', 'Normal'],
+      \ 'hl':      ['fg', 'Comment'],
+      \ 'fg+':     ['fg', 'CursorLine', 'CursorColumn', 'Normal'],
+      \ 'bg+':     ['bg', 'CursorLine', 'CursorColumn'],
+      \ 'hl+':     ['fg', 'Statement'],
+      \ 'info':    ['fg', 'PreProc'],
+      \ 'border':  ['fg', 'Ignore'],
+      \ 'prompt':  ['fg', 'Conditional'],
+      \ 'pointer': ['fg', 'Exception'],
+      \ 'marker':  ['fg', 'Keyword'],
+      \ 'spinner': ['fg', 'Label'],
+      \ 'header':  ['fg', 'Comment'] }
+
+    " Enable per-command history
+    " - History files will be stored in the specified directory
+    " - When set, CTRL-N and CTRL-P will be bound to 'next-history' and
+    "   'previous-history' instead of 'down' and 'up'.
+    let g:fzf_history_dir = '~/.local/share/fzf-history'
+<
+
+Explanation of g:fzf_colors~
+                                                 *fzf-explanation-of-gfzfcolors*
+
+`g:fzf_colors` is a dictionary mapping fzf elements to a color specification
+list:
+>
+    element: [ component, group1 [, group2, ...] ]
+<
+ - `element` is an fzf element to apply a color to:
+
+ ----------------------------+------------------------------------------------------
+ Element                     | Description                                          ~
+ ----------------------------+------------------------------------------------------
+  `fg`   /  `bg`   /  `hl`         | Item (foreground / background / highlight)
+  `fg+`  /  `bg+`  /  `hl+`        | Current item (foreground / background / highlight)
+  `preview-fg`  /  `preview-bg`  | Preview window text and background
+  `hl`   /  `hl+`                | Highlighted substrings (normal / current)
+  `gutter`                     | Background of the gutter on the left
+  `pointer`                    | Pointer to the current line ( `>` )
+  `marker`                     | Multi-select marker ( `>` )
+  `border`                     | Border around the window ( `--border`  and  `--preview` )
+  `header`                     | Header ( `--header`  or  `--header-lines` )
+  `info`                       | Info line (match counters)
+  `spinner`                    | Streaming input indicator
+  `query`                      | Query string
+  `disabled`                   | Query string when search is disabled
+  `prompt`                     | Prompt before query ( `> ` )
+  `pointer`                    | Pointer to the current line ( `>` )
+ ----------------------------+------------------------------------------------------
+ - `component` specifies the component (`fg` / `bg`) from which to extract the
+   color when considering each of the following highlight groups
+ - `group1 [, group2, ...]` is a list of highlight groups that are searched (in
+   order) for a matching color definition
+
+For example, consider the following specification:
+>
+      'prompt':  ['fg', 'Conditional', 'Comment'],
+<
+This means we color the prompt - using the `fg` attribute of the `Conditional`
+if it exists, - otherwise use the `fg` attribute of the `Comment` highlight
+group if it exists, - otherwise fall back to the default color settings for
+the prompt.
+
+You can examine the color option generated according the setting by printing
+the result of `fzf#wrap()` function like so:
+>
+    :echo fzf#wrap()
+<
+
+FZF#RUN
+==============================================================================
+
+                                                                       *fzf#run*
+
+`fzf#run()` function is the core of Vim integration. It takes a single
+dictionary argument, a spec, and starts fzf process accordingly. At the very
+least, specify `sink` option to tell what it should do with the selected
+entry.
+>
+    call fzf#run({'sink': 'e'})
+<
+We haven't specified the `source`, so this is equivalent to starting fzf on
+command line without standard input pipe; fzf will use find command (or
+`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
+directory. When you select one, it will open it with the sink, `:e` command.
+If you want to open it in a new tab, you can pass `:tabedit` command instead
+as the sink.
+>
+    call fzf#run({'sink': 'tabedit'})
+<
+Instead of using the default find command, you can use any shell command as
+the source. The following example will list the files managed by git. It's
+equivalent to running `git ls-files | fzf` on shell.
+>
+    call fzf#run({'source': 'git ls-files', 'sink': 'e'})
+<
+fzf options can be specified as `options` entry in spec dictionary.
+>
+    call fzf#run({'sink': 'tabedit', 'options': '--multi --reverse'})
+<
+You can also pass a layout option if you don't want fzf window to take up the
+entire screen.
+>
+    " up / down / left / right / window are allowed
+    call fzf#run({'source': 'git ls-files', 'sink': 'e', 'left': '40%'})
+    call fzf#run({'source': 'git ls-files', 'sink': 'e', 'window': '30vnew'})
+<
+`source` doesn't have to be an external shell command, you can pass a Vim
+array as the source. In the next example, we pass the names of color schemes
+as the source to implement a color scheme selector.
+>
+    call fzf#run({'source': map(split(globpath(&rtp, 'colors/*.vim')),
+                \               'fnamemodify(v:val, ":t:r")'),
+                \ 'sink': 'colo', 'left': '25%'})
+<
+The following table summarizes the available options.
+
+ ---------------------------+---------------+----------------------------------------------------------------------
+ Option name                | Type          | Description                                                          ~
+ ---------------------------+---------------+----------------------------------------------------------------------
+  `source`                    | string        | External command to generate input to fzf (e.g.  `find .` )
+  `source`                    | list          | Vim list as input to fzf
+  `sink`                      | string        | Vim command to handle the selected item (e.g.  `e` ,  `tabe` )
+  `sink`                      | funcref       | Reference to function to process each selected item
+  `sinklist`  (or  `sink*` )    | funcref       | Similar to  `sink` , but takes the list of output lines at once
+  `options`                   | string/list   | Options to fzf
+  `dir`                       | string        | Working directory
+  `up` / `down` / `left` / `right`  | number/string | (Layout) Window position and size (e.g.  `20` ,  `50%` )
+  `tmux`                      | string        | (Layout) fzf-tmux options (e.g.  `-p90%,60%` )
+  `window`  (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g.  `vertical aboveleft 30new` )
+  `window`  (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g.  `{'width': 0.9, 'height': 0.6}` )
+ ---------------------------+---------------+----------------------------------------------------------------------
+
+`options` entry can be either a string or a list. For simple cases, string
+should suffice, but prefer to use list type to avoid escaping issues.
+>
+    call fzf#run({'options': '--reverse --prompt "C:\\Program Files\\"'})
+    call fzf#run({'options': ['--reverse', '--prompt', 'C:\Program Files\']})
+<
+When `window` entry is a dictionary, fzf will start in a popup window. The
+following options are allowed:
+
+ - Required:
+   - `width` [float range [0 ~ 1]] or [integer range [8 ~ ]]
+   - `height` [float range [0 ~ 1]] or [integer range [4 ~ ]]
+ - Optional:
+   - `yoffset` [float default 0.5 range [0 ~ 1]]
+   - `xoffset` [float default 0.5 range [0 ~ 1]]
+   - `relative` [boolean default v:false]
+   - `border` [string default `rounded`]: Border style
+     - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right` / `no[ne]`
+
+
+FZF#WRAP
+==============================================================================
+
+                                                                      *fzf#wrap*
+
+We have seen that several aspects of `:FZF` command can be configured with a
+set of global option variables; different ways to open files (`g:fzf_action`),
+window position and size (`g:fzf_layout`), color palette (`g:fzf_colors`),
+etc.
+
+So how can we make our custom `fzf#run` calls also respect those variables?
+Simply by "wrapping" the spec dictionary with `fzf#wrap` before passing it to
+`fzf#run`.
+
+ - `fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`
+   - All arguments are optional. Usually we only need to pass a spec
+     dictionary.
+   - `name` is for managing history files. It is ignored if `g:fzf_history_dir`
+     is not defined.
+   - `fullscreen` can be either `0` or `1` (default: 0).
+
+`fzf#wrap` takes a spec and returns an extended version of it (also a
+dictionary) with additional options for addressing global preferences. You can
+examine the return value of it like so:
+>
+    echo fzf#wrap({'source': 'ls'})
+<
+After we "wrap" our spec, we pass it to `fzf#run`.
+>
+    call fzf#run(fzf#wrap({'source': 'ls'}))
+<
+Now it supports CTRL-T, CTRL-V, and CTRL-X key bindings (configurable via
+`g:fzf_action`) and it opens fzf window according to `g:fzf_layout` setting.
+
+To make it easier to use, let's define `LS` command.
+>
+    command! LS call fzf#run(fzf#wrap({'source': 'ls'}))
+<
+Type `:LS` and see how it works.
+
+We would like to make `:LS!` (bang version) open fzf in fullscreen, just like
+`:FZF!`. Add `-bang` to command definition, and use <bang> value to set the
+last `fullscreen` argument of `fzf#wrap` (see :help <bang>).
+>
+    " On :LS!, <bang> evaluates to '!', and '!0' becomes 1
+    command! -bang LS call fzf#run(fzf#wrap({'source': 'ls'}, <bang>0))
+<
+Our `:LS` command will be much more useful if we can pass a directory argument
+to it, so that something like `:LS /tmp` is possible.
+>
+    command! -bang -complete=dir -nargs=? LS
+        \ call fzf#run(fzf#wrap({'source': 'ls', 'dir': <q-args>}, <bang>0))
+<
+Lastly, if you have enabled `g:fzf_history_dir`, you might want to assign a
+unique name to our command and pass it as the first argument to `fzf#wrap`.
+>
+    " The query history for this command will be stored as 'ls' inside g:fzf_history_dir.
+    " The name is ignored if g:fzf_history_dir is not defined.
+    command! -bang -complete=dir -nargs=? LS
+        \ call fzf#run(fzf#wrap('ls', {'source': 'ls', 'dir': <q-args>}, <bang>0))
+<
+
+< Global options supported by fzf#wrap >______________________________________~
+                                      *fzf-global-options-supported-by-fzf#wrap*
+
+ - `g:fzf_layout`
+ - `g:fzf_action`
+   - Works only when no custom `sink` (or `sink*`) is provided
+     - Having custom sink usually means that each entry is not an ordinary
+       file path (e.g. name of color scheme), so we can't blindly apply the
+       same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
+ - `g:fzf_colors`
+ - `g:fzf_history_dir`
+
+
+TIPS                                                                  *fzf-tips*
+==============================================================================
+
+
+< fzf inside terminal buffer >________________________________________________~
+                                                    *fzf-inside-terminal-buffer*
+
+The latest versions of Vim and Neovim include builtin terminal emulator
+(`:terminal`) and fzf will start in a terminal buffer in the following cases:
+
+ - On Neovim
+ - On GVim
+ - On Terminal Vim with a non-default layout
+   - `call fzf#run({'left': '30%'})` or `let g:fzf_layout = {'left': '30%'}`
+
+On the latest versions of Vim and Neovim, fzf will start in a terminal buffer.
+If you find the default ANSI colors to be different, consider configuring the
+colors using `g:terminal_ansi_colors` in regular Vim or `g:terminal_color_x`
+in Neovim.
+
+                   *g:terminal_color_15* *g:terminal_color_14* *g:terminal_color_13*
+*g:terminal_color_12* *g:terminal_color_11* *g:terminal_color_10* *g:terminal_color_9*
+   *g:terminal_color_8* *g:terminal_color_7* *g:terminal_color_6* *g:terminal_color_5*
+   *g:terminal_color_4* *g:terminal_color_3* *g:terminal_color_2* *g:terminal_color_1*
+                                                            *g:terminal_color_0*
+>
+    " Terminal colors for seoul256 color scheme
+    if has('nvim')
+      let g:terminal_color_0 = '#4e4e4e'
+      let g:terminal_color_1 = '#d68787'
+      let g:terminal_color_2 = '#5f865f'
+      let g:terminal_color_3 = '#d8af5f'
+      let g:terminal_color_4 = '#85add4'
+      let g:terminal_color_5 = '#d7afaf'
+      let g:terminal_color_6 = '#87afaf'
+      let g:terminal_color_7 = '#d0d0d0'
+      let g:terminal_color_8 = '#626262'
+      let g:terminal_color_9 = '#d75f87'
+      let g:terminal_color_10 = '#87af87'
+      let g:terminal_color_11 = '#ffd787'
+      let g:terminal_color_12 = '#add4fb'
+      let g:terminal_color_13 = '#ffafaf'
+      let g:terminal_color_14 = '#87d7d7'
+      let g:terminal_color_15 = '#e4e4e4'
+    else
+      let g:terminal_ansi_colors = [
+        \ '#4e4e4e', '#d68787', '#5f865f', '#d8af5f',
+        \ '#85add4', '#d7afaf', '#87afaf', '#d0d0d0',
+        \ '#626262', '#d75f87', '#87af87', '#ffd787',
+        \ '#add4fb', '#ffafaf', '#87d7d7', '#e4e4e4'
+      \ ]
+    endif
+<
+
+< Starting fzf in a popup window >____________________________________________~
+                                            *fzf-starting-fzf-in-a-popup-window*
+>
+    " Required:
+    " - width [float range [0 ~ 1]] or [integer range [8 ~ ]]
+    " - height [float range [0 ~ 1]] or [integer range [4 ~ ]]
+    "
+    " Optional:
+    " - xoffset [float default 0.5 range [0 ~ 1]]
+    " - yoffset [float default 0.5 range [0 ~ 1]]
+    " - relative [boolean default v:false]
+    " - border [string default 'rounded']: Border style
+    "   - 'rounded' / 'sharp' / 'horizontal' / 'vertical' / 'top' / 'bottom' / 'left' / 'right'
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+<
+Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
+or above) by putting fzf-tmux options in `tmux` key.
+>
+    " See `man fzf-tmux` for available options
+    if exists('$TMUX')
+      let g:fzf_layout = { 'tmux': '-p90%,60%' }
+    else
+      let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+    endif
+<
+
+< Hide statusline >___________________________________________________________~
+                                                           *fzf-hide-statusline*
+
+When fzf starts in a terminal buffer, the file type of the buffer is set to
+`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
+the window.
+
+For example, if you open fzf on the bottom on the screen (e.g. `{'down':
+'40%'}`), you might want to temporarily disable the statusline for a cleaner
+look.
+>
+    let g:fzf_layout = { 'down': '30%' }
+    autocmd! FileType fzf
+    autocmd  FileType fzf set laststatus=0 noshowmode noruler
+      \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
+<
+
+LICENSE                                                            *fzf-license*
+==============================================================================
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2021 Junegunn Choi
+
+==============================================================================
+vim:tw=78:sw=2:ts=2:ft=help:norl:nowrap:

go.mod

@@ -0,0 +1,17 @@
+module github.com/junegunn/fzf
+
+require (
+	github.com/gdamore/tcell v1.4.0
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-isatty v0.0.14
+	github.com/mattn/go-runewidth v0.0.13
+	github.com/mattn/go-shellwords v1.0.12
+	github.com/rivo/uniseg v0.2.0
+	github.com/saracen/walker v0.1.2
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
+	golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c
+	golang.org/x/term v0.0.0-20210317153231-de623e64d2a6
+	golang.org/x/text v0.3.6 // indirect
+)
+
+go 1.13

go.sum

@@ -0,0 +1,31 @@
+github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
+github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
+github.com/gdamore/tcell v1.4.0 h1:vUnHwJRvcPQa3tzi+0QI4U9JINXYJlOz9yiaiPQ2wMU=
+github.com/gdamore/tcell v1.4.0/go.mod h1:vxEiSDZdW3L+Uhjii9c3375IlDmR05bzxY404ZVSMo0=
+github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
+github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-shellwords v1.0.12 h1:M2zGm7EW6UQJvDeQxo4T51eKPurbeFbe8WtebGE2xrk=
+github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/saracen/walker v0.1.2 h1:/o1TxP82n8thLvmL4GpJXduYaRmJ7qXp8u9dSlV0zmo=
+github.com/saracen/walker v0.1.2/go.mod h1:0oKYMsKVhSJ+ful4p/XbjvXbMgLEkLITZaxozsl4CGE=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20210317153231-de623e64d2a6 h1:EC6+IGYTjPpRfv9a2b/6Puw0W+hLtAhkV1tPsXhutqs=
+golang.org/x/term v0.0.0-20210317153231-de623e64d2a6/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

install

@@ -2,13 +2,14 @@
 
 set -u
 
-[[ "$@" =~ --pre ]] && version=0.13.2 pre=1 ||
+version=0.29.0
-                       version=0.13.2 pre=0
-
 auto_completion=
 key_bindings=
 update_config=2
-binary_arch=
+shells="bash zsh fish"
+prefix='~/.fzf'
+prefix_expand=~/.fzf
+fish_dir=${XDG_CONFIG_HOME:-$HOME/.config}/fish
 
 help() {
   cat << EOF
@@ -18,12 +19,14 @@ usage: $0 [OPTIONS]
     --bin                Download fzf binary only; Do not generate ~/.fzf.{bash,zsh}
     --all                Download fzf binary and update configuration files
                          to enable key bindings and fuzzy completion
+    --xdg                Generate files under \$XDG_CONFIG_HOME/fzf
     --[no-]key-bindings  Enable/disable key bindings (CTRL-T, CTRL-R, ALT-C)
     --[no-]completion    Enable/disable fuzzy completion (bash & zsh)
     --[no-]update-rc     Whether or not to update shell configuration files
 
-    --32                 Download 32-bit binary
+    --no-bash            Do not set up bash configuration
-    --64                 Download 64-bit binary
+    --no-zsh             Do not set up zsh configuration
+    --no-fish            Do not set up fish configuration
 EOF
 }
 
@@ -38,15 +41,21 @@ for opt in "$@"; do
       key_bindings=1
       update_config=1
       ;;
+    --xdg)
+      prefix='"${XDG_CONFIG_HOME:-$HOME/.config}"/fzf/fzf'
+      prefix_expand=${XDG_CONFIG_HOME:-$HOME/.config}/fzf/fzf
+      mkdir -p "${XDG_CONFIG_HOME:-$HOME/.config}/fzf"
+      ;;
     --key-bindings)    key_bindings=1    ;;
     --no-key-bindings) key_bindings=0    ;;
     --completion)      auto_completion=1 ;;
     --no-completion)   auto_completion=0 ;;
     --update-rc)       update_config=1   ;;
     --no-update-rc)    update_config=0   ;;
-    --32)              binary_arch=386   ;;
+    --bin)             ;;
-    --64)              binary_arch=amd64 ;;
+    --no-bash)         shells=${shells/bash/} ;;
-    --bin|--pre)       ;;
+    --no-zsh)          shells=${shells/zsh/} ;;
+    --no-fish)         shells=${shells/fish/} ;;
     *)
       echo "unknown option: $opt"
       help
@@ -56,17 +65,19 @@ for opt in "$@"; do
 done
 
 cd "$(dirname "${BASH_SOURCE[0]}")"
-fzf_base="$(pwd)"
+fzf_base=$(pwd)
+fzf_base_esc=$(printf %q "$fzf_base")
 
 ask() {
-  # If stdin is a tty, we are "interactive".
+  while true; do
-  # non-interactive shell: wait for a linefeed
+    read -p "$1 ([y]/n) " -r
-  #     interactive shell: continue after a single keypress
+    REPLY=${REPLY:-"y"}
-  read_n=$([ -t 0 ] && echo "-n 1")
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
-
+      return 1
-  read -p "$1 ([y]/n) " $read_n -r
+    elif [[ $REPLY =~ ^[Nn]$ ]]; then
-  echo
+      return 0
-  [[ $REPLY =~ ^[Nn]$ ]]
+    fi
+  done
 }
 
 check_binary() {
@@ -76,73 +87,80 @@ check_binary() {
   if [ $? -ne 0 ]; then
     echo "Error: $output"
     binary_error="Invalid binary"
-  elif [ "$version" != "$output" ]; then
-    echo "$output != $version"
-    binary_error="Invalid version"
   else
-    echo "$output"
+    output=${output/ */}
-    binary_error=""
+    if [ "$version" != "$output" ]; then
-    return 0
+      echo "$output != $version"
+      binary_error="Invalid version"
+    else
+      echo "$output"
+      binary_error=""
+      return 0
+    fi
   fi
   rm -f "$fzf_base"/bin/fzf
   return 1
 }
 
-symlink() {
-  echo "  - Creating symlink: bin/$1 -> bin/fzf"
-  (cd "$fzf_base"/bin &&
-   rm -f fzf &&
-   ln -sf $1 fzf)
-  if [ $? -ne 0 ]; then
-    binary_error="Failed to create symlink"
-    return 1
-  fi
-}
-
 link_fzf_in_path() {
   if which_fzf="$(command -v fzf)"; then
     echo "  - Found in \$PATH"
-    echo "  - Creating symlink: $which_fzf -> bin/fzf"
+    echo "  - Creating symlink: bin/fzf -> $which_fzf"
     (cd "$fzf_base"/bin && rm -f fzf && ln -sf "$which_fzf" fzf)
     check_binary && return
   fi
   return 1
 }
 
+try_curl() {
+  command -v curl > /dev/null &&
+  if [[ $1 =~ tar.gz$ ]]; then
+    curl -fL $1 | tar -xzf -
+  else
+    local temp=${TMPDIR:-/tmp}/fzf.zip
+    curl -fLo "$temp" $1 && unzip -o "$temp" && rm -f "$temp"
+  fi
+}
+
+try_wget() {
+  command -v wget > /dev/null &&
+  if [[ $1 =~ tar.gz$ ]]; then
+    wget -O - $1 | tar -xzf -
+  else
+    local temp=${TMPDIR:-/tmp}/fzf.zip
+    wget -O "$temp" $1 && unzip -o "$temp" && rm -f "$temp"
+  fi
+}
+
 download() {
   echo "Downloading bin/fzf ..."
-  if [ $pre = 0 ]; then
+  if [ -x "$fzf_base"/bin/fzf ]; then
-    if [ -x "$fzf_base"/bin/fzf ]; then
+    echo "  - Already exists"
-      echo "  - Already exists"
+    check_binary && return
-      check_binary && return
-    fi
-    if [ -x "$fzf_base"/bin/$1 ]; then
-      symlink $1 && check_binary && return
-    fi
-    link_fzf_in_path && return
   fi
+  link_fzf_in_path && return
   mkdir -p "$fzf_base"/bin && cd "$fzf_base"/bin
   if [ $? -ne 0 ]; then
     binary_error="Failed to create bin directory"
     return
   fi
 
-  local url=https://github.com/junegunn/fzf-bin/releases/download/$version/${1}.tgz
+  local url
-  if command -v curl > /dev/null; then
+  url=https://github.com/junegunn/fzf/releases/download/$version/${1}
-    curl -fL $url | tar -xz
+  set -o pipefail
-  elif command -v wget > /dev/null; then
+  if ! (try_curl $url || try_wget $url); then
-    wget -O - $url | tar -xz
+    set +o pipefail
-  else
+    binary_error="Failed to download with curl and wget"
-    binary_error="curl or wget not found"
     return
   fi
+  set +o pipefail
 
-  if [ ! -f $1 ]; then
+  if [ ! -f fzf ]; then
     binary_error="Failed to download ${1}"
     return
   fi
 
-  chmod +x $1 && symlink $1 && check_binary
+  chmod +x fzf && check_binary
 }
 
 # Try to download binary executable
@@ -150,110 +168,62 @@ archi=$(uname -sm)
 binary_available=1
 binary_error=""
 case "$archi" in
-  Darwin\ x86_64) download fzf-$version-darwin_${binary_arch:-amd64} ;;
+  Darwin\ arm64)   download fzf-$version-darwin_arm64.zip     ;;
-  Darwin\ i*86)   download fzf-$version-darwin_${binary_arch:-386}   ;;
+  Darwin\ x86_64)  download fzf-$version-darwin_amd64.zip     ;;
-  Linux\ x86_64)  download fzf-$version-linux_${binary_arch:-amd64}  ;;
+  Linux\ armv5*)   download fzf-$version-linux_armv5.tar.gz   ;;
-  Linux\ i*86)    download fzf-$version-linux_${binary_arch:-386}    ;;
+  Linux\ armv6*)   download fzf-$version-linux_armv6.tar.gz   ;;
-  *)              binary_available=0 binary_error=1  ;;
+  Linux\ armv7*)   download fzf-$version-linux_armv7.tar.gz   ;;
+  Linux\ armv8*)   download fzf-$version-linux_arm64.tar.gz   ;;
+  Linux\ aarch64*) download fzf-$version-linux_arm64.tar.gz   ;;
+  Linux\ *64)      download fzf-$version-linux_amd64.tar.gz   ;;
+  FreeBSD\ *64)    download fzf-$version-freebsd_amd64.tar.gz ;;
+  OpenBSD\ *64)    download fzf-$version-openbsd_amd64.tar.gz ;;
+  CYGWIN*\ *64)    download fzf-$version-windows_amd64.zip    ;;
+  MINGW*\ *64)     download fzf-$version-windows_amd64.zip    ;;
+  MSYS*\ *64)      download fzf-$version-windows_amd64.zip    ;;
+  Windows*\ *64)   download fzf-$version-windows_amd64.zip    ;;
+  *)               binary_available=0 binary_error=1 ;;
 esac
 
-install_ruby_fzf() {
-  echo "Installing legacy Ruby version ..."
-
-  # ruby executable
-  echo -n "Checking Ruby executable ... "
-  ruby=$(command -v ruby)
-  if [ $? -ne 0 ]; then
-    echo "ruby executable not found !!!"
-    exit 1
-  fi
-
-  # System ruby is preferred
-  system_ruby=/usr/bin/ruby
-  if [ -x $system_ruby ] && [ $system_ruby != "$ruby" ]; then
-    $system_ruby --disable-gems -rcurses -e0 2> /dev/null
-    [ $? -eq 0 ] && ruby=$system_ruby
-  fi
-
-  echo "OK ($ruby)"
-
-  # Curses-support
-  echo -n "Checking Curses support ... "
-  "$ruby" -rcurses -e0 2> /dev/null
-  if [ $? -eq 0 ]; then
-    echo "OK"
-  else
-    echo "Not found"
-    echo "Installing 'curses' gem ... "
-    if (( EUID )); then
-      /usr/bin/env gem install curses --user-install
-    else
-      /usr/bin/env gem install curses
-    fi
-    if [ $? -ne 0 ]; then
-      echo
-      echo "Failed to install 'curses' gem."
-      if [[ $(uname -r) =~ 'ARCH' ]]; then
-        echo "Make sure that base-devel package group is installed."
-      fi
-      exit 1
-    fi
-  fi
-
-  # Ruby version
-  echo -n "Checking Ruby version ... "
-  "$ruby" -e 'exit RUBY_VERSION >= "1.9"'
-  if [ $? -eq 0 ]; then
-    echo ">= 1.9"
-    "$ruby" --disable-gems -rcurses -e0 2> /dev/null
-    if [ $? -eq 0 ]; then
-      fzf_cmd="$ruby --disable-gems $fzf_base/fzf"
-    else
-      fzf_cmd="$ruby $fzf_base/fzf"
-    fi
-  else
-    echo "< 1.9"
-    fzf_cmd="$ruby $fzf_base/fzf"
-  fi
-
-  # Create fzf script
-  echo -n "Creating wrapper script for fzf ... "
-  rm -f "$fzf_base"/bin/fzf
-  echo "#!/bin/sh" > "$fzf_base"/bin/fzf
-  echo "$fzf_cmd \"\$@\"" >> "$fzf_base"/bin/fzf
-  chmod +x "$fzf_base"/bin/fzf
-  echo "OK"
-}
-
 cd "$fzf_base"
 if [ -n "$binary_error" ]; then
   if [ $binary_available -eq 0 ]; then
     echo "No prebuilt binary for $archi ..."
-    if command -v go > /dev/null; then
-      echo -n "Building binary (go get -u github.com/junegunn/fzf/src/fzf) ... "
-      if [ -z "${GOPATH-}" ]; then
-        export GOPATH="${TMPDIR:-/tmp}/fzf-gopath"
-        mkdir -p "$GOPATH"
-      fi
-      if go get -u github.com/junegunn/fzf/src/fzf; then
-        echo "OK"
-        cp "$GOPATH/bin/fzf" "$fzf_base/bin/"
-      else
-        echo "Failed to build binary ..."
-        install_ruby_fzf
-      fi
-    else
-      echo "go executable not found. Cannot build binary ..."
-      install_ruby_fzf
-    fi
   else
     echo "  - $binary_error !!!"
+  fi
+  if command -v go > /dev/null; then
+    echo -n "Building binary (go get -u github.com/junegunn/fzf) ... "
+    if [ -z "${GOPATH-}" ]; then
+      export GOPATH="${TMPDIR:-/tmp}/fzf-gopath"
+      mkdir -p "$GOPATH"
+    fi
+    if go get -ldflags "-s -w -X main.version=$version -X main.revision=go-get" github.com/junegunn/fzf; then
+      echo "OK"
+      cp "$GOPATH/bin/fzf" "$fzf_base/bin/"
+    else
+      echo "Failed to build binary. Installation failed."
+      exit 1
+    fi
+  else
+    echo "go executable not found. Installation failed."
     exit 1
   fi
 fi
 
 [[ "$*" =~ "--bin" ]] && exit 0
 
+for s in $shells; do
+  if ! command -v "$s" > /dev/null; then
+    shells=${shells/$s/}
+  fi
+done
+
+if [[ ${#shells} -lt 3 ]]; then
+  echo "No shell configuration to be updated."
+  exit 0
+fi
+
 # Auto-completion
 if [ -z "$auto_completion" ]; then
   ask "Do you want to enable fuzzy auto-completion?"
@@ -267,11 +237,10 @@ if [ -z "$key_bindings" ]; then
 fi
 
 echo
-has_zsh=$(command -v zsh > /dev/null && echo 1 || echo 0)
-shells=$([ $has_zsh -eq 1 ] && echo "bash zsh" || echo "bash")
 for shell in $shells; do
-  echo -n "Generate ~/.fzf.$shell ... "
+  [[ "$shell" = fish ]] && continue
-  src=~/.fzf.${shell}
+  src=${prefix_expand}.${shell}
+  echo -n "Generate $src ... "
 
   fzf_completion="[[ \$- == *i* ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
   if [ $auto_completion -eq 0 ]; then
@@ -283,17 +252,11 @@ for shell in $shells; do
     fzf_key_bindings="# $fzf_key_bindings"
   fi
 
-  cat > $src << EOF
+  cat > "$src" << EOF
 # Setup fzf
 # ---------
-if [[ ! "\$PATH" == *$fzf_base/bin* ]]; then
+if [[ ! "\$PATH" == *$fzf_base_esc/bin* ]]; then
-  export PATH="\$PATH:$fzf_base/bin"
+  export PATH="\${PATH:+\${PATH}:}$fzf_base/bin"
-fi
-
-# Man path
-# --------
-if [[ ! "\$MANPATH" == *$fzf_base/man* && -d "$fzf_base/man" ]]; then
-  export MANPATH="\$MANPATH:$fzf_base/man"
 fi
 
 # Auto-completion
@@ -303,28 +266,26 @@ $fzf_completion
 # Key bindings
 # ------------
 $fzf_key_bindings
-
 EOF
   echo "OK"
 done
 
 # fish
-has_fish=$(command -v fish > /dev/null && echo 1 || echo 0)
+if [[ "$shells" =~ fish ]]; then
-if [ $has_fish -eq 1 ]; then
   echo -n "Update fish_user_paths ... "
   fish << EOF
-  echo \$fish_user_paths | grep $fzf_base/bin > /dev/null
+  echo \$fish_user_paths | \grep "$fzf_base"/bin > /dev/null
-  or set --universal fish_user_paths \$fish_user_paths $fzf_base/bin
+  or set --universal fish_user_paths \$fish_user_paths "$fzf_base"/bin
 EOF
   [ $? -eq 0 ] && echo "OK" || echo "Failed"
 
-  mkdir -p ~/.config/fish/functions
+  mkdir -p "${fish_dir}/functions"
-  if [ -e ~/.config/fish/functions/fzf.fish ]; then
+  if [ -e "${fish_dir}/functions/fzf.fish" ]; then
-    echo -n "Remove unnecessary ~/.config/fish/functions/fzf.fish ... "
+    echo -n "Remove unnecessary ${fish_dir}/functions/fzf.fish ... "
-    rm -f ~/.config/fish/functions/fzf.fish && echo "OK" || echo "Failed"
+    rm -f "${fish_dir}/functions/fzf.fish" && echo "OK" || echo "Failed"
   fi
 
-  fish_binding=~/.config/fish/functions/fzf_key_bindings.fish
+  fish_binding="${fish_dir}/functions/fzf_key_bindings.fish"
   if [ $key_bindings -ne 0 ]; then
     echo -n "Symlink $fish_binding ... "
     ln -sf "$fzf_base/shell/key-bindings.fish" \
@@ -344,20 +305,22 @@ append_line() {
   line="$2"
   file="$3"
   pat="${4:-}"
+  lno=""
 
   echo "Update $file:"
   echo "  - $line"
-  [ -f "$file" ] || touch "$file"
+  if [ -f "$file" ]; then
-  if [ $# -lt 4 ]; then
+    if [ $# -lt 4 ]; then
-    lno=$(\grep -nF "$line" "$file" | sed 's/:.*//' | tr '\n' ' ')
+      lno=$(\grep -nF "$line" "$file" | sed 's/:.*//' | tr '\n' ' ')
-  else
+    else
-    lno=$(\grep -nF "$pat" "$file" | sed 's/:.*//' | tr '\n' ' ')
+      lno=$(\grep -nF "$pat" "$file" | sed 's/:.*//' | tr '\n' ' ')
+    fi
   fi
   if [ -n "$lno" ]; then
     echo "    - Already exists: line #$lno"
   else
     if [ $update -eq 1 ]; then
-      echo >> "$file"
+      [ -f "$file" ] && echo >> "$file"
       echo "$line" >> "$file"
       echo "    + Added"
     else
@@ -368,6 +331,17 @@ append_line() {
   set +e
 }
 
+create_file() {
+  local file="$1"
+  shift
+  echo "Create $file:"
+  for line in "$@"; do
+    echo "    $line"
+    echo "$line" >> "$file"
+  done
+  echo
+}
+
 if [ $update_config -eq 2 ]; then
   echo
   ask "Do you want to update your shell configuration files?"
@@ -375,23 +349,34 @@ if [ $update_config -eq 2 ]; then
 fi
 echo
 for shell in $shells; do
+  [[ "$shell" = fish ]] && continue
   [ $shell = zsh ] && dest=${ZDOTDIR:-~}/.zshrc || dest=~/.bashrc
-  append_line $update_config "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" "$dest" "~/.fzf.${shell}"
+  append_line $update_config "[ -f ${prefix}.${shell} ] && source ${prefix}.${shell}" "$dest" "${prefix}.${shell}"
 done
 
-if [ $key_bindings -eq 1 ] && [ $has_fish -eq 1 ]; then
+if [ $key_bindings -eq 1 ] && [[ "$shells" =~ fish ]]; then
-  bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
+  bind_file="${fish_dir}/functions/fish_user_key_bindings.fish"
-  append_line $update_config "fzf_key_bindings" "$bind_file"
+  if [ ! -e "$bind_file" ]; then
+    create_file "$bind_file" \
+      'function fish_user_key_bindings' \
+      '  fzf_key_bindings' \
+      'end'
+  else
+    append_line $update_config "fzf_key_bindings" "$bind_file"
+  fi
 fi
 
 if [ $update_config -eq 1 ]; then
   echo 'Finished. Restart your shell or reload config file.'
-  echo '   source ~/.bashrc  # bash'
+  if [[ "$shells" =~ bash ]]; then
-  [ $has_zsh  -eq 1 ] && echo "   source ${ZDOTDIR:-~}/.zshrc   # zsh"
+    echo -n '   source ~/.bashrc  # bash'
-  [ $has_fish -eq 1 ] && [ $key_bindings -eq 1 ] && echo '   fzf_key_bindings  # fish'
+    [[ "$archi" =~ Darwin ]] && echo -n '  (.bashrc should be loaded from .bash_profile)'
+    echo
+  fi
+  [[ "$shells" =~ zsh ]]  && echo "   source ${ZDOTDIR:-~}/.zshrc   # zsh"
+  [[ "$shells" =~ fish ]] && [ $key_bindings -eq 1 ] && echo '   fzf_key_bindings  # fish'
   echo
   echo 'Use uninstall script to remove fzf.'
   echo
 fi
 echo 'For more information, see: https://github.com/junegunn/fzf'
-

install.ps1

@@ -0,0 +1,65 @@
+$version="0.29.0"
+
+$fzf_base=Split-Path -Parent $MyInvocation.MyCommand.Definition
+
+function check_binary () {
+  Write-Host "  - Checking fzf executable ... " -NoNewline
+  $output=cmd /c $fzf_base\bin\fzf.exe --version 2>&1
+  if (-not $?) {
+    Write-Host "Error: $output"
+    $binary_error="Invalid binary"
+  } else {
+    $output=(-Split $output)[0]
+    if ($version -ne $output) {
+      Write-Host "$output != $version"
+      $binary_error="Invalid version"
+    } else {
+      Write-Host "$output"
+      $binary_error=""
+      return 1
+    }
+  }
+  Remove-Item "$fzf_base\bin\fzf.exe"
+  return 0
+}
+
+function download {
+  param($file)
+  Write-Host "Downloading bin/fzf ..."
+  if (Test-Path "$fzf_base\bin\fzf.exe") {
+    Write-Host "  - Already exists"
+    if (check_binary) {
+      return
+    }
+  }
+  if (-not (Test-Path "$fzf_base\bin")) {
+    md "$fzf_base\bin"
+  }
+  if (-not $?) {
+    $binary_error="Failed to create bin directory"
+    return
+  }
+  cd "$fzf_base\bin"
+  $url="https://github.com/junegunn/fzf/releases/download/$version/$file"
+  $temp=$env:TMP + "\fzf.zip"
+  [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+  if ($PSVersionTable.PSVersion.Major -ge 3) {
+    Invoke-WebRequest -Uri $url -OutFile $temp
+  } else {
+    (New-Object Net.WebClient).DownloadFile($url, $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath("$temp"))
+  }
+  if ($?) {
+    (Microsoft.PowerShell.Archive\Expand-Archive -Path $temp -DestinationPath .); (Remove-Item $temp)
+  } else {
+    $binary_error="Failed to download with powershell"
+  }
+  if (-not (Test-Path fzf.exe)) {
+    $binary_error="Failed to download $file"
+    return
+  }
+  echo y | icacls $fzf_base\bin\fzf.exe /grant Administrator:F ; check_binary >$null
+}
+
+download "fzf-$version-windows_amd64.zip"
+
+Write-Host 'For more information, see: https://github.com/junegunn/fzf'

main.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	fzf "github.com/junegunn/fzf/src"
+	"github.com/junegunn/fzf/src/protector"
+)
+
+var version string = "0.29"
+var revision string = "devel"
+
+func main() {
+	protector.Protect()
+	fzf.Run(fzf.ParseOptions(), version, revision)
+}

man/man1/fzf-tmux.1

@@ -0,0 +1,68 @@
+.ig
+The MIT License (MIT)
+
+Copyright (c) 2013-2021 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+..
+.TH fzf-tmux 1 "Dec 2021" "fzf 0.29.0" "fzf-tmux - open fzf in tmux split pane"
+
+.SH NAME
+fzf-tmux - open fzf in tmux split pane
+
+.SH SYNOPSIS
+.B fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
+
+.SH DESCRIPTION
+fzf-tmux is a wrapper script for fzf that opens fzf in a tmux split pane or in
+a tmux popup window. It is designed to work just like fzf except that it does
+not take up the whole screen. You can safely use fzf-tmux instead of fzf in
+your scripts as the extra options will be silently ignored if you're not on
+tmux.
+
+.SH LAYOUT OPTIONS
+
+(default layout: \fB-d 50%\fR)
+
+.SS Popup window
+(requires tmux 3.2 or above)
+.TP
+.B "-p [WIDTH[%][,HEIGHT[%]]]"
+.TP
+.B "-w WIDTH[%]"
+.TP
+.B "-h WIDTH[%]"
+.TP
+.B "-x COL"
+.TP
+.B "-y ROW"
+
+.SS Split pane
+.TP
+.B "-u [height[%]]"
+Split above (up)
+.TP
+.B "-d [height[%]]"
+Split below (down)
+.TP
+.B "-l [width[%]]"
+Split left
+.TP
+.B "-r [width[%]]"
+Split right

man/man1/fzf.1

@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)
 
-Copyright (c) 2016 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -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 2016" "fzf 0.13.2" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Dec 2021" "fzf 0.29.0" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -47,6 +47,19 @@ Case-insensitive match (default: smart-case match)
 .TP
 .B "+i"
 Case-sensitive match
+.TP
+.B "--literal"
+Do not normalize latin script letters for matching.
+.TP
+.BI "--algo=" TYPE
+Fuzzy matching algorithm (default: v2)
+
+.br
+.BR v2 "     Optimal scoring algorithm (quality)"
+.br
+.BR v1 "     Faster but not guaranteed to find the optimal result (performance)"
+.br
+
 .TP
 .BI "-n, --nth=" "N[,..]"
 Comma-separated list of field index expressions for limiting search scope.
@@ -57,6 +70,11 @@ Transform the presentation of each line using field index expressions
 .TP
 .BI "-d, --delimiter=" "STR"
 Field delimiter regex for \fB--nth\fR and \fB--with-nth\fR (default: AWK-style)
+.TP
+.BI "--disabled"
+Do not perform search. With this option, fzf becomes a simple selector
+interface rather than a "fuzzy finder". You can later enable the search using
+\fBenable-search\fR or \fBtoggle-search\fR action.
 .SS Search result
 .TP
 .B "+s, --no-sort"
@@ -66,7 +84,8 @@ Do not sort the result
 Reverse the order of the input
 
 .RS
-e.g. \fBhistory | fzf --tac --no-sort\fR
+e.g.
+     \fBhistory | fzf --tac --no-sort\fR
 .RE
 .TP
 .BI "--tiebreak=" "CRI[,..]"
@@ -96,32 +115,105 @@ Comma-separated list of sort criteria to apply when the scores are tied.
 .SS Interface
 .TP
 .B "-m, --multi"
-Enable multi-select with tab/shift-tab
+Enable multi-select with tab/shift-tab. It optionally takes an integer argument
+which denotes the maximum number of items that can be selected.
+.TP
+.B "+m, --no-multi"
+Disable multi-select
 .TP
 .B "--no-mouse"
 Disable mouse
 .TP
 .BI "--bind=" "KEYBINDS"
-Comma-separated list of custom key bindings. See \fBKEY BINDINGS\fR for the
+Comma-separated list of custom key bindings. See \fBKEY/EVENT BINDINGS\fR for
-details.
+the details.
 .TP
 .B "--cycle"
 Enable cyclic scroll
 .TP
+.B "--keep-right"
+Keep the right end of the line visible when it's too long. Effective only when
+the query string is empty.
+.TP
+.BI "--scroll-off=" "LINES"
+Number of screen lines to keep above or below when scrolling to the top or to
+the bottom (default: 0).
+.TP
 .B "--no-hscroll"
 Disable horizontal scroll
 .TP
-.BI "--hscroll-off=" "COL"
+.BI "--hscroll-off=" "COLS"
 Number of screen columns to keep to the right of the highlighted substring
 (default: 10). Setting it to a large value will cause the text to be positioned
 on the center of the screen.
 .TP
+.B "--filepath-word"
+Make word-wise movements and actions respect path separators. The following
+actions are affected:
+
+\fBbackward-kill-word\fR
+.br
+\fBbackward-word\fR
+.br
+\fBforward-word\fR
+.br
+\fBkill-word\fR
+.TP
 .BI "--jump-labels=" "CHARS"
 Label characters for \fBjump\fR and \fBjump-accept\fR
 .SS Layout
+.TP
+.BI "--height=" "HEIGHT[%]"
+Display fzf window below the cursor with the given height instead of using
+the full screen.
+.TP
+.BI "--min-height=" "HEIGHT"
+Minimum height when \fB--height\fR is given in percent (default: 10).
+Ignored when \fB--height\fR is not specified.
+.TP
+.BI "--layout=" "LAYOUT"
+Choose the layout (default: default)
+
+.br
+.BR default "       Display from the bottom of the screen"
+.br
+.BR reverse "       Display from the top of the screen"
+.br
+.BR reverse-list "  Display from the top of the screen, prompt at the bottom"
+.br
+
 .TP
 .B "--reverse"
-Reverse orientation
+A synonym for \fB--layout=reverse\fB
+
+.TP
+.BI "--border" [=STYLE]
+Draw border around the finder
+
+.br
+.BR rounded "     Border with rounded corners (default)"
+.br
+.BR sharp "       Border with sharp corners"
+.br
+.BR horizontal "  Horizontal lines above and below the finder"
+.br
+.BR vertical "    Vertical lines on each side of the finder"
+.br
+.BR top
+.br
+.BR bottom
+.br
+.BR left
+.br
+.BR right
+.br
+.BR none
+.br
+
+.TP
+.B "--no-unicode"
+Use ASCII characters instead of Unicode box drawing characters to draw border
+
 .TP
 .BI "--margin=" MARGIN
 Comma-separated expression for margins around the finder.
@@ -144,19 +236,62 @@ terminal size with \fB%\fR suffix.
 .br
 
 .br
-e.g. \fBfzf --margin 10%\fR
+e.g.
-     \fBfzf --margin 1,5%\fR
+     \fBfzf --margin 10%
+     fzf --margin 1,5%\fR
 .RE
 .TP
-.B "--inline-info"
+.BI "--padding=" PADDING
-Display finder info inline with the query
+Comma-separated expression for padding inside the border. Padding is
+distinguishable from margin only when \fB--border\fR option is used.
+.br
+
+.br
+e.g.
+     \fBfzf --margin 5% --padding 5% --border --preview 'cat {}' \\
+         --color bg:#222222,preview-bg:#333333\fR
+
+.br
+.RS
+.BR TRBL "     Same padding for top, right, bottom, and left"
+.br
+.BR TB,RL "    Vertical, horizontal padding"
+.br
+.BR T,RL,B "   Top, horizontal, bottom padding"
+.br
+.BR T,R,B,L "  Top, right, bottom, left padding"
+.br
+.RE
+
+.TP
+.BI "--info=" "STYLE"
+Determines the display style of finder info.
+
+.br
+.BR default "       Display on the next line to the prompt"
+.br
+.BR inline "        Display on the same line"
+.br
+.BR hidden "        Do not display finder info"
+.br
+
+.TP
+.B "--no-info"
+A synonym for \fB--info=hidden\fB
+
 .TP
 .BI "--prompt=" "STR"
 Input prompt (default: '> ')
 .TP
+.BI "--pointer=" "STR"
+Pointer to the current line (default: '>')
+.TP
+.BI "--marker=" "STR"
+Multi-select marker (default: '>')
+.TP
 .BI "--header=" "STR"
 The given string will be printed as the sticky header. The lines are displayed
-in the given order from top to bottom regardless of \fB--reverse\fR option, and
+in the given order from top to bottom regardless of \fB--layout\fR option, and
 are not affected by \fB--with-nth\fR. ANSI color codes are processed even when
 \fB--ansi\fR is not set.
 .TP
@@ -164,6 +299,9 @@ are not affected by \fB--with-nth\fR. ANSI color codes are processed even when
 The first N lines of the input are treated as the sticky header. When
 \fB--with-nth\fR is set, the lines are transformed just like the other
 lines that follow.
+.TP
+.B "--header-first"
+Print header before the prompt line
 .SS Display
 .TP
 .B "--ansi"
@@ -172,15 +310,9 @@ Enable processing of ANSI color codes
 .BI "--tabstop=" SPACES
 Number of spaces for a tab character (default: 8)
 .TP
-.BI "--color=" "[BASE_SCHEME][,COLOR:ANSI]"
+.BI "--color=" "[BASE_SCHEME][,COLOR_NAME[:ANSI_COLOR][:ANSI_ATTRIBUTES]]..."
 Color configuration. The name of the base color scheme is followed by custom
-color mappings. Ansi color code of -1 denotes terminal default
+color mappings.
-foreground/background color.
-
-.RS
-e.g. \fBfzf --color=bg+:24\fR
-     \fBfzf --color=light,fg:232,bg:255,bg+:116,info:27\fR
-.RE
 
 .RS
 .B BASE SCHEME:
@@ -189,23 +321,76 @@ e.g. \fBfzf --color=bg+:24\fR
     \fBdark    \fRColor scheme for dark 256-color terminal
     \fBlight   \fRColor scheme for light 256-color terminal
     \fB16      \fRColor scheme for 16-color terminal
-    \fBbw      \fRNo colors
+    \fBbw      \fRNo colors (equivalent to \fB--no-color\fR)
 
-.B COLOR:
+.B COLOR NAMES:
-    \fBfg      \fRText
+    \fBfg         \fRText
-    \fBbg      \fRBackground
+    \fBbg         \fRBackground
-    \fBhl      \fRHighlighted substrings
+    \fBpreview-fg \fRPreview window text
-    \fBfg+     \fRText (current line)
+    \fBpreview-bg \fRPreview window background
-    \fBbg+     \fRBackground (current line)
+    \fBhl         \fRHighlighted substrings
-    \fBhl+     \fRHighlighted substrings (current line)
+    \fBfg+        \fRText (current line)
-    \fBinfo    \fRInfo
+    \fBbg+        \fRBackground (current line)
-    \fBprompt  \fRPrompt
+    \fBgutter     \fRGutter on the left (defaults to \fBbg+\fR)
-    \fBpointer \fRPointer to the current line
+    \fBhl+        \fRHighlighted substrings (current line)
-    \fBmarker  \fRMulti-select marker
+    \fBquery      \fRQuery string
-    \fBspinner \fRStreaming input indicator
+    \fBdisabled   \fRQuery string when search is disabled
-    \fBheader  \fRHeader
+    \fBinfo       \fRInfo line (match counters)
+    \fBborder     \fRBorder around the window (\fB--border\fR and \fB--preview\fR)
+    \fBprompt     \fRPrompt
+    \fBpointer    \fRPointer to the current line
+    \fBmarker     \fRMulti-select marker
+    \fBspinner    \fRStreaming input indicator
+    \fBheader     \fRHeader
+
+.B ANSI COLORS:
+    \fB-1         \fRDefault terminal foreground/background color
+    \fB           \fR(or the original color of the text)
+    \fB0 ~ 15     \fR16 base colors
+      \fBblack\fR
+      \fBred\fR
+      \fBgreen\fR
+      \fByellow\fR
+      \fBblue\fR
+      \fBmagenta\fR
+      \fBcyan\fR
+      \fBwhite\fR
+      \fBbright-black\fR (gray | grey)
+      \fBbright-red\fR
+      \fBbright-green\fR
+      \fBbright-yellow\fR
+      \fBbright-blue\fR
+      \fBbright-magenta\fR
+      \fBbright-cyan\fR
+      \fBbright-white\fR
+    \fB16 ~ 255   \fRANSI 256 colors
+    \fB#rrggbb    \fR24-bit colors
+
+.B ANSI ATTRIBUTES: (Only applies to foreground colors)
+    \fBregular    \fRClears previously set attributes; should precede the other ones
+    \fBbold\fR
+    \fBunderline\fR
+    \fBreverse\fR
+    \fBdim\fR
+    \fBitalic\fR
+
+.B EXAMPLES:
+
+     \fB# Seoul256 theme with 8-bit colors
+     # (https://github.com/junegunn/seoul256.vim)
+     fzf --color='bg:237,bg+:236,info:143,border:240,spinner:108' \\
+         --color='hl:65,fg:252,header:65,fg+:252' \\
+         --color='pointer:161,marker:168,prompt:110,hl+:108'
+
+     # Seoul256 theme with 24-bit colors
+     fzf --color='bg:#4B4B4B,bg+:#3F3F3F,info:#BDBB72,border:#6B6B6B,spinner:#98BC99' \\
+         --color='hl:#719872,fg:#D9D9D9,header:#719872,fg+:#D9D9D9' \\
+         --color='pointer:#E12672,marker:#E17899,prompt:#98BEDE,hl+:#98BC99'\fR
 .RE
 .TP
+.B "--no-bold"
+Do not use bold text
+.TP
 .B "--black"
 Use black background
 .SS History
@@ -222,17 +407,67 @@ automatically truncated when the number of the lines exceeds the value.
 .TP
 .BI "--preview=" "COMMAND"
 Execute the given command for the current line and display the result on the
-preview window. \fB{}\fR is the placeholder for the quoted string of the
+preview window. \fB{}\fR in the command is the placeholder that is replaced to
-current line.
+the single-quoted string of the current line. To transform the replacement
+string, specify field index expressions between the braces (See \fBFIELD INDEX
+EXPRESSION\fR for the details).
 
 .RS
-e.g. \fBfzf --preview="head -$LINES {}"\fR
+e.g.
+     \fBfzf --preview='head -$LINES {}'
+     ls -l | fzf --preview="echo user={3} when={-4..-2}; cat {-1}" --header-lines=1\fR
+
+fzf exports \fB$FZF_PREVIEW_LINES\fR and \fB$FZF_PREVIEW_COLUMNS\fR so that
+they represent the exact size of the preview window. (It also overrides
+\fB$LINES\fR and \fB$COLUMNS\fR with the same values but they can be reset
+by the default shell, so prefer to refer to the ones with \fBFZF_PREVIEW_\fR
+prefix.)
+
+A placeholder expression starting with \fB+\fR flag will be replaced to the
+space-separated list of the selected lines (or the current line if no selection
+was made) individually quoted.
+
+e.g.
+     \fBfzf --multi --preview='head -10 {+}'
+     git log --oneline | fzf --multi --preview 'git show {+1}'\fR
+
+When using a field index expression, leading and trailing whitespace is stripped
+from the replacement string. To preserve the whitespace, use the \fBs\fR flag.
+
+Also, \fB{q}\fR is replaced to the current query string, and \fB{n}\fR is
+replaced to zero-based ordinal index of the line. Use \fB{+n}\fR if you want
+all index numbers when multiple lines are selected.
+
+A placeholder expression with \fBf\fR flag is replaced to the path of
+a temporary file that holds the evaluated list. This is useful when you
+multi-select a large number of items and the length of the evaluated string may
+exceed \fBARG_MAX\fR.
+
+e.g.
+     \fB# Press CTRL-A to select 100K items and see the sum of all the numbers.
+     # This won't work properly without 'f' flag due to ARG_MAX limit.
+     seq 100000 | fzf --multi --bind ctrl-a:select-all \\
+                      --preview "awk '{sum+=\$1} END {print sum}' {+f}"\fR
+
+Note that you can escape a placeholder pattern by prepending a backslash.
+
+Preview window will be updated even when there is no match for the current
+query if any of the placeholder expressions evaluates to a non-empty string.
+
+Since 0.24.0, fzf can render partial preview content before the preview command
+completes. ANSI escape sequence for clearing the display (\fBCSI 2 J\fR) is
+supported, so you can use it to implement preview window that is constantly
+updating.
+
+e.g.
+      \fBfzf --preview 'for i in $(seq 100000); do
+        (( i % 200 == 0 )) && printf "\\033[2J"
+        echo "$i"
+        sleep 0.01
+      done'\fR
 .RE
 .TP
-.BI "--preview-window=" "[POSITION][:SIZE[%]][:hidden]"
+.BI "--preview-window=" "[POSITION][,SIZE[%]][,border-BORDER_OPT][,[no]wrap][,[no]follow][,[no]cycle][,[no]hidden][,+SCROLL[OFFSETS][/DENOM]][,~HEADER_LINES][,default]"
-Determine the layout of the preview window. If the argument ends with
-\fB:hidden\fR, the preview window will be hidden by default until
-\fBtoggle-preview\fR action is triggered.
 
 .RS
 .B POSITION: (default: right)
@@ -240,22 +475,92 @@ Determine the layout of the preview window. If the argument ends with
     \fBdown
     \fBleft
     \fBright
-.RE
+
+\fRDetermines the layout of the preview window.
+
+* If the argument contains \fB:hidden\fR, the preview window will be hidden by
+default until \fBtoggle-preview\fR action is triggered.
+
+* If size is given as 0, preview window will not be visible, but fzf will still
+execute the command in the background.
+
+* Long lines are truncated by default. Line wrap can be enabled with
+\fB:wrap\fR flag.
+
+* Preview window will automatically scroll to the bottom when \fB:follow\fR
+flag is set, similarly to how \fBtail -f\fR works.
 
 .RS
-e.g. \fBfzf --preview="head {}" --preview-window=up:30%\fR
+e.g.
-     \fBfzf --preview="file {}" --preview-window=down:1\fR
+      \fBfzf --preview-window follow --preview 'for i in $(seq 100000); do
+        echo "$i"
+        sleep 0.01
+        (( i % 300 == 0 )) && printf "\\033[2J"
+      done'\fR
 .RE
+
+* Cyclic scrolling is enabled with \fB:cycle\fR flag.
+
+* To change the style of the border of the preview window, specify one of
+the options for \fB--border\fR with \fBborder-\fR prefix.
+e.g. \fBborder-rounded\fR (border with rounded edges, default),
+\fBborder-sharp\fR (border with sharp edges), \fBborder-left\fR,
+\fBborder-none\fR, etc.
+
+* \fB[:+SCROLL[OFFSETS][/DENOM]]\fR determines the initial scroll offset of the
+preview window.
+
+  - \fBSCROLL\fR can be either a numeric integer or a single-field index expression that refers to a numeric integer.
+
+  - The optional \fBOFFSETS\fR part is for adjusting the base offset. It should be given as a series of signed integers (\fB-INTEGER\fR or \fB+INTEGER\fR).
+
+  - The final \fB/DENOM\fR part is for specifying a fraction of the preview window height.
+
+* \fB~HEADER_LINES\fR keeps the top N lines as the fixed header so that they
+are always visible.
+
+* \fBdefault\fR resets all options previously set to the default.
+
+.RS
+e.g.
+     \fB# Non-default scroll window positions and sizes
+     fzf --preview="head {}" --preview-window=up,30%
+     fzf --preview="file {}" --preview-window=down,1
+
+     # Initial scroll offset is set to the line number of each line of
+     # git grep output *minus* 5 lines (-5)
+     git grep --line-number '' |
+       fzf --delimiter : --preview 'nl {1}' --preview-window '+{2}-5'
+
+     # Preview with bat, matching line in the middle of the window below
+     # the fixed header of the top 3 lines
+     #
+     #   ~3    Top 3 lines as the fixed header
+     #   +{2}  Base scroll offset extracted from the second field
+     #   +3    Extra offset to compensate for the 3-line header
+     #   /2    Put in the middle of the preview area
+     #
+     git grep --line-number '' |
+       fzf --delimiter : \\
+           --preview 'bat --style=full --color=always --highlight-line {2} {1}' \\
+           --preview-window '~3,+{2}+3/2'
+
+     # Display top 3 lines as the fixed header
+     fzf --preview 'bat --style=full --color=always {}' --preview-window '~3'\fR
+.RE
+
 .SS Scripting
 .TP
 .BI "-q, --query=" "STR"
 Start the finder with the given query
 .TP
 .B "-1, --select-1"
-Automatically select the only match
+If there is only one match for the initial query (\fB--query\fR), do not start
+interactive finder and automatically select the only match
 .TP
 .B "-0, --exit-0"
-Exit immediately when there's no match
+If there is no match for the initial query (\fB--query\fR), do not start
+interactive finder and exit immediately
 .TP
 .BI "-f, --filter=" "STR"
 Filter mode. Do not start interactive finder. When used with \fB--no-sort\fR,
@@ -269,12 +574,27 @@ 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"
+Read input delimited by ASCII NUL characters instead of newline characters
+.TP
+.B "--print0"
+Print output delimited by ASCII NUL characters instead of newline characters
+.TP
+.B "--no-clear"
+Do not clear finder interface on exit. If fzf was started in full screen mode,
+it will not switch back to the original screen, so you'll have to manually run
+\fBtput rmcup\fR to return. This option can be used to avoid flickering of the
+screen when your application needs to start fzf multiple times in order.
+.TP
 .B "--sync"
 Synchronous search for multi-staged filtering. If specified, fzf will launch
 ncurses finder only after the input stream is complete.
@@ -282,11 +602,19 @@ ncurses finder only after the input stream is complete.
 .RS
 e.g. \fBfzf --multi | fzf --sync\fR
 .RE
+.TP
+.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
-Default command to use when input is tty
+Default command to use when input is tty. On *nix systems, fzf runs the command
+with \fB$SHELL -c\fR if \fBSHELL\fR is set, otherwise with \fBsh -c\fR, so in
+this case make sure that the command is POSIX-compliant.
 .TP
 .B FZF_DEFAULT_OPTS
 Default options. e.g. \fBexport FZF_DEFAULT_OPTS="--extended --cycle"\fR
@@ -330,6 +658,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
@@ -342,7 +673,7 @@ with the given string. An anchored-match term is also an exact-match term.
 
 .SS Negation
 If a term is prefixed by \fB!\fR, fzf will exclude the lines that satisfy the
-term from the result.
+term from the result. In this case, fzf performs exact match by default.
 
 .SS Exact-match by default
 If you don't prefer fuzzy matching and do not wish to "quote" (prefixing with
@@ -356,83 +687,244 @@ query matches entries that start with \fBcore\fR and end with either \fBgo\fR,
 
 e.g. \fB^core go$ | rb$ | py$\fR
 
-.SH KEY BINDINGS
+.SH KEY/EVENT BINDINGS
-You can customize key bindings of fzf with \fB--bind\fR option which takes
+\fB--bind\fR option allows you to bind \fBa key\fR or \fBan event\fR to one or
-a comma-separated list of key binding expressions. Each key binding expression
+more \fBactions\fR. You can use it to customize key bindings or implement
-follows the following format: \fBKEY:ACTION\fR
+dynamic behaviors.
 
-e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
+\fB--bind\fR takes a comma-separated list of binding expressions. Each binding
+expression is \fBKEY:ACTION\fR or \fBEVENT:ACTION\fR.
 
-.B AVAILABLE KEYS:    (SYNONYMS)
+e.g.
-    \fIctrl-[a-z]\fR
+     \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
-    \fIalt-[a-z]\fR
-    \fIf[1-10]\fR
-    \fIenter\fR       (\fIreturn\fR \fIctrl-m\fR)
-    \fIspace\fR
-    \fIbspace\fR      (\fIbs\fR)
-    \fIalt-enter\fR
-    \fIalt-space\fR
-    \fIalt-bspace\fR  (\fIalt-bs\fR)
-    \fIalt-/\fR
-    \fItab\fR
-    \fIbtab\fR        (\fIshift-tab\fR)
-    \fIesc\fR
-    \fIdel\fR
-    \fIup\fR
-    \fIdown\fR
-    \fIleft\fR
-    \fIright\fR
-    \fIhome\fR
-    \fIend\fR
-    \fIpgup\fR        (\fIpage-up\fR)
-    \fIpgdn\fR        (\fIpage-down\fR)
-    \fIshift-left\fR
-    \fIshift-right\fR
-    \fIdouble-click\fR
-    or any single character
 
-  \fBACTION:               DEFAULT BINDINGS (NOTES):
+.SS AVAILABLE KEYS:    (SYNONYMS)
-    \fBabort\fR                 \fIctrl-c  ctrl-g  ctrl-q  esc\fR
+\fIctrl-[a-z]\fR
-    \fBaccept\fR                \fIenter   double-click\fR
+.br
-    \fBbackward-char\fR         \fIctrl-b  left\fR
+\fIctrl-space\fR
-    \fBbackward-delete-char\fR  \fIctrl-h  bspace\fR
+.br
-    \fBbackward-kill-word\fR    \fIalt-bs\fR
+\fIctrl-\\\fR
-    \fBbackward-word\fR         \fIalt-b   shift-left\fR
+.br
-    \fBbeginning-of-line\fR     \fIctrl-a  home\fR
+\fIctrl-]\fR
-    \fBcancel\fR
+.br
-    \fBclear-screen\fR          \fIctrl-l\fR
+\fIctrl-^\fR      (\fIctrl-6\fR)
-    \fBdelete-char\fR           \fIdel\fR
+.br
-    \fBdelete-char/eof\fR       \fIctrl-d\fR
+\fIctrl-/\fR      (\fIctrl-_\fR)
-    \fBdeselect-all\fR
+.br
-    \fBdown\fR                  \fIctrl-j  ctrl-n  down\fR
+\fIctrl-alt-[a-z]\fR
-    \fBend-of-line\fR           \fIctrl-e  end\fR
+.br
-    \fBexecute(...)\fR          (see below for the details)
+\fIalt-[*]\fR     (Any case-sensitive single character is allowed)
-    \fBexecute-multi(...)\fR    (see below for the details)
+.br
-    \fBforward-char\fR          \fIctrl-f  right\fR
+\fIf[1-12]\fR
-    \fBforward-word\fR          \fIalt-f   shift-right\fR
+.br
+\fIenter\fR       (\fIreturn\fR \fIctrl-m\fR)
+.br
+\fIspace\fR
+.br
+\fIbspace\fR      (\fIbs\fR)
+.br
+\fIalt-up\fR
+.br
+\fIalt-down\fR
+.br
+\fIalt-left\fR
+.br
+\fIalt-right\fR
+.br
+\fIalt-enter\fR
+.br
+\fIalt-space\fR
+.br
+\fIalt-bspace\fR  (\fIalt-bs\fR)
+.br
+\fItab\fR
+.br
+\fIbtab\fR        (\fIshift-tab\fR)
+.br
+\fIesc\fR
+.br
+\fIdel\fR
+.br
+\fIup\fR
+.br
+\fIdown\fR
+.br
+\fIleft\fR
+.br
+\fIright\fR
+.br
+\fIhome\fR
+.br
+\fIend\fR
+.br
+\fIinsert\fR
+.br
+\fIpgup\fR        (\fIpage-up\fR)
+.br
+\fIpgdn\fR        (\fIpage-down\fR)
+.br
+\fIshift-up\fR
+.br
+\fIshift-down\fR
+.br
+\fIshift-left\fR
+.br
+\fIshift-right\fR
+.br
+\fIalt-shift-up\fR
+.br
+\fIalt-shift-down\fR
+.br
+\fIalt-shift-left\fR
+.br
+\fIalt-shift-right\fR
+.br
+\fIleft-click\fR
+.br
+\fIright-click\fR
+.br
+\fIdouble-click\fR
+.br
+or any single character
+
+.SS AVAILABLE EVENTS:
+\fIchange\fR
+.RS
+Triggered whenever the query string is changed
+
+e.g.
+     \fB# Move cursor to the first entry whenever the query is changed
+     fzf --bind change:first\fR
+.RE
+
+\fIbackward-eof\fR
+.RS
+Triggered when the query string is already empty and you try to delete it
+backward.
+
+e.g.
+     \fBfzf --bind backward-eof:abort\fR
+.RE
+
+.SS AVAILABLE ACTIONS:
+A key or an event can be bound to one or more of the following actions.
+
+  \fBACTION:                   DEFAULT BINDINGS (NOTES):
+    \fBabort\fR                      \fIctrl-c  ctrl-g  ctrl-q  esc\fR
+    \fBaccept\fR                     \fIenter   double-click\fR
+    \fBaccept-non-empty\fR           (same as \fBaccept\fR except that it prevents fzf from exiting without selection)
+    \fBbackward-char\fR              \fIctrl-b  left\fR
+    \fBbackward-delete-char\fR       \fIctrl-h  bspace\fR
+    \fBbackward-delete-char/eof\fR   (same as \fBbackward-delete-char\fR except aborts fzf if query is empty)
+    \fBbackward-kill-word\fR         \fIalt-bs\fR
+    \fBbackward-word\fR              \fIalt-b   shift-left\fR
+    \fBbeginning-of-line\fR          \fIctrl-a  home\fR
+    \fBcancel\fR                     (clear query string if not empty, abort fzf otherwise)
+    \fBchange-preview(...)\fR        (change \fB--preview\fR option)
+    \fBchange-preview-window(...)\fR (change \fB--preview-window\fR option; rotate through the multiple option sets separated by '|')
+    \fBchange-prompt(...)\fR         (change prompt to the given string)
+    \fBclear-screen\fR               \fIctrl-l\fR
+    \fBclear-selection\fR            (clear multi-selection)
+    \fBclose\fR                      (close preview window if open, abort fzf otherwise)
+    \fBclear-query\fR                (clear query string)
+    \fBdelete-char\fR                \fIdel\fR
+    \fBdelete-char/eof\fR            \fIctrl-d\fR (same as \fBdelete-char\fR except aborts fzf if query is empty)
+    \fBdeselect\fR
+    \fBdeselect-all\fR               (deselect all matches)
+    \fBdisable-search\fR             (disable search functionality)
+    \fBdown\fR                       \fIctrl-j  ctrl-n  down\fR
+    \fBenable-search\fR              (enable search functionality)
+    \fBend-of-line\fR                \fIctrl-e  end\fR
+    \fBexecute(...)\fR               (see below for the details)
+    \fBexecute-silent(...)\fR        (see below for the details)
+    \fBfirst\fR                      (move to the first match)
+    \fBforward-char\fR               \fIctrl-f  right\fR
+    \fBforward-word\fR               \fIalt-f   shift-right\fR
     \fBignore\fR
-    \fBjump\fR                  (EasyMotion-like 2-keystroke movement)
+    \fBjump\fR                       (EasyMotion-like 2-keystroke movement)
-    \fBjump-accept\fR           (jump and accept)
+    \fBjump-accept\fR                (jump and accept)
     \fBkill-line\fR
-    \fBkill-word\fR             \fIalt-d\fR
+    \fBkill-word\fR                  \fIalt-d\fR
-    \fBnext-history\fR          (\fIctrl-n\fR on \fB--history\fR)
+    \fBlast\fR                       (move to the last match)
-    \fBpage-down\fR             \fIpgdn\fR
+    \fBnext-history\fR               (\fIctrl-n\fR on \fB--history\fR)
-    \fBpage-up\fR               \fIpgup\fR
+    \fBpage-down\fR                  \fIpgdn\fR
-    \fBprevious-history\fR      (\fIctrl-p\fR on \fB--history\fR)
+    \fBpage-up\fR                    \fIpgup\fR
-    \fBprint-query\fR           (print query and exit)
+    \fBhalf-page-down\fR
-    \fBselect-all\fR
+    \fBhalf-page-up\fR
-    \fBtoggle\fR
+    \fBpreview(...)\fR               (see below for the details)
-    \fBtoggle-all\fR
+    \fBpreview-down\fR               \fIshift-down\fR
-    \fBtoggle-down\fR           \fIctrl-i  (tab)\fR
+    \fBpreview-up\fR                 \fIshift-up\fR
-    \fBtoggle-in\fR             (\fB--reverse\fR ? \fBtoggle-up\fR : \fBtoggle-down\fR)
+    \fBpreview-page-down\fR
-    \fBtoggle-out\fR            (\fB--reverse\fR ? \fBtoggle-down\fR : \fBtoggle-up\fR)
+    \fBpreview-page-up\fR
+    \fBpreview-half-page-down\fR
+    \fBpreview-half-page-up\fR
+    \fBpreview-bottom\fR
+    \fBpreview-top\fR
+    \fBprevious-history\fR           (\fIctrl-p\fR on \fB--history\fR)
+    \fBprint-query\fR                (print query and exit)
+    \fBput\fR                        (put the character to the prompt)
+    \fBrefresh-preview\fR
+    \fBreload(...)\fR                (see below for the details)
+    \fBreplace-query\fR              (replace query string with the current selection)
+    \fBselect\fR
+    \fBselect-all\fR                 (select all matches)
+    \fBtoggle\fR                     (\fIright-click\fR)
+    \fBtoggle-all\fR                 (toggle all matches)
+    \fBtoggle+down\fR                \fIctrl-i  (tab)\fR
+    \fBtoggle-in\fR                  (\fB--layout=reverse*\fR ? \fBtoggle+up\fR : \fBtoggle+down\fR)
+    \fBtoggle-out\fR                 (\fB--layout=reverse*\fR ? \fBtoggle+down\fR : \fBtoggle+up\fR)
     \fBtoggle-preview\fR
-    \fBtoggle-sort\fR           (equivalent to \fB--toggle-sort\fR)
+    \fBtoggle-preview-wrap\fR
-    \fBtoggle-up\fR             \fIbtab    (shift-tab)\fR
+    \fBtoggle-search\fR              (toggle search functionality)
-    \fBunix-line-discard\fR     \fIctrl-u\fR
+    \fBtoggle-sort\fR
-    \fBunix-word-rubout\fR      \fIctrl-w\fR
+    \fBtoggle+up\fR                  \fIbtab    (shift-tab)\fR
-    \fBup\fR                    \fIctrl-k  ctrl-p  up\fR
+    \fBunbind(...)\fR                (unbind bindings)
-    \fByank\fR                  \fIctrl-y\fR
+    \fBunix-line-discard\fR          \fIctrl-u\fR
+    \fBunix-word-rubout\fR           \fIctrl-w\fR
+    \fBup\fR                         \fIctrl-k  ctrl-p  up\fR
+    \fByank\fR                       \fIctrl-y\fR
+
+.SS ACTION COMPOSITION
+
+Multiple actions can be chained using \fB+\fR separator.
+
+e.g.
+     \fBfzf --multi --bind 'ctrl-a:select-all+accept'\fR
+     \fBfzf --multi --bind 'ctrl-a:select-all' --bind 'ctrl-a:+accept'\fR
+
+.SS ACTION ARGUMENT
+
+An action denoted with \fB(...)\fR suffix takes an argument.
+
+e.g.
+     \fBfzf --bind 'ctrl-a:change-prompt(NewPrompt> )'\fR
+     \fBfzf --bind 'ctrl-v:preview(cat {})' --preview-window hidden\fR
+
+If the argument contains parentheses, fzf may fail to parse the expression. In
+that case, you can use any of the following alternative notations to avoid
+parse errors.
+
+    \fBaction-name[...]\fR
+    \fBaction-name~...~\fR
+    \fBaction-name!...!\fR
+    \fBaction-name@...@\fR
+    \fBaction-name#...#\fR
+    \fBaction-name$...$\fR
+    \fBaction-name%...%\fR
+    \fBaction-name^...^\fR
+    \fBaction-name&...&\fR
+    \fBaction-name*...*\fR
+    \fBaction-name;...;\fR
+    \fBaction-name/.../\fR
+    \fBaction-name|...|\fR
+    \fBaction-name:...\fR
+.RS
+The last one is the special form that frees you from parse errors as it does
+not expect the closing character. The catch is that it should be the last one
+in the comma-separated list of key-action pairs.
+.RE
+
+.SS COMMAND EXECUTION
 
 With \fBexecute(...)\fR action, you can execute arbitrary commands without
 leaving fzf. For example, you can turn fzf into a simple file browser by
@@ -440,34 +932,71 @@ binding \fBenter\fR key to \fBless\fR command like follows.
 
     \fBfzf --bind "enter:execute(less {})"\fR
 
-\fB{}\fR is the placeholder for the quoted string of the current line.
+You can use the same placeholder expressions as in \fB--preview\fR.
-If the command contains parentheses, you can use any of the following
-alternative notations to avoid parse errors.
 
-    \fBexecute[...]\fR
+fzf switches to the alternate screen when executing a command. However, if the
-    \fBexecute~...~\fR
+command is expected to complete quickly, and you are not interested in its
-    \fBexecute!...!\fR
+output, you might want to use \fBexecute-silent\fR instead, which silently
-    \fBexecute@...@\fR
+executes the command without the switching. Note that fzf will not be
-    \fBexecute#...#\fR
+responsive until the command is complete. For asynchronous execution, start
-    \fBexecute$...$\fR
+your command as a background process (i.e. appending \fB&\fR).
-    \fBexecute%...%\fR
-    \fBexecute^...^\fR
-    \fBexecute&...&\fR
-    \fBexecute*...*\fR
-    \fBexecute;...;\fR
-    \fBexecute/.../\fR
-    \fBexecute|...|\fR
-    \fBexecute:...\fR
-.RS
-This is the special form that frees you from parse errors as it does not expect
-the closing character. The catch is that it should be the last one in the
-comma-separated list.
-.RE
 
-\fBexecute-multi(...)\fR is an alternative action that executes the command
+On *nix systems, fzf runs the command with \fB$SHELL -c\fR if \fBSHELL\fR is
-with the selected entries when multi-select is enabled (\fB--multi\fR). With
+set, otherwise with \fBsh -c\fR, so in this case make sure that the command is
-this action, \fB{}\fR is replaced with the quoted strings of the selected
+POSIX-compliant.
-entries separated by spaces.
+
+.SS RELOAD INPUT
+
+\fBreload(...)\fR action is used to dynamically update the input list
+without restarting fzf. It takes the same command template with placeholder
+expressions as \fBexecute(...)\fR.
+
+See \fIhttps://github.com/junegunn/fzf/issues/1750\fR for more info.
+
+e.g.
+     \fB# Update the list of processes by pressing CTRL-R
+     ps -ef | fzf --bind 'ctrl-r:reload(ps -ef)' --header 'Press CTRL-R to reload' \\
+                  --header-lines=1 --layout=reverse
+
+     # Integration with ripgrep
+     RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+     INITIAL_QUERY="foobar"
+     FZF_DEFAULT_COMMAND="$RG_PREFIX '$INITIAL_QUERY'" \\
+       fzf --bind "change:reload:$RG_PREFIX {q} || true" \\
+           --ansi --disabled --query "$INITIAL_QUERY"\fR
+
+.SS PREVIEW BINDING
+
+With \fBpreview(...)\fR action, you can specify multiple different preview
+commands in addition to the default preview command given by \fB--preview\fR
+option.
+
+e.g.
+     # Default preview command with an extra preview binding
+     fzf --preview 'file {}' --bind '?:preview:cat {}'
+
+     # A preview binding with no default preview command
+     # (Preview window is initially empty)
+     fzf --bind '?:preview:cat {}'
+
+     # Preview window hidden by default, it appears when you first hit '?'
+     fzf --bind '?:preview:cat {}' --preview-window hidden
+
+.SS CHANGE PREVIEW WINDOW ATTRIBUTES
+
+\fBchange-preview-window\fR action can be used to change the properties of the
+preview window. Unlike the \fB--preview-window\fR option, you can specify
+multiple sets of options separated by '|' characters.
+
+e.g.
+     # Rotate through the options using CTRL-/
+     fzf --preview 'cat {}' --bind 'ctrl-/:change-preview-window(right,70%|down,40%,border-horizontal|hidden|right)'
+
+     # The default properties given by `--preview-window` are inherited, so an empty string in the list is interpreted as the default
+     fzf --preview 'cat {}' --preview-window 'right,40%,border-left' --bind 'ctrl-/:change-preview-window(70%|down,border-top|hidden|)'
+
+     # This is equivalent to toggle-preview action
+     fzf --preview 'cat {}' --bind 'ctrl-/:change-preview-window(hidden|)'
 
 .SH AUTHOR
 Junegunn Choi (\fIjunegunn.c@gmail.com\fR)

shell/completion.bash

@@ -1,38 +1,65 @@
-#!/bin/bash
 #     ____      ____
 #    / __/___  / __/
 #   / /_/_  / / /_
 #  / __/ / /_/ __/
-# /_/   /___/_/-completion.bash
+# /_/   /___/_/ completion.bash
 #
-# - $FZF_TMUX               (default: 1)
+# - $FZF_TMUX               (default: 0)
-# - $FZF_TMUX_HEIGHT        (default: '40%')
+# - $FZF_TMUX_OPTS          (default: empty)
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
+if [[ $- =~ i ]]; then
+
 # To use custom commands instead of find, override _fzf_compgen_{path,dir}
 if ! declare -f _fzf_compgen_path > /dev/null; then
   _fzf_compgen_path() {
     echo "$1"
-    \find -L "$1" \
+    command find -L "$1" \
-      -name .git -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
   }
 fi
 
 if ! declare -f _fzf_compgen_dir > /dev/null; then
   _fzf_compgen_dir() {
-    \find -L "$1" \
+    command find -L "$1" \
-      -name .git -prune -o -name .svn -prune -o -type d \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
   }
 fi
 
 ###########################################################
 
-_fzf_orig_completion_filter() {
+# To redraw line after fzf closes (printf '\e[5n')
-  sed 's/^\(.*-F\) *\([^ ]*\).* \([^ ]*\)$/export _fzf_orig_completion_\3="\1 %s \3 #\2";/' |
+bind '"\e[0n": redraw-current-line' 2> /dev/null
-  awk -F= '{gsub(/[^a-z0-9_= ;]/, "_", $1); print $1"="$2}'
+
+__fzf_comprun() {
+  if [[ "$(type -t _fzf_comprun 2>&1)" = function ]]; then
+    _fzf_comprun "$@"
+  elif [[ -n "$TMUX_PANE" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "$FZF_TMUX_OPTS" ]]; }; then
+    shift
+    fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- "$@"
+  else
+    shift
+    fzf "$@"
+  fi
+}
+
+__fzf_orig_completion() {
+  local l comp f cmd
+  while read -r l; do
+    if [[ "$l" =~ ^(.*\ -F)\ *([^ ]*).*\ ([^ ]*)$ ]]; then
+      comp="${BASH_REMATCH[1]}"
+      f="${BASH_REMATCH[2]}"
+      cmd="${BASH_REMATCH[3]}"
+      [[ "$f" = _fzf_* ]] && continue
+      printf -v "_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}" "%s" "${comp} %s ${cmd} #${f}"
+      if [[ "$l" = *" -o nospace "* ]] && [[ ! "$__fzf_nospace_commands" = *" $cmd "* ]]; then
+        __fzf_nospace_commands="$__fzf_nospace_commands $cmd "
+      fi
+    fi
+  done
 }
 
 _fzf_opts_completion() {
@@ -43,35 +70,45 @@ _fzf_opts_completion() {
   opts="
     -x --extended
     -e --exact
+    --algo
     -i +i
     -n --nth
+    --with-nth
     -d --delimiter
     +s --no-sort
     --tac
     --tiebreak
-    --bind
     -m --multi
     --no-mouse
-    --color
+    --bind
-    --black
+    --cycle
-    --reverse
     --no-hscroll
+    --jump-labels
+    --height
+    --literal
+    --reverse
+    --margin
     --inline-info
     --prompt
+    --pointer
+    --marker
+    --header
+    --header-lines
+    --ansi
+    --tabstop
+    --color
+    --no-bold
+    --history
+    --history-size
+    --preview
+    --preview-window
     -q --query
     -1 --select-1
     -0 --exit-0
     -f --filter
     --print-query
     --expect
-    --toggle-sort
+    --sync"
-    --sync
-    --cycle
-    --history
-    --history-size
-    --header
-    --header-lines
-    --margin"
 
   case "${prev}" in
   --tiebreak)
@@ -97,27 +134,34 @@ _fzf_opts_completion() {
 }
 
 _fzf_handle_dynamic_completion() {
-  local cmd orig_var orig ret orig_cmd
+  local cmd orig_var orig ret orig_cmd orig_complete
   cmd="$1"
   shift
   orig_cmd="$1"
   orig_var="_fzf_orig_completion_$cmd"
   orig="${!orig_var##*#}"
-  if [ -n "$orig" ] && type "$orig" > /dev/null 2>&1; then
+  if [[ -n "$orig" ]] && type "$orig" > /dev/null 2>&1; then
     $orig "$@"
-  elif [ -n "$_fzf_completion_loader" ]; then
+  elif [[ -n "$_fzf_completion_loader" ]]; then
+    orig_complete=$(complete -p "$orig_cmd" 2> /dev/null)
     _completion_loader "$@"
     ret=$?
-    eval "$(complete | \grep "\-F.* $orig_cmd$" | _fzf_orig_completion_filter)"
+    # _completion_loader may not have updated completion for the command
-    source "${BASH_SOURCE[0]}"
+    if [[ "$(complete -p "$orig_cmd" 2> /dev/null)" != "$orig_complete" ]]; then
+      __fzf_orig_completion < <(complete -p "$orig_cmd" 2> /dev/null)
+      if [[ "$__fzf_nospace_commands" = *" $orig_cmd "* ]]; then
+        eval "${orig_complete/ -F / -o nospace -F }"
+      else
+        eval "$orig_complete"
+      fi
+    fi
     return $ret
   fi
 }
 
 __fzf_generic_path_completion() {
-  local cur base dir leftover matches trigger cmd fzf
+  local cur base dir leftover matches trigger cmd
-  [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+  cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
-  cmd=$(echo "${COMP_WORDS[0]}" | sed 's/[^a-z0-9_=]/_/g')
   COMPREPLY=()
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
@@ -125,24 +169,24 @@ __fzf_generic_path_completion() {
     base=${cur:0:${#cur}-${#trigger}}
     eval "base=$base"
 
-    dir="$base"
+    [[ $base = *"/"* ]] && dir="$base"
     while true; do
-      if [ -z "$dir" ] || [ -d "$dir" ]; then
+      if [[ -z "$dir" ]] || [[ -d "$dir" ]]; then
         leftover=${base/#"$dir"}
         leftover=${leftover/#\/}
-        [ -z "$dir" ] && dir='.'
+        [[ -z "$dir" ]] && dir='.'
-        [ "$dir" != "/" ] && dir="${dir/%\//}"
+        [[ "$dir" != "/" ]] && dir="${dir/%\//}"
-        tput sc
+        matches=$(eval "$1 $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $2" __fzf_comprun "$4" -q "$leftover" | while read -r item; do
-        matches=$(eval "$1 $(printf %q "$dir")" | $fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read -r item; do
           printf "%q$3 " "$item"
         done)
         matches=${matches% }
-        if [ -n "$matches" ]; then
+        [[ -z "$3" ]] && [[ "$__fzf_nospace_commands" = *" ${COMP_WORDS[0]} "* ]] && matches="$matches "
+        if [[ -n "$matches" ]]; then
           COMPREPLY=( "$matches" )
         else
           COMPREPLY=( "$cur" )
         fi
-        tput rc
+        printf '\e[5n'
         return 0
       fi
       dir=$(dirname "$dir")
@@ -157,29 +201,48 @@ __fzf_generic_path_completion() {
 }
 
 _fzf_complete() {
-  local cur selected trigger cmd fzf post
+  # Split arguments around --
+  local args rest str_arg i sep
+  args=("$@")
+  sep=
+  for i in "${!args[@]}"; do
+    if [[ "${args[$i]}" = -- ]]; then
+      sep=$i
+      break
+    fi
+  done
+  if [[ -n "$sep" ]]; then
+    str_arg=
+    rest=("${args[@]:$((sep + 1)):${#args[@]}}")
+    args=("${args[@]:0:$sep}")
+  else
+    str_arg=$1
+    args=()
+    shift
+    rest=("$@")
+  fi
+
+  local cur selected trigger cmd post
   post="$(caller 0 | awk '{print $2}')_post"
   type -t "$post" > /dev/null 2>&1 || post=cat
-  [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
 
-  cmd=$(echo "${COMP_WORDS[0]}" | sed 's/[^a-z0-9_=]/_/g')
+  cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
   if [[ "$cur" == *"$trigger" ]]; then
     cur=${cur:0:${#cur}-${#trigger}}
 
-    tput sc
+    selected=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $str_arg" __fzf_comprun "${rest[0]}" "${args[@]}" -q "$cur" | $post | tr '\n' ' ')
-    selected=$(cat | $fzf $FZF_COMPLETION_OPTS $1 -q "$cur" | $post | tr '\n' ' ')
     selected=${selected% } # Strip trailing space not to repeat "-o nospace"
-    tput rc
+    if [[ -n "$selected" ]]; then
-
-    if [ -n "$selected" ]; then
       COMPREPLY=("$selected")
-      return 0
+    else
+      COMPREPLY=("$cur")
     fi
+    printf '\e[5n'
+    return 0
   else
-    shift
+    _fzf_handle_dynamic_completion "$cmd" "${rest[@]}"
-    _fzf_handle_dynamic_completion "$cmd" "$@"
   fi
 }
 
@@ -197,50 +260,44 @@ _fzf_dir_completion() {
 }
 
 _fzf_complete_kill() {
-  [ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1
+  local trigger=${FZF_COMPLETION_TRIGGER-'**'}
-
+  local cur="${COMP_WORDS[COMP_CWORD]}"
-  local selected fzf
+  if [[ -z "$cur" ]]; then
-  [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+    COMP_WORDS[$COMP_CWORD]=$trigger
-  tput sc
+  elif [[ "$cur" != *"$trigger" ]]; then
-  selected=$(ps -ef | sed 1d | $fzf -m $FZF_COMPLETION_OPTS | awk '{print $2}' | tr '\n' ' ')
+    return 1
-  tput rc
-
-  if [ -n "$selected" ]; then
-    COMPREPLY=( "$selected" )
-    return 0
   fi
+
+  _fzf_proc_completion "$@"
 }
 
-_fzf_complete_telnet() {
+_fzf_proc_completion() {
-  _fzf_complete '+m' "$@" < <(
+  _fzf_complete -m --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
-    \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' |
+    command ps -ef | sed 1d
+  )
+}
+
+_fzf_proc_completion_post() {
+  awk '{print $2}'
+}
+
+_fzf_host_completion() {
+  _fzf_complete +m -- "$@" < <(
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?]') \
+        <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
+        <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
         awk '{if (length($2) > 0) {print $2}}' | sort -u
   )
 }
 
-_fzf_complete_ssh() {
+_fzf_var_completion() {
-  _fzf_complete '+m' "$@" < <(
+  _fzf_complete -m -- "$@" < <(
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') \
-        <(\grep -oE '^[^ ]+' ~/.ssh/known_hosts | tr ',' '\n' | awk '{ print $1 " " $1 }') \
-        <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') |
-        awk '{if (length($2) > 0) {print $2}}' | sort -u
-  )
-}
-
-_fzf_complete_unset() {
-  _fzf_complete '-m' "$@" < <(
     declare -xp | sed 's/=.*//' | sed 's/.* //'
   )
 }
 
-_fzf_complete_export() {
+_fzf_alias_completion() {
-  _fzf_complete '-m' "$@" < <(
+  _fzf_complete -m -- "$@" < <(
-    declare -xp | sed 's/=.*//' | sed 's/.* //'
-  )
-}
-
-_fzf_complete_unalias() {
-  _fzf_complete '-m' "$@" < <(
     alias | sed 's/=.*//' | sed 's/.* //'
   )
 }
@@ -258,28 +315,22 @@ a_cmds="
   find git grep gunzip gzip hg jar
   ln ls mv open rm rsync scp
   svn tar unzip zip"
-x_cmds="kill ssh telnet unset unalias export"
 
 # Preserve existing completion
-if [ "$_fzf_completion_loaded" != '0.11.3' ]; then
+__fzf_orig_completion < <(complete -p $d_cmds $a_cmds 2> /dev/null)
-  # Really wish I could use associative array but OSX comes with bash 3.2 :(
-  eval $(complete | \grep '\-F' | \grep -v _fzf_ |
-    \grep -E " ($(echo $d_cmds $a_cmds $x_cmds | sed 's/ /|/g' | sed 's/+/\\+/g'))$" | _fzf_orig_completion_filter)
-  export _fzf_completion_loaded=0.11.3
-fi
 
 if type _completion_loader > /dev/null 2>&1; then
   _fzf_completion_loader=1
 fi
 
-_fzf_defc() {
+__fzf_defc() {
   local cmd func opts orig_var orig def
   cmd="$1"
   func="$2"
   opts="$3"
-  orig_var="_fzf_orig_completion_$cmd"
+  orig_var="_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}"
   orig="${!orig_var}"
-  if [ -n "$orig" ]; then
+  if [[ -n "$orig" ]]; then
     printf -v def "$orig" "$func"
     eval "$def"
   else
@@ -289,26 +340,42 @@ _fzf_defc() {
 
 # Anything
 for cmd in $a_cmds; do
-  _fzf_defc "$cmd" _fzf_path_completion "-o default -o bashdefault"
+  __fzf_defc "$cmd" _fzf_path_completion "-o default -o bashdefault"
 done
 
 # Directory
 for cmd in $d_cmds; do
-  _fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o plusdirs"
+  __fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o dirnames"
 done
 
-unset _fzf_defc
+# Kill completion (supports empty completion trigger)
+complete -F _fzf_complete_kill -o default -o bashdefault kill
 
-# Kill completion
+unset cmd d_cmds a_cmds
-complete -F _fzf_complete_kill -o nospace -o default -o bashdefault kill
 
-# Host completion
+_fzf_setup_completion() {
-complete -F _fzf_complete_ssh -o default -o bashdefault ssh
+  local kind fn cmd
-complete -F _fzf_complete_telnet -o default -o bashdefault telnet
+  kind=$1
+  fn=_fzf_${1}_completion
+  if [[ $# -lt 2 ]] || ! type -t "$fn" > /dev/null; then
+    echo "usage: ${FUNCNAME[0]} path|dir|var|alias|host|proc COMMANDS..."
+    return 1
+  fi
+  shift
+  __fzf_orig_completion < <(complete -p "$@" 2> /dev/null)
+  for cmd in "$@"; do
+    case "$kind" in
+      dir)   __fzf_defc "$cmd" "$fn" "-o nospace -o dirnames" ;;
+      var)   __fzf_defc "$cmd" "$fn" "-o default -o nospace -v" ;;
+      alias) __fzf_defc "$cmd" "$fn" "-a" ;;
+      *)     __fzf_defc "$cmd" "$fn" "-o default -o bashdefault" ;;
+    esac
+  done
+}
 
-# Environment variables / Aliases
+# Environment variables / Aliases / Hosts
-complete -F _fzf_complete_unset -o default -o bashdefault unset
+_fzf_setup_completion 'var'   export unset
-complete -F _fzf_complete_export -o default -o bashdefault export
+_fzf_setup_completion 'alias' unalias
-complete -F _fzf_complete_unalias -o default -o bashdefault unalias
+_fzf_setup_completion 'host'  ssh telnet
 
-unset cmd d_cmds a_cmds x_cmds
+fi

shell/completion.zsh

@@ -1,63 +1,158 @@
-#!/bin/zsh
 #     ____      ____
 #    / __/___  / __/
 #   / /_/_  / / /_
 #  / __/ / /_/ __/
-# /_/   /___/_/-completion.zsh
+# /_/   /___/_/ completion.zsh
 #
-# - $FZF_TMUX               (default: 1)
+# - $FZF_TMUX               (default: 0)
-# - $FZF_TMUX_HEIGHT        (default: '40%')
+# - $FZF_TMUX_OPTS          (default: '-d 40%')
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
+# Both branches of the following `if` do the same thing -- define
+# __fzf_completion_options such that `eval $__fzf_completion_options` sets
+# all options to the same values they currently have. We'll do just that at
+# the bottom of the file after changing options to what we prefer.
+#
+# IMPORTANT: Until we get to the `emulate` line, all words that *can* be quoted
+# *must* be quoted in order to prevent alias expansion. In addition, code must
+# be written in a way works with any set of zsh options. This is very tricky, so
+# careful when you change it.
+#
+# Start by loading the builtin zsh/parameter module. It provides `options`
+# associative array that stores current shell options.
+if 'zmodload' 'zsh/parameter' 2>'/dev/null' && (( ${+options} )); then
+  # This is the fast branch and it gets taken on virtually all Zsh installations.
+  #
+  # ${(kv)options[@]} expands to array of keys (option names) and values ("on"
+  # or "off"). The subsequent expansion# with (j: :) flag joins all elements
+  # together separated by spaces. __fzf_completion_options ends up with a value
+  # like this: "options=(shwordsplit off aliases on ...)".
+  __fzf_completion_options="options=(${(j: :)${(kv)options[@]}})"
+else
+  # This branch is much slower because it forks to get the names of all
+  # zsh options. It's possible to eliminate this fork but it's not worth the
+  # trouble because this branch gets taken only on very ancient or broken
+  # zsh installations.
+  () {
+    # That `()` above defines an anonymous function. This is essentially a scope
+    # for local parameters. We use it to avoid polluting global scope.
+    'local' '__fzf_opt'
+    __fzf_completion_options="setopt"
+    # `set -o` prints one line for every zsh option. Each line contains option
+    # name, some spaces, and then either "on" or "off". We just want option names.
+    # Expansion with (@f) flag splits a string into lines. The outer expansion
+    # removes spaces and everything that follow them on every line. __fzf_opt
+    # ends up iterating over option names: shwordsplit, aliases, etc.
+    for __fzf_opt in "${(@)${(@f)$(set -o)}%% *}"; do
+      if [[ -o "$__fzf_opt" ]]; then
+        # Option $__fzf_opt is currently on, so remember to set it back on.
+        __fzf_completion_options+=" -o $__fzf_opt"
+      else
+        # Option $__fzf_opt is currently off, so remember to set it back off.
+        __fzf_completion_options+=" +o $__fzf_opt"
+      fi
+    done
+    # The value of __fzf_completion_options here looks like this:
+    # "setopt +o shwordsplit -o aliases ..."
+  }
+fi
+
+# Enable the default zsh options (those marked with <Z> in `man zshoptions`)
+# but without `aliases`. Aliases in functions are expanded when functions are
+# defined, so if we disable aliases here, we'll be sure to have no pesky
+# aliases in any of our functions. This way we won't need prefix every
+# command with `command` or to quote every word to defend against global
+# aliases. Note that `aliases` is not the only option that's important to
+# control. There are several others that could wreck havoc if they are set
+# to values we don't expect. With the following `emulate` command we
+# sidestep this issue entirely.
+'emulate' 'zsh' '-o' 'no_aliases'
+
+# This brace is the start of try-always block. The `always` part is like
+# `finally` in lesser languages. We use it to *always* restore user options.
+{
+
+# Bail out if not interactive shell.
+[[ -o interactive ]] || return 0
+
 # To use custom commands instead of find, override _fzf_compgen_{path,dir}
 if ! declare -f _fzf_compgen_path > /dev/null; then
   _fzf_compgen_path() {
     echo "$1"
-    \find -L "$1" \
+    command find -L "$1" \
-      -name .git -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
   }
 fi
 
 if ! declare -f _fzf_compgen_dir > /dev/null; then
   _fzf_compgen_dir() {
-    \find -L "$1" \
+    command find -L "$1" \
-      -name .git -prune -o -name .svn -prune -o -type d \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
   }
 fi
 
 ###########################################################
 
+__fzf_comprun() {
+  if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
+    _fzf_comprun "$@"
+  elif [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; }; then
+    shift
+    if [ -n "$FZF_TMUX_OPTS" ]; then
+      fzf-tmux ${(Q)${(Z+n+)FZF_TMUX_OPTS}} -- "$@"
+    else
+      fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%} -- "$@"
+    fi
+  else
+    shift
+    fzf "$@"
+  fi
+}
+
+# Extract the name of the command. e.g. foo=1 bar baz**<tab>
+__fzf_extract_command() {
+  local token tokens
+  tokens=(${(z)1})
+  for token in $tokens; do
+    token=${(Q)token}
+    if [[ "$token" =~ [[:alnum:]] && ! "$token" =~ "=" ]]; then
+      echo "$token"
+      return
+    fi
+  done
+  echo "${tokens[1]}"
+}
+
 __fzf_generic_path_completion() {
-  local base lbuf compgen fzf_opts suffix tail fzf dir leftover matches
+  local base lbuf cmd compgen fzf_opts suffix tail dir leftover matches
-  # (Q) flag removes a quoting level: "foo\ bar" => "foo bar"
+  base=$1
-  base=${(Q)1}
   lbuf=$2
+  cmd=$(__fzf_extract_command "$lbuf")
   compgen=$3
   fzf_opts=$4
   suffix=$5
   tail=$6
-  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
 
   setopt localoptions nonomatch
-  dir="$base"
+  eval "base=$base"
+  [[ $base = *"/"* ]] && dir="$base"
   while [ 1 ]; do
-    if [ -z "$dir" -o -d ${~dir} ]; then
+    if [[ -z "$dir" || -d ${dir} ]]; then
       leftover=${base/#"$dir"}
       leftover=${leftover/#\/}
       [ -z "$dir" ] && dir='.'
       [ "$dir" != "/" ] && dir="${dir/%\//}"
-      dir=${~dir}
+      matches=$(eval "$compgen $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS" __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" | while read item; do
-      matches=$(eval "$compgen $(printf %q "$dir")" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "$leftover" | while read item; do
         echo -n "${(q)item}$suffix "
       done)
       matches=${matches% }
       if [ -n "$matches" ]; then
         LBUFFER="$lbuf$matches$tail"
       fi
-      zle redisplay
+      zle reset-prompt
       break
     fi
     dir=$(dirname "$dir")
@@ -76,67 +171,97 @@ _fzf_dir_completion() {
 }
 
 _fzf_feed_fifo() (
-  rm -f "$1"
+  command rm -f "$1"
   mkfifo "$1"
   cat <&0 > "$1" &
 )
 
 _fzf_complete() {
-  local fifo fzf_opts lbuf fzf matches post
+  setopt localoptions ksh_arrays
+  # Split arguments around --
+  local args rest str_arg i sep
+  args=("$@")
+  sep=
+  for i in {0..${#args[@]}}; do
+    if [[ "${args[$i]}" = -- ]]; then
+      sep=$i
+      break
+    fi
+  done
+  if [[ -n "$sep" ]]; then
+    str_arg=
+    rest=("${args[@]:$((sep + 1)):${#args[@]}}")
+    args=("${args[@]:0:$sep}")
+  else
+    str_arg=$1
+    args=()
+    shift
+    rest=("$@")
+  fi
+
+  local fifo lbuf cmd matches post
   fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
-  fzf_opts=$1
+  lbuf=${rest[0]}
-  lbuf=$2
+  cmd=$(__fzf_extract_command "$lbuf")
-  post="${funcstack[2]}_post"
+  post="${funcstack[1]}_post"
   type $post > /dev/null 2>&1 || post=cat
 
-  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
-
   _fzf_feed_fifo "$fifo"
-  matches=$(cat "$fifo" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "${(Q)prefix}" | $post | tr '\n' ' ')
+  matches=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $str_arg" __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
   if [ -n "$matches" ]; then
     LBUFFER="$lbuf$matches"
   fi
-  zle redisplay
+  command rm -f "$fifo"
-  rm -f "$fifo"
 }
 
 _fzf_complete_telnet() {
-  _fzf_complete '+m' "$@" < <(
+  _fzf_complete +m -- "$@" < <(
-    \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' |
+    command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0' |
         awk '{if (length($2) > 0) {print $2}}' | sort -u
   )
 }
 
 _fzf_complete_ssh() {
-  _fzf_complete '+m' "$@" < <(
+  _fzf_complete +m -- "$@" < <(
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') \
+    setopt localoptions nonomatch
-        <(\grep -oE '^[^ ]+' ~/.ssh/known_hosts | tr ',' '\n' | awk '{ print $1 " " $1 }') \
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?]') \
-        <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') |
+        <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
+        <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
         awk '{if (length($2) > 0) {print $2}}' | sort -u
   )
 }
 
 _fzf_complete_export() {
-  _fzf_complete '-m' "$@" < <(
+  _fzf_complete -m -- "$@" < <(
     declare -xp | sed 's/=.*//' | sed 's/.* //'
   )
 }
 
 _fzf_complete_unset() {
-  _fzf_complete '-m' "$@" < <(
+  _fzf_complete -m -- "$@" < <(
     declare -xp | sed 's/=.*//' | sed 's/.* //'
   )
 }
 
 _fzf_complete_unalias() {
-  _fzf_complete '+m' "$@" < <(
+  _fzf_complete +m -- "$@" < <(
     alias | sed 's/=.*//'
   )
 }
 
+_fzf_complete_kill() {
+  _fzf_complete -m --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+    command ps -ef | sed 1d
+  )
+}
+
+_fzf_complete_kill_post() {
+  awk '{print $2}'
+}
+
 fzf-completion() {
-  local tokens cmd prefix trigger tail fzf matches lbuf d_cmds
+  local tokens cmd prefix trigger tail matches lbuf d_cmds
-  setopt localoptions noshwordsplit
+  setopt localoptions noshwordsplit noksh_arrays noposixbuiltins
 
   # http://zsh.sourceforge.net/FAQ/zshfaq03.html
   # http://zsh.sourceforge.net/Doc/Release/Expansion.html#Parameter-Expansion-Flags
@@ -146,30 +271,37 @@ fzf-completion() {
     return
   fi
 
-  cmd=${tokens[1]}
+  cmd=$(__fzf_extract_command "$LBUFFER")
 
   # Explicitly allow for empty trigger.
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   [ -z "$trigger" -a ${LBUFFER[-1]} = ' ' ] && tokens+=("")
 
+  # When the trigger starts with ';', it becomes a separate token
+  if [[ ${LBUFFER} = *"${tokens[-2]}${tokens[-1]}" ]]; then
+    tokens[-2]="${tokens[-2]}${tokens[-1]}"
+    tokens=(${tokens[0,-2]})
+  fi
+
+  lbuf=$LBUFFER
   tail=${LBUFFER:$(( ${#LBUFFER} - ${#trigger} ))}
   # Kill completion (do not require trigger sequence)
-  if [ $cmd = kill -a ${LBUFFER[-1]} = ' ' ]; then
+  if [ "$cmd" = kill -a ${LBUFFER[-1]} = ' ' ]; then
-    [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+    tail=$trigger
-    matches=$(ps -ef | sed 1d | ${=fzf} ${=FZF_COMPLETION_OPTS} -m | awk '{print $2}' | tr '\n' ' ')
+    tokens+=$trigger
-    if [ -n "$matches" ]; then
+    lbuf="$lbuf$trigger"
-      LBUFFER="$LBUFFER$matches"
+  fi
-    fi
+
-    zle redisplay
   # Trigger sequence given
-  elif [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
+  if [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
     d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir})
 
     [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
-    [ -z "${tokens[-1]}" ] && lbuf=$LBUFFER        || lbuf=${LBUFFER:0:-${#tokens[-1]}}
+    [ -n "${tokens[-1]}" ] && lbuf=${lbuf:0:-${#tokens[-1]}}
 
     if eval "type _fzf_complete_${cmd} > /dev/null"; then
-      eval "prefix=\"$prefix\" _fzf_complete_${cmd} \"$lbuf\""
+      prefix="$prefix" eval _fzf_complete_${cmd} ${(q)lbuf}
+      zle reset-prompt
     elif [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
       _fzf_dir_completion "$prefix" "$lbuf"
     else
@@ -183,9 +315,15 @@ fzf-completion() {
 
 [ -z "$fzf_default_completion" ] && {
   binding=$(bindkey '^I')
-  [[ $binding =~ 'undefined-key' ]] || fzf_default_completion=$binding[(w)2]
+  [[ $binding =~ 'undefined-key' ]] || fzf_default_completion=$binding[(s: :w)2]
   unset binding
 }
 
 zle     -N   fzf-completion
 bindkey '^I' fzf-completion
+
+} always {
+  # Restore the original options.
+  eval $__fzf_completion_options
+  'unset' '__fzf_completion_options'
+}

shell/key-bindings.bash

@@ -1,11 +1,24 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.bash
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
 # Key bindings
 # ------------
 __fzf_select__() {
-  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
     -o -type f -print \
     -o -type d -print \
-    -o -type l -print 2> /dev/null | sed 1d | cut -b3-"}"
+    -o -type l -print 2> /dev/null | cut -b3-"}"
-  eval "$cmd | fzf -m $FZF_CTRL_T_OPTS" | while read -r item; do
+  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" $(__fzfcmd) -m "$@" | while read -r item; do
     printf '%q ' "$item"
   done
   echo
@@ -14,112 +27,70 @@ __fzf_select__() {
 if [[ $- =~ i ]]; then
 
 __fzfcmd() {
-  [ "${FZF_TMUX:-1}" != 0 ] && echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+  [[ -n "$TMUX_PANE" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "$FZF_TMUX_OPTS" ]]; } &&
-}
+    echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
-
-__fzf_select_tmux__() {
-  local height
-  height=${FZF_TMUX_HEIGHT:-40%}
-  if [[ $height =~ %$ ]]; then
-    height="-p ${height%\%}"
-  else
-    height="-l $height"
-  fi
-
-  tmux split-window $height "cd $(printf %q "$PWD"); FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS") PATH=$(printf %q "$PATH") FZF_CTRL_T_COMMAND=$(printf %q "$FZF_CTRL_T_COMMAND") FZF_CTRL_T_OPTS=$(printf %q "$FZF_CTRL_T_OPTS") bash -c 'source \"${BASH_SOURCE[0]}\"; tmux send-keys -t $TMUX_PANE \"\$(__fzf_select__)\"'"
 }
 
 fzf-file-widget() {
-  if __fzf_use_tmux__; then
+  local selected="$(__fzf_select__)"
-    __fzf_select_tmux__
+  READLINE_LINE="${READLINE_LINE:0:$READLINE_POINT}$selected${READLINE_LINE:$READLINE_POINT}"
-  else
+  READLINE_POINT=$(( READLINE_POINT + ${#selected} ))
-    local selected="$(__fzf_select__)"
-    READLINE_LINE="${READLINE_LINE:0:$READLINE_POINT}$selected${READLINE_LINE:$READLINE_POINT}"
-    READLINE_POINT=$(( READLINE_POINT + ${#selected} ))
-  fi
 }
 
 __fzf_cd__() {
   local cmd dir
-  cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  cmd="${FZF_ALT_C_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
-    -o -type d -print 2> /dev/null | sed 1d | cut -b3-"}"
+    -o -type d -print 2> /dev/null | cut -b3-"}"
-  dir=$(eval "$cmd | $(__fzfcmd) +m $FZF_ALT_C_OPTS") && printf 'cd %q' "$dir"
+  dir=$(eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS" $(__fzfcmd) +m) && printf 'cd -- %q' "$dir"
 }
 
-__fzf_history__() (
+__fzf_history__() {
-  local line
+  local output
-  shopt -u nocaseglob nocasematch
+  output=$(
-  line=$(
+    builtin fc -lnr -2147483648 |
-    HISTTIMEFORMAT= history |
+      last_hist=$(HISTTIMEFORMAT='' builtin history 1) perl -n -l0 -e 'BEGIN { getc; $/ = "\n\t"; $HISTCMD = $ENV{last_hist} + 1 } s/^[ *]//; print $HISTCMD - $. . "\t$_" if !$seen{$_}++' |
-    eval "$(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS" |
+      FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS +m --read0" $(__fzfcmd) --query "$READLINE_LINE"
-    \grep '^ *[0-9]') &&
+  ) || return
-    if [[ $- =~ H ]]; then
+  READLINE_LINE=${output#*$'\t'}
-      sed 's/^ *\([0-9]*\)\** .*/!\1/' <<< "$line"
+  if [[ -z "$READLINE_POINT" ]]; then
-    else
+    echo "$READLINE_LINE"
-      sed 's/^ *\([0-9]*\)\** *//' <<< "$line"
-    fi
-)
-
-__fzf_use_tmux__() {
-  [ -n "$TMUX_PANE" ] && [ "${FZF_TMUX:-1}" != 0 ] && [ ${LINES:-40} -gt 15 ]
-}
-
-[ $BASH_VERSINFO -gt 3 ] && __use_bind_x=1 || __use_bind_x=0
-__fzf_use_tmux__ && __use_tmux=1 || __use_tmux=0
-
-if [[ ! -o vi ]]; then
-  # Required to refresh the prompt after fzf
-  bind '"\er": redraw-current-line'
-  bind '"\e^": history-expand-line'
-
-  # CTRL-T - Paste the selected file path into the command line
-  if [ $__use_bind_x -eq 1 ]; then
-    bind -x '"\C-t": "fzf-file-widget"'
-  elif [ $__use_tmux -eq 1 ]; then
-    bind '"\C-t": " \C-u \C-a\C-k$(__fzf_select_tmux__)\e\C-e\C-y\C-a\C-d\C-y\ey\C-h"'
   else
-    bind '"\C-t": " \C-u \C-a\C-k$(__fzf_select__)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er \C-h"'
+    READLINE_POINT=0x7fffffff
   fi
+}
+
+# Required to refresh the prompt after fzf
+bind -m emacs-standard '"\er": redraw-current-line'
+
+bind -m vi-command '"\C-z": emacs-editing-mode'
+bind -m vi-insert '"\C-z": emacs-editing-mode'
+bind -m emacs-standard '"\C-z": vi-editing-mode'
+
+if (( BASH_VERSINFO[0] < 4 )); then
+  # CTRL-T - Paste the selected file path into the command line
+  bind -m emacs-standard '"\C-t": " \C-b\C-k \C-u`__fzf_select__`\e\C-e\er\C-a\C-y\C-h\C-e\e \C-y\ey\C-x\C-x\C-f"'
+  bind -m vi-command '"\C-t": "\C-z\C-t\C-z"'
+  bind -m vi-insert '"\C-t": "\C-z\C-t\C-z"'
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": " \C-e\C-u`__fzf_history__`\e\C-e\e^\er"'
+  bind -m emacs-standard '"\C-r": "\C-e \C-u\C-y\ey\C-u"$(__fzf_history__)"\e\C-e\er"'
-
+  bind -m vi-command '"\C-r": "\C-z\C-r\C-z"'
-  # ALT-C - cd into the selected directory
+  bind -m vi-insert '"\C-r": "\C-z\C-r\C-z"'
-  bind '"\ec": " \C-e\C-u`__fzf_cd__`\e\C-e\er\C-m"'
 else
-  # We'd usually use "\e" to enter vi-movement-mode so we can do our magic,
-  # but this incurs a very noticeable delay of a half second or so,
-  # because many other commands start with "\e".
-  # Instead, we bind an unused key, "\C-x\C-a",
-  # to also enter vi-movement-mode,
-  # and then use that thereafter.
-  # (We imagine that "\C-x\C-a" is relatively unlikely to be in use.)
-  bind '"\C-x\C-a": vi-movement-mode'
-
-  bind '"\C-x\C-e": shell-expand-line'
-  bind '"\C-x\C-r": redraw-current-line'
-  bind '"\C-x^": history-expand-line'
-
   # CTRL-T - Paste the selected file path into the command line
-  # - FIXME: Selected items are attached to the end regardless of cursor position
+  bind -m emacs-standard -x '"\C-t": fzf-file-widget'
-  if [ $__use_bind_x -eq 1 ]; then
+  bind -m vi-command -x '"\C-t": fzf-file-widget'
-    bind -x '"\C-t": "fzf-file-widget"'
+  bind -m vi-insert -x '"\C-t": fzf-file-widget'
-  elif [ $__use_tmux -eq 1 ]; then
-    bind '"\C-t": "\C-x\C-a$a \C-x\C-addi$(__fzf_select_tmux__)\C-x\C-e\C-x\C-a0P$xa"'
-  else
-    bind '"\C-t": "\C-x\C-a$a \C-x\C-addi$(__fzf_select__)\C-x\C-e\C-x\C-a0Px$a \C-x\C-r\C-x\C-axa "'
-  fi
-  bind -m vi-command '"\C-t": "i\C-t"'
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": "\C-x\C-addi$(__fzf_history__)\C-x\C-e\C-x^\C-x\C-a$a\C-x\C-r"'
+  bind -m emacs-standard -x '"\C-r": __fzf_history__'
-  bind -m vi-command '"\C-r": "i\C-r"'
+  bind -m vi-command -x '"\C-r": __fzf_history__'
-
+  bind -m vi-insert -x '"\C-r": __fzf_history__'
-  # ALT-C - cd into the selected directory
-  bind '"\ec": "\C-x\C-addi$(__fzf_cd__)\C-x\C-e\C-x\C-r\C-m"'
-  bind -m vi-command '"\ec": "ddi$(__fzf_cd__)\C-x\C-e\C-x\C-r\C-m"'
 fi
 
-unset -v __use_tmux __use_bind_x
+# ALT-C - cd into the selected directory
+bind -m emacs-standard '"\ec": " \C-b\C-k \C-u`__fzf_cd__`\e\C-e\er\C-m\C-y\C-h\e \C-y\ey\C-x\C-x\C-d"'
+bind -m vi-command '"\ec": "\C-z\ec\C-z"'
+bind -m vi-insert '"\ec": "\C-z\ec\C-z"'
 
 fi

shell/key-bindings.fish

@@ -1,58 +1,110 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.fish
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
 # Key bindings
 # ------------
 function fzf_key_bindings
-  # Due to a bug of fish, we cannot use command substitution,
-  # so we use temporary file instead
-  if [ -z "$TMPDIR" ]
-    set -g TMPDIR /tmp
-  end
 
-  function __fzf_escape
+  # Store current token in $dir as root for the 'find' command
-    while read item
+  function fzf-file-widget -d "List files and folders"
-      echo -n (echo -n "$item" | sed -E 's/([ "$~'\''([{<>})])/\\\\\\1/g')' '
+    set -l commandline (__fzf_parse_commandline)
+    set -l dir $commandline[1]
+    set -l fzf_query $commandline[2]
+    set -l prefix $commandline[3]
+
+    # "-path \$dir'*/\\.*'" matches hidden files/folders inside $dir but not
+    # $dir itself, even if hidden.
+    test -n "$FZF_CTRL_T_COMMAND"; or set -l FZF_CTRL_T_COMMAND "
+    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 | sed 's@^\./@@'"
+
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    begin
+      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS"
+      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
+    else
+      # Remove last token from commandline.
+      commandline -t ""
+    end
+    for i in $result
+      commandline -it -- $prefix
+      commandline -it -- (string escape $i)
+      commandline -it -- ' '
+    end
+    commandline -f repaint
   end
 
-  function fzf-file-widget
+  function fzf-history-widget -d "Show command history"
-    set -q FZF_CTRL_T_COMMAND; or set -l FZF_CTRL_T_COMMAND "
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
-    command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+    begin
-      -o -type f -print \
+      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT $FZF_DEFAULT_OPTS --tiebreak=index --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS +m"
-      -o -type d -print \
+
-      -o -type l -print 2> /dev/null | sed 1d | cut -b3-"
+      set -l FISH_MAJOR (echo $version | cut -f1 -d.)
-    eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)" -m $FZF_CTRL_T_OPTS > $TMPDIR/fzf.result"
+      set -l FISH_MINOR (echo $version | cut -f2 -d.)
-    and for i in (seq 20); commandline -i (cat $TMPDIR/fzf.result | __fzf_escape) 2> /dev/null; and break; sleep 0.1; end
+
+      # 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 --print0 -q '(commandline)' | read -lz result
+        and commandline -- $result
+      else
+        history | eval (__fzfcmd) -q '(commandline)' | read -l result
+        and commandline -- $result
+      end
+    end
     commandline -f repaint
-    rm -f $TMPDIR/fzf.result
   end
 
-  function fzf-history-widget
+  function fzf-cd-widget -d "Change directory"
-    history | eval (__fzfcmd) +s +m --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS > $TMPDIR/fzf.result
+    set -l commandline (__fzf_parse_commandline)
-    and commandline (cat $TMPDIR/fzf.result)
+    set -l dir $commandline[1]
-    commandline -f repaint
+    set -l fzf_query $commandline[2]
-    rm -f $TMPDIR/fzf.result
+    set -l prefix $commandline[3]
-  end
+
+    test -n "$FZF_ALT_C_COMMAND"; or set -l FZF_ALT_C_COMMAND "
+    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@^\./@@'"
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    begin
+      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS"
+      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 ""
+        commandline -it -- $prefix
+      end
+    end
 
-  function fzf-cd-widget
-    set -q FZF_ALT_C_COMMAND; or set -l FZF_ALT_C_COMMAND "
-    command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
-      -o -type d -print 2> /dev/null | sed 1d | cut -b3-"
-    # Fish hangs if the command before pipe redirects (2> /dev/null)
-    eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)" +m $FZF_ALT_C_OPTS > $TMPDIR/fzf.result"
-    [ (cat $TMPDIR/fzf.result | wc -l) -gt 0 ]
-    and cd (cat $TMPDIR/fzf.result)
     commandline -f repaint
-    rm -f $TMPDIR/fzf.result
   end
 
   function __fzfcmd
-    set -q FZF_TMUX; or set FZF_TMUX 1
+    test -n "$FZF_TMUX"; or set FZF_TMUX 0
-
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
-    if [ $FZF_TMUX -eq 1 ]
+    if [ -n "$FZF_TMUX_OPTS" ]
-      if set -q FZF_TMUX_HEIGHT
+      echo "fzf-tmux $FZF_TMUX_OPTS -- "
-        echo "fzf-tmux -d$FZF_TMUX_HEIGHT"
+    else if [ $FZF_TMUX -eq 1 ]
-      else
+      echo "fzf-tmux -d$FZF_TMUX_HEIGHT -- "
-        echo "fzf-tmux -d40%"
-      end
     else
       echo "fzf"
     end
@@ -67,5 +119,54 @@ function fzf_key_bindings
     bind -M insert \cr fzf-history-widget
     bind -M insert \ec fzf-cd-widget
   end
-end
 
+  function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath, fzf query, and optional -option= prefix'
+    set -l commandline (commandline -t)
+
+    # strip -option= from token if present
+    set -l prefix (string match -r -- '^-[^\s=]+=' $commandline)
+    set commandline (string replace -- "$prefix" '' $commandline)
+
+    # eval is used to do shell expansion on paths
+    eval set commandline $commandline
+
+    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
+    echo $prefix
+  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

shell/key-bindings.zsh

@@ -1,36 +1,90 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.zsh
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
 # Key bindings
 # ------------
-if [[ $- == *i* ]]; then
+
+# The code at the top and the bottom of this file is the same as in completion.zsh.
+# Refer to that file for explanation.
+if 'zmodload' 'zsh/parameter' 2>'/dev/null' && (( ${+options} )); then
+  __fzf_key_bindings_options="options=(${(j: :)${(kv)options[@]}})"
+else
+  () {
+    __fzf_key_bindings_options="setopt"
+    'local' '__fzf_opt'
+    for __fzf_opt in "${(@)${(@f)$(set -o)}%% *}"; do
+      if [[ -o "$__fzf_opt" ]]; then
+        __fzf_key_bindings_options+=" -o $__fzf_opt"
+      else
+        __fzf_key_bindings_options+=" +o $__fzf_opt"
+      fi
+    done
+  }
+fi
+
+'emulate' 'zsh' '-o' 'no_aliases'
+
+{
+
+[[ -o interactive ]] || return 0
 
 # CTRL-T - Paste the selected file path(s) into the command line
 __fsel() {
-  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
     -o -type f -print \
     -o -type d -print \
-    -o -type l -print 2> /dev/null | sed 1d | cut -b3-"}"
+    -o -type l -print 2> /dev/null | cut -b3-"}"
-  eval "$cmd | $(__fzfcmd) -m $FZF_CTRL_T_OPTS" | while read item; do
+  setopt localoptions pipefail no_aliases 2> /dev/null
+  local item
+  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" $(__fzfcmd) -m "$@" | while read item; do
     echo -n "${(q)item} "
   done
+  local ret=$?
   echo
+  return $ret
 }
 
 __fzfcmd() {
-  [ ${FZF_TMUX:-1} -eq 1 ] && echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+  [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; } &&
+    echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
 }
 
 fzf-file-widget() {
   LBUFFER="${LBUFFER}$(__fsel)"
-  zle redisplay
+  local ret=$?
+  zle reset-prompt
+  return $ret
 }
 zle     -N   fzf-file-widget
 bindkey '^T' fzf-file-widget
 
 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
-  local cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+  local cmd="${FZF_ALT_C_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
-    -o -type d -print 2> /dev/null | sed 1d | cut -b3-"}"
+    -o -type d -print 2> /dev/null | cut -b3-"}"
-  cd "${$(eval "$cmd | $(__fzfcmd) +m $FZF_ALT_C_OPTS"):-.}"
+  setopt localoptions pipefail no_aliases 2> /dev/null
+  local dir="$(eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS" $(__fzfcmd) +m)"
+  if [[ -z "$dir" ]]; then
+    zle redisplay
+    return 0
+  fi
+  zle push-line # Clear buffer. Auto-restored on next prompt.
+  BUFFER="cd -- ${(q)dir}"
+  zle accept-line
+  local ret=$?
+  unset dir # ensure this doesn't end up appearing in prompt expansion
   zle reset-prompt
+  return $ret
 }
 zle     -N    fzf-cd-widget
 bindkey '\ec' fzf-cd-widget
@@ -38,18 +92,23 @@ bindkey '\ec' fzf-cd-widget
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
   local selected num
-  setopt localoptions noglobsubst
+  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2> /dev/null
-  selected=( $(fc -l 1 | eval "$(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS -q ${(q)LBUFFER}") )
+  selected=( $(fc -rl 1 | perl -ne 'print if !$seen{(/^\s*[0-9]+\**\s+(.*)/, $1)}++' |
+    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS --query=${(qqq)LBUFFER} +m" $(__fzfcmd)) )
+  local ret=$?
   if [ -n "$selected" ]; then
     num=$selected[1]
     if [ -n "$num" ]; then
       zle vi-fetch-history -n $num
     fi
   fi
-  zle redisplay
+  zle reset-prompt
+  return $ret
 }
 zle     -N   fzf-history-widget
 bindkey '^R' fzf-history-widget
 
-fi
+} always {
-
+  eval $__fzf_key_bindings_options
+  'unset' '__fzf_key_bindings_options'
+}

src/Dockerfile.android

@@ -1,40 +0,0 @@
-FROM ubuntu:14.04
-MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
-
-# apt-get
-RUN apt-get update && apt-get -y upgrade && \
-    apt-get install -y --force-yes git curl build-essential
-
-# Install Go 1.4
-RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
-    tar -xz && mv go go1.4 && \
-    sed -i 's@#define PTHREAD_KEYS_MAX 128@@' /go1.4/src/runtime/cgo/gcc_android_arm.c
-
-ENV GOROOT /go1.4
-ENV PATH /go1.4/bin:$PATH
-
-RUN cd / && \
-    curl -O http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin && \
-    chmod 755 /android-ndk* && /android-ndk-r10e-linux-x86_64.bin && \
-    mv android-ndk-r10e /android-ndk
-
-RUN cd /android-ndk && bash ./build/tools/make-standalone-toolchain.sh --platform=android-21 --install-dir=/ndk --arch=arm
-
-ENV NDK_CC /ndk/bin/arm-linux-androideabi-gcc
-
-RUN cd $GOROOT/src && \
-    CC_FOR_TARGET=$NDK_CC GOOS=android GOARCH=arm GOARM=7 ./make.bash
-
-RUN cd / && curl \
-    http://ftp.gnu.org/gnu/ncurses/ncurses-5.9.tar.gz | \
-    tar -xz && cd /ncurses-5.9 && \
-    ./configure CC=$NDK_CC CFLAGS="-fPIE -march=armv7-a -mfpu=neon -mhard-float -Wl,--no-warn-mismatch" LDFLAGS="-march=armv7-a -Wl,--no-warn-mismatch" --host=arm-linux --enable-overwrite --enable-const --without-cxx-binding  --without-shared --without-debug --enable-widec --enable-ext-colors --enable-ext-mouse --enable-pc-files --with-pkg-config-libdir=$PKG_CONFIG_LIBDIR --without-manpages --without-ada --disable-shared --without-tests --prefix=/ndk/sysroot/usr --with-default-terminfo-dirs=/usr/share/terminfo --with-terminfo-dirs=/usr/share/terminfo ac_cv_header_locale_h=n ac_cv_func_getpwent=no ac_cv_func_getpwnam=no ac_cv_func_getpwuid=no && \
-    sed -i 's@#define HAVE_LOCALE_H 1@/* #undef HAVE_LOCALE_H */@' include/ncurses_cfg.h && \
-    make && \
-    sed -i '0,/echo.*/{s/echo.*/exit 0/}' misc/run_tic.sh && \
-    make install && \
-    mv /ndk/sysroot/usr/lib/libncursesw.a /ndk/sysroot/usr/lib/libncurses.a
-
-# Default CMD
-CMD cd /fzf/src && /bin/bash

src/Dockerfile.arch

@@ -1,24 +0,0 @@
-FROM base/archlinux:2014.07.03
-MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
-
-# apt-get
-RUN pacman-key --populate archlinux && pacman-key --refresh-keys
-RUN pacman-db-upgrade && pacman -Syu --noconfirm base-devel git
-
-# Install Go 1.4
-RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
-    tar -xz && mv go go1.4
-
-ENV GOROOT /go1.4
-ENV PATH /go1.4/bin:$PATH
-
-# For i386 build
-RUN echo '[multilib]' >> /etc/pacman.conf && \
-    echo 'Include = /etc/pacman.d/mirrorlist' >> /etc/pacman.conf && \
-    pacman-db-upgrade && yes | pacman -Sy gcc-multilib lib32-ncurses && \
-    cd $GOROOT/src && GOARCH=386 ./make.bash
-
-# Default CMD
-CMD cd /fzf/src && /bin/bash
-

src/Dockerfile.centos

@@ -1,32 +0,0 @@
-FROM centos:centos6
-MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
-
-# yum
-RUN yum install -y git gcc make tar glibc-devel glibc-devel.i686 \
-    ncurses-devel ncurses-static ncurses-devel.i686 \
-    gpm-devel gpm-static libgcc.i686
-
-# Install Go 1.4
-RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
-    tar -xz && mv go go1.4
-
-# Install Go 1.5
-RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.5.3.linux-amd64.tar.gz | \
-    tar -xz && mv go go1.5
-
-# Install RPMs for building static 32-bit binary
-RUN curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.7/os/i386/Packages/ncurses-static-5.7-4.20090207.el6.i686.rpm -o rpm && rpm -i rpm && \
-    curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.7/os/i386/Packages/gpm-static-1.20.6-12.el6.i686.rpm -o rpm && rpm -i rpm
-
-ENV GOROOT_BOOTSTRAP /go1.4
-ENV GOROOT /go1.5
-ENV PATH /go1.5/bin:$PATH
-
-# For i386 build
-RUN cd $GOROOT/src && GOARCH=386 ./make.bash
-
-# Default CMD
-CMD cd /fzf/src && /bin/bash
-

src/Dockerfile.ubuntu

@@ -1,22 +0,0 @@
-FROM ubuntu:14.04
-MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
-
-# apt-get
-RUN apt-get update && apt-get -y upgrade && \
-    apt-get install -y --force-yes git curl build-essential libncurses-dev libgpm-dev
-
-# Install Go 1.4
-RUN cd / && curl \
-    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
-    tar -xz && mv go go1.4
-
-ENV GOROOT /go1.4
-ENV PATH /go1.4/bin:$PATH
-
-# For i386 build
-RUN apt-get install -y lib32ncurses5-dev && \
-    cd $GOROOT/src && GOARCH=386 ./make.bash
-
-# Default CMD
-CMD cd /fzf/src && /bin/bash
-

src/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

src/Makefile

@@ -1,116 +0,0 @@
-ifndef GOOS
-UNAME_S := $(shell uname -s)
-ifeq ($(UNAME_S),Darwin)
-	GOOS := darwin
-else ifeq ($(UNAME_S),Linux)
-	GOOS := linux
-endif
-endif
-
-SOURCES     := $(wildcard *.go */*.go)
-ROOTDIR     := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
-BINDIR      := $(shell dirname $(ROOTDIR))/bin
-GOPATH      := $(shell dirname $(ROOTDIR))/gopath
-SRCDIR      := $(GOPATH)/src/github.com/junegunn/fzf/src
-DOCKEROPTS  := -i -t -v $(ROOTDIR):/fzf/src
-BINARY32    := fzf-$(GOOS)_386
-BINARY64    := fzf-$(GOOS)_amd64
-BINARYARM7  := fzf-$(GOOS)_arm7
-VERSION     := $(shell awk -F= '/version =/ {print $$2}' constants.go | tr -d "\" ")
-RELEASE32   := fzf-$(VERSION)-$(GOOS)_386
-RELEASE64   := fzf-$(VERSION)-$(GOOS)_amd64
-RELEASEARM7 := fzf-$(VERSION)-$(GOOS)_arm7
-export GOPATH
-
-UNAME_M := $(shell uname -m)
-ifeq ($(UNAME_M),x86_64)
-	BINARY := $(BINARY64)
-else ifeq ($(UNAME_M),i686)
-	BINARY := $(BINARY32)
-else
-$(error "Build on $(UNAME_M) is not supported, yet.")
-endif
-
-all: fzf/$(BINARY)
-
-release: test fzf/$(BINARY32) fzf/$(BINARY64)
-	-cd fzf && cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32)
-	cd fzf && cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64) && \
-	rm -f $(RELEASE32) $(RELEASE64)
-
-$(SRCDIR):
-	mkdir -p $(shell dirname $(SRCDIR))
-	ln -s $(ROOTDIR) $(SRCDIR)
-
-deps: $(SRCDIR) $(SOURCES)
-	cd $(SRCDIR) && go get
-
-android-build: $(SRCDIR)
-	cd $(SRCDIR) && GOARCH=arm GOARM=7 CGO_ENABLED=1 go get
-	cd $(SRCDIR)/fzf && GOARCH=arm GOARM=7 CGO_ENABLED=1 go build -a -ldflags="-w -extldflags=-pie" -o $(BINARYARM7)
-	cd $(SRCDIR)/fzf && cp $(BINARYARM7) $(RELEASEARM7) && tar -czf $(RELEASEARM7).tgz $(RELEASEARM7) && \
-	rm -f $(RELEASEARM7)
-
-test: deps
-	SHELL=/bin/sh go test -v ./...
-
-install: $(BINDIR)/fzf
-
-uninstall:
-	rm -f $(BINDIR)/fzf $(BINDIR)/$(BINARY)
-
-clean:
-	cd fzf && rm -f fzf-*
-
-fzf/$(BINARY32): deps
-	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -a -ldflags -w -tags "$(TAGS)" -o $(BINARY32)
-
-fzf/$(BINARY64): deps
-	cd fzf && go build -a -ldflags -w -tags "$(TAGS)" -o $(BINARY64)
-
-$(BINDIR)/fzf: fzf/$(BINARY) | $(BINDIR)
-	cp -f fzf/$(BINARY) $(BINDIR)
-	cd $(BINDIR) && ln -sf $(BINARY) fzf
-
-$(BINDIR):
-	mkdir -p $@
-
-docker-arch:
-	docker build -t junegunn/arch-sandbox - < Dockerfile.arch
-
-docker-ubuntu:
-	docker build -t junegunn/ubuntu-sandbox - < Dockerfile.ubuntu
-
-docker-centos:
-	docker build -t junegunn/centos-sandbox - < Dockerfile.centos
-
-docker-android:
-	docker build -t junegunn/android-sandbox - < Dockerfile.android
-
-arch: docker-arch
-	docker run $(DOCKEROPTS) junegunn/$@-sandbox \
-		sh -c 'cd /fzf/src; /bin/bash'
-
-ubuntu: docker-ubuntu
-	docker run $(DOCKEROPTS) junegunn/$@-sandbox \
-		sh -c 'cd /fzf/src; /bin/bash'
-
-centos: docker-centos
-	docker run $(DOCKEROPTS) junegunn/$@-sandbox \
-		sh -c 'cd /fzf/src; /bin/bash'
-
-linux: docker-centos
-	docker run $(DOCKEROPTS) junegunn/centos-sandbox \
-		/bin/bash -ci 'cd /fzf/src; make TAGS=static release'
-
-ubuntu-android: docker-android
-	docker run $(DOCKEROPTS) junegunn/android-sandbox \
-		sh -c 'cd /fzf/src; /bin/bash'
-
-android: docker-android
-	docker run $(DOCKEROPTS) junegunn/android-sandbox \
-		/bin/bash -ci 'cd /fzf/src; GOOS=android make android-build'
-
-.PHONY: all deps release test install uninstall clean \
-	linux arch ubuntu centos docker-arch docker-ubuntu docker-centos \
-	android-build docker-android ubuntu-android android

src/README.md

@@ -1,121 +0,0 @@
-fzf in Go
-=========
-
-<img src="https://cloud.githubusercontent.com/assets/700826/5725028/028ea834-9b93-11e4-9198-43088c3f295d.gif" height="463" alt="fzf in go">
-
-This directory contains the source code for the new fzf implementation in
-[Go][go].
-
-Upgrade from Ruby version
--------------------------
-
-The install script has been updated to download the right binary for your
-system. If you already have installed fzf, simply git-pull the repository and
-rerun the install script.
-
-```sh
-cd ~/.fzf
-git pull
-./install
-```
-
-Otherwise, follow [the instruction][install] as before. You can also install
-fzf using Homebrew if you prefer that way.
-
-Motivations
------------
-
-### No Ruby dependency
-
-There have always been complaints about fzf being a Ruby script. To make
-matters worse, Ruby 2.1 removed ncurses binding from its standard libary.
-Because of the change, users running Ruby 2.1 or above are forced to build C
-extensions of curses gem to meet the requirement of fzf. The new Go version
-will be distributed as an executable binary so it will be much more accessible
-and should be easier to setup.
-
-### Performance
-
-Many people have been surprised to see how fast fzf is even when it was
-written in Ruby. It stays quite responsive even for 100k+ lines, which is
-well above the size of the usual input.
-
-The new Go version, of course, is significantly faster than that. It has all
-the performance optimization techniques used in Ruby implementation and more.
-It also doesn't suffer from [GIL][gil], so the search performance scales
-proportional to the number of CPU cores. On my MacBook Pro (Mid 2012), the new
-version was shown to be an order of magnitude faster on certain cases. It also
-starts much faster though the difference may not be noticeable.
-
-Differences with Ruby version
------------------------------
-
-The Go version is designed to be perfectly compatible with the previous Ruby
-version. The only behavioral difference is that the new version ignores the
-numeric argument to `--sort=N` option and always sorts the result regardless
-of the number of matches. The value was introduced to limit the response time
-of the query, but the Go version is blazingly fast (almost instant response
-even for 1M+ items) so I decided that it's no longer required.
-
-System requirements
--------------------
-
-Currently, prebuilt binaries are provided only for OS X and Linux. The install
-script will fall back to the legacy Ruby version on the other systems, but if
-you have Go 1.4 installed, you can try building it yourself.
-
-However, as pointed out in [golang.org/doc/install][req], the Go version may
-not run on CentOS/RHEL 5.x, and if that's the case, the install script will
-choose the Ruby version instead.
-
-The Go version depends on [ncurses][ncurses] and some Unix system calls, so it
-shouldn't run natively on Windows at the moment. But it won't be impossible to
-support Windows by falling back to a cross-platform alternative such as
-[termbox][termbox] only on Windows. If you're interested in making fzf work on
-Windows, please let me know.
-
-Build
------
-
-```sh
-# Build fzf executables and tarballs
-make release
-
-# Install the executable to ../bin directory
-make install
-
-# Build executables and tarballs for Linux using Docker
-make linux
-```
-
-Contribution
-------------
-
-For the time being, I will not add or accept any new features until we can be
-sure that the implementation is stable and we have a sufficient number of test
-cases. However, fixes for obvious bugs and new test cases are welcome.
-
-I also care much about the performance of the implementation, so please make
-sure that your change does not result in performance regression. And please be
-noted that we don't have a quantitative measure of the performance yet.
-
-Third-party libraries used
---------------------------
-
-- [ncurses][ncurses]
-- [mattn/go-runewidth](https://github.com/mattn/go-runewidth)
-    - Licensed under [MIT](http://mattn.mit-license.org/2013)
-- [mattn/go-shellwords](https://github.com/mattn/go-shellwords)
-    - Licensed under [MIT](http://mattn.mit-license.org/2014)
-
-License
--------
-
-[MIT](LICENSE)
-
-[install]: https://github.com/junegunn/fzf#installation
-[go]:      https://golang.org/
-[gil]:     http://en.wikipedia.org/wiki/Global_Interpreter_Lock
-[ncurses]: https://www.gnu.org/software/ncurses/
-[req]:     http://golang.org/doc/install
-[termbox]: https://github.com/nsf/termbox-go

src/algo/algo_test.go

@@ -1,95 +1,197 @@
 package algo
 
 import (
+	"math"
+	"sort"
 	"strings"
 	"testing"
+
+	"github.com/junegunn/fzf/src/util"
 )
 
-func assertMatch(t *testing.T, fun func(bool, bool, []rune, []rune) Result, caseSensitive, forward bool, input, pattern string, sidx int32, eidx int32, bonus int32) {
+func assertMatch(t *testing.T, fun Algo, caseSensitive, forward bool, input, pattern string, sidx int, eidx int, score int) {
+	assertMatch2(t, fun, caseSensitive, false, forward, input, pattern, sidx, eidx, score)
+}
+
+func assertMatch2(t *testing.T, fun Algo, caseSensitive, normalize, forward bool, input, pattern string, sidx int, eidx int, score int) {
 	if !caseSensitive {
 		pattern = strings.ToLower(pattern)
 	}
-	res := fun(caseSensitive, forward, []rune(input), []rune(pattern))
+	chars := util.ToChars([]byte(input))
-	if res.Start != sidx {
+	res, pos := fun(caseSensitive, normalize, forward, &chars, []rune(pattern), true, nil)
-		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", res.Start, sidx, input, pattern)
+	var start, end int
+	if pos == nil || len(*pos) == 0 {
+		start = res.Start
+		end = res.End
+	} else {
+		sort.Ints(*pos)
+		start = (*pos)[0]
+		end = (*pos)[len(*pos)-1] + 1
 	}
-	if res.End != eidx {
+	if start != sidx {
-		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", res.End, eidx, input, pattern)
+		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", start, sidx, input, pattern)
 	}
-	if res.Bonus != bonus {
+	if end != eidx {
-		t.Errorf("Invalid bonus: %d (expected: %d, %s / %s)", res.Bonus, bonus, input, pattern)
+		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", end, eidx, input, pattern)
+	}
+	if res.Score != score {
+		t.Errorf("Invalid score: %d (expected: %d, %s / %s)", res.Score, score, input, pattern)
 	}
 }
 
 func TestFuzzyMatch(t *testing.T) {
-	assertMatch(t, FuzzyMatch, false, true, "fooBarbaz", "oBZ", 2, 9, 2)
+	for _, fn := range []Algo{FuzzyMatchV1, FuzzyMatchV2} {
-	assertMatch(t, FuzzyMatch, false, true, "foo bar baz", "fbb", 0, 9, 8)
+		for _, forward := range []bool{true, false} {
-	assertMatch(t, FuzzyMatch, false, true, "/AutomatorDocument.icns", "rdoc", 9, 13, 4)
+			assertMatch(t, fn, false, forward, "fooBarbaz1", "oBZ", 2, 9,
-	assertMatch(t, FuzzyMatch, false, true, "/man1/zshcompctl.1", "zshc", 6, 10, 7)
+				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtension*3)
-	assertMatch(t, FuzzyMatch, false, true, "/.oh-my-zsh/cache", "zshc", 8, 13, 8)
+			assertMatch(t, fn, false, forward, "foo bar baz", "fbb", 0, 9,
-	assertMatch(t, FuzzyMatch, false, true, "ab0123 456", "12356", 3, 10, 3)
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
-	assertMatch(t, FuzzyMatch, false, true, "abc123 456", "12356", 3, 10, 5)
+					bonusBoundary*2+2*scoreGapStart+4*scoreGapExtension)
+			assertMatch(t, fn, false, forward, "/AutomatorDocument.icns", "rdoc", 9, 13,
+				scoreMatch*4+bonusCamel123+bonusConsecutive*2)
+			assertMatch(t, fn, false, forward, "/man1/zshcompctl.1", "zshc", 6, 10,
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3)
+			assertMatch(t, fn, false, forward, "/.oh-my-zsh/cache", "zshc", 8, 13,
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3+scoreGapStart)
+			assertMatch(t, fn, false, forward, "ab0123 456", "12356", 3, 10,
+				scoreMatch*5+bonusConsecutive*3+scoreGapStart+scoreGapExtension)
+			assertMatch(t, fn, false, forward, "abc123 456", "12356", 3, 10,
+				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+bonusConsecutive+scoreGapStart+scoreGapExtension)
+			assertMatch(t, fn, false, forward, "foo/bar/baz", "fbb", 0, 9,
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
+					bonusBoundary*2+2*scoreGapStart+4*scoreGapExtension)
+			assertMatch(t, fn, false, forward, "fooBarBaz", "fbb", 0, 7,
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
+					bonusCamel123*2+2*scoreGapStart+2*scoreGapExtension)
+			assertMatch(t, fn, false, forward, "foo barbaz", "fbb", 0, 8,
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary+
+					scoreGapStart*2+scoreGapExtension*3)
+			assertMatch(t, fn, false, forward, "fooBar Baz", "foob", 0, 4,
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3)
+			assertMatch(t, fn, false, forward, "xFoo-Bar Baz", "foo-b", 1, 6,
+				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+
+					bonusNonWord+bonusBoundary)
 
-	assertMatch(t, FuzzyMatch, false, true, "foo/bar/baz", "fbb", 0, 9, 8)
+			assertMatch(t, fn, true, forward, "fooBarbaz", "oBz", 2, 9,
-	assertMatch(t, FuzzyMatch, false, true, "fooBarBaz", "fbb", 0, 7, 6)
+				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtension*3)
-	assertMatch(t, FuzzyMatch, false, true, "foo barbaz", "fbb", 0, 8, 6)
+			assertMatch(t, fn, true, forward, "Foo/Bar/Baz", "FBB", 0, 9,
-	assertMatch(t, FuzzyMatch, false, true, "fooBar Baz", "foob", 0, 4, 8)
+				scoreMatch*3+bonusBoundary*(bonusFirstCharMultiplier+2)+
-	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBZ", -1, -1, 0)
+					scoreGapStart*2+scoreGapExtension*4)
-	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBz", 2, 9, 2)
+			assertMatch(t, fn, true, forward, "FooBarBaz", "FBB", 0, 7,
-	assertMatch(t, FuzzyMatch, true, true, "Foo Bar Baz", "fbb", -1, -1, 0)
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+bonusCamel123*2+
-	assertMatch(t, FuzzyMatch, true, true, "Foo/Bar/Baz", "FBB", 0, 9, 8)
+					scoreGapStart*2+scoreGapExtension*2)
-	assertMatch(t, FuzzyMatch, true, true, "FooBarBaz", "FBB", 0, 7, 6)
+			assertMatch(t, fn, true, forward, "FooBar Baz", "FooB", 0, 4,
-	assertMatch(t, FuzzyMatch, true, true, "foo BarBaz", "fBB", 0, 8, 7)
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*2+
-	assertMatch(t, FuzzyMatch, true, true, "FooBar Baz", "FooB", 0, 4, 8)
+					util.Max(bonusCamel123, bonusBoundary))
-	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "fooBarbazz", -1, -1, 0)
+
+			// Consecutive bonus updated
+			assertMatch(t, fn, true, forward, "foo-bar", "o-ba", 2, 6,
+				scoreMatch*4+bonusBoundary*3)
+
+			// Non-match
+			assertMatch(t, fn, true, forward, "fooBarbaz", "oBZ", -1, -1, 0)
+			assertMatch(t, fn, true, forward, "Foo Bar Baz", "fbb", -1, -1, 0)
+			assertMatch(t, fn, true, forward, "fooBarbaz", "fooBarbazz", -1, -1, 0)
+		}
+	}
 }
 
 func TestFuzzyMatchBackward(t *testing.T) {
-	assertMatch(t, FuzzyMatch, false, true, "foobar fb", "fb", 0, 4, 4)
+	assertMatch(t, FuzzyMatchV1, false, true, "foobar fb", "fb", 0, 4,
-	assertMatch(t, FuzzyMatch, false, false, "foobar fb", "fb", 7, 9, 5)
+		scoreMatch*2+bonusBoundary*bonusFirstCharMultiplier+
+			scoreGapStart+scoreGapExtension)
+	assertMatch(t, FuzzyMatchV1, false, false, "foobar fb", "fb", 7, 9,
+		scoreMatch*2+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary)
 }
 
 func TestExactMatchNaive(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, ExactMatchNaive, false, dir, "fooBarbaz", "oBA", 2, 5, 3)
 		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "oBA", -1, -1, 0)
 		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "fooBarbazz", -1, -1, 0)
 
-		assertMatch(t, ExactMatchNaive, false, dir, "/AutomatorDocument.icns", "rdoc", 9, 13, 4)
+		assertMatch(t, ExactMatchNaive, false, dir, "fooBarbaz", "oBA", 2, 5,
-		assertMatch(t, ExactMatchNaive, false, dir, "/man1/zshcompctl.1", "zshc", 6, 10, 7)
+			scoreMatch*3+bonusCamel123+bonusConsecutive)
-		assertMatch(t, ExactMatchNaive, false, dir, "/.oh-my-zsh/cache", "zsh/c", 8, 13, 10)
+		assertMatch(t, ExactMatchNaive, false, dir, "/AutomatorDocument.icns", "rdoc", 9, 13,
+			scoreMatch*4+bonusCamel123+bonusConsecutive*2)
+		assertMatch(t, ExactMatchNaive, false, dir, "/man1/zshcompctl.1", "zshc", 6, 10,
+			scoreMatch*4+bonusBoundary*(bonusFirstCharMultiplier+3))
+		assertMatch(t, ExactMatchNaive, false, dir, "/.oh-my-zsh/cache", "zsh/c", 8, 13,
+			scoreMatch*5+bonusBoundary*(bonusFirstCharMultiplier+4))
 	}
 }
 
 func TestExactMatchNaiveBackward(t *testing.T) {
-	assertMatch(t, ExactMatchNaive, false, true, "foobar foob", "oo", 1, 3, 1)
+	assertMatch(t, ExactMatchNaive, false, true, "foobar foob", "oo", 1, 3,
-	assertMatch(t, ExactMatchNaive, false, false, "foobar foob", "oo", 8, 10, 1)
+		scoreMatch*2+bonusConsecutive)
+	assertMatch(t, ExactMatchNaive, false, false, "foobar foob", "oo", 8, 10,
+		scoreMatch*2+bonusConsecutive)
 }
 
 func TestPrefixMatch(t *testing.T) {
+	score := (scoreMatch+bonusBoundary)*3 + bonusBoundary*(bonusFirstCharMultiplier-1)
+
 	for _, dir := range []bool{true, false} {
 		assertMatch(t, PrefixMatch, true, dir, "fooBarbaz", "Foo", -1, -1, 0)
 		assertMatch(t, PrefixMatch, false, dir, "fooBarBaz", "baz", -1, -1, 0)
-		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "Foo", 0, 3, 6)
+		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "Foo", 0, 3, score)
-		assertMatch(t, PrefixMatch, false, dir, "foOBarBaZ", "foo", 0, 3, 7)
+		assertMatch(t, PrefixMatch, false, dir, "foOBarBaZ", "foo", 0, 3, score)
-		assertMatch(t, PrefixMatch, false, dir, "f-oBarbaz", "f-o", 0, 3, 8)
+		assertMatch(t, PrefixMatch, false, dir, "f-oBarbaz", "f-o", 0, 3, score)
+
+		assertMatch(t, PrefixMatch, false, dir, " fooBar", "foo", 1, 4, score)
+		assertMatch(t, PrefixMatch, false, dir, " fooBar", " fo", 0, 3, score)
+		assertMatch(t, PrefixMatch, false, dir, "     fo", "foo", -1, -1, 0)
 	}
 }
 
 func TestSuffixMatch(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "Foo", -1, -1, 0)
-		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "baz", 6, 9, 2)
-		assertMatch(t, SuffixMatch, false, dir, "fooBarBaZ", "baz", 6, 9, 5)
 		assertMatch(t, SuffixMatch, true, dir, "fooBarbaz", "Baz", -1, -1, 0)
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "Foo", -1, -1, 0)
+
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "baz", 6, 9,
+			scoreMatch*3+bonusConsecutive*2)
+		assertMatch(t, SuffixMatch, false, dir, "fooBarBaZ", "baz", 6, 9,
+			(scoreMatch+bonusCamel123)*3+bonusCamel123*(bonusFirstCharMultiplier-1))
+
+		// Strip trailing white space from the string
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz", 6, 9,
+			scoreMatch*3+bonusConsecutive*2)
+		// Only when the pattern doesn't end with a space
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz ", 6, 10,
+			scoreMatch*4+bonusConsecutive*2+bonusNonWord)
 	}
 }
 
 func TestEmptyPattern(t *testing.T) {
 	for _, dir := range []bool{true, false} {
-		assertMatch(t, FuzzyMatch, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, FuzzyMatchV1, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, FuzzyMatchV2, true, dir, "foobar", "", 0, 0, 0)
 		assertMatch(t, ExactMatchNaive, true, dir, "foobar", "", 0, 0, 0)
 		assertMatch(t, PrefixMatch, true, dir, "foobar", "", 0, 0, 0)
 		assertMatch(t, SuffixMatch, true, dir, "foobar", "", 6, 6, 0)
 	}
 }
+
+func TestNormalize(t *testing.T) {
+	caseSensitive := false
+	normalize := true
+	forward := true
+	test := func(input, pattern string, sidx, eidx, score int, funs ...Algo) {
+		for _, fun := range funs {
+			assertMatch2(t, fun, caseSensitive, normalize, forward,
+				input, pattern, sidx, eidx, score)
+		}
+	}
+	test("Só Danço Samba", "So", 0, 2, 56, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, ExactMatchNaive)
+	test("Só Danço Samba", "sodc", 0, 7, 89, FuzzyMatchV1, FuzzyMatchV2)
+	test("Danço", "danco", 0, 5, 128, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, SuffixMatch, ExactMatchNaive, EqualMatch)
+}
+
+func TestLongString(t *testing.T) {
+	bytes := make([]byte, math.MaxUint16*2)
+	for i := range bytes {
+		bytes[i] = 'x'
+	}
+	bytes[math.MaxUint16] = 'z'
+	assertMatch(t, FuzzyMatchV2, true, true, string(bytes), "zx", math.MaxUint16, math.MaxUint16+2, scoreMatch*2+bonusConsecutive)
+}

src/algo/normalize.go

@@ -0,0 +1,492 @@
+// Normalization of latin script letters
+// Reference: http://www.unicode.org/Public/UCD/latest/ucd/Index.txt
+
+package algo
+
+var normalized map[rune]rune = map[rune]rune{
+	0x00E1: 'a', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0103: 'a', //  WITH BREVE, LATIN SMALL LETTER
+	0x01CE: 'a', //  WITH CARON, LATIN SMALL LETTER
+	0x00E2: 'a', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00E4: 'a', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x0227: 'a', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1EA1: 'a', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0201: 'a', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00E0: 'a', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EA3: 'a', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x0203: 'a', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x0101: 'a', //  WITH MACRON, LATIN SMALL LETTER
+	0x0105: 'a', //  WITH OGONEK, LATIN SMALL LETTER
+	0x1E9A: 'a', //  WITH RIGHT HALF RING, LATIN SMALL LETTER
+	0x00E5: 'a', //  WITH RING ABOVE, LATIN SMALL LETTER
+	0x1E01: 'a', //  WITH RING BELOW, LATIN SMALL LETTER
+	0x00E3: 'a', //  WITH TILDE, LATIN SMALL LETTER
+	0x0363: 'a', // , COMBINING LATIN SMALL LETTER
+	0x0250: 'a', // , LATIN SMALL LETTER TURNED
+	0x1E03: 'b', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E05: 'b', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0253: 'b', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E07: 'b', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0180: 'b', //  WITH STROKE, LATIN SMALL LETTER
+	0x0183: 'b', //  WITH TOPBAR, LATIN SMALL LETTER
+	0x0107: 'c', //  WITH ACUTE, LATIN SMALL LETTER
+	0x010D: 'c', //  WITH CARON, LATIN SMALL LETTER
+	0x00E7: 'c', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x0109: 'c', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x0255: 'c', //  WITH CURL, LATIN SMALL LETTER
+	0x010B: 'c', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x0188: 'c', //  WITH HOOK, LATIN SMALL LETTER
+	0x023C: 'c', //  WITH STROKE, LATIN SMALL LETTER
+	0x0368: 'c', // , COMBINING LATIN SMALL LETTER
+	0x0297: 'c', // , LATIN LETTER STRETCHED
+	0x2184: 'c', // , LATIN SMALL LETTER REVERSED
+	0x010F: 'd', //  WITH CARON, LATIN SMALL LETTER
+	0x1E11: 'd', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E13: 'd', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x0221: 'd', //  WITH CURL, LATIN SMALL LETTER
+	0x1E0B: 'd', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E0D: 'd', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0257: 'd', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E0F: 'd', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0111: 'd', //  WITH STROKE, LATIN SMALL LETTER
+	0x0256: 'd', //  WITH TAIL, LATIN SMALL LETTER
+	0x018C: 'd', //  WITH TOPBAR, LATIN SMALL LETTER
+	0x0369: 'd', // , COMBINING LATIN SMALL LETTER
+	0x00E9: 'e', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0115: 'e', //  WITH BREVE, LATIN SMALL LETTER
+	0x011B: 'e', //  WITH CARON, LATIN SMALL LETTER
+	0x0229: 'e', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E19: 'e', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x00EA: 'e', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00EB: 'e', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x0117: 'e', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1EB9: 'e', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0205: 'e', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00E8: 'e', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EBB: 'e', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x025D: 'e', //  WITH HOOK, LATIN SMALL LETTER REVERSED OPEN
+	0x0207: 'e', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x0113: 'e', //  WITH MACRON, LATIN SMALL LETTER
+	0x0119: 'e', //  WITH OGONEK, LATIN SMALL LETTER
+	0x0247: 'e', //  WITH STROKE, LATIN SMALL LETTER
+	0x1E1B: 'e', //  WITH TILDE BELOW, LATIN SMALL LETTER
+	0x1EBD: 'e', //  WITH TILDE, LATIN SMALL LETTER
+	0x0364: 'e', // , COMBINING LATIN SMALL LETTER
+	0x029A: 'e', // , LATIN SMALL LETTER CLOSED OPEN
+	0x025E: 'e', // , LATIN SMALL LETTER CLOSED REVERSED OPEN
+	0x025B: 'e', // , LATIN SMALL LETTER OPEN
+	0x0258: 'e', // , LATIN SMALL LETTER REVERSED
+	0x025C: 'e', // , LATIN SMALL LETTER REVERSED OPEN
+	0x01DD: 'e', // , LATIN SMALL LETTER TURNED
+	0x1D08: 'e', // , LATIN SMALL LETTER TURNED OPEN
+	0x1E1F: 'f', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x0192: 'f', //  WITH HOOK, LATIN SMALL LETTER
+	0x01F5: 'g', //  WITH ACUTE, LATIN SMALL LETTER
+	0x011F: 'g', //  WITH BREVE, LATIN SMALL LETTER
+	0x01E7: 'g', //  WITH CARON, LATIN SMALL LETTER
+	0x0123: 'g', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x011D: 'g', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x0121: 'g', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x0260: 'g', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E21: 'g', //  WITH MACRON, LATIN SMALL LETTER
+	0x01E5: 'g', //  WITH STROKE, LATIN SMALL LETTER
+	0x0261: 'g', // , LATIN SMALL LETTER SCRIPT
+	0x1E2B: 'h', //  WITH BREVE BELOW, LATIN SMALL LETTER
+	0x021F: 'h', //  WITH CARON, LATIN SMALL LETTER
+	0x1E29: 'h', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x0125: 'h', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x1E27: 'h', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E23: 'h', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E25: 'h', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x02AE: 'h', //  WITH FISHHOOK, LATIN SMALL LETTER TURNED
+	0x0266: 'h', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E96: 'h', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0127: 'h', //  WITH STROKE, LATIN SMALL LETTER
+	0x036A: 'h', // , COMBINING LATIN SMALL LETTER
+	0x0265: 'h', // , LATIN SMALL LETTER TURNED
+	0x2095: 'h', // , LATIN SUBSCRIPT SMALL LETTER
+	0x00ED: 'i', //  WITH ACUTE, LATIN SMALL LETTER
+	0x012D: 'i', //  WITH BREVE, LATIN SMALL LETTER
+	0x01D0: 'i', //  WITH CARON, LATIN SMALL LETTER
+	0x00EE: 'i', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00EF: 'i', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1ECB: 'i', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0209: 'i', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00EC: 'i', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EC9: 'i', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x020B: 'i', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x012B: 'i', //  WITH MACRON, LATIN SMALL LETTER
+	0x012F: 'i', //  WITH OGONEK, LATIN SMALL LETTER
+	0x0268: 'i', //  WITH STROKE, LATIN SMALL LETTER
+	0x1E2D: 'i', //  WITH TILDE BELOW, LATIN SMALL LETTER
+	0x0129: 'i', //  WITH TILDE, LATIN SMALL LETTER
+	0x0365: 'i', // , COMBINING LATIN SMALL LETTER
+	0x0131: 'i', // , LATIN SMALL LETTER DOTLESS
+	0x1D09: 'i', // , LATIN SMALL LETTER TURNED
+	0x1D62: 'i', // , LATIN SUBSCRIPT SMALL LETTER
+	0x2071: 'i', // , SUPERSCRIPT LATIN SMALL LETTER
+	0x01F0: 'j', //  WITH CARON, LATIN SMALL LETTER
+	0x0135: 'j', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x029D: 'j', //  WITH CROSSED-TAIL, LATIN SMALL LETTER
+	0x0249: 'j', //  WITH STROKE, LATIN SMALL LETTER
+	0x025F: 'j', //  WITH STROKE, LATIN SMALL LETTER DOTLESS
+	0x0237: 'j', // , LATIN SMALL LETTER DOTLESS
+	0x1E31: 'k', //  WITH ACUTE, LATIN SMALL LETTER
+	0x01E9: 'k', //  WITH CARON, LATIN SMALL LETTER
+	0x0137: 'k', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E33: 'k', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0199: 'k', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E35: 'k', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x029E: 'k', // , LATIN SMALL LETTER TURNED
+	0x2096: 'k', // , LATIN SUBSCRIPT SMALL LETTER
+	0x013A: 'l', //  WITH ACUTE, LATIN SMALL LETTER
+	0x019A: 'l', //  WITH BAR, LATIN SMALL LETTER
+	0x026C: 'l', //  WITH BELT, LATIN SMALL LETTER
+	0x013E: 'l', //  WITH CARON, LATIN SMALL LETTER
+	0x013C: 'l', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E3D: 'l', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x0234: 'l', //  WITH CURL, LATIN SMALL LETTER
+	0x1E37: 'l', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x1E3B: 'l', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0140: 'l', //  WITH MIDDLE DOT, LATIN SMALL LETTER
+	0x026B: 'l', //  WITH MIDDLE TILDE, LATIN SMALL LETTER
+	0x026D: 'l', //  WITH RETROFLEX HOOK, LATIN SMALL LETTER
+	0x0142: 'l', //  WITH STROKE, LATIN SMALL LETTER
+	0x2097: 'l', // , LATIN SUBSCRIPT SMALL LETTER
+	0x1E3F: 'm', //  WITH ACUTE, LATIN SMALL LETTER
+	0x1E41: 'm', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E43: 'm', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0271: 'm', //  WITH HOOK, LATIN SMALL LETTER
+	0x0270: 'm', //  WITH LONG LEG, LATIN SMALL LETTER TURNED
+	0x036B: 'm', // , COMBINING LATIN SMALL LETTER
+	0x1D1F: 'm', // , LATIN SMALL LETTER SIDEWAYS TURNED
+	0x026F: 'm', // , LATIN SMALL LETTER TURNED
+	0x2098: 'm', // , LATIN SUBSCRIPT SMALL LETTER
+	0x0144: 'n', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0148: 'n', //  WITH CARON, LATIN SMALL LETTER
+	0x0146: 'n', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E4B: 'n', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x0235: 'n', //  WITH CURL, LATIN SMALL LETTER
+	0x1E45: 'n', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E47: 'n', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x01F9: 'n', //  WITH GRAVE, LATIN SMALL LETTER
+	0x0272: 'n', //  WITH LEFT HOOK, LATIN SMALL LETTER
+	0x1E49: 'n', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x019E: 'n', //  WITH LONG RIGHT LEG, LATIN SMALL LETTER
+	0x0273: 'n', //  WITH RETROFLEX HOOK, LATIN SMALL LETTER
+	0x00F1: 'n', //  WITH TILDE, LATIN SMALL LETTER
+	0x2099: 'n', // , LATIN SUBSCRIPT SMALL LETTER
+	0x00F3: 'o', //  WITH ACUTE, LATIN SMALL LETTER
+	0x014F: 'o', //  WITH BREVE, LATIN SMALL LETTER
+	0x01D2: 'o', //  WITH CARON, LATIN SMALL LETTER
+	0x00F4: 'o', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00F6: 'o', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x022F: 'o', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1ECD: 'o', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0151: 'o', //  WITH DOUBLE ACUTE, LATIN SMALL LETTER
+	0x020D: 'o', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00F2: 'o', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1ECF: 'o', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x01A1: 'o', //  WITH HORN, LATIN SMALL LETTER
+	0x020F: 'o', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x014D: 'o', //  WITH MACRON, LATIN SMALL LETTER
+	0x01EB: 'o', //  WITH OGONEK, LATIN SMALL LETTER
+	0x00F8: 'o', //  WITH STROKE, LATIN SMALL LETTER
+	0x1D13: 'o', //  WITH STROKE, LATIN SMALL LETTER SIDEWAYS
+	0x00F5: 'o', //  WITH TILDE, LATIN SMALL LETTER
+	0x0366: 'o', // , COMBINING LATIN SMALL LETTER
+	0x0275: 'o', // , LATIN SMALL LETTER BARRED
+	0x1D17: 'o', // , LATIN SMALL LETTER BOTTOM HALF
+	0x0254: 'o', // , LATIN SMALL LETTER OPEN
+	0x1D11: 'o', // , LATIN SMALL LETTER SIDEWAYS
+	0x1D12: 'o', // , LATIN SMALL LETTER SIDEWAYS OPEN
+	0x1D16: 'o', // , LATIN SMALL LETTER TOP HALF
+	0x1E55: 'p', //  WITH ACUTE, LATIN SMALL LETTER
+	0x1E57: 'p', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x01A5: 'p', //  WITH HOOK, LATIN SMALL LETTER
+	0x209A: 'p', // , LATIN SUBSCRIPT SMALL LETTER
+	0x024B: 'q', //  WITH HOOK TAIL, LATIN SMALL LETTER
+	0x02A0: 'q', //  WITH HOOK, LATIN SMALL LETTER
+	0x0155: 'r', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0159: 'r', //  WITH CARON, LATIN SMALL LETTER
+	0x0157: 'r', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E59: 'r', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E5B: 'r', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0211: 'r', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x027E: 'r', //  WITH FISHHOOK, LATIN SMALL LETTER
+	0x027F: 'r', //  WITH FISHHOOK, LATIN SMALL LETTER REVERSED
+	0x027B: 'r', //  WITH HOOK, LATIN SMALL LETTER TURNED
+	0x0213: 'r', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x1E5F: 'r', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x027C: 'r', //  WITH LONG LEG, LATIN SMALL LETTER
+	0x027A: 'r', //  WITH LONG LEG, LATIN SMALL LETTER TURNED
+	0x024D: 'r', //  WITH STROKE, LATIN SMALL LETTER
+	0x027D: 'r', //  WITH TAIL, LATIN SMALL LETTER
+	0x036C: 'r', // , COMBINING LATIN SMALL LETTER
+	0x0279: 'r', // , LATIN SMALL LETTER TURNED
+	0x1D63: 'r', // , LATIN SUBSCRIPT SMALL LETTER
+	0x015B: 's', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0161: 's', //  WITH CARON, LATIN SMALL LETTER
+	0x015F: 's', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x015D: 's', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x0219: 's', //  WITH COMMA BELOW, LATIN SMALL LETTER
+	0x1E61: 's', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E9B: 's', //  WITH DOT ABOVE, LATIN SMALL LETTER LONG
+	0x1E63: 's', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0282: 's', //  WITH HOOK, LATIN SMALL LETTER
+	0x023F: 's', //  WITH SWASH TAIL, LATIN SMALL LETTER
+	0x017F: 's', // , LATIN SMALL LETTER LONG
+	0x00DF: 's', // , LATIN SMALL LETTER SHARP
+	0x209B: 's', // , LATIN SUBSCRIPT SMALL LETTER
+	0x0165: 't', //  WITH CARON, LATIN SMALL LETTER
+	0x0163: 't', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E71: 't', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x021B: 't', //  WITH COMMA BELOW, LATIN SMALL LETTER
+	0x0236: 't', //  WITH CURL, LATIN SMALL LETTER
+	0x1E97: 't', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E6B: 't', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E6D: 't', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x01AD: 't', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E6F: 't', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x01AB: 't', //  WITH PALATAL HOOK, LATIN SMALL LETTER
+	0x0288: 't', //  WITH RETROFLEX HOOK, LATIN SMALL LETTER
+	0x0167: 't', //  WITH STROKE, LATIN SMALL LETTER
+	0x036D: 't', // , COMBINING LATIN SMALL LETTER
+	0x0287: 't', // , LATIN SMALL LETTER TURNED
+	0x209C: 't', // , LATIN SUBSCRIPT SMALL LETTER
+	0x0289: 'u', //  BAR, LATIN SMALL LETTER
+	0x00FA: 'u', //  WITH ACUTE, LATIN SMALL LETTER
+	0x016D: 'u', //  WITH BREVE, LATIN SMALL LETTER
+	0x01D4: 'u', //  WITH CARON, LATIN SMALL LETTER
+	0x1E77: 'u', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x00FB: 'u', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x1E73: 'u', //  WITH DIAERESIS BELOW, LATIN SMALL LETTER
+	0x00FC: 'u', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1EE5: 'u', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0171: 'u', //  WITH DOUBLE ACUTE, LATIN SMALL LETTER
+	0x0215: 'u', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00F9: 'u', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EE7: 'u', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x01B0: 'u', //  WITH HORN, LATIN SMALL LETTER
+	0x0217: 'u', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x016B: 'u', //  WITH MACRON, LATIN SMALL LETTER
+	0x0173: 'u', //  WITH OGONEK, LATIN SMALL LETTER
+	0x016F: 'u', //  WITH RING ABOVE, LATIN SMALL LETTER
+	0x1E75: 'u', //  WITH TILDE BELOW, LATIN SMALL LETTER
+	0x0169: 'u', //  WITH TILDE, LATIN SMALL LETTER
+	0x0367: 'u', // , COMBINING LATIN SMALL LETTER
+	0x1D1D: 'u', // , LATIN SMALL LETTER SIDEWAYS
+	0x1D1E: 'u', // , LATIN SMALL LETTER SIDEWAYS DIAERESIZED
+	0x1D64: 'u', // , LATIN SUBSCRIPT SMALL LETTER
+	0x1E7F: 'v', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x028B: 'v', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E7D: 'v', //  WITH TILDE, LATIN SMALL LETTER
+	0x036E: 'v', // , COMBINING LATIN SMALL LETTER
+	0x028C: 'v', // , LATIN SMALL LETTER TURNED
+	0x1D65: 'v', // , LATIN SUBSCRIPT SMALL LETTER
+	0x1E83: 'w', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0175: 'w', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x1E85: 'w', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E87: 'w', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E89: 'w', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x1E81: 'w', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1E98: 'w', //  WITH RING ABOVE, LATIN SMALL LETTER
+	0x028D: 'w', // , LATIN SMALL LETTER TURNED
+	0x1E8D: 'x', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E8B: 'x', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x036F: 'x', // , COMBINING LATIN SMALL LETTER
+	0x00FD: 'y', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0177: 'y', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00FF: 'y', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E8F: 'y', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1EF5: 'y', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x1EF3: 'y', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EF7: 'y', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x01B4: 'y', //  WITH HOOK, LATIN SMALL LETTER
+	0x0233: 'y', //  WITH MACRON, LATIN SMALL LETTER
+	0x1E99: 'y', //  WITH RING ABOVE, LATIN SMALL LETTER
+	0x024F: 'y', //  WITH STROKE, LATIN SMALL LETTER
+	0x1EF9: 'y', //  WITH TILDE, LATIN SMALL LETTER
+	0x028E: 'y', // , LATIN SMALL LETTER TURNED
+	0x017A: 'z', //  WITH ACUTE, LATIN SMALL LETTER
+	0x017E: 'z', //  WITH CARON, LATIN SMALL LETTER
+	0x1E91: 'z', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x0291: 'z', //  WITH CURL, LATIN SMALL LETTER
+	0x017C: 'z', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E93: 'z', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0225: 'z', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E95: 'z', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0290: 'z', //  WITH RETROFLEX HOOK, LATIN SMALL LETTER
+	0x01B6: 'z', //  WITH STROKE, LATIN SMALL LETTER
+	0x0240: 'z', //  WITH SWASH TAIL, LATIN SMALL LETTER
+	0x0251: 'a', // , latin small letter script
+	0x00C1: 'A', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00C2: 'A', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00C4: 'A', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x00C0: 'A', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x00C5: 'A', //  WITH RING ABOVE, LATIN CAPITAL LETTER
+	0x023A: 'A', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x00C3: 'A', //  WITH TILDE, LATIN CAPITAL LETTER
+	0x1D00: 'A', // , LATIN LETTER SMALL CAPITAL
+	0x0181: 'B', //  WITH HOOK, LATIN CAPITAL LETTER
+	0x0243: 'B', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x0299: 'B', // , LATIN LETTER SMALL CAPITAL
+	0x1D03: 'B', // , LATIN LETTER SMALL CAPITAL BARRED
+	0x00C7: 'C', //  WITH CEDILLA, LATIN CAPITAL LETTER
+	0x023B: 'C', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x1D04: 'C', // , LATIN LETTER SMALL CAPITAL
+	0x018A: 'D', //  WITH HOOK, LATIN CAPITAL LETTER
+	0x0189: 'D', // , LATIN CAPITAL LETTER AFRICAN
+	0x1D05: 'D', // , LATIN LETTER SMALL CAPITAL
+	0x00C9: 'E', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00CA: 'E', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00CB: 'E', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x00C8: 'E', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x0246: 'E', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x0190: 'E', // , LATIN CAPITAL LETTER OPEN
+	0x018E: 'E', // , LATIN CAPITAL LETTER REVERSED
+	0x1D07: 'E', // , LATIN LETTER SMALL CAPITAL
+	0x0193: 'G', //  WITH HOOK, LATIN CAPITAL LETTER
+	0x029B: 'G', //  WITH HOOK, LATIN LETTER SMALL CAPITAL
+	0x0262: 'G', // , LATIN LETTER SMALL CAPITAL
+	0x029C: 'H', // , LATIN LETTER SMALL CAPITAL
+	0x00CD: 'I', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00CE: 'I', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00CF: 'I', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x0130: 'I', //  WITH DOT ABOVE, LATIN CAPITAL LETTER
+	0x00CC: 'I', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x0197: 'I', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x026A: 'I', // , LATIN LETTER SMALL CAPITAL
+	0x0248: 'J', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x1D0A: 'J', // , LATIN LETTER SMALL CAPITAL
+	0x1D0B: 'K', // , LATIN LETTER SMALL CAPITAL
+	0x023D: 'L', //  WITH BAR, LATIN CAPITAL LETTER
+	0x1D0C: 'L', //  WITH STROKE, LATIN LETTER SMALL CAPITAL
+	0x029F: 'L', // , LATIN LETTER SMALL CAPITAL
+	0x019C: 'M', // , LATIN CAPITAL LETTER TURNED
+	0x1D0D: 'M', // , LATIN LETTER SMALL CAPITAL
+	0x019D: 'N', //  WITH LEFT HOOK, LATIN CAPITAL LETTER
+	0x0220: 'N', //  WITH LONG RIGHT LEG, LATIN CAPITAL LETTER
+	0x00D1: 'N', //  WITH TILDE, LATIN CAPITAL LETTER
+	0x0274: 'N', // , LATIN LETTER SMALL CAPITAL
+	0x1D0E: 'N', // , LATIN LETTER SMALL CAPITAL REVERSED
+	0x00D3: 'O', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00D4: 'O', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00D6: 'O', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x00D2: 'O', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x019F: 'O', //  WITH MIDDLE TILDE, LATIN CAPITAL LETTER
+	0x00D8: 'O', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x00D5: 'O', //  WITH TILDE, LATIN CAPITAL LETTER
+	0x0186: 'O', // , LATIN CAPITAL LETTER OPEN
+	0x1D0F: 'O', // , LATIN LETTER SMALL CAPITAL
+	0x1D10: 'O', // , LATIN LETTER SMALL CAPITAL OPEN
+	0x1D18: 'P', // , LATIN LETTER SMALL CAPITAL
+	0x024A: 'Q', //  WITH HOOK TAIL, LATIN CAPITAL LETTER SMALL
+	0x024C: 'R', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x0280: 'R', // , LATIN LETTER SMALL CAPITAL
+	0x0281: 'R', // , LATIN LETTER SMALL CAPITAL INVERTED
+	0x1D19: 'R', // , LATIN LETTER SMALL CAPITAL REVERSED
+	0x1D1A: 'R', // , LATIN LETTER SMALL CAPITAL TURNED
+	0x023E: 'T', //  WITH DIAGONAL STROKE, LATIN CAPITAL LETTER
+	0x01AE: 'T', //  WITH RETROFLEX HOOK, LATIN CAPITAL LETTER
+	0x1D1B: 'T', // , LATIN LETTER SMALL CAPITAL
+	0x0244: 'U', //  BAR, LATIN CAPITAL LETTER
+	0x00DA: 'U', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00DB: 'U', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00DC: 'U', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x00D9: 'U', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x1D1C: 'U', // , LATIN LETTER SMALL CAPITAL
+	0x01B2: 'V', //  WITH HOOK, LATIN CAPITAL LETTER
+	0x0245: 'V', // , LATIN CAPITAL LETTER TURNED
+	0x1D20: 'V', // , LATIN LETTER SMALL CAPITAL
+	0x1D21: 'W', // , LATIN LETTER SMALL CAPITAL
+	0x00DD: 'Y', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x0178: 'Y', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x024E: 'Y', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x028F: 'Y', // , LATIN LETTER SMALL CAPITAL
+	0x1D22: 'Z', // , LATIN LETTER SMALL CAPITAL
+
+	'Ắ': 'A',
+	'Ấ': 'A',
+	'Ằ': 'A',
+	'Ầ': 'A',
+	'Ẳ': 'A',
+	'Ẩ': 'A',
+	'Ẵ': 'A',
+	'Ẫ': 'A',
+	'Ặ': 'A',
+	'Ậ': 'A',
+
+	'ắ': 'a',
+	'ấ': 'a',
+	'ằ': 'a',
+	'ầ': 'a',
+	'ẳ': 'a',
+	'ẩ': 'a',
+	'ẵ': 'a',
+	'ẫ': 'a',
+	'ặ': 'a',
+	'ậ': 'a',
+
+	'Ế': 'E',
+	'Ề': 'E',
+	'Ể': 'E',
+	'Ễ': 'E',
+	'Ệ': 'E',
+
+	'ế': 'e',
+	'ề': 'e',
+	'ể': 'e',
+	'ễ': 'e',
+	'ệ': 'e',
+
+	'Ố': 'O',
+	'Ớ': 'O',
+	'Ồ': 'O',
+	'Ờ': 'O',
+	'Ổ': 'O',
+	'Ở': 'O',
+	'Ỗ': 'O',
+	'Ỡ': 'O',
+	'Ộ': 'O',
+	'Ợ': 'O',
+
+	'ố': 'o',
+	'ớ': 'o',
+	'ồ': 'o',
+	'ờ': 'o',
+	'ổ': 'o',
+	'ở': 'o',
+	'ỗ': 'o',
+	'ỡ': 'o',
+	'ộ': 'o',
+	'ợ': 'o',
+
+	'Ứ': 'U',
+	'Ừ': 'U',
+	'Ử': 'U',
+	'Ữ': 'U',
+	'Ự': 'U',
+
+	'ứ': 'u',
+	'ừ': 'u',
+	'ử': 'u',
+	'ữ': 'u',
+	'ự': 'u',
+}
+
+// NormalizeRunes normalizes latin script letters
+func NormalizeRunes(runes []rune) []rune {
+	ret := make([]rune, len(runes))
+	copy(ret, runes)
+	for idx, r := range runes {
+		if r < 0x00C0 || r > 0x2184 {
+			continue
+		}
+		n := normalized[r]
+		if n > 0 {
+			ret[idx] = normalized[r]
+		}
+	}
+	return ret
+}

src/ansi.go

@@ -1,11 +1,11 @@
 package fzf
 
 import (
-	"bytes"
-	"regexp"
 	"strconv"
 	"strings"
 	"unicode/utf8"
+
+	"github.com/junegunn/fzf/src/tui"
 )
 
 type ansiOffset struct {
@@ -14,107 +14,324 @@ type ansiOffset struct {
 }
 
 type ansiState struct {
-	fg   int
+	fg   tui.Color
-	bg   int
+	bg   tui.Color
-	bold bool
+	attr tui.Attr
+	lbg  tui.Color
 }
 
 func (s *ansiState) colored() bool {
-	return s.fg != -1 || s.bg != -1 || s.bold
+	return s.fg != -1 || s.bg != -1 || s.attr > 0 || s.lbg >= 0
 }
 
 func (s *ansiState) equals(t *ansiState) bool {
 	if t == nil {
 		return !s.colored()
 	}
-	return s.fg == t.fg && s.bg == t.bg && s.bold == t.bold
+	return s.fg == t.fg && s.bg == t.bg && s.attr == t.attr && s.lbg == t.lbg
 }
 
-var ansiRegex *regexp.Regexp
+func (s *ansiState) ToString() string {
+	if !s.colored() {
+		return ""
+	}
 
-func init() {
+	ret := ""
-	ansiRegex = regexp.MustCompile("\x1b\\[[0-9;]*[mK]")
+	if s.attr&tui.Bold > 0 {
+		ret += "1;"
+	}
+	if s.attr&tui.Dim > 0 {
+		ret += "2;"
+	}
+	if s.attr&tui.Italic > 0 {
+		ret += "3;"
+	}
+	if s.attr&tui.Underline > 0 {
+		ret += "4;"
+	}
+	if s.attr&tui.Blink > 0 {
+		ret += "5;"
+	}
+	if s.attr&tui.Reverse > 0 {
+		ret += "7;"
+	}
+	ret += toAnsiString(s.fg, 30) + toAnsiString(s.bg, 40)
+
+	return "\x1b[" + strings.TrimSuffix(ret, ";") + "m"
 }
 
-func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, []ansiOffset, *ansiState) {
+func toAnsiString(color tui.Color, offset int) string {
-	var offsets []ansiOffset
+	col := int(color)
-	var output bytes.Buffer
+	ret := ""
+	if col == -1 {
+		ret += strconv.Itoa(offset + 9)
+	} else if col < 8 {
+		ret += strconv.Itoa(offset + col)
+	} else if col < 16 {
+		ret += strconv.Itoa(offset - 30 + 90 + col - 8)
+	} else if col < 256 {
+		ret += strconv.Itoa(offset+8) + ";5;" + strconv.Itoa(col)
+	} else if col >= (1 << 24) {
+		r := strconv.Itoa((col >> 16) & 0xff)
+		g := strconv.Itoa((col >> 8) & 0xff)
+		b := strconv.Itoa(col & 0xff)
+		ret += strconv.Itoa(offset+8) + ";2;" + r + ";" + g + ";" + b
+	}
+	return ret + ";"
+}
+
+func isPrint(c uint8) bool {
+	return '\x20' <= c && c <= '\x7e'
+}
+
+func matchOperatingSystemCommand(s string) int {
+	// `\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)`
+	//                        ^ match starting here
+	//
+	i := 5 // prefix matched in nextAnsiEscapeSequence()
+	for ; i < len(s) && isPrint(s[i]); i++ {
+	}
+	if i < len(s) {
+		if s[i] == '\x07' {
+			return i + 1
+		}
+		if s[i] == '\x1b' && i < len(s)-1 && s[i+1] == '\\' {
+			return i + 2
+		}
+	}
+	return -1
+}
+
+func matchControlSequence(s string) int {
+	// `\x1b[\\[()][0-9;?]*[a-zA-Z@]`
+	//                    ^ match starting here
+	//
+	i := 2 // prefix matched in nextAnsiEscapeSequence()
+	for ; i < len(s) && (isNumeric(s[i]) || s[i] == ';' || s[i] == '?'); i++ {
+	}
+	if i < len(s) {
+		c := s[i]
+		if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '@' {
+			return i + 1
+		}
+	}
+	return -1
+}
+
+func isCtrlSeqStart(c uint8) bool {
+	return c == '\\' || c == '[' || c == '(' || c == ')'
+}
+
+// nextAnsiEscapeSequence returns the ANSI escape sequence and is equivalent to
+// calling FindStringIndex() on the below regex (which was originally used):
+//
+// "(?:\x1b[\\[()][0-9;?]*[a-zA-Z@]|\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)"
+//
+func nextAnsiEscapeSequence(s string) (int, int) {
+	// fast check for ANSI escape sequences
+	i := 0
+	for ; i < len(s); i++ {
+		switch s[i] {
+		case '\x0e', '\x0f', '\x1b', '\x08':
+			// We ignore the fact that '\x08' cannot be the first char
+			// in the string and be an escape sequence for the sake of
+			// speed and simplicity.
+			goto Loop
+		}
+	}
+	return -1, -1
+
+Loop:
+	for ; i < len(s); i++ {
+		switch s[i] {
+		case '\x08':
+			// backtrack to match: `.\x08`
+			if i > 0 && s[i-1] != '\n' {
+				if s[i-1] < utf8.RuneSelf {
+					return i - 1, i + 1
+				}
+				_, n := utf8.DecodeLastRuneInString(s[:i])
+				return i - n, i + 1
+			}
+		case '\x1b':
+			// match: `\x1b[\\[()][0-9;?]*[a-zA-Z@]`
+			if i+2 < len(s) && isCtrlSeqStart(s[i+1]) {
+				if j := matchControlSequence(s[i:]); j != -1 {
+					return i, i + j
+				}
+			}
+
+			// match: `\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)`
+			if i+5 < len(s) && s[i+1] == ']' && isNumeric(s[i+2]) &&
+				s[i+3] == ';' && isPrint(s[i+4]) {
+
+				if j := matchOperatingSystemCommand(s[i:]); j != -1 {
+					return i, i + j
+				}
+			}
+
+			// match: `\x1b.`
+			if i+1 < len(s) && s[i+1] != '\n' {
+				if s[i+1] < utf8.RuneSelf {
+					return i, i + 2
+				}
+				_, n := utf8.DecodeRuneInString(s[i+1:])
+				return i, i + n + 1
+			}
+		case '\x0e', '\x0f':
+			// match: `[\x0e\x0f]`
+			return i, i + 1
+		}
+	}
+	return -1, -1
+}
+
+func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, *[]ansiOffset, *ansiState) {
+	// We append to a stack allocated variable that we'll
+	// later copy and return, to save on allocations.
+	offsets := make([]ansiOffset, 0, 32)
 
 	if state != nil {
 		offsets = append(offsets, ansiOffset{[2]int32{0, 0}, *state})
 	}
 
-	idx := 0
+	var (
-	for _, offset := range ansiRegex.FindAllStringIndex(str, -1) {
+		pstate    *ansiState // lazily allocated
-		prev := str[idx:offset[0]]
+		output    strings.Builder
-		output.WriteString(prev)
+		prevIdx   int
-		if proc != nil && !proc(prev, state) {
+		runeCount int
+	)
+	for idx := 0; idx < len(str); {
+		// Make sure that we found an ANSI code
+		start, end := nextAnsiEscapeSequence(str[idx:])
+		if start == -1 {
 			break
 		}
-		newState := interpretCode(str[offset[0]:offset[1]], state)
+		start += idx
+		idx += end
 
+		// Check if we should continue
+		prev := str[prevIdx:start]
+		if proc != nil && !proc(prev, state) {
+			return "", nil, nil
+		}
+		prevIdx = idx
+
+		if len(prev) != 0 {
+			runeCount += utf8.RuneCountInString(prev)
+			// Grow the buffer size to the maximum possible length (string length
+			// containing ansi codes) to avoid repetitive allocation
+			if output.Cap() == 0 {
+				output.Grow(len(str))
+			}
+			output.WriteString(prev)
+		}
+
+		newState := interpretCode(str[start:idx], 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
+				if pstate == nil {
-				newLen := int32(utf8.RuneCount(output.Bytes()))
+					pstate = &ansiState{}
-				offsets = append(offsets, ansiOffset{[2]int32{newLen, newLen}, *state})
+				}
+				*pstate = newState
+				state = pstate
+				offsets = append(offsets, ansiOffset{
+					[2]int32{int32(runeCount), int32(runeCount)},
+					newState,
+				})
 			} else {
 				// Discard state
 				state = nil
 			}
 		}
-
-		idx = offset[1]
 	}
 
-	rest := str[idx:]
+	var rest string
-	if len(rest) > 0 {
+	var trimmed string
+	if prevIdx == 0 {
+		// No ANSI code found
+		rest = str
+		trimmed = str
+	} else {
+		rest = str[prevIdx:]
 		output.WriteString(rest)
-		if state != nil {
+		trimmed = output.String()
-			// Update last offset
-			(&offsets[len(offsets)-1]).offset[1] = int32(utf8.RuneCount(output.Bytes()))
-		}
 	}
 	if proc != nil {
 		proc(rest, state)
 	}
-	return output.String(), offsets, state
+	if len(offsets) > 0 {
+		if len(rest) > 0 && state != nil {
+			// Update last offset
+			runeCount += utf8.RuneCountInString(rest)
+			(&offsets[len(offsets)-1]).offset[1] = int32(runeCount)
+		}
+		// Return a copy of the offsets slice
+		a := make([]ansiOffset, len(offsets))
+		copy(a, offsets)
+		return trimmed, &a, state
+	}
+	return trimmed, nil, state
 }
 
-func interpretCode(ansiCode string, prevState *ansiState) *ansiState {
+func parseAnsiCode(s string) (int, string) {
-	// State
+	var remaining string
-	var state *ansiState
+	if i := strings.IndexByte(s, ';'); i >= 0 {
-	if prevState == nil {
+		remaining = s[i+1:]
-		state = &ansiState{-1, -1, false}
+		s = s[:i]
-	} else {
-		state = &ansiState{prevState.fg, prevState.bg, prevState.bold}
 	}
-	if ansiCode[len(ansiCode)-1] == 'K' {
+
+	if len(s) > 0 {
+		// Inlined version of strconv.Atoi() that only handles positive
+		// integers and does not allocate on error.
+		code := 0
+		for _, ch := range []byte(s) {
+			ch -= '0'
+			if ch > 9 {
+				return -1, remaining
+			}
+			code = code*10 + int(ch)
+		}
+		return code, remaining
+	}
+
+	return -1, remaining
+}
+
+func interpretCode(ansiCode string, prevState *ansiState) ansiState {
+	var state ansiState
+	if prevState == nil {
+		state = ansiState{-1, -1, 0, -1}
+	} else {
+		state = ansiState{prevState.fg, prevState.bg, prevState.attr, prevState.lbg}
+	}
+	if ansiCode[0] != '\x1b' || ansiCode[1] != '[' || ansiCode[len(ansiCode)-1] != 'm' {
+		if prevState != nil && strings.HasSuffix(ansiCode, "0K") {
+			state.lbg = prevState.bg
+		}
 		return state
 	}
 
-	ptr := &state.fg
+	if len(ansiCode) <= 3 {
-	state256 := 0
-
-	init := func() {
 		state.fg = -1
 		state.bg = -1
-		state.bold = false
+		state.attr = 0
-		state256 = 0
+		return state
 	}
-
 	ansiCode = ansiCode[2 : len(ansiCode)-1]
-	if len(ansiCode) == 0 {
+
-		init()
+	state256 := 0
-	}
+	ptr := &state.fg
-	for _, code := range strings.Split(ansiCode, ";") {
+
-		if num, err := strconv.Atoi(code); err == nil {
+	for len(ansiCode) != 0 {
+		var num int
+		if num, ansiCode = parseAnsiCode(ansiCode); num != -1 {
 			switch state256 {
 			case 0:
 				switch num {
@@ -129,28 +346,64 @@ func interpretCode(ansiCode string, prevState *ansiState) *ansiState {
 				case 49:
 					state.bg = -1
 				case 1:
-					state.bold = true
+					state.attr = state.attr | tui.Bold
+				case 2:
+					state.attr = state.attr | tui.Dim
+				case 3:
+					state.attr = state.attr | tui.Italic
+				case 4:
+					state.attr = state.attr | tui.Underline
+				case 5:
+					state.attr = state.attr | tui.Blink
+				case 7:
+					state.attr = state.attr | tui.Reverse
+				case 23: // tput rmso
+					state.attr = state.attr &^ tui.Italic
+				case 24: // tput rmul
+					state.attr = state.attr &^ tui.Underline
 				case 0:
-					init()
+					state.fg = -1
+					state.bg = -1
+					state.attr = 0
+					state256 = 0
 				default:
 					if num >= 30 && num <= 37 {
-						state.fg = num - 30
+						state.fg = tui.Color(num - 30)
 					} else if num >= 40 && num <= 47 {
-						state.bg = num - 40
+						state.bg = tui.Color(num - 40)
+					} else if num >= 90 && num <= 97 {
+						state.fg = tui.Color(num - 90 + 8)
+					} else if num >= 100 && num <= 107 {
+						state.bg = tui.Color(num - 100 + 8)
 					}
 				}
 			case 1:
 				switch num {
+				case 2:
+					state256 = 10 // MAGIC
 				case 5:
 					state256++
 				default:
 					state256 = 0
 				}
 			case 2:
-				*ptr = num
+				*ptr = tui.Color(num)
+				state256 = 0
+			case 10:
+				*ptr = tui.Color(1<<24) | tui.Color(num<<16)
+				state256++
+			case 11:
+				*ptr = *ptr | tui.Color(num<<8)
+				state256++
+			case 12:
+				*ptr = *ptr | tui.Color(num)
 				state256 = 0
 			}
 		}
 	}
+
+	if state256 > 0 {
+		*ptr = -1
+	}
 	return state
 }

src/ansi_test.go

@@ -1,152 +1,427 @@
 package fzf
 
 import (
-	"fmt"
+	"math/rand"
+	"regexp"
+	"strings"
 	"testing"
+	"unicode/utf8"
+
+	"github.com/junegunn/fzf/src/tui"
 )
 
+// The following regular expression will include not all but most of the
+// frequently used ANSI sequences. This regex is used as a reference for
+// testing nextAnsiEscapeSequence().
+//
+// References:
+// 	- https://github.com/gnachman/iTerm2
+// 	- https://web.archive.org/web/20090204053813/http://ascii-table.com/ansi-escape-sequences.php
+//      (archived from http://ascii-table.com/ansi-escape-sequences.php)
+// 	- https://web.archive.org/web/20090227051140/http://ascii-table.com/ansi-escape-sequences-vt-100.php
+//      (archived from http://ascii-table.com/ansi-escape-sequences-vt-100.php)
+// 	- http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
+// 	- https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+var ansiRegexReference = regexp.MustCompile("(?:\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)")
+
+func testParserReference(t testing.TB, str string) {
+	t.Helper()
+
+	toSlice := func(start, end int) []int {
+		if start == -1 {
+			return nil
+		}
+		return []int{start, end}
+	}
+
+	s := str
+	for i := 0; ; i++ {
+		got := toSlice(nextAnsiEscapeSequence(s))
+		exp := ansiRegexReference.FindStringIndex(s)
+
+		equal := len(got) == len(exp)
+		if equal {
+			for i := 0; i < len(got); i++ {
+				if got[i] != exp[i] {
+					equal = false
+					break
+				}
+			}
+		}
+		if !equal {
+			var exps, gots []rune
+			if len(got) == 2 {
+				gots = []rune(s[got[0]:got[1]])
+			}
+			if len(exp) == 2 {
+				exps = []rune(s[exp[0]:exp[1]])
+			}
+			t.Errorf("%d: %q: got: %v (%q) want: %v (%q)", i, s, got, gots, exp, exps)
+			return
+		}
+		if len(exp) == 0 {
+			return
+		}
+		s = s[exp[1]:]
+	}
+}
+
+func TestNextAnsiEscapeSequence(t *testing.T) {
+	testStrs := []string{
+		"\x1b[0mhello world",
+		"\x1b[1mhello world",
+		"椙\x1b[1m椙",
+		"椙\x1b[1椙m椙",
+		"\x1b[1mhello \x1b[mw\x1b7o\x1b8r\x1b(Bl\x1b[2@d",
+		"\x1b[1mhello \x1b[Kworld",
+		"hello \x1b[34;45;1mworld",
+		"hello \x1b[34;45;1mwor\x1b[34;45;1mld",
+		"hello \x1b[34;45;1mwor\x1b[0mld",
+		"hello \x1b[34;48;5;233;1mwo\x1b[38;5;161mr\x1b[0ml\x1b[38;5;161md",
+		"hello \x1b[38;5;38;48;5;48;1mwor\x1b[38;5;48;48;5;38ml\x1b[0md",
+		"hello \x1b[32;1mworld",
+		"hello world",
+		"hello \x1b[0;38;5;200;48;5;100mworld",
+		"\x1b椙",
+		"椙\x08",
+		"\n\x08",
+		"X\x08",
+		"",
+		"\x1b]4;3;rgb:aa/bb/cc\x07 ",
+		"\x1b]4;3;rgb:aa/bb/cc\x1b\\ ",
+		ansiBenchmarkString,
+	}
+
+	for _, s := range testStrs {
+		testParserReference(t, s)
+	}
+}
+
+func TestNextAnsiEscapeSequence_Fuzz_Modified(t *testing.T) {
+	t.Parallel()
+	if testing.Short() {
+		t.Skip("short test")
+	}
+
+	testStrs := []string{
+		"\x1b[0mhello world",
+		"\x1b[1mhello world",
+		"椙\x1b[1m椙",
+		"椙\x1b[1椙m椙",
+		"\x1b[1mhello \x1b[mw\x1b7o\x1b8r\x1b(Bl\x1b[2@d",
+		"\x1b[1mhello \x1b[Kworld",
+		"hello \x1b[34;45;1mworld",
+		"hello \x1b[34;45;1mwor\x1b[34;45;1mld",
+		"hello \x1b[34;45;1mwor\x1b[0mld",
+		"hello \x1b[34;48;5;233;1mwo\x1b[38;5;161mr\x1b[0ml\x1b[38;5;161md",
+		"hello \x1b[38;5;38;48;5;48;1mwor\x1b[38;5;48;48;5;38ml\x1b[0md",
+		"hello \x1b[32;1mworld",
+		"hello world",
+		"hello \x1b[0;38;5;200;48;5;100mworld",
+		ansiBenchmarkString,
+	}
+
+	replacementBytes := [...]rune{'\x0e', '\x0f', '\x1b', '\x08'}
+
+	modifyString := func(s string, rr *rand.Rand) string {
+		n := rr.Intn(len(s))
+		b := []rune(s)
+		for ; n >= 0 && len(b) != 0; n-- {
+			i := rr.Intn(len(b))
+			switch x := rr.Intn(4); x {
+			case 0:
+				b = append(b[:i], b[i+1:]...)
+			case 1:
+				j := rr.Intn(len(replacementBytes) - 1)
+				b[i] = replacementBytes[j]
+			case 2:
+				x := rune(rr.Intn(utf8.MaxRune))
+				for !utf8.ValidRune(x) {
+					x = rune(rr.Intn(utf8.MaxRune))
+				}
+				b[i] = x
+			case 3:
+				b[i] = rune(rr.Intn(utf8.MaxRune)) // potentially invalid
+			default:
+				t.Fatalf("unsupported value: %d", x)
+			}
+		}
+		return string(b)
+	}
+
+	rr := rand.New(rand.NewSource(1))
+	for _, s := range testStrs {
+		for i := 1_000; i >= 0; i-- {
+			testParserReference(t, modifyString(s, rr))
+		}
+	}
+}
+
+func TestNextAnsiEscapeSequence_Fuzz_Random(t *testing.T) {
+	t.Parallel()
+
+	if testing.Short() {
+		t.Skip("short test")
+	}
+
+	randomString := func(rr *rand.Rand) string {
+		numChars := rand.Intn(50)
+		codePoints := make([]rune, numChars)
+		for i := 0; i < len(codePoints); i++ {
+			var r rune
+			for n := 0; n < 1000; n++ {
+				r = rune(rr.Intn(utf8.MaxRune))
+				// Allow 10% of runes to be invalid
+				if utf8.ValidRune(r) || rr.Float64() < 0.10 {
+					break
+				}
+			}
+			codePoints[i] = r
+		}
+		return string(codePoints)
+	}
+
+	rr := rand.New(rand.NewSource(1))
+	for i := 0; i < 100_000; i++ {
+		testParserReference(t, randomString(rr))
+	}
+}
+
 func TestExtractColor(t *testing.T) {
-	assert := func(offset ansiOffset, b int32, e int32, fg int, bg int, bold bool) {
+	assert := func(offset ansiOffset, b int32, e int32, fg tui.Color, bg tui.Color, bold bool) {
+		var attr tui.Attr
+		if bold {
+			attr = tui.Bold
+		}
 		if offset.offset[0] != b || offset.offset[1] != e ||
-			offset.color.fg != fg || offset.color.bg != bg || offset.color.bold != bold {
+			offset.color.fg != fg || offset.color.bg != bg || offset.color.attr != attr {
-			t.Error(offset, b, e, fg, bg, bold)
+			t.Error(offset, b, e, fg, bg, attr)
 		}
 	}
 
 	src := "hello world"
 	var state *ansiState
 	clean := "\x1b[0m"
-	check := func(assertion func(ansiOffsets []ansiOffset, state *ansiState)) {
+	check := func(assertion func(ansiOffsets *[]ansiOffset, state *ansiState)) {
 		output, ansiOffsets, newState := extractColor(src, state, nil)
 		state = newState
 		if output != "hello world" {
-			t.Errorf("Invalid output: {}", output)
+			t.Errorf("Invalid output: %s %v", output, []rune(output))
 		}
-		fmt.Println(src, ansiOffsets, clean)
+		t.Log(src, ansiOffsets, clean)
 		assertion(ansiOffsets, state)
 	}
 
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) > 0 {
+		if offsets != nil {
 			t.Fail()
 		}
 	})
 
 	state = nil
 	src = "\x1b[0mhello world"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) > 0 {
+		if offsets != nil {
 			t.Fail()
 		}
 	})
 
 	state = nil
 	src = "\x1b[1mhello world"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 11, -1, -1, true)
+		assert((*offsets)[0], 0, 11, -1, -1, true)
 	})
 
 	state = nil
-	src = "\x1b[1mhello \x1b[mworld"
+	src = "\x1b[1mhello \x1b[mw\x1b7o\x1b8r\x1b(Bl\x1b[2@d"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 6, -1, -1, true)
+		assert((*offsets)[0], 0, 6, -1, -1, true)
 	})
 
 	state = nil
 	src = "\x1b[1mhello \x1b[Kworld"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 11, -1, -1, true)
+		assert((*offsets)[0], 0, 11, -1, -1, true)
 	})
 
 	state = nil
 	src = "hello \x1b[34;45;1mworld"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 11, 4, 5, true)
+		assert((*offsets)[0], 6, 11, 4, 5, true)
 	})
 
 	state = nil
 	src = "hello \x1b[34;45;1mwor\x1b[34;45;1mld"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 11, 4, 5, true)
+		assert((*offsets)[0], 6, 11, 4, 5, true)
 	})
 
 	state = nil
 	src = "hello \x1b[34;45;1mwor\x1b[0mld"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 9, 4, 5, true)
+		assert((*offsets)[0], 6, 9, 4, 5, true)
 	})
 
 	state = nil
 	src = "hello \x1b[34;48;5;233;1mwo\x1b[38;5;161mr\x1b[0ml\x1b[38;5;161md"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 3 {
+		if len(*offsets) != 3 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 8, 4, 233, true)
+		assert((*offsets)[0], 6, 8, 4, 233, true)
-		assert(offsets[1], 8, 9, 161, 233, true)
+		assert((*offsets)[1], 8, 9, 161, 233, true)
-		assert(offsets[2], 10, 11, 161, -1, false)
+		assert((*offsets)[2], 10, 11, 161, -1, false)
 	})
 
 	// {38,48};5;{38,48}
 	state = nil
 	src = "hello \x1b[38;5;38;48;5;48;1mwor\x1b[38;5;48;48;5;38ml\x1b[0md"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 2 {
+		if len(*offsets) != 2 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 9, 38, 48, true)
+		assert((*offsets)[0], 6, 9, 38, 48, true)
-		assert(offsets[1], 9, 10, 48, 38, true)
+		assert((*offsets)[1], 9, 10, 48, 38, true)
 	})
 
 	src = "hello \x1b[32;1mworld"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		if state.fg != 2 || state.bg != -1 || !state.bold {
+		if state.fg != 2 || state.bg != -1 || state.attr == 0 {
 			t.Fail()
 		}
-		assert(offsets[0], 6, 11, 2, -1, true)
+		assert((*offsets)[0], 6, 11, 2, -1, true)
 	})
 
 	src = "hello world"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 1 {
+		if len(*offsets) != 1 {
 			t.Fail()
 		}
-		if state.fg != 2 || state.bg != -1 || !state.bold {
+		if state.fg != 2 || state.bg != -1 || state.attr == 0 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 11, 2, -1, true)
+		assert((*offsets)[0], 0, 11, 2, -1, true)
 	})
 
 	src = "hello \x1b[0;38;5;200;48;5;100mworld"
-	check(func(offsets []ansiOffset, state *ansiState) {
+	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(offsets) != 2 {
+		if len(*offsets) != 2 {
 			t.Fail()
 		}
-		if state.fg != 200 || state.bg != 100 || state.bold {
+		if state.fg != 200 || state.bg != 100 || state.attr > 0 {
 			t.Fail()
 		}
-		assert(offsets[0], 0, 6, 2, -1, true)
+		assert((*offsets)[0], 0, 6, 2, -1, true)
-		assert(offsets[1], 6, 11, 200, 100, false)
+		assert((*offsets)[1], 6, 11, 200, 100, false)
 	})
 }
+
+func TestAnsiCodeStringConversion(t *testing.T) {
+	assert := func(code string, prevState *ansiState, expected string) {
+		state := interpretCode(code, prevState)
+		if expected != state.ToString() {
+			t.Errorf("expected: %s, actual: %s",
+				strings.Replace(expected, "\x1b[", "\\x1b[", -1),
+				strings.Replace(state.ToString(), "\x1b[", "\\x1b[", -1))
+		}
+	}
+	assert("\x1b[m", nil, "")
+	assert("\x1b[m", &ansiState{attr: tui.Blink, lbg: -1}, "")
+
+	assert("\x1b[31m", nil, "\x1b[31;49m")
+	assert("\x1b[41m", nil, "\x1b[39;41m")
+
+	assert("\x1b[92m", nil, "\x1b[92;49m")
+	assert("\x1b[102m", nil, "\x1b[39;102m")
+
+	assert("\x1b[31m", &ansiState{fg: 4, bg: 4, lbg: -1}, "\x1b[31;44m")
+	assert("\x1b[1;2;31m", &ansiState{fg: 2, bg: -1, attr: tui.Reverse, lbg: -1}, "\x1b[1;2;7;31;49m")
+	assert("\x1b[38;5;100;48;5;200m", nil, "\x1b[38;5;100;48;5;200m")
+	assert("\x1b[48;5;100;38;5;200m", nil, "\x1b[38;5;200;48;5;100m")
+	assert("\x1b[48;5;100;38;2;10;20;30;1m", nil, "\x1b[1;38;2;10;20;30;48;5;100m")
+	assert("\x1b[48;5;100;38;2;10;20;30;7m",
+		&ansiState{attr: tui.Dim | tui.Italic, fg: 1, bg: 1},
+		"\x1b[2;3;7;38;2;10;20;30;48;5;100m")
+}
+
+func TestParseAnsiCode(t *testing.T) {
+	tests := []struct {
+		In, Exp string
+		N       int
+	}{
+		{"123", "", 123},
+		{"1a", "", -1},
+		{"1a;12", "12", -1},
+		{"12;a", "a", 12},
+		{"-2", "", -1},
+	}
+	for _, x := range tests {
+		n, s := parseAnsiCode(x.In)
+		if n != x.N || s != x.Exp {
+			t.Fatalf("%q: got: (%d %q) want: (%d %q)", x.In, n, s, x.N, x.Exp)
+		}
+	}
+}
+
+// kernel/bpf/preload/iterators/README
+const ansiBenchmarkString = "\x1b[38;5;81m\x1b[01;31m\x1b[Kkernel/\x1b[0m\x1b[38;5;81mbpf/" +
+	"\x1b[0m\x1b[38;5;81mpreload/\x1b[0m\x1b[38;5;81miterators/" +
+	"\x1b[0m\x1b[38;5;149mMakefile\x1b[m\x1b[K\x1b[0m"
+
+func BenchmarkNextAnsiEscapeSequence(b *testing.B) {
+	b.SetBytes(int64(len(ansiBenchmarkString)))
+	for i := 0; i < b.N; i++ {
+		s := ansiBenchmarkString
+		for {
+			_, o := nextAnsiEscapeSequence(s)
+			if o == -1 {
+				break
+			}
+			s = s[o:]
+		}
+	}
+}
+
+// Baseline test to compare the speed of nextAnsiEscapeSequence() to the
+// previously used regex based implementation.
+func BenchmarkNextAnsiEscapeSequence_Regex(b *testing.B) {
+	b.SetBytes(int64(len(ansiBenchmarkString)))
+	for i := 0; i < b.N; i++ {
+		s := ansiBenchmarkString
+		for {
+			a := ansiRegexReference.FindStringIndex(s)
+			if len(a) == 0 {
+				break
+			}
+			s = s[a[1]:]
+		}
+	}
+}
+
+func BenchmarkExtractColor(b *testing.B) {
+	b.SetBytes(int64(len(ansiBenchmarkString)))
+	for i := 0; i < b.N; i++ {
+		extractColor(ansiBenchmarkString, nil, nil)
+	}
+}

src/cache.go

@@ -3,7 +3,7 @@ package fzf
 import "sync"
 
 // queryCache associates strings to lists of items
-type queryCache map[string][]*Item
+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 []*Item) {
+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 []*Item) {
 	(*qc)[key] = list
 }
 
-// Find is called to lookup ChunkCache
+// Lookup is called to lookup ChunkCache
-func (cc *ChunkCache) Find(chunk *Chunk, key string) ([]*Item, bool) {
+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) ([]*Item, 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
 }

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
+	chunk2p := &Chunk{count: chunkSize}
-	items1 := []*Item{&Item{}}
+	items1 := []Result{{}}
-	items2 := []*Item{&Item{}, &Item{}}
+	items2 := []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")
+		cached := cache.Lookup(chunk1p, "foo")
-		if found {
+		if cached != nil {
-			t.Error("Cached disabled for non-empty chunks", found, cached)
+			t.Error("Cached disabled for non-empty chunks", cached)
 		}
 	}
 	{
-		cached, found := cache.Find(chunk2p, "foo")
+		cached := cache.Lookup(chunk2p, "foo")
-		if !found || len(cached) != 1 {
+		if cached == nil || len(cached) != 1 {
-			t.Error("Expected 1 item cached", found, cached)
+			t.Error("Expected 1 item cached", cached)
 		}
 	}
 	{
-		cached, found := cache.Find(chunk2p, "bar")
+		cached := cache.Lookup(chunk2p, "bar")
-		if !found || len(cached) != 2 {
+		if cached == nil || len(cached) != 2 {
-			t.Error("Expected 2 items cached", found, cached)
+			t.Error("Expected 2 items cached", cached)
 		}
 	}
 	{
-		cached, found := cache.Find(chunk1p, "foobar")
+		cached := cache.Lookup(chunk1p, "foobar")
-		if found {
+		if cached != nil {
-			t.Error("Expected 0 item cached", found, cached)
+			t.Error("Expected 0 item cached", cached)
 		}
 	}
 }

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
+// Chunk is a list of Items whose size has the upper limit of chunkSize
-type Chunk []*Item // >>> []Item
+type Chunk struct {
+	items [chunkSize]Item
+	count int
+}
 
-// ItemBuilder is a closure type that builds Item object from a pointer to a
+// ItemBuilder is a closure type that builds Item object from byte array
-// string and an integer
+type ItemBuilder func(*Item, []byte) bool
-type ItemBuilder func([]byte, int) *Item
 
 // 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 {
+func (c *Chunk) push(trans ItemBuilder, data []byte) bool {
-	item := trans(data, index)
+	if trans(&c.items[c.count], data) {
-	if item != nil {
+		c.count++
-		*c = append(*c, item)
 		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,42 @@ 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, &Chunk{})
-		cl.chunks = append(cl.chunks, &newChunk)
 	}
 
-	if cl.lastChunk().push(cl.trans, data, cl.count) {
+	ret := cl.lastChunk().push(cl.trans, data)
-		cl.count++
+	cl.mutex.Unlock()
-		return true
+	return ret
-	}
+}
-	return false
+
+// Clear clears the data
+func (cl *ChunkList) Clear() {
+	cl.mutex.Lock()
+	cl.chunks = nil
+	cl.mutex.Unlock()
 }
 
 // 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 {
+	cl.mutex.Unlock()
-	newChunk := make(Chunk, len(*c))
+	return ret, CountItems(ret)
-	for idx, ptr := range *c {
-		newChunk[idx] = ptr
-	}
-	return &newChunk
 }

src/chunklist_test.go

@@ -3,14 +3,17 @@ package fzf
 import (
 	"fmt"
 	"testing"
+
+	"github.com/junegunn/fzf/src/util"
 )
 
 func TestChunkList(t *testing.T) {
 	// FIXME global
-	sortCriteria = []criterion{byMatchLen, byLength}
+	sortCriteria = []criterion{byScore, byLength}
 
-	cl := NewChunkList(func(s []byte, i int) *Item {
+	cl := NewChunkList(func(item *Item, s []byte) bool {
-		return &Item{text: []rune(string(s)), rank: buildEmptyRank(int32(i * 2))}
+		item.text = util.ToChars(s)
+		return true
 	})
 
 	// Snapshot
@@ -36,14 +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")
 	}
-	last := func(arr [5]int32) int32 {
+	if chunk1.items[0].text.ToString() != "hello" ||
-		return arr[len(arr)-1]
+		chunk1.items[1].text.ToString() != "world" {
-	}
-	if string((*chunk1)[0].text) != "hello" || last((*chunk1)[0].rank) != 0 ||
-		string((*chunk1)[1].text) != "world" || last((*chunk1)[1].rank) != 2 {
 		t.Error("Invalid data")
 	}
 	if chunk1.IsFull() {
@@ -66,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)
 	}

src/constants.go

@@ -1,33 +1,46 @@
 package fzf
 
 import (
+	"math"
+	"os"
 	"time"
 
 	"github.com/junegunn/fzf/src/util"
 )
 
 const (
-	// Current version
-	version = "0.13.2"
-
 	// Core
 	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
 	coordinatorDelayStep time.Duration = 10 * time.Millisecond
 
 	// Reader
-	defaultCommand = `find . -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | sed s/^..//`
+	readerBufferSize       = 64 * 1024
+	readerPollIntervalMin  = 10 * time.Millisecond
+	readerPollIntervalStep = 5 * time.Millisecond
+	readerPollIntervalMax  = 50 * time.Millisecond
 
 	// Terminal
-	initialDelay    = 20 * time.Millisecond
+	initialDelay      = 20 * time.Millisecond
-	initialDelayTac = 100 * time.Millisecond
+	initialDelayTac   = 100 * time.Millisecond
-	spinnerDuration = 200 * time.Millisecond
+	spinnerDuration   = 100 * time.Millisecond
+	previewCancelWait = 500 * time.Millisecond
+	previewChunkDelay = 100 * time.Millisecond
+	previewDelayed    = 500 * time.Millisecond
+	maxPatternLength  = 300
+	maxMulti          = math.MaxInt32
 
 	// Matcher
-	progressMinDuration = 200 * time.Millisecond
+	numPartitionsMultiplier = 8
+	maxPartitions           = 32
+	progressMinDuration     = 200 * time.Millisecond
 
 	// Capacity of each chunk
 	chunkSize int = 100
 
+	// Pre-allocated memory slices to minimize GC
+	slab16Size int = 100 * 1024 // 200KB * 32 = 12.8MB
+	slab32Size int = 2048       // 8KB * 32 = 256KB
+
 	// Do not cache results of low selectivity queries
 	queryCacheMax int = chunkSize / 5
 
@@ -41,6 +54,16 @@ const (
 	defaultJumpLabels string = "asdfghjklqwertyuiopzxcvbnm1234567890ASDFGHJKLQWERTYUIOPZXCVBNM`~;:,<.>/?'\"!@#$%^&*()[{]}-_=+"
 )
 
+var defaultCommand string
+
+func init() {
+	if !util.IsWindows() {
+		defaultCommand = `set -o pipefail; command find -L . -mindepth 1 \( -path '*/\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \) -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-`
+	} else if os.Getenv("TERM") == "cygwin" {
+		defaultCommand = `sh -c "command find -L . -mindepth 1 -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-"`
+	}
+}
+
 // fzf events
 const (
 	EvtReadNew util.EventType = iota
@@ -49,10 +72,12 @@ const (
 	EvtSearchProgress
 	EvtSearchFin
 	EvtHeader
-	EvtClose
+	EvtReady
+	EvtQuit
 )
 
 const (
+	exitCancel    = -1
 	exitOk        = 0
 	exitNoMatch   = 1
 	exitError     = 2

src/core.go

@@ -3,7 +3,7 @@ Package fzf implements fzf, a command-line fuzzy finder.
 
 The MIT License (MIT)
 
-Copyright (c) 2016 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -28,16 +28,11 @@ package fzf
 import (
 	"fmt"
 	"os"
-	"runtime"
 	"time"
 
 	"github.com/junegunn/fzf/src/util"
 )
 
-func initProcs() {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-}
-
 /*
 Reader   -> EvtReadFin
 Reader   -> EvtReadNew        -> Matcher  (restart)
@@ -48,14 +43,16 @@ Matcher  -> EvtHeader         -> Terminal (update header)
 */
 
 // Run starts fzf
-func Run(opts *Options) {
+func Run(opts *Options, version string, revision string) {
-	initProcs()
-
 	sort := opts.Sort > 0
 	sortCriteria = opts.Criteria
 
 	if opts.Version {
-		fmt.Println(version)
+		if len(revision) > 0 {
+			fmt.Printf("%s (%s)\n", version, revision)
+		} else {
+			fmt.Println(version)
+		}
 		os.Exit(exitOk)
 	}
 
@@ -63,78 +60,87 @@ func Run(opts *Options) {
 	eventBox := util.NewEventBox()
 
 	// ANSI code processor
-	ansiProcessor := func(data []byte) ([]rune, []ansiOffset) {
+	ansiProcessor := func(data []byte) (util.Chars, *[]ansiOffset) {
-		return util.BytesToRunes(data), nil
+		return util.ToChars(data), nil
-	}
-	ansiProcessorRunes := func(data []rune) ([]rune, []ansiOffset) {
-		return data, nil
 	}
+
+	var lineAnsiState, prevLineAnsiState *ansiState
 	if opts.Ansi {
-		if opts.Theme != nil {
+		if opts.Theme.Colored {
-			var state *ansiState
+			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
-			ansiProcessor = func(data []byte) ([]rune, []ansiOffset) {
+				prevLineAnsiState = lineAnsiState
-				trimmed, offsets, newState := extractColor(string(data), state, nil)
+				trimmed, offsets, newState := extractColor(string(data), lineAnsiState, nil)
-				state = newState
+				lineAnsiState = newState
-				return []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) ([]rune, []ansiOffset) {
+			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				trimmed, _, _ := extractColor(string(data), nil, nil)
-				return []rune(trimmed), nil
+				return util.ToChars([]byte(trimmed)), nil
 			}
 		}
-		ansiProcessorRunes = func(data []rune) ([]rune, []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
 			}
-			runes, colors := ansiProcessor(data)
+			item.text, item.colors = ansiProcessor(data)
-			return &Item{
+			item.text.Index = itemIndex
-				text:   runes,
+			itemIndex++
-				colors: colors,
+			return true
-				rank:   buildEmptyRank(int32(index))}
 		})
 	} else {
-		chunkList = NewChunkList(func(data []byte, index int) *Item {
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
-			runes := util.BytesToRunes(data)
+			tokens := Tokenize(string(data), opts.Delimiter)
-			tokens := Tokenize(runes, opts.Delimiter)
+			if opts.Ansi && opts.Theme.Colored && len(tokens) > 1 {
-			trans := Transform(tokens, opts.WithNth)
+				var ansiState *ansiState
-			if len(header) < opts.HeaderLines {
+				if prevLineAnsiState != nil {
-				header = append(header, string(joinTokens(trans)))
+					ansiStateDup := *prevLineAnsiState
-				eventBox.Set(EvtHeader, header)
+					ansiState = &ansiStateDup
-				return nil
+				}
+				for _, token := range tokens {
+					prevAnsiState := ansiState
+					_, _, ansiState = extractColor(token.text.ToString(), ansiState, nil)
+					if prevAnsiState != nil {
+						token.text.Prepend("\x1b[m" + prevAnsiState.ToString())
+					} else {
+						token.text.Prepend("\x1b[m")
+					}
+				}
 			}
-			item := Item{
+			trans := Transform(tokens, opts.WithNth)
-				text:     joinTokens(trans),
+			transformed := joinTokens(trans)
-				origText: &runes,
+			if len(header) < opts.HeaderLines {
-				colors:   nil,
+				header = append(header, transformed)
-				rank:     buildEmptyRank(int32(index))}
+				eventBox.Set(EvtHeader, header)
-
+				return false
-			trimmed, colors := ansiProcessorRunes(item.text)
+			}
-			item.text = trimmed
+			item.text, item.colors = ansiProcessor([]byte(transformed))
-			item.colors = colors
+			item.text.TrimTrailingWhitespaces()
-			return &item
+			item.text.Index = itemIndex
+			item.origText = &data
+			itemIndex++
+			return true
 		})
 	}
 
 	// Reader
 	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
+	var reader *Reader
 	if !streamingFilter {
-		reader := Reader{func(data []byte) bool {
+		reader = NewReader(func(data []byte) bool {
 			return chunkList.Push(data)
-		}, eventBox, opts.ReadZero}
+		}, eventBox, opts.ReadZero, opts.Filter == nil)
 		go reader.ReadSource()
 	}
 
@@ -151,30 +157,34 @@ func Run(opts *Options) {
 	}
 	patternBuilder := func(runes []rune) *Pattern {
 		return BuildPattern(
-			opts.Fuzzy, opts.Extended, opts.Case, forward,
+			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward,
-			opts.Nth, opts.Delimiter, runes)
+			opts.Filter == nil, opts.Nth, opts.Delimiter, runes)
 	}
 	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)
 
 	// Filtering mode
 	if opts.Filter != nil {
 		if opts.PrintQuery {
-			fmt.Println(*opts.Filter)
+			opts.Printer(*opts.Filter)
 		}
 
 		pattern := patternBuilder([]rune(*opts.Filter))
+		matcher.sort = pattern.sortable
 
 		found := false
 		if streamingFilter {
-			reader := Reader{
+			slab := util.MakeSlab(slab16Size, slab32Size)
+			reader := NewReader(
 				func(runes []byte) bool {
-					item := chunkList.trans(runes, 0)
+					item := Item{}
-					if item != nil && pattern.MatchItem(item) {
+					if chunkList.trans(&item, runes) {
-						fmt.Println(string(item.text))
+						if result, _, _ := pattern.MatchItem(&item, false, slab); result != nil {
-						found = true
+							opts.Printer(item.text.ToString())
+							found = true
+						}
 					}
 					return false
-				}, eventBox, opts.ReadZero}
+				}, eventBox, opts.ReadZero, false)
 			reader.ReadSource()
 		} else {
 			eventBox.Unwatch(EvtReadNew)
@@ -185,7 +195,7 @@ func Run(opts *Options) {
 				chunks:  snapshot,
 				pattern: pattern})
 			for i := 0; i < merger.Length(); i++ {
-				fmt.Println(merger.Get(i).AsString(opts.Ansi))
+				opts.Printer(merger.Get(i).item.AsString(opts.Ansi))
 				found = true
 			}
 		}
@@ -214,29 +224,76 @@ func Run(opts *Options) {
 
 	// Event coordination
 	reading := true
+	clearCache := util.Once(false)
+	clearSelection := util.Once(false)
 	ticks := 0
+	var nextCommand *string
+	restart := func(command string) {
+		reading = true
+		clearCache = util.Once(true)
+		clearSelection = util.Once(true)
+		chunkList.Clear()
+		itemIndex = 0
+		header = make([]string, 0, opts.HeaderLines)
+		go reader.restart(command)
+	}
 	eventBox.Watch(EvtReadNew)
+	query := []rune{}
 	for {
 		delay := true
 		ticks++
+		input := func() []rune {
+			paused, input := terminal.Input()
+			if !paused {
+				query = input
+			}
+			return query
+		}
 		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 EvtQuit:
+					if reading {
+						reader.terminate()
+					}
+					os.Exit(value.(int))
 				case EvtReadNew, EvtReadFin:
-					reading = reading && evt == EvtReadNew
+					if evt == EvtReadFin && nextCommand != nil {
+						restart(*nextCommand)
+						nextCommand = nil
+						break
+					} else {
+						reading = reading && evt == EvtReadNew
+					}
 					snapshot, count := chunkList.Snapshot()
-					terminal.UpdateCount(count, !reading)
+					terminal.UpdateCount(count, !reading, value.(*string))
-					matcher.Reset(snapshot, terminal.Input(), false, !reading, sort)
+					if opts.Sync {
+						opts.Sync = false
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac), false)
+					}
+					matcher.Reset(snapshot, input(), false, !reading, sort, clearCache())
 
 				case EvtSearchNew:
+					var command *string
 					switch val := value.(type) {
-					case bool:
+					case searchRequest:
-						sort = val
+						sort = val.sort
+						command = val.command
+					}
+					if command != nil {
+						if reading {
+							reader.terminate()
+							nextCommand = command
+						} else {
+							restart(*command)
+						}
+						break
 					}
 					snapshot, _ := chunkList.Snapshot()
-					matcher.Reset(snapshot, terminal.Input(), true, !reading, sort)
+					matcher.Reset(snapshot, input(), true, !reading, sort, clearCache())
 					delay = false
 
 				case EvtSearchProgress:
@@ -246,7 +303,9 @@ func Run(opts *Options) {
 					}
 
 				case EvtHeader:
-					terminal.UpdateHeader(value.([]string))
+					headerPadded := make([]string, opts.HeaderLines)
+					copy(headerPadded, value.([]string))
+					terminal.UpdateHeader(headerPadded)
 
 				case EvtSearchFin:
 					switch val := value.(type) {
@@ -259,13 +318,13 @@ func Run(opts *Options) {
 							} else if val.final {
 								if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
 									if opts.PrintQuery {
-										fmt.Println(opts.Query)
+										opts.Printer(opts.Query)
 									}
 									if len(opts.Expect) > 0 {
-										fmt.Println()
+										opts.Printer("")
 									}
 									for i := 0; i < count; i++ {
-										fmt.Println(val.Get(i).AsString(opts.Ansi))
+										opts.Printer(val.Get(i).item.AsString(opts.Ansi))
 									}
 									if count > 0 {
 										os.Exit(exitOk)
@@ -276,10 +335,11 @@ func Run(opts *Options) {
 								terminal.startChan <- true
 							}
 						}
-						terminal.UpdateList(val)
+						terminal.UpdateList(val, clearSelection())
 					}
 				}
 			}
+			events.Clear()
 		})
 		if delay && reading {
 			dur := util.DurWithin(

src/curses/curses.go

@@ -1,704 +0,0 @@
-package curses
-
-/*
-#include <ncurses.h>
-#include <locale.h>
-#cgo !static LDFLAGS: -lncurses
-#cgo static LDFLAGS: -l:libncursesw.a -l:libtinfo.a -l:libgpm.a -ldl
-#cgo android static LDFLAGS: -l:libncurses.a -fPIE -march=armv7-a -mfpu=neon -mhard-float -Wl,--no-warn-mismatch
-
-SCREEN *c_newterm () {
-	return newterm(NULL, stderr, stdin);
-}
-
-*/
-import "C"
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"syscall"
-	"time"
-	"unicode/utf8"
-)
-
-// Types of user action
-const (
-	Rune = iota
-
-	CtrlA
-	CtrlB
-	CtrlC
-	CtrlD
-	CtrlE
-	CtrlF
-	CtrlG
-	CtrlH
-	Tab
-	CtrlJ
-	CtrlK
-	CtrlL
-	CtrlM
-	CtrlN
-	CtrlO
-	CtrlP
-	CtrlQ
-	CtrlR
-	CtrlS
-	CtrlT
-	CtrlU
-	CtrlV
-	CtrlW
-	CtrlX
-	CtrlY
-	CtrlZ
-	ESC
-
-	Invalid
-	Mouse
-	DoubleClick
-
-	BTab
-	BSpace
-
-	Del
-	PgUp
-	PgDn
-
-	Up
-	Down
-	Left
-	Right
-	Home
-	End
-
-	SLeft
-	SRight
-
-	F1
-	F2
-	F3
-	F4
-	F5
-	F6
-	F7
-	F8
-	F9
-	F10
-
-	AltEnter
-	AltSpace
-	AltSlash
-	AltBS
-	AltA
-	AltB
-	AltC
-	AltD
-	AltE
-	AltF
-
-	AltZ = AltA + 'z' - 'a'
-)
-
-// Pallete
-const (
-	ColNormal = iota
-	ColPrompt
-	ColMatch
-	ColCurrent
-	ColCurrentMatch
-	ColSpinner
-	ColInfo
-	ColCursor
-	ColSelected
-	ColHeader
-	ColBorder
-	ColUser // Should be the last entry
-)
-
-const (
-	doubleClickDuration = 500 * time.Millisecond
-	colDefault          = -1
-	colUndefined        = -2
-)
-
-type ColorTheme struct {
-	UseDefault   bool
-	Fg           int16
-	Bg           int16
-	DarkBg       int16
-	Prompt       int16
-	Match        int16
-	Current      int16
-	CurrentMatch int16
-	Spinner      int16
-	Info         int16
-	Cursor       int16
-	Selected     int16
-	Header       int16
-	Border       int16
-}
-
-type Event struct {
-	Type       int
-	Char       rune
-	MouseEvent *MouseEvent
-}
-
-type MouseEvent struct {
-	Y      int
-	X      int
-	S      int
-	Down   bool
-	Double bool
-	Mod    bool
-}
-
-var (
-	_buf          []byte
-	_in           *os.File
-	_color        func(int, bool) C.int
-	_colorMap     map[int]int
-	_prevDownTime time.Time
-	_clickY       []int
-	_screen       *C.SCREEN
-	Default16     *ColorTheme
-	Dark256       *ColorTheme
-	Light256      *ColorTheme
-	FG            int
-	CurrentFG     int
-	BG            int
-	DarkBG        int
-)
-
-type Window struct {
-	win    *C.WINDOW
-	Top    int
-	Left   int
-	Width  int
-	Height int
-}
-
-func NewWindow(top int, left int, width int, height int, border bool) *Window {
-	win := C.newwin(C.int(height), C.int(width), C.int(top), C.int(left))
-	if border {
-		attr := _color(ColBorder, false)
-		C.wattron(win, attr)
-		C.box(win, 0, 0)
-		C.wattroff(win, attr)
-	}
-	return &Window{
-		win:    win,
-		Top:    top,
-		Left:   left,
-		Width:  width,
-		Height: height,
-	}
-}
-
-func EmptyTheme() *ColorTheme {
-	return &ColorTheme{
-		UseDefault:   true,
-		Fg:           colUndefined,
-		Bg:           colUndefined,
-		DarkBg:       colUndefined,
-		Prompt:       colUndefined,
-		Match:        colUndefined,
-		Current:      colUndefined,
-		CurrentMatch: colUndefined,
-		Spinner:      colUndefined,
-		Info:         colUndefined,
-		Cursor:       colUndefined,
-		Selected:     colUndefined,
-		Header:       colUndefined,
-		Border:       colUndefined}
-}
-
-func init() {
-	_prevDownTime = time.Unix(0, 0)
-	_clickY = []int{}
-	_colorMap = make(map[int]int)
-	Default16 = &ColorTheme{
-		UseDefault:   true,
-		Fg:           15,
-		Bg:           0,
-		DarkBg:       C.COLOR_BLACK,
-		Prompt:       C.COLOR_BLUE,
-		Match:        C.COLOR_GREEN,
-		Current:      C.COLOR_YELLOW,
-		CurrentMatch: C.COLOR_GREEN,
-		Spinner:      C.COLOR_GREEN,
-		Info:         C.COLOR_WHITE,
-		Cursor:       C.COLOR_RED,
-		Selected:     C.COLOR_MAGENTA,
-		Header:       C.COLOR_CYAN,
-		Border:       C.COLOR_BLACK}
-	Dark256 = &ColorTheme{
-		UseDefault:   true,
-		Fg:           15,
-		Bg:           0,
-		DarkBg:       236,
-		Prompt:       110,
-		Match:        108,
-		Current:      254,
-		CurrentMatch: 151,
-		Spinner:      148,
-		Info:         144,
-		Cursor:       161,
-		Selected:     168,
-		Header:       109,
-		Border:       59}
-	Light256 = &ColorTheme{
-		UseDefault:   true,
-		Fg:           15,
-		Bg:           0,
-		DarkBg:       251,
-		Prompt:       25,
-		Match:        66,
-		Current:      237,
-		CurrentMatch: 23,
-		Spinner:      65,
-		Info:         101,
-		Cursor:       161,
-		Selected:     168,
-		Header:       31,
-		Border:       145}
-}
-
-func attrColored(pair int, bold bool) C.int {
-	var attr C.int
-	if pair > ColNormal {
-		attr = C.COLOR_PAIR(C.int(pair))
-	}
-	if bold {
-		attr = attr | C.A_BOLD
-	}
-	return attr
-}
-
-func attrMono(pair int, bold bool) C.int {
-	var attr C.int
-	switch pair {
-	case ColCurrent:
-		if bold {
-			attr = C.A_REVERSE
-		}
-	case ColMatch:
-		attr = C.A_UNDERLINE
-	case ColCurrentMatch:
-		attr = C.A_UNDERLINE | C.A_REVERSE
-	}
-	if bold {
-		attr = attr | C.A_BOLD
-	}
-	return attr
-}
-
-func MaxX() int {
-	return int(C.COLS)
-}
-
-func MaxY() int {
-	return int(C.LINES)
-}
-
-func getch(nonblock bool) int {
-	b := make([]byte, 1)
-	syscall.SetNonblock(int(_in.Fd()), nonblock)
-	_, err := _in.Read(b)
-	if err != nil {
-		return -1
-	}
-	return int(b[0])
-}
-
-func Init(theme *ColorTheme, black bool, mouse bool) {
-	{
-		in, err := os.OpenFile("/dev/tty", syscall.O_RDONLY, 0)
-		if err != nil {
-			panic("Failed to open /dev/tty")
-		}
-		_in = in
-		// Break STDIN
-		// syscall.Dup2(int(in.Fd()), int(os.Stdin.Fd()))
-	}
-
-	C.setlocale(C.LC_ALL, C.CString(""))
-	_screen = C.c_newterm()
-	if _screen == nil {
-		fmt.Println("Invalid $TERM: " + os.Getenv("TERM"))
-		os.Exit(2)
-	}
-	C.set_term(_screen)
-	if mouse {
-		C.mousemask(C.ALL_MOUSE_EVENTS, nil)
-	}
-	C.noecho()
-	C.raw() // stty dsusp undef
-
-	if theme != nil {
-		C.start_color()
-		var baseTheme *ColorTheme
-		if C.tigetnum(C.CString("colors")) >= 256 {
-			baseTheme = Dark256
-		} else {
-			baseTheme = Default16
-		}
-		initPairs(baseTheme, theme, black)
-		_color = attrColored
-	} else {
-		_color = attrMono
-	}
-}
-
-func override(a int16, b int16) C.short {
-	if b == colUndefined {
-		return C.short(a)
-	}
-	return C.short(b)
-}
-
-func initPairs(baseTheme *ColorTheme, theme *ColorTheme, black bool) {
-	fg := override(baseTheme.Fg, theme.Fg)
-	bg := override(baseTheme.Bg, theme.Bg)
-	if black {
-		bg = C.COLOR_BLACK
-	} else if theme.UseDefault {
-		fg = colDefault
-		bg = colDefault
-		C.use_default_colors()
-	}
-	if theme.UseDefault {
-		FG = colDefault
-		BG = colDefault
-	} else {
-		FG = int(fg)
-		BG = int(bg)
-		C.assume_default_colors(C.int(override(baseTheme.Fg, theme.Fg)), C.int(bg))
-	}
-
-	currentFG := override(baseTheme.Current, theme.Current)
-	darkBG := override(baseTheme.DarkBg, theme.DarkBg)
-	CurrentFG = int(currentFG)
-	DarkBG = int(darkBG)
-	C.init_pair(ColPrompt, override(baseTheme.Prompt, theme.Prompt), bg)
-	C.init_pair(ColMatch, override(baseTheme.Match, theme.Match), bg)
-	C.init_pair(ColCurrent, currentFG, darkBG)
-	C.init_pair(ColCurrentMatch, override(baseTheme.CurrentMatch, theme.CurrentMatch), darkBG)
-	C.init_pair(ColSpinner, override(baseTheme.Spinner, theme.Spinner), bg)
-	C.init_pair(ColInfo, override(baseTheme.Info, theme.Info), bg)
-	C.init_pair(ColCursor, override(baseTheme.Cursor, theme.Cursor), darkBG)
-	C.init_pair(ColSelected, override(baseTheme.Selected, theme.Selected), darkBG)
-	C.init_pair(ColHeader, override(baseTheme.Header, theme.Header), bg)
-	C.init_pair(ColBorder, override(baseTheme.Border, theme.Border), bg)
-}
-
-func Close() {
-	C.endwin()
-	C.delscreen(_screen)
-}
-
-func GetBytes() []byte {
-	c := getch(false)
-	_buf = append(_buf, byte(c))
-
-	for {
-		c = getch(true)
-		if c == -1 {
-			break
-		}
-		_buf = append(_buf, byte(c))
-	}
-
-	return _buf
-}
-
-// 27 (91 79) 77 type x y
-func mouseSequence(sz *int) Event {
-	if len(_buf) < 6 {
-		return Event{Invalid, 0, nil}
-	}
-	*sz = 6
-	switch _buf[3] {
-	case 32, 36, 40, 48, // mouse-down / shift / cmd / ctrl
-		35, 39, 43, 51: // mouse-up / shift / cmd / ctrl
-		mod := _buf[3] >= 36
-		down := _buf[3]%2 == 0
-		x := int(_buf[4] - 33)
-		y := int(_buf[5] - 33)
-		double := false
-		if down {
-			now := time.Now()
-			if now.Sub(_prevDownTime) < doubleClickDuration {
-				_clickY = append(_clickY, y)
-			} else {
-				_clickY = []int{y}
-			}
-			_prevDownTime = now
-		} else {
-			if len(_clickY) > 1 && _clickY[0] == _clickY[1] &&
-				time.Now().Sub(_prevDownTime) < doubleClickDuration {
-				double = true
-			}
-		}
-		return Event{Mouse, 0, &MouseEvent{y, x, 0, down, double, mod}}
-	case 96, 100, 104, 112, // scroll-up / shift / cmd / ctrl
-		97, 101, 105, 113: // scroll-down / shift / cmd / ctrl
-		mod := _buf[3] >= 100
-		s := 1 - int(_buf[3]%2)*2
-		x := int(_buf[4] - 33)
-		y := int(_buf[5] - 33)
-		return Event{Mouse, 0, &MouseEvent{y, x, s, false, false, mod}}
-	}
-	return Event{Invalid, 0, nil}
-}
-
-func escSequence(sz *int) Event {
-	if len(_buf) < 2 {
-		return Event{ESC, 0, nil}
-	}
-	*sz = 2
-	switch _buf[1] {
-	case 13:
-		return Event{AltEnter, 0, nil}
-	case 32:
-		return Event{AltSpace, 0, nil}
-	case 47:
-		return Event{AltSlash, 0, nil}
-	case 98:
-		return Event{AltB, 0, nil}
-	case 100:
-		return Event{AltD, 0, nil}
-	case 102:
-		return Event{AltF, 0, nil}
-	case 127:
-		return Event{AltBS, 0, nil}
-	case 91, 79:
-		if len(_buf) < 3 {
-			return Event{Invalid, 0, nil}
-		}
-		*sz = 3
-		switch _buf[2] {
-		case 68:
-			return Event{Left, 0, nil}
-		case 67:
-			return Event{Right, 0, nil}
-		case 66:
-			return Event{Down, 0, nil}
-		case 65:
-			return Event{Up, 0, nil}
-		case 90:
-			return Event{BTab, 0, nil}
-		case 72:
-			return Event{Home, 0, nil}
-		case 70:
-			return Event{End, 0, nil}
-		case 77:
-			return mouseSequence(sz)
-		case 80:
-			return Event{F1, 0, nil}
-		case 81:
-			return Event{F2, 0, nil}
-		case 82:
-			return Event{F3, 0, nil}
-		case 83:
-			return Event{F4, 0, nil}
-		case 49, 50, 51, 52, 53, 54:
-			if len(_buf) < 4 {
-				return Event{Invalid, 0, nil}
-			}
-			*sz = 4
-			switch _buf[2] {
-			case 50:
-				if len(_buf) == 5 && _buf[4] == 126 {
-					*sz = 5
-					switch _buf[3] {
-					case 48:
-						return Event{F9, 0, nil}
-					case 49:
-						return Event{F10, 0, nil}
-					}
-				}
-				// Bracketed paste mode \e[200~ / \e[201
-				if _buf[3] == 48 && (_buf[4] == 48 || _buf[4] == 49) && _buf[5] == 126 {
-					*sz = 6
-					return Event{Invalid, 0, nil}
-				}
-				return Event{Invalid, 0, nil} // INS
-			case 51:
-				return Event{Del, 0, nil}
-			case 52:
-				return Event{End, 0, nil}
-			case 53:
-				return Event{PgUp, 0, nil}
-			case 54:
-				return Event{PgDn, 0, nil}
-			case 49:
-				switch _buf[3] {
-				case 126:
-					return Event{Home, 0, nil}
-				case 53, 55, 56, 57:
-					if len(_buf) == 5 && _buf[4] == 126 {
-						*sz = 5
-						switch _buf[3] {
-						case 53:
-							return Event{F5, 0, nil}
-						case 55:
-							return Event{F6, 0, nil}
-						case 56:
-							return Event{F7, 0, nil}
-						case 57:
-							return Event{F8, 0, nil}
-						}
-					}
-					return Event{Invalid, 0, nil}
-				case 59:
-					if len(_buf) != 6 {
-						return Event{Invalid, 0, nil}
-					}
-					*sz = 6
-					switch _buf[4] {
-					case 50:
-						switch _buf[5] {
-						case 68:
-							return Event{Home, 0, nil}
-						case 67:
-							return Event{End, 0, nil}
-						}
-					case 53:
-						switch _buf[5] {
-						case 68:
-							return Event{SLeft, 0, nil}
-						case 67:
-							return Event{SRight, 0, nil}
-						}
-					} // _buf[4]
-				} // _buf[3]
-			} // _buf[2]
-		} // _buf[2]
-	} // _buf[1]
-	if _buf[1] >= 'a' && _buf[1] <= 'z' {
-		return Event{AltA + int(_buf[1]) - 'a', 0, nil}
-	}
-	return Event{Invalid, 0, nil}
-}
-
-func GetChar() Event {
-	if len(_buf) == 0 {
-		_buf = GetBytes()
-	}
-	if len(_buf) == 0 {
-		panic("Empty _buffer")
-	}
-
-	sz := 1
-	defer func() {
-		_buf = _buf[sz:]
-	}()
-
-	switch _buf[0] {
-	case CtrlC:
-		return Event{CtrlC, 0, nil}
-	case CtrlG:
-		return Event{CtrlG, 0, nil}
-	case CtrlQ:
-		return Event{CtrlQ, 0, nil}
-	case 127:
-		return Event{BSpace, 0, nil}
-	case ESC:
-		return escSequence(&sz)
-	}
-
-	// CTRL-A ~ CTRL-Z
-	if _buf[0] <= CtrlZ {
-		return Event{int(_buf[0]), 0, nil}
-	}
-	r, rsz := utf8.DecodeRune(_buf)
-	if r == utf8.RuneError {
-		return Event{ESC, 0, nil}
-	}
-	sz = rsz
-	return Event{Rune, r, nil}
-}
-
-func (w *Window) Close() {
-	C.delwin(w.win)
-}
-
-func (w *Window) Enclose(y int, x int) bool {
-	return bool(C.wenclose(w.win, C.int(y), C.int(x)))
-}
-
-func (w *Window) Move(y int, x int) {
-	C.wmove(w.win, C.int(y), C.int(x))
-}
-
-func (w *Window) MoveAndClear(y int, x int) {
-	w.Move(y, x)
-	C.wclrtoeol(w.win)
-}
-
-func (w *Window) Print(text string) {
-	C.waddstr(w.win, C.CString(strings.Map(func(r rune) rune {
-		if r < 32 {
-			return -1
-		}
-		return r
-	}, text)))
-}
-
-func (w *Window) CPrint(pair int, bold bool, text string) {
-	attr := _color(pair, bold)
-	C.wattron(w.win, attr)
-	w.Print(text)
-	C.wattroff(w.win, attr)
-}
-
-func Clear() {
-	C.clear()
-}
-
-func Endwin() {
-	C.endwin()
-}
-
-func Refresh() {
-	C.refresh()
-}
-
-func (w *Window) Erase() {
-	C.werase(w.win)
-}
-
-func (w *Window) Fill(str string) bool {
-	return C.waddstr(w.win, C.CString(str)) == C.OK
-}
-
-func (w *Window) CFill(str string, fg int, bg int, bold bool) bool {
-	attr := _color(PairFor(fg, bg), bold)
-	C.wattron(w.win, attr)
-	ret := w.Fill(str)
-	C.wattroff(w.win, attr)
-	return ret
-}
-
-func (w *Window) Refresh() {
-	C.wnoutrefresh(w.win)
-}
-
-func DoUpdate() {
-	C.doupdate()
-}
-
-func PairFor(fg int, bg int) int {
-	key := (fg << 8) + bg
-	if found, prs := _colorMap[key]; prs {
-		return found
-	}
-
-	id := len(_colorMap) + ColUser
-	C.init_pair(C.short(id), C.short(fg), C.short(bg))
-	_colorMap[key] = id
-	return id
-}

src/curses/curses_test.go

@@ -1,14 +0,0 @@
-package curses
-
-import (
-	"testing"
-)
-
-func TestPairFor(t *testing.T) {
-	if PairFor(30, 50) != PairFor(30, 50) {
-		t.Fail()
-	}
-	if PairFor(-1, 10) != PairFor(-1, 10) {
-		t.Fail()
-	}
-}

src/fzf/main.go

@@ -1,7 +0,0 @@
-package main
-
-import "github.com/junegunn/fzf/src"
-
-func main() {
-	fzf.Run(fzf.ParseOptions())
-}

src/history.go

@@ -59,7 +59,7 @@ func (h *History) append(line string) error {
 
 	lines := append(h.lines[:len(h.lines)-1], line)
 	if len(lines) > h.maxSize {
-		lines = lines[len(lines)-h.maxSize : len(lines)]
+		lines = lines[len(lines)-h.maxSize:]
 	}
 	h.lines = append(lines, "")
 	return ioutil.WriteFile(h.path, []byte(strings.Join(h.lines, "\n")), 0600)

src/history_test.go

@@ -1,7 +1,9 @@
 package fzf
 
 import (
-	"os/user"
+	"io/ioutil"
+	"os"
+	"runtime"
 	"testing"
 )
 
@@ -9,24 +11,31 @@ func TestHistory(t *testing.T) {
 	maxHistory := 50
 
 	// Invalid arguments
-	user, _ := user.Current()
+	var paths []string
-	paths := []string{"/etc", "/proc"}
+	if runtime.GOOS == "windows" {
-	if user.Name != "root" {
+		// GOPATH should exist, so we shouldn't be able to override it
-		paths = append(paths, "/etc/sudoers")
+		paths = []string{os.Getenv("GOPATH")}
+	} else {
+		paths = []string{"/etc", "/proc"}
 	}
+
 	for _, path := range paths {
 		if _, e := NewHistory(path, maxHistory); e == nil {
 			t.Error("Error expected for: " + path)
 		}
 	}
+
+	f, _ := ioutil.TempFile("", "fzf-history")
+	f.Close()
+
 	{ // Append lines
-		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		h, _ := NewHistory(f.Name(), maxHistory)
 		for i := 0; i < maxHistory+10; i++ {
 			h.append("foobar")
 		}
 	}
 	{ // Read lines
-		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		h, _ := NewHistory(f.Name(), maxHistory)
 		if len(h.lines) != maxHistory+1 {
 			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
 		}
@@ -37,13 +46,13 @@ func TestHistory(t *testing.T) {
 		}
 	}
 	{ // Append lines
-		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		h, _ := NewHistory(f.Name(), maxHistory)
 		h.append("barfoo")
 		h.append("")
 		h.append("foobarbaz")
 	}
 	{ // Read lines again
-		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		h, _ := NewHistory(f.Name(), maxHistory)
 		if len(h.lines) != maxHistory+1 {
 			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
 		}

src/item.go

@@ -1,291 +1,44 @@
 package fzf
 
 import (
-	"math"
+	"github.com/junegunn/fzf/src/util"
-
-	"github.com/junegunn/fzf/src/curses"
 )
 
-// Offset holds three 32-bit integers denoting the offsets of a matched substring
+// Item represents each input line. 56 bytes.
-type Offset [3]int32
-
-type colorOffset struct {
-	offset [2]int32
-	color  int
-	bold   bool
-}
-
-// Item represents each input line
 type Item struct {
-	text        []rune
+	text        util.Chars    // 32 = 24 + 1 + 1 + 2 + 4
-	origText    *[]rune
+	transformed *[]Token      // 8
-	transformed []Token
+	origText    *[]byte       // 8
-	offsets     []Offset
+	colors      *[]ansiOffset // 8
-	colors      []ansiOffset
-	rank        [5]int32
-	bonus       int32
-}
-
-// Sort criteria to use. Never changes once fzf is started.
-var sortCriteria []criterion
-
-func isRankValid(rank [5]int32) bool {
-	// Exclude ordinal index
-	for _, r := range rank[:4] {
-		if r > 0 {
-			return true
-		}
-	}
-	return false
-}
-
-func buildEmptyRank(index int32) [5]int32 {
-	return [5]int32{0, 0, 0, 0, index}
 }
 
+// Index returns ordinal index of the Item
 func (item *Item) Index() int32 {
-	return item.rank[4]
+	return item.text.Index
 }
 
-// Rank calculates rank of the Item
+var minItem = Item{text: util.Chars{Index: -1}}
-func (item *Item) Rank(cache bool) [5]int32 {
+
-	if cache && isRankValid(item.rank) {
+func (item *Item) TrimLength() uint16 {
-		return item.rank
+	return item.text.TrimLength()
+}
+
+// Colors returns ansiOffsets of the Item
+func (item *Item) Colors() []ansiOffset {
+	if item.colors == nil {
+		return []ansiOffset{}
 	}
-	matchlen := 0
+	return *item.colors
-	prevEnd := 0
-	lenSum := 0
-	minBegin := math.MaxInt32
-	for _, offset := range item.offsets {
-		begin := int(offset[0])
-		end := int(offset[1])
-		trimLen := int(offset[2])
-		lenSum += trimLen
-		if prevEnd > begin {
-			begin = prevEnd
-		}
-		if end > prevEnd {
-			prevEnd = end
-		}
-		if end > begin {
-			if begin < minBegin {
-				minBegin = begin
-			}
-			matchlen += end - begin
-		}
-	}
-	rank := buildEmptyRank(item.Index())
-	for idx, criterion := range sortCriteria {
-		var val int32
-		switch criterion {
-		case byMatchLen:
-			if matchlen == 0 {
-				val = math.MaxInt32
-			} else {
-				// It is extremely unlikely that bonus exceeds 128
-				val = 128*int32(matchlen) - item.bonus
-			}
-		case byLength:
-			// It is guaranteed that .transformed in not null in normal execution
-			if item.transformed != nil {
-				// If offsets is empty, lenSum will be 0, but we don't care
-				val = int32(lenSum)
-			} else {
-				val = int32(len(item.text))
-			}
-		case byBegin:
-			// We can't just look at item.offsets[0][0] because it can be an inverse term
-			whitePrefixLen := 0
-			for idx, r := range item.text {
-				whitePrefixLen = idx
-				if idx == minBegin || r != ' ' && r != '\t' {
-					break
-				}
-			}
-			val = int32(minBegin - whitePrefixLen)
-		case byEnd:
-			if prevEnd > 0 {
-				val = int32(1 + len(item.text) - prevEnd)
-			} else {
-				// Empty offsets due to inverse terms.
-				val = 1
-			}
-		}
-		rank[idx] = val
-	}
-	if cache {
-		item.rank = rank
-	}
-	return rank
 }
 
 // AsString returns the original string
 func (item *Item) AsString(stripAnsi bool) string {
-	return *item.StringPtr(stripAnsi)
-}
-
-// StringPtr returns the pointer to the original string
-func (item *Item) StringPtr(stripAnsi bool) *string {
 	if item.origText != nil {
 		if stripAnsi {
 			trimmed, _, _ := extractColor(string(*item.origText), nil, nil)
-			return &trimmed
+			return trimmed
 		}
-		orig := string(*item.origText)
+		return string(*item.origText)
-		return &orig
 	}
-	str := string(item.text)
+	return item.text.ToString()
-	return &str
-}
-
-func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset {
-	if len(item.colors) == 0 {
-		var offsets []colorOffset
-		for _, off := range item.offsets {
-
-			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: color, bold: bold})
-		}
-		return offsets
-	}
-
-	// Find max column
-	var maxCol int32
-	for _, off := range item.offsets {
-		if off[1] > maxCol {
-			maxCol = off[1]
-		}
-	}
-	for _, ansi := range item.colors {
-		if ansi.offset[1] > maxCol {
-			maxCol = ansi.offset[1]
-		}
-	}
-	cols := make([]int, maxCol)
-
-	for colorIndex, ansi := range item.colors {
-		for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
-			cols[i] = colorIndex + 1 // XXX
-		}
-	}
-
-	for _, off := range item.offsets {
-		for i := off[0]; i < off[1]; i++ {
-			cols[i] = -1
-		}
-	}
-
-	// sort.Sort(ByOrder(offsets))
-
-	// Merge offsets
-	// ------------  ----  --  ----
-	//   ++++++++      ++++++++++
-	// --++++++++--  --++++++++++---
-	curr := 0
-	start := 0
-	var offsets []colorOffset
-	add := func(idx int) {
-		if curr != 0 && idx > start {
-			if curr == -1 {
-				offsets = append(offsets, colorOffset{
-					offset: [2]int32{int32(start), int32(idx)}, color: color, bold: bold})
-			} else {
-				ansi := item.colors[curr-1]
-				fg := ansi.color.fg
-				if fg == -1 {
-					if current {
-						fg = curses.CurrentFG
-					} else {
-						fg = curses.FG
-					}
-				}
-				bg := ansi.color.bg
-				if bg == -1 {
-					if current {
-						bg = curses.DarkBG
-					} else {
-						bg = curses.BG
-					}
-				}
-				offsets = append(offsets, colorOffset{
-					offset: [2]int32{int32(start), int32(idx)},
-					color:  curses.PairFor(fg, bg),
-					bold:   ansi.color.bold || bold})
-			}
-		}
-	}
-	for idx, col := range cols {
-		if col != curr {
-			add(idx)
-			start = idx
-			curr = col
-		}
-	}
-	add(int(maxCol))
-	return offsets
-}
-
-// ByOrder is for sorting substring offsets
-type ByOrder []Offset
-
-func (a ByOrder) Len() int {
-	return len(a)
-}
-
-func (a ByOrder) Swap(i, j int) {
-	a[i], a[j] = a[j], a[i]
-}
-
-func (a ByOrder) Less(i, j int) bool {
-	ioff := a[i]
-	joff := a[j]
-	return (ioff[0] < joff[0]) || (ioff[0] == joff[0]) && (ioff[1] <= joff[1])
-}
-
-// ByRelevance is for sorting Items
-type ByRelevance []*Item
-
-func (a ByRelevance) Len() int {
-	return len(a)
-}
-
-func (a ByRelevance) Swap(i, j int) {
-	a[i], a[j] = a[j], a[i]
-}
-
-func (a ByRelevance) Less(i, j int) bool {
-	irank := a[i].Rank(true)
-	jrank := a[j].Rank(true)
-
-	return compareRanks(irank, jrank, false)
-}
-
-// ByRelevanceTac is for sorting Items
-type ByRelevanceTac []*Item
-
-func (a ByRelevanceTac) Len() int {
-	return len(a)
-}
-
-func (a ByRelevanceTac) Swap(i, j int) {
-	a[i], a[j] = a[j], a[i]
-}
-
-func (a ByRelevanceTac) Less(i, j int) bool {
-	irank := a[i].Rank(true)
-	jrank := a[j].Rank(true)
-
-	return compareRanks(irank, jrank, true)
-}
-
-func compareRanks(irank [5]int32, jrank [5]int32, tac bool) bool {
-	for idx := 0; idx < 4; idx++ {
-		left := irank[idx]
-		right := jrank[idx]
-		if left < right {
-			return true
-		} else if left > right {
-			return false
-		}
-	}
-	return (irank[4] <= jrank[4]) != tac
 }

src/item_test.go

@@ -1,108 +1,23 @@
 package fzf
 
 import (
-	"math"
-	"sort"
 	"testing"
 
-	"github.com/junegunn/fzf/src/curses"
+	"github.com/junegunn/fzf/src/util"
 )
 
-func TestOffsetSort(t *testing.T) {
+func TestStringPtr(t *testing.T) {
-	offsets := []Offset{
+	orig := []byte("\x1b[34mfoo")
-		Offset{3, 5}, Offset{2, 7},
+	text := []byte("\x1b[34mbar")
-		Offset{1, 3}, Offset{2, 9}}
+	item := Item{origText: &orig, text: util.ToChars(text)}
-	sort.Sort(ByOrder(offsets))
+	if item.AsString(true) != "foo" || item.AsString(false) != string(orig) {
-
+		t.Fail()
-	if offsets[0][0] != 1 || offsets[0][1] != 3 ||
+	}
-		offsets[1][0] != 2 || offsets[1][1] != 7 ||
+	if item.AsString(true) != "foo" {
-		offsets[2][0] != 2 || offsets[2][1] != 9 ||
+		t.Fail()
-		offsets[3][0] != 3 || offsets[3][1] != 5 {
+	}
-		t.Error("Invalid order:", offsets)
+	item.origText = nil
+	if item.AsString(true) != string(text) || item.AsString(false) != string(text) {
+		t.Fail()
 	}
 }
-
-func TestRankComparison(t *testing.T) {
-	if compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{2, 0, 0, 0, 7}, false) ||
-		!compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{3, 0, 0, 0, 6}, false) ||
-		!compareRanks([5]int32{1, 2, 0, 0, 3}, [5]int32{1, 3, 0, 0, 2}, false) ||
-		!compareRanks([5]int32{0, 0, 0, 0, 0}, [5]int32{0, 0, 0, 0, 0}, false) {
-		t.Error("Invalid order")
-	}
-
-	if compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{2, 0, 0, 0, 7}, true) ||
-		!compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{3, 0, 0, 0, 6}, false) ||
-		!compareRanks([5]int32{1, 2, 0, 0, 3}, [5]int32{1, 3, 0, 0, 2}, true) ||
-		!compareRanks([5]int32{0, 0, 0, 0, 0}, [5]int32{0, 0, 0, 0, 0}, false) {
-		t.Error("Invalid order (tac)")
-	}
-}
-
-// Match length, string length, index
-func TestItemRank(t *testing.T) {
-	// FIXME global
-	sortCriteria = []criterion{byMatchLen, byLength}
-
-	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
-	item1 := Item{text: strs[0], offsets: []Offset{}, rank: [5]int32{0, 0, 0, 0, 1}}
-	rank1 := item1.Rank(true)
-	if rank1[0] != math.MaxInt32 || rank1[1] != 3 || rank1[4] != 1 {
-		t.Error(item1.Rank(true))
-	}
-	// Only differ in index
-	item2 := Item{text: strs[0], offsets: []Offset{}}
-
-	items := []*Item{&item1, &item2}
-	sort.Sort(ByRelevance(items))
-	if items[0] != &item2 || items[1] != &item1 {
-		t.Error(items)
-	}
-
-	items = []*Item{&item2, &item1, &item1, &item2}
-	sort.Sort(ByRelevance(items))
-	if items[0] != &item2 || items[1] != &item2 ||
-		items[2] != &item1 || items[3] != &item1 {
-		t.Error(items)
-	}
-
-	// Sort by relevance
-	item3 := Item{text: strs[1], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
-	item4 := Item{text: strs[1], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
-	item5 := Item{text: strs[2], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
-	item6 := Item{text: strs[2], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
-	items = []*Item{&item1, &item2, &item3, &item4, &item5, &item6}
-	sort.Sort(ByRelevance(items))
-	if items[0] != &item6 || items[1] != &item4 ||
-		items[2] != &item5 || items[3] != &item3 ||
-		items[4] != &item2 || items[5] != &item1 {
-		t.Error(items)
-	}
-}
-
-func TestColorOffset(t *testing.T) {
-	// ------------ 20 ----  --  ----
-	//   ++++++++        ++++++++++
-	// --++++++++--    --++++++++++---
-	item := Item{
-		offsets: []Offset{Offset{5, 15}, Offset{25, 35}},
-		colors: []ansiOffset{
-			ansiOffset{[2]int32{0, 20}, ansiState{1, 5, false}},
-			ansiOffset{[2]int32{22, 27}, ansiState{2, 6, true}},
-			ansiOffset{[2]int32{30, 32}, ansiState{3, 7, false}},
-			ansiOffset{[2]int32{33, 40}, ansiState{4, 8, true}}}}
-	// [{[0 5] 9 false} {[5 15] 99 false} {[15 20] 9 false} {[22 25] 10 true} {[25 35] 99 false} {[35 40] 11 true}]
-
-	offsets := item.colorOffsets(99, false, true)
-	assert := func(idx int, b int32, e int32, c int, bold bool) {
-		o := offsets[idx]
-		if o.offset[0] != b || o.offset[1] != e || o.color != c || o.bold != bold {
-			t.Error(o)
-		}
-	}
-	assert(0, 0, 5, curses.ColUser, false)
-	assert(1, 5, 15, 99, false)
-	assert(2, 15, 20, curses.ColUser, false)
-	assert(3, 22, 25, curses.ColUser+1, true)
-	assert(4, 25, 35, 99, false)
-	assert(5, 35, 40, curses.ColUser+2, true)
-}

src/matcher.go

@@ -12,10 +12,11 @@ import (
 
 // MatchRequest represents a search request
 type MatchRequest struct {
-	chunks  []*Chunk
+	chunks     []*Chunk
-	pattern *Pattern
+	pattern    *Pattern
-	final   bool
+	final      bool
-	sort    bool
+	sort       bool
+	clearCache bool
 }
 
 // Matcher is responsible for performing search
@@ -26,6 +27,7 @@ type Matcher struct {
 	eventBox       *util.EventBox
 	reqBox         *util.EventBox
 	partitions     int
+	slab           []*util.Slab
 	mergerCache    map[string]*Merger
 }
 
@@ -37,13 +39,15 @@ const (
 // NewMatcher returns a new Matcher
 func NewMatcher(patternBuilder func([]rune) *Pattern,
 	sort bool, tac bool, eventBox *util.EventBox) *Matcher {
+	partitions := util.Min(numPartitionsMultiplier*runtime.NumCPU(), maxPartitions)
 	return &Matcher{
 		patternBuilder: patternBuilder,
 		sort:           sort,
 		tac:            tac,
 		eventBox:       eventBox,
 		reqBox:         util.NewEventBox(),
-		partitions:     runtime.NumCPU(),
+		partitions:     partitions,
+		slab:           make([]*util.Slab, partitions),
 		mergerCache:    make(map[string]*Merger)}
 }
 
@@ -66,7 +70,7 @@ func (m *Matcher) Loop() {
 			events.Clear()
 		})
 
-		if request.sort != m.sort {
+		if request.sort != m.sort || request.clearCache {
 			m.sort = request.sort
 			m.mergerCache = make(map[string]*Merger)
 			clearChunkCache()
@@ -106,18 +110,19 @@ func (m *Matcher) Loop() {
 }
 
 func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {
-	perSlice := len(chunks) / m.partitions
+	partitions := m.partitions
+	perSlice := len(chunks) / partitions
 
-	// No need to parallelize
 	if perSlice == 0 {
-		return [][]*Chunk{chunks}
+		partitions = len(chunks)
+		perSlice = 1
 	}
 
-	slices := make([][]*Chunk, m.partitions)
+	slices := make([][]*Chunk, partitions)
-	for i := 0; i < m.partitions; i++ {
+	for i := 0; i < partitions; i++ {
 		start := i * perSlice
 		end := start + perSlice
-		if i == m.partitions-1 {
+		if i == partitions-1 {
 			end = len(chunks)
 		}
 		slices[i] = chunks[start:end]
@@ -127,7 +132,7 @@ func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {
 
 type partialResult struct {
 	index   int
-	matches []*Item
+	matches []Result
 }
 
 func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
@@ -152,17 +157,26 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 
 	for idx, chunks := range slices {
 		waitGroup.Add(1)
-		go func(idx int, chunks []*Chunk) {
+		if m.slab[idx] == nil {
+			m.slab[idx] = util.MakeSlab(slab16Size, slab32Size)
+		}
+		go func(idx int, slab *util.Slab, chunks []*Chunk) {
 			defer func() { waitGroup.Done() }()
-			sliceMatches := []*Item{}
+			count := 0
-			for _, chunk := range chunks {
+			allMatches := make([][]Result, len(chunks))
-				matches := request.pattern.Match(chunk)
+			for idx, chunk := range chunks {
-				sliceMatches = append(sliceMatches, matches...)
+				matches := request.pattern.Match(chunk, slab)
+				allMatches[idx] = matches
+				count += len(matches)
 				if cancelled.Get() {
 					return
 				}
 				countChan <- len(matches)
 			}
+			sliceMatches := make([]Result, 0, count)
+			for _, matches := range allMatches {
+				sliceMatches = append(sliceMatches, matches...)
+			}
 			if m.sort {
 				if m.tac {
 					sort.Sort(ByRelevanceTac(sliceMatches))
@@ -171,7 +185,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 				}
 			}
 			resultChan <- partialResult{idx, sliceMatches}
-		}(idx, chunks)
+		}(idx, m.slab[idx], chunks)
 	}
 
 	wait := func() bool {
@@ -194,21 +208,21 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 			return nil, wait()
 		}
 
-		if time.Now().Sub(startedAt) > progressMinDuration {
+		if time.Since(startedAt) > progressMinDuration {
 			m.eventBox.Set(EvtSearchProgress, float32(count)/float32(numChunks))
 		}
 	}
 
-	partialResults := make([][]*Item, numSlices)
+	partialResults := make([][]Result, numSlices)
-	for _, _ = range slices {
+	for range slices {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}
-	return NewMerger(partialResults, m.sort, m.tac), false
+	return NewMerger(pattern, partialResults, m.sort, m.tac), false
 }
 
 // Reset is called to interrupt/signal the ongoing search
-func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool) {
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool, clearCache bool) {
 	pattern := m.patternBuilder(patternRunes)
 
 	var event util.EventType
@@ -217,5 +231,5 @@ func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final
 	} else {
 		event = reqRetry
 	}
-	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort})
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, clearCache})
 }

src/merger.go

@@ -2,14 +2,15 @@ package fzf
 
 import "fmt"
 
-// Merger with no data
+// EmptyMerger is a Merger with no data
-var EmptyMerger = NewMerger([][]*Item{}, 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 {
-	lists   [][]*Item
+	pattern *Pattern
-	merged  []*Item
+	lists   [][]Result
+	merged  []Result
 	chunks  *[]*Chunk
 	cursors []int
 	sorted  bool
@@ -22,21 +23,23 @@ type Merger struct {
 // original order
 func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
 	mg := Merger{
-		chunks: chunks,
+		pattern: nil,
-		tac:    tac,
+		chunks:  chunks,
-		count:  0}
+		tac:     tac,
+		count:   0}
 
 	for _, chunk := range *mg.chunks {
-		mg.count += len(*chunk)
+		mg.count += chunk.count
 	}
 	return &mg
 }
 
 // NewMerger returns a new Merger
-func NewMerger(lists [][]*Item, sorted bool, tac bool) *Merger {
+func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool) *Merger {
 	mg := Merger{
+		pattern: pattern,
 		lists:   lists,
-		merged:  []*Item{},
+		merged:  []Result{},
 		chunks:  nil,
 		cursors: make([]int, len(lists)),
 		sorted:  sorted,
@@ -55,14 +58,14 @@ func (mg *Merger) Length() int {
 	return mg.count
 }
 
-// Get returns the pointer to the Item object indexed by the given integer
+// Get returns the pointer to the Result object indexed by the given integer
-func (mg *Merger) Get(idx int) *Item {
+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 (*chunk)[idx%chunkSize]
+		return Result{item: &chunk.items[idx%chunkSize]}
 	}
 
 	if mg.sorted {
@@ -86,9 +89,9 @@ func (mg *Merger) cacheable() bool {
 	return mg.count < mergerCacheMax
 }
 
-func (mg *Merger) mergedGet(idx int) *Item {
+func (mg *Merger) mergedGet(idx int) Result {
 	for i := len(mg.merged); i <= idx; i++ {
-		minRank := buildEmptyRank(0)
+		minRank := minRank()
 		minIdx := -1
 		for listIdx, list := range mg.lists {
 			cursor := mg.cursors[listIdx]
@@ -97,13 +100,12 @@ func (mg *Merger) mergedGet(idx int) *Item {
 				continue
 			}
 			if cursor >= 0 {
-				rank := list[cursor].Rank(false)
+				rank := list[cursor]
 				if minIdx < 0 || compareRanks(rank, minRank, mg.tac) {
 					minRank = rank
 					minIdx = listIdx
 				}
 			}
-			mg.cursors[listIdx] = cursor
 		}
 
 		if minIdx >= 0 {

src/merger_test.go

@@ -5,6 +5,8 @@ import (
 	"math/rand"
 	"sort"
 	"testing"
+
+	"github.com/junegunn/fzf/src/util"
 )
 
 func assert(t *testing.T, cond bool, msg ...string) {
@@ -13,18 +15,11 @@ func assert(t *testing.T, cond bool, msg ...string) {
 	}
 }
 
-func randItem() *Item {
+func randResult() Result {
 	str := fmt.Sprintf("%d", rand.Uint32())
-	offsets := make([]Offset, rand.Int()%3)
+	chars := util.ToChars([]byte(str))
-	for idx := range offsets {
+	chars.Index = rand.Int31()
-		sidx := int32(rand.Uint32() % 20)
+	return Result{item: &Item{text: chars}}
-		eidx := sidx + int32(rand.Uint32()%20)
-		offsets[idx] = Offset{sidx, eidx}
-	}
-	return &Item{
-		text:    []rune(str),
-		rank:    buildEmptyRank(rand.Int31()),
-		offsets: offsets}
 }
 
 func TestEmptyMerger(t *testing.T) {
@@ -34,23 +29,23 @@ func TestEmptyMerger(t *testing.T) {
 	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
 }
 
-func buildLists(partiallySorted bool) ([][]*Item, []*Item) {
+func buildLists(partiallySorted bool) ([][]Result, []Result) {
 	numLists := 4
-	lists := make([][]*Item, numLists)
+	lists := make([][]Result, numLists)
 	cnt := 0
 	for i := 0; i < numLists; i++ {
-		numItems := rand.Int() % 20
+		numResults := rand.Int() % 20
-		cnt += numItems
+		cnt += numResults
-		lists[i] = make([]*Item, numItems)
+		lists[i] = make([]Result, numResults)
-		for j := 0; j < numItems; j++ {
+		for j := 0; j < numResults; j++ {
-			item := randItem()
+			item := randResult()
 			lists[i][j] = item
 		}
 		if partiallySorted {
 			sort.Sort(ByRelevance(lists[i]))
 		}
 	}
-	items := []*Item{}
+	items := []Result{}
 	for _, list := range lists {
 		items = append(items, list...)
 	}
@@ -62,7 +57,7 @@ func TestMergerUnsorted(t *testing.T) {
 	cnt := len(items)
 
 	// Not sorted: same order
-	mg := NewMerger(lists, false, false)
+	mg := NewMerger(nil, lists, false, false)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	for i := 0; i < cnt; i++ {
 		assert(t, items[i] == mg.Get(i), "Invalid Get")
@@ -74,7 +69,7 @@ func TestMergerSorted(t *testing.T) {
 	cnt := len(items)
 
 	// Sorted sorted order
-	mg := NewMerger(lists, true, false)
+	mg := NewMerger(nil, lists, true, false)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	sort.Sort(ByRelevance(items))
 	for i := 0; i < cnt; i++ {
@@ -84,7 +79,7 @@ func TestMergerSorted(t *testing.T) {
 	}
 
 	// Inverse order
-	mg2 := NewMerger(lists, true, false)
+	mg2 := NewMerger(nil, lists, true, false)
 	for i := cnt - 1; i >= 0; i-- {
 		if items[i] != mg2.Get(i) {
 			t.Error("Not sorted", items[i], mg2.Get(i))

src/options_test.go

@@ -2,9 +2,10 @@ package fzf
 
 import (
 	"fmt"
+	"io/ioutil"
 	"testing"
 
-	"github.com/junegunn/fzf/src/curses"
+	"github.com/junegunn/fzf/src/tui"
 )
 
 func TestDelimiterRegex(t *testing.T) {
@@ -42,24 +43,24 @@ func TestDelimiterRegex(t *testing.T) {
 
 func TestDelimiterRegexString(t *testing.T) {
 	delim := delimiterRegexp("*")
-	tokens := Tokenize([]rune("-*--*---**---"), delim)
+	tokens := Tokenize("-*--*---**---", delim)
 	if delim.regex != nil ||
-		string(tokens[0].text) != "-*" ||
+		tokens[0].text.ToString() != "-*" ||
-		string(tokens[1].text) != "--*" ||
+		tokens[1].text.ToString() != "--*" ||
-		string(tokens[2].text) != "---*" ||
+		tokens[2].text.ToString() != "---*" ||
-		string(tokens[3].text) != "*" ||
+		tokens[3].text.ToString() != "*" ||
-		string(tokens[4].text) != "---" {
+		tokens[4].text.ToString() != "---" {
-		t.Errorf("%s %s %d", delim, tokens, len(tokens))
+		t.Errorf("%s %v %d", delim, tokens, len(tokens))
 	}
 }
 
 func TestDelimiterRegexRegex(t *testing.T) {
 	delim := delimiterRegexp("--\\*")
-	tokens := Tokenize([]rune("-*--*---**---"), delim)
+	tokens := Tokenize("-*--*---**---", delim)
 	if delim.str != nil ||
-		string(tokens[0].text) != "-*--*" ||
+		tokens[0].text.ToString() != "-*--*" ||
-		string(tokens[1].text) != "---*" ||
+		tokens[1].text.ToString() != "---*" ||
-		string(tokens[2].text) != "*---" {
+		tokens[2].text.ToString() != "*---" {
 		t.Errorf("%s %d", tokens, len(tokens))
 	}
 }
@@ -70,7 +71,7 @@ func TestSplitNth(t *testing.T) {
 		if len(ranges) != 1 ||
 			ranges[0].begin != rangeEllipsis ||
 			ranges[0].end != rangeEllipsis {
-			t.Errorf("%s", ranges)
+			t.Errorf("%v", ranges)
 		}
 	}
 	{
@@ -86,7 +87,7 @@ func TestSplitNth(t *testing.T) {
 			ranges[7].begin != -2 || ranges[7].end != -2 ||
 			ranges[8].begin != 2 || ranges[8].end != -2 ||
 			ranges[9].begin != rangeEllipsis || ranges[9].end != rangeEllipsis {
-			t.Errorf("%s", ranges)
+			t.Errorf("%v", ranges)
 		}
 	}
 }
@@ -98,16 +99,16 @@ func TestIrrelevantNth(t *testing.T) {
 		parseOptions(opts, words)
 		postProcessOptions(opts)
 		if len(opts.Nth) != 0 {
-			t.Errorf("nth should be empty: %s", opts.Nth)
+			t.Errorf("nth should be empty: %v", opts.Nth)
 		}
 	}
-	for _, words := range [][]string{[]string{"--nth", "..,3", "+x"}, []string{"--nth", "3,1..", "+x"}, []string{"--nth", "..-1,1", "+x"}} {
+	for _, words := range [][]string{{"--nth", "..,3", "+x"}, {"--nth", "3,1..", "+x"}, {"--nth", "..-1,1", "+x"}} {
 		{
 			opts := defaultOptions()
 			parseOptions(opts, words)
 			postProcessOptions(opts)
 			if len(opts.Nth) != 0 {
-				t.Errorf("nth should be empty: %s", opts.Nth)
+				t.Errorf("nth should be empty: %v", opts.Nth)
 			}
 		}
 		{
@@ -116,64 +117,68 @@ func TestIrrelevantNth(t *testing.T) {
 			parseOptions(opts, words)
 			postProcessOptions(opts)
 			if len(opts.Nth) != 2 {
-				t.Errorf("nth should not be empty: %s", opts.Nth)
+				t.Errorf("nth should not be empty: %v", opts.Nth)
 			}
 		}
 	}
 }
 
 func TestParseKeys(t *testing.T) {
-	pairs := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g,ALT-enter,alt-SPACE", "")
+	pairs := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g,ctrl-alt-a,ALT-enter,alt-SPACE", "")
-	check := func(i int, s string) {
+	checkEvent := func(e tui.Event, s string) {
-		if pairs[i] != s {
+		if pairs[e] != s {
-			t.Errorf("%s != %s", pairs[i], s)
+			t.Errorf("%s != %s", pairs[e], s)
 		}
 	}
-	if len(pairs) != 11 {
+	check := func(et tui.EventType, s string) {
-		t.Error(11)
+		checkEvent(et.AsEvent(), s)
 	}
-	check(curses.CtrlZ, "ctrl-z")
+	if len(pairs) != 12 {
-	check(curses.AltZ, "alt-z")
+		t.Error(12)
-	check(curses.F2, "f2")
+	}
-	check(curses.AltZ+'@', "@")
+	check(tui.CtrlZ, "ctrl-z")
-	check(curses.AltA, "Alt-a")
+	check(tui.F2, "f2")
-	check(curses.AltZ+'!', "!")
+	check(tui.CtrlG, "ctrl-G")
-	check(curses.CtrlA+'g'-'a', "ctrl-G")
+	checkEvent(tui.AltKey('z'), "alt-z")
-	check(curses.AltZ+'J', "J")
+	checkEvent(tui.Key('@'), "@")
-	check(curses.AltZ+'g', "g")
+	checkEvent(tui.AltKey('a'), "Alt-a")
-	check(curses.AltEnter, "ALT-enter")
+	checkEvent(tui.Key('!'), "!")
-	check(curses.AltSpace, "alt-SPACE")
+	checkEvent(tui.Key('J'), "J")
+	checkEvent(tui.Key('g'), "g")
+	checkEvent(tui.CtrlAltKey('a'), "ctrl-alt-a")
+	checkEvent(tui.CtrlAltKey('m'), "ALT-enter")
+	checkEvent(tui.AltKey(' '), "alt-SPACE")
 
 	// Synonyms
 	pairs = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
 	if len(pairs) != 9 {
 		t.Error(9)
 	}
-	check(curses.CtrlM, "Return")
+	check(tui.CtrlM, "Return")
-	check(curses.AltZ+' ', "space")
+	checkEvent(tui.Key(' '), "space")
-	check(curses.Tab, "tab")
+	check(tui.Tab, "tab")
-	check(curses.BTab, "btab")
+	check(tui.BTab, "btab")
-	check(curses.ESC, "esc")
+	check(tui.ESC, "esc")
-	check(curses.Up, "up")
+	check(tui.Up, "up")
-	check(curses.Down, "down")
+	check(tui.Down, "down")
-	check(curses.Left, "left")
+	check(tui.Left, "left")
-	check(curses.Right, "right")
+	check(tui.Right, "right")
 
 	pairs = parseKeyChords("Tab,Ctrl-I,PgUp,page-up,pgdn,Page-Down,Home,End,Alt-BS,Alt-BSpace,shift-left,shift-right,btab,shift-tab,return,Enter,bspace", "")
 	if len(pairs) != 11 {
 		t.Error(11)
 	}
-	check(curses.Tab, "Ctrl-I")
+	check(tui.Tab, "Ctrl-I")
-	check(curses.PgUp, "page-up")
+	check(tui.PgUp, "page-up")
-	check(curses.PgDn, "Page-Down")
+	check(tui.PgDn, "Page-Down")
-	check(curses.Home, "Home")
+	check(tui.Home, "Home")
-	check(curses.End, "End")
+	check(tui.End, "End")
-	check(curses.AltBS, "Alt-BSpace")
+	check(tui.AltBS, "Alt-BSpace")
-	check(curses.SLeft, "shift-left")
+	check(tui.SLeft, "shift-left")
-	check(curses.SRight, "shift-right")
+	check(tui.SRight, "shift-right")
-	check(curses.BTab, "shift-tab")
+	check(tui.BTab, "shift-tab")
-	check(curses.CtrlM, "Enter")
+	check(tui.CtrlM, "Enter")
-	check(curses.BSpace, "bspace")
+	check(tui.BSpace, "bspace")
 }
 
 func TestParseKeysWithComma(t *testing.T) {
@@ -182,94 +187,102 @@ func TestParseKeysWithComma(t *testing.T) {
 			t.Errorf("%d != %d", a, b)
 		}
 	}
-	check := func(pairs map[int]string, i int, s string) {
+	check := func(pairs map[tui.Event]string, e tui.Event, s string) {
-		if pairs[i] != s {
+		if pairs[e] != s {
-			t.Errorf("%s != %s", pairs[i], s)
+			t.Errorf("%s != %s", pairs[e], s)
 		}
 	}
 
 	pairs := parseKeyChords(",", "")
 	checkN(len(pairs), 1)
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.Key(','), ",")
 
 	pairs = parseKeyChords(",,a,b", "")
 	checkN(len(pairs), 3)
-	check(pairs, curses.AltZ+'a', "a")
+	check(pairs, tui.Key('a'), "a")
-	check(pairs, curses.AltZ+'b', "b")
+	check(pairs, tui.Key('b'), "b")
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.Key(','), ",")
 
 	pairs = parseKeyChords("a,b,,", "")
 	checkN(len(pairs), 3)
-	check(pairs, curses.AltZ+'a', "a")
+	check(pairs, tui.Key('a'), "a")
-	check(pairs, curses.AltZ+'b', "b")
+	check(pairs, tui.Key('b'), "b")
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.Key(','), ",")
 
 	pairs = parseKeyChords("a,,,b", "")
 	checkN(len(pairs), 3)
-	check(pairs, curses.AltZ+'a', "a")
+	check(pairs, tui.Key('a'), "a")
-	check(pairs, curses.AltZ+'b', "b")
+	check(pairs, tui.Key('b'), "b")
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.Key(','), ",")
 
 	pairs = parseKeyChords("a,,,b,c", "")
 	checkN(len(pairs), 4)
-	check(pairs, curses.AltZ+'a', "a")
+	check(pairs, tui.Key('a'), "a")
-	check(pairs, curses.AltZ+'b', "b")
+	check(pairs, tui.Key('b'), "b")
-	check(pairs, curses.AltZ+'c', "c")
+	check(pairs, tui.Key('c'), "c")
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.Key(','), ",")
 
 	pairs = parseKeyChords(",,,", "")
 	checkN(len(pairs), 1)
-	check(pairs, curses.AltZ+',', ",")
+	check(pairs, tui.Key(','), ",")
+
+	pairs = parseKeyChords(",ALT-,,", "")
+	checkN(len(pairs), 1)
+	check(pairs, tui.AltKey(','), "ALT-,")
 }
 
 func TestBind(t *testing.T) {
-	check := func(action actionType, expected actionType) {
-		if action != expected {
-			t.Errorf("%d != %d", action, expected)
-		}
-	}
-	checkString := func(action string, expected string) {
-		if action != expected {
-			t.Errorf("%d != %d", action, expected)
-		}
-	}
 	keymap := defaultKeymap()
-	execmap := make(map[int]string)
+	check := func(event tui.Event, arg1 string, types ...actionType) {
-	check(actBeginningOfLine, keymap[curses.CtrlA])
+		if len(keymap[event]) != len(types) {
-	parseKeymap(keymap, execmap,
+			t.Errorf("invalid number of actions for %v (%d != %d)",
-		"ctrl-a:kill-line,ctrl-b:toggle-sort,c:page-up,alt-z:page-down,"+
+				event, len(types), len(keymap[event]))
-			"f1:execute(ls {}),f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
+			return
-			"alt-a:execute@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};"+
+		}
-			",,:abort,::accept,X:execute:\nfoobar,Y:execute(baz)")
+		for idx, action := range keymap[event] {
-	check(actKillLine, keymap[curses.CtrlA])
+			if types[idx] != action.t {
-	check(actToggleSort, keymap[curses.CtrlB])
+				t.Errorf("invalid action type (%d != %d)", types[idx], action.t)
-	check(actPageUp, keymap[curses.AltZ+'c'])
+			}
-	check(actAbort, keymap[curses.AltZ+','])
+		}
-	check(actAccept, keymap[curses.AltZ+':'])
+		if len(arg1) > 0 && keymap[event][0].a != arg1 {
-	check(actPageDown, keymap[curses.AltZ])
+			t.Errorf("invalid action argument: (%s != %s)", arg1, keymap[event][0].a)
-	check(actExecute, keymap[curses.F1])
+		}
-	check(actExecute, keymap[curses.F2])
+	}
-	check(actExecute, keymap[curses.F3])
+	check(tui.CtrlA.AsEvent(), "", actBeginningOfLine)
-	check(actExecute, keymap[curses.F4])
+	parseKeymap(keymap,
-	checkString("ls {}", execmap[curses.F1])
+		"ctrl-a:kill-line,ctrl-b:toggle-sort+up+down,c:page-up,alt-z:page-down,"+
-	checkString("echo {}, {}, {}", execmap[curses.F2])
+			"f1:execute(ls {+})+abort+execute(echo {+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
-	checkString("echo '({})'", execmap[curses.F3])
+			"alt-a:execute-Multi@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};,"+
-	checkString("less {}", execmap[curses.F4])
+			"x:Execute(foo+bar),X:execute/bar+baz/"+
-	checkString("echo (,),[,],/,:,;,%,{}", execmap[curses.AltA])
+			",f1:+first,f1:+top"+
-	checkString("echo (,),[,],/,:,@,%,{}", execmap[curses.AltB])
+			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up")
-	checkString("\nfoobar,Y:execute(baz)", execmap[curses.AltZ+'X'])
+	check(tui.CtrlA.AsEvent(), "", actKillLine)
+	check(tui.CtrlB.AsEvent(), "", actToggleSort, actUp, actDown)
+	check(tui.Key('c'), "", actPageUp)
+	check(tui.Key(','), "", actAbort)
+	check(tui.Key(':'), "", actAccept)
+	check(tui.AltKey('z'), "", actPageDown)
+	check(tui.F1.AsEvent(), "ls {+}", actExecute, actAbort, actExecute, actSelectAll, actFirst, actFirst)
+	check(tui.F2.AsEvent(), "echo {}, {}, {}", actExecute)
+	check(tui.F3.AsEvent(), "echo '({})'", actExecute)
+	check(tui.F4.AsEvent(), "less {}", actExecute)
+	check(tui.Key('x'), "foo+bar", actExecute)
+	check(tui.Key('X'), "bar+baz", actExecute)
+	check(tui.AltKey('a'), "echo (,),[,],/,:,;,%,{}", actExecuteMulti)
+	check(tui.AltKey('b'), "echo (,),[,],/,:,@,%,{}", actExecute)
+	check(tui.Key('+'), "++\nfoobar,Y:execute(baz)+up", actExecute)
 
 	for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} {
-		parseKeymap(keymap, execmap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
+		parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
-		checkString("foobar", execmap[curses.AltZ+int([]rune(fmt.Sprintf("%d", idx%10))[0])])
+		check(tui.Key([]rune(fmt.Sprintf("%d", idx%10))[0]), "foobar", actExecute)
 	}
 
-	parseKeymap(keymap, execmap, "f1:abort")
+	parseKeymap(keymap, "f1:abort")
-	check(actAbort, keymap[curses.F1])
+	check(tui.F1.AsEvent(), "", actAbort)
 }
 
 func TestColorSpec(t *testing.T) {
-	theme := curses.Dark256
+	theme := tui.Dark256
 	dark := parseTheme(theme, "dark")
 	if *dark != *theme {
 		t.Errorf("colors should be equivalent")
@@ -282,7 +295,7 @@ func TestColorSpec(t *testing.T) {
 	if *light == *theme {
 		t.Errorf("should not be equivalent")
 	}
-	if *light != *curses.Light256 {
+	if *light != *tui.Light256 {
 		t.Errorf("colors should be equivalent")
 	}
 	if light == theme {
@@ -290,76 +303,61 @@ func TestColorSpec(t *testing.T) {
 	}
 
 	customized := parseTheme(theme, "fg:231,bg:232")
-	if customized.Fg != 231 || customized.Bg != 232 {
+	if customized.Fg.Color != 231 || customized.Bg.Color != 232 {
 		t.Errorf("color not customized")
 	}
-	if *curses.Dark256 == *customized {
+	if *tui.Dark256 == *customized {
 		t.Errorf("colors should not be equivalent")
 	}
-	customized.Fg = curses.Dark256.Fg
+	customized.Fg = tui.Dark256.Fg
-	customized.Bg = curses.Dark256.Bg
+	customized.Bg = tui.Dark256.Bg
-	if *curses.Dark256 == *customized {
+	if *tui.Dark256 != *customized {
-		t.Errorf("colors should now be equivalent")
+		t.Errorf("colors should now be equivalent: %v, %v", tui.Dark256, customized)
 	}
 
 	customized = parseTheme(theme, "fg:231,dark,bg:232")
-	if customized.Fg != curses.Dark256.Fg || customized.Bg == curses.Dark256.Bg {
+	if customized.Fg != tui.Dark256.Fg || customized.Bg == tui.Dark256.Bg {
 		t.Errorf("color not customized")
 	}
-	if customized.UseDefault {
-		t.Errorf("not using default colors")
-	}
-	if !curses.Dark256.UseDefault {
-		t.Errorf("using default colors")
-	}
-}
-
-func TestParseNilTheme(t *testing.T) {
-	var theme *curses.ColorTheme
-	newTheme := parseTheme(theme, "prompt:12")
-	if newTheme != nil {
-		t.Errorf("color is disabled. keep it that way.")
-	}
-	newTheme = parseTheme(theme, "prompt:12,dark,prompt:13")
-	if newTheme.Prompt != 13 {
-		t.Errorf("color should now be enabled and customized")
-	}
 }
 
 func TestDefaultCtrlNP(t *testing.T) {
-	check := func(words []string, key int, expected actionType) {
+	check := func(words []string, et tui.EventType, expected actionType) {
+		e := et.AsEvent()
 		opts := defaultOptions()
 		parseOptions(opts, words)
 		postProcessOptions(opts)
-		if opts.Keymap[key] != expected {
+		if opts.Keymap[e][0].t != expected {
 			t.Error()
 		}
 	}
-	check([]string{}, curses.CtrlN, actDown)
+	check([]string{}, tui.CtrlN, actDown)
-	check([]string{}, curses.CtrlP, actUp)
+	check([]string{}, tui.CtrlP, actUp)
 
-	check([]string{"--bind=ctrl-n:accept"}, curses.CtrlN, actAccept)
+	check([]string{"--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
-	check([]string{"--bind=ctrl-p:accept"}, curses.CtrlP, actAccept)
+	check([]string{"--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
 
-	hist := "--history=/tmp/foo"
+	f, _ := ioutil.TempFile("", "fzf-history")
-	check([]string{hist}, curses.CtrlN, actNextHistory)
+	f.Close()
-	check([]string{hist}, curses.CtrlP, actPreviousHistory)
+	hist := "--history=" + f.Name()
+	check([]string{hist}, tui.CtrlN, actNextHistory)
+	check([]string{hist}, tui.CtrlP, actPreviousHistory)
 
-	check([]string{hist, "--bind=ctrl-n:accept"}, curses.CtrlN, actAccept)
+	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
-	check([]string{hist, "--bind=ctrl-n:accept"}, curses.CtrlP, actPreviousHistory)
+	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlP, actPreviousHistory)
 
-	check([]string{hist, "--bind=ctrl-p:accept"}, curses.CtrlN, actNextHistory)
+	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlN, actNextHistory)
-	check([]string{hist, "--bind=ctrl-p:accept"}, curses.CtrlP, actAccept)
+	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
+}
+
+func optsFor(words ...string) *Options {
+	opts := defaultOptions()
+	parseOptions(opts, words)
+	postProcessOptions(opts)
+	return opts
 }
 
 func TestToggle(t *testing.T) {
-	optsFor := func(words ...string) *Options {
-		opts := defaultOptions()
-		parseOptions(opts, words)
-		postProcessOptions(opts)
-		return opts
-	}
-
 	opts := optsFor()
 	if opts.ToggleSort {
 		t.Error()
@@ -375,3 +373,85 @@ func TestToggle(t *testing.T) {
 		t.Error()
 	}
 }
+
+func TestPreviewOpts(t *testing.T) {
+	opts := optsFor()
+	if !(opts.Preview.command == "" &&
+		opts.Preview.hidden == false &&
+		opts.Preview.wrap == false &&
+		opts.Preview.position == posRight &&
+		opts.Preview.size.percent == true &&
+		opts.Preview.size.size == 50) {
+		t.Error()
+	}
+	opts = optsFor("--preview", "cat {}", "--preview-window=left:15,hidden,wrap:+{1}-/2")
+	if !(opts.Preview.command == "cat {}" &&
+		opts.Preview.hidden == true &&
+		opts.Preview.wrap == true &&
+		opts.Preview.position == posLeft &&
+		opts.Preview.scroll == "+{1}-/2" &&
+		opts.Preview.size.percent == false &&
+		opts.Preview.size.size == 15) {
+		t.Error(opts.Preview)
+	}
+	opts = optsFor("--preview-window=up,15,wrap,hidden,+{1}+3-1-2/2", "--preview-window=down", "--preview-window=cycle")
+	if !(opts.Preview.command == "" &&
+		opts.Preview.hidden == true &&
+		opts.Preview.wrap == true &&
+		opts.Preview.cycle == true &&
+		opts.Preview.position == posDown &&
+		opts.Preview.scroll == "+{1}+3-1-2/2" &&
+		opts.Preview.size.percent == false &&
+		opts.Preview.size.size == 15) {
+		t.Error(opts.Preview.size.size)
+	}
+	opts = optsFor("--preview-window=up:15:wrap:hidden")
+	if !(opts.Preview.command == "" &&
+		opts.Preview.hidden == true &&
+		opts.Preview.wrap == true &&
+		opts.Preview.position == posUp &&
+		opts.Preview.size.percent == false &&
+		opts.Preview.size.size == 15) {
+		t.Error(opts.Preview)
+	}
+	opts = optsFor("--preview=foo", "--preview-window=up", "--preview-window=default:70%")
+	if !(opts.Preview.command == "foo" &&
+		opts.Preview.position == posRight &&
+		opts.Preview.size.percent == true &&
+		opts.Preview.size.size == 70) {
+		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)
+	}
+}
+
+func TestValidateSign(t *testing.T) {
+	testCases := []struct {
+		inputSign string
+		isValid   bool
+	}{
+		{"> ", true},
+		{"아", true},
+		{"😀", true},
+		{"", false},
+		{">>>", false},
+		{"\n", false},
+		{"\t", false},
+	}
+
+	for _, testCase := range testCases {
+		err := validateSign(testCase.inputSign, "")
+		if testCase.isValid && err != nil {
+			t.Errorf("Input sign `%s` caused error", testCase.inputSign)
+		}
+
+		if !testCase.isValid && err == nil {
+			t.Errorf("Input sign `%s` did not cause error", testCase.inputSign)
+		}
+	}
+}

src/pattern.go

@@ -1,8 +1,8 @@
 package fzf
 
 import (
+	"fmt"
 	"regexp"
-	"sort"
 	"strings"
 
 	"github.com/junegunn/fzf/src/algo"
@@ -11,12 +11,12 @@ import (
 
 // fuzzy
 // 'exact
-// ^exact-prefix
+// ^prefix-exact
-// exact-suffix$
+// suffix-exact$
-// !not-fuzzy
+// !inverse-exact
-// !'not-exact
+// !'inverse-fuzzy
-// !^not-exact-prefix
+// !^inverse-prefix-exact
-// !not-exact-suffix$
+// !inverse-suffix-exact$
 
 type termType int
 
@@ -33,7 +33,12 @@ type term struct {
 	inv           bool
 	text          []rune
 	caseSensitive bool
-	origText      []rune
+	normalize     bool
+}
+
+// String returns the string representation of a term.
+func (t term) String() string {
+	return fmt.Sprintf("term{typ: %d, inv: %v, text: []rune(%q), caseSensitive: %v}", t.typ, t.inv, string(t.text), t.caseSensitive)
 }
 
 type termSet []term
@@ -41,15 +46,19 @@ type termSet []term
 // Pattern represents search pattern
 type Pattern struct {
 	fuzzy         bool
+	fuzzyAlgo     algo.Algo
 	extended      bool
 	caseSensitive bool
+	normalize     bool
 	forward       bool
 	text          []rune
 	termSets      []termSet
+	sortable      bool
 	cacheable     bool
+	cacheKey      string
 	delimiter     Delimiter
 	nth           []Range
-	procFun       map[termType]func(bool, bool, []rune, []rune) algo.Result
+	procFun       map[termType]algo.Algo
 }
 
 var (
@@ -59,7 +68,7 @@ var (
 )
 
 func init() {
-	_splitRegex = regexp.MustCompile("\\s+")
+	_splitRegex = regexp.MustCompile(" +")
 	clearPatternCache()
 	clearChunkCache()
 }
@@ -75,12 +84,15 @@ func clearChunkCache() {
 }
 
 // BuildPattern builds Pattern object from the given arguments
-func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
+func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
-	nth []Range, delimiter Delimiter, runes []rune) *Pattern {
+	cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
 
 	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)
 	}
@@ -90,24 +102,35 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 		return cached
 	}
 
-	caseSensitive, cacheable := true, true
+	caseSensitive := true
+	sortable := true
 	termSets := []termSet{}
 
 	if extended {
-		termSets = parseTerms(fuzzy, caseMode, asString)
+		termSets = parseTerms(fuzzy, caseMode, normalize, asString)
+		// We should not sort the result if there are only inverse search terms
+		sortable = false
 	Loop:
 		for _, termSet := range termSets {
 			for idx, term := range termSet {
+				if !term.inv {
+					sortable = true
+				}
 				// If the query contains inverse search terms or OR operators,
 				// we cannot cache the search scope
-				if idx > 0 || term.inv {
+				if !cacheable || idx > 0 || term.inv || fuzzy && term.typ != termFuzzy || !fuzzy && term.typ != termExact {
 					cacheable = false
-					break Loop
+					if sortable {
+						// Can't break until we see at least one non-inverse term
+						break Loop
+					}
 				}
 			}
 		}
 	} else {
 		lowerString := strings.ToLower(asString)
+		normalize = normalize &&
+			lowerString == string(algo.NormalizeRunes([]rune(lowerString)))
 		caseSensitive = caseMode == CaseRespect ||
 			caseMode == CaseSmart && lowerString != asString
 		if !caseSensitive {
@@ -117,17 +140,21 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 
 	ptr := &Pattern{
 		fuzzy:         fuzzy,
+		fuzzyAlgo:     fuzzyAlgo,
 		extended:      extended,
 		caseSensitive: caseSensitive,
+		normalize:     normalize,
 		forward:       forward,
 		text:          []rune(asString),
 		termSets:      termSets,
+		sortable:      sortable,
 		cacheable:     cacheable,
 		nth:           nth,
 		delimiter:     delimiter,
-		procFun:       make(map[termType]func(bool, bool, []rune, []rune) algo.Result)}
+		procFun:       make(map[termType]algo.Algo)}
 
-	ptr.procFun[termFuzzy] = algo.FuzzyMatch
+	ptr.cacheKey = ptr.buildCacheKey()
+	ptr.procFun[termFuzzy] = fuzzyAlgo
 	ptr.procFun[termEqual] = algo.EqualMatch
 	ptr.procFun[termExact] = algo.ExactMatchNaive
 	ptr.procFun[termPrefix] = algo.PrefixMatch
@@ -137,37 +164,48 @@ func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
 	return ptr
 }
 
-func parseTerms(fuzzy bool, caseMode Case, str string) []termSet {
+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
+		normalizeTerm := normalize &&
+			lowerText == string(algo.NormalizeRunes([]rune(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
+			typ = termExact
 			text = text[1:]
 		}
 
+		if text != "$" && strings.HasSuffix(text, "$") {
+			typ = termSuffix
+			text = text[:len(text)-1]
+		}
+
 		if strings.HasPrefix(text, "'") {
 			// Flip exactness
-			if fuzzy {
+			if fuzzy && !inv {
 				typ = termExact
 				text = text[1:]
 			} else {
@@ -175,16 +213,12 @@ func parseTerms(fuzzy bool, caseMode Case, 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, "$") {
+			text = text[1:]
-			typ = termSuffix
-			text = text[:len(text)-1]
 		}
 
 		if len(text) > 0 {
@@ -192,12 +226,16 @@ func parseTerms(fuzzy bool, caseMode Case, str string) []termSet {
 				sets = append(sets, set)
 				set = termSet{}
 			}
+			textRunes := []rune(text)
+			if normalizeTerm {
+				textRunes = algo.NormalizeRunes(textRunes)
+			}
 			set = append(set, term{
 				typ:           typ,
 				inv:           inv,
-				text:          []rune(text),
+				text:          textRunes,
 				caseSensitive: caseSensitive,
-				origText:      origText})
+				normalize:     normalizeTerm})
 			switchSet = true
 		}
 	}
@@ -220,50 +258,38 @@ 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) buildCacheKey() string {
-func (p *Pattern) CacheKey() 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) []*Item {
+func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []Result {
-	space := chunk
-
 	// 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
 		}
 	}
 
-	// ChunkCache: Prefix/suffix match
+	// Prefix/suffix cache
-Loop:
+	space := _cache.Search(chunk, cacheKey)
-	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 {
-				cachedChunk := Chunk(cached)
-				space = &cachedChunk
-				break Loop
-			}
-		}
-	}
 
-	matches := p.matchChunk(space)
+	matches := p.matchChunk(chunk, space, slab)
 
 	if p.cacheable {
 		_cache.Add(chunk, cacheKey, matches)
@@ -271,20 +297,19 @@ Loop:
 	return matches
 }
 
-func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
+func (p *Pattern) matchChunk(chunk *Chunk, space []Result, slab *util.Slab) []Result {
-	matches := []*Item{}
+	matches := []Result{}
-	if !p.extended {
+
-		for _, item := range *chunk {
+	if space == nil {
-			offset, bonus := p.basicMatch(item)
+		for idx := 0; idx < chunk.count; idx++ {
-			if sidx := offset[0]; sidx >= 0 {
+			if match, _, _ := p.MatchItem(&chunk.items[idx], false, slab); match != nil {
-				matches = append(matches,
+				matches = append(matches, *match)
-					dupItem(item, []Offset{offset}, bonus))
 			}
 		}
 	} else {
-		for _, item := range *chunk {
+		for _, result := range space {
-			if offsets, bonus := p.extendedMatch(item); len(offsets) == len(p.termSets) {
+			if match, _, _ := p.MatchItem(result.item, false, slab); match != nil {
-				matches = append(matches, dupItem(item, offsets, bonus))
+				matches = append(matches, *match)
 			}
 		}
 	}
@@ -292,91 +317,109 @@ func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
 }
 
 // MatchItem returns true if the Item is a match
-func (p *Pattern) MatchItem(item *Item) bool {
+func (p *Pattern) MatchItem(item *Item, withPos bool, slab *util.Slab) (*Result, []Offset, *[]int) {
-	if !p.extended {
+	if p.extended {
-		offset, _ := p.basicMatch(item)
+		if offsets, bonus, pos := p.extendedMatch(item, withPos, slab); len(offsets) == len(p.termSets) {
-		sidx := offset[0]
+			result := buildResult(item, offsets, bonus)
-		return sidx >= 0
+			return &result, offsets, pos
+		}
+		return nil, nil, nil
 	}
-	offsets, _ := p.extendedMatch(item)
+	offset, bonus, pos := p.basicMatch(item, withPos, slab)
-	return len(offsets) == len(p.termSets)
+	if sidx := offset[0]; sidx >= 0 {
+		offsets := []Offset{offset}
+		result := buildResult(item, offsets, bonus)
+		return &result, offsets, pos
+	}
+	return nil, nil, nil
 }
 
-func dupItem(item *Item, offsets []Offset, bonus int32) *Item {
+func (p *Pattern) basicMatch(item *Item, withPos bool, slab *util.Slab) (Offset, int, *[]int) {
-	sort.Sort(ByOrder(offsets))
+	var input []Token
-	return &Item{
+	if len(p.nth) == 0 {
-		text:        item.text,
+		input = []Token{{text: &item.text, prefixLength: 0}}
-		origText:    item.origText,
+	} else {
-		transformed: item.transformed,
+		input = p.transformInput(item)
-		offsets:     offsets,
+	}
-		bonus:       bonus,
-		colors:      item.colors,
-		rank:        buildEmptyRank(item.Index())}
-}
-
-func (p *Pattern) basicMatch(item *Item) (Offset, int32) {
-	input := p.prepareInput(item)
 	if p.fuzzy {
-		return p.iter(algo.FuzzyMatch, input, p.caseSensitive, p.forward, p.text)
+		return p.iter(p.fuzzyAlgo, input, p.caseSensitive, p.normalize, p.forward, p.text, withPos, slab)
 	}
-	return p.iter(algo.ExactMatchNaive, input, p.caseSensitive, p.forward, p.text)
+	return p.iter(algo.ExactMatchNaive, input, p.caseSensitive, p.normalize, p.forward, p.text, withPos, slab)
 }
 
-func (p *Pattern) extendedMatch(item *Item) ([]Offset, int32) {
+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{{text: &item.text, prefixLength: 0}}
+	} else {
+		input = p.transformInput(item)
+	}
 	offsets := []Offset{}
-	var totalBonus int32
+	var totalScore int
+	var allPos *[]int
+	if withPos {
+		allPos = &[]int{}
+	}
 	for _, termSet := range p.termSets {
-		var offset *Offset
+		var offset Offset
-		var bonus int32
+		var currentScore int
+		matched := false
 		for _, term := range termSet {
 			pfun := p.procFun[term.typ]
-			off, pen := p.iter(pfun, input, term.caseSensitive, p.forward, term.text)
+			off, score, pos := p.iter(pfun, input, term.caseSensitive, term.normalize, p.forward, term.text, withPos, slab)
 			if sidx := off[0]; sidx >= 0 {
 				if term.inv {
 					continue
 				}
-				offset, bonus = &off, pen
+				offset, currentScore = off, score
+				matched = true
+				if withPos {
+					if pos != nil {
+						*allPos = append(*allPos, *pos...)
+					} else {
+						for idx := off[0]; idx < off[1]; idx++ {
+							*allPos = append(*allPos, int(idx))
+						}
+					}
+				}
 				break
 			} else if term.inv {
-				offset, bonus = &Offset{0, 0, 0}, 0
+				offset, currentScore = Offset{0, 0}, 0
+				matched = true
 				continue
 			}
 		}
-		if offset != nil {
+		if matched {
-			offsets = append(offsets, *offset)
+			offsets = append(offsets, offset)
-			totalBonus += bonus
+			totalScore += currentScore
 		}
 	}
-	return offsets, totalBonus
+	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
+	tokens := Tokenize(item.text.ToString(), p.delimiter)
-	if len(p.nth) > 0 {
+	ret := Transform(tokens, p.nth)
-		tokens := Tokenize(item.text, p.delimiter)
+	item.transformed = &ret
-		ret = Transform(tokens, p.nth)
-	} else {
-		ret = []Token{Token{text: item.text, prefixLength: 0, trimLength: util.TrimLen(item.text)}}
-	}
-	item.transformed = ret
 	return ret
 }
 
-func (p *Pattern) iter(pfun func(bool, bool, []rune, []rune) algo.Result,
+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) {
-	tokens []Token, caseSensitive bool, forward bool, pattern []rune) (Offset, int32) {
 	for _, part := range tokens {
-		prefixLength := int32(part.prefixLength)
+		if res, pos := pfun(caseSensitive, normalize, forward, part.text, pattern, withPos, slab); res.Start >= 0 {
-		if res := pfun(caseSensitive, forward, part.text, pattern); res.Start >= 0 {
+			sidx := int32(res.Start) + part.prefixLength
-			var sidx int32 = res.Start + prefixLength
+			eidx := int32(res.End) + part.prefixLength
-			var eidx int32 = res.End + prefixLength
+			if pos != nil {
-			return Offset{sidx, eidx, int32(part.trimLength)}, res.Bonus
+				for idx := range *pos {
+					(*pos)[idx] += int(part.prefixLength)
+				}
+			}
+			return Offset{sidx, eidx}, res.Score, pos
 		}
 	}
-	// TODO: math.MaxUint16
+	return Offset{-1, -1}, 0, nil
-	return Offset{-1, -1, -1}, 0.0
 }

src/pattern_test.go

@@ -5,45 +5,44 @@ import (
 	"testing"
 
 	"github.com/junegunn/fzf/src/algo"
+	"github.com/junegunn/fzf/src/util"
 )
 
+var slab *util.Slab
+
+func init() {
+	slab = util.MakeSlab(slab16Size, slab32Size)
+}
+
 func TestParseTermsExtended(t *testing.T) {
-	terms := parseTerms(true, CaseSmart,
+	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 ||
 		terms[2][0].typ != termPrefix || terms[2][0].inv ||
 		terms[3][0].typ != termSuffix || terms[3][0].inv ||
-		terms[4][0].typ != termFuzzy || !terms[4][0].inv ||
+		terms[4][0].typ != termExact || !terms[4][0].inv ||
-		terms[5][0].typ != termExact || !terms[5][0].inv ||
+		terms[5][0].typ != termFuzzy || !terms[5][0].inv ||
 		terms[6][0].typ != termPrefix || !terms[6][0].inv ||
 		terms[7][0].typ != termSuffix || !terms[7][0].inv ||
 		terms[7][1].typ != termEqual || terms[7][1].inv ||
 		terms[8][0].typ != termPrefix || terms[8][0].inv ||
 		terms[8][1].typ != termExact || terms[8][1].inv ||
 		terms[8][2].typ != termSuffix || terms[8][2].inv ||
-		terms[8][3].typ != termFuzzy || !terms[8][3].inv {
+		terms[8][3].typ != termExact || !terms[8][3].inv {
-		t.Errorf("%s", terms)
+		t.Errorf("%v", terms)
 	}
-	for idx, termSet := range terms[:8] {
+	for _, termSet := range terms[:8] {
 		term := termSet[0]
 		if len(term.text) != 3 {
-			t.Errorf("%s", term)
+			t.Errorf("%v", 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)
 		}
 	}
 }
 
 func TestParseTermsExtendedExact(t *testing.T) {
-	terms := parseTerms(false, CaseSmart,
+	terms := parseTerms(false, CaseSmart, false,
 		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
 	if len(terms) != 8 ||
 		terms[0][0].typ != termExact || terms[0][0].inv || len(terms[0][0].text) != 3 ||
@@ -54,59 +53,70 @@ func TestParseTermsExtendedExact(t *testing.T) {
 		terms[5][0].typ != termFuzzy || !terms[5][0].inv || len(terms[5][0].text) != 3 ||
 		terms[6][0].typ != termPrefix || !terms[6][0].inv || len(terms[6][0].text) != 3 ||
 		terms[7][0].typ != termSuffix || !terms[7][0].inv || len(terms[7][0].text) != 3 {
-		t.Errorf("%s", terms)
+		t.Errorf("%v", terms)
 	}
 }
 
 func TestParseTermsEmpty(t *testing.T) {
-	terms := parseTerms(true, CaseSmart, "' $ ^ !' !^ !$")
+	terms := parseTerms(true, CaseSmart, false, "' ^ !' !^")
 	if len(terms) != 0 {
-		t.Errorf("%s", terms)
+		t.Errorf("%v", terms)
 	}
 }
 
 func TestExact(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(true, true, CaseSmart, true,
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true,
 		[]Range{}, Delimiter{}, []rune("'abc"))
-	res := algo.ExactMatchNaive(
+	chars := util.ToChars([]byte("aabbcc abc"))
-		pattern.caseSensitive, pattern.forward, []rune("aabbcc abc"), pattern.termSets[0][0].text)
+	res, pos := algo.ExactMatchNaive(
+		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)
+		t.Errorf("%v / %d / %d", pattern.termSets, res.Start, res.End)
+	}
+	if pos != nil {
+		t.Errorf("pos is expected to be nil")
 	}
 }
 
 func TestEqual(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(true, true, CaseSmart, true, []Range{}, Delimiter{}, []rune("^AbC$"))
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("^AbC$"))
 
-	match := func(str string, sidxExpected int32, eidxExpected int32) {
+	match := func(str string, sidxExpected int, eidxExpected int) {
-		res := algo.EqualMatch(
+		chars := util.ToChars([]byte(str))
-			pattern.caseSensitive, pattern.forward, []rune(str), pattern.termSets[0][0].text)
+		res, pos := algo.EqualMatch(
+			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)
+			t.Errorf("%v / %d / %d", pattern.termSets, res.Start, res.End)
+		}
+		if pos != nil {
+			t.Errorf("pos is expected to be nil")
 		}
 	}
 	match("ABC", -1, -1)
 	match("AbC", 0, 3)
+	match("AbC  ", 0, 3)
+	match(" AbC ", 1, 4)
+	match("  AbC", 2, 5)
 }
 
 func TestCaseSensitivity(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pat1 := BuildPattern(true, false, CaseSmart, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat1 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat2 := BuildPattern(true, false, CaseSmart, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat2 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat3 := BuildPattern(true, false, CaseIgnore, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat3 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat4 := BuildPattern(true, false, CaseIgnore, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat4 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat5 := BuildPattern(true, false, CaseRespect, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat5 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat6 := BuildPattern(true, false, CaseRespect, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat6 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
 
 	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
 		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
@@ -119,46 +129,81 @@ func TestCaseSensitivity(t *testing.T) {
 }
 
 func TestOrigTextAndTransformed(t *testing.T) {
-	pattern := BuildPattern(true, true, CaseSmart, true, []Range{}, Delimiter{}, []rune("jg"))
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("jg"))
-	tokens := Tokenize([]rune("junegunn"), Delimiter{})
+	tokens := Tokenize("junegunn", Delimiter{})
-	trans := Transform(tokens, []Range{Range{1, 1}})
+	trans := Transform(tokens, []Range{{1, 1}})
 
-	origRunes := []rune("junegunn.choi")
+	origBytes := []byte("junegunn.choi")
 	for _, extended := range []bool{false, true} {
-		chunk := Chunk{
+		chunk := Chunk{count: 1}
-			&Item{
+		chunk.items[0] = Item{
-				text:        []rune("junegunn"),
+			text:        util.ToChars([]byte("junegunn")),
-				origText:    &origRunes,
+			origText:    &origBytes,
-				transformed: trans},
+			transformed: &trans}
-		}
 		pattern.extended = extended
-		matches := pattern.matchChunk(&chunk)
+		matches := pattern.matchChunk(&chunk, nil, slab) // No cache
-		if string(matches[0].text) != "junegunn" || string(*matches[0].origText) != "junegunn.choi" ||
+		if !(matches[0].item.text.ToString() == "junegunn" &&
-			matches[0].offsets[0][0] != 0 || matches[0].offsets[0][1] != 5 ||
+			string(*matches[0].item.origText) == "junegunn.choi" &&
-			!reflect.DeepEqual(matches[0].transformed, trans) {
+			reflect.DeepEqual(*matches[0].item.transformed, trans)) {
 			t.Error("Invalid match result", matches)
 		}
+
+		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)) {
+			t.Error("Invalid match result", match, offsets, extended)
+		}
+		if !((*pos)[0] == 4 && (*pos)[1] == 0) {
+			t.Error("Invalid pos array", *pos)
+		}
 	}
 }
 
 func TestCacheKey(t *testing.T) {
 	test := func(extended bool, patStr string, expected string, cacheable bool) {
-		pat := BuildPattern(true, extended, CaseSmart, true, []Range{}, Delimiter{}, []rune(patStr))
+		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, 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", "foo\tbar", true)
+	test(true, "foo 'bar", "foo\tbar", false)
+	test(true, "foo !bar", "foo", 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)
 }

src/protector/protector.go

@@ -0,0 +1,8 @@
+// +build !openbsd
+
+package protector
+
+// Protect calls OS specific protections like pledge on OpenBSD
+func Protect() {
+	return
+}

src/protector/protector_openbsd.go

@@ -0,0 +1,10 @@
+// +build openbsd
+
+package protector
+
+import "golang.org/x/sys/unix"
+
+// Protect calls OS specific protections like pledge on OpenBSD
+func Protect() {
+	unix.PledgePromises("stdio rpath tty proc exec")
+}

src/reader.go

@@ -2,10 +2,17 @@ package fzf
 
 import (
 	"bufio"
+	"context"
 	"io"
 	"os"
+	"os/exec"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"time"
 
 	"github.com/junegunn/fzf/src/util"
+	"github.com/saracen/walker"
 )
 
 // Reader reads from command or standard input
@@ -13,20 +20,100 @@ type Reader struct {
 	pusher   func([]byte) bool
 	eventBox *util.EventBox
 	delimNil bool
+	event    int32
+	finChan  chan bool
+	mutex    sync.Mutex
+	exec     *exec.Cmd
+	command  *string
+	killed   bool
+	wait     bool
+}
+
+// NewReader returns new Reader object
+func NewReader(pusher func([]byte) bool, eventBox *util.EventBox, delimNil bool, wait bool) *Reader {
+	return &Reader{pusher, eventBox, delimNil, int32(EvtReady), make(chan bool, 1), sync.Mutex{}, nil, nil, false, wait}
+}
+
+func (r *Reader) startEventPoller() {
+	go func() {
+		ptr := &r.event
+		pollInterval := readerPollIntervalMin
+		for {
+			if atomic.CompareAndSwapInt32(ptr, int32(EvtReadNew), int32(EvtReady)) {
+				r.eventBox.Set(EvtReadNew, (*string)(nil))
+				pollInterval = readerPollIntervalMin
+			} else if atomic.LoadInt32(ptr) == int32(EvtReadFin) {
+				if r.wait {
+					r.finChan <- true
+				}
+				return
+			} else {
+				pollInterval += readerPollIntervalStep
+				if pollInterval > readerPollIntervalMax {
+					pollInterval = readerPollIntervalMax
+				}
+			}
+			time.Sleep(pollInterval)
+		}
+	}()
+}
+
+func (r *Reader) fin(success bool) {
+	atomic.StoreInt32(&r.event, int32(EvtReadFin))
+	if r.wait {
+		<-r.finChan
+	}
+
+	r.mutex.Lock()
+	ret := r.command
+	if success || r.killed {
+		ret = nil
+	}
+	r.mutex.Unlock()
+
+	r.eventBox.Set(EvtReadFin, ret)
+}
+
+func (r *Reader) terminate() {
+	r.mutex.Lock()
+	defer func() { r.mutex.Unlock() }()
+
+	r.killed = true
+	if r.exec != nil && r.exec.Process != nil {
+		util.KillCommand(r.exec)
+	} else if defaultCommand != "" {
+		os.Stdin.Close()
+	}
+}
+
+func (r *Reader) restart(command string) {
+	r.event = int32(EvtReady)
+	r.startEventPoller()
+	success := r.readFromCommand(nil, command)
+	r.fin(success)
 }
 
 // ReadSource reads data from the default command or from standard input
 func (r *Reader) ReadSource() {
+	r.startEventPoller()
+	var success bool
 	if util.IsTty() {
+		// The default command for *nix requires bash
+		shell := "bash"
 		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
 		if len(cmd) == 0 {
-			cmd = defaultCommand
+			if defaultCommand != "" {
+				success = r.readFromCommand(&shell, defaultCommand)
+			} else {
+				success = r.readFiles()
+			}
+		} else {
+			success = r.readFromCommand(nil, cmd)
 		}
-		r.readFromCommand(cmd)
 	} else {
-		r.readFromStdin()
+		success = r.readFromStdin()
 	}
-	r.eventBox.Set(EvtReadFin, nil)
+	r.fin(success)
 }
 
 func (r *Reader) feed(src io.Reader) {
@@ -34,17 +121,23 @@ func (r *Reader) feed(src io.Reader) {
 	if r.delimNil {
 		delim = '\000'
 	}
-	reader := bufio.NewReader(src)
+	reader := bufio.NewReaderSize(src, readerBufferSize)
 	for {
 		// ReadBytes returns err != nil if and only if the returned data does not
 		// end in delim.
 		bytea, err := reader.ReadBytes(delim)
-		if len(bytea) > 0 {
+		byteaLen := len(bytea)
+		if byteaLen > 0 {
 			if err == nil {
-				bytea = bytea[:len(bytea)-1]
+				// get rid of carriage return if under Windows:
+				if util.IsWindows() && byteaLen >= 2 && bytea[byteaLen-2] == byte('\r') {
+					bytea = bytea[:byteaLen-2]
+				} else {
+					bytea = bytea[:byteaLen-1]
+				}
 			}
 			if r.pusher(bytea) {
-				r.eventBox.Set(EvtReadNew, nil)
+				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}
 		if err != nil {
@@ -53,20 +146,56 @@ 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) readFiles() bool {
-	listCommand := util.ExecCommand(cmd)
+	r.killed = false
-	out, err := listCommand.StdoutPipe()
+	fn := func(path string, mode os.FileInfo) error {
-	if err != nil {
+		path = filepath.Clean(path)
-		return
+		if path != "." {
+			isDir := mode.Mode().IsDir()
+			if isDir && filepath.Base(path)[0] == '.' {
+				return filepath.SkipDir
+			}
+			if !isDir && r.pusher([]byte(path)) {
+				atomic.StoreInt32(&r.event, int32(EvtReadNew))
+			}
+		}
+		r.mutex.Lock()
+		defer r.mutex.Unlock()
+		if r.killed {
+			return context.Canceled
+		}
+		return nil
 	}
-	err = listCommand.Start()
+	cb := walker.WithErrorCallback(func(pathname string, err error) error {
-	if err != nil {
+		return nil
-		return
+	})
-	}
+	return walker.Walk(".", fn, cb) == nil
-	defer listCommand.Wait()
+}
-	r.feed(out)
+
+func (r *Reader) readFromCommand(shell *string, command string) bool {
+	r.mutex.Lock()
+	r.killed = false
+	r.command = &command
+	if shell != nil {
+		r.exec = util.ExecCommandWith(*shell, command, true)
+	} else {
+		r.exec = util.ExecCommand(command, true)
+	}
+	out, err := r.exec.StdoutPipe()
+	if err != nil {
+		r.mutex.Unlock()
+		return false
+	}
+	err = r.exec.Start()
+	r.mutex.Unlock()
+	if err != nil {
+		return false
+	}
+	r.feed(out)
+	return r.exec.Wait() == nil
 }

src/reader_test.go

@@ -2,6 +2,7 @@ package fzf
 
 import (
 	"testing"
+	"time"
 
 	"github.com/junegunn/fzf/src/util"
 )
@@ -9,9 +10,11 @@ import (
 func TestReadFromCommand(t *testing.T) {
 	strs := []string{}
 	eb := util.NewEventBox()
-	reader := Reader{
+	reader := NewReader(
-		pusher:   func(s []byte) bool { strs = append(strs, string(s)); return true },
+		func(s []byte) bool { strs = append(strs, string(s)); return true },
-		eventBox: eb}
+		eb, false, true)
+
+	reader.startEventPoller()
 
 	// Check EventBox
 	if eb.Peek(EvtReadNew) {
@@ -19,21 +22,16 @@ func TestReadFromCommand(t *testing.T) {
 	}
 
 	// Normal command
-	reader.readFromCommand(`echo abc && echo def`)
+	reader.fin(reader.readFromCommand(nil, `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) {
+	eb.WaitFor(EvtReadFin)
-		t.Error("EvtReadNew should be set yet")
-	}
 
 	// Wait should return immediately
 	eb.Wait(func(events *util.Events) {
-		if _, found := (*events)[EvtReadNew]; !found {
-			t.Errorf("%s", events)
-		}
 		events.Clear()
 	})
 
@@ -42,8 +40,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(nil, `no-such-command`))
 	strs = []string{}
 	if len(strs) > 0 {
 		t.Errorf("%s", strs)
@@ -51,6 +55,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")
 	}
 }

src/result.go

@@ -0,0 +1,243 @@
+package fzf
+
+import (
+	"math"
+	"sort"
+	"unicode"
+
+	"github.com/junegunn/fzf/src/tui"
+	"github.com/junegunn/fzf/src/util"
+)
+
+// Offset holds two 32-bit integers denoting the offsets of a matched substring
+type Offset [2]int32
+
+type colorOffset struct {
+	offset [2]int32
+	color  tui.ColorPair
+}
+
+type Result struct {
+	item   *Item
+	points [4]uint16
+}
+
+func buildResult(item *Item, offsets []Offset, score int) Result {
+	if len(offsets) > 1 {
+		sort.Sort(ByOrder(offsets))
+	}
+
+	result := Result{item: item}
+	numChars := item.text.Length()
+	minBegin := math.MaxUint16
+	minEnd := math.MaxUint16
+	maxEnd := 0
+	validOffsetFound := false
+	for _, offset := range offsets {
+		b, e := int(offset[0]), int(offset[1])
+		if b < e {
+			minBegin = util.Min(b, minBegin)
+			minEnd = util.Min(e, minEnd)
+			maxEnd = util.Max(e, maxEnd)
+			validOffsetFound = true
+		}
+	}
+
+	for idx, criterion := range sortCriteria {
+		val := uint16(math.MaxUint16)
+		switch criterion {
+		case byScore:
+			// Higher is better
+			val = math.MaxUint16 - util.AsUint16(score)
+		case byLength:
+			val = item.TrimLength()
+		case byBegin, byEnd:
+			if validOffsetFound {
+				whitePrefixLen := 0
+				for idx := 0; idx < numChars; idx++ {
+					r := item.text.Get(idx)
+					whitePrefixLen = idx
+					if idx == minBegin || !unicode.IsSpace(r) {
+						break
+					}
+				}
+				if criterion == byBegin {
+					val = util.AsUint16(minEnd - whitePrefixLen)
+				} else {
+					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/int(item.TrimLength()))
+				}
+			}
+		}
+		result.points[3-idx] = val
+	}
+
+	return result
+}
+
+// Sort criteria to use. Never changes once fzf is started.
+var sortCriteria []criterion
+
+// Index returns ordinal index of the Item
+func (result *Result) Index() int32 {
+	return result.item.Index()
+}
+
+func minRank() Result {
+	return Result{item: &minItem, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
+}
+
+func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme, colBase tui.ColorPair, colMatch tui.ColorPair, current bool) []colorOffset {
+	itemColors := result.item.Colors()
+
+	// No ANSI codes
+	if len(itemColors) == 0 {
+		var offsets []colorOffset
+		for _, off := range matchOffsets {
+			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: colMatch})
+		}
+		return offsets
+	}
+
+	// Find max column
+	var maxCol int32
+	for _, off := range matchOffsets {
+		if off[1] > maxCol {
+			maxCol = off[1]
+		}
+	}
+	for _, ansi := range itemColors {
+		if ansi.offset[1] > maxCol {
+			maxCol = ansi.offset[1]
+		}
+	}
+
+	cols := make([]int, maxCol)
+	for colorIndex, ansi := range itemColors {
+		for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
+			cols[i] = colorIndex + 1 // 1-based index of itemColors
+		}
+	}
+
+	for _, off := range matchOffsets {
+		for i := off[0]; i < off[1]; i++ {
+			// Negative of 1-based index of itemColors
+			// - The extra -1 means highlighted
+			cols[i] = cols[i]*-1 - 1
+		}
+	}
+
+	// sort.Sort(ByOrder(offsets))
+
+	// Merge offsets
+	// ------------  ----  --  ----
+	//   ++++++++      ++++++++++
+	// --++++++++--  --++++++++++---
+	curr := 0
+	start := 0
+	ansiToColorPair := func(ansi ansiOffset, base tui.ColorPair) tui.ColorPair {
+		fg := ansi.color.fg
+		bg := ansi.color.bg
+		if fg == -1 {
+			if current {
+				fg = theme.Current.Color
+			} else {
+				fg = theme.Fg.Color
+			}
+		}
+		if bg == -1 {
+			if current {
+				bg = theme.DarkBg.Color
+			} else {
+				bg = theme.Bg.Color
+			}
+		}
+		return tui.NewColorPair(fg, bg, ansi.color.attr).MergeAttr(base)
+	}
+	var colors []colorOffset
+	add := func(idx int) {
+		if curr != 0 && idx > start {
+			if curr < 0 {
+				color := colMatch
+				if curr < -1 && theme.Colored {
+					origColor := ansiToColorPair(itemColors[-curr-2], colMatch)
+					// hl or hl+ only sets the foreground color, so colMatch is the
+					// combination of either [hl and bg] or [hl+ and bg+].
+					//
+					// If the original text already has background color, and the
+					// foreground color of colMatch is -1, we shouldn't only apply the
+					// background color of colMatch.
+					// e.g. echo -e "\x1b[32;7mfoo\x1b[mbar" | fzf --ansi --color bg+:1,hl+:-1:underline
+					//      echo -e "\x1b[42mfoo\x1b[mbar" | fzf --ansi --color bg+:1,hl+:-1:underline
+					if color.Fg().IsDefault() && origColor.HasBg() {
+						color = origColor
+					} else {
+						color = origColor.MergeNonDefault(color)
+					}
+				}
+				colors = append(colors, colorOffset{
+					offset: [2]int32{int32(start), int32(idx)}, color: color})
+			} else {
+				ansi := itemColors[curr-1]
+				colors = append(colors, colorOffset{
+					offset: [2]int32{int32(start), int32(idx)},
+					color:  ansiToColorPair(ansi, colBase)})
+			}
+		}
+	}
+	for idx, col := range cols {
+		if col != curr {
+			add(idx)
+			start = idx
+			curr = col
+		}
+	}
+	add(int(maxCol))
+	return colors
+}
+
+// ByOrder is for sorting substring offsets
+type ByOrder []Offset
+
+func (a ByOrder) Len() int {
+	return len(a)
+}
+
+func (a ByOrder) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByOrder) Less(i, j int) bool {
+	ioff := a[i]
+	joff := a[j]
+	return (ioff[0] < joff[0]) || (ioff[0] == joff[0]) && (ioff[1] <= joff[1])
+}
+
+// ByRelevance is for sorting Items
+type ByRelevance []Result
+
+func (a ByRelevance) Len() int {
+	return len(a)
+}
+
+func (a ByRelevance) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByRelevance) Less(i, j int) bool {
+	return compareRanks(a[i], a[j], false)
+}
+
+// ByRelevanceTac is for sorting Items
+type ByRelevanceTac []Result
+
+func (a ByRelevanceTac) Len() int {
+	return len(a)
+}
+
+func (a ByRelevanceTac) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByRelevanceTac) Less(i, j int) bool {
+	return compareRanks(a[i], a[j], true)
+}

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
+}

src/result_test.go

@@ -0,0 +1,159 @@
+// +build !tcell
+
+package fzf
+
+import (
+	"math"
+	"sort"
+	"testing"
+
+	"github.com/junegunn/fzf/src/tui"
+	"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{
+		{3, 5}, {2, 7},
+		{1, 3}, {2, 9}}
+	sort.Sort(ByOrder(offsets))
+
+	if offsets[0][0] != 1 || offsets[0][1] != 3 ||
+		offsets[1][0] != 2 || offsets[1][1] != 7 ||
+		offsets[2][0] != 2 || offsets[2][1] != 9 ||
+		offsets[3][0] != 3 || offsets[3][1] != 5 {
+		t.Error("Invalid order:", offsets)
+	}
+}
+
+func TestRankComparison(t *testing.T) {
+	rank := func(vals ...uint16) Result {
+		return Result{
+			points: [4]uint16{vals[0], vals[1], vals[2], vals[3]},
+			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) ||
+		!compareRanks(rank(1, 2, 0, 0, 3), rank(1, 3, 0, 0, 2), false) ||
+		!compareRanks(rank(0, 0, 0, 0, 0), rank(0, 0, 0, 0, 0), false) {
+		t.Error("Invalid order")
+	}
+
+	if compareRanks(rank(3, 0, 0, 0, 5), rank(2, 0, 0, 0, 7), true) ||
+		!compareRanks(rank(3, 0, 0, 0, 5), rank(3, 0, 0, 0, 6), false) ||
+		!compareRanks(rank(1, 2, 0, 0, 3), rank(1, 3, 0, 0, 2), true) ||
+		!compareRanks(rank(0, 0, 0, 0, 0), rank(0, 0, 0, 0, 0), false) {
+		t.Error("Invalid order (tac)")
+	}
+}
+
+// Match length, string length, index
+func TestResultRank(t *testing.T) {
+	// FIXME global
+	sortCriteria = []criterion{byScore, byLength}
+
+	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
+	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}
+	sort.Sort(ByRelevance(items))
+	if items[0] != item2 || items[1] != item1 {
+		t.Error(items)
+	}
+
+	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())
+	}
+
+	// Sort by relevance
+	item3 := buildResult(
+		withIndex(&Item{}, 2), []Offset{{1, 3}, {5, 7}}, 3)
+	item4 := buildResult(
+		withIndex(&Item{}, 2), []Offset{{1, 2}, {6, 7}}, 4)
+	item5 := buildResult(
+		withIndex(&Item{}, 2), []Offset{{1, 3}, {5, 7}}, 5)
+	item6 := buildResult(
+		withIndex(&Item{}, 2), []Offset{{1, 2}, {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 &&
+		items[4] == item2 && items[5] == item1) {
+		t.Error(items, item1, item2, item3, item4, item5, item6)
+	}
+}
+
+func TestColorOffset(t *testing.T) {
+	// ------------ 20 ----  --  ----
+	//   ++++++++        ++++++++++
+	// --++++++++--    --++++++++++---
+
+	offsets := []Offset{{5, 15}, {25, 35}}
+	item := Result{
+		item: &Item{
+			colors: &[]ansiOffset{
+				{[2]int32{0, 20}, ansiState{1, 5, 0, -1}},
+				{[2]int32{22, 27}, ansiState{2, 6, tui.Bold, -1}},
+				{[2]int32{30, 32}, ansiState{3, 7, 0, -1}},
+				{[2]int32{33, 40}, ansiState{4, 8, tui.Bold, -1}}}}}
+
+	colBase := tui.NewColorPair(89, 189, tui.AttrUndefined)
+	colMatch := tui.NewColorPair(99, 199, tui.AttrUndefined)
+	colors := item.colorOffsets(offsets, tui.Dark256, colBase, colMatch, true)
+	assert := func(idx int, b int32, e int32, c tui.ColorPair) {
+		o := colors[idx]
+		if o.offset[0] != b || o.offset[1] != e || o.color != c {
+			t.Error(o, b, e, c)
+		}
+	}
+	// [{[0 5] {1 5 0}} {[5 15] {99 199 0}} {[15 20] {1 5 0}}
+	//  {[22 25] {2 6 1}} {[25 27] {99 199 1}} {[27 30] {99 199 0}}
+	//  {[30 32] {99 199 0}} {[32 33] {99 199 0}} {[33 35] {99 199 1}}
+	//  {[35 40] {4 8 1}}]
+	assert(0, 0, 5, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(1, 5, 15, colMatch)
+	assert(2, 15, 20, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(3, 22, 25, tui.NewColorPair(2, 6, tui.Bold))
+	assert(4, 25, 27, colMatch.WithAttr(tui.Bold))
+	assert(5, 27, 30, colMatch)
+	assert(6, 30, 32, colMatch)
+	assert(7, 32, 33, colMatch) // TODO: Should we merge consecutive blocks?
+	assert(8, 33, 35, colMatch.WithAttr(tui.Bold))
+	assert(9, 35, 40, tui.NewColorPair(4, 8, tui.Bold))
+
+	colRegular := tui.NewColorPair(-1, -1, tui.AttrUndefined)
+	colUnderline := tui.NewColorPair(-1, -1, tui.Underline)
+	colors = item.colorOffsets(offsets, tui.Dark256, colRegular, colUnderline, true)
+
+	// [{[0 5] {1 5 0}} {[5 15] {1 5 8}} {[15 20] {1 5 0}}
+	//  {[22 25] {2 6 1}} {[25 27] {2 6 9}} {[27 30] {-1 -1 8}}
+	//  {[30 32] {3 7 8}} {[32 33] {-1 -1 8}} {[33 35] {4 8 9}}
+	//  {[35 40] {4 8 1}}]
+	assert(0, 0, 5, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(1, 5, 15, tui.NewColorPair(1, 5, tui.Underline))
+	assert(2, 15, 20, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(3, 22, 25, tui.NewColorPair(2, 6, tui.Bold))
+	assert(4, 25, 27, tui.NewColorPair(2, 6, tui.Bold|tui.Underline))
+	assert(5, 27, 30, colUnderline)
+	assert(6, 30, 32, tui.NewColorPair(3, 7, tui.Underline))
+	assert(7, 32, 33, colUnderline)
+	assert(8, 33, 35, tui.NewColorPair(4, 8, tui.Bold|tui.Underline))
+	assert(9, 35, 40, tui.NewColorPair(4, 8, tui.Bold))
+}

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
+}

src/terminal_test.go

@@ -0,0 +1,638 @@
+package fzf
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+	"text/template"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func TestReplacePlaceholder(t *testing.T) {
+	item1 := newItem("  foo'bar \x1b[31mbaz\x1b[m")
+	items1 := []*Item{item1, item1}
+	items2 := []*Item{
+		newItem("foo'bar \x1b[31mbaz\x1b[m"),
+		newItem("foo'bar \x1b[31mbaz\x1b[m"),
+		newItem("FOO'BAR \x1b[31mBAZ\x1b[m")}
+
+	delim := "'"
+	var regex *regexp.Regexp
+
+	var result string
+	check := func(expected string) {
+		if result != expected {
+			t.Errorf("expected: %s, actual: %s", expected, result)
+		}
+	}
+	// helper function that converts template format into string and carries out the check()
+	checkFormat := func(format string) {
+		type quotes struct{ O, I, S string } // outer, inner quotes, print separator
+		unixStyle := quotes{`'`, `'\''`, "\n"}
+		windowsStyle := quotes{`^"`, `'`, "\n"}
+		var effectiveStyle quotes
+
+		if util.IsWindows() {
+			effectiveStyle = windowsStyle
+		} else {
+			effectiveStyle = unixStyle
+		}
+
+		expected := templateToString(format, effectiveStyle)
+		check(expected)
+	}
+	printsep := "\n"
+
+	/*
+		Test multiple placeholders and the function parameters.
+	*/
+
+	// {}, preserve ansi
+	result = replacePlaceholder("echo {}", false, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar \x1b[31mbaz\x1b[m{{.O}}")
+
+	// {}, strip ansi
+	result = replacePlaceholder("echo {}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
+
+	// {}, with multiple items
+	result = replacePlaceholder("echo {}", true, Delimiter{}, printsep, false, "query", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}")
+
+	// {..}, strip leading whitespaces, preserve ansi
+	result = replacePlaceholder("echo {..}", false, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}foo{{.I}}bar \x1b[31mbaz\x1b[m{{.O}}")
+
+	// {..}, strip leading whitespaces, strip ansi
+	result = replacePlaceholder("echo {..}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}")
+
+	// {q}
+	result = replacePlaceholder("echo {} {q}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}} {{.O}}query{{.O}}")
+
+	// {q}, multiple items
+	result = replacePlaceholder("echo {+}{q}{+}", true, Delimiter{}, printsep, false, "query 'string'", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}{{.O}}query {{.I}}string{{.I}}{{.O}}{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}")
+
+	result = replacePlaceholder("echo {}{q}{}", true, Delimiter{}, printsep, false, "query 'string'", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}{{.O}}query {{.I}}string{{.I}}{{.O}}{{.O}}foo{{.I}}bar baz{{.O}}")
+
+	result = replacePlaceholder("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}bazfoo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}foo{{.I}}bar{{.O}}/{{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}}")
+
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}baz{{.O}}/{{.O}}foo{{.I}}bar{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}}")
+
+	result = replacePlaceholder("echo {+1}/{+2}/{+-1}/{+-2}/{+..}/{n.t}/\\{}/\\{1}/\\{q}/{+3}", true, Delimiter{}, printsep, false, "query", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}} {{.O}}{{.O}}")
+
+	// forcePlus
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, true, "query", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}} {{.O}}{{.O}}")
+
+	// Whitespace preserving flag with "'" delimiter
+	result = replacePlaceholder("echo {s1}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.O}}")
+
+	result = replacePlaceholder("echo {s2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}bar baz{{.O}}")
+
+	result = replacePlaceholder("echo {s}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
+
+	result = replacePlaceholder("echo {s..}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
+
+	// Whitespace preserving flag with regex delimiter
+	regex = regexp.MustCompile(`\w+`)
+
+	result = replacePlaceholder("echo {s1}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  {{.O}}")
+
+	result = replacePlaceholder("echo {s2}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}{{.I}}{{.O}}")
+
+	result = replacePlaceholder("echo {s3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}} {{.O}}")
+
+	// No match
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, nil})
+	check("echo /")
+
+	// No match, but with selections
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, item1})
+	checkFormat("echo /{{.O}}  foo{{.I}}bar baz{{.O}}")
+
+	// String delimiter
+	result = replacePlaceholder("echo {}/{1}/{2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}foo{{.O}}/{{.O}}bar baz{{.O}}")
+
+	// Regex delimiter
+	regex = regexp.MustCompile("[oa]+")
+	// foo'bar baz
+	result = replacePlaceholder("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}f{{.O}}/{{.O}}r b{{.O}}/{{.O}}{{.I}}bar b{{.O}}")
+
+	/*
+		Test single placeholders, but focus on the placeholders' parameters (e.g. flags).
+		see: TestParsePlaceholder
+	*/
+	items3 := []*Item{
+		// single line
+		newItem("1a 1b 1c 1d 1e 1f"),
+		// multi line
+		newItem("1a 1b 1c 1d 1e 1f"),
+		newItem("2a 2b 2c 2d 2e 2f"),
+		newItem("3a 3b 3c 3d 3e 3f"),
+		newItem("4a 4b 4c 4d 4e 4f"),
+		newItem("5a 5b 5c 5d 5e 5f"),
+		newItem("6a 6b 6c 6d 6e 6f"),
+		newItem("7a 7b 7c 7d 7e 7f"),
+	}
+	stripAnsi := false
+	printsep = "\n"
+	forcePlus := false
+	query := "sample query"
+
+	templateToOutput := make(map[string]string)
+	templateToFile := make(map[string]string) // same as above, but the file contents will be matched
+	// I. item type placeholder
+	templateToOutput[`{}`] = `{{.O}}1a 1b 1c 1d 1e 1f{{.O}}`
+	templateToOutput[`{+}`] = `{{.O}}1a 1b 1c 1d 1e 1f{{.O}} {{.O}}2a 2b 2c 2d 2e 2f{{.O}} {{.O}}3a 3b 3c 3d 3e 3f{{.O}} {{.O}}4a 4b 4c 4d 4e 4f{{.O}} {{.O}}5a 5b 5c 5d 5e 5f{{.O}} {{.O}}6a 6b 6c 6d 6e 6f{{.O}} {{.O}}7a 7b 7c 7d 7e 7f{{.O}}`
+	templateToOutput[`{n}`] = `0`
+	templateToOutput[`{+n}`] = `0 0 0 0 0 0 0`
+	templateToFile[`{f}`] = `1a 1b 1c 1d 1e 1f{{.S}}`
+	templateToFile[`{+f}`] = `1a 1b 1c 1d 1e 1f{{.S}}2a 2b 2c 2d 2e 2f{{.S}}3a 3b 3c 3d 3e 3f{{.S}}4a 4b 4c 4d 4e 4f{{.S}}5a 5b 5c 5d 5e 5f{{.S}}6a 6b 6c 6d 6e 6f{{.S}}7a 7b 7c 7d 7e 7f{{.S}}`
+	templateToFile[`{nf}`] = `0{{.S}}`
+	templateToFile[`{+nf}`] = `0{{.S}}0{{.S}}0{{.S}}0{{.S}}0{{.S}}0{{.S}}0{{.S}}`
+
+	// II. token type placeholders
+	templateToOutput[`{..}`] = templateToOutput[`{}`]
+	templateToOutput[`{1..}`] = templateToOutput[`{}`]
+	templateToOutput[`{..2}`] = `{{.O}}1a 1b{{.O}}`
+	templateToOutput[`{1..2}`] = templateToOutput[`{..2}`]
+	templateToOutput[`{-2..-1}`] = `{{.O}}1e 1f{{.O}}`
+	// shorthand for x..x range
+	templateToOutput[`{1}`] = `{{.O}}1a{{.O}}`
+	templateToOutput[`{1..1}`] = templateToOutput[`{1}`]
+	templateToOutput[`{-6}`] = templateToOutput[`{1}`]
+	// multiple ranges
+	templateToOutput[`{1,2}`] = templateToOutput[`{1..2}`]
+	templateToOutput[`{1,2,4}`] = `{{.O}}1a 1b 1d{{.O}}`
+	templateToOutput[`{1,2..4}`] = `{{.O}}1a 1b 1c 1d{{.O}}`
+	templateToOutput[`{1..2,-4..-3}`] = `{{.O}}1a 1b 1c 1d{{.O}}`
+	// flags
+	templateToOutput[`{+1}`] = `{{.O}}1a{{.O}} {{.O}}2a{{.O}} {{.O}}3a{{.O}} {{.O}}4a{{.O}} {{.O}}5a{{.O}} {{.O}}6a{{.O}} {{.O}}7a{{.O}}`
+	templateToOutput[`{+-1}`] = `{{.O}}1f{{.O}} {{.O}}2f{{.O}} {{.O}}3f{{.O}} {{.O}}4f{{.O}} {{.O}}5f{{.O}} {{.O}}6f{{.O}} {{.O}}7f{{.O}}`
+	templateToOutput[`{s1}`] = `{{.O}}1a {{.O}}`
+	templateToFile[`{f1}`] = `1a{{.S}}`
+	templateToOutput[`{+s1..2}`] = `{{.O}}1a 1b {{.O}} {{.O}}2a 2b {{.O}} {{.O}}3a 3b {{.O}} {{.O}}4a 4b {{.O}} {{.O}}5a 5b {{.O}} {{.O}}6a 6b {{.O}} {{.O}}7a 7b {{.O}}`
+	templateToFile[`{+sf1..2}`] = `1a 1b {{.S}}2a 2b {{.S}}3a 3b {{.S}}4a 4b {{.S}}5a 5b {{.S}}6a 6b {{.S}}7a 7b {{.S}}`
+
+	// III. query type placeholder
+	// query flag is not removed after parsing, so it gets doubled
+	// while the double q is invalid, it is useful here for testing purposes
+	templateToOutput[`{q}`] = "{{.O}}" + query + "{{.O}}"
+
+	// IV. escaping placeholder
+	templateToOutput[`\{}`] = `{}`
+	templateToOutput[`\{++}`] = `{++}`
+	templateToOutput[`{++}`] = templateToOutput[`{+}`]
+
+	for giveTemplate, wantOutput := range templateToOutput {
+		result = replacePlaceholder(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
+		checkFormat(wantOutput)
+	}
+	for giveTemplate, wantOutput := range templateToFile {
+		path := replacePlaceholder(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
+
+		data, err := readFile(path)
+		if err != nil {
+			t.Errorf("Cannot read the content of the temp file %s.", path)
+		}
+		result = string(data)
+
+		checkFormat(wantOutput)
+	}
+}
+
+func TestQuoteEntry(t *testing.T) {
+	type quotes struct{ E, O, SQ, DQ, BS string } // standalone escape, outer, single and double quotes, backslash
+	unixStyle := quotes{``, `'`, `'\''`, `"`, `\`}
+	windowsStyle := quotes{`^`, `^"`, `'`, `\^"`, `\\`}
+	var effectiveStyle quotes
+
+	if util.IsWindows() {
+		effectiveStyle = windowsStyle
+	} else {
+		effectiveStyle = unixStyle
+	}
+
+	tests := map[string]string{
+		`'`:     `{{.O}}{{.SQ}}{{.O}}`,
+		`"`:     `{{.O}}{{.DQ}}{{.O}}`,
+		`\`:     `{{.O}}{{.BS}}{{.O}}`,
+		`\"`:    `{{.O}}{{.BS}}{{.DQ}}{{.O}}`,
+		`"\\\"`: `{{.O}}{{.DQ}}{{.BS}}{{.BS}}{{.BS}}{{.DQ}}{{.O}}`,
+
+		`$`:       `{{.O}}${{.O}}`,
+		`$HOME`:   `{{.O}}$HOME{{.O}}`,
+		`'$HOME'`: `{{.O}}{{.SQ}}$HOME{{.SQ}}{{.O}}`,
+
+		`&`:                       `{{.O}}{{.E}}&{{.O}}`,
+		`|`:                       `{{.O}}{{.E}}|{{.O}}`,
+		`<`:                       `{{.O}}{{.E}}<{{.O}}`,
+		`>`:                       `{{.O}}{{.E}}>{{.O}}`,
+		`(`:                       `{{.O}}{{.E}}({{.O}}`,
+		`)`:                       `{{.O}}{{.E}}){{.O}}`,
+		`@`:                       `{{.O}}{{.E}}@{{.O}}`,
+		`^`:                       `{{.O}}{{.E}}^{{.O}}`,
+		`%`:                       `{{.O}}{{.E}}%{{.O}}`,
+		`!`:                       `{{.O}}{{.E}}!{{.O}}`,
+		`%USERPROFILE%`:           `{{.O}}{{.E}}%USERPROFILE{{.E}}%{{.O}}`,
+		`C:\Program Files (x86)\`: `{{.O}}C:{{.BS}}Program Files {{.E}}(x86{{.E}}){{.BS}}{{.O}}`,
+		`"C:\Program Files"`:      `{{.O}}{{.DQ}}C:{{.BS}}Program Files{{.DQ}}{{.O}}`,
+	}
+
+	for input, expected := range tests {
+		escaped := quoteEntry(input)
+		expected = templateToString(expected, effectiveStyle)
+		if escaped != expected {
+			t.Errorf("Input: %s, expected: %s, actual %s", input, expected, escaped)
+		}
+	}
+}
+
+// purpose of this test is to demonstrate some shortcomings of fzf's templating system on Unix
+func TestUnixCommands(t *testing.T) {
+	if util.IsWindows() {
+		t.SkipNow()
+	}
+	tests := []testCase{
+		// reference: give{template, query, items}, want{output OR match}
+
+		// 1) working examples
+
+		// paths that does not have to evaluated will work fine, when quoted
+		{give{`grep foo {}`, ``, newItems(`test`)}, want{output: `grep foo 'test'`}},
+		{give{`grep foo {}`, ``, newItems(`/home/user/test`)}, want{output: `grep foo '/home/user/test'`}},
+		{give{`grep foo {}`, ``, newItems(`./test`)}, want{output: `grep foo './test'`}},
+
+		// only placeholders are escaped as data, this will lookup tilde character in a test file in your home directory
+		// quoting the tilde is required (to be treated as string)
+		{give{`grep {} ~/test`, ``, newItems(`~`)}, want{output: `grep '~' ~/test`}},
+
+		// 2) problematic examples
+		// (not necessarily unexpected)
+
+		// paths that need to expand some part of it won't work (special characters and variables)
+		{give{`cat {}`, ``, newItems(`~/test`)}, want{output: `cat '~/test'`}},
+		{give{`cat {}`, ``, newItems(`$HOME/test`)}, want{output: `cat '$HOME/test'`}},
+	}
+	testCommands(t, tests)
+}
+
+// purpose of this test is to demonstrate some shortcomings of fzf's templating system on Windows
+func TestWindowsCommands(t *testing.T) {
+	if !util.IsWindows() {
+		t.SkipNow()
+	}
+	tests := []testCase{
+		// reference: give{template, query, items}, want{output OR match}
+
+		// 1) working examples
+
+		// example of redundantly escaped backslash in the output, besides looking bit ugly, it won't cause any issue
+		{give{`type {}`, ``, newItems(`C:\test.txt`)}, want{output: `type ^"C:\\test.txt^"`}},
+		{give{`rg -- "package" {}`, ``, newItems(`.\test.go`)}, want{output: `rg -- "package" ^".\\test.go^"`}},
+		// example of mandatorily escaped backslash in the output, otherwise `rg -- "C:\test.txt"` is matching for tabulator
+		{give{`rg -- {}`, ``, newItems(`C:\test.txt`)}, want{output: `rg -- ^"C:\\test.txt^"`}},
+		// example of mandatorily escaped double quote in the output, otherwise `rg -- ""C:\\test.txt""` is not matching for the double quotes around the path
+		{give{`rg -- {}`, ``, newItems(`"C:\test.txt"`)}, want{output: `rg -- ^"\^"C:\\test.txt\^"^"`}},
+
+		// 2) problematic examples
+		// (not necessarily unexpected)
+
+		// notepad++'s parser can't handle `-n"12"` generate by fzf, expects `-n12`
+		{give{`notepad++ -n{1} {2}`, ``, newItems(`12	C:\Work\Test Folder\File.txt`)}, want{output: `notepad++ -n^"12^" ^"C:\\Work\\Test Folder\\File.txt^"`}},
+
+		// cat is parsing `\"` as a part of the file path, double quote is illegal character for paths on Windows
+		// cat: "C:\\test.txt: Invalid argument
+		{give{`cat {}`, ``, newItems(`"C:\test.txt"`)}, want{output: `cat ^"\^"C:\\test.txt\^"^"`}},
+		// cat: "C:\\test.txt": Invalid argument
+		{give{`cmd /c {}`, ``, newItems(`cat "C:\test.txt"`)}, want{output: `cmd /c ^"cat \^"C:\\test.txt\^"^"`}},
+
+		// the "file" flag in the pattern won't create *.bat or *.cmd file so the command in the output tries to edit the file, instead of executing it
+		// the temp file contains: `cat "C:\test.txt"`
+		// TODO this should actually work
+		{give{`cmd /c {f}`, ``, newItems(`cat "C:\test.txt"`)}, want{match: `^cmd /c .*\fzf-preview-[0-9]{9}$`}},
+	}
+	testCommands(t, tests)
+}
+
+// purpose of this test is to demonstrate some shortcomings of fzf's templating system on Windows in Powershell
+func TestPowershellCommands(t *testing.T) {
+	if !util.IsWindows() {
+		t.SkipNow()
+	}
+
+	tests := []testCase{
+		// reference: give{template, query, items}, want{output OR match}
+
+		/*
+			You can read each line in the following table as a pipeline that
+			consist of series of parsers that act upon your input (col. 1) and
+			each cell represents the output value.
+
+			For example:
+			 - exec.Command("program.exe", `\''`)
+			   - goes to win32 api which will process it transparently as it contains no special characters, see [CommandLineToArgvW][].
+			     - powershell command will receive it as is, that is two arguments: a literal backslash and empty string in single quotes
+			     - native command run via/from powershell will receive only one argument: a literal backslash. Because extra parsing rules apply, see [NativeCallsFromPowershell][].
+			       - some¹ apps have internal parser, that requires one more level of escaping (yes, this is completely application-specific, but see terminal_test.go#TestWindowsCommands)
+
+			Character⁰   CommandLineToArgvW   Powershell commands              Native commands from Powershell   Apps requiring escapes¹    | Being tested below
+			----------   ------------------   ------------------------------   -------------------------------   -------------------------- | ------------------
+			"            empty string²        missing argument error           ...                               ...                        |
+			\"           literal "            unbalanced quote error           ...                               ...                        |
+			'\"'         literal '"'          literal "                        empty string                      empty string (match all)   | yes
+			'\\\"'       literal '\"'         literal \"                       literal "                         literal "                  |
+			----------   ------------------   ------------------------------   -------------------------------   -------------------------- | ------------------
+			\            transparent          transparent                      transparent                       regex error                |
+			'\'          transparent          literal \                        literal \                         regex error                | yes
+			\\           transparent          transparent                      transparent                       literal \                  |
+			'\\'         transparent          literal \\                       literal \\                        literal \                  |
+			----------   ------------------   ------------------------------   -------------------------------   -------------------------- | ------------------
+			'            transparent          unbalanced quote error           ...                               ...                        |
+			\'           transparent          literal \ and unb. quote error   ...                               ...                        |
+			\''          transparent          literal \ and empty string       literal \                         regex error                | no, but given as example above
+			'''          transparent          unbalanced quote error           ...                               ...                        |
+			''''         transparent          literal '                        literal '                         literal '                  | yes
+			----------   ------------------   ------------------------------   -------------------------------   -------------------------- | ------------------
+
+			⁰: charatecter or characters 'x' as an argument to a program in go's call: exec.Command("program.exe", `x`)
+			¹: native commands like grep, git grep, ripgrep
+			²: interpreted as a grouping quote, affects argument parser and gets removed from the result
+
+			[CommandLineToArgvW]: https://docs.microsoft.com/en-gb/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw#remarks
+			[NativeCallsFromPowershell]: https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_parsing?view=powershell-7.1#passing-arguments-that-contain-quote-characters
+		*/
+
+		// 1) working examples
+
+		{give{`Get-Content {}`, ``, newItems(`C:\test.txt`)}, want{output: `Get-Content 'C:\test.txt'`}},
+		{give{`rg -- "package" {}`, ``, newItems(`.\test.go`)}, want{output: `rg -- "package" '.\test.go'`}},
+
+		// example of escaping single quotes
+		{give{`rg -- {}`, ``, newItems(`'foobar'`)}, want{output: `rg -- '''foobar'''`}},
+
+		// chaining powershells
+		{give{`powershell -NoProfile -Command {}`, ``, newItems(`cat "C:\test.txt"`)}, want{output: `powershell -NoProfile -Command 'cat \"C:\test.txt\"'`}},
+
+		// 2) problematic examples
+		// (not necessarily unexpected)
+
+		// looking for a path string will only work with escaped backslashes
+		{give{`rg -- {}`, ``, newItems(`C:\test.txt`)}, want{output: `rg -- 'C:\test.txt'`}},
+		// looking for a literal double quote will only work with triple escaped double quotes
+		{give{`rg -- {}`, ``, newItems(`"C:\test.txt"`)}, want{output: `rg -- '\"C:\test.txt\"'`}},
+
+		// Get-Content (i.e. cat alias) is parsing `"` as a part of the file path, returns an error:
+		// Get-Content : Cannot find drive. A drive with the name '"C:' does not exist.
+		{give{`cat {}`, ``, newItems(`"C:\test.txt"`)}, want{output: `cat '\"C:\test.txt\"'`}},
+
+		// the "file" flag in the pattern won't create *.ps1 file so the powershell will offload this "unknown" filetype
+		// to explorer, which will prompt user to pick editing program for the fzf-preview file
+		// the temp file contains: `cat "C:\test.txt"`
+		// TODO this should actually work
+		{give{`powershell -NoProfile -Command {f}`, ``, newItems(`cat "C:\test.txt"`)}, want{match: `^powershell -NoProfile -Command .*\fzf-preview-[0-9]{9}$`}},
+	}
+
+	// to force powershell-style escaping we temporarily set environment variable that fzf honors
+	shellBackup := os.Getenv("SHELL")
+	os.Setenv("SHELL", "powershell")
+	testCommands(t, tests)
+	os.Setenv("SHELL", shellBackup)
+}
+
+/*
+	Test typical valid placeholders and parsing of them.
+
+	Also since the parser assumes the input is matched with `placeholder` regex,
+	the regex is tested here as well.
+*/
+func TestParsePlaceholder(t *testing.T) {
+	// give, want pairs
+	templates := map[string]string{
+		// I. item type placeholder
+		`{}`:    `{}`,
+		`{+}`:   `{+}`,
+		`{n}`:   `{n}`,
+		`{+n}`:  `{+n}`,
+		`{f}`:   `{f}`,
+		`{+nf}`: `{+nf}`,
+
+		// II. token type placeholders
+		`{..}`:     `{..}`,
+		`{1..}`:    `{1..}`,
+		`{..2}`:    `{..2}`,
+		`{1..2}`:   `{1..2}`,
+		`{-2..-1}`: `{-2..-1}`,
+		// shorthand for x..x range
+		`{1}`:    `{1}`,
+		`{1..1}`: `{1..1}`,
+		`{-6}`:   `{-6}`,
+		// multiple ranges
+		`{1,2}`:         `{1,2}`,
+		`{1,2,4}`:       `{1,2,4}`,
+		`{1,2..4}`:      `{1,2..4}`,
+		`{1..2,-4..-3}`: `{1..2,-4..-3}`,
+		// flags
+		`{+1}`:      `{+1}`,
+		`{+-1}`:     `{+-1}`,
+		`{s1}`:      `{s1}`,
+		`{f1}`:      `{f1}`,
+		`{+s1..2}`:  `{+s1..2}`,
+		`{+sf1..2}`: `{+sf1..2}`,
+
+		// III. query type placeholder
+		// query flag is not removed after parsing, so it gets doubled
+		// while the double q is invalid, it is useful here for testing purposes
+		`{q}`: `{qq}`,
+
+		// IV. escaping placeholder
+		`\{}`:   `{}`,
+		`\{++}`: `{++}`,
+		`{++}`:  `{+}`,
+	}
+
+	for giveTemplate, wantTemplate := range templates {
+		if !placeholder.MatchString(giveTemplate) {
+			t.Errorf(`given placeholder %s does not match placeholder regex, so attempt to parse it is unexpected`, giveTemplate)
+			continue
+		}
+
+		_, placeholderWithoutFlags, flags := parsePlaceholder(giveTemplate)
+		gotTemplate := placeholderWithoutFlags[:1] + flags.encodePlaceholder() + placeholderWithoutFlags[1:]
+
+		if gotTemplate != wantTemplate {
+			t.Errorf(`parsed placeholder "%s" into "%s", but want "%s"`, giveTemplate, gotTemplate, wantTemplate)
+		}
+	}
+}
+
+/* utilities section */
+
+// Item represents one line in fzf UI. Usually it is relative path to files and folders.
+func newItem(str string) *Item {
+	bytes := []byte(str)
+	trimmed, _, _ := extractColor(str, nil, nil)
+	return &Item{origText: &bytes, text: util.ToChars([]byte(trimmed))}
+}
+
+// Functions tested in this file require array of items (allItems). The array needs
+// to consist of at least two nils. This is helper function.
+func newItems(str ...string) []*Item {
+	result := make([]*Item, util.Max(len(str), 2))
+	for i, s := range str {
+		result[i] = newItem(s)
+	}
+	return result
+}
+
+// (for logging purposes)
+func (item *Item) String() string {
+	return item.AsString(true)
+}
+
+// Helper function to parse, execute and convert "text/template" to string. Panics on error.
+func templateToString(format string, data interface{}) string {
+	bb := &bytes.Buffer{}
+
+	err := template.Must(template.New("").Parse(format)).Execute(bb, data)
+	if err != nil {
+		panic(err)
+	}
+
+	return bb.String()
+}
+
+// ad hoc types for test cases
+type give struct {
+	template string
+	query    string
+	allItems []*Item
+}
+type want struct {
+	/*
+		Unix:
+		The `want.output` string is supposed to be formatted for evaluation by
+		`sh -c command` system call.
+
+		Windows:
+		The `want.output` string is supposed to be formatted for evaluation by
+		`cmd.exe /s /c "command"` system call. The `/s` switch enables so called old
+		behaviour, which is more favourable for nesting (possibly escaped)
+		special characters. This is the relevant section of `help cmd`:
+
+		...old behavior is to see if the first character is
+		a quote character and if so, strip the leading character and
+		remove the last quote character on the command line, preserving
+		any text after the last quote character.
+	*/
+	output string // literal output
+	match  string // output is matched against this regex (when output is empty string)
+}
+type testCase struct {
+	give
+	want
+}
+
+func testCommands(t *testing.T, tests []testCase) {
+	// common test parameters
+	delim := "\t"
+	delimiter := Delimiter{str: &delim}
+	printsep := ""
+	stripAnsi := false
+	forcePlus := false
+
+	// evaluate the test cases
+	for idx, test := range tests {
+		gotOutput := replacePlaceholder(
+			test.give.template, stripAnsi, delimiter, printsep, forcePlus,
+			test.give.query,
+			test.give.allItems)
+		switch {
+		case test.want.output != "":
+			if gotOutput != test.want.output {
+				t.Errorf("tests[%v]:\ngave{\n\ttemplate: '%s',\n\tquery: '%s',\n\tallItems: %s}\nand got '%s',\nbut want '%s'",
+					idx,
+					test.give.template, test.give.query, test.give.allItems,
+					gotOutput, test.want.output)
+			}
+		case test.want.match != "":
+			wantMatch := strings.ReplaceAll(test.want.match, `\`, `\\`)
+			wantRegex := regexp.MustCompile(wantMatch)
+			if !wantRegex.MatchString(gotOutput) {
+				t.Errorf("tests[%v]:\ngave{\n\ttemplate: '%s',\n\tquery: '%s',\n\tallItems: %s}\nand got '%s',\nbut want '%s'",
+					idx,
+					test.give.template, test.give.query, test.give.allItems,
+					gotOutput, test.want.match)
+			}
+		default:
+			t.Errorf("tests[%v]: test case does not describe 'want' property", idx)
+		}
+	}
+}
+
+// naive encoder of placeholder flags
+func (flags placeholderFlags) encodePlaceholder() string {
+	encoded := ""
+	if flags.plus {
+		encoded += "+"
+	}
+	if flags.preserveSpace {
+		encoded += "s"
+	}
+	if flags.number {
+		encoded += "n"
+	}
+	if flags.file {
+		encoded += "f"
+	}
+	if flags.query {
+		encoded += "q"
+	}
+	return encoded
+}
+
+// can be replaced with os.ReadFile() in go 1.16+
+func readFile(path string) ([]byte, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	data := make([]byte, 0, 128)
+	for {
+		if len(data) >= cap(data) {
+			d := append(data[:cap(data)], 0)
+			data = d[:len(data)]
+		}
+
+		n, err := file.Read(data[len(data):cap(data)])
+		data = data[:len(data)+n]
+		if err != nil {
+			if err == io.EOF {
+				err = nil
+			}
+			return data, err
+		}
+	}
+}

src/terminal_unix.go

@@ -0,0 +1,26 @@
+// +build !windows
+
+package fzf
+
+import (
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+)
+
+func notifyOnResize(resizeChan chan<- os.Signal) {
+	signal.Notify(resizeChan, syscall.SIGWINCH)
+}
+
+func notifyStop(p *os.Process) {
+	p.Signal(syscall.SIGSTOP)
+}
+
+func notifyOnCont(resizeChan chan<- os.Signal) {
+	signal.Notify(resizeChan, syscall.SIGCONT)
+}
+
+func quoteEntry(entry string) string {
+	return "'" + strings.Replace(entry, "'", "'\\''", -1) + "'"
+}

src/terminal_windows.go

@@ -0,0 +1,45 @@
+// +build windows
+
+package fzf
+
+import (
+	"os"
+	"regexp"
+	"strings"
+)
+
+func notifyOnResize(resizeChan chan<- os.Signal) {
+	// TODO
+}
+
+func notifyStop(p *os.Process) {
+	// NOOP
+}
+
+func notifyOnCont(resizeChan chan<- os.Signal) {
+	// NOOP
+}
+
+func quoteEntry(entry string) string {
+	shell := os.Getenv("SHELL")
+	if len(shell) == 0 {
+		shell = "cmd"
+	}
+
+	if strings.Contains(shell, "cmd") {
+		// backslash escaping is done here for applications
+		// (see ripgrep test case in terminal_test.go#TestWindowsCommands)
+		escaped := strings.Replace(entry, `\`, `\\`, -1)
+		escaped = `"` + strings.Replace(escaped, `"`, `\"`, -1) + `"`
+		// caret is the escape character for cmd shell
+		r, _ := regexp.Compile(`[&|<>()@^%!"]`)
+		return r.ReplaceAllStringFunc(escaped, func(match string) string {
+			return "^" + match
+		})
+	} else if strings.Contains(shell, "pwsh") || strings.Contains(shell, "powershell") {
+		escaped := strings.Replace(entry, `"`, `\"`, -1)
+		return "'" + strings.Replace(escaped, "'", "''", -1) + "'"
+	} else {
+		return "'" + strings.Replace(entry, "'", "'\\''", -1) + "'"
+	}
+}

src/tokenizer.go

@@ -1,6 +1,8 @@
 package fzf
 
 import (
+	"bytes"
+	"fmt"
 	"regexp"
 	"strconv"
 	"strings"
@@ -18,9 +20,13 @@ type Range struct {
 
 // Token contains the tokenized part of the strings and its prefix length
 type Token struct {
-	text         []rune
+	text         *util.Chars
-	prefixLength int
+	prefixLength int32
-	trimLength   int
+}
+
+// String returns the string representation of a Token.
+func (t Token) String() string {
+	return fmt.Sprintf("Token{text: %s, prefixLength: %d}", t.text, t.prefixLength)
 }
 
 // Delimiter for tokenizing the input
@@ -29,6 +35,11 @@ type Delimiter struct {
 	str   *string
 }
 
+// String returns the string representation of a Delimiter.
+func (d Delimiter) String() string {
+	return fmt.Sprintf("Delimiter{regex: %v, str: &%q}", d.regex, *d.str)
+}
+
 func newRange(begin int, end int) Range {
 	if begin == 1 {
 		begin = rangeEllipsis
@@ -75,15 +86,14 @@ func ParseRange(str *string) (Range, bool) {
 	return newRange(n, n), true
 }
 
-func withPrefixLengths(tokens [][]rune, begin int) []Token {
+func withPrefixLengths(tokens []string, begin int) []Token {
 	ret := make([]Token, len(tokens))
 
 	prefixLength := begin
-	for idx, token := range tokens {
+	for idx := range tokens {
-		// Need to define a new local variable instead of the reused token to take
+		chars := util.ToChars([]byte(tokens[idx]))
-		// the pointer to it
+		ret[idx] = Token{&chars, int32(prefixLength)}
-		ret[idx] = Token{token, prefixLength, util.TrimLen(token)}
+		prefixLength += chars.Length()
-		prefixLength += len(token)
 	}
 	return ret
 }
@@ -94,90 +104,77 @@ const (
 	awkWhite
 )
 
-func awkTokenizer(input []rune) ([][]rune, int) {
+func awkTokenizer(input string) ([]string, int) {
 	// 9, 32
-	ret := [][]rune{}
+	ret := []string{}
-	str := []rune{}
 	prefixLength := 0
 	state := awkNil
-	for _, r := range input {
+	begin := 0
+	end := 0
+	for idx := 0; idx < len(input); idx++ {
+		r := input[idx]
 		white := r == 9 || r == 32
 		switch state {
 		case awkNil:
 			if white {
 				prefixLength++
 			} else {
-				state = awkBlack
+				state, begin, end = awkBlack, idx, idx+1
-				str = append(str, r)
 			}
 		case awkBlack:
-			str = append(str, r)
+			end = idx + 1
 			if white {
 				state = awkWhite
 			}
 		case awkWhite:
 			if white {
-				str = append(str, r)
+				end = idx + 1
 			} else {
-				ret = append(ret, str)
+				ret = append(ret, input[begin:end])
-				state = awkBlack
+				state, begin, end = awkBlack, idx, idx+1
-				str = []rune{r}
 			}
 		}
 	}
-	if len(str) > 0 {
+	if begin < end {
-		ret = append(ret, str)
+		ret = append(ret, input[begin:end])
 	}
 	return ret, prefixLength
 }
 
 // Tokenize tokenizes the given string with the delimiter
-func Tokenize(runes []rune, delimiter Delimiter) []Token {
+func Tokenize(text string, delimiter Delimiter) []Token {
 	if delimiter.str == nil && delimiter.regex == nil {
 		// AWK-style (\S+\s*)
-		tokens, prefixLength := awkTokenizer(runes)
+		tokens, prefixLength := awkTokenizer(text)
 		return withPrefixLengths(tokens, prefixLength)
 	}
 
-	var tokens []string
 	if delimiter.str != nil {
-		tokens = strings.Split(string(runes), *delimiter.str)
+		return withPrefixLengths(strings.SplitAfter(text, *delimiter.str), 0)
-		for i := 0; i < len(tokens)-1; i++ {
+	}
-			tokens[i] = tokens[i] + *delimiter.str
+
-		}
+	// FIXME performance
-	} else if delimiter.regex != nil {
+	var tokens []string
-		str := string(runes)
+	if delimiter.regex != nil {
-		for len(str) > 0 {
+		for len(text) > 0 {
-			loc := delimiter.regex.FindStringIndex(str)
+			loc := delimiter.regex.FindStringIndex(text)
-			if loc == nil {
+			if len(loc) < 2 {
-				loc = []int{0, len(str)}
+				loc = []int{0, len(text)}
 			}
 			last := util.Max(loc[1], 1)
-			tokens = append(tokens, str[:last])
+			tokens = append(tokens, text[:last])
-			str = str[last:]
+			text = text[last:]
 		}
 	}
-	asRunes := make([][]rune, len(tokens))
+	return withPrefixLengths(tokens, 0)
-	for i, token := range tokens {
-		asRunes[i] = []rune(token)
-	}
-	return withPrefixLengths(asRunes, 0)
 }
 
-func joinTokens(tokens []Token) []rune {
+func joinTokens(tokens []Token) string {
-	ret := []rune{}
+	var output bytes.Buffer
 	for _, token := range tokens {
-		ret = append(ret, token.text...)
+		output.WriteString(token.text.ToString())
 	}
-	return ret
+	return output.String()
-}
-
-func joinTokensAsRunes(tokens []Token) []rune {
-	ret := []rune{}
-	for _, token := range tokens {
-		ret = append(ret, token.text...)
-	}
-	return ret
 }
 
 // Transform is used to transform the input when --with-nth option is given
@@ -185,19 +182,20 @@ func Transform(tokens []Token, withNth []Range) []Token {
 	transTokens := make([]Token, len(withNth))
 	numTokens := len(tokens)
 	for idx, r := range withNth {
-		part := []rune{}
+		parts := []*util.Chars{}
 		minIdx := 0
 		if r.begin == r.end {
 			idx := r.begin
 			if idx == rangeEllipsis {
-				part = append(part, joinTokensAsRunes(tokens)...)
+				chars := util.ToChars([]byte(joinTokens(tokens)))
+				parts = append(parts, &chars)
 			} else {
 				if idx < 0 {
 					idx += numTokens + 1
 				}
 				if idx >= 1 && idx <= numTokens {
 					minIdx = idx - 1
-					part = append(part, tokens[idx-1].text...)
+					parts = append(parts, tokens[idx-1].text)
 				}
 			}
 		} else {
@@ -224,17 +222,32 @@ func Transform(tokens []Token, withNth []Range) []Token {
 			minIdx = util.Max(0, begin-1)
 			for idx := begin; idx <= end; idx++ {
 				if idx >= 1 && idx <= numTokens {
-					part = append(part, tokens[idx-1].text...)
+					parts = append(parts, tokens[idx-1].text)
 				}
 			}
 		}
-		var prefixLength int
+		// Merge multiple parts
+		var merged util.Chars
+		switch len(parts) {
+		case 0:
+			merged = util.ToChars([]byte{})
+		case 1:
+			merged = *parts[0]
+		default:
+			var output bytes.Buffer
+			for _, part := range parts {
+				output.WriteString(part.ToString())
+			}
+			merged = util.ToChars(output.Bytes())
+		}
+
+		var prefixLength int32
 		if minIdx < numTokens {
 			prefixLength = tokens[minIdx].prefixLength
 		} else {
 			prefixLength = 0
 		}
-		transTokens[idx] = Token{part, prefixLength, util.TrimLen(part)}
+		transTokens[idx] = Token{&merged, prefixLength}
 	}
 	return transTokens
 }

src/tokenizer_test.go

@@ -1,41 +1,43 @@
 package fzf
 
-import "testing"
+import (
+	"testing"
+)
 
 func TestParseRange(t *testing.T) {
 	{
 		i := ".."
 		r, _ := ParseRange(&i)
 		if r.begin != rangeEllipsis || r.end != rangeEllipsis {
-			t.Errorf("%s", r)
+			t.Errorf("%v", r)
 		}
 	}
 	{
 		i := "3.."
 		r, _ := ParseRange(&i)
 		if r.begin != 3 || r.end != rangeEllipsis {
-			t.Errorf("%s", r)
+			t.Errorf("%v", r)
 		}
 	}
 	{
 		i := "3..5"
 		r, _ := ParseRange(&i)
 		if r.begin != 3 || r.end != 5 {
-			t.Errorf("%s", r)
+			t.Errorf("%v", r)
 		}
 	}
 	{
 		i := "-3..-5"
 		r, _ := ParseRange(&i)
 		if r.begin != -3 || r.end != -5 {
-			t.Errorf("%s", r)
+			t.Errorf("%v", r)
 		}
 	}
 	{
 		i := "3"
 		r, _ := ParseRange(&i)
 		if r.begin != 3 || r.end != 3 {
-			t.Errorf("%s", r)
+			t.Errorf("%v", r)
 		}
 	}
 }
@@ -43,23 +45,23 @@ func TestParseRange(t *testing.T) {
 func TestTokenize(t *testing.T) {
 	// AWK-style
 	input := "  abc:  def:  ghi  "
-	tokens := Tokenize([]rune(input), Delimiter{})
+	tokens := Tokenize(input, Delimiter{})
-	if string(tokens[0].text) != "abc:  " || tokens[0].prefixLength != 2 || tokens[0].trimLength != 4 {
+	if tokens[0].text.ToString() != "abc:  " || tokens[0].prefixLength != 2 {
 		t.Errorf("%s", tokens)
 	}
 
 	// With delimiter
-	tokens = Tokenize([]rune(input), delimiterRegexp(":"))
+	tokens = Tokenize(input, delimiterRegexp(":"))
-	if string(tokens[0].text) != "  abc:" || tokens[0].prefixLength != 0 || tokens[0].trimLength != 4 {
+	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([]rune(input), delimiterRegexp("\\s+"))
+	tokens = Tokenize(input, delimiterRegexp("\\s+"))
-	if string(tokens[0].text) != "  " || tokens[0].prefixLength != 0 || tokens[0].trimLength != 0 ||
+	if tokens[0].text.ToString() != "  " || tokens[0].prefixLength != 0 ||
-		string(tokens[1].text) != "abc:  " || tokens[1].prefixLength != 2 || tokens[1].trimLength != 4 ||
+		tokens[1].text.ToString() != "abc:  " || tokens[1].prefixLength != 2 ||
-		string(tokens[2].text) != "def:  " || tokens[2].prefixLength != 8 || tokens[2].trimLength != 4 ||
+		tokens[2].text.ToString() != "def:  " || tokens[2].prefixLength != 8 ||
-		string(tokens[3].text) != "ghi  " || tokens[3].prefixLength != 14 || tokens[3].trimLength != 3 {
+		tokens[3].text.ToString() != "ghi  " || tokens[3].prefixLength != 14 {
 		t.Errorf("%s", tokens)
 	}
 }
@@ -67,11 +69,11 @@ func TestTokenize(t *testing.T) {
 func TestTransform(t *testing.T) {
 	input := "  abc:  def:  ghi:  jkl"
 	{
-		tokens := Tokenize([]rune(input), Delimiter{})
+		tokens := Tokenize(input, Delimiter{})
 		{
 			ranges := splitNth("1,2,3")
 			tx := Transform(tokens, ranges)
-			if string(joinTokens(tx)) != "abc:  def:  ghi:  " {
+			if joinTokens(tx) != "abc:  def:  ghi:  " {
 				t.Errorf("%s", tx)
 			}
 		}
@@ -80,25 +82,25 @@ func TestTransform(t *testing.T) {
 			tx := Transform(tokens, ranges)
 			if string(joinTokens(tx)) != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
 				len(tx) != 4 ||
-				string(tx[0].text) != "abc:  def:  " || tx[0].prefixLength != 2 ||
+				tx[0].text.ToString() != "abc:  def:  " || tx[0].prefixLength != 2 ||
-				string(tx[1].text) != "ghi:  " || tx[1].prefixLength != 14 ||
+				tx[1].text.ToString() != "ghi:  " || tx[1].prefixLength != 14 ||
-				string(tx[2].text) != "def:  ghi:  jkl" || tx[2].prefixLength != 8 ||
+				tx[2].text.ToString() != "def:  ghi:  jkl" || tx[2].prefixLength != 8 ||
-				string(tx[3].text) != "abc:  " || tx[3].prefixLength != 2 {
+				tx[3].text.ToString() != "abc:  " || tx[3].prefixLength != 2 {
 				t.Errorf("%s", tx)
 			}
 		}
 	}
 	{
-		tokens := Tokenize([]rune(input), delimiterRegexp(":"))
+		tokens := Tokenize(input, delimiterRegexp(":"))
 		{
 			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
-			if string(joinTokens(tx)) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
+			if joinTokens(tx) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
 				len(tx) != 4 ||
-				string(tx[0].text) != "  abc:  def:" || tx[0].prefixLength != 0 ||
+				tx[0].text.ToString() != "  abc:  def:" || tx[0].prefixLength != 0 ||
-				string(tx[1].text) != "  ghi:" || tx[1].prefixLength != 12 ||
+				tx[1].text.ToString() != "  ghi:" || tx[1].prefixLength != 12 ||
-				string(tx[2].text) != "  def:  ghi:  jkl" || tx[2].prefixLength != 6 ||
+				tx[2].text.ToString() != "  def:  ghi:  jkl" || tx[2].prefixLength != 6 ||
-				string(tx[3].text) != "  abc:" || tx[3].prefixLength != 0 {
+				tx[3].text.ToString() != "  abc:" || tx[3].prefixLength != 0 {
 				t.Errorf("%s", tx)
 			}
 		}

src/tui/dummy.go

@@ -0,0 +1,46 @@
+// +build !ncurses
+// +build !tcell
+// +build !windows
+
+package tui
+
+type Attr int32
+
+func HasFullscreenRenderer() bool {
+	return false
+}
+
+func (a Attr) Merge(b Attr) Attr {
+	return a | b
+}
+
+const (
+	AttrUndefined = Attr(0)
+	AttrRegular   = Attr(1 << 7)
+	AttrClear     = Attr(1 << 8)
+
+	Bold      = Attr(1)
+	Dim       = Attr(1 << 1)
+	Italic    = Attr(1 << 2)
+	Underline = Attr(1 << 3)
+	Blink     = Attr(1 << 4)
+	Blink2    = Attr(1 << 5)
+	Reverse   = Attr(1 << 6)
+)
+
+func (r *FullscreenRenderer) Init()             {}
+func (r *FullscreenRenderer) Pause(bool)        {}
+func (r *FullscreenRenderer) Resume(bool, bool) {}
+func (r *FullscreenRenderer) Clear()            {}
+func (r *FullscreenRenderer) Refresh()          {}
+func (r *FullscreenRenderer) Close()            {}
+
+func (r *FullscreenRenderer) GetChar() Event { return Event{} }
+func (r *FullscreenRenderer) MaxX() int      { return 0 }
+func (r *FullscreenRenderer) MaxY() int      { return 0 }
+
+func (r *FullscreenRenderer) RefreshWindows(windows []Window) {}
+
+func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
+	return nil
+}

src/tui/light.go

@@ -0,0 +1,987 @@
+package tui
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/mattn/go-runewidth"
+	"github.com/rivo/uniseg"
+
+	"golang.org/x/term"
+)
+
+const (
+	defaultWidth  = 80
+	defaultHeight = 24
+
+	defaultEscDelay = 100
+	escPollInterval = 5
+	offsetPollTries = 10
+	maxInputBuffer  = 10 * 1024
+)
+
+const consoleDevice string = "/dev/tty"
+
+var offsetRegexp *regexp.Regexp = regexp.MustCompile("(.*)\x1b\\[([0-9]+);([0-9]+)R")
+var offsetRegexpBegin *regexp.Regexp = regexp.MustCompile("^\x1b\\[[0-9]+;[0-9]+R")
+
+func (r *LightRenderer) stderr(str string) {
+	r.stderrInternal(str, true)
+}
+
+// FIXME: Need better handling of non-displayable characters
+func (r *LightRenderer) stderrInternal(str string, allowNLCR bool) {
+	bytes := []byte(str)
+	runes := []rune{}
+	for len(bytes) > 0 {
+		r, sz := utf8.DecodeRune(bytes)
+		nlcr := r == '\n' || r == '\r'
+		if r >= 32 || r == '\x1b' || nlcr {
+			if r == utf8.RuneError || nlcr && !allowNLCR {
+				runes = append(runes, ' ')
+			} else {
+				runes = append(runes, r)
+			}
+		}
+		bytes = bytes[sz:]
+	}
+	r.queued.WriteString(string(runes))
+}
+
+func (r *LightRenderer) csi(code string) {
+	r.stderr("\x1b[" + code)
+}
+
+func (r *LightRenderer) flush() {
+	if r.queued.Len() > 0 {
+		fmt.Fprint(os.Stderr, r.queued.String())
+		r.queued.Reset()
+	}
+}
+
+// Light renderer
+type LightRenderer struct {
+	theme         *ColorTheme
+	mouse         bool
+	forceBlack    bool
+	clearOnExit   bool
+	prevDownTime  time.Time
+	clickY        []int
+	ttyin         *os.File
+	buffer        []byte
+	origState     *term.State
+	width         int
+	height        int
+	yoffset       int
+	tabstop       int
+	escDelay      int
+	fullscreen    bool
+	upOneLine     bool
+	queued        strings.Builder
+	y             int
+	x             int
+	maxHeightFunc func(int) int
+
+	// Windows only
+	ttyinChannel    chan byte
+	inHandle        uintptr
+	outHandle       uintptr
+	origStateInput  uint32
+	origStateOutput uint32
+}
+
+type LightWindow struct {
+	renderer *LightRenderer
+	colored  bool
+	preview  bool
+	border   BorderStyle
+	top      int
+	left     int
+	width    int
+	height   int
+	posx     int
+	posy     int
+	tabstop  int
+	fg       Color
+	bg       Color
+}
+
+func NewLightRenderer(theme *ColorTheme, forceBlack bool, mouse bool, tabstop int, clearOnExit bool, fullscreen bool, maxHeightFunc func(int) int) Renderer {
+	r := LightRenderer{
+		theme:         theme,
+		forceBlack:    forceBlack,
+		mouse:         mouse,
+		clearOnExit:   clearOnExit,
+		ttyin:         openTtyIn(),
+		yoffset:       0,
+		tabstop:       tabstop,
+		fullscreen:    fullscreen,
+		upOneLine:     false,
+		maxHeightFunc: maxHeightFunc}
+	return &r
+}
+
+func repeat(r rune, times int) string {
+	if times > 0 {
+		return strings.Repeat(string(r), times)
+	}
+	return ""
+}
+
+func atoi(s string, defaultValue int) int {
+	value, err := strconv.Atoi(s)
+	if err != nil {
+		return defaultValue
+	}
+	return value
+}
+
+func (r *LightRenderer) Init() {
+	r.escDelay = atoi(os.Getenv("ESCDELAY"), defaultEscDelay)
+
+	if err := r.initPlatform(); err != nil {
+		errorExit(err.Error())
+	}
+	r.updateTerminalSize()
+	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
+
+	if r.fullscreen {
+		r.smcup()
+	} else {
+		// 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
+		// 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()
+		}
+		for i := 1; i < r.MaxY(); i++ {
+			r.makeSpace()
+		}
+	}
+
+	if r.mouse {
+		r.csi("?1000h")
+	}
+	r.csi(fmt.Sprintf("%dA", r.MaxY()-1))
+	r.csi("G")
+	r.csi("K")
+	if !r.clearOnExit && !r.fullscreen {
+		r.csi("s")
+	}
+	if !r.fullscreen && r.mouse {
+		r.yoffset, _ = r.findOffset()
+	}
+}
+
+func (r *LightRenderer) makeSpace() {
+	r.stderr("\n")
+	r.csi("G")
+}
+
+func (r *LightRenderer) move(y int, x int) {
+	// w.csi("u")
+	if r.y < y {
+		r.csi(fmt.Sprintf("%dB", y-r.y))
+	} else if r.y > y {
+		r.csi(fmt.Sprintf("%dA", r.y-y))
+	}
+	r.stderr("\r")
+	if x > 0 {
+		r.csi(fmt.Sprintf("%dC", x))
+	}
+	r.y = y
+	r.x = x
+}
+
+func (r *LightRenderer) origin() {
+	r.move(0, 0)
+}
+
+func getEnv(name string, defaultValue int) int {
+	env := os.Getenv(name)
+	if len(env) == 0 {
+		return defaultValue
+	}
+	return atoi(env, defaultValue)
+}
+
+func (r *LightRenderer) getBytes() []byte {
+	return r.getBytesInternal(r.buffer, false)
+}
+
+func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
+	c, ok := r.getch(nonblock)
+	if !nonblock && !ok {
+		r.Close()
+		errorExit("Failed to read " + consoleDevice)
+	}
+
+	retries := 0
+	if c == ESC.Int() || nonblock {
+		retries = r.escDelay / escPollInterval
+	}
+	buffer = append(buffer, byte(c))
+
+	pc := c
+	for {
+		c, ok = r.getch(true)
+		if !ok {
+			if retries > 0 {
+				retries--
+				time.Sleep(escPollInterval * time.Millisecond)
+				continue
+			}
+			break
+		} else if c == ESC.Int() && pc != c {
+			retries = r.escDelay / escPollInterval
+		} else {
+			retries = 0
+		}
+		buffer = append(buffer, byte(c))
+		pc = c
+
+		// This should never happen under normal conditions,
+		// so terminate fzf immediately.
+		if len(buffer) > maxInputBuffer {
+			r.Close()
+			panic(fmt.Sprintf("Input buffer overflow (%d): %v", len(buffer), buffer))
+		}
+	}
+
+	return buffer
+}
+
+func (r *LightRenderer) GetChar() Event {
+	if len(r.buffer) == 0 {
+		r.buffer = r.getBytes()
+	}
+	if len(r.buffer) == 0 {
+		panic("Empty buffer")
+	}
+
+	sz := 1
+	defer func() {
+		r.buffer = r.buffer[sz:]
+	}()
+
+	switch r.buffer[0] {
+	case CtrlC.Byte():
+		return Event{CtrlC, 0, nil}
+	case CtrlG.Byte():
+		return Event{CtrlG, 0, nil}
+	case CtrlQ.Byte():
+		return Event{CtrlQ, 0, nil}
+	case 127:
+		return Event{BSpace, 0, nil}
+	case 0:
+		return Event{CtrlSpace, 0, nil}
+	case 28:
+		return Event{CtrlBackSlash, 0, nil}
+	case 29:
+		return Event{CtrlRightBracket, 0, nil}
+	case 30:
+		return Event{CtrlCaret, 0, nil}
+	case 31:
+		return Event{CtrlSlash, 0, nil}
+	case ESC.Byte():
+		ev := r.escSequence(&sz)
+		// Second chance
+		if ev.Type == Invalid {
+			r.buffer = r.getBytes()
+			ev = r.escSequence(&sz)
+		}
+		return ev
+	}
+
+	// CTRL-A ~ CTRL-Z
+	if r.buffer[0] <= CtrlZ.Byte() {
+		return Event{EventType(r.buffer[0]), 0, nil}
+	}
+	char, rsz := utf8.DecodeRune(r.buffer)
+	if char == utf8.RuneError {
+		return Event{ESC, 0, nil}
+	}
+	sz = rsz
+	return Event{Rune, char, nil}
+}
+
+func (r *LightRenderer) escSequence(sz *int) Event {
+	if len(r.buffer) < 2 {
+		return Event{ESC, 0, nil}
+	}
+
+	loc := offsetRegexpBegin.FindIndex(r.buffer)
+	if loc != nil && loc[0] == 0 {
+		*sz = loc[1]
+		return Event{Invalid, 0, nil}
+	}
+
+	*sz = 2
+	if r.buffer[1] >= 1 && r.buffer[1] <= 'z'-'a'+1 {
+		return CtrlAltKey(rune(r.buffer[1] + 'a' - 1))
+	}
+	alt := false
+	if len(r.buffer) > 2 && r.buffer[1] == ESC.Byte() {
+		r.buffer = r.buffer[1:]
+		alt = true
+	}
+	switch r.buffer[1] {
+	case ESC.Byte():
+		return Event{ESC, 0, nil}
+	case 127:
+		return Event{AltBS, 0, nil}
+	case '[', 'O':
+		if len(r.buffer) < 3 {
+			return Event{Invalid, 0, nil}
+		}
+		*sz = 3
+		switch r.buffer[2] {
+		case 'D':
+			if alt {
+				return Event{AltLeft, 0, nil}
+			}
+			return Event{Left, 0, nil}
+		case 'C':
+			if alt {
+				// Ugh..
+				return Event{AltRight, 0, nil}
+			}
+			return Event{Right, 0, nil}
+		case 'B':
+			if alt {
+				return Event{AltDown, 0, nil}
+			}
+			return Event{Down, 0, nil}
+		case 'A':
+			if alt {
+				return Event{AltUp, 0, nil}
+			}
+			return Event{Up, 0, nil}
+		case 'Z':
+			return Event{BTab, 0, nil}
+		case 'H':
+			return Event{Home, 0, nil}
+		case 'F':
+			return Event{End, 0, nil}
+		case 'M':
+			return r.mouseSequence(sz)
+		case 'P':
+			return Event{F1, 0, nil}
+		case 'Q':
+			return Event{F2, 0, nil}
+		case 'R':
+			return Event{F3, 0, nil}
+		case 'S':
+			return Event{F4, 0, nil}
+		case '1', '2', '3', '4', '5', '6':
+			if len(r.buffer) < 4 {
+				return Event{Invalid, 0, nil}
+			}
+			*sz = 4
+			switch r.buffer[2] {
+			case '2':
+				if r.buffer[3] == '~' {
+					return Event{Insert, 0, nil}
+				}
+				if len(r.buffer) > 4 && r.buffer[4] == '~' {
+					*sz = 5
+					switch r.buffer[3] {
+					case '0':
+						return Event{F9, 0, nil}
+					case '1':
+						return Event{F10, 0, nil}
+					case '3':
+						return Event{F11, 0, nil}
+					case '4':
+						return Event{F12, 0, nil}
+					}
+				}
+				// Bracketed paste mode: \e[200~ ... \e[201~
+				if len(r.buffer) > 5 && 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 '3':
+				return Event{Del, 0, nil}
+			case '4':
+				return Event{End, 0, nil}
+			case '5':
+				return Event{PgUp, 0, nil}
+			case '6':
+				return Event{PgDn, 0, nil}
+			case '1':
+				switch r.buffer[3] {
+				case '~':
+					return Event{Home, 0, nil}
+				case '1', '2', '3', '4', '5', '7', '8', '9':
+					if len(r.buffer) == 5 && r.buffer[4] == '~' {
+						*sz = 5
+						switch r.buffer[3] {
+						case '1':
+							return Event{F1, 0, nil}
+						case '2':
+							return Event{F2, 0, nil}
+						case '3':
+							return Event{F3, 0, nil}
+						case '4':
+							return Event{F4, 0, nil}
+						case '5':
+							return Event{F5, 0, nil}
+						case '7':
+							return Event{F6, 0, nil}
+						case '8':
+							return Event{F7, 0, nil}
+						case '9':
+							return Event{F8, 0, nil}
+						}
+					}
+					return Event{Invalid, 0, nil}
+				case ';':
+					if len(r.buffer) < 6 {
+						return Event{Invalid, 0, nil}
+					}
+					*sz = 6
+					switch r.buffer[4] {
+					case '1', '2', '3', '5':
+						alt := r.buffer[4] == '3'
+						altShift := r.buffer[4] == '1' && r.buffer[5] == '0'
+						char := r.buffer[5]
+						if altShift {
+							if len(r.buffer) < 7 {
+								return Event{Invalid, 0, nil}
+							}
+							*sz = 7
+							char = r.buffer[6]
+						}
+						switch char {
+						case 'A':
+							if alt {
+								return Event{AltUp, 0, nil}
+							}
+							if altShift {
+								return Event{AltSUp, 0, nil}
+							}
+							return Event{SUp, 0, nil}
+						case 'B':
+							if alt {
+								return Event{AltDown, 0, nil}
+							}
+							if altShift {
+								return Event{AltSDown, 0, nil}
+							}
+							return Event{SDown, 0, nil}
+						case 'C':
+							if alt {
+								return Event{AltRight, 0, nil}
+							}
+							if altShift {
+								return Event{AltSRight, 0, nil}
+							}
+							return Event{SRight, 0, nil}
+						case 'D':
+							if alt {
+								return Event{AltLeft, 0, nil}
+							}
+							if altShift {
+								return Event{AltSLeft, 0, nil}
+							}
+							return Event{SLeft, 0, nil}
+						}
+					} // r.buffer[4]
+				} // r.buffer[3]
+			} // r.buffer[2]
+		} // r.buffer[2]
+	} // r.buffer[1]
+	rest := bytes.NewBuffer(r.buffer[1:])
+	c, size, err := rest.ReadRune()
+	if err == nil {
+		*sz = 1 + size
+		return AltKey(c)
+	}
+	return Event{Invalid, 0, nil}
+}
+
+func (r *LightRenderer) mouseSequence(sz *int) Event {
+	if len(r.buffer) < 6 || !r.mouse {
+		return Event{Invalid, 0, nil}
+	}
+	*sz = 6
+	switch r.buffer[3] {
+	case 32, 34, 36, 40, 48, // mouse-down / shift / cmd / ctrl
+		35, 39, 43, 51: // mouse-up / shift / cmd / ctrl
+		mod := r.buffer[3] >= 36
+		left := r.buffer[3] == 32
+		down := r.buffer[3]%2 == 0
+		x := int(r.buffer[4] - 33)
+		y := int(r.buffer[5]-33) - r.yoffset
+		double := false
+		if down {
+			now := time.Now()
+			if !left { // Right double click is not allowed
+				r.clickY = []int{}
+			} else if now.Sub(r.prevDownTime) < doubleClickDuration {
+				r.clickY = append(r.clickY, y)
+			} else {
+				r.clickY = []int{y}
+			}
+			r.prevDownTime = now
+		} else {
+			if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
+				time.Since(r.prevDownTime) < doubleClickDuration {
+				double = true
+			}
+		}
+
+		return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
+	case 96, 100, 104, 112, // scroll-up / shift / cmd / ctrl
+		97, 101, 105, 113: // scroll-down / shift / cmd / ctrl
+		mod := r.buffer[3] >= 100
+		s := 1 - int(r.buffer[3]%2)*2
+		x := int(r.buffer[4] - 33)
+		y := int(r.buffer[5]-33) - r.yoffset
+		return Event{Mouse, 0, &MouseEvent{y, x, s, false, false, false, mod}}
+	}
+	return Event{Invalid, 0, nil}
+}
+
+func (r *LightRenderer) smcup() {
+	r.csi("?1049h")
+}
+
+func (r *LightRenderer) rmcup() {
+	r.csi("?1049l")
+}
+
+func (r *LightRenderer) Pause(clear bool) {
+	r.restoreTerminal()
+	if clear {
+		if r.fullscreen {
+			r.rmcup()
+		} else {
+			r.smcup()
+			r.csi("H")
+		}
+		r.flush()
+	}
+}
+
+func (r *LightRenderer) Resume(clear bool, sigcont bool) {
+	r.setupTerminal()
+	if clear {
+		if r.fullscreen {
+			r.smcup()
+		} else {
+			r.rmcup()
+		}
+		r.flush()
+	} else if sigcont && !r.fullscreen && r.mouse {
+		// NOTE: SIGCONT (Coming back from CTRL-Z):
+		// It's highly likely that the offset we obtained at the beginning is
+		// no longer correct, so we simply disable mouse input.
+		r.csi("?1000l")
+		r.mouse = false
+	}
+}
+
+func (r *LightRenderer) Clear() {
+	if r.fullscreen {
+		r.csi("H")
+	}
+	// r.csi("u")
+	r.origin()
+	r.csi("J")
+	r.flush()
+}
+
+func (r *LightRenderer) RefreshWindows(windows []Window) {
+	r.flush()
+}
+
+func (r *LightRenderer) Refresh() {
+	r.updateTerminalSize()
+}
+
+func (r *LightRenderer) Close() {
+	// r.csi("u")
+	if r.clearOnExit {
+		if r.fullscreen {
+			r.rmcup()
+		} else {
+			r.origin()
+			if r.upOneLine {
+				r.csi("A")
+			}
+			r.csi("J")
+		}
+	} else if !r.fullscreen {
+		r.csi("u")
+	}
+	if r.mouse {
+		r.csi("?1000l")
+	}
+	r.flush()
+	r.closePlatform()
+	r.restoreTerminal()
+}
+
+func (r *LightRenderer) MaxX() int {
+	return r.width
+}
+
+func (r *LightRenderer) MaxY() int {
+	return r.height
+}
+
+func (r *LightRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
+	w := &LightWindow{
+		renderer: r,
+		colored:  r.theme.Colored,
+		preview:  preview,
+		border:   borderStyle,
+		top:      top,
+		left:     left,
+		width:    width,
+		height:   height,
+		tabstop:  r.tabstop,
+		fg:       colDefault,
+		bg:       colDefault}
+	if preview {
+		w.fg = r.theme.PreviewFg.Color
+		w.bg = r.theme.PreviewBg.Color
+	} else {
+		w.fg = r.theme.Fg.Color
+		w.bg = r.theme.Bg.Color
+	}
+	w.drawBorder()
+	return w
+}
+
+func (w *LightWindow) drawBorder() {
+	switch w.border.shape {
+	case BorderRounded, BorderSharp:
+		w.drawBorderAround()
+	case BorderHorizontal:
+		w.drawBorderHorizontal(true, true)
+	case BorderVertical:
+		w.drawBorderVertical(true, true)
+	case BorderTop:
+		w.drawBorderHorizontal(true, false)
+	case BorderBottom:
+		w.drawBorderHorizontal(false, true)
+	case BorderLeft:
+		w.drawBorderVertical(true, false)
+	case BorderRight:
+		w.drawBorderVertical(false, true)
+	}
+}
+
+func (w *LightWindow) drawBorderHorizontal(top, bottom bool) {
+	color := ColBorder
+	if w.preview {
+		color = ColPreviewBorder
+	}
+	if top {
+		w.Move(0, 0)
+		w.CPrint(color, repeat(w.border.horizontal, w.width))
+	}
+	if bottom {
+		w.Move(w.height-1, 0)
+		w.CPrint(color, repeat(w.border.horizontal, w.width))
+	}
+}
+
+func (w *LightWindow) drawBorderVertical(left, right bool) {
+	width := w.width - 2
+	if !left || !right {
+		width++
+	}
+	color := ColBorder
+	if w.preview {
+		color = ColPreviewBorder
+	}
+	for y := 0; y < w.height; y++ {
+		w.Move(y, 0)
+		if left {
+			w.CPrint(color, string(w.border.vertical))
+		}
+		w.CPrint(color, repeat(' ', width))
+		if right {
+			w.CPrint(color, string(w.border.vertical))
+		}
+	}
+}
+
+func (w *LightWindow) drawBorderAround() {
+	w.Move(0, 0)
+	color := ColBorder
+	if w.preview {
+		color = ColPreviewBorder
+	}
+	w.CPrint(color, string(w.border.topLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.topRight))
+	for y := 1; y < w.height-1; y++ {
+		w.Move(y, 0)
+		w.CPrint(color, string(w.border.vertical))
+		w.CPrint(color, repeat(' ', w.width-2))
+		w.CPrint(color, string(w.border.vertical))
+	}
+	w.Move(w.height-1, 0)
+	w.CPrint(color, string(w.border.bottomLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.bottomRight))
+}
+
+func (w *LightWindow) csi(code string) {
+	w.renderer.csi(code)
+}
+
+func (w *LightWindow) stderrInternal(str string, allowNLCR bool) {
+	w.renderer.stderrInternal(str, allowNLCR)
+}
+
+func (w *LightWindow) Top() int {
+	return w.top
+}
+
+func (w *LightWindow) Left() int {
+	return w.left
+}
+
+func (w *LightWindow) Width() int {
+	return w.width
+}
+
+func (w *LightWindow) Height() int {
+	return w.height
+}
+
+func (w *LightWindow) Refresh() {
+}
+
+func (w *LightWindow) Close() {
+}
+
+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)
+}
+
+func (w *LightWindow) Move(y int, x int) {
+	w.posx = x
+	w.posy = y
+
+	w.renderer.move(w.Top()+y, w.Left()+x)
+}
+
+func (w *LightWindow) MoveAndClear(y int, x int) {
+	w.Move(y, x)
+	// We should not delete preview window on the right
+	// csi("K")
+	w.Print(repeat(' ', w.width-x))
+	w.Move(y, x)
+}
+
+func attrCodes(attr Attr) []string {
+	codes := []string{}
+	if (attr & AttrClear) > 0 {
+		return codes
+	}
+	if (attr & Bold) > 0 {
+		codes = append(codes, "1")
+	}
+	if (attr & Dim) > 0 {
+		codes = append(codes, "2")
+	}
+	if (attr & Italic) > 0 {
+		codes = append(codes, "3")
+	}
+	if (attr & Underline) > 0 {
+		codes = append(codes, "4")
+	}
+	if (attr & Blink) > 0 {
+		codes = append(codes, "5")
+	}
+	if (attr & Reverse) > 0 {
+		codes = append(codes, "7")
+	}
+	return codes
+}
+
+func colorCodes(fg Color, bg Color) []string {
+	codes := []string{}
+	appendCode := func(c Color, offset int) {
+		if c == colDefault {
+			return
+		}
+		if c.is24() {
+			r := (c >> 16) & 0xff
+			g := (c >> 8) & 0xff
+			b := (c) & 0xff
+			codes = append(codes, fmt.Sprintf("%d;2;%d;%d;%d", 38+offset, r, g, b))
+		} else if c >= colBlack && c <= colWhite {
+			codes = append(codes, fmt.Sprintf("%d", int(c)+30+offset))
+		} else if c > colWhite && c < 16 {
+			codes = append(codes, fmt.Sprintf("%d", int(c)+90+offset-8))
+		} else if c >= 16 && c < 256 {
+			codes = append(codes, fmt.Sprintf("%d;5;%d", 38+offset, c))
+		}
+	}
+	appendCode(fg, 0)
+	appendCode(bg, 10)
+	return codes
+}
+
+func (w *LightWindow) csiColor(fg Color, bg Color, attr Attr) bool {
+	codes := append(attrCodes(attr), colorCodes(fg, bg)...)
+	w.csi(";" + strings.Join(codes, ";") + "m")
+	return len(codes) > 0
+}
+
+func (w *LightWindow) Print(text string) {
+	w.cprint2(colDefault, w.bg, AttrRegular, text)
+}
+
+func cleanse(str string) string {
+	return strings.Replace(str, "\x1b", "", -1)
+}
+
+func (w *LightWindow) CPrint(pair ColorPair, text string) {
+	w.csiColor(pair.Fg(), pair.Bg(), pair.Attr())
+	w.stderrInternal(cleanse(text), false)
+	w.csi("m")
+}
+
+func (w *LightWindow) cprint2(fg Color, bg Color, attr Attr, text string) {
+	if w.csiColor(fg, bg, attr) {
+		defer w.csi("m")
+	}
+	w.stderrInternal(cleanse(text), false)
+}
+
+type wrappedLine struct {
+	text         string
+	displayWidth int
+}
+
+func wrapLine(input string, prefixLength int, max int, tabstop int) []wrappedLine {
+	lines := []wrappedLine{}
+	width := 0
+	line := ""
+	gr := uniseg.NewGraphemes(input)
+	for gr.Next() {
+		rs := gr.Runes()
+		str := string(rs)
+		var w int
+		if len(rs) == 1 && rs[0] == '\t' {
+			w = tabstop - (prefixLength+width)%tabstop
+			str = repeat(' ', w)
+		} else {
+			w = runewidth.StringWidth(str)
+		}
+		width += w
+
+		if prefixLength+width <= max {
+			line += str
+		} else {
+			lines = append(lines, wrappedLine{string(line), width - w})
+			line = str
+			prefixLength = 0
+			width = w
+		}
+	}
+	lines = append(lines, wrappedLine{string(line), width})
+	return lines
+}
+
+func (w *LightWindow) fill(str string, onMove func()) FillReturn {
+	allLines := strings.Split(str, "\n")
+	for i, line := range allLines {
+		lines := wrapLine(line, w.posx, w.width, w.tabstop)
+		for j, wl := range lines {
+			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, w.posx)
+				w.Move(w.posy+1, 0)
+				onMove()
+			}
+		}
+	}
+	if w.posx+1 >= w.Width() {
+		if w.posy+1 >= w.height {
+			return FillSuspend
+		}
+		w.Move(w.posy+1, 0)
+		onMove()
+		return FillNextLine
+	}
+	return FillContinue
+}
+
+func (w *LightWindow) setBg() {
+	if w.bg != colDefault {
+		w.csiColor(colDefault, w.bg, AttrRegular)
+	}
+}
+
+func (w *LightWindow) Fill(text string) FillReturn {
+	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.Move(w.posy, w.posx)
+	if fg == colDefault {
+		fg = w.fg
+	}
+	if bg == colDefault {
+		bg = w.bg
+	}
+	if 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)
+	}
+}
+
+func (w *LightWindow) Erase() {
+	w.drawBorder()
+	// We don't erase the window here to avoid flickering during scroll
+	w.Move(0, 0)
+}

src/tui/light_unix.go

@@ -0,0 +1,110 @@
+// +build !windows
+
+package tui
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+
+	"github.com/junegunn/fzf/src/util"
+	"golang.org/x/term"
+)
+
+func IsLightRendererSupported() bool {
+	return true
+}
+
+func (r *LightRenderer) defaultTheme() *ColorTheme {
+	if strings.Contains(os.Getenv("TERM"), "256") {
+		return Dark256
+	}
+	colors, err := exec.Command("tput", "colors").Output()
+	if err == nil && atoi(strings.TrimSpace(string(colors)), 16) > 16 {
+		return Dark256
+	}
+	return Default16
+}
+
+func (r *LightRenderer) fd() int {
+	return int(r.ttyin.Fd())
+}
+
+func (r *LightRenderer) initPlatform() error {
+	fd := r.fd()
+	origState, err := term.GetState(fd)
+	if err != nil {
+		return err
+	}
+	r.origState = origState
+	term.MakeRaw(fd)
+	return nil
+}
+
+func (r *LightRenderer) closePlatform() {
+	// NOOP
+}
+
+func openTtyIn() *os.File {
+	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
+	if err != nil {
+		tty := ttyname()
+		if len(tty) > 0 {
+			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
+				return in
+			}
+		}
+		fmt.Fprintln(os.Stderr, "Failed to open "+consoleDevice)
+		os.Exit(2)
+	}
+	return in
+}
+
+func (r *LightRenderer) setupTerminal() {
+	term.MakeRaw(r.fd())
+}
+
+func (r *LightRenderer) restoreTerminal() {
+	term.Restore(r.fd(), r.origState)
+}
+
+func (r *LightRenderer) updateTerminalSize() {
+	width, height, err := term.GetSize(r.fd())
+
+	if err == nil {
+		r.width = width
+		r.height = r.maxHeightFunc(height)
+	} else {
+		r.width = getEnv("COLUMNS", defaultWidth)
+		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
+	}
+}
+
+func (r *LightRenderer) findOffset() (row int, col int) {
+	r.csi("6n")
+	r.flush()
+	bytes := []byte{}
+	for tries := 0; tries < offsetPollTries; tries++ {
+		bytes = r.getBytesInternal(bytes, tries > 0)
+		offsets := offsetRegexp.FindSubmatch(bytes)
+		if len(offsets) > 3 {
+			// Add anything we skipped over to the input buffer
+			r.buffer = append(r.buffer, offsets[1]...)
+			return atoi(string(offsets[2]), 0) - 1, atoi(string(offsets[3]), 0) - 1
+		}
+	}
+	return -1, -1
+}
+
+func (r *LightRenderer) getch(nonblock bool) (int, bool) {
+	b := make([]byte, 1)
+	fd := r.fd()
+	util.SetNonblock(r.ttyin, nonblock)
+	_, err := util.Read(fd, b)
+	if err != nil {
+		return 0, false
+	}
+	return int(b[0]), true
+}

src/tui/light_windows.go

@@ -0,0 +1,145 @@
+//+build windows
+
+package tui
+
+import (
+	"os"
+	"syscall"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+	"golang.org/x/sys/windows"
+)
+
+const (
+	timeoutInterval = 10
+)
+
+var (
+	consoleFlagsInput  = uint32(windows.ENABLE_VIRTUAL_TERMINAL_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_EXTENDED_FLAGS)
+	consoleFlagsOutput = uint32(windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING | windows.ENABLE_PROCESSED_OUTPUT | windows.DISABLE_NEWLINE_AUTO_RETURN)
+)
+
+// IsLightRendererSupported checks to see if the Light renderer is supported
+func IsLightRendererSupported() bool {
+	var oldState uint32
+	// enable vt100 emulation (https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences)
+	if windows.GetConsoleMode(windows.Stderr, &oldState) != nil {
+		return false
+	}
+	// attempt to set mode to determine if we support VT 100 codes. This will work on newer Windows 10
+	// version:
+	canSetVt100 := windows.SetConsoleMode(windows.Stderr, oldState|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING) == nil
+	var checkState uint32
+	if windows.GetConsoleMode(windows.Stderr, &checkState) != nil ||
+		(checkState&windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING) != windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING {
+		return false
+	}
+	windows.SetConsoleMode(windows.Stderr, oldState)
+	return canSetVt100
+}
+
+func (r *LightRenderer) defaultTheme() *ColorTheme {
+	// the getenv check is borrowed from here: https://github.com/gdamore/tcell/commit/0c473b86d82f68226a142e96cc5a34c5a29b3690#diff-b008fcd5e6934bf31bc3d33bf49f47d8R178:
+	if !IsLightRendererSupported() || os.Getenv("ConEmuPID") != "" || os.Getenv("TCELL_TRUECOLOR") == "disable" {
+		return Default16
+	}
+	return Dark256
+}
+
+func (r *LightRenderer) initPlatform() error {
+	//outHandle := windows.Stdout
+	outHandle, _ := syscall.Open("CONOUT$", syscall.O_RDWR, 0)
+	// enable vt100 emulation (https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences)
+	if err := windows.GetConsoleMode(windows.Handle(outHandle), &r.origStateOutput); err != nil {
+		return err
+	}
+	r.outHandle = uintptr(outHandle)
+	inHandle, _ := syscall.Open("CONIN$", syscall.O_RDWR, 0)
+	if err := windows.GetConsoleMode(windows.Handle(inHandle), &r.origStateInput); err != nil {
+		return err
+	}
+	r.inHandle = uintptr(inHandle)
+
+	r.setupTerminal()
+
+	// channel for non-blocking reads. Buffer to make sure
+	// we get the ESC sets:
+	r.ttyinChannel = make(chan byte, 1024)
+
+	// the following allows for non-blocking IO.
+	// syscall.SetNonblock() is a NOOP under Windows.
+	go func() {
+		fd := int(r.inHandle)
+		b := make([]byte, 1)
+		for {
+			// HACK: if run from PSReadline, something resets ConsoleMode to remove ENABLE_VIRTUAL_TERMINAL_INPUT.
+			_ = windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+
+			_, err := util.Read(fd, b)
+			if err == nil {
+				r.ttyinChannel <- b[0]
+			}
+		}
+	}()
+
+	return nil
+}
+
+func (r *LightRenderer) closePlatform() {
+	windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
+	windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput)
+}
+
+func openTtyIn() *os.File {
+	// not used
+	return nil
+}
+
+func (r *LightRenderer) setupTerminal() error {
+	if err := windows.SetConsoleMode(windows.Handle(r.outHandle), consoleFlagsOutput); err != nil {
+		return err
+	}
+	return windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+}
+
+func (r *LightRenderer) restoreTerminal() error {
+	if err := windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput); err != nil {
+		return err
+	}
+	return windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
+}
+
+func (r *LightRenderer) updateTerminalSize() {
+	var bufferInfo windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
+		r.width = getEnv("COLUMNS", defaultWidth)
+		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
+
+	} else {
+		r.width = int(bufferInfo.Window.Right - bufferInfo.Window.Left)
+		r.height = r.maxHeightFunc(int(bufferInfo.Window.Bottom - bufferInfo.Window.Top))
+	}
+}
+
+func (r *LightRenderer) findOffset() (row int, col int) {
+	var bufferInfo windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
+		return -1, -1
+	}
+	return int(bufferInfo.CursorPosition.X), int(bufferInfo.CursorPosition.Y)
+}
+
+func (r *LightRenderer) getch(nonblock bool) (int, bool) {
+	if nonblock {
+		select {
+		case bc := <-r.ttyinChannel:
+			return int(bc), true
+		case <-time.After(timeoutInterval * time.Millisecond):
+			return 0, false
+		}
+	} else {
+		bc := <-r.ttyinChannel
+		return int(bc), true
+	}
+}

src/tui/tcell.go

@@ -0,0 +1,721 @@
+// +build tcell windows
+
+package tui
+
+import (
+	"os"
+	"time"
+
+	"runtime"
+
+	"github.com/gdamore/tcell"
+	"github.com/gdamore/tcell/encoding"
+
+	"github.com/mattn/go-runewidth"
+	"github.com/rivo/uniseg"
+)
+
+func HasFullscreenRenderer() bool {
+	return true
+}
+
+func (p ColorPair) style() tcell.Style {
+	style := tcell.StyleDefault
+	return style.Foreground(tcell.Color(p.Fg())).Background(tcell.Color(p.Bg()))
+}
+
+type Attr tcell.Style
+
+type TcellWindow struct {
+	color       bool
+	preview     bool
+	top         int
+	left        int
+	width       int
+	height      int
+	normal      ColorPair
+	lastX       int
+	lastY       int
+	moveCursor  bool
+	borderStyle BorderStyle
+}
+
+func (w *TcellWindow) Top() int {
+	return w.top
+}
+
+func (w *TcellWindow) Left() int {
+	return w.left
+}
+
+func (w *TcellWindow) Width() int {
+	return w.width
+}
+
+func (w *TcellWindow) Height() int {
+	return w.height
+}
+
+func (w *TcellWindow) Refresh() {
+	if w.moveCursor {
+		_screen.ShowCursor(w.left+w.lastX, w.top+w.lastY)
+		w.moveCursor = false
+	}
+	w.lastX = 0
+	w.lastY = 0
+
+	w.drawBorder()
+}
+
+func (w *TcellWindow) FinishFill() {
+	// NO-OP
+}
+
+const (
+	Bold      Attr = Attr(tcell.AttrBold)
+	Dim            = Attr(tcell.AttrDim)
+	Blink          = Attr(tcell.AttrBlink)
+	Reverse        = Attr(tcell.AttrReverse)
+	Underline      = Attr(tcell.AttrUnderline)
+	Italic         = Attr(tcell.AttrItalic)
+)
+
+const (
+	AttrUndefined = Attr(0)
+	AttrRegular   = Attr(1 << 7)
+	AttrClear     = Attr(1 << 8)
+)
+
+func (r *FullscreenRenderer) defaultTheme() *ColorTheme {
+	if _screen.Colors() >= 256 {
+		return Dark256
+	}
+	return Default16
+}
+
+var (
+	_colorToAttribute = []tcell.Color{
+		tcell.ColorBlack,
+		tcell.ColorRed,
+		tcell.ColorGreen,
+		tcell.ColorYellow,
+		tcell.ColorBlue,
+		tcell.ColorDarkMagenta,
+		tcell.ColorLightCyan,
+		tcell.ColorWhite,
+	}
+)
+
+func (c Color) Style() tcell.Color {
+	if c <= colDefault {
+		return tcell.ColorDefault
+	} else if c >= colBlack && c <= colWhite {
+		return _colorToAttribute[int(c)]
+	} else {
+		return tcell.Color(c)
+	}
+}
+
+func (a Attr) Merge(b Attr) Attr {
+	return a | b
+}
+
+// handle the following as private members of FullscreenRenderer instance
+// they are declared here to prevent introducing tcell library in non-windows builds
+var (
+	_screen          tcell.Screen
+	_prevMouseButton tcell.ButtonMask
+)
+
+func (r *FullscreenRenderer) initScreen() {
+	s, e := tcell.NewScreen()
+	if e != nil {
+		errorExit(e.Error())
+	}
+	if e = s.Init(); e != nil {
+		errorExit(e.Error())
+	}
+	if r.mouse {
+		s.EnableMouse()
+	} else {
+		s.DisableMouse()
+	}
+	_screen = s
+}
+
+func (r *FullscreenRenderer) Init() {
+	if os.Getenv("TERM") == "cygwin" {
+		os.Setenv("TERM", "")
+	}
+	encoding.Register()
+
+	r.initScreen()
+	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
+}
+
+func (r *FullscreenRenderer) MaxX() int {
+	ncols, _ := _screen.Size()
+	return int(ncols)
+}
+
+func (r *FullscreenRenderer) MaxY() int {
+	_, nlines := _screen.Size()
+	return int(nlines)
+}
+
+func (w *TcellWindow) X() int {
+	return w.lastX
+}
+
+func (w *TcellWindow) Y() int {
+	return w.lastY
+}
+
+func (r *FullscreenRenderer) Clear() {
+	_screen.Sync()
+	_screen.Clear()
+}
+
+func (r *FullscreenRenderer) Refresh() {
+	// noop
+}
+
+func (r *FullscreenRenderer) GetChar() Event {
+	ev := _screen.PollEvent()
+	switch ev := ev.(type) {
+	case *tcell.EventResize:
+		return Event{Resize, 0, nil}
+
+	// process mouse events:
+	case *tcell.EventMouse:
+		// mouse down events have zeroed buttons, so we can't use them
+		// mouse up event consists of two events, 1. (main) event with modifier and other metadata, 2. event with zeroed buttons
+		// so mouse click is three consecutive events, but the first and last are indistinguishable from movement events (with released buttons)
+		// dragging has same structure, it only repeats the middle (main) event appropriately
+		x, y := ev.Position()
+		mod := ev.Modifiers() != 0
+
+		// since we dont have mouse down events (unlike LightRenderer), we need to track state in prevButton
+		prevButton, button := _prevMouseButton, ev.Buttons()
+		_prevMouseButton = button
+		drag := prevButton == button
+
+		switch {
+		case button&tcell.WheelDown != 0:
+			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, false, mod}}
+		case button&tcell.WheelUp != 0:
+			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, false, mod}}
+		case button&tcell.Button1 != 0 && !drag:
+			// all potential double click events put their 'line' coordinate in the clickY array
+			// double click event has two conditions, temporal and spatial, the first is checked here
+			now := time.Now()
+			if now.Sub(r.prevDownTime) < doubleClickDuration {
+				r.clickY = append(r.clickY, y)
+			} else {
+				r.clickY = []int{y}
+			}
+			r.prevDownTime = now
+
+			// detect double clicks (also check for spatial condition)
+			n := len(r.clickY)
+			double := n > 1 && r.clickY[n-2] == r.clickY[n-1]
+			if double {
+				// make sure two consecutive double clicks require four clicks
+				r.clickY = []int{}
+			}
+
+			// fire single or double click event
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, true, !double, double, mod}}
+		case button&tcell.Button2 != 0 && !drag:
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, false, true, false, mod}}
+		case runtime.GOOS != "windows":
+
+			// double and single taps on Windows don't quite work due to
+			// the console acting on the events and not allowing us
+			// to consume them.
+
+			left := button&tcell.Button1 != 0
+			down := left || button&tcell.Button3 != 0
+			double := false
+			if down {
+				now := time.Now()
+				if !left {
+					r.clickY = []int{}
+				} else if now.Sub(r.prevDownTime) < doubleClickDuration {
+					r.clickY = append(r.clickY, x)
+				} else {
+					r.clickY = []int{x}
+					r.prevDownTime = now
+				}
+			} else {
+				if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
+					time.Now().Sub(r.prevDownTime) < doubleClickDuration {
+					double = true
+				}
+			}
+
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
+		}
+
+		// process keyboard:
+	case *tcell.EventKey:
+		mods := ev.Modifiers()
+		none := mods == tcell.ModNone
+		alt := (mods & tcell.ModAlt) > 0
+		ctrl := (mods & tcell.ModCtrl) > 0
+		shift := (mods & tcell.ModShift) > 0
+		ctrlAlt := ctrl && alt
+		altShift := alt && shift
+
+		keyfn := func(r rune) Event {
+			if alt {
+				return CtrlAltKey(r)
+			}
+			return EventType(CtrlA.Int() - 'a' + int(r)).AsEvent()
+		}
+		switch ev.Key() {
+		// section 1: Ctrl+(Alt)+[a-z]
+		case tcell.KeyCtrlA:
+			return keyfn('a')
+		case tcell.KeyCtrlB:
+			return keyfn('b')
+		case tcell.KeyCtrlC:
+			return keyfn('c')
+		case tcell.KeyCtrlD:
+			return keyfn('d')
+		case tcell.KeyCtrlE:
+			return keyfn('e')
+		case tcell.KeyCtrlF:
+			return keyfn('f')
+		case tcell.KeyCtrlG:
+			return keyfn('g')
+		case tcell.KeyCtrlH:
+			switch ev.Rune() {
+			case 0:
+				if ctrl {
+					return Event{BSpace, 0, nil}
+				}
+			case rune(tcell.KeyCtrlH):
+				switch {
+				case ctrl:
+					return keyfn('h')
+				case alt:
+					return Event{AltBS, 0, nil}
+				case none, shift:
+					return Event{BSpace, 0, nil}
+				}
+			}
+		case tcell.KeyCtrlI:
+			return keyfn('i')
+		case tcell.KeyCtrlJ:
+			return keyfn('j')
+		case tcell.KeyCtrlK:
+			return keyfn('k')
+		case tcell.KeyCtrlL:
+			return keyfn('l')
+		case tcell.KeyCtrlM:
+			return keyfn('m')
+		case tcell.KeyCtrlN:
+			return keyfn('n')
+		case tcell.KeyCtrlO:
+			return keyfn('o')
+		case tcell.KeyCtrlP:
+			return keyfn('p')
+		case tcell.KeyCtrlQ:
+			return keyfn('q')
+		case tcell.KeyCtrlR:
+			return keyfn('r')
+		case tcell.KeyCtrlS:
+			return keyfn('s')
+		case tcell.KeyCtrlT:
+			return keyfn('t')
+		case tcell.KeyCtrlU:
+			return keyfn('u')
+		case tcell.KeyCtrlV:
+			return keyfn('v')
+		case tcell.KeyCtrlW:
+			return keyfn('w')
+		case tcell.KeyCtrlX:
+			return keyfn('x')
+		case tcell.KeyCtrlY:
+			return keyfn('y')
+		case tcell.KeyCtrlZ:
+			return keyfn('z')
+		// section 2: Ctrl+[ \]_]
+		case tcell.KeyCtrlSpace:
+			return Event{CtrlSpace, 0, nil}
+		case tcell.KeyCtrlBackslash:
+			return Event{CtrlBackSlash, 0, nil}
+		case tcell.KeyCtrlRightSq:
+			return Event{CtrlRightBracket, 0, nil}
+		case tcell.KeyCtrlCarat:
+			return Event{CtrlCaret, 0, nil}
+		case tcell.KeyCtrlUnderscore:
+			return Event{CtrlSlash, 0, nil}
+		// section 3: (Alt)+Backspace2
+		case tcell.KeyBackspace2:
+			if alt {
+				return Event{AltBS, 0, nil}
+			}
+			return Event{BSpace, 0, nil}
+
+		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
+		case tcell.KeyUp:
+			if altShift {
+				return Event{AltSUp, 0, nil}
+			}
+			if shift {
+				return Event{SUp, 0, nil}
+			}
+			if alt {
+				return Event{AltUp, 0, nil}
+			}
+			return Event{Up, 0, nil}
+		case tcell.KeyDown:
+			if altShift {
+				return Event{AltSDown, 0, nil}
+			}
+			if shift {
+				return Event{SDown, 0, nil}
+			}
+			if alt {
+				return Event{AltDown, 0, nil}
+			}
+			return Event{Down, 0, nil}
+		case tcell.KeyLeft:
+			if altShift {
+				return Event{AltSLeft, 0, nil}
+			}
+			if shift {
+				return Event{SLeft, 0, nil}
+			}
+			if alt {
+				return Event{AltLeft, 0, nil}
+			}
+			return Event{Left, 0, nil}
+		case tcell.KeyRight:
+			if altShift {
+				return Event{AltSRight, 0, nil}
+			}
+			if shift {
+				return Event{SRight, 0, nil}
+			}
+			if alt {
+				return Event{AltRight, 0, nil}
+			}
+			return Event{Right, 0, nil}
+
+		// section 5: (Insert|Home|Delete|End|PgUp|PgDn|BackTab|F1-F12)
+		case tcell.KeyInsert:
+			return Event{Insert, 0, nil}
+		case tcell.KeyHome:
+			return Event{Home, 0, nil}
+		case tcell.KeyDelete:
+			return Event{Del, 0, nil}
+		case tcell.KeyEnd:
+			return Event{End, 0, nil}
+		case tcell.KeyPgUp:
+			return Event{PgUp, 0, nil}
+		case tcell.KeyPgDn:
+			return Event{PgDn, 0, nil}
+		case tcell.KeyBacktab:
+			return Event{BTab, 0, nil}
+		case tcell.KeyF1:
+			return Event{F1, 0, nil}
+		case tcell.KeyF2:
+			return Event{F2, 0, nil}
+		case tcell.KeyF3:
+			return Event{F3, 0, nil}
+		case tcell.KeyF4:
+			return Event{F4, 0, nil}
+		case tcell.KeyF5:
+			return Event{F5, 0, nil}
+		case tcell.KeyF6:
+			return Event{F6, 0, nil}
+		case tcell.KeyF7:
+			return Event{F7, 0, nil}
+		case tcell.KeyF8:
+			return Event{F8, 0, nil}
+		case tcell.KeyF9:
+			return Event{F9, 0, nil}
+		case tcell.KeyF10:
+			return Event{F10, 0, nil}
+		case tcell.KeyF11:
+			return Event{F11, 0, nil}
+		case tcell.KeyF12:
+			return Event{F12, 0, nil}
+
+		// section 6: (Ctrl+Alt)+'rune'
+		case tcell.KeyRune:
+			r := ev.Rune()
+
+			switch {
+			// translate native key events to ascii control characters
+			case r == ' ' && ctrl:
+				return Event{CtrlSpace, 0, nil}
+			// handle AltGr characters
+			case ctrlAlt:
+				return Event{Rune, r, nil} // dropping modifiers
+			// simple characters (possibly with modifier)
+			case alt:
+				return AltKey(r)
+			default:
+				return Event{Rune, r, nil}
+			}
+
+		// section 7: Esc
+		case tcell.KeyEsc:
+			return Event{ESC, 0, nil}
+		}
+	}
+
+	// section 8: Invalid
+	return Event{Invalid, 0, nil}
+}
+
+func (r *FullscreenRenderer) Pause(clear bool) {
+	if clear {
+		_screen.Fini()
+	}
+}
+
+func (r *FullscreenRenderer) Resume(clear bool, sigcont bool) {
+	if clear {
+		r.initScreen()
+	}
+}
+
+func (r *FullscreenRenderer) Close() {
+	_screen.Fini()
+}
+
+func (r *FullscreenRenderer) RefreshWindows(windows []Window) {
+	// TODO
+	for _, w := range windows {
+		w.Refresh()
+	}
+	_screen.Show()
+}
+
+func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
+	normal := ColNormal
+	if preview {
+		normal = ColPreview
+	}
+	return &TcellWindow{
+		color:       r.theme.Colored,
+		preview:     preview,
+		top:         top,
+		left:        left,
+		width:       width,
+		height:      height,
+		normal:      normal,
+		borderStyle: borderStyle}
+}
+
+func (w *TcellWindow) Close() {
+	// TODO
+}
+
+func fill(x, y, w, h int, n ColorPair, r rune) {
+	for ly := 0; ly <= h; ly++ {
+		for lx := 0; lx <= w; lx++ {
+			_screen.SetContent(x+lx, y+ly, r, nil, n.style())
+		}
+	}
+}
+
+func (w *TcellWindow) Erase() {
+	fill(w.left-1, w.top, w.width+1, w.height, w.normal, ' ')
+}
+
+func (w *TcellWindow) Enclose(y int, x int) bool {
+	return x >= w.left && x < (w.left+w.width) &&
+		y >= w.top && y < (w.top+w.height)
+}
+
+func (w *TcellWindow) Move(y int, x int) {
+	w.lastX = x
+	w.lastY = y
+	w.moveCursor = true
+}
+
+func (w *TcellWindow) MoveAndClear(y int, x int) {
+	w.Move(y, x)
+	for i := w.lastX; i < w.width; i++ {
+		_screen.SetContent(i+w.left, w.lastY+w.top, rune(' '), nil, w.normal.style())
+	}
+	w.lastX = x
+}
+
+func (w *TcellWindow) Print(text string) {
+	w.printString(text, w.normal)
+}
+
+func (w *TcellWindow) printString(text string, pair ColorPair) {
+	lx := 0
+	a := pair.Attr()
+
+	style := pair.style()
+	if a&AttrClear == 0 {
+		style = style.
+			Reverse(a&Attr(tcell.AttrReverse) != 0).
+			Underline(a&Attr(tcell.AttrUnderline) != 0).
+			Italic(a&Attr(tcell.AttrItalic) != 0).
+			Blink(a&Attr(tcell.AttrBlink) != 0).
+			Dim(a&Attr(tcell.AttrDim) != 0)
+	}
+
+	gr := uniseg.NewGraphemes(text)
+	for gr.Next() {
+		rs := gr.Runes()
+
+		if len(rs) == 1 {
+			r := rs[0]
+			if r < rune(' ') { // ignore control characters
+				continue
+			} else if r == '\n' {
+				w.lastY++
+				lx = 0
+				continue
+			} else if r == '\u000D' { // skip carriage return
+				continue
+			}
+		}
+		var xPos = w.left + w.lastX + lx
+		var yPos = w.top + w.lastY
+		if xPos < (w.left+w.width) && yPos < (w.top+w.height) {
+			_screen.SetContent(xPos, yPos, rs[0], rs[1:], style)
+		}
+		lx += runewidth.StringWidth(string(rs))
+	}
+	w.lastX += lx
+}
+
+func (w *TcellWindow) CPrint(pair ColorPair, text string) {
+	w.printString(text, pair)
+}
+
+func (w *TcellWindow) fillString(text string, pair ColorPair) FillReturn {
+	lx := 0
+	a := pair.Attr()
+
+	var style tcell.Style
+	if w.color {
+		style = pair.style()
+	} else {
+		style = w.normal.style()
+	}
+	style = style.
+		Blink(a&Attr(tcell.AttrBlink) != 0).
+		Bold(a&Attr(tcell.AttrBold) != 0).
+		Dim(a&Attr(tcell.AttrDim) != 0).
+		Reverse(a&Attr(tcell.AttrReverse) != 0).
+		Underline(a&Attr(tcell.AttrUnderline) != 0).
+		Italic(a&Attr(tcell.AttrItalic) != 0)
+
+	gr := uniseg.NewGraphemes(text)
+	for gr.Next() {
+		rs := gr.Runes()
+		if len(rs) == 1 && rs[0] == '\n' {
+			w.lastY++
+			w.lastX = 0
+			lx = 0
+			continue
+		}
+
+		// word wrap:
+		xPos := w.left + w.lastX + lx
+		if xPos >= (w.left + w.width) {
+			w.lastY++
+			w.lastX = 0
+			lx = 0
+			xPos = w.left
+		}
+
+		yPos := w.top + w.lastY
+		if yPos >= (w.top + w.height) {
+			return FillSuspend
+		}
+
+		_screen.SetContent(xPos, yPos, rs[0], rs[1:], style)
+		lx += runewidth.StringWidth(string(rs))
+	}
+	w.lastX += lx
+	if w.lastX == w.width {
+		w.lastY++
+		w.lastX = 0
+		return FillNextLine
+	}
+
+	return FillContinue
+}
+
+func (w *TcellWindow) Fill(str string) FillReturn {
+	return w.fillString(str, w.normal)
+}
+
+func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
+	if fg == colDefault {
+		fg = w.normal.Fg()
+	}
+	if bg == colDefault {
+		bg = w.normal.Bg()
+	}
+	return w.fillString(str, NewColorPair(fg, bg, a))
+}
+
+func (w *TcellWindow) drawBorder() {
+	shape := w.borderStyle.shape
+	if shape == BorderNone {
+		return
+	}
+
+	left := w.left
+	right := left + w.width
+	top := w.top
+	bot := top + w.height
+
+	var style tcell.Style
+	if w.color {
+		if w.preview {
+			style = ColPreviewBorder.style()
+		} else {
+			style = ColBorder.style()
+		}
+	} else {
+		style = w.normal.style()
+	}
+
+	switch shape {
+	case BorderRounded, BorderSharp, BorderHorizontal, BorderTop:
+		for x := left; x < right; x++ {
+			_screen.SetContent(x, top, w.borderStyle.horizontal, nil, style)
+		}
+	}
+	switch shape {
+	case BorderRounded, BorderSharp, BorderHorizontal, BorderBottom:
+		for x := left; x < right; x++ {
+			_screen.SetContent(x, bot-1, w.borderStyle.horizontal, nil, style)
+		}
+	}
+	switch shape {
+	case BorderRounded, BorderSharp, BorderVertical, BorderLeft:
+		for y := top; y < bot; y++ {
+			_screen.SetContent(left, y, w.borderStyle.vertical, nil, style)
+		}
+	}
+	switch shape {
+	case BorderRounded, BorderSharp, BorderVertical, BorderRight:
+		for y := top; y < bot; y++ {
+			_screen.SetContent(right-1, y, w.borderStyle.vertical, nil, style)
+		}
+	}
+	switch shape {
+	case BorderRounded, BorderSharp:
+		_screen.SetContent(left, top, w.borderStyle.topLeft, nil, style)
+		_screen.SetContent(right-1, top, w.borderStyle.topRight, nil, style)
+		_screen.SetContent(left, bot-1, w.borderStyle.bottomLeft, nil, style)
+		_screen.SetContent(right-1, bot-1, w.borderStyle.bottomRight, nil, style)
+	}
+}

src/tui/tcell_test.go

@@ -0,0 +1,392 @@
+// +build tcell windows
+
+package tui
+
+import (
+	"testing"
+
+	"github.com/gdamore/tcell"
+	"github.com/junegunn/fzf/src/util"
+)
+
+func assert(t *testing.T, context string, got interface{}, want interface{}) bool {
+	if got == want {
+		return true
+	} else {
+		t.Errorf("%s = (%T)%v, want (%T)%v", context, got, got, want, want)
+		return false
+	}
+}
+
+// Test the handling of the tcell keyboard events.
+func TestGetCharEventKey(t *testing.T) {
+	if util.ToTty() {
+		// This test is skipped when output goes to terminal, because it causes
+		// some glitches:
+		// - output lines may not start at the beginning of a row which makes
+		//   the output unreadable
+		// - terminal may get cleared which prevents you from seeing results of
+		//   previous tests
+		// Good ways to prevent the glitches are piping the output to a pager
+		// or redirecting to a file. I've found `less +G` to be trouble-free.
+		t.Skip("Skipped because this test misbehaves in terminal, pipe to a pager or redirect output to a file to run it safely.")
+	} else if testing.Verbose() {
+		// I have observed a behaviour when this test outputted more than 8192
+		// bytes (32*256) into the 'less' pager, both the go's test executable
+		// and the pager hanged. The go's executable was blocking on printing.
+		// I was able to create minimal working example of that behaviour, but
+		// that example hanged after 12256 bytes (32*(256+127)).
+		t.Log("If you are piping this test to a pager and it hangs, make the pager greedy for input, e.g. 'less +G'.")
+	}
+
+	if !HasFullscreenRenderer() {
+		t.Skip("Can't test FullscreenRenderer.")
+	}
+
+	// construct test cases
+	type giveKey struct {
+		Type tcell.Key
+		Char rune
+		Mods tcell.ModMask
+	}
+	type wantKey = Event
+	type testCase struct {
+		giveKey
+		wantKey
+	}
+	/*
+		Some test cases are marked "fabricated". It means that giveKey value
+		is valid, but it is not what you get when you press the keys. For
+		example Ctrl+C will NOT give you tcell.KeyCtrlC, but tcell.KeyETX
+		(End-Of-Text character, causing SIGINT).
+		I was trying to accompany the fabricated test cases with real ones.
+
+		Some test cases are marked "unhandled". It means that giveKey.Type
+		is not present in tcell.go source code. It can still be handled via
+		implicit or explicit alias.
+
+		If not said otherwise, test cases are for US keyboard.
+
+		(tabstop=44)
+	*/
+	tests := []testCase{
+
+		// section 1: Ctrl+(Alt)+[a-z]
+		{giveKey{tcell.KeyCtrlA, rune(tcell.KeyCtrlA), tcell.ModCtrl}, wantKey{CtrlA, 0, nil}},
+		{giveKey{tcell.KeyCtrlC, rune(tcell.KeyCtrlC), tcell.ModCtrl}, wantKey{CtrlC, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyETX, rune(tcell.KeyETX), tcell.ModCtrl}, wantKey{CtrlC, 0, nil}},     // this is SIGINT (Ctrl+C)
+		{giveKey{tcell.KeyCtrlZ, rune(tcell.KeyCtrlZ), tcell.ModCtrl}, wantKey{CtrlZ, 0, nil}}, // fabricated
+		// KeyTab is alias for KeyTAB
+		{giveKey{tcell.KeyCtrlI, rune(tcell.KeyCtrlI), tcell.ModCtrl}, wantKey{Tab, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyTab, rune(tcell.KeyTab), tcell.ModNone}, wantKey{Tab, 0, nil}},     // unhandled, actual "Tab" keystroke
+		{giveKey{tcell.KeyTAB, rune(tcell.KeyTAB), tcell.ModNone}, wantKey{Tab, 0, nil}},     // fabricated, unhandled
+		// KeyEnter is alias for KeyCR
+		{giveKey{tcell.KeyCtrlM, rune(tcell.KeyCtrlM), tcell.ModNone}, wantKey{CtrlM, 0, nil}}, // actual "Enter" keystroke
+		{giveKey{tcell.KeyCR, rune(tcell.KeyCR), tcell.ModNone}, wantKey{CtrlM, 0, nil}},       // fabricated, unhandled
+		{giveKey{tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone}, wantKey{CtrlM, 0, nil}}, // fabricated, unhandled
+		// Ctrl+Alt keys
+		{giveKey{tcell.KeyCtrlA, rune(tcell.KeyCtrlA), tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAlt, 'a', nil}},                  // fabricated
+		{giveKey{tcell.KeyCtrlA, rune(tcell.KeyCtrlA), tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{CtrlAlt, 'a', nil}}, // fabricated
+
+		// section 2: Ctrl+[ \]_]
+		{giveKey{tcell.KeyCtrlSpace, rune(tcell.KeyCtrlSpace), tcell.ModCtrl}, wantKey{CtrlSpace, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyNUL, rune(tcell.KeyNUL), tcell.ModNone}, wantKey{CtrlSpace, 0, nil}},             // fabricated, unhandled
+		{giveKey{tcell.KeyRune, ' ', tcell.ModCtrl}, wantKey{CtrlSpace, 0, nil}},                           // actual Ctrl+' '
+		{giveKey{tcell.KeyCtrlBackslash, rune(tcell.KeyCtrlBackslash), tcell.ModCtrl}, wantKey{CtrlBackSlash, 0, nil}},
+		{giveKey{tcell.KeyCtrlRightSq, rune(tcell.KeyCtrlRightSq), tcell.ModCtrl}, wantKey{CtrlRightBracket, 0, nil}},
+		{giveKey{tcell.KeyCtrlCarat, rune(tcell.KeyCtrlCarat), tcell.ModShift | tcell.ModCtrl}, wantKey{CtrlCaret, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyRS, rune(tcell.KeyRS), tcell.ModShift | tcell.ModCtrl}, wantKey{CtrlCaret, 0, nil}},               // actual Ctrl+Shift+6 (i.e. Ctrl+^) keystroke
+		{giveKey{tcell.KeyCtrlUnderscore, rune(tcell.KeyCtrlUnderscore), tcell.ModShift | tcell.ModCtrl}, wantKey{CtrlSlash, 0, nil}},
+
+		// section 3: (Alt)+Backspace2
+		// KeyBackspace2 is alias for KeyDEL = 0x7F (ASCII) (allegedly unused by Windows)
+		// KeyDelete = 0x2E (VK_DELETE constant in Windows)
+		// KeyBackspace is alias for KeyBS = 0x08 (ASCII) (implicit alias with KeyCtrlH)
+		{giveKey{tcell.KeyBackspace2, 0, tcell.ModNone}, wantKey{BSpace, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyBackspace2, 0, tcell.ModAlt}, wantKey{AltBS, 0, nil}},   // fabricated
+		{giveKey{tcell.KeyDEL, 0, tcell.ModNone}, wantKey{BSpace, 0, nil}},        // fabricated, unhandled
+		{giveKey{tcell.KeyDelete, 0, tcell.ModNone}, wantKey{Del, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModAlt}, wantKey{Del, 0, nil}},
+		{giveKey{tcell.KeyBackspace, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                  // fabricated, unhandled
+		{giveKey{tcell.KeyBS, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                         // fabricated, unhandled
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                      // fabricated, unhandled
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModNone}, wantKey{BSpace, 0, nil}},                                    // actual "Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModAlt}, wantKey{AltBS, 0, nil}},                                      // actual "Alt+Backspace" keystroke
+		{giveKey{tcell.KeyDEL, rune(tcell.KeyDEL), tcell.ModCtrl}, wantKey{BSpace, 0, nil}},                                        // actual "Ctrl+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift}, wantKey{BSpace, 0, nil}},                                   // actual "Shift+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{BSpace, 0, nil}},                                        // actual "Ctrl+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{BSpace, 0, nil}},                                      // actual "Ctrl+Shift+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift | tcell.ModAlt}, wantKey{AltBS, 0, nil}},                     // actual "Shift+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{BSpace, 0, nil}},                       // actual "Ctrl+Shift+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl}, wantKey{CtrlH, 0, nil}},                                     // actual "Ctrl+H" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAlt, 'h', nil}},                  // fabricated "Ctrl+Alt+H" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlH, 0, nil}},                    // actual "Ctrl+Shift+H" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{CtrlAlt, 'h', nil}}, // fabricated "Ctrl+Shift+Alt+H" keystroke
+
+		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
+		{giveKey{tcell.KeyUp, 0, tcell.ModNone}, wantKey{Up, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModAlt}, wantKey{AltDown, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModShift}, wantKey{SLeft, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltSRight, 0, nil}},
+		{giveKey{tcell.KeyUpLeft, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},    // fabricated, unhandled
+		{giveKey{tcell.KeyUpRight, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},   // fabricated, unhandled
+		{giveKey{tcell.KeyDownLeft, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // fabricated, unhandled
+		{giveKey{tcell.KeyDownRight, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}}, // fabricated, unhandled
+		{giveKey{tcell.KeyCenter, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},    // fabricated, unhandled
+		// section 5: (Insert|Home|Delete|End|PgUp|PgDn|BackTab|F1-F12)
+		{giveKey{tcell.KeyInsert, 0, tcell.ModNone}, wantKey{Insert, 0, nil}},
+		{giveKey{tcell.KeyF1, 0, tcell.ModNone}, wantKey{F1, 0, nil}},
+		// section 6: (Ctrl+Alt)+'rune'
+		{giveKey{tcell.KeyRune, 'a', tcell.ModNone}, wantKey{Rune, 'a', nil}},
+		{giveKey{tcell.KeyRune, 'a', tcell.ModCtrl}, wantKey{Rune, 'a', nil}}, // fabricated
+		{giveKey{tcell.KeyRune, 'a', tcell.ModAlt}, wantKey{Alt, 'a', nil}},
+		{giveKey{tcell.KeyRune, 'A', tcell.ModAlt}, wantKey{Alt, 'A', nil}},
+		{giveKey{tcell.KeyRune, '`', tcell.ModAlt}, wantKey{Alt, '`', nil}},
+		/*
+			"Input method" in Windows Language options:
+			US: "US Keyboard" does not generate any characters (and thus any events) in Ctrl+Alt+[a-z] range
+			CS: "Czech keyboard"
+			DE: "German keyboard"
+
+			Note that right Alt is not just `tcell.ModAlt` on foreign language keyboards, but it is the AltGr `tcell.ModCtrl|tcell.ModAlt`.
+		*/
+		{giveKey{tcell.KeyRune, '{', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '{', nil}}, // CS: Ctrl+Alt+b = "{" // Note that this does not interfere with CtrlB, since the "b" is replaced with "{" on OS level
+		{giveKey{tcell.KeyRune, '$', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '$', nil}}, // CS: Ctrl+Alt+ů = "$"
+		{giveKey{tcell.KeyRune, '~', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '~', nil}}, // CS: Ctrl+Alt++ = "~"
+		{giveKey{tcell.KeyRune, '`', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '`', nil}}, // CS: Ctrl+Alt+ý,Space = "`" // this is dead key, space is required to emit the char
+
+		{giveKey{tcell.KeyRune, '{', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '{', nil}}, // DE: Ctrl+Alt+7 = "{"
+		{giveKey{tcell.KeyRune, '@', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '@', nil}}, // DE: Ctrl+Alt+q = "@"
+		{giveKey{tcell.KeyRune, 'µ', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, 'µ', nil}}, // DE: Ctrl+Alt+m = "µ"
+
+		// section 7: Esc
+		// KeyEsc and KeyEscape are aliases for KeyESC
+		{giveKey{tcell.KeyEsc, rune(tcell.KeyEsc), tcell.ModNone}, wantKey{ESC, 0, nil}},               // fabricated
+		{giveKey{tcell.KeyESC, rune(tcell.KeyESC), tcell.ModNone}, wantKey{ESC, 0, nil}},               // unhandled
+		{giveKey{tcell.KeyEscape, rune(tcell.KeyEscape), tcell.ModNone}, wantKey{ESC, 0, nil}},         // fabricated, unhandled
+		{giveKey{tcell.KeyESC, rune(tcell.KeyESC), tcell.ModCtrl}, wantKey{ESC, 0, nil}},               // actual Ctrl+[ keystroke
+		{giveKey{tcell.KeyCtrlLeftSq, rune(tcell.KeyCtrlLeftSq), tcell.ModCtrl}, wantKey{ESC, 0, nil}}, // fabricated, unhandled
+
+		// section 8: Invalid
+		{giveKey{tcell.KeyRune, 'a', tcell.ModMeta}, wantKey{Rune, 'a', nil}}, // fabricated
+		{giveKey{tcell.KeyF24, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},
+		{giveKey{tcell.KeyHelp, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},   // fabricated, unhandled
+		{giveKey{tcell.KeyExit, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},   // fabricated, unhandled
+		{giveKey{tcell.KeyClear, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // unhandled, actual keystroke Numpad_5 with Numlock OFF
+		{giveKey{tcell.KeyCancel, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}}, // fabricated, unhandled
+		{giveKey{tcell.KeyPrint, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // fabricated, unhandled
+		{giveKey{tcell.KeyPause, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // unhandled
+
+	}
+	r := NewFullscreenRenderer(&ColorTheme{}, false, false)
+	r.Init()
+
+	// run and evaluate the tests
+	for _, test := range tests {
+		// generate key event
+		giveEvent := tcell.NewEventKey(test.giveKey.Type, test.giveKey.Char, test.giveKey.Mods)
+		_screen.PostEventWait(giveEvent)
+		t.Logf("giveEvent = %T{key: %v, ch: %q (%[3]v), mod: %#04b}\n", giveEvent, giveEvent.Key(), giveEvent.Rune(), giveEvent.Modifiers())
+
+		// process the event in fzf and evaluate the test
+		gotEvent := r.GetChar()
+		// skip Resize events, those are sometimes put in the buffer outside of this test
+		for gotEvent.Type == Resize {
+			t.Logf("Resize swallowed")
+			gotEvent = r.GetChar()
+		}
+		t.Logf("wantEvent = %T{Type: %v, Char: %q (%[3]v)}\n", test.wantKey, test.wantKey.Type, test.wantKey.Char)
+		t.Logf("gotEvent = %T{Type: %v, Char: %q (%[3]v)}\n", gotEvent, gotEvent.Type, gotEvent.Char)
+
+		assert(t, "r.GetChar().Type", gotEvent.Type, test.wantKey.Type)
+		assert(t, "r.GetChar().Char", gotEvent.Char, test.wantKey.Char)
+	}
+
+	r.Close()
+}
+
+/*
+Quick reference
+---------------
+
+(tabstop=18)
+(this is not mapping table, it merely puts multiple constants ranges in one table)
+
+¹) the two columns are each other implicit alias
+²) explicit aliases here
+
+%v	section #	tcell ctrl key¹	tcell ctrl char¹	tcell alias²	tui constants	tcell named keys	tcell mods
+--	---------	--------------	---------------	-----------	-------------	----------------	----------
+0	2	KeyCtrlSpace	KeyNUL = ^@ 		Rune		ModNone
+1	1	KeyCtrlA	KeySOH = ^A		CtrlA		ModShift
+2	1	KeyCtrlB	KeySTX = ^B		CtrlB		ModCtrl
+3	1	KeyCtrlC	KeyETX = ^C		CtrlC
+4	1	KeyCtrlD	KeyEOT = ^D		CtrlD		ModAlt
+5	1	KeyCtrlE	KeyENQ = ^E		CtrlE
+6	1	KeyCtrlF	KeyACK = ^F		CtrlF
+7	1	KeyCtrlG	KeyBEL = ^G		CtrlG
+8	1	KeyCtrlH	KeyBS = ^H	KeyBackspace	CtrlH		ModMeta
+9	1	KeyCtrlI	KeyTAB = ^I	KeyTab	Tab
+10	1	KeyCtrlJ	KeyLF = ^J		CtrlJ
+11	1	KeyCtrlK	KeyVT = ^K		CtrlK
+12	1	KeyCtrlL	KeyFF = ^L		CtrlL
+13	1	KeyCtrlM	KeyCR = ^M	KeyEnter	CtrlM
+14	1	KeyCtrlN	KeySO = ^N		CtrlN
+15	1	KeyCtrlO	KeySI = ^O		CtrlO
+16	1	KeyCtrlP	KeyDLE = ^P		CtrlP
+17	1	KeyCtrlQ	KeyDC1 = ^Q		CtrlQ
+18	1	KeyCtrlR	KeyDC2 = ^R		CtrlR
+19	1	KeyCtrlS	KeyDC3 = ^S		CtrlS
+20	1	KeyCtrlT	KeyDC4 = ^T		CtrlT
+21	1	KeyCtrlU	KeyNAK = ^U		CtrlU
+22	1	KeyCtrlV	KeySYN = ^V		CtrlV
+23	1	KeyCtrlW	KeyETB = ^W		CtrlW
+24	1	KeyCtrlX	KeyCAN = ^X		CtrlX
+25	1	KeyCtrlY	KeyEM = ^Y		CtrlY
+26	1	KeyCtrlZ	KeySUB = ^Z		CtrlZ
+27	7	KeyCtrlLeftSq	KeyESC = ^[	KeyEsc, KeyEscape	ESC
+28	2	KeyCtrlBackslash	KeyFS = ^\		CtrlSpace
+29	2	KeyCtrlRightSq	KeyGS = ^]		CtrlBackSlash
+30	2	KeyCtrlCarat	KeyRS = ^^		CtrlRightBracket
+31	2	KeyCtrlUnderscore	KeyUS = ^_		CtrlCaret
+32					CtrlSlash
+33					Invalid
+34					Resize
+35					Mouse
+36					DoubleClick
+37					LeftClick
+38					RightClick
+39					BTab
+40					BSpace
+41					Del
+42					PgUp
+43					PgDn
+44					Up
+45					Down
+46					Left
+47					Right
+48					Home
+49					End
+50					Insert
+51					SUp
+52					SDown
+53					SLeft
+54					SRight
+55					F1
+56					F2
+57					F3
+58					F4
+59					F5
+60					F6
+61					F7
+62					F8
+63					F9
+64					F10
+65					F11
+66					F12
+67					Change
+68					BackwardEOF
+69					AltBS
+70					AltUp
+71					AltDown
+72					AltLeft
+73					AltRight
+74					AltSUp
+75					AltSDown
+76					AltSLeft
+77					AltSRight
+78					Alt
+79					CtrlAlt
+..
+127	3		  KeyDEL	KeyBackspace2
+..
+256	6					KeyRune
+257	4					KeyUp
+258	4					KeyDown
+259	4					KeyRight
+260	4					KeyLeft
+261	8					KeyUpLeft
+262	8					KeyUpRight
+263	8					KeyDownLeft
+264	8					KeyDownRight
+265	8					KeyCenter
+266	5					KeyPgUp
+267	5					KeyPgDn
+268	5					KeyHome
+269	5					KeyEnd
+270	5					KeyInsert
+271	5					KeyDelete
+272	8					KeyHelp
+273	8					KeyExit
+274	8					KeyClear
+275	8		  			KeyCancel
+276	8				  	KeyPrint
+277	8					KeyPause
+278	5					KeyBacktab
+279	5					KeyF1
+280	5					KeyF2
+281	5					KeyF3
+282	5					KeyF4
+283	5					KeyF5
+284	5					KeyF6
+285	5					KeyF7
+286	5					KeyF8
+287	5					KeyF9
+288	5					KeyF10
+289	5					KeyF11
+290	5					KeyF12
+291	8					KeyF13
+292	8					KeyF14
+293	8					KeyF15
+294	8					KeyF16
+295	8					KeyF17
+296	8					KeyF18
+297	8					KeyF19
+298	8					KeyF20
+299	8					KeyF21
+300	8					KeyF22
+301	8					KeyF23
+302	8					KeyF24
+303	8					KeyF25
+304	8					KeyF26
+305	8					KeyF27
+306	8					KeyF28
+307	8					KeyF29
+308	8					KeyF30
+309	8					KeyF31
+310	8					KeyF32
+311	8					KeyF33
+312	8					KeyF34
+313	8					KeyF35
+314	8					KeyF36
+315	8					KeyF37
+316	8					KeyF38
+317	8					KeyF39
+318	8					KeyF40
+319	8					KeyF41
+320	8					KeyF42
+321	8					KeyF43
+322	8					KeyF44
+323	8					KeyF45
+324	8					KeyF46
+325	8					KeyF47
+326	8					KeyF48
+327	8					KeyF49
+328	8					KeyF50
+329	8					KeyF51
+330	8					KeyF52
+331	8					KeyF53
+332	8					KeyF54
+333	8					KeyF55
+334	8					KeyF56
+335	8					KeyF57
+336	8					KeyF58
+337	8					KeyF59
+338	8					KeyF60
+339	8					KeyF61
+340	8					KeyF62
+341	8					KeyF63
+342	8					KeyF64
+--	---------	--------------	---------------	-----------	-------------	----------------	----------
+%v	section #	tcell ctrl key	tcell ctrl char	tcell alias	tui constants	tcell named keys	tcell mods
+*/

src/tui/ttyname_unix.go

@@ -0,0 +1,47 @@
+// +build !windows
+
+package tui
+
+import (
+	"io/ioutil"
+	"os"
+	"syscall"
+)
+
+var devPrefixes = [...]string{"/dev/pts/", "/dev/"}
+
+func ttyname() string {
+	var stderr syscall.Stat_t
+	if syscall.Fstat(2, &stderr) != nil {
+		return ""
+	}
+
+	for _, prefix := range devPrefixes {
+		files, err := ioutil.ReadDir(prefix)
+		if err != nil {
+			continue
+		}
+
+		for _, file := range files {
+			if stat, ok := file.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
+				return prefix + file.Name()
+			}
+		}
+	}
+	return ""
+}
+
+// TtyIn returns terminal device to be used as STDIN, falls back to os.Stdin
+func TtyIn() *os.File {
+	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
+	if err != nil {
+		tty := ttyname()
+		if len(tty) > 0 {
+			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
+				return in
+			}
+		}
+		return os.Stdin
+	}
+	return in
+}

src/tui/ttyname_windows.go

@@ -0,0 +1,14 @@
+// +build windows
+
+package tui
+
+import "os"
+
+func ttyname() string {
+	return ""
+}
+
+// TtyIn on Windows returns os.Stdin
+func TtyIn() *os.File {
+	return os.Stdin
+}

src/tui/tui.go

@@ -0,0 +1,625 @@
+package tui
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"time"
+)
+
+// Types of user action
+type EventType int
+
+const (
+	Rune EventType = iota
+
+	CtrlA
+	CtrlB
+	CtrlC
+	CtrlD
+	CtrlE
+	CtrlF
+	CtrlG
+	CtrlH
+	Tab
+	CtrlJ
+	CtrlK
+	CtrlL
+	CtrlM
+	CtrlN
+	CtrlO
+	CtrlP
+	CtrlQ
+	CtrlR
+	CtrlS
+	CtrlT
+	CtrlU
+	CtrlV
+	CtrlW
+	CtrlX
+	CtrlY
+	CtrlZ
+	ESC
+	CtrlSpace
+
+	// https://apple.stackexchange.com/questions/24261/how-do-i-send-c-that-is-control-slash-to-the-terminal
+	CtrlBackSlash
+	CtrlRightBracket
+	CtrlCaret
+	CtrlSlash
+
+	Invalid
+	Resize
+	Mouse
+	DoubleClick
+	LeftClick
+	RightClick
+
+	BTab
+	BSpace
+
+	Del
+	PgUp
+	PgDn
+
+	Up
+	Down
+	Left
+	Right
+	Home
+	End
+	Insert
+
+	SUp
+	SDown
+	SLeft
+	SRight
+
+	F1
+	F2
+	F3
+	F4
+	F5
+	F6
+	F7
+	F8
+	F9
+	F10
+	F11
+	F12
+
+	Change
+	BackwardEOF
+
+	AltBS
+
+	AltUp
+	AltDown
+	AltLeft
+	AltRight
+
+	AltSUp
+	AltSDown
+	AltSLeft
+	AltSRight
+
+	Alt
+	CtrlAlt
+)
+
+func (t EventType) AsEvent() Event {
+	return Event{t, 0, nil}
+}
+
+func (t EventType) Int() int {
+	return int(t)
+}
+
+func (t EventType) Byte() byte {
+	return byte(t)
+}
+
+func (e Event) Comparable() Event {
+	// Ignore MouseEvent pointer
+	return Event{e.Type, e.Char, nil}
+}
+
+func Key(r rune) Event {
+	return Event{Rune, r, nil}
+}
+
+func AltKey(r rune) Event {
+	return Event{Alt, r, nil}
+}
+
+func CtrlAltKey(r rune) Event {
+	return Event{CtrlAlt, r, nil}
+}
+
+const (
+	doubleClickDuration = 500 * time.Millisecond
+)
+
+type Color int32
+
+func (c Color) IsDefault() bool {
+	return c == colDefault
+}
+
+func (c Color) is24() bool {
+	return c > 0 && (c&(1<<24)) > 0
+}
+
+type ColorAttr struct {
+	Color Color
+	Attr  Attr
+}
+
+func NewColorAttr() ColorAttr {
+	return ColorAttr{Color: colUndefined, Attr: AttrUndefined}
+}
+
+const (
+	colUndefined Color = -2
+	colDefault   Color = -1
+)
+
+const (
+	colBlack Color = iota
+	colRed
+	colGreen
+	colYellow
+	colBlue
+	colMagenta
+	colCyan
+	colWhite
+)
+
+type FillReturn int
+
+const (
+	FillContinue FillReturn = iota
+	FillNextLine
+	FillSuspend
+)
+
+type ColorPair struct {
+	fg   Color
+	bg   Color
+	attr Attr
+}
+
+func HexToColor(rrggbb string) Color {
+	r, _ := strconv.ParseInt(rrggbb[1:3], 16, 0)
+	g, _ := strconv.ParseInt(rrggbb[3:5], 16, 0)
+	b, _ := strconv.ParseInt(rrggbb[5:7], 16, 0)
+	return Color((1 << 24) + (r << 16) + (g << 8) + b)
+}
+
+func NewColorPair(fg Color, bg Color, attr Attr) ColorPair {
+	return ColorPair{fg, bg, attr}
+}
+
+func (p ColorPair) Fg() Color {
+	return p.fg
+}
+
+func (p ColorPair) Bg() Color {
+	return p.bg
+}
+
+func (p ColorPair) Attr() Attr {
+	return p.attr
+}
+
+func (p ColorPair) HasBg() bool {
+	return p.attr&Reverse == 0 && p.bg != colDefault ||
+		p.attr&Reverse > 0 && p.fg != colDefault
+}
+
+func (p ColorPair) merge(other ColorPair, except Color) ColorPair {
+	dup := p
+	dup.attr = dup.attr.Merge(other.attr)
+	if other.fg != except {
+		dup.fg = other.fg
+	}
+	if other.bg != except {
+		dup.bg = other.bg
+	}
+	return dup
+}
+
+func (p ColorPair) WithAttr(attr Attr) ColorPair {
+	dup := p
+	dup.attr = dup.attr.Merge(attr)
+	return dup
+}
+
+func (p ColorPair) MergeAttr(other ColorPair) ColorPair {
+	return p.WithAttr(other.attr)
+}
+
+func (p ColorPair) Merge(other ColorPair) ColorPair {
+	return p.merge(other, colUndefined)
+}
+
+func (p ColorPair) MergeNonDefault(other ColorPair) ColorPair {
+	return p.merge(other, colDefault)
+}
+
+type ColorTheme struct {
+	Colored      bool
+	Input        ColorAttr
+	Disabled     ColorAttr
+	Fg           ColorAttr
+	Bg           ColorAttr
+	PreviewFg    ColorAttr
+	PreviewBg    ColorAttr
+	DarkBg       ColorAttr
+	Gutter       ColorAttr
+	Prompt       ColorAttr
+	Match        ColorAttr
+	Current      ColorAttr
+	CurrentMatch ColorAttr
+	Spinner      ColorAttr
+	Info         ColorAttr
+	Cursor       ColorAttr
+	Selected     ColorAttr
+	Header       ColorAttr
+	Border       ColorAttr
+}
+
+type Event struct {
+	Type       EventType
+	Char       rune
+	MouseEvent *MouseEvent
+}
+
+type MouseEvent struct {
+	Y      int
+	X      int
+	S      int
+	Left   bool
+	Down   bool
+	Double bool
+	Mod    bool
+}
+
+type BorderShape int
+
+const (
+	BorderNone BorderShape = iota
+	BorderRounded
+	BorderSharp
+	BorderHorizontal
+	BorderVertical
+	BorderTop
+	BorderBottom
+	BorderLeft
+	BorderRight
+)
+
+type BorderStyle struct {
+	shape       BorderShape
+	horizontal  rune
+	vertical    rune
+	topLeft     rune
+	topRight    rune
+	bottomLeft  rune
+	bottomRight rune
+}
+
+type BorderCharacter int
+
+func MakeBorderStyle(shape BorderShape, unicode bool) BorderStyle {
+	if unicode {
+		if shape == BorderRounded {
+			return BorderStyle{
+				shape:       shape,
+				horizontal:  '─',
+				vertical:    '│',
+				topLeft:     '╭',
+				topRight:    '╮',
+				bottomLeft:  '╰',
+				bottomRight: '╯',
+			}
+		}
+		return BorderStyle{
+			shape:       shape,
+			horizontal:  '─',
+			vertical:    '│',
+			topLeft:     '┌',
+			topRight:    '┐',
+			bottomLeft:  '└',
+			bottomRight: '┘',
+		}
+	}
+	return BorderStyle{
+		shape:       shape,
+		horizontal:  '-',
+		vertical:    '|',
+		topLeft:     '+',
+		topRight:    '+',
+		bottomLeft:  '+',
+		bottomRight: '+',
+	}
+}
+
+func MakeTransparentBorder() BorderStyle {
+	return BorderStyle{
+		shape:       BorderRounded,
+		horizontal:  ' ',
+		vertical:    ' ',
+		topLeft:     ' ',
+		topRight:    ' ',
+		bottomLeft:  ' ',
+		bottomRight: ' '}
+}
+
+type Renderer interface {
+	Init()
+	Pause(clear bool)
+	Resume(clear bool, sigcont bool)
+	Clear()
+	RefreshWindows(windows []Window)
+	Refresh()
+	Close()
+
+	GetChar() Event
+
+	MaxX() int
+	MaxY() int
+
+	NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window
+}
+
+type Window interface {
+	Top() int
+	Left() int
+	Width() int
+	Height() int
+
+	Refresh()
+	FinishFill()
+	Close()
+
+	X() int
+	Y() int
+	Enclose(y int, x int) bool
+
+	Move(y int, x int)
+	MoveAndClear(y int, x int)
+	Print(text string)
+	CPrint(color ColorPair, text string)
+	Fill(text string) FillReturn
+	CFill(fg Color, bg Color, attr Attr, text string) FillReturn
+	Erase()
+}
+
+type FullscreenRenderer struct {
+	theme        *ColorTheme
+	mouse        bool
+	forceBlack   bool
+	prevDownTime time.Time
+	clickY       []int
+}
+
+func NewFullscreenRenderer(theme *ColorTheme, forceBlack bool, mouse bool) Renderer {
+	r := &FullscreenRenderer{
+		theme:        theme,
+		mouse:        mouse,
+		forceBlack:   forceBlack,
+		prevDownTime: time.Unix(0, 0),
+		clickY:       []int{}}
+	return r
+}
+
+var (
+	Default16 *ColorTheme
+	Dark256   *ColorTheme
+	Light256  *ColorTheme
+
+	ColPrompt               ColorPair
+	ColNormal               ColorPair
+	ColInput                ColorPair
+	ColDisabled             ColorPair
+	ColMatch                ColorPair
+	ColCursor               ColorPair
+	ColCursorEmpty          ColorPair
+	ColSelected             ColorPair
+	ColCurrent              ColorPair
+	ColCurrentMatch         ColorPair
+	ColCurrentCursor        ColorPair
+	ColCurrentCursorEmpty   ColorPair
+	ColCurrentSelected      ColorPair
+	ColCurrentSelectedEmpty ColorPair
+	ColSpinner              ColorPair
+	ColInfo                 ColorPair
+	ColHeader               ColorPair
+	ColBorder               ColorPair
+	ColPreview              ColorPair
+	ColPreviewBorder        ColorPair
+)
+
+func EmptyTheme() *ColorTheme {
+	return &ColorTheme{
+		Colored:      true,
+		Input:        ColorAttr{colUndefined, AttrUndefined},
+		Disabled:     ColorAttr{colUndefined, AttrUndefined},
+		Fg:           ColorAttr{colUndefined, AttrUndefined},
+		Bg:           ColorAttr{colUndefined, AttrUndefined},
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
+		DarkBg:       ColorAttr{colUndefined, AttrUndefined},
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
+		Prompt:       ColorAttr{colUndefined, AttrUndefined},
+		Match:        ColorAttr{colUndefined, AttrUndefined},
+		Current:      ColorAttr{colUndefined, AttrUndefined},
+		CurrentMatch: ColorAttr{colUndefined, AttrUndefined},
+		Spinner:      ColorAttr{colUndefined, AttrUndefined},
+		Info:         ColorAttr{colUndefined, AttrUndefined},
+		Cursor:       ColorAttr{colUndefined, AttrUndefined},
+		Selected:     ColorAttr{colUndefined, AttrUndefined},
+		Header:       ColorAttr{colUndefined, AttrUndefined},
+		Border:       ColorAttr{colUndefined, AttrUndefined}}
+}
+
+func NoColorTheme() *ColorTheme {
+	return &ColorTheme{
+		Colored:      false,
+		Input:        ColorAttr{colDefault, AttrRegular},
+		Disabled:     ColorAttr{colDefault, AttrRegular},
+		Fg:           ColorAttr{colDefault, AttrRegular},
+		Bg:           ColorAttr{colDefault, AttrRegular},
+		PreviewFg:    ColorAttr{colDefault, AttrRegular},
+		PreviewBg:    ColorAttr{colDefault, AttrRegular},
+		DarkBg:       ColorAttr{colDefault, AttrRegular},
+		Gutter:       ColorAttr{colDefault, AttrRegular},
+		Prompt:       ColorAttr{colDefault, AttrRegular},
+		Match:        ColorAttr{colDefault, Underline},
+		Current:      ColorAttr{colDefault, Reverse},
+		CurrentMatch: ColorAttr{colDefault, Reverse | Underline},
+		Spinner:      ColorAttr{colDefault, AttrRegular},
+		Info:         ColorAttr{colDefault, AttrRegular},
+		Cursor:       ColorAttr{colDefault, AttrRegular},
+		Selected:     ColorAttr{colDefault, AttrRegular},
+		Header:       ColorAttr{colDefault, AttrRegular},
+		Border:       ColorAttr{colDefault, AttrRegular}}
+}
+
+func errorExit(message string) {
+	fmt.Fprintln(os.Stderr, message)
+	os.Exit(2)
+}
+
+func init() {
+	Default16 = &ColorTheme{
+		Colored:      true,
+		Input:        ColorAttr{colDefault, AttrUndefined},
+		Disabled:     ColorAttr{colUndefined, AttrUndefined},
+		Fg:           ColorAttr{colDefault, AttrUndefined},
+		Bg:           ColorAttr{colDefault, AttrUndefined},
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
+		DarkBg:       ColorAttr{colBlack, AttrUndefined},
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
+		Prompt:       ColorAttr{colBlue, AttrUndefined},
+		Match:        ColorAttr{colGreen, AttrUndefined},
+		Current:      ColorAttr{colYellow, AttrUndefined},
+		CurrentMatch: ColorAttr{colGreen, AttrUndefined},
+		Spinner:      ColorAttr{colGreen, AttrUndefined},
+		Info:         ColorAttr{colWhite, AttrUndefined},
+		Cursor:       ColorAttr{colRed, AttrUndefined},
+		Selected:     ColorAttr{colMagenta, AttrUndefined},
+		Header:       ColorAttr{colCyan, AttrUndefined},
+		Border:       ColorAttr{colBlack, AttrUndefined}}
+	Dark256 = &ColorTheme{
+		Colored:      true,
+		Input:        ColorAttr{colDefault, AttrUndefined},
+		Disabled:     ColorAttr{colUndefined, AttrUndefined},
+		Fg:           ColorAttr{colDefault, AttrUndefined},
+		Bg:           ColorAttr{colDefault, AttrUndefined},
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
+		DarkBg:       ColorAttr{236, AttrUndefined},
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
+		Prompt:       ColorAttr{110, AttrUndefined},
+		Match:        ColorAttr{108, AttrUndefined},
+		Current:      ColorAttr{254, AttrUndefined},
+		CurrentMatch: ColorAttr{151, AttrUndefined},
+		Spinner:      ColorAttr{148, AttrUndefined},
+		Info:         ColorAttr{144, AttrUndefined},
+		Cursor:       ColorAttr{161, AttrUndefined},
+		Selected:     ColorAttr{168, AttrUndefined},
+		Header:       ColorAttr{109, AttrUndefined},
+		Border:       ColorAttr{59, AttrUndefined}}
+	Light256 = &ColorTheme{
+		Colored:      true,
+		Input:        ColorAttr{colDefault, AttrUndefined},
+		Disabled:     ColorAttr{colUndefined, AttrUndefined},
+		Fg:           ColorAttr{colDefault, AttrUndefined},
+		Bg:           ColorAttr{colDefault, AttrUndefined},
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
+		DarkBg:       ColorAttr{251, AttrUndefined},
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
+		Prompt:       ColorAttr{25, AttrUndefined},
+		Match:        ColorAttr{66, AttrUndefined},
+		Current:      ColorAttr{237, AttrUndefined},
+		CurrentMatch: ColorAttr{23, AttrUndefined},
+		Spinner:      ColorAttr{65, AttrUndefined},
+		Info:         ColorAttr{101, AttrUndefined},
+		Cursor:       ColorAttr{161, AttrUndefined},
+		Selected:     ColorAttr{168, AttrUndefined},
+		Header:       ColorAttr{31, AttrUndefined},
+		Border:       ColorAttr{145, AttrUndefined}}
+}
+
+func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
+	if forceBlack {
+		theme.Bg = ColorAttr{colBlack, AttrUndefined}
+	}
+
+	o := func(a ColorAttr, b ColorAttr) ColorAttr {
+		c := a
+		if b.Color != colUndefined {
+			c.Color = b.Color
+		}
+		if b.Attr != AttrUndefined {
+			c.Attr = b.Attr
+		}
+		return c
+	}
+	theme.Input = o(baseTheme.Input, theme.Input)
+	theme.Disabled = o(theme.Input, o(baseTheme.Disabled, theme.Disabled))
+	theme.Fg = o(baseTheme.Fg, theme.Fg)
+	theme.Bg = o(baseTheme.Bg, theme.Bg)
+	theme.PreviewFg = o(theme.Fg, o(baseTheme.PreviewFg, theme.PreviewFg))
+	theme.PreviewBg = o(theme.Bg, o(baseTheme.PreviewBg, theme.PreviewBg))
+	theme.DarkBg = o(baseTheme.DarkBg, theme.DarkBg)
+	theme.Gutter = o(theme.DarkBg, o(baseTheme.Gutter, theme.Gutter))
+	theme.Prompt = o(baseTheme.Prompt, theme.Prompt)
+	theme.Match = o(baseTheme.Match, theme.Match)
+	theme.Current = o(baseTheme.Current, theme.Current)
+	theme.CurrentMatch = o(baseTheme.CurrentMatch, theme.CurrentMatch)
+	theme.Spinner = o(baseTheme.Spinner, theme.Spinner)
+	theme.Info = o(baseTheme.Info, theme.Info)
+	theme.Cursor = o(baseTheme.Cursor, theme.Cursor)
+	theme.Selected = o(baseTheme.Selected, theme.Selected)
+	theme.Header = o(baseTheme.Header, theme.Header)
+	theme.Border = o(baseTheme.Border, theme.Border)
+
+	initPalette(theme)
+}
+
+func initPalette(theme *ColorTheme) {
+	pair := func(fg, bg ColorAttr) ColorPair {
+		if fg.Color == colDefault && (fg.Attr&Reverse) > 0 {
+			bg.Color = colDefault
+		}
+		return ColorPair{fg.Color, bg.Color, fg.Attr}
+	}
+	blank := theme.Fg
+	blank.Attr = AttrRegular
+
+	ColPrompt = pair(theme.Prompt, theme.Bg)
+	ColNormal = pair(theme.Fg, theme.Bg)
+	ColInput = pair(theme.Input, theme.Bg)
+	ColDisabled = pair(theme.Disabled, theme.Bg)
+	ColMatch = pair(theme.Match, theme.Bg)
+	ColCursor = pair(theme.Cursor, theme.Gutter)
+	ColCursorEmpty = pair(blank, theme.Gutter)
+	ColSelected = pair(theme.Selected, theme.Gutter)
+	ColCurrent = pair(theme.Current, theme.DarkBg)
+	ColCurrentMatch = pair(theme.CurrentMatch, theme.DarkBg)
+	ColCurrentCursor = pair(theme.Cursor, theme.DarkBg)
+	ColCurrentCursorEmpty = pair(blank, theme.DarkBg)
+	ColCurrentSelected = pair(theme.Selected, theme.DarkBg)
+	ColCurrentSelectedEmpty = pair(blank, theme.DarkBg)
+	ColSpinner = pair(theme.Spinner, theme.Bg)
+	ColInfo = pair(theme.Info, theme.Bg)
+	ColHeader = pair(theme.Header, theme.Bg)
+	ColBorder = pair(theme.Border, theme.Bg)
+	ColPreview = pair(theme.PreviewFg, theme.PreviewBg)
+	ColPreviewBorder = pair(theme.Border, theme.PreviewBg)
+}

src/tui/tui_test.go

@@ -0,0 +1,20 @@
+package tui
+
+import "testing"
+
+func TestHexToColor(t *testing.T) {
+	assert := func(expr string, r, g, b int) {
+		color := HexToColor(expr)
+		if !color.is24() ||
+			int((color>>16)&0xff) != r ||
+			int((color>>8)&0xff) != g ||
+			int((color)&0xff) != b {
+			t.Fail()
+		}
+	}
+
+	assert("#ff0000", 255, 0, 0)
+	assert("#010203", 1, 2, 3)
+	assert("#102030", 16, 32, 48)
+	assert("#ffffff", 255, 255, 255)
+}

src/update_assets.rb

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-
-# http://www.rubydoc.info/github/rest-client/rest-client/RestClient
-require 'rest_client'
-
-if ARGV.length < 3
-  puts "usage: #$0 <token> <version> <files...>"
-  exit 1
-end
-
-token, version, *files = ARGV
-base = "https://api.github.com/repos/junegunn/fzf-bin/releases"
-
-# List releases
-rels = JSON.parse(RestClient.get(base, :authorization => "token #{token}"))
-rel = rels.find { |r| r['tag_name'] == version }
-unless rel
-  puts "#{version} not found"
-  exit 1
-end
-
-# List assets
-assets = Hash[rel['assets'].map { |a| a.values_at *%w[name id] }]
-
-files.select { |f| File.exists? f }.each do |file|
-  name = File.basename file
-
-  if asset_id = assets[name]
-    puts "#{name} found. Deleting asset id #{asset_id}."
-    RestClient.delete "#{base}/assets/#{asset_id}",
-      :authorization => "token #{token}"
-  else
-    puts "#{name} not found"
-  end
-
-  puts "Uploading #{name}"
-  RestClient.post(
-    "#{base.sub 'api', 'uploads'}/#{rel['id']}/assets?name=#{name}",
-    File.read(file),
-    :authorization => "token #{token}",
-    :content_type  => "application/octet-stream")
-end

src/util/atomicbool.go

@@ -1,32 +1,34 @@
 package util
 
-import "sync"
+import (
+	"sync/atomic"
+)
+
+func convertBoolToInt32(b bool) int32 {
+	if b {
+		return 1
+	}
+	return 0
+}
 
 // AtomicBool is a boxed-class that provides synchronized access to the
 // underlying boolean value
 type AtomicBool struct {
-	mutex sync.Mutex
+	state int32 // "1" is true, "0" is false
-	state bool
 }
 
 // NewAtomicBool returns a new AtomicBool
 func NewAtomicBool(initialState bool) *AtomicBool {
-	return &AtomicBool{
+	return &AtomicBool{state: convertBoolToInt32(initialState)}
-		mutex: sync.Mutex{},
-		state: initialState}
 }
 
 // Get returns the current boolean value synchronously
 func (a *AtomicBool) Get() bool {
-	a.mutex.Lock()
+	return atomic.LoadInt32(&a.state) == 1
-	defer a.mutex.Unlock()
-	return a.state
 }
 
 // Set updates the boolean value synchronously
 func (a *AtomicBool) Set(newState bool) bool {
-	a.mutex.Lock()
+	atomic.StoreInt32(&a.state, convertBoolToInt32(newState))
-	defer a.mutex.Unlock()
+	return newState
-	a.state = newState
-	return a.state
 }

src/util/chars.go

@@ -0,0 +1,198 @@
+package util
+
+import (
+	"fmt"
+	"unicode"
+	"unicode/utf8"
+	"unsafe"
+)
+
+const (
+	overflow64 uint64 = 0x8080808080808080
+	overflow32 uint32 = 0x80808080
+)
+
+type Chars struct {
+	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(bytes []byte) Chars {
+	inBytes, bytesUntil := checkAscii(bytes)
+	if inBytes {
+		return Chars{slice: bytes, inBytes: inBytes}
+	}
+
+	runes := make([]rune, bytesUntil, len(bytes))
+	for i := 0; i < bytesUntil; i++ {
+		runes[i] = rune(bytes[i])
+	}
+	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{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 runes := chars.optionalRunes(); runes != nil {
+		return runes[i]
+	}
+	return rune(chars.slice[i])
+}
+
+func (chars *Chars) Length() int {
+	if runes := chars.optionalRunes(); runes != nil {
+		return len(runes)
+	}
+	return len(chars.slice)
+}
+
+// String returns the string representation of a Chars object.
+func (chars *Chars) String() string {
+	return fmt.Sprintf("Chars{slice: []byte(%q), inBytes: %v, trimLengthKnown: %v, trimLength: %d, Index: %d}", chars.slice, chars.inBytes, chars.trimLengthKnown, chars.trimLength, chars.Index)
+}
+
+// TrimLength returns the length after trimming leading and trailing whitespaces
+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-- {
+		char := chars.Get(i)
+		if !unicode.IsSpace(char) {
+			break
+		}
+	}
+	// Completely empty
+	if i < 0 {
+		return 0
+	}
+
+	var j int
+	for j = 0; j < len; j++ {
+		char := chars.Get(j)
+		if !unicode.IsSpace(char) {
+			break
+		}
+	}
+	chars.trimLength = AsUint16(i - j + 1)
+	return chars.trimLength
+}
+
+func (chars *Chars) LeadingWhitespaces() int {
+	whitespaces := 0
+	for i := 0; i < chars.Length(); i++ {
+		char := chars.Get(i)
+		if !unicode.IsSpace(char) {
+			break
+		}
+		whitespaces++
+	}
+	return whitespaces
+}
+
+func (chars *Chars) TrailingWhitespaces() int {
+	whitespaces := 0
+	for i := chars.Length() - 1; i >= 0; i-- {
+		char := chars.Get(i)
+		if !unicode.IsSpace(char) {
+			break
+		}
+		whitespaces++
+	}
+	return whitespaces
+}
+
+func (chars *Chars) TrimTrailingWhitespaces() {
+	whitespaces := chars.TrailingWhitespaces()
+	chars.slice = chars.slice[0 : len(chars.slice)-whitespaces]
+}
+
+func (chars *Chars) ToString() string {
+	if runes := chars.optionalRunes(); runes != nil {
+		return string(runes)
+	}
+	return string(chars.slice)
+}
+
+func (chars *Chars) ToRunes() []rune {
+	if runes := chars.optionalRunes(); runes != nil {
+		return runes
+	}
+	bytes := chars.slice
+	runes := make([]rune, len(bytes))
+	for idx, b := range bytes {
+		runes[idx] = rune(b)
+	}
+	return runes
+}
+
+func (chars *Chars) CopyRunes(dest []rune) {
+	if runes := chars.optionalRunes(); runes != nil {
+		copy(dest, runes)
+		return
+	}
+	for idx, b := range chars.slice[:len(dest)] {
+		dest[idx] = rune(b)
+	}
+}
+
+func (chars *Chars) Prepend(prefix string) {
+	if runes := chars.optionalRunes(); runes != nil {
+		runes = append([]rune(prefix), runes...)
+		chars.slice = *(*[]byte)(unsafe.Pointer(&runes))
+	} else {
+		chars.slice = append([]byte(prefix), chars.slice...)
+	}
+}

src/util/chars_test.go

@@ -0,0 +1,46 @@
+package util
+
+import "testing"
+
+func TestToCharsAscii(t *testing.T) {
+	chars := ToChars([]byte("foobar"))
+	if !chars.inBytes || chars.ToString() != "foobar" || !chars.inBytes {
+		t.Error()
+	}
+}
+
+func TestCharsLength(t *testing.T) {
+	chars := ToChars([]byte("\tabc한글  "))
+	if chars.inBytes || chars.Length() != 8 || chars.TrimLength() != 5 {
+		t.Error()
+	}
+}
+
+func TestCharsToString(t *testing.T) {
+	text := "\tabc한글  "
+	chars := ToChars([]byte(text))
+	if chars.ToString() != text {
+		t.Error()
+	}
+}
+
+func TestTrimLength(t *testing.T) {
+	check := func(str string, exp uint16) {
+		chars := ToChars([]byte(str))
+		trimmed := chars.TrimLength()
+		if trimmed != exp {
+			t.Errorf("Invalid TrimLength result for '%s': %d (expected %d)",
+				str, trimmed, exp)
+		}
+	}
+	check("hello", 5)
+	check("hello ", 5)
+	check("hello  ", 5)
+	check(" hello", 5)
+	check("  hello", 5)
+	check(" hello ", 5)
+	check("  hello  ", 5)
+	check("h   o", 5)
+	check("  h   o  ", 5)
+	check("         ", 0)
+}

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

src/util/slab.go

@@ -0,0 +1,12 @@
+package util
+
+type Slab struct {
+	I16 []int16
+	I32 []int32
+}
+
+func MakeSlab(size16 int, size32 int) *Slab {
+	return &Slab{
+		I16: make([]int16, size16),
+		I32: make([]int32, size32)}
+}

src/util/util.go

@@ -1,24 +1,61 @@
 package util
 
-// #include <unistd.h>
-import "C"
-
 import (
+	"math"
 	"os"
-	"os/exec"
+	"strings"
 	"time"
-	"unicode/utf8"
+
+	"github.com/mattn/go-isatty"
+	"github.com/mattn/go-runewidth"
+	"github.com/rivo/uniseg"
 )
 
-// Max returns the largest integer
+// RunesWidth returns runes width
-func Max(first int, items ...int) int {
+func RunesWidth(runes []rune, prefixWidth int, tabstop int, limit int) (int, int) {
-	max := first
+	width := 0
-	for _, item := range items {
+	gr := uniseg.NewGraphemes(string(runes))
-		if item > max {
+	idx := 0
-			max = item
+	for gr.Next() {
+		rs := gr.Runes()
+		var w int
+		if len(rs) == 1 && rs[0] == '\t' {
+			w = tabstop - (prefixWidth+width)%tabstop
+		} else {
+			s := string(rs)
+			w = runewidth.StringWidth(s) + strings.Count(s, "\n")
 		}
+		width += w
+		if width > limit {
+			return width, idx
+		}
+		idx += len(rs)
 	}
-	return max
+	return width, -1
+}
+
+// Max returns the largest integer
+func Max(first int, second int) int {
+	if first >= second {
+		return first
+	}
+	return second
+}
+
+// Max16 returns the largest integer
+func Max16(first int16, second int16) int16 {
+	if first >= second {
+		return first
+	}
+	return second
+}
+
+// Max32 returns the largest 32-bit integer
+func Max32(first int32, second int32) int32 {
+	if first > second {
+		return first
+	}
+	return second
 }
 
 // Min returns the smallest integer
@@ -37,14 +74,6 @@ func Min32(first int32, second int32) int32 {
 	return second
 }
 
-// Max32 returns the largest 32-bit integer
-func Max32(first int32, second int32) int32 {
-	if first > second {
-		return first
-	}
-	return second
-}
-
 // Constrain32 limits the given 32-bit integer with the upper and lower bounds
 func Constrain32(val int32, min int32, max int32) int32 {
 	if val < min {
@@ -67,6 +96,15 @@ func Constrain(val int, min int, max int) int {
 	return val
 }
 
+func AsUint16(val int) uint16 {
+	if val > math.MaxUint16 {
+		return math.MaxUint16
+	} else if val < 0 {
+		return 0
+	}
+	return uint16(val)
+}
+
 // DurWithin limits the given time.Duration with the upper and lower bounds
 func DurWithin(
 	val time.Duration, min time.Duration, max time.Duration) time.Duration {
@@ -79,68 +117,22 @@ func DurWithin(
 	return val
 }
 
-// IsTty returns true is stdin is a terminal
+// IsTty returns true if stdin is a terminal
 func IsTty() bool {
-	return int(C.isatty(C.int(os.Stdin.Fd()))) != 0
+	return isatty.IsTerminal(os.Stdin.Fd())
 }
 
-// TrimRight returns rune array with trailing white spaces cut off
+// ToTty returns true if stdout is a terminal
-func TrimRight(runes []rune) []rune {
+func ToTty() bool {
-	var i int
+	return isatty.IsTerminal(os.Stdout.Fd())
-	for i = len(runes) - 1; i >= 0; i-- {
-		char := runes[i]
-		if char != ' ' && char != '\t' {
-			break
-		}
-	}
-	return runes[0 : i+1]
 }
 
-// BytesToRunes converts byte array into rune array
+// Once returns a function that returns the specified boolean value only once
-func BytesToRunes(bytea []byte) []rune {
+func Once(nextResponse bool) func() bool {
-	runes := make([]rune, 0, len(bytea))
+	state := nextResponse
-	for i := 0; i < len(bytea); {
+	return func() bool {
-		if bytea[i] < utf8.RuneSelf {
+		prevState := state
-			runes = append(runes, rune(bytea[i]))
+		state = false
-			i++
+		return prevState
-		} else {
-			r, sz := utf8.DecodeRune(bytea[i:])
-			i += sz
-			runes = append(runes, r)
-		}
 	}
-	return runes
-}
-
-// TrimLen returns the length of trimmed rune array
-func TrimLen(runes []rune) int {
-	var i int
-	for i = len(runes) - 1; i >= 0; i-- {
-		char := runes[i]
-		if char != ' ' && char != '\t' {
-			break
-		}
-	}
-	// Completely empty
-	if i < 0 {
-		return 0
-	}
-
-	var j int
-	for j = 0; j < len(runes); j++ {
-		char := runes[j]
-		if char != ' ' && char != '\t' {
-			break
-		}
-	}
-	return i - j + 1
-}
-
-// ExecCommand executes the given command with $SHELL
-func ExecCommand(command string) *exec.Cmd {
-	shell := os.Getenv("SHELL")
-	if len(shell) == 0 {
-		shell = "sh"
-	}
-	return exec.Command(shell, "-c", command)
 }

src/util/util_test.go

@@ -3,7 +3,7 @@ package util
 import "testing"
 
 func TestMax(t *testing.T) {
-	if Max(-2, 5, 1, 4, 3) != 5 {
+	if Max(-2, 5) != 5 {
 		t.Error("Invalid result")
 	}
 }
@@ -21,22 +21,36 @@ func TestContrain(t *testing.T) {
 	}
 }
 
-func TestTrimLen(t *testing.T) {
+func TestOnce(t *testing.T) {
-	check := func(str string, exp int) {
+	o := Once(false)
-		trimmed := TrimLen([]rune(str))
+	if o() {
-		if trimmed != exp {
+		t.Error("Expected: false")
-			t.Errorf("Invalid TrimLen result for '%s': %d (expected %d)",
+	}
-				str, trimmed, exp)
+	if o() {
+		t.Error("Expected: false")
+	}
+
+	o = Once(true)
+	if !o() {
+		t.Error("Expected: true")
+	}
+	if o() {
+		t.Error("Expected: false")
+	}
+}
+
+func TestRunesWidth(t *testing.T) {
+	for _, args := range [][]int{
+		{100, 5, -1},
+		{3, 4, 3},
+		{0, 1, 0},
+	} {
+		width, overflowIdx := RunesWidth([]rune("hello"), 0, 0, args[0])
+		if width != args[1] {
+			t.Errorf("Expected width: %d, actual: %d", args[1], width)
+		}
+		if overflowIdx != args[2] {
+			t.Errorf("Expected overflow index: %d, actual: %d", args[2], overflowIdx)
 		}
 	}
-	check("hello", 5)
-	check("hello ", 5)
-	check("hello  ", 5)
-	check(" hello", 5)
-	check("  hello", 5)
-	check(" hello ", 5)
-	check("  hello  ", 5)
-	check("h   o", 5)
-	check("  h   o  ", 5)
-	check("         ", 0)
 }

src/util/util_unix.go

@@ -0,0 +1,47 @@
+// +build !windows
+
+package util
+
+import (
+	"os"
+	"os/exec"
+	"syscall"
+)
+
+// ExecCommand executes the given command with $SHELL
+func ExecCommand(command string, setpgid bool) *exec.Cmd {
+	shell := os.Getenv("SHELL")
+	if len(shell) == 0 {
+		shell = "sh"
+	}
+	return ExecCommandWith(shell, command, setpgid)
+}
+
+// ExecCommandWith executes the given command with the specified shell
+func ExecCommandWith(shell string, command string, setpgid bool) *exec.Cmd {
+	cmd := exec.Command(shell, "-c", command)
+	if setpgid {
+		cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	}
+	return cmd
+}
+
+// KillCommand kills the process for the given command
+func KillCommand(cmd *exec.Cmd) error {
+	return syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
+}
+
+// IsWindows returns true on Windows
+func IsWindows() bool {
+	return false
+}
+
+// SetNonblock executes syscall.SetNonblock on file descriptor
+func SetNonblock(file *os.File, nonblock bool) {
+	syscall.SetNonblock(int(file.Fd()), nonblock)
+}
+
+// Read executes syscall.Read on file descriptor
+func Read(fd int, b []byte) (int, error) {
+	return syscall.Read(int(fd), b)
+}

src/util/util_windows.go

@@ -0,0 +1,83 @@
+// +build windows
+
+package util
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"sync/atomic"
+	"syscall"
+)
+
+var shellPath atomic.Value
+
+// ExecCommand executes the given command with $SHELL
+func ExecCommand(command string, setpgid bool) *exec.Cmd {
+	var shell string
+	if cached := shellPath.Load(); cached != nil {
+		shell = cached.(string)
+	} else {
+		shell = os.Getenv("SHELL")
+		if len(shell) == 0 {
+			shell = "cmd"
+		} else if strings.Contains(shell, "/") {
+			out, err := exec.Command("cygpath", "-w", shell).Output()
+			if err == nil {
+				shell = strings.Trim(string(out), "\n")
+			}
+		}
+		shellPath.Store(shell)
+	}
+	return ExecCommandWith(shell, command, setpgid)
+}
+
+// ExecCommandWith executes the given command with the specified shell
+// FIXME: setpgid is unused. We set it in the Unix implementation so that we
+// can kill preview process with its child processes at once.
+// NOTE: For "powershell", we should ideally set output encoding to UTF8,
+// but it is left as is now because no adverse effect has been observed.
+func ExecCommandWith(shell string, command string, setpgid bool) *exec.Cmd {
+	var cmd *exec.Cmd
+	if strings.Contains(shell, "cmd") {
+		cmd = exec.Command(shell)
+		cmd.SysProcAttr = &syscall.SysProcAttr{
+			HideWindow:    false,
+			CmdLine:       fmt.Sprintf(` /v:on/s/c "%s"`, command),
+			CreationFlags: 0,
+		}
+		return cmd
+	}
+
+	if strings.Contains(shell, "pwsh") || strings.Contains(shell, "powershell") {
+		cmd = exec.Command(shell, "-NoProfile", "-Command", command)
+	} else {
+		cmd = exec.Command(shell, "-c", command)
+	}
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow:    false,
+		CreationFlags: 0,
+	}
+	return cmd
+}
+
+// KillCommand kills the process for the given command
+func KillCommand(cmd *exec.Cmd) error {
+	return cmd.Process.Kill()
+}
+
+// IsWindows returns true on Windows
+func IsWindows() bool {
+	return true
+}
+
+// SetNonblock executes syscall.SetNonblock on file descriptor
+func SetNonblock(file *os.File, nonblock bool) {
+	syscall.SetNonblock(syscall.Handle(file.Fd()), nonblock)
+}
+
+// Read executes syscall.Read on file descriptor
+func Read(fd int, b []byte) (int, error) {
+	return syscall.Read(syscall.Handle(fd), b)
+}