0.24.0

* Fix: barbled multibyte text(exe. Japanese).

* fixup

Co-authored-by: Junegunn Choi <junegunn.c@gmail.com>

.gitignore

@@ -1,5 +1,6 @@
 bin/fzf
 bin/fzf.exe
+dist
 target
 pkg
 Gemfile.lock
@@ -9,3 +10,5 @@ vendor
 gopath
 *.zwc
 fzf
+tmp
+*.patch

.gon.hcl

@@ -0,0 +1,11 @@
+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 = "Apple Development: junegunn.c@gmail.com"
+}

.goreleaser.yml

@@ -0,0 +1,69 @@
+---
+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: gon .gon.hcl
+
+  - 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 }}"
+    format: tar.gz
+    format_overrides:
+      - goos: windows
+        format: zip
+    files:
+      - non-existent*
+
+release:
+  github:
+    owner: junegunn
+    name: fzf
+  prerelease: auto
+  name_template: '{{ .Tag }}'
+
+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,22 +1,28 @@
 language: go
+go:
+  - "1.14"
 env: GO111MODULE=on
 os:
   - linux
   - osx
-dist: bionic # For fish >= 2.3.0 string builtin
+dist: bionic
 addons:
   apt:
     packages:
       - fish
       - zsh
+    sources:
+      sourceline: ppa:fish-shell/release-3
   homebrew:
     packages:
       - fish
       - tmux
     update: true
+install: gem install --no-document minitest:5.14.2 rubocop:1.0.0 rubocop-minitest:0.10.1 rubocop-performance:1.8.1
 script:
   - make test
   # LC_ALL=C to avoid escape codes in
   # printf %q $'\355\205\214\354\212\244\355\212\270' on macOS. Bash on
   # macOS is built without HANDLE_MULTIBYTE?
   - make install && ./install --all && LC_ALL=C tmux new-session -d && ruby test/test_go.rb --verbose
+  - rubocop --require rubocop-minitest --require rubocop-performance

CHANGELOG.md

@@ -1,6 +1,173 @@
 CHANGELOG
 =========
 
+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)

Dockerfile

@@ -1,6 +1,6 @@
 FROM archlinux/base:latest
 RUN pacman -Sy && pacman --noconfirm -S awk git tmux zsh fish ruby procps go make gcc
-RUN gem install --no-document minitest
+RUN gem install --no-document -v 5.14.2 minitest
 RUN echo '. /usr/share/bash-completion/completions/git' >> ~/.bashrc
 RUN echo '. ~/.bashrc' >> ~/.bash_profile
 

Makefile

@@ -5,24 +5,18 @@ MAKEFILE       := $(realpath $(lastword $(MAKEFILE_LIST)))
 ROOT_DIR       := $(shell dirname $(MAKEFILE))
 SOURCES        := $(wildcard *.go src/*.go src/*/*.go) $(MAKEFILE)
 
+VERSION        := $(shell git describe --abbrev=0)
+VERSION_TRIM   := $(shell sed "s/-.*//" <<< $(VERSION))
+VERSION_REGEX  := $(subst .,\.,$(VERSION_TRIM))
 REVISION       := $(shell git log -n 1 --pretty=format:%h -- $(SOURCES))
-BUILD_FLAGS    := -a -ldflags "-X main.revision=$(REVISION) -w -extldflags=$(LDFLAGS)" -tags "$(TAGS)"
+BUILD_FLAGS    := -a -ldflags "-X main.version=$(VERSION) -X main.revision=$(REVISION) -w '-extldflags=$(LDFLAGS)'" -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
-VERSION        := $(shell awk -F= '/version =/ {print $$2}' src/constants.go | tr -d "\" ")
-RELEASE32      := fzf-$(VERSION)-$(GOOS)_386
-RELEASE64      := fzf-$(VERSION)-$(GOOS)_amd64
-RELEASEARM5    := fzf-$(VERSION)-$(GOOS)_arm5
-RELEASEARM6    := fzf-$(VERSION)-$(GOOS)_arm6
-RELEASEARM7    := fzf-$(VERSION)-$(GOOS)_arm7
-RELEASEARM8    := fzf-$(VERSION)-$(GOOS)_arm8
-RELEASEPPC64LE := fzf-$(VERSION)-$(GOOS)_ppc64le
 
 # https://en.wikipedia.org/wiki/Uname
 UNAME_M := $(shell uname -m)
@@ -30,10 +24,6 @@ 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)
@@ -47,43 +37,11 @@ else ifeq ($(UNAME_M),aarch64)
 else ifeq ($(UNAME_M),ppc64le)
 	BINARY := $(BINARYPPC64LE)
 else
-$(error "Build on $(UNAME_M) is not supported, yet.")
+$(error Build on $(UNAME_M) is not supported, yet.)
 endif
 
 all: target/$(BINARY)
 
-target:
-	mkdir -p $@
-
-ifeq ($(GOOS),windows)
-release: target/$(BINARY32) target/$(BINARY64)
-	cd target && cp -f $(BINARY32) fzf.exe && zip $(RELEASE32).zip fzf.exe
-	cd target && cp -f $(BINARY64) fzf.exe && zip $(RELEASE64).zip fzf.exe
-	cd target && rm -f fzf.exe
-else ifeq ($(GOOS),linux)
-release: target/$(BINARY32) target/$(BINARY64) target/$(BINARYARM5) target/$(BINARYARM6) target/$(BINARYARM7) target/$(BINARYARM8) target/$(BINARYPPC64LE)
-	cd target && cp -f $(BINARY32) fzf && tar -czf $(RELEASE32).tgz fzf
-	cd target && cp -f $(BINARY64) fzf && tar -czf $(RELEASE64).tgz fzf
-	cd target && cp -f $(BINARYARM5) fzf && tar -czf $(RELEASEARM5).tgz fzf
-	cd target && cp -f $(BINARYARM6) fzf && tar -czf $(RELEASEARM6).tgz fzf
-	cd target && cp -f $(BINARYARM7) fzf && tar -czf $(RELEASEARM7).tgz fzf
-	cd target && cp -f $(BINARYARM8) fzf && tar -czf $(RELEASEARM8).tgz fzf
-	cd target && cp -f $(BINARYPPC64LE) fzf && tar -czf $(RELEASEPPC64LE).tgz fzf
-	cd target && rm -f fzf
-else
-release: target/$(BINARY32) target/$(BINARY64)
-	cd target && cp -f $(BINARY32) fzf && tar -czf $(RELEASE32).tgz fzf
-	cd target && cp -f $(BINARY64) fzf && tar -czf $(RELEASE64).tgz fzf
-	cd target && rm -f fzf
-endif
-
-release-all: clean test
-	GOOS=darwin  make release
-	GOOS=linux   make release
-	GOOS=freebsd make release
-	GOOS=openbsd make release
-	GOOS=windows make release
-
 test: $(SOURCES)
 	SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" \
 				github.com/junegunn/fzf/src \
@@ -93,11 +51,46 @@ test: $(SOURCES)
 
 install: bin/fzf
 
-clean:
+build:
-	$(RM) -r target
+	goreleaser --rm-dist --snapshot
 
-target/$(BINARY32): $(SOURCES)
+release:
-	GOARCH=386 $(GO) build $(BUILD_FLAGS) -o $@
+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
+	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/$(BINARY64): $(SOURCES)
 	GOARCH=amd64 $(GO) build $(BUILD_FLAGS) -o $@
@@ -133,4 +126,4 @@ update:
 	$(GO) get -u
 	$(GO) mod tidy
 
-.PHONY: all release release-all test install clean docker docker-test update
+.PHONY: all build release test install clean docker docker-test update

README-VIM.md

@@ -127,10 +127,13 @@ let g:fzf_action = {
   \ 'ctrl-v': 'vsplit' }
 
 " Default fzf layout
-" - down / up / left / right
+" - Popup window
-let g:fzf_layout = { 'down': '~40%' }
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 
-" You can set up fzf window using a Vim command (Neovim or latest Vim 8 required)
+" - 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' }
@@ -274,6 +277,7 @@ The following table summarizes the available options.
 | `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}`) |
 
@@ -289,14 +293,13 @@ When `window` entry is a dictionary, fzf will start in a popup window. The
 following options are allowed:
 
 - Required:
-    - `width` [float range [0 ~ 1]]
+    - `width` [float range [0 ~ 1]] or [integer range [8 ~ ]]
-    - `height` [float range [0 ~ 1]]
+    - `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]]
-    - `highlight` [string default `'Comment'`]: Highlight group for border
     - `border` [string default `rounded`]: Border style
-        - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right`
+        - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right` / `none`
 
 `fzf#wrap`
 ----------
