91 changed files with 2555 additions and 6364 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -0,0 +1,22 @@
+<!-- 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
+
--- a/.github/ISSUE_TEMPLATE/issue_template.yml
+++ b/.github/ISSUE_TEMPLATE/issue_template.yml
@ -1,49 +0,0 @@
---
-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
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@ -27,7 +27,7 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
      with:
        fetch-depth: 0

--- a/.github/workflows/depsreview.yaml
+++ b/.github/workflows/depsreview.yaml
@ -9,6 +9,6 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: 'Checkout Repository'
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
      - name: 'Dependency Review'
        uses: actions/dependency-review-action@v4
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@ -11,21 +11,18 @@ on:
 permissions:
  contents: read

-env:
-  LANG: C.UTF-8
-
 jobs:
  build:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
      with:
        fetch-depth: 0

    - name: Set up Go
      uses: actions/setup-go@v5
      with:
-        go-version: "1.20"
+        go-version: 1.19

    - name: Setup Ruby
      uses: ruby/setup-ruby@v1
@ -45,7 +42,4 @@ jobs:
      run: make test

    - name: Integration test
-      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
+      run: make install && ./install --all && LC_ALL=C tmux new-session -d && ruby test/test_go.rb --verbose
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@ -15,14 +15,14 @@ jobs:
  build:
    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
      with:
        fetch-depth: 0

    - name: Set up Go
      uses: actions/setup-go@v5
      with:
-        go-version: "1.20"
+        go-version: 1.18

    - name: Setup Ruby
      uses: ruby/setup-ruby@v1
--- a/.github/workflows/sponsors.yml
+++ b/.github/workflows/sponsors.yml
@ -9,7 +9,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout 🛎️
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3

      - name: Generate Sponsors 💖
        uses: JamesIves/github-sponsors-readme-action@v1
--- a/.github/workflows/typos.yml
+++ b/.github/workflows/typos.yml
@ -6,5 +6,5 @@ jobs:
    name: Spell Check with Typos
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v4
-    - uses: crate-ci/typos@v1.21.0
+    - uses: actions/checkout@v3
+    - uses: crate-ci/typos@v1.17.2
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@ -12,8 +12,6 @@ builds:
      - darwin
    goarch:
      - amd64
-    flags:
-      - -trimpath
    ldflags:
      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
    hooks:
@ -21,7 +19,11 @@ builds:
        sh -c '
        cat > /tmp/fzf-gon-amd64.hcl << EOF
        source = ["./dist/fzf-macos_darwin_amd64_v1/fzf"]
-        bundle_id = "junegunn.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)"
        }
@ -38,8 +40,6 @@ builds:
      - darwin
    goarch:
      - arm64
-    flags:
-      - -trimpath
    ldflags:
      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
    hooks:
@ -47,7 +47,11 @@ builds:
        sh -c '
        cat > /tmp/fzf-gon-arm64.hcl << EOF
        source = ["./dist/fzf-macos-arm_darwin_arm64/fzf"]
-        bundle_id = "junegunn.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)"
        }
@ -75,8 +79,6 @@ builds:
      - 5
      - 6
      - 7
-    flags:
-      - -trimpath
    ldflags:
      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
    ignore:
--- a/.tool-versions
+++ b/.tool-versions
@ -1 +1 @@
-golang 1.20.13
+golang 1.21.6
--- a/ADVANCED.md
+++ b/ADVANCED.md
@ -1,17 +1,18 @@
 Advanced fzf examples
 ======================

