Deploying to master from @ junegunn/fzf@d8bfb6712d 🚀

When the search for the initial query doesn't finish immediately
fzf would trigger an invalid 'result' event for an empty query.

  seq 100 | fzf --query 99 --bind result:accept --sync
    # Prints 99

  seq 1000000 | fzf --query 99 --bind result:accept --sync
    # Should print 99, but fzf would print 1

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE.md

@@ -1,22 +0,0 @@
-<!-- ISSUES NOT FOLLOWING THIS TEMPLATE WILL BE CLOSED AND DELETED -->
-
-<!-- Check all that apply [x] -->
-
-- [ ] I have read through the manual page (`man fzf`)
-- [ ] I have the latest version of fzf
-- [ ] I have searched through the existing issues
-
-## Info
-
-- OS
-    - [ ] Linux
-    - [ ] Mac OS X
-    - [ ] Windows
-    - [ ] Etc.
-- Shell
-    - [ ] bash
-    - [ ] zsh
-    - [ ] fish
-    
-## Problem / Steps to reproduce
-

.github/ISSUE_TEMPLATE/issue_template.yml

@@ -0,0 +1,49 @@
+---
+name: Issue Template
+description: Report a problem or bug related to fzf to help us improve
+
+body:
+  - type: markdown
+    attributes:
+      value: ISSUES NOT FOLLOWING THIS TEMPLATE WILL BE CLOSED AND DELETED
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      options:
+        - label: I have read through the manual page (`man fzf`)
+          required: true
+        - label: I have searched through the existing issues
+          required: true
+        - label: For bug reports, I have checked if the bug is reproducible in the latest version of fzf
+          required: false
+
+  - type: input
+    attributes:
+      label: Output of `fzf --version`
+      placeholder: e.g. 0.48.1 (d579e33)
+    validations:
+      required: true
+
+  - type: checkboxes
+    attributes:
+      label: OS
+      options:
+        - label: Linux
+        - label: macOS
+        - label: Windows
+        - label: Etc.
+
+  - type: checkboxes
+    attributes:
+      label: Shell
+      options:
+        - label: bash
+        - label: zsh
+        - label: fish
+
+  - type: textarea
+    attributes:
+      label: Problem / Steps to reproduce
+    validations:
+      required: true

.github/dependabot.yml

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

.github/workflows/codeql-analysis.yml

@@ -6,9 +6,17 @@ on:
     branches: [ master, devel ]
   pull_request:
     branches: [ master ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
 
 jobs:
   analyze:
+    permissions:
+      actions: read  # for github/codeql-action/init to get workflow details
+      contents: read  # for actions/checkout to fetch code
+      security-events: write  # for github/codeql-action/autobuild to send a status report
     name: Analyze
     runs-on: ubuntu-latest
 
@@ -19,18 +27,18 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
         fetch-depth: 0
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
 
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v3
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v3

.github/workflows/depsreview.yaml

@@ -0,0 +1,14 @@
+name: 'Dependency Review'
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  dependency-review:
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Checkout Repository'
+        uses: actions/checkout@v4
+      - name: 'Dependency Review'
+        uses: actions/dependency-review-action@v4

.github/workflows/linux.yml

@@ -6,33 +6,37 @@ on:
     branches: [ master, devel ]
   pull_request:
     branches: [ master ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  LANG: C.UTF-8
 
 jobs:
   build:
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        go: [1.14, 1.16]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 0
 
     - name: Set up Go
-      uses: actions/setup-go@v2
+      uses: actions/setup-go@v5
       with:
-        go-version: ${{ matrix.go }}
+        go-version: "1.20"
 
     - name: Setup Ruby
-      uses: ruby/setup-ruby@v1.62.0
+      uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.0.0
+        ruby-version: 3.1.0
 
     - name: Install packages
       run: sudo apt-get install --yes zsh fish tmux
 
     - name: Install Ruby gems
-      run: sudo gem install --no-document minitest:5.14.2 rubocop:1.0.0 rubocop-minitest:0.10.1 rubocop-performance:1.8.1
+      run: sudo gem install --no-document minitest:5.17.0 rubocop:1.43.0 rubocop-minitest:0.25.1 rubocop-performance:1.15.2
 
     - name: Rubocop
       run: rubocop --require rubocop-minitest --require rubocop-performance
@@ -41,4 +45,7 @@ jobs:
       run: make test
 
     - name: Integration test
-      run: make install && ./install --all && LC_ALL=C tmux new-session -d && ruby test/test_go.rb --verbose
+      run: make install && ./install --all && tmux new-session -d && ruby test/test_go.rb --verbose
+
+    - name: Integration test (tcell)
+      run: TAGS=tcell make clean install && ruby test/test_go.rb --verbose

.github/workflows/macos.yml

@@ -6,25 +6,26 @@ on:
     branches: [ master, devel ]
   pull_request:
     branches: [ master ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
 
 jobs:
   build:
     runs-on: macos-latest
-    strategy:
-      matrix:
-        go: [1.14, 1.16]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 0
 
     - name: Set up Go
-      uses: actions/setup-go@v2
+      uses: actions/setup-go@v5
       with:
-        go-version: ${{ matrix.go }}
+        go-version: "1.20"
 
     - name: Setup Ruby
-      uses: ruby/setup-ruby@v1.62.0
+      uses: ruby/setup-ruby@v1
       with:
         ruby-version: 3.0.0
 

.github/workflows/sponsors.yml

@@ -0,0 +1,24 @@
+---
+name: Generate Sponsors README
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: 0 0 * * 0
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout 🛎️
+        uses: actions/checkout@v4
+
+      - name: Generate Sponsors 💖
+        uses: JamesIves/github-sponsors-readme-action@v1
+        with:
+          token: ${{ secrets.SPONSORS_TOKEN }}
+          file: 'README.md'
+
+      - name: Deploy to GitHub Pages 🚀
+        uses: JamesIves/github-pages-deploy-action@v4
+        with:
+          branch: master
+          folder: '.'

.github/workflows/typos.yml

@@ -0,0 +1,10 @@
+name: "Spell Check"
+on: [pull_request]
+
+jobs:
+  typos:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: crate-ci/typos@v1.19.0

.github/workflows/winget.yml

@@ -0,0 +1,15 @@
+name: Publish to Winget
+on:
+  release:
+    types: [released]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: vedantmgoyal2009/winget-releaser@v2
+        with:
+          identifier: junegunn.fzf
+          version: ${{ github.event.release.tag_name }}
+          installers-regex: '-windows_(armv7|arm64|amd64)\.zip$'
+          token: ${{ secrets.WINGET_TOKEN }}

.goreleaser.yml

@@ -14,6 +14,21 @@ builds:
       - amd64
     ldflags:
       - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
+    hooks:
+      post: |
+        sh -c '
+        cat > /tmp/fzf-gon-amd64.hcl << EOF
+        source = ["./dist/fzf-macos_darwin_amd64_v1/fzf"]
+        bundle_id = "kr.junegunn.fzf"
+        sign {
+          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
+        }
+        zip {
+          output_path = "./dist/fzf-{{ .Version }}-darwin_amd64.zip"
+        }
+        EOF
+        gon /tmp/fzf-gon-amd64.hcl
+        '
 
   - id: fzf-macos-arm
     binary: fzf
@@ -23,6 +38,21 @@ builds:
       - arm64
     ldflags:
       - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
+    hooks:
+      post: |
+        sh -c '
+        cat > /tmp/fzf-gon-arm64.hcl << EOF
+        source = ["./dist/fzf-macos-arm_darwin_arm64/fzf"]
+        bundle_id = "kr.junegunn.fzf"
+        sign {
+          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
+        }
+        zip {
+          output_path = "./dist/fzf-{{ .Version }}-darwin_arm64.zip"
+        }
+        EOF
+        gon /tmp/fzf-gon-arm64.hcl
+        '
 
   - id: fzf
     goos:
@@ -34,6 +64,9 @@ builds:
       - amd64
       - arm
       - arm64
+      - loong64
+      - ppc64le
+      - s390x
     goarm:
       - 5
       - 6
@@ -61,52 +94,9 @@ archives:
     files:
       - non-existent*
 
-signs:
-  - id: fzf-macos-sign
-    ids: [fzf-macos]
-    artifacts: all
-    cmd: sh
-    args:
-      - "-c"
-      - |-
-        cat > /tmp/fzf-gon-amd64.hcl << EOF
-        source = ["./dist/fzf-macos_darwin_amd64/fzf"]
-        bundle_id = "kr.junegunn.fzf"
-        apple_id {
-          username = "junegunn.c@gmail.com"
-          password = "@env:AC_PASSWORD"
-        }
-        sign {
-          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
-        }
-        zip {
-          output_path = "./dist/fzf-{{ .Version }}-darwin_amd64.zip"
-        }
-        EOF
-        gon /tmp/fzf-gon-amd64.hcl
-
-  - id: fzf-macos-arm-sign
-    ids: [fzf-macos-arm]
-    artifacts: all
-    cmd: sh
-    args:
-      - "-c"
-      - |-
-        cat > /tmp/fzf-gon-arm64.hcl << EOF
-        source = ["./dist/fzf-macos-arm_darwin_arm64/fzf"]
-        bundle_id = "kr.junegunn.fzf"
-        apple_id {
-          username = "junegunn.c@gmail.com"
-          password = "@env:AC_PASSWORD"
-        }
-        sign {
-          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
-        }
-        zip {
-          output_path = "./dist/fzf-{{ .Version }}-darwin_arm64.zip"
-        }
-        EOF
-        gon /tmp/fzf-gon-arm64.hcl
+checksum:
+  extra_files:
+    - glob: ./dist/fzf-*darwin*.zip
 
 release:
   github:

.rubocop.yml

@@ -26,3 +26,7 @@ Style/OptionalBooleanParameter:
   Enabled: false
 Style/WordArray:
   MinSize: 1
+Minitest/AssertEqual:
+  Enabled: false
+Naming/VariableNumber:
+  Enabled: false

.tool-versions

@@ -0,0 +1 @@
+golang 1.20.13

ADVANCED.md

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

BUILD.md

@@ -6,7 +6,7 @@ Build instructions
 
 ### Prerequisites
 
-- Go 1.13 or above
+- Go 1.20 or above
 
 ### Using Makefile
 
@@ -24,24 +24,36 @@ make build
 make release
 ```
 
-> :warning: Makefile uses git commands to determine the version and the
-> revision information for `fzf --version`. So if you're building fzf from an
+> [!WARNING]
+> Makefile uses git commands to determine the version and the revision
+> information for `fzf --version`. So if you're building fzf from an
 > environment where its git information is not available, you have to manually
 > set `$FZF_VERSION` and `$FZF_REVISION`.
 >
 > e.g. `FZF_VERSION=0.24.0 FZF_REVISION=tarball make`
 
+> [!TIP]
+> To build fzf with profiling options enabled, set `TAGS=pprof`
+>
+> ```sh
+> TAGS=pprof make clean install
+> fzf --profile-cpu /tmp/cpu.pprof --profile-mem /tmp/mem.pprof \
+>     --profile-block /tmp/block.pprof --profile-mutex /tmp/mutex.pprof
+> ```
+
 Third-party libraries used
 --------------------------
 
-- [mattn/go-runewidth](https://github.com/mattn/go-runewidth)
-    - Licensed under [MIT](http://mattn.mit-license.org)
+- [rivo/uniseg](https://github.com/rivo/uniseg)
+    - Licensed under [MIT](https://raw.githubusercontent.com/rivo/uniseg/master/LICENSE.txt)
 - [mattn/go-shellwords](https://github.com/mattn/go-shellwords)
     - Licensed under [MIT](http://mattn.mit-license.org)
 - [mattn/go-isatty](https://github.com/mattn/go-isatty)
     - Licensed under [MIT](http://mattn.mit-license.org)
 - [tcell](https://github.com/gdamore/tcell)
     - Licensed under [Apache License 2.0](https://github.com/gdamore/tcell/blob/master/LICENSE)
+- [fastwalk](https://github.com/charlievieth/fastwalk)
+    - Licensed under [MIT](https://raw.githubusercontent.com/charlievieth/fastwalk/master/LICENSE)
 
 License
 -------

CHANGELOG.md

@@ -1,6 +1,894 @@
 CHANGELOG
 =========
 
+0.50.0
+------
+- Search performance optimization. You can observe 50%+ improvement in some scenarios.
+  ```
+  $ rg --line-number --no-heading --smart-case . > $DATA
+
+  $ wc < $DATA
+   5520118 26862362 897487793
+
+  $ hyperfine -w 1 -L bin fzf-0.49.0,fzf-7ce6452,fzf-a5447b8,fzf '{bin} --filter "///" < $DATA | head -30'
+  Summary
+    fzf --filter "///" < $DATA | head -30 ran
+      1.16 ± 0.03 times faster than fzf-a5447b8 --filter "///" < $DATA | head -30
+      1.23 ± 0.03 times faster than fzf-7ce6452 --filter "///" < $DATA | head -30
+      1.52 ± 0.03 times faster than fzf-0.49.0 --filter "///" < $DATA | head -30
+  ```
+- Added `jump` and `jump-cancel` events that are triggered when leaving `jump` mode
+  ```sh
+  # Default behavior
+  fzf --bind space:jump
+
+  # Same as jump-accept action
+  fzf --bind space:jump,jump:accept
+
+  # Accept on jump, abort on cancel
+  fzf --bind space:jump,jump:accept,jump-cancel:abort
+
+  # Change header on jump-cancel
+  fzf --bind 'space:change-header(Type jump label)+jump,jump-cancel:change-header:Jump cancelled'
+  ```
+- Added a new environment variable `$FZF_KEY` exported to the child processes. It's the name of the last key pressed.
+  ```sh
+  fzf --bind 'space:jump,jump:accept,jump-cancel:transform:[[ $FZF_KEY =~ ctrl-c ]] && echo abort'
+  ```
+- fzf can be built with profiling options. See [BUILD.md](BUILD.md) for more information.
+- Bug fixes
+
+0.49.0
+------
+- Ingestion performance improved by around 40% (more or less depending on options)
+- `--info=hidden` and `--info=inline-right` will no longer hide the horizontal separator by default. This gives you more flexibility in customizing the layout.
+    ```sh
+    fzf --border --info=inline-right
+    fzf --border --info=inline-right --separator ═
+    fzf --border --info=inline-right --no-separator
+    fzf --border --info=hidden
+    fzf --border --info=hidden --separator ━
+    fzf --border --info=hidden --no-separator
+    ```
+- Added two environment variables exported to the child processes
+    - `FZF_PREVIEW_LABEL`
+    - `FZF_BORDER_LABEL`
+    ```sh
+    # Use the current value of $FZF_PREVIEW_LABEL to determine which actions to perform
+    git ls-files |
+      fzf --header 'Press CTRL-P to change preview mode' \
+          --bind='ctrl-p:transform:[[ $FZF_PREVIEW_LABEL =~ cat ]] \
+          && echo "change-preview(git log --color=always \{})+change-preview-label([[ log ]])" \
+          || echo "change-preview(bat --color=always \{})+change-preview-label([[ cat ]])"'
+    ```
+- Renamed `track` action to `track-current` to highlight the difference between the global tracking state set by `--track` and a one-off tracking action
+    - `track` is still available as an alias
+- Added `untrack-current` and `toggle-track-current` actions
+    - `*-current` actions are no-op when the global tracking state is set
+- Bug fixes and minor improvements
+
+0.48.1
+------
+- CTRL-T and ALT-C bindings can be disabled by setting `FZF_CTRL_T_COMMAND` and `FZF_ALT_C_COMMAND` to empty strings respectively when sourcing the script
+    ```sh
+    # bash
+    FZF_CTRL_T_COMMAND= FZF_ALT_C_COMMAND= eval "$(fzf --bash)"
+
+    # zsh
+    FZF_CTRL_T_COMMAND= FZF_ALT_C_COMMAND= eval "$(fzf --zsh)"
+
+    # fish
+    fzf --fish | FZF_CTRL_T_COMMAND= FZF_ALT_C_COMMAND= source
+    ```
+    - Setting the variables after sourcing the script will have no effect
+- Bug fixes
+
+0.48.0
+------
+- Shell integration scripts are now embedded in the fzf binary. This simplifies the distribution, and the users are less likely to have problems caused by using incompatible scripts and binaries.
+    - bash
+      ```sh
+      # Set up fzf key bindings and fuzzy completion
+      eval "$(fzf --bash)"
+      ```
+    - zsh
+      ```sh
+      # Set up fzf key bindings and fuzzy completion
+      eval "$(fzf --zsh)"
+      ```
+    - fish
+      ```fish
+      # Set up fzf key bindings
+      fzf --fish | source
+      ```
+- Added options for customizing the behavior of the built-in walker
+    | Option               | Description                                       | Default              |
+    | ---                  | ---                                               | ---                  |
+    | `--walker=OPTS`      | Walker options (`[file][,dir][,follow][,hidden]`) | `file,follow,hidden` |
+    | `--walker-root=DIR`  | Root directory from which to start walker         | `.`                  |
+    | `--walker-skip=DIRS` | Comma-separated list of directory names to skip   | `.git,node_modules`  |
+    - Examples
+        ```sh
+        # Built-in walker is only used by standalone fzf when $FZF_DEFAULT_COMMAND is not set
+        unset FZF_DEFAULT_COMMAND
+
+        fzf # default: --walker=file,follow,hidden --walker-root=. --walker-skip=.git,node_modules
+        fzf --walker=file,dir,hidden,follow --walker-skip=.git,node_modules,target
+
+        # Walker options in $FZF_DEFAULT_OPTS
+        export FZF_DEFAULT_OPTS="--walker=file,dir,hidden,follow --walker-skip=.git,node_modules,target"
+        fzf
+
+        # Reading from STDIN; --walker is ignored
+        seq 100 | fzf --walker=dir
+
+        # Reading from $FZF_DEFAULT_COMMAND; --walker is ignored
+        export FZF_DEFAULT_COMMAND='seq 100'
+        fzf --walker=dir
+        ```
+- Shell integration scripts have been updated to use the built-in walker with these new options and they are now much faster out of the box.
+
+0.47.0
+------
+- Replaced ["the default find command"][find] with a built-in directory walker to simplify the code and to achieve better performance and consistent behavior across platforms.
+  This doesn't affect you if you have `$FZF_DEFAULT_COMMAND` set.
+    - Breaking changes:
+        - Unlike [the previous "find" command][find], the new traversal code will list hidden files, but hidden directories will still be ignored
+        - No filtering of `devtmpfs` or `proc` types
+        - Traversal is parallelized, so the order of the entries will be different each time
+    - You may wonder why fzf implements directory walker anyway when it's a filter program following the [Unix philosophy][unix].
+      But fzf has had [the walker code for years][walker] to tackle the performance problem on Windows. And I decided to use the same approach on different platforms as well for the benefits listed above.
+    - Built-in walker is using the excellent [charlievieth/fastwalk][fastwalk] library, which easily outperforms its competitors and supports safely following symlinks.
+- Added `$FZF_DEFAULT_OPTS_FILE` to allow managing default options in a file
+    - See [#3618](https://github.com/junegunn/fzf/pull/3618)
+    - Option precedence from lower to higher
+        1. Options read from `$FZF_DEFAULT_OPTS_FILE`
+        1. Options from `$FZF_DEFAULT_OPTS`
+        1. Options from command-line arguments
+- Bug fixes and improvements
+
+[find]: https://github.com/junegunn/fzf/blob/0.46.1/src/constants.go#L60-L64
+[walker]: https://github.com/junegunn/fzf/pull/1847
+[fastwalk]: https://github.com/charlievieth/fastwalk
+[unix]: https://en.wikipedia.org/wiki/Unix_philosophy
+
+0.46.1
+------
+- Bug fixes and improvements
+- Fixed Windows binaries
+- Downgraded Go version to 1.20 to support older versions of Windows
+    - https://tip.golang.org/doc/go1.21#windows
+- Updated [rivo/uniseg](https://github.com/rivo/uniseg) dependency to v0.4.6
+
+0.46.0
+------
+- Added two new events
+    - `result` - triggered when the filtering for the current query is complete and the result list is ready
+    - `resize` - triggered when the terminal size is changed
+- fzf now exports the following environment variables to the child processes
+  | Variable           | Description                                                 |
+  | ---                | ---                                                         |
+  | `FZF_LINES`        | Number of lines fzf takes up excluding padding and margin   |
+  | `FZF_COLUMNS`      | Number of columns fzf takes up excluding padding and margin |
+  | `FZF_TOTAL_COUNT`  | Total number of items                                       |
+  | `FZF_MATCH_COUNT`  | Number of matched items                                     |
+  | `FZF_SELECT_COUNT` | Number of selected items                                    |
+  | `FZF_QUERY`        | Current query string                                        |
+  | `FZF_PROMPT`       | Prompt string                                               |
+  | `FZF_ACTION`       | The name of the last action performed                       |
+  - This allows you to write sophisticated transformations like so
+    ```sh
+    # Script to dynamically resize the preview window
+    transformer='
+      # 1 line for info, another for prompt, and 2 more lines for preview window border
+      lines=$(( FZF_LINES - FZF_MATCH_COUNT - 4 ))
+      if [[ $FZF_MATCH_COUNT -eq 0 ]]; then
+        echo "change-preview-window:hidden"
+      elif [[ $lines -gt 3 ]]; then
+        echo "change-preview-window:$lines"
+      elif [[ $FZF_PREVIEW_LINES -ne 3 ]]; then
+        echo "change-preview-window:3"
+      fi
+    '
+    seq 10000 | fzf --preview 'seq {} 10000' --preview-window up \
+                    --bind "result:transform:$transformer" \
+                    --bind "resize:transform:$transformer"
+    ```
+  - And we're phasing out `{fzf:prompt}` and `{fzf:action}`
+- Changed [mattn/go-runewidth](https://github.com/mattn/go-runewidth) dependency to [rivo/uniseg](https://github.com/rivo/uniseg) for accurate results
+    - Set `--ambidouble` if your terminal displays ambiguous width characters (e.g. box-drawing characters for borders) as 2 columns
+    - `RUNEWIDTH_EASTASIAN=1` is still respected for backward compatibility, but it's recommended that you use this new option instead
+- Bug fixes
+
+0.45.0
+------
+- Added `transform` action to conditionally perform a series of actions
+  ```sh
+  # Disallow selecting an empty line
+  echo -e "1. Hello\n2. Goodbye\n\n3. Exit" |
+    fzf --height '~100%' --reverse --header 'Select one' \
+        --bind 'enter:transform:[[ -n {} ]] && echo accept || echo "change-header:Invalid selection"'
+
+  # Move cursor past the empty line
+  echo -e "1. Hello\n2. Goodbye\n\n3. Exit" |
+    fzf --height '~100%' --reverse --header 'Select one' \
+        --bind 'enter:transform:[[ -n {} ]] && echo accept || echo "change-header:Invalid selection"' \
+        --bind 'focus:transform:[[ -n {} ]] && exit; [[ {fzf:action} =~ up$ ]] && echo up || echo down'
+
+  # A single key binding to toggle between modes
+  fd --type file |
+    fzf --prompt 'Files> ' \
+        --header 'CTRL-T: Switch between Files/Directories' \
+        --bind 'ctrl-t:transform:[[ ! {fzf:prompt} =~ Files ]] &&
+                  echo "change-prompt(Files> )+reload(fd --type file)" ||
+                  echo "change-prompt(Directories> )+reload(fd --type directory)"'
+  ```
+- Added placeholder expressions
+    - `{fzf:action}` - The name of the last action performed
+    - `{fzf:prompt}` - Prompt string (including ANSI color codes)
+    - `{fzf:query}` - Synonym for `{q}`
+- Added support for negative height
+  ```sh
+  # Terminal height minus 1, so you can still see the command line
+  fzf --height=-1
+  ```
+  - This handles a terminal resize better than `--height=$(($(tput lines) - 1))`
+- Added `accept-or-print-query` action that acts like `accept` but prints the
+  current query when there's no match for the query
+  ```sh
+  # You can make CTRL-R paste the current query when there's no match
+  export FZF_CTRL_R_OPTS='--bind enter:accept-or-print-query'
+  ```
+  - Note that there are alternative ways to implement the same strategy
+    ```sh
+    # 'become' is apparently more versatile but it's not available on Windows.
+    export FZF_CTRL_R_OPTS='--bind "enter:become:if [ -z {} ]; then echo {q}; else echo {}; fi"'
+
+    # Using the new 'transform' action
+    export FZF_CTRL_R_OPTS='--bind "enter:transform:[ -z {} ] && echo print-query || echo accept"'
+    ```
+- Added `show-header` and `hide-header` actions
+- Bug fixes
+
+0.44.1
+------
+- Fixed crash when preview window is hidden on `focus` event
+
+0.44.0
+------
+- (Experimental) Sixel image support in preview window (not available on Windows)
+    - [bin/fzf-preview.sh](bin/fzf-preview.sh) is added to demonstrate how to
+      display an image using Kitty image protocol or Sixel. You can use it
+      like so:
+      ```sh
+      fzf --preview='fzf-preview.sh {}'
+      ```
+- (Experimental) iTerm2 inline image protocol support in preview window (not available on Windows)
+  ```sh
+  # Using https://iterm2.com/utilities/imgcat
+  fzf --preview 'imgcat -W $FZF_PREVIEW_COLUMNS -H $FZF_PREVIEW_LINES {}'
+  ```
+- HTTP server can be configured to accept remote connections
+  ```sh
+  # FZF_API_KEY is required for a non-localhost listen address
+  export FZF_API_KEY="$(head -c 32 /dev/urandom | base64)"
+  fzf --listen 0.0.0.0:6266
+  ```
+    - To allow remote process execution, use `--listen-unsafe` instead
+      (`execute*`, `reload*`, `become`, `preview`, `change-preview`, `transform-*`)
+      ```sh
+      fzf --listen-unsafe 0.0.0.0:6266
+      ```
+- Bug fixes
+
+0.43.0
+------
+- (Experimental) Added support for Kitty image protocol in the preview window
+  (not available on Windows)
+  ```sh
+  fzf --preview='
+    if file --mime-type {} | grep -qF image/; then
+      # --transfer-mode=memory is the fastest option but if you want fzf to be able
+      # to redraw the image on terminal resize or on 'change-preview-window',
+      # you need to use --transfer-mode=stream.
+      kitty icat --clear --transfer-mode=memory --unicode-placeholder --stdin=no --place=${FZF_PREVIEW_COLUMNS}x${FZF_PREVIEW_LINES}@0x0 {} | sed \$d
+    else
+      bat --color=always {}
+    fi
+  '
+  ```
+- (Experimental) `--listen` server can report program state in JSON format (`GET /`)
+  ```sh
+  # fzf server started in "headless" mode
+  fzf --listen 6266 2> /dev/null
+
+  # Get program state
+  curl localhost:6266 | jq .
+
+  # Increase the number of items returned (default: 100)
+  curl localhost:6266?limit=1000 | jq .
+  ```
+- `--listen` server can be secured by setting `$FZF_API_KEY` environment
+  variable.
+  ```sh
+  export FZF_API_KEY="$(head -c 32 /dev/urandom | base64)"
+
+  # Server
+  fzf --listen 6266
+
+  # Client
+  curl localhost:6266 -H "x-api-key: $FZF_API_KEY" -d 'change-query(yo)'
+  ```
+- Added `toggle-header` action
+- Added mouse events for `--bind`
+    - `scroll-up` (bound to `up`)
+    - `scroll-down` (bound to `down`)
+    - `shift-scroll-up` (bound to `toggle+up`)
+    - `shift-scroll-down` (bound to `toggle+down`)
+    - `shift-left-click` (bound to `toggle`)
+    - `shift-right-click` (bound to `toggle`)
+    - `preview-scroll-up` (bound to `preview-up`)
+    - `preview-scroll-down` (bound to `preview-down`)
+    ```sh
+    # Twice faster scrolling both in the main window and the preview window
+    fzf --bind 'scroll-up:up+up,scroll-down:down+down' \
+        --bind 'preview-scroll-up:preview-up+preview-up' \
+        --bind 'preview-scroll-down:preview-down+preview-down' \
+        --preview 'cat {}'
+    ```
+- Added `offset-up` and `offset-down` actions
+  ```sh
+  # Scrolling will behave similarly to CTRL-E and CTRL-Y of vim
+  fzf --bind scroll-up:offset-up,scroll-down:offset-down \
+      --bind ctrl-y:offset-up,ctrl-e:offset-down \
+      --scroll-off=5
+  ```
+- Shell extensions
+    - Updated bash completion for fzf options
+    - bash key bindings no longer requires perl; it will use awk or mawk
+      instead if perl is not found
+    - Basic context-aware completion for ssh command
+    - Applied `--scheme=path` for better ordering of the result
+- Bug fixes and improvements
+
+0.42.0
+------
+- Added new info style: `--info=right`
+- Added new info style: `--info=inline-right`
+- Added new border style `thinblock` which uses symbols for legacy computing
+  [one eighth block elements](https://en.wikipedia.org/wiki/Symbols_for_Legacy_Computing)
+    - Similarly to `block`, this style is suitable when using a different
+      background color because the window is completely contained within the border.
+      ```sh
+      BAT_THEME=GitHub fzf --info=right --border=thinblock --preview-window=border-thinblock \
+          --margin=3 --scrollbar=▏▕ --preview='bat --color=always --style=numbers {}' \
+          --color=light,query:238,fg:238,bg:251,bg+:249,gutter:251,border:248,preview-bg:253
+      ```
+    - This style may not render correctly depending on the font and the
+      terminal emulator.
+
+0.41.1
+------
+- Fixed a bug where preview window is not updated when `--disabled` is set and
+  a reload is triggered by `change:reload` binding
+
+0.41.0
+------
+- Added color name `preview-border` and `preview-scrollbar`
+- Added new border style `block` which uses [block elements](https://en.wikipedia.org/wiki/Block_Elements)
+- `--scrollbar` can take two characters, one for the main window, the other
+  for the preview window
+- Putting it altogether:
+  ```sh
+  fzf-tmux -p 80% --padding 1,2 --preview 'bat --style=plain --color=always {}' \
+      --color 'bg:237,bg+:235,gutter:237,border:238,scrollbar:236' \
+      --color 'preview-bg:235,preview-border:236,preview-scrollbar:234' \
+      --preview-window 'border-block' --border block --scrollbar '▌▐'
+  ```
+- Bug fixes and improvements
+
+0.40.0
+------
+- Added `zero` event that is triggered when there's no match
+  ```sh
+  # Reload the candidate list when there's no match
+  echo $RANDOM | fzf --bind 'zero:reload(echo $RANDOM)+clear-query' --height 3
+  ```
+- New actions
+    - Added `track` action which makes fzf track the current item when the
+      search result is updated. If the user manually moves the cursor, or the
+      item is not in the updated search result, tracking is automatically
+      disabled. Tracking is useful when you want to see the surrounding items
+      by deleting the query string.
+      ```sh
+      # Narrow down the list with a query, point to a command,
+      # and hit CTRL-T to see its surrounding commands.
+      export FZF_CTRL_R_OPTS="
+        --preview 'echo {}' --preview-window up:3:hidden:wrap
+        --bind 'ctrl-/:toggle-preview'
+        --bind 'ctrl-t:track+clear-query'
+        --bind 'ctrl-y:execute-silent(echo -n {2..} | pbcopy)+abort'
+        --color header:italic
+        --header 'Press CTRL-Y to copy command into clipboard'"
+      ```
+    - Added `change-header(...)`
+    - Added `transform-header(...)`
+    - Added `toggle-track` action
+- Fixed `--track` behavior when used with `--tac`
+    - However, using `--track` with `--tac` is not recommended. The resulting
+      behavior can be very confusing.
+- Bug fixes and improvements
+
+0.39.0
+------
+- Added `one` event that is triggered when there's only one match
+  ```sh
+  # Automatically select the only match
+  seq 10 | fzf --bind one:accept
+  ```
+- Added `--track` option that makes fzf track the current selection when the
+  result list is updated. This can be useful when browsing logs using fzf with
+  sorting disabled.
+  ```sh
+  git log --oneline --graph --color=always | nl |
+      fzf --ansi --track --no-sort --layout=reverse-list
+  ```
+- If you use `--listen` option without a port number fzf will automatically
+  allocate an available port and export it as `$FZF_PORT` environment
+  variable.
+  ```sh
+  # Automatic port assignment
+  fzf --listen --bind 'start:execute-silent:echo $FZF_PORT > /tmp/fzf-port'
+
+  # Say hello
+  curl "localhost:$(cat /tmp/fzf-port)" -d 'preview:echo Hello, fzf is listening on $FZF_PORT.'
+  ```
+- A carriage return and a line feed character will be rendered as dim ␍ and
+  ␊ respectively.
+  ```sh
+  printf "foo\rbar\nbaz" | fzf --read0 --preview 'echo {}'
+  ```
+- fzf will stop rendering a non-displayable characters as a space. This will
+  likely cause less glitches in the preview window.
+  ```sh
+  fzf --preview 'head -1000 /dev/random'
+  ```
+- Bug fixes and improvements
+
+0.38.0
+------
+- New actions
+    - `become(...)` - Replace the current fzf process with the specified
+      command using `execve(2)` system call.
+      See https://github.com/junegunn/fzf#turning-into-a-different-process for
+      more information.
+      ```sh
+      # Open selected files in Vim
+      fzf --multi --bind 'enter:become(vim {+})'
+
+      # Open the file in Vim and go to the line
+      git grep --line-number . |
+          fzf --delimiter : --nth 3.. --bind 'enter:become(vim {1} +{2})'
+      ```
+        - This action is not supported on Windows
+    - `show-preview`
+    - `hide-preview`
+- Bug fixes
+    - `--preview-window 0,hidden` should not execute the preview command until
+      `toggle-preview` action is triggered
+
+0.37.0
+------
+- Added a way to customize the separator of inline info
+  ```sh
+  fzf --info 'inline: ╱ ' --prompt '╱ ' --color prompt:bright-yellow
+  ```
+- New event
+    - `focus` - Triggered when the focus changes due to a vertical cursor
+      movement or a search result update
+      ```sh
+      fzf --bind 'focus:transform-preview-label:echo [ {} ]' --preview 'cat {}'
+
+      # Any action bound to the event runs synchronously and thus can make the interface sluggish
+      # e.g. lolcat isn't one of the fastest programs, and every cursor movement in
+      #      fzf will be noticeably affected by its execution time
+      fzf --bind 'focus:transform-preview-label:echo [ {} ] | lolcat -f' --preview 'cat {}'
+
+      # Beware not to introduce an infinite loop
+      seq 10 | fzf --bind 'focus:up' --cycle
+      ```
+- New actions
+    - `change-border-label`
+    - `change-preview-label`
+    - `transform-border-label`
+    - `transform-preview-label`
+- Bug fixes and improvements
+
+0.36.0
+------
+- Added `--listen=HTTP_PORT` option to start HTTP server. It allows external
+  processes to send actions to perform via POST method.
+  ```sh
+  # Start HTTP server on port 6266
+  fzf --listen 6266
+
+  # Send actions to the server
+  curl -XPOST localhost:6266 -d 'reload(seq 100)+change-prompt(hundred> )'
+  ```
+- Added draggable scrollbar to the main search window and the preview window
+  ```sh
+  # Hide scrollbar
+  fzf --no-scrollbar
+
+  # Customize scrollbar
+  fzf --scrollbar ┆ --color scrollbar:blue
+  ```
+- New event
+    - Added `load` event that is triggered when the input stream is complete
+      and the initial processing of the list is complete.
+      ```sh
+      # Change the prompt to "loaded" when the input stream is complete
+      (seq 10; sleep 1; seq 11 20) | fzf --prompt 'Loading> ' --bind 'load:change-prompt:Loaded> '
+
+      # You can use it instead of 'start' event without `--sync` if asynchronous
+      # trigger is not an issue.
+      (seq 10; sleep 1; seq 11 20) | fzf --bind 'load:last'
+      ```
+- New actions
+    - Added `pos(...)` action to move the cursor to the numeric position
+        - `first` and `last` are equivalent to `pos(1)` and `pos(-1)` respectively
+      ```sh
+      # Put the cursor on the 10th item
+      seq 100 | fzf --sync --bind 'start:pos(10)'
+
+      # Put the cursor on the 10th to last item
+      seq 100 | fzf --sync --bind 'start:pos(-10)'
+      ```
+    - Added `reload-sync(...)` action which replaces the current list only after
+      the reload process is complete. This is useful when the command takes
+      a while to produce the initial output and you don't want fzf to run against
+      an empty list while the command is running.
+      ```sh
+      # You can still filter and select entries from the initial list for 3 seconds
+      seq 100 | fzf --bind 'load:reload-sync(sleep 3; seq 1000)+unbind(load)'
+      ```
+    - Added `next-selected` and `prev-selected` actions to move between selected
+      items
+      ```sh
+      # `next-selected` will move the pointer to the next selected item below the current line
+      # `prev-selected` will move the pointer to the previous selected item above the current line
+      seq 10 | fzf --multi --bind ctrl-n:next-selected,ctrl-p:prev-selected
+
+      # Both actions respect --layout option
+      seq 10 | fzf --multi --bind ctrl-n:next-selected,ctrl-p:prev-selected --layout reverse
+      ```
+    - Added `change-query(...)` action that simply changes the query string to the
+      given static string. This can be useful when used with `--listen`.
+      ```sh
+      curl localhost:6266 -d "change-query:$(date)"
+      ```
+    - Added `transform-prompt(...)` action for transforming the prompt string
+      using an external command
+      ```sh
+      # Press space to change the prompt string using an external command
+      # (only the first line of the output is taken)
+      fzf --bind 'space:reload(ls),load:transform-prompt(printf "%s> " "$(date)")'
+      ```
+    - Added `transform-query(...)` action for transforming the query string using
+      an external command
+      ```sh
+      # Press space to convert the query to uppercase letters
+      fzf --bind 'space:transform-query(tr "[:lower:]" "[:upper:]" <<< {q})'
+
+      # Bind it to 'change' event for automatic conversion
+      fzf --bind 'change:transform-query(tr "[:lower:]" "[:upper:]" <<< {q})'
+
+      # Can only type numbers
+      fzf --bind 'change:transform-query(sed "s/[^0-9]//g" <<< {q})'
+      ```
+    - `put` action can optionally take an argument string
+      ```sh
+      # a will put 'alpha' on the prompt, ctrl-b will put 'bravo'
+      fzf --bind 'a:put+put(lpha),ctrl-b:put(bravo)'
+      ```
+- Added color name `preview-label` for `--preview-label` (defaults to `label`
+  for `--border-label`)
+- Better support for (Windows) terminals where each box-drawing character
+  takes 2 columns. Set `RUNEWIDTH_EASTASIAN` environment variable to `0` or `1`.
+    - On Vim, the variable will be automatically set if `&ambiwidth` is `double`
+- Behavior changes
+    - fzf will always execute the preview command if the command template
+      contains `{q}` even when it's empty. If you prefer the old behavior,
+      you'll have to check if `{q}` is empty in your command.
+      ```sh
+      # This will show // even when the query is empty
+      : | fzf --preview 'echo /{q}/'
+
+      # But if you don't want it,
+      : | fzf --preview '[ -n {q} ] || exit; echo /{q}/'
+      ```
+    - `double-click` will behave the same as `enter` unless otherwise specified,
+      so you don't have to repeat the same action twice in `--bind` in most cases.
+      ```sh
+      # No need to bind 'double-click' to the same action
+      fzf --bind 'enter:execute:less {}' # --bind 'double-click:execute:less {}'
+      ```
+    - If the color for `separator` is not specified, it will default to the
+      color for `border`. Same holds true for `scrollbar`. This is to reduce
+      the number of configuration items required to achieve a consistent color
+      scheme.
+    - If `follow` flag is specified in `--preview-window` option, fzf will
+      automatically scroll to the bottom of the streaming preview output. But
+      when the user manually scrolls the window, the following stops. With
+      this version, fzf will resume following if the user scrolls the window
+      to the bottom.
+    - Default border style on Windows is changed to `sharp` because some
+      Windows terminals are not capable of displaying `rounded` border
+      characters correctly.
+- Minor bug fixes and improvements
+
+0.35.1
+------
+- Fixed a bug where fzf with `--tiebreak=chunk` crashes on inverse match query
+- Fixed a bug where clicking above fzf would paste escape sequences
+
+0.35.0
+------
+- Added `start` event that is triggered only once when fzf finder starts.
+  Since fzf consumes the input stream asynchronously, the input list is not
+  available unless you use `--sync`.
+  ```sh
+  seq 100 | fzf --multi --sync --bind 'start:last+select-all+preview(echo welcome)'
+  ```
+- Added `--border-label` and `--border-label-pos` for putting label on the border
+  ```sh
+  # ANSI color codes are supported
+  # (with https://github.com/busyloop/lolcat)
+  label=$(curl -s http://metaphorpsum.com/sentences/1 | lolcat -f)
+
+  # Border label at the center
+  fzf --height=10 --border --border-label="╢ $label ╟" --color=label:italic:black
+
+  # Left-aligned (positive integer)
+  fzf --height=10 --border --border-label="╢ $label ╟" --border-label-pos=3 --color=label:italic:black
+
+  # Right-aligned (negative integer) on the bottom line (:bottom)
+  fzf --height=10 --border --border-label="╢ $label ╟" --border-label-pos=-3:bottom --color=label:italic:black
+  ```
+- Also added `--preview-label` and `--preview-label-pos` for the border of the
+  preview window
+  ```sh
+  fzf --preview 'cat {}' --border --preview-label=' Preview ' --preview-label-pos=2
+  ```
+- Info panel (match counter) will be followed by a horizontal separator by
+  default
+    - Use `--no-separator` or `--separator=''` to hide the separator
+    - You can specify an arbitrary string that is repeated to form the
+      horizontal separator. e.g. `--separator=╸`
+    - The color of the separator can be customized via `--color=separator:...`
+    - ANSI color codes are also supported
+  ```sh
+  fzf --separator=╸ --color=separator:green
+  fzf --separator=$(lolcat -f -F 1.4 <<< ▁▁▂▃▄▅▆▆▅▄▃▂▁▁) --info=inline
+  ```
+- Added `--border=bold` and `--border=double` along with
+  `--preview-window=border-bold` and `--preview-window=border-double`
+
+0.34.0
+------
+- Added support for adaptive `--height`. If the `--height` value is prefixed
+  with `~`, fzf will automatically determine the height in the range according
+  to the input size.
+  ```sh
+  seq 1 | fzf --height ~70% --border --padding 1 --margin 1
+  seq 10 | fzf --height ~70% --border --padding 1 --margin 1
+  seq 100 | fzf --height ~70% --border --padding 1 --margin 1
+  ```
+    - There are a few limitations
+        - Not compatible with percent top/bottom margin/padding
+          ```sh
+          # This is not allowed (top/bottom margin in percent value)
+          fzf --height ~50% --border --margin 5%,10%
+
+          # This is allowed (top/bottom margin in fixed value)
+          fzf --height ~50% --border --margin 2,10%
+          ```
+        - fzf will not start until it can determine the right height for the input
+          ```sh
+          # fzf will open immediately
+          (sleep 2; seq 10) | fzf --height 50%
+
+          # fzf will open after 2 seconds
+          (sleep 2; seq 10) | fzf --height ~50%
+          (sleep 2; seq 1000) | fzf --height ~50%
+          ```
+- Fixed tcell renderer used to render full-screen fzf on Windows
+- ~~`--no-clear` is deprecated. Use `reload` action instead.~~
+
+0.33.0
+------
+- Added `--scheme=[default|path|history]` option to choose scoring scheme
+    - (Experimental)
+    - We updated the scoring algorithm in 0.32.0, however we have learned that
+      this new scheme (`default`) is not always giving the optimal result
+    - `path`: Additional bonus point is only given to the characters after
+      path separator. You might want to choose this scheme if you have many
+      files with spaces in their paths.
+    - `history`: No additional bonus points are given so that we give more
+      weight to the chronological ordering. This is equivalent to the scoring
+      scheme before 0.32.0. This also sets `--tiebreak=index`.
+- ANSI color sequences with colon delimiters are now supported.
+  ```sh
+  printf "\e[38;5;208mOption 1\e[m\nOption 2" | fzf --ansi
+  printf "\e[38:5:208mOption 1\e[m\nOption 2" | fzf --ansi
+  ```
+- Support `border-{up,down}` as the synonyms for `border-{top,bottom}` in
+  `--preview-window`
+- Added support for ANSI `strikethrough`
+  ```sh
+  printf "\e[9mdeleted" | fzf --ansi
+  fzf --color fg+:strikethrough
+  ```
+
+0.32.1
+------
+- Fixed incorrect ordering of `--tiebreak=chunk`
+- fzf-tmux will show fzf border instead of tmux popup border (requires tmux 3.3)
+  ```sh
+  fzf-tmux -p70%
+  fzf-tmux -p70% --color=border:bright-red
+  fzf-tmux -p100%,60% --color=border:bright-yellow --border=horizontal --padding 1,5 --margin 1,0
+  fzf-tmux -p70%,100% --color=border:bright-green --border=vertical
+
+  # Key bindings (CTRL-T, CTRL-R, ALT-C) will use these options
+  export FZF_TMUX_OPTS='-p100%,60% --color=border:green --border=horizontal --padding 1,5 --margin 1,0'
+  ```
+
+0.32.0
+------
+- Updated the scoring algorithm
+    - Different bonus points to different categories of word boundaries
+      (listed higher to lower bonus point)
+        - Word after whitespace characters or beginning of the string
+        - Word after common delimiter characters (`/,:;|`)
+        - Word after other non-word characters
+      ```sh
+      # foo/bar.sh` is preferred over `foo-bar.sh` on `bar`
+      fzf --query=bar --height=4 << EOF
+      foo-bar.sh
+      foo/bar.sh
+      EOF
+      ```
+- Added a new tiebreak `chunk`
+    - Favors the line with shorter matched chunk. A chunk is a set of
+      consecutive non-whitespace characters.
+    - Unlike the default `length`, this scheme works well with tabular input
+      ```sh
+      # length prefers item #1, because the whole line is shorter,
+      # chunk prefers item #2, because the matched chunk ("foo") is shorter
+      fzf --height=6 --header-lines=2 --tiebreak=chunk --reverse --query=fo << "EOF"
+      N | Field1 | Field2 | Field3
+      - | ------ | ------ | ------
+      1 | hello  | foobar | baz
+      2 | world  | foo    | bazbaz
+      EOF
+      ```
+    - If the input does not contain any spaces, `chunk` is equivalent to
+      `length`. But we're not going to set it as the default because it is
+      computationally more expensive.
+- Bug fixes and improvements
+
+0.31.0
+------
+- Added support for an alternative preview window layout that is activated
+  when the size of the preview window is smaller than a certain threshold.
+  ```sh
+  # If the width of the preview window is smaller than 50 columns,
+  # it will be displayed above the search window.
+  fzf --preview 'cat {}' --preview-window 'right,50%,border-left,<50(up,30%,border-bottom)'
+
+  # Or you can just hide it like so
+  fzf --preview 'cat {}' --preview-window '<50(hidden)'
+  ```
+- fzf now uses SGR mouse mode to properly support mouse on larger terminals
+- You can now use characters that do not satisfy `unicode.IsGraphic` constraint
+  for `--marker`, `--pointer`, and `--ellipsis`. Allows Nerd Fonts and stuff.
+  Use at your own risk.
+- Bug fixes and improvements
+- Shell extension
+    - `kill` completion now requires trigger sequence (`**`) for consistency
+
+0.30.0
+------
+- Fixed cursor flickering over the screen by hiding it during rendering
+- Added `--ellipsis` option. You can take advantage of it to make fzf
+  effectively search non-visible parts of the item.
+  ```sh
+  # Search against hidden line numbers on the far right
+  nl /usr/share/dict/words                  |
+    awk '{printf "%s%1000s\n", $2, $1}'     |
+    fzf --nth=-1 --no-hscroll --ellipsis='' |
+    awk '{print $2}'
+  ```
+- Added `rebind` action for restoring bindings after `unbind`
+- Bug fixes and improvements
+
+0.29.0
+------
+- Added `change-preview(...)` action to change the `--preview` command
+    - cf. `preview(...)` is a one-off action that doesn't change the default
+      preview command
+- Added `change-preview-window(...)` action
+    - You can rotate through the different options separated by `|`
+      ```sh
+      fzf --preview 'cat {}' --preview-window right:40% \
+          --bind 'ctrl-/:change-preview-window(right,70%|down,40%,border-top|hidden|)'
+      ```
+- Fixed rendering of the prompt line when overflow occurs with `--info=inline`
+
+0.28.0
+------
+- Added `--header-first` option to print header before the prompt line
+  ```sh
+  fzf --header $'Welcome to fzf\n▔▔▔▔▔▔▔▔▔▔▔▔▔▔' --reverse --height 30% --border --header-first
+  ```
+- Added `--scroll-off=LINES` option (similar to `scrolloff` option of Vim)
+    - You can set it to a very large number so that the cursor stays in the
+      middle of the screen while scrolling
+      ```sh
+      fzf --scroll-off=5
+      fzf --scroll-off=999
+      ```
+- Fixed bug where preview window is not updated on `reload` (#2644)
+- fzf on Windows will also use `$SHELL` to execute external programs
+    - See #2638 and #2647
+    - Thanks to @rashil2000, @vovcacik, and @janlazo
+
+0.27.3
+------
+- Preview window is `hidden` by default when there are `preview` bindings but
+  `--preview` command is not given
+- Fixed bug where `{n}` is not properly reset on `reload`
+- Fixed bug where spinner is not displayed on `reload`
+- Enhancements in tcell renderer for Windows (#2616)
+- Vim plugin
+    - `sinklist` is added as a synonym to `sink*` so that it's easier to add
+      a function to a spec dictionary
+      ```vim
+      let spec = { 'source': 'ls', 'options': ['--multi', '--preview', 'cat {}'] }
+      function spec.sinklist(matches)
+        echom string(a:matches)
+      endfunction
+
+      call fzf#run(fzf#wrap(spec))
+      ```
+    - Vim 7 compatibility
+
+0.27.2
+------
+- 16 base ANSI colors can be specified by their names
+  ```sh
+  fzf --color fg:3,fg+:11
+  fzf --color fg:yellow,fg+:bright-yellow
+  ```
+- Fix bug where `--read0` not properly displaying long lines
+
+0.27.1
+------
+- Added `unbind` action. In the following Ripgrep launcher example, you can
+  use `unbind(reload)` to switch to fzf-only filtering mode.
+    - See https://github.com/junegunn/fzf/blob/master/ADVANCED.md#switching-to-fzf-only-search-mode
+- Vim plugin
+    - Vim plugin will stop immediately even when the source command hasn't finished
+      ```vim
+      " fzf will read the stream file while allowing other processes to append to it
+      call fzf#run({'source': 'cat /dev/null > /tmp/stream; tail -f /tmp/stream'})
+      ```
+    - It is now possible to open popup window relative to the current window
+      ```vim
+      let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true, 'yoffset': 1.0 } }
+      ```
+
 0.27.0
 ------
 - More border options for `--preview-window`
@@ -46,7 +934,7 @@ CHANGELOG
   ```
 - Added `select` and `deselect` action for unconditionally selecting or
   deselecting a single item in `--multi` mode. Complements `toggle` action.
-- Sigificant performance improvement in ANSI code processing
+- Significant performance improvement in ANSI code processing
 - Bug fixes and improvements
 - Built with Go 1.16
 
@@ -1128,4 +2016,3 @@ add `--sync` option to re-enable buffering.
 ### Improvements
 - `--select-1` and `--exit-0` will start finder immediately when the condition
   cannot be met
-

Dockerfile

@@ -1,5 +1,5 @@
-FROM archlinux/base:latest
-RUN pacman -Sy && pacman --noconfirm -S awk git tmux zsh fish ruby procps go make gcc
+FROM --platform=linux/amd64 ubuntu:22.04
+RUN apt-get update -y && apt install -y git make golang zsh fish ruby tmux
 RUN gem install --no-document -v 5.14.2 minitest
 RUN echo '. /usr/share/bash-completion/completions/git' >> ~/.bashrc
 RUN echo '. ~/.bashrc' >> ~/.bash_profile
@@ -8,4 +8,5 @@ RUN echo '. ~/.bashrc' >> ~/.bash_profile
 RUN rm -f /etc/bash.bashrc
 COPY . /fzf
 RUN cd /fzf && make install && ./install --all
+ENV LANG C.UTF-8
 CMD tmux new 'set -o pipefail; ruby /fzf/test/test_go.rb | tee out && touch ok' && cat out && [ -e ok ]

LICENSE

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

Makefile

@@ -4,7 +4,7 @@ GOOS           ?= $(word 1, $(subst /, " ", $(word 4, $(shell go version))))
 
 MAKEFILE       := $(realpath $(lastword $(MAKEFILE_LIST)))
 ROOT_DIR       := $(shell dirname $(MAKEFILE))
-SOURCES        := $(wildcard *.go src/*.go src/*/*.go) $(MAKEFILE)
+SOURCES        := $(wildcard *.go src/*.go src/*/*.go shell/*sh) $(MAKEFILE)
 
 ifdef FZF_VERSION
 VERSION        := $(FZF_VERSION)
@@ -20,7 +20,7 @@ VERSION_REGEX  := $(subst .,\.,$(VERSION_TRIM))
 ifdef FZF_REVISION
 REVISION       := $(FZF_REVISION)
 else
-REVISION       := $(shell git log -n 1 --pretty=format:%h -- $(SOURCES) 2> /dev/null)
+REVISION       := $(shell git log -n 1 --pretty=format:%h --abbrev=8 -- $(SOURCES) 2> /dev/null)
 endif
 ifeq ($(REVISION),)
 $(error Not on git repository; cannot determine $$FZF_REVISION)
@@ -29,11 +29,14 @@ BUILD_FLAGS    := -a -ldflags "-s -w -X main.version=$(VERSION) -X main.revision
 
 BINARY32       := fzf-$(GOOS)_386
 BINARY64       := fzf-$(GOOS)_amd64
+BINARYS390     := fzf-$(GOOS)_s390x
 BINARYARM5     := fzf-$(GOOS)_arm5
 BINARYARM6     := fzf-$(GOOS)_arm6
 BINARYARM7     := fzf-$(GOOS)_arm7
 BINARYARM8     := fzf-$(GOOS)_arm8
 BINARYPPC64LE  := fzf-$(GOOS)_ppc64le
+BINARYRISCV64  := fzf-$(GOOS)_riscv64
+BINARYLOONG64  := fzf-$(GOOS)_loong64
 
 # https://en.wikipedia.org/wiki/Uname
 UNAME_M := $(shell uname -m)
@@ -41,6 +44,8 @@ ifeq ($(UNAME_M),x86_64)
 	BINARY := $(BINARY64)
 else ifeq ($(UNAME_M),amd64)
 	BINARY := $(BINARY64)
+else ifeq ($(UNAME_M),s390x)
+	BINARY := $(BINARYS390)
 else ifeq ($(UNAME_M),i686)
 	BINARY := $(BINARY32)
 else ifeq ($(UNAME_M),i386)
@@ -52,13 +57,19 @@ else ifeq ($(UNAME_M),armv6l)
 else ifeq ($(UNAME_M),armv7l)
 	BINARY := $(BINARYARM7)
 else ifeq ($(UNAME_M),armv8l)
-	BINARY := $(BINARYARM8)
+	# armv8l is always 32-bit and should implement the armv7 ISA, so
+	# just use the same filename as for armv7.
+	BINARY := $(BINARYARM7)
 else ifeq ($(UNAME_M),arm64)
 	BINARY := $(BINARYARM8)
 else ifeq ($(UNAME_M),aarch64)
 	BINARY := $(BINARYARM8)
 else ifeq ($(UNAME_M),ppc64le)
 	BINARY := $(BINARYPPC64LE)
+else ifeq ($(UNAME_M),riscv64)
+	BINARY := $(BINARYRISCV64)
+else ifeq ($(UNAME_M),loongarch64)
+	BINARY := $(BINARYLOONG64)
 else
 $(error Build on $(UNAME_M) is not supported, yet.)
 endif
@@ -68,6 +79,7 @@ all: target/$(BINARY)
 test: $(SOURCES)
 	[ -z "$$(gofmt -s -d src)" ] || (gofmt -s -d src; exit 1)
 	SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" \
+				github.com/junegunn/fzf \
 				github.com/junegunn/fzf/src \
 				github.com/junegunn/fzf/src/algo \
 				github.com/junegunn/fzf/src/tui \
@@ -78,10 +90,17 @@ bench:
 
 install: bin/fzf
 
+generate:
+	PATH=$(PATH):$(GOPATH)/bin $(GO) generate ./...
+
 build:
-	goreleaser --rm-dist --snapshot
+	goreleaser build --clean --snapshot --skip=post-hooks
 
 release:
+	# Make sure that the tests pass and the build works
+	TAGS=tcell make test
+	make test build clean
+
 ifndef GITHUB_TOKEN
 	$(error GITHUB_TOKEN is not defined)
 endif
@@ -99,6 +118,7 @@ endif
 	grep -qF $(VERSION) install.ps1
 
 	# Make release note out of CHANGELOG.md
+	mkdir -p tmp
 	sed -n '/^$(VERSION_REGEX)$$/,/^[0-9]/p' CHANGELOG.md | tail -r | \
 		sed '1,/^ *$$/d' | tail -r | sed 1,2d | tee tmp/release-note
 
@@ -107,7 +127,7 @@ endif
 	git push origin temp --follow-tags --force
 
 	# Make a GitHub release
-	goreleaser --rm-dist --release-notes tmp/release-note
+	goreleaser --clean --release-notes tmp/release-note
 
 	# Push to master
 	git checkout master
@@ -125,6 +145,8 @@ target/$(BINARY32): $(SOURCES)
 target/$(BINARY64): $(SOURCES)
 	GOARCH=amd64 $(GO) build $(BUILD_FLAGS) -o $@
 
+target/$(BINARYS390): $(SOURCES)
+	GOARCH=s390x $(GO) build $(BUILD_FLAGS) -o $@
 # https://github.com/golang/go/wiki/GoArm
 target/$(BINARYARM5): $(SOURCES)
 	GOARCH=arm GOARM=5 $(GO) build $(BUILD_FLAGS) -o $@
@@ -141,7 +163,14 @@ target/$(BINARYARM8): $(SOURCES)
 target/$(BINARYPPC64LE): $(SOURCES)
 	GOARCH=ppc64le $(GO) build $(BUILD_FLAGS) -o $@
 
+target/$(BINARYRISCV64): $(SOURCES)
+	GOARCH=riscv64 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYLOONG64): $(SOURCES)
+	GOARCH=loong64 $(GO) build $(BUILD_FLAGS) -o $@
+
 bin/fzf: target/$(BINARY) | bin
+	-rm -f bin/fzf
 	cp -f target/$(BINARY) bin/fzf
 
 docker:
@@ -156,4 +185,4 @@ update:
 	$(GO) get -u
 	$(GO) mod tidy
 
-.PHONY: all build release test bench install clean docker docker-test update
+.PHONY: all generate build release test bench install clean docker docker-test update

README-VIM.md

@@ -12,7 +12,10 @@ differ depending on the package manager.
 " If installed using Homebrew
 set rtp+=/usr/local/opt/fzf
 
-" If installed using git
+" If installed using Homebrew on Apple Silicon
+set rtp+=/opt/homebrew/opt/fzf
+
+" If you have cloned fzf on ~/.fzf directory
 set rtp+=~/.fzf
 ```
 
@@ -23,7 +26,10 @@ written as:
 " If installed using Homebrew
 Plug '/usr/local/opt/fzf'
 
-" If installed using git
+" If installed using Homebrew on Apple Silicon
+Plug '/opt/homebrew/opt/fzf'
+
+" If you have cloned fzf on ~/.fzf directory
 Plug '~/.fzf'
 ```
 
@@ -115,7 +121,7 @@ let g:fzf_action = {
 
 " An action can be a reference to a function that processes selected lines
 function! s:build_quickfix_list(lines)
-  call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
+  call setqflist(map(copy(a:lines), '{ "filename": v:val, "lnum": 1 }'))
   copen
   cc
 endfunction
@@ -127,9 +133,15 @@ let g:fzf_action = {
   \ 'ctrl-v': 'vsplit' }
 
 " Default fzf layout
-" - Popup window
+" - Popup window (center of the screen)
 let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 
+" - Popup window (center of the current window)
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true } }
+
+" - Popup window (anchored to the bottom of the current window)
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true, 'yoffset': 1.0 } }
+
 " - down / up / left / right
 let g:fzf_layout = { 'down': '40%' }
 
@@ -226,19 +238,20 @@ call fzf#run({'sink': 'e'})
 ```
 
 We haven't specified the `source`, so this is equivalent to starting fzf on
-command line without standard input pipe; fzf will use find command (or
-`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
-directory. When you select one, it will open it with the sink, `:e` command.
-If you want to open it in a new tab, you can pass `:tabedit` command instead
-as the sink.
+command line without standard input pipe; fzf will traverse the file system
+under the current directory to get the list of files. (If
+`$FZF_DEFAULT_COMMAND` is set, fzf will use the output of the command
+instead.) When you select one, it will open it with the sink, `:e` command. If
+you want to open it in a new tab, you can pass `:tabedit` command instead as
+the sink.
 
 ```vim
 call fzf#run({'sink': 'tabedit'})
 ```
 
-Instead of using the default find command, you can use any shell command as
-the source. The following example will list the files managed by git. It's
-equivalent to running `git ls-files | fzf` on shell.
+You can use any shell command as the source to generate the list. The
+following example will list the files managed by git. It's equivalent to
+running `git ls-files | fzf` on shell.
 
 ```vim
 call fzf#run({'source': 'git ls-files', 'sink': 'e'})
@@ -277,7 +290,7 @@ The following table summarizes the available options.
 | `source`                   | list          | Vim list as input to fzf                                              |
 | `sink`                     | string        | Vim command to handle the selected item (e.g. `e`, `tabe`)            |
 | `sink`                     | funcref       | Reference to function to process each selected item                   |
-| `sink*`                    | funcref       | Similar to `sink`, but takes the list of output lines at once         |
+| `sinklist` (or `sink*`)    | funcref       | Similar to `sink`, but takes the list of output lines at once         |
 | `options`                  | string/list   | Options to fzf                                                        |
 | `dir`                      | string        | Working directory                                                     |
 | `up`/`down`/`left`/`right` | number/string | (Layout) Window position and size (e.g. `20`, `50%`)                  |
@@ -302,7 +315,8 @@ following options are allowed:
 - Optional:
     - `yoffset` [float default 0.5 range [0 ~ 1]]
     - `xoffset` [float default 0.5 range [0 ~ 1]]
-    - `border` [string default `rounded`]: Border style
+    - `relative` [boolean default v:false]
+    - `border` [string default `rounded` (`sharp` on Windows)]: Border style
         - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right` / `no[ne]`
 
 `fzf#wrap`
@@ -380,7 +394,7 @@ command! -bang -complete=dir -nargs=? LS
 
 - `g:fzf_layout`
 - `g:fzf_action`
-    - **Works only when no custom `sink` (or `sink*`) is provided**
+    - **Works only when no custom `sink` (or `sinklist`) is provided**
         - Having custom sink usually means that each entry is not an ordinary
           file path (e.g. name of color scheme), so we can't blindly apply the
           same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
@@ -392,15 +406,41 @@ Tips
 
 ### fzf inside terminal buffer
 
-The latest versions of Vim and Neovim include builtin terminal emulator
-(`:terminal`) and fzf will start in a terminal buffer in the following cases:
+On the latest versions of Vim and Neovim, fzf will start in a terminal buffer.
+If you find the default ANSI colors to be different, consider configuring the
+colors using `g:terminal_ansi_colors` in regular Vim or `g:terminal_color_x`
+in Neovim.
 
-- On Neovim
-- On GVim
-- On Terminal Vim with a non-default layout
-    - `call fzf#run({'left': '30%'})` or `let g:fzf_layout = {'left': '30%'}`
+```vim
+" Terminal colors for seoul256 color scheme
+if has('nvim')
+  let g:terminal_color_0 = '#4e4e4e'
+  let g:terminal_color_1 = '#d68787'
+  let g:terminal_color_2 = '#5f865f'
+  let g:terminal_color_3 = '#d8af5f'
+  let g:terminal_color_4 = '#85add4'
+  let g:terminal_color_5 = '#d7afaf'
+  let g:terminal_color_6 = '#87afaf'
+  let g:terminal_color_7 = '#d0d0d0'
+  let g:terminal_color_8 = '#626262'
+  let g:terminal_color_9 = '#d75f87'
+  let g:terminal_color_10 = '#87af87'
+  let g:terminal_color_11 = '#ffd787'
+  let g:terminal_color_12 = '#add4fb'
+  let g:terminal_color_13 = '#ffafaf'
+  let g:terminal_color_14 = '#87d7d7'
+  let g:terminal_color_15 = '#e4e4e4'
+else
+  let g:terminal_ansi_colors = [
+    \ '#4e4e4e', '#d68787', '#5f865f', '#d8af5f',
+    \ '#85add4', '#d7afaf', '#87afaf', '#d0d0d0',
+    \ '#626262', '#d75f87', '#87af87', '#ffd787',
+    \ '#add4fb', '#ffafaf', '#87d7d7', '#e4e4e4'
+  \ ]
+endif
+```
 
-#### Starting fzf in a popup window
+### Starting fzf in a popup window
 
 ```vim
 " Required:
@@ -410,6 +450,7 @@ The latest versions of Vim and Neovim include builtin terminal emulator
 " Optional:
 " - xoffset [float default 0.5 range [0 ~ 1]]
 " - yoffset [float default 0.5 range [0 ~ 1]]
+" - relative [boolean default v:false]
 " - border [string default 'rounded']: Border style
 "   - 'rounded' / 'sharp' / 'horizontal' / 'vertical' / 'top' / 'bottom' / 'left' / 'right'
 let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
@@ -427,21 +468,21 @@ else
 endif
 ```
 
-#### Hide statusline
+### 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 a non-popup layout (e.g. `{'down': '40%'}`) on Neovim,
-you might want to temporarily disable the statusline for a cleaner look.
+For example, if you open fzf on the bottom on the screen (e.g. `{'down':
+'40%'}`), you might want to temporarily disable the statusline for a cleaner
+look.
 
 ```vim
-if has('nvim') && !exists('g:fzf_layout')
-  autocmd! FileType fzf
-  autocmd  FileType fzf set laststatus=0 noshowmode noruler
-    \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
-endif
+let g:fzf_layout = { 'down': '30%' }
+autocmd! FileType fzf
+autocmd  FileType fzf set laststatus=0 noshowmode noruler
+  \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
 ```
 
 [License](LICENSE)
@@ -449,4 +490,4 @@ endif
 
 The MIT License (MIT)
 
-Copyright (c) 2013-2021 Junegunn Choi
+Copyright (c) 2013-2024 Junegunn Choi

bin/fzf-preview.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+#
+# The purpose of this script is to demonstrate how to preview a file or an
+# image in the preview window of fzf.
+#
+# Dependencies:
+# - https://github.com/sharkdp/bat
+# - https://github.com/hpjansson/chafa
+# - https://iterm2.com/utilities/imgcat
+
+if [[ $# -ne 1 ]]; then
+  >&2 echo "usage: $0 FILENAME"
+  exit 1
+fi
+
+file=${1/#\~\//$HOME/}
+type=$(file --dereference --mime -- "$file")
+
+if [[ ! $type =~ image/ ]]; then
+  if [[ $type =~ =binary ]]; then
+    file "$1"
+    exit
+  fi
+
+  # Sometimes bat is installed as batcat.
+  if command -v batcat > /dev/null; then
+    batname="batcat"
+  elif command -v bat > /dev/null; then
+    batname="bat"
+  else
+    cat "$1"
+    exit
+  fi
+
+  ${batname} --style="${BAT_STYLE:-numbers}" --color=always --pager=never -- "$file"
+  exit
+fi
+
+dim=${FZF_PREVIEW_COLUMNS}x${FZF_PREVIEW_LINES}
+if [[ $dim = x ]]; then
+  dim=$(stty size < /dev/tty | awk '{print $2 "x" $1}')
+elif ! [[ $KITTY_WINDOW_ID ]] && (( FZF_PREVIEW_TOP + FZF_PREVIEW_LINES == $(stty size < /dev/tty | awk '{print $1}') )); then
+  # Avoid scrolling issue when the Sixel image touches the bottom of the screen
+  # * https://github.com/junegunn/fzf/issues/2544
+  dim=${FZF_PREVIEW_COLUMNS}x$((FZF_PREVIEW_LINES - 1))
+fi
+
+# 1. Use kitty icat on kitty terminal
+if [[ $KITTY_WINDOW_ID ]]; then
+  # 1. 'memory' is the fastest option but if you want the image to be scrollable,
+  #    you have to use 'stream'.
+  #
+  # 2. The last line of the output is the ANSI reset code without newline.
+  #    This confuses fzf and makes it render scroll offset indicator.
+  #    So we remove the last line and append the reset code to its previous line.
+  kitty icat --clear --transfer-mode=memory --unicode-placeholder --stdin=no --place="$dim@0x0" "$file" | sed '$d' | sed $'$s/$/\e[m/'
+
+# 2. Use chafa with Sixel output
+elif command -v chafa > /dev/null; then
+  chafa -f sixel -s "$dim" "$file"
+  # Add a new line character so that fzf can display multiple images in the preview window
+  echo
+
+# 3. If chafa is not found but imgcat is available, use it on iTerm2
+elif command -v imgcat > /dev/null; then
+  # NOTE: We should use https://iterm2.com/utilities/it2check to check if the
+  # user is running iTerm2. But for the sake of simplicity, we just assume
+  # that's the case here.
+  imgcat -W "${dim%%x*}" -H "${dim##*x}" "$file"
+
+# 4. Cannot find any suitable method to preview the image
+else
+  file "$file"
+fi

bin/fzf-tmux

@@ -7,10 +7,9 @@ fail() {
   exit 2
 }
 
-fzf="$(command -v fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
+fzf="$(command which fzf)" || fzf="$(dirname "$0")/fzf"
 [[ -x "$fzf" ]] || fail 'fzf executable not found'
 
-tmux_args=()
 args=()
 opt=""
 skip=""
@@ -58,7 +57,7 @@ while [[ $# -gt 0 ]]; do
       ;;
     -p*|-w*|-h*|-x*|-y*|-d*|-u*|-r*|-l*)
       if [[ "$arg" =~ ^-[pwhxy] ]]; then
-        [[ "$opt" =~ "-K -E" ]] || opt="-K -E"
+        [[ "$opt" =~ "-E" ]] || opt="-E"
       elif [[ "$arg" =~ ^.[lr] ]]; then
         opt="-h"
         if [[ "$arg" =~ ^.l ]]; then
@@ -96,9 +95,9 @@ while [[ $# -gt 0 ]]; do
       elif [[ "$size" =~ %$ ]]; then
         size=${size:0:((${#size}-1))}
         if [[ -n "$swap" ]]; then
-          opt="$opt -p $(( 100 - size ))"
+          opt="$opt -l $(( 100 - size ))%"
         else
-          opt="$opt -p $size"
+          opt="$opt -l $size%"
         fi
       else
         if [[ -n "$swap" ]]; then
@@ -119,8 +118,6 @@ 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
       ;;
     *)
@@ -139,7 +136,7 @@ fi
 args=("${args[@]}" "--no-height" "--bind=ctrl-z:ignore")
 
 # Handle zoomed tmux pane without popup options by moving it to a temp window
-if [[ ! "$opt" =~ "-K -E" ]] && tmux list-panes -F '#F' | grep -q Z; then
+if [[ ! "$opt" =~ "-E" ]] && tmux list-panes -F '#F' | grep -q Z; then
   zoomed_without_popup=1
   original_window=$(tmux display-message -p "#{window_id}")
   tmp_window=$(tmux new-window -d -P -F "#{window_id}" "bash -c 'while :; do for c in \\| / - '\\;' do sleep 0.2; printf \"\\r\$c fzf-tmux is running\\r\"; done; done'")
@@ -154,12 +151,18 @@ 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/$/ \\;/') )
+if tmux_win_opts=$(tmux show-options -p remain-on-exit \; show-options -p synchronize-panes 2> /dev/null); then
+  tmux_win_opts=( $(sed '/ off/d; s/synchronize-panes/set-option -p synchronize-panes/; s/remain-on-exit/set-option -p remain-on-exit/; s/$/ \\;/' <<< "$tmux_win_opts") )
+  tmux_off_opts='; set-option -p synchronize-panes off ; set-option -p remain-on-exit off'
+else
+  tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
+  tmux_off_opts='; set-window-option synchronize-panes off ; set-window-option remain-on-exit off'
+fi
 cleanup() {
   \rm -f $argsf $fifo1 $fifo2 $fifo3
 
   # Restore tmux window options
-  if [[ "${#tmux_win_opts[@]}" -gt 0 ]]; then
+  if [[ "${#tmux_win_opts[@]}" -gt 1 ]]; then
     eval "tmux ${tmux_win_opts[*]}"
   fi
 
@@ -172,7 +175,7 @@ cleanup() {
       resize-pane -Z
   fi
 
-  if [ $# -gt 0 ]; then
+  if [[ $# -gt 0 ]]; then
     trap - EXIT
     exit 130
   fi
@@ -181,9 +184,23 @@ trap 'cleanup 1' SIGUSR1
 trap 'cleanup' EXIT
 
 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")"
+if [[ "$opt" =~ "-E" ]]; then
+  tmux_version=$(tmux -V | sed 's/[^0-9.]//g')
+  if [[ $(awk '{print ($1 > 3.2)}' <<< "$tmux_version" 2> /dev/null || bc -l <<< "$tmux_version > 3.2") = 1 ]]; then
+    FZF_DEFAULT_OPTS="--border $FZF_DEFAULT_OPTS"
+    opt="-B $opt"
+  elif [[ $tmux_version = 3.2 ]]; then
+    FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
+  else
+    echo "fzf-tmux: tmux 3.2 or above is required for popup mode" >&2
+    exit 2
+  fi
+fi
+envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
+envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
+envs="$envs FZF_DEFAULT_OPTS_FILE=$(printf %q "$FZF_DEFAULT_OPTS_FILE")"
+[[ -n "$RUNEWIDTH_EASTASIAN" ]] && envs="$envs RUNEWIDTH_EASTASIAN=$(printf %q "$RUNEWIDTH_EASTASIAN")"
+[[ -n "$BAT_THEME" ]] && envs="$envs BAT_THEME=$(printf %q "$BAT_THEME")"
 echo "$envs;" > "$argsf"
 
 # Build arguments to fzf
@@ -195,7 +212,7 @@ close="; trap - EXIT SIGINT SIGTERM $close"
 
 export TMUX=$(cut -d , -f 1,2 <<< "$TMUX")
 mkfifo -m o+w $fifo2
-if [[ "$opt" =~ "-K -E" ]]; then
+if [[ "$opt" =~ "-E" ]]; then
   cat $fifo2 &
   if [[ -n "$term" ]] || [[ -t 0 ]]; then
     cat <<< "\"$fzf\" $opts > $fifo2; out=\$? $close; exit \$out" >> $argsf
@@ -205,15 +222,7 @@ if [[ "$opt" =~ "-K -E" ]]; then
     cat <&0 > $fifo1 &
   fi
 
-  # tmux dropped the support for `-K`, `-R` to popup command
-  #   TODO: We can remove this once tmux 3.2 is released
-  if [[ ! "$(tmux popup --help 2>&1)" =~ '-R shell-command' ]]; then
-    opt="${opt/-K/}"
-  else
-    opt="${opt} -R"
-  fi
-
-  tmux popup -d "$PWD" "${tmux_args[@]}" $opt "bash $argsf" > /dev/null 2>&1
+  tmux popup -d "$PWD" $opt "bash $argsf" > /dev/null 2>&1
   exit $?
 fi
 
@@ -225,9 +234,9 @@ else
   cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" >> $argsf
   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 \
+tmux \
+  split-window -c "$PWD" $opt "bash -c 'exec -a fzf bash $argsf'" $swap \
+  $tmux_off_opts \
   > /dev/null 2>&1 || { "$fzf" "${args[@]}"; exit $?; }
 cat $fifo2
 exit "$(cat $fifo3)"

doc/fzf.txt

@@ -1,4 +1,4 @@
-fzf.txt	fzf	Last change: January 3 2021
+fzf.txt	fzf	Last change: February 15 2024
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================
 
@@ -14,8 +14,8 @@ FZF - TABLE OF CONTENTS                                            *fzf* *fzf-to
       Global options supported by fzf#wrap  |fzf-global-options-supported-by-fzf#wrap|
     Tips                                    |fzf-tips|
       fzf inside terminal buffer            |fzf-inside-terminal-buffer|
-        Starting fzf in a popup window      |fzf-starting-fzf-in-a-popup-window|
-        Hide statusline                     |fzf-hide-statusline|
+      Starting fzf in a popup window        |fzf-starting-fzf-in-a-popup-window|
+      Hide statusline                       |fzf-hide-statusline|
     License                                 |fzf-license|
 
 FZF VIM INTEGRATION                                        *fzf-vim-integration*
@@ -32,7 +32,10 @@ depending on the package manager.
     " If installed using Homebrew
     set rtp+=/usr/local/opt/fzf
 
-    " If installed using git
+    " If installed using Homebrew on Apple Silicon
+    set rtp+=/opt/homebrew/opt/fzf
+
+    " If you have cloned fzf on ~/.fzf directory
     set rtp+=~/.fzf
 <
 If you use {vim-plug}{1}, the same can be written as:
@@ -40,7 +43,10 @@ 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
+    " If installed using Homebrew on Apple Silicon
+    Plug '/opt/homebrew/opt/fzf'
+
+    " If you have cloned fzf on ~/.fzf directory
     Plug '~/.fzf'
 <
 But if you want the latest Vim plugin file from GitHub rather than the one
@@ -68,16 +74,16 @@ SUMMARY                                                            *fzf-summary*
 The Vim plugin of fzf provides two core functions, and `:FZF` command which is
 the basic file selector command built on top of them.
 
- 1. `fzf#run([spec dict])`
+ 1. `fzf#run([spec dict])`
    - Starts fzf inside Vim with the given spec
-   - `:call fzf#run({'source': 'ls'})`
- 2. `fzf#wrap([spec dict]) -> (dict)`
+   - `:call fzf#run({'source': 'ls'})`
+ 2. `fzf#wrap([spec dict]) -> (dict)`
    - Takes a spec for `fzf#run` and returns an extended version of it with
      additional options for addressing global preferences (`g:fzf_xxx`)
-     - `:echo fzf#wrap({'source': 'ls'})`
+     - `:echo fzf#wrap({'source': 'ls'})`
    - We usually wrap a spec with `fzf#wrap` before passing it to `fzf#run`
-     - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
- 3. `:FZF [fzf_options string] [path string]`
+     - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
+ 3. `:FZF [fzf_options string] [path string]`
    - Basic fuzzy file selector
    - A reference implementation for those who don't want to write VimScript to
      implement custom commands
@@ -143,7 +149,7 @@ Examples~
 
     " An action can be a reference to a function that processes selected lines
     function! s:build_quickfix_list(lines)
-      call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
+      call setqflist(map(copy(a:lines), '{ "filename": v:val, "lnum": 1 }'))
       copen
       cc
     endfunction
@@ -155,9 +161,15 @@ Examples~
       \ 'ctrl-v': 'vsplit' }
 
     " Default fzf layout
-    " - Popup window
+    " - Popup window (center of the screen)
     let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 
+    " - Popup window (center of the current window)
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true } }
+
+    " - Popup window (anchored to the bottom of the current window)
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true, 'yoffset': 1.0 } }
+
     " - down / up / left / right
     let g:fzf_layout = { 'down': '40%' }
 
@@ -216,12 +228,12 @@ list:
   `spinner`                    | Streaming input indicator
   `query`                      | Query string
   `disabled`                   | Query string when search is disabled
-  `prompt`                     | Prompt before query ( `> ` )
+  `prompt`                     | Prompt before query ( `> ` )
   `pointer`                    | Pointer to the current line ( `>` )
  ----------------------------+------------------------------------------------------
  - `component` specifies the component (`fg` / `bg`) from which to extract the
    color when considering each of the following highlight groups
- - `group1 [, group2, ...]` is a list of highlight groups that are searched (in
+ - `group1 [, group2, ...]` is a list of highlight groups that are searched (in
    order) for a matching color definition
 
 For example, consider the following specification:
@@ -252,17 +264,18 @@ entry.
     call fzf#run({'sink': 'e'})
 <
 We haven't specified the `source`, so this is equivalent to starting fzf on
-command line without standard input pipe; fzf will use find command (or
-`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
-directory. When you select one, it will open it with the sink, `:e` command.
-If you want to open it in a new tab, you can pass `:tabedit` command instead
-as the sink.
+command line without standard input pipe; fzf will traverse the file system
+under the current directory to get the list of files. (If
+`$FZF_DEFAULT_COMMAND` is set, fzf will use the output of the command
+instead.) When you select one, it will open it with the sink, `:e` command. If
+you want to open it in a new tab, you can pass `:tabedit` command instead as
+the sink.
 >
     call fzf#run({'sink': 'tabedit'})
 <
-Instead of using the default find command, you can use any shell command as
-the source. The following example will list the files managed by git. It's
-equivalent to running `git ls-files | fzf` on shell.
+You can use any shell command as the source to generate the list. The
+following example will list the files managed by git. It's equivalent to
+running `git ls-files | fzf` on shell.
 >
     call fzf#run({'source': 'git ls-files', 'sink': 'e'})
 <
@@ -290,17 +303,17 @@ The following table summarizes the available options.
  ---------------------------+---------------+----------------------------------------------------------------------
  Option name                | Type          | Description                                                          ~
  ---------------------------+---------------+----------------------------------------------------------------------
-  `source`                    | string        | External command to generate input to fzf (e.g.  `find .` )
+  `source`                    | string        | External command to generate input to fzf (e.g.  `find .` )
   `source`                    | list          | Vim list as input to fzf
   `sink`                      | string        | Vim command to handle the selected item (e.g.  `e` ,  `tabe` )
   `sink`                      | funcref       | Reference to function to process each selected item
-  `sink*`                     | funcref       | Similar to  `sink` , but takes the list of output lines at once
+  `sinklist`  (or  `sink*` )    | funcref       | Similar to  `sink` , but takes the list of output lines at once
   `options`                   | string/list   | Options to fzf
   `dir`                       | string        | Working directory
   `up` / `down` / `left` / `right`  | number/string | (Layout) Window position and size (e.g.  `20` ,  `50%` )
   `tmux`                      | string        | (Layout) fzf-tmux options (e.g.  `-p90%,60%` )
-  `window`  (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g.  `vertical aboveleft 30new` )
-  `window`  (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g.  `{'width': 0.9, 'height': 0.6}` )
+  `window`  (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g.  `vertical aboveleft 30new` )
+  `window`  (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g.  `{'width': 0.9, 'height': 0.6}` )
  ---------------------------+---------------+----------------------------------------------------------------------
 
 `options` entry can be either a string or a list. For simple cases, string
@@ -318,7 +331,8 @@ following options are allowed:
  - Optional:
    - `yoffset` [float default 0.5 range [0 ~ 1]]
    - `xoffset` [float default 0.5 range [0 ~ 1]]
-   - `border` [string default `rounded`]: Border style
+   - `relative` [boolean default v:false]
+   - `border` [string default `rounded` (`sharp` on Windows)]: Border style
      - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right` / `no[ne]`
 
 
@@ -336,7 +350,7 @@ So how can we make our custom `fzf#run` calls also respect those variables?
 Simply by "wrapping" the spec dictionary with `fzf#wrap` before passing it to
 `fzf#run`.
 
- - `fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`
+ - `fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`
    - All arguments are optional. Usually we only need to pass a spec
      dictionary.
    - `name` is for managing history files. It is ignored if `g:fzf_history_dir`
@@ -370,9 +384,9 @@ last `fullscreen` argument of `fzf#wrap` (see :help <bang>).
     command! -bang LS call fzf#run(fzf#wrap({'source': 'ls'}, <bang>0))
 <
 Our `:LS` command will be much more useful if we can pass a directory argument
-to it, so that something like `:LS /tmp` is possible.
+to it, so that something like `:LS /tmp` is possible.
 >
-    command! -bang -complete=dir -nargs=* LS
+    command! -bang -complete=dir -nargs=? LS
         \ call fzf#run(fzf#wrap({'source': 'ls', 'dir': <q-args>}, <bang>0))
 <
 Lastly, if you have enabled `g:fzf_history_dir`, you might want to assign a
@@ -380,7 +394,7 @@ unique name to our command and pass it as the first argument to `fzf#wrap`.
 >
     " The query history for this command will be stored as 'ls' inside g:fzf_history_dir.
     " The name is ignored if g:fzf_history_dir is not defined.
-    command! -bang -complete=dir -nargs=* LS
+    command! -bang -complete=dir -nargs=? LS
         \ call fzf#run(fzf#wrap('ls', {'source': 'ls', 'dir': <q-args>}, <bang>0))
 <
 
@@ -389,10 +403,10 @@ unique name to our command and pass it as the first argument to `fzf#wrap`.
 
  - `g:fzf_layout`
  - `g:fzf_action`
-   - Works only when no custom `sink` (or `sink*`) is provided
+   - Works only when no custom `sink` (or `sinklist`) is provided
      - Having custom sink usually means that each entry is not an ordinary
        file path (e.g. name of color scheme), so we can't blindly apply the
-       same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
+       same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
  - `g:fzf_colors`
  - `g:fzf_history_dir`
 
@@ -404,16 +418,42 @@ TIPS                                                                  *fzf-tips*
 < fzf inside terminal buffer >________________________________________________~
                                                     *fzf-inside-terminal-buffer*
 
-The latest versions of Vim and Neovim include builtin terminal emulator
-(`:terminal`) and fzf will start in a terminal buffer in the following cases:
 
- - On Neovim
- - On GVim
- - On Terminal Vim with a non-default layout
-   - `call fzf#run({'left': '30%'})` or `let g:fzf_layout = {'left': '30%'}`
+On the latest versions of Vim and Neovim, fzf will start in a terminal buffer.
+If you find the default ANSI colors to be different, consider configuring the
+colors using `g:terminal_ansi_colors` in regular Vim or `g:terminal_color_x`
+in Neovim.
 
+>
+    " Terminal colors for seoul256 color scheme
+    if has('nvim')
+      let g:terminal_color_0 = '#4e4e4e'
+      let g:terminal_color_1 = '#d68787'
+      let g:terminal_color_2 = '#5f865f'
+      let g:terminal_color_3 = '#d8af5f'
+      let g:terminal_color_4 = '#85add4'
+      let g:terminal_color_5 = '#d7afaf'
+      let g:terminal_color_6 = '#87afaf'
+      let g:terminal_color_7 = '#d0d0d0'
+      let g:terminal_color_8 = '#626262'
+      let g:terminal_color_9 = '#d75f87'
+      let g:terminal_color_10 = '#87af87'
+      let g:terminal_color_11 = '#ffd787'
+      let g:terminal_color_12 = '#add4fb'
+      let g:terminal_color_13 = '#ffafaf'
+      let g:terminal_color_14 = '#87d7d7'
+      let g:terminal_color_15 = '#e4e4e4'
+    else
+      let g:terminal_ansi_colors = [
+        \ '#4e4e4e', '#d68787', '#5f865f', '#d8af5f',
+        \ '#85add4', '#d7afaf', '#87afaf', '#d0d0d0',
+        \ '#626262', '#d75f87', '#87af87', '#ffd787',
+        \ '#add4fb', '#ffafaf', '#87d7d7', '#e4e4e4'
+      \ ]
+    endif
+<
 
-Starting fzf in a popup window~
+< Starting fzf in a popup window >____________________________________________~
                                             *fzf-starting-fzf-in-a-popup-window*
 >
     " Required:
@@ -423,6 +463,7 @@ Starting fzf in a popup window~
     " Optional:
     " - xoffset [float default 0.5 range [0 ~ 1]]
     " - yoffset [float default 0.5 range [0 ~ 1]]
+    " - relative [boolean default v:false]
     " - border [string default 'rounded']: Border style
     "   - 'rounded' / 'sharp' / 'horizontal' / 'vertical' / 'top' / 'bottom' / 'left' / 'right'
     let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
@@ -438,21 +479,21 @@ or above) by putting fzf-tmux options in `tmux` key.
     endif
 <
 
-Hide statusline~
+< Hide statusline >___________________________________________________________~
                                                            *fzf-hide-statusline*
 
 When fzf starts in a terminal buffer, the file type of the buffer is set to
-`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
+`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
 the window.
 
-For example, if you use a non-popup layout (e.g. `{'down': '40%'}`) on Neovim,
-you might want to temporarily disable the statusline for a cleaner look.
+For example, if you open fzf on the bottom on the screen (e.g. `{'down':
+'40%'}`), you might want to temporarily disable the statusline for a cleaner
+look.
 >
-    if has('nvim') && !exists('g:fzf_layout')
-      autocmd! FileType fzf
-      autocmd  FileType fzf set laststatus=0 noshowmode noruler
-        \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
-    endif
+    let g:fzf_layout = { 'down': '30%' }
+    autocmd! FileType fzf
+    autocmd  FileType fzf set laststatus=0 noshowmode noruler
+      \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
 <
 
 LICENSE                                                            *fzf-license*
@@ -460,7 +501,7 @@ LICENSE                                                            *fzf-license*
 
 The MIT License (MIT)
 
-Copyright (c) 2013-2021 Junegunn Choi
+Copyright (c) 2013-2024 Junegunn Choi
 
 ==============================================================================
 vim:tw=78:sw=2:ts=2:ft=help:norl:nowrap:

go.mod

@@ -1,17 +1,20 @@
 module github.com/junegunn/fzf
 
 require (
-	github.com/gdamore/tcell v1.4.0
-	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/mattn/go-isatty v0.0.12
-	github.com/mattn/go-runewidth v0.0.12
-	github.com/mattn/go-shellwords v1.0.11
-	github.com/rivo/uniseg v0.2.0 // indirect
-	github.com/saracen/walker v0.1.2
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
-	golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57
-	golang.org/x/term v0.0.0-20210317153231-de623e64d2a6
-	golang.org/x/text v0.3.6 // indirect
+	github.com/charlievieth/fastwalk v1.0.3
+	github.com/gdamore/tcell/v2 v2.7.4
+	github.com/mattn/go-isatty v0.0.20
+	github.com/mattn/go-shellwords v1.0.12
+	github.com/rivo/uniseg v0.4.7
+	golang.org/x/sys v0.19.0
+	golang.org/x/term v0.19.0
 )
 
-go 1.13
+require (
+	github.com/gdamore/encoding v1.0.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // indirect
+	golang.org/x/text v0.14.0 // indirect
+)
+
+go 1.20

go.sum

@@ -1,33 +1,57 @@
+github.com/charlievieth/fastwalk v1.0.3 h1:eNWFaNPe5srPqQ5yyDbhAf11paeZaHWcihRhpuYFfSg=
+github.com/charlievieth/fastwalk v1.0.3/go.mod h1:JSfglY/gmL/rqsUS1NCsJTocB5n6sSl9ApAqif4CUbs=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
-github.com/gdamore/tcell v1.4.0 h1:vUnHwJRvcPQa3tzi+0QI4U9JINXYJlOz9yiaiPQ2wMU=
-github.com/gdamore/tcell v1.4.0/go.mod h1:vxEiSDZdW3L+Uhjii9c3375IlDmR05bzxY404ZVSMo0=
-github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/gdamore/tcell/v2 v2.7.4 h1:sg6/UnTM9jGpZU+oFYAsDahfchWAFW8Xx2yFinNSAYU=
+github.com/gdamore/tcell/v2 v2.7.4/go.mod h1:dSXtXTSK0VsW1biw65DZLZ2NKr7j0qP/0J7ONmsraWg=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-runewidth v0.0.12 h1:Y41i/hVW3Pgwr8gV+J23B9YEY0zxjptBuCWEaxmAOow=
-github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
-github.com/mattn/go-shellwords v1.0.11 h1:vCoR9VPpsk/TZFW2JwK5I9S0xdrtUq2bph6/YjEPnaw=
-github.com/mattn/go-shellwords v1.0.11/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-shellwords v1.0.12 h1:M2zGm7EW6UQJvDeQxo4T51eKPurbeFbe8WtebGE2xrk=
+github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/saracen/walker v0.1.2 h1:/o1TxP82n8thLvmL4GpJXduYaRmJ7qXp8u9dSlV0zmo=
-github.com/saracen/walker v0.1.2/go.mod h1:0oKYMsKVhSJ+ful4p/XbjvXbMgLEkLITZaxozsl4CGE=
-golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/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-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 h1:F5Gozwx4I1xtr/sr/8CFbb57iKi3297KFs0QDbGN60A=
-golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/term v0.0.0-20210317153231-de623e64d2a6 h1:EC6+IGYTjPpRfv9a2b/6Puw0W+hLtAhkV1tPsXhutqs=
-golang.org/x/term v0.0.0-20210317153231-de623e64d2a6/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
+golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
+golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

install

@@ -2,7 +2,7 @@
 
 set -u
 
-version=0.27.0
+version=0.50.0
 auto_completion=
 key_bindings=
 update_config=2
@@ -168,21 +168,24 @@ archi=$(uname -sm)
 binary_available=1
 binary_error=""
 case "$archi" in
-  Darwin\ arm64)   download fzf-$version-darwin_arm64.zip     ;;
-  Darwin\ x86_64)  download fzf-$version-darwin_amd64.zip     ;;
-  Linux\ armv5*)   download fzf-$version-linux_armv5.tar.gz   ;;
-  Linux\ armv6*)   download fzf-$version-linux_armv6.tar.gz   ;;
-  Linux\ armv7*)   download fzf-$version-linux_armv7.tar.gz   ;;
-  Linux\ armv8*)   download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ aarch64*) download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ *64)      download fzf-$version-linux_amd64.tar.gz   ;;
-  FreeBSD\ *64)    download fzf-$version-freebsd_amd64.tar.gz ;;
-  OpenBSD\ *64)    download fzf-$version-openbsd_amd64.tar.gz ;;
-  CYGWIN*\ *64)    download fzf-$version-windows_amd64.zip    ;;
-  MINGW*\ *64)     download fzf-$version-windows_amd64.zip    ;;
-  MSYS*\ *64)      download fzf-$version-windows_amd64.zip    ;;
-  Windows*\ *64)   download fzf-$version-windows_amd64.zip    ;;
-  *)               binary_available=0 binary_error=1 ;;
+  Darwin\ arm64)      download fzf-$version-darwin_arm64.zip     ;;
+  Darwin\ x86_64)     download fzf-$version-darwin_amd64.zip     ;;
+  Linux\ armv5*)      download fzf-$version-linux_armv5.tar.gz   ;;
+  Linux\ armv6*)      download fzf-$version-linux_armv6.tar.gz   ;;
+  Linux\ armv7*)      download fzf-$version-linux_armv7.tar.gz   ;;
+  Linux\ armv8*)      download fzf-$version-linux_arm64.tar.gz   ;;
+  Linux\ aarch64*)    download fzf-$version-linux_arm64.tar.gz   ;;
+  Linux\ loongarch64) download fzf-$version-linux_loong64.tar.gz ;;
+  Linux\ ppc64le)     download fzf-$version-linux_ppc64le.tar.gz ;;
+  Linux\ *64)         download fzf-$version-linux_amd64.tar.gz   ;;
+  Linux\ s390x)       download fzf-$version-linux_s390x.tar.gz   ;;
+  FreeBSD\ *64)       download fzf-$version-freebsd_amd64.tar.gz ;;
+  OpenBSD\ *64)       download fzf-$version-openbsd_amd64.tar.gz ;;
+  CYGWIN*\ *64)       download fzf-$version-windows_amd64.zip    ;;
+  MINGW*\ *64)        download fzf-$version-windows_amd64.zip    ;;
+  MSYS*\ *64)         download fzf-$version-windows_amd64.zip    ;;
+  Windows*\ *64)      download fzf-$version-windows_amd64.zip    ;;
+  *)                  binary_available=0 binary_error=1          ;;
 esac
 
 cd "$fzf_base"
@@ -193,12 +196,12 @@ if [ -n "$binary_error" ]; then
     echo "  - $binary_error !!!"
   fi
   if command -v go > /dev/null; then
-    echo -n "Building binary (go get -u github.com/junegunn/fzf) ... "
+    echo -n "Building binary (go install github.com/junegunn/fzf) ... "
     if [ -z "${GOPATH-}" ]; then
       export GOPATH="${TMPDIR:-/tmp}/fzf-gopath"
       mkdir -p "$GOPATH"
     fi
-    if go get -ldflags "-s -w -X main.version=$version -X main.revision=go-get" github.com/junegunn/fzf; then
+    if go install -ldflags "-s -w -X main.version=$version -X main.revision=go-install" github.com/junegunn/fzf; then
       echo "OK"
       cp "$GOPATH/bin/fzf" "$fzf_base/bin/"
     else
@@ -242,7 +245,7 @@ for shell in $shells; do
   src=${prefix_expand}.${shell}
   echo -n "Generate $src ... "
 
-  fzf_completion="[[ \$- == *i* ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
+  fzf_completion="source \"$fzf_base/shell/completion.${shell}\""
   if [ $auto_completion -eq 0 ]; then
     fzf_completion="# $fzf_completion"
   fi
@@ -256,9 +259,15 @@ for shell in $shells; do
 # Setup fzf
 # ---------
 if [[ ! "\$PATH" == *$fzf_base_esc/bin* ]]; then
-  export PATH="\${PATH:+\${PATH}:}$fzf_base/bin"
+  PATH="\${PATH:+\${PATH}:}$fzf_base/bin"
 fi
 
+EOF
+
+  if [[ $auto_completion -eq 1 ]] && [[ $key_bindings -eq 1 ]]; then
+    echo "eval \"\$(fzf --$shell)\"" >> "$src"
+  else
+    cat >> "$src" << EOF
 # Auto-completion
 # ---------------
 $fzf_completion
@@ -267,6 +276,7 @@ $fzf_completion
 # ------------
 $fzf_key_bindings
 EOF
+  fi
   echo "OK"
 done
 
@@ -278,23 +288,6 @@ if [[ "$shells" =~ fish ]]; then
   or set --universal fish_user_paths \$fish_user_paths "$fzf_base"/bin
 EOF
   [ $? -eq 0 ] && echo "OK" || echo "Failed"
-
-  mkdir -p "${fish_dir}/functions"
-  if [ -e "${fish_dir}/functions/fzf.fish" ]; then
-    echo -n "Remove unnecessary ${fish_dir}/functions/fzf.fish ... "
-    rm -f "${fish_dir}/functions/fzf.fish" && echo "OK" || echo "Failed"
-  fi
-
-  fish_binding="${fish_dir}/functions/fzf_key_bindings.fish"
-  if [ $key_bindings -ne 0 ]; then
-    echo -n "Symlink $fish_binding ... "
-    ln -sf "$fzf_base/shell/key-bindings.fish" \
-           "$fish_binding" && echo "OK" || echo "Failed"
-  else
-    echo -n "Removing $fish_binding ... "
-    rm -f "$fish_binding"
-    echo "OK"
-  fi
 fi
 
 append_line() {
@@ -357,12 +350,23 @@ done
 if [ $key_bindings -eq 1 ] && [[ "$shells" =~ fish ]]; then
   bind_file="${fish_dir}/functions/fish_user_key_bindings.fish"
   if [ ! -e "$bind_file" ]; then
+    mkdir -p "${fish_dir}/functions"
     create_file "$bind_file" \
       'function fish_user_key_bindings' \
-      '  fzf_key_bindings' \
+      '  fzf --fish | source' \
       'end'
   else
-    append_line $update_config "fzf_key_bindings" "$bind_file"
+    echo "Check $bind_file:"
+    lno=$(\grep -nF "fzf_key_bindings" "$bind_file" | sed 's/:.*//' | tr '\n' ' ')
+    if [[ -n $lno ]]; then
+      echo "  ** Found 'fzf_key_bindings' in line #$lno"
+      echo "  ** You have to replace the line to 'fzf --fish | source'"
+      echo
+    else
+      echo "  - Clear"
+      echo
+      append_line $update_config "fzf --fish | source" "$bind_file"
+    fi
   fi
 fi
 

install.ps1

@@ -1,4 +1,4 @@
-$version="0.27.0"
+$version="0.50.0"
 
 $fzf_base=Split-Path -Parent $MyInvocation.MyCommand.Definition
 

main.go

@@ -1,14 +1,55 @@
 package main
 
 import (
-	"github.com/junegunn/fzf/src"
+	_ "embed"
+	"fmt"
+	"strings"
+
+	fzf "github.com/junegunn/fzf/src"
 	"github.com/junegunn/fzf/src/protector"
 )
 
-var version string = "0.27"
+var version string = "0.50"
 var revision string = "devel"
 
+//go:embed shell/key-bindings.bash
+var bashKeyBindings []byte
+
+//go:embed shell/completion.bash
+var bashCompletion []byte
+
+//go:embed shell/key-bindings.zsh
+var zshKeyBindings []byte
+
+//go:embed shell/completion.zsh
+var zshCompletion []byte
+
+//go:embed shell/key-bindings.fish
+var fishKeyBindings []byte
+
+func printScript(label string, content []byte) {
+	fmt.Println("### " + label + " ###")
+	fmt.Println(strings.TrimSpace(string(content)))
+	fmt.Println("### end: " + label + " ###")
+}
+
 func main() {
 	protector.Protect()
-	fzf.Run(fzf.ParseOptions(), version, revision)
+	options := fzf.ParseOptions()
+	if options.Bash {
+		printScript("key-bindings.bash", bashKeyBindings)
+		printScript("completion.bash", bashCompletion)
+		return
+	}
+	if options.Zsh {
+		printScript("key-bindings.zsh", zshKeyBindings)
+		printScript("completion.zsh", zshCompletion)
+		return
+	}
+	if options.Fish {
+		printScript("key-bindings.fish", fishKeyBindings)
+		fmt.Println("fzf_key_bindings")
+		return
+	}
+	fzf.Run(options, version, revision)
 }

main_test.go

@@ -0,0 +1,158 @@
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func loadPackages(t *testing.T) []*build.Package {
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var pkgs []*build.Package
+	seen := make(map[string]bool)
+	err = filepath.WalkDir(wd, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		name := d.Name()
+		if d.IsDir() {
+			if name == "" || name[0] == '.' || name[0] == '_' || name == "vendor" || name == "tmp" {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if d.Type().IsRegular() && filepath.Ext(name) == ".go" && !strings.HasSuffix(name, "_test.go") {
+			dir := filepath.Dir(path)
+			if !seen[dir] {
+				pkg, err := build.ImportDir(dir, build.ImportComment)
+				if err != nil {
+					return fmt.Errorf("%s: %s", dir, err)
+				}
+				if pkg.ImportPath == "" || pkg.ImportPath == "." {
+					importPath, err := filepath.Rel(wd, dir)
+					if err != nil {
+						t.Fatal(err)
+					}
+					pkg.ImportPath = filepath.ToSlash(filepath.Join("github.com/junegunn/fzf", importPath))
+				}
+
+				pkgs = append(pkgs, pkg)
+				seen[dir] = true
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	sort.Slice(pkgs, func(i, j int) bool {
+		return pkgs[i].ImportPath < pkgs[j].ImportPath
+	})
+	return pkgs
+}
+
+var sourceImporter = importer.ForCompiler(token.NewFileSet(), "source", nil)
+
+func checkPackageForOsExit(t *testing.T, bpkg *build.Package, allowed map[string]int) (errOsExit bool) {
+	var files []*ast.File
+	fset := token.NewFileSet()
+	for _, name := range bpkg.GoFiles {
+		filename := filepath.Join(bpkg.Dir, name)
+		af, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		files = append(files, af)
+	}
+
+	info := types.Info{
+		Uses: make(map[*ast.Ident]types.Object),
+	}
+	conf := types.Config{
+		Importer: sourceImporter,
+	}
+	_, err := conf.Check(bpkg.Name, fset, files, &info)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for id, obj := range info.Uses {
+		if obj.Pkg() != nil && obj.Pkg().Name() == "os" && obj.Name() == "Exit" {
+			pos := fset.Position(id.Pos())
+
+			name, err := filepath.Rel(wd, pos.Filename)
+			if err != nil {
+				t.Log(err)
+				name = pos.Filename
+			}
+			name = filepath.ToSlash(name)
+
+			// Check if the usage is allowed
+			if allowed[name] > 0 {
+				allowed[name]--
+				continue
+			}
+
+			t.Errorf("os.Exit referenced at: %s:%d:%d", name, pos.Line, pos.Column)
+			errOsExit = true
+		}
+	}
+	return errOsExit
+}
+
+// Enforce that src/util.Exit() is used instead of os.Exit by prohibiting
+// references to it anywhere else in the fzf code base.
+func TestOSExitNotAllowed(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping: short test")
+	}
+	allowed := map[string]int{
+		"src/util/atexit.go": 1, // os.Exit allowed 1 time in "atexit.go"
+	}
+	var errOsExit bool
+	for _, pkg := range loadPackages(t) {
+		t.Run(pkg.ImportPath, func(t *testing.T) {
+			if checkPackageForOsExit(t, pkg, allowed) {
+				errOsExit = true
+			}
+		})
+	}
+	if t.Failed() && errOsExit {
+		var names []string
+		for name := range allowed {
+			names = append(names, fmt.Sprintf("%q", name))
+		}
+		sort.Strings(names)
+
+		const errMsg = `
+Test failed because os.Exit was referenced outside of the following files:
+
+    %s
+
+Use github.com/junegunn/fzf/src/util.Exit() instead to exit the program.
+This is enforced because calling os.Exit() prevents the functions
+registered with util.AtExit() from running.`
+
+		t.Errorf(errMsg, strings.Join(names, "\n    "))
+	}
+}

man/man1/fzf-tmux.1

@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)
 
-Copyright (c) 2013-2021 Junegunn Choi
+Copyright (c) 2013-2024 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf-tmux 1 "Apr 2021" "fzf 0.27.0" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Apr 2024" "fzf 0.50.0" "fzf-tmux - open fzf in tmux split pane"
 
 .SH NAME
 fzf-tmux - open fzf in tmux split pane

plugin/fzf.vim

@@ -1,4 +1,4 @@
-" Copyright (c) 2017 Junegunn Choi
+" Copyright (c) 2013-2024 Junegunn Choi
 "
 " MIT License
 "
@@ -96,7 +96,12 @@ function! fzf#shellescape(arg, ...)
   if shell =~# 'cmd.exe$'
     return s:shellesc_cmd(a:arg)
   endif
-  return s:fzf_call('shellescape', a:arg)
+  try
+    let [shell, &shell] = [&shell, shell]
+    return s:fzf_call('shellescape', a:arg)
+  finally
+    let [shell, &shell] = [&shell, shell]
+  endtry
 endfunction
 
 function! s:fzf_getcwd()
@@ -138,7 +143,7 @@ function! fzf#install()
     if !filereadable(script)
       throw script.' not found'
     endif
-    let script = 'powershell -ExecutionPolicy Bypass -file ' . script
+    let script = 'powershell -ExecutionPolicy Bypass -file ' . shellescape(script)
   else
     let script = s:base_dir.'/install'
     if !executable(script)
@@ -159,7 +164,7 @@ function s:get_version(bin)
   if has_key(s:versions, a:bin)
     return s:versions[a:bin]
   end
-  let command = a:bin . ' --version'
+  let command = (&shell =~ 'powershell\|pwsh' ? '&' : '') . s:fzf_call('shellescape', a:bin) . ' --version --no-height'
   let output = systemlist(command)
   if v:shell_error || empty(output)
     return ''
@@ -337,7 +342,8 @@ function! s:common_sink(action, lines) abort
 endfunction
 
 function! s:get_color(attr, ...)
-  let gui = !s:is_win && !has('win32unix') && has('termguicolors') && &termguicolors
+  " Force 24 bit colors: g:fzf_force_termguicolors (temporary workaround for https://github.com/junegunn/fzf.vim/issues/1152)
+  let gui = get(g:, 'fzf_force_termguicolors', 0) || (!s:is_win && !has('win32unix') && has('termguicolors') && &termguicolors)
   let fam = gui ? 'gui' : 'cterm'
   let pat = gui ? '^#[a-f0-9]\+' : '^[0-9]\+$'
   for group in a:000
@@ -419,13 +425,13 @@ function! fzf#wrap(...)
   endif
 
   " Action: g:fzf_action
-  if !s:has_any(opts, ['sink', 'sink*'])
+  if !s:has_any(opts, ['sink', 'sinklist', 'sink*'])
     let opts._action = get(g:, 'fzf_action', s:default_action)
     let opts.options .= ' --expect='.join(keys(opts._action), ',')
-    function! opts.sink(lines) abort
+    function! opts.sinklist(lines) abort
       return s:common_sink(self._action, a:lines)
     endfunction
-    let opts['sink*'] = remove(opts, 'sink')
+    let opts['sink*'] = opts.sinklist " For backward compatibility
   endif
 
   return opts
@@ -444,6 +450,36 @@ function! s:use_sh()
   return [shell, shellslash, shellcmdflag, shellxquote]
 endfunction
 
+function! s:writefile(...)
+  if call('writefile', a:000) == -1
+    throw 'Failed to write temporary file. Check if you can write to the path tempname() returns.'
+  endif
+endfunction
+
+function! s:extract_option(opts, name)
+  let opt = ''
+  let expect = 0
+  " There are a few cases where this function doesn't work as expected.
+  " Let's just assume such cases are extremely unlikely in real world.
+  "   e.g. --query --border
+  for word in split(a:opts)
+    if expect && word !~ '^"\=-'
+      let opt = opt . ' ' . word
+      let expect = 0
+    elseif word == '--no-'.a:name
+      let opt = ''
+    elseif word =~ '^--'.a:name.'='
+      let opt = word
+    elseif word =~ '^--'.a:name.'$'
+      let opt = word
+      let expect = 1
+    elseif expect
+      let expect = 0
+    endif
+  endfor
+  return opt
+endfunction
+
 function! fzf#run(...) abort
 try
   let [shell, shellslash, shellcmdflag, shellxquote] = s:use_sh()
@@ -452,7 +488,7 @@ try
   let temps  = { 'result': s:fzf_tempname() }
   let optstr = s:evaluate_opts(get(dict, 'options', ''))
   try
-    let fzf_exec = fzf#shellescape(fzf#exec())
+    let fzf_exec = shellescape(fzf#exec())
   catch
     throw v:exception
   endtry
@@ -465,19 +501,19 @@ try
   endif
 
   if has_key(dict, 'source')
-    let source = dict.source
+    let source = remove(dict, 'source')
     let type = type(source)
     if type == 1
-      let prefix = '( '.source.' )|'
+      let source_command = source
     elseif type == 3
       let temps.input = s:fzf_tempname()
-      call writefile(source, temps.input)
-      let prefix = (s:is_win ? 'type ' : 'cat ').fzf#shellescape(temps.input).'|'
+      call s:writefile(source, temps.input)
+      let source_command = (s:is_win ? 'type ' : 'cat ').fzf#shellescape(temps.input)
     else
       throw 'Invalid source type'
     endif
   else
-    let prefix = ''
+    let source_command = ''
   endif
 
   let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0) || has_key(dict, 'tmux')
@@ -487,20 +523,25 @@ try
   let has_vim8_term = has('terminal') && has('patch-8.0.995')
   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'))
+    \ has_vim8_term && !has('win32unix') && (has('gui_running') || s:is_win || s:present(dict, 'down', 'up', 'left', 'right', 'window'))
   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
   endif
-  if use_height
+  if use_term
+    let optstr .= ' --no-height'
+  elseif use_height
     let height = s:calc_size(&lines, dict.down, dict)
     let optstr .= ' --height='.height
-  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
+  " Respect --border option given in $FZF_DEFAULT_OPTS and 'options'
+  let optstr = join([s:border_opt(get(dict, 'window', 0)), s:extract_option($FZF_DEFAULT_OPTS, 'border'), optstr])
+  let prev_default_command = $FZF_DEFAULT_COMMAND
+  if len(source_command)
+    let $FZF_DEFAULT_COMMAND = source_command
+  endif
+  let command = (use_tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
 
   if use_term
     return s:execute_term(dict, command, temps)
@@ -511,6 +552,14 @@ try
   call s:callback(dict, lines)
   return lines
 finally
+  if exists('source_command') && len(source_command)
+    if len(prev_default_command)
+      let $FZF_DEFAULT_COMMAND = prev_default_command
+    else
+      let $FZF_DEFAULT_COMMAND = ''
+      silent! execute 'unlet $FZF_DEFAULT_COMMAND'
+    endif
+  endif
   let [&shell, &shellslash, &shellcmdflag, &shellxquote] = [shell, shellslash, shellcmdflag, shellxquote]
 endtry
 endfunction
@@ -540,8 +589,8 @@ function! s:fzf_tmux(dict)
       endif
     endfor
   endif
-  return printf('LINES=%d COLUMNS=%d %s %s %s --',
-    \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size, (has_key(a:dict, 'source') ? '' : '-'))
+  return printf('LINES=%d COLUMNS=%d %s %s - --',
+    \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size)
 endfunction
 
 function! s:splittable(dict)
@@ -648,7 +697,7 @@ function! s:execute(dict, command, use_height, temps) abort
   endif
   if s:is_win
     let batchfile = s:fzf_tempname().'.bat'
-    call writefile(s:wrap_cmds(command), batchfile)
+    call s:writefile(s:wrap_cmds(command), batchfile)
     let command = batchfile
     let a:temps.batchfile = batchfile
     if has('nvim')
@@ -666,13 +715,12 @@ function! s:execute(dict, command, use_height, temps) abort
     endif
   elseif has('win32unix') && $TERM !=# 'cygwin'
     let shellscript = s:fzf_tempname()
-    call writefile([command], shellscript)
+    call s:writefile([command], shellscript)
     let command = 'cmd.exe /C '.fzf#shellescape('set "TERM=" & start /WAIT sh -c '.shellscript)
     let a:temps.shellscript = shellscript
   endif
   if a:use_height
-    let stdin = has_key(a:dict, 'source') ? '' : '< /dev/tty'
-    call system(printf('tput cup %d > /dev/tty; tput cnorm > /dev/tty; %s %s 2> /dev/tty', &lines, command, stdin))
+    call system(printf('tput cup %d > /dev/tty; tput cnorm > /dev/tty; %s < /dev/tty 2> /dev/tty', &lines, command))
   else
     execute 'silent !'.command
   endif
@@ -715,7 +763,7 @@ function! s:calc_size(max, val, dict)
     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
+  let margin += match(opts, '--border\([^-]\|$\)') > match(opts, '--no-border\([^-]\|$\)') ? 2 : 0
   if stridx(opts, '--header') > stridx(opts, '--no-header')
     let margin += len(split(opts, "\n"))
   endif
@@ -732,9 +780,9 @@ function! s:border_opt(window)
   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'
+  let style = tolower(get(a:window, 'border', ''))
+  if !has_key(a:window, 'border') && has_key(a:window, 'rounded')
+    let style = a:window.rounded ? 'rounded' : 'sharp'
   endif
   if style == 'none' || style == 'no'
     return ''
@@ -742,7 +790,7 @@ function! s:border_opt(window)
 
   " For --border styles, we need fzf 0.24.0 or above
   call fzf#exec('0.24.0')
-  let opt = ' --border=' . style
+  let opt = ' --border ' . style
   if has_key(a:window, 'highlight')
     let color = s:get_color('fg', a:window.highlight)
     if len(color)
@@ -804,6 +852,17 @@ if exists(':tnoremap')
   tnoremap <silent> <Plug>(fzf-normal) <C-\><C-n>
 endif
 
+let s:warned = 0
+function! s:handle_ambidouble(dict)
+  if &ambiwidth == 'double'
+    let a:dict.env = { 'RUNEWIDTH_EASTASIAN': '1' }
+  elseif !s:warned && $RUNEWIDTH_EASTASIAN == '1' && &ambiwidth !=# 'double'
+    call s:warn("$RUNEWIDTH_EASTASIAN is '1' but &ambiwidth is not 'double'")
+    2sleep
+    let s:warned = 1
+  endif
+endfunction
+
 function! s:execute_term(dict, command, temps) abort
   let winrest = winrestcmd()
   let pbuf = bufnr('')
@@ -866,13 +925,14 @@ function! s:execute_term(dict, command, temps) abort
     call s:pushd(a:dict)
     if s:is_win
       let fzf.temps.batchfile = s:fzf_tempname().'.bat'
-      call writefile(s:wrap_cmds(a:command), fzf.temps.batchfile)
+      call s:writefile(s:wrap_cmds(a:command), fzf.temps.batchfile)
       let command = fzf.temps.batchfile
     else
       let command = a:command
     endif
     let command .= s:term_marker
     if has('nvim')
+      call s:handle_ambidouble(fzf)
       call termopen(command, fzf)
     else
       let term_opts = {'exit_cb': function(fzf.on_exit)}
@@ -884,7 +944,8 @@ function! s:execute_term(dict, command, temps) abort
       else
         let term_opts.curwin = 1
       endif
-      let fzf.buf = term_start([&shell, &shellcmdflag, command], term_opts)
+      call s:handle_ambidouble(term_opts)
+      keepjumps let fzf.buf = term_start([&shell, &shellcmdflag, command], term_opts)
       if is_popup && exists('#TerminalWinOpen')
         doautocmd <nomodeline> TerminalWinOpen
       endif
@@ -933,6 +994,8 @@ function! s:callback(dict, lines) abort
     endif
     if has_key(a:dict, 'sink*')
       call a:dict['sink*'](a:lines)
+    elseif has_key(a:dict, 'sinklist')
+      call a:dict['sinklist'](a:lines)
     endif
   catch
     if stridx(v:exception, ':E325:') < 0
@@ -948,16 +1011,16 @@ function! s:callback(dict, lines) abort
 endfunction
 
 if has('nvim')
-  function s:create_popup(hl, opts) abort
+  function s:create_popup(opts) abort
     let buf = nvim_create_buf(v:false, v:true)
     let opts = extend({'relative': 'editor', 'style': 'minimal'}, a:opts)
     let win = nvim_open_win(buf, v:true, opts)
-    call setwinvar(win, '&winhighlight', 'NormalFloat:'..a:hl)
+    silent! call setwinvar(win, '&winhighlight', 'Pmenu:,Normal:Normal')
     call setwinvar(win, '&colorcolumn', '')
     return buf
   endfunction
 else
-  function! s:create_popup(hl, opts) abort
+  function! s:create_popup(opts) abort
     let s:popup_create = {buf -> popup_create(buf, #{
       \ line: a:opts.row,
       \ col: a:opts.col,
@@ -972,11 +1035,19 @@ else
 endif
 
 function! s:popup(opts) abort
+  let xoffset = get(a:opts, 'xoffset', 0.5)
+  let yoffset = get(a:opts, 'yoffset', 0.5)
+  let relative = get(a:opts, 'relative', 0)
+
+  " Use current window size for positioning relatively positioned popups
+  let columns = relative ? winwidth(0) : &columns
+  let lines = relative ? winheight(0) : (&lines - has('nvim'))
+
   " Size and position
-  let width = min([max([8, a:opts.width > 1 ? a:opts.width : float2nr(&columns * a:opts.width)]), &columns])
-  let height = min([max([4, a:opts.height > 1 ? a:opts.height : 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))
+  let width = min([max([8, a:opts.width > 1 ? a:opts.width : float2nr(columns * a:opts.width)]), columns])
+  let height = min([max([4, a:opts.height > 1 ? a:opts.height : float2nr(lines * a:opts.height)]), lines])
+  let row = float2nr(yoffset * (lines - height)) + (relative ? win_screenpos(0)[0] - 1 : 0)
+  let col = float2nr(xoffset * (columns - width)) + (relative ? win_screenpos(0)[1] - 1 : 0)
 
   " Managing the differences
   let row = min([max([0, row]), &lines - has('nvim') - height])
@@ -984,7 +1055,7 @@ function! s:popup(opts) abort
   let row += !has('nvim')
   let col += !has('nvim')
 
-  call s:create_popup('Normal', {
+  call s:create_popup({
     \ 'row': row, 'col': col, 'width': width, 'height': height
   \ })
 endfunction

shell/completion.bash

@@ -11,33 +11,39 @@
 
 if [[ $- =~ i ]]; then
 
-# To use custom commands instead of find, override _fzf_compgen_{path,dir}
-if ! declare -f _fzf_compgen_path > /dev/null; then
-  _fzf_compgen_path() {
-    echo "$1"
-    command find -L "$1" \
-      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
-      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
-  }
-fi
 
-if ! declare -f _fzf_compgen_dir > /dev/null; then
-  _fzf_compgen_dir() {
-    command find -L "$1" \
-      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
-      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
-  }
-fi
+# To use custom commands instead of find, override _fzf_compgen_{path,dir}
+#
+#   _fzf_compgen_path() {
+#     echo "$1"
+#     command find -L "$1" \
+#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+#       -a -not -path "$1" -print 2> /dev/null | command sed 's@^\./@@'
+#   }
+#
+#   _fzf_compgen_dir() {
+#     command find -L "$1" \
+#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
+#       -a -not -path "$1" -print 2> /dev/null | command sed 's@^\./@@'
+#   }
 
 ###########################################################
 
 # To redraw line after fzf closes (printf '\e[5n')
-bind '"\e[0n": redraw-current-line'
+bind '"\e[0n": redraw-current-line' 2> /dev/null
+
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  echo "${FZF_DEFAULT_OPTS-} $2"
+}
 
 __fzf_comprun() {
-  if [ "$(type -t _fzf_comprun 2>&1)" = function ]; then
+  if [[ "$(type -t _fzf_comprun 2>&1)" = function ]]; then
     _fzf_comprun "$@"
-  elif [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; }; then
+  elif [[ -n "${TMUX_PANE-}" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "${FZF_TMUX_OPTS-}" ]]; }; then
     shift
     fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- "$@"
   else
@@ -55,72 +61,223 @@ __fzf_orig_completion() {
       cmd="${BASH_REMATCH[3]}"
       [[ "$f" = _fzf_* ]] && continue
       printf -v "_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}" "%s" "${comp} %s ${cmd} #${f}"
-      if [[ "$l" = *" -o nospace "* ]] && [[ ! "$__fzf_nospace_commands" = *" $cmd "* ]]; then
-        __fzf_nospace_commands="$__fzf_nospace_commands $cmd "
+      if [[ "$l" = *" -o nospace "* ]] && [[ ! "${__fzf_nospace_commands-}" = *" $cmd "* ]]; then
+        __fzf_nospace_commands="${__fzf_nospace_commands-} $cmd "
       fi
     fi
   done
 }
 
+# @param $1 cmd - Command name for which the original completion is searched
+# @var[out] REPLY - Original function name is returned
+__fzf_orig_completion_get_orig_func() {
+  local cmd orig_var orig
+  cmd=$1
+  orig_var="_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}"
+  orig="${!orig_var-}"
+  REPLY="${orig##*#}"
+  [[ $REPLY ]] && type "$REPLY" &> /dev/null
+}
+
+# @param $1 cmd - Command name for which the original completion is searched
+# @param $2 func - Fzf's completion function to replace the original function
+# @var[out] REPLY - Completion setting is returned as a string to "eval"
+__fzf_orig_completion_instantiate() {
+  local cmd func orig_var orig
+  cmd=$1
+  func=$2
+  orig_var="_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}"
+  orig="${!orig_var-}"
+  orig="${orig%#*}"
+  [[ $orig == *' %s '* ]] || return 1
+  printf -v REPLY "$orig" "$func"
+}
+
 _fzf_opts_completion() {
   local cur prev opts
   COMPREPLY=()
   cur="${COMP_WORDS[COMP_CWORD]}"
   prev="${COMP_WORDS[COMP_CWORD-1]}"
   opts="
+    -h --help
     -x --extended
     -e --exact
+    --extended-exact
+    +x --no-extended
+    +e --no-exact
+    -q --query
+    -f --filter
+    --literal
+    --no-literal
     --algo
-    -i +i
+    --scheme
+    --expect
+    --no-expect
+    --enabled --no-phony
+    --disabled --phony
+    --tiebreak
+    --bind
+    --color
+    --toggle-sort
+    -d --delimiter
     -n --nth
     --with-nth
-    -d --delimiter
+    -s --sort
     +s --no-sort
+    --track
+    --no-track
     --tac
-    --tiebreak
+    --no-tac
+    -i
+    +i
     -m --multi
+    +m --no-multi
+    --ansi
+    --no-ansi
     --no-mouse
-    --bind
-    --cycle
-    --no-hscroll
-    --jump-labels
-    --height
-    --literal
+    +c --no-color
+    +2 --no-256
+    --black
+    --no-black
+    --bold
+    --no-bold
+    --layout
     --reverse
-    --margin
+    --no-reverse
+    --cycle
+    --no-cycle
+    --keep-right
+    --no-keep-right
+    --hscroll
+    --no-hscroll
+    --hscroll-off
+    --scroll-off
+    --filepath-word
+    --no-filepath-word
+    --info
+    --no-info
     --inline-info
+    --no-inline-info
+    --separator
+    --no-separator
+    --scrollbar
+    --no-scrollbar
+    --jump-labels
+    -1 --select-1
+    +1 --no-select-1
+    -0 --exit-0
+    +0 --no-exit-0
+    --read0
+    --no-read0
+    --print0
+    --no-print0
+    --print-query
+    --no-print-query
     --prompt
     --pointer
     --marker
-    --header
-    --header-lines
-    --ansi
-    --tabstop
-    --color
-    --no-bold
+    --sync
+    --no-sync
+    --async
+    --no-history
     --history
     --history-size
+    --no-header
+    --no-header-lines
+    --header
+    --header-lines
+    --header-first
+    --no-header-first
+    --ellipsis
     --preview
+    --no-preview
     --preview-window
-    -q --query
-    -1 --select-1
-    -0 --exit-0
-    -f --filter
-    --print-query
-    --expect
-    --sync"
+    --height
+    --min-height
+    --no-height
+    --no-margin
+    --no-padding
+    --no-border
+    --border
+    --no-border-label
+    --border-label
+    --border-label-pos
+    --no-preview-label
+    --preview-label
+    --preview-label-pos
+    --no-unicode
+    --unicode
+    --margin
+    --padding
+    --tabstop
+    --listen
+    --no-listen
+    --clear
+    --no-clear
+    --version
+    --"
 
   case "${prev}" in
+  --algo)
+    COMPREPLY=( $(compgen -W "v1 v2" -- "$cur") )
+    return 0
+    ;;
+  --scheme)
+    COMPREPLY=( $(compgen -W "default path history" -- "$cur") )
+    return 0
+    ;;
   --tiebreak)
-    COMPREPLY=( $(compgen -W "length begin end index" -- "$cur") )
+    COMPREPLY=( $(compgen -W "length chunk begin end index" -- "$cur") )
     return 0
     ;;
   --color)
-    COMPREPLY=( $(compgen -W "dark light 16 bw" -- "$cur") )
+    COMPREPLY=( $(compgen -W "dark light 16 bw no" -- "$cur") )
     return 0
     ;;
-  --history)
-    COMPREPLY=()
+  --layout)
+    COMPREPLY=( $(compgen -W "default reverse reverse-list" -- "$cur") )
+    return 0
+    ;;
+  --info)
+    COMPREPLY=( $(compgen -W "default right hidden inline inline-right" -- "$cur") )
+    return 0
+    ;;
+  --preview-window)
+    COMPREPLY=( $(compgen -W "
+      default
+      hidden
+      nohidden
+      wrap
+      nowrap
+      cycle
+      nocycle
+      up top
+      down bottom
+      left
+      right
+      rounded border border-rounded
+      sharp border-sharp
+      border-bold
+      border-block
+      border-thinblock
+      border-double
+      noborder border-none
+      border-horizontal
+      border-vertical
+      border-up border-top
+      border-down border-bottom
+      border-left
+      border-right
+      follow
+      nofollow" -- "$cur") )
+    return 0
+    ;;
+  --border)
+    COMPREPLY=( $(compgen -W "rounded sharp bold block thinblock double horizontal vertical top bottom left right none" -- "$cur") )
+    return 0
+    ;;
+  --border-label-pos|--preview-label-pos)
+    COMPREPLY=( $(compgen -W "center bottom top" -- "$cur") )
     return 0
     ;;
   esac
@@ -134,54 +291,72 @@ _fzf_opts_completion() {
 }
 
 _fzf_handle_dynamic_completion() {
-  local cmd orig_var orig ret orig_cmd orig_complete
+  local cmd ret REPLY orig_cmd orig_complete
   cmd="$1"
   shift
   orig_cmd="$1"
-  orig_var="_fzf_orig_completion_$cmd"
-  orig="${!orig_var##*#}"
-  if [ -n "$orig" ] && type "$orig" > /dev/null 2>&1; then
-    $orig "$@"
-  elif [ -n "$_fzf_completion_loader" ]; then
+  if __fzf_orig_completion_get_orig_func "$cmd"; then
+    "$REPLY" "$@"
+  elif [[ -n "${_fzf_completion_loader-}" ]]; then
     orig_complete=$(complete -p "$orig_cmd" 2> /dev/null)
-    _completion_loader "$@"
+    $_fzf_completion_loader "$@"
     ret=$?
     # _completion_loader may not have updated completion for the command
-    if [ "$(complete -p "$orig_cmd" 2> /dev/null)" != "$orig_complete" ]; then
+    if [[ "$(complete -p "$orig_cmd" 2> /dev/null)" != "$orig_complete" ]]; then
       __fzf_orig_completion < <(complete -p "$orig_cmd" 2> /dev/null)
-      if [[ "$__fzf_nospace_commands" = *" $orig_cmd "* ]]; then
+
+      # Update orig_complete by _fzf_orig_completion entry
+      [[ $orig_complete =~ ' -F '(_fzf_[^ ]+)' ' ]] &&
+        __fzf_orig_completion_instantiate "$cmd" "${BASH_REMATCH[1]}" &&
+        orig_complete=$REPLY
+
+      if [[ "${__fzf_nospace_commands-}" = *" $orig_cmd "* ]]; then
         eval "${orig_complete/ -F / -o nospace -F }"
       else
         eval "$orig_complete"
       fi
     fi
+    [[ $ret -eq 0 ]] && return 124
     return $ret
   fi
 }
 
 __fzf_generic_path_completion() {
   local cur base dir leftover matches trigger cmd
-  cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
+  cmd="${COMP_WORDS[0]}"
+  if [[ $cmd == \\* ]]; then
+    cmd="${cmd:1}"
+  fi
   COMPREPLY=()
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ "$cur" == *"$trigger" ]]; then
+  if [[ "$cur" == *"$trigger" ]] && [[ $cur != *'$('* ]] && [[ $cur != *':='* ]] && [[ $cur != *'`'* ]]; then
     base=${cur:0:${#cur}-${#trigger}}
-    eval "base=$base"
+    eval "base=$base" 2> /dev/null || return
 
+    dir=
     [[ $base = *"/"* ]] && dir="$base"
     while true; do
-      if [ -z "$dir" ] || [ -d "$dir" ]; then
+      if [[ -z "$dir" ]] || [[ -d "$dir" ]]; then
         leftover=${base/#"$dir"}
         leftover=${leftover/#\/}
-        [ -z "$dir" ] && dir='.'
-        [ "$dir" != "/" ] && dir="${dir/%\//}"
-        matches=$(eval "$1 $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $2" __fzf_comprun "$4" -q "$leftover" | while read -r item; do
-          printf "%q$3 " "$item"
-        done)
+        [[ -z "$dir" ]] && dir='.'
+        [[ "$dir" != "/" ]] && dir="${dir/%\//}"
+        matches=$(
+          export FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --scheme=path" "${FZF_COMPLETION_OPTS-} $2")
+          unset FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS_FILE
+          if declare -F "$1" > /dev/null; then
+            eval "$1 $(printf %q "$dir")" | __fzf_comprun "$4" -q "$leftover"
+          else
+            [[ $1 =~ dir ]] && walker=dir,follow || walker=file,dir,follow,hidden
+            __fzf_comprun "$4" -q "$leftover" --walker "$walker" --walker-root="$dir"
+          fi | while read -r item; do
+            printf "%q " "${item%$3}$3"
+          done
+        )
         matches=${matches% }
-        [[ -z "$3" ]] && [[ "$__fzf_nospace_commands" = *" ${COMP_WORDS[0]} "* ]] && matches="$matches "
-        if [ -n "$matches" ]; then
+        [[ -z "$3" ]] && [[ "${__fzf_nospace_commands-}" = *" ${COMP_WORDS[0]} "* ]] && matches="$matches "
+        if [[ -n "$matches" ]]; then
           COMPREPLY=( "$matches" )
         else
           COMPREPLY=( "$cur" )
@@ -189,7 +364,7 @@ __fzf_generic_path_completion() {
         printf '\e[5n'
         return 0
       fi
-      dir=$(dirname "$dir")
+      dir=$(command dirname "$dir")
       [[ "$dir" =~ /$ ]] || dir="$dir"/
     done
   else
@@ -223,18 +398,21 @@ _fzf_complete() {
   fi
 
   local cur selected trigger cmd post
-  post="$(caller 0 | awk '{print $2}')_post"
-  type -t "$post" > /dev/null 2>&1 || post=cat
+  post="$(caller 0 | command awk '{print $2}')_post"
+  type -t "$post" > /dev/null 2>&1 || post='command cat'
 
-  cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
+  cmd="${COMP_WORDS[0]}"
   cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ "$cur" == *"$trigger" ]]; then
+  if [[ "$cur" == *"$trigger" ]] && [[ $cur != *'$('* ]] && [[ $cur != *':='* ]] && [[ $cur != *'`'* ]]; then
     cur=${cur:0:${#cur}-${#trigger}}
 
-    selected=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $str_arg" __fzf_comprun "${rest[0]}" "${args[@]}" -q "$cur" | $post | tr '\n' ' ')
+    selected=$(
+      FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse" "${FZF_COMPLETION_OPTS-} $str_arg") \
+      FZF_DEFAULT_OPTS_FILE='' \
+        __fzf_comprun "${rest[0]}" "${args[@]}" -q "$cur" | $post | command tr '\n' ' ')
     selected=${selected% } # Strip trailing space not to repeat "-o nospace"
-    if [ -n "$selected" ]; then
+    if [[ -n "$selected" ]]; then
       COMPREPLY=("$selected")
     else
       COMPREPLY=("$cur")
@@ -260,55 +438,86 @@ _fzf_dir_completion() {
 }
 
 _fzf_complete_kill() {
-  local trigger=${FZF_COMPLETION_TRIGGER-'**'}
-  local cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ -z "$cur" ]]; then
-    COMP_WORDS[$COMP_CWORD]=$trigger
-  elif [[ "$cur" != *"$trigger" ]]; then
-    return 1
-  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_complete -m --header-lines=1 --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+    command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
+      command ps -eo user,pid,ppid,time,args # For BusyBox
   )
 }
 
 _fzf_proc_completion_post() {
-  awk '{print $2}'
+  command awk '{print $2}'
 }
 
+# To use custom hostname lists, override __fzf_list_hosts.
+# The function is expected to print hostnames, one per line as well as in the
+# desired sorting and with any duplicates removed, to standard output.
+#
+# e.g.
+#   # Use bash-completions’s _known_hosts_real() for getting the list of hosts
+#   __fzf_list_hosts() {
+#     # Set the local attribute for any non-local variable that is set by _known_hosts_real()
+#     local COMPREPLY=()
+#     _known_hosts_real ''
+#     printf '%s\n' "${COMPREPLY[@]}" | command sort -u --version-sort
+#   }
+if ! declare -F __fzf_list_hosts > /dev/null; then
+  __fzf_list_hosts() {
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | command awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
+      <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts 2> /dev/null | command tr ',' '\n' | command tr -d '[' | command awk '{ print $1 " " $1 }') \
+      <(command grep -v '^\s*\(#\|$\)' /etc/hosts 2> /dev/null | command grep -Fv '0.0.0.0' | command sed 's/#.*//') |
+      command awk '{for (i = 2; i <= NF; i++) print $i}' | command sort -u
+  }
+fi
+
 _fzf_host_completion() {
-  _fzf_complete +m -- "$@" < <(
-    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?]') \
-        <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
-        <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
-        awk '{if (length($2) > 0) {print $2}}' | sort -u
-  )
+  _fzf_complete +m -- "$@" < <(__fzf_list_hosts)
+}
+
+# Values for $1 $2 $3 are described here
+# https://www.gnu.org/software/bash/manual/html_node/Programmable-Completion.html
+# > the first argument ($1) is the name of the command whose arguments are being completed,
+# > the second argument ($2) is the word being completed,
+# > and the third argument ($3) is the word preceding the word being completed on the current command line.
+_fzf_complete_ssh() {
+  case $3 in
+    -i|-F|-E)
+      _fzf_path_completion "$@"
+      ;;
+    *)
+      local user=
+      [[ "$2" =~ '@' ]] && user="${2%%@*}@"
+      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | command awk -v user="$user" '{print user $0}')
+      ;;
+  esac
 }
 
 _fzf_var_completion() {
   _fzf_complete -m -- "$@" < <(
-    declare -xp | sed 's/=.*//' | sed 's/.* //'
+    declare -xp | command sed -En 's|^declare [^ ]+ ([^=]+).*|\1|p'
   )
 }
 
 _fzf_alias_completion() {
   _fzf_complete -m -- "$@" < <(
-    alias | sed 's/=.*//' | sed 's/.* //'
+    alias | command sed -En 's|^alias ([^=]+).*|\1|p'
   )
 }
 
 # fzf options
 complete -o default -F _fzf_opts_completion fzf
+# fzf-tmux is a thin fzf wrapper that has only a few more options than fzf
+# itself. As a quick improvement we take fzf's completion. Adding the few extra
+# fzf-tmux specific options (like `-w WIDTH`) are left as a future patch.
+complete -o default -F _fzf_opts_completion fzf-tmux
 
 d_cmds="${FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir}"
 a_cmds="
-  awk cat diff diff3
-  emacs emacsclient ex file ftp g++ gcc gvim head hg java
+  awk bat cat diff diff3
+  emacs emacsclient ex file ftp g++ gcc gvim head hg hx java
   javac ld less more mvim nvim patch perl python ruby
   sed sftp sort source tail tee uniq vi view vim wc xdg-open
   basename bunzip2 bzip2 chmod chown curl cp dirname du
@@ -317,22 +526,27 @@ a_cmds="
   svn tar unzip zip"
 
 # Preserve existing completion
-__fzf_orig_completion < <(complete -p $d_cmds $a_cmds 2> /dev/null)
+__fzf_orig_completion < <(complete -p $d_cmds $a_cmds ssh 2> /dev/null)
 
-if type _completion_loader > /dev/null 2>&1; then
-  _fzf_completion_loader=1
+if type _comp_load > /dev/null 2>&1; then
+  # _comp_load was added in bash-completion 2.12 to replace _completion_loader.
+  # We use it without -D option so that it does not use _comp_complete_minimal as the fallback.
+  _fzf_completion_loader=_comp_load
+elif type __load_completion > /dev/null 2>&1; then
+  # In bash-completion 2.11, _completion_loader internally calls __load_completion
+  # and if it returns a non-zero status, it sets the default 'minimal' completion.
+  _fzf_completion_loader=__load_completion
+elif type _completion_loader > /dev/null 2>&1; then
+  _fzf_completion_loader=_completion_loader
 fi
 
 __fzf_defc() {
-  local cmd func opts orig_var orig def
+  local cmd func opts REPLY
   cmd="$1"
   func="$2"
   opts="$3"
-  orig_var="_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}"
-  orig="${!orig_var}"
-  if [ -n "$orig" ]; then
-    printf -v def "$orig" "$func"
-    eval "$def"
+  if __fzf_orig_completion_instantiate "$cmd" "$func"; then
+    eval "$REPLY"
   else
     complete -F "$func" $opts "$cmd"
   fi
@@ -345,11 +559,11 @@ done
 
 # Directory
 for cmd in $d_cmds; do
-  __fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o dirnames"
+  __fzf_defc "$cmd" _fzf_dir_completion "-o bashdefault -o nospace -o dirnames"
 done
 
-# Kill completion (supports empty completion trigger)
-complete -F _fzf_complete_kill -o default -o bashdefault kill
+# ssh
+__fzf_defc ssh _fzf_complete_ssh "-o default -o bashdefault"
 
 unset cmd d_cmds a_cmds
 
@@ -373,9 +587,10 @@ _fzf_setup_completion() {
   done
 }
 
-# Environment variables / Aliases / Hosts
-_fzf_setup_completion 'var'   export unset
+# Environment variables / Aliases / Hosts / Process
+_fzf_setup_completion 'var'   export unset printenv
 _fzf_setup_completion 'alias' unalias
-_fzf_setup_completion 'host'  ssh telnet
+_fzf_setup_completion 'host'  telnet
+_fzf_setup_completion 'proc'  kill
 
 fi

shell/completion.zsh

@@ -9,6 +9,7 @@
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)
 
+
 # Both branches of the following `if` do the same thing -- define
 # __fzf_completion_options such that `eval $__fzf_completion_options` sets
 # all options to the same values they currently have. We'll do just that at
@@ -67,41 +68,46 @@ fi
 # 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'
+'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' '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
+# The 'emulate' command should not be placed inside the interactive if check;
+# placing it there fails to disable alias expansion. See #3731.
+if [[ -o interactive ]]; then
 
 # To use custom commands instead of find, override _fzf_compgen_{path,dir}
-if ! declare -f _fzf_compgen_path > /dev/null; then
-  _fzf_compgen_path() {
-    echo "$1"
-    command find -L "$1" \
-      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
-      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
-  }
-fi
-
-if ! declare -f _fzf_compgen_dir > /dev/null; then
-  _fzf_compgen_dir() {
-    command find -L "$1" \
-      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
-      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
-  }
-fi
+#
+#   _fzf_compgen_path() {
+#     echo "$1"
+#     command find -L "$1" \
+#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+#       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+#   }
+#
+#   _fzf_compgen_dir() {
+#     command find -L "$1" \
+#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
+#       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+#   }
 
 ###########################################################
 
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  echo "${FZF_DEFAULT_OPTS-} $2"
+}
+
 __fzf_comprun() {
   if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
     _fzf_comprun "$@"
-  elif [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; }; then
+  elif [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; }; then
     shift
-    if [ -n "$FZF_TMUX_OPTS" ]; then
+    if [ -n "${FZF_TMUX_OPTS-}" ]; then
       fzf-tmux ${(Q)${(Z+n+)FZF_TMUX_OPTS}} -- "$@"
     else
       fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%} -- "$@"
@@ -137,7 +143,10 @@ __fzf_generic_path_completion() {
   tail=$6
 
   setopt localoptions nonomatch
-  eval "base=$base"
+  if [[ $base = *'$('* ]] || [[ $base = *'<('* ]] || [[ $base = *'>('* ]] || [[ $base = *':='* ]] || [[ $base = *'`'* ]]; then
+    return
+  fi
+  eval "base=$base" 2> /dev/null || return
   [[ $base = *"/"* ]] && dir="$base"
   while [ 1 ]; do
     if [[ -z "$dir" || -d ${dir} ]]; then
@@ -145,9 +154,19 @@ __fzf_generic_path_completion() {
       leftover=${leftover/#\/}
       [ -z "$dir" ] && dir='.'
       [ "$dir" != "/" ] && dir="${dir/%\//}"
-      matches=$(eval "$compgen $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS" __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" | while read item; do
-        echo -n "${(q)item}$suffix "
-      done)
+      matches=$(
+        export FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --scheme=path" "${FZF_COMPLETION_OPTS-}")
+        unset FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS_FILE
+        if declare -f "$compgen" > /dev/null; then
+          eval "$compgen $(printf %q "$dir")" | __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover"
+        else
+          [[ $compgen =~ dir ]] && walker=dir,follow || walker=file,dir,follow,hidden
+          __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" --walker "$walker" --walker-root="$dir" < /dev/tty
+        fi | while read item; do
+          item="${item%$suffix}$suffix"
+          echo -n "${(q)item} "
+        done
+      )
       matches=${matches% }
       if [ -n "$matches" ]; then
         LBUFFER="$lbuf$matches$tail"
@@ -183,7 +202,7 @@ _fzf_complete() {
   args=("$@")
   sep=
   for i in {0..${#args[@]}}; do
-    if [[ "${args[$i]}" = -- ]]; then
+    if [[ "${args[$i]-}" = -- ]]; then
       sep=$i
       break
     fi
@@ -207,28 +226,47 @@ _fzf_complete() {
   type $post > /dev/null 2>&1 || post=cat
 
   _fzf_feed_fifo "$fifo"
-  matches=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $str_arg" __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
+  matches=$(
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse" "${FZF_COMPLETION_OPTS-} $str_arg") \
+    FZF_DEFAULT_OPTS_FILE='' \
+      __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
   if [ -n "$matches" ]; then
     LBUFFER="$lbuf$matches"
   fi
   command rm -f "$fifo"
 }
 
+# To use custom hostname lists, override __fzf_list_hosts.
+# The function is expected to print hostnames, one per line as well as in the
+# desired sorting and with any duplicates removed, to standard output.
+if ! declare -f __fzf_list_hosts > /dev/null; then
+  __fzf_list_hosts() {
+    setopt localoptions nonomatch
+    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 2> /dev/null | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
+      <(command grep -v '^\s*\(#\|$\)' /etc/hosts 2> /dev/null | command grep -Fv '0.0.0.0' | command sed 's/#.*//') |
+      awk '{for (i = 2; i <= NF; i++) print $i}' | sort -u
+  }
+fi
+
 _fzf_complete_telnet() {
-  _fzf_complete +m -- "$@" < <(
-    command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0' |
-        awk '{if (length($2) > 0) {print $2}}' | sort -u
-  )
+  _fzf_complete +m -- "$@" < <(__fzf_list_hosts)
 }
 
+# The first and the only argument is the LBUFFER without the current word that contains the trigger.
+# The current word without the trigger is in the $prefix variable passed from the caller.
 _fzf_complete_ssh() {
-  _fzf_complete +m -- "$@" < <(
-    setopt localoptions nonomatch
-    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
-  )
+  local tokens=(${(z)1})
+  case ${tokens[-1]} in
+    -i|-F|-E)
+      _fzf_path_completion "$prefix" "$1"
+      ;;
+    *)
+      local user=
+      [[ $prefix =~ @ ]] && user="${prefix%%@*}@"
+      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | awk -v user="$user" '{print user $0}')
+      ;;
+  esac
 }
 
 _fzf_complete_export() {
@@ -250,8 +288,9 @@ _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 -m --header-lines=1 --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+    command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
+      command ps -eo user,pid,ppid,time,args # For BusyBox
   )
 }
 
@@ -278,25 +317,22 @@ fzf-completion() {
   [ -z "$trigger" -a ${LBUFFER[-1]} = ' ' ] && tokens+=("")
 
   # When the trigger starts with ';', it becomes a separate token
-  if [[ ${LBUFFER} = *"${tokens[-2]}${tokens[-1]}" ]]; then
-    tokens[-2]="${tokens[-2]}${tokens[-1]}"
+  if [[ ${LBUFFER} = *"${tokens[-2]-}${tokens[-1]}" ]]; then
+    tokens[-2]="${tokens[-2]-}${tokens[-1]}"
     tokens=(${tokens[0,-2]})
   fi
 
   lbuf=$LBUFFER
   tail=${LBUFFER:$(( ${#LBUFFER} - ${#trigger} ))}
-  # Kill completion (do not require trigger sequence)
-  if [ "$cmd" = kill -a ${LBUFFER[-1]} = ' ' ]; then
-    tail=$trigger
-    tokens+=$trigger
-    lbuf="$lbuf$trigger"
-  fi
 
   # Trigger sequence given
   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}}
+    if [[ $prefix = *'$('* ]] || [[ $prefix = *'<('* ]] || [[ $prefix = *'>('* ]] || [[ $prefix = *':='* ]] || [[ $prefix = *'`'* ]]; then
+      return
+    fi
     [ -n "${tokens[-1]}" ] && lbuf=${lbuf:0:-${#tokens[-1]}}
 
     if eval "type _fzf_complete_${cmd} > /dev/null"; then
@@ -321,6 +357,7 @@ fzf-completion() {
 
 zle     -N   fzf-completion
 bindkey '^I' fzf-completion
+fi
 
 } always {
   # Restore the original options.

shell/key-bindings.bash

@@ -11,53 +11,97 @@
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS
 
-# Key bindings
-# ------------
-__fzf_select__() {
-  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
-    -o -type f -print \
-    -o -type d -print \
-    -o -type l -print 2> /dev/null | cut -b3-"}"
-  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" $(__fzfcmd) -m "$@" | while read -r item; do
-    printf '%q ' "$item"
-  done
-  echo
-}
-
 if [[ $- =~ i ]]; then
 
+
+# Key bindings
+# ------------
+
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  echo "${FZF_DEFAULT_OPTS-} $2"
+}
+
+__fzf_select__() {
+  FZF_DEFAULT_COMMAND=${FZF_CTRL_T_COMMAND:-} \
+  FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=file,dir,follow,hidden --scheme=path" "${FZF_CTRL_T_OPTS-} -m") \
+  FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) "$@" |
+    while read -r item; do
+      printf '%q ' "$item"  # escape special chars
+    done
+}
+
 __fzfcmd() {
-  [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; } &&
+  [[ -n "${TMUX_PANE-}" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "${FZF_TMUX_OPTS-}" ]]; } &&
     echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
 }
 
 fzf-file-widget() {
-  local selected="$(__fzf_select__)"
+  local selected="$(__fzf_select__ "$@")"
   READLINE_LINE="${READLINE_LINE:0:$READLINE_POINT}$selected${READLINE_LINE:$READLINE_POINT}"
   READLINE_POINT=$(( READLINE_POINT + ${#selected} ))
 }
 
 __fzf_cd__() {
-  local cmd dir
-  cmd="${FZF_ALT_C_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
-    -o -type d -print 2> /dev/null | cut -b3-"}"
-  dir=$(eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS" $(__fzfcmd) +m) && printf 'cd %q' "$dir"
+  local dir
+  dir=$(
+    FZF_DEFAULT_COMMAND=${FZF_ALT_C_COMMAND:-} \
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=dir,follow,hidden --scheme=path" "${FZF_ALT_C_OPTS-} +m") \
+    FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd)
+  ) && printf 'builtin cd -- %q' "$(builtin unset CDPATH && builtin cd -- "$dir" && builtin pwd)"
 }
 
-__fzf_history__() {
-  local output
-  output=$(
-    builtin fc -lnr -2147483648 |
-      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 -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS +m --read0" $(__fzfcmd) --query "$READLINE_LINE"
-  ) || return
-  READLINE_LINE=${output#*$'\t'}
-  if [ -z "$READLINE_POINT" ]; then
-    echo "$READLINE_LINE"
-  else
-    READLINE_POINT=0x7fffffff
-  fi
-}
+if command -v perl > /dev/null; then
+  __fzf_history__() {
+    local output script
+    script='BEGIN { getc; $/ = "\n\t"; $HISTCOUNT = $ENV{last_hist} + 1 } s/^[ *]//; print $HISTCOUNT - $. . "\t$_" if !$seen{$_}++'
+    output=$(
+      set +o pipefail
+      builtin fc -lnr -2147483648 |
+        last_hist=$(HISTTIMEFORMAT='' builtin history 1) command perl -n -l0 -e "$script" |
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort ${FZF_CTRL_R_OPTS-} +m --read0") \
+        FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
+    ) || return
+    READLINE_LINE=${output#*$'\t'}
+    if [[ -z "$READLINE_POINT" ]]; then
+      echo "$READLINE_LINE"
+    else
+      READLINE_POINT=0x7fffffff
+    fi
+  }
+else # awk - fallback for POSIX systems
+  __fzf_history__() {
+    local output script n x y z d
+    if [[ -z $__fzf_awk ]]; then
+      __fzf_awk=awk
+      # choose the faster mawk if: it's installed && build date >= 20230322 && version >= 1.3.4
+      IFS=' .' read n x y z d <<< $(command mawk -W version 2> /dev/null)
+      [[ $n == mawk ]] && (( d >= 20230302 && (x *1000 +y) *1000 +z >= 1003004 )) && __fzf_awk=mawk
+    fi
+    [[ $(HISTTIMEFORMAT='' builtin history 1) =~ [[:digit:]]+ ]]    # how many history entries
+    script='function P(b) { ++n; sub(/^[ *]/, "", b); if (!seen[b]++) { printf "%d\t%s%c", '$((BASH_REMATCH + 1))' - n, b, 0 } }
+    NR==1 { b = substr($0, 2); next }
+    /^\t/ { P(b); b = substr($0, 2); next }
+    { b = b RS $0 }
+    END { if (NR) P(b) }'
+    output=$(
+      set +o pipefail
+      builtin fc -lnr -2147483648 2> /dev/null |   # ( $'\t '<lines>$'\n' )* ; <lines> ::= [^\n]* ( $'\n'<lines> )*
+        command $__fzf_awk "$script"           |   # ( <counter>$'\t'<lines>$'\000' )*
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort ${FZF_CTRL_R_OPTS-} +m --read0") \
+        FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
+    ) || return
+    READLINE_LINE=${output#*$'\t'}
+    if [[ -z "$READLINE_POINT" ]]; then
+      echo "$READLINE_LINE"
+    else
+      READLINE_POINT=0x7fffffff
+    fi
+  }
+fi
 
 # Required to refresh the prompt after fzf
 bind -m emacs-standard '"\er": redraw-current-line'
@@ -66,21 +110,25 @@ bind -m vi-command '"\C-z": emacs-editing-mode'
 bind -m vi-insert '"\C-z": emacs-editing-mode'
 bind -m emacs-standard '"\C-z": vi-editing-mode'
 
-if [ "${BASH_VERSINFO[0]}" -lt 4 ]; then
+if (( BASH_VERSINFO[0] < 4 )); then
   # CTRL-T - Paste the selected file path into the command line
-  bind -m emacs-standard '"\C-t": " \C-b\C-k \C-u`__fzf_select__`\e\C-e\er\C-a\C-y\C-h\C-e\e \C-y\ey\C-x\C-x\C-f"'
-  bind -m vi-command '"\C-t": "\C-z\C-t\C-z"'
-  bind -m vi-insert '"\C-t": "\C-z\C-t\C-z"'
+  if [[ "${FZF_CTRL_T_COMMAND-x}" != "" ]]; 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 vi-command '"\C-t": "\C-z\C-t\C-z"'
+    bind -m vi-insert '"\C-t": "\C-z\C-t\C-z"'
+  fi
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind -m emacs-standard '"\C-r": "\C-e \C-u\C-y\ey\C-u"$(__fzf_history__)"\e\C-e\er"'
+  bind -m emacs-standard '"\C-r": "\C-e \C-u\C-y\ey\C-u`__fzf_history__`\e\C-e\er"'
   bind -m vi-command '"\C-r": "\C-z\C-r\C-z"'
   bind -m vi-insert '"\C-r": "\C-z\C-r\C-z"'
 else
   # CTRL-T - Paste the selected file path into the command line
-  bind -m emacs-standard -x '"\C-t": fzf-file-widget'
-  bind -m vi-command -x '"\C-t": fzf-file-widget'
-  bind -m vi-insert -x '"\C-t": fzf-file-widget'
+  if [[ "${FZF_CTRL_T_COMMAND-x}" != "" ]]; then
+    bind -m emacs-standard -x '"\C-t": fzf-file-widget'
+    bind -m vi-command -x '"\C-t": fzf-file-widget'
+    bind -m vi-insert -x '"\C-t": fzf-file-widget'
+  fi
 
   # CTRL-R - Paste the selected command from history into the command line
   bind -m emacs-standard -x '"\C-r": __fzf_history__'
@@ -89,8 +137,10 @@ else
 fi
 
 # ALT-C - cd into the selected directory
-bind -m emacs-standard '"\ec": " \C-b\C-k \C-u`__fzf_cd__`\e\C-e\er\C-m\C-y\C-h\e \C-y\ey\C-x\C-x\C-d"'
-bind -m vi-command '"\ec": "\C-z\ec\C-z"'
-bind -m vi-insert '"\ec": "\C-z\ec\C-z"'
+if [[ "${FZF_ALT_C_COMMAND-x}" != "" ]]; then
+  bind -m emacs-standard '"\ec": " \C-b\C-k \C-u`__fzf_cd__`\e\C-e\er\C-m\C-y\C-h\e \C-y\ey\C-x\C-x\C-d"'
+  bind -m vi-command '"\ec": "\C-z\ec\C-z"'
+  bind -m vi-insert '"\ec": "\C-z\ec\C-z"'
+fi
 
 fi

shell/key-bindings.fish

@@ -11,29 +11,35 @@
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS
 
+status is-interactive; or exit 0
+
+
 # Key bindings
 # ------------
 function fzf_key_bindings
 
+  function __fzf_defaults
+    # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+    # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    echo "--height $FZF_TMUX_HEIGHT --bind=ctrl-z:ignore" $argv[1]
+    command cat "$FZF_DEFAULT_OPTS_FILE" 2> /dev/null
+    echo $FZF_DEFAULT_OPTS $argv[2]
+  end
+
   # Store current token in $dir as root for the 'find' command
   function fzf-file-widget -d "List files and folders"
     set -l commandline (__fzf_parse_commandline)
-    set -l dir $commandline[1]
+    set -lx dir $commandline[1]
     set -l fzf_query $commandline[2]
     set -l prefix $commandline[3]
 
-    # "-path \$dir'*/\\.*'" matches hidden files/folders inside $dir but not
-    # $dir itself, even if hidden.
-    test -n "$FZF_CTRL_T_COMMAND"; or set -l FZF_CTRL_T_COMMAND "
-    command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
-    -o -type f -print \
-    -o -type d -print \
-    -o -type l -print 2> /dev/null | sed 's@^\./@@'"
-
     test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
     begin
-      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS"
-      eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)' -m --query "'$fzf_query'"' | while read -l r; set result $result $r; end
+      set -lx FZF_DEFAULT_OPTS (__fzf_defaults "--reverse --walker=file,dir,follow,hidden --scheme=path --walker-root='$dir'" "$FZF_CTRL_T_OPTS")
+      set -lx FZF_DEFAULT_COMMAND "$FZF_CTRL_T_COMMAND"
+      set -lx FZF_DEFAULT_OPTS_FILE ''
+      eval (__fzfcmd)' -m --query "'$fzf_query'"' | while read -l r; set result $result $r; end
     end
     if [ -z "$result" ]
       commandline -f repaint
@@ -53,7 +59,8 @@ function fzf_key_bindings
   function fzf-history-widget -d "Show command history"
     test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
     begin
-      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT $FZF_DEFAULT_OPTS --tiebreak=index --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS +m"
+      set -lx FZF_DEFAULT_OPTS (__fzf_defaults "" "--scheme=history --bind=ctrl-r:toggle-sort $FZF_CTRL_R_OPTS +m")
+      set -lx FZF_DEFAULT_OPTS_FILE ''
 
       set -l FISH_MAJOR (echo $version | cut -f1 -d.)
       set -l FISH_MINOR (echo $version | cut -f2 -d.)
@@ -74,20 +81,19 @@ function fzf_key_bindings
 
   function fzf-cd-widget -d "Change directory"
     set -l commandline (__fzf_parse_commandline)
-    set -l dir $commandline[1]
+    set -lx dir $commandline[1]
     set -l fzf_query $commandline[2]
     set -l prefix $commandline[3]
 
-    test -n "$FZF_ALT_C_COMMAND"; or set -l FZF_ALT_C_COMMAND "
-    command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
-    -o -type d -print 2> /dev/null | sed 's@^\./@@'"
     test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
     begin
-      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS"
-      eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)' +m --query "'$fzf_query'"' | read -l result
+      set -lx FZF_DEFAULT_OPTS (__fzf_defaults "--reverse --walker=dir,follow,hidden --scheme=path --walker-root='$dir'" "$FZF_ALT_C_OPTS")
+      set -lx FZF_DEFAULT_OPTS_FILE ''
+      set -lx FZF_DEFAULT_COMMAND "$FZF_ALT_C_COMMAND"
+      eval (__fzfcmd)' +m --query "'$fzf_query'"' | read -l result
 
       if [ -n "$result" ]
-        cd $result
+        cd -- $result
 
         # Remove last token from commandline.
         commandline -t ""
@@ -110,14 +116,22 @@ function fzf_key_bindings
     end
   end
 
-  bind \ct fzf-file-widget
   bind \cr fzf-history-widget
-  bind \ec fzf-cd-widget
+  if not set -q FZF_CTRL_T_COMMAND; or test -n "$FZF_CTRL_T_COMMAND"
+    bind \ct fzf-file-widget
+  end
+  if not set -q FZF_ALT_C_COMMAND; or test -n "$FZF_ALT_C_COMMAND"
+    bind \ec fzf-cd-widget
+  end
 
   if bind -M insert > /dev/null 2>&1
-    bind -M insert \ct fzf-file-widget
     bind -M insert \cr fzf-history-widget
-    bind -M insert \ec fzf-cd-widget
+    if not set -q FZF_CTRL_T_COMMAND; or test -n "$FZF_CTRL_T_COMMAND"
+      bind -M insert \ct fzf-file-widget
+    end
+    if not set -q FZF_ALT_C_COMMAND; or test -n "$FZF_ALT_C_COMMAND"
+      bind -M insert \ec fzf-cd-widget
+    end
   end
 
   function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath, fzf query, and optional -option= prefix'

shell/key-bindings.zsh

@@ -11,6 +11,7 @@
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS
 
+
 # Key bindings
 # ------------
 
@@ -32,21 +33,26 @@ else
   }
 fi
 
-'emulate' 'zsh' '-o' 'no_aliases'
+'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' 'no_aliases'
 
 {
+if [[ -o interactive ]]; then
 
-[[ -o interactive ]] || return 0
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  echo "${FZF_DEFAULT_OPTS-} $2"
+}
 
 # CTRL-T - Paste the selected file path(s) into the command line
-__fsel() {
-  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
-    -o -type f -print \
-    -o -type d -print \
-    -o -type l -print 2> /dev/null | cut -b3-"}"
+__fzf_select() {
   setopt localoptions pipefail no_aliases 2> /dev/null
   local item
-  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" $(__fzfcmd) -m "$@" | while read item; do
+  FZF_DEFAULT_COMMAND=${FZF_CTRL_T_COMMAND:-} \
+  FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=file,dir,follow,hidden --scheme=path" "${FZF_CTRL_T_OPTS-} -m") \
+  FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) "$@" < /dev/tty | while read item; do
     echo -n "${(q)item} "
   done
   local ret=$?
@@ -55,58 +61,73 @@ __fsel() {
 }
 
 __fzfcmd() {
-  [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; } &&
+  [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; } &&
     echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
 }
 
 fzf-file-widget() {
-  LBUFFER="${LBUFFER}$(__fsel)"
+  LBUFFER="${LBUFFER}$(__fzf_select)"
   local ret=$?
   zle reset-prompt
   return $ret
 }
-zle     -N   fzf-file-widget
-bindkey '^T' fzf-file-widget
+if [[ "${FZF_CTRL_T_COMMAND-x}" != "" ]]; then
+  zle     -N            fzf-file-widget
+  bindkey -M emacs '^T' fzf-file-widget
+  bindkey -M vicmd '^T' fzf-file-widget
+  bindkey -M viins '^T' fzf-file-widget
+fi
 
 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
-  local cmd="${FZF_ALT_C_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
-    -o -type d -print 2> /dev/null | cut -b3-"}"
   setopt localoptions pipefail no_aliases 2> /dev/null
-  local dir="$(eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS" $(__fzfcmd) +m)"
+  local dir="$(
+    FZF_DEFAULT_COMMAND=${FZF_ALT_C_COMMAND:-} \
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=dir,follow,hidden --scheme=path" "${FZF_ALT_C_OPTS-} +m") \
+    FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) < /dev/tty)"
   if [[ -z "$dir" ]]; then
     zle redisplay
     return 0
   fi
   zle push-line # Clear buffer. Auto-restored on next prompt.
-  BUFFER="cd ${(q)dir}"
+  BUFFER="builtin cd -- ${(q)dir:a}"
   zle accept-line
   local ret=$?
   unset dir # ensure this doesn't end up appearing in prompt expansion
   zle reset-prompt
   return $ret
 }
-zle     -N    fzf-cd-widget
-bindkey '\ec' fzf-cd-widget
+if [[ "${FZF_ALT_C_COMMAND-x}" != "" ]]; then
+  zle     -N             fzf-cd-widget
+  bindkey -M emacs '\ec' fzf-cd-widget
+  bindkey -M vicmd '\ec' fzf-cd-widget
+  bindkey -M viins '\ec' fzf-cd-widget
+fi
 
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
   local selected num
   setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2> /dev/null
-  selected=( $(fc -rl 1 | perl -ne 'print if !$seen{(/^\s*[0-9]+\**\s+(.*)/, $1)}++' |
-    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS --query=${(qqq)LBUFFER} +m" $(__fzfcmd)) )
+  selected="$(fc -rl 1 | awk '{ cmd=$0; sub(/^[ \t]*[0-9]+\**[ \t]+/, "", cmd); if (!seen[cmd]++) print $0 }' |
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m") \
+    FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
   local ret=$?
   if [ -n "$selected" ]; then
-    num=$selected[1]
-    if [ -n "$num" ]; then
-      zle vi-fetch-history -n $num
+    num=$(awk '{print $1}' <<< "$selected")
+    if [[ "$num" =~ '^[1-9][0-9]*\*?$' ]]; then
+      zle vi-fetch-history -n ${num%\*}
+    else # selected is a custom query, not from history
+      LBUFFER="$selected"
     fi
   fi
   zle reset-prompt
   return $ret
 }
-zle     -N   fzf-history-widget
-bindkey '^R' fzf-history-widget
+zle     -N            fzf-history-widget
+bindkey -M emacs '^R' fzf-history-widget
+bindkey -M vicmd '^R' fzf-history-widget
+bindkey -M viins '^R' fzf-history-widget
+fi
 
 } always {
   eval $__fzf_key_bindings_options

src/LICENSE

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

src/actiontype_string.go

@@ -0,0 +1,131 @@
+// Code generated by "stringer -type=actionType"; DO NOT EDIT.
+
+package fzf
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[actIgnore-0]
+	_ = x[actStart-1]
+	_ = x[actClick-2]
+	_ = x[actInvalid-3]
+	_ = x[actChar-4]
+	_ = x[actMouse-5]
+	_ = x[actBeginningOfLine-6]
+	_ = x[actAbort-7]
+	_ = x[actAccept-8]
+	_ = x[actAcceptNonEmpty-9]
+	_ = x[actAcceptOrPrintQuery-10]
+	_ = x[actBackwardChar-11]
+	_ = x[actBackwardDeleteChar-12]
+	_ = x[actBackwardDeleteCharEof-13]
+	_ = x[actBackwardWord-14]
+	_ = x[actCancel-15]
+	_ = x[actChangeBorderLabel-16]
+	_ = x[actChangeHeader-17]
+	_ = x[actChangePreviewLabel-18]
+	_ = x[actChangePrompt-19]
+	_ = x[actChangeQuery-20]
+	_ = x[actClearScreen-21]
+	_ = x[actClearQuery-22]
+	_ = x[actClearSelection-23]
+	_ = x[actClose-24]
+	_ = x[actDeleteChar-25]
+	_ = x[actDeleteCharEof-26]
+	_ = x[actEndOfLine-27]
+	_ = x[actForwardChar-28]
+	_ = x[actForwardWord-29]
+	_ = x[actKillLine-30]
+	_ = x[actKillWord-31]
+	_ = x[actUnixLineDiscard-32]
+	_ = x[actUnixWordRubout-33]
+	_ = x[actYank-34]
+	_ = x[actBackwardKillWord-35]
+	_ = x[actSelectAll-36]
+	_ = x[actDeselectAll-37]
+	_ = x[actToggle-38]
+	_ = x[actToggleSearch-39]
+	_ = x[actToggleAll-40]
+	_ = x[actToggleDown-41]
+	_ = x[actToggleUp-42]
+	_ = x[actToggleIn-43]
+	_ = x[actToggleOut-44]
+	_ = x[actToggleTrack-45]
+	_ = x[actToggleTrackCurrent-46]
+	_ = x[actToggleHeader-47]
+	_ = x[actTrackCurrent-48]
+	_ = x[actUntrackCurrent-49]
+	_ = x[actDown-50]
+	_ = x[actUp-51]
+	_ = x[actPageUp-52]
+	_ = x[actPageDown-53]
+	_ = x[actPosition-54]
+	_ = x[actHalfPageUp-55]
+	_ = x[actHalfPageDown-56]
+	_ = x[actOffsetUp-57]
+	_ = x[actOffsetDown-58]
+	_ = x[actJump-59]
+	_ = x[actJumpAccept-60]
+	_ = x[actPrintQuery-61]
+	_ = x[actRefreshPreview-62]
+	_ = x[actReplaceQuery-63]
+	_ = x[actToggleSort-64]
+	_ = x[actShowPreview-65]
+	_ = x[actHidePreview-66]
+	_ = x[actTogglePreview-67]
+	_ = x[actTogglePreviewWrap-68]
+	_ = x[actTransform-69]
+	_ = x[actTransformBorderLabel-70]
+	_ = x[actTransformHeader-71]
+	_ = x[actTransformPreviewLabel-72]
+	_ = x[actTransformPrompt-73]
+	_ = x[actTransformQuery-74]
+	_ = x[actPreview-75]
+	_ = x[actChangePreview-76]
+	_ = x[actChangePreviewWindow-77]
+	_ = x[actPreviewTop-78]
+	_ = x[actPreviewBottom-79]
+	_ = x[actPreviewUp-80]
+	_ = x[actPreviewDown-81]
+	_ = x[actPreviewPageUp-82]
+	_ = x[actPreviewPageDown-83]
+	_ = x[actPreviewHalfPageUp-84]
+	_ = x[actPreviewHalfPageDown-85]
+	_ = x[actPrevHistory-86]
+	_ = x[actPrevSelected-87]
+	_ = x[actPut-88]
+	_ = x[actNextHistory-89]
+	_ = x[actNextSelected-90]
+	_ = x[actExecute-91]
+	_ = x[actExecuteSilent-92]
+	_ = x[actExecuteMulti-93]
+	_ = x[actSigStop-94]
+	_ = x[actFirst-95]
+	_ = x[actLast-96]
+	_ = x[actReload-97]
+	_ = x[actReloadSync-98]
+	_ = x[actDisableSearch-99]
+	_ = x[actEnableSearch-100]
+	_ = x[actSelect-101]
+	_ = x[actDeselect-102]
+	_ = x[actUnbind-103]
+	_ = x[actRebind-104]
+	_ = x[actBecome-105]
+	_ = x[actResponse-106]
+	_ = x[actShowHeader-107]
+	_ = x[actHideHeader-108]
+}
+
+const _actionType_name = "actIgnoreactStartactClickactInvalidactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactCancelactChangeBorderLabelactChangeHeaderactChangePreviewLabelactChangePromptactChangeQueryactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactForwardCharactForwardWordactKillLineactKillWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleTrackCurrentactToggleHeaderactTrackCurrentactUntrackCurrentactDownactUpactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTransformactTransformBorderLabelactTransformHeaderactTransformPreviewLabelactTransformPromptactTransformQueryactPreviewactChangePreviewactChangePreviewWindowactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactBecomeactResponseactShowHeaderactHideHeader"
+
+var _actionType_index = [...]uint16{0, 9, 17, 25, 35, 42, 50, 68, 76, 85, 102, 123, 138, 159, 183, 198, 207, 227, 242, 263, 278, 292, 306, 319, 336, 344, 357, 373, 385, 399, 413, 424, 435, 453, 470, 477, 496, 508, 522, 531, 546, 558, 571, 582, 593, 605, 619, 640, 655, 670, 687, 694, 699, 708, 719, 730, 743, 758, 769, 782, 789, 802, 815, 832, 847, 860, 874, 888, 904, 924, 936, 959, 977, 1001, 1019, 1036, 1046, 1062, 1084, 1097, 1113, 1125, 1139, 1155, 1173, 1193, 1215, 1229, 1244, 1250, 1264, 1279, 1289, 1305, 1320, 1330, 1338, 1345, 1354, 1367, 1383, 1398, 1407, 1418, 1427, 1436, 1445, 1456, 1469, 1482}
+
+func (i actionType) String() string {
+	if i < 0 || i >= actionType(len(_actionType_index)-1) {
+		return "actionType(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _actionType_name[_actionType_index[i]:_actionType_index[i+1]]
+}

src/algo/algo.go

@@ -80,6 +80,7 @@ Scoring criteria
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"strings"
 	"unicode"
 	"unicode/utf8"
@@ -89,6 +90,10 @@ import (
 
 var DEBUG bool
 
+var delimiterChars = "/,:;|"
+
+const whiteChars = " \t\n\v\f\r\x85\xA0"
+
 func indexAt(index int, max int, forward bool) int {
 	if forward {
 		return index
@@ -107,7 +112,7 @@ type Result struct {
 const (
 	scoreMatch        = 16
 	scoreGapStart     = -3
-	scoreGapExtention = -1
+	scoreGapExtension = -1
 
 	// We prefer matches at the beginning of a word, but the bonus should not be
 	// too great to prevent the longer acronym matches from always winning over
@@ -125,31 +130,93 @@ const (
 	// Edge-triggered bonus for matches in camelCase words.
 	// Compared to word-boundary case, they don't accompany single-character gaps
 	// (e.g. FooBar vs. foo-bar), so we deduct bonus point accordingly.
-	bonusCamel123 = bonusBoundary + scoreGapExtention
+	bonusCamel123 = bonusBoundary + scoreGapExtension
 
 	// Minimum bonus point given to characters in consecutive chunks.
 	// Note that bonus points for consecutive matches shouldn't have needed if we
 	// used fixed match score as in the original algorithm.
-	bonusConsecutive = -(scoreGapStart + scoreGapExtention)
+	bonusConsecutive = -(scoreGapStart + scoreGapExtension)
 
 	// The first character in the typed pattern usually has more significance
 	// than the rest so it's important that it appears at special positions where
-	// bonus points are given. e.g. "to-go" vs. "ongoing" on "og" or on "ogo".
+	// bonus points are given, e.g. "to-go" vs. "ongoing" on "og" or on "ogo".
 	// The amount of the extra bonus should be limited so that the gap penalty is
 	// still respected.
 	bonusFirstCharMultiplier = 2
 )
 
+var (
+	// Extra bonus for word boundary after whitespace character or beginning of the string
+	bonusBoundaryWhite int16 = bonusBoundary + 2
+
+	// Extra bonus for word boundary after slash, colon, semi-colon, and comma
+	bonusBoundaryDelimiter int16 = bonusBoundary + 1
+
+	initialCharClass charClass = charWhite
+
+	// A minor optimization that can give 15%+ performance boost
+	asciiCharClasses [unicode.MaxASCII + 1]charClass
+
+	// A minor optimization that can give yet another 5% performance boost
+	bonusMatrix [charNumber + 1][charNumber + 1]int16
+)
+
 type charClass int
 
 const (
-	charNonWord charClass = iota
+	charWhite charClass = iota
+	charNonWord
+	charDelimiter
 	charLower
 	charUpper
 	charLetter
 	charNumber
 )
 
+func Init(scheme string) bool {
+	switch scheme {
+	case "default":
+		bonusBoundaryWhite = bonusBoundary + 2
+		bonusBoundaryDelimiter = bonusBoundary + 1
+	case "path":
+		bonusBoundaryWhite = bonusBoundary
+		bonusBoundaryDelimiter = bonusBoundary + 1
+		if os.PathSeparator == '/' {
+			delimiterChars = "/"
+		} else {
+			delimiterChars = string([]rune{os.PathSeparator, '/'})
+		}
+		initialCharClass = charDelimiter
+	case "history":
+		bonusBoundaryWhite = bonusBoundary
+		bonusBoundaryDelimiter = bonusBoundary
+	default:
+		return false
+	}
+	for i := 0; i <= unicode.MaxASCII; i++ {
+		char := rune(i)
+		c := charNonWord
+		if char >= 'a' && char <= 'z' {
+			c = charLower
+		} else if char >= 'A' && char <= 'Z' {
+			c = charUpper
+		} else if char >= '0' && char <= '9' {
+			c = charNumber
+		} else if strings.ContainsRune(whiteChars, char) {
+			c = charWhite
+		} else if strings.ContainsRune(delimiterChars, char) {
+			c = charDelimiter
+		}
+		asciiCharClasses[i] = c
+	}
+	for i := 0; i <= int(charNumber); i++ {
+		for j := 0; j <= int(charNumber); j++ {
+			bonusMatrix[i][j] = bonusFor(charClass(i), charClass(j))
+		}
+	}
+	return true
+}
+
 func posArray(withPos bool, len int) *[]int {
 	if withPos {
 		pos := make([]int, 0, len)
@@ -174,17 +241,6 @@ func alloc32(offset int, slab *util.Slab, size int) (int, []int32) {
 	return offset, make([]int32, size)
 }
 
-func charClassOfAscii(char rune) charClass {
-	if char >= 'a' && char <= 'z' {
-		return charLower
-	} else if char >= 'A' && char <= 'Z' {
-		return charUpper
-	} else if char >= '0' && char <= '9' {
-		return charNumber
-	}
-	return charNonWord
-}
-
 func charClassOfNonAscii(char rune) charClass {
 	if unicode.IsLower(char) {
 		return charLower
@@ -194,36 +250,56 @@ func charClassOfNonAscii(char rune) charClass {
 		return charNumber
 	} else if unicode.IsLetter(char) {
 		return charLetter
+	} else if unicode.IsSpace(char) {
+		return charWhite
+	} else if strings.ContainsRune(delimiterChars, char) {
+		return charDelimiter
 	}
 	return charNonWord
 }
 
 func charClassOf(char rune) charClass {
 	if char <= unicode.MaxASCII {
-		return charClassOfAscii(char)
+		return asciiCharClasses[char]
 	}
 	return charClassOfNonAscii(char)
 }
 
 func bonusFor(prevClass charClass, class charClass) int16 {
-	if prevClass == charNonWord && class != charNonWord {
-		// Word boundary
-		return bonusBoundary
-	} else if prevClass == charLower && class == charUpper ||
+	if class > charNonWord {
+		switch prevClass {
+		case charWhite:
+			// Word boundary after whitespace
+			return bonusBoundaryWhite
+		case charDelimiter:
+			// Word boundary after a delimiter character
+			return bonusBoundaryDelimiter
+		case charNonWord:
+			// Word boundary
+			return bonusBoundary
+		}
+	}
+
+	if prevClass == charLower && class == charUpper ||
 		prevClass != charNumber && class == charNumber {
 		// camelCase letter123
 		return bonusCamel123
-	} else if class == charNonWord {
+	}
+
+	switch class {
+	case charNonWord, charDelimiter:
 		return bonusNonWord
+	case charWhite:
+		return bonusBoundaryWhite
 	}
 	return 0
 }
 
 func bonusAt(input *util.Chars, idx int) int16 {
 	if idx == 0 {
-		return bonusBoundary
+		return bonusBoundaryWhite
 	}
-	return bonusFor(charClassOf(input.Get(idx-1)), charClassOf(input.Get(idx)))
+	return bonusMatrix[charClassOf(input.Get(idx-1))][charClassOf(input.Get(idx))]
 }
 
 func normalizeRune(r rune) rune {
@@ -276,30 +352,45 @@ func isAscii(runes []rune) bool {
 	return true
 }
 
-func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) int {
+func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) (int, int) {
 	// Can't determine
 	if !input.IsBytes() {
-		return 0
+		return 0, input.Length()
 	}
 
 	// Not possible
 	if !isAscii(pattern) {
-		return -1
+		return -1, -1
 	}
 
-	firstIdx, idx := 0, 0
+	firstIdx, idx, lastIdx := 0, 0, 0
+	var b byte
 	for pidx := 0; pidx < len(pattern); pidx++ {
-		idx = trySkip(input, caseSensitive, byte(pattern[pidx]), idx)
+		b = byte(pattern[pidx])
+		idx = trySkip(input, caseSensitive, b, idx)
 		if idx < 0 {
-			return -1
+			return -1, -1
 		}
 		if pidx == 0 && idx > 0 {
 			// Step back to find the right bonus point
 			firstIdx = idx - 1
 		}
+		lastIdx = idx
 		idx++
 	}
-	return firstIdx
+
+	// Find the last appearance of the last character of the pattern to limit the search scope
+	bu := b
+	if !caseSensitive && b >= 'a' && b <= 'z' {
+		bu = b - 32
+	}
+	scope := input.Bytes()[lastIdx:]
+	for offset := len(scope) - 1; offset > 0; offset-- {
+		if scope[offset] == b || scope[offset] == bu {
+			return firstIdx, lastIdx + offset + 1
+		}
+	}
+	return firstIdx, lastIdx + 1
 }
 
 func debugV2(T []rune, pattern []rune, F []int32, lastIdx int, H []int16, C []int16) {
@@ -348,6 +439,9 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 		return Result{0, 0, 0}, posArray(withPos, M)
 	}
 	N := input.Length()
+	if M > N {
+		return Result{-1, -1, 0}, nil
+	}
 
 	// Since O(nm) algorithm can be prohibitively expensive for large input,
 	// we fall back to the greedy algorithm.
@@ -356,10 +450,12 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	}
 
 	// Phase 1. Optimized search for ASCII string
-	idx := asciiFuzzyIndex(input, pattern, caseSensitive)
-	if idx < 0 {
+	minIdx, maxIdx := asciiFuzzyIndex(input, pattern, caseSensitive)
+	if minIdx < 0 {
 		return Result{-1, -1, 0}, nil
 	}
+	// fmt.Println(N, maxIdx, idx, maxIdx-idx, input.ToString())
+	N = maxIdx - minIdx
 
 	// Reuse pre-allocated integer slice to avoid unnecessary sweeping of garbages
 	offset16 := 0
@@ -372,20 +468,19 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	offset32, F := alloc32(offset32, slab, M)
 	// Rune array
 	_, T := alloc32(offset32, slab, N)
-	input.CopyRunes(T)
+	input.CopyRunes(T, minIdx)
 
 	// Phase 2. Calculate bonus for each point
 	maxScore, maxScorePos := int16(0), 0
 	pidx, lastIdx := 0, 0
-	pchar0, pchar, prevH0, prevClass, inGap := pattern[0], pattern[0], int16(0), charNonWord, false
-	Tsub := T[idx:]
-	H0sub, C0sub, Bsub := H0[idx:][:len(Tsub)], C0[idx:][:len(Tsub)], B[idx:][:len(Tsub)]
-	for off, char := range Tsub {
+	pchar0, pchar, prevH0, prevClass, inGap := pattern[0], pattern[0], int16(0), initialCharClass, false
+	for off, char := range T {
 		var class charClass
 		if char <= unicode.MaxASCII {
-			class = charClassOfAscii(char)
+			class = asciiCharClasses[char]
 			if !caseSensitive && class == charUpper {
 				char += 32
+				T[off] = char
 			}
 		} else {
 			class = charClassOfNonAscii(char)
@@ -395,53 +490,53 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			if normalize {
 				char = normalizeRune(char)
 			}
+			T[off] = char
 		}
 
-		Tsub[off] = char
-		bonus := bonusFor(prevClass, class)
-		Bsub[off] = bonus
+		bonus := bonusMatrix[prevClass][class]
+		B[off] = bonus
 		prevClass = class
 
 		if char == pchar {
 			if pidx < M {
-				F[pidx] = int32(idx + off)
+				F[pidx] = int32(off)
 				pidx++
 				pchar = pattern[util.Min(pidx, M-1)]
 			}
-			lastIdx = idx + off
+			lastIdx = off
 		}
 
 		if char == pchar0 {
 			score := scoreMatch + bonus*bonusFirstCharMultiplier
-			H0sub[off] = score
-			C0sub[off] = 1
+			H0[off] = score
+			C0[off] = 1
 			if M == 1 && (forward && score > maxScore || !forward && score >= maxScore) {
-				maxScore, maxScorePos = score, idx+off
-				if forward && bonus == bonusBoundary {
+				maxScore, maxScorePos = score, off
+				if forward && bonus >= bonusBoundary {
 					break
 				}
 			}
 			inGap = false
 		} else {
 			if inGap {
-				H0sub[off] = util.Max16(prevH0+scoreGapExtention, 0)
+				H0[off] = util.Max16(prevH0+scoreGapExtension, 0)
 			} else {
-				H0sub[off] = util.Max16(prevH0+scoreGapStart, 0)
+				H0[off] = util.Max16(prevH0+scoreGapStart, 0)
 			}
-			C0sub[off] = 0
+			C0[off] = 0
 			inGap = true
 		}
-		prevH0 = H0sub[off]
+		prevH0 = H0[off]
 	}
 	if pidx != M {
 		return Result{-1, -1, 0}, nil
 	}
 	if M == 1 {
-		result := Result{maxScorePos, maxScorePos + 1, int(maxScore)}
+		result := Result{minIdx + maxScorePos, minIdx + maxScorePos + 1, int(maxScore)}
 		if !withPos {
 			return result, nil
 		}
-		pos := []int{maxScorePos}
+		pos := []int{minIdx + maxScorePos}
 		return result, &pos
 	}
 
@@ -477,7 +572,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			var s1, s2, consecutive int16
 
 			if inGap {
-				s2 = Hleft[off] + scoreGapExtention
+				s2 = Hleft[off] + scoreGapExtension
 			} else {
 				s2 = Hleft[off] + scoreGapStart
 			}
@@ -486,11 +581,14 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 				s1 = Hdiag[off] + scoreMatch
 				b := Bsub[off]
 				consecutive = Cdiag[off] + 1
-				// Break consecutive chunk
-				if b == bonusBoundary {
-					consecutive = 1
-				} else if consecutive > 1 {
-					b = util.Max16(b, util.Max16(bonusConsecutive, B[col-int(consecutive)+1]))
+				if consecutive > 1 {
+					fb := B[col-int(consecutive)+1]
+					// Break consecutive chunk
+					if b >= bonusBoundary && b > fb {
+						consecutive = 1
+					} else {
+						b = util.Max16(b, util.Max16(bonusConsecutive, fb))
+					}
 				}
 				if s1+b < s2 {
 					s1 += Bsub[off]
@@ -535,7 +633,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			}
 
 			if s > s1 && (s > s2 || s == s2 && preferMatch) {
-				*pos = append(*pos, j)
+				*pos = append(*pos, j+minIdx)
 				if i == 0 {
 					break
 				}
@@ -548,14 +646,14 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	// Start offset we return here is only relevant when begin tiebreak is used.
 	// However finding the accurate offset requires backtracking, and we don't
 	// want to pay extra cost for the option that has lost its importance.
-	return Result{j, maxScorePos + 1, int(maxScore)}, pos
+	return Result{minIdx + j, minIdx + maxScorePos + 1, int(maxScore)}, pos
 }
 
 // Implement the same sorting criteria as V2
 func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, pattern []rune, sidx int, eidx int, withPos bool) (int, *[]int) {
 	pidx, score, inGap, consecutive, firstBonus := 0, 0, false, 0, int16(0)
 	pos := posArray(withPos, len(pattern))
-	prevClass := charNonWord
+	prevClass := initialCharClass
 	if sidx > 0 {
 		prevClass = charClassOf(text.Get(sidx - 1))
 	}
@@ -578,12 +676,12 @@ func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, patter
 				*pos = append(*pos, idx)
 			}
 			score += scoreMatch
-			bonus := bonusFor(prevClass, class)
+			bonus := bonusMatrix[prevClass][class]
 			if consecutive == 0 {
 				firstBonus = bonus
 			} else {
 				// Break consecutive chunk
-				if bonus == bonusBoundary {
+				if bonus >= bonusBoundary && bonus > firstBonus {
 					firstBonus = bonus
 				}
 				bonus = util.Max16(util.Max16(bonus, firstBonus), bonusConsecutive)
@@ -598,7 +696,7 @@ func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, patter
 			pidx++
 		} else {
 			if inGap {
-				score += scoreGapExtention
+				score += scoreGapExtension
 			} else {
 				score += scoreGapStart
 			}
@@ -616,7 +714,8 @@ func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text *util.C
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
-	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
+	idx, _ := asciiFuzzyIndex(text, pattern, caseSensitive)
+	if idx < 0 {
 		return Result{-1, -1, 0}, nil
 	}
 
@@ -710,7 +809,8 @@ func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text *uti
 		return Result{-1, -1, 0}, nil
 	}
 
-	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
+	idx, _ := asciiFuzzyIndex(text, pattern, caseSensitive)
+	if idx < 0 {
 		return Result{-1, -1, 0}, nil
 	}
 
@@ -741,7 +841,7 @@ func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text *uti
 				if bonus > bestBonus {
 					bestPos, bestBonus = index, bonus
 				}
-				if bonus == bonusBoundary {
+				if bonus >= bonusBoundary {
 					break
 				}
 				index -= pidx - 1
@@ -877,8 +977,8 @@ func EqualMatch(caseSensitive bool, normalize bool, forward bool, text *util.Cha
 		match = runesStr == string(pattern)
 	}
 	if match {
-		return Result{trimmedLen, trimmedLen + lenPattern, (scoreMatch+bonusBoundary)*lenPattern +
-			(bonusFirstCharMultiplier-1)*bonusBoundary}, nil
+		return Result{trimmedLen, trimmedLen + lenPattern, (scoreMatch+int(bonusBoundaryWhite))*lenPattern +
+			(bonusFirstCharMultiplier-1)*int(bonusBoundaryWhite)}, nil
 	}
 	return Result{-1, -1, 0}, nil
 }

src/algo/algo_test.go

@@ -9,6 +9,10 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )
 
+func init() {
+	Init("default")
+}
+
 func assertMatch(t *testing.T, fun Algo, caseSensitive, forward bool, input, pattern string, sidx int, eidx int, score int) {
 	assertMatch2(t, fun, caseSensitive, false, forward, input, pattern, sidx, eidx, score)
 }
@@ -43,46 +47,46 @@ func TestFuzzyMatch(t *testing.T) {
 	for _, fn := range []Algo{FuzzyMatchV1, FuzzyMatchV2} {
 		for _, forward := range []bool{true, false} {
 			assertMatch(t, fn, false, forward, "fooBarbaz1", "oBZ", 2, 9,
-				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtention*3)
+				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtension*3)
 			assertMatch(t, fn, false, forward, "foo bar baz", "fbb", 0, 9,
-				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
-					bonusBoundary*2+2*scoreGapStart+4*scoreGapExtention)
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+					int(bonusBoundaryWhite)*2+2*scoreGapStart+4*scoreGapExtension)
 			assertMatch(t, fn, false, forward, "/AutomatorDocument.icns", "rdoc", 9, 13,
 				scoreMatch*4+bonusCamel123+bonusConsecutive*2)
 			assertMatch(t, fn, false, forward, "/man1/zshcompctl.1", "zshc", 6, 10,
-				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3)
+				scoreMatch*4+int(bonusBoundaryDelimiter)*bonusFirstCharMultiplier+int(bonusBoundaryDelimiter)*3)
 			assertMatch(t, fn, false, forward, "/.oh-my-zsh/cache", "zshc", 8, 13,
-				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3+scoreGapStart)
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*2+scoreGapStart+int(bonusBoundaryDelimiter))
 			assertMatch(t, fn, false, forward, "ab0123 456", "12356", 3, 10,
-				scoreMatch*5+bonusConsecutive*3+scoreGapStart+scoreGapExtention)
+				scoreMatch*5+bonusConsecutive*3+scoreGapStart+scoreGapExtension)
 			assertMatch(t, fn, false, forward, "abc123 456", "12356", 3, 10,
-				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+bonusConsecutive+scoreGapStart+scoreGapExtention)
+				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+bonusConsecutive+scoreGapStart+scoreGapExtension)
 			assertMatch(t, fn, false, forward, "foo/bar/baz", "fbb", 0, 9,
-				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
-					bonusBoundary*2+2*scoreGapStart+4*scoreGapExtention)
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+					int(bonusBoundaryDelimiter)*2+2*scoreGapStart+4*scoreGapExtension)
 			assertMatch(t, fn, false, forward, "fooBarBaz", "fbb", 0, 7,
-				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
-					bonusCamel123*2+2*scoreGapStart+2*scoreGapExtention)
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+					bonusCamel123*2+2*scoreGapStart+2*scoreGapExtension)
 			assertMatch(t, fn, false, forward, "foo barbaz", "fbb", 0, 8,
-				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary+
-					scoreGapStart*2+scoreGapExtention*3)
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)+
+					scoreGapStart*2+scoreGapExtension*3)
 			assertMatch(t, fn, false, forward, "fooBar Baz", "foob", 0, 4,
-				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3)
+				scoreMatch*4+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)*3)
 			assertMatch(t, fn, false, forward, "xFoo-Bar Baz", "foo-b", 1, 6,
 				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+
 					bonusNonWord+bonusBoundary)
 
 			assertMatch(t, fn, true, forward, "fooBarbaz", "oBz", 2, 9,
-				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtention*3)
+				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtension*3)
 			assertMatch(t, fn, true, forward, "Foo/Bar/Baz", "FBB", 0, 9,
-				scoreMatch*3+bonusBoundary*(bonusFirstCharMultiplier+2)+
-					scoreGapStart*2+scoreGapExtention*4)
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryDelimiter)*2+
+					scoreGapStart*2+scoreGapExtension*4)
 			assertMatch(t, fn, true, forward, "FooBarBaz", "FBB", 0, 7,
-				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+bonusCamel123*2+
-					scoreGapStart*2+scoreGapExtention*2)
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+bonusCamel123*2+
+					scoreGapStart*2+scoreGapExtension*2)
 			assertMatch(t, fn, true, forward, "FooBar Baz", "FooB", 0, 4,
-				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*2+
-					util.Max(bonusCamel123, bonusBoundary))
+				scoreMatch*4+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)*2+
+					util.Max(bonusCamel123, int(bonusBoundaryWhite)))
 
 			// Consecutive bonus updated
 			assertMatch(t, fn, true, forward, "foo-bar", "o-ba", 2, 6,
@@ -98,10 +102,10 @@ func TestFuzzyMatch(t *testing.T) {
 
 func TestFuzzyMatchBackward(t *testing.T) {
 	assertMatch(t, FuzzyMatchV1, false, true, "foobar fb", "fb", 0, 4,
-		scoreMatch*2+bonusBoundary*bonusFirstCharMultiplier+
-			scoreGapStart+scoreGapExtention)
+		scoreMatch*2+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+			scoreGapStart+scoreGapExtension)
 	assertMatch(t, FuzzyMatchV1, false, false, "foobar fb", "fb", 7, 9,
-		scoreMatch*2+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary)
+		scoreMatch*2+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite))
 }
 
 func TestExactMatchNaive(t *testing.T) {
@@ -114,9 +118,9 @@ func TestExactMatchNaive(t *testing.T) {
 		assertMatch(t, ExactMatchNaive, false, dir, "/AutomatorDocument.icns", "rdoc", 9, 13,
 			scoreMatch*4+bonusCamel123+bonusConsecutive*2)
 		assertMatch(t, ExactMatchNaive, false, dir, "/man1/zshcompctl.1", "zshc", 6, 10,
-			scoreMatch*4+bonusBoundary*(bonusFirstCharMultiplier+3))
+			scoreMatch*4+int(bonusBoundaryDelimiter)*(bonusFirstCharMultiplier+3))
 		assertMatch(t, ExactMatchNaive, false, dir, "/.oh-my-zsh/cache", "zsh/c", 8, 13,
-			scoreMatch*5+bonusBoundary*(bonusFirstCharMultiplier+4))
+			scoreMatch*5+bonusBoundary*(bonusFirstCharMultiplier+3)+int(bonusBoundaryDelimiter))
 	}
 }
 
@@ -128,7 +132,7 @@ func TestExactMatchNaiveBackward(t *testing.T) {
 }
 
 func TestPrefixMatch(t *testing.T) {
-	score := (scoreMatch+bonusBoundary)*3 + bonusBoundary*(bonusFirstCharMultiplier-1)
+	score := scoreMatch*3 + int(bonusBoundaryWhite)*bonusFirstCharMultiplier + int(bonusBoundaryWhite)*2
 
 	for _, dir := range []bool{true, false} {
 		assertMatch(t, PrefixMatch, true, dir, "fooBarbaz", "Foo", -1, -1, 0)
@@ -156,9 +160,10 @@ func TestSuffixMatch(t *testing.T) {
 		// Strip trailing white space from the string
 		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz", 6, 9,
 			scoreMatch*3+bonusConsecutive*2)
+
 		// Only when the pattern doesn't end with a space
 		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz ", 6, 10,
-			scoreMatch*4+bonusConsecutive*2+bonusNonWord)
+			scoreMatch*4+bonusConsecutive*2+int(bonusBoundaryWhite))
 	}
 }
 
@@ -182,9 +187,9 @@ func TestNormalize(t *testing.T) {
 				input, pattern, sidx, eidx, score)
 		}
 	}
-	test("Só Danço Samba", "So", 0, 2, 56, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, ExactMatchNaive)
-	test("Só Danço Samba", "sodc", 0, 7, 89, FuzzyMatchV1, FuzzyMatchV2)
-	test("Danço", "danco", 0, 5, 128, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, SuffixMatch, ExactMatchNaive, EqualMatch)
+	test("Só Danço Samba", "So", 0, 2, 62, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, ExactMatchNaive)
+	test("Só Danço Samba", "sodc", 0, 7, 97, FuzzyMatchV1, FuzzyMatchV2)
+	test("Danço", "danco", 0, 5, 140, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, SuffixMatch, ExactMatchNaive, EqualMatch)
 }
 
 func TestLongString(t *testing.T) {

src/ansi.go

@@ -55,6 +55,9 @@ func (s *ansiState) ToString() string {
 	if s.attr&tui.Reverse > 0 {
 		ret += "7;"
 	}
+	if s.attr&tui.StrikeThrough > 0 {
+		ret += "9;"
+	}
 	ret += toAnsiString(s.fg, 30) + toAnsiString(s.bg, 40)
 
 	return "\x1b[" + strings.TrimSuffix(ret, ";") + "m"
@@ -85,7 +88,7 @@ func isPrint(c uint8) bool {
 }
 
 func matchOperatingSystemCommand(s string) int {
-	// `\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)`
+	// `\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)`
 	//                        ^ match starting here
 	//
 	i := 5 // prefix matched in nextAnsiEscapeSequence()
@@ -103,30 +106,37 @@ func matchOperatingSystemCommand(s string) int {
 }
 
 func matchControlSequence(s string) int {
-	// `\x1b[\\[()][0-9;?]*[a-zA-Z@]`
-	//                    ^ match starting here
+	// `\x1b[\\[()][0-9;:?]*[a-zA-Z@]`
+	//                     ^ match starting here
 	//
 	i := 2 // prefix matched in nextAnsiEscapeSequence()
-	for ; i < len(s) && (isNumeric(s[i]) || s[i] == ';' || s[i] == '?'); i++ {
-	}
-	if i < len(s) {
+	for ; i < len(s); i++ {
 		c := s[i]
-		if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '@' {
-			return i + 1
+		switch c {
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ';', ':', '?':
+			// ok
+		default:
+			if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '@' {
+				return i + 1
+			}
+			return -1
 		}
 	}
 	return -1
 }
 
 func isCtrlSeqStart(c uint8) bool {
-	return c == '\\' || c == '[' || c == '(' || c == ')'
+	switch c {
+	case '\\', '[', '(', ')':
+		return true
+	}
+	return false
 }
 
 // nextAnsiEscapeSequence returns the ANSI escape sequence and is equivalent to
 // calling FindStringIndex() on the below regex (which was originally used):
 //
-// "(?:\x1b[\\[()][0-9;?]*[a-zA-Z@]|\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)"
-//
+// "(?:\x1b[\\[()][0-9;:?]*[a-zA-Z@]|\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)"
 func nextAnsiEscapeSequence(s string) (int, int) {
 	// fast check for ANSI escape sequences
 	i := 0
@@ -154,16 +164,16 @@ Loop:
 				return i - n, i + 1
 			}
 		case '\x1b':
-			// match: `\x1b[\\[()][0-9;?]*[a-zA-Z@]`
+			// match: `\x1b[\\[()][0-9;:?]*[a-zA-Z@]`
 			if i+2 < len(s) && isCtrlSeqStart(s[i+1]) {
 				if j := matchControlSequence(s[i:]); j != -1 {
 					return i, i + j
 				}
 			}
 
-			// match: `\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)`
+			// match: `\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)`
 			if i+5 < len(s) && s[i+1] == ']' && isNumeric(s[i+2]) &&
-				s[i+3] == ';' && isPrint(s[i+4]) {
+				(s[i+3] == ';' || s[i+3] == ':') && isPrint(s[i+4]) {
 
 				if j := matchOperatingSystemCommand(s[i:]); j != -1 {
 					return i, i + j
@@ -280,9 +290,20 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo
 	return trimmed, nil, state
 }
 
-func parseAnsiCode(s string) (int, string) {
+func parseAnsiCode(s string, delimiter byte) (int, byte, string) {
 	var remaining string
-	if i := strings.IndexByte(s, ';'); i >= 0 {
+	i := -1
+	if delimiter == 0 {
+		// Faster than strings.IndexAny(";:")
+		i = strings.IndexByte(s, ';')
+		if i < 0 {
+			i = strings.IndexByte(s, ':')
+		}
+	} else {
+		i = strings.IndexByte(s, delimiter)
+	}
+	if i >= 0 {
+		delimiter = s[i]
 		remaining = s[i+1:]
 		s = s[:i]
 	}
@@ -291,17 +312,17 @@ func parseAnsiCode(s string) (int, string) {
 		// Inlined version of strconv.Atoi() that only handles positive
 		// integers and does not allocate on error.
 		code := 0
-		for _, ch := range []byte(s) {
+		for _, ch := range sbytes(s) {
 			ch -= '0'
 			if ch > 9 {
-				return -1, remaining
+				return -1, delimiter, remaining
 			}
 			code = code*10 + int(ch)
 		}
-		return code, remaining
+		return code, delimiter, remaining
 	}
 
-	return -1, remaining
+	return -1, delimiter, remaining
 }
 
 func interpretCode(ansiCode string, prevState *ansiState) ansiState {
@@ -329,9 +350,12 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 	state256 := 0
 	ptr := &state.fg
 
+	var delimiter byte = 0
+	count := 0
 	for len(ansiCode) != 0 {
 		var num int
-		if num, ansiCode = parseAnsiCode(ansiCode); num != -1 {
+		if num, delimiter, ansiCode = parseAnsiCode(ansiCode, delimiter); num != -1 {
+			count++
 			switch state256 {
 			case 0:
 				switch num {
@@ -357,10 +381,21 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 					state.attr = state.attr | tui.Blink
 				case 7:
 					state.attr = state.attr | tui.Reverse
+				case 9:
+					state.attr = state.attr | tui.StrikeThrough
+				case 22:
+					state.attr = state.attr &^ tui.Bold
+					state.attr = state.attr &^ tui.Dim
 				case 23: // tput rmso
 					state.attr = state.attr &^ tui.Italic
 				case 24: // tput rmul
 					state.attr = state.attr &^ tui.Underline
+				case 25:
+					state.attr = state.attr &^ tui.Blink
+				case 27:
+					state.attr = state.attr &^ tui.Reverse
+				case 29:
+					state.attr = state.attr &^ tui.StrikeThrough
 				case 0:
 					state.fg = -1
 					state.bg = -1
@@ -402,6 +437,13 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 		}
 	}
 
+	// Empty sequence: reset
+	if count == 0 {
+		state.fg = -1
+		state.bg = -1
+		state.attr = 0
+	}
+
 	if state256 > 0 {
 		*ptr = -1
 	}

src/ansi_test.go

@@ -1,7 +1,6 @@
 package fzf
 
 import (
-	"fmt"
 	"math/rand"
 	"regexp"
 	"strings"
@@ -16,12 +15,14 @@ import (
 // testing nextAnsiEscapeSequence().
 //
 // References:
-// 	- https://github.com/gnachman/iTerm2
-// 	- http://ascii-table.com/ansi-escape-sequences.php
-// 	- http://ascii-table.com/ansi-escape-sequences-vt-100.php
-// 	- http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
-// 	- https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
-var ansiRegexRefence = regexp.MustCompile("(?:\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)")
+//   - https://github.com/gnachman/iTerm2
+//   - https://web.archive.org/web/20090204053813/http://ascii-table.com/ansi-escape-sequences.php
+//     (archived from http://ascii-table.com/ansi-escape-sequences.php)
+//   - https://web.archive.org/web/20090227051140/http://ascii-table.com/ansi-escape-sequences-vt-100.php
+//     (archived from http://ascii-table.com/ansi-escape-sequences-vt-100.php)
+//   - http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
+//   - https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+var ansiRegexReference = regexp.MustCompile("(?:\x1b[\\[()][0-9;:]*[a-zA-Z@]|\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)")
 
 func testParserReference(t testing.TB, str string) {
 	t.Helper()
@@ -36,7 +37,7 @@ func testParserReference(t testing.TB, str string) {
 	s := str
 	for i := 0; ; i++ {
 		got := toSlice(nextAnsiEscapeSequence(s))
-		exp := ansiRegexRefence.FindStringIndex(s)
+		exp := ansiRegexReference.FindStringIndex(s)
 
 		equal := len(got) == len(exp)
 		if equal {
@@ -207,7 +208,7 @@ func TestExtractColor(t *testing.T) {
 		if output != "hello world" {
 			t.Errorf("Invalid output: %s %v", output, []rune(output))
 		}
-		fmt.Println(src, ansiOffsets, clean)
+		t.Log(src, ansiOffsets, clean)
 		assertion(ansiOffsets, state)
 	}
 
@@ -347,6 +348,9 @@ func TestAnsiCodeStringConversion(t *testing.T) {
 	}
 	assert("\x1b[m", nil, "")
 	assert("\x1b[m", &ansiState{attr: tui.Blink, lbg: -1}, "")
+	assert("\x1b[0m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
+	assert("\x1b[;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
+	assert("\x1b[;;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
 
 	assert("\x1b[31m", nil, "\x1b[31;49m")
 	assert("\x1b[41m", nil, "\x1b[39;41m")
@@ -357,6 +361,7 @@ func TestAnsiCodeStringConversion(t *testing.T) {
 	assert("\x1b[31m", &ansiState{fg: 4, bg: 4, lbg: -1}, "\x1b[31;44m")
 	assert("\x1b[1;2;31m", &ansiState{fg: 2, bg: -1, attr: tui.Reverse, lbg: -1}, "\x1b[1;2;7;31;49m")
 	assert("\x1b[38;5;100;48;5;200m", nil, "\x1b[38;5;100;48;5;200m")
+	assert("\x1b[38:5:100:48:5:200m", nil, "\x1b[38;5;100;48;5;200m")
 	assert("\x1b[48;5;100;38;5;200m", nil, "\x1b[38;5;200;48;5;100m")
 	assert("\x1b[48;5;100;38;2;10;20;30;1m", nil, "\x1b[1;38;2;10;20;30;48;5;100m")
 	assert("\x1b[48;5;100;38;2;10;20;30;7m",
@@ -376,7 +381,7 @@ func TestParseAnsiCode(t *testing.T) {
 		{"-2", "", -1},
 	}
 	for _, x := range tests {
-		n, s := parseAnsiCode(x.In)
+		n, _, s := parseAnsiCode(x.In, 0)
 		if n != x.N || s != x.Exp {
 			t.Fatalf("%q: got: (%d %q) want: (%d %q)", x.In, n, s, x.N, x.Exp)
 		}
@@ -384,9 +389,9 @@ func TestParseAnsiCode(t *testing.T) {
 }
 
 // kernel/bpf/preload/iterators/README
-const ansiBenchmarkString = "\x1b[38;5;81m\x1b[01;31m\x1b[Kkernel/\x1b[0m\x1b[38;5;81mbpf/" +
-	"\x1b[0m\x1b[38;5;81mpreload/\x1b[0m\x1b[38;5;81miterators/" +
-	"\x1b[0m\x1b[38;5;149mMakefile\x1b[m\x1b[K\x1b[0m"
+const ansiBenchmarkString = "\x1b[38;5;81m\x1b[01;31m\x1b[Kkernel/\x1b[0m\x1b[38:5:81mbpf/" +
+	"\x1b[0m\x1b[38:5:81mpreload/\x1b[0m\x1b[38;5;81miterators/" +
+	"\x1b[0m\x1b[38:5:149mMakefile\x1b[m\x1b[K\x1b[0m"
 
 func BenchmarkNextAnsiEscapeSequence(b *testing.B) {
 	b.SetBytes(int64(len(ansiBenchmarkString)))
@@ -409,7 +414,7 @@ func BenchmarkNextAnsiEscapeSequence_Regex(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		s := ansiBenchmarkString
 		for {
-			a := ansiRegexRefence.FindStringIndex(s)
+			a := ansiRegexReference.FindStringIndex(s)
 			if len(a) == 0 {
 				break
 			}

src/constants.go

@@ -2,7 +2,6 @@ package fzf
 
 import (
 	"math"
-	"os"
 	"time"
 
 	"github.com/junegunn/fzf/src/util"
@@ -15,6 +14,7 @@ const (
 
 	// Reader
 	readerBufferSize       = 64 * 1024
+	readerSlabSize         = 128 * 1024
 	readerPollIntervalMin  = 10 * time.Millisecond
 	readerPollIntervalStep = 5 * time.Millisecond
 	readerPollIntervalMax  = 50 * time.Millisecond
@@ -54,16 +54,6 @@ const (
 	defaultJumpLabels string = "asdfghjklqwertyuiopzxcvbnm1234567890ASDFGHJKLQWERTYUIOPZXCVBNM`~;:,<.>/?'\"!@#$%^&*()[{]}-_=+"
 )
 
-var defaultCommand string
-
-func init() {
-	if !util.IsWindows() {
-		defaultCommand = `set -o pipefail; command find -L . -mindepth 1 \( -path '*/\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \) -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-`
-	} else if os.Getenv("TERM") == "cygwin" {
-		defaultCommand = `sh -c "command find -L . -mindepth 1 -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-"`
-	}
-}
-
 // fzf events
 const (
 	EvtReadNew util.EventType = iota

src/core.go

@@ -1,34 +1,11 @@
-/*
-Package fzf implements fzf, a command-line fuzzy finder.
-
-The MIT License (MIT)
-
-Copyright (c) 2013-2021 Junegunn Choi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
+// Package fzf implements fzf, a command-line fuzzy finder.
 package fzf
 
 import (
 	"fmt"
-	"os"
+	"sync"
 	"time"
+	"unsafe"
 
 	"github.com/junegunn/fzf/src/util"
 )
@@ -42,8 +19,18 @@ Matcher  -> EvtSearchFin      -> Terminal (update list)
 Matcher  -> EvtHeader         -> Terminal (update header)
 */
 
+func ustring(data []byte) string {
+	return unsafe.String(unsafe.SliceData(data), len(data))
+}
+
+func sbytes(data string) []byte {
+	return unsafe.Slice(unsafe.StringData(data), len(data))
+}
+
 // Run starts fzf
 func Run(opts *Options, version string, revision string) {
+	defer util.RunAtExitFuncs()
+
 	sort := opts.Sort > 0
 	sortCriteria = opts.Criteria
 
@@ -53,7 +40,7 @@ func Run(opts *Options, version string, revision string) {
 		} else {
 			fmt.Println(version)
 		}
-		os.Exit(exitOk)
+		util.Exit(exitOk)
 	}
 
 	// Event channel
@@ -69,16 +56,16 @@ func Run(opts *Options, version string, revision string) {
 		if opts.Theme.Colored {
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				prevLineAnsiState = lineAnsiState
-				trimmed, offsets, newState := extractColor(string(data), lineAnsiState, nil)
+				trimmed, offsets, newState := extractColor(ustring(data), lineAnsiState, nil)
 				lineAnsiState = newState
-				return util.ToChars([]byte(trimmed)), offsets
+				return util.ToChars(sbytes(trimmed)), offsets
 			}
 		} else {
 			// When color is disabled but ansi option is given,
 			// we simply strip out ANSI codes from the input
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
-				trimmed, _, _ := extractColor(string(data), nil, nil)
-				return util.ToChars([]byte(trimmed)), nil
+				trimmed, _, _ := extractColor(ustring(data), nil, nil)
+				return util.ToChars(sbytes(trimmed)), nil
 			}
 		}
 	}
@@ -90,7 +77,7 @@ func Run(opts *Options, version string, revision string) {
 	if len(opts.WithNth) == 0 {
 		chunkList = NewChunkList(func(item *Item, data []byte) bool {
 			if len(header) < opts.HeaderLines {
-				header = append(header, string(data))
+				header = append(header, ustring(data))
 				eventBox.Set(EvtHeader, header)
 				return false
 			}
@@ -101,7 +88,7 @@ func Run(opts *Options, version string, revision string) {
 		})
 	} else {
 		chunkList = NewChunkList(func(item *Item, data []byte) bool {
-			tokens := Tokenize(string(data), opts.Delimiter)
+			tokens := Tokenize(ustring(data), opts.Delimiter)
 			if opts.Ansi && opts.Theme.Colored && len(tokens) > 1 {
 				var ansiState *ansiState
 				if prevLineAnsiState != nil {
@@ -125,7 +112,7 @@ func Run(opts *Options, version string, revision string) {
 				eventBox.Set(EvtHeader, header)
 				return false
 			}
-			item.text, item.colors = ansiProcessor([]byte(transformed))
+			item.text, item.colors = ansiProcessor(sbytes(transformed))
 			item.text.TrimTrailingWhitespaces()
 			item.text.Index = itemIndex
 			item.origText = &data
@@ -141,26 +128,30 @@ func Run(opts *Options, version string, revision string) {
 		reader = NewReader(func(data []byte) bool {
 			return chunkList.Push(data)
 		}, eventBox, opts.ReadZero, opts.Filter == nil)
-		go reader.ReadSource()
+		go reader.ReadSource(opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
 	}
 
 	// Matcher
 	forward := true
-	for _, cri := range opts.Criteria[1:] {
-		if cri == byEnd {
+	withPos := false
+	for idx := len(opts.Criteria) - 1; idx > 0; idx-- {
+		switch opts.Criteria[idx] {
+		case byChunk:
+			withPos = true
+		case byEnd:
 			forward = false
-			break
-		}
-		if cri == byBegin {
-			break
+		case byBegin:
+			forward = true
 		}
 	}
 	patternBuilder := func(runes []rune) *Pattern {
 		return BuildPattern(
-			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward,
+			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward, withPos,
 			opts.Filter == nil, opts.Nth, opts.Delimiter, runes)
 	}
-	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)
+	inputRevision := 0
+	snapshotRevision := 0
+	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox, inputRevision)
 
 	// Filtering mode
 	if opts.Filter != nil {
@@ -174,18 +165,21 @@ func Run(opts *Options, version string, revision string) {
 		found := false
 		if streamingFilter {
 			slab := util.MakeSlab(slab16Size, slab32Size)
+			mutex := sync.Mutex{}
 			reader := NewReader(
 				func(runes []byte) bool {
 					item := Item{}
 					if chunkList.trans(&item, runes) {
+						mutex.Lock()
 						if result, _, _ := pattern.MatchItem(&item, false, slab); result != nil {
 							opts.Printer(item.text.ToString())
 							found = true
 						}
+						mutex.Unlock()
 					}
 					return false
 				}, eventBox, opts.ReadZero, false)
-			reader.ReadSource()
+			reader.ReadSource(opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
 		} else {
 			eventBox.Unwatch(EvtReadNew)
 			eventBox.WaitFor(EvtReadFin)
@@ -200,9 +194,9 @@ func Run(opts *Options, version string, revision string) {
 			}
 		}
 		if found {
-			os.Exit(exitOk)
+			util.Exit(exitOk)
 		}
-		os.Exit(exitNoMatch)
+		util.Exit(exitNoMatch)
 	}
 
 	// Synchronous search
@@ -216,28 +210,51 @@ func Run(opts *Options, version string, revision string) {
 
 	// Terminal I/O
 	terminal := NewTerminal(opts, eventBox)
+	maxFit := 0 // Maximum number of items that can fit on screen
+	padHeight := 0
+	heightUnknown := opts.Height.auto
+	if heightUnknown {
+		maxFit, padHeight = terminal.MaxFitAndPad()
+	}
 	deferred := opts.Select1 || opts.Exit0
 	go terminal.Loop()
-	if !deferred {
-		terminal.startChan <- true
+	if !deferred && !heightUnknown {
+		// Start right away
+		terminal.startChan <- fitpad{-1, -1}
 	}
 
 	// Event coordination
 	reading := true
-	clearCache := util.Once(false)
-	clearSelection := util.Once(false)
 	ticks := 0
 	var nextCommand *string
-	restart := func(command string) {
-		reading = true
-		clearCache = util.Once(true)
-		clearSelection = util.Once(true)
-		chunkList.Clear()
-		header = make([]string, 0, opts.HeaderLines)
-		go reader.restart(command)
-	}
+	var nextEnviron []string
 	eventBox.Watch(EvtReadNew)
+	total := 0
 	query := []rune{}
+	determine := func(final bool) {
+		if heightUnknown {
+			if total >= maxFit || final {
+				deferred = false
+				heightUnknown = false
+				terminal.startChan <- fitpad{util.Min(total, maxFit), padHeight}
+			}
+		} else if deferred {
+			deferred = false
+			terminal.startChan <- fitpad{-1, -1}
+		}
+	}
+
+	useSnapshot := false
+	var snapshot []*Chunk
+	var count int
+	restart := func(command string, environ []string) {
+		reading = true
+		chunkList.Clear()
+		itemIndex = 0
+		inputRevision++
+		header = make([]string, 0, opts.HeaderLines)
+		go reader.restart(command, environ)
+	}
 	for {
 		delay := true
 		ticks++
@@ -258,41 +275,75 @@ func Run(opts *Options, version string, revision string) {
 					if reading {
 						reader.terminate()
 					}
-					os.Exit(value.(int))
+					util.Exit(value.(int))
 				case EvtReadNew, EvtReadFin:
 					if evt == EvtReadFin && nextCommand != nil {
-						restart(*nextCommand)
+						restart(*nextCommand, nextEnviron)
 						nextCommand = nil
+						nextEnviron = nil
 						break
 					} else {
 						reading = reading && evt == EvtReadNew
 					}
-					snapshot, count := chunkList.Snapshot()
-					terminal.UpdateCount(count, !reading, value.(*string))
-					if opts.Sync {
-						opts.Sync = false
-						terminal.UpdateList(PassMerger(&snapshot, opts.Tac), false)
+					if useSnapshot && evt == EvtReadFin {
+						useSnapshot = false
 					}
-					matcher.Reset(snapshot, input(), false, !reading, sort, clearCache())
+					if !useSnapshot {
+						if snapshotRevision != inputRevision {
+							query = []rune{}
+						}
+						snapshot, count = chunkList.Snapshot()
+						snapshotRevision = inputRevision
+					}
+					total = count
+					terminal.UpdateCount(total, !reading, value.(*string))
+					if opts.Sync {
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac, snapshotRevision), false)
+					}
+					if heightUnknown && !deferred {
+						determine(!reading)
+					}
+					matcher.Reset(snapshot, input(), false, !reading, sort, snapshotRevision)
 
 				case EvtSearchNew:
 					var command *string
+					var environ []string
+					var changed bool
 					switch val := value.(type) {
 					case searchRequest:
 						sort = val.sort
 						command = val.command
+						environ = val.environ
+						changed = val.changed
+						if command != nil {
+							useSnapshot = val.sync
+						}
 					}
 					if command != nil {
 						if reading {
 							reader.terminate()
 							nextCommand = command
+							nextEnviron = environ
 						} else {
-							restart(*command)
+							restart(*command, environ)
 						}
+					}
+					if !changed {
 						break
 					}
-					snapshot, _ := chunkList.Snapshot()
-					matcher.Reset(snapshot, input(), true, !reading, sort, clearCache())
+					if !useSnapshot {
+						newSnapshot, newCount := chunkList.Snapshot()
+						// We want to avoid showing empty list when reload is triggered
+						// and the query string is changed at the same time i.e. command != nil && changed
+						if command == nil || newCount > 0 {
+							if snapshotRevision != inputRevision {
+								query = []rune{}
+							}
+							snapshot = newSnapshot
+							snapshotRevision = inputRevision
+						}
+					}
+					matcher.Reset(snapshot, input(), true, !reading, sort, snapshotRevision)
 					delay = false
 
 				case EvtSearchProgress:
@@ -312,8 +363,7 @@ func Run(opts *Options, version string, revision string) {
 						if deferred {
 							count := val.Length()
 							if opts.Select1 && count > 1 || opts.Exit0 && !opts.Select1 && count > 0 {
-								deferred = false
-								terminal.startChan <- true
+								determine(val.final)
 							} else if val.final {
 								if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
 									if opts.PrintQuery {
@@ -326,15 +376,14 @@ func Run(opts *Options, version string, revision string) {
 										opts.Printer(val.Get(i).item.AsString(opts.Ansi))
 									}
 									if count > 0 {
-										os.Exit(exitOk)
+										util.Exit(exitOk)
 									}
-									os.Exit(exitNoMatch)
+									util.Exit(exitNoMatch)
 								}
-								deferred = false
-								terminal.startChan <- true
+								determine(val.final)
 							}
 						}
-						terminal.UpdateList(val, clearSelection())
+						terminal.UpdateList(val, true)
 					}
 				}
 			}

src/history.go

@@ -2,7 +2,6 @@ package fzf
 
 import (
 	"errors"
-	"io/ioutil"
 	"os"
 	"strings"
 )
@@ -26,12 +25,12 @@ func NewHistory(path string, maxSize int) (*History, error) {
 	}
 
 	// Read history file
-	data, err := ioutil.ReadFile(path)
+	data, err := os.ReadFile(path)
 	if err != nil {
 		// If it doesn't exist, check if we can create a file with the name
 		if os.IsNotExist(err) {
 			data = []byte{}
-			if err := ioutil.WriteFile(path, data, 0600); err != nil {
+			if err := os.WriteFile(path, data, 0600); err != nil {
 				return nil, fmtError(err)
 			}
 		} else {
@@ -62,11 +61,11 @@ func (h *History) append(line string) error {
 		lines = lines[len(lines)-h.maxSize:]
 	}
 	h.lines = append(lines, "")
-	return ioutil.WriteFile(h.path, []byte(strings.Join(h.lines, "\n")), 0600)
+	return os.WriteFile(h.path, []byte(strings.Join(h.lines, "\n")), 0600)
 }
 
 func (h *History) override(str string) {
-	// You can update the history but they're not written to the file
+	// You can update the history, but they're not written to the file
 	if h.cursor == len(h.lines)-1 {
 		h.lines[h.cursor] = str
 	} else if h.cursor < len(h.lines)-1 {

src/history_test.go

@@ -1,7 +1,6 @@
 package fzf
 
 import (
-	"io/ioutil"
 	"os"
 	"runtime"
 	"testing"
@@ -25,7 +24,7 @@ func TestHistory(t *testing.T) {
 		}
 	}
 
-	f, _ := ioutil.TempFile("", "fzf-history")
+	f, _ := os.CreateTemp("", "fzf-history")
 	f.Close()
 
 	{ // Append lines

src/matcher.go

@@ -12,11 +12,11 @@ import (
 
 // MatchRequest represents a search request
 type MatchRequest struct {
-	chunks     []*Chunk
-	pattern    *Pattern
-	final      bool
-	sort       bool
-	clearCache bool
+	chunks   []*Chunk
+	pattern  *Pattern
+	final    bool
+	sort     bool
+	revision int
 }
 
 // Matcher is responsible for performing search
@@ -29,6 +29,7 @@ type Matcher struct {
 	partitions     int
 	slab           []*util.Slab
 	mergerCache    map[string]*Merger
+	revision       int
 }
 
 const (
@@ -38,7 +39,7 @@ const (
 
 // NewMatcher returns a new Matcher
 func NewMatcher(patternBuilder func([]rune) *Pattern,
-	sort bool, tac bool, eventBox *util.EventBox) *Matcher {
+	sort bool, tac bool, eventBox *util.EventBox, revision int) *Matcher {
 	partitions := util.Min(numPartitionsMultiplier*runtime.NumCPU(), maxPartitions)
 	return &Matcher{
 		patternBuilder: patternBuilder,
@@ -48,7 +49,8 @@ func NewMatcher(patternBuilder func([]rune) *Pattern,
 		reqBox:         util.NewEventBox(),
 		partitions:     partitions,
 		slab:           make([]*util.Slab, partitions),
-		mergerCache:    make(map[string]*Merger)}
+		mergerCache:    make(map[string]*Merger),
+		revision:       revision}
 }
 
 // Loop puts Matcher in action
@@ -70,8 +72,9 @@ func (m *Matcher) Loop() {
 			events.Clear()
 		})
 
-		if request.sort != m.sort || request.clearCache {
+		if request.sort != m.sort || request.revision != m.revision {
 			m.sort = request.sort
+			m.revision = request.revision
 			m.mergerCache = make(map[string]*Merger)
 			clearChunkCache()
 		}
@@ -140,11 +143,11 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 
 	numChunks := len(request.chunks)
 	if numChunks == 0 {
-		return EmptyMerger, false
+		return EmptyMerger(request.revision), false
 	}
 	pattern := request.pattern
 	if pattern.IsEmpty() {
-		return PassMerger(&request.chunks, m.tac), false
+		return PassMerger(&request.chunks, m.tac, request.revision), false
 	}
 
 	cancelled := util.NewAtomicBool(false)
@@ -218,11 +221,11 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}
-	return NewMerger(pattern, partialResults, m.sort, m.tac), false
+	return NewMerger(pattern, partialResults, m.sort, m.tac, request.revision), false
 }
 
 // Reset is called to interrupt/signal the ongoing search
-func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool, clearCache bool) {
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool, revision int) {
 	pattern := m.patternBuilder(patternRunes)
 
 	var event util.EventType
@@ -231,5 +234,5 @@ func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final
 	} else {
 		event = reqRetry
 	}
-	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, clearCache})
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, revision})
 }

src/merger.go

@@ -3,30 +3,36 @@ package fzf
 import "fmt"
 
 // EmptyMerger is a Merger with no data
-var EmptyMerger = NewMerger(nil, [][]Result{}, false, false)
+func EmptyMerger(revision int) *Merger {
+	return NewMerger(nil, [][]Result{}, false, false, revision)
+}
 
 // Merger holds a set of locally sorted lists of items and provides the view of
 // a single, globally-sorted list
 type Merger struct {
-	pattern *Pattern
-	lists   [][]Result
-	merged  []Result
-	chunks  *[]*Chunk
-	cursors []int
-	sorted  bool
-	tac     bool
-	final   bool
-	count   int
+	pattern  *Pattern
+	lists    [][]Result
+	merged   []Result
+	chunks   *[]*Chunk
+	cursors  []int
+	sorted   bool
+	tac      bool
+	final    bool
+	count    int
+	pass     bool
+	revision int
 }
 
 // PassMerger returns a new Merger that simply returns the items in the
 // original order
-func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
+func PassMerger(chunks *[]*Chunk, tac bool, revision int) *Merger {
 	mg := Merger{
-		pattern: nil,
-		chunks:  chunks,
-		tac:     tac,
-		count:   0}
+		pattern:  nil,
+		chunks:   chunks,
+		tac:      tac,
+		count:    0,
+		pass:     true,
+		revision: revision}
 
 	for _, chunk := range *mg.chunks {
 		mg.count += chunk.count
@@ -35,17 +41,18 @@ func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
 }
 
 // NewMerger returns a new Merger
-func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool) *Merger {
+func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revision int) *Merger {
 	mg := Merger{
-		pattern: pattern,
-		lists:   lists,
-		merged:  []Result{},
-		chunks:  nil,
-		cursors: make([]int, len(lists)),
-		sorted:  sorted,
-		tac:     tac,
-		final:   false,
-		count:   0}
+		pattern:  pattern,
+		lists:    lists,
+		merged:   []Result{},
+		chunks:   nil,
+		cursors:  make([]int, len(lists)),
+		sorted:   sorted,
+		tac:      tac,
+		final:    false,
+		count:    0,
+		revision: revision}
 
 	for _, list := range mg.lists {
 		mg.count += len(list)
@@ -53,11 +60,42 @@ func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool) *Merge
 	return &mg
 }
 
+// Revision returns revision number
+func (mg *Merger) Revision() int {
+	return mg.revision
+}
+
 // Length returns the number of items
 func (mg *Merger) Length() int {
 	return mg.count
 }
 
+func (mg *Merger) First() Result {
+	if mg.tac && !mg.sorted {
+		return mg.Get(mg.count - 1)
+	}
+	return mg.Get(0)
+}
+
+// FindIndex returns the index of the item with the given item index
+func (mg *Merger) FindIndex(itemIndex int32) int {
+	index := -1
+	if mg.pass {
+		index = int(itemIndex)
+		if mg.tac {
+			index = mg.count - index - 1
+		}
+	} else {
+		for i := 0; i < mg.count; i++ {
+			if mg.Get(i).item.Index() == itemIndex {
+				index = i
+				break
+			}
+		}
+	}
+	return index
+}
+
 // Get returns the pointer to the Result object indexed by the given integer
 func (mg *Merger) Get(idx int) Result {
 	if mg.chunks != nil {

src/merger_test.go

@@ -23,10 +23,10 @@ func randResult() Result {
 }
 
 func TestEmptyMerger(t *testing.T) {
-	assert(t, EmptyMerger.Length() == 0, "Not empty")
-	assert(t, EmptyMerger.count == 0, "Invalid count")
-	assert(t, len(EmptyMerger.lists) == 0, "Invalid lists")
-	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
+	assert(t, EmptyMerger(0).Length() == 0, "Not empty")
+	assert(t, EmptyMerger(0).count == 0, "Invalid count")
+	assert(t, len(EmptyMerger(0).lists) == 0, "Invalid lists")
+	assert(t, len(EmptyMerger(0).merged) == 0, "Invalid merged list")
 }
 
 func buildLists(partiallySorted bool) ([][]Result, []Result) {
@@ -57,7 +57,7 @@ func TestMergerUnsorted(t *testing.T) {
 	cnt := len(items)
 
 	// Not sorted: same order
-	mg := NewMerger(nil, lists, false, false)
+	mg := NewMerger(nil, lists, false, false, 0)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	for i := 0; i < cnt; i++ {
 		assert(t, items[i] == mg.Get(i), "Invalid Get")
@@ -69,7 +69,7 @@ func TestMergerSorted(t *testing.T) {
 	cnt := len(items)
 
 	// Sorted sorted order
-	mg := NewMerger(nil, lists, true, false)
+	mg := NewMerger(nil, lists, true, false, 0)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	sort.Sort(ByRelevance(items))
 	for i := 0; i < cnt; i++ {
@@ -79,7 +79,7 @@ func TestMergerSorted(t *testing.T) {
 	}
 
 	// Inverse order
-	mg2 := NewMerger(nil, lists, true, false)
+	mg2 := NewMerger(nil, lists, true, false, 0)
 	for i := cnt - 1; i >= 0; i-- {
 		if items[i] != mg2.Get(i) {
 			t.Error("Not sorted", items[i], mg2.Get(i))

src/options_no_pprof.go

@@ -0,0 +1,11 @@
+//go:build !pprof
+// +build !pprof
+
+package fzf
+
+func (o *Options) initProfiling() error {
+	if o.CPUProfile != "" || o.MEMProfile != "" || o.BlockProfile != "" || o.MutexProfile != "" {
+		errorExit("error: profiling not supported: FZF must be built with '-tags=pprof' to enable profiling")
+	}
+	return nil
+}

src/options_pprof.go

@@ -0,0 +1,73 @@
+//go:build pprof
+// +build pprof
+
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"runtime/pprof"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func (o *Options) initProfiling() error {
+	if o.CPUProfile != "" {
+		f, err := os.Create(o.CPUProfile)
+		if err != nil {
+			return fmt.Errorf("could not create CPU profile: %w", err)
+		}
+
+		if err := pprof.StartCPUProfile(f); err != nil {
+			return fmt.Errorf("could not start CPU profile: %w", err)
+		}
+
+		util.AtExit(func() {
+			pprof.StopCPUProfile()
+			if err := f.Close(); err != nil {
+				fmt.Fprintln(os.Stderr, "Error: closing cpu profile:", err)
+			}
+		})
+	}
+
+	stopProfile := func(name string, f *os.File) {
+		if err := pprof.Lookup(name).WriteTo(f, 0); err != nil {
+			fmt.Fprintf(os.Stderr, "Error: could not write %s profile: %v\n", name, err)
+		}
+		if err := f.Close(); err != nil {
+			fmt.Fprintf(os.Stderr, "Error: closing %s profile: %v\n", name, err)
+		}
+	}
+
+	if o.MEMProfile != "" {
+		f, err := os.Create(o.MEMProfile)
+		if err != nil {
+			return fmt.Errorf("could not create MEM profile: %w", err)
+		}
+		util.AtExit(func() {
+			runtime.GC()
+			stopProfile("allocs", f)
+		})
+	}
+
+	if o.BlockProfile != "" {
+		runtime.SetBlockProfileRate(1)
+		f, err := os.Create(o.BlockProfile)
+		if err != nil {
+			return fmt.Errorf("could not create BLOCK profile: %w", err)
+		}
+		util.AtExit(func() { stopProfile("block", f) })
+	}
+
+	if o.MutexProfile != "" {
+		runtime.SetMutexProfileFraction(1)
+		f, err := os.Create(o.MutexProfile)
+		if err != nil {
+			return fmt.Errorf("could not create MUTEX profile: %w", err)
+		}
+		util.AtExit(func() { stopProfile("mutex", f) })
+	}
+
+	return nil
+}

src/options_pprof_test.go

@@ -0,0 +1,89 @@
+//go:build pprof
+// +build pprof
+
+package fzf
+
+import (
+	"bytes"
+	"flag"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+// runInitProfileTests is an internal flag used TestInitProfiling
+var runInitProfileTests = flag.Bool("test-init-profile", false, "run init profile tests")
+
+func TestInitProfiling(t *testing.T) {
+	if testing.Short() {
+		t.Skip("short test")
+	}
+
+	// Run this test in a separate process since it interferes with
+	// profiling and modifies the global atexit state. Without this
+	// running `go test -bench . -cpuprofile cpu.out` will fail.
+	if !*runInitProfileTests {
+		t.Parallel()
+
+		// Make sure we are not the child process.
+		if os.Getenv("_FZF_CHILD_PROC") != "" {
+			t.Fatal("already running as child process!")
+		}
+
+		cmd := exec.Command(os.Args[0],
+			"-test.timeout", "30s",
+			"-test.run", "^"+t.Name()+"$",
+			"-test-init-profile",
+		)
+		cmd.Env = append(os.Environ(), "_FZF_CHILD_PROC=1")
+
+		out, err := cmd.CombinedOutput()
+		out = bytes.TrimSpace(out)
+		if err != nil {
+			t.Fatalf("Child test process failed: %v:\n%s", err, out)
+		}
+		// Make sure the test actually ran
+		if bytes.Contains(out, []byte("no tests to run")) {
+			t.Fatalf("Failed to run test %q:\n%s", t.Name(), out)
+		}
+		return
+	}
+
+	// Child process
+
+	tempdir := t.TempDir()
+	t.Cleanup(util.RunAtExitFuncs)
+
+	o := Options{
+		CPUProfile:   filepath.Join(tempdir, "cpu.prof"),
+		MEMProfile:   filepath.Join(tempdir, "mem.prof"),
+		BlockProfile: filepath.Join(tempdir, "block.prof"),
+		MutexProfile: filepath.Join(tempdir, "mutex.prof"),
+	}
+	if err := o.initProfiling(); err != nil {
+		t.Fatal(err)
+	}
+
+	profiles := []string{
+		o.CPUProfile,
+		o.MEMProfile,
+		o.BlockProfile,
+		o.MutexProfile,
+	}
+	for _, name := range profiles {
+		if _, err := os.Stat(name); err != nil {
+			t.Errorf("Failed to create profile %s: %v", filepath.Base(name), err)
+		}
+	}
+
+	util.RunAtExitFuncs()
+
+	for _, name := range profiles {
+		if _, err := os.Stat(name); err != nil {
+			t.Errorf("Failed to write profile %s: %v", filepath.Base(name), err)
+		}
+	}
+}

src/options_test.go

@@ -2,7 +2,7 @@ package fzf
 
 import (
 	"fmt"
-	"io/ioutil"
+	"os"
 	"testing"
 
 	"github.com/junegunn/fzf/src/tui"
@@ -65,6 +65,19 @@ func TestDelimiterRegexRegex(t *testing.T) {
 	}
 }
 
+func TestDelimiterRegexRegexCaret(t *testing.T) {
+	delim := delimiterRegexp(`(^\s*|\s+)`)
+	tokens := Tokenize("foo  bar baz", delim)
+	if delim.str != nil ||
+		len(tokens) != 4 ||
+		tokens[0].text.ToString() != "" ||
+		tokens[1].text.ToString() != "foo  " ||
+		tokens[2].text.ToString() != "bar " ||
+		tokens[3].text.ToString() != "baz" {
+		t.Errorf("%s %d", tokens, len(tokens))
+	}
+}
+
 func TestSplitNth(t *testing.T) {
 	{
 		ranges := splitNth("..")
@@ -157,8 +170,8 @@ func TestParseKeys(t *testing.T) {
 	check(tui.CtrlM, "Return")
 	checkEvent(tui.Key(' '), "space")
 	check(tui.Tab, "tab")
-	check(tui.BTab, "btab")
-	check(tui.ESC, "esc")
+	check(tui.ShiftTab, "btab")
+	check(tui.Esc, "esc")
 	check(tui.Up, "up")
 	check(tui.Down, "down")
 	check(tui.Left, "left")
@@ -169,16 +182,16 @@ func TestParseKeys(t *testing.T) {
 		t.Error(11)
 	}
 	check(tui.Tab, "Ctrl-I")
-	check(tui.PgUp, "page-up")
-	check(tui.PgDn, "Page-Down")
+	check(tui.PageUp, "page-up")
+	check(tui.PageDown, "Page-Down")
 	check(tui.Home, "Home")
 	check(tui.End, "End")
-	check(tui.AltBS, "Alt-BSpace")
-	check(tui.SLeft, "shift-left")
-	check(tui.SRight, "shift-right")
-	check(tui.BTab, "shift-tab")
+	check(tui.AltBackspace, "Alt-BSpace")
+	check(tui.ShiftLeft, "shift-left")
+	check(tui.ShiftRight, "shift-right")
+	check(tui.ShiftTab, "shift-tab")
 	check(tui.CtrlM, "Enter")
-	check(tui.BSpace, "bspace")
+	check(tui.Backspace, "bspace")
 }
 
 func TestParseKeysWithComma(t *testing.T) {
@@ -249,13 +262,17 @@ func TestBind(t *testing.T) {
 		}
 	}
 	check(tui.CtrlA.AsEvent(), "", actBeginningOfLine)
+	errorString := ""
+	errorFn := func(e string) {
+		errorString = e
+	}
 	parseKeymap(keymap,
 		"ctrl-a:kill-line,ctrl-b:toggle-sort+up+down,c:page-up,alt-z:page-down,"+
-			"f1:execute(ls {+})+abort+execute(echo {+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
+			"f1:execute(ls {+})+abort+execute(echo \n{+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
 			"alt-a:execute-Multi@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};,"+
 			"x:Execute(foo+bar),X:execute/bar+baz/"+
 			",f1:+first,f1:+top"+
-			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up")
+			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up", errorFn)
 	check(tui.CtrlA.AsEvent(), "", actKillLine)
 	check(tui.CtrlB.AsEvent(), "", actToggleSort, actUp, actDown)
 	check(tui.Key('c'), "", actPageUp)
@@ -273,12 +290,15 @@ func TestBind(t *testing.T) {
 	check(tui.Key('+'), "++\nfoobar,Y:execute(baz)+up", actExecute)
 
 	for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} {
-		parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
+		parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char), errorFn)
 		check(tui.Key([]rune(fmt.Sprintf("%d", idx%10))[0]), "foobar", actExecute)
 	}
 
-	parseKeymap(keymap, "f1:abort")
+	parseKeymap(keymap, "f1:abort", errorFn)
 	check(tui.F1.AsEvent(), "", actAbort)
+	if len(errorString) > 0 {
+		t.Errorf("error parsing keymap: %s", errorString)
+	}
 }
 
 func TestColorSpec(t *testing.T) {
@@ -337,14 +357,14 @@ func TestDefaultCtrlNP(t *testing.T) {
 	check([]string{"--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
 	check([]string{"--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
 
-	f, _ := ioutil.TempFile("", "fzf-history")
+	f, _ := os.CreateTemp("", "fzf-history")
 	f.Close()
 	hist := "--history=" + f.Name()
 	check([]string{hist}, tui.CtrlN, actNextHistory)
-	check([]string{hist}, tui.CtrlP, actPreviousHistory)
+	check([]string{hist}, tui.CtrlP, actPrevHistory)
 
 	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
-	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlP, actPreviousHistory)
+	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlP, actPrevHistory)
 
 	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlN, actNextHistory)
 	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
@@ -440,8 +460,6 @@ func TestValidateSign(t *testing.T) {
 		{"😀", true},
 		{"", false},
 		{">>>", false},
-		{"\n", false},
-		{"\t", false},
 	}
 
 	for _, testCase := range testCases {
@@ -455,3 +473,38 @@ func TestValidateSign(t *testing.T) {
 		}
 	}
 }
+
+func TestParseSingleActionList(t *testing.T) {
+	actions := parseSingleActionList("Execute@foo+bar,baz@+up+up+reload:down+down", func(string) {})
+	if len(actions) != 4 {
+		t.Errorf("Invalid number of actions parsed:%d", len(actions))
+	}
+	if actions[0].t != actExecute || actions[0].a != "foo+bar,baz" {
+		t.Errorf("Invalid action parsed: %v", actions[0])
+	}
+	if actions[1].t != actUp || actions[2].t != actUp {
+		t.Errorf("Invalid action parsed: %v / %v", actions[1], actions[2])
+	}
+	if actions[3].t != actReload || actions[3].a != "down+down" {
+		t.Errorf("Invalid action parsed: %v", actions[3])
+	}
+}
+
+func TestParseSingleActionListError(t *testing.T) {
+	err := ""
+	parseSingleActionList("change-query(foobar)baz", func(e string) {
+		err = e
+	})
+	if len(err) == 0 {
+		t.Errorf("Failed to detect error")
+	}
+}
+
+func TestMaskActionContents(t *testing.T) {
+	original := ":execute((f)(o)(o)(b)(a)(r))+change-query@qu@ry@+up,x:reload:hello:world"
+	expected := ":execute                    +change-query       +up,x:reload            "
+	masked := maskActionContents(original)
+	if masked != expected {
+		t.Errorf("Not masked: %s", masked)
+	}
+}

src/pattern.go

@@ -51,6 +51,7 @@ type Pattern struct {
 	caseSensitive bool
 	normalize     bool
 	forward       bool
+	withPos       bool
 	text          []rune
 	termSets      []termSet
 	sortable      bool
@@ -85,7 +86,7 @@ func clearChunkCache() {
 
 // BuildPattern builds Pattern object from the given arguments
 func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
-	cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
+	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
 
 	var asString string
 	if extended {
@@ -145,6 +146,7 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 		caseSensitive: caseSensitive,
 		normalize:     normalize,
 		forward:       forward,
+		withPos:       withPos,
 		text:          []rune(asString),
 		termSets:      termSets,
 		sortable:      sortable,
@@ -207,11 +209,10 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 			// Flip exactness
 			if fuzzy && !inv {
 				typ = termExact
-				text = text[1:]
 			} else {
 				typ = termFuzzy
-				text = text[1:]
 			}
+			text = text[1:]
 		} else if strings.HasPrefix(text, "^") {
 			if typ == termSuffix {
 				typ = termEqual
@@ -302,13 +303,13 @@ func (p *Pattern) matchChunk(chunk *Chunk, space []Result, slab *util.Slab) []Re
 
 	if space == nil {
 		for idx := 0; idx < chunk.count; idx++ {
-			if match, _, _ := p.MatchItem(&chunk.items[idx], false, slab); match != nil {
+			if match, _, _ := p.MatchItem(&chunk.items[idx], p.withPos, slab); match != nil {
 				matches = append(matches, *match)
 			}
 		}
 	} else {
 		for _, result := range space {
-			if match, _, _ := p.MatchItem(result.item, false, slab); match != nil {
+			if match, _, _ := p.MatchItem(result.item, p.withPos, slab); match != nil {
 				matches = append(matches, *match)
 			}
 		}

src/pattern_test.go

@@ -67,7 +67,7 @@ func TestParseTermsEmpty(t *testing.T) {
 func TestExact(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true,
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true,
 		[]Range{}, Delimiter{}, []rune("'abc"))
 	chars := util.ToChars([]byte("aabbcc abc"))
 	res, pos := algo.ExactMatchNaive(
@@ -83,7 +83,7 @@ func TestExact(t *testing.T) {
 func TestEqual(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("^AbC$"))
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("^AbC$"))
 
 	match := func(str string, sidxExpected int, eidxExpected int) {
 		chars := util.ToChars([]byte(str))
@@ -106,17 +106,17 @@ func TestEqual(t *testing.T) {
 func TestCaseSensitivity(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pat1 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat1 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat2 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat2 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat3 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat3 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat4 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat4 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat5 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat5 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat6 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat6 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
 
 	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
 		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
@@ -129,7 +129,7 @@ func TestCaseSensitivity(t *testing.T) {
 }
 
 func TestOrigTextAndTransformed(t *testing.T) {
-	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("jg"))
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("jg"))
 	tokens := Tokenize("junegunn", Delimiter{})
 	trans := Transform(tokens, []Range{{1, 1}})
 
@@ -164,7 +164,7 @@ func TestOrigTextAndTransformed(t *testing.T) {
 func TestCacheKey(t *testing.T) {
 	test := func(extended bool, patStr string, expected string, cacheable bool) {
 		clearPatternCache()
-		pat := BuildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune(patStr))
+		pat := BuildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune(patStr))
 		if pat.CacheKey() != expected {
 			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
 		}
@@ -188,7 +188,7 @@ func TestCacheKey(t *testing.T) {
 func TestCacheable(t *testing.T) {
 	test := func(fuzzy bool, str string, expected string, cacheable bool) {
 		clearPatternCache()
-		pat := BuildPattern(fuzzy, algo.FuzzyMatchV2, true, CaseSmart, true, true, true, []Range{}, Delimiter{}, []rune(str))
+		pat := BuildPattern(fuzzy, algo.FuzzyMatchV2, true, CaseSmart, true, true, false, true, []Range{}, Delimiter{}, []rune(str))
 		if pat.CacheKey() != expected {
 			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
 		}

src/protector/protector.go

@@ -1,4 +1,4 @@
-// +build !openbsd
+//go:build !openbsd
 
 package protector
 

src/protector/protector_openbsd.go

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

src/reader.go

@@ -1,7 +1,7 @@
 package fzf
 
 import (
-	"bufio"
+	"bytes"
 	"context"
 	"io"
 	"os"
@@ -11,8 +11,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/charlievieth/fastwalk"
 	"github.com/junegunn/fzf/src/util"
-	"github.com/saracen/walker"
 )
 
 // Reader reads from command or standard input
@@ -76,39 +76,33 @@ func (r *Reader) fin(success bool) {
 
 func (r *Reader) terminate() {
 	r.mutex.Lock()
-	defer func() { r.mutex.Unlock() }()
-
 	r.killed = true
 	if r.exec != nil && r.exec.Process != nil {
 		util.KillCommand(r.exec)
-	} else if defaultCommand != "" {
+	} else {
 		os.Stdin.Close()
 	}
+	r.mutex.Unlock()
 }
 
-func (r *Reader) restart(command string) {
+func (r *Reader) restart(command string, environ []string) {
 	r.event = int32(EvtReady)
 	r.startEventPoller()
-	success := r.readFromCommand(nil, command)
+	success := r.readFromCommand(command, environ)
 	r.fin(success)
 }
 
 // ReadSource reads data from the default command or from standard input
-func (r *Reader) ReadSource() {
+func (r *Reader) ReadSource(root string, opts walkerOpts, ignores []string) {
 	r.startEventPoller()
 	var success bool
 	if util.IsTty() {
-		// The default command for *nix requires bash
-		shell := "bash"
 		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
 		if len(cmd) == 0 {
-			if defaultCommand != "" {
-				success = r.readFromCommand(&shell, defaultCommand)
-			} else {
-				success = r.readFiles()
-			}
+			success = r.readFiles(root, opts, ignores)
 		} else {
-			success = r.readFromCommand(nil, cmd)
+			// We can't export FZF_* environment variables to the default command
+			success = r.readFromCommand(cmd, nil)
 		}
 	} else {
 		success = r.readFromStdin()
@@ -117,32 +111,90 @@ func (r *Reader) ReadSource() {
 }
 
 func (r *Reader) feed(src io.Reader) {
+	/*
+		readerSlabSize, ae := strconv.Atoi(os.Getenv("SLAB_KB"))
+		if ae != nil {
+			readerSlabSize = 128 * 1024
+		} else {
+			readerSlabSize *= 1024
+		}
+		readerBufferSize, be := strconv.Atoi(os.Getenv("BUF_KB"))
+		if be != nil {
+			readerBufferSize = 64 * 1024
+		} else {
+			readerBufferSize *= 1024
+		}
+	*/
+
 	delim := byte('\n')
+	trimCR := util.IsWindows()
 	if r.delimNil {
 		delim = '\000'
+		trimCR = false
 	}
-	reader := bufio.NewReaderSize(src, readerBufferSize)
+
+	slab := make([]byte, readerSlabSize)
+	leftover := []byte{}
+	var err error
 	for {
-		// ReadBytes returns err != nil if and only if the returned data does not
-		// end in delim.
-		bytea, err := reader.ReadBytes(delim)
-		byteaLen := len(bytea)
-		if byteaLen > 0 {
-			if err == nil {
-				// get rid of carriage return if under Windows:
-				if util.IsWindows() && byteaLen >= 2 && bytea[byteaLen-2] == byte('\r') {
-					bytea = bytea[:byteaLen-2]
-				} else {
-					bytea = bytea[:byteaLen-1]
-				}
-			}
-			if r.pusher(bytea) {
-				atomic.StoreInt32(&r.event, int32(EvtReadNew))
+		n := 0
+		scope := slab[:util.Min(len(slab), readerBufferSize)]
+		for i := 0; i < 100; i++ {
+			n, err = src.Read(scope)
+			if n > 0 || err != nil {
+				break
 			}
 		}
-		if err != nil {
+
+		// We're not making any progress after 100 tries. Stop.
+		if n == 0 && err == nil {
 			break
 		}
+
+		buf := slab[:n]
+		slab = slab[n:]
+
+		for len(buf) > 0 {
+			if i := bytes.IndexByte(buf, delim); i >= 0 {
+				// Found the delimiter
+				slice := buf[:i+1]
+				buf = buf[i+1:]
+				if trimCR && len(slice) >= 2 && slice[len(slice)-2] == byte('\r') {
+					slice = slice[:len(slice)-2]
+				} else {
+					slice = slice[:len(slice)-1]
+				}
+				if len(leftover) > 0 {
+					slice = append(leftover, slice...)
+					leftover = []byte{}
+				}
+				if (err == nil || len(slice) > 0) && r.pusher(slice) {
+					atomic.StoreInt32(&r.event, int32(EvtReadNew))
+				}
+			} else {
+				// Could not find the delimiter in the buffer
+				//   NOTE: We can further optimize this by keeping track of the cursor
+				//   position in the slab so that a straddling item that doesn't go
+				//   beyond the boundary of a slab doesn't need to be copied to
+				//   another buffer. However, the performance gain is negligible in
+				//   practice (< 0.1%) and is not
+				//   worth the added complexity.
+				leftover = append(leftover, buf...)
+				break
+			}
+		}
+
+		if err == io.EOF {
+			leftover = append(leftover, buf...)
+			break
+		}
+
+		if len(slab) == 0 {
+			slab = make([]byte, readerSlabSize)
+		}
+	}
+	if len(leftover) > 0 && r.pusher(leftover) {
+		atomic.StoreInt32(&r.event, int32(EvtReadNew))
 	}
 }
 
@@ -151,16 +203,28 @@ func (r *Reader) readFromStdin() bool {
 	return true
 }
 
-func (r *Reader) readFiles() bool {
+func (r *Reader) readFiles(root string, opts walkerOpts, ignores []string) bool {
 	r.killed = false
-	fn := func(path string, mode os.FileInfo) error {
+	conf := fastwalk.Config{Follow: opts.follow}
+	fn := func(path string, de os.DirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
 		path = filepath.Clean(path)
 		if path != "." {
-			isDir := mode.Mode().IsDir()
-			if isDir && filepath.Base(path)[0] == '.' {
-				return filepath.SkipDir
+			isDir := de.IsDir()
+			if isDir {
+				base := filepath.Base(path)
+				if !opts.hidden && base[0] == '.' {
+					return filepath.SkipDir
+				}
+				for _, ignore := range ignores {
+					if ignore == base {
+						return filepath.SkipDir
+					}
+				}
 			}
-			if !isDir && r.pusher([]byte(path)) {
+			if ((opts.file && !isDir) || (opts.dir && isDir)) && r.pusher([]byte(path)) {
 				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}
@@ -171,20 +235,16 @@ func (r *Reader) readFiles() bool {
 		}
 		return nil
 	}
-	cb := walker.WithErrorCallback(func(pathname string, err error) error {
-		return nil
-	})
-	return walker.Walk(".", fn, cb) == nil
+	return fastwalk.Walk(&conf, root, fn) == nil
 }
 
-func (r *Reader) readFromCommand(shell *string, command string) bool {
+func (r *Reader) readFromCommand(command string, environ []string) bool {
 	r.mutex.Lock()
 	r.killed = false
 	r.command = &command
-	if shell != nil {
-		r.exec = util.ExecCommandWith(*shell, command, true)
-	} else {
-		r.exec = util.ExecCommand(command, true)
+	r.exec = util.ExecCommand(command, true)
+	if environ != nil {
+		r.exec.Env = environ
 	}
 	out, err := r.exec.StdoutPipe()
 	if err != nil {

src/reader_test.go

@@ -22,7 +22,7 @@ func TestReadFromCommand(t *testing.T) {
 	}
 
 	// Normal command
-	reader.fin(reader.readFromCommand(nil, `echo abc && echo def`))
+	reader.fin(reader.readFromCommand(`echo abc&&echo def`, nil))
 	if len(strs) != 2 || strs[0] != "abc" || strs[1] != "def" {
 		t.Errorf("%s", strs)
 	}
@@ -47,7 +47,7 @@ func TestReadFromCommand(t *testing.T) {
 	reader.startEventPoller()
 
 	// Failing command
-	reader.fin(reader.readFromCommand(nil, `no-such-command`))
+	reader.fin(reader.readFromCommand(`no-such-command`, nil))
 	strs = []string{}
 	if len(strs) > 0 {
 		t.Errorf("%s", strs)

src/result.go

@@ -49,6 +49,22 @@ func buildResult(item *Item, offsets []Offset, score int) Result {
 		case byScore:
 			// Higher is better
 			val = math.MaxUint16 - util.AsUint16(score)
+		case byChunk:
+			if validOffsetFound {
+				b := minBegin
+				e := maxEnd
+				for ; b >= 1; b-- {
+					if unicode.IsSpace(item.text.Get(b - 1)) {
+						break
+					}
+				}
+				for ; e < numChars; e++ {
+					if unicode.IsSpace(item.text.Get(e)) {
+						break
+					}
+				}
+				val = util.AsUint16(e - b)
+			}
 		case byLength:
 			val = item.TrimLength()
 		case byBegin, byEnd:
@@ -64,7 +80,7 @@ func buildResult(item *Item, offsets []Offset, score int) Result {
 				if criterion == byBegin {
 					val = util.AsUint16(minEnd - whitePrefixLen)
 				} else {
-					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/int(item.TrimLength()))
+					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/int(item.TrimLength()+1))
 				}
 			}
 		}
@@ -122,7 +138,9 @@ func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme,
 		for i := off[0]; i < off[1]; i++ {
 			// Negative of 1-based index of itemColors
 			// - The extra -1 means highlighted
-			cols[i] = cols[i]*-1 - 1
+			if cols[i] >= 0 {
+				cols[i] = cols[i]*-1 - 1
+			}
 		}
 	}
 

src/result_others.go

@@ -1,4 +1,4 @@
-// +build !386,!amd64
+//go:build !386 && !amd64
 
 package fzf
 

src/result_test.go

@@ -1,5 +1,3 @@
-// +build !tcell
-
 package fzf
 
 import (
@@ -56,9 +54,9 @@ func TestResultRank(t *testing.T) {
 	// FIXME global
 	sortCriteria = []criterion{byScore, byLength}
 
-	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
+	str := []rune("foo")
 	item1 := buildResult(
-		withIndex(&Item{text: util.RunesToChars(strs[0])}, 1), []Offset{}, 2)
+		withIndex(&Item{text: util.RunesToChars(str)}, 1), []Offset{}, 2)
 	if item1.points[3] != math.MaxUint16-2 || // Bonus
 		item1.points[2] != 3 || // Length
 		item1.points[1] != 0 || // Unused
@@ -67,7 +65,7 @@ func TestResultRank(t *testing.T) {
 		t.Error(item1)
 	}
 	// Only differ in index
-	item2 := buildResult(&Item{text: util.RunesToChars(strs[0])}, []Offset{}, 2)
+	item2 := buildResult(&Item{text: util.RunesToChars(str)}, []Offset{}, 2)
 
 	items := []Result{item1, item2}
 	sort.Sort(ByRelevance(items))
@@ -100,12 +98,29 @@ func TestResultRank(t *testing.T) {
 	}
 }
 
+func TestChunkTiebreak(t *testing.T) {
+	// FIXME global
+	sortCriteria = []criterion{byScore, byChunk}
+
+	score := 100
+	test := func(input string, offset Offset, chunk string) {
+		item := buildResult(withIndex(&Item{text: util.RunesToChars([]rune(input))}, 1), []Offset{offset}, score)
+		if !(item.points[3] == math.MaxUint16-uint16(score) && item.points[2] == uint16(len(chunk))) {
+			t.Error(item.points)
+		}
+	}
+	test("hello foobar goodbye", Offset{8, 9}, "foobar")
+	test("hello foobar goodbye", Offset{7, 18}, "foobar goodbye")
+	test("hello foobar goodbye", Offset{0, 1}, "hello")
+	test("hello foobar goodbye", Offset{5, 7}, "hello foobar") // TBD
+}
+
 func TestColorOffset(t *testing.T) {
 	// ------------ 20 ----  --  ----
 	//   ++++++++        ++++++++++
 	// --++++++++--    --++++++++++---
 
-	offsets := []Offset{{5, 15}, {25, 35}}
+	offsets := []Offset{{5, 15}, {10, 12}, {25, 35}}
 	item := Result{
 		item: &Item{
 			colors: &[]ansiOffset{

src/result_x86.go

@@ -1,4 +1,4 @@
-// +build 386 amd64
+//go:build 386 || amd64
 
 package fzf
 

src/server.go

@@ -0,0 +1,257 @@
+package fzf
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/subtle"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var getRegex *regexp.Regexp
+
+func init() {
+	getRegex = regexp.MustCompile(`^GET /(?:\?([a-z0-9=&]+))? HTTP`)
+}
+
+type getParams struct {
+	limit  int
+	offset int
+}
+
+const (
+	crlf             = "\r\n"
+	httpOk           = "HTTP/1.1 200 OK" + crlf
+	httpBadRequest   = "HTTP/1.1 400 Bad Request" + crlf
+	httpUnauthorized = "HTTP/1.1 401 Unauthorized" + crlf
+	httpUnavailable  = "HTTP/1.1 503 Service Unavailable" + crlf
+	httpReadTimeout  = 10 * time.Second
+	channelTimeout   = 2 * time.Second
+	jsonContentType  = "Content-Type: application/json" + crlf
+	maxContentLength = 1024 * 1024
+)
+
+type httpServer struct {
+	apiKey          []byte
+	actionChannel   chan []*action
+	responseChannel chan string
+}
+
+type listenAddress struct {
+	host string
+	port int
+}
+
+func (addr listenAddress) IsLocal() bool {
+	return addr.host == "localhost" || addr.host == "127.0.0.1"
+}
+
+var defaultListenAddr = listenAddress{"localhost", 0}
+
+func parseListenAddress(address string) (listenAddress, error) {
+	parts := strings.SplitN(address, ":", 3)
+	if len(parts) == 1 {
+		parts = []string{"localhost", parts[0]}
+	}
+	if len(parts) != 2 {
+		return defaultListenAddr, fmt.Errorf("invalid listen address: %s", address)
+	}
+	portStr := parts[len(parts)-1]
+	port, err := strconv.Atoi(portStr)
+	if err != nil || port < 0 || port > 65535 {
+		return defaultListenAddr, fmt.Errorf("invalid listen port: %s", portStr)
+	}
+	if len(parts[0]) == 0 {
+		parts[0] = "localhost"
+	}
+	return listenAddress{parts[0], port}, nil
+}
+
+func startHttpServer(address listenAddress, actionChannel chan []*action, responseChannel chan string) (int, error) {
+	host := address.host
+	port := address.port
+	apiKey := os.Getenv("FZF_API_KEY")
+	if !address.IsLocal() && len(apiKey) == 0 {
+		return port, fmt.Errorf("FZF_API_KEY is required to allow remote access")
+	}
+	addrStr := fmt.Sprintf("%s:%d", host, port)
+	listener, err := net.Listen("tcp", addrStr)
+	if err != nil {
+		return port, fmt.Errorf("failed to listen on %s", addrStr)
+	}
+	if port == 0 {
+		addr := listener.Addr().String()
+		parts := strings.Split(addr, ":")
+		if len(parts) < 2 {
+			return port, fmt.Errorf("cannot extract port: %s", addr)
+		}
+		var err error
+		port, err = strconv.Atoi(parts[len(parts)-1])
+		if err != nil {
+			return port, err
+		}
+	}
+
+	server := httpServer{
+		apiKey:          []byte(apiKey),
+		actionChannel:   actionChannel,
+		responseChannel: responseChannel,
+	}
+
+	go func() {
+		for {
+			conn, err := listener.Accept()
+			if err != nil {
+				if errors.Is(err, net.ErrClosed) {
+					break
+				} else {
+					continue
+				}
+			}
+			conn.Write([]byte(server.handleHttpRequest(conn)))
+			conn.Close()
+		}
+		listener.Close()
+	}()
+
+	return port, nil
+}
+
+// Here we are writing a simplistic HTTP server without using net/http
+// package to reduce the size of the binary.
+//
+// * No --listen:            2.8MB
+// * --listen with net/http: 5.7MB
+// * --listen w/o net/http:  3.3MB
+func (server *httpServer) handleHttpRequest(conn net.Conn) string {
+	contentLength := 0
+	apiKey := ""
+	body := ""
+	answer := func(code string, message string) string {
+		message += "\n"
+		return code + fmt.Sprintf("Content-Length: %d%s", len(message), crlf+crlf+message)
+	}
+	unauthorized := func(message string) string {
+		return answer(httpUnauthorized, message)
+	}
+	bad := func(message string) string {
+		return answer(httpBadRequest, message)
+	}
+	good := func(message string) string {
+		return answer(httpOk+jsonContentType, message)
+	}
+	conn.SetReadDeadline(time.Now().Add(httpReadTimeout))
+	scanner := bufio.NewScanner(conn)
+	scanner.Split(func(data []byte, atEOF bool) (int, []byte, error) {
+		found := bytes.Index(data, []byte(crlf))
+		if found >= 0 {
+			token := data[:found+len(crlf)]
+			return len(token), token, nil
+		}
+		if atEOF || len(body)+len(data) >= contentLength {
+			return 0, data, bufio.ErrFinalToken
+		}
+		return 0, nil, nil
+	})
+
+	section := 0
+	for scanner.Scan() {
+		text := scanner.Text()
+		switch section {
+		case 0:
+			getMatch := getRegex.FindStringSubmatch(text)
+			if len(getMatch) > 0 {
+				server.actionChannel <- []*action{{t: actResponse, a: getMatch[1]}}
+				select {
+				case response := <-server.responseChannel:
+					return good(response)
+				case <-time.After(channelTimeout):
+					go func() {
+						// Drain the channel
+						<-server.responseChannel
+					}()
+					return answer(httpUnavailable+jsonContentType, `{"error":"timeout"}`)
+				}
+			} else if !strings.HasPrefix(text, "POST / HTTP") {
+				return bad("invalid request method")
+			}
+			section++
+		case 1:
+			if text == crlf {
+				if contentLength == 0 {
+					return bad("content-length header missing")
+				}
+				section++
+				continue
+			}
+			pair := strings.SplitN(text, ":", 2)
+			if len(pair) == 2 {
+				switch strings.ToLower(pair[0]) {
+				case "content-length":
+					length, err := strconv.Atoi(strings.TrimSpace(pair[1]))
+					if err != nil || length <= 0 || length > maxContentLength {
+						return bad("invalid content length")
+					}
+					contentLength = length
+				case "x-api-key":
+					apiKey = strings.TrimSpace(pair[1])
+				}
+			}
+		case 2:
+			body += text
+		}
+	}
+
+	if len(server.apiKey) != 0 && subtle.ConstantTimeCompare([]byte(apiKey), server.apiKey) != 1 {
+		return unauthorized("invalid api key")
+	}
+
+	if len(body) < contentLength {
+		return bad("incomplete request")
+	}
+	body = body[:contentLength]
+
+	errorMessage := ""
+	actions := parseSingleActionList(strings.Trim(string(body), "\r\n"), func(message string) {
+		errorMessage = message
+	})
+	if len(errorMessage) > 0 {
+		return bad(errorMessage)
+	}
+	if len(actions) == 0 {
+		return bad("no action specified")
+	}
+
+	select {
+	case server.actionChannel <- actions:
+	case <-time.After(channelTimeout):
+		return httpUnavailable + crlf
+	}
+	return httpOk + crlf
+}
+
+func parseGetParams(query string) getParams {
+	params := getParams{limit: 100, offset: 0}
+	for _, pair := range strings.Split(query, "&") {
+		parts := strings.SplitN(pair, "=", 2)
+		if len(parts) == 2 {
+			switch parts[0] {
+			case "limit", "offset":
+				if val, err := strconv.Atoi(parts[1]); err == nil {
+					if parts[0] == "limit" {
+						params.limit = val
+					} else {
+						params.offset = val
+					}
+				}
+			}
+		}
+	}
+	return params
+}

src/terminal_test.go

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

src/terminal_unix.go

@@ -1,21 +1,47 @@
-// +build !windows
+//go:build !windows
 
 package fzf
 
 import (
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
+
+	"golang.org/x/sys/unix"
 )
 
+var escaper *strings.Replacer
+
+func init() {
+	tokens := strings.Split(os.Getenv("SHELL"), "/")
+	if tokens[len(tokens)-1] == "fish" {
+		// https://fishshell.com/docs/current/language.html#quotes
+		// > The only meaningful escape sequences in single quotes are \', which
+		// > escapes a single quote and \\, which escapes the backslash symbol.
+		escaper = strings.NewReplacer("\\", "\\\\", "'", "\\'")
+	} else {
+		escaper = strings.NewReplacer("'", "'\\''")
+	}
+}
+
 func notifyOnResize(resizeChan chan<- os.Signal) {
 	signal.Notify(resizeChan, syscall.SIGWINCH)
 }
 
 func notifyStop(p *os.Process) {
-	p.Signal(syscall.SIGSTOP)
+	pid := p.Pid
+	pgid, err := unix.Getpgid(pid)
+	if err == nil {
+		pid = pgid * -1
+	}
+	unix.Kill(pid, syscall.SIGSTOP)
 }
 
 func notifyOnCont(resizeChan chan<- os.Signal) {
 	signal.Notify(resizeChan, syscall.SIGCONT)
 }
+
+func quoteEntry(entry string) string {
+	return "'" + escaper.Replace(entry) + "'"
+}

src/terminal_windows.go

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

src/tokenizer.go

@@ -91,7 +91,7 @@ func withPrefixLengths(tokens []string, begin int) []Token {
 
 	prefixLength := begin
 	for idx := range tokens {
-		chars := util.ToChars([]byte(tokens[idx]))
+		chars := util.ToChars(sbytes(tokens[idx]))
 		ret[idx] = Token{&chars, int32(prefixLength)}
 		prefixLength += chars.Length()
 	}
@@ -156,14 +156,14 @@ func Tokenize(text string, delimiter Delimiter) []Token {
 	// FIXME performance
 	var tokens []string
 	if delimiter.regex != nil {
-		for len(text) > 0 {
-			loc := delimiter.regex.FindStringIndex(text)
-			if len(loc) < 2 {
-				loc = []int{0, len(text)}
-			}
-			last := util.Max(loc[1], 1)
-			tokens = append(tokens, text[:last])
-			text = text[last:]
+		locs := delimiter.regex.FindAllStringIndex(text, -1)
+		begin := 0
+		for _, loc := range locs {
+			tokens = append(tokens, text[begin:loc[1]])
+			begin = loc[1]
+		}
+		if begin < len(text) {
+			tokens = append(tokens, text[begin:])
 		}
 	}
 	return withPrefixLengths(tokens, 0)
@@ -187,7 +187,7 @@ func Transform(tokens []Token, withNth []Range) []Token {
 		if r.begin == r.end {
 			idx := r.begin
 			if idx == rangeEllipsis {
-				chars := util.ToChars([]byte(joinTokens(tokens)))
+				chars := util.ToChars(sbytes(joinTokens(tokens)))
 				parts = append(parts, &chars)
 			} else {
 				if idx < 0 {

src/tui/dummy.go

@@ -1,6 +1,4 @@
-// +build !ncurses
-// +build !tcell
-// +build !windows
+//go:build !tcell && !windows
 
 package tui
 
@@ -10,32 +8,41 @@ func HasFullscreenRenderer() bool {
 	return false
 }
 
+var DefaultBorderShape BorderShape = BorderRounded
+
 func (a Attr) Merge(b Attr) Attr {
 	return a | b
 }
 
 const (
 	AttrUndefined = Attr(0)
-	AttrRegular   = Attr(1 << 7)
-	AttrClear     = Attr(1 << 8)
+	AttrRegular   = Attr(1 << 8)
+	AttrClear     = Attr(1 << 9)
 
-	Bold      = Attr(1)
-	Dim       = Attr(1 << 1)
-	Italic    = Attr(1 << 2)
-	Underline = Attr(1 << 3)
-	Blink     = Attr(1 << 4)
-	Blink2    = Attr(1 << 5)
-	Reverse   = Attr(1 << 6)
+	Bold          = Attr(1)
+	Dim           = Attr(1 << 1)
+	Italic        = Attr(1 << 2)
+	Underline     = Attr(1 << 3)
+	Blink         = Attr(1 << 4)
+	Blink2        = Attr(1 << 5)
+	Reverse       = Attr(1 << 6)
+	StrikeThrough = Attr(1 << 7)
 )
 
-func (r *FullscreenRenderer) Init()             {}
-func (r *FullscreenRenderer) Pause(bool)        {}
-func (r *FullscreenRenderer) Resume(bool, bool) {}
-func (r *FullscreenRenderer) Clear()            {}
-func (r *FullscreenRenderer) Refresh()          {}
-func (r *FullscreenRenderer) Close()            {}
+func (r *FullscreenRenderer) Init()                              {}
+func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
+func (r *FullscreenRenderer) Pause(bool)                         {}
+func (r *FullscreenRenderer) Resume(bool, bool)                  {}
+func (r *FullscreenRenderer) PassThrough(string)                 {}
+func (r *FullscreenRenderer) Clear()                             {}
+func (r *FullscreenRenderer) NeedScrollbarRedraw() bool          { return false }
+func (r *FullscreenRenderer) ShouldEmitResizeEvent() bool        { return false }
+func (r *FullscreenRenderer) Refresh()                           {}
+func (r *FullscreenRenderer) Close()                             {}
+func (r *FullscreenRenderer) Size() TermSize                     { return TermSize{} }
 
 func (r *FullscreenRenderer) GetChar() Event { return Event{} }
+func (r *FullscreenRenderer) Top() int       { return 0 }
 func (r *FullscreenRenderer) MaxX() int      { return 0 }
 func (r *FullscreenRenderer) MaxY() int      { return 0 }
 

src/tui/eventtype_string.go

@@ -0,0 +1,120 @@
+// Code generated by "stringer -type=EventType"; DO NOT EDIT.
+
+package tui
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[Rune-0]
+	_ = x[CtrlA-1]
+	_ = x[CtrlB-2]
+	_ = x[CtrlC-3]
+	_ = x[CtrlD-4]
+	_ = x[CtrlE-5]
+	_ = x[CtrlF-6]
+	_ = x[CtrlG-7]
+	_ = x[CtrlH-8]
+	_ = x[Tab-9]
+	_ = x[CtrlJ-10]
+	_ = x[CtrlK-11]
+	_ = x[CtrlL-12]
+	_ = x[CtrlM-13]
+	_ = x[CtrlN-14]
+	_ = x[CtrlO-15]
+	_ = x[CtrlP-16]
+	_ = x[CtrlQ-17]
+	_ = x[CtrlR-18]
+	_ = x[CtrlS-19]
+	_ = x[CtrlT-20]
+	_ = x[CtrlU-21]
+	_ = x[CtrlV-22]
+	_ = x[CtrlW-23]
+	_ = x[CtrlX-24]
+	_ = x[CtrlY-25]
+	_ = x[CtrlZ-26]
+	_ = x[Esc-27]
+	_ = x[CtrlSpace-28]
+	_ = x[CtrlDelete-29]
+	_ = x[CtrlBackSlash-30]
+	_ = x[CtrlRightBracket-31]
+	_ = x[CtrlCaret-32]
+	_ = x[CtrlSlash-33]
+	_ = x[ShiftTab-34]
+	_ = x[Backspace-35]
+	_ = x[Delete-36]
+	_ = x[PageUp-37]
+	_ = x[PageDown-38]
+	_ = x[Up-39]
+	_ = x[Down-40]
+	_ = x[Left-41]
+	_ = x[Right-42]
+	_ = x[Home-43]
+	_ = x[End-44]
+	_ = x[Insert-45]
+	_ = x[ShiftUp-46]
+	_ = x[ShiftDown-47]
+	_ = x[ShiftLeft-48]
+	_ = x[ShiftRight-49]
+	_ = x[ShiftDelete-50]
+	_ = x[F1-51]
+	_ = x[F2-52]
+	_ = x[F3-53]
+	_ = x[F4-54]
+	_ = x[F5-55]
+	_ = x[F6-56]
+	_ = x[F7-57]
+	_ = x[F8-58]
+	_ = x[F9-59]
+	_ = x[F10-60]
+	_ = x[F11-61]
+	_ = x[F12-62]
+	_ = x[AltBackspace-63]
+	_ = x[AltUp-64]
+	_ = x[AltDown-65]
+	_ = x[AltLeft-66]
+	_ = x[AltRight-67]
+	_ = x[AltShiftUp-68]
+	_ = x[AltShiftDown-69]
+	_ = x[AltShiftLeft-70]
+	_ = x[AltShiftRight-71]
+	_ = x[Alt-72]
+	_ = x[CtrlAlt-73]
+	_ = x[Invalid-74]
+	_ = x[Mouse-75]
+	_ = x[DoubleClick-76]
+	_ = x[LeftClick-77]
+	_ = x[RightClick-78]
+	_ = x[SLeftClick-79]
+	_ = x[SRightClick-80]
+	_ = x[ScrollUp-81]
+	_ = x[ScrollDown-82]
+	_ = x[SScrollUp-83]
+	_ = x[SScrollDown-84]
+	_ = x[PreviewScrollUp-85]
+	_ = x[PreviewScrollDown-86]
+	_ = x[Resize-87]
+	_ = x[Change-88]
+	_ = x[BackwardEOF-89]
+	_ = x[Start-90]
+	_ = x[Load-91]
+	_ = x[Focus-92]
+	_ = x[One-93]
+	_ = x[Zero-94]
+	_ = x[Result-95]
+	_ = x[Jump-96]
+	_ = x[JumpCancel-97]
+}
+
+const _EventType_name = "RuneCtrlACtrlBCtrlCCtrlDCtrlECtrlFCtrlGCtrlHTabCtrlJCtrlKCtrlLCtrlMCtrlNCtrlOCtrlPCtrlQCtrlRCtrlSCtrlTCtrlUCtrlVCtrlWCtrlXCtrlYCtrlZEscCtrlSpaceCtrlDeleteCtrlBackSlashCtrlRightBracketCtrlCaretCtrlSlashShiftTabBackspaceDeletePageUpPageDownUpDownLeftRightHomeEndInsertShiftUpShiftDownShiftLeftShiftRightShiftDeleteF1F2F3F4F5F6F7F8F9F10F11F12AltBackspaceAltUpAltDownAltLeftAltRightAltShiftUpAltShiftDownAltShiftLeftAltShiftRightAltCtrlAltInvalidMouseDoubleClickLeftClickRightClickSLeftClickSRightClickScrollUpScrollDownSScrollUpSScrollDownPreviewScrollUpPreviewScrollDownResizeChangeBackwardEOFStartLoadFocusOneZeroResultJumpJumpCancel"
+
+var _EventType_index = [...]uint16{0, 4, 9, 14, 19, 24, 29, 34, 39, 44, 47, 52, 57, 62, 67, 72, 77, 82, 87, 92, 97, 102, 107, 112, 117, 122, 127, 132, 135, 144, 154, 167, 183, 192, 201, 209, 218, 224, 230, 238, 240, 244, 248, 253, 257, 260, 266, 273, 282, 291, 301, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 333, 336, 339, 351, 356, 363, 370, 378, 388, 400, 412, 425, 428, 435, 442, 447, 458, 467, 477, 487, 498, 506, 516, 525, 536, 551, 568, 574, 580, 591, 596, 600, 605, 608, 612, 618, 622, 632}
+
+func (i EventType) String() string {
+	if i < 0 || i >= EventType(len(_EventType_index)-1) {
+		return "EventType(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _EventType_name[_EventType_index[i]:_EventType_index[i+1]]
+}

src/tui/light.go

@@ -10,7 +10,7 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"github.com/junegunn/fzf/src/util"
+	"github.com/rivo/uniseg"
 
 	"golang.org/x/term"
 )
@@ -22,7 +22,7 @@ const (
 	defaultEscDelay = 100
 	escPollInterval = 5
 	offsetPollTries = 10
-	maxInputBuffer  = 10 * 1024
+	maxInputBuffer  = 1024 * 1024
 )
 
 const consoleDevice string = "/dev/tty"
@@ -30,37 +30,49 @@ 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)
+func (r *LightRenderer) PassThrough(str string) {
+	r.queued.WriteString("\x1b7" + str + "\x1b8")
 }
 
-// FIXME: Need better handling of non-displayable characters
-func (r *LightRenderer) stderrInternal(str string, allowNLCR bool) {
+func (r *LightRenderer) stderr(str string) {
+	r.stderrInternal(str, true, "")
+}
+
+const CR string = "\x1b[2m␍"
+const LF string = "\x1b[2m␊"
+
+func (r *LightRenderer) stderrInternal(str string, allowNLCR bool, resetCode string) {
 	bytes := []byte(str)
 	runes := []rune{}
 	for len(bytes) > 0 {
 		r, sz := utf8.DecodeRune(bytes)
 		nlcr := r == '\n' || r == '\r'
 		if r >= 32 || r == '\x1b' || nlcr {
-			if r == utf8.RuneError || nlcr && !allowNLCR {
-				runes = append(runes, ' ')
-			} else {
+			if nlcr && !allowNLCR {
+				if r == '\r' {
+					runes = append(runes, []rune(CR+resetCode)...)
+				} else {
+					runes = append(runes, []rune(LF+resetCode)...)
+				}
+			} else if r != utf8.RuneError {
 				runes = append(runes, r)
 			}
 		}
 		bytes = bytes[sz:]
 	}
-	r.queued += string(runes)
+	r.queued.WriteString(string(runes))
 }
 
-func (r *LightRenderer) csi(code string) {
-	r.stderr("\x1b[" + code)
+func (r *LightRenderer) csi(code string) string {
+	fullcode := "\x1b[" + code
+	r.stderr(fullcode)
+	return fullcode
 }
 
 func (r *LightRenderer) flush() {
-	if len(r.queued) > 0 {
-		fmt.Fprint(os.Stderr, r.queued)
-		r.queued = ""
+	if r.queued.Len() > 0 {
+		fmt.Fprint(os.Stderr, "\x1b[?7l\x1b[?25l"+r.queued.String()+"\x1b[?25h\x1b[?7h")
+		r.queued.Reset()
 	}
 }
 
@@ -71,7 +83,7 @@ type LightRenderer struct {
 	forceBlack    bool
 	clearOnExit   bool
 	prevDownTime  time.Time
-	clickY        []int
+	clicks        [][2]int
 	ttyin         *os.File
 	buffer        []byte
 	origState     *term.State
@@ -82,7 +94,7 @@ type LightRenderer struct {
 	escDelay      int
 	fullscreen    bool
 	upOneLine     bool
-	queued        string
+	queued        strings.Builder
 	y             int
 	x             int
 	maxHeightFunc func(int) int
@@ -173,9 +185,7 @@ func (r *LightRenderer) Init() {
 		}
 	}
 
-	if r.mouse {
-		r.csi("?1000h")
-	}
+	r.enableMouse()
 	r.csi(fmt.Sprintf("%dA", r.MaxY()-1))
 	r.csi("G")
 	r.csi("K")
@@ -187,6 +197,10 @@ func (r *LightRenderer) Init() {
 	}
 }
 
+func (r *LightRenderer) Resize(maxHeightFunc func(int) int) {
+	r.maxHeightFunc = maxHeightFunc
+}
+
 func (r *LightRenderer) makeSpace() {
 	r.stderr("\n")
 	r.csi("G")
@@ -231,7 +245,7 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
 	}
 
 	retries := 0
-	if c == ESC.Int() || nonblock {
+	if c == Esc.Int() || nonblock {
 		retries = r.escDelay / escPollInterval
 	}
 	buffer = append(buffer, byte(c))
@@ -246,7 +260,7 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
 				continue
 			}
 			break
-		} else if c == ESC.Int() && pc != c {
+		} else if c == Esc.Int() && pc != c {
 			retries = r.escDelay / escPollInterval
 		} else {
 			retries = 0
@@ -286,7 +300,7 @@ func (r *LightRenderer) GetChar() Event {
 	case CtrlQ.Byte():
 		return Event{CtrlQ, 0, nil}
 	case 127:
-		return Event{BSpace, 0, nil}
+		return Event{Backspace, 0, nil}
 	case 0:
 		return Event{CtrlSpace, 0, nil}
 	case 28:
@@ -297,7 +311,7 @@ func (r *LightRenderer) GetChar() Event {
 		return Event{CtrlCaret, 0, nil}
 	case 31:
 		return Event{CtrlSlash, 0, nil}
-	case ESC.Byte():
+	case Esc.Byte():
 		ev := r.escSequence(&sz)
 		// Second chance
 		if ev.Type == Invalid {
@@ -313,7 +327,7 @@ func (r *LightRenderer) GetChar() Event {
 	}
 	char, rsz := utf8.DecodeRune(r.buffer)
 	if char == utf8.RuneError {
-		return Event{ESC, 0, nil}
+		return Event{Esc, 0, nil}
 	}
 	sz = rsz
 	return Event{Rune, char, nil}
@@ -321,7 +335,7 @@ func (r *LightRenderer) GetChar() Event {
 
 func (r *LightRenderer) escSequence(sz *int) Event {
 	if len(r.buffer) < 2 {
-		return Event{ESC, 0, nil}
+		return Event{Esc, 0, nil}
 	}
 
 	loc := offsetRegexpBegin.FindIndex(r.buffer)
@@ -335,15 +349,15 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 		return CtrlAltKey(rune(r.buffer[1] + 'a' - 1))
 	}
 	alt := false
-	if len(r.buffer) > 2 && r.buffer[1] == ESC.Byte() {
+	if len(r.buffer) > 2 && r.buffer[1] == Esc.Byte() {
 		r.buffer = r.buffer[1:]
 		alt = true
 	}
 	switch r.buffer[1] {
-	case ESC.Byte():
-		return Event{ESC, 0, nil}
+	case Esc.Byte():
+		return Event{Esc, 0, nil}
 	case 127:
-		return Event{AltBS, 0, nil}
+		return Event{AltBackspace, 0, nil}
 	case '[', 'O':
 		if len(r.buffer) < 3 {
 			return Event{Invalid, 0, nil}
@@ -372,12 +386,12 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 			}
 			return Event{Up, 0, nil}
 		case 'Z':
-			return Event{BTab, 0, nil}
+			return Event{ShiftTab, 0, nil}
 		case 'H':
 			return Event{Home, 0, nil}
 		case 'F':
 			return Event{End, 0, nil}
-		case 'M':
+		case '<':
 			return r.mouseSequence(sz)
 		case 'P':
 			return Event{F1, 0, nil}
@@ -387,7 +401,7 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 			return Event{F3, 0, nil}
 		case 'S':
 			return Event{F4, 0, nil}
-		case '1', '2', '3', '4', '5', '6':
+		case '1', '2', '3', '4', '5', '6', '7', '8':
 			if len(r.buffer) < 4 {
 				return Event{Invalid, 0, nil}
 			}
@@ -419,13 +433,29 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 				}
 				return Event{Invalid, 0, nil} // INS
 			case '3':
-				return Event{Del, 0, nil}
+				if r.buffer[3] == '~' {
+					return Event{Delete, 0, nil}
+				}
+				if len(r.buffer) == 6 && r.buffer[5] == '~' {
+					*sz = 6
+					switch r.buffer[4] {
+					case '5':
+						return Event{CtrlDelete, 0, nil}
+					case '2':
+						return Event{ShiftDelete, 0, nil}
+					}
+				}
+				return Event{Invalid, 0, nil}
 			case '4':
 				return Event{End, 0, nil}
 			case '5':
-				return Event{PgUp, 0, nil}
+				return Event{PageUp, 0, nil}
 			case '6':
-				return Event{PgDn, 0, nil}
+				return Event{PageDown, 0, nil}
+			case '7':
+				return Event{Home, 0, nil}
+			case '8':
+				return Event{End, 0, nil}
 			case '1':
 				switch r.buffer[3] {
 				case '~':
@@ -459,16 +489,29 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 					}
 					*sz = 6
 					switch r.buffer[4] {
-					case '1', '2', '3', '5':
+					case '1', '2', '3', '4', '5':
+						//                   Kitty      iTerm2     WezTerm
+						// SHIFT-ARROW       "\e[1;2D"
+						// ALT-SHIFT-ARROW   "\e[1;4D"  "\e[1;10D" "\e[1;4D"
+						// CTRL-SHIFT-ARROW  "\e[1;6D"             N/A
+						// CMD-SHIFT-ARROW   "\e[1;10D" N/A        N/A ("\e[1;2D")
 						alt := r.buffer[4] == '3'
-						altShift := r.buffer[4] == '1' && r.buffer[5] == '0'
 						char := r.buffer[5]
-						if altShift {
+						altShift := false
+						if r.buffer[4] == '1' && r.buffer[5] == '0' {
+							altShift = true
 							if len(r.buffer) < 7 {
 								return Event{Invalid, 0, nil}
 							}
 							*sz = 7
 							char = r.buffer[6]
+						} else if r.buffer[4] == '4' {
+							altShift = true
+							if len(r.buffer) < 6 {
+								return Event{Invalid, 0, nil}
+							}
+							*sz = 6
+							char = r.buffer[5]
 						}
 						switch char {
 						case 'A':
@@ -476,33 +519,33 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 								return Event{AltUp, 0, nil}
 							}
 							if altShift {
-								return Event{AltSUp, 0, nil}
+								return Event{AltShiftUp, 0, nil}
 							}
-							return Event{SUp, 0, nil}
+							return Event{ShiftUp, 0, nil}
 						case 'B':
 							if alt {
 								return Event{AltDown, 0, nil}
 							}
 							if altShift {
-								return Event{AltSDown, 0, nil}
+								return Event{AltShiftDown, 0, nil}
 							}
-							return Event{SDown, 0, nil}
+							return Event{ShiftDown, 0, nil}
 						case 'C':
 							if alt {
 								return Event{AltRight, 0, nil}
 							}
 							if altShift {
-								return Event{AltSRight, 0, nil}
+								return Event{AltShiftRight, 0, nil}
 							}
-							return Event{SRight, 0, nil}
+							return Event{ShiftRight, 0, nil}
 						case 'D':
 							if alt {
 								return Event{AltLeft, 0, nil}
 							}
 							if altShift {
-								return Event{AltSLeft, 0, nil}
+								return Event{AltShiftLeft, 0, nil}
 							}
-							return Event{SLeft, 0, nil}
+							return Event{ShiftLeft, 0, nil}
 						}
 					} // r.buffer[4]
 				} // r.buffer[3]
@@ -518,47 +561,79 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 	return Event{Invalid, 0, nil}
 }
 
+// https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 func (r *LightRenderer) mouseSequence(sz *int) Event {
-	if len(r.buffer) < 6 || !r.mouse {
+	// "\e[<0;0;0M"
+	if len(r.buffer) < 9 || !r.mouse {
 		return Event{Invalid, 0, nil}
 	}
-	*sz = 6
-	switch r.buffer[3] {
-	case 32, 34, 36, 40, 48, // mouse-down / shift / cmd / ctrl
-		35, 39, 43, 51: // mouse-up / shift / cmd / ctrl
-		mod := r.buffer[3] >= 36
-		left := r.buffer[3] == 32
-		down := r.buffer[3]%2 == 0
-		x := int(r.buffer[4] - 33)
-		y := int(r.buffer[5]-33) - r.yoffset
-		double := false
-		if down {
-			now := time.Now()
-			if !left { // Right double click is not allowed
-				r.clickY = []int{}
-			} else if now.Sub(r.prevDownTime) < doubleClickDuration {
-				r.clickY = append(r.clickY, y)
-			} else {
-				r.clickY = []int{y}
-			}
-			r.prevDownTime = now
+
+	rest := r.buffer[*sz:]
+	end := bytes.IndexAny(rest, "mM")
+	if end == -1 {
+		return Event{Invalid, 0, nil}
+	}
+
+	elems := strings.SplitN(string(rest[:end]), ";", 3)
+	if len(elems) != 3 {
+		return Event{Invalid, 0, nil}
+	}
+
+	t := atoi(elems[0], -1)
+	x := atoi(elems[1], -1) - 1
+	y := atoi(elems[2], -1) - 1 - r.yoffset
+	if t < 0 || x < 0 {
+		return Event{Invalid, 0, nil}
+	}
+	*sz += end + 1
+
+	down := rest[end] == 'M'
+
+	scroll := 0
+	if t >= 64 {
+		t -= 64
+		if t&0b1 == 1 {
+			scroll = -1
 		} else {
-			if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
-				time.Since(r.prevDownTime) < doubleClickDuration {
-				double = true
+			scroll = 1
+		}
+	}
+
+	// middle := t & 0b1
+	left := t&0b11 == 0
+
+	// shift := t & 0b100
+	// ctrl := t & 0b1000
+	mod := t&0b1100 > 0
+
+	drag := t&0b100000 > 0
+
+	if scroll != 0 {
+		return Event{Mouse, 0, &MouseEvent{y, x, scroll, false, false, false, mod}}
+	}
+
+	double := false
+	if down && !drag {
+		now := time.Now()
+		if !left { // Right double click is not allowed
+			r.clicks = [][2]int{}
+		} else if now.Sub(r.prevDownTime) < doubleClickDuration {
+			r.clicks = append(r.clicks, [2]int{x, y})
+		} else {
+			r.clicks = [][2]int{{x, y}}
+		}
+		r.prevDownTime = now
+	} else {
+		n := len(r.clicks)
+		if len(r.clicks) > 1 && r.clicks[n-2][0] == r.clicks[n-1][0] && r.clicks[n-2][1] == r.clicks[n-1][1] &&
+			time.Since(r.prevDownTime) < doubleClickDuration {
+			double = true
+			if double {
+				r.clicks = [][2]int{}
 			}
 		}
-
-		return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
-	case 96, 100, 104, 112, // scroll-up / shift / cmd / ctrl
-		97, 101, 105, 113: // scroll-down / shift / cmd / ctrl
-		mod := r.buffer[3] >= 100
-		s := 1 - int(r.buffer[3]%2)*2
-		x := int(r.buffer[4] - 33)
-		y := int(r.buffer[5]-33) - r.yoffset
-		return Event{Mouse, 0, &MouseEvent{y, x, s, false, false, false, mod}}
 	}
-	return Event{Invalid, 0, nil}
+	return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
 }
 
 func (r *LightRenderer) smcup() {
@@ -570,6 +645,7 @@ func (r *LightRenderer) rmcup() {
 }
 
 func (r *LightRenderer) Pause(clear bool) {
+	r.disableMouse()
 	r.restoreTerminal()
 	if clear {
 		if r.fullscreen {
@@ -582,6 +658,22 @@ func (r *LightRenderer) Pause(clear bool) {
 	}
 }
 
+func (r *LightRenderer) enableMouse() {
+	if r.mouse {
+		r.csi("?1000h")
+		r.csi("?1002h")
+		r.csi("?1006h")
+	}
+}
+
+func (r *LightRenderer) disableMouse() {
+	if r.mouse {
+		r.csi("?1000l")
+		r.csi("?1002l")
+		r.csi("?1006l")
+	}
+}
+
 func (r *LightRenderer) Resume(clear bool, sigcont bool) {
 	r.setupTerminal()
 	if clear {
@@ -590,12 +682,13 @@ func (r *LightRenderer) Resume(clear bool, sigcont bool) {
 		} else {
 			r.rmcup()
 		}
+		r.enableMouse()
 		r.flush()
 	} else if sigcont && !r.fullscreen && r.mouse {
 		// NOTE: SIGCONT (Coming back from CTRL-Z):
 		// It's highly likely that the offset we obtained at the beginning is
 		// no longer correct, so we simply disable mouse input.
-		r.csi("?1000l")
+		r.disableMouse()
 		r.mouse = false
 	}
 }
@@ -610,6 +703,14 @@ func (r *LightRenderer) Clear() {
 	r.flush()
 }
 
+func (r *LightRenderer) NeedScrollbarRedraw() bool {
+	return false
+}
+
+func (r *LightRenderer) ShouldEmitResizeEvent() bool {
+	return false
+}
+
 func (r *LightRenderer) RefreshWindows(windows []Window) {
 	r.flush()
 }
@@ -633,19 +734,24 @@ func (r *LightRenderer) Close() {
 	} else if !r.fullscreen {
 		r.csi("u")
 	}
-	if r.mouse {
-		r.csi("?1000l")
-	}
+	r.disableMouse()
 	r.flush()
 	r.closePlatform()
 	r.restoreTerminal()
 }
 
+func (r *LightRenderer) Top() int {
+	return r.yoffset
+}
+
 func (r *LightRenderer) MaxX() int {
 	return r.width
 }
 
 func (r *LightRenderer) MaxY() int {
+	if r.height == 0 {
+		r.updateTerminalSize()
+	}
 	return r.height
 }
 
@@ -669,25 +775,42 @@ func (r *LightRenderer) NewWindow(top int, left int, width int, height int, prev
 		w.fg = r.theme.Fg.Color
 		w.bg = r.theme.Bg.Color
 	}
-	w.drawBorder()
+	w.drawBorder(false)
 	return w
 }
 
-func (w *LightWindow) drawBorder() {
+func (w *LightWindow) DrawBorder() {
+	w.drawBorder(false)
+}
+
+func (w *LightWindow) DrawHBorder() {
+	w.drawBorder(true)
+}
+
+func (w *LightWindow) drawBorder(onlyHorizontal bool) {
 	switch w.border.shape {
-	case BorderRounded, BorderSharp:
-		w.drawBorderAround()
+	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble:
+		w.drawBorderAround(onlyHorizontal)
 	case BorderHorizontal:
 		w.drawBorderHorizontal(true, true)
 	case BorderVertical:
+		if onlyHorizontal {
+			return
+		}
 		w.drawBorderVertical(true, true)
 	case BorderTop:
 		w.drawBorderHorizontal(true, false)
 	case BorderBottom:
 		w.drawBorderHorizontal(false, true)
 	case BorderLeft:
+		if onlyHorizontal {
+			return
+		}
 		w.drawBorderVertical(true, false)
 	case BorderRight:
+		if onlyHorizontal {
+			return
+		}
 		w.drawBorderVertical(false, true)
 	}
 }
@@ -697,13 +820,26 @@ func (w *LightWindow) drawBorderHorizontal(top, bottom bool) {
 	if w.preview {
 		color = ColPreviewBorder
 	}
+	hw := runeWidth(w.border.top)
+	pad := repeat(' ', w.width/hw)
+
+	w.Move(0, 0)
 	if top {
-		w.Move(0, 0)
-		w.CPrint(color, repeat(w.border.horizontal, w.width))
+		w.CPrint(color, repeat(w.border.top, w.width/hw))
+	} else {
+		w.CPrint(color, pad)
 	}
+
+	for y := 1; y < w.height-1; y++ {
+		w.Move(y, 0)
+		w.CPrint(color, pad)
+	}
+
+	w.Move(w.height-1, 0)
 	if bottom {
-		w.Move(w.height-1, 0)
-		w.CPrint(color, repeat(w.border.horizontal, w.width))
+		w.CPrint(color, repeat(w.border.bottom, w.width/hw))
+	} else {
+		w.CPrint(color, pad)
 	}
 }
 
@@ -719,38 +855,46 @@ func (w *LightWindow) drawBorderVertical(left, right bool) {
 	for y := 0; y < w.height; y++ {
 		w.Move(y, 0)
 		if left {
-			w.CPrint(color, string(w.border.vertical))
+			w.CPrint(color, string(w.border.left))
 		}
 		w.CPrint(color, repeat(' ', width))
 		if right {
-			w.CPrint(color, string(w.border.vertical))
+			w.CPrint(color, string(w.border.right))
 		}
 	}
 }
 
-func (w *LightWindow) drawBorderAround() {
+func (w *LightWindow) drawBorderAround(onlyHorizontal bool) {
 	w.Move(0, 0)
 	color := ColBorder
 	if w.preview {
 		color = ColPreviewBorder
 	}
-	w.CPrint(color, string(w.border.topLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.topRight))
-	for y := 1; y < w.height-1; y++ {
-		w.Move(y, 0)
-		w.CPrint(color, string(w.border.vertical))
-		w.CPrint(color, repeat(' ', w.width-2))
-		w.CPrint(color, string(w.border.vertical))
+	hw := runeWidth(w.border.top)
+	tcw := runeWidth(w.border.topLeft) + runeWidth(w.border.topRight)
+	bcw := runeWidth(w.border.bottomLeft) + runeWidth(w.border.bottomRight)
+	rem := (w.width - tcw) % hw
+	w.CPrint(color, string(w.border.topLeft)+repeat(w.border.top, (w.width-tcw)/hw)+repeat(' ', rem)+string(w.border.topRight))
+	if !onlyHorizontal {
+		vw := runeWidth(w.border.left)
+		for y := 1; y < w.height-1; y++ {
+			w.Move(y, 0)
+			w.CPrint(color, string(w.border.left))
+			w.CPrint(color, repeat(' ', w.width-vw*2))
+			w.CPrint(color, string(w.border.right))
+		}
 	}
 	w.Move(w.height-1, 0)
-	w.CPrint(color, string(w.border.bottomLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.bottomRight))
+	rem = (w.width - bcw) % hw
+	w.CPrint(color, string(w.border.bottomLeft)+repeat(w.border.bottom, (w.width-bcw)/hw)+repeat(' ', rem)+string(w.border.bottomRight))
 }
 
-func (w *LightWindow) csi(code string) {
-	w.renderer.csi(code)
+func (w *LightWindow) csi(code string) string {
+	return w.renderer.csi(code)
 }
 
-func (w *LightWindow) stderrInternal(str string, allowNLCR bool) {
-	w.renderer.stderrInternal(str, allowNLCR)
+func (w *LightWindow) stderrInternal(str string, allowNLCR bool, resetCode string) {
+	w.renderer.stderrInternal(str, allowNLCR, resetCode)
 }
 
 func (w *LightWindow) Top() int {
@@ -826,6 +970,9 @@ func attrCodes(attr Attr) []string {
 	if (attr & Reverse) > 0 {
 		codes = append(codes, "7")
 	}
+	if (attr & StrikeThrough) > 0 {
+		codes = append(codes, "9")
+	}
 	return codes
 }
 
@@ -853,10 +1000,10 @@ func colorCodes(fg Color, bg Color) []string {
 	return codes
 }
 
-func (w *LightWindow) csiColor(fg Color, bg Color, attr Attr) bool {
+func (w *LightWindow) csiColor(fg Color, bg Color, attr Attr) (bool, string) {
 	codes := append(attrCodes(attr), colorCodes(fg, bg)...)
-	w.csi(";" + strings.Join(codes, ";") + "m")
-	return len(codes) > 0
+	code := w.csi(";" + strings.Join(codes, ";") + "m")
+	return len(codes) > 0, code
 }
 
 func (w *LightWindow) Print(text string) {
@@ -868,16 +1015,17 @@ func cleanse(str string) string {
 }
 
 func (w *LightWindow) CPrint(pair ColorPair, text string) {
-	w.csiColor(pair.Fg(), pair.Bg(), pair.Attr())
-	w.stderrInternal(cleanse(text), false)
+	_, code := w.csiColor(pair.Fg(), pair.Bg(), pair.Attr())
+	w.stderrInternal(cleanse(text), false, code)
 	w.csi("m")
 }
 
 func (w *LightWindow) cprint2(fg Color, bg Color, attr Attr, text string) {
-	if w.csiColor(fg, bg, attr) {
+	hasColors, code := w.csiColor(fg, bg, attr)
+	if hasColors {
 		defer w.csi("m")
 	}
-	w.stderrInternal(cleanse(text), false)
+	w.stderrInternal(cleanse(text), false, code)
 }
 
 type wrappedLine struct {
@@ -889,32 +1037,40 @@ func wrapLine(input string, prefixLength int, max int, tabstop int) []wrappedLin
 	lines := []wrappedLine{}
 	width := 0
 	line := ""
-	for _, r := range input {
-		w := util.RuneWidth(r, prefixLength+width, 8)
-		width += w
-		str := string(r)
-		if r == '\t' {
+	gr := uniseg.NewGraphemes(input)
+	for gr.Next() {
+		rs := gr.Runes()
+		str := string(rs)
+		var w int
+		if len(rs) == 1 && rs[0] == '\t' {
+			w = tabstop - (prefixLength+width)%tabstop
 			str = repeat(' ', w)
+		} else if rs[0] == '\r' {
+			w++
+		} else {
+			w = uniseg.StringWidth(str)
 		}
+		width += w
+
 		if prefixLength+width <= max {
 			line += str
 		} else {
 			lines = append(lines, wrappedLine{string(line), width - w})
 			line = str
 			prefixLength = 0
-			width = util.RuneWidth(r, prefixLength, 8)
+			width = w
 		}
 	}
 	lines = append(lines, wrappedLine{string(line), width})
 	return lines
 }
 
-func (w *LightWindow) fill(str string, onMove func()) FillReturn {
+func (w *LightWindow) fill(str string, resetCode string) FillReturn {
 	allLines := strings.Split(str, "\n")
 	for i, line := range allLines {
 		lines := wrapLine(line, w.posx, w.width, w.tabstop)
 		for j, wl := range lines {
-			w.stderrInternal(wl.text, false)
+			w.stderrInternal(wl.text, false, resetCode)
 			w.posx += wl.displayWidth
 
 			// Wrap line
@@ -924,7 +1080,7 @@ func (w *LightWindow) fill(str string, onMove func()) FillReturn {
 				}
 				w.MoveAndClear(w.posy, w.posx)
 				w.Move(w.posy+1, 0)
-				onMove()
+				w.renderer.stderr(resetCode)
 			}
 		}
 	}
@@ -933,22 +1089,26 @@ func (w *LightWindow) fill(str string, onMove func()) FillReturn {
 			return FillSuspend
 		}
 		w.Move(w.posy+1, 0)
-		onMove()
+		w.renderer.stderr(resetCode)
 		return FillNextLine
 	}
 	return FillContinue
 }
 
-func (w *LightWindow) setBg() {
+func (w *LightWindow) setBg() string {
 	if w.bg != colDefault {
-		w.csiColor(colDefault, w.bg, AttrRegular)
+		_, code := w.csiColor(colDefault, w.bg, AttrRegular)
+		return code
 	}
+	// Should clear dim attribute after ␍ in the preview window
+	// e.g. printf "foo\rbar" | fzf --ansi --preview 'printf "foo\rbar"'
+	return "\x1b[m"
 }
 
 func (w *LightWindow) Fill(text string) FillReturn {
 	w.Move(w.posy, w.posx)
-	w.setBg()
-	return w.fill(text, w.setBg)
+	code := w.setBg()
+	return w.fill(text, code)
 }
 
 func (w *LightWindow) CFill(fg Color, bg Color, attr Attr, text string) FillReturn {
@@ -959,22 +1119,29 @@ func (w *LightWindow) CFill(fg Color, bg Color, attr Attr, text string) FillRetu
 	if bg == colDefault {
 		bg = w.bg
 	}
-	if w.csiColor(fg, bg, attr) {
+	if hasColors, resetCode := w.csiColor(fg, bg, attr); hasColors {
 		defer w.csi("m")
-		return w.fill(text, func() { w.csiColor(fg, bg, attr) })
+		return w.fill(text, resetCode)
 	}
-	return w.fill(text, w.setBg)
+	return w.fill(text, w.setBg())
 }
 
 func (w *LightWindow) FinishFill() {
-	w.MoveAndClear(w.posy, w.posx)
+	if w.posy < w.height {
+		w.MoveAndClear(w.posy, w.posx)
+	}
 	for y := w.posy + 1; y < w.height; y++ {
 		w.MoveAndClear(y, 0)
 	}
 }
 
 func (w *LightWindow) Erase() {
-	w.drawBorder()
-	// We don't erase the window here to avoid flickering during scroll
+	w.DrawBorder()
+	w.Move(0, 0)
+	w.FinishFill()
 	w.Move(0, 0)
 }
+
+func (w *LightWindow) EraseMaybe() bool {
+	return false
+}

src/tui/light_unix.go

@@ -1,4 +1,4 @@
-// +build !windows
+//go:build !windows
 
 package tui
 
@@ -10,6 +10,7 @@ import (
 	"syscall"
 
 	"github.com/junegunn/fzf/src/util"
+	"golang.org/x/sys/unix"
 	"golang.org/x/term"
 )
 
@@ -57,7 +58,7 @@ func openTtyIn() *os.File {
 			}
 		}
 		fmt.Fprintln(os.Stderr, "Failed to open "+consoleDevice)
-		os.Exit(2)
+		util.Exit(2)
 	}
 	return in
 }
@@ -108,3 +109,11 @@ func (r *LightRenderer) getch(nonblock bool) (int, bool) {
 	}
 	return int(b[0]), true
 }
+
+func (r *LightRenderer) Size() TermSize {
+	ws, err := unix.IoctlGetWinsize(int(r.ttyin.Fd()), unix.TIOCGWINSZ)
+	if err != nil {
+		return TermSize{}
+	}
+	return TermSize{int(ws.Row), int(ws.Col), int(ws.Xpixel), int(ws.Ypixel)}
+}

src/tui/light_windows.go

@@ -1,4 +1,4 @@
-//+build windows
+//go:build windows
 
 package tui
 
@@ -73,6 +73,9 @@ func (r *LightRenderer) initPlatform() error {
 		fd := int(r.inHandle)
 		b := make([]byte, 1)
 		for {
+			// HACK: if run from PSReadline, something resets ConsoleMode to remove ENABLE_VIRTUAL_TERMINAL_INPUT.
+			_ = windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+
 			_, err := util.Read(fd, b)
 			if err == nil {
 				r.ttyinChannel <- b[0]
@@ -107,16 +110,24 @@ func (r *LightRenderer) restoreTerminal() error {
 	return windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
 }
 
-func (r *LightRenderer) updateTerminalSize() {
+func (r *LightRenderer) Size() TermSize {
+	var w, h int
 	var bufferInfo windows.ConsoleScreenBufferInfo
 	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
-		r.width = getEnv("COLUMNS", defaultWidth)
-		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
+		w = getEnv("COLUMNS", defaultWidth)
+		h = r.maxHeightFunc(getEnv("LINES", defaultHeight))
 
 	} else {
-		r.width = int(bufferInfo.Window.Right - bufferInfo.Window.Left)
-		r.height = r.maxHeightFunc(int(bufferInfo.Window.Bottom - bufferInfo.Window.Top))
+		w = int(bufferInfo.Window.Right - bufferInfo.Window.Left)
+		h = r.maxHeightFunc(int(bufferInfo.Window.Bottom - bufferInfo.Window.Top))
 	}
+	return TermSize{h, w, 0, 0}
+}
+
+func (r *LightRenderer) updateTerminalSize() {
+	size := r.Size()
+	r.width = size.Columns
+	r.height = size.Lines
 }
 
 func (r *LightRenderer) findOffset() (row int, col int) {

src/tui/tcell.go

@@ -1,30 +1,42 @@
-// +build tcell windows
+//go:build tcell || windows
 
 package tui
 
 import (
 	"os"
 	"time"
-	"unicode/utf8"
 
-	"runtime"
+	"github.com/gdamore/tcell/v2"
+	"github.com/gdamore/tcell/v2/encoding"
+	"github.com/junegunn/fzf/src/util"
 
-	"github.com/gdamore/tcell"
-	"github.com/gdamore/tcell/encoding"
-
-	"github.com/mattn/go-runewidth"
+	"github.com/rivo/uniseg"
 )
 
 func HasFullscreenRenderer() bool {
 	return true
 }
 
-func (p ColorPair) style() tcell.Style {
-	style := tcell.StyleDefault
-	return style.Foreground(tcell.Color(p.Fg())).Background(tcell.Color(p.Bg()))
+var DefaultBorderShape BorderShape = BorderSharp
+
+func asTcellColor(color Color) tcell.Color {
+	if color == colDefault {
+		return tcell.ColorDefault
+	}
+
+	value := uint64(tcell.ColorValid) + uint64(color)
+	if color.is24() {
+		value = value | uint64(tcell.ColorIsRGB)
+	}
+	return tcell.Color(value)
 }
 
-type Attr tcell.Style
+func (p ColorPair) style() tcell.Style {
+	style := tcell.StyleDefault
+	return style.Foreground(asTcellColor(p.Fg())).Background(asTcellColor(p.Bg()))
+}
+
+type Attr int32
 
 type TcellWindow struct {
 	color       bool
@@ -63,8 +75,6 @@ func (w *TcellWindow) Refresh() {
 	}
 	w.lastX = 0
 	w.lastY = 0
-
-	w.drawBorder()
 }
 
 func (w *TcellWindow) FinishFill() {
@@ -72,12 +82,13 @@ func (w *TcellWindow) FinishFill() {
 }
 
 const (
-	Bold      Attr = Attr(tcell.AttrBold)
-	Dim            = Attr(tcell.AttrDim)
-	Blink          = Attr(tcell.AttrBlink)
-	Reverse        = Attr(tcell.AttrReverse)
-	Underline      = Attr(tcell.AttrUnderline)
-	Italic         = Attr(tcell.AttrItalic)
+	Bold          Attr = Attr(tcell.AttrBold)
+	Dim                = Attr(tcell.AttrDim)
+	Blink              = Attr(tcell.AttrBlink)
+	Reverse            = Attr(tcell.AttrReverse)
+	Underline          = Attr(tcell.AttrUnderline)
+	StrikeThrough      = Attr(tcell.AttrStrikeThrough)
+	Italic             = Attr(tcell.AttrItalic)
 )
 
 const (
@@ -86,6 +97,13 @@ const (
 	AttrClear     = Attr(1 << 8)
 )
 
+func (r *FullscreenRenderer) PassThrough(str string) {
+	// No-op
+	// https://github.com/gdamore/tcell/pull/650#issuecomment-1806442846
+}
+
+func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
+
 func (r *FullscreenRenderer) defaultTheme() *ColorTheme {
 	if _screen.Colors() >= 256 {
 		return Dark256
@@ -120,8 +138,12 @@ func (a Attr) Merge(b Attr) Attr {
 	return a | b
 }
 
+// handle the following as private members of FullscreenRenderer instance
+// they are declared here to prevent introducing tcell library in non-windows builds
 var (
-	_screen tcell.Screen
+	_screen          tcell.Screen
+	_prevMouseButton tcell.ButtonMask
+	_initialResize   bool = true
 )
 
 func (r *FullscreenRenderer) initScreen() {
@@ -150,6 +172,10 @@ func (r *FullscreenRenderer) Init() {
 	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
 }
 
+func (r *FullscreenRenderer) Top() int {
+	return 0
+}
+
 func (r *FullscreenRenderer) MaxX() int {
 	ncols, _ := _screen.Size()
 	return int(ncols)
@@ -173,49 +199,87 @@ func (r *FullscreenRenderer) Clear() {
 	_screen.Clear()
 }
 
+func (r *FullscreenRenderer) NeedScrollbarRedraw() bool {
+	return true
+}
+
+func (r *FullscreenRenderer) ShouldEmitResizeEvent() bool {
+	return true
+}
+
 func (r *FullscreenRenderer) Refresh() {
 	// noop
 }
 
+// TODO: Pixel width and height not implemented
+func (r *FullscreenRenderer) Size() TermSize {
+	cols, lines := _screen.Size()
+	return TermSize{lines, cols, 0, 0}
+}
+
 func (r *FullscreenRenderer) GetChar() Event {
 	ev := _screen.PollEvent()
 	switch ev := ev.(type) {
 	case *tcell.EventResize:
+		// Ignore the first resize event
+		// https://github.com/gdamore/tcell/blob/v2.7.0/TUTORIAL.md?plain=1#L18
+		if _initialResize {
+			_initialResize = false
+			return Event{Invalid, 0, nil}
+		}
 		return Event{Resize, 0, nil}
 
 	// process mouse events:
 	case *tcell.EventMouse:
+		// mouse down events have zeroed buttons, so we can't use them
+		// mouse up event consists of two events, 1. (main) event with modifier and other metadata, 2. event with zeroed buttons
+		// so mouse click is three consecutive events, but the first and last are indistinguishable from movement events (with released buttons)
+		// dragging has same structure, it only repeats the middle (main) event appropriately
 		x, y := ev.Position()
-		button := ev.Buttons()
 		mod := ev.Modifiers() != 0
-		if button&tcell.WheelDown != 0 {
+
+		// since we dont have mouse down events (unlike LightRenderer), we need to track state in prevButton
+		prevButton, button := _prevMouseButton, ev.Buttons()
+		_prevMouseButton = button
+		drag := prevButton == button
+
+		switch {
+		case button&tcell.WheelDown != 0:
 			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, false, mod}}
-		} else if button&tcell.WheelUp != 0 {
+		case button&tcell.WheelUp != 0:
 			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, false, mod}}
-		} else if runtime.GOOS != "windows" {
+		case button&tcell.Button1 != 0:
+			double := false
+			if !drag {
+				// all potential double click events put their coordinates in the clicks array
+				// double click event has two conditions, temporal and spatial, the first is checked here
+				now := time.Now()
+				if now.Sub(r.prevDownTime) < doubleClickDuration {
+					r.clicks = append(r.clicks, [2]int{x, y})
+				} else {
+					r.clicks = [][2]int{{x, y}}
+				}
+				r.prevDownTime = now
+
+				// detect double clicks (also check for spatial condition)
+				n := len(r.clicks)
+				double = n > 1 && r.clicks[n-2][0] == r.clicks[n-1][0] && r.clicks[n-2][1] == r.clicks[n-1][1]
+				if double {
+					// make sure two consecutive double clicks require four clicks
+					r.clicks = [][2]int{}
+				}
+			}
+			// fire single or double click event
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, true, !double, double, mod}}
+		case button&tcell.Button2 != 0:
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, false, true, false, mod}}
+		default:
 			// double and single taps on Windows don't quite work due to
 			// the console acting on the events and not allowing us
 			// to consume them.
-
 			left := button&tcell.Button1 != 0
 			down := left || button&tcell.Button3 != 0
 			double := false
-			if down {
-				now := time.Now()
-				if !left {
-					r.clickY = []int{}
-				} else if now.Sub(r.prevDownTime) < doubleClickDuration {
-					r.clickY = append(r.clickY, x)
-				} else {
-					r.clickY = []int{x}
-					r.prevDownTime = now
-				}
-			} else {
-				if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
-					time.Now().Sub(r.prevDownTime) < doubleClickDuration {
-					double = true
-				}
-			}
 
 			return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
 		}
@@ -223,9 +287,13 @@ func (r *FullscreenRenderer) GetChar() Event {
 		// process keyboard:
 	case *tcell.EventKey:
 		mods := ev.Modifiers()
+		none := mods == tcell.ModNone
 		alt := (mods & tcell.ModAlt) > 0
+		ctrl := (mods & tcell.ModCtrl) > 0
 		shift := (mods & tcell.ModShift) > 0
+		ctrlAlt := ctrl && alt
 		altShift := alt && shift
+
 		keyfn := func(r rune) Event {
 			if alt {
 				return CtrlAltKey(r)
@@ -233,6 +301,7 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return EventType(CtrlA.Int() - 'a' + int(r)).AsEvent()
 		}
 		switch ev.Key() {
+		// section 1: Ctrl+(Alt)+[a-z]
 		case tcell.KeyCtrlA:
 			return keyfn('a')
 		case tcell.KeyCtrlB:
@@ -248,7 +317,21 @@ func (r *FullscreenRenderer) GetChar() Event {
 		case tcell.KeyCtrlG:
 			return keyfn('g')
 		case tcell.KeyCtrlH:
-			return keyfn('h')
+			switch ev.Rune() {
+			case 0:
+				if ctrl {
+					return Event{Backspace, 0, nil}
+				}
+			case rune(tcell.KeyCtrlH):
+				switch {
+				case ctrl:
+					return keyfn('h')
+				case alt:
+					return Event{AltBackspace, 0, nil}
+				case none, shift:
+					return Event{Backspace, 0, nil}
+				}
+			}
 		case tcell.KeyCtrlI:
 			return keyfn('i')
 		case tcell.KeyCtrlJ:
@@ -285,26 +368,31 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return keyfn('y')
 		case tcell.KeyCtrlZ:
 			return keyfn('z')
+		// section 2: Ctrl+[ \]_]
 		case tcell.KeyCtrlSpace:
 			return Event{CtrlSpace, 0, nil}
 		case tcell.KeyCtrlBackslash:
 			return Event{CtrlBackSlash, 0, nil}
 		case tcell.KeyCtrlRightSq:
 			return Event{CtrlRightBracket, 0, nil}
+		case tcell.KeyCtrlCarat:
+			return Event{CtrlCaret, 0, nil}
 		case tcell.KeyCtrlUnderscore:
 			return Event{CtrlSlash, 0, nil}
+		// section 3: (Alt)+Backspace2
 		case tcell.KeyBackspace2:
 			if alt {
-				return Event{AltBS, 0, nil}
+				return Event{AltBackspace, 0, nil}
 			}
-			return Event{BSpace, 0, nil}
+			return Event{Backspace, 0, nil}
 
+		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
 		case tcell.KeyUp:
 			if altShift {
-				return Event{AltSUp, 0, nil}
+				return Event{AltShiftUp, 0, nil}
 			}
 			if shift {
-				return Event{SUp, 0, nil}
+				return Event{ShiftUp, 0, nil}
 			}
 			if alt {
 				return Event{AltUp, 0, nil}
@@ -312,10 +400,10 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Up, 0, nil}
 		case tcell.KeyDown:
 			if altShift {
-				return Event{AltSDown, 0, nil}
+				return Event{AltShiftDown, 0, nil}
 			}
 			if shift {
-				return Event{SDown, 0, nil}
+				return Event{ShiftDown, 0, nil}
 			}
 			if alt {
 				return Event{AltDown, 0, nil}
@@ -323,10 +411,10 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Down, 0, nil}
 		case tcell.KeyLeft:
 			if altShift {
-				return Event{AltSLeft, 0, nil}
+				return Event{AltShiftLeft, 0, nil}
 			}
 			if shift {
-				return Event{SLeft, 0, nil}
+				return Event{ShiftLeft, 0, nil}
 			}
 			if alt {
 				return Event{AltLeft, 0, nil}
@@ -334,32 +422,37 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Left, 0, nil}
 		case tcell.KeyRight:
 			if altShift {
-				return Event{AltSRight, 0, nil}
+				return Event{AltShiftRight, 0, nil}
 			}
 			if shift {
-				return Event{SRight, 0, nil}
+				return Event{ShiftRight, 0, nil}
 			}
 			if alt {
 				return Event{AltRight, 0, nil}
 			}
 			return Event{Right, 0, nil}
 
+		// section 5: (Insert|Home|Delete|End|PgUp|PgDn|BackTab|F1-F12)
 		case tcell.KeyInsert:
 			return Event{Insert, 0, nil}
 		case tcell.KeyHome:
 			return Event{Home, 0, nil}
 		case tcell.KeyDelete:
-			return Event{Del, 0, nil}
+			if ctrl {
+				return Event{CtrlDelete, 0, nil}
+			}
+			if shift {
+				return Event{ShiftDelete, 0, nil}
+			}
+			return Event{Delete, 0, nil}
 		case tcell.KeyEnd:
 			return Event{End, 0, nil}
 		case tcell.KeyPgUp:
-			return Event{PgUp, 0, nil}
+			return Event{PageUp, 0, nil}
 		case tcell.KeyPgDn:
-			return Event{PgDn, 0, nil}
-
+			return Event{PageDown, 0, nil}
 		case tcell.KeyBacktab:
-			return Event{BTab, 0, nil}
-
+			return Event{ShiftTab, 0, nil}
 		case tcell.KeyF1:
 			return Event{F1, 0, nil}
 		case tcell.KeyF2:
@@ -385,20 +478,31 @@ func (r *FullscreenRenderer) GetChar() Event {
 		case tcell.KeyF12:
 			return Event{F12, 0, nil}
 
-		// ev.Ch doesn't work for some reason for space:
+		// section 6: (Ctrl+Alt)+'rune'
 		case tcell.KeyRune:
 			r := ev.Rune()
-			if alt {
+
+			switch {
+			// translate native key events to ascii control characters
+			case r == ' ' && ctrl:
+				return Event{CtrlSpace, 0, nil}
+			// handle AltGr characters
+			case ctrlAlt:
+				return Event{Rune, r, nil} // dropping modifiers
+			// simple characters (possibly with modifier)
+			case alt:
 				return AltKey(r)
+			default:
+				return Event{Rune, r, nil}
 			}
-			return Event{Rune, r, nil}
 
+		// section 7: Esc
 		case tcell.KeyEsc:
-			return Event{ESC, 0, nil}
-
+			return Event{Esc, 0, nil}
 		}
 	}
 
+	// section 8: Invalid
 	return Event{Invalid, 0, nil}
 }
 
@@ -431,7 +535,7 @@ func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int,
 	if preview {
 		normal = ColPreview
 	}
-	return &TcellWindow{
+	w := &TcellWindow{
 		color:       r.theme.Colored,
 		preview:     preview,
 		top:         top,
@@ -440,6 +544,8 @@ func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int,
 		height:      height,
 		normal:      normal,
 		borderStyle: borderStyle}
+	w.Erase()
+	return w
 }
 
 func (w *TcellWindow) Close() {
@@ -455,7 +561,13 @@ func fill(x, y, w, h int, n ColorPair, r rune) {
 }
 
 func (w *TcellWindow) Erase() {
-	fill(w.left-1, w.top, w.width+1, w.height, w.normal, ' ')
+	fill(w.left-1, w.top, w.width+1, w.height-1, w.normal, ' ')
+	w.drawBorder(false)
+}
+
+func (w *TcellWindow) EraseMaybe() bool {
+	w.Erase()
+	return true
 }
 
 func (w *TcellWindow) Enclose(y int, x int) bool {
@@ -482,7 +594,6 @@ func (w *TcellWindow) Print(text string) {
 }
 
 func (w *TcellWindow) printString(text string, pair ColorPair) {
-	t := text
 	lx := 0
 	a := pair.Attr()
 
@@ -491,38 +602,35 @@ func (w *TcellWindow) printString(text string, pair ColorPair) {
 		style = style.
 			Reverse(a&Attr(tcell.AttrReverse) != 0).
 			Underline(a&Attr(tcell.AttrUnderline) != 0).
+			StrikeThrough(a&Attr(tcell.AttrStrikeThrough) != 0).
 			Italic(a&Attr(tcell.AttrItalic) != 0).
 			Blink(a&Attr(tcell.AttrBlink) != 0).
 			Dim(a&Attr(tcell.AttrDim) != 0)
 	}
 
-	for {
-		if len(t) == 0 {
-			break
-		}
-		r, size := utf8.DecodeRuneInString(t)
-		t = t[size:]
+	gr := uniseg.NewGraphemes(text)
+	for gr.Next() {
+		st := style
+		rs := gr.Runes()
 
-		if r < rune(' ') { // ignore control characters
-			continue
-		}
-
-		if r == '\n' {
-			w.lastY++
-			lx = 0
-		} else {
-
-			if r == '\u000D' { // skip carriage return
+		if len(rs) == 1 {
+			r := rs[0]
+			if r == '\r' {
+				st = style.Dim(true)
+				rs[0] = '␍'
+			} else if r == '\n' {
+				st = style.Dim(true)
+				rs[0] = '␊'
+			} else if r < rune(' ') { // ignore control characters
 				continue
 			}
-
-			var xPos = w.left + w.lastX + lx
-			var yPos = w.top + w.lastY
-			if xPos < (w.left+w.width) && yPos < (w.top+w.height) {
-				_screen.SetContent(xPos, yPos, r, nil, style)
-			}
-			lx += runewidth.RuneWidth(r)
 		}
+		var xPos = w.left + w.lastX + lx
+		var yPos = w.top + w.lastY
+		if xPos < (w.left+w.width) && yPos < (w.top+w.height) {
+			_screen.SetContent(xPos, yPos, rs[0], rs[1:], st)
+		}
+		lx += util.StringWidth(string(rs))
 	}
 	w.lastX += lx
 }
@@ -547,32 +655,44 @@ func (w *TcellWindow) fillString(text string, pair ColorPair) FillReturn {
 		Dim(a&Attr(tcell.AttrDim) != 0).
 		Reverse(a&Attr(tcell.AttrReverse) != 0).
 		Underline(a&Attr(tcell.AttrUnderline) != 0).
+		StrikeThrough(a&Attr(tcell.AttrStrikeThrough) != 0).
 		Italic(a&Attr(tcell.AttrItalic) != 0)
 
-	for _, r := range text {
-		if r == '\n' {
-			w.lastY++
-			w.lastX = 0
-			lx = 0
-		} else {
-			var xPos = w.left + w.lastX + lx
-
-			// word wrap:
-			if xPos >= (w.left + w.width) {
+	gr := uniseg.NewGraphemes(text)
+Loop:
+	for gr.Next() {
+		st := style
+		rs := gr.Runes()
+		if len(rs) == 1 {
+			r := rs[0]
+			switch r {
+			case '\r':
+				st = style.Dim(true)
+				rs[0] = '␍'
+			case '\n':
 				w.lastY++
 				w.lastX = 0
 				lx = 0
-				xPos = w.left
+				continue Loop
 			}
-			var yPos = w.top + w.lastY
-
-			if yPos >= (w.top + w.height) {
-				return FillSuspend
-			}
-
-			_screen.SetContent(xPos, yPos, r, nil, style)
-			lx += runewidth.RuneWidth(r)
 		}
+
+		// word wrap:
+		xPos := w.left + w.lastX + lx
+		if xPos >= (w.left + w.width) {
+			w.lastY++
+			w.lastX = 0
+			lx = 0
+			xPos = w.left
+		}
+
+		yPos := w.top + w.lastY
+		if yPos >= (w.top + w.height) {
+			return FillSuspend
+		}
+
+		_screen.SetContent(xPos, yPos, rs[0], rs[1:], st)
+		lx += util.StringWidth(string(rs))
 	}
 	w.lastX += lx
 	if w.lastX == w.width {
@@ -598,7 +718,15 @@ func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
 	return w.fillString(str, NewColorPair(fg, bg, a))
 }
 
-func (w *TcellWindow) drawBorder() {
+func (w *TcellWindow) DrawBorder() {
+	w.drawBorder(false)
+}
+
+func (w *TcellWindow) DrawHBorder() {
+	w.drawBorder(true)
+}
+
+func (w *TcellWindow) drawBorder(onlyHorizontal bool) {
 	shape := w.borderStyle.shape
 	if shape == BorderNone {
 		return
@@ -620,35 +748,52 @@ func (w *TcellWindow) drawBorder() {
 		style = w.normal.style()
 	}
 
+	hw := runeWidth(w.borderStyle.top)
 	switch shape {
-	case BorderRounded, BorderSharp, BorderHorizontal, BorderTop:
-		for x := left; x < right; x++ {
-			_screen.SetContent(x, top, w.borderStyle.horizontal, nil, style)
+	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderTop:
+		max := right - 2*hw
+		if shape == BorderHorizontal || shape == BorderTop {
+			max = right - hw
+		}
+		// tcell has an issue displaying two overlapping wide runes
+		// e.g.  SetContent(  HH  )
+		//       SetContent(   TR )
+		//       ==================
+		//                 (  HH  ) => TR is ignored
+		for x := left; x <= max; x += hw {
+			_screen.SetContent(x, top, w.borderStyle.top, nil, style)
 		}
 	}
 	switch shape {
-	case BorderRounded, BorderSharp, BorderHorizontal, BorderBottom:
-		for x := left; x < right; x++ {
-			_screen.SetContent(x, bot-1, w.borderStyle.horizontal, nil, style)
+	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderBottom:
+		max := right - 2*hw
+		if shape == BorderHorizontal || shape == BorderBottom {
+			max = right - hw
+		}
+		for x := left; x <= max; x += hw {
+			_screen.SetContent(x, bot-1, w.borderStyle.bottom, nil, style)
+		}
+	}
+	if !onlyHorizontal {
+		switch shape {
+		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderLeft:
+			for y := top; y < bot; y++ {
+				_screen.SetContent(left, y, w.borderStyle.left, nil, style)
+			}
+		}
+		switch shape {
+		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderRight:
+			vw := runeWidth(w.borderStyle.right)
+			for y := top; y < bot; y++ {
+				_screen.SetContent(right-vw, y, w.borderStyle.right, 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:
+	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble:
 		_screen.SetContent(left, top, w.borderStyle.topLeft, nil, style)
-		_screen.SetContent(right-1, top, w.borderStyle.topRight, nil, style)
+		_screen.SetContent(right-runeWidth(w.borderStyle.topRight), top, w.borderStyle.topRight, nil, style)
 		_screen.SetContent(left, bot-1, w.borderStyle.bottomLeft, nil, style)
-		_screen.SetContent(right-1, bot-1, w.borderStyle.bottomRight, nil, style)
+		_screen.SetContent(right-runeWidth(w.borderStyle.bottomRight), bot-1, w.borderStyle.bottomRight, nil, style)
 	}
 }

src/tui/tcell_test.go

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

src/tui/ttyname_unix.go

@@ -1,9 +1,8 @@
-// +build !windows
+//go:build !windows
 
 package tui
 
 import (
-	"io/ioutil"
 	"os"
 	"syscall"
 )
@@ -17,13 +16,17 @@ func ttyname() string {
 	}
 
 	for _, prefix := range devPrefixes {
-		files, err := ioutil.ReadDir(prefix)
+		files, err := os.ReadDir(prefix)
 		if err != nil {
 			continue
 		}
 
 		for _, file := range files {
-			if stat, ok := file.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
+			info, err := file.Info()
+			if err != nil {
+				continue
+			}
+			if stat, ok := info.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
 				return prefix + file.Name()
 			}
 		}

src/tui/ttyname_windows.go

@@ -1,4 +1,4 @@
-// +build windows
+//go:build windows
 
 package tui
 

src/tui/tui.go

@@ -5,9 +5,14 @@ import (
 	"os"
 	"strconv"
 	"time"
+
+	"github.com/junegunn/fzf/src/util"
+	"github.com/rivo/uniseg"
 )
 
 // Types of user action
+//
+//go:generate stringer -type=EventType
 type EventType int
 
 const (
@@ -39,8 +44,9 @@ const (
 	CtrlX
 	CtrlY
 	CtrlZ
-	ESC
+	Esc
 	CtrlSpace
+	CtrlDelete
 
 	// https://apple.stackexchange.com/questions/24261/how-do-i-send-c-that-is-control-slash-to-the-terminal
 	CtrlBackSlash
@@ -48,19 +54,12 @@ const (
 	CtrlCaret
 	CtrlSlash
 
-	Invalid
-	Resize
-	Mouse
-	DoubleClick
-	LeftClick
-	RightClick
+	ShiftTab
+	Backspace
 
-	BTab
-	BSpace
-
-	Del
-	PgUp
-	PgDn
+	Delete
+	PageUp
+	PageDown
 
 	Up
 	Down
@@ -70,10 +69,11 @@ const (
 	End
 	Insert
 
-	SUp
-	SDown
-	SLeft
-	SRight
+	ShiftUp
+	ShiftDown
+	ShiftLeft
+	ShiftRight
+	ShiftDelete
 
 	F1
 	F2
@@ -88,23 +88,48 @@ const (
 	F11
 	F12
 
-	Change
-	BackwardEOF
-
-	AltBS
+	AltBackspace
 
 	AltUp
 	AltDown
 	AltLeft
 	AltRight
 
-	AltSUp
-	AltSDown
-	AltSLeft
-	AltSRight
+	AltShiftUp
+	AltShiftDown
+	AltShiftLeft
+	AltShiftRight
 
 	Alt
 	CtrlAlt
+
+	Invalid
+
+	Mouse
+	DoubleClick
+	LeftClick
+	RightClick
+	SLeftClick
+	SRightClick
+	ScrollUp
+	ScrollDown
+	SScrollUp
+	SScrollDown
+	PreviewScrollUp
+	PreviewScrollDown
+
+	// Events
+	Resize
+	Change
+	BackwardEOF
+	Start
+	Load
+	Focus
+	One
+	Zero
+	Result
+	Jump
+	JumpCancel
 )
 
 func (t EventType) AsEvent() Event {
@@ -124,6 +149,31 @@ func (e Event) Comparable() Event {
 	return Event{e.Type, e.Char, nil}
 }
 
+func (e Event) KeyName() string {
+	if e.Type >= Invalid {
+		return ""
+	}
+
+	switch e.Type {
+	case Rune:
+		return string(e.Char)
+	case Alt:
+		return "alt-" + string(e.Char)
+	case CtrlAlt:
+		return "ctrl-alt-" + string(e.Char)
+	case CtrlBackSlash:
+		return "ctrl-\\"
+	case CtrlRightBracket:
+		return "ctrl-]"
+	case CtrlCaret:
+		return "ctrl-^"
+	case CtrlSlash:
+		return "ctrl-/"
+	}
+
+	return util.ToKebabCase(e.Type.String())
+}
+
 func Key(r rune) Event {
 	return Event{Rune, r, nil}
 }
@@ -248,25 +298,31 @@ func (p ColorPair) MergeNonDefault(other ColorPair) ColorPair {
 }
 
 type ColorTheme struct {
-	Colored      bool
-	Input        ColorAttr
-	Disabled     ColorAttr
-	Fg           ColorAttr
-	Bg           ColorAttr
-	PreviewFg    ColorAttr
-	PreviewBg    ColorAttr
-	DarkBg       ColorAttr
-	Gutter       ColorAttr
-	Prompt       ColorAttr
-	Match        ColorAttr
-	Current      ColorAttr
-	CurrentMatch ColorAttr
-	Spinner      ColorAttr
-	Info         ColorAttr
-	Cursor       ColorAttr
-	Selected     ColorAttr
-	Header       ColorAttr
-	Border       ColorAttr
+	Colored          bool
+	Input            ColorAttr
+	Disabled         ColorAttr
+	Fg               ColorAttr
+	Bg               ColorAttr
+	PreviewFg        ColorAttr
+	PreviewBg        ColorAttr
+	DarkBg           ColorAttr
+	Gutter           ColorAttr
+	Prompt           ColorAttr
+	Match            ColorAttr
+	Current          ColorAttr
+	CurrentMatch     ColorAttr
+	Spinner          ColorAttr
+	Info             ColorAttr
+	Cursor           ColorAttr
+	Selected         ColorAttr
+	Header           ColorAttr
+	Separator        ColorAttr
+	Scrollbar        ColorAttr
+	Border           ColorAttr
+	PreviewBorder    ColorAttr
+	PreviewScrollbar ColorAttr
+	BorderLabel      ColorAttr
+	PreviewLabel     ColorAttr
 }
 
 type Event struct {
@@ -275,6 +331,15 @@ type Event struct {
 	MouseEvent *MouseEvent
 }
 
+func (e Event) Is(types ...EventType) bool {
+	for _, t := range types {
+		if e.Type == t {
+			return true
+		}
+	}
+	return false
+}
+
 type MouseEvent struct {
 	Y      int
 	X      int
@@ -291,6 +356,10 @@ const (
 	BorderNone BorderShape = iota
 	BorderRounded
 	BorderSharp
+	BorderBold
+	BorderBlock
+	BorderThinBlock
+	BorderDouble
 	BorderHorizontal
 	BorderVertical
 	BorderTop
@@ -299,10 +368,28 @@ const (
 	BorderRight
 )
 
+func (s BorderShape) HasRight() bool {
+	switch s {
+	case BorderNone, BorderLeft, BorderTop, BorderBottom, BorderHorizontal: // No right
+		return false
+	}
+	return true
+}
+
+func (s BorderShape) HasTop() bool {
+	switch s {
+	case BorderNone, BorderLeft, BorderRight, BorderBottom, BorderVertical: // No top
+		return false
+	}
+	return true
+}
+
 type BorderStyle struct {
 	shape       BorderShape
-	horizontal  rune
-	vertical    rune
+	top         rune
+	bottom      rune
+	left        rune
+	right       rune
 	topLeft     rune
 	topRight    rune
 	bottomLeft  rune
@@ -312,64 +399,143 @@ type BorderStyle struct {
 type BorderCharacter int
 
 func MakeBorderStyle(shape BorderShape, unicode bool) BorderStyle {
-	if unicode {
-		if shape == BorderRounded {
-			return BorderStyle{
-				shape:       shape,
-				horizontal:  '─',
-				vertical:    '│',
-				topLeft:     '╭',
-				topRight:    '╮',
-				bottomLeft:  '╰',
-				bottomRight: '╯',
-			}
-		}
+	if !unicode {
 		return BorderStyle{
 			shape:       shape,
-			horizontal:  '─',
-			vertical:    '│',
+			top:         '-',
+			bottom:      '-',
+			left:        '|',
+			right:       '|',
+			topLeft:     '+',
+			topRight:    '+',
+			bottomLeft:  '+',
+			bottomRight: '+',
+		}
+	}
+	switch shape {
+	case BorderSharp:
+		return BorderStyle{
+			shape:       shape,
+			top:         '─',
+			bottom:      '─',
+			left:        '│',
+			right:       '│',
 			topLeft:     '┌',
 			topRight:    '┐',
 			bottomLeft:  '└',
 			bottomRight: '┘',
 		}
+	case BorderBold:
+		return BorderStyle{
+			shape:       shape,
+			top:         '━',
+			bottom:      '━',
+			left:        '┃',
+			right:       '┃',
+			topLeft:     '┏',
+			topRight:    '┓',
+			bottomLeft:  '┗',
+			bottomRight: '┛',
+		}
+	case BorderBlock:
+		// ▛▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▜
+		// ▌                  ▐
+		// ▙▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▟
+		return BorderStyle{
+			shape:       shape,
+			top:         '▀',
+			bottom:      '▄',
+			left:        '▌',
+			right:       '▐',
+			topLeft:     '▛',
+			topRight:    '▜',
+			bottomLeft:  '▙',
+			bottomRight: '▟',
+		}
+
+	case BorderThinBlock:
+		// 🭽▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔🭾
+		// ▏                  ▕
+		// 🭼▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁🭿
+		return BorderStyle{
+			shape:       shape,
+			top:         '▔',
+			bottom:      '▁',
+			left:        '▏',
+			right:       '▕',
+			topLeft:     '🭽',
+			topRight:    '🭾',
+			bottomLeft:  '🭼',
+			bottomRight: '🭿',
+		}
+
+	case BorderDouble:
+		return BorderStyle{
+			shape:       shape,
+			top:         '═',
+			bottom:      '═',
+			left:        '║',
+			right:       '║',
+			topLeft:     '╔',
+			topRight:    '╗',
+			bottomLeft:  '╚',
+			bottomRight: '╝',
+		}
 	}
 	return BorderStyle{
 		shape:       shape,
-		horizontal:  '-',
-		vertical:    '|',
-		topLeft:     '+',
-		topRight:    '+',
-		bottomLeft:  '+',
-		bottomRight: '+',
+		top:         '─',
+		bottom:      '─',
+		left:        '│',
+		right:       '│',
+		topLeft:     '╭',
+		topRight:    '╮',
+		bottomLeft:  '╰',
+		bottomRight: '╯',
 	}
 }
 
 func MakeTransparentBorder() BorderStyle {
 	return BorderStyle{
 		shape:       BorderRounded,
-		horizontal:  ' ',
-		vertical:    ' ',
+		top:         ' ',
+		bottom:      ' ',
+		left:        ' ',
+		right:       ' ',
 		topLeft:     ' ',
 		topRight:    ' ',
 		bottomLeft:  ' ',
 		bottomRight: ' '}
 }
 
+type TermSize struct {
+	Lines    int
+	Columns  int
+	PxWidth  int
+	PxHeight int
+}
+
 type Renderer interface {
 	Init()
+	Resize(maxHeightFunc func(int) int)
 	Pause(clear bool)
 	Resume(clear bool, sigcont bool)
 	Clear()
 	RefreshWindows(windows []Window)
 	Refresh()
 	Close()
+	PassThrough(string)
+	NeedScrollbarRedraw() bool
+	ShouldEmitResizeEvent() bool
 
 	GetChar() Event
 
+	Top() int
 	MaxX() int
 	MaxY() int
 
+	Size() TermSize
+
 	NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window
 }
 
@@ -379,6 +545,8 @@ type Window interface {
 	Width() int
 	Height() int
 
+	DrawBorder()
+	DrawHBorder()
 	Refresh()
 	FinishFill()
 	Close()
@@ -394,6 +562,7 @@ type Window interface {
 	Fill(text string) FillReturn
 	CFill(fg Color, bg Color, attr Attr, text string) FillReturn
 	Erase()
+	EraseMaybe() bool
 }
 
 type FullscreenRenderer struct {
@@ -401,7 +570,7 @@ type FullscreenRenderer struct {
 	mouse        bool
 	forceBlack   bool
 	prevDownTime time.Time
-	clickY       []int
+	clicks       [][2]int
 }
 
 func NewFullscreenRenderer(theme *ColorTheme, forceBlack bool, mouse bool) Renderer {
@@ -410,7 +579,7 @@ func NewFullscreenRenderer(theme *ColorTheme, forceBlack bool, mouse bool) Rende
 		mouse:        mouse,
 		forceBlack:   forceBlack,
 		prevDownTime: time.Unix(0, 0),
-		clickY:       []int{}}
+		clicks:       [][2]int{}}
 	return r
 }
 
@@ -436,123 +605,164 @@ var (
 	ColSpinner              ColorPair
 	ColInfo                 ColorPair
 	ColHeader               ColorPair
+	ColSeparator            ColorPair
+	ColScrollbar            ColorPair
 	ColBorder               ColorPair
 	ColPreview              ColorPair
 	ColPreviewBorder        ColorPair
+	ColBorderLabel          ColorPair
+	ColPreviewLabel         ColorPair
+	ColPreviewScrollbar     ColorPair
+	ColPreviewSpinner       ColorPair
 )
 
 func EmptyTheme() *ColorTheme {
 	return &ColorTheme{
-		Colored:      true,
-		Input:        ColorAttr{colUndefined, AttrUndefined},
-		Disabled:     ColorAttr{colUndefined, AttrUndefined},
-		Fg:           ColorAttr{colUndefined, AttrUndefined},
-		Bg:           ColorAttr{colUndefined, AttrUndefined},
-		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
-		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
-		DarkBg:       ColorAttr{colUndefined, AttrUndefined},
-		Gutter:       ColorAttr{colUndefined, AttrUndefined},
-		Prompt:       ColorAttr{colUndefined, AttrUndefined},
-		Match:        ColorAttr{colUndefined, AttrUndefined},
-		Current:      ColorAttr{colUndefined, AttrUndefined},
-		CurrentMatch: ColorAttr{colUndefined, AttrUndefined},
-		Spinner:      ColorAttr{colUndefined, AttrUndefined},
-		Info:         ColorAttr{colUndefined, AttrUndefined},
-		Cursor:       ColorAttr{colUndefined, AttrUndefined},
-		Selected:     ColorAttr{colUndefined, AttrUndefined},
-		Header:       ColorAttr{colUndefined, AttrUndefined},
-		Border:       ColorAttr{colUndefined, AttrUndefined}}
+		Colored:          true,
+		Input:            ColorAttr{colUndefined, AttrUndefined},
+		Fg:               ColorAttr{colUndefined, AttrUndefined},
+		Bg:               ColorAttr{colUndefined, AttrUndefined},
+		DarkBg:           ColorAttr{colUndefined, AttrUndefined},
+		Prompt:           ColorAttr{colUndefined, AttrUndefined},
+		Match:            ColorAttr{colUndefined, AttrUndefined},
+		Current:          ColorAttr{colUndefined, AttrUndefined},
+		CurrentMatch:     ColorAttr{colUndefined, AttrUndefined},
+		Spinner:          ColorAttr{colUndefined, AttrUndefined},
+		Info:             ColorAttr{colUndefined, AttrUndefined},
+		Cursor:           ColorAttr{colUndefined, AttrUndefined},
+		Selected:         ColorAttr{colUndefined, AttrUndefined},
+		Header:           ColorAttr{colUndefined, AttrUndefined},
+		Border:           ColorAttr{colUndefined, AttrUndefined},
+		BorderLabel:      ColorAttr{colUndefined, AttrUndefined},
+		Disabled:         ColorAttr{colUndefined, AttrUndefined},
+		PreviewFg:        ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:        ColorAttr{colUndefined, AttrUndefined},
+		Gutter:           ColorAttr{colUndefined, AttrUndefined},
+		PreviewBorder:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewScrollbar: ColorAttr{colUndefined, AttrUndefined},
+		PreviewLabel:     ColorAttr{colUndefined, AttrUndefined},
+		Separator:        ColorAttr{colUndefined, AttrUndefined},
+		Scrollbar:        ColorAttr{colUndefined, AttrUndefined},
+	}
 }
 
 func NoColorTheme() *ColorTheme {
 	return &ColorTheme{
-		Colored:      false,
-		Input:        ColorAttr{colDefault, AttrRegular},
-		Disabled:     ColorAttr{colDefault, AttrRegular},
-		Fg:           ColorAttr{colDefault, AttrRegular},
-		Bg:           ColorAttr{colDefault, AttrRegular},
-		PreviewFg:    ColorAttr{colDefault, AttrRegular},
-		PreviewBg:    ColorAttr{colDefault, AttrRegular},
-		DarkBg:       ColorAttr{colDefault, AttrRegular},
-		Gutter:       ColorAttr{colDefault, AttrRegular},
-		Prompt:       ColorAttr{colDefault, AttrRegular},
-		Match:        ColorAttr{colDefault, Underline},
-		Current:      ColorAttr{colDefault, Reverse},
-		CurrentMatch: ColorAttr{colDefault, Reverse | Underline},
-		Spinner:      ColorAttr{colDefault, AttrRegular},
-		Info:         ColorAttr{colDefault, AttrRegular},
-		Cursor:       ColorAttr{colDefault, AttrRegular},
-		Selected:     ColorAttr{colDefault, AttrRegular},
-		Header:       ColorAttr{colDefault, AttrRegular},
-		Border:       ColorAttr{colDefault, AttrRegular}}
+		Colored:          false,
+		Input:            ColorAttr{colDefault, AttrUndefined},
+		Fg:               ColorAttr{colDefault, AttrUndefined},
+		Bg:               ColorAttr{colDefault, AttrUndefined},
+		DarkBg:           ColorAttr{colDefault, AttrUndefined},
+		Prompt:           ColorAttr{colDefault, AttrUndefined},
+		Match:            ColorAttr{colDefault, Underline},
+		Current:          ColorAttr{colDefault, Reverse},
+		CurrentMatch:     ColorAttr{colDefault, Reverse | Underline},
+		Spinner:          ColorAttr{colDefault, AttrUndefined},
+		Info:             ColorAttr{colDefault, AttrUndefined},
+		Cursor:           ColorAttr{colDefault, AttrUndefined},
+		Selected:         ColorAttr{colDefault, AttrUndefined},
+		Header:           ColorAttr{colDefault, AttrUndefined},
+		Border:           ColorAttr{colDefault, AttrUndefined},
+		BorderLabel:      ColorAttr{colDefault, AttrUndefined},
+		Disabled:         ColorAttr{colDefault, AttrUndefined},
+		PreviewFg:        ColorAttr{colDefault, AttrUndefined},
+		PreviewBg:        ColorAttr{colDefault, AttrUndefined},
+		Gutter:           ColorAttr{colDefault, AttrUndefined},
+		PreviewBorder:    ColorAttr{colDefault, AttrUndefined},
+		PreviewScrollbar: ColorAttr{colDefault, AttrUndefined},
+		PreviewLabel:     ColorAttr{colDefault, AttrUndefined},
+		Separator:        ColorAttr{colDefault, AttrUndefined},
+		Scrollbar:        ColorAttr{colDefault, AttrUndefined},
+	}
 }
 
 func errorExit(message string) {
 	fmt.Fprintln(os.Stderr, message)
-	os.Exit(2)
+	util.Exit(2)
 }
 
 func init() {
 	Default16 = &ColorTheme{
-		Colored:      true,
-		Input:        ColorAttr{colDefault, AttrUndefined},
-		Disabled:     ColorAttr{colUndefined, AttrUndefined},
-		Fg:           ColorAttr{colDefault, AttrUndefined},
-		Bg:           ColorAttr{colDefault, AttrUndefined},
-		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
-		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
-		DarkBg:       ColorAttr{colBlack, AttrUndefined},
-		Gutter:       ColorAttr{colUndefined, AttrUndefined},
-		Prompt:       ColorAttr{colBlue, AttrUndefined},
-		Match:        ColorAttr{colGreen, AttrUndefined},
-		Current:      ColorAttr{colYellow, AttrUndefined},
-		CurrentMatch: ColorAttr{colGreen, AttrUndefined},
-		Spinner:      ColorAttr{colGreen, AttrUndefined},
-		Info:         ColorAttr{colWhite, AttrUndefined},
-		Cursor:       ColorAttr{colRed, AttrUndefined},
-		Selected:     ColorAttr{colMagenta, AttrUndefined},
-		Header:       ColorAttr{colCyan, AttrUndefined},
-		Border:       ColorAttr{colBlack, AttrUndefined}}
+		Colored:          true,
+		Input:            ColorAttr{colDefault, AttrUndefined},
+		Fg:               ColorAttr{colDefault, AttrUndefined},
+		Bg:               ColorAttr{colDefault, AttrUndefined},
+		DarkBg:           ColorAttr{colBlack, AttrUndefined},
+		Prompt:           ColorAttr{colBlue, AttrUndefined},
+		Match:            ColorAttr{colGreen, AttrUndefined},
+		Current:          ColorAttr{colYellow, AttrUndefined},
+		CurrentMatch:     ColorAttr{colGreen, AttrUndefined},
+		Spinner:          ColorAttr{colGreen, AttrUndefined},
+		Info:             ColorAttr{colWhite, AttrUndefined},
+		Cursor:           ColorAttr{colRed, AttrUndefined},
+		Selected:         ColorAttr{colMagenta, AttrUndefined},
+		Header:           ColorAttr{colCyan, AttrUndefined},
+		Border:           ColorAttr{colBlack, AttrUndefined},
+		BorderLabel:      ColorAttr{colWhite, AttrUndefined},
+		Disabled:         ColorAttr{colUndefined, AttrUndefined},
+		PreviewFg:        ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:        ColorAttr{colUndefined, AttrUndefined},
+		Gutter:           ColorAttr{colUndefined, AttrUndefined},
+		PreviewBorder:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewScrollbar: ColorAttr{colUndefined, AttrUndefined},
+		PreviewLabel:     ColorAttr{colUndefined, AttrUndefined},
+		Separator:        ColorAttr{colUndefined, AttrUndefined},
+		Scrollbar:        ColorAttr{colUndefined, AttrUndefined},
+	}
 	Dark256 = &ColorTheme{
-		Colored:      true,
-		Input:        ColorAttr{colDefault, AttrUndefined},
-		Disabled:     ColorAttr{colUndefined, AttrUndefined},
-		Fg:           ColorAttr{colDefault, AttrUndefined},
-		Bg:           ColorAttr{colDefault, AttrUndefined},
-		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
-		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
-		DarkBg:       ColorAttr{236, AttrUndefined},
-		Gutter:       ColorAttr{colUndefined, AttrUndefined},
-		Prompt:       ColorAttr{110, AttrUndefined},
-		Match:        ColorAttr{108, AttrUndefined},
-		Current:      ColorAttr{254, AttrUndefined},
-		CurrentMatch: ColorAttr{151, AttrUndefined},
-		Spinner:      ColorAttr{148, AttrUndefined},
-		Info:         ColorAttr{144, AttrUndefined},
-		Cursor:       ColorAttr{161, AttrUndefined},
-		Selected:     ColorAttr{168, AttrUndefined},
-		Header:       ColorAttr{109, AttrUndefined},
-		Border:       ColorAttr{59, AttrUndefined}}
+		Colored:          true,
+		Input:            ColorAttr{colDefault, AttrUndefined},
+		Fg:               ColorAttr{colDefault, AttrUndefined},
+		Bg:               ColorAttr{colDefault, AttrUndefined},
+		DarkBg:           ColorAttr{236, AttrUndefined},
+		Prompt:           ColorAttr{110, AttrUndefined},
+		Match:            ColorAttr{108, AttrUndefined},
+		Current:          ColorAttr{254, AttrUndefined},
+		CurrentMatch:     ColorAttr{151, AttrUndefined},
+		Spinner:          ColorAttr{148, AttrUndefined},
+		Info:             ColorAttr{144, AttrUndefined},
+		Cursor:           ColorAttr{161, AttrUndefined},
+		Selected:         ColorAttr{168, AttrUndefined},
+		Header:           ColorAttr{109, AttrUndefined},
+		Border:           ColorAttr{59, AttrUndefined},
+		BorderLabel:      ColorAttr{145, AttrUndefined},
+		Disabled:         ColorAttr{colUndefined, AttrUndefined},
+		PreviewFg:        ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:        ColorAttr{colUndefined, AttrUndefined},
+		Gutter:           ColorAttr{colUndefined, AttrUndefined},
+		PreviewBorder:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewScrollbar: ColorAttr{colUndefined, AttrUndefined},
+		PreviewLabel:     ColorAttr{colUndefined, AttrUndefined},
+		Separator:        ColorAttr{colUndefined, AttrUndefined},
+		Scrollbar:        ColorAttr{colUndefined, AttrUndefined},
+	}
 	Light256 = &ColorTheme{
-		Colored:      true,
-		Input:        ColorAttr{colDefault, AttrUndefined},
-		Disabled:     ColorAttr{colUndefined, AttrUndefined},
-		Fg:           ColorAttr{colDefault, AttrUndefined},
-		Bg:           ColorAttr{colDefault, AttrUndefined},
-		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
-		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
-		DarkBg:       ColorAttr{251, AttrUndefined},
-		Gutter:       ColorAttr{colUndefined, AttrUndefined},
-		Prompt:       ColorAttr{25, AttrUndefined},
-		Match:        ColorAttr{66, AttrUndefined},
-		Current:      ColorAttr{237, AttrUndefined},
-		CurrentMatch: ColorAttr{23, AttrUndefined},
-		Spinner:      ColorAttr{65, AttrUndefined},
-		Info:         ColorAttr{101, AttrUndefined},
-		Cursor:       ColorAttr{161, AttrUndefined},
-		Selected:     ColorAttr{168, AttrUndefined},
-		Header:       ColorAttr{31, AttrUndefined},
-		Border:       ColorAttr{145, AttrUndefined}}
+		Colored:          true,
+		Input:            ColorAttr{colDefault, AttrUndefined},
+		Fg:               ColorAttr{colDefault, AttrUndefined},
+		Bg:               ColorAttr{colDefault, AttrUndefined},
+		DarkBg:           ColorAttr{251, AttrUndefined},
+		Prompt:           ColorAttr{25, AttrUndefined},
+		Match:            ColorAttr{66, AttrUndefined},
+		Current:          ColorAttr{237, AttrUndefined},
+		CurrentMatch:     ColorAttr{23, AttrUndefined},
+		Spinner:          ColorAttr{65, AttrUndefined},
+		Info:             ColorAttr{101, AttrUndefined},
+		Cursor:           ColorAttr{161, AttrUndefined},
+		Selected:         ColorAttr{168, AttrUndefined},
+		Header:           ColorAttr{31, AttrUndefined},
+		Border:           ColorAttr{145, AttrUndefined},
+		BorderLabel:      ColorAttr{59, AttrUndefined},
+		Disabled:         ColorAttr{colUndefined, AttrUndefined},
+		PreviewFg:        ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:        ColorAttr{colUndefined, AttrUndefined},
+		Gutter:           ColorAttr{colUndefined, AttrUndefined},
+		PreviewBorder:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewScrollbar: ColorAttr{colUndefined, AttrUndefined},
+		PreviewLabel:     ColorAttr{colUndefined, AttrUndefined},
+		Separator:        ColorAttr{colUndefined, AttrUndefined},
+		Scrollbar:        ColorAttr{colUndefined, AttrUndefined},
+	}
 }
 
 func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
@@ -571,13 +781,9 @@ func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
 		return c
 	}
 	theme.Input = o(baseTheme.Input, theme.Input)
-	theme.Disabled = o(theme.Input, o(baseTheme.Disabled, theme.Disabled))
 	theme.Fg = o(baseTheme.Fg, theme.Fg)
 	theme.Bg = o(baseTheme.Bg, theme.Bg)
-	theme.PreviewFg = o(theme.Fg, o(baseTheme.PreviewFg, theme.PreviewFg))
-	theme.PreviewBg = o(theme.Bg, o(baseTheme.PreviewBg, theme.PreviewBg))
 	theme.DarkBg = o(baseTheme.DarkBg, theme.DarkBg)
-	theme.Gutter = o(theme.DarkBg, o(baseTheme.Gutter, theme.Gutter))
 	theme.Prompt = o(baseTheme.Prompt, theme.Prompt)
 	theme.Match = o(baseTheme.Match, theme.Match)
 	theme.Current = o(baseTheme.Current, theme.Current)
@@ -588,6 +794,18 @@ func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
 	theme.Selected = o(baseTheme.Selected, theme.Selected)
 	theme.Header = o(baseTheme.Header, theme.Header)
 	theme.Border = o(baseTheme.Border, theme.Border)
+	theme.BorderLabel = o(baseTheme.BorderLabel, theme.BorderLabel)
+
+	// These colors are not defined in the base themes
+	theme.Disabled = o(theme.Input, theme.Disabled)
+	theme.Gutter = o(theme.DarkBg, theme.Gutter)
+	theme.PreviewFg = o(theme.Fg, theme.PreviewFg)
+	theme.PreviewBg = o(theme.Bg, theme.PreviewBg)
+	theme.PreviewLabel = o(theme.BorderLabel, theme.PreviewLabel)
+	theme.PreviewBorder = o(theme.Border, theme.PreviewBorder)
+	theme.Separator = o(theme.Border, theme.Separator)
+	theme.Scrollbar = o(theme.Border, theme.Scrollbar)
+	theme.PreviewScrollbar = o(theme.PreviewBorder, theme.PreviewScrollbar)
 
 	initPalette(theme)
 }
@@ -619,7 +837,17 @@ func initPalette(theme *ColorTheme) {
 	ColSpinner = pair(theme.Spinner, theme.Bg)
 	ColInfo = pair(theme.Info, theme.Bg)
 	ColHeader = pair(theme.Header, theme.Bg)
+	ColSeparator = pair(theme.Separator, theme.Bg)
+	ColScrollbar = pair(theme.Scrollbar, theme.Bg)
 	ColBorder = pair(theme.Border, theme.Bg)
+	ColBorderLabel = pair(theme.BorderLabel, theme.Bg)
+	ColPreviewLabel = pair(theme.PreviewLabel, theme.PreviewBg)
 	ColPreview = pair(theme.PreviewFg, theme.PreviewBg)
-	ColPreviewBorder = pair(theme.Border, theme.PreviewBg)
+	ColPreviewBorder = pair(theme.PreviewBorder, theme.PreviewBg)
+	ColPreviewScrollbar = pair(theme.PreviewScrollbar, theme.PreviewBg)
+	ColPreviewSpinner = pair(theme.Spinner, theme.PreviewBg)
+}
+
+func runeWidth(r rune) int {
+	return uniseg.StringWidth(string(r))
 }

src/util/atexit.go

@@ -0,0 +1,38 @@
+package util
+
+import (
+	"os"
+	"sync"
+)
+
+var atExitFuncs []func()
+
+// AtExit registers the function fn to be called on program termination.
+// The functions will be called in reverse order they were registered.
+func AtExit(fn func()) {
+	if fn == nil {
+		panic("AtExit called with nil func")
+	}
+	once := &sync.Once{}
+	atExitFuncs = append(atExitFuncs, func() {
+		once.Do(fn)
+	})
+}
+
+// RunAtExitFuncs runs any functions registered with AtExit().
+func RunAtExitFuncs() {
+	fns := atExitFuncs
+	for i := len(fns) - 1; i >= 0; i-- {
+		fns[i]()
+	}
+}
+
+// Exit executes any functions registered with AtExit() then exits the program
+// with os.Exit(code).
+//
+// NOTE: It must be used instead of os.Exit() since calling os.Exit() terminates
+// the program before any of the AtExit functions can run.
+func Exit(code int) {
+	defer os.Exit(code)
+	RunAtExitFuncs()
+}

src/util/atexit_test.go

@@ -0,0 +1,24 @@
+package util
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestAtExit(t *testing.T) {
+	want := []int{3, 2, 1, 0}
+	var called []int
+	for i := 0; i < 4; i++ {
+		n := i
+		AtExit(func() { called = append(called, n) })
+	}
+	RunAtExitFuncs()
+	if !reflect.DeepEqual(called, want) {
+		t.Errorf("AtExit: want call order: %v got: %v", want, called)
+	}
+
+	RunAtExitFuncs()
+	if !reflect.DeepEqual(called, want) {
+		t.Error("AtExit: should only call exit funcs once")
+	}
+}

src/util/chars.go

@@ -163,7 +163,7 @@ func (chars *Chars) ToString() string {
 	if runes := chars.optionalRunes(); runes != nil {
 		return string(runes)
 	}
-	return string(chars.slice)
+	return unsafe.String(unsafe.SliceData(chars.slice), len(chars.slice))
 }
 
 func (chars *Chars) ToRunes() []rune {
@@ -178,12 +178,12 @@ func (chars *Chars) ToRunes() []rune {
 	return runes
 }
 
-func (chars *Chars) CopyRunes(dest []rune) {
+func (chars *Chars) CopyRunes(dest []rune, from int) {
 	if runes := chars.optionalRunes(); runes != nil {
-		copy(dest, runes)
+		copy(dest, runes[from:])
 		return
 	}
-	for idx, b := range chars.slice[:len(dest)] {
+	for idx, b := range chars.slice[from:][:len(dest)] {
 		dest[idx] = rune(b)
 	}
 }

src/util/eventbox_test.go

@@ -9,7 +9,6 @@ const (
 	EvtSearchNew
 	EvtSearchProgress
 	EvtSearchFin
-	EvtClose
 )
 
 func TestEventBox(t *testing.T) {

src/util/util.go

@@ -3,26 +3,55 @@ package util
 import (
 	"math"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/mattn/go-isatty"
-	"github.com/mattn/go-runewidth"
+	"github.com/rivo/uniseg"
 )
 
-var _runeWidths = make(map[rune]int)
+// StringWidth returns string width where each CR/LF character takes 1 column
+func StringWidth(s string) int {
+	return uniseg.StringWidth(s) + strings.Count(s, "\n") + strings.Count(s, "\r")
+}
 
-// RuneWidth returns rune width
-func RuneWidth(r rune, prefixWidth int, tabstop int) int {
-	if r == '\t' {
-		return tabstop - prefixWidth%tabstop
-	} else if w, found := _runeWidths[r]; found {
-		return w
-	} else if r == '\n' || r == '\r' {
-		return 1
+// RunesWidth returns runes width
+func RunesWidth(runes []rune, prefixWidth int, tabstop int, limit int) (int, int) {
+	width := 0
+	gr := uniseg.NewGraphemes(string(runes))
+	idx := 0
+	for gr.Next() {
+		rs := gr.Runes()
+		var w int
+		if len(rs) == 1 && rs[0] == '\t' {
+			w = tabstop - (prefixWidth+width)%tabstop
+		} else {
+			w = StringWidth(string(rs))
+		}
+		width += w
+		if width > limit {
+			return width, idx
+		}
+		idx += len(rs)
 	}
-	w := runewidth.RuneWidth(r)
-	_runeWidths[r] = w
-	return w
+	return width, -1
+}
+
+// Truncate returns the truncated runes and its width
+func Truncate(input string, limit int) ([]rune, int) {
+	runes := []rune{}
+	width := 0
+	gr := uniseg.NewGraphemes(input)
+	for gr.Next() {
+		rs := gr.Runes()
+		w := StringWidth(string(rs))
+		if width+w > limit {
+			return runes, width
+		}
+		width += w
+		runes = append(runes, rs...)
+	}
+	return runes, width
 }
 
 // Max returns the largest integer
@@ -108,11 +137,16 @@ func DurWithin(
 	return val
 }
 
-// IsTty returns true is stdin is a terminal
+// IsTty returns true if stdin is a terminal
 func IsTty() bool {
 	return isatty.IsTerminal(os.Stdin.Fd())
 }
 
+// ToTty returns true if stdout is a terminal
+func ToTty() bool {
+	return isatty.IsTerminal(os.Stdout.Fd())
+}
+
 // Once returns a function that returns the specified boolean value only once
 func Once(nextResponse bool) func() bool {
 	state := nextResponse
@@ -122,3 +156,35 @@ func Once(nextResponse bool) func() bool {
 		return prevState
 	}
 }
+
+// RepeatToFill repeats the given string to fill the given width
+func RepeatToFill(str string, length int, limit int) string {
+	times := limit / length
+	rest := limit % length
+	output := strings.Repeat(str, times)
+	if rest > 0 {
+		for _, r := range str {
+			rest -= uniseg.StringWidth(string(r))
+			if rest < 0 {
+				break
+			}
+			output += string(r)
+			if rest == 0 {
+				break
+			}
+		}
+	}
+	return output
+}
+
+// ToKebabCase converts the given CamelCase string to kebab-case
+func ToKebabCase(s string) string {
+	name := ""
+	for i, r := range s {
+		if i > 0 && r >= 'A' && r <= 'Z' {
+			name += "-"
+		}
+		name += string(r)
+	}
+	return strings.ToLower(name)
+}

src/util/util_test.go

@@ -1,14 +1,76 @@
 package util
 
-import "testing"
+import (
+	"math"
+	"strings"
+	"testing"
+	"time"
+)
 
 func TestMax(t *testing.T) {
+	if Max(10, 1) != 10 {
+		t.Error("Expected", 10)
+	}
 	if Max(-2, 5) != 5 {
-		t.Error("Invalid result")
+		t.Error("Expected", 5)
 	}
 }
 
-func TestContrain(t *testing.T) {
+func TestMax16(t *testing.T) {
+	if Max16(10, 1) != 10 {
+		t.Error("Expected", 10)
+	}
+	if Max16(-2, 5) != 5 {
+		t.Error("Expected", 5)
+	}
+	if Max16(math.MaxInt16, 0) != math.MaxInt16 {
+		t.Error("Expected", math.MaxInt16)
+	}
+	if Max16(0, math.MinInt16) != 0 {
+		t.Error("Expected", 0)
+	}
+}
+
+func TestMax32(t *testing.T) {
+	if Max32(10, 1) != 10 {
+		t.Error("Expected", 10)
+	}
+	if Max32(-2, 5) != 5 {
+		t.Error("Expected", 5)
+	}
+	if Max32(math.MaxInt32, 0) != math.MaxInt32 {
+		t.Error("Expected", math.MaxInt32)
+	}
+	if Max32(0, math.MinInt32) != 0 {
+		t.Error("Expected", 0)
+	}
+}
+
+func TestMin(t *testing.T) {
+	if Min(10, 1) != 1 {
+		t.Error("Expected", 1)
+	}
+	if Min(-2, 5) != -2 {
+		t.Error("Expected", -2)
+	}
+}
+
+func TestMin32(t *testing.T) {
+	if Min32(10, 1) != 1 {
+		t.Error("Expected", 1)
+	}
+	if Min32(-2, 5) != -2 {
+		t.Error("Expected", -2)
+	}
+	if Min32(math.MaxInt32, 0) != 0 {
+		t.Error("Expected", 0)
+	}
+	if Min32(0, math.MinInt32) != math.MinInt32 {
+		t.Error("Expected", math.MinInt32)
+	}
+}
+
+func TestConstrain(t *testing.T) {
 	if Constrain(-3, -1, 3) != -1 {
 		t.Error("Expected", -1)
 	}
@@ -21,6 +83,55 @@ func TestContrain(t *testing.T) {
 	}
 }
 
+func TestConstrain32(t *testing.T) {
+	if Constrain32(-3, -1, 3) != -1 {
+		t.Error("Expected", -1)
+	}
+	if Constrain32(2, -1, 3) != 2 {
+		t.Error("Expected", 2)
+	}
+
+	if Constrain32(5, -1, 3) != 3 {
+		t.Error("Expected", 3)
+	}
+	if Constrain32(0, math.MinInt32, math.MaxInt32) != 0 {
+		t.Error("Expected", 0)
+	}
+}
+
+func TestAsUint16(t *testing.T) {
+	if AsUint16(5) != 5 {
+		t.Error("Expected", 5)
+	}
+	if AsUint16(-10) != 0 {
+		t.Error("Expected", 0)
+	}
+	if AsUint16(math.MaxUint16) != math.MaxUint16 {
+		t.Error("Expected", math.MaxUint16)
+	}
+	if AsUint16(math.MinInt32) != 0 {
+		t.Error("Expected", 0)
+	}
+	if AsUint16(math.MinInt16) != 0 {
+		t.Error("Expected", 0)
+	}
+	if AsUint16(math.MaxUint16+1) != math.MaxUint16 {
+		t.Error("Expected", math.MaxUint16)
+	}
+}
+
+func TestDurWithIn(t *testing.T) {
+	if DurWithin(time.Duration(5), time.Duration(1), time.Duration(8)) != time.Duration(5) {
+		t.Error("Expected", time.Duration(0))
+	}
+	if DurWithin(time.Duration(0)*time.Second, time.Second, time.Duration(3)*time.Second) != time.Second {
+		t.Error("Expected", time.Second)
+	}
+	if DurWithin(time.Duration(10)*time.Second, time.Duration(0), time.Second) != time.Second {
+		t.Error("Expected", time.Second)
+	}
+}
+
 func TestOnce(t *testing.T) {
 	o := Once(false)
 	if o() {
@@ -38,3 +149,57 @@ func TestOnce(t *testing.T) {
 		t.Error("Expected: false")
 	}
 }
+
+func TestRunesWidth(t *testing.T) {
+	for _, args := range [][]int{
+		{100, 5, -1},
+		{3, 4, 3},
+		{0, 1, 0},
+	} {
+		width, overflowIdx := RunesWidth([]rune("hello"), 0, 0, args[0])
+		if width != args[1] {
+			t.Errorf("Expected width: %d, actual: %d", args[1], width)
+		}
+		if overflowIdx != args[2] {
+			t.Errorf("Expected overflow index: %d, actual: %d", args[2], overflowIdx)
+		}
+	}
+	for _, input := range []struct {
+		s string
+		w int
+	}{
+		{"▶", 1},
+		{"▶️", 2},
+	} {
+		width, _ := RunesWidth([]rune(input.s), 0, 0, 100)
+		if width != input.w {
+			t.Errorf("Expected width of %s: %d, actual: %d", input.s, input.w, width)
+		}
+	}
+}
+
+func TestTruncate(t *testing.T) {
+	truncated, width := Truncate("가나다라마", 7)
+	if string(truncated) != "가나다" {
+		t.Errorf("Expected: 가나다, actual: %s", string(truncated))
+	}
+	if width != 6 {
+		t.Errorf("Expected: 6, actual: %d", width)
+	}
+}
+
+func TestRepeatToFill(t *testing.T) {
+	if RepeatToFill("abcde", 10, 50) != strings.Repeat("abcde", 5) {
+		t.Error("Expected:", strings.Repeat("abcde", 5))
+	}
+	if RepeatToFill("abcde", 10, 42) != strings.Repeat("abcde", 4)+"abcde"[:2] {
+		t.Error("Expected:", strings.Repeat("abcde", 4)+"abcde"[:2])
+	}
+}
+
+func TestStringWidth(t *testing.T) {
+	w := StringWidth("─")
+	if w != 1 {
+		t.Errorf("Expected: %d, Actual: %d", 1, w)
+	}
+}

src/util/util_unix.go

@@ -1,4 +1,4 @@
-// +build !windows
+//go:build !windows
 
 package util
 
@@ -6,6 +6,8 @@ import (
 	"os"
 	"os/exec"
 	"syscall"
+
+	"golang.org/x/sys/unix"
 )
 
 // ExecCommand executes the given command with $SHELL
@@ -45,3 +47,7 @@ func SetNonblock(file *os.File, nonblock bool) {
 func Read(fd int, b []byte) (int, error) {
 	return syscall.Read(int(fd), b)
 }
+
+func SetStdin(file *os.File) {
+	unix.Dup2(int(file.Fd()), 0)
+}

src/util/util_windows.go

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

typos.toml

@@ -0,0 +1,10 @@
+# See https://github.com/crate-ci/typos/blob/master/docs/reference.md to configure typos
+[default.extend-words]
+ba = "ba"
+fo = "fo"
+enew = "enew"
+tabe = "tabe"
+Iterm = "Iterm"
+
+[files]
+extend-exclude = ["README.md"]

uninstall

@@ -51,13 +51,8 @@ remove() {
 }
 
 remove_line() {
-  src=$(readlink "$1")
-  if [ $? -eq 0 ]; then
-    echo "Remove from $1 ($src):"
-  else
-    src=$1
-    echo "Remove from $1:"
-  fi
+  src=$1
+  echo "Remove from $1:"
 
   shift
   line_no=1
@@ -75,8 +70,9 @@ remove_line() {
     echo    "  - Line #$line_no: $content"
     [ "$content" = "$1" ] || ask "    - Remove?"
     if [ $? -eq 0 ]; then
-      awk -v n=$line_no 'NR == n {next} {print}' "$src" > "$src.bak" &&
-        mv "$src.bak" "$src" || break
+      temp=$(mktemp)
+      awk -v n=$line_no 'NR == n {next} {print}' "$src" > "$temp" &&
+        cat "$temp" > "$src" && rm -f "$temp" || break
       echo  "      - Removed"
     else
       echo  "      - Skipped"
@@ -98,16 +94,17 @@ done
 bind_file="${fish_dir}/functions/fish_user_key_bindings.fish"
 if [ -f "$bind_file" ]; then
   remove_line "$bind_file" "fzf_key_bindings"
+  remove_line "$bind_file" "fzf --fish | source"
 fi
 
 if [ -d "${fish_dir}/functions" ]; then
   remove "${fish_dir}/functions/fzf.fish"
   remove "${fish_dir}/functions/fzf_key_bindings.fish"
 
-  if [ "$(ls -A "${fish_dir}/functions")" ]; then
-    echo "Can't delete non-empty directory: \"${fish_dir}/functions\""
-  else
+  if [ -z "$(ls -A "${fish_dir}/functions")" ]; then
     rmdir "${fish_dir}/functions"
+  else
+    echo "Can't delete non-empty directory: \"${fish_dir}/functions\""
   fi
 fi