0.31.0

2025-11-14 14:23:47 -05:00 · 2022-07-21 22:46:34 +09:00
62 changed files with 1743 additions and 5230 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/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -27,18 +27,18 @@ jobs:

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

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

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

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
+      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@v3
-      - name: 'Dependency Review'
-        uses: actions/dependency-review-action@v3
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -15,25 +15,25 @@ jobs:
  build:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@629c2de402a417ea7690ca6ce3f33229e27606a5 # v2
      with:
        fetch-depth: 0

    - name: Set up Go
-      uses: actions/setup-go@v4
+      uses: actions/setup-go@f6164bd8c8acb4a71fb2791a8b6c4024ff038dab # v2
      with:
-        go-version: 1.19
+        go-version: 1.18

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

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

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

    - name: Rubocop
      run: rubocop --require rubocop-minitest --require rubocop-performance
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -15,17 +15,17 @@ jobs:
  build:
    runs-on: macos-latest
    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@629c2de402a417ea7690ca6ce3f33229e27606a5 # v2
      with:
        fetch-depth: 0

    - name: Set up Go
-      uses: actions/setup-go@v4
+      uses: actions/setup-go@f6164bd8c8acb4a71fb2791a8b6c4024ff038dab # v2
      with:
        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/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@v3
-    - uses: crate-ci/typos@v1.14.10
--- a/.github/workflows/winget.yml
+++ b/.github/workflows/winget.yml
@@ -1,15 +0,0 @@
-name: Publish to Winget
-on:
-  release:
-    types: [released]
-
-jobs:
-  publish:
-    runs-on: windows-latest # Action can only run on Windows
-    steps:
-      - uses: vedantmgoyal2009/winget-releaser@v2
-        with:
-          identifier: junegunn.fzf
-          version: ${{ github.event.release.tag_name }}
-          installers-regex: '-windows_(armv7|arm64|amd64)\.zip$'
-          token: ${{ secrets.WINGET_TOKEN }}
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -18,7 +18,7 @@ builds:
      post: |
        sh -c '
        cat > /tmp/fzf-gon-amd64.hcl << EOF
