0.31.0

2025-07-30 11:41:58 -07:00 · 2022-07-21 22:46:34 +09:00
118 changed files with 7324 additions and 21978 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1 +1 @@
-github: junegunn
+custom: ["https://paypal.me/junegunn", "https://www.buymeacoffee.com/junegunn"]
--- 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,18 +27,18 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@629c2de402a417ea7690ca6ce3f33229e27606a5 # v2
      with:
        fetch-depth: 0

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@1ed1437484560351c5be56cf73a48a279d116b78
      with:
        languages: ${{ matrix.language }}

    - name: Autobuild
-      uses: github/codeql-action/autobuild@v3
+      uses: github/codeql-action/autobuild@1ed1437484560351c5be56cf73a48a279d116b78

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@1ed1437484560351c5be56cf73a48a279d116b78
--- a/.github/workflows/depsreview.yaml
+++ b/.github/workflows/depsreview.yaml
@@ -1,14 +0,0 @@
-name: 'Dependency Review'
-on: [pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  dependency-review:
-    runs-on: ubuntu-latest
-    steps:
-      - name: 'Checkout Repository'
-        uses: actions/checkout@v4
-      - name: 'Dependency Review'
-        uses: actions/dependency-review-action@v4
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -11,38 +11,35 @@ on:
 permissions:
  contents: read

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

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

    - name: Setup Ruby
-      uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@ebaea52cb20fea395b0904125276395e37183dac
      with:
-        ruby-version: 3.4.1
+        ruby-version: 3.0.0

    - name: Install packages
      run: sudo apt-get install --yes zsh fish tmux

    - name: Install Ruby gems
-      run: bundle install
+      run: sudo gem install --no-document minitest:5.14.2 rubocop:1.0.0 rubocop-minitest:0.10.1 rubocop-performance:1.8.1

    - name: Rubocop
-      run: make lint
+      run: rubocop --require rubocop-minitest --require rubocop-performance

    - name: Unit test
      run: make test

    - name: Integration test
-      run: make install && ./install --all && tmux new-session -d && ruby test/runner.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,17 +15,17 @@ jobs:
  build:
    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@629c2de402a417ea7690ca6ce3f33229e27606a5 # v2
      with:
        fetch-depth: 0

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

    - name: Setup Ruby
-      uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@ebaea52cb20fea395b0904125276395e37183dac
      with:
        ruby-version: 3.0.0

--- a/.github/workflows/sponsors.yml
+++ b/.github/workflows/sponsors.yml
@@ -1,24 +0,0 @@
---
-name: Generate Sponsors README
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: 0 0 * * 0
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout 🛎️
-        uses: actions/checkout@v4
-
-      - name: Generate Sponsors 💖
-        uses: JamesIves/github-sponsors-readme-action@v1
-        with:
-          token: ${{ secrets.SPONSORS_TOKEN }}
-          file: 'README.md'
-
-      - name: Deploy to GitHub Pages 🚀
-        uses: JamesIves/github-pages-deploy-action@v4
-        with:
-          branch: master
-          folder: '.'
--- a/.github/workflows/typos.yml
+++ b/.github/workflows/typos.yml
@@ -1,10 +0,0 @@
-name: "Spell Check"
-on: [pull_request]
-
-jobs:
-  typos:
-    name: Spell Check with Typos
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: crate-ci/typos@v1.29.4
--- a/.github/workflows/winget.yml
+++ b/.github/workflows/winget.yml
@@ -1,14 +0,0 @@
-name: Publish to Winget
-on:
-  release:
-    types: [released]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: vedantmgoyal2009/winget-releaser@v2
-        with:
-          identifier: junegunn.fzf
-          installers-regex: '-windows_(armv7|arm64|amd64)\.zip$'
-          token: ${{ secrets.WINGET_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,7 @@ bin/fzf.exe
 dist
 target
 pkg
+Gemfile.lock
 .DS_Store
 doc/tags
 vendor
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -1,5 +1,4 @@
 ---
-version: 2
 project_name: fzf

 before:
@@ -7,9 +6,64 @@ before:
    - go mod download

 builds:
-  - id: fzf
+  - id: fzf-macos
+    binary: fzf
    goos:
      - darwin
+    goarch:
+      - amd64
+    ldflags:
+      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
+    hooks:
+      post: |
+        sh -c '
+        cat > /tmp/fzf-gon-amd64.hcl << EOF
+        source = ["./dist/fzf-macos_darwin_amd64/fzf"]
+        bundle_id = "kr.junegunn.fzf"
+        apple_id {
+          username = "junegunn.c@gmail.com"
+          password = "@env:AC_PASSWORD"
+        }
+        sign {
+          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
+        }
+        zip {
+          output_path = "./dist/fzf-{{ .Version }}-darwin_amd64.zip"
+        }
+        EOF
+        gon /tmp/fzf-gon-amd64.hcl
+        '
+
+  - id: fzf-macos-arm
+    binary: fzf
+    goos:
+      - darwin
+    goarch:
+      - arm64
+    ldflags:
+      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
+    hooks:
+      post: |
+        sh -c '
+        cat > /tmp/fzf-gon-arm64.hcl << EOF
+        source = ["./dist/fzf-macos-arm_darwin_arm64/fzf"]
+        bundle_id = "kr.junegunn.fzf"
+        apple_id {
+          username = "junegunn.c@gmail.com"
+          password = "@env:AC_PASSWORD"
+        }
+        sign {
+          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
+        }
+        zip {
+          output_path = "./dist/fzf-{{ .Version }}-darwin_arm64.zip"
+        }
+        EOF
+        gon /tmp/fzf-gon-arm64.hcl
+        '
+
+  - id: fzf
+    goos:
      - linux
      - windows
      - freebsd
@@ -18,15 +72,10 @@ builds:
      - amd64
      - arm
      - arm64
-      - loong64
-      - ppc64le
-      - s390x
    goarm:
      - 5
      - 6
      - 7
-    flags:
-      - -trimpath
    ldflags:
      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
    ignore:
@@ -39,42 +88,6 @@ builds:
      - goos: openbsd
        goarch: arm64

-# .goreleaser.yaml
-notarize:
-  macos:
-    - # Whether this configuration is enabled or not.
-      #
-      # Default: false.
-      # Templates: allowed.
-      enabled: "{{ not .IsSnapshot }}"
-
-      # Before notarizing, we need to sign the binary.
-      # This blocks defines the configuration for doing so.
-      sign:
-        # The .p12 certificate file path or its base64'd contents.
-        certificate: "{{.Env.MACOS_SIGN_P12}}"
-
-        # The password to be used to open the certificate.
-        password: "{{.Env.MACOS_SIGN_PASSWORD}}"
-
-      # Then, we notarize the binaries.
-      notarize:
-        # The issuer ID.
-        # Its the UUID you see when creating the App Store Connect key.
-        issuer_id: "{{.Env.MACOS_NOTARY_ISSUER_ID}}"
-
-        # Key ID.
-        # You can see it in the list of App Store Connect Keys.
-        # It will also be in the ApiKey filename.
-        key_id: "{{.Env.MACOS_NOTARY_KEY_ID}}"
-
-        # The .p8 key file path or its base64'd contents.
-        key: "{{.Env.MACOS_NOTARY_KEY}}"
-
-        # Whether to wait for the notarization to finish.
-        # Not recommended, as it could take a really long time.
-        wait: true
-
 archives:
  - name_template: "{{ .ProjectName }}-{{ .Version }}-{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
    builds:
@@ -91,10 +104,12 @@ release:
    owner: junegunn
    name: fzf
  prerelease: auto
-  name_template: '{{ .Version }}'
+  name_template: '{{ .Tag }}'
+  extra_files:
+    - glob: ./dist/fzf-*darwin*.zip

 snapshot:
-  name_template: "{{ .Version }}-devel"
+  name_template: "{{ .Tag }}-devel"

 changelog:
  sort: asc
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,16 +1,12 @@
-AllCops:
-  NewCops: enable
 Layout/LineLength:
  Enabled: false
 Metrics:
  Enabled: false
 Lint/ShadowingOuterLocalVariable:
  Enabled: false
-Lint/NestedMethodDefinition:
-  Enabled: false
 Style/MethodCallWithArgsParentheses:
  Enabled: true
-  AllowedMethods:
+  IgnoredMethods:
    - assert
    - exit
    - paste
@@ -19,7 +15,7 @@ Style/MethodCallWithArgsParentheses:
    - refute
    - require
    - send_keys
-  AllowedPatterns:
+  IgnoredPatterns:
    - ^assert_
    - ^refute_
 Style/NumericPredicate:
@@ -30,13 +26,3 @@ Style/OptionalBooleanParameter:
  Enabled: false
 Style/WordArray:
  MinSize: 1
-Minitest/AssertEqual:
-  Enabled: false
-Minitest/EmptyLineBeforeAssertionMethods:
-  Enabled: false
-Naming/VariableNumber:
-  Enabled: false
-Lint/EmptyBlock:
-  Enabled: false
-Style/SafeNavigationChainLength:
-  Enabled: false
--- a/.tool-versions
+++ b/.tool-versions
@@ -1,2 +1 @@
-golang 1.20.13
-ruby 3.4.1
+golang 1.18
--- a/ADVANCED.md
+++ b/ADVANCED.md
@@ -1,36 +1,30 @@
 Advanced fzf examples
 ======================

-* *Last update: 2025/02/02*
-* *Requires fzf 0.59.0 or later*
-
---
+*(Last update: 2021/05/22)*

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

 * [Introduction](#introduction)
-* [Display modes](#display-modes)
-    * [`--height`](#--height)
-    * [`--tmux`](#--tmux)
+* [Screen Layout](#screen-layout)
+  * [`--height`](#--height)
+  * [`fzf-tmux`](#fzf-tmux)
+    * [Popup window support](#popup-window-support)
 * [Dynamic reloading of the list](#dynamic-reloading-of-the-list)
-    * [Updating the list of processes by pressing CTRL-R](#updating-the-list-of-processes-by-pressing-ctrl-r)
-    * [Toggling between data sources](#toggling-between-data-sources)
-    * [Toggling with a single key binding](#toggling-with-a-single-key-binding)
+  * [Updating the list of processes by pressing CTRL-R](#updating-the-list-of-processes-by-pressing-ctrl-r)
+  * [Toggling between data sources](#toggling-between-data-sources)
 * [Ripgrep integration](#ripgrep-integration)
-    * [Using fzf as the secondary filter](#using-fzf-as-the-secondary-filter)
-    * [Using fzf as interactive Ripgrep launcher](#using-fzf-as-interactive-ripgrep-launcher)
-    * [Switching to fzf-only search mode](#switching-to-fzf-only-search-mode)
-    * [Switching between Ripgrep mode and fzf mode](#switching-between-ripgrep-mode-and-fzf-mode)
-    * [Switching between Ripgrep mode and fzf mode using a single key binding](#switching-between-ripgrep-mode-and-fzf-mode-using-a-single-key-binding)
-    * [Controlling Ripgrep search and fzf search simultaneously](#controlling-ripgrep-search-and-fzf-search-simultaneously)
+  * [Using fzf as the secondary filter](#using-fzf-as-the-secondary-filter)
+  * [Using fzf as interative Ripgrep launcher](#using-fzf-as-interative-ripgrep-launcher)
+  * [Switching to fzf-only search mode](#switching-to-fzf-only-search-mode)
+  * [Switching between Ripgrep mode and fzf mode](#switching-between-ripgrep-mode-and-fzf-mode)
 * [Log tailing](#log-tailing)
 * [Key bindings for git objects](#key-bindings-for-git-objects)
-    * [Files listed in `git status`](#files-listed-in-git-status)
-    * [Branches](#branches)
-    * [Commit hashes](#commit-hashes)
+  * [Files listed in `git status`](#files-listed-in-git-status)
+  * [Branches](#branches)
+  * [Commit hashes](#commit-hashes)
 * [Color themes](#color-themes)
-    * [fzf Theme Playground](#fzf-theme-playground)
-    * [Generating fzf color theme from Vim color schemes](#generating-fzf-color-theme-from-vim-color-schemes)
+  * [Generating fzf color theme from Vim color schemes](#generating-fzf-color-theme-from-vim-color-schemes)

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

@@ -63,7 +57,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`
@@ -93,7 +87,7 @@ fzf --height=40% --layout=reverse --info=inline --border --margin=1 --padding=1

 ![image](https://user-images.githubusercontent.com/700826/113379932-dfeac200-93b5-11eb-9e28-df1a2ee71f90.png)

-*(See man page to see the full list of options)*
+*(See `Layout` section of the man page to see the full list of options)*

 But you definitely don't want to repeat `--height=40% --layout=reverse
 --info=inline --border --margin=1 --padding=1` every time you use fzf. You
@@ -104,55 +98,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%
+# On the right (50%)
+fzf-tmux -r
+
+# On the left (30%)
+fzf-tmux -l30%
+
+# Above the cursor
+fzf-tmux -u30%
 ```

-You can also specify the position, width, and height of the popup window in
-the following format:
+![image](https://user-images.githubusercontent.com/700826/113379983-fa24a000-93b5-11eb-93eb-8a3d39b2f163.png)

-* `[center|top|bottom|left|right][,SIZE[%]][,SIZE[%][,border-native]]`
+![image](https://user-images.githubusercontent.com/700826/113380001-0577cb80-93b6-11eb-95d0-2ba453866882.png)
+
+![image](https://user-images.githubusercontent.com/700826/113380040-1d4f4f80-93b6-11eb-9bef-737fb120aafe.png)
+
+#### Popup window support
+
+But here's the really cool part; tmux 3.2 added support for popup windows. So
+you can open fzf in a popup window, which is quite useful if you frequently
+use split panes.

 ```sh
-# 100% width and 60% height
-fzf --tmux 100%,60% --border horizontal
+# 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/f80d3514-d69f-42f2-a8de-a392a562bfcf)
+![image](https://user-images.githubusercontent.com/700826/113380106-4a9bfd80-93b6-11eb-8cee-aeb1c4ce1a1f.png)

-```sh
-# On the right (50% width)
-fzf --tmux right
-```
-
-![image](https://github.com/junegunn/fzf/assets/700826/4033ade4-7efa-421b-a3fb-a430d197098a)
-
-```sh
-# On the left (40% width and 70% height)
-fzf --tmux left,40%,70%
-```
-
-![image](https://github.com/junegunn/fzf/assets/700826/efe43881-2bf0-49ea-ab2e-1377f778cd52)
-
-> [!TIP]
 > You might also want to check out my tmux plugins which support this popup
 > window layout.
 >
@@ -210,30 +205,6 @@ find * | fzf --prompt 'All> ' \

 ![image](https://user-images.githubusercontent.com/700826/113465072-46321c00-946c-11eb-9b6f-cda3951df579.png)

-### Toggling with a single key binding
-
-The above example uses two different key bindings to toggle between two modes,
-but can we just use a single key binding?
-
-To make a key binding behave differently each time it is pressed, we need:
-
-1. a way to store the current state. i.e. "which mode are we in?"
-2. and a way to dynamically perform different actions depending on the state.
-
-The following example shows how to 1. store the current mode in the prompt
-string, 2. and use this information (`$FZF_PROMPT`) to determine which
-actions to perform using the `transform` action.
-
-```sh
-fd --type file |
-  fzf --prompt 'Files> ' \
-      --header 'CTRL-T: Switch between Files/Directories' \
-      --bind 'ctrl-t:transform:[[ ! $FZF_PROMPT =~ Files ]] &&
-              echo "change-prompt(Files> )+reload(fd --type file)" ||
-              echo "change-prompt(Directories> )+reload(fd --type directory)"' \
-      --preview '[[ $FZF_PROMPT =~ Files ]] && bat --color=always {} || tree -C {}'
-```
-
 Ripgrep integration
 -------------------

@@ -265,13 +236,15 @@ file called `rfv`.
 # 1. Search for text in files using Ripgrep
 # 2. Interactively narrow down the list using fzf
 # 3. Open the file in Vim
-rg --color=always --line-number --no-heading --smart-case "${*:-}" |
-  fzf --ansi \
-      --color "hl:-1:underline,hl+:-1:underline:reverse" \
-      --delimiter : \
-      --preview 'bat --color=always {1} --highlight-line {2}' \
-      --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
-      --bind 'enter:become(vim {1} +{2})'
+IFS=: read -ra selected < <(
+  rg --color=always --line-number --no-heading --smart-case "${*:-}" |
+    fzf --ansi \
+        --color "hl:-1:underline,hl+:-1:underline:reverse" \
+        --delimiter : \
+        --preview 'bat --color=always {1} --highlight-line {2}' \
+        --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
+)
+[ -n "${selected[0]}" ] && vim "${selected[0]}" "+${selected[1]}"
 ```

 And run it with an initial query string.
@@ -334,14 +307,10 @@ I know it's a lot to digest, let's try to break down the code.
      position in the window
    - `~3` makes the top three lines fixed header so that they are always
      visible regardless of the scroll offset
- Instead of using shell script to process the final output of fzf, we use
-  `become(...)` action which was added in [fzf 0.38.0][0.38.0] to turn fzf
-  into a new process that opens the file with `vim` (`vim {1}`) and move the
-  cursor to the line (`+{2}`).
+- Once we selected a line, we open the file with `vim` (`vim
+  "${selected[0]}"`) and move the cursor to the line (`+${selected[1]}`).

-[0.38.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0380
-
-### Using fzf as interactive Ripgrep launcher
+### Using fzf as interative Ripgrep launcher

 We have learned that we can bind `reload` action to a key (e.g.
 `--bind=ctrl-r:execute(ps -ef)`). In the next example, we are going to **bind
@@ -362,20 +331,25 @@ projects, and it will free up memory as you narrow down the results.
 # 3. Open the file in Vim
 RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
 INITIAL_QUERY="${*:-}"
-fzf --ansi --disabled --query "$INITIAL_QUERY" \
-    --bind "start:reload:$RG_PREFIX {q}" \
-    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
-    --delimiter : \
-    --preview 'bat --color=always {1} --highlight-line {2}' \
-    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
-    --bind 'enter:become(vim {1} +{2})'
+IFS=: read -ra selected < <(
+  FZF_DEFAULT_COMMAND="$RG_PREFIX $(printf %q "$INITIAL_QUERY")" \
+  fzf --ansi \
+      --disabled --query "$INITIAL_QUERY" \
+      --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
+      --delimiter : \
+      --preview 'bat --color=always {1} --highlight-line {2}' \
+      --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
+)
+[ -n "${selected[0]}" ] && vim "${selected[0]}" "+${selected[1]}"
 ```

 ![image](https://user-images.githubusercontent.com/700826/113684212-f9ff0a00-96ff-11eb-8737-7bb571d320cc.png)

- Instead of starting fzf in the usual `rg ... | fzf` form, we make it start
-  the initial Ripgrep process immediately via `start:reload` binding for the
-  consistency of the code.
+- Instead of starting fzf in `rg ... | fzf` form, we start fzf without an
+  explicit input, but with a custom `FZF_DEFAULT_COMMAND` variable. This way
+  fzf can kill the initial Ripgrep process it starts with the initial query.
+  Otherwise, the initial Ripgrep process will keep consuming system resources
+  even after `reload` is triggered.
 - Filtering is no longer a responsibility of fzf; hence `--disabled`
 - `{q}` in the reload command evaluates to the query string on fzf prompt.
 - `sleep 0.1` in the reload command is for "debouncing". This small delay will
@@ -384,6 +358,8 @@ fzf --ansi --disabled --query "$INITIAL_QUERY" \

 ### Switching to fzf-only search mode

+*(Requires fzf 0.27.1 or above)*
+
 In the previous example, we lost fuzzy matching capability as we completely
 delegated search functionality to Ripgrep. But we can dynamically switch to
 fzf-only search mode by *"unbinding"* `reload` action from `change` event.
@@ -399,16 +375,19 @@ fzf-only search mode by *"unbinding"* `reload` action from `change` event.
 # 3. Open the file in Vim
 RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
 INITIAL_QUERY="${*:-}"
-fzf --ansi --disabled --query "$INITIAL_QUERY" \
-    --bind "start:reload:$RG_PREFIX {q}" \
-    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
-    --bind "alt-enter:unbind(change,alt-enter)+change-prompt(2. fzf> )+enable-search+clear-query" \
-    --color "hl:-1:underline,hl+:-1:underline:reverse" \
-    --prompt '1. ripgrep> ' \
-    --delimiter : \
-    --preview 'bat --color=always {1} --highlight-line {2}' \
-    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
-    --bind 'enter:become(vim {1} +{2})'
+IFS=: read -ra selected < <(
+  FZF_DEFAULT_COMMAND="$RG_PREFIX $(printf %q "$INITIAL_QUERY")" \
+  fzf --ansi \
+      --color "hl:-1:underline,hl+:-1:underline:reverse" \
+      --disabled --query "$INITIAL_QUERY" \
+      --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
+      --bind "alt-enter:unbind(change,alt-enter)+change-prompt(2. fzf> )+enable-search+clear-query" \
+      --prompt '1. ripgrep> ' \
+      --delimiter : \
+      --preview 'bat --color=always {1} --highlight-line {2}' \
+      --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
+)
+[ -n "${selected[0]}" ] && vim "${selected[0]}" "+${selected[1]}"
 ```

 * Phase 1. Filtering with Ripgrep
@@ -429,8 +408,10 @@ fzf --ansi --disabled --query "$INITIAL_QUERY" \

 ### Switching between Ripgrep mode and fzf mode

-[fzf 0.30.0][0.30.0] added `rebind` action so we can "rebind" the bindings
-that were previously "unbound" via `unbind`.
+*(Requires fzf 0.30.0 or above)*
+
+fzf 0.30.0 added `rebind` action so we can "rebind" the bindings that were
+previously "unbound" via `unbind`.

 This is an improved version of the previous example that allows us to switch
 between Ripgrep launcher mode and fzf-only filtering mode via CTRL-R and
@@ -440,103 +421,23 @@ CTRL-F.
 #!/usr/bin/env bash

 # Switch between Ripgrep launcher mode (CTRL-R) and fzf filtering mode (CTRL-F)
-rm -f /tmp/rg-fzf-{r,f}
 RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
 INITIAL_QUERY="${*:-}"
-fzf --ansi --disabled --query "$INITIAL_QUERY" \
-    --bind "start:reload($RG_PREFIX {q})+unbind(ctrl-r)" \
-    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
-    --bind "ctrl-f:unbind(change,ctrl-f)+change-prompt(2. fzf> )+enable-search+rebind(ctrl-r)+transform-query(echo {q} > /tmp/rg-fzf-r; cat /tmp/rg-fzf-f)" \
-    --bind "ctrl-r:unbind(ctrl-r)+change-prompt(1. ripgrep> )+disable-search+reload($RG_PREFIX {q} || true)+rebind(change,ctrl-f)+transform-query(echo {q} > /tmp/rg-fzf-f; cat /tmp/rg-fzf-r)" \
-    --color "hl:-1:underline,hl+:-1:underline:reverse" \
-    --prompt '1. ripgrep> ' \
-    --delimiter : \
-    --header '╱ CTRL-R (ripgrep mode) ╱ CTRL-F (fzf mode) ╱' \
-    --preview 'bat --color=always {1} --highlight-line {2}' \
-    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
-    --bind 'enter:become(vim {1} +{2})'
-```
-
- To restore the query string when switching between modes, we store the
-  current query in `/tmp/rg-fzf-{r,f}` files and restore the query using
-  `transform-query` action which was added in [fzf 0.36.0][0.36.0].
- Also note that we unbind `ctrl-r` binding on `start` event which is
-  triggered once when fzf starts.
-
-[0.30.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0300
-[0.36.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0360
-
-### Switching between Ripgrep mode and fzf mode using a single key binding
-
-In contrast to the previous version, we use just one hotkey to toggle between
-ripgrep and fzf mode. This is achieved by using the `$FZF_PROMPT` as a state
-within the `transform` action, a feature introduced in [fzf 0.45.0][0.45.0]. A
-more detailed explanation of this feature can be found in a previous section -
-[Toggling with a single keybinding](#toggling-with-a-single-key-binding).
-
-[0.45.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0450
-
-When using the `transform` action, the placeholder (`\{q}`) should be escaped to
-prevent immediate evaluation.
-
-```sh
-#!/usr/bin/env bash
-
-# Switch between Ripgrep mode and fzf filtering mode (CTRL-T)
-rm -f /tmp/rg-fzf-{r,f}
-RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
-INITIAL_QUERY="${*:-}"
-fzf --ansi --disabled --query "$INITIAL_QUERY" \
-    --bind "start:reload:$RG_PREFIX {q}" \
-    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
-    --bind 'ctrl-t:transform:[[ ! $FZF_PROMPT =~ ripgrep ]] &&
-      echo "rebind(change)+change-prompt(1. ripgrep> )+disable-search+transform-query:echo \{q} > /tmp/rg-fzf-f; cat /tmp/rg-fzf-r" ||
-      echo "unbind(change)+change-prompt(2. fzf> )+enable-search+transform-query:echo \{q} > /tmp/rg-fzf-r; cat /tmp/rg-fzf-f"' \
-    --color "hl:-1:underline,hl+:-1:underline:reverse" \
-    --prompt '1. ripgrep> ' \
-    --delimiter : \
-    --header 'CTRL-T: Switch between ripgrep/fzf' \
-    --preview 'bat --color=always {1} --highlight-line {2}' \
-    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
-    --bind 'enter:become(vim {1} +{2})'
-```
-
-### Controlling Ripgrep search and fzf search simultaneously
-
-`search` and `transform-search` action allow you to trigger an fzf search with
-an arbitrary query string. This frees fzf from strictly following the prompt
-input, enabling custom search syntax.
-
-In the example below, `transform` action is used to conditionally trigger
-`reload` for ripgrep, followed by `search` for fzf. The first word of the
-query initiates the Ripgrep process to generate the initial results, while the
-remainder of the query is passed to fzf for secondary filtering.
-
-```sh
-#!/usr/bin/env bash
-
-export TEMP=$(mktemp -u)
-trap 'rm -f "$TEMP"' EXIT
-
-INITIAL_QUERY="${*:-}"
-TRANSFORMER='
-  rg_pat={q:1}      # The first word is passed to ripgrep
-  fzf_pat={q:2..}   # The rest are passed to fzf
-
-  if ! [[ -r "$TEMP" ]] || [[ $rg_pat != $(cat "$TEMP") ]]; then
-    echo "$rg_pat" > "$TEMP"
-    printf "reload:sleep 0.1; rg --column --line-number --no-heading --color=always --smart-case %q || true" "$rg_pat"
-  fi
-  echo "+search:$fzf_pat"
-'
-fzf --ansi --disabled --query "$INITIAL_QUERY" \
-    --with-shell 'bash -c' \
-    --bind "start,change:transform:$TRANSFORMER" \
-    --color "hl:-1:underline,hl+:-1:underline:reverse" \
-    --delimiter : \
-    --preview 'bat --color=always {1} --highlight-line {2}' \
-    --preview-window 'up,60%,border-line,+{2}+3/3,~3' \
-    --bind 'enter:become(vim {1} +{2})'
+IFS=: read -ra selected < <(
+  FZF_DEFAULT_COMMAND="$RG_PREFIX $(printf %q "$INITIAL_QUERY")" \
+  fzf --ansi \
+      --color "hl:-1:underline,hl+:-1:underline:reverse" \
+      --disabled --query "$INITIAL_QUERY" \
+      --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
+      --bind "ctrl-f:unbind(change,ctrl-f)+change-prompt(2. fzf> )+enable-search+clear-query+rebind(ctrl-r)" \
+      --bind "ctrl-r:unbind(ctrl-r)+change-prompt(1. ripgrep> )+disable-search+reload($RG_PREFIX {q} || true)+rebind(change,ctrl-f)" \
+      --prompt '1. Ripgrep> ' \
+      --delimiter : \
+      --header '╱ CTRL-R (Ripgrep mode) ╱ CTRL-F (fzf mode) ╱' \
+      --preview 'bat --color=always {1} --highlight-line {2}' \
+      --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
+)
+[ -n "${selected[0]}" ] && vim "${selected[0]}" "+${selected[1]}"
 ```

 Log tailing
@@ -564,16 +465,16 @@ Kubernetes pods.

 ```bash
 pods() {
-  command='kubectl get pods --all-namespaces' fzf \
-    --info=inline --layout=reverse --header-lines=1 \
-    --prompt "$(kubectl config current-context | sed 's/-context$//')> " \
-    --header $'╱ Enter (kubectl exec) ╱ CTRL-O (open log in editor) ╱ CTRL-R (reload) ╱\n\n' \
-    --bind 'start,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})' \
-    --preview-window up:follow \
-    --preview 'kubectl logs --follow --all-containers --tail=10000 --namespace {1} {2}' "$@"
+  FZF_DEFAULT_COMMAND="kubectl get pods --all-namespaces" \
+    fzf --info=inline --layout=reverse --header-lines=1 \
+        --prompt "$(kubectl config current-context | sed 's/-context$//')> " \
+        --header $'╱ Enter (kubectl exec) ╱ CTRL-O (open log in editor) ╱ CTRL-R (reload) ╱\n\n' \
+        --bind 'ctrl-/:change-preview-window(80%,border-bottom|hidden|)' \
+        --bind 'enter:execute:kubectl exec -it --namespace {1} {2} -- bash > /dev/tty' \
+        --bind 'ctrl-o:execute:${EDITOR:-vim} <(kubectl logs --all-containers --namespace {1} {2}) > /dev/tty' \
+        --bind 'ctrl-r:reload:$FZF_DEFAULT_COMMAND' \
+        --preview-window up:follow \
+        --preview 'kubectl logs --follow --all-containers --tail=10000 --namespace {1} {2}' "$@"
 }
 ```

@@ -586,7 +487,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`
@@ -595,17 +496,9 @@ pods() {
 Key bindings for git objects
 ----------------------------

-Oftentimes, you want to put the identifiers of various Git object to the
-command-line. For example, it is common to write commands like these:
-
-```sh
-git checkout [SOME_COMMIT_HASH or BRANCH or TAG]
-git diff [SOME_COMMIT_HASH or BRANCH or TAG] [SOME_COMMIT_HASH or BRANCH or TAG]
-```
-
-[fzf-git.sh](https://github.com/junegunn/fzf-git.sh) project defines a set of
-fzf-based key bindings for Git objects. I strongly recommend that you check
-them out because they are seriously useful.
+I have [blogged](https://junegunn.kr/2016/07/fzf-git) about my fzf+git key
+bindings a few years ago. I'm going to show them here again, because they are
+seriously useful.

 ### Files listed in `git status`

@@ -625,6 +518,9 @@ them out because they are seriously useful.

 ![image](https://user-images.githubusercontent.com/700826/113473765-91692080-94a6-11eb-8d38-ed4d41f27ac1.png)

+
+The full source code can be found [here](https://gist.github.com/junegunn/8b572b8d4b5eddd8b85e5f4d40f17236).
+
 Color themes
 ------------

@@ -667,12 +563,6 @@ export FZF_DEFAULT_OPTS='--color=bg+:#293739,bg:#1B1D1E,border:#808080,spinner:#

 ![molokai](https://user-images.githubusercontent.com/700826/113475085-8619f300-94ae-11eb-85e4-2766fc3246bf.png)

-### fzf Theme Playground
-
-[fzf Theme Playground](https://vitormv.github.io/fzf-themes/) created by
-[Vitor Mello](https://github.com/vitormv) is a webpage where you can
-interactively create fzf themes.
-
 ### Generating fzf color theme from Vim color schemes

 The Vim plugin of fzf can generate `--color` option from the current color
--- a/BUILD.md
+++ b/BUILD.md
@@ -6,7 +6,7 @@ Build instructions

 ### Prerequisites

- Go 1.20 or above
+- Go 1.17 or above

 ### Using Makefile

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

- [rivo/uniseg](https://github.com/rivo/uniseg)
-    - Licensed under [MIT](https://raw.githubusercontent.com/rivo/uniseg/master/LICENSE.txt)
+- [mattn/go-runewidth](https://github.com/mattn/go-runewidth)
+    - Licensed under [MIT](http://mattn.mit-license.org)
 - [mattn/go-shellwords](https://github.com/mattn/go-shellwords)
    - Licensed under [MIT](http://mattn.mit-license.org)
 - [mattn/go-isatty](https://github.com/mattn/go-isatty)
    - Licensed under [MIT](http://mattn.mit-license.org)
 - [tcell](https://github.com/gdamore/tcell)
    - Licensed under [Apache License 2.0](https://github.com/gdamore/tcell/blob/master/LICENSE)
- [fastwalk](https://github.com/charlievieth/fastwalk)
-    - Licensed under [MIT](https://raw.githubusercontent.com/charlievieth/fastwalk/master/LICENSE)

 License
 -------
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/9
+++ b/9
@@ -1,6 +1,6 @@
-FROM rubylang/ruby:3.4.1-noble
-RUN apt-get update -y && apt install -y git make golang zsh fish tmux
-RUN gem install --no-document -v 5.22.3 minitest
+FROM archlinux
+RUN pacman -Sy && pacman --noconfirm -S awk git tmux zsh fish ruby procps go make gcc
+RUN gem install --no-document -v 5.14.2 minitest
 RUN echo '. /usr/share/bash-completion/completions/git' >> ~/.bashrc
 RUN echo '. ~/.bashrc' >> ~/.bash_profile

@@ -8,5 +8,4 @@ RUN echo '. ~/.bashrc' >> ~/.bash_profile
 RUN rm -f /etc/bash.bashrc
 COPY . /fzf
 RUN cd /fzf && make install && ./install --all
-ENV LANG=C.UTF-8
-CMD ["bash", "-ic", "tmux new 'set -o pipefail; ruby /fzf/test/runner.rb | tee out && touch ok' && cat out && [ -e ok ]"]
+CMD tmux new 'set -o pipefail; ruby /fzf/test/test_go.rb | tee out && touch ok' && cat out && [ -e ok ]
--- a/8
+++ b/8
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gem 'minitest', '5.25.4'
-gem 'rubocop', '1.71.0'
-gem 'rubocop-minitest', '0.36.0'
-gem 'rubocop-performance', '1.23.1'
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -1,47 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    ast (2.4.2)
-    json (2.9.1)
-    language_server-protocol (3.17.0.3)
-    minitest (5.25.4)
-    parallel (1.26.3)
-    parser (3.3.7.0)
-      ast (~> 2.4.1)
-      racc
-    racc (1.8.1)
-    rainbow (3.1.1)
-    regexp_parser (2.10.0)
-    rubocop (1.71.0)
-      json (~> 2.3)
-      language_server-protocol (>= 3.17.0)
-      parallel (~> 1.10)
-      parser (>= 3.3.0.2)
-      rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.36.2, < 2.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.37.0)
-      parser (>= 3.3.1.0)
-    rubocop-minitest (0.36.0)
-      rubocop (>= 1.61, < 2.0)
-      rubocop-ast (>= 1.31.1, < 2.0)
-    rubocop-performance (1.23.1)
-      rubocop (>= 1.48.1, < 2.0)
-      rubocop-ast (>= 1.31.1, < 2.0)
-    ruby-progressbar (1.13.0)
-    unicode-display_width (2.6.0)
-
-PLATFORMS
-  arm64-darwin-23
-  ruby
-
-DEPENDENCIES
-  minitest (= 5.25.4)
-  rubocop (= 1.71.0)
-  rubocop-minitest (= 0.36.0)
-  rubocop-performance (= 1.23.1)
-
-BUNDLED WITH
-   2.6.2
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/52
+++ b/52
@@ -1,34 +1,34 @@
+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)
 else
-VERSION        := $(shell git describe --abbrev=0 2> /dev/null | sed "s/^v//")
+VERSION        := $(shell git describe --abbrev=0 2> /dev/null)
 endif
 ifeq ($(VERSION),)
 $(error Not on git repository; cannot determine $$FZF_VERSION)
 endif
-VERSION_TRIM   := $(shell echo $(VERSION) | sed "s/^v//; s/-.*//")
+VERSION_TRIM   := $(shell sed "s/-.*//" <<< $(VERSION))
 VERSION_REGEX  := $(subst .,\.,$(VERSION_TRIM))

 ifdef FZF_REVISION
 REVISION       := $(FZF_REVISION)
 else
-REVISION       := $(shell git log -n 1 --pretty=format:%h --abbrev=8 -- $(SOURCES) 2> /dev/null)
+REVISION       := $(shell git log -n 1 --pretty=format:%h -- $(SOURCES) 2> /dev/null)
 endif
 ifeq ($(REVISION),)
 $(error Not on git repository; cannot determine $$FZF_REVISION)
 endif
-BUILD_FLAGS    := -a -ldflags "-s -w -X main.version=$(VERSION) -X main.revision=$(REVISION)" -tags "$(TAGS)" -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
-BINARYS390     := fzf-$(GOOS)_s390x
 BINARYARM5     := fzf-$(GOOS)_arm5
 BINARYARM6     := fzf-$(GOOS)_arm6
 BINARYARM7     := fzf-$(GOOS)_arm7
@@ -43,8 +43,6 @@ ifeq ($(UNAME_M),x86_64)
 	BINARY := $(BINARY64)
 else ifeq ($(UNAME_M),amd64)
 	BINARY := $(BINARY64)
-else ifeq ($(UNAME_M),s390x)
-	BINARY := $(BINARYS390)
 else ifeq ($(UNAME_M),i686)
 	BINARY := $(BINARY32)
 else ifeq ($(UNAME_M),i386)
@@ -56,9 +54,7 @@ else ifeq ($(UNAME_M),armv6l)
 else ifeq ($(UNAME_M),armv7l)
 	BINARY := $(BINARYARM7)
 else ifeq ($(UNAME_M),armv8l)
-	# armv8l is always 32-bit and should implement the armv7 ISA, so
-	# just use the same filename as for armv7.
-	BINARY := $(BINARYARM7)
+	BINARY := $(BINARYARM8)
 else ifeq ($(UNAME_M),arm64)
 	BINARY := $(BINARYARM8)
 else ifeq ($(UNAME_M),aarch64)
@@ -76,35 +72,22 @@ endif
 all: target/$(BINARY)

 test: $(SOURCES)
+	[ -z "$$(gofmt -s -d src)" ] || (gofmt -s -d src; exit 1)
 	SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" \
 				github.com/junegunn/fzf/src \
 				github.com/junegunn/fzf/src/algo \
 				github.com/junegunn/fzf/src/tui \
 				github.com/junegunn/fzf/src/util

-itest:
-	ruby test/runner.rb
-
 bench:
 	cd src && SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" -run=Bench -bench=. -benchmem

-lint: $(SOURCES) test/*.rb test/lib/*.rb
-	[ -z "$$(gofmt -s -d src)" ] || (gofmt -s -d src; exit 1)
-	bundle exec rubocop -a --require rubocop-minitest --require rubocop-performance
-
 install: bin/fzf

-generate:
-	PATH=$(PATH):$(GOPATH)/bin $(GO) generate ./...
-
 build:
-	goreleaser build --clean --snapshot --skip=post-hooks
+	goreleaser --rm-dist --snapshot

 release:
-	# Make sure that the tests pass and the build works
-	TAGS=tcell make test
-	make test build clean
-
 ifndef GITHUB_TOKEN
 	$(error GITHUB_TOKEN is not defined)
 endif
@@ -131,7 +114,7 @@ endif
 	git push origin temp --follow-tags --force

 	# Make a GitHub release
-	goreleaser --clean --release-notes tmp/release-note
+	goreleaser --rm-dist --release-notes tmp/release-note

 	# Push to master
 	git checkout master
@@ -149,8 +132,6 @@ target/$(BINARY32): $(SOURCES)
 target/$(BINARY64): $(SOURCES)
 	GOARCH=amd64 $(GO) build $(BUILD_FLAGS) -o $@

-target/$(BINARYS390): $(SOURCES)
-	GOARCH=s390x $(GO) build $(BUILD_FLAGS) -o $@
 # https://github.com/golang/go/wiki/GoArm
 target/$(BINARYARM5): $(SOURCES)
 	GOARCH=arm GOARM=5 $(GO) build $(BUILD_FLAGS) -o $@
@@ -174,19 +155,18 @@ target/$(BINARYLOONG64): $(SOURCES)
 	GOARCH=loong64 $(GO) build $(BUILD_FLAGS) -o $@

 bin/fzf: target/$(BINARY) | bin
-	-rm -f bin/fzf
 	cp -f target/$(BINARY) bin/fzf

 docker:
-	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
 	$(GO) mod tidy

-.PHONY: all generate build release test itest bench lint install clean docker docker-test update
+.PHONY: all build release test bench install clean docker docker-test update
--- a/README-VIM.md
+++ b/README-VIM.md
@@ -12,10 +12,7 @@ differ depending on the package manager.
 " If installed using Homebrew
 set rtp+=/usr/local/opt/fzf

-" If installed using Homebrew on Apple Silicon
-set rtp+=/opt/homebrew/opt/fzf
-
-" If you have cloned fzf on ~/.fzf directory
+" If installed using git
 set rtp+=~/.fzf
 ```

@@ -26,10 +23,7 @@ written as:
 " If installed using Homebrew
 Plug '/usr/local/opt/fzf'

-" If installed using Homebrew on Apple Silicon
-Plug '/opt/homebrew/opt/fzf'
-
-" If you have cloned fzf on ~/.fzf directory
+" If installed using git
 Plug '~/.fzf'
 ```

@@ -121,7 +115,7 @@ let g:fzf_action = {

 " An action can be a reference to a function that processes selected lines
 function! s:build_quickfix_list(lines)
-  call setqflist(map(copy(a:lines), '{ "filename": v:val, "lnum": 1 }'))
+  call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
  copen
  cc
 endfunction
@@ -238,20 +232,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'})
@@ -289,13 +282,12 @@ The following table summarizes the available options.
 | `source`                   | string        | External command to generate input to fzf (e.g. `find .`)             |
 | `source`                   | list          | Vim list as input to fzf                                              |
 | `sink`                     | string        | Vim command to handle the selected item (e.g. `e`, `tabe`)            |
-| `sink`                     | funcref       | Function to be called with each selected item                         |
+| `sink`                     | funcref       | Reference to function to process each selected item                   |
 | `sinklist` (or `sink*`)    | funcref       | Similar to `sink`, but takes the list of output lines at once         |
-| `exit`                     | funcref       | Function to be called with the exit status of fzf (e.g. 0, 1, 2, 130) |
 | `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}`) |

@@ -317,7 +309,7 @@ following options are allowed:
    - `yoffset` [float default 0.5 range [0 ~ 1]]
    - `xoffset` [float default 0.5 range [0 ~ 1]]
    - `relative` [boolean default v:false]
-    - `border` [string default `rounded` (`sharp` on Windows)]: Border style
+    - `border` [string default `rounded`]: Border style
        - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right` / `no[ne]`

 `fzf#wrap`
@@ -458,13 +450,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
@@ -492,4 +483,4 @@ autocmd  FileType fzf set laststatus=0 noshowmode noruler

 The MIT License (MIT)

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

+tmux_args=()
 args=()
 opt=""
 skip=""
@@ -19,9 +20,6 @@ term=""
 [[ -n "$LINES" ]] && lines=$LINES || lines=$(tput lines) || lines=$(tmux display-message -p "#{pane_height}")
 [[ -n "$COLUMNS" ]] && columns=$COLUMNS || columns=$(tput cols) || columns=$(tmux display-message -p "#{pane_width}")

-tmux_version=$(tmux -V | sed 's/[^0-9.]//g')
-tmux_32=$(awk '{print ($1 >= 3.2)}' <<< "$tmux_version" 2> /dev/null || bc -l <<< "$tmux_version >= 3.2")
-
 help() {
  >&2 echo 'usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]

@@ -60,7 +58,7 @@ while [[ $# -gt 0 ]]; do
      ;;
    -p*|-w*|-h*|-x*|-y*|-d*|-u*|-r*|-l*)
      if [[ "$arg" =~ ^-[pwhxy] ]]; then
-        [[ "$opt" =~ "-E" ]] || opt="-E"
+        [[ "$opt" =~ "-K -E" ]] || opt="-K -E"
      elif [[ "$arg" =~ ^.[lr] ]]; then
        opt="-h"
        if [[ "$arg" =~ ^.l ]]; then
@@ -97,18 +95,10 @@ while [[ $# -gt 0 ]]; do
        opt="$opt ${arg:0:2}$size"
      elif [[ "$size" =~ %$ ]]; then
        size=${size:0:((${#size}-1))}
-        if [[ $tmux_32 = 1 ]]; then
-          if [[ -n "$swap" ]]; then
-            opt="$opt -l $(( 100 - size ))%"
-          else
-            opt="$opt -l $size%"
-          fi
+        if [[ -n "$swap" ]]; then
+          opt="$opt -p $(( 100 - size ))"
        else
-          if [[ -n "$swap" ]]; then
-            opt="$opt -p $(( 100 - size ))"
-          else
-            opt="$opt -p $size"
-          fi
+          opt="$opt -p $size"
        fi
      else
        if [[ -n "$swap" ]]; then
@@ -129,6 +119,8 @@ while [[ $# -gt 0 ]]; do
      # "--" can be used to separate fzf-tmux options from fzf options to
      # avoid conflicts
      skip=1
+      tmux_args=("${args[@]}")
+      args=()
      continue
      ;;
    *)
@@ -143,13 +135,11 @@ 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
+if [[ ! "$opt" =~ "-K -E" ]] && tmux list-panes -F '#F' | grep -q Z; then
  zoomed_without_popup=1
  original_window=$(tmux display-message -p "#{window_id}")
  tmp_window=$(tmux new-window -d -P -F "#{window_id}" "bash -c 'while :; do for c in \\| / - '\\;' do sleep 0.2; printf \"\\r\$c fzf-tmux is running\\r\"; done; done'")
@@ -164,18 +154,12 @@ argsf="${TMPDIR:-/tmp}/fzf-args-$id"
 fifo1="${TMPDIR:-/tmp}/fzf-fifo1-$id"
 fifo2="${TMPDIR:-/tmp}/fzf-fifo2-$id"
 fifo3="${TMPDIR:-/tmp}/fzf-fifo3-$id"
-if tmux_win_opts=$(tmux show-options -p remain-on-exit \; show-options -p synchronize-panes 2> /dev/null); then
-  tmux_win_opts=( $(sed '/ off/d; s/synchronize-panes/set-option -p synchronize-panes/; s/remain-on-exit/set-option -p remain-on-exit/; s/$/ \\;/' <<< "$tmux_win_opts") )
-  tmux_off_opts='; set-option -p synchronize-panes off ; set-option -p remain-on-exit off'
-else
-  tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
-  tmux_off_opts='; set-window-option synchronize-panes off ; set-window-option remain-on-exit off'
-fi
+tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
 cleanup() {
  \rm -f $argsf $fifo1 $fifo2 $fifo3

  # Restore tmux window options
-  if [[ "${#tmux_win_opts[@]}" -gt 1 ]]; then
+  if [[ "${#tmux_win_opts[@]}" -gt 0 ]]; then
    eval "tmux ${tmux_win_opts[*]}"
  fi

@@ -197,22 +181,9 @@ trap 'cleanup 1' SIGUSR1
 trap 'cleanup' EXIT

 envs="export TERM=$TERM "
-if [[ "$opt" =~ "-E" ]]; then
-  if [[ $tmux_version = 3.2 ]]; then
-    FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
-  elif [[ $tmux_32 = 1 ]]; then
-    FZF_DEFAULT_OPTS="--border $FZF_DEFAULT_OPTS"
-    opt="-B $opt"
-  else
-    echo "fzf-tmux: tmux 3.2 or above is required for popup mode" >&2
-    exit 2
-  fi
-fi
-envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
-envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
-envs="$envs FZF_DEFAULT_OPTS_FILE=$(printf %q "$FZF_DEFAULT_OPTS_FILE")"
-[[ -n "$RUNEWIDTH_EASTASIAN" ]] && envs="$envs RUNEWIDTH_EASTASIAN=$(printf %q "$RUNEWIDTH_EASTASIAN")"
-[[ -n "$BAT_THEME" ]] && envs="$envs BAT_THEME=$(printf %q "$BAT_THEME")"
+[[ "$opt" =~ "-K -E" ]] && FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
+[[ -n "$FZF_DEFAULT_OPTS"    ]] && envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
+[[ -n "$FZF_DEFAULT_COMMAND" ]] && envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
 echo "$envs;" > "$argsf"

 # Build arguments to fzf
@@ -224,7 +195,7 @@ close="; trap - EXIT SIGINT SIGTERM $close"

 export TMUX=$(cut -d , -f 1,2 <<< "$TMUX")
 mkfifo -m o+w $fifo2
-if [[ "$opt" =~ "-E" ]]; then
+if [[ "$opt" =~ "-K -E" ]]; then
  cat $fifo2 &
  if [[ -n "$term" ]] || [[ -t 0 ]]; then
    cat <<< "\"$fzf\" $opts > $fifo2; out=\$? $close; exit \$out" >> $argsf
@@ -234,7 +205,15 @@ if [[ "$opt" =~ "-E" ]]; then
    cat <&0 > $fifo1 &
  fi

-  tmux popup -d "$PWD" $opt "bash $argsf" > /dev/null 2>&1
+  # tmux dropped the support for `-K`, `-R` to popup command
+  #   TODO: We can remove this once tmux 3.2 is released
+  if [[ ! "$(tmux popup --help 2>&1)" =~ '-R shell-command' ]]; then
+    opt="${opt/-K/}"
+  else
+    opt="${opt} -R"
+  fi
+
+  tmux popup -d "$PWD" "${tmux_args[@]}" $opt "bash $argsf" > /dev/null 2>&1
  exit $?
 fi

@@ -246,9 +225,9 @@ else
  cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" >> $argsf
  cat <&0 > $fifo1 &
 fi
-tmux \
-  split-window -c "$PWD" $opt "bash -c 'exec -a fzf bash $argsf'" $swap \
-  $tmux_off_opts \
+tmux set-window-option synchronize-panes off \;\
+  set-window-option remain-on-exit off \;\
+  split-window -c "$PWD" $opt "${tmux_args[@]}" "bash -c 'exec -a fzf bash $argsf'" $swap \
  > /dev/null 2>&1 || { "$fzf" "${args[@]}"; exit $?; }
 cat $fifo2
 exit "$(cat $fifo3)"
--- 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: May 19 2021
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================

@@ -32,10 +32,7 @@ depending on the package manager.
    " If installed using Homebrew
    set rtp+=/usr/local/opt/fzf

-    " If installed using Homebrew on Apple Silicon
-    set rtp+=/opt/homebrew/opt/fzf
-
-    " If you have cloned fzf on ~/.fzf directory
+    " If installed using git
    set rtp+=~/.fzf
 <
 If you use {vim-plug}{1}, the same can be written as:
@@ -43,10 +40,7 @@ If you use {vim-plug}{1}, the same can be written as:
    " If installed using Homebrew
    Plug '/usr/local/opt/fzf'

-    " If installed using Homebrew on Apple Silicon
-    Plug '/opt/homebrew/opt/fzf'
-
-    " If you have cloned fzf on ~/.fzf directory
+    " If installed using git
    Plug '~/.fzf'
 <
 But if you want the latest Vim plugin file from GitHub rather than the one
@@ -74,16 +68,16 @@ SUMMARY                                                            *fzf-summary*
 The Vim plugin of fzf provides two core functions, and `:FZF` command which is
 the basic file selector command built on top of them.

- 1. `fzf#run([spec dict])`
+ 1. `fzf#run([spec dict])`
   - Starts fzf inside Vim with the given spec
-   - `:call fzf#run({'source': 'ls'})`
- 2. `fzf#wrap([spec dict]) -> (dict)`
+   - `:call fzf#run({'source': 'ls'})`
+ 2. `fzf#wrap([spec dict]) -> (dict)`
   - Takes a spec for `fzf#run` and returns an extended version of it with
     additional options for addressing global preferences (`g:fzf_xxx`)
-     - `:echo fzf#wrap({'source': 'ls'})`
+     - `:echo fzf#wrap({'source': 'ls'})`
   - We usually wrap a spec with `fzf#wrap` before passing it to `fzf#run`
-     - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
- 3. `:FZF [fzf_options string] [path string]`
+     - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
+ 3. `:FZF [fzf_options string] [path string]`
   - Basic fuzzy file selector
   - A reference implementation for those who don't want to write VimScript to
     implement custom commands
@@ -149,7 +143,7 @@ Examples~

    " An action can be a reference to a function that processes selected lines
    function! s:build_quickfix_list(lines)
-      call setqflist(map(copy(a:lines), '{ "filename": v:val, "lnum": 1 }'))
+      call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
      copen
      cc
    endfunction
@@ -228,12 +222,12 @@ list:
  `spinner`                    | Streaming input indicator
  `query`                      | Query string
  `disabled`                   | Query string when search is disabled
-  `prompt`                     | Prompt before query ( `> ` )
+  `prompt`                     | Prompt before query ( `> ` )
  `pointer`                    | Pointer to the current line ( `>` )
 ----------------------------+------------------------------------------------------
 - `component` specifies the component (`fg` / `bg`) from which to extract the
   color when considering each of the following highlight groups
- - `group1 [, group2, ...]` is a list of highlight groups that are searched (in
+ - `group1 [, group2, ...]` is a list of highlight groups that are searched (in
   order) for a matching color definition

 For example, consider the following specification:
@@ -264,18 +258,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'})
 <
@@ -303,18 +296,17 @@ The following table summarizes the available options.
 ---------------------------+---------------+----------------------------------------------------------------------
 Option name                | Type          | Description                                                          ~
 ---------------------------+---------------+----------------------------------------------------------------------
-  `source`                    | string        | External command to generate input to fzf (e.g.  `find .` )
+  `source`                    | string        | External command to generate input to fzf (e.g.  `find .` )
  `source`                    | list          | Vim list as input to fzf
  `sink`                      | string        | Vim command to handle the selected item (e.g.  `e` ,  `tabe` )
-  `sink`                      | funcref       | Function to be called with each selected item
+  `sink`                      | funcref       | Reference to function to process each selected item
  `sinklist`  (or  `sink*` )    | funcref       | Similar to  `sink` , but takes the list of output lines at once
-  `exit`                      | funcref       | Function to be called with the exit status of fzf (e.g. 0, 1, 2, 130)
  `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%` )
-  `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}` )
+  `tmux`                      | string        | (Layout) fzf-tmux options (e.g.  `-p90%,60%` )
+  `window`  (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g.  `vertical aboveleft 30new` )
+  `window`  (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g.  `{'width': 0.9, 'height': 0.6}` )
 ---------------------------+---------------+----------------------------------------------------------------------

 `options` entry can be either a string or a list. For simple cases, string
@@ -333,7 +325,7 @@ following options are allowed:
   - `yoffset` [float default 0.5 range [0 ~ 1]]
   - `xoffset` [float default 0.5 range [0 ~ 1]]
   - `relative` [boolean default v:false]
-   - `border` [string default `rounded` (`sharp` on Windows)]: Border style
+   - `border` [string default `rounded`]: Border style
     - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right` / `no[ne]`


@@ -351,7 +343,7 @@ So how can we make our custom `fzf#run` calls also respect those variables?
 Simply by "wrapping" the spec dictionary with `fzf#wrap` before passing it to
 `fzf#run`.

- - `fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`
+ - `fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`
   - All arguments are optional. Usually we only need to pass a spec
     dictionary.
   - `name` is for managing history files. It is ignored if `g:fzf_history_dir`
@@ -385,7 +377,7 @@ last `fullscreen` argument of `fzf#wrap` (see :help <bang>).
    command! -bang LS call fzf#run(fzf#wrap({'source': 'ls'}, <bang>0))
 <
 Our `:LS` command will be much more useful if we can pass a directory argument
-to it, so that something like `:LS /tmp` is possible.
+to it, so that something like `:LS /tmp` is possible.
 >
    command! -bang -complete=dir -nargs=? LS
        \ call fzf#run(fzf#wrap({'source': 'ls', 'dir': <q-args>}, <bang>0))
@@ -404,10 +396,10 @@ unique name to our command and pass it as the first argument to `fzf#wrap`.

 - `g:fzf_layout`
 - `g:fzf_action`
-   - Works only when no custom `sink` (or `sinklist`) is provided
+   - Works only when no custom `sink` (or `sink*`) is provided
     - Having custom sink usually means that each entry is not an ordinary
       file path (e.g. name of color scheme), so we can't blindly apply the
-       same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
+       same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
 - `g:fzf_colors`
 - `g:fzf_history_dir`

@@ -419,12 +411,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')
@@ -470,12 +474,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
@@ -485,7 +488,7 @@ or above) by putting `--tmux` options in `tmux` key.
                                                           *fzf-hide-statusline*

 When fzf starts in a terminal buffer, the file type of the buffer is set to
-`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
+`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
 the window.

 For example, if you open fzf on the bottom on the screen (e.g. `{'down':
@@ -503,7 +506,7 @@ LICENSE                                                            *fzf-license*

 The MIT License (MIT)

-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi

 ==============================================================================
 vim:tw=78:sw=2:ts=2:ft=help:norl:nowrap:
--- a/go.mod
+++ b/go.mod
@@ -1,20 +1,21 @@
 module github.com/junegunn/fzf

 require (
-	github.com/charlievieth/fastwalk v1.0.9
-	github.com/gdamore/tcell/v2 v2.8.1
-	github.com/junegunn/go-shellwords v0.0.0-20250127100254-2aa3b3277741
-	github.com/mattn/go-isatty v0.0.20
-	github.com/rivo/uniseg v0.4.7
-	golang.org/x/sys v0.30.0
-	golang.org/x/term v0.29.0
+	github.com/gdamore/tcell v1.4.0
+	github.com/mattn/go-isatty v0.0.14
+	github.com/mattn/go-runewidth v0.0.13
+	github.com/mattn/go-shellwords v1.0.12
+	github.com/rivo/uniseg v0.2.0
+	github.com/saracen/walker v0.1.2
+	golang.org/x/sys v0.0.0-20220406163625-3f8b81556e12
+	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211
 )

 require (
-	github.com/gdamore/encoding v1.0.1 // indirect
+	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.16 // indirect
-	golang.org/x/text v0.21.0 // indirect
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
+	golang.org/x/text v0.3.7 // indirect
 )

-go 1.20
+go 1.17
--- a/go.sum
+++ b/go.sum
@@ -1,87 +1,32 @@
-github.com/charlievieth/fastwalk v1.0.9 h1:Odb92AfoReO3oFBfDGT5J+nwgzQPF/gWAw6E6/lkor0=
-github.com/charlievieth/fastwalk v1.0.9/go.mod h1:yGy1zbxog41ZVMcKA/i8ojXLFsuayX5VvwhQVoj9PBI=
-github.com/gdamore/encoding v1.0.1 h1:YzKZckdBL6jVt2Gc+5p82qhrGiqMdG/eNs6Wy0u3Uhw=
-github.com/gdamore/encoding v1.0.1/go.mod h1:0Z0cMFinngz9kS1QfMjCP8TY7em3bZYeeklsSDPivEo=
-github.com/gdamore/tcell/v2 v2.8.1 h1:KPNxyqclpWpWQlPLx6Xui1pMk8S+7+R37h3g07997NU=
-github.com/gdamore/tcell/v2 v2.8.1/go.mod h1:bj8ori1BG3OYMjmb3IklZVWfZUJ1UBQt9JXrOCOhGWw=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/junegunn/go-shellwords v0.0.0-20250127100254-2aa3b3277741 h1:7dYDtfMDfKzjT+DVfIS4iqknSEKtZpEcXtu6vuaasHs=
-github.com/junegunn/go-shellwords v0.0.0-20250127100254-2aa3b3277741/go.mod h1:6EILKtGpo5t+KLb85LNZLAF6P9LKp78hJI80PXMcn3c=
+github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
+github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
+github.com/gdamore/tcell v1.4.0 h1:vUnHwJRvcPQa3tzi+0QI4U9JINXYJlOz9yiaiPQ2wMU=
+github.com/gdamore/tcell v1.4.0/go.mod h1:vxEiSDZdW3L+Uhjii9c3375IlDmR05bzxY404ZVSMo0=
+github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-isatty v0.0.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.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
+github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-shellwords v1.0.12 h1:M2zGm7EW6UQJvDeQxo4T51eKPurbeFbe8WtebGE2xrk=
+github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
-golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
-golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
-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/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-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/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
-golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
-golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
-golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.10.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=
+github.com/saracen/walker v0.1.2 h1:/o1TxP82n8thLvmL4GpJXduYaRmJ7qXp8u9dSlV0zmo=
+github.com/saracen/walker v0.1.2/go.mod h1:0oKYMsKVhSJ+ful4p/XbjvXbMgLEkLITZaxozsl4CGE=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-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.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.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/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220406163625-3f8b81556e12 h1:QyVthZKMsyaQwBTJE04jdNN0Pp5Fn9Qga0mrgxyERQM=
+golang.org/x/sys v0.0.0-20220406163625-3f8b81556e12/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
 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.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
-golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
-golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
-golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
-golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
 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 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 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.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
-golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 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/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
-golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
--- a/126
+++ b/126
@@ -2,7 +2,7 @@

 set -u

-version=0.60.3
+version=0.31.0
 auto_completion=
 key_bindings=
 update_config=2
@@ -83,7 +83,7 @@ ask() {
 check_binary() {
  echo -n "  - Checking fzf executable ... "
  local output
-  output=$(FZF_DEFAULT_OPTS= "$fzf_base"/bin/fzf --version 2>&1)
+  output=$("$fzf_base"/bin/fzf --version 2>&1)
  if [ $? -ne 0 ]; then
    echo "Error: $output"
    binary_error="Invalid binary"
@@ -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"
@@ -146,7 +146,7 @@ download() {
  fi

  local url
-  url=https://github.com/junegunn/fzf/releases/download/v$version/${1}
+  url=https://github.com/junegunn/fzf/releases/download/$version/${1}
  set -o pipefail
  if ! (try_curl $url || try_wget $url); then
    set +o pipefail
@@ -168,24 +168,21 @@ archi=$(uname -sm)
 binary_available=1
 binary_error=""
 case "$archi" in
-  Darwin\ arm64)      download fzf-$version-darwin_arm64.tar.gz  ;;
-  Darwin\ x86_64)     download fzf-$version-darwin_amd64.tar.gz  ;;
-  Linux\ armv5*)      download fzf-$version-linux_armv5.tar.gz   ;;
-  Linux\ armv6*)      download fzf-$version-linux_armv6.tar.gz   ;;
-  Linux\ armv7*)      download fzf-$version-linux_armv7.tar.gz   ;;
-  Linux\ armv8*)      download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ aarch64*)    download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ loongarch64) download fzf-$version-linux_loong64.tar.gz ;;
-  Linux\ ppc64le)     download fzf-$version-linux_ppc64le.tar.gz ;;
-  Linux\ *64)         download fzf-$version-linux_amd64.tar.gz   ;;
-  Linux\ s390x)       download fzf-$version-linux_s390x.tar.gz   ;;
-  FreeBSD\ *64)       download fzf-$version-freebsd_amd64.tar.gz ;;
-  OpenBSD\ *64)       download fzf-$version-openbsd_amd64.tar.gz ;;
-  CYGWIN*\ *64)       download fzf-$version-windows_amd64.zip    ;;
-  MINGW*\ *64)        download fzf-$version-windows_amd64.zip    ;;
-  MSYS*\ *64)         download fzf-$version-windows_amd64.zip    ;;
-  Windows*\ *64)      download fzf-$version-windows_amd64.zip    ;;
-  *)                  binary_available=0 binary_error=1          ;;
+  Darwin\ arm64)   download fzf-$version-darwin_arm64.zip     ;;
+  Darwin\ x86_64)  download fzf-$version-darwin_amd64.zip     ;;
+  Linux\ armv5*)   download fzf-$version-linux_armv5.tar.gz   ;;
+  Linux\ armv6*)   download fzf-$version-linux_armv6.tar.gz   ;;
+  Linux\ armv7*)   download fzf-$version-linux_armv7.tar.gz   ;;
+  Linux\ armv8*)   download fzf-$version-linux_arm64.tar.gz   ;;
+  Linux\ aarch64*) download fzf-$version-linux_arm64.tar.gz   ;;
+  Linux\ *64)      download fzf-$version-linux_amd64.tar.gz   ;;
+  FreeBSD\ *64)    download fzf-$version-freebsd_amd64.tar.gz ;;
+  OpenBSD\ *64)    download fzf-$version-openbsd_amd64.tar.gz ;;
+  CYGWIN*\ *64)    download fzf-$version-windows_amd64.zip    ;;
+  MINGW*\ *64)     download fzf-$version-windows_amd64.zip    ;;
+  MSYS*\ *64)      download fzf-$version-windows_amd64.zip    ;;
+  Windows*\ *64)   download fzf-$version-windows_amd64.zip    ;;
+  *)               binary_available=0 binary_error=1 ;;
 esac

 cd "$fzf_base"
@@ -196,12 +193,12 @@ if [ -n "$binary_error" ]; then
    echo "  - $binary_error !!!"
  fi
  if command -v go > /dev/null; then
-    echo -n "Building binary (go install github.com/junegunn/fzf) ... "
+    echo -n "Building binary (go get -u github.com/junegunn/fzf) ... "
    if [ -z "${GOPATH-}" ]; then
      export GOPATH="${TMPDIR:-/tmp}/fzf-gopath"
      mkdir -p "$GOPATH"
    fi
-    if go install -ldflags "-s -w -X main.version=$version -X main.revision=go-install" github.com/junegunn/fzf; then
+    if go get -ldflags "-s -w -X main.version=$version -X main.revision=go-get" github.com/junegunn/fzf; then
      echo "OK"
      cp "$GOPATH/bin/fzf" "$fzf_base/bin/"
    else
@@ -245,7 +242,7 @@ for shell in $shells; do
  src=${prefix_expand}.${shell}
  echo -n "Generate $src ... "

-  fzf_completion="source \"$fzf_base/shell/completion.${shell}\""
+  fzf_completion="[[ \$- == *i* ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
  if [ $auto_completion -eq 0 ]; then
    fzf_completion="# $fzf_completion"
  fi
@@ -262,16 +259,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 +267,6 @@ $fzf_completion
 # ------------
 $fzf_key_bindings
 EOF
-  fi
  echo "OK"
 done

@@ -292,47 +278,50 @@ 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() {
-  local update line file pat lines
+  set -e
+
+  local update line file pat lno
  update="$1"
  line="$2"
  file="$3"
  pat="${4:-}"
-  lines=""
+  lno=""

  echo "Update $file:"
  echo "  - $line"
  if [ -f "$file" ]; then
    if [ $# -lt 4 ]; then
-      lines=$(\grep -nF "$line" "$file")
+      lno=$(\grep -nF "$line" "$file" | sed 's/:.*//' | tr '\n' ' ')
    else
-      lines=$(\grep -nF "$pat" "$file")
+      lno=$(\grep -nF "$pat" "$file" | sed 's/:.*//' | tr '\n' ' ')
    fi
  fi
-
-  if [ -n "$lines" ]; then
-    echo "    - Already exists:"
-    sed 's/^/        Line /' <<< "$lines"
-
-    update=0
-    if ! \grep -qv "^[0-9]*:[[:space:]]*#" <<< "$lines" ; then
-      echo "    - But they all seem to be commented"
-      ask  "    - Continue modifying $file?"
-      update=$?
-    fi
-  fi
-
-  set -e
-  if [ "$update" -eq 1 ]; then
-    [ -f "$file" ] && echo >> "$file"
-    echo "$line" >> "$file"
-    echo "    + Added"
+  if [ -n "$lno" ]; then
+    echo "    - Already exists: line #$lno"
  else
-    echo "    ~ Skipped"
+    if [ $update -eq 1 ]; then
+      [ -f "$file" ] && echo >> "$file"
+      echo "$line" >> "$file"
+      echo "    + Added"
+    else
+      echo "    ~ Skipped"
+    fi
  fi
-
  echo
  set +e
 }
@@ -363,23 +352,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.60.3"
+$version="0.31.0"

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

@@ -40,7 +40,7 @@ function download {
    return
  }
  cd "$fzf_base\bin"
-  $url="https://github.com/junegunn/fzf/releases/download/v$version/$file"
+  $url="https://github.com/junegunn/fzf/releases/download/$version/$file"
  $temp=$env:TMP + "\fzf.zip"
  [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
  if ($PSVersionTable.PSVersion.Major -ge 3) {
--- 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.60"
-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 && err != nil {
-		fmt.Fprintln(os.Stderr, err.Error())
-	}
-	os.Exit(code)
-}
+var version string = "0.31"
+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
@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)

-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,48 +21,48 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf\-tmux 1 "Mar 2025" "fzf 0.60.3" "fzf\-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Jul 2022" "fzf 0.31.0" "fzf-tmux - open fzf in tmux split pane"

 .SH NAME
-fzf\-tmux - open fzf in tmux split pane
+fzf-tmux - open fzf in tmux split pane

 .SH SYNOPSIS
-.B fzf\-tmux [\fILAYOUT OPTIONS\fR] [\-\-] [\fIFZF OPTIONS\fR]
+.B fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]

 .SH DESCRIPTION
-fzf\-tmux is a wrapper script for fzf that opens fzf in a tmux split pane or in
+fzf-tmux is a wrapper script for fzf that opens fzf in a tmux split pane or in
 a tmux popup window. It is designed to work just like fzf except that it does
-not take up the whole screen. You can safely use fzf\-tmux instead of fzf in
+not take up the whole screen. You can safely use fzf-tmux instead of fzf in
 your scripts as the extra options will be silently ignored if you're not on
 tmux.

 .SH LAYOUT OPTIONS

-(default layout: \fB\-d 50%\fR)
+(default layout: \fB-d 50%\fR)

 .SS Popup window
 (requires tmux 3.2 or above)
 .TP
-.B "\-p [WIDTH[%][,HEIGHT[%]]]"
+.B "-p [WIDTH[%][,HEIGHT[%]]]"
 .TP
-.B "\-w WIDTH[%]"
+.B "-w WIDTH[%]"
 .TP
-.B "\-h WIDTH[%]"
+.B "-h WIDTH[%]"
 .TP
-.B "\-x COL"
+.B "-x COL"
 .TP
-.B "\-y ROW"
+.B "-y ROW"

 .SS Split pane
 .TP
-.B "\-u [height[%]]"
+.B "-u [height[%]]"
 Split above (up)
 .TP
-.B "\-d [height[%]]"
+.B "-d [height[%]]"
 Split below (down)
 .TP
-.B "\-l [width[%]]"
+.B "-l [width[%]]"
 Split left
 .TP
-.B "\-r [width[%]]"
+.B "-r [width[%]]"
 Split right
--- a/man/man1/fzf.1
+++ b/man/man1/fzf.1
--- a/plugin/fzf.vim
+++ b/plugin/fzf.vim
@@ -1,4 +1,4 @@
-" Copyright (c) 2013-2024 Junegunn Choi
+" Copyright (c) 2017 Junegunn Choi
 "
 " MIT License
 "
@@ -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, ...)
@@ -150,7 +143,7 @@ function! fzf#install()
    if !filereadable(script)
      throw script.' not found'
    endif
-    let script = 'powershell -ExecutionPolicy Bypass -file ' . shellescape(script)
+    let script = 'powershell -ExecutionPolicy Bypass -file ' . script
  else
    let script = s:base_dir.'/install'
    if !executable(script)
@@ -171,7 +164,7 @@ function s:get_version(bin)
  if has_key(s:versions, a:bin)
    return s:versions[a:bin]
  end
-  let command = (&shell =~ 'powershell\|pwsh' ? '&' : '') . s:fzf_call('shellescape', a:bin) . ' --version --no-height'
+  let command = fzf#shellescape(a:bin) . ' --version --no-height'
  let output = systemlist(command)
  if v:shell_error || empty(output)
    return ''
@@ -198,7 +191,6 @@ function! s:compare_binary_versions(a, b)
  return s:compare_versions(s:get_version(a:a), s:get_version(a:b))
 endfunction

-let s:min_version = '0.53.0'
 let s:checked = {}
 function! fzf#exec(...)
  if !exists('s:exec')
@@ -226,11 +218,7 @@ function! fzf#exec(...)
    let s:exec = binaries[-1]
  endif

-  let min_version = s:min_version
-  if a:0 && s:compare_versions(a:1, min_version) > 0
-    let min_version = a:1
-  endif
-  if !has_key(s:checked, min_version)
+  if a:0 && !has_key(s:checked, a:1)
    let fzf_version = s:get_version(s:exec)
    if empty(fzf_version)
      let message = printf('Failed to run "%s --version"', s:exec)
@@ -238,17 +226,17 @@ function! fzf#exec(...)
      throw message
    end

-    if s:compare_versions(fzf_version, min_version) >= 0
-      let s:checked[min_version] = 1
+    if s:compare_versions(fzf_version, a:1) >= 0
+      let s:checked[a:1] = 1
      return s:exec
-    elseif a:0 < 2 && input(printf('You need fzf %s or above. Found: %s. Download binary? (y/n) ', min_version, fzf_version)) =~? '^y'
+    elseif a:0 < 2 && input(printf('You need fzf %s or above. Found: %s. Download binary? (y/n) ', a:1, fzf_version)) =~? '^y'
      let s:versions = {}
      unlet s:exec
      redraw
      call fzf#install()
-      return fzf#exec(min_version, 1)
+      return fzf#exec(a:1, 1)
    else
-      throw printf('You need to upgrade fzf (required: %s or above)', min_version)
+      throw printf('You need to upgrade fzf (required: %s or above)', a:1)
    endif
  endif

@@ -332,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
@@ -357,8 +342,7 @@ function! s:common_sink(action, lines) abort
 endfunction

 function! s:get_color(attr, ...)
-  " Force 24 bit colors: g:fzf_force_termguicolors (temporary workaround for https://github.com/junegunn/fzf.vim/issues/1152)
-  let gui = get(g:, 'fzf_force_termguicolors', 0) || (!s:is_win && !has('win32unix') && has('termguicolors') && &termguicolors)
+  let gui = !s:is_win && !has('win32unix') && has('termguicolors') && &termguicolors
  let fam = gui ? 'gui' : 'cterm'
  let pat = gui ? '^#[a-f0-9]\+' : '^[0-9]\+$'
  for group in a:000
@@ -471,32 +455,6 @@ function! s:writefile(...)
  endif
 endfunction

-function! s:extract_option(opts, name)
-  let opt = ''
-  let expect = 0
-  " There are a few cases where this function doesn't work as expected.
-  " Let's just assume such cases are extremely unlikely in real world.
-  "   e.g. --query --border
-  for word in split(a:opts)
-    if expect && word !~ '^"\=-'
-      let opt = opt . ' ' . word
-      let expect = 0
-    elseif word == '--no-'.a:name
-      let opt = ''
-    elseif word =~ '^--'.a:name.'='
-      let opt = word
-    elseif word =~ '^--'.a:name.'$'
-      let opt = word
-      let expect = 1
-    elseif expect
-      let expect = 0
-    endif
-  endfor
-  return opt
-endfunction
-
-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()
@@ -505,7 +463,7 @@ try
  let temps  = { 'result': s:fzf_tempname() }
  let optstr = s:evaluate_opts(get(dict, 'options', ''))
  try
-    let fzf_exec = shellescape(fzf#exec())
+    let fzf_exec = fzf#shellescape(fzf#exec())
  catch
    throw v:exception
  endtry
@@ -518,19 +476,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')
@@ -539,23 +497,25 @@ 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 optstr .= s:border_opt(get(dict, 'window', 0))
+  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)
@@ -566,6 +526,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
@@ -584,21 +552,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)
@@ -670,17 +636,21 @@ else
  let s:launcher = function('s:xterm_launcher')
 endif

-function! s:exit_handler(dict, code, command, ...)
-  if has_key(a:dict, 'exit')
-    call a:dict.exit(a:code)
-  endif
-  if a:code == 2
+function! s:exit_handler(code, command, ...)
+  if a:code == 130
+    return 0
+  elseif has('nvim') && a:code == 129
+    " When deleting the terminal buffer while fzf is still running,
+    " Nvim sends SIGHUP.
+    return 0
+  elseif a:code > 1
    call s:error('Error running ' . a:command)
    if !empty(a:000)
      sleep
    endif
+    return 0
  endif
-  return a:code
+  return 1
 endfunction

 function! s:execute(dict, command, use_height, temps) abort
@@ -717,22 +687,21 @@ 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
  let exit_status = v:shell_error
  redraw!
  let lines = s:collect(a:temps)
-  return s:exit_handler(a:dict, exit_status, command) < 2 ? lines : []
+  return s:exit_handler(exit_status, command) ? lines : []
 endfunction

 function! s:execute_tmux(dict, command, temps) abort
@@ -747,7 +716,7 @@ function! s:execute_tmux(dict, command, temps) abort
  let exit_status = v:shell_error
  redraw!
  let lines = s:collect(a:temps)
-  return s:exit_handler(a:dict, exit_status, command) < 2 ? lines : []
+  return s:exit_handler(exit_status, command) ? lines : []
 endfunction

 function! s:calc_size(max, val, dict)
@@ -768,7 +737,7 @@ function! s:calc_size(max, val, dict)
    return size
  endif
  let margin = match(opts, '--inline-info\|--info[^-]\{-}inline') > match(opts, '--no-inline-info\|--info[^-]\{-}\(default\|hidden\)') ? 1 : 2
-  let margin += match(opts, '--border\([^-]\|$\)') > match(opts, '--no-border\([^-]\|$\)') ? 2 : 0
+  let margin += stridx(opts, '--border') > stridx(opts, '--no-border') ? 2 : 0
  if stridx(opts, '--header') > stridx(opts, '--no-header')
    let margin += len(split(opts, "\n"))
  endif
@@ -785,9 +754,9 @@ function! s:border_opt(window)
  endif

  " Border style
-  let style = tolower(get(a:window, 'border', ''))
-  if !has_key(a:window, 'border') && has_key(a:window, 'rounded')
-    let style = a:window.rounded ? 'rounded' : 'sharp'
+  let style = tolower(get(a:window, 'border', 'rounded'))
+  if !has_key(a:window, 'border') && !get(a:window, 'rounded', 1)
+    let style = 'sharp'
  endif
  if style == 'none' || style == 'no'
    return ''
@@ -795,7 +764,7 @@ function! s:border_opt(window)

  " For --border styles, we need fzf 0.24.0 or above
  call fzf#exec('0.24.0')
-  let opt = ' --border ' . style
+  let opt = ' --border=' . style
  if has_key(a:window, 'highlight')
    let color = s:get_color('fg', a:window.highlight)
    if len(color)
@@ -857,17 +826,6 @@ if exists(':tnoremap')
  tnoremap <silent> <Plug>(fzf-normal) <C-\><C-n>
 endif

-let s:warned = 0
-function! s:handle_ambidouble(dict)
-  if &ambiwidth == 'double'
-    let a:dict.env = { 'RUNEWIDTH_EASTASIAN': '1' }
-  elseif !s:warned && $RUNEWIDTH_EASTASIAN == '1' && &ambiwidth !=# 'double'
-    call s:warn("$RUNEWIDTH_EASTASIAN is '1' but &ambiwidth is not 'double'")
-    2sleep
-    let s:warned = 1
-  endif
-endfunction
-
 function! s:execute_term(dict, command, temps) abort
  let winrest = winrestcmd()
  let pbuf = bufnr('')
@@ -913,7 +871,7 @@ function! s:execute_term(dict, command, temps) abort
    endif

    let lines = s:collect(self.temps)
-    if s:exit_handler(self.dict, a:code, self.command, 1) >= 2
+    if !s:exit_handler(a:code, self.command, 1)
      return
    endif

@@ -937,7 +895,6 @@ function! s:execute_term(dict, command, temps) abort
    endif
    let command .= s:term_marker
    if has('nvim')
-      call s:handle_ambidouble(fzf)
      call termopen(command, fzf)
    else
      let term_opts = {'exit_cb': function(fzf.on_exit)}
@@ -949,8 +906,7 @@ function! s:execute_term(dict, command, temps) abort
      else
        let term_opts.curwin = 1
      endif
-      call s:handle_ambidouble(term_opts)
-      keepjumps let fzf.buf = term_start([&shell, &shellcmdflag, command], term_opts)
+      let fzf.buf = term_start([&shell, &shellcmdflag, command], term_opts)
      if is_popup && exists('#TerminalWinOpen')
        doautocmd <nomodeline> TerminalWinOpen
      endif
@@ -1016,16 +972,16 @@ function! s:callback(dict, lines) abort
 endfunction

 if has('nvim')
-  function s:create_popup(opts) abort
+  function s:create_popup(hl, opts) abort
    let buf = nvim_create_buf(v:false, v:true)
    let opts = extend({'relative': 'editor', 'style': 'minimal'}, a:opts)
    let win = nvim_open_win(buf, v:true, opts)
-    silent! call setwinvar(win, '&winhighlight', 'Pmenu:,Normal:Normal')
+    call setwinvar(win, '&winhighlight', 'NormalFloat:'..a:hl)
    call setwinvar(win, '&colorcolumn', '')
    return buf
  endfunction
 else
-  function! s:create_popup(opts) abort
+  function! s:create_popup(hl, opts) abort
    let s:popup_create = {buf -> popup_create(buf, #{
      \ line: a:opts.row,
      \ col: a:opts.col,
@@ -1060,7 +1016,7 @@ function! s:popup(opts) abort
  let row += !has('nvim')
  let col += !has('nvim')

-  call s:create_popup({
+  call s:create_popup('Normal', {
    \ 'row': row, 'col': col, 'width': width, 'height': height
  \ })
 endfunction
@@ -1081,7 +1037,7 @@ endfunction

 function! s:cmd(bang, ...) abort
  let args = copy(a:000)
-  let opts = { 'options': ['--multi', '--scheme', 'path'] }
+  let opts = { 'options': ['--multi'] }
  if len(args) && isdirectory(expand(args[-1]))
    let opts.dir = substitute(substitute(remove(args, -1), '\\\(["'']\)', '\1', 'g'), '[/\\]*$', '/', '')
    if s:is_win && !&shellslash
--- a/shell/completion.bash
+++ b/shell/completion.bash
@@ -4,48 +4,40 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ 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

-
 # 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 | sed 's@^\./@@'
+  }
+fi
+
+if ! declare -f _fzf_compgen_dir > /dev/null; then
+  _fzf_compgen_dir() {
+    command find -L "$1" \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi

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

 # To 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%} --min-height 20+ --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 "$@"
-  elif [[ -n "${TMUX_PANE-}" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "${FZF_TMUX_OPTS-}" ]]; }; then
+  elif [[ -n "$TMUX_PANE" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "$FZF_TMUX_OPTS" ]]; }; then
    shift
    fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- "$@"
  else
@@ -63,181 +55,72 @@ __fzf_orig_completion() {
      cmd="${BASH_REMATCH[3]}"
      [[ "$f" = _fzf_* ]] && continue
      printf -v "_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}" "%s" "${comp} %s ${cmd} #${f}"
-      if [[ "$l" = *" -o nospace "* ]] && [[ ! "${__fzf_nospace_commands-}" = *" $cmd "* ]]; then
-        __fzf_nospace_commands="${__fzf_nospace_commands-} $cmd "
+      if [[ "$l" = *" -o nospace "* ]] && [[ ! "$__fzf_nospace_commands" = *" $cmd "* ]]; then
+        __fzf_nospace_commands="$__fzf_nospace_commands $cmd "
      fi
    fi
  done
 }

-# @param $1 cmd - Command name for which the original completion is searched
-# @var[out] REPLY - Original function name is returned
-__fzf_orig_completion_get_orig_func() {
-  local cmd orig_var orig
-  cmd=$1
-  orig_var="_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}"
-  orig="${!orig_var-}"
-  REPLY="${orig##*#}"
-  [[ $REPLY ]] && type "$REPLY" &> /dev/null
-}
-
-# @param $1 cmd - Command name for which the original completion is searched
-# @param $2 func - Fzf's completion function to replace the original function
-# @var[out] REPLY - Completion setting is returned as a string to "eval"
-__fzf_orig_completion_instantiate() {
-  local cmd func orig_var orig
-  cmd=$1
-  func=$2
-  orig_var="_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}"
-  orig="${!orig_var-}"
-  orig="${orig%#*}"
-  [[ $orig == *' %s '* ]] || return 1
-  printf -v REPLY "$orig" "$func"
-}
-
 _fzf_opts_completion() {
  local cur prev opts
  COMPREPLY=()
  cur="${COMP_WORDS[COMP_CWORD]}"
  prev="${COMP_WORDS[COMP_CWORD-1]}"
  opts="
-    +c --no-color
-    +i --no-ignore-case
+    -x --extended
+    -e --exact
+    --algo
+    -i +i
+    -n --nth
+    --with-nth
+    -d --delimiter
    +s --no-sort
-    +x --no-extended
-    --ansi
-    --bash
-    --bind
-    --border
-    --border-label
-    --border-label-pos
-    --color
-    --cycle
-    --disabled
-    --ellipsis
-    --expect
-    --filepath-word
-    --fish
-    --header
-    --header-first
-    --header-lines
-    --height
-    --highlight-line
-    --history
-    --history-size
-    --hscroll-off
-    --info
-    --jump-labels
-    --keep-right
-    --layout
-    --listen
-    --listen-unsafe
-    --literal
-    --man
-    --margin
-    --marker
-    --min-height
-    --no-bold
-    --no-clear
-    --no-hscroll
-    --no-mouse
-    --no-scrollbar
-    --no-separator
-    --no-unicode
-    --padding
-    --pointer
-    --preview
-    --preview-label
-    --preview-label-pos
-    --preview-window
-    --print-query
-    --print0
-    --prompt
-    --read0
-    --reverse
-    --scheme
-    --scroll-off
-    --separator
-    --sync
-    --tabstop
    --tac
    --tiebreak
-    --tmux
-    --track
-    --version
-    --with-nth
-    --with-shell
-    --wrap
-    --zsh
-    -0 --exit-0
-    -1 --select-1
-    -d --delimiter
-    -e --exact
-    -f --filter
-    -h --help
-    -i --ignore-case
    -m --multi
-    -n --nth
+    --no-mouse
+    --bind
+    --cycle
+    --no-hscroll
+    --jump-labels
+    --height
+    --literal
+    --reverse
+    --margin
+    --inline-info
+    --prompt
+    --pointer
+    --marker
+    --header
+    --header-lines
+    --ansi
+    --tabstop
+    --color
+    --no-bold
+    --history
+    --history-size
+    --preview
+    --preview-window
    -q --query
-    --"
+    -1 --select-1
+    -0 --exit-0
+    -f --filter
+    --print-query
+    --expect
+    --sync"

  case "${prev}" in
-  --scheme)
-    COMPREPLY=( $(compgen -W "default path history" -- "$cur") )
-    return 0
-    ;;
  --tiebreak)
-    COMPREPLY=( $(compgen -W "length chunk begin end index" -- "$cur") )
+    COMPREPLY=( $(compgen -W "length begin end index" -- "$cur") )
    return 0
    ;;
  --color)
-    COMPREPLY=( $(compgen -W "dark light 16 bw no" -- "$cur") )
+    COMPREPLY=( $(compgen -W "dark light 16 bw" -- "$cur") )
    return 0
    ;;
-  --layout)
-    COMPREPLY=( $(compgen -W "default reverse reverse-list" -- "$cur") )
-    return 0
-    ;;
-  --info)
-    COMPREPLY=( $(compgen -W "default right hidden inline inline-right" -- "$cur") )
-    return 0
-    ;;
-  --preview-window)
-    COMPREPLY=( $(compgen -W "
-      default
-      hidden
-      nohidden
-      wrap
-      nowrap
-      cycle
-      nocycle
-      up top
-      down bottom
-      left
-      right
-      rounded border border-rounded
-      sharp border-sharp
-      border-bold
-      border-block
-      border-thinblock
-      border-double
-      noborder border-none
-      border-horizontal
-      border-vertical
-      border-up border-top
-      border-down border-bottom
-      border-left
-      border-right
-      follow
-      nofollow" -- "$cur") )
-    return 0
-    ;;
-  --border)
-    COMPREPLY=( $(compgen -W "rounded sharp bold block thinblock double horizontal vertical top bottom left right none" -- "$cur") )
-    return 0
-    ;;
-  --border-label-pos|--preview-label-pos)
-    COMPREPLY=( $(compgen -W "center bottom top" -- "$cur") )
+  --history)
+    COMPREPLY=()
    return 0
    ;;
  esac
@@ -251,51 +134,41 @@ _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" "$@"
-  elif [[ -n "${_fzf_completion_loader-}" ]]; then
+  orig_var="_fzf_orig_completion_$cmd"
+  orig="${!orig_var##*#}"
+  if [[ -n "$orig" ]] && type "$orig" > /dev/null 2>&1; then
+    $orig "$@"
+  elif [[ -n "$_fzf_completion_loader" ]]; then
    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)
-      __fzf_orig_completion_get_orig_func "$cmd" || ret=1
-
-      # 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
+      if [[ "$__fzf_nospace_commands" = *" $orig_cmd "* ]]; then
        eval "${orig_complete/ -F / -o nospace -F }"
      else
        eval "$orig_complete"
      fi
    fi
-    [[ $ret -eq 0 ]] && return 124
    return $ret
  fi
 }

 __fzf_generic_path_completion() {
  local cur base dir leftover matches trigger cmd
-  cmd="${COMP_WORDS[0]}"
-  if [[ $cmd == \\* ]]; then
-    cmd="${cmd:1}"
-  fi
+  cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
  COMPREPLY=()
  trigger=${FZF_COMPLETION_TRIGGER-'**'}
-  [[ $COMP_CWORD -ge 0 ]] && cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ "$cur" == *"$trigger" ]] && [[ $cur != *'$('* ]] && [[ $cur != *':='* ]] && [[ $cur != *'`'* ]]; then
+  cur="${COMP_WORDS[COMP_CWORD]}"
+  if [[ "$cur" == *"$trigger" ]]; then
    base=${cur:0:${#cur}-${#trigger}}
-    eval "base=$base" 2> /dev/null || return
+    eval "base=$base"

-    dir=
    [[ $base = *"/"* ]] && dir="$base"
    while true; do
      if [[ -z "$dir" ]] || [[ -d "$dir" ]]; then
@@ -303,26 +176,11 @@ __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 --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $2" __fzf_comprun "$4" -q "$leftover" | while read -r item; do
+          printf "%q$3 " "$item"
+        done)
        matches=${matches% }
-        [[ -z "$3" ]] && [[ "${__fzf_nospace_commands-}" = *" ${COMP_WORDS[0]} "* ]] && matches="$matches "
+        [[ -z "$3" ]] && [[ "$__fzf_nospace_commands" = *" ${COMP_WORDS[0]} "* ]] && matches="$matches "
        if [[ -n "$matches" ]]; then
          COMPREPLY=( "$matches" )
        else
@@ -331,7 +189,7 @@ __fzf_generic_path_completion() {
        printf '\e[5n'
        return 0
      fi
-      dir=$(command dirname "$dir")
+      dir=$(dirname "$dir")
      [[ "$dir" =~ /$ ]] || dir="$dir"/
    done
  else
@@ -365,19 +223,16 @@ _fzf_complete() {
  fi

  local cur selected trigger cmd post
-  post="$(caller 0 | command awk '{print $2}')_post"
-  type -t "$post" > /dev/null 2>&1 || post='command cat'
+  post="$(caller 0 | awk '{print $2}')_post"
+  type -t "$post" > /dev/null 2>&1 || post=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
+  if [[ "$cur" == *"$trigger" ]]; 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" | eval "$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 | tr '\n' ' ')
    selected=${selected% } # Strip trailing space not to repeat "-o nospace"
    if [[ -n "$selected" ]]; then
      COMPREPLY=("$selected")
@@ -409,95 +264,33 @@ _fzf_complete_kill() {
 }

 _fzf_proc_completion() {
-  local transformer
-  transformer='
-    if [[ $FZF_KEY =~ ctrl|alt|shift ]] && [[ -n $FZF_NTH ]]; then
-      nths=( ${FZF_NTH//,/ } )
-      new_nths=()
-      found=0
-      for nth in ${nths[@]}; do
-        if [[ $nth = $FZF_CLICK_HEADER_NTH ]]; then
-          found=1
-        else
-          new_nths+=($nth)
-        fi
-      done
-      [[ $found = 0 ]] && new_nths+=($FZF_CLICK_HEADER_NTH)
-      new_nths=${new_nths[*]}
-      new_nths=${new_nths// /,}
-      echo "change-nth($new_nths)+change-prompt($new_nths> )"
-    else
-      if [[ $FZF_NTH = $FZF_CLICK_HEADER_NTH ]]; then
-        echo "change-nth()+change-prompt(> )"
-      else
-        echo "change-nth($FZF_CLICK_HEADER_NTH)+change-prompt($FZF_CLICK_HEADER_WORD> )"
-      fi
-    fi
-  '
-  _fzf_complete -m --header-lines=1 --no-preview --wrap --color fg:dim,nth:regular \
-    --bind "click-header:transform:$transformer" -- "$@" < <(
-    command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
-      command ps -eo user,pid,ppid,time,args 2> /dev/null || # For BusyBox
-      command ps --everyone --full --windows # For cygwin
+  _fzf_complete -m --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+    command ps -ef | sed 1d
  )
 }

 _fzf_proc_completion_post() {
-  command awk '{print $2}'
+  awk '{print $2}'
 }

-# To use custom hostname lists, override __fzf_list_hosts.
-# The function is expected to print hostnames, one per line as well as in the
-# desired sorting and with any duplicates removed, to standard output.
-#
-# e.g.
-#   # Use bash-completions’s _known_hosts_real() for getting the list of hosts
-#   __fzf_list_hosts() {
-#     # Set the local attribute for any non-local variable that is set by _known_hosts_real()
-#     local COMPREPLY=()
-#     _known_hosts_real ''
-#     printf '%s\n' "${COMPREPLY[@]}" | command sort -u --version-sort
-#   }
-if ! declare -F __fzf_list_hosts > /dev/null; then
-  __fzf_list_hosts() {
-    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | command awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
-      <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts 2> /dev/null | command tr ',' '\n' | command tr -d '[' | command awk '{ print $1 " " $1 }') \
-      <(command grep -v '^\s*\(#\|$\)' /etc/hosts 2> /dev/null | command grep -Fv '0.0.0.0' | command sed 's/#.*//') |
-      command awk '{for (i = 2; i <= NF; i++) print $i}' | command sort -u
-  }
-fi
-
 _fzf_host_completion() {
-  _fzf_complete +m -- "$@" < <(__fzf_list_hosts)
-}
-
-# Values for $1 $2 $3 are described here
-# https://www.gnu.org/software/bash/manual/html_node/Programmable-Completion.html
-# > the first argument ($1) is the name of the command whose arguments are being completed,
-# > the second argument ($2) is the word being completed,
-# > and the third argument ($3) is the word preceding the word being completed on the current command line.
-_fzf_complete_ssh() {
-  case $3 in
-    -i|-F|-E)
-      _fzf_path_completion "$@"
-      ;;
-    *)
-      local user=
-      [[ "$2" =~ '@' ]] && user="${2%%@*}@"
-      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | command awk -v user="$user" '{print user $0}')
-      ;;
-  esac
+  _fzf_complete +m -- "$@" < <(
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?]') \
+        <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
+        <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }

 _fzf_var_completion() {
  _fzf_complete -m -- "$@" < <(
-    declare -xp | command sed -En 's|^declare [^ ]+ ([^=]+).*|\1|p'
+    declare -xp | sed 's/=.*//' | sed 's/.* //'
  )
 }

 _fzf_alias_completion() {
  _fzf_complete -m -- "$@" < <(
-    alias | command sed -En 's|^alias ([^=]+).*|\1|p'
+    alias | sed 's/=.*//' | sed 's/.* //'
  )
 }

@@ -508,69 +301,34 @@ 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

-# Default path completion
-__fzf_default_completion() {
-  __fzf_generic_path_completion _fzf_compgen_path "-m" "" "$@"
-
-  # Dynamic completion loader has updated the completion for the command
-  if [[ $? -eq 124 ]]; then
-    # We trigger _fzf_setup_completion so that fuzzy completion for the command
-    # still works. However, loader can update the completion for multiple
-    # commands at once, and fuzzy completion will no longer work for those
-    # other commands. e.g. pytest -> py.test, pytest-2, pytest-3, etc
-    _fzf_setup_completion path "$1"
-    return 124
-  fi
-}
-
-# Set fuzzy path completion as the default completion for all commands.
-# We can't set up default completion,
-# 1. if it's already set up by another script
-# 2. or if the current version of bash doesn't support -D option
-complete | command grep -q __fzf_default_completion ||
-  complete | command grep -- '-D$' | command grep -qv _comp_complete_load ||
-  complete -D -F __fzf_default_completion -o default -o bashdefault 2> /dev/null
-
-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.
-#
-# NOTE: Although we have default completion, we still need to set up completion
-# for each command in case they already have completion set up by another script.
-a_cmds="${FZF_COMPLETION_PATH_COMMANDS-"
-  awk bat cat code diff diff3
-  emacs emacsclient ex file ftp g++ gcc gvim head hg hx java
+d_cmds="${FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir}"
+a_cmds="
+  awk cat diff diff3
+  emacs emacsclient ex file ftp g++ gcc gvim head hg java
  javac ld less more mvim nvim patch perl python ruby
  sed sftp sort source tail tee uniq vi view vim wc xdg-open
  basename bunzip2 bzip2 chmod chown curl cp dirname du
  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)
+__fzf_orig_completion < <(complete -p $d_cmds $a_cmds 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
+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
@@ -583,24 +341,10 @@ done

 # Directory
 for cmd in $d_cmds; do
-  __fzf_defc "$cmd" _fzf_dir_completion "-o bashdefault -o nospace -o dirnames"
+  __fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o dirnames"
 done

-# Variables
-for cmd in $v_cmds; do
-  __fzf_defc "$cmd" _fzf_var_completion "-o default -o nospace -v"
-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
@@ -622,4 +366,10 @@ _fzf_setup_completion() {
  done
 }

+# Environment variables / Aliases / Hosts / Process
+_fzf_setup_completion 'var'   export unset
+_fzf_setup_completion 'alias' unalias
+_fzf_setup_completion 'host'  ssh telnet
+_fzf_setup_completion 'proc'  kill
+
 fi
--- a/shell/completion.zsh
+++ b/shell/completion.zsh
@@ -4,13 +4,10 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ 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)

 # Both branches of the following `if` do the same thing -- define
 # __fzf_completion_options such that `eval $__fzf_completion_options` sets
@@ -70,46 +67,41 @@ fi
 # control. There are several others that could wreck havoc if they are set
 # to values we don't expect. With the following `emulate` command we
 # sidestep this issue entirely.
-'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' 'no_aliases'
+'emulate' 'zsh' '-o' 'no_aliases'

 # This brace is the start of try-always block. The `always` part is like
 # `finally` in lesser languages. We use it to *always* restore user options.
 {
-# 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
+
+# Bail out if not interactive shell.
+[[ -o interactive ]] || 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 | 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 -E "--height ${FZF_TMUX_HEIGHT:-40%} --min-height 20+ --bind=ctrl-z:ignore $1"
-  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
-  echo -E "${FZF_DEFAULT_OPTS-} $2"
-}
-
 __fzf_comprun() {
  if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
    _fzf_comprun "$@"
-  elif [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; }; then
+  elif [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; }; then
    shift
-    if [ -n "${FZF_TMUX_OPTS-}" ]; then
+    if [ -n "$FZF_TMUX_OPTS" ]; then
      fzf-tmux ${(Q)${(Z+n+)FZF_TMUX_OPTS}} -- "$@"
    else
      fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%} -- "$@"
@@ -120,28 +112,32 @@ __fzf_comprun() {
  fi
 }

-# Extract the name of the command. e.g. ls; foo=1 ssh **<tab>
+# Extract the name of the command. e.g. foo=1 bar baz**<tab>
 __fzf_extract_command() {
-  # Control completion with the "compstate" parameter, insert and list nothing
-  compstate[insert]=
-  compstate[list]=
-  cmd_word="${(Q)words[1]}"
+  local token tokens
+  tokens=(${(z)1})
+  for token in $tokens; do
+    token=${(Q)token}
+    if [[ "$token" =~ [[:alnum:]] && ! "$token" =~ "=" ]]; then
+      echo "$token"
+      return
+    fi
+  done
+  echo "${tokens[1]}"
 }

 __fzf_generic_path_completion() {
-  local base lbuf compgen fzf_opts suffix tail dir leftover matches
+  local base lbuf cmd compgen fzf_opts suffix tail dir leftover matches
  base=$1
  lbuf=$2
+  cmd=$(__fzf_extract_command "$lbuf")
  compgen=$3
  fzf_opts=$4
  suffix=$5
  tail=$6

  setopt localoptions nonomatch
-  if [[ $base = *'$('* ]] || [[ $base = *'<('* ]] || [[ $base = *'>('* ]] || [[ $base = *':='* ]] || [[ $base = *'`'* ]]; then
-    return
-  fi
-  eval "base=$base" 2> /dev/null || return
+  eval "base=$base"
  [[ $base = *"/"* ]] && dir="$base"
  while [ 1 ]; do
    if [[ -z "$dir" || -d ${dir} ]]; then
@@ -149,26 +145,9 @@ __fzf_generic_path_completion() {
      leftover=${leftover/#\/}
      [ -z "$dir" ] && dir='.'
      [ "$dir" != "/" ] && dir="${dir/%\//}"
-      matches=$(
-        export FZF_DEFAULT_OPTS
-        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_word" ${(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_word" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" --walker "$walker" --walker-root="$dir" ${(Q)${(Z+n+)rest}} < /dev/tty
-        fi | while read -r item; do
-          item="${item%$suffix}$suffix"
-          echo -n -E "${(q)item} "
-        done
-      )
+      matches=$(eval "$compgen $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS" __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" | while read item; do
+        echo -n "${(q)item}$suffix "
+      done)
      matches=${matches% }
      if [ -n "$matches" ]; then
        LBUFFER="$lbuf$matches$tail"
@@ -191,11 +170,11 @@ _fzf_dir_completion() {
    "" "/" ""
 }

-_fzf_feed_fifo() {
+_fzf_feed_fifo() (
  command rm -f "$1"
  mkfifo "$1"
-  cat <&0 > "$1" &|
-}
+  cat <&0 > "$1" &
+)

 _fzf_complete() {
  setopt localoptions ksh_arrays
@@ -204,7 +183,7 @@ _fzf_complete() {
  args=("$@")
  sep=
  for i in {0..${#args[@]}}; do
-    if [[ "${args[$i]-}" = -- ]]; then
+    if [[ "${args[$i]}" = -- ]]; then
      sep=$i
      break
    fi
@@ -220,55 +199,36 @@ _fzf_complete() {
    rest=("$@")
  fi

-  local fifo lbuf matches post
+  local fifo lbuf cmd matches post
  fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
  lbuf=${rest[0]}
+  cmd=$(__fzf_extract_command "$lbuf")
  post="${funcstack[1]}_post"
  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_word" "${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
  command rm -f "$fifo"
 }

-# To use custom hostname lists, override __fzf_list_hosts.
-# The function is expected to print hostnames, one per line as well as in the
-# desired sorting and with any duplicates removed, to standard output.
-if ! declare -f __fzf_list_hosts > /dev/null; then
-  __fzf_list_hosts() {
-    setopt localoptions nonomatch
-    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
-      <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts 2> /dev/null | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
-      <(command grep -v '^\s*\(#\|$\)' /etc/hosts 2> /dev/null | command grep -Fv '0.0.0.0' | command sed 's/#.*//') |
-      awk '{for (i = 2; i <= NF; i++) print $i}' | sort -u
-  }
-fi
-
 _fzf_complete_telnet() {
-  _fzf_complete +m -- "$@" < <(__fzf_list_hosts)
+  _fzf_complete +m -- "$@" < <(
+    command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0' |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }

-# The first and the only argument is the LBUFFER without the current word that contains the trigger.
-# The current word without the trigger is in the $prefix variable passed from the caller.
 _fzf_complete_ssh() {
-  local -a tokens
-  tokens=(${(z)1})
-  case ${tokens[-1]} in
-    -i|-F|-E)
-      _fzf_path_completion "$prefix" "$1"
-      ;;
-    *)
-      local user
-      [[ $prefix =~ @ ]] && user="${prefix%%@*}@"
-      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | awk -v user="$user" '{print user $0}')
-      ;;
-  esac
+  _fzf_complete +m -- "$@" < <(
+    setopt localoptions nonomatch
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?]') \
+        <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
+        <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }

 _fzf_complete_export() {
@@ -290,36 +250,8 @@ _fzf_complete_unalias() {
 }

 _fzf_complete_kill() {
-  local transformer
-  transformer='
-    if [[ $FZF_KEY =~ ctrl|alt|shift ]] && [[ -n $FZF_NTH ]]; then
-      nths=( ${FZF_NTH//,/ } )
-      new_nths=()
-      found=0
-      for nth in ${nths[@]}; do
-        if [[ $nth = $FZF_CLICK_HEADER_NTH ]]; then
-          found=1
-        else
-          new_nths+=($nth)
-        fi
-      done
-      [[ $found = 0 ]] && new_nths+=($FZF_CLICK_HEADER_NTH)
-      new_nths=${new_nths[*]}
-      new_nths=${new_nths// /,}
-      echo "change-nth($new_nths)+change-prompt($new_nths> )"
-    else
-      if [[ $FZF_NTH = $FZF_CLICK_HEADER_NTH ]]; then
-        echo "change-nth()+change-prompt(> )"
-      else
-        echo "change-nth($FZF_CLICK_HEADER_NTH)+change-prompt($FZF_CLICK_HEADER_WORD> )"
-      fi
-    fi
-  '
-  _fzf_complete -m --header-lines=1 --no-preview --wrap --color fg:dim,nth:regular \
-    --bind "click-header:transform:$transformer" -- "$@" < <(
-    command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
-      command ps -eo user,pid,ppid,time,args 2> /dev/null || # For BusyBox
-      command ps --everyone --full --windows # For cygwin
+  _fzf_complete -m --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+    command ps -ef | sed 1d
  )
 }

@@ -328,7 +260,7 @@ _fzf_complete_kill_post() {
 }

 fzf-completion() {
-  local tokens prefix trigger tail matches lbuf d_cmds cursor_pos cmd_word
+  local tokens cmd prefix trigger tail matches lbuf d_cmds
  setopt localoptions noshwordsplit noksh_arrays noposixbuiltins

  # http://zsh.sourceforge.net/FAQ/zshfaq03.html
@@ -339,13 +271,15 @@ fzf-completion() {
    return
  fi

+  cmd=$(__fzf_extract_command "$LBUFFER")
+
  # Explicitly allow for empty trigger.
  trigger=${FZF_COMPLETION_TRIGGER-'**'}
-  [[ -z $trigger && ${LBUFFER[-1]} == ' ' ]] && tokens+=("")
+  [ -z "$trigger" -a ${LBUFFER[-1]} = ' ' ] && tokens+=("")

  # When the trigger starts with ';', it becomes a separate token
-  if [[ ${LBUFFER} = *"${tokens[-2]-}${tokens[-1]}" ]]; then
-    tokens[-2]="${tokens[-2]-}${tokens[-1]}"
+  if [[ ${LBUFFER} = *"${tokens[-2]}${tokens[-1]}" ]]; then
+    tokens[-2]="${tokens[-2]}${tokens[-1]}"
    tokens=(${tokens[0,-2]})
  fi

@@ -354,39 +288,15 @@ fzf-completion() {

  # Trigger sequence given
  if [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
-    d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS-cd pushd rmdir})
-
-    {
-      cursor_pos=$CURSOR
-      # Move the cursor before the trigger to preserve word array elements when
-      # trigger chars like ';' or '`' would otherwise reset the 'words' array.
-      CURSOR=$((cursor_pos - ${#trigger} - 1))
-      # Check if at least one completion system (old or new) is active.
-      # If at least one user-defined completion widget is detected, nothing will
-      # be completed if neither the old nor the new completion system is enabled.
-      # In such cases, the 'zsh/compctl' module is loaded as a fallback.
-      if ! zmodload -F zsh/parameter p:functions 2>/dev/null || ! (( ${+functions[compdef]} )); then
-        zmodload -F zsh/compctl 2>/dev/null
-      fi
-      # Create a completion widget to access the 'words' array (man zshcompwid)
-      zle -C __fzf_extract_command .complete-word __fzf_extract_command
-      zle __fzf_extract_command
-    } always {
-      CURSOR=$cursor_pos
-      # Delete the completion widget
-      zle -D __fzf_extract_command  2>/dev/null
-    }
+    d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir})

    [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
-    if [[ $prefix = *'$('* ]] || [[ $prefix = *'<('* ]] || [[ $prefix = *'>('* ]] || [[ $prefix = *':='* ]] || [[ $prefix = *'`'* ]]; then
-      return
-    fi
    [ -n "${tokens[-1]}" ] && lbuf=${lbuf:0:-${#tokens[-1]}}

-    if eval "noglob type _fzf_complete_${cmd_word} >/dev/null"; then
-      prefix="$prefix" eval _fzf_complete_${cmd_word} ${(q)lbuf}
+    if eval "type _fzf_complete_${cmd} > /dev/null"; then
+      prefix="$prefix" eval _fzf_complete_${cmd} ${(q)lbuf}
      zle reset-prompt
-    elif [ ${d_cmds[(i)$cmd_word]} -le ${#d_cmds} ]; then
+    elif [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
      _fzf_dir_completion "$prefix" "$lbuf"
    else
      _fzf_path_completion "$prefix" "$lbuf"
@@ -403,10 +313,8 @@ fzf-completion() {
  unset binding
 }

-# Normal widget
 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,31 +11,26 @@
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS

-if [[ $- =~ i ]]; then
-
-
 # Key bindings
 # ------------
-
-__fzf_defaults() {
-  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  echo "--height ${FZF_TMUX_HEIGHT:-40%} --min-height 20+ --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 | cut -b3-"}"
+  opts="--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore --reverse $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
 }

+if [[ $- =~ i ]]; then
+
 __fzfcmd() {
-  [[ -n "${TMUX_PANE-}" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "${FZF_TMUX_OPTS-}" ]]; } &&
+  [[ -n "$TMUX_PANE" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "$FZF_TMUX_OPTS" ]]; } &&
    echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
 }

@@ -46,62 +41,29 @@ 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 | cut -b3-"}"
+  opts="--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore --reverse $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS +m"
+  dir=$(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{$_}++'
-    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 --wrap-sign '"$'\t'"↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
-        FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
-    ) || return
-    READLINE_LINE=$(command perl -pe 's/^\d*\t//' <<< "$output")
-    if [[ -z "$READLINE_POINT" ]]; then
-      echo "$READLINE_LINE"
-    else
-      READLINE_POINT=0x7fffffff
-    fi
-  }
-else # awk - fallback for POSIX systems
-  __fzf_history__() {
-    local output script n x y z d
-    if [[ -z $__fzf_awk ]]; then
-      __fzf_awk=awk
-      # choose the faster mawk if: it's installed && build date >= 20230322 && version >= 1.3.4
-      IFS=' .' read n x y z d <<< $(command mawk -W version 2> /dev/null)
-      [[ $n == mawk ]] && (( d >= 20230302 && (x *1000 +y) *1000 +z >= 1003004 )) && __fzf_awk=mawk
-    fi
-    [[ $(HISTTIMEFORMAT='' builtin history 1) =~ [[:digit:]]+ ]]    # how many history entries
-    script='function P(b) { ++n; sub(/^[ *]/, "", b); if (!seen[b]++) { printf "%d\t%s%c", '$((BASH_REMATCH + 1))' - n, b, 0 } }
-    NR==1 { b = substr($0, 2); next }
-    /^\t/ { P(b); b = substr($0, 2); next }
-    { b = b RS $0 }
-    END { if (NR) P(b) }'
-    output=$(
-      set +o pipefail
-      builtin fc -lnr -2147483648 2> /dev/null |   # ( $'\t '<lines>$'\n' )* ; <lines> ::= [^\n]* ( $'\n'<lines> )*
-        command $__fzf_awk "$script"           |   # ( <counter>$'\t'<lines>$'\000' )*
-        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"$'\t'"↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
-        FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
-    ) || return
-    READLINE_LINE=${output#*$'\t'}
-    if [[ -z "$READLINE_POINT" ]]; then
-      echo "$READLINE_LINE"
-    else
-      READLINE_POINT=0x7fffffff
-    fi
-  }
-fi
+__fzf_history__() {
+  local output opts script
+  opts="--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS -n2..,.. --tiebreak=index --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=$(
+    builtin fc -lnr -2147483648 |
+      last_hist=$(HISTTIMEFORMAT='' builtin history 1) perl -n -l0 -e "$script" |
+      FZF_DEFAULT_OPTS="$opts" $(__fzfcmd) --query "$READLINE_LINE"
+  ) || return
+  READLINE_LINE=${output#*$'\t'}
+  if [[ -z "$READLINE_POINT" ]]; then
+    echo "$READLINE_LINE"
+  else
+    READLINE_POINT=0x7fffffff
+  fi
+}

 # Required to refresh the prompt after fzf
 bind -m emacs-standard '"\er": redraw-current-line'
@@ -112,23 +74,19 @@ 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"'
+  bind -m emacs-standard '"\C-r": "\C-e \C-u\C-y\ey\C-u"$(__fzf_history__)"\e\C-e\er"'
  bind -m vi-command '"\C-r": "\C-z\C-r\C-z"'
  bind -m vi-insert '"\C-r": "\C-z\C-r\C-z"'
 else
  # CTRL-T - Paste the selected file path into the command line
-  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 +95,8 @@ 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
+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
--- a/shell/key-bindings.fish
+++ b/shell/key-bindings.fish
@@ -11,174 +11,162 @@
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS

-
 # Key bindings
 # ------------
-# For compatibility with fish versions down to 3.1.2, the script does not use:
-# - The -f/--function switch of command: set
-# - The process substitution syntax: $(cmd)
-# - Ranges that omit start/end indexes: $var[$start..] $var[..$end] $var[..]
 function fzf_key_bindings

-  function __fzf_defaults
-    # $argv[1]: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-    # $argv[2..]: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-    test -n "$FZF_TMUX_HEIGHT"; or set -l FZF_TMUX_HEIGHT 40%
-    string join ' ' -- \
-      "--height $FZF_TMUX_HEIGHT --min-height=20+ --bind=ctrl-z:ignore" $argv[1] \
-      (test -r "$FZF_DEFAULT_OPTS_FILE"; and string join -- ' ' <$FZF_DEFAULT_OPTS_FILE) \
-      $FZF_DEFAULT_OPTS $argv[2..-1]
+  # Store current token in $dir as root for the 'find' command
+  function fzf-file-widget -d "List files and folders"
+    set -l commandline (__fzf_parse_commandline)
+    set -l dir $commandline[1]
+    set -l fzf_query $commandline[2]
+    set -l prefix $commandline[3]
+
+    # "-path \$dir'*/\\.*'" matches hidden files/folders inside $dir but not
+    # $dir itself, even if hidden.
+    test -n "$FZF_CTRL_T_COMMAND"; or set -l FZF_CTRL_T_COMMAND "
+    command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
+    -o -type f -print \
+    -o -type d -print \
+    -o -type l -print 2> /dev/null | sed 's@^\./@@'"
+
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    begin
+      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS"
+      eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)' -m --query "'$fzf_query'"' | while read -l r; set result $result $r; end
+    end
+    if [ -z "$result" ]
+      commandline -f repaint
+      return
+    else
+      # Remove last token from commandline.
+      commandline -t ""
+    end
+    for i in $result
+      commandline -it -- $prefix
+      commandline -it -- (string escape $i)
+      commandline -it -- ' '
+    end
+    commandline -f repaint
+  end
+
+  function fzf-history-widget -d "Show command history"
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    begin
+      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT $FZF_DEFAULT_OPTS --tiebreak=index --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS +m"
+
+      set -l FISH_MAJOR (echo $version | cut -f1 -d.)
+      set -l FISH_MINOR (echo $version | cut -f2 -d.)
+
+      # history's -z flag is needed for multi-line support.
+      # history's -z flag was added in fish 2.4.0, so don't use it for versions
+      # before 2.4.0.
+      if [ "$FISH_MAJOR" -gt 2 -o \( "$FISH_MAJOR" -eq 2 -a "$FISH_MINOR" -ge 4 \) ];
+        history -z | eval (__fzfcmd) --read0 --print0 -q '(commandline)' | read -lz result
+        and commandline -- $result
+      else
+        history | eval (__fzfcmd) -q '(commandline)' | read -l result
+        and commandline -- $result
+      end
+    end
+    commandline -f repaint
+  end
+
+  function fzf-cd-widget -d "Change directory"
+    set -l commandline (__fzf_parse_commandline)
+    set -l dir $commandline[1]
+    set -l fzf_query $commandline[2]
+    set -l prefix $commandline[3]
+
+    test -n "$FZF_ALT_C_COMMAND"; or set -l FZF_ALT_C_COMMAND "
+    command find -L \$dir -mindepth 1 \\( -path \$dir'*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' \\) -prune \
+    -o -type d -print 2> /dev/null | sed 's@^\./@@'"
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    begin
+      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_ALT_C_OPTS"
+      eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)' +m --query "'$fzf_query'"' | read -l result
+
+      if [ -n "$result" ]
+        builtin cd -- $result
+
+        # Remove last token from commandline.
+        commandline -t ""
+        commandline -it -- $prefix
+      end
+    end
+
+    commandline -f repaint
  end

  function __fzfcmd
-    test -n "$FZF_TMUX_HEIGHT"; or set -l FZF_TMUX_HEIGHT 40%
-    if test -n "$FZF_TMUX_OPTS"
+    test -n "$FZF_TMUX"; or set FZF_TMUX 0
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    if [ -n "$FZF_TMUX_OPTS" ]
      echo "fzf-tmux $FZF_TMUX_OPTS -- "
-    else if test "$FZF_TMUX" = "1"
+    else if [ $FZF_TMUX -eq 1 ]
      echo "fzf-tmux -d$FZF_TMUX_HEIGHT -- "
    else
      echo "fzf"
    end
  end

-  function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath, fzf query, and optional -option= prefix'
-    set -l dir '.'
-    set -l query
-    set -l commandline (commandline -t | string unescape -n)
+  bind \ct fzf-file-widget
+  bind \cr fzf-history-widget
+  bind \ec fzf-cd-widget

-    # Strip -option= from token if present
+  if bind -M insert > /dev/null 2>&1
+    bind -M insert \ct fzf-file-widget
+    bind -M insert \cr fzf-history-widget
+    bind -M insert \ec fzf-cd-widget
+  end
+
+  function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath, fzf query, and optional -option= prefix'
+    set -l commandline (commandline -t)
+
+    # strip -option= from token if present
    set -l prefix (string match -r -- '^-[^\s=]+=' $commandline)
    set commandline (string replace -- "$prefix" '' $commandline)

-    # Enable home directory expansion of leading ~/
-    set commandline (string replace -r -- '^~/' '\$HOME/' $commandline)
-
-    # Escape special characters, except for the $ sign of valid variable names,
-    # so that the original string with expanded variables is returned after eval.
-    set commandline (string escape -n -- $commandline)
-    set commandline (string replace -r -a -- '\\\\\$(?=[\w])' '\$' $commandline)
-
    # eval is used to do shell expansion on paths
    eval set commandline $commandline

-    # Combine multiple consecutive slashes into one.
-    set commandline (string replace -r -a -- '/+' '/' $commandline)
+    if [ -z $commandline ]
+      # Default to current directory with no --query
+      set dir '.'
+      set fzf_query ''
+    else
+      set dir (__fzf_get_dir $commandline)

-    if test -n "$commandline"
-      # Strip trailing slash, unless $dir is root dir (/)
-      set dir (string replace -r -- '(?<!^)/$' '' $commandline)
-
-      # Set $dir to the longest existing filepath
-      while not test -d "$dir"
-        # If path is absolute, this can keep going until ends up at /
-        # If path is relative, this can keep going until entire input is consumed, dirname returns "."
-        set dir (dirname -- $dir)
-      end
-
-      if test "$dir" = '.'; and test (string sub -l 2 -- $commandline) != './'
-        # If $dir is "." but commandline is not a relative path, this means no file path found
+      if [ "$dir" = "." -a (string sub -l 1 -- $commandline) != '.' ]
+        # if $dir is "." but commandline is not a relative path, this means no file path found
        set fzf_query $commandline
      else
        # Also remove trailing slash after dir, to "split" input properly
-        set fzf_query (string replace -r -- "^$dir/?" '' $commandline)
+        set fzf_query (string replace -r "^$dir/?" -- '' "$commandline")
      end
    end

-    string escape -n -- "$dir" "$fzf_query" "$prefix"
+    echo $dir
+    echo $fzf_query
+    echo $prefix
  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 fzf_query $commandline[2]
-    set -l prefix $commandline[3]
+  function __fzf_get_dir -d 'Find the longest existing filepath from input string'
+    set dir $argv

-    set -lx FZF_DEFAULT_OPTS (__fzf_defaults \
-      "--reverse --walker=file,dir,follow,hidden --scheme=path --walker-root=$dir" \
-      "$FZF_CTRL_T_OPTS --multi")
-
-    set -lx FZF_DEFAULT_COMMAND "$FZF_CTRL_T_COMMAND"
-    set -lx FZF_DEFAULT_OPTS_FILE
-
-    if set -l result (eval (__fzfcmd) --query=$fzf_query)
-      # Remove last token from commandline.
-      commandline -t ''
-      for i in $result
-        commandline -it -- $prefix(string escape -- $i)' '
-      end
+    # Strip all trailing slashes. Ignore if $dir is root dir (/)
+    if [ (string length -- $dir) -gt 1 ]
+      set dir (string replace -r '/*$' -- '' $dir)
    end

-    commandline -f repaint
-  end
-
-  function fzf-history-widget -d "Show command history"
-    set -l fzf_query (commandline | string escape)
-
-    set -lx FZF_DEFAULT_OPTS (__fzf_defaults '' \
-      '--nth=2..,.. --scheme=history --multi --wrap-sign="\t↳ "' \
-      "--bind=ctrl-r:toggle-sort --highlight-line $FZF_CTRL_R_OPTS" \
-      '--accept-nth=2.. --read0 --print0 --with-shell='(status fish-path)\\ -c)
-
-    set -lx FZF_DEFAULT_OPTS_FILE
-    set -lx FZF_DEFAULT_COMMAND
-
-    if type -q perl
-      set -a FZF_DEFAULT_OPTS '--tac'
-      set FZF_DEFAULT_COMMAND 'builtin history -z --reverse | command perl -0 -pe \'s/^/$.\t/g; s/\n/\n\t/gm\''
-    else
-      set FZF_DEFAULT_COMMAND \
-        'set -l h (builtin history -z --reverse | string split0);' \
-        'for i in (seq (count $h) -1 1);' \
-        'string join0 -- $i\t(string replace -a -- \n \n\t $h[$i] | string collect);' \
-        'end'
+    # Iteratively check if dir exists and strip tail end of path
+    while [ ! -d "$dir" ]
+      # If path is absolute, this can keep going until ends up at /
+      # If path is relative, this can keep going until entire input is consumed, dirname returns "."
+      set dir (dirname -- "$dir")
    end

-    # Merge history from other sessions before searching
-    test -z "$fish_private_mode"; and builtin history merge
-
-    if set -l result (eval $FZF_DEFAULT_COMMAND \| (__fzfcmd) --query=$fzf_query | string split0)
-      commandline -- (string replace -a -- \n\t \n $result[1])
-      test (count $result) -gt 1; and for i in $result[2..-1]
-        commandline -i -- (string replace -a -- \n\t \n \n$i)
-      end
-    end
-
-    commandline -f repaint
-  end
-
-  function fzf-cd-widget -d "Change directory"
-    set -l commandline (__fzf_parse_commandline)
-    set -lx dir $commandline[1]
-    set -l fzf_query $commandline[2]
-    set -l prefix $commandline[3]
-
-    set -lx FZF_DEFAULT_OPTS (__fzf_defaults \
-      "--reverse --walker=dir,follow,hidden --scheme=path --walker-root=$dir" \
-      "$FZF_ALT_C_OPTS --no-multi")
-
-    set -lx FZF_DEFAULT_OPTS_FILE
-    set -lx FZF_DEFAULT_COMMAND "$FZF_ALT_C_COMMAND"
-
-    if set -l result (eval (__fzfcmd) --query=$fzf_query)
-      cd -- $result
-      commandline -rt -- $prefix
-    end
-
-    commandline -f repaint
-  end
-
-  bind \cr fzf-history-widget
-  bind -M insert \cr fzf-history-widget
-
-  if not set -q FZF_CTRL_T_COMMAND; or test -n "$FZF_CTRL_T_COMMAND"
-    bind \ct fzf-file-widget
-    bind -M insert \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
-    bind -M insert \ec fzf-cd-widget
+    echo $dir
  end

 end
--- a/shell/key-bindings.zsh
+++ b/shell/key-bindings.zsh
@@ -11,7 +11,6 @@
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS

-
 # Key bindings
 # ------------

@@ -33,27 +32,22 @@ else
  }
 fi

-'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' 'no_aliases'
+'emulate' 'zsh' '-o' '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 -E "--height ${FZF_TMUX_HEIGHT:-40%} --min-height 20+ --bind=ctrl-z:ignore $1"
-  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
-  echo -E "${FZF_DEFAULT_OPTS-} $2"
-}
+[[ -o interactive ]] || return 0

 # 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 -r item; do
-    echo -n -E "${(q)item} "
+  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_CTRL_T_OPTS" $(__fzfcmd) -m "$@" | while read item; do
+    echo -n "${(q)item} "
  done
  local ret=$?
  echo
@@ -61,72 +55,55 @@ __fzf_select() {
 }

 __fzfcmd() {
-  [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; } &&
+  [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; } &&
    echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
 }

 fzf-file-widget() {
-  LBUFFER="${LBUFFER}$(__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 --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
-  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases noglob nobash_rematch 2> /dev/null
-  # Ensure the module is loaded if not already, and the required features, such
-  # as the associative 'history' array, which maps event numbers to full history
-  # lines, are set. Also, make sure Perl is installed for multi-line output.
-  if zmodload -F zsh/parameter p:{commands,history} 2>/dev/null && (( ${+commands[perl]} )); then
-    selected="$(printf '%s\t%s\000' "${(kv)history[@]}" |
-      perl -0 -ne 'if (!$seen{(/^\s*[0-9]+\**\t(.*)/s, $1)}++) { s/\n/\n\t/g; print; }' |
-      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '\t↳ ' --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 --wrap-sign '\t↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m") \
-      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
-  fi
+  local selected num
+  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2> /dev/null
+  selected=( $(fc -rl 1 | awk '{ cmd=$0; sub(/^\s*[0-9]+\**\s+/, "", cmd); if (!seen[cmd]++) print $0 }' |
+    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} $FZF_DEFAULT_OPTS -n2..,.. --tiebreak=index --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS --query=${(qqq)LBUFFER} +m" $(__fzfcmd)) )
  local ret=$?
  if [ -n "$selected" ]; then
-    if [[ $(awk '{print $1; exit}' <<< "$selected") =~ ^[1-9][0-9]* ]]; then
-      zle vi-fetch-history -n $MATCH
-    else # selected is a custom query, not from history
-      LBUFFER="$selected"
+    num=$selected[1]
+    if [ -n "$num" ]; then
+      zle vi-fetch-history -n $num
    fi
  fi
  zle reset-prompt
@@ -136,7 +113,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/LICENSE
+++ b/src/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/src/actiontype_string.go
+++ b/src/actiontype_string.go
@@ -1,154 +0,0 @@
-// Code generated by "stringer -type=actionType"; DO NOT EDIT.
-
-package fzf
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[actIgnore-0]
-	_ = x[actStart-1]
-	_ = x[actClick-2]
-	_ = x[actInvalid-3]
-	_ = x[actChar-4]
-	_ = x[actMouse-5]
-	_ = x[actBeginningOfLine-6]
-	_ = x[actAbort-7]
-	_ = x[actAccept-8]
-	_ = x[actAcceptNonEmpty-9]
-	_ = x[actAcceptOrPrintQuery-10]
-	_ = x[actBackwardChar-11]
-	_ = x[actBackwardDeleteChar-12]
-	_ = x[actBackwardDeleteCharEof-13]
-	_ = x[actBackwardWord-14]
-	_ = x[actCancel-15]
-	_ = x[actChangeBorderLabel-16]
-	_ = x[actChangeListLabel-17]
-	_ = x[actChangeInputLabel-18]
-	_ = x[actChangeHeader-19]
-	_ = x[actChangeHeaderLabel-20]
-	_ = x[actChangeMulti-21]
-	_ = x[actChangePreviewLabel-22]
-	_ = x[actChangePrompt-23]
-	_ = x[actChangeQuery-24]
-	_ = x[actChangeNth-25]
-	_ = x[actClearScreen-26]
-	_ = x[actClearQuery-27]
-	_ = x[actClearSelection-28]
-	_ = x[actClose-29]
-	_ = x[actDeleteChar-30]
-	_ = x[actDeleteCharEof-31]
-	_ = x[actEndOfLine-32]
-	_ = x[actFatal-33]
-	_ = x[actForwardChar-34]
-	_ = x[actForwardWord-35]
-	_ = x[actKillLine-36]
-	_ = x[actKillWord-37]
-	_ = x[actUnixLineDiscard-38]
-	_ = x[actUnixWordRubout-39]
-	_ = x[actYank-40]
-	_ = x[actBackwardKillWord-41]
-	_ = x[actSelectAll-42]
-	_ = x[actDeselectAll-43]
-	_ = x[actToggle-44]
-	_ = x[actToggleSearch-45]
-	_ = x[actToggleAll-46]
-	_ = x[actToggleDown-47]
-	_ = x[actToggleUp-48]
-	_ = x[actToggleIn-49]
-	_ = x[actToggleOut-50]
-	_ = x[actToggleTrack-51]
-	_ = x[actToggleTrackCurrent-52]
-	_ = x[actToggleHeader-53]
-	_ = x[actToggleWrap-54]
-	_ = x[actToggleMultiLine-55]
-	_ = x[actToggleHscroll-56]
-	_ = x[actTrackCurrent-57]
-	_ = x[actToggleInput-58]
-	_ = x[actHideInput-59]
-	_ = x[actShowInput-60]
-	_ = x[actUntrackCurrent-61]
-	_ = x[actDown-62]
-	_ = x[actUp-63]
-	_ = x[actPageUp-64]
-	_ = x[actPageDown-65]
-	_ = x[actPosition-66]
-	_ = x[actHalfPageUp-67]
-	_ = x[actHalfPageDown-68]
-	_ = x[actOffsetUp-69]
-	_ = x[actOffsetDown-70]
-	_ = x[actOffsetMiddle-71]
-	_ = x[actJump-72]
-	_ = x[actJumpAccept-73]
-	_ = x[actPrintQuery-74]
-	_ = x[actRefreshPreview-75]
-	_ = x[actReplaceQuery-76]
-	_ = x[actToggleSort-77]
-	_ = x[actShowPreview-78]
-	_ = x[actHidePreview-79]
-	_ = x[actTogglePreview-80]
-	_ = x[actTogglePreviewWrap-81]
-	_ = x[actTransform-82]
-	_ = x[actTransformBorderLabel-83]
-	_ = x[actTransformListLabel-84]
-	_ = x[actTransformInputLabel-85]
-	_ = x[actTransformHeader-86]
-	_ = x[actTransformHeaderLabel-87]
-	_ = x[actTransformNth-88]
-	_ = x[actTransformPreviewLabel-89]
-	_ = x[actTransformPrompt-90]
-	_ = x[actTransformQuery-91]
-	_ = x[actTransformSearch-92]
-	_ = x[actSearch-93]
-	_ = x[actPreview-94]
-	_ = x[actChangePreview-95]
-	_ = x[actChangePreviewWindow-96]
-	_ = x[actPreviewTop-97]
-	_ = x[actPreviewBottom-98]
-	_ = x[actPreviewUp-99]
-	_ = x[actPreviewDown-100]
-	_ = x[actPreviewPageUp-101]
-	_ = x[actPreviewPageDown-102]
-	_ = x[actPreviewHalfPageUp-103]
-	_ = x[actPreviewHalfPageDown-104]
-	_ = x[actPrevHistory-105]
-	_ = x[actPrevSelected-106]
-	_ = x[actPrint-107]
-	_ = x[actPut-108]
-	_ = x[actNextHistory-109]
-	_ = x[actNextSelected-110]
-	_ = x[actExecute-111]
-	_ = x[actExecuteSilent-112]
-	_ = x[actExecuteMulti-113]
-	_ = x[actSigStop-114]
-	_ = x[actFirst-115]
-	_ = x[actLast-116]
-	_ = x[actReload-117]
-	_ = x[actReloadSync-118]
-	_ = x[actDisableSearch-119]
-	_ = x[actEnableSearch-120]
-	_ = x[actSelect-121]
-	_ = x[actDeselect-122]
-	_ = x[actUnbind-123]
-	_ = x[actRebind-124]
-	_ = x[actToggleBind-125]
-	_ = x[actBecome-126]
-	_ = x[actShowHeader-127]
-	_ = x[actHideHeader-128]
-	_ = x[actBell-129]
-	_ = x[actExclude-130]
-	_ = x[actExcludeMulti-131]
-}
-
-const _actionType_name = "actIgnoreactStartactClickactInvalidactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactCancelactChangeBorderLabelactChangeListLabelactChangeInputLabelactChangeHeaderactChangeHeaderLabelactChangeMultiactChangePreviewLabelactChangePromptactChangeQueryactChangeNthactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactFatalactForwardCharactForwardWordactKillLineactKillWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleTrackCurrentactToggleHeaderactToggleWrapactToggleMultiLineactToggleHscrollactTrackCurrentactToggleInputactHideInputactShowInputactUntrackCurrentactDownactUpactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactOffsetMiddleactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTransformactTransformBorderLabelactTransformListLabelactTransformInputLabelactTransformHeaderactTransformHeaderLabelactTransformNthactTransformPreviewLabelactTransformPromptactTransformQueryactTransformSearchactSearchactPreviewactChangePreviewactChangePreviewWindowactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPrintactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactToggleBindactBecomeactShowHeaderactHideHeaderactBellactExcludeactExcludeMulti"
-
-var _actionType_index = [...]uint16{0, 9, 17, 25, 35, 42, 50, 68, 76, 85, 102, 123, 138, 159, 183, 198, 207, 227, 245, 264, 279, 299, 313, 334, 349, 363, 375, 389, 402, 419, 427, 440, 456, 468, 476, 490, 504, 515, 526, 544, 561, 568, 587, 599, 613, 622, 637, 649, 662, 673, 684, 696, 710, 731, 746, 759, 777, 793, 808, 822, 834, 846, 863, 870, 875, 884, 895, 906, 919, 934, 945, 958, 973, 980, 993, 1006, 1023, 1038, 1051, 1065, 1079, 1095, 1115, 1127, 1150, 1171, 1193, 1211, 1234, 1249, 1273, 1291, 1308, 1326, 1335, 1345, 1361, 1383, 1396, 1412, 1424, 1438, 1454, 1472, 1492, 1514, 1528, 1543, 1551, 1557, 1571, 1586, 1596, 1612, 1627, 1637, 1645, 1652, 1661, 1674, 1690, 1705, 1714, 1725, 1734, 1743, 1756, 1765, 1778, 1791, 1798, 1808, 1823}
-
-func (i actionType) String() string {
-	if i < 0 || i >= actionType(len(_actionType_index)-1) {
-		return "actionType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _actionType_name[_actionType_index[i]:_actionType_index[i+1]]
-}
--- a/src/algo/algo.go
+++ b/src/algo/algo.go
@@ -80,7 +80,6 @@ Scoring criteria
 import (
 	"bytes"
 	"fmt"
-	"os"
 	"strings"
 	"unicode"
 	"unicode/utf8"
@@ -90,10 +89,6 @@ import (

 var DEBUG bool

-var delimiterChars = "/,:;|"
-
-const whiteChars = " \t\n\v\f\r\x85\xA0"
-
 func indexAt(index int, max int, forward bool) int {
 	if forward {
 		return index
@@ -145,78 +140,16 @@ const (
 	bonusFirstCharMultiplier = 2
 )

-var (
-	// Extra bonus for word boundary after whitespace character or beginning of the string
-	bonusBoundaryWhite int16 = bonusBoundary + 2
-
-	// Extra bonus for word boundary after slash, colon, semi-colon, and comma
-	bonusBoundaryDelimiter int16 = bonusBoundary + 1
-
-	initialCharClass = charWhite
-
-	// A minor optimization that can give 15%+ performance boost
-	asciiCharClasses [unicode.MaxASCII + 1]charClass
-
-	// A minor optimization that can give yet another 5% performance boost
-	bonusMatrix [charNumber + 1][charNumber + 1]int16
-)
-
 type charClass int

 const (
-	charWhite charClass = iota
-	charNonWord
-	charDelimiter
+	charNonWord charClass = iota
 	charLower
 	charUpper
 	charLetter
 	charNumber
 )

-func Init(scheme string) bool {
-	switch scheme {
-	case "default":
-		bonusBoundaryWhite = bonusBoundary + 2
-		bonusBoundaryDelimiter = bonusBoundary + 1
-	case "path":
-		bonusBoundaryWhite = bonusBoundary
-		bonusBoundaryDelimiter = bonusBoundary + 1
-		if os.PathSeparator == '/' {
-			delimiterChars = "/"
-		} else {
-			delimiterChars = string([]rune{os.PathSeparator, '/'})
-		}
-		initialCharClass = charDelimiter
-	case "history":
-		bonusBoundaryWhite = bonusBoundary
-		bonusBoundaryDelimiter = bonusBoundary
-	default:
-		return false
-	}
-	for i := 0; i <= unicode.MaxASCII; i++ {
-		char := rune(i)
-		c := charNonWord
-		if char >= 'a' && char <= 'z' {
-			c = charLower
-		} else if char >= 'A' && char <= 'Z' {
-			c = charUpper
-		} else if char >= '0' && char <= '9' {
-			c = charNumber
-		} else if strings.ContainsRune(whiteChars, char) {
-			c = charWhite
-		} else if strings.ContainsRune(delimiterChars, char) {
-			c = charDelimiter
-		}
-		asciiCharClasses[i] = c
-	}
-	for i := 0; i <= int(charNumber); i++ {
-		for j := 0; j <= int(charNumber); j++ {
-			bonusMatrix[i][j] = bonusFor(charClass(i), charClass(j))
-		}
-	}
-	return true
-}
-
 func posArray(withPos bool, len int) *[]int {
 	if withPos {
 		pos := make([]int, 0, len)
@@ -241,6 +174,17 @@ func alloc32(offset int, slab *util.Slab, size int) (int, []int32) {
 	return offset, make([]int32, size)
 }

+func charClassOfAscii(char rune) charClass {
+	if char >= 'a' && char <= 'z' {
+		return charLower
+	} else if char >= 'A' && char <= 'Z' {
+		return charUpper
+	} else if char >= '0' && char <= '9' {
+		return charNumber
+	}
+	return charNonWord
+}
+
 func charClassOfNonAscii(char rune) charClass {
 	if unicode.IsLower(char) {
 		return charLower
@@ -250,56 +194,36 @@ func charClassOfNonAscii(char rune) charClass {
 		return charNumber
 	} else if unicode.IsLetter(char) {
 		return charLetter
-	} else if unicode.IsSpace(char) {
-		return charWhite
-	} else if strings.ContainsRune(delimiterChars, char) {
-		return charDelimiter
 	}
 	return charNonWord
 }

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

 func bonusFor(prevClass charClass, class charClass) int16 {
-	if class > charNonWord {
-		switch prevClass {
-		case charWhite:
-			// Word boundary after whitespace
-			return bonusBoundaryWhite
-		case charDelimiter:
-			// Word boundary after a delimiter character
-			return bonusBoundaryDelimiter
-		case charNonWord:
-			// Word boundary
-			return bonusBoundary
-		}
-	}
-
-	if prevClass == charLower && class == charUpper ||
+	if prevClass == charNonWord && class != charNonWord {
+		// Word boundary
+		return bonusBoundary
+	} else 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:
-		return bonusBoundaryWhite
 	}
 	return 0
 }

 func bonusAt(input *util.Chars, idx int) int16 {
 	if idx == 0 {
-		return bonusBoundaryWhite
+		return bonusBoundary
 	}
-	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 +276,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) {
@@ -401,7 +310,7 @@ func debugV2(T []rune, pattern []rune, F []int32, lastIdx int, H []int16, C []in
 		if i == 0 {
 			fmt.Print("  ")
 			for j := int(f); j <= lastIdx; j++ {
-				fmt.Print(" " + string(T[j]) + " ")
+				fmt.Printf(" " + string(T[j]) + " ")
 			}
 			fmt.Println()
 		}
@@ -439,9 +348,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 +356,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 +372,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 {
+	pchar0, pchar, prevH0, prevClass, inGap := pattern[0], pattern[0], int16(0), charNonWord, false
+	Tsub := T[idx:]
+	H0sub, C0sub, Bsub := H0[idx:][:len(Tsub)], C0[idx:][:len(Tsub)], B[idx:][:len(Tsub)]
+	for off, char := range Tsub {
 		var class charClass
 		if char <= unicode.MaxASCII {
-			class = asciiCharClasses[char]
+			class = charClassOfAscii(char)
 			if !caseSensitive && class == charUpper {
 				char += 32
-				T[off] = char
 			}
 		} else {
 			class = charClassOfNonAscii(char)
@@ -490,53 +395,53 @@ 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
-				if forward && bonus >= bonusBoundary {
+				maxScore, maxScorePos = score, idx+off
+				if forward && bonus == bonusBoundary {
 					break
 				}
 			}
 			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
 	}

@@ -581,14 +486,11 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 				s1 = Hdiag[off] + scoreMatch
 				b := Bsub[off]
 				consecutive = Cdiag[off] + 1
-				if consecutive > 1 {
-					fb := B[col-int(consecutive)+1]
-					// Break consecutive chunk
-					if b >= bonusBoundary && b > fb {
-						consecutive = 1
-					} else {
-						b = util.Max16(b, util.Max16(bonusConsecutive, fb))
-					}
+				// Break consecutive chunk
+				if b == bonusBoundary {
+					consecutive = 1
+				} else if consecutive > 1 {
+					b = util.Max16(b, util.Max16(bonusConsecutive, B[col-int(consecutive)+1]))
 				}
 				if s1+b < s2 {
 					s1 += Bsub[off]
@@ -633,7 +535,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,14 +548,14 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	// Start offset we return here is only relevant when begin tiebreak is used.
 	// However finding the accurate offset requires backtracking, and we don't
 	// want to pay extra cost for the option that has lost its importance.
-	return Result{minIdx + j, minIdx + maxScorePos + 1, int(maxScore)}, pos
+	return Result{j, maxScorePos + 1, int(maxScore)}, pos
 }

 // Implement the same sorting criteria as V2
 func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, pattern []rune, sidx int, eidx int, withPos bool) (int, *[]int) {
 	pidx, score, inGap, consecutive, firstBonus := 0, 0, false, 0, int16(0)
 	pos := posArray(withPos, len(pattern))
-	prevClass := initialCharClass
+	prevClass := charNonWord
 	if sidx > 0 {
 		prevClass = charClassOf(text.Get(sidx - 1))
 	}
@@ -676,12 +578,12 @@ 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 {
 				// Break consecutive chunk
-				if bonus >= bonusBoundary && bonus > firstBonus {
+				if bonus == bonusBoundary {
 					firstBonus = bonus
 				}
 				bonus = util.Max16(util.Max16(bonus, firstBonus), bonusConsecutive)
@@ -714,8 +616,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
 	}

@@ -767,9 +668,6 @@ func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text *util.C
 					char = unicode.To(unicode.LowerCase, char)
 				}
 			}
-			if normalize {
-				char = normalizeRune(char)
-			}

 			pidx_ := indexAt(pidx, lenPattern, forward)
 			pchar := pattern[pidx_]
@@ -801,14 +699,6 @@ func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text *util.C
 // The solution is much cheaper since there is only one possible alignment of
 // the pattern.
 func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
-	return exactMatchNaive(caseSensitive, normalize, forward, false, text, pattern, withPos, slab)
-}
-
-func ExactMatchBoundary(caseSensitive bool, normalize bool, forward bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
-	return exactMatchNaive(caseSensitive, normalize, forward, true, text, pattern, withPos, slab)
-}
-
-func exactMatchNaive(caseSensitive bool, normalize bool, forward bool, boundaryCheck bool, text *util.Chars, pattern []rune, withPos bool, slab *util.Slab) (Result, *[]int) {
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
@@ -820,8 +710,7 @@ func exactMatchNaive(caseSensitive bool, normalize bool, forward bool, boundaryC
 		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
 	}

@@ -843,28 +732,16 @@ func exactMatchNaive(caseSensitive bool, normalize bool, forward bool, boundaryC
 		}
 		pidx_ := indexAt(pidx, lenPattern, forward)
 		pchar := pattern[pidx_]
-		ok := pchar == char
-		if ok {
+		if pchar == char {
 			if pidx_ == 0 {
 				bonus = bonusAt(text, index_)
 			}
-			if boundaryCheck {
-				ok = bonus >= bonusBoundary
-				if ok && pidx_ == 0 {
-					ok = index_ == 0 || charClassOf(text.Get(index_-1)) <= charDelimiter
-				}
-				if ok && pidx_ == len(pattern)-1 {
-					ok = index_ == lenRunes-1 || charClassOf(text.Get(index_+1)) <= charDelimiter
-				}
-			}
-		}
-		if ok {
 			pidx++
 			if pidx == lenPattern {
 				if bonus > bestBonus {
 					bestPos, bestBonus = index, bonus
 				}
-				if bonus >= bonusBoundary {
+				if bonus == bonusBoundary {
 					break
 				}
 				index -= pidx - 1
@@ -884,23 +761,7 @@ func exactMatchNaive(caseSensitive bool, normalize bool, forward bool, boundaryC
 			sidx = lenRunes - (bestPos + 1)
 			eidx = lenRunes - (bestPos - lenPattern + 1)
 		}
-		var score int
-		if boundaryCheck {
-			// Underscore boundaries should be ranked lower than the other types of boundaries
-			score = int(bonus)
-			deduct := int(bonus-bonusBoundary) + 1
-			if sidx > 0 && text.Get(sidx-1) == '_' {
-				score -= deduct + 1
-				deduct = 1
-			}
-			if eidx < lenRunes && text.Get(eidx) == '_' {
-				score -= deduct
-			}
-			// Add base score so that this can compete with other match types e.g. 'foo' | bar
-			score += scoreMatch*lenPattern + int(bonusBoundaryWhite)*(lenPattern+1)
-		} else {
-			score, _ = calculateScore(caseSensitive, normalize, text, pattern, sidx, eidx, false)
-		}
+		score, _ := calculateScore(caseSensitive, normalize, text, pattern, sidx, eidx, false)
 		return Result{sidx, eidx, score}, nil
 	}
 	return Result{-1, -1, 0}, nil
@@ -1016,8 +877,8 @@ func EqualMatch(caseSensitive bool, normalize bool, forward bool, text *util.Cha
 		match = runesStr == string(pattern)
 	}
 	if match {
-		return Result{trimmedLen, trimmedLen + lenPattern, (scoreMatch+int(bonusBoundaryWhite))*lenPattern +
-			(bonusFirstCharMultiplier-1)*int(bonusBoundaryWhite)}, nil
+		return Result{trimmedLen, trimmedLen + lenPattern, (scoreMatch+bonusBoundary)*lenPattern +
+			(bonusFirstCharMultiplier-1)*bonusBoundary}, nil
 	}
 	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)
 }
@@ -49,29 +45,29 @@ func TestFuzzyMatch(t *testing.T) {
 			assertMatch(t, fn, false, forward, "fooBarbaz1", "oBZ", 2, 9,
 				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtension*3)
 			assertMatch(t, fn, false, forward, "foo bar baz", "fbb", 0, 9,
-				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
-					int(bonusBoundaryWhite)*2+2*scoreGapStart+4*scoreGapExtension)
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
+					bonusBoundary*2+2*scoreGapStart+4*scoreGapExtension)
 			assertMatch(t, fn, false, forward, "/AutomatorDocument.icns", "rdoc", 9, 13,
 				scoreMatch*4+bonusCamel123+bonusConsecutive*2)
 			assertMatch(t, fn, false, forward, "/man1/zshcompctl.1", "zshc", 6, 10,
-				scoreMatch*4+int(bonusBoundaryDelimiter)*bonusFirstCharMultiplier+int(bonusBoundaryDelimiter)*3)
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3)
 			assertMatch(t, fn, false, forward, "/.oh-my-zsh/cache", "zshc", 8, 13,
-				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*2+scoreGapStart+int(bonusBoundaryDelimiter))
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3+scoreGapStart)
 			assertMatch(t, fn, false, forward, "ab0123 456", "12356", 3, 10,
 				scoreMatch*5+bonusConsecutive*3+scoreGapStart+scoreGapExtension)
 			assertMatch(t, fn, false, forward, "abc123 456", "12356", 3, 10,
 				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+bonusConsecutive+scoreGapStart+scoreGapExtension)
 			assertMatch(t, fn, false, forward, "foo/bar/baz", "fbb", 0, 9,
-				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
-					int(bonusBoundaryDelimiter)*2+2*scoreGapStart+4*scoreGapExtension)
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
+					bonusBoundary*2+2*scoreGapStart+4*scoreGapExtension)
 			assertMatch(t, fn, false, forward, "fooBarBaz", "fbb", 0, 7,
-				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+
 					bonusCamel123*2+2*scoreGapStart+2*scoreGapExtension)
 			assertMatch(t, fn, false, forward, "foo barbaz", "fbb", 0, 8,
-				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)+
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary+
 					scoreGapStart*2+scoreGapExtension*3)
 			assertMatch(t, fn, false, forward, "fooBar Baz", "foob", 0, 4,
-				scoreMatch*4+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)*3)
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*3)
 			assertMatch(t, fn, false, forward, "xFoo-Bar Baz", "foo-b", 1, 6,
 				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+
 					bonusNonWord+bonusBoundary)
@@ -79,14 +75,14 @@ func TestFuzzyMatch(t *testing.T) {
 			assertMatch(t, fn, true, forward, "fooBarbaz", "oBz", 2, 9,
 				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtension*3)
 			assertMatch(t, fn, true, forward, "Foo/Bar/Baz", "FBB", 0, 9,
-				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryDelimiter)*2+
+				scoreMatch*3+bonusBoundary*(bonusFirstCharMultiplier+2)+
 					scoreGapStart*2+scoreGapExtension*4)
 			assertMatch(t, fn, true, forward, "FooBarBaz", "FBB", 0, 7,
-				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+bonusCamel123*2+
+				scoreMatch*3+bonusBoundary*bonusFirstCharMultiplier+bonusCamel123*2+
 					scoreGapStart*2+scoreGapExtension*2)
 			assertMatch(t, fn, true, forward, "FooBar Baz", "FooB", 0, 4,
-				scoreMatch*4+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)*2+
-					util.Max(bonusCamel123, int(bonusBoundaryWhite)))
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*2+
+					util.Max(bonusCamel123, bonusBoundary))

 			// Consecutive bonus updated
 			assertMatch(t, fn, true, forward, "foo-bar", "o-ba", 2, 6,
@@ -102,10 +98,10 @@ func TestFuzzyMatch(t *testing.T) {

 func TestFuzzyMatchBackward(t *testing.T) {
 	assertMatch(t, FuzzyMatchV1, false, true, "foobar fb", "fb", 0, 4,
-		scoreMatch*2+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+		scoreMatch*2+bonusBoundary*bonusFirstCharMultiplier+
 			scoreGapStart+scoreGapExtension)
 	assertMatch(t, FuzzyMatchV1, false, false, "foobar fb", "fb", 7, 9,
-		scoreMatch*2+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite))
+		scoreMatch*2+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary)
 }

 func TestExactMatchNaive(t *testing.T) {
@@ -118,9 +114,9 @@ func TestExactMatchNaive(t *testing.T) {
 		assertMatch(t, ExactMatchNaive, false, dir, "/AutomatorDocument.icns", "rdoc", 9, 13,
 			scoreMatch*4+bonusCamel123+bonusConsecutive*2)
 		assertMatch(t, ExactMatchNaive, false, dir, "/man1/zshcompctl.1", "zshc", 6, 10,
-			scoreMatch*4+int(bonusBoundaryDelimiter)*(bonusFirstCharMultiplier+3))
+			scoreMatch*4+bonusBoundary*(bonusFirstCharMultiplier+3))
 		assertMatch(t, ExactMatchNaive, false, dir, "/.oh-my-zsh/cache", "zsh/c", 8, 13,
-			scoreMatch*5+bonusBoundary*(bonusFirstCharMultiplier+3)+int(bonusBoundaryDelimiter))
+			scoreMatch*5+bonusBoundary*(bonusFirstCharMultiplier+4))
 	}
 }

@@ -132,7 +128,7 @@ func TestExactMatchNaiveBackward(t *testing.T) {
 }

 func TestPrefixMatch(t *testing.T) {
-	score := scoreMatch*3 + int(bonusBoundaryWhite)*bonusFirstCharMultiplier + int(bonusBoundaryWhite)*2
+	score := (scoreMatch+bonusBoundary)*3 + bonusBoundary*(bonusFirstCharMultiplier-1)

 	for _, dir := range []bool{true, false} {
 		assertMatch(t, PrefixMatch, true, dir, "fooBarbaz", "Foo", -1, -1, 0)
@@ -160,10 +156,9 @@ func TestSuffixMatch(t *testing.T) {
 		// Strip trailing white space from the string
 		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz", 6, 9,
 			scoreMatch*3+bonusConsecutive*2)
-
 		// Only when the pattern doesn't end with a space
 		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz ", 6, 10,
-			scoreMatch*4+bonusConsecutive*2+int(bonusBoundaryWhite))
+			scoreMatch*4+bonusConsecutive*2+bonusNonWord)
 	}
 }

@@ -187,9 +182,9 @@ func TestNormalize(t *testing.T) {
 				input, pattern, sidx, eidx, score)
 		}
 	}
-	test("Só Danço Samba", "So", 0, 2, 62, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, ExactMatchNaive)
-	test("Só Danço Samba", "sodc", 0, 7, 97, FuzzyMatchV1, FuzzyMatchV2)
-	test("Danço", "danco", 0, 5, 140, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, SuffixMatch, ExactMatchNaive, EqualMatch)
+	test("Só Danço Samba", "So", 0, 2, 56, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, ExactMatchNaive)
+	test("Só Danço Samba", "sodc", 0, 7, 89, FuzzyMatchV1, FuzzyMatchV2)
+	test("Danço", "danco", 0, 5, 128, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, SuffixMatch, ExactMatchNaive, EqualMatch)
 }

 func TestLongString(t *testing.T) {
@@ -200,12 +195,3 @@ func TestLongString(t *testing.T) {
 	bytes[math.MaxUint16] = 'z'
 	assertMatch(t, FuzzyMatchV2, true, true, string(bytes), "zx", math.MaxUint16, math.MaxUint16+2, scoreMatch*2+bonusConsecutive)
 }
-
-func TestLongStringWithNormalize(t *testing.T) {
-	bytes := make([]byte, 30000)
-	for i := range bytes {
-		bytes[i] = 'x'
-	}
-	unicodeString := string(bytes) + " Minímal example"
-	assertMatch2(t, FuzzyMatchV1, false, true, false, unicodeString, "minim", 30001, 30006, 140)
-}
--- 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
@@ -1,7 +1,6 @@
 package fzf

 import (
-	"fmt"
 	"strconv"
 	"strings"
 	"unicode/utf8"
@@ -14,28 +13,22 @@ type ansiOffset struct {
 	color  ansiState
 }

-type url struct {
-	uri    string
-	params string
-}
-
 type ansiState struct {
 	fg   tui.Color
 	bg   tui.Color
 	attr tui.Attr
 	lbg  tui.Color
-	url  *url
 }

 func (s *ansiState) colored() bool {
-	return s.fg != -1 || s.bg != -1 || s.attr > 0 || s.lbg >= 0 || s.url != nil
+	return s.fg != -1 || s.bg != -1 || s.attr > 0 || s.lbg >= 0
 }

 func (s *ansiState) equals(t *ansiState) bool {
 	if t == nil {
 		return !s.colored()
 	}
-	return s.fg == t.fg && s.bg == t.bg && s.attr == t.attr && s.lbg == t.lbg && s.url == t.url
+	return s.fg == t.fg && s.bg == t.bg && s.attr == t.attr && s.lbg == t.lbg
 }

 func (s *ansiState) ToString() string {
@@ -44,7 +37,7 @@ func (s *ansiState) ToString() string {
 	}

 	ret := ""
-	if s.attr&tui.Bold > 0 || s.attr&tui.BoldForce > 0 {
+	if s.attr&tui.Bold > 0 {
 		ret += "1;"
 	}
 	if s.attr&tui.Dim > 0 {
@@ -62,16 +55,9 @@ func (s *ansiState) ToString() string {
 	if s.attr&tui.Reverse > 0 {
 		ret += "7;"
 	}
-	if s.attr&tui.StrikeThrough > 0 {
-		ret += "9;"
-	}
 	ret += toAnsiString(s.fg, 30) + toAnsiString(s.bg, 40)

-	ret = "\x1b[" + strings.TrimSuffix(ret, ";") + "m"
-	if s.url != nil {
-		ret = fmt.Sprintf("\x1b]8;%s;%s\x1b\\%s\x1b]8;;\x1b", s.url.params, s.url.uri, ret)
-	}
-	return ret
+	return "\x1b[" + strings.TrimSuffix(ret, ";") + "m"
 }

 func toAnsiString(color tui.Color, offset int) string {
@@ -98,65 +84,49 @@ func isPrint(c uint8) bool {
 	return '\x20' <= c && c <= '\x7e'
 }

-func matchOperatingSystemCommand(s string, start int) int {
-	// `\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)`
-	//                 ^ match starting here after the first printable character
+func matchOperatingSystemCommand(s string) int {
+	// `\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)`
+	//                        ^ match starting here
 	//
-	i := start // prefix matched in nextAnsiEscapeSequence()
+	i := 5 // prefix matched in nextAnsiEscapeSequence()
 	for ; i < len(s) && isPrint(s[i]); i++ {
 	}
 	if i < len(s) {
 		if s[i] == '\x07' {
 			return i + 1
 		}
-		// `\x1b]8;PARAMS;URI\x1b\\TITLE\x1b]8;;\x1b`
-		//                   ------
 		if s[i] == '\x1b' && i < len(s)-1 && s[i+1] == '\\' {
 			return i + 2
 		}
 	}
-
-	// `\x1b]8;PARAMS;URI\x1b\\TITLE\x1b]8;;\x1b`
-	//                              ------------
-	if i < len(s) && s[:i+1] == "\x1b]8;;\x1b" {
-		return i + 1
-	}
-
 	return -1
 }

 func matchControlSequence(s string) int {
-	// `\x1b[\\[()][0-9;:?]*[a-zA-Z@]`
-	//                     ^ match starting here
+	// `\x1b[\\[()][0-9;?]*[a-zA-Z@]`
+	//                    ^ match starting here
 	//
 	i := 2 // prefix matched in nextAnsiEscapeSequence()
-	for ; i < len(s); i++ {
+	for ; i < len(s) && (isNumeric(s[i]) || s[i] == ';' || s[i] == '?'); i++ {
+	}
+	if i < len(s) {
 		c := s[i]
-		switch c {
-		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ';', ':', '?':
-			// ok
-		default:
-			if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '@' {
-				return i + 1
-			}
-			return -1
+		if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '@' {
+			return i + 1
 		}
 	}
 	return -1
 }

 func isCtrlSeqStart(c uint8) bool {
-	switch c {
-	case '\\', '[', '(', ')':
-		return true
-	}
-	return false
+	return c == '\\' || c == '[' || c == '(' || c == ')'
 }

 // nextAnsiEscapeSequence returns the ANSI escape sequence and is equivalent to
 // calling FindStringIndex() on the below regex (which was originally used):
 //
-// "(?:\x1b[\\[()][0-9;:?]*[a-zA-Z@]|\x1b][0-9]+[;:][[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)"
+// "(?:\x1b[\\[()][0-9;?]*[a-zA-Z@]|\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)"
+//
 func nextAnsiEscapeSequence(s string) (int, int) {
 	// fast check for ANSI escape sequences
 	i := 0
@@ -184,27 +154,19 @@ Loop:
 				return i - n, i + 1
 			}
 		case '\x1b':
-			// match: `\x1b[\\[()][0-9;:?]*[a-zA-Z@]`
+			// match: `\x1b[\\[()][0-9;?]*[a-zA-Z@]`
 			if i+2 < len(s) && isCtrlSeqStart(s[i+1]) {
 				if j := matchControlSequence(s[i:]); j != -1 {
 					return i, i + j
 				}
 			}

-			// match: `\x1b][0-9]+[;:][[:print:]]+(?:\x1b\\\\|\x07)`
-			if i+5 < len(s) && s[i+1] == ']' {
-				j := 2
-				// \x1b][0-9]+[;:][[:print:]]+(?:\x1b\\\\|\x07)
-				//      ------
-				for ; i+j < len(s) && isNumeric(s[i+j]); j++ {
-				}
+			// match: `\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)`
+			if i+5 < len(s) && s[i+1] == ']' && isNumeric(s[i+2]) &&
+				s[i+3] == ';' && isPrint(s[i+4]) {

-				// \x1b][0-9]+[;:][[:print:]]+(?:\x1b\\\\|\x07)
-				//            ---------------
-				if j > 2 && i+j+1 < len(s) && (s[i+j] == ';' || s[i+j] == ':') && isPrint(s[i+j+1]) {
-					if k := matchOperatingSystemCommand(s[i:], j+2); k != -1 {
-						return i, i + k
-					}
+				if j := matchOperatingSystemCommand(s[i:]); j != -1 {
+					return i, i + j
 				}
 			}

@@ -320,13 +282,7 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo

 func parseAnsiCode(s string) (int, string) {
 	var remaining string
-	var i int
-	// Faster than strings.IndexAny(";:")
-	i = strings.IndexByte(s, ';')
-	if i < 0 {
-		i = strings.IndexByte(s, ':')
-	}
-	if i >= 0 {
+	if i := strings.IndexByte(s, ';'); i >= 0 {
 		remaining = s[i+1:]
 		s = s[:i]
 	}
@@ -335,7 +291,7 @@ func parseAnsiCode(s string) (int, string) {
 		// Inlined version of strconv.Atoi() that only handles positive
 		// integers and does not allocate on error.
 		code := 0
-		for _, ch := range stringBytes(s) {
+		for _, ch := range []byte(s) {
 			ch -= '0'
 			if ch > 9 {
 				return -1, remaining
@@ -351,26 +307,13 @@ func parseAnsiCode(s string) (int, string) {
 func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 	var state ansiState
 	if prevState == nil {
-		state = ansiState{-1, -1, 0, -1, nil}
+		state = ansiState{-1, -1, 0, -1}
 	} else {
-		state = ansiState{prevState.fg, prevState.bg, prevState.attr, prevState.lbg, prevState.url}
+		state = ansiState{prevState.fg, prevState.bg, prevState.attr, prevState.lbg}
 	}
 	if ansiCode[0] != '\x1b' || ansiCode[1] != '[' || ansiCode[len(ansiCode)-1] != 'm' {
 		if prevState != nil && strings.HasSuffix(ansiCode, "0K") {
 			state.lbg = prevState.bg
-		} else if strings.HasPrefix(ansiCode, "\x1b]8;") && (strings.HasSuffix(ansiCode, "\x1b\\") || strings.HasSuffix(ansiCode, "\a")) {
-			stLen := 2
-			if strings.HasSuffix(ansiCode, "\a") {
-				stLen = 1
-			}
-			// "\x1b]8;;\x1b\\" or "\x1b]8;;\a"
-			if len(ansiCode) == 5+stLen && ansiCode[4] == ';' {
-				state.url = nil
-			} else if paramsEnd := strings.IndexRune(ansiCode[4:], ';'); paramsEnd >= 0 {
-				params := ansiCode[4 : 4+paramsEnd]
-				uri := ansiCode[5+paramsEnd : len(ansiCode)-stLen]
-				state.url = &url{uri: uri, params: params}
-			}
 		}
 		return state
 	}
@@ -386,11 +329,9 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 	state256 := 0
 	ptr := &state.fg

-	count := 0
 	for len(ansiCode) != 0 {
 		var num int
 		if num, ansiCode = parseAnsiCode(ansiCode); num != -1 {
-			count++
 			switch state256 {
 			case 0:
 				switch num {
@@ -416,21 +357,10 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 					state.attr = state.attr | tui.Blink
 				case 7:
 					state.attr = state.attr | tui.Reverse
-				case 9:
-					state.attr = state.attr | tui.StrikeThrough
-				case 22:
-					state.attr = state.attr &^ tui.Bold
-					state.attr = state.attr &^ tui.Dim
 				case 23: // tput rmso
 					state.attr = state.attr &^ tui.Italic
 				case 24: // tput rmul
 					state.attr = state.attr &^ tui.Underline
-				case 25:
-					state.attr = state.attr &^ tui.Blink
-				case 27:
-					state.attr = state.attr &^ tui.Reverse
-				case 29:
-					state.attr = state.attr &^ tui.StrikeThrough
 				case 0:
 					state.fg = -1
 					state.bg = -1
@@ -472,13 +402,6 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 		}
 	}

-	// Empty sequence: reset
-	if count == 0 {
-		state.fg = -1
-		state.bg = -1
-		state.attr = 0
-	}
-
 	if state256 > 0 {
 		*ptr = -1
 	}
--- a/src/ansi_test.go
+++ b/src/ansi_test.go
@@ -15,14 +15,14 @@ import (
 // testing nextAnsiEscapeSequence().
 //
 // References:
-//   - https://github.com/gnachman/iTerm2
-//   - https://web.archive.org/web/20090204053813/http://ascii-table.com/ansi-escape-sequences.php
-//     (archived from http://ascii-table.com/ansi-escape-sequences.php)
-//   - https://web.archive.org/web/20090227051140/http://ascii-table.com/ansi-escape-sequences-vt-100.php
-//     (archived from http://ascii-table.com/ansi-escape-sequences-vt-100.php)
-//   - http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
-//   - https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
-var ansiRegexReference = regexp.MustCompile("(?:\x1b[\\[()][0-9;:]*[a-zA-Z@]|\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)")
+// 	- https://github.com/gnachman/iTerm2
+// 	- https://web.archive.org/web/20090204053813/http://ascii-table.com/ansi-escape-sequences.php
+//      (archived from http://ascii-table.com/ansi-escape-sequences.php)
+// 	- https://web.archive.org/web/20090227051140/http://ascii-table.com/ansi-escape-sequences-vt-100.php
+//      (archived from http://ascii-table.com/ansi-escape-sequences-vt-100.php)
+// 	- http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
+// 	- https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+var ansiRegexReference = regexp.MustCompile("(?:\x1b[\\[()][0-9;]*[a-zA-Z@]|\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)")

 func testParserReference(t testing.TB, str string) {
 	t.Helper()
@@ -335,28 +335,6 @@ func TestExtractColor(t *testing.T) {
 		assert((*offsets)[0], 0, 6, 2, -1, true)
 		assert((*offsets)[1], 6, 11, 200, 100, false)
 	})
-
-	state = nil
-	var color24 tui.Color = (1 << 24) + (180 << 16) + (190 << 8) + 254
-	src = "\x1b[1mhello \x1b[22;1;38:2:180:190:254mworld"
-	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(*offsets) != 2 {
-			t.Fail()
-		}
-		if state.fg != color24 || state.attr != 1 {
-			t.Fail()
-		}
-		assert((*offsets)[0], 0, 6, -1, -1, true)
-		assert((*offsets)[1], 6, 11, color24, -1, true)
-	})
-
-	src = "\x1b]133;A\x1b\\hello \x1b]133;C\x1b\\world"
-	check(func(offsets *[]ansiOffset, state *ansiState) {
-		if len(*offsets) != 1 {
-			t.Fail()
-		}
-		assert((*offsets)[0], 0, 11, color24, -1, true)
-	})
 }

 func TestAnsiCodeStringConversion(t *testing.T) {
@@ -364,15 +342,12 @@ 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, "")
 	assert("\x1b[m", &ansiState{attr: tui.Blink, lbg: -1}, "")
-	assert("\x1b[0m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
-	assert("\x1b[;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
-	assert("\x1b[;;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")

 	assert("\x1b[31m", nil, "\x1b[31;49m")
 	assert("\x1b[41m", nil, "\x1b[39;41m")
@@ -383,7 +358,6 @@ func TestAnsiCodeStringConversion(t *testing.T) {
 	assert("\x1b[31m", &ansiState{fg: 4, bg: 4, lbg: -1}, "\x1b[31;44m")
 	assert("\x1b[1;2;31m", &ansiState{fg: 2, bg: -1, attr: tui.Reverse, lbg: -1}, "\x1b[1;2;7;31;49m")
 	assert("\x1b[38;5;100;48;5;200m", nil, "\x1b[38;5;100;48;5;200m")
-	assert("\x1b[38:5:100:48:5:200m", nil, "\x1b[38;5;100;48;5;200m")
 	assert("\x1b[48;5;100;38;5;200m", nil, "\x1b[38;5;200;48;5;100m")
 	assert("\x1b[48;5;100;38;2;10;20;30;1m", nil, "\x1b[1;38;2;10;20;30;48;5;100m")
 	assert("\x1b[48;5;100;38;2;10;20;30;7m",
@@ -411,9 +385,9 @@ func TestParseAnsiCode(t *testing.T) {
 }

 // kernel/bpf/preload/iterators/README
-const ansiBenchmarkString = "\x1b[38;5;81m\x1b[01;31m\x1b[Kkernel/\x1b[0m\x1b[38:5:81mbpf/" +
-	"\x1b[0m\x1b[38:5:81mpreload/\x1b[0m\x1b[38;5;81miterators/" +
-	"\x1b[0m\x1b[38:5:149mMakefile\x1b[m\x1b[K\x1b[0m"
+const ansiBenchmarkString = "\x1b[38;5;81m\x1b[01;31m\x1b[Kkernel/\x1b[0m\x1b[38;5;81mbpf/" +
+	"\x1b[0m\x1b[38;5;81mpreload/\x1b[0m\x1b[38;5;81miterators/" +
+	"\x1b[0m\x1b[38;5;149mMakefile\x1b[m\x1b[K\x1b[0m"

 func BenchmarkNextAnsiEscapeSequence(b *testing.B) {
 	b.SetBytes(int64(len(ansiBenchmarkString)))
--- 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
@@ -26,7 +26,7 @@ const (
 	previewCancelWait = 500 * time.Millisecond
 	previewChunkDelay = 100 * time.Millisecond
 	previewDelayed    = 500 * time.Millisecond
-	maxPatternLength  = 1000
+	maxPatternLength  = 300
 	maxMulti          = math.MaxInt32

 	// Matcher
@@ -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
@@ -1,9 +1,33 @@
-// Package fzf implements fzf, a command-line fuzzy finder.
+/*
+Package fzf implements fzf, a command-line fuzzy finder.
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2021 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
 package fzf

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

 	"github.com/junegunn/fzf/src/util"
@@ -18,52 +42,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()
-
-	// Output channel given
-	if opts.Output != nil {
-		opts.Printer = func(str string) {
-			opts.Output <- str
-		}
-	}
-
+func Run(opts *Options, version string, revision string) {
 	sort := opts.Sort > 0
 	sortCriteria = opts.Criteria

+	if opts.Version {
+		if len(revision) > 0 {
+			fmt.Printf("%s (%s)\n", version, revision)
+		} else {
+			fmt.Println(version)
+		}
+		os.Exit(exitOk)
+	}
+
 	// Event channel
 	eventBox := util.NewEventBox()

@@ -77,29 +69,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 opts.WithNth == nil {
-		chunkList = NewChunkList(cache, func(item *Item, data []byte) bool {
+	if len(opts.WithNth) == 0 {
+		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,9 +100,8 @@ func Run(opts *Options) (int, error) {
 			return true
 		})
 	} else {
-		nthTransformer := opts.WithNth(opts.Delimiter)
-		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 {
@@ -128,13 +118,14 @@ func Run(opts *Options) (int, error) {
 					}
 				}
 			}
-			transformed := nthTransformer(tokens, itemIndex)
+			trans := Transform(tokens, opts.WithNth)
+			transformed := joinTokens(trans)
 			if len(header) < opts.HeaderLines {
 				header = append(header, transformed)
 				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,83 +134,33 @@ func Run(opts *Options) (int, error) {
 		})
 	}

-	// Process executor
-	executor := util.NewExecutor(opts.WithShell)
-
-	// Terminal I/O
-	var terminal *Terminal
-	var err error
-	var initialEnv []string
-	initialReload := opts.extractReloadOnStart()
-	if opts.Filter == nil {
-		terminal, err = NewTerminal(opts, eventBox, executor)
-		if err != nil {
-			return ExitError, err
-		}
-		if len(initialReload) > 0 {
-			var temps []string
-			initialReload, temps = terminal.replacePlaceholderInInitialCommand(initialReload)
-			initialEnv = terminal.environ()
-			defer removeFiles(temps)
-		}
-	}
-
 	// 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)
-
-		readyChan := make(chan bool)
-		go reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip, initialReload, initialEnv, readyChan)
-		<-readyChan
+		}, eventBox, opts.ReadZero, opts.Filter == nil)
+		go reader.ReadSource()
 	}

 	// Matcher
 	forward := true
-	withPos := false
-	for idx := len(opts.Criteria) - 1; idx > 0; idx-- {
-		switch opts.Criteria[idx] {
-		case byChunk:
-			withPos = true
-		case byEnd:
-			forward = false
-		case byBegin:
-			forward = true
-		case byPathname:
-			withPos = true
+	for _, cri := range opts.Criteria[1:] {
+		if cri == byEnd {
 			forward = false
+			break
 		}
-	}
-
-	nth := opts.Nth
-	inputRevision := revision{}
-	snapshotRevision := revision{}
-	patternCache := make(map[string]*Pattern)
-	denyMutex := sync.Mutex{}
-	denylist := make(map[int32]struct{})
-	clearDenylist := func() {
-		denyMutex.Lock()
-		if len(denylist) > 0 {
-			patternCache = make(map[string]*Pattern)
+		if cri == byBegin {
+			break
 		}
-		denylist = make(map[int32]struct{})
-		denyMutex.Unlock()
 	}
 	patternBuilder := func(runes []rune) *Pattern {
-		denyMutex.Lock()
-		denylistCopy := make(map[int32]struct{})
-		for k, v := range denylist {
-			denylistCopy[k] = v
-		}
-		denyMutex.Unlock()
-		return BuildPattern(cache, patternCache,
-			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward, withPos,
-			opts.Filter == nil, nth, opts.Delimiter, inputRevision, runes, denylistCopy)
+		return BuildPattern(
+			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward,
+			opts.Filter == nil, opts.Nth, opts.Delimiter, runes)
 	}
-	matcher := NewMatcher(cache, patternBuilder, sort, opts.Tac, eventBox, inputRevision)
+	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)

 	// Filtering mode
 	if opts.Filter != nil {
@@ -233,27 +174,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, initialReload, initialEnv, nil)
+				}, 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})
@@ -263,9 +200,9 @@ func Run(opts *Options) (int, error) {
 			}
 		}
 		if found {
-			return ExitOk, nil
+			os.Exit(exitOk)
 		}
-		return ExitNoMatch, nil
+		os.Exit(exitNoMatch)
 	}

 	// Synchronous search
@@ -276,68 +213,40 @@ func Run(opts *Options) (int, error) {

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

-	// Handling adaptive height
-	maxFit := 0 // Maximum number of items that can fit on screen
-	padHeight := 0
-	heightUnknown := opts.Height.auto
-	if heightUnknown {
-		maxFit, padHeight = terminal.MaxFitAndPad()
-	}
-	deferred := opts.Select1 || opts.Exit0 || opts.Sync
+	// Terminal I/O
+	terminal := NewTerminal(opts, eventBox)
+	deferred := opts.Select1 || opts.Exit0
 	go terminal.Loop()
-	if !deferred && !heightUnknown {
-		// Start right away
-		terminal.startChan <- fitpad{-1, -1}
+	if !deferred {
+		terminal.startChan <- true
 	}

 	// Event coordination
 	reading := true
+	clearCache := util.Once(false)
+	clearSelection := util.Once(false)
 	ticks := 0
-	var nextCommand *commandSpec
-	var nextEnviron []string
-	eventBox.Watch(EvtReadNew)
-	total := 0
-	query := []rune{}
-	determine := func(final bool) {
-		if heightUnknown {
-			if total >= maxFit || final {
-				deferred = false
-				heightUnknown = false
-				terminal.startChan <- fitpad{util.Min(total, maxFit), padHeight}
-			}
-		} else if deferred {
-			deferred = false
-			terminal.startChan <- fitpad{-1, -1}
-		}
-	}
-
-	useSnapshot := false
-	var snapshot []*Chunk
-	var count int
-	restart := func(command commandSpec, environ []string) {
-		if !useSnapshot {
-			clearDenylist()
-		}
+	var nextCommand *string
+	restart := func(command string) {
 		reading = true
+		clearCache = util.Once(true)
+		clearSelection = util.Once(true)
 		chunkList.Clear()
 		itemIndex = 0
-		inputRevision.bumpMajor()
 		header = make([]string, 0, opts.HeaderLines)
-		readyChan := make(chan bool)
-		go reader.restart(command, environ, readyChan)
-		<-readyChan
+		go reader.restart(command)
 	}
-
-	exitCode := ExitOk
-	stop := false
+	eventBox.Watch(EvtReadNew)
+	query := []rune{}
 	for {
 		delay := true
 		ticks++
-		input := func() []rune {
+		input := func(reloaded bool) []rune {
 			paused, input := terminal.Input()
-			if !paused {
+			if reloaded && paused {
+				query = []rune{}
+			} else if !paused {
 				query = input
 			}
 			return query
@@ -352,103 +261,43 @@ 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
 					}
-					if useSnapshot && evt == EvtReadFin { // reload-sync
-						clearDenylist()
-						useSnapshot = false
+					snapshot, count := chunkList.Snapshot()
+					terminal.UpdateCount(count, !reading, value.(*string))
+					if opts.Sync {
+						opts.Sync = false
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac), false)
 					}
-					if !useSnapshot {
-						if !snapshotRevision.compatible(inputRevision) {
-							query = []rune{}
-						}
-						var changed bool
-						snapshot, count, changed = chunkList.Snapshot(opts.Tail)
-						if changed {
-							inputRevision.bumpMinor()
-						}
-						snapshotRevision = inputRevision
-					}
-					total = count
-					terminal.UpdateCount(total, !reading, value.(*string))
-					if heightUnknown && !deferred {
-						determine(!reading)
-					}
-					matcher.Reset(snapshot, input(), false, !reading, sort, snapshotRevision)
+					reset := clearCache()
+					matcher.Reset(snapshot, input(reset), false, !reading, sort, reset)

 				case EvtSearchNew:
-					var command *commandSpec
-					var environ []string
-					var changed bool
+					var command *string
 					switch val := value.(type) {
 					case searchRequest:
 						sort = val.sort
 						command = val.command
-						environ = val.environ
-						changed = val.changed
-						bump := false
-						if len(val.denylist) > 0 && val.revision.compatible(inputRevision) {
-							denyMutex.Lock()
-							for _, itemIndex := range val.denylist {
-								denylist[itemIndex] = struct{}{}
-							}
-							denyMutex.Unlock()
-							bump = true
-						}
-						if val.nth != nil {
-							// Change nth and clear caches
-							nth = *val.nth
-							bump = true
-						}
-						if bump {
-							patternCache = make(map[string]*Pattern)
-							cache.Clear()
-							inputRevision.bumpMinor()
-						}
-						if command != nil {
-							useSnapshot = val.sync
-						}
 					}
 					if command != nil {
 						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()
-						}
-						// We want to avoid showing empty list when reload is triggered
-						// and the query string is changed at the same time i.e. command != nil && changed
-						if command == nil || newCount > 0 {
-							if snapshotRevision != inputRevision {
-								query = []rune{}
-							}
-							snapshot = newSnapshot
-							snapshotRevision = inputRevision
-						}
-					}
-					matcher.Reset(snapshot, input(), true, !reading, sort, snapshotRevision)
+					snapshot, _ := chunkList.Snapshot()
+					reset := clearCache()
+					matcher.Reset(snapshot, input(reset), true, !reading, sort, reset)
 					delay = false

 				case EvtSearchProgress:
@@ -468,7 +317,8 @@ func Run(opts *Options) (int, error) {
 						if deferred {
 							count := val.Length()
 							if opts.Select1 && count > 1 || opts.Exit0 && !opts.Select1 && count > 0 {
-								determine(val.final)
+								deferred = false
+								terminal.startChan <- true
 							} else if val.final {
 								if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
 									if opts.PrintQuery {
@@ -477,36 +327,24 @@ func Run(opts *Options) (int, error) {
 									if len(opts.Expect) > 0 {
 										opts.Printer("")
 									}
-									transformer := func(item *Item) string {
-										return item.AsString(opts.Ansi)
-									}
-									if opts.AcceptNth != nil {
-										fn := opts.AcceptNth(opts.Delimiter)
-										transformer = func(item *Item) string {
-											return item.acceptNth(opts.Ansi, opts.Delimiter, fn)
-										}
-									}
 									for i := 0; i < count; i++ {
-										opts.Printer(transformer(val.Get(i).item))
+										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)
+								deferred = false
+								terminal.startChan <- true
 							}
 						}
-						terminal.UpdateList(val)
+						terminal.UpdateList(val, clearSelection())
 					}
 				}
 			}
 			events.Clear()
 		})
-		if stop {
-			break
-		}
 		if delay && reading {
 			dur := util.DurWithin(
 				time.Duration(ticks)*coordinatorDelayStep,
@@ -514,5 +352,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/history.go
+++ b/src/history.go
@@ -2,6 +2,7 @@ package fzf

 import (
 	"errors"
+	"io/ioutil"
 	"os"
 	"strings"
 )
@@ -25,12 +26,12 @@ func NewHistory(path string, maxSize int) (*History, error) {
 	}

 	// Read history file
-	data, err := os.ReadFile(path)
+	data, err := ioutil.ReadFile(path)
 	if err != nil {
 		// If it doesn't exist, check if we can create a file with the name
 		if os.IsNotExist(err) {
 			data = []byte{}
-			if err := os.WriteFile(path, data, 0600); err != nil {
+			if err := ioutil.WriteFile(path, data, 0600); err != nil {
 				return nil, fmtError(err)
 			}
 		} else {
@@ -61,11 +62,11 @@ func (h *History) append(line string) error {
 		lines = lines[len(lines)-h.maxSize:]
 	}
 	h.lines = append(lines, "")
-	return os.WriteFile(h.path, []byte(strings.Join(h.lines, "\n")), 0600)
+	return ioutil.WriteFile(h.path, []byte(strings.Join(h.lines, "\n")), 0600)
 }

 func (h *History) override(str string) {
-	// You can update the history, but they're not written to the file
+	// You can update the history but they're not written to the file
 	if h.cursor == len(h.lines)-1 {
 		h.lines[h.cursor] = str
 	} else if h.cursor < len(h.lines)-1 {
--- a/src/history_test.go
+++ b/src/history_test.go
@@ -1,6 +1,7 @@
 package fzf

 import (
+	"io/ioutil"
 	"os"
 	"runtime"
 	"testing"
@@ -24,7 +25,7 @@ func TestHistory(t *testing.T) {
 		}
 	}

-	f, _ := os.CreateTemp("", "fzf-history")
+	f, _ := ioutil.TempFile("", "fzf-history")
 	f.Close()

 	{ // Append lines
--- a/src/item.go
+++ b/src/item.go
@@ -1,22 +1,13 @@
 package fzf

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

-type transformed struct {
-	// Because nth can be changed dynamically by change-nth action, we need to
-	// keep the revision number at the time of transformation.
-	revision revision
-	tokens   []Token
-}
-
 // Item represents each input line. 56 bytes.
 type Item struct {
 	text        util.Chars    // 32 = 24 + 1 + 1 + 2 + 4
-	transformed *transformed  // 8
+	transformed *[]Token      // 8
 	origText    *[]byte       // 8
 	colors      *[]ansiOffset // 8
 }
@@ -26,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()
@@ -51,9 +42,3 @@ func (item *Item) AsString(stripAnsi bool) string {
 	}
 	return item.text.ToString()
 }
-
-func (item *Item) acceptNth(stripAnsi bool, delimiter Delimiter, transformer func([]Token, int32) string) string {
-	tokens := Tokenize(item.AsString(stripAnsi), delimiter)
-	transformed := transformer(tokens, item.Index())
-	return StripLastDelimiter(transformed, delimiter)
-}
--- a/src/matcher.go
+++ b/src/matcher.go
@@ -12,16 +12,15 @@ import (

 // MatchRequest represents a search request
 type MatchRequest struct {
-	chunks   []*Chunk
-	pattern  *Pattern
-	final    bool
-	sort     bool
-	revision revision
+	chunks     []*Chunk
+	pattern    *Pattern
+	final      bool
+	sort       bool
+	clearCache bool
 }

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

 const (
@@ -39,11 +37,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) *Matcher {
 	partitions := util.Min(numPartitionsMultiplier*runtime.NumCPU(), maxPartitions)
 	return &Matcher{
-		cache:          cache,
 		patternBuilder: patternBuilder,
 		sort:           sort,
 		tac:            tac,
@@ -51,8 +48,7 @@ func NewMatcher(cache *ChunkCache, patternBuilder func([]rune) *Pattern,
 		reqBox:         util.NewEventBox(),
 		partitions:     partitions,
 		slab:           make([]*util.Slab, partitions),
-		mergerCache:    make(map[string]*Merger),
-		revision:       revision}
+		mergerCache:    make(map[string]*Merger)}
 }

 // Loop puts Matcher in action
@@ -62,13 +58,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 +69,11 @@ func (m *Matcher) Loop() {
 			}
 			events.Clear()
 		})
-		if stop {
-			break
-		}

-		cacheCleared := false
-		if request.sort != m.sort || request.revision != m.revision {
+		if request.sort != m.sort || request.clearCache {
 			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 +82,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 && cached.final == request.final {
-					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)
 		}

@@ -157,14 +140,13 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {

 	numChunks := len(request.chunks)
 	if numChunks == 0 {
-		return EmptyMerger(request.revision), false
+		return EmptyMerger, false
 	}
 	pattern := request.pattern
 	if pattern.IsEmpty() {
-		return PassMerger(&request.chunks, m.tac, request.revision), false
+		return PassMerger(&request.chunks, m.tac), false
 	}

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

 	slices := m.sliceChunks(request.chunks)
@@ -195,7 +177,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 +218,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), 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, clearCache bool) {
 	pattern := m.patternBuilder(patternRunes)

 	var event util.EventType
@@ -249,9 +231,5 @@ func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final
 	} else {
 		event = reqRetry
 	}
-	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort, revision})
-}
-
-func (m *Matcher) Stop() {
-	m.reqBox.Set(reqQuit, nil)
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, clearCache})
 }
--- a/src/merger.go
+++ b/src/merger.go
@@ -3,42 +3,30 @@ package fzf
 import "fmt"

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

 // Merger holds a set of locally sorted lists of items and provides the view of
 // a single, globally-sorted list
 type Merger struct {
-	pattern  *Pattern
-	lists    [][]Result
-	merged   []Result
-	chunks   *[]*Chunk
-	cursors  []int
-	sorted   bool
-	tac      bool
-	final    bool
-	count    int
-	pass     bool
-	revision revision
-	minIndex int32
+	pattern *Pattern
+	lists   [][]Result
+	merged  []Result
+	chunks  *[]*Chunk
+	cursors []int
+	sorted  bool
+	tac     bool
+	final   bool
+	count   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) *Merger {
 	mg := Merger{
-		pattern:  nil,
-		chunks:   chunks,
-		tac:      tac,
-		count:    0,
-		pass:     true,
-		revision: revision,
-		minIndex: minIndex}
+		pattern: nil,
+		chunks:  chunks,
+		tac:     tac,
+		count:   0}

 	for _, chunk := range *mg.chunks {
 		mg.count += chunk.count
@@ -47,19 +35,17 @@ 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) *Merger {
 	mg := Merger{
-		pattern:  pattern,
-		lists:    lists,
-		merged:   []Result{},
-		chunks:   nil,
-		cursors:  make([]int, len(lists)),
-		sorted:   sorted,
-		tac:      tac,
-		final:    false,
-		count:    0,
-		revision: revision,
-		minIndex: minIndex}
+		pattern: pattern,
+		lists:   lists,
+		merged:  []Result{},
+		chunks:  nil,
+		cursors: make([]int, len(lists)),
+		sorted:  sorted,
+		tac:     tac,
+		final:   false,
+		count:   0}

 	for _, list := range mg.lists {
 		mg.count += len(list)
@@ -67,55 +53,17 @@ func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revisi
 	return &mg
 }

-// Revision returns revision number
-func (mg *Merger) Revision() revision {
-	return mg.revision
-}
-
 // Length returns the number of items
 func (mg *Merger) Length() int {
 	return mg.count
 }

-func (mg *Merger) First() Result {
-	if mg.tac && !mg.sorted {
-		return mg.Get(mg.count - 1)
-	}
-	return mg.Get(0)
-}
-
-// FindIndex returns the index of the item with the given item index
-func (mg *Merger) FindIndex(itemIndex int32) int {
-	index := -1
-	if mg.pass {
-		index = int(itemIndex - mg.minIndex)
-		if mg.tac {
-			index = mg.count - index - 1
-		}
-	} else {
-		for i := 0; i < mg.count; i++ {
-			if mg.Get(i).item.Index() == itemIndex {
-				index = i
-				break
-			}
-		}
-	}
-	return index
-}
-
 // Get returns the pointer to the Result object indexed by the given integer
 func (mg *Merger) Get(idx int) Result {
 	if mg.chunks != nil {
 		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.Length() == 0, "Not empty")
+	assert(t, EmptyMerger.count == 0, "Invalid count")
+	assert(t, len(EmptyMerger.lists) == 0, "Invalid lists")
+	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
 }

 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)
 	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)
 	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)
 	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
@@ -2,20 +2,16 @@ package fzf

 import (
 	"fmt"
-	"os"
+	"io/ioutil"
 	"testing"

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

 func TestDelimiterRegex(t *testing.T) {
-	// Valid regex, but a single character -> string
+	// Valid regex
 	delim := delimiterRegexp(".")
-	if delim.regex != nil || *delim.str != "." {
-		t.Error(delim)
-	}
-	delim = delimiterRegexp("|")
-	if delim.regex != nil || *delim.str != "|" {
+	if delim.regex == nil || delim.str != nil {
 		t.Error(delim)
 	}
 	// Broken regex -> string
@@ -84,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 {
@@ -92,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 ||
@@ -110,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)
@@ -123,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)
@@ -132,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)
@@ -142,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)
@@ -168,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.Enter, "Return")
+	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.Enter, "Enter")
-	check(tui.Backspace, "bspace")
+	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.BSpace, "bspace")
 }

 func TestParseKeysWithComma(t *testing.T) {
@@ -211,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-,")
 }
@@ -269,7 +264,7 @@ func TestBind(t *testing.T) {
 	check(tui.CtrlA.AsEvent(), "", actBeginningOfLine)
 	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 {};,"+
+			"f1:execute(ls {+})+abort+execute(echo {+})+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"+
@@ -301,7 +296,7 @@ func TestBind(t *testing.T) {

 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")
 	}
@@ -309,7 +304,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")
 	}
@@ -320,7 +315,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")
 	}
@@ -333,18 +328,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()
@@ -356,23 +350,22 @@ func TestDefaultCtrlNP(t *testing.T) {
 	check([]string{"--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
 	check([]string{"--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)

-	f, _ := os.CreateTemp("", "fzf-history")
+	f, _ := ioutil.TempFile("", "fzf-history")
 	f.Close()
 	hist := "--history=" + f.Name()
 	check([]string{hist}, tui.CtrlN, actNextHistory)
-	check([]string{hist}, tui.CtrlP, actPrevHistory)
+	check([]string{hist}, tui.CtrlP, actPreviousHistory)

 	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
-	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlP, actPrevHistory)
+	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlP, actPreviousHistory)

 	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlN, actNextHistory)
 	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
 }

 func optsFor(words ...string) *Options {
-	index := 0
 	opts := defaultOptions()
-	parseOptions(&index, opts, words)
+	parseOptions(opts, words)
 	postProcessOptions(opts)
 	return opts
 }
@@ -458,6 +451,7 @@ func TestValidateSign(t *testing.T) {
 		{"> ", true},
 		{"아", true},
 		{"😀", true},
+		{"", false},
 		{">>>", false},
 	}

@@ -472,35 +466,3 @@ func TestValidateSign(t *testing.T) {
 		}
 	}
 }
-
-func TestParseSingleActionList(t *testing.T) {
-	actions, _ := parseSingleActionList("Execute@foo+bar,baz@+up+up+reload:down+down")
-	if len(actions) != 4 {
-		t.Errorf("Invalid number of actions parsed:%d", len(actions))
-	}
-	if actions[0].t != actExecute || actions[0].a != "foo+bar,baz" {
-		t.Errorf("Invalid action parsed: %v", actions[0])
-	}
-	if actions[1].t != actUp || actions[2].t != actUp {
-		t.Errorf("Invalid action parsed: %v / %v", actions[1], actions[2])
-	}
-	if actions[3].t != actReload || actions[3].a != "down+down" {
-		t.Errorf("Invalid action parsed: %v", actions[3])
-	}
-}
-
-func TestParseSingleActionListError(t *testing.T) {
-	_, err := parseSingleActionList("change-query(foobar)baz")
-	if err == nil {
-		t.Errorf("Failed to detect error")
-	}
-}
-
-func TestMaskActionContents(t *testing.T) {
-	original := ":execute((f)(o)(o)(b)(a)(r))+change-query@qu@ry@+up,x:reload:hello:world"
-	expected := ":execute                    +change-query       +up,x:reload            "
-	masked := maskActionContents(original)
-	if masked != expected {
-		t.Errorf("Not masked: %s", masked)
-	}
-}
--- a/src/pattern.go
+++ b/src/pattern.go
@@ -23,7 +23,6 @@ type termType int
 const (
 	termFuzzy termType = iota
 	termExact
-	termExactBoundary
 	termPrefix
 	termSuffix
 	termEqual
@@ -52,7 +51,6 @@ type Pattern struct {
 	caseSensitive bool
 	normalize     bool
 	forward       bool
-	withPos       bool
 	text          []rune
 	termSets      []termSet
 	sortable      bool
@@ -60,21 +58,34 @@ type Pattern struct {
 	cacheKey      string
 	delimiter     Delimiter
 	nth           []Range
-	revision      revision
 	procFun       map[termType]algo.Algo
-	cache         *ChunkCache
-	denylist      map[int32]struct{}
 }

-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,
-	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, revision revision, runes []rune, denylist map[int32]struct{}) *Pattern {
+func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
+	cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {

 	var asString string
 	if extended {
@@ -86,9 +97,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
 	}
@@ -136,39 +145,34 @@ func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy boo
 		caseSensitive: caseSensitive,
 		normalize:     normalize,
 		forward:       forward,
-		withPos:       withPos,
 		text:          []rune(asString),
 		termSets:      termSets,
 		sortable:      sortable,
 		cacheable:     cacheable,
 		nth:           nth,
-		revision:      revision,
 		delimiter:     delimiter,
-		cache:         cache,
-		denylist:      denylist,
 		procFun:       make(map[termType]algo.Algo)}

 	ptr.cacheKey = ptr.buildCacheKey()
 	ptr.procFun[termFuzzy] = fuzzyAlgo
 	ptr.procFun[termEqual] = algo.EqualMatch
 	ptr.procFun[termExact] = algo.ExactMatchNaive
-	ptr.procFun[termExactBoundary] = algo.ExactMatchBoundary
 	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
@@ -199,17 +203,15 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 			text = text[:len(text)-1]
 		}

-		if len(text) > 2 && strings.HasPrefix(text, "'") && strings.HasSuffix(text, "'") {
-			typ = termExactBoundary
-			text = text[1 : len(text)-1]
-		} else if strings.HasPrefix(text, "'") {
+		if strings.HasPrefix(text, "'") {
 			// 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
@@ -245,9 +247,6 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet

 // IsEmpty returns true if the pattern is effectively empty
 func (p *Pattern) IsEmpty() bool {
-	if len(p.denylist) > 0 {
-		return false
-	}
 	if !p.extended {
 		return len(p.text) == 0
 	}
@@ -282,18 +281,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
 }
@@ -301,39 +300,15 @@ func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []Result {
 func (p *Pattern) matchChunk(chunk *Chunk, space []Result, slab *util.Slab) []Result {
 	matches := []Result{}

-	if len(p.denylist) == 0 {
-		// Huge code duplication for minimizing unnecessary map lookups
-		if space == nil {
-			for idx := 0; idx < chunk.count; idx++ {
-				if match, _, _ := p.MatchItem(&chunk.items[idx], p.withPos, slab); match != nil {
-					matches = append(matches, *match)
-				}
-			}
-		} else {
-			for _, result := range space {
-				if match, _, _ := p.MatchItem(result.item, p.withPos, slab); match != nil {
-					matches = append(matches, *match)
-				}
-			}
-		}
-		return matches
-	}
-
 	if space == nil {
 		for idx := 0; idx < chunk.count; idx++ {
-			if _, prs := p.denylist[chunk.items[idx].Index()]; prs {
-				continue
-			}
-			if match, _, _ := p.MatchItem(&chunk.items[idx], p.withPos, slab); match != nil {
+			if match, _, _ := p.MatchItem(&chunk.items[idx], false, slab); match != nil {
 				matches = append(matches, *match)
 			}
 		}
 	} else {
 		for _, result := range space {
-			if _, prs := p.denylist[result.item.Index()]; prs {
-				continue
-			}
-			if match, _, _ := p.MatchItem(result.item, p.withPos, slab); match != nil {
+			if match, _, _ := p.MatchItem(result.item, false, slab); match != nil {
 				matches = append(matches, *match)
 			}
 		}
@@ -424,22 +399,12 @@ func (p *Pattern) extendedMatch(item *Item, withPos bool, slab *util.Slab) ([]Of

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

 	tokens := Tokenize(item.text.ToString(), p.delimiter)
 	ret := Transform(tokens, p.nth)
-	// Strip the last delimiter to allow suffix match
-	if len(ret) > 0 && !p.delimiter.IsAwk() {
-		chars := ret[len(ret)-1].text
-		stripped := StripLastDelimiter(chars.ToString(), p.delimiter)
-		newChars := util.ToChars(stringBytes(stripped))
-		ret[len(ret)-1].text = &newChars
-	}
-	item.transformed = &transformed{p.revision, ret}
+	item.transformed = &ret
 	return ret
 }

--- 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, revision{}, runes, nil)
-}
-
 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, 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, 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, true, []Range{}, Delimiter{}, []rune("abc"))
+	clearPatternCache()
+	pat2 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
+	clearPatternCache()
+	pat3 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
+	clearPatternCache()
+	pat4 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
+	clearPatternCache()
+	pat5 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
+	clearPatternCache()
+	pat6 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))

 	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
 		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
@@ -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, true, []Range{}, Delimiter{}, []rune("jg"))
 	tokens := Tokenize("junegunn", Delimiter{})
 	trans := Transform(tokens, []Range{{1, 1}})

@@ -135,12 +139,12 @@ func TestOrigTextAndTransformed(t *testing.T) {
 		chunk.items[0] = Item{
 			text:        util.ToChars([]byte("junegunn")),
 			origText:    &origBytes,
-			transformed: &transformed{pattern.revision, trans}}
+			transformed: &trans}
 		pattern.extended = extended
 		matches := pattern.matchChunk(&chunk, nil, slab) // No cache
 		if !(matches[0].item.text.ToString() == "junegunn" &&
 			string(*matches[0].item.origText) == "junegunn.choi" &&
-			reflect.DeepEqual((*matches[0].item.transformed).tokens, trans)) {
+			reflect.DeepEqual(*matches[0].item.transformed, trans)) {
 			t.Error("Invalid match result", matches)
 		}

@@ -148,7 +152,7 @@ func TestOrigTextAndTransformed(t *testing.T) {
 		if !(match.item.text.ToString() == "junegunn" &&
 			string(*match.item.origText) == "junegunn.choi" &&
 			offsets[0][0] == 0 && offsets[0][1] == 5 &&
-			reflect.DeepEqual((*match.item.transformed).tokens, trans)) {
+			reflect.DeepEqual(*match.item.transformed, trans)) {
 			t.Error("Invalid match result", match, offsets, extended)
 		}
 		if !((*pos)[0] == 4 && (*pos)[1] == 0) {
@@ -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, 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, 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/protector/protector_openbsd.go
+++ b/src/protector/protector_openbsd.go
@@ -6,5 +6,5 @@ import "golang.org/x/sys/unix"

 // Protect calls OS specific protections like pledge on OpenBSD
 func Protect() {
-	unix.PledgePromises("stdio dpath wpath rpath tty proc exec inet tmppath")
+	unix.PledgePromises("stdio rpath tty proc exec")
 }
--- a/src/proxy.go
+++ b/src/proxy.go
@@ -1,161 +0,0 @@
-package fzf
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"os/signal"
-	"path/filepath"
-	"regexp"
-	"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, needBash bool) (*exec.Cmd, error), 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, input 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
-	needBash := false
-	if withExports {
-		validIdentifier := regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`)
-		for _, pairStr := range os.Environ() {
-			pair := strings.SplitN(pairStr, "=", 2)
-			if validIdentifier.MatchString(pair[0]) {
-				exports = append(exports, fmt.Sprintf("export %s=%s", pair[0], escapeSingleQuote(pair[1])))
-			} else if strings.HasPrefix(pair[0], "BASH_FUNC_") && strings.HasSuffix(pair[0], "%%") {
-				name := pair[0][10 : len(pair[0])-2]
-				exports = append(exports, name+pair[1])
-				exports = append(exports, "export -f "+name)
-				needBash = true
-			}
-		}
-	}
-	temp := WriteTemporaryFile(append(exports, command), "\n")
-	defer os.Remove(temp)
-
-	cmd, err := cmdBuilder(temp, needBash)
-	if err != nil {
-		return ExitError, err
-	}
-	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
-				}
-				os.Remove(temp)
-				os.Remove(input)
-				os.Remove(output)
-				executor.Become(ttyin, env, command)
-			}
-			return code, err
-		}
-	}
-
-	return ExitOk, nil
-}
--- a/src/proxy_unix.go
+++ b/src/proxy_unix.go
@@ -1,41 +0,0 @@
-//go:build !windows
-
-package fzf
-
-import (
-	"io"
-	"os"
-
-	"golang.org/x/sys/unix"
-)
-
-func sh(bash bool) (string, error) {
-	if bash {
-		return "bash", nil
-	}
-	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,85 +0,0 @@
-//go:build windows
-
-package fzf
-
-import (
-	"fmt"
-	"io"
-	"os/exec"
-	"strconv"
-	"strings"
-	"sync/atomic"
-)
-
-var shPath atomic.Value
-
-func sh(bash bool) (string, error) {
-	if cached := shPath.Load(); cached != nil {
-		return cached.(string), nil
-	}
-
-	name := "sh"
-	if bash {
-		name = "bash"
-	}
-	cmd := exec.Command("cygpath", "-w", "/usr/bin/"+name)
-	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(false)
-	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(false)
-	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(false)
-	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,50 +1,37 @@
 package fzf

 import (
-	"bytes"
+	"bufio"
 	"context"
 	"io"
-	"io/fs"
 	"os"
+	"os/exec"
 	"path/filepath"
-	"strings"
 	"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
-	killed   bool
-	termFunc func()
+	exec     *exec.Cmd
 	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{},
-		false,
-		func() { os.Stdin.Close() },
-		nil,
-		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() {
@@ -89,151 +76,73 @@ func (r *Reader) fin(success bool) {

 func (r *Reader) terminate() {
 	r.mutex.Lock()
+	defer func() { r.mutex.Unlock() }()
+
 	r.killed = true
-	if r.termFunc != nil {
-		r.termFunc()
-		r.termFunc = nil
+	if r.exec != nil && r.exec.Process != nil {
+		util.KillCommand(r.exec)
+	} else if defaultCommand != "" {
+		os.Stdin.Close()
 	}
-	r.mutex.Unlock()
 }

-func (r *Reader) restart(command commandSpec, environ []string, readyChan chan bool) {
+func (r *Reader) restart(command string) {
 	r.event = int32(EvtReady)
 	r.startEventPoller()
-	success := r.readFromCommand(command.command, environ, func() {
-		readyChan <- true
-	})
+	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, roots []string, opts walkerOpts, ignores []string, initCmd string, initEnv []string, readyChan chan bool) {
+func (r *Reader) ReadSource() {
 	r.startEventPoller()
 	var success bool
-	signalReady := func() {
-		if readyChan != nil {
-			readyChan <- true
-		}
-	}
-	if inputChan != nil {
-		signalReady()
-		success = r.readChannel(inputChan)
-	} else if len(initCmd) > 0 {
-		success = r.readFromCommand(initCmd, initEnv, signalReady)
-	} else if util.IsTty(os.Stdin) {
+	if util.IsTty() {
+		// The default command for *nix requires bash
+		shell := "bash"
 		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
 		if len(cmd) == 0 {
-			signalReady()
-			success = r.readFiles(roots, opts, ignores)
+			if defaultCommand != "" {
+				success = r.readFromCommand(&shell, defaultCommand)
+			} else {
+				success = r.readFiles()
+			}
 		} else {
-			success = r.readFromCommand(cmd, initEnv, signalReady)
+			success = r.readFromCommand(nil, cmd)
 		}
 	} else {
-		signalReady()
 		success = r.readFromStdin()
 	}
 	r.fin(success)
 }

 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]
+					bytea = bytea[:byteaLen-1]
 				}
-				if len(leftover) > 0 {
-					slice = append(leftover, slice...)
-					leftover = []byte{}
-				}
-				if (err == nil || len(slice) > 0) && r.pusher(slice) {
-					atomic.StoreInt32(&r.event, int32(EvtReadNew))
-				}
-			} else {
-				// Could not find the delimiter in the buffer
-				//   NOTE: We can further optimize this by keeping track of the cursor
-				//   position in the slab so that a straddling item that doesn't go
-				//   beyond the boundary of a slab doesn't need to be copied to
-				//   another buffer. However, the performance gain is negligible in
-				//   practice (< 0.1%) and is not
-				//   worth the added complexity.
-				leftover = append(leftover, buf...)
-				break
+			}
+			if 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))
 	}
 }

@@ -242,90 +151,16 @@ func (r *Reader) readFromStdin() bool {
 	return true
 }

-func isSymlinkToDir(path string, de os.DirEntry) bool {
-	if de.Type()&fs.ModeSymlink == 0 {
-		return false
-	}
-	if s, err := os.Stat(path); err == nil {
-		return s.IsDir()
-	}
-	return false
-}
-
-func trimPath(path string) string {
-	bytes := stringBytes(path)
-
-	for len(bytes) > 1 && bytes[0] == '.' && (bytes[1] == '/' || bytes[1] == '\\') {
-		bytes = bytes[2:]
-	}
-
-	if len(bytes) == 0 {
-		return "."
-	}
-
-	return byteString(bytes)
-}
-
-func (r *Reader) readFiles(roots []string, opts walkerOpts, ignores []string) bool {
-	conf := fastwalk.Config{
-		Follow: opts.follow,
-		// Use forward slashes when running a Windows binary under WSL or MSYS
-		ToSlash: fastwalk.DefaultToSlash(),
-		Sort:    fastwalk.SortFilesFirst,
-	}
-	ignoresBase := []string{}
-	ignoresFull := []string{}
-	ignoresSuffix := []string{}
-	sep := string(os.PathSeparator)
-	if _, ok := os.LookupEnv("MSYSTEM"); ok {
-		sep = "/"
-	}
-	for _, ignore := range ignores {
-		if strings.ContainsRune(ignore, os.PathSeparator) {
-			if strings.HasPrefix(ignore, sep) {
-				ignoresSuffix = append(ignoresSuffix, ignore)
-			} else {
-				// 'foo/bar' should match match
-				// * 'foo/bar'
-				// * 'baz/foo/bar'
-				// * but NOT 'bazfoo/bar'
-				ignoresFull = append(ignoresFull, ignore)
-				ignoresSuffix = append(ignoresSuffix, sep+ignore)
-			}
-		} else {
-			ignoresBase = append(ignoresBase, ignore)
-		}
-	}
-	fn := func(path string, de os.DirEntry, err error) error {
-		if err != nil {
-			return nil
-		}
-		path = trimPath(path)
+func (r *Reader) readFiles() bool {
+	r.killed = false
+	fn := func(path string, mode os.FileInfo) error {
+		path = filepath.Clean(path)
 		if path != "." {
-			isDir := de.IsDir()
-			if isDir || opts.follow && isSymlinkToDir(path, de) {
-				base := filepath.Base(path)
-				if !opts.hidden && base[0] == '.' && base != ".." {
-					return filepath.SkipDir
-				}
-				for _, ignore := range ignoresBase {
-					if ignore == base {
-						return filepath.SkipDir
-					}
-				}
-				for _, ignore := range ignoresFull {
-					if ignore == path {
-						return filepath.SkipDir
-					}
-				}
-				for _, ignore := range ignoresSuffix {
-					if strings.HasSuffix(path, ignore) {
-						return filepath.SkipDir
-					}
-				}
-				path += sep
+			isDir := mode.Mode().IsDir()
+			if isDir && filepath.Base(path)[0] == '.' {
+				return filepath.SkipDir
 			}
-			if ((opts.file && !isDir) || (opts.dir && isDir)) && r.pusher(stringBytes(path)) {
+			if !isDir && r.pusher([]byte(path)) {
 				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}
@@ -336,39 +171,31 @@ func (r *Reader) readFiles(roots []string, opts walkerOpts, ignores []string) bo
 		}
 		return nil
 	}
-	noerr := true
-	for _, root := range roots {
-		noerr = noerr && (fastwalk.Walk(&conf, root, fn) == nil)
-	}
-	return noerr
+	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, signalReady func()) bool {
+func (r *Reader) readFromCommand(shell *string, command string) bool {
 	r.mutex.Lock()
-
 	r.killed = false
-	r.termFunc = nil
 	r.command = &command
-	exec := r.executor.ExecCommand(command, true)
-	if environ != nil {
-		exec.Env = environ
+	if shell != nil {
+		r.exec = util.ExecCommandWith(*shell, command, true)
+	} else {
+		r.exec = util.ExecCommand(command, true)
 	}
-	execOut, err := exec.StdoutPipe()
-	if err != nil || exec.Start() != nil {
-		signalReady()
+	out, err := r.exec.StdoutPipe()
+	if err != nil {
 		r.mutex.Unlock()
 		return false
 	}
-
-	// Function to call to terminate the running command
-	r.termFunc = func() {
-		execOut.Close()
-		util.KillCommand(exec)
-	}
-
-	signalReady()
+	err = r.exec.Start()
 	r.mutex.Unlock()
-
-	r.feed(execOut)
-	return exec.Wait() == nil
+	if err != nil {
+		return false
+	}
+	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,12 +22,8 @@ func TestReadFromCommand(t *testing.T) {
 	}

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

@@ -52,9 +47,9 @@ func TestReadFromCommand(t *testing.T) {
 	reader.startEventPoller()

 	// Failing command
-	reader.fin(reader.readFromCommand(`no-such-command`, nil, ready))
+	reader.fin(reader.readFromCommand(nil, `no-such-command`))
 	strs = []string{}
-	if len(strs) > 0 || counter != 2 {
+	if len(strs) > 0 {
 		t.Errorf("%s", strs)
 	}

--- a/src/result.go
+++ b/src/result.go
@@ -15,8 +15,6 @@ type Offset [2]int32
 type colorOffset struct {
 	offset [2]int32
 	color  tui.ColorPair
-	match  bool
-	url    *url
 }

 type Result struct {
@@ -51,39 +49,8 @@ func buildResult(item *Item, offsets []Offset, score int) Result {
 		case byScore:
 			// Higher is better
 			val = math.MaxUint16 - util.AsUint16(score)
-		case byChunk:
-			if validOffsetFound {
-				b := minBegin
-				e := maxEnd
-				for ; b >= 1; b-- {
-					if unicode.IsSpace(item.text.Get(b - 1)) {
-						break
-					}
-				}
-				for ; e < numChars; e++ {
-					if unicode.IsSpace(item.text.Get(e)) {
-						break
-					}
-				}
-				val = util.AsUint16(e - b)
-			}
 		case byLength:
 			val = item.TrimLength()
-		case byPathname:
-			if validOffsetFound {
-				// lastDelim := strings.LastIndexByte(item.text.ToString(), '/')
-				lastDelim := -1
-				s := item.text.ToString()
-				for i := len(s) - 1; i >= 0; i-- {
-					if s[i] == '/' || s[i] == '\\' {
-						lastDelim = i
-						break
-					}
-				}
-				if lastDelim <= minBegin {
-					val = util.AsUint16(minBegin - lastDelim)
-				}
-			}
 		case byBegin, byEnd:
 			if validOffsetFound {
 				whitePrefixLen := 0
@@ -97,7 +64,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()))
 				}
 			}
 		}
@@ -119,21 +86,21 @@ func minRank() Result {
 	return Result{item: &minItem, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
 }

-func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, theme *tui.ColorTheme, colBase tui.ColorPair, colMatch tui.ColorPair, attrNth tui.Attr, current bool) []colorOffset {
+func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme, colBase tui.ColorPair, colMatch tui.ColorPair, current bool) []colorOffset {
 	itemColors := result.item.Colors()

 	// No ANSI codes
-	if len(itemColors) == 0 && len(nthOffsets) == 0 {
+	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
 	}

 	// Find max column
 	var maxCol int32
-	for _, off := range append(matchOffsets, nthOffsets...) {
+	for _, off := range matchOffsets {
 		if off[1] > maxCol {
 			maxCol = off[1]
 		}
@@ -144,29 +111,18 @@ func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, t
 		}
 	}

-	type cellInfo struct {
-		index int
-		color bool
-		match bool
-		nth   bool
-	}
-
-	cols := make([]cellInfo, maxCol)
+	cols := make([]int, maxCol)
 	for colorIndex, ansi := range itemColors {
 		for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
-			cols[i] = cellInfo{colorIndex, true, false, false}
+			cols[i] = colorIndex + 1 // 1-based index of itemColors
 		}
 	}

 	for _, off := range matchOffsets {
 		for i := off[0]; i < off[1]; i++ {
-			cols[i].match = true
-		}
-	}
-
-	for _, off := range nthOffsets {
-		for i := off[0]; i < off[1]; i++ {
-			cols[i].nth = true
+			// Negative of 1-based index of itemColors
+			// - The extra -1 means highlighted
+			cols[i] = cols[i]*-1 - 1
 		}
 	}

@@ -176,7 +132,7 @@ func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, t
 	// ------------  ----  --  ----
 	//   ++++++++      ++++++++++
 	// --++++++++--  --++++++++++---
-	var curr cellInfo = cellInfo{0, false, false, false}
+	curr := 0
 	start := 0
 	ansiToColorPair := func(ansi ansiOffset, base tui.ColorPair) tui.ColorPair {
 		fg := ansi.color.fg
@@ -199,19 +155,11 @@ func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, t
 	}
 	var colors []colorOffset
 	add := func(idx int) {
-		if (curr.color || curr.nth || curr.match) && idx > start {
-			if curr.match {
-				var color tui.ColorPair
-				if curr.nth {
-					color = colBase.WithAttr(attrNth).Merge(colMatch)
-				} else {
-					color = colBase.Merge(colMatch)
-				}
-				var url *url
-				if curr.color && theme.Colored {
-					ansi := itemColors[curr.index]
-					url = ansi.color.url
-					origColor := ansiToColorPair(ansi, colMatch)
+		if curr != 0 && idx > start {
+			if curr < 0 {
+				color := colMatch
+				if curr < -1 && theme.Colored {
+					origColor := ansiToColorPair(itemColors[-curr-2], colMatch)
 					// hl or hl+ only sets the foreground color, so colMatch is the
 					// combination of either [hl and bg] or [hl+ and bg+].
 					//
@@ -222,32 +170,17 @@ func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, t
 					//      echo -e "\x1b[42mfoo\x1b[mbar" | fzf --ansi --color bg+:1,hl+:-1:underline
 					if color.Fg().IsDefault() && origColor.HasBg() {
 						color = origColor
-						if curr.nth {
-							color = color.WithAttr(attrNth)
-						}
 					} else {
 						color = origColor.MergeNonDefault(color)
 					}
 				}
 				colors = append(colors, colorOffset{
-					offset: [2]int32{int32(start), int32(idx)}, color: color, match: true, url: url})
-			} else if curr.color {
-				ansi := itemColors[curr.index]
-				color := ansiToColorPair(ansi, colBase)
-				if curr.nth {
-					color = color.WithAttr(attrNth)
-				}
-				colors = append(colors, colorOffset{
-					offset: [2]int32{int32(start), int32(idx)},
-					color:  color,
-					match:  false,
-					url:    ansi.color.url})
+					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:  colBase.WithAttr(attrNth),
-					match:  false,
-					url:    nil})
+					color:  ansiToColorPair(ansi, colBase)})
 			}
 		}
 	}
--- a/src/result_test.go
+++ b/src/result_test.go
@@ -54,9 +54,9 @@ func TestResultRank(t *testing.T) {
 	// FIXME global
 	sortCriteria = []criterion{byScore, byLength}

-	str := []rune("foo")
+	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
 	item1 := buildResult(
-		withIndex(&Item{text: util.RunesToChars(str)}, 1), []Offset{}, 2)
+		withIndex(&Item{text: util.RunesToChars(strs[0])}, 1), []Offset{}, 2)
 	if item1.points[3] != math.MaxUint16-2 || // Bonus
 		item1.points[2] != 3 || // Length
 		item1.points[1] != 0 || // Unused
@@ -65,7 +65,7 @@ func TestResultRank(t *testing.T) {
 		t.Error(item1)
 	}
 	// Only differ in index
-	item2 := buildResult(&Item{text: util.RunesToChars(str)}, []Offset{}, 2)
+	item2 := buildResult(&Item{text: util.RunesToChars(strs[0])}, []Offset{}, 2)

 	items := []Result{item1, item2}
 	sort.Sort(ByRelevance(items))
@@ -98,40 +98,23 @@ func TestResultRank(t *testing.T) {
 	}
 }

-func TestChunkTiebreak(t *testing.T) {
-	// FIXME global
-	sortCriteria = []criterion{byScore, byChunk}
-
-	score := 100
-	test := func(input string, offset Offset, chunk string) {
-		item := buildResult(withIndex(&Item{text: util.RunesToChars([]rune(input))}, 1), []Offset{offset}, score)
-		if !(item.points[3] == math.MaxUint16-uint16(score) && item.points[2] == uint16(len(chunk))) {
-			t.Error(item.points)
-		}
-	}
-	test("hello foobar goodbye", Offset{8, 9}, "foobar")
-	test("hello foobar goodbye", Offset{7, 18}, "foobar goodbye")
-	test("hello foobar goodbye", Offset{0, 1}, "hello")
-	test("hello foobar goodbye", Offset{5, 7}, "hello foobar") // TBD
-}
-
 func TestColorOffset(t *testing.T) {
 	// ------------ 20 ----  --  ----
 	//   ++++++++        ++++++++++
 	// --++++++++--    --++++++++++---

-	offsets := []Offset{{5, 15}, {10, 12}, {25, 35}}
+	offsets := []Offset{{5, 15}, {25, 35}}
 	item := Result{
 		item: &Item{
 			colors: &[]ansiOffset{
-				{[2]int32{0, 20}, ansiState{1, 5, 0, -1, nil}},
-				{[2]int32{22, 27}, ansiState{2, 6, tui.Bold, -1, nil}},
-				{[2]int32{30, 32}, ansiState{3, 7, 0, -1, nil}},
-				{[2]int32{33, 40}, ansiState{4, 8, tui.Bold, -1, nil}}}}}
+				{[2]int32{0, 20}, ansiState{1, 5, 0, -1}},
+				{[2]int32{22, 27}, ansiState{2, 6, tui.Bold, -1}},
+				{[2]int32{30, 32}, ansiState{3, 7, 0, -1}},
+				{[2]int32{33, 40}, ansiState{4, 8, tui.Bold, -1}}}}}

 	colBase := tui.NewColorPair(89, 189, tui.AttrUndefined)
 	colMatch := tui.NewColorPair(99, 199, tui.AttrUndefined)
-	colors := item.colorOffsets(offsets, nil, tui.Dark256, colBase, colMatch, tui.AttrUndefined, true)
+	colors := item.colorOffsets(offsets, tui.Dark256, colBase, colMatch, true)
 	assert := func(idx int, b int32, e int32, c tui.ColorPair) {
 		o := colors[idx]
 		if o.offset[0] != b || o.offset[1] != e || o.color != c {
@@ -155,30 +138,20 @@ func TestColorOffset(t *testing.T) {

 	colRegular := tui.NewColorPair(-1, -1, tui.AttrUndefined)
 	colUnderline := tui.NewColorPair(-1, -1, tui.Underline)
+	colors = item.colorOffsets(offsets, tui.Dark256, colRegular, colUnderline, true)

-	nthOffsets := []Offset{{37, 39}, {42, 45}}
-	for _, attr := range []tui.Attr{tui.AttrRegular, tui.StrikeThrough} {
-		colors = item.colorOffsets(offsets, nthOffsets, tui.Dark256, colRegular, colUnderline, attr, true)
-
-		// [{[0 5] {1 5 0}} {[5 15] {1 5 8}} {[15 20] {1 5 0}}
-		//  {[22 25] {2 6 1}} {[25 27] {2 6 9}} {[27 30] {-1 -1 8}}
-		//  {[30 32] {3 7 8}} {[32 33] {-1 -1 8}} {[33 35] {4 8 9}}
-		//  {[35 37] {4 8 1}} {[37 39] {4 8 x|1}} {[39 40] {4 8 x|1}}]
-		assert(0, 0, 5, tui.NewColorPair(1, 5, tui.AttrUndefined))
-		assert(1, 5, 15, tui.NewColorPair(1, 5, tui.Underline))
-		assert(2, 15, 20, tui.NewColorPair(1, 5, tui.AttrUndefined))
-		assert(3, 22, 25, tui.NewColorPair(2, 6, tui.Bold))
-		assert(4, 25, 27, tui.NewColorPair(2, 6, tui.Bold|tui.Underline))
-		assert(5, 27, 30, colUnderline)
-		assert(6, 30, 32, tui.NewColorPair(3, 7, tui.Underline))
-		assert(7, 32, 33, colUnderline)
-		assert(8, 33, 35, tui.NewColorPair(4, 8, tui.Bold|tui.Underline))
-		assert(9, 35, 37, tui.NewColorPair(4, 8, tui.Bold))
-		expected := tui.Bold | attr
-		if attr == tui.AttrRegular {
-			expected = tui.AttrRegular
-		}
-		assert(10, 37, 39, tui.NewColorPair(4, 8, expected))
-		assert(11, 39, 40, tui.NewColorPair(4, 8, tui.Bold))
-	}
+	// [{[0 5] {1 5 0}} {[5 15] {1 5 8}} {[15 20] {1 5 0}}
+	//  {[22 25] {2 6 1}} {[25 27] {2 6 9}} {[27 30] {-1 -1 8}}
+	//  {[30 32] {3 7 8}} {[32 33] {-1 -1 8}} {[33 35] {4 8 9}}
+	//  {[35 40] {4 8 1}}]
+	assert(0, 0, 5, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(1, 5, 15, tui.NewColorPair(1, 5, tui.Underline))
+	assert(2, 15, 20, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(3, 22, 25, tui.NewColorPair(2, 6, tui.Bold))
+	assert(4, 25, 27, tui.NewColorPair(2, 6, tui.Bold|tui.Underline))
+	assert(5, 27, 30, colUnderline)
+	assert(6, 30, 32, tui.NewColorPair(3, 7, tui.Underline))
+	assert(7, 32, 33, colUnderline)
+	assert(8, 33, 35, tui.NewColorPair(4, 8, tui.Bold|tui.Underline))
+	assert(9, 35, 40, tui.NewColorPair(4, 8, tui.Bold))
 }
--- a/src/server.go
+++ b/src/server.go
@@ -1,246 +0,0 @@
-package fzf
-
-import (
-	"bufio"
-	"bytes"
-	"crypto/subtle"
-	"errors"
-	"fmt"
-	"net"
-	"os"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-)
-
-var getRegex *regexp.Regexp
-
-func init() {
-	getRegex = regexp.MustCompile(`^GET /(?:\?([a-z0-9=&]+))? HTTP`)
-}
-
-type getParams struct {
-	limit  int
-	offset int
-}
-
-const (
-	crlf             = "\r\n"
-	httpOk           = "HTTP/1.1 200 OK" + crlf
-	httpBadRequest   = "HTTP/1.1 400 Bad Request" + crlf
-	httpUnauthorized = "HTTP/1.1 401 Unauthorized" + crlf
-	httpUnavailable  = "HTTP/1.1 503 Service Unavailable" + crlf
-	httpReadTimeout  = 10 * time.Second
-	channelTimeout   = 2 * time.Second
-	jsonContentType  = "Content-Type: application/json" + crlf
-	maxContentLength = 1024 * 1024
-)
-
-type httpServer struct {
-	apiKey        []byte
-	actionChannel chan []*action
-	getHandler    func(getParams) string
-}
-
-type listenAddress struct {
-	host string
-	port int
-}
-
-func (addr listenAddress) IsLocal() bool {
-	return addr.host == "localhost" || addr.host == "127.0.0.1"
-}
-
-var defaultListenAddr = listenAddress{"localhost", 0}
-
-func parseListenAddress(address string) (listenAddress, error) {
-	parts := strings.SplitN(address, ":", 3)
-	if len(parts) == 1 {
-		parts = []string{"localhost", parts[0]}
-	}
-	if len(parts) != 2 {
-		return defaultListenAddr, fmt.Errorf("invalid listen address: %s", address)
-	}
-	portStr := parts[len(parts)-1]
-	port, err := strconv.Atoi(portStr)
-	if err != nil || port < 0 || port > 65535 {
-		return defaultListenAddr, fmt.Errorf("invalid listen port: %s", portStr)
-	}
-	if len(parts[0]) == 0 {
-		parts[0] = "localhost"
-	}
-	return listenAddress{parts[0], port}, nil
-}
-
-func startHttpServer(address listenAddress, actionChannel chan []*action, getHandler func(getParams) string) (net.Listener, int, error) {
-	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")
-	}
-	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)
-	}
-	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)
-		}
-		var err error
-		port, err = strconv.Atoi(parts[len(parts)-1])
-		if err != nil {
-			return nil, port, err
-		}
-	}
-
-	server := httpServer{
-		apiKey:        []byte(apiKey),
-		actionChannel: actionChannel,
-		getHandler:    getHandler,
-	}
-
-	go func() {
-		for {
-			conn, err := listener.Accept()
-			if err != nil {
-				if errors.Is(err, net.ErrClosed) {
-					return
-				}
-				continue
-			}
-			conn.Write([]byte(server.handleHttpRequest(conn)))
-			conn.Close()
-		}
-	}()
-
-	return listener, port, nil
-}
-
-// Here we are writing a simplistic HTTP server without using net/http
-// package to reduce the size of the binary.
-//
-// * No --listen:            2.8MB
-// * --listen with net/http: 5.7MB
-// * --listen w/o net/http:  3.3MB
-func (server *httpServer) handleHttpRequest(conn net.Conn) string {
-	contentLength := 0
-	apiKey := ""
-	body := ""
-	answer := func(code string, message string) string {
-		message += "\n"
-		return code + fmt.Sprintf("Content-Length: %d%s", len(message), crlf+crlf+message)
-	}
-	unauthorized := func(message string) string {
-		return answer(httpUnauthorized, message)
-	}
-	bad := func(message string) string {
-		return answer(httpBadRequest, message)
-	}
-	good := func(message string) string {
-		return answer(httpOk+jsonContentType, message)
-	}
-	conn.SetReadDeadline(time.Now().Add(httpReadTimeout))
-	scanner := bufio.NewScanner(conn)
-	scanner.Split(func(data []byte, atEOF bool) (int, []byte, error) {
-		found := bytes.Index(data, []byte(crlf))
-		if found >= 0 {
-			token := data[:found+len(crlf)]
-			return len(token), token, nil
-		}
-		if atEOF || len(body)+len(data) >= contentLength {
-			return 0, data, bufio.ErrFinalToken
-		}
-		return 0, nil, nil
-	})
-
-	section := 0
-	for scanner.Scan() {
-		text := scanner.Text()
-		switch section {
-		case 0:
-			getMatch := getRegex.FindStringSubmatch(text)
-			if len(getMatch) > 0 {
-				response := server.getHandler(parseGetParams(getMatch[1]))
-				if len(response) > 0 {
-					return good(response)
-				}
-				return answer(httpUnavailable+jsonContentType, `{"error":"timeout"}`)
-			} else if !strings.HasPrefix(text, "POST / HTTP") {
-				return bad("invalid request method")
-			}
-			section++
-		case 1:
-			if text == crlf {
-				if contentLength == 0 {
-					return bad("content-length header missing")
-				}
-				section++
-				continue
-			}
-			pair := strings.SplitN(text, ":", 2)
-			if len(pair) == 2 {
-				switch strings.ToLower(pair[0]) {
-				case "content-length":
-					length, err := strconv.Atoi(strings.TrimSpace(pair[1]))
-					if err != nil || length <= 0 || length > maxContentLength {
-						return bad("invalid content length")
-					}
-					contentLength = length
-				case "x-api-key":
-					apiKey = strings.TrimSpace(pair[1])
-				}
-			}
-		case 2:
-			body += text
-		}
-	}
-
-	if len(server.apiKey) != 0 && subtle.ConstantTimeCompare([]byte(apiKey), server.apiKey) != 1 {
-		return unauthorized("invalid api key")
-	}
-
-	if len(body) < contentLength {
-		return bad("incomplete request")
-	}
-	body = body[:contentLength]
-
-	actions, err := parseSingleActionList(strings.Trim(string(body), "\r\n"))
-	if err != nil {
-		return bad(err.Error())
-	}
-	if len(actions) == 0 {
-		return bad("no action specified")
-	}
-
-	select {
-	case server.actionChannel <- actions:
-	case <-time.After(channelTimeout):
-		return httpUnavailable + crlf
-	}
-	return httpOk + crlf
-}
-
-func parseGetParams(query string) getParams {
-	params := getParams{limit: 100, offset: 0}
-	for _, pair := range strings.Split(query, "&") {
-		parts := strings.SplitN(pair, "=", 2)
-		if len(parts) == 2 {
-			switch parts[0] {
-			case "limit", "offset":
-				if val, err := strconv.Atoi(parts[1]); err == nil {
-					if parts[0] == "limit" {
-						params.limit = val
-					} else {
-						params.offset = val
-					}
-				}
-			}
-		}
-	}
-	return params
-}
--- a/src/terminal.go
+++ b/src/terminal.go
--- a/src/terminal_test.go
+++ b/src/terminal_test.go
@@ -12,22 +12,6 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )

-func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter, printsep string, forcePlus bool, query string, allItems []*Item) string {
-	replaced, _ := replacePlaceholder(replacePlaceholderParams{
-		template:   template,
-		stripAnsi:  stripAnsi,
-		delimiter:  delimiter,
-		printsep:   printsep,
-		forcePlus:  forcePlus,
-		query:      query,
-		allItems:   allItems,
-		lastAction: actBackwardDeleteCharEof,
-		prompt:     "prompt",
-		executor:   util.NewExecutor(""),
-	})
-	return replaced
-}
-
 func TestReplacePlaceholder(t *testing.T) {
 	item1 := newItem("  foo'bar \x1b[31mbaz\x1b[m")
 	items1 := []*Item{item1, item1}
@@ -68,90 +52,90 @@ func TestReplacePlaceholder(t *testing.T) {
 	*/

 	// {}, preserve ansi
-	result = replacePlaceholderTest("echo {}", false, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {}", false, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar \x1b[31mbaz\x1b[m{{.O}}")

 	// {}, strip ansi
-	result = replacePlaceholderTest("echo {}", true, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {}", true, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")

 	// {}, with multiple items
-	result = replacePlaceholderTest("echo {}", true, Delimiter{}, printsep, false, "query", items2)
+	result = replacePlaceholder("echo {}", true, Delimiter{}, printsep, false, "query", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}")

 	// {..}, strip leading whitespaces, preserve ansi
-	result = replacePlaceholderTest("echo {..}", false, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {..}", false, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}foo{{.I}}bar \x1b[31mbaz\x1b[m{{.O}}")

 	// {..}, strip leading whitespaces, strip ansi
-	result = replacePlaceholderTest("echo {..}", true, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {..}", true, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}")

 	// {q}
-	result = replacePlaceholderTest("echo {} {q}", true, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {} {q}", true, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}} {{.O}}query{{.O}}")

 	// {q}, multiple items
-	result = replacePlaceholderTest("echo {+}{q}{+}", true, Delimiter{}, printsep, false, "query 'string'", items2)
+	result = replacePlaceholder("echo {+}{q}{+}", true, Delimiter{}, printsep, false, "query 'string'", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}{{.O}}query {{.I}}string{{.I}}{{.O}}{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}")

-	result = replacePlaceholderTest("echo {}{q}{}", true, Delimiter{}, printsep, false, "query 'string'", items2)
+	result = replacePlaceholder("echo {}{q}{}", true, Delimiter{}, printsep, false, "query 'string'", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}{{.O}}query {{.I}}string{{.I}}{{.O}}{{.O}}foo{{.I}}bar baz{{.O}}")

-	result = replacePlaceholderTest("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}bazfoo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}foo{{.I}}bar{{.O}}/{{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}}")

-	result = replacePlaceholderTest("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items2)
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}baz{{.O}}/{{.O}}foo{{.I}}bar{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}}")

-	result = replacePlaceholderTest("echo {+1}/{+2}/{+-1}/{+-2}/{+..}/{n.t}/\\{}/\\{1}/\\{q}/{+3}", true, Delimiter{}, printsep, false, "query", items2)
+	result = replacePlaceholder("echo {+1}/{+2}/{+-1}/{+-2}/{+..}/{n.t}/\\{}/\\{1}/\\{q}/{+3}", true, Delimiter{}, printsep, false, "query", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}} {{.O}}{{.O}}")

 	// forcePlus
-	result = replacePlaceholderTest("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, true, "query", items2)
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, true, "query", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}} {{.O}}{{.O}}")

 	// Whitespace preserving flag with "'" delimiter
-	result = replacePlaceholderTest("echo {s1}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s1}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.O}}")

-	result = replacePlaceholderTest("echo {s2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}bar baz{{.O}}")

-	result = replacePlaceholderTest("echo {s}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")

-	result = replacePlaceholderTest("echo {s..}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s..}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")

 	// Whitespace preserving flag with regex delimiter
 	regex = regexp.MustCompile(`\w+`)

-	result = replacePlaceholderTest("echo {s1}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s1}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  {{.O}}")

-	result = replacePlaceholderTest("echo {s2}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s2}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}{{.I}}{{.O}}")

-	result = replacePlaceholderTest("echo {s3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}} {{.O}}")

 	// No match
-	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, nil})
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, nil})
 	check("echo /")

 	// No match, but with selections
-	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, item1})
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, item1})
 	checkFormat("echo /{{.O}}  foo{{.I}}bar baz{{.O}}")

 	// String delimiter
-	result = replacePlaceholderTest("echo {}/{1}/{2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {}/{1}/{2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}foo{{.O}}/{{.O}}bar baz{{.O}}")

 	// Regex delimiter
 	regex = regexp.MustCompile("[oa]+")
 	// foo'bar baz
-	result = replacePlaceholderTest("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}f{{.O}}/{{.O}}r b{{.O}}/{{.O}}{{.I}}bar b{{.O}}")

 	/*
@@ -171,6 +155,7 @@ func TestReplacePlaceholder(t *testing.T) {
 		newItem("7a 7b 7c 7d 7e 7f"),
 	}
 	stripAnsi := false
+	printsep = "\n"
 	forcePlus := false
 	query := "sample query"

@@ -213,23 +198,18 @@ func TestReplacePlaceholder(t *testing.T) {
 	// query flag is not removed after parsing, so it gets doubled
 	// while the double q is invalid, it is useful here for testing purposes
 	templateToOutput[`{q}`] = "{{.O}}" + query + "{{.O}}"
-	templateToOutput[`{fzf:query}`] = "{{.O}}" + query + "{{.O}}"
-	templateToOutput[`{fzf:action} {fzf:prompt}`] = "backward-delete-char-eof 'prompt'"

 	// IV. escaping placeholder
 	templateToOutput[`\{}`] = `{}`
-	templateToOutput[`\{q}`] = `{q}`
-	templateToOutput[`\{fzf:query}`] = `{fzf:query}`
-	templateToOutput[`\{fzf:action}`] = `{fzf:action}`
 	templateToOutput[`\{++}`] = `{++}`
 	templateToOutput[`{++}`] = templateToOutput[`{+}`]

 	for giveTemplate, wantOutput := range templateToOutput {
-		result = replacePlaceholderTest(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
+		result = replacePlaceholder(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
 		checkFormat(wantOutput)
 	}
 	for giveTemplate, wantOutput := range templateToFile {
-		path := replacePlaceholderTest(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
+		path := replacePlaceholder(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)

 		data, err := readFile(path)
 		if err != nil {
@@ -246,7 +226,6 @@ func TestQuoteEntry(t *testing.T) {
 	unixStyle := quotes{``, `'`, `'\''`, `"`, `\`}
 	windowsStyle := quotes{`^`, `^"`, `'`, `\^"`, `\\`}
 	var effectiveStyle quotes
-	exec := util.NewExecutor("")

 	if util.IsWindows() {
 		effectiveStyle = windowsStyle
@@ -281,7 +260,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 +299,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}

@@ -442,10 +421,10 @@ func TestPowershellCommands(t *testing.T) {
 }

 /*
-Test typical valid placeholders and parsing of them.
+	Test typical valid placeholders and parsing of them.

-Also since the parser assumes the input is matched with `placeholder` regex,
-the regex is tested here as well.
+	Also since the parser assumes the input is matched with `placeholder` regex,
+	the regex is tested here as well.
 */
 func TestParsePlaceholder(t *testing.T) {
 	// give, want pairs
@@ -484,12 +463,7 @@ func TestParsePlaceholder(t *testing.T) {
 		// III. query type placeholder
 		// query flag is not removed after parsing, so it gets doubled
 		// while the double q is invalid, it is useful here for testing purposes
-		`{q}`:        `{qq}`,
-		`{q:1}`:      `{qq:1}`,
-		`{q:2..}`:    `{qq:2..}`,
-		`{q:..}`:     `{qq:..}`,
-		`{q:2..-1}`:  `{qq:2..-1}`,
-		`{q:s2..-1}`: `{sqq:2..-1}`, // FIXME
+		`{q}`: `{qq}`,

 		// IV. escaping placeholder
 		`\{}`:   `{}`,
@@ -512,34 +486,6 @@ func TestParsePlaceholder(t *testing.T) {
 	}
 }

-func TestExtractPassthroughs(t *testing.T) {
-	for _, middle := range []string{
-		"\x1bPtmux;\x1b\x1bbar\x1b\\",
-		"\x1bPtmux;\x1b\x1bbar\x1bbar\x1b\\",
-		"\x1b]1337;bar\x1b\\",
-		"\x1b]1337;bar\x1bbar\x1b\\",
-		"\x1b]1337;bar\a",
-		"\x1b_Ga=T,f=32,s=1258,v=1295,c=74,r=35,m=1\x1b\\",
-		"\x1b_Ga=T,f=32,s=1258,v=1295,c=74,r=35,m=1\x1b\\\r",
-		"\x1b_Ga=T,f=32,s=1258,v=1295,c=74,r=35,m=1\x1bbar\x1b\\\r",
-		"\x1b_Gm=1;AAAAAAAAA=\x1b\\",
-		"\x1b_Gm=1;AAAAAAAAA=\x1b\\\r",
-		"\x1b_Gm=1;\x1bAAAAAAAAA=\x1b\\\r",
-	} {
-		line := "foo" + middle + "baz"
-		loc := findPassThrough(line)
-		if loc == nil || line[0:loc[0]] != "foo" || line[loc[1]:] != "baz" {
-			t.Error("failed to find passthrough")
-		}
-		garbage := "\x1bPtmux;\x1b]1337;\x1b_Ga=\x1b]1337;bar\x1b."
-		line = strings.Repeat("foo"+middle+middle+"baz", 3) + garbage
-		passthroughs, result := extractPassThroughs(line)
-		if result != "foobazfoobazfoobaz"+garbage || len(passthroughs) != 6 {
-			t.Error("failed to extract passthroughs")
-		}
-	}
-}
-
 /* utilities section */

 // Item represents one line in fzf UI. Usually it is relative path to files and folders.
@@ -617,7 +563,7 @@ func testCommands(t *testing.T, tests []testCase) {

 	// evaluate the test cases
 	for idx, test := range tests {
-		gotOutput := replacePlaceholderTest(
+		gotOutput := replacePlaceholder(
 			test.give.template, stripAnsi, delimiter, printsep, forcePlus,
 			test.give.query,
 			test.give.allItems)
@@ -659,7 +605,7 @@ func (flags placeholderFlags) encodePlaceholder() string {
 	if flags.file {
 		encoded += "f"
 	}
-	if flags.forceUpdate { // FIXME
+	if flags.query {
 		encoded += "q"
 	}
 	return encoded
--- a/src/terminal_unix.go
+++ b/src/terminal_unix.go
@@ -5,9 +5,8 @@ package fzf
 import (
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
-
-	"golang.org/x/sys/unix"
 )

 func notifyOnResize(resizeChan chan<- os.Signal) {
@@ -15,10 +14,13 @@ func notifyOnResize(resizeChan chan<- os.Signal) {
 }

 func notifyStop(p *os.Process) {
-	pid := p.Pid
-	pgid, err := unix.Getpgid(pid)
-	if err == nil {
-		pid = pgid * -1
-	}
-	unix.Kill(pid, syscall.SIGTSTP)
+	p.Signal(syscall.SIGSTOP)
+}
+
+func notifyOnCont(resizeChan chan<- os.Signal) {
+	signal.Notify(resizeChan, syscall.SIGCONT)
+}
+
+func quoteEntry(entry string) string {
+	return "'" + strings.Replace(entry, "'", "'\\''", -1) + "'"
 }
--- 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) {
@@ -13,3 +15,31 @@ func notifyOnResize(resizeChan chan<- os.Signal) {
 func notifyStop(p *os.Process) {
 	// NOOP
 }
+
+func notifyOnCont(resizeChan chan<- os.Signal) {
+	// NOOP
+}
+
+func quoteEntry(entry string) string {
+	shell := os.Getenv("SHELL")
+	if len(shell) == 0 {
+		shell = "cmd"
+	}
+
+	if strings.Contains(shell, "cmd") {
+		// backslash escaping is done here for applications
+		// (see ripgrep test case in terminal_test.go#TestWindowsCommands)
+		escaped := strings.Replace(entry, `\`, `\\`, -1)
+		escaped = `"` + strings.Replace(escaped, `"`, `\"`, -1) + `"`
+		// caret is the escape character for cmd shell
+		r, _ := regexp.Compile(`[&|<>()@^%!"]`)
+		return r.ReplaceAllStringFunc(escaped, func(match string) string {
+			return "^" + match
+		})
+	} else if strings.Contains(shell, "pwsh") || strings.Contains(shell, "powershell") {
+		escaped := strings.Replace(entry, `"`, `\"`, -1)
+		return "'" + strings.Replace(escaped, "'", "''", -1) + "'"
+	} else {
+		return "'" + strings.Replace(entry, "'", "'\\''", -1) + "'"
+	}
+}
--- a/src/tmux.go
+++ b/src/tmux.go
@@ -1,68 +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, rest := args[0], args[1:]
-	args = []string{"--bind=ctrl-z:ignore"}
-	if !opts.Tmux.border && opts.BorderShape == tui.BorderUndefined {
-		// We append --border option at the end, because `--style=full:STYLE`
-		// may have changed the default border style.
-		rest = append(rest, "--border")
-	}
-	if opts.Tmux.border && opts.Margin == defaultMargin() {
-		args = append(args, "--margin=0,1")
-	}
-	argStr := escapeSingleQuote(fzf)
-	for _, arg := range append(args, rest...) {
-		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", "-d", dir}
-	if !opts.Tmux.border {
-		tmuxArgs = append(tmuxArgs, "-B")
-	}
-	switch opts.Tmux.position {
-	case posUp:
-		tmuxArgs = append(tmuxArgs, "-xC", "-y0")
-	case posDown:
-		tmuxArgs = append(tmuxArgs, "-xC", "-y9999")
-	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, needBash bool) (*exec.Cmd, error) {
-		sh, err := sh(needBash)
-		if err != nil {
-			return nil, err
-		}
-		tmuxArgs = append(tmuxArgs, sh, temp)
-		return exec.Command("tmux", tmuxArgs...), nil
-	}, opts, true)
-}
--- a/src/tokenizer.go
+++ b/src/tokenizer.go
@@ -6,7 +6,6 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
-	"unicode"

 	"github.com/junegunn/fzf/src/util"
 )
@@ -19,48 +18,6 @@ type Range struct {
 	end   int
 }

-func (r Range) IsFull() bool {
-	return r.begin == rangeEllipsis && r.end == rangeEllipsis
-}
-
-func compareRanges(r1 []Range, r2 []Range) bool {
-	if len(r1) != len(r2) {
-		return false
-	}
-	for idx := range r1 {
-		if r1[idx] != r2[idx] {
-			return false
-		}
-	}
-	return true
-}
-
-func RangesToString(ranges []Range) string {
-	strs := []string{}
-	for _, r := range ranges {
-		s := ""
-		if r.begin == rangeEllipsis && r.end == rangeEllipsis {
-			s = ".."
-		} else if r.begin == r.end {
-			s = strconv.Itoa(r.begin)
-		} else {
-			if r.begin != rangeEllipsis {
-				s += strconv.Itoa(r.begin)
-			}
-
-			if r.begin != -1 {
-				s += ".."
-				if r.end != rangeEllipsis {
-					s += strconv.Itoa(r.end)
-				}
-			}
-		}
-		strs = append(strs, s)
-	}
-
-	return strings.Join(strs, ",")
-}
-
 // Token contains the tokenized part of the strings and its prefix length
 type Token struct {
 	text         *util.Chars
@@ -78,18 +35,13 @@ type Delimiter struct {
 	str   *string
 }

-// IsAwk returns true if the delimiter is an AWK-style delimiter
-func (d Delimiter) IsAwk() bool {
-	return d.regex == nil && d.str == nil
-}
-
 // String returns the string representation of a Delimiter.
 func (d Delimiter) String() string {
 	return fmt.Sprintf("Delimiter{regex: %v, str: &%q}", d.regex, *d.str)
 }

 func newRange(begin int, end int) Range {
-	if begin == 1 && end != 1 {
+	if begin == 1 {
 		begin = rangeEllipsis
 	}
 	if end == -1 {
@@ -121,7 +73,7 @@ func ParseRange(str *string) (Range, bool) {
 		}
 		begin, err1 := strconv.Atoi(ns[0])
 		end, err2 := strconv.Atoi(ns[1])
-		if err1 != nil || err2 != nil || begin == 0 || end == 0 || begin < 0 && end > 0 {
+		if err1 != nil || err2 != nil || begin == 0 || end == 0 {
 			return Range{}, false
 		}
 		return newRange(begin, end), true
@@ -139,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()
 	}
@@ -217,24 +169,7 @@ func Tokenize(text string, delimiter Delimiter) []Token {
 	return withPrefixLengths(tokens, 0)
 }

-// StripLastDelimiter removes the trailing delimiter and whitespaces
-func StripLastDelimiter(str string, delimiter Delimiter) string {
-	if delimiter.str != nil {
-		str = strings.TrimSuffix(str, *delimiter.str)
-	} else if delimiter.regex != nil {
-		locs := delimiter.regex.FindAllStringIndex(str, -1)
-		if len(locs) > 0 {
-			lastLoc := locs[len(locs)-1]
-			if lastLoc[1] == len(str) {
-				str = str[:lastLoc[0]]
-			}
-		}
-	}
-	return strings.TrimRightFunc(str, unicode.IsSpace)
-}
-
-// JoinTokens concatenates the tokens into a single string
-func JoinTokens(tokens []Token) string {
+func joinTokens(tokens []Token) string {
 	var output bytes.Buffer
 	for _, token := range tokens {
 		output.WriteString(token.text.ToString())
@@ -252,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
@@ -40,18 +40,6 @@ func TestParseRange(t *testing.T) {
 			t.Errorf("%v", r)
 		}
 	}
-	{
-		i := "1..3..5"
-		if r, ok := ParseRange(&i); ok {
-			t.Errorf("%v", r)
-		}
-	}
-	{
-		i := "-3..3"
-		if r, ok := ParseRange(&i); ok {
-			t.Errorf("%v", r)
-		}
-	}
 }

 func TestTokenize(t *testing.T) {
@@ -83,16 +71,16 @@ 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:  " {
+			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:  " ||
+			if string(joinTokens(tx)) != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
 				len(tx) != 4 ||
 				tx[0].text.ToString() != "abc:  def:  " || tx[0].prefixLength != 2 ||
 				tx[1].text.ToString() != "ghi:  " || tx[1].prefixLength != 14 ||
@@ -105,9 +93,9 @@ 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:" ||
+			if joinTokens(tx) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
 				len(tx) != 4 ||
 				tx[0].text.ToString() != "  abc:  def:" || tx[0].prefixLength != 0 ||
 				tx[1].text.ToString() != "  ghi:" || tx[1].prefixLength != 12 ||
@@ -120,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,56 +8,37 @@ func HasFullscreenRenderer() bool {
 	return false
 }

-var DefaultBorderShape = BorderRounded
-
 func (a Attr) Merge(b Attr) Attr {
-	if b&AttrRegular > 0 {
-		// Only keep bold attribute set by the system
-		return b | (a & BoldForce)
-	}
-
 	return a | b
 }

 const (
 	AttrUndefined = Attr(0)
-	AttrRegular   = Attr(1 << 8)
-	AttrClear     = Attr(1 << 9)
-	BoldForce     = Attr(1 << 10)
+	AttrRegular   = Attr(1 << 7)
+	AttrClear     = Attr(1 << 8)

-	Bold          = Attr(1)
-	Dim           = Attr(1 << 1)
-	Italic        = Attr(1 << 2)
-	Underline     = Attr(1 << 3)
-	Blink         = Attr(1 << 4)
-	Blink2        = Attr(1 << 5)
-	Reverse       = Attr(1 << 6)
-	StrikeThrough = Attr(1 << 7)
+	Bold      = Attr(1)
+	Dim       = Attr(1 << 1)
+	Italic    = Attr(1 << 2)
+	Underline = Attr(1 << 3)
+	Blink     = Attr(1 << 4)
+	Blink2    = Attr(1 << 5)
+	Reverse   = Attr(1 << 6)
 )

-func (r *FullscreenRenderer) Init() error                        { return nil }
-func (r *FullscreenRenderer) DefaultTheme() *ColorTheme          { return nil }
-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) Bell()                              {}
-func (r *FullscreenRenderer) HideCursor()                        {}
-func (r *FullscreenRenderer) ShowCursor()                        {}
-func (r *FullscreenRenderer) Refresh()                           {}
-func (r *FullscreenRenderer) Close()                             {}
-func (r *FullscreenRenderer) Size() TermSize                     { return TermSize{} }
+func (r *FullscreenRenderer) Init()             {}
+func (r *FullscreenRenderer) Pause(bool)        {}
+func (r *FullscreenRenderer) Resume(bool, bool) {}
+func (r *FullscreenRenderer) Clear()            {}
+func (r *FullscreenRenderer) Refresh()          {}
+func (r *FullscreenRenderer) Close()            {}

 func (r *FullscreenRenderer) GetChar() Event { return Event{} }
-func (r *FullscreenRenderer) Top() int       { return 0 }
 func (r *FullscreenRenderer) MaxX() int      { return 0 }
 func (r *FullscreenRenderer) MaxY() int      { return 0 }

 func (r *FullscreenRenderer) RefreshWindows(windows []Window) {}

-func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, windowType WindowType, borderStyle BorderStyle, erase bool) Window {
+func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
 	return nil
 }
--- 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[Enter-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 = "RuneCtrlACtrlBCtrlCCtrlDCtrlECtrlFCtrlGCtrlHTabCtrlJCtrlKCtrlLEnterCtrlNCtrlOCtrlPCtrlQCtrlRCtrlSCtrlTCtrlUCtrlVCtrlWCtrlXCtrlYCtrlZEscCtrlSpaceCtrlDeleteCtrlBackSlashCtrlRightBracketCtrlCaretCtrlSlashShiftTabBackspaceDeletePageUpPageDownUpDownLeftRightHomeEndInsertShiftUpShiftDownShiftLeftShiftRightShiftDeleteF1F2F3F4F5F6F7F8F9F10F11F12AltBackspaceAltUpAltDownAltLeftAltRightAltShiftUpAltShiftDownAltShiftLeftAltShiftRightAltCtrlAltInvalidFatalMouseDoubleClickLeftClickRightClickSLeftClickSRightClickScrollUpScrollDownSScrollUpSScrollDownPreviewScrollUpPreviewScrollDownResizeChangeBackwardEOFStartLoadFocusOneZeroResultJumpJumpCancelClickHeader"
-
-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
--- a/src/tui/light_unix.go
+++ b/src/tui/light_unix.go
@@ -3,14 +3,13 @@
 package tui

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

 	"github.com/junegunn/fzf/src/util"
-	"golang.org/x/sys/unix"
 	"golang.org/x/term"
 )

@@ -18,7 +17,7 @@ func IsLightRendererSupported() bool {
 	return true
 }

-func (r *LightRenderer) DefaultTheme() *ColorTheme {
+func (r *LightRenderer) defaultTheme() *ColorTheme {
 	if strings.Contains(os.Getenv("TERM"), "256") {
 		return Dark256
 	}
@@ -33,35 +32,34 @@ func (r *LightRenderer) fd() int {
 	return int(r.ttyin.Fd())
 }

-func (r *LightRenderer) initPlatform() (err error) {
-	r.origState, err = term.MakeRaw(r.fd())
-	return err
+func (r *LightRenderer) initPlatform() error {
+	fd := r.fd()
+	origState, err := term.GetState(fd)
+	if err != nil {
+		return err
+	}
+	r.origState = origState
+	term.MakeRaw(fd)
+	return nil
 }

 func (r *LightRenderer) closePlatform() {
-	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() {
@@ -87,14 +85,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
@@ -115,11 +108,3 @@ func (r *LightRenderer) getch(nonblock bool) (int, bool) {
 	}
 	return int(b[0]), true
 }
-
-func (r *LightRenderer) Size() TermSize {
-	ws, err := unix.IoctlGetWinsize(int(r.ttyin.Fd()), unix.TIOCGWINSZ)
-	if err != nil {
-		return TermSize{}
-	}
-	return TermSize{int(ws.Row), int(ws.Col), int(ws.Xpixel), int(ws.Ypixel)}
-}
--- a/src/tui/light_windows.go
+++ b/src/tui/light_windows.go
@@ -18,7 +18,6 @@ const (
 var (
 	consoleFlagsInput  = uint32(windows.ENABLE_VIRTUAL_TERMINAL_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_EXTENDED_FLAGS)
 	consoleFlagsOutput = uint32(windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING | windows.ENABLE_PROCESSED_OUTPUT | windows.DISABLE_NEWLINE_AUTO_RETURN)
-	counter            = uint64(0)
 )

 // IsLightRendererSupported checks to see if the Light renderer is supported
@@ -40,7 +39,7 @@ func IsLightRendererSupported() bool {
 	return canSetVt100
 }

-func (r *LightRenderer) DefaultTheme() *ColorTheme {
+func (r *LightRenderer) defaultTheme() *ColorTheme {
 	// the getenv check is borrowed from here: https://github.com/gdamore/tcell/commit/0c473b86d82f68226a142e96cc5a34c5a29b3690#diff-b008fcd5e6934bf31bc3d33bf49f47d8R178:
 	if !IsLightRendererSupported() || os.Getenv("ConEmuPID") != "" || os.Getenv("TCELL_TRUECOLOR") == "disable" {
 		return Default16
@@ -62,11 +61,27 @@ func (r *LightRenderer) initPlatform() error {
 	}
 	r.inHandle = uintptr(inHandle)

+	r.setupTerminal()
+
 	// channel for non-blocking reads. Buffer to make sure
 	// we get the ESC sets:
 	r.ttyinChannel = make(chan byte, 1024)

-	r.setupTerminal()
+	// the following allows for non-blocking IO.
+	// syscall.SetNonblock() is a NOOP under Windows.
+	go func() {
+		fd := int(r.inHandle)
+		b := make([]byte, 1)
+		for {
+			// HACK: if run from PSReadline, something resets ConsoleMode to remove ENABLE_VIRTUAL_TERMINAL_INPUT.
+			_ = windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+
+			_, err := util.Read(fd, b)
+			if err == nil {
+				r.ttyinChannel <- b[0]
+			}
+		}
+	}()

 	return nil
 }
@@ -76,71 +91,35 @@ 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
+	return nil
 }

-func openTtyOut() (*os.File, error) {
-	return os.Stderr, nil
-}
-
-func (r *LightRenderer) setupTerminal() {
-	windows.SetConsoleMode(windows.Handle(r.outHandle), consoleFlagsOutput)
-	windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
-
-	// The following allows for non-blocking IO.
-	// syscall.SetNonblock() is a NOOP under Windows.
-	current := counter
-	go func() {
-		fd := int(r.inHandle)
-		b := make([]byte, 1)
-		for {
-			if _, err := util.Read(fd, b); err == nil {
-				r.mutex.Lock()
-				// This condition prevents the goroutine from running after the renderer
-				// has been closed or paused.
-				if current != counter {
-					r.mutex.Unlock()
-					break
-				}
-				r.ttyinChannel <- b[0]
-				// HACK: if run from PSReadline, something resets ConsoleMode to remove ENABLE_VIRTUAL_TERMINAL_INPUT.
-				windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
-				r.mutex.Unlock()
-			}
-		}
-	}()
-}
-
-func (r *LightRenderer) restoreTerminal() {
-	r.mutex.Lock()
-	counter++
-	// We're setting ENABLE_VIRTUAL_TERMINAL_INPUT to allow escape sequences to be read during 'execute'.
-	// e.g. fzf --bind 'enter:execute:less {}'
-	windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput|windows.ENABLE_VIRTUAL_TERMINAL_INPUT)
-	windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
-	r.mutex.Unlock()
-}
-
-func (r *LightRenderer) Size() TermSize {
-	var w, h int
-	var bufferInfo windows.ConsoleScreenBufferInfo
-	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
-		w = getEnv("COLUMNS", defaultWidth)
-		h = r.maxHeightFunc(getEnv("LINES", defaultHeight))
-
-	} else {
-		w = int(bufferInfo.Window.Right - bufferInfo.Window.Left)
-		h = r.maxHeightFunc(int(bufferInfo.Window.Bottom - bufferInfo.Window.Top))
+func (r *LightRenderer) setupTerminal() error {
+	if err := windows.SetConsoleMode(windows.Handle(r.outHandle), consoleFlagsOutput); err != nil {
+		return err
 	}
-	return TermSize{h, w, 0, 0}
+	return windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+}
+
+func (r *LightRenderer) restoreTerminal() error {
+	if err := windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput); err != nil {
+		return err
+	}
+	return windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
 }

 func (r *LightRenderer) updateTerminalSize() {
-	size := r.Size()
-	r.width = size.Columns
-	r.height = size.Lines
+	var bufferInfo windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
+		r.width = getEnv("COLUMNS", defaultWidth)
+		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
+
+	} else {
+		r.width = int(bufferInfo.Window.Right - bufferInfo.Window.Left)
+		r.height = r.maxHeightFunc(int(bufferInfo.Window.Bottom - bufferInfo.Window.Top))
+	}
 }

 func (r *LightRenderer) findOffset() (row int, col int) {
@@ -148,7 +127,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
@@ -4,12 +4,14 @@ package tui

 import (
 	"os"
-	"regexp"
 	"time"

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

+	"github.com/gdamore/tcell"
+	"github.com/gdamore/tcell/encoding"
+
+	"github.com/mattn/go-runewidth"
 	"github.com/rivo/uniseg"
 )

@@ -17,44 +19,25 @@ func HasFullscreenRenderer() bool {
 	return true
 }

-var DefaultBorderShape BorderShape = BorderSharp
-
-func asTcellColor(color Color) tcell.Color {
-	if color == colDefault {
-		return tcell.ColorDefault
-	}
-
-	value := uint64(tcell.ColorValid) + uint64(color)
-	if color.is24() {
-		value = value | uint64(tcell.ColorIsRGB)
-	}
-	return tcell.Color(value)
-}
-
 func (p ColorPair) style() tcell.Style {
 	style := tcell.StyleDefault
-	return style.Foreground(asTcellColor(p.Fg())).Background(asTcellColor(p.Bg()))
+	return style.Foreground(tcell.Color(p.Fg())).Background(tcell.Color(p.Bg()))
 }

-type Attr int32
+type Attr tcell.Style

 type TcellWindow struct {
-	color         bool
-	windowType    WindowType
-	top           int
-	left          int
-	width         int
-	height        int
-	normal        ColorPair
-	lastX         int
-	lastY         int
-	moveCursor    bool
-	borderStyle   BorderStyle
-	uri           *string
-	params        *string
-	showCursor    bool
-	wrapSign      string
-	wrapSignWidth int
+	color       bool
+	preview     bool
+	top         int
+	left        int
+	width       int
+	height      int
+	normal      ColorPair
+	lastX       int
+	lastY       int
+	moveCursor  bool
+	borderStyle BorderStyle
 }

 func (w *TcellWindow) Top() int {
@@ -75,13 +58,13 @@ func (w *TcellWindow) Height() int {

 func (w *TcellWindow) Refresh() {
 	if w.moveCursor {
-		if w.showCursor {
-			_screen.ShowCursor(w.left+w.lastX, w.top+w.lastY)
-		}
+		_screen.ShowCursor(w.left+w.lastX, w.top+w.lastY)
 		w.moveCursor = false
 	}
 	w.lastX = 0
 	w.lastY = 0
+
+	w.drawBorder()
 }

 func (w *TcellWindow) FinishFill() {
@@ -89,47 +72,22 @@ func (w *TcellWindow) FinishFill() {
 }

 const (
-	Bold          Attr = Attr(tcell.AttrBold)
-	Dim                = Attr(tcell.AttrDim)
-	Blink              = Attr(tcell.AttrBlink)
-	Reverse            = Attr(tcell.AttrReverse)
-	Underline          = Attr(tcell.AttrUnderline)
-	StrikeThrough      = Attr(tcell.AttrStrikeThrough)
-	Italic             = Attr(tcell.AttrItalic)
+	Bold      Attr = Attr(tcell.AttrBold)
+	Dim            = Attr(tcell.AttrDim)
+	Blink          = Attr(tcell.AttrBlink)
+	Reverse        = Attr(tcell.AttrReverse)
+	Underline      = Attr(tcell.AttrUnderline)
+	Italic         = Attr(tcell.AttrItalic)
 )

 const (
 	AttrUndefined = Attr(0)
 	AttrRegular   = Attr(1 << 7)
 	AttrClear     = Attr(1 << 8)
-	BoldForce     = Attr(1 << 10)
 )

-func (r *FullscreenRenderer) Bell() {
-	_screen.Beep()
-}
-
-func (r *FullscreenRenderer) HideCursor() {
-	r.showCursor = false
-}
-
-func (r *FullscreenRenderer) ShowCursor() {
-	r.showCursor = true
-}
-
-func (r *FullscreenRenderer) PassThrough(str string) {
-	// No-op
-	// https://github.com/gdamore/tcell/pull/650#issuecomment-1806442846
-}
-
-func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
-
-func (r *FullscreenRenderer) DefaultTheme() *ColorTheme {
-	s, e := r.getScreen()
-	if e != nil {
-		return Default16
-	}
-	if s.Colors() >= 256 {
+func (r *FullscreenRenderer) defaultTheme() *ColorTheme {
+	if _screen.Colors() >= 256 {
 		return Dark256
 	}
 	return Default16
@@ -159,11 +117,6 @@ func (c Color) Style() tcell.Color {
 }

 func (a Attr) Merge(b Attr) Attr {
-	if b&AttrRegular > 0 {
-		// Only keep bold attribute set by the system
-		return b | (a & BoldForce)
-	}
-
 	return a | b
 }

@@ -172,54 +125,32 @@ func (a Attr) Merge(b Attr) Attr {
 var (
 	_screen          tcell.Screen
 	_prevMouseButton tcell.ButtonMask
-	_initialResize   bool = true
 )

-func (r *FullscreenRenderer) getScreen() (tcell.Screen, error) {
-	if _screen == nil {
-		s, e := tcell.NewScreen()
-		if e != nil {
-			return nil, e
-		}
-		if !r.showCursor {
-			s.HideCursor()
-		}
-		_screen = s
-	}
-	return _screen, nil
-}
-
-func (r *FullscreenRenderer) initScreen() error {
-	s, e := r.getScreen()
+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()
 	} else {
 		s.DisableMouse()
 	}
-
-	return nil
+	_screen = s
 }

-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
-	}
-
-	return nil
-}
-
-func (r *FullscreenRenderer) Top() int {
-	return 0
+	r.initScreen()
+	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
 }

 func (r *FullscreenRenderer) MaxX() int {
@@ -245,34 +176,14 @@ func (r *FullscreenRenderer) Clear() {
 	_screen.Clear()
 }

-func (r *FullscreenRenderer) NeedScrollbarRedraw() bool {
-	return true
-}
-
-func (r *FullscreenRenderer) ShouldEmitResizeEvent() bool {
-	return true
-}
-
 func (r *FullscreenRenderer) Refresh() {
 	// noop
 }

-// TODO: Pixel width and height not implemented
-func (r *FullscreenRenderer) Size() TermSize {
-	cols, lines := _screen.Size()
-	return TermSize{lines, cols, 0, 0}
-}
-
 func (r *FullscreenRenderer) GetChar() Event {
 	ev := _screen.PollEvent()
 	switch ev := ev.(type) {
 	case *tcell.EventResize:
-		// Ignore the first resize event
-		// https://github.com/gdamore/tcell/blob/v2.7.0/TUTORIAL.md?plain=1#L18
-		if _initialResize {
-			_initialResize = false
-			return Event{Invalid, 0, nil}
-		}
 		return Event{Resize, 0, nil}

 	// process mouse events:
@@ -282,11 +193,7 @@ func (r *FullscreenRenderer) GetChar() Event {
 		// so mouse click is three consecutive events, but the first and last are indistinguishable from movement events (with released buttons)
 		// dragging has same structure, it only repeats the middle (main) event appropriately
 		x, y := ev.Position()
-
-		mod := ev.Modifiers()
-		ctrl := (mod & tcell.ModCtrl) > 0
-		alt := (mod & tcell.ModAlt) > 0
-		shift := (mod & tcell.ModShift) > 0
+		mod := ev.Modifiers() != 0

 		// since we dont have mouse down events (unlike LightRenderer), we need to track state in prevButton
 		prevButton, button := _prevMouseButton, ev.Buttons()
@@ -295,47 +202,59 @@ func (r *FullscreenRenderer) GetChar() Event {

 		switch {
 		case button&tcell.WheelDown != 0:
-			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, false, ctrl, alt, shift}}
+			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, false, mod}}
 		case button&tcell.WheelUp != 0:
-			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, false, ctrl, alt, shift}}
-		case button&tcell.Button1 != 0:
-			double := false
-			if !drag {
-				// all potential double click events put their coordinates in the clicks array
-				// double click event has two conditions, temporal and spatial, the first is checked here
-				now := time.Now()
-				if now.Sub(r.prevDownTime) < doubleClickDuration {
-					r.clicks = append(r.clicks, [2]int{x, y})
-				} else {
-					r.clicks = [][2]int{{x, y}}
-				}
-				r.prevDownTime = now
-
-				// detect double clicks (also check for spatial condition)
-				n := len(r.clicks)
-				double = n > 1 && r.clicks[n-2][0] == r.clicks[n-1][0] && r.clicks[n-2][1] == r.clicks[n-1][1]
-				if double {
-					// make sure two consecutive double clicks require four clicks
-					r.clicks = [][2]int{}
-				}
+			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, false, mod}}
+		case button&tcell.Button1 != 0 && !drag:
+			// all potential double click events put their 'line' coordinate in the clickY array
+			// double click event has two conditions, temporal and spatial, the first is checked here
+			now := time.Now()
+			if now.Sub(r.prevDownTime) < doubleClickDuration {
+				r.clickY = append(r.clickY, y)
+			} else {
+				r.clickY = []int{y}
 			}
+			r.prevDownTime = now
+
+			// detect double clicks (also check for spatial condition)
+			n := len(r.clickY)
+			double := n > 1 && r.clickY[n-2] == r.clickY[n-1]
+			if double {
+				// make sure two consecutive double clicks require four clicks
+				r.clickY = []int{}
+			}
+
 			// fire single or double click event
-			return Event{Mouse, 0, &MouseEvent{y, x, 0, true, !double, double, ctrl, alt, shift}}
-		case button&tcell.Button2 != 0:
-			return Event{Mouse, 0, &MouseEvent{y, x, 0, false, true, false, ctrl, alt, shift}}
-		default:
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, true, !double, double, mod}}
+		case button&tcell.Button2 != 0 && !drag:
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, false, true, false, mod}}
+		case runtime.GOOS != "windows":
+
 			// double and single taps on Windows don't quite work due to
 			// the console acting on the events and not allowing us
 			// to consume them.
+
 			left := button&tcell.Button1 != 0
 			down := left || button&tcell.Button3 != 0
 			double := false
-
-			// No need to report mouse movement events when no button is pressed
-			if drag {
-				return Event{Invalid, 0, nil}
+			if down {
+				now := time.Now()
+				if !left {
+					r.clickY = []int{}
+				} else if now.Sub(r.prevDownTime) < doubleClickDuration {
+					r.clickY = append(r.clickY, x)
+				} else {
+					r.clickY = []int{x}
+					r.prevDownTime = now
+				}
+			} else {
+				if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
+					time.Now().Sub(r.prevDownTime) < doubleClickDuration {
+					double = true
+				}
 			}
-			return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, ctrl, alt, shift}}
+
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
 		}

 		// process keyboard:
@@ -374,16 +293,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:
@@ -436,17 +355,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}
@@ -454,10 +373,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}
@@ -465,10 +384,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}
@@ -476,10 +395,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}
@@ -492,21 +411,15 @@ func (r *FullscreenRenderer) GetChar() Event {
 		case tcell.KeyHome:
 			return Event{Home, 0, nil}
 		case tcell.KeyDelete:
-			if ctrl {
-				return Event{CtrlDelete, 0, nil}
-			}
-			if shift {
-				return Event{ShiftDelete, 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:
@@ -552,7 +465,7 @@ func (r *FullscreenRenderer) GetChar() Event {

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

@@ -562,7 +475,7 @@ func (r *FullscreenRenderer) GetChar() Event {

 func (r *FullscreenRenderer) Pause(clear bool) {
 	if clear {
-		r.Close()
+		_screen.Fini()
 	}
 }

@@ -574,7 +487,6 @@ func (r *FullscreenRenderer) Resume(clear bool, sigcont bool) {

 func (r *FullscreenRenderer) Close() {
 	_screen.Fini()
-	_screen = nil
 }

 func (r *FullscreenRenderer) RefreshWindows(windows []Window) {
@@ -585,32 +497,24 @@ func (r *FullscreenRenderer) RefreshWindows(windows []Window) {
 	_screen.Show()
 }

-func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, windowType WindowType, borderStyle BorderStyle, erase bool) Window {
-	width = util.Max(0, width)
-	height = util.Max(0, height)
-	normal := ColBorder
-	switch windowType {
-	case WindowList:
-		normal = ColNormal
-	case WindowHeader:
-		normal = ColHeader
-	case WindowInput:
-		normal = ColInput
-	case WindowPreview:
+func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
+	normal := ColNormal
+	if preview {
 		normal = ColPreview
 	}
-	w := &TcellWindow{
+	return &TcellWindow{
 		color:       r.theme.Colored,
-		windowType:  windowType,
+		preview:     preview,
 		top:         top,
 		left:        left,
 		width:       width,
 		height:      height,
 		normal:      normal,
-		borderStyle: borderStyle,
-		showCursor:  r.showCursor}
-	w.Erase()
-	return w
+		borderStyle: borderStyle}
+}
+
+func (w *TcellWindow) Close() {
+	// TODO
 }

 func fill(x, y, w, h int, n ColorPair, r rune) {
@@ -622,30 +526,12 @@ func fill(x, y, w, h int, n ColorPair, r rune) {
 }

 func (w *TcellWindow) Erase() {
-	fill(w.left, w.top, w.width-1, w.height-1, w.normal, ' ')
-	w.drawBorder(false)
-}
-
-func (w *TcellWindow) EraseMaybe() bool {
-	w.Erase()
-	return true
-}
-
-func (w *TcellWindow) SetWrapSign(sign string, width int) {
-	w.wrapSign = sign
-	w.wrapSignWidth = width
-}
-
-func (w *TcellWindow) EncloseX(x int) bool {
-	return x >= w.left && x < (w.left+w.width)
-}
-
-func (w *TcellWindow) EncloseY(y int) bool {
-	return y >= w.top && y < (w.top+w.height)
+	fill(w.left-1, w.top, w.width+1, w.height, w.normal, ' ')
 }

 func (w *TcellWindow) Enclose(y int, x int) bool {
-	return w.EncloseX(x) && w.EncloseY(y)
+	return x >= w.left && x < (w.left+w.width) &&
+		y >= w.top && y < (w.top+w.height)
 }

 func (w *TcellWindow) Move(y int, x int) {
@@ -666,16 +552,6 @@ func (w *TcellWindow) Print(text string) {
 	w.printString(text, w.normal)
 }

-func (w *TcellWindow) withUrl(style tcell.Style) tcell.Style {
-	if w.uri != nil {
-		style = style.Url(*w.uri)
-		if md := regexp.MustCompile(`id=([^:]+)`).FindStringSubmatch(*w.params); len(md) > 1 {
-			style = style.UrlId(md[1])
-		}
-	}
-	return style
-}
-
 func (w *TcellWindow) printString(text string, pair ColorPair) {
 	lx := 0
 	a := pair.Attr()
@@ -685,36 +561,33 @@ func (w *TcellWindow) printString(text string, pair ColorPair) {
 		style = style.
 			Reverse(a&Attr(tcell.AttrReverse) != 0).
 			Underline(a&Attr(tcell.AttrUnderline) != 0).
-			StrikeThrough(a&Attr(tcell.AttrStrikeThrough) != 0).
 			Italic(a&Attr(tcell.AttrItalic) != 0).
 			Blink(a&Attr(tcell.AttrBlink) != 0).
 			Dim(a&Attr(tcell.AttrDim) != 0)
 	}
-	style = w.withUrl(style)

 	gr := uniseg.NewGraphemes(text)
 	for gr.Next() {
-		st := style
 		rs := gr.Runes()

 		if len(rs) == 1 {
 			r := rs[0]
-			if r == '\r' {
-				st = style.Dim(true)
-				rs[0] = '␍'
+			if r < rune(' ') { // ignore control characters
+				continue
 			} else if r == '\n' {
-				st = style.Dim(true)
-				rs[0] = '␊'
-			} else if r < rune(' ') { // ignore control characters
+				w.lastY++
+				lx = 0
+				continue
+			} else if r == '\u000D' { // skip carriage return
 				continue
 			}
 		}
 		var xPos = w.left + w.lastX + lx
 		var yPos = w.top + w.lastY
 		if xPos < (w.left+w.width) && yPos < (w.top+w.height) {
-			_screen.SetContent(xPos, yPos, rs[0], rs[1:], st)
+			_screen.SetContent(xPos, yPos, rs[0], rs[1:], style)
 		}
-		lx += util.StringWidth(string(rs))
+		lx += runewidth.StringWidth(string(rs))
 	}
 	w.lastX += lx
 }
@@ -735,55 +608,29 @@ func (w *TcellWindow) fillString(text string, pair ColorPair) FillReturn {
 	}
 	style = style.
 		Blink(a&Attr(tcell.AttrBlink) != 0).
-		Bold(a&Attr(tcell.AttrBold) != 0 || a&BoldForce != 0).
+		Bold(a&Attr(tcell.AttrBold) != 0).
 		Dim(a&Attr(tcell.AttrDim) != 0).
 		Reverse(a&Attr(tcell.AttrReverse) != 0).
 		Underline(a&Attr(tcell.AttrUnderline) != 0).
-		StrikeThrough(a&Attr(tcell.AttrStrikeThrough) != 0).
 		Italic(a&Attr(tcell.AttrItalic) != 0)
-	style = w.withUrl(style)

 	gr := uniseg.NewGraphemes(text)
-Loop:
 	for gr.Next() {
-		st := style
 		rs := gr.Runes()
-		if len(rs) == 1 {
-			r := rs[0]
-			switch r {
-			case '\r':
-				st = style.Dim(true)
-				rs[0] = '␍'
-			case '\n':
-				w.lastY++
-				w.lastX = 0
-				lx = 0
-				continue Loop
-			}
+		if len(rs) == 1 && rs[0] == '\n' {
+			w.lastY++
+			w.lastX = 0
+			lx = 0
+			continue
 		}

 		// word wrap:
 		xPos := w.left + w.lastX + lx
-		if xPos >= w.left+w.width {
+		if xPos >= (w.left + w.width) {
 			w.lastY++
-			if w.lastY >= w.height {
-				return FillSuspend
-			}
 			w.lastX = 0
 			lx = 0
 			xPos = w.left
-			sign := w.wrapSign
-			if w.wrapSignWidth > w.width {
-				runes, _ := util.Truncate(sign, w.width)
-				sign = string(runes)
-			}
-			wgr := uniseg.NewGraphemes(sign)
-			for wgr.Next() {
-				rs := wgr.Runes()
-				_screen.SetContent(w.left+lx, w.top+w.lastY, rs[0], rs[1:], style.Dim(true))
-				lx += uniseg.StringWidth(string(rs))
-			}
-			xPos = w.left + lx
 		}

 		yPos := w.top + w.lastY
@@ -791,8 +638,8 @@ Loop:
 			return FillSuspend
 		}

-		_screen.SetContent(xPos, yPos, rs[0], rs[1:], st)
-		lx += util.StringWidth(string(rs))
+		_screen.SetContent(xPos, yPos, rs[0], rs[1:], style)
+		lx += runewidth.StringWidth(string(rs))
 	}
 	w.lastX += lx
 	if w.lastX == w.width {
@@ -808,16 +655,6 @@ func (w *TcellWindow) Fill(str string) FillReturn {
 	return w.fillString(str, w.normal)
 }

-func (w *TcellWindow) LinkBegin(uri string, params string) {
-	w.uri = &uri
-	w.params = &params
-}
-
-func (w *TcellWindow) LinkEnd() {
-	w.uri = nil
-	w.params = nil
-}
-
 func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
 	if fg == colDefault {
 		fg = w.normal.Fg()
@@ -828,18 +665,7 @@ func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
 	return w.fillString(str, NewColorPair(fg, bg, a))
 }

-func (w *TcellWindow) DrawBorder() {
-	w.drawBorder(false)
-}
-
-func (w *TcellWindow) DrawHBorder() {
-	w.drawBorder(true)
-}
-
-func (w *TcellWindow) drawBorder(onlyHorizontal bool) {
-	if w.height == 0 {
-		return
-	}
+func (w *TcellWindow) drawBorder() {
 	shape := w.borderStyle.shape
 	if shape == BorderNone {
 		return
@@ -852,68 +678,44 @@ func (w *TcellWindow) drawBorder(onlyHorizontal bool) {

 	var style tcell.Style
 	if w.color {
-		switch w.windowType {
-		case WindowBase:
-			style = ColBorder.style()
-		case WindowList:
-			style = ColListBorder.style()
-		case WindowHeader:
-			style = ColHeaderBorder.style()
-		case WindowInput:
-			style = ColInputBorder.style()
-		case WindowPreview:
+		if w.preview {
 			style = ColPreviewBorder.style()
+		} else {
+			style = ColBorder.style()
 		}
 	} else {
 		style = w.normal.style()
 	}

-	hw := runeWidth(w.borderStyle.top)
 	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderTop:
-		max := right - 2*hw
-		if shape == BorderHorizontal || shape == BorderTop {
-			max = right - hw
-		}
-		// tcell has an issue displaying two overlapping wide runes
-		// e.g.  SetContent(  HH  )
-		//       SetContent(   TR )
-		//       ==================
-		//                 (  HH  ) => TR is ignored
-		for x := left; x <= max; x += hw {
-			_screen.SetContent(x, top, w.borderStyle.top, nil, style)
+	case BorderRounded, BorderSharp, BorderHorizontal, BorderTop:
+		for x := left; x < right; x++ {
+			_screen.SetContent(x, top, w.borderStyle.horizontal, nil, style)
 		}
 	}
 	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderBottom:
-		max := right - 2*hw
-		if shape == BorderHorizontal || shape == BorderBottom {
-			max = right - hw
-		}
-		for x := left; x <= max; x += hw {
-			_screen.SetContent(x, bot-1, w.borderStyle.bottom, nil, style)
-		}
-	}
-	if !onlyHorizontal {
-		switch shape {
-		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderLeft:
-			for y := top; y < bot; y++ {
-				_screen.SetContent(left, y, w.borderStyle.left, nil, style)
-			}
-		}
-		switch shape {
-		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderRight:
-			vw := runeWidth(w.borderStyle.right)
-			for y := top; y < bot; y++ {
-				_screen.SetContent(right-vw, y, w.borderStyle.right, nil, style)
-			}
+	case BorderRounded, BorderSharp, BorderHorizontal, BorderBottom:
+		for x := left; x < right; x++ {
+			_screen.SetContent(x, bot-1, w.borderStyle.horizontal, nil, style)
 		}
 	}
 	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble:
+	case BorderRounded, BorderSharp, BorderVertical, BorderLeft:
+		for y := top; y < bot; y++ {
+			_screen.SetContent(left, y, w.borderStyle.vertical, nil, style)
+		}
+	}
+	switch shape {
+	case BorderRounded, BorderSharp, BorderVertical, BorderRight:
+		for y := top; y < bot; y++ {
+			_screen.SetContent(right-1, y, w.borderStyle.vertical, nil, style)
+		}
+	}
+	switch shape {
+	case BorderRounded, BorderSharp:
 		_screen.SetContent(left, top, w.borderStyle.topLeft, nil, style)
-		_screen.SetContent(right-runeWidth(w.borderStyle.topRight), top, w.borderStyle.topRight, nil, style)
+		_screen.SetContent(right-1, top, w.borderStyle.topRight, nil, style)
 		_screen.SetContent(left, bot-1, w.borderStyle.bottomLeft, nil, style)
-		_screen.SetContent(right-runeWidth(w.borderStyle.bottomRight), bot-1, w.borderStyle.bottomRight, nil, style)
+		_screen.SetContent(right-1, bot-1, w.borderStyle.bottomRight, nil, style)
 	}
 }
--- a/src/tui/tcell_test.go
+++ b/src/tui/tcell_test.go
@@ -3,10 +3,9 @@
 package tui

 import (
-	"os"
 	"testing"

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

@@ -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
@@ -82,9 +81,9 @@ func TestGetCharEventKey(t *testing.T) {
 		{giveKey{tcell.KeyTab, rune(tcell.KeyTab), tcell.ModNone}, wantKey{Tab, 0, nil}},     // unhandled, actual "Tab" keystroke
 		{giveKey{tcell.KeyTAB, rune(tcell.KeyTAB), tcell.ModNone}, wantKey{Tab, 0, nil}},     // fabricated, unhandled
 		// KeyEnter is alias for KeyCR
-		{giveKey{tcell.KeyCtrlM, rune(tcell.KeyCtrlM), tcell.ModNone}, wantKey{Enter, 0, nil}}, // actual "Enter" keystroke
-		{giveKey{tcell.KeyCR, rune(tcell.KeyCR), tcell.ModNone}, wantKey{Enter, 0, nil}},       // fabricated, unhandled
-		{giveKey{tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone}, wantKey{Enter, 0, nil}}, // fabricated, unhandled
+		{giveKey{tcell.KeyCtrlM, rune(tcell.KeyCtrlM), tcell.ModNone}, wantKey{CtrlM, 0, nil}}, // actual "Enter" keystroke
+		{giveKey{tcell.KeyCR, rune(tcell.KeyCR), tcell.ModNone}, wantKey{CtrlM, 0, nil}},       // fabricated, unhandled
+		{giveKey{tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone}, wantKey{CtrlM, 0, nil}}, // fabricated, unhandled
 		// Ctrl+Alt keys
 		{giveKey{tcell.KeyCtrlA, rune(tcell.KeyCtrlA), tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAlt, 'a', nil}},                  // fabricated
 		{giveKey{tcell.KeyCtrlA, rune(tcell.KeyCtrlA), tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{CtrlAlt, 'a', nil}}, // fabricated
@@ -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)
@@ -233,7 +230,7 @@ Quick reference
 10	1	KeyCtrlJ	KeyLF = ^J		CtrlJ
 11	1	KeyCtrlK	KeyVT = ^K		CtrlK
 12	1	KeyCtrlL	KeyFF = ^L		CtrlL
-13	1	KeyCtrlM	KeyCR = ^M	KeyEnter	Enter
+13	1	KeyCtrlM	KeyCR = ^M	KeyEnter	CtrlM
 14	1	KeyCtrlN	KeySO = ^N		CtrlN
 15	1	KeyCtrlO	KeySI = ^O		CtrlO
 16	1	KeyCtrlP	KeyDLE = ^P		CtrlP
@@ -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
@@ -3,52 +3,45 @@
 package tui

 import (
+	"io/ioutil"
 	"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 ""
 	}

 	for _, prefix := range devPrefixes {
-		files, err := os.ReadDir(prefix)
+		files, err := ioutil.ReadDir(prefix)
 		if err != nil {
 			continue
 		}

 		for _, file := range files {
-			info, err := file.Info()
-			if err != nil {
-				continue
-			}
-			if stat, ok := info.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
-				value := prefix + file.Name()
-				tty.Store(value)
-				return value
+			if stat, ok := file.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
+				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
-}
-
-// TtyOut 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
--- 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
@@ -189,32 +159,11 @@ func (chars *Chars) TrimTrailingWhitespaces() {
 	chars.slice = chars.slice[0 : len(chars.slice)-whitespaces]
 }

-func (chars *Chars) TrimSuffix(runes []rune) {
-	lastIdx := len(chars.slice)
-	firstIdx := lastIdx - len(runes)
-	if firstIdx < 0 {
-		return
-	}
-
-	for i := firstIdx; i < lastIdx; i++ {
-		char := chars.Get(i)
-		if char != runes[i-firstIdx] {
-			return
-		}
-	}
-
-	chars.slice = chars.slice[0:firstIdx]
-}
-
-func (chars *Chars) SliceRight(last int) {
-	chars.slice = chars.slice[:last]
-}
-
 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 {
@@ -229,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)
 	}
 }
@@ -247,85 +196,3 @@ func (chars *Chars) Prepend(prefix string) {
 		chars.slice = append([]byte(prefix), chars.slice...)
 	}
 }
-
-func (chars *Chars) Lines(multiLine bool, maxLines int, wrapCols int, wrapSignWidth int, tabstop int) ([][]rune, bool) {
-	text := make([]rune, chars.Length())
-	copy(text, chars.ToRunes())
-
-	lines := [][]rune{}
-	overflow := false
-	if !multiLine {
-		lines = append(lines, text)
-	} else {
-		from := 0
-		for off := 0; off < len(text); off++ {
-			if text[off] == '\n' {
-				lines = append(lines, text[from:off+1]) // Include '\n'
-				from = off + 1
-				if len(lines) >= maxLines {
-					break
-				}
-			}
-		}
-
-		var lastLine []rune
-		if from < len(text) {
-			lastLine = text[from:]
-		}
-
-		overflow = false
-		if len(lines) >= maxLines {
-			overflow = true
-		} else {
-			lines = append(lines, lastLine)
-		}
-	}
-
-	// If wrapping is disabled, we're done
-	if wrapCols == 0 {
-		return lines, overflow
-	}
-
-	wrapped := [][]rune{}
-	for _, line := range lines {
-		// Remove trailing '\n' and remember if it was there
-		newline := len(line) > 0 && line[len(line)-1] == '\n'
-		if newline {
-			line = line[:len(line)-1]
-		}
-
-		for {
-			cols := wrapCols
-			if len(wrapped) > 0 {
-				cols -= wrapSignWidth
-			}
-			_, overflowIdx := RunesWidth(line, 0, tabstop, cols)
-			if overflowIdx >= 0 {
-				// Might be a wide character
-				if overflowIdx == 0 {
-					overflowIdx = 1
-				}
-				if len(wrapped) >= maxLines {
-					return wrapped, true
-				}
-				wrapped = append(wrapped, line[:overflowIdx])
-				line = line[overflowIdx:]
-				continue
-			}
-
-			// Restore trailing '\n'
-			if newline {
-				line = append(line, '\n')
-			}
-
-			if len(wrapped) >= maxLines {
-				return wrapped, true
-			}
-
-			wrapped = append(wrapped, line)
-			break
-		}
-	}
-
-	return wrapped, overflow
-}
--- a/src/util/chars_test.go
+++ b/src/util/chars_test.go
@@ -1,9 +1,6 @@
 package util

-import (
-	"fmt"
-	"testing"
-)
+import "testing"

 func TestToCharsAscii(t *testing.T) {
 	chars := ToChars([]byte("foobar"))
@@ -47,37 +44,3 @@ func TestTrimLength(t *testing.T) {
 	check("  h   o  ", 5)
 	check("         ", 0)
 }
-
-func TestCharsLines(t *testing.T) {
-	chars := ToChars([]byte("abcdef\n가나다\n\tdef"))
-	check := func(multiLine bool, maxLines int, wrapCols int, wrapSignWidth int, tabstop int, expectedNumLines int, expectedOverflow bool) {
-		lines, overflow := chars.Lines(multiLine, maxLines, wrapCols, wrapSignWidth, tabstop)
-		fmt.Println(lines, overflow)
-		if len(lines) != expectedNumLines || overflow != expectedOverflow {
-			t.Errorf("Invalid result: %d %v (expected %d %v)", len(lines), overflow, expectedNumLines, expectedOverflow)
-		}
-	}
-
-	// No wrap
-	check(true, 1, 0, 0, 8, 1, true)
-	check(true, 2, 0, 0, 8, 2, true)
-	check(true, 3, 0, 0, 8, 3, false)
-
-	// Wrap (2)
-	check(true, 4, 2, 0, 8, 4, true)
-	check(true, 5, 2, 0, 8, 5, true)
-	check(true, 6, 2, 0, 8, 6, true)
-	check(true, 7, 2, 0, 8, 7, true)
-	check(true, 8, 2, 0, 8, 8, true)
-	check(true, 9, 2, 0, 8, 9, false)
-	check(true, 9, 2, 0, 1, 8, false) // Smaller tab size
-
-	// With wrap sign (3 + 1)
-	check(true, 100, 3, 1, 1, 8, false)
-
-	// With wrap sign (3 + 2)
-	check(true, 100, 3, 2, 1, 12, false)
-
-	// With wrap sign (3 + 2) and no multi-line
-	check(false, 100, 3, 2, 1, 13, false)
-}
--- a/src/util/eventbox_test.go
+++ b/src/util/eventbox_test.go
@@ -9,6 +9,7 @@ const (
 	EvtSearchNew
 	EvtSearchProgress
 	EvtSearchFin
+	EvtClose
 )

 func TestEventBox(t *testing.T) {
--- a/src/util/util.go
+++ b/src/util/util.go
@@ -3,19 +3,14 @@ package util
 import (
 	"math"
 	"os"
-	"strconv"
 	"strings"
 	"time"

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

-// StringWidth returns string width where each CR/LF character takes 1 column
-func StringWidth(s string) int {
-	return uniseg.StringWidth(s) + strings.Count(s, "\n") + strings.Count(s, "\r")
-}
-
 // RunesWidth returns runes width
 func RunesWidth(runes []rune, prefixWidth int, tabstop int, limit int) (int, int) {
 	width := 0
@@ -27,7 +22,8 @@ func RunesWidth(runes []rune, prefixWidth int, tabstop int, limit int) (int, int
 		if len(rs) == 1 && rs[0] == '\t' {
 			w = tabstop - (prefixWidth+width)%tabstop
 		} else {
-			w = StringWidth(string(rs))
+			s := string(rs)
+			w = runewidth.StringWidth(s) + strings.Count(s, "\n")
 		}
 		width += w
 		if width > limit {
@@ -45,7 +41,7 @@ func Truncate(input string, limit int) ([]rune, int) {
 	gr := uniseg.NewGraphemes(input)
 	for gr.Next() {
 		rs := gr.Runes()
-		w := StringWidth(string(rs))
+		w := runewidth.StringWidth(string(rs))
 		if width+w > limit {
 			return runes, width
 		}
@@ -138,20 +134,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())
 }

-// RunOnce runs the given function only once
-func RunOnce(f func()) func() {
-	once := Once(true)
-	return func() {
-		if once() {
-			f()
-		}
-	}
+// 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
@@ -159,70 +149,7 @@ func Once(nextResponse bool) func() bool {
 	state := nextResponse
 	return func() bool {
 		prevState := state
-		state = !nextResponse
+		state = false
 		return prevState
 	}
 }
-
-// RepeatToFill repeats the given string to fill the given width
-func RepeatToFill(str string, length int, limit int) string {
-	times := limit / length
-	rest := limit % length
-	output := strings.Repeat(str, times)
-	if rest > 0 {
-		for _, r := range str {
-			rest -= uniseg.StringWidth(string(r))
-			if rest < 0 {
-				break
-			}
-			output += string(r)
-			if rest == 0 {
-				break
-			}
-		}
-	}
-	return output
-}
-
-// ToKebabCase converts the given CamelCase string to kebab-case
-func ToKebabCase(s string) string {
-	name := ""
-	for i, r := range s {
-		if i > 0 && r >= 'A' && r <= 'Z' {
-			name += "-"
-		}
-		name += string(r)
-	}
-	return strings.ToLower(name)
-}
-
-// 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
@@ -1,76 +1,14 @@
 package util

-import (
-	"math"
-	"strings"
-	"testing"
-	"time"
-)
+import "testing"

 func TestMax(t *testing.T) {
-	if Max(10, 1) != 10 {
-		t.Error("Expected", 10)
-	}
 	if Max(-2, 5) != 5 {
-		t.Error("Expected", 5)
+		t.Error("Invalid result")
 	}
 }

-func TestMax16(t *testing.T) {
-	if Max16(10, 1) != 10 {
-		t.Error("Expected", 10)
-	}
-	if Max16(-2, 5) != 5 {
-		t.Error("Expected", 5)
-	}
-	if Max16(math.MaxInt16, 0) != math.MaxInt16 {
-		t.Error("Expected", math.MaxInt16)
-	}
-	if Max16(0, math.MinInt16) != 0 {
-		t.Error("Expected", 0)
-	}
-}
-
-func TestMax32(t *testing.T) {
-	if Max32(10, 1) != 10 {
-		t.Error("Expected", 10)
-	}
-	if Max32(-2, 5) != 5 {
-		t.Error("Expected", 5)
-	}
-	if Max32(math.MaxInt32, 0) != math.MaxInt32 {
-		t.Error("Expected", math.MaxInt32)
-	}
-	if Max32(0, math.MinInt32) != 0 {
-		t.Error("Expected", 0)
-	}
-}
-
-func TestMin(t *testing.T) {
-	if Min(10, 1) != 1 {
-		t.Error("Expected", 1)
-	}
-	if Min(-2, 5) != -2 {
-		t.Error("Expected", -2)
-	}
-}
-
-func TestMin32(t *testing.T) {
-	if Min32(10, 1) != 1 {
-		t.Error("Expected", 1)
-	}
-	if Min32(-2, 5) != -2 {
-		t.Error("Expected", -2)
-	}
-	if Min32(math.MaxInt32, 0) != 0 {
-		t.Error("Expected", 0)
-	}
-	if Min32(0, math.MinInt32) != math.MinInt32 {
-		t.Error("Expected", math.MinInt32)
-	}
-}
-
-func TestConstrain(t *testing.T) {
+func TestContrain(t *testing.T) {
 	if Constrain(-3, -1, 3) != -1 {
 		t.Error("Expected", -1)
 	}
@@ -83,65 +21,13 @@ func TestConstrain(t *testing.T) {
 	}
 }

-func TestConstrain32(t *testing.T) {
-	if Constrain32(-3, -1, 3) != -1 {
-		t.Error("Expected", -1)
-	}
-	if Constrain32(2, -1, 3) != 2 {
-		t.Error("Expected", 2)
-	}
-
-	if Constrain32(5, -1, 3) != 3 {
-		t.Error("Expected", 3)
-	}
-	if Constrain32(0, math.MinInt32, math.MaxInt32) != 0 {
-		t.Error("Expected", 0)
-	}
-}
-
-func TestAsUint16(t *testing.T) {
-	if AsUint16(5) != 5 {
-		t.Error("Expected", 5)
-	}
-	if AsUint16(-10) != 0 {
-		t.Error("Expected", 0)
-	}
-	if AsUint16(math.MaxUint16) != math.MaxUint16 {
-		t.Error("Expected", math.MaxUint16)
-	}
-	if AsUint16(math.MinInt32) != 0 {
-		t.Error("Expected", 0)
-	}
-	if AsUint16(math.MinInt16) != 0 {
-		t.Error("Expected", 0)
-	}
-	if AsUint16(math.MaxUint16+1) != math.MaxUint16 {
-		t.Error("Expected", math.MaxUint16)
-	}
-}
-
-func TestDurWithIn(t *testing.T) {
-	if DurWithin(time.Duration(5), time.Duration(1), time.Duration(8)) != time.Duration(5) {
-		t.Error("Expected", time.Duration(0))
-	}
-	if DurWithin(time.Duration(0)*time.Second, time.Second, time.Duration(3)*time.Second) != time.Second {
-		t.Error("Expected", time.Second)
-	}
-	if DurWithin(time.Duration(10)*time.Second, time.Duration(0), time.Second) != time.Second {
-		t.Error("Expected", time.Second)
-	}
-}
-
 func TestOnce(t *testing.T) {
 	o := Once(false)
 	if o() {
 		t.Error("Expected: false")
 	}
-	if !o() {
-		t.Error("Expected: true")
-	}
-	if !o() {
-		t.Error("Expected: true")
+	if o() {
+		t.Error("Expected: false")
 	}

 	o = Once(true)
@@ -151,9 +37,6 @@ func TestOnce(t *testing.T) {
 	if o() {
 		t.Error("Expected: false")
 	}
-	if o() {
-		t.Error("Expected: false")
-	}
 }

 func TestRunesWidth(t *testing.T) {
@@ -170,18 +53,6 @@ func TestRunesWidth(t *testing.T) {
 			t.Errorf("Expected overflow index: %d, actual: %d", args[2], overflowIdx)
 		}
 	}
-	for _, input := range []struct {
-		s string
-		w int
-	}{
-		{"▶", 1},
-		{"▶️", 2},
-	} {
-		width, _ := RunesWidth([]rune(input.s), 0, 0, 100)
-		if width != input.w {
-			t.Errorf("Expected width of %s: %d, actual: %d", input.s, input.w, width)
-		}
-	}
 }

 func TestTruncate(t *testing.T) {
@@ -193,50 +64,3 @@ func TestTruncate(t *testing.T) {
 		t.Errorf("Expected: 6, actual: %d", width)
 	}
 }
-
-func TestRepeatToFill(t *testing.T) {
-	if RepeatToFill("abcde", 10, 50) != strings.Repeat("abcde", 5) {
-		t.Error("Expected:", strings.Repeat("abcde", 5))
-	}
-	if RepeatToFill("abcde", 10, 42) != strings.Repeat("abcde", 4)+"abcde"[:2] {
-		t.Error("Expected:", strings.Repeat("abcde", 4)+"abcde"[:2])
-	}
-}
-
-func TestStringWidth(t *testing.T) {
-	w := StringWidth("─")
-	if w != 1 {
-		t.Errorf("Expected: %d, Actual: %d", 1, w)
-	}
-}
-
-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/Show More
+++ b/Show More