Ignore invalid byte sequence in UTF-8

This command would cause a deadlock and make fzf crash:

  fzf --bind 'start:reload:ls' --height ~100%

Because,

1. 'start' event is handled by Terminal
2. When 'reload' is bound to 'start', fzf avoids starting the initial reader
3. Terminal waits for the initial input to find the right height when
   adaptive height is used
4. Because the initial reader is not started, Terminal never gets the
   initial list
5. No chance to trigger 'start:reload', hence deadlock

This commit fixes the above problem by extracting the reload command
bound to 'start' event and starting the initial reader with that command
instead of letting Terminal start it.

This commit also makes the environment variables available to
$FZF_DEFAULT_COMMAND.

  FZF_DEFAULT_COMMAND='echo $FZF_QUERY' fzf --query foo

Fix #3944

.github/workflows/linux.yml

@@ -46,6 +46,3 @@ jobs:
 
     - 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

.github/workflows/typos.yml

@@ -7,4 +7,4 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
-    - uses: crate-ci/typos@v1.20.10
+    - uses: crate-ci/typos@v1.23.1

.github/workflows/winget.yml

@@ -10,6 +10,5 @@ jobs:
       - 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

@@ -1,4 +1,5 @@
 ---
+version: 2
 project_name: fzf
 
 before:
@@ -6,60 +7,9 @@ before:
     - go mod download
 
 builds:
-  - id: fzf-macos
-    binary: fzf
-    goos:
-      - 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"
-        sign {
-          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
-        }
-        zip {
-          output_path = "./dist/fzf-{{ .Version }}-darwin_amd64.zip"
-        }
-        EOF
-        gon /tmp/fzf-gon-amd64.hcl
-        '
-
-  - id: fzf-macos-arm
-    binary: fzf
-    goos:
-      - darwin
-    goarch:
-      - arm64
-    flags:
-      - -trimpath
-    ldflags:
-      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
-    hooks:
-      post: |
-        sh -c '
-        cat > /tmp/fzf-gon-arm64.hcl << EOF
-        source = ["./dist/fzf-macos-arm_darwin_arm64/fzf"]
-        bundle_id = "junegunn.fzf"
-        sign {
-          application_identity = "Developer ID Application: Junegunn Choi (Y254DRW44Z)"
-        }
-        zip {
-          output_path = "./dist/fzf-{{ .Version }}-darwin_arm64.zip"
-        }
-        EOF
-        gon /tmp/fzf-gon-arm64.hcl
-        '
-
   - id: fzf
     goos:
+      - darwin
       - linux
       - windows
       - freebsd
@@ -89,6 +39,42 @@ builds:
       - goos: openbsd
         goarch: arm64
 
+# .goreleaser.yaml
+notarize:
+  macos:
+    - # Whether this configuration is enabled or not.
+      #
+      # Default: false.
+      # Templates: allowed.
+      enabled: "{{ not .IsSnapshot }}"
+
+      # Before notarizing, we need to sign the binary.
+      # This blocks defines the configuration for doing so.
+      sign:
+        # The .p12 certificate file path or its base64'd contents.
+        certificate: "{{.Env.MACOS_SIGN_P12}}"
+
+        # The password to be used to open the certificate.
+        password: "{{.Env.MACOS_SIGN_PASSWORD}}"
+
+      # Then, we notarize the binaries.
+      notarize:
+        # The issuer ID.
+        # Its the UUID you see when creating the App Store Connect key.
+        issuer_id: "{{.Env.MACOS_NOTARY_ISSUER_ID}}"
+
+        # Key ID.
+        # You can see it in the list of App Store Connect Keys.
+        # It will also be in the ApiKey filename.
+        key_id: "{{.Env.MACOS_NOTARY_KEY_ID}}"
+
+        # The .p8 key file path or its base64'd contents.
+        key: "{{.Env.MACOS_NOTARY_KEY}}"
+
+        # Whether to wait for the notarization to finish.
+        # Not recommended, as it could take a really long time.
+        wait: true
+
 archives:
   - name_template: "{{ .ProjectName }}-{{ .Version }}-{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
     builds:
@@ -100,21 +86,15 @@ archives:
     files:
       - non-existent*
 
-checksum:
-  extra_files:
-    - glob: ./dist/fzf-*darwin*.zip
-
 release:
   github:
     owner: junegunn
     name: fzf
   prerelease: auto
-  name_template: '{{ .Tag }}'
-  extra_files:
-    - glob: ./dist/fzf-*darwin*.zip
+  name_template: '{{ .Version }}'
 
 snapshot:
-  name_template: "{{ .Tag }}-devel"
+  name_template: "{{ .Version }}-devel"
 
 changelog:
   sort: asc

ADVANCED.md

@@ -1,18 +1,17 @@
 Advanced fzf examples
 ======================
 
