Leverage existing bash completion

This is a PoC implementation for leveraging existing bash completion

git **<tab>
kubectl **<tab>

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: junegunn

.github/ISSUE_TEMPLATE/issue_template.yml

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

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "gomod"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+        interval: "weekly"

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,44 @@
+# https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning
+name: CodeQL
+
+on:
+  push:
+    branches: [ master, devel ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  analyze:
+    permissions:
+      actions: read  # for github/codeql-action/init to get workflow details
+      contents: read  # for actions/checkout to fetch code
+      security-events: write  # for github/codeql-action/autobuild to send a status report
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ['go']
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v3
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3

.github/workflows/depsreview.yaml

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

.github/workflows/linux.yml

@@ -0,0 +1,48 @@
+---
+name: Test fzf on Linux
+
+on:
+  push:
+    branches: [ master, devel ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  LANG: C.UTF-8
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: "1.20"
+
+    - name: Setup Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.1.0
+
+    - name: Install packages
+      run: sudo apt-get install --yes zsh fish tmux
+
+    - name: Install Ruby gems
+      run: sudo gem install --no-document minitest:5.25.1 rubocop:1.65.0 rubocop-minitest:0.35.1 rubocop-performance:1.21.1
+
+    - name: Rubocop
+      run: rubocop --require rubocop-minitest --require rubocop-performance
+
+    - name: Unit test
+      run: make test
+
+    - name: Integration test
+      run: make install && ./install --all && tmux new-session -d && ruby test/test_go.rb --verbose

.github/workflows/macos.yml

@@ -0,0 +1,45 @@
+---
+name: Test fzf on macOS
+
+on:
+  push:
+    branches: [ master, devel ]
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: "1.20"
+
+    - name: Setup Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0.0
+
+    - name: Install packages
+      run: HOMEBREW_NO_INSTALL_CLEANUP=1 brew install fish zsh tmux
+
+    - 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
+
+    - name: Rubocop
+      run: rubocop --require rubocop-minitest --require rubocop-performance
+
+    - name: Unit test
+      run: make test
+
+    - name: Integration test
+      run: make install && ./install --all && LC_ALL=C tmux new-session -d && ruby test/test_go.rb --verbose

.github/workflows/sponsors.yml

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

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

.github/workflows/winget.yml

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

.gitignore

@@ -1,3 +1,14 @@
+bin/fzf
+bin/fzf.exe
+dist
+target
 pkg
 Gemfile.lock
 .DS_Store
+doc/tags
+vendor
+gopath
+*.zwc
+fzf
+tmp
+*.patch

.goreleaser.yml

@@ -0,0 +1,104 @@
+---
+version: 2
+project_name: fzf
+
+before:
+  hooks:
+    - go mod download
+
+builds:
+  - id: fzf
+    goos:
+      - darwin
+      - linux
+      - windows
+      - freebsd
+      - openbsd
+    goarch:
+      - amd64
+      - arm
+      - arm64
+      - loong64
+      - ppc64le
+      - s390x
+    goarm:
+      - 5
+      - 6
+      - 7
+    flags:
+      - -trimpath
+    ldflags:
+      - "-s -w -X main.version={{ .Version }} -X main.revision={{ .ShortCommit }}"
+    ignore:
+      - goos: freebsd
+        goarch: arm
+      - goos: openbsd
+        goarch: arm
+      - goos: freebsd
+        goarch: arm64
+      - goos: openbsd
+        goarch: arm64
+
+# .goreleaser.yaml
+notarize:
+  macos:
+    - # Whether this configuration is enabled or not.
+      #
+      # Default: false.
+      # Templates: allowed.
+      enabled: "{{ not .IsSnapshot }}"
+
+      # Before notarizing, we need to sign the binary.
+      # This blocks defines the configuration for doing so.
+      sign:
+        # The .p12 certificate file path or its base64'd contents.
+        certificate: "{{.Env.MACOS_SIGN_P12}}"
+
+        # The password to be used to open the certificate.
+        password: "{{.Env.MACOS_SIGN_PASSWORD}}"
+
+      # Then, we notarize the binaries.
+      notarize:
+        # The issuer ID.
+        # Its the UUID you see when creating the App Store Connect key.
+        issuer_id: "{{.Env.MACOS_NOTARY_ISSUER_ID}}"
+
+        # Key ID.
+        # You can see it in the list of App Store Connect Keys.
+        # It will also be in the ApiKey filename.
+        key_id: "{{.Env.MACOS_NOTARY_KEY_ID}}"
+
+        # The .p8 key file path or its base64'd contents.
+        key: "{{.Env.MACOS_NOTARY_KEY}}"
+
+        # Whether to wait for the notarization to finish.
+        # Not recommended, as it could take a really long time.
+        wait: true
+
+archives:
+  - name_template: "{{ .ProjectName }}-{{ .Version }}-{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
+    builds:
+      - fzf
+    format: tar.gz
+    format_overrides:
+      - goos: windows
+        format: zip
+    files:
+      - non-existent*
+
+release:
+  github:
+    owner: junegunn
+    name: fzf
+  prerelease: auto
+  name_template: '{{ .Version }}'
+
+snapshot:
+  name_template: "{{ .Version }}-devel"
+
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - README
+      - test

.rubocop.yml

@@ -0,0 +1,32 @@
+Layout/LineLength:
+  Enabled: false
+Metrics:
+  Enabled: false
+Lint/ShadowingOuterLocalVariable:
+  Enabled: false
+Style/MethodCallWithArgsParentheses:
+  Enabled: true
+  AllowedMethods:
+    - assert
+    - exit
+    - paste
+    - puts
+    - raise
+    - refute
+    - require
+    - send_keys
+  AllowedPatterns:
+    - ^assert_
+    - ^refute_
+Style/NumericPredicate:
+  Enabled: false
+Style/StringConcatenation:
+  Enabled: false
+Style/OptionalBooleanParameter:
+  Enabled: false
+Style/WordArray:
+  MinSize: 1
+Minitest/AssertEqual:
+  Enabled: false
+Naming/VariableNumber:
+  Enabled: false

.tool-versions

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

ADVANCED.md

@@ -0,0 +1,676 @@
+Advanced fzf examples
+======================
+
+* *Last update: 2024/06/24*
+* *Requires fzf 0.54.0 or later*
+
+---
+
+<!-- vim-markdown-toc GFM -->
+
+* [Introduction](#introduction)
+* [Display modes](#display-modes)
+    * [`--height`](#--height)
+    * [`--tmux`](#--tmux)
+* [Dynamic reloading of the list](#dynamic-reloading-of-the-list)
+    * [Updating the list of processes by pressing CTRL-R](#updating-the-list-of-processes-by-pressing-ctrl-r)
+    * [Toggling between data sources](#toggling-between-data-sources)
+    * [Toggling with a single key binding](#toggling-with-a-single-key-binding)
+* [Ripgrep integration](#ripgrep-integration)
+    * [Using fzf as the secondary filter](#using-fzf-as-the-secondary-filter)
+    * [Using fzf as interactive Ripgrep launcher](#using-fzf-as-interactive-ripgrep-launcher)
+    * [Switching to fzf-only search mode](#switching-to-fzf-only-search-mode)
+    * [Switching between Ripgrep mode and fzf mode](#switching-between-ripgrep-mode-and-fzf-mode)
+    * [Switching between Ripgrep mode and fzf mode using a single key binding](#switching-between-ripgrep-mode-and-fzf-mode-using-a-single-key-binding)
+* [Log tailing](#log-tailing)
+* [Key bindings for git objects](#key-bindings-for-git-objects)
+    * [Files listed in `git status`](#files-listed-in-git-status)
+    * [Branches](#branches)
+    * [Commit hashes](#commit-hashes)
+* [Color themes](#color-themes)
+    * [fzf Theme Playground](#fzf-theme-playground)
+    * [Generating fzf color theme from Vim color schemes](#generating-fzf-color-theme-from-vim-color-schemes)
+
+<!-- vim-markdown-toc -->
+
+Introduction
+------------
+
+fzf is an interactive [Unix filter][filter] program that is designed to be
+used with other Unix tools. It reads a list of items from the standard input,
+allows you to select a subset of the items, and prints the selected ones to
+the standard output. You can think of it as an interactive version of *grep*,
+and it's already useful even if you don't know any of its options.
+
+```sh
+# 1. ps:   Feed the list of processes to fzf
+# 2. fzf:  Interactively select a process using fuzzy matching algorithm
+# 3. awk:  Take the PID from the selected line
+# 3. kill: Kill the process with the PID
+ps -ef | fzf | awk '{print $2}' | xargs kill -9
+```
+
+[filter]: https://en.wikipedia.org/wiki/Filter_(software)
+
+While the above example succinctly summarizes the fundamental concept of fzf,
+you can build much more sophisticated interactive workflows using fzf once you
+learn its wide variety of features.
+
+- To see the full list of options and features, see `man fzf`
+- To see the latest additions, see [CHANGELOG.md](CHANGELOG.md)
+
+This document will guide you through some examples that will familiarize you
+with the advanced features of fzf.
+
+Display modes
+-------------
+
+### `--height`
+
+fzf by default opens in fullscreen mode, but it's not always desirable.
+Oftentimes, you want to see the current context of the terminal while using
+fzf. `--height` is an option for opening fzf below the cursor in
+non-fullscreen mode so you can still see the previous commands and their
+results above it.
+
+```sh
+fzf --height=40%
+```
+
+![image](https://user-images.githubusercontent.com/700826/113379893-c184c680-93b5-11eb-9676-c7c0a2f01748.png)
+
+You might also want to experiment with other layout options such as
+`--layout=reverse`, `--info=inline`, `--border`, `--margin`, etc.
+
+```sh
+fzf --height=40% --layout=reverse
+fzf --height=40% --layout=reverse --info=inline
+fzf --height=40% --layout=reverse --info=inline --border
+fzf --height=40% --layout=reverse --info=inline --border --margin=1
+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)*
+
+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
+could write a wrapper script or shell alias, but there is an easier option.
+Define `$FZF_DEFAULT_OPTS` like so:
+
+```sh
+export FZF_DEFAULT_OPTS="--height=40% --layout=reverse --info=inline --border --margin=1 --padding=1"
+```
+
+### `--tmux`
+
+(Requires tmux 3.3 or later)
+
+If you're using tmux, you can open fzf in a tmux popup using `--tmux` option.
+
+```sh
+# Open fzf in a tmux popup at the center of the screen with 70% width and height
+fzf --tmux 70%
+```
+
+![image](https://github.com/junegunn/fzf/assets/700826/9c365405-c700-49b2-8985-60d822ed4cff)
+
+`--tmux` option is silently ignored if you're not on tmux. So if you're trying
+to avoid opening fzf in fullscreen, try specifying both `--height` and `--tmux`.
+
+```sh
+# --tmux is specified later so it takes precedence over --height when on tmux.
+# If you're not on tmux, --tmux is ignored and --height is used instead.
+fzf  --height 70% --tmux 70%
+```
+
+You can also specify the position, width, and height of the popup window in
+the following format:
+
+* `[center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]`
+
+```sh
+# 100% width and 60% height
+fzf --tmux 100%,60% --border horizontal
+```
+
+![image](https://github.com/junegunn/fzf/assets/700826/f80d3514-d69f-42f2-a8de-a392a562bfcf)
+
+```sh
+# On the right (50% width)
+fzf --tmux right
+```
+
+![image](https://github.com/junegunn/fzf/assets/700826/4033ade4-7efa-421b-a3fb-a430d197098a)
+
+```sh
+# On the left (40% width and 70% height)
+fzf --tmux left,40%,70%
+```
+
+![image](https://github.com/junegunn/fzf/assets/700826/efe43881-2bf0-49ea-ab2e-1377f778cd52)
+
+> [!TIP]
+> You might also want to check out my tmux plugins which support this popup
+> window layout.
+>
+> - https://github.com/junegunn/tmux-fzf-url
+> - https://github.com/junegunn/tmux-fzf-maccy
+
+Dynamic reloading of the list
+-----------------------------
+
+fzf can dynamically update the candidate list using an arbitrary program with
+`reload` bindings (The design document for `reload` can be found
+[here][reload]).
+
+[reload]: https://github.com/junegunn/fzf/issues/1750
+
+### Updating the list of processes by pressing CTRL-R
+
+This example shows how you can set up a binding for dynamically updating the
+list without restarting fzf.
+
+```sh
+(date; ps -ef) |
+  fzf --bind='ctrl-r:reload(date; ps -ef)' \
+      --header=$'Press CTRL-R to reload\n\n' --header-lines=2 \
+      --preview='echo {}' --preview-window=down,3,wrap \
+      --layout=reverse --height=80% | awk '{print $2}' | xargs kill -9
+```
+
+![image](https://user-images.githubusercontent.com/700826/113465047-200c7c00-946c-11eb-918c-268f37a900c8.png)
+
+- The initial command is `(date; ps -ef)`. It prints the current date and
+  time, and the list of the processes.
+- With `--header` option, you can show any message as the fixed header.
+- To disallow selecting the first two lines (`date` and `ps` header), we use
+  `--header-lines=2` option.
+- `--bind='ctrl-r:reload(date; ps -ef)'` binds CTRL-R to `reload` action that
+  runs `date; ps -ef`, so we can update the list of the processes by pressing
+  CTRL-R.
+- We use simple `echo {}` preview option, so we can see the entire line on the
+  preview window below even if it's too long
+
+### Toggling between data sources
+
+You're not limited to just one reload binding. Set up multiple bindings so
+you can switch between data sources.
+
+```sh
+find * | fzf --prompt 'All> ' \
+             --header 'CTRL-D: Directories / CTRL-F: Files' \
+             --bind 'ctrl-d:change-prompt(Directories> )+reload(find * -type d)' \
+             --bind 'ctrl-f:change-prompt(Files> )+reload(find * -type f)'
+```
+
+![image](https://user-images.githubusercontent.com/700826/113465073-4af6d000-946c-11eb-858f-2372c0955f67.png)
+
+![image](https://user-images.githubusercontent.com/700826/113465072-46321c00-946c-11eb-9b6f-cda3951df579.png)
+
+### Toggling with a single key binding
+
+The above example uses two different key bindings to toggle between two modes,
+but can we just use a single key binding?
+
+To make a key binding behave differently each time it is pressed, we need:
+
+1. a way to store the current state. i.e. "which mode are we in?"
+2. and a way to dynamically perform different actions depending on the state.
+
+The following example shows how to 1. store the current mode in the prompt
+string, 2. and use this information (`$FZF_PROMPT`) to determine which
+actions to perform using the `transform` action.
+
+```sh
+fd --type file |
+  fzf --prompt 'Files> ' \
+      --header 'CTRL-T: Switch between Files/Directories' \
+      --bind 'ctrl-t:transform:[[ ! $FZF_PROMPT =~ Files ]] &&
+              echo "change-prompt(Files> )+reload(fd --type file)" ||
+              echo "change-prompt(Directories> )+reload(fd --type directory)"' \
+      --preview '[[ $FZF_PROMPT =~ Files ]] && bat --color=always {} || tree -C {}'
+```
+
+Ripgrep integration
+-------------------
+
+### Using fzf as the secondary filter
+
+* Requires [bat][bat]
+* Requires [Ripgrep][rg]
+
+[bat]: https://github.com/sharkdp/bat
+[rg]: https://github.com/BurntSushi/ripgrep
+
+fzf is pretty fast for filtering a list that you will rarely have to think
+about its performance. But it is not the right tool for searching for text
+inside many large files, and in that case you should definitely use something
+like [Ripgrep][rg].
+
+In the next example, Ripgrep is the primary filter that searches for the given
+text in files, and fzf is used as the secondary fuzzy filter that adds
+interactivity to the workflow. And we use [bat][bat] to show the matching line in
+the preview window.
+
+This is a bash script and it will not run as expected on other non-compliant
+shells. To avoid the compatibility issue, let's save this snippet as a script
+file called `rfv`.
+
+```bash
+#!/usr/bin/env bash
+
+# 1. Search for text in files using Ripgrep
+# 2. Interactively narrow down the list using fzf
+# 3. Open the file in Vim
+rg --color=always --line-number --no-heading --smart-case "${*:-}" |
+  fzf --ansi \
+      --color "hl:-1:underline,hl+:-1:underline:reverse" \
+      --delimiter : \
+      --preview 'bat --color=always {1} --highlight-line {2}' \
+      --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
+      --bind 'enter:become(vim {1} +{2})'
+```
+
+And run it with an initial query string.
+
+```sh
+# Make the script executable
+chmod +x rfv
+
+# Run it with the initial query "algo"
+./rfv algo
+```
+
+> Ripgrep will perform the initial search and list all the lines that contain
+`algo`. Then we further narrow down the list on fzf.
+
+![image](https://user-images.githubusercontent.com/700826/113683873-a42a6200-96ff-11eb-9666-26ce4091b0e4.png)
+
+I know it's a lot to digest, let's try to break down the code.
+
+- Ripgrep prints the matching lines in the following format
+  ```
+  man/man1/fzf.1:54:.BI "--algo=" TYPE
+  man/man1/fzf.1:55:Fuzzy matching algorithm (default: v2)
+  man/man1/fzf.1:58:.BR v2 "     Optimal scoring algorithm (quality)"
+  src/pattern_test.go:7:  "github.com/junegunn/fzf/src/algo"
+  ```
+  The first token delimited by `:` is the file path, and the second token is
+  the line number of the matching line. They respectively correspond to `{1}`
+  and `{2}` in the preview command.
+    - `--preview 'bat --color=always {1} --highlight-line {2}'`
+- As we run `rg` with `--color=always` option, we should tell fzf to parse
+  ANSI color codes in the input by setting `--ansi`.
+- We customize how fzf colors various text elements using `--color` option.
+  `-1` tells fzf to keep the original color from the input. See `man fzf` for
+  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
+- 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
+      part of `bat` output
+        - ```
+          ───────┬──────────────────────────────────────────────────────────
+                 │ File: CHANGELOG.md
+          ───────┼──────────────────────────────────────────────────────────
+             1   │ CHANGELOG
+             2   │ =========
+             3   │
+             4   │ 0.26.0
+             5   │ ------
+          ```
+    - `/3` adjusts the offset so that the matching line is shown at a third
+      position in the window
+    - `~3` makes the top three lines fixed header so that they are always
+      visible regardless of the scroll offset
+- Instead of using shell script to process the final output of fzf, we use
+  `become(...)` action which was added in [fzf 0.38.0][0.38.0] to turn fzf
+  into a new process that opens the file with `vim` (`vim {1}`) and move the
+  cursor to the line (`+{2}`).
+
+[0.38.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0380
+
+### Using fzf as interactive Ripgrep launcher
+
+We have learned that we can bind `reload` action to a key (e.g.
+`--bind=ctrl-r:execute(ps -ef)`). In the next example, we are going to **bind
+`reload` action to `change` event** so that whenever the user *changes* the
+query string on fzf, `reload` action is triggered.
+
+Here is a variation of the above `rfv` script. fzf will restart Ripgrep every
+time the user updates the query string on fzf. Searching and filtering is
+completely done by Ripgrep, and fzf merely provides the interactive interface.
+So we lose the "fuzziness", but the performance will be better on larger
+projects, and it will free up memory as you narrow down the results.
+
+```bash
+#!/usr/bin/env bash
+
+# 1. Search for text in files using Ripgrep
+# 2. Interactively restart Ripgrep with reload action
+# 3. Open the file in Vim
+RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+INITIAL_QUERY="${*:-}"
+fzf --ansi --disabled --query "$INITIAL_QUERY" \
+    --bind "start:reload:$RG_PREFIX {q}" \
+    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
+    --delimiter : \
+    --preview 'bat --color=always {1} --highlight-line {2}' \
+    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
+    --bind 'enter:become(vim {1} +{2})'
+```
+
+![image](https://user-images.githubusercontent.com/700826/113684212-f9ff0a00-96ff-11eb-8737-7bb571d320cc.png)
+
+- Instead of starting fzf in the usual `rg ... | fzf` form, we make it start
+  the initial Ripgrep process immediately via `start:reload` binding for the
+  consistency of the code.
+- Filtering is no longer a responsibility of fzf; hence `--disabled`
+- `{q}` in the reload command evaluates to the query string on fzf prompt.
+- `sleep 0.1` in the reload command is for "debouncing". This small delay will
+  reduce the number of intermediate Ripgrep processes while we're typing in
+  a query.
+
+### Switching to fzf-only search mode
+
+In the previous example, we lost fuzzy matching capability as we completely
+delegated search functionality to Ripgrep. But we can dynamically switch to
+fzf-only search mode by *"unbinding"* `reload` action from `change` event.
+
+```sh
+#!/usr/bin/env bash
+
+# Two-phase filtering with Ripgrep and fzf
+#
+# 1. Search for text in files using Ripgrep
+# 2. Interactively restart Ripgrep with reload action
+#    * Press alt-enter to switch to fzf-only filtering
+# 3. Open the file in Vim
+RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+INITIAL_QUERY="${*:-}"
+fzf --ansi --disabled --query "$INITIAL_QUERY" \
+    --bind "start:reload:$RG_PREFIX {q}" \
+    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
+    --bind "alt-enter:unbind(change,alt-enter)+change-prompt(2. fzf> )+enable-search+clear-query" \
+    --color "hl:-1:underline,hl+:-1:underline:reverse" \
+    --prompt '1. ripgrep> ' \
+    --delimiter : \
+    --preview 'bat --color=always {1} --highlight-line {2}' \
+    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
+    --bind 'enter:become(vim {1} +{2})'
+```
+
+* Phase 1. Filtering with Ripgrep
+![image](https://user-images.githubusercontent.com/700826/119213880-735e8a80-bafd-11eb-8493-123e4be24fbc.png)
+* Phase 2. Filtering with fzf
+![image](https://user-images.githubusercontent.com/700826/119213887-7e191f80-bafd-11eb-98c9-71a1af9d7aab.png)
+
+- We added `--prompt` option to show that fzf is initially running in "Ripgrep
+  launcher mode".
+- We added `alt-enter` binding that
+    1. unbinds `change` event, so Ripgrep is no longer restarted on key press
+    2. changes the prompt to `2. fzf>`
+    3. enables search functionality of fzf
+    4. clears the current query string that was used to start Ripgrep process
+    5. and unbinds `alt-enter` itself as this is a one-off event
+- We reverted `--color` option for customizing how the matching chunks are
+  displayed in the second phase
+
+### Switching between Ripgrep mode and fzf mode
+
+[fzf 0.30.0][0.30.0] added `rebind` action so we can "rebind" the bindings
+that were previously "unbound" via `unbind`.
+
+This is an improved version of the previous example that allows us to switch
+between Ripgrep launcher mode and fzf-only filtering mode via CTRL-R and
+CTRL-F.
+
+```sh
+#!/usr/bin/env bash
+
+# Switch between Ripgrep launcher mode (CTRL-R) and fzf filtering mode (CTRL-F)
+rm -f /tmp/rg-fzf-{r,f}
+RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+INITIAL_QUERY="${*:-}"
+fzf --ansi --disabled --query "$INITIAL_QUERY" \
+    --bind "start:reload($RG_PREFIX {q})+unbind(ctrl-r)" \
+    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
+    --bind "ctrl-f:unbind(change,ctrl-f)+change-prompt(2. fzf> )+enable-search+rebind(ctrl-r)+transform-query(echo {q} > /tmp/rg-fzf-r; cat /tmp/rg-fzf-f)" \
+    --bind "ctrl-r:unbind(ctrl-r)+change-prompt(1. ripgrep> )+disable-search+reload($RG_PREFIX {q} || true)+rebind(change,ctrl-f)+transform-query(echo {q} > /tmp/rg-fzf-f; cat /tmp/rg-fzf-r)" \
+    --color "hl:-1:underline,hl+:-1:underline:reverse" \
+    --prompt '1. ripgrep> ' \
+    --delimiter : \
+    --header '╱ CTRL-R (ripgrep mode) ╱ CTRL-F (fzf mode) ╱' \
+    --preview 'bat --color=always {1} --highlight-line {2}' \
+    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
+    --bind 'enter:become(vim {1} +{2})'
+```
+
+- To restore the query string when switching between modes, we store the
+  current query in `/tmp/rg-fzf-{r,f}` files and restore the query using
+  `transform-query` action which was added in [fzf 0.36.0][0.36.0].
+- Also note that we unbind `ctrl-r` binding on `start` event which is
+  triggered once when fzf starts.
+
+[0.30.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0300
+[0.36.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0360
+
+### Switching between Ripgrep mode and fzf mode using a single key binding
+
+In contrast to the previous version, we use just one hotkey to toggle between
+ripgrep and fzf mode. This is achieved by using the `$FZF_PROMPT` as a state
+within the `transform` action, a feature introduced in [fzf 0.45.0][0.45.0]. A
+more detailed explanation of this feature can be found in a previous section -
+[Toggling with a single keybinding](#toggling-with-a-single-key-binding).
+
+[0.45.0]: https://github.com/junegunn/fzf/blob/master/CHANGELOG.md#0450
+
+When using the `transform` action, the placeholder (`\{q}`) should be escaped to
+prevent immediate evaluation.
+
+```sh
+#!/usr/bin/env bash
+
+# Switch between Ripgrep mode and fzf filtering mode (CTRL-T)
+rm -f /tmp/rg-fzf-{r,f}
+RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
+INITIAL_QUERY="${*:-}"
+fzf --ansi --disabled --query "$INITIAL_QUERY" \
+    --bind "start:reload:$RG_PREFIX {q}" \
+    --bind "change:reload:sleep 0.1; $RG_PREFIX {q} || true" \
+    --bind 'ctrl-t:transform:[[ ! $FZF_PROMPT =~ ripgrep ]] &&
+      echo "rebind(change)+change-prompt(1. ripgrep> )+disable-search+transform-query:echo \{q} > /tmp/rg-fzf-f; cat /tmp/rg-fzf-r" ||
+      echo "unbind(change)+change-prompt(2. fzf> )+enable-search+transform-query:echo \{q} > /tmp/rg-fzf-r; cat /tmp/rg-fzf-f"' \
+    --color "hl:-1:underline,hl+:-1:underline:reverse" \
+    --prompt '1. ripgrep> ' \
+    --delimiter : \
+    --header 'CTRL-T: Switch between ripgrep/fzf' \
+    --preview 'bat --color=always {1} --highlight-line {2}' \
+    --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' \
+    --bind 'enter:become(vim {1} +{2})'
+```
+
+Log tailing
+-----------
+
+fzf can run long-running preview commands and render partial results before
+completion. And when you specify `follow` flag in `--preview-window` option,
+fzf will "`tail -f`" the result, automatically scrolling to the bottom.
+
+```bash
+# With "follow", preview window will automatically scroll to the bottom.
+# "\033[2J" is an ANSI escape sequence for clearing the screen.
+# When fzf reads this code it clears the previous preview contents.
+fzf --preview-window follow --preview 'for i in $(seq 100000); do
+  echo "$i"
+  sleep 0.01
+  (( i % 300 == 0 )) && printf "\033[2J"
+done'
+```
+
+![image](https://user-images.githubusercontent.com/700826/113473303-dd669600-94a3-11eb-88a9-1f61b996bb0e.png)
+
+Admittedly, that was a silly example. Here's a practical one for browsing
+Kubernetes pods.
+
+```bash
+pods() {
+  command='kubectl get pods --all-namespaces' fzf \
+    --info=inline --layout=reverse --header-lines=1 \
+    --prompt "$(kubectl config current-context | sed 's/-context$//')> " \
+    --header $'╱ Enter (kubectl exec) ╱ CTRL-O (open log in editor) ╱ CTRL-R (reload) ╱\n\n' \
+    --bind 'start:reload:$command' \
+    --bind 'ctrl-r:reload:$command' \
+    --bind 'ctrl-/:change-preview-window(80%,border-bottom|hidden|)' \
+    --bind 'enter:execute:kubectl exec -it --namespace {1} {2} -- bash' \
+    --bind 'ctrl-o:execute:${EDITOR:-vim} <(kubectl logs --all-containers --namespace {1} {2})' \
+    --preview-window up:follow \
+    --preview 'kubectl logs --follow --all-containers --tail=10000 --namespace {1} {2}' "$@"
+}
+```
+
+![image](https://user-images.githubusercontent.com/700826/113473547-1d7a4880-94a5-11eb-98ef-9aa6f0ed215a.png)
+
+- The preview window will *"log tail"* the pod
+    - Holding on to a large amount of log will consume a lot of memory. So we
+      limited the initial log amount with `--tail=10000`.
+- `execute` bindings allow you to run any command without leaving fzf
+    - Press enter key on a pod to `kubectl exec` into it
+    - Press CTRL-O to open the log in your editor
+- Press CTRL-R to reload the pod list
+- Press CTRL-/ repeatedly to rotate through a different sets of preview
+  window options
+    1. `80%,border-bottom`
+    1. `hidden`
+    1. Empty string after `|` translates to the default options from `--preview-window`
+
+Key bindings for git objects
+----------------------------
+
+Oftentimes, you want to put the identifiers of various Git object to the
+command-line. For example, it is common to write commands like these:
+
+```sh
+git checkout [SOME_COMMIT_HASH or BRANCH or TAG]
+git diff [SOME_COMMIT_HASH or BRANCH or TAG] [SOME_COMMIT_HASH or BRANCH or TAG]
+```
+
+[fzf-git.sh](https://github.com/junegunn/fzf-git.sh) project defines a set of
+fzf-based key bindings for Git objects. I strongly recommend that you check
+them out because they are seriously useful.
+
+### Files listed in `git status`
+
+<kbd>CTRL-G</kbd><kbd>CTRL-F</kbd>
+
+![image](https://user-images.githubusercontent.com/700826/113473779-a9d93b00-94a6-11eb-87b5-f62a8d0a0efc.png)
+
+### Branches
+
+<kbd>CTRL-G</kbd><kbd>CTRL-B</kbd>
+
+![image](https://user-images.githubusercontent.com/700826/113473758-87dfb880-94a6-11eb-82f4-9218103f10bd.png)
+
+### Commit hashes
+
+<kbd>CTRL-G</kbd><kbd>CTRL-H</kbd>
+
+![image](https://user-images.githubusercontent.com/700826/113473765-91692080-94a6-11eb-8d38-ed4d41f27ac1.png)
+
+Color themes
+------------
+
+You can customize how fzf colors the text elements with `--color` option. Here
+are a few color themes. Note that you need a terminal emulator that can
+display 24-bit colors.
+
+```sh
+# junegunn/seoul256.vim (dark)
+export FZF_DEFAULT_OPTS='--color=bg+:#3F3F3F,bg:#4B4B4B,border:#6B6B6B,spinner:#98BC99,hl:#719872,fg:#D9D9D9,header:#719872,info:#BDBB72,pointer:#E12672,marker:#E17899,fg+:#D9D9D9,preview-bg:#3F3F3F,prompt:#98BEDE,hl+:#98BC99'
+```
+
+![seoul256](https://user-images.githubusercontent.com/700826/113475011-2c192d80-94ae-11eb-9d17-1e5867bae01f.png)
+
+```sh
+# junegunn/seoul256.vim (light)
+export FZF_DEFAULT_OPTS='--color=bg+:#D9D9D9,bg:#E1E1E1,border:#C8C8C8,spinner:#719899,hl:#719872,fg:#616161,header:#719872,info:#727100,pointer:#E12672,marker:#E17899,fg+:#616161,preview-bg:#D9D9D9,prompt:#0099BD,hl+:#719899'
+```
+
+![seoul256-light](https://user-images.githubusercontent.com/700826/113475022-389d8600-94ae-11eb-905f-0939dd535837.png)
+
+```sh
+# morhetz/gruvbox
+export FZF_DEFAULT_OPTS='--color=bg+:#3c3836,bg:#32302f,spinner:#fb4934,hl:#928374,fg:#ebdbb2,header:#928374,info:#8ec07c,pointer:#fb4934,marker:#fb4934,fg+:#ebdbb2,prompt:#fb4934,hl+:#fb4934'
+```
+
+![gruvbox](https://user-images.githubusercontent.com/700826/113475042-494dfc00-94ae-11eb-9322-cd03a027305a.png)
+
+```sh
+# arcticicestudio/nord-vim
+export FZF_DEFAULT_OPTS='--color=bg+:#3B4252,bg:#2E3440,spinner:#81A1C1,hl:#616E88,fg:#D8DEE9,header:#616E88,info:#81A1C1,pointer:#81A1C1,marker:#81A1C1,fg+:#D8DEE9,prompt:#81A1C1,hl+:#81A1C1'
+```
+
+![nord](https://user-images.githubusercontent.com/700826/113475063-67b3f780-94ae-11eb-9b24-5f0d22b63399.png)
+
+```sh
+# tomasr/molokai
+export FZF_DEFAULT_OPTS='--color=bg+:#293739,bg:#1B1D1E,border:#808080,spinner:#E6DB74,hl:#7E8E91,fg:#F8F8F2,header:#7E8E91,info:#A6E22E,pointer:#A6E22E,marker:#F92672,fg+:#F8F8F2,prompt:#F92672,hl+:#F92672'
+```
+
+![molokai](https://user-images.githubusercontent.com/700826/113475085-8619f300-94ae-11eb-85e4-2766fc3246bf.png)
+
+### fzf Theme Playground
+
+[fzf Theme Playground](https://vitormv.github.io/fzf-themes/) created by
+[Vitor Mello](https://github.com/vitormv) is a webpage where you can
+interactively create fzf themes.
+
+### Generating fzf color theme from Vim color schemes
+
+The Vim plugin of fzf can generate `--color` option from the current color
+scheme according to `g:fzf_colors` variable. You can find the detailed
+explanation [here](https://github.com/junegunn/fzf/blob/master/README-VIM.md#explanation-of-gfzf_colors).
+
+Here is an example. Add this to your Vim configuration file.
+
+```vim
+let g:fzf_colors =
+\ { 'fg':         ['fg', 'Normal'],
+  \ 'bg':         ['bg', 'Normal'],
+  \ 'preview-bg': ['bg', 'NormalFloat'],
+  \ 'hl':         ['fg', 'Comment'],
+  \ 'fg+':        ['fg', 'CursorLine', 'CursorColumn', 'Normal'],
+  \ 'bg+':        ['bg', 'CursorLine', 'CursorColumn'],
+  \ 'hl+':        ['fg', 'Statement'],
+  \ 'info':       ['fg', 'PreProc'],
+  \ 'border':     ['fg', 'Ignore'],
+  \ 'prompt':     ['fg', 'Conditional'],
+  \ 'pointer':    ['fg', 'Exception'],
+  \ 'marker':     ['fg', 'Keyword'],
+  \ 'spinner':    ['fg', 'Label'],
+  \ 'header':     ['fg', 'Comment'] }
+```
+
+Then you can see how the `--color` option is generated by printing the result
+of `fzf#wrap()`.
+
+```vim
+:echo fzf#wrap()
+```
+
+Use this command to append `export FZF_DEFAULT_OPTS="..."` line to the end of
+the current file.
+
+```vim
+:call append('$', printf('export FZF_DEFAULT_OPTS="%s"', matchstr(fzf#wrap().options, "--color[^']*")))
+```

BUILD.md

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

Dockerfile

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

LICENSE

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

Makefile

@@ -0,0 +1,190 @@
+SHELL          := bash
+GO             ?= go
+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)
+
+ifdef FZF_VERSION
+VERSION        := $(FZF_VERSION)
+else
+VERSION        := $(shell git describe --abbrev=0 2> /dev/null | sed "s/^v//")
+endif
+ifeq ($(VERSION),)
+$(error Not on git repository; cannot determine $$FZF_VERSION)
+endif
+VERSION_TRIM   := $(shell sed "s/^v//; s/-.*//" <<< $(VERSION))
+VERSION_REGEX  := $(subst .,\.,$(VERSION_TRIM))
+
+ifdef FZF_REVISION
+REVISION       := $(FZF_REVISION)
+else
+REVISION       := $(shell git log -n 1 --pretty=format:%h --abbrev=8 -- $(SOURCES) 2> /dev/null)
+endif
+ifeq ($(REVISION),)
+$(error Not on git repository; cannot determine $$FZF_REVISION)
+endif
+BUILD_FLAGS    := -a -ldflags "-s -w -X main.version=$(VERSION) -X main.revision=$(REVISION)" -tags "$(TAGS)" -trimpath
+
+BINARY32       := fzf-$(GOOS)_386
+BINARY64       := fzf-$(GOOS)_amd64
+BINARYS390     := fzf-$(GOOS)_s390x
+BINARYARM5     := fzf-$(GOOS)_arm5
+BINARYARM6     := fzf-$(GOOS)_arm6
+BINARYARM7     := fzf-$(GOOS)_arm7
+BINARYARM8     := fzf-$(GOOS)_arm8
+BINARYPPC64LE  := fzf-$(GOOS)_ppc64le
+BINARYRISCV64  := fzf-$(GOOS)_riscv64
+BINARYLOONG64  := fzf-$(GOOS)_loong64
+
+# https://en.wikipedia.org/wiki/Uname
+UNAME_M := $(shell uname -m)
+ifeq ($(UNAME_M),x86_64)
+	BINARY := $(BINARY64)
+else ifeq ($(UNAME_M),amd64)
+	BINARY := $(BINARY64)
+else ifeq ($(UNAME_M),s390x)
+	BINARY := $(BINARYS390)
+else ifeq ($(UNAME_M),i686)
+	BINARY := $(BINARY32)
+else ifeq ($(UNAME_M),i386)
+	BINARY := $(BINARY32)
+else ifeq ($(UNAME_M),armv5l)
+	BINARY := $(BINARYARM5)
+else ifeq ($(UNAME_M),armv6l)
+	BINARY := $(BINARYARM6)
+else ifeq ($(UNAME_M),armv7l)
+	BINARY := $(BINARYARM7)
+else ifeq ($(UNAME_M),armv8l)
+	# armv8l is always 32-bit and should implement the armv7 ISA, so
+	# just use the same filename as for armv7.
+	BINARY := $(BINARYARM7)
+else ifeq ($(UNAME_M),arm64)
+	BINARY := $(BINARYARM8)
+else ifeq ($(UNAME_M),aarch64)
+	BINARY := $(BINARYARM8)
+else ifeq ($(UNAME_M),ppc64le)
+	BINARY := $(BINARYPPC64LE)
+else ifeq ($(UNAME_M),riscv64)
+	BINARY := $(BINARYRISCV64)
+else ifeq ($(UNAME_M),loongarch64)
+	BINARY := $(BINARYLOONG64)
+else
+$(error Build on $(UNAME_M) is not supported, yet.)
+endif
+
+all: target/$(BINARY)
+
+test: $(SOURCES)
+	SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" \
+				github.com/junegunn/fzf/src \
+				github.com/junegunn/fzf/src/algo \
+				github.com/junegunn/fzf/src/tui \
+				github.com/junegunn/fzf/src/util
+
+bench:
+	cd src && SHELL=/bin/sh GOOS= $(GO) test -v -tags "$(TAGS)" -run=Bench -bench=. -benchmem
+
+lint: $(SOURCES) test/test_go.rb
+	[ -z "$$(gofmt -s -d src)" ] || (gofmt -s -d src; exit 1)
+	rubocop --require rubocop-minitest --require rubocop-performance
+
+install: bin/fzf
+
+generate:
+	PATH=$(PATH):$(GOPATH)/bin $(GO) generate ./...
+
+build:
+	goreleaser build --clean --snapshot --skip=post-hooks
+
+release:
+	# Make sure that the tests pass and the build works
+	TAGS=tcell make test
+	make test build clean
+
+ifndef GITHUB_TOKEN
+	$(error GITHUB_TOKEN is not defined)
+endif
+
+	# Check if we are on master branch
+ifneq ($(shell git symbolic-ref --short HEAD),master)
+	$(error Not on master branch)
+endif
+
+	# Check if version numbers are properly updated
+	grep -q ^$(VERSION_REGEX)$$ CHANGELOG.md
+	grep -qF '"fzf $(VERSION_TRIM)"' man/man1/fzf.1
+	grep -qF '"fzf $(VERSION_TRIM)"' man/man1/fzf-tmux.1
+	grep -qF $(VERSION) install
+	grep -qF $(VERSION) install.ps1
+
+	# Make release note out of CHANGELOG.md
+	mkdir -p tmp
+	sed -n '/^$(VERSION_REGEX)$$/,/^[0-9]/p' CHANGELOG.md | tail -r | \
+		sed '1,/^ *$$/d' | tail -r | sed 1,2d | tee tmp/release-note
+
+	# Push to temp branch first so that install scripts always works on master branch
+	git checkout -B temp master
+	git push origin temp --follow-tags --force
+
+	# Make a GitHub release
+	goreleaser --clean --release-notes tmp/release-note
+
+	# Push to master
+	git checkout master
+	git push origin master
+
+	# Delete temp branch
+	git push origin --delete temp
+
+clean:
+	$(RM) -r dist target
+
+target/$(BINARY32): $(SOURCES)
+	GOARCH=386 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARY64): $(SOURCES)
+	GOARCH=amd64 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYS390): $(SOURCES)
+	GOARCH=s390x $(GO) build $(BUILD_FLAGS) -o $@
+# https://github.com/golang/go/wiki/GoArm
+target/$(BINARYARM5): $(SOURCES)
+	GOARCH=arm GOARM=5 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYARM6): $(SOURCES)
+	GOARCH=arm GOARM=6 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYARM7): $(SOURCES)
+	GOARCH=arm GOARM=7 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYARM8): $(SOURCES)
+	GOARCH=arm64 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYPPC64LE): $(SOURCES)
+	GOARCH=ppc64le $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYRISCV64): $(SOURCES)
+	GOARCH=riscv64 $(GO) build $(BUILD_FLAGS) -o $@
+
+target/$(BINARYLOONG64): $(SOURCES)
+	GOARCH=loong64 $(GO) build $(BUILD_FLAGS) -o $@
+
+bin/fzf: target/$(BINARY) | bin
+	-rm -f bin/fzf
+	cp -f target/$(BINARY) bin/fzf
+
+docker:
+	docker build -t fzf-ubuntu .
+	docker run -it fzf-ubuntu tmux
+
+docker-test:
+	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

README-VIM.md

@@ -0,0 +1,495 @@
+FZF Vim integration
+===================
+
+Installation
+------------
+
+Once you have fzf installed, you can enable it inside Vim simply by adding the
+directory to `&runtimepath` in your Vim configuration file. The path may
+differ depending on the package manager.
+
+```vim
+" If installed using Homebrew
+set rtp+=/usr/local/opt/fzf
+
+" If installed using Homebrew on Apple Silicon
+set rtp+=/opt/homebrew/opt/fzf
+
+" If you have cloned fzf on ~/.fzf directory
+set rtp+=~/.fzf
+```
+
+If you use [vim-plug](https://github.com/junegunn/vim-plug), the same can be
+written as:
+
+```vim
+" If installed using Homebrew
+Plug '/usr/local/opt/fzf'
+
+" If installed using Homebrew on Apple Silicon
+Plug '/opt/homebrew/opt/fzf'
+
+" If you have cloned fzf on ~/.fzf directory
+Plug '~/.fzf'
+```
+
+But if you want the latest Vim plugin file from GitHub rather than the one
+included in the package, write:
+
+```vim
+Plug 'junegunn/fzf'
+```
+
+The Vim plugin will pick up fzf binary available on the system. If fzf is not
+found on `$PATH`, it will ask you if it should download the latest binary for
+you.
+
+To make sure that you have the latest version of the binary, set up
+post-update hook like so:
+
+```vim
+Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+```
+
+Summary
+-------
+
+The Vim plugin of fzf provides two core functions, and `:FZF` command which is
+the basic file selector command built on top of them.
+
+1. **`fzf#run([spec dict])`**
+    - Starts fzf inside Vim with the given spec
+    - `:call fzf#run({'source': 'ls'})`
+2. **`fzf#wrap([spec dict]) -> (dict)`**
+    - Takes a spec for `fzf#run` and returns an extended version of it with
+      additional options for addressing global preferences (`g:fzf_xxx`)
+        - `:echo fzf#wrap({'source': 'ls'})`
+    - We usually *wrap* a spec with `fzf#wrap` before passing it to `fzf#run`
+        - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
+3. **`:FZF [fzf_options string] [path string]`**
+    - Basic fuzzy file selector
+    - A reference implementation for those who don't want to write VimScript
+      to implement custom commands
+    - If you're looking for more such commands, check out [fzf.vim](https://github.com/junegunn/fzf.vim) project.
+
+The most important of all is `fzf#run`, but it would be easier to understand
+the whole if we start off with `:FZF` command.
+
+`:FZF[!]`
+---------
+
+```vim
+" Look for files under current directory
+:FZF
+
+" Look for files under your home directory
+:FZF ~
+
+" With fzf command-line options
+:FZF --reverse --info=inline /tmp
+
+" Bang version starts fzf in fullscreen mode
+:FZF!
+```
+
+Similarly to [ctrlp.vim](https://github.com/kien/ctrlp.vim), 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.
+
+Note that the environment variables `FZF_DEFAULT_COMMAND` and
+`FZF_DEFAULT_OPTS` also apply here.
+
+### Configuration
+
+- `g:fzf_action`
+    - Customizable extra key bindings for opening selected files in different ways
+- `g:fzf_layout`
+    - Determines the size and position of fzf window
+- `g:fzf_colors`
+    - Customizes fzf colors to match the current color scheme
+- `g:fzf_history_dir`
+    - Enables history feature
+
+#### Examples
+
+```vim
+" This is the default extra key bindings
+let g:fzf_action = {
+  \ 'ctrl-t': 'tab split',
+  \ 'ctrl-x': 'split',
+  \ 'ctrl-v': 'vsplit' }
+
+" An action can be a reference to a function that processes selected lines
+function! s:build_quickfix_list(lines)
+  call setqflist(map(copy(a:lines), '{ "filename": v:val, "lnum": 1 }'))
+  copen
+  cc
+endfunction
+
+let g:fzf_action = {
+  \ 'ctrl-q': function('s:build_quickfix_list'),
+  \ 'ctrl-t': 'tab split',
+  \ 'ctrl-x': 'split',
+  \ 'ctrl-v': 'vsplit' }
+
+" Default fzf layout
+" - Popup window (center of the screen)
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+
+" - Popup window (center of the current window)
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true } }
+
+" - Popup window (anchored to the bottom of the current window)
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true, 'yoffset': 1.0 } }
+
+" - down / up / left / right
+let g:fzf_layout = { 'down': '40%' }
+
+" - Window using a Vim command
+let g:fzf_layout = { 'window': 'enew' }
+let g:fzf_layout = { 'window': '-tabnew' }
+let g:fzf_layout = { 'window': '10new' }
+
+" Customize fzf colors to match your color scheme
+" - fzf#wrap translates this to a set of `--color` options
+let g:fzf_colors =
+\ { 'fg':      ['fg', 'Normal'],
+  \ 'bg':      ['bg', 'Normal'],
+  \ 'hl':      ['fg', 'Comment'],
+  \ 'fg+':     ['fg', 'CursorLine', 'CursorColumn', 'Normal'],
+  \ 'bg+':     ['bg', 'CursorLine', 'CursorColumn'],
+  \ 'hl+':     ['fg', 'Statement'],
+  \ 'info':    ['fg', 'PreProc'],
+  \ 'border':  ['fg', 'Ignore'],
+  \ 'prompt':  ['fg', 'Conditional'],
+  \ 'pointer': ['fg', 'Exception'],
+  \ 'marker':  ['fg', 'Keyword'],
+  \ 'spinner': ['fg', 'Label'],
+  \ 'header':  ['fg', 'Comment'] }
+
+" Enable per-command history
+" - History files will be stored in the specified directory
+" - When set, CTRL-N and CTRL-P will be bound to 'next-history' and
+"   'previous-history' instead of 'down' and 'up'.
+let g:fzf_history_dir = '~/.local/share/fzf-history'
+```
+
+##### Explanation of `g:fzf_colors`
+
+`g:fzf_colors` is a dictionary mapping fzf elements to a color specification
+list:
+
+    element: [ component, group1 [, group2, ...] ]
+
+- `element` is an fzf element to apply a color to:
+
+  | Element                     | Description                                           |
+  | ---                         | ---                                                   |
+  | `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 (`>`)                             |
+  | `border`                    | Border around the window (`--border` and `--preview`) |
+  | `header`                    | Header (`--header` or `--header-lines`)               |
+  | `info`                      | Info line (match counters)                            |
+  | `spinner`                   | Streaming input indicator                             |
+  | `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
+
+- `group1 [, group2, ...]` is a list of highlight groups that are searched (in
+  order) for a matching color definition
+
+For example, consider the following specification:
+
+```vim
+  'prompt':  ['fg', 'Conditional', 'Comment'],
+```
+
+This means we color the **prompt**
+- using the `fg` attribute of the `Conditional` 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
+the result of `fzf#wrap()` function like so:
+
+```vim
+:echo fzf#wrap()
+```
+
+`fzf#run`
+---------
+
+`fzf#run()` function is the core of Vim integration. It takes a single
+dictionary argument, *a spec*, and starts fzf process accordingly. At the very
+least, specify `sink` option to tell what it should do with the selected
+entry.
+
+```vim
+call fzf#run({'sink': 'e'})
+```
+
+We haven't specified the `source`, so this is equivalent to starting fzf on
+command line without standard input pipe; fzf will traverse the file system
+under the current directory to get the list of files. (If
+`$FZF_DEFAULT_COMMAND` is set, fzf will use the output of the command
+instead.) When you select one, it will open it with the sink, `:e` command. If
+you want to open it in a new tab, you can pass `:tabedit` command instead as
+the sink.
+
+```vim
+call fzf#run({'sink': 'tabedit'})
+```
+
+You can use any shell command as the source to generate the list. The
+following example will list the files managed by git. It's equivalent to
+running `git ls-files | fzf` on shell.
+
+```vim
+call fzf#run({'source': 'git ls-files', 'sink': 'e'})
+```
+
+fzf options can be specified as `options` entry in spec dictionary.
+
+```vim
+call fzf#run({'sink': 'tabedit', 'options': '--multi --reverse'})
+```
+
+You can also pass a layout option if you don't want fzf window to take up the
+entire screen.
+
+```vim
+" up / down / left / right / window are allowed
+call fzf#run({'source': 'git ls-files', 'sink': 'e', 'left': '40%'})
+call fzf#run({'source': 'git ls-files', 'sink': 'e', 'window': '30vnew'})
+```
+
+`source` doesn't have to be an external shell command, you can pass a Vim
+array as the source. In the next example, we pass the names of color
+schemes as the source to implement a color scheme selector.
+
+```vim
+call fzf#run({'source': map(split(globpath(&rtp, 'colors/*.vim')),
+            \               'fnamemodify(v:val, ":t:r")'),
+            \ 'sink': 'colo', 'left': '25%'})
+```
+
+The following table summarizes the available options.
+
+| Option name                | Type          | Description                                                           |
+| -------------------------- | ------------- | ----------------------------------------------------------------      |
+| `source`                   | string        | External command to generate input to fzf (e.g. `find .`)             |
+| `source`                   | list          | Vim list as input to fzf                                              |
+| `sink`                     | string        | Vim command to handle the selected item (e.g. `e`, `tabe`)            |
+| `sink`                     | funcref       | Function to be called with each selected item                         |
+| `sinklist` (or `sink*`)    | funcref       | Similar to `sink`, but takes the list of output lines at once         |
+| `exit`                     | funcref       | Function to be called with the exit status of fzf (e.g. 0, 1, 2, 130) |
+| `options`                  | string/list   | Options to fzf                                                        |
+| `dir`                      | string        | Working directory                                                     |
+| `up`/`down`/`left`/`right` | number/string | (Layout) Window position and size (e.g. `20`, `50%`)                  |
+| `tmux`                     | string        | (Layout) `--tmux` options (e.g. `90%,70%`)                            |
+| `window` (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g. `vertical aboveleft 30new`) |
+| `window` (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g. `{'width': 0.9, 'height': 0.6}`) |
+
+`options` entry can be either a string or a list. For simple cases, string
+should suffice, but prefer to use list type to avoid escaping issues.
+
+```vim
+call fzf#run({'options': '--reverse --prompt "C:\\Program Files\\"'})
+call fzf#run({'options': ['--reverse', '--prompt', 'C:\Program Files\']})
+```
+
+When `window` entry is a dictionary, fzf will start in a popup window. The
+following options are allowed:
+
+- Required:
+    - `width` [float range [0 ~ 1]] or [integer range [8 ~ ]]
+    - `height` [float range [0 ~ 1]] or [integer range [4 ~ ]]
+- Optional:
+    - `yoffset` [float default 0.5 range [0 ~ 1]]
+    - `xoffset` [float default 0.5 range [0 ~ 1]]
+    - `relative` [boolean default v:false]
+    - `border` [string default `rounded` (`sharp` on Windows)]: Border style
+        - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right` / `no[ne]`
+
+`fzf#wrap`
+----------
+
+We have seen that several aspects of `:FZF` command can be configured with
+a set of global option variables; different ways to open files
+(`g:fzf_action`), window position and size (`g:fzf_layout`), color palette
+(`g:fzf_colors`), etc.
+
+So how can we make our custom `fzf#run` calls also respect those variables?
+Simply by *"wrapping"* the spec dictionary with `fzf#wrap` before passing it
+to `fzf#run`.
+
+- **`fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`**
+    - All arguments are optional. Usually we only need to pass a spec dictionary.
+    - `name` is for managing history files. It is ignored if
+      `g:fzf_history_dir` is not defined.
+    - `fullscreen` can be either `0` or `1` (default: 0).
+
+`fzf#wrap` takes a spec and returns an extended version of it (also
+a dictionary) with additional options for addressing global preferences. You
+can examine the return value of it like so:
+
+```vim
+echo fzf#wrap({'source': 'ls'})
+```
+
+After we *"wrap"* our spec, we pass it to `fzf#run`.
+
+```vim
+call fzf#run(fzf#wrap({'source': 'ls'}))
+```
+
+Now it supports `CTRL-T`, `CTRL-V`, and `CTRL-X` key bindings (configurable
+via `g:fzf_action`) and it opens fzf window according to `g:fzf_layout`
+setting.
+
+To make it easier to use, let's define `LS` command.
+
+```vim
+command! LS call fzf#run(fzf#wrap({'source': 'ls'}))
+```
+
+Type `:LS` and see how it works.
+
+We would like to make `:LS!` (bang version) open fzf in fullscreen, just like
+`:FZF!`. Add `-bang` to command definition, and use `<bang>` value to set
+the last `fullscreen` argument of `fzf#wrap` (see `:help <bang>`).
+
+```vim
+" On :LS!, <bang> evaluates to '!', and '!0' becomes 1
+command! -bang LS call fzf#run(fzf#wrap({'source': 'ls'}, <bang>0))
+```
+
+Our `:LS` command will be much more useful if we can pass a directory argument
+to it, so that something like `:LS /tmp` is possible.
+
+```vim
+command! -bang -complete=dir -nargs=? LS
+    \ call fzf#run(fzf#wrap({'source': 'ls', 'dir': <q-args>}, <bang>0))
+```
+
+Lastly, if you have enabled `g:fzf_history_dir`, you might want to assign
+a unique name to our command and pass it as the first argument to `fzf#wrap`.
+
+```vim
+" The query history for this command will be stored as 'ls' inside g:fzf_history_dir.
+" The name is ignored if g:fzf_history_dir is not defined.
+command! -bang -complete=dir -nargs=? LS
+    \ call fzf#run(fzf#wrap('ls', {'source': 'ls', 'dir': <q-args>}, <bang>0))
+```
+
+### Global options supported by `fzf#wrap`
+
+- `g:fzf_layout`
+- `g:fzf_action`
+    - **Works only when no custom `sink` (or `sinklist`) is provided**
+        - Having custom sink usually means that each entry is not an ordinary
+          file path (e.g. name of color scheme), so we can't blindly apply the
+          same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
+- `g:fzf_colors`
+- `g:fzf_history_dir`
+
+Tips
+----
+
+### fzf inside terminal buffer
+
+On the latest versions of Vim and Neovim, fzf will start in a terminal buffer.
+If you find the default ANSI colors to be different, consider configuring the
+colors using `g:terminal_ansi_colors` in regular Vim or `g:terminal_color_x`
+in Neovim.
+
+```vim
+" Terminal colors for seoul256 color scheme
+if has('nvim')
+  let g:terminal_color_0 = '#4e4e4e'
+  let g:terminal_color_1 = '#d68787'
+  let g:terminal_color_2 = '#5f865f'
+  let g:terminal_color_3 = '#d8af5f'
+  let g:terminal_color_4 = '#85add4'
+  let g:terminal_color_5 = '#d7afaf'
+  let g:terminal_color_6 = '#87afaf'
+  let g:terminal_color_7 = '#d0d0d0'
+  let g:terminal_color_8 = '#626262'
+  let g:terminal_color_9 = '#d75f87'
+  let g:terminal_color_10 = '#87af87'
+  let g:terminal_color_11 = '#ffd787'
+  let g:terminal_color_12 = '#add4fb'
+  let g:terminal_color_13 = '#ffafaf'
+  let g:terminal_color_14 = '#87d7d7'
+  let g:terminal_color_15 = '#e4e4e4'
+else
+  let g:terminal_ansi_colors = [
+    \ '#4e4e4e', '#d68787', '#5f865f', '#d8af5f',
+    \ '#85add4', '#d7afaf', '#87afaf', '#d0d0d0',
+    \ '#626262', '#d75f87', '#87af87', '#ffd787',
+    \ '#add4fb', '#ffafaf', '#87d7d7', '#e4e4e4'
+  \ ]
+endif
+```
+
+### Starting fzf in a popup window
+
+```vim
+" Required:
+" - width [float range [0 ~ 1]] or [integer range [8 ~ ]]
+" - height [float range [0 ~ 1]] or [integer range [4 ~ ]]
+"
+" Optional:
+" - xoffset [float default 0.5 range [0 ~ 1]]
+" - yoffset [float default 0.5 range [0 ~ 1]]
+" - relative [boolean default v:false]
+" - border [string default 'rounded']: Border style
+"   - 'rounded' / 'sharp' / 'horizontal' / 'vertical' / 'top' / 'bottom' / 'left' / 'right'
+let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+```
+
+Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
+or above) by putting `--tmux` option value in `tmux` key.
+
+```vim
+" See `--tmux` option in `man fzf` for available options
+" [center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]
+if exists('$TMUX')
+  let g:fzf_layout = { 'tmux': '90%,70%' }
+else
+  let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+endif
+```
+
+### Hide statusline
+
+When fzf starts in a terminal buffer, the file type of the buffer is set to
+`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
+the window.
+
+For example, if you open fzf on the bottom on the screen (e.g. `{'down':
+'40%'}`), you might want to temporarily disable the statusline for a cleaner
+look.
+
+```vim
+let g:fzf_layout = { 'down': '30%' }
+autocmd! FileType fzf
+autocmd  FileType fzf set laststatus=0 noshowmode noruler
+  \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
+```
+
+[License](LICENSE)
+------------------
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2024 Junegunn Choi

Rakefile

@@ -1,8 +0,0 @@
-require "bundler/gem_tasks"
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |test|
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-

bin/fzf-preview.sh

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

bin/fzf-tmux

@@ -0,0 +1,254 @@
+#!/usr/bin/env bash
+# fzf-tmux: starts fzf in a tmux pane
+# usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
+
+fail() {
+  >&2 echo "$1"
+  exit 2
+}
+
+fzf="$(command which fzf)" || fzf="$(dirname "$0")/fzf"
+[[ -x "$fzf" ]] || fail 'fzf executable not found'
+
+args=()
+opt=""
+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}")
+
+tmux_version=$(tmux -V | sed 's/[^0-9.]//g')
+tmux_32=$(awk '{print ($1 >= 3.2)}' <<< "$tmux_version" 2> /dev/null || bc -l <<< "$tmux_version >= 3.2")
+
+help() {
+  >&2 echo 'usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]
+
+  LAYOUT OPTIONS:
+    (default layout: -d 50%)
+
+    Popup window (requires tmux 3.2 or above):
+      -p [WIDTH[%][,HEIGHT[%]]]  (default: 50%)
+      -w WIDTH[%]
+      -h HEIGHT[%]
+      -x COL
+      -y ROW
+
+    Split pane:
+      -u [HEIGHT[%]]             Split above (up)
+      -d [HEIGHT[%]]             Split below (down)
+      -l [WIDTH[%]]              Split left
+      -r [WIDTH[%]]              Split right
+'
+  exit
+}
+
+while [[ $# -gt 0 ]]; do
+  arg="$1"
+  shift
+  [[ -z "$skip" ]] && case "$arg" in
+    -)
+      term=1
+      ;;
+    --help)
+      help
+      ;;
+    --version)
+      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
+        opt="-h"
+        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
+          opt="$opt -d"
+          swap="; swap-pane -D ; select-pane -U"
+          close="; tmux swap-pane -D"
+        fi
+      fi
+      if [[ ${#arg} -gt 2 ]]; then
+        size="${arg:2}"
+      else
+        if [[ "$1" =~ ^[0-9%,]+$ ]] || [[ "$1" =~ ^[A-Z]$ ]]; then
+          size="$1"
+          shift
+        else
+          continue
+        fi
+      fi
+
+      if [[ "$arg" =~ ^-p ]]; then
+        if [[ -n "$size" ]]; then
+          w=${size%%,*}
+          h=${size##*,}
+          opt="$opt -w$w -h$h"
+        fi
+      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 ))%"
+          else
+            opt="$opt -l $size%"
+          fi
+        else
+          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
+            max=$columns
+          else
+            max=$lines
+          fi
+          size=$(( max - size ))
+          [[ $size -lt 0 ]] && size=0
+          opt="$opt -l $size"
+        else
+          opt="$opt -l $size"
+        fi
+      fi
+      ;;
+    --)
+      # "--" can be used to separate fzf-tmux options from fzf options to
+      # avoid conflicts
+      skip=1
+      continue
+      ;;
+    *)
+      args+=("$arg")
+      ;;
+  esac
+  [[ -n "$skip" ]] && args+=("$arg")
+done
+
+if [[ -z "$TMUX" ]]; then
+  "$fzf" "${args[@]}"
+  exit $?
+fi
+
+# * --height option is not allowed
+# * CTRL-Z is also disabled
+# * fzf-tmux script is not compatible with --tmux option in fzf 0.53.0 or later
+args=("${args[@]}" "--no-height" "--bind=ctrl-z:ignore" "--no-tmux")
+
+# 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
+  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'")
+  tmux swap-pane -t $tmp_window \; select-window -t $tmp_window
+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"
+if tmux_win_opts=$(tmux show-options -p remain-on-exit \; show-options -p synchronize-panes 2> /dev/null); then
+  tmux_win_opts=( $(sed '/ off/d; s/synchronize-panes/set-option -p synchronize-panes/; s/remain-on-exit/set-option -p remain-on-exit/; s/$/ \\;/' <<< "$tmux_win_opts") )
+  tmux_off_opts='; set-option -p synchronize-panes off ; set-option -p remain-on-exit off'
+else
+  tmux_win_opts=( $(tmux show-window-options remain-on-exit \; show-window-options synchronize-panes | sed '/ off/d; s/^/set-window-option /; s/$/ \\;/') )
+  tmux_off_opts='; set-window-option synchronize-panes off ; set-window-option remain-on-exit off'
+fi
+cleanup() {
+  \rm -f $argsf $fifo1 $fifo2 $fifo3
+
+  # Restore tmux window options
+  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
+    tmux display-message -p "#{window_id}" > /dev/null
+    tmux swap-pane -t $original_window \; \
+      select-window -t $original_window \; \
+      kill-window -t $tmp_window \; \
+      resize-pane -Z
+  fi
+
+  if [[ $# -gt 0 ]]; then
+    trap - EXIT
+    exit 130
+  fi
+}
+trap 'cleanup 1' SIGUSR1
+trap 'cleanup' EXIT
+
+envs="export TERM=$TERM "
+if [[ "$opt" =~ "-E" ]]; then
+  if [[ $tmux_version = 3.2 ]]; then
+    FZF_DEFAULT_OPTS="--margin 0,1 $FZF_DEFAULT_OPTS"
+  elif [[ $tmux_32 = 1 ]]; then
+    FZF_DEFAULT_OPTS="--border $FZF_DEFAULT_OPTS"
+    opt="-B $opt"
+  else
+    echo "fzf-tmux: tmux 3.2 or above is required for popup mode" >&2
+    exit 2
+  fi
+fi
+envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"
+envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
+envs="$envs FZF_DEFAULT_OPTS_FILE=$(printf %q "$FZF_DEFAULT_OPTS_FILE")"
+[[ -n "$RUNEWIDTH_EASTASIAN" ]] && envs="$envs RUNEWIDTH_EASTASIAN=$(printf %q "$RUNEWIDTH_EASTASIAN")"
+[[ -n "$BAT_THEME" ]] && envs="$envs BAT_THEME=$(printf %q "$BAT_THEME")"
+echo "$envs;" > "$argsf"
+
+# Build arguments to fzf
+opts=$(printf "%q " "${args[@]}")
+
+pppid=$$
+echo -n "trap 'kill -SIGUSR1 -$pppid' EXIT SIGINT SIGTERM;" >> $argsf
+close="; trap - EXIT SIGINT SIGTERM $close"
+
+export TMUX=$(cut -d , -f 1,2 <<< "$TMUX")
+mkfifo -m o+w $fifo2
+if [[ "$opt" =~ "-E" ]]; then
+  cat $fifo2 &
+  if [[ -n "$term" ]] || [[ -t 0 ]]; then
+    cat <<< "\"$fzf\" $opts > $fifo2; out=\$? $close; exit \$out" >> $argsf
+  else
+    mkfifo $fifo1
+    cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; out=\$? $close; exit \$out" >> $argsf
+    cat <&0 > $fifo1 &
+  fi
+
+  tmux popup -d "$PWD" $opt "bash $argsf" > /dev/null 2>&1
+  exit $?
+fi
+
+mkfifo -m o+w $fifo3
+if [[ -n "$term" ]] || [[ -t 0 ]]; then
+  cat <<< "\"$fzf\" $opts > $fifo2; echo \$? > $fifo3 $close" >> $argsf
+else
+  mkfifo $fifo1
+  cat <<< "\"$fzf\" $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" >> $argsf
+  cat <&0 > $fifo1 &
+fi
+tmux \
+  split-window -c "$PWD" $opt "bash -c 'exec -a fzf bash $argsf'" $swap \
+  $tmux_off_opts \
+  > /dev/null 2>&1 || { "$fzf" "${args[@]}"; exit $?; }
+cat $fifo2
+exit "$(cat $fifo3)"

doc/fzf.txt

@@ -0,0 +1,509 @@
+fzf.txt	fzf	Last change: February 15 2024
+FZF - TABLE OF CONTENTS                                            *fzf* *fzf-toc*
+==============================================================================
+
+  FZF Vim integration                       |fzf-vim-integration|
+    Installation                            |fzf-installation|
+    Summary                                 |fzf-summary|
+    :FZF[!]                                 |:FZF|
+      Configuration                         |fzf-configuration|
+        Examples                            |fzf-examples|
+          Explanation of g:fzf_colors       |fzf-explanation-of-gfzfcolors|
+    fzf#run                                 |fzf#run|
+    fzf#wrap                                |fzf#wrap|
+      Global options supported by fzf#wrap  |fzf-global-options-supported-by-fzf#wrap|
+    Tips                                    |fzf-tips|
+      fzf inside terminal buffer            |fzf-inside-terminal-buffer|
+      Starting fzf in a popup window        |fzf-starting-fzf-in-a-popup-window|
+      Hide statusline                       |fzf-hide-statusline|
+    License                                 |fzf-license|
+
+FZF VIM INTEGRATION                                        *fzf-vim-integration*
+==============================================================================
+
+
+INSTALLATION                                                  *fzf-installation*
+==============================================================================
+
+Once you have fzf installed, you can enable it inside Vim simply by adding the
+directory to 'runtimepath' in your Vim configuration file. The path may differ
+depending on the package manager.
+>
+    " If installed using Homebrew
+    set rtp+=/usr/local/opt/fzf
+
+    " If installed using Homebrew on Apple Silicon
+    set rtp+=/opt/homebrew/opt/fzf
+
+    " If you have cloned fzf on ~/.fzf directory
+    set rtp+=~/.fzf
+<
+If you use {vim-plug}{1}, the same can be written as:
+>
+    " If installed using Homebrew
+    Plug '/usr/local/opt/fzf'
+
+    " If installed using Homebrew on Apple Silicon
+    Plug '/opt/homebrew/opt/fzf'
+
+    " If you have cloned fzf on ~/.fzf directory
+    Plug '~/.fzf'
+<
+But if you want the latest Vim plugin file from GitHub rather than the one
+included in the package, write:
+>
+    Plug 'junegunn/fzf'
+<
+The Vim plugin will pick up fzf binary available on the system. If fzf is not
+found on `$PATH`, it will ask you if it should download the latest binary for
+you.
+
+To make sure that you have the latest version of the binary, set up
+post-update hook like so:
+
+                                                                   *fzf#install*
+>
+    Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
+<
+                                      {1} https://github.com/junegunn/vim-plug
+
+
+SUMMARY                                                            *fzf-summary*
+==============================================================================
+
+The Vim plugin of fzf provides two core functions, and `:FZF` command which is
+the basic file selector command built on top of them.
+
+ 1. `fzf#run([spec dict])`
+   - Starts fzf inside Vim with the given spec
+   - `:call fzf#run({'source': 'ls'})`
+ 2. `fzf#wrap([spec dict]) -> (dict)`
+   - Takes a spec for `fzf#run` and returns an extended version of it with
+     additional options for addressing global preferences (`g:fzf_xxx`)
+     - `:echo fzf#wrap({'source': 'ls'})`
+   - We usually wrap a spec with `fzf#wrap` before passing it to `fzf#run`
+     - `:call fzf#run(fzf#wrap({'source': 'ls'}))`
+ 3. `:FZF [fzf_options string] [path string]`
+   - Basic fuzzy file selector
+   - A reference implementation for those who don't want to write VimScript to
+     implement custom commands
+   - If you're looking for more such commands, check out {fzf.vim}{2} project.
+
+The most important of all is `fzf#run`, but it would be easier to understand
+the whole if we start off with `:FZF` command.
+
+                                       {2} https://github.com/junegunn/fzf.vim
+
+
+:FZF[!]
+==============================================================================
+
+                                                                          *:FZF*
+>
+    " Look for files under current directory
+    :FZF
+
+    " Look for files under your home directory
+    :FZF ~
+
+    " With fzf command-line options
+    :FZF --reverse --info=inline /tmp
+
+    " 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
+selected files in the current window, in new tabs, in horizontal splits, or in
+vertical splits respectively.
+
+Note that the environment variables `FZF_DEFAULT_COMMAND` and
+`FZF_DEFAULT_OPTS` also apply here.
+
+                                         {3} https://github.com/kien/ctrlp.vim
+
+
+< Configuration >_____________________________________________________________~
+                                                             *fzf-configuration*
+
+                      *g:fzf_action* *g:fzf_layout* *g:fzf_colors* *g:fzf_history_dir*
+
+ - `g:fzf_action`
+   - Customizable extra key bindings for opening selected files in different
+     ways
+ - `g:fzf_layout`
+   - Determines the size and position of fzf window
+ - `g:fzf_colors`
+   - Customizes fzf colors to match the current color scheme
+ - `g:fzf_history_dir`
+   - Enables history feature
+
+
+Examples~
+                                                                  *fzf-examples*
+>
+    " This is the default extra key bindings
+    let g:fzf_action = {
+      \ 'ctrl-t': 'tab split',
+      \ 'ctrl-x': 'split',
+      \ 'ctrl-v': 'vsplit' }
+
+    " An action can be a reference to a function that processes selected lines
+    function! s:build_quickfix_list(lines)
+      call setqflist(map(copy(a:lines), '{ "filename": v:val, "lnum": 1 }'))
+      copen
+      cc
+    endfunction
+
+    let g:fzf_action = {
+      \ 'ctrl-q': function('s:build_quickfix_list'),
+      \ 'ctrl-t': 'tab split',
+      \ 'ctrl-x': 'split',
+      \ 'ctrl-v': 'vsplit' }
+
+    " Default fzf layout
+    " - Popup window (center of the screen)
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+
+    " - Popup window (center of the current window)
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true } }
+
+    " - Popup window (anchored to the bottom of the current window)
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6, 'relative': v:true, 'yoffset': 1.0 } }
+
+    " - down / up / left / right
+    let g:fzf_layout = { 'down': '40%' }
+
+    " - Window using a Vim command
+    let g:fzf_layout = { 'window': 'enew' }
+    let g:fzf_layout = { 'window': '-tabnew' }
+    let g:fzf_layout = { 'window': '10new' }
+
+    " Customize fzf colors to match your color scheme
+    " - fzf#wrap translates this to a set of `--color` options
+    let g:fzf_colors =
+    \ { 'fg':      ['fg', 'Normal'],
+      \ 'bg':      ['bg', 'Normal'],
+      \ 'hl':      ['fg', 'Comment'],
+      \ 'fg+':     ['fg', 'CursorLine', 'CursorColumn', 'Normal'],
+      \ 'bg+':     ['bg', 'CursorLine', 'CursorColumn'],
+      \ 'hl+':     ['fg', 'Statement'],
+      \ 'info':    ['fg', 'PreProc'],
+      \ 'border':  ['fg', 'Ignore'],
+      \ 'prompt':  ['fg', 'Conditional'],
+      \ 'pointer': ['fg', 'Exception'],
+      \ 'marker':  ['fg', 'Keyword'],
+      \ 'spinner': ['fg', 'Label'],
+      \ 'header':  ['fg', 'Comment'] }
+
+    " Enable per-command history
+    " - History files will be stored in the specified directory
+    " - When set, CTRL-N and CTRL-P will be bound to 'next-history' and
+    "   'previous-history' instead of 'down' and 'up'.
+    let g:fzf_history_dir = '~/.local/share/fzf-history'
+<
+
+Explanation of g:fzf_colors~
+                                                 *fzf-explanation-of-gfzfcolors*
+
+`g:fzf_colors` is a dictionary mapping fzf elements to a color specification
+list:
+>
+    element: [ component, group1 [, group2, ...] ]
+<
+ - `element` is an fzf element to apply a color to:
+
+ ----------------------------+------------------------------------------------------
+ Element                     | Description                                          ~
+ ----------------------------+------------------------------------------------------
+  `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 ( `>` )
+  `border`                     | Border around the window ( `--border`  and  `--preview` )
+  `header`                     | Header ( `--header`  or  `--header-lines` )
+  `info`                       | Info line (match counters)
+  `spinner`                    | Streaming input indicator
+  `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
+ - `group1 [, group2, ...]` is a list of highlight groups that are searched (in
+   order) for a matching color definition
+
+For example, consider the following specification:
+>
+      'prompt':  ['fg', 'Conditional', 'Comment'],
+<
+This means we color the prompt - using the `fg` attribute of the `Conditional`
+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
+the result of `fzf#wrap()` function like so:
+>
+    :echo fzf#wrap()
+<
+
+FZF#RUN
+==============================================================================
+
+                                                                       *fzf#run*
+
+`fzf#run()` function is the core of Vim integration. It takes a single
+dictionary argument, a spec, and starts fzf process accordingly. At the very
+least, specify `sink` option to tell what it should do with the selected
+entry.
+>
+    call fzf#run({'sink': 'e'})
+<
+We haven't specified the `source`, so this is equivalent to starting fzf on
+command line without standard input pipe; fzf will traverse the file system
+under the current directory to get the list of files. (If
+`$FZF_DEFAULT_COMMAND` is set, fzf will use the output of the command
+instead.) When you select one, it will open it with the sink, `:e` command. If
+you want to open it in a new tab, you can pass `:tabedit` command instead as
+the sink.
+>
+    call fzf#run({'sink': 'tabedit'})
+<
+You can use any shell command as the source to generate the list. The
+following example will list the files managed by git. It's equivalent to
+running `git ls-files | fzf` on shell.
+>
+    call fzf#run({'source': 'git ls-files', 'sink': 'e'})
+<
+fzf options can be specified as `options` entry in spec dictionary.
+>
+    call fzf#run({'sink': 'tabedit', 'options': '--multi --reverse'})
+<
+You can also pass a layout option if you don't want fzf window to take up the
+entire screen.
+>
+    " up / down / left / right / window are allowed
+    call fzf#run({'source': 'git ls-files', 'sink': 'e', 'left': '40%'})
+    call fzf#run({'source': 'git ls-files', 'sink': 'e', 'window': '30vnew'})
+<
+`source` doesn't have to be an external shell command, you can pass a Vim
+array as the source. In the next example, we pass the names of color schemes
+as the source to implement a color scheme selector.
+>
+    call fzf#run({'source': map(split(globpath(&rtp, 'colors/*.vim')),
+                \               'fnamemodify(v:val, ":t:r")'),
+                \ 'sink': 'colo', 'left': '25%'})
+<
+The following table summarizes the available options.
+
+ ---------------------------+---------------+----------------------------------------------------------------------
+ Option name                | Type          | Description                                                          ~
+ ---------------------------+---------------+----------------------------------------------------------------------
+  `source`                    | string        | External command to generate input to fzf (e.g.  `find .` )
+  `source`                    | list          | Vim list as input to fzf
+  `sink`                      | string        | Vim command to handle the selected item (e.g.  `e` ,  `tabe` )
+  `sink`                      | funcref       | Function to be called with each selected item
+  `sinklist`  (or  `sink*` )    | funcref       | Similar to  `sink` , but takes the list of output lines at once
+  `exit`                      | funcref       | Function to be called with the exit status of fzf (e.g. 0, 1, 2, 130)
+  `options`                   | string/list   | Options to fzf
+  `dir`                       | string        | Working directory
+  `up` / `down` / `left` / `right`  | number/string | (Layout) Window position and size (e.g.  `20` ,  `50%` )
+  `tmux`                      | string        | (Layout) `--tmux` options (e.g.  `90%,70%` )
+  `window`  (Vim 8 / Neovim)  | string        | (Layout) Command to open fzf window (e.g.  `vertical aboveleft 30new` )
+  `window`  (Vim 8 / Neovim)  | dict          | (Layout) Popup window settings (e.g.  `{'width': 0.9, 'height': 0.6}` )
+ ---------------------------+---------------+----------------------------------------------------------------------
+
+`options` entry can be either a string or a list. For simple cases, string
+should suffice, but prefer to use list type to avoid escaping issues.
+>
+    call fzf#run({'options': '--reverse --prompt "C:\\Program Files\\"'})
+    call fzf#run({'options': ['--reverse', '--prompt', 'C:\Program Files\']})
+<
+When `window` entry is a dictionary, fzf will start in a popup window. The
+following options are allowed:
+
+ - Required:
+   - `width` [float range [0 ~ 1]] or [integer range [8 ~ ]]
+   - `height` [float range [0 ~ 1]] or [integer range [4 ~ ]]
+ - Optional:
+   - `yoffset` [float default 0.5 range [0 ~ 1]]
+   - `xoffset` [float default 0.5 range [0 ~ 1]]
+   - `relative` [boolean default v:false]
+   - `border` [string default `rounded` (`sharp` on Windows)]: Border style
+     - `rounded` / `sharp` / `horizontal` / `vertical` / `top` / `bottom` / `left` / `right` / `no[ne]`
+
+
+FZF#WRAP
+==============================================================================
+
+                                                                      *fzf#wrap*
+
+We have seen that several aspects of `:FZF` command can be configured with a
+set of global option variables; different ways to open files (`g:fzf_action`),
+window position and size (`g:fzf_layout`), color palette (`g:fzf_colors`),
+etc.
+
+So how can we make our custom `fzf#run` calls also respect those variables?
+Simply by "wrapping" the spec dictionary with `fzf#wrap` before passing it to
+`fzf#run`.
+
+ - `fzf#wrap([name string], [spec dict], [fullscreen bool]) -> (dict)`
+   - All arguments are optional. Usually we only need to pass a spec
+     dictionary.
+   - `name` is for managing history files. It is ignored if `g:fzf_history_dir`
+     is not defined.
+   - `fullscreen` can be either `0` or `1` (default: 0).
+
+`fzf#wrap` takes a spec and returns an extended version of it (also a
+dictionary) with additional options for addressing global preferences. You can
+examine the return value of it like so:
+>
+    echo fzf#wrap({'source': 'ls'})
+<
+After we "wrap" our spec, we pass it to `fzf#run`.
+>
+    call fzf#run(fzf#wrap({'source': 'ls'}))
+<
+Now it supports CTRL-T, CTRL-V, and CTRL-X key bindings (configurable via
+`g:fzf_action`) and it opens fzf window according to `g:fzf_layout` setting.
+
+To make it easier to use, let's define `LS` command.
+>
+    command! LS call fzf#run(fzf#wrap({'source': 'ls'}))
+<
+Type `:LS` and see how it works.
+
+We would like to make `:LS!` (bang version) open fzf in fullscreen, just like
+`:FZF!`. Add `-bang` to command definition, and use <bang> value to set the
+last `fullscreen` argument of `fzf#wrap` (see :help <bang>).
+>
+    " On :LS!, <bang> evaluates to '!', and '!0' becomes 1
+    command! -bang LS call fzf#run(fzf#wrap({'source': 'ls'}, <bang>0))
+<
+Our `:LS` command will be much more useful if we can pass a directory argument
+to it, so that something like `:LS /tmp` is possible.
+>
+    command! -bang -complete=dir -nargs=? LS
+        \ call fzf#run(fzf#wrap({'source': 'ls', 'dir': <q-args>}, <bang>0))
+<
+Lastly, if you have enabled `g:fzf_history_dir`, you might want to assign a
+unique name to our command and pass it as the first argument to `fzf#wrap`.
+>
+    " The query history for this command will be stored as 'ls' inside g:fzf_history_dir.
+    " The name is ignored if g:fzf_history_dir is not defined.
+    command! -bang -complete=dir -nargs=? LS
+        \ call fzf#run(fzf#wrap('ls', {'source': 'ls', 'dir': <q-args>}, <bang>0))
+<
+
+< Global options supported by fzf#wrap >______________________________________~
+                                      *fzf-global-options-supported-by-fzf#wrap*
+
+ - `g:fzf_layout`
+ - `g:fzf_action`
+   - Works only when no custom `sink` (or `sinklist`) is provided
+     - Having custom sink usually means that each entry is not an ordinary
+       file path (e.g. name of color scheme), so we can't blindly apply the
+       same strategy (i.e. `tabedit some-color-scheme` doesn't make sense)
+ - `g:fzf_colors`
+ - `g:fzf_history_dir`
+
+
+TIPS                                                                  *fzf-tips*
+==============================================================================
+
+
+< fzf inside terminal buffer >________________________________________________~
+                                                    *fzf-inside-terminal-buffer*
+
+
+On the latest versions of Vim and Neovim, fzf will start in a terminal buffer.
+If you find the default ANSI colors to be different, consider configuring the
+colors using `g:terminal_ansi_colors` in regular Vim or `g:terminal_color_x`
+in Neovim.
+
+>
+    " Terminal colors for seoul256 color scheme
+    if has('nvim')
+      let g:terminal_color_0 = '#4e4e4e'
+      let g:terminal_color_1 = '#d68787'
+      let g:terminal_color_2 = '#5f865f'
+      let g:terminal_color_3 = '#d8af5f'
+      let g:terminal_color_4 = '#85add4'
+      let g:terminal_color_5 = '#d7afaf'
+      let g:terminal_color_6 = '#87afaf'
+      let g:terminal_color_7 = '#d0d0d0'
+      let g:terminal_color_8 = '#626262'
+      let g:terminal_color_9 = '#d75f87'
+      let g:terminal_color_10 = '#87af87'
+      let g:terminal_color_11 = '#ffd787'
+      let g:terminal_color_12 = '#add4fb'
+      let g:terminal_color_13 = '#ffafaf'
+      let g:terminal_color_14 = '#87d7d7'
+      let g:terminal_color_15 = '#e4e4e4'
+    else
+      let g:terminal_ansi_colors = [
+        \ '#4e4e4e', '#d68787', '#5f865f', '#d8af5f',
+        \ '#85add4', '#d7afaf', '#87afaf', '#d0d0d0',
+        \ '#626262', '#d75f87', '#87af87', '#ffd787',
+        \ '#add4fb', '#ffafaf', '#87d7d7', '#e4e4e4'
+      \ ]
+    endif
+<
+
+< Starting fzf in a popup window >____________________________________________~
+                                            *fzf-starting-fzf-in-a-popup-window*
+>
+    " Required:
+    " - width [float range [0 ~ 1]] or [integer range [8 ~ ]]
+    " - height [float range [0 ~ 1]] or [integer range [4 ~ ]]
+    "
+    " Optional:
+    " - xoffset [float default 0.5 range [0 ~ 1]]
+    " - yoffset [float default 0.5 range [0 ~ 1]]
+    " - relative [boolean default v:false]
+    " - border [string default 'rounded']: Border style
+    "   - 'rounded' / 'sharp' / 'horizontal' / 'vertical' / 'top' / 'bottom' / 'left' / 'right'
+    let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+<
+Alternatively, you can make fzf open in a tmux popup window (requires tmux 3.2
+or above) by putting `--tmux` options in `tmux` key.
+>
+    " See `--tmux` option in `man fzf` for available options
+    " [center|top|bottom|left|right][,SIZE[%]][,SIZE[%]]
+    if exists('$TMUX')
+      let g:fzf_layout = { 'tmux': '90%,70%' }
+    else
+      let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6 } }
+    endif
+<
+
+< Hide statusline >___________________________________________________________~
+                                                           *fzf-hide-statusline*
+
+When fzf starts in a terminal buffer, the file type of the buffer is set to
+`fzf`. So you can set up `FileType fzf` autocmd to customize the settings of
+the window.
+
+For example, if you open fzf on the bottom on the screen (e.g. `{'down':
+'40%'}`), you might want to temporarily disable the statusline for a cleaner
+look.
+>
+    let g:fzf_layout = { 'down': '30%' }
+    autocmd! FileType fzf
+    autocmd  FileType fzf set laststatus=0 noshowmode noruler
+      \| autocmd BufLeave <buffer> set laststatus=2 showmode ruler
+<
+
+LICENSE                                                            *fzf-license*
+==============================================================================
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2024 Junegunn Choi
+
+==============================================================================
+vim:tw=78:sw=2:ts=2:ft=help:norl:nowrap:

ext/mkrf_conf.rb

@@ -1,9 +0,0 @@
-require 'rubygems/dependency_installer'
-
-if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.1.0')
-  Gem::DependencyInstaller.new.install 'curses', '~> 1.0'
-end
-
-File.open(File.expand_path('../Rakefile', __FILE__), 'w') do |f|
-  f.puts 'task :default'
-end

fzf-completion.bash

@@ -1,167 +0,0 @@
-#!/bin/bash
-#     ____      ____
-#    / __/___  / __/
-#   / /_/_  / / /_
-#  / __/ / /_/ __/
-# /_/   /___/_/-completion.bash
-#
-# - $FZF_COMPLETION_TRIGGER (default: '**')
-# - $FZF_COMPLETION_OPTS    (default: empty)
-
-_fzf_opts_completion() {
-  local cur prev opts
-  COMPREPLY=()
-  cur="${COMP_WORDS[COMP_CWORD]}"
-  prev="${COMP_WORDS[COMP_CWORD-1]}"
-  opts="-m --multi -x --extended -s --sort +s +i +c --no-color"
-
-  case "${prev}" in
-  --sort|-s)
-    COMPREPLY=( $(compgen -W "$(seq 2000 1000 10000)" -- ${cur}) )
-    return 0
-    ;;
-  esac
-
-  if [[ ${cur} =~ ^-|\+ ]]; then
-    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
-    return 0
-  fi
-
-  return 0
-}
-
-_fzf_generic_completion() {
-  local cur base dir leftover matches trigger
-  COMPREPLY=()
-  trigger=${FZF_COMPLETION_TRIGGER:-**}
-  cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ ${cur} == *"$trigger" ]]; then
-    base=${cur:0:${#cur}-${#trigger}}
-    eval base=$base
-
-    dir="$base"
-    while [ 1 ]; do
-      if [ -z "$dir" -o -d "$dir" ]; then
-        leftover=${base/#"$dir"}
-        leftover=${leftover/#\/}
-        [ "$dir" = './' ] && dir=''
-        tput sc
-        matches=$(find "$dir"* $1 2> /dev/null | fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
-          printf '%q ' "$item"
-        done)
-        matches=${matches% }
-        if [ -n "$matches" ]; then
-          COMPREPLY=( "$matches" )
-        else
-          COMPREPLY=( "$cur" )
-        fi
-        tput rc
-        return 0
-      fi
-      dir=$(dirname "$dir")
-      [[ "$dir" =~ /$ ]] || dir="$dir"/
-    done
-  fi
-}
-
-_fzf_all_completion() {
-  _fzf_generic_completion \
-    "-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
-    "-m"
-}
-
-_fzf_file_completion() {
-  _fzf_generic_completion \
-    "-name .git -prune -o -name .svn -prune -o -type f -print -o -type l -print" \
-    "-m"
-}
-
-_fzf_dir_completion() {
-  _fzf_generic_completion \
-    "-name .git -prune -o -name .svn -prune -o -type d -print" \
-    ""
-}
-
-_fzf_kill_completion() {
-  [ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1
-
-  local selected
-  tput sc
-  selected=$(ps -ef | sed 1d | fzf -m $FZF_COMPLETION_OPTS | awk '{print $2}' | tr '\n' ' ')
-  tput rc
-
-  if [ -n "$selected" ]; then
-    COMPREPLY=( "$selected" )
-    return 0
-  fi
-}
-
-_fzf_telnet_completion() {
-  local cur selected trigger
-  trigger=${FZF_COMPLETION_TRIGGER:-**}
-  cur="${COMP_WORDS[COMP_CWORD]}"
-  [[ ${cur} == *"$trigger" ]] || return 1
-  cur=${cur:0:${#cur}-${#trigger}}
-
-  tput sc
-  selected=$(grep -v '^\s*\(#\|$\)' /etc/hosts | awk '{print $2}' | sort -u | fzf $FZF_COMPLETION_OPTS -q "$cur")
-  tput rc
-
-  if [ -n "$selected" ]; then
-    COMPREPLY=("$selected")
-    return 0
-  fi
-}
-
-_fzf_ssh_completion() {
-  local cur selected trigger
-  trigger=${FZF_COMPLETION_TRIGGER:-**}
-  cur="${COMP_WORDS[COMP_CWORD]}"
-  [[ ${cur} == *"$trigger" ]] || return 1
-  cur=${cur:0:${#cur}-${#trigger}}
-
-  tput sc
-  selected=$(cat \
-    <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | grep -i ^host) \
-    <(grep -v '^\s*\(#\|$\)' /etc/hosts) | \
-    awk '{print $2}' | sort -u | fzf $FZF_COMPLETION_OPTS -q "$cur")
-  tput rc
-
-  if [ -n "$selected" ]; then
-    COMPREPLY=("$selected")
-    return 0
-  fi
-}
-
-complete -F _fzf_opts_completion fzf
-
-# Directory
-for cmd in "cd pushd rmdir"; do
-  complete -F _fzf_dir_completion -o default -o bashdefault $cmd
-done
-
-# File
-for cmd in "
-  awk cat diff diff3
-  emacs ex file ftp g++ gcc gvim head hg java
-  javac ld less more mvim patch perl python ruby
-  sed sftp sort source tail tee uniq vi view vim wc"; do
-  complete -F _fzf_file_completion -o default -o bashdefault $cmd
-done
-
-# Anything
-for cmd in "
-  basename bunzip2 bzip2 chmod chown curl cp dirname du
-  find git grep gunzip gzip hg jar
-  ln ls mv open rm rsync scp
-  svn tar unzip zip"; do
-  complete -F _fzf_all_completion -o default -o bashdefault $cmd
-done
-
-# Kill completion
-complete -F _fzf_kill_completion -o nospace -o default -o bashdefault kill
-
-# Host completion
-complete -F _fzf_ssh_completion -o default -o bashdefault ssh
-complete -F _fzf_telnet_completion -o default -o bashdefault telnet
-

fzf-completion.zsh

@@ -1,9 +0,0 @@
-#!/bin/zsh
-#     ____      ____
-#    / __/___  / __/
-#   / /_/_  / / /_
-#  / __/ / /_/ __/
-# /_/   /___/_/-completion.zsh
-#
-
-# TODO

fzf.gemspec

@@ -1,17 +0,0 @@
-# coding: utf-8
-Gem::Specification.new do |spec|
-  spec.name          = 'fzf'
-  spec.version       = '0.8.2'
-  spec.authors       = ['Junegunn Choi']
-  spec.email         = ['junegunn.c@gmail.com']
-  spec.description   = %q{Fuzzy finder for your shell}
-  spec.summary       = %q{Fuzzy finder for your shell}
-  spec.homepage      = 'https://github.com/junegunn/fzf'
-  spec.license       = 'MIT'
-
-  spec.bindir        = '.'
-  spec.files         = %w[fzf.gemspec]
-  spec.executables   = 'fzf'
-
-  spec.extensions   += ['ext/mkrf_conf.rb']
-end

go.mod

@@ -0,0 +1,20 @@
+module github.com/junegunn/fzf
+
+require (
+	github.com/charlievieth/fastwalk v1.0.8
+	github.com/gdamore/tcell/v2 v2.7.4
+	github.com/junegunn/go-shellwords v0.0.0-20240813092932-a62c48c52e97
+	github.com/mattn/go-isatty v0.0.20
+	github.com/rivo/uniseg v0.4.7
+	golang.org/x/sys v0.25.0
+	golang.org/x/term v0.24.0
+)
+
+require (
+	github.com/gdamore/encoding v1.0.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // indirect
+	golang.org/x/text v0.14.0 // indirect
+)
+
+go 1.20

go.sum

@@ -0,0 +1,57 @@
+github.com/charlievieth/fastwalk v1.0.8 h1:uaoH6cAKSk73aK7aKXqs0+bL+J3Txzd3NGH8tRXgHko=
+github.com/charlievieth/fastwalk v1.0.8/go.mod h1:yGy1zbxog41ZVMcKA/i8ojXLFsuayX5VvwhQVoj9PBI=
+github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
+github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
+github.com/gdamore/tcell/v2 v2.7.4 h1:sg6/UnTM9jGpZU+oFYAsDahfchWAFW8Xx2yFinNSAYU=
+github.com/gdamore/tcell/v2 v2.7.4/go.mod h1:dSXtXTSK0VsW1biw65DZLZ2NKr7j0qP/0J7ONmsraWg=
+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/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
+golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM=
+golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

install

@@ -1,260 +1,390 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
-cd `dirname $BASH_SOURCE`
-fzf_base=`pwd`
+set -u
 
-# ruby executable
-echo -n "Checking Ruby executable ... "
-ruby=`which ruby`
-if [ $? -ne 0 ]; then
-  echo "ruby executable not found!"
-  exit 1
-fi
+version=0.55.0
+auto_completion=
+key_bindings=
+update_config=2
+shells="bash zsh fish"
+prefix='~/.fzf'
+prefix_expand=~/.fzf
+fish_dir=${XDG_CONFIG_HOME:-$HOME/.config}/fish
 
-# System ruby is preferred
-curses_check="begin; require 'curses'; rescue Exception; exit 1; end"
-system_ruby=/usr/bin/ruby
-if [ -x $system_ruby -a $system_ruby != "$ruby" ]; then
-  $system_ruby --disable-gems -e "$curses_check" 2> /dev/null
-  [ $? -eq 0 ] && ruby=$system_ruby
-fi
+help() {
+  cat << EOF
+usage: $0 [OPTIONS]
 
-echo "OK ($ruby)"
+    --help               Show this message
+    --bin                Download fzf binary only; Do not generate ~/.fzf.{bash,zsh}
+    --all                Download fzf binary and update configuration files
+                         to enable key bindings and fuzzy completion
+    --xdg                Generate files under \$XDG_CONFIG_HOME/fzf
+    --[no-]key-bindings  Enable/disable key bindings (CTRL-T, CTRL-R, ALT-C)
+    --[no-]completion    Enable/disable fuzzy completion (bash & zsh)
+    --[no-]update-rc     Whether or not to update shell configuration files
 
-# Curses-support
-echo -n "Checking Curses support ... "
-"$ruby" -e "$curses_check"
-if [ $? -eq 0 ]; then
-  echo "OK"
-else
-  echo "Not found"
-  echo "Installing 'curses' gem ... "
-  /usr/bin/env gem install curses -v 1.0.0 --user-install
-  if [ $? -ne 0 ]; then
-    echo
-    echo "Failed to install 'curses' gem."
-    if [[ $(uname -r) =~ 'ARCH' ]]; then
-      echo "Make sure that base-devel package group is installed."
+    --no-bash            Do not set up bash configuration
+    --no-zsh             Do not set up zsh configuration
+    --no-fish            Do not set up fish configuration
+EOF
+}
+
+for opt in "$@"; do
+  case $opt in
+    --help)
+      help
+      exit 0
+      ;;
+    --all)
+      auto_completion=1
+      key_bindings=1
+      update_config=1
+      ;;
+    --xdg)
+      prefix='"${XDG_CONFIG_HOME:-$HOME/.config}"/fzf/fzf'
+      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/} ;;
+    *)
+      echo "unknown option: $opt"
+      help
+      exit 1
+      ;;
+  esac
+done
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+fzf_base=$(pwd)
+fzf_base_esc=$(printf %q "$fzf_base")
+
+ask() {
+  while true; do
+    read -p "$1 ([y]/n) " -r
+    REPLY=${REPLY:-"y"}
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+      return 1
+    elif [[ $REPLY =~ ^[Nn]$ ]]; then
+      return 0
     fi
+  done
+}
+
+check_binary() {
+  echo -n "  - Checking fzf executable ... "
+  local output
+  output=$("$fzf_base"/bin/fzf --version 2>&1)
+  if [ $? -ne 0 ]; then
+    echo "Error: $output"
+    binary_error="Invalid binary"
+  else
+    output=${output/ */}
+    if [ "$version" != "$output" ]; then
+      echo "$output != $version"
+      binary_error="Invalid version"
+    else
+      echo "$output"
+      binary_error=""
+      return 0
+    fi
+  fi
+  rm -f "$fzf_base"/bin/fzf
+  return 1
+}
+
+link_fzf_in_path() {
+  if which_fzf="$(command -v fzf)"; then
+    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
+  fi
+  return 1
+}
+
+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
+}
+
+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
+}
+
+download() {
+  echo "Downloading bin/fzf ..."
+  if [ -x "$fzf_base"/bin/fzf ]; then
+    echo "  - Already exists"
+    check_binary && return
+  fi
+  link_fzf_in_path && return
+  mkdir -p "$fzf_base"/bin && cd "$fzf_base"/bin
+  if [ $? -ne 0 ]; then
+    binary_error="Failed to create bin directory"
+    return
+  fi
+
+  local url
+  url=https://github.com/junegunn/fzf/releases/download/v$version/${1}
+  set -o pipefail
+  if ! (try_curl $url || try_wget $url); then
+    set +o pipefail
+    binary_error="Failed to download with curl and wget"
+    return
+  fi
+  set +o pipefail
+
+  if [ ! -f fzf ]; then
+    binary_error="Failed to download ${1}"
+    return
+  fi
+
+  chmod +x fzf && check_binary
+}
+
+# Try to download binary executable
+archi=$(uname -sm)
+binary_available=1
+binary_error=""
+case "$archi" in
+  Darwin\ arm64)      download fzf-$version-darwin_arm64.tar.gz  ;;
+  Darwin\ x86_64)     download fzf-$version-darwin_amd64.tar.gz  ;;
+  Linux\ armv5*)      download fzf-$version-linux_armv5.tar.gz   ;;
+  Linux\ armv6*)      download fzf-$version-linux_armv6.tar.gz   ;;
+  Linux\ armv7*)      download fzf-$version-linux_armv7.tar.gz   ;;
+  Linux\ armv8*)      download fzf-$version-linux_arm64.tar.gz   ;;
+  Linux\ aarch64*)    download fzf-$version-linux_arm64.tar.gz   ;;
+  Linux\ loongarch64) download fzf-$version-linux_loong64.tar.gz ;;
+  Linux\ ppc64le)     download fzf-$version-linux_ppc64le.tar.gz ;;
+  Linux\ *64)         download fzf-$version-linux_amd64.tar.gz   ;;
+  Linux\ s390x)       download fzf-$version-linux_s390x.tar.gz   ;;
+  FreeBSD\ *64)       download fzf-$version-freebsd_amd64.tar.gz ;;
+  OpenBSD\ *64)       download fzf-$version-openbsd_amd64.tar.gz ;;
+  CYGWIN*\ *64)       download fzf-$version-windows_amd64.zip    ;;
+  MINGW*\ *64)        download fzf-$version-windows_amd64.zip    ;;
+  MSYS*\ *64)         download fzf-$version-windows_amd64.zip    ;;
+  Windows*\ *64)      download fzf-$version-windows_amd64.zip    ;;
+  *)                  binary_available=0 binary_error=1          ;;
+esac
+
+cd "$fzf_base"
+if [ -n "$binary_error" ]; then
+  if [ $binary_available -eq 0 ]; then
+    echo "No prebuilt binary for $archi ..."
+  else
+    echo "  - $binary_error !!!"
+  fi
+  if command -v go > /dev/null; then
+    echo -n "Building binary (go install github.com/junegunn/fzf) ... "
+    if [ -z "${GOPATH-}" ]; then
+      export GOPATH="${TMPDIR:-/tmp}/fzf-gopath"
+      mkdir -p "$GOPATH"
+    fi
+    if go install -ldflags "-s -w -X main.version=$version -X main.revision=go-install" github.com/junegunn/fzf; then
+      echo "OK"
+      cp "$GOPATH/bin/fzf" "$fzf_base/bin/"
+    else
+      echo "Failed to build binary. Installation failed."
+      exit 1
+    fi
+  else
+    echo "go executable not found. Installation failed."
     exit 1
   fi
 fi
 
-# Ruby version
-echo -n "Checking Ruby version ... "
-"$ruby" -e 'exit RUBY_VERSION >= "1.9"'
-if [ $? -eq 0 ]; then
-  echo ">= 1.9"
-  "$ruby" --disable-gems -e "$curses_check"
-  if [ $? -eq 0 ]; then
-    fzf_cmd="$ruby --disable-gems $fzf_base/fzf"
-  else
-    fzf_cmd="$ruby $fzf_base/fzf"
+[[ "$*" =~ "--bin" ]] && exit 0
+
+for s in $shells; do
+  if ! command -v "$s" > /dev/null; then
+    shells=${shells/$s/}
   fi
-else
-  echo "< 1.9"
-  fzf_cmd="$ruby $fzf_base/fzf"
+done
+
+if [[ ${#shells} -lt 3 ]]; then
+  echo "No shell configuration to be updated."
+  exit 0
 fi
 
 # Auto-completion
-read -p "Do you want to add auto-completion support? ([y]/n) " -n 1 -r
-echo
-[[ ! $REPLY =~ ^[Nn]$ ]]
-auto_completion=$?
+if [ -z "$auto_completion" ]; then
+  ask "Do you want to enable fuzzy auto-completion?"
+  auto_completion=$?
+fi
 
 # Key-bindings
-read -p "Do you want to add key bindings? ([y]/n) " -n 1 -r
-echo
-[[ ! $REPLY =~ ^[Nn]$ ]]
-key_bindings=$?
+if [ -z "$key_bindings" ]; then
+  ask "Do you want to enable key bindings?"
+  key_bindings=$?
+fi
 
 echo
-for shell in bash zsh; do
-  echo -n "Generate ~/.fzf.$shell ... "
-  src=~/.fzf.${shell}
+for shell in $shells; do
+  [[ "$shell" = fish ]] && continue
+  src=${prefix_expand}.${shell}
+  echo -n "Generate $src ... "
 
-  fzf_completion="source $fzf_base/fzf-completion.${shell}"
-  if [ $auto_completion -ne 0 ]; then
+  fzf_completion="source \"$fzf_base/shell/completion.${shell}\""
+  if [ $auto_completion -eq 0 ]; then
     fzf_completion="# $fzf_completion"
   fi
 
-  cat > $src << EOF
-# Setup fzf function
-# ------------------
-unalias fzf 2> /dev/null
-fzf() {
-  $fzf_cmd "\$@"
-}
-export -f fzf > /dev/null
+  fzf_key_bindings="source \"$fzf_base/shell/key-bindings.${shell}\""
+  if [ $key_bindings -eq 0 ]; then
+    fzf_key_bindings="# $fzf_key_bindings"
+  fi
 
+  cat > "$src" << EOF
+# Setup fzf
+# ---------
+if [[ ! "\$PATH" == *$fzf_base_esc/bin* ]]; then
+  PATH="\${PATH:+\${PATH}:}$fzf_base/bin"
+fi
+
+EOF
+
+  if [[ $auto_completion -eq 1 ]] && [[ $key_bindings -eq 1 ]]; then
+    if [[ "$shell" = zsh ]]; then
+      echo "source <(fzf --$shell)" >> "$src"
+    else
+      echo "eval \"\$(fzf --$shell)\"" >> "$src"
+    fi
+  else
+    cat >> "$src" << EOF
 # Auto-completion
 # ---------------
 $fzf_completion
 
-EOF
-
-  if [ $key_bindings -eq 0 ]; then
-    if [ $shell = bash ]; then
-      cat >> $src << "EOFZF"
 # Key bindings
 # ------------
-if [[ $- =~ i ]]; then
-
-read -r -d '' __fsel <<'EOF'
-  find * -path '*/\.*' -prune \
-    -o -type f -print \
-    -o -type d -print \
-    -o -type l -print 2> /dev/null | fzf -m | while read item; do
-    printf '%q ' "$item"
-  done
-  echo
+$fzf_key_bindings
 EOF
-
-__fsel() {
-  eval "$__fsel"
-}
-
-__fsel_tmux() {
-  local height lines
-  height=${FZF_TMUX_HEIGHT:-40%}
-  lines=${LINES:-40}
-  if [[ $height =~ %$ ]]; then
-    height=${height:0:${#height}-1}
-    height=$(( height * lines / 100 ))
   fi
-  tmux split-window -l $height "tmux send-keys -t $TMUX_PANE \"\$($__fsel)\""
-}
-
-__fcd() {
-  local dir
-  dir=$(find ${1:-*} -path '*/\.*' -prune -o -type d -print 2> /dev/null | fzf +m) && printf 'cd %q' "$dir"
-}
-
-__use_tmux=0
-[ -n "$TMUX_PANE" -a ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ] && __use_tmux=1
-
-if [ -z "$(set -o | grep '^vi.*on')" ]; then
-  # Required to refresh the prompt after fzf
-  bind '"\er": redraw-current-line'
-
-  # CTRL-T - Paste the selected file path into the command line
-  if [ $__use_tmux -eq 1 ]; then
-    bind '"\C-t": " \C-u \C-a\C-k$(__fsel_tmux)\e\C-e\C-y\C-a\C-d\C-y\ey\C-h"'
-  else
-    bind '"\C-t": " \C-u \C-a\C-k$(__fsel)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er"'
-  fi
-
-  # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": " \C-e\C-u$(HISTTIMEFORMAT= history | fzf +s | sed \"s/ *[0-9]* *//\")\e\C-e\er"'
-
-  # ALT-C - cd into the selected directory
-  bind '"\ec": " \C-e\C-u$(__fcd)\e\C-e\er\C-m"'
-else
-  bind '"\C-x\C-e": shell-expand-line'
-  bind '"\C-x\C-r": redraw-current-line'
-
-  # CTRL-T - Paste the selected file path into the command line
-  # - FIXME: Selected items are attached to the end regardless of cursor position
-  if [ $__use_tmux -eq 1 ]; then
-    bind '"\C-t": "\e$a \eddi$(__fsel_tmux)\C-x\C-e\e0P$xa"'
-  else
-    bind '"\C-t": "\e$a \eddi$(__fsel)\C-x\C-e\e0Px$a \C-x\C-r"'
-  fi
-
-  # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": "\eddi$(HISTTIMEFORMAT= history | fzf +s | sed \"s/ *[0-9]* *//\")\C-x\C-e\e$a\C-x\C-r"'
-
-  # ALT-C - cd into the selected directory
-  bind '"\ec": "\eddi$(__fcd)\C-x\C-e\C-x\C-r\C-m"'
-fi
-
-unset __use_tmux
-
-fi
-EOFZF
-    else
-      cat >> $src << "EOFZF"
-# Key bindings
-# ------------
-# CTRL-T - Paste the selected file path(s) into the command line
-read -r -d '' __fsel <<'EOF'
-  find * -path '*/\.*' -prune \
-    -o -type f -print \
-    -o -type d -print \
-    -o -type l -print 2> /dev/null | fzf -m | while read item; do
-    printf '%q ' "$item"
-  done
-  echo
-EOF
-
-if [ -n "$TMUX_PANE" -a ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ]; then
-  fzf-file-widget() {
-    local height lines
-    height=${FZF_TMUX_HEIGHT:-40%}
-    lines=${LINES:-40}
-    if [[ $height =~ %$ ]]; then
-      height=${height:0:${#height}-1}
-      height=$(( height * lines / 100 ))
-    fi
-    tmux split-window -l $height "tmux send-keys -t $TMUX_PANE \"\$($__fsel)\""
-  }
-else
-  fzf-file-widget() {
-    LBUFFER="${LBUFFER%% #}$(eval "$__fsel")"
-    zle redisplay
-  }
-fi
-zle     -N   fzf-file-widget
-bindkey '^T' fzf-file-widget
-
-# ALT-C - cd into the selected directory
-fzf-cd-widget() {
-  cd "${$(find * -path '*/\.*' -prune \
-          -o -type d -print 2> /dev/null | fzf):-.}"
-  zle reset-prompt
-}
-zle     -N    fzf-cd-widget
-bindkey '\ec' fzf-cd-widget
-
-# CTRL-R - Paste the selected command from history into the command line
-fzf-history-widget() {
-  LBUFFER=$(fc -l 1 | fzf +s | sed "s/ *[0-9]* *//")
-  zle redisplay
-}
-zle     -N   fzf-history-widget
-bindkey '^R' fzf-history-widget
-
-EOFZF
-    fi
-  fi
-
   echo "OK"
 done
 
-echo
-for shell in bash zsh; do
-  rc=~/.${shell}rc
-  src="source ~/.fzf.${shell}"
+# fish
+if [[ "$shells" =~ fish ]]; then
+  echo -n "Update fish_user_paths ... "
+  fish << EOF
+  echo \$fish_user_paths | \grep "$fzf_base"/bin > /dev/null
+  or set --universal fish_user_paths \$fish_user_paths "$fzf_base"/bin
+EOF
+  [ $? -eq 0 ] && echo "OK" || echo "Failed"
+fi
 
-  echo "Update $rc:"
-  echo "  - $src"
-  line=$(grep -nF "$src" $rc | sed 's/:.*//')
-  if [ -n "$line" ]; then
-    echo "    - Already exists (line #$line)"
+append_line() {
+  set -e
+
+  local update line file pat lno
+  update="$1"
+  line="$2"
+  file="$3"
+  pat="${4:-}"
+  lno=""
+
+  echo "Update $file:"
+  echo "  - $line"
+  if [ -f "$file" ]; then
+    if [ $# -lt 4 ]; then
+      lno=$(\grep -nF "$line" "$file" | sed 's/:.*//' | tr '\n' ' ')
+    else
+      lno=$(\grep -nF "$pat" "$file" | sed 's/:.*//' | tr '\n' ' ')
+    fi
+  fi
+  if [ -n "$lno" ]; then
+    echo "    - Already exists: line #$lno"
   else
-    echo $src >> $rc
-    echo "    - Added"
+    if [ $update -eq 1 ]; then
+      [ -f "$file" ] && echo >> "$file"
+      echo "$line" >> "$file"
+      echo "    + Added"
+    else
+      echo "    ~ Skipped"
+    fi
   fi
   echo
+  set +e
+}
+
+create_file() {
+  local file="$1"
+  shift
+  echo "Create $file:"
+  for line in "$@"; do
+    echo "    $line"
+    echo "$line" >> "$file"
+  done
+  echo
+}
+
+if [ $update_config -eq 2 ]; then
+  echo
+  ask "Do you want to update your shell configuration files?"
+  update_config=$?
+fi
+echo
+for shell in $shells; do
+  [[ "$shell" = fish ]] && continue
+  [ $shell = zsh ] && dest=${ZDOTDIR:-~}/.zshrc || dest=~/.bashrc
+  append_line $update_config "[ -f ${prefix}.${shell} ] && source ${prefix}.${shell}" "$dest" "${prefix}.${shell}"
 done
 
-cat << EOF
-Finished. Reload your .bashrc or .zshrc.
-   source ~/.bashrc  # bash
-   source ~/.zshrc   # zsh
-
-To uninstall fzf, simply remove the added line.
-
-For more information, see: https://github.com/junegunn/fzf
-EOF
+if [ $key_bindings -eq 1 ] && [[ "$shells" =~ fish ]]; then
+  bind_file="${fish_dir}/functions/fish_user_key_bindings.fish"
+  if [ ! -e "$bind_file" ]; then
+    mkdir -p "${fish_dir}/functions"
+    create_file "$bind_file" \
+      'function fish_user_key_bindings' \
+      '  fzf --fish | source' \
+      'end'
+  else
+    echo "Check $bind_file:"
+    lno=$(\grep -nF "fzf_key_bindings" "$bind_file" | sed 's/:.*//' | tr '\n' ' ')
+    if [[ -n $lno ]]; then
+      echo "  ** Found 'fzf_key_bindings' in line #$lno"
+      echo "  ** You have to replace the line to 'fzf --fish | source'"
+      echo
+    else
+      echo "  - Clear"
+      echo
+      append_line $update_config "fzf --fish | source" "$bind_file"
+    fi
+  fi
+fi
 
+if [ $update_config -eq 1 ]; then
+  echo 'Finished. Restart your shell or reload config file.'
+  if [[ "$shells" =~ bash ]]; then
+    echo -n '   source ~/.bashrc  # bash'
+    [[ "$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'
+  echo
+  echo 'Use uninstall script to remove fzf.'
+  echo
+fi
+echo 'For more information, see: https://github.com/junegunn/fzf'

install.ps1

@@ -0,0 +1,65 @@
+$version="0.55.0"
+
+$fzf_base=Split-Path -Parent $MyInvocation.MyCommand.Definition
+
+function check_binary () {
+  Write-Host "  - Checking fzf executable ... " -NoNewline
+  $output=cmd /c $fzf_base\bin\fzf.exe --version 2>&1
+  if (-not $?) {
+    Write-Host "Error: $output"
+    $binary_error="Invalid binary"
+  } else {
+    $output=(-Split $output)[0]
+    if ($version -ne $output) {
+      Write-Host "$output != $version"
+      $binary_error="Invalid version"
+    } else {
+      Write-Host "$output"
+      $binary_error=""
+      return 1
+    }
+  }
+  Remove-Item "$fzf_base\bin\fzf.exe"
+  return 0
+}
+
+function download {
+  param($file)
+  Write-Host "Downloading bin/fzf ..."
+  if (Test-Path "$fzf_base\bin\fzf.exe") {
+    Write-Host "  - Already exists"
+    if (check_binary) {
+      return
+    }
+  }
+  if (-not (Test-Path "$fzf_base\bin")) {
+    md "$fzf_base\bin"
+  }
+  if (-not $?) {
+    $binary_error="Failed to create bin directory"
+    return
+  }
+  cd "$fzf_base\bin"
+  $url="https://github.com/junegunn/fzf/releases/download/v$version/$file"
+  $temp=$env:TMP + "\fzf.zip"
+  [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+  if ($PSVersionTable.PSVersion.Major -ge 3) {
+    Invoke-WebRequest -Uri $url -OutFile $temp
+  } else {
+    (New-Object Net.WebClient).DownloadFile($url, $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath("$temp"))
+  }
+  if ($?) {
+    (Microsoft.PowerShell.Archive\Expand-Archive -Path $temp -DestinationPath .); (Remove-Item $temp)
+  } else {
+    $binary_error="Failed to download with powershell"
+  }
+  if (-not (Test-Path fzf.exe)) {
+    $binary_error="Failed to download $file"
+    return
+  }
+  echo y | icacls $fzf_base\bin\fzf.exe /grant Administrator:F ; check_binary >$null
+}
+
+download "fzf-$version-windows_amd64.zip"
+
+Write-Host 'For more information, see: https://github.com/junegunn/fzf'

main.go

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

man/man1/fzf-tmux.1

@@ -0,0 +1,68 @@
+.ig
+The MIT License (MIT)
+
+Copyright (c) 2013-2024 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+..
+.TH fzf\-tmux 1 "Aug 2024" "fzf 0.55.0" "fzf\-tmux - open fzf in tmux split pane"
+
+.SH NAME
+fzf\-tmux - open fzf in tmux split pane
+
+.SH SYNOPSIS
+.B fzf\-tmux [\fILAYOUT OPTIONS\fR] [\-\-] [\fIFZF OPTIONS\fR]
+
+.SH DESCRIPTION
+fzf\-tmux is a wrapper script for fzf that opens fzf in a tmux split pane or in
+a tmux popup window. It is designed to work just like fzf except that it does
+not take up the whole screen. You can safely use fzf\-tmux instead of fzf in
+your scripts as the extra options will be silently ignored if you're not on
+tmux.
+
+.SH LAYOUT OPTIONS
+
+(default layout: \fB\-d 50%\fR)
+
+.SS Popup window
+(requires tmux 3.2 or above)
+.TP
+.B "\-p [WIDTH[%][,HEIGHT[%]]]"
+.TP
+.B "\-w WIDTH[%]"
+.TP
+.B "\-h WIDTH[%]"
+.TP
+.B "\-x COL"
+.TP
+.B "\-y ROW"
+
+.SS Split pane
+.TP
+.B "\-u [height[%]]"
+Split above (up)
+.TP
+.B "\-d [height[%]]"
+Split below (down)
+.TP
+.B "\-l [width[%]]"
+Split left
+.TP
+.B "\-r [width[%]]"
+Split right

shell/completion.bash

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

shell/completion.zsh

@@ -0,0 +1,377 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ completion.zsh
+#
+# - $FZF_TMUX                 (default: 0)
+# - $FZF_TMUX_OPTS            (default: empty)
+# - $FZF_COMPLETION_TRIGGER   (default: '**')
+# - $FZF_COMPLETION_OPTS      (default: empty)
+# - $FZF_COMPLETION_PATH_OPTS (default: empty)
+# - $FZF_COMPLETION_DIR_OPTS  (default: empty)
+
+
+# Both branches of the following `if` do the same thing -- define
+# __fzf_completion_options such that `eval $__fzf_completion_options` sets
+# all options to the same values they currently have. We'll do just that at
+# the bottom of the file after changing options to what we prefer.
+#
+# IMPORTANT: Until we get to the `emulate` line, all words that *can* be quoted
+# *must* be quoted in order to prevent alias expansion. In addition, code must
+# be written in a way works with any set of zsh options. This is very tricky, so
+# careful when you change it.
+#
+# Start by loading the builtin zsh/parameter module. It provides `options`
+# associative array that stores current shell options.
+if 'zmodload' 'zsh/parameter' 2>'/dev/null' && (( ${+options} )); then
+  # This is the fast branch and it gets taken on virtually all Zsh installations.
+  #
+  # ${(kv)options[@]} expands to array of keys (option names) and values ("on"
+  # or "off"). The subsequent expansion# with (j: :) flag joins all elements
+  # together separated by spaces. __fzf_completion_options ends up with a value
+  # like this: "options=(shwordsplit off aliases on ...)".
+  __fzf_completion_options="options=(${(j: :)${(kv)options[@]}})"
+else
+  # This branch is much slower because it forks to get the names of all
+  # zsh options. It's possible to eliminate this fork but it's not worth the
+  # trouble because this branch gets taken only on very ancient or broken
+  # zsh installations.
+  () {
+    # That `()` above defines an anonymous function. This is essentially a scope
+    # for local parameters. We use it to avoid polluting global scope.
+    'local' '__fzf_opt'
+    __fzf_completion_options="setopt"
+    # `set -o` prints one line for every zsh option. Each line contains option
+    # name, some spaces, and then either "on" or "off". We just want option names.
+    # Expansion with (@f) flag splits a string into lines. The outer expansion
+    # removes spaces and everything that follow them on every line. __fzf_opt
+    # ends up iterating over option names: shwordsplit, aliases, etc.
+    for __fzf_opt in "${(@)${(@f)$(set -o)}%% *}"; do
+      if [[ -o "$__fzf_opt" ]]; then
+        # Option $__fzf_opt is currently on, so remember to set it back on.
+        __fzf_completion_options+=" -o $__fzf_opt"
+      else
+        # Option $__fzf_opt is currently off, so remember to set it back off.
+        __fzf_completion_options+=" +o $__fzf_opt"
+      fi
+    done
+    # The value of __fzf_completion_options here looks like this:
+    # "setopt +o shwordsplit -o aliases ..."
+  }
+fi
+
+# Enable the default zsh options (those marked with <Z> in `man zshoptions`)
+# but without `aliases`. Aliases in functions are expanded when functions are
+# defined, so if we disable aliases here, we'll be sure to have no pesky
+# aliases in any of our functions. This way we won't need prefix every
+# command with `command` or to quote every word to defend against global
+# aliases. Note that `aliases` is not the only option that's important to
+# control. There are several others that could wreck havoc if they are set
+# to values we don't expect. With the following `emulate` command we
+# sidestep this issue entirely.
+'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' 'no_aliases'
+
+# This brace is the start of try-always block. The `always` part is like
+# `finally` in lesser languages. We use it to *always* restore user options.
+{
+# The 'emulate' command should not be placed inside the interactive if check;
+# placing it there fails to disable alias expansion. See #3731.
+if [[ -o interactive ]]; then
+
+# To use custom commands instead of find, override _fzf_compgen_{path,dir}
+#
+#   _fzf_compgen_path() {
+#     echo "$1"
+#     command find -L "$1" \
+#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+#       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+#   }
+#
+#   _fzf_compgen_dir() {
+#     command find -L "$1" \
+#       -name .git -prune -o -name .hg -prune -o -name .svn -prune -o -type d \
+#       -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+#   }
+
+###########################################################
+
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  echo "${FZF_DEFAULT_OPTS-} $2"
+}
+
+__fzf_comprun() {
+  if [[ "$(type _fzf_comprun 2>&1)" =~ function ]]; then
+    _fzf_comprun "$@"
+  elif [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; }; then
+    shift
+    if [ -n "${FZF_TMUX_OPTS-}" ]; then
+      fzf-tmux ${(Q)${(Z+n+)FZF_TMUX_OPTS}} -- "$@"
+    else
+      fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%} -- "$@"
+    fi
+  else
+    shift
+    fzf "$@"
+  fi
+}
+
+# Extract the name of the command. e.g. foo=1 bar baz**<tab>
+__fzf_extract_command() {
+  local token tokens
+  tokens=(${(z)1})
+  for token in $tokens; do
+    token=${(Q)token}
+    if [[ "$token" =~ [[:alnum:]] && ! "$token" =~ "=" ]]; then
+      echo "$token"
+      return
+    fi
+  done
+  echo "${tokens[1]}"
+}
+
+__fzf_generic_path_completion() {
+  local base lbuf cmd compgen fzf_opts suffix tail dir leftover matches
+  base=$1
+  lbuf=$2
+  cmd=$(__fzf_extract_command "$lbuf")
+  compgen=$3
+  fzf_opts=$4
+  suffix=$5
+  tail=$6
+
+  setopt localoptions nonomatch
+  if [[ $base = *'$('* ]] || [[ $base = *'<('* ]] || [[ $base = *'>('* ]] || [[ $base = *':='* ]] || [[ $base = *'`'* ]]; then
+    return
+  fi
+  eval "base=$base" 2> /dev/null || return
+  [[ $base = *"/"* ]] && dir="$base"
+  while [ 1 ]; do
+    if [[ -z "$dir" || -d ${dir} ]]; then
+      leftover=${base/#"$dir"}
+      leftover=${leftover/#\/}
+      [ -z "$dir" ] && dir='.'
+      [ "$dir" != "/" ] && dir="${dir/%\//}"
+      matches=$(
+        export FZF_DEFAULT_OPTS
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --scheme=path" "${FZF_COMPLETION_OPTS-}")
+        unset FZF_DEFAULT_COMMAND FZF_DEFAULT_OPTS_FILE
+        if declare -f "$compgen" > /dev/null; then
+          eval "$compgen $(printf %q "$dir")" | __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover"
+        else
+          if [[ $compgen =~ dir ]]; then
+            walker=dir,follow
+            rest=${FZF_COMPLETION_DIR_OPTS-}
+          else
+            walker=file,dir,follow,hidden
+            rest=${FZF_COMPLETION_PATH_OPTS-}
+          fi
+          __fzf_comprun "$cmd" ${(Q)${(Z+n+)fzf_opts}} -q "$leftover" --walker "$walker" --walker-root="$dir" ${(Q)${(Z+n+)rest}} < /dev/tty
+        fi | while read -r item; do
+          item="${item%$suffix}$suffix"
+          echo -n -E "${(q)item} "
+        done
+      )
+      matches=${matches% }
+      if [ -n "$matches" ]; then
+        LBUFFER="$lbuf$matches$tail"
+      fi
+      zle reset-prompt
+      break
+    fi
+    dir=$(dirname "$dir")
+    dir=${dir%/}/
+  done
+}
+
+_fzf_path_completion() {
+  __fzf_generic_path_completion "$1" "$2" _fzf_compgen_path \
+    "-m" "" " "
+}
+
+_fzf_dir_completion() {
+  __fzf_generic_path_completion "$1" "$2" _fzf_compgen_dir \
+    "" "/" ""
+}
+
+_fzf_feed_fifo() {
+  command rm -f "$1"
+  mkfifo "$1"
+  cat <&0 > "$1" &|
+}
+
+_fzf_complete() {
+  setopt localoptions ksh_arrays
+  # Split arguments around --
+  local args rest str_arg i sep
+  args=("$@")
+  sep=
+  for i in {0..${#args[@]}}; do
+    if [[ "${args[$i]-}" = -- ]]; then
+      sep=$i
+      break
+    fi
+  done
+  if [[ -n "$sep" ]]; then
+    str_arg=
+    rest=("${args[@]:$((sep + 1)):${#args[@]}}")
+    args=("${args[@]:0:$sep}")
+  else
+    str_arg=$1
+    args=()
+    shift
+    rest=("$@")
+  fi
+
+  local fifo lbuf cmd matches post
+  fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
+  lbuf=${rest[0]}
+  cmd=$(__fzf_extract_command "$lbuf")
+  post="${funcstack[1]}_post"
+  type $post > /dev/null 2>&1 || post=cat
+
+  _fzf_feed_fifo "$fifo"
+  matches=$(
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse" "${FZF_COMPLETION_OPTS-} $str_arg") \
+    FZF_DEFAULT_OPTS_FILE='' \
+      __fzf_comprun "$cmd" "${args[@]}" -q "${(Q)prefix}" < "$fifo" | $post | tr '\n' ' ')
+  if [ -n "$matches" ]; then
+    LBUFFER="$lbuf$matches"
+  fi
+  command rm -f "$fifo"
+}
+
+# To use custom hostname lists, override __fzf_list_hosts.
+# The function is expected to print hostnames, one per line as well as in the
+# desired sorting and with any duplicates removed, to standard output.
+if ! declare -f __fzf_list_hosts > /dev/null; then
+  __fzf_list_hosts() {
+    setopt localoptions nonomatch
+    command cat <(command tail -n +1 ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?%]') \
+      <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts 2> /dev/null | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
+      <(command grep -v '^\s*\(#\|$\)' /etc/hosts 2> /dev/null | command grep -Fv '0.0.0.0' | command sed 's/#.*//') |
+      awk '{for (i = 2; i <= NF; i++) print $i}' | sort -u
+  }
+fi
+
+_fzf_complete_telnet() {
+  _fzf_complete +m -- "$@" < <(__fzf_list_hosts)
+}
+
+# The first and the only argument is the LBUFFER without the current word that contains the trigger.
+# The current word without the trigger is in the $prefix variable passed from the caller.
+_fzf_complete_ssh() {
+  local -a tokens
+  tokens=(${(z)1})
+  case ${tokens[-1]} in
+    -i|-F|-E)
+      _fzf_path_completion "$prefix" "$1"
+      ;;
+    *)
+      local user
+      [[ $prefix =~ @ ]] && user="${prefix%%@*}@"
+      _fzf_complete +m -- "$@" < <(__fzf_list_hosts | awk -v user="$user" '{print user $0}')
+      ;;
+  esac
+}
+
+_fzf_complete_export() {
+  _fzf_complete -m -- "$@" < <(
+    declare -xp | sed 's/=.*//' | sed 's/.* //'
+  )
+}
+
+_fzf_complete_unset() {
+  _fzf_complete -m -- "$@" < <(
+    declare -xp | sed 's/=.*//' | sed 's/.* //'
+  )
+}
+
+_fzf_complete_unalias() {
+  _fzf_complete +m -- "$@" < <(
+    alias | sed 's/=.*//'
+  )
+}
+
+_fzf_complete_kill() {
+  _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
+  )
+}
+
+_fzf_complete_kill_post() {
+  awk '{print $2}'
+}
+
+fzf-completion() {
+  local tokens cmd prefix trigger tail matches lbuf d_cmds
+  setopt localoptions noshwordsplit noksh_arrays noposixbuiltins
+
+  # http://zsh.sourceforge.net/FAQ/zshfaq03.html
+  # http://zsh.sourceforge.net/Doc/Release/Expansion.html#Parameter-Expansion-Flags
+  tokens=(${(z)LBUFFER})
+  if [ ${#tokens} -lt 1 ]; then
+    zle ${fzf_default_completion:-expand-or-complete}
+    return
+  fi
+
+  cmd=$(__fzf_extract_command "$LBUFFER")
+
+  # Explicitly allow for empty trigger.
+  trigger=${FZF_COMPLETION_TRIGGER-'**'}
+  [ -z "$trigger" -a ${LBUFFER[-1]} = ' ' ] && tokens+=("")
+
+  # When the trigger starts with ';', it becomes a separate token
+  if [[ ${LBUFFER} = *"${tokens[-2]-}${tokens[-1]}" ]]; then
+    tokens[-2]="${tokens[-2]-}${tokens[-1]}"
+    tokens=(${tokens[0,-2]})
+  fi
+
+  lbuf=$LBUFFER
+  tail=${LBUFFER:$(( ${#LBUFFER} - ${#trigger} ))}
+
+  # Trigger sequence given
+  if [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
+    d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS-cd pushd rmdir})
+
+    [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
+    if [[ $prefix = *'$('* ]] || [[ $prefix = *'<('* ]] || [[ $prefix = *'>('* ]] || [[ $prefix = *':='* ]] || [[ $prefix = *'`'* ]]; then
+      return
+    fi
+    [ -n "${tokens[-1]}" ] && lbuf=${lbuf:0:-${#tokens[-1]}}
+
+    if eval "type _fzf_complete_${cmd} > /dev/null"; then
+      prefix="$prefix" eval _fzf_complete_${cmd} ${(q)lbuf}
+      zle reset-prompt
+    elif [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
+      _fzf_dir_completion "$prefix" "$lbuf"
+    else
+      _fzf_path_completion "$prefix" "$lbuf"
+    fi
+  # Fall back to default completion
+  else
+    zle ${fzf_default_completion:-expand-or-complete}
+  fi
+}
+
+[ -z "$fzf_default_completion" ] && {
+  binding=$(bindkey '^I')
+  [[ $binding =~ 'undefined-key' ]] || fzf_default_completion=$binding[(s: :w)2]
+  unset binding
+}
+
+zle     -N   fzf-completion
+bindkey '^I' fzf-completion
+fi
+
+} always {
+  # Restore the original options.
+  eval $__fzf_completion_options
+  'unset' '__fzf_completion_options'
+}

shell/key-bindings.bash

@@ -0,0 +1,146 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.bash
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
+if [[ $- =~ i ]]; then
+
+
+# Key bindings
+# ------------
+
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  echo "${FZF_DEFAULT_OPTS-} $2"
+}
+
+__fzf_select__() {
+  FZF_DEFAULT_COMMAND=${FZF_CTRL_T_COMMAND:-} \
+  FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=file,dir,follow,hidden --scheme=path" "${FZF_CTRL_T_OPTS-} -m") \
+  FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) "$@" |
+    while read -r item; do
+      printf '%q ' "$item"  # escape special chars
+    done
+}
+
+__fzfcmd() {
+  [[ -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} ))
+}
+
+__fzf_cd__() {
+  local dir
+  dir=$(
+    FZF_DEFAULT_COMMAND=${FZF_ALT_C_COMMAND:-} \
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=dir,follow,hidden --scheme=path" "${FZF_ALT_C_OPTS-} +m") \
+    FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd)
+  ) && printf 'builtin cd -- %q' "$(builtin unset CDPATH && builtin cd -- "$dir" && builtin pwd)"
+}
+
+if command -v perl > /dev/null; then
+  __fzf_history__() {
+    local output script
+    script='BEGIN { getc; $/ = "\n\t"; $HISTCOUNT = $ENV{last_hist} + 1 } s/^[ *]//; s/\n/\n\t/gm; print $HISTCOUNT - $. . "\t$_" if !$seen{$_}++'
+    output=$(
+      set +o pipefail
+      builtin fc -lnr -2147483648 |
+        last_hist=$(HISTTIMEFORMAT='' builtin history 1) command perl -n -l0 -e "$script" |
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"$'\t'"↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
+        FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
+    ) || return
+    READLINE_LINE=$(command perl -pe 's/^\d*\t//' <<< "$output")
+    if [[ -z "$READLINE_POINT" ]]; then
+      echo "$READLINE_LINE"
+    else
+      READLINE_POINT=0x7fffffff
+    fi
+  }
+else # awk - fallback for POSIX systems
+  __fzf_history__() {
+    local output script n x y z d
+    if [[ -z $__fzf_awk ]]; then
+      __fzf_awk=awk
+      # choose the faster mawk if: it's installed && build date >= 20230322 && version >= 1.3.4
+      IFS=' .' read n x y z d <<< $(command mawk -W version 2> /dev/null)
+      [[ $n == mawk ]] && (( d >= 20230302 && (x *1000 +y) *1000 +z >= 1003004 )) && __fzf_awk=mawk
+    fi
+    [[ $(HISTTIMEFORMAT='' builtin history 1) =~ [[:digit:]]+ ]]    # how many history entries
+    script='function P(b) { ++n; sub(/^[ *]/, "", b); if (!seen[b]++) { printf "%d\t%s%c", '$((BASH_REMATCH + 1))' - n, b, 0 } }
+    NR==1 { b = substr($0, 2); next }
+    /^\t/ { P(b); b = substr($0, 2); next }
+    { b = b RS $0 }
+    END { if (NR) P(b) }'
+    output=$(
+      set +o pipefail
+      builtin fc -lnr -2147483648 2> /dev/null |   # ( $'\t '<lines>$'\n' )* ; <lines> ::= [^\n]* ( $'\n'<lines> )*
+        command $__fzf_awk "$script"           |   # ( <counter>$'\t'<lines>$'\000' )*
+        FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"$'\t'"↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} +m --read0") \
+        FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) --query "$READLINE_LINE"
+    ) || return
+    READLINE_LINE=${output#*$'\t'}
+    if [[ -z "$READLINE_POINT" ]]; then
+      echo "$READLINE_LINE"
+    else
+      READLINE_POINT=0x7fffffff
+    fi
+  }
+fi
+
+# Required to refresh the prompt after fzf
+bind -m emacs-standard '"\er": 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
+  # CTRL-T - Paste the selected file path into the command line
+  if [[ "${FZF_CTRL_T_COMMAND-x}" != "" ]]; then
+    bind -m emacs-standard '"\C-t": " \C-b\C-k \C-u`__fzf_select__`\e\C-e\er\C-a\C-y\C-h\C-e\e \C-y\ey\C-x\C-x\C-f"'
+    bind -m vi-command '"\C-t": "\C-z\C-t\C-z"'
+    bind -m vi-insert '"\C-t": "\C-z\C-t\C-z"'
+  fi
+
+  # 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"'
+else
+  # CTRL-T - Paste the selected file path into the command line
+  if [[ "${FZF_CTRL_T_COMMAND-x}" != "" ]]; then
+    bind -m emacs-standard -x '"\C-t": fzf-file-widget'
+    bind -m vi-command -x '"\C-t": fzf-file-widget'
+    bind -m vi-insert -x '"\C-t": fzf-file-widget'
+  fi
+
+  # 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__'
+fi
+
+# ALT-C - cd into the selected directory
+if [[ "${FZF_ALT_C_COMMAND-x}" != "" ]]; then
+  bind -m emacs-standard '"\ec": " \C-b\C-k \C-u`__fzf_cd__`\e\C-e\er\C-m\C-y\C-h\e \C-y\ey\C-x\C-x\C-d"'
+  bind -m vi-command '"\ec": "\C-z\ec\C-z"'
+  bind -m vi-insert '"\ec": "\C-z\ec\C-z"'
+fi
+
+fi

shell/key-bindings.fish

@@ -0,0 +1,197 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.fish
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
+status is-interactive; or exit 0
+
+
+# Key bindings
+# ------------
+function fzf_key_bindings
+
+  function __fzf_defaults
+    # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+    # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    echo "--height $FZF_TMUX_HEIGHT --bind=ctrl-z:ignore" $argv[1]
+    command cat "$FZF_DEFAULT_OPTS_FILE" 2> /dev/null
+    echo $FZF_DEFAULT_OPTS $argv[2]
+  end
+
+  # Store current token in $dir as root for the 'find' command
+  function fzf-file-widget -d "List files and folders"
+    set -l commandline (__fzf_parse_commandline)
+    set -lx dir $commandline[1]
+    set -l 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=file,dir,follow,hidden --scheme=path --walker-root='$dir'" "$FZF_CTRL_T_OPTS")
+      set -lx FZF_DEFAULT_COMMAND "$FZF_CTRL_T_COMMAND"
+      set -lx FZF_DEFAULT_OPTS_FILE ''
+      eval (__fzfcmd)' -m --query "'$fzf_query'"' | while read -l r; set result $result $r; end
+    end
+    if [ -z "$result" ]
+      commandline -f repaint
+      return
+    else
+      # Remove last token from commandline.
+      commandline -t ""
+    end
+    for i in $result
+      commandline -it -- $prefix
+      commandline -it -- (string escape $i)
+      commandline -it -- ' '
+    end
+    commandline -f repaint
+  end
+
+  function fzf-history-widget -d "Show command history"
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    begin
+      set -l FISH_MAJOR (echo $version | cut -f1 -d.)
+      set -l FISH_MINOR (echo $version | cut -f2 -d.)
+
+      # merge history from other sessions before searching
+      if test -z "$fish_private_mode"
+        builtin history merge
+      end
+
+      # history's -z flag is needed for multi-line support.
+      # history's -z flag was added in fish 2.4.0, so don't use it for versions
+      # before 2.4.0.
+      if [ "$FISH_MAJOR" -gt 2 -o \( "$FISH_MAJOR" -eq 2 -a "$FISH_MINOR" -ge 4 \) ];
+        if type -P perl > /dev/null 2>&1
+          set -lx FZF_DEFAULT_OPTS (__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"\t"↳ ' --highlight-line $FZF_CTRL_R_OPTS +m")
+          set -lx FZF_DEFAULT_OPTS_FILE ''
+          builtin history -z --reverse | command perl -0 -pe 's/^/$.\t/g; s/\n/\n\t/gm' | eval (__fzfcmd) --tac --read0 --print0 -q '(commandline)' | command perl -pe 's/^\d*\t//' | read -lz result
+          and commandline -- $result
+        else
+          set -lx FZF_DEFAULT_OPTS (__fzf_defaults "" "--scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '"\t"↳ ' --highlight-line $FZF_CTRL_R_OPTS +m")
+          set -lx FZF_DEFAULT_OPTS_FILE ''
+          builtin history -z | eval (__fzfcmd) --read0 --print0 -q '(commandline)' | read -lz result
+          and commandline -- $result
+        end
+      else
+        builtin history | eval (__fzfcmd) -q '(commandline)' | read -l result
+        and commandline -- $result
+      end
+    end
+    commandline -f repaint
+  end
+
+  function fzf-cd-widget -d "Change directory"
+    set -l commandline (__fzf_parse_commandline)
+    set -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"
+      eval (__fzfcmd)' +m --query "'$fzf_query'"' | read -l result
+
+      if [ -n "$result" ]
+        cd -- $result
+
+        # Remove last token from commandline.
+        commandline -t ""
+        commandline -it -- $prefix
+      end
+    end
+
+    commandline -f repaint
+  end
+
+  function __fzfcmd
+    test -n "$FZF_TMUX"; or set FZF_TMUX 0
+    test -n "$FZF_TMUX_HEIGHT"; or set FZF_TMUX_HEIGHT 40%
+    if [ -n "$FZF_TMUX_OPTS" ]
+      echo "fzf-tmux $FZF_TMUX_OPTS -- "
+    else if [ $FZF_TMUX -eq 1 ]
+      echo "fzf-tmux -d$FZF_TMUX_HEIGHT -- "
+    else
+      echo "fzf"
+    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
+
+  if bind -M insert > /dev/null 2>&1
+    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
+  end
+
+  function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath, fzf query, and optional -option= prefix'
+    set -l commandline (commandline -t)
+
+    # strip -option= from token if present
+    set -l prefix (string match -r -- '^-[^\s=]+=' $commandline)
+    set commandline (string replace -- "$prefix" '' $commandline)
+
+    # eval is used to do shell expansion on paths
+    eval set commandline $commandline
+
+    if [ -z $commandline ]
+      # Default to current directory with no --query
+      set dir '.'
+      set fzf_query ''
+    else
+      set dir (__fzf_get_dir $commandline)
+
+      if [ "$dir" = "." -a (string sub -l 1 -- $commandline) != '.' ]
+        # if $dir is "." but commandline is not a relative path, this means no file path found
+        set fzf_query $commandline
+      else
+        # Also remove trailing slash after dir, to "split" input properly
+        set fzf_query (string replace -r "^$dir/?" -- '' "$commandline")
+      end
+    end
+
+    echo $dir
+    echo $fzf_query
+    echo $prefix
+  end
+
+  function __fzf_get_dir -d 'Find the longest existing filepath from input string'
+    set dir $argv
+
+    # Strip all trailing slashes. Ignore if $dir is root dir (/)
+    if [ (string length -- $dir) -gt 1 ]
+      set dir (string replace -r '/*$' -- '' $dir)
+    end
+
+    # Iteratively check if dir exists and strip tail end of path
+    while [ ! -d "$dir" ]
+      # If path is absolute, this can keep going until ends up at /
+      # If path is relative, this can keep going until entire input is consumed, dirname returns "."
+      set dir (dirname -- "$dir")
+    end
+
+    echo $dir
+  end
+
+end

shell/key-bindings.zsh

@@ -0,0 +1,143 @@
+#     ____      ____
+#    / __/___  / __/
+#   / /_/_  / / /_
+#  / __/ / /_/ __/
+# /_/   /___/_/ key-bindings.zsh
+#
+# - $FZF_TMUX_OPTS
+# - $FZF_CTRL_T_COMMAND
+# - $FZF_CTRL_T_OPTS
+# - $FZF_CTRL_R_OPTS
+# - $FZF_ALT_C_COMMAND
+# - $FZF_ALT_C_OPTS
+
+
+# Key bindings
+# ------------
+
+# The code at the top and the bottom of this file is the same as in completion.zsh.
+# Refer to that file for explanation.
+if 'zmodload' 'zsh/parameter' 2>'/dev/null' && (( ${+options} )); then
+  __fzf_key_bindings_options="options=(${(j: :)${(kv)options[@]}})"
+else
+  () {
+    __fzf_key_bindings_options="setopt"
+    'local' '__fzf_opt'
+    for __fzf_opt in "${(@)${(@f)$(set -o)}%% *}"; do
+      if [[ -o "$__fzf_opt" ]]; then
+        __fzf_key_bindings_options+=" -o $__fzf_opt"
+      else
+        __fzf_key_bindings_options+=" +o $__fzf_opt"
+      fi
+    done
+  }
+fi
+
+'builtin' 'emulate' 'zsh' && 'builtin' 'setopt' 'no_aliases'
+
+{
+if [[ -o interactive ]]; then
+
+__fzf_defaults() {
+  # $1: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  # $2: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
+  echo "--height ${FZF_TMUX_HEIGHT:-40%} --bind=ctrl-z:ignore $1"
+  command cat "${FZF_DEFAULT_OPTS_FILE-}" 2> /dev/null
+  echo "${FZF_DEFAULT_OPTS-} $2"
+}
+
+# CTRL-T - Paste the selected file path(s) into the command line
+__fzf_select() {
+  setopt localoptions pipefail no_aliases 2> /dev/null
+  local item
+  FZF_DEFAULT_COMMAND=${FZF_CTRL_T_COMMAND:-} \
+  FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=file,dir,follow,hidden --scheme=path" "${FZF_CTRL_T_OPTS-} -m") \
+  FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) "$@" < /dev/tty | while read -r item; do
+    echo -n -E "${(q)item} "
+  done
+  local ret=$?
+  echo
+  return $ret
+}
+
+__fzfcmd() {
+  [ -n "${TMUX_PANE-}" ] && { [ "${FZF_TMUX:-0}" != 0 ] || [ -n "${FZF_TMUX_OPTS-}" ]; } &&
+    echo "fzf-tmux ${FZF_TMUX_OPTS:--d${FZF_TMUX_HEIGHT:-40%}} -- " || echo "fzf"
+}
+
+fzf-file-widget() {
+  LBUFFER="${LBUFFER}$(__fzf_select)"
+  local ret=$?
+  zle reset-prompt
+  return $ret
+}
+if [[ "${FZF_CTRL_T_COMMAND-x}" != "" ]]; then
+  zle     -N            fzf-file-widget
+  bindkey -M emacs '^T' fzf-file-widget
+  bindkey -M vicmd '^T' fzf-file-widget
+  bindkey -M viins '^T' fzf-file-widget
+fi
+
+# ALT-C - cd into the selected directory
+fzf-cd-widget() {
+  setopt localoptions pipefail no_aliases 2> /dev/null
+  local dir="$(
+    FZF_DEFAULT_COMMAND=${FZF_ALT_C_COMMAND:-} \
+    FZF_DEFAULT_OPTS=$(__fzf_defaults "--reverse --walker=dir,follow,hidden --scheme=path" "${FZF_ALT_C_OPTS-} +m") \
+    FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd) < /dev/tty)"
+  if [[ -z "$dir" ]]; then
+    zle redisplay
+    return 0
+  fi
+  zle push-line # Clear buffer. Auto-restored on next prompt.
+  BUFFER="builtin cd -- ${(q)dir:a}"
+  zle accept-line
+  local ret=$?
+  unset dir # ensure this doesn't end up appearing in prompt expansion
+  zle reset-prompt
+  return $ret
+}
+if [[ "${FZF_ALT_C_COMMAND-x}" != "" ]]; then
+  zle     -N             fzf-cd-widget
+  bindkey -M emacs '\ec' fzf-cd-widget
+  bindkey -M vicmd '\ec' fzf-cd-widget
+  bindkey -M viins '\ec' fzf-cd-widget
+fi
+
+# CTRL-R - Paste the selected command from history into the command line
+fzf-history-widget() {
+  local selected
+  setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases noglob nobash_rematch 2> /dev/null
+  # Ensure the associative history array, which maps event numbers to the full
+  # history lines, is loaded, and that Perl is installed for multi-line output.
+  if zmodload -F zsh/parameter p:history 2>/dev/null && (( ${#commands[perl]} )); then
+    selected="$(printf '%s\t%s\000' "${(kv)history[@]}" |
+      perl -0 -ne 'if (!$seen{(/^\s*[0-9]+\**\t(.*)/s, $1)}++) { s/\n/\n\t/g; print; }' |
+      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '\t↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m --read0") \
+      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
+  else
+    selected="$(fc -rl 1 | awk '{ cmd=$0; sub(/^[ \t]*[0-9]+\**[ \t]+/, "", cmd); if (!seen[cmd]++) print $0 }' |
+      FZF_DEFAULT_OPTS=$(__fzf_defaults "" "-n2..,.. --scheme=history --bind=ctrl-r:toggle-sort --wrap-sign '\t↳ ' --highlight-line ${FZF_CTRL_R_OPTS-} --query=${(qqq)LBUFFER} +m") \
+      FZF_DEFAULT_OPTS_FILE='' $(__fzfcmd))"
+  fi
+  local ret=$?
+  if [ -n "$selected" ]; then
+    if [[ $(awk '{print $1; exit}' <<< "$selected") =~ ^[1-9][0-9]* ]]; then
+      zle vi-fetch-history -n $MATCH
+    else # selected is a custom query, not from history
+      LBUFFER="$selected"
+    fi
+  fi
+  zle reset-prompt
+  return $ret
+}
+zle     -N            fzf-history-widget
+bindkey -M emacs '^R' fzf-history-widget
+bindkey -M vicmd '^R' fzf-history-widget
+bindkey -M viins '^R' fzf-history-widget
+fi
+
+} always {
+  eval $__fzf_key_bindings_options
+  'unset' '__fzf_key_bindings_options'
+}

src/LICENSE

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

src/actiontype_string.go

@@ -0,0 +1,135 @@
+// Code generated by "stringer -type=actionType"; DO NOT EDIT.
+
+package fzf
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[actIgnore-0]
+	_ = x[actStart-1]
+	_ = x[actClick-2]
+	_ = x[actInvalid-3]
+	_ = x[actChar-4]
+	_ = x[actMouse-5]
+	_ = x[actBeginningOfLine-6]
+	_ = x[actAbort-7]
+	_ = x[actAccept-8]
+	_ = x[actAcceptNonEmpty-9]
+	_ = x[actAcceptOrPrintQuery-10]
+	_ = x[actBackwardChar-11]
+	_ = x[actBackwardDeleteChar-12]
+	_ = x[actBackwardDeleteCharEof-13]
+	_ = x[actBackwardWord-14]
+	_ = x[actCancel-15]
+	_ = x[actChangeBorderLabel-16]
+	_ = x[actChangeHeader-17]
+	_ = x[actChangeMulti-18]
+	_ = x[actChangePreviewLabel-19]
+	_ = x[actChangePrompt-20]
+	_ = x[actChangeQuery-21]
+	_ = x[actClearScreen-22]
+	_ = x[actClearQuery-23]
+	_ = x[actClearSelection-24]
+	_ = x[actClose-25]
+	_ = x[actDeleteChar-26]
+	_ = x[actDeleteCharEof-27]
+	_ = x[actEndOfLine-28]
+	_ = x[actFatal-29]
+	_ = x[actForwardChar-30]
+	_ = x[actForwardWord-31]
+	_ = x[actKillLine-32]
+	_ = x[actKillWord-33]
+	_ = x[actUnixLineDiscard-34]
+	_ = x[actUnixWordRubout-35]
+	_ = x[actYank-36]
+	_ = x[actBackwardKillWord-37]
+	_ = x[actSelectAll-38]
+	_ = x[actDeselectAll-39]
+	_ = x[actToggle-40]
+	_ = x[actToggleSearch-41]
+	_ = x[actToggleAll-42]
+	_ = x[actToggleDown-43]
+	_ = x[actToggleUp-44]
+	_ = x[actToggleIn-45]
+	_ = x[actToggleOut-46]
+	_ = x[actToggleTrack-47]
+	_ = x[actToggleTrackCurrent-48]
+	_ = x[actToggleHeader-49]
+	_ = x[actToggleWrap-50]
+	_ = x[actTrackCurrent-51]
+	_ = x[actUntrackCurrent-52]
+	_ = x[actDown-53]
+	_ = x[actUp-54]
+	_ = x[actPageUp-55]
+	_ = x[actPageDown-56]
+	_ = x[actPosition-57]
+	_ = x[actHalfPageUp-58]
+	_ = x[actHalfPageDown-59]
+	_ = x[actOffsetUp-60]
+	_ = x[actOffsetDown-61]
+	_ = x[actOffsetMiddle-62]
+	_ = x[actJump-63]
+	_ = x[actJumpAccept-64]
+	_ = x[actPrintQuery-65]
+	_ = x[actRefreshPreview-66]
+	_ = x[actReplaceQuery-67]
+	_ = x[actToggleSort-68]
+	_ = x[actShowPreview-69]
+	_ = x[actHidePreview-70]
+	_ = x[actTogglePreview-71]
+	_ = x[actTogglePreviewWrap-72]
+	_ = x[actTransform-73]
+	_ = x[actTransformBorderLabel-74]
+	_ = x[actTransformHeader-75]
+	_ = x[actTransformPreviewLabel-76]
+	_ = x[actTransformPrompt-77]
+	_ = x[actTransformQuery-78]
+	_ = x[actPreview-79]
+	_ = x[actChangePreview-80]
+	_ = x[actChangePreviewWindow-81]
+	_ = x[actPreviewTop-82]
+	_ = x[actPreviewBottom-83]
+	_ = x[actPreviewUp-84]
+	_ = x[actPreviewDown-85]
+	_ = x[actPreviewPageUp-86]
+	_ = x[actPreviewPageDown-87]
+	_ = x[actPreviewHalfPageUp-88]
+	_ = x[actPreviewHalfPageDown-89]
+	_ = x[actPrevHistory-90]
+	_ = x[actPrevSelected-91]
+	_ = x[actPrint-92]
+	_ = x[actPut-93]
+	_ = x[actNextHistory-94]
+	_ = x[actNextSelected-95]
+	_ = x[actExecute-96]
+	_ = x[actExecuteSilent-97]
+	_ = x[actExecuteMulti-98]
+	_ = x[actSigStop-99]
+	_ = x[actFirst-100]
+	_ = x[actLast-101]
+	_ = x[actReload-102]
+	_ = x[actReloadSync-103]
+	_ = x[actDisableSearch-104]
+	_ = x[actEnableSearch-105]
+	_ = x[actSelect-106]
+	_ = x[actDeselect-107]
+	_ = x[actUnbind-108]
+	_ = x[actRebind-109]
+	_ = x[actBecome-110]
+	_ = x[actShowHeader-111]
+	_ = x[actHideHeader-112]
+}
+
+const _actionType_name = "actIgnoreactStartactClickactInvalidactCharactMouseactBeginningOfLineactAbortactAcceptactAcceptNonEmptyactAcceptOrPrintQueryactBackwardCharactBackwardDeleteCharactBackwardDeleteCharEofactBackwardWordactCancelactChangeBorderLabelactChangeHeaderactChangeMultiactChangePreviewLabelactChangePromptactChangeQueryactClearScreenactClearQueryactClearSelectionactCloseactDeleteCharactDeleteCharEofactEndOfLineactFatalactForwardCharactForwardWordactKillLineactKillWordactUnixLineDiscardactUnixWordRuboutactYankactBackwardKillWordactSelectAllactDeselectAllactToggleactToggleSearchactToggleAllactToggleDownactToggleUpactToggleInactToggleOutactToggleTrackactToggleTrackCurrentactToggleHeaderactToggleWrapactTrackCurrentactUntrackCurrentactDownactUpactPageUpactPageDownactPositionactHalfPageUpactHalfPageDownactOffsetUpactOffsetDownactOffsetMiddleactJumpactJumpAcceptactPrintQueryactRefreshPreviewactReplaceQueryactToggleSortactShowPreviewactHidePreviewactTogglePreviewactTogglePreviewWrapactTransformactTransformBorderLabelactTransformHeaderactTransformPreviewLabelactTransformPromptactTransformQueryactPreviewactChangePreviewactChangePreviewWindowactPreviewTopactPreviewBottomactPreviewUpactPreviewDownactPreviewPageUpactPreviewPageDownactPreviewHalfPageUpactPreviewHalfPageDownactPrevHistoryactPrevSelectedactPrintactPutactNextHistoryactNextSelectedactExecuteactExecuteSilentactExecuteMultiactSigStopactFirstactLastactReloadactReloadSyncactDisableSearchactEnableSearchactSelectactDeselectactUnbindactRebindactBecomeactShowHeaderactHideHeader"
+
+var _actionType_index = [...]uint16{0, 9, 17, 25, 35, 42, 50, 68, 76, 85, 102, 123, 138, 159, 183, 198, 207, 227, 242, 256, 277, 292, 306, 320, 333, 350, 358, 371, 387, 399, 407, 421, 435, 446, 457, 475, 492, 499, 518, 530, 544, 553, 568, 580, 593, 604, 615, 627, 641, 662, 677, 690, 705, 722, 729, 734, 743, 754, 765, 778, 793, 804, 817, 832, 839, 852, 865, 882, 897, 910, 924, 938, 954, 974, 986, 1009, 1027, 1051, 1069, 1086, 1096, 1112, 1134, 1147, 1163, 1175, 1189, 1205, 1223, 1243, 1265, 1279, 1294, 1302, 1308, 1322, 1337, 1347, 1363, 1378, 1388, 1396, 1403, 1412, 1425, 1441, 1456, 1465, 1476, 1485, 1494, 1503, 1516, 1529}
+
+func (i actionType) String() string {
+	if i < 0 || i >= actionType(len(_actionType_index)-1) {
+		return "actionType(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _actionType_name[_actionType_index[i]:_actionType_index[i+1]]
+}

src/algo/algo_test.go

@@ -0,0 +1,202 @@
+package algo
+
+import (
+	"math"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func init() {
+	Init("default")
+}
+
+func assertMatch(t *testing.T, fun Algo, caseSensitive, forward bool, input, pattern string, sidx int, eidx int, score int) {
+	assertMatch2(t, fun, caseSensitive, false, forward, input, pattern, sidx, eidx, score)
+}
+
+func assertMatch2(t *testing.T, fun Algo, caseSensitive, normalize, forward bool, input, pattern string, sidx int, eidx int, score int) {
+	if !caseSensitive {
+		pattern = strings.ToLower(pattern)
+	}
+	chars := util.ToChars([]byte(input))
+	res, pos := fun(caseSensitive, normalize, forward, &chars, []rune(pattern), true, nil)
+	var start, end int
+	if pos == nil || len(*pos) == 0 {
+		start = res.Start
+		end = res.End
+	} else {
+		sort.Ints(*pos)
+		start = (*pos)[0]
+		end = (*pos)[len(*pos)-1] + 1
+	}
+	if start != sidx {
+		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", start, sidx, input, pattern)
+	}
+	if end != eidx {
+		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", end, eidx, input, pattern)
+	}
+	if res.Score != score {
+		t.Errorf("Invalid score: %d (expected: %d, %s / %s)", res.Score, score, input, pattern)
+	}
+}
+
+func TestFuzzyMatch(t *testing.T) {
+	for _, fn := range []Algo{FuzzyMatchV1, FuzzyMatchV2} {
+		for _, forward := range []bool{true, false} {
+			assertMatch(t, fn, false, forward, "fooBarbaz1", "oBZ", 2, 9,
+				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtension*3)
+			assertMatch(t, fn, false, forward, "foo bar baz", "fbb", 0, 9,
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+					int(bonusBoundaryWhite)*2+2*scoreGapStart+4*scoreGapExtension)
+			assertMatch(t, fn, false, forward, "/AutomatorDocument.icns", "rdoc", 9, 13,
+				scoreMatch*4+bonusCamel123+bonusConsecutive*2)
+			assertMatch(t, fn, false, forward, "/man1/zshcompctl.1", "zshc", 6, 10,
+				scoreMatch*4+int(bonusBoundaryDelimiter)*bonusFirstCharMultiplier+int(bonusBoundaryDelimiter)*3)
+			assertMatch(t, fn, false, forward, "/.oh-my-zsh/cache", "zshc", 8, 13,
+				scoreMatch*4+bonusBoundary*bonusFirstCharMultiplier+bonusBoundary*2+scoreGapStart+int(bonusBoundaryDelimiter))
+			assertMatch(t, fn, false, forward, "ab0123 456", "12356", 3, 10,
+				scoreMatch*5+bonusConsecutive*3+scoreGapStart+scoreGapExtension)
+			assertMatch(t, fn, false, forward, "abc123 456", "12356", 3, 10,
+				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+bonusConsecutive+scoreGapStart+scoreGapExtension)
+			assertMatch(t, fn, false, forward, "foo/bar/baz", "fbb", 0, 9,
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+					int(bonusBoundaryDelimiter)*2+2*scoreGapStart+4*scoreGapExtension)
+			assertMatch(t, fn, false, forward, "fooBarBaz", "fbb", 0, 7,
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+					bonusCamel123*2+2*scoreGapStart+2*scoreGapExtension)
+			assertMatch(t, fn, false, forward, "foo barbaz", "fbb", 0, 8,
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)+
+					scoreGapStart*2+scoreGapExtension*3)
+			assertMatch(t, fn, false, forward, "fooBar Baz", "foob", 0, 4,
+				scoreMatch*4+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)*3)
+			assertMatch(t, fn, false, forward, "xFoo-Bar Baz", "foo-b", 1, 6,
+				scoreMatch*5+bonusCamel123*bonusFirstCharMultiplier+bonusCamel123*2+
+					bonusNonWord+bonusBoundary)
+
+			assertMatch(t, fn, true, forward, "fooBarbaz", "oBz", 2, 9,
+				scoreMatch*3+bonusCamel123+scoreGapStart+scoreGapExtension*3)
+			assertMatch(t, fn, true, forward, "Foo/Bar/Baz", "FBB", 0, 9,
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryDelimiter)*2+
+					scoreGapStart*2+scoreGapExtension*4)
+			assertMatch(t, fn, true, forward, "FooBarBaz", "FBB", 0, 7,
+				scoreMatch*3+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+bonusCamel123*2+
+					scoreGapStart*2+scoreGapExtension*2)
+			assertMatch(t, fn, true, forward, "FooBar Baz", "FooB", 0, 4,
+				scoreMatch*4+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite)*2+
+					util.Max(bonusCamel123, int(bonusBoundaryWhite)))
+
+			// Consecutive bonus updated
+			assertMatch(t, fn, true, forward, "foo-bar", "o-ba", 2, 6,
+				scoreMatch*4+bonusBoundary*3)
+
+			// Non-match
+			assertMatch(t, fn, true, forward, "fooBarbaz", "oBZ", -1, -1, 0)
+			assertMatch(t, fn, true, forward, "Foo Bar Baz", "fbb", -1, -1, 0)
+			assertMatch(t, fn, true, forward, "fooBarbaz", "fooBarbazz", -1, -1, 0)
+		}
+	}
+}
+
+func TestFuzzyMatchBackward(t *testing.T) {
+	assertMatch(t, FuzzyMatchV1, false, true, "foobar fb", "fb", 0, 4,
+		scoreMatch*2+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+
+			scoreGapStart+scoreGapExtension)
+	assertMatch(t, FuzzyMatchV1, false, false, "foobar fb", "fb", 7, 9,
+		scoreMatch*2+int(bonusBoundaryWhite)*bonusFirstCharMultiplier+int(bonusBoundaryWhite))
+}
+
+func TestExactMatchNaive(t *testing.T) {
+	for _, dir := range []bool{true, false} {
+		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "oBA", -1, -1, 0)
+		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "fooBarbazz", -1, -1, 0)
+
+		assertMatch(t, ExactMatchNaive, false, dir, "fooBarbaz", "oBA", 2, 5,
+			scoreMatch*3+bonusCamel123+bonusConsecutive)
+		assertMatch(t, ExactMatchNaive, false, dir, "/AutomatorDocument.icns", "rdoc", 9, 13,
+			scoreMatch*4+bonusCamel123+bonusConsecutive*2)
+		assertMatch(t, ExactMatchNaive, false, dir, "/man1/zshcompctl.1", "zshc", 6, 10,
+			scoreMatch*4+int(bonusBoundaryDelimiter)*(bonusFirstCharMultiplier+3))
+		assertMatch(t, ExactMatchNaive, false, dir, "/.oh-my-zsh/cache", "zsh/c", 8, 13,
+			scoreMatch*5+bonusBoundary*(bonusFirstCharMultiplier+3)+int(bonusBoundaryDelimiter))
+	}
+}
+
+func TestExactMatchNaiveBackward(t *testing.T) {
+	assertMatch(t, ExactMatchNaive, false, true, "foobar foob", "oo", 1, 3,
+		scoreMatch*2+bonusConsecutive)
+	assertMatch(t, ExactMatchNaive, false, false, "foobar foob", "oo", 8, 10,
+		scoreMatch*2+bonusConsecutive)
+}
+
+func TestPrefixMatch(t *testing.T) {
+	score := scoreMatch*3 + int(bonusBoundaryWhite)*bonusFirstCharMultiplier + int(bonusBoundaryWhite)*2
+
+	for _, dir := range []bool{true, false} {
+		assertMatch(t, PrefixMatch, true, dir, "fooBarbaz", "Foo", -1, -1, 0)
+		assertMatch(t, PrefixMatch, false, dir, "fooBarBaz", "baz", -1, -1, 0)
+		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "Foo", 0, 3, score)
+		assertMatch(t, PrefixMatch, false, dir, "foOBarBaZ", "foo", 0, 3, score)
+		assertMatch(t, PrefixMatch, false, dir, "f-oBarbaz", "f-o", 0, 3, score)
+
+		assertMatch(t, PrefixMatch, false, dir, " fooBar", "foo", 1, 4, score)
+		assertMatch(t, PrefixMatch, false, dir, " fooBar", " fo", 0, 3, score)
+		assertMatch(t, PrefixMatch, false, dir, "     fo", "foo", -1, -1, 0)
+	}
+}
+
+func TestSuffixMatch(t *testing.T) {
+	for _, dir := range []bool{true, false} {
+		assertMatch(t, SuffixMatch, true, dir, "fooBarbaz", "Baz", -1, -1, 0)
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "Foo", -1, -1, 0)
+
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "baz", 6, 9,
+			scoreMatch*3+bonusConsecutive*2)
+		assertMatch(t, SuffixMatch, false, dir, "fooBarBaZ", "baz", 6, 9,
+			(scoreMatch+bonusCamel123)*3+bonusCamel123*(bonusFirstCharMultiplier-1))
+
+		// Strip trailing white space from the string
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz", 6, 9,
+			scoreMatch*3+bonusConsecutive*2)
+
+		// Only when the pattern doesn't end with a space
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz ", "baz ", 6, 10,
+			scoreMatch*4+bonusConsecutive*2+int(bonusBoundaryWhite))
+	}
+}
+
+func TestEmptyPattern(t *testing.T) {
+	for _, dir := range []bool{true, false} {
+		assertMatch(t, FuzzyMatchV1, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, FuzzyMatchV2, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, ExactMatchNaive, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, PrefixMatch, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, SuffixMatch, true, dir, "foobar", "", 6, 6, 0)
+	}
+}
+
+func TestNormalize(t *testing.T) {
+	caseSensitive := false
+	normalize := true
+	forward := true
+	test := func(input, pattern string, sidx, eidx, score int, funs ...Algo) {
+		for _, fun := range funs {
+			assertMatch2(t, fun, caseSensitive, normalize, forward,
+				input, pattern, sidx, eidx, score)
+		}
+	}
+	test("Só Danço Samba", "So", 0, 2, 62, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, ExactMatchNaive)
+	test("Só Danço Samba", "sodc", 0, 7, 97, FuzzyMatchV1, FuzzyMatchV2)
+	test("Danço", "danco", 0, 5, 140, FuzzyMatchV1, FuzzyMatchV2, PrefixMatch, SuffixMatch, ExactMatchNaive, EqualMatch)
+}
+
+func TestLongString(t *testing.T) {
+	bytes := make([]byte, math.MaxUint16*2)
+	for i := range bytes {
+		bytes[i] = 'x'
+	}
+	bytes[math.MaxUint16] = 'z'
+	assertMatch(t, FuzzyMatchV2, true, true, string(bytes), "zx", math.MaxUint16, math.MaxUint16+2, scoreMatch*2+bonusConsecutive)
+}

src/algo/normalize.go

@@ -0,0 +1,492 @@
+// Normalization of latin script letters
+// Reference: http://www.unicode.org/Public/UCD/latest/ucd/Index.txt
+
+package algo
+
+var normalized = map[rune]rune{
+	0x00E1: 'a', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0103: 'a', //  WITH BREVE, LATIN SMALL LETTER
+	0x01CE: 'a', //  WITH CARON, LATIN SMALL LETTER
+	0x00E2: 'a', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00E4: 'a', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x0227: 'a', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1EA1: 'a', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0201: 'a', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00E0: 'a', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EA3: 'a', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x0203: 'a', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x0101: 'a', //  WITH MACRON, LATIN SMALL LETTER
+	0x0105: 'a', //  WITH OGONEK, LATIN SMALL LETTER
+	0x1E9A: 'a', //  WITH RIGHT HALF RING, LATIN SMALL LETTER
+	0x00E5: 'a', //  WITH RING ABOVE, LATIN SMALL LETTER
+	0x1E01: 'a', //  WITH RING BELOW, LATIN SMALL LETTER
+	0x00E3: 'a', //  WITH TILDE, LATIN SMALL LETTER
+	0x0363: 'a', // , COMBINING LATIN SMALL LETTER
+	0x0250: 'a', // , LATIN SMALL LETTER TURNED
+	0x1E03: 'b', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E05: 'b', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0253: 'b', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E07: 'b', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0180: 'b', //  WITH STROKE, LATIN SMALL LETTER
+	0x0183: 'b', //  WITH TOPBAR, LATIN SMALL LETTER
+	0x0107: 'c', //  WITH ACUTE, LATIN SMALL LETTER
+	0x010D: 'c', //  WITH CARON, LATIN SMALL LETTER
+	0x00E7: 'c', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x0109: 'c', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x0255: 'c', //  WITH CURL, LATIN SMALL LETTER
+	0x010B: 'c', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x0188: 'c', //  WITH HOOK, LATIN SMALL LETTER
+	0x023C: 'c', //  WITH STROKE, LATIN SMALL LETTER
+	0x0368: 'c', // , COMBINING LATIN SMALL LETTER
+	0x0297: 'c', // , LATIN LETTER STRETCHED
+	0x2184: 'c', // , LATIN SMALL LETTER REVERSED
+	0x010F: 'd', //  WITH CARON, LATIN SMALL LETTER
+	0x1E11: 'd', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E13: 'd', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x0221: 'd', //  WITH CURL, LATIN SMALL LETTER
+	0x1E0B: 'd', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E0D: 'd', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0257: 'd', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E0F: 'd', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0111: 'd', //  WITH STROKE, LATIN SMALL LETTER
+	0x0256: 'd', //  WITH TAIL, LATIN SMALL LETTER
+	0x018C: 'd', //  WITH TOPBAR, LATIN SMALL LETTER
+	0x0369: 'd', // , COMBINING LATIN SMALL LETTER
+	0x00E9: 'e', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0115: 'e', //  WITH BREVE, LATIN SMALL LETTER
+	0x011B: 'e', //  WITH CARON, LATIN SMALL LETTER
+	0x0229: 'e', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E19: 'e', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x00EA: 'e', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00EB: 'e', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x0117: 'e', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1EB9: 'e', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0205: 'e', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00E8: 'e', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EBB: 'e', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x025D: 'e', //  WITH HOOK, LATIN SMALL LETTER REVERSED OPEN
+	0x0207: 'e', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x0113: 'e', //  WITH MACRON, LATIN SMALL LETTER
+	0x0119: 'e', //  WITH OGONEK, LATIN SMALL LETTER
+	0x0247: 'e', //  WITH STROKE, LATIN SMALL LETTER
+	0x1E1B: 'e', //  WITH TILDE BELOW, LATIN SMALL LETTER
+	0x1EBD: 'e', //  WITH TILDE, LATIN SMALL LETTER
+	0x0364: 'e', // , COMBINING LATIN SMALL LETTER
+	0x029A: 'e', // , LATIN SMALL LETTER CLOSED OPEN
+	0x025E: 'e', // , LATIN SMALL LETTER CLOSED REVERSED OPEN
+	0x025B: 'e', // , LATIN SMALL LETTER OPEN
+	0x0258: 'e', // , LATIN SMALL LETTER REVERSED
+	0x025C: 'e', // , LATIN SMALL LETTER REVERSED OPEN
+	0x01DD: 'e', // , LATIN SMALL LETTER TURNED
+	0x1D08: 'e', // , LATIN SMALL LETTER TURNED OPEN
+	0x1E1F: 'f', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x0192: 'f', //  WITH HOOK, LATIN SMALL LETTER
+	0x01F5: 'g', //  WITH ACUTE, LATIN SMALL LETTER
+	0x011F: 'g', //  WITH BREVE, LATIN SMALL LETTER
+	0x01E7: 'g', //  WITH CARON, LATIN SMALL LETTER
+	0x0123: 'g', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x011D: 'g', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x0121: 'g', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x0260: 'g', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E21: 'g', //  WITH MACRON, LATIN SMALL LETTER
+	0x01E5: 'g', //  WITH STROKE, LATIN SMALL LETTER
+	0x0261: 'g', // , LATIN SMALL LETTER SCRIPT
+	0x1E2B: 'h', //  WITH BREVE BELOW, LATIN SMALL LETTER
+	0x021F: 'h', //  WITH CARON, LATIN SMALL LETTER
+	0x1E29: 'h', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x0125: 'h', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x1E27: 'h', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E23: 'h', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E25: 'h', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x02AE: 'h', //  WITH FISHHOOK, LATIN SMALL LETTER TURNED
+	0x0266: 'h', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E96: 'h', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0127: 'h', //  WITH STROKE, LATIN SMALL LETTER
+	0x036A: 'h', // , COMBINING LATIN SMALL LETTER
+	0x0265: 'h', // , LATIN SMALL LETTER TURNED
+	0x2095: 'h', // , LATIN SUBSCRIPT SMALL LETTER
+	0x00ED: 'i', //  WITH ACUTE, LATIN SMALL LETTER
+	0x012D: 'i', //  WITH BREVE, LATIN SMALL LETTER
+	0x01D0: 'i', //  WITH CARON, LATIN SMALL LETTER
+	0x00EE: 'i', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00EF: 'i', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1ECB: 'i', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0209: 'i', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00EC: 'i', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EC9: 'i', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x020B: 'i', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x012B: 'i', //  WITH MACRON, LATIN SMALL LETTER
+	0x012F: 'i', //  WITH OGONEK, LATIN SMALL LETTER
+	0x0268: 'i', //  WITH STROKE, LATIN SMALL LETTER
+	0x1E2D: 'i', //  WITH TILDE BELOW, LATIN SMALL LETTER
+	0x0129: 'i', //  WITH TILDE, LATIN SMALL LETTER
+	0x0365: 'i', // , COMBINING LATIN SMALL LETTER
+	0x0131: 'i', // , LATIN SMALL LETTER DOTLESS
+	0x1D09: 'i', // , LATIN SMALL LETTER TURNED
+	0x1D62: 'i', // , LATIN SUBSCRIPT SMALL LETTER
+	0x2071: 'i', // , SUPERSCRIPT LATIN SMALL LETTER
+	0x01F0: 'j', //  WITH CARON, LATIN SMALL LETTER
+	0x0135: 'j', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x029D: 'j', //  WITH CROSSED-TAIL, LATIN SMALL LETTER
+	0x0249: 'j', //  WITH STROKE, LATIN SMALL LETTER
+	0x025F: 'j', //  WITH STROKE, LATIN SMALL LETTER DOTLESS
+	0x0237: 'j', // , LATIN SMALL LETTER DOTLESS
+	0x1E31: 'k', //  WITH ACUTE, LATIN SMALL LETTER
+	0x01E9: 'k', //  WITH CARON, LATIN SMALL LETTER
+	0x0137: 'k', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E33: 'k', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0199: 'k', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E35: 'k', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x029E: 'k', // , LATIN SMALL LETTER TURNED
+	0x2096: 'k', // , LATIN SUBSCRIPT SMALL LETTER
+	0x013A: 'l', //  WITH ACUTE, LATIN SMALL LETTER
+	0x019A: 'l', //  WITH BAR, LATIN SMALL LETTER
+	0x026C: 'l', //  WITH BELT, LATIN SMALL LETTER
+	0x013E: 'l', //  WITH CARON, LATIN SMALL LETTER
+	0x013C: 'l', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E3D: 'l', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x0234: 'l', //  WITH CURL, LATIN SMALL LETTER
+	0x1E37: 'l', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x1E3B: 'l', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0140: 'l', //  WITH MIDDLE DOT, LATIN SMALL LETTER
+	0x026B: 'l', //  WITH MIDDLE TILDE, LATIN SMALL LETTER
+	0x026D: 'l', //  WITH RETROFLEX HOOK, LATIN SMALL LETTER
+	0x0142: 'l', //  WITH STROKE, LATIN SMALL LETTER
+	0x2097: 'l', // , LATIN SUBSCRIPT SMALL LETTER
+	0x1E3F: 'm', //  WITH ACUTE, LATIN SMALL LETTER
+	0x1E41: 'm', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E43: 'm', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0271: 'm', //  WITH HOOK, LATIN SMALL LETTER
+	0x0270: 'm', //  WITH LONG LEG, LATIN SMALL LETTER TURNED
+	0x036B: 'm', // , COMBINING LATIN SMALL LETTER
+	0x1D1F: 'm', // , LATIN SMALL LETTER SIDEWAYS TURNED
+	0x026F: 'm', // , LATIN SMALL LETTER TURNED
+	0x2098: 'm', // , LATIN SUBSCRIPT SMALL LETTER
+	0x0144: 'n', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0148: 'n', //  WITH CARON, LATIN SMALL LETTER
+	0x0146: 'n', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E4B: 'n', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x0235: 'n', //  WITH CURL, LATIN SMALL LETTER
+	0x1E45: 'n', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E47: 'n', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x01F9: 'n', //  WITH GRAVE, LATIN SMALL LETTER
+	0x0272: 'n', //  WITH LEFT HOOK, LATIN SMALL LETTER
+	0x1E49: 'n', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x019E: 'n', //  WITH LONG RIGHT LEG, LATIN SMALL LETTER
+	0x0273: 'n', //  WITH RETROFLEX HOOK, LATIN SMALL LETTER
+	0x00F1: 'n', //  WITH TILDE, LATIN SMALL LETTER
+	0x2099: 'n', // , LATIN SUBSCRIPT SMALL LETTER
+	0x00F3: 'o', //  WITH ACUTE, LATIN SMALL LETTER
+	0x014F: 'o', //  WITH BREVE, LATIN SMALL LETTER
+	0x01D2: 'o', //  WITH CARON, LATIN SMALL LETTER
+	0x00F4: 'o', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00F6: 'o', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x022F: 'o', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1ECD: 'o', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0151: 'o', //  WITH DOUBLE ACUTE, LATIN SMALL LETTER
+	0x020D: 'o', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00F2: 'o', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1ECF: 'o', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x01A1: 'o', //  WITH HORN, LATIN SMALL LETTER
+	0x020F: 'o', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x014D: 'o', //  WITH MACRON, LATIN SMALL LETTER
+	0x01EB: 'o', //  WITH OGONEK, LATIN SMALL LETTER
+	0x00F8: 'o', //  WITH STROKE, LATIN SMALL LETTER
+	0x1D13: 'o', //  WITH STROKE, LATIN SMALL LETTER SIDEWAYS
+	0x00F5: 'o', //  WITH TILDE, LATIN SMALL LETTER
+	0x0366: 'o', // , COMBINING LATIN SMALL LETTER
+	0x0275: 'o', // , LATIN SMALL LETTER BARRED
+	0x1D17: 'o', // , LATIN SMALL LETTER BOTTOM HALF
+	0x0254: 'o', // , LATIN SMALL LETTER OPEN
+	0x1D11: 'o', // , LATIN SMALL LETTER SIDEWAYS
+	0x1D12: 'o', // , LATIN SMALL LETTER SIDEWAYS OPEN
+	0x1D16: 'o', // , LATIN SMALL LETTER TOP HALF
+	0x1E55: 'p', //  WITH ACUTE, LATIN SMALL LETTER
+	0x1E57: 'p', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x01A5: 'p', //  WITH HOOK, LATIN SMALL LETTER
+	0x209A: 'p', // , LATIN SUBSCRIPT SMALL LETTER
+	0x024B: 'q', //  WITH HOOK TAIL, LATIN SMALL LETTER
+	0x02A0: 'q', //  WITH HOOK, LATIN SMALL LETTER
+	0x0155: 'r', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0159: 'r', //  WITH CARON, LATIN SMALL LETTER
+	0x0157: 'r', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E59: 'r', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E5B: 'r', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0211: 'r', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x027E: 'r', //  WITH FISHHOOK, LATIN SMALL LETTER
+	0x027F: 'r', //  WITH FISHHOOK, LATIN SMALL LETTER REVERSED
+	0x027B: 'r', //  WITH HOOK, LATIN SMALL LETTER TURNED
+	0x0213: 'r', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x1E5F: 'r', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x027C: 'r', //  WITH LONG LEG, LATIN SMALL LETTER
+	0x027A: 'r', //  WITH LONG LEG, LATIN SMALL LETTER TURNED
+	0x024D: 'r', //  WITH STROKE, LATIN SMALL LETTER
+	0x027D: 'r', //  WITH TAIL, LATIN SMALL LETTER
+	0x036C: 'r', // , COMBINING LATIN SMALL LETTER
+	0x0279: 'r', // , LATIN SMALL LETTER TURNED
+	0x1D63: 'r', // , LATIN SUBSCRIPT SMALL LETTER
+	0x015B: 's', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0161: 's', //  WITH CARON, LATIN SMALL LETTER
+	0x015F: 's', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x015D: 's', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x0219: 's', //  WITH COMMA BELOW, LATIN SMALL LETTER
+	0x1E61: 's', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E9B: 's', //  WITH DOT ABOVE, LATIN SMALL LETTER LONG
+	0x1E63: 's', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0282: 's', //  WITH HOOK, LATIN SMALL LETTER
+	0x023F: 's', //  WITH SWASH TAIL, LATIN SMALL LETTER
+	0x017F: 's', // , LATIN SMALL LETTER LONG
+	0x00DF: 's', // , LATIN SMALL LETTER SHARP
+	0x209B: 's', // , LATIN SUBSCRIPT SMALL LETTER
+	0x0165: 't', //  WITH CARON, LATIN SMALL LETTER
+	0x0163: 't', //  WITH CEDILLA, LATIN SMALL LETTER
+	0x1E71: 't', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x021B: 't', //  WITH COMMA BELOW, LATIN SMALL LETTER
+	0x0236: 't', //  WITH CURL, LATIN SMALL LETTER
+	0x1E97: 't', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E6B: 't', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E6D: 't', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x01AD: 't', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E6F: 't', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x01AB: 't', //  WITH PALATAL HOOK, LATIN SMALL LETTER
+	0x0288: 't', //  WITH RETROFLEX HOOK, LATIN SMALL LETTER
+	0x0167: 't', //  WITH STROKE, LATIN SMALL LETTER
+	0x036D: 't', // , COMBINING LATIN SMALL LETTER
+	0x0287: 't', // , LATIN SMALL LETTER TURNED
+	0x209C: 't', // , LATIN SUBSCRIPT SMALL LETTER
+	0x0289: 'u', //  BAR, LATIN SMALL LETTER
+	0x00FA: 'u', //  WITH ACUTE, LATIN SMALL LETTER
+	0x016D: 'u', //  WITH BREVE, LATIN SMALL LETTER
+	0x01D4: 'u', //  WITH CARON, LATIN SMALL LETTER
+	0x1E77: 'u', //  WITH CIRCUMFLEX BELOW, LATIN SMALL LETTER
+	0x00FB: 'u', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x1E73: 'u', //  WITH DIAERESIS BELOW, LATIN SMALL LETTER
+	0x00FC: 'u', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1EE5: 'u', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0171: 'u', //  WITH DOUBLE ACUTE, LATIN SMALL LETTER
+	0x0215: 'u', //  WITH DOUBLE GRAVE, LATIN SMALL LETTER
+	0x00F9: 'u', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EE7: 'u', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x01B0: 'u', //  WITH HORN, LATIN SMALL LETTER
+	0x0217: 'u', //  WITH INVERTED BREVE, LATIN SMALL LETTER
+	0x016B: 'u', //  WITH MACRON, LATIN SMALL LETTER
+	0x0173: 'u', //  WITH OGONEK, LATIN SMALL LETTER
+	0x016F: 'u', //  WITH RING ABOVE, LATIN SMALL LETTER
+	0x1E75: 'u', //  WITH TILDE BELOW, LATIN SMALL LETTER
+	0x0169: 'u', //  WITH TILDE, LATIN SMALL LETTER
+	0x0367: 'u', // , COMBINING LATIN SMALL LETTER
+	0x1D1D: 'u', // , LATIN SMALL LETTER SIDEWAYS
+	0x1D1E: 'u', // , LATIN SMALL LETTER SIDEWAYS DIAERESIZED
+	0x1D64: 'u', // , LATIN SUBSCRIPT SMALL LETTER
+	0x1E7F: 'v', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x028B: 'v', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E7D: 'v', //  WITH TILDE, LATIN SMALL LETTER
+	0x036E: 'v', // , COMBINING LATIN SMALL LETTER
+	0x028C: 'v', // , LATIN SMALL LETTER TURNED
+	0x1D65: 'v', // , LATIN SUBSCRIPT SMALL LETTER
+	0x1E83: 'w', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0175: 'w', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x1E85: 'w', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E87: 'w', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E89: 'w', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x1E81: 'w', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1E98: 'w', //  WITH RING ABOVE, LATIN SMALL LETTER
+	0x028D: 'w', // , LATIN SMALL LETTER TURNED
+	0x1E8D: 'x', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E8B: 'x', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x036F: 'x', // , COMBINING LATIN SMALL LETTER
+	0x00FD: 'y', //  WITH ACUTE, LATIN SMALL LETTER
+	0x0177: 'y', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x00FF: 'y', //  WITH DIAERESIS, LATIN SMALL LETTER
+	0x1E8F: 'y', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1EF5: 'y', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x1EF3: 'y', //  WITH GRAVE, LATIN SMALL LETTER
+	0x1EF7: 'y', //  WITH HOOK ABOVE, LATIN SMALL LETTER
+	0x01B4: 'y', //  WITH HOOK, LATIN SMALL LETTER
+	0x0233: 'y', //  WITH MACRON, LATIN SMALL LETTER
+	0x1E99: 'y', //  WITH RING ABOVE, LATIN SMALL LETTER
+	0x024F: 'y', //  WITH STROKE, LATIN SMALL LETTER
+	0x1EF9: 'y', //  WITH TILDE, LATIN SMALL LETTER
+	0x028E: 'y', // , LATIN SMALL LETTER TURNED
+	0x017A: 'z', //  WITH ACUTE, LATIN SMALL LETTER
+	0x017E: 'z', //  WITH CARON, LATIN SMALL LETTER
+	0x1E91: 'z', //  WITH CIRCUMFLEX, LATIN SMALL LETTER
+	0x0291: 'z', //  WITH CURL, LATIN SMALL LETTER
+	0x017C: 'z', //  WITH DOT ABOVE, LATIN SMALL LETTER
+	0x1E93: 'z', //  WITH DOT BELOW, LATIN SMALL LETTER
+	0x0225: 'z', //  WITH HOOK, LATIN SMALL LETTER
+	0x1E95: 'z', //  WITH LINE BELOW, LATIN SMALL LETTER
+	0x0290: 'z', //  WITH RETROFLEX HOOK, LATIN SMALL LETTER
+	0x01B6: 'z', //  WITH STROKE, LATIN SMALL LETTER
+	0x0240: 'z', //  WITH SWASH TAIL, LATIN SMALL LETTER
+	0x0251: 'a', // , latin small letter script
+	0x00C1: 'A', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00C2: 'A', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00C4: 'A', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x00C0: 'A', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x00C5: 'A', //  WITH RING ABOVE, LATIN CAPITAL LETTER
+	0x023A: 'A', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x00C3: 'A', //  WITH TILDE, LATIN CAPITAL LETTER
+	0x1D00: 'A', // , LATIN LETTER SMALL CAPITAL
+	0x0181: 'B', //  WITH HOOK, LATIN CAPITAL LETTER
+	0x0243: 'B', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x0299: 'B', // , LATIN LETTER SMALL CAPITAL
+	0x1D03: 'B', // , LATIN LETTER SMALL CAPITAL BARRED
+	0x00C7: 'C', //  WITH CEDILLA, LATIN CAPITAL LETTER
+	0x023B: 'C', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x1D04: 'C', // , LATIN LETTER SMALL CAPITAL
+	0x018A: 'D', //  WITH HOOK, LATIN CAPITAL LETTER
+	0x0189: 'D', // , LATIN CAPITAL LETTER AFRICAN
+	0x1D05: 'D', // , LATIN LETTER SMALL CAPITAL
+	0x00C9: 'E', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00CA: 'E', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00CB: 'E', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x00C8: 'E', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x0246: 'E', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x0190: 'E', // , LATIN CAPITAL LETTER OPEN
+	0x018E: 'E', // , LATIN CAPITAL LETTER REVERSED
+	0x1D07: 'E', // , LATIN LETTER SMALL CAPITAL
+	0x0193: 'G', //  WITH HOOK, LATIN CAPITAL LETTER
+	0x029B: 'G', //  WITH HOOK, LATIN LETTER SMALL CAPITAL
+	0x0262: 'G', // , LATIN LETTER SMALL CAPITAL
+	0x029C: 'H', // , LATIN LETTER SMALL CAPITAL
+	0x00CD: 'I', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00CE: 'I', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00CF: 'I', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x0130: 'I', //  WITH DOT ABOVE, LATIN CAPITAL LETTER
+	0x00CC: 'I', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x0197: 'I', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x026A: 'I', // , LATIN LETTER SMALL CAPITAL
+	0x0248: 'J', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x1D0A: 'J', // , LATIN LETTER SMALL CAPITAL
+	0x1D0B: 'K', // , LATIN LETTER SMALL CAPITAL
+	0x023D: 'L', //  WITH BAR, LATIN CAPITAL LETTER
+	0x1D0C: 'L', //  WITH STROKE, LATIN LETTER SMALL CAPITAL
+	0x029F: 'L', // , LATIN LETTER SMALL CAPITAL
+	0x019C: 'M', // , LATIN CAPITAL LETTER TURNED
+	0x1D0D: 'M', // , LATIN LETTER SMALL CAPITAL
+	0x019D: 'N', //  WITH LEFT HOOK, LATIN CAPITAL LETTER
+	0x0220: 'N', //  WITH LONG RIGHT LEG, LATIN CAPITAL LETTER
+	0x00D1: 'N', //  WITH TILDE, LATIN CAPITAL LETTER
+	0x0274: 'N', // , LATIN LETTER SMALL CAPITAL
+	0x1D0E: 'N', // , LATIN LETTER SMALL CAPITAL REVERSED
+	0x00D3: 'O', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00D4: 'O', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00D6: 'O', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x00D2: 'O', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x019F: 'O', //  WITH MIDDLE TILDE, LATIN CAPITAL LETTER
+	0x00D8: 'O', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x00D5: 'O', //  WITH TILDE, LATIN CAPITAL LETTER
+	0x0186: 'O', // , LATIN CAPITAL LETTER OPEN
+	0x1D0F: 'O', // , LATIN LETTER SMALL CAPITAL
+	0x1D10: 'O', // , LATIN LETTER SMALL CAPITAL OPEN
+	0x1D18: 'P', // , LATIN LETTER SMALL CAPITAL
+	0x024A: 'Q', //  WITH HOOK TAIL, LATIN CAPITAL LETTER SMALL
+	0x024C: 'R', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x0280: 'R', // , LATIN LETTER SMALL CAPITAL
+	0x0281: 'R', // , LATIN LETTER SMALL CAPITAL INVERTED
+	0x1D19: 'R', // , LATIN LETTER SMALL CAPITAL REVERSED
+	0x1D1A: 'R', // , LATIN LETTER SMALL CAPITAL TURNED
+	0x023E: 'T', //  WITH DIAGONAL STROKE, LATIN CAPITAL LETTER
+	0x01AE: 'T', //  WITH RETROFLEX HOOK, LATIN CAPITAL LETTER
+	0x1D1B: 'T', // , LATIN LETTER SMALL CAPITAL
+	0x0244: 'U', //  BAR, LATIN CAPITAL LETTER
+	0x00DA: 'U', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x00DB: 'U', //  WITH CIRCUMFLEX, LATIN CAPITAL LETTER
+	0x00DC: 'U', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x00D9: 'U', //  WITH GRAVE, LATIN CAPITAL LETTER
+	0x1D1C: 'U', // , LATIN LETTER SMALL CAPITAL
+	0x01B2: 'V', //  WITH HOOK, LATIN CAPITAL LETTER
+	0x0245: 'V', // , LATIN CAPITAL LETTER TURNED
+	0x1D20: 'V', // , LATIN LETTER SMALL CAPITAL
+	0x1D21: 'W', // , LATIN LETTER SMALL CAPITAL
+	0x00DD: 'Y', //  WITH ACUTE, LATIN CAPITAL LETTER
+	0x0178: 'Y', //  WITH DIAERESIS, LATIN CAPITAL LETTER
+	0x024E: 'Y', //  WITH STROKE, LATIN CAPITAL LETTER
+	0x028F: 'Y', // , LATIN LETTER SMALL CAPITAL
+	0x1D22: 'Z', // , LATIN LETTER SMALL CAPITAL
+
+	'Ắ': 'A',
+	'Ấ': 'A',
+	'Ằ': 'A',
+	'Ầ': 'A',
+	'Ẳ': 'A',
+	'Ẩ': 'A',
+	'Ẵ': 'A',
+	'Ẫ': 'A',
+	'Ặ': 'A',
+	'Ậ': 'A',
+
+	'ắ': 'a',
+	'ấ': 'a',
+	'ằ': 'a',
+	'ầ': 'a',
+	'ẳ': 'a',
+	'ẩ': 'a',
+	'ẵ': 'a',
+	'ẫ': 'a',
+	'ặ': 'a',
+	'ậ': 'a',
+
+	'Ế': 'E',
+	'Ề': 'E',
+	'Ể': 'E',
+	'Ễ': 'E',
+	'Ệ': 'E',
+
+	'ế': 'e',
+	'ề': 'e',
+	'ể': 'e',
+	'ễ': 'e',
+	'ệ': 'e',
+
+	'Ố': 'O',
+	'Ớ': 'O',
+	'Ồ': 'O',
+	'Ờ': 'O',
+	'Ổ': 'O',
+	'Ở': 'O',
+	'Ỗ': 'O',
+	'Ỡ': 'O',
+	'Ộ': 'O',
+	'Ợ': 'O',
+
+	'ố': 'o',
+	'ớ': 'o',
+	'ồ': 'o',
+	'ờ': 'o',
+	'ổ': 'o',
+	'ở': 'o',
+	'ỗ': 'o',
+	'ỡ': 'o',
+	'ộ': 'o',
+	'ợ': 'o',
+
+	'Ứ': 'U',
+	'Ừ': 'U',
+	'Ử': 'U',
+	'Ữ': 'U',
+	'Ự': 'U',
+
+	'ứ': 'u',
+	'ừ': 'u',
+	'ử': 'u',
+	'ữ': 'u',
+	'ự': 'u',
+}
+
+// NormalizeRunes normalizes latin script letters
+func NormalizeRunes(runes []rune) []rune {
+	ret := make([]rune, len(runes))
+	copy(ret, runes)
+	for idx, r := range runes {
+		if r < 0x00C0 || r > 0x2184 {
+			continue
+		}
+		n := normalized[r]
+		if n > 0 {
+			ret[idx] = normalized[r]
+		}
+	}
+	return ret
+}

src/ansi.go

@@ -0,0 +1,479 @@
+package fzf
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/junegunn/fzf/src/tui"
+)
+
+type ansiOffset struct {
+	offset [2]int32
+	color  ansiState
+}
+
+type url struct {
+	uri    string
+	params string
+}
+
+type ansiState struct {
+	fg   tui.Color
+	bg   tui.Color
+	attr tui.Attr
+	lbg  tui.Color
+	url  *url
+}
+
+func (s *ansiState) colored() bool {
+	return s.fg != -1 || s.bg != -1 || s.attr > 0 || s.lbg >= 0 || s.url != nil
+}
+
+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
+}
+
+func (s *ansiState) ToString() string {
+	if !s.colored() {
+		return ""
+	}
+
+	ret := ""
+	if s.attr&tui.Bold > 0 {
+		ret += "1;"
+	}
+	if s.attr&tui.Dim > 0 {
+		ret += "2;"
+	}
+	if s.attr&tui.Italic > 0 {
+		ret += "3;"
+	}
+	if s.attr&tui.Underline > 0 {
+		ret += "4;"
+	}
+	if s.attr&tui.Blink > 0 {
+		ret += "5;"
+	}
+	if s.attr&tui.Reverse > 0 {
+		ret += "7;"
+	}
+	if s.attr&tui.StrikeThrough > 0 {
+		ret += "9;"
+	}
+	ret += toAnsiString(s.fg, 30) + toAnsiString(s.bg, 40)
+
+	ret = "\x1b[" + strings.TrimSuffix(ret, ";") + "m"
+	if s.url != nil {
+		ret = fmt.Sprintf("\x1b]8;%s;%s\x1b\\%s\x1b]8;;\x1b", s.url.params, s.url.uri, ret)
+	}
+	return ret
+}
+
+func toAnsiString(color tui.Color, offset int) string {
+	col := int(color)
+	ret := ""
+	if col == -1 {
+		ret += strconv.Itoa(offset + 9)
+	} else if col < 8 {
+		ret += strconv.Itoa(offset + col)
+	} else if col < 16 {
+		ret += strconv.Itoa(offset - 30 + 90 + col - 8)
+	} else if col < 256 {
+		ret += strconv.Itoa(offset+8) + ";5;" + strconv.Itoa(col)
+	} else if col >= (1 << 24) {
+		r := strconv.Itoa((col >> 16) & 0xff)
+		g := strconv.Itoa((col >> 8) & 0xff)
+		b := strconv.Itoa(col & 0xff)
+		ret += strconv.Itoa(offset+8) + ";2;" + r + ";" + g + ";" + b
+	}
+	return ret + ";"
+}
+
+func isPrint(c uint8) bool {
+	return '\x20' <= c && c <= '\x7e'
+}
+
+func matchOperatingSystemCommand(s string) int {
+	// `\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)`
+	//                        ^ match starting here
+	//
+	i := 5 // prefix matched in nextAnsiEscapeSequence()
+	for ; i < len(s) && isPrint(s[i]); i++ {
+	}
+	if i < len(s) {
+		if s[i] == '\x07' {
+			return i + 1
+		}
+		// `\x1b]8;PARAMS;URI\x1b\\TITLE\x1b]8;;\x1b`
+		//                   ------
+		if s[i] == '\x1b' && i < len(s)-1 && s[i+1] == '\\' {
+			return i + 2
+		}
+	}
+
+	// `\x1b]8;PARAMS;URI\x1b\\TITLE\x1b]8;;\x1b`
+	//                              ------------
+	if i < len(s) && s[:i+1] == "\x1b]8;;\x1b" {
+		return i + 1
+	}
+
+	return -1
+}
+
+func matchControlSequence(s string) int {
+	// `\x1b[\\[()][0-9;:?]*[a-zA-Z@]`
+	//                     ^ match starting here
+	//
+	i := 2 // prefix matched in nextAnsiEscapeSequence()
+	for ; i < len(s); i++ {
+		c := s[i]
+		switch c {
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ';', ':', '?':
+			// ok
+		default:
+			if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '@' {
+				return i + 1
+			}
+			return -1
+		}
+	}
+	return -1
+}
+
+func isCtrlSeqStart(c uint8) bool {
+	switch c {
+	case '\\', '[', '(', ')':
+		return true
+	}
+	return false
+}
+
+// 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)"
+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':
+			// 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.
+			goto Loop
+		}
+	}
+	return -1, -1
+
+Loop:
+	for ; i < len(s); i++ {
+		switch s[i] {
+		case '\x08':
+			// backtrack to match: `.\x08`
+			if i > 0 && s[i-1] != '\n' {
+				if s[i-1] < utf8.RuneSelf {
+					return i - 1, i + 1
+				}
+				_, n := utf8.DecodeLastRuneInString(s[:i])
+				return i - n, i + 1
+			}
+		case '\x1b':
+			// match: `\x1b[\\[()][0-9;:?]*[a-zA-Z@]`
+			if i+2 < len(s) && isCtrlSeqStart(s[i+1]) {
+				if j := matchControlSequence(s[i:]); j != -1 {
+					return i, i + j
+				}
+			}
+
+			// match: `\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)`
+			if i+5 < len(s) && s[i+1] == ']' && isNumeric(s[i+2]) &&
+				(s[i+3] == ';' || s[i+3] == ':') && isPrint(s[i+4]) {
+
+				if j := matchOperatingSystemCommand(s[i:]); j != -1 {
+					return i, i + j
+				}
+			}
+
+			// match: `\x1b.`
+			if i+1 < len(s) && s[i+1] != '\n' {
+				if s[i+1] < utf8.RuneSelf {
+					return i, i + 2
+				}
+				_, n := utf8.DecodeRuneInString(s[i+1:])
+				return i, i + n + 1
+			}
+		case '\x0e', '\x0f':
+			// match: `[\x0e\x0f]`
+			return i, i + 1
+		}
+	}
+	return -1, -1
+}
+
+func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, *[]ansiOffset, *ansiState) {
+	// We append to a stack allocated variable that we'll
+	// later copy and return, to save on allocations.
+	offsets := make([]ansiOffset, 0, 32)
+
+	if state != nil {
+		offsets = append(offsets, ansiOffset{[2]int32{0, 0}, *state})
+	}
+
+	var (
+		pstate    *ansiState // lazily allocated
+		output    strings.Builder
+		prevIdx   int
+		runeCount int
+	)
+	for idx := 0; idx < len(str); {
+		// Make sure that we found an ANSI code
+		start, end := nextAnsiEscapeSequence(str[idx:])
+		if start == -1 {
+			break
+		}
+		start += idx
+		idx += end
+
+		// Check if we should continue
+		prev := str[prevIdx:start]
+		if proc != nil && !proc(prev, state) {
+			return "", nil, nil
+		}
+		prevIdx = idx
+
+		if len(prev) != 0 {
+			runeCount += utf8.RuneCountInString(prev)
+			// Grow the buffer size to the maximum possible length (string length
+			// containing ansi codes) to avoid repetitive allocation
+			if output.Cap() == 0 {
+				output.Grow(len(str))
+			}
+			output.WriteString(prev)
+		}
+
+		newState := interpretCode(str[start:idx], state)
+		if !newState.equals(state) {
+			if state != nil {
+				// Update last offset
+				(&offsets[len(offsets)-1]).offset[1] = int32(runeCount)
+			}
+
+			if newState.colored() {
+				// Append new offset
+				if pstate == nil {
+					pstate = &ansiState{}
+				}
+				*pstate = newState
+				state = pstate
+				offsets = append(offsets, ansiOffset{
+					[2]int32{int32(runeCount), int32(runeCount)},
+					newState,
+				})
+			} else {
+				// Discard state
+				state = nil
+			}
+		}
+	}
+
+	var rest string
+	var trimmed string
+	if prevIdx == 0 {
+		// No ANSI code found
+		rest = str
+		trimmed = str
+	} else {
+		rest = str[prevIdx:]
+		output.WriteString(rest)
+		trimmed = output.String()
+	}
+	if proc != nil {
+		proc(rest, state)
+	}
+	if len(offsets) > 0 {
+		if len(rest) > 0 && state != nil {
+			// Update last offset
+			runeCount += utf8.RuneCountInString(rest)
+			(&offsets[len(offsets)-1]).offset[1] = int32(runeCount)
+		}
+		// Return a copy of the offsets slice
+		a := make([]ansiOffset, len(offsets))
+		copy(a, offsets)
+		return trimmed, &a, state
+	}
+	return trimmed, nil, state
+}
+
+func parseAnsiCode(s string, delimiter byte) (int, byte, string) {
+	var remaining string
+	var i int
+	if delimiter == 0 {
+		// Faster than strings.IndexAny(";:")
+		i = strings.IndexByte(s, ';')
+		if i < 0 {
+			i = strings.IndexByte(s, ':')
+		}
+	} else {
+		i = strings.IndexByte(s, delimiter)
+	}
+	if i >= 0 {
+		delimiter = s[i]
+		remaining = s[i+1:]
+		s = s[:i]
+	}
+
+	if len(s) > 0 {
+		// Inlined version of strconv.Atoi() that only handles positive
+		// integers and does not allocate on error.
+		code := 0
+		for _, ch := range stringBytes(s) {
+			ch -= '0'
+			if ch > 9 {
+				return -1, delimiter, remaining
+			}
+			code = code*10 + int(ch)
+		}
+		return code, delimiter, remaining
+	}
+
+	return -1, delimiter, remaining
+}
+
+func interpretCode(ansiCode string, prevState *ansiState) ansiState {
+	var state ansiState
+	if prevState == nil {
+		state = ansiState{-1, -1, 0, -1, nil}
+	} else {
+		state = ansiState{prevState.fg, prevState.bg, prevState.attr, prevState.lbg, prevState.url}
+	}
+	if ansiCode[0] != '\x1b' || ansiCode[1] != '[' || ansiCode[len(ansiCode)-1] != 'm' {
+		if prevState != nil && strings.HasSuffix(ansiCode, "0K") {
+			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 {
+				params := ansiCode[4 : 4+paramsEnd]
+				uri := ansiCode[5+paramsEnd : len(ansiCode)-2]
+				state.url = &url{uri: uri, params: params}
+			}
+		}
+		return state
+	}
+
+	if len(ansiCode) <= 3 {
+		state.fg = -1
+		state.bg = -1
+		state.attr = 0
+		return state
+	}
+	ansiCode = ansiCode[2 : len(ansiCode)-1]
+
+	state256 := 0
+	ptr := &state.fg
+
+	var delimiter byte
+	count := 0
+	for len(ansiCode) != 0 {
+		var num int
+		if num, delimiter, ansiCode = parseAnsiCode(ansiCode, delimiter); num != -1 {
+			count++
+			switch state256 {
+			case 0:
+				switch num {
+				case 38:
+					ptr = &state.fg
+					state256++
+				case 48:
+					ptr = &state.bg
+					state256++
+				case 39:
+					state.fg = -1
+				case 49:
+					state.bg = -1
+				case 1:
+					state.attr = state.attr | tui.Bold
+				case 2:
+					state.attr = state.attr | tui.Dim
+				case 3:
+					state.attr = state.attr | tui.Italic
+				case 4:
+					state.attr = state.attr | tui.Underline
+				case 5:
+					state.attr = state.attr | tui.Blink
+				case 7:
+					state.attr = state.attr | tui.Reverse
+				case 9:
+					state.attr = state.attr | tui.StrikeThrough
+				case 22:
+					state.attr = state.attr &^ tui.Bold
+					state.attr = state.attr &^ tui.Dim
+				case 23: // tput rmso
+					state.attr = state.attr &^ tui.Italic
+				case 24: // tput rmul
+					state.attr = state.attr &^ tui.Underline
+				case 25:
+					state.attr = state.attr &^ tui.Blink
+				case 27:
+					state.attr = state.attr &^ tui.Reverse
+				case 29:
+					state.attr = state.attr &^ tui.StrikeThrough
+				case 0:
+					state.fg = -1
+					state.bg = -1
+					state.attr = 0
+					state256 = 0
+				default:
+					if num >= 30 && num <= 37 {
+						state.fg = tui.Color(num - 30)
+					} else if num >= 40 && num <= 47 {
+						state.bg = tui.Color(num - 40)
+					} else if num >= 90 && num <= 97 {
+						state.fg = tui.Color(num - 90 + 8)
+					} else if num >= 100 && num <= 107 {
+						state.bg = tui.Color(num - 100 + 8)
+					}
+				}
+			case 1:
+				switch num {
+				case 2:
+					state256 = 10 // MAGIC
+				case 5:
+					state256++
+				default:
+					state256 = 0
+				}
+			case 2:
+				*ptr = tui.Color(num)
+				state256 = 0
+			case 10:
+				*ptr = tui.Color(1<<24) | tui.Color(num<<16)
+				state256++
+			case 11:
+				*ptr = *ptr | tui.Color(num<<8)
+				state256++
+			case 12:
+				*ptr = *ptr | tui.Color(num)
+				state256 = 0
+			}
+		}
+	}
+
+	// Empty sequence: reset
+	if count == 0 {
+		state.fg = -1
+		state.bg = -1
+		state.attr = 0
+	}
+
+	if state256 > 0 {
+		*ptr = -1
+	}
+	return state
+}

src/ansi_test.go

@@ -0,0 +1,431 @@
+package fzf
+
+import (
+	"math/rand"
+	"regexp"
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	"github.com/junegunn/fzf/src/tui"
+)
+
+// The following regular expression will include not all but most of the
+// frequently used ANSI sequences. This regex is used as a reference for
+// testing nextAnsiEscapeSequence().
+//
+// References:
+//   - https://github.com/gnachman/iTerm2
+//   - https://web.archive.org/web/20090204053813/http://ascii-table.com/ansi-escape-sequences.php
+//     (archived from http://ascii-table.com/ansi-escape-sequences.php)
+//   - https://web.archive.org/web/20090227051140/http://ascii-table.com/ansi-escape-sequences-vt-100.php
+//     (archived from http://ascii-table.com/ansi-escape-sequences-vt-100.php)
+//   - http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
+//   - https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+var ansiRegexReference = regexp.MustCompile("(?:\x1b[\\[()][0-9;:]*[a-zA-Z@]|\x1b][0-9][;:][[:print:]]+(?:\x1b\\\\|\x07)|\x1b.|[\x0e\x0f]|.\x08)")
+
+func testParserReference(t testing.TB, str string) {
+	t.Helper()
+
+	toSlice := func(start, end int) []int {
+		if start == -1 {
+			return nil
+		}
+		return []int{start, end}
+	}
+
+	s := str
+	for i := 0; ; i++ {
+		got := toSlice(nextAnsiEscapeSequence(s))
+		exp := ansiRegexReference.FindStringIndex(s)
+
+		equal := len(got) == len(exp)
+		if equal {
+			for i := 0; i < len(got); i++ {
+				if got[i] != exp[i] {
+					equal = false
+					break
+				}
+			}
+		}
+		if !equal {
+			var exps, gots []rune
+			if len(got) == 2 {
+				gots = []rune(s[got[0]:got[1]])
+			}
+			if len(exp) == 2 {
+				exps = []rune(s[exp[0]:exp[1]])
+			}
+			t.Errorf("%d: %q: got: %v (%q) want: %v (%q)", i, s, got, gots, exp, exps)
+			return
+		}
+		if len(exp) == 0 {
+			return
+		}
+		s = s[exp[1]:]
+	}
+}
+
+func TestNextAnsiEscapeSequence(t *testing.T) {
+	testStrs := []string{
+		"\x1b[0mhello world",
+		"\x1b[1mhello world",
+		"椙\x1b[1m椙",
+		"椙\x1b[1椙m椙",
+		"\x1b[1mhello \x1b[mw\x1b7o\x1b8r\x1b(Bl\x1b[2@d",
+		"\x1b[1mhello \x1b[Kworld",
+		"hello \x1b[34;45;1mworld",
+		"hello \x1b[34;45;1mwor\x1b[34;45;1mld",
+		"hello \x1b[34;45;1mwor\x1b[0mld",
+		"hello \x1b[34;48;5;233;1mwo\x1b[38;5;161mr\x1b[0ml\x1b[38;5;161md",
+		"hello \x1b[38;5;38;48;5;48;1mwor\x1b[38;5;48;48;5;38ml\x1b[0md",
+		"hello \x1b[32;1mworld",
+		"hello world",
+		"hello \x1b[0;38;5;200;48;5;100mworld",
+		"\x1b椙",
+		"椙\x08",
+		"\n\x08",
+		"X\x08",
+		"",
+		"\x1b]4;3;rgb:aa/bb/cc\x07 ",
+		"\x1b]4;3;rgb:aa/bb/cc\x1b\\ ",
+		ansiBenchmarkString,
+	}
+
+	for _, s := range testStrs {
+		testParserReference(t, s)
+	}
+}
+
+func TestNextAnsiEscapeSequence_Fuzz_Modified(t *testing.T) {
+	t.Parallel()
+	if testing.Short() {
+		t.Skip("short test")
+	}
+
+	testStrs := []string{
+		"\x1b[0mhello world",
+		"\x1b[1mhello world",
+		"椙\x1b[1m椙",
+		"椙\x1b[1椙m椙",
+		"\x1b[1mhello \x1b[mw\x1b7o\x1b8r\x1b(Bl\x1b[2@d",
+		"\x1b[1mhello \x1b[Kworld",
+		"hello \x1b[34;45;1mworld",
+		"hello \x1b[34;45;1mwor\x1b[34;45;1mld",
+		"hello \x1b[34;45;1mwor\x1b[0mld",
+		"hello \x1b[34;48;5;233;1mwo\x1b[38;5;161mr\x1b[0ml\x1b[38;5;161md",
+		"hello \x1b[38;5;38;48;5;48;1mwor\x1b[38;5;48;48;5;38ml\x1b[0md",
+		"hello \x1b[32;1mworld",
+		"hello world",
+		"hello \x1b[0;38;5;200;48;5;100mworld",
+		ansiBenchmarkString,
+	}
+
+	replacementBytes := [...]rune{'\x0e', '\x0f', '\x1b', '\x08'}
+
+	modifyString := func(s string, rr *rand.Rand) string {
+		n := rr.Intn(len(s))
+		b := []rune(s)
+		for ; n >= 0 && len(b) != 0; n-- {
+			i := rr.Intn(len(b))
+			switch x := rr.Intn(4); x {
+			case 0:
+				b = append(b[:i], b[i+1:]...)
+			case 1:
+				j := rr.Intn(len(replacementBytes) - 1)
+				b[i] = replacementBytes[j]
+			case 2:
+				x := rune(rr.Intn(utf8.MaxRune))
+				for !utf8.ValidRune(x) {
+					x = rune(rr.Intn(utf8.MaxRune))
+				}
+				b[i] = x
+			case 3:
+				b[i] = rune(rr.Intn(utf8.MaxRune)) // potentially invalid
+			default:
+				t.Fatalf("unsupported value: %d", x)
+			}
+		}
+		return string(b)
+	}
+
+	rr := rand.New(rand.NewSource(1))
+	for _, s := range testStrs {
+		for i := 1_000; i >= 0; i-- {
+			testParserReference(t, modifyString(s, rr))
+		}
+	}
+}
+
+func TestNextAnsiEscapeSequence_Fuzz_Random(t *testing.T) {
+	t.Parallel()
+
+	if testing.Short() {
+		t.Skip("short test")
+	}
+
+	randomString := func(rr *rand.Rand) string {
+		numChars := rand.Intn(50)
+		codePoints := make([]rune, numChars)
+		for i := 0; i < len(codePoints); i++ {
+			var r rune
+			for n := 0; n < 1000; n++ {
+				r = rune(rr.Intn(utf8.MaxRune))
+				// Allow 10% of runes to be invalid
+				if utf8.ValidRune(r) || rr.Float64() < 0.10 {
+					break
+				}
+			}
+			codePoints[i] = r
+		}
+		return string(codePoints)
+	}
+
+	rr := rand.New(rand.NewSource(1))
+	for i := 0; i < 100_000; i++ {
+		testParserReference(t, randomString(rr))
+	}
+}
+
+func TestExtractColor(t *testing.T) {
+	assert := func(offset ansiOffset, b int32, e int32, fg tui.Color, bg tui.Color, bold bool) {
+		var attr tui.Attr
+		if bold {
+			attr = tui.Bold
+		}
+		if offset.offset[0] != b || offset.offset[1] != e ||
+			offset.color.fg != fg || offset.color.bg != bg || offset.color.attr != attr {
+			t.Error(offset, b, e, fg, bg, attr)
+		}
+	}
+
+	src := "hello world"
+	var state *ansiState
+	clean := "\x1b[0m"
+	check := func(assertion func(ansiOffsets *[]ansiOffset, state *ansiState)) {
+		output, ansiOffsets, newState := extractColor(src, state, nil)
+		state = newState
+		if output != "hello world" {
+			t.Errorf("Invalid output: %s %v", output, []rune(output))
+		}
+		t.Log(src, ansiOffsets, clean)
+		assertion(ansiOffsets, state)
+	}
+
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if offsets != nil {
+			t.Fail()
+		}
+	})
+
+	state = nil
+	src = "\x1b[0mhello world"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if offsets != nil {
+			t.Fail()
+		}
+	})
+
+	state = nil
+	src = "\x1b[1mhello world"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 0, 11, -1, -1, true)
+	})
+
+	state = nil
+	src = "\x1b[1mhello \x1b[mw\x1b7o\x1b8r\x1b(Bl\x1b[2@d"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 0, 6, -1, -1, true)
+	})
+
+	state = nil
+	src = "\x1b[1mhello \x1b[Kworld"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 0, 11, -1, -1, true)
+	})
+
+	state = nil
+	src = "hello \x1b[34;45;1mworld"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 6, 11, 4, 5, true)
+	})
+
+	state = nil
+	src = "hello \x1b[34;45;1mwor\x1b[34;45;1mld"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 6, 11, 4, 5, true)
+	})
+
+	state = nil
+	src = "hello \x1b[34;45;1mwor\x1b[0mld"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 6, 9, 4, 5, true)
+	})
+
+	state = nil
+	src = "hello \x1b[34;48;5;233;1mwo\x1b[38;5;161mr\x1b[0ml\x1b[38;5;161md"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 3 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 6, 8, 4, 233, true)
+		assert((*offsets)[1], 8, 9, 161, 233, true)
+		assert((*offsets)[2], 10, 11, 161, -1, false)
+	})
+
+	// {38,48};5;{38,48}
+	state = nil
+	src = "hello \x1b[38;5;38;48;5;48;1mwor\x1b[38;5;48;48;5;38ml\x1b[0md"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 2 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 6, 9, 38, 48, true)
+		assert((*offsets)[1], 9, 10, 48, 38, true)
+	})
+
+	src = "hello \x1b[32;1mworld"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
+			t.Fail()
+		}
+		if state.fg != 2 || state.bg != -1 || state.attr == 0 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 6, 11, 2, -1, true)
+	})
+
+	src = "hello world"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 1 {
+			t.Fail()
+		}
+		if state.fg != 2 || state.bg != -1 || state.attr == 0 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 0, 11, 2, -1, true)
+	})
+
+	src = "hello \x1b[0;38;5;200;48;5;100mworld"
+	check(func(offsets *[]ansiOffset, state *ansiState) {
+		if len(*offsets) != 2 {
+			t.Fail()
+		}
+		if state.fg != 200 || state.bg != 100 || state.attr > 0 {
+			t.Fail()
+		}
+		assert((*offsets)[0], 0, 6, 2, -1, true)
+		assert((*offsets)[1], 6, 11, 200, 100, false)
+	})
+}
+
+func TestAnsiCodeStringConversion(t *testing.T) {
+	assert := func(code string, prevState *ansiState, expected string) {
+		state := interpretCode(code, prevState)
+		if expected != state.ToString() {
+			t.Errorf("expected: %s, actual: %s",
+				strings.ReplaceAll(expected, "\x1b[", "\\x1b["),
+				strings.ReplaceAll(state.ToString(), "\x1b[", "\\x1b["))
+		}
+	}
+	assert("\x1b[m", nil, "")
+	assert("\x1b[m", &ansiState{attr: tui.Blink, lbg: -1}, "")
+	assert("\x1b[0m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
+	assert("\x1b[;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
+	assert("\x1b[;;m", &ansiState{fg: 4, bg: 4, lbg: -1}, "")
+
+	assert("\x1b[31m", nil, "\x1b[31;49m")
+	assert("\x1b[41m", nil, "\x1b[39;41m")
+
+	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[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},
+		"\x1b[2;3;7;38;2;10;20;30;48;5;100m")
+}
+
+func TestParseAnsiCode(t *testing.T) {
+	tests := []struct {
+		In, Exp string
+		N       int
+	}{
+		{"123", "", 123},
+		{"1a", "", -1},
+		{"1a;12", "12", -1},
+		{"12;a", "a", 12},
+		{"-2", "", -1},
+	}
+	for _, x := range tests {
+		n, _, s := parseAnsiCode(x.In, 0)
+		if n != x.N || s != x.Exp {
+			t.Fatalf("%q: got: (%d %q) want: (%d %q)", x.In, n, s, x.N, x.Exp)
+		}
+	}
+}
+
+// kernel/bpf/preload/iterators/README
+const ansiBenchmarkString = "\x1b[38;5;81m\x1b[01;31m\x1b[Kkernel/\x1b[0m\x1b[38:5:81mbpf/" +
+	"\x1b[0m\x1b[38:5:81mpreload/\x1b[0m\x1b[38;5;81miterators/" +
+	"\x1b[0m\x1b[38:5:149mMakefile\x1b[m\x1b[K\x1b[0m"
+
+func BenchmarkNextAnsiEscapeSequence(b *testing.B) {
+	b.SetBytes(int64(len(ansiBenchmarkString)))
+	for i := 0; i < b.N; i++ {
+		s := ansiBenchmarkString
+		for {
+			_, o := nextAnsiEscapeSequence(s)
+			if o == -1 {
+				break
+			}
+			s = s[o:]
+		}
+	}
+}
+
+// Baseline test to compare the speed of nextAnsiEscapeSequence() to the
+// previously used regex based implementation.
+func BenchmarkNextAnsiEscapeSequence_Regex(b *testing.B) {
+	b.SetBytes(int64(len(ansiBenchmarkString)))
+	for i := 0; i < b.N; i++ {
+		s := ansiBenchmarkString
+		for {
+			a := ansiRegexReference.FindStringIndex(s)
+			if len(a) == 0 {
+				break
+			}
+			s = s[a[1]:]
+		}
+	}
+}
+
+func BenchmarkExtractColor(b *testing.B) {
+	b.SetBytes(int64(len(ansiBenchmarkString)))
+	for i := 0; i < b.N; i++ {
+		extractColor(ansiBenchmarkString, nil, nil)
+	}
+}

src/cache.go

@@ -0,0 +1,95 @@
+package fzf
+
+import "sync"
+
+// queryCache associates strings to lists of items
+type queryCache map[string][]Result
+
+// ChunkCache associates Chunk and query string to lists of items
+type ChunkCache struct {
+	mutex sync.Mutex
+	cache map[*Chunk]*queryCache
+}
+
+// NewChunkCache returns a new ChunkCache
+func NewChunkCache() *ChunkCache {
+	return &ChunkCache{sync.Mutex{}, make(map[*Chunk]*queryCache)}
+}
+
+func (cc *ChunkCache) Clear() {
+	cc.mutex.Lock()
+	cc.cache = make(map[*Chunk]*queryCache)
+	cc.mutex.Unlock()
+}
+
+func (cc *ChunkCache) retire(chunk ...*Chunk) {
+	cc.mutex.Lock()
+	for _, c := range chunk {
+		delete(cc.cache, c)
+	}
+	cc.mutex.Unlock()
+}
+
+// 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 {
+		return
+	}
+
+	cc.mutex.Lock()
+	defer cc.mutex.Unlock()
+
+	qc, ok := cc.cache[chunk]
+	if !ok {
+		cc.cache[chunk] = &queryCache{}
+		qc = cc.cache[chunk]
+	}
+	(*qc)[key] = list
+}
+
+// Lookup is called to lookup ChunkCache
+func (cc *ChunkCache) Lookup(chunk *Chunk, key string) []Result {
+	if len(key) == 0 || !chunk.IsFull() {
+		return nil
+	}
+
+	cc.mutex.Lock()
+	defer cc.mutex.Unlock()
+
+	qc, ok := cc.cache[chunk]
+	if ok {
+		list, ok := (*qc)[key]
+		if ok {
+			return list
+		}
+	}
+	return nil
+}
+
+func (cc *ChunkCache) Search(chunk *Chunk, key string) []Result {
+	if len(key) == 0 || !chunk.IsFull() {
+		return nil
+	}
+
+	cc.mutex.Lock()
+	defer cc.mutex.Unlock()
+
+	qc, ok := cc.cache[chunk]
+	if !ok {
+		return nil
+	}
+
+	for idx := 1; idx < len(key); idx++ {
+		// [---------| ] | [ |---------]
+		// [--------|  ] | [  |--------]
+		// [-------|   ] | [   |-------]
+		prefix := key[:len(key)-idx]
+		suffix := key[idx:]
+		for _, substr := range [2]string{prefix, suffix} {
+			if cached, found := (*qc)[substr]; found {
+				return cached
+			}
+		}
+	}
+	return nil
+}

src/cache_test.go

@@ -0,0 +1,39 @@
+package fzf
+
+import "testing"
+
+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)
+
+	{ // chunk1 is not full
+		cached := cache.Lookup(chunk1p, "foo")
+		if cached != nil {
+			t.Error("Cached disabled for non-empty chunks", cached)
+		}
+	}
+	{
+		cached := cache.Lookup(chunk2p, "foo")
+		if cached == nil || len(cached) != 1 {
+			t.Error("Expected 1 item cached", cached)
+		}
+	}
+	{
+		cached := cache.Lookup(chunk2p, "bar")
+		if cached == nil || len(cached) != 2 {
+			t.Error("Expected 2 items cached", cached)
+		}
+	}
+	{
+		cached := cache.Lookup(chunk1p, "foobar")
+		if cached != nil {
+			t.Error("Expected 0 item cached", cached)
+		}
+	}
+}

src/chunklist.go

@@ -0,0 +1,134 @@
+package fzf
+
+import "sync"
+
+// Chunk is a list of Items whose size has the upper limit of chunkSize
+type Chunk struct {
+	items [chunkSize]Item
+	count int
+}
+
+// ItemBuilder is a closure type that builds Item object from byte array
+type ItemBuilder func(*Item, []byte) bool
+
+// ChunkList is a list of Chunks
+type ChunkList struct {
+	chunks []*Chunk
+	mutex  sync.Mutex
+	trans  ItemBuilder
+	cache  *ChunkCache
+}
+
+// NewChunkList returns a new ChunkList
+func NewChunkList(cache *ChunkCache, trans ItemBuilder) *ChunkList {
+	return &ChunkList{
+		chunks: []*Chunk{},
+		mutex:  sync.Mutex{},
+		trans:  trans,
+		cache:  cache}
+}
+
+func (c *Chunk) push(trans ItemBuilder, data []byte) bool {
+	if trans(&c.items[c.count], data) {
+		c.count++
+		return true
+	}
+	return false
+}
+
+// IsFull returns true if the Chunk is full
+func (c *Chunk) IsFull() bool {
+	return c.count == chunkSize
+}
+
+func (cl *ChunkList) lastChunk() *Chunk {
+	return cl.chunks[len(cl.chunks)-1]
+}
+
+// CountItems returns the total number of Items
+func CountItems(cs []*Chunk) int {
+	if len(cs) == 0 {
+		return 0
+	}
+	if len(cs) == 1 {
+		return cs[0].count
+	}
+
+	// First chunk might not be full due to --tail=N
+	return cs[0].count + chunkSize*(len(cs)-2) + cs[len(cs)-1].count
+}
+
+// Push adds the item to the list
+func (cl *ChunkList) Push(data []byte) bool {
+	cl.mutex.Lock()
+
+	if len(cl.chunks) == 0 || cl.lastChunk().IsFull() {
+		cl.chunks = append(cl.chunks, &Chunk{})
+	}
+
+	ret := cl.lastChunk().push(cl.trans, data)
+	cl.mutex.Unlock()
+	return ret
+}
+
+// Clear clears the data
+func (cl *ChunkList) Clear() {
+	cl.mutex.Lock()
+	cl.chunks = nil
+	cl.mutex.Unlock()
+}
+
+// Snapshot returns immutable snapshot of the ChunkList
+func (cl *ChunkList) Snapshot(tail int) ([]*Chunk, int, bool) {
+	cl.mutex.Lock()
+
+	changed := false
+	if tail > 0 && CountItems(cl.chunks) > tail {
+		changed = true
+		// Find the number of chunks to keep
+		numChunks := 0
+		for left, i := tail, len(cl.chunks)-1; left > 0 && i >= 0; i-- {
+			numChunks++
+			left -= cl.chunks[i].count
+		}
+
+		// Copy the chunks to keep
+		ret := make([]*Chunk, numChunks)
+		minIndex := len(cl.chunks) - numChunks
+		cl.cache.retire(cl.chunks[:minIndex]...)
+		copy(ret, cl.chunks[minIndex:])
+
+		for left, i := tail, len(ret)-1; i >= 0; i-- {
+			chunk := ret[i]
+			if chunk.count > left {
+				newChunk := *chunk
+				newChunk.count = left
+				oldCount := chunk.count
+				for i := 0; i < left; i++ {
+					newChunk.items[i] = chunk.items[oldCount-left+i]
+				}
+				ret[i] = &newChunk
+				cl.cache.retire(chunk)
+				break
+			}
+			left -= chunk.count
+		}
+		cl.chunks = ret
+	}
+
+	ret := make([]*Chunk, len(cl.chunks))
+	copy(ret, cl.chunks)
+
+	// Duplicate the first and the last chunk
+	if cnt := len(ret); cnt > 0 {
+		if tail > 0 && cnt > 1 {
+			newChunk := *ret[0]
+			ret[0] = &newChunk
+		}
+		newChunk := *ret[cnt-1]
+		ret[cnt-1] = &newChunk
+	}
+
+	cl.mutex.Unlock()
+	return ret, CountItems(ret), changed
+}

src/chunklist_test.go

@@ -0,0 +1,116 @@
+package fzf
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func TestChunkList(t *testing.T) {
+	// FIXME global
+	sortCriteria = []criterion{byScore, byLength}
+
+	cl := NewChunkList(NewChunkCache(), func(item *Item, s []byte) bool {
+		item.text = util.ToChars(s)
+		return true
+	})
+
+	// Snapshot
+	snapshot, count, _ := cl.Snapshot(0)
+	if len(snapshot) > 0 || count > 0 {
+		t.Error("Snapshot should be empty now")
+	}
+
+	// Add some data
+	cl.Push([]byte("hello"))
+	cl.Push([]byte("world"))
+
+	// Previously created snapshot should remain the same
+	if len(snapshot) > 0 {
+		t.Error("Snapshot should not have changed")
+	}
+
+	// But the new snapshot should contain the added items
+	snapshot, count, _ = cl.Snapshot(0)
+	if len(snapshot) != 1 && count != 2 {
+		t.Error("Snapshot should not be empty now")
+	}
+
+	// Check the content of the ChunkList
+	chunk1 := snapshot[0]
+	if chunk1.count != 2 {
+		t.Error("Snapshot should contain only two items")
+	}
+	if chunk1.items[0].text.ToString() != "hello" ||
+		chunk1.items[1].text.ToString() != "world" {
+		t.Error("Invalid data")
+	}
+	if chunk1.IsFull() {
+		t.Error("Chunk should not have been marked full yet")
+	}
+
+	// Add more data
+	for i := 0; i < chunkSize*2; i++ {
+		cl.Push([]byte(fmt.Sprintf("item %d", i)))
+	}
+
+	// Previous snapshot should remain the same
+	if len(snapshot) != 1 {
+		t.Error("Snapshot should stay the same")
+	}
+
+	// New snapshot
+	snapshot, count, _ = cl.Snapshot(0)
+	if len(snapshot) != 3 || !snapshot[0].IsFull() ||
+		!snapshot[1].IsFull() || snapshot[2].IsFull() || count != chunkSize*2+2 {
+		t.Error("Expected two full chunks and one more chunk")
+	}
+	if snapshot[2].count != 2 {
+		t.Error("Unexpected number of items")
+	}
+
+	cl.Push([]byte("hello"))
+	cl.Push([]byte("world"))
+
+	lastChunkCount := snapshot[len(snapshot)-1].count
+	if lastChunkCount != 2 {
+		t.Error("Unexpected number of items:", lastChunkCount)
+	}
+}
+
+func TestChunkListTail(t *testing.T) {
+	cl := NewChunkList(NewChunkCache(), func(item *Item, s []byte) bool {
+		item.text = util.ToChars(s)
+		return true
+	})
+	total := chunkSize*2 + chunkSize/2
+	for i := 0; i < total; i++ {
+		cl.Push([]byte(fmt.Sprintf("item %d", i)))
+	}
+
+	snapshot, count, changed := cl.Snapshot(0)
+	assertCount := func(expected int, shouldChange bool) {
+		if count != expected || CountItems(snapshot) != expected {
+			t.Errorf("Unexpected count: %d (expected: %d)", count, expected)
+		}
+		if changed != shouldChange {
+			t.Error("Unexpected change status")
+		}
+	}
+	assertCount(total, false)
+
+	tail := chunkSize + chunkSize/2
+	snapshot, count, changed = cl.Snapshot(tail)
+	assertCount(tail, true)
+
+	snapshot, count, changed = cl.Snapshot(tail)
+	assertCount(tail, false)
+
+	snapshot, count, changed = cl.Snapshot(0)
+	assertCount(tail, false)
+
+	tail = chunkSize / 2
+	snapshot, count, changed = cl.Snapshot(tail)
+	assertCount(tail, true)
+}

src/constants.go

@@ -0,0 +1,75 @@
+package fzf
+
+import (
+	"math"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+const (
+	// Core
+	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
+	coordinatorDelayStep time.Duration = 10 * time.Millisecond
+
+	// Reader
+	readerBufferSize       = 64 * 1024
+	readerSlabSize         = 128 * 1024
+	readerPollIntervalMin  = 10 * time.Millisecond
+	readerPollIntervalStep = 5 * time.Millisecond
+	readerPollIntervalMax  = 50 * time.Millisecond
+
+	// Terminal
+	initialDelay      = 20 * time.Millisecond
+	initialDelayTac   = 100 * time.Millisecond
+	spinnerDuration   = 100 * time.Millisecond
+	previewCancelWait = 500 * time.Millisecond
+	previewChunkDelay = 100 * time.Millisecond
+	previewDelayed    = 500 * time.Millisecond
+	maxPatternLength  = 300
+	maxMulti          = math.MaxInt32
+
+	// Matcher
+	numPartitionsMultiplier = 8
+	maxPartitions           = 32
+	progressMinDuration     = 200 * time.Millisecond
+
+	// Capacity of each chunk
+	chunkSize int = 100
+
+	// 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
+
+	// Not to cache mergers with large lists
+	mergerCacheMax int = 100000
+
+	// History
+	defaultHistoryMax int = 1000
+
+	// Jump labels
+	defaultJumpLabels string = "asdfghjklqwertyuiopzxcvbnm1234567890ASDFGHJKLQWERTYUIOPZXCVBNM`~;:,<.>/?'\"!@#$%^&*()[{]}-_=+"
+)
+
+// fzf events
+const (
+	EvtReadNew util.EventType = iota
+	EvtReadFin
+	EvtSearchNew
+	EvtSearchProgress
+	EvtSearchFin
+	EvtHeader
+	EvtReady
+	EvtQuit
+)
+
+const (
+	ExitOk        = 0
+	ExitNoMatch   = 1
+	ExitError     = 2
+	ExitBecome    = 126
+	ExitInterrupt = 130
+)

src/core.go

@@ -0,0 +1,461 @@
+// Package fzf implements fzf, a command-line fuzzy finder.
+package fzf
+
+import (
+	"os"
+	"sync"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+/*
+Reader   -> EvtReadFin
+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 {
+	major int
+	minor int
+}
+
+func (r *revision) bumpMajor() {
+	r.major++
+	r.minor = 0
+}
+
+func (r *revision) bumpMinor() {
+	r.minor++
+}
+
+func (r revision) compatible(other revision) bool {
+	return r.major == other.major
+}
+
+// Run starts fzf
+func Run(opts *Options) (int, error) {
+	if opts.Filter == nil {
+		if opts.Tmux != nil && len(os.Getenv("TMUX")) > 0 && opts.Tmux.index >= opts.Height.index {
+			return runTmux(os.Args, opts)
+		}
+
+		if needWinpty(opts) {
+			return runWinpty(os.Args, opts)
+		}
+	}
+
+	if err := postProcessOptions(opts); err != nil {
+		return ExitError, err
+	}
+
+	defer util.RunAtExitFuncs()
+
+	// Output channel given
+	if opts.Output != nil {
+		opts.Printer = func(str string) {
+			opts.Output <- str
+		}
+	}
+
+	sort := opts.Sort > 0
+	sortCriteria = opts.Criteria
+
+	// Event channel
+	eventBox := util.NewEventBox()
+
+	// ANSI code processor
+	ansiProcessor := func(data []byte) (util.Chars, *[]ansiOffset) {
+		return util.ToChars(data), nil
+	}
+
+	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
+			}
+		}
+	}
+
+	// Chunk list
+	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
+			}
+			item.text, item.colors = ansiProcessor(data)
+			item.text.Index = itemIndex
+			itemIndex++
+			return true
+		})
+	} else {
+		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")
+					}
+				}
+			}
+			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++
+			return true
+		})
+	}
+
+	// Process executor
+	executor := util.NewExecutor(opts.WithShell)
+
+	// Terminal I/O
+	var terminal *Terminal
+	var err error
+	var initialEnv []string
+	initialReload := opts.extractReloadOnStart()
+	if opts.Filter == nil {
+		terminal, err = NewTerminal(opts, eventBox, executor)
+		if err != nil {
+			return ExitError, err
+		}
+		if len(initialReload) > 0 {
+			var temps []string
+			initialReload, temps = terminal.replacePlaceholderInInitialCommand(initialReload)
+			initialEnv = terminal.environ()
+			defer removeFiles(temps)
+		}
+	}
+
+	// Reader
+	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
+	var reader *Reader
+	if !streamingFilter {
+		reader = NewReader(func(data []byte) bool {
+			return chunkList.Push(data)
+		}, eventBox, executor, opts.ReadZero, opts.Filter == nil)
+
+		go reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip, initialReload, initialEnv)
+	}
+
+	// Matcher
+	forward := true
+	withPos := false
+	for idx := len(opts.Criteria) - 1; idx > 0; idx-- {
+		switch opts.Criteria[idx] {
+		case byChunk:
+			withPos = true
+		case byEnd:
+			forward = false
+		case byBegin:
+			forward = true
+		}
+	}
+	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, opts.Nth, opts.Delimiter, runes)
+	}
+	inputRevision := revision{}
+	snapshotRevision := revision{}
+	matcher := NewMatcher(cache, patternBuilder, sort, opts.Tac, eventBox, inputRevision)
+
+	// Filtering mode
+	if opts.Filter != nil {
+		if opts.PrintQuery {
+			opts.Printer(*opts.Filter)
+		}
+
+		pattern := patternBuilder([]rune(*opts.Filter))
+		matcher.sort = pattern.sortable
+
+		found := false
+		if streamingFilter {
+			slab := util.MakeSlab(slab16Size, slab32Size)
+			mutex := sync.Mutex{}
+			reader := NewReader(
+				func(runes []byte) bool {
+					item := Item{}
+					if chunkList.trans(&item, runes) {
+						mutex.Lock()
+						if result, _, _ := pattern.MatchItem(&item, false, slab); result != nil {
+							opts.Printer(item.text.ToString())
+							found = true
+						}
+						mutex.Unlock()
+					}
+					return false
+				}, eventBox, executor, opts.ReadZero, false)
+			reader.ReadSource(opts.Input, opts.WalkerRoot, opts.WalkerOpts, opts.WalkerSkip, initialReload, initialEnv)
+		} else {
+			eventBox.Unwatch(EvtReadNew)
+			eventBox.WaitFor(EvtReadFin)
+
+			// NOTE: Streaming filter is inherently not compatible with --tail
+			snapshot, _, _ := chunkList.Snapshot(opts.Tail)
+			merger, _ := matcher.scan(MatchRequest{
+				chunks:  snapshot,
+				pattern: pattern})
+			for i := 0; i < merger.Length(); i++ {
+				opts.Printer(merger.Get(i).item.AsString(opts.Ansi))
+				found = true
+			}
+		}
+		if found {
+			return ExitOk, nil
+		}
+		return ExitNoMatch, nil
+	}
+
+	// Synchronous search
+	if opts.Sync {
+		eventBox.Unwatch(EvtReadNew)
+		eventBox.WaitFor(EvtReadFin)
+	}
+
+	// Go interactive
+	go matcher.Loop()
+	defer matcher.Stop()
+
+	// Handling adaptive height
+	maxFit := 0 // Maximum number of items that can fit on screen
+	padHeight := 0
+	heightUnknown := opts.Height.auto
+	if heightUnknown {
+		maxFit, padHeight = terminal.MaxFitAndPad()
+	}
+	deferred := opts.Select1 || opts.Exit0 || opts.Sync
+	go terminal.Loop()
+	if !deferred && !heightUnknown {
+		// Start right away
+		terminal.startChan <- fitpad{-1, -1}
+	}
+
+	// Event coordination
+	reading := true
+	ticks := 0
+	var nextCommand *commandSpec
+	var nextEnviron []string
+	eventBox.Watch(EvtReadNew)
+	total := 0
+	query := []rune{}
+	determine := func(final bool) {
+		if heightUnknown {
+			if total >= maxFit || final {
+				deferred = false
+				heightUnknown = false
+				terminal.startChan <- fitpad{util.Min(total, maxFit), padHeight}
+			}
+		} else if deferred {
+			deferred = false
+			terminal.startChan <- fitpad{-1, -1}
+		}
+	}
+
+	useSnapshot := false
+	var snapshot []*Chunk
+	var count int
+	restart := func(command commandSpec, environ []string) {
+		reading = true
+		chunkList.Clear()
+		itemIndex = 0
+		inputRevision.bumpMajor()
+		header = make([]string, 0, opts.HeaderLines)
+		go reader.restart(command, environ)
+	}
+
+	exitCode := ExitOk
+	stop := false
+	for {
+		delay := true
+		ticks++
+		input := func() []rune {
+			paused, input := terminal.Input()
+			if !paused {
+				query = input
+			}
+			return query
+		}
+		eventBox.Wait(func(events *util.Events) {
+			if _, fin := (*events)[EvtReadFin]; fin {
+				delete(*events, EvtReadNew)
+			}
+			for evt, value := range *events {
+				switch evt {
+				case EvtQuit:
+					if reading {
+						reader.terminate()
+					}
+					quitSignal := value.(quitSignal)
+					exitCode = quitSignal.code
+					err = quitSignal.err
+					stop = true
+					return
+				case EvtReadNew, EvtReadFin:
+					if evt == EvtReadFin && nextCommand != nil {
+						restart(*nextCommand, nextEnviron)
+						nextCommand = nil
+						nextEnviron = nil
+						break
+					} else {
+						reading = reading && evt == EvtReadNew
+					}
+					if useSnapshot && evt == EvtReadFin {
+						useSnapshot = false
+					}
+					if !useSnapshot {
+						if !snapshotRevision.compatible(inputRevision) {
+							query = []rune{}
+						}
+						var changed bool
+						snapshot, count, changed = chunkList.Snapshot(opts.Tail)
+						if changed {
+							inputRevision.bumpMinor()
+						}
+						snapshotRevision = inputRevision
+					}
+					total = count
+					terminal.UpdateCount(total, !reading, value.(*string))
+					if heightUnknown && !deferred {
+						determine(!reading)
+					}
+					matcher.Reset(snapshot, input(), false, !reading, sort, snapshotRevision)
+
+				case EvtSearchNew:
+					var command *commandSpec
+					var environ []string
+					var changed bool
+					switch val := value.(type) {
+					case searchRequest:
+						sort = val.sort
+						command = val.command
+						environ = val.environ
+						changed = val.changed
+						if command != nil {
+							useSnapshot = val.sync
+						}
+					}
+					if command != nil {
+						if reading {
+							reader.terminate()
+							nextCommand = command
+							nextEnviron = environ
+						} else {
+							restart(*command, environ)
+						}
+					}
+					if !changed {
+						break
+					}
+					if !useSnapshot {
+						newSnapshot, newCount, changed := chunkList.Snapshot(opts.Tail)
+						if changed {
+							inputRevision.bumpMinor()
+						}
+						// We want to avoid showing empty list when reload is triggered
+						// and the query string is changed at the same time i.e. command != nil && changed
+						if command == nil || newCount > 0 {
+							if snapshotRevision != inputRevision {
+								query = []rune{}
+							}
+							snapshot = newSnapshot
+							snapshotRevision = inputRevision
+						}
+					}
+					matcher.Reset(snapshot, input(), true, !reading, sort, snapshotRevision)
+					delay = false
+
+				case EvtSearchProgress:
+					switch val := value.(type) {
+					case float32:
+						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:
+						if deferred {
+							count := val.Length()
+							if opts.Select1 && count > 1 || opts.Exit0 && !opts.Select1 && count > 0 {
+								determine(val.final)
+							} else if val.final {
+								if opts.Exit0 && count == 0 || opts.Select1 && count == 1 {
+									if opts.PrintQuery {
+										opts.Printer(opts.Query)
+									}
+									if len(opts.Expect) > 0 {
+										opts.Printer("")
+									}
+									for i := 0; i < count; i++ {
+										opts.Printer(val.Get(i).item.AsString(opts.Ansi))
+									}
+									if count == 0 {
+										exitCode = ExitNoMatch
+									}
+									stop = true
+									return
+								}
+								determine(val.final)
+							}
+						}
+						terminal.UpdateList(val)
+					}
+				}
+			}
+			events.Clear()
+		})
+		if stop {
+			break
+		}
+		if delay && reading {
+			dur := util.DurWithin(
+				time.Duration(ticks)*coordinatorDelayStep,
+				0, coordinatorDelayMax)
+			time.Sleep(dur)
+		}
+	}
+	return exitCode, err
+}

src/functions.go

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

src/history.go

@@ -0,0 +1,95 @@
+package fzf
+
+import (
+	"errors"
+	"os"
+	"strings"
+)
+
+// History struct represents input history
+type History struct {
+	path     string
+	lines    []string
+	modified map[int]string
+	maxSize  int
+	cursor   int
+}
+
+// NewHistory returns the pointer to a new History struct
+func NewHistory(path string, maxSize int) (*History, error) {
+	fmtError := func(e error) error {
+		if os.IsPermission(e) {
+			return errors.New("permission denied: " + path)
+		}
+		return errors.New("invalid history file: " + e.Error())
+	}
+
+	// Read history file
+	data, err := os.ReadFile(path)
+	if err != nil {
+		// If it doesn't exist, check if we can create a file with the name
+		if os.IsNotExist(err) {
+			data = []byte{}
+			if err := os.WriteFile(path, data, 0600); err != nil {
+				return nil, fmtError(err)
+			}
+		} else {
+			return nil, fmtError(err)
+		}
+	}
+	// Split lines and limit the maximum number of lines
+	lines := strings.Split(strings.Trim(string(data), "\n"), "\n")
+	if len(lines[len(lines)-1]) > 0 {
+		lines = append(lines, "")
+	}
+	return &History{
+		path:     path,
+		maxSize:  maxSize,
+		lines:    lines,
+		modified: make(map[int]string),
+		cursor:   len(lines) - 1}, nil
+}
+
+func (h *History) append(line string) error {
+	// We don't append empty lines
+	if len(line) == 0 {
+		return nil
+	}
+
+	lines := append(h.lines[:len(h.lines)-1], line)
+	if len(lines) > h.maxSize {
+		lines = lines[len(lines)-h.maxSize:]
+	}
+	h.lines = append(lines, "")
+	return os.WriteFile(h.path, []byte(strings.Join(h.lines, "\n")), 0600)
+}
+
+func (h *History) override(str string) {
+	// You can update the history, but they're not written to the file
+	if h.cursor == len(h.lines)-1 {
+		h.lines[h.cursor] = str
+	} else if h.cursor < len(h.lines)-1 {
+		h.modified[h.cursor] = str
+	}
+}
+
+func (h *History) current() string {
+	if str, prs := h.modified[h.cursor]; prs {
+		return str
+	}
+	return h.lines[h.cursor]
+}
+
+func (h *History) previous() string {
+	if h.cursor > 0 {
+		h.cursor--
+	}
+	return h.current()
+}
+
+func (h *History) next() string {
+	if h.cursor < len(h.lines)-1 {
+		h.cursor++
+	}
+	return h.current()
+}

src/history_test.go

@@ -0,0 +1,67 @@
+package fzf
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestHistory(t *testing.T) {
+	maxHistory := 50
+
+	// Invalid arguments
+	var paths []string
+	if runtime.GOOS == "windows" {
+		// GOPATH should exist, so we shouldn't be able to override it
+		paths = []string{os.Getenv("GOPATH")}
+	} else {
+		paths = []string{"/etc", "/proc"}
+	}
+
+	for _, path := range paths {
+		if _, e := NewHistory(path, maxHistory); e == nil {
+			t.Error("Error expected for: " + path)
+		}
+	}
+
+	f, _ := os.CreateTemp("", "fzf-history")
+	f.Close()
+
+	{ // Append lines
+		h, _ := NewHistory(f.Name(), maxHistory)
+		for i := 0; i < maxHistory+10; i++ {
+			h.append("foobar")
+		}
+	}
+	{ // Read lines
+		h, _ := NewHistory(f.Name(), maxHistory)
+		if len(h.lines) != maxHistory+1 {
+			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
+		}
+		for i := 0; i < maxHistory; i++ {
+			if h.lines[i] != "foobar" {
+				t.Error("Expected: foobar, actual: " + h.lines[i])
+			}
+		}
+	}
+	{ // Append lines
+		h, _ := NewHistory(f.Name(), maxHistory)
+		h.append("barfoo")
+		h.append("")
+		h.append("foobarbaz")
+	}
+	{ // Read lines again
+		h, _ := NewHistory(f.Name(), maxHistory)
+		if len(h.lines) != maxHistory+1 {
+			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
+		}
+		compare := func(idx int, exp string) {
+			if h.lines[idx] != exp {
+				t.Errorf("Expected: %s, actual: %s\n", exp, h.lines[idx])
+			}
+		}
+		compare(maxHistory-3, "foobar")
+		compare(maxHistory-2, "barfoo")
+		compare(maxHistory-1, "foobarbaz")
+	}
+}

src/item.go

@@ -0,0 +1,46 @@
+package fzf
+
+import (
+	"math"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+// Item represents each input line. 56 bytes.
+type Item struct {
+	text        util.Chars    // 32 = 24 + 1 + 1 + 2 + 4
+	transformed *[]Token      // 8
+	origText    *[]byte       // 8
+	colors      *[]ansiOffset // 8
+}
+
+// Index returns ordinal index of the Item
+func (item *Item) Index() int32 {
+	return item.text.Index
+}
+
+var minItem = Item{text: util.Chars{Index: math.MinInt32}}
+
+func (item *Item) TrimLength() uint16 {
+	return item.text.TrimLength()
+}
+
+// Colors returns ansiOffsets of the Item
+func (item *Item) Colors() []ansiOffset {
+	if item.colors == nil {
+		return []ansiOffset{}
+	}
+	return *item.colors
+}
+
+// AsString returns the original string
+func (item *Item) AsString(stripAnsi bool) string {
+	if item.origText != nil {
+		if stripAnsi {
+			trimmed, _, _ := extractColor(string(*item.origText), nil, nil)
+			return trimmed
+		}
+		return string(*item.origText)
+	}
+	return item.text.ToString()
+}

src/item_test.go

@@ -0,0 +1,23 @@
+package fzf
+
+import (
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func TestStringPtr(t *testing.T) {
+	orig := []byte("\x1b[34mfoo")
+	text := []byte("\x1b[34mbar")
+	item := Item{origText: &orig, text: util.ToChars(text)}
+	if item.AsString(true) != "foo" || item.AsString(false) != string(orig) {
+		t.Fail()
+	}
+	if item.AsString(true) != "foo" {
+		t.Fail()
+	}
+	item.origText = nil
+	if item.AsString(true) != string(text) || item.AsString(false) != string(text) {
+		t.Fail()
+	}
+}

src/matcher.go

@@ -0,0 +1,257 @@
+package fzf
+
+import (
+	"fmt"
+	"runtime"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+// MatchRequest represents a search request
+type MatchRequest struct {
+	chunks   []*Chunk
+	pattern  *Pattern
+	final    bool
+	sort     bool
+	revision revision
+}
+
+// Matcher is responsible for performing search
+type Matcher struct {
+	cache          *ChunkCache
+	patternBuilder func([]rune) *Pattern
+	sort           bool
+	tac            bool
+	eventBox       *util.EventBox
+	reqBox         *util.EventBox
+	partitions     int
+	slab           []*util.Slab
+	mergerCache    map[string]*Merger
+	revision       revision
+}
+
+const (
+	reqRetry util.EventType = iota
+	reqReset
+)
+
+// 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)
+	return &Matcher{
+		cache:          cache,
+		patternBuilder: patternBuilder,
+		sort:           sort,
+		tac:            tac,
+		eventBox:       eventBox,
+		reqBox:         util.NewEventBox(),
+		partitions:     partitions,
+		slab:           make([]*util.Slab, partitions),
+		mergerCache:    make(map[string]*Merger),
+		revision:       revision}
+}
+
+// Loop puts Matcher in action
+func (m *Matcher) Loop() {
+	prevCount := 0
+
+	for {
+		var request MatchRequest
+
+		stop := false
+		m.reqBox.Wait(func(events *util.Events) {
+			for t, val := range *events {
+				if t == reqQuit {
+					stop = true
+					return
+				}
+				switch val := val.(type) {
+				case MatchRequest:
+					request = val
+				default:
+					panic(fmt.Sprintf("Unexpected type: %T", val))
+				}
+			}
+			events.Clear()
+		})
+		if stop {
+			break
+		}
+
+		cacheCleared := false
+		if request.sort != m.sort || request.revision != m.revision {
+			m.sort = request.sort
+			m.revision = request.revision
+			m.mergerCache = make(map[string]*Merger)
+			if !request.revision.compatible(m.revision) {
+				m.cache.Clear()
+			}
+			cacheCleared = true
+		}
+
+		// Restart search
+		patternString := request.pattern.AsString()
+		var merger *Merger
+		cancelled := false
+		count := CountItems(request.chunks)
+
+		if !cacheCleared {
+			if count == prevCount {
+				// Look up mergerCache
+				if cached, found := m.mergerCache[patternString]; found {
+					merger = cached
+				}
+			} else {
+				// Invalidate mergerCache
+				prevCount = count
+				m.mergerCache = make(map[string]*Merger)
+			}
+		}
+
+		if merger == nil {
+			merger, cancelled = m.scan(request)
+		}
+
+		if !cancelled {
+			if merger.cacheable() {
+				m.mergerCache[patternString] = merger
+			}
+			merger.final = request.final
+			m.eventBox.Set(EvtSearchFin, merger)
+		}
+	}
+}
+
+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) {
+	startedAt := time.Now()
+
+	numChunks := len(request.chunks)
+	if numChunks == 0 {
+		return EmptyMerger(request.revision), false
+	}
+	pattern := request.pattern
+	if pattern.IsEmpty() {
+		return PassMerger(&request.chunks, m.tac, request.revision), false
+	}
+
+	minIndex := request.chunks[0].items[0].Index()
+	cancelled := util.NewAtomicBool(false)
+
+	slices := m.sliceChunks(request.chunks)
+	numSlices := len(slices)
+	resultChan := make(chan partialResult, numSlices)
+	countChan := make(chan int, numChunks)
+	waitGroup := sync.WaitGroup{}
+
+	for idx, chunks := range slices {
+		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)
+				if cancelled.Get() {
+					return
+				}
+				countChan <- len(matches)
+			}
+			sliceMatches := make([]Result, 0, count)
+			for _, matches := range allMatches {
+				sliceMatches = append(sliceMatches, matches...)
+			}
+			if m.sort && request.pattern.sortable {
+				if m.tac {
+					sort.Sort(ByRelevanceTac(sliceMatches))
+				} else {
+					sort.Sort(ByRelevance(sliceMatches))
+				}
+			}
+			resultChan <- partialResult{idx, sliceMatches}
+		}(idx, m.slab[idx], chunks)
+	}
+
+	wait := func() bool {
+		cancelled.Set(true)
+		waitGroup.Wait()
+		return true
+	}
+
+	count := 0
+	matchCount := 0
+	for matchesInChunk := range countChan {
+		count++
+		matchCount += matchesInChunk
+
+		if count == numChunks {
+			break
+		}
+
+		if m.reqBox.Peek(reqReset) {
+			return nil, wait()
+		}
+
+		if time.Since(startedAt) > progressMinDuration {
+			m.eventBox.Set(EvtSearchProgress, float32(count)/float32(numChunks))
+		}
+	}
+
+	partialResults := make([][]Result, numSlices)
+	for range slices {
+		partialResult := <-resultChan
+		partialResults[partialResult.index] = partialResult.matches
+	}
+	return NewMerger(pattern, partialResults, m.sort && request.pattern.sortable, m.tac, request.revision, minIndex), false
+}
+
+// Reset is called to interrupt/signal the ongoing search
+func (m *Matcher) Reset(chunks []*Chunk, patternRunes []rune, cancel bool, final bool, sort bool, revision revision) {
+	pattern := m.patternBuilder(patternRunes)
+
+	var event util.EventType
+	if cancel {
+		event = reqReset
+	} else {
+		event = reqRetry
+	}
+	m.reqBox.Set(event, MatchRequest{chunks, pattern, final, sort, revision})
+}
+
+func (m *Matcher) Stop() {
+	m.reqBox.Set(reqQuit, nil)
+}

src/merger.go

@@ -0,0 +1,172 @@
+package fzf
+
+import "fmt"
+
+// EmptyMerger is a Merger with no data
+func EmptyMerger(revision revision) *Merger {
+	return NewMerger(nil, [][]Result{}, false, false, revision, 0)
+}
+
+// Merger holds a set of locally sorted lists of items and provides the view of
+// 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
+}
+
+// PassMerger returns a new Merger that simply returns the items in the
+// original order
+func PassMerger(chunks *[]*Chunk, tac bool, revision revision) *Merger {
+	var minIndex int32
+	if len(*chunks) > 0 {
+		minIndex = (*chunks)[0].items[0].Index()
+	}
+	mg := Merger{
+		pattern:  nil,
+		chunks:   chunks,
+		tac:      tac,
+		count:    0,
+		pass:     true,
+		revision: revision,
+		minIndex: minIndex}
+
+	for _, chunk := range *mg.chunks {
+		mg.count += chunk.count
+	}
+	return &mg
+}
+
+// NewMerger returns a new Merger
+func NewMerger(pattern *Pattern, lists [][]Result, sorted bool, tac bool, revision revision, minIndex int32) *Merger {
+	mg := Merger{
+		pattern:  pattern,
+		lists:    lists,
+		merged:   []Result{},
+		chunks:   nil,
+		cursors:  make([]int, len(lists)),
+		sorted:   sorted,
+		tac:      tac,
+		final:    false,
+		count:    0,
+		revision: revision,
+		minIndex: minIndex}
+
+	for _, list := range mg.lists {
+		mg.count += len(list)
+	}
+	return &mg
+}
+
+// Revision returns revision number
+func (mg *Merger) Revision() revision {
+	return mg.revision
+}
+
+// Length returns the number of items
+func (mg *Merger) Length() int {
+	return mg.count
+}
+
+func (mg *Merger) First() Result {
+	if mg.tac && !mg.sorted {
+		return mg.Get(mg.count - 1)
+	}
+	return mg.Get(0)
+}
+
+// FindIndex returns the index of the item with the given item index
+func (mg *Merger) FindIndex(itemIndex int32) int {
+	index := -1
+	if mg.pass {
+		index = int(itemIndex - mg.minIndex)
+		if mg.tac {
+			index = mg.count - index - 1
+		}
+	} else {
+		for i := 0; i < mg.count; i++ {
+			if mg.Get(i).item.Index() == itemIndex {
+				index = i
+				break
+			}
+		}
+	}
+	return index
+}
+
+// Get returns the pointer to the Result object indexed by the given integer
+func (mg *Merger) Get(idx int) Result {
+	if mg.chunks != nil {
+		if mg.tac {
+			idx = mg.count - idx - 1
+		}
+		firstChunk := (*mg.chunks)[0]
+		if firstChunk.count < chunkSize && idx >= firstChunk.count {
+			idx -= firstChunk.count
+
+			chunk := (*mg.chunks)[idx/chunkSize+1]
+			return Result{item: &chunk.items[idx%chunkSize]}
+		}
+		chunk := (*mg.chunks)[idx/chunkSize]
+		return Result{item: &chunk.items[idx%chunkSize]}
+	}
+
+	if mg.sorted {
+		return mg.mergedGet(idx)
+	}
+
+	if mg.tac {
+		idx = mg.count - idx - 1
+	}
+	for _, list := range mg.lists {
+		numItems := len(list)
+		if idx < numItems {
+			return list[idx]
+		}
+		idx -= numItems
+	}
+	panic(fmt.Sprintf("Index out of bounds (unsorted, %d/%d)", idx, mg.count))
+}
+
+func (mg *Merger) cacheable() bool {
+	return mg.count < mergerCacheMax
+}
+
+func (mg *Merger) mergedGet(idx int) Result {
+	for i := len(mg.merged); i <= idx; i++ {
+		minRank := minRank()
+		minIdx := -1
+		for listIdx, list := range mg.lists {
+			cursor := mg.cursors[listIdx]
+			if cursor < 0 || cursor == len(list) {
+				mg.cursors[listIdx] = -1
+				continue
+			}
+			if cursor >= 0 {
+				rank := list[cursor]
+				if minIdx < 0 || compareRanks(rank, minRank, mg.tac) {
+					minRank = rank
+					minIdx = listIdx
+				}
+			}
+		}
+
+		if minIdx >= 0 {
+			chosen := mg.lists[minIdx]
+			mg.merged = append(mg.merged, chosen[mg.cursors[minIdx]])
+			mg.cursors[minIdx]++
+		} else {
+			panic(fmt.Sprintf("Index out of bounds (sorted, %d/%d)", i, mg.count))
+		}
+	}
+	return mg.merged[idx]
+}

src/merger_test.go

@@ -0,0 +1,89 @@
+package fzf
+
+import (
+	"fmt"
+	"math/rand"
+	"sort"
+	"testing"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func assert(t *testing.T, cond bool, msg ...string) {
+	if !cond {
+		t.Error(msg)
+	}
+}
+
+func randResult() Result {
+	str := fmt.Sprintf("%d", rand.Uint32())
+	chars := util.ToChars([]byte(str))
+	chars.Index = rand.Int31()
+	return Result{item: &Item{text: chars}}
+}
+
+func TestEmptyMerger(t *testing.T) {
+	r := revision{}
+	assert(t, EmptyMerger(r).Length() == 0, "Not empty")
+	assert(t, EmptyMerger(r).count == 0, "Invalid count")
+	assert(t, len(EmptyMerger(r).lists) == 0, "Invalid lists")
+	assert(t, len(EmptyMerger(r).merged) == 0, "Invalid merged list")
+}
+
+func buildLists(partiallySorted bool) ([][]Result, []Result) {
+	numLists := 4
+	lists := make([][]Result, numLists)
+	cnt := 0
+	for i := 0; i < numLists; i++ {
+		numResults := rand.Int() % 20
+		cnt += numResults
+		lists[i] = make([]Result, numResults)
+		for j := 0; j < numResults; j++ {
+			item := randResult()
+			lists[i][j] = item
+		}
+		if partiallySorted {
+			sort.Sort(ByRelevance(lists[i]))
+		}
+	}
+	items := []Result{}
+	for _, list := range lists {
+		items = append(items, list...)
+	}
+	return lists, items
+}
+
+func TestMergerUnsorted(t *testing.T) {
+	lists, items := buildLists(false)
+	cnt := len(items)
+
+	// Not sorted: same order
+	mg := NewMerger(nil, lists, false, false, revision{}, 0)
+	assert(t, cnt == mg.Length(), "Invalid Length")
+	for i := 0; i < cnt; i++ {
+		assert(t, items[i] == mg.Get(i), "Invalid Get")
+	}
+}
+
+func TestMergerSorted(t *testing.T) {
+	lists, items := buildLists(true)
+	cnt := len(items)
+
+	// Sorted sorted order
+	mg := NewMerger(nil, lists, true, false, revision{}, 0)
+	assert(t, cnt == mg.Length(), "Invalid Length")
+	sort.Sort(ByRelevance(items))
+	for i := 0; i < cnt; i++ {
+		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)
+	for i := cnt - 1; i >= 0; i-- {
+		if items[i] != mg2.Get(i) {
+			t.Error("Not sorted", items[i], mg2.Get(i))
+		}
+	}
+}

src/options_no_pprof.go

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

src/options_pprof.go

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

src/options_pprof_test.go

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

src/options_test.go

@@ -0,0 +1,502 @@
+package fzf
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/junegunn/fzf/src/tui"
+)
+
+func TestDelimiterRegex(t *testing.T) {
+	// Valid regex
+	delim := delimiterRegexp(".")
+	if delim.regex == nil || delim.str != nil {
+		t.Error(delim)
+	}
+	// Broken regex -> string
+	delim = delimiterRegexp("[0-9")
+	if delim.regex != nil || *delim.str != "[0-9" {
+		t.Error(delim)
+	}
+	// Valid regex
+	delim = delimiterRegexp("[0-9]")
+	if delim.regex.String() != "[0-9]" || delim.str != nil {
+		t.Error(delim)
+	}
+	// Tab character
+	delim = delimiterRegexp("\t")
+	if delim.regex != nil || *delim.str != "\t" {
+		t.Error(delim)
+	}
+	// Tab expression
+	delim = delimiterRegexp("\\t")
+	if delim.regex != nil || *delim.str != "\t" {
+		t.Error(delim)
+	}
+	// Tabs -> regex
+	delim = delimiterRegexp("\t+")
+	if delim.regex == nil || delim.str != nil {
+		t.Error(delim)
+	}
+}
+
+func TestDelimiterRegexString(t *testing.T) {
+	delim := delimiterRegexp("*")
+	tokens := Tokenize("-*--*---**---", delim)
+	if delim.regex != nil ||
+		tokens[0].text.ToString() != "-*" ||
+		tokens[1].text.ToString() != "--*" ||
+		tokens[2].text.ToString() != "---*" ||
+		tokens[3].text.ToString() != "*" ||
+		tokens[4].text.ToString() != "---" {
+		t.Errorf("%s %v %d", delim, tokens, len(tokens))
+	}
+}
+
+func TestDelimiterRegexRegex(t *testing.T) {
+	delim := delimiterRegexp("--\\*")
+	tokens := Tokenize("-*--*---**---", delim)
+	if delim.str != nil ||
+		tokens[0].text.ToString() != "-*--*" ||
+		tokens[1].text.ToString() != "---*" ||
+		tokens[2].text.ToString() != "*---" {
+		t.Errorf("%s %d", tokens, len(tokens))
+	}
+}
+
+func TestDelimiterRegexRegexCaret(t *testing.T) {
+	delim := delimiterRegexp(`(^\s*|\s+)`)
+	tokens := Tokenize("foo  bar baz", delim)
+	if delim.str != nil ||
+		len(tokens) != 4 ||
+		tokens[0].text.ToString() != "" ||
+		tokens[1].text.ToString() != "foo  " ||
+		tokens[2].text.ToString() != "bar " ||
+		tokens[3].text.ToString() != "baz" {
+		t.Errorf("%s %d", tokens, len(tokens))
+	}
+}
+
+func TestSplitNth(t *testing.T) {
+	{
+		ranges, _ := splitNth("..")
+		if len(ranges) != 1 ||
+			ranges[0].begin != rangeEllipsis ||
+			ranges[0].end != rangeEllipsis {
+			t.Errorf("%v", ranges)
+		}
+	}
+	{
+		ranges, _ := splitNth("..3,1..,2..3,4..-1,-3..-2,..,2,-2,2..-2,1..-1")
+		if len(ranges) != 10 ||
+			ranges[0].begin != rangeEllipsis || ranges[0].end != 3 ||
+			ranges[1].begin != rangeEllipsis || ranges[1].end != rangeEllipsis ||
+			ranges[2].begin != 2 || ranges[2].end != 3 ||
+			ranges[3].begin != 4 || ranges[3].end != rangeEllipsis ||
+			ranges[4].begin != -3 || ranges[4].end != -2 ||
+			ranges[5].begin != rangeEllipsis || ranges[5].end != rangeEllipsis ||
+			ranges[6].begin != 2 || ranges[6].end != 2 ||
+			ranges[7].begin != -2 || ranges[7].end != -2 ||
+			ranges[8].begin != 2 || ranges[8].end != -2 ||
+			ranges[9].begin != rangeEllipsis || ranges[9].end != rangeEllipsis {
+			t.Errorf("%v", ranges)
+		}
+	}
+}
+
+func TestIrrelevantNth(t *testing.T) {
+	index := 0
+	{
+		opts := defaultOptions()
+		words := []string{"--nth", "..", "-x"}
+		parseOptions(&index, opts, words)
+		postProcessOptions(opts)
+		if len(opts.Nth) != 0 {
+			t.Errorf("nth should be empty: %v", opts.Nth)
+		}
+	}
+	for _, words := range [][]string{{"--nth", "..,3", "+x"}, {"--nth", "3,1..", "+x"}, {"--nth", "..-1,1", "+x"}} {
+		{
+			opts := defaultOptions()
+			parseOptions(&index, opts, words)
+			postProcessOptions(opts)
+			if len(opts.Nth) != 0 {
+				t.Errorf("nth should be empty: %v", opts.Nth)
+			}
+		}
+		{
+			opts := defaultOptions()
+			words = append(words, "-x")
+			parseOptions(&index, opts, words)
+			postProcessOptions(opts)
+			if len(opts.Nth) != 2 {
+				t.Errorf("nth should not be empty: %v", opts.Nth)
+			}
+		}
+	}
+}
+
+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", "")
+	checkEvent := func(e tui.Event, s string) {
+		if pairs[e] != s {
+			t.Errorf("%s != %s", pairs[e], s)
+		}
+	}
+	check := func(et tui.EventType, s string) {
+		checkEvent(et.AsEvent(), s)
+	}
+	if len(pairs) != 12 {
+		t.Error(12)
+	}
+	check(tui.CtrlZ, "ctrl-z")
+	check(tui.F2, "f2")
+	check(tui.CtrlG, "ctrl-G")
+	checkEvent(tui.AltKey('z'), "alt-z")
+	checkEvent(tui.Key('@'), "@")
+	checkEvent(tui.AltKey('a'), "Alt-a")
+	checkEvent(tui.Key('!'), "!")
+	checkEvent(tui.Key('J'), "J")
+	checkEvent(tui.Key('g'), "g")
+	checkEvent(tui.CtrlAltKey('a'), "ctrl-alt-a")
+	checkEvent(tui.CtrlAltKey('m'), "ALT-enter")
+	checkEvent(tui.AltKey(' '), "alt-SPACE")
+
+	// Synonyms
+	pairs, _ = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
+	if len(pairs) != 9 {
+		t.Error(9)
+	}
+	check(tui.CtrlM, "Return")
+	checkEvent(tui.Key(' '), "space")
+	check(tui.Tab, "tab")
+	check(tui.ShiftTab, "btab")
+	check(tui.Esc, "esc")
+	check(tui.Up, "up")
+	check(tui.Down, "down")
+	check(tui.Left, "left")
+	check(tui.Right, "right")
+
+	pairs, _ = parseKeyChords("Tab,Ctrl-I,PgUp,page-up,pgdn,Page-Down,Home,End,Alt-BS,Alt-BSpace,shift-left,shift-right,btab,shift-tab,return,Enter,bspace", "")
+	if len(pairs) != 11 {
+		t.Error(11)
+	}
+	check(tui.Tab, "Ctrl-I")
+	check(tui.PageUp, "page-up")
+	check(tui.PageDown, "Page-Down")
+	check(tui.Home, "Home")
+	check(tui.End, "End")
+	check(tui.AltBackspace, "Alt-BSpace")
+	check(tui.ShiftLeft, "shift-left")
+	check(tui.ShiftRight, "shift-right")
+	check(tui.ShiftTab, "shift-tab")
+	check(tui.CtrlM, "Enter")
+	check(tui.Backspace, "bspace")
+}
+
+func TestParseKeysWithComma(t *testing.T) {
+	checkN := func(a int, b int) {
+		if a != b {
+			t.Errorf("%d != %d", a, b)
+		}
+	}
+	check := func(pairs map[tui.Event]string, e tui.Event, s string) {
+		if pairs[e] != s {
+			t.Errorf("%s != %s", pairs[e], s)
+		}
+	}
+
+	pairs, _ := parseKeyChords(",", "")
+	checkN(len(pairs), 1)
+	check(pairs, tui.Key(','), ",")
+
+	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,,", "")
+	checkN(len(pairs), 3)
+	check(pairs, tui.Key('a'), "a")
+	check(pairs, tui.Key('b'), "b")
+	check(pairs, tui.Key(','), ",")
+
+	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", "")
+	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(",,,", "")
+	checkN(len(pairs), 1)
+	check(pairs, tui.Key(','), ",")
+
+	pairs, _ = parseKeyChords(",ALT-,,", "")
+	checkN(len(pairs), 1)
+	check(pairs, tui.AltKey(','), "ALT-,")
+}
+
+func TestBind(t *testing.T) {
+	keymap := defaultKeymap()
+	check := func(event tui.Event, arg1 string, types ...actionType) {
+		if len(keymap[event]) != len(types) {
+			t.Errorf("invalid number of actions for %v (%d != %d)",
+				event, len(types), len(keymap[event]))
+			return
+		}
+		for idx, action := range keymap[event] {
+			if types[idx] != action.t {
+				t.Errorf("invalid action type (%d != %d)", types[idx], action.t)
+			}
+		}
+		if len(arg1) > 0 && keymap[event][0].a != arg1 {
+			t.Errorf("invalid action argument: (%s != %s)", arg1, keymap[event][0].a)
+		}
+	}
+	check(tui.CtrlA.AsEvent(), "", actBeginningOfLine)
+	parseKeymap(keymap,
+		"ctrl-a:kill-line,ctrl-b:toggle-sort+up+down,c:page-up,alt-z:page-down,"+
+			"f1:execute(ls {+})+abort+execute(echo \n{+})+select-all,f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
+			"alt-a:execute-Multi@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};,"+
+			"x:Execute(foo+bar),X:execute/bar+baz/"+
+			",f1:+first,f1:+top"+
+			",,:abort,::accept,+:execute:++\nfoobar,Y:execute(baz)+up")
+	check(tui.CtrlA.AsEvent(), "", actKillLine)
+	check(tui.CtrlB.AsEvent(), "", actToggleSort, actUp, actDown)
+	check(tui.Key('c'), "", actPageUp)
+	check(tui.Key(','), "", actAbort)
+	check(tui.Key(':'), "", actAccept)
+	check(tui.AltKey('z'), "", actPageDown)
+	check(tui.F1.AsEvent(), "ls {+}", actExecute, actAbort, actExecute, actSelectAll, actFirst, actFirst)
+	check(tui.F2.AsEvent(), "echo {}, {}, {}", actExecute)
+	check(tui.F3.AsEvent(), "echo '({})'", actExecute)
+	check(tui.F4.AsEvent(), "less {}", actExecute)
+	check(tui.Key('x'), "foo+bar", actExecute)
+	check(tui.Key('X'), "bar+baz", actExecute)
+	check(tui.AltKey('a'), "echo (,),[,],/,:,;,%,{}", actExecuteMulti)
+	check(tui.AltKey('b'), "echo (,),[,],/,:,@,%,{}", actExecute)
+	check(tui.Key('+'), "++\nfoobar,Y:execute(baz)+up", actExecute)
+
+	for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} {
+		parseKeymap(keymap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
+		check(tui.Key([]rune(fmt.Sprintf("%d", idx%10))[0]), "foobar", actExecute)
+	}
+
+	parseKeymap(keymap, "f1:abort")
+	check(tui.F1.AsEvent(), "", actAbort)
+}
+
+func TestColorSpec(t *testing.T) {
+	theme := tui.Dark256
+	dark, _ := parseTheme(theme, "dark")
+	if *dark != *theme {
+		t.Errorf("colors should be equivalent")
+	}
+	if dark == theme {
+		t.Errorf("point should not be equivalent")
+	}
+
+	light, _ := parseTheme(theme, "dark,light")
+	if *light == *theme {
+		t.Errorf("should not be equivalent")
+	}
+	if *light != *tui.Light256 {
+		t.Errorf("colors should be equivalent")
+	}
+	if light == theme {
+		t.Errorf("point should not be equivalent")
+	}
+
+	customized, _ := parseTheme(theme, "fg:231,bg:232")
+	if customized.Fg.Color != 231 || customized.Bg.Color != 232 {
+		t.Errorf("color not customized")
+	}
+	if *tui.Dark256 == *customized {
+		t.Errorf("colors should not be equivalent")
+	}
+	customized.Fg = tui.Dark256.Fg
+	customized.Bg = tui.Dark256.Bg
+	if *tui.Dark256 != *customized {
+		t.Errorf("colors should now be equivalent: %v, %v", tui.Dark256, customized)
+	}
+
+	customized, _ = parseTheme(theme, "fg:231,dark,bg:232")
+	if customized.Fg != tui.Dark256.Fg || customized.Bg == tui.Dark256.Bg {
+		t.Errorf("color not customized")
+	}
+}
+
+func TestDefaultCtrlNP(t *testing.T) {
+	index := 0
+	check := func(words []string, et tui.EventType, expected actionType) {
+		e := et.AsEvent()
+		opts := defaultOptions()
+		parseOptions(&index, opts, words)
+		postProcessOptions(opts)
+		if opts.Keymap[e][0].t != expected {
+			t.Error()
+		}
+	}
+	check([]string{}, tui.CtrlN, actDown)
+	check([]string{}, tui.CtrlP, actUp)
+
+	check([]string{"--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
+	check([]string{"--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
+
+	f, _ := os.CreateTemp("", "fzf-history")
+	f.Close()
+	hist := "--history=" + f.Name()
+	check([]string{hist}, tui.CtrlN, actNextHistory)
+	check([]string{hist}, tui.CtrlP, actPrevHistory)
+
+	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlN, actAccept)
+	check([]string{hist, "--bind=ctrl-n:accept"}, tui.CtrlP, actPrevHistory)
+
+	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlN, actNextHistory)
+	check([]string{hist, "--bind=ctrl-p:accept"}, tui.CtrlP, actAccept)
+}
+
+func optsFor(words ...string) *Options {
+	index := 0
+	opts := defaultOptions()
+	parseOptions(&index, opts, words)
+	postProcessOptions(opts)
+	return opts
+}
+
+func TestToggle(t *testing.T) {
+	opts := optsFor()
+	if opts.ToggleSort {
+		t.Error()
+	}
+
+	opts = optsFor("--bind=a:toggle-sort")
+	if !opts.ToggleSort {
+		t.Error()
+	}
+
+	opts = optsFor("--bind=a:toggle-sort", "--bind=a:up")
+	if opts.ToggleSort {
+		t.Error()
+	}
+}
+
+func TestPreviewOpts(t *testing.T) {
+	opts := optsFor()
+	if !(opts.Preview.command == "" &&
+		opts.Preview.hidden == false &&
+		opts.Preview.wrap == false &&
+		opts.Preview.position == posRight &&
+		opts.Preview.size.percent == true &&
+		opts.Preview.size.size == 50) {
+		t.Error()
+	}
+	opts = optsFor("--preview", "cat {}", "--preview-window=left:15,hidden,wrap:+{1}-/2")
+	if !(opts.Preview.command == "cat {}" &&
+		opts.Preview.hidden == true &&
+		opts.Preview.wrap == true &&
+		opts.Preview.position == posLeft &&
+		opts.Preview.scroll == "+{1}-/2" &&
+		opts.Preview.size.percent == false &&
+		opts.Preview.size.size == 15) {
+		t.Error(opts.Preview)
+	}
+	opts = optsFor("--preview-window=up,15,wrap,hidden,+{1}+3-1-2/2", "--preview-window=down", "--preview-window=cycle")
+	if !(opts.Preview.command == "" &&
+		opts.Preview.hidden == true &&
+		opts.Preview.wrap == true &&
+		opts.Preview.cycle == true &&
+		opts.Preview.position == posDown &&
+		opts.Preview.scroll == "+{1}+3-1-2/2" &&
+		opts.Preview.size.percent == false &&
+		opts.Preview.size.size == 15) {
+		t.Error(opts.Preview.size.size)
+	}
+	opts = optsFor("--preview-window=up:15:wrap:hidden")
+	if !(opts.Preview.command == "" &&
+		opts.Preview.hidden == true &&
+		opts.Preview.wrap == true &&
+		opts.Preview.position == posUp &&
+		opts.Preview.size.percent == false &&
+		opts.Preview.size.size == 15) {
+		t.Error(opts.Preview)
+	}
+	opts = optsFor("--preview=foo", "--preview-window=up", "--preview-window=default:70%")
+	if !(opts.Preview.command == "foo" &&
+		opts.Preview.position == posRight &&
+		opts.Preview.size.percent == true &&
+		opts.Preview.size.size == 70) {
+		t.Error(opts.Preview)
+	}
+}
+
+func TestAdditiveExpect(t *testing.T) {
+	opts := optsFor("--expect=a", "--expect", "b", "--expect=c")
+	if len(opts.Expect) != 3 {
+		t.Error(opts.Expect)
+	}
+}
+
+func TestValidateSign(t *testing.T) {
+	testCases := []struct {
+		inputSign string
+		isValid   bool
+	}{
+		{"> ", true},
+		{"아", true},
+		{"😀", true},
+		{">>>", false},
+	}
+
+	for _, testCase := range testCases {
+		err := validateSign(testCase.inputSign, "")
+		if testCase.isValid && err != nil {
+			t.Errorf("Input sign `%s` caused error", testCase.inputSign)
+		}
+
+		if !testCase.isValid && err == nil {
+			t.Errorf("Input sign `%s` did not cause error", testCase.inputSign)
+		}
+	}
+}
+
+func TestParseSingleActionList(t *testing.T) {
+	actions, _ := parseSingleActionList("Execute@foo+bar,baz@+up+up+reload:down+down")
+	if len(actions) != 4 {
+		t.Errorf("Invalid number of actions parsed:%d", len(actions))
+	}
+	if actions[0].t != actExecute || actions[0].a != "foo+bar,baz" {
+		t.Errorf("Invalid action parsed: %v", actions[0])
+	}
+	if actions[1].t != actUp || actions[2].t != actUp {
+		t.Errorf("Invalid action parsed: %v / %v", actions[1], actions[2])
+	}
+	if actions[3].t != actReload || actions[3].a != "down+down" {
+		t.Errorf("Invalid action parsed: %v", actions[3])
+	}
+}
+
+func TestParseSingleActionListError(t *testing.T) {
+	_, err := parseSingleActionList("change-query(foobar)baz")
+	if err == nil {
+		t.Errorf("Failed to detect error")
+	}
+}
+
+func TestMaskActionContents(t *testing.T) {
+	original := ":execute((f)(o)(o)(b)(a)(r))+change-query@qu@ry@+up,x:reload:hello:world"
+	expected := ":execute                    +change-query       +up,x:reload            "
+	masked := maskActionContents(original)
+	if masked != expected {
+		t.Errorf("Not masked: %s", masked)
+	}
+}

src/pattern.go

@@ -0,0 +1,419 @@
+package fzf
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/junegunn/fzf/src/algo"
+	"github.com/junegunn/fzf/src/util"
+)
+
+// fuzzy
+// 'exact
+// ^prefix-exact
+// suffix-exact$
+// !inverse-exact
+// !'inverse-fuzzy
+// !^inverse-prefix-exact
+// !inverse-suffix-exact$
+
+type termType int
+
+const (
+	termFuzzy termType = iota
+	termExact
+	termExactBoundary
+	termPrefix
+	termSuffix
+	termEqual
+)
+
+type term struct {
+	typ           termType
+	inv           bool
+	text          []rune
+	caseSensitive bool
+	normalize     bool
+}
+
+// String returns the string representation of a term.
+func (t term) String() string {
+	return fmt.Sprintf("term{typ: %d, inv: %v, text: []rune(%q), caseSensitive: %v}", t.typ, t.inv, string(t.text), t.caseSensitive)
+}
+
+type termSet []term
+
+// Pattern represents search pattern
+type Pattern struct {
+	fuzzy         bool
+	fuzzyAlgo     algo.Algo
+	extended      bool
+	caseSensitive bool
+	normalize     bool
+	forward       bool
+	withPos       bool
+	text          []rune
+	termSets      []termSet
+	sortable      bool
+	cacheable     bool
+	cacheKey      string
+	delimiter     Delimiter
+	nth           []Range
+	procFun       map[termType]algo.Algo
+	cache         *ChunkCache
+}
+
+var _splitRegex *regexp.Regexp
+
+func init() {
+	_splitRegex = regexp.MustCompile(" +")
+}
+
+// BuildPattern builds Pattern object from the given arguments
+func BuildPattern(cache *ChunkCache, patternCache map[string]*Pattern, fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
+	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
+
+	var asString string
+	if extended {
+		asString = strings.TrimLeft(string(runes), " ")
+		for strings.HasSuffix(asString, " ") && !strings.HasSuffix(asString, "\\ ") {
+			asString = asString[:len(asString)-1]
+		}
+	} else {
+		asString = string(runes)
+	}
+
+	// We can uniquely identify the pattern for a given string since
+	// search mode and caseMode do not change while the program is running
+	cached, found := patternCache[asString]
+	if found {
+		return cached
+	}
+
+	caseSensitive := true
+	sortable := true
+	termSets := []termSet{}
+
+	if extended {
+		termSets = parseTerms(fuzzy, caseMode, normalize, asString)
+		// We should not sort the result if there are only inverse search terms
+		sortable = false
+	Loop:
+		for _, termSet := range termSets {
+			for idx, term := range termSet {
+				if !term.inv {
+					sortable = true
+				}
+				// If the query contains inverse search terms or OR operators,
+				// we cannot cache the search scope
+				if !cacheable || idx > 0 || term.inv || fuzzy && term.typ != termFuzzy || !fuzzy && term.typ != termExact {
+					cacheable = false
+					if sortable {
+						// Can't break until we see at least one non-inverse term
+						break Loop
+					}
+				}
+			}
+		}
+	} else {
+		lowerString := strings.ToLower(asString)
+		normalize = normalize &&
+			lowerString == string(algo.NormalizeRunes([]rune(lowerString)))
+		caseSensitive = caseMode == CaseRespect ||
+			caseMode == CaseSmart && lowerString != asString
+		if !caseSensitive {
+			asString = lowerString
+		}
+	}
+
+	ptr := &Pattern{
+		fuzzy:         fuzzy,
+		fuzzyAlgo:     fuzzyAlgo,
+		extended:      extended,
+		caseSensitive: caseSensitive,
+		normalize:     normalize,
+		forward:       forward,
+		withPos:       withPos,
+		text:          []rune(asString),
+		termSets:      termSets,
+		sortable:      sortable,
+		cacheable:     cacheable,
+		nth:           nth,
+		delimiter:     delimiter,
+		cache:         cache,
+		procFun:       make(map[termType]algo.Algo)}
+
+	ptr.cacheKey = ptr.buildCacheKey()
+	ptr.procFun[termFuzzy] = fuzzyAlgo
+	ptr.procFun[termEqual] = algo.EqualMatch
+	ptr.procFun[termExact] = algo.ExactMatchNaive
+	ptr.procFun[termExactBoundary] = algo.ExactMatchBoundary
+	ptr.procFun[termPrefix] = algo.PrefixMatch
+	ptr.procFun[termSuffix] = algo.SuffixMatch
+
+	patternCache[asString] = ptr
+	return ptr
+}
+
+func parseTerms(fuzzy bool, caseMode Case, normalize bool, str string) []termSet {
+	str = strings.ReplaceAll(str, "\\ ", "\t")
+	tokens := _splitRegex.Split(str, -1)
+	sets := []termSet{}
+	set := termSet{}
+	switchSet := false
+	afterBar := false
+	for _, token := range tokens {
+		typ, inv, text := termFuzzy, false, strings.ReplaceAll(token, "\t", " ")
+		lowerText := strings.ToLower(text)
+		caseSensitive := caseMode == CaseRespect ||
+			caseMode == CaseSmart && text != lowerText
+		normalizeTerm := normalize &&
+			lowerText == string(algo.NormalizeRunes([]rune(lowerText)))
+		if !caseSensitive {
+			text = lowerText
+		}
+		if !fuzzy {
+			typ = termExact
+		}
+
+		if len(set) > 0 && !afterBar && text == "|" {
+			switchSet = false
+			afterBar = true
+			continue
+		}
+		afterBar = false
+
+		if strings.HasPrefix(text, "!") {
+			inv = true
+			typ = termExact
+			text = text[1:]
+		}
+
+		if text != "$" && strings.HasSuffix(text, "$") {
+			typ = termSuffix
+			text = text[:len(text)-1]
+		}
+
+		if len(text) > 2 && strings.HasPrefix(text, "'") && strings.HasSuffix(text, "'") {
+			typ = termExactBoundary
+			text = text[1 : len(text)-1]
+		} else if strings.HasPrefix(text, "'") {
+			// Flip exactness
+			if fuzzy && !inv {
+				typ = termExact
+			} else {
+				typ = termFuzzy
+			}
+			text = text[1:]
+		} else if strings.HasPrefix(text, "^") {
+			if typ == termSuffix {
+				typ = termEqual
+			} else {
+				typ = termPrefix
+			}
+			text = text[1:]
+		}
+
+		if len(text) > 0 {
+			if switchSet {
+				sets = append(sets, set)
+				set = termSet{}
+			}
+			textRunes := []rune(text)
+			if normalizeTerm {
+				textRunes = algo.NormalizeRunes(textRunes)
+			}
+			set = append(set, term{
+				typ:           typ,
+				inv:           inv,
+				text:          textRunes,
+				caseSensitive: caseSensitive,
+				normalize:     normalizeTerm})
+			switchSet = true
+		}
+	}
+	if len(set) > 0 {
+		sets = append(sets, set)
+	}
+	return sets
+}
+
+// IsEmpty returns true if the pattern is effectively empty
+func (p *Pattern) IsEmpty() bool {
+	if !p.extended {
+		return len(p.text) == 0
+	}
+	return len(p.termSets) == 0
+}
+
+// AsString returns the search query in string type
+func (p *Pattern) AsString() string {
+	return string(p.text)
+}
+
+func (p *Pattern) buildCacheKey() string {
+	if !p.extended {
+		return p.AsString()
+	}
+	cacheableTerms := []string{}
+	for _, termSet := range p.termSets {
+		if len(termSet) == 1 && !termSet[0].inv && (p.fuzzy || termSet[0].typ == termExact) {
+			cacheableTerms = append(cacheableTerms, string(termSet[0].text))
+		}
+	}
+	return strings.Join(cacheableTerms, "\t")
+}
+
+// CacheKey is used to build string to be used as the key of result cache
+func (p *Pattern) CacheKey() string {
+	return p.cacheKey
+}
+
+// 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()
+	if p.cacheable {
+		if cached := p.cache.Lookup(chunk, cacheKey); cached != nil {
+			return cached
+		}
+	}
+
+	// Prefix/suffix cache
+	space := p.cache.Search(chunk, cacheKey)
+
+	matches := p.matchChunk(chunk, space, slab)
+
+	if p.cacheable {
+		p.cache.Add(chunk, cacheKey, matches)
+	}
+	return matches
+}
+
+func (p *Pattern) matchChunk(chunk *Chunk, space []Result, slab *util.Slab) []Result {
+	matches := []Result{}
+
+	if space == nil {
+		for idx := 0; idx < chunk.count; idx++ {
+			if match, _, _ := p.MatchItem(&chunk.items[idx], p.withPos, slab); match != nil {
+				matches = append(matches, *match)
+			}
+		}
+	} else {
+		for _, result := range space {
+			if match, _, _ := p.MatchItem(result.item, p.withPos, slab); match != nil {
+				matches = append(matches, *match)
+			}
+		}
+	}
+	return matches
+}
+
+// MatchItem returns true if the Item is a 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 nil, 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 nil, nil, nil
+}
+
+func (p *Pattern) basicMatch(item *Item, withPos bool, slab *util.Slab) (Offset, int, *[]int) {
+	var input []Token
+	if len(p.nth) == 0 {
+		input = []Token{{text: &item.text, prefixLength: 0}}
+	} else {
+		input = p.transformInput(item)
+	}
+	if p.fuzzy {
+		return p.iter(p.fuzzyAlgo, input, p.caseSensitive, p.normalize, p.forward, p.text, withPos, slab)
+	}
+	return p.iter(algo.ExactMatchNaive, input, p.caseSensitive, p.normalize, p.forward, p.text, withPos, slab)
+}
+
+func (p *Pattern) extendedMatch(item *Item, withPos bool, slab *util.Slab) ([]Offset, int, *[]int) {
+	var input []Token
+	if len(p.nth) == 0 {
+		input = []Token{{text: &item.text, prefixLength: 0}}
+	} else {
+		input = p.transformInput(item)
+	}
+	offsets := []Offset{}
+	var totalScore int
+	var allPos *[]int
+	if withPos {
+		allPos = &[]int{}
+	}
+	for _, termSet := range p.termSets {
+		var offset Offset
+		var currentScore int
+		matched := false
+		for _, term := range termSet {
+			pfun := p.procFun[term.typ]
+			off, score, pos := p.iter(pfun, input, term.caseSensitive, term.normalize, p.forward, term.text, withPos, slab)
+			if sidx := off[0]; sidx >= 0 {
+				if term.inv {
+					continue
+				}
+				offset, currentScore = off, score
+				matched = true
+				if withPos {
+					if pos != nil {
+						*allPos = append(*allPos, *pos...)
+					} else {
+						for idx := off[0]; idx < off[1]; idx++ {
+							*allPos = append(*allPos, int(idx))
+						}
+					}
+				}
+				break
+			} else if term.inv {
+				offset, currentScore = Offset{0, 0}, 0
+				matched = true
+				continue
+			}
+		}
+		if matched {
+			offsets = append(offsets, offset)
+			totalScore += currentScore
+		}
+	}
+	return offsets, totalScore, allPos
+}
+
+func (p *Pattern) transformInput(item *Item) []Token {
+	if item.transformed != nil {
+		return *item.transformed
+	}
+
+	tokens := Tokenize(item.text.ToString(), p.delimiter)
+	ret := Transform(tokens, p.nth)
+	item.transformed = &ret
+	return ret
+}
+
+func (p *Pattern) iter(pfun algo.Algo, tokens []Token, caseSensitive bool, normalize bool, forward bool, pattern []rune, withPos bool, slab *util.Slab) (Offset, int, *[]int) {
+	for _, part := range tokens {
+		if res, pos := pfun(caseSensitive, normalize, forward, part.text, pattern, withPos, slab); res.Start >= 0 {
+			sidx := int32(res.Start) + part.prefixLength
+			eidx := int32(res.End) + part.prefixLength
+			if pos != nil {
+				for idx := range *pos {
+					(*pos)[idx] += int(part.prefixLength)
+				}
+			}
+			return Offset{sidx, eidx}, res.Score, pos
+		}
+	}
+	return Offset{-1, -1}, 0, nil
+}

src/pattern_test.go

@@ -0,0 +1,201 @@
+package fzf
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/junegunn/fzf/src/algo"
+	"github.com/junegunn/fzf/src/util"
+)
+
+var slab *util.Slab
+
+func init() {
+	slab = util.MakeSlab(slab16Size, slab32Size)
+}
+
+func TestParseTermsExtended(t *testing.T) {
+	terms := parseTerms(true, CaseSmart, false,
+		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$ | ^iii$ ^xxx | 'yyy | zzz$ | !ZZZ |")
+	if len(terms) != 9 ||
+		terms[0][0].typ != termFuzzy || terms[0][0].inv ||
+		terms[1][0].typ != termExact || terms[1][0].inv ||
+		terms[2][0].typ != termPrefix || terms[2][0].inv ||
+		terms[3][0].typ != termSuffix || terms[3][0].inv ||
+		terms[4][0].typ != termExact || !terms[4][0].inv ||
+		terms[5][0].typ != termFuzzy || !terms[5][0].inv ||
+		terms[6][0].typ != termPrefix || !terms[6][0].inv ||
+		terms[7][0].typ != termSuffix || !terms[7][0].inv ||
+		terms[7][1].typ != termEqual || terms[7][1].inv ||
+		terms[8][0].typ != termPrefix || terms[8][0].inv ||
+		terms[8][1].typ != termExact || terms[8][1].inv ||
+		terms[8][2].typ != termSuffix || terms[8][2].inv ||
+		terms[8][3].typ != termExact || !terms[8][3].inv {
+		t.Errorf("%v", terms)
+	}
+	for _, termSet := range terms[:8] {
+		term := termSet[0]
+		if len(term.text) != 3 {
+			t.Errorf("%v", term)
+		}
+	}
+}
+
+func TestParseTermsExtendedExact(t *testing.T) {
+	terms := parseTerms(false, CaseSmart, false,
+		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
+	if len(terms) != 8 ||
+		terms[0][0].typ != termExact || terms[0][0].inv || len(terms[0][0].text) != 3 ||
+		terms[1][0].typ != termFuzzy || terms[1][0].inv || len(terms[1][0].text) != 3 ||
+		terms[2][0].typ != termPrefix || terms[2][0].inv || len(terms[2][0].text) != 3 ||
+		terms[3][0].typ != termSuffix || terms[3][0].inv || len(terms[3][0].text) != 3 ||
+		terms[4][0].typ != termExact || !terms[4][0].inv || len(terms[4][0].text) != 3 ||
+		terms[5][0].typ != termFuzzy || !terms[5][0].inv || len(terms[5][0].text) != 3 ||
+		terms[6][0].typ != termPrefix || !terms[6][0].inv || len(terms[6][0].text) != 3 ||
+		terms[7][0].typ != termSuffix || !terms[7][0].inv || len(terms[7][0].text) != 3 {
+		t.Errorf("%v", terms)
+	}
+}
+
+func TestParseTermsEmpty(t *testing.T) {
+	terms := parseTerms(true, CaseSmart, false, "' ^ !' !^")
+	if len(terms) != 0 {
+		t.Errorf("%v", terms)
+	}
+}
+
+func buildPattern(fuzzy bool, fuzzyAlgo algo.Algo, extended bool, caseMode Case, normalize bool, forward bool,
+	withPos bool, cacheable bool, nth []Range, delimiter Delimiter, runes []rune) *Pattern {
+	return BuildPattern(NewChunkCache(), make(map[string]*Pattern),
+		fuzzy, fuzzyAlgo, extended, caseMode, normalize, forward,
+		withPos, cacheable, nth, delimiter, runes)
+}
+
+func TestExact(t *testing.T) {
+	pattern := buildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true,
+		[]Range{}, Delimiter{}, []rune("'abc"))
+	chars := util.ToChars([]byte("aabbcc abc"))
+	res, pos := algo.ExactMatchNaive(
+		pattern.caseSensitive, pattern.normalize, pattern.forward, &chars, pattern.termSets[0][0].text, true, nil)
+	if res.Start != 7 || res.End != 10 {
+		t.Errorf("%v / %d / %d", pattern.termSets, res.Start, res.End)
+	}
+	if pos != nil {
+		t.Errorf("pos is expected to be nil")
+	}
+}
+
+func TestEqual(t *testing.T) {
+	pattern := buildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("^AbC$"))
+
+	match := func(str string, sidxExpected int, eidxExpected int) {
+		chars := util.ToChars([]byte(str))
+		res, pos := algo.EqualMatch(
+			pattern.caseSensitive, pattern.normalize, pattern.forward, &chars, pattern.termSets[0][0].text, true, nil)
+		if res.Start != sidxExpected || res.End != eidxExpected {
+			t.Errorf("%v / %d / %d", pattern.termSets, res.Start, res.End)
+		}
+		if pos != nil {
+			t.Errorf("pos is expected to be nil")
+		}
+	}
+	match("ABC", -1, -1)
+	match("AbC", 0, 3)
+	match("AbC  ", 0, 3)
+	match(" AbC ", 1, 4)
+	match("  AbC", 2, 5)
+}
+
+func TestCaseSensitivity(t *testing.T) {
+	pat1 := buildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat2 := buildPattern(true, algo.FuzzyMatchV2, false, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat3 := buildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat4 := buildPattern(true, algo.FuzzyMatchV2, false, CaseIgnore, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+	pat5 := buildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("abc"))
+	pat6 := buildPattern(true, algo.FuzzyMatchV2, false, CaseRespect, false, true, false, true, []Range{}, Delimiter{}, []rune("Abc"))
+
+	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
+		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
+		string(pat3.text) != "abc" || pat3.caseSensitive != false ||
+		string(pat4.text) != "abc" || pat4.caseSensitive != false ||
+		string(pat5.text) != "abc" || pat5.caseSensitive != true ||
+		string(pat6.text) != "Abc" || pat6.caseSensitive != true {
+		t.Error("Invalid case conversion")
+	}
+}
+
+func TestOrigTextAndTransformed(t *testing.T) {
+	pattern := buildPattern(true, algo.FuzzyMatchV2, true, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune("jg"))
+	tokens := Tokenize("junegunn", Delimiter{})
+	trans := Transform(tokens, []Range{{1, 1}})
+
+	origBytes := []byte("junegunn.choi")
+	for _, extended := range []bool{false, true} {
+		chunk := Chunk{count: 1}
+		chunk.items[0] = Item{
+			text:        util.ToChars([]byte("junegunn")),
+			origText:    &origBytes,
+			transformed: &trans}
+		pattern.extended = extended
+		matches := pattern.matchChunk(&chunk, nil, slab) // No cache
+		if !(matches[0].item.text.ToString() == "junegunn" &&
+			string(*matches[0].item.origText) == "junegunn.choi" &&
+			reflect.DeepEqual(*matches[0].item.transformed, trans)) {
+			t.Error("Invalid match result", matches)
+		}
+
+		match, offsets, pos := pattern.MatchItem(&chunk.items[0], true, slab)
+		if !(match.item.text.ToString() == "junegunn" &&
+			string(*match.item.origText) == "junegunn.choi" &&
+			offsets[0][0] == 0 && offsets[0][1] == 5 &&
+			reflect.DeepEqual(*match.item.transformed, trans)) {
+			t.Error("Invalid match result", match, offsets, extended)
+		}
+		if !((*pos)[0] == 4 && (*pos)[1] == 0) {
+			t.Error("Invalid pos array", *pos)
+		}
+	}
+}
+
+func TestCacheKey(t *testing.T) {
+	test := func(extended bool, patStr string, expected string, cacheable bool) {
+		pat := buildPattern(true, algo.FuzzyMatchV2, extended, CaseSmart, false, true, false, true, []Range{}, Delimiter{}, []rune(patStr))
+		if pat.CacheKey() != expected {
+			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
+		}
+		if pat.cacheable != cacheable {
+			t.Errorf("Expected: %t, actual: %t (%s)", cacheable, pat.cacheable, patStr)
+		}
+	}
+	test(false, "foo !bar", "foo !bar", true)
+	test(false, "foo | bar !baz", "foo | bar !baz", true)
+	test(true, "foo  bar  baz", "foo\tbar\tbaz", true)
+	test(true, "foo !bar", "foo", false)
+	test(true, "foo !bar   baz", "foo\tbaz", false)
+	test(true, "foo | bar baz", "baz", false)
+	test(true, "foo | bar | baz", "", false)
+	test(true, "foo | bar !baz", "", false)
+	test(true, "| | foo", "", false)
+	test(true, "| | | foo", "foo", false)
+}
+
+func TestCacheable(t *testing.T) {
+	test := func(fuzzy bool, str string, expected string, cacheable bool) {
+		pat := buildPattern(fuzzy, algo.FuzzyMatchV2, true, CaseSmart, true, true, false, true, []Range{}, Delimiter{}, []rune(str))
+		if pat.CacheKey() != expected {
+			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
+		}
+		if cacheable != pat.cacheable {
+			t.Errorf("Invalid Pattern.cacheable for \"%s\": %v (expected: %v)", str, pat.cacheable, cacheable)
+		}
+	}
+	test(true, "foo bar", "foo\tbar", true)
+	test(true, "foo 'bar", "foo\tbar", false)
+	test(true, "foo !bar", "foo", false)
+
+	test(false, "foo bar", "foo\tbar", true)
+	test(false, "foo 'bar", "foo", false)
+	test(false, "foo '", "foo", true)
+	test(false, "foo 'bar", "foo", false)
+	test(false, "foo !bar", "foo", false)
+}

src/protector/protector.go

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

src/protector/protector_openbsd.go

@@ -0,0 +1,10 @@
+//go:build openbsd
+
+package protector
+
+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")
+}

src/proxy.go

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

src/proxy_unix.go

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

src/proxy_windows.go

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

src/reader.go

@@ -0,0 +1,318 @@
+package fzf
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"io/fs"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/charlievieth/fastwalk"
+	"github.com/junegunn/fzf/src/util"
+)
+
+// Reader reads from command or standard input
+type Reader struct {
+	pusher   func([]byte) bool
+	executor *util.Executor
+	eventBox *util.EventBox
+	delimNil bool
+	event    int32
+	finChan  chan bool
+	mutex    sync.Mutex
+	exec     *exec.Cmd
+	execOut  io.ReadCloser
+	command  *string
+	killed   bool
+	wait     bool
+}
+
+// NewReader returns new Reader object
+func NewReader(pusher func([]byte) bool, eventBox *util.EventBox, executor *util.Executor, delimNil bool, wait bool) *Reader {
+	return &Reader{pusher, executor, eventBox, delimNil, int32(EvtReady), make(chan bool, 1), sync.Mutex{}, nil, nil, nil, false, wait}
+}
+
+func (r *Reader) startEventPoller() {
+	go func() {
+		ptr := &r.event
+		pollInterval := readerPollIntervalMin
+		for {
+			if atomic.CompareAndSwapInt32(ptr, int32(EvtReadNew), int32(EvtReady)) {
+				r.eventBox.Set(EvtReadNew, (*string)(nil))
+				pollInterval = readerPollIntervalMin
+			} else if atomic.LoadInt32(ptr) == int32(EvtReadFin) {
+				if r.wait {
+					r.finChan <- true
+				}
+				return
+			} else {
+				pollInterval += readerPollIntervalStep
+				if pollInterval > readerPollIntervalMax {
+					pollInterval = readerPollIntervalMax
+				}
+			}
+			time.Sleep(pollInterval)
+		}
+	}()
+}
+
+func (r *Reader) fin(success bool) {
+	atomic.StoreInt32(&r.event, int32(EvtReadFin))
+	if r.wait {
+		<-r.finChan
+	}
+
+	r.mutex.Lock()
+	ret := r.command
+	if success || r.killed {
+		ret = nil
+	}
+	r.mutex.Unlock()
+
+	r.eventBox.Set(EvtReadFin, ret)
+}
+
+func (r *Reader) terminate() {
+	r.mutex.Lock()
+	r.killed = true
+	if r.exec != nil && r.exec.Process != nil {
+		r.execOut.Close()
+		util.KillCommand(r.exec)
+	} else {
+		os.Stdin.Close()
+	}
+	r.mutex.Unlock()
+}
+
+func (r *Reader) restart(command commandSpec, environ []string) {
+	r.event = int32(EvtReady)
+	r.startEventPoller()
+	success := r.readFromCommand(command.command, environ)
+	r.fin(success)
+	removeFiles(command.tempFiles)
+}
+
+func (r *Reader) readChannel(inputChan chan string) bool {
+	for {
+		item, more := <-inputChan
+		if !more {
+			break
+		}
+		if r.pusher([]byte(item)) {
+			atomic.StoreInt32(&r.event, int32(EvtReadNew))
+		}
+	}
+	return true
+}
+
+// ReadSource reads data from the default command or from standard input
+func (r *Reader) ReadSource(inputChan chan string, root string, opts walkerOpts, ignores []string, initCmd string, initEnv []string) {
+	r.startEventPoller()
+	var success bool
+	if inputChan != nil {
+		success = r.readChannel(inputChan)
+	} else if len(initCmd) > 0 {
+		success = r.readFromCommand(initCmd, initEnv)
+	} else if util.IsTty(os.Stdin) {
+		cmd := os.Getenv("FZF_DEFAULT_COMMAND")
+		if len(cmd) == 0 {
+			success = r.readFiles(root, opts, ignores)
+		} else {
+			success = r.readFromCommand(cmd, initEnv)
+		}
+	} else {
+		success = r.readFromStdin()
+	}
+	r.fin(success)
+}
+
+func (r *Reader) feed(src io.Reader) {
+	/*
+		readerSlabSize, ae := strconv.Atoi(os.Getenv("SLAB_KB"))
+		if ae != nil {
+			readerSlabSize = 128 * 1024
+		} else {
+			readerSlabSize *= 1024
+		}
+		readerBufferSize, be := strconv.Atoi(os.Getenv("BUF_KB"))
+		if be != nil {
+			readerBufferSize = 64 * 1024
+		} else {
+			readerBufferSize *= 1024
+		}
+	*/
+
+	delim := byte('\n')
+	trimCR := util.IsWindows()
+	if r.delimNil {
+		delim = '\000'
+		trimCR = false
+	}
+
+	slab := make([]byte, readerSlabSize)
+	leftover := []byte{}
+	var err error
+	for {
+		n := 0
+		scope := slab[:util.Min(len(slab), readerBufferSize)]
+		for i := 0; i < 100; i++ {
+			n, err = src.Read(scope)
+			if n > 0 || err != nil {
+				break
+			}
+		}
+
+		// We're not making any progress after 100 tries. Stop.
+		if n == 0 {
+			break
+		}
+
+		buf := slab[:n]
+		slab = slab[n:]
+
+		for len(buf) > 0 {
+			if i := bytes.IndexByte(buf, delim); i >= 0 {
+				// Found the delimiter
+				slice := buf[:i+1]
+				buf = buf[i+1:]
+				if trimCR && len(slice) >= 2 && slice[len(slice)-2] == byte('\r') {
+					slice = slice[:len(slice)-2]
+				} else {
+					slice = slice[:len(slice)-1]
+				}
+				if len(leftover) > 0 {
+					slice = append(leftover, slice...)
+					leftover = []byte{}
+				}
+				if (err == nil || len(slice) > 0) && r.pusher(slice) {
+					atomic.StoreInt32(&r.event, int32(EvtReadNew))
+				}
+			} else {
+				// Could not find the delimiter in the buffer
+				//   NOTE: We can further optimize this by keeping track of the cursor
+				//   position in the slab so that a straddling item that doesn't go
+				//   beyond the boundary of a slab doesn't need to be copied to
+				//   another buffer. However, the performance gain is negligible in
+				//   practice (< 0.1%) and is not
+				//   worth the added complexity.
+				leftover = append(leftover, buf...)
+				break
+			}
+		}
+
+		if err == io.EOF {
+			leftover = append(leftover, buf...)
+			break
+		}
+
+		if len(slab) == 0 {
+			slab = make([]byte, readerSlabSize)
+		}
+	}
+	if len(leftover) > 0 && r.pusher(leftover) {
+		atomic.StoreInt32(&r.event, int32(EvtReadNew))
+	}
+}
+
+func (r *Reader) readFromStdin() bool {
+	r.feed(os.Stdin)
+	return true
+}
+
+func isSymlinkToDir(path string, de os.DirEntry) bool {
+	if de.Type()&fs.ModeSymlink == 0 {
+		return false
+	}
+	if s, err := os.Stat(path); err == nil {
+		return s.IsDir()
+	}
+	return false
+}
+
+func trimPath(path string) string {
+	bytes := stringBytes(path)
+
+	for len(bytes) > 1 && bytes[0] == '.' && (bytes[1] == '/' || bytes[1] == '\\') {
+		bytes = bytes[2:]
+	}
+
+	if len(bytes) == 0 {
+		return "."
+	}
+
+	return byteString(bytes)
+}
+
+func (r *Reader) readFiles(root string, opts walkerOpts, ignores []string) bool {
+	r.killed = false
+	conf := fastwalk.Config{
+		Follow: opts.follow,
+		// Use forward slashes when running a Windows binary under WSL or MSYS
+		ToSlash: fastwalk.DefaultToSlash(),
+		Sort:    fastwalk.SortFilesFirst,
+	}
+	fn := func(path string, de os.DirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
+		path = trimPath(path)
+		if path != "." {
+			isDir := de.IsDir()
+			if isDir || opts.follow && isSymlinkToDir(path, de) {
+				base := filepath.Base(path)
+				if !opts.hidden && base[0] == '.' {
+					return filepath.SkipDir
+				}
+				for _, ignore := range ignores {
+					if ignore == base {
+						return filepath.SkipDir
+					}
+				}
+			}
+			if ((opts.file && !isDir) || (opts.dir && isDir)) && r.pusher(stringBytes(path)) {
+				atomic.StoreInt32(&r.event, int32(EvtReadNew))
+			}
+		}
+		r.mutex.Lock()
+		defer r.mutex.Unlock()
+		if r.killed {
+			return context.Canceled
+		}
+		return nil
+	}
+	return fastwalk.Walk(&conf, root, fn) == nil
+}
+
+func (r *Reader) readFromCommand(command string, environ []string) bool {
+	r.mutex.Lock()
+	r.killed = false
+	r.command = &command
+	r.exec = r.executor.ExecCommand(command, true)
+	if environ != nil {
+		r.exec.Env = environ
+	}
+
+	var err error
+	r.execOut, err = r.exec.StdoutPipe()
+	if err != nil {
+		r.exec = nil
+		r.mutex.Unlock()
+		return false
+	}
+
+	err = r.exec.Start()
+	if err != nil {
+		r.exec = nil
+		r.mutex.Unlock()
+		return false
+	}
+
+	r.mutex.Unlock()
+	r.feed(r.execOut)
+	return r.exec.Wait() == nil
+}

src/reader_test.go

@@ -0,0 +1,64 @@
+package fzf
+
+import (
+	"testing"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func TestReadFromCommand(t *testing.T) {
+	strs := []string{}
+	eb := util.NewEventBox()
+	exec := util.NewExecutor("")
+	reader := NewReader(
+		func(s []byte) bool { strs = append(strs, string(s)); return true },
+		eb, exec, false, true)
+
+	reader.startEventPoller()
+
+	// Check EventBox
+	if eb.Peek(EvtReadNew) {
+		t.Error("EvtReadNew should not be set yet")
+	}
+
+	// Normal command
+	reader.fin(reader.readFromCommand(`echo abc&&echo def`, nil))
+	if len(strs) != 2 || strs[0] != "abc" || strs[1] != "def" {
+		t.Errorf("%s", strs)
+	}
+
+	// Check EventBox again
+	eb.WaitFor(EvtReadFin)
+
+	// Wait should return immediately
+	eb.Wait(func(events *util.Events) {
+		events.Clear()
+	})
+
+	// EventBox is cleared
+	if eb.Peek(EvtReadNew) {
+		t.Error("EvtReadNew should not be set yet")
+	}
+
+	// Make sure that event poller is finished
+	time.Sleep(readerPollIntervalMax)
+
+	// Restart event poller
+	reader.startEventPoller()
+
+	// Failing command
+	reader.fin(reader.readFromCommand(`no-such-command`, nil))
+	strs = []string{}
+	if len(strs) > 0 {
+		t.Errorf("%s", strs)
+	}
+
+	// Check EventBox again
+	if eb.Peek(EvtReadNew) {
+		t.Error("Command failed. EvtReadNew should not be set")
+	}
+	if !eb.Peek(EvtReadFin) {
+		t.Error("EvtReadFin should be set")
+	}
+}

src/result.go

@@ -0,0 +1,268 @@
+package fzf
+
+import (
+	"math"
+	"sort"
+	"unicode"
+
+	"github.com/junegunn/fzf/src/tui"
+	"github.com/junegunn/fzf/src/util"
+)
+
+// Offset holds two 32-bit integers denoting the offsets of a matched substring
+type Offset [2]int32
+
+type colorOffset struct {
+	offset [2]int32
+	color  tui.ColorPair
+	match  bool
+	url    *url
+}
+
+type Result struct {
+	item   *Item
+	points [4]uint16
+}
+
+func buildResult(item *Item, offsets []Offset, score int) Result {
+	if len(offsets) > 1 {
+		sort.Sort(ByOrder(offsets))
+	}
+
+	result := Result{item: item}
+	numChars := item.text.Length()
+	minBegin := math.MaxUint16
+	minEnd := math.MaxUint16
+	maxEnd := 0
+	validOffsetFound := false
+	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)
+			validOffsetFound = true
+		}
+	}
+
+	for idx, criterion := range sortCriteria {
+		val := uint16(math.MaxUint16)
+		switch criterion {
+		case byScore:
+			// Higher is better
+			val = math.MaxUint16 - util.AsUint16(score)
+		case byChunk:
+			if validOffsetFound {
+				b := minBegin
+				e := maxEnd
+				for ; b >= 1; b-- {
+					if unicode.IsSpace(item.text.Get(b - 1)) {
+						break
+					}
+				}
+				for ; e < numChars; e++ {
+					if unicode.IsSpace(item.text.Get(e)) {
+						break
+					}
+				}
+				val = util.AsUint16(e - b)
+			}
+		case byLength:
+			val = item.TrimLength()
+		case byBegin, byEnd:
+			if validOffsetFound {
+				whitePrefixLen := 0
+				for idx := 0; idx < numChars; idx++ {
+					r := item.text.Get(idx)
+					whitePrefixLen = idx
+					if idx == minBegin || !unicode.IsSpace(r) {
+						break
+					}
+				}
+				if criterion == byBegin {
+					val = util.AsUint16(minEnd - whitePrefixLen)
+				} else {
+					val = util.AsUint16(math.MaxUint16 - math.MaxUint16*(maxEnd-whitePrefixLen)/(int(item.TrimLength())+1))
+				}
+			}
+		}
+		result.points[3-idx] = val
+	}
+
+	return result
+}
+
+// Sort criteria to use. Never changes once fzf is started.
+var sortCriteria []criterion
+
+// Index returns ordinal index of the Item
+func (result *Result) Index() int32 {
+	return result.item.Index()
+}
+
+func minRank() Result {
+	return Result{item: &minItem, points: [4]uint16{math.MaxUint16, 0, 0, 0}}
+}
+
+func (result *Result) colorOffsets(matchOffsets []Offset, theme *tui.ColorTheme, colBase tui.ColorPair, colMatch tui.ColorPair, current bool) []colorOffset {
+	itemColors := result.item.Colors()
+
+	// No ANSI codes
+	if len(itemColors) == 0 {
+		var offsets []colorOffset
+		for _, off := range matchOffsets {
+			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: colMatch, match: true})
+		}
+		return offsets
+	}
+
+	// Find max column
+	var maxCol int32
+	for _, off := range matchOffsets {
+		if off[1] > maxCol {
+			maxCol = off[1]
+		}
+	}
+	for _, ansi := range itemColors {
+		if ansi.offset[1] > maxCol {
+			maxCol = ansi.offset[1]
+		}
+	}
+
+	cols := make([]int, maxCol)
+	for colorIndex, ansi := range itemColors {
+		for i := ansi.offset[0]; i < ansi.offset[1]; i++ {
+			cols[i] = colorIndex + 1 // 1-based index of itemColors
+		}
+	}
+
+	for _, off := range matchOffsets {
+		for i := off[0]; i < off[1]; i++ {
+			// Negative of 1-based index of itemColors
+			// - The extra -1 means highlighted
+			if cols[i] >= 0 {
+				cols[i] = cols[i]*-1 - 1
+			}
+		}
+	}
+
+	// sort.Sort(ByOrder(offsets))
+
+	// Merge offsets
+	// ------------  ----  --  ----
+	//   ++++++++      ++++++++++
+	// --++++++++--  --++++++++++---
+	curr := 0
+	start := 0
+	ansiToColorPair := func(ansi ansiOffset, base tui.ColorPair) tui.ColorPair {
+		fg := ansi.color.fg
+		bg := ansi.color.bg
+		if fg == -1 {
+			if current {
+				fg = theme.Current.Color
+			} else {
+				fg = theme.Fg.Color
+			}
+		}
+		if bg == -1 {
+			if current {
+				bg = theme.DarkBg.Color
+			} else {
+				bg = theme.Bg.Color
+			}
+		}
+		return tui.NewColorPair(fg, bg, ansi.color.attr).MergeAttr(base)
+	}
+	var colors []colorOffset
+	add := func(idx int) {
+		if curr != 0 && idx > start {
+			if curr < 0 {
+				color := colMatch
+				var url *url
+				if curr < -1 && theme.Colored {
+					ansi := itemColors[-curr-2]
+					url = ansi.color.url
+					origColor := ansiToColorPair(ansi, colMatch)
+					// hl or hl+ only sets the foreground color, so colMatch is the
+					// combination of either [hl and bg] or [hl+ and bg+].
+					//
+					// If the original text already has background color, and the
+					// foreground color of colMatch is -1, we shouldn't only apply the
+					// background color of colMatch.
+					// e.g. echo -e "\x1b[32;7mfoo\x1b[mbar" | fzf --ansi --color bg+:1,hl+:-1:underline
+					//      echo -e "\x1b[42mfoo\x1b[mbar" | fzf --ansi --color bg+:1,hl+:-1:underline
+					if color.Fg().IsDefault() && origColor.HasBg() {
+						color = origColor
+					} else {
+						color = origColor.MergeNonDefault(color)
+					}
+				}
+				colors = append(colors, colorOffset{
+					offset: [2]int32{int32(start), int32(idx)}, color: color, match: true, url: url})
+			} else {
+				ansi := itemColors[curr-1]
+				colors = append(colors, colorOffset{
+					offset: [2]int32{int32(start), int32(idx)},
+					color:  ansiToColorPair(ansi, colBase),
+					match:  false,
+					url:    ansi.color.url})
+			}
+		}
+	}
+	for idx, col := range cols {
+		if col != curr {
+			add(idx)
+			start = idx
+			curr = col
+		}
+	}
+	add(int(maxCol))
+	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])
+}
+
+// ByRelevance is for sorting Items
+type ByRelevance []Result
+
+func (a ByRelevance) Len() int {
+	return len(a)
+}
+
+func (a ByRelevance) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByRelevance) Less(i, j int) bool {
+	return compareRanks(a[i], a[j], false)
+}
+
+// ByRelevanceTac is for sorting Items
+type ByRelevanceTac []Result
+
+func (a ByRelevanceTac) Len() int {
+	return len(a)
+}
+
+func (a ByRelevanceTac) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a ByRelevanceTac) Less(i, j int) bool {
+	return compareRanks(a[i], a[j], true)
+}

src/result_others.go

@@ -0,0 +1,16 @@
+//go:build !386 && !amd64
+
+package fzf
+
+func compareRanks(irank Result, jrank Result, tac bool) bool {
+	for idx := 3; idx >= 0; idx-- {
+		left := irank.points[idx]
+		right := jrank.points[idx]
+		if left < right {
+			return true
+		} else if left > right {
+			return false
+		}
+	}
+	return (irank.item.Index() <= jrank.item.Index()) != tac
+}

src/result_test.go

@@ -0,0 +1,174 @@
+package fzf
+
+import (
+	"math"
+	"sort"
+	"testing"
+
+	"github.com/junegunn/fzf/src/tui"
+	"github.com/junegunn/fzf/src/util"
+)
+
+func withIndex(i *Item, index int) *Item {
+	(*i).text.Index = int32(index)
+	return i
+}
+
+func TestOffsetSort(t *testing.T) {
+	offsets := []Offset{
+		{3, 5}, {2, 7},
+		{1, 3}, {2, 9}}
+	sort.Sort(ByOrder(offsets))
+
+	if offsets[0][0] != 1 || offsets[0][1] != 3 ||
+		offsets[1][0] != 2 || offsets[1][1] != 7 ||
+		offsets[2][0] != 2 || offsets[2][1] != 9 ||
+		offsets[3][0] != 3 || offsets[3][1] != 5 {
+		t.Error("Invalid order:", offsets)
+	}
+}
+
+func TestRankComparison(t *testing.T) {
+	rank := func(vals ...uint16) Result {
+		return Result{
+			points: [4]uint16{vals[0], vals[1], vals[2], vals[3]},
+			item:   &Item{text: util.Chars{Index: int32(vals[4])}}}
+	}
+	if compareRanks(rank(3, 0, 0, 0, 5), rank(2, 0, 0, 0, 7), false) ||
+		!compareRanks(rank(3, 0, 0, 0, 5), rank(3, 0, 0, 0, 6), false) ||
+		!compareRanks(rank(1, 2, 0, 0, 3), rank(1, 3, 0, 0, 2), false) ||
+		!compareRanks(rank(0, 0, 0, 0, 0), rank(0, 0, 0, 0, 0), false) {
+		t.Error("Invalid order")
+	}
+
+	if compareRanks(rank(3, 0, 0, 0, 5), rank(2, 0, 0, 0, 7), true) ||
+		!compareRanks(rank(3, 0, 0, 0, 5), rank(3, 0, 0, 0, 6), false) ||
+		!compareRanks(rank(1, 2, 0, 0, 3), rank(1, 3, 0, 0, 2), true) ||
+		!compareRanks(rank(0, 0, 0, 0, 0), rank(0, 0, 0, 0, 0), false) {
+		t.Error("Invalid order (tac)")
+	}
+}
+
+// Match length, string length, index
+func TestResultRank(t *testing.T) {
+	// FIXME global
+	sortCriteria = []criterion{byScore, byLength}
+
+	str := []rune("foo")
+	item1 := buildResult(
+		withIndex(&Item{text: util.RunesToChars(str)}, 1), []Offset{}, 2)
+	if item1.points[3] != math.MaxUint16-2 || // Bonus
+		item1.points[2] != 3 || // Length
+		item1.points[1] != 0 || // Unused
+		item1.points[0] != 0 || // Unused
+		item1.item.Index() != 1 {
+		t.Error(item1)
+	}
+	// Only differ in index
+	item2 := buildResult(&Item{text: util.RunesToChars(str)}, []Offset{}, 2)
+
+	items := []Result{item1, item2}
+	sort.Sort(ByRelevance(items))
+	if items[0] != item2 || items[1] != item1 {
+		t.Error(items)
+	}
+
+	items = []Result{item2, item1, item1, item2}
+	sort.Sort(ByRelevance(items))
+	if items[0] != item2 || items[1] != item2 ||
+		items[2] != item1 || items[3] != item1 {
+		t.Error(items, item1, item1.item.Index(), item2, item2.item.Index())
+	}
+
+	// Sort by relevance
+	item3 := buildResult(
+		withIndex(&Item{}, 2), []Offset{{1, 3}, {5, 7}}, 3)
+	item4 := buildResult(
+		withIndex(&Item{}, 2), []Offset{{1, 2}, {6, 7}}, 4)
+	item5 := buildResult(
+		withIndex(&Item{}, 2), []Offset{{1, 3}, {5, 7}}, 5)
+	item6 := buildResult(
+		withIndex(&Item{}, 2), []Offset{{1, 2}, {6, 7}}, 6)
+	items = []Result{item1, item2, item3, item4, item5, item6}
+	sort.Sort(ByRelevance(items))
+	if !(items[0] == item6 && items[1] == item5 &&
+		items[2] == item4 && items[3] == item3 &&
+		items[4] == item2 && items[5] == item1) {
+		t.Error(items, item1, item2, item3, item4, item5, item6)
+	}
+}
+
+func TestChunkTiebreak(t *testing.T) {
+	// FIXME global
+	sortCriteria = []criterion{byScore, byChunk}
+
+	score := 100
+	test := func(input string, offset Offset, chunk string) {
+		item := buildResult(withIndex(&Item{text: util.RunesToChars([]rune(input))}, 1), []Offset{offset}, score)
+		if !(item.points[3] == math.MaxUint16-uint16(score) && item.points[2] == uint16(len(chunk))) {
+			t.Error(item.points)
+		}
+	}
+	test("hello foobar goodbye", Offset{8, 9}, "foobar")
+	test("hello foobar goodbye", Offset{7, 18}, "foobar goodbye")
+	test("hello foobar goodbye", Offset{0, 1}, "hello")
+	test("hello foobar goodbye", Offset{5, 7}, "hello foobar") // TBD
+}
+
+func TestColorOffset(t *testing.T) {
+	// ------------ 20 ----  --  ----
+	//   ++++++++        ++++++++++
+	// --++++++++--    --++++++++++---
+
+	offsets := []Offset{{5, 15}, {10, 12}, {25, 35}}
+	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}}}}}
+
+	colBase := tui.NewColorPair(89, 189, tui.AttrUndefined)
+	colMatch := tui.NewColorPair(99, 199, tui.AttrUndefined)
+	colors := item.colorOffsets(offsets, tui.Dark256, colBase, colMatch, true)
+	assert := func(idx int, b int32, e int32, c tui.ColorPair) {
+		o := colors[idx]
+		if o.offset[0] != b || o.offset[1] != e || o.color != c {
+			t.Error(o, b, e, c)
+		}
+	}
+	// [{[0 5] {1 5 0}} {[5 15] {99 199 0}} {[15 20] {1 5 0}}
+	//  {[22 25] {2 6 1}} {[25 27] {99 199 1}} {[27 30] {99 199 0}}
+	//  {[30 32] {99 199 0}} {[32 33] {99 199 0}} {[33 35] {99 199 1}}
+	//  {[35 40] {4 8 1}}]
+	assert(0, 0, 5, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(1, 5, 15, colMatch)
+	assert(2, 15, 20, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(3, 22, 25, tui.NewColorPair(2, 6, tui.Bold))
+	assert(4, 25, 27, colMatch.WithAttr(tui.Bold))
+	assert(5, 27, 30, colMatch)
+	assert(6, 30, 32, colMatch)
+	assert(7, 32, 33, colMatch) // TODO: Should we merge consecutive blocks?
+	assert(8, 33, 35, colMatch.WithAttr(tui.Bold))
+	assert(9, 35, 40, tui.NewColorPair(4, 8, tui.Bold))
+
+	colRegular := tui.NewColorPair(-1, -1, tui.AttrUndefined)
+	colUnderline := tui.NewColorPair(-1, -1, tui.Underline)
+	colors = item.colorOffsets(offsets, tui.Dark256, colRegular, colUnderline, true)
+
+	// [{[0 5] {1 5 0}} {[5 15] {1 5 8}} {[15 20] {1 5 0}}
+	//  {[22 25] {2 6 1}} {[25 27] {2 6 9}} {[27 30] {-1 -1 8}}
+	//  {[30 32] {3 7 8}} {[32 33] {-1 -1 8}} {[33 35] {4 8 9}}
+	//  {[35 40] {4 8 1}}]
+	assert(0, 0, 5, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(1, 5, 15, tui.NewColorPair(1, 5, tui.Underline))
+	assert(2, 15, 20, tui.NewColorPair(1, 5, tui.AttrUndefined))
+	assert(3, 22, 25, tui.NewColorPair(2, 6, tui.Bold))
+	assert(4, 25, 27, tui.NewColorPair(2, 6, tui.Bold|tui.Underline))
+	assert(5, 27, 30, colUnderline)
+	assert(6, 30, 32, tui.NewColorPair(3, 7, tui.Underline))
+	assert(7, 32, 33, colUnderline)
+	assert(8, 33, 35, tui.NewColorPair(4, 8, tui.Bold|tui.Underline))
+	assert(9, 35, 40, tui.NewColorPair(4, 8, tui.Bold))
+}

src/result_x86.go

@@ -0,0 +1,16 @@
+//go:build 386 || amd64
+
+package fzf
+
+import "unsafe"
+
+func compareRanks(irank Result, jrank Result, tac bool) bool {
+	left := *(*uint64)(unsafe.Pointer(&irank.points[0]))
+	right := *(*uint64)(unsafe.Pointer(&jrank.points[0]))
+	if left < right {
+		return true
+	} else if left > right {
+		return false
+	}
+	return (irank.item.Index() <= jrank.item.Index()) != tac
+}

src/server.go

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

src/terminal_test.go

@@ -0,0 +1,659 @@
+package fzf
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+	"text/template"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+func replacePlaceholderTest(template string, stripAnsi bool, delimiter Delimiter, printsep string, forcePlus bool, query string, allItems []*Item) string {
+	replaced, _ := replacePlaceholder(replacePlaceholderParams{
+		template:   template,
+		stripAnsi:  stripAnsi,
+		delimiter:  delimiter,
+		printsep:   printsep,
+		forcePlus:  forcePlus,
+		query:      query,
+		allItems:   allItems,
+		lastAction: actBackwardDeleteCharEof,
+		prompt:     "prompt",
+		executor:   util.NewExecutor(""),
+	})
+	return replaced
+}
+
+func TestReplacePlaceholder(t *testing.T) {
+	item1 := newItem("  foo'bar \x1b[31mbaz\x1b[m")
+	items1 := []*Item{item1, item1}
+	items2 := []*Item{
+		newItem("foo'bar \x1b[31mbaz\x1b[m"),
+		newItem("foo'bar \x1b[31mbaz\x1b[m"),
+		newItem("FOO'BAR \x1b[31mBAZ\x1b[m")}
+
+	delim := "'"
+	var regex *regexp.Regexp
+
+	var result string
+	check := func(expected string) {
+		if result != expected {
+			t.Errorf("expected: %s, actual: %s", expected, result)
+		}
+	}
+	// helper function that converts template format into string and carries out the check()
+	checkFormat := func(format string) {
+		type quotes struct{ O, I, S string } // outer, inner quotes, print separator
+		unixStyle := quotes{`'`, `'\''`, "\n"}
+		windowsStyle := quotes{`^"`, `'`, "\n"}
+		var effectiveStyle quotes
+
+		if util.IsWindows() {
+			effectiveStyle = windowsStyle
+		} else {
+			effectiveStyle = unixStyle
+		}
+
+		expected := templateToString(format, effectiveStyle)
+		check(expected)
+	}
+	printsep := "\n"
+
+	/*
+		Test multiple placeholders and the function parameters.
+	*/
+
+	// {}, preserve ansi
+	result = replacePlaceholderTest("echo {}", false, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar \x1b[31mbaz\x1b[m{{.O}}")
+
+	// {}, strip ansi
+	result = replacePlaceholderTest("echo {}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
+
+	// {}, with multiple items
+	result = replacePlaceholderTest("echo {}", true, Delimiter{}, printsep, false, "query", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}")
+
+	// {..}, strip leading whitespaces, preserve ansi
+	result = replacePlaceholderTest("echo {..}", false, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}foo{{.I}}bar \x1b[31mbaz\x1b[m{{.O}}")
+
+	// {..}, strip leading whitespaces, strip ansi
+	result = replacePlaceholderTest("echo {..}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}")
+
+	// {q}
+	result = replacePlaceholderTest("echo {} {q}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}} {{.O}}query{{.O}}")
+
+	// {q}, multiple items
+	result = replacePlaceholderTest("echo {+}{q}{+}", true, Delimiter{}, printsep, false, "query 'string'", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}{{.O}}query {{.I}}string{{.I}}{{.O}}{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}")
+
+	result = replacePlaceholderTest("echo {}{q}{}", true, Delimiter{}, printsep, false, "query 'string'", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar baz{{.O}}{{.O}}query {{.I}}string{{.I}}{{.O}}{{.O}}foo{{.I}}bar baz{{.O}}")
+
+	result = replacePlaceholderTest("echo {1}/{2}/{2,1}/{-1}/{-2}/{}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}bazfoo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}foo{{.I}}bar{{.O}}/{{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}}")
+
+	result = replacePlaceholderTest("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, false, "query", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}}/{{.O}}baz{{.O}}/{{.O}}baz{{.O}}/{{.O}}foo{{.I}}bar{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}}")
+
+	result = replacePlaceholderTest("echo {+1}/{+2}/{+-1}/{+-2}/{+..}/{n.t}/\\{}/\\{1}/\\{q}/{+3}", true, Delimiter{}, printsep, false, "query", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}} {{.O}}{{.O}}")
+
+	// forcePlus
+	result = replacePlaceholderTest("echo {1}/{2}/{-1}/{-2}/{..}/{n.t}/\\{}/\\{1}/\\{q}/{3}", true, Delimiter{}, printsep, true, "query", items2)
+	checkFormat("echo {{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}baz{{.O}} {{.O}}BAZ{{.O}}/{{.O}}foo{{.I}}bar{{.O}} {{.O}}FOO{{.I}}BAR{{.O}}/{{.O}}foo{{.I}}bar baz{{.O}} {{.O}}FOO{{.I}}BAR BAZ{{.O}}/{n.t}/{}/{1}/{q}/{{.O}}{{.O}} {{.O}}{{.O}}")
+
+	// Whitespace preserving flag with "'" delimiter
+	result = replacePlaceholderTest("echo {s1}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.O}}")
+
+	result = replacePlaceholderTest("echo {s2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}bar baz{{.O}}")
+
+	result = replacePlaceholderTest("echo {s}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
+
+	result = replacePlaceholderTest("echo {s..}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}")
+
+	// Whitespace preserving flag with regex delimiter
+	regex = regexp.MustCompile(`\w+`)
+
+	result = replacePlaceholderTest("echo {s1}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  {{.O}}")
+
+	result = replacePlaceholderTest("echo {s2}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}{{.I}}{{.O}}")
+
+	result = replacePlaceholderTest("echo {s3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}} {{.O}}")
+
+	// No match
+	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, nil})
+	check("echo /")
+
+	// No match, but with selections
+	result = replacePlaceholderTest("echo {}/{+}", true, Delimiter{}, printsep, false, "query", []*Item{nil, item1})
+	checkFormat("echo /{{.O}}  foo{{.I}}bar baz{{.O}}")
+
+	// String delimiter
+	result = replacePlaceholderTest("echo {}/{1}/{2}", true, Delimiter{str: &delim}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}foo{{.O}}/{{.O}}bar baz{{.O}}")
+
+	// Regex delimiter
+	regex = regexp.MustCompile("[oa]+")
+	// foo'bar baz
+	result = replacePlaceholderTest("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
+	checkFormat("echo {{.O}}  foo{{.I}}bar baz{{.O}}/{{.O}}f{{.O}}/{{.O}}r b{{.O}}/{{.O}}{{.I}}bar b{{.O}}")
+
+	/*
+		Test single placeholders, but focus on the placeholders' parameters (e.g. flags).
+		see: TestParsePlaceholder
+	*/
+	items3 := []*Item{
+		// single line
+		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"),
+	}
+	stripAnsi := false
+	forcePlus := false
+	query := "sample query"
+
+	templateToOutput := make(map[string]string)
+	templateToFile := make(map[string]string) // same as above, but the file contents will be matched
+	// I. item type placeholder
+	templateToOutput[`{}`] = `{{.O}}1a 1b 1c 1d 1e 1f{{.O}}`
+	templateToOutput[`{+}`] = `{{.O}}1a 1b 1c 1d 1e 1f{{.O}} {{.O}}2a 2b 2c 2d 2e 2f{{.O}} {{.O}}3a 3b 3c 3d 3e 3f{{.O}} {{.O}}4a 4b 4c 4d 4e 4f{{.O}} {{.O}}5a 5b 5c 5d 5e 5f{{.O}} {{.O}}6a 6b 6c 6d 6e 6f{{.O}} {{.O}}7a 7b 7c 7d 7e 7f{{.O}}`
+	templateToOutput[`{n}`] = `0`
+	templateToOutput[`{+n}`] = `0 0 0 0 0 0 0`
+	templateToFile[`{f}`] = `1a 1b 1c 1d 1e 1f{{.S}}`
+	templateToFile[`{+f}`] = `1a 1b 1c 1d 1e 1f{{.S}}2a 2b 2c 2d 2e 2f{{.S}}3a 3b 3c 3d 3e 3f{{.S}}4a 4b 4c 4d 4e 4f{{.S}}5a 5b 5c 5d 5e 5f{{.S}}6a 6b 6c 6d 6e 6f{{.S}}7a 7b 7c 7d 7e 7f{{.S}}`
+	templateToFile[`{nf}`] = `0{{.S}}`
+	templateToFile[`{+nf}`] = `0{{.S}}0{{.S}}0{{.S}}0{{.S}}0{{.S}}0{{.S}}0{{.S}}`
+
+	// II. token type placeholders
+	templateToOutput[`{..}`] = templateToOutput[`{}`]
+	templateToOutput[`{1..}`] = templateToOutput[`{}`]
+	templateToOutput[`{..2}`] = `{{.O}}1a 1b{{.O}}`
+	templateToOutput[`{1..2}`] = templateToOutput[`{..2}`]
+	templateToOutput[`{-2..-1}`] = `{{.O}}1e 1f{{.O}}`
+	// shorthand for x..x range
+	templateToOutput[`{1}`] = `{{.O}}1a{{.O}}`
+	templateToOutput[`{1..1}`] = templateToOutput[`{1}`]
+	templateToOutput[`{-6}`] = templateToOutput[`{1}`]
+	// multiple ranges
+	templateToOutput[`{1,2}`] = templateToOutput[`{1..2}`]
+	templateToOutput[`{1,2,4}`] = `{{.O}}1a 1b 1d{{.O}}`
+	templateToOutput[`{1,2..4}`] = `{{.O}}1a 1b 1c 1d{{.O}}`
+	templateToOutput[`{1..2,-4..-3}`] = `{{.O}}1a 1b 1c 1d{{.O}}`
+	// flags
+	templateToOutput[`{+1}`] = `{{.O}}1a{{.O}} {{.O}}2a{{.O}} {{.O}}3a{{.O}} {{.O}}4a{{.O}} {{.O}}5a{{.O}} {{.O}}6a{{.O}} {{.O}}7a{{.O}}`
+	templateToOutput[`{+-1}`] = `{{.O}}1f{{.O}} {{.O}}2f{{.O}} {{.O}}3f{{.O}} {{.O}}4f{{.O}} {{.O}}5f{{.O}} {{.O}}6f{{.O}} {{.O}}7f{{.O}}`
+	templateToOutput[`{s1}`] = `{{.O}}1a {{.O}}`
+	templateToFile[`{f1}`] = `1a{{.S}}`
+	templateToOutput[`{+s1..2}`] = `{{.O}}1a 1b {{.O}} {{.O}}2a 2b {{.O}} {{.O}}3a 3b {{.O}} {{.O}}4a 4b {{.O}} {{.O}}5a 5b {{.O}} {{.O}}6a 6b {{.O}} {{.O}}7a 7b {{.O}}`
+	templateToFile[`{+sf1..2}`] = `1a 1b {{.S}}2a 2b {{.S}}3a 3b {{.S}}4a 4b {{.S}}5a 5b {{.S}}6a 6b {{.S}}7a 7b {{.S}}`
+
+	// 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
+	templateToOutput[`{q}`] = "{{.O}}" + query + "{{.O}}"
+	templateToOutput[`{fzf:query}`] = "{{.O}}" + query + "{{.O}}"
+	templateToOutput[`{fzf:action} {fzf:prompt}`] = "backward-delete-char-eof 'prompt'"
+
+	// IV. escaping placeholder
+	templateToOutput[`\{}`] = `{}`
+	templateToOutput[`\{q}`] = `{q}`
+	templateToOutput[`\{fzf:query}`] = `{fzf:query}`
+	templateToOutput[`\{fzf:action}`] = `{fzf:action}`
+	templateToOutput[`\{++}`] = `{++}`
+	templateToOutput[`{++}`] = templateToOutput[`{+}`]
+
+	for giveTemplate, wantOutput := range templateToOutput {
+		result = replacePlaceholderTest(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
+		checkFormat(wantOutput)
+	}
+	for giveTemplate, wantOutput := range templateToFile {
+		path := replacePlaceholderTest(giveTemplate, stripAnsi, Delimiter{}, printsep, forcePlus, query, items3)
+
+		data, err := readFile(path)
+		if err != nil {
+			t.Errorf("Cannot read the content of the temp file %s.", path)
+		}
+		result = string(data)
+
+		checkFormat(wantOutput)
+	}
+}
+
+func TestQuoteEntry(t *testing.T) {
+	type quotes struct{ E, O, SQ, DQ, BS string } // standalone escape, outer, single and double quotes, backslash
+	unixStyle := quotes{``, `'`, `'\''`, `"`, `\`}
+	windowsStyle := quotes{`^`, `^"`, `'`, `\^"`, `\\`}
+	var effectiveStyle quotes
+	exec := util.NewExecutor("")
+
+	if util.IsWindows() {
+		effectiveStyle = windowsStyle
+	} else {
+		effectiveStyle = unixStyle
+	}
+
+	tests := map[string]string{
+		`'`:     `{{.O}}{{.SQ}}{{.O}}`,
+		`"`:     `{{.O}}{{.DQ}}{{.O}}`,
+		`\`:     `{{.O}}{{.BS}}{{.O}}`,
+		`\"`:    `{{.O}}{{.BS}}{{.DQ}}{{.O}}`,
+		`"\\\"`: `{{.O}}{{.DQ}}{{.BS}}{{.BS}}{{.BS}}{{.DQ}}{{.O}}`,
+
+		`$`:       `{{.O}}${{.O}}`,
+		`$HOME`:   `{{.O}}$HOME{{.O}}`,
+		`'$HOME'`: `{{.O}}{{.SQ}}$HOME{{.SQ}}{{.O}}`,
+
+		`&`:                       `{{.O}}{{.E}}&{{.O}}`,
+		`|`:                       `{{.O}}{{.E}}|{{.O}}`,
+		`<`:                       `{{.O}}{{.E}}<{{.O}}`,
+		`>`:                       `{{.O}}{{.E}}>{{.O}}`,
+		`(`:                       `{{.O}}{{.E}}({{.O}}`,
+		`)`:                       `{{.O}}{{.E}}){{.O}}`,
+		`@`:                       `{{.O}}{{.E}}@{{.O}}`,
+		`^`:                       `{{.O}}{{.E}}^{{.O}}`,
+		`%`:                       `{{.O}}{{.E}}%{{.O}}`,
+		`!`:                       `{{.O}}{{.E}}!{{.O}}`,
+		`%USERPROFILE%`:           `{{.O}}{{.E}}%USERPROFILE{{.E}}%{{.O}}`,
+		`C:\Program Files (x86)\`: `{{.O}}C:{{.BS}}Program Files {{.E}}(x86{{.E}}){{.BS}}{{.O}}`,
+		`"C:\Program Files"`:      `{{.O}}{{.DQ}}C:{{.BS}}Program Files{{.DQ}}{{.O}}`,
+	}
+
+	for input, expected := range tests {
+		escaped := exec.QuoteEntry(input)
+		expected = templateToString(expected, effectiveStyle)
+		if escaped != expected {
+			t.Errorf("Input: %s, expected: %s, actual %s", input, expected, escaped)
+		}
+	}
+}
+
+// purpose of this test is to demonstrate some shortcomings of fzf's templating system on Unix
+func TestUnixCommands(t *testing.T) {
+	if util.IsWindows() {
+		t.SkipNow()
+	}
+	tests := []testCase{
+		// reference: give{template, query, items}, want{output OR match}
+
+		// 1) working examples
+
+		// paths that does not have to evaluated will work fine, when quoted
+		{give{`grep foo {}`, ``, newItems(`test`)}, want{output: `grep foo 'test'`}},
+		{give{`grep foo {}`, ``, newItems(`/home/user/test`)}, want{output: `grep foo '/home/user/test'`}},
+		{give{`grep foo {}`, ``, newItems(`./test`)}, want{output: `grep foo './test'`}},
+
+		// only placeholders are escaped as data, this will lookup tilde character in a test file in your home directory
+		// quoting the tilde is required (to be treated as string)
+		{give{`grep {} ~/test`, ``, newItems(`~`)}, want{output: `grep '~' ~/test`}},
+
+		// 2) problematic examples
+		// (not necessarily unexpected)
+
+		// paths that need to expand some part of it won't work (special characters and variables)
+		{give{`cat {}`, ``, newItems(`~/test`)}, want{output: `cat '~/test'`}},
+		{give{`cat {}`, ``, newItems(`$HOME/test`)}, want{output: `cat '$HOME/test'`}},
+	}
+	testCommands(t, tests)
+}
+
+// purpose of this test is to demonstrate some shortcomings of fzf's templating system on Windows
+func TestWindowsCommands(t *testing.T) {
+	// XXX Deprecated
+	t.SkipNow()
+
+	tests := []testCase{
+		// reference: give{template, query, items}, want{output OR match}
+
+		// 1) working examples
+
+		// example of redundantly escaped backslash in the output, besides looking bit ugly, it won't cause any issue
+		{give{`type {}`, ``, newItems(`C:\test.txt`)}, want{output: `type ^"C:\\test.txt^"`}},
+		{give{`rg -- "package" {}`, ``, newItems(`.\test.go`)}, want{output: `rg -- "package" ^".\\test.go^"`}},
+		// example of mandatorily escaped backslash in the output, otherwise `rg -- "C:\test.txt"` is matching for tabulator
+		{give{`rg -- {}`, ``, newItems(`C:\test.txt`)}, want{output: `rg -- ^"C:\\test.txt^"`}},
+		// example of mandatorily escaped double quote in the output, otherwise `rg -- ""C:\\test.txt""` is not matching for the double quotes around the path
+		{give{`rg -- {}`, ``, newItems(`"C:\test.txt"`)}, want{output: `rg -- ^"\^"C:\\test.txt\^"^"`}},
+
+		// 2) problematic examples
+		// (not necessarily unexpected)
+
+		// notepad++'s parser can't handle `-n"12"` generate by fzf, expects `-n12`
+		{give{`notepad++ -n{1} {2}`, ``, newItems(`12	C:\Work\Test Folder\File.txt`)}, want{output: `notepad++ -n^"12^" ^"C:\\Work\\Test Folder\\File.txt^"`}},
+
+		// cat is parsing `\"` as a part of the file path, double quote is illegal character for paths on Windows
+		// cat: "C:\\test.txt: Invalid argument
+		{give{`cat {}`, ``, newItems(`"C:\test.txt"`)}, want{output: `cat ^"\^"C:\\test.txt\^"^"`}},
+		// cat: "C:\\test.txt": Invalid argument
+		{give{`cmd /c {}`, ``, newItems(`cat "C:\test.txt"`)}, want{output: `cmd /c ^"cat \^"C:\\test.txt\^"^"`}},
+
+		// the "file" flag in the pattern won't create *.bat or *.cmd file so the command in the output tries to edit the file, instead of executing it
+		// the temp file contains: `cat "C:\test.txt"`
+		// TODO this should actually work
+		{give{`cmd /c {f}`, ``, newItems(`cat "C:\test.txt"`)}, want{match: `^cmd /c .*\fzf-preview-[0-9]{9}$`}},
+	}
+	testCommands(t, tests)
+}
+
+// purpose of this test is to demonstrate some shortcomings of fzf's templating system on Windows in Powershell
+func TestPowershellCommands(t *testing.T) {
+	if !util.IsWindows() {
+		t.SkipNow()
+	}
+
+	tests := []testCase{
+		// reference: give{template, query, items}, want{output OR match}
+
+		/*
+			You can read each line in the following table as a pipeline that
+			consist of series of parsers that act upon your input (col. 1) and
+			each cell represents the output value.
+
+			For example:
+			 - exec.Command("program.exe", `\''`)
+			   - goes to win32 api which will process it transparently as it contains no special characters, see [CommandLineToArgvW][].
+			     - powershell command will receive it as is, that is two arguments: a literal backslash and empty string in single quotes
+			     - native command run via/from powershell will receive only one argument: a literal backslash. Because extra parsing rules apply, see [NativeCallsFromPowershell][].
+			       - some¹ apps have internal parser, that requires one more level of escaping (yes, this is completely application-specific, but see terminal_test.go#TestWindowsCommands)
+
+			Character⁰   CommandLineToArgvW   Powershell commands              Native commands from Powershell   Apps requiring escapes¹    | Being tested below
+			----------   ------------------   ------------------------------   -------------------------------   -------------------------- | ------------------
+			"            empty string²        missing argument error           ...                               ...                        |
+			\"           literal "            unbalanced quote error           ...                               ...                        |
+			'\"'         literal '"'          literal "                        empty string                      empty string (match all)   | yes
+			'\\\"'       literal '\"'         literal \"                       literal "                         literal "                  |
+			----------   ------------------   ------------------------------   -------------------------------   -------------------------- | ------------------
+			\            transparent          transparent                      transparent                       regex error                |
+			'\'          transparent          literal \                        literal \                         regex error                | yes
+			\\           transparent          transparent                      transparent                       literal \                  |
+			'\\'         transparent          literal \\                       literal \\                        literal \                  |
+			----------   ------------------   ------------------------------   -------------------------------   -------------------------- | ------------------
+			'            transparent          unbalanced quote error           ...                               ...                        |
+			\'           transparent          literal \ and unb. quote error   ...                               ...                        |
+			\''          transparent          literal \ and empty string       literal \                         regex error                | no, but given as example above
+			'''          transparent          unbalanced quote error           ...                               ...                        |
+			''''         transparent          literal '                        literal '                         literal '                  | yes
+			----------   ------------------   ------------------------------   -------------------------------   -------------------------- | ------------------
+
+			⁰: charatecter or characters 'x' as an argument to a program in go's call: exec.Command("program.exe", `x`)
+			¹: native commands like grep, git grep, ripgrep
+			²: interpreted as a grouping quote, affects argument parser and gets removed from the result
+
+			[CommandLineToArgvW]: https://docs.microsoft.com/en-gb/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw#remarks
+			[NativeCallsFromPowershell]: https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_parsing?view=powershell-7.1#passing-arguments-that-contain-quote-characters
+		*/
+
+		// 1) working examples
+
+		{give{`Get-Content {}`, ``, newItems(`C:\test.txt`)}, want{output: `Get-Content 'C:\test.txt'`}},
+		{give{`rg -- "package" {}`, ``, newItems(`.\test.go`)}, want{output: `rg -- "package" '.\test.go'`}},
+
+		// example of escaping single quotes
+		{give{`rg -- {}`, ``, newItems(`'foobar'`)}, want{output: `rg -- '''foobar'''`}},
+
+		// chaining powershells
+		{give{`powershell -NoProfile -Command {}`, ``, newItems(`cat "C:\test.txt"`)}, want{output: `powershell -NoProfile -Command 'cat \"C:\test.txt\"'`}},
+
+		// 2) problematic examples
+		// (not necessarily unexpected)
+
+		// looking for a path string will only work with escaped backslashes
+		{give{`rg -- {}`, ``, newItems(`C:\test.txt`)}, want{output: `rg -- 'C:\test.txt'`}},
+		// looking for a literal double quote will only work with triple escaped double quotes
+		{give{`rg -- {}`, ``, newItems(`"C:\test.txt"`)}, want{output: `rg -- '\"C:\test.txt\"'`}},
+
+		// Get-Content (i.e. cat alias) is parsing `"` as a part of the file path, returns an error:
+		// Get-Content : Cannot find drive. A drive with the name '"C:' does not exist.
+		{give{`cat {}`, ``, newItems(`"C:\test.txt"`)}, want{output: `cat '\"C:\test.txt\"'`}},
+
+		// the "file" flag in the pattern won't create *.ps1 file so the powershell will offload this "unknown" filetype
+		// to explorer, which will prompt user to pick editing program for the fzf-preview file
+		// the temp file contains: `cat "C:\test.txt"`
+		// TODO this should actually work
+		{give{`powershell -NoProfile -Command {f}`, ``, newItems(`cat "C:\test.txt"`)}, want{match: `^powershell -NoProfile -Command .*\fzf-preview-[0-9]{9}$`}},
+	}
+
+	// to force powershell-style escaping we temporarily set environment variable that fzf honors
+	shellBackup := os.Getenv("SHELL")
+	os.Setenv("SHELL", "powershell")
+	testCommands(t, tests)
+	os.Setenv("SHELL", shellBackup)
+}
+
+/*
+Test typical valid placeholders and parsing of them.
+
+Also since the parser assumes the input is matched with `placeholder` regex,
+the regex is tested here as well.
+*/
+func TestParsePlaceholder(t *testing.T) {
+	// give, want pairs
+	templates := map[string]string{
+		// I. item type placeholder
+		`{}`:    `{}`,
+		`{+}`:   `{+}`,
+		`{n}`:   `{n}`,
+		`{+n}`:  `{+n}`,
+		`{f}`:   `{f}`,
+		`{+nf}`: `{+nf}`,
+
+		// II. token type placeholders
+		`{..}`:     `{..}`,
+		`{1..}`:    `{1..}`,
+		`{..2}`:    `{..2}`,
+		`{1..2}`:   `{1..2}`,
+		`{-2..-1}`: `{-2..-1}`,
+		// shorthand for x..x range
+		`{1}`:    `{1}`,
+		`{1..1}`: `{1..1}`,
+		`{-6}`:   `{-6}`,
+		// multiple ranges
+		`{1,2}`:         `{1,2}`,
+		`{1,2,4}`:       `{1,2,4}`,
+		`{1,2..4}`:      `{1,2..4}`,
+		`{1..2,-4..-3}`: `{1..2,-4..-3}`,
+		// flags
+		`{+1}`:      `{+1}`,
+		`{+-1}`:     `{+-1}`,
+		`{s1}`:      `{s1}`,
+		`{f1}`:      `{f1}`,
+		`{+s1..2}`:  `{+s1..2}`,
+		`{+sf1..2}`: `{+sf1..2}`,
+
+		// 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}`,
+
+		// IV. escaping placeholder
+		`\{}`:   `{}`,
+		`\{++}`: `{++}`,
+		`{++}`:  `{+}`,
+	}
+
+	for giveTemplate, wantTemplate := range templates {
+		if !placeholder.MatchString(giveTemplate) {
+			t.Errorf(`given placeholder %s does not match placeholder regex, so attempt to parse it is unexpected`, giveTemplate)
+			continue
+		}
+
+		_, placeholderWithoutFlags, flags := parsePlaceholder(giveTemplate)
+		gotTemplate := placeholderWithoutFlags[:1] + flags.encodePlaceholder() + placeholderWithoutFlags[1:]
+
+		if gotTemplate != wantTemplate {
+			t.Errorf(`parsed placeholder "%s" into "%s", but want "%s"`, giveTemplate, gotTemplate, wantTemplate)
+		}
+	}
+}
+
+/* utilities section */
+
+// Item represents one line in fzf UI. Usually it is relative path to files and folders.
+func newItem(str string) *Item {
+	bytes := []byte(str)
+	trimmed, _, _ := extractColor(str, nil, nil)
+	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))
+	for i, s := range str {
+		result[i] = newItem(s)
+	}
+	return result
+}
+
+// (for logging purposes)
+func (item *Item) String() string {
+	return item.AsString(true)
+}
+
+// Helper function to parse, execute and convert "text/template" to string. Panics on error.
+func templateToString(format string, data interface{}) string {
+	bb := &bytes.Buffer{}
+
+	err := template.Must(template.New("").Parse(format)).Execute(bb, data)
+	if err != nil {
+		panic(err)
+	}
+
+	return bb.String()
+}
+
+// ad hoc types for test cases
+type give struct {
+	template string
+	query    string
+	allItems []*Item
+}
+type want struct {
+	/*
+		Unix:
+		The `want.output` string is supposed to be formatted for evaluation by
+		`sh -c command` system call.
+
+		Windows:
+		The `want.output` string is supposed to be formatted for evaluation by
+		`cmd.exe /s /c "command"` system call. The `/s` switch enables so called old
+		behaviour, which is more favourable for nesting (possibly escaped)
+		special characters. This is the relevant section of `help cmd`:
+
+		...old behavior is to see if the first character is
+		a quote character and if so, strip the leading character and
+		remove the last quote character on the command line, preserving
+		any text after the last quote character.
+	*/
+	output string // literal output
+	match  string // output is matched against this regex (when output is empty string)
+}
+type testCase struct {
+	give
+	want
+}
+
+func testCommands(t *testing.T, tests []testCase) {
+	// common test parameters
+	delim := "\t"
+	delimiter := Delimiter{str: &delim}
+	printsep := ""
+	stripAnsi := false
+	forcePlus := false
+
+	// evaluate the test cases
+	for idx, test := range tests {
+		gotOutput := replacePlaceholderTest(
+			test.give.template, stripAnsi, delimiter, printsep, forcePlus,
+			test.give.query,
+			test.give.allItems)
+		switch {
+		case test.want.output != "":
+			if gotOutput != test.want.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)
+			}
+		case test.want.match != "":
+			wantMatch := strings.ReplaceAll(test.want.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)
+			}
+		default:
+			t.Errorf("tests[%v]: test case does not describe 'want' property", idx)
+		}
+	}
+}
+
+// naive encoder of placeholder flags
+func (flags placeholderFlags) encodePlaceholder() string {
+	encoded := ""
+	if flags.plus {
+		encoded += "+"
+	}
+	if flags.preserveSpace {
+		encoded += "s"
+	}
+	if flags.number {
+		encoded += "n"
+	}
+	if flags.file {
+		encoded += "f"
+	}
+	if flags.forceUpdate { // FIXME
+		encoded += "q"
+	}
+	return encoded
+}
+
+// can be replaced with os.ReadFile() in go 1.16+
+func readFile(path string) ([]byte, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	data := make([]byte, 0, 128)
+	for {
+		if len(data) >= cap(data) {
+			d := append(data[:cap(data)], 0)
+			data = d[:len(data)]
+		}
+
+		n, err := file.Read(data[len(data):cap(data)])
+		data = data[:len(data)+n]
+		if err != nil {
+			if err == io.EOF {
+				err = nil
+			}
+			return data, err
+		}
+	}
+}

src/terminal_unix.go

@@ -0,0 +1,24 @@
+//go:build !windows
+
+package fzf
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+func notifyOnResize(resizeChan chan<- os.Signal) {
+	signal.Notify(resizeChan, syscall.SIGWINCH)
+}
+
+func notifyStop(p *os.Process) {
+	pid := p.Pid
+	pgid, err := unix.Getpgid(pid)
+	if err == nil {
+		pid = pgid * -1
+	}
+	unix.Kill(pid, syscall.SIGTSTP)
+}

src/terminal_windows.go

@@ -0,0 +1,15 @@
+//go:build windows
+
+package fzf
+
+import (
+	"os"
+)
+
+func notifyOnResize(resizeChan chan<- os.Signal) {
+	// TODO
+}
+
+func notifyStop(p *os.Process) {
+	// NOOP
+}

src/tmux.go

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

src/tokenizer.go

@@ -0,0 +1,253 @@
+package fzf
+
+import (
+	"bytes"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/junegunn/fzf/src/util"
+)
+
+const rangeEllipsis = 0
+
+// Range represents nth-expression
+type Range struct {
+	begin int
+	end   int
+}
+
+// Token contains the tokenized part of the strings and its prefix length
+type Token struct {
+	text         *util.Chars
+	prefixLength int32
+}
+
+// String returns the string representation of a Token.
+func (t Token) String() string {
+	return fmt.Sprintf("Token{text: %s, prefixLength: %d}", t.text, t.prefixLength)
+}
+
+// Delimiter for tokenizing the input
+type Delimiter struct {
+	regex *regexp.Regexp
+	str   *string
+}
+
+// String returns the string representation of a Delimiter.
+func (d Delimiter) String() string {
+	return fmt.Sprintf("Delimiter{regex: %v, str: &%q}", d.regex, *d.str)
+}
+
+func newRange(begin int, end int) Range {
+	if begin == 1 {
+		begin = rangeEllipsis
+	}
+	if end == -1 {
+		end = rangeEllipsis
+	}
+	return Range{begin, end}
+}
+
+// ParseRange parses nth-expression and returns the corresponding Range object
+func ParseRange(str *string) (Range, bool) {
+	if (*str) == ".." {
+		return newRange(rangeEllipsis, rangeEllipsis), true
+	} else if strings.HasPrefix(*str, "..") {
+		end, err := strconv.Atoi((*str)[2:])
+		if err != nil || end == 0 {
+			return Range{}, false
+		}
+		return newRange(rangeEllipsis, end), true
+	} else if strings.HasSuffix(*str, "..") {
+		begin, err := strconv.Atoi((*str)[:len(*str)-2])
+		if err != nil || begin == 0 {
+			return Range{}, false
+		}
+		return newRange(begin, rangeEllipsis), true
+	} else if strings.Contains(*str, "..") {
+		ns := strings.Split(*str, "..")
+		if len(ns) != 2 {
+			return Range{}, false
+		}
+		begin, err1 := strconv.Atoi(ns[0])
+		end, err2 := strconv.Atoi(ns[1])
+		if err1 != nil || err2 != nil || begin == 0 || end == 0 {
+			return Range{}, false
+		}
+		return newRange(begin, end), true
+	}
+
+	n, err := strconv.Atoi(*str)
+	if err != nil || n == 0 {
+		return Range{}, false
+	}
+	return newRange(n, n), true
+}
+
+func withPrefixLengths(tokens []string, begin int) []Token {
+	ret := make([]Token, len(tokens))
+
+	prefixLength := begin
+	for idx := range tokens {
+		chars := util.ToChars(stringBytes(tokens[idx]))
+		ret[idx] = Token{&chars, int32(prefixLength)}
+		prefixLength += chars.Length()
+	}
+	return ret
+}
+
+const (
+	awkNil = iota
+	awkBlack
+	awkWhite
+)
+
+func awkTokenizer(input string) ([]string, int) {
+	// 9, 32
+	ret := []string{}
+	prefixLength := 0
+	state := awkNil
+	begin := 0
+	end := 0
+	for idx := 0; idx < len(input); idx++ {
+		r := input[idx]
+		white := r == 9 || r == 32
+		switch state {
+		case awkNil:
+			if white {
+				prefixLength++
+			} else {
+				state, begin, end = awkBlack, idx, idx+1
+			}
+		case awkBlack:
+			end = idx + 1
+			if white {
+				state = awkWhite
+			}
+		case awkWhite:
+			if white {
+				end = idx + 1
+			} else {
+				ret = append(ret, input[begin:end])
+				state, begin, end = awkBlack, idx, idx+1
+			}
+		}
+	}
+	if begin < end {
+		ret = append(ret, input[begin:end])
+	}
+	return ret, prefixLength
+}
+
+// Tokenize tokenizes the given string with the delimiter
+func Tokenize(text string, delimiter Delimiter) []Token {
+	if delimiter.str == nil && delimiter.regex == nil {
+		// AWK-style (\S+\s*)
+		tokens, prefixLength := awkTokenizer(text)
+		return withPrefixLengths(tokens, prefixLength)
+	}
+
+	if delimiter.str != nil {
+		return withPrefixLengths(strings.SplitAfter(text, *delimiter.str), 0)
+	}
+
+	// FIXME performance
+	var tokens []string
+	if delimiter.regex != nil {
+		locs := delimiter.regex.FindAllStringIndex(text, -1)
+		begin := 0
+		for _, loc := range locs {
+			tokens = append(tokens, text[begin:loc[1]])
+			begin = loc[1]
+		}
+		if begin < len(text) {
+			tokens = append(tokens, text[begin:])
+		}
+	}
+	return withPrefixLengths(tokens, 0)
+}
+
+func joinTokens(tokens []Token) string {
+	var output bytes.Buffer
+	for _, token := range tokens {
+		output.WriteString(token.text.ToString())
+	}
+	return output.String()
+}
+
+// Transform is used to transform the input when --with-nth option is given
+func Transform(tokens []Token, withNth []Range) []Token {
+	transTokens := make([]Token, len(withNth))
+	numTokens := len(tokens)
+	for idx, r := range withNth {
+		parts := []*util.Chars{}
+		minIdx := 0
+		if r.begin == r.end {
+			idx := r.begin
+			if idx == rangeEllipsis {
+				chars := util.ToChars(stringBytes(joinTokens(tokens)))
+				parts = append(parts, &chars)
+			} else {
+				if idx < 0 {
+					idx += numTokens + 1
+				}
+				if idx >= 1 && idx <= numTokens {
+					minIdx = idx - 1
+					parts = append(parts, tokens[idx-1].text)
+				}
+			}
+		} else {
+			var begin, end int
+			if r.begin == rangeEllipsis { // ..N
+				begin, end = 1, r.end
+				if end < 0 {
+					end += numTokens + 1
+				}
+			} else if r.end == rangeEllipsis { // N..
+				begin, end = r.begin, numTokens
+				if begin < 0 {
+					begin += numTokens + 1
+				}
+			} else {
+				begin, end = r.begin, r.end
+				if begin < 0 {
+					begin += numTokens + 1
+				}
+				if end < 0 {
+					end += numTokens + 1
+				}
+			}
+			minIdx = util.Max(0, begin-1)
+			for idx := begin; idx <= end; idx++ {
+				if idx >= 1 && idx <= numTokens {
+					parts = append(parts, tokens[idx-1].text)
+				}
+			}
+		}
+		// Merge multiple parts
+		var merged util.Chars
+		switch len(parts) {
+		case 0:
+			merged = util.ToChars([]byte{})
+		case 1:
+			merged = *parts[0]
+		default:
+			var output bytes.Buffer
+			for _, part := range parts {
+				output.WriteString(part.ToString())
+			}
+			merged = util.ToChars(output.Bytes())
+		}
+
+		var prefixLength int32
+		if minIdx < numTokens {
+			prefixLength = tokens[minIdx].prefixLength
+		} else {
+			prefixLength = 0
+		}
+		transTokens[idx] = Token{&merged, prefixLength}
+	}
+	return transTokens
+}

src/tokenizer_test.go

@@ -0,0 +1,113 @@
+package fzf
+
+import (
+	"testing"
+)
+
+func TestParseRange(t *testing.T) {
+	{
+		i := ".."
+		r, _ := ParseRange(&i)
+		if r.begin != rangeEllipsis || r.end != rangeEllipsis {
+			t.Errorf("%v", r)
+		}
+	}
+	{
+		i := "3.."
+		r, _ := ParseRange(&i)
+		if r.begin != 3 || r.end != rangeEllipsis {
+			t.Errorf("%v", r)
+		}
+	}
+	{
+		i := "3..5"
+		r, _ := ParseRange(&i)
+		if r.begin != 3 || r.end != 5 {
+			t.Errorf("%v", r)
+		}
+	}
+	{
+		i := "-3..-5"
+		r, _ := ParseRange(&i)
+		if r.begin != -3 || r.end != -5 {
+			t.Errorf("%v", r)
+		}
+	}
+	{
+		i := "3"
+		r, _ := ParseRange(&i)
+		if r.begin != 3 || r.end != 3 {
+			t.Errorf("%v", r)
+		}
+	}
+}
+
+func TestTokenize(t *testing.T) {
+	// AWK-style
+	input := "  abc:  def:  ghi  "
+	tokens := Tokenize(input, Delimiter{})
+	if tokens[0].text.ToString() != "abc:  " || tokens[0].prefixLength != 2 {
+		t.Errorf("%s", tokens)
+	}
+
+	// With delimiter
+	tokens = Tokenize(input, delimiterRegexp(":"))
+	if tokens[0].text.ToString() != "  abc:" || tokens[0].prefixLength != 0 {
+		t.Error(tokens[0].text.ToString(), tokens[0].prefixLength)
+	}
+
+	// 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 {
+		t.Errorf("%s", tokens)
+	}
+}
+
+func TestTransform(t *testing.T) {
+	input := "  abc:  def:  ghi:  jkl"
+	{
+		tokens := Tokenize(input, Delimiter{})
+		{
+			ranges, _ := splitNth("1,2,3")
+			tx := Transform(tokens, ranges)
+			if joinTokens(tx) != "abc:  def:  ghi:  " {
+				t.Errorf("%s", tx)
+			}
+		}
+		{
+			ranges, _ := splitNth("1..2,3,2..,1")
+			tx := Transform(tokens, ranges)
+			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 ||
+				tx[2].text.ToString() != "def:  ghi:  jkl" || tx[2].prefixLength != 8 ||
+				tx[3].text.ToString() != "abc:  " || tx[3].prefixLength != 2 {
+				t.Errorf("%s", tx)
+			}
+		}
+	}
+	{
+		tokens := Tokenize(input, delimiterRegexp(":"))
+		{
+			ranges, _ := splitNth("1..2,3,2..,1")
+			tx := Transform(tokens, ranges)
+			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 ||
+				tx[2].text.ToString() != "  def:  ghi:  jkl" || tx[2].prefixLength != 6 ||
+				tx[3].text.ToString() != "  abc:" || tx[3].prefixLength != 0 {
+				t.Errorf("%s", tx)
+			}
+		}
+	}
+}
+
+func TestTransformIndexOutOfBounds(t *testing.T) {
+	s, _ := splitNth("1")
+	Transform([]Token{}, s)
+}

src/tui/dummy.go

@@ -0,0 +1,53 @@
+//go:build !tcell && !windows
+
+package tui
+
+type Attr int32
+
+func HasFullscreenRenderer() bool {
+	return false
+}
+
+var DefaultBorderShape = BorderRounded
+
+func (a Attr) Merge(b Attr) Attr {
+	return a | b
+}
+
+const (
+	AttrUndefined = Attr(0)
+	AttrRegular   = Attr(1 << 8)
+	AttrClear     = Attr(1 << 9)
+
+	Bold          = Attr(1)
+	Dim           = Attr(1 << 1)
+	Italic        = Attr(1 << 2)
+	Underline     = Attr(1 << 3)
+	Blink         = Attr(1 << 4)
+	Blink2        = Attr(1 << 5)
+	Reverse       = Attr(1 << 6)
+	StrikeThrough = Attr(1 << 7)
+)
+
+func (r *FullscreenRenderer) Init() error                        { return nil }
+func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
+func (r *FullscreenRenderer) Pause(bool)                         {}
+func (r *FullscreenRenderer) Resume(bool, bool)                  {}
+func (r *FullscreenRenderer) PassThrough(string)                 {}
+func (r *FullscreenRenderer) Clear()                             {}
+func (r *FullscreenRenderer) NeedScrollbarRedraw() bool          { return false }
+func (r *FullscreenRenderer) ShouldEmitResizeEvent() bool        { return false }
+func (r *FullscreenRenderer) Refresh()                           {}
+func (r *FullscreenRenderer) Close()                             {}
+func (r *FullscreenRenderer) Size() TermSize                     { return TermSize{} }
+
+func (r *FullscreenRenderer) GetChar() Event { return Event{} }
+func (r *FullscreenRenderer) Top() int       { return 0 }
+func (r *FullscreenRenderer) MaxX() int      { return 0 }
+func (r *FullscreenRenderer) MaxY() int      { return 0 }
+
+func (r *FullscreenRenderer) RefreshWindows(windows []Window) {}
+
+func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
+	return nil
+}

src/tui/eventtype_string.go

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

src/tui/light_unix.go

@@ -0,0 +1,125 @@
+//go:build !windows
+
+package tui
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+
+	"github.com/junegunn/fzf/src/util"
+	"golang.org/x/sys/unix"
+	"golang.org/x/term"
+)
+
+func IsLightRendererSupported() bool {
+	return true
+}
+
+func (r *LightRenderer) defaultTheme() *ColorTheme {
+	if strings.Contains(os.Getenv("TERM"), "256") {
+		return Dark256
+	}
+	colors, err := exec.Command("tput", "colors").Output()
+	if err == nil && atoi(strings.TrimSpace(string(colors)), 16) > 16 {
+		return Dark256
+	}
+	return Default16
+}
+
+func (r *LightRenderer) fd() int {
+	return int(r.ttyin.Fd())
+}
+
+func (r *LightRenderer) initPlatform() (err error) {
+	r.origState, err = term.MakeRaw(r.fd())
+	return err
+}
+
+func (r *LightRenderer) closePlatform() {
+	r.ttyout.Close()
+}
+
+func openTty(mode int) (*os.File, error) {
+	in, err := os.OpenFile(consoleDevice, mode, 0)
+	if err != nil {
+		tty := ttyname()
+		if len(tty) > 0 {
+			if in, err := os.OpenFile(tty, mode, 0); err == nil {
+				return in, nil
+			}
+		}
+		return nil, errors.New("failed to open " + consoleDevice)
+	}
+	return in, nil
+}
+
+func openTtyIn() (*os.File, error) {
+	return openTty(syscall.O_RDONLY)
+}
+
+func openTtyOut() (*os.File, error) {
+	return openTty(syscall.O_WRONLY)
+}
+
+func (r *LightRenderer) setupTerminal() {
+	term.MakeRaw(r.fd())
+}
+
+func (r *LightRenderer) restoreTerminal() {
+	term.Restore(r.fd(), r.origState)
+}
+
+func (r *LightRenderer) updateTerminalSize() {
+	width, height, err := term.GetSize(r.fd())
+
+	if err == nil {
+		r.width = width
+		r.height = r.maxHeightFunc(height)
+	} else {
+		r.width = getEnv("COLUMNS", defaultWidth)
+		r.height = r.maxHeightFunc(getEnv("LINES", defaultHeight))
+	}
+}
+
+func (r *LightRenderer) findOffset() (row int, col int) {
+	r.csi("6n")
+	r.flush()
+	var err error
+	bytes := []byte{}
+	for tries := 0; tries < offsetPollTries; tries++ {
+		bytes, err = r.getBytesInternal(bytes, tries > 0)
+		if err != nil {
+			return -1, -1
+		}
+
+		offsets := offsetRegexp.FindSubmatch(bytes)
+		if len(offsets) > 3 {
+			// Add anything we skipped over to the input buffer
+			r.buffer = append(r.buffer, offsets[1]...)
+			return atoi(string(offsets[2]), 0) - 1, atoi(string(offsets[3]), 0) - 1
+		}
+	}
+	return -1, -1
+}
+
+func (r *LightRenderer) getch(nonblock bool) (int, bool) {
+	b := make([]byte, 1)
+	fd := r.fd()
+	util.SetNonblock(r.ttyin, nonblock)
+	_, err := util.Read(fd, b)
+	if err != nil {
+		return 0, false
+	}
+	return int(b[0]), true
+}
+
+func (r *LightRenderer) Size() TermSize {
+	ws, err := unix.IoctlGetWinsize(int(r.ttyin.Fd()), unix.TIOCGWINSZ)
+	if err != nil {
+		return TermSize{}
+	}
+	return TermSize{int(ws.Row), int(ws.Col), int(ws.Xpixel), int(ws.Ypixel)}
+}

src/tui/light_windows.go

@@ -0,0 +1,157 @@
+//go:build windows
+
+package tui
+
+import (
+	"os"
+	"syscall"
+	"time"
+
+	"github.com/junegunn/fzf/src/util"
+	"golang.org/x/sys/windows"
+)
+
+const (
+	timeoutInterval = 10
+)
+
+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)
+)
+
+// IsLightRendererSupported checks to see if the Light renderer is supported
+func IsLightRendererSupported() bool {
+	var oldState uint32
+	// enable vt100 emulation (https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences)
+	if windows.GetConsoleMode(windows.Stderr, &oldState) != nil {
+		return false
+	}
+	// attempt to set mode to determine if we support VT 100 codes. This will work on newer Windows 10
+	// version:
+	canSetVt100 := windows.SetConsoleMode(windows.Stderr, oldState|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING) == nil
+	var checkState uint32
+	if windows.GetConsoleMode(windows.Stderr, &checkState) != nil ||
+		(checkState&windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING) != windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING {
+		return false
+	}
+	windows.SetConsoleMode(windows.Stderr, oldState)
+	return canSetVt100
+}
+
+func (r *LightRenderer) defaultTheme() *ColorTheme {
+	// the getenv check is borrowed from here: https://github.com/gdamore/tcell/commit/0c473b86d82f68226a142e96cc5a34c5a29b3690#diff-b008fcd5e6934bf31bc3d33bf49f47d8R178:
+	if !IsLightRendererSupported() || os.Getenv("ConEmuPID") != "" || os.Getenv("TCELL_TRUECOLOR") == "disable" {
+		return Default16
+	}
+	return Dark256
+}
+
+func (r *LightRenderer) initPlatform() error {
+	//outHandle := windows.Stdout
+	outHandle, _ := syscall.Open("CONOUT$", syscall.O_RDWR, 0)
+	// enable vt100 emulation (https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences)
+	if err := windows.GetConsoleMode(windows.Handle(outHandle), &r.origStateOutput); err != nil {
+		return err
+	}
+	r.outHandle = uintptr(outHandle)
+	inHandle, _ := syscall.Open("CONIN$", syscall.O_RDWR, 0)
+	if err := windows.GetConsoleMode(windows.Handle(inHandle), &r.origStateInput); err != nil {
+		return err
+	}
+	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]
+			}
+		}
+	}()
+
+	return nil
+}
+
+func (r *LightRenderer) closePlatform() {
+	windows.SetConsoleMode(windows.Handle(r.outHandle), r.origStateOutput)
+	windows.SetConsoleMode(windows.Handle(r.inHandle), r.origStateInput)
+}
+
+func openTtyIn() (*os.File, error) {
+	// not used
+	return nil, nil
+}
+
+func openTtyOut() (*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) 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) Size() TermSize {
+	var w, h int
+	var bufferInfo windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
+		w = getEnv("COLUMNS", defaultWidth)
+		h = r.maxHeightFunc(getEnv("LINES", defaultHeight))
+
+	} else {
+		w = int(bufferInfo.Window.Right - bufferInfo.Window.Left)
+		h = r.maxHeightFunc(int(bufferInfo.Window.Bottom - bufferInfo.Window.Top))
+	}
+	return TermSize{h, w, 0, 0}
+}
+
+func (r *LightRenderer) updateTerminalSize() {
+	size := r.Size()
+	r.width = size.Columns
+	r.height = size.Lines
+}
+
+func (r *LightRenderer) findOffset() (row int, col int) {
+	var bufferInfo windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(r.outHandle), &bufferInfo); err != nil {
+		return -1, -1
+	}
+	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 {
+		bc := <-r.ttyinChannel
+		return int(bc), true
+	}
+}

src/tui/tcell.go

@@ -0,0 +1,832 @@
+//go:build tcell || windows
+
+package tui
+
+import (
+	"os"
+	"regexp"
+	"time"
+
+	"github.com/gdamore/tcell/v2"
+	"github.com/junegunn/fzf/src/util"
+
+	"github.com/rivo/uniseg"
+)
+
+func HasFullscreenRenderer() bool {
+	return true
+}
+
+var DefaultBorderShape BorderShape = BorderSharp
+
+func asTcellColor(color Color) tcell.Color {
+	if color == colDefault {
+		return tcell.ColorDefault
+	}
+
+	value := uint64(tcell.ColorValid) + uint64(color)
+	if color.is24() {
+		value = value | uint64(tcell.ColorIsRGB)
+	}
+	return tcell.Color(value)
+}
+
+func (p ColorPair) style() tcell.Style {
+	style := tcell.StyleDefault
+	return style.Foreground(asTcellColor(p.Fg())).Background(asTcellColor(p.Bg()))
+}
+
+type Attr int32
+
+type TcellWindow struct {
+	color       bool
+	preview     bool
+	top         int
+	left        int
+	width       int
+	height      int
+	normal      ColorPair
+	lastX       int
+	lastY       int
+	moveCursor  bool
+	borderStyle BorderStyle
+	uri         *string
+	params      *string
+}
+
+func (w *TcellWindow) Top() int {
+	return w.top
+}
+
+func (w *TcellWindow) Left() int {
+	return w.left
+}
+
+func (w *TcellWindow) Width() int {
+	return w.width
+}
+
+func (w *TcellWindow) Height() int {
+	return w.height
+}
+
+func (w *TcellWindow) Refresh() {
+	if w.moveCursor {
+		_screen.ShowCursor(w.left+w.lastX, w.top+w.lastY)
+		w.moveCursor = false
+	}
+	w.lastX = 0
+	w.lastY = 0
+}
+
+func (w *TcellWindow) FinishFill() {
+	// NO-OP
+}
+
+const (
+	Bold          Attr = Attr(tcell.AttrBold)
+	Dim                = Attr(tcell.AttrDim)
+	Blink              = Attr(tcell.AttrBlink)
+	Reverse            = Attr(tcell.AttrReverse)
+	Underline          = Attr(tcell.AttrUnderline)
+	StrikeThrough      = Attr(tcell.AttrStrikeThrough)
+	Italic             = Attr(tcell.AttrItalic)
+)
+
+const (
+	AttrUndefined = Attr(0)
+	AttrRegular   = Attr(1 << 7)
+	AttrClear     = Attr(1 << 8)
+)
+
+func (r *FullscreenRenderer) PassThrough(str string) {
+	// No-op
+	// https://github.com/gdamore/tcell/pull/650#issuecomment-1806442846
+}
+
+func (r *FullscreenRenderer) Resize(maxHeightFunc func(int) int) {}
+
+func (r *FullscreenRenderer) defaultTheme() *ColorTheme {
+	if _screen.Colors() >= 256 {
+		return Dark256
+	}
+	return Default16
+}
+
+var (
+	_colorToAttribute = []tcell.Color{
+		tcell.ColorBlack,
+		tcell.ColorRed,
+		tcell.ColorGreen,
+		tcell.ColorYellow,
+		tcell.ColorBlue,
+		tcell.ColorDarkMagenta,
+		tcell.ColorLightCyan,
+		tcell.ColorWhite,
+	}
+)
+
+func (c Color) Style() tcell.Color {
+	if c <= colDefault {
+		return tcell.ColorDefault
+	} else if c >= colBlack && c <= colWhite {
+		return _colorToAttribute[int(c)]
+	} else {
+		return tcell.Color(c)
+	}
+}
+
+func (a Attr) Merge(b Attr) Attr {
+	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 (
+	_screen          tcell.Screen
+	_prevMouseButton tcell.ButtonMask
+	_initialResize   bool = true
+)
+
+func (r *FullscreenRenderer) initScreen() error {
+	s, e := tcell.NewScreen()
+	if e != nil {
+		return e
+	}
+	if e = s.Init(); e != nil {
+		return e
+	}
+	if r.mouse {
+		s.EnableMouse()
+	} else {
+		s.DisableMouse()
+	}
+	_screen = s
+
+	return nil
+}
+
+func (r *FullscreenRenderer) Init() error {
+	if os.Getenv("TERM") == "cygwin" {
+		os.Setenv("TERM", "")
+	}
+
+	if err := r.initScreen(); err != nil {
+		return err
+	}
+	initTheme(r.theme, r.defaultTheme(), r.forceBlack)
+
+	return nil
+}
+
+func (r *FullscreenRenderer) Top() int {
+	return 0
+}
+
+func (r *FullscreenRenderer) MaxX() int {
+	ncols, _ := _screen.Size()
+	return int(ncols)
+}
+
+func (r *FullscreenRenderer) MaxY() int {
+	_, nlines := _screen.Size()
+	return int(nlines)
+}
+
+func (w *TcellWindow) X() int {
+	return w.lastX
+}
+
+func (w *TcellWindow) Y() int {
+	return w.lastY
+}
+
+func (r *FullscreenRenderer) Clear() {
+	_screen.Sync()
+	_screen.Clear()
+}
+
+func (r *FullscreenRenderer) NeedScrollbarRedraw() bool {
+	return true
+}
+
+func (r *FullscreenRenderer) ShouldEmitResizeEvent() bool {
+	return true
+}
+
+func (r *FullscreenRenderer) Refresh() {
+	// noop
+}
+
+// TODO: Pixel width and height not implemented
+func (r *FullscreenRenderer) Size() TermSize {
+	cols, lines := _screen.Size()
+	return TermSize{lines, cols, 0, 0}
+}
+
+func (r *FullscreenRenderer) GetChar() Event {
+	ev := _screen.PollEvent()
+	switch ev := ev.(type) {
+	case *tcell.EventResize:
+		// Ignore the first resize event
+		// https://github.com/gdamore/tcell/blob/v2.7.0/TUTORIAL.md?plain=1#L18
+		if _initialResize {
+			_initialResize = false
+			return Event{Invalid, 0, nil}
+		}
+		return Event{Resize, 0, nil}
+
+	// process mouse events:
+	case *tcell.EventMouse:
+		// mouse down events have zeroed buttons, so we can't use them
+		// mouse up event consists of two events, 1. (main) event with modifier and other metadata, 2. event with zeroed buttons
+		// 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
+
+		// since we dont have mouse down events (unlike LightRenderer), we need to track state in prevButton
+		prevButton, button := _prevMouseButton, ev.Buttons()
+		_prevMouseButton = button
+		drag := prevButton == button
+
+		switch {
+		case button&tcell.WheelDown != 0:
+			return Event{Mouse, 0, &MouseEvent{y, x, -1, false, false, false, mod}}
+		case button&tcell.WheelUp != 0:
+			return Event{Mouse, 0, &MouseEvent{y, x, +1, false, false, false, mod}}
+		case button&tcell.Button1 != 0:
+			double := false
+			if !drag {
+				// all potential double click events put their coordinates in the clicks array
+				// double click event has two conditions, temporal and spatial, the first is checked here
+				now := time.Now()
+				if now.Sub(r.prevDownTime) < doubleClickDuration {
+					r.clicks = append(r.clicks, [2]int{x, y})
+				} else {
+					r.clicks = [][2]int{{x, y}}
+				}
+				r.prevDownTime = now
+
+				// detect double clicks (also check for spatial condition)
+				n := len(r.clicks)
+				double = n > 1 && r.clicks[n-2][0] == r.clicks[n-1][0] && r.clicks[n-2][1] == r.clicks[n-1][1]
+				if double {
+					// make sure two consecutive double clicks require four clicks
+					r.clicks = [][2]int{}
+				}
+			}
+			// fire single or double click event
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, true, !double, double, mod}}
+		case button&tcell.Button2 != 0:
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, false, true, false, mod}}
+		default:
+			// double and single taps on Windows don't quite work due to
+			// the console acting on the events and not allowing us
+			// to consume them.
+			left := button&tcell.Button1 != 0
+			down := left || button&tcell.Button3 != 0
+			double := false
+
+			return Event{Mouse, 0, &MouseEvent{y, x, 0, left, down, double, mod}}
+		}
+
+		// process keyboard:
+	case *tcell.EventKey:
+		mods := ev.Modifiers()
+		none := mods == tcell.ModNone
+		alt := (mods & tcell.ModAlt) > 0
+		ctrl := (mods & tcell.ModCtrl) > 0
+		shift := (mods & tcell.ModShift) > 0
+		ctrlAlt := ctrl && alt
+		altShift := alt && shift
+
+		keyfn := func(r rune) Event {
+			if alt {
+				return CtrlAltKey(r)
+			}
+			return EventType(CtrlA.Int() - 'a' + int(r)).AsEvent()
+		}
+		switch ev.Key() {
+		// section 1: Ctrl+(Alt)+[a-z]
+		case tcell.KeyCtrlA:
+			return keyfn('a')
+		case tcell.KeyCtrlB:
+			return keyfn('b')
+		case tcell.KeyCtrlC:
+			return keyfn('c')
+		case tcell.KeyCtrlD:
+			return keyfn('d')
+		case tcell.KeyCtrlE:
+			return keyfn('e')
+		case tcell.KeyCtrlF:
+			return keyfn('f')
+		case tcell.KeyCtrlG:
+			return keyfn('g')
+		case tcell.KeyCtrlH:
+			switch ev.Rune() {
+			case 0:
+				if ctrl {
+					return Event{Backspace, 0, nil}
+				}
+			case rune(tcell.KeyCtrlH):
+				switch {
+				case ctrl:
+					return keyfn('h')
+				case alt:
+					return Event{AltBackspace, 0, nil}
+				case none, shift:
+					return Event{Backspace, 0, nil}
+				}
+			}
+		case tcell.KeyCtrlI:
+			return keyfn('i')
+		case tcell.KeyCtrlJ:
+			return keyfn('j')
+		case tcell.KeyCtrlK:
+			return keyfn('k')
+		case tcell.KeyCtrlL:
+			return keyfn('l')
+		case tcell.KeyCtrlM:
+			return keyfn('m')
+		case tcell.KeyCtrlN:
+			return keyfn('n')
+		case tcell.KeyCtrlO:
+			return keyfn('o')
+		case tcell.KeyCtrlP:
+			return keyfn('p')
+		case tcell.KeyCtrlQ:
+			return keyfn('q')
+		case tcell.KeyCtrlR:
+			return keyfn('r')
+		case tcell.KeyCtrlS:
+			return keyfn('s')
+		case tcell.KeyCtrlT:
+			return keyfn('t')
+		case tcell.KeyCtrlU:
+			return keyfn('u')
+		case tcell.KeyCtrlV:
+			return keyfn('v')
+		case tcell.KeyCtrlW:
+			return keyfn('w')
+		case tcell.KeyCtrlX:
+			return keyfn('x')
+		case tcell.KeyCtrlY:
+			return keyfn('y')
+		case tcell.KeyCtrlZ:
+			return keyfn('z')
+		// section 2: Ctrl+[ \]_]
+		case tcell.KeyCtrlSpace:
+			return Event{CtrlSpace, 0, nil}
+		case tcell.KeyCtrlBackslash:
+			return Event{CtrlBackSlash, 0, nil}
+		case tcell.KeyCtrlRightSq:
+			return Event{CtrlRightBracket, 0, nil}
+		case tcell.KeyCtrlCarat:
+			return Event{CtrlCaret, 0, nil}
+		case tcell.KeyCtrlUnderscore:
+			return Event{CtrlSlash, 0, nil}
+		// section 3: (Alt)+Backspace2
+		case tcell.KeyBackspace2:
+			if alt {
+				return Event{AltBackspace, 0, nil}
+			}
+			return Event{Backspace, 0, nil}
+
+		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
+		case tcell.KeyUp:
+			if altShift {
+				return Event{AltShiftUp, 0, nil}
+			}
+			if shift {
+				return Event{ShiftUp, 0, nil}
+			}
+			if alt {
+				return Event{AltUp, 0, nil}
+			}
+			return Event{Up, 0, nil}
+		case tcell.KeyDown:
+			if altShift {
+				return Event{AltShiftDown, 0, nil}
+			}
+			if shift {
+				return Event{ShiftDown, 0, nil}
+			}
+			if alt {
+				return Event{AltDown, 0, nil}
+			}
+			return Event{Down, 0, nil}
+		case tcell.KeyLeft:
+			if altShift {
+				return Event{AltShiftLeft, 0, nil}
+			}
+			if shift {
+				return Event{ShiftLeft, 0, nil}
+			}
+			if alt {
+				return Event{AltLeft, 0, nil}
+			}
+			return Event{Left, 0, nil}
+		case tcell.KeyRight:
+			if altShift {
+				return Event{AltShiftRight, 0, nil}
+			}
+			if shift {
+				return Event{ShiftRight, 0, nil}
+			}
+			if alt {
+				return Event{AltRight, 0, nil}
+			}
+			return Event{Right, 0, nil}
+
+		// section 5: (Insert|Home|Delete|End|PgUp|PgDn|BackTab|F1-F12)
+		case tcell.KeyInsert:
+			return Event{Insert, 0, nil}
+		case tcell.KeyHome:
+			return Event{Home, 0, nil}
+		case tcell.KeyDelete:
+			if ctrl {
+				return Event{CtrlDelete, 0, nil}
+			}
+			if shift {
+				return Event{ShiftDelete, 0, nil}
+			}
+			return Event{Delete, 0, nil}
+		case tcell.KeyEnd:
+			return Event{End, 0, nil}
+		case tcell.KeyPgUp:
+			return Event{PageUp, 0, nil}
+		case tcell.KeyPgDn:
+			return Event{PageDown, 0, nil}
+		case tcell.KeyBacktab:
+			return Event{ShiftTab, 0, nil}
+		case tcell.KeyF1:
+			return Event{F1, 0, nil}
+		case tcell.KeyF2:
+			return Event{F2, 0, nil}
+		case tcell.KeyF3:
+			return Event{F3, 0, nil}
+		case tcell.KeyF4:
+			return Event{F4, 0, nil}
+		case tcell.KeyF5:
+			return Event{F5, 0, nil}
+		case tcell.KeyF6:
+			return Event{F6, 0, nil}
+		case tcell.KeyF7:
+			return Event{F7, 0, nil}
+		case tcell.KeyF8:
+			return Event{F8, 0, nil}
+		case tcell.KeyF9:
+			return Event{F9, 0, nil}
+		case tcell.KeyF10:
+			return Event{F10, 0, nil}
+		case tcell.KeyF11:
+			return Event{F11, 0, nil}
+		case tcell.KeyF12:
+			return Event{F12, 0, nil}
+
+		// section 6: (Ctrl+Alt)+'rune'
+		case tcell.KeyRune:
+			r := ev.Rune()
+
+			switch {
+			// translate native key events to ascii control characters
+			case r == ' ' && ctrl:
+				return Event{CtrlSpace, 0, nil}
+			// handle AltGr characters
+			case ctrlAlt:
+				return Event{Rune, r, nil} // dropping modifiers
+			// simple characters (possibly with modifier)
+			case alt:
+				return AltKey(r)
+			default:
+				return Event{Rune, r, nil}
+			}
+
+		// section 7: Esc
+		case tcell.KeyEsc:
+			return Event{Esc, 0, nil}
+		}
+	}
+
+	// section 8: Invalid
+	return Event{Invalid, 0, nil}
+}
+
+func (r *FullscreenRenderer) Pause(clear bool) {
+	if clear {
+		_screen.Fini()
+	}
+}
+
+func (r *FullscreenRenderer) Resume(clear bool, sigcont bool) {
+	if clear {
+		r.initScreen()
+	}
+}
+
+func (r *FullscreenRenderer) Close() {
+	_screen.Fini()
+}
+
+func (r *FullscreenRenderer) RefreshWindows(windows []Window) {
+	// TODO
+	for _, w := range windows {
+		w.Refresh()
+	}
+	_screen.Show()
+}
+
+func (r *FullscreenRenderer) NewWindow(top int, left int, width int, height int, preview bool, borderStyle BorderStyle) Window {
+	normal := ColNormal
+	if preview {
+		normal = ColPreview
+	}
+	w := &TcellWindow{
+		color:       r.theme.Colored,
+		preview:     preview,
+		top:         top,
+		left:        left,
+		width:       width,
+		height:      height,
+		normal:      normal,
+		borderStyle: borderStyle}
+	w.Erase()
+	return w
+}
+
+func (w *TcellWindow) Close() {
+	// TODO
+}
+
+func fill(x, y, w, h int, n ColorPair, r rune) {
+	for ly := 0; ly <= h; ly++ {
+		for lx := 0; lx <= w; lx++ {
+			_screen.SetContent(x+lx, y+ly, r, nil, n.style())
+		}
+	}
+}
+
+func (w *TcellWindow) Erase() {
+	if w.borderStyle.shape.HasLeft() {
+		fill(w.left-1, w.top, w.width, w.height-1, w.normal, ' ')
+	} else {
+		fill(w.left, w.top, w.width-1, w.height-1, w.normal, ' ')
+	}
+	w.drawBorder(false)
+}
+
+func (w *TcellWindow) EraseMaybe() bool {
+	w.Erase()
+	return true
+}
+
+func (w *TcellWindow) Enclose(y int, x int) bool {
+	return x >= w.left && x < (w.left+w.width) &&
+		y >= w.top && y < (w.top+w.height)
+}
+
+func (w *TcellWindow) Move(y int, x int) {
+	w.lastX = x
+	w.lastY = y
+	w.moveCursor = true
+}
+
+func (w *TcellWindow) MoveAndClear(y int, x int) {
+	w.Move(y, x)
+	for i := w.lastX; i < w.width; i++ {
+		_screen.SetContent(i+w.left, w.lastY+w.top, rune(' '), nil, w.normal.style())
+	}
+	w.lastX = x
+}
+
+func (w *TcellWindow) Print(text string) {
+	w.printString(text, w.normal)
+}
+
+func (w *TcellWindow) withUrl(style tcell.Style) tcell.Style {
+	if w.uri != nil {
+		style = style.Url(*w.uri)
+		if md := regexp.MustCompile(`id=([^:]+)`).FindStringSubmatch(*w.params); len(md) > 1 {
+			style = style.UrlId(md[1])
+		}
+	}
+	return style
+}
+
+func (w *TcellWindow) printString(text string, pair ColorPair) {
+	lx := 0
+	a := pair.Attr()
+
+	style := pair.style()
+	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)
+	}
+	style = w.withUrl(style)
+
+	gr := uniseg.NewGraphemes(text)
+	for gr.Next() {
+		st := style
+		rs := gr.Runes()
+
+		if len(rs) == 1 {
+			r := rs[0]
+			if r == '\r' {
+				st = style.Dim(true)
+				rs[0] = '␍'
+			} else if r == '\n' {
+				st = style.Dim(true)
+				rs[0] = '␊'
+			} else if r < rune(' ') { // ignore control characters
+				continue
+			}
+		}
+		var xPos = w.left + w.lastX + lx
+		var yPos = w.top + w.lastY
+		if xPos < (w.left+w.width) && yPos < (w.top+w.height) {
+			_screen.SetContent(xPos, yPos, rs[0], rs[1:], st)
+		}
+		lx += util.StringWidth(string(rs))
+	}
+	w.lastX += lx
+}
+
+func (w *TcellWindow) CPrint(pair ColorPair, text string) {
+	w.printString(text, pair)
+}
+
+func (w *TcellWindow) fillString(text string, pair ColorPair) FillReturn {
+	lx := 0
+	a := pair.Attr()
+
+	var style tcell.Style
+	if w.color {
+		style = pair.style()
+	} else {
+		style = w.normal.style()
+	}
+	style = style.
+		Blink(a&Attr(tcell.AttrBlink) != 0).
+		Bold(a&Attr(tcell.AttrBold) != 0).
+		Dim(a&Attr(tcell.AttrDim) != 0).
+		Reverse(a&Attr(tcell.AttrReverse) != 0).
+		Underline(a&Attr(tcell.AttrUnderline) != 0).
+		StrikeThrough(a&Attr(tcell.AttrStrikeThrough) != 0).
+		Italic(a&Attr(tcell.AttrItalic) != 0)
+	style = w.withUrl(style)
+
+	gr := uniseg.NewGraphemes(text)
+Loop:
+	for gr.Next() {
+		st := style
+		rs := gr.Runes()
+		if len(rs) == 1 {
+			r := rs[0]
+			switch r {
+			case '\r':
+				st = style.Dim(true)
+				rs[0] = '␍'
+			case '\n':
+				w.lastY++
+				w.lastX = 0
+				lx = 0
+				continue Loop
+			}
+		}
+
+		// 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 {
+		w.lastY++
+		w.lastX = 0
+		return FillNextLine
+	}
+
+	return FillContinue
+}
+
+func (w *TcellWindow) Fill(str string) FillReturn {
+	return w.fillString(str, w.normal)
+}
+
+func (w *TcellWindow) LinkBegin(uri string, params string) {
+	w.uri = &uri
+	w.params = &params
+}
+
+func (w *TcellWindow) LinkEnd() {
+	w.uri = nil
+	w.params = nil
+}
+
+func (w *TcellWindow) CFill(fg Color, bg Color, a Attr, str string) FillReturn {
+	if fg == colDefault {
+		fg = w.normal.Fg()
+	}
+	if bg == colDefault {
+		bg = w.normal.Bg()
+	}
+	return w.fillString(str, NewColorPair(fg, bg, a))
+}
+
+func (w *TcellWindow) DrawBorder() {
+	w.drawBorder(false)
+}
+
+func (w *TcellWindow) DrawHBorder() {
+	w.drawBorder(true)
+}
+
+func (w *TcellWindow) drawBorder(onlyHorizontal bool) {
+	shape := w.borderStyle.shape
+	if shape == BorderNone {
+		return
+	}
+
+	left := w.left
+	right := left + w.width
+	top := w.top
+	bot := top + w.height
+
+	var style tcell.Style
+	if w.color {
+		if w.preview {
+			style = ColPreviewBorder.style()
+		} else {
+			style = ColBorder.style()
+		}
+	} else {
+		style = w.normal.style()
+	}
+
+	hw := runeWidth(w.borderStyle.top)
+	switch shape {
+	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderTop:
+		max := right - 2*hw
+		if shape == BorderHorizontal || shape == BorderTop {
+			max = right - hw
+		}
+		// tcell has an issue displaying two overlapping wide runes
+		// e.g.  SetContent(  HH  )
+		//       SetContent(   TR )
+		//       ==================
+		//                 (  HH  ) => TR is ignored
+		for x := left; x <= max; x += hw {
+			_screen.SetContent(x, top, w.borderStyle.top, nil, style)
+		}
+	}
+	switch shape {
+	case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderHorizontal, BorderBottom:
+		max := right - 2*hw
+		if shape == BorderHorizontal || shape == BorderBottom {
+			max = right - hw
+		}
+		for x := left; x <= max; x += hw {
+			_screen.SetContent(x, bot-1, w.borderStyle.bottom, nil, style)
+		}
+	}
+	if !onlyHorizontal {
+		switch shape {
+		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderLeft:
+			for y := top; y < bot; y++ {
+				_screen.SetContent(left, y, w.borderStyle.left, nil, style)
+			}
+		}
+		switch shape {
+		case BorderRounded, BorderSharp, BorderBold, BorderBlock, BorderThinBlock, BorderDouble, BorderVertical, BorderRight:
+			vw := runeWidth(w.borderStyle.right)
+			for y := top; y < bot; y++ {
+				_screen.SetContent(right-vw, y, w.borderStyle.right, nil, style)
+			}
+		}
+	}
+	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

@@ -0,0 +1,395 @@
+//go:build tcell || windows
+
+package tui
+
+import (
+	"os"
+	"testing"
+
+	"github.com/gdamore/tcell/v2"
+	"github.com/junegunn/fzf/src/util"
+)
+
+func assert(t *testing.T, context string, got interface{}, want interface{}) bool {
+	if got == want {
+		return true
+	} else {
+		t.Errorf("%s = (%T)%v, want (%T)%v", context, got, got, want, want)
+		return false
+	}
+}
+
+// Test the handling of the tcell keyboard events.
+func TestGetCharEventKey(t *testing.T) {
+	if util.IsTty(os.Stdout) {
+		// This test is skipped when output goes to terminal, because it causes
+		// some glitches:
+		// - output lines may not start at the beginning of a row which makes
+		//   the output unreadable
+		// - terminal may get cleared which prevents you from seeing results of
+		//   previous tests
+		// Good ways to prevent the glitches are piping the output to a pager
+		// or redirecting to a file. I've found `less +G` to be trouble-free.
+		t.Skip("Skipped because this test misbehaves in terminal, pipe to a pager or redirect output to a file to run it safely.")
+	} else if testing.Verbose() {
+		// I have observed a behaviour when this test outputted more than 8192
+		// bytes (32*256) into the 'less' pager, both the go's test executable
+		// and the pager hanged. The go's executable was blocking on printing.
+		// I was able to create minimal working example of that behaviour, but
+		// that example hanged after 12256 bytes (32*(256+127)).
+		t.Log("If you are piping this test to a pager and it hangs, make the pager greedy for input, e.g. 'less +G'.")
+	}
+
+	if !HasFullscreenRenderer() {
+		t.Skip("Can't test FullscreenRenderer.")
+	}
+
+	// construct test cases
+	type giveKey struct {
+		Type tcell.Key
+		Char rune
+		Mods tcell.ModMask
+	}
+	type wantKey = Event
+	type testCase struct {
+		giveKey
+		wantKey
+	}
+	/*
+		Some test cases are marked "fabricated". It means that giveKey value
+		is valid, but it is not what you get when you press the keys. For
+		example Ctrl+C will NOT give you tcell.KeyCtrlC, but tcell.KeyETX
+		(End-Of-Text character, causing SIGINT).
+		I was trying to accompany the fabricated test cases with real ones.
+
+		Some test cases are marked "unhandled". It means that giveKey.Type
+		is not present in tcell.go source code. It can still be handled via
+		implicit or explicit alias.
+
+		If not said otherwise, test cases are for US keyboard.
+
+		(tabstop=44)
+	*/
+	tests := []testCase{
+
+		// section 1: Ctrl+(Alt)+[a-z]
+		{giveKey{tcell.KeyCtrlA, rune(tcell.KeyCtrlA), tcell.ModCtrl}, wantKey{CtrlA, 0, nil}},
+		{giveKey{tcell.KeyCtrlC, rune(tcell.KeyCtrlC), tcell.ModCtrl}, wantKey{CtrlC, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyETX, rune(tcell.KeyETX), tcell.ModCtrl}, wantKey{CtrlC, 0, nil}},     // this is SIGINT (Ctrl+C)
+		{giveKey{tcell.KeyCtrlZ, rune(tcell.KeyCtrlZ), tcell.ModCtrl}, wantKey{CtrlZ, 0, nil}}, // fabricated
+		// KeyTab is alias for KeyTAB
+		{giveKey{tcell.KeyCtrlI, rune(tcell.KeyCtrlI), tcell.ModCtrl}, wantKey{Tab, 0, nil}}, // fabricated
+		{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
+		// 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
+
+		// section 2: Ctrl+[ \]_]
+		{giveKey{tcell.KeyCtrlSpace, rune(tcell.KeyCtrlSpace), tcell.ModCtrl}, wantKey{CtrlSpace, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyNUL, rune(tcell.KeyNUL), tcell.ModNone}, wantKey{CtrlSpace, 0, nil}},             // fabricated, unhandled
+		{giveKey{tcell.KeyRune, ' ', tcell.ModCtrl}, wantKey{CtrlSpace, 0, nil}},                           // actual Ctrl+' '
+		{giveKey{tcell.KeyCtrlBackslash, rune(tcell.KeyCtrlBackslash), tcell.ModCtrl}, wantKey{CtrlBackSlash, 0, nil}},
+		{giveKey{tcell.KeyCtrlRightSq, rune(tcell.KeyCtrlRightSq), tcell.ModCtrl}, wantKey{CtrlRightBracket, 0, nil}},
+		{giveKey{tcell.KeyCtrlCarat, rune(tcell.KeyCtrlCarat), tcell.ModShift | tcell.ModCtrl}, wantKey{CtrlCaret, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyRS, rune(tcell.KeyRS), tcell.ModShift | tcell.ModCtrl}, wantKey{CtrlCaret, 0, nil}},               // actual Ctrl+Shift+6 (i.e. Ctrl+^) keystroke
+		{giveKey{tcell.KeyCtrlUnderscore, rune(tcell.KeyCtrlUnderscore), tcell.ModShift | tcell.ModCtrl}, wantKey{CtrlSlash, 0, nil}},
+
+		// section 3: (Alt)+Backspace2
+		// KeyBackspace2 is alias for KeyDEL = 0x7F (ASCII) (allegedly unused by Windows)
+		// KeyDelete = 0x2E (VK_DELETE constant in Windows)
+		// KeyBackspace is alias for KeyBS = 0x08 (ASCII) (implicit alias with KeyCtrlH)
+		{giveKey{tcell.KeyBackspace2, 0, tcell.ModNone}, wantKey{Backspace, 0, nil}},   // fabricated
+		{giveKey{tcell.KeyBackspace2, 0, tcell.ModAlt}, wantKey{AltBackspace, 0, nil}}, // fabricated
+		{giveKey{tcell.KeyDEL, 0, tcell.ModNone}, wantKey{Backspace, 0, nil}},          // fabricated, unhandled
+		{giveKey{tcell.KeyDelete, 0, tcell.ModNone}, wantKey{Delete, 0, nil}},
+		{giveKey{tcell.KeyDelete, 0, tcell.ModAlt}, wantKey{Delete, 0, nil}},
+		{giveKey{tcell.KeyBackspace, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                  // fabricated, unhandled
+		{giveKey{tcell.KeyBS, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                         // fabricated, unhandled
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},                                                      // fabricated, unhandled
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModNone}, wantKey{Backspace, 0, nil}},                                 // actual "Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModAlt}, wantKey{AltBackspace, 0, nil}},                               // actual "Alt+Backspace" keystroke
+		{giveKey{tcell.KeyDEL, rune(tcell.KeyDEL), tcell.ModCtrl}, wantKey{Backspace, 0, nil}},                                     // actual "Ctrl+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift}, wantKey{Backspace, 0, nil}},                                // actual "Shift+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt}, wantKey{Backspace, 0, nil}},                                     // actual "Ctrl+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModShift}, wantKey{Backspace, 0, nil}},                                   // actual "Ctrl+Shift+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModShift | tcell.ModAlt}, wantKey{AltBackspace, 0, nil}},              // actual "Shift+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, 0, tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{Backspace, 0, nil}},                    // actual "Ctrl+Shift+Alt+Backspace" keystroke
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.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
+		{giveKey{tcell.KeyCtrlH, rune(tcell.KeyCtrlH), tcell.ModCtrl | tcell.ModAlt | tcell.ModShift}, wantKey{CtrlAlt, 'h', nil}}, // fabricated "Ctrl+Shift+Alt+H" keystroke
+
+		// section 4: (Alt+Shift)+Key(Up|Down|Left|Right)
+		{giveKey{tcell.KeyUp, 0, tcell.ModNone}, wantKey{Up, 0, nil}},
+		{giveKey{tcell.KeyDown, 0, tcell.ModAlt}, wantKey{AltDown, 0, nil}},
+		{giveKey{tcell.KeyLeft, 0, tcell.ModShift}, wantKey{ShiftLeft, 0, nil}},
+		{giveKey{tcell.KeyRight, 0, tcell.ModShift | tcell.ModAlt}, wantKey{AltShiftRight, 0, nil}},
+		{giveKey{tcell.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
+		{giveKey{tcell.KeyDownRight, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}}, // fabricated, unhandled
+		{giveKey{tcell.KeyCenter, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},    // fabricated, unhandled
+		// 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}},
+		// 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
+		{giveKey{tcell.KeyRune, 'a', tcell.ModAlt}, wantKey{Alt, 'a', nil}},
+		{giveKey{tcell.KeyRune, 'A', tcell.ModAlt}, wantKey{Alt, 'A', nil}},
+		{giveKey{tcell.KeyRune, '`', tcell.ModAlt}, wantKey{Alt, '`', nil}},
+		/*
+			"Input method" in Windows Language options:
+			US: "US Keyboard" does not generate any characters (and thus any events) in Ctrl+Alt+[a-z] range
+			CS: "Czech keyboard"
+			DE: "German keyboard"
+
+			Note that right Alt is not just `tcell.ModAlt` on foreign language keyboards, but it is the AltGr `tcell.ModCtrl|tcell.ModAlt`.
+		*/
+		{giveKey{tcell.KeyRune, '{', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '{', nil}}, // CS: Ctrl+Alt+b = "{" // Note that this does not interfere with CtrlB, since the "b" is replaced with "{" on OS level
+		{giveKey{tcell.KeyRune, '$', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '$', nil}}, // CS: Ctrl+Alt+ů = "$"
+		{giveKey{tcell.KeyRune, '~', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '~', nil}}, // CS: Ctrl+Alt++ = "~"
+		{giveKey{tcell.KeyRune, '`', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '`', nil}}, // CS: Ctrl+Alt+ý,Space = "`" // this is dead key, space is required to emit the char
+
+		{giveKey{tcell.KeyRune, '{', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '{', nil}}, // DE: Ctrl+Alt+7 = "{"
+		{giveKey{tcell.KeyRune, '@', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, '@', nil}}, // DE: Ctrl+Alt+q = "@"
+		{giveKey{tcell.KeyRune, 'µ', tcell.ModCtrl | tcell.ModAlt}, wantKey{Rune, 'µ', nil}}, // DE: Ctrl+Alt+m = "µ"
+
+		// section 7: Esc
+		// KeyEsc and KeyEscape are aliases for KeyESC
+		{giveKey{tcell.KeyEsc, rune(tcell.KeyEsc), tcell.ModNone}, wantKey{Esc, 0, nil}},               // fabricated
+		{giveKey{tcell.KeyESC, rune(tcell.KeyESC), tcell.ModNone}, wantKey{Esc, 0, nil}},               // unhandled
+		{giveKey{tcell.KeyEscape, rune(tcell.KeyEscape), tcell.ModNone}, wantKey{Esc, 0, nil}},         // fabricated, unhandled
+		{giveKey{tcell.KeyESC, rune(tcell.KeyESC), tcell.ModCtrl}, wantKey{Esc, 0, nil}},               // actual Ctrl+[ keystroke
+		{giveKey{tcell.KeyCtrlLeftSq, rune(tcell.KeyCtrlLeftSq), tcell.ModCtrl}, wantKey{Esc, 0, nil}}, // fabricated, unhandled
+
+		// section 8: Invalid
+		{giveKey{tcell.KeyRune, 'a', tcell.ModMeta}, wantKey{Rune, 'a', nil}}, // fabricated
+		{giveKey{tcell.KeyF24, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},
+		{giveKey{tcell.KeyHelp, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},   // fabricated, unhandled
+		{giveKey{tcell.KeyExit, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},   // fabricated, unhandled
+		{giveKey{tcell.KeyClear, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // unhandled, actual keystroke Numpad_5 with Numlock OFF
+		{giveKey{tcell.KeyCancel, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}}, // fabricated, unhandled
+		{giveKey{tcell.KeyPrint, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // fabricated, unhandled
+		{giveKey{tcell.KeyPause, 0, tcell.ModNone}, wantKey{Invalid, 0, nil}},  // unhandled
+
+	}
+	r := NewFullscreenRenderer(&ColorTheme{}, false, false)
+	r.Init()
+
+	// run and evaluate the tests
+	initialResizeAsInvalid := true
+	for _, test := range tests {
+		// generate key event
+		giveEvent := tcell.NewEventKey(test.giveKey.Type, test.giveKey.Char, test.giveKey.Mods)
+		_screen.PostEventWait(giveEvent)
+		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()
+		// 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()
+		}
+		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)
+	}
+
+	r.Close()
+}
+
+/*
+Quick reference
+---------------
+
+(tabstop=18)
+(this is not mapping table, it merely puts multiple constants ranges in one table)
+
+¹) the two columns are each other implicit alias
+²) explicit aliases here
+
+%v	section #	tcell ctrl key¹	tcell ctrl char¹	tcell alias²	tui constants	tcell named keys	tcell mods
+--	---------	--------------	---------------	-----------	-------------	----------------	----------
+0	2	KeyCtrlSpace	KeyNUL = ^@ 		Rune		ModNone
+1	1	KeyCtrlA	KeySOH = ^A		CtrlA		ModShift
+2	1	KeyCtrlB	KeySTX = ^B		CtrlB		ModCtrl
+3	1	KeyCtrlC	KeyETX = ^C		CtrlC
+4	1	KeyCtrlD	KeyEOT = ^D		CtrlD		ModAlt
+5	1	KeyCtrlE	KeyENQ = ^E		CtrlE
+6	1	KeyCtrlF	KeyACK = ^F		CtrlF
+7	1	KeyCtrlG	KeyBEL = ^G		CtrlG
+8	1	KeyCtrlH	KeyBS = ^H	KeyBackspace	CtrlH		ModMeta
+9	1	KeyCtrlI	KeyTAB = ^I	KeyTab	Tab
+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
+14	1	KeyCtrlN	KeySO = ^N		CtrlN
+15	1	KeyCtrlO	KeySI = ^O		CtrlO
+16	1	KeyCtrlP	KeyDLE = ^P		CtrlP
+17	1	KeyCtrlQ	KeyDC1 = ^Q		CtrlQ
+18	1	KeyCtrlR	KeyDC2 = ^R		CtrlR
+19	1	KeyCtrlS	KeyDC3 = ^S		CtrlS
+20	1	KeyCtrlT	KeyDC4 = ^T		CtrlT
+21	1	KeyCtrlU	KeyNAK = ^U		CtrlU
+22	1	KeyCtrlV	KeySYN = ^V		CtrlV
+23	1	KeyCtrlW	KeyETB = ^W		CtrlW
+24	1	KeyCtrlX	KeyCAN = ^X		CtrlX
+25	1	KeyCtrlY	KeyEM = ^Y		CtrlY
+26	1	KeyCtrlZ	KeySUB = ^Z		CtrlZ
+27	7	KeyCtrlLeftSq	KeyESC = ^[	KeyEsc, KeyEscape	ESC
+28	2	KeyCtrlBackslash	KeyFS = ^\		CtrlSpace
+29	2	KeyCtrlRightSq	KeyGS = ^]		CtrlBackSlash
+30	2	KeyCtrlCarat	KeyRS = ^^		CtrlRightBracket
+31	2	KeyCtrlUnderscore	KeyUS = ^_		CtrlCaret
+32					CtrlSlash
+33					Invalid
+34					Resize
+35					Mouse
+36					DoubleClick
+37					LeftClick
+38					RightClick
+39					BTab
+40					Backspace
+41					Del
+42					PgUp
+43					PgDn
+44					Up
+45					Down
+46					Left
+47					Right
+48					Home
+49					End
+50					Insert
+51					SUp
+52					SDown
+53					ShiftLeft
+54					SRight
+55					F1
+56					F2
+57					F3
+58					F4
+59					F5
+60					F6
+61					F7
+62					F8
+63					F9
+64					F10
+65					F11
+66					F12
+67					Change
+68					BackwardEOF
+69					AltBackspace
+70					AltUp
+71					AltDown
+72					AltLeft
+73					AltRight
+74					AltSUp
+75					AltSDown
+76					AltShiftLeft
+77					AltShiftRight
+78					Alt
+79					CtrlAlt
+..
+127	3		  KeyDEL	KeyBackspace2
+..
+256	6					KeyRune
+257	4					KeyUp
+258	4					KeyDown
+259	4					KeyRight
+260	4					KeyLeft
+261	8					KeyUpLeft
+262	8					KeyUpRight
+263	8					KeyDownLeft
+264	8					KeyDownRight
+265	8					KeyCenter
+266	5					KeyPgUp
+267	5					KeyPgDn
+268	5					KeyHome
+269	5					KeyEnd
+270	5					KeyInsert
+271	5					KeyDelete
+272	8					KeyHelp
+273	8					KeyExit
+274	8					KeyClear
+275	8		  			KeyCancel
+276	8				  	KeyPrint
+277	8					KeyPause
+278	5					KeyBacktab
+279	5					KeyF1
+280	5					KeyF2
+281	5					KeyF3
+282	5					KeyF4
+283	5					KeyF5
+284	5					KeyF6
+285	5					KeyF7
+286	5					KeyF8
+287	5					KeyF9
+288	5					KeyF10
+289	5					KeyF11
+290	5					KeyF12
+291	8					KeyF13
+292	8					KeyF14
+293	8					KeyF15
+294	8					KeyF16
+295	8					KeyF17
+296	8					KeyF18
+297	8					KeyF19
+298	8					KeyF20
+299	8					KeyF21
+300	8					KeyF22
+301	8					KeyF23
+302	8					KeyF24
+303	8					KeyF25
+304	8					KeyF26
+305	8					KeyF27
+306	8					KeyF28
+307	8					KeyF29
+308	8					KeyF30
+309	8					KeyF31
+310	8					KeyF32
+311	8					KeyF33
+312	8					KeyF34
+313	8					KeyF35
+314	8					KeyF36
+315	8					KeyF37
+316	8					KeyF38
+317	8					KeyF39
+318	8					KeyF40
+319	8					KeyF41
+320	8					KeyF42
+321	8					KeyF43
+322	8					KeyF44
+323	8					KeyF45
+324	8					KeyF46
+325	8					KeyF47
+326	8					KeyF48
+327	8					KeyF49
+328	8					KeyF50
+329	8					KeyF51
+330	8					KeyF52
+331	8					KeyF53
+332	8					KeyF54
+333	8					KeyF55
+334	8					KeyF56
+335	8					KeyF57
+336	8					KeyF58
+337	8					KeyF59
+338	8					KeyF60
+339	8					KeyF61
+340	8					KeyF62
+341	8					KeyF63
+342	8					KeyF64
+--	---------	--------------	---------------	-----------	-------------	----------------	----------
+%v	section #	tcell ctrl key	tcell ctrl char	tcell alias	tui constants	tcell named keys	tcell mods
+*/

src/tui/ttyname_unix.go

@@ -0,0 +1,54 @@
+//go:build !windows
+
+package tui
+
+import (
+	"os"
+	"sync/atomic"
+	"syscall"
+)
+
+var devPrefixes = [...]string{"/dev/pts/", "/dev/"}
+
+var tty atomic.Value
+
+func ttyname() string {
+	if cached := tty.Load(); cached != nil {
+		return cached.(string)
+	}
+
+	var stderr syscall.Stat_t
+	if syscall.Fstat(2, &stderr) != nil {
+		return ""
+	}
+
+	for _, prefix := range devPrefixes {
+		files, err := os.ReadDir(prefix)
+		if err != nil {
+			continue
+		}
+
+		for _, file := range files {
+			info, err := file.Info()
+			if err != nil {
+				continue
+			}
+			if stat, ok := info.Sys().(*syscall.Stat_t); ok && stat.Rdev == stderr.Rdev {
+				value := prefix + file.Name()
+				tty.Store(value)
+				return value
+			}
+		}
+	}
+	return ""
+}
+
+// TtyIn returns terminal device to read user input
+func TtyIn() (*os.File, error) {
+	return openTtyIn()
+}
+
+// TtyIn returns terminal device to write to
+func TtyOut() (*os.File, error) {
+	return openTtyOut()
+}

src/tui/ttyname_windows.go

@@ -0,0 +1,21 @@
+//go:build windows
+
+package tui
+
+import (
+	"os"
+)
+
+func ttyname() string {
+	return ""
+}
+
+// TtyIn on Windows returns os.Stdin
+func TtyIn() (*os.File, error) {
+	return os.Stdin, nil
+}
+
+// TtyIn on Windows returns nil
+func TtyOut() (*os.File, error) {
+	return nil, nil
+}