0.72.0

Mirror of the earlier change-header fix. The inline footer slot's row
budget depends on footer content length, but resizeIfNeeded() tolerates
a shorter-than-wanted inline window, so extra lines get clipped. Drive
a redraw on length change to re-run the layout.

.editorconfig

@@ -0,0 +1,20 @@
+root = true
+
+[*.{sh,bash,fish}]
+indent_style       = space
+indent_size        = 2
+simplify           = true
+binary_next_line   = false
+switch_case_indent = true
+space_redirects    = true
+function_next_line = false
+
+# also bash scripts.
+[{install,uninstall,bin/fzf-preview.sh,bin/fzf-tmux}]
+indent_style       = space
+indent_size        = 2
+simplify           = true
+binary_next_line   = false
+switch_case_indent = true
+space_redirects    = true
+function_next_line = false

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @junegunn

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,17 @@
+## Contribution Policy
+
+We do not accept pull requests generated primarily by AI without genuine understanding or real-world usage context.
+
+All contributions are expected to demonstrate:
+- A clear understanding of the codebase
+- Alignment with product direction
+- Thoughtful reasoning behind changes
+- Evidence of real-world usage or hands-on experience with the problem
+
+If these expectations are not met, we would prefer to implement the changes ourselves rather than spend time reviewing low-effort submissions.
+
+---
+
+## Acknowledgement
+
+- [ ] I confirm that this PR meets the above expectations and reflects my own understanding and real-world context.

.github/labeler.yml

@@ -0,0 +1,64 @@
+go:
+  - changed-files:
+      - any-glob-to-any-file:
+          - src/**
+          - main.go
+          - go.mod
+          - go.sum
+
+shell:
+  - changed-files:
+      - any-glob-to-any-file:
+          - shell/**
+
+bash:
+  - changed-files:
+      - any-glob-to-any-file:
+          - shell/**/*.bash
+
+zsh:
+  - changed-files:
+      - any-glob-to-any-file:
+          - shell/**/*.zsh
+
+fish:
+  - changed-files:
+      - any-glob-to-any-file:
+          - shell/**/*.fish
+
+vim:
+  - changed-files:
+      - any-glob-to-any-file:
+          - plugin/**
+
+docs:
+  - changed-files:
+      - any-glob-to-any-file:
+          - '*.md'
+          - doc/**
+          - man/**
+
+ci:
+  - changed-files:
+      - any-glob-to-any-file:
+          - .github/**
+
+build:
+  - changed-files:
+      - any-glob-to-any-file:
+          - Makefile
+          - .goreleaser.yml
+          - Dockerfile
+
+test:
+  - changed-files:
+      - any-glob-to-any-file:
+          - test/**
+          - src/**/*_test.go
+
+install:
+  - changed-files:
+      - any-glob-to-any-file:
+          - install
+          - install.ps1
+          - uninstall

.github/workflows/codeql-analysis.yml

@@ -27,18 +27,18 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         fetch-depth: 0
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@v4
       with:
         languages: ${{ matrix.language }}
 
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v3
+      uses: github/codeql-action/autobuild@v4
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@v4

.github/workflows/depsreview.yaml

@@ -9,6 +9,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: 'Checkout Repository'
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - name: 'Dependency Review'
         uses: actions/dependency-review-action@v4

.github/workflows/labeler.yml

@@ -0,0 +1,17 @@
+name: Label PRs
+
+on:
+  pull_request_target:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  label:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/labeler@v6
+        with:
+          configuration-path: .github/labeler.yml

.github/workflows/linux.yml

@@ -1,11 +1,11 @@
 ---
-name: Test fzf on Linux
+name: build
 
 on:
   push:
     branches: [ master, devel ]
   pull_request:
-    branches: [ master ]
+    branches: [ master, devel ]
   workflow_dispatch:
 
 permissions:
@@ -16,33 +16,38 @@ env:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
         fetch-depth: 0
 
     - name: Set up Go
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
-        go-version: "1.20"
+        go-version: "1.23"
 
     - name: Setup Ruby
-      uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@3ff19f5e2baf30647122352b96108b1fbe250c64 # v1
       with:
-        ruby-version: 3.1.0
+        ruby-version: 3.4.6
 
     - name: Install packages
-      run: sudo apt-get install --yes zsh fish tmux
+      run: sudo apt-get install --yes zsh fish tmux shfmt
 
     - name: Install Ruby gems
-      run: sudo gem install --no-document minitest:5.25.1 rubocop:1.65.0 rubocop-minitest:0.35.1 rubocop-performance:1.21.1
+      run: bundle install
 
     - name: Rubocop
-      run: rubocop --require rubocop-minitest --require rubocop-performance
+      run: make lint
 
     - name: Unit test
       run: make test
 
+    - name: Fuzz test
+      run: |
+        go test ./src/algo/ -fuzz=FuzzIndexByteTwo -fuzztime=5s
+        go test ./src/algo/ -fuzz=FuzzLastIndexByteTwo -fuzztime=5s
+
     - name: Integration test
-      run: make install && ./install --all && tmux new-session -d && ruby test/test_go.rb --verbose
+      run: make install && ./install --all && tmux new-session -d && ruby test/runner.rb --verbose

.github/workflows/macos.yml

@@ -15,22 +15,22 @@ jobs:
   build:
     runs-on: macos-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
         fetch-depth: 0
 
     - name: Set up Go
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
-        go-version: "1.20"
+        go-version: "1.23"
 
     - name: Setup Ruby
-      uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@3ff19f5e2baf30647122352b96108b1fbe250c64 # v1
       with:
         ruby-version: 3.0.0
 
     - name: Install packages
-      run: HOMEBREW_NO_INSTALL_CLEANUP=1 brew install fish zsh tmux
+      run: HOMEBREW_NO_INSTALL_CLEANUP=1 brew install fish zsh tmux shfmt
 
     - name: Install Ruby gems
       run: gem install --no-document minitest:5.14.2 rubocop:1.0.0 rubocop-minitest:0.10.1 rubocop-performance:1.8.1

.github/workflows/sponsors.yml

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

.github/workflows/typos.yml

@@ -6,5 +6,5 @@ jobs:
     name: Spell Check with Typos
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: crate-ci/typos@v1.28.4
+    - uses: actions/checkout@v5
+    - uses: crate-ci/typos@685eb3d55be2f85191e8c84acb9f44d7756f84ab # v1.29.4

.github/workflows/winget.yml

@@ -7,7 +7,7 @@ jobs:
   publish:
     runs-on: ubuntu-latest
     steps:
-      - uses: vedantmgoyal2009/winget-releaser@v2
+      - uses: vedantmgoyal2009/winget-releaser@4ffc7888bffd451b357355dc214d43bb9f23917e # v2
         with:
           identifier: junegunn.fzf
           installers-regex: '-windows_(armv7|arm64|amd64)\.zip$'

.gitignore

@@ -3,7 +3,6 @@ bin/fzf.exe
 dist
 target
 pkg
-Gemfile.lock
 .DS_Store
 doc/tags
 vendor
@@ -12,3 +11,4 @@ gopath
 fzf
 tmp
 *.patch
+.idea

.goreleaser.yml

@@ -14,6 +14,7 @@ builds:
       - windows
       - freebsd
       - openbsd
+      - android
     goarch:
       - amd64
       - arm
@@ -21,10 +22,11 @@ builds:
       - loong64
       - ppc64le
       - s390x
+      - riscv64
     goarm:
-      - 5
-      - 6
-      - 7
+      - "5"
+      - "6"
+      - "7"
     flags:
       - -trimpath
     ldflags:
@@ -38,6 +40,12 @@ builds:
         goarch: arm64
       - goos: openbsd
         goarch: arm64
+      - goos: openbsd
+        goarch: riscv64
+      - goos: android
+        goarch: amd64
+      - goos: android
+        goarch: arm
 
 # .goreleaser.yaml
 notarize:
@@ -77,12 +85,14 @@ notarize:
 
 archives:
   - name_template: "{{ .ProjectName }}-{{ .Version }}-{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
-    builds:
+    ids:
       - fzf
-    format: tar.gz
+    formats:
+      - tar.gz
     format_overrides:
       - goos: windows
-        format: zip
+        formats:
+          - zip
     files:
       - non-existent*
 
@@ -94,7 +104,7 @@ release:
   name_template: '{{ .Version }}'
 
 snapshot:
-  name_template: "{{ .Version }}-devel"
+  version_template: "{{ .Version }}-devel"
 
 changelog:
   sort: asc

.rubocop.yml

@@ -1,9 +1,13 @@
+AllCops:
+  NewCops: enable
 Layout/LineLength:
   Enabled: false
 Metrics:
   Enabled: false
 Lint/ShadowingOuterLocalVariable:
   Enabled: false
+Lint/NestedMethodDefinition:
+  Enabled: false
 Style/MethodCallWithArgsParentheses:
   Enabled: true
   AllowedMethods:
@@ -28,5 +32,11 @@ Style/WordArray:
   MinSize: 1
 Minitest/AssertEqual:
   Enabled: false
+Minitest/EmptyLineBeforeAssertionMethods:
+  Enabled: false
 Naming/VariableNumber:
   Enabled: false
+Lint/EmptyBlock:
+  Enabled: false
+Style/SafeNavigationChainLength:
+  Enabled: false

.tool-versions

@@ -1 +1,3 @@
-golang 1.20.13
+golang 1.23
+ruby 3.4
+shfmt 3.12

ADVANCED.md

@@ -1,8 +1,8 @@
 Advanced fzf examples
 ======================
 
-* *Last update: 2024/06/24*
-* *Requires fzf 0.54.0 or later*
+* *Last update: 2025/02/02*
+* *Requires fzf 0.59.0 or later*
 
 ---
 
@@ -22,6 +22,7 @@ Advanced fzf examples
     * [Switching to fzf-only search mode](#switching-to-fzf-only-search-mode)
     * [Switching between Ripgrep mode and fzf mode](#switching-between-ripgrep-mode-and-fzf-mode)
     * [Switching between Ripgrep mode and fzf mode using a single key binding](#switching-between-ripgrep-mode-and-fzf-mode-using-a-single-key-binding)
+    * [Controlling Ripgrep search and fzf search simultaneously](#controlling-ripgrep-search-and-fzf-search-simultaneously)
 * [Log tailing](#log-tailing)
 * [Key bindings for git objects](#key-bindings-for-git-objects)
     * [Files listed in `git status`](#files-listed-in-git-status)
@@ -92,7 +93,7 @@ fzf --height=40% --layout=reverse --info=inline --border --margin=1 --padding=1
 
 ![image](https://user-images.githubusercontent.com/700826/113379932-dfeac200-93b5-11eb-9e28-df1a2ee71f90.png)
 
-*(See `Layout` section of the man page to see the full list of options)*
+*(See man page to see the full list of options)*
 
 But you definitely don't want to repeat `--height=40% --layout=reverse
 --info=inline --border --margin=1 --padding=1` every time you use fzf. You
@@ -308,16 +309,16 @@ I know it's a lot to digest, let's try to break down the code.
   available color options.
 - The value of `--preview-window` option consists of 5 components delimited
   by `,`
-    1. `up` — Position of the preview window
-    1. `60%` — Size of the preview window
-    1. `border-bottom` — Preview window border only on the bottom side
-    1. `+{2}+3/3` — Scroll offset of the preview contents
-    1. `~3` — Fixed header
+    1. `up` -- Position of the preview window
+    1. `60%` -- Size of the preview window
+    1. `border-bottom` -- Preview window border only on the bottom side
+    1. `+{2}+3/3` -- Scroll offset of the preview contents
+    1. `~3` -- Fixed header
 - Let's break down the latter two. We want to display the bat output in the
   preview window with a certain scroll offset so that the matching line is
   positioned near the center of the preview window.
-    - `+{2}` — The base offset is extracted from the second token
-    - `+3` — We add 3 lines to the base offset to compensate for the header
+    - `+{2}` -- The base offset is extracted from the second token
+    - `+3` -- We add 3 lines to the base offset to compensate for the header
       part of `bat` output
         - ```
           ───────┬──────────────────────────────────────────────────────────
@@ -362,7 +363,7 @@ projects, and it will free up memory as you narrow down the results.
 RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
 INITIAL_QUERY="${*:-}"
 fzf --ansi --disabled --query "$INITIAL_QUERY" \
-    --bind "start:reload:$RG_PREFIX {q}" \
+    --bind "start:reload:$RG_PREFIX {q} || true" \
     --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
     --delimiter : \
     --preview 'bat --color=always {1} --highlight-line {2}' \
@@ -500,6 +501,44 @@ fzf --ansi --disabled --query "$INITIAL_QUERY" \
     --bind 'enter:become(vim {1} +{2})'
 ```
 
+### Controlling Ripgrep search and fzf search simultaneously
+
+`search` and `transform-search` action allow you to trigger an fzf search with
+an arbitrary query string. This frees fzf from strictly following the prompt
+input, enabling custom search syntax.
+
+In the example below, `transform` action is used to conditionally trigger
+`reload` for ripgrep, followed by `search` for fzf. The first word of the
+query initiates the Ripgrep process to generate the initial results, while the
+remainder of the query is passed to fzf for secondary filtering.
+
+```sh
+#!/usr/bin/env bash
+
+export TEMP=$(mktemp -u)
+trap 'rm -f "$TEMP"' EXIT
+
+INITIAL_QUERY="${*:-}"
+TRANSFORMER='
+  rg_pat={q:1}      # The first word is passed to ripgrep
+  fzf_pat={q:2..}   # The rest are passed to fzf
+
+  if ! [[ -r "$TEMP" ]] || [[ $rg_pat != $(cat "$TEMP") ]]; then
+    echo "$rg_pat" > "$TEMP"
+    printf "reload:sleep 0.1; rg --column --line-number --no-heading --color=always --smart-case %q || true" "$rg_pat"
+  fi
+  echo "+search:$fzf_pat"
+'
+fzf --ansi --disabled --query "$INITIAL_QUERY" \
+    --with-shell 'bash -c' \
+    --bind "start,change:transform:$TRANSFORMER" \
+    --color "hl:-1:underline,hl+:-1:underline:reverse" \
+    --delimiter : \
+    --preview 'bat --color=always {1} --highlight-line {2}' \
+    --preview-window 'up,60%,border-line,+{2}+3/3,~3' \
+    --bind 'enter:become(vim {1} +{2})'
+```
+
 Log tailing
 -----------
 
@@ -529,8 +568,7 @@ pods() {
     --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 'start,ctrl-r:reload:$command' \
     --bind 'ctrl-/:change-preview-window(80%,border-bottom|hidden|)' \
     --bind 'enter:execute:kubectl exec -it --namespace {1} {2} -- bash' \
     --bind 'ctrl-o:execute:${EDITOR:-vim} <(kubectl logs --all-containers --namespace {1} {2})' \

BUILD.md

@@ -6,7 +6,7 @@ Build instructions
 
 ### Prerequisites
 
-- Go 1.20 or above
+- Go 1.23 or above
 
 ### Using Makefile
 
@@ -41,6 +41,20 @@ make release
 >     --profile-block /tmp/block.pprof --profile-mutex /tmp/mutex.pprof
 > ```
 
+Running tests
+-------------
+
+```sh
+# Run go unit tests
+make test
+
+# Run integration tests (requires to be on tmux)
+make itest
+
+# Run a single test case
+ruby test/runner.rb --name test_something
+```
+
 Third-party libraries used
 --------------------------
 

CHANGELOG.md

@@ -1,6 +1,858 @@
 CHANGELOG
 =========
 
+0.72.0
+------
+_Release highlights: https://junegunn.github.io/fzf/releases/0.72.0/_
+
+- `--header-border`, `--header-lines-border`, and `--footer-border` now accept a new `inline` style that embeds the section inside the list frame, separated from the list content by a horizontal line. When the list border has side segments, the separator joins them as T-junctions.
+    - Requires a `--list-border` shape that has both top and bottom segments (`rounded`, `sharp`, `bold`, `double`, `block`, `thinblock`, or `horizontal`); falls back to `line` otherwise. `horizontal` has no side borders, so the separator is drawn without T-junction endpoints.
+    - Sections stack. Example combining all three:
+      ```sh
+      ps -ef | fzf --reverse --style full \
+          --header 'Select a process' --header-lines 1 \
+          --bind 'load:transform-footer:echo $FZF_TOTAL_COUNT processes' \
+          --header-border dashed --header-first \
+          --header-lines-border inline --footer-border inline
+      ```
+    - `--header-label` and `--footer-label` render on their respective separator row.
+    - The separator inherits `--color list-border` when the section's own border color is not explicitly set.
+    - `inline` takes precedence over `--header-first`: the inline section stays inside the list frame. `--header-border=inline` requires `--header-lines-border` to be `inline` or unset.
+- New `dashed` border style with dashed edges (`╶` / `┆`) and rounded corners.
+    - `--border=dashed`, `--list-border=dashed`, etc.
+    - Works with inline sections (T-junctions render correctly).
+- [vim] Move and resize popup window when detecting `VimResized` event (#4778) (@Vulcalien)
+- Bug fixes
+    - Fixed gutter display in `--style=minimal`
+    - Fixed arrow keys / Home / End without modifiers being ignored under the kitty keyboard protocol (#4776) (@TymekDev)
+    - bash: Persist history deletion when `histappend` is on (#4764)
+
+0.71.0
+------
+_Release highlights: https://junegunn.github.io/fzf/releases/0.71.0/_
+
+- Added `--popup` as a new name for `--tmux` with Zellij support
+    - `--popup` starts fzf in a tmux popup or a Zellij floating pane
+    - `--tmux` is now an alias for `--popup`
+    - Requires tmux 3.3+ or Zellij 0.44+
+- Cross-reload item identity with `--id-nth`
+    - Added `--id-nth=NTH` to define item identity fields for cross-reload operations
+    - When a `reload` is triggered with tracking enabled, fzf searches for the tracked item by its identity fields in the new list.
+        - `--track --id-nth ..` tracks by the entire line
+        - `--track --id-nth 1` tracks by the first field
+        - `--track` without `--id-nth` retains the existing index-based tracking behavior
+        - The UI is temporarily blocked (prompt dimmed, input disabled) until the item is found or loading completes.
+            - Press `Escape` or `Ctrl-C` to cancel the blocked state without quitting
+            - Info line shows `+T*` / `+t*` while searching
+    - With `--multi`, selected items are preserved across `reload-sync` by matching their identity fields
+- Performance improvements
+    - The search performance now scales linearly with the number of CPU cores, as we dropped static partitioning to allow better load balancing across threads.
+      ```
+      === query: 'linux' ===
+        [all]   baseline:    21.95ms  current:    17.47ms  (1.26x)  matches: 179966 (12.79%)
+        [1T]    baseline:   179.63ms  current:   180.53ms  (1.00x)  matches: 179966 (12.79%)
+        [2T]    baseline:    97.38ms  current:    90.05ms  (1.08x)  matches: 179966 (12.79%)
+        [4T]    baseline:    53.83ms  current:    44.77ms  (1.20x)  matches: 179966 (12.79%)
+        [8T]    baseline:    41.66ms  current:    22.58ms  (1.84x)  matches: 179966 (12.79%)
+      ```
+    - Improved the cache structure, reducing memory footprint per entry by 86x.
+        - With the reduced per-entry cost, the cache now has broader coverage.
+- Shell integration improvements
+    - bash: CTRL-R now supports multi-select and `shift-delete` to delete history entries (#4715)
+    - fish:
+        - Improved command history (CTRL-R) (#4703) (@bitraid)
+        - Rewrite completion script (SHIFT-TAB) (#4731) (@bitraid)
+        - Increase minimum fish version requirement to 3.4.0 (#4731) (@bitraid)
+- `GET /` HTTP endpoint now includes `positions` field in each match entry, providing the indices of matched characters for external highlighting (#4726)
+- Allow adaptive height with negative value (`--height=~-HEIGHT`) (#4682)
+- Bug fixes
+    - `--walker=follow` no longer follows symlinks whose target is an ancestor of the walker root, avoiding severe resource exhaustion when a symlink points outside the tree (e.g. Wine's `z:` → `/`) (#4710)
+    - Fixed AWK tokenizer not treating a new line character as whitespace
+    - Fixed `--{accept,with}-nth` removing trailing whitespaces with a non-default `--delimiter`
+    - Fixed OSC8 hyperlinks being mangled when the URL contains unicode characters (#4707)
+    - Fixed `--with-shell` not handling quoted arguments correctly (#4709)
+    - Fixed child processes not being terminated on Windows (#4723) (@pjeby)
+    - Fixed preview scrollbar not rendered after `toggle-preview`
+    - Fixed preview follow/scroll with long wrapped lines
+    - Fixed tab width when `--frozen-left` is used
+    - Fixed preview mouse events being processed when no preview window exists
+    - zsh: Fixed history widget when `sh_glob` option is on (#4714) (@EvanHahn)
+
+0.70.0
+------
+- Added `change-with-nth` action for dynamically changing the `--with-nth` option.
+    - Requires `--with-nth` to be set initially.
+    - Multiple options separated by `|` can be given to cycle through.
+  ```sh
+  echo -e "a b c\nd e f\ng h i" | fzf --with-nth .. \
+    --bind 'space:change-with-nth(1|2|3|1,3|2,3|)'
+  ```
+- Added `change-header-lines` action for dynamically changing the `--header-lines` option
+- Performance improvements (1.3x to 1.9x faster filtering depending on query)
+  ```
+  === query: 'l' ===
+    [all]   baseline:   168.87ms  current:    95.21ms  (1.77x)  matches: 5069891 (94.78%)
+    [1T]    baseline:  1652.22ms  current:   841.40ms  (1.96x)  matches: 5069891 (94.78%)
+
+  === query: 'lin' ===
+    [all]   baseline:   343.27ms  current:   252.59ms  (1.36x)  matches: 3516507 (65.74%)
+    [1T]    baseline:  3199.89ms  current:  2230.64ms  (1.43x)  matches: 3516507 (65.74%)
+
+  === query: 'linux' ===
+    [all]   baseline:    85.47ms  current:    63.72ms  (1.34x)  matches: 307229 (5.74%)
+    [1T]    baseline:   774.64ms  current:   589.32ms  (1.31x)  matches: 307229 (5.74%)
+
+  === query: 'linuxlinux' ===
+    [all]   baseline:    55.13ms  current:    35.67ms  (1.55x)  matches: 12230 (0.23%)
+    [1T]    baseline:   461.99ms  current:   332.38ms  (1.39x)  matches: 12230 (0.23%)
+
+  === query: 'linuxlinuxlinux' ===
+    [all]   baseline:    51.77ms  current:    32.53ms  (1.59x)  matches: 865 (0.02%)
+    [1T]    baseline:   409.99ms  current:   296.33ms  (1.38x)  matches: 865 (0.02%)
+  ```
+- Fixed `nth` attribute merge order to respect precedence hierarchy (#4697)
+- bash: Replaced `printf` with builtin `printf` to bypass local indirections (#4684) (@DarrenBishop)
+
+0.68.0
+------
+- Implemented word wrapping in the list section
+    - Added `--wrap=word` (or `--wrap-word`) option and `toggle-wrap-word` action for word-level line wrapping in the list section
+    - Changed default binding of `ctrl-/` and `alt-/` from `toggle-wrap` to `toggle-wrap-word`
+  ```sh
+  fzf --wrap=word
+  ```
+- Implemented word wrapping in the preview window
+    - Added `wrap-word` flag for `--preview-window` to enable word-level wrapping
+    - Added `toggle-preview-wrap-word` action
+  ```sh
+  fzf --preview 'bat --style=plain --color=always {}' \
+      --preview-window wrap-word \
+      --bind space:toggle-preview-wrap-word
+  ```
+- Added support for underline style variants in `--color`: `underline-double`, `underline-curly`, `underline-dotted`, `underline-dashed`
+  ```sh
+  fzf --color 'fg:underline-curly,current-fg:underline-dashed'
+  ```
+- Added support for underline styles (`4:N`) and underline colors (SGR 58/59)
+  ```sh
+  # In the list section
+  printf '\e[4:3;58;2;255;0;0mRed curly underline\e[0m\n' | fzf --ansi
+
+  # In the preview window
+  fzf --preview "printf '\e[4:3;58;2;255;0;0mRed curly underline\e[0m\n'"
+  ```
+- Added `--preview-wrap-sign` to set a different wrap indicator for the preview window
+- Added `alt-gutter` color option (#4602) (@hedgieinsocks)
+- Added `$FZF_WRAP` environment variable to child processes (`char` or `word` when wrapping is enabled) (#4672) (@bitraid)
+- fish: Improved command history (CTRL-R) (#4672) (@bitraid)
+    - Enabled syntax highlighting in the list on fish 4.3.3+
+    - Added syntax-highlighted preview window that auto-shows for long or multi-line commands
+    - Added `ALT-ENTER` to reformat and insert selected commands
+    - Improved handling of bulk deletion of selected history entries (`SHIFT-DELETE`)
+- Added fish completion support (#4605) (@lalvarezt)
+- zsh: Handle multi-line history selection (#4595) (@LangLangBart)
+- Bug fixes
+    - Fixed `_fzf_compgen_{path,dir}` to respect `FZF_COMPLETION_{PATH,DIR}_OPTS` (#4592) (@shtse8, @LangLangBart)
+    - Fixed `--preview-window follow` not working correctly with wrapping (#3243, #4258)
+    - Fixed symlinks to directories being returned as files (#4676) (@skk64)
+    - Fixed SIGHUP signal handling (#4668) (@LangLangBart)
+    - Fixed preview process not killed on exit (#4667)
+    - Fixed coloring of items with zero-width characters (#4620)
+    - Fixed `track-current` unset after a combined movement action (#4649)
+    - Fixed `--accept-nth` being ignored in filter mode (#4636) (@charemma)
+    - Fixed display width calculation with `maxWidth` (#4596) (@LangLangBart)
+    - Fixed clearing of the rest of the current line on start (#4652)
+    - Fixed `x-api-key` header not required for GET requests (#4627)
+    - Fixed key reading not cancelled when `execute` triggered via a server request (#4653)
+    - Fixed rebind of readline command `redraw-current-line` (#4635) (@jameslazo)
+    - Fixed `fzf-tmux` `TERM` quoting and added `mktemp` usage (#4664) (@Goofygiraffe06)
+    - Do not allow very long queries in `FuzzyMatchV2` (#4608)
+
+0.67.0
+------
+- Added `--freeze-left=N` option to keep the leftmost N columns always visible.
+  ```sh
+  # Keep the file name column fixed and always visible
+  git grep --line-number --color=always -- '' |
+      fzf --ansi --delimiter : --freeze-left 1
+
+  # Can be used with --keep-right
+  git grep --line-number --color=always -- '' |
+      fzf --ansi --delimiter : --freeze-left 1 --keep-right
+  ```
+- Also added `--freeze-right=N` option to keep the rightmost N columns always visible.
+  ```sh
+  # Stronger version of --keep-right that always keeps the right-end visible
+  fd | fzf --freeze-right 1
+
+  # Keep the base name always visible
+  fd | fzf --freeze-right 1 --delimiter /
+
+  # Keep both leftmost and rightmost components visible
+  fd | fzf --freeze-left 1 --freeze-right 1 --delimiter /
+  ```
+- Updated `--info=inline` to print the spinner (load indicator).
+- Bug fixes
+
+0.66.1
+------
+- Bug fixes
+    - Fixed a bug preventing 'ctrl-h' from being bound to an action (#4556)
+    - Fixed `--no-color` / `NO_COLOR` theme (#4561)
+
+0.66.0
+------
+
+### Quick summary
+
+This version introduces many new features centered around the new "raw" mode.
+
+| Type        | Class   | Name                | Description                                        |
+| :--         | :--     | :--                 | :--                                                |
+| New         | Option  | `--raw`             | Enable raw mode by default                         |
+| New         | Option  | `--gutter CHAR`     | Set the gutter column character                    |
+| New         | Option  | `--gutter-raw CHAR` | Set the gutter column character in raw mode        |
+| Enhancement | Option  | `--listen SOCKET`   | Added support for Unix domain sockets              |
+| New         | Action  | `toggle-raw`        | Toggle raw mode                                    |
+| New         | Action  | `enable-raw`        | Enable raw mode                                    |
+| New         | Action  | `disable-raw`       | Disable raw mode                                   |
+| New         | Action  | `up-match`          | Move up to the matching item                       |
+| New         | Action  | `down-match`        | Move down to the matching item                     |
+| New         | Action  | `best`              | Move to the  matching item with the best score     |
+| New         | Color   | `nomatch`           | Color for non-matching items in raw mode           |
+| New         | Env Var | `FZF_RAW`           | Matching status in raw mode (0, 1, or undefined)   |
+| New         | Env Var | `FZF_DIRECTION`     | `up` or `down` depending on the layout             |
+| New         | Env Var | `FZF_SOCK`          | Path to the Unix domain socket fzf is listening on |
+| Enhancement | Key     | `CTRL-N`            | `down` -> `down-match`                             |
+| Enhancement | Key     | `CTRL-P`            | `up` -> `up-match`                                 |
+| Enhancement | Shell   | `CTRL-R` binding    | Toggle raw mode with `ALT-R`                       |
+| Enhancement | Shell   | `CTRL-R` binding    | Opt-out with an empty `FZF_CTRL_R_COMMAND`         |
+
+### 1. Introducing "raw" mode
+
+![](https://github.com/user-attachments/assets/9640ae11-b5f7-43fb-95f1-c29307fc17c2)
+
+This version introduces a new "raw" mode (named so because it shows the list
+"unfiltered"). In raw mode, non-matching items stay in their original positions,
+but appear dimmed. This allows you to see the surrounding items of a match and
+better understand the context of it. You can enable raw mode by default with
+`--raw`, but it's often more useful when toggled dynamically with the
+`toggle-raw` action.
+
+```sh
+tree | fzf --reverse --bind alt-r:toggle-raw
+```
+
+While non-matching items are displayed in a dimmed color, they are treated just
+like matching items, so you place the cursor on them and perform any action. If
+you prefer to navigate only through matching items, use the `down-match` and
+`up-match` actions, which are from now on bound to `CTRL-N` and `CTRL-P`
+respectively, and also to `ALT-DOWN` and `ALT-UP`.
+
+| Key        | Action       | With `--history` |
+| :--        | :--          | :--              |
+| `down`     | `down`       |                  |
+| `up`       | `up`         |                  |
+| `ctrl-j`   | `down`       |                  |
+| `ctrl-k`   | `up`         |                  |
+| `ctrl-n`   | `down-match` | `next-history`   |
+| `ctrl-p`   | `up-match`   | `prev-history`   |
+| `alt-down` | `down-match` |                  |
+| `alt-up`   | `up-match`   |                  |
+
+> [!NOTE]
+> `CTRL-N` and `CTRL-P` are bound to `next-history` and `prev-history` when
+> `--history` option is enabled, so in that case, you'll need to manually bind
+> them, or use `ALT-DOWN` and `ALT-UP` instead.
+
+> [!TIP]
+> `up-match` and `down-match` are equivalent to `up` and `down` when not in
+> raw mode, so you can safely bind them to `up` and `arrow` keys if you prefer.
+> ```sh
+> fzf --bind up:up-match,down:down-match
+> ```
+
+#### Customizing the behavior
+
+In raw mode, the input list is presented in its original order, unfiltered, and
+your cursor will not move to the matching item automatically. Here are ways to
+customize the behavior.
+
+```sh
+# When the result list is updated, move the cursor to the item with the best score
+# (assuming sorting is not disabled)
+fzf --raw --bind result:best
+
+# Move to the first matching item in the original list
+# - $FZF_RAW is set to 0 when raw mode is enabled and the current item is a non-match
+# - $FZF_DIRECTION is set to either 'up' or 'down' depending on the layout direction
+fzf --raw --bind 'result:first+transform:[[ $FZF_RAW = 0 ]] && echo $FZF_DIRECTION-match'
+```
+
+#### Customizing the look
+
+##### Gutter
+
+To make the mode visually distinct, the gutter column is rendered in a dashed
+line using `▖` character. But you can customize it with the `--gutter-raw CHAR`
+option.
+
+```sh
+# Use a thinner gutter instead of the default dashed line
+fzf --bind alt-r:toggle-raw --gutter-raw ▎
+```
+
+##### Color and style of non-matching items
+
+Non-matching items are displayed in a dimmed color by default, but you can
+change it with the `--color nomatch:...` option.
+
+```sh
+fzf --raw --color nomatch:red
+fzf --raw --color nomatch:red:dim
+fzf --raw --color nomatch:red:dim:strikethrough
+fzf --raw --color nomatch:red:dim:strikethrough:italic
+```
+
+For colored input, dimming alone may not be enough, and you may prefer to remove
+colors entirely. For that case, a new special style attribute `strip` has been
+added.
+
+```sh
+fd --color always | fzf --ansi --raw --color nomatch:dim:strip:strikethrough
+```
+
+#### Conditional actions for raw mode
+
+You may want to perform different actions depending on whether the current item
+is a match or not. For that, fzf now exports `$FZF_RAW` environment variable.
+
+It's:
+
+- Undefined if raw mode is disabled
+- `1` if the current item is a match
+- `0` otherwise
+
+```sh
+# Do not allow selecting non-matching items
+fzf --raw --bind 'enter:transform:[[ ${FZF_RAW-1} = 1 ]] && echo accept || echo bell'
+```
+
+#### Leveraging raw mode in shell integration
+
+The `CTRL-R` binding (command history) now lets you toggle raw mode with `ALT-R`.
+
+### 2. Style changes
+
+The screenshot on the right shows the updated gutter style:
+
+![](https://github.com/user-attachments/assets/8ea7b5ef-c99e-4686-905b-22eb078b700a)
+
+This version includes a few minor updates to fzf's classic visual style:
+
+- The gutter column is now narrower, rendered with the left-half block character (`▌`).
+- Markers no longer use background colors.
+- The `--color base16` theme (alias: `16`) has been updated for better compatibility with both dark and light themes.
+
+### 3. `--listen` now supports Unix domain sockets
+
+If an argument to `--listen` ends with `.sock`, fzf will listen on a Unix
+domain socket at the specified path.
+
+```sh
+fzf --listen /tmp/fzf.sock --no-tmux
+
+# GET
+curl --unix-socket /tmp/fzf.sock http
+
+# POST
+curl --unix-socket /tmp/fzf.sock http -d up
+```
+
+Note that any existing file at the given path will be removed before creating
+the socket, so avoid using an important file path.
+
+### 4. Added options
+
+#### `--gutter CHAR`
+
+The gutter column can now be customized using `--gutter CHAR` and styled with
+`--color gutter:...`. Examples:
+
+```sh
+# Right-aligned gutter
+fzf --gutter '▐'
+
+# Even thinner gutter
+fzf --gutter '▎'
+
+# Yellow checker pattern
+fzf --gutter '▚' --color gutter:yellow
+
+# Classic style
+fzf --gutter ' ' --color gutter:reverse
+```
+
+#### `--gutter-raw CHAR`
+
+As noted above, the `--gutter-raw CHAR` option was also added for customizing the gutter column in raw mode.
+
+### 5. Added actions
+
+The following actions were introduced to support working with raw mode:
+
+| Action        | Description                                                                                 |
+| :--           | :--                                                                                         |
+| `toggle-raw`  | Toggle raw mode                                                                             |
+| `enable-raw`  | Enable raw mode                                                                             |
+| `disable-raw` | Disable raw mode                                                                            |
+| `up-match`    | Move up to the matching item; identical to `up` if raw mode is disabled                     |
+| `down-match`  | Move down to the matching item; identical to `down` if raw mode is disabled                 |
+| `best`        | Move to the matching item with the best score; identical to `first` if raw mode is disabled |
+
+### 6. Added environment variables
+
+#### `$FZF_DIRECTION`
+
+`$FZF_DIRECTION` is now exported to child processes, indicating the list direction of the current layout:
+
+- `up` for the default layout
+- `down` for `reverse` or `reverse-list`
+
+This simplifies writing transform actions involving layout-dependent actions
+like `{up,down}-match`, `{up,down}-selected`, and `toggle+{up,down}`.
+
+```sh
+fzf --raw --bind 'result:first+transform:[[ $FZF_RAW = 0 ]] && echo $FZF_DIRECTION-match'
+```
+
+#### `$FZF_SOCK`
+
+When fzf is listening on a Unix domain socket using `--listen`, the path to the
+socket is exported as `$FZF_SOCK`, analogous to `$FZF_PORT` for TCP sockets.
+
+#### `$FZF_RAW`
+
+As described above, `$FZF_RAW` is now exported to child processes in raw mode,
+indicating whether the current item is a match (`1`) or not (`0`). It is not
+defined when not in raw mode.
+
+#### `$FZF_CTRL_R_COMMAND`
+
+You can opt-out `CTRL-R` binding from the shell integration by setting
+`FZF_CTRL_R_COMMAND` to an empty string. Setting it to any other value is not
+supported and will result in a warning.
+
+```sh
+# Disable the CTRL-R binding from the shell integration
+FZF_CTRL_R_COMMAND= eval "$(fzf --bash)"
+```
+
+### 7. Added key support for `--bind`
+
+Pull request [#3996](https://github.com/junegunn/fzf/pull/3996) added support
+for many additional keys for `--bind` option, such as `ctrl-backspace`.
+
+### 8. Breaking changes
+
+#### Hiding the gutter column
+
+In the previous versions, the recommended way to hide the gutter column was to
+set `--color gutter:-1`. That's because the gutter column was just a space
+character, reversed. But now that it's using a visible character (`▌`), applying
+the default color is no longer enough to hide it. Instead, you can set it to
+a space character.
+
+```sh
+# Hide the gutter column
+fzf --gutter ' '
+
+# Classic style
+fzf --gutter ' ' --color gutter:reverse
+```
+
+#### `--color` option
+
+In the previous versions, some elements had default style attributes applied and
+you would have to explicitly unset them with `regular` attribute if you wanted
+to reset them. This is no longer needed now, as the default style attributes
+are applied only when you do not specify any color or style for that element.
+
+```sh
+# No 'dim', just red and italic.
+fzf --ghost 'Type to search' --color ghost:red:italic
+```
+
+#### Compatibility changes
+
+Starting with this release, fzf is built with Go 1.23. Support for some old OS versions has been dropped.
+
+See https://go.dev/wiki/MinimumRequirements.
+
+0.65.2
+------
+- Bug fixes and improvements
+    - Fix incorrect truncation of `--info-command` with `--info=inline-right` (#4479)
+    - [install] Support old uname in macOS (#4492)
+    - [bash 3] Fix `CTRL-T` and `ALT-C` to preserve the last yank (#4496)
+    - Do not unset `FZF_DEFAULT_*` variables when using winpty (#4497) (#4400)
+    - Fix rendering of items with tabs when using a non-default ellipsis (#4505)
+- **This is the final release to support Windows 7.**
+    - Future versions will be built with the latest Go toolchain, which has dropped support for Windows 7.
+
+0.65.1
+------
+- Fixed incorrect `$FZF_CLICK_HEADER_WORD` and `$FZF_CLICK_FOOTER_WORD` when the header or footer contains ANSI escape sequences and tab characters.
+- Fixed a bug where you cannot unset the default `--nth` using `change-nth` action.
+- Fixed a highlighting bug when using `--color fg:dim,nth:regular` pattern over ANSI-colored items.
+
+0.65.0
+------
+- Added `click-footer` event that is triggered when the footer section is clicked. When the event is triggered, the following environment variables are set:
+    - `$FZF_CLICK_FOOTER_COLUMN` - clicked column (1-based)
+    - `$FZF_CLICK_FOOTER_LINE` - clicked line (1-based)
+    - `$FZF_CLICK_FOOTER_WORD` - the word under the cursor
+  ```sh
+  fzf --footer $'[Edit] [View]\n[Copy to clipboard]' \
+      --with-shell 'bash -c' \
+      --bind 'click-footer:transform:
+        [[ $FZF_CLICK_FOOTER_WORD =~ Edit ]] && echo "execute:vim \{}"
+        [[ $FZF_CLICK_FOOTER_WORD =~ View ]] && echo "execute:view \{}"
+        (( FZF_CLICK_FOOTER_LINE == 2 )) && (( FZF_CLICK_FOOTER_COLUMN < 20 )) &&
+            echo "execute-silent(echo -n \{} | pbcopy)+bell"
+      '
+  ```
+- Added `trigger(...)` action that triggers events bound to another key or event.
+  ```sh
+  # You can click on each key name to trigger the actions bound to that key
+  fzf --footer 'Ctrl-E: Edit / Ctrl-V: View / Ctrl-Y: Copy to clipboard' \
+      --with-shell 'bash -c' \
+      --bind 'ctrl-e:execute:vim {}' \
+      --bind 'ctrl-v:execute:view {}' \
+      --bind 'ctrl-y:execute-silent(echo -n {} | pbcopy)+bell' \
+      --bind 'click-footer:transform:
+        [[ $FZF_CLICK_FOOTER_WORD =~ Ctrl ]] && echo "trigger(${FZF_CLICK_FOOTER_WORD%:})"
+      '
+  ```
+    - You can specify a series of keys and events
+      ```sh
+      fzf --bind 'a:up,b:trigger(a,a,a)'
+      ```
+- Added support for `{*n}` and `{*nf}` placeholder.
+    - `{*n}` evaluates to the zero-based ordinal index of all matched items.
+    - `{*nf}` evaluates to the temporary file containing that.
+- Bug fixes and improvements
+    - [neovim] Fixed margin background color when `&winborder` is used (#4453)
+    - Fixed rendering error when hiding a preview window without border (#4465)
+    - fix(shell): check for mawk existence before version check (#4468)
+        - Thanks to @LangLangBart and @akinomyoga
+    - Fixed `--no-header-lines-border` behavior (08027e7a)
+
+0.64.0
+------
+- Added `multi` event that is triggered when the multi-selection has changed.
+  ```sh
+  fzf --multi \
+      --bind 'ctrl-a:select-all,ctrl-d:deselect-all' \
+      --bind 'multi:transform-footer:(( FZF_SELECT_COUNT )) && echo "Selected $FZF_SELECT_COUNT item(s)"'
+  ```
+- [Halfwidth and fullwidth alphanumeric and punctuation characters](https://en.wikipedia.org/wiki/Halfwidth_and_Fullwidth_Forms_(Unicode_block)) are now internally normalized to their ASCII equivalents to allow matching with ASCII queries.
+  ```sh
+  echo ＡＢＣ| fzf -q abc
+  ```
+- Renamed `clear-selection` action to `clear-multi` for consistency.
+    - `clear-selection` remains supported as an alias for backward compatibility.
+- Bug fixes
+    - Fixed a bug that could cause fzf to abort due to incorrect update ordering.
+    - Fixed a bug where some multi-selections were lost when using `exclude` or `change-nth`.
+
+0.63.0
+------
+_Release highlights: https://junegunn.github.io/fzf/releases/0.63.0/_
+
+- Added footer. The default border style for footer is `line`, which draws a single separator line.
+  ```sh
+  fzf --reverse --footer "fzf: friend zone forever"
+  ```
+  - Options
+      - `--footer[=STRING]`
+      - `--footer-border[=STYLE]`
+      - `--footer-label=LABEL`
+      - `--footer-label-pos=COL[:bottom]`
+  - Colors
+      - `footer`
+      - `footer-bg`
+      - `footer-border`
+      - `footer-label`
+  - Actions
+      - `change-footer`
+      - `transform-footer`
+      - `bg-transform-footer`
+      - `change-footer-label`
+      - `transform-footer-label`
+      - `bg-transform-footer-label`
+- `line` border style is now allowed for all types of border except for `--list-border`.
+  ```sh
+  fzf --height 50% --style full:line --preview 'cat {}' \
+      --bind 'focus:bg-transform-header(file {})+bg-transform-footer(wc {})'
+  ```
+- Added `{*}` placeholder flag that evaluates to all matched items.
+  ```bash
+  seq 10000 | fzf --preview "awk '{sum += \$1} END {print sum}' {*f}"
+  ```
+  - Use this with caution, as it can make fzf sluggish for large lists.
+- Added asynchronous transform actions with `bg-` prefix that run asynchronously in the background, along with `bg-cancel` action to cancel currently running `bg-transform` actions.
+  ```sh
+  # Implement popup that disappears after 1 second
+  #   * Use footer as the popup
+  #   * Use `bell` to ring the terminal bell
+  #   * Use `bg-transform-footer` to clear the footer after 1 second
+  #   * Use `bg-cancel` to cancel currently running background transform actions
+  fzf --multi --list-border \
+      --bind 'enter:execute-silent(echo -n {+} | pbcopy)+bell' \
+      --bind 'enter:+transform-footer(echo Copied {} to clipboard)' \
+      --bind 'enter:+bg-cancel+bg-transform-footer(sleep 1)'
+
+  # It's okay for the commands to take a little while because they run in the background
+  GETTER='curl -s http://metaphorpsum.com/sentences/1'
+  fzf --style full --border --preview : \
+      --bind "focus:bg-transform-header:$GETTER" \
+      --bind "focus:+bg-transform-footer:$GETTER" \
+      --bind "focus:+bg-transform-border-label:$GETTER" \
+      --bind "focus:+bg-transform-preview-label:$GETTER" \
+      --bind "focus:+bg-transform-input-label:$GETTER" \
+      --bind "focus:+bg-transform-list-label:$GETTER" \
+      --bind "focus:+bg-transform-header-label:$GETTER" \
+      --bind "focus:+bg-transform-footer-label:$GETTER" \
+      --bind "focus:+bg-transform-ghost:$GETTER" \
+      --bind "focus:+bg-transform-prompt:$GETTER"
+  ```
+- Added support for full-line background color in the list section
+  ```sh
+  for i in $(seq 16 255); do
+    echo -e "\x1b[48;5;${i}m\x1b[0Khello"
+  done | fzf --ansi
+  ```
+- SSH completion enhancements by @akinomyoga
+- Bug fixes and improvements
+
+0.62.0
+------
+- Relaxed the `--color` option syntax to allow whitespace-separated entries (in addition to commas), making multi-line definitions easier to write and read
+  ```sh
+  # seoul256-light
+  fzf --style full --color='
+    fg:#616161 fg+:#616161
+    bg:#ffffff bg+:#e9e9e9 alt-bg:#f1f1f1
+    hl:#719872 hl+:#719899
+    pointer:#e12672 marker:#e17899
+    header:#719872
+    spinner:#719899 info:#727100
+    prompt:#0099bd query:#616161
+    border:#e1e1e1
+  '
+  ```
+- Added `alt-bg` color to create striped lines to visually separate rows
+  ```sh
+  fzf --color bg:237,alt-bg:238,current-bg:236 --highlight-line
+
+  declare -f | perl -0777 -pe 's/^}\n/}\0/gm' |
+    bat --plain --language bash --color always |
+    fzf --read0 --ansi --reverse --multi \
+        --color bg:237,alt-bg:238,current-bg:236 --highlight-line
+  ```
+- [fish] Improvements in CTRL-R binding (@bitraid)
+    - You can trigger CTRL-R in the middle of a command to insert the selected item
+    - You can delete history items with SHIFT-DEL
+- Bug fixes and improvements
+    - Fixed unnecessary 100ms delay after `reload` (#4364)
+    - Fixed `selected-bg` not applied to colored items (#4372)
+
+0.61.3
+------
+- Reverted #4351 as it caused `tmux run-shell 'fzf --tmux'` to fail (#4559 #4560)
+- More environment variables for child processes (#4356)
+
+0.61.2
+------
+- Fixed panic when using header border without pointer/marker (@phanen)
+- Fixed `--tmux` option when already inside a tmux popup (@peikk0)
+- Bug fixes and improvements in CTRL-T binding of fish (#4334) (@bitraid)
+- Added `--no-tty-default` option to make fzf search for the current TTY device instead of defaulting to `/dev/tty` (#4242)
+
+0.61.1
+------
+- Disable bracketed-paste mode on exit. This fixes issue where pasting breaks after running fzf on old bash versions that don't support the mode.
+
+0.61.0
+------
+- Added `--ghost=TEXT` to display a ghost text when the input is empty
+  ```sh
+  # Display "Type to search" when the input is empty
+  fzf --ghost "Type to search"
+  ```
+- Added `change-ghost` and `transform-ghost` actions for dynamically changing the ghost text
+- Added `change-pointer` and `transform-pointer` actions for dynamically changing the pointer sign
+- Added `r` flag for placeholder expression (raw mode) for unquoted output
+- Bug fixes and improvements
+
+0.60.3
+------
+- Bug fixes and improvements
+    - [fish] Enable multiple history commands insertion (#4280) (@bitraid)
+    - [walker] Append '/' to directory entries on MSYS2 (#4281)
+    - Trim trailing whitespaces after processing ANSI sequences (#4282)
+    - Remove temp files before `become` when using `--tmux` option (#4283)
+    - Fix condition for using item numlines cache (#4285) (@alex-huff)
+    - Make `--accept-nth` compatible with `--select-1` (#4287)
+    - Increase the query length limit from 300 to 1000 (#4292)
+    - [windows] Prevent fzf from consuming user input while paused (#4260)
+
+0.60.2
+------
+- Template for `--with-nth` and `--accept-nth` now supports `{n}` which evaluates to the zero-based ordinal index of the item
+- Fixed a regression that caused the last field in the "nth" expression to be trimmed when a regular expression delimiter is used
+    - Thanks to @phanen for the fix
+- Fixed 'jump' action when the pointer is an empty string
+
+0.60.1
+------
+- Bug fixes and minor improvements
+    - Built-in walker now prints directory entries with a trailing slash
+    - Fixed a bug causing unexpected behavior with [fzf-tab](https://github.com/Aloxaf/fzf-tab). Please upgrade if you use it.
+- Thanks to @alexeisersun, @bitraid, @Lompik, and @fsc0 for the contributions
+
+0.60.0
+------
+_Release highlights: https://junegunn.github.io/fzf/releases/0.60.0/_
+
+- Added `--accept-nth` for choosing output fields
+  ```sh
+  ps -ef | fzf --multi --header-lines 1 | awk '{print $2}'
+  # Becomes
+  ps -ef | fzf --multi --header-lines 1 --accept-nth 2
+
+  git branch | fzf | cut -c3-
+  # Can be rewritten as
+  git branch | fzf --accept-nth -1
+  ```
+- `--accept-nth` and `--with-nth` now support a template that includes multiple field index expressions in curly braces
+  ```sh
+  echo foo,bar,baz | fzf --delimiter , --accept-nth '{1}, {3}, {2}'
+    # foo, baz, bar
+
+  echo foo,bar,baz | fzf --delimiter , --with-nth '{1},{3},{2},{1..2}'
+    # foo,baz,bar,foo,bar
+  ```
+- Added `exclude` and `exclude-multi` actions for dynamically excluding items
+  ```sh
+  seq 100 | fzf --bind 'ctrl-x:exclude'
+
+  # 'exclude-multi' will exclude the selected items or the current item
+  seq 100 | fzf --multi --bind 'ctrl-x:exclude-multi'
+  ```
+- Preview window now prints wrap indicator when wrapping is enabled
+  ```sh
+  seq 100 | xargs | fzf --wrap --preview 'echo {}' --preview-window wrap
+  ```
+- Bug fixes and improvements
+
+0.59.0
+------
+_Release highlights: https://junegunn.github.io/fzf/releases/0.59.0/_
+
+- Prioritizing file name matches (#4192)
+    - Added a new tiebreak option `pathname` for prioritizing file name matches
+    - `--scheme=path` now sets `--tiebreak=pathname,length`
+    - fzf will automatically choose `path` scheme
+        * when the input is a TTY device, where fzf would start its built-in walker or run `$FZF_DEFAULT_COMMAND` which is usually a command for listing files,
+        * but not when `reload` or `transform` action is bound to `start` event, because in that case, fzf can't be sure of the input type.
+- Added `--header-lines-border` to display header from `--header-lines` with a separate border
+  ```sh
+  # Use --header-lines-border to separate two headers
+  ps -ef | fzf --style full --layout reverse --header-lines 1 \
+               --bind 'ctrl-r:reload(ps -ef)' --header 'Press CTRL-R to reload' \
+               --header-lines-border bottom --no-list-border
+  ```
+- `click-header` event now sets `$FZF_CLICK_HEADER_WORD` and `$FZF_CLICK_HEADER_NTH`. You can use them to implement a clickable header for changing the search scope using the new `transform-nth` action.
+  ```sh
+  # Click on the header line to limit search scope
+  ps -ef | fzf --style full --layout reverse --header-lines 1 \
+               --header-lines-border bottom --no-list-border \
+               --color fg:dim,nth:regular \
+               --bind 'click-header:transform-nth(
+                         echo $FZF_CLICK_HEADER_NTH
+                       )+transform-prompt(
+                         echo "$FZF_CLICK_HEADER_WORD> "
+                       )'
+  ```
+    - `$FZF_KEY` was updated to expose the type of the click. e.g. `click`, `ctrl-click`, etc. You can use it to implement a more sophisticated behavior.
+    - `kill` completion for bash and zsh were updated to use this feature
+- Added `--no-input` option to completely disable and hide the input section
+  ```sh
+  # Click header to trigger search
+  fzf --header '[src] [test]' --no-input --layout reverse \
+      --header-border bottom --input-border \
+      --bind 'click-header:transform-search:echo ${FZF_CLICK_HEADER_WORD:1:-1}'
+
+  # Vim-like mode switch
+  fzf --layout reverse-list --no-input \
+      --bind 'j:down,k:up,/:show-input+unbind(j,k,/)' \
+      --bind 'enter,esc,ctrl-c:transform:
+        if [[ $FZF_INPUT_STATE = enabled ]]; then
+          echo "rebind(j,k,/)+hide-input"
+        elif [[ $FZF_KEY = enter ]]; then
+          echo accept
+        else
+          echo abort
+        fi
+      '
+  ```
+    - You can later show the input section using `show-input` or `toggle-input` action, and hide it again using `hide-input`, or `toggle-input`.
+- Extended `{q}` placeholder to support ranges. e.g. `{q:1}`, `{q:2..}`, etc.
+- Added `search(...)` and `transform-search(...)` action to trigger an fzf search with an arbitrary query string. This can be used to extend the search syntax of fzf. In the following example, fzf will use the first word of the query to trigger ripgrep search, and use the rest of the query to perform fzf search within the result.
+  ```sh
+  export TEMP=$(mktemp -u)
+  trap 'rm -f "$TEMP"' EXIT
+
+  TRANSFORMER='
+    rg_pat={q:1}      # The first word is passed to ripgrep
+    fzf_pat={q:2..}   # The rest are passed to fzf
+
+    if ! [[ -r "$TEMP" ]] || [[ $rg_pat != $(cat "$TEMP") ]]; then
+      echo "$rg_pat" > "$TEMP"
+      printf "reload:sleep 0.1; rg --column --line-number --no-heading --color=always --smart-case %q || true" "$rg_pat"
+    fi
+    echo "+search:$fzf_pat"
+  '
+  fzf --ansi --disabled \
+    --with-shell 'bash -c' \
+    --bind "start,change:transform:$TRANSFORMER"
+  ```
+- You can now bind actions to multiple keys and events at once by writing a comma-separated list of keys and events before the colon
+  ```sh
+  # Load 'ps -ef' output on start and reload it on CTRL-R
+  fzf --bind 'start,ctrl-r:reload:ps -ef'
+  ```
+- `--min-height` option now takes a number followed by `+`, which tells fzf to show at least that many items in the list section. The default value is now changed to `10+`.
+  ```sh
+  # You will only see the input section which takes 3 lines
+  fzf --style=full --height 1% --min-height 3
+
+  # You will see 3 items in the list section
+  fzf --style full --height 1% --min-height 3+
+  ```
+    - Shell integration scripts were updated to use `--min-height 20+` by default
+- `--header-lines` will be displayed at the top in `reverse-list` layout
+- Added `bell` action to ring the terminal bell
+  ```sh
+  # Press CTRL-Y to copy the current line to the clipboard and ring the bell
+  fzf --bind 'ctrl-y:execute-silent(echo -n {} | pbcopy)+bell'
+  ```
+- Added `toggle-bind` action
+- Bug fixes and improvements
+- Fixed fish script to support fish 3.1.2 or later (@bitraid)
+
 0.58.0
 ------
 _Release highlights: https://junegunn.github.io/fzf/releases/0.58.0/_
@@ -269,7 +1121,7 @@ _Release highlights: https://junegunn.github.io/fzf/releases/0.54.0/_
 - 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 
+  # `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' \

Dockerfile

@@ -1,5 +1,5 @@
-FROM ubuntu:24.04
-RUN apt-get update -y && apt install -y git make golang zsh fish ruby tmux
+FROM rubylang/ruby:3.4.1-noble
+RUN apt-get update -y && apt install -y git make golang zsh fish tmux
 RUN gem install --no-document -v 5.22.3 minitest
 RUN echo '. /usr/share/bash-completion/completions/git' >> ~/.bashrc
 RUN echo '. ~/.bashrc' >> ~/.bash_profile
@@ -9,4 +9,4 @@ RUN rm -f /etc/bash.bashrc
 COPY . /fzf
 RUN cd /fzf && make install && ./install --all
 ENV LANG=C.UTF-8
-CMD ["bash", "-ic", "tmux new 'set -o pipefail; ruby /fzf/test/test_go.rb | tee out && touch ok' && cat out && [ -e ok ]"]
+CMD ["bash", "-ic", "tmux new 'set -o pipefail; ruby /fzf/test/runner.rb | tee out && touch ok' && cat out && [ -e ok ]"]

Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'minitest', '5.25.4'
+gem 'rubocop', '1.71.0'
+gem 'rubocop-minitest', '0.36.0'
+gem 'rubocop-performance', '1.23.1'

Gemfile.lock

@@ -0,0 +1,47 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    json (2.9.1)
+    language_server-protocol (3.17.0.3)
+    minitest (5.25.4)
+    parallel (1.26.3)
+    parser (3.3.7.0)
+      ast (~> 2.4.1)
+      racc
+    racc (1.8.1)
+    rainbow (3.1.1)
+    regexp_parser (2.10.0)
+    rubocop (1.71.0)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.36.2, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.37.0)
+      parser (>= 3.3.1.0)
+    rubocop-minitest (0.36.0)
+      rubocop (>= 1.61, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    rubocop-performance (1.23.1)
+      rubocop (>= 1.48.1, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (2.6.0)
+
+PLATFORMS
+  arm64-darwin-23
+  ruby
+
+DEPENDENCIES
+  minitest (= 5.25.4)
+  rubocop (= 1.71.0)
+  rubocop-minitest (= 0.36.0)
+  rubocop-performance (= 1.23.1)
+
+BUNDLED WITH
+   2.6.2

LICENSE

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

Makefile

@@ -1,10 +1,20 @@
 GO             ?= go
+DOCKER         ?= docker
 GOOS           ?= $(shell $(GO) env GOOS)
 
 MAKEFILE       := $(realpath $(lastword $(MAKEFILE_LIST)))
 ROOT_DIR       := $(shell dirname $(MAKEFILE))
 SOURCES        := $(wildcard *.go src/*.go src/*/*.go shell/*sh man/man1/*.1) $(MAKEFILE)
 
+BASH_SCRIPTS   := $(ROOT_DIR)/bin/fzf-preview.sh \
+					$(ROOT_DIR)/bin/fzf-tmux \
+					$(ROOT_DIR)/install \
+					$(ROOT_DIR)/uninstall \
+					$(ROOT_DIR)/shell/common.sh \
+					$(ROOT_DIR)/shell/update.sh \
+					$(ROOT_DIR)/shell/completion.bash \
+					$(ROOT_DIR)/shell/key-bindings.bash
+
 ifdef FZF_VERSION
 VERSION        := $(FZF_VERSION)
 else
@@ -43,6 +53,8 @@ ifeq ($(UNAME_M),x86_64)
 	BINARY := $(BINARY64)
 else ifeq ($(UNAME_M),amd64)
 	BINARY := $(BINARY64)
+else ifeq ($(UNAME_M),i86pc)
+	BINARY := $(BINARY64)
 else ifeq ($(UNAME_M),s390x)
 	BINARY := $(BINARYS390)
 else ifeq ($(UNAME_M),i686)
@@ -82,12 +94,20 @@ test: $(SOURCES)
 				github.com/junegunn/fzf/src/tui \
 				github.com/junegunn/fzf/src/util
 
+itest:
+	ruby test/runner.rb
+
 bench:
 	cd src && SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" -run=Bench -bench=. -benchmem
 
-lint: $(SOURCES) test/test_go.rb
+lint: $(SOURCES) test/*.rb test/lib/*.rb ${BASH_SCRIPTS}
 	[ -z "$$(gofmt -s -d src)" ] || (gofmt -s -d src; exit 1)
-	rubocop --require rubocop-minitest --require rubocop-performance
+	bundle exec rubocop -a --require rubocop-minitest --require rubocop-performance
+	shell/update.sh --check ${BASH_SCRIPTS}
+
+fmt: $(SOURCES) $(BASH_SCRIPTS)
+	gofmt -s -w src
+	shell/update.sh ${BASH_SCRIPTS}
 
 install: bin/fzf
 
@@ -175,15 +195,15 @@ bin/fzf: target/$(BINARY) | bin
 	cp -f target/$(BINARY) bin/fzf
 
 docker:
-	docker build -t fzf-ubuntu .
-	docker run -it fzf-ubuntu tmux
+	$(DOCKER) build -t fzf-ubuntu .
+	$(DOCKER) run -it fzf-ubuntu tmux
 
 docker-test:
-	docker build -t fzf-ubuntu .
-	docker run -it fzf-ubuntu
+	$(DOCKER) build -t fzf-ubuntu .
+	$(DOCKER) run -it fzf-ubuntu
 
 update:
 	$(GO) get -u
 	$(GO) mod tidy
 
-.PHONY: all generate build release test bench lint install clean docker docker-test update
+.PHONY: all generate build release test itest bench lint install clean docker docker-test update fmt

README-VIM.md

@@ -155,6 +155,7 @@ let g:fzf_layout = { 'window': '10new' }
 let g:fzf_colors =
 \ { 'fg':      ['fg', 'Normal'],
   \ 'bg':      ['bg', 'Normal'],
+  \ 'query':   ['fg', 'Normal'],
   \ 'hl':      ['fg', 'Comment'],
   \ 'fg+':     ['fg', 'CursorLine', 'CursorColumn', 'Normal'],
   \ 'bg+':     ['bg', 'CursorLine', 'CursorColumn'],
@@ -492,4 +493,4 @@ autocmd  FileType fzf set laststatus=0 noshowmode noruler
 
 The MIT License (MIT)
 
-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2026 Junegunn Choi

SECURITY.md

@@ -0,0 +1,33 @@
+# Security Reporting
+
+If you wish to report a security vulnerability privately, we appreciate your diligence. Please follow the guidelines below to submit your report.
+
+## Reporting
+
+To report a security vulnerability, please provide the following information:
+
+1. **PROJECT**
+   - https://github.com/junegunn/fzf
+
+2. **PUBLIC**
+   - Indicate whether this vulnerability has already been publicly discussed or disclosed.
+   - If so, provide relevant links.
+
+3. **DESCRIPTION**
+   - Provide a detailed description of the security vulnerability.
+   - Include as much information as possible to help us understand and address the issue.
+
+Send this information, along with any additional relevant details, to <junegunn.c AT gmail DOT com>.
+
+## Confidentiality
+
+We kindly ask you to keep the report confidential until a public announcement is made.
+
+## Notes
+
+- Vulnerabilities will be handled on a best-effort basis.
+- You may request an advance copy of the patched release, but we cannot guarantee early access before the public release.
+- You will be notified via email simultaneously with the public announcement.
+- We will respond within a few weeks to confirm whether your report has been accepted or rejected.
+
+Thank you for helping to improve the security of our project!

bin/fzf-preview.sh

@@ -49,23 +49,23 @@ if [[ ! $type =~ image/ ]]; then
 fi
 
 dim=${FZF_PREVIEW_COLUMNS}x${FZF_PREVIEW_LINES}
-if [[ $dim = x ]]; then
+if [[ $dim == x ]]; then
   dim=$(stty size < /dev/tty | awk '{print $2 "x" $1}')
-elif ! [[ $KITTY_WINDOW_ID ]] && (( FZF_PREVIEW_TOP + FZF_PREVIEW_LINES == $(stty size < /dev/tty | awk '{print $1}') )); then
+elif ! [[ $KITTY_WINDOW_ID ]] && ((FZF_PREVIEW_TOP + FZF_PREVIEW_LINES == $(stty size < /dev/tty | awk '{print $1}'))); then
   # Avoid scrolling issue when the Sixel image touches the bottom of the screen
   # * https://github.com/junegunn/fzf/issues/2544
   dim=${FZF_PREVIEW_COLUMNS}x$((FZF_PREVIEW_LINES - 1))
 fi
 
-# 1. Use kitty icat on kitty terminal
-if [[ $KITTY_WINDOW_ID ]]; then
+# 1. Use icat (from Kitty) if kitten is installed
+if [[ $KITTY_WINDOW_ID ]] || [[ $GHOSTTY_RESOURCES_DIR ]] && command -v kitten > /dev/null; then
   # 1. 'memory' is the fastest option but if you want the image to be scrollable,
   #    you have to use 'stream'.
   #
   # 2. The last line of the output is the ANSI reset code without newline.
   #    This confuses fzf and makes it render scroll offset indicator.
   #    So we remove the last line and append the reset code to its previous line.
-  kitty icat --clear --transfer-mode=memory --unicode-placeholder --stdin=no --place="$dim@0x0" "$file" | sed '$d' | sed $'$s/$/\e[m/'
+  kitten icat --clear --transfer-mode=memory --unicode-placeholder --stdin=no --place="$dim@0x0" "$file" | sed '$d' | sed $'$s/$/\e[m/'
 
 # 2. Use chafa with Sixel output
 elif command -v chafa > /dev/null; then

bin/fzf-tmux

@@ -8,7 +8,7 @@ fail() {
 }
 
 fzf="$(command which fzf)" || fzf="$(dirname "$0")/fzf"
-[[ -x "$fzf" ]] || fail 'fzf executable not found'
+[[ -x $fzf ]] || fail 'fzf executable not found'
 
 args=()
 opt=""
@@ -16,8 +16,8 @@ skip=""
 swap=""
 close=""
 term=""
-[[ -n "$LINES" ]] && lines=$LINES || lines=$(tput lines) || lines=$(tmux display-message -p "#{pane_height}")
-[[ -n "$COLUMNS" ]] && columns=$COLUMNS || columns=$(tput cols) || columns=$(tmux display-message -p "#{pane_width}")
+[[ -n $LINES ]] && lines=$LINES || lines=$(tput lines) || lines=$(tmux display-message -p "#{pane_height}")
+[[ -n $COLUMNS ]] && columns=$COLUMNS || columns=$(tput cols) || columns=$(tmux display-message -p "#{pane_width}")
 
 tmux_version=$(tmux -V | sed 's/[^0-9.]//g')
 tmux_32=$(awk '{print ($1 >= 3.2)}' <<< "$tmux_version" 2> /dev/null || bc -l <<< "$tmux_version >= 3.2")
@@ -47,7 +47,7 @@ help() {
 while [[ $# -gt 0 ]]; do
   arg="$1"
   shift
-  [[ -z "$skip" ]] && case "$arg" in
+  [[ -z $skip ]] && case "$arg" in
     -)
       term=1
       ;;
@@ -58,19 +58,19 @@ while [[ $# -gt 0 ]]; do
       echo "fzf-tmux (with fzf $("$fzf" --version))"
       exit
       ;;
-    -p*|-w*|-h*|-x*|-y*|-d*|-u*|-r*|-l*)
-      if [[ "$arg" =~ ^-[pwhxy] ]]; then
-        [[ "$opt" =~ "-E" ]] || opt="-E"
-      elif [[ "$arg" =~ ^.[lr] ]]; then
+    -p* | -w* | -h* | -x* | -y* | -d* | -u* | -r* | -l*)
+      if [[ $arg =~ ^-[pwhxy] ]]; then
+        [[ $opt =~ "-E" ]] || opt="-E"
+      elif [[ $arg =~ ^.[lr] ]]; then
         opt="-h"
-        if [[ "$arg" =~ ^.l ]]; then
+        if [[ $arg =~ ^.l ]]; then
           opt="$opt -d"
           swap="; swap-pane -D ; select-pane -L"
           close="; tmux swap-pane -D"
         fi
       else
         opt=""
-        if [[ "$arg" =~ ^.u ]]; then
+        if [[ $arg =~ ^.u ]]; then
           opt="$opt -d"
           swap="; swap-pane -D ; select-pane -U"
           close="; tmux swap-pane -D"
@@ -79,7 +79,7 @@ while [[ $# -gt 0 ]]; do
       if [[ ${#arg} -gt 2 ]]; then
         size="${arg:2}"
       else
-        if [[ "$1" =~ ^[0-9%,]+$ ]] || [[ "$1" =~ ^[A-Z]$ ]]; then
+        if [[ $1 =~ ^[0-9%,]+$ ]] || [[ $1 =~ ^[A-Z]$ ]]; then
           size="$1"
           shift
         else
@@ -87,37 +87,37 @@ while [[ $# -gt 0 ]]; do
         fi
       fi
 
-      if [[ "$arg" =~ ^-p ]]; then
-        if [[ -n "$size" ]]; then
+      if [[ $arg =~ ^-p ]]; then
+        if [[ -n $size ]]; then
           w=${size%%,*}
           h=${size##*,}
           opt="$opt -w$w -h$h"
         fi
-      elif [[ "$arg" =~ ^-[whxy] ]]; then
+      elif [[ $arg =~ ^-[whxy] ]]; then
         opt="$opt ${arg:0:2}$size"
-      elif [[ "$size" =~ %$ ]]; then
-        size=${size:0:((${#size}-1))}
-        if [[ $tmux_32 = 1 ]]; then
-          if [[ -n "$swap" ]]; then
-            opt="$opt -l $(( 100 - size ))%"
+      elif [[ $size =~ %$ ]]; then
+        size=${size:0:${#size}-1}
+        if [[ $tmux_32 == 1 ]]; then
+          if [[ -n $swap ]]; then
+            opt="$opt -l $((100 - size))%"
           else
             opt="$opt -l $size%"
           fi
         else
-          if [[ -n "$swap" ]]; then
-            opt="$opt -p $(( 100 - size ))"
+          if [[ -n $swap ]]; then
+            opt="$opt -p $((100 - size))"
           else
             opt="$opt -p $size"
           fi
         fi
       else
-        if [[ -n "$swap" ]]; then
-          if [[ "$arg" =~ ^.l ]]; then
+        if [[ -n $swap ]]; then
+          if [[ $arg =~ ^.l ]]; then
             max=$columns
           else
             max=$lines
           fi
-          size=$(( max - size ))
+          size=$((max - size))
           [[ $size -lt 0 ]] && size=0
           opt="$opt -l $size"
         else
@@ -135,10 +135,10 @@ while [[ $# -gt 0 ]]; do
       args+=("$arg")
       ;;
   esac
-  [[ -n "$skip" ]] && args+=("$arg")
+  [[ -n $skip ]] && args+=("$arg")
 done
 
-if [[ -z "$TMUX" ]]; then
+if [[ -z $TMUX ]]; then
   "$fzf" "${args[@]}"
   exit $?
 fi
@@ -149,7 +149,7 @@ fi
 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
+if [[ ! $opt =~ "-E" ]] && tmux list-panes -F '#F' | grep -q Z; then
   zoomed_without_popup=1
   original_window=$(tmux display-message -p "#{window_id}")
   tmp_window=$(tmux new-window -d -P -F "#{window_id}" "bash -c 'while :; do for c in \\| / - '\\;' do sleep 0.2; printf \"\\r\$c fzf-tmux is running\\r\"; done; done'")
@@ -159,28 +159,27 @@ fi
 set -e
 
 # Clean up named pipes on exit
-id=$RANDOM
-argsf="${TMPDIR:-/tmp}/fzf-args-$id"
-fifo1="${TMPDIR:-/tmp}/fzf-fifo1-$id"
-fifo2="${TMPDIR:-/tmp}/fzf-fifo2-$id"
-fifo3="${TMPDIR:-/tmp}/fzf-fifo3-$id"
+tmpdir=$(mktemp -d "${TMPDIR:-/tmp}/fzf-tmux-XXXXXX")
+argsf="$tmpdir/args"
+fifo1="$tmpdir/fifo1"
+fifo2="$tmpdir/fifo2"
+fifo3="$tmpdir/fifo3"
 if tmux_win_opts=$(tmux show-options -p remain-on-exit \; show-options -p synchronize-panes 2> /dev/null); then
-  tmux_win_opts=( $(sed '/ off/d; s/synchronize-panes/set-option -p synchronize-panes/; s/remain-on-exit/set-option -p remain-on-exit/; s/$/ \\;/' <<< "$tmux_win_opts") )
+  tmux_win_opts=($(sed '/ off/d; s/synchronize-panes/set-option -p synchronize-panes/; s/remain-on-exit/set-option -p remain-on-exit/; s/$/ \\;/' <<< "$tmux_win_opts"))
   tmux_off_opts='; set-option -p synchronize-panes off ; set-option -p remain-on-exit off'
 else
-  tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
+  tmux_win_opts=($(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/'))
   tmux_off_opts='; set-window-option synchronize-panes off ; set-window-option remain-on-exit off'
 fi
 cleanup() {
-  \rm -f $argsf $fifo1 $fifo2 $fifo3
-
+  \rm -rf "$tmpdir"
   # Restore tmux window options
-  if [[ "${#tmux_win_opts[@]}" -gt 1 ]]; then
+  if [[ ${#tmux_win_opts[@]} -gt 1 ]]; then
     eval "tmux ${tmux_win_opts[*]}"
   fi
 
   # Remove temp window if we were zoomed without popup options
-  if [[ -n "$zoomed_without_popup" ]]; then
+  if [[ -n $zoomed_without_popup ]]; then
     tmux display-message -p "#{window_id}" > /dev/null
     tmux swap-pane -t $original_window \; \
       select-window -t $original_window \; \
@@ -196,11 +195,11 @@ cleanup() {
 trap 'cleanup 1' SIGUSR1
 trap 'cleanup' EXIT
 
-envs="export TERM=$TERM "
-if [[ "$opt" =~ "-E" ]]; then
-  if [[ $tmux_version = 3.2 ]]; then
+envs="export TERM=$(printf %q "$TERM") "
+if [[ $opt =~ "-E" ]]; then
+  if [[ $tmux_version == 3.2 ]]; then
     FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
-  elif [[ $tmux_32 = 1 ]]; then
+  elif [[ $tmux_32 == 1 ]]; then
     FZF_DEFAULT_OPTS="--border $FZF_DEFAULT_OPTS"
     opt="-B $opt"
   else
@@ -211,8 +210,8 @@ fi
 envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
 envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
 envs="$envs FZF_DEFAULT_OPTS_FILE=$(printf %q "$FZF_DEFAULT_OPTS_FILE")"
-[[ -n "$RUNEWIDTH_EASTASIAN" ]] && envs="$envs RUNEWIDTH_EASTASIAN=$(printf %q "$RUNEWIDTH_EASTASIAN")"
-[[ -n "$BAT_THEME" ]] && envs="$envs BAT_THEME=$(printf %q "$BAT_THEME")"
+[[ -n $RUNEWIDTH_EASTASIAN ]] && envs="$envs RUNEWIDTH_EASTASIAN=$(printf %q "$RUNEWIDTH_EASTASIAN")"
+[[ -n $BAT_THEME ]] && envs="$envs BAT_THEME=$(printf %q "$BAT_THEME")"
 echo "$envs;" > "$argsf"
 
 # Build arguments to fzf
@@ -224,9 +223,9 @@ close="; trap - EXIT SIGINT SIGTERM $close"
 
 export TMUX=$(cut -d , -f 1,2 <<< "$TMUX")
 mkfifo -m o+w $fifo2
-if [[ "$opt" =~ "-E" ]]; then
+if [[ $opt =~ "-E" ]]; then
   cat $fifo2 &
-  if [[ -n "$term" ]] || [[ -t 0 ]]; then
+  if [[ -n $term ]] || [[ -t 0 ]]; then
     cat <<< "\"$fzf\" $opts > $fifo2; out=\$? $close; exit \$out" >> $argsf
   else
     mkfifo $fifo1
@@ -239,7 +238,7 @@ if [[ "$opt" =~ "-E" ]]; then
 fi
 
 mkfifo -m o+w $fifo3
-if [[ -n "$term" ]] || [[ -t 0 ]]; then
+if [[ -n $term ]] || [[ -t 0 ]]; then
   cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" >> $argsf
 else
   mkfifo $fifo1
@@ -249,6 +248,9 @@ fi
 tmux \
   split-window -c "$PWD" $opt "bash -c 'exec -a fzf bash $argsf'" $swap \
   $tmux_off_opts \
-  > /dev/null 2>&1 || { "$fzf" "${args[@]}"; exit $?; }
+  > /dev/null 2>&1 || {
+  "$fzf" "${args[@]}"
+  exit $?
+}
 cat $fifo2
 exit "$(cat $fifo3)"

doc/fzf.txt

@@ -112,7 +112,7 @@ the whole if we start off with `:FZF` command.
     " Bang version starts fzf in fullscreen mode
     :FZF!
 <
-Similarly to {ctrlp.vim}{3}, use enter key, CTRL-T, CTRL-X or CTRL-V to open
+Similarly to {ctrlp.vim}{3}, use Enter key, CTRL-T, CTRL-X or CTRL-V to open
 selected files in the current window, in new tabs, in horizontal splits, or in
 vertical splits respectively.
 
@@ -218,7 +218,6 @@ list:
   `fg`   /  `bg`   /  `hl`         | Item (foreground / background / highlight)
   `fg+`  /  `bg+`  /  `hl+`        | Current item (foreground / background / highlight)
   `preview-fg`  /  `preview-bg`  | Preview window text and background
-  `hl`   /  `hl+`                | Highlighted substrings (normal / current)
   `gutter`                     | Background of the gutter on the left
   `pointer`                    | Pointer to the current line ( `>` )
   `marker`                     | Multi-select marker ( `>` )
@@ -229,7 +228,6 @@ list:
   `query`                      | Query string
   `disabled`                   | Query string when search is disabled
   `prompt`                     | Prompt before query ( `> ` )
-  `pointer`                    | Pointer to the current line ( `>` )
  ----------------------------+------------------------------------------------------
  - `component` specifies the component (`fg` / `bg`) from which to extract the
    color when considering each of the following highlight groups
@@ -245,7 +243,7 @@ if it exists, - otherwise use the `fg` attribute of the `Comment` highlight
 group if it exists, - otherwise fall back to the default color settings for
 the prompt.
 
-You can examine the color option generated according the setting by printing
+You can examine the color option generated according to the setting by printing
 the result of `fzf#wrap()` function like so:
 >
     :echo fzf#wrap()
@@ -503,7 +501,7 @@ LICENSE                                                            *fzf-license*
 
 The MIT License (MIT)
 
-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2026 Junegunn Choi
 
 ==============================================================================
 vim:tw=78:sw=2:ts=2:ft=help:norl:nowrap:

go.mod

@@ -1,20 +1,20 @@
 module github.com/junegunn/fzf
 
 require (
-	github.com/charlievieth/fastwalk v1.0.9
-	github.com/gdamore/tcell/v2 v2.8.1
-	github.com/junegunn/go-shellwords v0.0.0-20240813092932-a62c48c52e97
+	github.com/charlievieth/fastwalk v1.0.14
+	github.com/gdamore/tcell/v2 v2.9.0
+	github.com/junegunn/go-shellwords v0.0.0-20250127100254-2aa3b3277741
 	github.com/mattn/go-isatty v0.0.20
 	github.com/rivo/uniseg v0.4.7
-	golang.org/x/sys v0.29.0
-	golang.org/x/term v0.28.0
+	golang.org/x/sys v0.35.0
+	golang.org/x/term v0.34.0
 )
 
 require (
 	github.com/gdamore/encoding v1.0.1 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
-	golang.org/x/text v0.21.0 // indirect
+	golang.org/x/text v0.28.0 // indirect
 )
 
-go 1.20
+go 1.23.0

go.sum

@@ -1,12 +1,11 @@
-github.com/charlievieth/fastwalk v1.0.9 h1:Odb92AfoReO3oFBfDGT5J+nwgzQPF/gWAw6E6/lkor0=
-github.com/charlievieth/fastwalk v1.0.9/go.mod h1:yGy1zbxog41ZVMcKA/i8ojXLFsuayX5VvwhQVoj9PBI=
+github.com/charlievieth/fastwalk v1.0.14 h1:3Eh5uaFGwHZd8EGwTjJnSpBkfwfsak9h6ICgnWlhAyg=
+github.com/charlievieth/fastwalk v1.0.14/go.mod h1:diVcUreiU1aQ4/Wu3NbxxH4/KYdKpLDojrQ1Bb2KgNY=
 github.com/gdamore/encoding v1.0.1 h1:YzKZckdBL6jVt2Gc+5p82qhrGiqMdG/eNs6Wy0u3Uhw=
 github.com/gdamore/encoding v1.0.1/go.mod h1:0Z0cMFinngz9kS1QfMjCP8TY7em3bZYeeklsSDPivEo=
-github.com/gdamore/tcell/v2 v2.8.1 h1:KPNxyqclpWpWQlPLx6Xui1pMk8S+7+R37h3g07997NU=
-github.com/gdamore/tcell/v2 v2.8.1/go.mod h1:bj8ori1BG3OYMjmb3IklZVWfZUJ1UBQt9JXrOCOhGWw=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/junegunn/go-shellwords v0.0.0-20240813092932-a62c48c52e97 h1:rqzLixVo1c/GQW6px9j1xQmlvQIn+lf/V6M1UQ7IFzw=
-github.com/junegunn/go-shellwords v0.0.0-20240813092932-a62c48c52e97/go.mod h1:6EILKtGpo5t+KLb85LNZLAF6P9LKp78hJI80PXMcn3c=
+github.com/gdamore/tcell/v2 v2.9.0 h1:N6t+eqK7/xwtRPwxzs1PXeRWnm0H9l02CrgJ7DLn1ys=
+github.com/gdamore/tcell/v2 v2.9.0/go.mod h1:8/ZoqM9rxzYphT9tH/9LnunhV9oPBqwS8WHGYm5nrmo=
+github.com/junegunn/go-shellwords v0.0.0-20250127100254-2aa3b3277741 h1:7dYDtfMDfKzjT+DVfIS4iqknSEKtZpEcXtu6vuaasHs=
+github.com/junegunn/go-shellwords v0.0.0-20250127100254-2aa3b3277741/go.mod h1:6EILKtGpo5t+KLb85LNZLAF6P9LKp78hJI80PXMcn3c=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
@@ -14,35 +13,20 @@ github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
-golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
-golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
-golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
-golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
-golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -50,36 +34,22 @@ golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 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.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
-golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
-golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
-golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
+golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
+golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
-golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
-golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

install

@@ -2,7 +2,7 @@
 
 set -u
 
-version=0.58.0
+version=0.72.0
 auto_completion=
 key_bindings=
 update_config=2
@@ -46,16 +46,16 @@ for opt in "$@"; do
       prefix_expand=${XDG_CONFIG_HOME:-$HOME/.config}/fzf/fzf
       mkdir -p "${XDG_CONFIG_HOME:-$HOME/.config}/fzf"
       ;;
-    --key-bindings)    key_bindings=1    ;;
-    --no-key-bindings) key_bindings=0    ;;
-    --completion)      auto_completion=1 ;;
-    --no-completion)   auto_completion=0 ;;
-    --update-rc)       update_config=1   ;;
-    --no-update-rc)    update_config=0   ;;
-    --bin)             ;;
-    --no-bash)         shells=${shells/bash/} ;;
-    --no-zsh)          shells=${shells/zsh/} ;;
-    --no-fish)         shells=${shells/fish/} ;;
+    --key-bindings) key_bindings=1 ;;
+    --no-key-bindings) key_bindings=0 ;;
+    --completion) auto_completion=1 ;;
+    --no-completion) auto_completion=0 ;;
+    --update-rc) update_config=1 ;;
+    --no-update-rc) update_config=0 ;;
+    --bin) ;;
+    --no-bash) shells=${shells/bash/} ;;
+    --no-zsh) shells=${shells/zsh/} ;;
+    --no-fish) shells=${shells/fish/} ;;
     *)
       echo "unknown option: $opt"
       help
@@ -104,7 +104,7 @@ check_binary() {
 
 link_fzf_in_path() {
   if which_fzf="$(command -v fzf)"; then
-    echo "  - Found in \$PATH"
+    echo '  - Found in $PATH'
     echo "  - Creating symlink: bin/fzf -> $which_fzf"
     (cd "$fzf_base"/bin && rm -f fzf && ln -sf "$which_fzf" fzf)
     check_binary && return
@@ -112,24 +112,29 @@ link_fzf_in_path() {
   return 1
 }
 
+tar_opts="-xzf -"
+if tar --no-same-owner -tf /dev/null 2> /dev/null; then
+  tar_opts="--no-same-owner $tar_opts"
+fi
+
 try_curl() {
   command -v curl > /dev/null &&
-  if [[ $1 =~ tar.gz$ ]]; then
-    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"
-  fi
+    if [[ $1 =~ tar.gz$ ]]; then
+      curl -fL $1 | tar $tar_opts
+    else
+      local temp=${TMPDIR:-/tmp}/fzf.zip
+      curl -fLo "$temp" $1 && unzip -o "$temp" && rm -f "$temp"
+    fi
 }
 
 try_wget() {
   command -v wget > /dev/null &&
-  if [[ $1 =~ tar.gz$ ]]; then
-    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"
-  fi
+    if [[ $1 =~ tar.gz$ ]]; then
+      wget -O - $1 | tar $tar_opts
+    else
+      local temp=${TMPDIR:-/tmp}/fzf.zip
+      wget -O "$temp" $1 && unzip -o "$temp" && rm -f "$temp"
+    fi
 }
 
 download() {
@@ -164,28 +169,30 @@ download() {
 }
 
 # Try to download binary executable
-archi=$(uname -sm)
+archi=$(uname -smo 2> /dev/null || uname -sm)
 binary_available=1
 binary_error=""
 case "$archi" in
-  Darwin\ arm64)      download fzf-$version-darwin_arm64.tar.gz  ;;
-  Darwin\ x86_64)     download fzf-$version-darwin_amd64.tar.gz  ;;
-  Linux\ armv5*)      download fzf-$version-linux_armv5.tar.gz   ;;
-  Linux\ armv6*)      download fzf-$version-linux_armv6.tar.gz   ;;
-  Linux\ armv7*)      download fzf-$version-linux_armv7.tar.gz   ;;
-  Linux\ armv8*)      download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ aarch64*)    download fzf-$version-linux_arm64.tar.gz   ;;
-  Linux\ loongarch64) download fzf-$version-linux_loong64.tar.gz ;;
-  Linux\ ppc64le)     download fzf-$version-linux_ppc64le.tar.gz ;;
-  Linux\ *64)         download fzf-$version-linux_amd64.tar.gz   ;;
-  Linux\ s390x)       download fzf-$version-linux_s390x.tar.gz   ;;
-  FreeBSD\ *64)       download fzf-$version-freebsd_amd64.tar.gz ;;
-  OpenBSD\ *64)       download fzf-$version-openbsd_amd64.tar.gz ;;
-  CYGWIN*\ *64)       download fzf-$version-windows_amd64.zip    ;;
-  MINGW*\ *64)        download fzf-$version-windows_amd64.zip    ;;
-  MSYS*\ *64)         download fzf-$version-windows_amd64.zip    ;;
-  Windows*\ *64)      download fzf-$version-windows_amd64.zip    ;;
-  *)                  binary_available=0 binary_error=1          ;;
+  Darwin\ arm64*) download fzf-$version-darwin_arm64.tar.gz ;;
+  Darwin\ x86_64*) download fzf-$version-darwin_amd64.tar.gz ;;
+  Linux\ armv5*) download fzf-$version-linux_armv5.tar.gz ;;
+  Linux\ armv6*) download fzf-$version-linux_armv6.tar.gz ;;
+  Linux\ armv7*) download fzf-$version-linux_armv7.tar.gz ;;
+  Linux\ armv8*) download fzf-$version-linux_arm64.tar.gz ;;
+  Linux\ aarch64\ Android) download fzf-$version-android_arm64.tar.gz ;;
+  Linux\ aarch64*) download fzf-$version-linux_arm64.tar.gz ;;
+  Linux\ loongarch64*) download fzf-$version-linux_loong64.tar.gz ;;
+  Linux\ riscv64*) download fzf-$version-linux_riscv64.tar.gz ;;
+  Linux\ ppc64le*) download fzf-$version-linux_ppc64le.tar.gz ;;
+  Linux\ *64*) download fzf-$version-linux_amd64.tar.gz ;;
+  Linux\ s390x*) download fzf-$version-linux_s390x.tar.gz ;;
+  FreeBSD\ *64*) download fzf-$version-freebsd_amd64.tar.gz ;;
+  OpenBSD\ *64*) download fzf-$version-openbsd_amd64.tar.gz ;;
+  CYGWIN*\ *64*) download fzf-$version-windows_amd64.zip ;;
+  MINGW*\ *64*) download fzf-$version-windows_amd64.zip ;;
+  MSYS*\ *64*) download fzf-$version-windows_amd64.zip ;;
+  Windows*\ *64*) download fzf-$version-windows_amd64.zip ;;
+  *) binary_available=0 binary_error=1 ;;
 esac
 
 cd "$fzf_base"
@@ -214,7 +221,7 @@ if [ -n "$binary_error" ]; then
   fi
 fi
 
-[[ "$*" =~ "--bin" ]] && exit 0
+[[ $* =~ "--bin" ]] && exit 0
 
 for s in $shells; do
   if ! command -v "$s" > /dev/null; then
@@ -241,16 +248,16 @@ fi
 
 echo
 for shell in $shells; do
-  [[ "$shell" = fish ]] && continue
+  fzf_completion="source \"$fzf_base/shell/completion.${shell}\""
+  fzf_key_bindings="source \"$fzf_base/shell/key-bindings.${shell}\""
+  [[ $shell == fish ]] && continue
   src=${prefix_expand}.${shell}
   echo -n "Generate $src ... "
 
-  fzf_completion="source \"$fzf_base/shell/completion.${shell}\""
   if [ $auto_completion -eq 0 ]; then
     fzf_completion="# $fzf_completion"
   fi
 
-  fzf_key_bindings="source \"$fzf_base/shell/key-bindings.${shell}\""
   if [ $key_bindings -eq 0 ]; then
     fzf_key_bindings="# $fzf_key_bindings"
   fi
@@ -265,7 +272,7 @@ fi
 EOF
 
   if [[ $auto_completion -eq 1 ]] && [[ $key_bindings -eq 1 ]]; then
-    if [[ "$shell" = zsh ]]; then
+    if [[ $shell == zsh ]]; then
       echo "source <(fzf --$shell)" >> "$src"
     else
       echo "eval \"\$(fzf --$shell)\"" >> "$src"
@@ -285,7 +292,7 @@ EOF
 done
 
 # fish
-if [[ "$shells" =~ fish ]]; then
+if [[ $shells =~ fish ]]; then
   echo -n "Update fish_user_paths ... "
   fish << EOF
   echo \$fish_user_paths | \grep "$fzf_base"/bin > /dev/null
@@ -300,15 +307,16 @@ append_line() {
   line="$2"
   file="$3"
   pat="${4:-}"
+  at_lno="${5:-}"
   lines=""
 
   echo "Update $file:"
   echo "  - $line"
   if [ -f "$file" ]; then
-    if [ $# -lt 4 ]; then
-      lines=$(\grep -nF "$line" "$file")
-    else
+    if [[ -n $pat ]]; then
       lines=$(\grep -nF "$pat" "$file")
+    else
+      lines=$(\grep -nF "${line#"${line%%[![:space:]]*}"}" "$file")
     fi
   fi
 
@@ -317,17 +325,21 @@ append_line() {
     sed 's/^/        Line /' <<< "$lines"
 
     update=0
-    if ! \grep -qv "^[0-9]*:[[:space:]]*#" <<< "$lines" ; then
+    if ! \grep -qv "^[0-9]*:[[:space:]]*#" <<< "$lines"; then
       echo "    - But they all seem to be commented"
-      ask  "    - Continue modifying $file?"
+      ask "    - Continue modifying $file?"
       update=$?
     fi
   fi
 
   set -e
   if [ "$update" -eq 1 ]; then
-    [ -f "$file" ] && echo >> "$file"
-    echo "$line" >> "$file"
+    if [[ -z $at_lno ]]; then
+      [ -f "$file" ] && echo >> "$file"
+      echo "$line" >> "$file"
+    else
+      sed -i.~fzf_bak "${at_lno}a\\"$'\n'"$line" "$file" && rm "$file.~fzf_bak"
+    fi
     echo "    + Added"
   else
     echo "    ~ Skipped"
@@ -355,43 +367,84 @@ if [ $update_config -eq 2 ]; then
 fi
 echo
 for shell in $shells; do
-  [[ "$shell" = fish ]] && continue
+  [[ $shell == fish ]] && continue
   [ $shell = zsh ] && dest=${ZDOTDIR:-~}/.zshrc || dest=~/.bashrc
   append_line $update_config "[ -f ${prefix}.${shell} ] && source ${prefix}.${shell}" "$dest" "${prefix}.${shell}"
 done
 
-if [ $key_bindings -eq 1 ] && [[ "$shells" =~ fish ]]; then
+if [[ $shells =~ fish ]]; then
   bind_file="${fish_dir}/functions/fish_user_key_bindings.fish"
   if [ ! -e "$bind_file" ]; then
-    mkdir -p "${fish_dir}/functions"
-    create_file "$bind_file" \
-      'function fish_user_key_bindings' \
-      '  fzf --fish | source' \
-      'end'
+    if [[ $key_bindings -eq 1 || $auto_completion -eq 1 ]]; then
+      mkdir -p "${fish_dir}/functions"
+      if [[ $key_bindings -eq 1 && $auto_completion -eq 1 ]]; then
+        create_file "$bind_file" \
+          'function fish_user_key_bindings' \
+          '  fzf --fish | source' \
+          'end'
+      elif [[ $key_bindings -eq 1 ]]; then
+        create_file "$bind_file" \
+          'function fish_user_key_bindings' \
+          "  $fzf_key_bindings" \
+          'end'
+      elif [[ $auto_completion -eq 1 ]]; then
+        create_file "$bind_file" \
+          'function fish_user_key_bindings' \
+          "  $fzf_completion" \
+          'end'
+      fi
+      lno_func=$(\grep -nF "function fish_user_key_bindings" "$bind_file" | sed 's/:.*//' | tr '\n' ' ')
+    else
+      lno_func=0
+    fi
   else
     echo "Check $bind_file:"
-    lno=$(\grep -nF "fzf_key_bindings" "$bind_file" | sed 's/:.*//' | tr '\n' ' ')
-    if [[ -n $lno ]]; then
-      echo "  ** Found 'fzf_key_bindings' in line #$lno"
-      echo "  ** You have to replace the line to 'fzf --fish | source'"
+    lno_func=$(\grep -nF "function fish_user_key_bindings" "$bind_file" | sed 's/:.*//' | tr '\n' ' ')
+    if [[ -z $lno_func ]]; then
+      echo -e "function fish_user_key_bindings\nend" >> "$bind_file"
+      lno_func=$(\grep -nF "function fish_user_key_bindings" "$bind_file" | sed 's/:.*//' | tr '\n' ' ')
+    fi
+    lno_keys=$(\grep -nF "fzf_key_bindings" "$bind_file" | sed 's/:.*//' | tr '\n' ' ')
+    if [[ -n $lno_keys ]]; then
+      echo "  ** Found 'fzf_key_bindings' in line #$lno_keys"
+      if [[ $key_bindings -eq 1 && $auto_completion -eq 1 ]]; then
+        echo "  ** You have to replace the line to 'fzf --fish | source'"
+      elif [[ $key_bindings -eq 1 ]]; then
+        echo "  ** You have to replace the line to '$fzf_key_bindings'"
+      else
+        echo "  ** You have to remove the line"
+      fi
       echo
     else
       echo "  - Clear"
       echo
-      append_line $update_config "fzf --fish | source" "$bind_file"
+      if [[ $key_bindings -eq 1 && $auto_completion -eq 1 ]]; then
+        sed -i.~fzf_bak "\#$fzf_completion#d" "$bind_file" && rm "$bind_file.~fzf_bak"
+        sed -i.~fzf_bak "\#$fzf_key_bindings#d" "$bind_file" && rm "$bind_file.~fzf_bak"
+        append_line $update_config "  fzf --fish | source" "$bind_file" "" "$lno_func"
+      else
+        sed -i.~fzf_bak '/fzf --fish \| source/d' "$bind_file" && rm "$bind_file.~fzf_bak"
+        if [[ $key_bindings -eq 1 ]]; then
+          sed -i.~fzf_bak "\#$fzf_completion#d" "$bind_file" && rm "$bind_file.~fzf_bak"
+          append_line $update_config "  $fzf_key_bindings" "$bind_file" "" "$lno_func"
+        elif [[ $auto_completion -eq 1 ]]; then
+          sed -i.~fzf_bak "\#$fzf_key_bindings#d" "$bind_file" && rm "$bind_file.~fzf_bak"
+          append_line $update_config "  $fzf_completion" "$bind_file" "" "$lno_func"
+        fi
+      fi
     fi
   fi
 fi
 
 if [ $update_config -eq 1 ]; then
   echo 'Finished. Restart your shell or reload config file.'
-  if [[ "$shells" =~ bash ]]; then
+  if [[ $shells =~ bash ]]; then
     echo -n '   source ~/.bashrc  # bash'
-    [[ "$archi" =~ Darwin ]] && echo -n '  (.bashrc should be loaded from .bash_profile)'
+    [[ $archi =~ Darwin ]] && echo -n '  (.bashrc should be loaded from .bash_profile)'
     echo
   fi
-  [[ "$shells" =~ zsh ]]  && echo "   source ${ZDOTDIR:-~}/.zshrc   # zsh"
-  [[ "$shells" =~ fish ]] && [ $key_bindings -eq 1 ] && echo '   fzf_key_bindings  # fish'
+  [[ $shells =~ zsh ]] && echo "   source ${ZDOTDIR:-~}/.zshrc   # zsh"
+  [[ $shells =~ fish && $lno_func -ne 0 ]] && echo '   fish_user_key_bindings  # fish'
   echo
   echo 'Use uninstall script to remove fzf.'
   echo

install.ps1

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

main.go

@@ -11,7 +11,7 @@ import (
 	"github.com/junegunn/fzf/src/protector"
 )
 
-var version = "0.58"
+var version = "0.72"
 var revision = "devel"
 
 //go:embed shell/key-bindings.bash
@@ -29,6 +29,9 @@ var zshCompletion []byte
 //go:embed shell/key-bindings.fish
 var fishKeyBindings []byte
 
+//go:embed shell/completion.fish
+var fishCompletion []byte
+
 //go:embed man/man1/fzf.1
 var manPage []byte
 
@@ -65,7 +68,7 @@ func main() {
 	}
 	if options.Fish {
 		printScript("key-bindings.fish", fishKeyBindings)
-		fmt.Println("fzf_key_bindings")
+		printScript("completion.fish", fishCompletion)
 		return
 	}
 	if options.Help {

man/man1/fzf-tmux.1

@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)
 
-Copyright (c) 2013-2024 Junegunn Choi
+Copyright (c) 2013-2026 Junegunn Choi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf\-tmux 1 "Jan 2025" "fzf 0.58.0" "fzf\-tmux - open fzf in tmux split pane"
+.TH fzf\-tmux 1 "Apr 2026" "fzf 0.72.0" "fzf\-tmux - open fzf in tmux split pane"
 
 .SH NAME
 fzf\-tmux - open fzf in tmux split pane

plugin/fzf.vim

@@ -1,4 +1,4 @@
-" Copyright (c) 2013-2024 Junegunn Choi
+" Copyright (c) 2013-2026 Junegunn Choi
 "
 " MIT License
 "
@@ -358,7 +358,7 @@ endfunction
 
 function! s:get_color(attr, ...)
   " Force 24 bit colors: g:fzf_force_termguicolors (temporary workaround for https://github.com/junegunn/fzf.vim/issues/1152)
-  let gui = get(g:, 'fzf_force_termguicolors', 0) || (!s:is_win && !has('win32unix') && has('termguicolors') && &termguicolors)
+  let gui = get(g:, 'fzf_force_termguicolors', 0) || (!s:is_win && !has('win32unix') && (has('gui_running') || has('termguicolors') && &termguicolors))
   let fam = gui ? 'gui' : 'cterm'
   let pat = gui ? '^#[a-f0-9]\+' : '^[0-9]\+$'
   for group in a:000
@@ -553,8 +553,15 @@ try
     let height = s:calc_size(&lines, dict.down, dict)
     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])
+
+  if exists('&winborder') && &winborder !=# '' && &winborder !=# 'none'
+    " Add 1-column horizontal margin
+    let optstr = join(['--margin 0,1', optstr])
+  else
+    " 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])
+  endif
+
   let command = prefix.(use_tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result
 
   if use_term
@@ -889,6 +896,7 @@ function! s:execute_term(dict, command, temps) abort
     endif
   endfunction
   function! fzf.on_exit(id, code, ...)
+    silent! autocmd! fzf_popup_resize
     if s:getpos() == self.ppos " {'window': 'enew'}
       for [opt, val] in items(self.winopts)
         execute 'let' opt '=' val
@@ -1016,41 +1024,79 @@ function! s:callback(dict, lines) abort
 endfunction
 
 if has('nvim')
-  function s:create_popup(opts) abort
+  function! s:create_popup() abort
+    let opts = s:popup_bounds()
+    let opts = extend({'relative': 'editor', 'style': 'minimal'}, opts)
+
     let buf = nvim_create_buf(v:false, v:true)
-    let opts = extend({'relative': 'editor', 'style': 'minimal'}, a:opts)
-    let win = nvim_open_win(buf, v:true, opts)
-    silent! call setwinvar(win, '&winhighlight', 'Pmenu:,Normal:Normal')
-    call setwinvar(win, '&colorcolumn', '')
+    let s:popup_id = nvim_open_win(buf, v:true, opts)
+    call setwinvar(s:popup_id, '&colorcolumn', '')
+
+    " Colors
+    try
+      call setwinvar(s:popup_id, '&winhighlight', 'Pmenu:,Normal:Normal')
+      let rules = get(g:, 'fzf_colors', {})
+      if has_key(rules, 'bg')
+        let color = call('s:get_color', rules.bg)
+        if len(color)
+          let ns = nvim_create_namespace('fzf_popup')
+          let hl = nvim_set_hl(ns, 'Normal',
+                \ &termguicolors ? { 'bg': color } : { 'ctermbg': str2nr(color) })
+          call nvim_win_set_hl_ns(s:popup_id, ns)
+        endif
+      endif
+    catch
+    endtry
     return buf
   endfunction
+
+  function! s:resize_popup() abort
+    if !exists('s:popup_id') || !nvim_win_is_valid(s:popup_id)
+      return
+    endif
+    let opts = s:popup_bounds()
+    let opts = extend({'relative': 'editor'}, opts)
+    call nvim_win_set_config(s:popup_id, opts)
+  endfunction
 else
-  function! s:create_popup(opts) abort
-    let s:popup_create = {buf -> popup_create(buf, #{
-      \ line: a:opts.row,
-      \ col: a:opts.col,
-      \ minwidth: a:opts.width,
-      \ maxwidth: a:opts.width,
-      \ minheight: a:opts.height,
-      \ maxheight: a:opts.height,
-      \ zindex: 1000,
-    \ })}
+  function! s:create_popup() abort
+    function! s:popup_create(buf)
+      let s:popup_id = popup_create(a:buf, #{zindex: 1000})
+      call s:resize_popup()
+    endfunction
     autocmd TerminalOpen * ++once call s:popup_create(str2nr(expand('<abuf>')))
   endfunction
+
+  function! s:resize_popup() abort
+    if !exists('s:popup_id') || empty(popup_getpos(s:popup_id))
+      return
+    endif
+    let opts = s:popup_bounds()
+    call popup_move(s:popup_id, {
+      \ 'line': opts.row,
+      \ 'col': opts.col,
+      \ 'minwidth': opts.width,
+      \ 'maxwidth': opts.width,
+      \ 'minheight': opts.height,
+      \ 'maxheight': opts.height,
+    \ })
+  endfunction
 endif
 
-function! s:popup(opts) abort
-  let xoffset = get(a:opts, 'xoffset', 0.5)
-  let yoffset = get(a:opts, 'yoffset', 0.5)
-  let relative = get(a:opts, 'relative', 0)
+function! s:popup_bounds() abort
+  let opts = s:popup_opts
+
+  let xoffset = get(opts, 'xoffset', 0.5)
+  let yoffset = get(opts, 'yoffset', 0.5)
+  let relative = get(opts, 'relative', 0)
 
   " Use current window size for positioning relatively positioned popups
   let columns = relative ? winwidth(0) : &columns
   let lines = relative ? winheight(0) : (&lines - has('nvim'))
 
   " Size and position
-  let width = min([max([8, a:opts.width > 1 ? a:opts.width : float2nr(columns * a:opts.width)]), columns])
-  let height = min([max([4, a:opts.height > 1 ? a:opts.height : float2nr(lines * a:opts.height)]), lines])
+  let width = min([max([8, opts.width > 1 ? opts.width : float2nr(columns * opts.width)]), columns])
+  let height = min([max([4, opts.height > 1 ? opts.height : float2nr(lines * opts.height)]), lines])
   let row = float2nr(yoffset * (lines - height)) + (relative ? win_screenpos(0)[0] - 1 : 0)
   let col = float2nr(xoffset * (columns - width)) + (relative ? win_screenpos(0)[1] - 1 : 0)
 
@@ -1060,9 +1106,17 @@ function! s:popup(opts) abort
   let row += !has('nvim')
   let col += !has('nvim')
 
-  call s:create_popup({
-    \ 'row': row, 'col': col, 'width': width, 'height': height
-  \ })
+  return { 'row': row, 'col': col, 'width': width, 'height': height }
+endfunction
+
+function! s:popup(opts) abort
+  let s:popup_opts = a:opts
+  call s:create_popup()
+
+  augroup fzf_popup_resize
+    autocmd!
+    autocmd VimResized * call s:resize_popup()
+  augroup END
 endfunction
 
 let s:default_action = {
@@ -1081,7 +1135,7 @@ endfunction
 
 function! s:cmd(bang, ...) abort
   let args = copy(a:000)
-  let opts = { 'options': ['--multi'] }
+  let opts = { 'options': ['--multi', '--scheme', 'path'] }
   if len(args) && isdirectory(expand(args[-1]))
     let opts.dir = substitute(substitute(remove(args, -1), '\\\(["'']\)', '\1', 'g'), '[/\\]*$', '/', '')
     if s:is_win && !&shellslash

shell/common.sh

@@ -0,0 +1,40 @@
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  builtin printf '%s\n' "--height ${FZF_TMUX_HEIGHT:-40%} --min-height 20+ --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  builtin printf '%s\n' "${FZF_DEFAULT_OPTS-} $2"
+}
+
+__fzf_exec_awk() {
+  # This function performs `exec awk "$@"` safely by working around awk
+  # compatibility issues.
+  #
+  # To reduce an extra fork, this function performs "exec" so is expected to be
+  # run as the last command in a subshell.
+  if [[ -z ${__fzf_awk-} ]]; then
+    __fzf_awk=awk
+    if [[ $OSTYPE == solaris* && -x /usr/xpg4/bin/awk ]]; then
+      # Note: Solaris awk at /usr/bin/awk is meant for backward compatibility
+      # with an ancient implementation of 1977 awk in the original UNIX.  It
+      # lacks many features of POSIX awk, so it is essentially useless in the
+      # modern point of view.  To use a standard-conforming version in Solaris,
+      # one needs to explicitly use /usr/xpg4/bin/awk.
+      __fzf_awk=/usr/xpg4/bin/awk
+    elif command -v mawk > /dev/null 2>&1; then
+      # choose the faster mawk if: it's installed && build date >= 20230322 &&
+      # version >= 1.3.4
+      local n x y z d
+      IFS=' .' read -r n x y z d <<< $(command mawk -W version 2> /dev/null)
+      [[ $n == mawk ]] &&
+        (((x * 1000 + y) * 1000 + z >= 1003004)) 2> /dev/null &&
+        ((d >= 20230302)) 2> /dev/null &&
+        __fzf_awk=mawk
+    fi
+  fi
+  # Note: macOS awk has a quirk that it stops processing at all when it sees
+  # any data not following UTF-8 in the input stream when the current LC_CTYPE
+  # specifies the UTF-8 encoding.  To work around this quirk, one needs to
+  # specify LC_ALL=C to change the current encoding to the plain one.
+  LC_ALL=C exec "$__fzf_awk" "$@"
+}

shell/completion.bash

@@ -4,8 +4,6 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ completion.bash
 #
-# - $FZF_TMUX                 (default: 0)
-# - $FZF_TMUX_OPTS            (default: empty)
 # - $FZF_COMPLETION_TRIGGER   (default: '**')
 # - $FZF_COMPLETION_OPTS      (default: empty)
 # - $FZF_COMPLETION_PATH_OPTS (default: empty)
@@ -31,21 +29,40 @@ if [[ $- =~ i ]]; then
 
 ###########################################################
 
-# To redraw line after fzf closes (printf '\e[5n')
-bind '"\e[0n": redraw-current-line' 2> /dev/null
+#----BEGIN shfmt
+#----BEGIN INCLUDE common.sh
+# NOTE: Do not directly edit this section, which is copied from "common.sh".
+# To modify it, one can edit "common.sh" and run "./update.sh" to apply
+# the changes. See code comments in "common.sh" for the implementation details.
 
 __fzf_defaults() {
-  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  builtin printf '%s\n' "--height ${FZF_TMUX_HEIGHT:-40%} --min-height 20+ --bind=ctrl-z:ignore $1"
   command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
-  echo "${FZF_DEFAULT_OPTS-} $2"
+  builtin printf '%s\n' "${FZF_DEFAULT_OPTS-} $2"
 }
 
+__fzf_exec_awk() {
+  if [[ -z ${__fzf_awk-} ]]; then
+    __fzf_awk=awk
+    if [[ $OSTYPE == solaris* && -x /usr/xpg4/bin/awk ]]; then
+      __fzf_awk=/usr/xpg4/bin/awk
+    elif command -v mawk > /dev/null 2>&1; then
+      local n x y z d
+      IFS=' .' read -r n x y z d <<< $(command mawk -W version 2> /dev/null)
+      [[ $n == mawk ]] &&
+        (((x * 1000 + y) * 1000 + z >= 1003004)) 2> /dev/null &&
+        ((d >= 20230302)) 2> /dev/null &&
+        __fzf_awk=mawk
+    fi
+  fi
+  LC_ALL=C exec "$__fzf_awk" "$@"
+}
+#----END INCLUDE
+
 __fzf_comprun() {
-  if [[ "$(type -t _fzf_comprun 2>&1)" = function ]]; then
+  if [[ "$(type -t _fzf_comprun 2>&1)" == function ]]; then
     _fzf_comprun "$@"
-  elif [[ -n "${TMUX_PANE-}" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "${FZF_TMUX_OPTS-}" ]]; }; then
+  elif [[ -n ${TMUX_PANE-} ]] && { [[ ${FZF_TMUX:-0} != 0 ]] || [[ -n ${FZF_TMUX_OPTS-} ]]; }; then
     shift
     fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- "$@"
   else
@@ -57,13 +74,13 @@ __fzf_comprun() {
 __fzf_orig_completion() {
   local l comp f cmd
   while read -r l; do
-    if [[ "$l" =~ ^(.*\ -F)\ *([^ ]*).*\ ([^ ]*)$ ]]; then
+    if [[ $l =~ ^(.*\ -F)\ *([^ ]*).*\ ([^ ]*)$ ]]; then
       comp="${BASH_REMATCH[1]}"
       f="${BASH_REMATCH[2]}"
       cmd="${BASH_REMATCH[3]}"
-      [[ "$f" = _fzf_* ]] && continue
-      printf -v "_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}" "%s" "${comp} %s ${cmd} #${f}"
-      if [[ "$l" = *" -o nospace "* ]] && [[ ! "${__fzf_nospace_commands-}" = *" $cmd "* ]]; then
+      [[ $f == _fzf_* ]] && continue
+      builtin printf -v "_fzf_orig_completion_${cmd//[^A-Za-z0-9_]/_}" "%s" "${comp} %s ${cmd} #${f}"
+      if [[ $l == *" -o nospace "* ]] && [[ ${__fzf_nospace_commands-} != *" $cmd "* ]]; then
         __fzf_nospace_commands="${__fzf_nospace_commands-} $cmd "
       fi
     fi
@@ -92,19 +109,20 @@ __fzf_orig_completion_instantiate() {
   orig="${!orig_var-}"
   orig="${orig%#*}"
   [[ $orig == *' %s '* ]] || return 1
-  printf -v REPLY "$orig" "$func"
+  builtin printf -v REPLY "$orig" "$func"
 }
 
 _fzf_opts_completion() {
   local cur prev opts
   COMPREPLY=()
   cur="${COMP_WORDS[COMP_CWORD]}"
-  prev="${COMP_WORDS[COMP_CWORD-1]}"
+  prev="${COMP_WORDS[COMP_CWORD - 1]}"
   opts="
     +c --no-color
     +i --no-ignore-case
     +s --no-sort
     +x --no-extended
+    --accept-nth
     --ansi
     --bash
     --bind
@@ -118,56 +136,89 @@ _fzf_opts_completion() {
     --expect
     --filepath-word
     --fish
+    --footer
+    --footer-border
+    --footer-label
+    --footer-label-pos
+    --freeze-left
+    --freeze-right
+    --gap
+    --gap-line
+    --ghost
+    --gutter
+    --gutter-raw
     --header
+    --header-border
     --header-first
+    --header-label
+    --header-label-pos
     --header-lines
+    --header-lines-border
     --height
     --highlight-line
     --history
     --history-size
     --hscroll-off
+    --id-nth
     --info
+    --info-command
+    --input-border
+    --input-label
+    --input-label-pos
     --jump-labels
     --keep-right
     --layout
     --listen
     --listen-unsafe
+    --list-border
+    --list-label
+    --list-label-pos
     --literal
     --man
     --margin
     --marker
+    --marker-multi-line
     --min-height
     --no-bold
-    --no-clear
     --no-hscroll
-    --no-mouse
+    --no-input
+    --no-multi-line
     --no-scrollbar
     --no-separator
-    --no-unicode
     --padding
     --pointer
     --preview
+    --preview-border
     --preview-label
     --preview-label-pos
     --preview-window
     --print-query
     --print0
     --prompt
+    --raw
     --read0
-    --reverse
     --scheme
     --scroll-off
+    --scrollbar
     --separator
+    --smart-case
+    --style
     --sync
     --tabstop
     --tac
+    --tail
     --tiebreak
     --tmux
     --track
     --version
+    --walker
+    --walker-root
+    --walker-skip
     --with-nth
     --with-shell
     --wrap
+    --wrap-sign
+    --preview-wrap-sign
     --zsh
     -0 --exit-0
     -1 --select-1
@@ -182,32 +233,41 @@ _fzf_opts_completion() {
     --"
 
   case "${prev}" in
-  --scheme)
-    COMPREPLY=( $(compgen -W "default path history" -- "$cur") )
-    return 0
-    ;;
-  --tiebreak)
-    COMPREPLY=( $(compgen -W "length chunk begin end index" -- "$cur") )
-    return 0
-    ;;
-  --color)
-    COMPREPLY=( $(compgen -W "dark light 16 bw no" -- "$cur") )
-    return 0
-    ;;
-  --layout)
-    COMPREPLY=( $(compgen -W "default reverse reverse-list" -- "$cur") )
-    return 0
-    ;;
-  --info)
-    COMPREPLY=( $(compgen -W "default right hidden inline inline-right" -- "$cur") )
-    return 0
-    ;;
-  --preview-window)
-    COMPREPLY=( $(compgen -W "
+    --scheme)
+      COMPREPLY=($(compgen -W "default path history" -- "$cur"))
+      return 0
+      ;;
+    --tiebreak)
+      COMPREPLY=($(compgen -W "length chunk pathname begin end index" -- "$cur"))
+      return 0
+      ;;
+    --color)
+      COMPREPLY=($(compgen -W "dark light base16 16 bw no" -- "$cur"))
+      return 0
+      ;;
+    --layout)
+      COMPREPLY=($(compgen -W "default reverse reverse-list" -- "$cur"))
+      return 0
+      ;;
+    --info)
+      COMPREPLY=($(compgen -W "default right hidden inline inline-right" -- "$cur"))
+      return 0
+      ;;
+    --wrap)
+      COMPREPLY=($(compgen -W "char word" -- "$cur"))
+      return 0
+      ;;
+    --style)
+      COMPREPLY=($(compgen -W "default minimal full" -- "$cur"))
+      return 0
+      ;;
+    --preview-window)
+      COMPREPLY=($(compgen -W "
       default
       hidden
       nohidden
       wrap
+      wrap-word
       nowrap
       cycle
       nocycle
@@ -216,6 +276,7 @@ _fzf_opts_completion() {
       left
       right
       rounded border border-rounded
+      border-line
       sharp border-sharp
       border-bold
       border-block
@@ -229,21 +290,23 @@ _fzf_opts_completion() {
       border-left
       border-right
       follow
-      nofollow" -- "$cur") )
-    return 0
-    ;;
-  --border)
-    COMPREPLY=( $(compgen -W "rounded sharp bold block thinblock double horizontal vertical top bottom left right none" -- "$cur") )
-    return 0
-    ;;
-  --border-label-pos|--preview-label-pos)
-    COMPREPLY=( $(compgen -W "center bottom top" -- "$cur") )
-    return 0
-    ;;
+      nofollow
+      info
+      noinfo" -- "$cur"))
+      return 0
+      ;;
+    --border | --list-border | --header-border | --header-lines-border | --footer-border | --input-border | --preview-border)
+      COMPREPLY=($(compgen -W "line rounded sharp bold block thinblock double horizontal vertical top bottom left right none" -- "$cur"))
+      return 0
+      ;;
+    --border-label-pos | --preview-label-pos | --list-label-pos | --header-label-pos | --footer-label-pos | --input-label-pos)
+      COMPREPLY=($(compgen -W "center bottom top" -- "$cur"))
+      return 0
+      ;;
   esac
 
-  if [[ "$cur" =~ ^-|\+ ]]; then
-    COMPREPLY=( $(compgen -W "${opts}" -- "$cur") )
+  if [[ $cur =~ ^-|\+ ]]; then
+    COMPREPLY=($(compgen -W "${opts}" -- "$cur"))
     return 0
   fi
 
@@ -257,7 +320,7 @@ _fzf_handle_dynamic_completion() {
   orig_cmd="$1"
   if __fzf_orig_completion_get_orig_func "$cmd"; then
     "$REPLY" "$@"
-  elif [[ -n "${_fzf_completion_loader-}" ]]; then
+  elif [[ -n ${_fzf_completion_loader-} ]]; then
     orig_complete=$(complete -p "$orig_cmd" 2> /dev/null)
     $_fzf_completion_loader "$@"
     ret=$?
@@ -271,7 +334,7 @@ _fzf_handle_dynamic_completion() {
         __fzf_orig_completion_instantiate "$cmd" "${BASH_REMATCH[1]}" &&
         orig_complete=$REPLY
 
-      if [[ "${__fzf_nospace_commands-}" = *" $orig_cmd "* ]]; then
+      if [[ ${__fzf_nospace_commands-} == *" $orig_cmd "* ]]; then
         eval "${orig_complete/ -F / -o nospace -F }"
       else
         eval "$orig_complete"
@@ -291,48 +354,53 @@ __fzf_generic_path_completion() {
   COMPREPLY=()
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   [[ $COMP_CWORD -ge 0 ]] && cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ "$cur" == *"$trigger" ]] && [[ $cur != *'$('* ]] && [[ $cur != *':='* ]] && [[ $cur != *'`'* ]]; then
+  if [[ $cur == *"$trigger" ]] && [[ $cur != *'$('* ]] && [[ $cur != *':='* ]] && [[ $cur != *'`'* ]]; then
     base=${cur:0:${#cur}-${#trigger}}
     eval "base=$base" 2> /dev/null || return
 
     dir=
-    [[ $base = *"/"* ]] && dir="$base"
+    [[ $base == *"/"* ]] && dir="$base"
     while true; do
-      if [[ -z "$dir" ]] || [[ -d "$dir" ]]; then
-        leftover=${base/#"$dir"}
-        leftover=${leftover/#\/}
-        [[ -z "$dir" ]] && dir='.'
-        [[ "$dir" != "/" ]] && dir="${dir/%\//}"
+      if [[ -z $dir ]] || [[ -d $dir ]]; then
+        leftover=${base/#"$dir"/}
+        leftover=${leftover/#\//}
+        [[ -z $dir ]] && dir='.'
+        [[ $dir != "/" ]] && dir="${dir/%\//}"
         matches=$(
           export FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --scheme=path" "${FZF_COMPLETION_OPTS-} $2")
           unset FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS_FILE
+          if [[ $1 =~ dir ]]; then
+            eval "rest=(${FZF_COMPLETION_DIR_OPTS-})"
+          else
+            eval "rest=(${FZF_COMPLETION_PATH_OPTS-})"
+          fi
           if declare -F "$1" > /dev/null; then
-            eval "$1 $(printf %q "$dir")" | __fzf_comprun "$4" -q "$leftover"
+            eval "$1 $(builtin printf %q "$dir")" | __fzf_comprun "$4" -q "$leftover" "${rest[@]}"
           else
             if [[ $1 =~ dir ]]; then
               walker=dir,follow
-              rest=${FZF_COMPLETION_DIR_OPTS-}
             else
               walker=file,dir,follow,hidden
-              rest=${FZF_COMPLETION_PATH_OPTS-}
             fi
-            __fzf_comprun "$4" -q "$leftover" --walker "$walker" --walker-root="$dir" $rest
+            __fzf_comprun "$4" -q "$leftover" --walker "$walker" --walker-root="$dir" "${rest[@]}"
           fi | while read -r item; do
-            printf "%q " "${item%$3}$3"
+            builtin printf "%q " "${item%$3}$3"
           done
         )
         matches=${matches% }
-        [[ -z "$3" ]] && [[ "${__fzf_nospace_commands-}" = *" ${COMP_WORDS[0]} "* ]] && matches="$matches "
-        if [[ -n "$matches" ]]; then
-          COMPREPLY=( "$matches" )
+        [[ -z $3 ]] && [[ ${__fzf_nospace_commands-} == *" ${COMP_WORDS[0]} "* ]] && matches="$matches "
+        if [[ -n $matches ]]; then
+          COMPREPLY=("$matches")
         else
-          COMPREPLY=( "$cur" )
+          COMPREPLY=("$cur")
         fi
-        printf '\e[5n'
+        # To redraw line after fzf closes (builtin printf '\e[5n')
+        bind '"\e[0n": redraw-current-line' 2> /dev/null
+        builtin printf '\e[5n'
         return 0
       fi
       dir=$(command dirname "$dir")
-      [[ "$dir" =~ /$ ]] || dir="$dir"/
+      [[ $dir =~ /$ ]] || dir="$dir"/
     done
   else
     shift
@@ -348,15 +416,15 @@ _fzf_complete() {
   args=("$@")
   sep=
   for i in "${!args[@]}"; do
-    if [[ "${args[$i]}" = -- ]]; then
+    if [[ ${args[$i]} == -- ]]; then
       sep=$i
       break
     fi
   done
-  if [[ -n "$sep" ]]; then
+  if [[ -n $sep ]]; then
     str_arg=
     rest=("${args[@]:$((sep + 1)):${#args[@]}}")
-    args=("${args[@]:0:$sep}")
+    args=("${args[@]:0:sep}")
   else
     str_arg=$1
     args=()
@@ -365,26 +433,28 @@ _fzf_complete() {
   fi
 
   local cur selected trigger cmd post
-  post="$(caller 0 | command awk '{print $2}')_post"
+  post="$(caller 0 | __fzf_exec_awk '{print $2}')_post"
   type -t "$post" > /dev/null 2>&1 || post='command cat'
 
   trigger=${FZF_COMPLETION_TRIGGER-'**'}
   cmd="${COMP_WORDS[0]}"
   cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ "$cur" == *"$trigger" ]] && [[ $cur != *'$('* ]] && [[ $cur != *':='* ]] && [[ $cur != *'`'* ]]; then
+  if [[ $cur == *"$trigger" ]] && [[ $cur != *'$('* ]] && [[ $cur != *':='* ]] && [[ $cur != *'`'* ]]; then
     cur=${cur:0:${#cur}-${#trigger}}
 
     selected=$(
       FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse" "${FZF_COMPLETION_OPTS-} $str_arg") \
       FZF_DEFAULT_OPTS_FILE='' \
-        __fzf_comprun "${rest[0]}" "${args[@]}" -q "$cur" | eval "$post" | command tr '\n' ' ')
+        __fzf_comprun "${rest[0]}" "${args[@]}" -q "$cur" | eval "$post" | command tr '\n' ' '
+    )
     selected=${selected% } # Strip trailing space not to repeat "-o nospace"
-    if [[ -n "$selected" ]]; then
+    if [[ -n $selected ]]; then
       COMPREPLY=("$selected")
     else
       COMPREPLY=("$cur")
     fi
-    printf '\e[5n'
+    bind '"\e[0n": redraw-current-line' 2> /dev/null
+    builtin printf '\e[5n'
     return 0
   else
     _fzf_handle_dynamic_completion "$cmd" "${rest[@]}"
@@ -409,15 +479,41 @@ _fzf_complete_kill() {
 }
 
 _fzf_proc_completion() {
-  _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 2> /dev/null || # For BusyBox
-      command ps --everyone --full --windows # For cygwin
-  )
+  local transformer
+  transformer='
+    if [[ $FZF_KEY =~ ctrl|alt|shift ]] && [[ -n $FZF_NTH ]]; then
+      nths=( ${FZF_NTH//,/ } )
+      new_nths=()
+      found=0
+      for nth in ${nths[@]}; do
+        if [[ $nth = $FZF_CLICK_HEADER_NTH ]]; then
+          found=1
+        else
+          new_nths+=($nth)
+        fi
+      done
+      [[ $found = 0 ]] && new_nths+=($FZF_CLICK_HEADER_NTH)
+      new_nths=${new_nths[*]}
+      new_nths=${new_nths// /,}
+      echo "change-nth($new_nths)+change-prompt($new_nths> )"
+    else
+      if [[ $FZF_NTH = $FZF_CLICK_HEADER_NTH ]]; then
+        echo "change-nth()+change-prompt(> )"
+      else
+        echo "change-nth($FZF_CLICK_HEADER_NTH)+change-prompt($FZF_CLICK_HEADER_WORD> )"
+      fi
+    fi
+  '
+  _fzf_complete -m --header-lines=1 --no-preview --wrap --color fg:dim,nth:regular \
+    --bind "click-header:transform:$transformer" -- "$@" < <(
+      command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
+        command ps -eo user,pid,ppid,time,args 2> /dev/null || # For BusyBox
+        command ps --everyone --full --windows                 # For cygwin
+    )
 }
 
 _fzf_proc_completion_post() {
-  command awk '{print $2}'
+  __fzf_exec_awk '{print $2}'
 }
 
 # To use custom hostname lists, override __fzf_list_hosts.
@@ -430,14 +526,58 @@ _fzf_proc_completion_post() {
 #     # Set the local attribute for any non-local variable that is set by _known_hosts_real()
 #     local COMPREPLY=()
 #     _known_hosts_real ''
-#     printf '%s\n' "${COMPREPLY[@]}" | command sort -u --version-sort
+#     builtin printf '%s\n' "${COMPREPLY[@]}" | command sort -u --version-sort
 #   }
 if ! declare -F __fzf_list_hosts > /dev/null; then
   __fzf_list_hosts() {
-    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | command awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
-      <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts 2> /dev/null | command tr ',' '\n' | command tr -d '[' | command awk '{ print $1 " " $1 }') \
-      <(command grep -v '^\s*\(#\|$\)' /etc/hosts 2> /dev/null | command grep -Fv '0.0.0.0' | command sed 's/#.*//') |
-      command awk '{for (i = 2; i <= NF; i++) print $i}' | command sort -u
+    command sort -u \
+      <(
+        # Note: To make the pathname expansion of "~/.ssh/config.d/*" work
+        # properly, we need to adjust the related shell options.  We need to
+        # unset "set -f" and "GLOBIGNORE", which disable the pathname expansion
+        # totally or partially.  We need to unset "dotglob" and "nocaseglob" to
+        # avoid matching unwanted files.  We need to unset "failglob" to avoid
+        # outputting the error messages to the terminal when no matching is
+        # found.  We need to set "nullglob" to avoid attempting to read the
+        # literal filename '~/.ssh/config.d/*' when no matching is found.
+        set +f
+        GLOBIGNORE=
+        shopt -u dotglob nocaseglob failglob
+        shopt -s nullglob
+
+        __fzf_exec_awk '
+          # Note: mawk <= 1.3.3-20090705 does not support the POSIX brackets of
+          # the form [[:blank:]], and Ubuntu 18.04 LTS still uses this
+          # 16-year-old mawk unfortunately.  We need to use [ \t] instead.
+          match(tolower($0), /^[ \t]*host(name)?[ \t]*[ \t=]/) {
+            $0 = substr($0, RLENGTH + 1) # Remove "Host(name)?=?"
+            sub(/#.*/, "")
+            for (i = 1; i <= NF; i++)
+              if ($i !~ /[*?%]/)
+                print $i
+          }
+        ' ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null
+      ) \
+      <(
+        __fzf_exec_awk -F ',' '
+          match($0, /^[][a-zA-Z0-9.,:-]+/) {
+            $0 = substr($0, 1, RLENGTH)
+            gsub(/[][]|:[^,]*/, "")
+            for (i = 1; i <= NF; i++)
+              print $i
+          }
+        ' ~/.ssh/known_hosts 2> /dev/null
+      ) \
+      <(
+        __fzf_exec_awk '
+          {
+            sub(/#.*/, "")
+            for (i = 2; i <= NF; i++)
+              if ($i != "0.0.0.0")
+                print $i
+          }
+        ' /etc/hosts 2> /dev/null
+      )
   }
 fi
 
@@ -452,13 +592,13 @@ _fzf_host_completion() {
 # > and the third argument ($3) is the word preceding the word being completed on the current command line.
 _fzf_complete_ssh() {
   case $3 in
-    -i|-F|-E)
+    -i | -F | -E)
       _fzf_path_completion "$@"
       ;;
     *)
       local user=
-      [[ "$2" =~ '@' ]] && user="${2%%@*}@"
-      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | command awk -v user="$user" '{print user $0}')
+      [[ $2 =~ '@' ]] && user="${2%%@*}@"
+      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | __fzf_exec_awk -v user="$user" '{print user $0}')
       ;;
   esac
 }
@@ -546,7 +686,7 @@ __fzf_defc() {
   if __fzf_orig_completion_instantiate "$cmd" "$func"; then
     eval "$REPLY"
   else
-    complete -F "$func" $opts "$cmd"
+    eval "complete -F \"$func\" $opts \"$cmd\""
   fi
 }
 
@@ -588,12 +728,13 @@ _fzf_setup_completion() {
   __fzf_orig_completion < <(complete -p "$@" 2> /dev/null)
   for cmd in "$@"; do
     case "$kind" in
-      dir)   __fzf_defc "$cmd" "$fn" "-o nospace -o dirnames" ;;
-      var)   __fzf_defc "$cmd" "$fn" "-o default -o nospace -v" ;;
+      dir) __fzf_defc "$cmd" "$fn" "-o nospace -o dirnames" ;;
+      var) __fzf_defc "$cmd" "$fn" "-o default -o nospace -v" ;;
       alias) __fzf_defc "$cmd" "$fn" "-a" ;;
-      *)     __fzf_defc "$cmd" "$fn" "-o default -o bashdefault" ;;
+      *) __fzf_defc "$cmd" "$fn" "-o default -o bashdefault" ;;
     esac
   done
 }
+#----END shfmt
 
 fi

shell/completion.fish

@@ -0,0 +1,169 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ completion.fish
+#
+# - $FZF_COMPLETION_OPTS
+# - $FZF_EXPANSION_OPTS
+
+# The oldest supported fish version is 3.4.0. For this message being able to be
+# displayed on older versions, the command substitution syntax $() should not
+# be used anywhere in the script, otherwise the source command will fail.
+if string match -qr -- '^[12]\\.|^3\\.[0-3]' $version
+  echo "fzf completion script requires fish version 3.4.0 or newer." >&2
+  return 1
+else if not command -q fzf
+  echo "fzf was not found in path." >&2
+  return 1
+end
+
+function fzf_complete -w fzf -d 'fzf command completion and wildcard expansion search'
+  # Restore the default shift-tab behavior on tab completions
+  if commandline --paging-mode
+    commandline -f complete-and-search
+    return
+  end
+
+  # Remove any trailing unescaped backslash from token and update command line
+  set -l -- token (string replace -r -- '(?<!\\\\)(?:\\\\\\\\)*\\K\\\\$' '' (commandline -t | string collect) | string collect)
+  commandline -rt -- $token
+
+  # Remove any line breaks from token
+  set -- token (string replace -ra -- '\\\\\\n' '' $token | string collect)
+
+  # regex: Match token with unescaped/unquoted glob character
+  set -l -- r_glob '^(?:[^\'"\\\\*]|\\\\[\\S\\s]|\'(?:\\\\[\\S\\s]|[^\'\\\\])*\'|"(?:\\\\[\\S\\s]|[^"\\\\])*")*\\*[\\S\\s]*$'
+
+  # regex: Match any unbalanced quote character
+  set -l -- r_quote '^(?>(?:\\\\[\\s\\S]|"(?:[^"\\\\]|\\\\[\\s\\S])*"|\'(?:[^\'\\\\]|\\\\[\\s\\S])*\'|[^\'"\\\\]+)*)\\K[\'"]'
+
+  # The expansion pattern is the token with any open quote closed, or is empty.
+  set -l -- glob_pattern (string match -r -- $r_glob $token | string collect)(string match -r -- $r_quote $token | string collect -a)
+
+  set -l -- cl_tokenize_opt '--tokens-expanded'
+  string match -q -- '3.*' $version
+  and set -- cl_tokenize_opt '--tokenize'
+
+  # Set command line tokens without any leading variable definitions or launcher
+  # commands (including their options, but not any option arguments).
+  set -l -- r_cmd '^(?:(?:builtin|command|doas|env|sudo|\\w+=\\S*|-\\S+)\\s+)*\\K[\\s\\S]+'
+  set -l -- cmd (commandline $cl_tokenize_opt --input=(commandline -pc | string match -r $r_cmd))
+  test -z "$token"
+  and set -a -- cmd ''
+
+  # Set fzf options
+  test -z "$FZF_TMUX_HEIGHT"
+  and set -l -- FZF_TMUX_HEIGHT 40%
+
+  set -lax -- FZF_DEFAULT_OPTS \
+    "--height=$FZF_TMUX_HEIGHT --min-height=20+ --bind=ctrl-z:ignore" \
+    (test -r "$FZF_DEFAULT_OPTS_FILE"; and string join -- ' ' <$FZF_DEFAULT_OPTS_FILE) \
+    $FZF_DEFAULT_OPTS '--bind=alt-r:toggle-raw --multi --wrap=word --reverse' \
+    (if test -n "$glob_pattern"; string collect -- $FZF_EXPANSION_OPTS; else;
+      string collect -- $FZF_COMPLETION_OPTS; end; string escape -n -- $argv) \
+    --with-shell=(status fish-path)\\ -c
+
+  set -lx FZF_DEFAULT_OPTS_FILE
+
+  set -l -- fzf_cmd fzf
+  test "$FZF_TMUX" = 1
+  and set -- fzf_cmd fzf-tmux $FZF_TMUX_OPTS -d$FZF_TMUX_HEIGHT --
+
+  set -l result
+
+  # Get the completion list from stdin when it's not a tty
+  if not isatty stdin
+    set -l -- custom_post_func _fzf_post_complete_$cmd[1]
+    functions -q $custom_post_func
+    or set -- custom_post_func _fzf_complete_$cmd[1]_post
+
+    if functions -q $custom_post_func
+      $fzf_cmd | $custom_post_func $cmd | while read -l r; set -a -- result $r; end
+    else if string match -q -- '*--print0*' "$FZF_DEFAULT_OPTS"
+      $fzf_cmd | while read -lz r; set -a -- result $r; end
+    else
+      $fzf_cmd | while read -l r; set -a -- result $r; end
+    end
+
+  # Wildcard expansion
+  else if test -n "$glob_pattern"
+    # Set the command to be run by fzf, so there is a visual indicator and an
+    # easy way to abort on long recursive searches.
+    set -lx -- FZF_DEFAULT_COMMAND "for i in $glob_pattern;" \
+      'test -d "$i"; and string match -qv -- "*/" $i; and set -- i $i/;' \
+      'string join0 -- $i; end'
+
+    set -- result (string escape -n -- ($fzf_cmd --read0 --print0 --scheme=path --no-multi-line | string split0))
+
+  # Command completion
+  else
+    # Call custom function if defined
+    set -l -- custom_func _fzf_complete_$cmd[1]
+    if functions -q $custom_func; and not set -q __fzf_no_custom_complete
+      set -lx __fzf_no_custom_complete
+      $custom_func $cmd
+      return
+    end
+
+    # Workaround for complete not having newlines in results
+    if string match -qr -- '\\n' $token
+      set -- token (string replace -ra -- '(?<!\\\\)(?:\\\\\\\\)*\\K\\\\\$' '\\\\\\\\\$' $token | string collect)
+      set -- token (string unescape -- $token | string collect)
+      set -- token (string replace -ra -- '\\n' '\\\\n' $token | string collect)
+    end
+
+    set -- list (complete -C --escape -- (string join -- ' ' (commandline -pc $cl_tokenize_opt) $token | string collect))
+    if test -n "$list"
+      # Get the initial tabstop value
+      if set -l -- tabstop (string match -rga -- '--tabstop[= ](?:0*)([1-9]\\d+|[4-9])' "$FZF_DEFAULT_OPTS")[-1]
+        set -- tabstop (math $tabstop - 4)
+      else
+        set -- tabstop 4
+      end
+
+      # Determine the tabstop length for description alignment
+      set -l -- max_columns (math $COLUMNS - 40)
+      for i in $list[1..500]
+        set -l -- item (string split -f 1 -- \t $i)
+        and set -l -- len (string length -V -- $item)
+        and test "$len" -gt "$tabstop" -a "$len" -lt "$max_columns"
+        and set -- tabstop $len
+      end
+      set -- tabstop (math $tabstop + 4)
+
+      set -- result (string collect -- $list | $fzf_cmd --delimiter="\t" --tabstop=$tabstop --wrap-sign=\t"↳ " --accept-nth=1)
+    end
+  end
+
+  # Update command line
+  if test -n "$result"
+    # No extra space after single selection that ends with path separator
+    set -l -- tail ' '
+    test (count $result) -eq 1
+    and string match -q -- '*/' "$result"
+    and set -- tail ''
+
+    commandline -rt -- (string join -- ' ' $result)$tail
+  end
+
+  commandline -f repaint
+end
+
+function _fzf_complete
+  set -l fzf_args
+  for i in $argv
+    string match -q -- '--' $i; and break
+    set -a -- fzf_args $i
+  end
+  fzf_complete $fzf_args
+end
+
+# Bind to shift-tab
+if string match -qr -- '^\\d\\d+|^[4-9]' $version
+  bind shift-tab fzf_complete
+  bind -M insert shift-tab fzf_complete
+else
+  bind -k btab fzf_complete
+  bind -M insert -k btab fzf_complete
+end

shell/completion.zsh

@@ -4,8 +4,6 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ completion.zsh
 #
-# - $FZF_TMUX                 (default: 0)
-# - $FZF_TMUX_OPTS            (default: empty)
 # - $FZF_COMPLETION_TRIGGER   (default: '**')
 # - $FZF_COMPLETION_OPTS      (default: empty)
 # - $FZF_COMPLETION_PATH_OPTS (default: empty)
@@ -96,14 +94,35 @@ if [[ -o interactive ]]; then
 
 ###########################################################
 
+#----BEGIN INCLUDE common.sh
+# NOTE: Do not directly edit this section, which is copied from "common.sh".
+# To modify it, one can edit "common.sh" and run "./update.sh" to apply
+# the changes. See code comments in "common.sh" for the implementation details.
+
 __fzf_defaults() {
-  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  builtin printf '%s\n' "--height ${FZF_TMUX_HEIGHT:-40%} --min-height 20+ --bind=ctrl-z:ignore $1"
   command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
-  echo "${FZF_DEFAULT_OPTS-} $2"
+  builtin printf '%s\n' "${FZF_DEFAULT_OPTS-} $2"
 }
 
+__fzf_exec_awk() {
+  if [[ -z ${__fzf_awk-} ]]; then
+    __fzf_awk=awk
+    if [[ $OSTYPE == solaris* && -x /usr/xpg4/bin/awk ]]; then
+      __fzf_awk=/usr/xpg4/bin/awk
+    elif command -v mawk > /dev/null 2>&1; then
+      local n x y z d
+      IFS=' .' read -r n x y z d <<< $(command mawk -W version 2> /dev/null)
+      [[ $n == mawk ]] &&
+        (((x * 1000 + y) * 1000 + z >= 1003004)) 2> /dev/null &&
+        ((d >= 20230302)) 2> /dev/null &&
+        __fzf_awk=mawk
+    fi
+  fi
+  LC_ALL=C exec "$__fzf_awk" "$@"
+}
+#----END INCLUDE
+
 __fzf_comprun() {
   if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
     _fzf_comprun "$@"
@@ -153,15 +172,18 @@ __fzf_generic_path_completion() {
         export FZF_DEFAULT_OPTS
         FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --scheme=path" "${FZF_COMPLETION_OPTS-}")
         unset FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS_FILE
+        if [[ $compgen =~ dir ]]; then
+          rest=${FZF_COMPLETION_DIR_OPTS-}
+        else
+          rest=${FZF_COMPLETION_PATH_OPTS-}
+        fi
         if declare -f "$compgen" > /dev/null; then
-          eval "$compgen $(printf %q "$dir")" | __fzf_comprun "$cmd_word" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover"
+          eval "$compgen $(printf %q "$dir")" | __fzf_comprun "$cmd_word" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" ${(Q)${(Z+n+)rest}}
         else
           if [[ $compgen =~ dir ]]; then
             walker=dir,follow
-            rest=${FZF_COMPLETION_DIR_OPTS-}
           else
             walker=file,dir,follow,hidden
-            rest=${FZF_COMPLETION_PATH_OPTS-}
           fi
           __fzf_comprun "$cmd_word" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" --walker "$walker" --walker-root="$dir" ${(Q)${(Z+n+)rest}} < /dev/tty
         fi | while read -r item; do
@@ -242,11 +264,50 @@ _fzf_complete() {
 # desired sorting and with any duplicates removed, to standard output.
 if ! declare -f __fzf_list_hosts > /dev/null; then
   __fzf_list_hosts() {
-    setopt localoptions nonomatch
-    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
-      <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts 2> /dev/null | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
-      <(command grep -v '^\s*\(#\|$\)' /etc/hosts 2> /dev/null | command grep -Fv '0.0.0.0' | command sed 's/#.*//') |
-      awk '{for (i = 2; i <= NF; i++) print $i}' | sort -u
+    command sort -u \
+      <(
+        # Note: To make the pathname expansion of "~/.ssh/config.d/*" work
+        # properly, we need to adjust the related shell options.  We need to
+        # unset "NO_GLOB" (or reset "GLOB"), which disable the pathname
+        # expansion totally.  We need to unset "DOT_GLOB" and set "CASE_GLOB"
+        # to avoid matching unwanted files.  We need to set "NULL_GLOB" to
+        # avoid attempting to read the literal filename '~/.ssh/config.d/*'
+        # when no matching is found.
+        setopt GLOB NO_DOT_GLOB CASE_GLOB NO_NOMATCH NULL_GLOB
+
+        __fzf_exec_awk '
+          # Note: mawk <= 1.3.3-20090705 does not support the POSIX brackets of
+          # the form [[:blank:]], and Ubuntu 18.04 LTS still uses this
+          # 16-year-old mawk unfortunately.  We need to use [ \t] instead.
+          match(tolower($0), /^[ \t]*host(name)?[ \t]*[ \t=]/) {
+            $0 = substr($0, RLENGTH + 1) # Remove "Host(name)?=?"
+            sub(/#.*/, "")
+            for (i = 1; i <= NF; i++)
+              if ($i !~ /[*?%]/)
+                print $i
+          }
+        ' ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null
+      ) \
+      <(
+        __fzf_exec_awk -F ',' '
+          match($0, /^[][a-zA-Z0-9.,:-]+/) {
+            $0 = substr($0, 1, RLENGTH)
+            gsub(/[][]|:[^,]*/, "")
+            for (i = 1; i <= NF; i++)
+              print $i
+          }
+        ' ~/.ssh/known_hosts 2> /dev/null
+      ) \
+      <(
+        __fzf_exec_awk '
+          {
+            sub(/#.*/, "")
+            for (i = 2; i <= NF; i++)
+              if ($i != "0.0.0.0")
+                print $i
+          }
+        ' /etc/hosts 2> /dev/null
+      )
   }
 fi
 
@@ -266,7 +327,7 @@ _fzf_complete_ssh() {
     *)
       local user
       [[ $prefix =~ @ ]] && user="${prefix%%@*}@"
-      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | awk -v user="$user" '{print user $0}')
+      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | __fzf_exec_awk -v user="$user" '{print user $0}')
       ;;
   esac
 }
@@ -290,7 +351,33 @@ _fzf_complete_unalias() {
 }
 
 _fzf_complete_kill() {
-  _fzf_complete -m --header-lines=1 --no-preview --wrap -- "$@" < <(
+  local transformer
+  transformer='
+    if [[ $FZF_KEY =~ ctrl|alt|shift ]] && [[ -n $FZF_NTH ]]; then
+      nths=( ${FZF_NTH//,/ } )
+      new_nths=()
+      found=0
+      for nth in ${nths[@]}; do
+        if [[ $nth = $FZF_CLICK_HEADER_NTH ]]; then
+          found=1
+        else
+          new_nths+=($nth)
+        fi
+      done
+      [[ $found = 0 ]] && new_nths+=($FZF_CLICK_HEADER_NTH)
+      new_nths=${new_nths[*]}
+      new_nths=${new_nths// /,}
+      echo "change-nth($new_nths)+change-prompt($new_nths> )"
+    else
+      if [[ $FZF_NTH = $FZF_CLICK_HEADER_NTH ]]; then
+        echo "change-nth()+change-prompt(> )"
+      else
+        echo "change-nth($FZF_CLICK_HEADER_NTH)+change-prompt($FZF_CLICK_HEADER_WORD> )"
+      fi
+    fi
+  '
+  _fzf_complete -m --header-lines=1 --no-preview --wrap --color fg:dim,nth:regular \
+    --bind "click-header:transform:$transformer" -- "$@" < <(
     command ps -eo user,pid,ppid,start,time,command 2> /dev/null ||
       command ps -eo user,pid,ppid,time,args 2> /dev/null || # For BusyBox
       command ps --everyone --full --windows # For cygwin
@@ -298,7 +385,7 @@ _fzf_complete_kill() {
 }
 
 _fzf_complete_kill_post() {
-  awk '{print $2}'
+  __fzf_exec_awk '{print $2}'
 }
 
 fzf-completion() {

shell/key-bindings.bash

@@ -4,9 +4,9 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ key-bindings.bash
 #
-# - $FZF_TMUX_OPTS
 # - $FZF_CTRL_T_COMMAND
 # - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_COMMAND
 # - $FZF_CTRL_R_OPTS
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS
@@ -17,56 +17,96 @@ if [[ $- =~ i ]]; then
 # Key bindings
 # ------------
 
+#----BEGIN shfmt
+#----BEGIN INCLUDE common.sh
+# NOTE: Do not directly edit this section, which is copied from "common.sh".
+# To modify it, one can edit "common.sh" and run "./update.sh" to apply
+# the changes. See code comments in "common.sh" for the implementation details.
+
 __fzf_defaults() {
-  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  builtin printf '%s\n' "--height ${FZF_TMUX_HEIGHT:-40%} --min-height 20+ --bind=ctrl-z:ignore $1"
   command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
-  echo "${FZF_DEFAULT_OPTS-} $2"
+  builtin printf '%s\n' "${FZF_DEFAULT_OPTS-} $2"
 }
 
+__fzf_exec_awk() {
+  if [[ -z ${__fzf_awk-} ]]; then
+    __fzf_awk=awk
+    if [[ $OSTYPE == solaris* && -x /usr/xpg4/bin/awk ]]; then
+      __fzf_awk=/usr/xpg4/bin/awk
+    elif command -v mawk > /dev/null 2>&1; then
+      local n x y z d
+      IFS=' .' read -r n x y z d <<< $(command mawk -W version 2> /dev/null)
+      [[ $n == mawk ]] &&
+        (((x * 1000 + y) * 1000 + z >= 1003004)) 2> /dev/null &&
+        ((d >= 20230302)) 2> /dev/null &&
+        __fzf_awk=mawk
+    fi
+  fi
+  LC_ALL=C exec "$__fzf_awk" "$@"
+}
+#----END INCLUDE
+
 __fzf_select__() {
   FZF_DEFAULT_COMMAND=${FZF_CTRL_T_COMMAND:-} \
-  FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=file,dir,follow,hidden --scheme=path" "${FZF_CTRL_T_OPTS-} -m") \
-  FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) "$@" |
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=file,dir,follow,hidden --scheme=path" "${FZF_CTRL_T_OPTS-} -m") \
+    FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) "$@" |
     while read -r item; do
-      printf '%q ' "$item"  # escape special chars
+      printf '%q ' "$item" # escape special chars
     done
 }
 
 __fzfcmd() {
-  [[ -n "${TMUX_PANE-}" ]] && { [[ "${FZF_TMUX:-0}" != 0 ]] || [[ -n "${FZF_TMUX_OPTS-}" ]]; } &&
+  [[ -n ${TMUX_PANE-} ]] && { [[ ${FZF_TMUX:-0} != 0 ]] || [[ -n ${FZF_TMUX_OPTS-} ]]; } &&
     echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
 }
 
 fzf-file-widget() {
   local selected="$(__fzf_select__ "$@")"
-  READLINE_LINE="${READLINE_LINE:0:$READLINE_POINT}$selected${READLINE_LINE:$READLINE_POINT}"
-  READLINE_POINT=$(( READLINE_POINT + ${#selected} ))
+  READLINE_LINE="${READLINE_LINE:0:READLINE_POINT}$selected${READLINE_LINE:READLINE_POINT}"
+  READLINE_POINT=$((READLINE_POINT + ${#selected}))
 }
 
 __fzf_cd__() {
   local dir
   dir=$(
     FZF_DEFAULT_COMMAND=${FZF_ALT_C_COMMAND:-} \
-    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=dir,follow,hidden --scheme=path" "${FZF_ALT_C_OPTS-} +m") \
-    FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd)
+      FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=dir,follow,hidden --scheme=path" "${FZF_ALT_C_OPTS-} +m") \
+      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd)
   ) && printf 'builtin cd -- %q' "$(builtin unset CDPATH && builtin cd -- "$dir" && builtin pwd)"
 }
 
+__fzf_history_delete() {
+  [[ -s $1 ]] || return
+
+  local offsets
+  offsets=($(sort -rnu "$1"))
+  for offset in "${offsets[@]}"; do
+    builtin history -d "$offset"
+  done
+
+  if [[ ${#offsets[@]} -gt 0 ]] && shopt -q histappend; then
+    builtin history -w
+  fi
+}
+
 if command -v perl > /dev/null; then
   __fzf_history__() {
-    local output script
+    local output script deletefile
+    deletefile=$(mktemp)
     script='BEGIN { getc; $/ = "\n\t"; $HISTCOUNT = $ENV{last_hist} + 1 } s/^[ *]//; s/\n/\n\t/gm; print $HISTCOUNT - $. . "\t$_" if !$seen{$_}++'
     output=$(
       set +o pipefail
       builtin fc -lnr -2147483648 |
         last_hist=$(HISTTIMEFORMAT='' builtin history 1) command perl -n -l0 -e "$script" |
-        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"$'\t'"↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort,alt-r:toggle-raw --wrap-sign '"$'\t'"↳ ' --highlight-line --bind 'shift-delete:execute-silent(cat {+f1} >> \"$deletefile\")+exclude-multi' --multi ${FZF_CTRL_R_OPTS-} --read0") \
         FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
-    ) || return
+    )
+    __fzf_history_delete "$deletefile"
+    command rm -f "$deletefile"
+    [[ -n $output ]] || return
     READLINE_LINE=$(command perl -pe 's/^\d*\t//' <<< "$output")
-    if [[ -z "$READLINE_POINT" ]]; then
+    if [[ -z $READLINE_POINT ]]; then
       echo "$READLINE_LINE"
     else
       READLINE_POINT=0x7fffffff
@@ -74,14 +114,9 @@ if command -v perl > /dev/null; then
   }
 else # awk - fallback for POSIX systems
   __fzf_history__() {
-    local output script n x y z d
-    if [[ -z $__fzf_awk ]]; then
-      __fzf_awk=awk
-      # choose the faster mawk if: it's installed && build date >= 20230322 && version >= 1.3.4
-      IFS=' .' read n x y z d <<< $(command mawk -W version 2> /dev/null)
-      [[ $n == mawk ]] && (( d >= 20230302 && (x *1000 +y) *1000 +z >= 1003004 )) && __fzf_awk=mawk
-    fi
-    [[ $(HISTTIMEFORMAT='' builtin history 1) =~ [[:digit:]]+ ]]    # how many history entries
+    local output script deletefile
+    deletefile=$(mktemp)
+    [[ $(HISTTIMEFORMAT='' builtin history 1) =~ [[:digit:]]+ ]] # how many history entries
     script='function P(b) { ++n; sub(/^[ *]/, "", b); if (!seen[b]++) { printf "%d\t%s%c", '$((BASH_REMATCH + 1))' - n, b, 0 } }
     NR==1 { b = substr($0, 2); next }
     /^\t/ { P(b); b = substr($0, 2); next }
@@ -89,13 +124,16 @@ else # awk - fallback for POSIX systems
     END { if (NR) P(b) }'
     output=$(
       set +o pipefail
-      builtin fc -lnr -2147483648 2> /dev/null |   # ( $'\t '<lines>$'\n' )* ; <lines> ::= [^\n]* ( $'\n'<lines> )*
-        command $__fzf_awk "$script"           |   # ( <counter>$'\t'<lines>$'\000' )*
-        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"$'\t'"↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
+      builtin fc -lnr -2147483648 2> /dev/null | # ( $'\t '<lines>$'\n' )* ; <lines> ::= [^\n]* ( $'\n'<lines> )*
+        __fzf_exec_awk "$script" |               # ( <counter>$'\t'<lines>$'\000' )*
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort,alt-r:toggle-raw --wrap-sign '"$'\t'"↳ ' --highlight-line --bind 'shift-delete:execute-silent(cat {+f1} >> \"$deletefile\")+exclude-multi' --multi ${FZF_CTRL_R_OPTS-} --read0") \
         FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
-    ) || return
+    )
+    __fzf_history_delete "$deletefile"
+    command rm -f "$deletefile"
+    [[ -n $output ]] || return
     READLINE_LINE=${output#*$'\t'}
-    if [[ -z "$READLINE_POINT" ]]; then
+    if [[ -z $READLINE_POINT ]]; then
       echo "$READLINE_LINE"
     else
       READLINE_POINT=0x7fffffff
@@ -104,43 +142,54 @@ else # awk - fallback for POSIX systems
 fi
 
 # Required to refresh the prompt after fzf
-bind -m emacs-standard '"\er": redraw-current-line'
+bind -m emacs-standard '"\C-\e(": redraw-current-line'
 
 bind -m vi-command '"\C-z": emacs-editing-mode'
 bind -m vi-insert '"\C-z": emacs-editing-mode'
 bind -m emacs-standard '"\C-z": vi-editing-mode'
 
-if (( BASH_VERSINFO[0] < 4 )); then
+if ((BASH_VERSINFO[0] < 4)); then
   # CTRL-T - Paste the selected file path into the command line
-  if [[ "${FZF_CTRL_T_COMMAND-x}" != "" ]]; then
-    bind -m emacs-standard '"\C-t": " \C-b\C-k \C-u`__fzf_select__`\e\C-e\er\C-a\C-y\C-h\C-e\e \C-y\ey\C-x\C-x\C-f"'
+  if [[ ${FZF_CTRL_T_COMMAND-x} != "" ]]; then
+    bind -m emacs-standard '"\C-t": " \C-b\C-k \C-u`__fzf_select__`\e\C-e\C-\e(\C-a\C-y\C-h\C-e\e \C-y\ey\C-x\C-x\C-f\C-y\ey\C-_"'
     bind -m vi-command '"\C-t": "\C-z\C-t\C-z"'
     bind -m vi-insert '"\C-t": "\C-z\C-t\C-z"'
   fi
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind -m emacs-standard '"\C-r": "\C-e \C-u\C-y\ey\C-u`__fzf_history__`\e\C-e\er"'
-  bind -m vi-command '"\C-r": "\C-z\C-r\C-z"'
-  bind -m vi-insert '"\C-r": "\C-z\C-r\C-z"'
+  if [[ ${FZF_CTRL_R_COMMAND-x} != "" ]]; then
+    if [[ -n ${FZF_CTRL_R_COMMAND-} ]]; then
+      echo "warning: FZF_CTRL_R_COMMAND is set to a custom command, but custom commands are not yet supported for CTRL-R" >&2
+    fi
+    bind -m emacs-standard '"\C-r": "\C-e \C-u\C-y\ey\C-u`__fzf_history__`\e\C-e\C-\e("'
+    bind -m vi-command '"\C-r": "\C-z\C-r\C-z"'
+    bind -m vi-insert '"\C-r": "\C-z\C-r\C-z"'
+  fi
 else
   # CTRL-T - Paste the selected file path into the command line
-  if [[ "${FZF_CTRL_T_COMMAND-x}" != "" ]]; then
+  if [[ ${FZF_CTRL_T_COMMAND-x} != "" ]]; then
     bind -m emacs-standard -x '"\C-t": fzf-file-widget'
     bind -m vi-command -x '"\C-t": fzf-file-widget'
     bind -m vi-insert -x '"\C-t": fzf-file-widget'
   fi
 
   # CTRL-R - Paste the selected command from history into the command line
-  bind -m emacs-standard -x '"\C-r": __fzf_history__'
-  bind -m vi-command -x '"\C-r": __fzf_history__'
-  bind -m vi-insert -x '"\C-r": __fzf_history__'
+  if [[ ${FZF_CTRL_R_COMMAND-x} != "" ]]; then
+    if [[ -n ${FZF_CTRL_R_COMMAND-} ]]; then
+      echo "warning: FZF_CTRL_R_COMMAND is set to a custom command, but custom commands are not yet supported for CTRL-R" >&2
+    fi
+    bind -m emacs-standard -x '"\C-r": __fzf_history__'
+    bind -m vi-command -x '"\C-r": __fzf_history__'
+    bind -m vi-insert -x '"\C-r": __fzf_history__'
+  fi
 fi
 
 # ALT-C - cd into the selected directory
-if [[ "${FZF_ALT_C_COMMAND-x}" != "" ]]; then
-  bind -m emacs-standard '"\ec": " \C-b\C-k \C-u`__fzf_cd__`\e\C-e\er\C-m\C-y\C-h\e \C-y\ey\C-x\C-x\C-d"'
+if [[ ${FZF_ALT_C_COMMAND-x} != "" ]]; then
+  bind -m emacs-standard '"\ec": " \C-b\C-k \C-u`__fzf_cd__`\e\C-e\C-\e(\C-m\C-y\C-h\e \C-y\ey\C-x\C-x\C-d\C-y\ey\C-_"'
   bind -m vi-command '"\ec": "\C-z\ec\C-z"'
   bind -m vi-insert '"\ec": "\C-z\ec\C-z"'
 fi
+#----END shfmt
 
 fi

shell/key-bindings.fish

@@ -4,111 +4,40 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ key-bindings.fish
 #
-# - $FZF_TMUX_OPTS
 # - $FZF_CTRL_T_COMMAND
 # - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_COMMAND
 # - $FZF_CTRL_R_OPTS
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS
 
-
 # Key bindings
 # ------------
 function fzf_key_bindings
 
+  # The oldest supported fish version is 3.4.0. For this message being able to be
+  # displayed on older versions, the command substitution syntax $() should not
+  # be used anywhere in the script, otherwise the source command will fail.
+  if string match -qr -- '^[12]\\.|^3\\.[0-3]' $version
+    echo "fzf key bindings script requires fish version 3.4.0 or newer." >&2
+    return 1
+  else if not command -q fzf
+    echo "fzf was not found in path." >&2
+    return 1
+  end
+
   function __fzf_defaults
-    # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-    # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
-    echo "--height $FZF_TMUX_HEIGHT --bind=ctrl-z:ignore" $argv[1]
-    test -r "$FZF_DEFAULT_OPTS_FILE"; and string collect -N -- <$FZF_DEFAULT_OPTS_FILE
-    echo $FZF_DEFAULT_OPTS $argv[2]
-  end
-
-  # Store current token in $dir as root for the 'find' command
-  function fzf-file-widget -d "List files and folders"
-    set -l commandline (__fzf_parse_commandline)
-    set -lx dir $commandline[1]
-    set -l fzf_query $commandline[2]
-    set -l prefix $commandline[3]
-    set -l result
-
-    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
-    begin
-      set -lx FZF_DEFAULT_OPTS (__fzf_defaults "--reverse --walker=file,dir,follow,hidden --scheme=path --walker-root=$dir" "$FZF_CTRL_T_OPTS")
-      set -lx FZF_DEFAULT_COMMAND "$FZF_CTRL_T_COMMAND"
-      set -lx FZF_DEFAULT_OPTS_FILE ''
-      set result (eval (__fzfcmd) -m --query=$fzf_query)
-    end
-    if test -z "$result"
-      commandline -f repaint
-      return
-    else
-      # Remove last token from commandline.
-      commandline -t ""
-    end
-    for i in $result
-      commandline -it -- $prefix
-      commandline -it -- (string escape -- $i)
-      commandline -it -- ' '
-    end
-    commandline -f repaint
-  end
-
-  function fzf-history-widget -d "Show command history"
-    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
-    begin
-      # merge history from other sessions before searching
-      test -z "$fish_private_mode"; and builtin history merge
-
-      set -lx FZF_DEFAULT_OPTS (__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"\t"↳ ' --highlight-line +m $FZF_CTRL_R_OPTS")
-      set -lx FZF_DEFAULT_OPTS_FILE ''
-      set -lx FZF_DEFAULT_COMMAND
-      string match -q -r -- '/fish$' $SHELL; or set -lx SHELL (type -p fish)
-      if type -q perl
-        set -a FZF_DEFAULT_OPTS '--tac'
-        set FZF_DEFAULT_COMMAND 'builtin history -z --reverse | command perl -0 -pe \'s/^/$.\t/g; s/\n/\n\t/gm\''
-      else
-        set FZF_DEFAULT_COMMAND \
-          'set -l h (builtin history -z --reverse | string split0);' \
-          'for i in (seq (count $h) -1 1);' \
-          'string join0 -- $i\t(string replace -a -- \n \n\t $h[$i] | string collect);' \
-          'end'
-      end
-      set -l result (eval "$FZF_DEFAULT_COMMAND | $(__fzfcmd) --read0 --print0 -q (commandline) --bind='enter:become:string replace -a -- \n\t \n {2..} | string collect'")
-      and commandline -- $result
-    end
-    commandline -f repaint
-  end
-
-  function fzf-cd-widget -d "Change directory"
-    set -l commandline (__fzf_parse_commandline)
-    set -lx dir $commandline[1]
-    set -l fzf_query $commandline[2]
-    set -l prefix $commandline[3]
-
-    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
-    begin
-      set -lx FZF_DEFAULT_OPTS (__fzf_defaults "--reverse --walker=dir,follow,hidden --scheme=path --walker-root=$dir" "$FZF_ALT_C_OPTS")
-      set -lx FZF_DEFAULT_OPTS_FILE ''
-      set -lx FZF_DEFAULT_COMMAND "$FZF_ALT_C_COMMAND"
-      set -l result (eval (__fzfcmd) +m --query=$fzf_query)
-
-      if test -n "$result"
-        cd -- $result
-
-        # Remove last token from commandline.
-        commandline -t ""
-        commandline -it -- $prefix
-      end
-    end
-
-    commandline -f repaint
+    # $argv[1]: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+    # $argv[2..]: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+    test -n "$FZF_TMUX_HEIGHT"; or set -l FZF_TMUX_HEIGHT 40%
+    string join ' ' -- \
+      "--height $FZF_TMUX_HEIGHT --min-height=20+ --bind=ctrl-z:ignore" $argv[1] \
+      (test -r "$FZF_DEFAULT_OPTS_FILE"; and string join -- ' ' <$FZF_DEFAULT_OPTS_FILE) \
+      $FZF_DEFAULT_OPTS $argv[2..]
   end
 
   function __fzfcmd
-    test -n "$FZF_TMUX"; or set FZF_TMUX 0
-    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    test -n "$FZF_TMUX_HEIGHT"; or set -l FZF_TMUX_HEIGHT 40%
     if test -n "$FZF_TMUX_OPTS"
       echo "fzf-tmux $FZF_TMUX_OPTS -- "
     else if test "$FZF_TMUX" = "1"
@@ -118,82 +47,173 @@ function fzf_key_bindings
     end
   end
 
-  bind \cr fzf-history-widget
-  if not set -q FZF_CTRL_T_COMMAND; or test -n "$FZF_CTRL_T_COMMAND"
-    bind \ct fzf-file-widget
-  end
-  if not set -q FZF_ALT_C_COMMAND; or test -n "$FZF_ALT_C_COMMAND"
-    bind \ec fzf-cd-widget
-  end
-
-  bind -M insert \cr fzf-history-widget
-  if not set -q FZF_CTRL_T_COMMAND; or test -n "$FZF_CTRL_T_COMMAND"
-    bind -M insert \ct fzf-file-widget
-  end
-  if not set -q FZF_ALT_C_COMMAND; or test -n "$FZF_ALT_C_COMMAND"
-    bind -M insert \ec fzf-cd-widget
-  end
-
   function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath, fzf query, and optional -option= prefix'
-    set -l commandline (commandline -t)
+    set -l fzf_query ''
+    set -l prefix ''
+    set -l dir '.'
 
-    # strip -option= from token if present
-    set -l prefix (string match -r -- '^-[^\s=]+=' $commandline)
-    set commandline (string replace -- "$prefix" '' $commandline)
+    set -l -- match_regex '(?<fzf_query>[\\s\\S]*?(?=\\n?$)$)'
+    set -l -- prefix_regex '^-[^\\s=]+=|^-(?!-)\\S'
 
-    # Enable home directory expansion of leading ~/
-    set commandline (string replace -r -- '^~/' '\$HOME/' $commandline)
+    # Don't use option prefix if " -- " is preceded.
+    string match -qv -- '* -- *' (string sub -l (commandline -Cp) -- (commandline -p))
+    and set -- match_regex "(?<prefix>$prefix_regex)?$match_regex"
 
-    # escape special characters, except for the $ sign of valid variable names,
-    # so that after eval, the original string is returned, but with the
-    # variable names replaced by their values.
-    set commandline (string escape -n -- $commandline)
-    set commandline (string replace -r -a -- '\x5c\$(?=[\w])' '\$' $commandline)
-
-    # eval is used to do shell expansion on paths
-    eval set commandline $commandline
-
-    # Combine multiple consecutive slashes into one
-    set commandline (string replace -r -a -- '/+' '/' $commandline)
-
-    if test -z "$commandline"
-      # Default to current directory with no --query
-      set dir '.'
-      set fzf_query ''
+    # Set $prefix and expanded $fzf_query with preserved trailing newlines.
+    if string match -qr -- '^\\d\\d+|^[4-9]' $version
+      # fish v4.0.0 and newer
+      string match -q -r -- $match_regex (commandline --current-token --tokens-expanded | string collect -N)
     else
-      set dir (__fzf_get_dir $commandline)
+      string match -q -r -- $match_regex (commandline --current-token --tokenize | string collect -N)
+      eval set -- fzf_query (string escape -n -- $fzf_query | string replace -r -a '^\\\\(?=~)|\\\\(?=\\$\\w)' '')
+    end
 
-      # BUG: on combined expressions, if a left argument is a single `!`, the
-      # builtin test command of fish will treat it as the ! operator. To
-      # overcome this, have the variable parts on the right.
-      if test "." = "$dir" -a "./" != (string sub -l 2 -- $commandline)
-        # if $dir is "." but commandline is not a relative path, this means no file path found
-        set fzf_query $commandline
+    if test -n "$fzf_query"
+      # Normalize path in $fzf_query, set $dir to the longest existing directory.
+      if string match -qr -- '^\\d\\d+|^4|^3\\.[5-9]' $version
+        # fish v3.5.0 and newer
+        set -- fzf_query (path normalize -- $fzf_query)
+        set -- dir $fzf_query
+        while not path is -d $dir
+          set -- dir (path dirname $dir)
+        end
       else
-        # Also remove trailing slash after dir, to "split" input properly
-        set fzf_query (string replace -r -- "^$dir/?" '' $commandline)
+        string match -q -r -- '(?<fzf_query>^[\\s\\S]*?(?=\\n?$)$)' \
+          (string replace -r -a -- '(?<=/)/|(?<!^)/+(?!\\n)$' '' $fzf_query | string collect -N)
+        set -- dir $fzf_query
+        while not test -d "$dir"
+          set -- dir (dirname -z -- "$dir" | string split0)
+        end
+      end
+
+      if not string match -q -- '.' $dir; or string match -qr -- '^\\.(/|$)' $fzf_query
+        # Strip $dir from $fzf_query - preserve trailing newlines.
+        if string match -qr -- '^\\d\\d+|^[4-9]' $version
+          # fish v4.0.0 and newer
+          string match -q -r -- '^'(string escape --style=regex -- $dir)'/?(?<fzf_query>[\\s\\S]*)' $fzf_query
+        else
+          string match -q -r -- '^/?(?<fzf_query>[\\s\\S]*?(?=\\n?$)$)' \
+            (string replace -- "$dir" '' $fzf_query | string collect -N)
+        end
       end
     end
 
-    echo (string escape -- $dir)
-    echo (string escape -- $fzf_query)
-    echo $prefix
+    string escape -n -- "$dir" "$fzf_query" "$prefix"
   end
 
-  function __fzf_get_dir -d 'Find the longest existing filepath from input string'
-    set dir $argv
+  # Store current token in $dir as root for the 'find' command
+  function fzf-file-widget -d "List files and folders"
+    set -l commandline (__fzf_parse_commandline)
+    set -lx dir $commandline[1]
+    set -l fzf_query $commandline[2]
+    set -l prefix $commandline[3]
 
-    # Strip trailing slash, unless $dir is root dir (/)
-    set dir (string replace -r -- '(?<!^)/$' '' $dir)
+    set -lx FZF_DEFAULT_OPTS (__fzf_defaults \
+      "--reverse --walker=file,dir,follow,hidden --scheme=path" \
+      "--multi $FZF_CTRL_T_OPTS --print0")
 
-    # Iteratively check if dir exists and strip tail end of path
-    while test ! -d "$dir"
-      # If path is absolute, this can keep going until ends up at /
-      # If path is relative, this can keep going until entire input is consumed, dirname returns "."
-      set dir (dirname -- "$dir")
+    set -lx FZF_DEFAULT_COMMAND "$FZF_CTRL_T_COMMAND"
+    set -lx FZF_DEFAULT_OPTS_FILE
+
+    set -l result (eval (__fzfcmd) --walker-root=$dir --query=$fzf_query | string split0)
+    and commandline -rt -- (string join -- ' ' $prefix(string escape -n -- $result))' '
+
+    commandline -f repaint
+  end
+
+  function fzf-history-widget -d "Show command history"
+    set -l -- command_line (commandline)
+    set -l -- current_line (commandline -L)
+    set -l -- total_lines (count $command_line)
+    set -l -- fzf_query (string escape -- $command_line[$current_line])
+
+    set -lx -- FZF_DEFAULT_OPTS (__fzf_defaults '' \
+      '--with-nth=2.. --nth=2..,.. --scheme=history --multi --no-multi-line' \
+      '--no-wrap --wrap-sign="\t\t\t↳ " --preview-wrap-sign="↳ " --freeze-left=1' \
+      '--bind="alt-enter:become(set -g fzf_temp {+sf3..}; string join0 -- (string split0 -- <$fzf_temp | fish_indent -i); unlink $fzf_temp &>/dev/null)"' \
+      '--bind="alt-t:change-with-nth(1,3..|3..|2..)"' \
+      '--bind="shift-delete:execute-silent(eval builtin history delete -Ce -- (string escape -n -- (string split0 -- <{+sf3..})))+reload(eval $FZF_DEFAULT_COMMAND)"' \
+      "--bind=ctrl-r:toggle-sort,alt-r:toggle-raw --highlight-line $FZF_CTRL_R_OPTS" \
+      '--accept-nth=3.. --delimiter="\t" --tabstop=4 --read0 --print0 --with-shell='(status fish-path)\\ -c)
+
+    # Add dynamic preview options if preview command isn't already set by user
+    if string match -qvr -- '--preview[= ]' "$FZF_DEFAULT_OPTS"
+      # Prepend the options to allow user overrides
+      set -p -- FZF_DEFAULT_OPTS \
+        '--bind="focus,multi,resize:bg-transform:if test \\"$FZF_COLUMNS\\" -gt 100 -a \\\\( \\"$FZF_SELECT_COUNT\\" -gt 0 -o \\\\( -z \\"$FZF_WRAP\\" -a (string join0 -- <{f3..} | string length) -gt (math $FZF_COLUMNS - (switch $FZF_WITH_NTH; case 2..; echo 13; case 1,3..; echo 25; case 3..; echo 1; end)) \\\\) -o (string split0 -- <{sf3..} | fish_indent | count) -gt 1 \\\\); echo show-preview; else; echo hide-preview; end"' \
+        '--preview="test \\"$FZF_SELECT_COUNT\\" -gt 0; and string split0 -- <{+sf3..} | fish_indent (string match -q -- 3.\\\\* $version; or echo -- --only-indent) --ansi; and echo -n \\\\n; string collect -- \\\\#\\\\ {1} (string split0 -- <{sf3..}) | fish_indent --ansi"' \
+        '--preview-window="right,50%,wrap-word,follow,info,hidden"'
     end
 
-    echo $dir
+    set -lx FZF_DEFAULT_OPTS_FILE
+
+    set -lx -- FZF_DEFAULT_COMMAND 'builtin history -z'
+
+    # Enable syntax highlighting colors on fish v4.3.3 and newer
+    if string match -qr -- '^\\d\\d+|^4\\.[4-9]|^4\\.3\\.[3-9]' $version
+      set -a -- FZF_DEFAULT_OPTS '--ansi'
+      set -a -- FZF_DEFAULT_COMMAND '--color=always --show-time=(set_color $fish_color_comment)"%F %a %T%t%s%t"(set_color $fish_color_normal)'
+    else
+      set -a -- FZF_DEFAULT_COMMAND '--show-time="%F %a %T%t%s%t"'
+    end
+
+    # Merge history from other sessions before searching
+    test -z "$fish_private_mode"; and builtin history merge
+
+    if set -l result (eval $FZF_DEFAULT_COMMAND \| (__fzfcmd) --query=$fzf_query | string split0)
+      if test "$total_lines" -eq 1
+        commandline -- $result
+      else
+        set -l a (math $current_line - 1)
+        set -l b (math $current_line + 1)
+        commandline -- $command_line[1..$a] $result
+        commandline -a -- '' $command_line[$b..-1]
+      end
+    end
+
+    commandline -f repaint
+  end
+
+  function fzf-cd-widget -d "Change directory"
+    set -l commandline (__fzf_parse_commandline)
+    set -lx dir $commandline[1]
+    set -l fzf_query $commandline[2]
+    set -l prefix $commandline[3]
+
+    set -lx FZF_DEFAULT_OPTS (__fzf_defaults \
+      "--reverse --walker=dir,follow,hidden --scheme=path" \
+      "$FZF_ALT_C_OPTS --no-multi --print0")
+
+    set -lx FZF_DEFAULT_OPTS_FILE
+    set -lx FZF_DEFAULT_COMMAND "$FZF_ALT_C_COMMAND"
+
+    if set -l result (eval (__fzfcmd) --query=$fzf_query --walker-root=$dir | string split0)
+      cd -- $result
+      commandline -rt -- $prefix
+    end
+
+    commandline -f repaint
+  end
+
+  if not set -q FZF_CTRL_R_COMMAND; or test -n "$FZF_CTRL_R_COMMAND"
+    if test -n "$FZF_CTRL_R_COMMAND"
+      echo "warning: FZF_CTRL_R_COMMAND is set to a custom command, but custom commands are not yet supported for CTRL-R" >&2
+    end
+    bind \cr fzf-history-widget
+    bind -M insert \cr fzf-history-widget
+  end
+
+  if not set -q FZF_CTRL_T_COMMAND; or test -n "$FZF_CTRL_T_COMMAND"
+    bind \ct fzf-file-widget
+    bind -M insert \ct fzf-file-widget
+  end
+
+  if not set -q FZF_ALT_C_COMMAND; or test -n "$FZF_ALT_C_COMMAND"
+    bind \ec fzf-cd-widget
+    bind -M insert \ec fzf-cd-widget
   end
 
 end
+
+# Run setup
+fzf_key_bindings

shell/key-bindings.zsh

@@ -4,9 +4,9 @@
 #  / __/ / /_/ __/
 # /_/   /___/_/ key-bindings.zsh
 #
-# - $FZF_TMUX_OPTS
 # - $FZF_CTRL_T_COMMAND
 # - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_COMMAND
 # - $FZF_CTRL_R_OPTS
 # - $FZF_ALT_C_COMMAND
 # - $FZF_ALT_C_OPTS
@@ -38,14 +38,35 @@ fi
 {
 if [[ -o interactive ]]; then
 
+#----BEGIN INCLUDE common.sh
+# NOTE: Do not directly edit this section, which is copied from "common.sh".
+# To modify it, one can edit "common.sh" and run "./update.sh" to apply
+# the changes. See code comments in "common.sh" for the implementation details.
+
 __fzf_defaults() {
-  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
-  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  builtin printf '%s\n' "--height ${FZF_TMUX_HEIGHT:-40%} --min-height 20+ --bind=ctrl-z:ignore $1"
   command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
-  echo "${FZF_DEFAULT_OPTS-} $2"
+  builtin printf '%s\n' "${FZF_DEFAULT_OPTS-} $2"
 }
 
+__fzf_exec_awk() {
+  if [[ -z ${__fzf_awk-} ]]; then
+    __fzf_awk=awk
+    if [[ $OSTYPE == solaris* && -x /usr/xpg4/bin/awk ]]; then
+      __fzf_awk=/usr/xpg4/bin/awk
+    elif command -v mawk > /dev/null 2>&1; then
+      local n x y z d
+      IFS=' .' read -r n x y z d <<< $(command mawk -W version 2> /dev/null)
+      [[ $n == mawk ]] &&
+        (((x * 1000 + y) * 1000 + z >= 1003004)) 2> /dev/null &&
+        ((d >= 20230302)) 2> /dev/null &&
+        __fzf_awk=mawk
+    fi
+  fi
+  LC_ALL=C exec "$__fzf_awk" "$@"
+}
+#----END INCLUDE
+
 # CTRL-T - Paste the selected file path(s) into the command line
 __fzf_select() {
   setopt localoptions pipefail no_aliases 2> /dev/null
@@ -106,25 +127,52 @@ fi
 
 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
-  local selected
-  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases noglob nobash_rematch 2> /dev/null
+  local selected extracted_with_perl=0
+  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases no_glob no_sh_glob no_ksharrays extendedglob 2> /dev/null
   # Ensure the module is loaded if not already, and the required features, such
   # as the associative 'history' array, which maps event numbers to full history
   # lines, are set. Also, make sure Perl is installed for multi-line output.
   if zmodload -F zsh/parameter p:{commands,history} 2>/dev/null && (( ${+commands[perl]} )); then
     selected="$(printf '%s\t%s\000' "${(kv)history[@]}" |
       perl -0 -ne 'if (!$seen{(/^\s*[0-9]+\**\t(.*)/s, $1)}++) { s/\n/\n\t/g; print; }' |
-      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '\t↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m --read0") \
+      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort,alt-r:toggle-raw --wrap-sign '\t↳ ' --highlight-line --multi ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} --read0") \
       FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
+      extracted_with_perl=1
   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") \
+    selected="$(fc -rl 1 | __fzf_exec_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,alt-r:toggle-raw --wrap-sign '\t↳ ' --highlight-line --multi ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER}") \
       FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
   fi
   local ret=$?
+  local -a cmds
+  # Avoid leaking auto assigned values when using backreferences '(#b)'
+  local -a mbegin mend match
   if [ -n "$selected" ]; then
-    if [[ $(awk '{print $1; exit}' <<< "$selected") =~ ^[1-9][0-9]* ]]; then
-      zle vi-fetch-history -n $MATCH
+    # Heuristic to check if the selected value is from history or a custom query
+    if ((( extracted_with_perl )) && [[ $selected == <->$'\t'* ]]) ||
+    ((( ! extracted_with_perl )) && [[ $selected == [[:blank:]]#<->(  |\* )* ]]); then
+      # Split at newlines
+      for line in ${(ps:\n:)selected}; do
+        if (( extracted_with_perl )); then
+          if [[ $line == (#b)(<->)(#B)$'\t'* ]]; then
+            (( ${+history[${match[1]}]} )) && cmds+=("${history[${match[1]}]}")
+          fi
+        elif [[ $line == [[:blank:]]#(#b)(<->)(#B)(  |\* )* ]]; then
+          # Avoid $history array: lags behind 'fc' on foreign commands (*)
+          # https://zsh.org/mla/users/2024/msg00692.html
+          # Push BUFFER onto stack; fetch and save history entry from BUFFER; restore
+          zle .push-line
+          zle vi-fetch-history -n ${match[1]}
+          (( ${#BUFFER} )) && cmds+=("${BUFFER}")
+          BUFFER=""
+          zle .get-line
+        fi
+      done
+      if (( ${#cmds[@]} )); then
+        # Join by newline after stripping trailing newlines from each command
+        BUFFER="${(pj:\n:)${(@)cmds%%$'\n'#}}"
+        CURSOR=${#BUFFER}
+      fi
     else # selected is a custom query, not from history
       LBUFFER="$selected"
     fi
@@ -132,10 +180,15 @@ fzf-history-widget() {
   zle reset-prompt
   return $ret
 }
-zle     -N            fzf-history-widget
-bindkey -M emacs '^R' fzf-history-widget
-bindkey -M vicmd '^R' fzf-history-widget
-bindkey -M viins '^R' fzf-history-widget
+if [[ ${FZF_CTRL_R_COMMAND-x} != "" ]]; then
+  if [[ -n ${FZF_CTRL_R_COMMAND-} ]]; then
+    echo "warning: FZF_CTRL_R_COMMAND is set to a custom command, but custom commands are not yet supported for CTRL-R" >&2
+  fi
+  zle     -N            fzf-history-widget
+  bindkey -M emacs '^R' fzf-history-widget
+  bindkey -M vicmd '^R' fzf-history-widget
+  bindkey -M viins '^R' fzf-history-widget
+fi
 fi
 
 } always {

shell/update.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+
+# This script applies the contents of "common.sh" to the other files.
+
+set -e
+
+dir=${0%"${0##*/}"}
+
+update() {
+  {
+    sed -n '1,/^#----BEGIN INCLUDE common\.sh/p' "$1"
+    cat << EOF
+# NOTE: Do not directly edit this section, which is copied from "common.sh".
+# To modify it, one can edit "common.sh" and run "./update.sh" to apply
+# the changes. See code comments in "common.sh" for the implementation details.
+EOF
+    echo
+    grep -v '^[[:blank:]]*#' "$dir/common.sh" # remove code comments in common.sh
+    sed -n '/^#----END INCLUDE/,$p' "$1"
+  } > "$1.part"
+
+  mv -f "$1.part" "$1"
+}
+
+update "$dir/completion.bash"
+update "$dir/completion.zsh"
+update "$dir/key-bindings.bash"
+update "$dir/key-bindings.zsh"
+
+# Check if --check is in ARGV
+check=0
+rest=()
+for arg in "$@"; do
+  case $arg in
+    --check) check=1 ;;
+    *) rest+=("$arg") ;;
+  esac
+done
+
+fmt() {
+  if ! grep -q "^#----BEGIN shfmt" "$1"; then
+    if [[ $check == 1 ]]; then
+      shfmt -d "$1"
+      return $?
+    else
+      shfmt -w "$1"
+    fi
+  else
+    {
+      sed -n '1,/^#----BEGIN shfmt/p' "$1" | sed '$d'
+      sed -n '/^#----BEGIN shfmt/,/^#----END shfmt/p' "$1" | shfmt --filename "$1"
+      sed -n '/^#----END shfmt/,$p' "$1" | sed '1d'
+    } > "$1.part"
+
+    if [[ $check == 1 ]]; then
+      diff -q "$1" "$1.part"
+      ret=$?
+      rm -f "$1.part"
+      return $ret
+    fi
+
+    mv -f "$1.part" "$1"
+  fi
+}
+
+for file in "${rest[@]}"; do
+  fmt "$file" || exit $?
+done

src/LICENSE

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

src/actiontype_string.go

@@ -12,129 +12,185 @@ func _() {
 	_ = x[actStart-1]
 	_ = x[actClick-2]
 	_ = x[actInvalid-3]
-	_ = x[actChar-4]
-	_ = x[actMouse-5]
-	_ = x[actBeginningOfLine-6]
-	_ = x[actAbort-7]
-	_ = x[actAccept-8]
-	_ = x[actAcceptNonEmpty-9]
-	_ = x[actAcceptOrPrintQuery-10]
-	_ = x[actBackwardChar-11]
-	_ = x[actBackwardDeleteChar-12]
-	_ = x[actBackwardDeleteCharEof-13]
-	_ = x[actBackwardWord-14]
-	_ = x[actCancel-15]
-	_ = x[actChangeBorderLabel-16]
-	_ = x[actChangeListLabel-17]
-	_ = x[actChangeInputLabel-18]
-	_ = x[actChangeHeader-19]
-	_ = x[actChangeHeaderLabel-20]
-	_ = x[actChangeMulti-21]
-	_ = x[actChangePreviewLabel-22]
-	_ = x[actChangePrompt-23]
-	_ = x[actChangeQuery-24]
-	_ = x[actChangeNth-25]
-	_ = x[actClearScreen-26]
-	_ = x[actClearQuery-27]
-	_ = x[actClearSelection-28]
-	_ = x[actClose-29]
-	_ = x[actDeleteChar-30]
-	_ = x[actDeleteCharEof-31]
-	_ = x[actEndOfLine-32]
-	_ = x[actFatal-33]
-	_ = x[actForwardChar-34]
-	_ = x[actForwardWord-35]
-	_ = x[actKillLine-36]
-	_ = x[actKillWord-37]
-	_ = x[actUnixLineDiscard-38]
-	_ = x[actUnixWordRubout-39]
-	_ = x[actYank-40]
-	_ = x[actBackwardKillWord-41]
-	_ = x[actSelectAll-42]
-	_ = x[actDeselectAll-43]
-	_ = x[actToggle-44]
-	_ = x[actToggleSearch-45]
-	_ = x[actToggleAll-46]
-	_ = x[actToggleDown-47]
-	_ = x[actToggleUp-48]
-	_ = x[actToggleIn-49]
-	_ = x[actToggleOut-50]
-	_ = x[actToggleTrack-51]
-	_ = x[actToggleTrackCurrent-52]
-	_ = x[actToggleHeader-53]
-	_ = x[actToggleWrap-54]
-	_ = x[actToggleMultiLine-55]
-	_ = x[actToggleHscroll-56]
-	_ = x[actTrackCurrent-57]
-	_ = x[actUntrackCurrent-58]
-	_ = x[actDown-59]
-	_ = x[actUp-60]
-	_ = x[actPageUp-61]
-	_ = x[actPageDown-62]
-	_ = x[actPosition-63]
-	_ = x[actHalfPageUp-64]
-	_ = x[actHalfPageDown-65]
-	_ = x[actOffsetUp-66]
-	_ = x[actOffsetDown-67]
-	_ = x[actOffsetMiddle-68]
-	_ = x[actJump-69]
-	_ = x[actJumpAccept-70]
-	_ = x[actPrintQuery-71]
-	_ = x[actRefreshPreview-72]
-	_ = x[actReplaceQuery-73]
-	_ = x[actToggleSort-74]
-	_ = x[actShowPreview-75]
-	_ = x[actHidePreview-76]
-	_ = x[actTogglePreview-77]
-	_ = x[actTogglePreviewWrap-78]
-	_ = x[actTransform-79]
-	_ = x[actTransformBorderLabel-80]
-	_ = x[actTransformListLabel-81]
-	_ = x[actTransformInputLabel-82]
-	_ = x[actTransformHeader-83]
-	_ = x[actTransformHeaderLabel-84]
-	_ = x[actTransformPreviewLabel-85]
-	_ = x[actTransformPrompt-86]
-	_ = x[actTransformQuery-87]
-	_ = x[actPreview-88]
-	_ = x[actChangePreview-89]
-	_ = x[actChangePreviewWindow-90]
-	_ = x[actPreviewTop-91]
-	_ = x[actPreviewBottom-92]
-	_ = x[actPreviewUp-93]
-	_ = x[actPreviewDown-94]
-	_ = x[actPreviewPageUp-95]
-	_ = x[actPreviewPageDown-96]
-	_ = x[actPreviewHalfPageUp-97]
-	_ = x[actPreviewHalfPageDown-98]
-	_ = x[actPrevHistory-99]
-	_ = x[actPrevSelected-100]
-	_ = x[actPrint-101]
-	_ = x[actPut-102]
-	_ = x[actNextHistory-103]
-	_ = x[actNextSelected-104]
-	_ = x[actExecute-105]
-	_ = x[actExecuteSilent-106]
-	_ = x[actExecuteMulti-107]
-	_ = x[actSigStop-108]
-	_ = x[actFirst-109]
-	_ = x[actLast-110]
-	_ = x[actReload-111]
-	_ = x[actReloadSync-112]
-	_ = x[actDisableSearch-113]
-	_ = x[actEnableSearch-114]
-	_ = x[actSelect-115]
-	_ = x[actDeselect-116]
-	_ = x[actUnbind-117]
-	_ = x[actRebind-118]
-	_ = x[actBecome-119]
-	_ = x[actShowHeader-120]
-	_ = x[actHideHeader-121]
+	_ = x[actBracketedPasteBegin-4]
+	_ = x[actBracketedPasteEnd-5]
+	_ = x[actChar-6]
+	_ = x[actMouse-7]
+	_ = x[actBeginningOfLine-8]
+	_ = x[actAbort-9]
+	_ = x[actAccept-10]
+	_ = x[actAcceptNonEmpty-11]
+	_ = x[actAcceptOrPrintQuery-12]
+	_ = x[actBackwardChar-13]
+	_ = x[actBackwardDeleteChar-14]
+	_ = x[actBackwardDeleteCharEof-15]
+	_ = x[actBackwardWord-16]
+	_ = x[actBackwardSubWord-17]
+	_ = x[actCancel-18]
+	_ = x[actChangeBorderLabel-19]
+	_ = x[actChangeGhost-20]
+	_ = x[actChangeHeader-21]
+	_ = x[actChangeHeaderLines-22]
+	_ = x[actChangeFooter-23]
+	_ = x[actChangeHeaderLabel-24]
+	_ = x[actChangeFooterLabel-25]
+	_ = x[actChangeInputLabel-26]
+	_ = x[actChangeListLabel-27]
+	_ = x[actChangeMulti-28]
+	_ = x[actChangeNth-29]
+	_ = x[actChangeWithNth-30]
+	_ = x[actChangePointer-31]
+	_ = x[actChangePreview-32]
+	_ = x[actChangePreviewLabel-33]
+	_ = x[actChangePreviewWindow-34]
+	_ = x[actChangePrompt-35]
+	_ = x[actChangeQuery-36]
+	_ = x[actClearScreen-37]
+	_ = x[actClearQuery-38]
+	_ = x[actClearSelection-39]
+	_ = x[actClose-40]
+	_ = x[actDeleteChar-41]
+	_ = x[actDeleteCharEof-42]
+	_ = x[actEndOfLine-43]
+	_ = x[actFatal-44]
+	_ = x[actForwardChar-45]
+	_ = x[actForwardWord-46]
+	_ = x[actForwardSubWord-47]
+	_ = x[actKillLine-48]
+	_ = x[actKillWord-49]
+	_ = x[actKillSubWord-50]
+	_ = x[actUnixLineDiscard-51]
+	_ = x[actUnixWordRubout-52]
+	_ = x[actYank-53]
+	_ = x[actBackwardKillWord-54]
+	_ = x[actBackwardKillSubWord-55]
+	_ = x[actSelectAll-56]
+	_ = x[actDeselectAll-57]
+	_ = x[actToggle-58]
+	_ = x[actToggleSearch-59]
+	_ = x[actToggleAll-60]
+	_ = x[actToggleDown-61]
+	_ = x[actToggleUp-62]
+	_ = x[actToggleIn-63]
+	_ = x[actToggleOut-64]
+	_ = x[actToggleTrack-65]
+	_ = x[actToggleTrackCurrent-66]
+	_ = x[actToggleHeader-67]
+	_ = x[actToggleWrap-68]
+	_ = x[actToggleWrapWord-69]
+	_ = x[actToggleMultiLine-70]
+	_ = x[actToggleHscroll-71]
+	_ = x[actToggleRaw-72]
+	_ = x[actEnableRaw-73]
+	_ = x[actDisableRaw-74]
+	_ = x[actTrackCurrent-75]
+	_ = x[actToggleInput-76]
+	_ = x[actHideInput-77]
+	_ = x[actShowInput-78]
+	_ = x[actUntrackCurrent-79]
+	_ = x[actDown-80]
+	_ = x[actDownMatch-81]
+	_ = x[actUp-82]
+	_ = x[actUpMatch-83]
+	_ = x[actPageUp-84]
+	_ = x[actPageDown-85]
+	_ = x[actPosition-86]
+	_ = x[actHalfPageUp-87]
+	_ = x[actHalfPageDown-88]
+	_ = x[actOffsetUp-89]
+	_ = x[actOffsetDown-90]
+	_ = x[actOffsetMiddle-91]
+	_ = x[actJump-92]
+	_ = x[actJumpAccept-93]
+	_ = x[actPrintQuery-94]
+	_ = x[actRefreshPreview-95]
+	_ = x[actReplaceQuery-96]
+	_ = x[actToggleSort-97]
+	_ = x[actShowPreview-98]
+	_ = x[actHidePreview-99]
+	_ = x[actTogglePreview-100]
+	_ = x[actTogglePreviewWrap-101]
+	_ = x[actTogglePreviewWrapWord-102]
+	_ = x[actTransform-103]
+	_ = x[actTransformBorderLabel-104]
+	_ = x[actTransformGhost-105]
+	_ = x[actTransformHeader-106]
+	_ = x[actTransformHeaderLines-107]
+	_ = x[actTransformFooter-108]
+	_ = x[actTransformHeaderLabel-109]
+	_ = x[actTransformFooterLabel-110]
+	_ = x[actTransformInputLabel-111]
+	_ = x[actTransformListLabel-112]
+	_ = x[actTransformNth-113]
+	_ = x[actTransformWithNth-114]
+	_ = x[actTransformPointer-115]
+	_ = x[actTransformPreviewLabel-116]
+	_ = x[actTransformPrompt-117]
+	_ = x[actTransformQuery-118]
+	_ = x[actTransformSearch-119]
+	_ = x[actTrigger-120]
+	_ = x[actBgTransform-121]
+	_ = x[actBgTransformBorderLabel-122]
+	_ = x[actBgTransformGhost-123]
+	_ = x[actBgTransformHeader-124]
+	_ = x[actBgTransformHeaderLines-125]
+	_ = x[actBgTransformFooter-126]
+	_ = x[actBgTransformHeaderLabel-127]
+	_ = x[actBgTransformFooterLabel-128]
+	_ = x[actBgTransformInputLabel-129]
+	_ = x[actBgTransformListLabel-130]
+	_ = x[actBgTransformNth-131]
+	_ = x[actBgTransformWithNth-132]
+	_ = x[actBgTransformPointer-133]
+	_ = x[actBgTransformPreviewLabel-134]
+	_ = x[actBgTransformPrompt-135]
+	_ = x[actBgTransformQuery-136]
+	_ = x[actBgTransformSearch-137]
+	_ = x[actBgCancel-138]
+	_ = x[actSearch-139]
+	_ = x[actPreview-140]
+	_ = x[actPreviewTop-141]
+	_ = x[actPreviewBottom-142]
+	_ = x[actPreviewUp-143]
+	_ = x[actPreviewDown-144]
+	_ = x[actPreviewPageUp-145]
+	_ = x[actPreviewPageDown-146]
+	_ = x[actPreviewHalfPageUp-147]
+	_ = x[actPreviewHalfPageDown-148]
+	_ = x[actPrevHistory-149]
+	_ = x[actPrevSelected-150]
+	_ = x[actPrint-151]
+	_ = x[actPut-152]
+	_ = x[actNextHistory-153]
+	_ = x[actNextSelected-154]
+	_ = x[actExecute-155]
+	_ = x[actExecuteSilent-156]
+	_ = x[actExecuteMulti-157]
+	_ = x[actSigStop-158]
+	_ = x[actBest-159]
+	_ = x[actFirst-160]
+	_ = x[actLast-161]
+	_ = x[actReload-162]
+	_ = x[actReloadSync-163]
+	_ = x[actDisableSearch-164]
+	_ = x[actEnableSearch-165]
+	_ = x[actSelect-166]
+	_ = x[actDeselect-167]
+	_ = x[actUnbind-168]
+	_ = x[actRebind-169]
+	_ = x[actToggleBind-170]
+	_ = x[actBecome-171]
+	_ = x[actShowHeader-172]
+	_ = x[actHideHeader-173]
+	_ = x[actBell-174]
+	_ = x[actExclude-175]
+	_ = x[actExcludeMulti-176]
+	_ = x[actAsync-177]
 }
 
-const _actionType_name = "actIgnoreactStartactClickactInvalidactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactCancelactChangeBorderLabelactChangeListLabelactChangeInputLabelactChangeHeaderactChangeHeaderLabelactChangeMultiactChangePreviewLabelactChangePromptactChangeQueryactChangeNthactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactFatalactForwardCharactForwardWordactKillLineactKillWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleTrackCurrentactToggleHeaderactToggleWrapactToggleMultiLineactToggleHscrollactTrackCurrentactUntrackCurrentactDownactUpactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactOffsetMiddleactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTransformactTransformBorderLabelactTransformListLabelactTransformInputLabelactTransformHeaderactTransformHeaderLabelactTransformPreviewLabelactTransformPromptactTransformQueryactPreviewactChangePreviewactChangePreviewWindowactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPrintactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactBecomeactShowHeaderactHideHeader"
+const _actionType_name = "actIgnoreactStartactClickactInvalidactBracketedPasteBeginactBracketedPasteEndactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactBackwardSubWordactCancelactChangeBorderLabelactChangeGhostactChangeHeaderactChangeHeaderLinesactChangeFooteractChangeHeaderLabelactChangeFooterLabelactChangeInputLabelactChangeListLabelactChangeMultiactChangeNthactChangeWithNthactChangePointeractChangePreviewactChangePreviewLabelactChangePreviewWindowactChangePromptactChangeQueryactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactFatalactForwardCharactForwardWordactForwardSubWordactKillLineactKillWordactKillSubWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactBackwardKillSubWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleTrackCurrentactToggleHeaderactToggleWrapactToggleWrapWordactToggleMultiLineactToggleHscrollactToggleRawactEnableRawactDisableRawactTrackCurrentactToggleInputactHideInputactShowInputactUntrackCurrentactDownactDownMatchactUpactUpMatchactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactOffsetMiddleactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTogglePreviewWrapWordactTransformactTransformBorderLabelactTransformGhostactTransformHeaderactTransformHeaderLinesactTransformFooteractTransformHeaderLabelactTransformFooterLabelactTransformInputLabelactTransformListLabelactTransformNthactTransformWithNthactTransformPointeractTransformPreviewLabelactTransformPromptactTransformQueryactTransformSearchactTriggeractBgTransformactBgTransformBorderLabelactBgTransformGhostactBgTransformHeaderactBgTransformHeaderLinesactBgTransformFooteractBgTransformHeaderLabelactBgTransformFooterLabelactBgTransformInputLabelactBgTransformListLabelactBgTransformNthactBgTransformWithNthactBgTransformPointeractBgTransformPreviewLabelactBgTransformPromptactBgTransformQueryactBgTransformSearchactBgCancelactSearchactPreviewactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPrintactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactBestactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactToggleBindactBecomeactShowHeaderactHideHeaderactBellactExcludeactExcludeMultiactAsync"
 
-var _actionType_index = [...]uint16{0, 9, 17, 25, 35, 42, 50, 68, 76, 85, 102, 123, 138, 159, 183, 198, 207, 227, 245, 264, 279, 299, 313, 334, 349, 363, 375, 389, 402, 419, 427, 440, 456, 468, 476, 490, 504, 515, 526, 544, 561, 568, 587, 599, 613, 622, 637, 649, 662, 673, 684, 696, 710, 731, 746, 759, 777, 793, 808, 825, 832, 837, 846, 857, 868, 881, 896, 907, 920, 935, 942, 955, 968, 985, 1000, 1013, 1027, 1041, 1057, 1077, 1089, 1112, 1133, 1155, 1173, 1196, 1220, 1238, 1255, 1265, 1281, 1303, 1316, 1332, 1344, 1358, 1374, 1392, 1412, 1434, 1448, 1463, 1471, 1477, 1491, 1506, 1516, 1532, 1547, 1557, 1565, 1572, 1581, 1594, 1610, 1625, 1634, 1645, 1654, 1663, 1672, 1685, 1698}
+var _actionType_index = [...]uint16{0, 9, 17, 25, 35, 57, 77, 84, 92, 110, 118, 127, 144, 165, 180, 201, 225, 240, 258, 267, 287, 301, 316, 336, 351, 371, 391, 410, 428, 442, 454, 470, 486, 502, 523, 545, 560, 574, 588, 601, 618, 626, 639, 655, 667, 675, 689, 703, 720, 731, 742, 756, 774, 791, 798, 817, 839, 851, 865, 874, 889, 901, 914, 925, 936, 948, 962, 983, 998, 1011, 1028, 1046, 1062, 1074, 1086, 1099, 1114, 1128, 1140, 1152, 1169, 1176, 1188, 1193, 1203, 1212, 1223, 1234, 1247, 1262, 1273, 1286, 1301, 1308, 1321, 1334, 1351, 1366, 1379, 1393, 1407, 1423, 1443, 1467, 1479, 1502, 1519, 1537, 1560, 1578, 1601, 1624, 1646, 1667, 1682, 1701, 1720, 1744, 1762, 1779, 1797, 1807, 1821, 1846, 1865, 1885, 1910, 1930, 1955, 1980, 2004, 2027, 2044, 2065, 2086, 2112, 2132, 2151, 2171, 2182, 2191, 2201, 2214, 2230, 2242, 2256, 2272, 2290, 2310, 2332, 2346, 2361, 2369, 2375, 2389, 2404, 2414, 2430, 2445, 2455, 2462, 2470, 2477, 2486, 2499, 2515, 2530, 2539, 2550, 2559, 2568, 2581, 2590, 2603, 2616, 2623, 2633, 2648, 2656}
 
 func (i actionType) String() string {
 	if i < 0 || i >= actionType(len(_actionType_index)-1) {

src/algo/SIMD.md

@@ -0,0 +1,99 @@
+# SIMD byte search: `indexByteTwo` / `lastIndexByteTwo`
+
+## What these functions do
+
+`indexByteTwo(s []byte, b1, b2 byte) int` -- returns the index of the
+**first** occurrence of `b1` or `b2` in `s`, or `-1`.
+
+`lastIndexByteTwo(s []byte, b1, b2 byte) int` -- returns the index of the
+**last** occurrence of `b1` or `b2` in `s`, or `-1`.
+
+They are used by the fuzzy matching algorithm (`algo.go`) to skip ahead
+during case-insensitive search. Instead of calling `bytes.IndexByte` twice
+(once for lowercase, once for uppercase), a single SIMD pass finds both at
+once.
+
+## File layout
+
+| File                  | Purpose                                                           |
+| ------                | ---------                                                         |
+| `indexbyte2_arm64.go` | Go declarations (`//go:noescape`) for ARM64                       |
+| `indexbyte2_arm64.s`  | ARM64 NEON assembly (32-byte aligned blocks, syndrome extraction) |
+| `indexbyte2_amd64.go` | Go declarations + AVX2 runtime detection for AMD64                |
+| `indexbyte2_amd64.s`  | AMD64 AVX2/SSE2 assembly with CPUID dispatch                      |
+| `indexbyte2_other.go` | Pure Go fallback for all other architectures                      |
+| `indexbyte2_test.go`  | Unit tests, exhaustive tests, fuzz tests, and benchmarks          |
+
+## How the SIMD implementations work
+
+**ARM64 (NEON):**
+- Broadcasts both needle bytes into NEON registers (`VMOV`).
+- Processes 32-byte aligned chunks. For each chunk, compares all bytes
+  against both needles (`VCMEQ`), ORs the results (`VORR`), and builds a
+  64-bit syndrome with 2 bits per byte.
+- `indexByteTwo` uses `RBIT` + `CLZ` to find the lowest set bit (first match).
+- `lastIndexByteTwo` scans backward and uses `CLZ` on the raw syndrome to
+  find the highest set bit (last match).
+- Handles alignment and partial first/last blocks with bit masking.
+- Adapted from Go's `internal/bytealg/indexbyte_arm64.s`.
+
+**AMD64 (AVX2 with SSE2 fallback):**
+- At init time, `cpuHasAVX2()` checks CPUID + XGETBV for AVX2 and OS YMM
+  support. The result is cached in `_useAVX2`.
+- **AVX2 path** (inputs >= 32 bytes, when available):
+  - Broadcasts both needles via `VPBROADCASTB`.
+  - Processes 32-byte blocks: `VPCMPEQB` against both needles, `VPOR`, then
+    `VPMOVMSKB` to get a 32-bit mask.
+  - 5 instructions per loop iteration (vs 7 for SSE2) at 2x the throughput.
+  - `VZEROUPPER` before every return to avoid SSE/AVX transition penalties.
+- **SSE2 fallback** (inputs < 32 bytes, or CPUs without AVX2):
+  - Broadcasts via `PUNPCKLBW` + `PSHUFL`.
+  - Processes 16-byte blocks: `PCMPEQB`, `POR`, `PMOVMSKB`.
+  - Small inputs (<16 bytes) are handled with page-boundary-safe loads.
+- Both paths use `BSFL` (forward) / `BSRL` (reverse) for bit scanning.
+- Adapted from Go's `internal/bytealg/indexbyte_amd64.s`.
+
+**Fallback (other platforms):**
+- `indexByteTwo` uses two `bytes.IndexByte` calls with scope-limiting
+  (search `b1` first, then limit the `b2` search to `s[:i1]`).
+- `lastIndexByteTwo` uses a simple backward for loop.
+
+## Running tests
+
+```bash
+# Unit + exhaustive tests
+go test ./src/algo/ -run 'TestIndexByteTwo|TestLastIndexByteTwo' -v
+
+# Fuzz tests (run for 10 seconds each)
+go test ./src/algo/ -run '^$' -fuzz FuzzIndexByteTwo -fuzztime 10s
+go test ./src/algo/ -run '^$' -fuzz FuzzLastIndexByteTwo -fuzztime 10s
+
+# Cross-architecture: test amd64 on an arm64 Mac (via Rosetta)
+GOARCH=amd64 go test ./src/algo/ -run 'TestIndexByteTwo|TestLastIndexByteTwo' -v
+GOARCH=amd64 go test ./src/algo/ -run '^$' -fuzz FuzzIndexByteTwo -fuzztime 10s
+GOARCH=amd64 go test ./src/algo/ -run '^$' -fuzz FuzzLastIndexByteTwo -fuzztime 10s
+```
+
+## Running micro-benchmarks
+
+```bash
+# All indexByteTwo / lastIndexByteTwo benchmarks
+go test ./src/algo/ -bench 'IndexByteTwo' -benchmem
+
+# Specific size
+go test ./src/algo/ -bench 'IndexByteTwo_1000'
+```
+
+Each benchmark compares the SIMD `asm` implementation against reference
+implementations (`2xIndexByte` using `bytes.IndexByte`, and a simple `loop`).
+
+## Correctness verification
+
+The assembly is verified by three layers of testing:
+
+1. **Table-driven tests** -- known inputs with expected outputs.
+2. **Exhaustive tests** -- all lengths 0–256, every match position, no-match
+   cases, and both-bytes-present cases, compared against a simple loop
+   reference.
+3. **Fuzz tests** -- randomized inputs via `testing.F`, compared against the
+   same loop reference.

src/algo/algo.go

@@ -303,7 +303,7 @@ func bonusAt(input *util.Chars, idx int) int16 {
 }
 
 func normalizeRune(r rune) rune {
-	if r < 0x00C0 || r > 0x2184 {
+	if r < 0x00C0 || r > 0xFF61 {
 		return r
 	}
 
@@ -321,22 +321,15 @@ type Algo func(caseSensitive bool, normalize bool, forward bool, input *util.Cha
 
 func trySkip(input *util.Chars, caseSensitive bool, b byte, from int) int {
 	byteArray := input.Bytes()[from:]
-	idx := bytes.IndexByte(byteArray, b)
-	if idx == 0 {
-		// Can't skip any further
-		return from
-	}
-	// We may need to search for the uppercase letter again. We don't have to
-	// consider normalization as we can be sure that this is an ASCII string.
+	// For case-insensitive search of a letter, search for both cases in one pass
 	if !caseSensitive && b >= 'a' && b <= 'z' {
-		if idx > 0 {
-			byteArray = byteArray[:idx]
-		}
-		uidx := bytes.IndexByte(byteArray, b-32)
-		if uidx >= 0 {
-			idx = uidx
+		idx := IndexByteTwo(byteArray, b, b-32)
+		if idx < 0 {
+			return -1
 		}
+		return from + idx
 	}
+	idx := bytes.IndexByte(byteArray, b)
 	if idx < 0 {
 		return -1
 	}
@@ -365,7 +358,7 @@ func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) (int
 
 	firstIdx, idx, lastIdx := 0, 0, 0
 	var b byte
-	for pidx := 0; pidx < len(pattern); pidx++ {
+	for pidx := range pattern {
 		b = byte(pattern[pidx])
 		idx = trySkip(input, caseSensitive, b, idx)
 		if idx < 0 {
@@ -380,14 +373,17 @@ func asciiFuzzyIndex(input *util.Chars, pattern []rune, caseSensitive bool) (int
 	}
 
 	// Find the last appearance of the last character of the pattern to limit the search scope
-	bu := b
-	if !caseSensitive && b >= 'a' && b <= 'z' {
-		bu = b - 32
-	}
 	scope := input.Bytes()[lastIdx:]
-	for offset := len(scope) - 1; offset > 0; offset-- {
-		if scope[offset] == b || scope[offset] == bu {
-			return firstIdx, lastIdx + offset + 1
+	if len(scope) > 1 {
+		tail := scope[1:]
+		var end int
+		if !caseSensitive && b >= 'a' && b <= 'z' {
+			end = lastIndexByteTwo(tail, b, b-32)
+		} else {
+			end = bytes.LastIndexByte(tail, b)
+		}
+		if end >= 0 {
+			return firstIdx, lastIdx + 1 + end + 1
 		}
 	}
 	return firstIdx, lastIdx + 1
@@ -445,7 +441,9 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 
 	// Since O(nm) algorithm can be prohibitively expensive for large input,
 	// we fall back to the greedy algorithm.
-	if slab != nil && N*M > cap(slab.I16) {
+	// Also, we should not allow a very long pattern to avoid 16-bit integer
+	// overflow in the score matrix. 1000 is a safe limit.
+	if slab != nil && N*M > cap(slab.I16) || M > 1000 {
 		return FuzzyMatchV1(caseSensitive, normalize, forward, input, pattern, withPos, slab)
 	}
 
@@ -501,7 +499,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			if pidx < M {
 				F[pidx] = int32(off)
 				pidx++
-				pchar = pattern[util.Min(pidx, M-1)]
+				pchar = pattern[min(pidx, M-1)]
 			}
 			lastIdx = off
 		}
@@ -519,9 +517,9 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			inGap = false
 		} else {
 			if inGap {
-				H0[off] = util.Max16(prevH0+scoreGapExtension, 0)
+				H0[off] = max(prevH0+scoreGapExtension, 0)
 			} else {
-				H0[off] = util.Max16(prevH0+scoreGapStart, 0)
+				H0[off] = max(prevH0+scoreGapStart, 0)
 			}
 			C0[off] = 0
 			inGap = true
@@ -587,7 +585,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 					if b >= bonusBoundary && b > fb {
 						consecutive = 1
 					} else {
-						b = util.Max16(b, util.Max16(bonusConsecutive, fb))
+						b = max(b, bonusConsecutive, fb)
 					}
 				}
 				if s1+b < s2 {
@@ -600,7 +598,7 @@ func FuzzyMatchV2(caseSensitive bool, normalize bool, forward bool, input *util.
 			Csub[off] = consecutive
 
 			inGap = s1 < s2
-			score := util.Max16(util.Max16(s1, s2), 0)
+			score := max(s1, s2, 0)
 			if pidx == M-1 && (forward && score > maxScore || !forward && score >= maxScore) {
 				maxScore, maxScorePos = score, col
 			}
@@ -684,7 +682,7 @@ func calculateScore(caseSensitive bool, normalize bool, text *util.Chars, patter
 				if bonus >= bonusBoundary && bonus > firstBonus {
 					firstBonus = bonus
 				}
-				bonus = util.Max16(util.Max16(bonus, firstBonus), bonusConsecutive)
+				bonus = max(bonus, firstBonus, bonusConsecutive)
 			}
 			if pidx == 0 {
 				score += int(bonus * bonusFirstCharMultiplier)
@@ -726,7 +724,7 @@ func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text *util.C
 	lenRunes := text.Length()
 	lenPattern := len(pattern)
 
-	for index := 0; index < lenRunes; index++ {
+	for index := range lenRunes {
 		char := text.Get(indexAt(index, lenRunes, forward))
 		// This is considerably faster than blindly applying strings.ToLower to the
 		// whole string
@@ -767,6 +765,9 @@ func FuzzyMatchV1(caseSensitive bool, normalize bool, forward bool, text *util.C
 					char = unicode.To(unicode.LowerCase, char)
 				}
 			}
+			if normalize {
+				char = normalizeRune(char)
+			}
 
 			pidx_ := indexAt(pidx, lenPattern, forward)
 			pchar := pattern[pidx_]
@@ -824,7 +825,7 @@ func exactMatchNaive(caseSensitive bool, normalize bool, forward bool, boundaryC
 
 	// For simplicity, only look at the bonus at the first character position
 	pidx := 0
-	bestPos, bonus, bestBonus := -1, int16(0), int16(-1)
+	bestPos, bonus, bbonus, bestBonus := -1, int16(0), int16(0), int16(-1)
 	for index := 0; index < lenRunes; index++ {
 		index_ := indexAt(index, lenRunes, forward)
 		char := text.Get(index_)
@@ -846,7 +847,16 @@ func exactMatchNaive(caseSensitive bool, normalize bool, forward bool, boundaryC
 				bonus = bonusAt(text, index_)
 			}
 			if boundaryCheck {
-				ok = bonus >= bonusBoundary
+				if forward && pidx_ == 0 {
+					bbonus = bonus
+				} else if !forward && pidx_ == lenPattern-1 {
+					if index_ < lenRunes-1 {
+						bbonus = bonusAt(text, index_+1)
+					} else {
+						bbonus = bonusBoundaryWhite
+					}
+				}
+				ok = bbonus >= bonusBoundary
 				if ok && pidx_ == 0 {
 					ok = index_ == 0 || charClassOf(text.Get(index_-1)) <= charDelimiter
 				}

src/algo/algo_test.go

@@ -86,7 +86,7 @@ func TestFuzzyMatch(t *testing.T) {
 					scoreGapStart*2+scoreGapExtension*2)
 			assertMatch(t, fn, true, forward, "FooBar Baz", "FooB", 0, 4,
 				scoreMatch*4+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)*2+
-					util.Max(bonusCamel123, int(bonusBoundaryWhite)))
+					max(bonusCamel123, int(bonusBoundaryWhite)))
 
 			// Consecutive bonus updated
 			assertMatch(t, fn, true, forward, "foo-bar", "o-ba", 2, 6,
@@ -200,3 +200,12 @@ func TestLongString(t *testing.T) {
 	bytes[math.MaxUint16] = 'z'
 	assertMatch(t, FuzzyMatchV2, true, true, string(bytes), "zx", math.MaxUint16, math.MaxUint16+2, scoreMatch*2+bonusConsecutive)
 }
+
+func TestLongStringWithNormalize(t *testing.T) {
+	bytes := make([]byte, 30000)
+	for i := range bytes {
+		bytes[i] = 'x'
+	}
+	unicodeString := string(bytes) + " Minímal example"
+	assertMatch2(t, FuzzyMatchV1, false, true, false, unicodeString, "minim", 30001, 30006, 140)
+}

src/algo/indexbyte2_amd64.go

@@ -0,0 +1,24 @@
+//go:build amd64
+
+package algo
+
+var _useAVX2 bool
+
+func init() {
+	_useAVX2 = cpuHasAVX2()
+}
+
+//go:noescape
+func cpuHasAVX2() bool
+
+// indexByteTwo returns the index of the first occurrence of b1 or b2 in s,
+// or -1 if neither is present. Uses AVX2 when available, SSE2 otherwise.
+//
+//go:noescape
+func IndexByteTwo(s []byte, b1, b2 byte) int
+
+// lastIndexByteTwo returns the index of the last occurrence of b1 or b2 in s,
+// or -1 if neither is present. Uses AVX2 when available, SSE2 otherwise.
+//
+//go:noescape
+func lastIndexByteTwo(s []byte, b1, b2 byte) int

src/algo/indexbyte2_amd64.s

@@ -0,0 +1,377 @@
+#include "textflag.h"
+
+// func cpuHasAVX2() bool
+//
+// Checks CPUID and XGETBV for AVX2 + OS YMM support.
+TEXT ·cpuHasAVX2(SB),NOSPLIT,$0-1
+	MOVQ	BX, R8          // save BX (callee-saved, clobbered by CPUID)
+
+	// Check max CPUID leaf >= 7
+	MOVL	$0, AX
+	CPUID
+	CMPL	AX, $7
+	JL	cpuid_no
+
+	// Check OSXSAVE (CPUID.1:ECX bit 27)
+	MOVL	$1, AX
+	CPUID
+	TESTL	$(1<<27), CX
+	JZ	cpuid_no
+
+	// Check AVX2 (CPUID.7.0:EBX bit 5)
+	MOVL	$7, AX
+	MOVL	$0, CX
+	CPUID
+	TESTL	$(1<<5), BX
+	JZ	cpuid_no
+
+	// Check OS YMM state support via XGETBV
+	MOVL	$0, CX
+	BYTE	$0x0F; BYTE $0x01; BYTE $0xD0  // XGETBV → EDX:EAX
+	ANDL	$6, AX          // bits 1 (XMM) and 2 (YMM)
+	CMPL	AX, $6
+	JNE	cpuid_no
+
+	MOVQ	R8, BX          // restore BX
+	MOVB	$1, ret+0(FP)
+	RET
+
+cpuid_no:
+	MOVQ	R8, BX
+	MOVB	$0, ret+0(FP)
+	RET
+
+// func IndexByteTwo(s []byte, b1, b2 byte) int
+//
+// Returns the index of the first occurrence of b1 or b2 in s, or -1.
+// Uses AVX2 (32 bytes/iter) when available, SSE2 (16 bytes/iter) otherwise.
+TEXT ·IndexByteTwo(SB),NOSPLIT,$0-40
+	MOVQ	s_base+0(FP), SI
+	MOVQ	s_len+8(FP), BX
+	MOVBLZX	b1+24(FP), AX
+	MOVBLZX	b2+25(FP), CX
+	LEAQ	ret+32(FP), R8
+
+	TESTQ	BX, BX
+	JEQ	fwd_failure
+
+	// Try AVX2 for inputs >= 32 bytes
+	CMPQ	BX, $32
+	JLT	fwd_sse2
+	CMPB	·_useAVX2(SB), $1
+	JNE	fwd_sse2
+
+	// ====== AVX2 forward search ======
+	MOVD	AX, X0
+	VPBROADCASTB	X0, Y0       // Y0 = splat(b1)
+	MOVD	CX, X1
+	VPBROADCASTB	X1, Y1       // Y1 = splat(b2)
+
+	MOVQ	SI, DI
+	LEAQ	-32(SI)(BX*1), AX    // AX = last valid 32-byte chunk
+	JMP	fwd_avx2_entry
+
+fwd_avx2_loop:
+	VMOVDQU	(DI), Y2
+	VPCMPEQB	Y0, Y2, Y3
+	VPCMPEQB	Y1, Y2, Y4
+	VPOR	Y3, Y4, Y3
+	VPMOVMSKB	Y3, DX
+	BSFL	DX, DX
+	JNZ	fwd_avx2_success
+	ADDQ	$32, DI
+
+fwd_avx2_entry:
+	CMPQ	DI, AX
+	JB	fwd_avx2_loop
+
+	// Last 32-byte chunk (may overlap with previous)
+	MOVQ	AX, DI
+	VMOVDQU	(AX), Y2
+	VPCMPEQB	Y0, Y2, Y3
+	VPCMPEQB	Y1, Y2, Y4
+	VPOR	Y3, Y4, Y3
+	VPMOVMSKB	Y3, DX
+	BSFL	DX, DX
+	JNZ	fwd_avx2_success
+
+	MOVQ	$-1, (R8)
+	VZEROUPPER
+	RET
+
+fwd_avx2_success:
+	SUBQ	SI, DI
+	ADDQ	DX, DI
+	MOVQ	DI, (R8)
+	VZEROUPPER
+	RET
+
+	// ====== SSE2 forward search (< 32 bytes or no AVX2) ======
+
+fwd_sse2:
+	// Broadcast b1 into X0
+	MOVD	AX, X0
+	PUNPCKLBW	X0, X0
+	PUNPCKLBW	X0, X0
+	PSHUFL	$0, X0, X0
+
+	// Broadcast b2 into X4
+	MOVD	CX, X4
+	PUNPCKLBW	X4, X4
+	PUNPCKLBW	X4, X4
+	PSHUFL	$0, X4, X4
+
+	CMPQ	BX, $16
+	JLT	fwd_small
+
+	MOVQ	SI, DI
+	LEAQ	-16(SI)(BX*1), AX
+	JMP	fwd_sseloopentry
+
+fwd_sseloop:
+	MOVOU	(DI), X1
+	MOVOU	X1, X2
+	PCMPEQB	X0, X1
+	PCMPEQB	X4, X2
+	POR	X2, X1
+	PMOVMSKB	X1, DX
+	BSFL	DX, DX
+	JNZ	fwd_ssesuccess
+	ADDQ	$16, DI
+
+fwd_sseloopentry:
+	CMPQ	DI, AX
+	JB	fwd_sseloop
+
+	// Search the last 16-byte chunk (may overlap)
+	MOVQ	AX, DI
+	MOVOU	(AX), X1
+	MOVOU	X1, X2
+	PCMPEQB	X0, X1
+	PCMPEQB	X4, X2
+	POR	X2, X1
+	PMOVMSKB	X1, DX
+	BSFL	DX, DX
+	JNZ	fwd_ssesuccess
+
+fwd_failure:
+	MOVQ	$-1, (R8)
+	RET
+
+fwd_ssesuccess:
+	SUBQ	SI, DI
+	ADDQ	DX, DI
+	MOVQ	DI, (R8)
+	RET
+
+fwd_small:
+	// Check if loading 16 bytes from SI would cross a page boundary
+	LEAQ	16(SI), AX
+	TESTW	$0xff0, AX
+	JEQ	fwd_endofpage
+
+	MOVOU	(SI), X1
+	MOVOU	X1, X2
+	PCMPEQB	X0, X1
+	PCMPEQB	X4, X2
+	POR	X2, X1
+	PMOVMSKB	X1, DX
+	BSFL	DX, DX
+	JZ	fwd_failure
+	CMPL	DX, BX
+	JAE	fwd_failure
+	MOVQ	DX, (R8)
+	RET
+
+fwd_endofpage:
+	MOVOU	-16(SI)(BX*1), X1
+	MOVOU	X1, X2
+	PCMPEQB	X0, X1
+	PCMPEQB	X4, X2
+	POR	X2, X1
+	PMOVMSKB	X1, DX
+	MOVL	BX, CX
+	SHLL	CX, DX
+	SHRL	$16, DX
+	BSFL	DX, DX
+	JZ	fwd_failure
+	MOVQ	DX, (R8)
+	RET
+
+// func lastIndexByteTwo(s []byte, b1, b2 byte) int
+//
+// Returns the index of the last occurrence of b1 or b2 in s, or -1.
+// Uses AVX2 (32 bytes/iter) when available, SSE2 (16 bytes/iter) otherwise.
+TEXT ·lastIndexByteTwo(SB),NOSPLIT,$0-40
+	MOVQ	s_base+0(FP), SI
+	MOVQ	s_len+8(FP), BX
+	MOVBLZX	b1+24(FP), AX
+	MOVBLZX	b2+25(FP), CX
+	LEAQ	ret+32(FP), R8
+
+	TESTQ	BX, BX
+	JEQ	back_failure
+
+	// Try AVX2 for inputs >= 32 bytes
+	CMPQ	BX, $32
+	JLT	back_sse2
+	CMPB	·_useAVX2(SB), $1
+	JNE	back_sse2
+
+	// ====== AVX2 backward search ======
+	MOVD	AX, X0
+	VPBROADCASTB	X0, Y0
+	MOVD	CX, X1
+	VPBROADCASTB	X1, Y1
+
+	// DI = start of last 32-byte chunk
+	LEAQ	-32(SI)(BX*1), DI
+
+back_avx2_loop:
+	CMPQ	DI, SI
+	JBE	back_avx2_first
+
+	VMOVDQU	(DI), Y2
+	VPCMPEQB	Y0, Y2, Y3
+	VPCMPEQB	Y1, Y2, Y4
+	VPOR	Y3, Y4, Y3
+	VPMOVMSKB	Y3, DX
+	BSRL	DX, DX
+	JNZ	back_avx2_success
+	SUBQ	$32, DI
+	JMP	back_avx2_loop
+
+back_avx2_first:
+	// First 32 bytes (DI <= SI, load from SI)
+	VMOVDQU	(SI), Y2
+	VPCMPEQB	Y0, Y2, Y3
+	VPCMPEQB	Y1, Y2, Y4
+	VPOR	Y3, Y4, Y3
+	VPMOVMSKB	Y3, DX
+	BSRL	DX, DX
+	JNZ	back_avx2_firstsuccess
+
+	MOVQ	$-1, (R8)
+	VZEROUPPER
+	RET
+
+back_avx2_success:
+	SUBQ	SI, DI
+	ADDQ	DX, DI
+	MOVQ	DI, (R8)
+	VZEROUPPER
+	RET
+
+back_avx2_firstsuccess:
+	MOVQ	DX, (R8)
+	VZEROUPPER
+	RET
+
+	// ====== SSE2 backward search (< 32 bytes or no AVX2) ======
+
+back_sse2:
+	// Broadcast b1 into X0
+	MOVD	AX, X0
+	PUNPCKLBW	X0, X0
+	PUNPCKLBW	X0, X0
+	PSHUFL	$0, X0, X0
+
+	// Broadcast b2 into X4
+	MOVD	CX, X4
+	PUNPCKLBW	X4, X4
+	PUNPCKLBW	X4, X4
+	PSHUFL	$0, X4, X4
+
+	CMPQ	BX, $16
+	JLT	back_small
+
+	// DI = start of last 16-byte chunk
+	LEAQ	-16(SI)(BX*1), DI
+
+back_sseloop:
+	CMPQ	DI, SI
+	JBE	back_ssefirst
+
+	MOVOU	(DI), X1
+	MOVOU	X1, X2
+	PCMPEQB	X0, X1
+	PCMPEQB	X4, X2
+	POR	X2, X1
+	PMOVMSKB	X1, DX
+	BSRL	DX, DX
+	JNZ	back_ssesuccess
+	SUBQ	$16, DI
+	JMP	back_sseloop
+
+back_ssefirst:
+	// First 16 bytes (DI <= SI, load from SI)
+	MOVOU	(SI), X1
+	MOVOU	X1, X2
+	PCMPEQB	X0, X1
+	PCMPEQB	X4, X2
+	POR	X2, X1
+	PMOVMSKB	X1, DX
+	BSRL	DX, DX
+	JNZ	back_ssefirstsuccess
+
+back_failure:
+	MOVQ	$-1, (R8)
+	RET
+
+back_ssesuccess:
+	SUBQ	SI, DI
+	ADDQ	DX, DI
+	MOVQ	DI, (R8)
+	RET
+
+back_ssefirstsuccess:
+	// DX = byte offset from base
+	MOVQ	DX, (R8)
+	RET
+
+back_small:
+	// Check page boundary
+	LEAQ	16(SI), AX
+	TESTW	$0xff0, AX
+	JEQ	back_endofpage
+
+	MOVOU	(SI), X1
+	MOVOU	X1, X2
+	PCMPEQB	X0, X1
+	PCMPEQB	X4, X2
+	POR	X2, X1
+	PMOVMSKB	X1, DX
+	// Mask to first BX bytes: keep bits 0..BX-1
+	MOVL	$1, AX
+	MOVL	BX, CX
+	SHLL	CX, AX
+	DECL	AX
+	ANDL	AX, DX
+	BSRL	DX, DX
+	JZ	back_failure
+	MOVQ	DX, (R8)
+	RET
+
+back_endofpage:
+	// Load 16 bytes ending at base+n
+	MOVOU	-16(SI)(BX*1), X1
+	MOVOU	X1, X2
+	PCMPEQB	X0, X1
+	PCMPEQB	X4, X2
+	POR	X2, X1
+	PMOVMSKB	X1, DX
+	// Bits correspond to bytes [base+n-16, base+n).
+	// We want original bytes [0, n), which are bits [16-n, 16).
+	// Mask: keep bits (16-n) through 15.
+	MOVL	$16, CX
+	SUBL	BX, CX
+	SHRL	CX, DX
+	SHLL	CX, DX
+	BSRL	DX, DX
+	JZ	back_failure
+	// DX is the bit position in the loaded chunk.
+	// Original byte index = DX - (16 - n) = DX + n - 16
+	ADDL	BX, DX
+	SUBL	$16, DX
+	MOVQ	DX, (R8)
+	RET

src/algo/indexbyte2_arm64.go

@@ -0,0 +1,17 @@
+//go:build arm64
+
+package algo
+
+// indexByteTwo returns the index of the first occurrence of b1 or b2 in s,
+// or -1 if neither is present. Implemented in assembly using ARM64 NEON
+// to search for both bytes in a single pass.
+//
+//go:noescape
+func IndexByteTwo(s []byte, b1, b2 byte) int
+
+// lastIndexByteTwo returns the index of the last occurrence of b1 or b2 in s,
+// or -1 if neither is present. Implemented in assembly using ARM64 NEON,
+// scanning backward.
+//
+//go:noescape
+func lastIndexByteTwo(s []byte, b1, b2 byte) int

src/algo/indexbyte2_arm64.s

@@ -0,0 +1,249 @@
+#include "textflag.h"
+
+// func IndexByteTwo(s []byte, b1, b2 byte) int
+//
+// Returns the index of the first occurrence of b1 or b2 in s, or -1.
+// Uses ARM64 NEON to search for both bytes in a single pass over the data.
+// Adapted from Go's internal/bytealg/indexbyte_arm64.s (single-byte version).
+TEXT ·IndexByteTwo(SB),NOSPLIT,$0-40
+	MOVD	s_base+0(FP), R0
+	MOVD	s_len+8(FP), R2
+	MOVBU	b1+24(FP), R1
+	MOVBU	b2+25(FP), R7
+	MOVD	$ret+32(FP), R8
+
+	// Core algorithm:
+	// For each 32-byte chunk we calculate a 64-bit syndrome value,
+	// with two bits per byte. We compare against both b1 and b2,
+	// OR the results, then use the same syndrome extraction as
+	// Go's IndexByte.
+
+	CBZ	R2, fail
+	MOVD	R0, R11
+	// Magic constant 0x40100401 allows us to identify which lane matches.
+	// Each byte in the group of 4 gets a distinct bit: 1, 4, 16, 64.
+	MOVD	$0x40100401, R5
+	VMOV	R1, V0.B16    // V0 = splat(b1)
+	VMOV	R7, V7.B16    // V7 = splat(b2)
+	// Work with aligned 32-byte chunks
+	BIC	$0x1f, R0, R3
+	VMOV	R5, V5.S4
+	ANDS	$0x1f, R0, R9
+	AND	$0x1f, R2, R10
+	BEQ	loop
+
+	// Input string is not 32-byte aligned. Process the first
+	// aligned 32-byte block and mask off bytes before our start.
+	VLD1.P	(R3), [V1.B16, V2.B16]
+	SUB	$0x20, R9, R4
+	ADDS	R4, R2, R2
+	// Compare against both needles
+	VCMEQ	V0.B16, V1.B16, V3.B16  // b1 vs first 16 bytes
+	VCMEQ	V7.B16, V1.B16, V8.B16  // b2 vs first 16 bytes
+	VORR	V8.B16, V3.B16, V3.B16  // combine
+	VCMEQ	V0.B16, V2.B16, V4.B16  // b1 vs second 16 bytes
+	VCMEQ	V7.B16, V2.B16, V9.B16  // b2 vs second 16 bytes
+	VORR	V9.B16, V4.B16, V4.B16  // combine
+	// Build syndrome
+	VAND	V5.B16, V3.B16, V3.B16
+	VAND	V5.B16, V4.B16, V4.B16
+	VADDP	V4.B16, V3.B16, V6.B16
+	VADDP	V6.B16, V6.B16, V6.B16
+	VMOV	V6.D[0], R6
+	// Clear the irrelevant lower bits
+	LSL	$1, R9, R4
+	LSR	R4, R6, R6
+	LSL	R4, R6, R6
+	// The first block can also be the last
+	BLS	masklast
+	// Have we found something already?
+	CBNZ	R6, tail
+
+loop:
+	VLD1.P	(R3), [V1.B16, V2.B16]
+	SUBS	$0x20, R2, R2
+	// Compare against both needles, OR results
+	VCMEQ	V0.B16, V1.B16, V3.B16
+	VCMEQ	V7.B16, V1.B16, V8.B16
+	VORR	V8.B16, V3.B16, V3.B16
+	VCMEQ	V0.B16, V2.B16, V4.B16
+	VCMEQ	V7.B16, V2.B16, V9.B16
+	VORR	V9.B16, V4.B16, V4.B16
+	// If we're out of data we finish regardless of the result
+	BLS	end
+	// Fast check: OR both halves and check for any match
+	VORR	V4.B16, V3.B16, V6.B16
+	VADDP	V6.D2, V6.D2, V6.D2
+	VMOV	V6.D[0], R6
+	CBZ	R6, loop
+
+end:
+	// Found something or out of data, build full syndrome
+	VAND	V5.B16, V3.B16, V3.B16
+	VAND	V5.B16, V4.B16, V4.B16
+	VADDP	V4.B16, V3.B16, V6.B16
+	VADDP	V6.B16, V6.B16, V6.B16
+	VMOV	V6.D[0], R6
+	// Only mask for the last block
+	BHS	tail
+
+masklast:
+	// Clear irrelevant upper bits
+	ADD	R9, R10, R4
+	AND	$0x1f, R4, R4
+	SUB	$0x20, R4, R4
+	NEG	R4<<1, R4
+	LSL	R4, R6, R6
+	LSR	R4, R6, R6
+
+tail:
+	CBZ	R6, fail
+	RBIT	R6, R6
+	SUB	$0x20, R3, R3
+	CLZ	R6, R6
+	ADD	R6>>1, R3, R0
+	SUB	R11, R0, R0
+	MOVD	R0, (R8)
+	RET
+
+fail:
+	MOVD	$-1, R0
+	MOVD	R0, (R8)
+	RET
+
+// func lastIndexByteTwo(s []byte, b1, b2 byte) int
+//
+// Returns the index of the last occurrence of b1 or b2 in s, or -1.
+// Scans backward using ARM64 NEON.
+TEXT ·lastIndexByteTwo(SB),NOSPLIT,$0-40
+	MOVD	s_base+0(FP), R0
+	MOVD	s_len+8(FP), R2
+	MOVBU	b1+24(FP), R1
+	MOVBU	b2+25(FP), R7
+	MOVD	$ret+32(FP), R8
+
+	CBZ	R2, lfail
+	MOVD	R0, R11          // save base
+	ADD	R0, R2, R12      // R12 = end = base + len
+	MOVD	$0x40100401, R5
+	VMOV	R1, V0.B16       // V0 = splat(b1)
+	VMOV	R7, V7.B16       // V7 = splat(b2)
+	VMOV	R5, V5.S4
+
+	// Align: find the aligned block containing the last byte
+	SUB	$1, R12, R3
+	BIC	$0x1f, R3, R3    // R3 = start of aligned block containing last byte
+
+	// --- Process tail block ---
+	VLD1	(R3), [V1.B16, V2.B16]
+	VCMEQ	V0.B16, V1.B16, V3.B16
+	VCMEQ	V7.B16, V1.B16, V8.B16
+	VORR	V8.B16, V3.B16, V3.B16
+	VCMEQ	V0.B16, V2.B16, V4.B16
+	VCMEQ	V7.B16, V2.B16, V9.B16
+	VORR	V9.B16, V4.B16, V4.B16
+	VAND	V5.B16, V3.B16, V3.B16
+	VAND	V5.B16, V4.B16, V4.B16
+	VADDP	V4.B16, V3.B16, V6.B16
+	VADDP	V6.B16, V6.B16, V6.B16
+	VMOV	V6.D[0], R6
+
+	// Mask upper bits (bytes past end of slice)
+	// tail_bytes = end - R3 (1..32)
+	SUB	R3, R12, R10     // R10 = tail_bytes
+	MOVD	$64, R4
+	SUB	R10<<1, R4, R4   // R4 = 64 - 2*tail_bytes
+	LSL	R4, R6, R6
+	LSR	R4, R6, R6
+
+	// Is this also the head block?
+	CMP	R11, R3          // R3 - R11
+	BLO	lmaskfirst       // R3 < base: head+tail in same block
+	BEQ	ltailonly         // R3 == base: single aligned block
+
+	// R3 > base: more blocks before this one
+	CBNZ	R6, llast
+	B	lbacksetup
+
+ltailonly:
+	// Single block, already masked upper bits
+	CBNZ	R6, llast
+	B	lfail
+
+lmaskfirst:
+	// Mask lower bits (bytes before start of slice)
+	SUB	R3, R11, R4      // R4 = base - R3
+	LSL	$1, R4, R4
+	LSR	R4, R6, R6
+	LSL	R4, R6, R6
+	CBNZ	R6, llast
+	B	lfail
+
+lbacksetup:
+	SUB	$0x20, R3
+
+lbackloop:
+	VLD1	(R3), [V1.B16, V2.B16]
+	VCMEQ	V0.B16, V1.B16, V3.B16
+	VCMEQ	V7.B16, V1.B16, V8.B16
+	VORR	V8.B16, V3.B16, V3.B16
+	VCMEQ	V0.B16, V2.B16, V4.B16
+	VCMEQ	V7.B16, V2.B16, V9.B16
+	VORR	V9.B16, V4.B16, V4.B16
+	// Quick check: any match in this block?
+	VORR	V4.B16, V3.B16, V6.B16
+	VADDP	V6.D2, V6.D2, V6.D2
+	VMOV	V6.D[0], R6
+
+	// Is this a head block? (R3 < base)
+	CMP	R11, R3
+	BLO	lheadblock
+
+	// Full block (R3 >= base)
+	CBNZ	R6, lbackfound
+	// More blocks?
+	BEQ	lfail            // R3 == base, no more
+	SUB	$0x20, R3
+	B	lbackloop
+
+lbackfound:
+	// Build full syndrome
+	VAND	V5.B16, V3.B16, V3.B16
+	VAND	V5.B16, V4.B16, V4.B16
+	VADDP	V4.B16, V3.B16, V6.B16
+	VADDP	V6.B16, V6.B16, V6.B16
+	VMOV	V6.D[0], R6
+	B	llast
+
+lheadblock:
+	// R3 < base. Build full syndrome if quick check had a match.
+	CBZ	R6, lfail
+	VAND	V5.B16, V3.B16, V3.B16
+	VAND	V5.B16, V4.B16, V4.B16
+	VADDP	V4.B16, V3.B16, V6.B16
+	VADDP	V6.B16, V6.B16, V6.B16
+	VMOV	V6.D[0], R6
+	// Mask lower bits
+	SUB	R3, R11, R4      // R4 = base - R3
+	LSL	$1, R4, R4
+	LSR	R4, R6, R6
+	LSL	R4, R6, R6
+	CBZ	R6, lfail
+
+llast:
+	// Find last match: highest set bit in syndrome
+	// Syndrome has bit 2i set for matching byte i.
+	// CLZ gives leading zeros; byte_offset = (63 - CLZ) / 2.
+	CLZ	R6, R6
+	MOVD	$63, R4
+	SUB	R6, R4, R6       // R6 = 63 - CLZ = bit position
+	LSR	$1, R6            // R6 = byte offset within block
+	ADD	R3, R6, R0        // R0 = absolute address
+	SUB	R11, R0, R0       // R0 = slice index
+	MOVD	R0, (R8)
+	RET
+
+lfail:
+	MOVD	$-1, R0
+	MOVD	R0, (R8)
+	RET

src/algo/indexbyte2_other.go

@@ -0,0 +1,33 @@
+//go:build !arm64 && !amd64
+
+package algo
+
+import "bytes"
+
+// indexByteTwo returns the index of the first occurrence of b1 or b2 in s,
+// or -1 if neither is present.
+func IndexByteTwo(s []byte, b1, b2 byte) int {
+	i1 := bytes.IndexByte(s, b1)
+	if i1 == 0 {
+		return 0
+	}
+	scope := s
+	if i1 > 0 {
+		scope = s[:i1]
+	}
+	if i2 := bytes.IndexByte(scope, b2); i2 >= 0 {
+		return i2
+	}
+	return i1
+}
+
+// lastIndexByteTwo returns the index of the last occurrence of b1 or b2 in s,
+// or -1 if neither is present.
+func lastIndexByteTwo(s []byte, b1, b2 byte) int {
+	for i := len(s) - 1; i >= 0; i-- {
+		if s[i] == b1 || s[i] == b2 {
+			return i
+		}
+	}
+	return -1
+}

src/algo/indexbyte2_test.go

@@ -0,0 +1,259 @@
+package algo
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestIndexByteTwo(t *testing.T) {
+	tests := []struct {
+		name string
+		s    string
+		b1   byte
+		b2   byte
+		want int
+	}{
+		{"empty", "", 'a', 'b', -1},
+		{"single_b1", "a", 'a', 'b', 0},
+		{"single_b2", "b", 'a', 'b', 0},
+		{"single_none", "c", 'a', 'b', -1},
+		{"b1_first", "xaxb", 'a', 'b', 1},
+		{"b2_first", "xbxa", 'a', 'b', 1},
+		{"same_byte", "xxa", 'a', 'a', 2},
+		{"at_end", "xxxxa", 'a', 'b', 4},
+		{"not_found", "xxxxxxxx", 'a', 'b', -1},
+		{"long_b1_at_3000", string(make([]byte, 3000)) + "a" + string(make([]byte, 1000)), 'a', 'b', 3000},
+		{"long_b2_at_3000", string(make([]byte, 3000)) + "b" + string(make([]byte, 1000)), 'a', 'b', 3000},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := IndexByteTwo([]byte(tt.s), tt.b1, tt.b2)
+			if got != tt.want {
+				t.Errorf("IndexByteTwo(%q, %c, %c) = %d, want %d", tt.s[:min(len(tt.s), 40)], tt.b1, tt.b2, got, tt.want)
+			}
+		})
+	}
+
+	// Exhaustive test: compare against loop reference for various lengths,
+	// including sizes around SIMD block boundaries (16, 32, 64).
+	for n := 0; n <= 256; n++ {
+		data := make([]byte, n)
+		for i := range data {
+			data[i] = byte('c' + (i % 20))
+		}
+		// Test with match at every position
+		for pos := 0; pos < n; pos++ {
+			for _, b := range []byte{'A', 'B'} {
+				data[pos] = b
+				got := IndexByteTwo(data, 'A', 'B')
+				want := loopIndexByteTwo(data, 'A', 'B')
+				if got != want {
+					t.Fatalf("IndexByteTwo(len=%d, match=%c@%d) = %d, want %d", n, b, pos, got, want)
+				}
+				data[pos] = byte('c' + (pos % 20))
+			}
+		}
+		// Test with no match
+		got := IndexByteTwo(data, 'A', 'B')
+		if got != -1 {
+			t.Fatalf("IndexByteTwo(len=%d, no match) = %d, want -1", n, got)
+		}
+		// Test with both bytes present
+		if n >= 2 {
+			data[n/3] = 'A'
+			data[n*2/3] = 'B'
+			got := IndexByteTwo(data, 'A', 'B')
+			want := loopIndexByteTwo(data, 'A', 'B')
+			if got != want {
+				t.Fatalf("IndexByteTwo(len=%d, both@%d,%d) = %d, want %d", n, n/3, n*2/3, got, want)
+			}
+			data[n/3] = byte('c' + ((n / 3) % 20))
+			data[n*2/3] = byte('c' + ((n * 2 / 3) % 20))
+		}
+	}
+}
+
+func TestLastIndexByteTwo(t *testing.T) {
+	tests := []struct {
+		name string
+		s    string
+		b1   byte
+		b2   byte
+		want int
+	}{
+		{"empty", "", 'a', 'b', -1},
+		{"single_b1", "a", 'a', 'b', 0},
+		{"single_b2", "b", 'a', 'b', 0},
+		{"single_none", "c", 'a', 'b', -1},
+		{"b1_last", "xbxa", 'a', 'b', 3},
+		{"b2_last", "xaxb", 'a', 'b', 3},
+		{"same_byte", "axx", 'a', 'a', 0},
+		{"at_start", "axxxx", 'a', 'b', 0},
+		{"both_present", "axbx", 'a', 'b', 2},
+		{"not_found", "xxxxxxxx", 'a', 'b', -1},
+		{"long_b1_at_3000", string(make([]byte, 3000)) + "a" + string(make([]byte, 1000)), 'a', 'b', 3000},
+		{"long_b2_at_end", string(make([]byte, 4000)) + "b", 'a', 'b', 4000},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := lastIndexByteTwo([]byte(tt.s), tt.b1, tt.b2)
+			if got != tt.want {
+				t.Errorf("lastIndexByteTwo(%q, %c, %c) = %d, want %d", tt.s[:min(len(tt.s), 40)], tt.b1, tt.b2, got, tt.want)
+			}
+		})
+	}
+
+	// Exhaustive test against loop reference
+	for n := 0; n <= 256; n++ {
+		data := make([]byte, n)
+		for i := range data {
+			data[i] = byte('c' + (i % 20))
+		}
+		for pos := 0; pos < n; pos++ {
+			for _, b := range []byte{'A', 'B'} {
+				data[pos] = b
+				got := lastIndexByteTwo(data, 'A', 'B')
+				want := refLastIndexByteTwo(data, 'A', 'B')
+				if got != want {
+					t.Fatalf("lastIndexByteTwo(len=%d, match=%c@%d) = %d, want %d", n, b, pos, got, want)
+				}
+				data[pos] = byte('c' + (pos % 20))
+			}
+		}
+		// No match
+		got := lastIndexByteTwo(data, 'A', 'B')
+		if got != -1 {
+			t.Fatalf("lastIndexByteTwo(len=%d, no match) = %d, want -1", n, got)
+		}
+		// Both bytes present
+		if n >= 2 {
+			data[n/3] = 'A'
+			data[n*2/3] = 'B'
+			got := lastIndexByteTwo(data, 'A', 'B')
+			want := refLastIndexByteTwo(data, 'A', 'B')
+			if got != want {
+				t.Fatalf("lastIndexByteTwo(len=%d, both@%d,%d) = %d, want %d", n, n/3, n*2/3, got, want)
+			}
+			data[n/3] = byte('c' + ((n / 3) % 20))
+			data[n*2/3] = byte('c' + ((n * 2 / 3) % 20))
+		}
+	}
+}
+
+func FuzzIndexByteTwo(f *testing.F) {
+	f.Add([]byte("hello world"), byte('o'), byte('l'))
+	f.Add([]byte(""), byte('a'), byte('b'))
+	f.Add([]byte("aaa"), byte('a'), byte('a'))
+	f.Fuzz(func(t *testing.T, data []byte, b1, b2 byte) {
+		got := IndexByteTwo(data, b1, b2)
+		want := loopIndexByteTwo(data, b1, b2)
+		if got != want {
+			t.Errorf("IndexByteTwo(len=%d, b1=%d, b2=%d) = %d, want %d", len(data), b1, b2, got, want)
+		}
+	})
+}
+
+func FuzzLastIndexByteTwo(f *testing.F) {
+	f.Add([]byte("hello world"), byte('o'), byte('l'))
+	f.Add([]byte(""), byte('a'), byte('b'))
+	f.Add([]byte("aaa"), byte('a'), byte('a'))
+	f.Fuzz(func(t *testing.T, data []byte, b1, b2 byte) {
+		got := lastIndexByteTwo(data, b1, b2)
+		want := refLastIndexByteTwo(data, b1, b2)
+		if got != want {
+			t.Errorf("lastIndexByteTwo(len=%d, b1=%d, b2=%d) = %d, want %d", len(data), b1, b2, got, want)
+		}
+	})
+}
+
+// Reference implementations for correctness checking
+func refIndexByteTwo(s []byte, b1, b2 byte) int {
+	i1 := bytes.IndexByte(s, b1)
+	if i1 == 0 {
+		return 0
+	}
+	scope := s
+	if i1 > 0 {
+		scope = s[:i1]
+	}
+	if i2 := bytes.IndexByte(scope, b2); i2 >= 0 {
+		return i2
+	}
+	return i1
+}
+
+func loopIndexByteTwo(s []byte, b1, b2 byte) int {
+	for i, b := range s {
+		if b == b1 || b == b2 {
+			return i
+		}
+	}
+	return -1
+}
+
+func refLastIndexByteTwo(s []byte, b1, b2 byte) int {
+	for i := len(s) - 1; i >= 0; i-- {
+		if s[i] == b1 || s[i] == b2 {
+			return i
+		}
+	}
+	return -1
+}
+
+func benchIndexByteTwo(b *testing.B, size int, pos int) {
+	data := make([]byte, size)
+	for i := range data {
+		data[i] = byte('a' + (i % 20))
+	}
+	data[pos] = 'Z'
+
+	type impl struct {
+		name string
+		fn   func([]byte, byte, byte) int
+	}
+	impls := []impl{
+		{"asm", IndexByteTwo},
+		{"2xIndexByte", refIndexByteTwo},
+		{"loop", loopIndexByteTwo},
+	}
+	for _, im := range impls {
+		b.Run(im.name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				im.fn(data, 'Z', 'z')
+			}
+		})
+	}
+}
+
+func benchLastIndexByteTwo(b *testing.B, size int, pos int) {
+	data := make([]byte, size)
+	for i := range data {
+		data[i] = byte('a' + (i % 20))
+	}
+	data[pos] = 'Z'
+
+	type impl struct {
+		name string
+		fn   func([]byte, byte, byte) int
+	}
+	impls := []impl{
+		{"asm", lastIndexByteTwo},
+		{"loop", refLastIndexByteTwo},
+	}
+	for _, im := range impls {
+		b.Run(im.name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				im.fn(data, 'Z', 'z')
+			}
+		})
+	}
+}
+
+func BenchmarkIndexByteTwo_10(b *testing.B)       { benchIndexByteTwo(b, 10, 8) }
+func BenchmarkIndexByteTwo_100(b *testing.B)      { benchIndexByteTwo(b, 100, 80) }
+func BenchmarkIndexByteTwo_1000(b *testing.B)     { benchIndexByteTwo(b, 1000, 800) }
+func BenchmarkLastIndexByteTwo_10(b *testing.B)   { benchLastIndexByteTwo(b, 10, 2) }
+func BenchmarkLastIndexByteTwo_100(b *testing.B)  { benchLastIndexByteTwo(b, 100, 20) }
+func BenchmarkLastIndexByteTwo_1000(b *testing.B) { benchLastIndexByteTwo(b, 1000, 200) }

src/algo/normalize.go

@@ -473,6 +473,103 @@ var normalized = map[rune]rune{
 	'ử': 'u',
 	'ữ': 'u',
 	'ự': 'u',
+
+	// https://en.wikipedia.org/wiki/Halfwidth_and_Fullwidth_Forms_(Unicode_block)
+	0xFF01: '!',  // Fullwidth exclamation
+	0xFF02: '"',  // Fullwidth quotation mark
+	0xFF03: '#',  // Fullwidth number sign
+	0xFF04: '$',  // Fullwidth dollar sign
+	0xFF05: '%',  // Fullwidth percent
+	0xFF06: '&',  // Fullwidth ampersand
+	0xFF07: '\'', // Fullwidth apostrophe
+	0xFF08: '(',  // Fullwidth left parenthesis
+	0xFF09: ')',  // Fullwidth right parenthesis
+	0xFF0A: '*',  // Fullwidth asterisk
+	0xFF0B: '+',  // Fullwidth plus
+	0xFF0C: ',',  // Fullwidth comma
+	0xFF0D: '-',  // Fullwidth hyphen-minus
+	0xFF0E: '.',  // Fullwidth period
+	0xFF0F: '/',  // Fullwidth slash
+	0xFF10: '0',
+	0xFF11: '1',
+	0xFF12: '2',
+	0xFF13: '3',
+	0xFF14: '4',
+	0xFF15: '5',
+	0xFF16: '6',
+	0xFF17: '7',
+	0xFF18: '8',
+	0xFF19: '9',
+	0xFF1A: ':', // Fullwidth colon
+	0xFF1B: ';', // Fullwidth semicolon
+	0xFF1C: '<', // Fullwidth less-than
+	0xFF1D: '=', // Fullwidth equal
+	0xFF1E: '>', // Fullwidth greater-than
+	0xFF1F: '?', // Fullwidth question mark
+	0xFF20: '@', // Fullwidth at sign
+	0xFF21: 'A',
+	0xFF22: 'B',
+	0xFF23: 'C',
+	0xFF24: 'D',
+	0xFF25: 'E',
+	0xFF26: 'F',
+	0xFF27: 'G',
+	0xFF28: 'H',
+	0xFF29: 'I',
+	0xFF2A: 'J',
+	0xFF2B: 'K',
+	0xFF2C: 'L',
+	0xFF2D: 'M',
+	0xFF2E: 'N',
+	0xFF2F: 'O',
+	0xFF30: 'P',
+	0xFF31: 'Q',
+	0xFF32: 'R',
+	0xFF33: 'S',
+	0xFF34: 'T',
+	0xFF35: 'U',
+	0xFF36: 'V',
+	0xFF37: 'W',
+	0xFF38: 'X',
+	0xFF39: 'Y',
+	0xFF3A: 'Z',
+	0xFF3B: '[',  // Fullwidth left bracket
+	0xFF3C: '\\', // Fullwidth backslash
+	0xFF3D: ']',  // Fullwidth right bracket
+	0xFF3E: '^',  // Fullwidth circumflex
+	0xFF3F: '_',  // Fullwidth underscore
+	0xFF40: '`',  // Fullwidth grave accent
+	0xFF41: 'a',
+	0xFF42: 'b',
+	0xFF43: 'c',
+	0xFF44: 'd',
+	0xFF45: 'e',
+	0xFF46: 'f',
+	0xFF47: 'g',
+	0xFF48: 'h',
+	0xFF49: 'i',
+	0xFF4A: 'j',
+	0xFF4B: 'k',
+	0xFF4C: 'l',
+	0xFF4D: 'm',
+	0xFF4E: 'n',
+	0xFF4F: 'o',
+	0xFF50: 'p',
+	0xFF51: 'q',
+	0xFF52: 'r',
+	0xFF53: 's',
+	0xFF54: 't',
+	0xFF55: 'u',
+	0xFF56: 'v',
+	0xFF57: 'w',
+	0xFF58: 'x',
+	0xFF59: 'y',
+	0xFF5A: 'z',
+	0xFF5B: '{', // Fullwidth left brace
+	0xFF5C: '|', // Fullwidth vertical bar
+	0xFF5D: '}', // Fullwidth right brace
+	0xFF5E: '~', // Fullwidth tilde
+	0xFF61: '.', // Halfwidth ideographic full stop
 }
 
 // NormalizeRunes normalizes latin script letters
@@ -480,7 +577,7 @@ func NormalizeRunes(runes []rune) []rune {
 	ret := make([]rune, len(runes))
 	copy(ret, runes)
 	for idx, r := range runes {
-		if r < 0x00C0 || r > 0x2184 {
+		if r < 0x00C0 || r > 0xFF61 {
 			continue
 		}
 		n := normalized[r]

src/ansi.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"unicode/utf8"
 
+	"github.com/junegunn/fzf/src/algo"
 	"github.com/junegunn/fzf/src/tui"
 )
 
@@ -22,20 +23,21 @@ type url struct {
 type ansiState struct {
 	fg   tui.Color
 	bg   tui.Color
+	ul   tui.Color
 	attr tui.Attr
 	lbg  tui.Color
 	url  *url
 }
 
 func (s *ansiState) colored() bool {
-	return s.fg != -1 || s.bg != -1 || s.attr > 0 || s.lbg >= 0 || s.url != nil
+	return s.fg != -1 || s.bg != -1 || s.ul != -1 || s.attr > 0 || s.lbg >= 0 || s.url != nil
 }
 
 func (s *ansiState) equals(t *ansiState) bool {
 	if t == nil {
 		return !s.colored()
 	}
-	return s.fg == t.fg && s.bg == t.bg && s.attr == t.attr && s.lbg == t.lbg && s.url == t.url
+	return s.fg == t.fg && s.bg == t.bg && s.ul == t.ul && s.attr == t.attr && s.lbg == t.lbg && s.url == t.url
 }
 
 func (s *ansiState) ToString() string {
@@ -54,7 +56,18 @@ func (s *ansiState) ToString() string {
 		ret += "3;"
 	}
 	if s.attr&tui.Underline > 0 {
-		ret += "4;"
+		switch s.attr.UnderlineStyle() {
+		case tui.UlStyleDouble:
+			ret += "4:2;"
+		case tui.UlStyleCurly:
+			ret += "4:3;"
+		case tui.UlStyleDotted:
+			ret += "4:4;"
+		case tui.UlStyleDashed:
+			ret += "4:5;"
+		default:
+			ret += "4;"
+		}
 	}
 	if s.attr&tui.Blink > 0 {
 		ret += "5;"
@@ -66,6 +79,9 @@ func (s *ansiState) ToString() string {
 		ret += "9;"
 	}
 	ret += toAnsiString(s.fg, 30) + toAnsiString(s.bg, 40)
+	if s.ul != -1 {
+		ret += toAnsiStringUl(s.ul)
+	}
 
 	ret = "\x1b[" + strings.TrimSuffix(ret, ";") + "m"
 	if s.url != nil {
@@ -74,6 +90,20 @@ func (s *ansiState) ToString() string {
 	return ret
 }
 
+func toAnsiStringUl(color tui.Color) string {
+	col := int(color)
+	if col < 0 {
+		return ""
+	}
+	if col >= (1 << 24) {
+		r := strconv.Itoa((col >> 16) & 0xff)
+		g := strconv.Itoa((col >> 8) & 0xff)
+		b := strconv.Itoa(col & 0xff)
+		return "58;2;" + r + ";" + g + ";" + b + ";"
+	}
+	return "58;5;" + strconv.Itoa(col) + ";"
+}
+
 func toAnsiString(color tui.Color, offset int) string {
 	col := int(color)
 	ret := ""
@@ -94,31 +124,31 @@ func toAnsiString(color tui.Color, offset int) string {
 	return ret + ";"
 }
 
-func isPrint(c uint8) bool {
-	return '\x20' <= c && c <= '\x7e'
-}
-
 func matchOperatingSystemCommand(s string, start int) int {
 	// `\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)`
 	//                 ^ match starting here after the first printable character
 	//
 	i := start // prefix matched in nextAnsiEscapeSequence()
-	for ; i < len(s) && isPrint(s[i]); i++ {
+
+	// Find the terminator: BEL (\x07) or ESC (\x1b) for ST (\x1b\\)
+	idx := algo.IndexByteTwo(stringBytes(s[i:]), '\x07', '\x1b')
+	if idx < 0 {
+		return -1
 	}
-	if i < len(s) {
-		if s[i] == '\x07' {
-			return i + 1
-		}
-		// `\x1b]8;PARAMS;URI\x1b\\TITLE\x1b]8;;\x1b`
-		//                   ------
-		if s[i] == '\x1b' && i < len(s)-1 && s[i+1] == '\\' {
-			return i + 2
-		}
+	i += idx
+
+	if s[i] == '\x07' {
+		return i + 1
+	}
+	// `\x1b]8;PARAMS;URI\x1b\\TITLE\x1b]8;;\x1b`
+	//                   ------
+	if i < len(s)-1 && s[i+1] == '\\' {
+		return i + 2
 	}
 
 	// `\x1b]8;PARAMS;URI\x1b\\TITLE\x1b]8;;\x1b`
 	//                              ------------
-	if i < len(s) && s[:i+1] == "\x1b]8;;\x1b" {
+	if s[:i+1] == "\x1b]8;;\x1b" {
 		return i + 1
 	}
 
@@ -156,13 +186,13 @@ func isCtrlSeqStart(c uint8) bool {
 // nextAnsiEscapeSequence returns the ANSI escape sequence and is equivalent to
 // calling FindStringIndex() on the below regex (which was originally used):
 //
-// "(?:\x1b[\\[()][0-9;:?]*[a-zA-Z@]|\x1b][0-9]+[;:][[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)"
+// "(?:\x1b[\\[()][0-9;:?]*[a-zA-Z@]|\x1b][0-9]+[;:][[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08|\n)"
 func nextAnsiEscapeSequence(s string) (int, int) {
 	// fast check for ANSI escape sequences
 	i := 0
 	for ; i < len(s); i++ {
 		switch s[i] {
-		case '\x0e', '\x0f', '\x1b', '\x08':
+		case '\x0e', '\x0f', '\x1b', '\x08', '\n':
 			// We ignore the fact that '\x08' cannot be the first char
 			// in the string and be an escape sequence for the sake of
 			// speed and simplicity.
@@ -174,6 +204,9 @@ func nextAnsiEscapeSequence(s string) (int, int) {
 Loop:
 	for ; i < len(s); i++ {
 		switch s[i] {
+		case '\n':
+			// match: `\n`
+			return i, i + 1
 		case '\x08':
 			// backtrack to match: `.\x08`
 			if i > 0 && s[i-1] != '\n' {
@@ -201,7 +234,7 @@ Loop:
 
 				// \x1b][0-9]+[;:][[:print:]]+(?:\x1b\\\\|\x07)
 				//            ---------------
-				if j > 2 && i+j+1 < len(s) && (s[i+j] == ';' || s[i+j] == ':') && isPrint(s[i+j+1]) {
+				if j > 2 && i+j+1 < len(s) && (s[i+j] == ';' || s[i+j] == ':') && s[i+j+1] >= '\x20' {
 					if k := matchOperatingSystemCommand(s[i:], j+2); k != -1 {
 						return i, i + k
 					}
@@ -265,13 +298,30 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo
 			output.WriteString(prev)
 		}
 
-		newState := interpretCode(str[start:idx], state)
-		if !newState.equals(state) {
+		code := str[start:idx]
+		newState := interpretCode(code, state)
+		if code == "\n" || !newState.equals(state) {
 			if state != nil {
 				// Update last offset
 				(&offsets[len(offsets)-1]).offset[1] = int32(runeCount)
 			}
 
+			if code == "\n" {
+				output.WriteRune('\n')
+				runeCount++
+				// Full-background marker
+				if newState.lbg >= 0 {
+					marker := newState
+					marker.attr |= tui.FullBg
+					offsets = append(offsets, ansiOffset{
+						[2]int32{int32(runeCount), int32(runeCount)},
+						marker,
+					})
+					// Reset the full-line background color
+					newState.lbg = -1
+				}
+			}
+
 			if newState.colored() {
 				// Append new offset
 				if pstate == nil {
@@ -318,15 +368,19 @@ func extractColor(str string, state *ansiState, proc func(string, *ansiState) bo
 	return trimmed, nil, state
 }
 
-func parseAnsiCode(s string) (int, string) {
+func parseAnsiCode(s string) (int, byte, string) {
 	var remaining string
-	var i int
-	// Faster than strings.IndexAny(";:")
-	i = strings.IndexByte(s, ';')
-	if i < 0 {
-		i = strings.IndexByte(s, ':')
+	var sep byte
+	// Find the first separator (either ; or :)
+	i := -1
+	for j := 0; j < len(s); j++ {
+		if s[j] == ';' || s[j] == ':' {
+			i = j
+			break
+		}
 	}
 	if i >= 0 {
+		sep = s[i]
 		remaining = s[i+1:]
 		s = s[:i]
 	}
@@ -338,42 +392,59 @@ func parseAnsiCode(s string) (int, string) {
 		for _, ch := range stringBytes(s) {
 			ch -= '0'
 			if ch > 9 {
-				return -1, remaining
+				return -1, sep, remaining
 			}
 			code = code*10 + int(ch)
 		}
-		return code, remaining
+		return code, sep, remaining
 	}
 
-	return -1, remaining
+	return -1, sep, remaining
 }
 
 func interpretCode(ansiCode string, prevState *ansiState) ansiState {
+	if ansiCode == "\n" {
+		if prevState != nil {
+			return *prevState
+		}
+		return ansiState{-1, -1, -1, 0, -1, nil}
+	}
+
 	var state ansiState
 	if prevState == nil {
-		state = ansiState{-1, -1, 0, -1, nil}
+		state = ansiState{-1, -1, -1, 0, -1, nil}
 	} else {
-		state = ansiState{prevState.fg, prevState.bg, prevState.attr, prevState.lbg, prevState.url}
+		state = ansiState{prevState.fg, prevState.bg, prevState.ul, prevState.attr, prevState.lbg, prevState.url}
 	}
 	if ansiCode[0] != '\x1b' || ansiCode[1] != '[' || ansiCode[len(ansiCode)-1] != 'm' {
-		if prevState != nil && strings.HasSuffix(ansiCode, "0K") {
+		if prevState != nil && (strings.HasSuffix(ansiCode, "0K") || strings.HasSuffix(ansiCode, "[K")) {
 			state.lbg = prevState.bg
-		} else if ansiCode == "\x1b]8;;\x1b\\" { // End of a hyperlink
-			state.url = nil
-		} else if strings.HasPrefix(ansiCode, "\x1b]8;") && strings.HasSuffix(ansiCode, "\x1b\\") {
-			if paramsEnd := strings.IndexRune(ansiCode[4:], ';'); paramsEnd >= 0 {
+		} else if strings.HasPrefix(ansiCode, "\x1b]8;") && (strings.HasSuffix(ansiCode, "\x1b\\") || strings.HasSuffix(ansiCode, "\a")) {
+			stLen := 2
+			if strings.HasSuffix(ansiCode, "\a") {
+				stLen = 1
+			}
+			// "\x1b]8;;\x1b\\" or "\x1b]8;;\a"
+			if len(ansiCode) == 5+stLen && ansiCode[4] == ';' {
+				state.url = nil
+			} else if paramsEnd := strings.IndexRune(ansiCode[4:], ';'); paramsEnd >= 0 {
 				params := ansiCode[4 : 4+paramsEnd]
-				uri := ansiCode[5+paramsEnd : len(ansiCode)-2]
+				uri := ansiCode[5+paramsEnd : len(ansiCode)-stLen]
 				state.url = &url{uri: uri, params: params}
 			}
 		}
 		return state
 	}
 
-	if len(ansiCode) <= 3 {
+	reset := func() {
 		state.fg = -1
 		state.bg = -1
+		state.ul = -1
 		state.attr = 0
+	}
+
+	if len(ansiCode) <= 3 {
+		reset()
 		return state
 	}
 	ansiCode = ansiCode[2 : len(ansiCode)-1]
@@ -384,7 +455,8 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 	count := 0
 	for len(ansiCode) != 0 {
 		var num int
-		if num, ansiCode = parseAnsiCode(ansiCode); num != -1 {
+		var sep byte
+		if num, sep, ansiCode = parseAnsiCode(ansiCode); num != -1 {
 			count++
 			switch state256 {
 			case 0:
@@ -395,10 +467,15 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 				case 48:
 					ptr = &state.bg
 					state256++
+				case 58:
+					ptr = &state.ul
+					state256++
 				case 39:
 					state.fg = -1
 				case 49:
 					state.bg = -1
+				case 59:
+					state.ul = -1
 				case 1:
 					state.attr = state.attr | tui.Bold
 				case 2:
@@ -406,7 +483,30 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 				case 3:
 					state.attr = state.attr | tui.Italic
 				case 4:
-					state.attr = state.attr | tui.Underline
+					if sep == ':' {
+						// SGR 4:N - underline style sub-parameter
+						var subNum int
+						subNum, _, ansiCode = parseAnsiCode(ansiCode)
+						state.attr = state.attr &^ tui.UnderlineStyleMask
+						switch subNum {
+						case 0:
+							state.attr = state.attr &^ tui.Underline
+						case 1:
+							state.attr = state.attr | tui.Underline
+						case 2:
+							state.attr = state.attr | tui.Underline | tui.UlStyleDouble
+						case 3:
+							state.attr = state.attr | tui.Underline | tui.UlStyleCurly
+						case 4:
+							state.attr = state.attr | tui.Underline | tui.UlStyleDotted
+						case 5:
+							state.attr = state.attr | tui.Underline | tui.UlStyleDashed
+						default:
+							state.attr = state.attr | tui.Underline
+						}
+					} else {
+						state.attr = state.attr | tui.Underline
+					}
 				case 5:
 					state.attr = state.attr | tui.Blink
 				case 7:
@@ -420,6 +520,7 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 					state.attr = state.attr &^ tui.Italic
 				case 24: // tput rmul
 					state.attr = state.attr &^ tui.Underline
+					state.attr = state.attr &^ tui.UnderlineStyleMask
 				case 25:
 					state.attr = state.attr &^ tui.Blink
 				case 27:
@@ -427,9 +528,7 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 				case 29:
 					state.attr = state.attr &^ tui.StrikeThrough
 				case 0:
-					state.fg = -1
-					state.bg = -1
-					state.attr = 0
+					reset()
 					state256 = 0
 				default:
 					if num >= 30 && num <= 37 {
@@ -469,9 +568,7 @@ func interpretCode(ansiCode string, prevState *ansiState) ansiState {
 
 	// Empty sequence: reset
 	if count == 0 {
-		state.fg = -1
-		state.bg = -1
-		state.attr = 0
+		reset()
 	}
 
 	if state256 > 0 {

src/ansi_test.go

@@ -22,7 +22,7 @@ import (
 //     (archived from http://ascii-table.com/ansi-escape-sequences-vt-100.php)
 //   - http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
 //   - https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
-var ansiRegexReference = regexp.MustCompile("(?:\x1b[\\[()][0-9;:]*[a-zA-Z@]|\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)")
+var ansiRegexReference = regexp.MustCompile("(?:\x1b[\\[()][0-9;:]*[a-zA-Z@]|\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08|\n)")
 
 func testParserReference(t testing.TB, str string) {
 	t.Helper()
@@ -41,7 +41,7 @@ func testParserReference(t testing.TB, str string) {
 
 		equal := len(got) == len(exp)
 		if equal {
-			for i := 0; i < len(got); i++ {
+			for i := range got {
 				if got[i] != exp[i] {
 					equal = false
 					break
@@ -167,9 +167,9 @@ func TestNextAnsiEscapeSequence_Fuzz_Random(t *testing.T) {
 	randomString := func(rr *rand.Rand) string {
 		numChars := rand.Intn(50)
 		codePoints := make([]rune, numChars)
-		for i := 0; i < len(codePoints); i++ {
+		for i := range codePoints {
 			var r rune
-			for n := 0; n < 1000; n++ {
+			for range 1000 {
 				r = rune(rr.Intn(utf8.MaxRune))
 				// Allow 10% of runes to be invalid
 				if utf8.ValidRune(r) || rr.Float64() < 0.10 {
@@ -182,7 +182,7 @@ func TestNextAnsiEscapeSequence_Fuzz_Random(t *testing.T) {
 	}
 
 	rr := rand.New(rand.NewSource(1))
-	for i := 0; i < 100_000; i++ {
+	for range 100_000 {
 		testParserReference(t, randomString(rr))
 	}
 }
@@ -369,10 +369,10 @@ func TestAnsiCodeStringConversion(t *testing.T) {
 		}
 	}
 	assert("\x1b[m", nil, "")
-	assert("\x1b[m", &ansiState{attr: tui.Blink, lbg: -1}, "")
-	assert("\x1b[0m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
-	assert("\x1b[;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
-	assert("\x1b[;;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
+	assert("\x1b[m", &ansiState{attr: tui.Blink, ul: -1, lbg: -1}, "")
+	assert("\x1b[0m", &ansiState{fg: 4, bg: 4, ul: -1, lbg: -1}, "")
+	assert("\x1b[;m", &ansiState{fg: 4, bg: 4, ul: -1, lbg: -1}, "")
+	assert("\x1b[;;m", &ansiState{fg: 4, bg: 4, ul: -1, lbg: -1}, "")
 
 	assert("\x1b[31m", nil, "\x1b[31;49m")
 	assert("\x1b[41m", nil, "\x1b[39;41m")
@@ -380,36 +380,142 @@ func TestAnsiCodeStringConversion(t *testing.T) {
 	assert("\x1b[92m", nil, "\x1b[92;49m")
 	assert("\x1b[102m", nil, "\x1b[39;102m")
 
-	assert("\x1b[31m", &ansiState{fg: 4, bg: 4, lbg: -1}, "\x1b[31;44m")
-	assert("\x1b[1;2;31m", &ansiState{fg: 2, bg: -1, attr: tui.Reverse, lbg: -1}, "\x1b[1;2;7;31;49m")
+	assert("\x1b[31m", &ansiState{fg: 4, bg: 4, ul: -1, lbg: -1}, "\x1b[31;44m")
+	assert("\x1b[1;2;31m", &ansiState{fg: 2, bg: -1, ul: -1, attr: tui.Reverse, lbg: -1}, "\x1b[1;2;7;31;49m")
 	assert("\x1b[38;5;100;48;5;200m", nil, "\x1b[38;5;100;48;5;200m")
 	assert("\x1b[38:5:100:48:5:200m", nil, "\x1b[38;5;100;48;5;200m")
 	assert("\x1b[48;5;100;38;5;200m", nil, "\x1b[38;5;200;48;5;100m")
 	assert("\x1b[48;5;100;38;2;10;20;30;1m", nil, "\x1b[1;38;2;10;20;30;48;5;100m")
 	assert("\x1b[48;5;100;38;2;10;20;30;7m",
-		&ansiState{attr: tui.Dim | tui.Italic, fg: 1, bg: 1},
+		&ansiState{attr: tui.Dim | tui.Italic, fg: 1, bg: 1, ul: -1},
 		"\x1b[2;3;7;38;2;10;20;30;48;5;100m")
+
+	// Underline styles
+	assert("\x1b[4:3m", nil, "\x1b[4:3;39;49m")
+	assert("\x1b[4:2m", nil, "\x1b[4:2;39;49m")
+	assert("\x1b[4:4m", nil, "\x1b[4:4;39;49m")
+	assert("\x1b[4:5m", nil, "\x1b[4:5;39;49m")
+	assert("\x1b[4:1m", nil, "\x1b[4;39;49m")
+
+	// Underline color (256-color)
+	assert("\x1b[4;58;5;100m", nil, "\x1b[4;39;49;58;5;100m")
+	// Underline color (24-bit)
+	assert("\x1b[4;58;2;255;0;128m", nil, "\x1b[4;39;49;58;2;255;0;128m")
+	// Curly underline + underline color
+	assert("\x1b[4:3;58;2;255;0;0m", nil, "\x1b[4:3;39;49;58;2;255;0;0m")
+	// SGR 59 resets underline color
+	assert("\x1b[59m", &ansiState{fg: 1, bg: -1, ul: 100, lbg: -1}, "\x1b[31;49m")
 }
 
 func TestParseAnsiCode(t *testing.T) {
 	tests := []struct {
-		In, Exp string
-		N       int
+		In  string
+		Exp string
+		N   int
+		Sep byte
 	}{
-		{"123", "", 123},
-		{"1a", "", -1},
-		{"1a;12", "12", -1},
-		{"12;a", "a", 12},
-		{"-2", "", -1},
+		{"123", "", 123, 0},
+		{"1a", "", -1, 0},
+		{"1a;12", "12", -1, ';'},
+		{"12;a", "a", 12, ';'},
+		{"-2", "", -1, 0},
+		// Colon sub-parameters: earliest separator wins (@shtse8)
+		{"4:3", "3", 4, ':'},
+		{"4:3;31", "3;31", 4, ':'},
+		{"38:2:255:0:0", "2:255:0:0", 38, ':'},
+		{"58:5:200", "5:200", 58, ':'},
+		// Semicolon before colon
+		{"4;38:2:0:0:0", "38:2:0:0:0", 4, ';'},
 	}
 	for _, x := range tests {
-		n, s := parseAnsiCode(x.In)
-		if n != x.N || s != x.Exp {
-			t.Fatalf("%q: got: (%d %q) want: (%d %q)", x.In, n, s, x.N, x.Exp)
+		n, sep, s := parseAnsiCode(x.In)
+		if n != x.N || s != x.Exp || sep != x.Sep {
+			t.Fatalf("%q: got: (%d %q %q) want: (%d %q %q)", x.In, n, s, string(sep), x.N, x.Exp, string(x.Sep))
 		}
 	}
 }
 
+// Test cases adapted from @shtse8 (PR #4678)
+func TestInterpretCodeUnderlineStyles(t *testing.T) {
+	// 4:0 = no underline
+	state := interpretCode("\x1b[4:0m", nil)
+	if state.attr&tui.Underline != 0 {
+		t.Error("4:0 should not set underline")
+	}
+
+	// 4:1 = single underline
+	state = interpretCode("\x1b[4:1m", nil)
+	if state.attr&tui.Underline == 0 {
+		t.Error("4:1 should set underline")
+	}
+
+	// 4:3 = curly underline
+	state = interpretCode("\x1b[4:3m", nil)
+	if state.attr&tui.Underline == 0 {
+		t.Error("4:3 should set underline")
+	}
+	if state.attr.UnderlineStyle() != tui.UlStyleCurly {
+		t.Error("4:3 should set curly underline style")
+	}
+
+	// 4:3 should NOT set italic (3 is a sub-param, not SGR 3)
+	if state.attr&tui.Italic != 0 {
+		t.Error("4:3 should not set italic")
+	}
+
+	// 4:2;31 = double underline + red fg
+	state = interpretCode("\x1b[4:2;31m", nil)
+	if state.attr&tui.Underline == 0 {
+		t.Error("4:2;31 should set underline")
+	}
+	if state.fg != 1 {
+		t.Errorf("4:2;31 should set fg to red (1), got %d", state.fg)
+	}
+	if state.attr&tui.Dim != 0 {
+		t.Error("4:2;31 should not set dim")
+	}
+
+	// Plain 4 still works
+	state = interpretCode("\x1b[4m", nil)
+	if state.attr&tui.Underline == 0 {
+		t.Error("4 should set underline")
+	}
+
+	// 4;2 (semicolon) = underline + dim
+	state = interpretCode("\x1b[4;2m", nil)
+	if state.attr&tui.Underline == 0 {
+		t.Error("4;2 should set underline")
+	}
+	if state.attr&tui.Dim == 0 {
+		t.Error("4;2 should set dim")
+	}
+}
+
+// Test cases adapted from @shtse8 (PR #4678)
+func TestInterpretCodeUnderlineColor(t *testing.T) {
+	// 58:2:R:G:B should not affect fg or bg
+	state := interpretCode("\x1b[58:2:255:0:0m", nil)
+	if state.fg != -1 || state.bg != -1 {
+		t.Errorf("58:2:R:G:B should not affect fg/bg, got fg=%d bg=%d", state.fg, state.bg)
+	}
+
+	// 58:5:200 should not affect fg or bg
+	state = interpretCode("\x1b[58:5:200m", nil)
+	if state.fg != -1 || state.bg != -1 {
+		t.Errorf("58:5:N should not affect fg/bg, got fg=%d bg=%d", state.fg, state.bg)
+	}
+
+	// 58:2:R:G:B combined with 38:2:R:G:B should only set fg
+	state = interpretCode("\x1b[58:2:255:0:0;38:2:0:255:0m", nil)
+	expectedFg := tui.Color(1<<24 | 0<<16 | 255<<8 | 0)
+	if state.fg != expectedFg {
+		t.Errorf("expected fg=%d, got %d", expectedFg, state.fg)
+	}
+	if state.bg != -1 {
+		t.Errorf("bg should be -1, got %d", state.bg)
+	}
+}
+
 // kernel/bpf/preload/iterators/README
 const ansiBenchmarkString = "\x1b[38;5;81m\x1b[01;31m\x1b[Kkernel/\x1b[0m\x1b[38:5:81mbpf/" +
 	"\x1b[0m\x1b[38:5:81mpreload/\x1b[0m\x1b[38;5;81miterators/" +

src/cache.go

@@ -2,10 +2,13 @@ package fzf
 
 import "sync"
 
-// queryCache associates strings to lists of items
-type queryCache map[string][]Result
+// ChunkBitmap is a bitmap with one bit per item in a chunk.
+type ChunkBitmap [chunkBitWords]uint64
 
-// ChunkCache associates Chunk and query string to lists of items
+// queryCache associates query strings to bitmaps of matching items
+type queryCache map[string]ChunkBitmap
+
+// ChunkCache associates Chunk and query string to bitmaps
 type ChunkCache struct {
 	mutex sync.Mutex
 	cache map[*Chunk]*queryCache
@@ -30,9 +33,9 @@ func (cc *ChunkCache) retire(chunk ...*Chunk) {
 	cc.mutex.Unlock()
 }
 
-// Add adds the list to the cache
-func (cc *ChunkCache) Add(chunk *Chunk, key string, list []Result) {
-	if len(key) == 0 || !chunk.IsFull() || len(list) > queryCacheMax {
+// Add stores the bitmap for the given chunk and key
+func (cc *ChunkCache) Add(chunk *Chunk, key string, bitmap ChunkBitmap, matchCount int) {
+	if len(key) == 0 || !chunk.IsFull() || matchCount > queryCacheMax {
 		return
 	}
 
@@ -44,11 +47,11 @@ func (cc *ChunkCache) Add(chunk *Chunk, key string, list []Result) {
 		cc.cache[chunk] = &queryCache{}
 		qc = cc.cache[chunk]
 	}
-	(*qc)[key] = list
+	(*qc)[key] = bitmap
 }
 
-// Lookup is called to lookup ChunkCache
-func (cc *ChunkCache) Lookup(chunk *Chunk, key string) []Result {
+// Lookup returns the bitmap for the exact key
+func (cc *ChunkCache) Lookup(chunk *Chunk, key string) *ChunkBitmap {
 	if len(key) == 0 || !chunk.IsFull() {
 		return nil
 	}
@@ -58,15 +61,15 @@ func (cc *ChunkCache) Lookup(chunk *Chunk, key string) []Result {
 
 	qc, ok := cc.cache[chunk]
 	if ok {
-		list, ok := (*qc)[key]
-		if ok {
-			return list
+		if bm, ok := (*qc)[key]; ok {
+			return &bm
 		}
 	}
 	return nil
 }
 
-func (cc *ChunkCache) Search(chunk *Chunk, key string) []Result {
+// Search finds the bitmap for the longest prefix or suffix of the key
+func (cc *ChunkCache) Search(chunk *Chunk, key string) *ChunkBitmap {
 	if len(key) == 0 || !chunk.IsFull() {
 		return nil
 	}
@@ -86,8 +89,8 @@ func (cc *ChunkCache) Search(chunk *Chunk, key string) []Result {
 		prefix := key[:len(key)-idx]
 		suffix := key[idx:]
 		for _, substr := range [2]string{prefix, suffix} {
-			if cached, found := (*qc)[substr]; found {
-				return cached
+			if bm, found := (*qc)[substr]; found {
+				return &bm
 			}
 		}
 	}

src/cache_test.go

@@ -6,34 +6,34 @@ func TestChunkCache(t *testing.T) {
 	cache := NewChunkCache()
 	chunk1p := &Chunk{}
 	chunk2p := &Chunk{count: chunkSize}
-	items1 := []Result{{}}
-	items2 := []Result{{}, {}}
-	cache.Add(chunk1p, "foo", items1)
-	cache.Add(chunk2p, "foo", items1)
-	cache.Add(chunk2p, "bar", items2)
+	bm1 := ChunkBitmap{1}
+	bm2 := ChunkBitmap{1, 2}
+	cache.Add(chunk1p, "foo", bm1, 1)
+	cache.Add(chunk2p, "foo", bm1, 1)
+	cache.Add(chunk2p, "bar", bm2, 2)
 
 	{ // chunk1 is not full
 		cached := cache.Lookup(chunk1p, "foo")
 		if cached != nil {
-			t.Error("Cached disabled for non-empty chunks", cached)
+			t.Error("Cached disabled for non-full chunks", cached)
 		}
 	}
 	{
 		cached := cache.Lookup(chunk2p, "foo")
-		if cached == nil || len(cached) != 1 {
-			t.Error("Expected 1 item cached", cached)
+		if cached == nil || cached[0] != 1 {
+			t.Error("Expected bitmap cached", cached)
 		}
 	}
 	{
 		cached := cache.Lookup(chunk2p, "bar")
-		if cached == nil || len(cached) != 2 {
-			t.Error("Expected 2 items cached", cached)
+		if cached == nil || cached[1] != 2 {
+			t.Error("Expected bitmap cached", cached)
 		}
 	}
 	{
 		cached := cache.Lookup(chunk1p, "foobar")
 		if cached != nil {
-			t.Error("Expected 0 item cached", cached)
+			t.Error("Expected nil cached", cached)
 		}
 	}
 }

src/chunklist.go

@@ -41,10 +41,31 @@ func (c *Chunk) IsFull() bool {
 	return c.count == chunkSize
 }
 
+func (c *Chunk) lastIndex(minValue int32) int32 {
+	if c.count == 0 {
+		return minValue
+	}
+	return c.items[c.count-1].Index() + 1 // Exclusive
+}
+
 func (cl *ChunkList) lastChunk() *Chunk {
 	return cl.chunks[len(cl.chunks)-1]
 }
 
+// GetItems returns the first n items from the given chunks
+func GetItems(chunks []*Chunk, n int) []Item {
+	items := make([]Item, 0, n)
+	for _, chunk := range chunks {
+		for i := 0; i < chunk.count && len(items) < n; i++ {
+			items = append(items, chunk.items[i])
+		}
+		if len(items) >= n {
+			break
+		}
+	}
+	return items
+}
+
 // CountItems returns the total number of Items
 func CountItems(cs []*Chunk) int {
 	if len(cs) == 0 {
@@ -78,6 +99,21 @@ func (cl *ChunkList) Clear() {
 	cl.mutex.Unlock()
 }
 
+// ForEachItem iterates all items and applies fn to each one.
+// The done callback runs under the lock to safely update shared state.
+func (cl *ChunkList) ForEachItem(fn func(*Item), done func()) {
+	cl.mutex.Lock()
+	for _, chunk := range cl.chunks {
+		for i := 0; i < chunk.count; i++ {
+			fn(&chunk.items[i])
+		}
+	}
+	if done != nil {
+		done()
+	}
+	cl.mutex.Unlock()
+}
+
 // Snapshot returns immutable snapshot of the ChunkList
 func (cl *ChunkList) Snapshot(tail int) ([]*Chunk, int, bool) {
 	cl.mutex.Lock()

src/chunklist_test.go

@@ -51,8 +51,8 @@ func TestChunkList(t *testing.T) {
 	}
 
 	// Add more data
-	for i := 0; i < chunkSize*2; i++ {
-		cl.Push([]byte(fmt.Sprintf("item %d", i)))
+	for i := range chunkSize * 2 {
+		cl.Push(fmt.Appendf(nil, "item %d", i))
 	}
 
 	// Previous snapshot should remain the same
@@ -85,8 +85,8 @@ func TestChunkListTail(t *testing.T) {
 		return true
 	})
 	total := chunkSize*2 + chunkSize/2
-	for i := 0; i < total; i++ {
-		cl.Push([]byte(fmt.Sprintf("item %d", i)))
+	for i := range total {
+		cl.Push(fmt.Appendf(nil, "item %d", i))
 	}
 
 	snapshot, count, changed := cl.Snapshot(0)

src/constants.go

@@ -26,23 +26,26 @@ const (
 	previewCancelWait = 500 * time.Millisecond
 	previewChunkDelay = 100 * time.Millisecond
 	previewDelayed    = 500 * time.Millisecond
-	maxPatternLength  = 300
+	maxPatternLength  = 1000
 	maxMulti          = math.MaxInt32
 
+	// Background processes
+	maxBgProcesses          = 30
+	maxBgProcessesPerAction = 3
+
 	// Matcher
-	numPartitionsMultiplier = 8
-	maxPartitions           = 32
-	progressMinDuration     = 200 * time.Millisecond
+	progressMinDuration = 200 * time.Millisecond
 
 	// Capacity of each chunk
-	chunkSize int = 100
+	chunkSize     int = 1024
+	chunkBitWords     = (chunkSize + 63) / 64
 
 	// Pre-allocated memory slices to minimize GC
 	slab16Size int = 100 * 1024 // 200KB * 32 = 12.8MB
 	slab32Size int = 2048       // 8KB * 32 = 256KB
 
 	// Do not cache results of low selectivity queries
-	queryCacheMax int = chunkSize / 5
+	queryCacheMax int = chunkSize / 2
 
 	// Not to cache mergers with large lists
 	mergerCacheMax int = 100000
@@ -61,7 +64,6 @@ const (
 	EvtSearchNew
 	EvtSearchProgress
 	EvtSearchFin
-	EvtHeader
 	EvtReady
 	EvtQuit
 )

src/core.go

@@ -2,10 +2,13 @@
 package fzf
 
 import (
+	"fmt"
+	"maps"
 	"os"
 	"sync"
 	"time"
 
+	"github.com/junegunn/fzf/src/tui"
 	"github.com/junegunn/fzf/src/util"
 )
 
@@ -15,7 +18,6 @@ Reader   -> EvtReadNew        -> Matcher  (restart)
 Terminal -> EvtSearchNew:bool -> Matcher  (restart)
 Matcher  -> EvtSearchProgress -> Terminal (update info)
 Matcher  -> EvtSearchFin      -> Terminal (update list)
-Matcher  -> EvtHeader         -> Terminal (update header)
 */
 
 type revision struct {
@@ -36,12 +38,27 @@ func (r revision) compatible(other revision) bool {
 	return r.major == other.major
 }
 
+func buildItemTransformer(opts *Options) func(*Item) string {
+	if opts.AcceptNth != nil {
+		fn := opts.AcceptNth(opts.Delimiter)
+		return func(item *Item) string {
+			return item.acceptNth(opts.Ansi, opts.Delimiter, fn)
+		}
+	}
+	return func(item *Item) string {
+		return item.AsString(opts.Ansi)
+	}
+}
+
 // Run starts fzf
 func Run(opts *Options) (int, error) {
 	if opts.Filter == nil {
-		if opts.Tmux != nil && len(os.Getenv("TMUX")) > 0 && opts.Tmux.index >= opts.Height.index {
+		if opts.useTmux() {
 			return runTmux(os.Args, opts)
 		}
+		if opts.useZellij() {
+			return runZellij(os.Args, opts)
+		}
 
 		if needWinpty(opts) {
 			return runWinpty(os.Args, opts)
@@ -74,20 +91,24 @@ func Run(opts *Options) (int, error) {
 
 	var lineAnsiState, prevLineAnsiState *ansiState
 	if opts.Ansi {
-		if opts.Theme.Colored {
-			ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
-				prevLineAnsiState = lineAnsiState
-				trimmed, offsets, newState := extractColor(byteString(data), lineAnsiState, nil)
-				lineAnsiState = newState
-				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(byteString(data), nil, nil)
-				return util.ToChars(stringBytes(trimmed)), nil
+		ansiProcessor = func(data []byte) (util.Chars, *[]ansiOffset) {
+			prevLineAnsiState = lineAnsiState
+			trimmed, offsets, newState := extractColor(byteString(data), lineAnsiState, nil)
+			lineAnsiState = newState
+
+			// Full line background is found. Add a special marker.
+			if offsets != nil && newState != nil && len(*offsets) > 0 && newState.lbg >= 0 {
+				marker := (*offsets)[len(*offsets)-1]
+				marker.offset[0] = marker.offset[1]
+				marker.color.bg = newState.lbg
+				marker.color.attr = marker.color.attr | tui.FullBg
+				newOffsets := append(*offsets, marker)
+				offsets = &newOffsets
+
+				// Reset the full-line background color
+				lineAnsiState.lbg = -1
 			}
+			return util.ToChars(stringBytes(trimmed)), offsets
 		}
 	}
 
@@ -95,47 +116,57 @@ func Run(opts *Options) (int, error) {
 	cache := NewChunkCache()
 	var chunkList *ChunkList
 	var itemIndex int32
-	header := make([]string, 0, opts.HeaderLines)
-	if len(opts.WithNth) == 0 {
-		chunkList = NewChunkList(cache, func(item *Item, data []byte) bool {
-			if len(header) < opts.HeaderLines {
-				header = append(header, byteString(data))
-				eventBox.Set(EvtHeader, header)
-				return false
+	// transformItem applies with-nth transformation to an item's raw data.
+	// It handles ANSI token propagation using prevLineAnsiState for cross-line continuity.
+	transformItem := func(item *Item, data []byte, transformer func([]Token, int32) string, index int32) {
+		tokens := Tokenize(byteString(data), opts.Delimiter)
+		if opts.Ansi && len(tokens) > 1 {
+			var ansiState *ansiState
+			if prevLineAnsiState != nil {
+				ansiStateDup := *prevLineAnsiState
+				ansiState = &ansiStateDup
 			}
+			for _, token := range tokens {
+				prevAnsiState := ansiState
+				_, _, ansiState = extractColor(token.text.ToString(), ansiState, nil)
+				if prevAnsiState != nil {
+					token.text.Prepend("\x1b[m" + prevAnsiState.ToString())
+				} else {
+					token.text.Prepend("\x1b[m")
+				}
+			}
+		}
+		transformed := transformer(tokens, index)
+		item.text, item.colors = ansiProcessor(stringBytes(transformed))
+
+		// We should not trim trailing whitespaces with background colors
+		var maxColorOffset int32
+		if item.colors != nil {
+			for _, ansi := range *item.colors {
+				if ansi.color.bg >= 0 {
+					maxColorOffset = max(maxColorOffset, ansi.offset[1])
+				}
+			}
+		}
+		item.text.TrimTrailingWhitespaces(int(maxColorOffset))
+	}
+
+	var nthTransformer func([]Token, int32) string
+	if opts.WithNth == nil {
+		chunkList = NewChunkList(cache, func(item *Item, data []byte) bool {
 			item.text, item.colors = ansiProcessor(data)
 			item.text.Index = itemIndex
 			itemIndex++
 			return true
 		})
 	} else {
+		nthTransformer = opts.WithNth(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 {
-					ansiStateDup := *prevLineAnsiState
-					ansiState = &ansiStateDup
-				}
-				for _, token := range tokens {
-					prevAnsiState := ansiState
-					_, _, ansiState = extractColor(token.text.ToString(), ansiState, nil)
-					if prevAnsiState != nil {
-						token.text.Prepend("\x1b[m" + prevAnsiState.ToString())
-					} else {
-						token.text.Prepend("\x1b[m")
-					}
-				}
+			if nthTransformer == nil {
+				item.text, item.colors = ansiProcessor(data)
+			} else {
+				transformItem(item, data, nthTransformer, itemIndex)
 			}
-			trans := Transform(tokens, opts.WithNth)
-			transformed := joinTokens(trans)
-			if len(header) < opts.HeaderLines {
-				header = append(header, transformed)
-				eventBox.Set(EvtHeader, header)
-				return false
-			}
-			item.text, item.colors = ansiProcessor(stringBytes(transformed))
-			item.text.TrimTrailingWhitespaces()
 			item.text.Index = itemIndex
 			item.origText = &data
 			itemIndex++
@@ -165,13 +196,15 @@ func Run(opts *Options) (int, error) {
 	}
 
 	// Reader
-	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
+	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync && opts.Bench == 0
 	var reader *Reader
+	var ingestionStart time.Time
 	if !streamingFilter {
 		reader = NewReader(func(data []byte) bool {
 			return chunkList.Push(data)
 		}, eventBox, executor, opts.ReadZero, opts.Filter == nil)
 
+		ingestionStart = time.Now()
 		readyChan := make(chan bool)
 		go reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip, initialReload, initialEnv, readyChan)
 		<-readyChan
@@ -188,20 +221,37 @@ func Run(opts *Options) (int, error) {
 			forward = false
 		case byBegin:
 			forward = true
+		case byPathname:
+			withPos = true
+			forward = false
 		}
 	}
 
 	nth := opts.Nth
-	nthRevision := 0
-	patternCache := make(map[string]*Pattern)
-	patternBuilder := func(runes []rune) *Pattern {
-		return BuildPattern(cache, patternCache,
-			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward, withPos,
-			opts.Filter == nil, nth, opts.Delimiter, nthRevision, runes)
-	}
 	inputRevision := revision{}
 	snapshotRevision := revision{}
-	matcher := NewMatcher(cache, patternBuilder, sort, opts.Tac, eventBox, inputRevision)
+	patternCache := make(map[string]*Pattern)
+	denyMutex := sync.Mutex{}
+	denylist := make(map[int32]struct{})
+	clearDenylist := func() {
+		denyMutex.Lock()
+		if len(denylist) > 0 {
+			patternCache = make(map[string]*Pattern)
+		}
+		denylist = make(map[int32]struct{})
+		denyMutex.Unlock()
+	}
+	headerLines := int32(opts.HeaderLines)
+	headerUpdated := false
+	patternBuilder := func(runes []rune) *Pattern {
+		denyMutex.Lock()
+		denylistCopy := maps.Clone(denylist)
+		denyMutex.Unlock()
+		return BuildPattern(cache, patternCache,
+			opts.Fuzzy, opts.FuzzyAlgo, opts.Extended, opts.Case, opts.Normalize, forward, withPos,
+			opts.Filter == nil, nth, opts.Delimiter, inputRevision, runes, denylistCopy, headerLines)
+	}
+	matcher := NewMatcher(cache, patternBuilder, sort, opts.Tac, eventBox, inputRevision, opts.Threads)
 
 	// Filtering mode
 	if opts.Filter != nil {
@@ -212,6 +262,8 @@ func Run(opts *Options) (int, error) {
 		pattern := patternBuilder([]rune(*opts.Filter))
 		matcher.sort = pattern.sortable
 
+		transformer := buildItemTransformer(opts)
+
 		found := false
 		if streamingFilter {
 			slab := util.MakeSlab(slab16Size, slab32Size)
@@ -220,9 +272,12 @@ func Run(opts *Options) (int, error) {
 				func(runes []byte) bool {
 					item := Item{}
 					if chunkList.trans(&item, runes) {
+						if item.Index() < headerLines {
+							return false
+						}
 						mutex.Lock()
-						if result, _, _ := pattern.MatchItem(&item, false, slab); result != nil {
-							opts.Printer(item.text.ToString())
+						if result, _, _ := pattern.MatchItem(&item, false, slab); result.item != nil {
+							opts.Printer(transformer(&item))
 							found = true
 						}
 						mutex.Unlock()
@@ -233,14 +288,56 @@ func Run(opts *Options) (int, error) {
 		} else {
 			eventBox.Unwatch(EvtReadNew)
 			eventBox.WaitFor(EvtReadFin)
+			ingestionTime := time.Since(ingestionStart)
 
 			// NOTE: Streaming filter is inherently not compatible with --tail
 			snapshot, _, _ := chunkList.Snapshot(opts.Tail)
-			merger, _ := matcher.scan(MatchRequest{
+
+			if opts.Bench > 0 {
+				// Benchmark mode: repeat scan for the given duration
+				totalItems := CountItems(snapshot)
+				var matchCount int
+				var times []time.Duration
+				deadline := time.Now().Add(opts.Bench)
+				for time.Now().Before(deadline) {
+					cache.Clear()
+					start := time.Now()
+					result := matcher.scan(MatchRequest{
+						chunks:  snapshot,
+						pattern: pattern})
+					times = append(times, time.Since(start))
+					matchCount = result.merger.Length()
+				}
+				// Print stats
+				var total time.Duration
+				minD, maxD := times[0], times[0]
+				for _, d := range times {
+					total += d
+					if d < minD {
+						minD = d
+					}
+					if d > maxD {
+						maxD = d
+					}
+				}
+				avg := total / time.Duration(len(times))
+				selectivity := float64(matchCount) / float64(totalItems) * 100
+				fmt.Printf("  %d iterations  avg: %.2fms  min: %.2fms  max: %.2fms  total: %.2fs  items: %d  matches: %d (%.2f%%)  ingestion: %.2fms\n",
+					len(times),
+					float64(avg.Microseconds())/1000,
+					float64(minD.Microseconds())/1000,
+					float64(maxD.Microseconds())/1000,
+					total.Seconds(),
+					totalItems, matchCount, selectivity,
+					float64(ingestionTime.Microseconds())/1000)
+				return ExitOk, nil
+			}
+
+			result := matcher.scan(MatchRequest{
 				chunks:  snapshot,
 				pattern: pattern})
-			for i := 0; i < merger.Length(); i++ {
-				opts.Printer(merger.Get(i).item.AsString(opts.Ansi))
+			for i := 0; i < result.merger.Length(); i++ {
+				opts.Printer(transformer(result.merger.Get(i).item))
 				found = true
 			}
 		}
@@ -277,6 +374,7 @@ func Run(opts *Options) (int, error) {
 	// Event coordination
 	reading := true
 	ticks := 0
+	startTick := 0
 	var nextCommand *commandSpec
 	var nextEnviron []string
 	eventBox.Watch(EvtReadNew)
@@ -284,10 +382,11 @@ func Run(opts *Options) (int, error) {
 	query := []rune{}
 	determine := func(final bool) {
 		if heightUnknown {
-			if total >= maxFit || final {
+			items := max(0, total-int(headerLines))
+			if items >= maxFit || final {
 				deferred = false
 				heightUnknown = false
-				terminal.startChan <- fitpad{util.Min(total, maxFit), padHeight}
+				terminal.startChan <- fitpad{min(items, maxFit), padHeight}
 			}
 		} else if deferred {
 			deferred = false
@@ -299,11 +398,15 @@ func Run(opts *Options) (int, error) {
 	var snapshot []*Chunk
 	var count int
 	restart := func(command commandSpec, environ []string) {
+		if !useSnapshot {
+			clearDenylist()
+		}
 		reading = true
+		headerUpdated = false
+		startTick = ticks
 		chunkList.Clear()
 		itemIndex = 0
 		inputRevision.bumpMajor()
-		header = make([]string, 0, opts.HeaderLines)
 		readyChan := make(chan bool)
 		go reader.restart(command, environ, readyChan)
 		<-readyChan
@@ -345,7 +448,8 @@ func Run(opts *Options) (int, error) {
 					} else {
 						reading = reading && evt == EvtReadNew
 					}
-					if useSnapshot && evt == EvtReadFin {
+					if useSnapshot && evt == EvtReadFin { // reload-sync
+						clearDenylist()
 						useSnapshot = false
 					}
 					if !useSnapshot {
@@ -360,26 +464,79 @@ func Run(opts *Options) (int, error) {
 						snapshotRevision = inputRevision
 					}
 					total = count
-					terminal.UpdateCount(total, !reading, value.(*string))
+					terminal.UpdateCount(max(0, total-int(headerLines)), !reading, value.(*string))
+					if headerLines > 0 && !headerUpdated {
+						terminal.UpdateHeader(GetItems(snapshot, int(headerLines)))
+						headerUpdated = int32(total) >= headerLines
+					}
 					if heightUnknown && !deferred {
 						determine(!reading)
 					}
-					matcher.Reset(snapshot, input(), false, !reading, sort, snapshotRevision)
+					if !useSnapshot || evt == EvtReadFin {
+						matcher.Reset(snapshot, input(), false, !reading, sort, snapshotRevision)
+					}
 
 				case EvtSearchNew:
 					var command *commandSpec
 					var environ []string
 					var changed bool
+					headerLinesChanged := false
+					withNthChanged := false
 					switch val := value.(type) {
 					case searchRequest:
 						sort = val.sort
 						command = val.command
 						environ = val.environ
 						changed = val.changed
+						bump := false
+						if len(val.denylist) > 0 && val.revision.compatible(inputRevision) {
+							denyMutex.Lock()
+							for _, itemIndex := range val.denylist {
+								denylist[itemIndex] = struct{}{}
+							}
+							denyMutex.Unlock()
+							bump = true
+						}
 						if val.nth != nil {
 							// Change nth and clear caches
 							nth = *val.nth
-							nthRevision++
+							bump = true
+						}
+						if val.headerLines != nil {
+							headerLines = int32(*val.headerLines)
+							headerUpdated = false
+							headerLinesChanged = true
+							bump = true
+						}
+						if val.withNth != nil {
+							newTransformer := val.withNth.fn
+							// Cancel any in-flight scan and block the terminal from reading
+							// items before mutating them in-place. Snapshot shares middle
+							// chunk pointers, so the matcher and terminal can race with us.
+							matcher.CancelScan()
+							terminal.PauseRendering()
+							// Reset cross-line ANSI state before re-processing all items
+							lineAnsiState = nil
+							prevLineAnsiState = nil
+							chunkList.ForEachItem(func(item *Item) {
+								origBytes := *item.origText
+								savedIndex := item.Index()
+								if newTransformer != nil {
+									transformItem(item, origBytes, newTransformer, savedIndex)
+								} else {
+									item.text, item.colors = ansiProcessor(origBytes)
+								}
+								item.text.Index = savedIndex
+								item.transformed = nil
+							}, func() {
+								nthTransformer = newTransformer
+							})
+							terminal.ResumeRendering()
+							matcher.ResumeScan()
+							withNthChanged = true
+							bump = true
+						}
+						if bump {
 							patternCache = make(map[string]*Pattern)
 							cache.Clear()
 							inputRevision.bumpMinor()
@@ -415,6 +572,16 @@ func Run(opts *Options) (int, error) {
 							snapshotRevision = inputRevision
 						}
 					}
+					if headerLinesChanged {
+						terminal.UpdateCount(max(0, total-int(headerLines)), !reading, nil)
+						if headerLines > 0 {
+							terminal.UpdateHeader(GetItems(snapshot, int(headerLines)))
+						} else {
+							terminal.UpdateHeader(nil)
+						}
+					} else if withNthChanged && headerLines > 0 {
+						terminal.UpdateHeader(GetItems(snapshot, int(headerLines)))
+					}
 					matcher.Reset(snapshot, input(), true, !reading, sort, snapshotRevision)
 					delay = false
 
@@ -424,19 +591,15 @@ func Run(opts *Options) (int, error) {
 						terminal.UpdateProgress(val)
 					}
 
-				case EvtHeader:
-					headerPadded := make([]string, opts.HeaderLines)
-					copy(headerPadded, value.([]string))
-					terminal.UpdateHeader(headerPadded)
-
 				case EvtSearchFin:
 					switch val := value.(type) {
-					case *Merger:
+					case MatchResult:
+						merger := val.merger
 						if deferred {
-							count := val.Length()
+							count := merger.Length()
 							if opts.Select1 && count > 1 || opts.Exit0 && !opts.Select1 && count > 0 {
-								determine(val.final)
-							} else if val.final {
+								determine(merger.final)
+							} else if merger.final {
 								if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
 									if opts.PrintQuery {
 										opts.Printer(opts.Query)
@@ -444,8 +607,9 @@ func Run(opts *Options) (int, error) {
 									if len(opts.Expect) > 0 {
 										opts.Printer("")
 									}
-									for i := 0; i < count; i++ {
-										opts.Printer(val.Get(i).item.AsString(opts.Ansi))
+									transformer := buildItemTransformer(opts)
+									for i := range count {
+										opts.Printer(transformer(merger.Get(i).item))
 									}
 									if count == 0 {
 										exitCode = ExitNoMatch
@@ -453,7 +617,7 @@ func Run(opts *Options) (int, error) {
 									stop = true
 									return
 								}
-								determine(val.final)
+								determine(merger.final)
 							}
 						}
 						terminal.UpdateList(val)
@@ -466,8 +630,8 @@ func Run(opts *Options) (int, error) {
 			break
 		}
 		if delay && reading {
-			dur := util.DurWithin(
-				time.Duration(ticks)*coordinatorDelayStep,
+			dur := util.Constrain(
+				time.Duration(ticks-startTick)*coordinatorDelayStep,
 				0, coordinatorDelayMax)
 			time.Sleep(dur)
 		}

src/history_test.go

@@ -38,7 +38,7 @@ func TestHistory(t *testing.T) {
 		if len(h.lines) != maxHistory+1 {
 			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
 		}
-		for i := 0; i < maxHistory; i++ {
+		for i := range maxHistory {
 			if h.lines[i] != "foobar" {
 				t.Error("Expected: foobar, actual: " + h.lines[i])
 			}

src/item.go

@@ -9,7 +9,7 @@ import (
 type transformed struct {
 	// Because nth can be changed dynamically by change-nth action, we need to
 	// keep the revision number at the time of transformation.
-	revision int
+	revision revision
 	tokens   []Token
 }
 
@@ -51,3 +51,9 @@ func (item *Item) AsString(stripAnsi bool) string {
 	}
 	return item.text.ToString()
 }
+
+func (item *Item) acceptNth(stripAnsi bool, delimiter Delimiter, transformer func([]Token, int32) string) string {
+	tokens := Tokenize(item.AsString(stripAnsi), delimiter)
+	transformed := transformer(tokens, item.Index())
+	return StripLastDelimiter(transformed, delimiter)
+}

src/matcher.go

@@ -3,8 +3,8 @@ package fzf
 import (
 	"fmt"
 	"runtime"
-	"sort"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/junegunn/fzf/src/util"
@@ -19,6 +19,20 @@ type MatchRequest struct {
 	revision revision
 }
 
+type MatchResult struct {
+	merger     *Merger
+	passMerger *Merger
+	cancelled  bool
+}
+
+func (mr MatchResult) cacheable() bool {
+	return mr.merger != nil && mr.merger.cacheable()
+}
+
+func (mr MatchResult) final() bool {
+	return mr.merger != nil && mr.merger.final
+}
+
 // Matcher is responsible for performing search
 type Matcher struct {
 	cache          *ChunkCache
@@ -29,8 +43,11 @@ type Matcher struct {
 	reqBox         *util.EventBox
 	partitions     int
 	slab           []*util.Slab
-	mergerCache    map[string]*Merger
+	sortBuf        [][]Result
+	mergerCache    map[string]MatchResult
 	revision       revision
+	scanMutex      sync.Mutex
+	cancelScan     *util.AtomicBool
 }
 
 const (
@@ -40,8 +57,11 @@ const (
 
 // NewMatcher returns a new 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)
+	sort bool, tac bool, eventBox *util.EventBox, revision revision, threads int) *Matcher {
+	partitions := runtime.NumCPU()
+	if threads > 0 {
+		partitions = threads
+	}
 	return &Matcher{
 		cache:          cache,
 		patternBuilder: patternBuilder,
@@ -51,8 +71,10 @@ func NewMatcher(cache *ChunkCache, patternBuilder func([]rune) *Pattern,
 		reqBox:         util.NewEventBox(),
 		partitions:     partitions,
 		slab:           make([]*util.Slab, partitions),
-		mergerCache:    make(map[string]*Merger),
-		revision:       revision}
+		sortBuf:        make([][]Result, partitions),
+		mergerCache:    make(map[string]MatchResult),
+		revision:       revision,
+		cancelScan:     util.NewAtomicBool(false)}
 }
 
 // Loop puts Matcher in action
@@ -85,125 +107,102 @@ func (m *Matcher) Loop() {
 		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)
+			m.mergerCache = make(map[string]MatchResult)
 			if !request.revision.compatible(m.revision) {
 				m.cache.Clear()
 			}
+			m.revision = request.revision
 			cacheCleared = true
 		}
 
 		// Restart search
 		patternString := request.pattern.AsString()
-		var merger *Merger
-		cancelled := false
+		var result MatchResult
 		count := CountItems(request.chunks)
 
 		if !cacheCleared {
 			if count == prevCount {
 				// Look up mergerCache
-				if cached, found := m.mergerCache[patternString]; found && cached.final == request.final {
-					merger = cached
+				if cached, found := m.mergerCache[patternString]; found && cached.final() == request.final {
+					result = cached
 				}
 			} else {
 				// Invalidate mergerCache
 				prevCount = count
-				m.mergerCache = make(map[string]*Merger)
+				m.mergerCache = make(map[string]MatchResult)
 			}
 		}
 
-		if merger == nil {
-			merger, cancelled = m.scan(request)
+		if result.merger == nil {
+			m.scanMutex.Lock()
+			result = m.scan(request)
+			m.scanMutex.Unlock()
 		}
 
-		if !cancelled {
-			if merger.cacheable() {
-				m.mergerCache[patternString] = merger
+		if !result.cancelled {
+			if result.cacheable() {
+				m.mergerCache[patternString] = result
 			}
-			merger.final = request.final
-			m.eventBox.Set(EvtSearchFin, merger)
+			result.merger.final = request.final
+			m.eventBox.Set(EvtSearchFin, result)
 		}
 	}
 }
 
-func (m *Matcher) sliceChunks(chunks []*Chunk) [][]*Chunk {
-	partitions := m.partitions
-	perSlice := len(chunks) / partitions
-
-	if perSlice == 0 {
-		partitions = len(chunks)
-		perSlice = 1
-	}
-
-	slices := make([][]*Chunk, partitions)
-	for i := 0; i < partitions; i++ {
-		start := i * perSlice
-		end := start + perSlice
-		if i == partitions-1 {
-			end = len(chunks)
-		}
-		slices[i] = chunks[start:end]
-	}
-	return slices
-}
-
 type partialResult struct {
 	index   int
 	matches []Result
 }
 
-func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
+func (m *Matcher) scan(request MatchRequest) MatchResult {
 	startedAt := time.Now()
 
 	numChunks := len(request.chunks)
 	if numChunks == 0 {
-		return EmptyMerger(request.revision), false
+		m := EmptyMerger(request.revision)
+		return MatchResult{m, m, false}
 	}
 	pattern := request.pattern
+	passMerger := PassMerger(&request.chunks, m.tac, request.revision, pattern.startIndex)
 	if pattern.IsEmpty() {
-		return PassMerger(&request.chunks, m.tac, request.revision), false
+		return MatchResult{passMerger, passMerger, false}
 	}
 
 	minIndex := request.chunks[0].items[0].Index()
+	maxIndex := request.chunks[numChunks-1].lastIndex(minIndex)
 	cancelled := util.NewAtomicBool(false)
 
-	slices := m.sliceChunks(request.chunks)
-	numSlices := len(slices)
-	resultChan := make(chan partialResult, numSlices)
+	numWorkers := min(m.partitions, numChunks)
+	var nextChunk atomic.Int32
+	resultChan := make(chan partialResult, numWorkers)
 	countChan := make(chan int, numChunks)
 	waitGroup := sync.WaitGroup{}
 
-	for idx, chunks := range slices {
+	for idx := range numWorkers {
 		waitGroup.Add(1)
 		if m.slab[idx] == nil {
 			m.slab[idx] = util.MakeSlab(slab16Size, slab32Size)
 		}
-		go func(idx int, slab *util.Slab, chunks []*Chunk) {
-			defer func() { waitGroup.Done() }()
-			count := 0
-			allMatches := make([][]Result, len(chunks))
-			for idx, chunk := range chunks {
-				matches := request.pattern.Match(chunk, slab)
-				allMatches[idx] = matches
-				count += len(matches)
+		go func(idx int, slab *util.Slab) {
+			defer waitGroup.Done()
+			var matches []Result
+			for {
+				ci := int(nextChunk.Add(1)) - 1
+				if ci >= numChunks {
+					break
+				}
+				chunkMatches := request.pattern.Match(request.chunks[ci], slab)
+				matches = append(matches, chunkMatches...)
 				if cancelled.Get() {
 					return
 				}
-				countChan <- len(matches)
-			}
-			sliceMatches := make([]Result, 0, count)
-			for _, matches := range allMatches {
-				sliceMatches = append(sliceMatches, matches...)
+				countChan <- len(chunkMatches)
 			}
 			if m.sort && request.pattern.sortable {
-				if m.tac {
-					sort.Sort(ByRelevanceTac(sliceMatches))
-				} else {
-					sort.Sort(ByRelevance(sliceMatches))
-				}
+				m.sortBuf[idx] = radixSortResults(matches, m.tac, m.sortBuf[idx])
 			}
-			resultChan <- partialResult{idx, sliceMatches}
-		}(idx, m.slab[idx], chunks)
+			resultChan <- partialResult{idx, matches}
+		}(idx, m.slab[idx])
 	}
 
 	wait := func() bool {
@@ -222,8 +221,8 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 			break
 		}
 
-		if m.reqBox.Peek(reqReset) {
-			return nil, wait()
+		if m.cancelScan.Get() || m.reqBox.Peek(reqReset) {
+			return MatchResult{nil, nil, wait()}
 		}
 
 		if time.Since(startedAt) > progressMinDuration {
@@ -231,12 +230,13 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 		}
 	}
 
-	partialResults := make([][]Result, numSlices)
-	for range slices {
+	partialResults := make([][]Result, numWorkers)
+	for range numWorkers {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}
-	return NewMerger(pattern, partialResults, m.sort && request.pattern.sortable, m.tac, request.revision, minIndex), false
+	merger := NewMerger(pattern, partialResults, m.sort && request.pattern.sortable, m.tac, request.revision, minIndex, maxIndex)
+	return MatchResult{merger, passMerger, false}
 }
 
 // Reset is called to interrupt/signal the ongoing search
@@ -252,6 +252,20 @@ func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final
 	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort, revision})
 }
 
+// CancelScan cancels any in-flight scan, waits for it to finish,
+// and prevents new scans from starting until ResumeScan is called.
+// This is used to safely mutate shared items (e.g., during with-nth changes).
+func (m *Matcher) CancelScan() {
+	m.cancelScan.Set(true)
+	m.scanMutex.Lock()
+	m.cancelScan.Set(false)
+}
+
+// ResumeScan allows scans to proceed again after CancelScan.
+func (m *Matcher) ResumeScan() {
+	m.scanMutex.Unlock()
+}
+
 func (m *Matcher) Stop() {
 	m.reqBox.Set(reqQuit, nil)
 }

src/merger.go

@@ -4,50 +4,57 @@ import "fmt"
 
 // EmptyMerger is a Merger with no data
 func EmptyMerger(revision revision) *Merger {
-	return NewMerger(nil, [][]Result{}, false, false, revision, 0)
+	return NewMerger(nil, [][]Result{}, false, false, revision, 0, 0)
 }
 
 // Merger holds a set of locally sorted lists of items and provides the view of
 // a single, globally-sorted list
 type Merger struct {
-	pattern  *Pattern
-	lists    [][]Result
-	merged   []Result
-	chunks   *[]*Chunk
-	cursors  []int
-	sorted   bool
-	tac      bool
-	final    bool
-	count    int
-	pass     bool
-	revision revision
-	minIndex int32
+	pattern    *Pattern
+	lists      [][]Result
+	merged     []Result
+	chunks     *[]*Chunk
+	cursors    []int
+	sorted     bool
+	tac        bool
+	final      bool
+	count      int
+	pass       bool
+	startIndex int
+	revision   revision
+	minIndex   int32
+	maxIndex   int32
 }
 
 // PassMerger returns a new Merger that simply returns the items in the
-// original order
-func PassMerger(chunks *[]*Chunk, tac bool, revision revision) *Merger {
-	var minIndex int32
+// original order. startIndex items are skipped from the beginning.
+func PassMerger(chunks *[]*Chunk, tac bool, revision revision, startIndex int32) *Merger {
+	var minIndex, maxIndex int32
 	if len(*chunks) > 0 {
 		minIndex = (*chunks)[0].items[0].Index()
+		maxIndex = (*chunks)[len(*chunks)-1].lastIndex(minIndex)
 	}
+	si := int(startIndex)
 	mg := Merger{
-		pattern:  nil,
-		chunks:   chunks,
-		tac:      tac,
-		count:    0,
-		pass:     true,
-		revision: revision,
-		minIndex: minIndex}
+		pattern:    nil,
+		chunks:     chunks,
+		tac:        tac,
+		count:      0,
+		pass:       true,
+		startIndex: si,
+		revision:   revision,
+		minIndex:   minIndex + startIndex,
+		maxIndex:   maxIndex}
 
 	for _, chunk := range *mg.chunks {
 		mg.count += chunk.count
 	}
+	mg.count = max(0, mg.count-si)
 	return &mg
 }
 
 // NewMerger returns a new Merger
-func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revision revision, minIndex int32) *Merger {
+func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revision revision, minIndex int32, maxIndex int32) *Merger {
 	mg := Merger{
 		pattern:  pattern,
 		lists:    lists,
@@ -59,7 +66,8 @@ func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revisi
 		final:    false,
 		count:    0,
 		revision: revision,
-		minIndex: minIndex}
+		minIndex: minIndex,
+		maxIndex: maxIndex}
 
 	for _, list := range mg.lists {
 		mg.count += len(list)
@@ -109,6 +117,7 @@ func (mg *Merger) Get(idx int) Result {
 		if mg.tac {
 			idx = mg.count - idx - 1
 		}
+		idx += mg.startIndex
 		firstChunk := (*mg.chunks)[0]
 		if firstChunk.count < chunkSize && idx >= firstChunk.count {
 			idx -= firstChunk.count
@@ -127,14 +136,16 @@ func (mg *Merger) Get(idx int) Result {
 	if mg.tac {
 		idx = mg.count - idx - 1
 	}
-	for _, list := range mg.lists {
-		numItems := len(list)
-		if idx < numItems {
-			return list[idx]
-		}
-		idx -= numItems
+	return mg.mergedGet(idx)
+}
+
+func (mg *Merger) ToMap() map[int32]Result {
+	ret := make(map[int32]Result, mg.count)
+	for i := 0; i < mg.count; i++ {
+		result := mg.Get(i)
+		ret[result.Index()] = result
 	}
-	panic(fmt.Sprintf("Index out of bounds (unsorted, %d/%d)", idx, mg.count))
+	return ret
 }
 
 func (mg *Merger) cacheable() bool {
@@ -153,7 +164,7 @@ func (mg *Merger) mergedGet(idx int) Result {
 			}
 			if cursor >= 0 {
 				rank := list[cursor]
-				if minIdx < 0 || compareRanks(rank, minRank, mg.tac) {
+				if minIdx < 0 || mg.sorted && compareRanks(rank, minRank, mg.tac) || !mg.sorted && rank.item.Index() < minRank.item.Index() {
 					minRank = rank
 					minIdx = listIdx
 				}

src/merger_test.go

@@ -34,11 +34,11 @@ func buildLists(partiallySorted bool) ([][]Result, []Result) {
 	numLists := 4
 	lists := make([][]Result, numLists)
 	cnt := 0
-	for i := 0; i < numLists; i++ {
+	for i := range numLists {
 		numResults := rand.Int() % 20
 		cnt += numResults
 		lists[i] = make([]Result, numResults)
-		for j := 0; j < numResults; j++ {
+		for j := range numResults {
 			item := randResult()
 			lists[i][j] = item
 		}
@@ -54,13 +54,28 @@ func buildLists(partiallySorted bool) ([][]Result, []Result) {
 }
 
 func TestMergerUnsorted(t *testing.T) {
-	lists, items := buildLists(false)
+	lists, _ := buildLists(false)
+
+	// Sort each list by index to simulate real worker behavior
+	// (workers process chunks in ascending order via nextChunk.Add(1))
+	for _, list := range lists {
+		sort.Slice(list, func(i, j int) bool {
+			return list[i].item.Index() < list[j].item.Index()
+		})
+	}
+	items := []Result{}
+	for _, list := range lists {
+		items = append(items, list...)
+	}
+	sort.Slice(items, func(i, j int) bool {
+		return items[i].item.Index() < items[j].item.Index()
+	})
 	cnt := len(items)
 
-	// Not sorted: same order
-	mg := NewMerger(nil, lists, false, false, revision{}, 0)
+	// Not sorted: items in ascending index order
+	mg := NewMerger(nil, lists, false, false, revision{}, 0, 0)
 	assert(t, cnt == mg.Length(), "Invalid Length")
-	for i := 0; i < cnt; i++ {
+	for i := range cnt {
 		assert(t, items[i] == mg.Get(i), "Invalid Get")
 	}
 }
@@ -70,17 +85,17 @@ func TestMergerSorted(t *testing.T) {
 	cnt := len(items)
 
 	// Sorted sorted order
-	mg := NewMerger(nil, lists, true, false, revision{}, 0)
+	mg := NewMerger(nil, lists, true, false, revision{}, 0, 0)
 	assert(t, cnt == mg.Length(), "Invalid Length")
 	sort.Sort(ByRelevance(items))
-	for i := 0; i < cnt; i++ {
+	for i := range cnt {
 		if items[i] != mg.Get(i) {
 			t.Error("Not sorted", items[i], mg.Get(i))
 		}
 	}
 
 	// Inverse order
-	mg2 := NewMerger(nil, lists, true, false, revision{}, 0)
+	mg2 := NewMerger(nil, lists, true, false, revision{}, 0, 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_test.go

@@ -142,7 +142,7 @@ func TestIrrelevantNth(t *testing.T) {
 }
 
 func TestParseKeys(t *testing.T) {
-	pairs, _ := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g,ctrl-alt-a,ALT-enter,alt-SPACE", "")
+	pairs, _, _ := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g,ctrl-alt-a,ALT-enter,alt-SPACE", "")
 	checkEvent := func(e tui.Event, s string) {
 		if pairs[e] != s {
 			t.Errorf("%s != %s", pairs[e], s)
@@ -168,11 +168,11 @@ func TestParseKeys(t *testing.T) {
 	checkEvent(tui.AltKey(' '), "alt-SPACE")
 
 	// Synonyms
-	pairs, _ = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
+	pairs, _, _ = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
 	if len(pairs) != 9 {
 		t.Error(9)
 	}
-	check(tui.CtrlM, "Return")
+	check(tui.Enter, "Return")
 	checkEvent(tui.Key(' '), "space")
 	check(tui.Tab, "tab")
 	check(tui.ShiftTab, "btab")
@@ -182,7 +182,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)
 	}
@@ -195,7 +195,7 @@ func TestParseKeys(t *testing.T) {
 	check(tui.ShiftLeft, "shift-left")
 	check(tui.ShiftRight, "shift-right")
 	check(tui.ShiftTab, "shift-tab")
-	check(tui.CtrlM, "Enter")
+	check(tui.Enter, "Enter")
 	check(tui.Backspace, "bspace")
 }
 
@@ -211,40 +211,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-,")
 }
@@ -300,8 +300,12 @@ func TestBind(t *testing.T) {
 }
 
 func TestColorSpec(t *testing.T) {
+	var base *tui.ColorTheme
 	theme := tui.Dark256
-	dark, _ := parseTheme(theme, "dark")
+	base, dark, _ := parseTheme(theme, "dark")
+	if *dark != *base {
+		t.Errorf("incorrect base theme returned")
+	}
 	if *dark != *theme {
 		t.Errorf("colors should be equivalent")
 	}
@@ -309,7 +313,10 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("point should not be equivalent")
 	}
 
-	light, _ := parseTheme(theme, "dark,light")
+	base, light, _ := parseTheme(theme, "dark,light")
+	if *light != *base {
+		t.Errorf("incorrect base theme returned")
+	}
 	if *light == *theme {
 		t.Errorf("should not be equivalent")
 	}
@@ -320,7 +327,7 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("point should not be equivalent")
 	}
 
-	customized, _ := parseTheme(theme, "fg:231,bg:232")
+	_, customized, _ := parseTheme(theme, "fg:231,bg:232")
 	if customized.Fg.Color != 231 || customized.Bg.Color != 232 {
 		t.Errorf("color not customized")
 	}
@@ -333,7 +340,7 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("colors should now be equivalent: %v, %v", tui.Dark256, customized)
 	}
 
-	customized, _ = parseTheme(theme, "fg:231,dark,bg:232")
+	_, customized, _ = parseTheme(theme, "fg:231,dark   bg:232")
 	if customized.Fg != tui.Dark256.Fg || customized.Bg == tui.Dark256.Bg {
 		t.Errorf("color not customized")
 	}
@@ -350,8 +357,8 @@ func TestDefaultCtrlNP(t *testing.T) {
 			t.Error()
 		}
 	}
-	check([]string{}, tui.CtrlN, actDown)
-	check([]string{}, tui.CtrlP, actUp)
+	check([]string{}, tui.CtrlN, actDownMatch)
+	check([]string{}, tui.CtrlP, actUpMatch)
 
 	check([]string{"--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
 	check([]string{"--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
@@ -441,6 +448,64 @@ func TestPreviewOpts(t *testing.T) {
 		opts.Preview.size.size == 70) {
 		t.Error(opts.Preview)
 	}
+
+	// wrap-word tests
+	opts = optsFor("--preview-window=wrap-word")
+	if !(opts.Preview.wrap == true && opts.Preview.wrapWord == true) {
+		t.Errorf("wrap-word: wrap=%v, wrapWord=%v", opts.Preview.wrap, opts.Preview.wrapWord)
+	}
+	opts = optsFor("--preview-window=wrap-word,nowrap")
+	if !(opts.Preview.wrap == false && opts.Preview.wrapWord == false) {
+		t.Errorf("wrap-word,nowrap: wrap=%v, wrapWord=%v", opts.Preview.wrap, opts.Preview.wrapWord)
+	}
+	opts = optsFor("--preview-window=wrap-word,wrap")
+	if !(opts.Preview.wrap == true && opts.Preview.wrapWord == false) {
+		t.Errorf("wrap-word,wrap: wrap=%v, wrapWord=%v", opts.Preview.wrap, opts.Preview.wrapWord)
+	}
+}
+
+func TestPreviewWrapSign(t *testing.T) {
+	// Default: no preview wrap sign override
+	opts := optsFor()
+	if opts.PreviewWrapSign != nil {
+		t.Errorf("expected nil PreviewWrapSign, got %v", *opts.PreviewWrapSign)
+	}
+
+	// --preview-wrap-sign sets PreviewWrapSign
+	opts = optsFor("--preview-wrap-sign", ">> ")
+	if opts.PreviewWrapSign == nil || *opts.PreviewWrapSign != ">> " {
+		t.Errorf("expected '>> ', got %v", opts.PreviewWrapSign)
+	}
+
+	// --preview-wrap-sign is independent of --wrap-sign
+	opts = optsFor("--wrap-sign", "| ", "--preview-wrap-sign", ">> ")
+	if opts.WrapSign == nil || *opts.WrapSign != "| " {
+		t.Errorf("expected WrapSign '| ', got %v", opts.WrapSign)
+	}
+	if opts.PreviewWrapSign == nil || *opts.PreviewWrapSign != ">> " {
+		t.Errorf("expected PreviewWrapSign '>> ', got %v", opts.PreviewWrapSign)
+	}
+
+	// --preview-wrap-sign without --wrap-sign
+	opts = optsFor("--preview-wrap-sign", "→ ")
+	if opts.WrapSign != nil {
+		t.Errorf("expected nil WrapSign, got %v", *opts.WrapSign)
+	}
+	if opts.PreviewWrapSign == nil || *opts.PreviewWrapSign != "→ " {
+		t.Errorf("expected PreviewWrapSign '→ ', got %v", opts.PreviewWrapSign)
+	}
+
+	// Last --preview-wrap-sign wins
+	opts = optsFor("--preview-wrap-sign", "A ", "--preview-wrap-sign", "B ")
+	if opts.PreviewWrapSign == nil || *opts.PreviewWrapSign != "B " {
+		t.Errorf("expected PreviewWrapSign 'B ', got %v", opts.PreviewWrapSign)
+	}
+
+	// Empty string is allowed
+	opts = optsFor("--preview-wrap-sign", "")
+	if opts.PreviewWrapSign == nil || *opts.PreviewWrapSign != "" {
+		t.Errorf("expected empty PreviewWrapSign, got %v", opts.PreviewWrapSign)
+	}
 }
 
 func TestAdditiveExpect(t *testing.T) {
@@ -462,7 +527,7 @@ func TestValidateSign(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		err := validateSign(testCase.inputSign, "")
+		err := validateSign(testCase.inputSign, "", 2)
 		if testCase.isValid && err != nil {
 			t.Errorf("Input sign `%s` caused error", testCase.inputSign)
 		}

src/pattern.go

@@ -60,9 +60,13 @@ type Pattern struct {
 	cacheKey      string
 	delimiter     Delimiter
 	nth           []Range
-	revision      int
-	procFun       map[termType]algo.Algo
+	revision      revision
+	procFun       [6]algo.Algo
 	cache         *ChunkCache
+	denylist      map[int32]struct{}
+	startIndex    int32
+	directAlgo    algo.Algo
+	directTerm    *term
 }
 
 var _splitRegex *regexp.Regexp
@@ -73,7 +77,7 @@ func init() {
 
 // BuildPattern builds Pattern object from the given arguments
 func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
-	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, revision int, runes []rune) *Pattern {
+	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, revision revision, runes []rune, denylist map[int32]struct{}, startIndex int32) *Pattern {
 
 	var asString string
 	if extended {
@@ -144,9 +148,12 @@ func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy boo
 		revision:      revision,
 		delimiter:     delimiter,
 		cache:         cache,
-		procFun:       make(map[termType]algo.Algo)}
+		denylist:      denylist,
+		startIndex:    startIndex,
+	}
 
 	ptr.cacheKey = ptr.buildCacheKey()
+	ptr.directAlgo, ptr.directTerm = ptr.buildDirectAlgo(fuzzyAlgo)
 	ptr.procFun[termFuzzy] = fuzzyAlgo
 	ptr.procFun[termEqual] = algo.EqualMatch
 	ptr.procFun[termExact] = algo.ExactMatchNaive
@@ -243,6 +250,9 @@ func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet
 
 // IsEmpty returns true if the pattern is effectively empty
 func (p *Pattern) IsEmpty() bool {
+	if len(p.denylist) > 0 {
+		return false
+	}
 	if !p.extended {
 		return len(p.text) == 0
 	}
@@ -267,6 +277,22 @@ func (p *Pattern) buildCacheKey() string {
 	return strings.Join(cacheableTerms, "\t")
 }
 
+// buildDirectAlgo returns the algo function and term for the direct fast path
+// in matchChunk. Returns (nil, nil) if the pattern is not suitable.
+// Requirements: extended mode, single term set with single non-inverse fuzzy term, no nth.
+func (p *Pattern) buildDirectAlgo(fuzzyAlgo algo.Algo) (algo.Algo, *term) {
+	if !p.extended || len(p.nth) > 0 {
+		return nil, nil
+	}
+	if len(p.termSets) == 1 && len(p.termSets[0]) == 1 {
+		t := &p.termSets[0][0]
+		if !t.inv && t.typ == termFuzzy {
+			return fuzzyAlgo, t
+		}
+	}
+	return nil, nil
+}
+
 // CacheKey is used to build string to be used as the key of result cache
 func (p *Pattern) CacheKey() string {
 	return p.cacheKey
@@ -274,60 +300,104 @@ func (p *Pattern) CacheKey() string {
 
 // Match returns the list of matches Items in the given Chunk
 func (p *Pattern) Match(chunk *Chunk, slab *util.Slab) []Result {
-	// ChunkCache: Exact match
 	cacheKey := p.CacheKey()
+
+	// Bitmap cache: exact match or prefix/suffix
+	var cachedBitmap *ChunkBitmap
 	if p.cacheable {
-		if cached := p.cache.Lookup(chunk, cacheKey); cached != nil {
-			return cached
-		}
+		cachedBitmap = p.cache.Lookup(chunk, cacheKey)
+	}
+	if cachedBitmap == nil {
+		cachedBitmap = p.cache.Search(chunk, cacheKey)
 	}
 
-	// Prefix/suffix cache
-	space := p.cache.Search(chunk, cacheKey)
-
-	matches := p.matchChunk(chunk, space, slab)
+	matches, bitmap := p.matchChunk(chunk, cachedBitmap, slab)
 
 	if p.cacheable {
-		p.cache.Add(chunk, cacheKey, matches)
+		p.cache.Add(chunk, cacheKey, bitmap, len(matches))
 	}
 	return matches
 }
 
-func (p *Pattern) matchChunk(chunk *Chunk, space []Result, slab *util.Slab) []Result {
+func (p *Pattern) matchChunk(chunk *Chunk, cachedBitmap *ChunkBitmap, slab *util.Slab) ([]Result, ChunkBitmap) {
 	matches := []Result{}
+	var bitmap ChunkBitmap
 
-	if space == nil {
-		for idx := 0; idx < chunk.count; idx++ {
-			if match, _, _ := p.MatchItem(&chunk.items[idx], p.withPos, slab); match != nil {
-				matches = append(matches, *match)
-			}
-		}
-	} else {
-		for _, result := range space {
-			if match, _, _ := p.MatchItem(result.item, p.withPos, slab); match != nil {
-				matches = append(matches, *match)
-			}
+	// Skip header items in chunks that contain them
+	startIdx := 0
+	if p.startIndex > 0 && chunk.count > 0 && chunk.items[0].Index() < p.startIndex {
+		startIdx = int(p.startIndex - chunk.items[0].Index())
+		if startIdx >= chunk.count {
+			return matches, bitmap
 		}
 	}
-	return matches
+
+	hasCachedBitmap := cachedBitmap != nil
+
+	// Fast path: single fuzzy term, no nth, no denylist.
+	// Calls the algo function directly, bypassing MatchItem/extendedMatch/iter
+	// and avoiding per-match []Offset heap allocation.
+	if p.directAlgo != nil && len(p.denylist) == 0 {
+		t := p.directTerm
+		for idx := startIdx; idx < chunk.count; idx++ {
+			if hasCachedBitmap && cachedBitmap[idx/64]&(uint64(1)<<(idx%64)) == 0 {
+				continue
+			}
+			res, _ := p.directAlgo(t.caseSensitive, t.normalize, p.forward,
+				&chunk.items[idx].text, t.text, p.withPos, slab)
+			if res.Start >= 0 {
+				bitmap[idx/64] |= uint64(1) << (idx % 64)
+				matches = append(matches, buildResultFromBounds(
+					&chunk.items[idx], res.Score,
+					int(res.Start), int(res.End), int(res.End), true))
+			}
+		}
+		return matches, bitmap
+	}
+
+	if len(p.denylist) == 0 {
+		for idx := startIdx; idx < chunk.count; idx++ {
+			if hasCachedBitmap && cachedBitmap[idx/64]&(uint64(1)<<(idx%64)) == 0 {
+				continue
+			}
+			if match, _, _ := p.MatchItem(&chunk.items[idx], p.withPos, slab); match.item != nil {
+				bitmap[idx/64] |= uint64(1) << (idx % 64)
+				matches = append(matches, match)
+			}
+		}
+		return matches, bitmap
+	}
+
+	for idx := startIdx; idx < chunk.count; idx++ {
+		if hasCachedBitmap && cachedBitmap[idx/64]&(uint64(1)<<(idx%64)) == 0 {
+			continue
+		}
+		if _, prs := p.denylist[chunk.items[idx].Index()]; prs {
+			continue
+		}
+		if match, _, _ := p.MatchItem(&chunk.items[idx], p.withPos, slab); match.item != nil {
+			bitmap[idx/64] |= uint64(1) << (idx % 64)
+			matches = append(matches, match)
+		}
+	}
+	return matches, bitmap
 }
 
-// MatchItem returns true if the Item is a match
-func (p *Pattern) MatchItem(item *Item, withPos bool, slab *util.Slab) (*Result, []Offset, *[]int) {
+// MatchItem returns the match result if the Item is a match.
+// A zero-value Result (with item == nil) indicates no match.
+func (p *Pattern) MatchItem(item *Item, withPos bool, slab *util.Slab) (Result, []Offset, *[]int) {
 	if p.extended {
 		if offsets, bonus, pos := p.extendedMatch(item, withPos, slab); len(offsets) == len(p.termSets) {
-			result := buildResult(item, offsets, bonus)
-			return &result, offsets, pos
+			return buildResult(item, offsets, bonus), offsets, pos
 		}
-		return nil, nil, nil
+		return Result{}, nil, nil
 	}
 	offset, bonus, pos := p.basicMatch(item, withPos, slab)
 	if sidx := offset[0]; sidx >= 0 {
 		offsets := []Offset{offset}
-		result := buildResult(item, offsets, bonus)
-		return &result, offsets, pos
+		return buildResult(item, offsets, bonus), offsets, pos
 	}
-	return nil, nil, nil
+	return Result{}, nil, nil
 }
 
 func (p *Pattern) basicMatch(item *Item, withPos bool, slab *util.Slab) (Offset, int, *[]int) {
@@ -403,6 +473,13 @@ func (p *Pattern) transformInput(item *Item) []Token {
 
 	tokens := Tokenize(item.text.ToString(), p.delimiter)
 	ret := Transform(tokens, p.nth)
+	// Strip the last delimiter to allow suffix match
+	if len(ret) > 0 && !p.delimiter.IsAwk() {
+		chars := ret[len(ret)-1].text
+		stripped := StripLastDelimiter(chars.ToString(), p.delimiter)
+		newChars := util.ToChars(stringBytes(stripped))
+		ret[len(ret)-1].text = &newChars
+	}
 	item.transformed = &transformed{p.revision, ret}
 	return ret
 }

src/pattern_test.go

@@ -2,6 +2,7 @@ package fzf
 
 import (
 	"reflect"
+	"runtime"
 	"testing"
 
 	"github.com/junegunn/fzf/src/algo"
@@ -68,7 +69,7 @@ func buildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case,
 	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, 0, runes)
+		withPos, cacheable, nth, delimiter, revision{}, runes, nil, 0)
 }
 
 func TestExact(t *testing.T) {
@@ -137,7 +138,7 @@ func TestOrigTextAndTransformed(t *testing.T) {
 			origText:    &origBytes,
 			transformed: &transformed{pattern.revision, trans}}
 		pattern.extended = extended
-		matches := pattern.matchChunk(&chunk, nil, slab) // No cache
+		matches, _ := pattern.matchChunk(&chunk, nil, slab) // No cache
 		if !(matches[0].item.text.ToString() == "junegunn" &&
 			string(*matches[0].item.origText) == "junegunn.choi" &&
 			reflect.DeepEqual((*matches[0].item.transformed).tokens, trans)) {
@@ -199,3 +200,119 @@ func TestCacheable(t *testing.T) {
 	test(false, "foo 'bar", "foo", false)
 	test(false, "foo !bar", "foo", false)
 }
+
+func buildChunks(numChunks int) []*Chunk {
+	chunks := make([]*Chunk, numChunks)
+	words := []string{
+		"src/main/java/com/example/service/UserService.java",
+		"src/test/java/com/example/service/UserServiceTest.java",
+		"docs/api/reference/endpoints.md",
+		"lib/internal/utils/string_helper.go",
+		"pkg/server/http/handler/auth.go",
+		"build/output/release/app.exe",
+		"config/production/database.yml",
+		"scripts/deploy/kubernetes/setup.sh",
+		"vendor/github.com/junegunn/fzf/src/core.go",
+		"node_modules/.cache/babel/transform.js",
+	}
+	for ci := range numChunks {
+		chunks[ci] = &Chunk{count: chunkSize}
+		for i := range chunkSize {
+			text := words[(ci*chunkSize+i)%len(words)]
+			chunks[ci].items[i] = Item{text: util.ToChars([]byte(text))}
+			chunks[ci].items[i].text.Index = int32(ci*chunkSize + i)
+		}
+	}
+	return chunks
+}
+
+func buildPatternWith(cache *ChunkCache, runes []rune) *Pattern {
+	return BuildPattern(cache, make(map[string]*Pattern),
+		true, algo.FuzzyMatchV2, true, CaseSmart, false, true,
+		false, true, []Range{}, Delimiter{}, revision{}, runes, nil, 0)
+}
+
+func TestBitmapCacheBenefit(t *testing.T) {
+	numChunks := 100
+	chunks := buildChunks(numChunks)
+	queries := []string{"s", "se", "ser", "serv", "servi"}
+
+	// 1. Run all queries with shared cache (simulates incremental typing)
+	cache := NewChunkCache()
+	for _, q := range queries {
+		pat := buildPatternWith(cache, []rune(q))
+		for _, chunk := range chunks {
+			pat.Match(chunk, slab)
+		}
+	}
+
+	// 2. GC and measure memory with cache populated
+	runtime.GC()
+	runtime.GC()
+	var memWith runtime.MemStats
+	runtime.ReadMemStats(&memWith)
+
+	// 3. Clear cache, GC, measure again
+	cache.Clear()
+	runtime.GC()
+	runtime.GC()
+	var memWithout runtime.MemStats
+	runtime.ReadMemStats(&memWithout)
+
+	cacheMem := int64(memWith.Alloc) - int64(memWithout.Alloc)
+	t.Logf("Chunks: %d, Queries: %d", numChunks, len(queries))
+	t.Logf("Cache memory: %d bytes (%.1f KB)", cacheMem, float64(cacheMem)/1024)
+	t.Logf("Per-chunk-per-query: %.0f bytes", float64(cacheMem)/float64(numChunks*len(queries)))
+
+	// 4. Verify correctness: cached vs uncached produce same results
+	cache2 := NewChunkCache()
+	for _, q := range queries {
+		pat := buildPatternWith(cache2, []rune(q))
+		for _, chunk := range chunks {
+			pat.Match(chunk, slab)
+		}
+	}
+	for _, q := range queries {
+		patCached := buildPatternWith(cache2, []rune(q))
+		patFresh := buildPatternWith(NewChunkCache(), []rune(q))
+		var countCached, countFresh int
+		for _, chunk := range chunks {
+			countCached += len(patCached.Match(chunk, slab))
+			countFresh += len(patFresh.Match(chunk, slab))
+		}
+		if countCached != countFresh {
+			t.Errorf("query=%q: cached=%d, fresh=%d", q, countCached, countFresh)
+		}
+		t.Logf("query=%q: matches=%d", q, countCached)
+	}
+}
+
+func BenchmarkWithCache(b *testing.B) {
+	numChunks := 100
+	chunks := buildChunks(numChunks)
+	queries := []string{"s", "se", "ser", "serv", "servi"}
+
+	b.Run("cached", func(b *testing.B) {
+		for range b.N {
+			cache := NewChunkCache()
+			for _, q := range queries {
+				pat := buildPatternWith(cache, []rune(q))
+				for _, chunk := range chunks {
+					pat.Match(chunk, slab)
+				}
+			}
+		}
+	})
+
+	b.Run("uncached", func(b *testing.B) {
+		for range b.N {
+			for _, q := range queries {
+				cache := NewChunkCache()
+				pat := buildPatternWith(cache, []rune(q))
+				for _, chunk := range chunks {
+					pat.Match(chunk, slab)
+				}
+			}
+		}
+	})
+}

src/protector/protector_openbsd.go

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

src/proxy.go

@@ -23,6 +23,32 @@ func escapeSingleQuote(str string) string {
 	return "'" + strings.ReplaceAll(str, "'", "'\\''") + "'"
 }
 
+func popupArgStr(args []string, opts *Options) (string, string) {
+	fzf, rest := args[0], args[1:]
+	args = []string{"--bind=ctrl-z:ignore"}
+	if !opts.Tmux.border && (opts.BorderShape == tui.BorderUndefined || opts.BorderShape == tui.BorderLine) {
+		if tui.DefaultBorderShape == tui.BorderRounded {
+			rest = append(rest, "--border=rounded")
+		} else {
+			rest = append(rest, "--border=sharp")
+		}
+	}
+	if opts.Tmux.border && opts.Margin == defaultMargin() {
+		args = append(args, "--margin=0,1")
+	}
+	argStr := escapeSingleQuote(fzf)
+	for _, arg := range append(args, rest...) {
+		argStr += " " + escapeSingleQuote(arg)
+	}
+	argStr += ` --no-popup --no-height`
+
+	dir, err := os.Getwd()
+	if err != nil {
+		dir = "."
+	}
+	return argStr, dir
+}
+
 func fifo(name string) (string, error) {
 	ns := time.Now().UnixNano()
 	output := filepath.Join(os.TempDir(), fmt.Sprintf("fzf-%s-%d", name, ns))
@@ -59,12 +85,12 @@ func runProxy(commandPrefix string, cmdBuilder func(temp string, needBash bool)
 		})
 	}()
 
-	var command string
+	var command, input string
 	commandPrefix += ` --no-force-tty-in --proxy-script "$0"`
 	if opts.Input == nil && (opts.ForceTtyIn || util.IsTty(os.Stdin)) {
 		command = fmt.Sprintf(`%s > %q`, commandPrefix, output)
 	} else {
-		input, err := fifo("proxy-input")
+		input, err = fifo("proxy-input")
 		if err != nil {
 			return ExitError, err
 		}
@@ -90,11 +116,12 @@ func runProxy(commandPrefix string, cmdBuilder func(temp string, needBash bool)
 		}
 	}
 
-	// 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.
+	// Write the command to a temporary file and run it with sh to ensure POSIX compliance.
 	var exports []string
 	needBash := false
 	if withExports {
+		// Nullify FZF_DEFAULT_* variables as tmux popup may inject them even when undefined.
+		exports = []string{"FZF_DEFAULT_COMMAND=", "FZF_DEFAULT_OPTS=", "FZF_DEFAULT_OPTS_FILE="}
 		validIdentifier := regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`)
 		for _, pairStr := range os.Environ() {
 			pair := strings.SplitN(pairStr, "=", 2)
@@ -144,10 +171,13 @@ func runProxy(commandPrefix string, cmdBuilder func(temp string, needBash bool)
 					env = elems[1:]
 				}
 				executor := util.NewExecutor(opts.WithShell)
-				ttyin, err := tui.TtyIn()
+				ttyin, err := tui.TtyIn(opts.TtyDefault)
 				if err != nil {
 					return ExitError, err
 				}
+				os.Remove(temp)
+				os.Remove(input)
+				os.Remove(output)
 				executor.Become(ttyin, env, command)
 			}
 			return code, err

src/reader.go

@@ -7,6 +7,7 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -177,8 +178,8 @@ func (r *Reader) feed(src io.Reader) {
 	var err error
 	for {
 		n := 0
-		scope := slab[:util.Min(len(slab), readerBufferSize)]
-		for i := 0; i < 100; i++ {
+		scope := slab[:min(len(slab), readerBufferSize)]
+		for range 100 {
 			n, err = src.Read(scope)
 			if n > 0 || err != nil {
 				break
@@ -273,16 +274,37 @@ func (r *Reader) readFiles(roots []string, opts walkerOpts, ignores []string) bo
 		ToSlash: fastwalk.DefaultToSlash(),
 		Sort:    fastwalk.SortFilesFirst,
 	}
+
+	// When following symlinks, precompute the absolute real paths of walker
+	// roots so we can skip symlinks that point to an ancestor. fastwalk's
+	// built-in loop detection (shouldTraverse) catches loops on the second
+	// pass, but a single pass through a symlink like z: -> / already
+	// traverses the entire root filesystem, causing severe resource
+	// exhaustion. Skipping ancestor symlinks prevents this entirely.
+	var absRoots []string
+	if opts.follow {
+		for _, root := range roots {
+			if real, err := filepath.EvalSymlinks(root); err == nil {
+				if abs, err := filepath.Abs(real); err == nil {
+					absRoots = append(absRoots, filepath.Clean(abs))
+				}
+			}
+		}
+	}
+
 	ignoresBase := []string{}
 	ignoresFull := []string{}
 	ignoresSuffix := []string{}
 	sep := string(os.PathSeparator)
+	if _, ok := os.LookupEnv("MSYSTEM"); ok {
+		sep = "/"
+	}
 	for _, ignore := range ignores {
 		if strings.ContainsRune(ignore, os.PathSeparator) {
 			if strings.HasPrefix(ignore, sep) {
 				ignoresSuffix = append(ignoresSuffix, ignore)
 			} else {
-				// 'foo/bar' should match match
+				// 'foo/bar' should match
 				// * 'foo/bar'
 				// * 'baz/foo/bar'
 				// * but NOT 'bazfoo/bar'
@@ -299,27 +321,48 @@ func (r *Reader) readFiles(roots []string, opts walkerOpts, ignores []string) bo
 		}
 		path = trimPath(path)
 		if path != "." {
-			isDir := de.IsDir()
-			if isDir || opts.follow && isSymlinkToDir(path, de) {
+			isDirSymlink := isSymlinkToDir(path, de)
+			if isDirSymlink && !opts.follow {
+				return filepath.SkipDir
+			}
+			// Skip symlinks whose target is an ancestor of (or equal to)
+			// any walker root. Following such symlinks would traverse a
+			// superset of the tree we're already walking.
+			if isDirSymlink && len(absRoots) > 0 {
+				if target, err := filepath.EvalSymlinks(path); err == nil {
+					if abs, err := filepath.Abs(target); err == nil {
+						abs = filepath.Clean(abs)
+						if abs == string(os.PathSeparator) {
+							return filepath.SkipDir
+						}
+						for _, absRoot := range absRoots {
+							if absRoot == abs || strings.HasPrefix(absRoot, abs+string(os.PathSeparator)) {
+								return filepath.SkipDir
+							}
+						}
+					}
+				}
+			}
+			isDir := de.IsDir() || isDirSymlink
+			if isDir {
 				base := filepath.Base(path)
 				if !opts.hidden && base[0] == '.' && base != ".." {
 					return filepath.SkipDir
 				}
-				for _, ignore := range ignoresBase {
-					if ignore == base {
-						return filepath.SkipDir
-					}
+				if slices.Contains(ignoresBase, base) {
+					return filepath.SkipDir
 				}
-				for _, ignore := range ignoresFull {
-					if ignore == path {
-						return filepath.SkipDir
-					}
+				if slices.Contains(ignoresFull, path) {
+					return filepath.SkipDir
 				}
 				for _, ignore := range ignoresSuffix {
 					if strings.HasSuffix(path, ignore) {
 						return filepath.SkipDir
 					}
 				}
+				if path != sep {
+					path += sep
+				}
 			}
 			if ((opts.file && !isDir) || (opts.dir && isDir)) && r.pusher(stringBytes(path)) {
 				atomic.StoreInt32(&r.event, int32(EvtReadNew))

src/result.go

@@ -2,6 +2,7 @@ package fzf
 
 import (
 	"math"
+	"slices"
 	"sort"
 	"unicode"
 
@@ -19,6 +20,10 @@ type colorOffset struct {
 	url    *url
 }
 
+func (co colorOffset) IsFullBgMarker(at int32) bool {
+	return at == co.offset[0] && at == co.offset[1] && co.color.Attr()&tui.FullBg > 0
+}
+
 type Result struct {
 	item   *Item
 	points [4]uint16
@@ -26,11 +31,9 @@ type Result struct {
 
 func buildResult(item *Item, offsets []Offset, score int) Result {
 	if len(offsets) > 1 {
-		sort.Sort(ByOrder(offsets))
+		slices.SortFunc(offsets, compareOffsets)
 	}
 
-	result := Result{item: item}
-	numChars := item.text.Length()
 	minBegin := math.MaxUint16
 	minEnd := math.MaxUint16
 	maxEnd := 0
@@ -38,13 +41,21 @@ func buildResult(item *Item, offsets []Offset, score int) Result {
 	for _, offset := range offsets {
 		b, e := int(offset[0]), int(offset[1])
 		if b < e {
-			minBegin = util.Min(b, minBegin)
-			minEnd = util.Min(e, minEnd)
-			maxEnd = util.Max(e, maxEnd)
+			minBegin = min(b, minBegin)
+			minEnd = min(e, minEnd)
+			maxEnd = max(e, maxEnd)
 			validOffsetFound = true
 		}
 	}
 
+	return buildResultFromBounds(item, score, minBegin, minEnd, maxEnd, validOffsetFound)
+}
+
+// buildResultFromBounds builds a Result from pre-computed offset bounds.
+func buildResultFromBounds(item *Item, score int, minBegin, minEnd, maxEnd int, validOffsetFound bool) Result {
+	result := Result{item: item}
+	numChars := item.text.Length()
+
 	for idx, criterion := range sortCriteria {
 		val := uint16(math.MaxUint16)
 		switch criterion {
@@ -69,10 +80,24 @@ func buildResult(item *Item, offsets []Offset, score int) Result {
 			}
 		case byLength:
 			val = item.TrimLength()
+		case byPathname:
+			if validOffsetFound {
+				lastDelim := -1
+				s := item.text.ToString()
+				for i := len(s) - 1; i >= 0; i-- {
+					if s[i] == '/' || s[i] == '\\' {
+						lastDelim = i
+						break
+					}
+				}
+				if lastDelim <= minBegin {
+					val = util.AsUint16(minBegin - lastDelim)
+				}
+			}
 		case byBegin, byEnd:
 			if validOffsetFound {
 				whitePrefixLen := 0
-				for idx := 0; idx < numChars; idx++ {
+				for idx := range numChars {
 					r := item.text.Get(idx)
 					whitePrefixLen = idx
 					if idx == minBegin || !unicode.IsSpace(r) {
@@ -104,14 +129,14 @@ func minRank() Result {
 	return Result{item: &minItem, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
 }
 
-func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, theme *tui.ColorTheme, colBase tui.ColorPair, colMatch tui.ColorPair, attrNth tui.Attr, current bool) []colorOffset {
+func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, theme *tui.ColorTheme, colBase tui.ColorPair, colMatch tui.ColorPair, attrNth tui.Attr, nthOverlay tui.Attr, hidden bool) []colorOffset {
 	itemColors := result.item.Colors()
 
 	// No ANSI codes
 	if len(itemColors) == 0 && len(nthOffsets) == 0 {
-		var offsets []colorOffset
-		for _, off := range matchOffsets {
-			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: colMatch, match: true})
+		offsets := make([]colorOffset, len(matchOffsets))
+		for i, off := range matchOffsets {
+			offsets[i] = colorOffset{offset: [2]int32{off[0], off[1]}, color: colMatch, match: true}
 		}
 		return offsets
 	}
@@ -134,12 +159,20 @@ func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, t
 		color bool
 		match bool
 		nth   bool
+		fbg   tui.Color
 	}
 
-	cols := make([]cellInfo, maxCol)
+	cols := make([]cellInfo, maxCol+1)
+	for idx := range cols {
+		cols[idx].fbg = -1
+	}
 	for colorIndex, ansi := range itemColors {
-		for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
-			cols[i] = cellInfo{colorIndex, true, false, false}
+		if ansi.offset[0] == ansi.offset[1] && ansi.color.attr&tui.FullBg > 0 {
+			cols[ansi.offset[0]].fbg = ansi.color.lbg
+		} else {
+			for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
+				cols[i] = cellInfo{colorIndex, true, false, false, cols[i].fbg}
+			}
 		}
 	}
 
@@ -155,45 +188,55 @@ func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, t
 		}
 	}
 
-	// sort.Sort(ByOrder(offsets))
+	// slices.SortFunc(offsets, compareOffsets)
 
 	// Merge offsets
 	// ------------  ----  --  ----
 	//   ++++++++      ++++++++++
 	// --++++++++--  --++++++++++---
-	var curr cellInfo = cellInfo{0, false, false, false}
+	curr := cellInfo{0, false, false, false, -1}
 	start := 0
 	ansiToColorPair := func(ansi ansiOffset, base tui.ColorPair) tui.ColorPair {
+		if !theme.Colored {
+			return tui.NewColorPair(-1, -1, ansi.color.attr).MergeAttr(base)
+		}
+		// fd --color always | fzf --ansi --delimiter / --nth -1 --color fg:dim:strip,nth:regular
+		if base.ShouldStripColors() {
+			return base
+		}
 		fg := ansi.color.fg
 		bg := ansi.color.bg
 		if fg == -1 {
-			if current {
-				fg = theme.Current.Color
-			} else {
-				fg = theme.Fg.Color
-			}
+			fg = colBase.Fg()
 		}
 		if bg == -1 {
-			if current {
-				bg = theme.DarkBg.Color
-			} else {
-				bg = theme.Bg.Color
-			}
+			bg = colBase.Bg()
 		}
-		return tui.NewColorPair(fg, bg, ansi.color.attr).MergeAttr(base)
+		return tui.NewColorPair(fg, bg, ansi.color.attr).WithUl(ansi.color.ul).MergeAttr(base)
 	}
+	fgAttr := tui.ColNormal.Attr()
+	nthAttrFinal := fgAttr.Merge(attrNth).Merge(nthOverlay)
+	nthBase := colBase.WithNewAttr(nthAttrFinal)
+
 	var colors []colorOffset
 	add := func(idx int) {
+		if curr.fbg >= 0 {
+			colors = append(colors, colorOffset{
+				offset: [2]int32{int32(start), int32(start)},
+				color:  tui.NewColorPair(-1, curr.fbg, tui.FullBg),
+				match:  false,
+				url:    nil})
+		}
 		if (curr.color || curr.nth || curr.match) && idx > start {
 			if curr.match {
 				var color tui.ColorPair
 				if curr.nth {
-					color = colBase.WithAttr(attrNth).Merge(colMatch)
+					color = nthBase.Merge(colMatch)
 				} else {
 					color = colBase.Merge(colMatch)
 				}
 				var url *url
-				if curr.color && theme.Colored {
+				if curr.color {
 					ansi := itemColors[curr.index]
 					url = ansi.color.url
 					origColor := ansiToColorPair(ansi, colMatch)
@@ -208,7 +251,7 @@ func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, t
 					if color.Fg().IsDefault() && origColor.HasBg() {
 						color = origColor
 						if curr.nth {
-							color = color.WithAttr(attrNth)
+							color = color.WithAttr((attrNth &^ tui.AttrRegular).Merge(nthOverlay))
 						}
 					} else {
 						color = origColor.MergeNonDefault(color)
@@ -218,19 +261,27 @@ func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, t
 					offset: [2]int32{int32(start), int32(idx)}, color: color, match: true, url: url})
 			} else if curr.color {
 				ansi := itemColors[curr.index]
-				color := ansiToColorPair(ansi, colBase)
+				base := colBase
 				if curr.nth {
-					color = color.WithAttr(attrNth)
+					base = nthBase
 				}
+				if hidden {
+					base = base.WithFg(theme.Nomatch)
+				}
+				color := ansiToColorPair(ansi, base)
 				colors = append(colors, colorOffset{
 					offset: [2]int32{int32(start), int32(idx)},
 					color:  color,
 					match:  false,
 					url:    ansi.color.url})
 			} else {
+				color := nthBase
+				if hidden {
+					color = color.WithFg(theme.Nomatch)
+				}
 				colors = append(colors, colorOffset{
 					offset: [2]int32{int32(start), int32(idx)},
-					color:  colBase.WithAttr(attrNth),
+					color:  color,
 					match:  false,
 					url:    nil})
 			}
@@ -247,21 +298,20 @@ func (result *Result) colorOffsets(matchOffsets []Offset, nthOffsets []Offset, t
 	return colors
 }
 
-// ByOrder is for sorting substring offsets
-type ByOrder []Offset
-
-func (a ByOrder) Len() int {
-	return len(a)
-}
-
-func (a ByOrder) Swap(i, j int) {
-	a[i], a[j] = a[j], a[i]
-}
-
-func (a ByOrder) Less(i, j int) bool {
-	ioff := a[i]
-	joff := a[j]
-	return (ioff[0] < joff[0]) || (ioff[0] == joff[0]) && (ioff[1] <= joff[1])
+func compareOffsets(a, b Offset) int {
+	if a[0] < b[0] {
+		return -1
+	}
+	if a[0] > b[0] {
+		return 1
+	}
+	if a[1] < b[1] {
+		return -1
+	}
+	if a[1] > b[1] {
+		return 1
+	}
+	return 0
 }
 
 // ByRelevance is for sorting Items
@@ -293,3 +343,79 @@ func (a ByRelevanceTac) Swap(i, j int) {
 func (a ByRelevanceTac) Less(i, j int) bool {
 	return compareRanks(a[i], a[j], true)
 }
+
+// radixSortResults sorts Results by their points key using LSD radix sort.
+// O(n) time complexity vs O(n log n) for comparison sort.
+// The sort is stable, so equal-key items maintain original (item-index) order.
+// For tac mode, runs of equal keys are reversed after sorting.
+func radixSortResults(a []Result, tac bool, scratch []Result) []Result {
+	n := len(a)
+	if n < 128 {
+		if tac {
+			sort.Sort(ByRelevanceTac(a))
+		} else {
+			sort.Sort(ByRelevance(a))
+		}
+		return scratch[:0]
+	}
+
+	if cap(scratch) < n {
+		scratch = make([]Result, n)
+	}
+	buf := scratch[:n]
+	src, dst := a, buf
+	scattered := 0
+
+	for pass := range 8 {
+		shift := uint(pass) * 8
+
+		var count [256]int
+		for i := range src {
+			count[byte(sortKey(&src[i])>>shift)]++
+		}
+
+		// Skip if all items have the same byte value at this position
+		if count[byte(sortKey(&src[0])>>shift)] == n {
+			continue
+		}
+
+		var offset [256]int
+		for i := 1; i < 256; i++ {
+			offset[i] = offset[i-1] + count[i-1]
+		}
+
+		for i := range src {
+			b := byte(sortKey(&src[i]) >> shift)
+			dst[offset[b]] = src[i]
+			offset[b]++
+		}
+
+		src, dst = dst, src
+		scattered++
+	}
+
+	// If odd number of scatters, data is in buf, copy back to a
+	if scattered%2 == 1 {
+		copy(a, src)
+	}
+
+	// Handle tac: reverse runs of equal keys so equal-key items
+	// are in reverse item-index order
+	if tac {
+		i := 0
+		for i < n {
+			ki := sortKey(&a[i])
+			j := i + 1
+			for j < n && sortKey(&a[j]) == ki {
+				j++
+			}
+			if j-i > 1 {
+				for l, r := i, j-1; l < r; l, r = l+1, r-1 {
+					a[l], a[r] = a[r], a[l]
+				}
+			}
+			i = j
+		}
+	}
+	return scratch
+}

src/result_others.go

@@ -1,4 +1,4 @@
-//go:build !386 && !amd64
+//go:build !386 && !amd64 && !arm64
 
 package fzf
 
@@ -14,3 +14,7 @@ func compareRanks(irank Result, jrank Result, tac bool) bool {
 	}
 	return (irank.item.Index() <= jrank.item.Index()) != tac
 }
+
+func sortKey(r *Result) uint64 {
+	return uint64(r.points[0]) | uint64(r.points[1])<<16 | uint64(r.points[2])<<32 | uint64(r.points[3])<<48
+}

src/result_test.go

@@ -2,6 +2,8 @@ package fzf
 
 import (
 	"math"
+	"math/rand"
+	"slices"
 	"sort"
 	"testing"
 
@@ -18,7 +20,7 @@ func TestOffsetSort(t *testing.T) {
 	offsets := []Offset{
 		{3, 5}, {2, 7},
 		{1, 3}, {2, 9}}
-	sort.Sort(ByOrder(offsets))
+	slices.SortFunc(offsets, compareOffsets)
 
 	if offsets[0][0] != 1 || offsets[0][1] != 3 ||
 		offsets[1][0] != 2 || offsets[1][1] != 7 ||
@@ -124,14 +126,14 @@ func TestColorOffset(t *testing.T) {
 	item := Result{
 		item: &Item{
 			colors: &[]ansiOffset{
-				{[2]int32{0, 20}, ansiState{1, 5, 0, -1, nil}},
-				{[2]int32{22, 27}, ansiState{2, 6, tui.Bold, -1, nil}},
-				{[2]int32{30, 32}, ansiState{3, 7, 0, -1, nil}},
-				{[2]int32{33, 40}, ansiState{4, 8, tui.Bold, -1, nil}}}}}
+				{[2]int32{0, 20}, ansiState{1, 5, -1, 0, -1, nil}},
+				{[2]int32{22, 27}, ansiState{2, 6, -1, tui.Bold, -1, nil}},
+				{[2]int32{30, 32}, ansiState{3, 7, -1, 0, -1, nil}},
+				{[2]int32{33, 40}, ansiState{4, 8, -1, tui.Bold, -1, nil}}}}}
 
 	colBase := tui.NewColorPair(89, 189, tui.AttrUndefined)
 	colMatch := tui.NewColorPair(99, 199, tui.AttrUndefined)
-	colors := item.colorOffsets(offsets, nil, tui.Dark256, colBase, colMatch, tui.AttrUndefined, true)
+	colors := item.colorOffsets(offsets, nil, tui.Dark256, colBase, colMatch, tui.AttrUndefined, 0, false)
 	assert := func(idx int, b int32, e int32, c tui.ColorPair) {
 		o := colors[idx]
 		if o.offset[0] != b || o.offset[1] != e || o.color != c {
@@ -158,7 +160,7 @@ func TestColorOffset(t *testing.T) {
 
 	nthOffsets := []Offset{{37, 39}, {42, 45}}
 	for _, attr := range []tui.Attr{tui.AttrRegular, tui.StrikeThrough} {
-		colors = item.colorOffsets(offsets, nthOffsets, tui.Dark256, colRegular, colUnderline, attr, true)
+		colors = item.colorOffsets(offsets, nthOffsets, tui.Dark256, colRegular, colUnderline, attr, 0, false)
 
 		// [{[0 5] {1 5 0}} {[5 15] {1 5 8}} {[15 20] {1 5 0}}
 		//  {[22 25] {2 6 1}} {[25 27] {2 6 9}} {[27 30] {-1 -1 8}}
@@ -176,9 +178,97 @@ func TestColorOffset(t *testing.T) {
 		assert(9, 35, 37, tui.NewColorPair(4, 8, tui.Bold))
 		expected := tui.Bold | attr
 		if attr == tui.AttrRegular {
-			expected = tui.AttrRegular
+			expected = tui.Bold
 		}
 		assert(10, 37, 39, tui.NewColorPair(4, 8, expected))
 		assert(11, 39, 40, tui.NewColorPair(4, 8, tui.Bold))
 	}
+
+	// Test nthOverlay: simulates nth:regular with current-fg:underline
+	// The overlay (underline) should survive even though nth:regular clears attrs.
+	// Precedence: fg < nth < current-fg
+	colors = item.colorOffsets(offsets, nthOffsets, tui.Dark256, colRegular, colUnderline, tui.AttrRegular, tui.Underline, false)
+
+	// nth regions should have Underline (from overlay), not cleared by AttrRegular
+	// Non-nth regions keep colBase attrs (AttrUndefined)
+	assert(0, 0, 5, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(1, 5, 15, tui.NewColorPair(1, 5, tui.Underline))
+	assert(2, 15, 20, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(3, 22, 25, tui.NewColorPair(2, 6, tui.Bold))
+	assert(4, 25, 27, tui.NewColorPair(2, 6, tui.Bold|tui.Underline))
+	assert(5, 27, 30, colUnderline)
+	assert(6, 30, 32, tui.NewColorPair(3, 7, tui.Underline))
+	assert(7, 32, 33, colUnderline)
+	assert(8, 33, 35, tui.NewColorPair(4, 8, tui.Bold|tui.Underline))
+	assert(9, 35, 37, tui.NewColorPair(4, 8, tui.Bold))
+	// nth region within ANSI bold: AttrRegular clears, overlay adds Underline back
+	assert(10, 37, 39, tui.NewColorPair(4, 8, tui.Bold|tui.Underline))
+	assert(11, 39, 40, tui.NewColorPair(4, 8, tui.Bold))
+
+	// Test nthOverlay with additive attrs: nth:strikethrough with selected-fg:bold
+	colors = item.colorOffsets(offsets, nthOffsets, tui.Dark256, colRegular, colUnderline, tui.StrikeThrough, tui.Bold, false)
+
+	// Non-nth entries unchanged from overlay=0 case
+	assert(0, 0, 5, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(5, 27, 30, colUnderline) // match only, no nth
+	assert(7, 32, 33, colUnderline) // match only, no nth
+	// nth region within ANSI bold: StrikeThrough|Bold merged with ANSI Bold
+	assert(10, 37, 39, tui.NewColorPair(4, 8, tui.Bold|tui.StrikeThrough))
+}
+
+func TestRadixSortResults(t *testing.T) {
+	sortCriteria = []criterion{byScore, byLength}
+
+	rng := rand.New(rand.NewSource(42))
+
+	for _, n := range []int{128, 256, 500, 1000} {
+		for _, tac := range []bool{false, true} {
+			// Build items with random points and indices
+			items := make([]*Item, n)
+			for i := range items {
+				items[i] = &Item{text: util.Chars{Index: int32(i)}}
+			}
+
+			results := make([]Result, n)
+			for i := range results {
+				results[i] = Result{
+					item: items[i],
+					points: [4]uint16{
+						uint16(rng.Intn(256)),
+						uint16(rng.Intn(256)),
+						uint16(rng.Intn(256)),
+						uint16(rng.Intn(256)),
+					},
+				}
+			}
+
+			// Make some duplicates to test stability
+			for i := 0; i < n/4; i++ {
+				j := rng.Intn(n)
+				k := rng.Intn(n)
+				results[j].points = results[k].points
+			}
+
+			// Copy for reference sort
+			expected := make([]Result, n)
+			copy(expected, results)
+			if tac {
+				sort.Sort(ByRelevanceTac(expected))
+			} else {
+				sort.Sort(ByRelevance(expected))
+			}
+
+			// Radix sort
+			var scratch []Result
+			scratch = radixSortResults(results, tac, scratch)
+
+			for i := range results {
+				if results[i] != expected[i] {
+					t.Errorf("n=%d tac=%v: mismatch at index %d: got item %d, want item %d",
+						n, tac, i, results[i].item.Index(), expected[i].item.Index())
+					break
+				}
+			}
+		}
+	}
 }

src/result_x86.go

@@ -1,4 +1,4 @@
-//go:build 386 || amd64
+//go:build 386 || amd64 || arm64
 
 package fzf
 
@@ -14,3 +14,7 @@ func compareRanks(irank Result, jrank Result, tac bool) bool {
 	}
 	return (irank.item.Index() <= jrank.item.Index()) != tac
 }
+
+func sortKey(r *Result) uint64 {
+	return *(*uint64)(unsafe.Pointer(&r.points[0]))
+}

src/server.go

@@ -46,15 +46,20 @@ type httpServer struct {
 type listenAddress struct {
 	host string
 	port int
+	sock string
 }
 
 func (addr listenAddress) IsLocal() bool {
-	return addr.host == "localhost" || addr.host == "127.0.0.1"
+	return addr.host == "localhost" || addr.host == "127.0.0.1" || len(addr.sock) > 0
 }
 
-var defaultListenAddr = listenAddress{"localhost", 0}
+var defaultListenAddr = listenAddress{"localhost", 0, ""}
 
 func parseListenAddress(address string) (listenAddress, error) {
+	if strings.HasSuffix(address, ".sock") {
+		return listenAddress{"", 0, address}, nil
+	}
+
 	parts := strings.SplitN(address, ":", 3)
 	if len(parts) == 1 {
 		parts = []string{"localhost", parts[0]}
@@ -70,7 +75,7 @@ func parseListenAddress(address string) (listenAddress, error) {
 	if len(parts[0]) == 0 {
 		parts[0] = "localhost"
 	}
-	return listenAddress{parts[0], port}, nil
+	return listenAddress{parts[0], port, ""}, nil
 }
 
 func startHttpServer(address listenAddress, actionChannel chan []*action, getHandler func(getParams) string) (net.Listener, int, error) {
@@ -80,31 +85,49 @@ func startHttpServer(address listenAddress, actionChannel chan []*action, getHan
 	if !address.IsLocal() && len(apiKey) == 0 {
 		return nil, port, errors.New("FZF_API_KEY is required to allow remote access")
 	}
-	addrStr := fmt.Sprintf("%s:%d", host, port)
-	listener, err := net.Listen("tcp", addrStr)
-	if err != nil {
-		return nil, port, fmt.Errorf("failed to listen on %s", addrStr)
-	}
-	if port == 0 {
-		addr := listener.Addr().String()
-		parts := strings.Split(addr, ":")
-		if len(parts) < 2 {
-			return nil, port, fmt.Errorf("cannot extract port: %s", addr)
-		}
-		var err error
-		port, err = strconv.Atoi(parts[len(parts)-1])
-		if err != nil {
-			return nil, port, err
-		}
-	}
 
-	server := httpServer{
-		apiKey:        []byte(apiKey),
-		actionChannel: actionChannel,
-		getHandler:    getHandler,
+	var listener net.Listener
+	var err error
+	if len(address.sock) > 0 {
+		if _, err := os.Stat(address.sock); err == nil {
+			// Check if the socket is already in use
+			if conn, err := net.Dial("unix", address.sock); err == nil {
+				conn.Close()
+				return nil, 0, fmt.Errorf("socket already in use: %s", address.sock)
+			}
+			os.Remove(address.sock)
+		}
+		listener, err = net.Listen("unix", address.sock)
+		if err != nil {
+			return nil, 0, fmt.Errorf("failed to listen on %s", address.sock)
+		}
+		os.Chmod(address.sock, 0600)
+	} else {
+		addrStr := fmt.Sprintf("%s:%d", host, port)
+		listener, err = net.Listen("tcp", addrStr)
+		if err != nil {
+			return nil, port, fmt.Errorf("failed to listen on %s", addrStr)
+		}
+		if port == 0 {
+			addr := listener.Addr().String()
+			parts := strings.Split(addr, ":")
+			if len(parts) < 2 {
+				return nil, port, fmt.Errorf("cannot extract port: %s", addr)
+			}
+			var err error
+			port, err = strconv.Atoi(parts[len(parts)-1])
+			if err != nil {
+				return nil, port, err
+			}
+		}
 	}
 
 	go func() {
+		server := httpServer{
+			apiKey:        []byte(apiKey),
+			actionChannel: actionChannel,
+			getHandler:    getHandler,
+		}
 		for {
 			conn, err := listener.Accept()
 			if err != nil {
@@ -159,23 +182,22 @@ func (server *httpServer) handleHttpRequest(conn net.Conn) string {
 	})
 
 	section := 0
+	var getMatch []string
+Loop:
 	for scanner.Scan() {
 		text := scanner.Text()
 		switch section {
-		case 0:
-			getMatch := getRegex.FindStringSubmatch(text)
-			if len(getMatch) > 0 {
-				response := server.getHandler(parseGetParams(getMatch[1]))
-				if len(response) > 0 {
-					return good(response)
-				}
-				return answer(httpUnavailable+jsonContentType, `{"error":"timeout"}`)
-			} else if !strings.HasPrefix(text, "POST / HTTP") {
+		case 0: // Request line
+			getMatch = getRegex.FindStringSubmatch(text)
+			if len(getMatch) == 0 && !strings.HasPrefix(text, "POST / HTTP") {
 				return bad("invalid request method")
 			}
 			section++
-		case 1:
-			if text == crlf {
+		case 1: // Request headers
+			if text == crlf { // End of headers
+				if len(getMatch) > 0 {
+					break Loop
+				}
 				if contentLength == 0 {
 					return bad("content-length header missing")
 				}
@@ -195,7 +217,7 @@ func (server *httpServer) handleHttpRequest(conn net.Conn) string {
 					apiKey = strings.TrimSpace(pair[1])
 				}
 			}
-		case 2:
+		case 2: // Request body
 			body += text
 		}
 	}
@@ -204,6 +226,14 @@ func (server *httpServer) handleHttpRequest(conn net.Conn) string {
 		return unauthorized("invalid api key")
 	}
 
+	if len(getMatch) > 0 {
+		response := server.getHandler(parseGetParams(getMatch[1]))
+		if len(response) > 0 {
+			return good(response)
+		}
+		return answer(httpUnavailable+jsonContentType, `{"error":"timeout"}`)
+	}
+
 	if len(body) < contentLength {
 		return bad("incomplete request")
 	}

src/terminal_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )
 
-func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter, printsep string, forcePlus bool, query string, allItems []*Item) string {
+func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter, printsep string, forcePlus bool, query string, allItems [3][]*Item) string {
 	replaced, _ := replacePlaceholder(replacePlaceholderParams{
 		template:   template,
 		stripAnsi:  stripAnsi,
@@ -30,11 +30,11 @@ func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter
 
 func TestReplacePlaceholder(t *testing.T) {
 	item1 := newItem("  foo'bar \x1b[31mbaz\x1b[m")
-	items1 := []*Item{item1, item1}
-	items2 := []*Item{
-		newItem("foo'bar \x1b[31mbaz\x1b[m"),
-		newItem("foo'bar \x1b[31mbaz\x1b[m"),
-		newItem("FOO'BAR \x1b[31mBAZ\x1b[m")}
+	items1 := [3][]*Item{{item1}, {item1}, nil}
+	items2 := [3][]*Item{
+		{newItem("foo'bar \x1b[31mbaz\x1b[m")},
+		{newItem("foo'bar \x1b[31mbaz\x1b[m"),
+			newItem("FOO'BAR \x1b[31mBAZ\x1b[m")}, nil}
 
 	delim := "'"
 	var regex *regexp.Regexp
@@ -75,6 +75,14 @@ func TestReplacePlaceholder(t *testing.T) {
 	result = replacePlaceholderTest("echo {}", true, Delimiter{}, printsep, false, "query", items1)
 	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
 
+	// {r}, strip ansi
+	result = replacePlaceholderTest("echo {r}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo   foo'bar baz")
+
+	// {r..}, strip ansi
+	result = replacePlaceholderTest("echo {r..}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo foo'bar baz")
+
 	// {}, with multiple items
 	result = replacePlaceholderTest("echo {}", true, Delimiter{}, printsep, false, "query", items2)
 	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}")
@@ -137,11 +145,11 @@ func TestReplacePlaceholder(t *testing.T) {
 	checkFormat("echo {{.O}} {{.O}}")
 
 	// No match
-	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, nil})
+	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", [3][]*Item{nil, nil, nil})
 	check("echo /")
 
 	// No match, but with selections
-	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, item1})
+	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", [3][]*Item{nil, {item1}, nil})
 	checkFormat("echo /{{.O}}  foo{{.I}}bar baz{{.O}}")
 
 	// String delimiter
@@ -158,17 +166,18 @@ func TestReplacePlaceholder(t *testing.T) {
 		Test single placeholders, but focus on the placeholders' parameters (e.g. flags).
 		see: TestParsePlaceholder
 	*/
-	items3 := []*Item{
+	items3 := [3][]*Item{
 		// single line
-		newItem("1a 1b 1c 1d 1e 1f"),
+		{newItem("1a 1b 1c 1d 1e 1f")},
 		// multi line
-		newItem("1a 1b 1c 1d 1e 1f"),
-		newItem("2a 2b 2c 2d 2e 2f"),
-		newItem("3a 3b 3c 3d 3e 3f"),
-		newItem("4a 4b 4c 4d 4e 4f"),
-		newItem("5a 5b 5c 5d 5e 5f"),
-		newItem("6a 6b 6c 6d 6e 6f"),
-		newItem("7a 7b 7c 7d 7e 7f"),
+		{newItem("1a 1b 1c 1d 1e 1f"),
+			newItem("2a 2b 2c 2d 2e 2f"),
+			newItem("3a 3b 3c 3d 3e 3f"),
+			newItem("4a 4b 4c 4d 4e 4f"),
+			newItem("5a 5b 5c 5d 5e 5f"),
+			newItem("6a 6b 6c 6d 6e 6f"),
+			newItem("7a 7b 7c 7d 7e 7f")},
+		nil,
 	}
 	stripAnsi := false
 	forcePlus := false
@@ -484,7 +493,12 @@ func TestParsePlaceholder(t *testing.T) {
 		// III. query type placeholder
 		// query flag is not removed after parsing, so it gets doubled
 		// while the double q is invalid, it is useful here for testing purposes
-		`{q}`: `{qq}`,
+		`{q}`:        `{qq}`,
+		`{q:1}`:      `{qq:1}`,
+		`{q:2..}`:    `{qq:2..}`,
+		`{q:..}`:     `{qq:..}`,
+		`{q:2..-1}`:  `{qq:2..-1}`,
+		`{q:s2..-1}`: `{sqq:2..-1}`, // FIXME
 
 		// IV. escaping placeholder
 		`\{}`:   `{}`,
@@ -544,14 +558,14 @@ func newItem(str string) *Item {
 	return &Item{origText: &bytes, text: util.ToChars([]byte(trimmed))}
 }
 
-// Functions tested in this file require array of items (allItems). The array needs
-// to consist of at least two nils. This is helper function.
-func newItems(str ...string) []*Item {
-	result := make([]*Item, util.Max(len(str), 2))
+// Functions tested in this file require array of items (allItems).
+// This is helper function.
+func newItems(str ...string) [3][]*Item {
+	result := make([]*Item, len(str))
 	for i, s := range str {
 		result[i] = newItem(s)
 	}
-	return result
+	return [3][]*Item{result, nil, nil}
 }
 
 // (for logging purposes)
@@ -560,7 +574,7 @@ func (item *Item) String() string {
 }
 
 // Helper function to parse, execute and convert "text/template" to string. Panics on error.
-func templateToString(format string, data interface{}) string {
+func templateToString(format string, data any) string {
 	bb := &bytes.Buffer{}
 
 	err := template.Must(template.New("").Parse(format)).Execute(bb, data)
@@ -575,7 +589,7 @@ func templateToString(format string, data interface{}) string {
 type give struct {
 	template string
 	query    string
-	allItems []*Item
+	allItems [3][]*Item
 }
 type want struct {
 	/*
@@ -613,25 +627,25 @@ func testCommands(t *testing.T, tests []testCase) {
 	// evaluate the test cases
 	for idx, test := range tests {
 		gotOutput := replacePlaceholderTest(
-			test.give.template, stripAnsi, delimiter, printsep, forcePlus,
-			test.give.query,
-			test.give.allItems)
+			test.template, stripAnsi, delimiter, printsep, forcePlus,
+			test.query,
+			test.allItems)
 		switch {
-		case test.want.output != "":
-			if gotOutput != test.want.output {
+		case test.output != "":
+			if gotOutput != test.output {
 				t.Errorf("tests[%v]:\ngave{\n\ttemplate: '%s',\n\tquery: '%s',\n\tallItems: %s}\nand got '%s',\nbut want '%s'",
 					idx,
-					test.give.template, test.give.query, test.give.allItems,
-					gotOutput, test.want.output)
+					test.template, test.query, test.allItems,
+					gotOutput, test.output)
 			}
-		case test.want.match != "":
-			wantMatch := strings.ReplaceAll(test.want.match, `\`, `\\`)
+		case test.match != "":
+			wantMatch := strings.ReplaceAll(test.match, `\`, `\\`)
 			wantRegex := regexp.MustCompile(wantMatch)
 			if !wantRegex.MatchString(gotOutput) {
 				t.Errorf("tests[%v]:\ngave{\n\ttemplate: '%s',\n\tquery: '%s',\n\tallItems: %s}\nand got '%s',\nbut want '%s'",
 					idx,
-					test.give.template, test.give.query, test.give.allItems,
-					gotOutput, test.want.match)
+					test.template, test.query, test.allItems,
+					gotOutput, test.match)
 			}
 		default:
 			t.Errorf("tests[%v]: test case does not describe 'want' property", idx)
@@ -685,3 +699,72 @@ func readFile(path string) ([]byte, error) {
 		}
 	}
 }
+
+func TestWordWrapAnsiLine(t *testing.T) {
+	term := &Terminal{}
+
+	// Simple wrapping
+	result := term.wordWrapAnsiLine("hello world", 7, 2)
+	if len(result) != 2 || result[0] != "hello" || result[1] != "world" {
+		t.Errorf("Simple: %q", result)
+	}
+
+	// No wrapping needed
+	result = term.wordWrapAnsiLine("hello", 10, 2)
+	if len(result) != 1 || result[0] != "hello" {
+		t.Errorf("No wrap: %q", result)
+	}
+
+	// ANSI codes preserved across split
+	result = term.wordWrapAnsiLine("\x1b[31mhello \x1b[32mworld", 8, 2)
+	if len(result) != 2 || result[0] != "\x1b[31mhello" || result[1] != "\x1b[32mworld" {
+		t.Errorf("ANSI: %q", result)
+	}
+
+	// Long word (no space) - no break, let character wrapping handle it
+	result = term.wordWrapAnsiLine("abcdefghij", 5, 2)
+	if len(result) != 1 || result[0] != "abcdefghij" {
+		t.Errorf("Long word: %q", result)
+	}
+
+	// Multiple words with continuation wrapSignWidth
+	result = term.wordWrapAnsiLine("aa bb cc dd", 5, 2)
+	// max=5 for first line, max=3 for continuations (5-2)
+	// "aa bb" (5 wide), split at second space -> "aa bb" | "cc" | "dd"
+	if len(result) != 3 || result[0] != "aa bb" || result[1] != "cc" || result[2] != "dd" {
+		t.Errorf("Multiple words: %q", result)
+	}
+
+	// Empty string
+	result = term.wordWrapAnsiLine("", 10, 2)
+	if len(result) != 1 || result[0] != "" {
+		t.Errorf("Empty: %q", result)
+	}
+
+	// OSC 8 hyperlink preserved
+	result = term.wordWrapAnsiLine("\x1b]8;;http://example.com\x1b\\click here\x1b]8;;\x1b\\", 8, 2)
+	if len(result) != 2 {
+		t.Errorf("Hyperlink split count: %d, %q", len(result), result)
+	}
+
+	// Tab handling: tab expands to tabstop-aligned width
+	term.tabstop = 8
+	// "\thi there" - tab at column 0 expands to 8, total "hi" starts at 8
+	// maxWidth=15: "\thi" = 10 wide, "there" = 5 wide, total 16 > 15, wrap at space
+	result = term.wordWrapAnsiLine("\thi there", 15, 2)
+	if len(result) != 2 || result[0] != "\thi" || result[1] != "there" {
+		t.Errorf("Tab: %q", result)
+	}
+
+	// Tab as word boundary: "hello"(5) + tab(3→col8) + "world"(5) = 13 total
+	// maxWidth=13: fits without wrapping
+	result = term.wordWrapAnsiLine("hello\tworld", 13, 2)
+	if len(result) != 1 || result[0] != "hello\tworld" {
+		t.Errorf("Tab no wrap: %q", result)
+	}
+	// maxWidth=12: 13 > 12, wraps at tab
+	result = term.wordWrapAnsiLine("hello\tworld", 12, 2)
+	if len(result) != 2 || result[0] != "hello" || result[1] != "world" {
+		t.Errorf("Tab wrap: %q", result)
+	}
+}

src/tmux.go

@@ -1,35 +1,11 @@
 package fzf
 
 import (
-	"os"
 	"os/exec"
-
-	"github.com/junegunn/fzf/src/tui"
 )
 
 func runTmux(args []string, opts *Options) (int, error) {
-	// Prepare arguments
-	fzf, rest := args[0], args[1:]
-	args = []string{"--bind=ctrl-z:ignore"}
-	if !opts.Tmux.border && opts.BorderShape == tui.BorderUndefined {
-		// We append --border option at the end, because `--style=full:STYLE`
-		// may have changed the default border style.
-		rest = append(rest, "--border")
-	}
-	if opts.Tmux.border && opts.Margin == defaultMargin() {
-		args = append(args, "--margin=0,1")
-	}
-	argStr := escapeSingleQuote(fzf)
-	for _, arg := range append(args, rest...) {
-		argStr += " " + escapeSingleQuote(arg)
-	}
-	argStr += ` --no-tmux --no-height`
-
-	// Get current directory
-	dir, err := os.Getwd()
-	if err != nil {
-		dir = "."
-	}
+	argStr, dir := popupArgStr(args, opts)
 
 	// Set tmux options for popup placement
 	// C        Both    The centre of the terminal

src/tokenizer.go

@@ -6,6 +6,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"unicode"
 
 	"github.com/junegunn/fzf/src/util"
 )
@@ -22,6 +23,18 @@ func (r Range) IsFull() bool {
 	return r.begin == rangeEllipsis && r.end == rangeEllipsis
 }
 
+func compareRanges(r1 []Range, r2 []Range) bool {
+	if len(r1) != len(r2) {
+		return false
+	}
+	for idx := range r1 {
+		if r1[idx] != r2[idx] {
+			return false
+		}
+	}
+	return true
+}
+
 func RangesToString(ranges []Range) string {
 	strs := []string{}
 	for _, r := range ranges {
@@ -65,6 +78,11 @@ type Delimiter struct {
 	str   *string
 }
 
+// IsAwk returns true if the delimiter is an AWK-style delimiter
+func (d Delimiter) IsAwk() bool {
+	return d.regex == nil && d.str == nil
+}
+
 // String returns the string representation of a Delimiter.
 func (d Delimiter) String() string {
 	return fmt.Sprintf("Delimiter{regex: %v, str: &%q}", d.regex, *d.str)
@@ -143,7 +161,7 @@ func awkTokenizer(input string) ([]string, int) {
 	end := 0
 	for idx := 0; idx < len(input); idx++ {
 		r := input[idx]
-		white := r == 9 || r == 32
+		white := r == 9 || r == 32 || r == 10
 		switch state {
 		case awkNil:
 			if white {
@@ -188,8 +206,9 @@ func Tokenize(text string, delimiter Delimiter) []Token {
 	if delimiter.regex != nil {
 		locs := delimiter.regex.FindAllStringIndex(text, -1)
 		begin := 0
-		for _, loc := range locs {
-			tokens = append(tokens, text[begin:loc[1]])
+		tokens = make([]string, len(locs))
+		for i, loc := range locs {
+			tokens[i] = text[begin:loc[1]]
 			begin = loc[1]
 		}
 		if begin < len(text) {
@@ -199,7 +218,43 @@ func Tokenize(text string, delimiter Delimiter) []Token {
 	return withPrefixLengths(tokens, 0)
 }
 
-func joinTokens(tokens []Token) string {
+// StripLastDelimiter removes the trailing delimiter
+func StripLastDelimiter(str string, delimiter Delimiter) string {
+	if delimiter.str != nil {
+		return strings.TrimSuffix(str, *delimiter.str)
+	}
+	if delimiter.regex != nil {
+		locs := delimiter.regex.FindAllStringIndex(str, -1)
+		if len(locs) > 0 {
+			lastLoc := locs[len(locs)-1]
+			if lastLoc[1] == len(str) {
+				str = str[:lastLoc[0]]
+			}
+		}
+		return str
+	}
+	return strings.TrimRightFunc(str, unicode.IsSpace)
+}
+
+func GetLastDelimiter(str string, delimiter Delimiter) string {
+	if delimiter.str != nil {
+		if strings.HasSuffix(str, *delimiter.str) {
+			return *delimiter.str
+		}
+	} else if delimiter.regex != nil {
+		locs := delimiter.regex.FindAllStringIndex(str, -1)
+		if len(locs) > 0 {
+			lastLoc := locs[len(locs)-1]
+			if lastLoc[1] == len(str) {
+				return str[lastLoc[0]:]
+			}
+		}
+	}
+	return ""
+}
+
+// JoinTokens concatenates the tokens into a single string
+func JoinTokens(tokens []Token) string {
 	var output bytes.Buffer
 	for _, token := range tokens {
 		output.WriteString(token.text.ToString())
@@ -217,7 +272,7 @@ func Transform(tokens []Token, withNth []Range) []Token {
 		if r.begin == r.end {
 			idx := r.begin
 			if idx == rangeEllipsis {
-				chars := util.ToChars(stringBytes(joinTokens(tokens)))
+				chars := util.ToChars(stringBytes(JoinTokens(tokens)))
 				parts = append(parts, &chars)
 			} else {
 				if idx < 0 {
@@ -249,7 +304,7 @@ func Transform(tokens []Token, withNth []Range) []Token {
 					end += numTokens + 1
 				}
 			}
-			minIdx = util.Max(0, begin-1)
+			minIdx = max(0, begin-1)
 			for idx := begin; idx <= end; idx++ {
 				if idx >= 1 && idx <= numTokens {
 					parts = append(parts, tokens[idx-1].text)

src/tokenizer_test.go

@@ -56,9 +56,9 @@ func TestParseRange(t *testing.T) {
 
 func TestTokenize(t *testing.T) {
 	// AWK-style
-	input := "  abc:  def:  ghi  "
+	input := "  abc: \n\t def:  ghi  "
 	tokens := Tokenize(input, Delimiter{})
-	if tokens[0].text.ToString() != "abc:  " || tokens[0].prefixLength != 2 {
+	if tokens[0].text.ToString() != "abc: \n\t " || tokens[0].prefixLength != 2 {
 		t.Errorf("%s", tokens)
 	}
 
@@ -71,9 +71,9 @@ func TestTokenize(t *testing.T) {
 	// With delimiter regex
 	tokens = Tokenize(input, delimiterRegexp("\\s+"))
 	if tokens[0].text.ToString() != "  " || tokens[0].prefixLength != 0 ||
-		tokens[1].text.ToString() != "abc:  " || tokens[1].prefixLength != 2 ||
-		tokens[2].text.ToString() != "def:  " || tokens[2].prefixLength != 8 ||
-		tokens[3].text.ToString() != "ghi  " || tokens[3].prefixLength != 14 {
+		tokens[1].text.ToString() != "abc: \n\t " || tokens[1].prefixLength != 2 ||
+		tokens[2].text.ToString() != "def:  " || tokens[2].prefixLength != 10 ||
+		tokens[3].text.ToString() != "ghi  " || tokens[3].prefixLength != 16 {
 		t.Errorf("%s", tokens)
 	}
 }
@@ -85,14 +85,14 @@ func TestTransform(t *testing.T) {
 		{
 			ranges, _ := splitNth("1,2,3")
 			tx := Transform(tokens, ranges)
-			if joinTokens(tx) != "abc:  def:  ghi:  " {
+			if JoinTokens(tx) != "abc:  def:  ghi:  " {
 				t.Errorf("%s", tx)
 			}
 		}
 		{
 			ranges, _ := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
-			if string(joinTokens(tx)) != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
+			if string(JoinTokens(tx)) != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
 				len(tx) != 4 ||
 				tx[0].text.ToString() != "abc:  def:  " || tx[0].prefixLength != 2 ||
 				tx[1].text.ToString() != "ghi:  " || tx[1].prefixLength != 14 ||
@@ -107,7 +107,7 @@ func TestTransform(t *testing.T) {
 		{
 			ranges, _ := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
-			if joinTokens(tx) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
+			if JoinTokens(tx) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
 				len(tx) != 4 ||
 				tx[0].text.ToString() != "  abc:  def:" || tx[0].prefixLength != 0 ||
 				tx[1].text.ToString() != "  ghi:" || tx[1].prefixLength != 12 ||

src/tui/dummy.go

@@ -2,29 +2,7 @@
 
 package tui
 
-type Attr int32
-
-func HasFullscreenRenderer() bool {
-	return false
-}
-
-var DefaultBorderShape = BorderRounded
-
-func (a Attr) Merge(b Attr) Attr {
-	if b&AttrRegular > 0 {
-		// Only keep bold attribute set by the system
-		return b | (a & BoldForce)
-	}
-
-	return a | b
-}
-
 const (
-	AttrUndefined = Attr(0)
-	AttrRegular   = Attr(1 << 8)
-	AttrClear     = Attr(1 << 9)
-	BoldForce     = Attr(1 << 10)
-
 	Bold          = Attr(1)
 	Dim           = Attr(1 << 1)
 	Italic        = Attr(1 << 2)
@@ -35,6 +13,12 @@ const (
 	StrikeThrough = Attr(1 << 7)
 )
 
+func HasFullscreenRenderer() bool {
+	return false
+}
+
+var DefaultBorderShape = BorderRounded
+
 func (r *FullscreenRenderer) Init() error                        { return nil }
 func (r *FullscreenRenderer) DefaultTheme() *ColorTheme          { return nil }
 func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
@@ -44,14 +28,17 @@ func (r *FullscreenRenderer) PassThrough(string)                 {}
 func (r *FullscreenRenderer) Clear()                             {}
 func (r *FullscreenRenderer) NeedScrollbarRedraw() bool          { return false }
 func (r *FullscreenRenderer) ShouldEmitResizeEvent() bool        { return false }
+func (r *FullscreenRenderer) Bell()                              {}
+func (r *FullscreenRenderer) HideCursor()                        {}
+func (r *FullscreenRenderer) ShowCursor()                        {}
 func (r *FullscreenRenderer) Refresh()                           {}
 func (r *FullscreenRenderer) Close()                             {}
 func (r *FullscreenRenderer) Size() TermSize                     { return TermSize{} }
-
-func (r *FullscreenRenderer) GetChar() Event { return Event{} }
-func (r *FullscreenRenderer) Top() int       { return 0 }
-func (r *FullscreenRenderer) MaxX() int      { return 0 }
-func (r *FullscreenRenderer) MaxY() int      { return 0 }
+func (r *FullscreenRenderer) Top() int                           { return 0 }
+func (r *FullscreenRenderer) MaxX() int                          { return 0 }
+func (r *FullscreenRenderer) MaxY() int                          { return 0 }
+func (r *FullscreenRenderer) GetChar(bool) Event                 { return Event{} }
+func (r *FullscreenRenderer) CancelGetChar()                     {}
 
 func (r *FullscreenRenderer) RefreshWindows(windows []Window) {}
 

src/tui/eventtype_string.go

@@ -21,7 +21,7 @@ func _() {
 	_ = x[CtrlJ-10]
 	_ = x[CtrlK-11]
 	_ = x[CtrlL-12]
-	_ = x[CtrlM-13]
+	_ = x[Enter-13]
 	_ = x[CtrlN-14]
 	_ = x[CtrlO-15]
 	_ = x[CtrlP-16]
@@ -37,82 +37,137 @@ func _() {
 	_ = x[CtrlZ-26]
 	_ = x[Esc-27]
 	_ = x[CtrlSpace-28]
-	_ = x[CtrlDelete-29]
-	_ = x[CtrlBackSlash-30]
-	_ = x[CtrlRightBracket-31]
-	_ = x[CtrlCaret-32]
-	_ = x[CtrlSlash-33]
-	_ = x[ShiftTab-34]
-	_ = x[Backspace-35]
-	_ = x[Delete-36]
-	_ = x[PageUp-37]
-	_ = x[PageDown-38]
-	_ = x[Up-39]
-	_ = x[Down-40]
-	_ = x[Left-41]
-	_ = x[Right-42]
-	_ = x[Home-43]
-	_ = x[End-44]
-	_ = x[Insert-45]
-	_ = x[ShiftUp-46]
-	_ = x[ShiftDown-47]
-	_ = x[ShiftLeft-48]
-	_ = x[ShiftRight-49]
-	_ = x[ShiftDelete-50]
-	_ = x[F1-51]
-	_ = x[F2-52]
-	_ = x[F3-53]
-	_ = x[F4-54]
-	_ = x[F5-55]
-	_ = x[F6-56]
-	_ = x[F7-57]
-	_ = x[F8-58]
-	_ = x[F9-59]
-	_ = x[F10-60]
-	_ = x[F11-61]
-	_ = x[F12-62]
-	_ = x[AltBackspace-63]
-	_ = x[AltUp-64]
-	_ = x[AltDown-65]
-	_ = x[AltLeft-66]
-	_ = x[AltRight-67]
-	_ = x[AltShiftUp-68]
-	_ = x[AltShiftDown-69]
-	_ = x[AltShiftLeft-70]
-	_ = x[AltShiftRight-71]
-	_ = x[Alt-72]
-	_ = x[CtrlAlt-73]
-	_ = x[Invalid-74]
-	_ = x[Fatal-75]
-	_ = x[Mouse-76]
-	_ = x[DoubleClick-77]
-	_ = x[LeftClick-78]
-	_ = x[RightClick-79]
-	_ = x[SLeftClick-80]
-	_ = x[SRightClick-81]
-	_ = x[ScrollUp-82]
-	_ = x[ScrollDown-83]
-	_ = x[SScrollUp-84]
-	_ = x[SScrollDown-85]
-	_ = x[PreviewScrollUp-86]
-	_ = x[PreviewScrollDown-87]
-	_ = x[Resize-88]
-	_ = x[Change-89]
-	_ = x[BackwardEOF-90]
-	_ = x[Start-91]
-	_ = x[Load-92]
-	_ = x[Focus-93]
-	_ = x[One-94]
-	_ = x[Zero-95]
-	_ = x[Result-96]
-	_ = x[Jump-97]
-	_ = x[JumpCancel-98]
-	_ = x[ClickHeader-99]
+	_ = x[CtrlBackSlash-29]
+	_ = x[CtrlRightBracket-30]
+	_ = x[CtrlCaret-31]
+	_ = x[CtrlSlash-32]
+	_ = x[ShiftTab-33]
+	_ = x[Backspace-34]
+	_ = x[Delete-35]
+	_ = x[PageUp-36]
+	_ = x[PageDown-37]
+	_ = x[Up-38]
+	_ = x[Down-39]
+	_ = x[Left-40]
+	_ = x[Right-41]
+	_ = x[Home-42]
+	_ = x[End-43]
+	_ = x[Insert-44]
+	_ = x[ShiftUp-45]
+	_ = x[ShiftDown-46]
+	_ = x[ShiftLeft-47]
+	_ = x[ShiftRight-48]
+	_ = x[ShiftDelete-49]
+	_ = x[ShiftHome-50]
+	_ = x[ShiftEnd-51]
+	_ = x[ShiftPageUp-52]
+	_ = x[ShiftPageDown-53]
+	_ = x[F1-54]
+	_ = x[F2-55]
+	_ = x[F3-56]
+	_ = x[F4-57]
+	_ = x[F5-58]
+	_ = x[F6-59]
+	_ = x[F7-60]
+	_ = x[F8-61]
+	_ = x[F9-62]
+	_ = x[F10-63]
+	_ = x[F11-64]
+	_ = x[F12-65]
+	_ = x[AltBackspace-66]
+	_ = x[AltUp-67]
+	_ = x[AltDown-68]
+	_ = x[AltLeft-69]
+	_ = x[AltRight-70]
+	_ = x[AltDelete-71]
+	_ = x[AltHome-72]
+	_ = x[AltEnd-73]
+	_ = x[AltPageUp-74]
+	_ = x[AltPageDown-75]
+	_ = x[AltShiftUp-76]
+	_ = x[AltShiftDown-77]
+	_ = x[AltShiftLeft-78]
+	_ = x[AltShiftRight-79]
+	_ = x[AltShiftDelete-80]
+	_ = x[AltShiftHome-81]
+	_ = x[AltShiftEnd-82]
+	_ = x[AltShiftPageUp-83]
+	_ = x[AltShiftPageDown-84]
+	_ = x[CtrlUp-85]
+	_ = x[CtrlDown-86]
+	_ = x[CtrlLeft-87]
+	_ = x[CtrlRight-88]
+	_ = x[CtrlHome-89]
+	_ = x[CtrlEnd-90]
+	_ = x[CtrlBackspace-91]
+	_ = x[CtrlDelete-92]
+	_ = x[CtrlPageUp-93]
+	_ = x[CtrlPageDown-94]
+	_ = x[Alt-95]
+	_ = x[CtrlAlt-96]
+	_ = x[CtrlAltUp-97]
+	_ = x[CtrlAltDown-98]
+	_ = x[CtrlAltLeft-99]
+	_ = x[CtrlAltRight-100]
+	_ = x[CtrlAltHome-101]
+	_ = x[CtrlAltEnd-102]
+	_ = x[CtrlAltBackspace-103]
+	_ = x[CtrlAltDelete-104]
+	_ = x[CtrlAltPageUp-105]
+	_ = x[CtrlAltPageDown-106]
+	_ = x[CtrlShiftUp-107]
+	_ = x[CtrlShiftDown-108]
+	_ = x[CtrlShiftLeft-109]
+	_ = x[CtrlShiftRight-110]
+	_ = x[CtrlShiftHome-111]
+	_ = x[CtrlShiftEnd-112]
+	_ = x[CtrlShiftDelete-113]
+	_ = x[CtrlShiftPageUp-114]
+	_ = x[CtrlShiftPageDown-115]
+	_ = x[CtrlAltShiftUp-116]
+	_ = x[CtrlAltShiftDown-117]
+	_ = x[CtrlAltShiftLeft-118]
+	_ = x[CtrlAltShiftRight-119]
+	_ = x[CtrlAltShiftHome-120]
+	_ = x[CtrlAltShiftEnd-121]
+	_ = x[CtrlAltShiftDelete-122]
+	_ = x[CtrlAltShiftPageUp-123]
+	_ = x[CtrlAltShiftPageDown-124]
+	_ = x[Invalid-125]
+	_ = x[Fatal-126]
+	_ = x[BracketedPasteBegin-127]
+	_ = x[BracketedPasteEnd-128]
+	_ = x[Mouse-129]
+	_ = x[DoubleClick-130]
+	_ = x[LeftClick-131]
+	_ = x[RightClick-132]
+	_ = x[SLeftClick-133]
+	_ = x[SRightClick-134]
+	_ = x[ScrollUp-135]
+	_ = x[ScrollDown-136]
+	_ = x[SScrollUp-137]
+	_ = x[SScrollDown-138]
+	_ = x[PreviewScrollUp-139]
+	_ = x[PreviewScrollDown-140]
+	_ = x[Resize-141]
+	_ = x[Change-142]
+	_ = x[BackwardEOF-143]
+	_ = x[Start-144]
+	_ = x[Load-145]
+	_ = x[Focus-146]
+	_ = x[One-147]
+	_ = x[Zero-148]
+	_ = x[Result-149]
+	_ = x[Jump-150]
+	_ = x[JumpCancel-151]
+	_ = x[ClickHeader-152]
+	_ = x[ClickFooter-153]
+	_ = x[Multi-154]
 }
 
-const _EventType_name = "RuneCtrlACtrlBCtrlCCtrlDCtrlECtrlFCtrlGCtrlHTabCtrlJCtrlKCtrlLCtrlMCtrlNCtrlOCtrlPCtrlQCtrlRCtrlSCtrlTCtrlUCtrlVCtrlWCtrlXCtrlYCtrlZEscCtrlSpaceCtrlDeleteCtrlBackSlashCtrlRightBracketCtrlCaretCtrlSlashShiftTabBackspaceDeletePageUpPageDownUpDownLeftRightHomeEndInsertShiftUpShiftDownShiftLeftShiftRightShiftDeleteF1F2F3F4F5F6F7F8F9F10F11F12AltBackspaceAltUpAltDownAltLeftAltRightAltShiftUpAltShiftDownAltShiftLeftAltShiftRightAltCtrlAltInvalidFatalMouseDoubleClickLeftClickRightClickSLeftClickSRightClickScrollUpScrollDownSScrollUpSScrollDownPreviewScrollUpPreviewScrollDownResizeChangeBackwardEOFStartLoadFocusOneZeroResultJumpJumpCancelClickHeader"
+const _EventType_name = "RuneCtrlACtrlBCtrlCCtrlDCtrlECtrlFCtrlGCtrlHTabCtrlJCtrlKCtrlLEnterCtrlNCtrlOCtrlPCtrlQCtrlRCtrlSCtrlTCtrlUCtrlVCtrlWCtrlXCtrlYCtrlZEscCtrlSpaceCtrlBackSlashCtrlRightBracketCtrlCaretCtrlSlashShiftTabBackspaceDeletePageUpPageDownUpDownLeftRightHomeEndInsertShiftUpShiftDownShiftLeftShiftRightShiftDeleteShiftHomeShiftEndShiftPageUpShiftPageDownF1F2F3F4F5F6F7F8F9F10F11F12AltBackspaceAltUpAltDownAltLeftAltRightAltDeleteAltHomeAltEndAltPageUpAltPageDownAltShiftUpAltShiftDownAltShiftLeftAltShiftRightAltShiftDeleteAltShiftHomeAltShiftEndAltShiftPageUpAltShiftPageDownCtrlUpCtrlDownCtrlLeftCtrlRightCtrlHomeCtrlEndCtrlBackspaceCtrlDeleteCtrlPageUpCtrlPageDownAltCtrlAltCtrlAltUpCtrlAltDownCtrlAltLeftCtrlAltRightCtrlAltHomeCtrlAltEndCtrlAltBackspaceCtrlAltDeleteCtrlAltPageUpCtrlAltPageDownCtrlShiftUpCtrlShiftDownCtrlShiftLeftCtrlShiftRightCtrlShiftHomeCtrlShiftEndCtrlShiftDeleteCtrlShiftPageUpCtrlShiftPageDownCtrlAltShiftUpCtrlAltShiftDownCtrlAltShiftLeftCtrlAltShiftRightCtrlAltShiftHomeCtrlAltShiftEndCtrlAltShiftDeleteCtrlAltShiftPageUpCtrlAltShiftPageDownInvalidFatalBracketedPasteBeginBracketedPasteEndMouseDoubleClickLeftClickRightClickSLeftClickSRightClickScrollUpScrollDownSScrollUpSScrollDownPreviewScrollUpPreviewScrollDownResizeChangeBackwardEOFStartLoadFocusOneZeroResultJumpJumpCancelClickHeaderClickFooterMulti"
 
-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}
+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, 157, 173, 182, 191, 199, 208, 214, 220, 228, 230, 234, 238, 243, 247, 250, 256, 263, 272, 281, 291, 302, 311, 319, 330, 343, 345, 347, 349, 351, 353, 355, 357, 359, 361, 364, 367, 370, 382, 387, 394, 401, 409, 418, 425, 431, 440, 451, 461, 473, 485, 498, 512, 524, 535, 549, 565, 571, 579, 587, 596, 604, 611, 624, 634, 644, 656, 659, 666, 675, 686, 697, 709, 720, 730, 746, 759, 772, 787, 798, 811, 824, 838, 851, 863, 878, 893, 910, 924, 940, 956, 973, 989, 1004, 1022, 1040, 1060, 1067, 1072, 1091, 1108, 1113, 1124, 1133, 1143, 1153, 1164, 1172, 1182, 1191, 1202, 1217, 1234, 1240, 1246, 1257, 1262, 1266, 1271, 1274, 1278, 1284, 1288, 1298, 1309, 1320, 1325}
 
 func (i EventType) String() string {
 	if i < 0 || i >= EventType(len(_EventType_index)-1) {

src/tui/light_test.go

@@ -0,0 +1,352 @@
+package tui
+
+import (
+	"fmt"
+	"os"
+	"testing"
+	"unicode"
+)
+
+func TestLightRenderer(t *testing.T) {
+	tty_file, _ := os.Open("")
+	renderer, _ := NewLightRenderer(
+		"", tty_file, &ColorTheme{}, true, false, 0, false, true,
+		func(h int) int { return h })
+
+	light_renderer := renderer.(*LightRenderer)
+
+	go func() {
+		for {
+			light_renderer.mutex.Lock()
+			ready := light_renderer.cancel != nil
+			light_renderer.mutex.Unlock()
+
+			if ready {
+				light_renderer.CancelGetChar()
+				break
+			}
+		}
+	}()
+	event := light_renderer.GetChar(true)
+	if event.Type != Invalid {
+		t.Error("Not cancelled")
+	}
+
+	assertCharSequence := func(sequence string, name string) {
+		bytes := []byte(sequence)
+		light_renderer.buffer = bytes
+		event := light_renderer.GetChar(true)
+		if event.KeyName() != name {
+			t.Errorf(
+				"sequence: %q | %v | '%s' (%s) != %s",
+				string(bytes), bytes,
+				event.KeyName(), event.Type.String(), name)
+		}
+	}
+
+	assertEscSequence := func(sequence string, name string) {
+		bytes := []byte(sequence)
+		light_renderer.buffer = bytes
+
+		sz := 1
+		event := light_renderer.escSequence(&sz)
+		if fmt.Sprintf("!%s", event.Type.String()) == name {
+			// this is fine
+		} else if event.KeyName() != name {
+			t.Errorf(
+				"sequence: %q | %v | '%s' (%s) != %s",
+				string(bytes), bytes,
+				event.KeyName(), event.Type.String(), name)
+		}
+	}
+
+	// invalid
+	assertEscSequence("\x1b[<", "!Invalid")
+	assertEscSequence("\x1b[1;1R", "!Invalid")
+	assertEscSequence("\x1b[", "!Invalid")
+	assertEscSequence("\x1b[1", "!Invalid")
+	assertEscSequence("\x1b[3;3~1", "!Invalid")
+	assertEscSequence("\x1b[13", "!Invalid")
+	assertEscSequence("\x1b[1;3", "!Invalid")
+	assertEscSequence("\x1b[1;10", "!Invalid")
+	assertEscSequence("\x1b[220~", "!Invalid")
+	assertEscSequence("\x1b[5;30~", "!Invalid")
+	assertEscSequence("\x1b[6;30~", "!Invalid")
+
+	// general
+	for r := 'a'; r < 'z'; r++ {
+		lower_r := fmt.Sprintf("%c", r)
+		upper_r := fmt.Sprintf("%c", unicode.ToUpper(r))
+		assertCharSequence(lower_r, lower_r)
+		assertCharSequence(upper_r, upper_r)
+	}
+
+	assertCharSequence("\x01", "ctrl-a")
+	assertCharSequence("\x02", "ctrl-b")
+	assertCharSequence("\x03", "ctrl-c")
+	assertCharSequence("\x04", "ctrl-d")
+	assertCharSequence("\x05", "ctrl-e")
+	assertCharSequence("\x06", "ctrl-f")
+	assertCharSequence("\x07", "ctrl-g")
+	// ctrl-h is the same as ctrl-backspace
+	// ctrl-i is the same as tab
+	assertCharSequence("\n", "ctrl-j")
+	assertCharSequence("\x0b", "ctrl-k")
+	assertCharSequence("\x0c", "ctrl-l")
+	assertCharSequence("\r", "enter") // enter
+	assertCharSequence("\x0e", "ctrl-n")
+	assertCharSequence("\x0f", "ctrl-o")
+	assertCharSequence("\x10", "ctrl-p")
+	assertCharSequence("\x11", "ctrl-q")
+	assertCharSequence("\x12", "ctrl-r")
+	assertCharSequence("\x13", "ctrl-s")
+	assertCharSequence("\x14", "ctrl-t")
+	assertCharSequence("\x15", "ctrl-u")
+	assertCharSequence("\x16", "ctrl-v")
+	assertCharSequence("\x17", "ctrl-w")
+	assertCharSequence("\x18", "ctrl-x")
+	assertCharSequence("\x19", "ctrl-y")
+	assertCharSequence("\x1a", "ctrl-z")
+
+	assertCharSequence("\x00", "ctrl-space")
+	assertCharSequence("\x1c", "ctrl-\\")
+	assertCharSequence("\x1d", "ctrl-]")
+	assertCharSequence("\x1e", "ctrl-^")
+	assertCharSequence("\x1f", "ctrl-/")
+
+	assertEscSequence("\x1ba", "alt-a")
+	assertEscSequence("\x1bb", "alt-b")
+	assertEscSequence("\x1bc", "alt-c")
+	assertEscSequence("\x1bd", "alt-d")
+	assertEscSequence("\x1be", "alt-e")
+	assertEscSequence("\x1bf", "alt-f")
+	assertEscSequence("\x1bg", "alt-g")
+	assertEscSequence("\x1bh", "alt-h")
+	assertEscSequence("\x1bi", "alt-i")
+	assertEscSequence("\x1bj", "alt-j")
+	assertEscSequence("\x1bk", "alt-k")
+	assertEscSequence("\x1bl", "alt-l")
+	assertEscSequence("\x1bm", "alt-m")
+	assertEscSequence("\x1bn", "alt-n")
+	assertEscSequence("\x1bo", "alt-o")
+	assertEscSequence("\x1bp", "alt-p")
+	assertEscSequence("\x1bq", "alt-q")
+	assertEscSequence("\x1br", "alt-r")
+	assertEscSequence("\x1bs", "alt-s")
+	assertEscSequence("\x1bt", "alt-t")
+	assertEscSequence("\x1bu", "alt-u")
+	assertEscSequence("\x1bv", "alt-v")
+	assertEscSequence("\x1bw", "alt-w")
+	assertEscSequence("\x1bx", "alt-x")
+	assertEscSequence("\x1by", "alt-y")
+	assertEscSequence("\x1bz", "alt-z")
+
+	assertEscSequence("\x1bOP", "f1")
+	assertEscSequence("\x1bOQ", "f2")
+	assertEscSequence("\x1bOR", "f3")
+	assertEscSequence("\x1bOS", "f4")
+	assertEscSequence("\x1b[15~", "f5")
+	assertEscSequence("\x1b[17~", "f6")
+	assertEscSequence("\x1b[18~", "f7")
+	assertEscSequence("\x1b[19~", "f8")
+	assertEscSequence("\x1b[20~", "f9")
+	assertEscSequence("\x1b[21~", "f10")
+	assertEscSequence("\x1b[23~", "f11")
+	assertEscSequence("\x1b[24~", "f12")
+
+	assertEscSequence("\x1b", "esc")
+	assertCharSequence("\t", "tab")
+	assertEscSequence("\x1b[Z", "shift-tab")
+
+	assertCharSequence("\x7f", "backspace")
+	assertEscSequence("\x1b\x7f", "alt-backspace")
+	assertCharSequence("\b", "ctrl-backspace")
+	assertEscSequence("\x1b\b", "ctrl-alt-backspace")
+
+	assertEscSequence("\x1b[A", "up")
+	assertEscSequence("\x1b[B", "down")
+	assertEscSequence("\x1b[C", "right")
+	assertEscSequence("\x1b[D", "left")
+	assertEscSequence("\x1b[H", "home")
+	assertEscSequence("\x1b[F", "end")
+	assertEscSequence("\x1b[2~", "insert")
+	assertEscSequence("\x1b[3~", "delete")
+	assertEscSequence("\x1b[5~", "page-up")
+	assertEscSequence("\x1b[6~", "page-down")
+	assertEscSequence("\x1b[7~", "home")
+	assertEscSequence("\x1b[8~", "end")
+
+	assertEscSequence("\x1b[1;2A", "shift-up")
+	assertEscSequence("\x1b[1;2B", "shift-down")
+	assertEscSequence("\x1b[1;2C", "shift-right")
+	assertEscSequence("\x1b[1;2D", "shift-left")
+	assertEscSequence("\x1b[1;2H", "shift-home")
+	assertEscSequence("\x1b[1;2F", "shift-end")
+	assertEscSequence("\x1b[3;2~", "shift-delete")
+	assertEscSequence("\x1b[5;2~", "shift-page-up")
+	assertEscSequence("\x1b[6;2~", "shift-page-down")
+
+	assertEscSequence("\x1b\x1b", "esc")
+	assertEscSequence("\x1b\x1b[A", "alt-up")
+	assertEscSequence("\x1b\x1b[B", "alt-down")
+	assertEscSequence("\x1b\x1b[C", "alt-right")
+	assertEscSequence("\x1b\x1b[D", "alt-left")
+
+	assertEscSequence("\x1b[1;3A", "alt-up")
+	assertEscSequence("\x1b[1;3B", "alt-down")
+	assertEscSequence("\x1b[1;3C", "alt-right")
+	assertEscSequence("\x1b[1;3D", "alt-left")
+	assertEscSequence("\x1b[1;3H", "alt-home")
+	assertEscSequence("\x1b[1;3F", "alt-end")
+	assertEscSequence("\x1b[3;3~", "alt-delete")
+	assertEscSequence("\x1b[5;3~", "alt-page-up")
+	assertEscSequence("\x1b[6;3~", "alt-page-down")
+
+	assertEscSequence("\x1b[1;4A", "alt-shift-up")
+	assertEscSequence("\x1b[1;4B", "alt-shift-down")
+	assertEscSequence("\x1b[1;4C", "alt-shift-right")
+	assertEscSequence("\x1b[1;4D", "alt-shift-left")
+	assertEscSequence("\x1b[1;4H", "alt-shift-home")
+	assertEscSequence("\x1b[1;4F", "alt-shift-end")
+	assertEscSequence("\x1b[3;4~", "alt-shift-delete")
+	assertEscSequence("\x1b[5;4~", "alt-shift-page-up")
+	assertEscSequence("\x1b[6;4~", "alt-shift-page-down")
+
+	assertEscSequence("\x1b[1;5A", "ctrl-up")
+	assertEscSequence("\x1b[1;5B", "ctrl-down")
+	assertEscSequence("\x1b[1;5C", "ctrl-right")
+	assertEscSequence("\x1b[1;5D", "ctrl-left")
+	assertEscSequence("\x1b[1;5H", "ctrl-home")
+	assertEscSequence("\x1b[1;5F", "ctrl-end")
+	assertEscSequence("\x1b[3;5~", "ctrl-delete")
+	assertEscSequence("\x1b[5;5~", "ctrl-page-up")
+	assertEscSequence("\x1b[6;5~", "ctrl-page-down")
+
+	assertEscSequence("\x1b[1;7A", "ctrl-alt-up")
+	assertEscSequence("\x1b[1;7B", "ctrl-alt-down")
+	assertEscSequence("\x1b[1;7C", "ctrl-alt-right")
+	assertEscSequence("\x1b[1;7D", "ctrl-alt-left")
+	assertEscSequence("\x1b[1;7H", "ctrl-alt-home")
+	assertEscSequence("\x1b[1;7F", "ctrl-alt-end")
+	assertEscSequence("\x1b[3;7~", "ctrl-alt-delete")
+	assertEscSequence("\x1b[5;7~", "ctrl-alt-page-up")
+	assertEscSequence("\x1b[6;7~", "ctrl-alt-page-down")
+
+	assertEscSequence("\x1b[1;6A", "ctrl-shift-up")
+	assertEscSequence("\x1b[1;6B", "ctrl-shift-down")
+	assertEscSequence("\x1b[1;6C", "ctrl-shift-right")
+	assertEscSequence("\x1b[1;6D", "ctrl-shift-left")
+	assertEscSequence("\x1b[1;6H", "ctrl-shift-home")
+	assertEscSequence("\x1b[1;6F", "ctrl-shift-end")
+	assertEscSequence("\x1b[3;6~", "ctrl-shift-delete")
+	assertEscSequence("\x1b[5;6~", "ctrl-shift-page-up")
+	assertEscSequence("\x1b[6;6~", "ctrl-shift-page-down")
+
+	assertEscSequence("\x1b[1;8A", "ctrl-alt-shift-up")
+	assertEscSequence("\x1b[1;8B", "ctrl-alt-shift-down")
+	assertEscSequence("\x1b[1;8C", "ctrl-alt-shift-right")
+	assertEscSequence("\x1b[1;8D", "ctrl-alt-shift-left")
+	assertEscSequence("\x1b[1;8H", "ctrl-alt-shift-home")
+	assertEscSequence("\x1b[1;8F", "ctrl-alt-shift-end")
+	assertEscSequence("\x1b[3;8~", "ctrl-alt-shift-delete")
+	assertEscSequence("\x1b[5;8~", "ctrl-alt-shift-page-up")
+	assertEscSequence("\x1b[6;8~", "ctrl-alt-shift-page-down")
+
+	// xterm meta & mac
+	assertEscSequence("\x1b[1;9A", "alt-up")
+	assertEscSequence("\x1b[1;9B", "alt-down")
+	assertEscSequence("\x1b[1;9C", "alt-right")
+	assertEscSequence("\x1b[1;9D", "alt-left")
+	assertEscSequence("\x1b[1;9H", "alt-home")
+	assertEscSequence("\x1b[1;9F", "alt-end")
+	assertEscSequence("\x1b[3;9~", "alt-delete")
+	assertEscSequence("\x1b[5;9~", "alt-page-up")
+	assertEscSequence("\x1b[6;9~", "alt-page-down")
+
+	assertEscSequence("\x1b[1;10A", "alt-shift-up")
+	assertEscSequence("\x1b[1;10B", "alt-shift-down")
+	assertEscSequence("\x1b[1;10C", "alt-shift-right")
+	assertEscSequence("\x1b[1;10D", "alt-shift-left")
+	assertEscSequence("\x1b[1;10H", "alt-shift-home")
+	assertEscSequence("\x1b[1;10F", "alt-shift-end")
+	assertEscSequence("\x1b[3;10~", "alt-shift-delete")
+	assertEscSequence("\x1b[5;10~", "alt-shift-page-up")
+	assertEscSequence("\x1b[6;10~", "alt-shift-page-down")
+
+	assertEscSequence("\x1b[1;11A", "alt-up")
+	assertEscSequence("\x1b[1;11B", "alt-down")
+	assertEscSequence("\x1b[1;11C", "alt-right")
+	assertEscSequence("\x1b[1;11D", "alt-left")
+	assertEscSequence("\x1b[1;11H", "alt-home")
+	assertEscSequence("\x1b[1;11F", "alt-end")
+	assertEscSequence("\x1b[3;11~", "alt-delete")
+	assertEscSequence("\x1b[5;11~", "alt-page-up")
+	assertEscSequence("\x1b[6;11~", "alt-page-down")
+
+	assertEscSequence("\x1b[1;12A", "alt-shift-up")
+	assertEscSequence("\x1b[1;12B", "alt-shift-down")
+	assertEscSequence("\x1b[1;12C", "alt-shift-right")
+	assertEscSequence("\x1b[1;12D", "alt-shift-left")
+	assertEscSequence("\x1b[1;12H", "alt-shift-home")
+	assertEscSequence("\x1b[1;12F", "alt-shift-end")
+	assertEscSequence("\x1b[3;12~", "alt-shift-delete")
+	assertEscSequence("\x1b[5;12~", "alt-shift-page-up")
+	assertEscSequence("\x1b[6;12~", "alt-shift-page-down")
+
+	assertEscSequence("\x1b[1;13A", "ctrl-alt-up")
+	assertEscSequence("\x1b[1;13B", "ctrl-alt-down")
+	assertEscSequence("\x1b[1;13C", "ctrl-alt-right")
+	assertEscSequence("\x1b[1;13D", "ctrl-alt-left")
+	assertEscSequence("\x1b[1;13H", "ctrl-alt-home")
+	assertEscSequence("\x1b[1;13F", "ctrl-alt-end")
+	assertEscSequence("\x1b[3;13~", "ctrl-alt-delete")
+	assertEscSequence("\x1b[5;13~", "ctrl-alt-page-up")
+	assertEscSequence("\x1b[6;13~", "ctrl-alt-page-down")
+
+	assertEscSequence("\x1b[1;14A", "ctrl-alt-shift-up")
+	assertEscSequence("\x1b[1;14B", "ctrl-alt-shift-down")
+	assertEscSequence("\x1b[1;14C", "ctrl-alt-shift-right")
+	assertEscSequence("\x1b[1;14D", "ctrl-alt-shift-left")
+	assertEscSequence("\x1b[1;14H", "ctrl-alt-shift-home")
+	assertEscSequence("\x1b[1;14F", "ctrl-alt-shift-end")
+	assertEscSequence("\x1b[3;14~", "ctrl-alt-shift-delete")
+	assertEscSequence("\x1b[5;14~", "ctrl-alt-shift-page-up")
+	assertEscSequence("\x1b[6;14~", "ctrl-alt-shift-page-down")
+
+	assertEscSequence("\x1b[1;15A", "ctrl-alt-up")
+	assertEscSequence("\x1b[1;15B", "ctrl-alt-down")
+	assertEscSequence("\x1b[1;15C", "ctrl-alt-right")
+	assertEscSequence("\x1b[1;15D", "ctrl-alt-left")
+	assertEscSequence("\x1b[1;15H", "ctrl-alt-home")
+	assertEscSequence("\x1b[1;15F", "ctrl-alt-end")
+	assertEscSequence("\x1b[3;15~", "ctrl-alt-delete")
+	assertEscSequence("\x1b[5;15~", "ctrl-alt-page-up")
+	assertEscSequence("\x1b[6;15~", "ctrl-alt-page-down")
+
+	assertEscSequence("\x1b[1;16A", "ctrl-alt-shift-up")
+	assertEscSequence("\x1b[1;16B", "ctrl-alt-shift-down")
+	assertEscSequence("\x1b[1;16C", "ctrl-alt-shift-right")
+	assertEscSequence("\x1b[1;16D", "ctrl-alt-shift-left")
+	assertEscSequence("\x1b[1;16H", "ctrl-alt-shift-home")
+	assertEscSequence("\x1b[1;16F", "ctrl-alt-shift-end")
+	assertEscSequence("\x1b[3;16~", "ctrl-alt-shift-delete")
+	assertEscSequence("\x1b[5;16~", "ctrl-alt-shift-page-up")
+	assertEscSequence("\x1b[6;16~", "ctrl-alt-shift-page-down")
+
+	// tmux & emacs
+	assertEscSequence("\x1bOA", "up")
+	assertEscSequence("\x1bOB", "down")
+	assertEscSequence("\x1bOC", "right")
+	assertEscSequence("\x1bOD", "left")
+	assertEscSequence("\x1bOH", "home")
+	assertEscSequence("\x1bOF", "end")
+
+	// rrvt
+	assertEscSequence("\x1b[1~", "home")
+	assertEscSequence("\x1b[4~", "end")
+	assertEscSequence("\x1b[11~", "f1")
+	assertEscSequence("\x1b[12~", "f2")
+	assertEscSequence("\x1b[13~", "f3")
+	assertEscSequence("\x1b[14~", "f4")
+
+}

src/tui/light_unix.go

@@ -42,26 +42,35 @@ func (r *LightRenderer) closePlatform() {
 	r.ttyout.Close()
 }
 
-func openTty(mode int) (*os.File, error) {
-	in, err := os.OpenFile(consoleDevice, mode, 0)
-	if err != nil {
+func openTty(ttyDefault string, mode int) (*os.File, error) {
+	var in *os.File
+	var err error
+	if len(ttyDefault) > 0 {
+		in, err = os.OpenFile(ttyDefault, mode, 0)
+	}
+	if in == nil || err != nil || ttyDefault != DefaultTtyDevice && !util.IsTty(in) {
 		tty := ttyname()
 		if len(tty) > 0 {
 			if in, err := os.OpenFile(tty, mode, 0); err == nil {
 				return in, nil
 			}
 		}
-		return nil, errors.New("failed to open " + consoleDevice)
+		if ttyDefault != DefaultTtyDevice {
+			if in, err = os.OpenFile(DefaultTtyDevice, mode, 0); err == nil {
+				return in, nil
+			}
+		}
+		return nil, errors.New("failed to open " + DefaultTtyDevice)
 	}
 	return in, nil
 }
 
-func openTtyIn() (*os.File, error) {
-	return openTty(syscall.O_RDONLY)
+func openTtyIn(ttyDefault string) (*os.File, error) {
+	return openTty(ttyDefault, syscall.O_RDONLY)
 }
 
-func openTtyOut() (*os.File, error) {
-	return openTty(syscall.O_WRONLY)
+func openTtyOut(ttyDefault string) (*os.File, error) {
+	return openTty(ttyDefault, syscall.O_WRONLY)
 }
 
 func (r *LightRenderer) setupTerminal() {
@@ -89,8 +98,8 @@ func (r *LightRenderer) findOffset() (row int, col int) {
 	r.flush()
 	var err error
 	bytes := []byte{}
-	for tries := 0; tries < offsetPollTries; tries++ {
-		bytes, err = r.getBytesInternal(bytes, tries > 0)
+	for tries := range offsetPollTries {
+		bytes, _, err = r.getBytesInternal(false, bytes, tries > 0)
 		if err != nil {
 			return -1, -1
 		}
@@ -105,15 +114,62 @@ func (r *LightRenderer) findOffset() (row int, col int) {
 	return -1, -1
 }
 
-func (r *LightRenderer) getch(nonblock bool) (int, bool) {
-	b := make([]byte, 1)
+func (r *LightRenderer) getch(cancellable bool, nonblock bool) (int, getCharResult) {
 	fd := r.fd()
-	util.SetNonblock(r.ttyin, nonblock)
-	_, err := util.Read(fd, b)
-	if err != nil {
-		return 0, false
+	getter := func() (int, getCharResult) {
+		b := make([]byte, 1)
+		util.SetNonblock(r.ttyin, nonblock)
+		_, err := util.Read(fd, b)
+		if err != nil {
+			return 0, getCharError
+		}
+		return int(b[0]), getCharSuccess
 	}
-	return int(b[0]), true
+	if nonblock || !cancellable {
+		return getter()
+	}
+
+	rpipe, wpipe, err := os.Pipe()
+	if err != nil {
+		// Fallback to blocking read without cancellation
+		return getter()
+	}
+	r.setCancel(func() {
+		wpipe.Write([]byte{0})
+	})
+	defer func() {
+		r.setCancel(nil)
+		rpipe.Close()
+		wpipe.Close()
+	}()
+
+	cancelFd := int(rpipe.Fd())
+	for range maxSelectTries {
+		var rfds unix.FdSet
+		limit := len(rfds.Bits) * unix.NFDBITS
+		if fd >= limit || cancelFd >= limit {
+			return getter()
+		}
+
+		rfds.Set(fd)
+		rfds.Set(cancelFd)
+		_, err := unix.Select(max(fd, cancelFd)+1, &rfds, nil, nil, nil)
+		if err != nil {
+			if err == syscall.EINTR {
+				continue
+			}
+			return 0, getCharError
+		}
+
+		if rfds.IsSet(cancelFd) {
+			return 0, getCharCancelled
+		}
+
+		if rfds.IsSet(fd) {
+			return getter()
+		}
+	}
+	return 0, getCharError
 }
 
 func (r *LightRenderer) Size() TermSize {

src/tui/light_windows.go

@@ -18,6 +18,7 @@ const (
 var (
 	consoleFlagsInput  = uint32(windows.ENABLE_VIRTUAL_TERMINAL_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_EXTENDED_FLAGS)
 	consoleFlagsOutput = uint32(windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING | windows.ENABLE_PROCESSED_OUTPUT | windows.DISABLE_NEWLINE_AUTO_RETURN)
+	counter            = uint64(0)
 )
 
 // IsLightRendererSupported checks to see if the Light renderer is supported
@@ -61,27 +62,11 @@ func (r *LightRenderer) initPlatform() error {
 	}
 	r.inHandle = uintptr(inHandle)
 
-	r.setupTerminal()
-
 	// channel for non-blocking reads. Buffer to make sure
 	// we get the ESC sets:
 	r.ttyinChannel = make(chan byte, 1024)
 
-	// the following allows for non-blocking IO.
-	// syscall.SetNonblock() is a NOOP under Windows.
-	go func() {
-		fd := int(r.inHandle)
-		b := make([]byte, 1)
-		for !r.closed.Get() {
-			// HACK: if run from PSReadline, something resets ConsoleMode to remove ENABLE_VIRTUAL_TERMINAL_INPUT.
-			_ = windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
-
-			_, err := util.Read(fd, b)
-			if err == nil {
-				r.ttyinChannel <- b[0]
-			}
-		}
-	}()
+	r.setupTerminal()
 
 	return nil
 }
@@ -91,27 +76,51 @@ func (r *LightRenderer) closePlatform() {
 	windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput)
 }
 
-func openTtyIn() (*os.File, error) {
+func openTtyIn(ttyDefault string) (*os.File, error) {
 	// not used
 	return nil, nil
 }
 
-func openTtyOut() (*os.File, error) {
+func openTtyOut(ttyDefault string) (*os.File, error) {
 	return os.Stderr, nil
 }
 
-func (r *LightRenderer) setupTerminal() error {
-	if err := windows.SetConsoleMode(windows.Handle(r.outHandle), consoleFlagsOutput); err != nil {
-		return err
-	}
-	return windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+func (r *LightRenderer) setupTerminal() {
+	windows.SetConsoleMode(windows.Handle(r.outHandle), consoleFlagsOutput)
+	windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+
+	// The following allows for non-blocking IO.
+	// syscall.SetNonblock() is a NOOP under Windows.
+	current := counter
+	go func() {
+		fd := int(r.inHandle)
+		b := make([]byte, 1)
+		for {
+			if _, err := util.Read(fd, b); err == nil {
+				r.mutex.Lock()
+				// This condition prevents the goroutine from running after the renderer
+				// has been closed or paused.
+				if current != counter {
+					r.mutex.Unlock()
+					break
+				}
+				r.ttyinChannel <- b[0]
+				// HACK: if run from PSReadline, something resets ConsoleMode to remove ENABLE_VIRTUAL_TERMINAL_INPUT.
+				windows.SetConsoleMode(windows.Handle(r.inHandle), consoleFlagsInput)
+				r.mutex.Unlock()
+			}
+		}
+	}()
 }
 
-func (r *LightRenderer) restoreTerminal() error {
-	if err := windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput); err != nil {
-		return err
-	}
-	return windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
+func (r *LightRenderer) restoreTerminal() {
+	r.mutex.Lock()
+	counter++
+	// We're setting ENABLE_VIRTUAL_TERMINAL_INPUT to allow escape sequences to be read during 'execute'.
+	// e.g. fzf --bind 'enter:execute:less {}'
+	windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput|windows.ENABLE_VIRTUAL_TERMINAL_INPUT)
+	windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
+	r.mutex.Unlock()
 }
 
 func (r *LightRenderer) Size() TermSize {
@@ -142,16 +151,33 @@ func (r *LightRenderer) findOffset() (row int, col int) {
 	return int(bufferInfo.CursorPosition.Y), int(bufferInfo.CursorPosition.X)
 }
 
-func (r *LightRenderer) getch(nonblock bool) (int, bool) {
-	if nonblock {
-		select {
-		case bc := <-r.ttyinChannel:
-			return int(bc), true
-		case <-time.After(timeoutInterval * time.Millisecond):
-			return 0, false
-		}
-	} else {
+func (r *LightRenderer) getch(cancellable bool, nonblock bool) (int, getCharResult) {
+	if !nonblock && !cancellable {
 		bc := <-r.ttyinChannel
-		return int(bc), true
+		return int(bc), getCharSuccess
+	}
+
+	var timeout <-chan time.Time
+	if nonblock {
+		timeout = time.After(timeoutInterval * time.Millisecond)
+	}
+
+	var cancel chan struct{}
+	if cancellable {
+		cancel = make(chan struct{})
+		r.setCancel(func() {
+			close(cancel)
+		})
+		defer r.setCancel(nil)
+	}
+
+	select {
+	case bc := <-r.ttyinChannel:
+		return int(bc), getCharSuccess
+	case <-cancel:
+		return 0, getCharCancelled
+	case <-timeout:
+		// NOTE: not really an error
+		return 0, getCharError
 	}
 }

src/tui/tcell.go

@@ -5,6 +5,7 @@ package tui
 import (
 	"os"
 	"regexp"
+	"strings"
 	"time"
 
 	"github.com/gdamore/tcell/v2"
@@ -36,22 +37,24 @@ func (p ColorPair) style() tcell.Style {
 	return style.Foreground(asTcellColor(p.Fg())).Background(asTcellColor(p.Bg()))
 }
 
-type Attr int32
-
 type TcellWindow struct {
-	color       bool
-	windowType  WindowType
-	top         int
-	left        int
-	width       int
-	height      int
-	normal      ColorPair
-	lastX       int
-	lastY       int
-	moveCursor  bool
-	borderStyle BorderStyle
-	uri         *string
-	params      *string
+	color         bool
+	windowType    WindowType
+	top           int
+	left          int
+	width         int
+	height        int
+	normal        ColorPair
+	lastX         int
+	lastY         int
+	moveCursor    bool
+	borderStyle   BorderStyle
+	uri           *string
+	params        *string
+	showCursor    bool
+	wrapSign      string
+	wrapSignWidth int
+	tabstop       int
 }
 
 func (w *TcellWindow) Top() int {
@@ -72,7 +75,9 @@ func (w *TcellWindow) Height() int {
 
 func (w *TcellWindow) Refresh() {
 	if w.moveCursor {
-		_screen.ShowCursor(w.left+w.lastX, w.top+w.lastY)
+		if w.showCursor {
+			_screen.ShowCursor(w.left+w.lastX, w.top+w.lastY)
+		}
 		w.moveCursor = false
 	}
 	w.lastX = 0
@@ -93,12 +98,17 @@ const (
 	Italic             = Attr(tcell.AttrItalic)
 )
 
-const (
-	AttrUndefined = Attr(0)
-	AttrRegular   = Attr(1 << 7)
-	AttrClear     = Attr(1 << 8)
-	BoldForce     = Attr(1 << 10)
-)
+func (r *FullscreenRenderer) Bell() {
+	_screen.Beep()
+}
+
+func (r *FullscreenRenderer) HideCursor() {
+	r.showCursor = false
+}
+
+func (r *FullscreenRenderer) ShowCursor() {
+	r.showCursor = true
+}
 
 func (r *FullscreenRenderer) PassThrough(str string) {
 	// No-op
@@ -141,15 +151,6 @@ func (c Color) Style() tcell.Color {
 	}
 }
 
-func (a Attr) Merge(b Attr) Attr {
-	if b&AttrRegular > 0 {
-		// Only keep bold attribute set by the system
-		return b | (a & BoldForce)
-	}
-
-	return a | b
-}
-
 // handle the following as private members of FullscreenRenderer instance
 // they are declared here to prevent introducing tcell library in non-windows builds
 var (
@@ -164,6 +165,9 @@ func (r *FullscreenRenderer) getScreen() (tcell.Screen, error) {
 		if e != nil {
 			return nil, e
 		}
+		if !r.showCursor {
+			s.HideCursor()
+		}
 		_screen = s
 	}
 	return _screen, nil
@@ -177,6 +181,7 @@ func (r *FullscreenRenderer) initScreen() error {
 	if e = s.Init(); e != nil {
 		return e
 	}
+	s.EnablePaste()
 	if r.mouse {
 		s.EnableMouse()
 	} else {
@@ -243,9 +248,14 @@ func (r *FullscreenRenderer) Size() TermSize {
 	return TermSize{lines, cols, 0, 0}
 }
 
-func (r *FullscreenRenderer) GetChar() Event {
+func (r *FullscreenRenderer) GetChar(cancellable bool) Event {
 	ev := _screen.PollEvent()
 	switch ev := ev.(type) {
+	case *tcell.EventPaste:
+		if ev.Start() {
+			return Event{BracketedPasteBegin, 0, nil}
+		}
+		return Event{BracketedPasteEnd, 0, nil}
 	case *tcell.EventResize:
 		// Ignore the first resize event
 		// https://github.com/gdamore/tcell/blob/v2.7.0/TUTORIAL.md?plain=1#L18
@@ -262,7 +272,11 @@ func (r *FullscreenRenderer) GetChar() Event {
 		// so mouse click is three consecutive events, but the first and last are indistinguishable from movement events (with released buttons)
 		// dragging has same structure, it only repeats the middle (main) event appropriately
 		x, y := ev.Position()
-		mod := ev.Modifiers() != 0
+
+		mod := ev.Modifiers()
+		ctrl := (mod & tcell.ModCtrl) > 0
+		alt := (mod & tcell.ModAlt) > 0
+		shift := (mod & tcell.ModShift) > 0
 
 		// since we dont have mouse down events (unlike LightRenderer), we need to track state in prevButton
 		prevButton, button := _prevMouseButton, ev.Buttons()
@@ -271,9 +285,9 @@ func (r *FullscreenRenderer) GetChar() Event {
 
 		switch {
 		case button&tcell.WheelDown != 0:
-			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, false, mod}}
+			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, false, ctrl, alt, shift}}
 		case button&tcell.WheelUp != 0:
-			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, false, mod}}
+			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, false, ctrl, alt, shift}}
 		case button&tcell.Button1 != 0:
 			double := false
 			if !drag {
@@ -296,9 +310,9 @@ func (r *FullscreenRenderer) GetChar() Event {
 				}
 			}
 			// fire single or double click event
-			return Event{Mouse, 0, &MouseEvent{y, x, 0, true, !double, double, mod}}
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, true, !double, double, ctrl, alt, shift}}
 		case button&tcell.Button2 != 0:
-			return Event{Mouse, 0, &MouseEvent{y, x, 0, false, true, false, mod}}
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, false, true, false, ctrl, alt, shift}}
 		default:
 			// double and single taps on Windows don't quite work due to
 			// the console acting on the events and not allowing us
@@ -307,7 +321,11 @@ func (r *FullscreenRenderer) GetChar() Event {
 			down := left || button&tcell.Button3 != 0
 			double := false
 
-			return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
+			// No need to report mouse movement events when no button is pressed
+			if drag {
+				return Event{Invalid, 0, nil}
+			}
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, ctrl, alt, shift}}
 		}
 
 		// process keyboard:
@@ -319,6 +337,8 @@ func (r *FullscreenRenderer) GetChar() Event {
 		shift := (mods & tcell.ModShift) > 0
 		ctrlAlt := ctrl && alt
 		altShift := alt && shift
+		ctrlShift := ctrl && shift
+		ctrlAltShift := ctrl && alt && shift
 
 		keyfn := func(r rune) Event {
 			if alt {
@@ -345,8 +365,11 @@ func (r *FullscreenRenderer) GetChar() Event {
 		case tcell.KeyCtrlH:
 			switch ev.Rune() {
 			case 0:
+				if ctrlAlt {
+					return Event{CtrlAltBackspace, 0, nil}
+				}
 				if ctrl {
-					return Event{Backspace, 0, nil}
+					return Event{CtrlBackspace, 0, nil}
 				}
 			case rune(tcell.KeyCtrlH):
 				switch {
@@ -407,6 +430,9 @@ func (r *FullscreenRenderer) GetChar() Event {
 			return Event{CtrlSlash, 0, nil}
 		// section 3: (Alt)+Backspace2
 		case tcell.KeyBackspace2:
+			if ctrl {
+				return Event{CtrlBackspace, 0, nil}
+			}
 			if alt {
 				return Event{AltBackspace, 0, nil}
 			}
@@ -414,9 +440,21 @@ func (r *FullscreenRenderer) GetChar() Event {
 
 		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
 		case tcell.KeyUp:
+			if ctrlAltShift {
+				return Event{CtrlAltShiftUp, 0, nil}
+			}
+			if ctrlAlt {
+				return Event{CtrlAltUp, 0, nil}
+			}
+			if ctrlShift {
+				return Event{CtrlShiftUp, 0, nil}
+			}
 			if altShift {
 				return Event{AltShiftUp, 0, nil}
 			}
+			if ctrl {
+				return Event{CtrlUp, 0, nil}
+			}
 			if shift {
 				return Event{ShiftUp, 0, nil}
 			}
@@ -425,9 +463,21 @@ func (r *FullscreenRenderer) GetChar() Event {
 			}
 			return Event{Up, 0, nil}
 		case tcell.KeyDown:
+			if ctrlAltShift {
+				return Event{CtrlAltShiftDown, 0, nil}
+			}
+			if ctrlAlt {
+				return Event{CtrlAltDown, 0, nil}
+			}
+			if ctrlShift {
+				return Event{CtrlShiftDown, 0, nil}
+			}
 			if altShift {
 				return Event{AltShiftDown, 0, nil}
 			}
+			if ctrl {
+				return Event{CtrlDown, 0, nil}
+			}
 			if shift {
 				return Event{ShiftDown, 0, nil}
 			}
@@ -436,9 +486,21 @@ func (r *FullscreenRenderer) GetChar() Event {
 			}
 			return Event{Down, 0, nil}
 		case tcell.KeyLeft:
+			if ctrlAltShift {
+				return Event{CtrlAltShiftLeft, 0, nil}
+			}
+			if ctrlAlt {
+				return Event{CtrlAltLeft, 0, nil}
+			}
+			if ctrlShift {
+				return Event{CtrlShiftLeft, 0, nil}
+			}
 			if altShift {
 				return Event{AltShiftLeft, 0, nil}
 			}
+			if ctrl {
+				return Event{CtrlLeft, 0, nil}
+			}
 			if shift {
 				return Event{ShiftLeft, 0, nil}
 			}
@@ -447,9 +509,21 @@ func (r *FullscreenRenderer) GetChar() Event {
 			}
 			return Event{Left, 0, nil}
 		case tcell.KeyRight:
+			if ctrlAltShift {
+				return Event{CtrlAltShiftRight, 0, nil}
+			}
+			if ctrlAlt {
+				return Event{CtrlAltRight, 0, nil}
+			}
+			if ctrlShift {
+				return Event{CtrlShiftRight, 0, nil}
+			}
 			if altShift {
 				return Event{AltShiftRight, 0, nil}
 			}
+			if ctrl {
+				return Event{CtrlRight, 0, nil}
+			}
 			if shift {
 				return Event{ShiftRight, 0, nil}
 			}
@@ -462,20 +536,119 @@ func (r *FullscreenRenderer) GetChar() Event {
 		case tcell.KeyInsert:
 			return Event{Insert, 0, nil}
 		case tcell.KeyHome:
+			if ctrlAltShift {
+				return Event{CtrlAltShiftHome, 0, nil}
+			}
+			if ctrlAlt {
+				return Event{CtrlAltHome, 0, nil}
+			}
+			if ctrlShift {
+				return Event{CtrlShiftHome, 0, nil}
+			}
+			if altShift {
+				return Event{AltShiftHome, 0, nil}
+			}
+			if ctrl {
+				return Event{CtrlHome, 0, nil}
+			}
+			if shift {
+				return Event{ShiftHome, 0, nil}
+			}
+			if alt {
+				return Event{AltHome, 0, nil}
+			}
 			return Event{Home, 0, nil}
 		case tcell.KeyDelete:
+			if ctrlAltShift {
+				return Event{CtrlAltShiftDelete, 0, nil}
+			}
+			if ctrlAlt {
+				return Event{CtrlAltDelete, 0, nil}
+			}
+			if ctrlShift {
+				return Event{CtrlShiftDelete, 0, nil}
+			}
+			if altShift {
+				return Event{AltShiftDelete, 0, nil}
+			}
 			if ctrl {
 				return Event{CtrlDelete, 0, nil}
 			}
+			if alt {
+				return Event{AltDelete, 0, nil}
+			}
 			if shift {
 				return Event{ShiftDelete, 0, nil}
 			}
 			return Event{Delete, 0, nil}
 		case tcell.KeyEnd:
+			if ctrlAltShift {
+				return Event{CtrlAltShiftEnd, 0, nil}
+			}
+			if ctrlAlt {
+				return Event{CtrlAltEnd, 0, nil}
+			}
+			if ctrlShift {
+				return Event{CtrlShiftEnd, 0, nil}
+			}
+			if altShift {
+				return Event{AltShiftEnd, 0, nil}
+			}
+			if ctrl {
+				return Event{CtrlEnd, 0, nil}
+			}
+			if shift {
+				return Event{ShiftEnd, 0, nil}
+			}
+			if alt {
+				return Event{AltEnd, 0, nil}
+			}
 			return Event{End, 0, nil}
 		case tcell.KeyPgUp:
+			if ctrlAltShift {
+				return Event{CtrlAltShiftPageUp, 0, nil}
+			}
+			if ctrlAlt {
+				return Event{CtrlAltPageUp, 0, nil}
+			}
+			if ctrlShift {
+				return Event{CtrlShiftPageUp, 0, nil}
+			}
+			if altShift {
+				return Event{AltShiftPageUp, 0, nil}
+			}
+			if ctrl {
+				return Event{CtrlPageUp, 0, nil}
+			}
+			if shift {
+				return Event{ShiftPageUp, 0, nil}
+			}
+			if alt {
+				return Event{AltPageUp, 0, nil}
+			}
 			return Event{PageUp, 0, nil}
 		case tcell.KeyPgDn:
+			if ctrlAltShift {
+				return Event{CtrlAltShiftPageDown, 0, nil}
+			}
+			if ctrlAlt {
+				return Event{CtrlAltPageDown, 0, nil}
+			}
+			if ctrlShift {
+				return Event{CtrlShiftPageDown, 0, nil}
+			}
+			if altShift {
+				return Event{AltShiftPageDown, 0, nil}
+			}
+			if ctrl {
+				return Event{CtrlPageDown, 0, nil}
+			}
+			if shift {
+				return Event{ShiftPageDown, 0, nil}
+			}
+			if alt {
+				return Event{AltPageDown, 0, nil}
+			}
 			return Event{PageDown, 0, nil}
 		case tcell.KeyBacktab:
 			return Event{ShiftTab, 0, nil}
@@ -532,20 +705,25 @@ func (r *FullscreenRenderer) GetChar() Event {
 	return Event{Invalid, 0, nil}
 }
 
+func (r *FullscreenRenderer) CancelGetChar() {
+	// TODO
+}
+
 func (r *FullscreenRenderer) Pause(clear bool) {
 	if clear {
-		_screen.Fini()
+		_screen.Suspend()
 	}
 }
 
 func (r *FullscreenRenderer) Resume(clear bool, sigcont bool) {
 	if clear {
-		r.initScreen()
+		_screen.Resume()
 	}
 }
 
 func (r *FullscreenRenderer) Close() {
 	_screen.Fini()
+	_screen = nil
 }
 
 func (r *FullscreenRenderer) RefreshWindows(windows []Window) {
@@ -557,14 +735,16 @@ func (r *FullscreenRenderer) RefreshWindows(windows []Window) {
 }
 
 func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, windowType WindowType, borderStyle BorderStyle, erase bool) Window {
-	width = util.Max(0, width)
-	height = util.Max(0, height)
+	width = max(0, width)
+	height = max(0, height)
 	normal := ColBorder
 	switch windowType {
 	case WindowList:
 		normal = ColNormal
 	case WindowHeader:
 		normal = ColHeader
+	case WindowFooter:
+		normal = ColFooter
 	case WindowInput:
 		normal = ColInput
 	case WindowPreview:
@@ -578,7 +758,9 @@ func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int,
 		width:       width,
 		height:      height,
 		normal:      normal,
-		borderStyle: borderStyle}
+		borderStyle: borderStyle,
+		showCursor:  r.showCursor,
+		tabstop:     r.tabstop}
 	w.Erase()
 	return w
 }
@@ -601,6 +783,11 @@ func (w *TcellWindow) EraseMaybe() bool {
 	return true
 }
 
+func (w *TcellWindow) SetWrapSign(sign string, width int) {
+	w.wrapSign = sign
+	w.wrapSignWidth = width
+}
+
 func (w *TcellWindow) EncloseX(x int) bool {
 	return x >= w.left && x < (w.left+w.width)
 }
@@ -641,6 +828,21 @@ func (w *TcellWindow) withUrl(style tcell.Style) tcell.Style {
 	return style
 }
 
+func underlineStyleFromAttr(a Attr) tcell.UnderlineStyle {
+	switch a.UnderlineStyle() {
+	case UlStyleDouble:
+		return tcell.UnderlineStyleDouble
+	case UlStyleCurly:
+		return tcell.UnderlineStyleCurly
+	case UlStyleDotted:
+		return tcell.UnderlineStyleDotted
+	case UlStyleDashed:
+		return tcell.UnderlineStyleDashed
+	default:
+		return tcell.UnderlineStyleSolid
+	}
+}
+
 func (w *TcellWindow) printString(text string, pair ColorPair) {
 	lx := 0
 	a := pair.Attr()
@@ -649,11 +851,18 @@ func (w *TcellWindow) printString(text string, pair ColorPair) {
 	if a&AttrClear == 0 {
 		style = style.
 			Reverse(a&Attr(tcell.AttrReverse) != 0).
-			Underline(a&Attr(tcell.AttrUnderline) != 0).
 			StrikeThrough(a&Attr(tcell.AttrStrikeThrough) != 0).
 			Italic(a&Attr(tcell.AttrItalic) != 0).
 			Blink(a&Attr(tcell.AttrBlink) != 0).
 			Dim(a&Attr(tcell.AttrDim) != 0)
+		if a&Attr(tcell.AttrUnderline) != 0 {
+			style = style.Underline(underlineStyleFromAttr(a))
+			if pair.Ul() != colDefault {
+				style = style.Underline(asTcellColor(pair.Ul()))
+			}
+		} else {
+			style = style.Underline(false)
+		}
 	}
 	style = w.withUrl(style)
 
@@ -688,10 +897,8 @@ func (w *TcellWindow) CPrint(pair ColorPair, text string) {
 	w.printString(text, pair)
 }
 
-func (w *TcellWindow) fillString(text string, pair ColorPair) FillReturn {
-	lx := 0
+func (w *TcellWindow) pairStyle(pair ColorPair) tcell.Style {
 	a := pair.Attr()
-
 	var style tcell.Style
 	if w.color {
 		style = pair.style()
@@ -703,49 +910,73 @@ func (w *TcellWindow) fillString(text string, pair ColorPair) FillReturn {
 		Bold(a&Attr(tcell.AttrBold) != 0 || a&BoldForce != 0).
 		Dim(a&Attr(tcell.AttrDim) != 0).
 		Reverse(a&Attr(tcell.AttrReverse) != 0).
-		Underline(a&Attr(tcell.AttrUnderline) != 0).
 		StrikeThrough(a&Attr(tcell.AttrStrikeThrough) != 0).
 		Italic(a&Attr(tcell.AttrItalic) != 0)
-	style = w.withUrl(style)
+	if a&Attr(tcell.AttrUnderline) != 0 {
+		style = style.Underline(underlineStyleFromAttr(a))
+		if pair.Ul() != colDefault {
+			style = style.Underline(asTcellColor(pair.Ul()))
+		}
+	} else {
+		style = style.Underline(false)
+	}
+	return w.withUrl(style)
+}
 
+func (w *TcellWindow) renderGraphemes(text string, style tcell.Style) {
 	gr := uniseg.NewGraphemes(text)
-Loop:
 	for gr.Next() {
 		st := style
 		rs := gr.Runes()
-		if len(rs) == 1 {
-			r := rs[0]
-			switch r {
-			case '\r':
-				st = style.Dim(true)
-				rs[0] = '␍'
-			case '\n':
+		if len(rs) == 1 && rs[0] == '\r' {
+			st = style.Dim(true)
+			rs[0] = '␍'
+		}
+
+		xPos := w.left + w.lastX
+		yPos := w.top + w.lastY
+		if xPos < (w.left+w.width) && yPos < (w.top+w.height) {
+			_screen.SetContent(xPos, yPos, rs[0], rs[1:], st)
+		}
+		w.lastX += util.StringWidth(string(rs))
+	}
+}
+
+func (w *TcellWindow) renderWrapSign(style tcell.Style) {
+	sign := w.wrapSign
+	if w.wrapSignWidth > w.width {
+		runes, _ := util.Truncate(sign, w.width)
+		sign = string(runes)
+	}
+	gr := uniseg.NewGraphemes(sign)
+	for gr.Next() {
+		rs := gr.Runes()
+		_screen.SetContent(w.left+w.lastX, w.top+w.lastY, rs[0], rs[1:], style.Dim(true))
+		w.lastX += uniseg.StringWidth(string(rs))
+	}
+}
+
+func (w *TcellWindow) fillString(text string, pair ColorPair) FillReturn {
+	style := w.pairStyle(pair)
+
+	for i, segment := range strings.Split(text, "\n") {
+		for j, wl := range WrapLine(segment, w.lastX, w.width, w.tabstop, w.wrapSignWidth) {
+			if i > 0 || j > 0 {
 				w.lastY++
+				if w.lastY >= w.height {
+					return FillSuspend
+				}
 				w.lastX = 0
-				lx = 0
-				continue Loop
+				if j > 0 {
+					w.renderWrapSign(style)
+				}
+			}
+			if w.lastX < w.width {
+				w.renderGraphemes(wl.Text, style)
 			}
 		}
-
-		// word wrap:
-		xPos := w.left + w.lastX + lx
-		if xPos >= (w.left + w.width) {
-			w.lastY++
-			w.lastX = 0
-			lx = 0
-			xPos = w.left
-		}
-
-		yPos := w.top + w.lastY
-		if yPos >= (w.top + w.height) {
-			return FillSuspend
-		}
-
-		_screen.SetContent(xPos, yPos, rs[0], rs[1:], st)
-		lx += util.StringWidth(string(rs))
 	}
-	w.lastX += lx
-	if w.lastX == w.width {
+	if w.lastX >= w.width {
 		w.lastY++
 		w.lastX = 0
 		return FillNextLine
@@ -768,14 +999,14 @@ func (w *TcellWindow) LinkEnd() {
 	w.params = nil
 }
 
-func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
+func (w *TcellWindow) CFill(fg Color, bg Color, ul Color, a Attr, str string) FillReturn {
 	if fg == colDefault {
 		fg = w.normal.Fg()
 	}
 	if bg == colDefault {
 		bg = w.normal.Bg()
 	}
-	return w.fillString(str, NewColorPair(fg, bg, a))
+	return w.fillString(str, NewColorPair(fg, bg, a).WithUl(ul))
 }
 
 func (w *TcellWindow) DrawBorder() {
@@ -786,6 +1017,115 @@ func (w *TcellWindow) DrawHBorder() {
 	w.drawBorder(true)
 }
 
+// borderStyleFor returns the tcell.Style used to draw borders for `wt`, honoring
+// whether the window is rendering with colors.
+func (w *TcellWindow) borderStyleFor(wt WindowType) tcell.Style {
+	if !w.color {
+		return w.normal.style()
+	}
+	return BorderColor(wt).style()
+}
+
+// drawHLine fills row `y` with `line` between optional left/right caps.
+// A zero rune means "no cap"; caps are placed at the very edges of `w`.
+// tcell has an issue displaying two overlapping wide runes, so the line
+// stops before the cap position rather than overpainting.
+func (w *TcellWindow) drawHLine(y int, line, leftCap, rightCap rune, style tcell.Style) {
+	left := w.left
+	right := left + w.width
+	hw := runeWidth(line)
+	lw := 0
+	rw := 0
+	if leftCap != 0 {
+		lw = runeWidth(leftCap)
+	}
+	if rightCap != 0 {
+		rw = runeWidth(rightCap)
+	}
+	for x := left + lw; x <= right-rw-hw; x += hw {
+		_screen.SetContent(x, y, line, nil, style)
+	}
+	if leftCap != 0 {
+		_screen.SetContent(left, y, leftCap, nil, style)
+	}
+	if rightCap != 0 {
+		_screen.SetContent(right-rw, y, rightCap, nil, style)
+	}
+}
+
+func (w *TcellWindow) DrawHSeparator(row int, windowType WindowType, useBottom bool) {
+	if w.height == 0 {
+		return
+	}
+	shape := w.borderStyle.shape
+	if shape == BorderNone {
+		return
+	}
+	style := w.borderStyleFor(windowType)
+	line := w.borderStyle.top
+	if useBottom {
+		line = w.borderStyle.bottom
+	}
+	var leftCap, rightCap rune
+	if shape.HasLeft() {
+		leftCap = w.borderStyle.leftMid
+	}
+	if shape.HasRight() {
+		rightCap = w.borderStyle.rightMid
+	}
+	w.drawHLine(w.top+row, line, leftCap, rightCap, style)
+}
+
+func (w *TcellWindow) PaintSectionFrame(topContent, bottomContent int, windowType WindowType, edge SectionEdge) {
+	if w.height == 0 {
+		return
+	}
+	shape := w.borderStyle.shape
+	if shape == BorderNone {
+		return
+	}
+	style := w.borderStyleFor(windowType)
+	left := w.left
+	right := left + w.width
+	hasLeft := shape.HasLeft()
+	hasRight := shape.HasRight()
+	leftW := runeWidth(w.borderStyle.left)
+	rightW := runeWidth(w.borderStyle.right)
+	// Content rows: overpaint the left and right verticals (+ their 1-char margin) in
+	// the section's color. Inner margin stays at whatever bg the sub-window set.
+	for row := topContent; row <= bottomContent; row++ {
+		y := w.top + row
+		if hasLeft {
+			_screen.SetContent(left, y, w.borderStyle.left, nil, style)
+			_screen.SetContent(left+leftW, y, ' ', nil, style)
+		}
+		if hasRight {
+			_screen.SetContent(right-rightW-1, y, ' ', nil, style)
+			_screen.SetContent(right-rightW, y, w.borderStyle.right, nil, style)
+		}
+	}
+	if edge == SectionEdgeTop && shape.HasTop() {
+		var leftCap, rightCap rune
+		if hasLeft {
+			leftCap = w.borderStyle.topLeft
+		}
+		if hasRight {
+			rightCap = w.borderStyle.topRight
+		}
+		w.drawHLine(w.top, w.borderStyle.top, leftCap, rightCap, style)
+	}
+	if edge == SectionEdgeBottom && shape.HasBottom() {
+		var leftCap, rightCap rune
+		if hasLeft {
+			leftCap = w.borderStyle.bottomLeft
+		}
+		if hasRight {
+			rightCap = w.borderStyle.bottomRight
+		}
+		w.drawHLine(w.top+w.height-1, w.borderStyle.bottom, leftCap, rightCap, style)
+	}
+}
+
 func (w *TcellWindow) drawBorder(onlyHorizontal bool) {
 	if w.height == 0 {
 		return
@@ -800,70 +1140,44 @@ func (w *TcellWindow) drawBorder(onlyHorizontal bool) {
 	top := w.top
 	bot := top + w.height
 
-	var style tcell.Style
-	if w.color {
-		switch w.windowType {
-		case WindowBase:
-			style = ColBorder.style()
-		case WindowList:
-			style = ColListBorder.style()
-		case WindowHeader:
-			style = ColHeaderBorder.style()
-		case WindowInput:
-			style = ColInputBorder.style()
-		case WindowPreview:
-			style = ColPreviewBorder.style()
-		}
-	} else {
-		style = w.normal.style()
-	}
+	style := w.borderStyleFor(w.windowType)
 
-	hw := runeWidth(w.borderStyle.top)
-	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderTop:
-		max := right - 2*hw
-		if shape == BorderHorizontal || shape == BorderTop {
-			max = right - hw
+	hasLeft := shape.HasLeft()
+	hasRight := shape.HasRight()
+
+	if shape.HasTop() {
+		var leftCap, rightCap rune
+		if hasLeft {
+			leftCap = w.borderStyle.topLeft
 		}
-		// tcell has an issue displaying two overlapping wide runes
-		// e.g.  SetContent(  HH  )
-		//       SetContent(   TR )
-		//       ==================
-		//                 (  HH  ) => TR is ignored
-		for x := left; x <= max; x += hw {
-			_screen.SetContent(x, top, w.borderStyle.top, nil, style)
+		if hasRight {
+			rightCap = w.borderStyle.topRight
 		}
+		w.drawHLine(top, w.borderStyle.top, leftCap, rightCap, style)
 	}
-	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderBottom:
-		max := right - 2*hw
-		if shape == BorderHorizontal || shape == BorderBottom {
-			max = right - hw
+	if shape.HasBottom() {
+		var leftCap, rightCap rune
+		if hasLeft {
+			leftCap = w.borderStyle.bottomLeft
 		}
-		for x := left; x <= max; x += hw {
-			_screen.SetContent(x, bot-1, w.borderStyle.bottom, nil, style)
+		if hasRight {
+			rightCap = w.borderStyle.bottomRight
 		}
+		w.drawHLine(bot-1, w.borderStyle.bottom, leftCap, rightCap, style)
 	}
 	if !onlyHorizontal {
-		switch shape {
-		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderLeft:
-			for y := top; y < bot; y++ {
+		vw := runeWidth(w.borderStyle.right)
+		for y := top; y < bot; y++ {
+			// Corner rows are already painted by drawHLine above / below.
+			if (y == top && shape.HasTop()) || (y == bot-1 && shape.HasBottom()) {
+				continue
+			}
+			if hasLeft {
 				_screen.SetContent(left, y, w.borderStyle.left, nil, style)
 			}
-		}
-		switch shape {
-		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderRight:
-			vw := runeWidth(w.borderStyle.right)
-			for y := top; y < bot; y++ {
+			if hasRight {
 				_screen.SetContent(right-vw, y, w.borderStyle.right, nil, style)
 			}
 		}
 	}
-	switch shape {
-	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble:
-		_screen.SetContent(left, top, w.borderStyle.topLeft, nil, style)
-		_screen.SetContent(right-runeWidth(w.borderStyle.topRight), top, w.borderStyle.topRight, nil, style)
-		_screen.SetContent(left, bot-1, w.borderStyle.bottomLeft, nil, style)
-		_screen.SetContent(right-runeWidth(w.borderStyle.bottomRight), bot-1, w.borderStyle.bottomRight, nil, style)
-	}
 }

src/tui/tcell_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/junegunn/fzf/src/util"
 )
 
-func assert(t *testing.T, context string, got interface{}, want interface{}) bool {
+func assert(t *testing.T, context string, got any, want any) bool {
 	if got == want {
 		return true
 	} else {
@@ -82,9 +82,9 @@ func TestGetCharEventKey(t *testing.T) {
 		{giveKey{tcell.KeyTab, rune(tcell.KeyTab), tcell.ModNone}, wantKey{Tab, 0, nil}},     // unhandled, actual "Tab" keystroke
 		{giveKey{tcell.KeyTAB, rune(tcell.KeyTAB), tcell.ModNone}, wantKey{Tab, 0, nil}},     // fabricated, unhandled
 		// KeyEnter is alias for KeyCR
-		{giveKey{tcell.KeyCtrlM, rune(tcell.KeyCtrlM), tcell.ModNone}, wantKey{CtrlM, 0, nil}}, // actual "Enter" keystroke
-		{giveKey{tcell.KeyCR, rune(tcell.KeyCR), tcell.ModNone}, wantKey{CtrlM, 0, nil}},       // fabricated, unhandled
-		{giveKey{tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone}, wantKey{CtrlM, 0, nil}}, // fabricated, unhandled
+		{giveKey{tcell.KeyCtrlM, rune(tcell.KeyCtrlM), tcell.ModNone}, wantKey{Enter, 0, nil}}, // actual "Enter" keystroke
+		{giveKey{tcell.KeyCR, rune(tcell.KeyCR), tcell.ModNone}, wantKey{Enter, 0, nil}},       // fabricated, unhandled
+		{giveKey{tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone}, wantKey{Enter, 0, nil}}, // fabricated, unhandled
 		// Ctrl+Alt keys
 		{giveKey{tcell.KeyCtrlA, rune(tcell.KeyCtrlA), tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAlt, 'a', nil}},                  // fabricated
 		{giveKey{tcell.KeyCtrlA, rune(tcell.KeyCtrlA), tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{CtrlAlt, 'a', nil}}, // fabricated
@@ -107,18 +107,20 @@ func TestGetCharEventKey(t *testing.T) {
 		{giveKey{tcell.KeyBackspace2, 0, tcell.ModAlt}, wantKey{AltBackspace, 0, nil}}, // fabricated
 		{giveKey{tcell.KeyDEL, 0, tcell.ModNone}, wantKey{Backspace, 0, nil}},          // fabricated, unhandled
 		{giveKey{tcell.KeyDelete, 0, tcell.ModNone}, wantKey{Delete, 0, nil}},
-		{giveKey{tcell.KeyDelete, 0, tcell.ModAlt}, wantKey{Delete, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModAlt}, wantKey{AltDelete, 0, nil}},
+		{giveKey{tcell.KeyBackspace, 0, tcell.ModCtrl}, wantKey{CtrlBackspace, 0, nil}},
+		{giveKey{tcell.KeyBackspace, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltBackspace, 0, nil}},
 		{giveKey{tcell.KeyBackspace, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                  // fabricated, unhandled
 		{giveKey{tcell.KeyBS, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                         // fabricated, unhandled
 		{giveKey{tcell.KeyCtrlH, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                      // fabricated, unhandled
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModNone}, wantKey{Backspace, 0, nil}},                                 // actual "Backspace" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModAlt}, wantKey{AltBackspace, 0, nil}},                               // actual "Alt+Backspace" keystroke
-		{giveKey{tcell.KeyDEL, rune(tcell.KeyDEL), tcell.ModCtrl}, wantKey{Backspace, 0, nil}},                                     // actual "Ctrl+Backspace" keystroke
+		{giveKey{tcell.KeyDEL, rune(tcell.KeyDEL), tcell.ModCtrl}, wantKey{CtrlBackspace, 0, nil}},                                 // actual "Ctrl+Backspace" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift}, wantKey{Backspace, 0, nil}},                                // actual "Shift+Backspace" keystroke
-		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{Backspace, 0, nil}},                                     // actual "Ctrl+Alt+Backspace" keystroke
-		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{Backspace, 0, nil}},                                   // actual "Ctrl+Shift+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltBackspace, 0, nil}},                              // actual "Ctrl+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlBackspace, 0, nil}},                               // actual "Ctrl+Shift+Backspace" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift | tcell.ModAlt}, wantKey{AltBackspace, 0, nil}},              // actual "Shift+Alt+Backspace" keystroke
-		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{Backspace, 0, nil}},                    // actual "Ctrl+Shift+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{CtrlAltBackspace, 0, nil}},             // actual "Ctrl+Shift+Alt+Backspace" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl}, wantKey{CtrlH, 0, nil}},                                     // actual "Ctrl+H" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAlt, 'h', nil}},                  // fabricated "Ctrl+Alt+H" keystroke
 		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlH, 0, nil}},                    // actual "Ctrl+Shift+H" keystroke
@@ -126,9 +128,41 @@ func TestGetCharEventKey(t *testing.T) {
 
 		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
 		{giveKey{tcell.KeyUp, 0, tcell.ModNone}, wantKey{Up, 0, nil}},
-		{giveKey{tcell.KeyDown, 0, tcell.ModAlt}, wantKey{AltDown, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModNone}, wantKey{Down, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModNone}, wantKey{Left, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModNone}, wantKey{Right, 0, nil}},
+		{giveKey{tcell.KeyUp, 0, tcell.ModNone}, wantKey{Up, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModNone}, wantKey{Down, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModNone}, wantKey{Right, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModNone}, wantKey{Left, 0, nil}},
+		{giveKey{tcell.KeyUp, 0, tcell.ModCtrl}, wantKey{CtrlUp, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModCtrl}, wantKey{CtrlDown, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModCtrl}, wantKey{CtrlRight, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModCtrl}, wantKey{CtrlLeft, 0, nil}},
+		{giveKey{tcell.KeyUp, 0, tcell.ModShift}, wantKey{ShiftUp, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModShift}, wantKey{ShiftDown, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModShift}, wantKey{ShiftRight, 0, nil}},
 		{giveKey{tcell.KeyLeft, 0, tcell.ModShift}, wantKey{ShiftLeft, 0, nil}},
+		{giveKey{tcell.KeyUp, 0, tcell.ModAlt}, wantKey{AltUp, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModAlt}, wantKey{AltDown, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModAlt}, wantKey{AltRight, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModAlt}, wantKey{AltLeft, 0, nil}},
+		{giveKey{tcell.KeyUp, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlShiftUp, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlShiftDown, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlShiftRight, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlShiftLeft, 0, nil}},
+		{giveKey{tcell.KeyUp, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltUp, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltDown, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltRight, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltLeft, 0, nil}},
+		{giveKey{tcell.KeyUp, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftUp, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftDown, 0, nil}},
 		{giveKey{tcell.KeyRight, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftRight, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftLeft, 0, nil}},
+		{giveKey{tcell.KeyUp, 0, tcell.ModCtrl | tcell.ModShift | tcell.ModAlt}, wantKey{CtrlAltShiftUp, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModCtrl | tcell.ModShift | tcell.ModAlt}, wantKey{CtrlAltShiftDown, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModCtrl | tcell.ModShift | tcell.ModAlt}, wantKey{CtrlAltShiftRight, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModCtrl | tcell.ModShift | tcell.ModAlt}, wantKey{CtrlAltShiftLeft, 0, nil}},
 		{giveKey{tcell.KeyUpLeft, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},    // fabricated, unhandled
 		{giveKey{tcell.KeyUpRight, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},   // fabricated, unhandled
 		{giveKey{tcell.KeyDownLeft, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // fabricated, unhandled
@@ -137,6 +171,46 @@ func TestGetCharEventKey(t *testing.T) {
 		// section 5: (Insert|Home|Delete|End|PgUp|PgDn|BackTab|F1-F12)
 		{giveKey{tcell.KeyInsert, 0, tcell.ModNone}, wantKey{Insert, 0, nil}},
 		{giveKey{tcell.KeyF1, 0, tcell.ModNone}, wantKey{F1, 0, nil}},
+		{giveKey{tcell.KeyHome, 0, tcell.ModNone}, wantKey{Home, 0, nil}},
+		{giveKey{tcell.KeyEnd, 0, tcell.ModNone}, wantKey{End, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModNone}, wantKey{Delete, 0, nil}},
+		{giveKey{tcell.KeyPgUp, 0, tcell.ModNone}, wantKey{PageUp, 0, nil}},
+		{giveKey{tcell.KeyPgDn, 0, tcell.ModNone}, wantKey{PageDown, 0, nil}},
+		{giveKey{tcell.KeyHome, 0, tcell.ModCtrl}, wantKey{CtrlHome, 0, nil}},
+		{giveKey{tcell.KeyEnd, 0, tcell.ModCtrl}, wantKey{CtrlEnd, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModCtrl}, wantKey{CtrlDelete, 0, nil}},
+		{giveKey{tcell.KeyPgUp, 0, tcell.ModCtrl}, wantKey{CtrlPageUp, 0, nil}},
+		{giveKey{tcell.KeyPgDn, 0, tcell.ModCtrl}, wantKey{CtrlPageDown, 0, nil}},
+		{giveKey{tcell.KeyHome, 0, tcell.ModShift}, wantKey{ShiftHome, 0, nil}},
+		{giveKey{tcell.KeyEnd, 0, tcell.ModShift}, wantKey{ShiftEnd, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModShift}, wantKey{ShiftDelete, 0, nil}},
+		{giveKey{tcell.KeyPgUp, 0, tcell.ModShift}, wantKey{ShiftPageUp, 0, nil}},
+		{giveKey{tcell.KeyPgDn, 0, tcell.ModShift}, wantKey{ShiftPageDown, 0, nil}},
+		{giveKey{tcell.KeyHome, 0, tcell.ModAlt}, wantKey{AltHome, 0, nil}},
+		{giveKey{tcell.KeyEnd, 0, tcell.ModAlt}, wantKey{AltEnd, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModAlt}, wantKey{AltDelete, 0, nil}},
+		{giveKey{tcell.KeyPgUp, 0, tcell.ModAlt}, wantKey{AltPageUp, 0, nil}},
+		{giveKey{tcell.KeyPgDn, 0, tcell.ModAlt}, wantKey{AltPageDown, 0, nil}},
+		{giveKey{tcell.KeyHome, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlShiftHome, 0, nil}},
+		{giveKey{tcell.KeyEnd, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlShiftEnd, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlShiftDelete, 0, nil}},
+		{giveKey{tcell.KeyPgUp, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlShiftPageUp, 0, nil}},
+		{giveKey{tcell.KeyPgDn, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{CtrlShiftPageDown, 0, nil}},
+		{giveKey{tcell.KeyHome, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltHome, 0, nil}},
+		{giveKey{tcell.KeyEnd, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltEnd, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltDelete, 0, nil}},
+		{giveKey{tcell.KeyPgUp, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltPageUp, 0, nil}},
+		{giveKey{tcell.KeyPgDn, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{CtrlAltPageDown, 0, nil}},
+		{giveKey{tcell.KeyHome, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftHome, 0, nil}},
+		{giveKey{tcell.KeyEnd, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftEnd, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftDelete, 0, nil}},
+		{giveKey{tcell.KeyPgUp, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftPageUp, 0, nil}},
+		{giveKey{tcell.KeyPgDn, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftPageDown, 0, nil}},
+		{giveKey{tcell.KeyHome, 0, tcell.ModCtrl | tcell.ModShift | tcell.ModAlt}, wantKey{CtrlAltShiftHome, 0, nil}},
+		{giveKey{tcell.KeyEnd, 0, tcell.ModCtrl | tcell.ModShift | tcell.ModAlt}, wantKey{CtrlAltShiftEnd, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModCtrl | tcell.ModShift | tcell.ModAlt}, wantKey{CtrlAltShiftDelete, 0, nil}},
+		{giveKey{tcell.KeyPgUp, 0, tcell.ModCtrl | tcell.ModShift | tcell.ModAlt}, wantKey{CtrlAltShiftPageUp, 0, nil}},
+		{giveKey{tcell.KeyPgDn, 0, tcell.ModCtrl | tcell.ModShift | tcell.ModAlt}, wantKey{CtrlAltShiftPageDown, 0, nil}},
 		// section 6: (Ctrl+Alt)+'rune'
 		{giveKey{tcell.KeyRune, 'a', tcell.ModNone}, wantKey{Rune, 'a', nil}},
 		{giveKey{tcell.KeyRune, 'a', tcell.ModCtrl}, wantKey{Rune, 'a', nil}}, // fabricated
@@ -179,7 +253,7 @@ func TestGetCharEventKey(t *testing.T) {
 		{giveKey{tcell.KeyPause, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // unhandled
 
 	}
-	r := NewFullscreenRenderer(&ColorTheme{}, false, false)
+	r := NewFullscreenRenderer(&ColorTheme{}, false, false, 8)
 	r.Init()
 
 	// run and evaluate the tests
@@ -191,18 +265,22 @@ func TestGetCharEventKey(t *testing.T) {
 		t.Logf("giveEvent = %T{key: %v, ch: %q (%[3]v), mod: %#04b}\n", giveEvent, giveEvent.Key(), giveEvent.Rune(), giveEvent.Modifiers())
 
 		// process the event in fzf and evaluate the test
-		gotEvent := r.GetChar()
+		gotEvent := r.GetChar(true)
 		// skip Resize events, those are sometimes put in the buffer outside of this test
 		if initialResizeAsInvalid && gotEvent.Type == Invalid {
 			t.Logf("Resize as Invalid swallowed")
 			initialResizeAsInvalid = false
-			gotEvent = r.GetChar()
+			gotEvent = r.GetChar(true)
+		}
+		if gotEvent.Type == Resize {
+			t.Logf("Resize swallowed")
+			gotEvent = r.GetChar(true)
 		}
 		t.Logf("wantEvent = %T{Type: %v, Char: %q (%[3]v)}\n", test.wantKey, test.wantKey.Type, test.wantKey.Char)
 		t.Logf("gotEvent = %T{Type: %v, Char: %q (%[3]v)}\n", gotEvent, gotEvent.Type, gotEvent.Char)
 
-		assert(t, "r.GetChar().Type", gotEvent.Type, test.wantKey.Type)
-		assert(t, "r.GetChar().Char", gotEvent.Char, test.wantKey.Char)
+		assert(t, "r.GetChar(true).Type", gotEvent.Type, test.wantKey.Type)
+		assert(t, "r.GetChar(true).Char", gotEvent.Char, test.wantKey.Char)
 	}
 
 	r.Close()
@@ -233,7 +311,7 @@ Quick reference
 10	1	KeyCtrlJ	KeyLF = ^J		CtrlJ
 11	1	KeyCtrlK	KeyVT = ^K		CtrlK
 12	1	KeyCtrlL	KeyFF = ^L		CtrlL
-13	1	KeyCtrlM	KeyCR = ^M	KeyEnter	CtrlM
+13	1	KeyCtrlM	KeyCR = ^M	KeyEnter	Enter
 14	1	KeyCtrlN	KeySO = ^N		CtrlN
 15	1	KeyCtrlO	KeySI = ^O		CtrlO
 16	1	KeyCtrlP	KeyDLE = ^P		CtrlP

src/tui/ttyname_unix.go

@@ -44,11 +44,11 @@ func ttyname() string {
 }
 
 // TtyIn returns terminal device to read user input
-func TtyIn() (*os.File, error) {
-	return openTtyIn()
+func TtyIn(ttyDefault string) (*os.File, error) {
+	return openTtyIn(ttyDefault)
 }
 
-// TtyIn returns terminal device to write to
-func TtyOut() (*os.File, error) {
-	return openTtyOut()
+// TtyOut returns terminal device to write to
+func TtyOut(ttyDefault string) (*os.File, error) {
+	return openTtyOut(ttyDefault)
 }

src/tui/ttyname_windows.go

@@ -11,11 +11,11 @@ func ttyname() string {
 }
 
 // TtyIn on Windows returns os.Stdin
-func TtyIn() (*os.File, error) {
+func TtyIn(ttyDefault string) (*os.File, error) {
 	return os.Stdin, nil
 }
 
 // TtyOut on Windows returns nil
-func TtyOut() (*os.File, error) {
+func TtyOut(ttyDefault string) (*os.File, error) {
 	return nil, nil
 }

src/tui/tui_test.go

@@ -2,6 +2,46 @@ package tui
 
 import "testing"
 
+func TestWrapLine(t *testing.T) {
+	// Basic wrapping
+	lines := WrapLine("hello world", 0, 7, 8, 2)
+	if len(lines) != 2 || lines[0].Text != "hello w" || lines[1].Text != "orld" {
+		t.Errorf("Basic wrap: %v", lines)
+	}
+
+	// Exact fit - no wrapping needed
+	lines = WrapLine("hello", 0, 5, 8, 2)
+	if len(lines) != 1 || lines[0].Text != "hello" || lines[0].DisplayWidth != 5 {
+		t.Errorf("Exact fit: %v", lines)
+	}
+
+	// With prefix length
+	lines = WrapLine("hello", 3, 5, 8, 2)
+	if len(lines) != 2 || lines[0].Text != "he" || lines[1].Text != "llo" {
+		t.Errorf("Prefix length: %v", lines)
+	}
+
+	// Empty string
+	lines = WrapLine("", 0, 10, 8, 2)
+	if len(lines) != 1 || lines[0].Text != "" || lines[0].DisplayWidth != 0 {
+		t.Errorf("Empty string: %v", lines)
+	}
+
+	// Continuation lines account for wrapSignWidth
+	lines = WrapLine("abcdefghij", 0, 5, 8, 2)
+	// First line: "abcde" (5 chars fit in width 5)
+	// Continuation max: 5-2=3, so "fgh" then "ij"
+	if len(lines) != 3 || lines[0].Text != "abcde" || lines[1].Text != "fgh" || lines[2].Text != "ij" {
+		t.Errorf("Continuation: %v", lines)
+	}
+
+	// Tab expansion
+	lines = WrapLine("\there", 0, 10, 4, 2)
+	if len(lines) != 1 || lines[0].DisplayWidth != 8 {
+		t.Errorf("Tab: %v", lines)
+	}
+}
+
 func TestHexToColor(t *testing.T) {
 	assert := func(expr string, r, g, b int) {
 		color := HexToColor(expr)