@@ -330,8 +333,9 @@ 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 and it opens fzf
+Now it supports `CTRL-T`, `CTRL-V`, and `CTRL-X` key bindings (configurable
-window according to `g:fzf_layout` setting.
+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.
 
@@ -368,6 +372,17 @@ 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 `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
 ----
 
@@ -385,8 +400,8 @@ The latest versions of Vim and Neovim include builtin terminal emulator
 
 ```vim
 " Required:
-" - width [float range [0 ~ 1]]
+" - width [float range [0 ~ 1]] or [integer range [8 ~ ]]
-" - height [float range [0 ~ 1]]
+" - height [float range [0 ~ 1]] or [integer range [4 ~ ]]
 "
 " Optional:
 " - xoffset [float default 0.5 range [0 ~ 1]]
@@ -397,14 +412,26 @@ The latest versions of Vim and Neovim include builtin terminal emulator
 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 use the default layout (`{'down': '~40%'}`) on Neovim, you
+For example, if you use a non-popup layout (e.g. `{'down': '40%'}`) on Neovim,
-might want to temporarily disable the statusline for a cleaner look.
+you might want to temporarily disable the statusline for a cleaner look.
 
 ```vim
 if has('nvim') && !exists('g:fzf_layout')

README.md

@@ -22,42 +22,50 @@ Pros
 Table of Contents
 -----------------
 
-   * [Installation](#installation)
+<!-- vim-markdown-toc GFM -->
-      * [Using Homebrew or Linuxbrew](#using-homebrew-or-linuxbrew)
+
-      * [Using git](#using-git)
+* [Installation](#installation)
-      * [Using Linux package managers](#using-linux-package-managers)
+  * [Using Homebrew or Linuxbrew](#using-homebrew-or-linuxbrew)
-      * [Windows](#windows)
+  * [Using git](#using-git)
-      * [As Vim plugin](#as-vim-plugin)
+  * [Using Linux package managers](#using-linux-package-managers)
-   * [Upgrading fzf](#upgrading-fzf)
+  * [Windows](#windows)
-   * [Building fzf](#building-fzf)
+  * [As Vim plugin](#as-vim-plugin)
-   * [Usage](#usage)
+* [Upgrading fzf](#upgrading-fzf)
-      * [Using the finder](#using-the-finder)
+* [Building fzf](#building-fzf)
-      * [Layout](#layout)
+* [Usage](#usage)
-      * [Search syntax](#search-syntax)
+    * [Using the finder](#using-the-finder)
-      * [Environment variables](#environment-variables)
+    * [Layout](#layout)
-      * [Options](#options)
+    * [Search syntax](#search-syntax)
-      * [Demo](#demo)
+    * [Environment variables](#environment-variables)
-   * [Examples](#examples)
+    * [Options](#options)
-   * [fzf-tmux script](#fzf-tmux-script)
+    * [Demo](#demo)
-   * [Key bindings for command line](#key-bindings-for-command-line)
+* [Examples](#examples)
-   * [Fuzzy completion for bash and zsh](#fuzzy-completion-for-bash-and-zsh)
+* [`fzf-tmux` script](#fzf-tmux-script)
-      * [Files and directories](#files-and-directories)
+* [Key bindings for command-line](#key-bindings-for-command-line)
-      * [Process IDs](#process-ids)
+* [Fuzzy completion for bash and zsh](#fuzzy-completion-for-bash-and-zsh)
-      * [Host names](#host-names)
+    * [Files and directories](#files-and-directories)
-      * [Environment variables / Aliases](#environment-variables--aliases)
+    * [Process IDs](#process-ids)
-      * [Settings](#settings)
+    * [Host names](#host-names)
-      * [Supported commands](#supported-commands)
+    * [Environment variables / Aliases](#environment-variables--aliases)
-      * [Custom fuzzy completion](#custom-fuzzy-completion)
+    * [Settings](#settings)
-   * [Vim plugin](#vim-plugin)
+    * [Supported commands](#supported-commands)
-   * [Advanced topics](#advanced-topics)
+    * [Custom fuzzy completion](#custom-fuzzy-completion)
-      * [Performance](#performance)
+* [Vim plugin](#vim-plugin)
-      * [Executing external programs](#executing-external-programs)
+* [Advanced topics](#advanced-topics)
-      * [Preview window](#preview-window)
+  * [Performance](#performance)
-   * [Tips](#tips)
+  * [Executing external programs](#executing-external-programs)
-      * [Respecting .gitignore](#respecting-gitignore)
+  * [Reloading the candidate list](#reloading-the-candidate-list)
-      * [Fish shell](#fish-shell)
+    * [1. Update the list of processes by pressing CTRL-R](#1-update-the-list-of-processes-by-pressing-ctrl-r)
-   * [Related projects](#related-projects)
+    * [2. Switch between sources by pressing CTRL-D or CTRL-F](#2-switch-between-sources-by-pressing-ctrl-d-or-ctrl-f)
-   * [<a href="LICENSE">License</a>](#license)
+    * [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
 ------------
@@ -74,7 +82,7 @@ fzf project consists of the following components:
 You can [download fzf executable][bin] alone if you don't need the extra
 stuff.
 
-[bin]: https://github.com/junegunn/fzf-bin/releases
+[bin]: https://github.com/junegunn/fzf/releases
 
 ### Using Homebrew or Linuxbrew
 
@@ -104,20 +112,23 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 
 ### Using Linux package managers
 
-| Distro       | Command                    |
+| Package Manager | Linux Distribution      | Command                            |
-| ---          | ---                        |
+| ---             | ---                     | ---                                |
-| Alpine Linux | `sudo apk add fzf`         |
+| APK             | Alpine Linux            | `sudo apk add fzf`                 |
-| Arch Linux   | `sudo pacman -S fzf`       |
+| APT             | Debian 9+/Ubuntu 19.10+ | `sudo apt-get install fzf`         |
-| Debian       | `sudo apt-get install fzf` |
+| Conda           |                         | `conda install -c conda-forge fzf` |
-| Fedora       | `sudo dnf install fzf`     |
+| DNF             | Fedora                  | `sudo dnf install fzf`             |
-| FreeBSD      | `pkg install fzf`          |
+| Nix             | NixOS, etc.             | `nix-env -iA nixpkgs.fzf`          |
-| NixOS        | `nix-env -iA nixpkgs.fzf`  |
+| Pacman          | Arch Linux              | `sudo pacman -S fzf`               |
-| openSUSE     | `sudo zypper install fzf`  |
+| pkg             | FreeBSD                 | `pkg install fzf`                  |
-| OpenBSD      | `pkg_add fzf`              |
+| pkg_add         | OpenBSD                 | `pkg_add fzf`                      |
+| XBPS            | Void Linux              | `sudo xbps-install -S fzf`         |
+| Zypper          | openSUSE                | `sudo zypper install fzf`          |
 
-Shell extensions (key bindings and fuzzy auto-completion) and Vim/Neovim
+> :warning: **Key bindings (CTRL-T / CTRL-R / ALT-C) and fuzzy auto-completion
-plugin may or may not be enabled by default depending on the package manager.
+> may not be enabled by default.**
-Refer to the package documentation for more information.
+>
+> Refer to the package documentation for more information. (e.g. `apt-cache show fzf`)
 
 ### Windows
 
@@ -281,8 +292,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
@@ -291,7 +304,7 @@ 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.
 
 Alternatively, you can use `--height HEIGHT[%]` option not to start fzf in
@@ -318,9 +331,9 @@ fish.
     - 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, you can start fzf in a split pane by setting
+If you're on a tmux session, you can start fzf in a tmux split pane or in
-`FZF_TMUX` to 1, and change the height of the pane with `FZF_TMUX_HEIGHT`
+a tmux popup window by setting `FZF_TMUX_OPTS` (e.g. `-d 40%`).
-(e.g. `20`, `50%`).
+See `fzf-tmux --help` for available options.
 
 More tips can be found on [the wiki page](https://github.com/junegunn/fzf/wiki/Configuring-shell-key-bindings).
 
@@ -524,33 +537,69 @@ 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, ripgrep
+process will restart with the updated query string denoted by the placeholder
+expression `{q}`. Also, note that we used `--phony` 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 --phony --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 `--preview` option is set, fzf automatically starts an external process with
+When the `--preview` option is set, fzf automatically starts an external process
-the current line as the argument and shows the result in the split window. Your
+with the current line as the argument and shows the result in the split window.
-`$SHELL` is used to execute the command with `$SHELL -c COMMAND`.
+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 to the single-quoted string of the focused line
 fzf --preview 'cat {}'
 ```
 
-Since the preview window is updated only after the process is complete, it's
-important that the command finishes quickly.
-
-```bash
-# Use head instead of cat so that the command doesn't take too long to finish
-fzf --preview 'head -100 {}'
-```
-
 Preview window supports ANSI colors, so you can use any program that
-syntax-highlights the content of a file.
+syntax-highlights the content of a file, such as
-
+[Bat](https://github.com/sharkdp/bat) or
-- Bat: https://github.com/sharkdp/bat
+[Highlight](http://www.andre-simon.de/doku/highlight/en/highlight.php):
-- Highlight: http://www.andre-simon.de/doku/highlight/en/highlight.php
 
 ```bash
-fzf --preview 'bat --style=numbers --color=always {} | head -500'
+fzf --preview 'bat --style=numbers --color=always --line-range :500 {}'
 ```
 
 You can customize the size, position, and border of the preview window using
@@ -579,7 +628,7 @@ not a good idea to add `--preview` option to your `$FZF_DEFAULT_OPTS`**.
 # *********************
 # ** DO NOT DO THIS! **
 # *********************
-export FZF_DEFAULT_OPTS='--preview "bat --style=numbers --color=always {} | head -500"'
+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

bin/fzf-tmux

@@ -1,6 +1,6 @@
 #!/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"
@@ -10,6 +10,7 @@ fail() {
 fzf="$(command -v fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
 [[ -x "$fzf" ]] || fail 'fzf executable not found'
 
+tmux_args=()
 args=()
 opt=""
 skip=""
@@ -20,15 +21,23 @@ term=""
 [[ -n "$COLUMNS" ]] && columns=$COLUMNS || columns=$(tput cols) || columns=$(tmux display-message -p "#{pane_width}")
 
 help() {
-  >&2 echo 'usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
+  >&2 echo 'usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
 
-  Layout
+  LAYOUT OPTIONS:
-    -u [HEIGHT[%]]  Split above (up)
+    (default layout: -d 50%)
-    -d [HEIGHT[%]]  Split below (down)
-    -l [WIDTH[%]]   Split left
-    -r [WIDTH[%]]   Split right
 
-    (default: -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
 }
@@ -47,8 +56,10 @@ while [[ $# -gt 0 ]]; do
       echo "fzf-tmux (with fzf $("$fzf" --version))"
       exit
       ;;
-    -w*|-h*|-d*|-u*|-r*|-l*)
+    -p*|-w*|-h*|-x*|-y*|-d*|-u*|-r*|-l*)
-      if [[ "$arg" =~ ^.[lrw] ]]; then
+      if [[ "$arg" =~ ^-[pwhxy] ]]; then
+        [[ "$opt" =~ "-K -E" ]] || opt="-K -E"
+      elif [[ "$arg" =~ ^.[lr] ]]; then
         opt="-h"
         if [[ "$arg" =~ ^.l ]]; then
           opt="$opt -d"
@@ -66,7 +77,7 @@ while [[ $# -gt 0 ]]; do
       if [[ ${#arg} -gt 2 ]]; then
         size="${arg:2}"
       else
-        if [[ "$1" =~ ^[0-9]+%?$ ]]; then
+        if [[ "$1" =~ ^[0-9%,]+$ ]] || [[ "$1" =~ ^[A-Z]$ ]]; then
           size="$1"
           shift
         else
@@ -74,7 +85,15 @@ while [[ $# -gt 0 ]]; do
         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
           opt="$opt -p $(( 100 - size ))"
@@ -100,6 +119,8 @@ 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
       ;;
     *)
@@ -109,17 +130,17 @@ while [[ $# -gt 0 ]]; do
   [[ -n "$skip" ]] && args+=("$arg")
 done
 
-if [[ -z "$TMUX" || "$opt" =~ ^-h && "$columns" -le 40 || ! "$opt" =~ ^-h && "$lines" -le 15 ]]; then
+if [[ -z "$TMUX" ]]; then
   "$fzf" "${args[@]}"
   exit $?
 fi
 
 # --height option is not allowed
-args+=("--no-height")
+args=("${args[@]}" "--no-height")
 
-# Handle zoomed tmux pane by moving it to a temp window
+# Handle zoomed tmux pane without popup options by moving it to a temp window
-if tmux list-panes -F '#F' | grep -q Z; then
+if [[ ! "$opt" =~ "-K -E" ]] && tmux list-panes -F '#F' | grep -q Z; then
-  zoomed=1
+  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'")
   tmux swap-pane -t $tmp_window \; select-window -t $tmp_window
@@ -133,16 +154,17 @@ 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
 
   # Restore tmux window options
   if [[ "${#tmux_win_opts[@]}" -gt 0 ]]; then
-    eval "tmux ${tmux_win_opts[@]}"
+    eval "tmux ${tmux_win_opts[*]}"
   fi
 
-  # Remove temp window if we were zoomed
+  # Remove temp window if we were zoomed without popup options
-  if [[ -n "$zoomed" ]]; then
+  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 \; \
@@ -158,44 +180,45 @@ cleanup() {
 trap 'cleanup 1' SIGUSR1
 trap 'cleanup' EXIT
 
-envs="env TERM=$TERM "
+envs="export TERM=$TERM "
+[[ "$opt" =~ "-K -E" ]] && FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
 [[ -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")"
-
+echo "$envs;" > "$argsf"
-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
 
 pppid=$$
-echo -n "trap 'kill -SIGUSR1 -$pppid' EXIT SIGINT SIGTERM;" > $argsf
+echo -n "trap 'kill -SIGUSR1 -$pppid' EXIT SIGINT SIGTERM;" >> $argsf
 close="; trap - EXIT SIGINT SIGTERM $close"
 
-tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
+export TMUX=$(cut -d , -f 1,2 <<< "$TMUX")
+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 popup -d "$PWD" "${tmux_args[@]}" $opt -R "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
-  TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
-    set-window-option remain-on-exit off \;\
-    split-window $opt "$envs bash -c 'cd $(printf %q "$PWD"); exec -a fzf bash $argsf'" $swap \
-    > /dev/null 2>&1
 else
   mkfifo $fifo1
   cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" >> $argsf
-  TMUX=$(echo $TMUX | cut -d , -f 1,2) tmux set-window-option synchronize-panes off \;\
-    set-window-option remain-on-exit off \;\
-    split-window $opt "$envs bash -c 'exec -a fzf 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

@@ -1,14 +1,17 @@
-fzf.txt	fzf	Last change: February 14 2020
+fzf.txt	fzf	Last change: October 18 2020
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================
 
   FZF Vim integration
+    Installation
     Summary
     :FZF[!]
       Configuration
         Examples
+          Explanation of g:fzf_colors
     fzf#run
     fzf#wrap
+      Global options supported by fzf#wrap
     Tips
       fzf inside terminal buffer
         Starting fzf in a popup window
@@ -19,6 +22,46 @@ 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*
 ==============================================================================
 
@@ -38,12 +81,12 @@ the basic file selector command built on top of them.
    - 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}{1} project.
+   - 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.
 
-                                       {1} https://github.com/junegunn/fzf.vim
+                                       {2} https://github.com/junegunn/fzf.vim
 
 
 :FZF[!]
@@ -63,14 +106,14 @@ the whole if we start off with `:FZF` command.
     " Bang version starts fzf in fullscreen mode
     :FZF!
 <
-Similarly to {ctrlp.vim}{2}, use enter key, CTRL-T, CTRL-X or CTRL-V to open
+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.
 
-                                         {2} https://github.com/kien/ctrlp.vim
+                                         {3} https://github.com/kien/ctrlp.vim
 
 
 < Configuration >_____________________________________________________________~
@@ -112,10 +155,13 @@ Examples~
       \ 'ctrl-v': 'vsplit' }
 
     " Default fzf layout
-    " - down / up / left / right
+    " - Popup window
-    let g:fzf_layout = { 'down': '~40%' }
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 
-    " You can set up fzf window using a Vim command (Neovim or latest Vim 8 required)
+    " - 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' }
@@ -144,6 +190,51 @@ Examples~
     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)
+  `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
+  `prompt`               | Prompt before query ( `> ` )
+ ----------------------+------------------------------------------------------
+ - `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
 ==============================================================================
 
@@ -203,6 +294,7 @@ The following table summarizes the available options.
   `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}` )
  ---------------------------+---------------+----------------------------------------------------------------------
@@ -217,8 +309,8 @@ When `window` entry is a dictionary, fzf will start in a popup window. The
 following options are allowed:
 
  - Required:
-   - `width` [float range [0 ~ 1]]
+   - `width` [float range [0 ~ 1]] or [integer range [8 ~ ]]
-   - `height` [float range [0 ~ 1]]
+   - `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]]
@@ -258,8 +350,8 @@ 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 and it opens fzf
+Now it supports CTRL-T, CTRL-V, and CTRL-X key bindings (configurable via
-window according to `g:fzf_layout` setting.
+`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.
 >
@@ -289,6 +381,19 @@ unique name to our command and pass it as the first argument to `fzf#wrap`.
         \ 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*
 ==============================================================================
 
@@ -309,8 +414,8 @@ Starting fzf in a popup window~
                                             *fzf-starting-fzf-in-a-popup-window*
 >
     " Required:
-    " - width [float range [0 ~ 1]]
+    " - width [float range [0 ~ 1]] or [integer range [8 ~ ]]
-    " - height [float range [0 ~ 1]]
+    " - height [float range [0 ~ 1]] or [integer range [4 ~ ]]
     "
     " Optional:
     " - xoffset [float default 0.5 range [0 ~ 1]]
@@ -320,6 +425,16 @@ Starting fzf in a popup window~
     "   - '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*
@@ -328,8 +443,8 @@ 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 use the default layout (`{'down': '~40%'}`) on Neovim, you
+For example, if you use a non-popup layout (e.g. `{'down': '40%'}`) on Neovim,
-might want to temporarily disable the statusline for a cleaner look.
+you might want to temporarily disable the statusline for a cleaner look.
 >
     if has('nvim') && !exists('g:fzf_layout')
       autocmd! FileType fzf

go.mod

@@ -1,15 +1,15 @@
 module github.com/junegunn/fzf
 
 require (
-	github.com/gdamore/tcell v1.3.0
+	github.com/gdamore/tcell v1.4.0
-	github.com/lucasb-eyer/go-colorful v1.0.3 // indirect
 	github.com/mattn/go-isatty v0.0.12
-	github.com/mattn/go-runewidth v0.0.8
+	github.com/mattn/go-runewidth v0.0.9
-	github.com/mattn/go-shellwords v1.0.9
+	github.com/mattn/go-shellwords v1.0.10
-	github.com/saracen/walker v0.0.0-20191201085201-324a081bae7e
+	github.com/saracen/walker v0.1.1
-	golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d
+	golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897
-	golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5
+	golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9 // indirect
-	golang.org/x/text v0.3.2 // indirect
+	golang.org/x/sys v0.0.0-20201026173827-119d4633e4d1
+	golang.org/x/text v0.3.3 // indirect
 )
 
 go 1.13

go.sum

@@ -1,44 +1,35 @@
-github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 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.3.0 h1:r35w0JBADPZCVQijYebl6YMWWtHRqVEGt7kL2eBADRM=
+github.com/gdamore/tcell v1.4.0 h1:vUnHwJRvcPQa3tzi+0QI4U9JINXYJlOz9yiaiPQ2wMU=
-github.com/gdamore/tcell v1.3.0/go.mod h1:Hjvr+Ofd+gLglo7RYKxxnzCBmev3BzsS67MebKS4zMM=
+github.com/gdamore/tcell v1.4.0/go.mod h1:vxEiSDZdW3L+Uhjii9c3375IlDmR05bzxY404ZVSMo0=
-github.com/lucasb-eyer/go-colorful v1.0.2 h1:mCMFu6PgSozg9tDNMMK3g18oJBX7oYGrC09mS6CXfO4=
-github.com/lucasb-eyer/go-colorful v1.0.2/go.mod h1:0MS4r+7BZKSJ5mw4/S5MPN+qHFF1fYclkSPilDOKW0s=
 github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tWFlaaUAac=
 github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
-github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-shellwords v1.0.10 h1:Y7Xqm8piKOO3v10Thp7Z36h4FYFjt5xB//6XvOrs2Gw=
-github.com/mattn/go-shellwords v1.0.9 h1:eaB5JspOwiKKcHdqcjbfe5lA9cNn/4NRRtddXJCimqk=
+github.com/mattn/go-shellwords v1.0.10/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
-github.com/mattn/go-shellwords v1.0.9/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
+github.com/saracen/walker v0.1.1 h1:Ou2QIKTWqo0QxhtuHVmtObbmhjMCEUyJ82xp0uV+MGI=
-github.com/saracen/walker v0.0.0-20191201085201-324a081bae7e h1:NO86zOn5ScSKW8wRbMaSIcjDZUFpWdCQQnexRqZ9h9A=
+github.com/saracen/walker v0.1.1/go.mod h1:0oKYMsKVhSJ+ful4p/XbjvXbMgLEkLITZaxozsl4CGE=
-github.com/saracen/walker v0.0.0-20191201085201-324a081bae7e/go.mod h1:G0Z6yVPru183i2MuRJx1DcR4dgIZtLcTdaaE/pC1BJU=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d h1:9FCpayM9Egr1baVnV1SX0H87m+XB0B8S0hAMi99X/3U=
+golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897 h1:pLI5jrR7OSLijeIDcmRxNmw2api+jEfxLoykJVice/E=
-golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9 h1:SQFwaSi55rU7vdNs9Yr0Z324VNlrF+0wMqRXT4St8ck=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756 h1:9nuHUbU8dRnRRfj9KjWUVrJeoexdbeMjttk6Oh1rD10=
 golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5 h1:LfCXLvNmTYH9kEmVgqbnsWfruoXZIrh4YBgqVHtDvw0=
+golang.org/x/sys v0.0.0-20201026173827-119d4633e4d1 h1:/DtoiOYKoQCcIFXQjz07RnWNPRCbqmSXSpgEzhC9ZHM=
-golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201026173827-119d4633e4d1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191011211836-4c025a95b26e h1:1o2bDs9pCd2xFhdwqJTrCIswAeEsn4h/PCNelWpfcsI=
-golang.org/x/tools v0.0.0-20191011211836-4c025a95b26e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

install

@@ -2,11 +2,10 @@
 
 set -u
 
-version=0.21.0
+version=0.24.0
 auto_completion=
 key_bindings=
 update_config=2
-binary_arch=
 shells="bash zsh fish"
 prefix='~/.fzf'
 prefix_expand=~/.fzf
@@ -28,9 +27,6 @@ usage: $0 [OPTIONS]
     --no-bash            Do not set up bash configuration
     --no-zsh             Do not set up zsh configuration
     --no-fish            Do not set up fish configuration
-
-    --32                 Download 32-bit binary
-    --64                 Download 64-bit binary
 EOF
 }
 
@@ -56,8 +52,6 @@ for opt in "$@"; do
     --no-completion)   auto_completion=0 ;;
     --update-rc)       update_config=1   ;;
     --no-update-rc)    update_config=0   ;;
-    --32)              binary_arch=386   ;;
-    --64)              binary_arch=amd64 ;;
     --bin)             ;;
     --no-bash)         shells=${shells/bash/} ;;
     --no-zsh)          shells=${shells/zsh/} ;;
@@ -120,7 +114,7 @@ link_fzf_in_path() {
 
 try_curl() {
   command -v curl > /dev/null &&
-  if [[ $1 =~ tgz$ ]]; then
+  if [[ $1 =~ tar.gz$ ]]; then
     curl -fL $1 | tar -xzf -
   else
     local temp=${TMPDIR:-/tmp}/fzf.zip
@@ -130,7 +124,7 @@ try_curl() {
 
 try_wget() {
   command -v wget > /dev/null &&
-  if [[ $1 =~ tgz$ ]]; then
+  if [[ $1 =~ tar.gz$ ]]; then
     wget -O - $1 | tar -xzf -
   else
     local temp=${TMPDIR:-/tmp}/fzf.zip
@@ -140,13 +134,11 @@ try_wget() {
 
 download() {
   echo "Downloading bin/fzf ..."
-  if [[ ! "$version" =~ alpha ]]; 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
-    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"
@@ -154,9 +146,7 @@ download() {
   fi
 
   local url
-  [[ "$version" =~ alpha ]] &&
+  url=https://github.com/junegunn/fzf/releases/download/$version/${1}
-    url=https://github.com/junegunn/fzf-bin/releases/download/alpha/${1} ||
-    url=https://github.com/junegunn/fzf-bin/releases/download/$version/${1}
   set -o pipefail
   if ! (try_curl $url || try_wget $url); then
     set +o pipefail
@@ -178,27 +168,20 @@ archi=$(uname -sm)
 binary_available=1
 binary_error=""
 case "$archi" in
-  Darwin\ *64)   download fzf-$version-darwin_${binary_arch:-amd64}.tgz  ;;
+  Darwin\ *64)     download fzf-$version-darwin_amd64.tar.gz  ;;
-  Darwin\ *86)   download fzf-$version-darwin_${binary_arch:-386}.tgz    ;;
+  Linux\ armv5*)   download fzf-$version-linux_armv5.tar.gz   ;;
-  Linux\ armv5*) download fzf-$version-linux_${binary_arch:-arm5}.tgz    ;;
+  Linux\ armv6*)   download fzf-$version-linux_armv6.tar.gz   ;;
-  Linux\ armv6*) download fzf-$version-linux_${binary_arch:-arm6}.tgz    ;;
+  Linux\ armv7*)   download fzf-$version-linux_armv7.tar.gz   ;;
-  Linux\ armv7*) download fzf-$version-linux_${binary_arch:-arm7}.tgz    ;;
+  Linux\ armv8*)   download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ armv8*) download fzf-$version-linux_${binary_arch:-arm8}.tgz    ;;
+  Linux\ aarch64*) download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ aarch64*) download fzf-$version-linux_${binary_arch:-arm8}.tgz  ;;
+  Linux\ *64)      download fzf-$version-linux_amd64.tar.gz   ;;
-  Linux\ *64)    download fzf-$version-linux_${binary_arch:-amd64}.tgz   ;;
+  FreeBSD\ *64)    download fzf-$version-freebsd_amd64.tar.gz ;;
-  Linux\ *86)    download fzf-$version-linux_${binary_arch:-386}.tgz     ;;
+  OpenBSD\ *64)    download fzf-$version-openbsd_amd64.tar.gz ;;
-  FreeBSD\ *64)  download fzf-$version-freebsd_${binary_arch:-amd64}.tgz ;;
+  CYGWIN*\ *64)    download fzf-$version-windows_amd64.zip    ;;
-  FreeBSD\ *86)  download fzf-$version-freebsd_${binary_arch:-386}.tgz   ;;
+  MINGW*\ *64)     download fzf-$version-windows_amd64.zip    ;;
-  OpenBSD\ *64)  download fzf-$version-openbsd_${binary_arch:-amd64}.tgz ;;
+  MSYS*\ *64)      download fzf-$version-windows_amd64.zip    ;;
-  OpenBSD\ *86)  download fzf-$version-openbsd_${binary_arch:-386}.tgz   ;;
+  Windows*\ *64)   download fzf-$version-windows_amd64.zip    ;;
-  CYGWIN*\ *64)  download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
+  *)               binary_available=0 binary_error=1 ;;
-  MINGW*\ *86)   download fzf-$version-windows_${binary_arch:-386}.zip   ;;
-  MINGW*\ *64)   download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
-  MSYS*\ *86)    download fzf-$version-windows_${binary_arch:-386}.zip   ;;
-  MSYS*\ *64)    download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
-  Windows*\ *86) download fzf-$version-windows_${binary_arch:-386}.zip   ;;
-  Windows*\ *64) download fzf-$version-windows_${binary_arch:-amd64}.zip ;;
-  *)             binary_available=0 binary_error=1 ;;
 esac
 
 cd "$fzf_base"
