build(deps): bump assets/syntaxes/02_Extra/NSIS

Bumps [assets/syntaxes/02_Extra/NSIS](https://github.com/SublimeText/NSIS) from `619a65a` to `fe5aec8`. - [Release notes](https://github.com/SublimeText/NSIS/releases) - [Commits](https://github.com/SublimeText/NSIS/compare/619a65a04efbf343bdfcde875700675b9b273368...fe5aec8de320fd6c32c67cafd9911a3b521e7026) --- updated-dependencies: - dependency-name: assets/syntaxes/02_Extra/NSIS dependency-version: fe5aec8de320fd6c32c67cafd9911a3b521e7026 dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>
Merge pull request #3862 from lenamonj/fix/sanitize-bidi-control-set
2026-08-04 19:01:44 +00:00 · 2026-08-01 02:04:20 +00:00 · 2026-07-30 00:27:20 +03:00 · 2026-07-29 17:02:33 -04:00 · 2026-07-29 17:02:11 -04:00 · 2026-07-29 23:49:08 +03:00
118 changed files with 6793 additions and 1887 deletions
@@ -0,0 +1,11 @@
+# On Windows MSVC, statically link the C runtime so that the resulting EXE does
+# not depend on the vcruntime DLL.
+#
+# See: https://github.com/sharkdp/bat/issues/3634
+
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]
+[target.i686-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]
+[target.aarch64-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]
@@ -0,0 +1 @@
+use flake
@@ -35,7 +35,7 @@ jobs:
    name: Extract crate metadata
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
    - name: Extract crate information
      id: crate_metadata
      run: |
@@ -58,7 +58,7 @@ jobs:
    - uses: dtolnay/rust-toolchain@stable
      with:
        components: rustfmt,clippy
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
    - run: cargo fmt -- --check
    - run: cargo clippy --locked --all-targets --all-features -- -D warnings

@@ -68,7 +68,7 @@ jobs:
    needs: crate_metadata
    steps:
    - name: Checkout source code
-      uses: actions/checkout@v5
+      uses: actions/checkout@v6
    - name: Install rust toolchain (v${{ needs.crate_metadata.outputs.msrv }})
      uses: dtolnay/rust-toolchain@master
      with:
@@ -80,7 +80,7 @@ jobs:
    name: License checks
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
      with:
        submodules: true # we especially want to perform license checks on submodules
    - run: tests/scripts/license-checks.sh
@@ -90,7 +90,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - name: Git checkout
-      uses: actions/checkout@v5
+      uses: actions/checkout@v6
      with:
        submodules: true # we need all syntax and theme submodules
    - name: Install Rust toolchain
@@ -119,7 +119,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - name: Git checkout
-      uses: actions/checkout@v5
+      uses: actions/checkout@v6
    - name: Prepare environment variables
      run: |
        echo "BAT_SYSTEM_CONFIG_PREFIX=$GITHUB_WORKSPACE/tests/examples/system_config" >> $GITHUB_ENV
@@ -135,7 +135,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - name: Git checkout
-      uses: actions/checkout@v5
+      uses: actions/checkout@v6
    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
    - name: Check documentation
@@ -150,7 +150,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - run: cargo install cargo-audit --locked
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
      - run: cargo audit

  build:
@@ -161,24 +161,24 @@ jobs:
      fail-fast: false
      matrix:
        job:
-          - { target: aarch64-unknown-linux-musl  , os: ubuntu-latest, dpkg_arch: arm64,            use-cross: true }
-          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-latest, dpkg_arch: arm64,            use-cross: true }
-          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-latest, dpkg_arch: armhf,            use-cross: true }
-          - { target: arm-unknown-linux-musleabihf, os: ubuntu-latest, dpkg_arch: musl-linux-armhf, use-cross: true }
-          - { target: i686-pc-windows-msvc        , os: windows-2025,                                              }
-          - { target: i686-unknown-linux-gnu      , os: ubuntu-latest, dpkg_arch: i686,             use-cross: true }
-          - { target: i686-unknown-linux-musl     , os: ubuntu-latest, dpkg_arch: musl-linux-i686,  use-cross: true }
-          - { target: x86_64-apple-darwin         , os: macos-13,                                                  }
-          - { target: aarch64-apple-darwin        , os: macos-14,                                                  }
-          - { target: x86_64-pc-windows-msvc      , os: windows-2025,                                              }
-          - { target: aarch64-pc-windows-msvc     , os: windows-11-arm,                                            }
-          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-latest, dpkg_arch: amd64,            use-cross: true }
-          - { target: x86_64-unknown-linux-musl   , os: ubuntu-latest, dpkg_arch: musl-linux-amd64, use-cross: true }
+          - { target: aarch64-unknown-linux-musl  , os: ubuntu-latest , dpkg_arch: musl-linux-arm64, use-cross: true }
+          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-latest , dpkg_arch: arm64,            use-cross: true }
+          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-latest , dpkg_arch: armhf,            use-cross: true }
+          - { target: arm-unknown-linux-musleabihf, os: ubuntu-latest , dpkg_arch: musl-linux-armhf, use-cross: true }
+          - { target: i686-pc-windows-msvc        , os: windows-2025  ,                                              }
+          - { target: i686-unknown-linux-gnu      , os: ubuntu-latest , dpkg_arch: i386,             use-cross: true }
+          - { target: i686-unknown-linux-musl     , os: ubuntu-latest , dpkg_arch: musl-linux-i686,  use-cross: true }
+          - { target: x86_64-apple-darwin         , os: macos-15-intel,                                              }
+          - { target: aarch64-apple-darwin        , os: macos-latest  ,                                              }
+          - { target: x86_64-pc-windows-msvc      , os: windows-2025  ,                                              }
+          - { target: aarch64-pc-windows-msvc     , os: windows-11-arm,                                              }
+          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-latest , dpkg_arch: amd64,            use-cross: true }
+          - { target: x86_64-unknown-linux-musl   , os: ubuntu-latest , dpkg_arch: musl-linux-amd64, use-cross: true }
    env:
      BUILD_CMD: cargo
    steps:
    - name: Checkout source code
-      uses: actions/checkout@v5
+      uses: actions/checkout@v6

    - name: Install prerequisites
      shell: bash
@@ -195,9 +195,7 @@ jobs:

    - name: Install cross
      if: matrix.job.use-cross
-      uses: taiki-e/install-action@v2
-      with:
-        tool: cross
+      run: cargo install cross --git https://github.com/cross-rs/cross --rev 588b3c99db52b5a9c5906fab96cfadcf1bde7863

    - name: Overwrite build command env variable
      if: matrix.job.use-cross
@@ -335,7 +333,7 @@ jobs:

        DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}
        DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }}-musl
-        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-musl ; DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }} ;; esac;
+        case ${{ matrix.job.target }} in *-musl*) DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-musl ; DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }} ;; esac;
        DPKG_VERSION=${{ needs.crate_metadata.outputs.version }}
        DPKG_ARCH="${{ matrix.job.dpkg_arch }}"
        DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
@@ -13,7 +13,7 @@ jobs:
      PR_NUMBER: ${{ github.event.number }}
      PR_BASE: ${{ github.base_ref }}
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
      - name: Fetch PR base
        run: git fetch --no-tags --prune --depth=1 origin