-* *Last update: 2024/01/20*
-* *Requires fzf 0.46.0 or above*
+* *Last update: 2024/06/24*
+* *Requires fzf 0.54.0 or later*
 
 ---
 
 <!-- vim-markdown-toc GFM -->
 
 * [Introduction](#introduction)
-* [Screen Layout](#screen-layout)
+* [Display modes](#display-modes)
     * [`--height`](#--height)
-    * [`fzf-tmux`](#fzf-tmux)
-        * [Popup window support](#popup-window-support)
+    * [`--tmux`](#--tmux)
 * [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)
@@ -63,7 +62,7 @@ learn its wide variety of features.
 This document will guide you through some examples that will familiarize you
 with the advanced features of fzf.
 
-Screen Layout
+Display modes
 -------------
 
 ### `--height`
@@ -104,56 +103,55 @@ Define `$FZF_DEFAULT_OPTS` like so:
 export FZF_DEFAULT_OPTS="--height=40% --layout=reverse --info=inline --border --margin=1 --padding=1"
 ```
 
-### `fzf-tmux`
+### `--tmux`
 
-Before fzf had `--height` option, we would open fzf in a tmux split pane not
-to take up the whole screen. This is done using `fzf-tmux` script.
+(Requires tmux 3.3 or later)
+
+If you're using tmux, you can open fzf in a tmux popup using `--tmux` option.
 
 ```sh
-# Open fzf on a tmux split pane below the current pane.
-# Takes the same set of options.
-fzf-tmux --layout=reverse
+# Open fzf in a tmux popup at the center of the screen with 70% width and height
+fzf --tmux 70%
 ```
 
-![image](https://user-images.githubusercontent.com/700826/113379973-f1cc6500-93b5-11eb-8860-c9bc4498aadf.png)
+![image](https://github.com/junegunn/fzf/assets/700826/9c365405-c700-49b2-8985-60d822ed4cff)
 
-The limitation of `fzf-tmux` is that it only works when you're on tmux unlike
-`--height` option. But the advantage of it is that it's more flexible.
-(See `man fzf-tmux` for available options.)
+`--tmux` option is silently ignored if you're not on tmux. So if you're trying
+to avoid opening fzf in fullscreen, try specifying both `--height` and `--tmux`.
 
 ```sh
-# On the right (50%)
-fzf-tmux -r
-
-# On the left (30%)
-fzf-tmux -l30%
-
-# Above the cursor
-fzf-tmux -u30%
+# --tmux is specified later so it takes precedence over --height when on tmux.
+# If you're not on tmux, --tmux is ignored and --height is used instead.
+fzf  --height 70% --tmux 70%
 ```
 
-![image](https://user-images.githubusercontent.com/700826/113379983-fa24a000-93b5-11eb-93eb-8a3d39b2f163.png)
+You can also specify the position, width, and height of the popup window in
+the following format:
 
-![image](https://user-images.githubusercontent.com/700826/113380001-0577cb80-93b6-11eb-95d0-2ba453866882.png)
-
-![image](https://user-images.githubusercontent.com/700826/113380040-1d4f4f80-93b6-11eb-9bef-737fb120aafe.png)
-
-#### Popup window support
-
-But here's the really cool part; tmux 3.2 added support for popup windows. So
-you can open fzf in a popup window, which is quite useful if you frequently
-use split panes.
+* `[center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]`
 
 ```sh
-# Open tmux in a tmux popup window (default size: 50% of the screen)
-fzf-tmux -p
-
-# 80% width, 60% height
-fzf-tmux -p 80%,60%
+# 100% width and 60% height
+fzf --tmux 100%,60% --border horizontal
 ```
 
-![image](https://user-images.githubusercontent.com/700826/113380106-4a9bfd80-93b6-11eb-8cee-aeb1c4ce1a1f.png)
+![image](https://github.com/junegunn/fzf/assets/700826/f80d3514-d69f-42f2-a8de-a392a562bfcf)
 
+```sh
+# On the right (50% width)
+fzf --tmux right
+```
+
+![image](https://github.com/junegunn/fzf/assets/700826/4033ade4-7efa-421b-a3fb-a430d197098a)
+
+```sh
+# On the left (40% width and 70% height)
+fzf --tmux left,40%,70%
+```
+
+![image](https://github.com/junegunn/fzf/assets/700826/efe43881-2bf0-49ea-ab2e-1377f778cd52)
+
+> [!TIP]
 > You might also want to check out my tmux plugins which support this popup
 > window layout.
 >
@@ -363,7 +361,7 @@ 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" \
+fzf --ansi --disabled --query "$INITIAL_QUERY" \
     --bind "start:reload:$RG_PREFIX {q}" \
     --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
     --delimiter : \
@@ -374,11 +372,9 @@ INITIAL_QUERY="${*:-}"
 
 ![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 the usual `rg ... | fzf` form, we make it start
+  the initial Ripgrep process immediately via `start:reload` binding for the
+  consistency of the code.
 - 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
@@ -402,7 +398,7 @@ 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" \
+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" \
@@ -446,7 +442,7 @@ 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" \
+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)" \
@@ -489,7 +485,7 @@ prevent immediate evaluation.
 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" \
+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 ]] &&
@@ -529,15 +525,15 @@ Kubernetes pods.
 
 ```bash
 pods() {
-  : | command='kubectl get pods --all-namespaces' fzf \
+  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' \
+    --bind 'enter:execute:kubectl exec -it --namespace {1} {2} -- bash' \
+    --bind 'ctrl-o:execute:${EDITOR:-vim} <(kubectl logs --all-containers --namespace {1} {2})' \
     --preview-window up:follow \
     --preview 'kubectl logs --follow --all-containers --tail=10000 --namespace {1} {2}' "$@"
 }

CHANGELOG.md

@@ -1,6 +1,197 @@
 CHANGELOG
 =========
 
+0.54.3
+------
+- Fixed incompatibility of adaptive height and 'start:reload'
+- Environment variables are now available to `$FZF_DEFAULT_COMMAND`
+  ```sh
+  FZF_DEFAULT_COMMAND='echo $FZF_QUERY' fzf --query foo
+  ```
+
+0.54.2
+------
+- Fixed incorrect syntax highlighting of truncated multi-line entries
+- Updated GoReleaser to 2.1.0 to simplify notarization of macOS binaries
+    - macOS archives will be in `tar.gz` format instead of `zip` format since we no longer notarize the zip files but binaries
+- (Windows) Reverted a mintty fix in 0.54.0
+    - As a result, mouse may not work on mintty in fullscreen mode. However, fzf will correctly read non-ASCII input in fullscreen mode (`--no-height`).
+    - fzf unfortunately cannot read non-ASCII input when not in fullscreen mode on Windows. So if you need to input non-ASCII characters, add `--no-height` to your `$FZF_DEFAULT_OPTS`.
+    - Any help in fixing this issue will be appreciated (#3799, #3847).
+
+0.54.1
+------
+- Updated [fastwalk](https://github.com/charlievieth/fastwalk) dependency for built-in directory walker
+    - [fastwalk: add optional sorting and improve documentation](https://github.com/charlievieth/fastwalk/pull/27)
+    - [fastwalk: only check if MSYSTEM is set during MSYS/MSYS2](https://github.com/charlievieth/fastwalk/pull/28)
+    - Thanks to @charlievieth
+- Reverted ALT-C binding of fish to use `cd` instead of `builtin cd`
+    - `builtin cd` was introduced to work around a bug of `cd` coming from `zoxide init --cmd cd fish` where it cannot handle `--` argument.
+    - However, the default `cd` of fish is actually a wrapper function for supporting `cd -`, so we want to use it instead.
+    - See [#3928](https://github.com/junegunn/fzf/pull/3928) for more information and consider helping zoxide fix the bug.
+
+0.54.0
+------
+_Release highlights: https://junegunn.github.io/fzf/releases/0.54.0/_
+
+- Implemented line wrap of long items
+    - `--wrap` option enables line wrap
+    - `--wrap-sign` customizes the sign for wrapped lines (default: `↳ `)
+    - `toggle-wrap` action toggles line wrap
+      ```sh
+      history | fzf --tac --wrap --bind 'ctrl-/:toggle-wrap' --wrap-sign $'\t↳ '
+      ```
+    - fzf by default binds `CTRL-/` and `ALT-/` to `toggle-wrap`
+- Updated shell integration scripts to leverage line wrap
+    - CTRL-R binding includes `--wrap-sign $'\t↳ '` to indent wrapped lines
+    - `kill **` completion uses `--wrap` to show the whole line by default
+      instead of showing it in the preview window
+- Added `--info-command` option for customizing the info line
+  ```sh
+  # Prepend the current cursor position in yellow
+  fzf --info-command='echo -e "\x1b[33;1m$FZF_POS\x1b[m/$FZF_INFO 💛"'
+  ```
+    - `$FZF_INFO` is set to the original info text
+    - ANSI color codes are supported
+- Pointer and marker signs can be set to empty strings
+  ```sh
+  # Minimal style
+  fzf --pointer '' --marker '' --prompt '' --info hidden
+  ```
+- Better cache management and improved rendering for `--tail`
+- Improved `--sync` behavior
+    - When `--sync` is provided, fzf will not render the interface until the initial filtering and the associated actions (bound to any of `start`, `load`, `result`, or `focus`) are complete.
+      ```sh
+      # fzf will not render intermediate states
+      (sleep 1; seq 1000000; sleep 1) |
+        fzf --sync --query 5 --listen --bind start:up,load:up,result:up,focus:change-header:Ready
+      ```
+- GET endpoint is now available from `execute` and `transform` actions (it used to timeout due to lock conflict)
+  ```sh
+  fzf --listen --sync --bind 'focus:transform-header:curl -s localhost:$FZF_PORT?limit=0 | jq .'
+  ```
+- Added `offset-middle` action to place the current item is in the middle of the screen
+- fzf will not start the initial reader when `reload` or `reload-sync` is bound to `start` event. `fzf < /dev/null` or `: | fzf` are no longer required and extraneous `load` event will not fire due to the empty list.
+  ```sh
+  # Now this will work as expected. Previously, this would print an invalid header line.
+  # `fzf < /dev/null` or `: | fzf` would fix the problem, but then an extraneous 
+  # `load` event would fire and the header would be prematurely updated.
+  fzf --header 'Loading ...' --header-lines 1 \
+      --bind 'start:reload:sleep 1; ps -ef' \
+      --bind 'load:change-header:Loaded!'
+  ```
+- Fixed mouse support on Windows
+- Fixed crash when using `--tiebreak=end` with very long items
+- zsh 5.0 compatibility (thanks to @LangLangBart)
+- Fixed `--walker-skip` to also skip symlinks to directories
+- Fixed `result` event not fired when input stream is not complete
+- New tags will have `v` prefix so that they are available on https://proxy.golang.org/
+
+0.53.0
+------
+_Release highlights: https://junegunn.github.io/fzf/releases/0.53.0/_
+
+- Multi-line display
+    - See [Processing multi-line items](https://junegunn.github.io/fzf/tips/processing-multi-line-items/)
+    - fzf can now display multi-line items
+      ```sh
+      # All bash functions, highlighted
+      declare -f | perl -0777 -pe 's/^}\n/}\0/gm' |
+        bat --plain --language bash --color always |
+        fzf --read0 --ansi --reverse --multi --highlight-line
+
+      # Ripgrep multi-line output
+      rg --pretty bash | perl -0777 -pe 's/\n\n/\n\0/gm' |
+        fzf --read0 --ansi --multi --highlight-line --reverse --tmux 70%
+      ```
+        - To disable multi-line display, use `--no-multi-line`
+    - CTRL-R bindings of bash, zsh, and fish have been updated to leverage multi-line display
+    - The default `--pointer` and `--marker` have been changed from `>` to Unicode bar characters as they look better with multi-line items
+    - Added `--marker-multi-line` to customize the select marker for multi-line entries with the default set to `╻┃╹`
+      ```
+      ╻First line
+      ┃...
+      ╹Last line
+      ```
+- Native tmux integration
+    - Added `--tmux` option to replace fzf-tmux script and simplify distribution
+      ```sh
+      # --tmux [center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]
+      # Center, 100% width and 70% height
+      fzf --tmux 100%,70% --border horizontal --padding 1,2
+
+      # Left, 30% width
+      fzf --tmux left,30%
+
+      # Bottom, 50% height
+      fzf --tmux bottom,50%
+      ```
+        - To keep the implementation simple, it only uses popups. You need tmux 3.3 or later.
+    - To use `--tmux` in Vim plugin:
+      ```vim
+      let g:fzf_layout = { 'tmux': '100%,70%' }
+      ```
+- Added support for endless input streams
+    - See [Browsing log stream with fzf](https://junegunn.github.io/fzf/tips/browsing-log-streams/)
+    - Added `--tail=NUM` option to limit the number of items to keep in memory. This is useful when you want to browse an endless stream of data (e.g. log stream) with fzf while limiting memory usage.
+      ```sh
+      # Interactive filtering of a log stream
+      tail -f *.log | fzf --tail 100000 --tac --no-sort --exact
+      ```
+- Better Windows Support
+    - fzf now works on Git bash (mintty) out of the box via winpty integration
+    - Many fixes and improvements for Windows
+- man page is now embedded in the binary; `fzf --man` to see it
+- Changed the default `--scroll-off` to 3, as we think it's a better default
+- Process started by `execute` action now directly writes to and reads from `/dev/tty`. Manual `/dev/tty` redirection for interactive programs is no longer required.
+  ```sh
+  # Vim will work fine without /dev/tty redirection
+  ls | fzf --bind 'space:execute:vim {}' > selected
+  ```
+- Added `print(...)` action to queue an arbitrary string to be printed on exit. This was mainly added to work around the limitation of `--expect` where it's not compatible with `--bind` on the same key and it would ignore other actions bound to it.
+  ```sh
+  # This doesn't work as expected because --expect is not compatible with --bind
+  fzf --multi --expect ctrl-y --bind 'ctrl-y:select-all'
+
+  # This is something you can do instead
+  fzf --multi --bind 'enter:print()+accept,ctrl-y:select-all+print(ctrl-y)+accept'
+  ```
+    - We also considered making them compatible, but realized that some users may have been relying on the current behavior.
+- [`NO_COLOR`](https://no-color.org/) environment variable is now respected. If the variable is set, fzf defaults to `--no-color` unless otherwise specified.
+
+0.52.1
+------
+- Fixed a critical bug in the Windows version
+    - Windows users are strongly encouraged to upgrade to this version
+
+0.52.0
+------
+- Added `--highlight-line` to highlight the whole current line (à la `set cursorline` of Vim)
+- Added color names for selected lines: `selected-fg`, `selected-bg`, and `selected-hl`
+  ```sh
+  fzf --border --multi --info inline-right --layout reverse --marker ▏ --pointer ▌ --prompt '▌ '  \
+      --highlight-line --color gutter:-1,selected-bg:238,selected-fg:146,current-fg:189
+  ```
+- Added `click-header` event that is triggered when the header section is clicked. When the event is triggered, `$FZF_CLICK_HEADER_COLUMN` and `$FZF_CLICK_HEADER_LINE` are set.
+  ```sh
+  fd --type f |
+    fzf --header $'[Files] [Directories]' --header-first \
+        --bind 'click-header:transform:
+          (( FZF_CLICK_HEADER_COLUMN <= 7 )) && echo "reload(fd --type f)"
+          (( FZF_CLICK_HEADER_COLUMN >= 9 )) && echo "reload(fd --type d)"
+        '
+  ```
+- Add `$FZF_COMPLETION_{DIR,PATH}_OPTS` for separately customizing the behavior of fuzzy completion
+  ```sh
+  # Set --walker options without 'follow' not to follow symbolic links
+  FZF_COMPLETION_PATH_OPTS="--walker=file,dir,hidden"
+  FZF_COMPLETION_DIR_OPTS="--walker=dir,hidden"
+  ```
+- Fixed Windows argument escaping
+- Bug fixes and improvements
+- The code was heavily refactored to allow using fzf as a library in Go programs. The API is still experimental and subject to change.
+    - https://gist.github.com/junegunn/193990b65be48a38aac6ac49d5669170
+
 0.51.0
 ------
 - Added a new environment variable `$FZF_POS` exported to the child processes. It's the vertical position of the cursor in the list starting from 1.

Makefile

@@ -1,20 +1,20 @@
 SHELL          := bash
 GO             ?= go
-GOOS           ?= $(word 1, $(subst /, " ", $(word 4, $(shell go version))))
+GOOS           ?= $(shell $(GO) env GOOS)
 
 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 shell/*sh man/man1/*.1) $(MAKEFILE)
 
 ifdef FZF_VERSION
 VERSION        := $(FZF_VERSION)
 else
-VERSION        := $(shell git describe --abbrev=0 2> /dev/null)
+VERSION        := $(shell git describe --abbrev=0 2> /dev/null | sed "s/^v//")
 endif
 ifeq ($(VERSION),)
 $(error Not on git repository; cannot determine $$FZF_VERSION)
 endif
-VERSION_TRIM   := $(shell sed "s/-.*//" <<< $(VERSION))
+VERSION_TRIM   := $(shell sed "s/^v//; s/-.*//" <<< $(VERSION))
 VERSION_REGEX  := $(subst .,\.,$(VERSION_TRIM))
 
 ifdef FZF_REVISION
@@ -79,7 +79,6 @@ all: target/$(BINARY)
 test: $(SOURCES)
 	[ -z "$$(gofmt -s -d src)" ] || (gofmt -s -d src; exit 1)
 	SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" \
-				github.com/junegunn/fzf \
 				github.com/junegunn/fzf/src \
 				github.com/junegunn/fzf/src/algo \
 				github.com/junegunn/fzf/src/tui \

README-VIM.md

@@ -294,7 +294,7 @@ The following table summarizes the available options.
 | `options`                  | string/list   | Options to fzf                                                        |
 | `dir`                      | string        | Working directory                                                     |
 | `up`/`down`/`left`/`right` | number/string | (Layout) Window position and size (e.g. `20`, `50%`)                  |
-| `tmux`                     | string        | (Layout) fzf-tmux options (e.g. `-p90%,60%`)                          |
+| `tmux`                     | string        | (Layout) `--tmux` options (e.g. `90%,70%`)                            |
 | `window` (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g. `vertical aboveleft 30new`) |
 | `window` (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g. `{'width': 0.9, 'height': 0.6}`) |
 
@@ -457,12 +457,13 @@ let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 ```
 
 Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
-or above) by putting fzf-tmux options in `tmux` key.
+or above) by putting `--tmux` option value in `tmux` key.
 
 ```vim
-" See `man fzf-tmux` for available options
+" See `--tmux` option in `man fzf` for available options
+" [center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]
 if exists('$TMUX')
-  let g:fzf_layout = { 'tmux': '-p90%,60%' }
+  let g:fzf_layout = { 'tmux': '90%,70%' }
 else
   let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 endif

README.md

@@ -23,19 +23,19 @@ fzf is a general-purpose command-line fuzzy finder.
 
 <img src="https://raw.githubusercontent.com/junegunn/i/master/fzf-preview.png" width=640>
 
-It's an interactive Unix filter for command-line that can be used with any
-list; files, command history, processes, hostnames, bookmarks, git commits,
-etc.
+It's an interactive filter program for any kind of list; files, command
+history, processes, hostnames, bookmarks, git commits, etc. It implements
+a "fuzzy" matching algorithm, so you can quickly type in patterns with omitted
+characters and still get the results you want.
 
 Pros
 ----
 
 - Portable, no dependencies
 - Blazingly fast
-- The most comprehensive feature set
-- Flexible layout
+- Extremely versatile
 - Batteries included
-    - Vim/Neovim plugin, key bindings, and fuzzy auto-completion
+    - bash/zsh/fish integration, tmux integration, Vim/Neovim plugin
 
 Sponsors ❤️
 -----------
@@ -44,7 +44,7 @@ I would like to thank all the sponsors of this project who make it possible for
 
 If you'd like to sponsor this project, please visit https://github.com/sponsors/junegunn.
 
-<!-- sponsors --><a href="https://github.com/miyanokomiya"><img src="https://github.com/miyanokomiya.png" width="60px" alt="miyanokomiya" /></a><a href="https://github.com/jonhoo"><img src="https://github.com/jonhoo.png" width="60px" alt="Jon Gjengset" /></a><a href="https://github.com/AceofSpades5757"><img src="https://github.com/AceofSpades5757.png" width="60px" alt="Kyle L. Davis" /></a><a href="https://github.com/Frederick888"><img src="https://github.com/Frederick888.png" width="60px" alt="Frederick Zhang" /></a><a href="https://github.com/moritzdietz"><img src="https://github.com/moritzdietz.png" width="60px" alt="Moritz Dietz" /></a><a href="https://github.com/mikker"><img src="https://github.com/mikker.png" width="60px" alt="Mikkel Malmberg" /></a><a href="https://github.com/pldubouilh"><img src="https://github.com/pldubouilh.png" width="60px" alt="Pierre Dubouilh" /></a><a href="https://github.com/rcorre"><img src="https://github.com/rcorre.png" width="60px" alt="Ryan Roden-Corrent" /></a><a href="https://github.com/blissdev"><img src="https://github.com/blissdev.png" width="60px" alt="Jordan Arentsen" /></a><a href="https://github.com/mislav"><img src="https://github.com/mislav.png" width="60px" alt="Mislav Marohnić" /></a><a href="https://github.com/aexvir"><img src="https://github.com/aexvir.png" width="60px" alt="Alex Viscreanu" /></a><a href="https://github.com/dbalatero"><img src="https://github.com/dbalatero.png" width="60px" alt="David Balatero" /></a><a href="https://github.com/comatory"><img src="https://github.com/comatory.png" width="60px" alt="Ondrej Synacek" /></a><a href="https://github.com/moobar"><img src="https://github.com/moobar.png" width="60px" alt="" /></a><a href="https://github.com/majjoha"><img src="https://github.com/majjoha.png" width="60px" alt="Mathias Jean Johansen" /></a><a href="https://github.com/benelan"><img src="https://github.com/benelan.png" width="60px" alt="Ben Elan" /></a><a href="https://github.com/pawelduda"><img src="https://github.com/pawelduda.png" width="60px" alt="Paweł Duda" /></a><a href="https://github.com/slezica"><img src="https://github.com/slezica.png" width="60px" alt="Santiago Lezica" /></a><a href="https://github.com/pbwn"><img src="https://github.com/pbwn.png" width="60px" alt="" /></a><a href="https://github.com/timgluz"><img src="https://github.com/timgluz.png" width="60px" alt="Timo Sulg" /></a><a href="https://github.com/pyrho"><img src="https://github.com/pyrho.png" width="60px" alt="Damien Rajon" /></a><a href="https://github.com/ArtBIT"><img src="https://github.com/ArtBIT.png" width="60px" alt="ArtBIT" /></a><a href="https://github.com/da-moon"><img src="https://github.com/da-moon.png" width="60px" alt="" /></a><a href="https://github.com/hovissimo"><img src="https://github.com/hovissimo.png" width="60px" alt="Hovis" /></a><a href="https://github.com/dariusjonda"><img src="https://github.com/dariusjonda.png" width="60px" alt="Darius Jonda" /></a><a href="https://github.com/cristiand391"><img src="https://github.com/cristiand391.png" width="60px" alt="Cristian Dominguez" /></a><a href="https://github.com/eliangcs"><img src="https://github.com/eliangcs.png" width="60px" alt="Chang-Hung Liang" /></a><a href="https://github.com/asphaltbuffet"><img src="https://github.com/asphaltbuffet.png" width="60px" alt="Ben Lechlitner" /></a><a href="https://github.com/yash1th"><img src="https://github.com/yash1th.png" width="60px" alt="yash" /></a><a href="https://github.com/looshch"><img src="https://github.com/looshch.png" width="60px" alt="george looshch" /></a><a href="https://github.com/kg8m"><img src="https://github.com/kg8m.png" width="60px" alt="Takumi KAGIYAMA" /></a><a href="https://github.com/polm"><img src="https://github.com/polm.png" width="60px" alt="Paul O'Leary McCann" /></a><a href="https://github.com/rbeeger"><img src="https://github.com/rbeeger.png" width="60px" alt="Robert Beeger" /></a><a href="https://github.com/veebch"><img src="https://github.com/veebch.png" width="60px" alt="VEEB Projects" /></a><a href="https://github.com/khuedoan"><img src="https://github.com/khuedoan.png" width="60px" alt="Khue Doan" /></a><a href="https://github.com/yowayb"><img src="https://github.com/yowayb.png" width="60px" alt="Yoway Buorn" /></a><a href="https://github.com/scalisi"><img src="https://github.com/scalisi.png" width="60px" alt="Josh Scalisi" /></a><a href="https://github.com/alecbcs"><img src="https://github.com/alecbcs.png" width="60px" alt="Alec Scott" /></a><a href="https://github.com/thnxdev"><img src="https://github.com/thnxdev.png" width="60px" alt="thanks.dev" /></a><a href="https://github.com/artursapek"><img src="https://github.com/artursapek.png" width="60px" alt="Artur Sapek" /></a><a href="https://github.com/ramnes"><img src="https://github.com/ramnes.png" width="60px" alt="Guillaume Gelin" /></a><a href="https://github.com/jyc"><img src="https://github.com/jyc.png" width="60px" alt="" /></a><a href="https://github.com/Line truncated
+<!-- sponsors --><a href="https://github.com/miyanokomiya"><img src="https://github.com/miyanokomiya.png" width="60px" alt="miyanokomiya" /></a><a href="https://github.com/jonhoo"><img src="https://github.com/jonhoo.png" width="60px" alt="Jon Gjengset" /></a><a href="https://github.com/AceofSpades5757"><img src="https://github.com/AceofSpades5757.png" width="60px" alt="Kyle L. Davis" /></a><a href="https://github.com/Frederick888"><img src="https://github.com/Frederick888.png" width="60px" alt="Frederick Zhang" /></a><a href="https://github.com/moritzdietz"><img src="https://github.com/moritzdietz.png" width="60px" alt="Moritz Dietz" /></a><a href="https://github.com/mikker"><img src="https://github.com/mikker.png" width="60px" alt="Mikkel Malmberg" /></a><a href="https://github.com/pldubouilh"><img src="https://github.com/pldubouilh.png" width="60px" alt="Pierre Dubouilh" /></a><a href="https://github.com/rcorre"><img src="https://github.com/rcorre.png" width="60px" alt="Ryan Roden-Corrent" /></a><a href="https://github.com/blissdev"><img src="https://github.com/blissdev.png" width="60px" alt="Jordan Arentsen" /></a><a href="https://github.com/mislav"><img src="https://github.com/mislav.png" width="60px" alt="Mislav Marohnić" /></a><a href="https://github.com/aexvir"><img src="https://github.com/aexvir.png" width="60px" alt="Alex Viscreanu" /></a><a href="https://github.com/dbalatero"><img src="https://github.com/dbalatero.png" width="60px" alt="David Balatero" /></a><a href="https://github.com/moobar"><img src="https://github.com/moobar.png" width="60px" alt="" /></a><a href="https://github.com/majjoha"><img src="https://github.com/majjoha.png" width="60px" alt="Mathias Jean Johansen" /></a><a href="https://github.com/benelan"><img src="https://github.com/benelan.png" width="60px" alt="Ben Elan" /></a><a href="https://github.com/pawelduda"><img src="https://github.com/pawelduda.png" width="60px" alt="Paweł Duda" /></a><a href="https://github.com/slezica"><img src="https://github.com/slezica.png" width="60px" alt="Santiago Lezica" /></a><a href="https://github.com/pbwn"><img src="https://github.com/pbwn.png" width="60px" alt="" /></a><a href="https://github.com/timgluz"><img src="https://github.com/timgluz.png" width="60px" alt="Timo Sulg" /></a><a href="https://github.com/pyrho"><img src="https://github.com/pyrho.png" width="60px" alt="Damien Rajon" /></a><a href="https://github.com/ArtBIT"><img src="https://github.com/ArtBIT.png" width="60px" alt="ArtBIT" /></a><a href="https://github.com/da-moon"><img src="https://github.com/da-moon.png" width="60px" alt="" /></a><a href="https://github.com/hovissimo"><img src="https://github.com/hovissimo.png" width="60px" alt="Hovis" /></a><a href="https://github.com/dariusjonda"><img src="https://github.com/dariusjonda.png" width="60px" alt="Darius Jonda" /></a><a href="https://github.com/cristiand391"><img src="https://github.com/cristiand391.png" width="60px" alt="Cristian Dominguez" /></a><a href="https://github.com/eliangcs"><img src="https://github.com/eliangcs.png" width="60px" alt="Chang-Hung Liang" /></a><a href="https://github.com/asphaltbuffet"><img src="https://github.com/asphaltbuffet.png" width="60px" alt="Ben Lechlitner" /></a><a href="https://github.com/yash1th"><img src="https://github.com/yash1th.png" width="60px" alt="yash" /></a><a href="https://github.com/looshch"><img src="https://github.com/looshch.png" width="60px" alt="george looshch" /></a><a href="https://github.com/kg8m"><img src="https://github.com/kg8m.png" width="60px" alt="Takumi KAGIYAMA" /></a><a href="https://github.com/polm"><img src="https://github.com/polm.png" width="60px" alt="Paul O'Leary McCann" /></a><a href="https://github.com/rbeeger"><img src="https://github.com/rbeeger.png" width="60px" alt="Robert Beeger" /></a><a href="https://github.com/veebch"><img src="https://github.com/veebch.png" width="60px" alt="VEEB Projects" /></a><a href="https://github.com/yowayb"><img src="https://github.com/yowayb.png" width="60px" alt="Yoway Buorn" /></a><a href="https://github.com/scalisi"><img src="https://github.com/scalisi.png" width="60px" alt="Josh Scalisi" /></a><a href="https://github.com/alecbcs"><img src="https://github.com/alecbcs.png" width="60px" alt="Alec Scott" /></a><a href="https://github.com/the-shank"><img src="https://github.com/the-shank.png" width="60px" alt="theshank" /></a><a href="https://github.com/thnxdev"><img src="https://github.com/thnxdev.png" width="60px" alt="thanks.dev" /></a><a href="https://github.com/artursapek"><img src="https://github.com/artursapek.png" width="60px" alt="Artur Sapek" /></a><a href="https://github.com/ramnes"><img src="https://github.com/ramnes.png" width="60px" alt="Guillaume Gelin" /></a><a href="https://github.com/jyc"><img src="https://github.com/jyc.png" width="60px" alt="" /></a><a href="https://github.com/mrcnski"><img src="https://github.com/mrcnski.png" width="60px" alt="Marcin S." /></a><a href="https://github.com/roblevLine truncated
 
 Table of Contents
 -----------------
@@ -53,22 +53,24 @@ Table of Contents
 
 * [Installation](#installation)
     * [Using Homebrew](#using-homebrew)
+    * [Linux packages](#linux-packages)
+    * [Windows packages](#windows-packages)
     * [Using git](#using-git)
-    * [Using Linux package managers](#using-linux-package-managers)
-    * [Windows](#windows)
+    * [Binary releases](#binary-releases)
     * [Setting up shell integration](#setting-up-shell-integration)
-    * [As Vim plugin](#as-vim-plugin)
+    * [Vim/Neovim plugin](#vimneovim-plugin)
 * [Upgrading fzf](#upgrading-fzf)
 * [Building fzf](#building-fzf)
 * [Usage](#usage)
     * [Using the finder](#using-the-finder)
-    * [Layout](#layout)
+    * [Display modes](#display-modes)
+        * [`--height` mode](#--height-mode)
+        * [`--tmux` mode](#--tmux-mode)
     * [Search syntax](#search-syntax)
     * [Environment variables](#environment-variables)
     * [Options](#options)
     * [Demo](#demo)
 * [Examples](#examples)
-* [`fzf-tmux` script](#fzf-tmux-script)
 * [Key bindings for command-line](#key-bindings-for-command-line)
 * [Fuzzy completion for bash and zsh](#fuzzy-completion-for-bash-and-zsh)
     * [Files and directories](#files-and-directories)
@@ -101,28 +103,12 @@ Table of Contents
 Installation
 ------------
 
-fzf project consists of the following components:
-
-- `fzf` executable
-- `fzf-tmux` script for launching fzf in a tmux pane
-- Shell integration
-    - Key bindings (`CTRL-T`, `CTRL-R`, and `ALT-C`) (bash, zsh, fish)
-    - Fuzzy completion (bash, zsh)
-- Vim/Neovim plugin
-
-You can [download fzf executable][bin] alone if you don't need the extra
-stuff.
-
-[bin]: https://github.com/junegunn/fzf/releases
-
 ### Using Homebrew
 
-You can use [Homebrew](https://brew.sh/) (on macOS or Linux)
-to install fzf.
+You can use [Homebrew](https://brew.sh/) (on macOS or Linux) to install fzf.
 
 ```sh
 brew install fzf
-  # To build fzf from the latest source: brew install --HEAD fzf
 ```
 
 > [!IMPORTANT]
@@ -133,20 +119,7 @@ fzf is also available [via MacPorts][portfile]: `sudo port install fzf`
 
 [portfile]: https://github.com/macports/macports-ports/blob/master/sysutils/fzf/Portfile
 
-### Using git
-
-Alternatively, you can "git clone" this repository to any directory and run
-[install](https://github.com/junegunn/fzf/blob/master/install) script.
-
-```sh
-git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
-~/.fzf/install
-```
-
-The install script will add lines to your shell configuration file to modify
-`$PATH` and set up shell integration.
-
-### Using Linux package managers
+### Linux packages
 
 | Package Manager | Linux Distribution      | Command                            |
 | --------------- | ----------------------- | ---------------------------------- |
@@ -168,12 +141,12 @@ The install script will add lines to your shell configuration file to modify
 > To set up shell integration (key bindings and fuzzy completion),
 > see [the instructions below](#setting-up-shell-integration).
 
-[![Packaging status](https://repology.org/badge/vertical-allrepos/fzf.svg)](https://repology.org/project/fzf/versions)
+[![Packaging status](https://repology.org/badge/vertical-allrepos/fzf.svg?columns=3)](https://repology.org/project/fzf/versions)
 
-### Windows
+### Windows packages
 
-Pre-built binaries for Windows can be downloaded [here][bin]. fzf is also
-available via [Chocolatey][choco], [Scoop][scoop], [Winget][winget], and [MSYS2][msys2]:
+On Windows, fzf is available via [Chocolatey][choco], [Scoop][scoop],
+[Winget][winget], and [MSYS2][msys2]:
 
 | Package manager | Command                               |
 | --------------- | ------------------------------------- |
@@ -187,10 +160,24 @@ available via [Chocolatey][choco], [Scoop][scoop], [Winget][winget], and [MSYS2]
 [winget]: https://github.com/microsoft/winget-pkgs/tree/master/manifests/j/junegunn/fzf
 [msys2]: https://packages.msys2.org/base/mingw-w64-fzf
 
-Known issues and limitations on Windows can be found on [the wiki
-page][windows-wiki].
+### Using git
 
-[windows-wiki]: https://github.com/junegunn/fzf/wiki/Windows
+Alternatively, you can "git clone" this repository to any directory and run
+[install](https://github.com/junegunn/fzf/blob/master/install) script.
+
+```sh
+git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
+~/.fzf/install
+```
+
+The install script will add lines to your shell configuration file to modify
+`$PATH` and set up shell integration.
+
+### Binary releases
+
+You can download the official fzf binaries from the releases page.
+
+* https://github.com/junegunn/fzf/releases
 
 ### Setting up shell integration
 
@@ -204,7 +191,7 @@ Add the following line to your shell configuration file.
 * zsh
   ```sh
   # Set up fzf key bindings and fuzzy completion
-  eval "$(fzf --zsh)"
+  source <(fzf --zsh)
   ```
 * fish
   ```fish
@@ -226,25 +213,31 @@ Add the following line to your shell configuration file.
 > For example, to disable ALT-C binding:
 >
 > * bash: `FZF_ALT_C_COMMAND= eval "$(fzf --bash)"`
-> * zsh: `FZF_ALT_C_COMMAND= eval "$(fzf --zsh)"`
+> * zsh: `FZF_ALT_C_COMMAND= source <(fzf --zsh)`
 > * fish: `fzf --fish | FZF_ALT_C_COMMAND= source`
 >
 > Setting the variables after sourcing the script will have no effect.
 
-### As Vim plugin
+### Vim/Neovim plugin
 
-If you use
-[vim-plug](https://github.com/junegunn/vim-plug), add this line to your Vim
-configuration file:
+If you use [vim-plug](https://github.com/junegunn/vim-plug), add this to
+your Vim configuration file:
 
 ```vim
 Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+Plug 'junegunn/fzf.vim'
 ```
 
-`fzf#install()` makes sure that you have the latest binary, but it's optional,
-so you can omit it if you use a plugin manager that doesn't support hooks.
+* `junegunn/fzf` provides the basic library functions
+    * `fzf#install()` makes sure that you have the latest binary
+* `junegunn/fzf.vim` is [a separate project](https://github.com/junegunn/fzf.vim)
+  that provides a variety of useful commands
 
-For more installation options, see [README-VIM.md](README-VIM.md).
+To learn more about the Vim integration, see [README-VIM.md](README-VIM.md).
+
+> [!TIP]
+> If you use Neovim and prefer Lua-based plugins, check out
+> [fzf-lua](https://github.com/ibhagwan/fzf-lua).
 
 Upgrading fzf
 -------------
@@ -312,29 +305,71 @@ vim $(fzf)
 - Mouse: scroll, click, double-click; shift-click and shift-scroll on
   multi-select mode
 
-### Layout
+### Display modes
 
-fzf by default starts in fullscreen mode, but you can make it start below the
-cursor with `--height` option.
+fzf by default runs in fullscreen mode, but there are other display modes.
+
+#### `--height` mode
+
+With `--height HEIGHT[%]`, fzf will start below the cursor with the given height.
 
 ```sh
-vim $(fzf --height 40%)
+fzf --height 40%
 ```
 
-Also, check out `--reverse` and `--layout` options if you prefer
-"top-down" layout instead of the default "bottom-up" layout.
+`reverse` layout and `--border` goes well with this option.
 
 ```sh
-vim $(fzf --height 40% --reverse)
+fzf --height 40% --layout reverse --border
 ```
 
-You can add these options to `$FZF_DEFAULT_OPTS` so that they're applied by
-default. For example,
+By prepending `~` to the height, you're setting the maximum height.
 
 ```sh
-export FZF_DEFAULT_OPTS='--height 40% --layout=reverse --border'
+# Will take as few lines as possible to display the list
+seq 3 | fzf --height ~100%
+seq 3000 | fzf --height ~100%
 ```
 
+Height value can be a negative number.
+
+```sh
+# Screen height - 3
+fzf --height -3
+```
+
+#### `--tmux` mode
+
+With `--tmux` option, fzf will start in a tmux popup.
+
+```sh
+# --tmux [center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]
+
+fzf --tmux center         # Center, 50% width and height
+fzf --tmux 80%            # Center, 80% width and height
+fzf --tmux 100%,50%       # Center, 100% width and 50% height
+fzf --tmux left,40%       # Left, 40% width
+fzf --tmux left,40%,90%   # Left, 40% width, 90% height
+fzf --tmux top,40%        # Top, 40% height
+fzf --tmux bottom,80%,40% # Bottom, 80% height, 40% height
+```
+
+`--tmux` is silently ignored when you're not on tmux.
+
+> [!NOTE]
+> If you're stuck with an old version of tmux that doesn't support popup,
+> or if you want to open fzf in a regular tmux pane, check out
+> [fzf-tmux](bin/fzf-tmux) script.
+
+> [!TIP]
+> You can add these options to `$FZF_DEFAULT_OPTS` so that they're applied by
+> default. For example,
+>
+> ```sh
+> # Open in tmux popup if on tmux, otherwise use --height mode
+> export FZF_DEFAULT_OPTS='--height 40% --tmux bottom,40% --layout reverse --border top'
+> ```
+
 ### Search syntax
 
 Unless otherwise specified, fzf starts in "extended-search mode" where you can
@@ -406,39 +441,11 @@ Examples
       and are not thoroughly tested*
 * [Advanced fzf examples](https://github.com/junegunn/fzf/blob/master/ADVANCED.md)
 
-`fzf-tmux` script
------------------
-
-[fzf-tmux](bin/fzf-tmux) is a bash script that opens fzf in a tmux pane.
-
-```sh
-# usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
-
-# See available options
-fzf-tmux --help
-
-# select git branches in horizontal split below (15 lines)
-git branch | fzf-tmux -d 15
-
-# select multiple words in vertical split on the left (20% of screen width)
-cat /usr/share/dict/words | fzf-tmux -l 20% --multi --reverse
-```
-
-It will still work even when you're not on tmux, silently ignoring `-[pudlr]`
-options, so you can invariably use `fzf-tmux` in your scripts.
-
-Alternatively, you can use `--height HEIGHT[%]` option not to start fzf in
-fullscreen mode.
-
-```sh
-fzf --height 40%
-```
-
 Key bindings for command-line
 -----------------------------
 
-The install script will setup the following key bindings for bash, zsh, and
-fish.
+By [setting up shell integration](#setting-up-shell-integration), you can use
+the following key bindings in bash, zsh, and fish.
 
 - `CTRL-T` - Paste the selected files and directories onto the command-line
     - The list is generated using `--walker file,dir,follow,hidden` option
@@ -457,13 +464,11 @@ fish.
 - `CTRL-R` - Paste the selected command from history onto the command-line
     - If you want to see the commands in chronological order, press `CTRL-R`
       again which toggles sorting by relevance
+    - Press `CTRL-/` or `ALT-/` to toggle line wrapping
     - Set `FZF_CTRL_R_OPTS` to pass additional options to fzf
       ```sh
-      # CTRL-/ to toggle small preview window to see the full command
       # CTRL-Y to copy the command into clipboard using pbcopy
       export FZF_CTRL_R_OPTS="
-        --preview 'echo {}' --preview-window up:3:hidden:wrap
-        --bind 'ctrl-/:toggle-preview'
         --bind 'ctrl-y:execute-silent(echo -n {2..} | pbcopy)+abort'
         --color header:italic
         --header 'Press CTRL-Y to copy command into clipboard'"
@@ -482,9 +487,9 @@ fish.
     - Can be disabled by setting `FZF_ALT_C_COMMAND` to an empty string when
       sourcing the script
 
-If you're on a tmux session, you can start fzf in a tmux split-pane or in
-a tmux popup window by setting `FZF_TMUX_OPTS` (e.g. `export FZF_TMUX_OPTS='-p80%,60%'`).
-See `fzf-tmux --help` for available options.
+Display modes for these bindings can be separately configured via
+`FZF_{CTRL_T,CTRL_R,ALT_C}_OPTS` or globally via `FZF_DEFAULT_OPTS`.
+(e.g. `FZF_CTRL_R_OPTS='--tmux bottom,60% --height 60% --border top'`)
 
 More tips can be found on [the wiki page](https://github.com/junegunn/fzf/wiki/Configuring-shell-key-bindings).
 

bin/fzf-preview.sh

@@ -57,7 +57,7 @@ if [[ $KITTY_WINDOW_ID ]]; then
 
 # 2. Use chafa with Sixel output
 elif command -v chafa > /dev/null; then
-  chafa -f sixel -s "$dim" "$file"
+  chafa -s "$dim" "$file"
   # Add a new line character so that fzf can display multiple images in the preview window
   echo
 

bin/fzf-tmux

@@ -132,8 +132,10 @@ if [[ -z "$TMUX" ]]; then
   exit $?
 fi
 
-# --height option is not allowed. CTRL-Z is also disabled.
-args=("${args[@]}" "--no-height" "--bind=ctrl-z:ignore")
+# * --height option is not allowed
+# * CTRL-Z is also disabled
+# * fzf-tmux script is not compatible with --tmux option in fzf 0.53.0 or later
+args=("${args[@]}" "--no-height" "--bind=ctrl-z:ignore" "--no-tmux")
 
 # 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

doc/fzf.txt

@@ -311,7 +311,7 @@ The following table summarizes the available options.
   `options`                   | string/list   | Options to fzf
   `dir`                       | string        | Working directory
   `up` / `down` / `left` / `right`  | number/string | (Layout) Window position and size (e.g.  `20` ,  `50%` )
-  `tmux`                      | string        | (Layout) fzf-tmux options (e.g.  `-p90%,60%` )
+  `tmux`                      | string        | (Layout) `--tmux` options (e.g.  `90%,70%` )
   `window`  (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g.  `vertical aboveleft 30new` )
   `window`  (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g.  `{'width': 0.9, 'height': 0.6}` )
  ---------------------------+---------------+----------------------------------------------------------------------
@@ -469,11 +469,12 @@ in Neovim.
     let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
 <
 Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
-or above) by putting fzf-tmux options in `tmux` key.
+or above) by putting `--tmux` options in `tmux` key.
 >
-    " See `man fzf-tmux` for available options
+    " See `--tmux` option in `man fzf` for available options
+    " [center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]
     if exists('$TMUX')
-      let g:fzf_layout = { 'tmux': '-p90%,60%' }
+      let g:fzf_layout = { 'tmux': '90%,70%' }
     else
       let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
     endif

go.mod

@@ -1,13 +1,13 @@
 module github.com/junegunn/fzf
 
 require (
-	github.com/charlievieth/fastwalk v1.0.3
+	github.com/charlievieth/fastwalk v1.0.8
 	github.com/gdamore/tcell/v2 v2.7.4
 	github.com/mattn/go-isatty v0.0.20
 	github.com/mattn/go-shellwords v1.0.12
 	github.com/rivo/uniseg v0.4.7
-	golang.org/x/sys v0.19.0
-	golang.org/x/term v0.19.0
+	golang.org/x/sys v0.22.0
+	golang.org/x/term v0.22.0
 )
 
 require (

go.sum

@@ -1,5 +1,5 @@
-github.com/charlievieth/fastwalk v1.0.3 h1:eNWFaNPe5srPqQ5yyDbhAf11paeZaHWcihRhpuYFfSg=
-github.com/charlievieth/fastwalk v1.0.3/go.mod h1:JSfglY/gmL/rqsUS1NCsJTocB5n6sSl9ApAqif4CUbs=
+github.com/charlievieth/fastwalk v1.0.8 h1:uaoH6cAKSk73aK7aKXqs0+bL+J3Txzd3NGH8tRXgHko=
+github.com/charlievieth/fastwalk v1.0.8/go.mod h1:yGy1zbxog41ZVMcKA/i8ojXLFsuayX5VvwhQVoj9PBI=
 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=
@@ -36,14 +36,14 @@ golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
-golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
-golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
+golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk=
+golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
 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=

install

@@ -2,7 +2,7 @@
 
 set -u
 
-version=0.51.0
+version=0.54.2
 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 -xzf -
+    curl -fL $1 | tar --no-same-owner -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 -xzf -
+    wget -O - $1 | tar --no-same-owner -xzf -
   else
     local temp=${TMPDIR:-/tmp}/fzf.zip
     wget -O "$temp" $1 && unzip -o "$temp" && rm -f "$temp"
@@ -146,7 +146,7 @@ download() {
   fi
 
   local url
-  url=https://github.com/junegunn/fzf/releases/download/$version/${1}
+  url=https://github.com/junegunn/fzf/releases/download/v$version/${1}
   set -o pipefail
   if ! (try_curl $url || try_wget $url); then
     set +o pipefail
@@ -168,8 +168,8 @@ 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     ;;
+  Darwin\ arm64)      download fzf-$version-darwin_arm64.tar.gz  ;;
+  Darwin\ x86_64)     download fzf-$version-darwin_amd64.tar.gz  ;;
   Linux\ armv5*)      download fzf-$version-linux_armv5.tar.gz   ;;
   Linux\ armv6*)      download fzf-$version-linux_armv6.tar.gz   ;;
   Linux\ armv7*)      download fzf-$version-linux_armv7.tar.gz   ;;
@@ -265,7 +265,11 @@ fi
 EOF
 
   if [[ $auto_completion -eq 1 ]] && [[ $key_bindings -eq 1 ]]; then
-    echo "eval \"\$(fzf --$shell)\"" >> "$src"
+    if [[ "$shell" = zsh ]]; then
+      echo "source <(fzf --$shell)" >> "$src"
+    else
+      echo "eval \"\$(fzf --$shell)\"" >> "$src"
+    fi
   else
     cat >> "$src" << EOF
 # Auto-completion

install.ps1

@@ -1,4 +1,4 @@
-$version="0.51.0"
+$version="0.54.2"
 
 $fzf_base=Split-Path -Parent $MyInvocation.MyCommand.Definition
 
@@ -40,7 +40,7 @@ function download {
     return
   }
   cd "$fzf_base\bin"
-  $url="https://github.com/junegunn/fzf/releases/download/$version/$file"
+  $url="https://github.com/junegunn/fzf/releases/download/v$version/$file"
   $temp=$env:TMP + "\fzf.zip"
   [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
   if ($PSVersionTable.PSVersion.Major -ge 3) {

main.go

@@ -3,14 +3,16 @@ package main
 import (
 	_ "embed"
 	"fmt"
+	"os"
+	"os/exec"
 	"strings"
 
 	fzf "github.com/junegunn/fzf/src"
 	"github.com/junegunn/fzf/src/protector"
 )
 
-var version string = "0.51"
-var revision string = "devel"
+var version = "0.54"
+var revision = "devel"
 
 //go:embed shell/key-bindings.bash
 var bashKeyBindings []byte
@@ -27,15 +29,30 @@ var zshCompletion []byte
 //go:embed shell/key-bindings.fish
 var fishKeyBindings []byte
 
+//go:embed man/man1/fzf.1
+var manPage []byte
+
 func printScript(label string, content []byte) {
 	fmt.Println("### " + label + " ###")
 	fmt.Println(strings.TrimSpace(string(content)))
 	fmt.Println("### end: " + label + " ###")
 }
 
+func exit(code int, err error) {
+	if code == fzf.ExitError && err != nil {
+		fmt.Fprintln(os.Stderr, err.Error())
+	}
+	os.Exit(code)
+}
+
 func main() {
 	protector.Protect()
-	options := fzf.ParseOptions()
+
+	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)
@@ -51,5 +68,34 @@ func main() {
 		fmt.Println("fzf_key_bindings")
 		return
 	}
-	fzf.Run(options, version, revision)
+	if options.Help {
+		fmt.Print(fzf.Usage)
+		return
+	}
+	if options.Version {
+		if len(revision) > 0 {
+			fmt.Printf("%s (%s)\n", version, revision)
+		} else {
+			fmt.Println(version)
+		}
+		return
+	}
+	if options.Man {
+		file := fzf.WriteTemporaryFile([]string{string(manPage)}, "\n")
+		if len(file) == 0 {
+			fmt.Print(string(manPage))
+			return
+		}
+		defer os.Remove(file)
+		cmd := exec.Command("man", file)
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		if err := cmd.Run(); err != nil {
+			fmt.Print(string(manPage))
+		}
+		return
+	}
+
+	code, err := fzf.Run(options)
+	exit(code, err)
 }

main_test.go

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

man/man1/fzf-tmux.1

@@ -21,48 +21,48 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf-tmux 1 "May 2024" "fzf 0.51.0" "fzf-tmux - open fzf in tmux split pane"
+.TH fzf\-tmux 1 "Jul 2024" "fzf 0.54.2" "fzf\-tmux - open fzf in tmux split pane"
 
 .SH NAME
-fzf-tmux - open fzf in tmux split pane
+fzf\-tmux - open fzf in tmux split pane
 
 .SH SYNOPSIS
-.B fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
+.B fzf\-tmux [LAYOUT OPTIONS] [\-\-] [FZF OPTIONS]
 
 .SH DESCRIPTION
-fzf-tmux is a wrapper script for fzf that opens fzf in a tmux split pane or in
+fzf\-tmux is a wrapper script for fzf that opens fzf in a tmux split pane or in
 a tmux popup window. It is designed to work just like fzf except that it does
-not take up the whole screen. You can safely use fzf-tmux instead of fzf in
+not take up the whole screen. You can safely use fzf\-tmux instead of fzf in
 your scripts as the extra options will be silently ignored if you're not on
 tmux.
 
 .SH LAYOUT OPTIONS
 
-(default layout: \fB-d 50%\fR)
+(default layout: \fB\-d 50%\fR)
 
 .SS Popup window
 (requires tmux 3.2 or above)
 .TP
-.B "-p [WIDTH[%][,HEIGHT[%]]]"
+.B "\-p [WIDTH[%][,HEIGHT[%]]]"
 .TP
-.B "-w WIDTH[%]"
+.B "\-w WIDTH[%]"
 .TP
-.B "-h WIDTH[%]"
+.B "\-h WIDTH[%]"
 .TP
-.B "-x COL"
+.B "\-x COL"
 .TP
-.B "-y ROW"
+.B "\-y ROW"
 
 .SS Split pane
 .TP
-.B "-u [height[%]]"
+.B "\-u [height[%]]"
 Split above (up)
 .TP
-.B "-d [height[%]]"
+.B "\-d [height[%]]"
 Split below (down)
 .TP
-.B "-l [width[%]]"
+.B "\-l [width[%]]"
 Split left
 .TP
-.B "-r [width[%]]"
+.B "\-r [width[%]]"
 Split right

plugin/fzf.vim

@@ -59,12 +59,9 @@ if s:is_win
     return iconv(a:str, &encoding, 'cp'.s:codepage)
   endfunction
   function! s:wrap_cmds(cmds)
-    return map([
-      \ '@echo off',
-      \ 'setlocal enabledelayedexpansion']
+    return map(['@echo off']
     \ + (has('gui_running') ? ['set TERM= > nul'] : [])
-    \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds])
-    \ + ['endlocal'],
+    \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds]),
     \ '<SID>enc_to_cp(v:val."\r")')
   endfunction
 else
@@ -83,8 +80,6 @@ else
   endfunction
 endif
 
-let s:cmd_control_chars = ['&', '|', '<', '>', '(', ')', '@', '^', '!']
-
 function! s:shellesc_cmd(arg)
   let e = '"'
   let slashes = 0
@@ -94,17 +89,13 @@ function! s:shellesc_cmd(arg)
     elseif c ==# '"'
       let e .= repeat('\', slashes + 1)
       let slashes = 0
-    elseif c ==# '%'
-      let e .= '%'
-    elseif index(s:cmd_control_chars, c) >= 0
-      let e .= '^'
     else
       let slashes = 0
     endif
     let e .= c
   endfor
   let e .= repeat('\', slashes) .'"'
-  return e
+  return substitute(substitute(e, '[&|<>()^!"]', '^&', 'g'), '%', '%%', 'g')
 endfunction
 
 function! fzf#shellescape(arg, ...)
@@ -336,7 +327,10 @@ 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 has('win32unix') && item !~ '/'
+        let item = substitute(item, '\', '/', 'g')
+      end
+      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
@@ -496,6 +490,8 @@ function! s:extract_option(opts, name)
   return opt
 endfunction
 
+let s:need_cmd_window = has('win32unix') && $TERM_PROGRAM ==# 'mintty' && s:compare_versions($TERM_PROGRAM_VERSION, '3.4.5') < 0 && !executable('winpty')
+
 function! fzf#run(...) abort
 try
   let [shell, shellslash, shellcmdflag, shellxquote] = s:use_sh()
@@ -517,19 +513,19 @@ try
   endif
 
   if has_key(dict, 'source')
-    let source = remove(dict, 'source')
+    let source = dict.source
     let type = type(source)
     if type == 1
-      let source_command = source
+      let prefix = '('.source.')|'
     elseif type == 3
       let temps.input = s:fzf_tempname()
       call s:writefile(source, temps.input)
-      let source_command = (s:is_win ? 'type ' : 'cat ').fzf#shellescape(temps.input)
+      let prefix = (s:is_win ? 'type ' : 'command cat ').fzf#shellescape(temps.input).'|'
     else
       throw 'Invalid source type'
     endif
   else
-    let source_command = ''
+    let prefix = ''
   endif
 
   let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0) || has_key(dict, 'tmux')
@@ -538,26 +534,23 @@ try
         \ executable('tput') && filereadable('/dev/tty')
   let has_vim8_term = has('terminal') && has('patch-8.0.995')
   let has_nvim_term = has('nvim-0.2.1') || has('nvim') && !s:is_win
-  let use_term = has_nvim_term ||
-    \ has_vim8_term && !has('win32unix') && (has('gui_running') || s:is_win || s:present(dict, 'down', 'up', 'left', 'right', 'window'))
+  let use_term = has_nvim_term || has_vim8_term
+    \ && !s:need_cmd_window
+    \ && (has('gui_running') || s:is_win || s:present(dict, 'down', 'up', 'left', 'right', 'window'))
   let use_tmux = (has_key(dict, 'tmux') || (!use_height && !use_term || prefer_tmux) && !has('win32unix') && s:splittable(dict)) && s:tmux_enabled()
   if prefer_tmux && use_tmux
     let use_height = 0
     let use_term = 0
   endif
   if use_term
-    let optstr .= ' --no-height'
+    let optstr .= ' --no-height --no-tmux'
   elseif use_height
     let height = s:calc_size(&lines, dict.down, dict)
-    let optstr .= ' --height='.height
+    let optstr .= ' --no-tmux --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 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
+  let command = prefix.(use_tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
 
   if use_term
     return s:execute_term(dict, command, temps)
@@ -568,14 +561,6 @@ 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
@@ -594,19 +579,21 @@ function! s:fzf_tmux(dict)
   if empty(size)
     for o in ['up', 'down', 'left', 'right']
       if s:present(a:dict, o)
-        let spec = a:dict[o]
-        if (o == 'up' || o == 'down') && spec[0] == '~'
-          let size = '-'.o[0].s:calc_size(&lines, spec, a:dict)
-        else
-          " Legacy boolean option
-          let size = '-'.o[0].(spec == 1 ? '' : substitute(spec, '^\~', '', ''))
-        endif
+        let size = o . ',' . a:dict[o]
         break
       endif
     endfor
   endif
-  return printf('LINES=%d COLUMNS=%d %s %s - --',
-    \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size)
+
+  " Legacy fzf-tmux options
+  if size =~ '-'
+    return printf('LINES=%d COLUMNS=%d %s %s %s --',
+          \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size, (has_key(a:dict, 'source') ? '' : '-'))
+  end
+
+  " Using native --tmux option
+  let in = (has_key(a:dict, 'source') ? '' : ' --force-tty-in')
+  return printf('%s --tmux %s%s', fzf#shellescape(fzf#exec()), size, in)
 endfunction
 
 function! s:splittable(dict)
@@ -729,14 +716,15 @@ function! s:execute(dict, command, use_height, temps) abort
       call jobstart(cmd, fzf)
       return []
     endif
-  elseif has('win32unix') && $TERM !=# 'cygwin'
+  elseif s:need_cmd_window
     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 = 'start //WAIT sh -c '.shellscript
     let a:temps.shellscript = shellscript
   endif
   if a:use_height
-    call system(printf('tput cup %d > /dev/tty; tput cnorm > /dev/tty; %s < /dev/tty 2> /dev/tty', &lines, command))
+    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))
   else
     execute 'silent !'.command
   endif

shell/completion.bash

@@ -4,10 +4,12 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ completion.bash
 #
-# - $FZF_TMUX               (default: 0)
-# - $FZF_TMUX_OPTS          (default: empty)
-# - $FZF_COMPLETION_TRIGGER (default: '**')
-# - $FZF_COMPLETION_OPTS    (default: empty)
+# - $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)
 
 if [[ $- =~ i ]]; then
 
@@ -99,75 +101,84 @@ _fzf_opts_completion() {
   cur="${COMP_WORDS[COMP_CWORD]}"
   prev="${COMP_WORDS[COMP_CWORD-1]}"
   opts="
-    -h --help
-    -e --exact
-    +x --no-extended
-    -q --query
-    -f --filter
-    --literal
-    --scheme
-    --expect
-    --disabled
-    --tiebreak
-    --bind
-    --color
-    -d --delimiter
-    -n --nth
-    --with-nth
-    +s --no-sort
-    --track
-    --tac
-    -i
-    +i
-    -m --multi
-    --ansi
-    --no-mouse
     +c --no-color
-    --no-bold
-    --layout
-    --reverse
-    --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
-    --prompt
-    --pointer
-    --marker
-    --sync
-    --history
-    --history-size
-    --header
-    --header-lines
-    --header-first
-    --ellipsis
-    --preview
-    --preview-window
-    --height
-    --min-height
+    +i --no-ignore-case
+    +s --no-sort
+    +x --no-extended
+    --ansi
+    --bash
+    --bind
     --border
     --border-label
     --border-label-pos
+    --color
+    --cycle
+    --disabled
+    --ellipsis
+    --expect
+    --filepath-word
+    --fish
+    --header
+    --header-first
+    --header-lines
+    --height
+    --highlight-line
+    --history
+    --history-size
+    --hscroll-off
+    --info
+    --jump-labels
+    --keep-right
+    --layout
+    --listen
+    --listen-unsafe
+    --literal
+    --man
+    --margin
+    --marker
+    --min-height
+    --no-bold
+    --no-clear
+    --no-hscroll
+    --no-mouse
+    --no-scrollbar
+    --no-separator
+    --no-unicode
+    --padding
+    --pointer
+    --preview
     --preview-label
     --preview-label-pos
-    --no-unicode
-    --margin
-    --padding
+    --preview-window
+    --print-query
+    --print0
+    --prompt
+    --read0
+    --reverse
+    --scheme
+    --scroll-off
+    --separator
+    --sync
     --tabstop
-    --listen
-    --no-clear
+    --tac
+    --tiebreak
+    --tmux
+    --track
     --version
+    --with-nth
+    --with-shell
+    --wrap
+    --zsh
+    -0 --exit-0
+    -1 --select-1
+    -d --delimiter
+    -e --exact
+    -f --filter
+    -h --help
+    -i --ignore-case
+    -m --multi
+    -n --nth
+    -q --query
     --"
 
   case "${prev}" in
@@ -297,8 +308,14 @@ __fzf_generic_path_completion() {
           if declare -F "$1" > /dev/null; then
             eval "$1 $(printf %q "$dir")" | __fzf_comprun "$4" -q "$leftover"
           else
-            [[ $1 =~ dir ]] && walker=dir,follow || walker=file,dir,follow,hidden
-            __fzf_comprun "$4" -q "$leftover" --walker "$walker" --walker-root="$dir"
+            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
@@ -391,7 +408,7 @@ _fzf_complete_kill() {
 }
 
 _fzf_proc_completion() {
-  _fzf_complete -m --header-lines=1 --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+  _fzf_complete -m --header-lines=1 --no-preview --wrap -- "$@" < <(
     command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
       command ps -eo user,pid,ppid,time,args # For BusyBox
   )
@@ -468,7 +485,7 @@ 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
+  awk bat cat code diff diff3
   emacs emacsclient ex file ftp g++ gcc gvim head hg hx java
   javac ld less more mvim nvim patch perl python ruby
   sed sftp sort source tail tee uniq vi view vim wc xdg-open

shell/completion.zsh

@@ -4,10 +4,12 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ completion.zsh
 #
-# - $FZF_TMUX               (default: 0)
-# - $FZF_TMUX_OPTS          (default: '-d 40%')
-# - $FZF_COMPLETION_TRIGGER (default: '**')
-# - $FZF_COMPLETION_OPTS    (default: empty)
+# - $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)
 
 
 # Both branches of the following `if` do the same thing -- define
@@ -155,16 +157,23 @@ __fzf_generic_path_completion() {
       [ -z "$dir" ] && dir='.'
       [ "$dir" != "/" ] && dir="${dir/%\//}"
       matches=$(
-        export FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --scheme=path" "${FZF_COMPLETION_OPTS-}")
+        export FZF_DEFAULT_OPTS
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --scheme=path" "${FZF_COMPLETION_OPTS-}")
         unset FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS_FILE
         if declare -f "$compgen" > /dev/null; then
           eval "$compgen $(printf %q "$dir")" | __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover"
         else
-          [[ $compgen =~ dir ]] && walker=dir,follow || walker=file,dir,follow,hidden
-          __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" --walker "$walker" --walker-root="$dir" < /dev/tty
-        fi | while read item; do
+          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 -r item; do
           item="${item%$suffix}$suffix"
-          echo -n "${(q)item} "
+          echo -n -E "${(q)item} "
         done
       )
       matches=${matches% }
@@ -189,11 +198,11 @@ _fzf_dir_completion() {
     "" "/" ""
 }
 
-_fzf_feed_fifo() (
+_fzf_feed_fifo() {
   command rm -f "$1"
   mkfifo "$1"
-  cat <&0 > "$1" &
-)
+  cat <&0 > "$1" &|
+}
 
 _fzf_complete() {
   setopt localoptions ksh_arrays
@@ -256,13 +265,14 @@ _fzf_complete_telnet() {
 # 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})
+  local -a tokens
+  tokens=(${(z)1})
   case ${tokens[-1]} in
     -i|-F|-E)
       _fzf_path_completion "$prefix" "$1"
       ;;
     *)
-      local user=
+      local user
       [[ $prefix =~ @ ]] && user="${prefix%%@*}@"
       _fzf_complete +m -- "$@" < <(__fzf_list_hosts | awk -v user="$user" '{print user $0}')
       ;;
@@ -288,7 +298,7 @@ _fzf_complete_unalias() {
 }
 
 _fzf_complete_kill() {
-  _fzf_complete -m --header-lines=1 --preview 'echo {}' --preview-window down:3:wrap --min-height 15 -- "$@" < <(
+  _fzf_complete -m --header-lines=1 --no-preview --wrap -- "$@" < <(
     command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
       command ps -eo user,pid,ppid,time,args # For BusyBox
   )

shell/key-bindings.bash

@@ -54,18 +54,56 @@ __fzf_cd__() {
   ) && printf 'builtin cd -- %q' "$(builtin unset CDPATH && builtin cd -- "$dir" && builtin pwd)"
 }
 
-if command -v perl > /dev/null; then
+if command -v ruby > /dev/null; then
+  __fzf_history__() {
+    local n output
+    builtin history -w /tmp/fzf-bash-history
+    output=$(
+      ruby -e '
+        fmt = begin
+          require "rouge"
+          formatter = Rouge::Formatters::Terminal256.new(Rouge::Themes::Monokai.new)
+          lexer = Rouge::Lexers::Shell.new
+          lambda { |c| formatter.format(lexer.lex(c)) }
+        rescue LoadError
+          lambda { |c| c }
+        end
+
+        h = {}
+        i = 0
+        File.read("/tmp/fzf-bash-history").encode!("UTF-8", "UTF-8", :invalid => :replace).scan(/^#([0-9]+)$\n(.*?)\n(?=^#[0-9]+$|\z)/m) do |t, c|
+          next if c.empty?
+          h.delete(c)
+          h[c] = [i += 1, t]
+        end
+        h.to_a.reverse.each do |c, it|
+          i, t = it
+          print "\x1b[33m#{i}\t\x1b[32m#{Time.at(t.to_i).strftime(%[%F %T])}\x1b[m  "
+          print fmt[c.gsub("\n", "\n\t")]
+          print "\0"
+        end
+      ' | FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n1,4.. --ansi --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"$'\t'"↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
+          FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE" --bind 'enter:become:echo {4..}'
+    ) || return
+    READLINE_LINE=$(command perl -pe 's/^\d*\t//' <<< "$output")
+    if [[ -z "$READLINE_POINT" ]]; then
+      echo "$READLINE_LINE"
+    else
+      READLINE_POINT=0x7fffffff
+    fi
+  }
+elif 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{$_}++'
+    script='BEGIN { getc; $/ = "\n\t"; $HISTCOUNT = $ENV{last_hist} + 1 } s/^[ *]//; s/\n/\n\t/gm; print $HISTCOUNT - $. . "\t$_" if !$seen{$_}++'
     output=$(
       set +o pipefail
       builtin fc -lnr -2147483648 |
         last_hist=$(HISTTIMEFORMAT='' builtin history 1) command perl -n -l0 -e "$script" |
-        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort ${FZF_CTRL_R_OPTS-} +m --read0") \
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"$'\t'"↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
         FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
     ) || return
-    READLINE_LINE=${output#*$'\t'}
+    READLINE_LINE=$(command perl -pe 's/^\d*\t//' <<< "$output")
     if [[ -z "$READLINE_POINT" ]]; then
       echo "$READLINE_LINE"
     else
@@ -91,7 +129,7 @@ else # awk - fallback for POSIX systems
       set +o pipefail
       builtin fc -lnr -2147483648 2> /dev/null |   # ( $'\t '<lines>$'\n' )* ; <lines> ::= [^\n]* ( $'\n'<lines> )*
         command $__fzf_awk "$script"           |   # ( <counter>$'\t'<lines>$'\000' )*
-        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort ${FZF_CTRL_R_OPTS-} +m --read0") \
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"$'\t'"↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
         FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
     ) || return
     READLINE_LINE=${output#*$'\t'}

shell/key-bindings.fish

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

shell/key-bindings.zsh

@@ -52,8 +52,8 @@ __fzf_select() {
   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
-    echo -n "${(q)item} "
+  FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) "$@" < /dev/tty | while read -r item; do
+    echo -n -E "${(q)item} "
   done
   local ret=$?
   echo
@@ -106,16 +106,24 @@ fi
 
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
-  local selected num
-  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2> /dev/null
-  selected="$(fc -rl 1 | awk '{ cmd=$0; sub(/^[ \t]*[0-9]+\**[ \t]+/, "", cmd); if (!seen[cmd]++) print $0 }' |
-    FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m") \
-    FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
+  local selected
+  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases noglob nobash_rematch 2> /dev/null
+  # Ensure the associative history array, which maps event numbers to the full
+  # history lines, is loaded, and that Perl is installed for multi-line output.
+  if zmodload -F zsh/parameter p:history 2>/dev/null && (( ${#commands[perl]} )); then
+    selected="$(printf '%s\t%s\000' "${(kv)history[@]}" |
+      perl -0 -ne 'if (!$seen{(/^\s*[0-9]+\**\t(.*)/s, $1)}++) { s/\n/\n\t/g; print; }' |
+      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '\t↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m --read0") \
+      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
+  else
+    selected="$(fc -rl 1 | awk '{ cmd=$0; sub(/^[ \t]*[0-9]+\**[ \t]+/, "", cmd); if (!seen[cmd]++) print $0 }' |
+      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '\t↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m") \
+      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
+  fi
   local ret=$?
   if [ -n "$selected" ]; then
-    num=$(awk '{print $1}' <<< "$selected")
-    if [[ "$num" =~ '^[1-9][0-9]*\*?$' ]]; then
-      zle vi-fetch-history -n ${num%\*}
+    if [[ $(awk '{print $1; exit}' <<< "$selected") =~ ^[1-9][0-9]* ]]; then
+      zle vi-fetch-history -n $MATCH
     else # selected is a custom query, not from history
       LBUFFER="$selected"
     fi

src/actiontype_string.go

@@ -37,92 +37,95 @@ func _() {
 	_ = x[actDeleteChar-26]
 	_ = x[actDeleteCharEof-27]
 	_ = x[actEndOfLine-28]
-	_ = x[actForwardChar-29]
-	_ = x[actForwardWord-30]
-	_ = x[actKillLine-31]
-	_ = x[actKillWord-32]
-	_ = x[actUnixLineDiscard-33]
-	_ = x[actUnixWordRubout-34]
-	_ = x[actYank-35]
-	_ = x[actBackwardKillWord-36]
-	_ = x[actSelectAll-37]
-	_ = x[actDeselectAll-38]
-	_ = x[actToggle-39]
-	_ = x[actToggleSearch-40]
-	_ = x[actToggleAll-41]
-	_ = x[actToggleDown-42]
-	_ = x[actToggleUp-43]
-	_ = x[actToggleIn-44]
-	_ = x[actToggleOut-45]
-	_ = x[actToggleTrack-46]
-	_ = x[actToggleTrackCurrent-47]
-	_ = x[actToggleHeader-48]
-	_ = x[actTrackCurrent-49]
-	_ = x[actUntrackCurrent-50]
-	_ = x[actDown-51]
-	_ = x[actUp-52]
-	_ = x[actPageUp-53]
-	_ = x[actPageDown-54]
-	_ = x[actPosition-55]
-	_ = x[actHalfPageUp-56]
-	_ = x[actHalfPageDown-57]
-	_ = x[actOffsetUp-58]
-	_ = x[actOffsetDown-59]
-	_ = x[actJump-60]
-	_ = x[actJumpAccept-61]
-	_ = x[actPrintQuery-62]
-	_ = x[actRefreshPreview-63]
-	_ = x[actReplaceQuery-64]
-	_ = x[actToggleSort-65]
-	_ = x[actShowPreview-66]
-	_ = x[actHidePreview-67]
-	_ = x[actTogglePreview-68]
-	_ = x[actTogglePreviewWrap-69]
-	_ = x[actTransform-70]
-	_ = x[actTransformBorderLabel-71]
-	_ = x[actTransformHeader-72]
-	_ = x[actTransformPreviewLabel-73]
-	_ = x[actTransformPrompt-74]
-	_ = x[actTransformQuery-75]
-	_ = x[actPreview-76]
-	_ = x[actChangePreview-77]
-	_ = x[actChangePreviewWindow-78]
-	_ = x[actPreviewTop-79]
-	_ = x[actPreviewBottom-80]
-	_ = x[actPreviewUp-81]
-	_ = x[actPreviewDown-82]
-	_ = x[actPreviewPageUp-83]
-	_ = x[actPreviewPageDown-84]
-	_ = x[actPreviewHalfPageUp-85]
-	_ = x[actPreviewHalfPageDown-86]
-	_ = x[actPrevHistory-87]
-	_ = x[actPrevSelected-88]
-	_ = x[actPut-89]
-	_ = x[actNextHistory-90]
-	_ = x[actNextSelected-91]
-	_ = x[actExecute-92]
-	_ = x[actExecuteSilent-93]
-	_ = x[actExecuteMulti-94]
-	_ = x[actSigStop-95]
-	_ = x[actFirst-96]
-	_ = x[actLast-97]
-	_ = x[actReload-98]
-	_ = x[actReloadSync-99]
-	_ = x[actDisableSearch-100]
-	_ = x[actEnableSearch-101]
-	_ = x[actSelect-102]
-	_ = x[actDeselect-103]
-	_ = x[actUnbind-104]
-	_ = x[actRebind-105]
-	_ = x[actBecome-106]
-	_ = x[actResponse-107]
-	_ = x[actShowHeader-108]
-	_ = x[actHideHeader-109]
+	_ = 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[actToggleWrap-50]
+	_ = x[actTrackCurrent-51]
+	_ = x[actUntrackCurrent-52]
+	_ = x[actDown-53]
+	_ = x[actUp-54]
+	_ = x[actPageUp-55]
+	_ = x[actPageDown-56]
+	_ = x[actPosition-57]
+	_ = x[actHalfPageUp-58]
+	_ = x[actHalfPageDown-59]
+	_ = x[actOffsetUp-60]
+	_ = x[actOffsetDown-61]
+	_ = x[actOffsetMiddle-62]
+	_ = x[actJump-63]
+	_ = x[actJumpAccept-64]
+	_ = x[actPrintQuery-65]
+	_ = x[actRefreshPreview-66]
+	_ = x[actReplaceQuery-67]
+	_ = x[actToggleSort-68]
+	_ = x[actShowPreview-69]
+	_ = x[actHidePreview-70]
+	_ = x[actTogglePreview-71]
+	_ = x[actTogglePreviewWrap-72]
+	_ = x[actTransform-73]
+	_ = x[actTransformBorderLabel-74]
+	_ = x[actTransformHeader-75]
+	_ = x[actTransformPreviewLabel-76]
+	_ = x[actTransformPrompt-77]
+	_ = x[actTransformQuery-78]
+	_ = x[actPreview-79]
+	_ = x[actChangePreview-80]
+	_ = x[actChangePreviewWindow-81]
+	_ = x[actPreviewTop-82]
+	_ = x[actPreviewBottom-83]
+	_ = x[actPreviewUp-84]
+	_ = x[actPreviewDown-85]
+	_ = x[actPreviewPageUp-86]
+	_ = x[actPreviewPageDown-87]
+	_ = x[actPreviewHalfPageUp-88]
+	_ = x[actPreviewHalfPageDown-89]
+	_ = x[actPrevHistory-90]
+	_ = x[actPrevSelected-91]
+	_ = x[actPrint-92]
+	_ = x[actPut-93]
+	_ = x[actNextHistory-94]
+	_ = x[actNextSelected-95]
+	_ = x[actExecute-96]
+	_ = x[actExecuteSilent-97]
+	_ = x[actExecuteMulti-98]
+	_ = x[actSigStop-99]
+	_ = x[actFirst-100]
+	_ = x[actLast-101]
+	_ = x[actReload-102]
+	_ = x[actReloadSync-103]
+	_ = x[actDisableSearch-104]
+	_ = x[actEnableSearch-105]
+	_ = x[actSelect-106]
+	_ = x[actDeselect-107]
+	_ = x[actUnbind-108]
+	_ = x[actRebind-109]
+	_ = x[actBecome-110]
+	_ = x[actShowHeader-111]
+	_ = x[actHideHeader-112]
 }
 
-const _actionType_name = "actIgnoreactStartactClickactInvalidactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactCancelactChangeBorderLabelactChangeHeaderactChangeMultiactChangePreviewLabelactChangePromptactChangeQueryactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactForwardCharactForwardWordactKillLineactKillWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleTrackCurrentactToggleHeaderactTrackCurrentactUntrackCurrentactDownactUpactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTransformactTransformBorderLabelactTransformHeaderactTransformPreviewLabelactTransformPromptactTransformQueryactPreviewactChangePreviewactChangePreviewWindowactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactBecomeactResponseactShowHeaderactHideHeader"
+const _actionType_name = "actIgnoreactStartactClickactInvalidactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactCancelactChangeBorderLabelactChangeHeaderactChangeMultiactChangePreviewLabelactChangePromptactChangeQueryactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactFatalactForwardCharactForwardWordactKillLineactKillWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleTrackCurrentactToggleHeaderactToggleWrapactTrackCurrentactUntrackCurrentactDownactUpactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactOffsetMiddleactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTransformactTransformBorderLabelactTransformHeaderactTransformPreviewLabelactTransformPromptactTransformQueryactPreviewactChangePreviewactChangePreviewWindowactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPrintactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactBecomeactShowHeaderactHideHeader"
 
-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, 413, 427, 438, 449, 467, 484, 491, 510, 522, 536, 545, 560, 572, 585, 596, 607, 619, 633, 654, 669, 684, 701, 708, 713, 722, 733, 744, 757, 772, 783, 796, 803, 816, 829, 846, 861, 874, 888, 902, 918, 938, 950, 973, 991, 1015, 1033, 1050, 1060, 1076, 1098, 1111, 1127, 1139, 1153, 1169, 1187, 1207, 1229, 1243, 1258, 1264, 1278, 1293, 1303, 1319, 1334, 1344, 1352, 1359, 1368, 1381, 1397, 1412, 1421, 1432, 1441, 1450, 1459, 1470, 1483, 1496}
+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, 690, 705, 722, 729, 734, 743, 754, 765, 778, 793, 804, 817, 832, 839, 852, 865, 882, 897, 910, 924, 938, 954, 974, 986, 1009, 1027, 1051, 1069, 1086, 1096, 1112, 1134, 1147, 1163, 1175, 1189, 1205, 1223, 1243, 1265, 1279, 1294, 1302, 1308, 1322, 1337, 1347, 1363, 1378, 1388, 1396, 1403, 1412, 1425, 1441, 1456, 1465, 1476, 1485, 1494, 1503, 1516, 1529}
 
 func (i actionType) String() string {
 	if i < 0 || i >= actionType(len(_actionType_index)-1) {

src/algo/algo.go

@@ -152,7 +152,7 @@ var (
 	// Extra bonus for word boundary after slash, colon, semi-colon, and comma
 	bonusBoundaryDelimiter int16 = bonusBoundary + 1
 
-	initialCharClass charClass = charWhite
+	initialCharClass = charWhite
 
 	// A minor optimization that can give 15%+ performance boost
 	asciiCharClasses [unicode.MaxASCII + 1]charClass

src/algo/normalize.go

@@ -3,7 +3,7 @@
 
 package algo
 
-var normalized map[rune]rune = map[rune]rune{
+var normalized = 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

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

src/ansi_test.go

@@ -342,8 +342,8 @@ func TestAnsiCodeStringConversion(t *testing.T) {
 		state := interpretCode(code, prevState)
 		if expected != state.ToString() {
 			t.Errorf("expected: %s, actual: %s",
-				strings.Replace(expected, "\x1b[", "\\x1b[", -1),
-				strings.Replace(state.ToString(), "\x1b[", "\\x1b[", -1))
+				strings.ReplaceAll(expected, "\x1b[", "\\x1b["),
+				strings.ReplaceAll(state.ToString(), "\x1b[", "\\x1b["))
 		}
 	}
 	assert("\x1b[m", nil, "")

src/cache.go

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

src/chunklist.go

@@ -16,14 +16,16 @@ type ChunkList struct {
 	chunks []*Chunk
 	mutex  sync.Mutex
 	trans  ItemBuilder
+	cache  *ChunkCache
 }
 
 // NewChunkList returns a new ChunkList
-func NewChunkList(trans ItemBuilder) *ChunkList {
+func NewChunkList(cache *ChunkCache, trans ItemBuilder) *ChunkList {
 	return &ChunkList{
 		chunks: []*Chunk{},
 		mutex:  sync.Mutex{},
-		trans:  trans}
+		trans:  trans,
+		cache:  cache}
 }
 
 func (c *Chunk) push(trans ItemBuilder, data []byte) bool {
@@ -48,7 +50,12 @@ func CountItems(cs []*Chunk) int {
 	if len(cs) == 0 {
 		return 0
 	}
-	return chunkSize*(len(cs)-1) + cs[len(cs)-1].count
+	if len(cs) == 1 {
+		return cs[0].count
+	}
+
+	// First chunk might not be full due to --tail=N
+	return cs[0].count + chunkSize*(len(cs)-2) + cs[len(cs)-1].count
 }
 
 // Push adds the item to the list
@@ -72,18 +79,56 @@ func (cl *ChunkList) Clear() {
 }
 
 // Snapshot returns immutable snapshot of the ChunkList
-func (cl *ChunkList) Snapshot() ([]*Chunk, int) {
+func (cl *ChunkList) Snapshot(tail int) ([]*Chunk, int, bool) {
 	cl.mutex.Lock()
 
+	changed := false
+	if tail > 0 && CountItems(cl.chunks) > tail {
+		changed = true
+		// Find the number of chunks to keep
+		numChunks := 0
+		for left, i := tail, len(cl.chunks)-1; left > 0 && i >= 0; i-- {
+			numChunks++
+			left -= cl.chunks[i].count
+		}
+
+		// Copy the chunks to keep
+		ret := make([]*Chunk, numChunks)
+		minIndex := len(cl.chunks) - numChunks
+		cl.cache.retire(cl.chunks[:minIndex]...)
+		copy(ret, cl.chunks[minIndex:])
+
+		for left, i := tail, len(ret)-1; i >= 0; i-- {
+			chunk := ret[i]
+			if chunk.count > left {
+				newChunk := *chunk
+				newChunk.count = left
+				oldCount := chunk.count
+				for i := 0; i < left; i++ {
+					newChunk.items[i] = chunk.items[oldCount-left+i]
+				}
+				ret[i] = &newChunk
+				cl.cache.retire(chunk)
+				break
+			}
+			left -= chunk.count
+		}
+		cl.chunks = ret
+	}
+
 	ret := make([]*Chunk, len(cl.chunks))
 	copy(ret, cl.chunks)
 
-	// Duplicate the last chunk
+	// Duplicate the first and the last chunk
 	if cnt := len(ret); cnt > 0 {
+		if tail > 0 && cnt > 1 {
+			newChunk := *ret[0]
+			ret[0] = &newChunk
+		}
 		newChunk := *ret[cnt-1]
 		ret[cnt-1] = &newChunk
 	}
 
 	cl.mutex.Unlock()
-	return ret, CountItems(ret)
+	return ret, CountItems(ret), changed
 }

src/chunklist_test.go

@@ -11,13 +11,13 @@ func TestChunkList(t *testing.T) {
 	// FIXME global
 	sortCriteria = []criterion{byScore, byLength}
 
-	cl := NewChunkList(func(item *Item, s []byte) bool {
+	cl := NewChunkList(NewChunkCache(), func(item *Item, s []byte) bool {
 		item.text = util.ToChars(s)
 		return true
 	})
 
 	// Snapshot
-	snapshot, count := cl.Snapshot()
+	snapshot, count, _ := cl.Snapshot(0)
 	if len(snapshot) > 0 || count > 0 {
 		t.Error("Snapshot should be empty now")
 	}
@@ -32,7 +32,7 @@ func TestChunkList(t *testing.T) {
 	}
 
 	// But the new snapshot should contain the added items
-	snapshot, count = cl.Snapshot()
+	snapshot, count, _ = cl.Snapshot(0)
 	if len(snapshot) != 1 && count != 2 {
 		t.Error("Snapshot should not be empty now")
 	}
@@ -61,7 +61,7 @@ func TestChunkList(t *testing.T) {
 	}
 
 	// New snapshot
-	snapshot, count = cl.Snapshot()
+	snapshot, count, _ = cl.Snapshot(0)
 	if len(snapshot) != 3 || !snapshot[0].IsFull() ||
 		!snapshot[1].IsFull() || snapshot[2].IsFull() || count != chunkSize*2+2 {
 		t.Error("Expected two full chunks and one more chunk")
@@ -78,3 +78,39 @@ func TestChunkList(t *testing.T) {
 		t.Error("Unexpected number of items:", lastChunkCount)
 	}
 }
+
+func TestChunkListTail(t *testing.T) {
+	cl := NewChunkList(NewChunkCache(), func(item *Item, s []byte) bool {
+		item.text = util.ToChars(s)
+		return true
+	})
+	total := chunkSize*2 + chunkSize/2
+	for i := 0; i < total; i++ {
+		cl.Push([]byte(fmt.Sprintf("item %d", i)))
+	}
+
+	snapshot, count, changed := cl.Snapshot(0)
+	assertCount := func(expected int, shouldChange bool) {
+		if count != expected || CountItems(snapshot) != expected {
+			t.Errorf("Unexpected count: %d (expected: %d)", count, expected)
+		}
+		if changed != shouldChange {
+			t.Error("Unexpected change status")
+		}
+	}
+	assertCount(total, false)
+
+	tail := chunkSize + chunkSize/2
+	snapshot, count, changed = cl.Snapshot(tail)
+	assertCount(tail, true)
+
+	snapshot, count, changed = cl.Snapshot(tail)
+	assertCount(tail, false)
+
+	snapshot, count, changed = cl.Snapshot(0)
+	assertCount(tail, false)
+
+	tail = chunkSize / 2
+	snapshot, count, changed = cl.Snapshot(tail)
+	assertCount(tail, true)
+}

src/constants.go

@@ -67,9 +67,9 @@ const (
 )
 
 const (
-	exitCancel    = -1
-	exitOk        = 0
-	exitNoMatch   = 1
-	exitError     = 2
-	exitInterrupt = 130
+	ExitOk        = 0
+	ExitNoMatch   = 1
+	ExitError     = 2
+	ExitBecome    = 126
+	ExitInterrupt = 130
 )

src/core.go

@@ -2,10 +2,9 @@
 package fzf
 
 import (
-	"fmt"
+	"os"
 	"sync"
 	"time"
-	"unsafe"
 
 	"github.com/junegunn/fzf/src/util"
 )
@@ -19,30 +18,52 @@ Matcher  -> EvtSearchFin      -> Terminal (update list)
 Matcher  -> EvtHeader         -> Terminal (update header)
 */
 
-func ustring(data []byte) string {
-	return unsafe.String(unsafe.SliceData(data), len(data))
+type revision struct {
+	major int
+	minor int
 }
 
-func sbytes(data string) []byte {
-	return unsafe.Slice(unsafe.StringData(data), len(data))
+func (r *revision) bumpMajor() {
+	r.major++
+	r.minor = 0
+}
+
+func (r *revision) bumpMinor() {
+	r.minor++
+}
+
+func (r revision) compatible(other revision) bool {
+	return r.major == other.major
 }
 
 // Run starts fzf
-func Run(opts *Options, version string, revision string) {
+func Run(opts *Options) (int, error) {
+	if opts.Filter == nil {
+		if opts.Tmux != nil && len(os.Getenv("TMUX")) > 0 && opts.Tmux.index >= opts.Height.index {
+			return runTmux(os.Args, opts)
+		}
+
+		if needWinpty(opts) {
+			return runWinpty(os.Args, opts)
+		}
+	}
+
+	if err := postProcessOptions(opts); err != nil {
+		return ExitError, err
+	}
+
 	defer util.RunAtExitFuncs()
 
+	// Output channel given
+	if opts.Output != nil {
+		opts.Printer = func(str string) {
+			opts.Output <- str
+		}
+	}
+
 	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)
-		}
-		util.Exit(exitOk)
-	}
-
 	// Event channel
 	eventBox := util.NewEventBox()
 
@@ -56,28 +77,29 @@ func Run(opts *Options, version string, revision string) {
 		if opts.Theme.Colored {
 			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
 				prevLineAnsiState = lineAnsiState
-				trimmed, offsets, newState := extractColor(ustring(data), lineAnsiState, nil)
+				trimmed, offsets, newState := extractColor(byteString(data), lineAnsiState, nil)
 				lineAnsiState = newState
-				return util.ToChars(sbytes(trimmed)), offsets
+				return util.ToChars(stringBytes(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(ustring(data), nil, nil)
-				return util.ToChars(sbytes(trimmed)), nil
+				trimmed, _, _ := extractColor(byteString(data), nil, nil)
+				return util.ToChars(stringBytes(trimmed)), nil
 			}
 		}
 	}
 
 	// Chunk list
+	cache := NewChunkCache()
 	var chunkList *ChunkList
 	var itemIndex int32
 	header := make([]string, 0, opts.HeaderLines)
 	if len(opts.WithNth) == 0 {
-		chunkList = NewChunkList(func(item *Item, data []byte) bool {
+		chunkList = NewChunkList(cache, func(item *Item, data []byte) bool {
 			if len(header) < opts.HeaderLines {
-				header = append(header, ustring(data))
+				header = append(header, byteString(data))
 				eventBox.Set(EvtHeader, header)
 				return false
 			}
@@ -87,8 +109,8 @@ func Run(opts *Options, version string, revision string) {
 			return true
 		})
 	} else {
-		chunkList = NewChunkList(func(item *Item, data []byte) bool {
-			tokens := Tokenize(ustring(data), opts.Delimiter)
+		chunkList = NewChunkList(cache, func(item *Item, data []byte) bool {
+			tokens := Tokenize(byteString(data), opts.Delimiter)
 			if opts.Ansi && opts.Theme.Colored && len(tokens) > 1 {
 				var ansiState *ansiState
 				if prevLineAnsiState != nil {
@@ -112,7 +134,7 @@ func Run(opts *Options, version string, revision string) {
 				eventBox.Set(EvtHeader, header)
 				return false
 			}
-			item.text, item.colors = ansiProcessor(sbytes(transformed))
+			item.text, item.colors = ansiProcessor(stringBytes(transformed))
 			item.text.TrimTrailingWhitespaces()
 			item.text.Index = itemIndex
 			item.origText = &data
@@ -124,6 +146,24 @@ func Run(opts *Options, version string, revision string) {
 	// Process executor
 	executor := util.NewExecutor(opts.WithShell)
 
+	// Terminal I/O
+	var terminal *Terminal
+	var err error
+	var initialEnv []string
+	initialReload := opts.extractReloadOnStart()
+	if opts.Filter == nil {
+		terminal, err = NewTerminal(opts, eventBox, executor)
+		if err != nil {
+			return ExitError, err
+		}
+		if len(initialReload) > 0 {
+			var temps []string
+			initialReload, temps = terminal.replacePlaceholderInInitialCommand(initialReload)
+			initialEnv = terminal.environ()
+			defer removeFiles(temps)
+		}
+	}
+
 	// Reader
 	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
 	var reader *Reader
@@ -131,7 +171,8 @@ func Run(opts *Options, version string, revision string) {
 		reader = NewReader(func(data []byte) bool {
 			return chunkList.Push(data)
 		}, eventBox, executor, opts.ReadZero, opts.Filter == nil)
-		go reader.ReadSource(opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
+
+		go reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip, initialReload, initialEnv)
 	}
 
 	// Matcher
@@ -147,14 +188,15 @@ func Run(opts *Options, version string, revision string) {
 			forward = true
 		}
 	}
+	patternCache := make(map[string]*Pattern)
 	patternBuilder := func(runes []rune) *Pattern {
-		return BuildPattern(
+		return BuildPattern(cache, patternCache,
 			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward, withPos,
 			opts.Filter == nil, opts.Nth, opts.Delimiter, runes)
 	}
-	inputRevision := 0
-	snapshotRevision := 0
-	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox, inputRevision)
+	inputRevision := revision{}
+	snapshotRevision := revision{}
+	matcher := NewMatcher(cache, patternBuilder, sort, opts.Tac, eventBox, inputRevision)
 
 	// Filtering mode
 	if opts.Filter != nil {
@@ -182,12 +224,13 @@ func Run(opts *Options, version string, revision string) {
 					}
 					return false
 				}, eventBox, executor, opts.ReadZero, false)
-			reader.ReadSource(opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip)
+			reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip, initialReload, initialEnv)
 		} else {
 			eventBox.Unwatch(EvtReadNew)
 			eventBox.WaitFor(EvtReadFin)
 
-			snapshot, _ := chunkList.Snapshot()
+			// NOTE: Streaming filter is inherently not compatible with --tail
+			snapshot, _, _ := chunkList.Snapshot(opts.Tail)
 			merger, _ := matcher.scan(MatchRequest{
 				chunks:  snapshot,
 				pattern: pattern})
@@ -197,9 +240,9 @@ func Run(opts *Options, version string, revision string) {
 			}
 		}
 		if found {
-			util.Exit(exitOk)
+			return ExitOk, nil
 		}
-		util.Exit(exitNoMatch)
+		return ExitNoMatch, nil
 	}
 
 	// Synchronous search
@@ -210,16 +253,16 @@ func Run(opts *Options, version string, revision string) {
 
 	// Go interactive
 	go matcher.Loop()
+	defer matcher.Stop()
 
-	// Terminal I/O
-	terminal := NewTerminal(opts, eventBox, executor)
+	// Handling adaptive height
 	maxFit := 0 // Maximum number of items that can fit on screen
 	padHeight := 0
 	heightUnknown := opts.Height.auto
 	if heightUnknown {
 		maxFit, padHeight = terminal.MaxFitAndPad()
 	}
-	deferred := opts.Select1 || opts.Exit0
+	deferred := opts.Select1 || opts.Exit0 || opts.Sync
 	go terminal.Loop()
 	if !deferred && !heightUnknown {
 		// Start right away
@@ -229,7 +272,7 @@ func Run(opts *Options, version string, revision string) {
 	// Event coordination
 	reading := true
 	ticks := 0
-	var nextCommand *string
+	var nextCommand *commandSpec
 	var nextEnviron []string
 	eventBox.Watch(EvtReadNew)
 	total := 0
@@ -250,14 +293,17 @@ func Run(opts *Options, version string, revision string) {
 	useSnapshot := false
 	var snapshot []*Chunk
 	var count int
-	restart := func(command string, environ []string) {
+	restart := func(command commandSpec, environ []string) {
 		reading = true
 		chunkList.Clear()
 		itemIndex = 0
-		inputRevision++
+		inputRevision.bumpMajor()
 		header = make([]string, 0, opts.HeaderLines)
 		go reader.restart(command, environ)
 	}
+
+	exitCode := ExitOk
+	stop := false
 	for {
 		delay := true
 		ticks++
@@ -278,7 +324,11 @@ func Run(opts *Options, version string, revision string) {
 					if reading {
 						reader.terminate()
 					}
-					util.Exit(value.(int))
+					quitSignal := value.(quitSignal)
+					exitCode = quitSignal.code
+					err = quitSignal.err
+					stop = true
+					return
 				case EvtReadNew, EvtReadFin:
 					if evt == EvtReadFin && nextCommand != nil {
 						restart(*nextCommand, nextEnviron)
@@ -292,24 +342,25 @@ func Run(opts *Options, version string, revision string) {
 						useSnapshot = false
 					}
 					if !useSnapshot {
-						if snapshotRevision != inputRevision {
+						if !snapshotRevision.compatible(inputRevision) {
 							query = []rune{}
 						}
-						snapshot, count = chunkList.Snapshot()
+						var changed bool
+						snapshot, count, changed = chunkList.Snapshot(opts.Tail)
+						if changed {
+							inputRevision.bumpMinor()
+						}
 						snapshotRevision = inputRevision
 					}
 					total = count
 					terminal.UpdateCount(total, !reading, value.(*string))
-					if opts.Sync {
-						terminal.UpdateList(PassMerger(&snapshot, opts.Tac, snapshotRevision), false)
-					}
 					if heightUnknown && !deferred {
 						determine(!reading)
 					}
 					matcher.Reset(snapshot, input(), false, !reading, sort, snapshotRevision)
 
 				case EvtSearchNew:
-					var command *string
+					var command *commandSpec
 					var environ []string
 					var changed bool
 					switch val := value.(type) {
@@ -335,7 +386,10 @@ func Run(opts *Options, version string, revision string) {
 						break
 					}
 					if !useSnapshot {
-						newSnapshot, newCount := chunkList.Snapshot()
+						newSnapshot, newCount, changed := chunkList.Snapshot(opts.Tail)
+						if changed {
+							inputRevision.bumpMinor()
+						}
 						// We want to avoid showing empty list when reload is triggered
 						// and the query string is changed at the same time i.e. command != nil && changed
 						if command == nil || newCount > 0 {
@@ -378,20 +432,24 @@ func Run(opts *Options, version string, revision string) {
 									for i := 0; i < count; i++ {
 										opts.Printer(val.Get(i).item.AsString(opts.Ansi))
 									}
-									if count > 0 {
-										util.Exit(exitOk)
+									if count == 0 {
+										exitCode = ExitNoMatch
 									}
-									util.Exit(exitNoMatch)
+									stop = true
+									return
 								}
 								determine(val.final)
 							}
 						}
-						terminal.UpdateList(val, true)
+						terminal.UpdateList(val)
 					}
 				}
 			}
 			events.Clear()
 		})
+		if stop {
+			break
+		}
 		if delay && reading {
 			dur := util.DurWithin(
 				time.Duration(ticks)*coordinatorDelayStep,
@@ -399,4 +457,5 @@ func Run(opts *Options, version string, revision string) {
 			time.Sleep(dur)
 		}
 	}
+	return exitCode, err
 }

src/functions.go

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

src/item.go

@@ -1,6 +1,8 @@
 package fzf
 
 import (
+	"math"
+
 	"github.com/junegunn/fzf/src/util"
 )
 
@@ -17,7 +19,7 @@ func (item *Item) Index() int32 {
 	return item.text.Index
 }
 
-var minItem = Item{text: util.Chars{Index: -1}}
+var minItem = Item{text: util.Chars{Index: math.MinInt32}}
 
 func (item *Item) TrimLength() uint16 {
 	return item.text.TrimLength()

src/matcher.go

@@ -16,11 +16,12 @@ type MatchRequest struct {
 	pattern  *Pattern
 	final    bool
 	sort     bool
-	revision int
+	revision revision
 }
 
 // Matcher is responsible for performing search
 type Matcher struct {
+	cache          *ChunkCache
 	patternBuilder func([]rune) *Pattern
 	sort           bool
 	tac            bool
@@ -29,7 +30,7 @@ type Matcher struct {
 	partitions     int
 	slab           []*util.Slab
 	mergerCache    map[string]*Merger
-	revision       int
+	revision       revision
 }
 
 const (
@@ -38,10 +39,11 @@ const (
 )
 
 // NewMatcher returns a new Matcher
-func NewMatcher(patternBuilder func([]rune) *Pattern,
-	sort bool, tac bool, eventBox *util.EventBox, revision int) *Matcher {
+func NewMatcher(cache *ChunkCache, patternBuilder func([]rune) *Pattern,
+	sort bool, tac bool, eventBox *util.EventBox, revision revision) *Matcher {
 	partitions := util.Min(numPartitionsMultiplier*runtime.NumCPU(), maxPartitions)
 	return &Matcher{
+		cache:          cache,
 		patternBuilder: patternBuilder,
 		sort:           sort,
 		tac:            tac,
@@ -60,8 +62,13 @@ func (m *Matcher) Loop() {
 	for {
 		var request MatchRequest
 
+		stop := false
 		m.reqBox.Wait(func(events *util.Events) {
-			for _, val := range *events {
+			for t, val := range *events {
+				if t == reqQuit {
+					stop = true
+					return
+				}
 				switch val := val.(type) {
 				case MatchRequest:
 					request = val
@@ -71,12 +78,19 @@ func (m *Matcher) Loop() {
 			}
 			events.Clear()
 		})
+		if stop {
+			break
+		}
 
+		cacheCleared := false
 		if request.sort != m.sort || request.revision != m.revision {
 			m.sort = request.sort
 			m.revision = request.revision
 			m.mergerCache = make(map[string]*Merger)
-			clearChunkCache()
+			if !request.revision.compatible(m.revision) {
+				m.cache.Clear()
+			}
+			cacheCleared = true
 		}
 
 		// Restart search
@@ -85,20 +99,20 @@ func (m *Matcher) Loop() {
 		cancelled := false
 		count := CountItems(request.chunks)
 
-		foundCache := false
-		if count == prevCount {
-			// Look up mergerCache
-			if cached, found := m.mergerCache[patternString]; found {
-				foundCache = true
-				merger = cached
+		if !cacheCleared {
+			if count == prevCount {
+				// Look up mergerCache
+				if cached, found := m.mergerCache[patternString]; found {
+					merger = cached
+				}
+			} else {
+				// Invalidate mergerCache
+				prevCount = count
+				m.mergerCache = make(map[string]*Merger)
 			}
-		} else {
-			// Invalidate mergerCache
-			prevCount = count
-			m.mergerCache = make(map[string]*Merger)
 		}
 
-		if !foundCache {
+		if merger == nil {
 			merger, cancelled = m.scan(request)
 		}
 
@@ -150,6 +164,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		return PassMerger(&request.chunks, m.tac, request.revision), false
 	}
 
+	minIndex := request.chunks[0].items[0].Index()
 	cancelled := util.NewAtomicBool(false)
 
 	slices := m.sliceChunks(request.chunks)
@@ -180,7 +195,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 			for _, matches := range allMatches {
 				sliceMatches = append(sliceMatches, matches...)
 			}
-			if m.sort {
+			if m.sort && request.pattern.sortable {
 				if m.tac {
 					sort.Sort(ByRelevanceTac(sliceMatches))
 				} else {
@@ -221,11 +236,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 && request.pattern.sortable, m.tac, request.revision, minIndex), 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, revision revision) {
 	pattern := m.patternBuilder(patternRunes)
 
 	var event util.EventType
@@ -234,5 +249,9 @@ func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final
 	} else {
 		event = reqRetry
 	}
-	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort && pattern.sortable, revision})
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort, revision})
+}
+
+func (m *Matcher) Stop() {
+	m.reqBox.Set(reqQuit, nil)
 }

src/merger.go

@@ -3,8 +3,8 @@ package fzf
 import "fmt"
 
 // EmptyMerger is a Merger with no data
-func EmptyMerger(revision int) *Merger {
-	return NewMerger(nil, [][]Result{}, false, false, revision)
+func EmptyMerger(revision revision) *Merger {
+	return NewMerger(nil, [][]Result{}, false, false, revision, 0)
 }
 
 // Merger holds a set of locally sorted lists of items and provides the view of
@@ -20,19 +20,25 @@ type Merger struct {
 	final    bool
 	count    int
 	pass     bool
-	revision int
+	revision revision
+	minIndex int32
 }
 
 // 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, revision revision) *Merger {
+	var minIndex int32
+	if len(*chunks) > 0 {
+		minIndex = (*chunks)[0].items[0].Index()
+	}
 	mg := Merger{
 		pattern:  nil,
 		chunks:   chunks,
 		tac:      tac,
 		count:    0,
 		pass:     true,
-		revision: revision}
+		revision: revision,
+		minIndex: minIndex}
 
 	for _, chunk := range *mg.chunks {
 		mg.count += chunk.count
@@ -41,7 +47,7 @@ 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, revision revision, minIndex int32) *Merger {
 	mg := Merger{
 		pattern:  pattern,
 		lists:    lists,
@@ -52,7 +58,8 @@ func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revisi
 		tac:      tac,
 		final:    false,
 		count:    0,
-		revision: revision}
+		revision: revision,
+		minIndex: minIndex}
 
 	for _, list := range mg.lists {
 		mg.count += len(list)
@@ -61,7 +68,7 @@ func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revisi
 }
 
 // Revision returns revision number
-func (mg *Merger) Revision() int {
+func (mg *Merger) Revision() revision {
 	return mg.revision
 }
 
@@ -81,7 +88,7 @@ func (mg *Merger) First() Result {
 func (mg *Merger) FindIndex(itemIndex int32) int {
 	index := -1
 	if mg.pass {
-		index = int(itemIndex)
+		index = int(itemIndex - mg.minIndex)
 		if mg.tac {
 			index = mg.count - index - 1
 		}
@@ -102,6 +109,13 @@ func (mg *Merger) Get(idx int) Result {
 		if mg.tac {
 			idx = mg.count - idx - 1
 		}
+		firstChunk := (*mg.chunks)[0]
+		if firstChunk.count < chunkSize && idx >= firstChunk.count {
+			idx -= firstChunk.count
+
+			chunk := (*mg.chunks)[idx/chunkSize+1]
+			return Result{item: &chunk.items[idx%chunkSize]}
+		}
 		chunk := (*mg.chunks)[idx/chunkSize]
 		return Result{item: &chunk.items[idx%chunkSize]}
 	}

src/merger_test.go

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

src/options_no_pprof.go

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

src/options_test.go

@@ -80,7 +80,7 @@ func TestDelimiterRegexRegexCaret(t *testing.T) {
 
 func TestSplitNth(t *testing.T) {
 	{
-		ranges := splitNth("..")
+		ranges, _ := splitNth("..")
 		if len(ranges) != 1 ||
 			ranges[0].begin != rangeEllipsis ||
 			ranges[0].end != rangeEllipsis {
@@ -88,7 +88,7 @@ func TestSplitNth(t *testing.T) {
 		}
 	}
 	{
-		ranges := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2,2..-2,1..-1")
+		ranges, _ := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2,2..-2,1..-1")
 		if len(ranges) != 10 ||
 			ranges[0].begin != rangeEllipsis || ranges[0].end != 3 ||
 			ranges[1].begin != rangeEllipsis || ranges[1].end != rangeEllipsis ||
@@ -106,10 +106,11 @@ func TestSplitNth(t *testing.T) {
 }
 
 func TestIrrelevantNth(t *testing.T) {
+	index := 0
 	{
 		opts := defaultOptions()
 		words := []string{"--nth", "..", "-x"}
-		parseOptions(opts, words)
+		parseOptions(&index, opts, words)
 		postProcessOptions(opts)
 		if len(opts.Nth) != 0 {
 			t.Errorf("nth should be empty: %v", opts.Nth)
@@ -118,7 +119,7 @@ func TestIrrelevantNth(t *testing.T) {
 	for _, words := range [][]string{{"--nth", "..,3", "+x"}, {"--nth", "3,1..", "+x"}, {"--nth", "..-1,1", "+x"}} {
 		{
 			opts := defaultOptions()
-			parseOptions(opts, words)
+			parseOptions(&index, opts, words)
 			postProcessOptions(opts)
 			if len(opts.Nth) != 0 {
 				t.Errorf("nth should be empty: %v", opts.Nth)
@@ -127,7 +128,7 @@ func TestIrrelevantNth(t *testing.T) {
 		{
 			opts := defaultOptions()
 			words = append(words, "-x")
-			parseOptions(opts, words)
+			parseOptions(&index, opts, words)
 			postProcessOptions(opts)
 			if len(opts.Nth) != 2 {
 				t.Errorf("nth should not be empty: %v", opts.Nth)
@@ -137,7 +138,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,7 +164,7 @@ 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)
 	}
@@ -177,7 +178,7 @@ func TestParseKeys(t *testing.T) {
 	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)
 	}
@@ -206,40 +207,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-,")
 }
@@ -262,17 +263,13 @@ func TestBind(t *testing.T) {
 		}
 	}
 	check(tui.CtrlA.AsEvent(), "", actBeginningOfLine)
-	errorString := ""
-	errorFn := func(e string) {
-		errorString = e
-	}
 	parseKeymap(keymap,
 		"ctrl-a:kill-line,ctrl-b:toggle-sort+up+down,c:page-up,alt-z:page-down,"+
 			"f1:execute(ls {+})+abort+execute(echo \n{+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
 			"alt-a:execute-Multi@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};,"+
 			"x:Execute(foo+bar),X:execute/bar+baz/"+
 			",f1:+first,f1:+top"+
-			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up", errorFn)
+			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up")
 	check(tui.CtrlA.AsEvent(), "", actKillLine)
 	check(tui.CtrlB.AsEvent(), "", actToggleSort, actUp, actDown)
 	check(tui.Key('c'), "", actPageUp)
@@ -290,20 +287,17 @@ func TestBind(t *testing.T) {
 	check(tui.Key('+'), "++\nfoobar,Y:execute(baz)+up", actExecute)
 
 	for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} {
-		parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char), errorFn)
+		parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
 		check(tui.Key([]rune(fmt.Sprintf("%d", idx%10))[0]), "foobar", actExecute)
 	}
 
-	parseKeymap(keymap, "f1:abort", errorFn)
+	parseKeymap(keymap, "f1:abort")
 	check(tui.F1.AsEvent(), "", actAbort)
-	if len(errorString) > 0 {
-		t.Errorf("error parsing keymap: %s", errorString)
-	}
 }
 
 func TestColorSpec(t *testing.T) {
 	theme := tui.Dark256
-	dark := parseTheme(theme, "dark")
+	dark, _ := parseTheme(theme, "dark")
 	if *dark != *theme {
 		t.Errorf("colors should be equivalent")
 	}
@@ -311,7 +305,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")
 	}
@@ -322,7 +316,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")
 	}
@@ -335,17 +329,18 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("colors should now be equivalent: %v, %v", tui.Dark256, customized)
 	}
 
-	customized = parseTheme(theme, "fg:231,dark,bg:232")
+	customized, _ = parseTheme(theme, "fg:231,dark,bg:232")
 	if customized.Fg != tui.Dark256.Fg || customized.Bg == tui.Dark256.Bg {
 		t.Errorf("color not customized")
 	}
 }
 
 func TestDefaultCtrlNP(t *testing.T) {
+	index := 0
 	check := func(words []string, et tui.EventType, expected actionType) {
 		e := et.AsEvent()
 		opts := defaultOptions()
-		parseOptions(opts, words)
+		parseOptions(&index, opts, words)
 		postProcessOptions(opts)
 		if opts.Keymap[e][0].t != expected {
 			t.Error()
@@ -371,8 +366,9 @@ func TestDefaultCtrlNP(t *testing.T) {
 }
 
 func optsFor(words ...string) *Options {
+	index := 0
 	opts := defaultOptions()
-	parseOptions(opts, words)
+	parseOptions(&index, opts, words)
 	postProcessOptions(opts)
 	return opts
 }
@@ -458,7 +454,6 @@ func TestValidateSign(t *testing.T) {
 		{"> ", true},
 		{"아", true},
 		{"😀", true},
-		{"", false},
 		{">>>", false},
 	}
 
@@ -475,7 +470,7 @@ func TestValidateSign(t *testing.T) {
 }
 
 func TestParseSingleActionList(t *testing.T) {
-	actions := parseSingleActionList("Execute@foo+bar,baz@+up+up+reload:down+down", func(string) {})
+	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))
 	}
@@ -491,11 +486,8 @@ func TestParseSingleActionList(t *testing.T) {
 }
 
 func TestParseSingleActionListError(t *testing.T) {
-	err := ""
-	parseSingleActionList("change-query(foobar)baz", func(e string) {
-		err = e
-	})
-	if len(err) == 0 {
+	_, err := parseSingleActionList("change-query(foobar)baz")
+	if err == nil {
 		t.Errorf("Failed to detect error")
 	}
 }

src/pattern.go

@@ -60,32 +60,17 @@ type Pattern struct {
 	delimiter     Delimiter
 	nth           []Range
 	procFun       map[termType]algo.Algo
+	cache         *ChunkCache
 }
 
-var (
-	_patternCache map[string]*Pattern
-	_splitRegex   *regexp.Regexp
-	_cache        ChunkCache
-)
+var _splitRegex *regexp.Regexp
 
 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(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
+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 {
 
 	var asString string
@@ -98,7 +83,9 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 		asString = string(runes)
 	}
 
-	cached, found := _patternCache[asString]
+	// 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]
 	if found {
 		return cached
 	}
@@ -153,6 +140,7 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 		cacheable:     cacheable,
 		nth:           nth,
 		delimiter:     delimiter,
+		cache:         cache,
 		procFun:       make(map[termType]algo.Algo)}
 
 	ptr.cacheKey = ptr.buildCacheKey()
@@ -162,19 +150,19 @@ func BuildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 	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.Replace(str, "\\ ", "\t", -1)
+	str = strings.ReplaceAll(str, "\\ ", "\t")
 	tokens := _splitRegex.Split(str, -1)
 	sets := []termSet{}
 	set := termSet{}
 	switchSet := false
 	afterBar := false
 	for _, token := range tokens {
-		typ, inv, text := termFuzzy, false, strings.Replace(token, "\t", " ", -1)
+		typ, inv, text := termFuzzy, false, strings.ReplaceAll(token, "\t", " ")
 		lowerText := strings.ToLower(text)
 		caseSensitive := caseMode == CaseRespect ||
 			caseMode == CaseSmart && text != lowerText
@@ -282,18 +270,18 @@ func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []Result {
 	// ChunkCache: Exact match
 	cacheKey := p.CacheKey()
 	if p.cacheable {
-		if cached := _cache.Lookup(chunk, cacheKey); cached != nil {
+		if cached := p.cache.Lookup(chunk, cacheKey); cached != nil {
 			return cached
 		}
 	}
 
 	// Prefix/suffix cache
-	space := _cache.Search(chunk, cacheKey)
+	space := p.cache.Search(chunk, cacheKey)
 
 	matches := p.matchChunk(chunk, space, slab)
 
 	if p.cacheable {
-		_cache.Add(chunk, cacheKey, matches)
+		p.cache.Add(chunk, cacheKey, matches)
 	}
 	return matches
 }

src/pattern_test.go

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

src/protector/protector.go

@@ -3,6 +3,4 @@
 package protector
 
 // Protect calls OS specific protections like pledge on OpenBSD
-func Protect() {
-	return
-}
+func Protect() {}

src/protector/protector_openbsd.go

@@ -6,5 +6,5 @@ import "golang.org/x/sys/unix"
 
 // Protect calls OS specific protections like pledge on OpenBSD
 func Protect() {
-	unix.PledgePromises("stdio rpath tty proc exec inet tmppath")
+	unix.PledgePromises("stdio dpath wpath rpath tty proc exec inet tmppath")
 }

src/proxy.go

@@ -0,0 +1,146 @@
+package fzf
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/junegunn/fzf/src/tui"
+	"github.com/junegunn/fzf/src/util"
+)
+
+const becomeSuffix = ".become"
+
+func escapeSingleQuote(str string) string {
+	return "'" + strings.ReplaceAll(str, "'", "'\\''") + "'"
+}
+
+func fifo(name string) (string, error) {
+	ns := time.Now().UnixNano()
+	output := filepath.Join(os.TempDir(), fmt.Sprintf("fzf-%s-%d", name, ns))
+	output, err := mkfifo(output, 0600)
+	if err != nil {
+		return output, err
+	}
+	return output, nil
+}
+
+func runProxy(commandPrefix string, cmdBuilder func(temp string) *exec.Cmd, opts *Options, withExports bool) (int, error) {
+	output, err := fifo("proxy-output")
+	if err != nil {
+		return ExitError, err
+	}
+	defer os.Remove(output)
+
+	// Take the output
+	go func() {
+		withOutputPipe(output, func(outputFile io.ReadCloser) {
+			if opts.Output == nil {
+				io.Copy(os.Stdout, outputFile)
+			} else {
+				reader := bufio.NewReader(outputFile)
+				sep := opts.PrintSep[0]
+				for {
+					item, err := reader.ReadString(sep)
+					if err != nil {
+						break
+					}
+					opts.Output <- item
+				}
+			}
+		})
+	}()
+
+	var command string
+	commandPrefix += ` --no-force-tty-in --proxy-script "$0"`
+	if opts.Input == nil && (opts.ForceTtyIn || util.IsTty(os.Stdin)) {
+		command = fmt.Sprintf(`%s > %q`, commandPrefix, output)
+	} else {
+		input, err := fifo("proxy-input")
+		if err != nil {
+			return ExitError, err
+		}
+		defer os.Remove(input)
+
+		go func() {
+			withInputPipe(input, func(inputFile io.WriteCloser) {
+				if opts.Input == nil {
+					io.Copy(inputFile, os.Stdin)
+				} else {
+					for item := range opts.Input {
+						fmt.Fprint(inputFile, item+opts.PrintSep)
+					}
+				}
+			})
+		}()
+
+		if withExports {
+			command = fmt.Sprintf(`%s < %q > %q`, commandPrefix, input, output)
+		} else {
+			// For mintty: cannot directly read named pipe from Go code
+			command = fmt.Sprintf(`command cat %q | %s > %q`, input, commandPrefix, output)
+		}
+	}
+
+	// To ensure that the options are processed by a POSIX-compliant shell,
+	// we need to write the command to a temporary file and execute it with sh.
+	var exports []string
+	if withExports {
+		exports = os.Environ()
+		for idx, pairStr := range exports {
+			pair := strings.SplitN(pairStr, "=", 2)
+			exports[idx] = fmt.Sprintf("export %s=%s", pair[0], escapeSingleQuote(pair[1]))
+		}
+	}
+	temp := WriteTemporaryFile(append(exports, command), "\n")
+	defer os.Remove(temp)
+
+	cmd := cmdBuilder(temp)
+	cmd.Stderr = os.Stderr
+	intChan := make(chan os.Signal, 1)
+	defer close(intChan)
+	go func() {
+		if sig, valid := <-intChan; valid {
+			cmd.Process.Signal(sig)
+		}
+	}()
+	signal.Notify(intChan, os.Interrupt)
+	if err := cmd.Run(); err != nil {
+		if exitError, ok := err.(*exec.ExitError); ok {
+			code := exitError.ExitCode()
+			if code == ExitBecome {
+				becomeFile := temp + becomeSuffix
+				data, err := os.ReadFile(becomeFile)
+				os.Remove(becomeFile)
+				if err != nil {
+					return ExitError, err
+				}
+				elems := strings.Split(string(data), "\x00")
+				if len(elems) < 1 {
+					return ExitError, errors.New("invalid become command")
+				}
+				command := elems[0]
+				env := []string{}
+				if len(elems) > 1 {
+					env = elems[1:]
+				}
+				executor := util.NewExecutor(opts.WithShell)
+				ttyin, err := tui.TtyIn()
+				if err != nil {
+					return ExitError, err
+				}
+				executor.Become(ttyin, env, command)
+			}
+			return code, err
+		}
+	}
+
+	return ExitOk, nil
+}

src/proxy_unix.go

@@ -0,0 +1,38 @@
+//go:build !windows
+
+package fzf
+
+import (
+	"io"
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+func sh() (string, error) {
+	return "sh", nil
+}
+
+func mkfifo(path string, mode uint32) (string, error) {
+	return path, unix.Mkfifo(path, mode)
+}
+
+func withOutputPipe(output string, task func(io.ReadCloser)) error {
+	outputFile, err := os.OpenFile(output, os.O_RDONLY, 0)
+	if err != nil {
+		return err
+	}
+	task(outputFile)
+	outputFile.Close()
+	return nil
+}
+
+func withInputPipe(input string, task func(io.WriteCloser)) error {
+	inputFile, err := os.OpenFile(input, os.O_WRONLY, 0)
+	if err != nil {
+		return err
+	}
+	task(inputFile)
+	inputFile.Close()
+	return nil
+}

src/proxy_windows.go

@@ -0,0 +1,81 @@
+//go:build windows
+
+package fzf
+
+import (
+	"fmt"
+	"io"
+	"os/exec"
+	"strconv"
+	"strings"
+	"sync/atomic"
+)
+
+var shPath atomic.Value
+
+func sh() (string, error) {
+	if cached := shPath.Load(); cached != nil {
+		return cached.(string), nil
+	}
+
+	cmd := exec.Command("cygpath", "-w", "/usr/bin/sh")
+	bytes, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+
+	sh := strings.TrimSpace(string(bytes))
+	shPath.Store(sh)
+	return sh, nil
+}
+
+func mkfifo(path string, mode uint32) (string, error) {
+	m := strconv.FormatUint(uint64(mode), 8)
+	sh, err := sh()
+	if err != nil {
+		return path, err
+	}
+	cmd := exec.Command(sh, "-c", fmt.Sprintf(`command mkfifo -m %s %q`, m, path))
+	if err := cmd.Run(); err != nil {
+		return path, err
+	}
+	return path + ".lnk", nil
+}
+
+func withOutputPipe(output string, task func(io.ReadCloser)) error {
+	sh, err := sh()
+	if err != nil {
+		return err
+	}
+	cmd := exec.Command(sh, "-c", fmt.Sprintf(`command cat %q`, output))
+	outputFile, err := cmd.StdoutPipe()
+	if err != nil {
+		return err
+	}
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	task(outputFile)
+	cmd.Wait()
+	return nil
+}
+
+func withInputPipe(input string, task func(io.WriteCloser)) error {
+	sh, err := sh()
+	if err != nil {
+		return err
+	}
+	cmd := exec.Command(sh, "-c", fmt.Sprintf(`command cat - > %q`, input))
+	inputFile, err := cmd.StdinPipe()
+	if err != nil {
+		return err
+	}
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+	task(inputFile)
+	inputFile.Close()
+	cmd.Wait()
+	return nil
+}

src/reader.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"io"
+	"io/fs"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -25,6 +26,7 @@ type Reader struct {
 	finChan  chan bool
 	mutex    sync.Mutex
 	exec     *exec.Cmd
+	execOut  io.ReadCloser
 	command  *string
 	killed   bool
 	wait     bool
@@ -32,7 +34,7 @@ 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}
+	return &Reader{pusher, executor, eventBox, delimNil, int32(EvtReady), make(chan bool, 1), sync.Mutex{}, nil, nil, nil, false, wait}
 }
 
 func (r *Reader) startEventPoller() {
@@ -79,6 +81,7 @@ func (r *Reader) terminate() {
 	r.mutex.Lock()
 	r.killed = true
 	if r.exec != nil && r.exec.Process != nil {
+		r.execOut.Close()
 		util.KillCommand(r.exec)
 	} else {
 		os.Stdin.Close()
@@ -86,24 +89,41 @@ func (r *Reader) terminate() {
 	r.mutex.Unlock()
 }
 
-func (r *Reader) restart(command string, environ []string) {
+func (r *Reader) restart(command commandSpec, environ []string) {
 	r.event = int32(EvtReady)
 	r.startEventPoller()
-	success := r.readFromCommand(command, environ)
+	success := r.readFromCommand(command.command, environ)
 	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(root string, opts walkerOpts, ignores []string) {
+func (r *Reader) ReadSource(inputChan chan string, root string, opts walkerOpts, ignores []string, initCmd string, initEnv []string) {
 	r.startEventPoller()
 	var success bool
-	if util.IsTty() {
+	if inputChan != nil {
+		success = r.readChannel(inputChan)
+	} else if len(initCmd) > 0 {
+		success = r.readFromCommand(initCmd, initEnv)
+	} else if util.IsTty(os.Stdin) {
 		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
 		if len(cmd) == 0 {
 			success = r.readFiles(root, opts, ignores)
 		} else {
-			// We can't export FZF_* environment variables to the default command
-			success = r.readFromCommand(cmd, nil)
+			success = r.readFromCommand(cmd, initEnv)
 		}
 	} else {
 		success = r.readFromStdin()
@@ -204,17 +224,46 @@ func (r *Reader) readFromStdin() bool {
 	return true
 }
 
+func isSymlinkToDir(path string, de os.DirEntry) bool {
+	if de.Type()&fs.ModeSymlink == 0 {
+		return false
+	}
+	if s, err := os.Stat(path); err == nil {
+		return s.IsDir()
+	}
+	return false
+}
+
+func trimPath(path string) string {
+	bytes := stringBytes(path)
+
+	for len(bytes) > 1 && bytes[0] == '.' && (bytes[1] == '/' || bytes[1] == '\\') {
+		bytes = bytes[2:]
+	}
+
+	if len(bytes) == 0 {
+		return "."
+	}
+
+	return byteString(bytes)
+}
+
 func (r *Reader) readFiles(root string, opts walkerOpts, ignores []string) bool {
 	r.killed = false
-	conf := fastwalk.Config{Follow: opts.follow}
+	conf := fastwalk.Config{
+		Follow: opts.follow,
+		// Use forward slashes when running a Windows binary under WSL or MSYS
+		ToSlash: fastwalk.DefaultToSlash(),
+		Sort:    fastwalk.SortFilesFirst,
+	}
 	fn := func(path string, de os.DirEntry, err error) error {
 		if err != nil {
 			return nil
 		}
-		path = filepath.Clean(path)
+		path = trimPath(path)
 		if path != "." {
 			isDir := de.IsDir()
-			if isDir {
+			if isDir || opts.follow && isSymlinkToDir(path, de) {
 				base := filepath.Base(path)
 				if !opts.hidden && base[0] == '.' {
 					return filepath.SkipDir
@@ -225,7 +274,7 @@ func (r *Reader) readFiles(root string, opts walkerOpts, ignores []string) bool
 					}
 				}
 			}
-			if ((opts.file && !isDir) || (opts.dir && isDir)) && r.pusher([]byte(path)) {
+			if ((opts.file && !isDir) || (opts.dir && isDir)) && r.pusher(stringBytes(path)) {
 				atomic.StoreInt32(&r.event, int32(EvtReadNew))
 			}
 		}
@@ -247,16 +296,23 @@ func (r *Reader) readFromCommand(command string, environ []string) bool {
 	if environ != nil {
 		r.exec.Env = environ
 	}
-	out, err := r.exec.StdoutPipe()
+
+	var err error
+	r.execOut, err = r.exec.StdoutPipe()
 	if err != nil {
+		r.exec = nil
 		r.mutex.Unlock()
 		return false
 	}
+
 	err = r.exec.Start()
-	r.mutex.Unlock()
 	if err != nil {
+		r.exec = nil
+		r.mutex.Unlock()
 		return false
 	}
-	r.feed(out)
+
+	r.mutex.Unlock()
+	r.feed(r.execOut)
 	return r.exec.Wait() == nil
 }

src/result.go

@@ -15,6 +15,7 @@ type Offset [2]int32
 type colorOffset struct {
 	offset [2]int32
 	color  tui.ColorPair
+	match  bool
 }
 
 type Result struct {
@@ -80,7 +81,7 @@ func buildResult(item *Item, offsets []Offset, score int) Result {
 				if criterion == byBegin {
 					val = util.AsUint16(minEnd - whitePrefixLen)
 				} else {
-					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/int(item.TrimLength()+1))
+					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/(int(item.TrimLength())+1))
 				}
 			}
 		}
@@ -109,7 +110,7 @@ func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme,
 	if len(itemColors) == 0 {
 		var offsets []colorOffset
 		for _, off := range matchOffsets {
-			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: colMatch})
+			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: colMatch, match: true})
 		}
 		return offsets
 	}
@@ -193,12 +194,13 @@ func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme,
 					}
 				}
 				colors = append(colors, colorOffset{
-					offset: [2]int32{int32(start), int32(idx)}, color: color})
+					offset: [2]int32{int32(start), int32(idx)}, color: color, match: true})
 			} else {
 				ansi := itemColors[curr-1]
 				colors = append(colors, colorOffset{
 					offset: [2]int32{int32(start), int32(idx)},
-					color:  ansiToColorPair(ansi, colBase)})
+					color:  ansiToColorPair(ansi, colBase),
+					match:  false})
 			}
 		}
 	}

src/server.go

@@ -38,9 +38,9 @@ const (
 )
 
 type httpServer struct {
-	apiKey          []byte
-	actionChannel   chan []*action
-	responseChannel chan string
+	apiKey        []byte
+	actionChannel chan []*action
+	getHandler    func(getParams) string
 }
 
 type listenAddress struct {
@@ -73,35 +73,35 @@ func parseListenAddress(address string) (listenAddress, error) {
 	return listenAddress{parts[0], port}, nil
 }
 
-func startHttpServer(address listenAddress, actionChannel chan []*action, responseChannel chan string) (int, error) {
+func startHttpServer(address listenAddress, actionChannel chan []*action, getHandler func(getParams) string) (net.Listener, int, error) {
 	host := address.host
 	port := address.port
 	apiKey := os.Getenv("FZF_API_KEY")
 	if !address.IsLocal() && len(apiKey) == 0 {
-		return port, errors.New("FZF_API_KEY is required to allow remote access")
+		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 port, fmt.Errorf("failed to listen on %s", addrStr)
+		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 port, fmt.Errorf("cannot extract port: %s", addr)
+			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 port, err
+			return nil, port, err
 		}
 	}
 
 	server := httpServer{
-		apiKey:          []byte(apiKey),
-		actionChannel:   actionChannel,
-		responseChannel: responseChannel,
+		apiKey:        []byte(apiKey),
+		actionChannel: actionChannel,
+		getHandler:    getHandler,
 	}
 
 	go func() {
@@ -109,18 +109,16 @@ func startHttpServer(address listenAddress, actionChannel chan []*action, respon
 			conn, err := listener.Accept()
 			if err != nil {
 				if errors.Is(err, net.ErrClosed) {
-					break
-				} else {
-					continue
+					return
 				}
+				continue
 			}
 			conn.Write([]byte(server.handleHttpRequest(conn)))
 			conn.Close()
 		}
-		listener.Close()
 	}()
 
-	return port, nil
+	return listener, port, nil
 }
 
 // Here we are writing a simplistic HTTP server without using net/http
@@ -167,17 +165,11 @@ func (server *httpServer) handleHttpRequest(conn net.Conn) string {
 		case 0:
 			getMatch := getRegex.FindStringSubmatch(text)
 			if len(getMatch) > 0 {
-				server.actionChannel <- []*action{{t: actResponse, a: getMatch[1]}}
-				select {
-				case response := <-server.responseChannel:
+				response := server.getHandler(parseGetParams(getMatch[1]))
+				if len(response) > 0 {
 					return good(response)
-				case <-time.After(channelTimeout):
-					go func() {
-						// Drain the channel
-						<-server.responseChannel
-					}()
-					return answer(httpUnavailable+jsonContentType, `{"error":"timeout"}`)
 				}
+				return answer(httpUnavailable+jsonContentType, `{"error":"timeout"}`)
 			} else if !strings.HasPrefix(text, "POST / HTTP") {
 				return bad("invalid request method")
 			}
@@ -217,12 +209,9 @@ func (server *httpServer) handleHttpRequest(conn net.Conn) string {
 	}
 	body = body[:contentLength]
 
-	errorMessage := ""
-	actions := parseSingleActionList(strings.Trim(string(body), "\r\n"), func(message string) {
-		errorMessage = message
-	})
-	if len(errorMessage) > 0 {
-		return bad(errorMessage)
+	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")

src/terminal_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter, printsep string, forcePlus bool, query string, allItems []*Item) string {
-	return replacePlaceholder(replacePlaceholderParams{
+	replaced, _ := replacePlaceholder(replacePlaceholderParams{
 		template:   template,
 		stripAnsi:  stripAnsi,
 		delimiter:  delimiter,
@@ -25,6 +25,7 @@ func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter
 		prompt:     "prompt",
 		executor:   util.NewExecutor(""),
 	})
+	return replaced
 }
 
 func TestReplacePlaceholder(t *testing.T) {

src/tmux.go

@@ -0,0 +1,57 @@
+package fzf
+
+import (
+	"os"
+	"os/exec"
+
+	"github.com/junegunn/fzf/src/tui"
+)
+
+func runTmux(args []string, opts *Options) (int, error) {
+	// Prepare arguments
+	fzf := args[0]
+	args = append([]string{"--bind=ctrl-z:ignore"}, args[1:]...)
+	if opts.BorderShape == tui.BorderUndefined {
+		args = append(args, "--border")
+	}
+	argStr := escapeSingleQuote(fzf)
+	for _, arg := range args {
+		argStr += " " + escapeSingleQuote(arg)
+	}
+	argStr += ` --no-tmux --no-height`
+
+	// Get current directory
+	dir, err := os.Getwd()
+	if err != nil {
+		dir = "."
+	}
+
+	// Set tmux options for popup placement
+	// C        Both    The centre of the terminal
+	// R        -x      The right side of the terminal
+	// P        Both    The bottom left of the pane
+	// M        Both    The mouse position
+	// W        Both    The window position on the status line
+	// S        -y      The line above or below the status line
+	tmuxArgs := []string{"display-popup", "-E", "-B", "-d", dir}
+	switch opts.Tmux.position {
+	case posUp:
+		tmuxArgs = append(tmuxArgs, "-xC", "-y0")
+	case posDown:
+		tmuxArgs = append(tmuxArgs, "-xC", "-yS")
+	case posLeft:
+		tmuxArgs = append(tmuxArgs, "-x0", "-yC")
+	case posRight:
+		tmuxArgs = append(tmuxArgs, "-xR", "-yC")
+	case posCenter:
+		tmuxArgs = append(tmuxArgs, "-xC", "-yC")
+	}
+	tmuxArgs = append(tmuxArgs, "-w"+opts.Tmux.width.String())
+	tmuxArgs = append(tmuxArgs, "-h"+opts.Tmux.height.String())
+
+	return runProxy(argStr, func(temp string) *exec.Cmd {
+		sh, _ := sh()
+		tmuxArgs = append(tmuxArgs, sh, temp)
+		return exec.Command("tmux", tmuxArgs...)
+	}, opts, true)
+}

src/tokenizer.go

@@ -91,7 +91,7 @@ func withPrefixLengths(tokens []string, begin int) []Token {
 
 	prefixLength := begin
 	for idx := range tokens {
-		chars := util.ToChars(sbytes(tokens[idx]))
+		chars := util.ToChars(stringBytes(tokens[idx]))
 		ret[idx] = Token{&chars, int32(prefixLength)}
 		prefixLength += chars.Length()
 	}
@@ -187,7 +187,7 @@ func Transform(tokens []Token, withNth []Range) []Token {
 		if r.begin == r.end {
 			idx := r.begin
 			if idx == rangeEllipsis {
-				chars := util.ToChars(sbytes(joinTokens(tokens)))
+				chars := util.ToChars(stringBytes(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,5 +108,6 @@ func TestTransform(t *testing.T) {
 }
 
 func TestTransformIndexOutOfBounds(t *testing.T) {
-	Transform([]Token{}, splitNth("1"))
+	s, _ := splitNth("1")
+	Transform([]Token{}, s)
 }

src/tui/dummy.go

@@ -8,7 +8,7 @@ func HasFullscreenRenderer() bool {
 	return false
 }
 
-var DefaultBorderShape BorderShape = BorderRounded
+var DefaultBorderShape = BorderRounded
 
 func (a Attr) Merge(b Attr) Attr {
 	return a | b
@@ -29,7 +29,7 @@ const (
 	StrikeThrough = Attr(1 << 7)
 )
 
-func (r *FullscreenRenderer) Init()                              {}
+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)                  {}

src/tui/eventtype_string.go

@@ -83,34 +83,36 @@ func _() {
 	_ = x[Alt-72]
 	_ = x[CtrlAlt-73]
 	_ = x[Invalid-74]
-	_ = x[Mouse-75]
-	_ = x[DoubleClick-76]
-	_ = x[LeftClick-77]
-	_ = x[RightClick-78]
-	_ = x[SLeftClick-79]
-	_ = x[SRightClick-80]
-	_ = x[ScrollUp-81]
-	_ = x[ScrollDown-82]
-	_ = x[SScrollUp-83]
-	_ = x[SScrollDown-84]
-	_ = x[PreviewScrollUp-85]
-	_ = x[PreviewScrollDown-86]
-	_ = x[Resize-87]
-	_ = x[Change-88]
-	_ = x[BackwardEOF-89]
-	_ = x[Start-90]
-	_ = x[Load-91]
-	_ = x[Focus-92]
-	_ = x[One-93]
-	_ = x[Zero-94]
-	_ = x[Result-95]
-	_ = x[Jump-96]
-	_ = x[JumpCancel-97]
+	_ = x[Fatal-75]
+	_ = x[Mouse-76]
+	_ = x[DoubleClick-77]
+	_ = x[LeftClick-78]
+	_ = x[RightClick-79]
+	_ = x[SLeftClick-80]
+	_ = x[SRightClick-81]
+	_ = x[ScrollUp-82]
+	_ = x[ScrollDown-83]
+	_ = x[SScrollUp-84]
+	_ = x[SScrollDown-85]
+	_ = x[PreviewScrollUp-86]
+	_ = x[PreviewScrollDown-87]
+	_ = x[Resize-88]
+	_ = x[Change-89]
+	_ = x[BackwardEOF-90]
+	_ = x[Start-91]
+	_ = x[Load-92]
+	_ = x[Focus-93]
+	_ = x[One-94]
+	_ = x[Zero-95]
+	_ = x[Result-96]
+	_ = x[Jump-97]
+	_ = x[JumpCancel-98]
+	_ = x[ClickHeader-99]
 }
 
-const _EventType_name = "RuneCtrlACtrlBCtrlCCtrlDCtrlECtrlFCtrlGCtrlHTabCtrlJCtrlKCtrlLCtrlMCtrlNCtrlOCtrlPCtrlQCtrlRCtrlSCtrlTCtrlUCtrlVCtrlWCtrlXCtrlYCtrlZEscCtrlSpaceCtrlDeleteCtrlBackSlashCtrlRightBracketCtrlCaretCtrlSlashShiftTabBackspaceDeletePageUpPageDownUpDownLeftRightHomeEndInsertShiftUpShiftDownShiftLeftShiftRightShiftDeleteF1F2F3F4F5F6F7F8F9F10F11F12AltBackspaceAltUpAltDownAltLeftAltRightAltShiftUpAltShiftDownAltShiftLeftAltShiftRightAltCtrlAltInvalidMouseDoubleClickLeftClickRightClickSLeftClickSRightClickScrollUpScrollDownSScrollUpSScrollDownPreviewScrollUpPreviewScrollDownResizeChangeBackwardEOFStartLoadFocusOneZeroResultJumpJumpCancel"
+const _EventType_name = "RuneCtrlACtrlBCtrlCCtrlDCtrlECtrlFCtrlGCtrlHTabCtrlJCtrlKCtrlLCtrlMCtrlNCtrlOCtrlPCtrlQCtrlRCtrlSCtrlTCtrlUCtrlVCtrlWCtrlXCtrlYCtrlZEscCtrlSpaceCtrlDeleteCtrlBackSlashCtrlRightBracketCtrlCaretCtrlSlashShiftTabBackspaceDeletePageUpPageDownUpDownLeftRightHomeEndInsertShiftUpShiftDownShiftLeftShiftRightShiftDeleteF1F2F3F4F5F6F7F8F9F10F11F12AltBackspaceAltUpAltDownAltLeftAltRightAltShiftUpAltShiftDownAltShiftLeftAltShiftRightAltCtrlAltInvalidFatalMouseDoubleClickLeftClickRightClickSLeftClickSRightClickScrollUpScrollDownSScrollUpSScrollDownPreviewScrollUpPreviewScrollDownResizeChangeBackwardEOFStartLoadFocusOneZeroResultJumpJumpCancelClickHeader"
 
-var _EventType_index = [...]uint16{0, 4, 9, 14, 19, 24, 29, 34, 39, 44, 47, 52, 57, 62, 67, 72, 77, 82, 87, 92, 97, 102, 107, 112, 117, 122, 127, 132, 135, 144, 154, 167, 183, 192, 201, 209, 218, 224, 230, 238, 240, 244, 248, 253, 257, 260, 266, 273, 282, 291, 301, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 333, 336, 339, 351, 356, 363, 370, 378, 388, 400, 412, 425, 428, 435, 442, 447, 458, 467, 477, 487, 498, 506, 516, 525, 536, 551, 568, 574, 580, 591, 596, 600, 605, 608, 612, 618, 622, 632}
+var _EventType_index = [...]uint16{0, 4, 9, 14, 19, 24, 29, 34, 39, 44, 47, 52, 57, 62, 67, 72, 77, 82, 87, 92, 97, 102, 107, 112, 117, 122, 127, 132, 135, 144, 154, 167, 183, 192, 201, 209, 218, 224, 230, 238, 240, 244, 248, 253, 257, 260, 266, 273, 282, 291, 301, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 333, 336, 339, 351, 356, 363, 370, 378, 388, 400, 412, 425, 428, 435, 442, 447, 452, 463, 472, 482, 492, 503, 511, 521, 530, 541, 556, 573, 579, 585, 596, 601, 605, 610, 613, 617, 623, 627, 637, 648}
 
 func (i EventType) String() string {
 	if i < 0 || i >= EventType(len(_EventType_index)-1) {

src/tui/light.go

@@ -2,6 +2,7 @@ package tui
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"os"
 	"regexp"
@@ -10,6 +11,7 @@ import (
 	"time"
 	"unicode/utf8"
 
+	"github.com/junegunn/fzf/src/util"
 	"github.com/rivo/uniseg"
 
 	"golang.org/x/term"
@@ -27,8 +29,8 @@ const (
 
 const consoleDevice string = "/dev/tty"
 
-var offsetRegexp *regexp.Regexp = regexp.MustCompile("(.*)\x1b\\[([0-9]+);([0-9]+)R")
-var offsetRegexpBegin *regexp.Regexp = regexp.MustCompile("^\x1b\\[[0-9]+;[0-9]+R")
+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")
@@ -71,13 +73,14 @@ func (r *LightRenderer) csi(code string) string {
 
 func (r *LightRenderer) flush() {
 	if r.queued.Len() > 0 {
-		fmt.Fprint(os.Stderr, "\x1b[?7l\x1b[?25l"+r.queued.String()+"\x1b[?25h\x1b[?7h")
+		fmt.Fprint(r.ttyout, "\x1b[?7l\x1b[?25l"+r.queued.String()+"\x1b[?25h\x1b[?7h")
 		r.queued.Reset()
 	}
 }
 
 // Light renderer
 type LightRenderer struct {
+	closed        *util.AtomicBool
 	theme         *ColorTheme
 	mouse         bool
 	forceBlack    bool
@@ -85,6 +88,7 @@ type LightRenderer struct {
 	prevDownTime  time.Time
 	clicks        [][2]int
 	ttyin         *os.File
+	ttyout        *os.File
 	buffer        []byte
 	origState     *term.State
 	width         int
@@ -123,19 +127,25 @@ type LightWindow struct {
 	bg       Color
 }
 
-func NewLightRenderer(theme *ColorTheme, forceBlack bool, mouse bool, tabstop int, clearOnExit bool, fullscreen bool, maxHeightFunc func(int) int) Renderer {
+func NewLightRenderer(ttyin *os.File, theme *ColorTheme, forceBlack bool, mouse bool, tabstop int, clearOnExit bool, fullscreen bool, maxHeightFunc func(int) int) (Renderer, error) {
+	out, err := openTtyOut()
+	if err != nil {
+		out = os.Stderr
+	}
 	r := LightRenderer{
+		closed:        util.NewAtomicBool(false),
 		theme:         theme,
 		forceBlack:    forceBlack,
 		mouse:         mouse,
 		clearOnExit:   clearOnExit,
-		ttyin:         openTtyIn(),
+		ttyin:         ttyin,
+		ttyout:        out,
 		yoffset:       0,
 		tabstop:       tabstop,
 		fullscreen:    fullscreen,
 		upOneLine:     false,
 		maxHeightFunc: maxHeightFunc}
-	return &r
+	return &r, nil
 }
 
 func repeat(r rune, times int) string {
@@ -153,11 +163,11 @@ func atoi(s string, defaultValue int) int {
 	return value
 }
 
-func (r *LightRenderer) Init() {
+func (r *LightRenderer) Init() error {
 	r.escDelay = atoi(os.Getenv("ESCDELAY"), defaultEscDelay)
 
 	if err := r.initPlatform(); err != nil {
-		errorExit(err.Error())
+		return err
 	}
 	r.updateTerminalSize()
 	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
@@ -195,6 +205,7 @@ func (r *LightRenderer) Init() {
 	if !r.fullscreen && r.mouse {
 		r.yoffset, _ = r.findOffset()
 	}
+	return nil
 }
 
 func (r *LightRenderer) Resize(maxHeightFunc func(int) int) {
@@ -233,15 +244,16 @@ func getEnv(name string, defaultValue int) int {
 	return atoi(env, defaultValue)
 }
 
-func (r *LightRenderer) getBytes() []byte {
-	return r.getBytesInternal(r.buffer, false)
+func (r *LightRenderer) getBytes() ([]byte, error) {
+	bytes, err := r.getBytesInternal(r.buffer, false)
+	return bytes, err
 }
 
-func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
+func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) ([]byte, error) {
 	c, ok := r.getch(nonblock)
 	if !nonblock && !ok {
 		r.Close()
-		errorExit("Failed to read " + consoleDevice)
+		return nil, errors.New("failed to read " + consoleDevice)
 	}
 
 	retries := 0
@@ -272,19 +284,23 @@ func (r *LightRenderer) getBytesInternal(buffer []byte, nonblock bool) []byte {
 		// so terminate fzf immediately.
 		if len(buffer) > maxInputBuffer {
 			r.Close()
-			panic(fmt.Sprintf("Input buffer overflow (%d): %v", len(buffer), buffer))
+			return nil, fmt.Errorf("input buffer overflow (%d): %v", len(buffer), buffer)
 		}
 	}
 
-	return buffer
+	return buffer, nil
 }
 
 func (r *LightRenderer) GetChar() Event {
+	var err error
 	if len(r.buffer) == 0 {
-		r.buffer = r.getBytes()
+		r.buffer, err = r.getBytes()
+		if err != nil {
+			return Event{Fatal, 0, nil}
+		}
 	}
 	if len(r.buffer) == 0 {
-		panic("Empty buffer")
+		return Event{Fatal, 0, nil}
 	}
 
 	sz := 1
@@ -315,7 +331,9 @@ func (r *LightRenderer) GetChar() Event {
 		ev := r.escSequence(&sz)
 		// Second chance
 		if ev.Type == Invalid {
-			r.buffer = r.getBytes()
+			if r.buffer, err = r.getBytes(); err != nil {
+				return Event{Fatal, 0, nil}
+			}
 			ev = r.escSequence(&sz)
 		}
 		return ev
@@ -738,6 +756,7 @@ func (r *LightRenderer) Close() {
 	r.flush()
 	r.closePlatform()
 	r.restoreTerminal()
+	r.closed.Set(true)
 }
 
 func (r *LightRenderer) Top() int {
@@ -775,6 +794,9 @@ 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
 	}
+	if !w.bg.IsDefault() && w.border.shape != BorderNone {
+		w.Erase()
+	}
 	w.drawBorder(false)
 	return w
 }
@@ -821,44 +843,32 @@ func (w *LightWindow) drawBorderHorizontal(top, bottom bool) {
 		color = ColPreviewBorder
 	}
 	hw := runeWidth(w.border.top)
-	pad := repeat(' ', w.width/hw)
-
-	w.Move(0, 0)
 	if top {
+		w.Move(0, 0)
 		w.CPrint(color, repeat(w.border.top, w.width/hw))
-	} else {
-		w.CPrint(color, pad)
 	}
 
-	for y := 1; y < w.height-1; y++ {
-		w.Move(y, 0)
-		w.CPrint(color, pad)
-	}
-
-	w.Move(w.height-1, 0)
 	if bottom {
+		w.Move(w.height-1, 0)
 		w.CPrint(color, repeat(w.border.bottom, w.width/hw))
-	} else {
-		w.CPrint(color, pad)
 	}
 }
 
 func (w *LightWindow) drawBorderVertical(left, right bool) {
-	width := w.width - 2
-	if !left || !right {
-		width++
-	}
+	vw := runeWidth(w.border.left)
 	color := ColBorder
 	if w.preview {
 		color = ColPreviewBorder
 	}
 	for y := 0; y < w.height; y++ {
-		w.Move(y, 0)
 		if left {
+			w.Move(y, 0)
 			w.CPrint(color, string(w.border.left))
+			w.CPrint(color, " ") // Margin
 		}
-		w.CPrint(color, repeat(' ', width))
 		if right {
+			w.Move(y, w.width-vw-1)
+			w.CPrint(color, " ") // Margin
 			w.CPrint(color, string(w.border.right))
 		}
 	}
@@ -880,7 +890,10 @@ func (w *LightWindow) drawBorderAround(onlyHorizontal bool) {
 		for y := 1; y < w.height-1; y++ {
 			w.Move(y, 0)
 			w.CPrint(color, string(w.border.left))
-			w.CPrint(color, repeat(' ', w.width-vw*2))
+			w.CPrint(color, " ") // Margin
+
+			w.Move(y, w.width-vw-1)
+			w.CPrint(color, " ") // Margin
 			w.CPrint(color, string(w.border.right))
 		}
 	}
@@ -1011,7 +1024,7 @@ func (w *LightWindow) Print(text string) {
 }
 
 func cleanse(str string) string {
-	return strings.Replace(str, "\x1b", "", -1)
+	return strings.ReplaceAll(str, "\x1b", "")
 }
 
 func (w *LightWindow) CPrint(pair ColorPair, text string) {

src/tui/light_unix.go

@@ -3,7 +3,7 @@
 package tui
 
 import (
-	"fmt"
+	"errors"
 	"os"
 	"os/exec"
 	"strings"
@@ -33,34 +33,35 @@ func (r *LightRenderer) fd() int {
 	return int(r.ttyin.Fd())
 }
 
-func (r *LightRenderer) initPlatform() error {
-	fd := r.fd()
-	origState, err := term.GetState(fd)
-	if err != nil {
-		return err
-	}
-	r.origState = origState
-	term.MakeRaw(fd)
-	return nil
+func (r *LightRenderer) initPlatform() (err error) {
+	r.origState, err = term.MakeRaw(r.fd())
+	return err
 }
 
 func (r *LightRenderer) closePlatform() {
-	// NOOP
+	r.ttyout.Close()
 }
 
-func openTtyIn() *os.File {
-	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
+func openTty(mode int) (*os.File, error) {
+	in, err := os.OpenFile(consoleDevice, mode, 0)
 	if err != nil {
 		tty := ttyname()
 		if len(tty) > 0 {
-			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
-				return in
+			if in, err := os.OpenFile(tty, mode, 0); err == nil {
+				return in, nil
 			}
 		}
-		fmt.Fprintln(os.Stderr, "Failed to open "+consoleDevice)
-		util.Exit(2)
+		return nil, errors.New("failed to open " + consoleDevice)
 	}
-	return in
+	return in, nil
+}
+
+func openTtyIn() (*os.File, error) {
+	return openTty(syscall.O_RDONLY)
+}
+
+func openTtyOut() (*os.File, error) {
+	return openTty(syscall.O_WRONLY)
 }
 
 func (r *LightRenderer) setupTerminal() {
@@ -86,9 +87,14 @@ 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 = r.getBytesInternal(bytes, tries > 0)
+		bytes, err = r.getBytesInternal(bytes, tries > 0)
+		if err != nil {
+			return -1, -1
+		}
+
 		offsets := offsetRegexp.FindSubmatch(bytes)
 		if len(offsets) > 3 {
 			// Add anything we skipped over to the input buffer

src/tui/light_windows.go

@@ -72,7 +72,7 @@ func (r *LightRenderer) initPlatform() error {
 	go func() {
 		fd := int(r.inHandle)
 		b := make([]byte, 1)
-		for {
+		for !r.closed.Get() {
 			// HACK: if run from PSReadline, something resets ConsoleMode to remove ENABLE_VIRTUAL_TERMINAL_INPUT.
 			_ = windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
 
@@ -91,9 +91,13 @@ func (r *LightRenderer) closePlatform() {
 	windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput)
 }
 
-func openTtyIn() *os.File {
+func openTtyIn() (*os.File, error) {
 	// not used
-	return nil
+	return nil, nil
+}
+
+func openTtyOut() (*os.File, error) {
+	return os.Stderr, nil
 }
 
 func (r *LightRenderer) setupTerminal() error {
@@ -135,7 +139,7 @@ func (r *LightRenderer) findOffset() (row int, col int) {
 	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
 		return -1, -1
 	}
-	return int(bufferInfo.CursorPosition.X), int(bufferInfo.CursorPosition.Y)
+	return int(bufferInfo.CursorPosition.Y), int(bufferInfo.CursorPosition.X)
 }
 
 func (r *LightRenderer) getch(nonblock bool) (int, bool) {

src/tui/tcell.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/gdamore/tcell/v2"
-	"github.com/gdamore/tcell/v2/encoding"
 	"github.com/junegunn/fzf/src/util"
 
 	"github.com/rivo/uniseg"
@@ -146,13 +145,13 @@ var (
 	_initialResize   bool = true
 )
 
-func (r *FullscreenRenderer) initScreen() {
+func (r *FullscreenRenderer) initScreen() error {
 	s, e := tcell.NewScreen()
 	if e != nil {
-		errorExit(e.Error())
+		return e
 	}
 	if e = s.Init(); e != nil {
-		errorExit(e.Error())
+		return e
 	}
 	if r.mouse {
 		s.EnableMouse()
@@ -160,16 +159,21 @@ func (r *FullscreenRenderer) initScreen() {
 		s.DisableMouse()
 	}
 	_screen = s
+
+	return nil
 }
 
-func (r *FullscreenRenderer) Init() {
+func (r *FullscreenRenderer) Init() error {
 	if os.Getenv("TERM") == "cygwin" {
 		os.Setenv("TERM", "")
 	}
-	encoding.Register()
 
-	r.initScreen()
+	if err := r.initScreen(); err != nil {
+		return err
+	}
 	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
+
+	return nil
 }
 
 func (r *FullscreenRenderer) Top() int {
@@ -561,7 +565,11 @@ func fill(x, y, w, h int, n ColorPair, r rune) {
 }
 
 func (w *TcellWindow) Erase() {
-	fill(w.left-1, w.top, w.width+1, w.height-1, w.normal, ' ')
+	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)
 }
 

src/tui/tcell_test.go

@@ -3,6 +3,7 @@
 package tui
 
 import (
+	"os"
 	"testing"
 
 	"github.com/gdamore/tcell/v2"
@@ -20,7 +21,7 @@ func assert(t *testing.T, context string, got interface{}, want interface{}) boo
 
 // Test the handling of the tcell keyboard events.
 func TestGetCharEventKey(t *testing.T) {
-	if util.ToTty() {
+	if util.IsTty(os.Stdout) {
 		// This test is skipped when output goes to terminal, because it causes
 		// some glitches:
 		// - output lines may not start at the beginning of a row which makes

src/tui/ttyname_unix.go

@@ -4,12 +4,19 @@ package tui
 
 import (
 	"os"
+	"sync/atomic"
 	"syscall"
 )
 
 var devPrefixes = [...]string{"/dev/pts/", "/dev/"}
 
+var tty atomic.Value
+
 func ttyname() string {
+	if cached := tty.Load(); cached != nil {
+		return cached.(string)
+	}
+
 	var stderr syscall.Stat_t
 	if syscall.Fstat(2, &stderr) != nil {
 		return ""
@@ -27,24 +34,21 @@ func ttyname() string {
 				continue
 			}
 			if stat, ok := info.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
-				return prefix + file.Name()
+				value := prefix + file.Name()
+				tty.Store(value)
+				return value
 			}
 		}
 	}
 	return ""
 }
 
-// TtyIn returns terminal device to be used as STDIN, falls back to os.Stdin
-func TtyIn() *os.File {
-	in, err := os.OpenFile(consoleDevice, syscall.O_RDONLY, 0)
-	if err != nil {
-		tty := ttyname()
-		if len(tty) > 0 {
-			if in, err := os.OpenFile(tty, syscall.O_RDONLY, 0); err == nil {
-				return in
-			}
-		}
-		return os.Stdin
-	}
-	return in
+// TtyIn returns terminal device to read user input
+func TtyIn() (*os.File, error) {
+	return openTtyIn()
+}
+
+// TtyIn returns terminal device to write to
+func TtyOut() (*os.File, error) {
+	return openTtyOut()
 }

src/tui/ttyname_windows.go

@@ -2,13 +2,20 @@
 
 package tui
 
-import "os"
+import (
+	"os"
+)
 
 func ttyname() string {
 	return ""
 }
 
 // TtyIn on Windows returns os.Stdin
-func TtyIn() *os.File {
-	return os.Stdin
+func TtyIn() (*os.File, error) {
+	return os.Stdin, nil
+}
+
+// TtyIn on Windows returns nil
+func TtyOut() (*os.File, error) {
+	return nil, nil
 }

src/tui/tui.go

@@ -1,8 +1,6 @@
 package tui
 
 import (
-	"fmt"
-	"os"
 	"strconv"
 	"time"
 
@@ -104,6 +102,7 @@ const (
 	CtrlAlt
 
 	Invalid
+	Fatal
 
 	Mouse
 	DoubleClick
@@ -130,6 +129,7 @@ const (
 	Result
 	Jump
 	JumpCancel
+	ClickHeader
 )
 
 func (t EventType) AsEvent() Event {
@@ -303,6 +303,9 @@ type ColorTheme struct {
 	Disabled         ColorAttr
 	Fg               ColorAttr
 	Bg               ColorAttr
+	SelectedFg       ColorAttr
+	SelectedBg       ColorAttr
+	SelectedMatch    ColorAttr
 	PreviewFg        ColorAttr
 	PreviewBg        ColorAttr
 	DarkBg           ColorAttr
@@ -314,7 +317,7 @@ type ColorTheme struct {
 	Spinner          ColorAttr
 	Info             ColorAttr
 	Cursor           ColorAttr
-	Selected         ColorAttr
+	Marker           ColorAttr
 	Header           ColorAttr
 	Separator        ColorAttr
 	Scrollbar        ColorAttr
@@ -331,15 +334,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
@@ -353,7 +347,8 @@ type MouseEvent struct {
 type BorderShape int
 
 const (
-	BorderNone BorderShape = iota
+	BorderUndefined BorderShape = iota
+	BorderNone
 	BorderRounded
 	BorderSharp
 	BorderBold
@@ -368,6 +363,14 @@ 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
@@ -516,7 +519,7 @@ type TermSize struct {
 }
 
 type Renderer interface {
-	Init()
+	Init() error
 	Resize(maxHeightFunc func(int) int)
 	Pause(clear bool)
 	Resume(clear bool, sigcont bool)
@@ -595,12 +598,14 @@ var (
 	ColMatch                ColorPair
 	ColCursor               ColorPair
 	ColCursorEmpty          ColorPair
+	ColMarker               ColorPair
 	ColSelected             ColorPair
+	ColSelectedMatch        ColorPair
 	ColCurrent              ColorPair
 	ColCurrentMatch         ColorPair
 	ColCurrentCursor        ColorPair
 	ColCurrentCursorEmpty   ColorPair
-	ColCurrentSelected      ColorPair
+	ColCurrentMarker        ColorPair
 	ColCurrentSelectedEmpty ColorPair
 	ColSpinner              ColorPair
 	ColInfo                 ColorPair
@@ -622,6 +627,9 @@ func EmptyTheme() *ColorTheme {
 		Input:            ColorAttr{colUndefined, AttrUndefined},
 		Fg:               ColorAttr{colUndefined, AttrUndefined},
 		Bg:               ColorAttr{colUndefined, AttrUndefined},
+		SelectedFg:       ColorAttr{colUndefined, AttrUndefined},
+		SelectedBg:       ColorAttr{colUndefined, AttrUndefined},
+		SelectedMatch:    ColorAttr{colUndefined, AttrUndefined},
 		DarkBg:           ColorAttr{colUndefined, AttrUndefined},
 		Prompt:           ColorAttr{colUndefined, AttrUndefined},
 		Match:            ColorAttr{colUndefined, AttrUndefined},
@@ -630,7 +638,7 @@ func EmptyTheme() *ColorTheme {
 		Spinner:          ColorAttr{colUndefined, AttrUndefined},
 		Info:             ColorAttr{colUndefined, AttrUndefined},
 		Cursor:           ColorAttr{colUndefined, AttrUndefined},
-		Selected:         ColorAttr{colUndefined, AttrUndefined},
+		Marker:           ColorAttr{colUndefined, AttrUndefined},
 		Header:           ColorAttr{colUndefined, AttrUndefined},
 		Border:           ColorAttr{colUndefined, AttrUndefined},
 		BorderLabel:      ColorAttr{colUndefined, AttrUndefined},
@@ -652,6 +660,9 @@ func NoColorTheme() *ColorTheme {
 		Input:            ColorAttr{colDefault, AttrUndefined},
 		Fg:               ColorAttr{colDefault, AttrUndefined},
 		Bg:               ColorAttr{colDefault, AttrUndefined},
+		SelectedFg:       ColorAttr{colDefault, AttrUndefined},
+		SelectedBg:       ColorAttr{colDefault, AttrUndefined},
+		SelectedMatch:    ColorAttr{colDefault, AttrUndefined},
 		DarkBg:           ColorAttr{colDefault, AttrUndefined},
 		Prompt:           ColorAttr{colDefault, AttrUndefined},
 		Match:            ColorAttr{colDefault, Underline},
@@ -660,7 +671,7 @@ func NoColorTheme() *ColorTheme {
 		Spinner:          ColorAttr{colDefault, AttrUndefined},
 		Info:             ColorAttr{colDefault, AttrUndefined},
 		Cursor:           ColorAttr{colDefault, AttrUndefined},
-		Selected:         ColorAttr{colDefault, AttrUndefined},
+		Marker:           ColorAttr{colDefault, AttrUndefined},
 		Header:           ColorAttr{colDefault, AttrUndefined},
 		Border:           ColorAttr{colDefault, AttrUndefined},
 		BorderLabel:      ColorAttr{colDefault, AttrUndefined},
@@ -676,17 +687,15 @@ func NoColorTheme() *ColorTheme {
 	}
 }
 
-func errorExit(message string) {
-	fmt.Fprintln(os.Stderr, message)
-	util.Exit(2)
-}
-
 func init() {
 	Default16 = &ColorTheme{
 		Colored:          true,
 		Input:            ColorAttr{colDefault, AttrUndefined},
 		Fg:               ColorAttr{colDefault, AttrUndefined},
 		Bg:               ColorAttr{colDefault, AttrUndefined},
+		SelectedFg:       ColorAttr{colUndefined, AttrUndefined},
+		SelectedBg:       ColorAttr{colUndefined, AttrUndefined},
+		SelectedMatch:    ColorAttr{colUndefined, AttrUndefined},
 		DarkBg:           ColorAttr{colBlack, AttrUndefined},
 		Prompt:           ColorAttr{colBlue, AttrUndefined},
 		Match:            ColorAttr{colGreen, AttrUndefined},
@@ -695,7 +704,7 @@ func init() {
 		Spinner:          ColorAttr{colGreen, AttrUndefined},
 		Info:             ColorAttr{colWhite, AttrUndefined},
 		Cursor:           ColorAttr{colRed, AttrUndefined},
-		Selected:         ColorAttr{colMagenta, AttrUndefined},
+		Marker:           ColorAttr{colMagenta, AttrUndefined},
 		Header:           ColorAttr{colCyan, AttrUndefined},
 		Border:           ColorAttr{colBlack, AttrUndefined},
 		BorderLabel:      ColorAttr{colWhite, AttrUndefined},
@@ -714,6 +723,9 @@ func init() {
 		Input:            ColorAttr{colDefault, AttrUndefined},
 		Fg:               ColorAttr{colDefault, AttrUndefined},
 		Bg:               ColorAttr{colDefault, AttrUndefined},
+		SelectedFg:       ColorAttr{colUndefined, AttrUndefined},
+		SelectedBg:       ColorAttr{colUndefined, AttrUndefined},
+		SelectedMatch:    ColorAttr{colUndefined, AttrUndefined},
 		DarkBg:           ColorAttr{236, AttrUndefined},
 		Prompt:           ColorAttr{110, AttrUndefined},
 		Match:            ColorAttr{108, AttrUndefined},
@@ -722,7 +734,7 @@ func init() {
 		Spinner:          ColorAttr{148, AttrUndefined},
 		Info:             ColorAttr{144, AttrUndefined},
 		Cursor:           ColorAttr{161, AttrUndefined},
-		Selected:         ColorAttr{168, AttrUndefined},
+		Marker:           ColorAttr{168, AttrUndefined},
 		Header:           ColorAttr{109, AttrUndefined},
 		Border:           ColorAttr{59, AttrUndefined},
 		BorderLabel:      ColorAttr{145, AttrUndefined},
@@ -741,6 +753,9 @@ func init() {
 		Input:            ColorAttr{colDefault, AttrUndefined},
 		Fg:               ColorAttr{colDefault, AttrUndefined},
 		Bg:               ColorAttr{colDefault, AttrUndefined},
+		SelectedFg:       ColorAttr{colUndefined, AttrUndefined},
+		SelectedBg:       ColorAttr{colUndefined, AttrUndefined},
+		SelectedMatch:    ColorAttr{colUndefined, AttrUndefined},
 		DarkBg:           ColorAttr{251, AttrUndefined},
 		Prompt:           ColorAttr{25, AttrUndefined},
 		Match:            ColorAttr{66, AttrUndefined},
@@ -749,7 +764,7 @@ func init() {
 		Spinner:          ColorAttr{65, AttrUndefined},
 		Info:             ColorAttr{101, AttrUndefined},
 		Cursor:           ColorAttr{161, AttrUndefined},
-		Selected:         ColorAttr{168, AttrUndefined},
+		Marker:           ColorAttr{168, AttrUndefined},
 		Header:           ColorAttr{31, AttrUndefined},
 		Border:           ColorAttr{145, AttrUndefined},
 		BorderLabel:      ColorAttr{59, AttrUndefined},
@@ -791,12 +806,15 @@ 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.Selected = o(baseTheme.Selected, theme.Selected)
+	theme.Marker = o(baseTheme.Marker, theme.Marker)
 	theme.Header = o(baseTheme.Header, theme.Header)
 	theme.Border = o(baseTheme.Border, theme.Border)
 	theme.BorderLabel = o(baseTheme.BorderLabel, theme.BorderLabel)
 
 	// These colors are not defined in the base themes
+	theme.SelectedFg = o(theme.Fg, theme.SelectedFg)
+	theme.SelectedBg = o(theme.Bg, theme.SelectedBg)
+	theme.SelectedMatch = o(theme.Match, theme.SelectedMatch)
 	theme.Disabled = o(theme.Input, theme.Disabled)
 	theme.Gutter = o(theme.DarkBg, theme.Gutter)
 	theme.PreviewFg = o(theme.Fg, theme.PreviewFg)
@@ -822,17 +840,23 @@ 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)
-	ColSelected = pair(theme.Selected, theme.Gutter)
+	if theme.SelectedBg.Color != theme.Bg.Color {
+		ColMarker = pair(theme.Marker, theme.SelectedBg)
+	} else {
+		ColMarker = pair(theme.Marker, 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)
-	ColCurrentSelected = pair(theme.Selected, theme.DarkBg)
+	ColCurrentMarker = pair(theme.Marker, theme.DarkBg)
 	ColCurrentSelectedEmpty = pair(blank, theme.DarkBg)
 	ColSpinner = pair(theme.Spinner, theme.Bg)
 	ColInfo = pair(theme.Info, theme.Bg)

src/util/atexit.go

@@ -1,7 +1,6 @@
 package util
 
 import (
-	"os"
 	"sync"
 )
 
@@ -25,14 +24,5 @@ func RunAtExitFuncs() {
 	for i := len(fns) - 1; i >= 0; i-- {
 		fns[i]()
 	}
-}
-
-// Exit executes any functions registered with AtExit() then exits the program
-// with os.Exit(code).
-//
-// NOTE: It must be used instead of os.Exit() since calling os.Exit() terminates
-// the program before any of the AtExit functions can run.
-func Exit(code int) {
-	defer os.Exit(code)
-	RunAtExitFuncs()
+	atExitFuncs = nil
 }

src/util/chars.go

@@ -1,6 +1,7 @@
 package util
 
 import (
+	"bytes"
 	"fmt"
 	"unicode"
 	"unicode/utf8"
@@ -74,6 +75,35 @@ func (chars *Chars) Bytes() []byte {
 	return chars.slice
 }
 
+func (chars *Chars) NumLines(atMost int) (int, bool) {
+	lines := 1
+	if runes := chars.optionalRunes(); runes != nil {
+		for _, r := range runes {
+			if r == '\n' {
+				lines++
+			}
+			if lines > atMost {
+				return atMost, true
+			}
+		}
+		return lines, false
+	}
+
+	for idx := 0; idx < len(chars.slice); idx++ {
+		found := bytes.IndexByte(chars.slice[idx:], '\n')
+		if found < 0 {
+			break
+		}
+
+		idx += found
+		lines++
+		if lines > atMost {
+			return atMost, true
+		}
+	}
+	return lines, false
+}
+
 func (chars *Chars) optionalRunes() []rune {
 	if chars.inBytes {
 		return nil
@@ -196,3 +226,85 @@ func (chars *Chars) Prepend(prefix string) {
 		chars.slice = append([]byte(prefix), chars.slice...)
 	}
 }
+
+func (chars *Chars) Lines(multiLine bool, maxLines int, wrapCols int, wrapSignWidth int, tabstop int) ([][]rune, bool) {
+	text := make([]rune, chars.Length())
+	copy(text, chars.ToRunes())
+
+	lines := [][]rune{}
+	overflow := false
+	if !multiLine {
+		lines = append(lines, text)
+	} else {
+		from := 0
+		for off := 0; off < len(text); off++ {
+			if text[off] == '\n' {
+				lines = append(lines, text[from:off+1]) // Include '\n'
+				from = off + 1
+				if len(lines) >= maxLines {
+					break
+				}
+			}
+		}
+
+		var lastLine []rune
+		if from < len(text) {
+			lastLine = text[from:]
+		}
+
+		overflow = false
+		if len(lines) >= maxLines {
+			overflow = true
+		} else {
+			lines = append(lines, lastLine)
+		}
+	}
+
+	// If wrapping is disabled, we're done
+	if wrapCols == 0 {
+		return lines, overflow
+	}
+
+	wrapped := [][]rune{}
+	for _, line := range lines {
+		// Remove trailing '\n' and remember if it was there
+		newline := len(line) > 0 && line[len(line)-1] == '\n'
+		if newline {
+			line = line[:len(line)-1]
+		}
+
+		for {
+			cols := wrapCols
+			if len(wrapped) > 0 {
+				cols -= wrapSignWidth
+			}
+			_, overflowIdx := RunesWidth(line, 0, tabstop, cols)
+			if overflowIdx >= 0 {
+				// Might be a wide character
+				if overflowIdx == 0 {
+					overflowIdx = 1
+				}
+				if len(wrapped) >= maxLines {
+					return wrapped, true
+				}
+				wrapped = append(wrapped, line[:overflowIdx])
+				line = line[overflowIdx:]
+				continue
+			}
+
+			// Restore trailing '\n'
+			if newline {
+				line = append(line, '\n')
+			}
+
+			if len(wrapped) >= maxLines {
+				return wrapped, true
+			}
+
+			wrapped = append(wrapped, line)
+			break
+		}
+	}
+
+	return wrapped, false
+}

src/util/chars_test.go

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

src/util/util.go

@@ -3,6 +3,7 @@ package util
 import (
 	"math"
 	"os"
+	"strconv"
 	"strings"
 	"time"
 
@@ -137,14 +138,20 @@ func DurWithin(
 	return val
 }
 
-// IsTty returns true if stdin is a terminal
-func IsTty() bool {
-	return isatty.IsTerminal(os.Stdin.Fd())
+// IsTty returns true if the file is a terminal
+func IsTty(file *os.File) bool {
+	fd := file.Fd()
+	return isatty.IsTerminal(fd) || isatty.IsCygwinTerminal(fd)
 }
 
-// ToTty returns true if stdout is a terminal
-func ToTty() bool {
-	return isatty.IsTerminal(os.Stdout.Fd())
+// RunOnce runs the given function only once
+func RunOnce(f func()) func() {
+	once := Once(true)
+	return func() {
+		if once() {
+			f()
+		}
+	}
 }
 
 // Once returns a function that returns the specified boolean value only once
@@ -152,7 +159,7 @@ func Once(nextResponse bool) func() bool {
 	state := nextResponse
 	return func() bool {
 		prevState := state
-		state = false
+		state = !nextResponse
 		return prevState
 	}
 }
@@ -188,3 +195,34 @@ func ToKebabCase(s string) string {
 	}
 	return strings.ToLower(name)
 }
+
+// CompareVersions compares two version strings
+func CompareVersions(v1, v2 string) int {
+	parts1 := strings.Split(v1, ".")
+	parts2 := strings.Split(v2, ".")
+
+	atoi := func(s string) int {
+		n, e := strconv.Atoi(s)
+		if e != nil {
+			return 0
+		}
+		return n
+	}
+
+	for i := 0; i < Max(len(parts1), len(parts2)); i++ {
+		var p1, p2 int
+		if i < len(parts1) {
+			p1 = atoi(parts1[i])
+		}
+		if i < len(parts2) {
+			p2 = atoi(parts2[i])
+		}
+
+		if p1 > p2 {
+			return 1
+		} else if p1 < p2 {
+			return -1
+		}
+	}
+	return 0
+}

src/util/util_test.go

@@ -137,8 +137,11 @@ func TestOnce(t *testing.T) {
 	if o() {
 		t.Error("Expected: false")
 	}
-	if o() {
-		t.Error("Expected: false")
+	if !o() {
+		t.Error("Expected: true")
+	}
+	if !o() {
+		t.Error("Expected: true")
 	}
 
 	o = Once(true)
@@ -148,6 +151,9 @@ func TestOnce(t *testing.T) {
 	if o() {
 		t.Error("Expected: false")
 	}
+	if o() {
+		t.Error("Expected: false")
+	}
 }
 
 func TestRunesWidth(t *testing.T) {
@@ -203,3 +209,34 @@ func TestStringWidth(t *testing.T) {
 		t.Errorf("Expected: %d, Actual: %d", 1, w)
 	}
 }
+
+func TestCompareVersions(t *testing.T) {
+	assert := func(a, b string, expected int) {
+		if result := CompareVersions(a, b); result != expected {
+			t.Errorf("Expected: %d, Actual: %d", expected, result)
+		}
+	}
+
+	assert("2", "1", 1)
+	assert("2", "2", 0)
+	assert("2", "10", -1)
+
+	assert("2.1", "2.2", -1)
+	assert("2.1", "2.1.1", -1)
+
+	assert("1.2.3", "1.2.2", 1)
+	assert("1.2.3", "1.2.3", 0)
+	assert("1.2.3", "1.2.3.0", 0)
+	assert("1.2.3", "1.2.4", -1)
+
+	// Different number of parts
+	assert("1.0.0", "1", 0)
+	assert("1.0.0", "1.0", 0)
+	assert("1.0.0", "1.0.0", 0)
+	assert("1.0", "1.0.0", 0)
+	assert("1", "1.0.0", 0)
+	assert("1.0.0", "1.0.0.1", -1)
+	assert("1.0.0.1.0", "1.0.0.1", 0)
+
+	assert("", "3.4.5", -1)
+}

src/util/util_unix.go

@@ -61,7 +61,7 @@ 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())
-		Exit(127)
+		os.Exit(127)
 	}
 	args := append([]string{shellPath}, append(x.args, command)...)
 	SetStdin(stdin)

src/util/util_windows.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"sync/atomic"
 	"syscall"
@@ -20,6 +21,8 @@ const (
 	shellTypePowerShell
 )
 
+var escapeRegex = regexp.MustCompile(`[&|<>()^%!"]`)
+
 type Executor struct {
 	shell     string
 	shellType shellType
@@ -42,7 +45,7 @@ func NewExecutor(withShell string) *Executor {
 		args = args[1:]
 	} else if strings.HasPrefix(basename, "cmd") {
 		shellType = shellTypeCmd
-		args = []string{"/v:on/s/c"}
+		args = []string{"/s/c"}
 	} else if strings.HasPrefix(basename, "pwsh") || strings.HasPrefix(basename, "powershell") {
 		shellType = shellTypePowerShell
 		args = []string{"-NoProfile", "-Command"}
@@ -97,15 +100,15 @@ func (x *Executor) Become(stdin *os.File, environ []string, command string) {
 	err := cmd.Start()
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "fzf (become): %s\n", err.Error())
-		Exit(127)
+		os.Exit(127)
 	}
 	err = cmd.Wait()
 	if err != nil {
 		if exitError, ok := err.(*exec.ExitError); ok {
-			Exit(exitError.ExitCode())
+			os.Exit(exitError.ExitCode())
 		}
 	}
-	Exit(0)
+	os.Exit(0)
 }
 
 func escapeArg(s string) string {
@@ -119,8 +122,6 @@ func escapeArg(s string) string {
 			slashes = 0
 		case '\\':
 			slashes++
-		case '&', '|', '<', '>', '(', ')', '@', '^', '%', '!':
-			b = append(b, '^')
 		case '"':
 			for ; slashes > 0; slashes-- {
 				b = append(b, '\\')
@@ -133,7 +134,9 @@ func escapeArg(s string) string {
 		b = append(b, '\\')
 	}
 	b = append(b, '"')
-	return string(b)
+	return escapeRegex.ReplaceAllStringFunc(string(b), func(match string) string {
+		return "^" + match
+	})
 }
 
 func (x *Executor) QuoteEntry(entry string) string {
@@ -154,10 +157,10 @@ func (x *Executor) QuoteEntry(entry string) string {
 		*/
 		return escapeArg(entry)
 	case shellTypePowerShell:
-		escaped := strings.Replace(entry, `"`, `\"`, -1)
-		return "'" + strings.Replace(escaped, "'", "''", -1) + "'"
+		escaped := strings.ReplaceAll(entry, `"`, `\"`)
+		return "'" + strings.ReplaceAll(escaped, "'", "''") + "'"
 	default:
-		return "'" + strings.Replace(entry, "'", "'\\''", -1) + "'"
+		return "'" + strings.ReplaceAll(entry, "'", "'\\''") + "'"
 	}
 }
 

src/winpty.go

@@ -0,0 +1,13 @@
+//go:build !windows
+
+package fzf
+
+import "errors"
+
+func needWinpty(_ *Options) bool {
+	return false
+}
+
+func runWinpty(_ []string, _ *Options) (int, error) {
+	return ExitError, errors.New("Not supported")
+}

src/winpty_windows.go

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