.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE.md

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

.github/ISSUE_TEMPLATE/issue_template.yml

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

.github/dependabot.yml

@@ -4,7 +4,3 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-        interval: "weekly"

.github/workflows/codeql-analysis.yml

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

.github/workflows/depsreview.yaml

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

.github/workflows/linux.yml

@@ -8,35 +8,32 @@ on:
     branches: [ master ]
   workflow_dispatch:
 
-permissions:
-  contents: read
-
-env:
-  LANG: C.UTF-8
-
 jobs:
   build:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go: [1.14, 1.16]
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
       with:
         fetch-depth: 0
 
     - name: Set up Go
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v2
       with:
-        go-version: "1.20"
+        go-version: ${{ matrix.go }}
 
     - name: Setup Ruby
-      uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@v1.62.0
       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
@@ -45,7 +42,4 @@ jobs:
       run: make test
 
     - name: Integration test
-      run: make install && ./install --all && tmux new-session -d && ruby test/test_go.rb --verbose
-
-    - name: Integration test (tcell)
-      run: TAGS=tcell make clean install && ruby test/test_go.rb --verbose
+      run: make install && ./install --all && LC_ALL=C tmux new-session -d && ruby test/test_go.rb --verbose

.github/workflows/macos.yml

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

.github/workflows/sponsors.yml

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

.github/workflows/typos.yml

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

.github/workflows/winget.yml

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

.goreleaser.yml

@@ -12,16 +12,18 @@ builds:
       - darwin
     goarch:
       - amd64
-    flags:
-      - -trimpath
     ldflags:
       - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
     hooks:
       post: |
         sh -c '
         cat > /tmp/fzf-gon-amd64.hcl << EOF
-        source = ["./dist/fzf-macos_darwin_amd64_v1/fzf"]
-        bundle_id = "junegunn.fzf"
+        source = ["./dist/fzf-macos_darwin_amd64/fzf"]
+        bundle_id = "kr.junegunn.fzf"
+        apple_id {
+          username = "junegunn.c@gmail.com"
+          password = "@env:AC_PASSWORD"
+        }
         sign {
           application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
         }
@@ -38,8 +40,6 @@ builds:
       - darwin
     goarch:
       - arm64
-    flags:
-      - -trimpath
     ldflags:
       - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
     hooks:
@@ -47,7 +47,11 @@ builds:
         sh -c '
         cat > /tmp/fzf-gon-arm64.hcl << EOF
         source = ["./dist/fzf-macos-arm_darwin_arm64/fzf"]
-        bundle_id = "junegunn.fzf"
+        bundle_id = "kr.junegunn.fzf"
+        apple_id {
+          username = "junegunn.c@gmail.com"
+          password = "@env:AC_PASSWORD"
+        }
         sign {
           application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
         }
@@ -68,15 +72,10 @@ builds:
       - amd64
       - arm
       - arm64
-      - loong64
-      - ppc64le
-      - s390x
     goarm:
       - 5
       - 6
       - 7
-    flags:
-      - -trimpath
     ldflags:
       - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
     ignore:
@@ -100,10 +99,6 @@ archives:
     files:
       - non-existent*
 
-checksum:
-  extra_files:
-    - glob: ./dist/fzf-*darwin*.zip
-
 release:
   github:
     owner: junegunn

.rubocop.yml

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

.tool-versions

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

ADVANCED.md

@@ -1,36 +1,29 @@
 Advanced fzf examples
 ======================
 