@@ -1,6 +1,11 @@
+.direnv/
 /target/
 **/*.rs.bk

+# Editors
+.idea/
+.vscode/
+
 # Generated files
 /assets/completions/_bat.ps1
 /assets/completions/bat.bash
@@ -8,3 +13,5 @@
 /assets/completions/bat.zsh
 /assets/manual/bat.1
 /assets/metadata.yaml
+
+
@@ -49,9 +49,6 @@
 [submodule "assets/themes/zenburn"]
 	path = assets/themes/zenburn
 	url = https://github.com/colinta/zenburn.git
-[submodule "assets/syntaxes/Kotlin"]
-	path = assets/syntaxes/02_Extra/Kotlin
-	url = https://github.com/vkostyukov/kotlin-sublime-package
 [submodule "assets/syntaxes/Elm"]
 	path = assets/syntaxes/02_Extra/Elm
 	url = https://github.com/elm-community/SublimeElmLanguageSupport
@@ -130,7 +127,7 @@
 	url = https://github.com/djuretic/SublimeStrace
 [submodule "assets/syntaxes/Jinja2"]
 	path = assets/syntaxes/02_Extra/Jinja2
-	url = https://github.com/Martin819/sublime-jinja2
+	url = https://github.com/ltrzesniewski/sublime-jinja2.git
 [submodule "assets/syntaxes/SLS"]
 	path = assets/syntaxes/02_Extra/SLS
 	url = https://github.com/saltstack/sublime-text
@@ -196,16 +193,13 @@
 	url = https://github.com/leanprover/vscode-lean4.git
 [submodule "assets/syntaxes/02_Extra/Zig"]
 	path = assets/syntaxes/02_Extra/Zig
-	url = https://github.com/ziglang/sublime-zig-language.git
+	url = https://codeberg.org/ziglang/sublime-zig-language.git
 [submodule "assets/syntaxes/02_Extra/gnuplot"]
 	path = assets/syntaxes/02_Extra/gnuplot
 	url = https://github.com/hesstobi/sublime_gnuplot
 [submodule "assets/syntaxes/02_Extra/SystemVerilog"]
 	path = assets/syntaxes/02_Extra/SystemVerilog
 	url = https://github.com/TheClams/SystemVerilog.git
-[submodule "assets/themes/visual-studio-dark-plus"]
-	path = assets/themes/visual-studio-dark-plus
-	url = https://github.com/vidann1/visual-studio-dark-plus.git
 [submodule "assets/syntaxes/02_Extra/SublimeEthereum"]
 	path = assets/syntaxes/02_Extra/SublimeEthereum
 	url = https://github.com/davidhq/SublimeEthereum.git
@@ -243,7 +237,7 @@
 	url = https://github.com/dertuxmalwieder/SublimeTodoTxt
 [submodule "assets/syntaxes/02_Extra/Ada"]
 	path = assets/syntaxes/02_Extra/Ada
-	url = https://github.com/wiremoons/ada-sublime-syntax
+	url = https://github.com/AldanTanneo/ada-sublime-syntax
  
 [submodule "assets/syntaxes/02_Extra/Crontab"]
 	path = assets/syntaxes/02_Extra/Crontab
@@ -281,3 +275,12 @@
 [submodule "assets/syntaxes/02_Extra/Gomod"]
 	path = assets/syntaxes/02_Extra/Gomod
 	url = https://github.com/mitranim/sublime-gomod
+[submodule "assets/syntaxes/02_Extra/COBOL"]
+	path = assets/syntaxes/02_Extra/COBOL
+	url = https://github.com/adukhan99/sublime_cobol.git
+[submodule "assets/syntaxes/02_Extra/Kotlin"]
+	path = assets/syntaxes/02_Extra/Kotlin
+	url = https://github.com/guille/sublime-kotlin
+[submodule "assets/syntaxes/02_Extra/Caddy"]
+	path = assets/syntaxes/02_Extra/Caddy
+	url = https://github.com/caddyserver/sublimetext.git
@@ -1,3 +1,120 @@
+# unreleased
+
+
+## Other
+
+- Update Cargo dependencies to resolve current RustSec advisories, see #3861 (@TyceHerrman)
+- Add instructions for removing fish help abbreviations to README, see #3655 (@claw-explorer). Closes #3536
+- Add .NET slnx extension, see #3682 (@ltrzesniewski)
+
+## Features
+
+- Add a `--sanitize=<auto|always|never>` flag for safe display of untrusted input. It implies `--strip-ansi` at the same value and additionally substitutes terminal-active control bytes (cursor moves, charset switches, beep, etc.) and Unicode bidi / zero-width formatting characters with the Unicode replacement character (U+FFFD). Mitigates Trojan-Source-style spoofing (CVE-2021-42574). See #3729 (@curious-rabbit)
+- Map justfile, Justfile, .justfile, and *.justfile to Makefile syntax highlighting, see #3623 (@zachvalenta)
+- Preserve `--diff` change markers and snip separators when `--plain` is set. Closes #3630, see #3643 (@mvanhorn)
+- Added support for `hidden_file_extensions` from `.sublime-syntax` files, see #3613 (@Matei02355)
+- Add word wrapping mode via `--wrap=word`, see #3597 (@veeceey)
+- Support configuring `--terminal-width` via `BAT_WIDTH`, see #3679 (@officialasishkumar)
+- Implement `--unbuffered` mode for streaming input, allowing partial lines to display immediately (e.g. `tail -f | bat -u`). Closes #3555, see #3583 (@mainnebula)
+- Added an initial `flake.nix` for a ready made development environment; see #3578 (@vorburger)
+- Add `--quiet-empty` (`-E`) flag to suppress output when input is empty. Closes #1936, see #3563 (@NORMAL-EX)
+- Improve native man pages and command help syntax highlighting by stripping overstriking, see #3517 (@akirk)
+- Add `--fallback-syntax`/`--fallback-language` to apply syntax highlighting only when auto-detection fails, see #1341 (@Xavrir)
+- Map `BUILD` case sensitively to Python (Starlark) for Bazel, see #3576 (@vorburger)
+- Syntax highlighting for Python files using uv as script runner in shebang #3689 (@janlarres)
+
+## Bugfixes
+- Fix `--list-languages` respecting `--paging=never`, see #3828 (@cyphercodes)
+- Fix `--sanitize` passing through the bidi control characters U+200E, U+200F and U+061C, see #3862 (@lenamonj)
+- `--strip-ansi`: also strip 8-bit C1 introducers (U+0090, U+0098, U+009B, U+009D, U+009E, U+009F) and DCS/SOS/PM/APC sequence bodies, which previously passed through. See #3729 (@curious-rabbit)
+- Fix `--ignored-suffix` not falling back to first-line/shebang detection when the ignored suffix is also a registered extension (e.g. `--ignored-suffix .txt` on a shebang script), see #2745 and #3816 (@adnrivera)
+- Fix `capacity overflow` panic when printing a snip separator at `--terminal-width=1` with multiple line ranges. Closes #3803, see #3804 (@leeewee)
+- Pass `--no-paging` to `bat` invocations inside the bash / zsh / fish / PowerShell shell completion scripts so that shell-level pager wiring (e.g. `LESSOPEN='|-bat -f -pp %s'`) cannot inject ANSI escape sequences into the completion candidates. Closes #3760 (@mvanhorn)
+- Quote filenames before substituting them into `$LESSOPEN` / `$LESSCLOSE` templates, preventing shell injection when a filename contains shell metacharacters, see #3726 (@curious-rabbit)
+- Fix `--list-themes` unconditionally probing the terminal via OSC 10/11 even when `--theme` was set to an explicit value, see #3700 (regression introduced in bc42149a). (@optimistiCli)
+- Fix inverted `$LESSCLOSE` warning so bat warns on nonzero exit, not on success. See #3654 (@cuiweixie)
+- Sanitize control characters in filenames before displaying them in the file header, error messages, and the terminal title, preventing ANSI escape injection via crafted filenames. Closes #3054, see #3691 (@curious-rabbit)
+- Report initial input read errors instead of treating them as empty input. Closes #3002, see #3706 (@lawrence3699)
+- Treat ZIP archives as binary content based on their magic header, see #3686 (@officialasishkumar)
+- Fix i686 `.deb` package using incorrect architecture name (`i686` instead of `i386`), preventing installation on Debian. Closes #3611, see #3650 (@Sim-hu)
+- Fix inconsistent `.deb` MUSL package names (aarch64-musl used `arm64` instead of `musl-linux-arm64`, and `musleabihf` target missed `bat-musl` prefix). Closes #3482, see #3642 (@mvanhorn)
+- Fix incorrect text width computation when using `--binary=as-text` with non-printable characters in caret notation, see #3640 and #3631 (@eyupcanakman)
+- Fix `BAT_CONFIG_DIR` pointing at system config directory causing duplicate flag errors. Closes #3589, see #3620 (@Xavrir)
+- Fix syntax highlighting for symlinked files when the symlink name has no extension but the target does. Closes #1001, see #3621 (@Xavrir)
+- Report error when pager is missing instead of silently falling back, see #3588 (@IMaloney)
+- Fix `--wrap=never` and `-S` flags being ignored when piping to pager, see #3592 (@IMaloney)
+- Fix crash with BusyBox `less` on Windows, see #3527 (@Anchal-T)
+- Fix `bat cache --help` failing with 'unexpected argument' error, see #3580 and #3560 (@NORMAL-EX)
+- `--help` now correctly honors `--pager=builtin`. See #3516 (@keith-hall)
+- `--help` now correctly honors custom themes. See #3524 (@keith-hall)
+- Fixed test compatibility with future Cargo build directory changes, see #3550 (@nmacl)
+- Fixed bug caused by using `--plain` and `--terminal-width=N` flags simultaneously, see #3529 (@H4k1l)
+- Fixed syntax tests path, see #3610 (@foxfromworld)
+- Fix zsh tab completion word-splitting language names containing spaces (e.g. `HTML (Jinja2)`, `Apache Conf`), see #3693 (@YoshKoz)
+- Fix zsh tab completion offering invalid `-l` arguments (file globs, paths, hidden filenames) sourced from the second column of `--list-languages`. Closes #3735, see #3737 (@truffle-dev)
+- Fix `usize` underflow in `--list-languages` when `--terminal-width` is smaller than the longest language name, see #3812 (@greymoth-jp)
+
+## Other
+- Use git version of cross. See #3533 (@OctopusET)
+- Bump MSRV to 1.88, update `time` crate to 0.3.47 to fix RUSTSEC-2026-0009, see #3581 (@NORMAL-EX)
+- Allow home and end keys to be used with builtin pager, see #3651 (@keith-hall)
+- Builtin syntax mapping: cleanup matcher glob parsing logic #3652 (@cyqsimon)
+- Statically link the CRT for MSVC builds via Cargo config to avoid runtime DLL dependencies. Closes #3634, see #3692 (@barry3406)
+- Replace `libgit2` with a pure Rust implementation of git called `gitoxide`, see PR #3703 (@blinxen)
+
+## Syntaxes
+
+- Add shebang-based detection for Tcl (`tclsh`, `wish`) and Expect (`expect`) scripts, see #3647 (@mvanhorn)
+- Change the URL of Zig submodule from GitHub to Codeberg, see #3519 (@sorairolake)
+- Don't color strings inside CSV files, to make it easier to tell which column they belong to, see #3521 (@keith-hall)
+- Add syntax highlighting support for COBOL, see #3584 (@adukhan99)
+- Fixed manpage syntax so that ANSI escape codes don't get incorrectly highlighted and thus broken, see #3586 (@BlueElectivire)
+- Map several Google Cloud CLI config files to their appropriate syntax #3635 (@victor-gp)
+- Map all ignore dotfiles to Git Ignore syntax #3636 (@victor-gp)
+- Improved Kotlin syntax, see #3699 (@guille)
+- Include subdirectories in SSH Config syntax mapping, see #3758 (@injust)
+- Add Ghostty syntax mapping, see #3759 (@injust)
+- Add syntax highlighting for `Caddyfile` #3789 (@CosmicHorrorDev)
+- Include `.code-workspace` as a JSON extension #3809 (@dhruvkb)
+- Add syntax mapping for DNF repo configuration files, see #3814 (@injust)
+
+## Themes
+
+- Remove the Visual Studio Dark+ theme, see #3552 (@CosmicHorrorDev)
+
+## `bat` as a library
+
+# v0.26.1
+
+## Features
+
+- Add paging to '-h' and '--help' see PR #3478 (@MuntasirSZN)
+
+## Bugfixes
+
+- Fix hang when using `--list-themes` with an explicit pager, see #3457 (@abhinavcool42)
+- Fix negative values of N not being parsed in <N:M> line ranges without `=` flag value separator, see #3442 (@lmmx)
+- Fix broken Docker syntax preventing use of custom assets, see #3476 (@keith-hall)
+- Fix decorations being applied unexpectedly when piping. Now only line numbers explicitly required on the command line should be applied in auto decorations mode for `cat` compatibility. See #3496 (@keith-hall)
+- Fix diagnostics attempting to find the version of an executable named builtin when builtin pager is used. See #3498 (@keith-hall)
+- `--help` now correctly reads the config file for theme information etc. See #3507 (@keith-hall)
+
+## Other
+- Improve README documentation on pager options passed to less, see #3443 (@injust)
+- Make PowerShell completions compatible with PowerShell v5.1, see #3495 (@keith-hall)
+- Use more robust approach to escaping in Bash completions, see #3448 (@akinomyoga)
+
+## Syntaxes
+
+- Update quadlet syntax mapping to include *.{build,pod} files #3484 (@cyqsimon)
+- Fix inconsistencies in Ada syntax, see #3481 (@AldanTanneo)
+- Add syntax mapping for podman's `artifact` quadlet files, see #3497 (@xduugu)
+- Highlight Korn Shell scripts (i.e. with a shebang of ...`ksh`) using Bash syntax, see #3509 (@keith-hall)
+
+## Themes
+
+## `bat` as a library
+
 # v0.26.0

 ## Features
@@ -29,7 +146,7 @@
 - Update base16 README links to community driven base16 work #2871 (@JamyGolden)
 - Work around build failures when building `bat` from vendored sources #3179 (@dtolnay)
 - CICD: Stop building for x86_64-pc-windows-gnu which fails #3261 (Enselic)
- CICD:  CICD: replace windows-2019 runners with windows-2025 #3339 (@cyqsimon)
+- CICD: replace windows-2019 runners with windows-2025 #3339 (@cyqsimon)
 - Build script: replace string-based codegen with quote-based codegen #3340 (@cyqsimon)
 - Improve code coverage of `--list-languages` parameter #2942 (@sblondon)
 - Only start offload worker thread when there's more than 1 core #2956 (@cyqsimon)
@@ -68,6 +68,8 @@ users, please read the corresponding
 [documentation](https://github.com/sharkdp/bat/blob/master/doc/assets.md)
 first.

+To map a file name pattern to an existing syntax, read [the documentation here](https://github.com/sharkdp/bat/blob/master/src/syntax_mapping/builtins/README.md).
+
 Note: We are currently not accepting new default themes.


@@ -91,3 +93,29 @@ To learn how to write regression tests for theme and syntax changes, read the
 [Syntax
 tests](https://github.com/sharkdp/bat/blob/master/doc/assets.md#syntax-tests)
 section in `assets.md`.
+
+### Ensuring bat is available for Syntax tests
+
+The syntax test script (`tests/syntax-tests/update.sh`) calls `bat` from your PATH and regenerates the highlighted output files under
+`tests/syntax-tests/highlighted/`. These files are used to verify that syntax highlighting works as expected.
+
+- If you only built the binaries with:
+  ```bash
+  cargo build --bins
+  ```
+
+  you need to add the debug build to your PATH from the bat project root before running the tests.
+  See also step 5 in [Syntax
+tests](https://github.com/sharkdp/bat/blob/master/doc/assets.md#syntax-tests) for related instructions.
+  ```bash
+  export PATH="$PATH:$(pwd)/target/debug"
+  ```
+  Otherwise, you will see:
+  ```bash
+  Error: Could not execute 'bat'. Please make sure that the executable is available on the PATH.
+  ```
+- If you installed bat with:
+  ```bash
+  cargo install --path . --locked
+  ```
+  then bat will be available in ~/.cargo/bin (usually already in PATH), and the tests will run without issues.
@@ -6,12 +6,12 @@ homepage = "https://github.com/sharkdp/bat"
 license = "MIT OR Apache-2.0"
 name = "bat"
 repository = "https://github.com/sharkdp/bat"
-version = "0.26.0"
+version = "0.26.1"
 exclude = ["assets/syntaxes/*", "assets/themes/*"]
 build = "build/main.rs"
 edition = '2021'
 # You are free to bump MSRV as soon as a reason for bumping emerges.
-rust-version = "1.79"
+rust-version = "1.88"

 [features]
 default = ["application", "git"]
@@ -31,8 +31,7 @@ minimal-application = [
    "regex-onig",
    "wild",
 ]
-git = ["git2"] # Support indicating git modifications
-vendored-libgit2 = ["git2/vendored-libgit2"]
+git = ["gix"] # Support indicating git modifications
 paging = [ "shell-words", "grep-cli", "minus"] # Support applying a pager on the output
 lessopen = ["execute"] # Support $LESSOPEN preprocessor
 build-assets = ["syntect/yaml-load", "syntect/plist-load", "regex", "walkdir"]
@@ -42,21 +41,21 @@ regex-onig = ["syntect/regex-onig"] # Use the "oniguruma" regex engine
 regex-fancy = ["syntect/regex-fancy"] # Use the rust-only "fancy-regex" engine

 [dependencies]
-nu-ansi-term = "0.50.0"
+nu-ansi-term = "0.50.3"
 ansi_colours = "^1.2"
 bincode = "1.0"
-console = "0.16.0"
+console = "0.16.2"
 flate2 = "1.1"
 once_cell = "1.20"
 thiserror = "2.0"
 wild = { version = "2.2", optional = true }
 content_inspector = "0.2.4"
-shell-words = { version = "1.1.0", optional = true }
-minus = { version = "5.6", optional = true, features = [
+shell-words = { version = "1.1.1", optional = true }
+minus = { version = "5.7", optional = true, features = [
  "dynamic_output",
  "search",
 ] }
-unicode-width = "0.2.1"
+unicode-width = "0.2.2"
 globset = "0.4"
 serde = "1.0"
 serde_derive = "1.0"
@@ -64,22 +63,23 @@ serde_yaml = "0.9.28"
 semver = "1.0"
 path_abs = { version = "0.5", default-features = false }
 clircle = { version = "0.6.1", default-features = false }
-bugreport = { version = "0.5.0", optional = true }
-etcetera = { version = "0.10.0", optional = true }
-grep-cli = { version = "0.1.11", optional = true }
-regex = { version = "1.10.6", optional = true }
+bugreport = { version = "0.6.0", optional = true }
+etcetera = { version = "0.11.0", optional = true }
+grep-cli = { version = "0.1.12", optional = true }
+regex = { version = "1.12.3", optional = true }
 walkdir = { version = "2.5", optional = true }
-bytesize = { version = "1.3.0" }
+bytesize = { version = "2.3.1" }
 encoding_rs = "0.8.35"
-execute = { version = "0.2.13", optional = true }
+execute = { version = "0.2.15", optional = true }
 terminal-colorsaurus = "1.0"
-unicode-segmentation = "1.12.0"
+unicode-segmentation = "1.13.2"
 itertools = "0.14.0"

-[dependencies.git2]
-version = "0.20"
+[dependencies.gix]
+version = "0.85"
 optional = true
 default-features = false
+features = ["sha1", "blob-diff"]

 [dependencies.syntect]
 version = "5.3.0"
@@ -87,44 +87,43 @@ default-features = false
 features = ["parsing"]

 [dependencies.clap]
-version = "4.5.46"
+version = "4.6.1"
 optional = true
 features = ["wrap_help", "cargo"]

 [target.'cfg(target_os = "macos")'.dependencies]
-home = "0.5.9"
-plist = "1.7.0"
+plist = "1.9.0"

 [dev-dependencies]
-assert_cmd = "2.0.12"
+assert_cmd = "2.0.16"
 expect-test = "1.5.0"
 serial_test = { version = "2.0.0", default-features = false }
-predicates = "3.1.3"
+predicates = "3.1.4"
 wait-timeout = "0.2.1"
-tempfile = "3.16.0"
+tempfile = "3.27.0"
 serde = { version = "1.0", features = ["derive"] }

 [target.'cfg(unix)'.dev-dependencies]
-nix = { version = "0.30", default-features = false, features = ["term"] }
+nix = { version = "0.31", default-features = false, features = ["term"] }

 [build-dependencies]
 anyhow = "1.0.97"
-indexmap = { version = "2.8.0", features = ["serde"] }
+indexmap = { version = "2.14.0", features = ["serde"] }
 itertools = "0.14.0"
 once_cell = "1.20"
-prettyplease = "0.2.35"
-proc-macro2 = "1.0.95"
-quote = "1.0.40"
-regex = "1.10.6"
+prettyplease = "0.2.37"
+proc-macro2 = "1.0.106"
+quote = "1.0.45"
+regex = "1.12.3"
 serde = "1.0"
 serde_derive = "1.0"
-serde_with = { version = "3.12.0", default-features = false, features = ["macros"] }
+serde_with = { version = "3.17.0", default-features = false, features = ["macros"] }
 syn = { version = "2.0.104", features = ["full"] }
-toml = { version = "0.9.1", features = ["preserve_order"] }
+toml = { version = "1.1.1", features = ["preserve_order"] }
 walkdir = "2.5"

 [build-dependencies.clap]
-version = "4.5.46"
+version = "4.6.1"
 optional = true
 features = ["wrap_help", "cargo"]

@@ -19,26 +19,6 @@
  [<a href="doc/README-ru.md">Русский</a>]
 </p>

-### Sponsors
-
-A special *thank you* goes to our biggest <a href="doc/sponsors.md">sponsors</a>:<br>
-
-<p>
-<a href="https://www.warp.dev/bat">
-  <img src="doc/sponsors/warp-logo.png" width="200" alt="Warp">
-  <br>
-  <strong>Warp, the intelligent terminal</strong>
-  <br>
-  <sub>Available on MacOS, Linux, Windows</sub>
-</a>
-</p><p>
-<a href="https://graphite.dev/?utm_source=github&utm_medium=repo&utm_campaign=bat">
-  <img src="doc/sponsors/graphite-logo.jpeg" width="200" alt="Graphite">
-  <br>
-  <strong>Graphite is the AI developer productivity platform helping<br>teams on GitHub ship higher quality software, faster</strong>
-</a>
-</p>
-
 ### Syntax highlighting

 `bat` supports syntax highlighting for a large number of programming and markup
@@ -49,7 +29,7 @@ languages:
 ### Git integration

 `bat` communicates with `git` to show modifications with respect to the index
-(see left side bar):
+(see left sidebar):

 ![Git integration example](https://i.imgur.com/2lSW4RE.png)

@@ -201,30 +181,19 @@ bat main.cpp | xclip
 `MANPAGER` environment variable:

 ```bash
-export MANPAGER="sh -c 'awk '\''{ gsub(/\x1B\[[0-9;]*m/, \"\", \$0); gsub(/.\x08/, \"\", \$0); print }'\'' | bat -p -lman'"
+export MANPAGER="bat -plman"
 man 2 select
 ```
-(replace `bat` with `batcat` if you are on Debian or Ubuntu)
+(on some older Debian or Ubuntu releases, the executable is named `batcat` instead of `bat`)

 If you prefer to have this bundled in a new command, you can also use [`batman`](https://github.com/eth-p/bat-extras/blob/master/doc/batman.md).

-> [!WARNING]  
-> This will [not work](https://github.com/sharkdp/bat/issues/1145) out of the box with Mandoc's `man` implementation.
->
-> Please either use `batman`, or convert the shell script to a [shebang executable](https://en.wikipedia.org/wiki/Shebang_(Unix)) and point `MANPAGER` to that.
-
 Note that the [Manpage syntax](assets/syntaxes/02_Extra/Manpage.sublime-syntax) is developed in this repository and still needs some work.

 #### `prettier` / `shfmt` / `rustfmt`

 The [`prettybat`](https://github.com/eth-p/bat-extras/blob/master/doc/prettybat.md) script is a wrapper that will format code and print it with `bat`.

-#### `Warp`
-
-<a href="https://app.warp.dev/drive/folder/-Bat-Warp-Pack-lxhe7HrEwgwpG17mvrFSz1">
-  <img src="doc/sponsors/warp-pack-header.png" alt="Warp">
-</a>
-
 #### Highlighting `--help` messages

 You can use `bat` to colorize help text: `$ cp --help | bat -plhelp`
@@ -257,6 +226,14 @@ abbr -a --position anywhere -- -h '-h | bat -plhelp'

 This way, you can keep on using `cp --help`, but get colorized help pages.

+> [!TIP]
+> To remove these abbreviations later, run:
+> ```fish
+> abbr -e -- --help
+> abbr -e -- -h
+> ```
+> The `--` before the abbreviation name is required because `--help` and `-h` start with dashes, which would otherwise be interpreted as flags to `abbr` itself.
+
 Be aware that in some cases, `-h` may not be a shorthand of `--help` (for example with `ls`). In cases where you need to use `-h` 
 as a command argument you can prepend `\` to the argument (eg. `ls \-h`) to escape the aliasing defined above. 

@@ -287,8 +264,8 @@ If your Ubuntu/Debian installation is new enough you can simply run:
 sudo apt install bat
 ```

-**Important**: If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name
-clash with another package](https://github.com/sharkdp/bat/issues/982)). You can set up a `bat -> batcat` symlink or alias to prevent any issues that may come up because of this and to be consistent with other distributions:
+**Important**: On some older Ubuntu/Debian releases, the executable is installed as `batcat` instead of `bat` (due to [a name
+clash with another package](https://github.com/sharkdp/bat/issues/982)). On newer releases, the executable is available as `bat`. If `bat --version` does not work after installation, try `batcat --version` instead. You can set up a `bat -> batcat` symlink or alias to prevent any issues that may come up because of this and to be consistent with other distributions:
 ``` bash
 mkdir -p ~/.local/bin
 ln -s /usr/bin/batcat ~/.local/bin/bat
@@ -330,7 +307,7 @@ pacman -S bat

 ### On Fedora

-You can install [the `bat` package](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506) from the official [Fedora Modular](https://docs.fedoraproject.org/en-US/modularity/using-modules/) repository.
+You can install [the `bat` package](https://packages.fedoraproject.org/pkgs/rust-bat/bat/) from the official sources:

 ```bash
 dnf install bat
@@ -530,6 +507,30 @@ and line numbers but no grid and no file header. Set the `BAT_STYLE` environment
 variable to make these changes permanent or use `bat`'s
 [configuration file](#configuration-file).

+By default, `bat` enables `changes`, `grid`, `header-filename`, `numbers`, and `snip`.
+
+The available pre-defined styles are:
+
+| Style | Description |
+|-------|-------------|
+| `default` | Enables the recommended style components listed above. |
+| `full` | Enables all available components. |
+| `auto` | Same as `default`, unless the output is piped. |
+| `plain` | Disables all available components. |
+
+The available individual components are:
+
+| Component | Description |
+|-----------|-------------|
+| `changes` | Show Git modification markers. |
+| `header` | Alias for `header-filename`. |
+| `header-filename` | Show filenames before the content. |
+| `header-filesize` | Show file sizes before the content. |
+| `grid` | Vertical/horizontal lines to separate the side bar and header from the content. |
+| `rule` | Horizontal lines to delimit files. |
+| `numbers` | Show line numbers in the side bar. |
+| `snip` | Draw separation lines between distinct line ranges. |
+
 >[!tip]
 > If you specify a default style in `bat`'s config file, you can change which components
 > are displayed during a single run of `bat` using the `--style` command-line argument.
@@ -540,6 +541,12 @@ variable to make these changes permanent or use `bat`'s
 > Or, if you want to override the styles completely, you use `--style=numbers` to
 > only show the line numbers.

+### Decorations
+
+By default, `bat` only shows decorations (such as line numbers, file headers, grid borders, etc.) when outputting to an interactive terminal. You can control this behavior with the `--decorations` option. Use `--decorations=always` to show decorations even when piping output to another command, or `--decorations=never` to disable them entirely. Possible values are `auto` (default), `never`, and `always`.
+
+There is also the `--force-colorization` option, which is an alias for `--decorations=always --color=always`. This is useful if you want to keep colorization and decorations when piping `bat`'s output to another program.
+
 ### Adding new syntaxes / language definitions

 Should you find that a particular syntax is not available within `bat`, you can follow these
@@ -586,7 +593,8 @@ syntax:

 This works very similar to how we add new syntax definitions.
 > [!NOTE]
-> Themes are stored in [`.tmTheme` files](https://www.sublimetext.com/docs/color_schemes_tmtheme.html).
+> Custom themes must be stored in [`.tmTheme` files](https://www.sublimetext.com/docs/color_schemes_tmtheme.html).
+> Newer `.sublime-color-scheme` files are currently not supported.

 First, create a folder with the new syntax highlighting themes:
 ```bash
@@ -670,22 +678,22 @@ to improve the experience. Specifically, `-R`/`--RAW-CONTROL-CHARS`, `-F`/`--qui
 > - The `--paging=always` argument is used.
 > - The `BAT_PAGING` environment is set to `always`.

-The `-R` option is needed to interpret ANSI colors correctly.
+The `-R`/`--RAW-CONTROL-CHARS` option is needed to interpret ANSI colors correctly.

-The `-F` option instructs `less` to exit immediately if the output size is smaller than
+The `-F`/`--quit-if-one-screen` option instructs `less` to exit immediately if the output size is smaller than
 the vertical size of the terminal. This is convenient for small files because you do not
 have to press `q` to quit the pager.

-The `-K` option instructs `less` to exit immediately when an interrupt signal is received.
+The `-K`/`--quit-on-intr` option instructs `less` to exit immediately when an interrupt signal is received.
 This is useful to ensure that `less` quits together with `bat` on SIGINT.

-The `-X` option is needed to fix a bug with the `--quit-if-one-screen` feature in versions
-of `less` older than version 530. Unfortunately, it also breaks mouse-wheel support in `less`.
+The `-X`/`--no-init` option is added to versions of `less` older than version 530 (older than 558 on Windows) to
+fix a bug with the `-F`/`--quit-if-one-screen` feature. Unfortunately, it also breaks mouse-wheel support in `less`.
 If you want to enable mouse-wheel scrolling on older versions of `less` and do not mind losing
 the quit-if-one-screen feature, you can set the pager (via `--pager` or `BAT_PAGER`) to `less -R`.
 For `less` 530 or newer, it should work out of the box.

-The `-S` option is added when `bat`'s `-S`/`--chop-long-lines` option is used. This tells `less`
+The `-S`/`--chop-long-lines` option is added when `bat`'s `-S`/`--chop-long-lines` option is used. This tells `less`
 to truncate any lines larger than the terminal width.

 ### Indentation
@@ -835,6 +843,10 @@ If your version of `bat` supports the `--strip-ansi=auto` option, it can be used
 before syntax highlighting. Alternatively, you may disable both syntax highlighting and wrapping by
 passing the `--color=never --wrap=never` options to `bat`.

+For untrusted input, the `--sanitize=auto|always|never` option additionally replaces terminal-active
+control bytes and Unicode bidi / zero-width formatting characters with the Unicode replacement
+character. It implies `--strip-ansi` at the same value.
+
 > [!NOTE]
 > The `auto` option of `--strip-ansi` avoids removing escape sequences when the syntax is plain text.

@@ -9,17 +9,17 @@ Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -Script
    $ArrayCompletion = @('bash', 'fish', 'zsh', 'ps1')
    $ArrayWhen       = @('auto', 'never', 'always')
    $ArrayYesNo      = @('never', 'always')
-    $ArrayWrap       = @('always', 'never', 'character')
+    $ArrayWrap       = @('always', 'never', 'character', 'word')
    $ArrayBinary     = @('no-printing', 'as-text')
    $ArrayPrint      = @('unicode', 'caret')

    function Get-MyThemes(){
-        $themes = {{PROJECT_EXECUTABLE}} --list-themes | ForEach-Object {$_  -replace "^(.*)$", '''$1'''} | select-object
+        $themes = {{PROJECT_EXECUTABLE}} --no-paging --list-themes | ForEach-Object {$_  -replace "^(.*)$", '''$1'''} | select-object
        return $themes
    }

    function Get-MyLanguages(){
-        $themes = {{PROJECT_EXECUTABLE}} --list-languages | ForEach-Object{[pscustomobject]@{MyParameter=$_.Substring(0,$_.IndexOf(":")).Trim();MyDescription=$_.Substring($_.IndexOf(":")+1)}} | select-object
+        $themes = {{PROJECT_EXECUTABLE}} --no-paging --list-languages | ForEach-Object{[pscustomobject]@{MyParameter=$_.Substring(0,$_.IndexOf(":")).Trim();MyDescription=$_.Substring($_.IndexOf(":")+1)}} | select-object
        return $themes
    }

@@ -49,7 +49,10 @@ Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -Script
        }
        '*;--language' {
            Get-MyLanguages |
-            ForEach-Object {[CompletionResult]::new(($_.MyParameter -replace "^(.*)$", '''$1'''), $_.MyParameter, [CompletionResultType]::ParameterName, $_.MyDescription ?? '_no value_')}
+            ForEach-Object {
+                $desc = if ($null -eq $_.MyDescription) { '_no value_' } else { $_.MyDescription }
+                [CompletionResult]::new(($_.MyParameter -replace "^(.*)$", '''$1'''), $_.MyParameter, [CompletionResultType]::ParameterName, $desc)
+            }
            break
        }
        '*;--theme' {
@@ -97,6 +100,11 @@ Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -Script
            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
            break
        }
+        '*;--sanitize' {
+            $ArrayWhen |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
        '*;--strip-ansi' {
            $ArrayWhen |
            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
@@ -132,7 +140,7 @@ Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -Script
            [CompletionResult]::new('--file-name'             , 'file-name'             , [CompletionResultType]::ParameterName, 'Specify the name to display for a file.')
            [CompletionResult]::new('--diff-context'          , 'diff-context'          , [CompletionResultType]::ParameterName, 'diff-context')
            [CompletionResult]::new('--tabs'                  , 'tabs'                  , [CompletionResultType]::ParameterName, 'Set the tab width to T spaces.')
-            [CompletionResult]::new('--wrap'                  , 'wrap'                  , [CompletionResultType]::ParameterName, 'Specify the text-wrapping mode (*auto*, character).')
+            [CompletionResult]::new('--wrap'                  , 'wrap'                  , [CompletionResultType]::ParameterName, 'Specify the text-wrapping mode (*auto*, never, character, word).')
            [CompletionResult]::new('--terminal-width'        , 'terminal-width'        , [CompletionResultType]::ParameterName, 'Explicitly set the width of the terminal instead of determining it automatically. If prefixed with ''+'' or ''-'', the value will be treated as an offset to the actual terminal width. See also: ''--wrap''.')
            [CompletionResult]::new('--color'                 , 'color'                 , [CompletionResultType]::ParameterName, 'When to use colors (*auto*, never, always).')
            [CompletionResult]::new('--italic-text'           , 'italic-text'           , [CompletionResultType]::ParameterName, 'Use italics in output (always, *never*)')
@@ -155,6 +163,7 @@ Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -Script
            [CompletionResult]::new('--ignored-suffix'        , 'ignored-suffix'        , [CompletionResultType]::ParameterName, 'Ignore extension. For example: ''bat --ignored-suffix ".dev" my_file.json.dev'' will use JSON syntax, and ignore ''.dev''')
            [CompletionResult]::new('--squeeze-blank'         , 'squeeze-blank'         , [CompletionResultType]::ParameterName, 'Squeeze consecutive empty lines into a single empty line.')
            [CompletionResult]::new('--squeeze-limit'         , 'squeeze-limit'         , [CompletionResultType]::ParameterName, 'Set the maximum number of consecutive empty lines to be printed.')
+            [CompletionResult]::new('--sanitize'              , 'sanitize'              , [CompletionResultType]::ParameterName, 'Specify when to sanitize untrusted input for safe display. Implies --strip-ansi and also replaces terminal-active and bidi / zero-width bytes. (auto, always, *never*).')
            [CompletionResult]::new('--strip-ansi'            , 'strip-ansi'            , [CompletionResultType]::ParameterName, 'Specify when to strip ANSI escape sequences from the input. The automatic mode will remove escape sequences unless the syntax highlighting language is plain text. (auto, always, *never*).')
        #   [CompletionResult]::new('-p'                      , 'p'                     , [CompletionResultType]::ParameterName, 'Show plain style (alias for ''--style=plain'').')
            [CompletionResult]::new('--plain'                 , 'plain'                 , [CompletionResultType]::ParameterName, 'Show plain style (alias for ''--style=plain'').')
@@ -170,7 +179,7 @@ Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -Script
        #   [CompletionResult]::new('-L'                      , 'L'                     , [CompletionResultType]::ParameterName, 'Display all supported languages.')
            [CompletionResult]::new('--list-languages'        , 'list-languages'        , [CompletionResultType]::ParameterName, 'Display all supported languages.')
        #   [CompletionResult]::new('-u'                      , 'u'                     , [CompletionResultType]::ParameterName, 'u')
-            [CompletionResult]::new('--unbuffered'            , 'unbuffered'            , [CompletionResultType]::ParameterName, 'unbuffered')
+            [CompletionResult]::new('--unbuffered'            , 'unbuffered'            , [CompletionResultType]::ParameterName, 'Enable unbuffered input reading for streaming use cases')
            [CompletionResult]::new('--completion'            , 'completion'            , [CompletionResultType]::ParameterName, 'Show shell completion for a certain shell. [possible values: bash, fish, zsh, ps1]')
            [CompletionResult]::new('--no-config'             , 'no-config'             , [CompletionResultType]::ParameterName, 'Do not use the configuration file')
            [CompletionResult]::new('--no-custom-assets'      , 'no-custom-assets'      , [CompletionResultType]::ParameterName, 'Do not load custom assets')
@@ -183,6 +192,7 @@ Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -Script
            [CompletionResult]::new('--acknowledgements'      , 'acknowledgements'      , [CompletionResultType]::ParameterName, 'Show acknowledgements.')
            [CompletionResult]::new('--set-terminal-title'    , 'set-terminal-title'    , [CompletionResultType]::ParameterName, 'Sets terminal title to filenames when using a pager.')
            [CompletionResult]::new('--diagnostic'            , 'diagnostic'            , [CompletionResultType]::ParameterName, 'Show diagnostic information for bug reports.')
+            [CompletionResult]::new('--quiet-empty'           , 'quiet-empty'           , [CompletionResultType]::ParameterName, 'Do not produce any output when the input is empty.')
        #   [CompletionResult]::new('-h'                      , 'h'                     , [CompletionResultType]::ParameterName, 'Print this help message.')
            [CompletionResult]::new('--help'                  , 'help'                  , [CompletionResultType]::ParameterName, 'Print this help message.')
        #   [CompletionResult]::new('-V'                      , 'V'                     , [CompletionResultType]::ParameterName, 'Show version information.')
@@ -14,18 +14,36 @@ __bat_escape_completions()
 {
 	# Do not escape if completing a quoted value.
 	[[ $cur == [\"\']* ]] && return 0
-	# printf -v to an array index is available in bash >= 4.1.
-	# Use it if available, as -o filenames is semantically incorrect if
-	# we are not actually completing filenames, and it has side effects
-	# (e.g. adds trailing slash to candidates matching present dirs).
 	if ((
+		BASH_VERSINFO[0] > 5 || \
+		BASH_VERSINFO[0] == 5 && BASH_VERSINFO[1] >= 3
+	)); then
+		# bash >= 5.3 has "compopt -o fullquote", which exactly does
+		# what this function tries to do.
+		compopt -o fullquote
+	elif ((
 		BASH_VERSINFO[0] > 4 || \
 		BASH_VERSINFO[0] == 4 && BASH_VERSINFO[1] > 0
 	)); then
+		# printf -v to an array index is available in bash >= 4.1.
+		# Use it if available, as -o filenames is semantically
+		# incorrect if we are not actually completing filenames, and it
+		# has side effects (e.g. adds trailing slash to candidates
+		# matching present dirs).
 		local i
 		for i in ${!COMPREPLY[*]}; do
 			printf -v "COMPREPLY[i]" %q "${COMPREPLY[i]}"
 		done
+
+		# We can use "compopt -o noquote" available in bash >= 4.3 to
+		# prevent further quoting by the shell, which would be
+		# unexpectedly applied when a quoted result matches a filename.
+		if ((
+			BASH_VERSINFO[0] > 4 || \
+			BASH_VERSINFO[0] == 4 && BASH_VERSINFO[1] >= 3
+		)); then
+			compopt -o noquote
+		fi
 	else
 		compopt -o filenames
 	fi
@@ -62,11 +80,11 @@ _bat() {
 	-l | --language)
 		local IFS=$'\n'
 		COMPREPLY=($(compgen -W "$(
-			"$1" --list-languages | while IFS=: read -r lang _; do
+			"$1" --no-paging --list-languages | while IFS=: read -r lang _; do
 				printf "%s\n" "$lang"
 			done
 		)" -- "$cur"))
-                __bat_escape_completions
+		__bat_escape_completions
 		return 0
 		;;
 	-H | --highlight-line | \
@@ -82,6 +100,7 @@ _bat() {
 	--lessopen | \
 	--no-paging | \
 	--diagnostic | \
+	--quiet-empty | \
 	--acknowledgements | \
 	-h | --help | \
 	-V | --version | \
@@ -98,7 +117,7 @@ _bat() {
 		return 0
 		;;
 	--wrap)
-		COMPREPLY=($(compgen -W "auto never character" -- "$cur"))
+		COMPREPLY=($(compgen -W "auto never character word" -- "$cur"))
 		return 0
 		;;
 	--binary)
@@ -113,6 +132,10 @@ _bat() {
 		COMPREPLY=($(compgen -W "auto never always" -- "$cur"))
 		return 0
 		;;
+	--sanitize)
+		COMPREPLY=($(compgen -W "auto never always" -- "$cur"))
+		return 0
+		;;
 	--completion)
 		COMPREPLY=($(compgen -W "bash fish zsh ps1" -- "$cur"))
 		return 0
@@ -130,16 +153,16 @@ _bat() {
 		return 0
 		;;
 	--theme)
-    	local IFS=$'\n'
-    	COMPREPLY=($(compgen -W "auto${IFS}auto:always${IFS}auto:system${IFS}dark${IFS}light${IFS}$("$1" --list-themes)" -- "$cur"))
-                    __bat_escape_completions
-    	return 0
-    	;;
+		local IFS=$'\n'
+		COMPREPLY=($(compgen -W "auto${IFS}auto:always${IFS}auto:system${IFS}dark${IFS}light${IFS}$("$1" --no-paging --list-themes)" -- "$cur"))
+		__bat_escape_completions
+		return 0
+		;;
 	--theme-dark | \
 	--theme-light)
 		local IFS=$'\n'
-		COMPREPLY=($(compgen -W "$("$1" --list-themes)" -- "$cur"))
-                __bat_escape_completions
+		COMPREPLY=($(compgen -W "$("$1" --no-paging --list-themes)" -- "$cur"))
+		__bat_escape_completions
 		return 0
 		;;
 	--style)
@@ -158,7 +181,7 @@ _bat() {
 			numbers
 			snip
 		)
-                # shellcheck disable=SC2016
+		# shellcheck disable=SC2016
 		if declare -F _comp_delimited >/dev/null 2>&1; then
 			# bash-completion > 2.11
 			_comp_delimited , -W '"${styles[@]}"'
@@ -171,8 +194,8 @@ _bat() {
 	$split && return 0

 	if [[ $cur == -* ]]; then
-		# --unbuffered excluded intentionally (no-op)
 		COMPREPLY=($(compgen -W "
+			--unbuffered
 			--show-all
 			--nonprintable-notation
 			--binary
@@ -202,6 +225,7 @@ _bat() {
 			--list-themes
 			--squeeze-blank
 			--squeeze-limit
+			--sanitize
 			--strip-ansi
 			--style
 			--line-range
@@ -209,6 +233,7 @@ _bat() {
 			--lessopen
 			--completion
 			--diagnostic
+			--quiet-empty
 			--acknowledgements
 			--set-terminal-title
 			--help
@@ -15,11 +15,11 @@ function __bat_complete_files -a token
 end

 function __bat_complete_one_language -a comp
-    command $bat --list-languages | string split -f1 : | string match -e "$comp"
+    command $bat --no-paging --list-languages | string split -f1 : | string match -e "$comp"
 end

 function __bat_complete_list_languages
-    for spec in (command $bat --list-languages)
+    for spec in (command $bat --no-paging --list-languages)
        set -l name (string split -f1 : $spec)
        for ext in (string split -f2 : $spec | string split ,)
            test -n "$ext"; or continue
@@ -61,7 +61,7 @@ function __bat_no_excl_args
        -s V -l version \
        -l acknowledgements \
        -l config-dir -l config-file \
-        -l diagnostic \
+        -l diagnostic -l quiet-empty \
        -l list-languages -l list-themes
 end

@@ -118,6 +118,7 @@ set -l wrap_opts '
    auto\tdefault
    never\t
    character\t
+    word\t
 '

 # While --tabs theoretically takes any number, most people should be OK with these.
@@ -159,6 +160,7 @@ complete -c $bat -l config-file -f -d "Display location of configuration file" -
 complete -c $bat -l decorations -x -a "$decorations_opts" -d "When to use --style decorations" -n __bat_no_excl_args

 complete -c $bat -l diagnostic -d "Print diagnostic info for bug reports" -n __fish_is_first_arg
+complete -c $bat -l quiet-empty -d "Do not produce any output when the input is empty" -n __fish_is_first_arg

 complete -c $bat -s d -l diff -d "Only show lines with Git changes" -n __bat_no_excl_args

@@ -219,6 +221,7 @@ complete -c $bat -s s -l squeeze-blank -d "Squeeze consecutive empty lines into
 complete -c $bat -l squeeze-limit -x -d "Set the maximum number of consecutive empty lines to be printed" -n __bat_no_excl_args

 complete -c $bat -l strip-ansi -x -a "auto never always" -d "Specify when to strip ANSI escape sequences from the input" -n __bat_no_excl_args
+complete -c $bat -l sanitize -x -a "auto never always" -d "Specify when to sanitize untrusted input for safe display" -n __bat_no_excl_args

 complete -c $bat -s p -l plain -d "Disable decorations" -n __bat_no_excl_args

@@ -232,13 +235,13 @@ complete -c $bat -l tabs -x -a "$tabs_opts" -d "Set tab width" -n __bat_no_excl_

 complete -c $bat -l terminal-width -x -d "Set terminal <width>, +<offset>, or -<offset>" -n __bat_no_excl_args

-complete -c $bat -l theme -x -a "$special_themes(command $bat --list-themes | command cat)" -d "Set the syntax highlighting theme" -n __bat_no_excl_args
+complete -c $bat -l theme -x -a "$special_themes(command $bat --no-paging --list-themes | command cat)" -d "Set the syntax highlighting theme" -n __bat_no_excl_args

-complete -c $bat -l theme-dark -x -a "(command $bat --list-themes | command cat)" -d "Set the syntax highlighting theme for dark backgrounds" -n __bat_no_excl_args
+complete -c $bat -l theme-dark -x -a "(command $bat --no-paging --list-themes | command cat)" -d "Set the syntax highlighting theme for dark backgrounds" -n __bat_no_excl_args

-complete -c $bat -l theme-light -x -a "(command $bat --list-themes | command cat)" -d "Set the syntax highlighting theme for light backgrounds" -n __bat_no_excl_args
+complete -c $bat -l theme-light -x -a "(command $bat --no-paging --list-themes | command cat)" -d "Set the syntax highlighting theme for light backgrounds" -n __bat_no_excl_args

-complete -c $bat -s u -l unbuffered -d "This option exists for POSIX-compliance reasons" -n __bat_no_excl_args
+complete -c $bat -s u -l unbuffered -d "Enable unbuffered input reading for streaming use cases" -n __bat_no_excl_args

 complete -c $bat -s V -l version -f -d "Show version information" -n __fish_is_first_arg

@@ -34,7 +34,7 @@ _{{PROJECT_EXECUTABLE}}_main() {
        '(-d --diff)'--diff'[only show lines that have been added/removed/modified]'
        --diff-context='[specify lines of context around added/removed/modified lines when using `--diff`]:lines'
        --tabs='[set the tab width]:tab width [4]'
-        --wrap='[specify the text-wrapping mode]:mode [auto]:(auto never character)'
+        --wrap='[specify the text-wrapping mode]:mode [auto]:(auto never character word)'
        '!(--wrap)'{-S,--chop-long-lines}
        --terminal-width='[explicitly set the width of the terminal instead of determining it automatically]:width'
        '(-n --number --diff --diff-context)'{-n,--number}'[show line numbers]'
@@ -54,14 +54,16 @@ _{{PROJECT_EXECUTABLE}}_main() {
        --squeeze-blank'[squeeze consecutive empty lines into a single empty line]'
        --squeeze-limit='[set the maximum number of consecutive empty lines]:limit:'
        --strip-ansi='[specify when to strip ANSI escape sequences]:when:(auto never always)'
+        --sanitize='[specify when to sanitize untrusted input for safe display]:when:(auto never always)'
        --style='[comma-separated list of style elements to display]: : _values "style [default]"
            default auto full plain changes header header-filename header-filesize grid rule numbers snip'
        \*{-r+,--line-range=}'[only print the specified line range]:start\:end'
        '(* -)'{-L,--list-languages}'[display all supported languages]'
-        '(-u --unbuffered)'--unbuffered'[this option exists for POSIX-compliance reasons]'
+        '(-u --unbuffered)'--unbuffered'[enable unbuffered input reading for streaming use cases]'
        --completion='[show shell completion for a certain shell]:shell:(bash fish zsh ps1)'
        --set-terminal-title'[sets terminal title to filenames when using a pager]'
        --diagnostic'[show diagnostic information for bug reports]'
+        --quiet-empty'[do not produce any output when the input is empty]'
        -P'[disable paging]'
        "--no-config[don't use the configuration file]"
        "--no-custom-assets[don't load custom assets]"
@@ -89,20 +91,25 @@ _{{PROJECT_EXECUTABLE}}_main() {
        languages)
            local IFS=$'\n'
            local -a languages
-            languages=( $({{PROJECT_EXECUTABLE}} --list-languages | awk -F':|,' '{ for (i = 1; i <= NF; ++i) printf("%s:%s\n", $i, $1) }') )
+            # `--list-languages` emits one `name:matchers` line per language,
+            # which `_describe` parses as `value:description`. Only the
+            # language name is offered as the completion value; the matchers
+            # show up as the menu description. See
+            # https://github.com/sharkdp/bat/issues/3735.
+            languages=( ${(f)"$({{PROJECT_EXECUTABLE}} --no-paging --color=never --decorations=never --list-languages)"} )

            _describe 'language' languages && ret=0
        ;;

        themes)
            local -a themes expl
-            themes=(${(f)"$(_call_program themes {{PROJECT_EXECUTABLE}} --list-themes)"} )
+            themes=(${(f)"$(_call_program themes {{PROJECT_EXECUTABLE}} --no-paging --color=never --decorations=never --list-themes)"} )

            _wanted themes expl 'theme' compadd -a themes && ret=0
        ;;
        theme_preferences)
            local -a themes expl
-            themes=(auto dark light auto:always auto:system ${(f)"$(_call_program themes {{PROJECT_EXECUTABLE}} --list-themes)"} )
+            themes=(auto dark light auto:always auto:system ${(f)"$(_call_program themes {{PROJECT_EXECUTABLE}} --no-paging --color=never --decorations=never --list-themes)"} )

            _wanted themes expl 'theme' compadd -a themes && ret=0
        ;;
@@ -102,8 +102,10 @@ Set the tab width to T spaces. Use a width of 0 to pass tabs through directly
 .HP
 \fB\-\-wrap\fR <mode>
 .IP
-Specify the text\-wrapping mode (*auto*, never, character). The '\-\-terminal\-width' option
-can be used in addition to control the output width.
+Specify the text\-wrapping mode (*auto*, never, character, word). The '\-\-terminal\-width' option
+can be used in addition to control the output width. In \fBword\fR mode, lines are broken at
+whitespace boundaries. If a single word exceeds the terminal width, it falls back to
+character wrapping.
 .HP
 \fB\-S\fR, \fB\-\-chop\-long\-lines\fR
 .IP
@@ -263,8 +265,10 @@ Display a list of supported languages for syntax highlighting.
 .HP
 \fB\-u\fR, \fB\-\-unbuffered\fR
 .IP
-This option exists for POSIX\-compliance reasons ('u' is for 'unbuffered'). The output is
-always unbuffered \- this option is simply ignored.
+Enable unbuffered input reading. When this flag is set, bat will display data as soon as it
+is available, without waiting for a complete line. This is useful for streaming use cases like
+\&'tail \-f logfile | bat \-u \-\-paging=never'. Note that line numbers are automatically disabled
+in unbuffered mode, and syntax highlighting may be imperfect on partial lines.
 .HP
 \fB\-\-no\-custom\-assets\fR
 .IP
@@ -282,6 +286,10 @@ Show bat's cache directory.
 .IP
 Show diagnostic information for bug reports.
 .HP
+\fB\-\-quiet\-empty\fR
+.IP
+Do not produce any output when the input is empty (e.g. an empty file or empty stdin). This is useful in scripts where silent behavior is preferred for empty input.
+.HP
 \fB\-\-acknowledgements\fR
 .IP
 Show acknowledgements.
@@ -2,6 +2,15 @@ diff --git syntaxes/01_Packages/Python/Python.sublime-syntax syntaxes/01_Package
 index 2acd86d8..86257f7b 100644
 --- syntaxes/01_Packages/Python/Python.sublime-syntax
 +++ syntaxes/01_Packages/Python/Python.sublime-syntax
+@@ -25,7 +31,7 @@ file_extensions:
+   - wscript
+   - bazel
+   - bzl
+-first_line_match: ^#!\s*/.*\bpython(\d(\.\d)?)?\b
+first_line_match: ^#!\s*/.*\b(python(\d(\.\d)?)?|uv)\b
+ scope: source.python
+
+ variables:
@@ -988,10 +988,6 @@ contexts:
         - match: \}
           scope: punctuation.section.mapping-or-set.end.python
@@ -14,7 +14,7 @@ index e973e319..07c170a7 100644
 first_line_match: |
   (?x)
 -    ^\#! .* \b(bash|zsh|sh|tcsh|ash)\b
-+    ^\#! .* \b(bash|zsh|sh|tcsh|ash|dash)\b
+    ^\#! .* \b(bash|zsh|sh|tcsh|ash|dash|ksh)\b
   | ^\# \s* -\*- [^*]* mode: \s* shell-script [^*]* -\*-
 
 #-------------------------------------------------------------------------------