-        source = ["./dist/fzf-macos_darwin_amd64_v1/fzf"]
+        source = ["./dist/fzf-macos_darwin_amd64/fzf"]
        bundle_id = "kr.junegunn.fzf"
        apple_id {
          username = "junegunn.c@gmail.com"
@@ -72,9 +72,6 @@ builds:
      - amd64
      - arm
      - arm64
-      - loong64
-      - ppc64le
-      - s390x
    goarm:
      - 5
      - 6
@@ -102,10 +99,6 @@ archives:
    files:
      - non-existent*

-checksum:
-  extra_files:
-    - glob: ./dist/fzf-*darwin*.zip
-
 release:
  github:
    owner: junegunn
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -26,7 +26,3 @@ Style/OptionalBooleanParameter:
  Enabled: false
 Style/WordArray:
  MinSize: 1
-Minitest/AssertEqual:
-  Enabled: false
-Naming/VariableNumber:
-  Enabled: false
--- a/.tool-versions
+++ b/.tool-versions
@@ -1 +1 @@
-golang 1.20.4
+golang 1.18
--- a/ADVANCED.md
+++ b/ADVANCED.md
@@ -1,33 +1,30 @@
 Advanced fzf examples
 ======================

-* *Last update: 2023/05/26*
-* *Requires fzf 0.41.0 or above*
-
---
+*(Last update: 2021/05/22)*

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

 * [Introduction](#introduction)
 * [Screen Layout](#screen-layout)
-    * [`--height`](#--height)
-    * [`fzf-tmux`](#fzf-tmux)
-        * [Popup window support](#popup-window-support)
+  * [`--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)
+  * [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)
+  * [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)
-    * [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 -->

@@ -239,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.
@@ -308,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
@@ -336,22 +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 start fzf with
-  an empty input (`: | fzf`), then we make it start the initial Ripgrep
-  process immediately via `start:reload` binding. This way, fzf owns the
-  initial Ripgrep process so it can kill it on the next `reload`. Otherwise,
-  the process will keep running in the background.
+- 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
@@ -360,6 +358,8 @@ 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.
@@ -375,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
@@ -405,8 +408,10 @@ 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
@@ -416,32 +421,25 @@ 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})'
+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]}"
 ```

- 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
-
 Log tailing
 -----------

@@ -467,17 +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:reload:$command' \
-    --bind 'ctrl-r:reload:$command' \
-    --bind 'ctrl-/:change-preview-window(80%,border-bottom|hidden|)' \
-    --bind 'enter:execute:kubectl exec -it --namespace {1} {2} -- bash > /dev/tty' \
-    --bind 'ctrl-o:execute:${EDITOR:-vim} <(kubectl logs --all-containers --namespace {1} {2}) > /dev/tty' \
-    --preview-window up:follow \
-    --preview 'kubectl logs --follow --all-containers --tail=10000 --namespace {1} {2}' "$@"
+  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}' "$@"
 }
 ```

@@ -499,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`

@@ -529,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
 ------------

--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,417 +1,6 @@
 CHANGELOG
 =========

-0.41.1
------
- Fixed a bug where preview window is not updated when `--disabled` is set and
-  a reload is triggered by `change:reload` binding
-
-0.41.0
------
- Added color name `preview-border` and `preview-scrollbar`
- Added new border style `block` which uses [block elements](https://en.wikipedia.org/wiki/Block_Elements)
- `--scrollbar` can take two characters, one for the main window, the other
-  for the preview window
- Putting it altogether:
-  ```sh
-  fzf-tmux -p 80% --padding 1,2 --preview 'bat --style=plain --color=always {}' \
-      --color 'bg:237,bg+:235,gutter:237,border:238,scrollbar:236' \
-      --color 'preview-bg:235,preview-border:236,preview-scrollbar:234' \
-      --preview-window 'border-block' --border block --scrollbar '▌▐'
-  ```
- Bug fixes and improvements
-
-0.40.0
------
- Added `zero` event that is triggered when there's no match
-  ```sh
-  # Reload the candidate list when there's no match
-  echo $RANDOM | fzf --bind 'zero:reload(echo $RANDOM)+clear-query' --height 3
-  ```
- New actions
-    - Added `track` action which makes fzf track the current item when the
-      search result is updated. If the user manually moves the cursor, or the
-      item is not in the updated search result, tracking is automatically
-      disabled. Tracking is useful when you want to see the surrounding items
-      by deleting the query string.
-      ```sh
-      # Narrow down the list with a query, point to a command,
-      # and hit CTRL-T to see its surrounding commands.
-      export FZF_CTRL_R_OPTS="
-        --preview 'echo {}' --preview-window up:3:hidden:wrap
-        --bind 'ctrl-/:toggle-preview'
-        --bind 'ctrl-t:track+clear-query'
-        --bind 'ctrl-y:execute-silent(echo -n {2..} | pbcopy)+abort'
-        --color header:italic
-        --header 'Press CTRL-Y to copy command into clipboard'"
-      ```
-    - Added `change-header(...)`
-    - Added `transform-header(...)`
-    - Added `toggle-track` action
- Fixed `--track` behavior when used with `--tac`
-    - However, using `--track` with `--tac` is not recommended. The resulting
-      behavior can be very confusing.
- Bug fixes and improvements
-
-0.39.0
------
- Added `one` event that is triggered when there's only one match
-  ```sh
-  # Automatically select the only match
-  seq 10 | fzf --bind one:accept
-  ```
- Added `--track` option that makes fzf track the current selection when the
-  result list is updated. This can be useful when browsing logs using fzf with
-  sorting disabled.
-  ```sh
-  git log --oneline --graph --color=always | nl |
-      fzf --ansi --track --no-sort --layout=reverse-list
-  ```
- If you use `--listen` option without a port number fzf will automatically
-  allocate an available port and export it as `$FZF_PORT` environment
-  variable.
-  ```sh
-  # Automatic port assignment
-  fzf --listen --bind 'start:execute-silent:echo $FZF_PORT > /tmp/fzf-port'
-
-  # Say hello
-  curl "localhost:$(cat /tmp/fzf-port)" -d 'preview:echo Hello, fzf is listening on $FZF_PORT.'
-  ```
- A carriage return and a line feed character will be rendered as dim ␍ and
-  ␊ respectively.
-  ```sh
-  printf "foo\rbar\nbaz" | fzf --read0 --preview 'echo {}'
-  ```
- fzf will stop rendering a non-displayable characters as a space. This will
-  likely cause less glitches in the preview window.
-  ```sh
-  fzf --preview 'head -1000 /dev/random'
-  ```
- Bug fixes and improvements
-
-0.38.0
------
- New actions
-    - `become(...)` - Replace the current fzf process with the specified
-      command using `execve(2)` system call.
-      See https://github.com/junegunn/fzf#turning-into-a-different-process for
-      more information.
-      ```sh
-      # Open selected files in Vim
-      fzf --multi --bind 'enter:become(vim {+})'
-
-      # Open the file in Vim and go to the line
-      git grep --line-number . |
-          fzf --delimiter : --nth 3.. --bind 'enter:become(vim {1} +{2})'
-      ```
-        - This action is not supported on Windows
-    - `show-preview`
-    - `hide-preview`
- Bug fixes
-    - `--preview-window 0,hidden` should not execute the preview command until
-      `toggle-preview` action is triggered
-
-0.37.0
------
- Added a way to customize the separator of inline info
-  ```sh
-  fzf --info 'inline: ╱ ' --prompt '╱ ' --color prompt:bright-yellow
-  ```
- New event
-    - `focus` - Triggered when the focus changes due to a vertical cursor
-      movement or a search result update
-      ```sh
-      fzf --bind 'focus:transform-preview-label:echo [ {} ]' --preview 'cat {}'
-
-      # Any action bound to the event runs synchronously and thus can make the interface sluggish
-      # e.g. lolcat isn't one of the fastest programs, and every cursor movement in
-      #      fzf will be noticeably affected by its execution time
-      fzf --bind 'focus:transform-preview-label:echo [ {} ] | lolcat -f' --preview 'cat {}'
-
-      # Beware not to introduce an infinite loop
-      seq 10 | fzf --bind 'focus:up' --cycle
-      ```
- New actions
-    - `change-border-label`
-    - `change-preview-label`
-    - `transform-border-label`
-    - `transform-preview-label`
- Bug fixes and improvements
-
-0.36.0
------
- Added `--listen=HTTP_PORT` option to start HTTP server. It allows external
-  processes to send actions to perform via POST method.
-  ```sh
-  # Start HTTP server on port 6266
-  fzf --listen 6266
-
-  # Send actions to the server
-  curl -XPOST localhost:6266 -d 'reload(seq 100)+change-prompt(hundred> )'
-  ```
- Added draggable scrollbar to the main search window and the preview window
-  ```sh
-  # Hide scrollbar
-  fzf --no-scrollbar
-
-  # Customize scrollbar
-  fzf --scrollbar ┆ --color scrollbar:blue
-  ```
- New event
-    - Added `load` event that is triggered when the input stream is complete
-      and the initial processing of the list is complete.
-      ```sh
-      # Change the prompt to "loaded" when the input stream is complete
-      (seq 10; sleep 1; seq 11 20) | fzf --prompt 'Loading> ' --bind 'load:change-prompt:Loaded> '
-
-      # You can use it instead of 'start' event without `--sync` if asynchronous
-      # trigger is not an issue.
-      (seq 10; sleep 1; seq 11 20) | fzf --bind 'load:last'
-      ```
- New actions
-    - Added `pos(...)` action to move the cursor to the numeric position
-        - `first` and `last` are equivalent to `pos(1)` and `pos(-1)` respectively
-      ```sh
-      # Put the cursor on the 10th item
-      seq 100 | fzf --sync --bind 'start:pos(10)'
-
-      # Put the cursor on the 10th to last item
-      seq 100 | fzf --sync --bind 'start:pos(-10)'
-      ```
-    - Added `reload-sync(...)` action which replaces the current list only after
-      the reload process is complete. This is useful when the command takes
-      a while to produce the initial output and you don't want fzf to run against
-      an empty list while the command is running.
-      ```sh
-      # You can still filter and select entries from the initial list for 3 seconds
-      seq 100 | fzf --bind 'load:reload-sync(sleep 3; seq 1000)+unbind(load)'
-      ```
-    - Added `next-selected` and `prev-selected` actions to move between selected
-      items
-      ```sh
-      # `next-selected` will move the pointer to the next selected item below the current line
-      # `prev-selected` will move the pointer to the previous selected item above the current line
-      seq 10 | fzf --multi --bind ctrl-n:next-selected,ctrl-p:prev-selected
-
-      # Both actions respect --layout option
-      seq 10 | fzf --multi --bind ctrl-n:next-selected,ctrl-p:prev-selected --layout reverse
-      ```
-    - Added `change-query(...)` action that simply changes the query string to the
-      given static string. This can be useful when used with `--listen`.
-      ```sh
-      curl localhost:6266 -d "change-query:$(date)"
-      ```
-    - Added `transform-prompt(...)` action for transforming the prompt string
-      using an external command
-      ```sh
-      # Press space to change the prompt string using an external command
-      # (only the first line of the output is taken)
-      fzf --bind 'space:reload(ls),load:transform-prompt(printf "%s> " "$(date)")'
-      ```
-    - Added `transform-query(...)` action for transforming the query string using
-      an external command
-      ```sh
-      # Press space to convert the query to uppercase letters
-      fzf --bind 'space:transform-query(tr "[:lower:]" "[:upper:]" <<< {q})'
-
-      # Bind it to 'change' event for automatic conversion
-      fzf --bind 'change:transform-query(tr "[:lower:]" "[:upper:]" <<< {q})'
-
-      # Can only type numbers
-      fzf --bind 'change:transform-query(sed "s/[^0-9]//g" <<< {q})'
-      ```
-    - `put` action can optionally take an argument string
-      ```sh
-      # a will put 'alpha' on the prompt, ctrl-b will put 'bravo'
-      fzf --bind 'a:put+put(lpha),ctrl-b:put(bravo)'
-      ```
- Added color name `preview-label` for `--preview-label` (defaults to `label`
-  for `--border-label`)
- Better support for (Windows) terminals where each box-drawing character
-  takes 2 columns. Set `RUNEWIDTH_EASTASIAN` environment variable to `0` or `1`.
-    - On Vim, the variable will be automatically set if `&ambiwidth` is `double`
- Behavior changes
-    - fzf will always execute the preview command if the command template
-      contains `{q}` even when it's empty. If you prefer the old behavior,
-      you'll have to check if `{q}` is empty in your command.
-      ```sh
-      # This will show // even when the query is empty
-      : | fzf --preview 'echo /{q}/'
-
-      # But if you don't want it,
-      : | fzf --preview '[ -n {q} ] || exit; echo /{q}/'
-      ```
-    - `double-click` will behave the same as `enter` unless otherwise specified,
-      so you don't have to repeat the same action twice in `--bind` in most cases.
-      ```sh
-      # No need to bind 'double-click' to the same action
-      fzf --bind 'enter:execute:less {}' # --bind 'double-click:execute:less {}'
-      ```
-    - If the color for `separator` is not specified, it will default to the
-      color for `border`. Same holds true for `scrollbar`. This is to reduce
-      the number of configuration items required to achieve a consistent color
-      scheme.
-    - If `follow` flag is specified in `--preview-window` option, fzf will
-      automatically scroll to the bottom of the streaming preview output. But
-      when the user manually scrolls the window, the following stops. With
-      this version, fzf will resume following if the user scrolls the window
-      to the bottom.
-    - Default border style on Windows is changed to `sharp` because some
-      Windows terminals are not capable of displaying `rounded` border
-      characters correctly.
- Minor bug fixes and improvements
-
-0.35.1
------
- Fixed a bug where fzf with `--tiebreak=chunk` crashes on inverse match query
- Fixed a bug where clicking above fzf would paste escape sequences
-
-0.35.0
------
- Added `start` event that is triggered only once when fzf finder starts.
-  Since fzf consumes the input stream asynchronously, the input list is not
-  available unless you use `--sync`.
-  ```sh
-  seq 100 | fzf --multi --sync --bind 'start:last+select-all+preview(echo welcome)'
-  ```
- Added `--border-label` and `--border-label-pos` for putting label on the border
-  ```sh
-  # ANSI color codes are supported
-  # (with https://github.com/busyloop/lolcat)
-  label=$(curl -s http://metaphorpsum.com/sentences/1 | lolcat -f)
-
-  # Border label at the center
-  fzf --height=10 --border --border-label="╢ $label ╟" --color=label:italic:black
-
-  # Left-aligned (positive integer)
-  fzf --height=10 --border --border-label="╢ $label ╟" --border-label-pos=3 --color=label:italic:black
-
-  # Right-aligned (negative integer) on the bottom line (:bottom)
-  fzf --height=10 --border --border-label="╢ $label ╟" --border-label-pos=-3:bottom --color=label:italic:black
-  ```
- Also added `--preview-label` and `--preview-label-pos` for the border of the
-  preview window
-  ```sh
-  fzf --preview 'cat {}' --border --preview-label=' Preview ' --preview-label-pos=2
-  ```
- Info panel (match counter) will be followed by a horizontal separator by
-  default
-    - Use `--no-separator` or `--separator=''` to hide the separator
-    - You can specify an arbitrary string that is repeated to form the
-      horizontal separator. e.g. `--separator=╸`
-    - The color of the separator can be customized via `--color=separator:...`
-    - ANSI color codes are also supported
-  ```sh
-  fzf --separator=╸ --color=separator:green
-  fzf --separator=$(lolcat -f -F 1.4 <<< ▁▁▂▃▄▅▆▆▅▄▃▂▁▁) --info=inline
-  ```
- Added `--border=bold` and `--border=double` along with
-  `--preview-window=border-bold` and `--preview-window=border-double`
-
-0.34.0
------
- Added support for adaptive `--height`. If the `--height` value is prefixed
-  with `~`, fzf will automatically determine the height in the range according
-  to the input size.
-  ```sh
-  seq 1 | fzf --height ~70% --border --padding 1 --margin 1
-  seq 10 | fzf --height ~70% --border --padding 1 --margin 1
-  seq 100 | fzf --height ~70% --border --padding 1 --margin 1
-  ```
-    - There are a few limitations
-        - Not compatible with percent top/bottom margin/padding
-          ```sh
-          # This is not allowed (top/bottom margin in percent value)
-          fzf --height ~50% --border --margin 5%,10%
-
-          # This is allowed (top/bottom margin in fixed value)
-          fzf --height ~50% --border --margin 2,10%
-          ```
-        - fzf will not start until it can determine the right height for the input
-          ```sh
-          # fzf will open immediately
-          (sleep 2; seq 10) | fzf --height 50%
-
-          # fzf will open after 2 seconds
-          (sleep 2; seq 10) | fzf --height ~50%
-          (sleep 2; seq 1000) | fzf --height ~50%
-          ```
- Fixed tcell renderer used to render full-screen fzf on Windows
- `--no-clear` is deprecated. Use `reload` action instead.
-
-0.33.0
------
- Added `--scheme=[default|path|history]` option to choose scoring scheme
-    - (Experimental)
-    - We updated the scoring algorithm in 0.32.0, however we have learned that
-      this new scheme (`default`) is not always giving the optimal result
-    - `path`: Additional bonus point is only given to the characters after
-      path separator. You might want to choose this scheme if you have many
-      files with spaces in their paths.
-    - `history`: No additional bonus points are given so that we give more
-      weight to the chronological ordering. This is equivalent to the scoring
-      scheme before 0.32.0. This also sets `--tiebreak=index`.
- ANSI color sequences with colon delimiters are now supported.
-  ```sh
-  printf "\e[38;5;208mOption 1\e[m\nOption 2" | fzf --ansi
-  printf "\e[38:5:208mOption 1\e[m\nOption 2" | fzf --ansi
-  ```
- Support `border-{up,down}` as the synonyms for `border-{top,bottom}` in
-  `--preview-window`
- Added support for ANSI `strikethrough`
-  ```sh
-  printf "\e[9mdeleted" | fzf --ansi
-  fzf --color fg+:strikethrough
-  ```
-
-0.32.1
------
- Fixed incorrect ordering of `--tiebreak=chunk`
- fzf-tmux will show fzf border instead of tmux popup border (requires tmux 3.3)
-  ```sh
-  fzf-tmux -p70%
-  fzf-tmux -p70% --color=border:bright-red
-  fzf-tmux -p100%,60% --color=border:bright-yellow --border=horizontal --padding 1,5 --margin 1,0
-  fzf-tmux -p70%,100% --color=border:bright-green --border=vertical
-
-  # Key bindings (CTRL-T, CTRL-R, ALT-C) will use these options
-  export FZF_TMUX_OPTS='-p100%,60% --color=border:green --border=horizontal --padding 1,5 --margin 1,0'
-  ```
-
-0.32.0
------
- Updated the scoring algorithm
-    - Different bonus points to different categories of word boundaries
-      (listed higher to lower bonus point)
-        - Word after whitespace characters or beginning of the string
-        - Word after common delimiter characters (`/,:;|`)
-        - Word after other non-word characters
-      ```sh
-      # foo/bar.sh` is preferred over `foo-bar.sh` on `bar`
-      fzf --query=bar --height=4 << EOF
-      foo-bar.sh
-      foo/bar.sh
-      EOF
-      ```
- Added a new tiebreak `chunk`
-    - Favors the line with shorter matched chunk. A chunk is a set of
-      consecutive non-whitespace characters.
-    - Unlike the default `length`, this scheme works well with tabular input
-      ```sh
-      # length prefers item #1, because the whole line is shorter,
-      # chunk prefers item #2, because the matched chunk ("foo") is shorter
-      fzf --height=6 --header-lines=2 --tiebreak=chunk --reverse --query=fo << "EOF"
-      N | Field1 | Field2 | Field3
-      - | ------ | ------ | ------
-      1 | hello  | foobar | baz
-      2 | world  | foo    | bazbaz
-      EOF
-      ```
-    - If the input does not contain any spaces, `chunk` is equivalent to
-      `length`. But we're not going to set it as the default because it is
-      computationally more expensive.
- Bug fixes and improvements
-
 0.31.0
 ------
 - Added support for an alternative preview window layout that is activated
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-FROM --platform=linux/amd64 archlinux
+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
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2013-2023 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/10
+++ b/10
@@ -20,7 +20,7 @@ VERSION_REGEX  := $(subst .,\.,$(VERSION_TRIM))
 ifdef FZF_REVISION
 REVISION       := $(FZF_REVISION)
 else
-REVISION       := $(shell git log -n 1 --pretty=format:%h --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)
@@ -29,7 +29,6 @@ BUILD_FLAGS    := -a -ldflags "-s -w -X main.version=$(VERSION) -X main.revision

 BINARY32       := fzf-$(GOOS)_386
 BINARY64       := fzf-$(GOOS)_amd64
-BINARYS390     := fzf-$(GOOS)_s390x
 BINARYARM5     := fzf-$(GOOS)_arm5
 BINARYARM6     := fzf-$(GOOS)_arm6
 BINARYARM7     := fzf-$(GOOS)_arm7
@@ -44,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)
@@ -88,7 +85,7 @@ bench:
 install: bin/fzf

 build:
-	goreleaser build --rm-dist --snapshot --skip-post-hooks
+	goreleaser --rm-dist --snapshot

 release:
 ifndef GITHUB_TOKEN
@@ -135,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 $@
@@ -160,7 +155,6 @@ 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:
--- 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,7 +23,7 @@ written as:
 " If installed using Homebrew
 Plug '/usr/local/opt/fzf'

-" If you have cloned fzf on ~/.fzf directory
+" If installed using git
 Plug '~/.fzf'
 ```

@@ -118,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
@@ -312,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`
@@ -486,4 +483,4 @@ autocmd  FileType fzf set laststatus=0 noshowmode noruler

 The MIT License (MIT)

-Copyright (c) 2013-2023 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi
--- a/README.md
+++ b/README.md
@@ -25,11 +25,11 @@ Table of Contents
 <!-- vim-markdown-toc GFM -->

 * [Installation](#installation)
-    * [Using Homebrew](#using-homebrew)
-    * [Using git](#using-git)
-    * [Using Linux package managers](#using-linux-package-managers)
-    * [Windows](#windows)
-    * [As Vim plugin](#as-vim-plugin)
+  * [Using Homebrew](#using-homebrew)
+  * [Using git](#using-git)
+  * [Using Linux package managers](#using-linux-package-managers)
+  * [Windows](#windows)
+  * [As Vim plugin](#as-vim-plugin)
 * [Upgrading fzf](#upgrading-fzf)
 * [Building fzf](#building-fzf)
 * [Usage](#usage)
@@ -52,14 +52,13 @@ Table of Contents
    * [Custom fuzzy completion](#custom-fuzzy-completion)
 * [Vim plugin](#vim-plugin)
 * [Advanced topics](#advanced-topics)
-    * [Performance](#performance)
-    * [Executing external programs](#executing-external-programs)
-    * [Turning into a different process](#turning-into-a-different-process)
-    * [Reloading the candidate list](#reloading-the-candidate-list)
-        * [1. Update the list of processes by pressing CTRL-R](#1-update-the-list-of-processes-by-pressing-ctrl-r)
-        * [2. Switch between sources by pressing CTRL-D or CTRL-F](#2-switch-between-sources-by-pressing-ctrl-d-or-ctrl-f)
-        * [3. Interactive ripgrep integration](#3-interactive-ripgrep-integration)
-    * [Preview window](#preview-window)
+  * [Performance](#performance)
+  * [Executing external programs](#executing-external-programs)
+  * [Reloading the candidate list](#reloading-the-candidate-list)
+    * [1. Update the list of processes by pressing CTRL-R](#1-update-the-list-of-processes-by-pressing-ctrl-r)
+    * [2. Switch between sources by pressing CTRL-D or CTRL-F](#2-switch-between-sources-by-pressing-ctrl-d-or-ctrl-f)
+    * [3. Interactive ripgrep integration](#3-interactive-ripgrep-integration)
+  * [Preview window](#preview-window)
 * [Tips](#tips)
    * [Respecting `.gitignore`](#respecting-gitignore)
    * [Fish shell](#fish-shell)
@@ -116,7 +115,7 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 | Package Manager | Linux Distribution      | Command                            |
 | ---             | ---                     | ---                                |
 | APK             | Alpine Linux            | `sudo apk add fzf`                 |
-| APT             | Debian 9+/Ubuntu 19.10+ | `sudo apt install fzf`             |
+| APT             | Debian 9+/Ubuntu 19.10+ | `sudo apt-get install fzf`         |
 | Conda           |                         | `conda install -c conda-forge fzf` |
 | DNF             | Fedora                  | `sudo dnf install fzf`             |
 | Nix             | NixOS, etc.             | `nix-env -iA nixpkgs.fzf`          |
@@ -124,31 +123,28 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 | pkg             | FreeBSD                 | `pkg install fzf`                  |
 | pkgin           | NetBSD                  | `pkgin install fzf`                |
 | pkg_add         | OpenBSD                 | `pkg_add fzf`                      |
-| Portage         | Gentoo                  | `emerge --ask app-shells/fzf`      |
 | XBPS            | Void Linux              | `sudo xbps-install -S fzf`         |
 | Zypper          | openSUSE                | `sudo zypper install fzf`          |

 > :warning: **Key bindings (CTRL-T / CTRL-R / ALT-C) and fuzzy auto-completion
 > may not be enabled by default.**
 >
-> Refer to the package documentation for more information. (e.g. `apt show fzf`)
+> Refer to the package documentation for more information. (e.g. `apt-cache show fzf`)

 [![Packaging status](https://repology.org/badge/vertical-allrepos/fzf.svg)](https://repology.org/project/fzf/versions)

 ### Windows

 Pre-built binaries for Windows can be downloaded [here][bin]. fzf is also
-available via [Chocolatey][choco], [Scoop][scoop], and [Winget][winget]:
+available via [Chocolatey][choco] and [Scoop][scoop]:

-| Package manager | Command              |
-| ---             | ---                  |
-| Chocolatey      | `choco install fzf`  |
-| Scoop           | `scoop install fzf`  |
-| Winget          | `winget install fzf` |
+| Package manager | Command             |
+| ---             | ---                 |
+| Chocolatey      | `choco install fzf` |
+| Scoop           | `scoop install fzf` |

 [choco]: https://chocolatey.org/packages/fzf
 [scoop]: https://github.com/ScoopInstaller/Main/blob/master/bucket/fzf.json
-[winget]: https://github.com/microsoft/winget-pkgs/tree/master/manifests/j/junegunn/fzf

 Known issues and limitations on Windows can be found on [the wiki
 page][windows-wiki].
@@ -206,23 +202,7 @@ files excluding hidden ones. (You can override the default command with
 vim $(fzf)
 ```

-> *:bulb: A more robust solution would be to use `xargs` but we've presented
-> the above as it's easier to grasp*
-> ```sh
-> fzf --print0 | xargs -0 -o vim
-> ```
-
->
-> *:bulb: fzf also has the ability to turn itself into a different process.*
->
-> ```sh
-> fzf --bind 'enter:become(vim {})'
-> ```
->
-> *See [Turning into a different process](#turning-into-a-different-process)
-> for more information.*
-
-### Using the finder
+#### Using the finder

 - `CTRL-K` / `CTRL-J` (or `CTRL-P` / `CTRL-N`) to move cursor up and down
 - `Enter` key to select the item, `CTRL-C` / `CTRL-G` / `ESC` to exit
@@ -231,7 +211,7 @@ vim $(fzf)
 - Mouse: scroll, click, double-click; shift-click and shift-scroll on
  multi-select mode

-### Layout
+#### Layout

 fzf by default starts in fullscreen mode, but you can make it start below the
 cursor with `--height` option.
@@ -254,7 +234,7 @@ default. For example,
 export FZF_DEFAULT_OPTS='--height 40% --layout=reverse --border'
 ```

-### Search syntax
+#### Search syntax

 Unless otherwise specified, fzf starts in "extended-search mode" where you can
 type in multiple search terms delimited by spaces. e.g. `^music .mp3$ sbtrkt
@@ -282,7 +262,7 @@ or `py`.
 ^core go$ | rb$ | py$
 ```

-### Environment variables
+#### Environment variables

 - `FZF_DEFAULT_COMMAND`
    - Default command to use when input is tty
@@ -298,11 +278,11 @@ or `py`.
    - Default options
    - e.g. `export FZF_DEFAULT_OPTS="--layout=reverse --inline-info"`

-### Options
+#### Options

 See the man page (`man fzf`) for the full list of options.

-### Demo
+#### Demo
 If you learn by watching videos, check out this screencast by [@samoshkin](https://github.com/samoshkin) to explore `fzf` features.

 <a title="fzf - command-line fuzzy finder" href="https://www.youtube.com/watch?v=qgG5Jhi_Els">
@@ -353,37 +333,17 @@ fish.

 - `CTRL-T` - Paste the selected files and directories onto the command-line
    - Set `FZF_CTRL_T_COMMAND` to override the default command
-    - Set `FZF_CTRL_T_OPTS` to pass additional options to fzf
-      ```sh
-      # Preview file content using bat (https://github.com/sharkdp/bat)
-      export FZF_CTRL_T_OPTS="
-        --preview 'bat -n --color=always {}'
-        --bind 'ctrl-/:change-preview-window(down|hidden|)'"
-      ```
+    - Set `FZF_CTRL_T_OPTS` to pass additional options
 - `CTRL-R` - Paste the selected command from history onto the command-line
    - If you want to see the commands in chronological order, press `CTRL-R`
      again which toggles sorting by relevance
-    - Set `FZF_CTRL_R_OPTS` to pass additional options to fzf
-      ```sh
-      # CTRL-/ to toggle small preview window to see the full command
-      # CTRL-Y to copy the command into clipboard using pbcopy
-      export FZF_CTRL_R_OPTS="
-        --preview 'echo {}' --preview-window up:3:hidden:wrap
-        --bind 'ctrl-/:toggle-preview'
-        --bind 'ctrl-y:execute-silent(echo -n {2..} | pbcopy)+abort'
-        --color header:italic
-        --header 'Press CTRL-Y to copy command into clipboard'"
-      ```
+    - Set `FZF_CTRL_R_OPTS` to pass additional options
 - `ALT-C` - cd into the selected directory
    - Set `FZF_ALT_C_COMMAND` to override the default command
-    - Set `FZF_ALT_C_OPTS` to pass additional options to fzf
-      ```sh
-      # Print tree structure in the preview window
-      export FZF_ALT_C_OPTS="--preview 'tree -C {}'"
-      ```
+    - Set `FZF_ALT_C_OPTS` to pass additional options

 If you're on a tmux session, you can start fzf in a tmux split-pane or in
-a tmux popup window by setting `FZF_TMUX_OPTS` (e.g. `export FZF_TMUX_OPTS='-p80%,60%'`).
+a tmux popup window by setting `FZF_TMUX_OPTS` (e.g. `-d 40%`).
 See `fzf-tmux --help` for available options.

 More tips can be found on [the wiki page](https://github.com/junegunn/fzf/wiki/Configuring-shell-key-bindings).
@@ -391,7 +351,7 @@ More tips can be found on [the wiki page](https://github.com/junegunn/fzf/wiki/C
 Fuzzy completion for bash and zsh
 ---------------------------------

-### Files and directories
+#### Files and directories

 Fuzzy completion for files and directories can be triggered if the word before
 the cursor ends with the trigger sequence, which is by default `**`.
@@ -420,7 +380,7 @@ cd **<TAB>
 cd ~/github/fzf**<TAB>
 ```

-### Process IDs
+#### Process IDs

 Fuzzy completion for PIDs is provided for kill command.

@@ -429,7 +389,7 @@ Fuzzy completion for PIDs is provided for kill command.
 kill -9 **<TAB>
 ```

-### Host names
+#### Host names

 For ssh and telnet commands, fuzzy completion for hostnames is provided. The
 names are extracted from /etc/hosts and ~/.ssh/config.
@@ -439,7 +399,7 @@ ssh **<TAB>
 telnet **<TAB>
 ```

-### Environment variables / Aliases
+#### Environment variables / Aliases

 ```sh
 unset **<TAB>
@@ -447,7 +407,7 @@ export **<TAB>
 unalias **<TAB>
 ```

-### Settings
+#### Settings

 ```sh
 # Use ~~ as the trigger sequence instead of the default **
@@ -469,7 +429,7 @@ _fzf_compgen_dir() {
  fd --type d --hidden --follow --exclude ".git" . "$1"
 }

-# Advanced customization of fzf options via _fzf_comprun function
+# (EXPERIMENTAL) Advanced customization of fzf options via _fzf_comprun function
 # - The first argument to the function is the name of the command.
 # - You should make sure to pass the rest of the arguments to fzf.
 _fzf_comprun() {
@@ -477,15 +437,15 @@ _fzf_comprun() {
  shift

  case "$command" in
-    cd)           fzf --preview 'tree -C {} | head -200'   "$@" ;;
-    export|unset) fzf --preview "eval 'echo \$'{}"         "$@" ;;
-    ssh)          fzf --preview 'dig {}'                   "$@" ;;
-    *)            fzf --preview 'bat -n --color=always {}' "$@" ;;
+    cd)           fzf "$@" --preview 'tree -C {} | head -200' ;;
+    export|unset) fzf "$@" --preview "eval 'echo \$'{}" ;;
+    ssh)          fzf "$@" --preview 'dig {}' ;;
+    *)            fzf "$@" ;;
  esac
 }
 ```

-### Supported commands
+#### Supported commands

 On bash, fuzzy completion is enabled only for a predefined set of commands
 (`complete | grep _fzf` to see the list). But you can enable it for other
@@ -497,7 +457,7 @@ _fzf_setup_completion path ag git kubectl
 _fzf_setup_completion dir tree
 ```

-### Custom fuzzy completion
+#### Custom fuzzy completion

 _**(Custom completion API is experimental and subject to change)**_

@@ -557,8 +517,9 @@ Advanced topics

 ### Performance

-fzf is fast. Performance should not be a problem in most use cases. However,
-you might want to be aware of the options that can affect performance.
+fzf is fast and is [getting even faster][perf]. Performance should not be
+a problem in most use cases. However, you might want to be aware of the
+options that affect performance.

 - `--ansi` tells fzf to extract and parse ANSI color codes in the input, and it
  makes the initial scanning slower. So it's not recommended that you add it
@@ -566,6 +527,12 @@ you might want to be aware of the options that can affect performance.
 - `--nth` makes fzf slower because it has to tokenize each line.
 - `--with-nth` makes fzf slower as fzf has to tokenize and reassemble each
  line.
+- If you absolutely need better performance, you can consider using
+  `--algo=v1` (the default being `v2`) to make fzf use a faster greedy
+  algorithm. However, this algorithm is not guaranteed to find the optimal
+  ordering of the matches and is not recommended.
+
+[perf]: https://junegunn.kr/images/fzf-0.17.0.png

 ### Executing external programs

@@ -580,47 +547,6 @@ fzf --bind 'f1:execute(less -f {}),ctrl-y:execute-silent(echo {} | pbcopy)+abort

 See *KEY BINDINGS* section of the man page for details.

-### Turning into a different process
-
-`become(...)` is similar to `execute(...)`/`execute-silent(...)` described
-above, but instead of executing the command and coming back to fzf on
-complete, it turns fzf into a new process for the command.
-
-```sh
-fzf --bind 'enter:become(vim {})'
-```
-
-Compared to the seemingly equivalent command substitution `vim "$(fzf)"`, this
-approach has several advantages:
-
-* Vim will not open an empty file when you terminate fzf with
-  <kbd>CTRL-C</kbd>
-* Vim will not open an empty file when you press <kbd>ENTER</kbd> on an empty
-  result
-* Can handle multiple selections even when they have whitespaces
-  ```sh
-  fzf --multi --bind 'enter:become(vim {+})'
-  ```
-
-To be fair, running `fzf --print0 | xargs -0 -o vim` instead of `vim "$(fzf)"`
-resolves all of the issues mentioned. Nonetheless, `become(...)` still offers
-additional benefits in different scenarios.
-
-* You can set up multiple bindings to handle the result in different ways
-  without any wrapping script
-  ```sh
-  fzf --bind 'enter:become(vim {}),ctrl-e:become(emacs {})'
-  ```
-  * Previously, you would have to use `--expect=ctrl-e` and check the first
-    line of the output of fzf
-* You can easily build the subsequent command using the field index
-  expressions of fzf
-  ```sh
-  # Open the file in Vim and go to the line
-  git grep --line-number . |
-      fzf --delimiter : --nth 3.. --bind 'enter:become(vim {1} +{2})'
-  ```
-
 ### Reloading the candidate list

 By binding `reload` action to a key or an event, you can make fzf dynamically
@@ -630,8 +556,8 @@ more details.
 #### 1. Update the list of processes by pressing CTRL-R

 ```sh
-ps -ef |
-  fzf --bind 'ctrl-r:reload(ps -ef)' \
+FZF_DEFAULT_COMMAND='ps -ef' \
+  fzf --bind 'ctrl-r:reload($FZF_DEFAULT_COMMAND)' \
      --header 'Press CTRL-R to reload' --header-lines=1 \
      --height=50% --layout=reverse
 ```
@@ -640,7 +566,7 @@ ps -ef |

 ```sh
 FZF_DEFAULT_COMMAND='find . -type f' \
-  fzf --bind 'ctrl-d:reload(find . -type d),ctrl-f:reload(eval "$FZF_DEFAULT_COMMAND")' \
+  fzf --bind 'ctrl-d:reload(find . -type d),ctrl-f:reload($FZF_DEFAULT_COMMAND)' \
      --height=50% --layout=reverse
 ```

@@ -653,20 +579,20 @@ expression `{q}`. Also, note that we used `--disabled` option so that fzf
 doesn't perform any secondary filtering.

 ```sh
-: | rg_prefix='rg --column --line-number --no-heading --color=always --smart-case' \
-    fzf --bind 'start:reload:$rg_prefix ""' \
-        --bind 'change:reload:$rg_prefix {q} || true' \
-        --bind 'enter:become(vim {1} +{2})' \
-        --ansi --disabled \
-        --height=50% --layout=reverse
+INITIAL_QUERY=""
+RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+FZF_DEFAULT_COMMAND="$RG_PREFIX '$INITIAL_QUERY'" \
+  fzf --bind "change:reload:$RG_PREFIX {q} || true" \
+      --ansi --disabled --query "$INITIAL_QUERY" \
+      --height=50% --layout=reverse
 ```

 If ripgrep doesn't find any matches, it will exit with a non-zero exit status,
 and fzf will warn you about it. To suppress the warning message, we added
 `|| true` to the command, so that it always exits with 0.

-See ["Using fzf as interactive Ripgrep launcher"](https://github.com/junegunn/fzf/blob/master/ADVANCED.md#using-fzf-as-interactive-ripgrep-launcher)
-for more sophisticated examples.
+See ["Using fzf as interative Ripgrep launcher"](https://github.com/junegunn/fzf/blob/master/ADVANCED.md#using-fzf-as-interative-ripgrep-launcher)
+for a fuller example with preview window options.

 ### Preview window

@@ -686,7 +612,7 @@ syntax-highlights the content of a file, such as
 [Highlight](http://www.andre-simon.de/doku/highlight/en/highlight.php):

 ```bash
-fzf --preview 'bat --color=always {}' --preview-window '~3'
+fzf --preview 'bat --style=numbers --color=always --line-range :500 {}'
 ```

 You can customize the size, position, and border of the preview window using
@@ -696,13 +622,15 @@ You can customize the size, position, and border of the preview window using
 ```bash
 fzf --height 40% --layout reverse --info inline --border \
    --preview 'file {}' --preview-window up,1,border-horizontal \
-    --bind 'ctrl-/:change-preview-window(50%|hidden|)' \
    --color 'fg:#bbccdd,fg+:#ddeeff,bg:#334455,preview-bg:#223344,border:#778899'
 ```

 See the man page (`man fzf`) for the full list of options.

-More advanced examples can be found [here](https://github.com/junegunn/fzf/blob/master/ADVANCED.md).
+For more advanced examples, see [Key bindings for git with fzf][fzf-git]
+([code](https://gist.github.com/junegunn/8b572b8d4b5eddd8b85e5f4d40f17236)).
+
+[fzf-git]: https://junegunn.kr/2016/07/fzf-git/

 ----

@@ -724,7 +652,7 @@ history | fzf
 Tips
 ----

-### Respecting `.gitignore`
+#### Respecting `.gitignore`

 You can use [fd](https://github.com/sharkdp/fd),
 [ripgrep](https://github.com/BurntSushi/ripgrep), or [the silver
@@ -734,10 +662,10 @@ default find command to traverse the file system while respecting

 ```sh
 # Feed the output of fd into fzf
-fd --type f --strip-cwd-prefix | fzf
+fd --type f | fzf

 # Setting fd as the default source for fzf
-export FZF_DEFAULT_COMMAND='fd --type f --strip-cwd-prefix'
+export FZF_DEFAULT_COMMAND='fd --type f'

 # Now fzf (w/o pipe) will use fd instead of find
 fzf
@@ -750,10 +678,10 @@ If you want the command to follow symbolic links and don't want it to exclude
 hidden files, use the following command:

 ```sh
-export FZF_DEFAULT_COMMAND='fd --type f --strip-cwd-prefix --hidden --follow --exclude .git'
+export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
 ```

-### Fish shell
+#### Fish shell

 `CTRL-T` key binding of fish, unlike those of bash and zsh, will use the last
 token on the command-line as the root directory for the recursive search. For
@@ -783,4 +711,4 @@ https://github.com/junegunn/fzf/wiki/Related-projects

 The MIT License (MIT)

-Copyright (c) 2013-2023 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi
--- a/bin/fzf-tmux
+++ b/bin/fzf-tmux
@@ -10,6 +10,7 @@ fail() {
 fzf="$(command -v fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
 [[ -x "$fzf" ]] || fail 'fzf executable not found'

+tmux_args=()
 args=()
 opt=""
 skip=""
@@ -57,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
@@ -118,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
      ;;
    *)
@@ -136,7 +139,7 @@ fi
 args=("${args[@]}" "--no-height" "--bind=ctrl-z:ignore")

 # Handle zoomed tmux pane without popup options by moving it to a temp window
-if [[ ! "$opt" =~ "-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'")
@@ -178,18 +181,7 @@ trap 'cleanup 1' SIGUSR1
 trap 'cleanup' EXIT

 envs="export TERM=$TERM "
-if [[ "$opt" =~ "-E" ]]; then
-  tmux_version=$(tmux -V | sed 's/[^0-9.]//g')
-  if [[ $(awk '{print ($1 > 3.2)}' <<< "$tmux_version" 2> /dev/null || bc -l <<< "$tmux_version > 3.2") = 1 ]]; then
-    FZF_DEFAULT_OPTS="--border $FZF_DEFAULT_OPTS"
-    opt="-B $opt"
-  elif [[ $tmux_version = 3.2 ]]; then
-    FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
-  else
-    echo "fzf-tmux: tmux 3.2 or above is required for popup mode" >&2
-    exit 2
-  fi
-fi
+[[ "$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"
@@ -203,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
@@ -213,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

@@ -227,7 +227,7 @@ else
 fi
 tmux set-window-option synchronize-panes off \;\
  set-window-option remain-on-exit off \;\
-  split-window -c "$PWD" $opt "bash -c 'exec -a fzf bash $argsf'" $swap \
+  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: Mar 20 2023
+fzf.txt	fzf	Last change: May 19 2021
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================

@@ -32,7 +32,7 @@ depending on the package manager.
    " If installed using Homebrew
    set rtp+=/usr/local/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:
@@ -40,7 +40,7 @@ If you use {vim-plug}{1}, the same can be written as:
    " If installed using Homebrew
    Plug '/usr/local/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
@@ -143,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
@@ -325,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]`


@@ -506,7 +506,7 @@ LICENSE                                                            *fzf-license*

 The MIT License (MIT)

-Copyright (c) 2013-2023 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,21 +1,21 @@
 module github.com/junegunn/fzf

 require (
-	github.com/gdamore/tcell/v2 v2.5.4
-	github.com/mattn/go-isatty v0.0.17
-	github.com/mattn/go-runewidth v0.0.14
+	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.4.4
-	github.com/saracen/walker v0.1.3
-	golang.org/x/sys v0.8.0
-	golang.org/x/term v0.8.0
+	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.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 // indirect
-	golang.org/x/text v0.5.0 // indirect
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
+	golang.org/x/text v0.3.7 // indirect
 )

 go 1.17
--- a/go.sum
+++ b/go.sum
@@ -1,49 +1,32 @@
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
-github.com/gdamore/tcell/v2 v2.5.4 h1:TGU4tSjD3sCL788vFNeJnTdzpNKIw1H5dgLnJRQVv/k=
-github.com/gdamore/tcell/v2 v2.5.4/go.mod h1:dZgRy5v4iMobMEcWNYBtREnDZAT9DYmfqIkrgEMxLyw=
+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.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
-github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
-github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-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.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/saracen/walker v0.1.3 h1:YtcKKmpRPy6XJTHJ75J2QYXXZYWnZNQxPCVqZSHVV/g=
-github.com/saracen/walker v0.1.3/go.mod h1:FU+7qU8DeQQgSZDmmThMJi93kPkLFgy0oVAcLxurjIk=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/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/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+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.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-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.8.0 h1:n5xxQn2i3PC0yLAbjTpNT85q/Kgzcr2gIoX9OrJUols=
-golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
 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.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM=
-golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
--- a/35
+++ b/35
@@ -2,7 +2,7 @@

 set -u

-version=0.41.1
+version=0.31.0
 auto_completion=
 key_bindings=
 update_config=2
@@ -168,24 +168,21 @@ archi=$(uname -sm)
 binary_available=1
 binary_error=""
 case "$archi" in
-  Darwin\ arm64)      download fzf-$version-darwin_arm64.zip     ;;
-  Darwin\ x86_64)     download fzf-$version-darwin_amd64.zip     ;;
-  Linux\ armv5*)      download fzf-$version-linux_armv5.tar.gz   ;;
-  Linux\ armv6*)      download fzf-$version-linux_armv6.tar.gz   ;;
-  Linux\ armv7*)      download fzf-$version-linux_armv7.tar.gz   ;;
-  Linux\ armv8*)      download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ aarch64*)    download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ 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"
--- a/install.ps1
+++ b/install.ps1
@@ -1,4 +1,4 @@
-$version="0.41.1"
+$version="0.31.0"

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

--- a/main.go
+++ b/main.go
@@ -5,7 +5,7 @@ import (
 	"github.com/junegunn/fzf/src/protector"
 )

-var version string = "0.41"
+var version string = "0.31"
 var revision string = "devel"

 func main() {
--- a/man/man1/fzf-tmux.1
+++ b/man/man1/fzf-tmux.1
@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)

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

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf-tmux 1 "May 2023" "fzf 0.41.1" "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
--- a/man/man1/fzf.1
+++ b/man/man1/fzf.1
@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)

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

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf 1 "May 2023" "fzf 0.41.1" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Jul 2022" "fzf 0.31.0" "fzf - a command-line fuzzy finder"

 .SH NAME
 fzf - a command-line fuzzy finder
@@ -51,18 +51,6 @@ Case-sensitive match
 .B "--literal"
 Do not normalize latin script letters for matching.
 .TP
-.BI "--scheme=" SCHEME
-Choose scoring scheme tailored for different types of input.
-
-.br
-.BR default "  Generic scoring scheme designed to work well with any type of input"
-.br
-.BR path "     Scoring scheme for paths (additional bonus point only after path separator)
-.br
-.BR history "  Scoring scheme for command history (no additional bonus points).
-         Sets \fB--tiebreak=index\fR as well.
-.br
-.TP
 .BI "--algo=" TYPE
 Fuzzy matching algorithm (default: v2)

@@ -92,19 +80,6 @@ interface rather than a "fuzzy finder". You can later enable the search using
 .B "+s, --no-sort"
 Do not sort the result
 .TP
-.B "--track"
-Make fzf track the current selection when the result list is updated.
-This can be useful when browsing logs using fzf with sorting disabled. It is
-not recommended to use this option with \fB--tac\fR as the resulting behavior
-can be confusing. Also, consider using \fBtrack\fR action instead of this
-option.
-
-.RS
-e.g.
-     \fBgit log --oneline --graph --color=always | nl |
-         fzf --ansi --track --no-sort --layout=reverse-list\fR
-.RE
-.TP
 .B "--tac"
 Reverse the order of the input

@@ -120,8 +95,6 @@ Comma-separated list of sort criteria to apply when the scores are tied.
 .br
 .BR length "  Prefers line with shorter length"
 .br
-.BR chunk "   Prefers line with shorter matched chunk (delimited by whitespaces)"
-.br
 .BR begin "   Prefers line with matched substring closer to the beginning"
 .br
 .BR end "     Prefers line with matched substring closer to the end"
@@ -190,11 +163,9 @@ actions are affected:
 Label characters for \fBjump\fR and \fBjump-accept\fR
 .SS Layout
 .TP
-.BI "--height=" "[~]HEIGHT[%]"
+.BI "--height=" "HEIGHT[%]"
 Display fzf window below the cursor with the given height instead of using
-the full screen. When prefixed with \fB~\fR, fzf will automatically determine
-the height in the range according to the input size. Note that adaptive height
-is not compatible with top/bottom margin and padding given in percent size.
+the full screen.
 .TP
 .BI "--min-height=" "HEIGHT"
 Minimum height when \fB--height\fR is given in percent (default: 10).
@@ -216,25 +187,21 @@ Choose the layout (default: default)
 A synonym for \fB--layout=reverse\fB

 .TP
-.BI "--border" [=BORDER_OPT]
+.BI "--border" [=STYLE]
 Draw border around the finder

 .br
-.BR rounded "       Border with rounded corners (default)"
+.BR rounded "     Border with rounded corners (default)"
 .br
-.BR sharp "         Border with sharp corners"
+.BR sharp "       Border with sharp corners"
 .br
-.BR bold "          Border with bold lines"
+.BR horizontal "  Horizontal lines above and below the finder"
 .br
-.BR double "        Border with double lines"
+.BR vertical "    Vertical lines on each side of the finder"
 .br
-.BR horizontal "    Horizontal lines above and below the finder"
+.BR top
 .br
-.BR vertical "      Vertical lines on each side of the finder"
-.br
-.BR top " (up)"
-.br
-.BR bottom " (down)"
+.BR bottom
 .br
 .BR left
 .br
@@ -243,59 +210,9 @@ Draw border around the finder
 .BR none
 .br

-If you use a terminal emulator where each box-drawing character takes
-2 columns, try setting \fBRUNEWIDTH_EASTASIAN\fR environment variable to
-\fB0\fR or \fB1\fR. If the border is still not properly rendered, set
-\fB--no-unicode\fR.
-
-.TP
-.BI "--border-label" [=LABEL]
-Label to print on the horizontal border line. Should be used with one of the
-following \fB--border\fR options.
-
-.br
-.B * rounded
-.br
-.B * sharp
-.br
-.B * bold
-.br
-.B * double
-.br
-.B * horizontal
-.br
-.BR "* top" " (up)"
-.br
-.BR "* bottom" " (down)"
-.br
-
-.br
-e.g.
-  \fB# ANSI color codes are supported
-  # (with https://github.com/busyloop/lolcat)
-  label=$(curl -s http://metaphorpsum.com/sentences/1 | lolcat -f)
-
-  # Border label at the center
-  fzf --height=10 --border --border-label="╢ $label ╟" --color=label:italic:black
-
-  # Left-aligned (positive integer)
-  fzf --height=10 --border --border-label="╢ $label ╟" --border-label-pos=3 --color=label:italic:black
-
-  # Right-aligned (negative integer) on the bottom line (:bottom)
-  fzf --height=10 --border --border-label="╢ $label ╟" --border-label-pos=-3:bottom --color=label:italic:black\fR
-
-.TP
-.BI "--border-label-pos" [=N[:top|bottom]]
-Position of the border label on the border line. Specify a positive integer as
-the column position from the left. Specify a negative integer to right-align
-the label. Label is printed on the top border line by default, add
-\fB:bottom\fR to put it on the border line on the bottom. The default value
-\fB0 (or \fBcenter\fR) will put the label at the center of the border line.
-
 .TP
 .B "--no-unicode"
-Use ASCII characters instead of Unicode drawing characters to draw borders,
-the spinner and the horizontal separator.
+Use ASCII characters instead of Unicode box drawing characters to draw border

 .TP
 .BI "--margin=" MARGIN
@@ -348,44 +265,20 @@ e.g.

 .TP
 .BI "--info=" "STYLE"
-Determines the display style of finder info (match counters).
+Determines the display style of finder info.

 .br
-.BR default "          Display on the next line to the prompt"
+.BR default "       Display on the next line to the prompt"
 .br
-.BR inline "           Display on the same line with the default separator ' < '"
+.BR inline "        Display on the same line"
 .br
-.BR inline:SEPARATOR " Display on the same line with a non-default separator"
-.br
-.BR hidden "           Do not display finder info"
+.BR hidden "        Do not display finder info"
 .br

 .TP
 .B "--no-info"
 A synonym for \fB--info=hidden\fB

-.TP
-.BI "--separator=" "STR"
-The given string will be repeated to form the horizontal separator on the info
-line (default: '─' or '-' depending on \fB--no-unicode\fR).
-
-ANSI color codes are supported.
-
-.TP
-.B "--no-separator"
-Do not display horizontal separator on the info line. A synonym for
-\fB--separator=''\fB
-
-.TP
-.BI "--scrollbar=" "CHAR1[CHAR2]"
-Use the given character to render scrollbar. (default: '│' or ':' depending on
-\fB--no-unicode\fR). The optional \fBCHAR2\fR is used to render scrollbar of
-the preview window.
-
-.TP
-.B "--no-scrollbar"
-Do not display scrollbar. A synonym for \fB--scrollbar=''\fB
-
 .TP
 .BI "--prompt=" "STR"
 Input prompt (default: '> ')
@@ -434,30 +327,24 @@ color mappings.
    \fBbw      \fRNo colors (equivalent to \fB--no-color\fR)

 .B COLOR NAMES:
-    \fBfg                  \fRText
-      \fBpreview-fg        \fRPreview window text
-    \fBbg                  \fRBackground
-      \fBpreview-bg        \fRPreview window background
-    \fBhl                  \fRHighlighted substrings
-    \fBfg+                 \fRText (current line)
-    \fBbg+                 \fRBackground (current line)
-      \fBgutter            \fRGutter on the left
-    \fBhl+                 \fRHighlighted substrings (current line)
-    \fBquery               \fRQuery string
-      \fBdisabled          \fRQuery string when search is disabled (\fB--disabled\fR)
-    \fBinfo                \fRInfo line (match counters)
-    \fBborder              \fRBorder around the window (\fB--border\fR and \fB--preview\fR)
-      \fBscrollbar         \fRScrollbar
-      \fBpreview-border    \fRBorder around the preview window (\fB--preview\fR)
-      \fBpreview-scrollbar \fRScrollbar
-      \fBseparator         \fRHorizontal separator on info line
-    \fBlabel               \fRBorder label (\fB--border-label\fR and \fB--preview-label\fR)
-      \fBpreview-label     \fRBorder label of the preview window (\fB--preview-label\fR)
-    \fBprompt              \fRPrompt
-    \fBpointer             \fRPointer to the current line
-    \fBmarker              \fRMulti-select marker
-    \fBspinner             \fRStreaming input indicator
-    \fBheader              \fRHeader
+    \fBfg         \fRText
+    \fBbg         \fRBackground
+    \fBpreview-fg \fRPreview window text
+    \fBpreview-bg \fRPreview window background
+    \fBhl         \fRHighlighted substrings
+    \fBfg+        \fRText (current line)
+    \fBbg+        \fRBackground (current line)
+    \fBgutter     \fRGutter on the left (defaults to \fBbg+\fR)
+    \fBhl+        \fRHighlighted substrings (current line)
+    \fBquery      \fRQuery string
+    \fBdisabled   \fRQuery string when search is disabled
+    \fBinfo       \fRInfo line (match counters)
+    \fBborder     \fRBorder around the window (\fB--border\fR and \fB--preview\fR)
+    \fBprompt     \fRPrompt
+    \fBpointer    \fRPointer to the current line
+    \fBmarker     \fRMulti-select marker
+    \fBspinner    \fRStreaming input indicator
+    \fBheader     \fRHeader

 .B ANSI COLORS:
    \fB-1         \fRDefault terminal foreground/background color
@@ -489,7 +376,6 @@ color mappings.
    \fBreverse\fR
    \fBdim\fR
    \fBitalic\fR
-    \fBstrikethrough\fR

 .B EXAMPLES:

@@ -515,7 +401,7 @@ Use black background
 .BI "--history=" "HISTORY_FILE"
 Load search history from the specified file and update the file on completion.
 When enabled, \fBCTRL-N\fR and \fBCTRL-P\fR are automatically remapped to
-\fBnext-history\fR and \fBprev-history\fR.
+\fBnext-history\fR and \fBprevious-history\fR.
 .TP
 .BI "--history-size=" "N"
 Maximum number of entries in the history file (default: 1000). The file is
@@ -569,8 +455,7 @@ e.g.
 Note that you can escape a placeholder pattern by prepending a backslash.

 Preview window will be updated even when there is no match for the current
-query if any of the placeholder expressions evaluates to a non-empty string
-or \fB{q}\fR is in the command template.
+query if any of the placeholder expressions evaluates to a non-empty string.

 Since 0.24.0, fzf can render partial preview content before the preview command
 completes. ANSI escape sequence for clearing the display (\fBCSI 2 J\fR) is
@@ -584,37 +469,6 @@ e.g.
        sleep 0.01
      done'\fR
 .RE
-
-.TP
-.BI "--preview-label" [=LABEL]
-Label to print on the horizontal border line of the preview window.
-Should be used with one of the following \fB--preview-window\fR options.
-
-.br
-.B * border-rounded (default on non-Windows platforms)
-.br
-.B * border-sharp (default on Windows)
-.br
-.B * border-bold
-.br
-.B * border-double
-.br
-.B * border-horizontal
-.br
-.B * border-top
-.br
-.B * border-bottom
-.br
-
-.TP
-.BI "--preview-label-pos" [=N[:top|bottom]]
-Position of the border label on the border line of the preview window. Specify
-a positive integer as the column position from the left. Specify a negative
-integer to right-align the label. Label is printed on the top border line by
-default, add \fB:bottom\fR to put it on the border line on the bottom. The
-default value 0 (or \fBcenter\fR) will put the label at the center of the
-border line.
-
 .TP
 .BI "--preview-window=" "[POSITION][,SIZE[%]][,border-BORDER_OPT][,[no]wrap][,[no]follow][,[no]cycle][,[no]hidden][,+SCROLL[OFFSETS][/DENOM]][,~HEADER_LINES][,default][,<SIZE_THRESHOLD(ALTERNATIVE_LAYOUT)]"

@@ -747,6 +601,12 @@ Read input delimited by ASCII NUL characters instead of newline characters
 .B "--print0"
 Print output delimited by ASCII NUL characters instead of newline characters
 .TP
+.B "--no-clear"
+Do not clear finder interface on exit. If fzf was started in full screen mode,
+it will not switch back to the original screen, so you'll have to manually run
+\fBtput rmcup\fR to return. This option can be used to avoid flickering of the
+screen when your application needs to start fzf multiple times in order.
+.TP
 .B "--sync"
 Synchronous search for multi-staged filtering. If specified, fzf will launch
 ncurses finder only after the input stream is complete.
@@ -755,24 +615,6 @@ ncurses finder only after the input stream is complete.
 e.g. \fBfzf --multi | fzf --sync\fR
 .RE
 .TP
-.B "--listen[=HTTP_PORT]"
-Start HTTP server on the given port. It allows external processes to send
-actions to perform via POST method. If the port number is omitted or given as
-0, fzf will choose the port automatically and export it as \fBFZF_PORT\fR
-environment variable to the child processes started via \fBexecute\fR and
-\fBexecute-silent\fR actions.
-
-e.g.
-     \fB# Start HTTP server on port 6266
-     fzf --listen 6266
-
-     # Send action to the server
-     curl -XPOST localhost:6266 -d 'reload(seq 100)+change-prompt(hundred> )'
-
-     # Choose port automatically and export it as $FZF_PORT to the child process
-     fzf --listen --bind 'start:execute-silent:echo $FZF_PORT > /tmp/fzf-port'
-     \fR
-.TP
 .B "--version"
 Display version information and exit

@@ -873,8 +715,6 @@ e.g.
 .br
 \fIctrl-space\fR
 .br
-\fIctrl-delete\fR
-.br
 \fIctrl-\\\fR
 .br
 \fIctrl-]\fR
@@ -943,8 +783,6 @@ e.g.
 .br
 \fIshift-right\fR
 .br
-\fIshift-delete\fR
-.br
 \fIalt-shift-up\fR
 .br
 \fIalt-shift-down\fR
@@ -962,24 +800,6 @@ e.g.
 or any single character

 .SS AVAILABLE EVENTS:
-\fIstart\fR
-.RS
-Triggered only once when fzf finder starts. Since fzf consumes the input stream
-asynchronously, the input list is not available unless you use \fI--sync\fR.
-
-e.g.
-     \fB# Move cursor to the last item and select all items
-     seq 1000 | fzf --multi --sync --bind start:last+select-all\fR
-.RE
-\fIload\fR
-.RS
-Triggered when the input stream is complete and the initial processing of the
-list is complete.
-
-e.g.
-     \fB# Change the prompt to "loaded" when the input stream is complete
-     (seq 10; sleep 1; seq 11 20) | fzf --prompt 'Loading> ' --bind 'load:change-prompt:Loaded> '\fR
-.RE
 \fIchange\fR
 .RS
 Triggered whenever the query string is changed
@@ -988,44 +808,6 @@ e.g.
     \fB# Move cursor to the first entry whenever the query is changed
     fzf --bind change:first\fR
 .RE
-\fIfocus\fR
-.RS
-Triggered when the focus changes due to a vertical cursor movement or a search
-result update.
-
-e.g.
-     \fBfzf --bind 'focus:transform-preview-label:echo [ {} ]' --preview 'cat {}'
-
-     # Any action bound to the event runs synchronously and thus can make the interface sluggish
-     # e.g. lolcat isn't one of the fastest programs, and every cursor movement in
-     #      fzf will be noticeably affected by its execution time
-     fzf --bind 'focus:transform-preview-label:echo [ {} ] | lolcat -f' --preview 'cat {}'
-
-     # Beware not to introduce an infinite loop
-     seq 10 | fzf --bind 'focus:up' --cycle\fR
-.RE
-\fIone\fR
-.RS
-Triggered when there's only one match. \fBone:accept\fR binding is comparable
-to \fB--select-1\fR option, but the difference is that \fB--select-1\fR is only
-effective before the interactive finder starts but \fBone\fR event is triggered
-by the interactive finder.
-
-e.g.
-     \fB# Automatically select the only match
-     seq 10 | fzf --bind one:accept\fR
-.RE
-\fIzero\fR
-.RS
-Triggered when there's no match. \fBzero:abort\fR binding is comparable to
-\fB--exit-0\fR option, but the difference is that \fB--exit-0\fR is only
-effective before the interactive finder starts but \fBzero\fR event is
-triggered by the interactive finder.
-
-e.g.
-     \fB# Reload the candidate list when there's no match
-     echo $RANDOM | fzf --bind 'zero:reload(echo $RANDOM)+clear-query' --height 3\fR
-.RE

 \fIbackward-eof\fR
 .RS
@@ -1039,100 +821,81 @@ e.g.
 .SS AVAILABLE ACTIONS:
 A key or an event can be bound to one or more of the following actions.

-  \fBACTION:                      DEFAULT BINDINGS (NOTES):
-    \fBabort\fR                        \fIctrl-c  ctrl-g  ctrl-q  esc\fR
-    \fBaccept\fR                       \fIenter   double-click\fR
-    \fBaccept-non-empty\fR             (same as \fBaccept\fR except that it prevents fzf from exiting without selection)
-    \fBbackward-char\fR                \fIctrl-b  left\fR
-    \fBbackward-delete-char\fR         \fIctrl-h  bspace\fR
-    \fBbackward-delete-char/eof\fR     (same as \fBbackward-delete-char\fR except aborts fzf if query is empty)
-    \fBbackward-kill-word\fR           \fIalt-bs\fR
-    \fBbackward-word\fR                \fIalt-b   shift-left\fR
-    \fBbecome(...)\fR                  (replace fzf process with the specified command; see below for the details)
-    \fBbeginning-of-line\fR            \fIctrl-a  home\fR
-    \fBcancel\fR                       (clear query string if not empty, abort fzf otherwise)
-    \fBchange-border-label(...)\fR     (change \fB--border-label\fR to the given string)
-    \fBchange-header(...)\fR           (change header to the given string; doesn't affect \fB--header-lines\fR)
-    \fBchange-preview(...)\fR          (change \fB--preview\fR option)
-    \fBchange-preview-label(...)\fR    (change \fB--preview-label\fR to the given string)
-    \fBchange-preview-window(...)\fR   (change \fB--preview-window\fR option; rotate through the multiple option sets separated by '|')
-    \fBchange-prompt(...)\fR           (change prompt to the given string)
-    \fBchange-query(...)\fR            (change query string to the given string)
-    \fBclear-screen\fR                 \fIctrl-l\fR
-    \fBclear-selection\fR              (clear multi-selection)
-    \fBclose\fR                        (close preview window if open, abort fzf otherwise)
-    \fBclear-query\fR                  (clear query string)
-    \fBdelete-char\fR                  \fIdel\fR
-    \fBdelete-char/eof\fR              \fIctrl-d\fR (same as \fBdelete-char\fR except aborts fzf if query is empty)
+  \fBACTION:                   DEFAULT BINDINGS (NOTES):
+    \fBabort\fR                      \fIctrl-c  ctrl-g  ctrl-q  esc\fR
+    \fBaccept\fR                     \fIenter   double-click\fR
+    \fBaccept-non-empty\fR           (same as \fBaccept\fR except that it prevents fzf from exiting without selection)
+    \fBbackward-char\fR              \fIctrl-b  left\fR
+    \fBbackward-delete-char\fR       \fIctrl-h  bspace\fR
+    \fBbackward-delete-char/eof\fR   (same as \fBbackward-delete-char\fR except aborts fzf if query is empty)
+    \fBbackward-kill-word\fR         \fIalt-bs\fR
+    \fBbackward-word\fR              \fIalt-b   shift-left\fR
+    \fBbeginning-of-line\fR          \fIctrl-a  home\fR
+    \fBcancel\fR                     (clear query string if not empty, abort fzf otherwise)
+    \fBchange-preview(...)\fR        (change \fB--preview\fR option)
+    \fBchange-preview-window(...)\fR (change \fB--preview-window\fR option; rotate through the multiple option sets separated by '|')
+    \fBchange-prompt(...)\fR         (change prompt to the given string)
+    \fBclear-screen\fR               \fIctrl-l\fR
+    \fBclear-selection\fR            (clear multi-selection)
+    \fBclose\fR                      (close preview window if open, abort fzf otherwise)
+    \fBclear-query\fR                (clear query string)
+    \fBdelete-char\fR                \fIdel\fR
+    \fBdelete-char/eof\fR            \fIctrl-d\fR (same as \fBdelete-char\fR except aborts fzf if query is empty)
    \fBdeselect\fR
-    \fBdeselect-all\fR                 (deselect all matches)
-    \fBdisable-search\fR               (disable search functionality)
-    \fBdown\fR                         \fIctrl-j  ctrl-n  down\fR
-    \fBenable-search\fR                (enable search functionality)
-    \fBend-of-line\fR                  \fIctrl-e  end\fR
-    \fBexecute(...)\fR                 (see below for the details)
-    \fBexecute-silent(...)\fR          (see below for the details)
-    \fBfirst\fR                        (move to the first match; same as \fBpos(1)\fR)
-    \fBforward-char\fR                 \fIctrl-f  right\fR
-    \fBforward-word\fR                 \fIalt-f   shift-right\fR
+    \fBdeselect-all\fR               (deselect all matches)
+    \fBdisable-search\fR             (disable search functionality)
+    \fBdown\fR                       \fIctrl-j  ctrl-n  down\fR
+    \fBenable-search\fR              (enable search functionality)
+    \fBend-of-line\fR                \fIctrl-e  end\fR
+    \fBexecute(...)\fR               (see below for the details)
+    \fBexecute-silent(...)\fR        (see below for the details)
+    \fBfirst\fR                      (move to the first match)
+    \fBforward-char\fR               \fIctrl-f  right\fR
+    \fBforward-word\fR               \fIalt-f   shift-right\fR
    \fBignore\fR
-    \fBjump\fR                         (EasyMotion-like 2-keystroke movement)
-    \fBjump-accept\fR                  (jump and accept)
+    \fBjump\fR                       (EasyMotion-like 2-keystroke movement)
+    \fBjump-accept\fR                (jump and accept)
    \fBkill-line\fR
-    \fBkill-word\fR                    \fIalt-d\fR
-    \fBlast\fR                         (move to the last match; same as \fBpos(-1)\fR)
-    \fBnext-history\fR                 (\fIctrl-n\fR on \fB--history\fR)
-    \fBnext-selected\fR                (move to the next selected item)
-    \fBpage-down\fR                    \fIpgdn\fR
-    \fBpage-up\fR                      \fIpgup\fR
+    \fBkill-word\fR                  \fIalt-d\fR
+    \fBlast\fR                       (move to the last match)
+    \fBnext-history\fR               (\fIctrl-n\fR on \fB--history\fR)
+    \fBpage-down\fR                  \fIpgdn\fR
+    \fBpage-up\fR                    \fIpgup\fR
    \fBhalf-page-down\fR
    \fBhalf-page-up\fR
-    \fBhide-preview\fR
-    \fBpos(...)\fR                     (move cursor to the numeric position; negative number to count from the end)
-    \fBprev-history\fR                 (\fIctrl-p\fR on \fB--history\fR)
-    \fBprev-selected\fR                (move to the previous selected item)
-    \fBpreview(...)\fR                 (see below for the details)
-    \fBpreview-down\fR                 \fIshift-down\fR
-    \fBpreview-up\fR                   \fIshift-up\fR
+    \fBpreview(...)\fR               (see below for the details)
+    \fBpreview-down\fR               \fIshift-down\fR
+    \fBpreview-up\fR                 \fIshift-up\fR
    \fBpreview-page-down\fR
    \fBpreview-page-up\fR
    \fBpreview-half-page-down\fR
    \fBpreview-half-page-up\fR
    \fBpreview-bottom\fR
    \fBpreview-top\fR
-    \fBprint-query\fR                  (print query and exit)
-    \fBput\fR                          (put the character to the prompt)
-    \fBput(...)\fR                     (put the given string to the prompt)
+    \fBprevious-history\fR           (\fIctrl-p\fR on \fB--history\fR)
+    \fBprint-query\fR                (print query and exit)
+    \fBput\fR                        (put the character to the prompt)
    \fBrefresh-preview\fR
-    \fBrebind(...)\fR                  (rebind bindings after \fBunbind\fR)
-    \fBreload(...)\fR                  (see below for the details)
-    \fBreload-sync(...)\fR             (see below for the details)
-    \fBreplace-query\fR                (replace query string with the current selection)
+    \fBrebind(...)\fR                (rebind bindings after \fBunbind\fR)
+    \fBreload(...)\fR                (see below for the details)
+    \fBreplace-query\fR              (replace query string with the current selection)
    \fBselect\fR
-    \fBselect-all\fR                   (select all matches)
-    \fBshow-preview\fR
-    \fBtoggle\fR                       (\fIright-click\fR)
-    \fBtoggle-all\fR                   (toggle all matches)
-    \fBtoggle+down\fR                  \fIctrl-i  (tab)\fR
-    \fBtoggle-in\fR                    (\fB--layout=reverse*\fR ? \fBtoggle+up\fR : \fBtoggle+down\fR)
-    \fBtoggle-out\fR                   (\fB--layout=reverse*\fR ? \fBtoggle+down\fR : \fBtoggle+up\fR)
+    \fBselect-all\fR                 (select all matches)
+    \fBtoggle\fR                     (\fIright-click\fR)
+    \fBtoggle-all\fR                 (toggle all matches)
+    \fBtoggle+down\fR                \fIctrl-i  (tab)\fR
+    \fBtoggle-in\fR                  (\fB--layout=reverse*\fR ? \fBtoggle+up\fR : \fBtoggle+down\fR)
+    \fBtoggle-out\fR                 (\fB--layout=reverse*\fR ? \fBtoggle+down\fR : \fBtoggle+up\fR)
    \fBtoggle-preview\fR
    \fBtoggle-preview-wrap\fR
-    \fBtoggle-search\fR                (toggle search functionality)
+    \fBtoggle-search\fR              (toggle search functionality)
    \fBtoggle-sort\fR
-    \fBtoggle-track\fR
-    \fBtoggle+up\fR                    \fIbtab    (shift-tab)\fR
-    \fBtrack\fR                        (track the current item; automatically disabled if focus changes)
-    \fBtransform-border-label(...)\fR  (transform border label using an external command)
-    \fBtransform-header(...)\fR        (transform header using an external command)
-    \fBtransform-preview-label(...)\fR (transform preview label using an external command)
-    \fBtransform-prompt(...)\fR        (transform prompt string using an external command)
-    \fBtransform-query(...)\fR         (transform query string using an external command)
-    \fBunbind(...)\fR                  (unbind bindings)
-    \fBunix-line-discard\fR            \fIctrl-u\fR
-    \fBunix-word-rubout\fR             \fIctrl-w\fR
-    \fBup\fR                           \fIctrl-k  ctrl-p  up\fR
-    \fByank\fR                         \fIctrl-y\fR
+    \fBtoggle+up\fR                  \fIbtab    (shift-tab)\fR
+    \fBunbind(...)\fR                (unbind bindings)
+    \fBunix-line-discard\fR          \fIctrl-u\fR
+    \fBunix-word-rubout\fR           \fIctrl-w\fR
+    \fBup\fR                         \fIctrl-k  ctrl-p  up\fR
+    \fByank\fR                       \fIctrl-y\fR

 .SS ACTION COMPOSITION

@@ -1155,8 +918,6 @@ that case, you can use any of the following alternative notations to avoid
 parse errors.

    \fBaction-name[...]\fR
-    \fBaction-name{...}\fR
-    \fBaction-name<...>\fR
    \fBaction-name~...~\fR
    \fBaction-name!...!\fR
    \fBaction-name@...@\fR
@@ -1197,14 +958,6 @@ On *nix systems, fzf runs the command with \fB$SHELL -c\fR if \fBSHELL\fR is
 set, otherwise with \fBsh -c\fR, so in this case make sure that the command is
 POSIX-compliant.

-\fBbecome(...)\fR action is similar to \fBexecute(...)\fR, but it replaces the
-current fzf process with the specified command using \fBexecve(2)\fR system
-call.
-
-    \fBfzf --bind "enter:become(vim {})"\fR
-
-\fBbecome(...)\fR is not supported on Windows.
-
 .SS RELOAD INPUT

 \fBreload(...)\fR action is used to dynamically update the input list
@@ -1225,16 +978,6 @@ e.g.
       fzf --bind "change:reload:$RG_PREFIX {q} || true" \\
           --ansi --disabled --query "$INITIAL_QUERY"\fR

-\fBreload-sync(...)\fR is a synchronous version of \fBreload\fR that replaces
-the list only when the command is complete. This is useful when the command
-takes a while to produce the initial output and you don't want fzf to run
-against an empty list while the command is running.
-
-
-e.g.
-     \fB# You can still filter and select entries from the initial list for 3 seconds
-     seq 100 | fzf --bind 'load:reload-sync(sleep 3; seq 1000)+unbind(load)'\fR
-
 .SS PREVIEW BINDING

 With \fBpreview(...)\fR action, you can specify multiple different preview
--- a/plugin/fzf.vim
+++ b/plugin/fzf.vim
@@ -1,4 +1,4 @@
-" Copyright (c) 2013-2023 Junegunn Choi
+" Copyright (c) 2017 Junegunn Choi
 "
 " MIT License
 "
@@ -143,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)
@@ -164,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 ''
@@ -342,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
@@ -464,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
@@ -511,8 +510,7 @@ try
    let height = s:calc_size(&lines, dict.down, dict)
    let optstr .= ' --height='.height
  endif
-  " Respect --border option given in 'options'
-  let optstr = join([s:border_opt(get(dict, 'window', 0)), optstr])
+  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
@@ -739,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
@@ -756,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 ''
@@ -766,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)
@@ -828,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('')
@@ -908,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)}
@@ -920,7 +906,6 @@ function! s:execute_term(dict, command, temps) abort
      else
        let term_opts.curwin = 1
      endif
-      call s:handle_ambidouble(term_opts)
      let fzf.buf = term_start([&shell, &shellcmdflag, command], term_opts)
      if is_popup && exists('#TerminalWinOpen')
        doautocmd <nomodeline> TerminalWinOpen
@@ -987,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,
@@ -1031,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
--- a/shell/completion.bash
+++ b/shell/completion.bash
@@ -37,7 +37,7 @@ bind '"\e[0n": redraw-current-line' 2> /dev/null
 __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
@@ -55,8 +55,8 @@ __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
@@ -139,18 +139,17 @@ _fzf_handle_dynamic_completion() {
  shift
  orig_cmd="$1"
  orig_var="_fzf_orig_completion_$cmd"
-  orig="${!orig_var-}"
-  orig="${orig##*#}"
+  orig="${!orig_var##*#}"
  if [[ -n "$orig" ]] && type "$orig" > /dev/null 2>&1; then
    $orig "$@"
-  elif [[ -n "${_fzf_completion_loader-}" ]]; then
+  elif [[ -n "$_fzf_completion_loader" ]]; then
    orig_complete=$(complete -p "$orig_cmd" 2> /dev/null)
    _completion_loader "$@"
    ret=$?
    # _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)
-      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"
@@ -162,11 +161,7 @@ _fzf_handle_dynamic_completion() {

 __fzf_generic_path_completion() {
  local cur base dir leftover matches trigger cmd
-  cmd="${COMP_WORDS[0]}"
-  if [[ $cmd == \\* ]]; then
-    cmd="${cmd:1}"
-  fi
-  cmd="${cmd//[^A-Za-z0-9_=]/_}"
+  cmd="${COMP_WORDS[0]//[^A-Za-z0-9_=]/_}"
  COMPREPLY=()
  trigger=${FZF_COMPLETION_TRIGGER-'**'}
  cur="${COMP_WORDS[COMP_CWORD]}"
@@ -174,7 +169,6 @@ __fzf_generic_path_completion() {
    base=${cur:0:${#cur}-${#trigger}}
    eval "base=$base"

-    dir=
    [[ $base = *"/"* ]] && dir="$base"
    while true; do
      if [[ -z "$dir" ]] || [[ -d "$dir" ]]; then
@@ -182,11 +176,11 @@ __fzf_generic_path_completion() {
        leftover=${leftover/#\/}
        [[ -z "$dir" ]] && dir='.'
        [[ "$dir" != "/" ]] && dir="${dir/%\//}"
-        matches=$(eval "$1 $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_COMPLETION_OPTS-} $2" __fzf_comprun "$4" -q "$leftover" | while read -r item; do
-          printf "%q " "${item%$3}$3"
+        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
@@ -238,7 +232,7 @@ _fzf_complete() {
  if [[ "$cur" == *"$trigger" ]]; then
    cur=${cur:0:${#cur}-${#trigger}}

-    selected=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_COMPLETION_OPTS-} $str_arg" __fzf_comprun "${rest[0]}" "${args[@]}" -q "$cur" | $post | tr '\n' ' ')
+    selected=$(FZF_DEFAULT_OPTS="--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")
@@ -270,9 +264,8 @@ _fzf_complete_kill() {
 }

 _fzf_proc_completion() {
-  _fzf_complete -m --header-lines=1 --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
-    command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
-      command ps -eo user,pid,ppid,time,args # For BusyBox
+  _fzf_complete -m --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+    command ps -ef | sed 1d
  )
 }

@@ -282,7 +275,7 @@ _fzf_proc_completion_post() {

 _fzf_host_completion() {
  _fzf_complete +m -- "$@" < <(
-    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
+    command 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
@@ -291,13 +284,13 @@ _fzf_host_completion() {

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

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

@@ -310,8 +303,8 @@ complete -o default -F _fzf_opts_completion fzf-tmux

 d_cmds="${FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir}"
 a_cmds="
-  awk bat cat diff diff3
-  emacs emacsclient ex file ftp g++ gcc gvim head hg hx java
+  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
@@ -332,7 +325,7 @@ __fzf_defc() {
  func="$2"
  opts="$3"
  orig_var="_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}"
-  orig="${!orig_var-}"
+  orig="${!orig_var}"
  if [[ -n "$orig" ]]; then
    printf -v def "$orig" "$func"
    eval "$def"
@@ -374,7 +367,7 @@ _fzf_setup_completion() {
 }

 # Environment variables / Aliases / Hosts / Process
-_fzf_setup_completion 'var'   export unset printenv
+_fzf_setup_completion 'var'   export unset
 _fzf_setup_completion 'alias' unalias
 _fzf_setup_completion 'host'  ssh telnet
 _fzf_setup_completion 'proc'  kill
--- a/shell/completion.zsh
+++ b/shell/completion.zsh
@@ -99,9 +99,9 @@ fi
 __fzf_comprun() {
  if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
    _fzf_comprun "$@"
-  elif [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; }; then
+  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%} -- "$@"
@@ -145,9 +145,8 @@ __fzf_generic_path_completion() {
      leftover=${leftover/#\/}
      [ -z "$dir" ] && dir='.'
      [ "$dir" != "/" ] && dir="${dir/%\//}"
-      matches=$(eval "$compgen $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_COMPLETION_OPTS-}" __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" | while read item; do
-        item="${item%$suffix}$suffix"
-        echo -n "${(q)item} "
+      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
@@ -184,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
@@ -208,7 +207,7 @@ _fzf_complete() {
  type $post > /dev/null 2>&1 || post=cat

  _fzf_feed_fifo "$fifo"
-  matches=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_COMPLETION_OPTS-} $str_arg" __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
+  matches=$(FZF_DEFAULT_OPTS="--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
@@ -225,7 +224,7 @@ _fzf_complete_telnet() {
 _fzf_complete_ssh() {
  _fzf_complete +m -- "$@" < <(
    setopt localoptions nonomatch
-    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
+    command 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
@@ -251,9 +250,8 @@ _fzf_complete_unalias() {
 }

 _fzf_complete_kill() {
-  _fzf_complete -m --header-lines=1 --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
-    command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
-      command ps -eo user,pid,ppid,time,args # For BusyBox
+  _fzf_complete -m --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+    command ps -ef | sed 1d
  )
 }

@@ -280,8 +278,8 @@ fzf-completion() {
  [ -z "$trigger" -a ${LBUFFER[-1]} = ' ' ] && tokens+=("")

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

--- a/shell/key-bindings.bash
+++ b/shell/key-bindings.bash
@@ -19,7 +19,7 @@ __fzf_select__() {
    -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"
+  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
@@ -30,7 +30,7 @@ __fzf_select__() {
 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"
 }

@@ -44,13 +44,13 @@ __fzf_cd__() {
  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"
+  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"
 }

 __fzf_history__() {
  local output opts script
-  opts="--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} -n2..,.. --scheme=history --bind=ctrl-r:toggle-sort ${FZF_CTRL_R_OPTS-} +m --read0"
+  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 |
--- a/shell/key-bindings.fish
+++ b/shell/key-bindings.fish
@@ -53,7 +53,7 @@ function fzf_key_bindings
  function fzf-history-widget -d "Show command history"
    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
    begin
-      set -lx FZF_DEFAULT_OPTS "--height $FZF_TMUX_HEIGHT $FZF_DEFAULT_OPTS --scheme=history --bind=ctrl-r:toggle-sort,ctrl-z:ignore $FZF_CTRL_R_OPTS +m"
+      set -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.)
@@ -87,7 +87,7 @@ function fzf_key_bindings
      eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)' +m --query "'$fzf_query'"' | read -l result

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

        # Remove last token from commandline.
        commandline -t ""
--- a/shell/key-bindings.zsh
+++ b/shell/key-bindings.zsh
@@ -46,7 +46,7 @@ __fsel() {
    -o -type l -print 2> /dev/null | cut -b3-"}"
  setopt localoptions pipefail no_aliases 2> /dev/null
  local item
-  eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_CTRL_T_OPTS-}" $(__fzfcmd) -m "$@" | while read item; do
+  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=$?
@@ -55,7 +55,7 @@ __fsel() {
 }

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

@@ -75,7 +75,7 @@ fzf-cd-widget() {
  local cmd="${FZF_ALT_C_COMMAND:-"command find -L . -mindepth 1 \\( -path '*/\\.*' -o -fstype 'sysfs' -o -fstype 'devfs' -o -fstype 'devtmpfs' -o -fstype 'proc' \\) -prune \
    -o -type d -print 2> /dev/null | cut -b3-"}"
  setopt localoptions pipefail no_aliases 2> /dev/null
-  local dir="$(eval "$cmd" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore ${FZF_DEFAULT_OPTS-} ${FZF_ALT_C_OPTS-}" $(__fzfcmd) +m)"
+  local dir="$(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
@@ -97,8 +97,8 @@ bindkey -M viins '\ec' fzf-cd-widget
 fzf-history-widget() {
  local selected num
  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2> /dev/null
-  selected=( $(fc -rl 1 | awk '{ cmd=$0; sub(/^[ \t]*[0-9]+\**[ \t]+/, "", cmd); if (!seen[cmd]++) print $0 }' |
-    FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} ${FZF_DEFAULT_OPTS-} -n2..,.. --scheme=history --bind=ctrl-r:toggle-sort,ctrl-z:ignore ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m" $(__fzfcmd)) )
+  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
    num=$selected[1]
--- a/src/LICENSE
+++ b/src/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2013-2023 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/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,51 +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 charClass = charWhite
-)
-
 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
-	}
-	return true
-}
-
 func posArray(withPos bool, len int) *[]int {
 	if withPos {
 		pos := make([]int, 0, len)
@@ -221,10 +181,6 @@ func charClassOfAscii(char rune) charClass {
 		return charUpper
 	} else if char >= '0' && char <= '9' {
 		return charNumber
-	} else if strings.IndexRune(whiteChars, char) >= 0 {
-		return charWhite
-	} else if strings.IndexRune(delimiterChars, char) >= 0 {
-		return charDelimiter
 	}
 	return charNonWord
 }
@@ -238,10 +194,6 @@ func charClassOfNonAscii(char rune) charClass {
 		return charNumber
 	} else if unicode.IsLetter(char) {
 		return charLetter
-	} else if unicode.IsSpace(char) {
-		return charWhite
-	} else if strings.IndexRune(delimiterChars, char) >= 0 {
-		return charDelimiter
 	}
 	return charNonWord
 }
@@ -254,33 +206,22 @@ func charClassOf(char rune) charClass {
 }

 func bonusFor(prevClass charClass, class charClass) int16 {
-	if class > charNonWord {
-		if prevClass == charWhite {
-			// Word boundary after whitespace
-			return bonusBoundaryWhite
-		} else if prevClass == charDelimiter {
-			// Word boundary after a delimiter character
-			return bonusBoundaryDelimiter
-		} else if prevClass == 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
 	} else if class == charNonWord {
 		return bonusNonWord
-	} else if class == charWhite {
-		return bonusBoundaryWhite
 	}
 	return 0
 }

 func bonusAt(input *util.Chars, idx int) int16 {
 	if idx == 0 {
-		return bonusBoundaryWhite
+		return bonusBoundary
 	}
 	return bonusFor(charClassOf(input.Get(idx-1)), charClassOf(input.Get(idx)))
 }
@@ -436,7 +377,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	// 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
+	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 {
@@ -476,7 +417,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			C0sub[off] = 1
 			if M == 1 && (forward && score > maxScore || !forward && score >= maxScore) {
 				maxScore, maxScorePos = score, idx+off
-				if forward && bonus >= bonusBoundary {
+				if forward && bonus == bonusBoundary {
 					break
 				}
 			}
@@ -545,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]
@@ -617,7 +555,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 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))
 	}
@@ -645,7 +583,7 @@ func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, patter
 				firstBonus = bonus
 			} else {
 				// Break consecutive chunk
-				if bonus >= bonusBoundary && bonus > firstBonus {
+				if bonus == bonusBoundary {
 					firstBonus = bonus
 				}
 				bonus = util.Max16(util.Max16(bonus, firstBonus), bonusConsecutive)
@@ -803,7 +741,7 @@ func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text *uti
 				if bonus > bestBonus {
 					bestPos, bestBonus = index, bonus
 				}
-				if bonus >= bonusBoundary {
+				if bonus == bonusBoundary {
 					break
 				}
 				index -= pidx - 1
@@ -939,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
@@ -45,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)
@@ -75,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,
@@ -98,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) {
@@ -114,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))
 	}
 }

@@ -128,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)
@@ -156,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)
 	}
 }

@@ -183,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) {
--- a/src/ansi.go
+++ b/src/ansi.go
@@ -55,9 +55,6 @@ func (s *ansiState) ToString() string {
 	if s.attr&tui.Reverse > 0 {
 		ret += "7;"
 	}
-	if s.attr&tui.StrikeThrough > 0 {
-		ret += "9;"
-	}
 	ret += toAnsiString(s.fg, 30) + toAnsiString(s.bg, 40)

 	return "\x1b[" + strings.TrimSuffix(ret, ";") + "m"
@@ -88,7 +85,7 @@ func isPrint(c uint8) bool {
 }

 func matchOperatingSystemCommand(s string) int {
-	// `\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)`
+	// `\x1b][0-9];[[:print:]]+(?:\x1b\\\\|\x07)`
 	//                        ^ match starting here
 	//
 	i := 5 // prefix matched in nextAnsiEscapeSequence()
@@ -106,37 +103,30 @@ func matchOperatingSystemCommand(s string) int {
 }

 func matchControlSequence(s string) int {
-	// `\x1b[\\[()][0-9;:?]*[a-zA-Z@]`
-	//                     ^ match starting here
+	// `\x1b[\\[()][0-9;?]*[a-zA-Z@]`
+	//                    ^ match starting here
 	//
 	i := 2 // prefix matched in nextAnsiEscapeSequence()
-	for ; i < len(s); 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
@@ -164,16 +154,16 @@ Loop:
 				return i - n, i + 1
 			}
 		case '\x1b':
-			// match: `\x1b[\\[()][0-9;:?]*[a-zA-Z@]`
+			// match: `\x1b[\\[()][0-9;?]*[a-zA-Z@]`
 			if i+2 < len(s) && isCtrlSeqStart(s[i+1]) {
 				if j := matchControlSequence(s[i:]); j != -1 {
 					return i, i + j
 				}
 			}

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

 				if j := matchOperatingSystemCommand(s[i:]); j != -1 {
 					return i, i + j
@@ -290,20 +280,9 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo
 	return trimmed, nil, state
 }

-func parseAnsiCode(s string, delimiter byte) (int, byte, string) {
+func parseAnsiCode(s string) (int, string) {
 	var remaining string
-	i := -1
-	if delimiter == 0 {
-		// Faster than strings.IndexAny(";:")
-		i = strings.IndexByte(s, ';')
-		if i < 0 {
-			i = strings.IndexByte(s, ':')
-		}
-	} else {
-		i = strings.IndexByte(s, delimiter)
-	}
-	if i >= 0 {
-		delimiter = s[i]
+	if i := strings.IndexByte(s, ';'); i >= 0 {
 		remaining = s[i+1:]
 		s = s[:i]
 	}
@@ -315,14 +294,14 @@ func parseAnsiCode(s string, delimiter byte) (int, byte, string) {
 		for _, ch := range []byte(s) {
 			ch -= '0'
 			if ch > 9 {
-				return -1, delimiter, remaining
+				return -1, remaining
 			}
 			code = code*10 + int(ch)
 		}
-		return code, delimiter, remaining
+		return code, remaining
 	}

-	return -1, delimiter, remaining
+	return -1, remaining
 }

 func interpretCode(ansiCode string, prevState *ansiState) ansiState {
@@ -350,10 +329,9 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 	state256 := 0
 	ptr := &state.fg

-	var delimiter byte = 0
 	for len(ansiCode) != 0 {
 		var num int
-		if num, delimiter, ansiCode = parseAnsiCode(ansiCode, delimiter); num != -1 {
+		if num, ansiCode = parseAnsiCode(ansiCode); num != -1 {
 			switch state256 {
 			case 0:
 				switch num {
@@ -379,8 +357,6 @@ 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 23: // tput rmso
 					state.attr = state.attr &^ tui.Italic
 				case 24: // tput rmul
--- 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()
@@ -358,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",
@@ -378,7 +377,7 @@ func TestParseAnsiCode(t *testing.T) {
 		{"-2", "", -1},
 	}
 	for _, x := range tests {
-		n, _, s := parseAnsiCode(x.In, 0)
+		n, s := parseAnsiCode(x.In)
 		if n != x.N || s != x.Exp {
 			t.Fatalf("%q: got: (%d %q) want: (%d %q)", x.In, n, s, x.N, x.Exp)
 		}
@@ -386,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/core.go
+++ b/src/core.go
@@ -1,4 +1,28 @@
-// 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 (
@@ -122,25 +146,21 @@ func Run(opts *Options, version string, revision string) {

 	// Matcher
 	forward := true
-	withPos := false
-	for idx := len(opts.Criteria) - 1; idx > 0; idx-- {
-		switch opts.Criteria[idx] {
-		case byChunk:
-			withPos = true
-		case byEnd:
+	for _, cri := range opts.Criteria[1:] {
+		if cri == byEnd {
 			forward = false
-		case byBegin:
-			forward = true
+			break
+		}
+		if cri == byBegin {
+			break
 		}
 	}
 	patternBuilder := func(runes []rune) *Pattern {
 		return BuildPattern(
-			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward, withPos,
+			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward,
 			opts.Filter == nil, opts.Nth, opts.Delimiter, runes)
 	}
-	inputRevision := 0
-	snapshotRevision := 0
-	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox, inputRevision)
+	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)

 	// Filtering mode
 	if opts.Filter != nil {
@@ -196,55 +216,33 @@ func Run(opts *Options, version string, revision string) {

 	// Terminal I/O
 	terminal := NewTerminal(opts, eventBox)
-	maxFit := 0 // Maximum number of items that can fit on screen
-	padHeight := 0
-	heightUnknown := opts.Height.auto
-	if heightUnknown {
-		maxFit, padHeight = terminal.MaxFitAndPad(opts)
-	}
 	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 *string
-	eventBox.Watch(EvtReadNew)
-	total := 0
-	query := []rune{}
-	determine := func(final bool) {
-		if heightUnknown {
-			if total >= maxFit || final {
-				deferred = false
-				heightUnknown = false
-				terminal.startChan <- fitpad{util.Min(total, maxFit), padHeight}
-			}
-		} else if deferred {
-			deferred = false
-			terminal.startChan <- fitpad{-1, -1}
-		}
-	}
-
-	useSnapshot := false
-	var snapshot []*Chunk
-	var count int
 	restart := func(command string) {
 		reading = true
+		clearCache = util.Once(true)
+		clearSelection = util.Once(true)
 		chunkList.Clear()
 		itemIndex = 0
-		inputRevision++
 		header = make([]string, 0, opts.HeaderLines)
 		go reader.restart(command)
 	}
+	eventBox.Watch(EvtReadNew)
+	query := []rune{}
 	for {
 		delay := true
 		ticks++
-		input := func() []rune {
-			reloaded := snapshotRevision != inputRevision
+		input := func(reloaded bool) []rune {
 			paused, input := terminal.Input()
 			if reloaded && paused {
 				query = []rune{}
@@ -272,35 +270,21 @@ func Run(opts *Options, version string, revision string) {
 					} else {
 						reading = reading && evt == EvtReadNew
 					}
-					if useSnapshot && evt == EvtReadFin {
-						useSnapshot = false
-					}
-					if !useSnapshot {
-						snapshot, count = chunkList.Snapshot()
-						snapshotRevision = inputRevision
-					}
-					total = count
-					terminal.UpdateCount(total, !reading, value.(*string))
+					snapshot, count := chunkList.Snapshot()
+					terminal.UpdateCount(count, !reading, value.(*string))
 					if opts.Sync {
 						opts.Sync = false
-						terminal.UpdateList(PassMerger(&snapshot, opts.Tac, snapshotRevision))
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac), false)
 					}
-					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 *string
-					var changed bool
 					switch val := value.(type) {
 					case searchRequest:
 						sort = val.sort
 						command = val.command
-						changed = val.changed
-						if command != nil {
-							useSnapshot = val.sync
-						}
 					}
 					if command != nil {
 						if reading {
@@ -309,20 +293,11 @@ func Run(opts *Options, version string, revision string) {
 						} else {
 							restart(*command)
 						}
-					}
-					if !changed {
 						break
 					}
-					if !useSnapshot {
-						newSnapshot, _ := chunkList.Snapshot()
-						// We want to avoid showing empty list when reload is triggered
-						// and the query string is changed at the same time i.e. command != nil && changed
-						if command == nil || len(newSnapshot) > 0 {
-							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:
@@ -342,7 +317,8 @@ func Run(opts *Options, version string, revision string) {
 						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 {
@@ -359,10 +335,11 @@ func Run(opts *Options, version string, revision string) {
 									}
 									os.Exit(exitNoMatch)
 								}
-								determine(val.final)
+								deferred = false
+								terminal.startChan <- true
 							}
 						}
-						terminal.UpdateList(val)
+						terminal.UpdateList(val, clearSelection())
 					}
 				}
 			}
--- a/src/matcher.go
+++ b/src/matcher.go
@@ -12,11 +12,11 @@ import (

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

 // Matcher is responsible for performing search
@@ -29,7 +29,6 @@ type Matcher struct {
 	partitions     int
 	slab           []*util.Slab
 	mergerCache    map[string]*Merger
-	revision       int
 }

 const (
@@ -39,7 +38,7 @@ const (

 // NewMatcher returns a new Matcher
 func NewMatcher(patternBuilder func([]rune) *Pattern,
-	sort bool, tac bool, eventBox *util.EventBox, revision int) *Matcher {
+	sort bool, tac bool, eventBox *util.EventBox) *Matcher {
 	partitions := util.Min(numPartitionsMultiplier*runtime.NumCPU(), maxPartitions)
 	return &Matcher{
 		patternBuilder: patternBuilder,
@@ -49,8 +48,7 @@ func NewMatcher(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
@@ -72,9 +70,8 @@ func (m *Matcher) Loop() {
 			events.Clear()
 		})

-		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)
 			clearChunkCache()
 		}
@@ -143,11 +140,11 @@ 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
 	}

 	cancelled := util.NewAtomicBool(false)
@@ -221,11 +218,11 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}
-	return NewMerger(pattern, partialResults, m.sort, m.tac, request.revision), 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 int) {
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool, clearCache bool) {
 	pattern := m.patternBuilder(patternRunes)

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

 // EmptyMerger is a Merger with no data
-func EmptyMerger(revision int) *Merger {
-	return NewMerger(nil, [][]Result{}, false, false, revision)
-}
+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 int
+	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 int) *Merger {
+func PassMerger(chunks *[]*Chunk, tac bool) *Merger {
 	mg := Merger{
-		pattern:  nil,
-		chunks:   chunks,
-		tac:      tac,
-		count:    0,
-		pass:     true,
-		revision: revision}
+		pattern: nil,
+		chunks:  chunks,
+		tac:     tac,
+		count:   0}

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

 // NewMerger returns a new Merger
-func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revision int) *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}
+		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)
@@ -60,42 +53,11 @@ func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revisi
 	return &mg
 }

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

-func (mg *Merger) First() Result {
-	if mg.tac && !mg.sorted {
-		return mg.Get(mg.count - 1)
-	}
-	return mg.Get(0)
-}
-
-// FindIndex returns the index of the item with the given item index
-func (mg *Merger) FindIndex(itemIndex int32) int {
-	index := -1
-	if mg.pass {
-		index = int(itemIndex)
-		if mg.tac {
-			index = mg.count - index - 1
-		}
-	} else {
-		for i := 0; i < mg.count; i++ {
-			if mg.Get(i).item.Index() == itemIndex {
-				index = i
-				break
-			}
-		}
-	}
-	return index
-}
-
 // Get returns the pointer to the Result object indexed by the given integer
 func (mg *Merger) Get(idx int) Result {
 	if mg.chunks != nil {
--- a/src/merger_test.go
+++ b/src/merger_test.go
@@ -57,7 +57,7 @@ func TestMergerUnsorted(t *testing.T) {
 	cnt := len(items)

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

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

 	// Inverse order
-	mg2 := NewMerger(nil, lists, true, false, 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_test.go
+++ b/src/options_test.go
@@ -262,17 +262,13 @@ func TestBind(t *testing.T) {
 		}
 	}
 	check(tui.CtrlA.AsEvent(), "", actBeginningOfLine)
-	errorString := ""
-	errorFn := func(e string) {
-		errorString = e
-	}
 	parseKeymap(keymap,
 		"ctrl-a:kill-line,ctrl-b:toggle-sort+up+down,c:page-up,alt-z:page-down,"+
-			"f1:execute(ls {+})+abort+execute(echo \n{+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
+			"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"+
-			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up", errorFn)
+			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up")
 	check(tui.CtrlA.AsEvent(), "", actKillLine)
 	check(tui.CtrlB.AsEvent(), "", actToggleSort, actUp, actDown)
 	check(tui.Key('c'), "", actPageUp)
@@ -290,15 +286,12 @@ func TestBind(t *testing.T) {
 	check(tui.Key('+'), "++\nfoobar,Y:execute(baz)+up", actExecute)

 	for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} {
-		parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char), errorFn)
+		parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
 		check(tui.Key([]rune(fmt.Sprintf("%d", idx%10))[0]), "foobar", actExecute)
 	}

-	parseKeymap(keymap, "f1:abort", errorFn)
+	parseKeymap(keymap, "f1:abort")
 	check(tui.F1.AsEvent(), "", actAbort)
-	if len(errorString) > 0 {
-		t.Errorf("error parsing keymap: %s", errorString)
-	}
 }

 func TestColorSpec(t *testing.T) {
@@ -361,10 +354,10 @@ func TestDefaultCtrlNP(t *testing.T) {
 	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)
@@ -473,38 +466,3 @@ func TestValidateSign(t *testing.T) {
 		}
 	}
 }
-
-func TestParseSingleActionList(t *testing.T) {
-	actions := parseSingleActionList("Execute@foo+bar,baz@+up+up+reload:down+down", func(string) {})
-	if len(actions) != 4 {
-		t.Errorf("Invalid number of actions parsed:%d", len(actions))
-	}
-	if actions[0].t != actExecute || actions[0].a != "foo+bar,baz" {
-		t.Errorf("Invalid action parsed: %v", actions[0])
-	}
-	if actions[1].t != actUp || actions[2].t != actUp {
-		t.Errorf("Invalid action parsed: %v / %v", actions[1], actions[2])
-	}
-	if actions[3].t != actReload || actions[3].a != "down+down" {
-		t.Errorf("Invalid action parsed: %v", actions[3])
-	}
-}
-
-func TestParseSingleActionListError(t *testing.T) {
-	err := ""
-	parseSingleActionList("change-query(foobar)baz", func(e string) {
-		err = e
-	})
-	if len(err) == 0 {
-		t.Errorf("Failed to detect error")
-	}
-}
-
-func TestMaskActionContents(t *testing.T) {
-	original := ":execute((f)(o)(o)(b)(a)(r))+change-query@qu@ry@+up,x:reload:hello:world"
-	expected := ":execute                    +change-query       +up,x:reload            "
-	masked := maskActionContents(original)
-	if masked != expected {
-		t.Errorf("Not masked: %s", masked)
-	}
-}
--- a/src/pattern.go
+++ b/src/pattern.go
@@ -51,7 +51,6 @@ type Pattern struct {
 	caseSensitive bool
 	normalize     bool
 	forward       bool
-	withPos       bool
 	text          []rune
 	termSets      []termSet
 	sortable      bool
@@ -86,7 +85,7 @@ func clearChunkCache() {

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

 	var asString string
 	if extended {
@@ -146,7 +145,6 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 		caseSensitive: caseSensitive,
 		normalize:     normalize,
 		forward:       forward,
-		withPos:       withPos,
 		text:          []rune(asString),
 		termSets:      termSets,
 		sortable:      sortable,
@@ -304,13 +302,13 @@ func (p *Pattern) matchChunk(chunk *Chunk, space []Result, slab *util.Slab) []Re

 	if space == nil {
 		for idx := 0; idx < chunk.count; idx++ {
-			if match, _, _ := p.MatchItem(&chunk.items[idx], 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 match, _, _ := p.MatchItem(result.item, p.withPos, slab); match != nil {
+			if match, _, _ := p.MatchItem(result.item, false, slab); match != nil {
 				matches = append(matches, *match)
 			}
 		}
--- a/src/pattern_test.go
+++ b/src/pattern_test.go
@@ -67,7 +67,7 @@ func TestParseTermsEmpty(t *testing.T) {
 func TestExact(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true,
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true,
 		[]Range{}, Delimiter{}, []rune("'abc"))
 	chars := util.ToChars([]byte("aabbcc abc"))
 	res, pos := algo.ExactMatchNaive(
@@ -83,7 +83,7 @@ func TestExact(t *testing.T) {
 func TestEqual(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("^AbC$"))
+	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))
@@ -106,17 +106,17 @@ func TestEqual(t *testing.T) {
 func TestCaseSensitivity(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pat1 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat1 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat2 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat2 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat3 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat3 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat4 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat4 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat5 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat5 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat6 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat6 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))

 	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
 		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
@@ -129,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}})

@@ -164,7 +164,7 @@ func TestOrigTextAndTransformed(t *testing.T) {
 func TestCacheKey(t *testing.T) {
 	test := func(extended bool, patStr string, expected string, cacheable bool) {
 		clearPatternCache()
-		pat := BuildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune(patStr))
+		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())
 		}
@@ -188,7 +188,7 @@ func TestCacheKey(t *testing.T) {
 func TestCacheable(t *testing.T) {
 	test := func(fuzzy bool, str string, expected string, cacheable bool) {
 		clearPatternCache()
-		pat := BuildPattern(fuzzy, algo.FuzzyMatchV2, true, CaseSmart, true, true, false, true, []Range{}, Delimiter{}, []rune(str))
+		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())
 		}
--- a/src/result.go
+++ b/src/result.go
@@ -49,22 +49,6 @@ func buildResult(item *Item, offsets []Offset, score int) Result {
 		case byScore:
 			// Higher is better
 			val = math.MaxUint16 - util.AsUint16(score)
-		case byChunk:
-			if validOffsetFound {
-				b := minBegin
-				e := maxEnd
-				for ; b >= 1; b-- {
-					if unicode.IsSpace(item.text.Get(b - 1)) {
-						break
-					}
-				}
-				for ; e < numChars; e++ {
-					if unicode.IsSpace(item.text.Get(e)) {
-						break
-					}
-				}
-				val = util.AsUint16(e - b)
-			}
 		case byLength:
 			val = item.TrimLength()
 		case byBegin, byEnd:
--- 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,23 +98,6 @@ 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 ----  --  ----
 	//   ++++++++        ++++++++++
--- a/src/server.go
+++ b/src/server.go
@@ -1,138 +0,0 @@
-package fzf
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"fmt"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-)
-
-const (
-	crlf             = "\r\n"
-	httpOk           = "HTTP/1.1 200 OK" + crlf
-	httpBadRequest   = "HTTP/1.1 400 Bad Request" + crlf
-	httpReadTimeout  = 10 * time.Second
-	maxContentLength = 1024 * 1024
-)
-
-func startHttpServer(port int, channel chan []*action) (error, int) {
-	if port < 0 {
-		return nil, port
-	}
-
-	listener, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", port))
-	if err != nil {
-		return fmt.Errorf("port not available: %d", port), port
-	}
-	if port == 0 {
-		addr := listener.Addr().String()
-		parts := strings.SplitN(addr, ":", 2)
-		if len(parts) < 2 {
-			return fmt.Errorf("cannot extract port: %s", addr), port
-		}
-		var err error
-		port, err = strconv.Atoi(parts[1])
-		if err != nil {
-			return err, port
-		}
-	}
-
-	go func() {
-		for {
-			conn, err := listener.Accept()
-			if err != nil {
-				if errors.Is(err, net.ErrClosed) {
-					break
-				} else {
-					continue
-				}
-			}
-			conn.Write([]byte(handleHttpRequest(conn, channel)))
-			conn.Close()
-		}
-		listener.Close()
-	}()
-
-	return nil, port
-}
-
-// 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 handleHttpRequest(conn net.Conn, channel chan []*action) string {
-	contentLength := 0
-	body := ""
-	bad := func(message string) string {
-		message += "\n"
-		return httpBadRequest + fmt.Sprintf("Content-Length: %d%s", len(message), crlf+crlf+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:
-			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 && strings.ToLower(pair[0]) == "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 2:
-			body += text
-		}
-	}
-
-	if len(body) < contentLength {
-		return bad("incomplete request")
-	}
-	body = body[:contentLength]
-
-	errorMessage := ""
-	actions := parseSingleActionList(strings.Trim(string(body), "\r\n"), func(message string) {
-		errorMessage = message
-	})
-	if len(errorMessage) > 0 {
-		return bad(errorMessage)
-	}
-	if len(actions) == 0 {
-		return bad("no action specified")
-	}
-
-	channel <- actions
-	return httpOk
-}
--- a/src/terminal.go
+++ b/src/terminal.go
--- a/src/terminal_test.go
+++ b/src/terminal_test.go
@@ -421,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
--- a/src/tui/dummy.go
+++ b/src/tui/dummy.go
@@ -8,35 +8,30 @@ func HasFullscreenRenderer() bool {
 	return false
 }

-var DefaultBorderShape BorderShape = BorderRounded
-
 func (a Attr) Merge(b Attr) Attr {
 	return a | b
 }

 const (
 	AttrUndefined = Attr(0)
-	AttrRegular   = Attr(1 << 8)
-	AttrClear     = Attr(1 << 9)
+	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()                              {}
-func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
-func (r *FullscreenRenderer) Pause(bool)                         {}
-func (r *FullscreenRenderer) Resume(bool, bool)                  {}
-func (r *FullscreenRenderer) Clear()                             {}
-func (r *FullscreenRenderer) NeedScrollbarRedraw() bool          { return false }
-func (r *FullscreenRenderer) Refresh()                           {}
-func (r *FullscreenRenderer) Close()                             {}
+func (r *FullscreenRenderer) Init()             {}
+func (r *FullscreenRenderer) Pause(bool)        {}
+func (r *FullscreenRenderer) Resume(bool, bool) {}
+func (r *FullscreenRenderer) Clear()            {}
+func (r *FullscreenRenderer) Refresh()          {}
+func (r *FullscreenRenderer) Close()            {}

 func (r *FullscreenRenderer) GetChar() Event { return Event{} }
 func (r *FullscreenRenderer) MaxX() int      { return 0 }
--- a/src/tui/light.go
+++ b/src/tui/light.go
@@ -32,26 +32,20 @@ var offsetRegexp *regexp.Regexp = regexp.MustCompile("(.*)\x1b\\[([0-9]+);([0-9]
 var offsetRegexpBegin *regexp.Regexp = regexp.MustCompile("^\x1b\\[[0-9]+;[0-9]+R")

 func (r *LightRenderer) stderr(str string) {
-	r.stderrInternal(str, true, "")
+	r.stderrInternal(str, true)
 }

-const CR string = "\x1b[2m␍"
-const LF string = "\x1b[2m␊"
-
-func (r *LightRenderer) stderrInternal(str string, allowNLCR bool, resetCode string) {
+// FIXME: Need better handling of non-displayable characters
+func (r *LightRenderer) stderrInternal(str string, allowNLCR bool) {
 	bytes := []byte(str)
 	runes := []rune{}
 	for len(bytes) > 0 {
 		r, sz := utf8.DecodeRune(bytes)
 		nlcr := r == '\n' || r == '\r'
 		if r >= 32 || r == '\x1b' || nlcr {
-			if nlcr && !allowNLCR {
-				if r == '\r' {
-					runes = append(runes, []rune(CR+resetCode)...)
-				} else {
-					runes = append(runes, []rune(LF+resetCode)...)
-				}
-			} else if r != utf8.RuneError {
+			if r == utf8.RuneError || nlcr && !allowNLCR {
+				runes = append(runes, ' ')
+			} else {
 				runes = append(runes, r)
 			}
 		}
@@ -60,10 +54,8 @@ func (r *LightRenderer) stderrInternal(str string, allowNLCR bool, resetCode str
 	r.queued.WriteString(string(runes))
 }

-func (r *LightRenderer) csi(code string) string {
-	fullcode := "\x1b[" + code
-	r.stderr(fullcode)
-	return fullcode
+func (r *LightRenderer) csi(code string) {
+	r.stderr("\x1b[" + code)
 }

 func (r *LightRenderer) flush() {
@@ -80,7 +72,7 @@ type LightRenderer struct {
 	forceBlack    bool
 	clearOnExit   bool
 	prevDownTime  time.Time
-	clicks        [][2]int
+	clickY        []int
 	ttyin         *os.File
 	buffer        []byte
 	origState     *term.State
@@ -182,7 +174,10 @@ func (r *LightRenderer) Init() {
 		}
 	}

-	r.enableMouse()
+	if r.mouse {
+		r.csi("?1000h")
+		r.csi("?1006h")
+	}
 	r.csi(fmt.Sprintf("%dA", r.MaxY()-1))
 	r.csi("G")
 	r.csi("K")
@@ -194,10 +189,6 @@ func (r *LightRenderer) Init() {
 	}
 }

-func (r *LightRenderer) Resize(maxHeightFunc func(int) int) {
-	r.maxHeightFunc = maxHeightFunc
-}
-
 func (r *LightRenderer) makeSpace() {
 	r.stderr("\n")
 	r.csi("G")
@@ -430,19 +421,7 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 				}
 				return Event{Invalid, 0, nil} // INS
 			case '3':
-				if r.buffer[3] == '~' {
-					return Event{Del, 0, nil}
-				}
-				if len(r.buffer) == 6 && r.buffer[5] == '~' {
-					*sz = 6
-					switch r.buffer[4] {
-					case '5':
-						return Event{CtrlDelete, 0, nil}
-					case '2':
-						return Event{SDelete, 0, nil}
-					}
-				}
-				return Event{Invalid, 0, nil}
+				return Event{Del, 0, nil}
 			case '4':
 				return Event{End, 0, nil}
 			case '5':
@@ -561,8 +540,8 @@ func (r *LightRenderer) mouseSequence(sz *int) Event {

 	t := atoi(elems[0], -1)
 	x := atoi(elems[1], -1) - 1
-	y := atoi(elems[2], -1) - 1 - r.yoffset
-	if t < 0 || x < 0 {
+	y := atoi(elems[2], -1) - 1
+	if t < 0 || x < 0 || y < 0 {
 		return Event{Invalid, 0, nil}
 	}
 	*sz += end + 1
@@ -586,31 +565,25 @@ func (r *LightRenderer) mouseSequence(sz *int) Event {
 	// ctrl := t & 0b1000
 	mod := t&0b1100 > 0

-	drag := t&0b100000 > 0
-
 	if scroll != 0 {
 		return Event{Mouse, 0, &MouseEvent{y, x, scroll, false, false, false, mod}}
 	}

 	double := false
-	if down && !drag {
+	if down {
 		now := time.Now()
 		if !left { // Right double click is not allowed
-			r.clicks = [][2]int{}
+			r.clickY = []int{}
 		} else if now.Sub(r.prevDownTime) < doubleClickDuration {
-			r.clicks = append(r.clicks, [2]int{x, y})
+			r.clickY = append(r.clickY, y)
 		} else {
-			r.clicks = [][2]int{{x, y}}
+			r.clickY = []int{y}
 		}
 		r.prevDownTime = now
 	} else {
-		n := len(r.clicks)
-		if len(r.clicks) > 1 && r.clicks[n-2][0] == r.clicks[n-1][0] && r.clicks[n-2][1] == r.clicks[n-1][1] &&
+		if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
 			time.Since(r.prevDownTime) < doubleClickDuration {
 			double = true
-			if double {
-				r.clicks = [][2]int{}
-			}
 		}
 	}
 	return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
@@ -625,7 +598,6 @@ func (r *LightRenderer) rmcup() {
 }

 func (r *LightRenderer) Pause(clear bool) {
-	r.disableMouse()
 	r.restoreTerminal()
 	if clear {
 		if r.fullscreen {
@@ -638,22 +610,6 @@ func (r *LightRenderer) Pause(clear bool) {
 	}
 }

-func (r *LightRenderer) enableMouse() {
-	if r.mouse {
-		r.csi("?1000h")
-		r.csi("?1002h")
-		r.csi("?1006h")
-	}
-}
-
-func (r *LightRenderer) disableMouse() {
-	if r.mouse {
-		r.csi("?1000l")
-		r.csi("?1002l")
-		r.csi("?1006l")
-	}
-}
-
 func (r *LightRenderer) Resume(clear bool, sigcont bool) {
 	r.setupTerminal()
 	if clear {
@@ -662,13 +618,13 @@ func (r *LightRenderer) Resume(clear bool, sigcont bool) {
 		} else {
 			r.rmcup()
 		}
-		r.enableMouse()
 		r.flush()
 	} else if sigcont && !r.fullscreen && r.mouse {
 		// NOTE: SIGCONT (Coming back from CTRL-Z):
 		// It's highly likely that the offset we obtained at the beginning is
 		// no longer correct, so we simply disable mouse input.
-		r.disableMouse()
+		r.csi("?1000l")
+		r.csi("?1006l")
 		r.mouse = false
 	}
 }
@@ -683,10 +639,6 @@ func (r *LightRenderer) Clear() {
 	r.flush()
 }

-func (r *LightRenderer) NeedScrollbarRedraw() bool {
-	return false
-}
-
 func (r *LightRenderer) RefreshWindows(windows []Window) {
 	r.flush()
 }
@@ -710,7 +662,10 @@ func (r *LightRenderer) Close() {
 	} else if !r.fullscreen {
 		r.csi("u")
 	}
-	r.disableMouse()
+	if r.mouse {
+		r.csi("?1000l")
+		r.csi("?1006l")
+	}
 	r.flush()
 	r.closePlatform()
 	r.restoreTerminal()
@@ -721,9 +676,6 @@ func (r *LightRenderer) MaxX() int {
 }

 func (r *LightRenderer) MaxY() int {
-	if r.height == 0 {
-		r.updateTerminalSize()
-	}
 	return r.height
 }

@@ -747,38 +699,25 @@ func (r *LightRenderer) NewWindow(top int, left int, width int, height int, prev
 		w.fg = r.theme.Fg.Color
 		w.bg = r.theme.Bg.Color
 	}
-	w.drawBorder(false)
+	w.drawBorder()
 	return w
 }

-func (w *LightWindow) DrawHBorder() {
-	w.drawBorder(true)
-}
-
-func (w *LightWindow) drawBorder(onlyHorizontal bool) {
+func (w *LightWindow) drawBorder() {
 	switch w.border.shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderDouble:
-		w.drawBorderAround(onlyHorizontal)
+	case BorderRounded, BorderSharp:
+		w.drawBorderAround()
 	case BorderHorizontal:
 		w.drawBorderHorizontal(true, true)
 	case BorderVertical:
-		if onlyHorizontal {
-			return
-		}
 		w.drawBorderVertical(true, true)
 	case BorderTop:
 		w.drawBorderHorizontal(true, false)
 	case BorderBottom:
 		w.drawBorderHorizontal(false, true)
 	case BorderLeft:
-		if onlyHorizontal {
-			return
-		}
 		w.drawBorderVertical(true, false)
 	case BorderRight:
-		if onlyHorizontal {
-			return
-		}
 		w.drawBorderVertical(false, true)
 	}
 }
@@ -788,14 +727,13 @@ func (w *LightWindow) drawBorderHorizontal(top, bottom bool) {
 	if w.preview {
 		color = ColPreviewBorder
 	}
-	hw := runewidth.RuneWidth(w.border.top)
 	if top {
 		w.Move(0, 0)
-		w.CPrint(color, repeat(w.border.top, w.width/hw))
+		w.CPrint(color, repeat(w.border.horizontal, w.width))
 	}
 	if bottom {
 		w.Move(w.height-1, 0)
-		w.CPrint(color, repeat(w.border.bottom, w.width/hw))
+		w.CPrint(color, repeat(w.border.horizontal, w.width))
 	}
 }

@@ -811,46 +749,38 @@ func (w *LightWindow) drawBorderVertical(left, right bool) {
 	for y := 0; y < w.height; y++ {
 		w.Move(y, 0)
 		if left {
-			w.CPrint(color, string(w.border.left))
+			w.CPrint(color, string(w.border.vertical))
 		}
 		w.CPrint(color, repeat(' ', width))
 		if right {
-			w.CPrint(color, string(w.border.right))
+			w.CPrint(color, string(w.border.vertical))
 		}
 	}
 }

-func (w *LightWindow) drawBorderAround(onlyHorizontal bool) {
+func (w *LightWindow) drawBorderAround() {
 	w.Move(0, 0)
 	color := ColBorder
 	if w.preview {
 		color = ColPreviewBorder
 	}
-	hw := runewidth.RuneWidth(w.border.top)
-	tcw := runewidth.RuneWidth(w.border.topLeft) + runewidth.RuneWidth(w.border.topRight)
-	bcw := runewidth.RuneWidth(w.border.bottomLeft) + runewidth.RuneWidth(w.border.bottomRight)
-	rem := (w.width - tcw) % hw
-	w.CPrint(color, string(w.border.topLeft)+repeat(w.border.top, (w.width-tcw)/hw)+repeat(' ', rem)+string(w.border.topRight))
-	if !onlyHorizontal {
-		vw := runewidth.RuneWidth(w.border.left)
-		for y := 1; y < w.height-1; y++ {
-			w.Move(y, 0)
-			w.CPrint(color, string(w.border.left))
-			w.CPrint(color, repeat(' ', w.width-vw*2))
-			w.CPrint(color, string(w.border.right))
-		}
+	w.CPrint(color, string(w.border.topLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.topRight))
+	for y := 1; y < w.height-1; y++ {
+		w.Move(y, 0)
+		w.CPrint(color, string(w.border.vertical))
+		w.CPrint(color, repeat(' ', w.width-2))
+		w.CPrint(color, string(w.border.vertical))
 	}
 	w.Move(w.height-1, 0)
-	rem = (w.width - bcw) % hw
-	w.CPrint(color, string(w.border.bottomLeft)+repeat(w.border.bottom, (w.width-bcw)/hw)+repeat(' ', rem)+string(w.border.bottomRight))
+	w.CPrint(color, string(w.border.bottomLeft)+repeat(w.border.horizontal, w.width-2)+string(w.border.bottomRight))
 }

-func (w *LightWindow) csi(code string) string {
-	return w.renderer.csi(code)
+func (w *LightWindow) csi(code string) {
+	w.renderer.csi(code)
 }

-func (w *LightWindow) stderrInternal(str string, allowNLCR bool, resetCode string) {
-	w.renderer.stderrInternal(str, allowNLCR, resetCode)
+func (w *LightWindow) stderrInternal(str string, allowNLCR bool) {
+	w.renderer.stderrInternal(str, allowNLCR)
 }

 func (w *LightWindow) Top() int {
@@ -926,9 +856,6 @@ func attrCodes(attr Attr) []string {
 	if (attr & Reverse) > 0 {
 		codes = append(codes, "7")
 	}
-	if (attr & StrikeThrough) > 0 {
-		codes = append(codes, "9")
-	}
 	return codes
 }

@@ -956,10 +883,10 @@ func colorCodes(fg Color, bg Color) []string {
 	return codes
 }

-func (w *LightWindow) csiColor(fg Color, bg Color, attr Attr) (bool, string) {
+func (w *LightWindow) csiColor(fg Color, bg Color, attr Attr) bool {
 	codes := append(attrCodes(attr), colorCodes(fg, bg)...)
-	code := w.csi(";" + strings.Join(codes, ";") + "m")
-	return len(codes) > 0, code
+	w.csi(";" + strings.Join(codes, ";") + "m")
+	return len(codes) > 0
 }

 func (w *LightWindow) Print(text string) {
@@ -971,17 +898,16 @@ func cleanse(str string) string {
 }

 func (w *LightWindow) CPrint(pair ColorPair, text string) {
-	_, code := w.csiColor(pair.Fg(), pair.Bg(), pair.Attr())
-	w.stderrInternal(cleanse(text), false, code)
+	w.csiColor(pair.Fg(), pair.Bg(), pair.Attr())
+	w.stderrInternal(cleanse(text), false)
 	w.csi("m")
 }

 func (w *LightWindow) cprint2(fg Color, bg Color, attr Attr, text string) {
-	hasColors, code := w.csiColor(fg, bg, attr)
-	if hasColors {
+	if w.csiColor(fg, bg, attr) {
 		defer w.csi("m")
 	}
-	w.stderrInternal(cleanse(text), false, code)
+	w.stderrInternal(cleanse(text), false)
 }

 type wrappedLine struct {
@@ -1001,8 +927,6 @@ func wrapLine(input string, prefixLength int, max int, tabstop int) []wrappedLin
 		if len(rs) == 1 && rs[0] == '\t' {
 			w = tabstop - (prefixLength+width)%tabstop
 			str = repeat(' ', w)
-		} else if rs[0] == '\r' {
-			w++
 		} else {
 			w = runewidth.StringWidth(str)
 		}
@@ -1021,12 +945,12 @@ func wrapLine(input string, prefixLength int, max int, tabstop int) []wrappedLin
 	return lines
 }

-func (w *LightWindow) fill(str string, resetCode string) FillReturn {
+func (w *LightWindow) fill(str string, onMove func()) FillReturn {
 	allLines := strings.Split(str, "\n")
 	for i, line := range allLines {
 		lines := wrapLine(line, w.posx, w.width, w.tabstop)
 		for j, wl := range lines {
-			w.stderrInternal(wl.text, false, resetCode)
+			w.stderrInternal(wl.text, false)
 			w.posx += wl.displayWidth

 			// Wrap line
@@ -1036,7 +960,7 @@ func (w *LightWindow) fill(str string, resetCode string) FillReturn {
 				}
 				w.MoveAndClear(w.posy, w.posx)
 				w.Move(w.posy+1, 0)
-				w.renderer.stderr(resetCode)
+				onMove()
 			}
 		}
 	}
@@ -1045,26 +969,22 @@ func (w *LightWindow) fill(str string, resetCode string) FillReturn {
 			return FillSuspend
 		}
 		w.Move(w.posy+1, 0)
-		w.renderer.stderr(resetCode)
+		onMove()
 		return FillNextLine
 	}
 	return FillContinue
 }

-func (w *LightWindow) setBg() string {
+func (w *LightWindow) setBg() {
 	if w.bg != colDefault {
-		_, code := w.csiColor(colDefault, w.bg, AttrRegular)
-		return code
+		w.csiColor(colDefault, w.bg, AttrRegular)
 	}
-	// Should clear dim attribute after ␍ in the preview window
-	// e.g. printf "foo\rbar" | fzf --ansi --preview 'printf "foo\rbar"'
-	return "\x1b[m"
 }

 func (w *LightWindow) Fill(text string) FillReturn {
 	w.Move(w.posy, w.posx)
-	code := w.setBg()
-	return w.fill(text, code)
+	w.setBg()
+	return w.fill(text, w.setBg)
 }

 func (w *LightWindow) CFill(fg Color, bg Color, attr Attr, text string) FillReturn {
@@ -1075,11 +995,11 @@ func (w *LightWindow) CFill(fg Color, bg Color, attr Attr, text string) FillRetu
 	if bg == colDefault {
 		bg = w.bg
 	}
-	if hasColors, resetCode := w.csiColor(fg, bg, attr); hasColors {
+	if w.csiColor(fg, bg, attr) {
 		defer w.csi("m")
-		return w.fill(text, resetCode)
+		return w.fill(text, func() { w.csiColor(fg, bg, attr) })
 	}
-	return w.fill(text, w.setBg())
+	return w.fill(text, w.setBg)
 }

 func (w *LightWindow) FinishFill() {
@@ -1090,7 +1010,7 @@ func (w *LightWindow) FinishFill() {
 }

 func (w *LightWindow) Erase() {
-	w.drawBorder(false)
+	w.drawBorder()
 	// We don't erase the window here to avoid flickering during scroll
 	w.Move(0, 0)
 }
--- a/src/tui/tcell.go
+++ b/src/tui/tcell.go
@@ -6,9 +6,10 @@ import (
 	"os"
 	"time"

-	"github.com/gdamore/tcell/v2"
-	"github.com/gdamore/tcell/v2/encoding"
-	"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"
@@ -18,26 +19,12 @@ 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
@@ -76,6 +63,8 @@ func (w *TcellWindow) Refresh() {
 	}
 	w.lastX = 0
 	w.lastY = 0
+
+	w.drawBorder()
 }

 func (w *TcellWindow) FinishFill() {
@@ -83,13 +72,12 @@ 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 (
@@ -98,8 +86,6 @@ const (
 	AttrClear     = Attr(1 << 8)
 )

-func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
-
 func (r *FullscreenRenderer) defaultTheme() *ColorTheme {
 	if _screen.Colors() >= 256 {
 		return Dark256
@@ -190,10 +176,6 @@ func (r *FullscreenRenderer) Clear() {
 	_screen.Clear()
 }

-func (r *FullscreenRenderer) NeedScrollbarRedraw() bool {
-	return true
-}
-
 func (r *FullscreenRenderer) Refresh() {
 	// noop
 }
@@ -223,38 +205,54 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, false, mod}}
 		case button&tcell.WheelUp != 0:
 			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, false, mod}}
-		case button&tcell.Button1 != 0:
-			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{}
-				}
+		case button&tcell.Button1 != 0 && !drag:
+			// all potential double click events put their 'line' coordinate in the clickY array
+			// double click event has two conditions, temporal and spatial, the first is checked here
+			now := time.Now()
+			if now.Sub(r.prevDownTime) < doubleClickDuration {
+				r.clickY = append(r.clickY, y)
+			} else {
+				r.clickY = []int{y}
 			}
+			r.prevDownTime = now
+
+			// detect double clicks (also check for spatial condition)
+			n := len(r.clickY)
+			double := n > 1 && r.clickY[n-2] == r.clickY[n-1]
+			if double {
+				// make sure two consecutive double clicks require four clicks
+				r.clickY = []int{}
+			}
+
 			// fire single or double click event
 			return Event{Mouse, 0, &MouseEvent{y, x, 0, true, !double, double, mod}}
-		case button&tcell.Button2 != 0:
+		case button&tcell.Button2 != 0 && !drag:
 			return Event{Mouse, 0, &MouseEvent{y, x, 0, false, true, false, mod}}
-		default:
+		case runtime.GOOS != "windows":
+
 			// double and single taps on Windows don't quite work due to
 			// the console acting on the events and not allowing us
 			// to consume them.
+
 			left := button&tcell.Button1 != 0
 			down := left || button&tcell.Button3 != 0
 			double := false
+			if down {
+				now := time.Now()
+				if !left {
+					r.clickY = []int{}
+				} else if now.Sub(r.prevDownTime) < doubleClickDuration {
+					r.clickY = append(r.clickY, x)
+				} else {
+					r.clickY = []int{x}
+					r.prevDownTime = now
+				}
+			} else {
+				if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
+					time.Now().Sub(r.prevDownTime) < doubleClickDuration {
+					double = true
+				}
+			}

 			return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
 		}
@@ -413,12 +411,6 @@ 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{SDelete, 0, nil}
-			}
 			return Event{Del, 0, nil}
 		case tcell.KeyEnd:
 			return Event{End, 0, nil}
@@ -510,7 +502,7 @@ func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int,
 	if preview {
 		normal = ColPreview
 	}
-	w := &TcellWindow{
+	return &TcellWindow{
 		color:       r.theme.Colored,
 		preview:     preview,
 		top:         top,
@@ -519,8 +511,6 @@ func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int,
 		height:      height,
 		normal:      normal,
 		borderStyle: borderStyle}
-	w.drawBorder(false)
-	return w
 }

 func (w *TcellWindow) Close() {
@@ -536,7 +526,7 @@ func fill(x, y, w, h int, n ColorPair, r rune) {
 }

 func (w *TcellWindow) Erase() {
-	fill(w.left-1, w.top, w.width+1, w.height-1, w.normal, ' ')
+	fill(w.left-1, w.top, w.width+1, w.height, w.normal, ' ')
 }

 func (w *TcellWindow) Enclose(y int, x int) bool {
@@ -571,7 +561,6 @@ 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)
@@ -579,27 +568,26 @@ func (w *TcellWindow) printString(text string, pair ColorPair) {

 	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
 }
@@ -624,26 +612,16 @@ func (w *TcellWindow) fillString(text string, pair ColorPair) FillReturn {
 		Dim(a&Attr(tcell.AttrDim) != 0).
 		Reverse(a&Attr(tcell.AttrReverse) != 0).
 		Underline(a&Attr(tcell.AttrUnderline) != 0).
-		StrikeThrough(a&Attr(tcell.AttrStrikeThrough) != 0).
 		Italic(a&Attr(tcell.AttrItalic) != 0)

 	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:
@@ -660,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 {
@@ -687,11 +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) DrawHBorder() {
-	w.drawBorder(true)
-}
-
-func (w *TcellWindow) drawBorder(onlyHorizontal bool) {
+func (w *TcellWindow) drawBorder() {
 	shape := w.borderStyle.shape
 	if shape == BorderNone {
 		return
@@ -713,52 +687,35 @@ func (w *TcellWindow) drawBorder(onlyHorizontal bool) {
 		style = w.normal.style()
 	}

-	hw := runewidth.RuneWidth(w.borderStyle.top)
 	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, 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, 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, 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, BorderDouble, BorderVertical, BorderRight:
-			vw := runewidth.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, 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.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.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
@@ -5,7 +5,7 @@ package tui
 import (
 	"testing"

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

--- a/src/tui/tui.go
+++ b/src/tui/tui.go
@@ -41,7 +41,6 @@ const (
 	CtrlZ
 	ESC
 	CtrlSpace
-	CtrlDelete

 	// https://apple.stackexchange.com/questions/24261/how-do-i-send-c-that-is-control-slash-to-the-terminal
 	CtrlBackSlash
@@ -75,7 +74,6 @@ const (
 	SDown
 	SLeft
 	SRight
-	SDelete

 	F1
 	F2
@@ -92,11 +90,6 @@ const (

 	Change
 	BackwardEOF
-	Start
-	Load
-	Focus
-	One
-	Zero

 	AltBS

@@ -255,31 +248,25 @@ func (p ColorPair) MergeNonDefault(other ColorPair) ColorPair {
 }

 type ColorTheme struct {
-	Colored          bool
-	Input            ColorAttr
-	Disabled         ColorAttr
-	Fg               ColorAttr
-	Bg               ColorAttr
-	PreviewFg        ColorAttr
-	PreviewBg        ColorAttr
-	DarkBg           ColorAttr
-	Gutter           ColorAttr
-	Prompt           ColorAttr
-	Match            ColorAttr
-	Current          ColorAttr
-	CurrentMatch     ColorAttr
-	Spinner          ColorAttr
-	Info             ColorAttr
-	Cursor           ColorAttr
-	Selected         ColorAttr
-	Header           ColorAttr
-	Separator        ColorAttr
-	Scrollbar        ColorAttr
-	Border           ColorAttr
-	PreviewBorder    ColorAttr
-	PreviewScrollbar ColorAttr
-	BorderLabel      ColorAttr
-	PreviewLabel     ColorAttr
+	Colored      bool
+	Input        ColorAttr
+	Disabled     ColorAttr
+	Fg           ColorAttr
+	Bg           ColorAttr
+	PreviewFg    ColorAttr
+	PreviewBg    ColorAttr
+	DarkBg       ColorAttr
+	Gutter       ColorAttr
+	Prompt       ColorAttr
+	Match        ColorAttr
+	Current      ColorAttr
+	CurrentMatch ColorAttr
+	Spinner      ColorAttr
+	Info         ColorAttr
+	Cursor       ColorAttr
+	Selected     ColorAttr
+	Header       ColorAttr
+	Border       ColorAttr
 }

 type Event struct {
@@ -288,15 +275,6 @@ type Event struct {
 	MouseEvent *MouseEvent
 }

-func (e Event) Is(types ...EventType) bool {
-	for _, t := range types {
-		if e.Type == t {
-			return true
-		}
-	}
-	return false
-}
-
 type MouseEvent struct {
 	Y      int
 	X      int
@@ -313,9 +291,6 @@ const (
 	BorderNone BorderShape = iota
 	BorderRounded
 	BorderSharp
-	BorderBold
-	BorderBlock
-	BorderDouble
 	BorderHorizontal
 	BorderVertical
 	BorderTop
@@ -324,28 +299,10 @@ const (
 	BorderRight
 )

-func (s BorderShape) HasRight() bool {
-	switch s {
-	case BorderNone, BorderLeft, BorderTop, BorderBottom, BorderHorizontal: // No right
-		return false
-	}
-	return true
-}
-
-func (s BorderShape) HasTop() bool {
-	switch s {
-	case BorderNone, BorderLeft, BorderRight, BorderBottom, BorderVertical: // No top
-		return false
-	}
-	return true
-}
-
 type BorderStyle struct {
 	shape       BorderShape
-	top         rune
-	bottom      rune
-	left        rune
-	right       rune
+	horizontal  rune
+	vertical    rune
 	topLeft     rune
 	topRight    rune
 	bottomLeft  rune
@@ -355,92 +312,44 @@ type BorderStyle struct {
 type BorderCharacter int

 func MakeBorderStyle(shape BorderShape, unicode bool) BorderStyle {
-	if !unicode {
-		return BorderStyle{
-			shape:       shape,
-			top:         '-',
-			bottom:      '-',
-			left:        '|',
-			right:       '|',
-			topLeft:     '+',
-			topRight:    '+',
-			bottomLeft:  '+',
-			bottomRight: '+',
+	if unicode {
+		if shape == BorderRounded {
+			return BorderStyle{
+				shape:       shape,
+				horizontal:  '─',
+				vertical:    '│',
+				topLeft:     '╭',
+				topRight:    '╮',
+				bottomLeft:  '╰',
+				bottomRight: '╯',
+			}
 		}
-	}
-	switch shape {
-	case BorderSharp:
 		return BorderStyle{
 			shape:       shape,
-			top:         '─',
-			bottom:      '─',
-			left:        '│',
-			right:       '│',
+			horizontal:  '─',
+			vertical:    '│',
 			topLeft:     '┌',
 			topRight:    '┐',
 			bottomLeft:  '└',
 			bottomRight: '┘',
 		}
-	case BorderBold:
-		return BorderStyle{
-			shape:       shape,
-			top:         '━',
-			bottom:      '━',
-			left:        '┃',
-			right:       '┃',
-			topLeft:     '┏',
-			topRight:    '┓',
-			bottomLeft:  '┗',
-			bottomRight: '┛',
-		}
-	case BorderBlock:
-		// ▛▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▜
-		// ▌                  ▐
-		// ▙▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▟
-		return BorderStyle{
-			shape:       shape,
-			top:         '▀',
-			bottom:      '▄',
-			left:        '▌',
-			right:       '▐',
-			topLeft:     '▛',
-			topRight:    '▜',
-			bottomLeft:  '▙',
-			bottomRight: '▟',
-		}
-	case BorderDouble:
-		return BorderStyle{
-			shape:       shape,
-			top:         '═',
-			bottom:      '═',
-			left:        '║',
-			right:       '║',
-			topLeft:     '╔',
-			topRight:    '╗',
-			bottomLeft:  '╚',
-			bottomRight: '╝',
-		}
 	}
 	return BorderStyle{
 		shape:       shape,
-		top:         '─',
-		bottom:      '─',
-		left:        '│',
-		right:       '│',
-		topLeft:     '╭',
-		topRight:    '╮',
-		bottomLeft:  '╰',
-		bottomRight: '╯',
+		horizontal:  '-',
+		vertical:    '|',
+		topLeft:     '+',
+		topRight:    '+',
+		bottomLeft:  '+',
+		bottomRight: '+',
 	}
 }

 func MakeTransparentBorder() BorderStyle {
 	return BorderStyle{
 		shape:       BorderRounded,
-		top:         ' ',
-		bottom:      ' ',
-		left:        ' ',
-		right:       ' ',
+		horizontal:  ' ',
+		vertical:    ' ',
 		topLeft:     ' ',
 		topRight:    ' ',
 		bottomLeft:  ' ',
@@ -449,14 +358,12 @@ func MakeTransparentBorder() BorderStyle {

 type Renderer interface {
 	Init()
-	Resize(maxHeightFunc func(int) int)
 	Pause(clear bool)
 	Resume(clear bool, sigcont bool)
 	Clear()
 	RefreshWindows(windows []Window)
 	Refresh()
 	Close()
-	NeedScrollbarRedraw() bool

 	GetChar() Event

@@ -472,7 +379,6 @@ type Window interface {
 	Width() int
 	Height() int

-	DrawHBorder()
 	Refresh()
 	FinishFill()
 	Close()
@@ -495,7 +401,7 @@ type FullscreenRenderer struct {
 	mouse        bool
 	forceBlack   bool
 	prevDownTime time.Time
-	clicks       [][2]int
+	clickY       []int
 }

 func NewFullscreenRenderer(theme *ColorTheme, forceBlack bool, mouse bool) Renderer {
@@ -504,7 +410,7 @@ func NewFullscreenRenderer(theme *ColorTheme, forceBlack bool, mouse bool) Rende
 		mouse:        mouse,
 		forceBlack:   forceBlack,
 		prevDownTime: time.Unix(0, 0),
-		clicks:       [][2]int{}}
+		clickY:       []int{}}
 	return r
 }

@@ -530,74 +436,55 @@ var (
 	ColSpinner              ColorPair
 	ColInfo                 ColorPair
 	ColHeader               ColorPair
-	ColSeparator            ColorPair
-	ColScrollbar            ColorPair
 	ColBorder               ColorPair
 	ColPreview              ColorPair
 	ColPreviewBorder        ColorPair
-	ColBorderLabel          ColorPair
-	ColPreviewLabel         ColorPair
-	ColPreviewScrollbar     ColorPair
 )

 func EmptyTheme() *ColorTheme {
 	return &ColorTheme{
-		Colored:          true,
-		Input:            ColorAttr{colUndefined, AttrUndefined},
-		Fg:               ColorAttr{colUndefined, AttrUndefined},
-		Bg:               ColorAttr{colUndefined, AttrUndefined},
-		DarkBg:           ColorAttr{colUndefined, AttrUndefined},
-		Prompt:           ColorAttr{colUndefined, AttrUndefined},
-		Match:            ColorAttr{colUndefined, AttrUndefined},
-		Current:          ColorAttr{colUndefined, AttrUndefined},
-		CurrentMatch:     ColorAttr{colUndefined, AttrUndefined},
-		Spinner:          ColorAttr{colUndefined, AttrUndefined},
-		Info:             ColorAttr{colUndefined, AttrUndefined},
-		Cursor:           ColorAttr{colUndefined, AttrUndefined},
-		Selected:         ColorAttr{colUndefined, AttrUndefined},
-		Header:           ColorAttr{colUndefined, AttrUndefined},
-		Border:           ColorAttr{colUndefined, AttrUndefined},
-		BorderLabel:      ColorAttr{colUndefined, AttrUndefined},
-		Disabled:         ColorAttr{colUndefined, AttrUndefined},
-		PreviewFg:        ColorAttr{colUndefined, AttrUndefined},
-		PreviewBg:        ColorAttr{colUndefined, AttrUndefined},
-		Gutter:           ColorAttr{colUndefined, AttrUndefined},
-		PreviewBorder:    ColorAttr{colUndefined, AttrUndefined},
-		PreviewScrollbar: ColorAttr{colUndefined, AttrUndefined},
-		PreviewLabel:     ColorAttr{colUndefined, AttrUndefined},
-		Separator:        ColorAttr{colUndefined, AttrUndefined},
-		Scrollbar:        ColorAttr{colUndefined, AttrUndefined},
-	}
+		Colored:      true,
+		Input:        ColorAttr{colUndefined, AttrUndefined},
+		Disabled:     ColorAttr{colUndefined, AttrUndefined},
+		Fg:           ColorAttr{colUndefined, AttrUndefined},
+		Bg:           ColorAttr{colUndefined, AttrUndefined},
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
+		DarkBg:       ColorAttr{colUndefined, AttrUndefined},
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
+		Prompt:       ColorAttr{colUndefined, AttrUndefined},
+		Match:        ColorAttr{colUndefined, AttrUndefined},
+		Current:      ColorAttr{colUndefined, AttrUndefined},
+		CurrentMatch: ColorAttr{colUndefined, AttrUndefined},
+		Spinner:      ColorAttr{colUndefined, AttrUndefined},
+		Info:         ColorAttr{colUndefined, AttrUndefined},
+		Cursor:       ColorAttr{colUndefined, AttrUndefined},
+		Selected:     ColorAttr{colUndefined, AttrUndefined},
+		Header:       ColorAttr{colUndefined, AttrUndefined},
+		Border:       ColorAttr{colUndefined, AttrUndefined}}
 }

 func NoColorTheme() *ColorTheme {
 	return &ColorTheme{
-		Colored:          false,
-		Input:            ColorAttr{colDefault, AttrUndefined},
-		Fg:               ColorAttr{colDefault, AttrUndefined},
-		Bg:               ColorAttr{colDefault, AttrUndefined},
-		DarkBg:           ColorAttr{colDefault, AttrUndefined},
-		Prompt:           ColorAttr{colDefault, AttrUndefined},
-		Match:            ColorAttr{colDefault, Underline},
-		Current:          ColorAttr{colDefault, Reverse},
-		CurrentMatch:     ColorAttr{colDefault, Reverse | Underline},
-		Spinner:          ColorAttr{colDefault, AttrUndefined},
-		Info:             ColorAttr{colDefault, AttrUndefined},
-		Cursor:           ColorAttr{colDefault, AttrUndefined},
-		Selected:         ColorAttr{colDefault, AttrUndefined},
-		Header:           ColorAttr{colDefault, AttrUndefined},
-		Border:           ColorAttr{colDefault, AttrUndefined},
-		BorderLabel:      ColorAttr{colDefault, AttrUndefined},
-		Disabled:         ColorAttr{colDefault, AttrUndefined},
-		PreviewFg:        ColorAttr{colDefault, AttrUndefined},
-		PreviewBg:        ColorAttr{colDefault, AttrUndefined},
-		Gutter:           ColorAttr{colDefault, AttrUndefined},
-		PreviewBorder:    ColorAttr{colDefault, AttrUndefined},
-		PreviewScrollbar: ColorAttr{colDefault, AttrUndefined},
-		PreviewLabel:     ColorAttr{colDefault, AttrUndefined},
-		Separator:        ColorAttr{colDefault, AttrUndefined},
-		Scrollbar:        ColorAttr{colDefault, AttrUndefined},
-	}
+		Colored:      false,
+		Input:        ColorAttr{colDefault, AttrRegular},
+		Disabled:     ColorAttr{colDefault, AttrRegular},
+		Fg:           ColorAttr{colDefault, AttrRegular},
+		Bg:           ColorAttr{colDefault, AttrRegular},
+		PreviewFg:    ColorAttr{colDefault, AttrRegular},
+		PreviewBg:    ColorAttr{colDefault, AttrRegular},
+		DarkBg:       ColorAttr{colDefault, AttrRegular},
+		Gutter:       ColorAttr{colDefault, AttrRegular},
+		Prompt:       ColorAttr{colDefault, AttrRegular},
+		Match:        ColorAttr{colDefault, Underline},
+		Current:      ColorAttr{colDefault, Reverse},
+		CurrentMatch: ColorAttr{colDefault, Reverse | Underline},
+		Spinner:      ColorAttr{colDefault, AttrRegular},
+		Info:         ColorAttr{colDefault, AttrRegular},
+		Cursor:       ColorAttr{colDefault, AttrRegular},
+		Selected:     ColorAttr{colDefault, AttrRegular},
+		Header:       ColorAttr{colDefault, AttrRegular},
+		Border:       ColorAttr{colDefault, AttrRegular}}
 }

 func errorExit(message string) {
@@ -607,86 +494,65 @@ func errorExit(message string) {

 func init() {
 	Default16 = &ColorTheme{
-		Colored:          true,
-		Input:            ColorAttr{colDefault, AttrUndefined},
-		Fg:               ColorAttr{colDefault, AttrUndefined},
-		Bg:               ColorAttr{colDefault, AttrUndefined},
-		DarkBg:           ColorAttr{colBlack, AttrUndefined},
-		Prompt:           ColorAttr{colBlue, AttrUndefined},
-		Match:            ColorAttr{colGreen, AttrUndefined},
-		Current:          ColorAttr{colYellow, AttrUndefined},
-		CurrentMatch:     ColorAttr{colGreen, AttrUndefined},
-		Spinner:          ColorAttr{colGreen, AttrUndefined},
-		Info:             ColorAttr{colWhite, AttrUndefined},
-		Cursor:           ColorAttr{colRed, AttrUndefined},
-		Selected:         ColorAttr{colMagenta, AttrUndefined},
-		Header:           ColorAttr{colCyan, AttrUndefined},
-		Border:           ColorAttr{colBlack, AttrUndefined},
-		BorderLabel:      ColorAttr{colWhite, AttrUndefined},
-		Disabled:         ColorAttr{colUndefined, AttrUndefined},
-		PreviewFg:        ColorAttr{colUndefined, AttrUndefined},
-		PreviewBg:        ColorAttr{colUndefined, AttrUndefined},
-		Gutter:           ColorAttr{colUndefined, AttrUndefined},
-		PreviewBorder:    ColorAttr{colUndefined, AttrUndefined},
-		PreviewScrollbar: ColorAttr{colUndefined, AttrUndefined},
-		PreviewLabel:     ColorAttr{colUndefined, AttrUndefined},
-		Separator:        ColorAttr{colUndefined, AttrUndefined},
-		Scrollbar:        ColorAttr{colUndefined, AttrUndefined},
-	}
+		Colored:      true,
+		Input:        ColorAttr{colDefault, AttrUndefined},
+		Disabled:     ColorAttr{colUndefined, AttrUndefined},
+		Fg:           ColorAttr{colDefault, AttrUndefined},
+		Bg:           ColorAttr{colDefault, AttrUndefined},
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
+		DarkBg:       ColorAttr{colBlack, AttrUndefined},
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
+		Prompt:       ColorAttr{colBlue, AttrUndefined},
+		Match:        ColorAttr{colGreen, AttrUndefined},
+		Current:      ColorAttr{colYellow, AttrUndefined},
+		CurrentMatch: ColorAttr{colGreen, AttrUndefined},
+		Spinner:      ColorAttr{colGreen, AttrUndefined},
+		Info:         ColorAttr{colWhite, AttrUndefined},
+		Cursor:       ColorAttr{colRed, AttrUndefined},
+		Selected:     ColorAttr{colMagenta, AttrUndefined},
+		Header:       ColorAttr{colCyan, AttrUndefined},
+		Border:       ColorAttr{colBlack, AttrUndefined}}
 	Dark256 = &ColorTheme{
-		Colored:          true,
-		Input:            ColorAttr{colDefault, AttrUndefined},
-		Fg:               ColorAttr{colDefault, AttrUndefined},
-		Bg:               ColorAttr{colDefault, AttrUndefined},
-		DarkBg:           ColorAttr{236, AttrUndefined},
-		Prompt:           ColorAttr{110, AttrUndefined},
-		Match:            ColorAttr{108, AttrUndefined},
-		Current:          ColorAttr{254, AttrUndefined},
-		CurrentMatch:     ColorAttr{151, AttrUndefined},
-		Spinner:          ColorAttr{148, AttrUndefined},
-		Info:             ColorAttr{144, AttrUndefined},
-		Cursor:           ColorAttr{161, AttrUndefined},
-		Selected:         ColorAttr{168, AttrUndefined},
-		Header:           ColorAttr{109, AttrUndefined},
-		Border:           ColorAttr{59, AttrUndefined},
-		BorderLabel:      ColorAttr{145, AttrUndefined},
-		Disabled:         ColorAttr{colUndefined, AttrUndefined},
-		PreviewFg:        ColorAttr{colUndefined, AttrUndefined},
-		PreviewBg:        ColorAttr{colUndefined, AttrUndefined},
-		Gutter:           ColorAttr{colUndefined, AttrUndefined},
-		PreviewBorder:    ColorAttr{colUndefined, AttrUndefined},
-		PreviewScrollbar: ColorAttr{colUndefined, AttrUndefined},
-		PreviewLabel:     ColorAttr{colUndefined, AttrUndefined},
-		Separator:        ColorAttr{colUndefined, AttrUndefined},
-		Scrollbar:        ColorAttr{colUndefined, AttrUndefined},
-	}
+		Colored:      true,
+		Input:        ColorAttr{colDefault, AttrUndefined},
+		Disabled:     ColorAttr{colUndefined, AttrUndefined},
+		Fg:           ColorAttr{colDefault, AttrUndefined},
+		Bg:           ColorAttr{colDefault, AttrUndefined},
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
+		DarkBg:       ColorAttr{236, AttrUndefined},
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
+		Prompt:       ColorAttr{110, AttrUndefined},
+		Match:        ColorAttr{108, AttrUndefined},
+		Current:      ColorAttr{254, AttrUndefined},
+		CurrentMatch: ColorAttr{151, AttrUndefined},
+		Spinner:      ColorAttr{148, AttrUndefined},
+		Info:         ColorAttr{144, AttrUndefined},
+		Cursor:       ColorAttr{161, AttrUndefined},
+		Selected:     ColorAttr{168, AttrUndefined},
+		Header:       ColorAttr{109, AttrUndefined},
+		Border:       ColorAttr{59, AttrUndefined}}
 	Light256 = &ColorTheme{
-		Colored:          true,
-		Input:            ColorAttr{colDefault, AttrUndefined},
-		Fg:               ColorAttr{colDefault, AttrUndefined},
-		Bg:               ColorAttr{colDefault, AttrUndefined},
-		DarkBg:           ColorAttr{251, AttrUndefined},
-		Prompt:           ColorAttr{25, AttrUndefined},
-		Match:            ColorAttr{66, AttrUndefined},
-		Current:          ColorAttr{237, AttrUndefined},
-		CurrentMatch:     ColorAttr{23, AttrUndefined},
-		Spinner:          ColorAttr{65, AttrUndefined},
-		Info:             ColorAttr{101, AttrUndefined},
-		Cursor:           ColorAttr{161, AttrUndefined},
-		Selected:         ColorAttr{168, AttrUndefined},
-		Header:           ColorAttr{31, AttrUndefined},
-		Border:           ColorAttr{145, AttrUndefined},
-		BorderLabel:      ColorAttr{59, AttrUndefined},
-		Disabled:         ColorAttr{colUndefined, AttrUndefined},
-		PreviewFg:        ColorAttr{colUndefined, AttrUndefined},
-		PreviewBg:        ColorAttr{colUndefined, AttrUndefined},
-		Gutter:           ColorAttr{colUndefined, AttrUndefined},
-		PreviewBorder:    ColorAttr{colUndefined, AttrUndefined},
-		PreviewScrollbar: ColorAttr{colUndefined, AttrUndefined},
-		PreviewLabel:     ColorAttr{colUndefined, AttrUndefined},
-		Separator:        ColorAttr{colUndefined, AttrUndefined},
-		Scrollbar:        ColorAttr{colUndefined, AttrUndefined},
-	}
+		Colored:      true,
+		Input:        ColorAttr{colDefault, AttrUndefined},
+		Disabled:     ColorAttr{colUndefined, AttrUndefined},
+		Fg:           ColorAttr{colDefault, AttrUndefined},
+		Bg:           ColorAttr{colDefault, AttrUndefined},
+		PreviewFg:    ColorAttr{colUndefined, AttrUndefined},
+		PreviewBg:    ColorAttr{colUndefined, AttrUndefined},
+		DarkBg:       ColorAttr{251, AttrUndefined},
+		Gutter:       ColorAttr{colUndefined, AttrUndefined},
+		Prompt:       ColorAttr{25, AttrUndefined},
+		Match:        ColorAttr{66, AttrUndefined},
+		Current:      ColorAttr{237, AttrUndefined},
+		CurrentMatch: ColorAttr{23, AttrUndefined},
+		Spinner:      ColorAttr{65, AttrUndefined},
+		Info:         ColorAttr{101, AttrUndefined},
+		Cursor:       ColorAttr{161, AttrUndefined},
+		Selected:     ColorAttr{168, AttrUndefined},
+		Header:       ColorAttr{31, AttrUndefined},
+		Border:       ColorAttr{145, AttrUndefined}}
 }

 func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
@@ -705,9 +571,13 @@ func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
 		return c
 	}
 	theme.Input = o(baseTheme.Input, theme.Input)
+	theme.Disabled = o(theme.Input, o(baseTheme.Disabled, theme.Disabled))
 	theme.Fg = o(baseTheme.Fg, theme.Fg)
 	theme.Bg = o(baseTheme.Bg, theme.Bg)
+	theme.PreviewFg = o(theme.Fg, o(baseTheme.PreviewFg, theme.PreviewFg))
+	theme.PreviewBg = o(theme.Bg, o(baseTheme.PreviewBg, theme.PreviewBg))
 	theme.DarkBg = o(baseTheme.DarkBg, theme.DarkBg)
+	theme.Gutter = o(theme.DarkBg, o(baseTheme.Gutter, theme.Gutter))
 	theme.Prompt = o(baseTheme.Prompt, theme.Prompt)
 	theme.Match = o(baseTheme.Match, theme.Match)
 	theme.Current = o(baseTheme.Current, theme.Current)
@@ -718,18 +588,6 @@ func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
 	theme.Selected = o(baseTheme.Selected, theme.Selected)
 	theme.Header = o(baseTheme.Header, theme.Header)
 	theme.Border = o(baseTheme.Border, theme.Border)
-	theme.BorderLabel = o(baseTheme.BorderLabel, theme.BorderLabel)
-
-	// These colors are not defined in the base themes
-	theme.Disabled = o(theme.Input, theme.Disabled)
-	theme.Gutter = o(theme.DarkBg, theme.Gutter)
-	theme.PreviewFg = o(theme.Fg, theme.PreviewFg)
-	theme.PreviewBg = o(theme.Bg, theme.PreviewBg)
-	theme.PreviewLabel = o(theme.BorderLabel, theme.PreviewLabel)
-	theme.PreviewBorder = o(theme.Border, theme.PreviewBorder)
-	theme.Separator = o(theme.Border, theme.Separator)
-	theme.Scrollbar = o(theme.Border, theme.Scrollbar)
-	theme.PreviewScrollbar = o(theme.PreviewBorder, theme.PreviewScrollbar)

 	initPalette(theme)
 }
@@ -761,12 +619,7 @@ func initPalette(theme *ColorTheme) {
 	ColSpinner = pair(theme.Spinner, theme.Bg)
 	ColInfo = pair(theme.Info, theme.Bg)
 	ColHeader = pair(theme.Header, theme.Bg)
-	ColSeparator = pair(theme.Separator, theme.Bg)
-	ColScrollbar = pair(theme.Scrollbar, theme.Bg)
 	ColBorder = pair(theme.Border, theme.Bg)
-	ColBorderLabel = pair(theme.BorderLabel, theme.Bg)
-	ColPreviewLabel = pair(theme.PreviewLabel, theme.PreviewBg)
 	ColPreview = pair(theme.PreviewFg, theme.PreviewBg)
-	ColPreviewBorder = pair(theme.PreviewBorder, theme.PreviewBg)
-	ColPreviewScrollbar = pair(theme.PreviewScrollbar, theme.PreviewBg)
+	ColPreviewBorder = pair(theme.Border, theme.PreviewBg)
 }
--- 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
@@ -11,11 +11,6 @@ import (
 	"github.com/rivo/uniseg"
 )

-// StringWidth returns string width where each CR/LF character takes 1 column
-func StringWidth(s string) int {
-	return runewidth.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
 		}
@@ -157,23 +153,3 @@ func Once(nextResponse bool) func() bool {
 		return prevState
 	}
 }
-
-// RepeatToFill repeats the given string to fill the given width
-func RepeatToFill(str string, length int, limit int) string {
-	times := limit / length
-	rest := limit % length
-	output := strings.Repeat(str, times)
-	if rest > 0 {
-		for _, r := range str {
-			rest -= runewidth.RuneWidth(r)
-			if rest < 0 {
-				break
-			}
-			output += string(r)
-			if rest == 0 {
-				break
-			}
-		}
-	}
-	return output
-}
--- 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,55 +21,6 @@ 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() {
@@ -175,12 +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])
-	}
-}
--- a/src/util/util_unix.go
+++ b/src/util/util_unix.go
@@ -6,8 +6,6 @@ import (
 	"os"
 	"os/exec"
 	"syscall"
-
-	"golang.org/x/sys/unix"
 )

 // ExecCommand executes the given command with $SHELL
@@ -47,7 +45,3 @@ func SetNonblock(file *os.File, nonblock bool) {
 func Read(fd int, b []byte) (int, error) {
 	return syscall.Read(int(fd), b)
 }
-
-func SetStdin(file *os.File) {
-	unix.Dup2(int(file.Fd()), 0)
-}
--- a/src/util/util_windows.go
+++ b/src/util/util_windows.go
@@ -81,7 +81,3 @@ func SetNonblock(file *os.File, nonblock bool) {
 func Read(fd int, b []byte) (int, error) {
 	return syscall.Read(syscall.Handle(fd), b)
 }
-
-func SetStdin(file *os.File) {
-	// No-op
-}
--- a/test/test_go.rb
+++ b/test/test_go.rb
--- a/typos.toml
+++ b/typos.toml
@@ -1,6 +0,0 @@
-# See https://github.com/crate-ci/typos/blob/master/docs/reference.md to configure typos
-[default.extend-words]
-ba = "ba"
-fo = "fo"
-enew = "enew"
-tabe = "tabe"