@@ -384,7 +367,11 @@ fi
 
 if [ $update_config -eq 1 ]; then
   echo 'Finished. Restart your shell or reload config file.'
-  [[ "$shells" =~ bash ]] && echo '   source ~/.bashrc  # bash'
+  if [[ "$shells" =~ bash ]]; then
+    echo -n '   source ~/.bashrc  # bash'
+    [[ "$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

install.ps1

@@ -1,10 +1,4 @@
-$version="0.21.0"
+$version="0.24.0"
-
-if ([Environment]::Is64BitProcess) {
-  $binary_arch="amd64"
-} else {
-  $binary_arch="386"
-}
 
 $fzf_base=Split-Path -Parent $MyInvocation.MyCommand.Definition
 
@@ -32,12 +26,10 @@ function check_binary () {
 function download {
   param($file)
   Write-Host "Downloading bin/fzf ..."
-  if ("$version" -ne "alpha") {
+  if (Test-Path "$fzf_base\bin\fzf.exe") {
-    if (Test-Path "$fzf_base\bin\fzf.exe") {
+    Write-Host "  - Already exists"
-      Write-Host "  - Already exists"
+    if (check_binary) {
-      if (check_binary) {
+      return
-        return
-      }
     }
   }
   if (-not (Test-Path "$fzf_base\bin")) {
@@ -48,16 +40,12 @@ function download {
     return
   }
   cd "$fzf_base\bin"
-  if ("$version" -eq "alpha") {
+  $url="https://github.com/junegunn/fzf/releases/download/$version/$file"
-    $url="https://github.com/junegunn/fzf-bin/releases/download/alpha/$file"
-  } else {
-    $url="https://github.com/junegunn/fzf-bin/releases/download/$version/$file"
-  }
   $temp=$env:TMP + "\fzf.zip"
   [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
   (New-Object Net.WebClient).DownloadFile($url, $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath("$temp"))
   if ($?) {
-    (Expand-Archive -Path $temp -DestinationPath .); (Remove-Item $temp)
+    (Microsoft.PowerShell.Archive\Expand-Archive -Path $temp -DestinationPath .); (Remove-Item $temp)
   } else {
     $binary_error="Failed to download with powershell"
   }
@@ -68,6 +56,6 @@ function download {
   check_binary >$null
 }
 
-download "fzf-$version-windows_$binary_arch.zip"
+download "fzf-$version-windows_amd64.zip"
 
 Write-Host 'For more information, see: https://github.com/junegunn/fzf'

main.go

@@ -5,9 +5,10 @@ import (
 	"github.com/junegunn/fzf/src/protector"
 )
 
+var version string
 var revision string
 
 func main() {
 	protector.Protect()
-	fzf.Run(fzf.ParseOptions(), revision)
+	fzf.Run(fzf.ParseOptions(), version, revision)
 }

man/man1/fzf-tmux.1

@@ -21,25 +21,39 @@ 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 "Mar 2020" "fzf 0.21.0" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Oct 2020" "fzf 0.24.0" "fzf-tmux - open fzf in tmux split pane"
 
 .SH NAME
 fzf-tmux - open fzf in tmux split pane
 
 .SH SYNOPSIS
-.B fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
+.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. It is
+fzf-tmux is a wrapper script for fzf that opens fzf in a tmux split pane or in
-designed to work just like fzf except that it does not take up the whole
+a tmux popup window. It is designed to work just like fzf except that it does
-screen. You can safely use fzf-tmux instead of fzf in your scripts as the extra
+not take up the whole screen. You can safely use fzf-tmux instead of fzf in
-options will be silently ignored if you're not on tmux.
+your scripts as the extra options will be silently ignored if you're not on
+tmux.
 
-.SH OPTIONS
+.SH LAYOUT OPTIONS
-.SS Layout
 
-(default: \fB-d 50%\fR)
+(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)

man/man1/fzf.1

@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf 1 "Mar 2020" "fzf 0.21.0" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Oct 2020" "fzf 0.24.0" "fzf - a command-line fuzzy finder"
 
 .SH NAME
 fzf - a command-line fuzzy finder
@@ -192,6 +192,16 @@ Draw border around the finder
 .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
 
 .TP
 .B "--no-unicode"
@@ -267,11 +277,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. You can also specify 24-bit color in \fB#rrggbb\fR
-format.
 
 .RS
 .B BASE SCHEME:
@@ -282,7 +290,7 @@ format.
     \fB16      \fRColor scheme for 16-color terminal
     \fBbw      \fRNo colors (equivalent to \fB--no-color\fR)
 
-.B COLOR:
+.B COLOR NAMES:
     \fBfg         \fRText
     \fBbg         \fRBackground
     \fBpreview-fg \fRPreview window text
@@ -300,6 +308,21 @@ format.
     \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
+    \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
@@ -379,16 +402,21 @@ 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[%]][:noborder][:wrap][:hidden]"
+.BI "--preview-window=" "[POSITION][:SIZE[%]][:rounded|sharp|noborder][:[no]wrap][:[no]cycle][:[no]hidden][:+SCROLL[-OFFSET]][:default]"
-Determines 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. Long lines are truncated by default.
-Line wrap can be enabled with \fB:wrap\fR flag.
-
-If size is given as 0, preview window will not be visible, but fzf will still
-execute the command in the background.
 
 .RS
 .B POSITION: (default: right)
@@ -396,13 +424,48 @@ execute the command in the background.
     \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. Long lines are truncated by default.
+Line wrap can be enabled with \fB:wrap\fR flag. Cyclic scrolling is enabled
+with \fB:cycle\fR flag.
+
+If size is given as 0, preview window will not be visible, but fzf will still
+execute the command in the background.
+
+To change the style of the border of the preview window, specify one of
+\fBrounded\fR (border with rounded edges, default), \fBsharp\fR (border with
+sharp edges), or \fBnoborder\fR (no border).
+
+\fB+SCROLL[-OFFSET]\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 \fB-OFFSET\fR part is
+for adjusting the base offset so that you can see the text above it. It should
+be given as a numeric integer (\fB-INTEGER\fR), or as a denominator form
+(\fB-/INTEGER\fR) for specifying a fraction of the preview window height.
+
+\fBdefault\fR resets all options previously set to the default.
 
 .RS
 e.g.
-     \fBfzf --preview="head {}" --preview-window=up:30%
+     \fB# Non-default scroll window positions and sizes
-     fzf --preview="file {}" --preview-window=down:1\fR
+     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 (-/2)
+     git grep --line-number '' |
+       fzf --delimiter : \\
+           --preview 'bat --style=numbers --color=always --highlight-line {2} {1}' \\
+           --preview-window +{2}-/2\fR
+
 .RE
+
 .SS Scripting
 .TP
 .BI "-q, --query=" "STR"
@@ -635,12 +698,23 @@ e.g.
 or any single character
 
 .SS AVAILABLE EVENTS:
-\fIchange\fR (triggered whenever the query string is changed)
+\fIchange\fR
-.br
+.RS
+Triggered whenever the query string is changed
 
-    e.g.
+e.g.
-         \fB# Moves cursor to the top (or bottom depending on --layout) whenever the query is changed
+     \fB# Moves cursor to the top (or bottom depending on --layout) whenever the query is changed
-         fzf --bind change:top\fR
+     fzf --bind change:top\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.
@@ -666,7 +740,6 @@ A key or an event can be bound to one or more of the following actions.
     \fBend-of-line\fR               \fIctrl-e  end\fR
     \fBexecute(...)\fR              (see below for the details)
     \fBexecute-silent(...)\fR       (see below for the details)
-    \fRexecute-multi(...)\fR        (deprecated in favor of \fB{+}\fR expression)
     \fBforward-char\fR              \fIctrl-f  right\fR
     \fBforward-word\fR              \fIalt-f   shift-right\fR
     \fBignore\fR
@@ -679,12 +752,16 @@ A key or an event can be bound to one or more of the following actions.
     \fBpage-up\fR                   \fIpgup\fR
     \fBhalf-page-down\fR
     \fBhalf-page-up\fR
+    \fBpreview(...)\fR              (see below for the details)
     \fBpreview-down\fR              \fIshift-down\fR
     \fBpreview-up\fR                \fIshift-up\fR
     \fBpreview-page-down\fR
     \fBpreview-page-up\fR
+    \fBpreview-half-page-down\fR
+    \fBpreview-half-page-up\fR
     \fBprevious-history\fR          (\fIctrl-p\fR on \fB--history\fR)
     \fBprint-query\fR               (print query and exit)
+    \fBrefresh-preview\fR
     \fBreload(...)\fR               (see below for the details)
     \fBreplace-query\fR             (replace query string with the current selection)
     \fBselect-all\fR                (select all matches)
@@ -771,6 +848,24 @@ e.g.
        fzf --bind "change:reload:$RG_PREFIX {q} || true" \\
            --ansi --phony --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
+
 .SH AUTHOR
 Junegunn Choi (\fIjunegunn.c@gmail.com\fR)
 

plugin/fzf.vim

@@ -115,14 +115,23 @@ function! s:fzf_tempname()
   return s:fzf_call('tempname')
 endfunction
 
-let s:default_layout = { 'down': '~40%' }
+let s:layout_keys = ['window', 'tmux', 'up', 'down', 'left', 'right']
-let s:layout_keys = ['window', 'up', 'down', 'left', 'right']
 let s:fzf_go = s:base_dir.'/bin/fzf'
 let s:fzf_tmux = s:base_dir.'/bin/fzf-tmux'
 
 let s:cpo_save = &cpo
 set cpo&vim
 
+function! s:popup_support()
+  return has('nvim') ? has('nvim-0.4') : has('popupwin') && has('patch-8.2.191')
+endfunction
+
+function! s:default_layout()
+  return s:popup_support()
+        \ ? { 'window' : { 'width': 0.9, 'height': 0.6 } }
+        \ : { 'down': '~40%' }
+endfunction
+
 function! fzf#install()
   if s:is_win && !has('win32unix')
     let script = s:base_dir.'/install.ps1'
@@ -145,7 +154,20 @@ function! fzf#install()
   endif
 endfunction
 
-function! s:fzf_exec()
+function! s:version_requirement(val, min)
+  let val = split(a:val, '\.')
+  let min = split(a:min, '\.')
+  for idx in range(0, len(min) - 1)
+    let v = get(val, idx, 0)
+    if     v < min[idx] | return 0
+    elseif v > min[idx] | return 1
+    endif
+  endfor
+  return 1
+endfunction
+
+let s:checked = {}
+function! fzf#exec(...)
   if !exists('s:exec')
     if executable(s:fzf_go)
       let s:exec = s:fzf_go
@@ -154,13 +176,33 @@ function! s:fzf_exec()
     elseif input('fzf executable not found. Download binary? (y/n) ') =~? '^y'
       redraw
       call fzf#install()
-      return s:fzf_exec()
+      return fzf#exec()
     else
       redraw
       throw 'fzf executable not found'
     endif
   endif
-  return fzf#shellescape(s:exec)
+
+  if a:0 && !has_key(s:checked, a:1)
+    let command = s:exec . ' --version'
+    let output = systemlist(command)
+    if v:shell_error || empty(output)
+      throw printf('Failed to run "%s": %s', command, output)
+    endif
+    let fzf_version = matchstr(output[0], '[0-9.]\+')
+    if s:version_requirement(fzf_version, a:1)
+      let s:checked[a:1] = 1
+      return s:exec
+    elseif a:0 < 2 && input(printf('You need fzf %s or above. Found: %s. Download binary? (y/n) ', a:1, fzf_version)) =~? '^y'
+      redraw
+      call fzf#install()
+      return fzf#exec(a:1, 1)
+    else
+      throw printf('You need to upgrade fzf (required: %s or above)', a:1)
+    endif
+  endif
+
+  return s:exec
 endfunction
 
 function! s:tmux_enabled()
@@ -191,21 +233,6 @@ function! s:escape(path)
   return s:is_win ? escape(path, '$') : path
 endfunction
 
-" Upgrade legacy options
-function! s:upgrade(dict)
-  let copy = copy(a:dict)
-  if has_key(copy, 'tmux')
-    let copy.down = remove(copy, 'tmux')
-  endif
-  if has_key(copy, 'tmux_height')
-    let copy.down = remove(copy, 'tmux_height')
-  endif
-  if has_key(copy, 'tmux_width')
-    let copy.right = remove(copy, 'tmux_width')
-  endif
-  return copy
-endfunction
-
 function! s:error(msg)
   echohl ErrorMsg
   echom a:msg
@@ -251,9 +278,13 @@ function! s:common_sink(action, lines) abort
   endif
   try
     let empty = empty(s:fzf_expand('%')) && line('$') == 1 && empty(getline(1)) && !&modified
-    let autochdir = &autochdir
+    " Preserve the current working directory in case it's changed during
-    set noautochdir
+    " the execution (e.g. `set autochdir` or `autocmd BufEnter * lcd ...`)
+    let cwd = exists('w:fzf_pushd') ? w:fzf_pushd.dir : expand('%:p:h')
     for item in a:lines
+      if item[0] != '~' && item !~ (s:is_win ? '^[A-Z]:\' : '^/')
+        let item = join([cwd, item], (s:is_win ? '\' : '/'))
+      endif
       if empty
         execute 'e' s:escape(item)
         let empty = 0
@@ -267,7 +298,6 @@ function! s:common_sink(action, lines) abort
     endfor
   catch /^Vim:Interrupt$/
   finally
-    let &autochdir = autochdir
     silent! autocmd! fzf_swap
   endtry
 endfunction
@@ -312,7 +342,7 @@ function! fzf#wrap(...)
   let expects = map(copy(args), 'type(v:val)')
   let tidx = 0
   for arg in copy(a:000)
-    let tidx = index(expects, type(arg), tidx)
+    let tidx = index(expects, type(arg) == 6 ? type(0) : type(arg), tidx)
     if tidx < 0
       throw 'Invalid arguments (expected: [name string] [opts dict] [fullscreen boolean])'
     endif
@@ -337,7 +367,7 @@ function! fzf#wrap(...)
     if !exists('g:fzf_layout') && exists('g:fzf_height')
       let opts.down = g:fzf_height
     else
-      let opts = extend(opts, s:validate_layout(get(g:, 'fzf_layout', s:default_layout)))
+      let opts = extend(opts, s:validate_layout(get(g:, 'fzf_layout', s:default_layout())))
     endif
   endif
 
@@ -384,11 +414,11 @@ function! fzf#run(...) abort
 try
   let [shell, shellslash, shellcmdflag, shellxquote] = s:use_sh()
 
-  let dict   = exists('a:1') ? s:upgrade(a:1) : {}
+  let dict   = exists('a:1') ? copy(a:1) : {}
   let temps  = { 'result': s:fzf_tempname() }
   let optstr = s:evaluate_opts(get(dict, 'options', ''))
   try
-    let fzf_exec = s:fzf_exec()
+    let fzf_exec = fzf#shellescape(fzf#exec())
   catch
     throw v:exception
   endtry
@@ -407,7 +437,7 @@ try
       let prefix = '( '.source.' )|'
     elseif type == 3
       let temps.input = s:fzf_tempname()
-      call writefile(map(source, '<SID>enc_to_cp(v:val)'), temps.input)
+      call writefile(source, temps.input)
       let prefix = (s:is_win ? 'type ' : 'cat ').fzf#shellescape(temps.input).'|'
     else
       throw 'Invalid source type'
@@ -416,7 +446,7 @@ try
     let prefix = ''
   endif
 
-  let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0)
+  let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0) || has_key(dict, 'tmux')
   let use_height = has_key(dict, 'down') && !has('gui_running') &&
         \ !(has('nvim') || s:is_win || has('win32unix') || s:present(dict, 'up', 'left', 'right', 'window')) &&
         \ executable('tput') && filereadable('/dev/tty')
@@ -424,7 +454,7 @@ try
   let has_nvim_term = has('nvim-0.2.1') || has('nvim') && !s:is_win
   let use_term = has_nvim_term ||
     \ has_vim8_term && !has('win32unix') && (has('gui_running') || s:is_win || !use_height && s:present(dict, 'down', 'up', 'left', 'right', 'window'))
-  let use_tmux = (!use_height && !use_term || prefer_tmux) && !has('win32unix') && s:tmux_enabled() && s:splittable(dict)
+  let use_tmux = (has_key(dict, 'tmux') || (!use_height && !use_term || prefer_tmux) && !has('win32unix') && s:splittable(dict)) && s:tmux_enabled()
   if prefer_tmux && use_tmux
     let use_height = 0
     let use_term = 0
@@ -435,6 +465,7 @@ try
   elseif use_term
     let optstr .= ' --no-height'
   endif
+  let optstr .= s:border_opt(get(dict, 'window', 0))
   let command = prefix.(use_tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
 
   if use_term
@@ -460,19 +491,21 @@ function! s:present(dict, ...)
 endfunction
 
 function! s:fzf_tmux(dict)
-  let size = ''
+  let size = get(a:dict, 'tmux', '')
-  for o in ['up', 'down', 'left', 'right']
+  if empty(size)
-    if s:present(a:dict, o)
+    for o in ['up', 'down', 'left', 'right']
-      let spec = a:dict[o]
+      if s:present(a:dict, o)
-      if (o == 'up' || o == 'down') && spec[0] == '~'
+        let spec = a:dict[o]
-        let size = '-'.o[0].s:calc_size(&lines, spec, a:dict)
+        if (o == 'up' || o == 'down') && spec[0] == '~'
-      else
+          let size = '-'.o[0].s:calc_size(&lines, spec, a:dict)
-        " Legacy boolean option
+        else
-        let size = '-'.o[0].(spec == 1 ? '' : substitute(spec, '^\~', '', ''))
+          " Legacy boolean option
+          let size = '-'.o[0].(spec == 1 ? '' : substitute(spec, '^\~', '', ''))
+        endif
+        break
       endif
-      break
+    endfor
-    endif
+  endif
-  endfor
   return printf('LINES=%d COLUMNS=%d %s %s %s --',
     \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size, (has_key(a:dict, 'source') ? '' : '-'))
 endfunction
@@ -527,7 +560,7 @@ function! s:dopopd()
   if s:fzf_getcwd() ==# w:fzf_pushd.dir && (!&autochdir || w:fzf_pushd.bufname ==# bufname(''))
     execute w:fzf_pushd.command s:escape(w:fzf_pushd.origin)
   endif
-  unlet w:fzf_pushd
+  unlet! w:fzf_pushd
 endfunction
 
 function! s:xterm_launcher()
@@ -642,6 +675,9 @@ function! s:calc_size(max, val, dict)
   endif
 
   let opts = $FZF_DEFAULT_OPTS.' '.s:evaluate_opts(get(a:dict, 'options', ''))
+  if opts =~ 'preview'
+    return size
+  endif
   let margin = match(opts, '--inline-info\|--info[^-]\{-}inline') > match(opts, '--no-inline-info\|--info[^-]\{-}\(default\|hidden\)') ? 1 : 2
   let margin += stridx(opts, '--border') > stridx(opts, '--no-border') ? 2 : 0
   if stridx(opts, '--header') > stridx(opts, '--no-header')
@@ -651,7 +687,33 @@ function! s:calc_size(max, val, dict)
 endfunction
 
 function! s:getpos()
-  return {'tab': tabpagenr(), 'win': winnr(), 'cnt': winnr('$'), 'tcnt': tabpagenr('$')}
+  return {'tab': tabpagenr(), 'win': winnr(), 'winid': win_getid(), 'cnt': winnr('$'), 'tcnt': tabpagenr('$')}
+endfunction
+
+function! s:border_opt(window)
+  if type(a:window) != type({})
+    return ''
+  endif
+
+  " Border style
+  let style = tolower(get(a:window, 'border', 'rounded'))
+  if !has_key(a:window, 'border') && !get(a:window, 'rounded', 1)
+    let style = 'sharp'
+  endif
+  if style == 'none'
+    return ''
+  endif
+
+  " For --border styles, we need fzf 0.24.0 or above
+  call fzf#exec('0.24.0')
+  let opt = ' --border=' . style
+  if has_key(a:window, 'highlight')
+    let color = s:get_color('fg', a:window.highlight)
+    if len(color)
+      let opt .= ' --color=border:' . color
+    endif
+  endif
+  return opt
 endfunction
 
 function! s:split(dict)
@@ -661,13 +723,15 @@ function! s:split(dict)
   \ 'left':  ['vertical topleft', 'vertical resize', &columns],
   \ 'right': ['vertical botright', 'vertical resize', &columns] }
   let ppos = s:getpos()
+  let is_popup = 0
   try
     if s:present(a:dict, 'window')
       if type(a:dict.window) == type({})
-        if !has('nvim') && !has('patch-8.2.191')
+        if !s:popup_support()
-          throw 'Vim 8.2.191 or later is required for pop-up window'
+          throw 'Nvim 0.4+ or Vim 8.2.191+ with popupwin feature is required for pop-up window'
         end
         call s:popup(a:dict.window)
+        let is_popup = 1
       else
         execute 'keepalt' a:dict.window
       endif
@@ -685,20 +749,22 @@ function! s:split(dict)
           endif
           execute cmd sz.'new'
           execute resz sz
-          return [ppos, {}]
+          return [ppos, {}, is_popup]
         endif
       endfor
     endif
-    return [ppos, { '&l:wfw': &l:wfw, '&l:wfh': &l:wfh }]
+    return [ppos, is_popup ? {} : { '&l:wfw': &l:wfw, '&l:wfh': &l:wfh }, is_popup]
   finally
-    setlocal winfixwidth winfixheight
+    if !is_popup
+      setlocal winfixwidth winfixheight
+    endif
   endtry
 endfunction
 
 function! s:execute_term(dict, command, temps) abort
   let winrest = winrestcmd()
   let pbuf = bufnr('')
-  let [ppos, winopts] = s:split(a:dict)
+  let [ppos, winopts, is_popup] = s:split(a:dict)
   call s:use_sh()
   let b:fzf = a:dict
   let fzf = { 'buf': bufnr(''), 'pbuf': pbuf, 'ppos': ppos, 'dict': a:dict, 'temps': a:temps,
@@ -727,8 +793,8 @@ function! s:execute_term(dict, command, temps) abort
         " there's no other listed buffer (nvim +'set nobuflisted')
         close
       endif
-      execute 'tabnext' self.ppos.tab
+      silent! execute 'tabnext' self.ppos.tab
-      execute self.ppos.win.'wincmd w'
+      silent! execute self.ppos.win.'wincmd w'
     endif
 
     if bufexists(self.buf)
@@ -762,11 +828,17 @@ function! s:execute_term(dict, command, temps) abort
     if has('nvim')
       call termopen(command, fzf)
     else
-      if !len(&bufhidden)
+      let term_opts = {'exit_cb': function(fzf.on_exit)}
-        setlocal bufhidden=hide
+      if is_popup
+        let term_opts.hidden = 1
+      else
+        let term_opts.curwin = 1
       endif
-      let fzf.buf = term_start([&shell, &shellcmdflag, command], {'curwin': 1, 'exit_cb': function(fzf.on_exit)})
+      let fzf.buf = term_start([&shell, &shellcmdflag, command], term_opts)
-      if !has('patch-8.0.1261') && !has('nvim') && !s:is_win
+      if is_popup && exists('#TerminalWinOpen')
+        doautocmd <nomodeline> TerminalWinOpen
+      endif
+      if !has('patch-8.0.1261') && !s:is_win
         call term_wait(fzf.buf, 20)
       endif
     endif
@@ -837,34 +909,29 @@ if has('nvim')
 else
   function! s:create_popup(hl, opts) abort
     let is_frame = has_key(a:opts, 'border')
-    let buf = is_frame ? '' : term_start(&shell, #{hidden: 1})
+    let s:popup_create = {buf -> popup_create(buf, #{
-    let id = popup_create(buf, #{
       \ line: a:opts.row,
       \ col: a:opts.col,
       \ minwidth: a:opts.width,
       \ minheight: a:opts.height,
       \ zindex: 50 - is_frame,
-    \ })
+    \ })}
-
     if is_frame
+      let id = s:popup_create('')
       call setwinvar(id, '&wincolor', a:hl)
       call setbufline(winbufnr(id), 1, a:opts.border)
       execute 'autocmd BufWipeout * ++once call popup_close('..id..')'
+      return winbufnr(id)
     else
-      execute 'autocmd BufWipeout * ++once bwipeout! '..buf
+      autocmd TerminalOpen * ++once call s:popup_create(str2nr(expand('<abuf>')))
     endif
-    return winbufnr(id)
   endfunction
 endif
 
 function! s:popup(opts) abort
-  " Support ambiwidth == 'double'
-  let ambidouble = &ambiwidth == 'double' ? 2 : 1
-
   " Size and position
-  let width = min([max([0, float2nr(&columns * a:opts.width)]), &columns])
+  let width = min([max([8, a:opts.width > 1 ? a:opts.width : float2nr(&columns * a:opts.width)]), &columns])
-  let width += width % ambidouble
+  let height = min([max([4, a:opts.height > 1 ? a:opts.height : float2nr(&lines * a:opts.height)]), &lines - has('nvim')])
-  let height = min([max([0, float2nr(&lines * a:opts.height)]), &lines - has('nvim')])
   let row = float2nr(get(a:opts, 'yoffset', 0.5) * (&lines - height))
   let col = float2nr(get(a:opts, 'xoffset', 0.5) * (&columns - width))
 
@@ -874,45 +941,9 @@ function! s:popup(opts) abort
   let row += !has('nvim')
   let col += !has('nvim')
 
-  " Border style
-  let style = tolower(get(a:opts, 'border', 'rounded'))
-  if !has_key(a:opts, 'border') && !get(a:opts, 'rounded', 1)
-    let style = 'sharp'
-  endif
-
-  if style =~ 'vertical\|left\|right'
-    let mid = style == 'vertical' ? '│' .. repeat(' ', width - 2 * ambidouble) .. '│' :
-            \ style == 'left'     ? '│' .. repeat(' ', width - 1 * ambidouble)
-            \                     :        repeat(' ', width - 1 * ambidouble) .. '│'
-    let border = repeat([mid], height)
-    let shift = { 'row': 0, 'col': style == 'right' ? 0 : 2, 'width': style == 'vertical' ? -4 : -2, 'height': 0 }
-  elseif style =~ 'horizontal\|top\|bottom'
-    let hor = repeat('─', width / ambidouble)
-    let mid = repeat(' ', width)
-    let border = style == 'horizontal' ? [hor] + repeat([mid], height - 2) + [hor] :
-               \ style == 'top'        ? [hor] + repeat([mid], height - 1)
-               \                       :         repeat([mid], height - 1) + [hor]
-    let shift = { 'row': style == 'bottom' ? 0 : 1, 'col': 0, 'width': 0, 'height': style == 'horizontal' ? -2 : -1 }
-  else
-    let edges = style == 'sharp' ? ['┌', '┐', '└', '┘'] : ['╭', '╮', '╰', '╯']
-    let bar = repeat('─', width / ambidouble - 2)
-    let top = edges[0] .. bar .. edges[1]
-    let mid = '│' .. repeat(' ', width - 2 * ambidouble) .. '│'
-    let bot = edges[2] .. bar .. edges[3]
-    let border = [top] + repeat([mid], height - 2) + [bot]
-    let shift = { 'row': 1, 'col': 2, 'width': -4, 'height': -2 }
-  endif
-
-  let highlight = get(a:opts, 'highlight', 'Comment')
-  let frame = s:create_popup(highlight, {
-    \ 'row': row, 'col': col, 'width': width, 'height': height, 'border': border
-  \ })
   call s:create_popup('Normal', {
-    \ 'row': row + shift.row, 'col': col + shift.col, 'width': width + shift.width, 'height': height + shift.height
+    \ 'row': row, 'col': col, 'width': width, 'height': height
   \ })
-  if has('nvim')
-    execute 'autocmd BufWipeout <buffer> bwipeout '..frame
-  endif
 endfunction
 
 let s:default_action = {

shell/completion.bash

@@ -2,10 +2,10 @@
 #    / __/___  / __/
 #   / /_/_  / / /_
 #  / __/ / /_/ __/
-# /_/   /___/_/-completion.bash
+# /_/   /___/_/ completion.bash
 #
 # - $FZF_TMUX               (default: 0)
-# - $FZF_TMUX_HEIGHT        (default: '40%')
+# - $FZF_TMUX_OPTS          (default: empty)
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
@@ -37,9 +37,9 @@ bind '"\e[0n": redraw-current-line'
 __fzf_comprun() {
   if [ "$(type -t _fzf_comprun 2>&1)" = function ]; then
     _fzf_comprun "$@"
-  elif [ -n "$TMUX_PANE" ] && [ "${FZF_TMUX:-0}" != 0 ] && [ ${LINES:-40} -gt 15 ]; then
+  elif [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; }; then
     shift
-    fzf-tmux -d "${FZF_TMUX_HEIGHT:-40%}" "$@"
+    fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- "$@"
   else
     shift
     fzf "$@"
@@ -249,22 +249,30 @@ _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
+  if [[ -z "$cur" ]]; then
-  selected=$(command ps -ef | sed 1d | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-50%} --min-height 15 --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS --preview 'echo {}' --preview-window down:3:wrap" __fzf_comprun "kill" -m | awk '{print $2}' | tr '\n' ' ')
+    COMP_WORDS[$COMP_CWORD]=$trigger
-  selected=${selected% }
+  elif [[ "$cur" != *"$trigger" ]]; then
-  printf '\e[5n'
+    return 1
-
-  if [ -n "$selected" ]; then
-    COMPREPLY=( "$selected" )
-    return 0
   fi
+
+  _fzf_proc_completion "$@"
+}
+
+_fzf_proc_completion() {
+  _fzf_complete -m --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+    command ps -ef | sed 1d
+  )
+}
+
+_fzf_proc_completion_post() {
+  awk '{print $2}'
 }
 
 _fzf_host_completion() {
   _fzf_complete +m -- "$@" < <(
-    cat <(cat ~/.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 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
@@ -296,11 +304,10 @@ a_cmds="
   find git grep gunzip gzip hg jar
   ln ls mv open rm rsync scp
   svn tar unzip zip"
-x_cmds="kill"
 
 # Preserve existing completion
 eval "$(complete |
-  sed -E '/-F/!d; / _fzf/d; '"/ ($(echo $d_cmds $a_cmds $x_cmds | sed 's/ /|/g; s/+/\\+/g'))$/"'!d' |
+  sed -E '/-F/!d; / _fzf/d; '"/ ($(echo $d_cmds $a_cmds | sed 's/ /|/g; s/+/\\+/g'))$/"'!d' |
   __fzf_orig_completion_filter)"
 
 if type _completion_loader > /dev/null 2>&1; then
@@ -332,17 +339,17 @@ for cmd in $d_cmds; do
   __fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o dirnames"
 done
 
-# Kill completion
+# Kill completion (supports empty completion trigger)
 complete -F _fzf_complete_kill -o default -o bashdefault kill
 
-unset cmd d_cmds a_cmds x_cmds
+unset cmd d_cmds a_cmds
 
 _fzf_setup_completion() {
   local kind fn cmd
   kind=$1
   fn=_fzf_${1}_completion
   if [[ $# -lt 2 ]] || ! type -t "$fn" > /dev/null; then
-    echo "usage: ${FUNCNAME[0]} path|dir|var|alias|host COMMANDS..."
+    echo "usage: ${FUNCNAME[0]} path|dir|var|alias|host|proc COMMANDS..."
     return 1
   fi
   shift

shell/completion.zsh

@@ -2,14 +2,79 @@
 #    / __/___  / __/
 #   / /_/_  / / /_
 #  / __/ / /_/ __/
-# /_/   /___/_/-completion.zsh
+# /_/   /___/_/ completion.zsh
 #
 # - $FZF_TMUX               (default: 0)
-# - $FZF_TMUX_HEIGHT        (default: '40%')
+# - $FZF_TMUX_OPTS          (default: '-d 40%')
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
-if [[ $- =~ i ]]; then
+# 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
@@ -34,9 +99,13 @@ fi
 __fzf_comprun() {
   if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
     _fzf_comprun "$@"
-  elif [ -n "$TMUX_PANE" ] && [ "${FZF_TMUX:-0}" != 0 ] && [ ${LINES:-40} -gt 15 ]; then
+  elif [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; }; then
     shift
-    fzf-tmux -d "${FZF_TMUX_HEIGHT:-40%}" "$@"
+    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 "$@"
@@ -48,6 +117,7 @@ __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
@@ -112,7 +182,7 @@ _fzf_complete() {
   local args rest str_arg i sep
   args=("$@")
   sep=
-  for i in {0..$#args}; do
+  for i in {0..${#args[@]}}; do
     if [[ "${args[$i]}" = -- ]]; then
       sep=$i
       break
@@ -155,7 +225,7 @@ _fzf_complete_telnet() {
 _fzf_complete_ssh() {
   _fzf_complete +m -- "$@" < <(
     setopt localoptions nonomatch
-    command cat <(cat ~/.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 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
@@ -180,6 +250,16 @@ _fzf_complete_unalias() {
   )
 }
 
+_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 matches lbuf d_cmds
   setopt localoptions noshwordsplit noksh_arrays noposixbuiltins
@@ -204,20 +284,21 @@ fzf-completion() {
     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
-    matches=$(command ps -ef | sed 1d | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-50%} --min-height 15 --reverse $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS --preview 'echo {}' --preview-window down:3:wrap" __fzf_comprun "$cmd" -m | awk '{print $2}' | tr '\n' ' ')
+    tail=$trigger
-    if [ -n "$matches" ]; then
+    tokens+=$trigger
-      LBUFFER="$LBUFFER$matches"
+    lbuf="$lbuf$trigger"
-    fi
+  fi
-    zle reset-prompt
+
   # 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
       prefix="$prefix" eval _fzf_complete_${cmd} ${(q)lbuf}
@@ -241,4 +322,8 @@ fzf-completion() {
 zle     -N   fzf-completion
 bindkey '^I' fzf-completion
 
-fi
+} always {
+  # Restore the original options.
+  eval $__fzf_completion_options
+  'unset' '__fzf_completion_options'
+}

shell/key-bindings.bash

@@ -1,3 +1,16 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ 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__() {
@@ -5,7 +18,7 @@ __fzf_select__() {
     -o -type f -print \
     -o -type d -print \
     -o -type l -print 2> /dev/null | cut -b3-"}"
-  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" fzf -m "$@" | while read -r item; do
+  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" $(__fzfcmd) -m "$@" | while read -r item; do
     printf '%q ' "$item"
   done
   echo
@@ -13,35 +26,15 @@ __fzf_select__() {
 
 if [[ $- =~ i ]]; then
 
-__fzf_use_tmux__() {
-  [ -n "$TMUX_PANE" ] && [ "${FZF_TMUX:-0}" != 0 ] && [ ${LINES:-40} -gt 15 ]
-}
-
 __fzfcmd() {
-  __fzf_use_tmux__ &&
+  [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; } &&
-    echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+    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]}\"; RESULT=\"\$(__fzf_select__ --no-height)\"; tmux setb -b fzf \"\$RESULT\" \\; pasteb -b fzf -t $TMUX_PANE \\; deleteb -b fzf || tmux send-keys -t $TMUX_PANE \"\$RESULT\"'"
 }
 
 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__() {
@@ -55,8 +48,8 @@ __fzf_history__() {
   local output
   output=$(
     builtin fc -lnr -2147483648 |
-      last_hist=$(HISTTIMEFORMAT='' builtin history 1) perl -p -l0 -e 'BEGIN { getc; $/ = "\n\t"; $HISTCMD = $ENV{last_hist} + 1 } s/^[ *]//; $_ = $HISTCMD - $. . "\t$_"' |
+      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{$_}++' |
-      FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m --read0" $(__fzfcmd) --query "$READLINE_LINE"
+      FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m --read0" $(__fzfcmd) --query "$READLINE_LINE"
   ) || return
   READLINE_LINE=${output#*$'\t'}
   if [ -z "$READLINE_POINT" ]; then
@@ -75,11 +68,7 @@ bind -m emacs-standard '"\C-z": vi-editing-mode'
 
 if [ "${BASH_VERSINFO[0]}" -lt 4 ]; then
   # CTRL-T - Paste the selected file path into the command line
-  if __fzf_use_tmux__; then
+  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 emacs-standard '"\C-t": " \C-b\C-k \C-u`__fzf_select_tmux__`\e\C-e\C-a\C-y\C-h\C-e\e \C-y\ey\C-x\C-x\C-f"'
-  else
-    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"'
-  fi
   bind -m vi-command '"\C-t": "\C-z\C-t\C-z"'
   bind -m vi-insert '"\C-t": "\C-z\C-t\C-z"'
 

shell/key-bindings.fish

@@ -1,3 +1,16 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ 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
@@ -84,8 +97,10 @@ function fzf_key_bindings
   function __fzfcmd
     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" ]
-      echo "fzf-tmux -d$FZF_TMUX_HEIGHT"
+      echo "fzf-tmux $FZF_TMUX_OPTS -- "
+    else if [ $FZF_TMUX -eq 1 ]
+      echo "fzf-tmux -d$FZF_TMUX_HEIGHT -- "
     else
       echo "fzf"
     end
@@ -112,12 +127,12 @@ function fzf_key_bindings
     else
       set dir (__fzf_get_dir $commandline)
 
-      if [ "$dir" = "." -a (string sub -l 1 $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")
+        set fzf_query (string replace -r "^$dir/?" -- '' "$commandline")
       end
     end
 
@@ -129,15 +144,15 @@ function fzf_key_bindings
     set dir $argv
 
     # Strip all trailing slashes. Ignore if $dir is root dir (/)
-    if [ (string length $dir) -gt 1 ]
+    if [ (string length -- $dir) -gt 1 ]
-      set dir (string replace -r '/*$' '' $dir)
+      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")
+      set dir (dirname -- "$dir")
     end
 
     echo $dir

shell/key-bindings.zsh

@@ -1,6 +1,42 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ 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() {
@@ -17,13 +53,9 @@ __fsel() {
   return $ret
 }
 
-__fzf_use_tmux__() {
-  [ -n "$TMUX_PANE" ] && [ "${FZF_TMUX:-0}" != 0 ] && [ ${LINES:-40} -gt 15 ]
-}
-
 __fzfcmd() {
-  __fzf_use_tmux__ &&
+  [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; } &&
-    echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+    echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
 }
 
 fzf-file-widget() {
@@ -55,9 +87,15 @@ fzf-cd-widget() {
     zle redisplay
     return 0
   fi
-  cd "$dir"
+  if [ -z "$BUFFER" ]; then
-  unset dir # ensure this doesn't end up appearing in prompt expansion
+    BUFFER="cd ${(q)dir}"
+    zle accept-line
+  else
+    print -sr "cd ${(q)dir}"
+    cd "$dir"
+  fi
   local ret=$?
+  unset dir # ensure this doesn't end up appearing in prompt expansion
   zle fzf-redraw-prompt
   return $ret
 }
@@ -68,7 +106,7 @@ bindkey '\ec' fzf-cd-widget
 fzf-history-widget() {
   local selected num
   setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2> /dev/null
-  selected=( $(fc -rl 1 |
+  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 $FZF_CTRL_R_OPTS --query=${(qqq)LBUFFER} +m" $(__fzfcmd)) )
   local ret=$?
   if [ -n "$selected" ]; then
@@ -83,4 +121,7 @@ fzf-history-widget() {
 zle     -N   fzf-history-widget
 bindkey '^R' fzf-history-widget
 
-fi
+} always {
+  eval $__fzf_key_bindings_options
+  'unset' '__fzf_key_bindings_options'
+}

src/algo/normalize.go

@@ -405,6 +405,74 @@ var normalized map[rune]rune = map[rune]rune{
 	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

src/constants.go

@@ -9,9 +9,6 @@ import (
 )
 
 const (
-	// Current version
-	version = "0.21.0"
-
 	// Core
 	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
 	coordinatorDelayStep time.Duration = 10 * time.Millisecond
@@ -27,6 +24,8 @@ const (
 	initialDelayTac   = 100 * time.Millisecond
 	spinnerDuration   = 100 * time.Millisecond
 	previewCancelWait = 500 * time.Millisecond
+	previewChunkDelay = 100 * time.Millisecond
+	previewDelayed    = 500 * time.Millisecond
 	maxPatternLength  = 300
 	maxMulti          = math.MaxInt32
 

src/core.go

@@ -43,7 +43,7 @@ Matcher  -> EvtHeader         -> Terminal (update header)
 */
 
 // Run starts fzf
-func Run(opts *Options, revision string) {
+func Run(opts *Options, version string, revision string) {
 	sort := opts.Sort > 0
 	sortCriteria = opts.Criteria
 
@@ -66,7 +66,7 @@ func Run(opts *Options, revision string) {
 
 	var lineAnsiState, prevLineAnsiState *ansiState
 	if opts.Ansi {
-		if opts.Theme != nil {
+		if opts.Theme.Colored {
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				prevLineAnsiState = lineAnsiState
 				trimmed, offsets, newState := extractColor(string(data), lineAnsiState, nil)
@@ -102,7 +102,7 @@ func Run(opts *Options, revision string) {
 	} else {
 		chunkList = NewChunkList(func(item *Item, data []byte) bool {
 			tokens := Tokenize(string(data), opts.Delimiter)
-			if opts.Ansi && opts.Theme != nil && len(tokens) > 1 {
+			if opts.Ansi && opts.Theme.Colored && len(tokens) > 1 {
 				var ansiState *ansiState
 				if prevLineAnsiState != nil {
 					ansiStateDup := *prevLineAnsiState

src/options.go

@@ -58,7 +58,8 @@ const usage = `usage: fzf [options]
                           (default: 10)
     --layout=LAYOUT       Choose layout: [default|reverse|reverse-list]
     --border[=STYLE]      Draw border around the finder
-                          [rounded|sharp|horizontal] (default: rounded)
+                          [rounded|sharp|horizontal|vertical|
+                           top|bottom|left|right] (default: rounded)
     --margin=MARGIN       Screen margin (TRBL / TB,RL / T,RL,B / T,R,B,L)
     --info=STYLE          Finder info style [default|inline|hidden]
     --prompt=STR          Input prompt (default: '> ')
@@ -80,7 +81,11 @@ const usage = `usage: fzf [options]
   Preview
     --preview=COMMAND     Command to preview highlighted line ({})
     --preview-window=OPT  Preview window layout (default: right:50%)
-                          [up|down|left|right][:SIZE[%]][:wrap][:hidden]
+                          [up|down|left|right][:SIZE[%]]
+                          [:[no]wrap][:[no]cycle][:[no]hidden]
+                          [:rounded|sharp|noborder]
+                          [:+SCROLL[-OFFSET]]
+                          [:default]
 
   Scripting
     -q, --query=STR       Start the finder with the given query
@@ -159,9 +164,11 @@ type previewOpts struct {
 	command  string
 	position windowPosition
 	size     sizeSpec
+	scroll   string
 	hidden   bool
 	wrap     bool
-	border   bool
+	cycle    bool
+	border   tui.BorderShape
 }
 
 // Options stores the values of command-line options
@@ -221,6 +228,10 @@ type Options struct {
 	Version     bool
 }
 
+func defaultPreviewOpts(command string) previewOpts {
+	return previewOpts{command, posRight, sizeSpec{50, true}, "", false, false, false, tui.BorderRounded}
+}
+
 func defaultOptions() *Options {
 	return &Options{
 		Fuzzy:       true,
@@ -260,7 +271,7 @@ func defaultOptions() *Options {
 		ToggleSort:  false,
 		Expect:      make(map[int]string),
 		Keymap:      make(map[int][]action),
-		Preview:     previewOpts{"", posRight, sizeSpec{50, true}, false, false, true},
+		Preview:     defaultPreviewOpts(""),
 		PrintQuery:  false,
 		ReadZero:    false,
 		Printer:     func(str string) { fmt.Println(str) },
@@ -411,11 +422,21 @@ func parseBorder(str string, optional bool) tui.BorderShape {
 		return tui.BorderSharp
 	case "horizontal":
 		return tui.BorderHorizontal
+	case "vertical":
+		return tui.BorderVertical
+	case "top":
+		return tui.BorderTop
+	case "bottom":
+		return tui.BorderBottom
+	case "left":
+		return tui.BorderLeft
+	case "right":
+		return tui.BorderRight
 	default:
 		if optional && str == "" {
 			return tui.BorderRounded
 		}
-		errorExit("invalid border style (expected: rounded|sharp|horizontal)")
+		errorExit("invalid border style (expected: rounded|sharp|horizontal|vertical|top|bottom|left|right)")
 	}
 	return tui.BorderNone
 }
@@ -464,6 +485,8 @@ func parseKeyChords(str string, message string) map[int]string {
 			chord = tui.CtrlRightBracket
 		case "change":
 			chord = tui.Change
+		case "backward-eof":
+			chord = tui.BackwardEOF
 		case "alt-enter", "alt-return":
 			chord = tui.CtrlAltM
 		case "alt-space":
@@ -578,11 +601,8 @@ func parseTiebreak(str string) []criterion {
 }
 
 func dupeTheme(theme *tui.ColorTheme) *tui.ColorTheme {
-	if theme != nil {
+	dupe := *theme
-		dupe := *theme
+	return &dupe
-		return &dupe
-	}
-	return nil
 }
 
 func parseTheme(defaultTheme *tui.ColorTheme, str string) *tui.ColorTheme {
@@ -607,54 +627,76 @@ func parseTheme(defaultTheme *tui.ColorTheme, str string) *tui.ColorTheme {
 				continue
 			}
 
-			pair := strings.Split(str, ":")
+			components := strings.Split(str, ":")
-			if len(pair) != 2 {
+			if len(components) < 2 {
 				fail()
 			}
 
-			var ansi tui.Color
+			cattr := tui.NewColorAttr()
-			if rrggbb.MatchString(pair[1]) {
+			for _, component := range components[1:] {
-				ansi = tui.HexToColor(pair[1])
+				switch component {
-			} else {
+				case "regular":
-				ansi32, err := strconv.Atoi(pair[1])
+					cattr.Attr = tui.AttrRegular
-				if err != nil || ansi32 < -1 || ansi32 > 255 {
+				case "bold", "strong":
-					fail()
+					cattr.Attr |= tui.Bold
+				case "dim":
+					cattr.Attr |= tui.Dim
+				case "italic":
+					cattr.Attr |= tui.Italic
+				case "underline":
+					cattr.Attr |= tui.Underline
+				case "blink":
+					cattr.Attr |= tui.Blink
+				case "reverse":
+					cattr.Attr |= tui.Reverse
+				case "":
+				default:
+					if rrggbb.MatchString(component) {
+						cattr.Color = tui.HexToColor(component)
+					} else {
+						ansi32, err := strconv.Atoi(component)
+						if err != nil || ansi32 < -1 || ansi32 > 255 {
+							fail()
+						}
+						cattr.Color = tui.Color(ansi32)
+					}
 				}
-				ansi = tui.Color(ansi32)
 			}
-			switch pair[0] {
+			switch components[0] {
+			case "input":
+				theme.Input = cattr
 			case "fg":
-				theme.Fg = ansi
+				theme.Fg = cattr
 			case "bg":
-				theme.Bg = ansi
+				theme.Bg = cattr
 			case "preview-fg":
-				theme.PreviewFg = ansi
+				theme.PreviewFg = cattr
 			case "preview-bg":
-				theme.PreviewBg = ansi
+				theme.PreviewBg = cattr
 			case "fg+":
-				theme.Current = ansi
+				theme.Current = cattr
 			case "bg+":
-				theme.DarkBg = ansi
+				theme.DarkBg = cattr
 			case "gutter":
-				theme.Gutter = ansi
+				theme.Gutter = cattr
 			case "hl":
-				theme.Match = ansi
+				theme.Match = cattr
 			case "hl+":
-				theme.CurrentMatch = ansi
+				theme.CurrentMatch = cattr
 			case "border":
-				theme.Border = ansi
+				theme.Border = cattr
 			case "prompt":
-				theme.Prompt = ansi
+				theme.Prompt = cattr
 			case "spinner":
-				theme.Spinner = ansi
+				theme.Spinner = cattr
 			case "info":
-				theme.Info = ansi
+				theme.Info = cattr
 			case "pointer":
-				theme.Cursor = ansi
+				theme.Cursor = cattr
 			case "marker":
-				theme.Selected = ansi
+				theme.Selected = cattr
 			case "header":
-				theme.Header = ansi
+				theme.Header = cattr
 			default:
 				fail()
 			}
@@ -682,7 +724,7 @@ func init() {
 	// Backreferences are not supported.
 	// "~!@#$%^&*;/|".each_char.map { |c| Regexp.escape(c) }.map { |c| "#{c}[^#{c}]*#{c}" }.join('|')
 	executeRegexp = regexp.MustCompile(
-		`(?si)[:+](execute(?:-multi|-silent)?|reload):.+|[:+](execute(?:-multi|-silent)?|reload)(\([^)]*\)|\[[^\]]*\]|~[^~]*~|![^!]*!|@[^@]*@|\#[^\#]*\#|\$[^\$]*\$|%[^%]*%|\^[^\^]*\^|&[^&]*&|\*[^\*]*\*|;[^;]*;|/[^/]*/|\|[^\|]*\|)`)
+		`(?si)[:+](execute(?:-multi|-silent)?|reload|preview):.+|[:+](execute(?:-multi|-silent)?|reload|preview)(\([^)]*\)|\[[^\]]*\]|~[^~]*~|![^!]*!|@[^@]*@|\#[^\#]*\#|\$[^\$]*\$|%[^%]*%|\^[^\^]*\^|&[^&]*&|\*[^\*]*\*|;[^;]*;|/[^/]*/|\|[^\|]*\|)`)
 }
 
 func parseKeymap(keymap map[int][]action, str string) {
@@ -694,6 +736,8 @@ func parseKeymap(keymap map[int][]action, str string) {
 		prefix := symbol + "execute"
 		if strings.HasPrefix(src[1:], "reload") {
 			prefix = symbol + "reload"
+		} else if strings.HasPrefix(src[1:], "preview") {
+			prefix = symbol + "preview"
 		} else if src[len(prefix)] == '-' {
 			c := src[len(prefix)+1]
 			if c == 's' || c == 'S' {
@@ -754,6 +798,8 @@ func parseKeymap(keymap map[int][]action, str string) {
 				appendAction(actAcceptNonEmpty)
 			case "print-query":
 				appendAction(actPrintQuery)
+			case "refresh-preview":
+				appendAction(actRefreshPreview)
 			case "replace-query":
 				appendAction(actReplaceQuery)
 			case "backward-char":
@@ -846,6 +892,10 @@ func parseKeymap(keymap map[int][]action, str string) {
 				appendAction(actPreviewPageUp)
 			case "preview-page-down":
 				appendAction(actPreviewPageDown)
+			case "preview-half-page-up":
+				appendAction(actPreviewHalfPageUp)
+			case "preview-half-page-down":
+				appendAction(actPreviewHalfPageDown)
 			default:
 				t := isExecuteAction(specLower)
 				if t == actIgnore {
@@ -859,6 +909,8 @@ func parseKeymap(keymap map[int][]action, str string) {
 					switch t {
 					case actReload:
 						offset = len("reload")
+					case actPreview:
+						offset = len("preview")
 					case actExecuteSilent:
 						offset = len("execute-silent")
 					case actExecuteMulti:
@@ -896,6 +948,8 @@ func isExecuteAction(str string) actionType {
 	switch prefix {
 	case "reload":
 		return actReload
+	case "preview":
+		return actPreview
 	case "execute":
 		return actExecute
 	case "execute-silent":
@@ -976,21 +1030,26 @@ func parseInfoStyle(str string) infoStyle {
 }
 
 func parsePreviewWindow(opts *previewOpts, input string) {
-	// Default
-	opts.position = posRight
-	opts.size = sizeSpec{50, true}
-	opts.hidden = false
-	opts.wrap = false
-
 	tokens := strings.Split(input, ":")
 	sizeRegex := regexp.MustCompile("^[0-9]+%?$")
+	offsetRegex := regexp.MustCompile("^\\+([0-9]+|{-?[0-9]+})(-[0-9]+|-/[1-9][0-9]*)?$")
 	for _, token := range tokens {
 		switch token {
 		case "":
+		case "default":
+			*opts = defaultPreviewOpts(opts.command)
 		case "hidden":
 			opts.hidden = true
+		case "nohidden":
+			opts.hidden = false
 		case "wrap":
 			opts.wrap = true
+		case "nowrap":
+			opts.wrap = false
+		case "cycle":
+			opts.cycle = true
+		case "nocycle":
+			opts.cycle = false
 		case "up", "top":
 			opts.position = posUp
 		case "down", "bottom":
@@ -999,26 +1058,22 @@ func parsePreviewWindow(opts *previewOpts, input string) {
 			opts.position = posLeft
 		case "right":
 			opts.position = posRight
-		case "border":
+		case "rounded", "border":
-			opts.border = true
+			opts.border = tui.BorderRounded
+		case "sharp":
+			opts.border = tui.BorderSharp
 		case "noborder":
-			opts.border = false
+			opts.border = tui.BorderNone
 		default:
 			if sizeRegex.MatchString(token) {
 				opts.size = parseSize(token, 99, "window size")
+			} else if offsetRegex.MatchString(token) {
+				opts.scroll = token[1:]
 			} else {
-				errorExit("invalid preview window layout: " + input)
+				errorExit("invalid preview window option: " + token)
 			}
 		}
 	}
-	if !opts.size.percent && opts.size.size > 0 {
-		// Adjust size for border
-		opts.size.size += 2
-		// And padding
-		if opts.position == posLeft || opts.position == posRight {
-			opts.size.size += 2
-		}
-	}
 }
 
 func parseMargin(margin string) [4]sizeSpec {
@@ -1155,7 +1210,7 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--no-mouse":
 			opts.Mouse = false
 		case "+c", "--no-color":
-			opts.Theme = nil
+			opts.Theme = tui.NoColorTheme()
 		case "+2", "--no-256":
 			opts.Theme = tui.Default16
 		case "--black":
@@ -1260,7 +1315,7 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Preview.command = ""
 		case "--preview-window":
 			parsePreviewWindow(&opts.Preview,
-				nextString(allArgs, &i, "preview window layout required: [up|down|left|right][:SIZE[%]][:noborder][:wrap][:hidden]"))
+				nextString(allArgs, &i, "preview window layout required: [up|down|left|right][:SIZE[%]][:rounded|sharp|noborder][:wrap][:cycle][:hidden][:+SCROLL[-OFFSET]][:default]"))
 		case "--height":
 			opts.Height = parseHeight(nextString(allArgs, &i, "height required: HEIGHT[%]"))
 		case "--min-height":
@@ -1453,6 +1508,25 @@ func postProcessOptions(opts *Options) {
 			}
 		}
 	}
+
+	if opts.Bold {
+		theme := opts.Theme
+		boldify := func(c tui.ColorAttr) tui.ColorAttr {
+			dup := c
+			if !theme.Colored {
+				dup.Attr |= tui.Bold
+			} else if (c.Attr & tui.AttrRegular) == 0 {
+				dup.Attr |= tui.Bold
+			}
+			return dup
+		}
+		theme.Current = boldify(theme.Current)
+		theme.CurrentMatch = boldify(theme.CurrentMatch)
+		theme.Prompt = boldify(theme.Prompt)
+		theme.Input = boldify(theme.Input)
+		theme.Cursor = boldify(theme.Cursor)
+		theme.Spinner = boldify(theme.Spinner)
+	}
 }
 
 // ParseOptions parses command-line options

src/options_test.go

@@ -295,7 +295,7 @@ 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 *tui.Dark256 == *customized {
@@ -313,18 +313,6 @@ func TestColorSpec(t *testing.T) {
 	}
 }
 
-func TestParseNilTheme(t *testing.T) {
-	var theme *tui.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) {
 		opts := defaultOptions()
@@ -387,23 +375,26 @@ func TestPreviewOpts(t *testing.T) {
 		opts.Preview.size.size == 50) {
 		t.Error()
 	}
-	opts = optsFor("--preview", "cat {}", "--preview-window=left:15:hidden:wrap")
+	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+2+2) {
+		opts.Preview.size.size == 15) {
 		t.Error(opts.Preview)
 	}
-	opts = optsFor("--preview-window=up:15:wrap:hidden", "--preview-window=down")
+	opts = optsFor("--preview-window=up:15:wrap:hidden:+{1}-/2", "--preview-window=down", "--preview-window=cycle")
 	if !(opts.Preview.command == "" &&
-		opts.Preview.hidden == false &&
+		opts.Preview.hidden == true &&
-		opts.Preview.wrap == false &&
+		opts.Preview.wrap == true &&
+		opts.Preview.cycle == true &&
 		opts.Preview.position == posDown &&
-		opts.Preview.size.percent == true &&
+		opts.Preview.scroll == "{1}-/2" &&
-		opts.Preview.size.size == 50) {
+		opts.Preview.size.percent == false &&
-		t.Error(opts.Preview)
+		opts.Preview.size.size == 15) {
+		t.Error(opts.Preview.size.size)
 	}
 	opts = optsFor("--preview-window=up:15:wrap:hidden")
 	if !(opts.Preview.command == "" &&
@@ -411,7 +402,14 @@ func TestPreviewOpts(t *testing.T) {
 		opts.Preview.wrap == true &&
 		opts.Preview.position == posUp &&
 		opts.Preview.size.percent == false &&
-		opts.Preview.size.size == 15+2) {
+		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)
 	}
 }

src/pattern.go

@@ -33,6 +33,7 @@ type term struct {
 	inv           bool
 	text          []rune
 	caseSensitive bool
+	normalize     bool
 }
 
 // String returns the string representation of a term.
@@ -128,6 +129,8 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 		}
 	} else {
 		lowerString := strings.ToLower(asString)
+		normalize = normalize &&
+			lowerString == string(algo.NormalizeRunes([]rune(lowerString)))
 		caseSensitive = caseMode == CaseRespect ||
 			caseMode == CaseSmart && lowerString != asString
 		if !caseSensitive {
@@ -173,6 +176,8 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 		lowerText := strings.ToLower(text)
 		caseSensitive := caseMode == CaseRespect ||
 			caseMode == CaseSmart && text != lowerText
+		normalizeTerm := normalize &&
+			lowerText == string(algo.NormalizeRunes([]rune(lowerText)))
 		if !caseSensitive {
 			text = lowerText
 		}
@@ -222,14 +227,15 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 				set = termSet{}
 			}
 			textRunes := []rune(text)
-			if normalize {
+			if normalizeTerm {
 				textRunes = algo.NormalizeRunes(textRunes)
 			}
 			set = append(set, term{
 				typ:           typ,
 				inv:           inv,
 				text:          textRunes,
-				caseSensitive: caseSensitive})
+				caseSensitive: caseSensitive,
+				normalize:     normalizeTerm})
 			switchSet = true
 		}
 	}
@@ -360,7 +366,7 @@ func (p *Pattern) extendedMatch(item *Item, withPos bool, slab *util.Slab) ([]Of
 		matched := false
 		for _, term := range termSet {
 			pfun := p.procFun[term.typ]
-			off, score, pos := p.iter(pfun, input, term.caseSensitive, p.normalize, p.forward, term.text, withPos, slab)
+			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

src/reader.go

@@ -156,10 +156,11 @@ func (r *Reader) readFiles() bool {
 	fn := func(path string, mode os.FileInfo) error {
 		path = filepath.Clean(path)
 		if path != "." {
-			if mode.Mode().IsDir() && filepath.Base(path)[0] == '.' {
+			isDir := mode.Mode().IsDir()
+			if isDir && filepath.Base(path)[0] == '.' {
 				return filepath.SkipDir
 			}
-			if r.pusher([]byte(path)) {
+			if !isDir && r.pusher([]byte(path)) {
 				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}

src/result.go

@@ -15,7 +15,6 @@ type Offset [2]int32
 type colorOffset struct {
 	offset [2]int32
 	color  tui.ColorPair
-	attr   tui.Attr
 }
 
 type Result struct {
@@ -87,14 +86,14 @@ func minRank() Result {
 	return Result{item: &minItem, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
 }
 
-func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme, color tui.ColorPair, attr tui.Attr, current bool) []colorOffset {
+func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme, colBase tui.ColorPair, colMatch tui.ColorPair, current bool) []colorOffset {
 	itemColors := result.item.Colors()
 
-	// No ANSI code, or --color=no
+	// 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: color, attr: attr})
+			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: colMatch})
 		}
 		return offsets
 	}
@@ -111,17 +110,19 @@ func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme,
 			maxCol = ansi.offset[1]
 		}
 	}
-	cols := make([]int, maxCol)
 
+	cols := make([]int, maxCol)
 	for colorIndex, ansi := range itemColors {
 		for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
-			cols[i] = colorIndex + 1 // XXX
+			cols[i] = colorIndex + 1 // 1-based index of itemColors
 		}
 	}
 
 	for _, off := range matchOffsets {
 		for i := off[0]; i < off[1]; i++ {
-			cols[i] = -1
+			// Negative of 1-based index of itemColors
+			// - The extra -1 means highlighted
+			cols[i] = cols[i]*-1 - 1
 		}
 	}
 
@@ -133,36 +134,41 @@ func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme,
 	// --++++++++--  --++++++++++---
 	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 == -1 {
+			if curr < 0 {
-				colors = append(colors, colorOffset{
+				color := colMatch
-					offset: [2]int32{int32(start), int32(idx)}, color: color, attr: attr})
+				if curr < -1 && theme.Colored {
-			} else {
+					origColor := ansiToColorPair(itemColors[-curr-2], colMatch)
-				ansi := itemColors[curr-1]
+					color = origColor.MergeNonDefault(color)
-				fg := ansi.color.fg
-				bg := ansi.color.bg
-				if theme != nil {
-					if fg == -1 {
-						if current {
-							fg = theme.Current
-						} else {
-							fg = theme.Fg
-						}
-					}
-					if bg == -1 {
-						if current {
-							bg = theme.DarkBg
-						} else {
-							bg = theme.Bg
-						}
-					}
 				}
+				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:  tui.NewColorPair(fg, bg),
+					color:  ansiToColorPair(ansi, colBase)})
-					attr:   ansi.color.attr.Merge(attr)})
 			}
 		}
 	}

src/result_test.go

@@ -105,32 +105,55 @@ func TestColorOffset(t *testing.T) {
 	//   ++++++++        ++++++++++
 	// --++++++++--    --++++++++++---
 
-	offsets := []Offset{Offset{5, 15}, Offset{25, 35}}
+	offsets := []Offset{{5, 15}, {25, 35}}
 	item := Result{
 		item: &Item{
 			colors: &[]ansiOffset{
-				ansiOffset{[2]int32{0, 20}, ansiState{1, 5, 0}},
+				{[2]int32{0, 20}, ansiState{1, 5, 0}},
-				ansiOffset{[2]int32{22, 27}, ansiState{2, 6, tui.Bold}},
+				{[2]int32{22, 27}, ansiState{2, 6, tui.Bold}},
-				ansiOffset{[2]int32{30, 32}, ansiState{3, 7, 0}},
+				{[2]int32{30, 32}, ansiState{3, 7, 0}},
-				ansiOffset{[2]int32{33, 40}, ansiState{4, 8, tui.Bold}}}}}
+				{[2]int32{33, 40}, ansiState{4, 8, tui.Bold}}}}}
-	// [{[0 5] 9 false} {[5 15] 99 false} {[15 20] 9 false} {[22 25] 10 true} {[25 35] 99 false} {[35 40] 11 true}]
 
-	pair := tui.NewColorPair(99, 199)
+	colBase := tui.NewColorPair(89, 189, tui.AttrUndefined)
-	colors := item.colorOffsets(offsets, tui.Dark256, pair, tui.AttrRegular, true)
+	colMatch := tui.NewColorPair(99, 199, tui.AttrUndefined)
-	assert := func(idx int, b int32, e int32, c tui.ColorPair, bold bool) {
+	colors := item.colorOffsets(offsets, tui.Dark256, colBase, colMatch, true)
-		var attr tui.Attr
+	assert := func(idx int, b int32, e int32, c tui.ColorPair) {
-		if bold {
-			attr = tui.Bold
-		}
 		o := colors[idx]
-		if o.offset[0] != b || o.offset[1] != e || o.color != c || o.attr != attr {
+		if o.offset[0] != b || o.offset[1] != e || o.color != c {
-			t.Error(o)
+			t.Error(o, b, e, c)
 		}
 	}
-	assert(0, 0, 5, tui.NewColorPair(1, 5), false)
+	// [{[0 5] {1 5 0}} {[5 15] {99 199 0}} {[15 20] {1 5 0}}
-	assert(1, 5, 15, pair, false)
+	//  {[22 25] {2 6 1}} {[25 27] {99 199 1}} {[27 30] {99 199 0}}
-	assert(2, 15, 20, tui.NewColorPair(1, 5), false)
+	//  {[30 32] {99 199 0}} {[32 33] {99 199 0}} {[33 35] {99 199 1}}
-	assert(3, 22, 25, tui.NewColorPair(2, 6), true)
+	//  {[35 40] {4 8 1}}]
-	assert(4, 25, 35, pair, false)
+	assert(0, 0, 5, tui.NewColorPair(1, 5, tui.AttrUndefined))
-	assert(5, 35, 40, tui.NewColorPair(4, 8), true)
+	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/tui/dummy.go

@@ -15,27 +15,29 @@ func (a Attr) Merge(b Attr) Attr {
 }
 
 const (
-	AttrRegular Attr = Attr(0)
+	AttrUndefined = Attr(0)
-	Bold             = Attr(1)
+	AttrRegular   = Attr(1 << 7)
-	Dim              = Attr(1 << 1)
+	AttrClear     = Attr(1 << 8)
-	Italic           = Attr(1 << 2)
+
-	Underline        = Attr(1 << 3)
+	Bold      = Attr(1)
-	Blink            = Attr(1 << 4)
+	Dim       = Attr(1 << 1)
-	Blink2           = Attr(1 << 5)
+	Italic    = Attr(1 << 2)
-	Reverse          = Attr(1 << 6)
+	Underline = Attr(1 << 3)
+	Blink     = Attr(1 << 4)
+	Blink2    = Attr(1 << 5)
+	Reverse   = Attr(1 << 6)
 )
 
-func (r *FullscreenRenderer) Init()       {}
+func (r *FullscreenRenderer) Init()             {}
-func (r *FullscreenRenderer) Pause(bool)  {}
+func (r *FullscreenRenderer) Pause(bool)        {}
-func (r *FullscreenRenderer) Resume(bool) {}
+func (r *FullscreenRenderer) Resume(bool, bool) {}
-func (r *FullscreenRenderer) Clear()      {}
+func (r *FullscreenRenderer) Clear()            {}
-func (r *FullscreenRenderer) Refresh()    {}
+func (r *FullscreenRenderer) Refresh()          {}
-func (r *FullscreenRenderer) Close()      {}
+func (r *FullscreenRenderer) Close()            {}
 
-func (r *FullscreenRenderer) DoesAutoWrap() bool { return false }
+func (r *FullscreenRenderer) GetChar() Event { return Event{} }
-func (r *FullscreenRenderer) GetChar() Event     { return Event{} }
+func (r *FullscreenRenderer) MaxX() int      { return 0 }
-func (r *FullscreenRenderer) MaxX() int          { return 0 }
+func (r *FullscreenRenderer) MaxY() int      { return 0 }
-func (r *FullscreenRenderer) MaxY() int          { return 0 }
 
 func (r *FullscreenRenderer) RefreshWindows(windows []Window) {}
 

src/tui/light.go

@@ -3,7 +3,6 @@ package tui
 import (
 	"fmt"
 	"os"
-	"os/exec"
 	"regexp"
 	"strconv"
 	"strings"
@@ -28,6 +27,7 @@ const (
 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)
@@ -125,17 +125,6 @@ func NewLightRenderer(theme *ColorTheme, forceBlack bool, mouse bool, tabstop in
 	return &r
 }
 
-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 repeat(r rune, times int) string {
 	if times > 0 {
 		return strings.Repeat(string(r), times)
@@ -333,6 +322,13 @@ 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 Event{int(CtrlAltA + r.buffer[1] - 1), 0, nil}
@@ -345,81 +341,81 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 	switch r.buffer[1] {
 	case ESC:
 		return Event{ESC, 0, nil}
-	case 32:
+	case ' ':
 		return Event{AltSpace, 0, nil}
-	case 47:
+	case '/':
 		return Event{AltSlash, 0, nil}
-	case 98:
+	case 'b':
 		return Event{AltB, 0, nil}
-	case 100:
+	case 'd':
 		return Event{AltD, 0, nil}
-	case 102:
+	case 'f':
 		return Event{AltF, 0, nil}
 	case 127:
 		return Event{AltBS, 0, nil}
-	case 91, 79:
+	case '[', 'O':
 		if len(r.buffer) < 3 {
 			return Event{Invalid, 0, nil}
 		}
 		*sz = 3
 		switch r.buffer[2] {
-		case 68:
+		case 'D':
 			if alt {
 				return Event{AltLeft, 0, nil}
 			}
 			return Event{Left, 0, nil}
-		case 67:
+		case 'C':
 			if alt {
 				// Ugh..
 				return Event{AltRight, 0, nil}
 			}
 			return Event{Right, 0, nil}
-		case 66:
+		case 'B':
 			if alt {
 				return Event{AltDown, 0, nil}
 			}
 			return Event{Down, 0, nil}
-		case 65:
+		case 'A':
 			if alt {
 				return Event{AltUp, 0, nil}
 			}
 			return Event{Up, 0, nil}
-		case 90:
+		case 'Z':
 			return Event{BTab, 0, nil}
-		case 72:
+		case 'H':
 			return Event{Home, 0, nil}
-		case 70:
+		case 'F':
 			return Event{End, 0, nil}
-		case 77:
+		case 'M':
 			return r.mouseSequence(sz)
-		case 80:
+		case 'P':
 			return Event{F1, 0, nil}
-		case 81:
+		case 'Q':
 			return Event{F2, 0, nil}
-		case 82:
+		case 'R':
 			return Event{F3, 0, nil}
-		case 83:
+		case 'S':
 			return Event{F4, 0, nil}
-		case 49, 50, 51, 52, 53, 54:
+		case '1', '2', '3', '4', '5', '6':
 			if len(r.buffer) < 4 {
 				return Event{Invalid, 0, nil}
 			}
 			*sz = 4
 			switch r.buffer[2] {
-			case 50:
+			case '2':
-				if r.buffer[3] == 126 {
+				if r.buffer[3] == '~' {
 					return Event{Insert, 0, nil}
 				}
-				if len(r.buffer) > 4 && r.buffer[4] == 126 {
+				if len(r.buffer) > 4 && r.buffer[4] == '~' {
 					*sz = 5
 					switch r.buffer[3] {
-					case 48:
+					case '0':
 						return Event{F9, 0, nil}
-					case 49:
+					case '1':
 						return Event{F10, 0, nil}
-					case 51:
+					case '3':
 						return Event{F11, 0, nil}
-					case 52:
+					case '4':
 						return Event{F12, 0, nil}
 					}
 				}
@@ -431,37 +427,37 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 					return r.GetChar()
 				}
 				return Event{Invalid, 0, nil} // INS
-			case 51:
+			case '3':
 				return Event{Del, 0, nil}
-			case 52:
+			case '4':
 				return Event{End, 0, nil}
-			case 53:
+			case '5':
 				return Event{PgUp, 0, nil}
-			case 54:
+			case '6':
 				return Event{PgDn, 0, nil}
-			case 49:
+			case '1':
 				switch r.buffer[3] {
-				case 126:
+				case '~':
 					return Event{Home, 0, nil}
-				case 49, 50, 51, 52, 53, 55, 56, 57:
+				case '1', '2', '3', '4', '5', '7', '8', '9':
-					if len(r.buffer) == 5 && r.buffer[4] == 126 {
+					if len(r.buffer) == 5 && r.buffer[4] == '~' {
 						*sz = 5
 						switch r.buffer[3] {
-						case 49:
+						case '1':
 							return Event{F1, 0, nil}
-						case 50:
+						case '2':
 							return Event{F2, 0, nil}
-						case 51:
+						case '3':
 							return Event{F3, 0, nil}
-						case 52:
+						case '4':
 							return Event{F4, 0, nil}
-						case 53:
+						case '5':
 							return Event{F5, 0, nil}
-						case 55:
+						case '7':
 							return Event{F6, 0, nil}
-						case 56:
+						case '8':
 							return Event{F7, 0, nil}
-						case 57:
+						case '9':
 							return Event{F8, 0, nil}
 						}
 					}
@@ -561,7 +557,7 @@ func (r *LightRenderer) Pause(clear bool) {
 	}
 }
 
-func (r *LightRenderer) Resume(clear bool) {
+func (r *LightRenderer) Resume(clear bool, sigcont bool) {
 	r.setupTerminal()
 	if clear {
 		if r.fullscreen {
@@ -570,10 +566,10 @@ func (r *LightRenderer) Resume(clear bool) {
 			r.rmcup()
 		}
 		r.flush()
-	} else if !r.fullscreen && r.mouse {
+	} else if sigcont && !r.fullscreen && r.mouse {
-		// NOTE: Resume(false) is only called on SIGCONT after SIGSTOP.
+		// NOTE: SIGCONT (Coming back from CTRL-Z):
-		// And It's highly likely that the offset we obtained at the beginning will
+		// It's highly likely that the offset we obtained at the beginning is
-		// no longer be correct, so we simply disable mouse input.
+		// no longer correct, so we simply disable mouse input.
 		r.csi("?1000l")
 		r.mouse = false
 	}
@@ -628,14 +624,10 @@ func (r *LightRenderer) MaxY() int {
 	return r.height
 }
 
-func (r *LightRenderer) DoesAutoWrap() bool {
-	return false
-}
-
 func (r *LightRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
 	w := &LightWindow{
 		renderer: r,
-		colored:  r.theme != nil,
+		colored:  r.theme.Colored,
 		preview:  preview,
 		border:   borderStyle,
 		top:      top,
@@ -645,14 +637,12 @@ func (r *LightRenderer) NewWindow(top int, left int, width int, height int, prev
 		tabstop:  r.tabstop,
 		fg:       colDefault,
 		bg:       colDefault}
-	if r.theme != nil {
+	if preview {
-		if preview {
+		w.fg = r.theme.PreviewFg.Color
-			w.fg = r.theme.PreviewFg
+		w.bg = r.theme.PreviewBg.Color
-			w.bg = r.theme.PreviewBg
+	} else {
-		} else {
+		w.fg = r.theme.Fg.Color
-			w.fg = r.theme.Fg
+		w.bg = r.theme.Bg.Color
-			w.bg = r.theme.Bg
-		}
 	}
 	w.drawBorder()
 	return w
@@ -663,15 +653,46 @@ func (w *LightWindow) drawBorder() {
 	case BorderRounded, BorderSharp:
 		w.drawBorderAround()
 	case BorderHorizontal:
-		w.drawBorderHorizontal()
+		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() {
+func (w *LightWindow) drawBorderHorizontal(top, bottom bool) {
-	w.Move(0, 0)
+	if top {
-	w.CPrint(ColBorder, AttrRegular, repeat(w.border.horizontal, w.width))
+		w.Move(0, 0)
-	w.Move(w.height-1, 0)
+		w.CPrint(ColBorder, repeat(w.border.horizontal, w.width))
-	w.CPrint(ColBorder, AttrRegular, repeat(w.border.horizontal, w.width))
+	}
+	if bottom {
+		w.Move(w.height-1, 0)
+		w.CPrint(ColBorder, repeat(w.border.horizontal, w.width))
+	}
+}
+
+func (w *LightWindow) drawBorderVertical(left, right bool) {
+	width := w.width - 2
+	if !left || !right {
+		width++
+	}
+	for y := 0; y < w.height; y++ {
+		w.Move(y, 0)
+		if left {
+			w.CPrint(ColBorder, string(w.border.vertical))
+		}
+		w.CPrint(ColBorder, repeat(' ', width))
+		if right {
+			w.CPrint(ColBorder, string(w.border.vertical))
+		}
+	}
 }
 
 func (w *LightWindow) drawBorderAround() {
@@ -680,17 +701,15 @@ func (w *LightWindow) drawBorderAround() {
 	if w.preview {
 		color = ColPreviewBorder
 	}
-	w.CPrint(color, AttrRegular,
+	w.CPrint(color, string(w.border.topLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.topRight))
-		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, AttrRegular, string(w.border.vertical))
+		w.CPrint(color, string(w.border.vertical))
-		w.CPrint(color, AttrRegular, repeat(' ', w.width-2))
+		w.CPrint(color, repeat(' ', w.width-2))
-		w.CPrint(color, AttrRegular, string(w.border.vertical))
+		w.CPrint(color, string(w.border.vertical))
 	}
 	w.Move(w.height-1, 0)
-	w.CPrint(color, AttrRegular,
+	w.CPrint(color, string(w.border.bottomLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.bottomRight))
-		string(w.border.bottomLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.bottomRight))
 }
 
 func (w *LightWindow) csi(code string) {
@@ -753,6 +772,9 @@ func (w *LightWindow) MoveAndClear(y int, x int) {
 
 func attrCodes(attr Attr) []string {
 	codes := []string{}
+	if (attr & AttrClear) > 0 {
+		return codes
+	}
 	if (attr & Bold) > 0 {
 		codes = append(codes, "1")
 	}
@@ -812,12 +834,8 @@ func cleanse(str string) string {
 	return strings.Replace(str, "\x1b", "", -1)
 }
 
-func (w *LightWindow) CPrint(pair ColorPair, attr Attr, text string) {
+func (w *LightWindow) CPrint(pair ColorPair, text string) {
-	if !w.colored {
+	w.csiColor(pair.Fg(), pair.Bg(), pair.Attr())
-		w.csiColor(colDefault, colDefault, attrFor(pair, attr))
-	} else {
-		w.csiColor(pair.Fg(), pair.Bg(), attr)
-	}
 	w.stderrInternal(cleanse(text), false)
 	w.csi("m")
 }
@@ -839,7 +857,7 @@ func wrapLine(input string, prefixLength int, max int, tabstop int) []wrappedLin
 	width := 0
 	line := ""
 	for _, r := range input {
-		w := util.Max(util.RuneWidth(r, prefixLength+width, 8), 1)
+		w := util.RuneWidth(r, prefixLength+width, 8)
 		width += w
 		str := string(r)
 		if r == '\t' {

src/tui/light_unix.go

@@ -5,6 +5,8 @@ package tui
 import (
 	"fmt"
 	"os"
+	"os/exec"
+	"strings"
 	"syscall"
 
 	"github.com/junegunn/fzf/src/util"
@@ -15,6 +17,17 @@ 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())
 }

src/tui/light_windows.go

@@ -34,6 +34,14 @@ func IsLightRendererSupported() bool {
 	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)

src/tui/tcell.go

@@ -77,11 +77,13 @@ const (
 	Blink          = Attr(tcell.AttrBlink)
 	Reverse        = Attr(tcell.AttrReverse)
 	Underline      = Attr(tcell.AttrUnderline)
-	Italic         = Attr(tcell.AttrNone) // Not supported
+	Italic         = Attr(tcell.AttrItalic)
 )
 
 const (
-	AttrRegular Attr = 0
+	AttrUndefined = Attr(0)
+	AttrRegular   = Attr(1 << 7)
+	AttrClear     = Attr(1 << 8)
 )
 
 func (r *FullscreenRenderer) defaultTheme() *ColorTheme {
@@ -166,10 +168,6 @@ func (w *TcellWindow) Y() int {
 	return w.lastY
 }
 
-func (r *FullscreenRenderer) DoesAutoWrap() bool {
-	return false
-}
-
 func (r *FullscreenRenderer) Clear() {
 	_screen.Sync()
 	_screen.Clear()
@@ -394,7 +392,7 @@ func (r *FullscreenRenderer) Pause(clear bool) {
 	}
 }
 
-func (r *FullscreenRenderer) Resume(clear bool) {
+func (r *FullscreenRenderer) Resume(clear bool, sigcont bool) {
 	if clear {
 		r.initScreen()
 	}
@@ -418,7 +416,7 @@ func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int,
 		normal = ColPreview
 	}
 	return &TcellWindow{
-		color:       r.theme != nil,
+		color:       r.theme.Colored,
 		preview:     preview,
 		top:         top,
 		left:        left,
@@ -464,27 +462,23 @@ func (w *TcellWindow) MoveAndClear(y int, x int) {
 }
 
 func (w *TcellWindow) Print(text string) {
-	w.printString(text, w.normal, 0)
+	w.printString(text, w.normal)
 }
 
-func (w *TcellWindow) printString(text string, pair ColorPair, a Attr) {
+func (w *TcellWindow) printString(text string, pair ColorPair) {
 	t := text
 	lx := 0
+	a := pair.Attr()
 
-	var style tcell.Style
+	style := pair.style()
-	if w.color {
+	if a&AttrClear == 0 {
-		style = pair.style().
+		style = style.
 			Reverse(a&Attr(tcell.AttrReverse) != 0).
-			Underline(a&Attr(tcell.AttrUnderline) != 0)
+			Underline(a&Attr(tcell.AttrUnderline) != 0).
-	} else {
+			Italic(a&Attr(tcell.AttrItalic) != 0).
-		style = w.normal.style().
+			Blink(a&Attr(tcell.AttrBlink) != 0).
-			Reverse(a&Attr(tcell.AttrReverse) != 0 || pair == ColCurrent || pair == ColCurrentMatch).
+			Dim(a&Attr(tcell.AttrDim) != 0)
-			Underline(a&Attr(tcell.AttrUnderline) != 0 || pair == ColMatch || pair == ColCurrentMatch)
 	}
-	style = style.
-		Blink(a&Attr(tcell.AttrBlink) != 0).
-		Bold(a&Attr(tcell.AttrBold) != 0).
-		Dim(a&Attr(tcell.AttrDim) != 0)
 
 	for {
 		if len(t) == 0 {
@@ -517,12 +511,13 @@ func (w *TcellWindow) printString(text string, pair ColorPair, a Attr) {
 	w.lastX += lx
 }
 
-func (w *TcellWindow) CPrint(pair ColorPair, attr Attr, text string) {
+func (w *TcellWindow) CPrint(pair ColorPair, text string) {
-	w.printString(text, pair, attr)
+	w.printString(text, pair)
 }
 
-func (w *TcellWindow) fillString(text string, pair ColorPair, a Attr) FillReturn {
+func (w *TcellWindow) fillString(text string, pair ColorPair) FillReturn {
 	lx := 0
+	a := pair.Attr()
 
 	var style tcell.Style
 	if w.color {
@@ -535,7 +530,8 @@ func (w *TcellWindow) fillString(text string, pair ColorPair, a Attr) FillReturn
 		Bold(a&Attr(tcell.AttrBold) != 0).
 		Dim(a&Attr(tcell.AttrDim) != 0).
 		Reverse(a&Attr(tcell.AttrReverse) != 0).
-		Underline(a&Attr(tcell.AttrUnderline) != 0)
+		Underline(a&Attr(tcell.AttrUnderline) != 0).
+		Italic(a&Attr(tcell.AttrItalic) != 0)
 
 	for _, r := range text {
 		if r == '\n' {
@@ -563,12 +559,17 @@ func (w *TcellWindow) fillString(text string, pair ColorPair, a Attr) FillReturn
 		}
 	}
 	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, 0)
+	return w.fillString(str, w.normal)
 }
 
 func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
@@ -578,11 +579,12 @@ func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
 	if bg == colDefault {
 		bg = w.normal.Bg()
 	}
-	return w.fillString(str, NewColorPair(fg, bg), a)
+	return w.fillString(str, NewColorPair(fg, bg, a))
 }
 
 func (w *TcellWindow) drawBorder() {
-	if w.borderStyle.shape == BorderNone {
+	shape := w.borderStyle.shape
+	if shape == BorderNone {
 		return
 	}
 
@@ -602,17 +604,32 @@ func (w *TcellWindow) drawBorder() {
 		style = w.normal.style()
 	}
 
-	for x := left; x < right; x++ {
+	switch shape {
-		_screen.SetContent(x, top, w.borderStyle.horizontal, nil, style)
+	case BorderRounded, BorderSharp, BorderHorizontal, BorderTop:
-		_screen.SetContent(x, bot-1, w.borderStyle.horizontal, nil, style)
+		for x := left; x < right; x++ {
+			_screen.SetContent(x, top, w.borderStyle.horizontal, nil, style)
+		}
 	}
-
+	switch shape {
-	if w.borderStyle.shape != BorderHorizontal {
+	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)

src/tui/tui.go

@@ -87,6 +87,7 @@ const (
 	F12
 
 	Change
+	BackwardEOF
 
 	AltSpace
 	AltSlash
@@ -122,6 +123,15 @@ 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
@@ -147,9 +157,9 @@ const (
 )
 
 type ColorPair struct {
-	fg Color
+	fg   Color
-	bg Color
+	bg   Color
-	id int
+	attr Attr
 }
 
 func HexToColor(rrggbb string) Color {
@@ -159,8 +169,8 @@ func HexToColor(rrggbb string) Color {
 	return Color((1 << 24) + (r << 16) + (g << 8) + b)
 }
 
-func NewColorPair(fg Color, bg Color) ColorPair {
+func NewColorPair(fg Color, bg Color, attr Attr) ColorPair {
-	return ColorPair{fg, bg, -1}
+	return ColorPair{fg, bg, attr}
 }
 
 func (p ColorPair) Fg() Color {
@@ -171,23 +181,59 @@ func (p ColorPair) Bg() Color {
 	return p.bg
 }
 
+func (p ColorPair) Attr() Attr {
+	return p.attr
+}
+
+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 {
-	Fg           Color
+	Colored      bool
-	Bg           Color
+	Input        ColorAttr
-	PreviewFg    Color
+	Fg           ColorAttr
-	PreviewBg    Color
+	Bg           ColorAttr
-	DarkBg       Color
+	PreviewFg    ColorAttr
-	Gutter       Color
+	PreviewBg    ColorAttr
-	Prompt       Color
+	DarkBg       ColorAttr
-	Match        Color
+	Gutter       ColorAttr
-	Current      Color
+	Prompt       ColorAttr
-	CurrentMatch Color
+	Match        ColorAttr
-	Spinner      Color
+	Current      ColorAttr
-	Info         Color
+	CurrentMatch ColorAttr
-	Cursor       Color
+	Spinner      ColorAttr
-	Selected     Color
+	Info         ColorAttr
-	Header       Color
+	Cursor       ColorAttr
-	Border       Color
+	Selected     ColorAttr
+	Header       ColorAttr
+	Border       ColorAttr
 }
 
 type Event struct {
@@ -213,6 +259,11 @@ const (
 	BorderRounded
 	BorderSharp
 	BorderHorizontal
+	BorderVertical
+	BorderTop
+	BorderBottom
+	BorderLeft
+	BorderRight
 )
 
 type BorderStyle struct {
@@ -275,7 +326,7 @@ func MakeTransparentBorder() BorderStyle {
 type Renderer interface {
 	Init()
 	Pause(clear bool)
-	Resume(clear bool)
+	Resume(clear bool, sigcont bool)
 	Clear()
 	RefreshWindows(windows []Window)
 	Refresh()
@@ -285,7 +336,6 @@ type Renderer interface {
 
 	MaxX() int
 	MaxY() int
-	DoesAutoWrap() bool
 
 	NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window
 }
@@ -307,7 +357,7 @@ type Window interface {
 	Move(y int, x int)
 	MoveAndClear(y int, x int)
 	Print(text string)
-	CPrint(color ColorPair, attr Attr, text string)
+	CPrint(color ColorPair, text string)
 	Fill(text string) FillReturn
 	CFill(fg Color, bg Color, attr Attr, text string) FillReturn
 	Erase()
@@ -336,41 +386,69 @@ var (
 	Dark256   *ColorTheme
 	Light256  *ColorTheme
 
-	ColPrompt          ColorPair
+	ColPrompt               ColorPair
-	ColNormal          ColorPair
+	ColNormal               ColorPair
-	ColMatch           ColorPair
+	ColInput                ColorPair
-	ColCursor          ColorPair
+	ColMatch                ColorPair
-	ColSelected        ColorPair
+	ColCursor               ColorPair
-	ColCurrent         ColorPair
+	ColCursorEmpty          ColorPair
-	ColCurrentMatch    ColorPair
+	ColSelected             ColorPair
-	ColCurrentCursor   ColorPair
+	ColCurrent              ColorPair
-	ColCurrentSelected ColorPair
+	ColCurrentMatch         ColorPair
-	ColSpinner         ColorPair
+	ColCurrentCursor        ColorPair
-	ColInfo            ColorPair
+	ColCurrentCursorEmpty   ColorPair
-	ColHeader          ColorPair
+	ColCurrentSelected      ColorPair
-	ColBorder          ColorPair
+	ColCurrentSelectedEmpty ColorPair
-	ColPreview         ColorPair
+	ColSpinner              ColorPair
-	ColPreviewBorder   ColorPair
+	ColInfo                 ColorPair
+	ColHeader               ColorPair
+	ColBorder               ColorPair
+	ColPreview              ColorPair
+	ColPreviewBorder        ColorPair
 )
 
 func EmptyTheme() *ColorTheme {
 	return &ColorTheme{
-		Fg:           colUndefined,
+		Colored:      true,
-		Bg:           colUndefined,
+		Input:        ColorAttr{colUndefined, AttrUndefined},
-		PreviewFg:    colUndefined,
+		Fg:           ColorAttr{colUndefined, AttrUndefined},
-		PreviewBg:    colUndefined,
+		Bg:           ColorAttr{colUndefined, AttrUndefined},
-		DarkBg:       colUndefined,
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
-		Gutter:       colUndefined,
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
-		Prompt:       colUndefined,
+		DarkBg:       ColorAttr{colUndefined, AttrUndefined},
-		Match:        colUndefined,
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
-		Current:      colUndefined,
+		Prompt:       ColorAttr{colUndefined, AttrUndefined},
-		CurrentMatch: colUndefined,
+		Match:        ColorAttr{colUndefined, AttrUndefined},
-		Spinner:      colUndefined,
+		Current:      ColorAttr{colUndefined, AttrUndefined},
-		Info:         colUndefined,
+		CurrentMatch: ColorAttr{colUndefined, AttrUndefined},
-		Cursor:       colUndefined,
+		Spinner:      ColorAttr{colUndefined, AttrUndefined},
-		Selected:     colUndefined,
+		Info:         ColorAttr{colUndefined, AttrUndefined},
-		Header:       colUndefined,
+		Cursor:       ColorAttr{colUndefined, AttrUndefined},
-		Border:       colUndefined}
+		Selected:     ColorAttr{colUndefined, AttrUndefined},
+		Header:       ColorAttr{colUndefined, AttrUndefined},
+		Border:       ColorAttr{colUndefined, AttrUndefined}}
+}
+
+func NoColorTheme() *ColorTheme {
+	return &ColorTheme{
+		Colored:      false,
+		Input:        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) {
@@ -380,74 +458,80 @@ func errorExit(message string) {
 
 func init() {
 	Default16 = &ColorTheme{
-		Fg:           colDefault,
+		Colored:      true,
-		Bg:           colDefault,
+		Input:        ColorAttr{colDefault, AttrUndefined},
-		PreviewFg:    colUndefined,
+		Fg:           ColorAttr{colDefault, AttrUndefined},
-		PreviewBg:    colUndefined,
+		Bg:           ColorAttr{colDefault, AttrUndefined},
-		DarkBg:       colBlack,
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
-		Gutter:       colUndefined,
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
-		Prompt:       colBlue,
+		DarkBg:       ColorAttr{colBlack, AttrUndefined},
-		Match:        colGreen,
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
-		Current:      colYellow,
+		Prompt:       ColorAttr{colBlue, AttrUndefined},
-		CurrentMatch: colGreen,
+		Match:        ColorAttr{colGreen, AttrUndefined},
-		Spinner:      colGreen,
+		Current:      ColorAttr{colYellow, AttrUndefined},
-		Info:         colWhite,
+		CurrentMatch: ColorAttr{colGreen, AttrUndefined},
-		Cursor:       colRed,
+		Spinner:      ColorAttr{colGreen, AttrUndefined},
-		Selected:     colMagenta,
+		Info:         ColorAttr{colWhite, AttrUndefined},
-		Header:       colCyan,
+		Cursor:       ColorAttr{colRed, AttrUndefined},
-		Border:       colBlack}
+		Selected:     ColorAttr{colMagenta, AttrUndefined},
+		Header:       ColorAttr{colCyan, AttrUndefined},
+		Border:       ColorAttr{colBlack, AttrUndefined}}
 	Dark256 = &ColorTheme{
-		Fg:           colDefault,
+		Colored:      true,
-		Bg:           colDefault,
+		Input:        ColorAttr{colDefault, AttrUndefined},
-		PreviewFg:    colUndefined,
+		Fg:           ColorAttr{colDefault, AttrUndefined},
-		PreviewBg:    colUndefined,
+		Bg:           ColorAttr{colDefault, AttrUndefined},
-		DarkBg:       236,
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
-		Gutter:       colUndefined,
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
-		Prompt:       110,
+		DarkBg:       ColorAttr{236, AttrUndefined},
-		Match:        108,
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
-		Current:      254,
+		Prompt:       ColorAttr{110, AttrUndefined},
-		CurrentMatch: 151,
+		Match:        ColorAttr{108, AttrUndefined},
-		Spinner:      148,
+		Current:      ColorAttr{254, AttrUndefined},
-		Info:         144,
+		CurrentMatch: ColorAttr{151, AttrUndefined},
-		Cursor:       161,
+		Spinner:      ColorAttr{148, AttrUndefined},
-		Selected:     168,
+		Info:         ColorAttr{144, AttrUndefined},
-		Header:       109,
+		Cursor:       ColorAttr{161, AttrUndefined},
-		Border:       59}
+		Selected:     ColorAttr{168, AttrUndefined},
+		Header:       ColorAttr{109, AttrUndefined},
+		Border:       ColorAttr{59, AttrUndefined}}
 	Light256 = &ColorTheme{
-		Fg:           colDefault,
+		Colored:      true,
-		Bg:           colDefault,
+		Input:        ColorAttr{colDefault, AttrUndefined},
-		PreviewFg:    colUndefined,
+		Fg:           ColorAttr{colDefault, AttrUndefined},
-		PreviewBg:    colUndefined,
+		Bg:           ColorAttr{colDefault, AttrUndefined},
-		DarkBg:       251,
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
-		Gutter:       colUndefined,
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
-		Prompt:       25,
+		DarkBg:       ColorAttr{251, AttrUndefined},
-		Match:        66,
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
-		Current:      237,
+		Prompt:       ColorAttr{25, AttrUndefined},
-		CurrentMatch: 23,
+		Match:        ColorAttr{66, AttrUndefined},
-		Spinner:      65,
+		Current:      ColorAttr{237, AttrUndefined},
-		Info:         101,
+		CurrentMatch: ColorAttr{23, AttrUndefined},
-		Cursor:       161,
+		Spinner:      ColorAttr{65, AttrUndefined},
-		Selected:     168,
+		Info:         ColorAttr{101, AttrUndefined},
-		Header:       31,
+		Cursor:       ColorAttr{161, AttrUndefined},
-		Border:       145}
+		Selected:     ColorAttr{168, AttrUndefined},
+		Header:       ColorAttr{31, AttrUndefined},
+		Border:       ColorAttr{145, AttrUndefined}}
 }
 
 func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
-	if theme == nil {
-		initPalette(theme)
-		return
-	}
-
 	if forceBlack {
-		theme.Bg = colBlack
+		theme.Bg = ColorAttr{colBlack, AttrUndefined}
 	}
 
-	o := func(a Color, b Color) Color {
+	o := func(a ColorAttr, b ColorAttr) ColorAttr {
-		if b == colUndefined {
+		c := a
-			return a
+		if b.Color != colUndefined {
+			c.Color = b.Color
 		}
-		return b
+		if b.Attr != AttrUndefined {
+			c.Attr = b.Attr
+		}
+		return c
 	}
+	theme.Input = o(baseTheme.Input, theme.Input)
 	theme.Fg = o(baseTheme.Fg, theme.Fg)
 	theme.Bg = o(baseTheme.Bg, theme.Bg)
 	theme.PreviewFg = o(theme.Fg, o(baseTheme.PreviewFg, theme.PreviewFg))
@@ -469,54 +553,29 @@ func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
 }
 
 func initPalette(theme *ColorTheme) {
-	idx := 0
+	pair := func(fg, bg ColorAttr) ColorPair {
-	pair := func(fg, bg Color) ColorPair {
+		return ColorPair{fg.Color, bg.Color, fg.Attr}
-		idx++
-		return ColorPair{fg, bg, idx}
 	}
-	if theme != nil {
+	blank := theme.Fg
-		ColPrompt = pair(theme.Prompt, theme.Bg)
+	blank.Attr = AttrRegular
-		ColNormal = pair(theme.Fg, theme.Bg)
-		ColMatch = pair(theme.Match, theme.Bg)
-		ColCursor = pair(theme.Cursor, 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)
-		ColCurrentSelected = pair(theme.Selected, 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)
-	} else {
-		ColPrompt = pair(colDefault, colDefault)
-		ColNormal = pair(colDefault, colDefault)
-		ColMatch = pair(colDefault, colDefault)
-		ColCursor = pair(colDefault, colDefault)
-		ColSelected = pair(colDefault, colDefault)
-		ColCurrent = pair(colDefault, colDefault)
-		ColCurrentMatch = pair(colDefault, colDefault)
-		ColCurrentCursor = pair(colDefault, colDefault)
-		ColCurrentSelected = pair(colDefault, colDefault)
-		ColSpinner = pair(colDefault, colDefault)
-		ColInfo = pair(colDefault, colDefault)
-		ColHeader = pair(colDefault, colDefault)
-		ColBorder = pair(colDefault, colDefault)
-		ColPreview = pair(colDefault, colDefault)
-		ColPreviewBorder = pair(colDefault, colDefault)
-	}
-}
 
-func attrFor(color ColorPair, attr Attr) Attr {
+	ColPrompt = pair(theme.Prompt, theme.Bg)
-	switch color {
+	ColNormal = pair(theme.Fg, theme.Bg)
-	case ColCurrent:
+	ColInput = pair(theme.Input, theme.Bg)
-		return attr | Reverse
+	ColMatch = pair(theme.Match, theme.Bg)
-	case ColMatch:
+	ColCursor = pair(theme.Cursor, theme.Gutter)
-		return attr | Underline
+	ColCursorEmpty = pair(blank, theme.Gutter)
-	case ColCurrentMatch:
+	ColSelected = pair(theme.Selected, theme.Gutter)
-		return attr | Underline | Reverse
+	ColCurrent = pair(theme.Current, theme.DarkBg)
-	}
+	ColCurrentMatch = pair(theme.CurrentMatch, theme.DarkBg)
-	return attr
+	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/update_assets.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-
-# http://www.rubydoc.info/github/rest-client/rest-client/RestClient
-require 'rest_client'
-require 'json'
-
-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 }.map do |file|
-  Thread.new do
-    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
-end.each(&:join)

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
 }