@@ -0,0 +1,12 @@
+diff --git syntaxes/01_Packages/TCL/Tcl.sublime-syntax syntaxes/01_Packages/TCL/Tcl.sublime-syntax
+index 1234567..abcdefg 100644
+--- syntaxes/01_Packages/TCL/Tcl.sublime-syntax
+++ syntaxes/01_Packages/TCL/Tcl.sublime-syntax
+@@ -3,6 +3,7 @@
+ # http://www.sublimetext.com/docs/3/syntax.html
+ name: Tcl
+ file_extensions:
+   - tcl
+first_line_match: ^\#!.*\b(tclsh|wish|expect)\b
+ scope: source.tcl
+ variables:
@@ -79,7 +79,7 @@ contexts:

  double_quoted_string:
    - meta_include_prototype: false
-    - meta_scope: string.quoted.double.csv
+    - meta_scope: meta.string.quoted.double.csv
    - match: '""'
      scope: constant.character.escape.csv
    - match: '"'
@@ -1,398 +0,0 @@
-%YAML 1.2
---
-# http://www.sublimetext.com/docs/3/syntax.html
-name: Kotlin
-file_extensions:
-  - kt
-  - kts
-scope: source.Kotlin
-contexts:
-  main:
-    - include: comments
-    - match: '^\s*(package)\b(?:\s*([^ ;$]+)\s*)?'
-      captures:
-        1: keyword.other.kotlin
-        2: entity.name.package.kotlin
-    - include: imports
-    - include: statements
-  classes:
-    - match: (?<!::)(?=\b(?:companion|class|object|interface)\b)
-      push:
-        - match: '(?=$|\})'
-          pop: true
-        - include: comments
-        - match: \b(companion\s*)?(class|object|interface)\b
-          captures:
-            1: storage.modifier.kotlin
-            2: storage.modifier.kotlin
-          push:
-            - match: '(?=<|\{|\(|:|$)'
-              pop: true
-            - include: comments
-            - match: \w+
-              scope: entity.name.type.class.kotlin
-        - match: <
-          push:
-            - match: ">"
-              pop: true
-            - include: generics
-        - match: \(
-          push:
-            - match: \)
-              pop: true
-            - include: parameters
-        - match: (:)
-          captures:
-            1: keyword.operator.declaration.kotlin
-          push:
-            - match: "(?={|$)"
-              pop: true
-            - match: \w+
-              scope: entity.other.inherited-class.kotlin
-            - match: \(
-              push:
-                - match: \)
-                  pop: true
-                - include: expressions
-        - match: '\{'
-          push:
-            - match: '\}'
-              pop: true
-            - include: statements
-  comments:
-    - match: /\*
-      captures:
-        0: punctuation.definition.comment.kotlin
-      push:
-        - meta_scope: comment.block.kotlin
-        - match: \*/
-          captures:
-            0: punctuation.definition.comment.kotlin
-          pop: true
-    - match: \s*((//).*$\n?)
-      captures:
-        1: comment.line.double-slash.kotlin
-        2: punctuation.definition.comment.kotlin
-  constants:
-    - match: \b(true|false|null|this|super)\b
-      scope: constant.language.kotlin
-    - match: '\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)([LlFf])?\b'
-      scope: constant.numeric.kotlin
-    - match: '\b([A-Z][A-Z0-9_]+)\b'
-      scope: constant.other.kotlin
-  expressions:
-    - match: \(
-      push:
-        - match: \)
-          pop: true
-        - include: expressions
-    - include: types
-    - include: strings
-    - include: constants
-    - include: comments
-    - include: keywords
-  functions:
-    - match: (?=\s*\b(?:fun)\b)
-      push:
-        - match: '(?=$|\})'
-          pop: true
-        - match: \b(fun)\b
-          captures:
-            1: keyword.other.kotlin
-          push:
-            - match: (?=\()
-              pop: true
-            - match: <
-              push:
-                - match: ">"
-                  pop: true
-                - include: generics
-            - match: '([\.<\?>\w]+\.)?(\w+)'
-              captures:
-                2: entity.name.function.kotlin
-        - match: \(
-          push:
-            - match: \)
-              pop: true
-            - include: parameters
-        - match: (:)
-          captures:
-            1: keyword.operator.declaration.kotlin
-          push:
-            - match: "(?={|=|$)"
-              pop: true
-            - include: types
-        - match: '\{'
-          push:
-            - match: '(?=\})'
-              pop: true
-            - include: statements
-        - match: (=)
-          captures:
-            1: keyword.operator.assignment.kotlin
-          push:
-            - match: (?=$)
-              pop: true
-            - include: expressions
-  generics:
-    - match: (:)
-      captures:
-        1: keyword.operator.declaration.kotlin
-      push:
-        - match: (?=,|>)
-          pop: true
-        - include: types
-    - include: keywords
-    - match: \w+
-      scope: storage.type.generic.kotlin
-  getters-and-setters:
-    - match: \b(get)\b\s*\(\s*\)
-      captures:
-        1: entity.name.function.kotlin
-      push:
-        - match: '\}|(?=\bset\b)|$'
-          pop: true
-        - match: (=)
-          captures:
-            1: keyword.operator.assignment.kotlin
-          push:
-            - match: (?=$|\bset\b)
-              pop: true
-            - include: expressions
-        - match: '\{'
-          push:
-            - match: '\}'
-              pop: true
-            - include: expressions
-    - match: \b(set)\b\s*(?=\()
-      captures:
-        1: entity.name.function.kotlin
-      push:
-        - match: '\}|(?=\bget\b)|$'
-          pop: true
-        - match: \(
-          push:
-            - match: \)
-              pop: true
-            - include: parameters
-        - match: (=)
-          captures:
-            1: keyword.operator.assignment.kotlin
-          push:
-            - match: (?=$|\bset\b)
-              pop: true
-            - include: expressions
-        - match: '\{'
-          push:
-            - match: '\}'
-              pop: true
-            - include: expressions
-  imports:
-    - match: '^\s*(import)\s+[^ $]+\s+(as)?'
-      captures:
-        1: keyword.other.kotlin
-        2: keyword.other.kotlin
-  keywords:
-    - match: \b(var|val|public|private|protected|abstract|final|sealed|enum|open|attribute|annotation|override|inline|vararg|in|out|internal|data|tailrec|operator|infix|const|yield|typealias|typeof|reified|suspend)\b
-      scope: storage.modifier.kotlin
-    - match: \b(try|catch|finally|throw)\b
-      scope: keyword.control.catch-exception.kotlin
-    - match: \b(if|else|while|for|do|return|when|where|break|continue)\b
-      scope: keyword.control.kotlin
-    - match: \b(in|is|!in|!is|as|as\?|assert)\b
-      scope: keyword.operator.kotlin
-    - match: (==|!=|===|!==|<=|>=|<|>)
-      scope: keyword.operator.comparison.kotlin
-    - match: (=)
-      scope: keyword.operator.assignment.kotlin
-    - match: (::)
-      scope: keyword.operator.kotlin
-    - match: (:)
-      scope: keyword.operator.declaration.kotlin
-    - match: \b(by)\b
-      scope: keyword.other.by.kotlin
-    - match: (\?\.)
-      scope: keyword.operator.safenav.kotlin
-    - match: (\.)
-      scope: keyword.operator.dot.kotlin
-    - match: (\?:)
-      scope: keyword.operator.elvis.kotlin
-    - match: (\-\-|\+\+)
-      scope: keyword.operator.increment-decrement.kotlin
-    - match: (\+=|\-=|\*=|\/=)
-      scope: keyword.operator.arithmetic.assign.kotlin
-    - match: (\.\.)
-      scope: keyword.operator.range.kotlin
-    - match: (\-|\+|\*|\/|%)
-      scope: keyword.operator.arithmetic.kotlin
-    - match: (!|&&|\|\|)
-      scope: keyword.operator.logical.kotlin
-    - match: (;)
-      scope: punctuation.terminator.kotlin
-  namespaces:
-    - match: \b(namespace)\b
-      scope: keyword.other.kotlin
-    - match: '\{'
-      push:
-        - match: '\}'
-          pop: true
-        - include: statements
-  parameters:
-    - match: (:)
-      captures:
-        1: keyword.operator.declaration.kotlin
-      push:
-        - match: (?=,|\)|=)
-          pop: true
-        - include: types
-    - match: (=)
-      captures:
-        1: keyword.operator.declaration.kotlin
-      push:
-        - match: (?=,|\))
-          pop: true
-        - include: expressions
-    - include: keywords
-    - match: \w+
-      scope: variable.parameter.function.kotlin
-  statements:
-    - include: namespaces
-    - include: typedefs
-    - include: classes
-    - include: functions
-    - include: variables
-    - include: getters-and-setters
-    - include: expressions
-  strings:
-    - match: '"""'
-      captures:
-        0: punctuation.definition.string.begin.kotlin
-      push:
-        - meta_scope: string.quoted.third.kotlin
-        - match: '"""'
-          captures:
-            0: punctuation.definition.string.end.kotlin
-          pop: true
-        - match: '(\$\w+|\$\{[^\}]+\})'
-          scope: variable.parameter.template.kotlin
-        - match: \\.
-          scope: constant.character.escape.kotlin
-    - match: '"'
-      captures:
-        0: punctuation.definition.string.begin.kotlin
-      push:
-        - meta_scope: string.quoted.double.kotlin
-        - match: '"'
-          captures:
-            0: punctuation.definition.string.end.kotlin
-          pop: true
-        - match: '(\$\w+|\$\{[^\}]+\})'
-          scope: variable.parameter.template.kotlin
-        - match: \\.
-          scope: constant.character.escape.kotlin
-    - match: "'"
-      captures:
-        0: punctuation.definition.string.begin.kotlin
-      push:
-        - meta_scope: string.quoted.single.kotlin
-        - match: "'"
-          captures:
-            0: punctuation.definition.string.end.kotlin
-          pop: true
-        - match: \\.
-          scope: constant.character.escape.kotlin
-    - match: "`"
-      captures:
-        0: punctuation.definition.string.begin.kotlin
-      push:
-        - meta_scope: string.quoted.single.kotlin
-        - match: "`"
-          captures:
-            0: punctuation.definition.string.end.kotlin
-          pop: true
-  typedefs:
-    - match: (?=\s*(?:type))
-      push:
-        - match: (?=$)
-          pop: true
-        - match: \b(type)\b
-          scope: keyword.other.kotlin
-        - match: <
-          push:
-            - match: ">"
-              pop: true
-            - include: generics
-        - include: expressions
-  types:
-    - match: \b(Nothing|Any|Unit|String|CharSequence|Int|Boolean|Char|Long|Double|Float|Short|Byte|dynamic)\b
-      scope: storage.type.buildin.kotlin
-    - match: \b(IntArray|BooleanArray|CharArray|LongArray|DoubleArray|FloatArray|ShortArray|ByteArray)\b
-      scope: storage.type.buildin.array.kotlin
-    - match: \b(Array|Collection|List|Map|Set|MutableList|MutableMap|MutableSet|Sequence)<\b
-      captures:
-        1: storage.type.buildin.collection.kotlin
-      push:
-        - match: ">"
-          pop: true
-        - include: types
-        - include: keywords
-    - match: \w+<
-      push:
-        - match: ">"
-          pop: true
-        - include: types
-        - include: keywords
-    - match: '\{'
-      push:
-        - match: '\}'
-          pop: true
-        - include: statements
-    - match: \(
-      push:
-        - match: \)
-          pop: true
-        - include: types
-    - match: (->)
-      scope: keyword.operator.declaration.kotlin
-  variables:
-    - match: (?=\s*\b(?:var|val)\b)
-      push:
-        - match: (?=:|=|(\b(by)\b)|$)
-          pop: true
-        - match: \b(var|val)\b
-          captures:
-            1: keyword.other.kotlin
-          push:
-            - match: (?=:|=|(\b(by)\b)|$)
-              pop: true
-            - match: <
-              push:
-                - match: ">"
-                  pop: true
-                - include: generics
-            - match: '([\.<\?>\w]+\.)?(\w+)'
-              captures:
-                2: entity.name.variable.kotlin
-        - match: (:)
-          captures:
-            1: keyword.operator.declaration.kotlin
-          push:
-            - match: (?==|$)
-              pop: true
-            - include: types
-            - include: getters-and-setters
-        - match: \b(by)\b
-          captures:
-            1: keyword.other.kotlin
-          push:
-            - match: (?=$)
-              pop: true
-            - include: expressions
-        - match: (=)
-          captures:
-            1: keyword.operator.assignment.kotlin
-          push:
-            - match: (?=$)
-              pop: true
-            - include: expressions
-            - include: getters-and-setters
@@ -9,6 +9,7 @@ scope: source.man
 variables:
  section_heading: '^(?!#)\S.*$'
  command_line_option: '(--?[A-Za-z0-9][_A-Za-z0-9-]*)'
+  ansi_escape_sequence: '\e\[[\?=]?(?:\d+;?)*[A-Za-z]'

 contexts:
  prototype:
@@ -69,7 +70,7 @@ contexts:
      escape: '(?={{section_heading}})'

  function-call:
-    - match: '\b([A-Za-z0-9_\-]+\.)?([A-Za-z0-9_\-]+)(\()([^)]*)(\))'
+    - match: '(?<!\e\[)(?:\b|\s)(?:{{ansi_escape_sequence}})?([A-Za-z0-9_\-]+\.)?([A-Za-z0-9_\-]+)(?:{{ansi_escape_sequence}})?(\()([^)]*)(\))'
      captures:
        1: entity.name.function.man
        2: entity.name.function.man
@@ -47,12 +47,49 @@ impl ToTokens for MappingTarget {
    }
 }

-#[derive(Clone, Debug, PartialEq, Eq, Hash, DeserializeFromStr)]
+/// Helper type for deserializing a `Matcher` from either a plain string or a
+/// `{ glob = "...", case_sensitive = true }` struct.
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum RawMatcher {
+    Simple(String),
+    Full {
+        glob: String,
+        case_sensitive: Option<bool>,
+    },
+}
+
+/// Whether a glob pattern should be matched case-sensitively or case-insensitively.
+///
+/// Mirrors the runtime `Case` type in `src/syntax_mapping.rs`.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+enum Case {
+    Sensitive,
+    Insensitive,
+}
+impl ToTokens for Case {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let t = match self {
+            Self::Sensitive => quote! { Case::Sensitive },
+            Self::Insensitive => quote! { Case::Insensitive },
+        };
+        tokens.append_all(t);
+    }
+}
+
 /// A single matcher.
 ///
 /// Codegen converts this into a `Lazy<Option<GlobMatcher>>`.
-struct Matcher(Vec<MatcherSegment>);
-/// Parse a matcher.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize)]
+#[serde(try_from = "RawMatcher")]
+struct Matcher {
+    segments: Vec<MatcherSegment>,
+    /// Whether the glob pattern should be matched case-sensitively.
+    ///
+    /// Defaults to `Case::Insensitive` for backwards compatibility.
+    case: Case,
+}
+/// Parse the glob pattern of a matcher.
 ///
 /// Note that this implementation is rather strict: it will greedily interpret
 /// every valid environment variable replacement as such, then immediately
@@ -66,68 +103,95 @@ struct Matcher(Vec<MatcherSegment>);
 ///
 /// Revision history:
 /// - 2024-02-20: allow `{` and `}` (glob brace expansion)
-impl FromStr for Matcher {
-    type Err = anyhow::Error;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        use MatcherSegment as Seg;
-        static VAR_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"\$\{([\w\d_]+)\}").unwrap());
+fn parse_glob(s: &str) -> Result<Vec<MatcherSegment>, anyhow::Error> {
+    use MatcherSegment as Seg;
+    static VAR_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"\$\{([\w\d_]+)\}").unwrap());