-* *Last update: 2024/01/20*
-* *Requires fzf 0.46.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)
-    * [Toggling with a single key binding](#toggling-with-a-single-key-binding)
+  * [Updating the list of processes by pressing CTRL-R](#updating-the-list-of-processes-by-pressing-ctrl-r)
+  * [Toggling between data sources](#toggling-between-data-sources)
 * [Ripgrep integration](#ripgrep-integration)
-    * [Using fzf as the secondary filter](#using-fzf-as-the-secondary-filter)
-    * [Using fzf as interactive Ripgrep launcher](#using-fzf-as-interactive-ripgrep-launcher)
-    * [Switching to fzf-only search mode](#switching-to-fzf-only-search-mode)
-    * [Switching between Ripgrep mode and fzf mode](#switching-between-ripgrep-mode-and-fzf-mode)
-    * [Switching between Ripgrep mode and fzf mode using a single key binding](#switching-between-ripgrep-mode-and-fzf-mode-using-a-single-key-binding)
+  * [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)
 * [Log tailing](#log-tailing)
 * [Key bindings for git objects](#key-bindings-for-git-objects)
-    * [Files listed in `git status`](#files-listed-in-git-status)
-    * [Branches](#branches)
-    * [Commit hashes](#commit-hashes)
+  * [Files listed in `git status`](#files-listed-in-git-status)
+  * [Branches](#branches)
+  * [Commit hashes](#commit-hashes)
 * [Color themes](#color-themes)
-    * [fzf Theme Playground](#fzf-theme-playground)
-    * [Generating fzf color theme from Vim color schemes](#generating-fzf-color-theme-from-vim-color-schemes)
+  * [Generating fzf color theme from Vim color schemes](#generating-fzf-color-theme-from-vim-color-schemes)
 
 <!-- vim-markdown-toc -->
 
@@ -211,30 +204,6 @@ find * | fzf --prompt 'All> ' \
 
 ![image](https://user-images.githubusercontent.com/700826/113465072-46321c00-946c-11eb-9b6f-cda3951df579.png)
 
-### Toggling with a single key binding
-
-The above example uses two different key bindings to toggle between two modes,
-but can we just use a single key binding?
-
-To make a key binding behave differently each time it is pressed, we need:
-
-1. a way to store the current state. i.e. "which mode are we in?"
-2. and a way to dynamically perform different actions depending on the state.
-
-The following example shows how to 1. store the current mode in the prompt
-string, 2. and use this information (`$FZF_PROMPT`) to determine which
-actions to perform using the `transform` action.
-
-```sh
-fd --type file |
-  fzf --prompt 'Files> ' \
-      --header 'CTRL-T: Switch between Files/Directories' \
-      --bind 'ctrl-t:transform:[[ ! $FZF_PROMPT =~ Files ]] &&
-              echo "change-prompt(Files> )+reload(fd --type file)" ||
-              echo "change-prompt(Directories> )+reload(fd --type directory)"' \
-      --preview '[[ $FZF_PROMPT =~ Files ]] && bat --color=always {} || tree -C {}'
-```
-
 Ripgrep integration
 -------------------
 
@@ -266,13 +235,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.
@@ -335,14 +306,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
@@ -363,22 +330,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
@@ -387,6 +357,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.
@@ -402,16 +374,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
@@ -430,80 +405,6 @@ INITIAL_QUERY="${*:-}"
 - We reverted `--color` option for customizing how the matching chunks are
   displayed in the second phase
 
-### Switching between Ripgrep mode and fzf mode
-
-[fzf 0.30.0][0.30.0] added `rebind` action so we can "rebind" the bindings
-that were previously "unbound" via `unbind`.
-
-This is an improved version of the previous example that allows us to switch
-between Ripgrep launcher mode and fzf-only filtering mode via CTRL-R and
-CTRL-F.
-
-```sh
-#!/usr/bin/env bash
-
-# Switch between Ripgrep launcher mode (CTRL-R) and fzf filtering mode (CTRL-F)
-rm -f /tmp/rg-fzf-{r,f}
-RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
-INITIAL_QUERY="${*:-}"
-: | fzf --ansi --disabled --query "$INITIAL_QUERY" \
-    --bind "start:reload($RG_PREFIX {q})+unbind(ctrl-r)" \
-    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
-    --bind "ctrl-f:unbind(change,ctrl-f)+change-prompt(2. fzf> )+enable-search+rebind(ctrl-r)+transform-query(echo {q} > /tmp/rg-fzf-r; cat /tmp/rg-fzf-f)" \
-    --bind "ctrl-r:unbind(ctrl-r)+change-prompt(1. ripgrep> )+disable-search+reload($RG_PREFIX {q} || true)+rebind(change,ctrl-f)+transform-query(echo {q} > /tmp/rg-fzf-f; cat /tmp/rg-fzf-r)" \
-    --color "hl:-1:underline,hl+:-1:underline:reverse" \
-    --prompt '1. ripgrep> ' \
-    --delimiter : \
-    --header '╱ CTRL-R (ripgrep mode) ╱ CTRL-F (fzf mode) ╱' \
-    --preview 'bat --color=always {1} --highlight-line {2}' \
-    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
-    --bind 'enter:become(vim {1} +{2})'
-```
-
-- To restore the query string when switching between modes, we store the
-  current query in `/tmp/rg-fzf-{r,f}` files and restore the query using
-  `transform-query` action which was added in [fzf 0.36.0][0.36.0].
-- Also note that we unbind `ctrl-r` binding on `start` event which is
-  triggered once when fzf starts.
-
-[0.30.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0300
-[0.36.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0360
-
-### Switching between Ripgrep mode and fzf mode using a single key binding
-
-In contrast to the previous version, we use just one hotkey to toggle between
-ripgrep and fzf mode. This is achieved by using the `$FZF_PROMPT` as a state
-within the `transform` action, a feature introduced in [fzf 0.45.0][0.45.0]. A
-more detailed explanation of this feature can be found in a previous section -
-[Toggling with a single keybinding](#toggling-with-a-single-key-binding).
-
-[0.45.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0450
-
-When using the `transform` action, the placeholder (`\{q}`) should be escaped to
-prevent immediate evaluation.
-
-```sh
-#!/usr/bin/env bash
-
-# Switch between Ripgrep mode and fzf filtering mode (CTRL-T)
-rm -f /tmp/rg-fzf-{r,f}
-RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
-INITIAL_QUERY="${*:-}"
-: | fzf --ansi --disabled --query "$INITIAL_QUERY" \
-    --bind "start:reload:$RG_PREFIX {q}" \
-    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
-    --bind 'ctrl-t:transform:[[ ! $FZF_PROMPT =~ ripgrep ]] &&
-      echo "rebind(change)+change-prompt(1. ripgrep> )+disable-search+transform-query:echo \{q} > /tmp/rg-fzf-f; cat /tmp/rg-fzf-r" ||
-      echo "unbind(change)+change-prompt(2. fzf> )+enable-search+transform-query:echo \{q} > /tmp/rg-fzf-r; cat /tmp/rg-fzf-f"' \
-    --color "hl:-1:underline,hl+:-1:underline:reverse" \
-    --prompt '1. ripgrep> ' \
-    --delimiter : \
-    --header 'CTRL-T: Switch between ripgrep/fzf' \
-    --preview 'bat --color=always {1} --highlight-line {2}' \
-    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
-    --bind 'enter:become(vim {1} +{2})'
-```
-
 Log tailing
 -----------
 
@@ -529,17 +430,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}' "$@"
 }
 ```
 
@@ -552,7 +452,7 @@ pods() {
     - Press enter key on a pod to `kubectl exec` into it
     - Press CTRL-O to open the log in your editor
 - Press CTRL-R to reload the pod list
-- Press CTRL-/ repeatedly to rotate through a different sets of preview
+- Press CTRL-/ repeatedly to to rotate through a different sets of preview
   window options
     1. `80%,border-bottom`
     1. `hidden`
@@ -561,17 +461,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`
 
@@ -591,6 +483,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
 ------------
 
@@ -633,12 +528,6 @@ export FZF_DEFAULT_OPTS='--color=bg+:#293739,bg:#1B1D1E,border:#808080,spinner:#
 
 ![molokai](https://user-images.githubusercontent.com/700826/113475085-8619f300-94ae-11eb-85e4-2766fc3246bf.png)
 
-### fzf Theme Playground
-
-[fzf Theme Playground](https://vitormv.github.io/fzf-themes/) created by
-[Vitor Mello](https://github.com/vitormv) is a webpage where you can
-interactively create fzf themes.
-
 ### Generating fzf color theme from Vim color schemes
 
 The Vim plugin of fzf can generate `--color` option from the current color

BUILD.md

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

CHANGELOG.md

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

Dockerfile

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

LICENSE

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

Makefile

@@ -1,10 +1,10 @@
 SHELL          := bash
 GO             ?= go
-GOOS           ?= $(shell $(GO) env GOOS)
+GOOS           ?= $(word 1, $(subst /, " ", $(word 4, $(shell go version))))
 
 MAKEFILE       := $(realpath $(lastword $(MAKEFILE_LIST)))
 ROOT_DIR       := $(shell dirname $(MAKEFILE))
-SOURCES        := $(wildcard *.go src/*.go src/*/*.go shell/*sh) $(MAKEFILE)
+SOURCES        := $(wildcard *.go src/*.go src/*/*.go) $(MAKEFILE)
 
 ifdef FZF_VERSION
 VERSION        := $(FZF_VERSION)
@@ -20,23 +20,21 @@ VERSION_REGEX  := $(subst .,\.,$(VERSION_TRIM))
 ifdef FZF_REVISION
 REVISION       := $(FZF_REVISION)
 else
-REVISION       := $(shell git log -n 1 --pretty=format:%h --abbrev=8 -- $(SOURCES) 2> /dev/null)
+REVISION       := $(shell git log -n 1 --pretty=format:%h -- $(SOURCES) 2> /dev/null)
 endif
 ifeq ($(REVISION),)
 $(error Not on git repository; cannot determine $$FZF_REVISION)
 endif
-BUILD_FLAGS    := -a -ldflags "-s -w -X main.version=$(VERSION) -X main.revision=$(REVISION)" -tags "$(TAGS)" -trimpath
+BUILD_FLAGS    := -a -ldflags "-s -w -X main.version=$(VERSION) -X main.revision=$(REVISION)" -tags "$(TAGS)"
 
 BINARY32       := fzf-$(GOOS)_386
 BINARY64       := fzf-$(GOOS)_amd64
-BINARYS390     := fzf-$(GOOS)_s390x
 BINARYARM5     := fzf-$(GOOS)_arm5
 BINARYARM6     := fzf-$(GOOS)_arm6
 BINARYARM7     := fzf-$(GOOS)_arm7
 BINARYARM8     := fzf-$(GOOS)_arm8
 BINARYPPC64LE  := fzf-$(GOOS)_ppc64le
 BINARYRISCV64  := fzf-$(GOOS)_riscv64
-BINARYLOONG64  := fzf-$(GOOS)_loong64
 
 # https://en.wikipedia.org/wiki/Uname
 UNAME_M := $(shell uname -m)
@@ -44,8 +42,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)
@@ -57,9 +53,7 @@ else ifeq ($(UNAME_M),armv6l)
 else ifeq ($(UNAME_M),armv7l)
 	BINARY := $(BINARYARM7)
 else ifeq ($(UNAME_M),armv8l)
-	# armv8l is always 32-bit and should implement the armv7 ISA, so
-	# just use the same filename as for armv7.
-	BINARY := $(BINARYARM7)
+	BINARY := $(BINARYARM8)
 else ifeq ($(UNAME_M),arm64)
 	BINARY := $(BINARYARM8)
 else ifeq ($(UNAME_M),aarch64)
@@ -68,8 +62,6 @@ else ifeq ($(UNAME_M),ppc64le)
 	BINARY := $(BINARYPPC64LE)
 else ifeq ($(UNAME_M),riscv64)
 	BINARY := $(BINARYRISCV64)
-else ifeq ($(UNAME_M),loongarch64)
-	BINARY := $(BINARYLOONG64)
 else
 $(error Build on $(UNAME_M) is not supported, yet.)
 endif
@@ -89,17 +81,10 @@ bench:
 
 install: bin/fzf
 
-generate:
-	PATH=$(PATH):$(GOPATH)/bin $(GO) generate ./...
-
 build:
-	goreleaser build --clean --snapshot --skip=post-hooks
+	goreleaser --rm-dist --snapshot
 
 release:
-	# Make sure that the tests pass and the build works
-	TAGS=tcell make test
-	make test build clean
-
 ifndef GITHUB_TOKEN
 	$(error GITHUB_TOKEN is not defined)
 endif
@@ -126,7 +111,7 @@ endif
 	git push origin temp --follow-tags --force
 
 	# Make a GitHub release
-	goreleaser --clean --release-notes tmp/release-note
+	goreleaser --rm-dist --release-notes tmp/release-note
 
 	# Push to master
 	git checkout master
@@ -144,8 +129,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 $@
@@ -165,23 +148,19 @@ target/$(BINARYPPC64LE): $(SOURCES)
 target/$(BINARYRISCV64): $(SOURCES)
 	GOARCH=riscv64 $(GO) build $(BUILD_FLAGS) -o $@
 
-target/$(BINARYLOONG64): $(SOURCES)
-	GOARCH=loong64 $(GO) build $(BUILD_FLAGS) -o $@
-
 bin/fzf: target/$(BINARY) | bin
-	-rm -f bin/fzf
 	cp -f target/$(BINARY) bin/fzf
 
 docker:
-	docker build -t fzf-ubuntu .
-	docker run -it fzf-ubuntu tmux
+	docker build -t fzf-arch .
+	docker run -it fzf-arch tmux
 
 docker-test:
-	docker build -t fzf-ubuntu .
-	docker run -it fzf-ubuntu
+	docker build -t fzf-arch .
+	docker run -it fzf-arch
 
 update:
 	$(GO) get -u
 	$(GO) mod tidy
 
-.PHONY: all generate build release test bench install clean docker docker-test update
+.PHONY: all build release test bench install clean docker docker-test update

README-VIM.md

@@ -12,10 +12,7 @@ differ depending on the package manager.
 " If installed using Homebrew
 set rtp+=/usr/local/opt/fzf
 
-" If installed using Homebrew on Apple Silicon
-set rtp+=/opt/homebrew/opt/fzf
-
-" If you have cloned fzf on ~/.fzf directory
+" If installed using git
 set rtp+=~/.fzf
 ```
 
@@ -26,10 +23,7 @@ written as:
 " If installed using Homebrew
 Plug '/usr/local/opt/fzf'
 
-" If installed using Homebrew on Apple Silicon
-Plug '/opt/homebrew/opt/fzf'
-
-" If you have cloned fzf on ~/.fzf directory
+" If installed using git
 Plug '~/.fzf'
 ```
 
@@ -121,7 +115,7 @@ let g:fzf_action = {
 
 " An action can be a reference to a function that processes selected lines
 function! s:build_quickfix_list(lines)
-  call setqflist(map(copy(a:lines), '{ "filename": v:val, "lnum": 1 }'))
+  call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
   copen
   cc
 endfunction
@@ -238,20 +232,19 @@ call fzf#run({'sink': 'e'})
 ```
 
 We haven't specified the `source`, so this is equivalent to starting fzf on
-command line without standard input pipe; fzf will traverse the file system
-under the current directory to get the list of files. (If
-`$FZF_DEFAULT_COMMAND` is set, fzf will use the output of the command
-instead.) When you select one, it will open it with the sink, `:e` command. If
-you want to open it in a new tab, you can pass `:tabedit` command instead as
-the sink.
+command line without standard input pipe; fzf will use find command (or
+`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
+directory. When you select one, it will open it with the sink, `:e` command.
+If you want to open it in a new tab, you can pass `:tabedit` command instead
+as the sink.
 
 ```vim
 call fzf#run({'sink': 'tabedit'})
 ```
 
-You can use any shell command as the source to generate the list. The
-following example will list the files managed by git. It's equivalent to
-running `git ls-files | fzf` on shell.
+Instead of using the default find command, you can use any shell command as
+the source. The following example will list the files managed by git. It's
+equivalent to running `git ls-files | fzf` on shell.
 
 ```vim
 call fzf#run({'source': 'git ls-files', 'sink': 'e'})
@@ -316,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`
@@ -490,4 +483,4 @@ autocmd  FileType fzf set laststatus=0 noshowmode noruler
 
 The MIT License (MIT)
 
-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi

bin/fzf-preview.sh

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

bin/fzf-tmux

@@ -7,9 +7,10 @@ fail() {
   exit 2
 }
 
-fzf="$(command which fzf)" || fzf="$(dirname "$0")/fzf"
+fzf="$(command -v fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
 [[ -x "$fzf" ]] || fail 'fzf executable not found'
 
+tmux_args=()
 args=()
 opt=""
 skip=""
@@ -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
@@ -95,9 +96,9 @@ while [[ $# -gt 0 ]]; do
       elif [[ "$size" =~ %$ ]]; then
         size=${size:0:((${#size}-1))}
         if [[ -n "$swap" ]]; then
-          opt="$opt -l $(( 100 - size ))%"
+          opt="$opt -p $(( 100 - size ))"
         else
-          opt="$opt -l $size%"
+          opt="$opt -p $size"
         fi
       else
         if [[ -n "$swap" ]]; then
@@ -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'")
@@ -151,18 +154,12 @@ argsf="${TMPDIR:-/tmp}/fzf-args-$id"
 fifo1="${TMPDIR:-/tmp}/fzf-fifo1-$id"
 fifo2="${TMPDIR:-/tmp}/fzf-fifo2-$id"
 fifo3="${TMPDIR:-/tmp}/fzf-fifo3-$id"
-if tmux_win_opts=$(tmux show-options -p remain-on-exit \; show-options -p synchronize-panes 2> /dev/null); then
-  tmux_win_opts=( $(sed '/ off/d; s/synchronize-panes/set-option -p synchronize-panes/; s/remain-on-exit/set-option -p remain-on-exit/; s/$/ \\;/' <<< "$tmux_win_opts") )
-  tmux_off_opts='; set-option -p synchronize-panes off ; set-option -p remain-on-exit off'
-else
-  tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
-  tmux_off_opts='; set-window-option synchronize-panes off ; set-window-option remain-on-exit off'
-fi
+tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
 cleanup() {
   \rm -f $argsf $fifo1 $fifo2 $fifo3
 
   # Restore tmux window options
-  if [[ "${#tmux_win_opts[@]}" -gt 1 ]]; then
+  if [[ "${#tmux_win_opts[@]}" -gt 0 ]]; then
     eval "tmux ${tmux_win_opts[*]}"
   fi
 
@@ -184,23 +181,9 @@ 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
-envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
-envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
-envs="$envs FZF_DEFAULT_OPTS_FILE=$(printf %q "$FZF_DEFAULT_OPTS_FILE")"
-[[ -n "$RUNEWIDTH_EASTASIAN" ]] && envs="$envs RUNEWIDTH_EASTASIAN=$(printf %q "$RUNEWIDTH_EASTASIAN")"
-[[ -n "$BAT_THEME" ]] && envs="$envs BAT_THEME=$(printf %q "$BAT_THEME")"
+[[ "$opt" =~ "-K -E" ]] && FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
+[[ -n "$FZF_DEFAULT_OPTS"    ]] && envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
+[[ -n "$FZF_DEFAULT_COMMAND" ]] && envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
 echo "$envs;" > "$argsf"
 
 # Build arguments to fzf
@@ -212,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
@@ -222,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
 
@@ -234,9 +225,9 @@ else
   cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" >> $argsf
   cat <&0 > $fifo1 &
 fi
-tmux \
-  split-window -c "$PWD" $opt "bash -c 'exec -a fzf bash $argsf'" $swap \
-  $tmux_off_opts \
+tmux set-window-option synchronize-panes off \;\
+  set-window-option remain-on-exit off \;\
+  split-window -c "$PWD" $opt "${tmux_args[@]}" "bash -c 'exec -a fzf bash $argsf'" $swap \
   > /dev/null 2>&1 || { "$fzf" "${args[@]}"; exit $?; }
 cat $fifo2
 exit "$(cat $fifo3)"

doc/fzf.txt

@@ -1,4 +1,4 @@
-fzf.txt	fzf	Last change: February 15 2024
+fzf.txt	fzf	Last change: May 19 2021
 FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
 ==============================================================================
 
@@ -32,10 +32,7 @@ depending on the package manager.
     " If installed using Homebrew
     set rtp+=/usr/local/opt/fzf
 
-    " If installed using Homebrew on Apple Silicon
-    set rtp+=/opt/homebrew/opt/fzf
-
-    " If you have cloned fzf on ~/.fzf directory
+    " If installed using git
     set rtp+=~/.fzf
 <
 If you use {vim-plug}{1}, the same can be written as:
@@ -43,10 +40,7 @@ If you use {vim-plug}{1}, the same can be written as:
     " If installed using Homebrew
     Plug '/usr/local/opt/fzf'
 
-    " If installed using Homebrew on Apple Silicon
-    Plug '/opt/homebrew/opt/fzf'
-
-    " If you have cloned fzf on ~/.fzf directory
+    " If installed using git
     Plug '~/.fzf'
 <
 But if you want the latest Vim plugin file from GitHub rather than the one
@@ -74,16 +68,16 @@ SUMMARY                                                            *fzf-summary*
 The Vim plugin of fzf provides two core functions, and `:FZF` command which is
 the basic file selector command built on top of them.
 
- 1. `fzf#run([spec dict])`
+ 1. `fzf#run([spec dict])`
    - Starts fzf inside Vim with the given spec
-   - `:call fzf#run({'source': 'ls'})`
- 2. `fzf#wrap([spec dict]) -> (dict)`
+   - `:call fzf#run({'source': 'ls'})`
+ 2. `fzf#wrap([spec dict]) -> (dict)`
    - Takes a spec for `fzf#run` and returns an extended version of it with
      additional options for addressing global preferences (`g:fzf_xxx`)
-     - `:echo fzf#wrap({'source': 'ls'})`
+     - `:echo fzf#wrap({'source': 'ls'})`
    - We usually wrap a spec with `fzf#wrap` before passing it to `fzf#run`
-     - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
- 3. `:FZF [fzf_options string] [path string]`
+     - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
+ 3. `:FZF [fzf_options string] [path string]`
    - Basic fuzzy file selector
    - A reference implementation for those who don't want to write VimScript to
      implement custom commands
@@ -149,7 +143,7 @@ Examples~
 
     " An action can be a reference to a function that processes selected lines
     function! s:build_quickfix_list(lines)
-      call setqflist(map(copy(a:lines), '{ "filename": v:val, "lnum": 1 }'))
+      call setqflist(map(copy(a:lines), '{ "filename": v:val }'))
       copen
       cc
     endfunction
@@ -228,12 +222,12 @@ list:
   `spinner`                    | Streaming input indicator
   `query`                      | Query string
   `disabled`                   | Query string when search is disabled
-  `prompt`                     | Prompt before query ( `> ` )
+  `prompt`                     | Prompt before query ( `> ` )
   `pointer`                    | Pointer to the current line ( `>` )
  ----------------------------+------------------------------------------------------
  - `component` specifies the component (`fg` / `bg`) from which to extract the
    color when considering each of the following highlight groups
- - `group1 [, group2, ...]` is a list of highlight groups that are searched (in
+ - `group1 [, group2, ...]` is a list of highlight groups that are searched (in
    order) for a matching color definition
 
 For example, consider the following specification:
@@ -264,18 +258,17 @@ entry.
     call fzf#run({'sink': 'e'})
 <
 We haven't specified the `source`, so this is equivalent to starting fzf on
-command line without standard input pipe; fzf will traverse the file system
-under the current directory to get the list of files. (If
-`$FZF_DEFAULT_COMMAND` is set, fzf will use the output of the command
-instead.) When you select one, it will open it with the sink, `:e` command. If
-you want to open it in a new tab, you can pass `:tabedit` command instead as
-the sink.
+command line without standard input pipe; fzf will use find command (or
+`$FZF_DEFAULT_COMMAND` if defined) to list the files under the current
+directory. When you select one, it will open it with the sink, `:e` command.
+If you want to open it in a new tab, you can pass `:tabedit` command instead
+as the sink.
 >
     call fzf#run({'sink': 'tabedit'})
 <
-You can use any shell command as the source to generate the list. The
-following example will list the files managed by git. It's equivalent to
-running `git ls-files | fzf` on shell.
+Instead of using the default find command, you can use any shell command as
+the source. The following example will list the files managed by git. It's
+equivalent to running `git ls-files | fzf` on shell.
 >
     call fzf#run({'source': 'git ls-files', 'sink': 'e'})
 <
@@ -303,7 +296,7 @@ The following table summarizes the available options.
  ---------------------------+---------------+----------------------------------------------------------------------
  Option name                | Type          | Description                                                          ~
  ---------------------------+---------------+----------------------------------------------------------------------
-  `source`                    | string        | External command to generate input to fzf (e.g.  `find .` )
+  `source`                    | string        | External command to generate input to fzf (e.g.  `find .` )
   `source`                    | list          | Vim list as input to fzf
   `sink`                      | string        | Vim command to handle the selected item (e.g.  `e` ,  `tabe` )
   `sink`                      | funcref       | Reference to function to process each selected item
@@ -312,8 +305,8 @@ The following table summarizes the available options.
   `dir`                       | string        | Working directory
   `up` / `down` / `left` / `right`  | number/string | (Layout) Window position and size (e.g.  `20` ,  `50%` )
   `tmux`                      | string        | (Layout) fzf-tmux options (e.g.  `-p90%,60%` )
-  `window`  (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g.  `vertical aboveleft 30new` )
-  `window`  (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g.  `{'width': 0.9, 'height': 0.6}` )
+  `window`  (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g.  `vertical aboveleft 30new` )
+  `window`  (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g.  `{'width': 0.9, 'height': 0.6}` )
  ---------------------------+---------------+----------------------------------------------------------------------
 
 `options` entry can be either a string or a list. For simple cases, string
@@ -332,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]`
 
 
@@ -350,7 +343,7 @@ So how can we make our custom `fzf#run` calls also respect those variables?
 Simply by "wrapping" the spec dictionary with `fzf#wrap` before passing it to
 `fzf#run`.
 
- - `fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`
+ - `fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`
    - All arguments are optional. Usually we only need to pass a spec
      dictionary.
    - `name` is for managing history files. It is ignored if `g:fzf_history_dir`
@@ -384,7 +377,7 @@ last `fullscreen` argument of `fzf#wrap` (see :help <bang>).
     command! -bang LS call fzf#run(fzf#wrap({'source': 'ls'}, <bang>0))
 <
 Our `:LS` command will be much more useful if we can pass a directory argument
-to it, so that something like `:LS /tmp` is possible.
+to it, so that something like `:LS /tmp` is possible.
 >
     command! -bang -complete=dir -nargs=? LS
         \ call fzf#run(fzf#wrap({'source': 'ls', 'dir': <q-args>}, <bang>0))
@@ -403,10 +396,10 @@ unique name to our command and pass it as the first argument to `fzf#wrap`.
 
  - `g:fzf_layout`
  - `g:fzf_action`
-   - Works only when no custom `sink` (or `sinklist`) is provided
+   - Works only when no custom `sink` (or `sink*`) is provided
      - Having custom sink usually means that each entry is not an ordinary
        file path (e.g. name of color scheme), so we can't blindly apply the
-       same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
+       same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
  - `g:fzf_colors`
  - `g:fzf_history_dir`
 
@@ -418,12 +411,24 @@ TIPS                                                                  *fzf-tips*
 < fzf inside terminal buffer >________________________________________________~
                                                     *fzf-inside-terminal-buffer*
 
+The latest versions of Vim and Neovim include builtin terminal emulator
+(`:terminal`) and fzf will start in a terminal buffer in the following cases:
+
+ - On Neovim
+ - On GVim
+ - On Terminal Vim with a non-default layout
+   - `call fzf#run({'left': '30%'})` or `let g:fzf_layout = {'left': '30%'}`
 
 On the latest versions of Vim and Neovim, fzf will start in a terminal buffer.
 If you find the default ANSI colors to be different, consider configuring the
 colors using `g:terminal_ansi_colors` in regular Vim or `g:terminal_color_x`
 in Neovim.
 
+                   *g:terminal_color_15* *g:terminal_color_14* *g:terminal_color_13*
+*g:terminal_color_12* *g:terminal_color_11* *g:terminal_color_10* *g:terminal_color_9*
+   *g:terminal_color_8* *g:terminal_color_7* *g:terminal_color_6* *g:terminal_color_5*
+   *g:terminal_color_4* *g:terminal_color_3* *g:terminal_color_2* *g:terminal_color_1*
+                                                            *g:terminal_color_0*
 >
     " Terminal colors for seoul256 color scheme
     if has('nvim')
@@ -483,7 +488,7 @@ or above) by putting fzf-tmux options in `tmux` key.
                                                            *fzf-hide-statusline*
 
 When fzf starts in a terminal buffer, the file type of the buffer is set to
-`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
+`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
 the window.
 
 For example, if you open fzf on the bottom on the screen (e.g. `{'down':
@@ -501,7 +506,7 @@ LICENSE                                                            *fzf-license*
 
 The MIT License (MIT)
 
-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi
 
 ==============================================================================
 vim:tw=78:sw=2:ts=2:ft=help:norl:nowrap:

go.mod

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

go.sum

@@ -1,57 +1,31 @@
-github.com/charlievieth/fastwalk v1.0.3 h1:eNWFaNPe5srPqQ5yyDbhAf11paeZaHWcihRhpuYFfSg=
-github.com/charlievieth/fastwalk v1.0.3/go.mod h1:JSfglY/gmL/rqsUS1NCsJTocB5n6sSl9ApAqif4CUbs=
 github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
-github.com/gdamore/tcell/v2 v2.7.4 h1:sg6/UnTM9jGpZU+oFYAsDahfchWAFW8Xx2yFinNSAYU=
-github.com/gdamore/tcell/v2 v2.7.4/go.mod h1:dSXtXTSK0VsW1biw65DZLZ2NKr7j0qP/0J7ONmsraWg=
+github.com/gdamore/tcell v1.4.0 h1:vUnHwJRvcPQa3tzi+0QI4U9JINXYJlOz9yiaiPQ2wMU=
+github.com/gdamore/tcell v1.4.0/go.mod h1:vxEiSDZdW3L+Uhjii9c3375IlDmR05bzxY404ZVSMo0=
+github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
+github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-shellwords v1.0.12 h1:M2zGm7EW6UQJvDeQxo4T51eKPurbeFbe8WtebGE2xrk=
 github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+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-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
-golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20210317153231-de623e64d2a6 h1:EC6+IGYTjPpRfv9a2b/6Puw0W+hLtAhkV1tPsXhutqs=
+golang.org/x/term v0.0.0-20210317153231-de623e64d2a6/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

install

@@ -2,7 +2,7 @@
 
 set -u
 
-version=0.52.1
+version=0.29.0
 auto_completion=
 key_bindings=
 update_config=2
@@ -115,7 +115,7 @@ link_fzf_in_path() {
 try_curl() {
   command -v curl > /dev/null &&
   if [[ $1 =~ tar.gz$ ]]; then
-    curl -fL $1 | tar --no-same-owner -xzf -
+    curl -fL $1 | tar -xzf -
   else
     local temp=${TMPDIR:-/tmp}/fzf.zip
     curl -fLo "$temp" $1 && unzip -o "$temp" && rm -f "$temp"
@@ -125,7 +125,7 @@ try_curl() {
 try_wget() {
   command -v wget > /dev/null &&
   if [[ $1 =~ tar.gz$ ]]; then
-    wget -O - $1 | tar --no-same-owner -xzf -
+    wget -O - $1 | tar -xzf -
   else
     local temp=${TMPDIR:-/tmp}/fzf.zip
     wget -O "$temp" $1 && unzip -o "$temp" && rm -f "$temp"
@@ -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"
@@ -196,12 +193,12 @@ if [ -n "$binary_error" ]; then
     echo "  - $binary_error !!!"
   fi
   if command -v go > /dev/null; then
-    echo -n "Building binary (go install github.com/junegunn/fzf) ... "
+    echo -n "Building binary (go get -u github.com/junegunn/fzf) ... "
     if [ -z "${GOPATH-}" ]; then
       export GOPATH="${TMPDIR:-/tmp}/fzf-gopath"
       mkdir -p "$GOPATH"
     fi
-    if go install -ldflags "-s -w -X main.version=$version -X main.revision=go-install" github.com/junegunn/fzf; then
+    if go get -ldflags "-s -w -X main.version=$version -X main.revision=go-get" github.com/junegunn/fzf; then
       echo "OK"
       cp "$GOPATH/bin/fzf" "$fzf_base/bin/"
     else
@@ -245,7 +242,7 @@ for shell in $shells; do
   src=${prefix_expand}.${shell}
   echo -n "Generate $src ... "
 
-  fzf_completion="source \"$fzf_base/shell/completion.${shell}\""
+  fzf_completion="[[ \$- == *i* ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
   if [ $auto_completion -eq 0 ]; then
     fzf_completion="# $fzf_completion"
   fi
@@ -259,19 +256,9 @@ for shell in $shells; do
 # Setup fzf
 # ---------
 if [[ ! "\$PATH" == *$fzf_base_esc/bin* ]]; then
-  PATH="\${PATH:+\${PATH}:}$fzf_base/bin"
+  export PATH="\${PATH:+\${PATH}:}$fzf_base/bin"
 fi
 
-EOF
-
-  if [[ $auto_completion -eq 1 ]] && [[ $key_bindings -eq 1 ]]; then
-    if [[ "$shell" = zsh ]]; then
-      echo "source <(fzf --$shell)" >> "$src"
-    else
-      echo "eval \"\$(fzf --$shell)\"" >> "$src"
-    fi
-  else
-    cat >> "$src" << EOF
 # Auto-completion
 # ---------------
 $fzf_completion
@@ -280,7 +267,6 @@ $fzf_completion
 # ------------
 $fzf_key_bindings
 EOF
-  fi
   echo "OK"
 done
 
@@ -292,6 +278,23 @@ if [[ "$shells" =~ fish ]]; then
   or set --universal fish_user_paths \$fish_user_paths "$fzf_base"/bin
 EOF
   [ $? -eq 0 ] && echo "OK" || echo "Failed"
+
+  mkdir -p "${fish_dir}/functions"
+  if [ -e "${fish_dir}/functions/fzf.fish" ]; then
+    echo -n "Remove unnecessary ${fish_dir}/functions/fzf.fish ... "
+    rm -f "${fish_dir}/functions/fzf.fish" && echo "OK" || echo "Failed"
+  fi
+
+  fish_binding="${fish_dir}/functions/fzf_key_bindings.fish"
+  if [ $key_bindings -ne 0 ]; then
+    echo -n "Symlink $fish_binding ... "
+    ln -sf "$fzf_base/shell/key-bindings.fish" \
+           "$fish_binding" && echo "OK" || echo "Failed"
+  else
+    echo -n "Removing $fish_binding ... "
+    rm -f "$fish_binding"
+    echo "OK"
+  fi
 fi
 
 append_line() {
@@ -354,23 +357,12 @@ done
 if [ $key_bindings -eq 1 ] && [[ "$shells" =~ fish ]]; then
   bind_file="${fish_dir}/functions/fish_user_key_bindings.fish"
   if [ ! -e "$bind_file" ]; then
-    mkdir -p "${fish_dir}/functions"
     create_file "$bind_file" \
       'function fish_user_key_bindings' \
-      '  fzf --fish | source' \
+      '  fzf_key_bindings' \
       'end'
   else
-    echo "Check $bind_file:"
-    lno=$(\grep -nF "fzf_key_bindings" "$bind_file" | sed 's/:.*//' | tr '\n' ' ')
-    if [[ -n $lno ]]; then
-      echo "  ** Found 'fzf_key_bindings' in line #$lno"
-      echo "  ** You have to replace the line to 'fzf --fish | source'"
-      echo
-    else
-      echo "  - Clear"
-      echo
-      append_line $update_config "fzf --fish | source" "$bind_file"
-    fi
+    append_line $update_config "fzf_key_bindings" "$bind_file"
   fi
 fi
 

install.ps1

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

main.go

@@ -1,82 +1,14 @@
 package main
 
 import (
-	_ "embed"
-	"fmt"
-	"os"
-	"strings"
-
 	fzf "github.com/junegunn/fzf/src"
 	"github.com/junegunn/fzf/src/protector"
 )
 
-var version = "0.52"
-var revision = "devel"
-
-//go:embed shell/key-bindings.bash
-var bashKeyBindings []byte
-
-//go:embed shell/completion.bash
-var bashCompletion []byte
-
-//go:embed shell/key-bindings.zsh
-var zshKeyBindings []byte
-
-//go:embed shell/completion.zsh
-var zshCompletion []byte
-
-//go:embed shell/key-bindings.fish
-var fishKeyBindings []byte
-
-func printScript(label string, content []byte) {
-	fmt.Println("### " + label + " ###")
-	fmt.Println(strings.TrimSpace(string(content)))
-	fmt.Println("### end: " + label + " ###")
-}
-
-func exit(code int, err error) {
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err.Error())
-	}
-	os.Exit(code)
-}
+var version string = "0.29"
+var revision string = "devel"
 
 func main() {
 	protector.Protect()
-
-	options, err := fzf.ParseOptions(true, os.Args[1:])
-	if err != nil {
-		exit(fzf.ExitError, err)
-		return
-	}
-	if options.Bash {
-		printScript("key-bindings.bash", bashKeyBindings)
-		printScript("completion.bash", bashCompletion)
-		return
-	}
-	if options.Zsh {
-		printScript("key-bindings.zsh", zshKeyBindings)
-		printScript("completion.zsh", zshCompletion)
-		return
-	}
-	if options.Fish {
-		printScript("key-bindings.fish", fishKeyBindings)
-		fmt.Println("fzf_key_bindings")
-		return
-	}
-	if options.Help {
-		fmt.Print(fzf.Usage)
-		return
-	}
-	if options.Version {
-		if len(revision) > 0 {
-			fmt.Printf("%s (%s)\n", version, revision)
-		} else {
-			fmt.Println(version)
-		}
-		return
-	}
-
-	code, err := fzf.Run(options)
-	exit(code, err)
+	fzf.Run(fzf.ParseOptions(), version, revision)
 }

man/man1/fzf-tmux.1

@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)
 
-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2021 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,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 2024" "fzf 0.52.1" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf-tmux 1 "Dec 2021" "fzf 0.29.0" "fzf-tmux - open fzf in tmux split pane"
 
 .SH NAME
 fzf-tmux - open fzf in tmux split pane

plugin/fzf.vim

@@ -1,4 +1,4 @@
-" Copyright (c) 2013-2024 Junegunn Choi
+" Copyright (c) 2017 Junegunn Choi
 "
 " MIT License
 "
@@ -59,9 +59,12 @@ if s:is_win
     return iconv(a:str, &encoding, 'cp'.s:codepage)
   endfunction
   function! s:wrap_cmds(cmds)
-    return map(['@echo off']
+    return map([
+      \ '@echo off',
+      \ 'setlocal enabledelayedexpansion']
     \ + (has('gui_running') ? ['set TERM= > nul'] : [])
-    \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds]),
+    \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds])
+    \ + ['endlocal'],
     \ '<SID>enc_to_cp(v:val."\r")')
   endfunction
 else
@@ -81,21 +84,11 @@ else
 endif
 
 function! s:shellesc_cmd(arg)
-  let e = '"'
-  let slashes = 0
-  for c in split(a:arg, '\zs')
-    if c ==# '\'
-      let slashes += 1
-    elseif c ==# '"'
-      let e .= repeat('\', slashes + 1)
-      let slashes = 0
-    else
-      let slashes = 0
-    endif
-    let e .= c
-  endfor
-  let e .= repeat('\', slashes) .'"'
-  return substitute(substitute(e, '[&|<>()^!"]', '^&', 'g'), '%', '%%', 'g')
+  let escaped = substitute(a:arg, '[&|<>()@^]', '^&', 'g')
+  let escaped = substitute(escaped, '%', '%%', 'g')
+  let escaped = substitute(escaped, '"', '\\^&', 'g')
+  let escaped = substitute(escaped, '\(\\\+\)\(\\^\)', '\1\1\2', 'g')
+  return '^"'.substitute(escaped, '\(\\\+\)$', '\1\1', '').'^"'
 endfunction
 
 function! fzf#shellescape(arg, ...)
@@ -103,12 +96,7 @@ function! fzf#shellescape(arg, ...)
   if shell =~# 'cmd.exe$'
     return s:shellesc_cmd(a:arg)
   endif
-  try
-    let [shell, &shell] = [&shell, shell]
-    return s:fzf_call('shellescape', a:arg)
-  finally
-    let [shell, &shell] = [&shell, shell]
-  endtry
+  return s:fzf_call('shellescape', a:arg)
 endfunction
 
 function! s:fzf_getcwd()
@@ -150,7 +138,7 @@ function! fzf#install()
     if !filereadable(script)
       throw script.' not found'
     endif
-    let script = 'powershell -ExecutionPolicy Bypass -file ' . shellescape(script)
+    let script = 'powershell -ExecutionPolicy Bypass -file ' . script
   else
     let script = s:base_dir.'/install'
     if !executable(script)
@@ -171,7 +159,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 = a:bin . ' --version --no-height'
   let output = systemlist(command)
   if v:shell_error || empty(output)
     return ''
@@ -327,7 +315,7 @@ function! s:common_sink(action, lines) abort
     " the execution (e.g. `set autochdir` or `autocmd BufEnter * lcd ...`)
     let cwd = exists('w:fzf_pushd') ? w:fzf_pushd.dir : expand('%:p:h')
     for item in a:lines
-      if item[0] != '~' && item !~ (s:is_win ? '^\([A-Z]:\)\?\' : '^/')
+      if item[0] != '~' && item !~ (s:is_win ? '^[A-Z]:\' : '^/')
         let sep = s:is_win ? '\' : '/'
         let item = join([cwd, item], cwd[len(cwd)-1] == sep ? '' : sep)
       endif
@@ -349,8 +337,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
@@ -463,30 +450,6 @@ function! s:writefile(...)
   endif
 endfunction
 
-function! s:extract_option(opts, name)
-  let opt = ''
-  let expect = 0
-  " There are a few cases where this function doesn't work as expected.
-  " Let's just assume such cases are extremely unlikely in real world.
-  "   e.g. --query --border
-  for word in split(a:opts)
-    if expect && word !~ '^"\=-'
-      let opt = opt . ' ' . word
-      let expect = 0
-    elseif word == '--no-'.a:name
-      let opt = ''
-    elseif word =~ '^--'.a:name.'='
-      let opt = word
-    elseif word =~ '^--'.a:name.'$'
-      let opt = word
-      let expect = 1
-    elseif expect
-      let expect = 0
-    endif
-  endfor
-  return opt
-endfunction
-
 function! fzf#run(...) abort
 try
   let [shell, shellslash, shellcmdflag, shellxquote] = s:use_sh()
@@ -495,7 +458,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
@@ -508,19 +471,19 @@ try
   endif
 
   if has_key(dict, 'source')
-    let source = dict.source
+    let source = remove(dict, 'source')
     let type = type(source)
     if type == 1
-      let prefix = '('.source.')|'
+      let source_command = source
     elseif type == 3
       let temps.input = s:fzf_tempname()
       call s:writefile(source, temps.input)
-      let prefix = (s:is_win ? 'type ' : 'command cat ').fzf#shellescape(temps.input).'|'
+      let source_command = (s:is_win ? 'type ' : 'cat ').fzf#shellescape(temps.input)
     else
       throw 'Invalid source type'
     endif
   else
-    let prefix = ''
+    let source_command = ''
   endif
 
   let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0) || has_key(dict, 'tmux')
@@ -542,9 +505,12 @@ try
     let height = s:calc_size(&lines, dict.down, dict)
     let optstr .= ' --height='.height
   endif
-  " Respect --border option given in $FZF_DEFAULT_OPTS and 'options'
-  let optstr = join([s:border_opt(get(dict, 'window', 0)), s:extract_option($FZF_DEFAULT_OPTS, 'border'), optstr])
-  let command = prefix.(use_tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
+  let optstr .= s:border_opt(get(dict, 'window', 0))
+  let prev_default_command = $FZF_DEFAULT_COMMAND
+  if len(source_command)
+    let $FZF_DEFAULT_COMMAND = source_command
+  endif
+  let command = (use_tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
 
   if use_term
     return s:execute_term(dict, command, temps)
@@ -555,6 +521,14 @@ try
   call s:callback(dict, lines)
   return lines
 finally
+  if exists('source_command') && len(source_command)
+    if len(prev_default_command)
+      let $FZF_DEFAULT_COMMAND = prev_default_command
+    else
+      let $FZF_DEFAULT_COMMAND = ''
+      silent! execute 'unlet $FZF_DEFAULT_COMMAND'
+    endif
+  endif
   let [&shell, &shellslash, &shellcmdflag, &shellxquote] = [shell, shellslash, shellcmdflag, shellxquote]
 endtry
 endfunction
@@ -584,8 +558,8 @@ function! s:fzf_tmux(dict)
       endif
     endfor
   endif
-  return printf('LINES=%d COLUMNS=%d %s %s %s --',
-    \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size, (has_key(a:dict, 'source') ? '' : '-'))
+  return printf('LINES=%d COLUMNS=%d %s %s - --',
+    \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size)
 endfunction
 
 function! s:splittable(dict)
@@ -711,12 +685,11 @@ function! s:execute(dict, command, use_height, temps) abort
   elseif has('win32unix') && $TERM !=# 'cygwin'
     let shellscript = s:fzf_tempname()
     call s:writefile([command], shellscript)
-    let command = 'cmd.exe //C '.fzf#shellescape('set "TERM=" & start /WAIT sh -c '.shellscript)
+    let command = 'cmd.exe /C '.fzf#shellescape('set "TERM=" & start /WAIT sh -c '.shellscript)
     let a:temps.shellscript = shellscript
   endif
   if a:use_height
-    let stdin = has_key(a:dict, 'source') ? '' : '< /dev/tty'
-    call system(printf('tput cup %d > /dev/tty; tput cnorm > /dev/tty; %s %s 2> /dev/tty', &lines, command, stdin))
+    call system(printf('tput cup %d > /dev/tty; tput cnorm > /dev/tty; %s < /dev/tty 2> /dev/tty', &lines, command))
   else
     execute 'silent !'.command
   endif
@@ -759,7 +732,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
@@ -776,9 +749,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 ''
@@ -786,7 +759,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)
@@ -848,17 +821,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('')
@@ -928,7 +890,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)}
@@ -940,8 +901,7 @@ function! s:execute_term(dict, command, temps) abort
       else
         let term_opts.curwin = 1
       endif
-      call s:handle_ambidouble(term_opts)
-      keepjumps let fzf.buf = term_start([&shell, &shellcmdflag, command], term_opts)
+      let fzf.buf = term_start([&shell, &shellcmdflag, command], term_opts)
       if is_popup && exists('#TerminalWinOpen')
         doautocmd <nomodeline> TerminalWinOpen
       endif
@@ -1007,16 +967,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,
@@ -1051,7 +1011,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

shell/completion.bash

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

shell/completion.zsh

@@ -4,13 +4,10 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ completion.zsh
 #
-# - $FZF_TMUX                 (default: 0)
-# - $FZF_TMUX_OPTS            (default: empty)
-# - $FZF_COMPLETION_TRIGGER   (default: '**')
-# - $FZF_COMPLETION_OPTS      (default: empty)
-# - $FZF_COMPLETION_PATH_OPTS (default: empty)
-# - $FZF_COMPLETION_DIR_OPTS  (default: empty)
-
+# - $FZF_TMUX               (default: 0)
+# - $FZF_TMUX_OPTS          (default: '-d 40%')
+# - $FZF_COMPLETION_TRIGGER (default: '**')
+# - $FZF_COMPLETION_OPTS    (default: empty)
 
 # Both branches of the following `if` do the same thing -- define
 # __fzf_completion_options such that `eval $__fzf_completion_options` sets
@@ -70,46 +67,41 @@ fi
 # control. There are several others that could wreck havoc if they are set
 # to values we don't expect. With the following `emulate` command we
 # sidestep this issue entirely.
-'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' 'no_aliases'
+'emulate' 'zsh' '-o' 'no_aliases'
 
 # This brace is the start of try-always block. The `always` part is like
 # `finally` in lesser languages. We use it to *always* restore user options.
 {
-# The 'emulate' command should not be placed inside the interactive if check;
-# placing it there fails to disable alias expansion. See #3731.
-if [[ -o interactive ]]; then
+
+# Bail out if not interactive shell.
+[[ -o interactive ]] || return 0
 
 # To use custom commands instead of find, override _fzf_compgen_{path,dir}
-#
-#   _fzf_compgen_path() {
-#     echo "$1"
-#     command find -L "$1" \
-#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
-#       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
-#   }
-#
-#   _fzf_compgen_dir() {
-#     command find -L "$1" \
-#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
-#       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
-#   }
+if ! declare -f _fzf_compgen_path > /dev/null; then
+  _fzf_compgen_path() {
+    echo "$1"
+    command find -L "$1" \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
+
+if ! declare -f _fzf_compgen_dir > /dev/null; then
+  _fzf_compgen_dir() {
+    command find -L "$1" \
+      -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
 
 ###########################################################
 
-__fzf_defaults() {
-  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
-  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
-  echo "${FZF_DEFAULT_OPTS-} $2"
-}
-
 __fzf_comprun() {
   if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
     _fzf_comprun "$@"
-  elif [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; }; then
+  elif [ -n "$TMUX_PANE" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "$FZF_TMUX_OPTS" ]; }; then
     shift
-    if [ -n "${FZF_TMUX_OPTS-}" ]; then
+    if [ -n "$FZF_TMUX_OPTS" ]; then
       fzf-tmux ${(Q)${(Z+n+)FZF_TMUX_OPTS}} -- "$@"
     else
       fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%} -- "$@"
@@ -145,10 +137,7 @@ __fzf_generic_path_completion() {
   tail=$6
 
   setopt localoptions nonomatch
-  if [[ $base = *'$('* ]] || [[ $base = *'<('* ]] || [[ $base = *'>('* ]] || [[ $base = *':='* ]] || [[ $base = *'`'* ]]; then
-    return
-  fi
-  eval "base=$base" 2> /dev/null || return
+  eval "base=$base"
   [[ $base = *"/"* ]] && dir="$base"
   while [ 1 ]; do
     if [[ -z "$dir" || -d ${dir} ]]; then
@@ -156,25 +145,9 @@ __fzf_generic_path_completion() {
       leftover=${leftover/#\/}
       [ -z "$dir" ] && dir='.'
       [ "$dir" != "/" ] && dir="${dir/%\//}"
-      matches=$(
-        export FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --scheme=path" "${FZF_COMPLETION_OPTS-}")
-        unset FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS_FILE
-        if declare -f "$compgen" > /dev/null; then
-          eval "$compgen $(printf %q "$dir")" | __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover"
-        else
-          if [[ $compgen =~ dir ]]; then
-            walker=dir,follow
-            rest=${FZF_COMPLETION_DIR_OPTS-}
-          else
-            walker=file,dir,follow,hidden
-            rest=${FZF_COMPLETION_PATH_OPTS-}
-          fi
-          __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" --walker "$walker" --walker-root="$dir" ${(Q)${(Z+n+)rest}} < /dev/tty
-        fi | while read item; do
-          item="${item%$suffix}$suffix"
-          echo -n "${(q)item} "
-        done
-      )
+      matches=$(eval "$compgen $(printf %q "$dir")" | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS" __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" | while read item; do
+        echo -n "${(q)item}$suffix "
+      done)
       matches=${matches% }
       if [ -n "$matches" ]; then
         LBUFFER="$lbuf$matches$tail"
@@ -210,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
@@ -234,47 +207,28 @@ _fzf_complete() {
   type $post > /dev/null 2>&1 || post=cat
 
   _fzf_feed_fifo "$fifo"
-  matches=$(
-    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse" "${FZF_COMPLETION_OPTS-} $str_arg") \
-    FZF_DEFAULT_OPTS_FILE='' \
-      __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
+  matches=$(FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-40%} --reverse --bind=ctrl-z:ignore $FZF_DEFAULT_OPTS $FZF_COMPLETION_OPTS $str_arg" __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
   if [ -n "$matches" ]; then
     LBUFFER="$lbuf$matches"
   fi
   command rm -f "$fifo"
 }
 
-# To use custom hostname lists, override __fzf_list_hosts.
-# The function is expected to print hostnames, one per line as well as in the
-# desired sorting and with any duplicates removed, to standard output.
-if ! declare -f __fzf_list_hosts > /dev/null; then
-  __fzf_list_hosts() {
-    setopt localoptions nonomatch
-    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
-      <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts 2> /dev/null | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
-      <(command grep -v '^\s*\(#\|$\)' /etc/hosts 2> /dev/null | command grep -Fv '0.0.0.0' | command sed 's/#.*//') |
-      awk '{for (i = 2; i <= NF; i++) print $i}' | sort -u
-  }
-fi
-
 _fzf_complete_telnet() {
-  _fzf_complete +m -- "$@" < <(__fzf_list_hosts)
+  _fzf_complete +m -- "$@" < <(
+    command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0' |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }
 
-# The first and the only argument is the LBUFFER without the current word that contains the trigger.
-# The current word without the trigger is in the $prefix variable passed from the caller.
 _fzf_complete_ssh() {
-  local tokens=(${(z)1})
-  case ${tokens[-1]} in
-    -i|-F|-E)
-      _fzf_path_completion "$prefix" "$1"
-      ;;
-    *)
-      local user=
-      [[ $prefix =~ @ ]] && user="${prefix%%@*}@"
-      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | awk -v user="$user" '{print user $0}')
-      ;;
-  esac
+  _fzf_complete +m -- "$@" < <(
+    setopt localoptions nonomatch
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?]') \
+        <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
+        <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }
 
 _fzf_complete_export() {
@@ -296,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
   )
 }
 
@@ -325,22 +278,25 @@ fzf-completion() {
   [ -z "$trigger" -a ${LBUFFER[-1]} = ' ' ] && tokens+=("")
 
   # When the trigger starts with ';', it becomes a separate token
-  if [[ ${LBUFFER} = *"${tokens[-2]-}${tokens[-1]}" ]]; then
-    tokens[-2]="${tokens[-2]-}${tokens[-1]}"
+  if [[ ${LBUFFER} = *"${tokens[-2]}${tokens[-1]}" ]]; then
+    tokens[-2]="${tokens[-2]}${tokens[-1]}"
     tokens=(${tokens[0,-2]})
   fi
 
   lbuf=$LBUFFER
   tail=${LBUFFER:$(( ${#LBUFFER} - ${#trigger} ))}
+  # Kill completion (do not require trigger sequence)
+  if [ "$cmd" = kill -a ${LBUFFER[-1]} = ' ' ]; then
+    tail=$trigger
+    tokens+=$trigger
+    lbuf="$lbuf$trigger"
+  fi
 
   # Trigger sequence given
   if [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
-    d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS-cd pushd rmdir})
+    d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir})
 
     [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
-    if [[ $prefix = *'$('* ]] || [[ $prefix = *'<('* ]] || [[ $prefix = *'>('* ]] || [[ $prefix = *':='* ]] || [[ $prefix = *'`'* ]]; then
-      return
-    fi
     [ -n "${tokens[-1]}" ] && lbuf=${lbuf:0:-${#tokens[-1]}}
 
     if eval "type _fzf_complete_${cmd} > /dev/null"; then
@@ -365,7 +321,6 @@ fzf-completion() {
 
 zle     -N   fzf-completion
 bindkey '^I' fzf-completion
-fi
 
 } always {
   # Restore the original options.

shell/key-bindings.bash

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

shell/key-bindings.fish

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

shell/key-bindings.zsh

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

src/LICENSE

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

src/actiontype_string.go

@@ -1,133 +0,0 @@
-// Code generated by "stringer -type=actionType"; DO NOT EDIT.
-
-package fzf
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[actIgnore-0]
-	_ = x[actStart-1]
-	_ = x[actClick-2]
-	_ = x[actInvalid-3]
-	_ = x[actChar-4]
-	_ = x[actMouse-5]
-	_ = x[actBeginningOfLine-6]
-	_ = x[actAbort-7]
-	_ = x[actAccept-8]
-	_ = x[actAcceptNonEmpty-9]
-	_ = x[actAcceptOrPrintQuery-10]
-	_ = x[actBackwardChar-11]
-	_ = x[actBackwardDeleteChar-12]
-	_ = x[actBackwardDeleteCharEof-13]
-	_ = x[actBackwardWord-14]
-	_ = x[actCancel-15]
-	_ = x[actChangeBorderLabel-16]
-	_ = x[actChangeHeader-17]
-	_ = x[actChangeMulti-18]
-	_ = x[actChangePreviewLabel-19]
-	_ = x[actChangePrompt-20]
-	_ = x[actChangeQuery-21]
-	_ = x[actClearScreen-22]
-	_ = x[actClearQuery-23]
-	_ = x[actClearSelection-24]
-	_ = x[actClose-25]
-	_ = x[actDeleteChar-26]
-	_ = x[actDeleteCharEof-27]
-	_ = x[actEndOfLine-28]
-	_ = x[actFatal-29]
-	_ = x[actForwardChar-30]
-	_ = x[actForwardWord-31]
-	_ = x[actKillLine-32]
-	_ = x[actKillWord-33]
-	_ = x[actUnixLineDiscard-34]
-	_ = x[actUnixWordRubout-35]
-	_ = x[actYank-36]
-	_ = x[actBackwardKillWord-37]
-	_ = x[actSelectAll-38]
-	_ = x[actDeselectAll-39]
-	_ = x[actToggle-40]
-	_ = x[actToggleSearch-41]
-	_ = x[actToggleAll-42]
-	_ = x[actToggleDown-43]
-	_ = x[actToggleUp-44]
-	_ = x[actToggleIn-45]
-	_ = x[actToggleOut-46]
-	_ = x[actToggleTrack-47]
-	_ = x[actToggleTrackCurrent-48]
-	_ = x[actToggleHeader-49]
-	_ = x[actTrackCurrent-50]
-	_ = x[actUntrackCurrent-51]
-	_ = x[actDown-52]
-	_ = x[actUp-53]
-	_ = x[actPageUp-54]
-	_ = x[actPageDown-55]
-	_ = x[actPosition-56]
-	_ = x[actHalfPageUp-57]
-	_ = x[actHalfPageDown-58]
-	_ = x[actOffsetUp-59]
-	_ = x[actOffsetDown-60]
-	_ = x[actJump-61]
-	_ = x[actJumpAccept-62]
-	_ = x[actPrintQuery-63]
-	_ = x[actRefreshPreview-64]
-	_ = x[actReplaceQuery-65]
-	_ = x[actToggleSort-66]
-	_ = x[actShowPreview-67]
-	_ = x[actHidePreview-68]
-	_ = x[actTogglePreview-69]
-	_ = x[actTogglePreviewWrap-70]
-	_ = x[actTransform-71]
-	_ = x[actTransformBorderLabel-72]
-	_ = x[actTransformHeader-73]
-	_ = x[actTransformPreviewLabel-74]
-	_ = x[actTransformPrompt-75]
-	_ = x[actTransformQuery-76]
-	_ = x[actPreview-77]
-	_ = x[actChangePreview-78]
-	_ = x[actChangePreviewWindow-79]
-	_ = x[actPreviewTop-80]
-	_ = x[actPreviewBottom-81]
-	_ = x[actPreviewUp-82]
-	_ = x[actPreviewDown-83]
-	_ = x[actPreviewPageUp-84]
-	_ = x[actPreviewPageDown-85]
-	_ = x[actPreviewHalfPageUp-86]
-	_ = x[actPreviewHalfPageDown-87]
-	_ = x[actPrevHistory-88]
-	_ = x[actPrevSelected-89]
-	_ = x[actPut-90]
-	_ = x[actNextHistory-91]
-	_ = x[actNextSelected-92]
-	_ = x[actExecute-93]
-	_ = x[actExecuteSilent-94]
-	_ = x[actExecuteMulti-95]
-	_ = x[actSigStop-96]
-	_ = x[actFirst-97]
-	_ = x[actLast-98]
-	_ = x[actReload-99]
-	_ = x[actReloadSync-100]
-	_ = x[actDisableSearch-101]
-	_ = x[actEnableSearch-102]
-	_ = x[actSelect-103]
-	_ = x[actDeselect-104]
-	_ = x[actUnbind-105]
-	_ = x[actRebind-106]
-	_ = x[actBecome-107]
-	_ = x[actResponse-108]
-	_ = x[actShowHeader-109]
-	_ = x[actHideHeader-110]
-}
-
-const _actionType_name = "actIgnoreactStartactClickactInvalidactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactCancelactChangeBorderLabelactChangeHeaderactChangeMultiactChangePreviewLabelactChangePromptactChangeQueryactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactFatalactForwardCharactForwardWordactKillLineactKillWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleTrackCurrentactToggleHeaderactTrackCurrentactUntrackCurrentactDownactUpactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTransformactTransformBorderLabelactTransformHeaderactTransformPreviewLabelactTransformPromptactTransformQueryactPreviewactChangePreviewactChangePreviewWindowactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactBecomeactResponseactShowHeaderactHideHeader"
-
-var _actionType_index = [...]uint16{0, 9, 17, 25, 35, 42, 50, 68, 76, 85, 102, 123, 138, 159, 183, 198, 207, 227, 242, 256, 277, 292, 306, 320, 333, 350, 358, 371, 387, 399, 407, 421, 435, 446, 457, 475, 492, 499, 518, 530, 544, 553, 568, 580, 593, 604, 615, 627, 641, 662, 677, 692, 709, 716, 721, 730, 741, 752, 765, 780, 791, 804, 811, 824, 837, 854, 869, 882, 896, 910, 926, 946, 958, 981, 999, 1023, 1041, 1058, 1068, 1084, 1106, 1119, 1135, 1147, 1161, 1177, 1195, 1215, 1237, 1251, 1266, 1272, 1286, 1301, 1311, 1327, 1342, 1352, 1360, 1367, 1376, 1389, 1405, 1420, 1429, 1440, 1449, 1458, 1467, 1478, 1491, 1504}
-
-func (i actionType) String() string {
-	if i < 0 || i >= actionType(len(_actionType_index)-1) {
-		return "actionType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _actionType_name[_actionType_index[i]:_actionType_index[i+1]]
-}

src/algo/algo.go

@@ -80,7 +80,6 @@ Scoring criteria
 import (
 	"bytes"
 	"fmt"
-	"os"
 	"strings"
 	"unicode"
 	"unicode/utf8"
@@ -90,10 +89,6 @@ import (
 
 var DEBUG bool
 
-var delimiterChars = "/,:;|"
-
-const whiteChars = " \t\n\v\f\r\x85\xA0"
-
 func indexAt(index int, max int, forward bool) int {
 	if forward {
 		return index
@@ -145,78 +140,16 @@ const (
 	bonusFirstCharMultiplier = 2
 )
 
-var (
-	// Extra bonus for word boundary after whitespace character or beginning of the string
-	bonusBoundaryWhite int16 = bonusBoundary + 2
-
-	// Extra bonus for word boundary after slash, colon, semi-colon, and comma
-	bonusBoundaryDelimiter int16 = bonusBoundary + 1
-
-	initialCharClass = charWhite
-
-	// A minor optimization that can give 15%+ performance boost
-	asciiCharClasses [unicode.MaxASCII + 1]charClass
-
-	// A minor optimization that can give yet another 5% performance boost
-	bonusMatrix [charNumber + 1][charNumber + 1]int16
-)
-
 type charClass int
 
 const (
-	charWhite charClass = iota
-	charNonWord
-	charDelimiter
+	charNonWord charClass = iota
 	charLower
 	charUpper
 	charLetter
 	charNumber
 )
 
-func Init(scheme string) bool {
-	switch scheme {
-	case "default":
-		bonusBoundaryWhite = bonusBoundary + 2
-		bonusBoundaryDelimiter = bonusBoundary + 1
-	case "path":
-		bonusBoundaryWhite = bonusBoundary
-		bonusBoundaryDelimiter = bonusBoundary + 1
-		if os.PathSeparator == '/' {
-			delimiterChars = "/"
-		} else {
-			delimiterChars = string([]rune{os.PathSeparator, '/'})
-		}
-		initialCharClass = charDelimiter
-	case "history":
-		bonusBoundaryWhite = bonusBoundary
-		bonusBoundaryDelimiter = bonusBoundary
-	default:
-		return false
-	}
-	for i := 0; i <= unicode.MaxASCII; i++ {
-		char := rune(i)
-		c := charNonWord
-		if char >= 'a' && char <= 'z' {
-			c = charLower
-		} else if char >= 'A' && char <= 'Z' {
-			c = charUpper
-		} else if char >= '0' && char <= '9' {
-			c = charNumber
-		} else if strings.ContainsRune(whiteChars, char) {
-			c = charWhite
-		} else if strings.ContainsRune(delimiterChars, char) {
-			c = charDelimiter
-		}
-		asciiCharClasses[i] = c
-	}
-	for i := 0; i <= int(charNumber); i++ {
-		for j := 0; j <= int(charNumber); j++ {
-			bonusMatrix[i][j] = bonusFor(charClass(i), charClass(j))
-		}
-	}
-	return true
-}
-
 func posArray(withPos bool, len int) *[]int {
 	if withPos {
 		pos := make([]int, 0, len)
@@ -241,6 +174,17 @@ func alloc32(offset int, slab *util.Slab, size int) (int, []int32) {
 	return offset, make([]int32, size)
 }
 
+func charClassOfAscii(char rune) charClass {
+	if char >= 'a' && char <= 'z' {
+		return charLower
+	} else if char >= 'A' && char <= 'Z' {
+		return charUpper
+	} else if char >= '0' && char <= '9' {
+		return charNumber
+	}
+	return charNonWord
+}
+
 func charClassOfNonAscii(char rune) charClass {
 	if unicode.IsLower(char) {
 		return charLower
@@ -250,56 +194,36 @@ func charClassOfNonAscii(char rune) charClass {
 		return charNumber
 	} else if unicode.IsLetter(char) {
 		return charLetter
-	} else if unicode.IsSpace(char) {
-		return charWhite
-	} else if strings.ContainsRune(delimiterChars, char) {
-		return charDelimiter
 	}
 	return charNonWord
 }
 
 func charClassOf(char rune) charClass {
 	if char <= unicode.MaxASCII {
-		return asciiCharClasses[char]
+		return charClassOfAscii(char)
 	}
 	return charClassOfNonAscii(char)
 }
 
 func bonusFor(prevClass charClass, class charClass) int16 {
-	if class > charNonWord {
-		switch prevClass {
-		case charWhite:
-			// Word boundary after whitespace
-			return bonusBoundaryWhite
-		case charDelimiter:
-			// Word boundary after a delimiter character
-			return bonusBoundaryDelimiter
-		case charNonWord:
-			// Word boundary
-			return bonusBoundary
-		}
-	}
-
-	if prevClass == charLower && class == charUpper ||
+	if prevClass == charNonWord && class != charNonWord {
+		// Word boundary
+		return bonusBoundary
+	} else if prevClass == charLower && class == charUpper ||
 		prevClass != charNumber && class == charNumber {
 		// camelCase letter123
 		return bonusCamel123
-	}
-
-	switch class {
-	case charNonWord, charDelimiter:
+	} else if class == charNonWord {
 		return bonusNonWord
-	case charWhite:
-		return bonusBoundaryWhite
 	}
 	return 0
 }
 
 func bonusAt(input *util.Chars, idx int) int16 {
 	if idx == 0 {
-		return bonusBoundaryWhite
+		return bonusBoundary
 	}
-	return bonusMatrix[charClassOf(input.Get(idx-1))][charClassOf(input.Get(idx))]
+	return bonusFor(charClassOf(input.Get(idx-1)), charClassOf(input.Get(idx)))
 }
 
 func normalizeRune(r rune) rune {
@@ -352,45 +276,30 @@ func isAscii(runes []rune) bool {
 	return true
 }
 
-func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) (int, int) {
+func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) int {
 	// Can't determine
 	if !input.IsBytes() {
-		return 0, input.Length()
+		return 0
 	}
 
 	// Not possible
 	if !isAscii(pattern) {
-		return -1, -1
+		return -1
 	}
 
-	firstIdx, idx, lastIdx := 0, 0, 0
-	var b byte
+	firstIdx, idx := 0, 0
 	for pidx := 0; pidx < len(pattern); pidx++ {
-		b = byte(pattern[pidx])
-		idx = trySkip(input, caseSensitive, b, idx)
+		idx = trySkip(input, caseSensitive, byte(pattern[pidx]), idx)
 		if idx < 0 {
-			return -1, -1
+			return -1
 		}
 		if pidx == 0 && idx > 0 {
 			// Step back to find the right bonus point
 			firstIdx = idx - 1
 		}
-		lastIdx = idx
 		idx++
 	}
-
-	// Find the last appearance of the last character of the pattern to limit the search scope
-	bu := b
-	if !caseSensitive && b >= 'a' && b <= 'z' {
-		bu = b - 32
-	}
-	scope := input.Bytes()[lastIdx:]
-	for offset := len(scope) - 1; offset > 0; offset-- {
-		if scope[offset] == b || scope[offset] == bu {
-			return firstIdx, lastIdx + offset + 1
-		}
-	}
-	return firstIdx, lastIdx + 1
+	return firstIdx
 }
 
 func debugV2(T []rune, pattern []rune, F []int32, lastIdx int, H []int16, C []int16) {
@@ -439,9 +348,6 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 		return Result{0, 0, 0}, posArray(withPos, M)
 	}
 	N := input.Length()
-	if M > N {
-		return Result{-1, -1, 0}, nil
-	}
 
 	// Since O(nm) algorithm can be prohibitively expensive for large input,
 	// we fall back to the greedy algorithm.
@@ -450,12 +356,10 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	}
 
 	// Phase 1. Optimized search for ASCII string
-	minIdx, maxIdx := asciiFuzzyIndex(input, pattern, caseSensitive)
-	if minIdx < 0 {
+	idx := asciiFuzzyIndex(input, pattern, caseSensitive)
+	if idx < 0 {
 		return Result{-1, -1, 0}, nil
 	}
-	// fmt.Println(N, maxIdx, idx, maxIdx-idx, input.ToString())
-	N = maxIdx - minIdx
 
 	// Reuse pre-allocated integer slice to avoid unnecessary sweeping of garbages
 	offset16 := 0
@@ -468,19 +372,20 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	offset32, F := alloc32(offset32, slab, M)
 	// Rune array
 	_, T := alloc32(offset32, slab, N)
-	input.CopyRunes(T, minIdx)
+	input.CopyRunes(T)
 
 	// Phase 2. Calculate bonus for each point
 	maxScore, maxScorePos := int16(0), 0
 	pidx, lastIdx := 0, 0
-	pchar0, pchar, prevH0, prevClass, inGap := pattern[0], pattern[0], int16(0), initialCharClass, false
-	for off, char := range T {
+	pchar0, pchar, prevH0, prevClass, inGap := pattern[0], pattern[0], int16(0), charNonWord, false
+	Tsub := T[idx:]
+	H0sub, C0sub, Bsub := H0[idx:][:len(Tsub)], C0[idx:][:len(Tsub)], B[idx:][:len(Tsub)]
+	for off, char := range Tsub {
 		var class charClass
 		if char <= unicode.MaxASCII {
-			class = asciiCharClasses[char]
+			class = charClassOfAscii(char)
 			if !caseSensitive && class == charUpper {
 				char += 32
-				T[off] = char
 			}
 		} else {
 			class = charClassOfNonAscii(char)
@@ -490,53 +395,53 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			if normalize {
 				char = normalizeRune(char)
 			}
-			T[off] = char
 		}
 
-		bonus := bonusMatrix[prevClass][class]
-		B[off] = bonus
+		Tsub[off] = char
+		bonus := bonusFor(prevClass, class)
+		Bsub[off] = bonus
 		prevClass = class
 
 		if char == pchar {
 			if pidx < M {
-				F[pidx] = int32(off)
+				F[pidx] = int32(idx + off)
 				pidx++
 				pchar = pattern[util.Min(pidx, M-1)]
 			}
-			lastIdx = off
+			lastIdx = idx + off
 		}
 
 		if char == pchar0 {
 			score := scoreMatch + bonus*bonusFirstCharMultiplier
-			H0[off] = score
-			C0[off] = 1
+			H0sub[off] = score
+			C0sub[off] = 1
 			if M == 1 && (forward && score > maxScore || !forward && score >= maxScore) {
-				maxScore, maxScorePos = score, off
-				if forward && bonus >= bonusBoundary {
+				maxScore, maxScorePos = score, idx+off
+				if forward && bonus == bonusBoundary {
 					break
 				}
 			}
 			inGap = false
 		} else {
 			if inGap {
-				H0[off] = util.Max16(prevH0+scoreGapExtension, 0)
+				H0sub[off] = util.Max16(prevH0+scoreGapExtension, 0)
 			} else {
-				H0[off] = util.Max16(prevH0+scoreGapStart, 0)
+				H0sub[off] = util.Max16(prevH0+scoreGapStart, 0)
 			}
-			C0[off] = 0
+			C0sub[off] = 0
 			inGap = true
 		}
-		prevH0 = H0[off]
+		prevH0 = H0sub[off]
 	}
 	if pidx != M {
 		return Result{-1, -1, 0}, nil
 	}
 	if M == 1 {
-		result := Result{minIdx + maxScorePos, minIdx + maxScorePos + 1, int(maxScore)}
+		result := Result{maxScorePos, maxScorePos + 1, int(maxScore)}
 		if !withPos {
 			return result, nil
 		}
-		pos := []int{minIdx + maxScorePos}
+		pos := []int{maxScorePos}
 		return result, &pos
 	}
 
@@ -581,14 +486,11 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 				s1 = Hdiag[off] + scoreMatch
 				b := Bsub[off]
 				consecutive = Cdiag[off] + 1
-				if consecutive > 1 {
-					fb := B[col-int(consecutive)+1]
-					// Break consecutive chunk
-					if b >= bonusBoundary && b > fb {
-						consecutive = 1
-					} else {
-						b = util.Max16(b, util.Max16(bonusConsecutive, fb))
-					}
+				// Break consecutive chunk
+				if b == bonusBoundary {
+					consecutive = 1
+				} else if consecutive > 1 {
+					b = util.Max16(b, util.Max16(bonusConsecutive, B[col-int(consecutive)+1]))
 				}
 				if s1+b < s2 {
 					s1 += Bsub[off]
@@ -633,7 +535,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			}
 
 			if s > s1 && (s > s2 || s == s2 && preferMatch) {
-				*pos = append(*pos, j+minIdx)
+				*pos = append(*pos, j)
 				if i == 0 {
 					break
 				}
@@ -646,14 +548,14 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 	// Start offset we return here is only relevant when begin tiebreak is used.
 	// However finding the accurate offset requires backtracking, and we don't
 	// want to pay extra cost for the option that has lost its importance.
-	return Result{minIdx + j, minIdx + maxScorePos + 1, int(maxScore)}, pos
+	return Result{j, maxScorePos + 1, int(maxScore)}, pos
 }
 
 // Implement the same sorting criteria as V2
 func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, pattern []rune, sidx int, eidx int, withPos bool) (int, *[]int) {
 	pidx, score, inGap, consecutive, firstBonus := 0, 0, false, 0, int16(0)
 	pos := posArray(withPos, len(pattern))
-	prevClass := initialCharClass
+	prevClass := charNonWord
 	if sidx > 0 {
 		prevClass = charClassOf(text.Get(sidx - 1))
 	}
@@ -676,12 +578,12 @@ func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, patter
 				*pos = append(*pos, idx)
 			}
 			score += scoreMatch
-			bonus := bonusMatrix[prevClass][class]
+			bonus := bonusFor(prevClass, class)
 			if consecutive == 0 {
 				firstBonus = bonus
 			} else {
 				// Break consecutive chunk
-				if bonus >= bonusBoundary && bonus > firstBonus {
+				if bonus == bonusBoundary {
 					firstBonus = bonus
 				}
 				bonus = util.Max16(util.Max16(bonus, firstBonus), bonusConsecutive)
@@ -714,8 +616,7 @@ func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text *util.C
 	if len(pattern) == 0 {
 		return Result{0, 0, 0}, nil
 	}
-	idx, _ := asciiFuzzyIndex(text, pattern, caseSensitive)
-	if idx < 0 {
+	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
 		return Result{-1, -1, 0}, nil
 	}
 
@@ -809,8 +710,7 @@ func ExactMatchNaive(caseSensitive bool, normalize bool, forward bool, text *uti
 		return Result{-1, -1, 0}, nil
 	}
 
-	idx, _ := asciiFuzzyIndex(text, pattern, caseSensitive)
-	if idx < 0 {
+	if asciiFuzzyIndex(text, pattern, caseSensitive) < 0 {
 		return Result{-1, -1, 0}, nil
 	}
 
@@ -841,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
@@ -977,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
 }

src/algo/algo_test.go

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

src/algo/normalize.go

@@ -3,7 +3,7 @@
 
 package algo
 
-var normalized = map[rune]rune{
+var normalized map[rune]rune = map[rune]rune{
 	0x00E1: 'a', //  WITH ACUTE, LATIN SMALL LETTER
 	0x0103: 'a', //  WITH BREVE, LATIN SMALL LETTER
 	0x01CE: 'a', //  WITH CARON, LATIN SMALL LETTER

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
-	var i int
-	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]
 	}
@@ -312,17 +291,17 @@ func parseAnsiCode(s string, delimiter byte) (int, byte, string) {
 		// Inlined version of strconv.Atoi() that only handles positive
 		// integers and does not allocate on error.
 		code := 0
-		for _, ch := range stringBytes(s) {
+		for _, ch := range []byte(s) {
 			ch -= '0'
 			if ch > 9 {
-				return -1, delimiter, remaining
+				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,12 +329,9 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 	state256 := 0
 	ptr := &state.fg
 
-	var delimiter byte
-	count := 0
 	for len(ansiCode) != 0 {
 		var num int
-		if num, delimiter, ansiCode = parseAnsiCode(ansiCode, delimiter); num != -1 {
-			count++
+		if num, ansiCode = parseAnsiCode(ansiCode); num != -1 {
 			switch state256 {
 			case 0:
 				switch num {
@@ -381,21 +357,10 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 					state.attr = state.attr | tui.Blink
 				case 7:
 					state.attr = state.attr | tui.Reverse
-				case 9:
-					state.attr = state.attr | tui.StrikeThrough
-				case 22:
-					state.attr = state.attr &^ tui.Bold
-					state.attr = state.attr &^ tui.Dim
 				case 23: // tput rmso
 					state.attr = state.attr &^ tui.Italic
 				case 24: // tput rmul
 					state.attr = state.attr &^ tui.Underline
-				case 25:
-					state.attr = state.attr &^ tui.Blink
-				case 27:
-					state.attr = state.attr &^ tui.Reverse
-				case 29:
-					state.attr = state.attr &^ tui.StrikeThrough
 				case 0:
 					state.fg = -1
 					state.bg = -1
@@ -437,13 +402,6 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 		}
 	}
 
-	// Empty sequence: reset
-	if count == 0 {
-		state.fg = -1
-		state.bg = -1
-		state.attr = 0
-	}
-
 	if state256 > 0 {
 		*ptr = -1
 	}

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()
@@ -342,15 +342,12 @@ func TestAnsiCodeStringConversion(t *testing.T) {
 		state := interpretCode(code, prevState)
 		if expected != state.ToString() {
 			t.Errorf("expected: %s, actual: %s",
-				strings.ReplaceAll(expected, "\x1b[", "\\x1b["),
-				strings.ReplaceAll(state.ToString(), "\x1b[", "\\x1b["))
+				strings.Replace(expected, "\x1b[", "\\x1b[", -1),
+				strings.Replace(state.ToString(), "\x1b[", "\\x1b[", -1))
 		}
 	}
 	assert("\x1b[m", nil, "")
 	assert("\x1b[m", &ansiState{attr: tui.Blink, lbg: -1}, "")
-	assert("\x1b[0m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
-	assert("\x1b[;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
-	assert("\x1b[;;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
 
 	assert("\x1b[31m", nil, "\x1b[31;49m")
 	assert("\x1b[41m", nil, "\x1b[39;41m")
@@ -361,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",
@@ -381,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)
 		}
@@ -389,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)))

src/cache.go

@@ -12,14 +12,8 @@ type ChunkCache struct {
 }
 
 // NewChunkCache returns a new ChunkCache
-func NewChunkCache() *ChunkCache {
-	return &ChunkCache{sync.Mutex{}, make(map[*Chunk]*queryCache)}
-}
-
-func (cc *ChunkCache) Clear() {
-	cc.mutex.Lock()
-	cc.cache = make(map[*Chunk]*queryCache)
-	cc.mutex.Unlock()
+func NewChunkCache() ChunkCache {
+	return ChunkCache{sync.Mutex{}, make(map[*Chunk]*queryCache)}
 }
 
 // Add adds the list to the cache

src/constants.go

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

src/core.go

@@ -1,8 +1,33 @@
-// Package fzf implements fzf, a command-line fuzzy finder.
+/*
+Package fzf implements fzf, a command-line fuzzy finder.
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2021 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
 package fzf
 
 import (
-	"sync"
+	"fmt"
+	"os"
 	"time"
 
 	"github.com/junegunn/fzf/src/util"
@@ -18,23 +43,19 @@ Matcher  -> EvtHeader         -> Terminal (update header)
 */
 
 // Run starts fzf
-func Run(opts *Options) (int, error) {
-	if err := postProcessOptions(opts); err != nil {
-		return ExitError, err
-	}
-
-	defer util.RunAtExitFuncs()
-
-	// Output channel given
-	if opts.Output != nil {
-		opts.Printer = func(str string) {
-			opts.Output <- str
-		}
-	}
-
+func Run(opts *Options, version string, revision string) {
 	sort := opts.Sort > 0
 	sortCriteria = opts.Criteria
 
+	if opts.Version {
+		if len(revision) > 0 {
+			fmt.Printf("%s (%s)\n", version, revision)
+		} else {
+			fmt.Println(version)
+		}
+		os.Exit(exitOk)
+	}
+
 	// Event channel
 	eventBox := util.NewEventBox()
 
@@ -48,16 +69,16 @@ func Run(opts *Options) (int, error) {
 		if opts.Theme.Colored {
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				prevLineAnsiState = lineAnsiState
-				trimmed, offsets, newState := extractColor(byteString(data), lineAnsiState, nil)
+				trimmed, offsets, newState := extractColor(string(data), lineAnsiState, nil)
 				lineAnsiState = newState
-				return util.ToChars(stringBytes(trimmed)), offsets
+				return util.ToChars([]byte(trimmed)), offsets
 			}
 		} else {
 			// When color is disabled but ansi option is given,
 			// we simply strip out ANSI codes from the input
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
-				trimmed, _, _ := extractColor(byteString(data), nil, nil)
-				return util.ToChars(stringBytes(trimmed)), nil
+				trimmed, _, _ := extractColor(string(data), nil, nil)
+				return util.ToChars([]byte(trimmed)), nil
 			}
 		}
 	}
@@ -69,7 +90,7 @@ func Run(opts *Options) (int, error) {
 	if len(opts.WithNth) == 0 {
 		chunkList = NewChunkList(func(item *Item, data []byte) bool {
 			if len(header) < opts.HeaderLines {
-				header = append(header, byteString(data))
+				header = append(header, string(data))
 				eventBox.Set(EvtHeader, header)
 				return false
 			}
@@ -80,7 +101,7 @@ func Run(opts *Options) (int, error) {
 		})
 	} else {
 		chunkList = NewChunkList(func(item *Item, data []byte) bool {
-			tokens := Tokenize(byteString(data), opts.Delimiter)
+			tokens := Tokenize(string(data), opts.Delimiter)
 			if opts.Ansi && opts.Theme.Colored && len(tokens) > 1 {
 				var ansiState *ansiState
 				if prevLineAnsiState != nil {
@@ -104,7 +125,7 @@ func Run(opts *Options) (int, error) {
 				eventBox.Set(EvtHeader, header)
 				return false
 			}
-			item.text, item.colors = ansiProcessor(stringBytes(transformed))
+			item.text, item.colors = ansiProcessor([]byte(transformed))
 			item.text.TrimTrailingWhitespaces()
 			item.text.Index = itemIndex
 			item.origText = &data
@@ -113,42 +134,33 @@ func Run(opts *Options) (int, error) {
 		})
 	}
 
-	// Process executor
-	executor := util.NewExecutor(opts.WithShell)
-
 	// Reader
 	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
 	var reader *Reader
 	if !streamingFilter {
 		reader = NewReader(func(data []byte) bool {
 			return chunkList.Push(data)
-		}, eventBox, executor, opts.ReadZero, opts.Filter == nil)
-		go reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
+		}, eventBox, opts.ReadZero, opts.Filter == nil)
+		go reader.ReadSource()
 	}
 
 	// Matcher
 	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
 		}
 	}
-	cache := NewChunkCache()
-	patternCache := make(map[string]*Pattern)
 	patternBuilder := func(runes []rune) *Pattern {
-		return BuildPattern(cache, patternCache,
-			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward, withPos,
+		return BuildPattern(
+			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(cache, patternBuilder, sort, opts.Tac, eventBox, inputRevision)
+	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)
 
 	// Filtering mode
 	if opts.Filter != nil {
@@ -162,21 +174,18 @@ func Run(opts *Options) (int, error) {
 		found := false
 		if streamingFilter {
 			slab := util.MakeSlab(slab16Size, slab32Size)
-			mutex := sync.Mutex{}
 			reader := NewReader(
 				func(runes []byte) bool {
 					item := Item{}
 					if chunkList.trans(&item, runes) {
-						mutex.Lock()
 						if result, _, _ := pattern.MatchItem(&item, false, slab); result != nil {
 							opts.Printer(item.text.ToString())
 							found = true
 						}
-						mutex.Unlock()
 					}
 					return false
-				}, eventBox, executor, opts.ReadZero, false)
-			reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
+				}, eventBox, opts.ReadZero, false)
+			reader.ReadSource()
 		} else {
 			eventBox.Unwatch(EvtReadNew)
 			eventBox.WaitFor(EvtReadFin)
@@ -191,9 +200,9 @@ func Run(opts *Options) (int, error) {
 			}
 		}
 		if found {
-			return ExitOk, nil
+			os.Exit(exitOk)
 		}
-		return ExitNoMatch, nil
+		os.Exit(exitNoMatch)
 	}
 
 	// Synchronous search
@@ -204,61 +213,32 @@ func Run(opts *Options) (int, error) {
 
 	// Go interactive
 	go matcher.Loop()
-	defer matcher.Stop()
 
 	// Terminal I/O
-	terminal, err := NewTerminal(opts, eventBox, executor)
-	if err != nil {
-		return ExitError, err
-	}
-	maxFit := 0 // Maximum number of items that can fit on screen
-	padHeight := 0
-	heightUnknown := opts.Height.auto
-	if heightUnknown {
-		maxFit, padHeight = terminal.MaxFitAndPad()
-	}
+	terminal := NewTerminal(opts, eventBox)
 	deferred := opts.Select1 || opts.Exit0
 	go terminal.Loop()
-	if !deferred && !heightUnknown {
-		// Start right away
-		terminal.startChan <- fitpad{-1, -1}
+	if !deferred {
+		terminal.startChan <- true
 	}
 
 	// Event coordination
 	reading := true
+	clearCache := util.Once(false)
+	clearSelection := util.Once(false)
 	ticks := 0
-	var nextCommand *commandSpec
-	var nextEnviron []string
-	eventBox.Watch(EvtReadNew)
-	total := 0
-	query := []rune{}
-	determine := func(final bool) {
-		if heightUnknown {
-			if total >= maxFit || final {
-				deferred = false
-				heightUnknown = false
-				terminal.startChan <- fitpad{util.Min(total, maxFit), padHeight}
-			}
-		} else if deferred {
-			deferred = false
-			terminal.startChan <- fitpad{-1, -1}
-		}
-	}
-
-	useSnapshot := false
-	var snapshot []*Chunk
-	var count int
-	restart := func(command commandSpec, environ []string) {
+	var nextCommand *string
+	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, environ)
+		go reader.restart(command)
 	}
-
-	exitCode := ExitOk
-	stop := false
+	eventBox.Watch(EvtReadNew)
+	query := []rune{}
 	for {
 		delay := true
 		ticks++
@@ -279,79 +259,41 @@ func Run(opts *Options) (int, error) {
 					if reading {
 						reader.terminate()
 					}
-					quitSignal := value.(quitSignal)
-					exitCode = quitSignal.code
-					err = quitSignal.err
-					stop = true
-					return
+					os.Exit(value.(int))
 				case EvtReadNew, EvtReadFin:
 					if evt == EvtReadFin && nextCommand != nil {
-						restart(*nextCommand, nextEnviron)
+						restart(*nextCommand)
 						nextCommand = nil
-						nextEnviron = nil
 						break
 					} else {
 						reading = reading && evt == EvtReadNew
 					}
-					if useSnapshot && evt == EvtReadFin {
-						useSnapshot = false
-					}
-					if !useSnapshot {
-						if snapshotRevision != inputRevision {
-							query = []rune{}
-						}
-						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 {
-						terminal.UpdateList(PassMerger(&snapshot, opts.Tac, snapshotRevision), false)
+						opts.Sync = false
+						terminal.UpdateList(PassMerger(&snapshot, opts.Tac), false)
 					}
-					if heightUnknown && !deferred {
-						determine(!reading)
-					}
-					matcher.Reset(snapshot, input(), false, !reading, sort, snapshotRevision)
+					matcher.Reset(snapshot, input(), false, !reading, sort, clearCache())
 
 				case EvtSearchNew:
-					var command *commandSpec
-					var environ []string
-					var changed bool
+					var command *string
 					switch val := value.(type) {
 					case searchRequest:
 						sort = val.sort
 						command = val.command
-						environ = val.environ
-						changed = val.changed
-						if command != nil {
-							useSnapshot = val.sync
-						}
 					}
 					if command != nil {
 						if reading {
 							reader.terminate()
 							nextCommand = command
-							nextEnviron = environ
 						} else {
-							restart(*command, environ)
+							restart(*command)
 						}
-					}
-					if !changed {
 						break
 					}
-					if !useSnapshot {
-						newSnapshot, newCount := chunkList.Snapshot()
-						// We want to avoid showing empty list when reload is triggered
-						// and the query string is changed at the same time i.e. command != nil && changed
-						if command == nil || newCount > 0 {
-							if snapshotRevision != inputRevision {
-								query = []rune{}
-							}
-							snapshot = newSnapshot
-							snapshotRevision = inputRevision
-						}
-					}
-					matcher.Reset(snapshot, input(), true, !reading, sort, snapshotRevision)
+					snapshot, _ := chunkList.Snapshot()
+					matcher.Reset(snapshot, input(), true, !reading, sort, clearCache())
 					delay = false
 
 				case EvtSearchProgress:
@@ -371,7 +313,8 @@ func Run(opts *Options) (int, error) {
 						if deferred {
 							count := val.Length()
 							if opts.Select1 && count > 1 || opts.Exit0 && !opts.Select1 && count > 0 {
-								determine(val.final)
+								deferred = false
+								terminal.startChan <- true
 							} else if val.final {
 								if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
 									if opts.PrintQuery {
@@ -383,24 +326,21 @@ func Run(opts *Options) (int, error) {
 									for i := 0; i < count; i++ {
 										opts.Printer(val.Get(i).item.AsString(opts.Ansi))
 									}
-									if count == 0 {
-										exitCode = ExitNoMatch
+									if count > 0 {
+										os.Exit(exitOk)
 									}
-									stop = true
-									return
+									os.Exit(exitNoMatch)
 								}
-								determine(val.final)
+								deferred = false
+								terminal.startChan <- true
 							}
 						}
-						terminal.UpdateList(val, true)
+						terminal.UpdateList(val, clearSelection())
 					}
 				}
 			}
 			events.Clear()
 		})
-		if stop {
-			break
-		}
 		if delay && reading {
 			dur := util.DurWithin(
 				time.Duration(ticks)*coordinatorDelayStep,
@@ -408,5 +348,4 @@ func Run(opts *Options) (int, error) {
 			time.Sleep(dur)
 		}
 	}
-	return exitCode, err
 }

src/functions.go

@@ -1,35 +0,0 @@
-package fzf
-
-import (
-	"os"
-	"strings"
-	"unsafe"
-)
-
-func writeTemporaryFile(data []string, printSep string) string {
-	f, err := os.CreateTemp("", "fzf-preview-*")
-	if err != nil {
-		// Unable to create temporary file
-		// FIXME: Should we terminate the program?
-		return ""
-	}
-	defer f.Close()
-
-	f.WriteString(strings.Join(data, printSep))
-	f.WriteString(printSep)
-	return f.Name()
-}
-
-func removeFiles(files []string) {
-	for _, filename := range files {
-		os.Remove(filename)
-	}
-}
-
-func stringBytes(data string) []byte {
-	return unsafe.Slice(unsafe.StringData(data), len(data))
-}
-
-func byteString(data []byte) string {
-	return unsafe.String(unsafe.SliceData(data), len(data))
-}

src/history.go

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

src/history_test.go

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

src/matcher.go

@@ -12,16 +12,15 @@ import (
 
 // MatchRequest represents a search request
 type MatchRequest struct {
-	chunks   []*Chunk
-	pattern  *Pattern
-	final    bool
-	sort     bool
-	revision int
+	chunks     []*Chunk
+	pattern    *Pattern
+	final      bool
+	sort       bool
+	clearCache bool
 }
 
 // Matcher is responsible for performing search
 type Matcher struct {
-	cache          *ChunkCache
 	patternBuilder func([]rune) *Pattern
 	sort           bool
 	tac            bool
@@ -30,7 +29,6 @@ type Matcher struct {
 	partitions     int
 	slab           []*util.Slab
 	mergerCache    map[string]*Merger
-	revision       int
 }
 
 const (
@@ -39,11 +37,10 @@ const (
 )
 
 // NewMatcher returns a new Matcher
-func NewMatcher(cache *ChunkCache, patternBuilder func([]rune) *Pattern,
-	sort bool, tac bool, eventBox *util.EventBox, revision int) *Matcher {
+func NewMatcher(patternBuilder func([]rune) *Pattern,
+	sort bool, tac bool, eventBox *util.EventBox) *Matcher {
 	partitions := util.Min(numPartitionsMultiplier*runtime.NumCPU(), maxPartitions)
 	return &Matcher{
-		cache:          cache,
 		patternBuilder: patternBuilder,
 		sort:           sort,
 		tac:            tac,
@@ -51,8 +48,7 @@ func NewMatcher(cache *ChunkCache, patternBuilder func([]rune) *Pattern,
 		reqBox:         util.NewEventBox(),
 		partitions:     partitions,
 		slab:           make([]*util.Slab, partitions),
-		mergerCache:    make(map[string]*Merger),
-		revision:       revision}
+		mergerCache:    make(map[string]*Merger)}
 }
 
 // Loop puts Matcher in action
@@ -62,13 +58,8 @@ func (m *Matcher) Loop() {
 	for {
 		var request MatchRequest
 
-		stop := false
 		m.reqBox.Wait(func(events *util.Events) {
-			for t, val := range *events {
-				if t == reqQuit {
-					stop = true
-					return
-				}
+			for _, val := range *events {
 				switch val := val.(type) {
 				case MatchRequest:
 					request = val
@@ -78,15 +69,11 @@ func (m *Matcher) Loop() {
 			}
 			events.Clear()
 		})
-		if stop {
-			break
-		}
 
-		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)
-			m.cache.Clear()
+			clearChunkCache()
 		}
 
 		// Restart search
@@ -153,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)
@@ -231,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
@@ -244,9 +231,5 @@ func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final
 	} else {
 		event = reqRetry
 	}
-	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, revision})
-}
-
-func (m *Matcher) Stop() {
-	m.reqBox.Set(reqQuit, nil)
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, clearCache})
 }

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 {

src/merger_test.go

@@ -23,10 +23,10 @@ func randResult() Result {
 }
 
 func TestEmptyMerger(t *testing.T) {
-	assert(t, EmptyMerger(0).Length() == 0, "Not empty")
-	assert(t, EmptyMerger(0).count == 0, "Invalid count")
-	assert(t, len(EmptyMerger(0).lists) == 0, "Invalid lists")
-	assert(t, len(EmptyMerger(0).merged) == 0, "Invalid merged list")
+	assert(t, EmptyMerger.Length() == 0, "Not empty")
+	assert(t, EmptyMerger.count == 0, "Invalid count")
+	assert(t, len(EmptyMerger.lists) == 0, "Invalid lists")
+	assert(t, len(EmptyMerger.merged) == 0, "Invalid merged list")
 }
 
 func buildLists(partiallySorted bool) ([][]Result, []Result) {
@@ -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))

src/options_no_pprof.go

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

src/options_pprof.go

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

src/options_pprof_test.go

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

src/options_test.go

@@ -2,7 +2,7 @@ package fzf
 
 import (
 	"fmt"
-	"os"
+	"io/ioutil"
 	"testing"
 
 	"github.com/junegunn/fzf/src/tui"
@@ -65,22 +65,9 @@ func TestDelimiterRegexRegex(t *testing.T) {
 	}
 }
 
-func TestDelimiterRegexRegexCaret(t *testing.T) {
-	delim := delimiterRegexp(`(^\s*|\s+)`)
-	tokens := Tokenize("foo  bar baz", delim)
-	if delim.str != nil ||
-		len(tokens) != 4 ||
-		tokens[0].text.ToString() != "" ||
-		tokens[1].text.ToString() != "foo  " ||
-		tokens[2].text.ToString() != "bar " ||
-		tokens[3].text.ToString() != "baz" {
-		t.Errorf("%s %d", tokens, len(tokens))
-	}
-}
-
 func TestSplitNth(t *testing.T) {
 	{
-		ranges, _ := splitNth("..")
+		ranges := splitNth("..")
 		if len(ranges) != 1 ||
 			ranges[0].begin != rangeEllipsis ||
 			ranges[0].end != rangeEllipsis {
@@ -88,7 +75,7 @@ func TestSplitNth(t *testing.T) {
 		}
 	}
 	{
-		ranges, _ := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2,2..-2,1..-1")
+		ranges := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2,2..-2,1..-1")
 		if len(ranges) != 10 ||
 			ranges[0].begin != rangeEllipsis || ranges[0].end != 3 ||
 			ranges[1].begin != rangeEllipsis || ranges[1].end != rangeEllipsis ||
@@ -137,7 +124,7 @@ func TestIrrelevantNth(t *testing.T) {
 }
 
 func TestParseKeys(t *testing.T) {
-	pairs, _ := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g,ctrl-alt-a,ALT-enter,alt-SPACE", "")
+	pairs := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g,ctrl-alt-a,ALT-enter,alt-SPACE", "")
 	checkEvent := func(e tui.Event, s string) {
 		if pairs[e] != s {
 			t.Errorf("%s != %s", pairs[e], s)
@@ -163,35 +150,35 @@ func TestParseKeys(t *testing.T) {
 	checkEvent(tui.AltKey(' '), "alt-SPACE")
 
 	// Synonyms
-	pairs, _ = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
+	pairs = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
 	if len(pairs) != 9 {
 		t.Error(9)
 	}
 	check(tui.CtrlM, "Return")
 	checkEvent(tui.Key(' '), "space")
 	check(tui.Tab, "tab")
-	check(tui.ShiftTab, "btab")
-	check(tui.Esc, "esc")
+	check(tui.BTab, "btab")
+	check(tui.ESC, "esc")
 	check(tui.Up, "up")
 	check(tui.Down, "down")
 	check(tui.Left, "left")
 	check(tui.Right, "right")
 
-	pairs, _ = parseKeyChords("Tab,Ctrl-I,PgUp,page-up,pgdn,Page-Down,Home,End,Alt-BS,Alt-BSpace,shift-left,shift-right,btab,shift-tab,return,Enter,bspace", "")
+	pairs = parseKeyChords("Tab,Ctrl-I,PgUp,page-up,pgdn,Page-Down,Home,End,Alt-BS,Alt-BSpace,shift-left,shift-right,btab,shift-tab,return,Enter,bspace", "")
 	if len(pairs) != 11 {
 		t.Error(11)
 	}
 	check(tui.Tab, "Ctrl-I")
-	check(tui.PageUp, "page-up")
-	check(tui.PageDown, "Page-Down")
+	check(tui.PgUp, "page-up")
+	check(tui.PgDn, "Page-Down")
 	check(tui.Home, "Home")
 	check(tui.End, "End")
-	check(tui.AltBackspace, "Alt-BSpace")
-	check(tui.ShiftLeft, "shift-left")
-	check(tui.ShiftRight, "shift-right")
-	check(tui.ShiftTab, "shift-tab")
+	check(tui.AltBS, "Alt-BSpace")
+	check(tui.SLeft, "shift-left")
+	check(tui.SRight, "shift-right")
+	check(tui.BTab, "shift-tab")
 	check(tui.CtrlM, "Enter")
-	check(tui.Backspace, "bspace")
+	check(tui.BSpace, "bspace")
 }
 
 func TestParseKeysWithComma(t *testing.T) {
@@ -206,40 +193,40 @@ func TestParseKeysWithComma(t *testing.T) {
 		}
 	}
 
-	pairs, _ := parseKeyChords(",", "")
+	pairs := parseKeyChords(",", "")
 	checkN(len(pairs), 1)
 	check(pairs, tui.Key(','), ",")
 
-	pairs, _ = parseKeyChords(",,a,b", "")
+	pairs = parseKeyChords(",,a,b", "")
 	checkN(len(pairs), 3)
 	check(pairs, tui.Key('a'), "a")
 	check(pairs, tui.Key('b'), "b")
 	check(pairs, tui.Key(','), ",")
 
-	pairs, _ = parseKeyChords("a,b,,", "")
+	pairs = parseKeyChords("a,b,,", "")
 	checkN(len(pairs), 3)
 	check(pairs, tui.Key('a'), "a")
 	check(pairs, tui.Key('b'), "b")
 	check(pairs, tui.Key(','), ",")
 
-	pairs, _ = parseKeyChords("a,,,b", "")
+	pairs = parseKeyChords("a,,,b", "")
 	checkN(len(pairs), 3)
 	check(pairs, tui.Key('a'), "a")
 	check(pairs, tui.Key('b'), "b")
 	check(pairs, tui.Key(','), ",")
 
-	pairs, _ = parseKeyChords("a,,,b,c", "")
+	pairs = parseKeyChords("a,,,b,c", "")
 	checkN(len(pairs), 4)
 	check(pairs, tui.Key('a'), "a")
 	check(pairs, tui.Key('b'), "b")
 	check(pairs, tui.Key('c'), "c")
 	check(pairs, tui.Key(','), ",")
 
-	pairs, _ = parseKeyChords(",,,", "")
+	pairs = parseKeyChords(",,,", "")
 	checkN(len(pairs), 1)
 	check(pairs, tui.Key(','), ",")
 
-	pairs, _ = parseKeyChords(",ALT-,,", "")
+	pairs = parseKeyChords(",ALT-,,", "")
 	checkN(len(pairs), 1)
 	check(pairs, tui.AltKey(','), "ALT-,")
 }
@@ -264,7 +251,7 @@ func TestBind(t *testing.T) {
 	check(tui.CtrlA.AsEvent(), "", actBeginningOfLine)
 	parseKeymap(keymap,
 		"ctrl-a:kill-line,ctrl-b:toggle-sort+up+down,c:page-up,alt-z:page-down,"+
-			"f1:execute(ls {+})+abort+execute(echo \n{+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
+			"f1:execute(ls {+})+abort+execute(echo {+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
 			"alt-a:execute-Multi@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};,"+
 			"x:Execute(foo+bar),X:execute/bar+baz/"+
 			",f1:+first,f1:+top"+
@@ -296,7 +283,7 @@ func TestBind(t *testing.T) {
 
 func TestColorSpec(t *testing.T) {
 	theme := tui.Dark256
-	dark, _ := parseTheme(theme, "dark")
+	dark := parseTheme(theme, "dark")
 	if *dark != *theme {
 		t.Errorf("colors should be equivalent")
 	}
@@ -304,7 +291,7 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("point should not be equivalent")
 	}
 
-	light, _ := parseTheme(theme, "dark,light")
+	light := parseTheme(theme, "dark,light")
 	if *light == *theme {
 		t.Errorf("should not be equivalent")
 	}
@@ -315,7 +302,7 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("point should not be equivalent")
 	}
 
-	customized, _ := parseTheme(theme, "fg:231,bg:232")
+	customized := parseTheme(theme, "fg:231,bg:232")
 	if customized.Fg.Color != 231 || customized.Bg.Color != 232 {
 		t.Errorf("color not customized")
 	}
@@ -328,7 +315,7 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("colors should now be equivalent: %v, %v", tui.Dark256, customized)
 	}
 
-	customized, _ = parseTheme(theme, "fg:231,dark,bg:232")
+	customized = parseTheme(theme, "fg:231,dark,bg:232")
 	if customized.Fg != tui.Dark256.Fg || customized.Bg == tui.Dark256.Bg {
 		t.Errorf("color not customized")
 	}
@@ -350,14 +337,14 @@ func TestDefaultCtrlNP(t *testing.T) {
 	check([]string{"--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
 	check([]string{"--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
 
-	f, _ := os.CreateTemp("", "fzf-history")
+	f, _ := ioutil.TempFile("", "fzf-history")
 	f.Close()
 	hist := "--history=" + f.Name()
 	check([]string{hist}, tui.CtrlN, actNextHistory)
-	check([]string{hist}, tui.CtrlP, actPrevHistory)
+	check([]string{hist}, tui.CtrlP, actPreviousHistory)
 
 	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
-	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlP, actPrevHistory)
+	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlP, actPreviousHistory)
 
 	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlN, actNextHistory)
 	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
@@ -453,6 +440,8 @@ func TestValidateSign(t *testing.T) {
 		{"😀", true},
 		{"", false},
 		{">>>", false},
+		{"\n", false},
+		{"\t", false},
 	}
 
 	for _, testCase := range testCases {
@@ -466,35 +455,3 @@ func TestValidateSign(t *testing.T) {
 		}
 	}
 }
-
-func TestParseSingleActionList(t *testing.T) {
-	actions, _ := parseSingleActionList("Execute@foo+bar,baz@+up+up+reload:down+down")
-	if len(actions) != 4 {
-		t.Errorf("Invalid number of actions parsed:%d", len(actions))
-	}
-	if actions[0].t != actExecute || actions[0].a != "foo+bar,baz" {
-		t.Errorf("Invalid action parsed: %v", actions[0])
-	}
-	if actions[1].t != actUp || actions[2].t != actUp {
-		t.Errorf("Invalid action parsed: %v / %v", actions[1], actions[2])
-	}
-	if actions[3].t != actReload || actions[3].a != "down+down" {
-		t.Errorf("Invalid action parsed: %v", actions[3])
-	}
-}
-
-func TestParseSingleActionListError(t *testing.T) {
-	_, err := parseSingleActionList("change-query(foobar)baz")
-	if err == nil {
-		t.Errorf("Failed to detect error")
-	}
-}
-
-func TestMaskActionContents(t *testing.T) {
-	original := ":execute((f)(o)(o)(b)(a)(r))+change-query@qu@ry@+up,x:reload:hello:world"
-	expected := ":execute                    +change-query       +up,x:reload            "
-	masked := maskActionContents(original)
-	if masked != expected {
-		t.Errorf("Not masked: %s", masked)
-	}
-}

src/pattern.go

@@ -51,7 +51,6 @@ type Pattern struct {
 	caseSensitive bool
 	normalize     bool
 	forward       bool
-	withPos       bool
 	text          []rune
 	termSets      []termSet
 	sortable      bool
@@ -60,18 +59,33 @@ type Pattern struct {
 	delimiter     Delimiter
 	nth           []Range
 	procFun       map[termType]algo.Algo
-	cache         *ChunkCache
 }
 
-var _splitRegex *regexp.Regexp
+var (
+	_patternCache map[string]*Pattern
+	_splitRegex   *regexp.Regexp
+	_cache        ChunkCache
+)
 
 func init() {
 	_splitRegex = regexp.MustCompile(" +")
+	clearPatternCache()
+	clearChunkCache()
+}
+
+func clearPatternCache() {
+	// We can uniquely identify the pattern for a given string since
+	// search mode and caseMode do not change while the program is running
+	_patternCache = make(map[string]*Pattern)
+}
+
+func clearChunkCache() {
+	_cache = NewChunkCache()
 }
 
 // BuildPattern builds Pattern object from the given arguments
-func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
-	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
+func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
+	cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
 
 	var asString string
 	if extended {
@@ -83,9 +97,7 @@ func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy boo
 		asString = string(runes)
 	}
 
-	// We can uniquely identify the pattern for a given string since
-	// search mode and caseMode do not change while the program is running
-	cached, found := patternCache[asString]
+	cached, found := _patternCache[asString]
 	if found {
 		return cached
 	}
@@ -133,14 +145,12 @@ func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy boo
 		caseSensitive: caseSensitive,
 		normalize:     normalize,
 		forward:       forward,
-		withPos:       withPos,
 		text:          []rune(asString),
 		termSets:      termSets,
 		sortable:      sortable,
 		cacheable:     cacheable,
 		nth:           nth,
 		delimiter:     delimiter,
-		cache:         cache,
 		procFun:       make(map[termType]algo.Algo)}
 
 	ptr.cacheKey = ptr.buildCacheKey()
@@ -150,19 +160,19 @@ func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy boo
 	ptr.procFun[termPrefix] = algo.PrefixMatch
 	ptr.procFun[termSuffix] = algo.SuffixMatch
 
-	patternCache[asString] = ptr
+	_patternCache[asString] = ptr
 	return ptr
 }
 
 func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet {
-	str = strings.ReplaceAll(str, "\\ ", "\t")
+	str = strings.Replace(str, "\\ ", "\t", -1)
 	tokens := _splitRegex.Split(str, -1)
 	sets := []termSet{}
 	set := termSet{}
 	switchSet := false
 	afterBar := false
 	for _, token := range tokens {
-		typ, inv, text := termFuzzy, false, strings.ReplaceAll(token, "\t", " ")
+		typ, inv, text := termFuzzy, false, strings.Replace(token, "\t", " ", -1)
 		lowerText := strings.ToLower(text)
 		caseSensitive := caseMode == CaseRespect ||
 			caseMode == CaseSmart && text != lowerText
@@ -197,10 +207,11 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 			// Flip exactness
 			if fuzzy && !inv {
 				typ = termExact
+				text = text[1:]
 			} else {
 				typ = termFuzzy
+				text = text[1:]
 			}
-			text = text[1:]
 		} else if strings.HasPrefix(text, "^") {
 			if typ == termSuffix {
 				typ = termEqual
@@ -270,18 +281,18 @@ func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []Result {
 	// ChunkCache: Exact match
 	cacheKey := p.CacheKey()
 	if p.cacheable {
-		if cached := p.cache.Lookup(chunk, cacheKey); cached != nil {
+		if cached := _cache.Lookup(chunk, cacheKey); cached != nil {
 			return cached
 		}
 	}
 
 	// Prefix/suffix cache
-	space := p.cache.Search(chunk, cacheKey)
+	space := _cache.Search(chunk, cacheKey)
 
 	matches := p.matchChunk(chunk, space, slab)
 
 	if p.cacheable {
-		p.cache.Add(chunk, cacheKey, matches)
+		_cache.Add(chunk, cacheKey, matches)
 	}
 	return matches
 }
@@ -291,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)
 			}
 		}

src/pattern_test.go

@@ -64,15 +64,10 @@ func TestParseTermsEmpty(t *testing.T) {
 	}
 }
 
-func buildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
-	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
-	return BuildPattern(NewChunkCache(), make(map[string]*Pattern),
-		fuzzy, fuzzyAlgo, extended, caseMode, normalize, forward,
-		withPos, cacheable, nth, delimiter, runes)
-}
-
 func TestExact(t *testing.T) {
-	pattern := buildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true,
+	defer clearPatternCache()
+	clearPatternCache()
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true,
 		[]Range{}, Delimiter{}, []rune("'abc"))
 	chars := util.ToChars([]byte("aabbcc abc"))
 	res, pos := algo.ExactMatchNaive(
@@ -86,7 +81,9 @@ func TestExact(t *testing.T) {
 }
 
 func TestEqual(t *testing.T) {
-	pattern := buildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("^AbC$"))
+	defer clearPatternCache()
+	clearPatternCache()
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("^AbC$"))
 
 	match := func(str string, sidxExpected int, eidxExpected int) {
 		chars := util.ToChars([]byte(str))
@@ -107,12 +104,19 @@ func TestEqual(t *testing.T) {
 }
 
 func TestCaseSensitivity(t *testing.T) {
-	pat1 := buildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
-	pat2 := buildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
-	pat3 := buildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
-	pat4 := buildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
-	pat5 := buildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
-	pat6 := buildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+	defer clearPatternCache()
+	clearPatternCache()
+	pat1 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
+	clearPatternCache()
+	pat2 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
+	clearPatternCache()
+	pat3 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
+	clearPatternCache()
+	pat4 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
+	clearPatternCache()
+	pat5 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("abc"))
+	clearPatternCache()
+	pat6 := BuildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, true, []Range{}, Delimiter{}, []rune("Abc"))
 
 	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
 		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
@@ -125,7 +129,7 @@ func TestCaseSensitivity(t *testing.T) {
 }
 
 func TestOrigTextAndTransformed(t *testing.T) {
-	pattern := buildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("jg"))
+	pattern := BuildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune("jg"))
 	tokens := Tokenize("junegunn", Delimiter{})
 	trans := Transform(tokens, []Range{{1, 1}})
 
@@ -159,13 +163,15 @@ func TestOrigTextAndTransformed(t *testing.T) {
 
 func TestCacheKey(t *testing.T) {
 	test := func(extended bool, patStr string, expected string, cacheable bool) {
-		pat := buildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune(patStr))
+		clearPatternCache()
+		pat := BuildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, false, true, true, []Range{}, Delimiter{}, []rune(patStr))
 		if pat.CacheKey() != expected {
 			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
 		}
 		if pat.cacheable != cacheable {
 			t.Errorf("Expected: %t, actual: %t (%s)", cacheable, pat.cacheable, patStr)
 		}
+		clearPatternCache()
 	}
 	test(false, "foo !bar", "foo !bar", true)
 	test(false, "foo | bar !baz", "foo | bar !baz", true)
@@ -181,13 +187,15 @@ func TestCacheKey(t *testing.T) {
 
 func TestCacheable(t *testing.T) {
 	test := func(fuzzy bool, str string, expected string, cacheable bool) {
-		pat := buildPattern(fuzzy, algo.FuzzyMatchV2, true, CaseSmart, true, true, false, true, []Range{}, Delimiter{}, []rune(str))
+		clearPatternCache()
+		pat := BuildPattern(fuzzy, algo.FuzzyMatchV2, true, CaseSmart, true, true, true, []Range{}, Delimiter{}, []rune(str))
 		if pat.CacheKey() != expected {
 			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
 		}
 		if cacheable != pat.cacheable {
 			t.Errorf("Invalid Pattern.cacheable for \"%s\": %v (expected: %v)", str, pat.cacheable, cacheable)
 		}
+		clearPatternCache()
 	}
 	test(true, "foo bar", "foo\tbar", true)
 	test(true, "foo 'bar", "foo\tbar", false)

src/protector/protector.go

@@ -1,6 +1,8 @@
-//go:build !openbsd
+// +build !openbsd
 
 package protector
 
 // Protect calls OS specific protections like pledge on OpenBSD
-func Protect() {}
+func Protect() {
+	return
+}

src/protector/protector_openbsd.go

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

src/reader.go

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

src/reader_test.go

@@ -10,10 +10,9 @@ import (
 func TestReadFromCommand(t *testing.T) {
 	strs := []string{}
 	eb := util.NewEventBox()
-	exec := util.NewExecutor("")
 	reader := NewReader(
 		func(s []byte) bool { strs = append(strs, string(s)); return true },
-		eb, exec, false, true)
+		eb, false, true)
 
 	reader.startEventPoller()
 
@@ -23,7 +22,7 @@ func TestReadFromCommand(t *testing.T) {
 	}
 
 	// Normal command
-	reader.fin(reader.readFromCommand(`echo abc&&echo def`, nil))
+	reader.fin(reader.readFromCommand(nil, `echo abc&&echo def`))
 	if len(strs) != 2 || strs[0] != "abc" || strs[1] != "def" {
 		t.Errorf("%s", strs)
 	}
@@ -48,7 +47,7 @@ func TestReadFromCommand(t *testing.T) {
 	reader.startEventPoller()
 
 	// Failing command
-	reader.fin(reader.readFromCommand(`no-such-command`, nil))
+	reader.fin(reader.readFromCommand(nil, `no-such-command`))
 	strs = []string{}
 	if len(strs) > 0 {
 		t.Errorf("%s", strs)

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:
@@ -80,7 +64,7 @@ func buildResult(item *Item, offsets []Offset, score int) Result {
 				if criterion == byBegin {
 					val = util.AsUint16(minEnd - whitePrefixLen)
 				} else {
-					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/int(item.TrimLength()+1))
+					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/int(item.TrimLength()))
 				}
 			}
 		}
@@ -138,9 +122,7 @@ func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme,
 		for i := off[0]; i < off[1]; i++ {
 			// Negative of 1-based index of itemColors
 			// - The extra -1 means highlighted
-			if cols[i] >= 0 {
-				cols[i] = cols[i]*-1 - 1
-			}
+			cols[i] = cols[i]*-1 - 1
 		}
 	}
 

src/result_others.go

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

src/result_test.go

@@ -1,3 +1,5 @@
+// +build !tcell
+
 package fzf
 
 import (
@@ -54,9 +56,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 +67,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,29 +100,12 @@ func TestResultRank(t *testing.T) {
 	}
 }
 
-func TestChunkTiebreak(t *testing.T) {
-	// FIXME global
-	sortCriteria = []criterion{byScore, byChunk}
-
-	score := 100
-	test := func(input string, offset Offset, chunk string) {
-		item := buildResult(withIndex(&Item{text: util.RunesToChars([]rune(input))}, 1), []Offset{offset}, score)
-		if !(item.points[3] == math.MaxUint16-uint16(score) && item.points[2] == uint16(len(chunk))) {
-			t.Error(item.points)
-		}
-	}
-	test("hello foobar goodbye", Offset{8, 9}, "foobar")
-	test("hello foobar goodbye", Offset{7, 18}, "foobar goodbye")
-	test("hello foobar goodbye", Offset{0, 1}, "hello")
-	test("hello foobar goodbye", Offset{5, 7}, "hello foobar") // TBD
-}
-
 func TestColorOffset(t *testing.T) {
 	// ------------ 20 ----  --  ----
 	//   ++++++++        ++++++++++
 	// --++++++++--    --++++++++++---
 
-	offsets := []Offset{{5, 15}, {10, 12}, {25, 35}}
+	offsets := []Offset{{5, 15}, {25, 35}}
 	item := Result{
 		item: &Item{
 			colors: &[]ansiOffset{

src/result_x86.go

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

src/server.go

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

src/terminal_test.go

@@ -12,22 +12,6 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )
 
-func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter, printsep string, forcePlus bool, query string, allItems []*Item) string {
-	replaced, _ := replacePlaceholder(replacePlaceholderParams{
-		template:   template,
-		stripAnsi:  stripAnsi,
-		delimiter:  delimiter,
-		printsep:   printsep,
-		forcePlus:  forcePlus,
-		query:      query,
-		allItems:   allItems,
-		lastAction: actBackwardDeleteCharEof,
-		prompt:     "prompt",
-		executor:   util.NewExecutor(""),
-	})
-	return replaced
-}
-
 func TestReplacePlaceholder(t *testing.T) {
 	item1 := newItem("  foo'bar \x1b[31mbaz\x1b[m")
 	items1 := []*Item{item1, item1}
@@ -68,90 +52,90 @@ func TestReplacePlaceholder(t *testing.T) {
 	*/
 
 	// {}, preserve ansi
-	result = replacePlaceholderTest("echo {}", false, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {}", false, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar \x1b[31mbaz\x1b[m{{.O}}")
 
 	// {}, strip ansi
-	result = replacePlaceholderTest("echo {}", true, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {}", true, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
 
 	// {}, with multiple items
-	result = replacePlaceholderTest("echo {}", true, Delimiter{}, printsep, false, "query", items2)
+	result = replacePlaceholder("echo {}", true, Delimiter{}, printsep, false, "query", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}")
 
 	// {..}, strip leading whitespaces, preserve ansi
-	result = replacePlaceholderTest("echo {..}", false, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {..}", false, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}foo{{.I}}bar \x1b[31mbaz\x1b[m{{.O}}")
 
 	// {..}, strip leading whitespaces, strip ansi
-	result = replacePlaceholderTest("echo {..}", true, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {..}", true, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}")
 
 	// {q}
-	result = replacePlaceholderTest("echo {} {q}", true, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {} {q}", true, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}} {{.O}}query{{.O}}")
 
 	// {q}, multiple items
-	result = replacePlaceholderTest("echo {+}{q}{+}", true, Delimiter{}, printsep, false, "query 'string'", items2)
+	result = replacePlaceholder("echo {+}{q}{+}", true, Delimiter{}, printsep, false, "query 'string'", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}{{.O}}query {{.I}}string{{.I}}{{.O}}{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}")
 
-	result = replacePlaceholderTest("echo {}{q}{}", true, Delimiter{}, printsep, false, "query 'string'", items2)
+	result = replacePlaceholder("echo {}{q}{}", true, Delimiter{}, printsep, false, "query 'string'", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}{{.O}}query {{.I}}string{{.I}}{{.O}}{{.O}}foo{{.I}}bar baz{{.O}}")
 
-	result = replacePlaceholderTest("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}bazfoo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}foo{{.I}}bar{{.O}}/{{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}}")
 
-	result = replacePlaceholderTest("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items2)
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}baz{{.O}}/{{.O}}foo{{.I}}bar{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}}")
 
-	result = replacePlaceholderTest("echo {+1}/{+2}/{+-1}/{+-2}/{+..}/{n.t}/\\{}/\\{1}/\\{q}/{+3}", true, Delimiter{}, printsep, false, "query", items2)
+	result = replacePlaceholder("echo {+1}/{+2}/{+-1}/{+-2}/{+..}/{n.t}/\\{}/\\{1}/\\{q}/{+3}", true, Delimiter{}, printsep, false, "query", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}} {{.O}}{{.O}}")
 
 	// forcePlus
-	result = replacePlaceholderTest("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, true, "query", items2)
+	result = replacePlaceholder("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, true, "query", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}} {{.O}}{{.O}}")
 
 	// Whitespace preserving flag with "'" delimiter
-	result = replacePlaceholderTest("echo {s1}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s1}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.O}}")
 
-	result = replacePlaceholderTest("echo {s2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}bar baz{{.O}}")
 
-	result = replacePlaceholderTest("echo {s}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
 
-	result = replacePlaceholderTest("echo {s..}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s..}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
 
 	// Whitespace preserving flag with regex delimiter
 	regex = regexp.MustCompile(`\w+`)
 
-	result = replacePlaceholderTest("echo {s1}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s1}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  {{.O}}")
 
-	result = replacePlaceholderTest("echo {s2}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s2}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}{{.I}}{{.O}}")
 
-	result = replacePlaceholderTest("echo {s3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {s3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}} {{.O}}")
 
 	// No match
-	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, nil})
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, nil})
 	check("echo /")
 
 	// No match, but with selections
-	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, item1})
+	result = replacePlaceholder("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, item1})
 	checkFormat("echo /{{.O}}  foo{{.I}}bar baz{{.O}}")
 
 	// String delimiter
-	result = replacePlaceholderTest("echo {}/{1}/{2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {}/{1}/{2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}foo{{.O}}/{{.O}}bar baz{{.O}}")
 
 	// Regex delimiter
 	regex = regexp.MustCompile("[oa]+")
 	// foo'bar baz
-	result = replacePlaceholderTest("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	result = replacePlaceholder("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}f{{.O}}/{{.O}}r b{{.O}}/{{.O}}{{.I}}bar b{{.O}}")
 
 	/*
@@ -171,6 +155,7 @@ func TestReplacePlaceholder(t *testing.T) {
 		newItem("7a 7b 7c 7d 7e 7f"),
 	}
 	stripAnsi := false
+	printsep = "\n"
 	forcePlus := false
 	query := "sample query"
 
@@ -213,23 +198,18 @@ func TestReplacePlaceholder(t *testing.T) {
 	// query flag is not removed after parsing, so it gets doubled
 	// while the double q is invalid, it is useful here for testing purposes
 	templateToOutput[`{q}`] = "{{.O}}" + query + "{{.O}}"
-	templateToOutput[`{fzf:query}`] = "{{.O}}" + query + "{{.O}}"
-	templateToOutput[`{fzf:action} {fzf:prompt}`] = "backward-delete-char-eof 'prompt'"
 
 	// IV. escaping placeholder
 	templateToOutput[`\{}`] = `{}`
-	templateToOutput[`\{q}`] = `{q}`
-	templateToOutput[`\{fzf:query}`] = `{fzf:query}`
-	templateToOutput[`\{fzf:action}`] = `{fzf:action}`
 	templateToOutput[`\{++}`] = `{++}`
 	templateToOutput[`{++}`] = templateToOutput[`{+}`]
 
 	for giveTemplate, wantOutput := range templateToOutput {
-		result = replacePlaceholderTest(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
+		result = replacePlaceholder(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
 		checkFormat(wantOutput)
 	}
 	for giveTemplate, wantOutput := range templateToFile {
-		path := replacePlaceholderTest(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
+		path := replacePlaceholder(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
 
 		data, err := readFile(path)
 		if err != nil {
@@ -246,7 +226,6 @@ func TestQuoteEntry(t *testing.T) {
 	unixStyle := quotes{``, `'`, `'\''`, `"`, `\`}
 	windowsStyle := quotes{`^`, `^"`, `'`, `\^"`, `\\`}
 	var effectiveStyle quotes
-	exec := util.NewExecutor("")
 
 	if util.IsWindows() {
 		effectiveStyle = windowsStyle
@@ -281,7 +260,7 @@ func TestQuoteEntry(t *testing.T) {
 	}
 
 	for input, expected := range tests {
-		escaped := exec.QuoteEntry(input)
+		escaped := quoteEntry(input)
 		expected = templateToString(expected, effectiveStyle)
 		if escaped != expected {
 			t.Errorf("Input: %s, expected: %s, actual %s", input, expected, escaped)
@@ -320,9 +299,9 @@ func TestUnixCommands(t *testing.T) {
 
 // purpose of this test is to demonstrate some shortcomings of fzf's templating system on Windows
 func TestWindowsCommands(t *testing.T) {
-	// XXX Deprecated
-	t.SkipNow()
-
+	if !util.IsWindows() {
+		t.SkipNow()
+	}
 	tests := []testCase{
 		// reference: give{template, query, items}, want{output OR match}
 
@@ -442,10 +421,10 @@ func TestPowershellCommands(t *testing.T) {
 }
 
 /*
-Test typical valid placeholders and parsing of them.
+	Test typical valid placeholders and parsing of them.
 
-Also since the parser assumes the input is matched with `placeholder` regex,
-the regex is tested here as well.
+	Also since the parser assumes the input is matched with `placeholder` regex,
+	the regex is tested here as well.
 */
 func TestParsePlaceholder(t *testing.T) {
 	// give, want pairs
@@ -584,7 +563,7 @@ func testCommands(t *testing.T, tests []testCase) {
 
 	// evaluate the test cases
 	for idx, test := range tests {
-		gotOutput := replacePlaceholderTest(
+		gotOutput := replacePlaceholder(
 			test.give.template, stripAnsi, delimiter, printsep, forcePlus,
 			test.give.query,
 			test.give.allItems)
@@ -626,7 +605,7 @@ func (flags placeholderFlags) encodePlaceholder() string {
 	if flags.file {
 		encoded += "f"
 	}
-	if flags.forceUpdate { // FIXME
+	if flags.query {
 		encoded += "q"
 	}
 	return encoded

src/terminal_unix.go

@@ -1,13 +1,12 @@
-//go:build !windows
+// +build !windows
 
 package fzf
 
 import (
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
-
-	"golang.org/x/sys/unix"
 )
 
 func notifyOnResize(resizeChan chan<- os.Signal) {
@@ -15,14 +14,13 @@ func notifyOnResize(resizeChan chan<- os.Signal) {
 }
 
 func notifyStop(p *os.Process) {
-	pid := p.Pid
-	pgid, err := unix.Getpgid(pid)
-	if err == nil {
-		pid = pgid * -1
-	}
-	unix.Kill(pid, syscall.SIGSTOP)
+	p.Signal(syscall.SIGSTOP)
 }
 
 func notifyOnCont(resizeChan chan<- os.Signal) {
 	signal.Notify(resizeChan, syscall.SIGCONT)
 }
+
+func quoteEntry(entry string) string {
+	return "'" + strings.Replace(entry, "'", "'\\''", -1) + "'"
+}

src/terminal_windows.go

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

src/tokenizer.go

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

src/tokenizer_test.go

@@ -71,14 +71,14 @@ func TestTransform(t *testing.T) {
 	{
 		tokens := Tokenize(input, Delimiter{})
 		{
-			ranges, _ := splitNth("1,2,3")
+			ranges := splitNth("1,2,3")
 			tx := Transform(tokens, ranges)
 			if joinTokens(tx) != "abc:  def:  ghi:  " {
 				t.Errorf("%s", tx)
 			}
 		}
 		{
-			ranges, _ := splitNth("1..2,3,2..,1")
+			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
 			if string(joinTokens(tx)) != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
 				len(tx) != 4 ||
@@ -93,7 +93,7 @@ func TestTransform(t *testing.T) {
 	{
 		tokens := Tokenize(input, delimiterRegexp(":"))
 		{
-			ranges, _ := splitNth("1..2,3,2..,1")
+			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
 			if joinTokens(tx) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
 				len(tx) != 4 ||
@@ -108,6 +108,5 @@ func TestTransform(t *testing.T) {
 }
 
 func TestTransformIndexOutOfBounds(t *testing.T) {
-	s, _ := splitNth("1")
-	Transform([]Token{}, s)
+	Transform([]Token{}, splitNth("1"))
 }

src/tui/dummy.go

@@ -1,4 +1,6 @@
-//go:build !tcell && !windows
+// +build !ncurses
+// +build !tcell
+// +build !windows
 
 package tui
 
@@ -8,41 +10,32 @@ func HasFullscreenRenderer() bool {
 	return false
 }
 
-var DefaultBorderShape = 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() error                        { return nil }
-func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
-func (r *FullscreenRenderer) Pause(bool)                         {}
-func (r *FullscreenRenderer) Resume(bool, bool)                  {}
-func (r *FullscreenRenderer) PassThrough(string)                 {}
-func (r *FullscreenRenderer) Clear()                             {}
-func (r *FullscreenRenderer) NeedScrollbarRedraw() bool          { return false }
-func (r *FullscreenRenderer) ShouldEmitResizeEvent() bool        { return false }
-func (r *FullscreenRenderer) Refresh()                           {}
-func (r *FullscreenRenderer) Close()                             {}
-func (r *FullscreenRenderer) Size() TermSize                     { return TermSize{} }
+func (r *FullscreenRenderer) Init()             {}
+func (r *FullscreenRenderer) Pause(bool)        {}
+func (r *FullscreenRenderer) Resume(bool, bool) {}
+func (r *FullscreenRenderer) Clear()            {}
+func (r *FullscreenRenderer) Refresh()          {}
+func (r *FullscreenRenderer) Close()            {}
 
 func (r *FullscreenRenderer) GetChar() Event { return Event{} }
-func (r *FullscreenRenderer) Top() int       { return 0 }
 func (r *FullscreenRenderer) MaxX() int      { return 0 }
 func (r *FullscreenRenderer) MaxY() int      { return 0 }
 

src/tui/eventtype_string.go

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

src/tui/light.go

@@ -2,7 +2,6 @@ package tui
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"os"
 	"regexp"
@@ -11,7 +10,7 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"github.com/junegunn/fzf/src/util"
+	"github.com/mattn/go-runewidth"
 	"github.com/rivo/uniseg"
 
 	"golang.org/x/term"
@@ -24,39 +23,29 @@ const (
 	defaultEscDelay = 100
 	escPollInterval = 5
 	offsetPollTries = 10
-	maxInputBuffer  = 1024 * 1024
+	maxInputBuffer  = 10 * 1024
 )
 
 const consoleDevice string = "/dev/tty"
 
-var offsetRegexp = regexp.MustCompile("(.*)\x1b\\[([0-9]+);([0-9]+)R")
-var offsetRegexpBegin = regexp.MustCompile("^\x1b\\[[0-9]+;[0-9]+R")
-
-func (r *LightRenderer) PassThrough(str string) {
-	r.queued.WriteString("\x1b7" + str + "\x1b8")
-}
+var offsetRegexp *regexp.Regexp = regexp.MustCompile("(.*)\x1b\\[([0-9]+);([0-9]+)R")
+var offsetRegexpBegin *regexp.Regexp = regexp.MustCompile("^\x1b\\[[0-9]+;[0-9]+R")
 
 func (r *LightRenderer) stderr(str string) {
-	r.stderrInternal(str, true, "")
+	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)
 			}
 		}
@@ -65,30 +54,26 @@ 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() {
 	if r.queued.Len() > 0 {
-		fmt.Fprint(r.ttyout, "\x1b[?7l\x1b[?25l"+r.queued.String()+"\x1b[?25h\x1b[?7h")
+		fmt.Fprint(os.Stderr, r.queued.String())
 		r.queued.Reset()
 	}
 }
 
 // Light renderer
 type LightRenderer struct {
-	closed        *util.AtomicBool
 	theme         *ColorTheme
 	mouse         bool
 	forceBlack    bool
 	clearOnExit   bool
 	prevDownTime  time.Time
-	clicks        [][2]int
+	clickY        []int
 	ttyin         *os.File
-	ttyout        *os.File
 	buffer        []byte
 	origState     *term.State
 	width         int
@@ -127,29 +112,19 @@ type LightWindow struct {
 	bg       Color
 }
 
-func NewLightRenderer(theme *ColorTheme, forceBlack bool, mouse bool, tabstop int, clearOnExit bool, fullscreen bool, maxHeightFunc func(int) int) (Renderer, error) {
-	in, err := openTtyIn()
-	if err != nil {
-		return nil, err
-	}
-	out, err := openTtyOut()
-	if err != nil {
-		out = os.Stderr
-	}
+func NewLightRenderer(theme *ColorTheme, forceBlack bool, mouse bool, tabstop int, clearOnExit bool, fullscreen bool, maxHeightFunc func(int) int) Renderer {
 	r := LightRenderer{
-		closed:        util.NewAtomicBool(false),
 		theme:         theme,
 		forceBlack:    forceBlack,
 		mouse:         mouse,
 		clearOnExit:   clearOnExit,
-		ttyin:         in,
-		ttyout:        out,
+		ttyin:         openTtyIn(),
 		yoffset:       0,
 		tabstop:       tabstop,
 		fullscreen:    fullscreen,
 		upOneLine:     false,
 		maxHeightFunc: maxHeightFunc}
-	return &r, nil
+	return &r
 }
 
 func repeat(r rune, times int) string {
@@ -167,11 +142,11 @@ func atoi(s string, defaultValue int) int {
 	return value
 }
 
-func (r *LightRenderer) Init() error {
+func (r *LightRenderer) Init() {
 	r.escDelay = atoi(os.Getenv("ESCDELAY"), defaultEscDelay)
 
 	if err := r.initPlatform(); err != nil {
-		return err
+		errorExit(err.Error())
 	}
 	r.updateTerminalSize()
 	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
@@ -199,7 +174,9 @@ func (r *LightRenderer) Init() error {
 		}
 	}
 
-	r.enableMouse()
+	if r.mouse {
+		r.csi("?1000h")
+	}
 	r.csi(fmt.Sprintf("%dA", r.MaxY()-1))
 	r.csi("G")
 	r.csi("K")
@@ -209,11 +186,6 @@ func (r *LightRenderer) Init() error {
 	if !r.fullscreen && r.mouse {
 		r.yoffset, _ = r.findOffset()
 	}
-	return nil
-}
-
-func (r *LightRenderer) Resize(maxHeightFunc func(int) int) {
-	r.maxHeightFunc = maxHeightFunc
 }
 
 func (r *LightRenderer) makeSpace() {
@@ -248,20 +220,19 @@ func getEnv(name string, defaultValue int) int {
 	return atoi(env, defaultValue)
 }
 
-func (r *LightRenderer) getBytes() ([]byte, error) {
-	bytes, err := r.getBytesInternal(r.buffer, false)
-	return bytes, err
+func (r *LightRenderer) getBytes() []byte {
+	return r.getBytesInternal(r.buffer, false)
 }
 
-func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) ([]byte, error) {
+func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
 	c, ok := r.getch(nonblock)
 	if !nonblock && !ok {
 		r.Close()
-		return nil, errors.New("failed to read " + consoleDevice)
+		errorExit("Failed to read " + consoleDevice)
 	}
 
 	retries := 0
-	if c == Esc.Int() || nonblock {
+	if c == ESC.Int() || nonblock {
 		retries = r.escDelay / escPollInterval
 	}
 	buffer = append(buffer, byte(c))
@@ -276,7 +247,7 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) ([]byte,
 				continue
 			}
 			break
-		} else if c == Esc.Int() && pc != c {
+		} else if c == ESC.Int() && pc != c {
 			retries = r.escDelay / escPollInterval
 		} else {
 			retries = 0
@@ -288,23 +259,19 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) ([]byte,
 		// so terminate fzf immediately.
 		if len(buffer) > maxInputBuffer {
 			r.Close()
-			return nil, fmt.Errorf("input buffer overflow (%d): %v", len(buffer), buffer)
+			panic(fmt.Sprintf("Input buffer overflow (%d): %v", len(buffer), buffer))
 		}
 	}
 
-	return buffer, nil
+	return buffer
 }
 
 func (r *LightRenderer) GetChar() Event {
-	var err error
 	if len(r.buffer) == 0 {
-		r.buffer, err = r.getBytes()
-		if err != nil {
-			return Event{Fatal, 0, nil}
-		}
+		r.buffer = r.getBytes()
 	}
 	if len(r.buffer) == 0 {
-		return Event{Fatal, 0, nil}
+		panic("Empty buffer")
 	}
 
 	sz := 1
@@ -320,7 +287,7 @@ func (r *LightRenderer) GetChar() Event {
 	case CtrlQ.Byte():
 		return Event{CtrlQ, 0, nil}
 	case 127:
-		return Event{Backspace, 0, nil}
+		return Event{BSpace, 0, nil}
 	case 0:
 		return Event{CtrlSpace, 0, nil}
 	case 28:
@@ -331,13 +298,11 @@ func (r *LightRenderer) GetChar() Event {
 		return Event{CtrlCaret, 0, nil}
 	case 31:
 		return Event{CtrlSlash, 0, nil}
-	case Esc.Byte():
+	case ESC.Byte():
 		ev := r.escSequence(&sz)
 		// Second chance
 		if ev.Type == Invalid {
-			if r.buffer, err = r.getBytes(); err != nil {
-				return Event{Fatal, 0, nil}
-			}
+			r.buffer = r.getBytes()
 			ev = r.escSequence(&sz)
 		}
 		return ev
@@ -349,7 +314,7 @@ func (r *LightRenderer) GetChar() Event {
 	}
 	char, rsz := utf8.DecodeRune(r.buffer)
 	if char == utf8.RuneError {
-		return Event{Esc, 0, nil}
+		return Event{ESC, 0, nil}
 	}
 	sz = rsz
 	return Event{Rune, char, nil}
@@ -357,7 +322,7 @@ func (r *LightRenderer) GetChar() Event {
 
 func (r *LightRenderer) escSequence(sz *int) Event {
 	if len(r.buffer) < 2 {
-		return Event{Esc, 0, nil}
+		return Event{ESC, 0, nil}
 	}
 
 	loc := offsetRegexpBegin.FindIndex(r.buffer)
@@ -371,15 +336,15 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 		return CtrlAltKey(rune(r.buffer[1] + 'a' - 1))
 	}
 	alt := false
-	if len(r.buffer) > 2 && r.buffer[1] == Esc.Byte() {
+	if len(r.buffer) > 2 && r.buffer[1] == ESC.Byte() {
 		r.buffer = r.buffer[1:]
 		alt = true
 	}
 	switch r.buffer[1] {
-	case Esc.Byte():
-		return Event{Esc, 0, nil}
+	case ESC.Byte():
+		return Event{ESC, 0, nil}
 	case 127:
-		return Event{AltBackspace, 0, nil}
+		return Event{AltBS, 0, nil}
 	case '[', 'O':
 		if len(r.buffer) < 3 {
 			return Event{Invalid, 0, nil}
@@ -408,12 +373,12 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 			}
 			return Event{Up, 0, nil}
 		case 'Z':
-			return Event{ShiftTab, 0, nil}
+			return Event{BTab, 0, nil}
 		case 'H':
 			return Event{Home, 0, nil}
 		case 'F':
 			return Event{End, 0, nil}
-		case '<':
+		case 'M':
 			return r.mouseSequence(sz)
 		case 'P':
 			return Event{F1, 0, nil}
@@ -423,7 +388,7 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 			return Event{F3, 0, nil}
 		case 'S':
 			return Event{F4, 0, nil}
-		case '1', '2', '3', '4', '5', '6', '7', '8':
+		case '1', '2', '3', '4', '5', '6':
 			if len(r.buffer) < 4 {
 				return Event{Invalid, 0, nil}
 			}
@@ -455,29 +420,13 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 				}
 				return Event{Invalid, 0, nil} // INS
 			case '3':
-				if r.buffer[3] == '~' {
-					return Event{Delete, 0, nil}
-				}
-				if len(r.buffer) == 6 && r.buffer[5] == '~' {
-					*sz = 6
-					switch r.buffer[4] {
-					case '5':
-						return Event{CtrlDelete, 0, nil}
-					case '2':
-						return Event{ShiftDelete, 0, nil}
-					}
-				}
-				return Event{Invalid, 0, nil}
+				return Event{Del, 0, nil}
 			case '4':
 				return Event{End, 0, nil}
 			case '5':
-				return Event{PageUp, 0, nil}
+				return Event{PgUp, 0, nil}
 			case '6':
-				return Event{PageDown, 0, nil}
-			case '7':
-				return Event{Home, 0, nil}
-			case '8':
-				return Event{End, 0, nil}
+				return Event{PgDn, 0, nil}
 			case '1':
 				switch r.buffer[3] {
 				case '~':
@@ -511,29 +460,16 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 					}
 					*sz = 6
 					switch r.buffer[4] {
-					case '1', '2', '3', '4', '5':
-						//                   Kitty      iTerm2     WezTerm
-						// SHIFT-ARROW       "\e[1;2D"
-						// ALT-SHIFT-ARROW   "\e[1;4D"  "\e[1;10D" "\e[1;4D"
-						// CTRL-SHIFT-ARROW  "\e[1;6D"             N/A
-						// CMD-SHIFT-ARROW   "\e[1;10D" N/A        N/A ("\e[1;2D")
+					case '1', '2', '3', '5':
 						alt := r.buffer[4] == '3'
+						altShift := r.buffer[4] == '1' && r.buffer[5] == '0'
 						char := r.buffer[5]
-						altShift := false
-						if r.buffer[4] == '1' && r.buffer[5] == '0' {
-							altShift = true
+						if altShift {
 							if len(r.buffer) < 7 {
 								return Event{Invalid, 0, nil}
 							}
 							*sz = 7
 							char = r.buffer[6]
-						} else if r.buffer[4] == '4' {
-							altShift = true
-							if len(r.buffer) < 6 {
-								return Event{Invalid, 0, nil}
-							}
-							*sz = 6
-							char = r.buffer[5]
 						}
 						switch char {
 						case 'A':
@@ -541,33 +477,33 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 								return Event{AltUp, 0, nil}
 							}
 							if altShift {
-								return Event{AltShiftUp, 0, nil}
+								return Event{AltSUp, 0, nil}
 							}
-							return Event{ShiftUp, 0, nil}
+							return Event{SUp, 0, nil}
 						case 'B':
 							if alt {
 								return Event{AltDown, 0, nil}
 							}
 							if altShift {
-								return Event{AltShiftDown, 0, nil}
+								return Event{AltSDown, 0, nil}
 							}
-							return Event{ShiftDown, 0, nil}
+							return Event{SDown, 0, nil}
 						case 'C':
 							if alt {
 								return Event{AltRight, 0, nil}
 							}
 							if altShift {
-								return Event{AltShiftRight, 0, nil}
+								return Event{AltSRight, 0, nil}
 							}
-							return Event{ShiftRight, 0, nil}
+							return Event{SRight, 0, nil}
 						case 'D':
 							if alt {
 								return Event{AltLeft, 0, nil}
 							}
 							if altShift {
-								return Event{AltShiftLeft, 0, nil}
+								return Event{AltSLeft, 0, nil}
 							}
-							return Event{ShiftLeft, 0, nil}
+							return Event{SLeft, 0, nil}
 						}
 					} // r.buffer[4]
 				} // r.buffer[3]
@@ -583,79 +519,47 @@ func (r *LightRenderer) escSequence(sz *int) Event {
 	return Event{Invalid, 0, nil}
 }
 
-// https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
 func (r *LightRenderer) mouseSequence(sz *int) Event {
-	// "\e[<0;0;0M"
-	if len(r.buffer) < 9 || !r.mouse {
+	if len(r.buffer) < 6 || !r.mouse {
 		return Event{Invalid, 0, nil}
 	}
-
-	rest := r.buffer[*sz:]
-	end := bytes.IndexAny(rest, "mM")
-	if end == -1 {
-		return Event{Invalid, 0, nil}
-	}
-
-	elems := strings.SplitN(string(rest[:end]), ";", 3)
-	if len(elems) != 3 {
-		return Event{Invalid, 0, nil}
-	}
-
-	t := atoi(elems[0], -1)
-	x := atoi(elems[1], -1) - 1
-	y := atoi(elems[2], -1) - 1 - r.yoffset
-	if t < 0 || x < 0 {
-		return Event{Invalid, 0, nil}
-	}
-	*sz += end + 1
-
-	down := rest[end] == 'M'
-
-	scroll := 0
-	if t >= 64 {
-		t -= 64
-		if t&0b1 == 1 {
-			scroll = -1
+	*sz = 6
+	switch r.buffer[3] {
+	case 32, 34, 36, 40, 48, // mouse-down / shift / cmd / ctrl
+		35, 39, 43, 51: // mouse-up / shift / cmd / ctrl
+		mod := r.buffer[3] >= 36
+		left := r.buffer[3] == 32
+		down := r.buffer[3]%2 == 0
+		x := int(r.buffer[4] - 33)
+		y := int(r.buffer[5]-33) - r.yoffset
+		double := false
+		if down {
+			now := time.Now()
+			if !left { // Right double click is not allowed
+				r.clickY = []int{}
+			} else if now.Sub(r.prevDownTime) < doubleClickDuration {
+				r.clickY = append(r.clickY, y)
+			} else {
+				r.clickY = []int{y}
+			}
+			r.prevDownTime = now
 		} else {
-			scroll = 1
-		}
-	}
-
-	// middle := t & 0b1
-	left := t&0b11 == 0
-
-	// shift := t & 0b100
-	// ctrl := t & 0b1000
-	mod := t&0b1100 > 0
-
-	drag := t&0b100000 > 0
-
-	if scroll != 0 {
-		return Event{Mouse, 0, &MouseEvent{y, x, scroll, false, false, false, mod}}
-	}
-
-	double := false
-	if down && !drag {
-		now := time.Now()
-		if !left { // Right double click is not allowed
-			r.clicks = [][2]int{}
-		} else if now.Sub(r.prevDownTime) < doubleClickDuration {
-			r.clicks = append(r.clicks, [2]int{x, y})
-		} else {
-			r.clicks = [][2]int{{x, y}}
-		}
-		r.prevDownTime = now
-	} else {
-		n := len(r.clicks)
-		if len(r.clicks) > 1 && r.clicks[n-2][0] == r.clicks[n-1][0] && r.clicks[n-2][1] == r.clicks[n-1][1] &&
-			time.Since(r.prevDownTime) < doubleClickDuration {
-			double = true
-			if double {
-				r.clicks = [][2]int{}
+			if len(r.clickY) > 1 && r.clickY[0] == r.clickY[1] &&
+				time.Since(r.prevDownTime) < doubleClickDuration {
+				double = true
 			}
 		}
+
+		return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
+	case 96, 100, 104, 112, // scroll-up / shift / cmd / ctrl
+		97, 101, 105, 113: // scroll-down / shift / cmd / ctrl
+		mod := r.buffer[3] >= 100
+		s := 1 - int(r.buffer[3]%2)*2
+		x := int(r.buffer[4] - 33)
+		y := int(r.buffer[5]-33) - r.yoffset
+		return Event{Mouse, 0, &MouseEvent{y, x, s, false, false, false, mod}}
 	}
-	return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
+	return Event{Invalid, 0, nil}
 }
 
 func (r *LightRenderer) smcup() {
@@ -667,7 +571,6 @@ func (r *LightRenderer) rmcup() {
 }
 
 func (r *LightRenderer) Pause(clear bool) {
-	r.disableMouse()
 	r.restoreTerminal()
 	if clear {
 		if r.fullscreen {
@@ -680,22 +583,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 {
@@ -704,13 +591,12 @@ 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.mouse = false
 	}
 }
@@ -725,14 +611,6 @@ func (r *LightRenderer) Clear() {
 	r.flush()
 }
 
-func (r *LightRenderer) NeedScrollbarRedraw() bool {
-	return false
-}
-
-func (r *LightRenderer) ShouldEmitResizeEvent() bool {
-	return false
-}
-
 func (r *LightRenderer) RefreshWindows(windows []Window) {
 	r.flush()
 }
@@ -756,15 +634,12 @@ func (r *LightRenderer) Close() {
 	} else if !r.fullscreen {
 		r.csi("u")
 	}
-	r.disableMouse()
+	if r.mouse {
+		r.csi("?1000l")
+	}
 	r.flush()
 	r.closePlatform()
 	r.restoreTerminal()
-	r.closed.Set(true)
-}
-
-func (r *LightRenderer) Top() int {
-	return r.yoffset
 }
 
 func (r *LightRenderer) MaxX() int {
@@ -772,9 +647,6 @@ func (r *LightRenderer) MaxX() int {
 }
 
 func (r *LightRenderer) MaxY() int {
-	if r.height == 0 {
-		r.updateTerminalSize()
-	}
 	return r.height
 }
 
@@ -798,42 +670,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) DrawBorder() {
-	w.drawBorder(false)
-}
-
-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, BorderThinBlock, 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)
 	}
 }
@@ -843,72 +698,60 @@ func (w *LightWindow) drawBorderHorizontal(top, bottom bool) {
 	if w.preview {
 		color = ColPreviewBorder
 	}
-	hw := 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))
 	}
 }
 
 func (w *LightWindow) drawBorderVertical(left, right bool) {
-	vw := runeWidth(w.border.left)
+	width := w.width - 2
+	if !left || !right {
+		width++
+	}
 	color := ColBorder
 	if w.preview {
 		color = ColPreviewBorder
 	}
 	for y := 0; y < w.height; y++ {
+		w.Move(y, 0)
 		if left {
-			w.Move(y, 0)
-			w.CPrint(color, string(w.border.left))
-			w.CPrint(color, " ") // Margin
+			w.CPrint(color, string(w.border.vertical))
 		}
+		w.CPrint(color, repeat(' ', width))
 		if right {
-			w.Move(y, w.width-vw-1)
-			w.CPrint(color, " ") // Margin
-			w.CPrint(color, string(w.border.right))
+			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(w.border.top)
-	tcw := runeWidth(w.border.topLeft) + runeWidth(w.border.topRight)
-	bcw := runeWidth(w.border.bottomLeft) + runeWidth(w.border.bottomRight)
-	rem := (w.width - tcw) % hw
-	w.CPrint(color, string(w.border.topLeft)+repeat(w.border.top, (w.width-tcw)/hw)+repeat(' ', rem)+string(w.border.topRight))
-	if !onlyHorizontal {
-		vw := runeWidth(w.border.left)
-		for y := 1; y < w.height-1; y++ {
-			w.Move(y, 0)
-			w.CPrint(color, string(w.border.left))
-			w.CPrint(color, " ") // Margin
-
-			w.Move(y, w.width-vw-1)
-			w.CPrint(color, " ") // Margin
-			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 {
@@ -984,9 +827,6 @@ func attrCodes(attr Attr) []string {
 	if (attr & Reverse) > 0 {
 		codes = append(codes, "7")
 	}
-	if (attr & StrikeThrough) > 0 {
-		codes = append(codes, "9")
-	}
 	return codes
 }
 
@@ -1014,10 +854,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) {
@@ -1025,21 +865,20 @@ func (w *LightWindow) Print(text string) {
 }
 
 func cleanse(str string) string {
-	return strings.ReplaceAll(str, "\x1b", "")
+	return strings.Replace(str, "\x1b", "", -1)
 }
 
 func (w *LightWindow) CPrint(pair ColorPair, text string) {
-	_, 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 {
@@ -1059,10 +898,8 @@ 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 = uniseg.StringWidth(str)
+			w = runewidth.StringWidth(str)
 		}
 		width += w
 
@@ -1079,12 +916,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
@@ -1094,7 +931,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()
 			}
 		}
 	}
@@ -1103,26 +940,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 {
@@ -1133,29 +966,22 @@ 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() {
-	if w.posy < w.height {
-		w.MoveAndClear(w.posy, w.posx)
-	}
+	w.MoveAndClear(w.posy, w.posx)
 	for y := w.posy + 1; y < w.height; y++ {
 		w.MoveAndClear(y, 0)
 	}
 }
 
 func (w *LightWindow) Erase() {
-	w.DrawBorder()
-	w.Move(0, 0)
-	w.FinishFill()
+	w.drawBorder()
+	// We don't erase the window here to avoid flickering during scroll
 	w.Move(0, 0)
 }
-
-func (w *LightWindow) EraseMaybe() bool {
-	return false
-}

src/tui/light_unix.go

@@ -1,27 +1,18 @@
-//go:build !windows
+// +build !windows
 
 package tui
 
 import (
-	"errors"
+	"fmt"
 	"os"
 	"os/exec"
 	"strings"
-	"sync"
 	"syscall"
 
 	"github.com/junegunn/fzf/src/util"
-	"golang.org/x/sys/unix"
 	"golang.org/x/term"
 )
 
-var (
-	tty    string
-	ttyin  *os.File
-	ttyout *os.File
-	mutex  sync.Mutex
-)
-
 func IsLightRendererSupported() bool {
 	return true
 }
@@ -56,48 +47,19 @@ func (r *LightRenderer) closePlatform() {
 	// NOOP
 }
 
-func openTty(mode int) (*os.File, error) {
-	in, err := os.OpenFile(consoleDevice, mode, 0)
+func openTtyIn() *os.File {
+	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
 	if err != nil {
-		if len(tty) == 0 {
-			tty = ttyname()
-		}
+		tty := ttyname()
 		if len(tty) > 0 {
-			if in, err := os.OpenFile(tty, mode, 0); err == nil {
-				return in, nil
+			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
+				return in
 			}
 		}
-		return nil, errors.New("failed to open " + consoleDevice)
+		fmt.Fprintln(os.Stderr, "Failed to open "+consoleDevice)
+		os.Exit(2)
 	}
-	return in, nil
-}
-
-func openTtyIn() (*os.File, error) {
-	mutex.Lock()
-	defer mutex.Unlock()
-
-	if ttyin != nil {
-		return ttyin, nil
-	}
-	in, err := openTty(syscall.O_RDONLY)
-	if err == nil {
-		ttyin = in
-	}
-	return in, err
-}
-
-func openTtyOut() (*os.File, error) {
-	mutex.Lock()
-	defer mutex.Unlock()
-
-	if ttyout != nil {
-		return ttyout, nil
-	}
-	out, err := openTty(syscall.O_WRONLY)
-	if err == nil {
-		ttyout = out
-	}
-	return out, err
+	return in
 }
 
 func (r *LightRenderer) setupTerminal() {
@@ -123,14 +85,9 @@ func (r *LightRenderer) updateTerminalSize() {
 func (r *LightRenderer) findOffset() (row int, col int) {
 	r.csi("6n")
 	r.flush()
-	var err error
 	bytes := []byte{}
 	for tries := 0; tries < offsetPollTries; tries++ {
-		bytes, err = r.getBytesInternal(bytes, tries > 0)
-		if err != nil {
-			return -1, -1
-		}
-
+		bytes = r.getBytesInternal(bytes, tries > 0)
 		offsets := offsetRegexp.FindSubmatch(bytes)
 		if len(offsets) > 3 {
 			// Add anything we skipped over to the input buffer
@@ -151,11 +108,3 @@ func (r *LightRenderer) getch(nonblock bool) (int, bool) {
 	}
 	return int(b[0]), true
 }
-
-func (r *LightRenderer) Size() TermSize {
-	ws, err := unix.IoctlGetWinsize(int(r.ttyin.Fd()), unix.TIOCGWINSZ)
-	if err != nil {
-		return TermSize{}
-	}
-	return TermSize{int(ws.Row), int(ws.Col), int(ws.Xpixel), int(ws.Ypixel)}
-}

src/tui/light_windows.go

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

src/tui/tcell.go

@@ -1,4 +1,4 @@
-//go:build tcell || windows
+// +build tcell windows
 
 package tui
 
@@ -6,9 +6,12 @@ import (
 	"os"
 	"time"
 
-	"github.com/gdamore/tcell/v2"
-	"github.com/junegunn/fzf/src/util"
+	"runtime"
 
+	"github.com/gdamore/tcell"
+	"github.com/gdamore/tcell/encoding"
+
+	"github.com/mattn/go-runewidth"
 	"github.com/rivo/uniseg"
 )
 
@@ -16,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
@@ -74,6 +63,8 @@ func (w *TcellWindow) Refresh() {
 	}
 	w.lastX = 0
 	w.lastY = 0
+
+	w.drawBorder()
 }
 
 func (w *TcellWindow) FinishFill() {
@@ -81,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 (
@@ -96,13 +86,6 @@ const (
 	AttrClear     = Attr(1 << 8)
 )
 
-func (r *FullscreenRenderer) PassThrough(str string) {
-	// No-op
-	// https://github.com/gdamore/tcell/pull/650#issuecomment-1806442846
-}
-
-func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
-
 func (r *FullscreenRenderer) defaultTheme() *ColorTheme {
 	if _screen.Colors() >= 256 {
 		return Dark256
@@ -142,16 +125,15 @@ func (a Attr) Merge(b Attr) Attr {
 var (
 	_screen          tcell.Screen
 	_prevMouseButton tcell.ButtonMask
-	_initialResize   bool = true
 )
 
-func (r *FullscreenRenderer) initScreen() error {
+func (r *FullscreenRenderer) initScreen() {
 	s, e := tcell.NewScreen()
 	if e != nil {
-		return e
+		errorExit(e.Error())
 	}
 	if e = s.Init(); e != nil {
-		return e
+		errorExit(e.Error())
 	}
 	if r.mouse {
 		s.EnableMouse()
@@ -159,25 +141,16 @@ func (r *FullscreenRenderer) initScreen() error {
 		s.DisableMouse()
 	}
 	_screen = s
-
-	return nil
 }
 
-func (r *FullscreenRenderer) Init() error {
+func (r *FullscreenRenderer) Init() {
 	if os.Getenv("TERM") == "cygwin" {
 		os.Setenv("TERM", "")
 	}
+	encoding.Register()
 
-	if err := r.initScreen(); err != nil {
-		return err
-	}
+	r.initScreen()
 	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
-
-	return nil
-}
-
-func (r *FullscreenRenderer) Top() int {
-	return 0
 }
 
 func (r *FullscreenRenderer) MaxX() int {
@@ -203,34 +176,14 @@ func (r *FullscreenRenderer) Clear() {
 	_screen.Clear()
 }
 
-func (r *FullscreenRenderer) NeedScrollbarRedraw() bool {
-	return true
-}
-
-func (r *FullscreenRenderer) ShouldEmitResizeEvent() bool {
-	return true
-}
-
 func (r *FullscreenRenderer) Refresh() {
 	// noop
 }
 
-// TODO: Pixel width and height not implemented
-func (r *FullscreenRenderer) Size() TermSize {
-	cols, lines := _screen.Size()
-	return TermSize{lines, cols, 0, 0}
-}
-
 func (r *FullscreenRenderer) GetChar() Event {
 	ev := _screen.PollEvent()
 	switch ev := ev.(type) {
 	case *tcell.EventResize:
-		// Ignore the first resize event
-		// https://github.com/gdamore/tcell/blob/v2.7.0/TUTORIAL.md?plain=1#L18
-		if _initialResize {
-			_initialResize = false
-			return Event{Invalid, 0, nil}
-		}
 		return Event{Resize, 0, nil}
 
 	// process mouse events:
@@ -252,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}}
 		}
@@ -324,16 +293,16 @@ func (r *FullscreenRenderer) GetChar() Event {
 			switch ev.Rune() {
 			case 0:
 				if ctrl {
-					return Event{Backspace, 0, nil}
+					return Event{BSpace, 0, nil}
 				}
 			case rune(tcell.KeyCtrlH):
 				switch {
 				case ctrl:
 					return keyfn('h')
 				case alt:
-					return Event{AltBackspace, 0, nil}
+					return Event{AltBS, 0, nil}
 				case none, shift:
-					return Event{Backspace, 0, nil}
+					return Event{BSpace, 0, nil}
 				}
 			}
 		case tcell.KeyCtrlI:
@@ -386,17 +355,17 @@ func (r *FullscreenRenderer) GetChar() Event {
 		// section 3: (Alt)+Backspace2
 		case tcell.KeyBackspace2:
 			if alt {
-				return Event{AltBackspace, 0, nil}
+				return Event{AltBS, 0, nil}
 			}
-			return Event{Backspace, 0, nil}
+			return Event{BSpace, 0, nil}
 
 		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
 		case tcell.KeyUp:
 			if altShift {
-				return Event{AltShiftUp, 0, nil}
+				return Event{AltSUp, 0, nil}
 			}
 			if shift {
-				return Event{ShiftUp, 0, nil}
+				return Event{SUp, 0, nil}
 			}
 			if alt {
 				return Event{AltUp, 0, nil}
@@ -404,10 +373,10 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Up, 0, nil}
 		case tcell.KeyDown:
 			if altShift {
-				return Event{AltShiftDown, 0, nil}
+				return Event{AltSDown, 0, nil}
 			}
 			if shift {
-				return Event{ShiftDown, 0, nil}
+				return Event{SDown, 0, nil}
 			}
 			if alt {
 				return Event{AltDown, 0, nil}
@@ -415,10 +384,10 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Down, 0, nil}
 		case tcell.KeyLeft:
 			if altShift {
-				return Event{AltShiftLeft, 0, nil}
+				return Event{AltSLeft, 0, nil}
 			}
 			if shift {
-				return Event{ShiftLeft, 0, nil}
+				return Event{SLeft, 0, nil}
 			}
 			if alt {
 				return Event{AltLeft, 0, nil}
@@ -426,10 +395,10 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{Left, 0, nil}
 		case tcell.KeyRight:
 			if altShift {
-				return Event{AltShiftRight, 0, nil}
+				return Event{AltSRight, 0, nil}
 			}
 			if shift {
-				return Event{ShiftRight, 0, nil}
+				return Event{SRight, 0, nil}
 			}
 			if alt {
 				return Event{AltRight, 0, nil}
@@ -442,21 +411,15 @@ func (r *FullscreenRenderer) GetChar() Event {
 		case tcell.KeyHome:
 			return Event{Home, 0, nil}
 		case tcell.KeyDelete:
-			if ctrl {
-				return Event{CtrlDelete, 0, nil}
-			}
-			if shift {
-				return Event{ShiftDelete, 0, nil}
-			}
-			return Event{Delete, 0, nil}
+			return Event{Del, 0, nil}
 		case tcell.KeyEnd:
 			return Event{End, 0, nil}
 		case tcell.KeyPgUp:
-			return Event{PageUp, 0, nil}
+			return Event{PgUp, 0, nil}
 		case tcell.KeyPgDn:
-			return Event{PageDown, 0, nil}
+			return Event{PgDn, 0, nil}
 		case tcell.KeyBacktab:
-			return Event{ShiftTab, 0, nil}
+			return Event{BTab, 0, nil}
 		case tcell.KeyF1:
 			return Event{F1, 0, nil}
 		case tcell.KeyF2:
@@ -502,7 +465,7 @@ func (r *FullscreenRenderer) GetChar() Event {
 
 		// section 7: Esc
 		case tcell.KeyEsc:
-			return Event{Esc, 0, nil}
+			return Event{ESC, 0, nil}
 		}
 	}
 
@@ -539,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,
@@ -548,8 +511,6 @@ func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int,
 		height:      height,
 		normal:      normal,
 		borderStyle: borderStyle}
-	w.Erase()
-	return w
 }
 
 func (w *TcellWindow) Close() {
@@ -565,17 +526,7 @@ func fill(x, y, w, h int, n ColorPair, r rune) {
 }
 
 func (w *TcellWindow) Erase() {
-	if w.borderStyle.shape.HasLeft() {
-		fill(w.left-1, w.top, w.width, w.height-1, w.normal, ' ')
-	} else {
-		fill(w.left, w.top, w.width-1, w.height-1, w.normal, ' ')
-	}
-	w.drawBorder(false)
-}
-
-func (w *TcellWindow) EraseMaybe() bool {
-	w.Erase()
-	return true
+	fill(w.left-1, w.top, w.width+1, w.height, w.normal, ' ')
 }
 
 func (w *TcellWindow) Enclose(y int, x int) bool {
@@ -610,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)
@@ -618,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
 }
@@ -663,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:
@@ -699,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 {
@@ -726,15 +665,7 @@ func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
 	return w.fillString(str, NewColorPair(fg, bg, a))
 }
 
-func (w *TcellWindow) DrawBorder() {
-	w.drawBorder(false)
-}
-
-func (w *TcellWindow) DrawHBorder() {
-	w.drawBorder(true)
-}
-
-func (w *TcellWindow) drawBorder(onlyHorizontal bool) {
+func (w *TcellWindow) drawBorder() {
 	shape := w.borderStyle.shape
 	if shape == BorderNone {
 		return
@@ -756,52 +687,35 @@ func (w *TcellWindow) drawBorder(onlyHorizontal bool) {
 		style = w.normal.style()
 	}
 
-	hw := runeWidth(w.borderStyle.top)
 	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderTop:
-		max := right - 2*hw
-		if shape == BorderHorizontal || shape == BorderTop {
-			max = right - hw
-		}
-		// tcell has an issue displaying two overlapping wide runes
-		// e.g.  SetContent(  HH  )
-		//       SetContent(   TR )
-		//       ==================
-		//                 (  HH  ) => TR is ignored
-		for x := left; x <= max; x += hw {
-			_screen.SetContent(x, top, w.borderStyle.top, nil, style)
+	case BorderRounded, BorderSharp, BorderHorizontal, BorderTop:
+		for x := left; x < right; x++ {
+			_screen.SetContent(x, top, w.borderStyle.horizontal, nil, style)
 		}
 	}
 	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderBottom:
-		max := right - 2*hw
-		if shape == BorderHorizontal || shape == BorderBottom {
-			max = right - hw
-		}
-		for x := left; x <= max; x += hw {
-			_screen.SetContent(x, bot-1, w.borderStyle.bottom, nil, style)
-		}
-	}
-	if !onlyHorizontal {
-		switch shape {
-		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderLeft:
-			for y := top; y < bot; y++ {
-				_screen.SetContent(left, y, w.borderStyle.left, nil, style)
-			}
-		}
-		switch shape {
-		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderRight:
-			vw := runeWidth(w.borderStyle.right)
-			for y := top; y < bot; y++ {
-				_screen.SetContent(right-vw, y, w.borderStyle.right, nil, style)
-			}
+	case BorderRounded, BorderSharp, BorderHorizontal, BorderBottom:
+		for x := left; x < right; x++ {
+			_screen.SetContent(x, bot-1, w.borderStyle.horizontal, nil, style)
 		}
 	}
 	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble:
+	case BorderRounded, BorderSharp, BorderVertical, BorderLeft:
+		for y := top; y < bot; y++ {
+			_screen.SetContent(left, y, w.borderStyle.vertical, nil, style)
+		}
+	}
+	switch shape {
+	case BorderRounded, BorderSharp, BorderVertical, BorderRight:
+		for y := top; y < bot; y++ {
+			_screen.SetContent(right-1, y, w.borderStyle.vertical, nil, style)
+		}
+	}
+	switch shape {
+	case BorderRounded, BorderSharp:
 		_screen.SetContent(left, top, w.borderStyle.topLeft, nil, style)
-		_screen.SetContent(right-runeWidth(w.borderStyle.topRight), top, w.borderStyle.topRight, nil, style)
+		_screen.SetContent(right-1, top, w.borderStyle.topRight, nil, style)
 		_screen.SetContent(left, bot-1, w.borderStyle.bottomLeft, nil, style)
-		_screen.SetContent(right-runeWidth(w.borderStyle.bottomRight), bot-1, w.borderStyle.bottomRight, nil, style)
+		_screen.SetContent(right-1, bot-1, w.borderStyle.bottomRight, nil, style)
 	}
 }

src/tui/tcell_test.go

@@ -1,11 +1,11 @@
-//go:build tcell || windows
+// +build tcell windows
 
 package tui
 
 import (
 	"testing"
 
-	"github.com/gdamore/tcell/v2"
+	"github.com/gdamore/tcell"
 	"github.com/junegunn/fzf/src/util"
 )
 
@@ -102,22 +102,22 @@ func TestGetCharEventKey(t *testing.T) {
 		// KeyBackspace2 is alias for KeyDEL = 0x7F (ASCII) (allegedly unused by Windows)
 		// KeyDelete = 0x2E (VK_DELETE constant in Windows)
 		// KeyBackspace is alias for KeyBS = 0x08 (ASCII) (implicit alias with KeyCtrlH)
-		{giveKey{tcell.KeyBackspace2, 0, tcell.ModNone}, wantKey{Backspace, 0, nil}},   // fabricated
-		{giveKey{tcell.KeyBackspace2, 0, tcell.ModAlt}, wantKey{AltBackspace, 0, nil}}, // fabricated
-		{giveKey{tcell.KeyDEL, 0, tcell.ModNone}, wantKey{Backspace, 0, nil}},          // fabricated, unhandled
-		{giveKey{tcell.KeyDelete, 0, tcell.ModNone}, wantKey{Delete, 0, nil}},
-		{giveKey{tcell.KeyDelete, 0, tcell.ModAlt}, wantKey{Delete, 0, nil}},
+		{giveKey{tcell.KeyBackspace2, 0, tcell.ModNone}, wantKey{BSpace, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyBackspace2, 0, tcell.ModAlt}, wantKey{AltBS, 0, nil}},   // fabricated
+		{giveKey{tcell.KeyDEL, 0, tcell.ModNone}, wantKey{BSpace, 0, nil}},        // fabricated, unhandled
+		{giveKey{tcell.KeyDelete, 0, tcell.ModNone}, wantKey{Del, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModAlt}, wantKey{Del, 0, nil}},
 		{giveKey{tcell.KeyBackspace, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                  // fabricated, unhandled
 		{giveKey{tcell.KeyBS, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                         // fabricated, unhandled
 		{giveKey{tcell.KeyCtrlH, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                      // fabricated, unhandled
-		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModNone}, wantKey{Backspace, 0, nil}},                                 // actual "Backspace" keystroke
-		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModAlt}, wantKey{AltBackspace, 0, nil}},                               // actual "Alt+Backspace" keystroke
-		{giveKey{tcell.KeyDEL, rune(tcell.KeyDEL), tcell.ModCtrl}, wantKey{Backspace, 0, nil}},                                     // actual "Ctrl+Backspace" keystroke
-		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift}, wantKey{Backspace, 0, nil}},                                // actual "Shift+Backspace" keystroke
-		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{Backspace, 0, nil}},                                     // actual "Ctrl+Alt+Backspace" keystroke
-		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{Backspace, 0, nil}},                                   // actual "Ctrl+Shift+Backspace" keystroke
-		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift | tcell.ModAlt}, wantKey{AltBackspace, 0, nil}},              // actual "Shift+Alt+Backspace" keystroke
-		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{Backspace, 0, nil}},                    // actual "Ctrl+Shift+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModNone}, wantKey{BSpace, 0, nil}},                                    // actual "Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModAlt}, wantKey{AltBS, 0, nil}},                                      // actual "Alt+Backspace" keystroke
+		{giveKey{tcell.KeyDEL, rune(tcell.KeyDEL), tcell.ModCtrl}, wantKey{BSpace, 0, nil}},                                        // actual "Ctrl+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift}, wantKey{BSpace, 0, nil}},                                   // actual "Shift+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{BSpace, 0, nil}},                                        // actual "Ctrl+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{BSpace, 0, nil}},                                      // actual "Ctrl+Shift+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift | tcell.ModAlt}, wantKey{AltBS, 0, nil}},                     // actual "Shift+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{BSpace, 0, nil}},                       // actual "Ctrl+Shift+Alt+Backspace" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl}, wantKey{CtrlH, 0, nil}},                                     // actual "Ctrl+H" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAlt, 'h', nil}},                  // fabricated "Ctrl+Alt+H" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlH, 0, nil}},                    // actual "Ctrl+Shift+H" keystroke
@@ -126,8 +126,8 @@ func TestGetCharEventKey(t *testing.T) {
 		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
 		{giveKey{tcell.KeyUp, 0, tcell.ModNone}, wantKey{Up, 0, nil}},
 		{giveKey{tcell.KeyDown, 0, tcell.ModAlt}, wantKey{AltDown, 0, nil}},
-		{giveKey{tcell.KeyLeft, 0, tcell.ModShift}, wantKey{ShiftLeft, 0, nil}},
-		{giveKey{tcell.KeyRight, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftRight, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModShift}, wantKey{SLeft, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltSRight, 0, nil}},
 		{giveKey{tcell.KeyUpLeft, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},    // fabricated, unhandled
 		{giveKey{tcell.KeyUpRight, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},   // fabricated, unhandled
 		{giveKey{tcell.KeyDownLeft, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // fabricated, unhandled
@@ -161,11 +161,11 @@ func TestGetCharEventKey(t *testing.T) {
 
 		// section 7: Esc
 		// KeyEsc and KeyEscape are aliases for KeyESC
-		{giveKey{tcell.KeyEsc, rune(tcell.KeyEsc), tcell.ModNone}, wantKey{Esc, 0, nil}},               // fabricated
-		{giveKey{tcell.KeyESC, rune(tcell.KeyESC), tcell.ModNone}, wantKey{Esc, 0, nil}},               // unhandled
-		{giveKey{tcell.KeyEscape, rune(tcell.KeyEscape), tcell.ModNone}, wantKey{Esc, 0, nil}},         // fabricated, unhandled
-		{giveKey{tcell.KeyESC, rune(tcell.KeyESC), tcell.ModCtrl}, wantKey{Esc, 0, nil}},               // actual Ctrl+[ keystroke
-		{giveKey{tcell.KeyCtrlLeftSq, rune(tcell.KeyCtrlLeftSq), tcell.ModCtrl}, wantKey{Esc, 0, nil}}, // fabricated, unhandled
+		{giveKey{tcell.KeyEsc, rune(tcell.KeyEsc), tcell.ModNone}, wantKey{ESC, 0, nil}},               // fabricated
+		{giveKey{tcell.KeyESC, rune(tcell.KeyESC), tcell.ModNone}, wantKey{ESC, 0, nil}},               // unhandled
+		{giveKey{tcell.KeyEscape, rune(tcell.KeyEscape), tcell.ModNone}, wantKey{ESC, 0, nil}},         // fabricated, unhandled
+		{giveKey{tcell.KeyESC, rune(tcell.KeyESC), tcell.ModCtrl}, wantKey{ESC, 0, nil}},               // actual Ctrl+[ keystroke
+		{giveKey{tcell.KeyCtrlLeftSq, rune(tcell.KeyCtrlLeftSq), tcell.ModCtrl}, wantKey{ESC, 0, nil}}, // fabricated, unhandled
 
 		// section 8: Invalid
 		{giveKey{tcell.KeyRune, 'a', tcell.ModMeta}, wantKey{Rune, 'a', nil}}, // fabricated
@@ -182,7 +182,6 @@ func TestGetCharEventKey(t *testing.T) {
 	r.Init()
 
 	// run and evaluate the tests
-	initialResizeAsInvalid := true
 	for _, test := range tests {
 		// generate key event
 		giveEvent := tcell.NewEventKey(test.giveKey.Type, test.giveKey.Char, test.giveKey.Mods)
@@ -192,9 +191,8 @@ func TestGetCharEventKey(t *testing.T) {
 		// process the event in fzf and evaluate the test
 		gotEvent := r.GetChar()
 		// skip Resize events, those are sometimes put in the buffer outside of this test
-		if initialResizeAsInvalid && gotEvent.Type == Invalid {
-			t.Logf("Resize as Invalid swallowed")
-			initialResizeAsInvalid = false
+		for gotEvent.Type == Resize {
+			t.Logf("Resize swallowed")
 			gotEvent = r.GetChar()
 		}
 		t.Logf("wantEvent = %T{Type: %v, Char: %q (%[3]v)}\n", test.wantKey, test.wantKey.Type, test.wantKey.Char)
@@ -259,7 +257,7 @@ Quick reference
 37					LeftClick
 38					RightClick
 39					BTab
-40					Backspace
+40					BSpace
 41					Del
 42					PgUp
 43					PgDn
@@ -272,7 +270,7 @@ Quick reference
 50					Insert
 51					SUp
 52					SDown
-53					ShiftLeft
+53					SLeft
 54					SRight
 55					F1
 56					F2
@@ -288,15 +286,15 @@ Quick reference
 66					F12
 67					Change
 68					BackwardEOF
-69					AltBackspace
+69					AltBS
 70					AltUp
 71					AltDown
 72					AltLeft
 73					AltRight
 74					AltSUp
 75					AltSDown
-76					AltShiftLeft
-77					AltShiftRight
+76					AltSLeft
+77					AltSRight
 78					Alt
 79					CtrlAlt
 ..

src/tui/ttyname_unix.go

@@ -1,8 +1,9 @@
-//go:build !windows
+// +build !windows
 
 package tui
 
 import (
+	"io/ioutil"
 	"os"
 	"syscall"
 )
@@ -16,17 +17,13 @@ func ttyname() string {
 	}
 
 	for _, prefix := range devPrefixes {
-		files, err := os.ReadDir(prefix)
+		files, err := ioutil.ReadDir(prefix)
 		if err != nil {
 			continue
 		}
 
 		for _, file := range files {
-			info, err := file.Info()
-			if err != nil {
-				continue
-			}
-			if stat, ok := info.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
+			if stat, ok := file.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
 				return prefix + file.Name()
 			}
 		}
@@ -36,8 +33,15 @@ func ttyname() string {
 
 // TtyIn returns terminal device to be used as STDIN, falls back to os.Stdin
 func TtyIn() *os.File {
-	if in, err := openTtyIn(); err == nil {
-		return in
+	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
+	if err != nil {
+		tty := ttyname()
+		if len(tty) > 0 {
+			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
+				return in
+			}
+		}
+		return os.Stdin
 	}
-	return os.Stdin
+	return in
 }

src/tui/ttyname_windows.go

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

src/tui/tui.go

@@ -1,16 +1,13 @@
 package tui
 
 import (
+	"fmt"
+	"os"
 	"strconv"
 	"time"
-
-	"github.com/junegunn/fzf/src/util"
-	"github.com/rivo/uniseg"
 )
 
 // Types of user action
-//
-//go:generate stringer -type=EventType
 type EventType int
 
 const (
@@ -42,9 +39,8 @@ const (
 	CtrlX
 	CtrlY
 	CtrlZ
-	Esc
+	ESC
 	CtrlSpace
-	CtrlDelete
 
 	// https://apple.stackexchange.com/questions/24261/how-do-i-send-c-that-is-control-slash-to-the-terminal
 	CtrlBackSlash
@@ -52,12 +48,19 @@ const (
 	CtrlCaret
 	CtrlSlash
 
-	ShiftTab
-	Backspace
+	Invalid
+	Resize
+	Mouse
+	DoubleClick
+	LeftClick
+	RightClick
 
-	Delete
-	PageUp
-	PageDown
+	BTab
+	BSpace
+
+	Del
+	PgUp
+	PgDn
 
 	Up
 	Down
@@ -67,11 +70,10 @@ const (
 	End
 	Insert
 
-	ShiftUp
-	ShiftDown
-	ShiftLeft
-	ShiftRight
-	ShiftDelete
+	SUp
+	SDown
+	SLeft
+	SRight
 
 	F1
 	F2
@@ -86,50 +88,23 @@ const (
 	F11
 	F12
 
-	AltBackspace
+	Change
+	BackwardEOF
+
+	AltBS
 
 	AltUp
 	AltDown
 	AltLeft
 	AltRight
 
-	AltShiftUp
-	AltShiftDown
-	AltShiftLeft
-	AltShiftRight
+	AltSUp
+	AltSDown
+	AltSLeft
+	AltSRight
 
 	Alt
 	CtrlAlt
-
-	Invalid
-	Fatal
-
-	Mouse
-	DoubleClick
-	LeftClick
-	RightClick
-	SLeftClick
-	SRightClick
-	ScrollUp
-	ScrollDown
-	SScrollUp
-	SScrollDown
-	PreviewScrollUp
-	PreviewScrollDown
-
-	// Events
-	Resize
-	Change
-	BackwardEOF
-	Start
-	Load
-	Focus
-	One
-	Zero
-	Result
-	Jump
-	JumpCancel
-	ClickHeader
 )
 
 func (t EventType) AsEvent() Event {
@@ -149,31 +124,6 @@ func (e Event) Comparable() Event {
 	return Event{e.Type, e.Char, nil}
 }
 
-func (e Event) KeyName() string {
-	if e.Type >= Invalid {
-		return ""
-	}
-
-	switch e.Type {
-	case Rune:
-		return string(e.Char)
-	case Alt:
-		return "alt-" + string(e.Char)
-	case CtrlAlt:
-		return "ctrl-alt-" + string(e.Char)
-	case CtrlBackSlash:
-		return "ctrl-\\"
-	case CtrlRightBracket:
-		return "ctrl-]"
-	case CtrlCaret:
-		return "ctrl-^"
-	case CtrlSlash:
-		return "ctrl-/"
-	}
-
-	return util.ToKebabCase(e.Type.String())
-}
-
 func Key(r rune) Event {
 	return Event{Rune, r, nil}
 }
@@ -298,34 +248,25 @@ func (p ColorPair) MergeNonDefault(other ColorPair) ColorPair {
 }
 
 type ColorTheme struct {
-	Colored          bool
-	Input            ColorAttr
-	Disabled         ColorAttr
-	Fg               ColorAttr
-	Bg               ColorAttr
-	SelectedFg       ColorAttr
-	SelectedBg       ColorAttr
-	SelectedMatch    ColorAttr
-	PreviewFg        ColorAttr
-	PreviewBg        ColorAttr
-	DarkBg           ColorAttr
-	Gutter           ColorAttr
-	Prompt           ColorAttr
-	Match            ColorAttr
-	Current          ColorAttr
-	CurrentMatch     ColorAttr
-	Spinner          ColorAttr
-	Info             ColorAttr
-	Cursor           ColorAttr
-	Marker           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 {
@@ -334,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
@@ -359,10 +291,6 @@ const (
 	BorderNone BorderShape = iota
 	BorderRounded
 	BorderSharp
-	BorderBold
-	BorderBlock
-	BorderThinBlock
-	BorderDouble
 	BorderHorizontal
 	BorderVertical
 	BorderTop
@@ -371,36 +299,10 @@ const (
 	BorderRight
 )
 
-func (s BorderShape) HasLeft() bool {
-	switch s {
-	case BorderNone, BorderRight, BorderTop, BorderBottom, BorderHorizontal: // No Left
-		return false
-	}
-	return true
-}
-
-func (s BorderShape) HasRight() bool {
-	switch s {
-	case BorderNone, BorderLeft, BorderTop, BorderBottom, BorderHorizontal: // No right
-		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
@@ -410,143 +312,64 @@ 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 BorderThinBlock:
-		// 🭽▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔🭾
-		// ▏                  ▕
-		// 🭼▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁🭿
-		return BorderStyle{
-			shape:       shape,
-			top:         '▔',
-			bottom:      '▁',
-			left:        '▏',
-			right:       '▕',
-			topLeft:     '🭽',
-			topRight:    '🭾',
-			bottomLeft:  '🭼',
-			bottomRight: '🭿',
-		}
-
-	case BorderDouble:
-		return BorderStyle{
-			shape:       shape,
-			top:         '═',
-			bottom:      '═',
-			left:        '║',
-			right:       '║',
-			topLeft:     '╔',
-			topRight:    '╗',
-			bottomLeft:  '╚',
-			bottomRight: '╝',
-		}
 	}
 	return BorderStyle{
 		shape:       shape,
-		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:  ' ',
 		bottomRight: ' '}
 }
 
-type TermSize struct {
-	Lines    int
-	Columns  int
-	PxWidth  int
-	PxHeight int
-}
-
 type Renderer interface {
-	Init() error
-	Resize(maxHeightFunc func(int) int)
+	Init()
 	Pause(clear bool)
 	Resume(clear bool, sigcont bool)
 	Clear()
 	RefreshWindows(windows []Window)
 	Refresh()
 	Close()
-	PassThrough(string)
-	NeedScrollbarRedraw() bool
-	ShouldEmitResizeEvent() bool
 
 	GetChar() Event
 
-	Top() int
 	MaxX() int
 	MaxY() int
 
-	Size() TermSize
-
 	NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window
 }
 
@@ -556,8 +379,6 @@ type Window interface {
 	Width() int
 	Height() int
 
-	DrawBorder()
-	DrawHBorder()
 	Refresh()
 	FinishFill()
 	Close()
@@ -573,7 +394,6 @@ type Window interface {
 	Fill(text string) FillReturn
 	CFill(fg Color, bg Color, attr Attr, text string) FillReturn
 	Erase()
-	EraseMaybe() bool
 }
 
 type FullscreenRenderer struct {
@@ -581,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 {
@@ -590,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
 }
 
@@ -606,186 +426,133 @@ var (
 	ColMatch                ColorPair
 	ColCursor               ColorPair
 	ColCursorEmpty          ColorPair
-	ColMarker               ColorPair
 	ColSelected             ColorPair
-	ColSelectedMatch        ColorPair
 	ColCurrent              ColorPair
 	ColCurrentMatch         ColorPair
 	ColCurrentCursor        ColorPair
 	ColCurrentCursorEmpty   ColorPair
-	ColCurrentMarker        ColorPair
+	ColCurrentSelected      ColorPair
 	ColCurrentSelectedEmpty ColorPair
 	ColSpinner              ColorPair
 	ColInfo                 ColorPair
 	ColHeader               ColorPair
-	ColSeparator            ColorPair
-	ColScrollbar            ColorPair
 	ColBorder               ColorPair
 	ColPreview              ColorPair
 	ColPreviewBorder        ColorPair
-	ColBorderLabel          ColorPair
-	ColPreviewLabel         ColorPair
-	ColPreviewScrollbar     ColorPair
-	ColPreviewSpinner       ColorPair
 )
 
 func EmptyTheme() *ColorTheme {
 	return &ColorTheme{
-		Colored:          true,
-		Input:            ColorAttr{colUndefined, AttrUndefined},
-		Fg:               ColorAttr{colUndefined, AttrUndefined},
-		Bg:               ColorAttr{colUndefined, AttrUndefined},
-		SelectedFg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedBg:       ColorAttr{colUndefined, AttrUndefined},
-		SelectedMatch:    ColorAttr{colUndefined, AttrUndefined},
-		DarkBg:           ColorAttr{colUndefined, AttrUndefined},
-		Prompt:           ColorAttr{colUndefined, AttrUndefined},
-		Match:            ColorAttr{colUndefined, AttrUndefined},
-		Current:          ColorAttr{colUndefined, AttrUndefined},
-		CurrentMatch:     ColorAttr{colUndefined, AttrUndefined},
-		Spinner:          ColorAttr{colUndefined, AttrUndefined},
-		Info:             ColorAttr{colUndefined, AttrUndefined},
-		Cursor:           ColorAttr{colUndefined, AttrUndefined},
-		Marker:           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},
-		SelectedFg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedBg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedMatch:    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},
-		Marker:           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) {
+	fmt.Fprintln(os.Stderr, message)
+	os.Exit(2)
 }
 
 func init() {
 	Default16 = &ColorTheme{
-		Colored:          true,
-		Input:            ColorAttr{colDefault, AttrUndefined},
-		Fg:               ColorAttr{colDefault, AttrUndefined},
-		Bg:               ColorAttr{colDefault, AttrUndefined},
-		SelectedFg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedBg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedMatch:    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},
-		Marker:           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},
-		SelectedFg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedBg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedMatch:    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},
-		Marker:           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},
-		SelectedFg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedBg:       ColorAttr{colDefault, AttrUndefined},
-		SelectedMatch:    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},
-		Marker:           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) {
@@ -804,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)
@@ -814,24 +585,9 @@ func initTheme(theme *ColorTheme, baseTheme *ColorTheme, forceBlack bool) {
 	theme.Spinner = o(baseTheme.Spinner, theme.Spinner)
 	theme.Info = o(baseTheme.Info, theme.Info)
 	theme.Cursor = o(baseTheme.Cursor, theme.Cursor)
-	theme.Marker = o(baseTheme.Marker, theme.Marker)
+	theme.Selected = o(baseTheme.Selected, theme.Selected)
 	theme.Header = o(baseTheme.Header, theme.Header)
 	theme.Border = o(baseTheme.Border, theme.Border)
-	theme.BorderLabel = o(baseTheme.BorderLabel, theme.BorderLabel)
-
-	// These colors are not defined in the base themes
-	theme.SelectedFg = o(theme.Fg, theme.SelectedFg)
-	theme.SelectedBg = o(theme.Bg, theme.SelectedBg)
-	theme.SelectedMatch = o(theme.CurrentMatch, theme.SelectedMatch)
-	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)
 }
@@ -848,38 +604,22 @@ func initPalette(theme *ColorTheme) {
 
 	ColPrompt = pair(theme.Prompt, theme.Bg)
 	ColNormal = pair(theme.Fg, theme.Bg)
-	ColSelected = pair(theme.SelectedFg, theme.SelectedBg)
 	ColInput = pair(theme.Input, theme.Bg)
 	ColDisabled = pair(theme.Disabled, theme.Bg)
 	ColMatch = pair(theme.Match, theme.Bg)
-	ColSelectedMatch = pair(theme.SelectedMatch, theme.SelectedBg)
 	ColCursor = pair(theme.Cursor, theme.Gutter)
 	ColCursorEmpty = pair(blank, theme.Gutter)
-	if theme.SelectedBg.Color != theme.Bg.Color {
-		ColMarker = pair(theme.Marker, theme.SelectedBg)
-	} else {
-		ColMarker = pair(theme.Marker, theme.Gutter)
-	}
+	ColSelected = pair(theme.Selected, theme.Gutter)
 	ColCurrent = pair(theme.Current, theme.DarkBg)
 	ColCurrentMatch = pair(theme.CurrentMatch, theme.DarkBg)
 	ColCurrentCursor = pair(theme.Cursor, theme.DarkBg)
 	ColCurrentCursorEmpty = pair(blank, theme.DarkBg)
-	ColCurrentMarker = pair(theme.Marker, theme.DarkBg)
+	ColCurrentSelected = pair(theme.Selected, theme.DarkBg)
 	ColCurrentSelectedEmpty = pair(blank, theme.DarkBg)
 	ColSpinner = pair(theme.Spinner, theme.Bg)
 	ColInfo = pair(theme.Info, theme.Bg)
 	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)
-	ColPreviewSpinner = pair(theme.Spinner, theme.PreviewBg)
-}
-
-func runeWidth(r rune) int {
-	return uniseg.StringWidth(string(r))
+	ColPreviewBorder = pair(theme.Border, theme.PreviewBg)
 }

src/util/atexit.go

@@ -1,28 +0,0 @@
-package util
-
-import (
-	"sync"
-)
-
-var atExitFuncs []func()
-
-// AtExit registers the function fn to be called on program termination.
-// The functions will be called in reverse order they were registered.
-func AtExit(fn func()) {
-	if fn == nil {
-		panic("AtExit called with nil func")
-	}
-	once := &sync.Once{}
-	atExitFuncs = append(atExitFuncs, func() {
-		once.Do(fn)
-	})
-}
-
-// RunAtExitFuncs runs any functions registered with AtExit().
-func RunAtExitFuncs() {
-	fns := atExitFuncs
-	for i := len(fns) - 1; i >= 0; i-- {
-		fns[i]()
-	}
-	atExitFuncs = nil
-}

src/util/atexit_test.go

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

src/util/chars.go

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

src/util/eventbox_test.go

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

src/util/util.go

@@ -7,14 +7,10 @@ import (
 	"time"
 
 	"github.com/mattn/go-isatty"
+	"github.com/mattn/go-runewidth"
 	"github.com/rivo/uniseg"
 )
 
-// StringWidth returns string width where each CR/LF character takes 1 column
-func StringWidth(s string) int {
-	return uniseg.StringWidth(s) + strings.Count(s, "\n") + strings.Count(s, "\r")
-}
-
 // RunesWidth returns runes width
 func RunesWidth(runes []rune, prefixWidth int, tabstop int, limit int) (int, int) {
 	width := 0
@@ -26,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 {
@@ -37,23 +34,6 @@ func RunesWidth(runes []rune, prefixWidth int, tabstop int, limit int) (int, int
 	return width, -1
 }
 
-// Truncate returns the truncated runes and its width
-func Truncate(input string, limit int) ([]rune, int) {
-	runes := []rune{}
-	width := 0
-	gr := uniseg.NewGraphemes(input)
-	for gr.Next() {
-		rs := gr.Runes()
-		w := StringWidth(string(rs))
-		if width+w > limit {
-			return runes, width
-		}
-		width += w
-		runes = append(runes, rs...)
-	}
-	return runes, width
-}
-
 // Max returns the largest integer
 func Max(first int, second int) int {
 	if first >= second {
@@ -156,35 +136,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 -= uniseg.StringWidth(string(r))
-			if rest < 0 {
-				break
-			}
-			output += string(r)
-			if rest == 0 {
-				break
-			}
-		}
-	}
-	return output
-}
-
-// ToKebabCase converts the given CamelCase string to kebab-case
-func ToKebabCase(s string) string {
-	name := ""
-	for i, r := range s {
-		if i > 0 && r >= 'A' && r <= 'Z' {
-			name += "-"
-		}
-		name += string(r)
-	}
-	return strings.ToLower(name)
-}

src/util/util_test.go

@@ -1,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() {
@@ -164,42 +53,4 @@ func TestRunesWidth(t *testing.T) {
 			t.Errorf("Expected overflow index: %d, actual: %d", args[2], overflowIdx)
 		}
 	}
-	for _, input := range []struct {
-		s string
-		w int
-	}{
-		{"▶", 1},
-		{"▶️", 2},
-	} {
-		width, _ := RunesWidth([]rune(input.s), 0, 0, 100)
-		if width != input.w {
-			t.Errorf("Expected width of %s: %d, actual: %d", input.s, input.w, width)
-		}
-	}
-}
-
-func TestTruncate(t *testing.T) {
-	truncated, width := Truncate("가나다라마", 7)
-	if string(truncated) != "가나다" {
-		t.Errorf("Expected: 가나다, actual: %s", string(truncated))
-	}
-	if width != 6 {
-		t.Errorf("Expected: 6, actual: %d", width)
-	}
-}
-
-func TestRepeatToFill(t *testing.T) {
-	if RepeatToFill("abcde", 10, 50) != strings.Repeat("abcde", 5) {
-		t.Error("Expected:", strings.Repeat("abcde", 5))
-	}
-	if RepeatToFill("abcde", 10, 42) != strings.Repeat("abcde", 4)+"abcde"[:2] {
-		t.Error("Expected:", strings.Repeat("abcde", 4)+"abcde"[:2])
-	}
-}
-
-func TestStringWidth(t *testing.T) {
-	w := StringWidth("─")
-	if w != 1 {
-		t.Errorf("Expected: %d, Actual: %d", 1, w)
-	}
 }

src/util/util_unix.go

@@ -1,73 +1,31 @@
-//go:build !windows
+// +build !windows
 
 package util
 
 import (
-	"fmt"
 	"os"
 	"os/exec"
-	"strings"
 	"syscall"
-
-	"golang.org/x/sys/unix"
 )
 
-type Executor struct {
-	shell   string
-	args    []string
-	escaper *strings.Replacer
-}
-
-func NewExecutor(withShell string) *Executor {
-	shell := os.Getenv("SHELL")
-	args := strings.Fields(withShell)
-	if len(args) > 0 {
-		shell = args[0]
-		args = args[1:]
-	} else {
-		if len(shell) == 0 {
-			shell = "sh"
-		}
-		args = []string{"-c"}
-	}
-
-	var escaper *strings.Replacer
-	tokens := strings.Split(shell, "/")
-	if tokens[len(tokens)-1] == "fish" {
-		// https://fishshell.com/docs/current/language.html#quotes
-		// > The only meaningful escape sequences in single quotes are \', which
-		// > escapes a single quote and \\, which escapes the backslash symbol.
-		escaper = strings.NewReplacer("\\", "\\\\", "'", "\\'")
-	} else {
-		escaper = strings.NewReplacer("'", "'\\''")
-	}
-	return &Executor{shell, args, escaper}
-}
-
 // ExecCommand executes the given command with $SHELL
-func (x *Executor) ExecCommand(command string, setpgid bool) *exec.Cmd {
-	cmd := exec.Command(x.shell, append(x.args, command)...)
+func ExecCommand(command string, setpgid bool) *exec.Cmd {
+	shell := os.Getenv("SHELL")
+	if len(shell) == 0 {
+		shell = "sh"
+	}
+	return ExecCommandWith(shell, command, setpgid)
+}
+
+// ExecCommandWith executes the given command with the specified shell
+func ExecCommandWith(shell string, command string, setpgid bool) *exec.Cmd {
+	cmd := exec.Command(shell, "-c", command)
 	if setpgid {
 		cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
 	}
 	return cmd
 }
 
-func (x *Executor) QuoteEntry(entry string) string {
-	return "'" + x.escaper.Replace(entry) + "'"
-}
-
-func (x *Executor) Become(stdin *os.File, environ []string, command string) {
-	shellPath, err := exec.LookPath(x.shell)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "fzf (become): %s\n", err.Error())
-		os.Exit(127)
-	}
-	args := append([]string{shellPath}, append(x.args, command)...)
-	SetStdin(stdin)
-	syscall.Exec(shellPath, args, environ)
-}
-
 // KillCommand kills the process for the given command
 func KillCommand(cmd *exec.Cmd) error {
 	return syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
@@ -87,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)
-}

src/util/util_windows.go

@@ -1,4 +1,4 @@
-//go:build windows
+// +build windows
 
 package util
 
@@ -6,164 +6,62 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"path/filepath"
-	"regexp"
 	"strings"
 	"sync/atomic"
 	"syscall"
 )
 
-type shellType int
-
-const (
-	shellTypeUnknown shellType = iota
-	shellTypeCmd
-	shellTypePowerShell
-)
-
-var escapeRegex = regexp.MustCompile(`[&|<>()^%!"]`)
-
-type Executor struct {
-	shell     string
-	shellType shellType
-	args      []string
-	shellPath atomic.Value
-}
-
-func NewExecutor(withShell string) *Executor {
-	shell := os.Getenv("SHELL")
-	args := strings.Fields(withShell)
-	if len(args) > 0 {
-		shell = args[0]
-	} else if len(shell) == 0 {
-		shell = "cmd"
-	}
-
-	shellType := shellTypeUnknown
-	basename := filepath.Base(shell)
-	if len(args) > 0 {
-		args = args[1:]
-	} else if strings.HasPrefix(basename, "cmd") {
-		shellType = shellTypeCmd
-		args = []string{"/s/c"}
-	} else if strings.HasPrefix(basename, "pwsh") || strings.HasPrefix(basename, "powershell") {
-		shellType = shellTypePowerShell
-		args = []string{"-NoProfile", "-Command"}
-	} else {
-		args = []string{"-c"}
-	}
-	return &Executor{shell: shell, shellType: shellType, args: args}
-}
+var shellPath atomic.Value
 
 // ExecCommand executes the given command with $SHELL
-// FIXME: setpgid is unused. We set it in the Unix implementation so that we
-// can kill preview process with its child processes at once.
-// NOTE: For "powershell", we should ideally set output encoding to UTF8,
-// but it is left as is now because no adverse effect has been observed.
-func (x *Executor) ExecCommand(command string, setpgid bool) *exec.Cmd {
-	shell := x.shell
-	if cached := x.shellPath.Load(); cached != nil {
+func ExecCommand(command string, setpgid bool) *exec.Cmd {
+	var shell string
+	if cached := shellPath.Load(); cached != nil {
 		shell = cached.(string)
 	} else {
-		if strings.Contains(shell, "/") {
+		shell = os.Getenv("SHELL")
+		if len(shell) == 0 {
+			shell = "cmd"
+		} else if strings.Contains(shell, "/") {
 			out, err := exec.Command("cygpath", "-w", shell).Output()
 			if err == nil {
 				shell = strings.Trim(string(out), "\n")
 			}
 		}
-		x.shellPath.Store(shell)
+		shellPath.Store(shell)
 	}
+	return ExecCommandWith(shell, command, setpgid)
+}
+
+// ExecCommandWith executes the given command with the specified shell
+// FIXME: setpgid is unused. We set it in the Unix implementation so that we
+// can kill preview process with its child processes at once.
+// NOTE: For "powershell", we should ideally set output encoding to UTF8,
+// but it is left as is now because no adverse effect has been observed.
+func ExecCommandWith(shell string, command string, setpgid bool) *exec.Cmd {
 	var cmd *exec.Cmd
-	if x.shellType == shellTypeCmd {
+	if strings.Contains(shell, "cmd") {
 		cmd = exec.Command(shell)
 		cmd.SysProcAttr = &syscall.SysProcAttr{
 			HideWindow:    false,
-			CmdLine:       fmt.Sprintf(`%s "%s"`, strings.Join(x.args, " "), command),
+			CmdLine:       fmt.Sprintf(` /v:on/s/c "%s"`, command),
 			CreationFlags: 0,
 		}
+		return cmd
+	}
+
+	if strings.Contains(shell, "pwsh") || strings.Contains(shell, "powershell") {
+		cmd = exec.Command(shell, "-NoProfile", "-Command", command)
 	} else {
-		cmd = exec.Command(shell, append(x.args, command)...)
-		cmd.SysProcAttr = &syscall.SysProcAttr{
-			HideWindow:    false,
-			CreationFlags: 0,
-		}
+		cmd = exec.Command(shell, "-c", command)
+	}
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow:    false,
+		CreationFlags: 0,
 	}
 	return cmd
 }
 
-func (x *Executor) Become(stdin *os.File, environ []string, command string) {
-	cmd := x.ExecCommand(command, false)
-	cmd.Stdin = stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Env = environ
-	err := cmd.Start()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "fzf (become): %s\n", err.Error())
-		os.Exit(127)
-	}
-	err = cmd.Wait()
-	if err != nil {
-		if exitError, ok := err.(*exec.ExitError); ok {
-			os.Exit(exitError.ExitCode())
-		}
-	}
-	os.Exit(0)
-}
-
-func escapeArg(s string) string {
-	b := make([]byte, 0, len(s)+2)
-	b = append(b, '"')
-	slashes := 0
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		switch c {
-		default:
-			slashes = 0
-		case '\\':
-			slashes++
-		case '"':
-			for ; slashes > 0; slashes-- {
-				b = append(b, '\\')
-			}
-			b = append(b, '\\')
-		}
-		b = append(b, c)
-	}
-	for ; slashes > 0; slashes-- {
-		b = append(b, '\\')
-	}
-	b = append(b, '"')
-	return escapeRegex.ReplaceAllStringFunc(string(b), func(match string) string {
-		return "^" + match
-	})
-}
-
-func (x *Executor) QuoteEntry(entry string) string {
-	switch x.shellType {
-	case shellTypeCmd:
-		/* Manually tested with the following commands:
-		   fzf --preview "echo {}"
-		   fzf --preview "type {}"
-		   echo .git\refs\| fzf --preview "dir {}"
-		   echo .git\refs\\| fzf --preview "dir {}"
-		   echo .git\refs\\\| fzf --preview "dir {}"
-		   reg query HKCU | fzf --reverse --bind "enter:reload(reg query {})"
-		   fzf --disabled --preview "echo {q} {n} {}" --query "&|<>()@^%!"
-		   fd -H --no-ignore -td -d 4 | fzf --preview "dir {}"
-		   fd -H --no-ignore -td -d 4 | fzf --preview "eza {}" --preview-window up
-		   fd -H --no-ignore -td -d 4 | fzf --preview "eza --color=always --tree --level=3 --icons=always {}"
-		   fd -H --no-ignore -td -d 4 | fzf --preview ".\eza.exe --color=always --tree --level=3 --icons=always {}" --with-shell "powershell -NoProfile -Command"
-		*/
-		return escapeArg(entry)
-	case shellTypePowerShell:
-		escaped := strings.ReplaceAll(entry, `"`, `\"`)
-		return "'" + strings.ReplaceAll(escaped, "'", "''") + "'"
-	default:
-		return "'" + strings.ReplaceAll(entry, "'", "'\\''") + "'"
-	}
-}
-
 // KillCommand kills the process for the given command
 func KillCommand(cmd *exec.Cmd) error {
 	return cmd.Process.Kill()
@@ -183,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
-}

typos.toml

@@ -1,10 +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"
-Iterm = "Iterm"
-
-[files]
-extend-exclude = ["README.md"]

uninstall

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