-* *Last update: 2024/06/06*
-* *Requires fzf 0.53.0 or later*
+* *Last update: 2024/01/20*
+* *Requires fzf 0.46.0 or above*

 ---

 <!-- vim-markdown-toc GFM -->

 * [Introduction](#introduction)
-* [Display modes](#display-modes)
+* [Screen Layout](#screen-layout)
    * [`--height`](#--height)
-    * [`--tmux`](#--tmux)
+    * [`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)
@ -62,7 +63,7 @@ learn its wide variety of features.
 This document will guide you through some examples that will familiarize you
 with the advanced features of fzf.

-Display modes
+Screen Layout
 -------------

 ### `--height`
@ -103,55 +104,56 @@ Define `$FZF_DEFAULT_OPTS` like so:
 export FZF_DEFAULT_OPTS="--height=40% --layout=reverse --info=inline --border --margin=1 --padding=1"
 ```

-### `--tmux`
+### `fzf-tmux`

-(Requires tmux 3.3 or later)
-
-If you're using tmux, you can open fzf in a tmux popup using `--tmux` option.
+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 in a tmux popup at the center of the screen with 70% width and height
-fzf --tmux 70%
+# Open fzf on a tmux split pane below the current pane.
+# Takes the same set of options.
+fzf-tmux --layout=reverse
 ```

-![image](https://github.com/junegunn/fzf/assets/700826/9c365405-c700-49b2-8985-60d822ed4cff)
+![image](https://user-images.githubusercontent.com/700826/113379973-f1cc6500-93b5-11eb-8860-c9bc4498aadf.png)

-`--tmux` option is silently ignored if you're not on tmux. So if you're trying
-to avoid opening fzf in fullscreen, try specifying both `--height` and `--tmux`.
+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
-# --tmux is specified later so it takes precedence over --height when on tmux.
-# If you're not on tmux, --tmux is ignored and --height is used instead.
-fzf  --height 70% --tmux 70%
-```
-
-You can also specify the position, width, and height of the popup window in
-the following format:
+# On the right (50%)
+fzf-tmux -r

-* `[center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]`
+# On the left (30%)
+fzf-tmux -l30%

-```sh
-# 100% width and 60% height
-fzf --tmux 100%,60% --border horizontal
+# Above the cursor
+fzf-tmux -u30%
 ```

-![image](https://github.com/junegunn/fzf/assets/700826/f80d3514-d69f-42f2-a8de-a392a562bfcf)
+![image](https://user-images.githubusercontent.com/700826/113379983-fa24a000-93b5-11eb-93eb-8a3d39b2f163.png)

-```sh
-# On the right (50% width)
-fzf --tmux right
-```
+![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)

-![image](https://github.com/junegunn/fzf/assets/700826/4033ade4-7efa-421b-a3fb-a430d197098a)
+#### 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
-# On the left (40% width and 70% height)
-fzf --tmux left,40%,70%
+# 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://github.com/junegunn/fzf/assets/700826/efe43881-2bf0-49ea-ab2e-1377f778cd52)
+![image](https://user-images.githubusercontent.com/700826/113380106-4a9bfd80-93b6-11eb-8cee-aeb1c4ce1a1f.png)

-> [!TIP]
 > You might also want to check out my tmux plugins which support this popup
 > window layout.
 >
@ -534,8 +536,8 @@ pods() {
    --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' \
-    --bind 'ctrl-o:execute:${EDITOR:-vim} <(kubectl logs --all-containers --namespace {1} {2})' \
+    --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}' "$@"
 }
@ -550,7 +552,7 @@ pods() {
    - 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
+- Press CTRL-/ repeatedly to to rotate through a different sets of preview
  window options
    1. `80%,border-bottom`
    1. `hidden`
--- a/BUILD.md
+++ b/BUILD.md
@ -6,7 +6,7 @@ Build instructions

 ### Prerequisites

- Go 1.20 or above
+- Go 1.18 or above

 ### Using Makefile

@ -24,23 +24,13 @@ 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
 --------------------------

@ -52,8 +42,6 @@ Third-party libraries used
    - 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
 -------
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,302 +1,6 @@
 CHANGELOG
 =========

-0.53.1
------
- Bug fixes and minor improvements
-
-0.53.0
------
- Multi-line display
-    - See [Processing multi-line items](https://junegunn.github.io/fzf/tips/processing-multi-line-items/)
-    - fzf can now display multi-line items
-      ```sh
-      # All bash functions, highlighted
-      declare -f | perl -0777 -pe 's/^}\n/}\0/gm' |
-        bat --plain --language bash --color always |
-        fzf --read0 --ansi --reverse --multi --highlight-line
-
-      # Ripgrep multi-line output
-      rg --pretty bash | perl -0777 -pe 's/\n\n/\n\0/gm' |
-        fzf --read0 --ansi --multi --highlight-line --reverse --tmux 70%
-      ```
-        - To disable multi-line display, use `--no-multi-line`
-    - CTRL-R bindings of bash, zsh, and fish have been updated to leverage multi-line display
-    - The default `--pointer` and `--marker` have been changed from `>` to Unicode bar characters as they look better with multi-line items
-    - Added `--marker-multi-line` to customize the select marker for multi-line entries with the default set to `╻┃╹`
-      ```
-      ╻First line
-      ┃...
-      ╹Last line
-      ```
- Native tmux integration
-    - Added `--tmux` option to replace fzf-tmux script and simplify distribution
-      ```sh
-      # --tmux [center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]
-      # Center, 100% width and 70% height
-      fzf --tmux 100%,70% --border horizontal --padding 1,2
-
-      # Left, 30% width
-      fzf --tmux left,30%
-
-      # Bottom, 50% height
-      fzf --tmux bottom,50%
-      ```
-        - To keep the implementation simple, it only uses popups. You need tmux 3.3 or later.
-    - To use `--tmux` in Vim plugin:
-      ```vim
-      let g:fzf_layout = { 'tmux': '100%,70%' }
-      ```
- Added support for endless input streams
-    - See [Browsing log stream with fzf](https://junegunn.github.io/fzf/tips/browsing-log-streams/)
-    - Added `--tail=NUM` option to limit the number of items to keep in memory. This is useful when you want to browse an endless stream of data (e.g. log stream) with fzf while limiting memory usage.
-      ```sh
-      # Interactive filtering of a log stream
-      tail -f *.log | fzf --tail 100000 --tac --no-sort --exact
-      ```
- Better Windows Support
-    - fzf now works on Git bash (mintty) out of the box via winpty integration
-    - Many fixes and improvements for Windows
- man page is now embedded in the binary; `fzf --man` to see it
- Changed the default `--scroll-off` to 3, as we think it's a better default
- Process started by `execute` action now directly writes to and reads from `/dev/tty`. Manual `/dev/tty` redirection for interactive programs is no longer required.
-  ```sh
-  # Vim will work fine without /dev/tty redirection
-  ls | fzf --bind 'space:execute:vim {}' > selected
-  ```
- Added `print(...)` action to queue an arbitrary string to be printed on exit. This was mainly added to work around the limitation of `--expect` where it's not compatible with `--bind` on the same key and it would ignore other actions bound to it.
-  ```sh
-  # This doesn't work as expected because --expect is not compatible with --bind
-  fzf --multi --expect ctrl-y --bind 'ctrl-y:select-all'
-
-  # This is something you can do instead
-  fzf --multi --bind 'enter:print()+accept,ctrl-y:select-all+print(ctrl-y)+accept'
-  ```
-    - We also considered making them compatible, but realized that some users may have been relying on the current behavior.
- [`NO_COLOR`](https://no-color.org/) environment variable is now respected. If the variable is set, fzf defaults to `--no-color` unless otherwise specified.
-
-0.52.1
------
- Fixed a critical bug in the Windows version
-    - Windows users are strongly encouraged to upgrade to this version
-
-0.52.0
------
- Added `--highlight-line` to highlight the whole current line (à la `set cursorline` of Vim)
- Added color names for selected lines: `selected-fg`, `selected-bg`, and `selected-hl`
-  ```sh
-  fzf --border --multi --info inline-right --layout reverse --marker ▏ --pointer ▌ --prompt '▌ '  \
-      --highlight-line --color gutter:-1,selected-bg:238,selected-fg:146,current-fg:189
-  ```
- Added `click-header` event that is triggered when the header section is clicked. When the event is triggered, `$FZF_CLICK_HEADER_COLUMN` and `$FZF_CLICK_HEADER_LINE` are set.
-  ```sh
-  fd --type f |
-    fzf --header $'[Files] [Directories]' --header-first \
-        --bind 'click-header:transform:
-          (( FZF_CLICK_HEADER_COLUMN <= 7 )) && echo "reload(fd --type f)"
-          (( FZF_CLICK_HEADER_COLUMN >= 9 )) && echo "reload(fd --type d)"
-        '
-  ```
- Add `$FZF_COMPLETION_{DIR,PATH}_OPTS` for separately customizing the behavior of fuzzy completion
-  ```sh
-  # Set --walker options without 'follow' not to follow symbolic links
-  FZF_COMPLETION_PATH_OPTS="--walker=file,dir,hidden"
-  FZF_COMPLETION_DIR_OPTS="--walker=dir,hidden"
-  ```
- Fixed Windows argument escaping
- Bug fixes and improvements
- The code was heavily refactored to allow using fzf as a library in Go programs. The API is still experimental and subject to change.
-    - https://gist.github.com/junegunn/193990b65be48a38aac6ac49d5669170
-
-0.51.0
------
- Added a new environment variable `$FZF_POS` exported to the child processes. It's the vertical position of the cursor in the list starting from 1.
-  ```sh
-  # Toggle selection to the top or to the bottom
-  seq 30 | fzf --multi --bind 'load:pos(10)' \
-    --bind 'shift-up:transform:for _ in $(seq $FZF_POS $FZF_MATCH_COUNT); do echo -n +toggle+up; done' \
-    --bind 'shift-down:transform:for _ in $(seq 1 $FZF_POS); do echo -n +toggle+down; done'
-  ```
- Added `--with-shell` option to start child processes with a custom shell command and flags
-  ```sh
-  gem list | fzf --with-shell 'ruby -e' \
-    --preview 'pp Gem::Specification.find_by_name({1})' \
-    --bind 'ctrl-o:execute-silent:
-        spec = Gem::Specification.find_by_name({1})
-        [spec.homepage, *spec.metadata.filter { _1.end_with?("uri") }.values].uniq.each do
-          system "open", _1
-        end
-    '
-  ```
- Added `change-multi` action for dynamically changing `--multi` option
-    - `change-multi` - enable multi-select mode with no limit
-    - `change-multi(NUM)` - enable multi-select mode with a limit
-    - `change-multi(0)` - disable multi-select mode
- Windows improvements
-    - `become` action is now supported on Windows
-        - Unlike in *nix, this does not use `execve(2)`. Instead it spawns a new process and waits for it to finish, so the exact behavior may differ.
-    - Fixed argument escaping for Windows cmd.exe. No redundant escaping of backslashes.
- Bug fixes and improvements
-
-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
--- a/4
+++ b/4
@ -1,6 +1,6 @@
-FROM ubuntu:24.04
+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.22.3 minitest
+RUN gem install --no-document -v 5.14.2 minitest
 RUN echo '. /usr/share/bash-completion/completions/git' >> ~/.bashrc
 RUN echo '. ~/.bashrc' >> ~/.bash_profile

--- a/14
+++ b/14
@ -1,10 +1,10 @@
 SHELL          := bash
 GO             ?= go
-GOOS           ?= $(shell $(GO) env GOOS)
+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 shell/*sh man/man1/*.1) $(MAKEFILE)
+SOURCES        := $(wildcard *.go src/*.go src/*/*.go) $(MAKEFILE)

 ifdef FZF_VERSION
 VERSION        := $(FZF_VERSION)
@ -25,7 +25,7 @@ endif
 ifeq ($(REVISION),)
 $(error Not on git repository; cannot determine $$FZF_REVISION)
 endif
-BUILD_FLAGS    := -a -ldflags "-s -w -X main.version=$(VERSION) -X main.revision=$(REVISION)" -tags "$(TAGS)" -trimpath
+BUILD_FLAGS    := -a -ldflags "-s -w -X main.version=$(VERSION) -X main.revision=$(REVISION)" -tags "$(TAGS)"

 BINARY32       := fzf-$(GOOS)_386
 BINARY64       := fzf-$(GOOS)_amd64
@ -173,12 +173,12 @@ bin/fzf: target/$(BINARY) | bin
 	cp -f target/$(BINARY) bin/fzf

 docker:
-	docker build -t fzf-ubuntu .
-	docker run -it fzf-ubuntu tmux
+	docker build -t fzf-arch .
+	docker run -it fzf-arch tmux

 docker-test:
-	docker build -t fzf-ubuntu .
-	docker run -it fzf-ubuntu
+	docker build -t fzf-arch .
+	docker run -it fzf-arch

 update:
 	$(GO) get -u
--- a/README-VIM.md
+++ b/README-VIM.md
@ -238,20 +238,19 @@ 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 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.
+command line without standard input pipe; fzf will use find command (or
+`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
+directory. When you select one, it will open it with the sink, `:e` command.
+If you want to open it in a new tab, you can pass `:tabedit` command instead
+as the sink.

 ```vim
 call fzf#run({'sink': 'tabedit'})
 ```

-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.
+Instead of using the default find command, you can use any shell command as
+the source. The following example will list the files managed by git. It's
+equivalent to running `git ls-files | fzf` on shell.

 ```vim
 call fzf#run({'source': 'git ls-files', 'sink': 'e'})
@ -294,7 +293,7 @@ The following table summarizes the available options.
 | `options`                  | string/list   | Options to fzf                                                        |
 | `dir`                      | string        | Working directory                                                     |
 | `up`/`down`/`left`/`right` | number/string | (Layout) Window position and size (e.g. `20`, `50%`)                  |
-| `tmux`                     | string        | (Layout) `--tmux` options (e.g. `90%,70%`)                            |
+| `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}`) |

@ -457,13 +456,12 @@ let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 ```

 Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
-or above) by putting `--tmux` option value in `tmux` key.
+or above) by putting fzf-tmux options in `tmux` key.

 ```vim
-" See `--tmux` option in `man fzf` for available options
-" [center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]
+" See `man fzf-tmux` for available options
 if exists('$TMUX')
-  let g:fzf_layout = { 'tmux': '90%,70%' }
+  let g:fzf_layout = { 'tmux': '-p90%,60%' }
 else
  let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 endif
--- a/README.md
+++ b/README.md
--- a/bin/fzf-tmux
+++ b/bin/fzf-tmux
@ -7,7 +7,7 @@ fail() {
  exit 2
 }

-fzf="$(command which fzf)" || fzf="$(dirname "$0")/fzf"
+fzf="$(command -v fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
 [[ -x "$fzf" ]] || fail 'fzf executable not found'

 args=()
@ -95,9 +95,9 @@ while [[ $# -gt 0 ]]; do
      elif [[ "$size" =~ %$ ]]; then
        size=${size:0:((${#size}-1))}
        if [[ -n "$swap" ]]; then
-          opt="$opt -l $(( 100 - size ))%"
+          opt="$opt -p $(( 100 - size ))"
        else
-          opt="$opt -l $size%"
+          opt="$opt -p $size"
        fi
      else
        if [[ -n "$swap" ]]; then
@ -132,10 +132,8 @@ if [[ -z "$TMUX" ]]; then
  exit $?
 fi

-# * --height option is not allowed
-# * CTRL-Z is also disabled
-# * fzf-tmux script is not compatible with --tmux option in fzf 0.53.0 or later
-args=("${args[@]}" "--no-height" "--bind=ctrl-z:ignore" "--no-tmux")
+# --height option is not allowed. CTRL-Z is also disabled.
+args=("${args[@]}" "--no-height" "--bind=ctrl-z:ignore")

 # Handle zoomed tmux pane without popup options by moving it to a temp window
 if [[ ! "$opt" =~ "-E" ]] && tmux list-panes -F '#F' | grep -q Z; then
@ -198,9 +196,8 @@ if [[ "$opt" =~ "-E" ]]; then
    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 "$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")"
 [[ -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"
--- a/doc/fzf.txt
+++ b/doc/fzf.txt
@ -1,4 +1,4 @@
-fzf.txt	fzf	Last change: February 15 2024
+fzf.txt	fzf	Last change: January 1 2024
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================

@ -264,18 +264,17 @@ 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 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.
+command line without standard input pipe; fzf will use find command (or
+`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
+directory. When you select one, it will open it with the sink, `:e` command.
+If you want to open it in a new tab, you can pass `:tabedit` command instead
+as the sink.
 >
    call fzf#run({'sink': 'tabedit'})
 <
-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.
+Instead of using the default find command, you can use any shell command as
+the source. The following example will list the files managed by git. It's
+equivalent to running `git ls-files | fzf` on shell.
 >
    call fzf#run({'source': 'git ls-files', 'sink': 'e'})
 <
@ -311,7 +310,7 @@ The following table summarizes the available options.
  `options`                   | string/list   | Options to fzf
  `dir`                       | string        | Working directory
  `up` / `down` / `left` / `right`  | number/string | (Layout) Window position and size (e.g.  `20` ,  `50%` )
-  `tmux`                      | string        | (Layout) `--tmux` options (e.g.  `90%,70%` )
+  `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}` )
 ---------------------------+---------------+----------------------------------------------------------------------
@ -418,12 +417,24 @@ TIPS                                                                  *fzf-tips*
 < fzf inside terminal buffer >________________________________________________~
                                                    *fzf-inside-terminal-buffer*

+The latest versions of Vim and Neovim include builtin terminal emulator
+(`:terminal`) and fzf will start in a terminal buffer in the following cases:
+
+ - On Neovim
+ - On GVim
+ - On Terminal Vim with a non-default layout
+   - `call fzf#run({'left': '30%'})` or `let g:fzf_layout = {'left': '30%'}`

 On the latest versions of Vim and Neovim, fzf will start in a terminal buffer.
 If you find the default ANSI colors to be different, consider configuring the
 colors using `g:terminal_ansi_colors` in regular Vim or `g:terminal_color_x`
 in Neovim.

+                   *g:terminal_color_15* *g:terminal_color_14* *g:terminal_color_13*
+*g:terminal_color_12* *g:terminal_color_11* *g:terminal_color_10* *g:terminal_color_9*
+   *g:terminal_color_8* *g:terminal_color_7* *g:terminal_color_6* *g:terminal_color_5*
+   *g:terminal_color_4* *g:terminal_color_3* *g:terminal_color_2* *g:terminal_color_1*
+                                                            *g:terminal_color_0*
 >
    " Terminal colors for seoul256 color scheme
    if has('nvim')
@ -469,12 +480,11 @@ in Neovim.
    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 <
 Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
-or above) by putting `--tmux` options in `tmux` key.
+or above) by putting fzf-tmux options in `tmux` key.
 >
-    " See `--tmux` option in `man fzf` for available options
-    " [center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]
+    " See `man fzf-tmux` for available options
    if exists('$TMUX')
-      let g:fzf_layout = { 'tmux': '90%,70%' }
+      let g:fzf_layout = { 'tmux': '-p90%,60%' }
    else
      let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
    endif
--- a/go.mod
+++ b/go.mod
@ -1,20 +1,22 @@
 module github.com/junegunn/fzf

 require (
-	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/gdamore/tcell/v2 v2.5.4
+	github.com/junegunn/uniseg v0.0.0-20240120174029-b504da4f6ed2
+	github.com/mattn/go-isatty v0.0.17
 	github.com/mattn/go-shellwords v1.0.12
-	github.com/rivo/uniseg v0.4.7
-	golang.org/x/sys v0.20.0
-	golang.org/x/term v0.20.0
+	github.com/saracen/walker v0.1.3
+	golang.org/x/sys v0.16.0
+	golang.org/x/term v0.16.0
 )

 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
+	github.com/mattn/go-runewidth v0.0.14 // indirect
+	github.com/rivo/uniseg v0.4.4 // indirect
+	golang.org/x/sync v0.5.0 // indirect
+	golang.org/x/text v0.5.0 // indirect
 )

-go 1.20
+go 1.17
--- a/go.sum
+++ b/go.sum
@ -1,57 +1,52 @@
-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/v2 v2.7.4 h1:sg6/UnTM9jGpZU+oFYAsDahfchWAFW8Xx2yFinNSAYU=
-github.com/gdamore/tcell/v2 v2.7.4/go.mod h1:dSXtXTSK0VsW1biw65DZLZ2NKr7j0qP/0J7ONmsraWg=
+github.com/gdamore/tcell/v2 v2.5.4 h1:TGU4tSjD3sCL788vFNeJnTdzpNKIw1H5dgLnJRQVv/k=
+github.com/gdamore/tcell/v2 v2.5.4/go.mod h1:dZgRy5v4iMobMEcWNYBtREnDZAT9DYmfqIkrgEMxLyw=
+github.com/junegunn/uniseg v0.0.0-20240120174029-b504da4f6ed2 h1:oEwPBh29BPu1MaTsz2dM9bDrkOgKBoYFC0u6uY2izWo=
+github.com/junegunn/uniseg v0.0.0-20240120174029-b504da4f6ed2/go.mod h1:ywqF55XaSE3/uS2tkJqVFKiE0oIYAXRvU2N7DU4y3XQ=
 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.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-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
+github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
+github.com/mattn/go-runewidth v0.0.14/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/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/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/saracen/walker v0.1.3 h1:YtcKKmpRPy6XJTHJ75J2QYXXZYWnZNQxPCVqZSHVV/g=
+github.com/saracen/walker v0.1.3/go.mod h1:FU+7qU8DeQQgSZDmmThMJi93kPkLFgy0oVAcLxurjIk=
 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-20220601150217-0de741cfad7f/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/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE=
+golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 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-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.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.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.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
-golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
+golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 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/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM=
+golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 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=
--- a/44
+++ b/44
@ -2,7 +2,7 @@

 set -u

-version=0.53.0
+version=0.46.0
 auto_completion=
 key_bindings=
 update_config=2
@ -115,7 +115,7 @@ link_fzf_in_path() {
 try_curl() {
  command -v curl > /dev/null &&
  if [[ $1 =~ tar.gz$ ]]; then
-    curl -fL $1 | tar --no-same-owner -xzf -
+    curl -fL $1 | tar -xzf -
  else
    local temp=${TMPDIR:-/tmp}/fzf.zip
    curl -fLo "$temp" $1 && unzip -o "$temp" && rm -f "$temp"
@ -125,7 +125,7 @@ try_curl() {
 try_wget() {
  command -v wget > /dev/null &&
  if [[ $1 =~ tar.gz$ ]]; then
-    wget -O - $1 | tar --no-same-owner -xzf -
+    wget -O - $1 | tar -xzf -
  else
    local temp=${TMPDIR:-/tmp}/fzf.zip
    wget -O "$temp" $1 && unzip -o "$temp" && rm -f "$temp"
@ -262,16 +262,6 @@ if [[ ! "\$PATH" == *$fzf_base_esc/bin* ]]; then
  PATH="\${PATH:+\${PATH}:}$fzf_base/bin"
 fi

-EOF
-
-  if [[ $auto_completion -eq 1 ]] && [[ $key_bindings -eq 1 ]]; then
-    if [[ "$shell" = zsh ]]; then
-      echo "source <(fzf --$shell)" >> "$src"
-    else
-      echo "eval \"\$(fzf --$shell)\"" >> "$src"
-    fi
-  else
-    cat >> "$src" << EOF
 # Auto-completion
 # ---------------
 $fzf_completion
@ -280,7 +270,6 @@ $fzf_completion
 # ------------
 $fzf_key_bindings
 EOF
-  fi
  echo "OK"
 done

@ -292,6 +281,18 @@ 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"
+  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() {
@ -354,23 +355,12 @@ 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 --fish | source' \
+      '  fzf_key_bindings' \
      'end'
  else
-    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
+    append_line $update_config "fzf_key_bindings" "$bind_file"
  fi
 fi

--- a/install.ps1
+++ b/install.ps1
@ -1,4 +1,4 @@
-$version="0.53.0"
+$version="0.46.0"

 $fzf_base=Split-Path -Parent $MyInvocation.MyCommand.Definition

--- a/main.go
+++ b/main.go
@ -1,101 +1,14 @@
 package main

 import (
-	_ "embed"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-
 	fzf "github.com/junegunn/fzf/src"
 	"github.com/junegunn/fzf/src/protector"
 )

-var version = "0.53"
-var revision = "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
-
-//go:embed man/man1/fzf.1
-var manPage []byte
-
-func printScript(label string, content []byte) {
-	fmt.Println("### " + label + " ###")
-	fmt.Println(strings.TrimSpace(string(content)))
-	fmt.Println("### end: " + label + " ###")
-}
-
-func exit(code int, err error) {
-	if code == fzf.ExitError {
-		fmt.Fprintln(os.Stderr, err.Error())
-	}
-	os.Exit(code)
-}
+var version string = "0.46"
+var revision string = "devel"

 func main() {
 	protector.Protect()
-
-	options, err := fzf.ParseOptions(true, os.Args[1:])
-	if err != nil {
-		exit(fzf.ExitError, err)
-		return
-	}
-	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
-	}
-	if options.Help {
-		fmt.Print(fzf.Usage)
-		return
-	}
-	if options.Version {
-		if len(revision) > 0 {
-			fmt.Printf("%s (%s)\n", version, revision)
-		} else {
-			fmt.Println(version)
-		}
-		return
-	}
-	if options.Man {
-		file := fzf.WriteTemporaryFile([]string{string(manPage)}, "\n")
-		if len(file) == 0 {
-			fmt.Print(string(manPage))
-			return
-		}
-		defer os.Remove(file)
-		cmd := exec.Command("man", file)
-		cmd.Stdin = os.Stdin
-		cmd.Stdout = os.Stdout
-		if err := cmd.Run(); err != nil {
-			fmt.Print(string(manPage))
-		}
-		return
-	}
-
-	code, err := fzf.Run(options)
-	exit(code, err)
+	fzf.Run(fzf.ParseOptions(), version, revision)
 }
--- a/man/man1/fzf-tmux.1
+++ b/man/man1/fzf-tmux.1
@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf-tmux 1 "Jun 2024" "fzf 0.53.0" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Jan 2024" "fzf 0.46.0" "fzf-tmux - open fzf in tmux split pane"

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

 .SH NAME
 fzf - a command-line fuzzy finder
@ -30,16 +30,9 @@ fzf - a command-line fuzzy finder
 fzf [options]

 .SH DESCRIPTION
-fzf is an interactive filter program for any kind of list.
-
-It implements a "fuzzy" matching algorithm, so you can quickly type in patterns
-with omitted characters and still get the results you want.
+fzf is a general-purpose command-line fuzzy finder.

 .SH OPTIONS
-.SS Note
-.TP
-Most long options have the opposite version with \fB--no-\fR prefix.
-
 .SS Search mode
 .TP
 .B "-x, --extended"
@ -49,10 +42,10 @@ it with \fB+x\fR or \fB--no-extended\fR.
 .B "-e, --exact"
 Enable exact-match
 .TP
-.B "-i, --ignore-case"
+.B "-i"
 Case-insensitive match (default: smart-case match)
 .TP
-.B "+i, --no-ignore-case"
+.B "+i"
 Case-sensitive match
 .TP
 .B "--literal"
@ -61,32 +54,14 @@ Do not normalize latin script letters for matching.
 .BI "--scheme=" SCHEME
 Choose scoring scheme tailored for different types of input.

-.RS
-.B default
-.RS
-Generic scoring scheme designed to work well with any type of input.
-.RE
-.RE
-
-.RS
-.B path
-.RS
-Additional bonus point is only given to the characters after path separator.
-You might want to choose this scheme over \fBdefault\fR if you have many files
-with spaces in their paths.
-.RE
-.RE
-
-.RS
-.B history
-.RS
-Scoring scheme well suited for command history or any input where chronological
-ordering is important. No additional bonus points are given so that we give
-more weight to the chronological ordering. This also sets
-\fB--tiebreak=index\fR.
-.RE
-.RE
-
+.br
+.BR default "  Generic scoring scheme designed to work well with any type of input"
+.br
+.BR path "     Scoring scheme well suited for file paths
+.br
+.BR history "  Scoring scheme well suited for command history or any input where chronological ordering is important
+         Sets \fB--tiebreak=index\fR as well.
+.br
 .TP
 .BI "--algo=" TYPE
 Fuzzy matching algorithm (default: v2)
@ -106,8 +81,7 @@ See \fBFIELD INDEX EXPRESSION\fR for the details.
 Transform the presentation of each line using field index expressions
 .TP
 .BI "-d, --delimiter=" "STR"
-Field delimiter regex for \fB--nth\fR, \fB--with-nth\fR, and field index
-expressions (default: AWK-style)
+Field delimiter regex for \fB--nth\fR and \fB--with-nth\fR (default: AWK-style)
 .TP
 .BI "--disabled"
 Do not perform search. With this option, fzf becomes a simple selector
@ -118,16 +92,6 @@ interface rather than a "fuzzy finder". You can later enable the search using
 .B "+s, --no-sort"
 Do not sort the result
 .TP
-.B "--tail=NUM"
-Maximum number of items to keep in memory. This is useful when you want to
-browse an endless stream of data (e.g. log stream) with fzf while limiting
-memory usage.
-.RS
-e.g.
-     \fB# Interactive filtering of a log stream
-     tail -f *.log | fzf --tail 100000 --tac --no-sort --exact\fR
-.RE
-.TP
 .B "--track"
 Make fzf track the current selection when the result list is updated.
 This can be useful when browsing logs using fzf with sorting disabled. It is
@ -194,16 +158,13 @@ the details.
 .B "--cycle"
 Enable cyclic scroll
 .TP
-.B "--no-multi-line"
-Disable multi-line display of items when using \fB--read0\fR
-.TP
 .B "--keep-right"
 Keep the right end of the line visible when it's too long. Effective only when
 the query string is empty.
 .TP
 .BI "--scroll-off=" "LINES"
 Number of screen lines to keep above or below when scrolling to the top or to
-the bottom (default: 3).
+the bottom (default: 0).
 .TP
 .B "--no-hscroll"
 Disable horizontal scroll
@ -226,7 +187,7 @@ actions are affected:
 \fBkill-word\fR
 .TP
 .BI "--jump-labels=" "CHARS"
-Label characters for \fBjump\fR mode.
+Label characters for \fBjump\fR and \fBjump-accept\fR
 .SS Layout
 .TP
 .BI "--height=" "[~]HEIGHT[%]"
@ -239,41 +200,17 @@ height minus the given value.
  fzf --height=-1

 When prefixed with \fB~\fR, fzf will automatically determine the height in the
-range according to the input size.
+range according to the input size. Note that adaptive height is not compatible
+with top/bottom margin and padding given in percent size. It is also not
+compatible with a negative height value.

  # Will not take up 100% of the screen
  seq 5 | fzf --height=~100%

-Adaptive height has the following limitations:
-.br
-* Cannot be used with top/bottom margin and padding given in percent size
-.br
-* Negative value is not allowed
-.br
-* It will not find the right size when there are multi-line items
-
 .TP
 .BI "--min-height=" "HEIGHT"
 Minimum height when \fB--height\fR is given in percent (default: 10).
 Ignored when \fB--height\fR is not specified.
-.TP
-.BI "--tmux" "[=[center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]]"
-Start fzf in a tmux popup (default \fBcenter,50%\fR). Requires tmux 3.3 or
-later. This option is ignored if you are not running fzf inside tmux.
-
-e.g.
-  \fB# Popup in the center with 70% width and height
-  fzf --tmux 70%
-
-  # Popup on the left with 40% width and 100% height
-  fzf --tmux right,40%
-
-  # Popup on the bottom with 100% width and 30% height
-  fzf --tmux bottom,30%
-
-  # Popup on the top with 80% width and 40% height
-  fzf --tmux top,80%,40%\fR
-
 .TP
 .BI "--layout=" "LAYOUT"
 Choose the layout (default: default)
@ -431,21 +368,20 @@ e.g.

 .TP
 .BI "--info=" "STYLE"
-Determines the display style of the finder info. (e.g. match counter, loading indicator, etc.)
+Determines the display style of finder info (match counters).

-.BR default "              On the left end of the horizontal separator"
 .br
-.BR right "                On the right end of the horizontal separator"
+.BR default "          Display on the next line to the prompt"
 .br
-.BR hidden "               Do not display finder info"
+.BR right "            Display on the right end of the next line to the prompt"
 .br
-.BR inline "               After the prompt with the default prefix ' < '"
+.BR inline "           Display on the same line with the default separator ' < '"
 .br
-.BR inline:PREFIX "        After the prompt with a non-default prefix"
+.BR inline:SEPARATOR " Display on the same line with a non-default separator"
 .br
-.BR inline-right "         On the right end of the prompt line"
+.BR inline-right "     Display on the right end of the same line
 .br
-.BR inline-right:PREFIX "  On the right end of the prompt line with a custom prefix"
+.BR hidden "           Do not display finder info"
 .br

 .TP
@ -479,14 +415,10 @@ Do not display scrollbar. A synonym for \fB--scrollbar=''\fB
 Input prompt (default: '> ')
 .TP
 .BI "--pointer=" "STR"
-Pointer to the current line (default: '▌' or '>' depending on \fB--no-unicode\fR)
+Pointer to the current line (default: '>')
 .TP
 .BI "--marker=" "STR"
-Multi-select marker (default: '┃' or '>' depending on \fB--no-unicode\fR)
-.TP
-.BI "--marker-multi-line=" "STR"
-Multi-select marker for multi-line entries. 3 elements for top, middle, and bottom.
-(default: '╻┃╹' or '.|'' depending on \fB--no-unicode\fR)
+Multi-select marker (default: '>')
 .TP
 .BI "--header=" "STR"
 The given string will be printed as the sticky header. The lines are displayed
@ -518,7 +450,7 @@ color mappings.

 .RS
 .B BASE SCHEME:
-    (default: \fBdark\fR on 256-color terminal, otherwise \fB16\fR; If \fBNO_COLOR\fR is set, \fBbw\fR)
+    (default: dark on 256-color terminal, otherwise 16)

    \fBdark    \fRColor scheme for dark 256-color terminal
    \fBlight   \fRColor scheme for light 256-color terminal
@ -527,17 +459,14 @@ color mappings.

 .B COLOR NAMES:
    \fBfg                  \fRText
-      \fBselected-fg       \fRSelected line text
      \fBpreview-fg        \fRPreview window text
    \fBbg                  \fRBackground
-      \fBselected-bg       \fRSelected line background
      \fBpreview-bg        \fRPreview window background
    \fBhl                  \fRHighlighted substrings
-      \fBselected-hl       \fRHighlighted substrings in the selected line
-    \fBcurrent-fg (fg+)    \fRText (current line)
-    \fBcurrent-bg (bg+)    \fRBackground (current line)
+    \fBfg+                 \fRText (current line)
+    \fBbg+                 \fRBackground (current line)
      \fBgutter            \fRGutter on the left
-    \fBcurrent-hl (hl+)    \fRHighlighted substrings (current line)
+    \fBhl+                 \fRHighlighted substrings (current line)
    \fBquery               \fRQuery string
      \fBdisabled          \fRQuery string when search is disabled (\fB--disabled\fR)
    \fBinfo                \fRInfo line (match counters)
@ -600,9 +529,6 @@ color mappings.
         --color='pointer:#E12672,marker:#E17899,prompt:#98BEDE,hl+:#98BC99'\fR
 .RE
 .TP
-.B "--highlight-line"
-Highlight the whole current line
-.TP
 .B "--no-bold"
 Do not use bold text
 .TP
@ -694,7 +620,7 @@ The following example uses https://github.com/junegunn/fzf/blob/master/bin/fzf-p
 script to render an image using either of the protocols inside the preview window.

 e.g.
-      \fBfzf --preview='fzf-preview.sh {}'\fR
+      \fBfzf --preview='fzf-preview.sh {}'

 .RE

@ -857,14 +783,6 @@ list.
 e.g.
     \fBfzf --expect=ctrl-v,ctrl-t,alt-s --expect=f1,f2,~,@\fR
 .RE
-
-This option is not compatible with \fB--bind\fR on the same key and will take
-precedence over it. To combine the two, use \fBprint\fR action.
-
-.RS
-e.g.
-     \fBfzf --multi --bind 'enter:print()+accept,ctrl-y:select-all+print(ctrl-y)+accept'\fR
-.RE
 .TP
 .B "--read0"
 Read input delimited by ASCII NUL characters instead of newline characters
@ -889,22 +807,12 @@ e.g.
 .TP
 .B "--sync"
 Synchronous search for multi-staged filtering. If specified, fzf will launch
-the finder only after the input stream is complete.
+ncurses finder only after the input stream is complete.

 .RS
 e.g. \fBfzf --multi | fzf --sync\fR
 .RE
 .TP
-.B "--with-shell=STR"
-Shell command and flags to start child processes with. On *nix Systems, the
-default value is \fB$SHELL -c\fR if \fB$SHELL\fR is set, otherwise \fBsh -c\fR.
-On Windows, the default value is \fBcmd /s/c\fR when \fB$SHELL\fR is not
-set.
-
-.RS
-e.g. \fBgem list | fzf --with-shell 'ruby -e' --preview 'pp Gem::Specification.find_by_name({1})'\fR
-.RE
-.TP
 .B "--listen[=[ADDR:]PORT]" "--listen-unsafe[=[ADDR:]PORT]"
 Start HTTP server and listen on the given address. It allows external processes
 to send actions to perform via POST method.
@ -942,60 +850,12 @@ e.g.
     # Choose port automatically and export it as $FZF_PORT to the child process
     fzf --listen --bind 'start:execute-silent:echo $FZF_PORT > /tmp/fzf-port'
     \fR
-.SS Help
 .TP
 .B "--version"
 Display version information and exit
-.TP
-.B "--help"
-Show help message
-.TP
-.B "--man"
-Show man page

-.SS Directory traversal
 .TP
-.B "--walker=[file][,dir][,follow][,hidden]"
-Determines the behavior of the built-in directory walker that is used when
-\fB$FZF_DEFAULT_COMMAND\fR is not set. The default value is \fBfile,follow,hidden\fR.
-
-* \fBfile\fR: Include files in the search result
-.br
-* \fBdir\fR: Include directories in the search result
-.br
-* \fBhidden\fR: Include and follow hidden directories
-.br
-* \fBfollow\fR: Follow symbolic links
-.br
-
-.TP
-.B "--walker-root=DIR"
-The root directory from which to start the built-in directory walker.
-The default value is the current working directory.
-
-.TP
-.B "--walker-skip=DIRS"
-Comma-separated list of directory names to skip during the directory walk.
-The default value is \fB.git,node_modules\fR.
-
-.SS Shell integration
-.TP
-.B "--bash"
-Print script to set up Bash shell integration
-
-e.g. \fBeval "$(fzf --bash)"\fR
-
-.TP
-.B "--zsh"
-Print script to set up Zsh shell integration
-
-e.g. \fBsource <(fzf --zsh)\fR
-
-.TP
-.B "--fish"
-Print script to set up Fish shell integration
-
-e.g. \fBfzf --fish | source\fR
+Note that most options have the opposite versions with \fB--no-\fR prefix.

 .SH ENVIRONMENT VARIABLES
 .TP
@ -1005,14 +865,7 @@ with \fB$SHELL -c\fR if \fBSHELL\fR is set, otherwise with \fBsh -c\fR, so in
 this case make sure that the command is POSIX-compliant.
 .TP
 .B FZF_DEFAULT_OPTS
-Default options.
-.br
-e.g. \fBexport FZF_DEFAULT_OPTS="--layout=reverse --border --cycle"\fR
-.TP
-.B FZF_DEFAULT_OPTS_FILE
-The location of the file that contains the default options.
-.br
-e.g. \fBexport FZF_DEFAULT_OPTS_FILE=~/.fzfrc\fR
+Default options. e.g. \fBexport FZF_DEFAULT_OPTS="--extended --cycle"\fR
 .TP
 .B FZF_API_KEY
 Can be used to require an API key when using \fB--listen\fR option. If not set,
@ -1026,10 +879,6 @@ you need to protect against DNS rebinding and privilege escalation attacks.
 .br
 .BR 2 "      Error"
 .br
-.BR 126 "    Permission denied error from \fBbecome\fR action"
-.br
-.BR 127 "    Invalid shell command for \fBbecome\fR action"
-.br
 .BR 130 "    Interrupted with \fBCTRL-C\fR or \fBESC\fR"

 .SH FIELD INDEX EXPRESSION
@ -1070,20 +919,12 @@ fzf exports the following environment variables to its child processes.
 .br
 .BR FZF_SELECT_COUNT "    Number of selected items"
 .br
-.BR FZF_POS "             Vertical position of the cursor in the list starting from 1"
-.br
 .BR FZF_QUERY "           Current query string"
 .br
 .BR FZF_PROMPT "          Prompt string"
 .br
-.BR FZF_PREVIEW_LABEL "   Preview label string"
-.br
-.BR FZF_BORDER_LABEL "    Border label string"
-.br
 .BR FZF_ACTION "          The name of the last action performed"
 .br
-.BR FZF_KEY "             The name of the last key pressed"
-.br
 .BR FZF_PORT "            Port number when --listen option is used"
 .br

@ -1154,21 +995,21 @@ e.g.
 .br
 \fIctrl-]\fR
 .br
-\fIctrl-^\fR         (\fIctrl-6\fR)
+\fIctrl-^\fR      (\fIctrl-6\fR)
 .br
-\fIctrl-/\fR         (\fIctrl-_\fR)
+\fIctrl-/\fR      (\fIctrl-_\fR)
 .br
 \fIctrl-alt-[a-z]\fR
 .br
-\fIalt-[*]\fR        (Any case-sensitive single character is allowed)
+\fIalt-[*]\fR     (Any case-sensitive single character is allowed)
 .br
 \fIf[1-12]\fR
 .br
-\fIenter\fR          (\fIreturn\fR \fIctrl-m\fR)
+\fIenter\fR       (\fIreturn\fR \fIctrl-m\fR)
 .br
 \fIspace\fR
 .br
-\fIbackspace\fR      (\fIbspace\fR \fIbs\fR)
+\fIbspace\fR      (\fIbs\fR)
 .br
 \fIalt-up\fR
 .br
@ -1182,15 +1023,15 @@ e.g.
 .br
 \fIalt-space\fR
 .br
-\fIalt-backspace\fR  (\fIalt-bspace\fR \fIalt-bs\fR)
+\fIalt-bspace\fR  (\fIalt-bs\fR)
 .br
 \fItab\fR
 .br
-\fIshift-tab\fR      (\fIbtab\fR)
+\fIbtab\fR        (\fIshift-tab\fR)
 .br
 \fIesc\fR
 .br
-\fIdelete\fR         (\fIdel\fR)
+\fIdel\fR
 .br
 \fIup\fR
 .br
@ -1206,9 +1047,9 @@ e.g.
 .br
 \fIinsert\fR
 .br
-\fIpage-up\fR        (\fIpgup\fR)
+\fIpgup\fR        (\fIpage-up\fR)
 .br
-\fIpage-down\fR      (\fIpgdn\fR)
+\fIpgdn\fR        (\fIpage-down\fR)
 .br
 \fIshift-up\fR
 .br
@ -1262,7 +1103,6 @@ e.g.
     \fB# Move cursor to the last item and select all items
     seq 1000 | fzf --multi --sync --bind start:last+select-all\fR
 .RE
-
 \fIload\fR
 .RS
 Triggered when the input stream is complete and the initial processing of the
@ -1272,7 +1112,6 @@ e.g.
     \fB# 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> '\fR
 .RE
-
 \fIresize\fR
 .RS
 Triggered when the terminal size is changed.
@ -1280,7 +1119,6 @@ Triggered when the terminal size is changed.
 e.g.
     \fBfzf --bind 'resize:transform-header:echo Resized: ${FZF_COLUMNS}x${FZF_LINES}'\fR
 .RE
-
 \fIresult\fR
 .RS
 Triggered when the filtering for the current query is complete and the result list is ready.
@ -1314,7 +1152,6 @@ e.g.
     # Beware not to introduce an infinite loop
     seq 10 | fzf --bind 'focus:up' --cycle\fR
 .RE
-
 \fIone\fR
 .RS
 Triggered when there's only one match. \fBone:accept\fR binding is comparable
@ -1326,7 +1163,6 @@ e.g.
     \fB# Automatically select the only match
     seq 10 | fzf --bind one:accept\fR
 .RE
-
 \fIzero\fR
 .RS
 Triggered when there's no match. \fBzero:abort\fR binding is comparable to
@ -1348,31 +1184,6 @@ e.g.
     \fBfzf --bind backward-eof:abort\fR
 .RE

-\fIjump\fR
-.RS
-Triggered when successfully jumped to the target item in \fBjump\fR mode.
-
-e.g.
-     \fBfzf --bind space:jump,jump:accept\fR
-.RE
-
-\fIjump-cancel\fR
-.RS
-Triggered when \fBjump\fR mode is cancelled.
-
-e.g.
-     \fBfzf --bind space:jump,jump:accept,jump-cancel:abort\fR
-.RE
-
-\fIclick-header\fR
-.RS
-Triggered when a mouse click occurs within the header. Sets \fBFZF_CLICK_HEADER_LINE\fR and \fBFZF_CLICK_HEADER_COLUMN\fR environment variables starting from 1.
-
-e.g.
-     \fBprintf "head1\\nhead2" | fzf --header-lines=2 --bind 'click-header:transform-prompt:printf ${FZF_CLICK_HEADER_LINE}x${FZF_CLICK_HEADER_COLUMN}'\fR
-
-.RE
-
 .SS AVAILABLE ACTIONS:
 A key or an event can be bound to one or more of the following actions.

@ -1391,8 +1202,6 @@ A key or an event can be bound to one or more of the following actions.
    \fBcancel\fR                       (clear query string if not empty, abort fzf otherwise)
    \fBchange-border-label(...)\fR     (change \fB--border-label\fR to the given string)
    \fBchange-header(...)\fR           (change header to the given string; doesn't affect \fB--header-lines\fR)
-    \fBchange-multi\fR                 (enable multi-select mode with no limit)
-    \fBchange-multi(...)\fR            (enable multi-select mode with a limit or disable it with 0)
    \fBchange-preview(...)\fR          (change \fB--preview\fR option)
    \fBchange-preview-label(...)\fR    (change \fB--preview-label\fR to the given string)
    \fBchange-preview-window(...)\fR   (change \fB--preview-window\fR option; rotate through the multiple option sets separated by '|')
@ -1417,6 +1226,7 @@ A key or an event can be bound to one or more of the following actions.
    \fBforward-word\fR                 \fIalt-f   shift-right\fR
    \fBignore\fR
    \fBjump\fR                         (EasyMotion-like 2-keystroke movement)
+    \fBjump-accept\fR                  (jump and accept)
    \fBkill-line\fR
    \fBkill-word\fR                    \fIalt-d\fR
    \fBlast\fR                         (move to the last match; same as \fBpos(-1)\fR)
@ -1442,7 +1252,7 @@ A key or an event can be bound to one or more of the following actions.
    \fBpreview-half-page-up\fR
    \fBpreview-bottom\fR
    \fBpreview-top\fR
-    \fBprint(...)\fR                   (add string to the output queue and print on exit)
+    \fBprint-query\fR                  (print query and exit)
    \fBput\fR                          (put the character to the prompt)
    \fBput(...)\fR                     (put the given string to the prompt)
    \fBrefresh-preview\fR
@ -1464,10 +1274,9 @@ A key or an event can be bound to one or more of the following actions.
    \fBtoggle-preview-wrap\fR
    \fBtoggle-search\fR                (toggle search functionality)
    \fBtoggle-sort\fR
-    \fBtoggle-track\fR                 (toggle global tracking option (\fB--track\fR))
-    \fBtoggle-track-current\fR         (toggle tracking of the current item)
+    \fBtoggle-track\fR
    \fBtoggle+up\fR                    \fIbtab    (shift-tab)\fR
-    \fBtrack-current\fR                (track the current item; automatically disabled if focus changes)
+    \fBtrack\fR                        (track the current item; automatically disabled if focus changes)
    \fBtransform(...)\fR               (transform states using the output of an external command)
    \fBtransform-border-label(...)\fR  (transform border label using an external command)
    \fBtransform-header(...)\fR        (transform header using an external command)
@ -1477,7 +1286,6 @@ A key or an event can be bound to one or more of the following actions.
    \fBunbind(...)\fR                  (unbind bindings)
    \fBunix-line-discard\fR            \fIctrl-u\fR
    \fBunix-word-rubout\fR             \fIctrl-w\fR
-    \fBuntrack-current\fR              (stop tracking the current item; no-op if global tracking is enabled)
    \fBup\fR                           \fIctrl-k  ctrl-p  up\fR
    \fByank\fR                         \fIctrl-y\fR

@ -1550,6 +1358,8 @@ call.

    \fBfzf --bind "enter:become(vim {})"\fR

+\fBbecome(...)\fR is not supported on Windows.
+
 .SS RELOAD INPUT

 \fBreload(...)\fR action is used to dynamically update the input list
--- a/plugin/fzf.vim
+++ b/plugin/fzf.vim
@ -59,9 +59,12 @@ if s:is_win
    return iconv(a:str, &encoding, 'cp'.s:codepage)
  endfunction
  function! s:wrap_cmds(cmds)
-    return map(['@echo off']
+    return map([
+      \ '@echo off',
+      \ 'setlocal enabledelayedexpansion']
    \ + (has('gui_running') ? ['set TERM= > nul'] : [])
-    \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds]),
+    \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds])
+    \ + ['endlocal'],
    \ '<SID>enc_to_cp(v:val."\r")')
  endfunction
 else
@ -81,21 +84,11 @@ else
 endif

 function! s:shellesc_cmd(arg)
-  let e = '"'
-  let slashes = 0
-  for c in split(a:arg, '\zs')
-    if c ==# '\'
-      let slashes += 1
-    elseif c ==# '"'
-      let e .= repeat('\', slashes + 1)
-      let slashes = 0
-    else
-      let slashes = 0
-    endif
-    let e .= c
-  endfor
-  let e .= repeat('\', slashes) .'"'
-  return substitute(substitute(e, '[&|<>()^!"]', '^&', 'g'), '%', '%%', 'g')
+  let escaped = substitute(a:arg, '[&|<>()@^]', '^&', 'g')
+  let escaped = substitute(escaped, '%', '%%', 'g')
+  let escaped = substitute(escaped, '"', '\\^&', 'g')
+  let escaped = substitute(escaped, '\(\\\+\)\(\\^\)', '\1\1\2', 'g')
+  return '^"'.substitute(escaped, '\(\\\+\)$', '\1\1', '').'^"'
 endfunction

 function! fzf#shellescape(arg, ...)
@ -327,10 +320,7 @@ function! s:common_sink(action, lines) abort
    " the execution (e.g. `set autochdir` or `autocmd BufEnter * lcd ...`)
    let cwd = exists('w:fzf_pushd') ? w:fzf_pushd.dir : expand('%:p:h')
    for item in a:lines
-      if has('win32unix') && item !~ '/'
-        let item = substitute(item, '\', '/', 'g')
-      end
-      if item[0] != '~' && item !~ (s:is_win ? '^\([A-Z]:\)\?\' : '^/')
+      if item[0] != '~' && item !~ (s:is_win ? '^[A-Z]:\' : '^/')
        let sep = s:is_win ? '\' : '/'
        let item = join([cwd, item], cwd[len(cwd)-1] == sep ? '' : sep)
      endif
@ -490,8 +480,6 @@ function! s:extract_option(opts, name)
  return opt
 endfunction

-let s:need_cmd_window = has('win32unix') && $TERM_PROGRAM ==# 'mintty' && s:compare_versions($TERM_PROGRAM_VERSION, '3.4.5') < 0 && !executable('winpty')
-
 function! fzf#run(...) abort
 try
  let [shell, shellslash, shellcmdflag, shellxquote] = s:use_sh()
@ -513,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 s:writefile(source, temps.input)
-      let prefix = (s:is_win ? 'type ' : 'command cat ').fzf#shellescape(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')
@ -534,23 +522,26 @@ try
        \ executable('tput') && filereadable('/dev/tty')
  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
-    \ && !s:need_cmd_window
-    \ && (has('gui_running') || s:is_win || s:present(dict, 'down', 'up', 'left', 'right', 'window'))
+  let use_term = has_nvim_term ||
+    \ 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_term
-    let optstr .= ' --no-height --no-tmux'
+    let optstr .= ' --no-height'
  elseif use_height
    let height = s:calc_size(&lines, dict.down, dict)
-    let optstr .= ' --no-tmux --height='.height
+    let optstr .= ' --height='.height
  endif
  " 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 command = prefix.(use_tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
+  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)
@ -561,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
@ -579,21 +578,19 @@ function! s:fzf_tmux(dict)
  if empty(size)
    for o in ['up', 'down', 'left', 'right']
      if s:present(a:dict, o)
-        let size = o . ',' . a:dict[o]
+        let spec = a:dict[o]
+        if (o == 'up' || o == 'down') && spec[0] == '~'
+          let size = '-'.o[0].s:calc_size(&lines, spec, a:dict)
+        else
+          " Legacy boolean option
+          let size = '-'.o[0].(spec == 1 ? '' : substitute(spec, '^\~', '', ''))
+        endif
        break
      endif
    endfor
  endif
-
-  " Legacy fzf-tmux options
-  if size =~ '-'
-    return printf('LINES=%d COLUMNS=%d %s %s %s --',
-          \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size, (has_key(a:dict, 'source') ? '' : '-'))
-  end
-
-  " Using native --tmux option
-  let in = (has_key(a:dict, 'source') ? '' : ' --force-tty-in')
-  return printf('%s --tmux %s%s', fzf#shellescape(fzf#exec()), size, in)
+  return printf('LINES=%d COLUMNS=%d %s %s - --',
+    \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size)
 endfunction

 function! s:splittable(dict)
@ -716,15 +713,14 @@ function! s:execute(dict, command, use_height, temps) abort
      call jobstart(cmd, fzf)
      return []
    endif
-  elseif s:need_cmd_window
+  elseif has('win32unix') && $TERM !=# 'cygwin'
    let shellscript = s:fzf_tempname()
    call s:writefile([command], shellscript)
-    let command = 'start //WAIT sh -c '.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
--- a/shell/completion.bash
+++ b/shell/completion.bash
@ -4,44 +4,37 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ completion.bash
 #
-# - $FZF_TMUX                 (default: 0)
-# - $FZF_TMUX_OPTS            (default: empty)
-# - $FZF_COMPLETION_TRIGGER   (default: '**')
-# - $FZF_COMPLETION_OPTS      (default: empty)
-# - $FZF_COMPLETION_PATH_OPTS (default: empty)
-# - $FZF_COMPLETION_DIR_OPTS  (default: empty)
+# - $FZF_TMUX               (default: 0)
+# - $FZF_TMUX_OPTS          (default: empty)
+# - $FZF_COMPLETION_TRIGGER (default: '**')
+# - $FZF_COMPLETION_OPTS    (default: empty)

-if [[ $- =~ i ]]; then
+[[ $- =~ i ]] || return 0


 # 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@^\./@@'
-#   }
+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 | command 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 | command sed 's@^\./@@'
+  }
+fi

 ###########################################################

 # To redraw line after fzf closes (printf '\e[5n')
 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
    _fzf_comprun "$@"
@ -70,117 +63,135 @@ __fzf_orig_completion() {
  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="
-    +c --no-color
-    +i --no-ignore-case
-    +s --no-sort
+    -h --help
+    -x --extended
+    -e --exact
+    --extended-exact
    +x --no-extended
-    --ansi
-    --bash
+    +e --no-exact
+    -q --query
+    -f --filter
+    --literal
+    --no-literal
+    --algo
+    --scheme
+    --expect
+    --no-expect
+    --enabled --no-phony
+    --disabled --phony
+    --tiebreak
    --bind
-    --border
-    --border-label
-    --border-label-pos
    --color
+    --toggle-sort
+    -d --delimiter
+    -n --nth
+    --with-nth
+    -s --sort
+    +s --no-sort
+    --track
+    --no-track
+    --tac
+    --no-tac
+    -i
+    +i
+    -m --multi
+    +m --no-multi
+    --ansi
+    --no-ansi
+    --no-mouse
+    +c --no-color
+    +2 --no-256
+    --black
+    --no-black
+    --bold
+    --no-bold
+    --layout
+    --reverse
+    --no-reverse
    --cycle
-    --disabled
-    --ellipsis
-    --expect
-    --filepath-word
-    --fish
-    --header
-    --header-first
-    --header-lines
-    --height
-    --highlight-line
-    --history
-    --history-size
-    --hscroll-off
-    --info
-    --jump-labels
+    --no-cycle
    --keep-right
-    --layout
-    --listen
-    --listen-unsafe
-    --literal
-    --man
-    --margin
-    --marker
-    --min-height
-    --no-bold
-    --no-clear
+    --no-keep-right
+    --hscroll
    --no-hscroll
-    --no-mouse
-    --no-scrollbar
+    --hscroll-off
+    --scroll-off
+    --filepath-word
+    --no-filepath-word
+    --info
+    --no-info
+    --inline-info
+    --no-inline-info
+    --separator
    --no-separator
-    --no-unicode
-    --padding
+    --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
+    --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
+    --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
-    --preview-window
-    --print-query
-    --print0
-    --prompt
-    --read0
-    --reverse
-    --scheme
-    --scroll-off
-    --separator
-    --sync
+    --no-unicode
+    --unicode
+    --margin
+    --padding
    --tabstop
-    --tac
-    --tiebreak
-    --tmux
-    --track
+    --listen
+    --no-listen
+    --clear
+    --no-clear
    --version
-    --with-nth
-    --with-shell
-    --zsh
-    -0 --exit-0
-    -1 --select-1
-    -d --delimiter
-    -e --exact
-    -f --filter
-    -h --help
-    -i --ignore-case
-    -m --multi
-    -n --nth
-    -q --query
    --"

  case "${prev}" in
+  --algo)
+    COMPREPLY=( $(compgen -W "v1 v2" -- "$cur") )
+    return 0
+    ;;
  --scheme)
    COMPREPLY=( $(compgen -W "default path history" -- "$cur") )
    return 0
@ -250,32 +261,28 @@ _fzf_opts_completion() {
 }

 _fzf_handle_dynamic_completion() {
-  local cmd ret REPLY orig_cmd orig_complete
+  local cmd orig_var orig ret orig_cmd orig_complete
  cmd="$1"
  shift
  orig_cmd="$1"
-  if __fzf_orig_completion_get_orig_func "$cmd"; then
-    "$REPLY" "$@"
+  orig_var="_fzf_orig_completion_$cmd"
+  orig="${!orig_var-}"
+  orig="${orig##*#}"
+  if [[ -n "$orig" ]] && type "$orig" > /dev/null 2>&1; then
+    $orig "$@"
  elif [[ -n "${_fzf_completion_loader-}" ]]; then
    orig_complete=$(complete -p "$orig_cmd" 2> /dev/null)
-    $_fzf_completion_loader "$@"
+    _completion_loader "$@"
    ret=$?
    # _completion_loader may not have updated completion for the command
    if [[ "$(complete -p "$orig_cmd" 2> /dev/null)" != "$orig_complete" ]]; then
      __fzf_orig_completion < <(complete -p "$orig_cmd" 2> /dev/null)
-
-      # 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
 }
@ -286,6 +293,7 @@ __fzf_generic_path_completion() {
  if [[ $cmd == \\* ]]; then
    cmd="${cmd:1}"
  fi
+  cmd="${cmd//[^A-Za-z0-9_=]/_}"
  COMPREPLY=()
  trigger=${FZF_COMPLETION_TRIGGER-'**'}
  cur="${COMP_WORDS[COMP_CWORD]}"
@ -301,24 +309,9 @@ __fzf_generic_path_completion() {
        leftover=${leftover/#\/}
        [[ -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
-            if [[ $1 =~ dir ]]; then
-              walker=dir,follow
-              rest=${FZF_COMPLETION_DIR_OPTS-}
-            else
-              walker=file,dir,follow,hidden
-              rest=${FZF_COMPLETION_PATH_OPTS-}
-            fi
-            __fzf_comprun "$4" -q "$leftover" --walker "$walker" --walker-root="$dir" $rest
-          fi | while read -r item; do
-            printf "%q " "${item%$3}$3"
-          done
-        )
+        matches=$(eval "$1 $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --scheme=path --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_COMPLETION_OPTS-} $2" __fzf_comprun "$4" -q "$leftover" | 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
@ -366,16 +359,13 @@ _fzf_complete() {
  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" ]] && [[ $cur != *'$('* ]] && [[ $cur != *':='* ]] && [[ $cur != *'`'* ]]; then
    cur=${cur:0:${#cur}-${#trigger}}

-    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=$(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 | command tr '\n' ' ')
    selected=${selected% } # Strip trailing space not to repeat "-o nospace"
    if [[ -n "$selected" ]]; then
      COMPREPLY=("$selected")
@ -479,11 +469,8 @@ complete -o default -F _fzf_opts_completion fzf
 # 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}"
-
-# NOTE: $FZF_COMPLETION_PATH_COMMANDS and $FZF_COMPLETION_VAR_COMMANDS are
-# undocumented and subject to change in the future.
-a_cmds="${FZF_COMPLETION_PATH_COMMANDS-"
+d_cmds="${FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir}"
+a_cmds="
  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
@ -491,31 +478,25 @@ a_cmds="${FZF_COMPLETION_PATH_COMMANDS-"
  basename bunzip2 bzip2 chmod chown curl cp dirname du
  find git grep gunzip gzip hg jar
  ln ls mv open rm rsync scp
-  svn tar unzip zip"}"
-v_cmds="${FZF_COMPLETION_VAR_COMMANDS-export unset printenv}"
+  svn tar unzip zip"

 # Preserve existing completion
-__fzf_orig_completion < <(complete -p $d_cmds $a_cmds $v_cmds unalias kill ssh 2> /dev/null)
-
-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
+__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
 fi

 __fzf_defc() {
-  local cmd func opts REPLY
+  local cmd func opts orig_var orig def
  cmd="$1"
  func="$2"
  opts="$3"
-  if __fzf_orig_completion_instantiate "$cmd" "$func"; then
-    eval "$REPLY"
+  orig_var="_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}"
+  orig="${!orig_var-}"
+  if [[ -n "$orig" ]]; then
+    printf -v def "$orig" "$func"
+    eval "$def"
  else
    complete -F "$func" $opts "$cmd"
  fi
@ -528,24 +509,13 @@ done

 # Directory
 for cmd in $d_cmds; do
-  __fzf_defc "$cmd" _fzf_dir_completion "-o bashdefault -o nospace -o dirnames"
-done
-
-# Variables
-for cmd in $v_cmds; do
-  __fzf_defc "$cmd" _fzf_var_completion "-o default -o nospace -v"
+  __fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o dirnames"
 done

-# Aliases
-__fzf_defc unalias _fzf_alias_completion "-a"
-
-# Processes
-__fzf_defc kill _fzf_proc_completion "-o default -o bashdefault"
-
 # ssh
 __fzf_defc ssh _fzf_complete_ssh "-o default -o bashdefault"

-unset cmd d_cmds a_cmds v_cmds
+unset cmd d_cmds a_cmds

 _fzf_setup_completion() {
  local kind fn cmd
@ -567,4 +537,8 @@ _fzf_setup_completion() {
  done
 }

-fi
+# Environment variables / Aliases / Hosts / Process
+_fzf_setup_completion 'var'   export unset printenv
+_fzf_setup_completion 'alias' unalias
+_fzf_setup_completion 'host'  telnet
+_fzf_setup_completion 'proc'  kill
--- a/shell/completion.zsh
+++ b/shell/completion.zsh
@ -4,12 +4,12 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ completion.zsh
 #
-# - $FZF_TMUX                 (default: 0)
-# - $FZF_TMUX_OPTS            (default: empty)
-# - $FZF_COMPLETION_TRIGGER   (default: '**')
-# - $FZF_COMPLETION_OPTS      (default: empty)
-# - $FZF_COMPLETION_PATH_OPTS (default: empty)
-# - $FZF_COMPLETION_DIR_OPTS  (default: empty)
+# - $FZF_TMUX               (default: 0)
+# - $FZF_TMUX_OPTS          (default: '-d 40%')
+# - $FZF_COMPLETION_TRIGGER (default: '**')
+# - $FZF_COMPLETION_OPTS    (default: empty)
+
+[[ -o interactive ]] || return 0


 # Both branches of the following `if` do the same thing -- define
@ -75,34 +75,26 @@ fi
 # 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.
 {
-# 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}
-#
-#   _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@^\./@@'
-#   }
+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_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
@ -156,25 +148,10 @@ __fzf_generic_path_completion() {
      leftover=${leftover/#\/}
      [ -z "$dir" ] && dir='.'
      [ "$dir" != "/" ] && dir="${dir/%\//}"
-      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
-          if [[ $compgen =~ dir ]]; then
-            walker=dir,follow
-            rest=${FZF_COMPLETION_DIR_OPTS-}
-          else
-            walker=file,dir,follow,hidden
-            rest=${FZF_COMPLETION_PATH_OPTS-}
-          fi
-          __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" --walker "$walker" --walker-root="$dir" ${(Q)${(Z+n+)rest}} < /dev/tty
-        fi | while read item; do
-          item="${item%$suffix}$suffix"
-          echo -n "${(q)item} "
-        done
-      )
+      matches=$(eval "$compgen $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --scheme=path --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_COMPLETION_OPTS-}" __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" | while read item; do
+        item="${item%$suffix}$suffix"
+        echo -n "${(q)item} "
+      done)
      matches=${matches% }
      if [ -n "$matches" ]; then
        LBUFFER="$lbuf$matches$tail"
@ -234,10 +211,7 @@ _fzf_complete() {
  type $post > /dev/null 2>&1 || post=cat

  _fzf_feed_fifo "$fifo"
-  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' ' ')
+  matches=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_COMPLETION_OPTS-} $str_arg" __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
  if [ -n "$matches" ]; then
    LBUFFER="$lbuf$matches"
  fi
@ -335,7 +309,7 @@ fzf-completion() {

  # Trigger sequence given
  if [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
-    d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS-cd pushd rmdir})
+    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
@ -365,7 +339,6 @@ fzf-completion() {

 zle     -N   fzf-completion
 bindkey '^I' fzf-completion
-fi

 } always {
  # Restore the original options.
--- a/shell/key-bindings.bash
+++ b/shell/key-bindings.bash
@ -11,24 +11,20 @@
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS

-if [[ $- =~ i ]]; then
+[[ $- =~ i ]] || return 0


 # 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) "$@" |
+  local cmd opts
+  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 | command cut -b3-"}"
+  opts="--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore --reverse --scheme=path ${FZF_DEFAULT_OPTS-} ${FZF_CTRL_T_OPTS-} -m"
+  eval "$cmd" |
+    FZF_DEFAULT_OPTS="$opts" $(__fzfcmd) "$@" |
    while read -r item; do
      printf '%q ' "$item"  # escape special chars
    done
@ -46,26 +42,25 @@ fzf-file-widget() {
 }

 __fzf_cd__() {
-  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)"
+  local cmd opts 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 | command cut -b3-"}"
+  opts="--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore --reverse --scheme=path ${FZF_DEFAULT_OPTS-} ${FZF_ALT_C_OPTS-} +m"
+  dir=$(set +o pipefail; eval "$cmd" | FZF_DEFAULT_OPTS="$opts" $(__fzfcmd)) && printf 'builtin cd -- %q' "$dir"
 }

 if command -v perl > /dev/null; then
  __fzf_history__() {
-    local output script
-    script='BEGIN { getc; $/ = "\n\t"; $HISTCOUNT = $ENV{last_hist} + 1 } s/^[ *]//; s/\n/\n\t/gm; print $HISTCOUNT - $. . "\t$_" if !$seen{$_}++'
+    local output opts script
+    opts="--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} -n2..,.. --scheme=history --bind=ctrl-r:toggle-sort ${FZF_CTRL_R_OPTS-} +m --read0"
+    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 --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
-        FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
+        FZF_DEFAULT_OPTS="$opts" $(__fzfcmd) --query "$READLINE_LINE"
    ) || return
-    READLINE_LINE=$(command perl -pe 's/^\d*\t//' <<< "$output")
+    READLINE_LINE=${output#*$'\t'}
    if [[ -z "$READLINE_POINT" ]]; then
      echo "$READLINE_LINE"
    else
@ -74,13 +69,14 @@ if command -v perl > /dev/null; then
  }
 else # awk - fallback for POSIX systems
  __fzf_history__() {
-    local output script n x y z d
+    local output opts 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
+    opts="--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} -n2..,.. --scheme=history --bind=ctrl-r:toggle-sort ${FZF_CTRL_R_OPTS-} +m --read0"
    [[ $(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 }
@ -91,8 +87,7 @@ else # awk - fallback for POSIX systems
      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 --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
-        FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
+        FZF_DEFAULT_OPTS="$opts" $(__fzfcmd) --query "$READLINE_LINE"
    ) || return
    READLINE_LINE=${output#*$'\t'}
    if [[ -z "$READLINE_POINT" ]]; then
@ -112,11 +107,9 @@ bind -m emacs-standard '"\C-z": vi-editing-mode'

 if (( BASH_VERSINFO[0] < 4 )); then
  # CTRL-T - Paste the selected file path into the command line
-  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
+  bind -m emacs-standard '"\C-t": " \C-b\C-k \C-u`__fzf_select__`\e\C-e\er\C-a\C-y\C-h\C-e\e \C-y\ey\C-x\C-x\C-f"'
+  bind -m vi-command '"\C-t": "\C-z\C-t\C-z"'
+  bind -m vi-insert '"\C-t": "\C-z\C-t\C-z"'

  # CTRL-R - Paste the selected command from history into the command line
  bind -m emacs-standard '"\C-r": "\C-e \C-u\C-y\ey\C-u`__fzf_history__`\e\C-e\er"'
@ -124,11 +117,9 @@ if (( BASH_VERSINFO[0] < 4 )); then
  bind -m vi-insert '"\C-r": "\C-z\C-r\C-z"'
 else
  # CTRL-T - Paste the selected file path into the command line
-  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
+  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'

  # CTRL-R - Paste the selected command from history into the command line
  bind -m emacs-standard -x '"\C-r": __fzf_history__'
@ -137,10 +128,6 @@ else
 fi

 # ALT-C - cd into the selected directory
-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
+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"'
--- a/shell/key-bindings.fish
+++ b/shell/key-bindings.fish
@ -18,28 +18,25 @@ status is-interactive; or exit 0
 # ------------
 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 -lx dir $commandline[1]
+    set -l dir $commandline[1]
    set -l fzf_query $commandline[2]
    set -l prefix $commandline[3]

+    # "-path \$dir'*/.*'" matches hidden files/folders inside $dir but not
+    # $dir itself, even if hidden.
+    test -n "$FZF_CTRL_T_COMMAND"; or set -l FZF_CTRL_T_COMMAND "
+    command find -L \$dir -mindepth 1 \\( -path \$dir'*/.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
+    -o -type f -print \
+    -o -type d -print \
+    -o -type l -print 2> /dev/null | sed 's@^\./@@'"
+
    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
    begin
-      set -lx FZF_DEFAULT_OPTS (__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
+      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse --scheme=path --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS"
+      eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)' -m --query "'$fzf_query'"' | while read -l r; set result $result $r; end
    end
    if [ -z "$result" ]
      commandline -f repaint
@ -59,31 +56,19 @@ 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 --scheme=history --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS +m"
+
      set -l FISH_MAJOR (echo $version | cut -f1 -d.)
      set -l FISH_MINOR (echo $version | cut -f2 -d.)

-      # merge history from other sessions before searching
-      if test -z "$fish_private_mode"
-        builtin history merge
-      end
-
      # history's -z flag is needed for multi-line support.
      # history's -z flag was added in fish 2.4.0, so don't use it for versions
      # before 2.4.0.
      if [ "$FISH_MAJOR" -gt 2 -o \( "$FISH_MAJOR" -eq 2 -a "$FISH_MINOR" -ge 4 \) ];
-        if type -P perl > /dev/null 2>&1
-          set -lx FZF_DEFAULT_OPTS (__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --highlight-line $FZF_CTRL_R_OPTS +m")
-          set -lx FZF_DEFAULT_OPTS_FILE ''
-          builtin history -z --reverse | command perl -0 -pe 's/^/$.\t/g; s/\n/\n\t/gm' | eval (__fzfcmd) --tac --read0 --print0 -q '(commandline)' | command perl -pe 's/^\d*\t//' | read -lz result
-          and commandline -- $result
-        else
-          set -lx FZF_DEFAULT_OPTS (__fzf_defaults "" "--scheme=history --bind=ctrl-r:toggle-sort --highlight-line $FZF_CTRL_R_OPTS +m")
-          set -lx FZF_DEFAULT_OPTS_FILE ''
-          builtin history -z | eval (__fzfcmd) --read0 --print0 -q '(commandline)' | read -lz result
-          and commandline -- $result
-        end
+        history -z | eval (__fzfcmd) --read0 --print0 -q '(commandline)' | read -lz result
+        and commandline -- $result
      else
-        builtin history | eval (__fzfcmd) -q '(commandline)' | read -l result
+        history | eval (__fzfcmd) -q '(commandline)' | read -l result
        and commandline -- $result
      end
    end
@ -92,19 +77,20 @@ function fzf_key_bindings

  function fzf-cd-widget -d "Change directory"
    set -l commandline (__fzf_parse_commandline)
-    set -lx dir $commandline[1]
+    set -l 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 (__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
+      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse --scheme=path --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS"
+      eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)' +m --query "'$fzf_query'"' | read -l result

      if [ -n "$result" ]
-        builtin cd -- $result
+        cd -- $result

        # Remove last token from commandline.
        commandline -t ""
@ -127,22 +113,14 @@ function fzf_key_bindings
    end
  end

+  bind \ct fzf-file-widget
  bind \cr fzf-history-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
+  bind \ec fzf-cd-widget

  if bind -M insert > /dev/null 2>&1
+    bind -M insert \ct fzf-file-widget
    bind -M insert \cr fzf-history-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
+    bind -M insert \ec fzf-cd-widget
  end

  function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath, fzf query, and optional -option= prefix'
--- a/shell/key-bindings.zsh
+++ b/shell/key-bindings.zsh
@ -11,6 +11,8 @@
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS

+[[ -o interactive ]] || return 0
+

 # Key bindings
 # ------------
@ -36,23 +38,16 @@ fi
 'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' 'no_aliases'

 {
-if [[ -o interactive ]]; then
-
-__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
-__fzf_select() {
+__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-"}"
  setopt localoptions pipefail no_aliases 2> /dev/null
  local item
-  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
+  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --scheme=path --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_CTRL_T_OPTS-}" $(__fzfcmd) -m "$@" | while read item; do
    echo -n "${(q)item} "
  done
  local ret=$?
@ -66,64 +61,50 @@ __fzfcmd() {
 }

 fzf-file-widget() {
-  LBUFFER="${LBUFFER}$(__fzf_select)"
+  LBUFFER="${LBUFFER}$(__fsel)"
  local ret=$?
  zle reset-prompt
  return $ret
 }
-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
+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

 # 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="$(
-    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)"
+  local dir="$(eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --scheme=path --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_ALT_C_OPTS-}" $(__fzfcmd) +m)"
  if [[ -z "$dir" ]]; then
    zle redisplay
    return 0
  fi
  zle push-line # Clear buffer. Auto-restored on next prompt.
-  BUFFER="builtin cd -- ${(q)dir:a}"
+  BUFFER="builtin cd -- ${(q)dir}"
  zle accept-line
  local ret=$?
  unset dir # ensure this doesn't end up appearing in prompt expansion
  zle reset-prompt
  return $ret
 }
-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
+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

 # 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 noglob 2> /dev/null
-  # Ensure the associative history array, which maps event numbers to the full
-  # history lines, is loaded, and that Perl is installed for multi-line output.
-  if zmodload -F zsh/parameter p:history 2>/dev/null && (( ${#commands[perl]} )); then
-    selected="$(printf '%1$s\t%2$s\000' "${(vk)history[@]}" |
-      perl -0 -ne 'if (!$seen{(/^\s*[0-9]+\**\s+(.*)/, $1)}++) { s/\n/\n\t/gm; print; }' |
-      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m --read0") \
-      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
-  else
-    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 --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m") \
-      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
-  fi
+  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2> /dev/null
+  selected="$(fc -rl 1 | awk '{ cmd=$0; sub(/^[ \t]*[0-9]+\**[ \t]+/, "", cmd); if (!seen[cmd]++) print $0 }' |
+    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} ${FZF_DEFAULT_OPTS-} -n2..,.. --scheme=history --bind=ctrl-r:toggle-sort,ctrl-z:ignore ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m" $(__fzfcmd))"
  local ret=$?
  if [ -n "$selected" ]; then
-    if num=$(awk '{print $1; exit}' <<< "$selected" | grep -o '^[1-9][0-9]*'); 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
@ -135,7 +116,6 @@ 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
--- a/src/actiontype_string.go
+++ b/src/actiontype_string.go
@ -26,105 +26,100 @@ func _() {
 	_ = x[actCancel-15]
 	_ = x[actChangeBorderLabel-16]
 	_ = x[actChangeHeader-17]
-	_ = x[actChangeMulti-18]
-	_ = x[actChangePreviewLabel-19]
-	_ = x[actChangePrompt-20]
-	_ = x[actChangeQuery-21]
-	_ = x[actClearScreen-22]
-	_ = x[actClearQuery-23]
-	_ = x[actClearSelection-24]
-	_ = x[actClose-25]
-	_ = x[actDeleteChar-26]
-	_ = x[actDeleteCharEof-27]
-	_ = x[actEndOfLine-28]
-	_ = x[actFatal-29]
-	_ = x[actForwardChar-30]
-	_ = x[actForwardWord-31]
-	_ = x[actKillLine-32]
-	_ = x[actKillWord-33]
-	_ = x[actUnixLineDiscard-34]
-	_ = x[actUnixWordRubout-35]
-	_ = x[actYank-36]
-	_ = x[actBackwardKillWord-37]
-	_ = x[actSelectAll-38]
-	_ = x[actDeselectAll-39]
-	_ = x[actToggle-40]
-	_ = x[actToggleSearch-41]
-	_ = x[actToggleAll-42]
-	_ = x[actToggleDown-43]
-	_ = x[actToggleUp-44]
-	_ = x[actToggleIn-45]
-	_ = x[actToggleOut-46]
-	_ = x[actToggleTrack-47]
-	_ = x[actToggleTrackCurrent-48]
-	_ = x[actToggleHeader-49]
-	_ = x[actTrackCurrent-50]
-	_ = x[actUntrackCurrent-51]
-	_ = x[actDown-52]
-	_ = x[actUp-53]
-	_ = x[actPageUp-54]
-	_ = x[actPageDown-55]
-	_ = x[actPosition-56]
-	_ = x[actHalfPageUp-57]
-	_ = x[actHalfPageDown-58]
-	_ = x[actOffsetUp-59]
-	_ = x[actOffsetDown-60]
-	_ = x[actJump-61]
-	_ = x[actJumpAccept-62]
-	_ = x[actPrintQuery-63]
-	_ = x[actRefreshPreview-64]
-	_ = x[actReplaceQuery-65]
-	_ = x[actToggleSort-66]
-	_ = x[actShowPreview-67]
-	_ = x[actHidePreview-68]
-	_ = x[actTogglePreview-69]
-	_ = x[actTogglePreviewWrap-70]
-	_ = x[actTransform-71]
-	_ = x[actTransformBorderLabel-72]
-	_ = x[actTransformHeader-73]
-	_ = x[actTransformPreviewLabel-74]
-	_ = x[actTransformPrompt-75]
-	_ = x[actTransformQuery-76]
-	_ = x[actPreview-77]
-	_ = x[actChangePreview-78]
-	_ = x[actChangePreviewWindow-79]
-	_ = x[actPreviewTop-80]
-	_ = x[actPreviewBottom-81]
-	_ = x[actPreviewUp-82]
-	_ = x[actPreviewDown-83]
-	_ = x[actPreviewPageUp-84]
-	_ = x[actPreviewPageDown-85]
-	_ = x[actPreviewHalfPageUp-86]
-	_ = x[actPreviewHalfPageDown-87]
-	_ = x[actPrevHistory-88]
-	_ = x[actPrevSelected-89]
-	_ = x[actPrint-90]
-	_ = x[actPut-91]
-	_ = x[actNextHistory-92]
-	_ = x[actNextSelected-93]
-	_ = x[actExecute-94]
-	_ = x[actExecuteSilent-95]
-	_ = x[actExecuteMulti-96]
-	_ = x[actSigStop-97]
-	_ = x[actFirst-98]
-	_ = x[actLast-99]
-	_ = x[actReload-100]
-	_ = x[actReloadSync-101]
-	_ = x[actDisableSearch-102]
-	_ = x[actEnableSearch-103]
-	_ = x[actSelect-104]
-	_ = x[actDeselect-105]
-	_ = x[actUnbind-106]
-	_ = x[actRebind-107]
-	_ = x[actBecome-108]
-	_ = x[actResponse-109]
-	_ = x[actShowHeader-110]
-	_ = x[actHideHeader-111]
+	_ = 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[actToggleHeader-46]
+	_ = x[actTrack-47]
+	_ = x[actDown-48]
+	_ = x[actUp-49]
+	_ = x[actPageUp-50]
+	_ = x[actPageDown-51]
+	_ = x[actPosition-52]
+	_ = x[actHalfPageUp-53]
+	_ = x[actHalfPageDown-54]
+	_ = x[actOffsetUp-55]
+	_ = x[actOffsetDown-56]
+	_ = x[actJump-57]
+	_ = x[actJumpAccept-58]
+	_ = x[actPrintQuery-59]
+	_ = x[actRefreshPreview-60]
+	_ = x[actReplaceQuery-61]
+	_ = x[actToggleSort-62]
+	_ = x[actShowPreview-63]
+	_ = x[actHidePreview-64]
+	_ = x[actTogglePreview-65]
+	_ = x[actTogglePreviewWrap-66]
+	_ = x[actTransform-67]
+	_ = x[actTransformBorderLabel-68]
+	_ = x[actTransformHeader-69]
+	_ = x[actTransformPreviewLabel-70]
+	_ = x[actTransformPrompt-71]
+	_ = x[actTransformQuery-72]
+	_ = x[actPreview-73]
+	_ = x[actChangePreview-74]
+	_ = x[actChangePreviewWindow-75]
+	_ = x[actPreviewTop-76]
+	_ = x[actPreviewBottom-77]
+	_ = x[actPreviewUp-78]
+	_ = x[actPreviewDown-79]
+	_ = x[actPreviewPageUp-80]
+	_ = x[actPreviewPageDown-81]
+	_ = x[actPreviewHalfPageUp-82]
+	_ = x[actPreviewHalfPageDown-83]
+	_ = x[actPrevHistory-84]
+	_ = x[actPrevSelected-85]
+	_ = x[actPut-86]
+	_ = x[actNextHistory-87]
+	_ = x[actNextSelected-88]
+	_ = x[actExecute-89]
+	_ = x[actExecuteSilent-90]
+	_ = x[actExecuteMulti-91]
+	_ = x[actSigStop-92]
+	_ = x[actFirst-93]
+	_ = x[actLast-94]
+	_ = x[actReload-95]
+	_ = x[actReloadSync-96]
+	_ = x[actDisableSearch-97]
+	_ = x[actEnableSearch-98]
+	_ = x[actSelect-99]
+	_ = x[actDeselect-100]
+	_ = x[actUnbind-101]
+	_ = x[actRebind-102]
+	_ = x[actBecome-103]
+	_ = x[actResponse-104]
+	_ = x[actShowHeader-105]
+	_ = x[actHideHeader-106]
 }

-const _actionType_name = "actIgnoreactStartactClickactInvalidactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactCancelactChangeBorderLabelactChangeHeaderactChangeMultiactChangePreviewLabelactChangePromptactChangeQueryactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactFatalactForwardCharactForwardWordactKillLineactKillWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleTrackCurrentactToggleHeaderactTrackCurrentactUntrackCurrentactDownactUpactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTransformactTransformBorderLabelactTransformHeaderactTransformPreviewLabelactTransformPromptactTransformQueryactPreviewactChangePreviewactChangePreviewWindowactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPrintactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactBecomeactResponseactShowHeaderactHideHeader"
+const _actionType_name = "actIgnoreactStartactClickactInvalidactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactCancelactChangeBorderLabelactChangeHeaderactChangePreviewLabelactChangePromptactChangeQueryactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactForwardCharactForwardWordactKillLineactKillWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleHeaderactTrackactDownactUpactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTransformactTransformBorderLabelactTransformHeaderactTransformPreviewLabelactTransformPromptactTransformQueryactPreviewactChangePreviewactChangePreviewWindowactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactBecomeactResponseactShowHeaderactHideHeader"

-var _actionType_index = [...]uint16{0, 9, 17, 25, 35, 42, 50, 68, 76, 85, 102, 123, 138, 159, 183, 198, 207, 227, 242, 256, 277, 292, 306, 320, 333, 350, 358, 371, 387, 399, 407, 421, 435, 446, 457, 475, 492, 499, 518, 530, 544, 553, 568, 580, 593, 604, 615, 627, 641, 662, 677, 692, 709, 716, 721, 730, 741, 752, 765, 780, 791, 804, 811, 824, 837, 854, 869, 882, 896, 910, 926, 946, 958, 981, 999, 1023, 1041, 1058, 1068, 1084, 1106, 1119, 1135, 1147, 1161, 1177, 1195, 1215, 1237, 1251, 1266, 1274, 1280, 1294, 1309, 1319, 1335, 1350, 1360, 1368, 1375, 1384, 1397, 1413, 1428, 1437, 1448, 1457, 1466, 1475, 1486, 1499, 1512}
+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, 634, 642, 649, 654, 663, 674, 685, 698, 713, 724, 737, 744, 757, 770, 787, 802, 815, 829, 843, 859, 879, 891, 914, 932, 956, 974, 991, 1001, 1017, 1039, 1052, 1068, 1080, 1094, 1110, 1128, 1148, 1170, 1184, 1199, 1205, 1219, 1234, 1244, 1260, 1275, 1285, 1293, 1300, 1309, 1322, 1338, 1353, 1362, 1373, 1382, 1391, 1400, 1411, 1424, 1437}

 func (i actionType) String() string {
 	if i < 0 || i >= actionType(len(_actionType_index)-1) {
--- a/src/algo/algo.go
+++ b/src/algo/algo.go
@ -152,13 +152,7 @@ var (
 	// Extra bonus for word boundary after slash, colon, semi-colon, and comma
 	bonusBoundaryDelimiter int16 = bonusBoundary + 1

-	initialCharClass = 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
+	initialCharClass charClass = charWhite
 )

 type charClass int
@ -193,27 +187,6 @@ func Init(scheme string) bool {
 	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
 }

@ -241,6 +214,21 @@ 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
+	} else if strings.ContainsRune(whiteChars, char) {
+		return charWhite
+	} else if strings.ContainsRune(delimiterChars, char) {
+		return charDelimiter
+	}
+	return charNonWord
+}
+
 func charClassOfNonAscii(char rune) charClass {
 	if unicode.IsLower(char) {
 		return charLower
@ -260,36 +248,31 @@ func charClassOfNonAscii(char rune) charClass {

 func charClassOf(char rune) charClass {
 	if char <= unicode.MaxASCII {
-		return asciiCharClasses[char]
+		return charClassOfAscii(char)
 	}
 	return charClassOfNonAscii(char)
 }

 func bonusFor(prevClass charClass, class charClass) int16 {
 	if class > charNonWord {
-		switch prevClass {
-		case charWhite:
+		if prevClass == charWhite {
 			// Word boundary after whitespace
 			return bonusBoundaryWhite
-		case charDelimiter:
+		} else if prevClass == charDelimiter {
 			// Word boundary after a delimiter character
 			return bonusBoundaryDelimiter
-		case charNonWord:
+		} else if prevClass == charNonWord {
 			// Word boundary
 			return bonusBoundary
 		}
 	}
-
 	if prevClass == charLower && class == charUpper ||
 		prevClass != charNumber && class == charNumber {
 		// camelCase letter123
 		return bonusCamel123
-	}
-
-	switch class {
-	case charNonWord, charDelimiter:
+	} else if class == charNonWord {
 		return bonusNonWord
-	case charWhite:
+	} else if class == charWhite {
 		return bonusBoundaryWhite
 	}
 	return 0
@ -299,7 +282,7 @@ func bonusAt(input *util.Chars, idx int) int16 {
 	if idx == 0 {
 		return bonusBoundaryWhite
 	}
-	return bonusMatrix[charClassOf(input.Get(idx-1))][charClassOf(input.Get(idx))]
+	return bonusFor(charClassOf(input.Get(idx-1)), charClassOf(input.Get(idx)))
 }

 func normalizeRune(r rune) rune {
@ -352,45 +335,30 @@ func isAscii(runes []rune) bool {
 	return true
 }

-func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) (int, int) {
+func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) int {
 	// Can't determine
 	if !input.IsBytes() {
-		return 0, input.Length()
+		return 0
 	}

 	// Not possible
 	if !isAscii(pattern) {
-		return -1, -1
+		return -1
 	}

-	firstIdx, idx, lastIdx := 0, 0, 0
-	var b byte
+	firstIdx, idx := 0, 0
 	for pidx := 0; pidx < len(pattern); pidx++ {
-		b = byte(pattern[pidx])
-		idx = trySkip(input, caseSensitive, b, idx)
+		idx = trySkip(input, caseSensitive, byte(pattern[pidx]), idx)
 		if idx < 0 {
-			return -1, -1
+			return -1
 		}
 		if pidx == 0 && idx > 0 {
 			// Step back to find the right bonus point
 			firstIdx = idx - 1
 		}
-		lastIdx = idx
 		idx++
 	}
-
-	// 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
+	return firstIdx
 }

 func debugV2(T []rune, pattern []rune, F []int32, lastIdx int, H []int16, C []int16) {
@ -439,9 +407,6 @@ 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.
@ -450,12 +415,10 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	}

 	// Phase 1. Optimized search for ASCII string
-	minIdx, maxIdx := asciiFuzzyIndex(input, pattern, caseSensitive)
-	if minIdx < 0 {
+	idx := asciiFuzzyIndex(input, pattern, caseSensitive)
+	if idx < 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
@ -468,19 +431,20 @@ 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, minIdx)
+	input.CopyRunes(T)

 	// 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), initialCharClass, false
-	for off, char := range T {
+	Tsub := T[idx:]
+	H0sub, C0sub, Bsub := H0[idx:][:len(Tsub)], C0[idx:][:len(Tsub)], B[idx:][:len(Tsub)]
+	for off, char := range Tsub {
 		var class charClass
 		if char <= unicode.MaxASCII {
-			class = asciiCharClasses[char]
+			class = charClassOfAscii(char)
 			if !caseSensitive && class == charUpper {
 				char += 32
-				T[off] = char
 			}
 		} else {
 			class = charClassOfNonAscii(char)
@ -490,28 +454,28 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			if normalize {
 				char = normalizeRune(char)
 			}
-			T[off] = char
 		}

-		bonus := bonusMatrix[prevClass][class]
-		B[off] = bonus
+		Tsub[off] = char
+		bonus := bonusFor(prevClass, class)
+		Bsub[off] = bonus
 		prevClass = class

 		if char == pchar {
 			if pidx < M {
-				F[pidx] = int32(off)
+				F[pidx] = int32(idx + off)
 				pidx++
 				pchar = pattern[util.Min(pidx, M-1)]
 			}
-			lastIdx = off
+			lastIdx = idx + off
 		}

 		if char == pchar0 {
 			score := scoreMatch + bonus*bonusFirstCharMultiplier
-			H0[off] = score
-			C0[off] = 1
+			H0sub[off] = score
+			C0sub[off] = 1
 			if M == 1 && (forward && score > maxScore || !forward && score >= maxScore) {
-				maxScore, maxScorePos = score, off
+				maxScore, maxScorePos = score, idx+off
 				if forward && bonus >= bonusBoundary {
 					break
 				}
@ -519,24 +483,24 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			inGap = false
 		} else {
 			if inGap {
-				H0[off] = util.Max16(prevH0+scoreGapExtension, 0)
+				H0sub[off] = util.Max16(prevH0+scoreGapExtension, 0)
 			} else {
-				H0[off] = util.Max16(prevH0+scoreGapStart, 0)
+				H0sub[off] = util.Max16(prevH0+scoreGapStart, 0)
 			}
-			C0[off] = 0
+			C0sub[off] = 0
 			inGap = true
 		}
-		prevH0 = H0[off]
+		prevH0 = H0sub[off]
 	}
 	if pidx != M {
 		return Result{-1, -1, 0}, nil
 	}
 	if M == 1 {
-		result := Result{minIdx + maxScorePos, minIdx + maxScorePos + 1, int(maxScore)}
+		result := Result{maxScorePos, maxScorePos + 1, int(maxScore)}
 		if !withPos {
 			return result, nil
 		}
-		pos := []int{minIdx + maxScorePos}
+		pos := []int{maxScorePos}
 		return result, &pos
 	}

@ -633,7 +597,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			}

 			if s > s1 && (s > s2 || s == s2 && preferMatch) {
-				*pos = append(*pos, j+minIdx)
+				*pos = append(*pos, j)
 				if i == 0 {
 					break
 				}
@ -646,7 +610,7 @@ 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{minIdx + j, minIdx + maxScorePos + 1, int(maxScore)}, pos
+	return Result{j, maxScorePos + 1, int(maxScore)}, pos
 }

 // Implement the same sorting criteria as V2
@ -676,7 +640,7 @@ func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, patter
 				*pos = append(*pos, idx)
 			}
 			score += scoreMatch
-			bonus := bonusMatrix[prevClass][class]
+			bonus := bonusFor(prevClass, class)
 			if consecutive == 0 {
 				firstBonus = bonus
 			} else {
@ -714,8 +678,7 @@ func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text *util.C
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
-	idx, _ := asciiFuzzyIndex(text, pattern, caseSensitive)
-	if idx < 0 {
+	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
 		return Result{-1, -1, 0}, nil
 	}

@ -809,8 +772,7 @@ func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text *uti
 		return Result{-1, -1, 0}, nil
 	}

-	idx, _ := asciiFuzzyIndex(text, pattern, caseSensitive)
-	if idx < 0 {
+	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
 		return Result{-1, -1, 0}, nil
 	}

--- a/src/algo/algo_test.go
+++ b/src/algo/algo_test.go
@ -9,10 +9,6 @@ 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)
 }
--- a/src/algo/normalize.go
+++ b/src/algo/normalize.go
@ -3,7 +3,7 @@

 package algo

-var normalized = map[rune]rune{
+var normalized map[rune]rune = map[rune]rune{
 	0x00E1: 'a', //  WITH ACUTE, LATIN SMALL LETTER
 	0x0103: 'a', //  WITH BREVE, LATIN SMALL LETTER
 	0x01CE: 'a', //  WITH CARON, LATIN SMALL LETTER
--- a/src/ansi.go
+++ b/src/ansi.go
@ -292,7 +292,7 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo

 func parseAnsiCode(s string, delimiter byte) (int, byte, string) {
 	var remaining string
-	var i int
+	i := -1
 	if delimiter == 0 {
 		// Faster than strings.IndexAny(";:")
 		i = strings.IndexByte(s, ';')
@ -312,7 +312,7 @@ func parseAnsiCode(s string, delimiter byte) (int, byte, string) {
 		// Inlined version of strconv.Atoi() that only handles positive
 		// integers and does not allocate on error.
 		code := 0
-		for _, ch := range stringBytes(s) {
+		for _, ch := range []byte(s) {
 			ch -= '0'
 			if ch > 9 {
 				return -1, delimiter, remaining
@ -350,7 +350,7 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 	state256 := 0
 	ptr := &state.fg

-	var delimiter byte
+	var delimiter byte = 0
 	count := 0
 	for len(ansiCode) != 0 {
 		var num int
--- a/src/ansi_test.go
+++ b/src/ansi_test.go
@ -342,8 +342,8 @@ func TestAnsiCodeStringConversion(t *testing.T) {
 		state := interpretCode(code, prevState)
 		if expected != state.ToString() {
 			t.Errorf("expected: %s, actual: %s",
-				strings.ReplaceAll(expected, "\x1b[", "\\x1b["),
-				strings.ReplaceAll(state.ToString(), "\x1b[", "\\x1b["))
+				strings.Replace(expected, "\x1b[", "\\x1b[", -1),
+				strings.Replace(state.ToString(), "\x1b[", "\\x1b[", -1))
 		}
 	}
 	assert("\x1b[m", nil, "")
--- a/src/cache.go
+++ b/src/cache.go
@ -12,22 +12,8 @@ type ChunkCache struct {
 }

 // NewChunkCache returns a new ChunkCache
-func NewChunkCache() *ChunkCache {
-	return &ChunkCache{sync.Mutex{}, make(map[*Chunk]*queryCache)}
-}
-
-func (cc *ChunkCache) Clear() {
-	cc.mutex.Lock()
-	cc.cache = make(map[*Chunk]*queryCache)
-	cc.mutex.Unlock()
-}
-
-func (cc *ChunkCache) retire(chunk ...*Chunk) {
-	cc.mutex.Lock()
-	for _, c := range chunk {
-		delete(cc.cache, c)
-	}
-	cc.mutex.Unlock()
+func NewChunkCache() ChunkCache {
+	return ChunkCache{sync.Mutex{}, make(map[*Chunk]*queryCache)}
 }

 // Add adds the list to the cache
--- a/src/chunklist.go
+++ b/src/chunklist.go
@ -16,16 +16,14 @@ type ChunkList struct {
 	chunks []*Chunk
 	mutex  sync.Mutex
 	trans  ItemBuilder
-	cache  *ChunkCache
 }

 // NewChunkList returns a new ChunkList
-func NewChunkList(cache *ChunkCache, trans ItemBuilder) *ChunkList {
+func NewChunkList(trans ItemBuilder) *ChunkList {
 	return &ChunkList{
 		chunks: []*Chunk{},
 		mutex:  sync.Mutex{},
-		trans:  trans,
-		cache:  cache}
+		trans:  trans}
 }

 func (c *Chunk) push(trans ItemBuilder, data []byte) bool {
@ -50,12 +48,7 @@ func CountItems(cs []*Chunk) int {
 	if len(cs) == 0 {
 		return 0
 	}
-	if len(cs) == 1 {
-		return cs[0].count
-	}
-
-	// First chunk might not be full due to --tail=N
-	return cs[0].count + chunkSize*(len(cs)-2) + cs[len(cs)-1].count
+	return chunkSize*(len(cs)-1) + cs[len(cs)-1].count
 }

 // Push adds the item to the list
@ -79,56 +72,18 @@ func (cl *ChunkList) Clear() {
 }

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

-	changed := false
-	if tail > 0 && CountItems(cl.chunks) > tail {
-		changed = true
-		// Find the number of chunks to keep
-		numChunks := 0
-		for left, i := tail, len(cl.chunks)-1; left > 0 && i >= 0; i-- {
-			numChunks++
-			left -= cl.chunks[i].count
-		}
-
-		// Copy the chunks to keep
-		ret := make([]*Chunk, numChunks)
-		minIndex := len(cl.chunks) - numChunks
-		cl.cache.retire(cl.chunks[:minIndex]...)
-		copy(ret, cl.chunks[minIndex:])
-
-		for left, i := tail, len(ret)-1; i >= 0; i-- {
-			chunk := ret[i]
-			if chunk.count > left {
-				newChunk := *chunk
-				newChunk.count = left
-				oldCount := chunk.count
-				for i := 0; i < left; i++ {
-					newChunk.items[i] = chunk.items[oldCount-left+i]
-				}
-				ret[i] = &newChunk
-				cl.cache.retire(chunk)
-				break
-			}
-			left -= chunk.count
-		}
-		cl.chunks = ret
-	}
-
 	ret := make([]*Chunk, len(cl.chunks))
 	copy(ret, cl.chunks)

-	// Duplicate the first and the last chunk
+	// Duplicate the last chunk
 	if cnt := len(ret); cnt > 0 {
-		if tail > 0 && cnt > 1 {
-			newChunk := *ret[0]
-			ret[0] = &newChunk
-		}
 		newChunk := *ret[cnt-1]
 		ret[cnt-1] = &newChunk
 	}

 	cl.mutex.Unlock()
-	return ret, CountItems(ret), changed
+	return ret, CountItems(ret)
 }
--- a/src/chunklist_test.go
+++ b/src/chunklist_test.go
@ -11,13 +11,13 @@ func TestChunkList(t *testing.T) {
 	// FIXME global
 	sortCriteria = []criterion{byScore, byLength}

-	cl := NewChunkList(NewChunkCache(), func(item *Item, s []byte) bool {
+	cl := NewChunkList(func(item *Item, s []byte) bool {
 		item.text = util.ToChars(s)
 		return true
 	})

 	// Snapshot
-	snapshot, count, _ := cl.Snapshot(0)
+	snapshot, count := cl.Snapshot()
 	if len(snapshot) > 0 || count > 0 {
 		t.Error("Snapshot should be empty now")
 	}
@ -32,7 +32,7 @@ func TestChunkList(t *testing.T) {
 	}

 	// But the new snapshot should contain the added items
-	snapshot, count, _ = cl.Snapshot(0)
+	snapshot, count = cl.Snapshot()
 	if len(snapshot) != 1 && count != 2 {
 		t.Error("Snapshot should not be empty now")
 	}
@ -61,7 +61,7 @@ func TestChunkList(t *testing.T) {
 	}

 	// New snapshot
-	snapshot, count, _ = cl.Snapshot(0)
+	snapshot, count = cl.Snapshot()
 	if len(snapshot) != 3 || !snapshot[0].IsFull() ||
 		!snapshot[1].IsFull() || snapshot[2].IsFull() || count != chunkSize*2+2 {
 		t.Error("Expected two full chunks and one more chunk")
@ -78,39 +78,3 @@ func TestChunkList(t *testing.T) {
 		t.Error("Unexpected number of items:", lastChunkCount)
 	}
 }
-
-func TestChunkListTail(t *testing.T) {
-	cl := NewChunkList(NewChunkCache(), func(item *Item, s []byte) bool {
-		item.text = util.ToChars(s)
-		return true
-	})
-	total := chunkSize*2 + chunkSize/2
-	for i := 0; i < total; i++ {
-		cl.Push([]byte(fmt.Sprintf("item %d", i)))
-	}
-
-	snapshot, count, changed := cl.Snapshot(0)
-	assertCount := func(expected int, shouldChange bool) {
-		if count != expected || CountItems(snapshot) != expected {
-			t.Errorf("Unexpected count: %d (expected: %d)", count, expected)
-		}
-		if changed != shouldChange {
-			t.Error("Unexpected change status")
-		}
-	}
-	assertCount(total, false)
-
-	tail := chunkSize + chunkSize/2
-	snapshot, count, changed = cl.Snapshot(tail)
-	assertCount(tail, true)
-
-	snapshot, count, changed = cl.Snapshot(tail)
-	assertCount(tail, false)
-
-	snapshot, count, changed = cl.Snapshot(0)
-	assertCount(tail, false)
-
-	tail = chunkSize / 2
-	snapshot, count, changed = cl.Snapshot(tail)
-	assertCount(tail, true)
-}
--- a/src/constants.go
+++ b/src/constants.go
@ -2,6 +2,7 @@ package fzf

 import (
 	"math"
+	"os"
 	"time"

 	"github.com/junegunn/fzf/src/util"
@ -14,7 +15,6 @@ const (

 	// Reader
 	readerBufferSize       = 64 * 1024
-	readerSlabSize         = 128 * 1024
 	readerPollIntervalMin  = 10 * time.Millisecond
 	readerPollIntervalStep = 5 * time.Millisecond
 	readerPollIntervalMax  = 50 * time.Millisecond
@ -54,6 +54,16 @@ const (
 	defaultJumpLabels string = "asdfghjklqwertyuiopzxcvbnm1234567890ASDFGHJKLQWERTYUIOPZXCVBNM`~;:,<.>/?'\"!@#$%^&*()[{]}-_=+"
 )

+var defaultCommand string
+
+func init() {
+	if !util.IsWindows() {
+		defaultCommand = `set -o pipefail; command find -L . -mindepth 1 \( -path '*/.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \) -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-`
+	} else if os.Getenv("TERM") == "cygwin" {
+		defaultCommand = `sh -c "command find -L . -mindepth 1 -path '*/.*' -prune -o -type f -print -o -type l -print 2> /dev/null | cut -b3-"`
+	}
+}
+
 // fzf events
 const (
 	EvtReadNew util.EventType = iota
@ -67,9 +77,9 @@ const (
 )

 const (
-	ExitOk        = 0
-	ExitNoMatch   = 1
-	ExitError     = 2
-	ExitBecome    = 126
-	ExitInterrupt = 130
+	exitCancel    = -1
+	exitOk        = 0
+	exitNoMatch   = 1
+	exitError     = 2
+	exitInterrupt = 130
 )
--- a/src/core.go
+++ b/src/core.go
@ -2,8 +2,8 @@
 package fzf

 import (
+	"fmt"
 	"os"
-	"sync"
 	"time"

 	"github.com/junegunn/fzf/src/util"
@ -18,52 +18,20 @@ Matcher  -> EvtSearchFin      -> Terminal (update list)
 Matcher  -> EvtHeader         -> Terminal (update header)
 */

-type revision struct {
-	major int
-	minor int
-}
-
-func (r *revision) bumpMajor() {
-	r.major++
-	r.minor = 0
-}
-
-func (r *revision) bumpMinor() {
-	r.minor++
-}
-
-func (r revision) compatible(other revision) bool {
-	return r.major == other.major
-}
-
 // Run starts fzf
-func Run(opts *Options) (int, error) {
-	if opts.Filter == nil {
-		if opts.Tmux != nil && len(os.Getenv("TMUX")) > 0 && opts.Tmux.index >= opts.Height.index {
-			return runTmux(os.Args, opts)
-		}
-
-		if needWinpty(opts) {
-			return runWinpty(os.Args, opts)
-		}
-	}
-
-	if err := postProcessOptions(opts); err != nil {
-		return ExitError, err
-	}
-
-	defer util.RunAtExitFuncs()
+func Run(opts *Options, version string, revision string) {
+	sort := opts.Sort > 0
+	sortCriteria = opts.Criteria

-	// Output channel given
-	if opts.Output != nil {
-		opts.Printer = func(str string) {
-			opts.Output <- str
+	if opts.Version {
+		if len(revision) > 0 {
+			fmt.Printf("%s (%s)\n", version, revision)
+		} else {
+			fmt.Println(version)
 		}
+		os.Exit(exitOk)
 	}

-	sort := opts.Sort > 0
-	sortCriteria = opts.Criteria
-
 	// Event channel
 	eventBox := util.NewEventBox()

@ -77,29 +45,28 @@ func Run(opts *Options) (int, error) {
 		if opts.Theme.Colored {
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				prevLineAnsiState = lineAnsiState
-				trimmed, offsets, newState := extractColor(byteString(data), lineAnsiState, nil)
+				trimmed, offsets, newState := extractColor(string(data), lineAnsiState, nil)
 				lineAnsiState = newState
-				return util.ToChars(stringBytes(trimmed)), offsets
+				return util.ToChars([]byte(trimmed)), offsets
 			}
 		} else {
 			// When color is disabled but ansi option is given,
 			// we simply strip out ANSI codes from the input
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
-				trimmed, _, _ := extractColor(byteString(data), nil, nil)
-				return util.ToChars(stringBytes(trimmed)), nil
+				trimmed, _, _ := extractColor(string(data), nil, nil)
+				return util.ToChars([]byte(trimmed)), nil
 			}
 		}
 	}

 	// Chunk list
-	cache := NewChunkCache()
 	var chunkList *ChunkList
 	var itemIndex int32
 	header := make([]string, 0, opts.HeaderLines)
 	if len(opts.WithNth) == 0 {
-		chunkList = NewChunkList(cache, func(item *Item, data []byte) bool {
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
 			if len(header) < opts.HeaderLines {
-				header = append(header, byteString(data))
+				header = append(header, string(data))
 				eventBox.Set(EvtHeader, header)
 				return false
 			}
@ -109,8 +76,8 @@ func Run(opts *Options) (int, error) {
 			return true
 		})
 	} else {
-		chunkList = NewChunkList(cache, func(item *Item, data []byte) bool {
-			tokens := Tokenize(byteString(data), opts.Delimiter)
+		chunkList = NewChunkList(func(item *Item, data []byte) bool {
+			tokens := Tokenize(string(data), opts.Delimiter)
 			if opts.Ansi && opts.Theme.Colored && len(tokens) > 1 {
 				var ansiState *ansiState
 				if prevLineAnsiState != nil {
@ -134,7 +101,7 @@ func Run(opts *Options) (int, error) {
 				eventBox.Set(EvtHeader, header)
 				return false
 			}
-			item.text, item.colors = ansiProcessor(stringBytes(transformed))
+			item.text, item.colors = ansiProcessor([]byte(transformed))
 			item.text.TrimTrailingWhitespaces()
 			item.text.Index = itemIndex
 			item.origText = &data
@ -143,17 +110,14 @@ func Run(opts *Options) (int, error) {
 		})
 	}

-	// Process executor
-	executor := util.NewExecutor(opts.WithShell)
-
 	// Reader
 	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
 	var reader *Reader
 	if !streamingFilter {
 		reader = NewReader(func(data []byte) bool {
 			return chunkList.Push(data)
-		}, eventBox, executor, opts.ReadZero, opts.Filter == nil)
-		go reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
+		}, eventBox, opts.ReadZero, opts.Filter == nil)
+		go reader.ReadSource()
 	}

 	// Matcher
@ -169,15 +133,14 @@ func Run(opts *Options) (int, error) {
 			forward = true
 		}
 	}
-	patternCache := make(map[string]*Pattern)
 	patternBuilder := func(runes []rune) *Pattern {
-		return BuildPattern(cache, patternCache,
+		return BuildPattern(
 			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward, withPos,
 			opts.Filter == nil, opts.Nth, opts.Delimiter, runes)
 	}
-	inputRevision := revision{}
-	snapshotRevision := revision{}
-	matcher := NewMatcher(cache, patternBuilder, sort, opts.Tac, eventBox, inputRevision)
+	inputRevision := 0
+	snapshotRevision := 0
+	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox, inputRevision)

 	// Filtering mode
 	if opts.Filter != nil {
@ -191,27 +154,23 @@ func Run(opts *Options) (int, error) {
 		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, executor, opts.ReadZero, false)
-			reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
+				}, eventBox, opts.ReadZero, false)
+			reader.ReadSource()
 		} else {
 			eventBox.Unwatch(EvtReadNew)
 			eventBox.WaitFor(EvtReadFin)

-			// NOTE: Streaming filter is inherently not compatible with --tail
-			snapshot, _, _ := chunkList.Snapshot(opts.Tail)
+			snapshot, _ := chunkList.Snapshot()
 			merger, _ := matcher.scan(MatchRequest{
 				chunks:  snapshot,
 				pattern: pattern})
@ -221,9 +180,9 @@ func Run(opts *Options) (int, error) {
 			}
 		}
 		if found {
-			return ExitOk, nil
+			os.Exit(exitOk)
 		}
-		return ExitNoMatch, nil
+		os.Exit(exitNoMatch)
 	}

 	// Synchronous search
@ -234,13 +193,9 @@ func Run(opts *Options) (int, error) {

 	// Go interactive
 	go matcher.Loop()
-	defer matcher.Stop()

 	// Terminal I/O
-	terminal, err := NewTerminal(opts, eventBox, executor)
-	if err != nil {
-		return ExitError, err
-	}
+	terminal := NewTerminal(opts, eventBox)
 	maxFit := 0 // Maximum number of items that can fit on screen
 	padHeight := 0
 	heightUnknown := opts.Height.auto
@ -257,8 +212,7 @@ func Run(opts *Options) (int, error) {
 	// Event coordination
 	reading := true
 	ticks := 0
-	var nextCommand *commandSpec
-	var nextEnviron []string
+	var nextCommand *string
 	eventBox.Watch(EvtReadNew)
 	total := 0
 	query := []rune{}
@ -278,23 +232,23 @@ func Run(opts *Options) (int, error) {
 	useSnapshot := false
 	var snapshot []*Chunk
 	var count int
-	restart := func(command commandSpec, environ []string) {
+	restart := func(command string) {
 		reading = true
 		chunkList.Clear()
 		itemIndex = 0
-		inputRevision.bumpMajor()
+		inputRevision++
 		header = make([]string, 0, opts.HeaderLines)
-		go reader.restart(command, environ)
+		go reader.restart(command)
 	}
-
-	exitCode := ExitOk
-	stop := false
 	for {
 		delay := true
 		ticks++
 		input := func() []rune {
+			reloaded := snapshotRevision != inputRevision
 			paused, input := terminal.Input()
-			if !paused {
+			if reloaded && paused {
+				query = []rune{}
+			} else if !paused {
 				query = input
 			}
 			return query
@ -309,16 +263,11 @@ func Run(opts *Options) (int, error) {
 					if reading {
 						reader.terminate()
 					}
-					quitSignal := value.(quitSignal)
-					exitCode = quitSignal.code
-					err = quitSignal.err
-					stop = true
-					return
+					os.Exit(value.(int))
 				case EvtReadNew, EvtReadFin:
 					if evt == EvtReadFin && nextCommand != nil {
-						restart(*nextCommand, nextEnviron)
+						restart(*nextCommand)
 						nextCommand = nil
-						nextEnviron = nil
 						break
 					} else {
 						reading = reading && evt == EvtReadNew
@ -327,20 +276,14 @@ func Run(opts *Options) (int, error) {
 						useSnapshot = false
 					}
 					if !useSnapshot {
-						if !snapshotRevision.compatible(inputRevision) {
-							query = []rune{}
-						}
-						var changed bool
-						snapshot, count, changed = chunkList.Snapshot(opts.Tail)
-						if changed {
-							inputRevision.bumpMinor()
-						}
+						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)
+						opts.Sync = false
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac, snapshotRevision))
 					}
 					if heightUnknown && !deferred {
 						determine(!reading)
@ -348,14 +291,12 @@ func Run(opts *Options) (int, error) {
 					matcher.Reset(snapshot, input(), false, !reading, sort, snapshotRevision)

 				case EvtSearchNew:
-					var command *commandSpec
-					var environ []string
+					var command *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
@ -365,25 +306,18 @@ func Run(opts *Options) (int, error) {
 						if reading {
 							reader.terminate()
 							nextCommand = command
-							nextEnviron = environ
 						} else {
-							restart(*command, environ)
+							restart(*command)
 						}
 					}
 					if !changed {
 						break
 					}
 					if !useSnapshot {
-						newSnapshot, newCount, changed := chunkList.Snapshot(opts.Tail)
-						if changed {
-							inputRevision.bumpMinor()
-						}
+						newSnapshot, _ := 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{}
-							}
+						if command == nil || len(newSnapshot) > 0 {
 							snapshot = newSnapshot
 							snapshotRevision = inputRevision
 						}
@ -420,24 +354,20 @@ func Run(opts *Options) (int, error) {
 									for i := 0; i < count; i++ {
 										opts.Printer(val.Get(i).item.AsString(opts.Ansi))
 									}
-									if count == 0 {
-										exitCode = ExitNoMatch
+									if count > 0 {
+										os.Exit(exitOk)
 									}
-									stop = true
-									return
+									os.Exit(exitNoMatch)
 								}
 								determine(val.final)
 							}
 						}
-						terminal.UpdateList(val, true)
+						terminal.UpdateList(val)
 					}
 				}
 			}
 			events.Clear()
 		})
-		if stop {
-			break
-		}
 		if delay && reading {
 			dur := util.DurWithin(
 				time.Duration(ticks)*coordinatorDelayStep,
@ -445,5 +375,4 @@ func Run(opts *Options) (int, error) {
 			time.Sleep(dur)
 		}
 	}
-	return exitCode, err
 }
--- a/src/functions.go
+++ b/src/functions.go
@ -1,35 +0,0 @@
-package fzf
-
-import (
-	"os"
-	"strings"
-	"unsafe"
-)
-
-func WriteTemporaryFile(data []string, printSep string) string {
-	f, err := os.CreateTemp("", "fzf-temp-*")
-	if err != nil {
-		// Unable to create temporary file
-		// FIXME: Should we terminate the program?
-		return ""
-	}
-	defer f.Close()
-
-	f.WriteString(strings.Join(data, printSep))
-	f.WriteString(printSep)
-	return f.Name()
-}
-
-func removeFiles(files []string) {
-	for _, filename := range files {
-		os.Remove(filename)
-	}
-}
-
-func stringBytes(data string) []byte {
-	return unsafe.Slice(unsafe.StringData(data), len(data))
-}
-
-func byteString(data []byte) string {
-	return unsafe.String(unsafe.SliceData(data), len(data))
-}
--- a/src/item.go
+++ b/src/item.go
@ -1,8 +1,6 @@
 package fzf

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

@ -19,7 +17,7 @@ func (item *Item) Index() int32 {
 	return item.text.Index
 }

-var minItem = Item{text: util.Chars{Index: math.MinInt32}}
+var minItem = Item{text: util.Chars{Index: -1}}

 func (item *Item) TrimLength() uint16 {
 	return item.text.TrimLength()
--- a/src/matcher.go
+++ b/src/matcher.go
@ -16,12 +16,11 @@ type MatchRequest struct {
 	pattern  *Pattern
 	final    bool
 	sort     bool
-	revision revision
+	revision int
 }

 // Matcher is responsible for performing search
 type Matcher struct {
-	cache          *ChunkCache
 	patternBuilder func([]rune) *Pattern
 	sort           bool
 	tac            bool
@ -30,7 +29,7 @@ type Matcher struct {
 	partitions     int
 	slab           []*util.Slab
 	mergerCache    map[string]*Merger
-	revision       revision
+	revision       int
 }

 const (
@ -39,11 +38,10 @@ const (
 )

 // NewMatcher returns a new Matcher
-func NewMatcher(cache *ChunkCache, patternBuilder func([]rune) *Pattern,
-	sort bool, tac bool, eventBox *util.EventBox, revision revision) *Matcher {
+func NewMatcher(patternBuilder func([]rune) *Pattern,
+	sort bool, tac bool, eventBox *util.EventBox, revision int) *Matcher {
 	partitions := util.Min(numPartitionsMultiplier*runtime.NumCPU(), maxPartitions)
 	return &Matcher{
-		cache:          cache,
 		patternBuilder: patternBuilder,
 		sort:           sort,
 		tac:            tac,
@ -62,13 +60,8 @@ func (m *Matcher) Loop() {
 	for {
 		var request MatchRequest

-		stop := false
 		m.reqBox.Wait(func(events *util.Events) {
-			for t, val := range *events {
-				if t == reqQuit {
-					stop = true
-					return
-				}
+			for _, val := range *events {
 				switch val := val.(type) {
 				case MatchRequest:
 					request = val
@ -78,19 +71,12 @@ func (m *Matcher) Loop() {
 			}
 			events.Clear()
 		})
-		if stop {
-			break
-		}

-		cacheCleared := false
 		if request.sort != m.sort || request.revision != m.revision {
 			m.sort = request.sort
 			m.revision = request.revision
 			m.mergerCache = make(map[string]*Merger)
-			if !request.revision.compatible(m.revision) {
-				m.cache.Clear()
-			}
-			cacheCleared = true
+			clearChunkCache()
 		}

 		// Restart search
@ -99,20 +85,20 @@ func (m *Matcher) Loop() {
 		cancelled := false
 		count := CountItems(request.chunks)

-		if !cacheCleared {
-			if count == prevCount {
-				// Look up mergerCache
-				if cached, found := m.mergerCache[patternString]; found {
-					merger = cached
-				}
-			} else {
-				// Invalidate mergerCache
-				prevCount = count
-				m.mergerCache = make(map[string]*Merger)
+		foundCache := false
+		if count == prevCount {
+			// Look up mergerCache
+			if cached, found := m.mergerCache[patternString]; found {
+				foundCache = true
+				merger = cached
 			}
+		} else {
+			// Invalidate mergerCache
+			prevCount = count
+			m.mergerCache = make(map[string]*Merger)
 		}

-		if merger == nil {
+		if !foundCache {
 			merger, cancelled = m.scan(request)
 		}

@ -164,7 +150,6 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		return PassMerger(&request.chunks, m.tac, request.revision), false
 	}

-	minIndex := request.chunks[0].items[0].Index()
 	cancelled := util.NewAtomicBool(false)

 	slices := m.sliceChunks(request.chunks)
@ -195,7 +180,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 			for _, matches := range allMatches {
 				sliceMatches = append(sliceMatches, matches...)
 			}
-			if m.sort && request.pattern.sortable {
+			if m.sort {
 				if m.tac {
 					sort.Sort(ByRelevanceTac(sliceMatches))
 				} else {
@ -236,11 +221,11 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}
-	return NewMerger(pattern, partialResults, m.sort && request.pattern.sortable, m.tac, request.revision, minIndex), 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, revision revision) {
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool, revision int) {
 	pattern := m.patternBuilder(patternRunes)

 	var event util.EventType
@ -249,9 +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, revision})
-}
-
-func (m *Matcher) Stop() {
-	m.reqBox.Set(reqQuit, nil)
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, revision})
 }
--- a/src/merger.go
+++ b/src/merger.go
@ -3,8 +3,8 @@ package fzf
 import "fmt"

 // EmptyMerger is a Merger with no data
-func EmptyMerger(revision revision) *Merger {
-	return NewMerger(nil, [][]Result{}, false, false, revision, 0)
+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
@ -20,25 +20,19 @@ type Merger struct {
 	final    bool
 	count    int
 	pass     bool
-	revision revision
-	minIndex int32
+	revision int
 }

 // PassMerger returns a new Merger that simply returns the items in the
 // original order
-func PassMerger(chunks *[]*Chunk, tac bool, revision revision) *Merger {
-	var minIndex int32
-	if len(*chunks) > 0 {
-		minIndex = (*chunks)[0].items[0].Index()
-	}
+func PassMerger(chunks *[]*Chunk, tac bool, revision int) *Merger {
 	mg := Merger{
 		pattern:  nil,
 		chunks:   chunks,
 		tac:      tac,
 		count:    0,
 		pass:     true,
-		revision: revision,
-		minIndex: minIndex}
+		revision: revision}

 	for _, chunk := range *mg.chunks {
 		mg.count += chunk.count
@ -47,7 +41,7 @@ func PassMerger(chunks *[]*Chunk, tac bool, revision revision) *Merger {
 }

 // NewMerger returns a new Merger
-func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revision revision, minIndex int32) *Merger {
+func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revision int) *Merger {
 	mg := Merger{
 		pattern:  pattern,
 		lists:    lists,
@ -58,8 +52,7 @@ func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revisi
 		tac:      tac,
 		final:    false,
 		count:    0,
-		revision: revision,
-		minIndex: minIndex}
+		revision: revision}

 	for _, list := range mg.lists {
 		mg.count += len(list)
@ -68,7 +61,7 @@ func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revisi
 }

 // Revision returns revision number
-func (mg *Merger) Revision() revision {
+func (mg *Merger) Revision() int {
 	return mg.revision
 }

@ -88,7 +81,7 @@ func (mg *Merger) First() Result {
 func (mg *Merger) FindIndex(itemIndex int32) int {
 	index := -1
 	if mg.pass {
-		index = int(itemIndex - mg.minIndex)
+		index = int(itemIndex)
 		if mg.tac {
 			index = mg.count - index - 1
 		}
@ -109,13 +102,6 @@ func (mg *Merger) Get(idx int) Result {
 		if mg.tac {
 			idx = mg.count - idx - 1
 		}
-		firstChunk := (*mg.chunks)[0]
-		if firstChunk.count < chunkSize && idx >= firstChunk.count {
-			idx -= firstChunk.count
-
-			chunk := (*mg.chunks)[idx/chunkSize+1]
-			return Result{item: &chunk.items[idx%chunkSize]}
-		}
 		chunk := (*mg.chunks)[idx/chunkSize]
 		return Result{item: &chunk.items[idx%chunkSize]}
 	}
--- a/src/merger_test.go
+++ b/src/merger_test.go
@ -23,11 +23,10 @@ func randResult() Result {
 }

 func TestEmptyMerger(t *testing.T) {
-	r := revision{}
-	assert(t, EmptyMerger(r).Length() == 0, "Not empty")
-	assert(t, EmptyMerger(r).count == 0, "Invalid count")
-	assert(t, len(EmptyMerger(r).lists) == 0, "Invalid lists")
-	assert(t, len(EmptyMerger(r).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) {
@ -58,7 +57,7 @@ func TestMergerUnsorted(t *testing.T) {
 	cnt := len(items)

 	// Not sorted: same order
-	mg := NewMerger(nil, lists, false, false, revision{}, 0)
+	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")
@ -70,7 +69,7 @@ func TestMergerSorted(t *testing.T) {
 	cnt := len(items)

 	// Sorted sorted order
-	mg := NewMerger(nil, lists, true, false, revision{}, 0)
+	mg := NewMerger(nil, lists, true, false, 0)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	sort.Sort(ByRelevance(items))
 	for i := 0; i < cnt; i++ {
@ -80,7 +79,7 @@ func TestMergerSorted(t *testing.T) {
 	}

 	// Inverse order
-	mg2 := NewMerger(nil, lists, true, false, revision{}, 0)
+	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))
--- a/src/options.go
+++ b/src/options.go
--- a/src/options_no_pprof.go
+++ b/src/options_no_pprof.go
@ -1,13 +0,0 @@
-//go:build !pprof
-// +build !pprof
-
-package fzf
-
-import "errors"
-
-func (o *Options) initProfiling() error {
-	if o.CPUProfile != "" || o.MEMProfile != "" || o.BlockProfile != "" || o.MutexProfile != "" {
-		return errors.New("error: profiling not supported: FZF must be built with '-tags=pprof' to enable profiling")
-	}
-	return nil
-}
--- a/src/options_pprof.go
+++ b/src/options_pprof.go
@ -1,73 +0,0 @@
-//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
-}
--- a/src/options_pprof_test.go
+++ b/src/options_pprof_test.go
@ -1,89 +0,0 @@
-//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)
-		}
-	}
-}
--- a/src/options_test.go
+++ b/src/options_test.go
@ -80,7 +80,7 @@ func TestDelimiterRegexRegexCaret(t *testing.T) {

 func TestSplitNth(t *testing.T) {
 	{
-		ranges, _ := splitNth("..")
+		ranges := splitNth("..")
 		if len(ranges) != 1 ||
 			ranges[0].begin != rangeEllipsis ||
 			ranges[0].end != rangeEllipsis {
@ -88,7 +88,7 @@ func TestSplitNth(t *testing.T) {
 		}
 	}
 	{
-		ranges, _ := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2,2..-2,1..-1")
+		ranges := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2,2..-2,1..-1")
 		if len(ranges) != 10 ||
 			ranges[0].begin != rangeEllipsis || ranges[0].end != 3 ||
 			ranges[1].begin != rangeEllipsis || ranges[1].end != rangeEllipsis ||
@ -106,11 +106,10 @@ func TestSplitNth(t *testing.T) {
 }

 func TestIrrelevantNth(t *testing.T) {
-	index := 0
 	{
 		opts := defaultOptions()
 		words := []string{"--nth", "..", "-x"}
-		parseOptions(&index, opts, words)
+		parseOptions(opts, words)
 		postProcessOptions(opts)
 		if len(opts.Nth) != 0 {
 			t.Errorf("nth should be empty: %v", opts.Nth)
@ -119,7 +118,7 @@ func TestIrrelevantNth(t *testing.T) {
 	for _, words := range [][]string{{"--nth", "..,3", "+x"}, {"--nth", "3,1..", "+x"}, {"--nth", "..-1,1", "+x"}} {
 		{
 			opts := defaultOptions()
-			parseOptions(&index, opts, words)
+			parseOptions(opts, words)
 			postProcessOptions(opts)
 			if len(opts.Nth) != 0 {
 				t.Errorf("nth should be empty: %v", opts.Nth)
@ -128,7 +127,7 @@ func TestIrrelevantNth(t *testing.T) {
 		{
 			opts := defaultOptions()
 			words = append(words, "-x")
-			parseOptions(&index, opts, words)
+			parseOptions(opts, words)
 			postProcessOptions(opts)
 			if len(opts.Nth) != 2 {
 				t.Errorf("nth should not be empty: %v", opts.Nth)
@ -138,7 +137,7 @@ func TestIrrelevantNth(t *testing.T) {
 }

 func TestParseKeys(t *testing.T) {
-	pairs, _ := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g,ctrl-alt-a,ALT-enter,alt-SPACE", "")
+	pairs := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g,ctrl-alt-a,ALT-enter,alt-SPACE", "")
 	checkEvent := func(e tui.Event, s string) {
 		if pairs[e] != s {
 			t.Errorf("%s != %s", pairs[e], s)
@ -164,35 +163,35 @@ func TestParseKeys(t *testing.T) {
 	checkEvent(tui.AltKey(' '), "alt-SPACE")

 	// Synonyms
-	pairs, _ = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
+	pairs = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
 	if len(pairs) != 9 {
 		t.Error(9)
 	}
 	check(tui.CtrlM, "Return")
 	checkEvent(tui.Key(' '), "space")
 	check(tui.Tab, "tab")
-	check(tui.ShiftTab, "btab")
-	check(tui.Esc, "esc")
+	check(tui.BTab, "btab")
+	check(tui.ESC, "esc")
 	check(tui.Up, "up")
 	check(tui.Down, "down")
 	check(tui.Left, "left")
 	check(tui.Right, "right")

-	pairs, _ = parseKeyChords("Tab,Ctrl-I,PgUp,page-up,pgdn,Page-Down,Home,End,Alt-BS,Alt-BSpace,shift-left,shift-right,btab,shift-tab,return,Enter,bspace", "")
+	pairs = parseKeyChords("Tab,Ctrl-I,PgUp,page-up,pgdn,Page-Down,Home,End,Alt-BS,Alt-BSpace,shift-left,shift-right,btab,shift-tab,return,Enter,bspace", "")
 	if len(pairs) != 11 {
 		t.Error(11)
 	}
 	check(tui.Tab, "Ctrl-I")
-	check(tui.PageUp, "page-up")
-	check(tui.PageDown, "Page-Down")
+	check(tui.PgUp, "page-up")
+	check(tui.PgDn, "Page-Down")
 	check(tui.Home, "Home")
 	check(tui.End, "End")
-	check(tui.AltBackspace, "Alt-BSpace")
-	check(tui.ShiftLeft, "shift-left")
-	check(tui.ShiftRight, "shift-right")
-	check(tui.ShiftTab, "shift-tab")
+	check(tui.AltBS, "Alt-BSpace")
+	check(tui.SLeft, "shift-left")
+	check(tui.SRight, "shift-right")
+	check(tui.BTab, "shift-tab")
 	check(tui.CtrlM, "Enter")
-	check(tui.Backspace, "bspace")
+	check(tui.BSpace, "bspace")
 }

 func TestParseKeysWithComma(t *testing.T) {
@ -207,40 +206,40 @@ func TestParseKeysWithComma(t *testing.T) {
 		}
 	}

-	pairs, _ := parseKeyChords(",", "")
+	pairs := parseKeyChords(",", "")
 	checkN(len(pairs), 1)
 	check(pairs, tui.Key(','), ",")

-	pairs, _ = parseKeyChords(",,a,b", "")
+	pairs = parseKeyChords(",,a,b", "")
 	checkN(len(pairs), 3)
 	check(pairs, tui.Key('a'), "a")
 	check(pairs, tui.Key('b'), "b")
 	check(pairs, tui.Key(','), ",")

-	pairs, _ = parseKeyChords("a,b,,", "")
+	pairs = parseKeyChords("a,b,,", "")
 	checkN(len(pairs), 3)
 	check(pairs, tui.Key('a'), "a")
 	check(pairs, tui.Key('b'), "b")
 	check(pairs, tui.Key(','), ",")

-	pairs, _ = parseKeyChords("a,,,b", "")
+	pairs = parseKeyChords("a,,,b", "")
 	checkN(len(pairs), 3)
 	check(pairs, tui.Key('a'), "a")
 	check(pairs, tui.Key('b'), "b")
 	check(pairs, tui.Key(','), ",")

-	pairs, _ = parseKeyChords("a,,,b,c", "")
+	pairs = parseKeyChords("a,,,b,c", "")
 	checkN(len(pairs), 4)
 	check(pairs, tui.Key('a'), "a")
 	check(pairs, tui.Key('b'), "b")
 	check(pairs, tui.Key('c'), "c")
 	check(pairs, tui.Key(','), ",")

-	pairs, _ = parseKeyChords(",,,", "")
+	pairs = parseKeyChords(",,,", "")
 	checkN(len(pairs), 1)
 	check(pairs, tui.Key(','), ",")

-	pairs, _ = parseKeyChords(",ALT-,,", "")
+	pairs = parseKeyChords(",ALT-,,", "")
 	checkN(len(pairs), 1)
 	check(pairs, tui.AltKey(','), "ALT-,")
 }
@ -263,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 \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)
@ -287,17 +290,20 @@ 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) {
 	theme := tui.Dark256
-	dark, _ := parseTheme(theme, "dark")
+	dark := parseTheme(theme, "dark")
 	if *dark != *theme {
 		t.Errorf("colors should be equivalent")
 	}
@ -305,7 +311,7 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("point should not be equivalent")
 	}

-	light, _ := parseTheme(theme, "dark,light")
+	light := parseTheme(theme, "dark,light")
 	if *light == *theme {
 		t.Errorf("should not be equivalent")
 	}
@ -316,7 +322,7 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("point should not be equivalent")
 	}

-	customized, _ := parseTheme(theme, "fg:231,bg:232")
+	customized := parseTheme(theme, "fg:231,bg:232")
 	if customized.Fg.Color != 231 || customized.Bg.Color != 232 {
 		t.Errorf("color not customized")
 	}
@ -329,18 +335,17 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("colors should now be equivalent: %v, %v", tui.Dark256, customized)
 	}

-	customized, _ = parseTheme(theme, "fg:231,dark,bg:232")
+	customized = parseTheme(theme, "fg:231,dark,bg:232")
 	if customized.Fg != tui.Dark256.Fg || customized.Bg == tui.Dark256.Bg {
 		t.Errorf("color not customized")
 	}
 }

 func TestDefaultCtrlNP(t *testing.T) {
-	index := 0
 	check := func(words []string, et tui.EventType, expected actionType) {
 		e := et.AsEvent()
 		opts := defaultOptions()
-		parseOptions(&index, opts, words)
+		parseOptions(opts, words)
 		postProcessOptions(opts)
 		if opts.Keymap[e][0].t != expected {
 			t.Error()
@ -366,9 +371,8 @@ func TestDefaultCtrlNP(t *testing.T) {
 }

 func optsFor(words ...string) *Options {
-	index := 0
 	opts := defaultOptions()
-	parseOptions(&index, opts, words)
+	parseOptions(opts, words)
 	postProcessOptions(opts)
 	return opts
 }
@ -471,7 +475,7 @@ func TestValidateSign(t *testing.T) {
 }

 func TestParseSingleActionList(t *testing.T) {
-	actions, _ := parseSingleActionList("Execute@foo+bar,baz@+up+up+reload:down+down")
+	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))
 	}
@ -487,8 +491,11 @@ func TestParseSingleActionList(t *testing.T) {
 }

 func TestParseSingleActionListError(t *testing.T) {
-	_, err := parseSingleActionList("change-query(foobar)baz")
-	if err == nil {
+	err := ""
+	parseSingleActionList("change-query(foobar)baz", func(e string) {
+		err = e
+	})
+	if len(err) == 0 {
 		t.Errorf("Failed to detect error")
 	}
 }
--- a/src/pattern.go
+++ b/src/pattern.go
@ -60,17 +60,32 @@ type Pattern struct {
 	delimiter     Delimiter
 	nth           []Range
 	procFun       map[termType]algo.Algo
-	cache         *ChunkCache
 }

-var _splitRegex *regexp.Regexp
+var (
+	_patternCache map[string]*Pattern
+	_splitRegex   *regexp.Regexp
+	_cache        ChunkCache
+)

 func init() {
 	_splitRegex = regexp.MustCompile(" +")
+	clearPatternCache()
+	clearChunkCache()
+}
+
+func clearPatternCache() {
+	// We can uniquely identify the pattern for a given string since
+	// search mode and caseMode do not change while the program is running
+	_patternCache = make(map[string]*Pattern)
+}
+
+func clearChunkCache() {
+	_cache = NewChunkCache()
 }

 // BuildPattern builds Pattern object from the given arguments
-func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
+func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
 	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {

 	var asString string
@ -83,9 +98,7 @@ func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy boo
 		asString = string(runes)
 	}

-	// We can uniquely identify the pattern for a given string since
-	// search mode and caseMode do not change while the program is running
-	cached, found := patternCache[asString]
+	cached, found := _patternCache[asString]
 	if found {
 		return cached
 	}
@ -140,7 +153,6 @@ func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy boo
 		cacheable:     cacheable,
 		nth:           nth,
 		delimiter:     delimiter,
-		cache:         cache,
 		procFun:       make(map[termType]algo.Algo)}

 	ptr.cacheKey = ptr.buildCacheKey()
@ -150,19 +162,19 @@ func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy boo
 	ptr.procFun[termPrefix] = algo.PrefixMatch
 	ptr.procFun[termSuffix] = algo.SuffixMatch

-	patternCache[asString] = ptr
+	_patternCache[asString] = ptr
 	return ptr
 }

 func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet {
-	str = strings.ReplaceAll(str, "\\ ", "\t")
+	str = strings.Replace(str, "\\ ", "\t", -1)
 	tokens := _splitRegex.Split(str, -1)
 	sets := []termSet{}
 	set := termSet{}
 	switchSet := false
 	afterBar := false
 	for _, token := range tokens {
-		typ, inv, text := termFuzzy, false, strings.ReplaceAll(token, "\t", " ")
+		typ, inv, text := termFuzzy, false, strings.Replace(token, "\t", " ", -1)
 		lowerText := strings.ToLower(text)
 		caseSensitive := caseMode == CaseRespect ||
 			caseMode == CaseSmart && text != lowerText
@ -197,10 +209,11 @@ 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
@ -270,18 +283,18 @@ func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []Result {
 	// ChunkCache: Exact match
 	cacheKey := p.CacheKey()
 	if p.cacheable {
-		if cached := p.cache.Lookup(chunk, cacheKey); cached != nil {
+		if cached := _cache.Lookup(chunk, cacheKey); cached != nil {
 			return cached
 		}
 	}

 	// Prefix/suffix cache
-	space := p.cache.Search(chunk, cacheKey)
+	space := _cache.Search(chunk, cacheKey)

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

 	if p.cacheable {
-		p.cache.Add(chunk, cacheKey, matches)
+		_cache.Add(chunk, cacheKey, matches)
 	}
 	return matches
 }
--- a/src/pattern_test.go
+++ b/src/pattern_test.go
@ -64,15 +64,10 @@ func TestParseTermsEmpty(t *testing.T) {
 	}
 }

-func buildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
-	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
-	return BuildPattern(NewChunkCache(), make(map[string]*Pattern),
-		fuzzy, fuzzyAlgo, extended, caseMode, normalize, forward,
-		withPos, cacheable, nth, delimiter, runes)
-}
-
 func TestExact(t *testing.T) {
-	pattern := buildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true,
+	defer clearPatternCache()
+	clearPatternCache()
+	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(
@ -86,7 +81,9 @@ func TestExact(t *testing.T) {
 }

 func TestEqual(t *testing.T) {
-	pattern := buildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("^AbC$"))
+	defer clearPatternCache()
+	clearPatternCache()
+	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))
@ -107,12 +104,19 @@ func TestEqual(t *testing.T) {
 }

 func TestCaseSensitivity(t *testing.T) {
-	pat1 := buildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
-	pat2 := buildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
-	pat3 := buildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
-	pat4 := buildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
-	pat5 := buildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
-	pat6 := buildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+	defer clearPatternCache()
+	clearPatternCache()
+	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, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+	clearPatternCache()
+	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, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+	clearPatternCache()
+	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, false, true, []Range{}, Delimiter{}, []rune("Abc"))

 	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
 		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
@ -125,7 +129,7 @@ func TestCaseSensitivity(t *testing.T) {
 }

 func TestOrigTextAndTransformed(t *testing.T) {
-	pattern := buildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, 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}})

@ -159,13 +163,15 @@ func TestOrigTextAndTransformed(t *testing.T) {

 func TestCacheKey(t *testing.T) {
 	test := func(extended bool, patStr string, expected string, cacheable bool) {
-		pat := buildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune(patStr))
+		clearPatternCache()
+		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())
 		}
 		if pat.cacheable != cacheable {
 			t.Errorf("Expected: %t, actual: %t (%s)", cacheable, pat.cacheable, patStr)
 		}
+		clearPatternCache()
 	}
 	test(false, "foo !bar", "foo !bar", true)
 	test(false, "foo | bar !baz", "foo | bar !baz", true)
@ -181,13 +187,15 @@ func TestCacheKey(t *testing.T) {

 func TestCacheable(t *testing.T) {
 	test := func(fuzzy bool, str string, expected string, cacheable bool) {
-		pat := buildPattern(fuzzy, algo.FuzzyMatchV2, true, CaseSmart, true, true, false, true, []Range{}, Delimiter{}, []rune(str))
+		clearPatternCache()
+		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())
 		}
 		if cacheable != pat.cacheable {
 			t.Errorf("Invalid Pattern.cacheable for \"%s\": %v (expected: %v)", str, pat.cacheable, cacheable)
 		}
+		clearPatternCache()
 	}
 	test(true, "foo bar", "foo\tbar", true)
 	test(true, "foo 'bar", "foo\tbar", false)
--- a/src/protector/protector.go
+++ b/src/protector/protector.go
@ -3,4 +3,6 @@
 package protector

 // Protect calls OS specific protections like pledge on OpenBSD
-func Protect() {}
+func Protect() {
+	return
+}
--- a/src/proxy.go
+++ b/src/proxy.go
@ -1,146 +0,0 @@
-package fzf
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"os/signal"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/junegunn/fzf/src/tui"
-	"github.com/junegunn/fzf/src/util"
-)
-
-const becomeSuffix = ".become"
-
-func escapeSingleQuote(str string) string {
-	return "'" + strings.ReplaceAll(str, "'", "'\\''") + "'"
-}
-
-func fifo(name string) (string, error) {
-	ns := time.Now().UnixNano()
-	output := filepath.Join(os.TempDir(), fmt.Sprintf("fzf-%s-%d", name, ns))
-	output, err := mkfifo(output, 0600)
-	if err != nil {
-		return output, err
-	}
-	return output, nil
-}
-
-func runProxy(commandPrefix string, cmdBuilder func(temp string) *exec.Cmd, opts *Options, withExports bool) (int, error) {
-	output, err := fifo("proxy-output")
-	if err != nil {
-		return ExitError, err
-	}
-	defer os.Remove(output)
-
-	// Take the output
-	go func() {
-		withOutputPipe(output, func(outputFile io.ReadCloser) {
-			if opts.Output == nil {
-				io.Copy(os.Stdout, outputFile)
-			} else {
-				reader := bufio.NewReader(outputFile)
-				sep := opts.PrintSep[0]
-				for {
-					item, err := reader.ReadString(sep)
-					if err != nil {
-						break
-					}
-					opts.Output <- item
-				}
-			}
-		})
-	}()
-
-	var command string
-	commandPrefix += ` --no-force-tty-in --proxy-script "$0"`
-	if opts.Input == nil && (opts.ForceTtyIn || util.IsTty(os.Stdin)) {
-		command = fmt.Sprintf(`%s > %q`, commandPrefix, output)
-	} else {
-		input, err := fifo("proxy-input")
-		if err != nil {
-			return ExitError, err
-		}
-		defer os.Remove(input)
-
-		go func() {
-			withInputPipe(input, func(inputFile io.WriteCloser) {
-				if opts.Input == nil {
-					io.Copy(inputFile, os.Stdin)
-				} else {
-					for item := range opts.Input {
-						fmt.Fprint(inputFile, item+opts.PrintSep)
-					}
-				}
-			})
-		}()
-
-		if withExports {
-			command = fmt.Sprintf(`%s < %q > %q`, commandPrefix, input, output)
-		} else {
-			// For mintty: cannot directly read named pipe from Go code
-			command = fmt.Sprintf(`command cat %q | %s > %q`, input, commandPrefix, output)
-		}
-	}
-
-	// To ensure that the options are processed by a POSIX-compliant shell,
-	// we need to write the command to a temporary file and execute it with sh.
-	var exports []string
-	if withExports {
-		exports = os.Environ()
-		for idx, pairStr := range exports {
-			pair := strings.SplitN(pairStr, "=", 2)
-			exports[idx] = fmt.Sprintf("export %s=%s", pair[0], escapeSingleQuote(pair[1]))
-		}
-	}
-	temp := WriteTemporaryFile(append(exports, command), "\n")
-	defer os.Remove(temp)
-
-	cmd := cmdBuilder(temp)
-	cmd.Stderr = os.Stderr
-	intChan := make(chan os.Signal, 1)
-	defer close(intChan)
-	go func() {
-		if sig, valid := <-intChan; valid {
-			cmd.Process.Signal(sig)
-		}
-	}()
-	signal.Notify(intChan, os.Interrupt)
-	if err := cmd.Run(); err != nil {
-		if exitError, ok := err.(*exec.ExitError); ok {
-			code := exitError.ExitCode()
-			if code == ExitBecome {
-				becomeFile := temp + becomeSuffix
-				data, err := os.ReadFile(becomeFile)
-				os.Remove(becomeFile)
-				if err != nil {
-					return ExitError, err
-				}
-				elems := strings.Split(string(data), "\x00")
-				if len(elems) < 1 {
-					return ExitError, errors.New("invalid become command")
-				}
-				command := elems[0]
-				env := []string{}
-				if len(elems) > 1 {
-					env = elems[1:]
-				}
-				executor := util.NewExecutor(opts.WithShell)
-				ttyin, err := tui.TtyIn()
-				if err != nil {
-					return ExitError, err
-				}
-				executor.Become(ttyin, env, command)
-			}
-			return code, err
-		}
-	}
-
-	return ExitOk, nil
-}
--- a/src/proxy_unix.go
+++ b/src/proxy_unix.go
@ -1,38 +0,0 @@
-//go:build !windows
-
-package fzf
-
-import (
-	"io"
-	"os"
-
-	"golang.org/x/sys/unix"
-)
-
-func sh() (string, error) {
-	return "sh", nil
-}
-
-func mkfifo(path string, mode uint32) (string, error) {
-	return path, unix.Mkfifo(path, mode)
-}
-
-func withOutputPipe(output string, task func(io.ReadCloser)) error {
-	outputFile, err := os.OpenFile(output, os.O_RDONLY, 0)
-	if err != nil {
-		return err
-	}
-	task(outputFile)
-	outputFile.Close()
-	return nil
-}
-
-func withInputPipe(input string, task func(io.WriteCloser)) error {
-	inputFile, err := os.OpenFile(input, os.O_WRONLY, 0)
-	if err != nil {
-		return err
-	}
-	task(inputFile)
-	inputFile.Close()
-	return nil
-}
--- a/src/proxy_windows.go
+++ b/src/proxy_windows.go
@ -1,81 +0,0 @@
-//go:build windows
-
-package fzf
-
-import (
-	"fmt"
-	"io"
-	"os/exec"
-	"strconv"
-	"strings"
-	"sync/atomic"
-)
-
-var shPath atomic.Value
-
-func sh() (string, error) {
-	if cached := shPath.Load(); cached != nil {
-		return cached.(string), nil
-	}
-
-	cmd := exec.Command("cygpath", "-w", "/usr/bin/sh")
-	bytes, err := cmd.Output()
-	if err != nil {
-		return "", err
-	}
-
-	sh := strings.TrimSpace(string(bytes))
-	shPath.Store(sh)
-	return sh, nil
-}
-
-func mkfifo(path string, mode uint32) (string, error) {
-	m := strconv.FormatUint(uint64(mode), 8)
-	sh, err := sh()
-	if err != nil {
-		return path, err
-	}
-	cmd := exec.Command(sh, "-c", fmt.Sprintf(`command mkfifo -m %s %q`, m, path))
-	if err := cmd.Run(); err != nil {
-		return path, err
-	}
-	return path + ".lnk", nil
-}
-
-func withOutputPipe(output string, task func(io.ReadCloser)) error {
-	sh, err := sh()
-	if err != nil {
-		return err
-	}
-	cmd := exec.Command(sh, "-c", fmt.Sprintf(`command cat %q`, output))
-	outputFile, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	task(outputFile)
-	cmd.Wait()
-	return nil
-}
-
-func withInputPipe(input string, task func(io.WriteCloser)) error {
-	sh, err := sh()
-	if err != nil {
-		return err
-	}
-	cmd := exec.Command(sh, "-c", fmt.Sprintf(`command cat - > %q`, input))
-	inputFile, err := cmd.StdinPipe()
-	if err != nil {
-		return err
-	}
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-	task(inputFile)
-	inputFile.Close()
-	cmd.Wait()
-	return nil
-}
--- a/src/reader.go
+++ b/src/reader.go
@ -1,39 +1,38 @@
 package fzf

 import (
-	"bytes"
+	"bufio"
 	"context"
 	"io"
 	"os"
 	"os/exec"
+	"path"
 	"path/filepath"
 	"sync"
 	"sync/atomic"
 	"time"

-	"github.com/charlievieth/fastwalk"
 	"github.com/junegunn/fzf/src/util"
+	"github.com/saracen/walker"
 )

 // Reader reads from command or standard input
 type Reader struct {
 	pusher   func([]byte) bool
-	executor *util.Executor
 	eventBox *util.EventBox
 	delimNil bool
 	event    int32
 	finChan  chan bool
 	mutex    sync.Mutex
 	exec     *exec.Cmd
-	execOut  io.ReadCloser
 	command  *string
 	killed   bool
 	wait     bool
 }

 // NewReader returns new Reader object
-func NewReader(pusher func([]byte) bool, eventBox *util.EventBox, executor *util.Executor, delimNil bool, wait bool) *Reader {
-	return &Reader{pusher, executor, eventBox, delimNil, int32(EvtReady), make(chan bool, 1), sync.Mutex{}, nil, nil, nil, false, wait}
+func NewReader(pusher func([]byte) bool, eventBox *util.EventBox, delimNil bool, wait bool) *Reader {
+	return &Reader{pusher, eventBox, delimNil, int32(EvtReady), make(chan bool, 1), sync.Mutex{}, nil, nil, false, wait}
 }

 func (r *Reader) startEventPoller() {
@ -78,50 +77,48 @@ 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 {
-		r.execOut.Close()
 		util.KillCommand(r.exec)
-	} else {
+	} else if defaultCommand != "" {
 		os.Stdin.Close()
 	}
-	r.mutex.Unlock()
 }

-func (r *Reader) restart(command commandSpec, environ []string) {
+func (r *Reader) restart(command string) {
 	r.event = int32(EvtReady)
 	r.startEventPoller()
-	success := r.readFromCommand(command.command, environ)
+	success := r.readFromCommand(nil, command)
 	r.fin(success)
-	removeFiles(command.tempFiles)
-}
-
-func (r *Reader) readChannel(inputChan chan string) bool {
-	for {
-		item, more := <-inputChan
-		if !more {
-			break
-		}
-		if r.pusher([]byte(item)) {
-			atomic.StoreInt32(&r.event, int32(EvtReadNew))
-		}
-	}
-	return true
 }

 // ReadSource reads data from the default command or from standard input
-func (r *Reader) ReadSource(inputChan chan string, root string, opts walkerOpts, ignores []string) {
+func (r *Reader) ReadSource() {
 	r.startEventPoller()
 	var success bool
-	if inputChan != nil {
-		success = r.readChannel(inputChan)
-	} else if util.IsTty(os.Stdin) {
+	if util.IsTty() {
+		// The default command for *nix requires a shell that supports "pipefail"
+		// https://unix.stackexchange.com/a/654932/62171
+		shell := "bash"
+		currentShell := os.Getenv("SHELL")
+		currentShellName := path.Base(currentShell)
+		for _, shellName := range []string{"bash", "zsh", "ksh", "ash", "hush", "mksh", "yash"} {
+			if currentShellName == shellName {
+				shell = currentShell
+				break
+			}
+		}
 		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
 		if len(cmd) == 0 {
-			success = r.readFiles(root, opts, ignores)
+			if defaultCommand != "" {
+				success = r.readFromCommand(&shell, defaultCommand)
+			} else {
+				success = r.readFiles()
+			}
 		} else {
-			// We can't export FZF_* environment variables to the default command
-			success = r.readFromCommand(cmd, nil)
+			success = r.readFromCommand(nil, cmd)
 		}
 	} else {
 		success = r.readFromStdin()
@ -130,90 +127,32 @@ func (r *Reader) ReadSource(inputChan chan string, root string, opts walkerOpts,
 }

 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
 	}
-
-	slab := make([]byte, readerSlabSize)
-	leftover := []byte{}
-	var err error
+	reader := bufio.NewReaderSize(src, readerBufferSize)
 	for {
-		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
-			}
-		}
-
-		// We're not making any progress after 100 tries. Stop.
-		if n == 0 {
-			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]
+		// 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 {
-					slice = slice[:len(slice)-1]
-				}
-				if len(leftover) > 0 {
-					slice = append(leftover, slice...)
-					leftover = []byte{}
+					bytea = bytea[:byteaLen-1]
 				}
-				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 r.pusher(bytea) {
+				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}
-
-		if err == io.EOF {
-			leftover = append(leftover, buf...)
+		if err != nil {
 			break
 		}
-
-		if len(slab) == 0 {
-			slab = make([]byte, readerSlabSize)
-		}
-	}
-	if len(leftover) > 0 && r.pusher(leftover) {
-		atomic.StoreInt32(&r.event, int32(EvtReadNew))
 	}
 }

@ -222,28 +161,16 @@ func (r *Reader) readFromStdin() bool {
 	return true
 }

-func (r *Reader) readFiles(root string, opts walkerOpts, ignores []string) bool {
+func (r *Reader) readFiles() bool {
 	r.killed = false
-	conf := fastwalk.Config{Follow: opts.follow}
-	fn := func(path string, de os.DirEntry, err error) error {
-		if err != nil {
-			return nil
-		}
+	fn := func(path string, mode os.FileInfo) error {
 		path = filepath.Clean(path)
 		if path != "." {
-			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
-					}
-				}
+			isDir := mode.Mode().IsDir()
+			if isDir && filepath.Base(path)[0] == '.' {
+				return filepath.SkipDir
 			}
-			if ((opts.file && !isDir) || (opts.dir && isDir)) && r.pusher([]byte(path)) {
+			if !isDir && r.pusher([]byte(path)) {
 				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}
@ -254,34 +181,31 @@ func (r *Reader) readFiles(root string, opts walkerOpts, ignores []string) bool
 		}
 		return nil
 	}
-	return fastwalk.Walk(&conf, root, fn) == nil
+	cb := walker.WithErrorCallback(func(pathname string, err error) error {
+		return nil
+	})
+	return walker.Walk(".", fn, cb) == nil
 }

-func (r *Reader) readFromCommand(command string, environ []string) bool {
+func (r *Reader) readFromCommand(shell *string, command string) bool {
 	r.mutex.Lock()
 	r.killed = false
 	r.command = &command
-	r.exec = r.executor.ExecCommand(command, true)
-	if environ != nil {
-		r.exec.Env = environ
+	if shell != nil {
+		r.exec = util.ExecCommandWith(*shell, command, true)
+	} else {
+		r.exec = util.ExecCommand(command, true)
 	}
-
-	var err error
-	r.execOut, err = r.exec.StdoutPipe()
+	out, err := r.exec.StdoutPipe()
 	if err != nil {
-		r.exec = nil
 		r.mutex.Unlock()
 		return false
 	}
-
 	err = r.exec.Start()
+	r.mutex.Unlock()
 	if err != nil {
-		r.exec = nil
-		r.mutex.Unlock()
 		return false
 	}
-
-	r.mutex.Unlock()
-	r.feed(r.execOut)
+	r.feed(out)
 	return r.exec.Wait() == nil
 }
--- a/src/reader_test.go
+++ b/src/reader_test.go
@ -10,10 +10,9 @@ import (
 func TestReadFromCommand(t *testing.T) {
 	strs := []string{}
 	eb := util.NewEventBox()
-	exec := util.NewExecutor("")
 	reader := NewReader(
 		func(s []byte) bool { strs = append(strs, string(s)); return true },
-		eb, exec, false, true)
+		eb, false, true)

 	reader.startEventPoller()

@ -23,7 +22,7 @@ func TestReadFromCommand(t *testing.T) {
 	}

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

 	// Failing command
-	reader.fin(reader.readFromCommand(`no-such-command`, nil))
+	reader.fin(reader.readFromCommand(nil, `no-such-command`))
 	strs = []string{}
 	if len(strs) > 0 {
 		t.Errorf("%s", strs)
--- a/src/result.go
+++ b/src/result.go
@ -15,7 +15,6 @@ type Offset [2]int32
 type colorOffset struct {
 	offset [2]int32
 	color  tui.ColorPair
-	match  bool
 }

 type Result struct {
@ -81,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())+1))
+					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/int(item.TrimLength()+1))
 				}
 			}
 		}
@ -110,7 +109,7 @@ func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme,
 	if len(itemColors) == 0 {
 		var offsets []colorOffset
 		for _, off := range matchOffsets {
-			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: colMatch, match: true})
+			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: colMatch})
 		}
 		return offsets
 	}
@ -194,13 +193,12 @@ func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme,
 					}
 				}
 				colors = append(colors, colorOffset{
-					offset: [2]int32{int32(start), int32(idx)}, color: color, match: true})
+					offset: [2]int32{int32(start), int32(idx)}, color: color})
 			} else {
 				ansi := itemColors[curr-1]
 				colors = append(colors, colorOffset{
 					offset: [2]int32{int32(start), int32(idx)},
-					color:  ansiToColorPair(ansi, colBase),
-					match:  false})
+					color:  ansiToColorPair(ansi, colBase)})
 			}
 		}
 	}
--- a/src/server.go
+++ b/src/server.go
@ -32,7 +32,6 @@ const (
 	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
 )
@ -54,47 +53,47 @@ func (addr listenAddress) IsLocal() bool {

 var defaultListenAddr = listenAddress{"localhost", 0}

-func parseListenAddress(address string) (listenAddress, error) {
+func parseListenAddress(address string) (error, listenAddress) {
 	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)
+		return fmt.Errorf("invalid listen address: %s", address), defaultListenAddr
 	}
 	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)
+		return fmt.Errorf("invalid listen port: %s", portStr), defaultListenAddr
 	}
 	if len(parts[0]) == 0 {
 		parts[0] = "localhost"
 	}
-	return listenAddress{parts[0], port}, nil
+	return nil, listenAddress{parts[0], port}
 }

-func startHttpServer(address listenAddress, actionChannel chan []*action, responseChannel chan string) (net.Listener, int, error) {
+func startHttpServer(address listenAddress, actionChannel chan []*action, responseChannel chan string) (error, int) {
 	host := address.host
 	port := address.port
 	apiKey := os.Getenv("FZF_API_KEY")
 	if !address.IsLocal() && len(apiKey) == 0 {
-		return nil, port, errors.New("FZF_API_KEY is required to allow remote access")
+		return fmt.Errorf("FZF_API_KEY is required to allow remote access"), port
 	}
 	addrStr := fmt.Sprintf("%s:%d", host, port)
 	listener, err := net.Listen("tcp", addrStr)
 	if err != nil {
-		return nil, port, fmt.Errorf("failed to listen on %s", addrStr)
+		return fmt.Errorf("failed to listen on %s", addrStr), port
 	}
 	if port == 0 {
 		addr := listener.Addr().String()
 		parts := strings.Split(addr, ":")
 		if len(parts) < 2 {
-			return nil, port, fmt.Errorf("cannot extract port: %s", addr)
+			return fmt.Errorf("cannot extract port: %s", addr), port
 		}
 		var err error
 		port, err = strconv.Atoi(parts[len(parts)-1])
 		if err != nil {
-			return nil, port, err
+			return err, port
 		}
 	}

@ -109,16 +108,18 @@ func startHttpServer(address listenAddress, actionChannel chan []*action, respon
 			conn, err := listener.Accept()
 			if err != nil {
 				if errors.Is(err, net.ErrClosed) {
-					return
+					break
+				} else {
+					continue
 				}
-				continue
 			}
 			conn.Write([]byte(server.handleHttpRequest(conn)))
 			conn.Close()
 		}
+		listener.Close()
 	}()

-	return listener, port, nil
+	return nil, port
 }

 // Here we are writing a simplistic HTTP server without using net/http
@ -169,7 +170,7 @@ func (server *httpServer) handleHttpRequest(conn net.Conn) string {
 				select {
 				case response := <-server.responseChannel:
 					return good(response)
-				case <-time.After(channelTimeout):
+				case <-time.After(2 * time.Second):
 					go func() {
 						// Drain the channel
 						<-server.responseChannel
@ -215,19 +216,18 @@ func (server *httpServer) handleHttpRequest(conn net.Conn) string {
 	}
 	body = body[:contentLength]

-	actions, err := parseSingleActionList(strings.Trim(string(body), "\r\n"))
-	if err != nil {
-		return bad(err.Error())
+	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
-	}
+	server.actionChannel <- actions
 	return httpOk + crlf
 }

@ -237,13 +237,15 @@ func parseGetParams(query string) getParams {
 		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
-					}
+			case "limit":
+				val, err := strconv.Atoi(parts[1])
+				if err == nil {
+					params.limit = val
+				}
+			case "offset":
+				val, err := strconv.Atoi(parts[1])
+				if err == nil {
+					params.offset = val
 				}
 			}
 		}
--- a/src/terminal.go
+++ b/src/terminal.go
--- a/src/terminal_test.go
+++ b/src/terminal_test.go
@ -13,7 +13,7 @@ import (
 )

 func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter, printsep string, forcePlus bool, query string, allItems []*Item) string {
-	replaced, _ := replacePlaceholder(replacePlaceholderParams{
+	return replacePlaceholder(replacePlaceholderParams{
 		template:   template,
 		stripAnsi:  stripAnsi,
 		delimiter:  delimiter,
@ -23,9 +23,7 @@ func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter
 		allItems:   allItems,
 		lastAction: actBackwardDeleteCharEof,
 		prompt:     "prompt",
-		executor:   util.NewExecutor(""),
 	})
-	return replaced
 }

 func TestReplacePlaceholder(t *testing.T) {
@ -246,7 +244,6 @@ func TestQuoteEntry(t *testing.T) {
 	unixStyle := quotes{``, `'`, `'\''`, `"`, `\`}
 	windowsStyle := quotes{`^`, `^"`, `'`, `\^"`, `\\`}
 	var effectiveStyle quotes
-	exec := util.NewExecutor("")

 	if util.IsWindows() {
 		effectiveStyle = windowsStyle
@ -281,7 +278,7 @@ func TestQuoteEntry(t *testing.T) {
 	}

 	for input, expected := range tests {
-		escaped := exec.QuoteEntry(input)
+		escaped := quoteEntry(input)
 		expected = templateToString(expected, effectiveStyle)
 		if escaped != expected {
 			t.Errorf("Input: %s, expected: %s, actual %s", input, expected, escaped)
@ -320,9 +317,9 @@ func TestUnixCommands(t *testing.T) {

 // purpose of this test is to demonstrate some shortcomings of fzf's templating system on Windows
 func TestWindowsCommands(t *testing.T) {
-	// XXX Deprecated
-	t.SkipNow()
-
+	if !util.IsWindows() {
+		t.SkipNow()
+	}
 	tests := []testCase{
 		// reference: give{template, query, items}, want{output OR match}

--- a/src/terminal_unix.go
+++ b/src/terminal_unix.go
@ -5,11 +5,26 @@ 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)
 }
@ -26,3 +41,7 @@ func notifyStop(p *os.Process) {
 func notifyOnCont(resizeChan chan<- os.Signal) {
 	signal.Notify(resizeChan, syscall.SIGCONT)
 }
+
+func quoteEntry(entry string) string {
+	return "'" + escaper.Replace(entry) + "'"
+}
--- a/src/terminal_windows.go
+++ b/src/terminal_windows.go
@ -4,6 +4,8 @@ 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) + "'"
+	}
+}
--- a/src/tmux.go
+++ b/src/tmux.go
@ -1,57 +0,0 @@
-package fzf
-
-import (
-	"os"
-	"os/exec"
-
-	"github.com/junegunn/fzf/src/tui"
-)
-
-func runTmux(args []string, opts *Options) (int, error) {
-	// Prepare arguments
-	fzf := args[0]
-	args = append([]string{"--bind=ctrl-z:ignore"}, args[1:]...)
-	if opts.BorderShape == tui.BorderUndefined {
-		args = append(args, "--border")
-	}
-	argStr := escapeSingleQuote(fzf)
-	for _, arg := range args {
-		argStr += " " + escapeSingleQuote(arg)
-	}
-	argStr += ` --no-tmux --no-height`
-
-	// Get current directory
-	dir, err := os.Getwd()
-	if err != nil {
-		dir = "."
-	}
-
-	// Set tmux options for popup placement
-	// C        Both    The centre of the terminal
-	// R        -x      The right side of the terminal
-	// P        Both    The bottom left of the pane
-	// M        Both    The mouse position
-	// W        Both    The window position on the status line
-	// S        -y      The line above or below the status line
-	tmuxArgs := []string{"display-popup", "-E", "-B", "-d", dir}
-	switch opts.Tmux.position {
-	case posUp:
-		tmuxArgs = append(tmuxArgs, "-xC", "-y0")
-	case posDown:
-		tmuxArgs = append(tmuxArgs, "-xC", "-yS")
-	case posLeft:
-		tmuxArgs = append(tmuxArgs, "-x0", "-yC")
-	case posRight:
-		tmuxArgs = append(tmuxArgs, "-xR", "-yC")
-	case posCenter:
-		tmuxArgs = append(tmuxArgs, "-xC", "-yC")
-	}
-	tmuxArgs = append(tmuxArgs, "-w"+opts.Tmux.width.String())
-	tmuxArgs = append(tmuxArgs, "-h"+opts.Tmux.height.String())
-
-	return runProxy(argStr, func(temp string) *exec.Cmd {
-		sh, _ := sh()
-		tmuxArgs = append(tmuxArgs, sh, temp)
-		return exec.Command("tmux", tmuxArgs...)
-	}, opts, true)
-}
--- a/src/tokenizer.go
+++ b/src/tokenizer.go
@ -91,7 +91,7 @@ func withPrefixLengths(tokens []string, begin int) []Token {

 	prefixLength := begin
 	for idx := range tokens {
-		chars := util.ToChars(stringBytes(tokens[idx]))
+		chars := util.ToChars([]byte(tokens[idx]))
 		ret[idx] = Token{&chars, int32(prefixLength)}
 		prefixLength += chars.Length()
 	}
@ -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(stringBytes(joinTokens(tokens)))
+				chars := util.ToChars([]byte(joinTokens(tokens)))
 				parts = append(parts, &chars)
 			} else {
 				if idx < 0 {
--- a/src/tokenizer_test.go
+++ b/src/tokenizer_test.go
@ -71,14 +71,14 @@ func TestTransform(t *testing.T) {
 	{
 		tokens := Tokenize(input, Delimiter{})
 		{
-			ranges, _ := splitNth("1,2,3")
+			ranges := splitNth("1,2,3")
 			tx := Transform(tokens, ranges)
 			if joinTokens(tx) != "abc:  def:  ghi:  " {
 				t.Errorf("%s", tx)
 			}
 		}
 		{
-			ranges, _ := splitNth("1..2,3,2..,1")
+			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
 			if string(joinTokens(tx)) != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
 				len(tx) != 4 ||
@ -93,7 +93,7 @@ func TestTransform(t *testing.T) {
 	{
 		tokens := Tokenize(input, delimiterRegexp(":"))
 		{
-			ranges, _ := splitNth("1..2,3,2..,1")
+			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
 			if joinTokens(tx) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
 				len(tx) != 4 ||
@ -108,6 +108,5 @@ func TestTransform(t *testing.T) {
 }

 func TestTransformIndexOutOfBounds(t *testing.T) {
-	s, _ := splitNth("1")
-	Transform([]Token{}, s)
+	Transform([]Token{}, splitNth("1"))
 }
--- a/src/tui/dummy.go
+++ b/src/tui/dummy.go
@ -8,7 +8,7 @@ func HasFullscreenRenderer() bool {
 	return false
 }

-var DefaultBorderShape = BorderRounded
+var DefaultBorderShape BorderShape = BorderRounded

 func (a Attr) Merge(b Attr) Attr {
 	return a | b
@ -29,14 +29,13 @@ const (
 	StrikeThrough = Attr(1 << 7)
 )

-func (r *FullscreenRenderer) Init() error                        { return nil }
+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{} }
--- a/src/tui/eventtype_string.go
+++ b/src/tui/eventtype_string.go
@ -1,122 +0,0 @@
-// 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[Fatal-75]
-	_ = x[Mouse-76]
-	_ = x[DoubleClick-77]
-	_ = x[LeftClick-78]
-	_ = x[RightClick-79]
-	_ = x[SLeftClick-80]
-	_ = x[SRightClick-81]
-	_ = x[ScrollUp-82]
-	_ = x[ScrollDown-83]
-	_ = x[SScrollUp-84]
-	_ = x[SScrollDown-85]
-	_ = x[PreviewScrollUp-86]
-	_ = x[PreviewScrollDown-87]
-	_ = x[Resize-88]
-	_ = x[Change-89]
-	_ = x[BackwardEOF-90]
-	_ = x[Start-91]
-	_ = x[Load-92]
-	_ = x[Focus-93]
-	_ = x[One-94]
-	_ = x[Zero-95]
-	_ = x[Result-96]
-	_ = x[Jump-97]
-	_ = x[JumpCancel-98]
-	_ = x[ClickHeader-99]
-}
-
-const _EventType_name = "RuneCtrlACtrlBCtrlCCtrlDCtrlECtrlFCtrlGCtrlHTabCtrlJCtrlKCtrlLCtrlMCtrlNCtrlOCtrlPCtrlQCtrlRCtrlSCtrlTCtrlUCtrlVCtrlWCtrlXCtrlYCtrlZEscCtrlSpaceCtrlDeleteCtrlBackSlashCtrlRightBracketCtrlCaretCtrlSlashShiftTabBackspaceDeletePageUpPageDownUpDownLeftRightHomeEndInsertShiftUpShiftDownShiftLeftShiftRightShiftDeleteF1F2F3F4F5F6F7F8F9F10F11F12AltBackspaceAltUpAltDownAltLeftAltRightAltShiftUpAltShiftDownAltShiftLeftAltShiftRightAltCtrlAltInvalidFatalMouseDoubleClickLeftClickRightClickSLeftClickSRightClickScrollUpScrollDownSScrollUpSScrollDownPreviewScrollUpPreviewScrollDownResizeChangeBackwardEOFStartLoadFocusOneZeroResultJumpJumpCancelClickHeader"
-
-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, 452, 463, 472, 482, 492, 503, 511, 521, 530, 541, 556, 573, 579, 585, 596, 601, 605, 610, 613, 617, 623, 627, 637, 648}
-
-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]]
-}
--- a/src/tui/light.go
+++ b/src/tui/light.go
@ -2,7 +2,6 @@ package tui

 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"os"
 	"regexp"
@ -11,8 +10,7 @@ import (
 	"time"
 	"unicode/utf8"

-	"github.com/junegunn/fzf/src/util"
-	"github.com/rivo/uniseg"
+	"github.com/junegunn/uniseg"

 	"golang.org/x/term"
 )
@ -29,8 +27,8 @@ const (

 const consoleDevice string = "/dev/tty"

-var offsetRegexp = regexp.MustCompile("(.*)\x1b\\[([0-9]+);([0-9]+)R")
-var offsetRegexpBegin = regexp.MustCompile("^\x1b\\[[0-9]+;[0-9]+R")
+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) PassThrough(str string) {
 	r.queued.WriteString("\x1b7" + str + "\x1b8")
@ -73,14 +71,13 @@ func (r *LightRenderer) csi(code string) string {

 func (r *LightRenderer) flush() {
 	if r.queued.Len() > 0 {
-		fmt.Fprint(r.ttyout, "\x1b[?7l\x1b[?25l"+r.queued.String()+"\x1b[?25h\x1b[?7h")
+		fmt.Fprint(os.Stderr, "\x1b[?25l"+r.queued.String()+"\x1b[?25h")
 		r.queued.Reset()
 	}
 }

 // Light renderer
 type LightRenderer struct {
-	closed        *util.AtomicBool
 	theme         *ColorTheme
 	mouse         bool
 	forceBlack    bool
@ -88,7 +85,6 @@ type LightRenderer struct {
 	prevDownTime  time.Time
 	clicks        [][2]int
 	ttyin         *os.File
-	ttyout        *os.File
 	buffer        []byte
 	origState     *term.State
 	width         int
@ -127,25 +123,19 @@ type LightWindow struct {
 	bg       Color
 }

-func NewLightRenderer(ttyin *os.File, theme *ColorTheme, forceBlack bool, mouse bool, tabstop int, clearOnExit bool, fullscreen bool, maxHeightFunc func(int) int) (Renderer, error) {
-	out, err := openTtyOut()
-	if err != nil {
-		out = os.Stderr
-	}
+func NewLightRenderer(theme *ColorTheme, forceBlack bool, mouse bool, tabstop int, clearOnExit bool, fullscreen bool, maxHeightFunc func(int) int) Renderer {
 	r := LightRenderer{
-		closed:        util.NewAtomicBool(false),
 		theme:         theme,
 		forceBlack:    forceBlack,
 		mouse:         mouse,
 		clearOnExit:   clearOnExit,
-		ttyin:         ttyin,
-		ttyout:        out,
+		ttyin:         openTtyIn(),
 		yoffset:       0,
 		tabstop:       tabstop,
 		fullscreen:    fullscreen,
 		upOneLine:     false,
 		maxHeightFunc: maxHeightFunc}
-	return &r, nil
+	return &r
 }

 func repeat(r rune, times int) string {
@ -163,11 +153,11 @@ func atoi(s string, defaultValue int) int {
 	return value
 }

-func (r *LightRenderer) Init() error {
+func (r *LightRenderer) Init() {
 	r.escDelay = atoi(os.Getenv("ESCDELAY"), defaultEscDelay)

 	if err := r.initPlatform(); err != nil {
-		return err
+		errorExit(err.Error())
 	}
 	r.updateTerminalSize()
 	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
@ -205,7 +195,6 @@ func (r *LightRenderer) Init() error {
 	if !r.fullscreen && r.mouse {
 		r.yoffset, _ = r.findOffset()
 	}
-	return nil
 }

 func (r *LightRenderer) Resize(maxHeightFunc func(int) int) {
@ -244,20 +233,19 @@ func getEnv(name string, defaultValue int) int {
 	return atoi(env, defaultValue)
 }

-func (r *LightRenderer) getBytes() ([]byte, error) {
-	bytes, err := r.getBytesInternal(r.buffer, false)
-	return bytes, err
+func (r *LightRenderer) getBytes() []byte {
+	return r.getBytesInternal(r.buffer, false)
 }

-func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) ([]byte, error) {
+func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
 	c, ok := r.getch(nonblock)
 	if !nonblock && !ok {
 		r.Close()
-		return nil, errors.New("failed to read " + consoleDevice)
+		errorExit("Failed to read " + consoleDevice)
 	}

 	retries := 0
-	if c == Esc.Int() || nonblock {
+	if c == ESC.Int() || nonblock {
 		retries = r.escDelay / escPollInterval
 	}
 	buffer = append(buffer, byte(c))
@ -272,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
@ -284,23 +272,19 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) ([]byte,
 		// so terminate fzf immediately.
 		if len(buffer) > maxInputBuffer {
 			r.Close()
-			return nil, fmt.Errorf("input buffer overflow (%d): %v", len(buffer), buffer)
+			panic(fmt.Sprintf("Input buffer overflow (%d): %v", len(buffer), buffer))
 		}
 	}

-	return buffer, nil
+	return buffer
 }

 func (r *LightRenderer) GetChar() Event {
-	var err error
 	if len(r.buffer) == 0 {
-		r.buffer, err = r.getBytes()
-		if err != nil {
-			return Event{Fatal, 0, nil}
-		}
+		r.buffer = r.getBytes()
 	}
 	if len(r.buffer) == 0 {
-		return Event{Fatal, 0, nil}
+		panic("Empty buffer")
 	}

 	sz := 1
@ -316,7 +300,7 @@ func (r *LightRenderer) GetChar() Event {
 	case CtrlQ.Byte():
 		return Event{CtrlQ, 0, nil}
 	case 127:
-		return Event{Backspace, 0, nil}
+		return Event{BSpace, 0, nil}
 	case 0:
 		return Event{CtrlSpace, 0, nil}
 	case 28:
@ -327,13 +311,11 @@ 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 {
-			if r.buffer, err = r.getBytes(); err != nil {
-				return Event{Fatal, 0, nil}
-			}
+			r.buffer = r.getBytes()
 			ev = r.escSequence(&sz)
 		}
 		return ev
@ -345,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}
@ -353,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)
@ -367,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{AltBackspace, 0, nil}
+		return Event{AltBS, 0, nil}
 	case '[', 'O':
 		if len(r.buffer) < 3 {
 			return Event{Invalid, 0, nil}
@ -404,7 +386,7 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 			}
 			return Event{Up, 0, nil}
 		case 'Z':
-			return Event{ShiftTab, 0, nil}
+			return Event{BTab, 0, nil}
 		case 'H':
 			return Event{Home, 0, nil}
 		case 'F':
@ -452,7 +434,7 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 				return Event{Invalid, 0, nil} // INS
 			case '3':
 				if r.buffer[3] == '~' {
-					return Event{Delete, 0, nil}
+					return Event{Del, 0, nil}
 				}
 				if len(r.buffer) == 6 && r.buffer[5] == '~' {
 					*sz = 6
@ -460,16 +442,16 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 					case '5':
 						return Event{CtrlDelete, 0, nil}
 					case '2':
-						return Event{ShiftDelete, 0, nil}
+						return Event{SDelete, 0, nil}
 					}
 				}
 				return Event{Invalid, 0, nil}
 			case '4':
 				return Event{End, 0, nil}
 			case '5':
-				return Event{PageUp, 0, nil}
+				return Event{PgUp, 0, nil}
 			case '6':
-				return Event{PageDown, 0, nil}
+				return Event{PgDn, 0, nil}
 			case '7':
 				return Event{Home, 0, nil}
 			case '8':
@ -507,29 +489,16 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 					}
 					*sz = 6
 					switch r.buffer[4] {
-					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")
+					case '1', '2', '3', '5':
 						alt := r.buffer[4] == '3'
+						altShift := r.buffer[4] == '1' && r.buffer[5] == '0'
 						char := r.buffer[5]
-						altShift := false
-						if r.buffer[4] == '1' && r.buffer[5] == '0' {
-							altShift = true
+						if altShift {
 							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':
@ -537,33 +506,33 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 								return Event{AltUp, 0, nil}
 							}
 							if altShift {
-								return Event{AltShiftUp, 0, nil}
+								return Event{AltSUp, 0, nil}
 							}
-							return Event{ShiftUp, 0, nil}
+							return Event{SUp, 0, nil}
 						case 'B':
 							if alt {
 								return Event{AltDown, 0, nil}
 							}
 							if altShift {
-								return Event{AltShiftDown, 0, nil}
+								return Event{AltSDown, 0, nil}
 							}
-							return Event{ShiftDown, 0, nil}
+							return Event{SDown, 0, nil}
 						case 'C':
 							if alt {
 								return Event{AltRight, 0, nil}
 							}
 							if altShift {
-								return Event{AltShiftRight, 0, nil}
+								return Event{AltSRight, 0, nil}
 							}
-							return Event{ShiftRight, 0, nil}
+							return Event{SRight, 0, nil}
 						case 'D':
 							if alt {
 								return Event{AltLeft, 0, nil}
 							}
 							if altShift {
-								return Event{AltShiftLeft, 0, nil}
+								return Event{AltSLeft, 0, nil}
 							}
-							return Event{ShiftLeft, 0, nil}
+							return Event{SLeft, 0, nil}
 						}
 					} // r.buffer[4]
 				} // r.buffer[3]
@ -725,10 +694,6 @@ func (r *LightRenderer) NeedScrollbarRedraw() bool {
 	return false
 }

-func (r *LightRenderer) ShouldEmitResizeEvent() bool {
-	return false
-}
-
 func (r *LightRenderer) RefreshWindows(windows []Window) {
 	r.flush()
 }
@ -756,7 +721,6 @@ func (r *LightRenderer) Close() {
 	r.flush()
 	r.closePlatform()
 	r.restoreTerminal()
-	r.closed.Set(true)
 }

 func (r *LightRenderer) Top() int {
@ -844,7 +808,6 @@ func (w *LightWindow) drawBorderHorizontal(top, bottom bool) {
 		w.Move(0, 0)
 		w.CPrint(color, repeat(w.border.top, w.width/hw))
 	}
-
 	if bottom {
 		w.Move(w.height-1, 0)
 		w.CPrint(color, repeat(w.border.bottom, w.width/hw))
@ -852,20 +815,21 @@ func (w *LightWindow) drawBorderHorizontal(top, bottom bool) {
 }

 func (w *LightWindow) drawBorderVertical(left, right bool) {
-	vw := runeWidth(w.border.left)
+	width := w.width - 2
+	if !left || !right {
+		width++
+	}
 	color := ColBorder
 	if w.preview {
 		color = ColPreviewBorder
 	}
 	for y := 0; y < w.height; y++ {
+		w.Move(y, 0)
 		if left {
-			w.Move(y, 0)
 			w.CPrint(color, string(w.border.left))
-			w.CPrint(color, " ") // Margin
 		}
+		w.CPrint(color, repeat(' ', width))
 		if right {
-			w.Move(y, w.width-vw-1)
-			w.CPrint(color, " ") // Margin
 			w.CPrint(color, string(w.border.right))
 		}
 	}
@ -887,10 +851,7 @@ func (w *LightWindow) drawBorderAround(onlyHorizontal bool) {
 		for y := 1; y < w.height-1; y++ {
 			w.Move(y, 0)
 			w.CPrint(color, string(w.border.left))
-			w.CPrint(color, " ") // Margin
-
-			w.Move(y, w.width-vw-1)
-			w.CPrint(color, " ") // Margin
+			w.CPrint(color, repeat(' ', w.width-vw*2))
 			w.CPrint(color, string(w.border.right))
 		}
 	}
@ -1021,7 +982,7 @@ func (w *LightWindow) Print(text string) {
 }

 func cleanse(str string) string {
-	return strings.ReplaceAll(str, "\x1b", "")
+	return strings.Replace(str, "\x1b", "", -1)
 }

 func (w *LightWindow) CPrint(pair ColorPair, text string) {
--- a/src/tui/light_unix.go
+++ b/src/tui/light_unix.go
@ -3,7 +3,7 @@
 package tui

 import (
-	"errors"
+	"fmt"
 	"os"
 	"os/exec"
 	"strings"
@ -45,29 +45,22 @@ func (r *LightRenderer) initPlatform() error {
 }

 func (r *LightRenderer) closePlatform() {
-	r.ttyout.Close()
+	// NOOP
 }

-func openTty(mode int) (*os.File, error) {
-	in, err := os.OpenFile(consoleDevice, mode, 0)
+func openTtyIn() *os.File {
+	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
 	if err != nil {
 		tty := ttyname()
 		if len(tty) > 0 {
-			if in, err := os.OpenFile(tty, mode, 0); err == nil {
-				return in, nil
+			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
+				return in
 			}
 		}
-		return nil, errors.New("failed to open " + consoleDevice)
+		fmt.Fprintln(os.Stderr, "Failed to open "+consoleDevice)
+		os.Exit(2)
 	}
-	return in, nil
-}
-
-func openTtyIn() (*os.File, error) {
-	return openTty(syscall.O_RDONLY)
-}
-
-func openTtyOut() (*os.File, error) {
-	return openTty(syscall.O_WRONLY)
+	return in
 }

 func (r *LightRenderer) setupTerminal() {
@ -93,14 +86,9 @@ func (r *LightRenderer) updateTerminalSize() {
 func (r *LightRenderer) findOffset() (row int, col int) {
 	r.csi("6n")
 	r.flush()
-	var err error
 	bytes := []byte{}
 	for tries := 0; tries < offsetPollTries; tries++ {
-		bytes, err = r.getBytesInternal(bytes, tries > 0)
-		if err != nil {
-			return -1, -1
-		}
-
+		bytes = r.getBytesInternal(bytes, tries > 0)
 		offsets := offsetRegexp.FindSubmatch(bytes)
 		if len(offsets) > 3 {
 			// Add anything we skipped over to the input buffer
--- a/src/tui/light_windows.go
+++ b/src/tui/light_windows.go
@ -72,7 +72,7 @@ func (r *LightRenderer) initPlatform() error {
 	go func() {
 		fd := int(r.inHandle)
 		b := make([]byte, 1)
-		for !r.closed.Get() {
+		for {
 			// HACK: if run from PSReadline, something resets ConsoleMode to remove ENABLE_VIRTUAL_TERMINAL_INPUT.
 			_ = windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)

@ -91,13 +91,9 @@ func (r *LightRenderer) closePlatform() {
 	windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput)
 }

-func openTtyIn() (*os.File, error) {
+func openTtyIn() *os.File {
 	// not used
-	return nil, nil
-}
-
-func openTtyOut() (*os.File, error) {
-	return os.Stderr, nil
+	return nil
 }

 func (r *LightRenderer) setupTerminal() error {
@ -139,7 +135,7 @@ func (r *LightRenderer) findOffset() (row int, col int) {
 	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
 		return -1, -1
 	}
-	return int(bufferInfo.CursorPosition.Y), int(bufferInfo.CursorPosition.X)
+	return int(bufferInfo.CursorPosition.X), int(bufferInfo.CursorPosition.Y)
 }

 func (r *LightRenderer) getch(nonblock bool) (int, bool) {
--- a/src/tui/tcell.go
+++ b/src/tui/tcell.go
@ -7,9 +7,10 @@ import (
 	"time"

 	"github.com/gdamore/tcell/v2"
+	"github.com/gdamore/tcell/v2/encoding"
 	"github.com/junegunn/fzf/src/util"

-	"github.com/rivo/uniseg"
+	"github.com/junegunn/uniseg"
 )

 func HasFullscreenRenderer() bool {
@ -142,16 +143,15 @@ func (a Attr) Merge(b Attr) Attr {
 var (
 	_screen          tcell.Screen
 	_prevMouseButton tcell.ButtonMask
-	_initialResize   bool = true
 )

-func (r *FullscreenRenderer) initScreen() error {
+func (r *FullscreenRenderer) initScreen() {
 	s, e := tcell.NewScreen()
 	if e != nil {
-		return e
+		errorExit(e.Error())
 	}
 	if e = s.Init(); e != nil {
-		return e
+		errorExit(e.Error())
 	}
 	if r.mouse {
 		s.EnableMouse()
@ -159,21 +159,16 @@ func (r *FullscreenRenderer) initScreen() error {
 		s.DisableMouse()
 	}
 	_screen = s
-
-	return nil
 }

-func (r *FullscreenRenderer) Init() error {
+func (r *FullscreenRenderer) Init() {
 	if os.Getenv("TERM") == "cygwin" {
 		os.Setenv("TERM", "")
 	}
+	encoding.Register()

-	if err := r.initScreen(); err != nil {
-		return err
-	}
+	r.initScreen()
 	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
-
-	return nil
 }

 func (r *FullscreenRenderer) Top() int {
@ -207,10 +202,6 @@ func (r *FullscreenRenderer) NeedScrollbarRedraw() bool {
 	return true
 }

-func (r *FullscreenRenderer) ShouldEmitResizeEvent() bool {
-	return true
-}
-
 func (r *FullscreenRenderer) Refresh() {
 	// noop
 }
@ -225,12 +216,6 @@ 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:
@ -324,16 +309,16 @@ func (r *FullscreenRenderer) GetChar() Event {
 			switch ev.Rune() {
 			case 0:
 				if ctrl {
-					return Event{Backspace, 0, nil}
+					return Event{BSpace, 0, nil}
 				}
 			case rune(tcell.KeyCtrlH):
 				switch {
 				case ctrl:
 					return keyfn('h')
 				case alt:
-					return Event{AltBackspace, 0, nil}
+					return Event{AltBS, 0, nil}
 				case none, shift:
-					return Event{Backspace, 0, nil}
+					return Event{BSpace, 0, nil}
 				}
 			}
 		case tcell.KeyCtrlI:
@ -386,17 +371,17 @@ func (r *FullscreenRenderer) GetChar() Event {
 		// section 3: (Alt)+Backspace2
 		case tcell.KeyBackspace2:
 			if alt {
-				return Event{AltBackspace, 0, nil}
+				return Event{AltBS, 0, nil}
 			}
-			return Event{Backspace, 0, nil}
+			return Event{BSpace, 0, nil}

 		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
 		case tcell.KeyUp:
 			if altShift {
-				return Event{AltShiftUp, 0, nil}
+				return Event{AltSUp, 0, nil}
 			}
 			if shift {
-				return Event{ShiftUp, 0, nil}
+				return Event{SUp, 0, nil}
 			}
 			if alt {
 				return Event{AltUp, 0, nil}
@ -404,10 +389,10 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Up, 0, nil}
 		case tcell.KeyDown:
 			if altShift {
-				return Event{AltShiftDown, 0, nil}
+				return Event{AltSDown, 0, nil}
 			}
 			if shift {
-				return Event{ShiftDown, 0, nil}
+				return Event{SDown, 0, nil}
 			}
 			if alt {
 				return Event{AltDown, 0, nil}
@ -415,10 +400,10 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Down, 0, nil}
 		case tcell.KeyLeft:
 			if altShift {
-				return Event{AltShiftLeft, 0, nil}
+				return Event{AltSLeft, 0, nil}
 			}
 			if shift {
-				return Event{ShiftLeft, 0, nil}
+				return Event{SLeft, 0, nil}
 			}
 			if alt {
 				return Event{AltLeft, 0, nil}
@ -426,10 +411,10 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Left, 0, nil}
 		case tcell.KeyRight:
 			if altShift {
-				return Event{AltShiftRight, 0, nil}
+				return Event{AltSRight, 0, nil}
 			}
 			if shift {
-				return Event{ShiftRight, 0, nil}
+				return Event{SRight, 0, nil}
 			}
 			if alt {
 				return Event{AltRight, 0, nil}
@ -446,17 +431,17 @@ func (r *FullscreenRenderer) GetChar() Event {
 				return Event{CtrlDelete, 0, nil}
 			}
 			if shift {
-				return Event{ShiftDelete, 0, nil}
+				return Event{SDelete, 0, nil}
 			}
-			return Event{Delete, 0, nil}
+			return Event{Del, 0, nil}
 		case tcell.KeyEnd:
 			return Event{End, 0, nil}
 		case tcell.KeyPgUp:
-			return Event{PageUp, 0, nil}
+			return Event{PgUp, 0, nil}
 		case tcell.KeyPgDn:
-			return Event{PageDown, 0, nil}
+			return Event{PgDn, 0, nil}
 		case tcell.KeyBacktab:
-			return Event{ShiftTab, 0, nil}
+			return Event{BTab, 0, nil}
 		case tcell.KeyF1:
 			return Event{F1, 0, nil}
 		case tcell.KeyF2:
@ -502,7 +487,7 @@ func (r *FullscreenRenderer) GetChar() Event {

 		// section 7: Esc
 		case tcell.KeyEsc:
-			return Event{Esc, 0, nil}
+			return Event{ESC, 0, nil}
 		}
 	}

@ -548,7 +533,7 @@ func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int,
 		height:      height,
 		normal:      normal,
 		borderStyle: borderStyle}
-	w.Erase()
+	w.drawBorder(false)
 	return w
 }

@ -565,12 +550,8 @@ func fill(x, y, w, h int, n ColorPair, r rune) {
 }

 func (w *TcellWindow) Erase() {
-	if w.borderStyle.shape.HasLeft() {
-		fill(w.left-1, w.top, w.width, w.height-1, w.normal, ' ')
-	} else {
-		fill(w.left, w.top, w.width-1, w.height-1, w.normal, ' ')
-	}
 	w.drawBorder(false)
+	fill(w.left-1, w.top, w.width+1, w.height-1, w.normal, ' ')
 }

 func (w *TcellWindow) EraseMaybe() bool {
--- a/src/tui/tcell_test.go
+++ b/src/tui/tcell_test.go
@ -3,7 +3,6 @@
 package tui

 import (
-	"os"
 	"testing"

 	"github.com/gdamore/tcell/v2"
@ -21,7 +20,7 @@ func assert(t *testing.T, context string, got interface{}, want interface{}) boo

 // Test the handling of the tcell keyboard events.
 func TestGetCharEventKey(t *testing.T) {
-	if util.IsTty(os.Stdout) {
+	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
@ -103,22 +102,22 @@ func TestGetCharEventKey(t *testing.T) {
 		// 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.KeyBackspace2, 0, tcell.ModNone}, wantKey{BSpace, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyBackspace2, 0, tcell.ModAlt}, wantKey{AltBS, 0, nil}},   // fabricated
+		{giveKey{tcell.KeyDEL, 0, tcell.ModNone}, wantKey{BSpace, 0, nil}},        // fabricated, unhandled
+		{giveKey{tcell.KeyDelete, 0, tcell.ModNone}, wantKey{Del, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModAlt}, wantKey{Del, 0, nil}},
 		{giveKey{tcell.KeyBackspace, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                  // fabricated, unhandled
 		{giveKey{tcell.KeyBS, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                         // fabricated, unhandled
 		{giveKey{tcell.KeyCtrlH, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                      // fabricated, unhandled
-		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModNone}, wantKey{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.ModNone}, wantKey{BSpace, 0, nil}},                                    // actual "Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModAlt}, wantKey{AltBS, 0, nil}},                                      // actual "Alt+Backspace" keystroke
+		{giveKey{tcell.KeyDEL, rune(tcell.KeyDEL), tcell.ModCtrl}, wantKey{BSpace, 0, nil}},                                        // actual "Ctrl+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift}, wantKey{BSpace, 0, nil}},                                   // actual "Shift+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{BSpace, 0, nil}},                                        // actual "Ctrl+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{BSpace, 0, nil}},                                      // actual "Ctrl+Shift+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift | tcell.ModAlt}, wantKey{AltBS, 0, nil}},                     // actual "Shift+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{BSpace, 0, nil}},                       // actual "Ctrl+Shift+Alt+Backspace" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl}, wantKey{CtrlH, 0, nil}},                                     // actual "Ctrl+H" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAlt, 'h', nil}},                  // fabricated "Ctrl+Alt+H" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlH, 0, nil}},                    // actual "Ctrl+Shift+H" keystroke
@ -127,8 +126,8 @@ func TestGetCharEventKey(t *testing.T) {
 		// 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.KeyLeft, 0, tcell.ModShift}, wantKey{SLeft, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltSRight, 0, nil}},
 		{giveKey{tcell.KeyUpLeft, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},    // fabricated, unhandled
 		{giveKey{tcell.KeyUpRight, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},   // fabricated, unhandled
 		{giveKey{tcell.KeyDownLeft, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // fabricated, unhandled
@ -162,11 +161,11 @@ func TestGetCharEventKey(t *testing.T) {

 		// 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
+		{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
@ -183,7 +182,6 @@ func TestGetCharEventKey(t *testing.T) {
 	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)
@ -193,9 +191,8 @@ func TestGetCharEventKey(t *testing.T) {
 		// 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
+		for gotEvent.Type == Resize {
+			t.Logf("Resize swallowed")
 			gotEvent = r.GetChar()
 		}
 		t.Logf("wantEvent = %T{Type: %v, Char: %q (%[3]v)}\n", test.wantKey, test.wantKey.Type, test.wantKey.Char)
@ -260,7 +257,7 @@ Quick reference
 37					LeftClick
 38					RightClick
 39					BTab
-40					Backspace
+40					BSpace
 41					Del
 42					PgUp
 43					PgDn
@ -273,7 +270,7 @@ Quick reference
 50					Insert
 51					SUp
 52					SDown
-53					ShiftLeft
+53					SLeft
 54					SRight
 55					F1
 56					F2
@ -289,15 +286,15 @@ Quick reference
 66					F12
 67					Change
 68					BackwardEOF
-69					AltBackspace
+69					AltBS
 70					AltUp
 71					AltDown
 72					AltLeft
 73					AltRight
 74					AltSUp
 75					AltSDown
-76					AltShiftLeft
-77					AltShiftRight
+76					AltSLeft
+77					AltSRight
 78					Alt
 79					CtrlAlt
 ..
--- a/src/tui/ttyname_unix.go
+++ b/src/tui/ttyname_unix.go
@ -4,19 +4,12 @@ package tui

 import (
 	"os"
-	"sync/atomic"
 	"syscall"
 )

 var devPrefixes = [...]string{"/dev/pts/", "/dev/"}

-var tty atomic.Value
-
 func ttyname() string {
-	if cached := tty.Load(); cached != nil {
-		return cached.(string)
-	}
-
 	var stderr syscall.Stat_t
 	if syscall.Fstat(2, &stderr) != nil {
 		return ""
@ -34,21 +27,24 @@ func ttyname() string {
 				continue
 			}
 			if stat, ok := info.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
-				value := prefix + file.Name()
-				tty.Store(value)
-				return value
+				return prefix + file.Name()
 			}
 		}
 	}
 	return ""
 }

-// TtyIn returns terminal device to read user input
-func TtyIn() (*os.File, error) {
-	return openTtyIn()
-}
-
-// TtyIn returns terminal device to write to
-func TtyOut() (*os.File, error) {
-	return openTtyOut()
+// TtyIn returns terminal device to be used as STDIN, falls back to os.Stdin
+func TtyIn() *os.File {
+	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
+	if err != nil {
+		tty := ttyname()
+		if len(tty) > 0 {
+			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
+				return in
+			}
+		}
+		return os.Stdin
+	}
+	return in
 }
--- a/src/tui/ttyname_windows.go
+++ b/src/tui/ttyname_windows.go
@ -2,20 +2,13 @@

 package tui

-import (
-	"os"
-)
+import "os"

 func ttyname() string {
 	return ""
 }

 // TtyIn on Windows returns os.Stdin
-func TtyIn() (*os.File, error) {
-	return os.Stdin, nil
-}
-
-// TtyIn on Windows returns nil
-func TtyOut() (*os.File, error) {
-	return nil, nil
+func TtyIn() *os.File {
+	return os.Stdin
 }
--- a/src/tui/tui.go
+++ b/src/tui/tui.go
@ -1,16 +1,15 @@
 package tui

 import (
+	"fmt"
+	"os"
 	"strconv"
 	"time"

-	"github.com/junegunn/fzf/src/util"
-	"github.com/rivo/uniseg"
+	"github.com/junegunn/uniseg"
 )

 // Types of user action
-//
-//go:generate stringer -type=EventType
 type EventType int

 const (
@ -42,7 +41,7 @@ const (
 	CtrlX
 	CtrlY
 	CtrlZ
-	Esc
+	ESC
 	CtrlSpace
 	CtrlDelete

@ -52,12 +51,27 @@ const (
 	CtrlCaret
 	CtrlSlash

-	ShiftTab
-	Backspace
+	Invalid
+	Resize
+	Mouse
+	DoubleClick
+	LeftClick
+	RightClick
+	SLeftClick
+	SRightClick
+	ScrollUp
+	ScrollDown
+	SScrollUp
+	SScrollDown
+	PreviewScrollUp
+	PreviewScrollDown

-	Delete
-	PageUp
-	PageDown
+	BTab
+	BSpace
+
+	Del
+	PgUp
+	PgDn

 	Up
 	Down
@ -67,11 +81,11 @@ const (
 	End
 	Insert

-	ShiftUp
-	ShiftDown
-	ShiftLeft
-	ShiftRight
-	ShiftDelete
+	SUp
+	SDown
+	SLeft
+	SRight
+	SDelete

 	F1
 	F2
@ -86,50 +100,29 @@ const (
 	F11
 	F12

-	AltBackspace
+	Change
+	BackwardEOF
+	Start
+	Load
+	Focus
+	One
+	Zero
+	Result
+
+	AltBS

 	AltUp
 	AltDown
 	AltLeft
 	AltRight

-	AltShiftUp
-	AltShiftDown
-	AltShiftLeft
-	AltShiftRight
+	AltSUp
+	AltSDown
+	AltSLeft
+	AltSRight

 	Alt
 	CtrlAlt
-
-	Invalid
-	Fatal
-
-	Mouse
-	DoubleClick
-	LeftClick
-	RightClick
-	SLeftClick
-	SRightClick
-	ScrollUp
-	ScrollDown
-	SScrollUp
-	SScrollDown
-	PreviewScrollUp
-	PreviewScrollDown
-
-	// Events
-	Resize
-	Change
-	BackwardEOF
-	Start
-	Load
-	Focus
-	One
-	Zero
-	Result
-	Jump
-	JumpCancel
-	ClickHeader
 )

 func (t EventType) AsEvent() Event {
@ -149,31 +142,6 @@ 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}
 }
@ -303,9 +271,6 @@ type ColorTheme struct {
 	Disabled         ColorAttr
 	Fg               ColorAttr
 	Bg               ColorAttr
-	SelectedFg       ColorAttr
-	SelectedBg       ColorAttr
-	SelectedMatch    ColorAttr
 	PreviewFg        ColorAttr
 	PreviewBg        ColorAttr
 	DarkBg           ColorAttr
@ -317,7 +282,7 @@ type ColorTheme struct {
 	Spinner          ColorAttr
 	Info             ColorAttr
 	Cursor           ColorAttr
-	Marker           ColorAttr
+	Selected         ColorAttr
 	Header           ColorAttr
 	Separator        ColorAttr
 	Scrollbar        ColorAttr
@ -356,8 +321,7 @@ type MouseEvent struct {
 type BorderShape int

 const (
-	BorderUndefined BorderShape = iota
-	BorderNone
+	BorderNone BorderShape = iota
 	BorderRounded
 	BorderSharp
 	BorderBold
@ -372,14 +336,6 @@ const (
 	BorderRight
 )

-func (s BorderShape) HasLeft() bool {
-	switch s {
-	case BorderNone, BorderRight, BorderTop, BorderBottom, BorderHorizontal: // No Left
-		return false
-	}
-	return true
-}
-
 func (s BorderShape) HasRight() bool {
 	switch s {
 	case BorderNone, BorderLeft, BorderTop, BorderBottom, BorderHorizontal: // No right
@ -528,7 +484,7 @@ type TermSize struct {
 }

 type Renderer interface {
-	Init() error
+	Init()
 	Resize(maxHeightFunc func(int) int)
 	Pause(clear bool)
 	Resume(clear bool, sigcont bool)
@ -538,7 +494,6 @@ type Renderer interface {
 	Close()
 	PassThrough(string)
 	NeedScrollbarRedraw() bool
-	ShouldEmitResizeEvent() bool

 	GetChar() Event

@ -607,14 +562,12 @@ var (
 	ColMatch                ColorPair
 	ColCursor               ColorPair
 	ColCursorEmpty          ColorPair
-	ColMarker               ColorPair
 	ColSelected             ColorPair
-	ColSelectedMatch        ColorPair
 	ColCurrent              ColorPair
 	ColCurrentMatch         ColorPair
 	ColCurrentCursor        ColorPair
 	ColCurrentCursorEmpty   ColorPair
-	ColCurrentMarker        ColorPair
+	ColCurrentSelected      ColorPair
 	ColCurrentSelectedEmpty ColorPair
 	ColSpinner              ColorPair
 	ColInfo                 ColorPair
@ -636,9 +589,6 @@ func EmptyTheme() *ColorTheme {
 		Input:            ColorAttr{colUndefined, AttrUndefined},
 		Fg:               ColorAttr{colUndefined, AttrUndefined},
 		Bg:               ColorAttr{colUndefined, AttrUndefined},
-		SelectedFg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedBg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedMatch:    ColorAttr{colUndefined, AttrUndefined},
 		DarkBg:           ColorAttr{colUndefined, AttrUndefined},
 		Prompt:           ColorAttr{colUndefined, AttrUndefined},
 		Match:            ColorAttr{colUndefined, AttrUndefined},
@ -647,7 +597,7 @@ func EmptyTheme() *ColorTheme {
 		Spinner:          ColorAttr{colUndefined, AttrUndefined},
 		Info:             ColorAttr{colUndefined, AttrUndefined},
 		Cursor:           ColorAttr{colUndefined, AttrUndefined},
-		Marker:           ColorAttr{colUndefined, AttrUndefined},
+		Selected:         ColorAttr{colUndefined, AttrUndefined},
 		Header:           ColorAttr{colUndefined, AttrUndefined},
 		Border:           ColorAttr{colUndefined, AttrUndefined},
 		BorderLabel:      ColorAttr{colUndefined, AttrUndefined},
@ -669,9 +619,6 @@ func NoColorTheme() *ColorTheme {
 		Input:            ColorAttr{colDefault, AttrUndefined},
 		Fg:               ColorAttr{colDefault, AttrUndefined},
 		Bg:               ColorAttr{colDefault, AttrUndefined},
-		SelectedFg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedBg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedMatch:    ColorAttr{colDefault, AttrUndefined},
 		DarkBg:           ColorAttr{colDefault, AttrUndefined},
 		Prompt:           ColorAttr{colDefault, AttrUndefined},
 		Match:            ColorAttr{colDefault, Underline},
@ -680,7 +627,7 @@ func NoColorTheme() *ColorTheme {
 		Spinner:          ColorAttr{colDefault, AttrUndefined},
 		Info:             ColorAttr{colDefault, AttrUndefined},
 		Cursor:           ColorAttr{colDefault, AttrUndefined},
-		Marker:           ColorAttr{colDefault, AttrUndefined},
+		Selected:         ColorAttr{colDefault, AttrUndefined},
 		Header:           ColorAttr{colDefault, AttrUndefined},
 		Border:           ColorAttr{colDefault, AttrUndefined},
 		BorderLabel:      ColorAttr{colDefault, AttrUndefined},
@ -696,15 +643,17 @@ func NoColorTheme() *ColorTheme {
 	}
 }

+func errorExit(message string) {
+	fmt.Fprintln(os.Stderr, message)
+	os.Exit(2)
+}
+
 func init() {
 	Default16 = &ColorTheme{
 		Colored:          true,
 		Input:            ColorAttr{colDefault, AttrUndefined},
 		Fg:               ColorAttr{colDefault, AttrUndefined},
 		Bg:               ColorAttr{colDefault, AttrUndefined},
-		SelectedFg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedBg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedMatch:    ColorAttr{colUndefined, AttrUndefined},
 		DarkBg:           ColorAttr{colBlack, AttrUndefined},
 		Prompt:           ColorAttr{colBlue, AttrUndefined},
 		Match:            ColorAttr{colGreen, AttrUndefined},
@ -713,7 +662,7 @@ func init() {
 		Spinner:          ColorAttr{colGreen, AttrUndefined},
 		Info:             ColorAttr{colWhite, AttrUndefined},
 		Cursor:           ColorAttr{colRed, AttrUndefined},
-		Marker:           ColorAttr{colMagenta, AttrUndefined},
+		Selected:         ColorAttr{colMagenta, AttrUndefined},
 		Header:           ColorAttr{colCyan, AttrUndefined},
 		Border:           ColorAttr{colBlack, AttrUndefined},
 		BorderLabel:      ColorAttr{colWhite, AttrUndefined},
@ -732,9 +681,6 @@ func init() {
 		Input:            ColorAttr{colDefault, AttrUndefined},
 		Fg:               ColorAttr{colDefault, AttrUndefined},
 		Bg:               ColorAttr{colDefault, AttrUndefined},
-		SelectedFg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedBg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedMatch:    ColorAttr{colUndefined, AttrUndefined},
 		DarkBg:           ColorAttr{236, AttrUndefined},
 		Prompt:           ColorAttr{110, AttrUndefined},
 		Match:            ColorAttr{108, AttrUndefined},
@ -743,7 +689,7 @@ func init() {
 		Spinner:          ColorAttr{148, AttrUndefined},
 		Info:             ColorAttr{144, AttrUndefined},
 		Cursor:           ColorAttr{161, AttrUndefined},
-		Marker:           ColorAttr{168, AttrUndefined},
+		Selected:         ColorAttr{168, AttrUndefined},
 		Header:           ColorAttr{109, AttrUndefined},
 		Border:           ColorAttr{59, AttrUndefined},
 		BorderLabel:      ColorAttr{145, AttrUndefined},
@ -762,9 +708,6 @@ func init() {
 		Input:            ColorAttr{colDefault, AttrUndefined},
 		Fg:               ColorAttr{colDefault, AttrUndefined},
 		Bg:               ColorAttr{colDefault, AttrUndefined},
-		SelectedFg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedBg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedMatch:    ColorAttr{colUndefined, AttrUndefined},
 		DarkBg:           ColorAttr{251, AttrUndefined},
 		Prompt:           ColorAttr{25, AttrUndefined},
 		Match:            ColorAttr{66, AttrUndefined},
@ -773,7 +716,7 @@ func init() {
 		Spinner:          ColorAttr{65, AttrUndefined},
 		Info:             ColorAttr{101, AttrUndefined},
 		Cursor:           ColorAttr{161, AttrUndefined},
-		Marker:           ColorAttr{168, AttrUndefined},
+		Selected:         ColorAttr{168, AttrUndefined},
 		Header:           ColorAttr{31, AttrUndefined},
 		Border:           ColorAttr{145, AttrUndefined},
 		BorderLabel:      ColorAttr{59, AttrUndefined},
@ -815,15 +758,12 @@ func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
 	theme.Spinner = o(baseTheme.Spinner, theme.Spinner)
 	theme.Info = o(baseTheme.Info, theme.Info)
 	theme.Cursor = o(baseTheme.Cursor, theme.Cursor)
-	theme.Marker = o(baseTheme.Marker, theme.Marker)
+	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.SelectedFg = o(theme.Fg, theme.SelectedFg)
-	theme.SelectedBg = o(theme.Bg, theme.SelectedBg)
-	theme.SelectedMatch = o(theme.Match, theme.SelectedMatch)
 	theme.Disabled = o(theme.Input, theme.Disabled)
 	theme.Gutter = o(theme.DarkBg, theme.Gutter)
 	theme.PreviewFg = o(theme.Fg, theme.PreviewFg)
@ -849,23 +789,17 @@ func initPalette(theme *ColorTheme) {

 	ColPrompt = pair(theme.Prompt, theme.Bg)
 	ColNormal = pair(theme.Fg, theme.Bg)
-	ColSelected = pair(theme.SelectedFg, theme.SelectedBg)
 	ColInput = pair(theme.Input, theme.Bg)
 	ColDisabled = pair(theme.Disabled, theme.Bg)
 	ColMatch = pair(theme.Match, theme.Bg)
-	ColSelectedMatch = pair(theme.SelectedMatch, theme.SelectedBg)
 	ColCursor = pair(theme.Cursor, theme.Gutter)
 	ColCursorEmpty = pair(blank, theme.Gutter)
-	if theme.SelectedBg.Color != theme.Bg.Color {
-		ColMarker = pair(theme.Marker, theme.SelectedBg)
-	} else {
-		ColMarker = pair(theme.Marker, theme.Gutter)
-	}
+	ColSelected = pair(theme.Selected, theme.Gutter)
 	ColCurrent = pair(theme.Current, theme.DarkBg)
 	ColCurrentMatch = pair(theme.CurrentMatch, theme.DarkBg)
 	ColCurrentCursor = pair(theme.Cursor, theme.DarkBg)
 	ColCurrentCursorEmpty = pair(blank, theme.DarkBg)
-	ColCurrentMarker = pair(theme.Marker, theme.DarkBg)
+	ColCurrentSelected = pair(theme.Selected, theme.DarkBg)
 	ColCurrentSelectedEmpty = pair(blank, theme.DarkBg)
 	ColSpinner = pair(theme.Spinner, theme.Bg)
 	ColInfo = pair(theme.Info, theme.Bg)
--- a/src/util/atexit.go
+++ b/src/util/atexit.go
@ -1,28 +0,0 @@
-package util
-
-import (
-	"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]()
-	}
-	atExitFuncs = nil
-}
--- a/src/util/atexit_test.go
+++ b/src/util/atexit_test.go
@ -1,24 +0,0 @@
-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")
-	}
-}
--- a/src/util/chars.go
+++ b/src/util/chars.go
@ -1,7 +1,6 @@
 package util

 import (
-	"bytes"
 	"fmt"
 	"unicode"
 	"unicode/utf8"
@ -75,35 +74,6 @@ func (chars *Chars) Bytes() []byte {
 	return chars.slice
 }

-func (chars *Chars) NumLines(atMost int) (int, bool) {
-	lines := 1
-	if runes := chars.optionalRunes(); runes != nil {
-		for _, r := range runes {
-			if r == '\n' {
-				lines++
-			}
-			if lines > atMost {
-				return atMost, true
-			}
-		}
-		return lines, false
-	}
-
-	for idx := 0; idx < len(chars.slice); idx++ {
-		found := bytes.IndexByte(chars.slice[idx:], '\n')
-		if found < 0 {
-			break
-		}
-
-		idx += found
-		lines++
-		if lines > atMost {
-			return atMost, true
-		}
-	}
-	return lines, false
-}
-
 func (chars *Chars) optionalRunes() []rune {
 	if chars.inBytes {
 		return nil
@ -193,7 +163,7 @@ func (chars *Chars) ToString() string {
 	if runes := chars.optionalRunes(); runes != nil {
 		return string(runes)
 	}
-	return unsafe.String(unsafe.SliceData(chars.slice), len(chars.slice))
+	return string(chars.slice)
 }

 func (chars *Chars) ToRunes() []rune {
@ -208,12 +178,12 @@ func (chars *Chars) ToRunes() []rune {
 	return runes
 }

-func (chars *Chars) CopyRunes(dest []rune, from int) {
+func (chars *Chars) CopyRunes(dest []rune) {
 	if runes := chars.optionalRunes(); runes != nil {
-		copy(dest, runes[from:])
+		copy(dest, runes)
 		return
 	}
-	for idx, b := range chars.slice[from:][:len(dest)] {
+	for idx, b := range chars.slice[:len(dest)] {
 		dest[idx] = rune(b)
 	}
 }
--- a/src/util/util.go
+++ b/src/util/util.go
@ -3,12 +3,11 @@ package util
 import (
 	"math"
 	"os"
-	"strconv"
 	"strings"
 	"time"

+	"github.com/junegunn/uniseg"
 	"github.com/mattn/go-isatty"
-	"github.com/rivo/uniseg"
 )

 // StringWidth returns string width where each CR/LF character takes 1 column
@ -138,10 +137,14 @@ func DurWithin(
 	return val
 }

-// IsTty returns true if the file is a terminal
-func IsTty(file *os.File) bool {
-	fd := file.Fd()
-	return isatty.IsTerminal(fd) || isatty.IsCygwinTerminal(fd)
+// 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
@ -173,46 +176,3 @@ func RepeatToFill(str string, length int, limit int) string {
 	}
 	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)
-}
-
-// CompareVersions compares two version strings
-func CompareVersions(v1, v2 string) int {
-	parts1 := strings.Split(v1, ".")
-	parts2 := strings.Split(v2, ".")
-
-	atoi := func(s string) int {
-		n, e := strconv.Atoi(s)
-		if e != nil {
-			return 0
-		}
-		return n
-	}
-
-	for i := 0; i < Max(len(parts1), len(parts2)); i++ {
-		var p1, p2 int
-		if i < len(parts1) {
-			p1 = atoi(parts1[i])
-		}
-		if i < len(parts2) {
-			p2 = atoi(parts2[i])
-		}
-
-		if p1 > p2 {
-			return 1
-		} else if p1 < p2 {
-			return -1
-		}
-	}
-	return 0
-}
--- a/src/util/util_test.go
+++ b/src/util/util_test.go
@ -203,34 +203,3 @@ func TestStringWidth(t *testing.T) {
 		t.Errorf("Expected: %d, Actual: %d", 1, w)
 	}
 }
-
-func TestCompareVersions(t *testing.T) {
-	assert := func(a, b string, expected int) {
-		if result := CompareVersions(a, b); result != expected {
-			t.Errorf("Expected: %d, Actual: %d", expected, result)
-		}
-	}
-
-	assert("2", "1", 1)
-	assert("2", "2", 0)
-	assert("2", "10", -1)
-
-	assert("2.1", "2.2", -1)
-	assert("2.1", "2.1.1", -1)
-
-	assert("1.2.3", "1.2.2", 1)
-	assert("1.2.3", "1.2.3", 0)
-	assert("1.2.3", "1.2.3.0", 0)
-	assert("1.2.3", "1.2.4", -1)
-
-	// Different number of parts
-	assert("1.0.0", "1", 0)
-	assert("1.0.0", "1.0", 0)
-	assert("1.0.0", "1.0.0", 0)
-	assert("1.0", "1.0.0", 0)
-	assert("1", "1.0.0", 0)
-	assert("1.0.0", "1.0.0.1", -1)
-	assert("1.0.0.1.0", "1.0.0.1", 0)
-
-	assert("", "3.4.5", -1)
-}
--- a/src/util/util_unix.go
+++ b/src/util/util_unix.go
@ -3,71 +3,31 @@
 package util

 import (
-	"fmt"
 	"os"
 	"os/exec"
-	"strings"
 	"syscall"

 	"golang.org/x/sys/unix"
 )

-type Executor struct {
-	shell   string
-	args    []string
-	escaper *strings.Replacer
-}
-
-func NewExecutor(withShell string) *Executor {
+// ExecCommand executes the given command with $SHELL
+func ExecCommand(command string, setpgid bool) *exec.Cmd {
 	shell := os.Getenv("SHELL")
-	args := strings.Fields(withShell)
-	if len(args) > 0 {
-		shell = args[0]
-		args = args[1:]
-	} else {
-		if len(shell) == 0 {
-			shell = "sh"
-		}
-		args = []string{"-c"}
+	if len(shell) == 0 {
+		shell = "sh"
 	}
-
-	var escaper *strings.Replacer
-	tokens := strings.Split(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("'", "'\\''")
-	}
-	return &Executor{shell, args, escaper}
+	return ExecCommandWith(shell, command, setpgid)
 }

-// ExecCommand executes the given command with $SHELL
-func (x *Executor) ExecCommand(command string, setpgid bool) *exec.Cmd {
-	cmd := exec.Command(x.shell, append(x.args, command)...)
+// ExecCommandWith executes the given command with the specified shell
+func ExecCommandWith(shell string, command string, setpgid bool) *exec.Cmd {
+	cmd := exec.Command(shell, "-c", command)
 	if setpgid {
 		cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
 	}
 	return cmd
 }

-func (x *Executor) QuoteEntry(entry string) string {
-	return "'" + x.escaper.Replace(entry) + "'"
-}
-
-func (x *Executor) Become(stdin *os.File, environ []string, command string) {
-	shellPath, err := exec.LookPath(x.shell)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "fzf (become): %s\n", err.Error())
-		os.Exit(127)
-	}
-	args := append([]string{shellPath}, append(x.args, command)...)
-	SetStdin(stdin)
-	syscall.Exec(shellPath, args, environ)
-}
-
 // KillCommand kills the process for the given command
 func KillCommand(cmd *exec.Cmd) error {
 	return syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
--- a/src/util/util_windows.go
+++ b/src/util/util_windows.go
@ -6,162 +6,60 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"path/filepath"
-	"regexp"
 	"strings"
 	"sync/atomic"
 	"syscall"
 )

-type shellType int
-
-const (
-	shellTypeUnknown shellType = iota
-	shellTypeCmd
-	shellTypePowerShell
-)
-
-var escapeRegex = regexp.MustCompile(`[&|<>()^%!"]`)
-
-type Executor struct {
-	shell     string
-	shellType shellType
-	args      []string
-	shellPath atomic.Value
-}
-
-func NewExecutor(withShell string) *Executor {
-	shell := os.Getenv("SHELL")
-	args := strings.Fields(withShell)
-	if len(args) > 0 {
-		shell = args[0]
-	} else if len(shell) == 0 {
-		shell = "cmd"
-	}
-
-	shellType := shellTypeUnknown
-	basename := filepath.Base(shell)
-	if len(args) > 0 {
-		args = args[1:]
-	} else if strings.HasPrefix(basename, "cmd") {
-		shellType = shellTypeCmd
-		args = []string{"/s/c"}
-	} else if strings.HasPrefix(basename, "pwsh") || strings.HasPrefix(basename, "powershell") {
-		shellType = shellTypePowerShell
-		args = []string{"-NoProfile", "-Command"}
-	} else {
-		args = []string{"-c"}
-	}
-	return &Executor{shell: shell, shellType: shellType, args: args}
-}
+var shellPath atomic.Value

 // ExecCommand executes the given command with $SHELL
-// FIXME: setpgid is unused. We set it in the Unix implementation so that we
-// can kill preview process with its child processes at once.
-// NOTE: For "powershell", we should ideally set output encoding to UTF8,
-// but it is left as is now because no adverse effect has been observed.
-func (x *Executor) ExecCommand(command string, setpgid bool) *exec.Cmd {
-	shell := x.shell
-	if cached := x.shellPath.Load(); cached != nil {
+func ExecCommand(command string, setpgid bool) *exec.Cmd {
+	var shell string
+	if cached := shellPath.Load(); cached != nil {
 		shell = cached.(string)
 	} else {
-		if strings.Contains(shell, "/") {
+		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")
 			}
 		}
-		x.shellPath.Store(shell)
+		shellPath.Store(shell)
 	}
+	return ExecCommandWith(shell, command, setpgid)
+}
+
+// ExecCommandWith executes the given command with the specified shell
+// FIXME: setpgid is unused. We set it in the Unix implementation so that we
+// can kill preview process with its child processes at once.
+// NOTE: For "powershell", we should ideally set output encoding to UTF8,
+// but it is left as is now because no adverse effect has been observed.
+func ExecCommandWith(shell string, command string, setpgid bool) *exec.Cmd {
 	var cmd *exec.Cmd
-	if x.shellType == shellTypeCmd {
+	if strings.Contains(shell, "cmd") {
 		cmd = exec.Command(shell)
 		cmd.SysProcAttr = &syscall.SysProcAttr{
 			HideWindow:    false,
-			CmdLine:       fmt.Sprintf(`%s "%s"`, strings.Join(x.args, " "), command),
-			CreationFlags: 0,
-		}
-	} else {
-		cmd = exec.Command(shell, append(x.args, command)...)
-		cmd.SysProcAttr = &syscall.SysProcAttr{
-			HideWindow:    false,
+			CmdLine:       fmt.Sprintf(` /v:on/s/c "%s"`, command),
 			CreationFlags: 0,
 		}
+		return cmd
 	}
-	return cmd
-}
-
-func (x *Executor) Become(stdin *os.File, environ []string, command string) {
-	cmd := x.ExecCommand(command, false)
-	cmd.Stdin = stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Env = environ
-	err := cmd.Start()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "fzf (become): %s\n", err.Error())
-		os.Exit(127)
-	}
-	err = cmd.Wait()
-	if err != nil {
-		if exitError, ok := err.(*exec.ExitError); ok {
-			os.Exit(exitError.ExitCode())
-		}
-	}
-	os.Exit(0)
-}

-func escapeArg(s string) string {
-	b := make([]byte, 0, len(s)+2)
-	b = append(b, '"')
-	slashes := 0
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		switch c {
-		default:
-			slashes = 0
-		case '\\':
-			slashes++
-		case '"':
-			for ; slashes > 0; slashes-- {
-				b = append(b, '\\')
-			}
-			b = append(b, '\\')
-		}
-		b = append(b, c)
+	if strings.Contains(shell, "pwsh") || strings.Contains(shell, "powershell") {
+		cmd = exec.Command(shell, "-NoProfile", "-Command", command)
+	} else {
+		cmd = exec.Command(shell, "-c", command)
 	}
-	for ; slashes > 0; slashes-- {
-		b = append(b, '\\')
-	}
-	b = append(b, '"')
-	return escapeRegex.ReplaceAllStringFunc(string(b), func(match string) string {
-		return "^" + match
-	})
-}
-
-func (x *Executor) QuoteEntry(entry string) string {
-	switch x.shellType {
-	case shellTypeCmd:
-		/* Manually tested with the following commands:
-		   fzf --preview "echo {}"
-		   fzf --preview "type {}"
-		   echo .git\refs\| fzf --preview "dir {}"
-		   echo .git\refs\\| fzf --preview "dir {}"
-		   echo .git\refs\\\| fzf --preview "dir {}"
-		   reg query HKCU | fzf --reverse --bind "enter:reload(reg query {})"
-		   fzf --disabled --preview "echo {q} {n} {}" --query "&|<>()@^%!"
-		   fd -H --no-ignore -td -d 4 | fzf --preview "dir {}"
-		   fd -H --no-ignore -td -d 4 | fzf --preview "eza {}" --preview-window up
-		   fd -H --no-ignore -td -d 4 | fzf --preview "eza --color=always --tree --level=3 --icons=always {}"
-		   fd -H --no-ignore -td -d 4 | fzf --preview ".\eza.exe --color=always --tree --level=3 --icons=always {}" --with-shell "powershell -NoProfile -Command"
-		*/
-		return escapeArg(entry)
-	case shellTypePowerShell:
-		escaped := strings.ReplaceAll(entry, `"`, `\"`)
-		return "'" + strings.ReplaceAll(escaped, "'", "''") + "'"
-	default:
-		return "'" + strings.ReplaceAll(entry, "'", "'\\''") + "'"
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow:    false,
+		CreationFlags: 0,
 	}
+	return cmd
 }

 // KillCommand kills the process for the given command
--- a/src/winpty.go
+++ b/src/winpty.go
@ -1,13 +0,0 @@
-//go:build !windows
-
-package fzf
-
-import "errors"
-
-func needWinpty(_ *Options) bool {
-	return false
-}
-
-func runWinpty(_ []string, _ *Options) (int, error) {
-	return ExitError, errors.New("Not supported")
-}
--- a/src/winpty_windows.go
+++ b/src/winpty_windows.go
@ -1,75 +0,0 @@
-//go:build windows
-
-package fzf
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/junegunn/fzf/src/util"
-)
-
-func isMintty345() bool {
-	return util.CompareVersions(os.Getenv("TERM_PROGRAM_VERSION"), "3.4.5") >= 0
-}
-
-func needWinpty(opts *Options) bool {
-	if os.Getenv("TERM_PROGRAM") != "mintty" {
-		return false
-	}
-	if isMintty345() {
-		/*
-		 See: https://github.com/junegunn/fzf/issues/3809
-
-		 "MSYS=enable_pcon" allows fzf to run properly on mintty 3.4.5 or later.
-		*/
-		if strings.Contains(os.Getenv("MSYS"), "enable_pcon") {
-			return false
-		}
-
-		// Setting the environment variable here unfortunately doesn't help,
-		// so we need to start a child process with "MSYS=enable_pcon"
-		//   os.Setenv("MSYS", "enable_pcon")
-		return true
-	}
-	if opts.NoWinpty {
-		return false
-	}
-	if _, err := exec.LookPath("winpty"); err != nil {
-		return false
-	}
-	return true
-}
-
-func runWinpty(args []string, opts *Options) (int, error) {
-	sh, err := sh()
-	if err != nil {
-		return ExitError, err
-	}
-
-	argStr := escapeSingleQuote(args[0])
-	for _, arg := range args[1:] {
-		argStr += " " + escapeSingleQuote(arg)
-	}
-	argStr += ` --no-winpty`
-
-	if isMintty345() {
-		return runProxy(argStr, func(temp string) *exec.Cmd {
-			cmd := exec.Command(sh, temp)
-			cmd.Env = append(os.Environ(), "MSYS=enable_pcon")
-			cmd.Stdin = os.Stdin
-			cmd.Stdout = os.Stdout
-			cmd.Stderr = os.Stderr
-			return cmd
-		}, opts, false)
-	}
-
-	return runProxy(argStr, func(temp string) *exec.Cmd {
-		cmd := exec.Command(sh, "-c", fmt.Sprintf(`winpty < /dev/tty > /dev/tty -- sh %q`, temp))
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		return cmd
-	}, opts, false)
-}
--- a/test/test_go.rb
+++ b/test/test_go.rb
--- a/1
+++ b/1
@ -94,7 +94,6 @@ 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