-        let mut segments = vec![];
-        let mut text_start = 0;
-        for capture in VAR_REGEX.captures_iter(s) {
-            let match_0 = capture.get(0).unwrap();
+    let mut segments = vec![];
+    let mut text_start = 0;
+    for capture in VAR_REGEX.captures_iter(s) {
+        let match_0 = capture.get(0).unwrap();

-            // text before this var
-            let text_end = match_0.start();
-            segments.push(Seg::Text(s[text_start..text_end].into()));
-            text_start = match_0.end();
+        // text before this var
+        let text_end = match_0.start();
+        segments.push(Seg::Text(s[text_start..text_end].into()));
+        text_start = match_0.end();

-            // this var
-            segments.push(Seg::Env(capture.get(1).unwrap().as_str().into()));
+        // this var
+        segments.push(Seg::Env(capture.get(1).unwrap().as_str().into()));
+    }
+    // possible trailing text
+    segments.push(Seg::Text(s[text_start..].into()));
+
+    // cleanup empty text segments
+    let non_empty_segments = segments
+        .into_iter()
+        .filter(|seg| seg.text().map(|t| !t.is_empty()).unwrap_or(true))
+        .collect_vec();
+
+    // sanity check
+    if non_empty_segments
+        .windows(2)
+        .any(|segs| segs[0].is_text() && segs[1].is_text())
+    {
+        unreachable!("Parsed into consecutive text segments: {non_empty_segments:?}");
+    }
+
+    // guard empty case
+    if non_empty_segments.is_empty() {
+        bail!(r#"Parsed an empty matcher: "{s}""#);
+    }
+
+    // guard variable syntax leftover fragments
+    if non_empty_segments
+        .iter()
+        .filter_map(Seg::text)
+        .any(|t| t.contains('$'))
+    {
+        bail!(r#"Invalid matcher: "{s}""#);
+    }
+
+    Ok(non_empty_segments)
+}
+impl TryFrom<RawMatcher> for Matcher {
+    type Error = anyhow::Error;
+    fn try_from(raw: RawMatcher) -> Result<Self, Self::Error> {
+        const DEFAULT_CASE: Case = Case::Insensitive;
+        match &raw {
+            RawMatcher::Simple(s) => {
+                let segments = parse_glob(s)?;
+                Ok(Self {
+                    segments,
+                    case: DEFAULT_CASE,
+                })
+            }
+            RawMatcher::Full {
+                glob,
+                case_sensitive,
+            } => {
+                let segments = parse_glob(glob)?;
+                let case = match case_sensitive {
+                    None => DEFAULT_CASE,
+                    Some(false) => Case::Insensitive,
+                    Some(true) => Case::Sensitive,
+                };
+                Ok(Self { segments, case })
+            }
        }
-        // possible trailing text
-        segments.push(Seg::Text(s[text_start..].into()));
-
-        // cleanup empty text segments
-        let non_empty_segments = segments
-            .into_iter()
-            .filter(|seg| seg.text().map(|t| !t.is_empty()).unwrap_or(true))
-            .collect_vec();
-
-        // sanity check
-        if non_empty_segments
-            .windows(2)
-            .any(|segs| segs[0].is_text() && segs[1].is_text())
-        {
-            unreachable!("Parsed into consecutive text segments: {non_empty_segments:?}");
-        }
-
-        // guard empty case
-        if non_empty_segments.is_empty() {
-            bail!(r#"Parsed an empty matcher: "{s}""#);
-        }
-
-        // guard variable syntax leftover fragments
-        if non_empty_segments
-            .iter()
-            .filter_map(Seg::text)
-            .any(|t| t.contains('$'))
-        {
-            bail!(r#"Invalid matcher: "{s}""#);
-        }
-
-        Ok(Self(non_empty_segments))
    }
 }
 impl ToTokens for Matcher {
    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let t = match self.0.as_slice() {
+        let case = &self.case;
+        let t = match self.segments.as_slice() {
            [] => unreachable!("0-length matcher should never be created"),
            [MatcherSegment::Text(text)] => {
-                quote! { Lazy::new(|| Some(build_matcher_fixed(#text))) }
+                quote! { Lazy::new(|| Some(build_matcher_fixed(#text, #case))) }
            }
            // parser logic ensures that this case can only happen when there are dynamic segments
-            segs @ [_, ..] => quote! { Lazy::new(|| build_matcher_dynamic(&[ #(#segs),* ])) },
+            segs @ [_, ..] => {
+                quote! { Lazy::new(|| build_matcher_dynamic(&[ #(#segs),* ], #case)) }
+            }
        };
        tokens.append_all(t);
    }
@@ -175,6 +239,7 @@ impl MatcherSegment {
 /// A struct that models a single .toml file in /src/syntax_mapping/builtins/.
 #[derive(Clone, Debug, Deserialize)]
 struct MappingDefModel {
+    #[serde(default)]
    mappings: IndexMap<MappingTarget, Vec<Matcher>>,
 }
 impl MappingDefModel {
@@ -6,12 +6,12 @@ if you are not looking for a program like `bat`, this comparison might not be fo

 |                                              | bat                                                                 | [pygments](http://pygments.org/) | [highlight](http://www.andre-simon.de/doku/highlight/highlight.php) | [ccat](https://github.com/jingweno/ccat) | [source-highlight](https://www.gnu.org/software/src-highlite/) | [hicat](https://github.com/rstacruz/hicat)          | [coderay](https://github.com/rubychan/coderay)      | [rouge](https://github.com/jneen/rouge)             | [clp](https://github.com/jpe90/clp)      |
 |----------------------------------------------|---------------------------------------------------------------------|----------------------------------|---------------------------------------------------------------------|------------------------------------------|----------------------------------------------------------------|-----------------------------------------------------|-----------------------------------------------------|-----------------------------------------------------|-----------------------------------------------------|
-| Drop-in `cat` replacement                    | :heavy_check_mark: [*](https://github.com/sharkdp/bat/issues/134)   | :x:                              | :x:                                                                 | (:heavy_check_mark:)                     | :x:                                                            | :x: [*](https://github.com/rstacruz/hicat/issues/6) | :x:                                                 | :x:                                                 | :x:                                                                 |
+| Drop-in `cat` replacement                    | :heavy_check_mark:&nbsp;[*](https://github.com/sharkdp/bat/issues/134)   | :x:                              | :x:                                                                 | (✔️)                     | :x:                                                            | :x:&nbsp;[*](https://github.com/rstacruz/hicat/issues/6) | :x:                                                 | :x:                                                 | :x:                                                                 |
 | Git integration                              | :heavy_check_mark:                                                  | :x:                              | :x:                                                                 | :x:                                      | :x:                                                            | :x:                                                 | :x:                                                 | :x:                                                 | :x:                                                                 |
 | Automatic paging                             | :heavy_check_mark:                                                  | :x:                              | :x:                                                                 | :x:                                      | :x:                                                            | :heavy_check_mark:                                  | :x:                                                 | :x:                                                 | :x:                                                                 |
 | Languages (circa)                            | 150                                                                 | 300                              | 200                                                                 | 7                                        | 80                                                             | 130                                                 | 30                                                  | 130                                                 | 150                                                 |
-| Extensible (languages, themes)               | :heavy_check_mark:                                                  | (:heavy_check_mark:)             | (:heavy_check_mark:)                                                | :x:                                      | (:heavy_check_mark:)                                           | :x:                                                 | :x:                                                 | :x:                                                 | :heavy_check_mark:                                                 |
-| Advanced highlighting (e.g. nested syntaxes) | :heavy_check_mark:                                                  | :heavy_check_mark:               | (:heavy_check_mark:) ?                                              | :x:                                      | :heavy_check_mark:                                             | :heavy_check_mark:                                  | :heavy_check_mark:                                  | :heavy_check_mark:                                  | :heavy_check_mark:                                  |
+| Extensible (languages, themes)               | :heavy_check_mark:                                                  | (✔️)             | (✔️)                                                | :x:                                      | (✔️)                                           | :x:                                                 | :x:                                                 | :x:                                                 | :heavy_check_mark:                                                 |
+| Advanced highlighting (e.g. nested syntaxes) | :heavy_check_mark:                                                  | :heavy_check_mark:               | (✔️) ?                                              | :x:                                      | :heavy_check_mark:                                             | :heavy_check_mark:                                  | :heavy_check_mark:                                  | :heavy_check_mark:                                  | :heavy_check_mark:                                  |
 | Execution time [ms] (`jquery-3.3.1.js`)      | 422                                                                 | 455                              | 299                                                                 | 39                                       | 208                                                            | 287                                                 | 128                                                 | 740                                                 | 22                                          |
 | Execution time [ms] (`miniz.c`)              | 27                                                                  | 169                              | 19                                                                  | 4                                        | 36                                                             | 131                                                 | 58                                                  | 231                                                 | 4                                          |
 | Execution time [ms] (957 kB XML file)        | 215                                                                 | 296                              | 236                                                                 | 165                                      | 83                                                            | 412                                                 | 135                                                 | 386                                                 | 127                                          |
@@ -97,7 +97,7 @@ The following files have been manually modified after converting from a `.tmLang
   as it is not kept in a standalone repository. The file is generated from
   https://github.com/open-policy-agent/opa/blob/master/misc/syntax/textmate/Rego.tmLanguage
 * `SML.sublime_syntax` has been added manually from
-   https://github.com/seanjames777/SML-Language-Definitiona as it is not
+   https://github.com/seanjames777/SML-Language-Definition as it is not
   kept in a standalone repository. The file generated is from
   https://github.com/seanjames777/SML-Language-Definition/blob/master/sml.tmLanguage
 * `Cabal.sublime_syntax` has been added manually from
@@ -37,6 +37,13 @@ Options:
          name (like 'C++' or 'LaTeX') or possible file extension (like 'cpp', 'hpp' or 'md'). Use
          '--list-languages' to show all supported language names and file extensions.

+      --fallback-syntax <fallback-syntax>
+          Set a fallback language for syntax highlighting when auto-detection fails. Unlike
+          '--language', this is only used when no syntax could be detected from filename, custom
+          syntax mappings, or first-line detection.
+          
+          [aliases: --fallback-language]
+
  -H, --highlight-line <N:M>
          Highlight the specified line ranges with a different background color For example:
            '--highlight-line 40' highlights line 40
@@ -61,8 +68,8 @@ Options:
          Set the tab width to T spaces. Use a width of 0 to pass tabs through directly

      --wrap <mode>
-          Specify the text-wrapping mode (*auto*, never, character). The '--terminal-width' option
-          can be used in addition to control the output width.
+          Specify the text-wrapping mode (*auto*, never, character, word). The '--terminal-width'
+          option can be used in addition to control the output width.

  -S, --chop-long-lines
          Truncate all lines longer than screen width. Alias for '--wrap=never'.
@@ -70,7 +77,8 @@ Options:
      --terminal-width <width>
          Explicitly set the width of the terminal instead of determining it automatically. If
          prefixed with '+' or '-', the value will be treated as an offset to the actual terminal
-          width. See also: '--wrap'.
+          width. This can also be configured via the BAT_WIDTH environment variable (e.g. export
+          BAT_WIDTH="100"). See also: '--wrap'.

  -n, --number
          Only show line numbers, no other decorations. This is an alias for '--style=numbers'
@@ -156,6 +164,14 @@ Options:
          escape sequences unless the syntax highlighting language is plain text. Possible values:
          auto, always, *never*.

+      --sanitize <when>
+          Specify when to sanitize input bytes for safe terminal display. Implies --strip-ansi to
+          the same value, and additionally substitutes terminal-active control bytes (cursor moves,
+          charset switches, beep, etc.) and Unicode bidi / zero-width formatting characters with the
+          Unicode replacement character (U+FFFD). Tab, LF, FF, and CRLF pass through. Useful for
+          displaying untrusted file content (e.g. file-manager preview panes). Possible values:
+          auto, always, *never*.
+
      --style <components>
          Configure which elements (line numbers, file headers, grid borders, Git modifications, ..)
          to display in addition to the file contents. The argument is a comma-separated list of
@@ -194,6 +210,7 @@ Options:
            '--line-range :40' prints lines 1 to 40
            '--line-range 40:' prints lines 40 to the end of the file
            '--line-range 40' only prints line 40
+            '--line-range -10:' prints the last 10 lines
            '--line-range 30:+10' prints lines 30 to 40
            '--line-range 35::5' prints lines 30 to 40 (line 35 with 5 lines of context)
            '--line-range 30:40:2' prints lines 28 to 42 (range 30-40 with 2 lines of context)
@@ -202,8 +219,11 @@ Options:
          Display a list of supported languages for syntax highlighting.

  -u, --unbuffered
-          This option exists for POSIX-compliance reasons ('u' is for 'unbuffered'). The output is
-          always unbuffered - this option is simply ignored.
+          Enable unbuffered input reading. When this flag is set, bat will display data as soon as
+          it is available, without waiting for a complete line. This is useful for streaming use
+          cases like 'tail -f logfile | bat -u --paging=never'. Note that line numbers are
+          automatically disabled in unbuffered mode, and syntax highlighting may be imperfect on
+          partial lines.

      --completion <SHELL>
          Show shell completion for a certain shell. [possible values: bash, fish, zsh, ps1]
@@ -211,6 +231,10 @@ Options:
      --diagnostic
          Show diagnostic information for bug reports.

+  -E, --quiet-empty
+          When this flag is set, bat will produce no output at all when the input is empty. This is
+          useful when piping commands that may produce empty output, like 'git diff'.
+
      --acknowledgements
          Show acknowledgements.

@@ -17,6 +17,8 @@ Options:
          Show plain style (alias for '--style=plain').
  -l, --language <language>
          Set the language for syntax highlighting.
+      --fallback-syntax <fallback-syntax>
+          Set a fallback language for undetected syntaxes. [aliases: --fallback-language]
  -H, --highlight-line <N:M>
          Highlight lines N through M.
      --file-name <name>
@@ -26,7 +28,7 @@ Options:
      --tabs <T>
          Set the tab width to T spaces.
      --wrap <mode>
-          Specify the text-wrapping mode (*auto*, never, character).
+          Specify the text-wrapping mode (*auto*, never, character, word).
  -S, --chop-long-lines
          Truncate all lines longer than screen width. Alias for '--wrap=never'.
  -n, --number
@@ -58,8 +60,12 @@ Options:
          Only print the lines from N to M.
  -L, --list-languages
          Display all supported languages.
+  -u, --unbuffered
+          Enable unbuffered input reading for streaming use cases.
      --completion <SHELL>
          Show shell completion for a certain shell. [possible values: bash, fish, zsh, ps1]
+  -E, --quiet-empty
+          Produce no output when the input is empty.
  -h, --help
          Print help (see more with '--help')
  -V, --version
@@ -10,5 +10,3 @@ No issue will have a different priority based on sponsorship status of the
 reporter.

 Contributions from anybody are most welcomed, please see our [`CONTRIBUTING.md`](../CONTRIBUTING.md) guide.
-
-If you want to see our biggest sponsors, check the top of [`README.md`](../README.md#sponsors).
@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1769789167,
+        "narHash": "sha256-kKB3bqYJU5nzYeIROI82Ef9VtTbu4uA3YydSk/Bioa8=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "62c8382960464ceb98ea593cb8321a2cf8f9e3e5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
@@ -0,0 +1,40 @@
+{
+  description = "bat";
+
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+  outputs =
+    { self, ... }@inputs:
+    let
+      supportedSystems = [
+        "x86_64-linux" # 64-bit Intel/AMD Linux
+        "aarch64-linux" # 64-bit ARM Linux
+        "aarch64-darwin" # 64-bit ARM macOS
+        "x86_64-darwin" # 64-bit Intel macOS
+      ];
+
+      forEachSupportedSystem =
+        f:
+        inputs.nixpkgs.lib.genAttrs supportedSystems (
+          system:
+          f {
+            inherit system;
+            pkgs = import inputs.nixpkgs {
+              inherit system;
+            };
+          }
+        );
+    in
+    {
+      devShells = forEachSupportedSystem (
+        { pkgs, system }:
+        {
+          default = pkgs.mkShellNoCC {
+            packages = with pkgs; [
+              cargo
+            ];
+          };
+        }
+      );
+    };
+}
@@ -158,7 +158,9 @@ impl HighlightingAssets {
        let syntax_match = mapping.get_syntax_for(path);

        if let Some(MappingTarget::MapToUnknown) = syntax_match {
-            return Err(Error::UndetectedSyntax(path.to_string_lossy().into()));
+            return Err(Error::UndetectedSyntax(
+                crate::preprocessor::sanitize_for_terminal(&path.to_string_lossy()),
+            ));
        }

        if let Some(MappingTarget::MapTo(syntax_name)) = syntax_match {
@@ -175,13 +177,17 @@ impl HighlightingAssets {
        ) {
            (Some(syntax), _) => Ok(syntax),

-            (_, Some(MappingTarget::MapExtensionToUnknown)) => {
-                Err(Error::UndetectedSyntax(path.to_string_lossy().into()))
-            }
+            (_, Some(MappingTarget::MapExtensionToUnknown)) => Err(Error::UndetectedSyntax(
+                crate::preprocessor::sanitize_for_terminal(&path.to_string_lossy()),
+            )),

            _ => self
                .get_syntax_for_file_extension(file_name, &mapping.ignored_suffixes)?
-                .ok_or_else(|| Error::UndetectedSyntax(path.to_string_lossy().into())),
+                .ok_or_else(|| {
+                    Error::UndetectedSyntax(crate::preprocessor::sanitize_for_terminal(
+                        &path.to_string_lossy(),
+                    ))
+                }),
        }
    }

@@ -210,6 +216,7 @@ impl HighlightingAssets {
    pub(crate) fn get_syntax(
        &self,
        language: Option<&str>,
+        fallback_syntax: Option<&str>,
        input: &mut OpenedInput,
        mapping: &SyntaxMapping,
    ) -> Result<SyntaxReferenceInSet<'_>> {
@@ -222,21 +229,50 @@ impl HighlightingAssets {
        }

        let path = input.path();
-        let path_syntax = if let Some(path) = path {
-            self.get_syntax_for_path(
-                PathAbs::new(path).map_or_else(|_| path.to_owned(), |p| p.as_path().to_path_buf()),
-                mapping,
-            )
+        let absolute_path = path.and_then(|p| {
+            PathAbs::new(p)
+                .ok()
+                .map(|abs| abs.as_path().to_path_buf())
+                .or_else(|| Some(p.to_owned()))
+        });
+
+        let path_syntax = if let Some(ref path) = absolute_path {
+            self.get_syntax_for_path(path, mapping).or_else(|e| {
+                // If syntax detection failed on the given path, retry with the
+                // canonicalized path (which resolves symlinks). This handles
+                // cases like `Aliases/0install -> ../Formula/zero-install.rb`
+                // where the symlink name has no extension but the target does.
+                // See #1001.
+                if matches!(e, Error::UndetectedSyntax(_)) {
+                    if let Ok(resolved) = fs::canonicalize(path) {
+                        if resolved != *path {
+                            return match self.get_syntax_for_path(&resolved, mapping) {
+                                Ok(syntax) => Ok(syntax),
+                                Err(Error::UndetectedSyntax(_)) => Err(e),
+                                Err(err) => Err(err),
+                            };
+                        }
+                    }
+                }
+                Err(e)
+            })
        } else {
            Err(Error::UndetectedSyntax("[unknown]".into()))
        };

+        // If a path wasn't provided, or if path based syntax detection
+        // above failed, we fall back to first-line syntax detection.
        match path_syntax {
-            // If a path wasn't provided, or if path based syntax detection
-            // above failed, we fall back to first-line syntax detection.
-            Err(Error::UndetectedSyntax(path)) => self
-                .get_first_line_syntax(&mut input.reader)?
-                .ok_or(Error::UndetectedSyntax(path)),
+            Err(Error::UndetectedSyntax(path)) => {
+                if let Some(syntax_in_set) = self.get_first_line_syntax(&mut input.reader)? {
+                    Ok(syntax_in_set)
+                } else if let Some(language) = fallback_syntax {
+                    self.find_syntax_by_token(language)?
+                        .ok_or_else(|| Error::UnknownSyntax(language.to_owned()))
+                } else {
+                    Err(Error::UndetectedSyntax(path))
+                }
+            }
            _ => path_syntax,
        }
    }
@@ -262,6 +298,24 @@ impl HighlightingAssets {
            .map(|syntax| SyntaxReferenceInSet { syntax, syntax_set }))
    }

+    fn find_syntax_by_hidden_file_name(
+        &self,
+        file_name: &OsStr,
+    ) -> Result<Option<SyntaxReferenceInSet<'_>>> {
+        let Some(hidden_file_extension) = file_name
+            .to_str()
+            .and_then(|name| name.strip_prefix('.'))
+            .filter(|name| !name.is_empty())
+        else {
+            return Ok(None);
+        };
+
+        // syntect stores `hidden_file_extensions` in the same extension list as
+        // regular file extensions, but dotfiles must be queried without the
+        // leading period.
+        self.find_syntax_by_extension(Some(OsStr::new(hidden_file_extension)))
+    }
+
    fn find_syntax_by_token(&self, token: &str) -> Result<Option<SyntaxReferenceInSet<'_>>> {
        let syntax_set = self.get_syntax_set()?;
        Ok(syntax_set
@@ -275,6 +329,9 @@ impl HighlightingAssets {
        ignored_suffixes: &IgnoredSuffixes,
    ) -> Result<Option<SyntaxReferenceInSet<'_>>> {
        let mut syntax = self.find_syntax_by_extension(Some(file_name))?;
+        if syntax.is_none() {
+            syntax = self.find_syntax_by_hidden_file_name(file_name)?;
+        }
        if syntax.is_none() {
            syntax =
                ignored_suffixes.try_with_stripped_suffix(file_name, |stripped_file_name| {
@@ -290,15 +347,15 @@ impl HighlightingAssets {
        file_name: &OsStr,
        ignored_suffixes: &IgnoredSuffixes,
    ) -> Result<Option<SyntaxReferenceInSet<'_>>> {
-        let mut syntax = self.find_syntax_by_extension(Path::new(file_name).extension())?;
-        if syntax.is_none() {
-            syntax =
-                ignored_suffixes.try_with_stripped_suffix(file_name, |stripped_file_name| {
-                    // Note: recursion
-                    self.get_syntax_for_file_extension(stripped_file_name, ignored_suffixes)
-                })?;
+        let stripped =
+            ignored_suffixes.try_with_stripped_suffix(file_name, |stripped_file_name| {
+                self.get_syntax_for_file_extension(stripped_file_name, ignored_suffixes)
+                    .map(Some)
+            })?;
+        match stripped {
+            Some(syntax) => Ok(syntax),
+            None => self.find_syntax_by_extension(Path::new(file_name).extension()),
        }
-        Ok(syntax)
    }

    fn get_first_line_syntax(
@@ -395,11 +452,12 @@ mod tests {
        fn get_syntax_name(
            &self,
            language: Option<&str>,
+            fallback_syntax: Option<&str>,
            input: &mut OpenedInput,
            mapping: &SyntaxMapping,
        ) -> String {
            self.assets
-                .get_syntax(language, input, mapping)
+                .get_syntax(language, fallback_syntax, input, mapping)
                .map(|syntax_in_set| syntax_in_set.syntax.name.clone())
                .unwrap_or_else(|_| "!no syntax!".to_owned())
        }
@@ -419,7 +477,7 @@ mod tests {
            let dummy_stdin: &[u8] = &[];
            let mut opened_input = input.open(dummy_stdin, None).unwrap();

-            self.get_syntax_name(None, &mut opened_input, &self.syntax_mapping)
+            self.get_syntax_name(None, None, &mut opened_input, &self.syntax_mapping)
        }

        fn syntax_for_file_with_content_os(&self, file_name: &OsStr, first_line: &str) -> String {
@@ -429,7 +487,7 @@ mod tests {
            let dummy_stdin: &[u8] = &[];
            let mut opened_input = input.open(dummy_stdin, None).unwrap();

-            self.get_syntax_name(None, &mut opened_input, &self.syntax_mapping)
+            self.get_syntax_name(None, None, &mut opened_input, &self.syntax_mapping)
        }

        #[cfg(unix)]
@@ -449,7 +507,7 @@ mod tests {
            let input = Input::stdin().with_name(Some(file_name));
            let mut opened_input = input.open(content, None).unwrap();

-            self.get_syntax_name(None, &mut opened_input, &self.syntax_mapping)
+            self.get_syntax_name(None, None, &mut opened_input, &self.syntax_mapping)
        }

        fn syntax_is_same_for_inputkinds(&self, file_name: &str, content: &str) -> bool {
@@ -628,6 +686,48 @@ mod tests {
        );
    }

+    #[test]
+    fn syntax_detection_ignored_suffix_falls_back_to_first_line() {
+        let mut test = SyntaxDetectionTest::new();
+
+        // By default a `.txt` file uses Plain Text, even with a shebang: the
+        // `.txt` extension wins and first-line detection is not reached.
+        assert_eq!(
+            test.syntax_for_file_with_content("test.txt", "#!/usr/bin/env bash"),
+            "Plain Text"
+        );
+
+        // Once `.txt` is an ignored suffix it is stripped before detection. The
+        // stripped name (`test`) has no extension, so detection falls back to the
+        // first line -- even though `.txt` is itself a registered extension that
+        // would otherwise match as Plain Text. See #2745.
+        test.syntax_mapping.insert_ignored_suffix(".txt");
+        assert_eq!(
+            test.syntax_for_file_with_content("test.txt", "#!/usr/bin/env bash"),
+            "Bourne Again Shell (bash)"
+        );
+        assert_eq!(
+            test.syntax_for_file_with_content("test.txt", "<?php"),
+            "PHP"
+        );
+
+        // A `.txt` file without a recognizable first line keeps no syntax (the
+        // caller renders it as plain text); we must not resurrect the shadowed
+        // `.txt` -> Plain Text match here.
+        assert_eq!(
+            test.syntax_for_file_with_content("notes.txt", "just some prose"),
+            "!no syntax!"
+        );
+
+        // Stripping that exposes a real extension still works: `.dev` is ignored,
+        // and the remaining `.json` extension is detected as usual.
+        test.syntax_mapping.insert_ignored_suffix(".dev");
+        assert_eq!(
+            test.syntax_for_file_with_content("config.json.dev", ""),
+            "JSON"
+        );
+    }
+
    #[test]
    fn syntax_detection_is_case_insensitive() {
        let mut test = SyntaxDetectionTest::new();
@@ -661,6 +761,55 @@ mod tests {
        );
    }

+    #[cfg(feature = "build-assets")]
+    #[test]
+    fn syntax_detection_hidden_file_extensions() {
+        let source_dir = TempDir::new().expect("creation of temporary source directory");
+        let cache_dir = TempDir::new().expect("creation of temporary cache directory");
+        let syntax_dir = source_dir.path().join("syntaxes");
+
+        std::fs::create_dir_all(&syntax_dir).expect("creation of syntax directory succeeds");
+        std::fs::write(
+            syntax_dir.join("HiddenFileExtension.sublime-syntax"),
+            r#"%YAML 1.2
+---
+name: Hidden File Extension
+hidden_file_extensions:
+  - testrc
+scope: source.hiddenfileextension
+
+contexts:
+  main:
+    - match: .
+      scope: source.hiddenfileextension
+"#,
+        )
+        .expect("custom syntax can be written");
+
+        build(
+            source_dir.path(),
+            false,
+            false,
+            cache_dir.path(),
+            env!("CARGO_PKG_VERSION"),
+        )
+        .expect("custom assets can be built");
+
+        let test = SyntaxDetectionTest {
+            assets: HighlightingAssets::from_cache(cache_dir.path())
+                .expect("custom syntax cache can be loaded"),
+            syntax_mapping: SyntaxMapping::new(),
+            temp_dir: TempDir::new().expect("creation of temporary directory"),
+        };
+
+        assert_eq!(test.syntax_for_file(".testrc"), "Hidden File Extension");
+        assert_eq!(
+            test.syntax_for_stdin_with_content(".testrc", b""),
+            "Hidden File Extension"
+        );
+        assert!(test.syntax_is_same_for_inputkinds(".testrc", ""));
+    }
+
    #[cfg(unix)]
    #[test]
    fn syntax_detection_for_symlinked_file() {
@@ -682,8 +831,35 @@ mod tests {
        let mut opened_input = input.open(dummy_stdin, None).unwrap();

        assert_eq!(
-            test.get_syntax_name(None, &mut opened_input, &test.syntax_mapping),
+            test.get_syntax_name(None, None, &mut opened_input, &test.syntax_mapping),
            "SSH Config"
        );
    }
+
+    #[cfg(unix)]
+    #[test]
+    fn syntax_detection_for_symlinked_file_by_target_extension() {
+        use std::os::unix::fs::symlink;
+
+        let test = SyntaxDetectionTest::new();
+
+        let formula_dir = test.temp_dir.path().join("Formula");
+        std::fs::create_dir(&formula_dir).unwrap();
+        let target = formula_dir.join("zero-install.rb");
+        File::create(&target).unwrap();
+
+        let aliases_dir = test.temp_dir.path().join("Aliases");
+        std::fs::create_dir(&aliases_dir).unwrap();
+        let link = aliases_dir.join("0install");
+        symlink(&target, &link).unwrap();
+
+        let input = Input::ordinary_file(&link);
+        let dummy_stdin: &[u8] = &[];
+        let mut opened_input = input.open(dummy_stdin, None).unwrap();
+
+        assert_eq!(
+            test.get_syntax_name(None, None, &mut opened_input, &test.syntax_mapping),
+            "Ruby"
+        );
+    }
 }
@@ -38,9 +38,27 @@ pub fn env_no_color() -> bool {
    env::var_os("NO_COLOR").is_some_and(|x| !x.is_empty())
 }

+fn parse_strip_ansi_value(raw: Option<&str>, flag_name: &str) -> StripAnsiMode {
+    match raw {
+        Some("never") | None => StripAnsiMode::Never,
+        Some("always") => StripAnsiMode::Always,
+        Some("auto") => StripAnsiMode::Auto,
+        _ => unreachable!("other values for {flag_name} are not allowed"),
+    }
+}
+
+enum HelpType {
+    Short,
+    Long,
+}
+
 pub struct App {
    pub matches: ArgMatches,
    interactive_output: bool,
+    /// True if -n / --number was passed on the command line
+    /// (not from config file or environment variables).
+    /// This is used to honor the flag when piping output, similar to `cat -n`.
+    number_from_cli: bool,
 }

 impl App {
@@ -50,65 +68,217 @@ impl App {

        let interactive_output = std::io::stdout().is_terminal();

+        // Check if the -n / --number option was passed on the command line
+        // (before merging with config file and environment variables).
+        // This is needed to honor the -n flag when piping output, similar to `cat -n`.
+        // We need to handle both standalone (-n, --number) and combined short flags (-pn, -An, etc.)
+        // Note: We only check if -n appears and is not overridden by -p in the same combined flag.
+        // For combined flags like -np, -p comes after -n and overrides it, so we don't count it.
+        // For combined flags like -pn, -n comes after -p and takes effect.
+        let number_from_cli = wild::args_os().any(|arg| {
+            let arg_str = arg.to_string_lossy();
+            if arg_str == "-n" || arg_str == "--number" {
+                return true;
+            }
+            // Handle combined short flags
+            // Only count -n if it's the LAST flag in the combined form (so -p doesn't override it)
+            // or if -p is not present in the combined form
+            if arg_str.starts_with('-') && !arg_str.starts_with("--") && arg_str.len() > 2 {
+                let chars: Vec<char> = arg_str.chars().skip(1).collect();
+                let n_pos = chars.iter().position(|&c| c == 'n');
+                let p_pos = chars.iter().position(|&c| c == 'p');
+                // -n is in the combined flag and either:
+                // - -p is not present, OR
+                // - -n comes after -p (so -n takes effect)
+                if let Some(n) = n_pos {
+                    if p_pos.is_none() || n > p_pos.unwrap() {
+                        return true;
+                    }
+                }
+            }
+            false
+        });
+
+        let matches = Self::matches(interactive_output)?;
+
+        if matches.get_flag("help") {
+            let help_type = if wild::args_os().any(|arg| arg == "--help") {
+                HelpType::Long
+            } else {
+                HelpType::Short
+            };
+
+            let use_pager = match matches.get_one::<String>("paging").map(|s| s.as_str()) {
+                Some("never") => false,
+                _ => !matches.get_flag("no-paging"),
+            };
+
+            let use_color = match matches.get_one::<String>("color").map(|s| s.as_str()) {
+                Some("always") => true,
+                Some("never") => false,
+                _ => interactive_output, // auto: use color if interactive
+            };
+
+            let pager = matches.get_one::<String>("pager").map(|s| s.as_str());
+            let theme_options = Self::theme_options_from_matches(&matches);
+            let use_custom_assets = !matches.get_flag("no-custom-assets");
+
+            Self::display_help(
+                interactive_output,
+                help_type,
+                use_pager,
+                use_color,
+                pager,
+                theme_options,
+                use_custom_assets,
+            )?;
+            std::process::exit(0);
+        }
+
        Ok(App {
-            matches: Self::matches(interactive_output)?,
+            matches,
            interactive_output,
+            number_from_cli,
        })
    }

+    fn display_help(
+        interactive_output: bool,
+        help_type: HelpType,
+        use_pager: bool,
+        use_color: bool,
+        pager: Option<&str>,
+        theme_options: ThemeOptions,
+        use_custom_assets: bool,
+    ) -> Result<()> {
+        use crate::assets::assets_from_cache_or_binary;
+        use crate::directories::PROJECT_DIRS;
+        use bat::{
+            config::Config,
+            controller::Controller,
+            input::Input,
+            style::{StyleComponent, StyleComponents},
+            theme::theme,
+            PagingMode,
+        };
+
+        let mut cmd = clap_app::build_app(interactive_output);
+        let help_text = match help_type {
+            HelpType::Short => cmd.render_help().to_string(),
+            HelpType::Long => cmd.render_long_help().to_string(),
+        };
+
+        let inputs: Vec<Input> = vec![Input::from_reader(Box::new(help_text.as_bytes()))];
+
+        let paging_mode = if use_pager {
+            PagingMode::QuitIfOneScreen
+        } else {
+            PagingMode::Never
+        };
+
+        let help_config = Config {
+            style_components: StyleComponents::new(StyleComponent::Plain.components(false)),
+            paging_mode,
+            pager,
+            colored_output: use_color,
+            true_color: use_color,
+            language: if use_color { Some("help") } else { None },
+            theme: theme(theme_options).to_string(),
+            ..Default::default()
+        };
+
+        let cache_dir = PROJECT_DIRS.cache_dir();
+        let assets = assets_from_cache_or_binary(use_custom_assets, cache_dir)?;
+        Controller::new(&help_config, &assets)
+            .run(inputs, None)
+            .ok();
+
+        Ok(())
+    }
+
+    /// Build argument list with env vars and CLI args (without config file)
+    fn build_args_without_config() -> Vec<std::ffi::OsString> {
+        let mut cli_args = wild::args_os();
+        let mut args = get_args_from_env_vars();
+
+        // Put the zero-th CLI argument (program name) first
+        args.insert(0, cli_args.next().unwrap());
+
+        // .. and the rest at the end
+        cli_args.for_each(|a| args.push(a));
+
+        args
+    }
+
    fn matches(interactive_output: bool) -> Result<ArgMatches> {
        // Check if we should skip config file processing for special arguments
-        // that don't require full application setup (help, version, diagnostic)
+        // that don't require full application setup (version, diagnostic)
        let should_skip_config = wild::args_os().any(|arg| {
            matches!(
                arg.to_str(),
-                Some("-h" | "--help" | "-V" | "--version" | "--diagnostic" | "--diagnostics")
+                Some("-V" | "--version" | "--diagnostic" | "--diagnostics")
            )
        });

-        let args = if wild::args_os().nth(1) == Some("cache".into()) {
+        // Check if help was requested - help should read the config file but be
+        // forgiving of invalid arguments (so configured theme etc. can be used)
+        let help_requested =
+            wild::args_os().any(|arg| matches!(arg.to_str(), Some("-h" | "--help")));
+
+        if wild::args_os().nth(1) == Some("cache".into()) {
            // Skip the config file and env vars
+            let args = wild::args_os().collect::<Vec<_>>();
+            return Ok(clap_app::build_app(interactive_output).get_matches_from(args));
+        }

-            wild::args_os().collect::<Vec<_>>()
-        } else if wild::args_os().any(|arg| arg == "--no-config") || should_skip_config {
+        if wild::args_os().any(|arg| arg == "--no-config") || should_skip_config {
            // Skip the arguments in bats config file when --no-config is present
-            // or when user requests help, version, or diagnostic information
+            // or when user requests version or diagnostic information
+            let args = Self::build_args_without_config();
+            return Ok(clap_app::build_app(interactive_output).get_matches_from(args));
+        }

-            let mut cli_args = wild::args_os();
-            let mut args = if should_skip_config {
-                // For special commands, don't even try to load env vars that might fail
-                vec![]
-            } else {
-                get_args_from_env_vars()
-            };
+        // Build arguments with config file
+        let mut cli_args = wild::args_os();

-            // Put the zero-th CLI argument (program name) first
-            args.insert(0, cli_args.next().unwrap());
-
-            // .. and the rest at the end
-            cli_args.for_each(|a| args.push(a));
-
-            args
-        } else {
-            let mut cli_args = wild::args_os();
-
-            // Read arguments from bats config file
-            let mut args = get_args_from_env_opts_var()
-                .unwrap_or_else(get_args_from_config_file)
-                .map_err(|_| "Could not parse configuration file")?;
-
-            // Selected env vars supersede config vars
-            args.extend(get_args_from_env_vars());
-
-            // Put the zero-th CLI argument (program name) first
-            args.insert(0, cli_args.next().unwrap());
-
-            // .. and the rest at the end
-            cli_args.for_each(|a| args.push(a));
-            args
+        // Read arguments from bats config file
+        let config_args = match get_args_from_env_opts_var() {
+            Some(result) => result,
+            None => get_args_from_config_file(),
        };

-        Ok(clap_app::build_app(interactive_output).get_matches_from(args))
+        // For help, ignore config file parse errors (use empty config instead)
+        // For non-help, propagate the error
+        let mut args = if help_requested {
+            config_args.unwrap_or_default()
+        } else {
+            config_args.map_err(|_| "Could not parse configuration file")?
+        };
+
+        // Selected env vars supersede config vars
+        args.extend(get_args_from_env_vars());
+
+        // Put the zero-th CLI argument (program name) first
+        args.insert(0, cli_args.next().unwrap());
+
+        // .. and the rest at the end
+        cli_args.for_each(|a| args.push(a));
+
+        // For help, try parsing with config, and if clap fails (e.g., invalid
+        // argument in config), fall back to parsing without config file args
+        if help_requested {
+            let app = clap_app::build_app(interactive_output);
+            match app.try_get_matches_from(args) {
+                Ok(matches) => Ok(matches),
+                Err(_) => {
+                    // Config has invalid arguments, fall back to just env vars + CLI args
+                    let fallback_args = Self::build_args_without_config();
+                    Ok(clap_app::build_app(interactive_output).get_matches_from(fallback_args))
+                }
+            }
+        } else {
+            Ok(clap_app::build_app(interactive_output).get_matches_from(args))
+        }
    }

    pub fn config(&self, inputs: &[Input]) -> Result<Config<'_>> {
@@ -223,6 +393,10 @@ impl App {
                        None
                    }
                }),
+            fallback_syntax: self
+                .matches
+                .get_one::<String>("fallback-syntax")
+                .map(|s| s.as_str()),
            show_nonprintable: self.matches.get_flag("show-all"),
            nonprintable_notation: match self
                .matches
@@ -238,27 +412,30 @@ impl App {
                Some("no-printing") => BinaryBehavior::NoPrinting,
                _ => unreachable!("other values for --binary are not allowed"),
            },
-            wrapping_mode: if self.interactive_output || maybe_term_width.is_some() {
-                if !self.matches.get_flag("chop-long-lines") {
+            wrapping_mode: {
+                if self.matches.get_flag("chop-long-lines") {
+                    WrappingMode::NoWrapping(true)
+                } else {
                    match self.matches.get_one::<String>("wrap").map(|s| s.as_str()) {
                        Some("character") => WrappingMode::Character,
+                        Some("word") => WrappingMode::Word,
                        Some("never") => WrappingMode::NoWrapping(true),
                        Some("auto") | None => {
-                            if style_components.plain() {
-                                WrappingMode::NoWrapping(false)
+                            if self.interactive_output || maybe_term_width.is_some() {
+                                if style_components.plain() && maybe_term_width.is_none() {
+                                    WrappingMode::NoWrapping(false)
+                                } else {
+                                    WrappingMode::Character
+                                }
                            } else {
-                                WrappingMode::Character
+                                // We don't have the tty width when piping to another program.
+                                // There's no point in wrapping when this is the case.
+                                WrappingMode::NoWrapping(false)
                            }
                        }
                        _ => unreachable!("other values for --wrap are not allowed"),
                    }
-                } else {
-                    WrappingMode::NoWrapping(true)
                }
-            } else {
-                // We don't have the tty width when piping to another program.
-                // There's no point in wrapping when this is the case.
-                WrappingMode::NoWrapping(false)
            },
            colored_output: self.matches.get_flag("force-colorization")
                || match self.matches.get_one::<String>("color").map(|s| s.as_str()) {
@@ -277,8 +454,7 @@ impl App {
                    .map(|s| s.as_str())
                    == Some("always")
                || self.matches.get_flag("force-colorization")
-                || self.matches.get_flag("number")
-                || self.matches.contains_id("style") && !style_components.plain()),
+                || self.number_from_cli),
            tab_width: self
                .matches
                .get_one::<String>("tabs")
@@ -291,16 +467,34 @@ impl App {
                        4
                    },
                ),
-            strip_ansi: match self
-                .matches
-                .get_one::<String>("strip-ansi")
-                .map(|s| s.as_str())
-            {
-                Some("never") => StripAnsiMode::Never,
-                Some("always") => StripAnsiMode::Always,
-                Some("auto") => StripAnsiMode::Auto,
-                _ => unreachable!("other values for --strip-ansi are not allowed"),
+            strip_ansi: {
+                let sanitize = parse_strip_ansi_value(
+                    self.matches
+                        .get_one::<String>("sanitize")
+                        .map(|s| s.as_str()),
+                    "--sanitize",
+                );
+                let strip_ansi = parse_strip_ansi_value(
+                    self.matches
+                        .get_one::<String>("strip-ansi")
+                        .map(|s| s.as_str()),
+                    "--strip-ansi",
+                );
+                // --sanitize implies --strip-ansi to the same value.
+                if sanitize != StripAnsiMode::Never {
+                    sanitize
+                } else {
+                    strip_ansi
+                }
            },
+            sanitize: parse_strip_ansi_value(
+                self.matches
+                    .get_one::<String>("sanitize")
+                    .map(|s| s.as_str()),
+                "--sanitize",
+            ),
+            quiet_empty: self.matches.get_flag("quiet-empty"),
+            unbuffered: self.matches.get_flag("unbuffered"),
            theme: theme(self.theme_options()).to_string(),
            visible_lines: match self.matches.try_contains_id("diff").unwrap_or_default()
                && self.matches.get_flag("diff")
@@ -421,7 +615,17 @@ impl App {

        // Plain if `--plain` is specified at least once.
        if self.matches.get_count("plain") > 0 {
-            return Some(StyleComponents(HashSet::from([StyleComponent::Plain])));
+            let mut components = HashSet::from([StyleComponent::Plain]);
+            // When --diff is active, preserve change markers and snip separators
+            // so that diff output remains visually useful.
+            if self.matches.try_contains_id("diff").unwrap_or_default()
+                && self.matches.get_flag("diff")
+            {
+                #[cfg(feature = "git")]
+                components.insert(StyleComponent::Changes);
+                components.insert(StyleComponent::Snip);
+            }
+            return Some(StyleComponents(components));
        }

        // Default behavior.
@@ -458,21 +662,27 @@ impl App {
            bat_warning!("Style 'rule' is a subset of style 'grid', 'rule' will not be visible.");
        }

+        // Auto-disable line numbers in unbuffered mode to avoid confusion with partial lines
+        if self.matches.get_flag("unbuffered") {
+            styled_components.0.remove(&StyleComponent::LineNumbers);
+        }
+
        Ok(styled_components)
    }

-    fn theme_options(&self) -> ThemeOptions {
-        let theme = self
-            .matches
+    pub(crate) fn theme_options(&self) -> ThemeOptions {
+        Self::theme_options_from_matches(&self.matches)
+    }
+
+    fn theme_options_from_matches(matches: &ArgMatches) -> ThemeOptions {
+        let theme = matches
            .get_one::<String>("theme")
            .map(|t| ThemePreference::from_str(t).unwrap())
            .unwrap_or_default();
-        let theme_dark = self
-            .matches
+        let theme_dark = matches
            .get_one::<String>("theme-dark")
            .map(|t| ThemeName::from_str(t).unwrap());
-        let theme_light = self
-            .matches
+        let theme_light = matches
            .get_one::<String>("theme-light")
            .map(|t| ThemeName::from_str(t).unwrap());
        ThemeOptions {
@@ -1,7 +1,5 @@
 use bat::style::StyleComponentList;
-use clap::{
-    crate_name, crate_version, value_parser, Arg, ArgAction, ArgGroup, ColorChoice, Command,
-};
+use clap::{crate_name, crate_version, value_parser, Arg, ArgAction, ColorChoice, Command};
 use once_cell::sync::Lazy;
 use std::env;
 use std::path::{Path, PathBuf};
@@ -34,6 +32,8 @@ pub fn build_app(interactive_output: bool) -> Command {
        .args_conflicts_with_subcommands(true)
        .allow_external_subcommands(true)
        .disable_help_subcommand(true)
+        .disable_help_flag(true)
+        .disable_version_flag(true)
        .max_term_width(100)
        .about("A cat(1) clone with wings.")
        .long_about("A cat(1) clone with syntax highlighting and Git integration.")
@@ -120,6 +120,17 @@ pub fn build_app(interactive_output: bool) -> Command {
                     language names and file extensions.",
                ),
        )
+        .arg(
+            Arg::new("fallback-syntax")
+                .long("fallback-syntax")
+                .visible_alias("fallback-language")
+                .help("Set a fallback language for undetected syntaxes.")
+                .long_help(
+                    "Set a fallback language for syntax highlighting when auto-detection fails. \
+                     Unlike '--language', this is only used when no syntax could be detected from \
+                     filename, custom syntax mappings, or first-line detection.",
+                ),
+        )
        .arg(
            Arg::new("highlight-line")
                .long("highlight-line")
@@ -211,11 +222,11 @@ pub fn build_app(interactive_output: bool) -> Command {
                .long("wrap")
                .overrides_with("wrap")
                .value_name("mode")
-                .value_parser(["auto", "never", "character"])
+                .value_parser(["auto", "never", "character", "word"])
                .default_value("auto")
                .hide_default_value(true)
-                .help("Specify the text-wrapping mode (*auto*, never, character).")
-                .long_help("Specify the text-wrapping mode (*auto*, never, character). \
+                .help("Specify the text-wrapping mode (*auto*, never, character, word).")
+                .long_help("Specify the text-wrapping mode (*auto*, never, character, word). \
                           The '--terminal-width' option can be used in addition to \
                           control the output width."),
        )
@@ -229,6 +240,7 @@ pub fn build_app(interactive_output: bool) -> Command {
        .arg(
            Arg::new("terminal-width")
                .long("terminal-width")
+                .overrides_with("terminal-width")
                .value_name("width")
                .hide_short_help(true)
                .allow_hyphen_values(true)
@@ -244,10 +256,13 @@ pub fn build_app(interactive_output: bool) -> Command {
                            })
                            .map_err(|e| e.to_string())
                    })
-                .help(
+                .help("Explicitly set the width of the terminal instead of determining it automatically.")
+                .long_help(
                    "Explicitly set the width of the terminal instead of determining it \
                     automatically. If prefixed with '+' or '-', the value will be treated \
-                     as an offset to the actual terminal width. See also: '--wrap'.",
+                     as an offset to the actual terminal width. This can also be configured \
+                     via the BAT_WIDTH environment variable (e.g. export BAT_WIDTH=\"100\"). \
+                     See also: '--wrap'.",
                ),
        )
        .arg(
@@ -465,6 +480,24 @@ pub fn build_app(interactive_output: bool) -> Command {
                language is plain text. Possible values: auto, always, *never*.")
                .hide_short_help(true)
        )
+        .arg(
+            Arg::new("sanitize")
+                .long("sanitize")
+                .overrides_with("sanitize")
+                .value_name("when")
+                .value_parser(["auto", "always", "never"])
+                .default_value("never")
+                .hide_default_value(true)
+                .help("Sanitize untrusted input for safe display (auto, always, *never*)")
+                .long_help("Specify when to sanitize input bytes for safe terminal display. \
+                Implies --strip-ansi to the same value, and additionally substitutes \
+                terminal-active control bytes (cursor moves, charset switches, beep, etc.) \
+                and Unicode bidi / zero-width formatting characters with the Unicode \
+                replacement character (U+FFFD). Tab, LF, FF, and CRLF pass through. Useful \
+                for displaying untrusted file content (e.g. file-manager preview panes). \
+                Possible values: auto, always, *never*.")
+                .hide_short_help(true)
+        )
        .arg(
            Arg::new("style")
                .long("style")
@@ -519,6 +552,7 @@ pub fn build_app(interactive_output: bool) -> Command {
                .short('r')
                .action(ArgAction::Append)
                .value_name("N:M")
+                .allow_hyphen_values(true)
                .help("Only print the lines from N to M.")
                .long_help(
                    "Only print the specified range of lines for each file. \
@@ -527,6 +561,7 @@ pub fn build_app(interactive_output: bool) -> Command {
                     '--line-range :40' prints lines 1 to 40\n  \
                     '--line-range 40:' prints lines 40 to the end of the file\n  \
                     '--line-range 40' only prints line 40\n  \
+                     '--line-range -10:' prints the last 10 lines\n  \
                     '--line-range 30:+10' prints lines 30 to 40\n  \
                     '--line-range 35::5' prints lines 30 to 40 (line 35 with 5 lines of context)\n  \
                     '--line-range 30:40:2' prints lines 28 to 42 (range 30-40 with 2 lines of context)",
@@ -546,11 +581,14 @@ pub fn build_app(interactive_output: bool) -> Command {
                .short('u')
                .long("unbuffered")
                .action(ArgAction::SetTrue)
-                .hide_short_help(true)
+                .help("Enable unbuffered input reading for streaming use cases.")
                .long_help(
-                    "This option exists for POSIX-compliance reasons ('u' is for \
-                     'unbuffered'). The output is always unbuffered - this option \
-                     is simply ignored.",
+                    "Enable unbuffered input reading. When this flag is set, bat will \
+                     display data as soon as it is available, without waiting for a \
+                     complete line. This is useful for streaming use cases like \
+                     'tail -f logfile | bat -u --paging=never'. Note that line numbers \
+                     are automatically disabled in unbuffered mode, and syntax \
+                     highlighting may be imperfect on partial lines.",
                ),
        )
        .arg(
@@ -639,6 +677,18 @@ pub fn build_app(interactive_output: bool) -> Command {
                .hide_short_help(true)
                .help("Show diagnostic information for bug reports."),
        )
+        .arg(
+            Arg::new("quiet-empty")
+                .long("quiet-empty")
+                .short('E')
+                .action(ArgAction::SetTrue)
+                .help("Produce no output when the input is empty.")
+                .long_help(
+                    "When this flag is set, bat will produce no output at all when \
+                     the input is empty. This is useful when piping commands that may \
+                     produce empty output, like 'git diff'.",
+                ),
+        )
        .arg(
            Arg::new("acknowledgements")
                .long("acknowledgements")
@@ -652,6 +702,21 @@ pub fn build_app(interactive_output: bool) -> Command {
                .action(ArgAction::SetTrue)
                .hide_short_help(true)
                .help("Sets terminal title to filenames when using a pager."),
+        )
+        .arg(
+            Arg::new("help")
+                .short('h')
+                .long("help")
+                .action(ArgAction::SetTrue)
+                .help("Print help (see more with '--help')")
+                .long_help("Print help (see a summary with '-h')"),
+        )
+        .arg(
+            Arg::new("version")
+                .long("version")
+                .short('V')
+                .action(ArgAction::Version)
+                .help("Print version"),
        );

    // Check if the current directory contains a file name cache. Otherwise,
@@ -663,11 +728,20 @@ pub fn build_app(interactive_output: bool) -> Command {
            Command::new("cache")
                .hide(true)
                .about("Modify the syntax-definition and theme cache")
+                .arg_required_else_help(true)
+                .arg(
+                    Arg::new("help")
+                        .short('h')
+                        .long("help")
+                        .action(ArgAction::Help)
+                        .help("Print help"),
+                )
                .arg(
                    Arg::new("build")
                        .long("build")
                        .short('b')
                        .action(ArgAction::SetTrue)
+                        .conflicts_with("clear")
                        .help("Initialize (or update) the syntax/theme cache.")
                        .long_help(
                            "Initialize (or update) the syntax/theme cache by loading from \
@@ -679,13 +753,9 @@ pub fn build_app(interactive_output: bool) -> Command {
                        .long("clear")
                        .short('c')
                        .action(ArgAction::SetTrue)
+                        .conflicts_with("build")
                        .help("Remove the cached syntax definitions and themes."),
                )
-                .group(
-                    ArgGroup::new("cache-actions")
-                        .args(["build", "clear"])
-                        .required(true),
-                )
                .arg(
                    Arg::new("source")
                        .long("source")
@@ -2,7 +2,7 @@ use std::env;
 use std::ffi::OsString;
 use std::fs;
 use std::io::{self, Write};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};

 use crate::directories::PROJECT_DIRS;

@@ -104,18 +104,32 @@ pub fn generate_config_file() -> bat::error::Result<()> {
 pub fn get_args_from_config_file() -> Result<Vec<OsString>, shell_words::ParseError> {
    let mut config = String::new();

-    if let Ok(c) = fs::read_to_string(system_config_file()) {
+    let system_config = system_config_file();
+    let user_config = config_file();
+
+    if let Ok(c) = fs::read_to_string(&system_config) {
        config.push_str(&c);
        config.push('\n');
    }

-    if let Ok(c) = fs::read_to_string(config_file()) {
-        config.push_str(&c);
+    // Skip the user config if it resolves to the same file as the system config,
+    // which can happen when BAT_CONFIG_DIR is set to e.g. "/etc/bat". See #3589.
+    if !same_file(&system_config, &user_config) {
+        if let Ok(c) = fs::read_to_string(&user_config) {
+            config.push_str(&c);
+        }
    }

    get_args_from_str(&config)
 }

+fn same_file(a: &Path, b: &Path) -> bool {
+    match (fs::canonicalize(a), fs::canonicalize(b)) {
+        (Ok(a), Ok(b)) => a == b,
+        _ => a == b,
+    }
+}
+
 pub fn get_args_from_env_opts_var() -> Option<Result<Vec<OsString>, shell_words::ParseError>> {
    env::var("BAT_OPTS").ok().map(|s| get_args_from_str(&s))
 }
@@ -139,6 +153,7 @@ fn get_args_from_str(content: &str) -> Result<Vec<OsString>, shell_words::ParseE
 pub fn get_args_from_env_vars() -> Vec<OsString> {
    [
        ("--tabs", "BAT_TABS"),
+        ("--terminal-width", "BAT_WIDTH"),
        ("--theme", bat::theme::env::BAT_THEME),
        ("--theme-dark", bat::theme::env::BAT_THEME_DARK),
        ("--theme-light", bat::theme::env::BAT_THEME_LIGHT),
@@ -214,3 +229,40 @@ fn comments() {
        get_args_from_str(config).unwrap()
    );
 }
+
+#[test]
+fn same_file_identical_paths() {
+    let dir = tempfile::tempdir().unwrap();
+    let file = dir.path().join("config");
+    fs::write(&file, "").unwrap();
+    assert!(same_file(&file, &file));
+}
+
+#[test]
+fn same_file_different_paths() {
+    let dir = tempfile::tempdir().unwrap();
+    let a = dir.path().join("a");
+    let b = dir.path().join("b");
+    fs::write(&a, "").unwrap();
+    fs::write(&b, "").unwrap();
+    assert!(!same_file(&a, &b));
+}
+
+#[test]
+fn same_file_nonexistent() {
+    let dir = tempfile::tempdir().unwrap();
+    let a = dir.path().join("a");
+    let b = dir.path().join("b");
+    assert!(!same_file(&a, &b));
+}
+
+#[cfg(unix)]
+#[test]
+fn same_file_via_symlink() {
+    let dir = tempfile::tempdir().unwrap();
+    let original = dir.path().join("config");
+    let link = dir.path().join("link");
+    fs::write(&original, "").unwrap();
+    std::os::unix::fs::symlink(&original, &link).unwrap();
+    assert!(same_file(&original, &link));
+}
@@ -16,8 +16,7 @@ use std::io::{BufReader, Write};
 use std::path::Path;
 use std::process;

-use bat::output::OutputType;
-use bat::theme::DetectColorScheme;
+use bat::output::{OutputHandle, OutputType};
 use nu_ansi_term::Color::Green;
 use nu_ansi_term::Style;

@@ -39,7 +38,7 @@ use bat::{
    error::*,
    input::Input,
    style::{StyleComponent, StyleComponents},
-    theme::{color_scheme, default_theme, ColorScheme},
+    theme::{default_theme, theme, ColorScheme, ThemeOptions},
    MappingTarget, PagingMode,
 };

@@ -153,7 +152,14 @@ pub fn get_languages(config: &Config, cache_dir: &Path) -> Result<String> {
        let comma_separator = ", ";
        let separator = " ";
        // Line-wrapping for the possible file extension overflow.
-        let desired_width = config.term_width - longest - separator.len();
+        // Clamp instead of subtracting: a tiny `--terminal-width` (smaller than the
+        // longest language name) would otherwise underflow `usize` and wrap to a huge
+        // value, silently disabling wrapping (and panicking in debug/overflow-checked
+        // builds). Mirrors the `saturating_sub` fix applied to `print_snip` in #3804.
+        let desired_width = config
+            .term_width
+            .saturating_sub(longest)
+            .saturating_sub(separator.len());

        let style = if config.colored_output {
            Green.normal()
@@ -197,7 +203,7 @@ pub fn list_themes(
    cfg: &Config,
    config_dir: &Path,
    cache_dir: &Path,
-    detect_color_scheme: DetectColorScheme,
+    theme_options: ThemeOptions,
 ) -> Result<()> {
    let assets = assets_from_cache_or_binary(cfg.use_custom_assets, cache_dir)?;
    let mut config = cfg.clone();
@@ -206,11 +212,10 @@ pub fn list_themes(
    config.language = Some("Rust");
    config.style_components = StyleComponents(style);

-    let mut output_type =
-        OutputType::from_mode(config.paging_mode, config.wrapping_mode, config.pager)?;
-    let mut writer = output_type.handle()?;
+    let default_theme_name = theme(theme_options).to_string();
+    let mut buf = String::new();
+    let mut handle = OutputHandle::FmtWrite(&mut buf);

-    let default_theme_name = default_theme(color_scheme(detect_color_scheme).unwrap_or_default());
    for theme in assets.themes() {
        let default_theme_info = if default_theme_name == theme {
            " (default)"
@@ -221,42 +226,48 @@ pub fn list_themes(
        } else {
            ""
        };
+
        if config.colored_output {
-            writeln!(
-                writer,
-                "Theme: {}{default_theme_info}\n",
+            handle.write_fmt(format_args!(
+                "{}{default_theme_info}\n\n",
                Style::new().bold().paint(theme.to_string()),
-            )?;
+            ))?;
            config.theme = theme.to_string();
            Controller::new(&config, &assets)
-                .run(vec![theme_preview_file()], Some(&mut writer))
+                .run(vec![theme_preview_file()], Some(&mut handle))
                .ok();
-            writeln!(writer)?;
+            handle.write_fmt(format_args!("\n"))?;
        } else if config.loop_through {
-            writeln!(writer, "{theme}")?;
+            handle.write_fmt(format_args!("{theme}\n"))?;
        } else {
-            writeln!(writer, "{theme}{default_theme_info}")?;
+            handle.write_fmt(format_args!("{theme}{default_theme_info}\n"))?;
        }
    }

    if config.colored_output {
-        writeln!(
-            writer,
+        handle.write_fmt(format_args!(
            "Further themes can be installed to '{}', \
            and are added to the cache with `bat cache --build`. \
            For more information, see:\n\n  \
            https://github.com/sharkdp/bat#adding-new-themes",
            config_dir.join("themes").to_string_lossy()
-        )?;
+        ))?;
    }

+    let mut output_type =
+        OutputType::from_mode(config.paging_mode, config.wrapping_mode, config.pager)?;
+    let mut writer = output_type.handle()?;
+    writer.write_fmt(format_args!("{buf}"))?;
+
    Ok(())
 }

 fn set_terminal_title_to(new_terminal_title: String) {
    let osc_command_for_setting_terminal_title = "\x1b]0;";
    let osc_end_command = "\x07";
-    print!("{osc_command_for_setting_terminal_title}{new_terminal_title}{osc_end_command}");
+    // Prevent BEL/ESC/C1 bytes in the title from terminating or nesting the OSC.
+    let safe_title = bat::sanitize_for_terminal(&new_terminal_title);
+    print!("{osc_command_for_setting_terminal_title}{safe_title}{osc_end_command}");
    io::stdout().flush().unwrap();
 }

@@ -282,7 +293,28 @@ fn run_controller(inputs: Vec<Input>, config: &Config, cache_dir: &Path) -> Resu

 #[cfg(feature = "bugreport")]
 fn invoke_bugreport(app: &App, cache_dir: &Path) {
-    use bugreport::{bugreport, collector::*, format::Markdown};
+    use bugreport::{bugreport, collector::*, format::Markdown, report::ReportEntry};
+
+    struct ColorSchemeCollector;
+
+    impl Collector for ColorSchemeCollector {
+        fn description(&self) -> &str {
+            "Detected terminal color scheme"
+        }
+
+        fn collect(
+            &mut self,
+            _: &bugreport::CrateInfo,
+        ) -> std::result::Result<ReportEntry, CollectionError> {
+            let color_scheme = bat::theme::color_scheme(bat::theme::DetectColorScheme::Always);
+            let text = match color_scheme {
+                Some(bat::theme::ColorScheme::Dark) => "dark",
+                Some(bat::theme::ColorScheme::Light) => "light",
+                None => "not detected",
+            };
+            Ok(ReportEntry::Text(text.to_string()))
+        }
+    }
    let pager = bat::config::get_pager_executable(
        app.matches.get_one::<String>("pager").map(|s| s.as_str()),
    )
@@ -304,6 +336,9 @@ fn invoke_bugreport(app: &App, cache_dir: &Path) {
            "BAT_STYLE",
            "BAT_TABS",
            "BAT_THEME",
+            "BAT_WIDTH",
+            bat::theme::env::BAT_THEME_DARK,
+            bat::theme::env::BAT_THEME_LIGHT,
            "COLORTERM",
            "LANG",
            "LC_ALL",
@@ -323,6 +358,7 @@ fn invoke_bugreport(app: &App, cache_dir: &Path) {
            custom_assets_metadata,
        ))
        .info(DirectoryEntries::new("Custom assets", cache_dir))
+        .info(ColorSchemeCollector)
        .info(CompileTimeInformation::default());

    #[cfg(feature = "paging")]
@@ -391,14 +427,12 @@ fn run() -> Result<bool> {
            if app.matches.get_flag("list-languages") {
                let languages: String = get_languages(&config, cache_dir)?;
                let inputs: Vec<Input> = vec![Input::from_reader(Box::new(languages.as_bytes()))];
-                let plain_config = Config {
-                    style_components: StyleComponents::new(StyleComponent::Plain.components(false)),
-                    paging_mode: PagingMode::QuitIfOneScreen,
-                    ..Default::default()
-                };
+                let mut plain_config = config.clone();
+                plain_config.style_components =
+                    StyleComponents::new(StyleComponent::Plain.components(false));
                run_controller(inputs, &plain_config, cache_dir)
            } else if app.matches.get_flag("list-themes") {
-                list_themes(&config, config_dir, cache_dir, DetectColorScheme::default())?;
+                list_themes(&config, config_dir, cache_dir, app.theme_options())?;
                Ok(true)
            } else if app.matches.get_flag("config-file") {
                println!("{}", config_file().to_string_lossy());
@@ -38,6 +38,9 @@ pub struct Config<'a> {
    /// The explicitly configured language, if any
    pub language: Option<&'a str>,

+    /// The fallback syntax used when auto-detection fails
+    pub fallback_syntax: Option<&'a str>,
+
    /// Whether or not to show/replace non-printable characters like space, tab and newline.
    pub show_nonprintable: bool,

@@ -99,14 +102,23 @@ pub struct Config<'a> {
    #[cfg(feature = "lessopen")]
    pub use_lessopen: bool,

-    // Weather or not to set terminal title when using a pager
+    // Whether or not to set terminal title when using a pager
    pub set_terminal_title: bool,

    /// The maximum number of consecutive empty lines to display
    pub squeeze_lines: Option<usize>,

-    // Weather or not to set terminal title when using a pager
+    // Whether or not to strip ANSI escape codes from the input
    pub strip_ansi: StripAnsiMode,
+
+    // Substitute terminal-active and spoofing-relevant bytes; implies strip_ansi.
+    pub sanitize: StripAnsiMode,
+
+    /// Whether or not to produce no output when input is empty
+    pub quiet_empty: bool,
+
+    /// Whether or not to use unbuffered input reading for streaming use cases
+    pub unbuffered: bool,
 }

 #[cfg(all(feature = "minimal-application", feature = "paging"))]
@@ -114,7 +126,13 @@ pub fn get_pager_executable(config_pager: Option<&str>) -> Option<String> {
    crate::pager::get_pager(config_pager)
        .ok()
        .flatten()
-        .map(|pager| pager.bin)
+        .and_then(|pager| {
+            if pager.kind != crate::pager::PagerKind::Builtin {
+                Some(pager.bin)
+            } else {
+                None
+            }
+        })
 }

 #[test]
@@ -141,3 +159,80 @@ fn default_config_should_highlight_no_lines() {
        RangeCheckResult::InRange
    );
 }
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_with_config_pager_less() {
+    let result = get_pager_executable(Some("less"));
+    assert_eq!(result, Some("less".to_string()));
+}
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_with_config_pager_builtin() {
+    let result = get_pager_executable(Some("builtin"));
+    assert_eq!(result, None);
+}
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_with_config_pager_more() {
+    let result = get_pager_executable(Some("more"));
+    assert_eq!(result, Some("more".to_string()));
+}
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_with_bat_pager() {
+    std::env::set_var("BAT_PAGER", "most");
+    let result = get_pager_executable(None);
+    assert_eq!(result, Some("most".to_string()));
+    std::env::remove_var("BAT_PAGER");
+}
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_with_pager_more_switches_to_less() {
+    std::env::set_var("PAGER", "more");
+    let result = get_pager_executable(None);
+    assert_eq!(result, Some("less".to_string()));
+    std::env::remove_var("PAGER");
+}
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_default() {
+    // Ensure no env vars
+    std::env::remove_var("BAT_PAGER");
+    std::env::remove_var("PAGER");
+    let result = get_pager_executable(None);
+    assert_eq!(result, Some("less".to_string()));
+}
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_name_ignoring_arguments() {
+    let result = get_pager_executable(Some("foo --bar"));
+    assert_eq!(result, Some("foo".to_string()));
+}
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_name_ignoring_path() {
+    let result = get_pager_executable(Some("/bin/foo test"));
+    assert_eq!(result, Some("/bin/foo".to_string()));
+}
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_invalid_command() {
+    let result = get_pager_executable(Some("invalid ' command"));
+    assert_eq!(result, None);
+}
+
+#[cfg(all(feature = "minimal-application", feature = "paging"))]
+#[test]
+fn get_pager_executable_empty_config() {
+    let result = get_pager_executable(Some(""));
+    assert_eq!(result, None);
+}
@@ -50,10 +50,12 @@ impl Controller<'_> {
        output_handle: Option<&mut OutputHandle<'_>>,
        mut handle_error: impl FnMut(&Error, &mut dyn Write),
    ) -> Result<bool> {
-        let mut output_type;
+        // only create our own OutputType if no output handle was provided.
+        #[allow(unused_mut)]
+        let mut output_type_opt: Option<OutputType> = None;

        #[cfg(feature = "paging")]
-        {
+        if output_handle.is_none() {
            use crate::input::InputKind;
            use std::path::Path;

@@ -74,25 +76,35 @@ impl Controller<'_> {

            let wrapping_mode = self.config.wrapping_mode;

-            output_type = OutputType::from_mode(paging_mode, wrapping_mode, self.config.pager)?;
+            output_type_opt = Some(OutputType::from_mode(
+                paging_mode,
+                wrapping_mode,
+                self.config.pager,
+            )?);
        }

        #[cfg(not(feature = "paging"))]
-        {
-            output_type = OutputType::stdout();
+        if output_handle.is_none() {
+            output_type_opt = Some(OutputType::stdout());
        }

-        let attached_to_pager = output_type.is_pager();
+        let attached_to_pager = match (&output_handle, &output_type_opt) {
+            (Some(_), _) => true,
+            (None, Some(ot)) => ot.is_pager(),
+            (None, None) => false,
+        };
+
        let stdout_identifier = if cfg!(windows) || attached_to_pager {
            None
        } else {
            clircle::Identifier::stdout()
        };

-        let mut writer = match output_handle {
-            Some(OutputHandle::FmtWrite(w)) => OutputHandle::FmtWrite(w),
-            Some(OutputHandle::IoWrite(w)) => OutputHandle::IoWrite(w),
-            None => output_type.handle()?,
+        let mut writer = match (output_handle, &mut output_type_opt) {
+            (Some(OutputHandle::FmtWrite(w)), _) => OutputHandle::FmtWrite(w),
+            (Some(OutputHandle::IoWrite(w)), _) => OutputHandle::IoWrite(w),
+            (None, Some(ot)) => ot.handle()?,
+            (None, None) => unreachable!("No output handle and no output type available"),
        };
        let mut no_errors: bool = true;
        let stderr = io::stderr();
@@ -146,6 +158,7 @@ impl Controller<'_> {
            #[cfg(not(feature = "lessopen"))]
            input.open(stdin, stdout_identifier)?
        };
+        opened_input.reader.unbuffered = self.config.unbuffered;
        #[cfg(feature = "git")]
        let line_changes = if self.config.visible_lines.diff_mode()
            || (!self.config.loop_through && self.config.style_components.changes())
@@ -315,6 +328,9 @@ impl Controller<'_> {
                    }

                    printer.print_line(false, writer, line_nr, &line, max_buffered_line_number)?;
+                    if self.config.unbuffered {
+                        writer.flush()?;
+                    }
                }
                RangeCheckResult::AfterLastRange => {
                    break;
@@ -1,12 +1,13 @@
 #![cfg(feature = "git")]

+use gix::diff::blob::pipeline::{Mode, WorktreeRoots};
+use gix::diff::blob::{Algorithm, HunkIter, ResourceKind};
+use gix::object::tree::EntryKind;
+use path_abs::PathInfo;
 use std::collections::HashMap;
-use std::fs;
 use std::path::Path;

-use git2::{DiffOptions, IntoCString, Repository};
-
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum LineChange {
    Added,
    RemovedAbove,
@@ -16,68 +17,181 @@ pub enum LineChange {

 pub type LineChanges = HashMap<u32, LineChange>;

-pub fn get_git_diff(filename: &Path) -> Option<LineChanges> {
-    let repo = Repository::discover(filename).ok()?;
-
-    let repo_path_absolute = fs::canonicalize(repo.workdir()?).ok()?;
-
-    let filepath_absolute = fs::canonicalize(filename).ok()?;
-    let filepath_relative_to_repo = filepath_absolute.strip_prefix(&repo_path_absolute).ok()?;
-
-    let mut diff_options = DiffOptions::new();
-    let pathspec = filepath_relative_to_repo.into_c_string().ok()?;
-    diff_options.pathspec(pathspec);
-    diff_options.context_lines(0);
-
-    let diff = repo
-        .diff_index_to_workdir(None, Some(&mut diff_options))
-        .ok()?;
-
-    let mut line_changes: LineChanges = HashMap::new();
-
-    let mark_section =
-        |line_changes: &mut LineChanges, start: u32, end: i32, change: LineChange| {
-            for line in start..=end as u32 {
-                line_changes.insert(line, change);
+fn collect_changes_from_hunks(hunks: HunkIter) -> Option<LineChanges> {
+    let mut changes: LineChanges = HashMap::new();
+    for hunk in hunks {
+        if hunk.before.is_empty() && !hunk.after.is_empty() {
+            for line in hunk.after {
+                changes.insert(line + 1, LineChange::Added);
            }
-        };
-
-    let _ = diff.foreach(
-        &mut |_, _| true,
-        None,
-        Some(&mut |delta, hunk| {
-            let path = delta.new_file().path().unwrap_or_else(|| Path::new(""));
-
-            if filepath_relative_to_repo != path {
-                return false;
-            }
-
-            let old_lines = hunk.old_lines();
-            let new_start = hunk.new_start();
-            let new_lines = hunk.new_lines();
-            let new_end = (new_start + new_lines) as i32 - 1;
-
-            if old_lines == 0 && new_lines > 0 {
-                mark_section(&mut line_changes, new_start, new_end, LineChange::Added);
-            } else if new_lines == 0 && old_lines > 0 {
-                if new_start == 0 {
-                    mark_section(&mut line_changes, 1, 1, LineChange::RemovedAbove);
-                } else {
-                    mark_section(
-                        &mut line_changes,
-                        new_start,
-                        new_start as i32,
-                        LineChange::RemovedBelow,
-                    );
-                }
+        } else if hunk.after.is_empty() && !hunk.before.is_empty() {
+            if hunk.after.start == 0 {
+                changes.insert(1, LineChange::RemovedAbove);
            } else {
-                mark_section(&mut line_changes, new_start, new_end, LineChange::Modified);
+                changes.insert(hunk.after.start, LineChange::RemovedBelow);
            }
+        } else {
+            for line in hunk.after {
+                changes.insert(line + 1, LineChange::Modified);
+            }
+        }
+    }

-            true
-        }),
-        None,
+    Some(changes)
+}
+
+pub fn get_git_diff(filename: &Path) -> Option<LineChanges> {
+    let filepath_absolute = filename.canonicalize().ok()?;
+    let repository = gix::discover(filepath_absolute.parent().ok()?).ok()?;
+    let repo_path_absolute = repository.workdir()?.canonicalize().ok()?;
+    let filepath_relative_to_repo = gix::path::to_unix_separators_on_windows(gix::path::into_bstr(
+        filepath_absolute.strip_prefix(&repo_path_absolute).ok()?,
+    ));
+    let index = repository.index_or_load_from_head_or_empty().ok()?;
+    let index_entry = index.entry_by_path(filepath_relative_to_repo.as_ref())?;
+    let mut cache = repository
+        .diff_resource_cache(
+            Mode::ToGit,
+            WorktreeRoots {
+                old_root: None,
+                new_root: repository.workdir().map(Path::to_path_buf),
+            },
+        )
+        .ok()?;
+    cache
+        .set_resource(
+            index_entry.id,
+            index_entry.mode.to_tree_entry_mode()?.kind(),
+            filepath_relative_to_repo.as_ref(),
+            ResourceKind::OldOrSource,
+            &repository,
+        )
+        .ok()?;
+    cache
+        .set_resource(
+            repository.object_hash().null(),
+            EntryKind::Blob,
+            filepath_relative_to_repo.as_ref(),
+            ResourceKind::NewOrDestination,
+            &repository,
+        )
+        .ok()?;
+    let diff = gix::diff::blob::diff_with_slider_heuristics(
+        Algorithm::Histogram,
+        &cache.prepare_diff().ok()?.interned_input(),
    );

-    Some(line_changes)
+    collect_changes_from_hunks(diff.hunks())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{get_git_diff, LineChange};
+    use std::path::{Path, PathBuf};
+    use std::process::Command;
+
+    fn git(repo: &Path, args: &[&str]) {
+        let output = Command::new("git")
+            .args(args)
+            .current_dir(repo)
+            .output()
+            .expect("git command can run");
+        assert!(
+            output.status.success(),
+            "git {args:?} failed\nstdout: {}\nstderr: {}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    fn setup_repo() -> tempfile::TempDir {
+        let dir = tempfile::tempdir().expect("can create temporary directory");
+        let repo = dir.path();
+        git(repo, &["init"]);
+        git(repo, &["config", "user.email", "test@test.test"]);
+        git(repo, &["config", "user.name", "Test"]);
+        dir
+    }
+
+    fn create_and_track_file(repo: &tempfile::TempDir, filename: &str) -> PathBuf {
+        let filepath = repo.path().join(filename);
+        std::fs::write(&filepath, "file\n").expect("can write file");
+        git(repo.path(), &["add", filename]);
+        git(repo.path(), &["commit", "-m", "initial"]);
+
+        filepath.to_owned()
+    }
+
+    #[test]
+    fn not_a_git_repository() {
+        let dir = tempfile::tempdir().expect("can create temporary directory");
+        let file = dir.path().join("file.txt");
+        std::fs::write(&file, "line 1\n").expect("can write file");
+
+        assert_eq!(get_git_diff(&file), None);
+    }
+
+    #[test]
+    fn diff_is_calculated_against_index() {
+        let repo = setup_repo();
+        let file = create_and_track_file(&repo, "file.txt");
+
+        std::fs::write(&file, "line 1\nline 2 modified\n").expect("can write file");
+        // Add modified file to index -> should find 0 changes but not none
+        git(repo.path(), &["add", "file.txt"]);
+
+        assert_eq!(get_git_diff(&file).expect("empty map").len(), 0);
+    }
+
+    #[test]
+    fn diff_is_calculated_against_index_2() {
+        let repo = setup_repo();
+        let file = create_and_track_file(&repo, "file.txt");
+
+        std::fs::write(&file, "line 1\nline 2 modified\n").expect("can write file");
+        git(repo.path(), &["add", "file.txt"]);
+        // modify the second line again which should show a single change
+        std::fs::write(&file, "line 1\nline 2 modified again\n").expect("can write file");
+
+        assert_eq!(get_git_diff(&file).expect("one change").len(), 1);
+    }
+
+    #[test]
+    fn diff_is_calculated_correctly() {
+        let repo = setup_repo();
+        create_and_track_file(&repo, "committed.txt");
+        let filename = "committed2.txt";
+        let file = create_and_track_file(&repo, filename);
+
+        std::fs::write(&file, "file\nline 2 added\n").expect("can write file");
+        let mut changes = get_git_diff(&file).expect("multiple changes");
+        assert_eq!(changes.get(&2), Some(&LineChange::Added));
+        git(repo.path(), &["add", filename]);
+
+        std::fs::write(&file, "file\nline 2 modified\n").expect("can write file");
+        changes = get_git_diff(&file).expect("multiple changes");
+        assert_eq!(changes.get(&2), Some(&LineChange::Modified));
+        git(repo.path(), &["add", filename]);
+
+        std::fs::write(&file, "line 2 modified\nline 3 added").expect("can write file");
+        changes = get_git_diff(&file).expect("multiple changes");
+        assert_eq!(changes.get(&1), Some(&LineChange::RemovedAbove));
+        assert_eq!(changes.get(&2), Some(&LineChange::Added));
+    }
+
+    #[test]
+    fn faulty_git_version_does_not_panic() {
+        let repo = setup_repo();
+        let file = create_and_track_file(&repo, "file.txt");
+        std::fs::write(&file, "line 1\nline 2 modified\n").expect("can write file");
+        // changes are detected
+        assert_eq!(get_git_diff(&file).expect("one change").len(), 2);
+        // write invalid repositoryformatversion
+        git(
+            repo.path(),
+            &["config", "core.repositoryformatversion", "one"],
+        );
+        // changes are no longer detected
+        assert_eq!(get_git_diff(&file), None);
+    }
 }
@@ -207,7 +207,7 @@ impl<'a> Input<'a> {
                    kind: OpenedInputKind::StdIn,
                    description,
                    metadata: self.metadata,
-                    reader: InputReader::new(stdin),
+                    reader: InputReader::try_new(stdin)?,
                })
            }

@@ -216,34 +216,34 @@ impl<'a> Input<'a> {
                description,
                metadata: self.metadata,
                reader: {
-                    let mut file = File::open(&path)
-                        .map_err(|e| format!("'{}': {e}", path.to_string_lossy()))?;
+                    let path_display =
+                        crate::preprocessor::sanitize_for_terminal(&path.to_string_lossy());
+                    let mut file =
+                        File::open(&path).map_err(|e| format!("'{path_display}': {e}"))?;
                    if file.metadata()?.is_dir() {
-                        return Err(format!("'{}' is a directory.", path.to_string_lossy()).into());
+                        return Err(format!("'{path_display}' is a directory.").into());
                    }

                    if let Some(stdout) = stdout_identifier {
-                        let input_identifier = Identifier::try_from(file).map_err(|e| {
-                            format!("{}: Error identifying file: {e}", path.to_string_lossy())
-                        })?;
+                        let input_identifier = Identifier::try_from(file)
+                            .map_err(|e| format!("{path_display}: Error identifying file: {e}"))?;
                        if stdout.surely_conflicts_with(&input_identifier) {
                            return Err(format!(
-                                "IO circle detected. The input from '{}' is also an output. Aborting to avoid infinite loop.",
-                                path.to_string_lossy()
+                                "IO circle detected. The input from '{path_display}' is also an output. Aborting to avoid infinite loop.",
                            )
                            .into());
                        }
                        file = input_identifier.into_inner().expect("The file was lost in the clircle::Identifier, this should not have happened...");
                    }

-                    InputReader::new(BufReader::new(file))
+                    InputReader::try_new(BufReader::new(file))?
                },
            }),
            InputKind::CustomReader(reader) => Ok(OpenedInput {
                description,
                kind: OpenedInputKind::CustomReader,
                metadata: self.metadata,
-                reader: InputReader::new(BufReader::new(reader)),
+                reader: InputReader::try_new(BufReader::new(reader))?,
            }),
        }
    }
@@ -253,30 +253,33 @@ pub(crate) struct InputReader<'a> {
    inner: Box<dyn BufRead + 'a>,
    pub(crate) first_line: Vec<u8>,
    pub(crate) content_type: Option<ContentType>,
+    pub(crate) unbuffered: bool,
 }

 impl<'a> InputReader<'a> {
-    pub(crate) fn new<R: BufRead + 'a>(mut reader: R) -> InputReader<'a> {
-        let mut first_line = vec![];
-        reader.read_until(b'\n', &mut first_line).ok();
+    #[cfg(test)]
+    pub(crate) fn new<R: BufRead + 'a>(reader: R) -> InputReader<'a> {
+        Self::try_new(reader).expect("reading the first line failed")
+    }

-        let content_type = if first_line.is_empty() {
-            None
-        } else {
-            Some(content_inspector::inspect(&first_line[..]))
-        };
+    pub(crate) fn try_new<R: BufRead + 'a>(mut reader: R) -> io::Result<InputReader<'a>> {
+        let mut first_line = vec![];
+        reader.read_until(b'\n', &mut first_line)?;
+
+        let content_type = inspect_content_type(&first_line);

        if content_type == Some(ContentType::UTF_16LE) {
-            read_utf16_line(&mut reader, &mut first_line, 0x00, 0x0A).ok();
+            read_utf16_line(&mut reader, &mut first_line, 0x00, 0x0A)?;
        } else if content_type == Some(ContentType::UTF_16BE) {
-            read_utf16_line(&mut reader, &mut first_line, 0x0A, 0x00).ok();
+            read_utf16_line(&mut reader, &mut first_line, 0x0A, 0x00)?;
        }

-        InputReader {
+        Ok(InputReader {
            inner: Box::new(reader),
            first_line,
            content_type,
-        }
+            unbuffered: false,
+        })
    }

    pub(crate) fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<bool> {
@@ -292,9 +295,48 @@ impl<'a> InputReader<'a> {
            return read_utf16_line(&mut self.inner, buf, 0x0A, 0x00);
        }

+        if self.unbuffered {
+            return self.read_line_unbuffered(buf);
+        }
+
        let res = self.inner.read_until(b'\n', buf).map(|size| size > 0)?;
        Ok(res)
    }
+
+    fn read_line_unbuffered(&mut self, buf: &mut Vec<u8>) -> io::Result<bool> {
+        let available = self.inner.fill_buf()?;
+        if available.is_empty() {
+            return Ok(!buf.is_empty());
+        }
+        if let Some(pos) = available.iter().position(|&b| b == b'\n') {
+            buf.extend_from_slice(&available[..=pos]);
+            self.inner.consume(pos + 1);
+        } else {
+            let len = available.len();
+            buf.extend_from_slice(available);
+            self.inner.consume(len);
+        }
+        Ok(true)
+    }
+}
+
+fn inspect_content_type(first_line: &[u8]) -> Option<ContentType> {
+    if first_line.is_empty() {
+        return None;
+    }
+
+    let content_type = content_inspector::inspect(first_line);
+    if content_type == ContentType::UTF_8 && has_zip_signature(first_line) {
+        Some(ContentType::BINARY)
+    } else {
+        Some(content_type)
+    }
+}
+
+fn has_zip_signature(bytes: &[u8]) -> bool {
+    [b"PK\x03\x04", b"PK\x05\x06", b"PK\x07\x08"]
+        .into_iter()
+        .any(|signature| bytes.starts_with(signature))
 }

 fn read_utf16_line<R: BufRead>(
@@ -352,6 +394,43 @@ fn basic() {
    assert!(buffer.is_empty());
 }

+#[test]
+fn zip_magic_headers_are_treated_as_binary() {
+    for content in [b"PK\x03\x04hello", b"PK\x05\x06hello", b"PK\x07\x08hello"] {
+        let reader = InputReader::new(&content[..]);
+        assert_eq!(Some(ContentType::BINARY), reader.content_type);
+    }
+}
+
+#[test]
+fn non_zip_pk_prefix_is_not_treated_as_binary() {
+    assert_eq!(
+        Some(ContentType::UTF_8),
+        inspect_content_type(b"PK\x03\x03hello")
+    );
+}
+
+#[test]
+fn input_open_returns_initial_read_errors() {
+    struct FailingRead;
+
+    impl Read for FailingRead {
+        fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> {
+            Err(io::Error::other("initial read failed"))
+        }
+    }
+
+    let input = Input::from_reader(Box::new(FailingRead));
+    let result = input.open(io::empty(), None);
+
+    assert!(result.is_err());
+    assert!(result
+        .err()
+        .unwrap()
+        .to_string()
+        .contains("initial read failed"));
+}
+
 #[test]
 fn utf16le() {
    let content = b"\xFF\xFE\x73\x00\x0A\x00\x64\x00";
@@ -381,6 +460,89 @@ fn utf16le() {
    assert!(buffer.is_empty());
 }

+#[test]
+fn unbuffered_returns_partial_data() {
+    use std::io::Cursor;
+
+    let content = b"first line\npartial";
+    let mut reader = InputReader::new(Cursor::new(&content[..]));
+    reader.unbuffered = true;
+
+    // First call returns first_line (buffered during new())
+    let mut buffer = vec![];
+    let res = reader.read_line(&mut buffer);
+    assert!(res.is_ok());
+    assert!(res.unwrap());
+    assert_eq!(b"first line\n", &buffer[..]);
+
+    // Subsequent calls use unbuffered reading
+    buffer.clear();
+    let res = reader.read_line(&mut buffer);
+    assert!(res.is_ok());
+    assert!(res.unwrap());
+    assert_eq!(b"partial", &buffer[..]);
+
+    // EOF
+    buffer.clear();
+    let res = reader.read_line(&mut buffer);
+    assert!(res.is_ok());
+    assert!(!res.unwrap());
+    assert!(buffer.is_empty());
+}
+
+#[test]
+fn unbuffered_returns_complete_lines() {
+    use std::io::Cursor;
+
+    let content = b"line1\nline2\n";
+    let mut reader = InputReader::new(Cursor::new(&content[..]));
+    reader.unbuffered = true;
+
+    // First call returns first_line
+    let mut buffer = vec![];
+    let res = reader.read_line(&mut buffer);
+    assert!(res.is_ok());
+    assert!(res.unwrap());
+    assert_eq!(b"line1\n", &buffer[..]);
+
+    // Second call returns line2 (complete line with newline)
+    buffer.clear();
+    let res = reader.read_line(&mut buffer);
+    assert!(res.is_ok());
+    assert!(res.unwrap());
+    assert_eq!(b"line2\n", &buffer[..]);
+
+    // EOF
+    buffer.clear();
+    let res = reader.read_line(&mut buffer);
+    assert!(res.is_ok());
+    assert!(!res.unwrap());
+    assert!(buffer.is_empty());
+}
+
+#[test]
+fn unbuffered_eof_handling() {
+    use std::io::Cursor;
+
+    let content = b"only line\n";
+    let mut reader = InputReader::new(Cursor::new(&content[..]));
+    reader.unbuffered = true;
+
+    // First call returns first_line
+    let mut buffer = vec![];
+    let res = reader.read_line(&mut buffer);
+    assert!(res.is_ok());
+    assert!(res.unwrap());
+    assert_eq!(b"only line\n", &buffer[..]);
+
+    // EOF - empty buffer returns false
+    buffer.clear();
+    let res = reader.read_line(&mut buffer);
+    assert!(res.is_ok());
+    assert!(!res.unwrap());
+    assert!(buffer.is_empty());
+}
+
 #[test]
 fn utf16le_issue3367() {
    let content = b"\xFF\xFE\x0A\x4E\x00\x4E\x0A\x4F\x00\x52\x0A\x00\
@@ -14,6 +14,53 @@ use crate::{
    input::{Input, InputKind, InputReader, OpenedInput, OpenedInputKind},
 };

+/// Wrap `s` in POSIX single quotes. An embedded `'` is encoded as `'\''`
+/// (close, escaped quote, reopen) since `'...'` has no escape character.
+fn shell_quote(s: &str) -> String {
+    if !s.contains('\'') {
+        let mut quoted = String::with_capacity(s.len() + 2);
+        quoted.push('\'');
+        quoted.push_str(s);
+        quoted.push('\'');
+        return quoted;
+    }
+    let mut quoted = String::with_capacity(s.len() + 2);
+    quoted.push('\'');
+    for c in s.chars() {
+        if c == '\'' {
+            quoted.push_str("'\\''");
+        } else {
+            quoted.push(c);
+        }
+    }
+    quoted.push('\'');
+    quoted
+}
+
+/// Substitute the first `%s` in a $LESSOPEN/$LESSCLOSE template with a quoted value.
+fn shell_substitute(template: &str, replacement: &str) -> String {
+    template.replacen("%s", &shell_quote(replacement), 1)
+}
+
+/// Substitute the first two `%s` occurrences positionally in one pass; chaining
+/// `shell_substitute` twice would mis-target if `first` itself contains `%s`.
+fn shell_substitute_two(template: &str, first: &str, second: &str) -> String {
+    let mut out = String::with_capacity(template.len() + first.len() + second.len() + 4);
+    let mut remaining = template;
+    let mut to_substitute = [Some(first), Some(second)];
+    for slot in &mut to_substitute {
+        if let Some(idx) = remaining.find("%s") {
+            out.push_str(&remaining[..idx]);
+            out.push_str(&shell_quote(slot.take().unwrap()));
+            remaining = &remaining[idx + 2..];
+        } else {
+            break;
+        }
+    }
+    out.push_str(remaining);
+    out
+}
+
 /// Preprocess files and/or stdin using $LESSOPEN and $LESSCLOSE
 pub(crate) struct LessOpenPreprocessor {
    lessopen: String,
@@ -87,7 +134,7 @@ impl LessOpenPreprocessor {
                    None => return input.open(stdin, stdout_identifier),
                };

-                let mut lessopen_command = shell(self.lessopen.replacen("%s", path_str, 1));
+                let mut lessopen_command = shell(shell_substitute(&self.lessopen, path_str));
                lessopen_command.stdout(Stdio::piped());

                let lessopen_output = match lessopen_command.execute_output() {
@@ -122,7 +169,7 @@ impl LessOpenPreprocessor {
                    let mut stdin_buffer = Vec::new();
                    stdin.read_to_end(&mut stdin_buffer)?;

-                    let mut lessopen_command = shell(self.lessopen.replacen("%s", "-", 1));
+                    let mut lessopen_command = shell(shell_substitute(&self.lessopen, "-"));
                    lessopen_command.stdout(Stdio::piped());

                    let lessopen_output = match lessopen_command.execute_input_output(&stdin_buffer)
@@ -155,7 +202,7 @@ impl LessOpenPreprocessor {

        Ok(OpenedInput {
            kind,
-            reader: InputReader::new(BufReader::new(
+            reader: InputReader::try_new(BufReader::new(
                if matches!(self.kind, LessOpenKind::TempFile) {
                    let lessopen_string = match String::from_utf8(lessopen_stdout) {
                        Ok(string) => string,
@@ -181,7 +228,7 @@ impl LessOpenPreprocessor {
                        lessclose: self
                            .lessclose
                            .as_ref()
-                            .map(|s| s.replacen("%s", &path_str, 1).replacen("%s", &stdout, 1)),
+                            .map(|s| shell_substitute_two(s, &path_str, &stdout)),
                    }
                } else {
                    Preprocessed {
@@ -189,10 +236,10 @@ impl LessOpenPreprocessor {
                        lessclose: self
                            .lessclose
                            .as_ref()
-                            .map(|s| s.replacen("%s", &path_str, 1).replacen("%s", "-", 1)),
+                            .map(|s| shell_substitute_two(s, &path_str, "-")),
                    }
                },
-            )),
+            ))?,
            metadata: input.metadata,
            description: input.description,
        })
@@ -261,7 +308,7 @@ impl Drop for Preprocessed {
                }
            };

-            if lessclose_output.status.success() {
+            if !lessclose_output.status.success() {
                bat_warning!("$LESSCLOSE exited with nonzero exit code",)
            };
        }
@@ -384,4 +431,65 @@ mod tests {

        Ok(())
    }
+
+    #[test]
+    fn shell_quote_plain_filename() {
+        assert_eq!(super::shell_quote("file.txt"), "'file.txt'");
+        assert_eq!(super::shell_quote("with space.txt"), "'with space.txt'");
+        assert_eq!(super::shell_quote(""), "''");
+        assert_eq!(super::shell_quote("-"), "'-'");
+    }
+
+    #[test]
+    fn shell_quote_metacharacters_neutralised() {
+        assert_eq!(super::shell_quote("; rm -rf ~ ;"), "'; rm -rf ~ ;'");
+        assert_eq!(super::shell_quote("$(payload)"), "'$(payload)'");
+        assert_eq!(super::shell_quote("`payload`"), "'`payload`'");
+        assert_eq!(super::shell_quote("a|b&c;d"), "'a|b&c;d'");
+        assert_eq!(super::shell_quote("..>/dev/null"), "'..>/dev/null'");
+        assert_eq!(super::shell_quote("\n\t"), "'\n\t'");
+    }
+
+    #[test]
+    fn shell_quote_embedded_single_quote() {
+        assert_eq!(super::shell_quote("it's"), "'it'\\''s'");
+        assert_eq!(super::shell_quote("'"), "''\\'''");
+        assert_eq!(super::shell_quote("a'b'c"), "'a'\\''b'\\''c'");
+    }
+
+    #[test]
+    fn shell_substitute_only_replaces_first_percent_s() {
+        assert_eq!(super::shell_substitute("echo %s", "x"), "echo 'x'");
+        assert_eq!(super::shell_substitute("echo %s %s", "x"), "echo 'x' %s");
+    }
+
+    #[test]
+    fn shell_substitute_protects_against_filename_injection() {
+        let template = "|preproc %s";
+        let attacker_filename = "; rm -rf ~ ;";
+        let result = super::shell_substitute(template, attacker_filename);
+        assert_eq!(result, "|preproc '; rm -rf ~ ;'");
+    }
+
+    #[test]
+    fn shell_substitute_two_replaces_first_two_placeholders() {
+        assert_eq!(
+            super::shell_substitute_two("echo %s and %s done", "a", "b"),
+            "echo 'a' and 'b' done"
+        );
+        // A third %s is left alone.
+        assert_eq!(
+            super::shell_substitute_two("echo %s %s %s", "a", "b"),
+            "echo 'a' 'b' %s"
+        );
+    }
+
+    #[test]
+    fn shell_substitute_two_handles_percent_s_in_first_argument() {
+        // The chained-substitute approach would replace the injected `%s` here.
+        assert_eq!(
+            super::shell_substitute_two("a %s b %s c", "%s", "second"),
+            "a '%s' b 'second' c"
+        );
+    }
 }
@@ -54,6 +54,7 @@ mod vscreen;
 pub(crate) mod wrapping;

 pub use nonprintable_notation::{BinaryBehavior, NonprintableNotation};
+pub use preprocessor::sanitize_for_terminal;
 pub use preprocessor::StripAnsiMode;
 pub use pretty_printer::{Input, PrettyPrinter, Syntax};
 pub use syntax_mapping::{MappingTarget, SyntaxMapping};
@@ -23,6 +23,18 @@ pub struct BuiltinPager {
 impl BuiltinPager {
    fn new() -> Self {
        let pager = minus::Pager::new();
+
+        let mut input_register = minus::input::HashedEventRegister::default();
+        input_register.add_key_events(&["home"], |_, _| {
+            minus::input::InputEvent::UpdateUpperMark(0)
+        });
+        input_register.add_key_events(&["end"], |_, _| {
+            minus::input::InputEvent::UpdateUpperMark(usize::MAX)
+        });
+        pager
+            .set_input_classifier(Box::new(input_register))
+            .expect("failed to set input classifier on newly created pager");
+
        let handle = {
            let pager = pager.clone();
            Some(spawn(move || {
@@ -105,6 +117,10 @@ impl OutputType {
        let resolved_path = match grep_cli::resolve_binary(&pager.bin) {
            Ok(path) => path,
            Err(_) => {
+                crate::bat_warning!(
+                    "Pager '{}' not found, outputting to stdout instead",
+                    pager.bin
+                );
                return Ok(OutputType::stdout());
            }
        };
@@ -131,8 +147,13 @@ impl OutputType {
                    p.arg("-S"); // Short version of --chop-long-lines for compatibility
                }

+                let less_version = retrieve_less_version(&pager.bin);
+
                // Ensures that 'less' quits together with 'bat'
-                p.arg("-K"); // Short version of '--quit-on-intr'
+                // The BusyBox version of less does not support -K
+                if less_version != Some(LessVersion::BusyBox) {
+                    p.arg("-K"); // Short version of '--quit-on-intr'
+                }

                // Passing '--no-init' fixes a bug with '--quit-if-one-screen' in older
                // versions of 'less'. Unfortunately, it also breaks mouse-wheel support.
@@ -141,16 +162,18 @@ impl OutputType {
                //
                // For newer versions (530 or 558 on Windows), we omit '--no-init' as it
                // is not needed anymore.
-                match retrieve_less_version(&pager.bin) {
-                    None => {
-                        p.arg("--no-init");
+                if single_screen_action == SingleScreenAction::Quit {
+                    match less_version {
+                        None => {
+                            p.arg("--no-init");
+                        }
+                        Some(LessVersion::Less(version))
+                            if (version < 530 || (cfg!(windows) && version < 558)) =>
+                        {
+                            p.arg("--no-init");
+                        }
+                        _ => {}
                    }
-                    Some(LessVersion::Less(version))
-                        if (version < 530 || (cfg!(windows) && version < 558)) =>
-                    {
-                        p.arg("--no-init");
-                    }
-                    _ => {}
                }
            } else {
                p.args(args);
@@ -167,7 +190,13 @@ impl OutputType {
        Ok(p.stdin(Stdio::piped())
            .spawn()
            .map(OutputType::Pager)
-            .unwrap_or_else(|_| OutputType::stdout()))
+            .unwrap_or_else(|_| {
+                crate::bat_warning!(
+                    "Pager '{}' not found, outputting to stdout instead",
+                    &pager.bin
+                );
+                OutputType::stdout()
+            }))
    }

    pub(crate) fn stdout() -> Self {
@@ -208,8 +237,8 @@ impl Drop for OutputType {
                let _ = command.wait();
            }
            OutputType::BuiltinPager(ref mut pager) => {
-                if pager.handle.is_some() {
-                    let _ = pager.handle.take().unwrap().join().unwrap();
+                if let Some(handle) = pager.handle.take() {
+                    let _ = handle.join();
                }
            }
            OutputType::Stdout(_) => (),
@@ -229,4 +258,11 @@ impl OutputHandle<'_> {
            Self::FmtWrite(handle) => handle.write_fmt(args).map_err(Into::into),
        }
    }
+
+    pub fn flush(&mut self) -> Result<()> {
+        match self {
+            Self::IoWrite(handle) => handle.flush().map_err(Into::into),
+            Self::FmtWrite(_) => Ok(()),
+        }
+    }
 }
@@ -139,16 +139,169 @@ pub fn replace_nonprintable(
 /// Strips ANSI escape sequences from the input.
 pub fn strip_ansi(line: &str) -> String {
    let mut buffer = String::with_capacity(line.len());
-
    for seq in EscapeSequenceOffsetsIterator::new(line) {
        if let EscapeSequenceOffsets::Text { .. } = seq {
            buffer.push_str(&line[seq.index_of_start()..seq.index_past_end()]);
        }
    }
-
    buffer
 }

+/// Strips ANSI escape sequences and substitutes terminal-active control bytes
+/// and visual-spoofing Unicode codepoints (bidi, zero-width) with U+FFFD.
+pub fn sanitize(line: &str) -> String {
+    let stripped = strip_ansi(line);
+    let mut buffer = String::with_capacity(stripped.len());
+    let bytes = stripped.as_bytes();
+    let mut start = 0;
+    let mut i = 0;
+    // Skip directly to the next trigger byte instead of testing each one.
+    while let Some(off) = bytes[i..].iter().position(|&b| is_sanitize_trigger(b)) {
+        i += off;
+        let len = sanitize_at(bytes, i, &stripped, &mut buffer, &mut start);
+        i += len;
+    }
+    buffer.push_str(&stripped[start..]);
+    buffer
+}
+
+#[inline]
+fn is_sanitize_trigger(b: u8) -> bool {
+    // C0 controls minus \t \n \f; DEL; UTF-8 leads with dangerous codepoints.
+    matches!(b, 0x00..=0x08 | 0x0B | 0x0D..=0x1F | 0x7F | 0xC2 | 0xD8 | 0xE2 | 0xEF)
+}
+
+/// Substitutes the byte/sequence at `bytes[i]` (or passes it through on
+/// false-alarm trigger), flushing the prefix from `start`. Returns bytes consumed.
+fn sanitize_at(
+    bytes: &[u8],
+    i: usize,
+    full: &str,
+    buffer: &mut String,
+    start: &mut usize,
+) -> usize {
+    buffer.push_str(&full[*start..i]);
+    let consumed = match bytes[i] {
+        b'\r' if bytes.get(i + 1) == Some(&b'\n') => {
+            buffer.push_str("\r\n");
+            2
+        }
+        // 0xC2 leads U+0080..U+00FF; filter the C1 range.
+        0xC2 if matches!(bytes.get(i + 1), Some(0x80..=0x9F)) => {
+            buffer.push('\u{FFFD}');
+            2
+        }
+        0xE2 if is_dangerous_e2(bytes, i) => {
+            buffer.push('\u{FFFD}');
+            3
+        }
+        // 0xEF 0xBB 0xBF = U+FEFF (BOM / zero-width no-break space).
+        0xEF if bytes.get(i + 1) == Some(&0xBB) && bytes.get(i + 2) == Some(&0xBF) => {
+            buffer.push('\u{FFFD}');
+            3
+        }
+        // 0xD8 0x9C = U+061C (Arabic letter mark, a bidi control). The rest of
+        // the 0xD8 block is ordinary Arabic text.
+        0xD8 if bytes.get(i + 1) == Some(&0x9C) => {
+            buffer.push('\u{FFFD}');
+            2
+        }
+        // False-alarm trigger: pass the full UTF-8 sequence through.
+        lead @ (0xC2 | 0xD8 | 0xE2 | 0xEF) => {
+            let n = utf8_len_from_lead(lead);
+            buffer.push_str(&full[i..i + n]);
+            n
+        }
+        _ => {
+            buffer.push('\u{FFFD}');
+            1
+        }
+    };
+    *start = i + consumed;
+    consumed
+}
+
+#[inline]
+fn is_dangerous_e2(bytes: &[u8], i: usize) -> bool {
+    // U+200B..D (zero-width), U+200E..F (LRM/RLM), U+202A..E (bidi embedding
+    // and override), U+2066..9 (bidi isolates).
+    matches!(
+        (bytes.get(i + 1), bytes.get(i + 2)),
+        (Some(0x80), Some(0x8B..=0x8F | 0xAA..=0xAE)) | (Some(0x81), Some(0xA6..=0xA9))
+    )
+}
+
+#[inline]
+fn utf8_len_from_lead(lead: u8) -> usize {
+    if lead < 0x80 {
+        1
+    } else if lead < 0xE0 {
+        2
+    } else if lead < 0xF0 {
+        3
+    } else {
+        4
+    }
+}
+
+/// Escape C0, DEL, and C1 control characters so a string from an untrusted
+/// filename or path can be safely written to the terminal.
+pub fn sanitize_for_terminal(input: &str) -> String {
+    if !input
+        .chars()
+        .any(|c| matches!(c, '\x00'..='\x08' | '\x0A'..='\x1F' | '\x7F'..='\u{9F}'))
+    {
+        return input.to_owned();
+    }
+
+    let mut out = String::with_capacity(input.len() + 8);
+    for c in input.chars() {
+        match c {
+            '\t' => out.push('\t'),
+            '\x00'..='\x1F' => {
+                out.push('^');
+                out.push(char::from_u32(0x40 + c as u32).unwrap_or('?'));
+            }
+            '\x7F' => out.push_str("^?"),
+            '\u{80}'..='\u{9F}' => {
+                use std::fmt::Write as _;
+                let _ = write!(out, "\\u{{{:x}}}", c as u32);
+            }
+            other => out.push(other),
+        }
+    }
+    out
+}
+
+/// Strips overstrike sequences (backspace formatting) from input.
+///
+/// Overstrike formatting is used by man pages and some help output:
+/// - Bold: `X\x08X` (character, backspace, same character)
+/// - Underline: `_\x08X` (underscore, backspace, character)
+///
+/// This function removes these sequences, keeping only the visible character.
+/// `first_backspace` is the position of the first backspace in the line.
+pub fn strip_overstrike(line: &str, first_backspace: usize) -> String {
+    let mut output = String::with_capacity(line.len());
+    output.push_str(&line[..first_backspace]);
+    output.pop();
+
+    let mut remaining = &line[first_backspace + 1..];
+
+    loop {
+        if let Some(pos) = remaining.find('\x08') {
+            output.push_str(&remaining[..pos]);
+            output.pop();
+            remaining = &remaining[pos + 1..];
+        } else {
+            output.push_str(remaining);
+            break;
+        }
+    }
+
+    output
+}
+
 #[derive(Debug, PartialEq, Clone, Copy, Default)]
 pub enum StripAnsiMode {
    #[default]
@@ -211,3 +364,168 @@ fn test_strip_ansi() {
        "multiple sequences"
    );
 }
+
+#[test]
+fn test_strip_ansi_8bit_c1_introducers() {
+    assert_eq!(strip_ansi("a\u{9B}31mRED\u{9B}0mb"), "aREDb");
+    assert_eq!(strip_ansi("a\x1bP1;0|payload\x1b\\b"), "ab");
+    assert_eq!(strip_ansi("a\u{90}body\u{9C}b"), "ab");
+}
+
+#[test]
+fn test_strip_ansi_single_char_esc() {
+    // strip_ansi must consume both bytes of single-byte ESC sequences (RIS, DECSC, keypad, VT52).
+    assert_eq!(strip_ansi("a\x1bcb"), "ab");
+    assert_eq!(strip_ansi("a\x1b7b\x1b8c"), "abc");
+    assert_eq!(strip_ansi("a\x1b=b\x1b>c"), "abc");
+    assert_eq!(strip_ansi("a\x1bZb"), "ab");
+}
+
+#[test]
+fn test_strip_ansi_preserves_control_bytes() {
+    // strip_ansi removes only ANSI escape sequences; control bytes pass through.
+    assert_eq!(strip_ansi("safe\rEVIL"), "safe\rEVIL");
+    assert_eq!(strip_ansi("a\x08b\x07c\x0E\x0Fd"), "a\x08b\x07c\x0E\x0Fd");
+}
+
+#[test]
+fn test_sanitize_substitutes_dangerous_bytes() {
+    let r = '\u{FFFD}';
+    assert_eq!(sanitize("safe\rEVIL"), format!("safe{r}EVIL"));
+    assert_eq!(sanitize("a\x08b"), format!("a{r}b"));
+    assert_eq!(sanitize("a\x07b"), format!("a{r}b"));
+    assert_eq!(sanitize("a\x0Bb"), format!("a{r}b"));
+    assert_eq!(sanitize("a\x0Eb\x0Fc"), format!("a{r}b{r}c"));
+    assert_eq!(sanitize("a\u{8D}b"), format!("a{r}b"));
+    assert_eq!(sanitize("a\u{85}b"), format!("a{r}b"));
+    assert_eq!(sanitize("trailing\r"), format!("trailing{r}"));
+    assert_eq!(sanitize("a\x7Fb"), format!("a{r}b"));
+}
+
+#[test]
+fn test_sanitize_substitutes_bidi_and_zero_width() {
+    let r = '\u{FFFD}';
+    // Trojan-Source bidi formatting: U+202A..U+202E
+    assert_eq!(sanitize("a\u{202A}b"), format!("a{r}b"));
+    assert_eq!(sanitize("a\u{202E}b"), format!("a{r}b"));
+    // Bidi isolates: U+2066..U+2069
+    assert_eq!(sanitize("a\u{2066}b"), format!("a{r}b"));
+    assert_eq!(sanitize("a\u{2069}b"), format!("a{r}b"));
+    // Zero-width: U+200B..U+200D
+    assert_eq!(sanitize("a\u{200B}b"), format!("a{r}b"));
+    assert_eq!(sanitize("a\u{200D}b"), format!("a{r}b"));
+    // BOM in middle of file: U+FEFF
+    assert_eq!(sanitize("a\u{FEFF}b"), format!("a{r}b"));
+}
+
+#[test]
+fn test_sanitize_substitutes_every_bidi_control() {
+    // Unicode Bidi_Control is exactly these 12 codepoints. Covering only some
+    // of them leaves a reordering attack available through the rest.
+    let r = '\u{FFFD}';
+    for c in [
+        '\u{061C}', '\u{200E}', '\u{200F}', '\u{202A}', '\u{202B}', '\u{202C}', '\u{202D}',
+        '\u{202E}', '\u{2066}', '\u{2067}', '\u{2068}', '\u{2069}',
+    ] {
+        assert_eq!(
+            sanitize(&format!("a{c}b")),
+            format!("a{r}b"),
+            "U+{:04X} was not substituted",
+            c as u32
+        );
+    }
+}
+
+#[test]
+fn test_sanitize_preserves_arabic_sharing_the_alm_lead_byte() {
+    // U+061C is reached via lead byte 0xD8, which also leads ordinary Arabic.
+    assert_eq!(
+        sanitize("\u{0600}\u{061F}\u{06FF}"),
+        "\u{0600}\u{061F}\u{06FF}"
+    );
+    assert_eq!(sanitize("مرحبا بالعالم"), "مرحبا بالعالم");
+}
+
+#[test]
+fn test_sanitize_preserves_legitimate_bytes() {
+    assert_eq!(sanitize("crlf\r\nline\r\n"), "crlf\r\nline\r\n");
+    assert_eq!(sanitize("a\tb\nc"), "a\tb\nc");
+    assert_eq!(sanitize("plain ascii"), "plain ascii");
+    assert_eq!(sanitize("üñíçödé"), "üñíçödé");
+    // FF (U+000C) passes through; section separator in C source / Emacs Lisp.
+    assert_eq!(sanitize("section1\x0Csection2"), "section1\x0Csection2");
+    // Common Unicode that shares a UTF-8 lead byte with dangerous codepoints
+    // must pass through unchanged.
+    assert_eq!(sanitize("snowman ☃ moon ☾"), "snowman ☃ moon ☾");
+    assert_eq!(sanitize("emoji 🎉 ☃"), "emoji 🎉 ☃");
+    assert_eq!(sanitize("0xC2 lead: ÿ ñ ç"), "0xC2 lead: ÿ ñ ç");
+    assert_eq!(sanitize("CJK 漢字 emoji 🦀"), "CJK 漢字 emoji 🦀");
+}
+
+#[test]
+fn test_sanitize_strips_ansi() {
+    let r = '\u{FFFD}';
+    // sanitize is a strict superset of strip_ansi.
+    assert_eq!(sanitize("a\x1B[31mb\x1B[0mc"), "abc");
+    assert_eq!(sanitize("a\u{9B}31mb\u{9B}0mc"), "abc");
+    // ANSI then dangerous byte: ANSI gone, byte substituted.
+    assert_eq!(sanitize("\x1B[31mhello\rEVIL"), format!("hello{r}EVIL"));
+}
+
+#[test]
+fn test_strip_overstrike() {
+    // Bold: X\x08X (same char repeated)
+    assert_eq!(strip_overstrike("H\x08Hello", 1), "Hello");
+
+    // Underline: _\x08X (underscore before char)
+    assert_eq!(strip_overstrike("_\x08Hello", 1), "Hello");
+
+    // Multiple overstrike sequences
+    assert_eq!(strip_overstrike("B\x08Bo\x08ol\x08ld\x08d", 1), "Bold");
+
+    // Backspace at start of line (nothing to pop)
+    assert_eq!(strip_overstrike("\x08Hello", 0), "Hello");
+
+    // Multiple consecutive backspaces
+    assert_eq!(strip_overstrike("ABC\x08\x08\x08XYZ", 3), "XYZ");
+
+    // Unicode with overstrike
+    assert_eq!(strip_overstrike("ä\x08äöü", 2), "äöü");
+}
+
+#[test]
+fn test_sanitize_for_terminal_passthrough() {
+    assert_eq!(sanitize_for_terminal(""), "");
+    assert_eq!(sanitize_for_terminal("hello.txt"), "hello.txt");
+    assert_eq!(sanitize_for_terminal("résumé.pdf"), "résumé.pdf");
+    assert_eq!(sanitize_for_terminal("日本語.md"), "日本語.md");
+    assert_eq!(
+        sanitize_for_terminal("path/with spaces/file.log"),
+        "path/with spaces/file.log"
+    );
+    assert_eq!(sanitize_for_terminal("a\tb"), "a\tb");
+}
+
+#[test]
+fn test_sanitize_for_terminal_c0_controls() {
+    assert_eq!(
+        sanitize_for_terminal("\x1b[31mINJECTED\x1b[0m.txt"),
+        "^[[31mINJECTED^[[0m.txt"
+    );
+    assert_eq!(sanitize_for_terminal("bad\x07rest"), "bad^Grest");
+    assert_eq!(sanitize_for_terminal("\x00\x08\n\r\x7F"), "^@^H^J^M^?");
+    assert_eq!(sanitize_for_terminal("\u{9b}31m"), "\\u{9b}31m");
+    assert_eq!(
+        sanitize_for_terminal("\u{9d}0;pwned\x07"),
+        "\\u{9d}0;pwned^G"
+    );
+}
+
+#[test]
+fn test_sanitize_for_terminal_idempotent_on_sanitized() {
+    let dirty = "\x1b]0;pwned\x07file.txt";
+    let clean = sanitize_for_terminal(dirty);
+    assert_eq!(sanitize_for_terminal(&clean), clean);
+    assert!(!clean.contains('\x1b'));
+    assert!(!clean.contains('\x07'));
+}
@@ -192,6 +192,15 @@ impl<'a> PrettyPrinter<'a> {
        self
    }

+    /// Whether to sanitize untrusted input for safe display (default: never)
+    ///
+    /// Strips ANSI escape sequences and additionally substitutes terminal-active
+    /// control bytes and bidi / zero-width codepoints with U+FFFD.
+    pub fn sanitize(&mut self, mode: StripAnsiMode) -> &mut Self {
+        self.config.sanitize = mode;
+        self
+    }
+
    /// Text wrapping mode (default: do not wrap)
    pub fn wrapping_mode(&mut self, mode: WrappingMode) -> &mut Self {
        self.config.wrapping_mode = mode;
@@ -29,8 +29,10 @@ use crate::error::*;
 use crate::input::OpenedInput;
 use crate::line_range::{MaxBufferedLineNumber, RangeCheckResult};
 use crate::output::OutputHandle;
-use crate::preprocessor::strip_ansi;
-use crate::preprocessor::{expand_tabs, replace_nonprintable};
+use crate::preprocessor::{
+    expand_tabs, replace_nonprintable, sanitize, sanitize_for_terminal, strip_ansi,
+    strip_overstrike,
+};
 use crate::style::StyleComponent;
 use crate::terminal::{as_terminal_escaped, to_ansi_color};
 use crate::vscreen::{AnsiStyle, EscapeSequence, EscapeSequenceIterator};
@@ -38,6 +40,16 @@ use crate::wrapping::WrappingMode;
 use crate::BinaryBehavior;
 use crate::StripAnsiMode;

+// Return the displayed width of a character.
+//
+// Control characters (0x00..=0x1F and 0x7F) are rendered by the terminal
+// in caret notation (e.g. ^@, ^A, ..., ^?), which occupies two columns.
+// UnicodeWidthChar::width() returns None for these, so we map them to 2
+// here instead of the previous default of 0.
+fn char_width(c: char) -> usize {
+    c.width().unwrap_or(if c.is_control() { 2 } else { 0 })
+}
+
 const ANSI_UNDERLINE_ENABLE: EscapeSequence = EscapeSequence::CSI {
    raw_sequence: "\x1B[4m",
    parameters: "4",
@@ -199,6 +211,8 @@ pub(crate) struct InteractivePrinter<'a> {
    background_color_highlight: Option<Color>,
    consecutive_empty_lines: usize,
    strip_ansi: bool,
+    sanitize: bool,
+    strip_overstrike: bool,
 }

 impl<'a> InteractivePrinter<'a> {
@@ -261,19 +275,31 @@ impl<'a> InteractivePrinter<'a> {

        let needs_to_match_syntax = (!is_printing_binary
            || matches!(config.binary, BinaryBehavior::AsText))
-            && (config.colored_output || config.strip_ansi == StripAnsiMode::Auto);
+            && (config.colored_output
+                || config.strip_ansi == StripAnsiMode::Auto
+                || config.sanitize == StripAnsiMode::Auto);

-        let (is_plain_text, highlighter_from_set) = if needs_to_match_syntax {
+        let (is_plain_text, strip_overstrike, highlighter_from_set) = if needs_to_match_syntax {
            // Determine the type of syntax for highlighting
            const PLAIN_TEXT_SYNTAX: &str = "Plain Text";
-            match assets.get_syntax(config.language, input, &config.syntax_mapping) {
+            const MANPAGE_SYNTAX: &str = "Manpage";
+            const COMMAND_HELP_SYNTAX: &str = "Command Help";
+            match assets.get_syntax(
+                config.language,
+                config.fallback_syntax,
+                input,
+                &config.syntax_mapping,
+            ) {
                Ok(syntax_in_set) => (
                    syntax_in_set.syntax.name == PLAIN_TEXT_SYNTAX,
+                    syntax_in_set.syntax.name == MANPAGE_SYNTAX
+                        || syntax_in_set.syntax.name == COMMAND_HELP_SYNTAX,
                    Some(HighlighterFromSet::new(syntax_in_set, theme)),
                ),

                Err(Error::UndetectedSyntax(_)) => (
                    true,
+                    false,
                    Some(
                        assets
                            .find_syntax_by_name(PLAIN_TEXT_SYNTAX)?
@@ -285,7 +311,7 @@ impl<'a> InteractivePrinter<'a> {
                Err(e) => return Err(e),
            }
        } else {
-            (false, None)
+            (false, false, None)
        };

        // Determine when to strip ANSI sequences
@@ -297,6 +323,14 @@ impl<'a> InteractivePrinter<'a> {
            _ => false,
        };

+        let sanitize = match config.sanitize {
+            _ if config.show_nonprintable => false,
+            StripAnsiMode::Always => true,
+            StripAnsiMode::Auto if is_plain_text => false,
+            StripAnsiMode::Auto => true,
+            _ => false,
+        };
+
        Ok(InteractivePrinter {
            panel_width,
            colors,
@@ -310,6 +344,8 @@ impl<'a> InteractivePrinter<'a> {
            background_color_highlight,
            consecutive_empty_lines: 0,
            strip_ansi,
+            sanitize,
+            strip_overstrike,
        })
    }

@@ -448,6 +484,11 @@ impl Printer for InteractivePrinter<'_> {
        input: &OpenedInput,
        add_header_padding: bool,
    ) -> Result<()> {
+        // If input is empty and quiet_empty is enabled, skip all output
+        if self.content_type.is_none() && self.config.quiet_empty {
+            return Ok(());
+        }
+
        if add_header_padding && self.config.style_components.rule() {
            self.print_horizontal_line_term(handle, self.colors.rule)?;
        }
@@ -463,7 +504,7 @@ impl Printer for InteractivePrinter<'_> {
                     (but will be present if the output of 'bat' is piped). You can use 'bat -A' \
                     to show the binary file contents.",
                    Yellow.paint("[bat warning]"),
-                    input.description.summary(),
+                    sanitize_for_terminal(&input.description.summary()),
                )?;
            } else if self.config.style_components.grid() {
                self.print_horizontal_line(handle, '┬')?;
@@ -517,9 +558,11 @@ impl Printer for InteractivePrinter<'_> {
                        "{}{}{mode}",
                        description
                            .kind()
-                            .map(|kind| format!("{kind}: "))
+                            .map(|kind| format!("{}: ", sanitize_for_terminal(kind)))
                            .unwrap_or_else(|| "".into()),
-                        self.colors.header_value.paint(description.title()),
+                        self.colors
+                            .header_value
+                            .paint(sanitize_for_terminal(description.title())),
                    );
                    self.print_header_multiline_component(handle, &header_filename)
                }
@@ -550,6 +593,11 @@ impl Printer for InteractivePrinter<'_> {
    }

    fn print_footer(&mut self, handle: &mut OutputHandle, _input: &OpenedInput) -> Result<()> {
+        // If input is empty and quiet_empty is enabled, skip footer
+        if self.content_type.is_none() && self.config.quiet_empty {
+            return Ok(());
+        }
+
        if self.config.style_components.grid()
            && (self.content_type.is_some_and(|c| c.is_text())
                || self.config.show_nonprintable
@@ -568,11 +616,23 @@ impl Printer for InteractivePrinter<'_> {
        let title = "8<";
        let title_count = title.chars().count();

-        let snip_left = "─ ".repeat((self.config.term_width - panel_count - (title_count / 2)) / 4);
+        let snip_left = "─ ".repeat(
+            self.config
+                .term_width
+                .saturating_sub(panel_count)
+                .saturating_sub(title_count / 2)
+                / 4,
+        );
        let snip_left_count = snip_left.chars().count(); // Can't use .len() with Unicode.

-        let snip_right =
-            " ─".repeat((self.config.term_width - panel_count - snip_left_count - title_count) / 2);
+        let snip_right = " ─".repeat(
+            self.config
+                .term_width
+                .saturating_sub(panel_count)
+                .saturating_sub(snip_left_count)
+                .saturating_sub(title_count)
+                / 2,
+        );

        writeln!(
            handle,
@@ -622,8 +682,16 @@ impl Printer for InteractivePrinter<'_> {
                }
            };

-            // If ANSI escape sequences are supposed to be stripped, do it before syntax highlighting.
-            if self.strip_ansi {
+            if self.strip_overstrike {
+                if let Some(pos) = line.find('\x08') {
+                    line = strip_overstrike(&line, pos).into();
+                }
+            }
+
+            // Sanitize is the strict superset; otherwise strip-ansi alone.
+            if self.sanitize {
+                line = sanitize(&line).into()
+            } else if self.strip_ansi {
                line = strip_ansi(&line).into()
            }

@@ -759,11 +827,21 @@ impl Printer for InteractivePrinter<'_> {
                            // Displayed width of line_buf
                            let mut current_width = 0;

+                            let word_wrap = matches!(self.config.wrapping_mode, WrappingMode::Word);
+
+                            // For word wrapping, track last whitespace position.
+                            let mut last_ws_idx: Option<usize> = None;
+
                            for c in text.chars() {
                                // calculate the displayed width for next character
-                                let cw = c.width().unwrap_or(0);
+                                let cw = char_width(c);
                                current_width += cw;

+                                // Track whitespace positions for word wrapping.
+                                if word_wrap && c.is_whitespace() {
+                                    last_ws_idx = Some(line_buf.len());
+                                }
+
                                // if next character cannot be printed on this line,
                                // flush the buffer.
                                if current_width > max_width {
@@ -785,13 +863,37 @@ impl Printer for InteractivePrinter<'_> {
                                        }
                                    }

+                                    // Determine the break point and remainder
+                                    // for word wrapping.
+                                    let (emit_end, rest_start) = if word_wrap {
+                                        if let Some(ws_idx) = last_ws_idx {
+                                            // Skip the whitespace character itself
+                                            // and carry the rest to the next line.
+                                            let rs = ws_idx
+                                                + line_buf[ws_idx..]
+                                                    .chars()
+                                                    .next()
+                                                    .map(|ch| ch.len_utf8())
+                                                    .unwrap_or(0);
+                                            (ws_idx, Some(rs))
+                                        } else {
+                                            (line_buf.len(), None)
+                                        }
+                                    } else {
+                                        (line_buf.len(), None)
+                                    };
+
                                    // It wraps.
                                    write!(
                                        handle,
                                        "{}{}\n{}",
                                        as_terminal_escaped(
                                            style,
-                                            &format!("{}{line_buf}", self.ansi_style),
+                                            &format!(
+                                                "{}{}",
+                                                self.ansi_style,
+                                                &line_buf[..emit_end]
+                                            ),
                                            self.config.true_color,
                                            self.config.colored_output,
                                            self.config.use_italic_text,
@@ -804,8 +906,19 @@ impl Printer for InteractivePrinter<'_> {
                                    cursor = 0;
                                    max_width = cursor_max;

-                                    line_buf.clear();
-                                    current_width = cw;
+                                    if let Some(rs) = rest_start {
+                                        // Word wrap: carry remainder to next line.
+                                        let remainder = line_buf[rs..].to_string();
+                                        let rem_width: usize =
+                                            remainder.chars().map(char_width).sum();
+                                        line_buf.clear();
+                                        line_buf.push_str(&remainder);
+                                        current_width = rem_width + cw;
+                                    } else {
+                                        line_buf.clear();
+                                        current_width = cw;
+                                    }
+                                    last_ws_idx = None;
                                }

                                line_buf.push(c);
@@ -17,9 +17,16 @@ use ignored_suffixes::IgnoredSuffixes;
 mod builtin;
 pub mod ignored_suffixes;

-fn make_glob_matcher(from: &str) -> Result<GlobMatcher> {
+/// Whether a glob pattern should be matched case-sensitively or case-insensitively.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Case {
+    Sensitive,
+    Insensitive,
+}
+
+fn make_glob_matcher(from: &str, case: Case) -> Result<GlobMatcher> {
    let matcher = GlobBuilder::new(from)
-        .case_insensitive(true)
+        .case_insensitive(matches!(case, Case::Insensitive))
        .literal_separator(true)
        .build()?
        .compile_matcher();
@@ -97,7 +104,14 @@ impl<'a> SyntaxMapping<'a> {
    }

    pub fn insert(&mut self, from: &str, to: MappingTarget<'a>) -> Result<()> {
-        let matcher = make_glob_matcher(from)?;
+        let matcher = make_glob_matcher(from, Case::Insensitive)?;
+        self.custom_mappings.push((matcher, to));
+        Ok(())
+    }
+
+    /// Like [`Self::insert`], but the glob pattern is matched case-sensitively.
+    pub fn insert_case_sensitive(&mut self, from: &str, to: MappingTarget<'a>) -> Result<()> {
+        let matcher = make_glob_matcher(from, Case::Sensitive)?;
        self.custom_mappings.push((matcher, to));
        Ok(())
    }
@@ -261,4 +275,41 @@ mod tests {
            Some(MappingTarget::MapTo("alpha"))
        );
    }
+
+    #[test]
+    fn case_sensitive_custom_mappings_work() {
+        let mut map = SyntaxMapping::new();
+        map.insert_case_sensitive("MY_SPECIAL_FILE", MappingTarget::MapTo("Python"))
+            .ok();
+
+        // Exact case matches
+        assert_eq!(
+            map.get_syntax_for("/path/to/MY_SPECIAL_FILE"),
+            Some(MappingTarget::MapTo("Python"))
+        );
+        // Different case should NOT match the case-sensitive rule
+        assert_eq!(map.get_syntax_for("/path/to/my_special_file"), None);
+        assert_eq!(map.get_syntax_for("/path/to/My_Special_File"), None);
+    }
+
+    #[test]
+    fn builtin_mappings_build_is_case_sensitive() {
+        let map = SyntaxMapping::new();
+
+        // "BUILD" (uppercase) should map to Python via case-sensitive builtin
+        assert_eq!(
+            map.get_syntax_for("/path/to/BUILD"),
+            Some(MappingTarget::MapTo("Python"))
+        );
+        // "build" (lowercase) should still map to MapToUnknown
+        assert_eq!(
+            map.get_syntax_for("/path/to/build"),
+            Some(MappingTarget::MapToUnknown)
+        );
+        // Mixed case should NOT match the Python rule
+        assert_eq!(
+            map.get_syntax_for("/path/to/Build"),
+            Some(MappingTarget::MapToUnknown)
+        );
+    }
 }
@@ -3,7 +3,7 @@ use std::env;
 use globset::GlobMatcher;
 use once_cell::sync::Lazy;

-use crate::syntax_mapping::{make_glob_matcher, MappingTarget};
+use crate::syntax_mapping::{make_glob_matcher, Case, MappingTarget};

 // Static syntax mappings generated from /src/syntax_mapping/builtins/ by the
 // build script (/build/syntax_mapping.rs).
@@ -53,8 +53,8 @@ include!(concat!(
 /// A failure to compile is a fatal error.
 ///
 /// Used internally by `Lazy<Option<GlobMatcher>>`'s lazy evaluation closure.
-fn build_matcher_fixed(from: &str) -> GlobMatcher {
-    make_glob_matcher(from).expect("A builtin fixed glob matcher failed to compile")
+fn build_matcher_fixed(from: &str, case: Case) -> GlobMatcher {
+    make_glob_matcher(from, case).expect("A builtin fixed glob matcher failed to compile")
 }

 /// Join a list of matcher segments to create a glob string, replacing all
@@ -64,7 +64,7 @@ fn build_matcher_fixed(from: &str) -> GlobMatcher {
 /// to compile.
 ///
 /// Used internally by `Lazy<Option<GlobMatcher>>`'s lazy evaluation closure.
-fn build_matcher_dynamic(segs: &[MatcherSegment]) -> Option<GlobMatcher> {
+fn build_matcher_dynamic(segs: &[MatcherSegment], case: Case) -> Option<GlobMatcher> {
    // join segments
    let mut buf = String::new();
    for seg in segs {
@@ -77,7 +77,7 @@ fn build_matcher_dynamic(segs: &[MatcherSegment]) -> Option<GlobMatcher> {
        }
    }
    // compile glob matcher
-    let matcher = make_glob_matcher(&buf).ok()?;
+    let matcher = make_glob_matcher(&buf, case).ok()?;
    Some(matcher)
 }

@@ -20,12 +20,10 @@ syntax mappings defined by all TOML files, and embed them into the binary.

 ## File syntax

-Each TOML file should contain a single section named `mappings`, with each of
-its keys being a language identifier (first column of `bat -L`; also referred to
-as "target").
+Each TOML file should contain a single section named `mappings`, with each of its keys being a language
+identifier (first column of `bat -L`; also referred to as "target").

-The value of each key should be an array of strings, with each item being a glob
-matcher. We will call each of these items a "rule".
+The value of each key should be an array of "rules". The rules are expected to be objects with a `glob` string and a `case_sensitive` boolean. For simplification, a rule can be just a glob string, which is shorthand for the default case insensitive mode.

 For example, if `foo-application` uses both TOML and YAML configuration files,
 we could write something like this:
@@ -98,6 +96,15 @@ like this:
 ]
 ```

+### Case sensitivity
+
+By default, all glob patterns are matched case-insensitively. To match a pattern case-sensitively, use the object form of the rule with the `case_sensitive` option:
+
+```toml
+[mappings]
+"Python" = [{ glob = "BUILD", case_sensitive = true }]
+```
+
 ## Ordering

 At compile time, all TOML files applicable to the target are processed in
@@ -0,0 +1,2 @@
+[mappings]
+"Python" = [{ glob = "BUILD", case_sensitive = true }]
@@ -1,2 +1,2 @@
 [mappings]
-"XML" = ["*.csproj", "*.vbproj", "*.props", "*.targets"]
+"XML" = ["*.csproj", "*.vbproj", "*.props", "*.targets", "*.slnx"]
@@ -0,0 +1,3 @@
+[mappings]
+"INI" = [".boto", "**/gcloud/configurations/config_*"]
+"Git Ignore" = [".gcloudignore"]
@@ -1,3 +1,3 @@
 # JSON Lines is a simple variation of JSON #2535
 [mappings]
-"JSON" = ["*.jsonl", "*.jsonc", "*.jsonld", "*.geojson", "*.ndjson"]
+"JSON" = ["*.jsonl", "*.jsonc", "*.jsonld", "*.geojson", "*.ndjson", "*.code-workspace"]
@@ -0,0 +1,2 @@
+[mappings]
+"Makefile" = ["justfile", "Justfile", ".justfile", "*.justfile"]
@@ -1,2 +1,2 @@
 [mappings]
-"SSH Config" = ["**/.ssh/config"]
+"SSH Config" = ["**/.ssh/**/config"]
@@ -0,0 +1,2 @@
+[mappings]
+"Git Ignore" = [".?*ignore"]
@@ -0,0 +1,2 @@
+[mappings]
+"INI" = ["/etc/dnf/dnf.conf", "/etc/yum.repos.d/*.repo"]
@@ -1,5 +1,5 @@
 # see `man quadlet`
 [mappings]
 "INI" = [
-    "**/containers/systemd/**/*.{container,volume,network,kube,image}",
+    "**/containers/systemd/**/*.{container,volume,network,kube,image,build,pod,artifact}",
 ]
@@ -0,0 +1,2 @@
+[mappings]
+"INI" = ["**/ghostty/**/*.ghostty", "**/ghostty/themes/*"]
@@ -288,7 +288,7 @@ fn color_scheme_from_system() -> Option<ColorScheme> {
    const PREFERENCES_FILE: &str = "Library/Preferences/.GlobalPreferences.plist";
    const STYLE_KEY: &str = "AppleInterfaceStyle";

-    let preferences_file = home::home_dir()
+    let preferences_file = std::env::home_dir()
        .map(|home| home.join(PREFERENCES_FILE))
        .expect("Could not get home directory");

@@ -386,12 +386,23 @@ impl<'a> EscapeSequenceOffsetsIterator<'a> {
    }

    fn next_text(&mut self) -> Option<EscapeSequenceOffsets> {
-        self.chars_take_while(|c| c != '\x1B')
+        self.chars_take_while(|c| !is_sequence_introducer(c))
            .map(|(start, end)| EscapeSequenceOffsets::Text { start, end })
    }

    fn next_sequence(&mut self) -> Option<EscapeSequenceOffsets> {
        let (start_sequence, c) = self.chars.next().expect("to not be finished");
+
+        // Handle 8-bit C1 introducers as their 7-bit `ESC <x>` equivalents.
+        match c {
+            '\u{9B}' => return self.next_csi_body(start_sequence),
+            '\u{9D}' => return self.next_osc_body(start_sequence),
+            '\u{90}' | '\u{98}' | '\u{9E}' | '\u{9F}' => {
+                return self.next_string_terminated_body(start_sequence)
+            }
+            _ => {}
+        }
+
        match self.chars.peek() {
            None => Some(EscapeSequenceOffsets::Unknown {
                start: start_sequence,
@@ -400,12 +411,24 @@ impl<'a> EscapeSequenceOffsetsIterator<'a> {

            Some((_, ']')) => self.next_osc(start_sequence),
            Some((_, '[')) => self.next_csi(start_sequence),
-            Some((i, c)) => match c {
+            // 7-bit DCS/SOS/PM/APC: `ESC P/X/^/_` introduces a string body.
+            Some((_, 'P' | 'X' | '^' | '_')) => {
+                self.chars.next();
+                self.next_string_terminated_body(start_sequence)
+            }
+            Some(&(i, c)) => match c {
                '\x20'..='\x2F' => self.next_nf(start_sequence),
-                c => Some(EscapeSequenceOffsets::Unknown {
-                    start: start_sequence,
-                    end: i + c.len_utf8(),
-                }),
+                c => {
+                    // Single-byte ESC sequence (RIS, DECSC/DECRC, keypad, VT52 etc.).
+                    let end = match self.chars.next() {
+                        Some((j, fc)) => j + fc.len_utf8(),
+                        None => i + c.len_utf8(),
+                    };
+                    Some(EscapeSequenceOffsets::Unknown {
+                        start: start_sequence,
+                        end,
+                    })
+                }
            },
        }
    }
@@ -413,12 +436,27 @@ impl<'a> EscapeSequenceOffsetsIterator<'a> {
    fn next_osc(&mut self, start_sequence: usize) -> Option<EscapeSequenceOffsets> {
        let (osc_open_index, osc_open_char) = self.chars.next().expect("to not be finished");
        debug_assert_eq!(osc_open_char, ']');
+        let start_command = osc_open_index + osc_open_char.len_utf8();
+        Some(self.read_osc_body(start_sequence, start_command))
+    }

+    /// OSC body parser entered after the 8-bit introducer U+009D was consumed.
+    fn next_osc_body(&mut self, start_sequence: usize) -> Option<EscapeSequenceOffsets> {
+        let start_command = start_sequence + '\u{9D}'.len_utf8();
+        Some(self.read_osc_body(start_sequence, start_command))
+    }
+
+    fn read_osc_body(
+        &mut self,
+        start_sequence: usize,
+        start_command: usize,
+    ) -> EscapeSequenceOffsets {
        let mut start_terminator: usize;
        let mut end_sequence: usize;

        loop {
-            match self.chars_take_while(|c| !matches!(c, '\x07' | '\x1B')) {
+            // ST is BEL, ESC `\\`, or U+009C.
+            match self.chars_take_while(|c| !matches!(c, '\x07' | '\x1B' | '\u{9C}')) {
                None => {
                    start_terminator = self.text.len();
                    end_sequence = start_terminator;
@@ -437,6 +475,11 @@ impl<'a> EscapeSequenceOffsetsIterator<'a> {
                    break;
                }

+                Some((ti, '\u{9C}')) => {
+                    end_sequence = ti + '\u{9C}'.len_utf8();
+                    break;
+                }
+
                Some((ti, '\x1B')) => {
                    match self.chars.next() {
                        Some((i, '\\')) => {
@@ -466,20 +509,82 @@ impl<'a> EscapeSequenceOffsetsIterator<'a> {
            }
        }

-        Some(EscapeSequenceOffsets::OSC {
+        EscapeSequenceOffsets::OSC {
            start_sequence,
-            start_command: osc_open_index + osc_open_char.len_utf8(),
+            start_command,
            start_terminator,
            end: end_sequence,
+        }
+    }
+
+    /// DCS/SOS/PM/APC body parser. Emitted as `Unknown` so the body is stripped.
+    fn next_string_terminated_body(
+        &mut self,
+        start_sequence: usize,
+    ) -> Option<EscapeSequenceOffsets> {
+        let mut end_sequence: usize;
+
+        loop {
+            match self.chars_take_while(|c| !matches!(c, '\x07' | '\x1B' | '\u{9C}')) {
+                None => {
+                    end_sequence = self.text.len();
+                    break;
+                }
+                Some((_, end)) => {
+                    end_sequence = end;
+                }
+            }
+
+            match self.chars.next() {
+                Some((ti, '\x07')) => {
+                    end_sequence = ti + '\x07'.len_utf8();
+                    break;
+                }
+                Some((ti, '\u{9C}')) => {
+                    end_sequence = ti + '\u{9C}'.len_utf8();
+                    break;
+                }
+                Some((ti, '\x1B')) => match self.chars.next() {
+                    Some((i, '\\')) => {
+                        end_sequence = i + '\\'.len_utf8();
+                        break;
+                    }
+                    None => {
+                        end_sequence = ti + '\x1B'.len_utf8();
+                        break;
+                    }
+                    _ => {}
+                },
+                None => break,
+                Some((_, tc)) => {
+                    panic!("this should not be reached: char {tc:?}")
+                }
+            }
+        }
+
+        Some(EscapeSequenceOffsets::Unknown {
+            start: start_sequence,
+            end: end_sequence,
        })
    }

    fn next_csi(&mut self, start_sequence: usize) -> Option<EscapeSequenceOffsets> {
        let (csi_open_index, csi_open_char) = self.chars.next().expect("to not be finished");
        debug_assert_eq!(csi_open_char, '[');
+        Some(self.read_csi_body(start_sequence, csi_open_index + csi_open_char.len_utf8()))
+    }

-        let start_parameters: usize = csi_open_index + csi_open_char.len_utf8();
+    /// CSI body parser entered after the 8-bit introducer U+009B was consumed.
+    fn next_csi_body(&mut self, start_sequence: usize) -> Option<EscapeSequenceOffsets> {
+        let start_parameters = start_sequence + '\u{9B}'.len_utf8();
+        Some(self.read_csi_body(start_sequence, start_parameters))
+    }

+    fn read_csi_body(
+        &mut self,
+        start_sequence: usize,
+        start_parameters: usize,
+    ) -> EscapeSequenceOffsets {
        // Keep iterating while within the range of `0x30-0x3F`.
        let mut start_intermediates: usize = start_parameters;
        if let Some((_, end)) = self.chars_take_while(|c| matches!(c, '\x30'..='\x3F')) {
@@ -498,13 +603,13 @@ impl<'a> EscapeSequenceOffsetsIterator<'a> {
            Some((i, c)) => i + c.len_utf8(),
        };

-        Some(EscapeSequenceOffsets::CSI {
+        EscapeSequenceOffsets::CSI {
            start_sequence,
            start_parameters,
            start_intermediates,
            start_final_byte,
            end: end_of_sequence,
-        })
+        }
    }

    fn next_nf(&mut self, start_sequence: usize) -> Option<EscapeSequenceOffsets> {
@@ -543,13 +648,25 @@ impl Iterator for EscapeSequenceOffsetsIterator<'_> {
    type Item = EscapeSequenceOffsets;
    fn next(&mut self) -> Option<Self::Item> {
        match self.chars.peek() {
-            Some((_, '\x1B')) => self.next_sequence(),
+            Some((_, c)) if is_sequence_introducer(*c) => self.next_sequence(),
            Some((_, _)) => self.next_text(),
            None => None,
        }
    }
 }

+/// True for ESC and the 8-bit C1 sequence introducers (DCS/SOS/CSI/OSC/PM/APC).
+#[inline]
+fn is_sequence_introducer(c: char) -> bool {
+    if (c as u32) < 0x80 {
+        return c == '\x1B';
+    }
+    matches!(
+        c,
+        '\u{90}' | '\u{98}' | '\u{9B}' | '\u{9D}' | '\u{9E}' | '\u{9F}'
+    )
+}
+
 /// An iterator over ANSI/VT escape sequences within a string.
 ///
 /// ## Example
@@ -717,6 +834,79 @@ mod tests {
        );
    }

+    #[test]
+    fn test_escape_sequence_offsets_iterator_parses_8bit_csi() {
+        let mut iter = EscapeSequenceOffsetsIterator::new("\u{9B}31m");
+        assert_eq!(
+            iter.next(),
+            Some(EscapeSequenceOffsets::CSI {
+                start_sequence: 0,
+                start_parameters: 2,
+                start_intermediates: 4,
+                start_final_byte: 4,
+                end: 5,
+            })
+        );
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_escape_sequence_offsets_iterator_parses_8bit_osc_with_8bit_st() {
+        let mut iter = EscapeSequenceOffsetsIterator::new("\u{9D}0;title\u{9C}");
+        assert_eq!(
+            iter.next(),
+            Some(EscapeSequenceOffsets::OSC {
+                start_sequence: 0,
+                start_command: 2,
+                start_terminator: 9,
+                end: 11,
+            })
+        );
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_escape_sequence_offsets_iterator_parses_7bit_dcs_consumes_body() {
+        let mut iter = EscapeSequenceOffsetsIterator::new("\x1BP1;0;|payload\x1B\\rest");
+        assert_eq!(
+            iter.next(),
+            Some(EscapeSequenceOffsets::Unknown { start: 0, end: 16 })
+        );
+        assert_eq!(
+            iter.next(),
+            Some(EscapeSequenceOffsets::Text { start: 16, end: 20 })
+        );
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_escape_sequence_offsets_iterator_8bit_dcs_consumes_body() {
+        let mut iter = EscapeSequenceOffsetsIterator::new("\u{90}body\u{9C}rest");
+        assert_eq!(
+            iter.next(),
+            Some(EscapeSequenceOffsets::Unknown { start: 0, end: 8 })
+        );
+        assert_eq!(
+            iter.next(),
+            Some(EscapeSequenceOffsets::Text { start: 8, end: 12 })
+        );
+    }
+
+    #[test]
+    fn test_escape_sequence_offsets_iterator_truncated_dcs_consumes_to_eof() {
+        // Unterminated DCS must still be consumed, not emitted as `Text`.
+        let input = "\x1BPno-terminator";
+        let mut iter = EscapeSequenceOffsetsIterator::new(input);
+        assert_eq!(
+            iter.next(),
+            Some(EscapeSequenceOffsets::Unknown {
+                start: 0,
+                end: input.len(),
+            })
+        );
+        assert_eq!(iter.next(), None);
+    }
+
    #[test]
    fn test_escape_sequence_offsets_iterator_parses_csi() {
        let mut iter = EscapeSequenceOffsetsIterator::new("\x1B[m");
@@ -1,6 +1,7 @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum WrappingMode {
    Character,
+    Word,
    // The bool specifies whether wrapping has been explicitly disabled by the user via --wrap=never
    NoWrapping(bool),
 }
@@ -34,7 +34,6 @@ fn all_themes_are_present() {
            "Solarized (light)",
            "Sublime Snazzy",
            "TwoDark",
-            "Visual Studio Dark+",
            "ansi",
            "base16",
            "base16-256",
@@ -0,0 +1,30 @@
+GIT-COMMIT(1)                     Git Manual                     GIT-COMMIT(1)
+
+NNAAMMEE
+       git-commit - Record changes to the repository
+
+SSYYNNOOPPSSIISS
+       ggiitt ccoommmmiitt [--aa | ----iinntteerraaccttiivvee | ----ppaattcchh] [--ss] [--vv] [--uu[_<_m_o_d_e_>]] [----aammeenndd]
+               [----ddrryy--rruunn] [(--cc | --CC | ----ssqquuaasshh) _<_c_o_m_m_i_t_> | ----ffiixxuupp [(aammeenndd|rreewwoorrdd)::]_<_c_o_m_m_i_t_>]
+               [--FF _<_f_i_l_e_> | --mm _<_m_s_g_>] [----rreesseett--aauutthhoorr] [----aallllooww--eemmppttyy]
+               [----aallllooww--eemmppttyy--mmeessssaaggee] [----nnoo--vveerriiffyy] [--ee] [----aauutthhoorr==_<_a_u_t_h_o_r_>]
+               [----ddaattee==_<_d_a_t_e_>] [----cclleeaannuupp==_<_m_o_d_e_>] [----[nnoo--]ssttaattuuss]
+               [--ii | --oo] [----ppaatthhssppeecc--ffrroomm--ffiillee==_<_f_i_l_e_> [----ppaatthhssppeecc--ffiillee--nnuull]]
+               [(----ttrraaiilleerr _<_t_o_k_e_n_>[(==|::)_<_v_a_l_u_e_>])...] [--SS[_<_k_e_y_i_d_>]]
+               [----] [_<_p_a_t_h_s_p_e_c_>...]
+
+DDEESSCCRRIIPPTTIIOONN
+       Create a new commit containing the current contents of the index and
+       the given log message describing the changes. The new commit is a
+       direct child of HEAD, usually the tip of the current branch, and the
+       branch is updated to point to it (unless no branch is associated with
+       the working tree, in which case HHEEAADD is "detached" as described in ggiitt--
+       cchheecckkoouutt(1)).
+
+       The content to be committed can be specified in several ways:
+
+        1. by using ggiitt--aadddd(1) to incrementally "add" changes to the index
+           before using the ccoommmmiitt command (Note: even modified files must be
+           "added");
+
+        2. by using ggiitt--rrmm(1) to remove files from the working tree and the
@@ -0,0 +1 @@
+BBold tteexxtt and _u_n_d_e_r_l_i_n_e
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+NAME="${0##*/}"
+for i in {1..3}; do
+    echo "hello $NAME $i"
+done
@@ -0,0 +1,2 @@
+#!/usr/bin/expect -f
+set timeout 30
@@ -0,0 +1,2 @@
+#!/usr/bin/env tclsh
+puts "Hello from tclsh"
@@ -0,0 +1,2 @@
+#!/usr/bin/wish
+button .b -text "Click"
@@ -0,0 +1,3 @@
+The quick brown fox jumps over the lazy dog and then runs away
+superlongwordthatdefinitelyexceedstheterminalwidthandshouldfallbacktocharacterwrapping
+short words here
@@ -4,6 +4,7 @@ import itertools
 import subprocess
 import pathlib
 import shutil
+from typing import Iterable


 def generate_snapshots():
@@ -19,22 +20,23 @@ def generate_snapshots():


 def generate_style_snapshot(style):
-    generate_snapshot(style.replace(",", "_"), "--style={}".format(style))
+    generate_snapshot(style.replace(",", "_"), ["--style={}".format(style)])


-def generate_snapshot(name, arguments):
-    command = "cargo run -- --paging=never --color=never --decorations=always "
-    command += "{args} sample.rs > output/{name}.snapshot.txt".format(
-        name=name,
-        args=arguments
-    )
+def generate_snapshot(name: str, arguments: Iterable[str]):
+    output_file = "output/{name}.snapshot.txt".format(name=name)
+    command = [
+        "cargo", "run", "--", "--paging=never", "--color=never",
+        "--decorations=always", *arguments, "sample.rs"
+    ]
    print("generating snapshot for {}".format(name))
-    subprocess.call(command, shell=True)
+    with open(output_file, "w") as f:
+        subprocess.call(command, stdout=f)


 def build_bat():
    print("building bat")
-    subprocess.call("cargo build", cwd="../..", shell=True)
+    subprocess.call(["cargo", "build"], cwd="../..")


 def prepare_output_dir():
@@ -49,7 +51,7 @@ def modify_sample_file():

 def undo_sample_file_modification():
    print("undoing sample.rs modifications")
-    subprocess.call("git checkout -- sample.rs", shell=True)
+    subprocess.call(["git", "checkout", "--", "sample.rs"])


 build_bat()
@@ -1,5 +1,5 @@
-[38;2;230;219;116mwith Chests.Ring_Buffers;[0m
-[38;2;230;219;116mwith USB.Device.HID.Keyboard;[0m
+[38;2;249;38;114mwith[0m[38;2;248;248;242m [0m[38;2;166;226;46mChests.Ring_Buffers[0m[38;2;248;248;242m;[0m
+[38;2;249;38;114mwith[0m[38;2;248;248;242m [0m[38;2;166;226;46mUSB.Device.HID.Keyboard[0m[38;2;248;248;242m;[0m

 [38;2;249;38;114mpackage[0m[38;2;248;248;242m [0m[38;2;249;38;114mbody[0m[38;2;248;248;242m [0m[38;2;166;226;46mClick[0m[38;2;248;248;242m [0m[38;2;249;38;114mis[0m
 [38;2;248;248;242m   [0m[38;2;117;113;94m--[0m[38;2;117;113;94m--------------[0m
@@ -1,5 +1,5 @@
-[38;2;230;219;116mwith HAL.GPIO;[0m
-[38;2;230;219;116mwith USB.Device.HID.Keyboard;[0m
+[38;2;249;38;114mwith[0m[38;2;248;248;242m [0m[38;2;166;226;46mHAL.GPIO[0m[38;2;248;248;242m;[0m
+[38;2;249;38;114mwith[0m[38;2;248;248;242m [0m[38;2;166;226;46mUSB.Device.HID.Keyboard[0m[38;2;248;248;242m;[0m

 [38;2;249;38;114mgeneric[0m
 [38;2;249;38;114m   [0m[38;2;166;226;46mNb_Bounce[0m[38;2;249;38;114m :[0m[38;2;248;248;242m Natural;[0m
@@ -0,0 +1,19 @@
+[3;38;2;124;120;101m#[0m[3;38;2;124;120;101m!/bin/ksh[0m
+[3;38;2;124;120;101m#[0m
+[3;38;2;124;120;101m#[0m[3;38;2;124;120;101m https://www.qnx.com/developers/docs/6.4.0/neutrino/user_guide/scripts.html[0m
+[3;38;2;124;120;101m#[0m[3;38;2;124;120;101m tfind:[0m
+[3;38;2;124;120;101m#[0m[3;38;2;124;120;101m script to look for strings in various files and dump to less[0m
+
+[38;2;249;38;114mcase[0m[38;2;255;255;255m [0m[38;2;255;255;255m$[0m[38;2;255;255;255m#[0m[38;2;255;255;255m [0m[38;2;249;38;114min[0m
+[38;2;255;255;255m1[0m[38;2;249;38;114m)[0m
+[38;2;255;255;255m    [0m[38;2;255;255;255mfind[0m[38;2;255;255;255m .[0m[3;38;2;253;151;31m -[0m[3;38;2;253;151;31mname[0m[38;2;255;255;255m [0m[38;2;255;255;255m'[0m[38;2;230;219;116m*.[ch][0m[38;2;255;255;255m'[0m[38;2;255;255;255m [0m[38;2;249;38;114m|[0m[38;2;255;255;255m [0m[38;2;255;255;255mxargs[0m[38;2;255;255;255m grep [0m[38;2;255;255;255m$[0m[38;2;255;255;255m1[0m[38;2;255;255;255m [0m[38;2;249;38;114m|[0m[38;2;255;255;255m [0m[38;2;255;255;255mless[0m
+[38;2;255;255;255m    [0m[38;2;102;217;239mexit[0m[38;2;255;255;255m 0   [0m[3;38;2;124;120;101m#[0m[3;38;2;124;120;101m good status[0m
+[38;2;249;38;114mesac[0m
+
+[38;2;102;217;239mecho[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116mUse tfind stuff_to_find                               [0m[38;2;255;255;255m"[0m
+[38;2;102;217;239mecho[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m      where : stuff_to_find = search string           [0m[38;2;255;255;255m"[0m
+[38;2;102;217;239mecho[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m                                                      [0m[38;2;255;255;255m"[0m
+[38;2;102;217;239mecho[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116me.g. tfind console_state looks through all files in   [0m[38;2;255;255;255m"[0m[38;2;255;255;255m    [0m
+[38;2;102;217;239mecho[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m     the current directory and below and displays all [0m[38;2;255;255;255m"[0m
+[38;2;102;217;239mecho[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m     instances of console_state.[0m[38;2;255;255;255m"[0m
+[38;2;102;217;239mexit[0m[38;2;255;255;255m 1    [0m[3;38;2;124;120;101m#[0m[3;38;2;124;120;101m bad status[0m
@@ -0,0 +1,61 @@
+[38;2;249;38;114mIDENTIFICATION DIVISION[0m[38;2;248;248;242m.[0m
+[38;2;249;38;114mPROGRAM-ID[0m[38;2;248;248;242m. [0m[38;2;248;248;242mPAYROLL-CALC[0m[38;2;248;248;242m.[0m
+
+[38;2;249;38;114mDATA DIVISION[0m[38;2;248;248;242m.[0m
+[38;2;249;38;114mWORKING-STORAGE SECTION[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;190;132;255m01[0m[38;2;248;248;242m [0m[38;2;248;248;242mEMPLOYEE-DETAILS[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mEMPLOYEE-NAME[0m[38;2;248;248;242m      [0m[3;38;2;102;217;239mPIC X(30).[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m       [0m[3;38;2;102;217;239mPIC 99V9[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m        [0m[3;38;2;102;217;239mPIC 99V99[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;190;132;255m01[0m[38;2;248;248;242m [0m[38;2;248;248;242mPAY-CALCULATIONS[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m          [0m[3;38;2;102;217;239mPIC 9(5)V99.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-HOURS[0m[38;2;248;248;242m     [0m[3;38;2;102;217;239mPIC 99V9[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-PAY[0m[38;2;248;248;242m       [0m[3;38;2;102;217;239mPIC 9(5)V99.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-RATE[0m[38;2;248;248;242m           [0m[3;38;2;102;217;239mPIC V99[0m[38;2;248;248;242m [0m[38;2;249;38;114mVALUE[0m[38;2;248;248;242m [0m[38;2;190;132;255m0.10[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-AMOUNT[0m[38;2;248;248;242m         [0m[3;38;2;102;217;239mPIC 9(5)V99.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mNET-PAY[0m[38;2;248;248;242m            [0m[3;38;2;102;217;239mPIC 9(5)V99.[0m
+
+[38;2;249;38;114mPROCEDURE DIVISION[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242mMAIN-LOGIC[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116m--- COBOL Payroll Calculator ---[0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mEnter Employee Name: [0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mACCEPT[0m[38;2;248;248;242m [0m[38;2;248;248;242mEMPLOYEE-NAME[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mEnter Hours Worked (e.g., 40.5): [0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mACCEPT[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mEnter Hourly Rate (e.g., 15.75): [0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mACCEPT[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mPERFORM[0m[38;2;248;248;242m [0m[38;2;248;248;242mCALCULATE-GROSS-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mPERFORM[0m[38;2;248;248;242m [0m[38;2;248;248;242mCALCULATE-TAX[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mPERFORM[0m[38;2;248;248;242m [0m[38;2;248;248;242mCALCULATE-NET-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mPERFORM[0m[38;2;248;248;242m [0m[38;2;248;248;242mDISPLAY-RESULTS[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mSTOP RUN[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242mCALCULATE-GROSS-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mIF[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m [0m[38;2;249;38;114m>[0m[38;2;248;248;242m [0m[38;2;190;132;255m40[0m[38;2;248;248;242m [0m[38;2;249;38;114mTHEN[0m
+[38;2;248;248;242m        [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-HOURS[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m [0m[38;2;249;38;114m-[0m[38;2;248;248;242m [0m[38;2;190;132;255m40[0m
+[38;2;248;248;242m        [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-HOURS[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;190;132;255m1.5[0m
+[38;2;248;248;242m        [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m ([0m[38;2;190;132;255m40[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m) [0m[38;2;249;38;114m+[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-PAY[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mELSE[0m
+[38;2;248;248;242m        [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mEND-IF[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242mCALCULATE-TAX[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-AMOUNT[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-RATE[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242mCALCULATE-NET-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mNET-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m-[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-AMOUNT[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242mDISPLAY-RESULTS[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116m----------------------------------[0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mEmployee Name: [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mEMPLOYEE-NAME[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mHours Worked:  [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mHourly Rate:   [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mGross Pay:     [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mTax (10%):     [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-AMOUNT[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mNet Pay:       [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mNET-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116m----------------------------------[0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
@@ -0,0 +1,61 @@
+[38;2;249;38;114mIDENTIFICATION DIVISION[0m[38;2;248;248;242m.[0m
+[38;2;249;38;114mPROGRAM-ID[0m[38;2;248;248;242m. [0m[38;2;248;248;242mPAYROLL-CALC[0m[38;2;248;248;242m.[0m
+
+[38;2;249;38;114mDATA DIVISION[0m[38;2;248;248;242m.[0m
+[38;2;249;38;114mWORKING-STORAGE SECTION[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;190;132;255m01[0m[38;2;248;248;242m [0m[38;2;248;248;242mEMPLOYEE-DETAILS[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mEMPLOYEE-NAME[0m[38;2;248;248;242m      [0m[3;38;2;102;217;239mPIC X(30).[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m       [0m[3;38;2;102;217;239mPIC 99V9[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m        [0m[3;38;2;102;217;239mPIC 99V99[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;190;132;255m01[0m[38;2;248;248;242m [0m[38;2;248;248;242mPAY-CALCULATIONS[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m          [0m[3;38;2;102;217;239mPIC 9(5)V99.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-HOURS[0m[38;2;248;248;242m     [0m[3;38;2;102;217;239mPIC 99V9[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-PAY[0m[38;2;248;248;242m       [0m[3;38;2;102;217;239mPIC 9(5)V99.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-RATE[0m[38;2;248;248;242m           [0m[3;38;2;102;217;239mPIC V99[0m[38;2;248;248;242m [0m[38;2;249;38;114mVALUE[0m[38;2;248;248;242m [0m[38;2;190;132;255m0.10[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-AMOUNT[0m[38;2;248;248;242m         [0m[3;38;2;102;217;239mPIC 9(5)V99.[0m
+[38;2;248;248;242m        [0m[38;2;190;132;255m05[0m[38;2;248;248;242m [0m[38;2;248;248;242mNET-PAY[0m[38;2;248;248;242m            [0m[3;38;2;102;217;239mPIC 9(5)V99.[0m
+
+[38;2;249;38;114mPROCEDURE DIVISION[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242mMAIN-LOGIC[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116m--- COBOL Payroll Calculator ---[0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mEnter Employee Name: [0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mACCEPT[0m[38;2;248;248;242m [0m[38;2;248;248;242mEMPLOYEE-NAME[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mEnter Hours Worked (e.g., 40.5): [0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mACCEPT[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mEnter Hourly Rate (e.g., 15.75): [0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mACCEPT[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mPERFORM[0m[38;2;248;248;242m [0m[38;2;248;248;242mCALCULATE-GROSS-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mPERFORM[0m[38;2;248;248;242m [0m[38;2;248;248;242mCALCULATE-TAX[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mPERFORM[0m[38;2;248;248;242m [0m[38;2;248;248;242mCALCULATE-NET-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mPERFORM[0m[38;2;248;248;242m [0m[38;2;248;248;242mDISPLAY-RESULTS[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242m    [0m[38;2;249;38;114mSTOP RUN[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242mCALCULATE-GROSS-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mIF[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m [0m[38;2;249;38;114m>[0m[38;2;248;248;242m [0m[38;2;190;132;255m40[0m[38;2;248;248;242m [0m[38;2;249;38;114mTHEN[0m
+[38;2;248;248;242m        [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-HOURS[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m [0m[38;2;249;38;114m-[0m[38;2;248;248;242m [0m[38;2;190;132;255m40[0m
+[38;2;248;248;242m        [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-HOURS[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;190;132;255m1.5[0m
+[38;2;248;248;242m        [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m ([0m[38;2;190;132;255m40[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m) [0m[38;2;249;38;114m+[0m[38;2;248;248;242m [0m[38;2;248;248;242mOVERTIME-PAY[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mELSE[0m
+[38;2;248;248;242m        [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mEND-IF[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242mCALCULATE-TAX[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-AMOUNT[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m*[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-RATE[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242mCALCULATE-NET-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mCOMPUTE[0m[38;2;248;248;242m [0m[38;2;248;248;242mNET-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m [0m[38;2;249;38;114m-[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-AMOUNT[0m[38;2;248;248;242m.[0m
+
+[38;2;248;248;242mDISPLAY-RESULTS[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116m----------------------------------[0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mEmployee Name: [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mEMPLOYEE-NAME[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mHours Worked:  [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURS-WORKED[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mHourly Rate:   [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mHOURLY-RATE[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mGross Pay:     [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mGROSS-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mTax (10%):     [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mTAX-AMOUNT[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mNet Pay:       [0m[38;2;230;219;116m"[0m[38;2;248;248;242m [0m[38;2;248;248;242mNET-PAY[0m[38;2;248;248;242m.[0m
+[38;2;248;248;242m    [0m[38;2;249;38;114mDISPLAY[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116m----------------------------------[0m[38;2;230;219;116m"[0m[38;2;248;248;242m.[0m
@@ -1,7 +1,7 @@
 [3;38;2;253;151;31mfirst[0m[38;2;253;151;31m,[0m[38;2;102;217;239mlast[0m[38;2;253;151;31m,[0m[38;2;190;132;255maddress[0m[38;2;253;151;31m,[0m[38;2;249;38;114mcity[0m[38;2;253;151;31m,[0m[38;2;230;219;116mzip[0m
-[3;38;2;253;151;31mJohn[0m[38;2;253;151;31m,[0m[38;2;102;217;239mDoe[0m[38;2;253;151;31m,[0m[38;2;190;132;255m120 any st.[0m[38;2;253;151;31m,[0m[38;2;230;219;116m"[0m[38;2;230;219;116mAnytown, WW[0m[38;2;230;219;116m"[0m[38;2;253;151;31m,[0m[38;2;230;219;116m08123[0m
+[3;38;2;253;151;31mJohn[0m[38;2;253;151;31m,[0m[38;2;102;217;239mDoe[0m[38;2;253;151;31m,[0m[38;2;190;132;255m120 any st.[0m[38;2;253;151;31m,[0m[38;2;249;38;114m"[0m[38;2;249;38;114mAnytown, WW[0m[38;2;249;38;114m"[0m[38;2;253;151;31m,[0m[38;2;230;219;116m08123[0m
 [3;38;2;253;151;31ma[0m[38;2;253;151;31m,[0m[38;2;102;217;239mb[0m
-[3;38;2;253;151;31m1[0m[38;2;253;151;31m,[0m[38;2;230;219;116m"[0m[38;2;230;219;116mha [0m
-[38;2;190;132;255m""[0m[38;2;230;219;116mha[0m[38;2;190;132;255m""[0m[38;2;230;219;116m [0m
-[38;2;230;219;116mha[0m[38;2;230;219;116m"[0m[38;2;253;151;31m,[0m[38;2;190;132;255m120 any st.[0m[38;2;253;151;31m,[0m[38;2;230;219;116m"[0m[38;2;230;219;116mAnytown, WW[0m[38;2;230;219;116m"[0m[38;2;253;151;31m,[0m[38;2;230;219;116m08123[0m
-[3;38;2;253;151;31m3[0m[38;2;253;151;31m,[0m[38;2;102;217;239m4[0m[38;2;253;151;31m,[0m[38;2;190;132;255m120 any st.[0m[38;2;253;151;31m,[0m[38;2;230;219;116m"[0m[38;2;230;219;116mAnytown, WW[0m[38;2;230;219;116m"[0m[38;2;253;151;31m,[0m[38;2;230;219;116m08123[0m
+[3;38;2;253;151;31m1[0m[38;2;253;151;31m,[0m[38;2;102;217;239m"[0m[38;2;102;217;239mha [0m
+[38;2;190;132;255m""[0m[38;2;102;217;239mha[0m[38;2;190;132;255m""[0m[38;2;102;217;239m [0m
+[38;2;102;217;239mha[0m[38;2;102;217;239m"[0m[38;2;253;151;31m,[0m[38;2;190;132;255m120 any st.[0m[38;2;253;151;31m,[0m[38;2;249;38;114m"[0m[38;2;249;38;114mAnytown, WW[0m[38;2;249;38;114m"[0m[38;2;253;151;31m,[0m[38;2;230;219;116m08123[0m
+[3;38;2;253;151;31m3[0m[38;2;253;151;31m,[0m[38;2;102;217;239m4[0m[38;2;253;151;31m,[0m[38;2;190;132;255m120 any st.[0m[38;2;253;151;31m,[0m[38;2;249;38;114m"[0m[38;2;249;38;114mAnytown, WW[0m[38;2;249;38;114m"[0m[38;2;253;151;31m,[0m[38;2;230;219;116m08123[0m
@@ -1,3 +1,3 @@
 [3;38;2;253;151;31mfoo[0m[38;2;253;151;31m	[0m[38;2;102;217;239mbar[0m[38;2;253;151;31m	[0m[38;2;190;132;255mbaz|;,[0m[38;2;253;151;31m	[0m[38;2;249;38;114mtest[0m[38;2;253;151;31m	[0m[38;2;230;219;116mhello world[0m[38;2;253;151;31m	[0m[3;38;2;253;151;31mtsv[0m
 [3;38;2;253;151;31m1,2[0m[38;2;253;151;31m	[0m[38;2;102;217;239m1,7[0m[38;2;253;151;31m	[0m[38;2;190;132;255m2,7[0m[38;2;253;151;31m	[0m[38;2;249;38;114ma b c[0m[38;2;253;151;31m	[0m[38;2;230;219;116m"[0m[38;2;230;219;116mhello	again[0m[38;2;230;219;116m"[0m[38;2;253;151;31m	[0m[3;38;2;253;151;31mtsv[0m
-[3;38;2;230;219;116m"[0m[3;38;2;230;219;116m;|,[0m[3;38;2;230;219;116m"[0m[38;2;253;151;31m	[0m[38;2;102;217;239m;|,[0m[38;2;253;151;31m	[0m[38;2;190;132;255mbaz[0m[38;2;253;151;31m	[0m[38;2;249;38;114mtest[0m[38;2;253;151;31m	[0m[38;2;230;219;116m"[0m[38;2;230;219;116mhello world[0m[38;2;230;219;116m"[0m[38;2;253;151;31m	[0m[3;38;2;253;151;31mtsv[0m
+[3;38;2;253;151;31m"[0m[3;38;2;253;151;31m;|,[0m[3;38;2;253;151;31m"[0m[38;2;253;151;31m	[0m[38;2;102;217;239m;|,[0m[38;2;253;151;31m	[0m[38;2;190;132;255mbaz[0m[38;2;253;151;31m	[0m[38;2;249;38;114mtest[0m[38;2;253;151;31m	[0m[38;2;230;219;116m"[0m[38;2;230;219;116mhello world[0m[38;2;230;219;116m"[0m[38;2;253;151;31m	[0m[3;38;2;253;151;31mtsv[0m
--- a/Show More
+++ b/Show More