Fix #254

Return a proper error if terminal size fails
Change columns type to u16
2026-10-26 20:16:34 +00:00 · 2026-02-14 13:42:51 +01:00 · 2022-07-17 15:53:56 -04:00 · 2022-07-17 15:53:23 -04:00 · 2022-07-17 15:48:05 -04:00 · 2022-07-17 15:26:43 -04:00
15 changed files with 1973 additions and 3330 deletions
@@ -1,8 +1,8 @@
 name: CICD

 env:
+  MIN_SUPPORTED_RUST_VERSION: "1.56.1"
  CICD_INTERMEDIATES_DIR: "_cicd-intermediates"
-  MSRV_FEATURES: ""

 on:
  workflow_dispatch:
@@ -14,104 +14,84 @@ on:
      - '*'

 jobs:
-  crate_metadata:
-    name: Extract crate metadata
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - name: Extract crate information
-      id: crate_metadata
-      run: |
-        cargo metadata --no-deps --format-version 1 | jq -r '"name=" + .packages[0].name' | tee -a $GITHUB_OUTPUT
-        cargo metadata --no-deps --format-version 1 | jq -r '"version=" + .packages[0].version' | tee -a $GITHUB_OUTPUT
-        cargo metadata --no-deps --format-version 1 | jq -r '"maintainer=" + .packages[0].authors[0]' | tee -a $GITHUB_OUTPUT
-        cargo metadata --no-deps --format-version 1 | jq -r '"homepage=" + .packages[0].homepage' | tee -a $GITHUB_OUTPUT
-        cargo metadata --no-deps --format-version 1 | jq -r '"msrv=" + .packages[0].rust_version' | tee -a $GITHUB_OUTPUT
-    outputs:
-      name: ${{ steps.crate_metadata.outputs.name }}
-      version: ${{ steps.crate_metadata.outputs.version }}
-      maintainer: ${{ steps.crate_metadata.outputs.maintainer }}
-      homepage: ${{ steps.crate_metadata.outputs.homepage }}
-      msrv: ${{ steps.crate_metadata.outputs.msrv }}
-
-  ensure_cargo_fmt:
-    name: Ensure 'cargo fmt' has been run
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: dtolnay/rust-toolchain@stable
-      with:
-        components: rustfmt
-    - uses: actions/checkout@v3
-    - run: cargo fmt -- --check
-
  min_version:
    name: Minimum supported rust version
-    runs-on: ubuntu-24.04
-    needs: crate_metadata
+    runs-on: ubuntu-18.04
    steps:
    - name: Checkout source code
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2

-    - name: Install rust toolchain (v${{ needs.crate_metadata.outputs.msrv }})
-      uses: dtolnay/rust-toolchain@master
+    - name: Install rust toolchain (v${{ env.MIN_SUPPORTED_RUST_VERSION }})
+      uses: actions-rs/toolchain@v1
      with:
-        toolchain: ${{ needs.crate_metadata.outputs.msrv }}
-        components: clippy
+        toolchain: ${{ env.MIN_SUPPORTED_RUST_VERSION }}
+        default: true
+        profile: minimal # minimal component installation (ie, no documentation)
+        components: clippy, rustfmt
+
+    - name: Ensure `cargo fmt` has been run
+      uses: actions-rs/cargo@v1
+      with:
+        command: fmt
+        args: -- --check
+
    - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)
-      run: cargo clippy --locked --all-targets ${{ env.MSRV_FEATURES }}
+      uses: actions-rs/cargo@v1
+      with:
+        command: clippy
+        args: --locked --all-targets
+
    - name: Run tests
-      run: cargo test --locked ${{ env.MSRV_FEATURES }}
+      uses: actions-rs/cargo@v1
+      with:
+        command: test
+        args: --locked

  build:
-    name: ${{ matrix.job.target }} (${{ matrix.job.os }})
+    name: ${{ matrix.job.os }} (${{ matrix.job.target }})
    runs-on: ${{ matrix.job.os }}
-    needs: crate_metadata
    strategy:
      fail-fast: false
      matrix:
        job:
-          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-24.04, use-cross: true }
-          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-24.04, use-cross: true }
-          - { target: arm-unknown-linux-musleabihf, os: ubuntu-24.04, use-cross: true }
-          - { target: i686-pc-windows-msvc        , os: windows-2025                  }
-          - { target: i686-unknown-linux-gnu      , os: ubuntu-24.04, use-cross: true }
-          - { target: i686-unknown-linux-musl     , os: ubuntu-24.04, use-cross: true }
-          - { target: x86_64-apple-darwin         , os: macos-15-intel                }
-          - { target: aarch64-apple-darwin        , os: macos-15                      }
-          # Was causing CI failures unrelated to app logic
-          # - { target: x86_64-pc-windows-gnu       , os: windows-2019                  }
-          - { target: x86_64-pc-windows-msvc      , os: windows-2025                  }
-          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-24.04, use-cross: true }
-          - { target: x86_64-unknown-linux-musl   , os: ubuntu-24.04, use-cross: true }
-    env:
-      BUILD_CMD: cargo
+          - { os: ubuntu-18.04, target: arm-unknown-linux-gnueabihf , use-cross: true }
+          - { os: ubuntu-18.04, target: aarch64-unknown-linux-gnu   , use-cross: true }
+          - { os: ubuntu-18.04, target: i686-unknown-linux-gnu      , use-cross: true }
+          - { os: ubuntu-18.04, target: i686-unknown-linux-musl     , use-cross: true }
+          - { os: ubuntu-18.04, target: x86_64-unknown-linux-gnu    }
+          - { os: ubuntu-18.04, target: x86_64-unknown-linux-musl   , use-cross: true }
+          - { os: macos-10.15 , target: x86_64-apple-darwin         }
+          # - { os: windows-2019, target: i686-pc-windows-gnu         }  ## disabled; error: linker `i686-w64-mingw32-gcc` not found
+          - { os: windows-2019, target: i686-pc-windows-msvc        }
+          - { os: windows-2019, target: x86_64-pc-windows-gnu       }
+          - { os: windows-2019, target: x86_64-pc-windows-msvc      }
    steps:
    - name: Checkout source code
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2

    - name: Install prerequisites
      shell: bash
      run: |
        case ${{ matrix.job.target }} in
-          arm-unknown-linux-*) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
+          arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
          aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install gcc-aarch64-linux-gnu ;;
        esac

-    - name: Install Rust toolchain
-      uses: dtolnay/rust-toolchain@stable
-      with:
-        targets: ${{ matrix.job.target }}
-
-    - name: Install cross
-      if: matrix.job.use-cross
-      uses: taiki-e/install-action@v2
-      with:
-        tool: cross
-
-    - name: Overwrite build command env variable
-      if: matrix.job.use-cross
+    - name: Extract crate information
      shell: bash
-      run: echo "BUILD_CMD=cross" >> $GITHUB_ENV
+      run: |
+        echo "PROJECT_NAME=$(sed -n 's/^name = "\(.*\)"/\1/p' Cargo.toml | head -n1)" >> $GITHUB_ENV
+        echo "PROJECT_VERSION=$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)" >> $GITHUB_ENV
+        echo "PROJECT_MAINTAINER=$(sed -n 's/^authors = \["\(.*\)"\]/\1/p' Cargo.toml)" >> $GITHUB_ENV
+        echo "PROJECT_HOMEPAGE=$(sed -n 's/^homepage = "\(.*\)"/\1/p' Cargo.toml)" >> $GITHUB_ENV
+
+    - name: Install Rust toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        target: ${{ matrix.job.target }}
+        override: true
+        profile: minimal # minimal component installation (ie, no documentation)

    - name: Show version information (Rust, cargo, GCC)
      shell: bash
@@ -124,16 +104,21 @@ jobs:
        rustc -V

    - name: Build
-      shell: bash
-      run: $BUILD_CMD build --locked --release --target=${{ matrix.job.target }}
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: build
+        args: --release --target=${{ matrix.job.target }}

    - name: Run example
-      if: ${{ !matrix.job.use-cross }}
-      shell: bash
-      run: $BUILD_CMD run --release --target=${{ matrix.job.target }} --example=simple
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: run
+        args: --release --target=${{ matrix.job.target }} --example=simple

-    - name: Set binary name & path
-      id: bin
+    - name: Strip debug information from executable
+      id: strip
      shell: bash
      run: |
        # Figure out suffix of binary
@@ -142,13 +127,31 @@ jobs:
          *-pc-windows-*) EXE_suffix=".exe" ;;
        esac;

-        # Setup paths
-        BIN_NAME="${{ needs.crate_metadata.outputs.name }}${EXE_suffix}"
-        BIN_PATH="target/${{ matrix.job.target }}/release/${BIN_NAME}"
+        # Figure out what strip tool to use if any
+        STRIP="strip"
+        case ${{ matrix.job.target }} in
+          arm-unknown-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;;
+          aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;;
+          *-pc-windows-msvc) STRIP="" ;;
+        esac;

-        # Let subsequent steps know where to find the binary
-        echo "BIN_PATH=${BIN_PATH}" >> $GITHUB_OUTPUT
-        echo "BIN_NAME=${BIN_NAME}" >> $GITHUB_OUTPUT
+        # Setup paths
+        BIN_DIR="${{ env.CICD_INTERMEDIATES_DIR }}/stripped-release-bin/"
+        mkdir -p "${BIN_DIR}"
+        BIN_NAME="${{ env.PROJECT_NAME }}${EXE_suffix}"
+        BIN_PATH="${BIN_DIR}/${BIN_NAME}"
+
+        # Copy the release build binary to the result location
+        cp "target/${{ matrix.job.target }}/release/${BIN_NAME}" "${BIN_DIR}"
+
+        # Also strip if possible
+        if [ -n "${STRIP}" ]; then
+          "${STRIP}" "${BIN_PATH}"
+        fi
+
+        # Let subsequent steps know where to find the (stripped) bin
+        echo ::set-output name=BIN_PATH::${BIN_PATH}
+        echo ::set-output name=BIN_NAME::${BIN_NAME}

    - name: Set testing options
      id: test-options
@@ -156,41 +159,44 @@ jobs:
      run: |
        # test only library unit tests and binary for arm-type targets
        unset CARGO_TEST_OPTIONS
-        case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${{ needs.crate_metadata.outputs.name }}" ;; esac;
-        echo "CARGO_TEST_OPTIONS=${CARGO_TEST_OPTIONS}" >> $GITHUB_OUTPUT
+        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${PROJECT_NAME}" ;; esac;
+        echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}

    - name: Run tests
-      shell: bash
-      run: $BUILD_CMD test --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: test
+        args: --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}

    - name: Setup Pandoc
      uses: r-lib/actions/setup-pandoc@v2

    - name: Generate man page
-      run: pandoc -s -f markdown -t man -o "doc/${{ needs.crate_metadata.outputs.name }}.1" "doc/${{ needs.crate_metadata.outputs.name }}.1.md"
+      run: pandoc -s -f markdown -t man -o "doc/${{ env.PROJECT_NAME }}.1" "doc/${{ env.PROJECT_NAME }}.1.md"

    - name: Create tarball
      id: package
      shell: bash
      run: |
        PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
-        PKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-v${{ needs.crate_metadata.outputs.version }}-${{ matrix.job.target }}
+        PKG_BASENAME=${PROJECT_NAME}-v${PROJECT_VERSION}-${{ matrix.job.target }}
        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
-        echo "PKG_NAME=${PKG_NAME}" >> $GITHUB_OUTPUT
+        echo ::set-output name=PKG_NAME::${PKG_NAME}

        PKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/package"
        ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"
        mkdir -p "${ARCHIVE_DIR}"

        # Binary
-        cp "${{ steps.bin.outputs.BIN_PATH }}" "$ARCHIVE_DIR"
+        cp "${{ steps.strip.outputs.BIN_PATH }}" "$ARCHIVE_DIR"
+
+        # Man page
+        cp "doc/${{ env.PROJECT_NAME }}.1" "$ARCHIVE_DIR"

        # README, LICENSE and CHANGELOG files
        cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "CHANGELOG.md" "$ARCHIVE_DIR"

-        # Man page
-        cp "doc/${{ needs.crate_metadata.outputs.name }}.1" "$ARCHIVE_DIR"
-
        # base compressed package
        pushd "${PKG_STAGING}/" >/dev/null
        case ${{ matrix.job.target }} in
@@ -200,7 +206,7 @@ jobs:
        popd >/dev/null

        # Let subsequent steps know where to find the compressed package
-        echo "PKG_PATH=${PKG_STAGING}/${PKG_NAME}" >> $GITHUB_OUTPUT
+        echo ::set-output name=PKG_PATH::"${PKG_STAGING}/${PKG_NAME}"

    - name: Create Debian package
      id: debian-package
@@ -212,10 +218,10 @@ jobs:
        DPKG_DIR="${DPKG_STAGING}/dpkg"
        mkdir -p "${DPKG_DIR}"

-        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;
-        DPKG_VERSION=${{ needs.crate_metadata.outputs.version }}
+        DPKG_BASENAME=${PROJECT_NAME}
+        DPKG_CONFLICTS=${PROJECT_NAME}-musl
+        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${PROJECT_NAME}-musl ; DPKG_CONFLICTS=${PROJECT_NAME} ;; esac;
+        DPKG_VERSION=${PROJECT_VERSION}

        unset DPKG_ARCH
        case ${{ matrix.job.target }} in
@@ -227,14 +233,14 @@ jobs:
        esac;

        DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
-        echo "DPKG_NAME=${DPKG_NAME}" >> $GITHUB_OUTPUT
+        echo ::set-output name=DPKG_NAME::${DPKG_NAME}

        # Binary
-        install -Dm755 "${{ steps.bin.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.bin.outputs.BIN_NAME }}"
+        install -Dm755 "${{ steps.strip.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.strip.outputs.BIN_NAME }}"

        # Man page
-        install -Dm644 'doc/${{ needs.crate_metadata.outputs.name }}.1' "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"
-        gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"
+        install -Dm644 "doc/${{ env.PROJECT_NAME }}.1" "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"

        # README and LICENSE
        install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"
@@ -245,12 +251,12 @@ jobs:

        cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF
        Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-        Upstream-Name: ${{ needs.crate_metadata.outputs.name }}
-        Source: ${{ needs.crate_metadata.outputs.homepage }}
+        Upstream-Name: ${{ env.PROJECT_NAME }}
+        Source: ${{ env.PROJECT_HOMEPAGE }}

        Files: *
-        Copyright: ${{ needs.crate_metadata.outputs.maintainer }}
-        Copyright: $COPYRIGHT_YEARS ${{ needs.crate_metadata.outputs.maintainer }}
+        Copyright: ${{ env.PROJECT_MAINTAINER }}
+        Copyright: $COPYRIGHT_YEARS ${{ env.PROJECT_MAINTAINER }}
        License: Apache-2.0 or MIT

        License: Apache-2.0
@@ -291,28 +297,28 @@ jobs:
        Version: ${DPKG_VERSION}
        Section: utils
        Priority: optional
-        Maintainer: ${{ needs.crate_metadata.outputs.maintainer }}
-        Homepage: ${{ needs.crate_metadata.outputs.homepage }}
+        Maintainer: ${{ env.PROJECT_MAINTAINER }}
+        Homepage: ${{ env.PROJECT_HOMEPAGE }}
        Architecture: ${DPKG_ARCH}
-        Provides: ${{ needs.crate_metadata.outputs.name }}
+        Provides: ${{ env.PROJECT_NAME }}
        Conflicts: ${DPKG_CONFLICTS}
-        Description: A command-line benchmarking tool
+        Description: colorized hex viewer for the terminal.
        EOF

        DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
-        echo "DPKG_PATH=${DPKG_PATH}" >> $GITHUB_OUTPUT
+        echo ::set-output name=DPKG_PATH::${DPKG_PATH}

        # build dpkg
        fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"

    - name: "Artifact upload: tarball"
-      uses: actions/upload-artifact@main
+      uses: actions/upload-artifact@master
      with:
        name: ${{ steps.package.outputs.PKG_NAME }}
        path: ${{ steps.package.outputs.PKG_PATH }}

    - name: "Artifact upload: Debian package"
-      uses: actions/upload-artifact@main
+      uses: actions/upload-artifact@master
      if: steps.debian-package.outputs.DPKG_NAME
      with:
        name: ${{ steps.debian-package.outputs.DPKG_NAME }}
@@ -323,7 +329,7 @@ jobs:
      shell: bash
      run: |
        unset IS_RELEASE ; if [[ $GITHUB_REF =~ ^refs/tags/v[0-9].* ]]; then IS_RELEASE='true' ; fi
-        echo "IS_RELEASE=${IS_RELEASE}" >> $GITHUB_OUTPUT
+        echo ::set-output name=IS_RELEASE::${IS_RELEASE}

    - name: Publish archives and packages
      uses: softprops/action-gh-release@v1
@@ -1,118 +1,19 @@
-# v0.17.0
-
-## Features
-
- Add option to output result in C include file style, see #242 (@wpcwzy)
- Add `--color-scheme` option, see #247 (@aticu)
- Add `braille` character table, see #247 (@aticu)
- Add command line argument to generate shell completion, see #155 (@friedz)
- Add colors to `--help`/`-h`, see #253 (@starsep)
-
-## Bugfixes
-
- Fix memory allocation bug when terminal width is less than 10, see #244 (@selfup)
-
-
-# v0.16.0
-
-## Features
-
-* New `--print-color-table` option, see #229 (@sahinfalcon)
-
-## Bugfixes
-
- Throw an error when try to view a directory, see #234 (@Integral-Tech)
-
-
-# v0.15.0
-
-## Features
-
- Add codepage 1047 for EBCDIC, see #226 (@v1gnesh)
-
-## Other
-
- Rewrite CLI using the derive API, see #225 (@sorairolake)
-
-
-# v0.14.0
-
-## Features
-
-* New `--character-table` option, with the ability to use [codepage 437](https://www.azabani.com/2020/11/15/xd.html), see #194 and #195 (@sharifhsn)
-* New `--character-table=ascii` option for a ASCII-only character table, see #212 and #36 (@sharkdp)
-
-## Bugfixes
-
-* Show output when doing `hexyl /dev/zero`, see #211 (@sharifhsn)
-* Respect NO_COLOR environment variable, see #210 (@sharkdp)
-
-
-# v0.13.1
-
-## Bugfixes
-
- Correctly handle discontinuous input (stdin), see #196 and #197 (@sharifhsn)
-
-# v0.13.0
-
-## Features
-
- Support both little and big Endian dumps using `--endianness={little,big}`, see #189 and #104 (@RinHizakura)
+# unreleased

 ## Changes

- **Breaking**: Changed the meaning of the short flag `-C` to be consistent with `hexdump -C`. Previously, this would *hide* the character panel, but now `-C` *shows* the character panel, in case it has been previously (e.g. in an `alias`) disabled with `--no-characters`, see #187 (@sharkdp)
-
-## `hexyl` as a library
-
- New `endianness` method for `PrinterBuilder`
-
-
-# v0.12.0

 ## Features

- Only show one panel by default if the terminal width is not wide enough for two panels, see #182 (@sharkdp)
- Respect the `NO_COLOR` environment variable, see #179 (@sharifhsn)

 ## Bugfixes

- Do not fail with an error if `--panels=auto` is used and the output is piped, see #184 (@sharkdp)
-
-## Changes
-
- Breaking: For `xxd`-compatibility reasons, `--group_bytes` has been renamed to `--group-size` (with an `--groupsize` alias), see #121 (@sharkdp)
-
-## `hexyl` as a library
-
- Breaking: `num_group_bytes` has been renamed to `group_size`.
-
-
-# v0.11.0
-
-## Features
-
- Significantly improved performance, see #173 and #176 (@sharifhsn)
- Added variable panels through the `--panels` and `--terminal-width` flags, see [#13](https://github.com/sharkdp/hexyl/issues/13) and [#164](https://github.com/sharkdp/hexyl/pull/164) (@sharifhsn)
- Added new `--group-bytes`/`-g` option, see #104 and #170 (@RinHizakura)
- Added new `--base B` option (where `B` can be `binary`, `octal`, `decimal` or `hexadecimal`), see #147 and #178 (@sharifhsn)
- Show actual zero bytes as `⋄` in the character panel (previously: `0`), in order not to confuse them with ASCII
-  `0` bytes if colors are deactivated. Closes #166 (@sharkdp)
-
-## `hexyl` as a library
-
- Breaking change: `Printer::new` is deprecated as a part of the public API. Alternatively, you can now construct a `Printer` using the `PrinterBuilder` builder API, see [#168](https://github.com/sharkdp/hexyl/pull/168). (@sharifhsn)

 ## Other

- More tests for the squeezing feature, see #177 (@mkatychev)

-## Thank you
+## Packaging

-Special thanks go to @sharifhsn, not just for the new features,
-bugfixes and performance improvements. But also for many internal
-improvements of the code base and other maintenance tasks.


 # v0.10.0
@@ -4,67 +4,33 @@ version = 4

 [[package]]
 name = "aho-corasick"
-version = "1.1.3"
+version = "0.7.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
 dependencies = [
 "memchr",
 ]

 [[package]]
-name = "anstream"
-version = "0.6.17"
+name = "ansi_term"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23a1e53f0f5d86382dafe1cf314783b2044280f406e7e1506368220ad11b1338"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
 dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "is_terminal_polyfill",
- "utf8parse",
+ "winapi",
 ]

 [[package]]
 name = "anstyle"
-version = "1.0.9"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8365de52b16c035ff4fcafe0092ba9390540e3e352870ac09933bebcaa2c8c56"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
-dependencies = [
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
-dependencies = [
- "anstyle",
- "windows-sys 0.59.0",
-]
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"

 [[package]]
 name = "anyhow"
-version = "1.0.91"
+version = "1.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c042108f3ed77fd83760a5fd79b53be043192bb3b9dba91d8c574c0ada7850c8"
+checksum = "08f9b8508dccb7687a1d6c4ce66b2b0ecef467c94667de27d8d7fe1f8d2a9cdc"

 [[package]]
 name = "assert_cmd"
@@ -75,117 +41,98 @@ dependencies = [
 "anstyle",
 "bstr",
 "libc",
- "predicates",
+ "predicates 3.1.4",
 "predicates-core",
 "predicates-tree",
 "wait-timeout",
 ]

 [[package]]
-name = "autocfg"
-version = "1.4.0"
+name = "atty"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"

 [[package]]
 name = "bitflags"
-version = "2.6.0"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

 [[package]]
 name = "bstr"
-version = "1.10.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40723b8fb387abc38f4f4a37c09073622e41dd12327033091ef8950659e6dc0c"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
 dependencies = [
 "memchr",
 "regex-automata",
 "serde",
 ]

+[[package]]
+name = "cc"
+version = "1.0.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+
 [[package]]
 name = "clap"
-version = "4.5.20"
+version = "3.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8"
+checksum = "d646c7ade5eb07c4aa20e907a922750df0c448892513714fd3e4acbc7130829f"
 dependencies = [
- "clap_builder",
- "clap_derive",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.5.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54"
-dependencies = [
- "anstream",
- "anstyle",
+ "atty",
+ "bitflags",
 "clap_lex",
+ "indexmap",
+ "once_cell",
 "strsim",
- "terminal_size",
-]
-
-[[package]]
-name = "clap_complete"
-version = "4.5.55"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5abde44486daf70c5be8b8f8f1b66c49f86236edf6fa2abadb4d961c4c6229a"
-dependencies = [
- "clap",
-]
-
-[[package]]
-name = "clap_derive"
-version = "4.5.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
+ "termcolor",
+ "terminal_size 0.1.17",
+ "textwrap",
 ]

 [[package]]
 name = "clap_lex"
-version = "0.7.2"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
-
-[[package]]
-name = "colorchoice"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+dependencies = [
+ "os_str_bytes",
+]

 [[package]]
 name = "const_format"
-version = "0.2.33"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50c655d81ff1114fb0dcdea9225ea9f0cc712a6f8d189378e82bdf62a473a64b"
+checksum = "0936ffe6d0c8d6a51b3b0a73b2acbe925d786f346cf45bfddc8341d79fb7dc8a"
 dependencies = [
 "const_format_proc_macros",
 ]

 [[package]]
 name = "const_format_proc_macros"
-version = "0.2.33"
+version = "0.2.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eff1a44b93f47b1bac19a27932f5c591e43d1ba357ee4f61526c8a25603f0eb1"
+checksum = "ef196d5d972878a48da7decb7686eded338b4858fbabeed513d63a7c98b2b82d"
 dependencies = [
 "proc-macro2",
 "quote",
 "unicode-xid",
 ]

-[[package]]
-name = "diff"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
-
 [[package]]
 name = "difflib"
 version = "0.4.0"
@@ -193,13 +140,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"

 [[package]]
-name = "errno"
-version = "0.3.9"
+name = "either"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "errno"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
 dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "errno-dragonfly"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+dependencies = [
+ "cc",
 "libc",
- "windows-sys 0.52.0",
 ]

 [[package]]
@@ -212,58 +176,78 @@ dependencies = [
 ]

 [[package]]
-name = "heck"
-version = "0.5.0"
+name = "hashbrown"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]

 [[package]]
 name = "hexyl"
-version = "0.17.0"
+version = "0.10.0"
 dependencies = [
+ "ansi_term",
 "anyhow",
 "assert_cmd",
+ "atty",
 "clap",
- "clap_complete",
 "const_format",
 "libc",
- "owo-colors",
- "predicates",
- "pretty_assertions",
- "supports-color",
- "terminal_size",
+ "predicates 2.1.1",
+ "terminal_size 0.2.1",
 "thiserror",
 ]

 [[package]]
-name = "is_ci"
-version = "1.2.0"
+name = "indexmap"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45"
+checksum = "0f647032dfaa1f8b6dc29bd3edb7bbef4861b8b8007ebb118d6db284fd59f6ee"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]

 [[package]]
-name = "is_terminal_polyfill"
-version = "1.70.1"
+name = "io-lifetimes"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+checksum = "24c3f4eff5495aee4c0399d7b6a0dc2b6e81be84242ffbfcf253ebacccc1d0cb"
+
+[[package]]
+name = "itertools"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
+dependencies = [
+ "either",
+]

 [[package]]
 name = "libc"
-version = "0.2.161"
+version = "0.2.182"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"

 [[package]]
 name = "linux-raw-sys"
-version = "0.4.14"
+version = "0.0.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"

 [[package]]
 name = "memchr"
-version = "2.7.4"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"

 [[package]]
 name = "normalize-line-endings"
@@ -273,159 +257,138 @@ checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"

 [[package]]
 name = "num-traits"
-version = "0.2.19"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
 dependencies = [
 "autocfg",
 ]

 [[package]]
-name = "owo-colors"
-version = "4.1.0"
+name = "once_cell"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb37767f6569cd834a413442455e0f066d0d522de8630436e2a1761d9726ba56"
+checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1"
+
+[[package]]
+name = "os_str_bytes"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "029d8d0b2f198229de29dca79676f2738ff952edf3fde542eb8bf94d8c21b435"

 [[package]]
 name = "predicates"
-version = "3.1.2"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e9086cc7640c29a356d1a29fd134380bee9d8f79a17410aa76e7ad295f42c97"
+checksum = "a5aab5be6e4732b473071984b3164dbbfb7a3674d30ea5ff44410b6bcd960c3c"
 dependencies = [
- "anstyle",
 "difflib",
 "float-cmp",
+ "itertools",
 "normalize-line-endings",
 "predicates-core",
 "regex",
 ]

 [[package]]
-name = "predicates-core"
-version = "1.0.8"
+name = "predicates"
+version = "3.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae8177bee8e75d6846599c6b9ff679ed51e882816914eec639944d7c9aa11931"
+checksum = "ada8f2932f28a27ee7b70dd6c1c39ea0675c55a36879ab92f3a715eaa1e63cfe"
+dependencies = [
+ "anstyle",
+ "difflib",
+ "predicates-core",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cad38746f3166b4031b1a0d39ad9f954dd291e7854fcc0eed52ee41a0b50d144"

 [[package]]
 name = "predicates-tree"
-version = "1.0.11"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41b740d195ed3166cd147c8047ec98db0e22ec019eb8eeb76d343b795304fb13"
+checksum = "4d86de6de25020a36c6d3643a86d9a6a9f552107c0559c60ea03551b5e16c032"
 dependencies = [
 "predicates-core",
 "termtree",
 ]

-[[package]]
-name = "pretty_assertions"
-version = "1.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
-dependencies = [
- "diff",
- "yansi",
-]
-
 [[package]]
 name = "proc-macro2"
-version = "1.0.89"
+version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f"
 dependencies = [
 "unicode-ident",
 ]

 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1"
 dependencies = [
 "proc-macro2",
 ]

 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "d83f127d94bdbcda4c8cc2e50f6f84f4b611f69c902699ca385a39c3a75f9ff1"
 dependencies = [
 "aho-corasick",
 "memchr",
- "regex-automata",
 "regex-syntax",
 ]

 [[package]]
 name = "regex-automata"
-version = "0.4.8"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"

 [[package]]
 name = "regex-syntax"
-version = "0.8.5"
+version = "0.6.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+checksum = "49b3de9ec5dc0a3417da371aab17d729997c15010e7fd24ff707773a33bddb64"

 [[package]]
 name = "rustix"
-version = "0.38.38"
+version = "0.35.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa260229e6538e52293eeb577aabd09945a09d6d9cc0fc550ed7529056c2e32a"
+checksum = "d51cc38aa10f6bbb377ed28197aa052aa4e2b762c22be9d3153d01822587e787"
 dependencies = [
 "bitflags",
 "errno",
+ "io-lifetimes",
 "libc",
 "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys",
 ]

 [[package]]
 name = "serde"
-version = "1.0.214"
+version = "1.0.185"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.214"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "be9b6f69f1dfd54c3b568ffa45c310d6973a5e5148fd40cf515acaf38cf5bc31"

 [[package]]
 name = "strsim"
-version = "0.11.1"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
-
-[[package]]
-name = "supports-color"
-version = "3.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8775305acf21c96926c900ad056abeef436701108518cf890020387236ac5a77"
-dependencies = [
- "is_ci",
-]
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

 [[package]]
 name = "syn"
-version = "2.0.85"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56"
+checksum = "fbaf6116ab8924f39d52792136fb74fd60a80194cf1b1c6ffa6453eef1c3f942"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -433,35 +396,63 @@ dependencies = [
 ]

 [[package]]
-name = "terminal_size"
-version = "0.4.0"
+name = "termcolor"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f599bd7ca042cfdf8f4512b277c02ba102247820f9d9d4a9f521f496751a6ef"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "terminal_size"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "terminal_size"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8440c860cf79def6164e4a0a983bcc2305d82419177a0e0c71930d049e3ac5a1"
 dependencies = [
 "rustix",
- "windows-sys 0.59.0",
+ "windows-sys",
 ]

 [[package]]
 name = "termtree"
-version = "0.4.1"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
+checksum = "507e9898683b6c43a9aa55b64259b721b52ba226e0f3779137e50ad114a4c90b"
+
+[[package]]
+name = "textwrap"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+dependencies = [
+ "terminal_size 0.1.17",
+]

 [[package]]
 name = "thiserror"
-version = "1.0.65"
+version = "1.0.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d11abd9594d9b38965ef50805c5e469ca9cc6f197f883f717e0269a3057b3d5"
+checksum = "bd829fe32373d27f76265620b5309d0340cb8550f523c1dda251d6298069069a"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.65"
+version = "1.0.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae71770322cbd277e69d762a16c444af02aa0575ac0d174f0b9562d3b37f8602"
+checksum = "0396bc89e626244658bef819e22d0cc459e795a5ebe878e6ec336d1674a8d79a"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -470,21 +461,15 @@ dependencies = [

 [[package]]
 name = "unicode-ident"
-version = "1.0.13"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee"

 [[package]]
 name = "unicode-xid"
-version = "0.2.6"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
-
-[[package]]
-name = "utf8parse"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+checksum = "957e51f3646910546462e67d5f7599b9e4fb8acdd304b087a6494730f9eebf04"

 [[package]]
 name = "wait-timeout"
@@ -496,89 +481,75 @@ dependencies = [
 ]

 [[package]]
-name = "windows-sys"
-version = "0.52.0"
+name = "winapi"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
 dependencies = [
- "windows-targets",
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
 ]

 [[package]]
-name = "windows-sys"
-version = "0.59.0"
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
 dependencies = [
- "windows-targets",
+ "winapi",
 ]

 [[package]]
-name = "windows-targets"
-version = "0.52.6"
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
 dependencies = [
- "windows_aarch64_gnullvm",
 "windows_aarch64_msvc",
 "windows_i686_gnu",
- "windows_i686_gnullvm",
 "windows_i686_msvc",
 "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
 "windows_x86_64_msvc",
 ]

-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.6"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"

 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.6"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"

 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.6"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"

 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.6"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"

 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.6"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
-
-[[package]]
-name = "yansi"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
@@ -1,35 +1,32 @@
 [package]
 authors = ["David Peter <mail@david-peter.de>"]
 categories = ["command-line-utilities"]
-keywords = ["hex", "viewer"]
 description = "A command-line hex viewer"
 homepage = "https://github.com/sharkdp/hexyl"
 license = "MIT/Apache-2.0"
 name = "hexyl"
 readme = "README.md"
 repository = "https://github.com/sharkdp/hexyl"
-version = "0.17.0"
+version = "0.10.0"
 edition = "2021"
-rust-version = "1.88"

 [dependencies]
+ansi_term = "0.12"
 anyhow = "1.0"
+atty = "0.2"
 const_format = "0.2"
 libc = "0.2"
-owo-colors = "4"
-supports-color = "3"
 thiserror = "1.0"
-terminal_size = "0.4"
-clap_complete = "4"
+terminal_size = "0.2"

 [dependencies.clap]
-version = "4"
-features = ["derive", "wrap_help"]
+version = "3"
+default-features = false
+features = ["std", "suggestions", "color", "wrap_help", "cargo"]

 [dev-dependencies]
 assert_cmd = "2.1"
-predicates = "3.0"
-pretty_assertions = "1.4.0"
+predicates = "2.0"

 [profile.release]
 lto = true
@@ -4,7 +4,7 @@
 [![](https://img.shields.io/crates/l/hexyl.svg?colorB=22ba4c)](https://crates.io/crates/hexyl)
 ![](https://img.shields.io/crates/v/hexyl.svg?colorB=00aa88)

-`hexyl` is a hex viewer for the terminal. It uses a colored output to distinguish different categories
+`hexyl` is a simple hex viewer for the terminal. It uses a colored output to distinguish different categories
 of bytes (NULL bytes, printable ASCII characters, ASCII whitespace characters, other ASCII characters and non-ASCII).

 ## Preview
@@ -17,7 +17,6 @@ of bytes (NULL bytes, printable ASCII characters, ASCII whitespace characters, o

 ![](https://i.imgur.com/f8nm8g6.png)

-
 ## Installation

 ### On Ubuntu
@@ -32,7 +31,7 @@ If you use an older version of Ubuntu, you can download
 the latest `.deb` package from the release page and install it via:

 ``` bash
-sudo dpkg -i hexyl_0.15.0_amd64.deb  # adapt version number and architecture
+sudo dpkg -i hexyl_0.10.0_amd64.deb  # adapt version number and architecture
 ```

 ### On Debian
@@ -55,7 +54,7 @@ sudo dnf install hexyl

 ### On Arch Linux

-You can install `hexyl` from [the official package repository](https://archlinux.org/packages/extra/x86_64/hexyl/):
+You can install `hexyl` from [the official package repository](https://www.archlinux.org/packages/community/x86_64/hexyl/):

 ```
 pacman -S hexyl
@@ -97,18 +96,6 @@ sudo port install hexyl
 pkg install hexyl
 ```

-### On NetBSD
-
-```
-pkgin install hexyl
-```
-
-### On OpenBSD
-
-```
-doas pkg_add hexyl
-```
-
 ### on Termux
 ```
 pkg install hexyl
@@ -176,26 +163,6 @@ sudo snap install hexyl
 scoop install hexyl
 ```

-### Via [X-CMD](https://x-cmd.com)
-```
-x env use hexyl
-```
-
-## Configuration
-
-`hexyl` colors can be configured via environment variables. The variables used are as follows:
-
- * `HEXYL_COLOR_ASCII_PRINTABLE`: Any non-whitespace printable ASCII character
- * `HEXYL_COLOR_ASCII_WHITESPACE`: Whitespace such as space or newline (only visible in middle panel with byte values)
- * `HEXYL_COLOR_ASCII_OTHER`: Any other ASCII character (< `0x80`) besides null
- * `HEXYL_COLOR_NULL`: The null byte (`0x00`)
- * `HEXYL_COLOR_NONASCII`: Any non-ASCII byte (> `0x7F`)
- * `HEXYL_COLOR_OFFSET`: The lefthand file offset
-
-The colors can be any of the 8 standard terminal colors: `black`, `blue`, `cyan`, `green`, `magenta`, `red`,
-`yellow` and `white`. The "bright" variants are also supported (e.g., `bright blue`). Additionally, you can use
-the RGB hex format, `#abcdef`. For example, `HEXYL_COLOR_ASCII_PRINTABLE=blue HEXYL_COLOR_ASCII_WHITESPACE="bright green"
-HEXYL_COLOR_ASCII_OTHER="#ff7f99"`.

 ## License

@@ -1,6 +1,11 @@
-% HEXYL(1) hexyl 0.12.0 | General Commands Manual
+% HEXYL(1) hexyl 0.10.0 | General Commands Manual
 %
-% 2022-12-05
+% 2022-03-23
+
+<!--
+This man page is written in Pandoc's Markdown.
+See: https://pandoc.org/MANUAL.html#pandocs-markdown
+-->

 # NAME

@@ -106,22 +111,6 @@ _FILE_
 **-V**, **\--version**
 :   Prints version information.

-# ENVIRONMENT VARIABLES
-
-**hexyl** colors can be configured via environment variables. The variables used are as follows:
-
-:   - **HEXYL_COLOR_ASCII_PRINTABLE**: Any non-whitespace printable ASCII character
-    - **HEXYL_COLOR_ASCII_WHITESPACE**: Whitespace such as space or newline (only visible in middle panel with byte values)
-    - **HEXYL_COLOR_ASCII_OTHER**: Any other ASCII character (< **0x80**) besides null
-    - **HEXYL_COLOR_NULL**: The null byte (**0x00**)
-    - **HEXYL_COLOR_NONASCII**: Any non-ASCII byte (> **0x7F**)
-    - **HEXYL_COLOR_OFFSET**: The lefthand file offset
-
-The colors can be any of the 8 standard terminal colors: **black**, **blue**, **cyan**, **green**, **magenta**, **red**,
-**yellow** and **white**. The "bright" variants are also supported (e.g., **bright blue**). Additionally, you can use
-the RGB hex format, **#abcdef**. For example, **HEXYL_COLOR_ASCII_PRINTABLE=blue HEXYL_COLOR_ASCII_WHITESPACE="bright green"
-HEXYL_COLOR_ASCII_OTHER="#ff7f99"**.
-
 # NOTES

 Source repository:
@@ -1,9 +1,9 @@
 use std::io;

-use hexyl::{BorderStyle, PrinterBuilder};
+use hexyl::{BorderStyle, Printer};

 fn main() {
-    let input = [
+    let input = vec![
        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44,
        0x52, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x44, 0x08, 0x02, 0x00, 0x00, 0x00,
    ];
@@ -11,14 +11,21 @@ fn main() {
    let stdout = io::stdout();
    let mut handle = stdout.lock();

-    let mut printer = PrinterBuilder::new(&mut handle)
-        .show_color(true)
-        .show_char_panel(true)
-        .show_position_panel(true)
-        .with_border_style(BorderStyle::Unicode)
-        .enable_squeezing(false)
-        .num_panels(2)
-        .group_size(1)
-        .build();
+    let show_color = true;
+    let show_char_panel = true;
+    let show_position_panel = true;
+    let use_squeezing = false;
+    let border_style = BorderStyle::Unicode;
+    let columns = 2;
+
+    let mut printer = Printer::new(
+        &mut handle,
+        show_color,
+        show_char_panel,
+        show_position_panel,
+        border_style,
+        use_squeezing,
+        columns,
+    );
    printer.print_all(&input[..]).unwrap();
 }
@@ -0,0 +1,800 @@
+#[macro_use]
+extern crate clap;
+
+use std::convert::TryFrom;
+use std::fs::File;
+use std::io::{self, prelude::*, SeekFrom};
+use std::num::{NonZeroI64, NonZeroU16};
+
+use clap::{crate_name, crate_version, AppSettings, Arg, ColorChoice, Command};
+
+use atty::Stream;
+
+use anyhow::{anyhow, Context, Error as AnyhowError};
+
+use const_format::formatcp;
+
+use thiserror::Error as ThisError;
+
+use terminal_size::terminal_size;
+
+use hexyl::{BorderStyle, Input, Printer};
+
+const DEFAULT_BLOCK_SIZE: i64 = 512;
+
+fn run() -> Result<(), AnyhowError> {
+    let command = Command::new(crate_name!())
+        .setting(AppSettings::DeriveDisplayOrder)
+        .color(ColorChoice::Auto)
+        .max_term_width(90)
+        .version(crate_version!())
+        .about(crate_description!())
+        .arg(
+            Arg::new("FILE")
+                .help("The file to display. If no FILE argument is given, read from STDIN."),
+        )
+        .arg(
+            Arg::new("length")
+                .short('n')
+                .long("length")
+                .takes_value(true)
+                .value_name("N")
+                .help(
+                    "Only read N bytes from the input. The N argument can also include a \
+                     unit with a decimal prefix (kB, MB, ..) or binary prefix (kiB, MiB, ..), \
+                     or can be specified using a hex number. \
+                     The short option '-l' can be used as an alias.\n\
+                     Examples: --length=64, --length=4KiB, --length=0xff",
+                ),
+        )
+        .arg(
+            Arg::new("bytes")
+                .short('c')
+                .long("bytes")
+                .takes_value(true)
+                .value_name("N")
+                .conflicts_with("length")
+                .help("An alias for -n/--length"),
+        )
+        .arg(
+            Arg::new("count")
+                .short('l')
+                .takes_value(true)
+                .value_name("N")
+                .conflicts_with_all(&["length", "bytes"])
+                .hide(true)
+                .help("Yet another alias for -n/--length"),
+        )
+        .arg(
+            Arg::new("skip")
+                .short('s')
+                .long("skip")
+                .takes_value(true)
+                .value_name("N")
+                .help(
+                    "Skip the first N bytes of the input. The N argument can also include \
+                     a unit (see `--length` for details)\n\
+                     A negative value is valid and will seek from the end of the file.",
+                ),
+        )
+        .arg(
+            Arg::new("block_size")
+                .long("block-size")
+                .takes_value(true)
+                .value_name("SIZE")
+                .help(formatcp!(
+                    "Sets the size of the `block` unit to SIZE (default is {}).\n\
+                     Examples: --block-size=1024, --block-size=4kB",
+                    DEFAULT_BLOCK_SIZE
+                )),
+        )
+        .arg(
+            Arg::new("nosqueezing")
+                .short('v')
+                .long("no-squeezing")
+                .help(
+                    "Displays all input data. Otherwise any number of groups of output \
+                     lines which would be identical to the preceding group of lines, are \
+                     replaced with a line comprised of a single asterisk.",
+                ),
+        )
+        .arg(
+            Arg::new("color")
+                .long("color")
+                .takes_value(true)
+                .value_name("WHEN")
+                .possible_values(&["always", "auto", "never"])
+                .default_value_if("plain", None, Some("never"))
+                .default_value("always")
+                .help(
+                    "When to use colors. The auto-mode only displays colors if the output \
+                     goes to an interactive terminal",
+                ),
+        )
+        .arg(Arg::new("plain").short('p').long("plain").help(
+            "Display output with --no-characters, --no-position, --border=none, and --color=never.",
+        ))
+        .arg(
+            Arg::new("border")
+                .long("border")
+                .takes_value(true)
+                .value_name("STYLE")
+                .possible_values(&["unicode", "ascii", "none"])
+                .default_value_if("plain", None, Some("none"))
+                .default_value("unicode")
+                .help(
+                    "Whether to draw a border with Unicode characters, ASCII characters, \
+                    or none at all",
+                ),
+        )
+        .arg(
+            Arg::new("no_chars")
+                .short('C')
+                .long("no-characters")
+                .help("Whether to display the character panel on the right."),
+        )
+        .arg(
+            Arg::new("no_position")
+                .short('P')
+                .long("no-position")
+                .help("Whether to display the position panel on the left."),
+        )
+        .arg(
+            Arg::new("display_offset")
+                .short('o')
+                .long("display-offset")
+                .takes_value(true)
+                .value_name("N")
+                .help(
+                    "Add N bytes to the displayed file position. The N argument can also \
+                    include a unit (see `--length` for details)\n\
+                    A negative value is valid and calculates an offset relative to the \
+                    end of the file.",
+                ),
+        )
+        .arg(
+            Arg::new("columns")
+                .short('w')
+                .long("columns")
+                .takes_value(true)
+                .value_name("N")
+                .help(
+                    "Sets the number of hex data columns to be displayed. \
+                    Cannot be used with other width-setting options.",
+                ),
+        )
+        .arg(
+            Arg::new("terminal_width")
+                .short('t')
+                .long("terminal-width")
+                .takes_value(true)
+                .value_name("N")
+                .conflicts_with("columns")
+                .help(
+                    "Sets the number of terminal columns to be displayed.\nSince the terminal \
+                    width may not be an evenly divisible by the width per hex data column, this \
+                    will use the greatest number of hex data columns that can fit in the requested \
+                    width but still leave some space to the right.\nCannot be used with other \
+                    width-setting options.",
+                ),
+        )
+        .arg(
+            Arg::new("auto_width")
+                .short('a')
+                .long("auto-width")
+                .conflicts_with_all(&["columns", "terminal_width"])
+                .help(
+                    "Sets the number of hex data columns to be adjusted according to the \
+                    detected terminal width.\nCannot be used with other width-setting options.",
+                ),
+        );
+
+    let matches = command.get_matches();
+
+    let stdin = io::stdin();
+
+    let mut reader = match matches.value_of("FILE") {
+        Some(filename) => Input::File(File::open(filename)?),
+        None => Input::Stdin(stdin.lock()),
+    };
+
+    let block_size = matches
+        .value_of("block_size")
+        .map(|bs| {
+            if let Some(hex_number) = try_parse_as_hex_number(bs) {
+                return hex_number.map_err(|e| anyhow!(e)).and_then(|x| {
+                    PositiveI64::new(x)
+                        .ok_or_else(|| anyhow!("block size argument must be positive"))
+                });
+            }
+            let (num, unit) = extract_num_and_unit_from(bs)?;
+            if let Unit::Block { custom_size: _ } = unit {
+                return Err(anyhow!(
+                    "can not use 'block(s)' as a unit to specify block size"
+                ));
+            };
+            num.checked_mul(unit.get_multiplier())
+                .ok_or_else(|| anyhow!(ByteOffsetParseError::UnitMultiplicationOverflow))
+                .and_then(|x| {
+                    PositiveI64::new(x)
+                        .ok_or_else(|| anyhow!("block size argument must be positive"))
+                })
+        })
+        .transpose()?
+        .unwrap_or_else(|| PositiveI64::new(DEFAULT_BLOCK_SIZE).unwrap());
+
+    let skip_arg = matches
+        .value_of("skip")
+        .map(|s| {
+            parse_byte_offset(s, block_size).context(anyhow!(
+                "failed to parse `--skip` arg {:?} as byte count",
+                s
+            ))
+        })
+        .transpose()?;
+
+    let skip_offset = if let Some(ByteOffset { kind, value }) = skip_arg {
+        let value = value.into_inner();
+        reader
+            .seek(match kind {
+                ByteOffsetKind::ForwardFromBeginning | ByteOffsetKind::ForwardFromLastOffset => {
+                    SeekFrom::Current(value)
+                }
+                ByteOffsetKind::BackwardFromEnd => SeekFrom::End(value.checked_neg().unwrap()),
+            })
+            .map_err(|_| {
+                anyhow!(
+                    "Failed to jump to the desired input position. \
+                     This could be caused by a negative offset that is too large or by \
+                     an input that is not seek-able (e.g. if the input comes from a pipe)."
+                )
+            })?
+    } else {
+        0
+    };
+
+    let parse_byte_count = |s| -> Result<u64, AnyhowError> {
+        Ok(parse_byte_offset(s, block_size)?
+            .assume_forward_offset_from_start()?
+            .into())
+    };
+
+    let mut reader = if let Some(length) = matches
+        .value_of("length")
+        .or_else(|| matches.value_of("bytes"))
+        .or_else(|| matches.value_of("count"))
+        .map(|s| {
+            parse_byte_count(s).context(anyhow!(
+                "failed to parse `--length` arg {:?} as byte count",
+                s
+            ))
+        })
+        .transpose()?
+    {
+        Box::new(reader.take(length))
+    } else {
+        reader.into_inner()
+    };
+
+    let show_color = match matches.value_of("color") {
+        Some("never") => false,
+        Some("auto") => atty::is(Stream::Stdout),
+        _ => true,
+    };
+
+    let border_style = match matches.value_of("border") {
+        Some("unicode") => BorderStyle::Unicode,
+        Some("ascii") => BorderStyle::Ascii,
+        _ => BorderStyle::None,
+    };
+
+    let squeeze = !matches.is_present("nosqueezing");
+
+    let show_char_panel = !matches.is_present("no_chars") && !matches.is_present("plain");
+
+    let show_position_panel = !matches.is_present("no_position") && !matches.is_present("plain");
+
+    let display_offset: u64 = matches
+        .value_of("display_offset")
+        .map(|s| {
+            parse_byte_count(s).context(anyhow!(
+                "failed to parse `--display-offset` arg {:?} as byte count",
+                s
+            ))
+        })
+        .transpose()?
+        .unwrap_or(0);
+
+    let columns = if let Some(columns) = matches
+        .value_of("columns")
+        .map(|s| {
+            s.parse::<NonZeroU16>().map(u16::from).context(anyhow!(
+                "failed to parse `--columns` arg {:?} as unsigned nonzero integer",
+                s
+            ))
+        })
+        .transpose()?
+    {
+        columns
+    } else {
+        let terminal_width = if let Some(terminal_width) = matches
+            .value_of("terminal_width")
+            .map(|s| {
+                s.parse::<NonZeroU16>().map(u16::from).context(anyhow!(
+                    "failed to parse `--columns` arg {:?} as unsigned nonzero integer",
+                    s
+                ))
+            })
+            .transpose()?
+        {
+            Some(terminal_width)
+        } else if matches.is_present("auto_width") {
+            Some(terminal_size().ok_or_else(|| anyhow!("not a TTY"))?.0 .0)
+        } else {
+            None
+        };
+
+        if let Some(terminal_width) = terminal_width {
+            let offset = if show_position_panel { 10 } else { 1 };
+            let col_width = if show_char_panel { 35 } else { 26 };
+            if (terminal_width - offset) / col_width < 1 {
+                1
+            } else {
+                (terminal_width - offset) / col_width
+            }
+        } else {
+            2
+        }
+    };
+
+    let stdout = io::stdout();
+    let mut stdout_lock = stdout.lock();
+
+    let mut printer = Printer::new(
+        &mut stdout_lock,
+        show_color,
+        show_char_panel,
+        show_position_panel,
+        border_style,
+        squeeze,
+        columns,
+    );
+    printer.display_offset(skip_offset + display_offset);
+    printer.print_all(&mut reader).map_err(|e| anyhow!(e))?;
+
+    Ok(())
+}
+
+fn main() {
+    // Enable ANSI support for Windows
+    #[cfg(windows)]
+    let _ = ansi_term::enable_ansi_support();
+
+    let result = run();
+
+    if let Err(err) = result {
+        eprintln!("Error: {:?}", err);
+        std::process::exit(1);
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Hash, Eq, Ord, PartialEq, PartialOrd)]
+pub struct NonNegativeI64(i64);
+
+impl NonNegativeI64 {
+    pub fn new(x: i64) -> Option<Self> {
+        if x.is_negative() {
+            None
+        } else {
+            Some(Self(x))
+        }
+    }
+
+    pub fn into_inner(self) -> i64 {
+        self.0
+    }
+}
+
+impl From<NonNegativeI64> for u64 {
+    fn from(x: NonNegativeI64) -> u64 {
+        u64::try_from(x.0)
+            .expect("invariant broken: NonNegativeI64 should contain a non-negative i64 value")
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Hash, Eq, Ord, PartialEq, PartialOrd)]
+pub struct PositiveI64(i64);
+
+impl PositiveI64 {
+    pub fn new(x: i64) -> Option<Self> {
+        if x < 1 {
+            None
+        } else {
+            Some(Self(x))
+        }
+    }
+
+    pub fn into_inner(self) -> i64 {
+        self.0
+    }
+}
+
+impl From<PositiveI64> for u64 {
+    fn from(x: PositiveI64) -> u64 {
+        u64::try_from(x.0)
+            .expect("invariant broken: PositiveI64 should contain a positive i64 value")
+    }
+}
+
+#[derive(Debug, PartialEq)]
+enum Unit {
+    Byte,
+    Kilobyte,
+    Megabyte,
+    Gigabyte,
+    Terabyte,
+    Kibibyte,
+    Mebibyte,
+    Gibibyte,
+    Tebibyte,
+    /// a customizable amount of bytes
+    Block {
+        custom_size: Option<NonZeroI64>,
+    },
+}
+
+impl Unit {
+    const fn get_multiplier(self) -> i64 {
+        match self {
+            Self::Byte => 1,
+            Self::Kilobyte => 1000,
+            Self::Megabyte => 1_000_000,
+            Self::Gigabyte => 1_000_000_000,
+            Self::Terabyte => 1_000_000_000_000,
+            Self::Kibibyte => 1 << 10,
+            Self::Mebibyte => 1 << 20,
+            Self::Gibibyte => 1 << 30,
+            Self::Tebibyte => 1 << 40,
+            Self::Block {
+                custom_size: Some(size),
+            } => size.get(),
+            Self::Block { custom_size: None } => DEFAULT_BLOCK_SIZE,
+        }
+    }
+}
+
+const HEX_PREFIX: &str = "0x";
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+enum ByteOffsetKind {
+    ForwardFromBeginning,
+    ForwardFromLastOffset,
+    BackwardFromEnd,
+}
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+struct ByteOffset {
+    value: NonNegativeI64,
+    kind: ByteOffsetKind,
+}
+
+#[derive(Clone, Debug, ThisError)]
+#[error(
+    "negative offset specified, but only positive offsets (counts) are accepted in this context"
+)]
+struct NegativeOffsetSpecifiedError;
+
+impl ByteOffset {
+    fn assume_forward_offset_from_start(
+        &self,
+    ) -> Result<NonNegativeI64, NegativeOffsetSpecifiedError> {
+        let &Self { value, kind } = self;
+        match kind {
+            ByteOffsetKind::ForwardFromBeginning | ByteOffsetKind::ForwardFromLastOffset => {
+                Ok(value)
+            }
+            ByteOffsetKind::BackwardFromEnd => Err(NegativeOffsetSpecifiedError),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, ThisError)]
+enum ByteOffsetParseError {
+    #[error("no character data found, did you forget to write it?")]
+    Empty,
+    #[error("no digits found after sign, did you forget to write them?")]
+    EmptyAfterSign,
+    #[error(
+        "found {0:?} sign after hex prefix ({:?}); signs should go before it",
+        HEX_PREFIX
+    )]
+    SignFoundAfterHexPrefix(char),
+    #[error("{0:?} is not of the expected form <pos-integer>[<unit>]")]
+    InvalidNumAndUnit(String),
+    #[error("{0:?} is a valid unit, but an integer should come before it")]
+    EmptyWithUnit(String),
+    #[error("invalid unit {0:?}")]
+    InvalidUnit(String),
+    #[error("failed to parse integer part")]
+    ParseNum(#[source] std::num::ParseIntError),
+    #[error("count multiplied by the unit overflowed a signed 64-bit integer; are you sure it should be that big?")]
+    UnitMultiplicationOverflow,
+}
+
+fn parse_byte_offset(n: &str, block_size: PositiveI64) -> Result<ByteOffset, ByteOffsetParseError> {
+    use ByteOffsetParseError::*;
+
+    let (n, kind) = process_sign_of(n)?;
+
+    let into_byte_offset = |value| {
+        Ok(ByteOffset {
+            value: NonNegativeI64::new(value).unwrap(),
+            kind,
+        })
+    };
+
+    if let Some(hex_number) = try_parse_as_hex_number(n) {
+        return hex_number.map(into_byte_offset)?;
+    }
+
+    let (num, mut unit) = extract_num_and_unit_from(n)?;
+    if let Unit::Block { custom_size: None } = unit {
+        unit = Unit::Block {
+            custom_size: Some(
+                NonZeroI64::new(block_size.into_inner()).expect("PositiveI64 was zero"),
+            ),
+        };
+    }
+
+    num.checked_mul(unit.get_multiplier())
+        .ok_or(UnitMultiplicationOverflow)
+        .and_then(into_byte_offset)
+}
+
+/// Takes a string containing a base-10 number and an optional unit, and returns them with their proper types.
+/// The unit must directly follow the number (e.g. no whitespace is allowed between them).
+/// When no unit is given, [Unit::Byte] is assumed.
+/// When the unit is [Unit::Block], it is returned without custom size.
+/// No normalization is performed, that is "1024" is extracted to (1024, Byte), not (1, Kibibyte).
+fn extract_num_and_unit_from(n: &str) -> Result<(i64, Unit), ByteOffsetParseError> {
+    use ByteOffsetParseError::*;
+    if n.is_empty() {
+        return Err(Empty);
+    }
+    match n.chars().position(|c| !c.is_ascii_digit()) {
+        Some(unit_begin_idx) => {
+            let (n, raw_unit) = n.split_at(unit_begin_idx);
+            let unit = match raw_unit.to_lowercase().as_str() {
+                "" => Unit::Byte, // no "b" => Byte to allow hex nums with units
+                "kb" => Unit::Kilobyte,
+                "mb" => Unit::Megabyte,
+                "gb" => Unit::Gigabyte,
+                "tb" => Unit::Terabyte,
+                "kib" => Unit::Kibibyte,
+                "mib" => Unit::Mebibyte,
+                "gib" => Unit::Gibibyte,
+                "tib" => Unit::Tebibyte,
+                "block" | "blocks" => Unit::Block { custom_size: None },
+                _ => {
+                    return if n.is_empty() {
+                        Err(InvalidNumAndUnit(raw_unit.to_string()))
+                    } else {
+                        Err(InvalidUnit(raw_unit.to_string()))
+                    }
+                }
+            };
+            let num = n.parse::<i64>().map_err(|e| {
+                if n.is_empty() {
+                    EmptyWithUnit(raw_unit.to_owned())
+                } else {
+                    ParseNum(e)
+                }
+            })?;
+            Ok((num, unit))
+        }
+        None => {
+            // no unit part
+            let num = n.parse::<i64>().map_err(ParseNum)?;
+            Ok((num, Unit::Byte))
+        }
+    }
+}
+
+/// Extracts a [ByteOffsetKind] based on the sign at the beginning of the given string.
+/// Returns the input string without the sign (or an equal string if there wasn't any sign).
+fn process_sign_of(n: &str) -> Result<(&str, ByteOffsetKind), ByteOffsetParseError> {
+    use ByteOffsetParseError::*;
+    let mut chars = n.chars();
+    let next_char = chars.next();
+    let check_empty_after_sign = || {
+        if chars.clone().next().is_none() {
+            Err(EmptyAfterSign)
+        } else {
+            Ok(chars.as_str())
+        }
+    };
+    match next_char {
+        Some('+') => Ok((
+            check_empty_after_sign()?,
+            ByteOffsetKind::ForwardFromLastOffset,
+        )),
+        Some('-') => Ok((check_empty_after_sign()?, ByteOffsetKind::BackwardFromEnd)),
+        None => Err(Empty),
+        _ => Ok((n, ByteOffsetKind::ForwardFromBeginning)),
+    }
+}
+
+/// If `n` starts with a hex prefix, its remaining part is returned as some number (if possible),
+/// otherwise None is returned.
+fn try_parse_as_hex_number(n: &str) -> Option<Result<i64, ByteOffsetParseError>> {
+    use ByteOffsetParseError::*;
+    n.strip_prefix(HEX_PREFIX).map(|num| {
+        let mut chars = num.chars();
+        match chars.next() {
+            Some(c @ '+') | Some(c @ '-') => {
+                return if chars.next().is_none() {
+                    Err(EmptyAfterSign)
+                } else {
+                    Err(SignFoundAfterHexPrefix(c))
+                }
+            }
+            _ => (),
+        }
+        i64::from_str_radix(num, 16).map_err(ParseNum)
+    })
+}
+
+#[test]
+fn unit_multipliers() {
+    use Unit::*;
+    assert_eq!(Kilobyte.get_multiplier(), 1000 * Byte.get_multiplier());
+    assert_eq!(Megabyte.get_multiplier(), 1000 * Kilobyte.get_multiplier());
+    assert_eq!(Gigabyte.get_multiplier(), 1000 * Megabyte.get_multiplier());
+    assert_eq!(Terabyte.get_multiplier(), 1000 * Gigabyte.get_multiplier());
+
+    assert_eq!(Kibibyte.get_multiplier(), 1024 * Byte.get_multiplier());
+    assert_eq!(Mebibyte.get_multiplier(), 1024 * Kibibyte.get_multiplier());
+    assert_eq!(Gibibyte.get_multiplier(), 1024 * Mebibyte.get_multiplier());
+    assert_eq!(Tebibyte.get_multiplier(), 1024 * Gibibyte.get_multiplier());
+}
+
+#[test]
+fn test_process_sign() {
+    use ByteOffsetKind::*;
+    use ByteOffsetParseError::*;
+    assert_eq!(process_sign_of("123"), Ok(("123", ForwardFromBeginning)));
+    assert_eq!(process_sign_of("+123"), Ok(("123", ForwardFromLastOffset)));
+    assert_eq!(process_sign_of("-123"), Ok(("123", BackwardFromEnd)));
+    assert_eq!(process_sign_of("-"), Err(EmptyAfterSign));
+    assert_eq!(process_sign_of("+"), Err(EmptyAfterSign));
+    assert_eq!(process_sign_of(""), Err(Empty));
+}
+
+#[test]
+fn test_parse_as_hex() {
+    assert_eq!(try_parse_as_hex_number("73"), None);
+    assert_eq!(try_parse_as_hex_number("0x1337"), Some(Ok(0x1337)));
+    assert!(matches!(try_parse_as_hex_number("0xnope"), Some(Err(_))));
+    assert!(matches!(try_parse_as_hex_number("0x-1"), Some(Err(_))));
+}
+
+#[test]
+fn extract_num_and_unit() {
+    use ByteOffsetParseError::*;
+    use Unit::*;
+    // byte is default unit
+    assert_eq!(extract_num_and_unit_from("4"), Ok((4, Byte)));
+    // blocks are returned without customization
+    assert_eq!(
+        extract_num_and_unit_from("2blocks"),
+        Ok((2, Block { custom_size: None }))
+    );
+    // no normalization is performed
+    assert_eq!(extract_num_and_unit_from("1024kb"), Ok((1024, Kilobyte)));
+
+    // unit without number results in error
+    assert_eq!(
+        extract_num_and_unit_from("gib"),
+        Err(EmptyWithUnit("gib".to_string()))
+    );
+    // empty string results in error
+    assert_eq!(extract_num_and_unit_from(""), Err(Empty));
+    // an invalid unit results in an error
+    assert_eq!(
+        extract_num_and_unit_from("25litres"),
+        Err(InvalidUnit("litres".to_string()))
+    );
+}
+
+#[test]
+fn test_parse_byte_offset() {
+    use ByteOffsetParseError::*;
+
+    macro_rules! success {
+        ($input: expr, $expected_kind: ident $expected_value: expr) => {
+            success!($input, $expected_kind $expected_value; block_size: DEFAULT_BLOCK_SIZE)
+        };
+        ($input: expr, $expected_kind: ident $expected_value: expr; block_size: $block_size: expr) => {
+            assert_eq!(
+                parse_byte_offset($input, PositiveI64::new($block_size).unwrap()),
+                Ok(
+                    ByteOffset {
+                        value: NonNegativeI64::new($expected_value).unwrap(),
+                        kind: ByteOffsetKind::$expected_kind,
+                    }
+                ),
+            );
+        };
+    }
+
+    macro_rules! error {
+        ($input: expr, $expected_err: expr) => {
+            assert_eq!(
+                parse_byte_offset($input, PositiveI64::new(DEFAULT_BLOCK_SIZE).unwrap()),
+                Err($expected_err),
+            );
+        };
+    }
+
+    success!("0", ForwardFromBeginning 0);
+    success!("1", ForwardFromBeginning 1);
+    success!("1", ForwardFromBeginning 1);
+    success!("100", ForwardFromBeginning 100);
+    success!("+100", ForwardFromLastOffset 100);
+
+    success!("0x0", ForwardFromBeginning 0);
+    success!("0xf", ForwardFromBeginning 15);
+    success!("0xdeadbeef", ForwardFromBeginning 3_735_928_559);
+
+    success!("1KB", ForwardFromBeginning 1000);
+    success!("2MB", ForwardFromBeginning 2000000);
+    success!("3GB", ForwardFromBeginning 3000000000);
+    success!("4TB", ForwardFromBeginning 4000000000000);
+    success!("+4TB", ForwardFromLastOffset 4000000000000);
+
+    success!("1GiB", ForwardFromBeginning 1073741824);
+    success!("2TiB", ForwardFromBeginning 2199023255552);
+    success!("+2TiB", ForwardFromLastOffset 2199023255552);
+
+    success!("0xff", ForwardFromBeginning 255);
+    success!("0xEE", ForwardFromBeginning 238);
+    success!("+0xFF", ForwardFromLastOffset 255);
+
+    success!("1block", ForwardFromBeginning 512; block_size: 512);
+    success!("2block", ForwardFromBeginning 1024; block_size: 512);
+    success!("1block", ForwardFromBeginning 4; block_size: 4);
+    success!("2block", ForwardFromBeginning 8; block_size: 4);
+
+    // empty string is invalid
+    error!("", Empty);
+    // These are also bad.
+    error!("+", EmptyAfterSign);
+    error!("-", EmptyAfterSign);
+    error!("K", InvalidNumAndUnit("K".to_owned()));
+    error!("k", InvalidNumAndUnit("k".to_owned()));
+    error!("m", InvalidNumAndUnit("m".to_owned()));
+    error!("block", EmptyWithUnit("block".to_owned()));
+    // leading/trailing space is invalid
+    error!(" 0", InvalidNumAndUnit(" 0".to_owned()));
+    error!("0 ", InvalidUnit(" ".to_owned()));
+    // Signs after the hex prefix make no sense
+    error!("0x-12", SignFoundAfterHexPrefix('-'));
+    // This was previously accepted but shouldn't be.
+    error!("0x+12", SignFoundAfterHexPrefix('+'));
+    // invalid suffix
+    error!("1234asdf", InvalidUnit("asdf".to_owned()));
+    // bad numbers
+    error!("asdf1234", InvalidNumAndUnit("asdf1234".to_owned()));
+    error!("a1s2d3f4", InvalidNumAndUnit("a1s2d3f4".to_owned()));
+    // multiplication overflows u64
+    error!("20000000TiB", UnitMultiplicationOverflow);
+
+    assert!(
+        match parse_byte_offset("99999999999999999999", PositiveI64::new(512).unwrap()) {
+            // We can't check against the kind of the `ParseIntError`, so we'll just make sure it's the
+            // same as trying to do the parse directly.
+            Err(ParseNum(e)) => e == "99999999999999999999".parse::<i64>().unwrap_err(),
+            _ => false,
+        }
+    );
+}
@@ -1,184 +0,0 @@
-use owo_colors::{colors, AnsiColors, Color, DynColors, OwoColorize};
-use std::str::FromStr;
-use std::sync::LazyLock;
-
-pub static COLOR_NULL: LazyLock<String> =
-    LazyLock::new(|| init_color("NULL", AnsiColors::BrightBlack));
-pub static COLOR_OFFSET: LazyLock<String> =
-    LazyLock::new(|| init_color("OFFSET", AnsiColors::BrightBlack));
-pub static COLOR_ASCII_PRINTABLE: LazyLock<String> =
-    LazyLock::new(|| init_color("ASCII_PRINTABLE", AnsiColors::Cyan));
-pub static COLOR_ASCII_WHITESPACE: LazyLock<String> =
-    LazyLock::new(|| init_color("ASCII_WHITESPACE", AnsiColors::Green));
-pub static COLOR_ASCII_OTHER: LazyLock<String> =
-    LazyLock::new(|| init_color("ASCII_OTHER", AnsiColors::Green));
-pub static COLOR_NONASCII: LazyLock<String> =
-    LazyLock::new(|| init_color("NONASCII", AnsiColors::Yellow));
-pub const COLOR_RESET: &str = colors::Default::ANSI_FG;
-
-fn init_color(name: &str, default_ansi: AnsiColors) -> String {
-    let default = DynColors::Ansi(default_ansi);
-    let env_var = format!("HEXYL_COLOR_{name}");
-    let color = match std::env::var(env_var).as_deref() {
-        Ok(color) => match DynColors::from_str(color) {
-            Ok(color) => color,
-            _ => default,
-        },
-        _ => default,
-    };
-    // owo_colors' API isn't designed to get the terminal codes directly for
-    // dynamic colors, so we use this hack to get them from the LHS of some text.
-    format!("{}", "|".color(color))
-        .split_once("|")
-        .unwrap()
-        .0
-        .to_owned()
-}
-
-pub const COLOR_NULL_RGB: &[u8] = &rgb_bytes(100, 100, 100);
-
-pub const COLOR_DEL: &[u8] = &rgb_bytes(64, 128, 0);
-
-pub const COLOR_GRADIENT_NONASCII: [[u8; 19]; 128] =
-    generate_color_gradient(&[(255, 0, 0, 0.0), (255, 255, 0, 0.66), (255, 255, 255, 1.0)]);
-
-pub const COLOR_GRADIENT_ASCII_NONPRINTABLE: [[u8; 19]; 31] =
-    generate_color_gradient(&[(255, 0, 255, 0.0), (128, 0, 255, 1.0)]);
-
-pub const COLOR_GRADIENT_ASCII_PRINTABLE: [[u8; 19]; 95] =
-    generate_color_gradient(&[(0, 128, 255, 0.0), (0, 255, 128, 1.0)]);
-
-const fn as_dec(byte: u8) -> [u8; 3] {
-    [
-        b'0' + (byte / 100),
-        b'0' + ((byte % 100) / 10),
-        b'0' + (byte % 10),
-    ]
-}
-
-const fn rgb_bytes(r: u8, g: u8, b: u8) -> [u8; 19] {
-    let mut buf = *b"\x1b[38;2;rrr;ggg;bbbm";
-
-    // r 7
-    buf[7] = as_dec(r)[0];
-    buf[8] = as_dec(r)[1];
-    buf[9] = as_dec(r)[2];
-
-    // g 11
-    buf[11] = as_dec(g)[0];
-    buf[12] = as_dec(g)[1];
-    buf[13] = as_dec(g)[2];
-
-    // b 15
-    buf[15] = as_dec(b)[0];
-    buf[16] = as_dec(b)[1];
-    buf[17] = as_dec(b)[2];
-
-    buf
-}
-
-const fn generate_color_gradient<const N: usize>(stops: &[(u8, u8, u8, f64)]) -> [[u8; 19]; N] {
-    let mut out = [rgb_bytes(0, 0, 0); N];
-
-    assert!(stops.len() >= 2, "need at least two stops for the gradient");
-
-    let mut byte = 0;
-    while byte < N {
-        let relative_byte = byte as f64 / N as f64;
-
-        let mut i = 1;
-        while i < stops.len() && stops[i].3 < relative_byte {
-            i += 1;
-        }
-        if i >= stops.len() {
-            i = stops.len() - 1;
-        }
-        let prev_stop = stops[i - 1];
-        let stop = stops[i];
-        let diff = stop.3 - prev_stop.3;
-        let t = (relative_byte - prev_stop.3) / diff;
-
-        let r = (prev_stop.0 as f64 + (t * (stop.0 as f64 - prev_stop.0 as f64))) as u8;
-        let g = (prev_stop.1 as f64 + (t * (stop.1 as f64 - prev_stop.1 as f64))) as u8;
-        let b = (prev_stop.2 as f64 + (t * (stop.2 as f64 - prev_stop.2 as f64))) as u8;
-
-        out[byte] = rgb_bytes(r, g, b);
-
-        byte += 1;
-    }
-
-    out
-}
-
-#[rustfmt::skip]
-pub const CP437: [char; 256] = [
-    // Copyright (c) 2016, Delan Azabani <delan@azabani.com>
-    //
-    // Permission to use, copy, modify, and/or distribute this software for any
-    // purpose with or without fee is hereby granted, provided that the above
-    // copyright notice and this permission notice appear in all copies.
-    //
-    // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-    // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-    // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-    //
-    // modified to use the ⋄ character instead of ␀
-
-    // use https://en.wikipedia.org/w/index.php?title=Code_page_437&oldid=978947122
-    // not ftp://ftp.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/PC/CP437.TXT
-    // because we want the graphic versions of 01h–1Fh + 7Fh
-    '⋄','☺','☻','♥','♦','♣','♠','•','◘','○','◙','♂','♀','♪','♫','☼',
-    '►','◄','↕','‼','¶','§','▬','↨','↑','↓','→','←','∟','↔','▲','▼',
-    ' ','!','"','#','$','%','&','\'','(',')','*','+',',','-','.','/',
-    '0','1','2','3','4','5','6','7','8','9',':',';','<','=','>','?',
-    '@','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
-    'P','Q','R','S','T','U','V','W','X','Y','Z','[','\\',']','^','_',
-    '`','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o',
-    'p','q','r','s','t','u','v','w','x','y','z','{','|','}','~','⌂',
-    'Ç','ü','é','â','ä','à','å','ç','ê','ë','è','ï','î','ì','Ä','Å',
-    'É','æ','Æ','ô','ö','ò','û','ù','ÿ','Ö','Ü','¢','£','¥','₧','ƒ',
-    'á','í','ó','ú','ñ','Ñ','ª','º','¿','⌐','¬','½','¼','¡','«','»',
-    '░','▒','▓','│','┤','╡','╢','╖','╕','╣','║','╗','╝','╜','╛','┐',
-    '└','┴','┬','├','─','┼','╞','╟','╚','╔','╩','╦','╠','═','╬','╧',
-    '╨','╤','╥','╙','╘','╒','╓','╫','╪','┘','┌','█','▄','▌','▐','▀',
-    'α','ß','Γ','π','Σ','σ','µ','τ','Φ','Θ','Ω','δ','∞','φ','ε','∩',
-    '≡','±','≥','≤','⌠','⌡','÷','≈','°','∙','·','√','ⁿ','²','■','ﬀ',
-];
-
-#[rustfmt::skip]
-pub const CP1047: [char; 256] = [
-     //
-     //  Copyright (c) 2016,2024 IBM Corporation and other Contributors.
-     //
-     //  All rights reserved. This program and the accompanying materials
-     //  are made available under the terms of the Eclipse Public License v1.0
-     //  which accompanies this distribution, and is available at
-     //  http://www.eclipse.org/legal/epl-v10.html
-     //
-     //  Contributors:
-     //    Mark Taylor - Initial Contribution
-     //
-
-     // ref1 https://github.com/ibm-messaging/mq-smf-csv/blob/master/src/smfConv.c
-    //  ref2 https://web.archive.org/web/20150607033635/http://www-01.ibm.com/software/globalization/cp/cp01047.html
-    '.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',
-    '.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',
-    '.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',
-    '.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',
-    ' ','.','.','.','.','.','.','.','.','.','$','.','<','(','+','|',
-    '&','.','.','.','.','.','.','.','.','.','!','$','*',')',';','.',
-    '-','/','.','.','.','.','.','.','.','.','.',',','%','_','>','?',
-    '.','.','.','.','.','.','.','.','.','.',':','#','@','\'','=','.',
-    '.','a','b','c','d','e','f','g','h','i','.','{','.','(','+','.',
-    '.','j','k','l','m','n','o','p','q','r','.','}','.',')','.','.',
-    '.','~','s','t','u','v','w','x','y','z','.','.','.','.','.','.',
-    '.','.','.','.','.','.','.','.','.','.','[',']','.','.','.','-',
-    '{','A','B','C','D','E','F','G','H','I','.','.','.','.','.','.',
-    '}','J','K','L','M','N','O','P','Q','R','.','.','.','.','.','.',
-    '.','.','S','T','U','V','W','X','Y','Z','.','.','.','.','.','.',
-    '0','1','2','3','4','5','6','7','8','9','.','.','.','.','.','.'
-];
@@ -1,3 +1,4 @@
+use std::convert::TryFrom;
 use std::fs;
 use std::io::{self, copy, sink, Read, Seek, SeekFrom};

@@ -6,7 +7,7 @@ pub enum Input<'a> {
    Stdin(io::StdinLock<'a>),
 }

-impl Read for Input<'_> {
+impl<'a> Read for Input<'a> {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        match *self {
            Input::File(ref mut file) => file.read(buf),
@@ -15,13 +16,13 @@ impl Read for Input<'_> {
    }
 }

-impl Seek for Input<'_> {
+impl<'a> Seek for Input<'a> {
    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
        fn try_skip<R>(reader: R, pos: SeekFrom, err_desc: &'static str) -> io::Result<u64>
        where
            R: Read,
        {
-            let cant_seek_abs_err = || Err(io::Error::other(err_desc));
+            let cant_seek_abs_err = || Err(io::Error::new(io::ErrorKind::Other, err_desc));

            let offset = match pos {
                SeekFrom::Current(o) => u64::try_from(o).or_else(|_e| cant_seek_abs_err())?,
@@ -1,835 +0,0 @@
-use std::fs::File;
-use std::io::{self, prelude::*, BufWriter, SeekFrom};
-use std::num::{NonZeroI64, NonZeroU64};
-use std::path::PathBuf;
-
-use clap::builder::styling::{AnsiColor, Effects};
-use clap::builder::ArgPredicate;
-use clap::builder::Styles;
-use clap::{ArgAction, CommandFactory, Parser, ValueEnum};
-use clap_complete::aot::{generate, Shell};
-
-use anyhow::{anyhow, bail, Context, Result};
-
-use const_format::formatcp;
-
-use thiserror::Error as ThisError;
-
-use terminal_size::terminal_size;
-
-use hexyl::{
-    Base, BorderStyle, CharacterTable, ColorScheme, Endianness, IncludeMode, Input, PrinterBuilder,
-};
-
-use hexyl::{
-    COLOR_ASCII_OTHER, COLOR_ASCII_PRINTABLE, COLOR_ASCII_WHITESPACE, COLOR_NONASCII, COLOR_NULL,
-    COLOR_RESET,
-};
-
-#[cfg(test)]
-mod tests;
-
-const DEFAULT_BLOCK_SIZE: i64 = 512;
-
-const LENGTH_HELP_TEXT: &str = "Only read N bytes from the input. The N argument can also include \
-                                a unit with a decimal prefix (kB, MB, ..) or binary prefix (kiB, \
-                                MiB, ..), or can be specified using a hex number. The short \
-                                option '-l' can be used as an alias.
-Examples: --length=64, --length=4KiB, --length=0xff";
-
-const SKIP_HELP_TEXT: &str = "Skip the first N bytes of the input. The N argument can also \
-                              include a unit (see `--length` for details).
-A negative value is valid and will seek from the end of the file.";
-
-const BLOCK_SIZE_HELP_TEXT: &str = "Sets the size of the `block` unit to SIZE.
-Examples: --block-size=1024, --block-size=4kB";
-
-const DISPLAY_OFFSET_HELP_TEXT: &str = "Add N bytes to the displayed file position. The N \
-                                        argument can also include a unit (see `--length` for \
-                                        details).
-A negative value is valid and calculates an offset relative to the end of the file.";
-
-const TERMINAL_WIDTH_HELP_TEXT: &str = "Sets the number of terminal columns to be displayed.
-Since the terminal width may not be an evenly divisible by the width per hex data column, this \
-                                        will use the greatest number of hex data panels that can \
-                                        fit in the requested width but still leave some space to \
-                                        the right.
-Cannot be used with other width-setting options.";
-
-const STYLES: Styles = Styles::styled()
-    .header(AnsiColor::Green.on_default().effects(Effects::BOLD))
-    .usage(AnsiColor::Green.on_default().effects(Effects::BOLD))
-    .literal(AnsiColor::Cyan.on_default().effects(Effects::BOLD))
-    .placeholder(AnsiColor::Cyan.on_default());
-
-#[derive(Debug, Parser)]
-#[command(version, about, max_term_width(90), styles = STYLES)]
-struct Opt {
-    /// The file to display. If no FILE argument is given, read from STDIN.
-    #[arg(value_name("FILE"))]
-    file: Option<PathBuf>,
-
-    #[arg(
-        help(LENGTH_HELP_TEXT),
-        short('n'),
-        long,
-        visible_short_alias('c'),
-        visible_alias("bytes"),
-        short_alias('l'),
-        value_name("N")
-    )]
-    length: Option<String>,
-
-    #[arg(help(SKIP_HELP_TEXT), short, long, value_name("N"))]
-    skip: Option<String>,
-
-    #[arg(
-        help(BLOCK_SIZE_HELP_TEXT),
-        long,
-        default_value(formatcp!("{DEFAULT_BLOCK_SIZE}")),
-        value_name("SIZE")
-    )]
-    block_size: String,
-
-    /// Displays all input data. Otherwise any number of groups of output lines
-    /// which would be identical to the preceding group of lines, are replaced
-    /// with a line comprised of a single asterisk.
-    #[arg(short('v'), long)]
-    no_squeezing: bool,
-
-    /// When to use colors.
-    #[arg(
-        long,
-        value_enum,
-        default_value_t,
-        value_name("WHEN"),
-        default_value_if("plain", ArgPredicate::IsPresent, Some("never"))
-    )]
-    color: ColorWhen,
-
-    /// Whether to draw a border.
-    #[arg(
-        long,
-        value_enum,
-        default_value_t,
-        value_name("STYLE"),
-        default_value_if("plain", ArgPredicate::IsPresent, Some("none"))
-    )]
-    border: BorderStyle,
-
-    /// Display output with --no-characters, --no-position, --border=none, and
-    /// --color=never.
-    #[arg(short, long)]
-    plain: bool,
-
-    /// Do not show the character panel on the right.
-    #[arg(long)]
-    no_characters: bool,
-
-    /// Show the character panel on the right. This is the default, unless
-    /// --no-characters has been specified.
-    #[arg(
-        short('C'),
-        long,
-        action(ArgAction::SetTrue),
-        overrides_with("no_characters")
-    )]
-    characters: (),
-
-    /// Defines how bytes are mapped to characters.
-    #[arg(long, value_enum, default_value_t, value_name("FORMAT"))]
-    character_table: CharacterTable,
-
-    /// Defines the color scheme for the characters.
-    #[arg(long, value_enum, default_value_t, value_name("FORMAT"))]
-    color_scheme: ColorScheme,
-
-    /// Whether to display the position panel on the left.
-    #[arg(short('P'), long)]
-    no_position: bool,
-
-    #[arg(
-        help(DISPLAY_OFFSET_HELP_TEXT),
-        short('o'),
-        long,
-        default_value("0"),
-        value_name("N")
-    )]
-    display_offset: String,
-
-    /// Sets the number of hex data panels to be displayed. `--panels=auto` will
-    /// display the maximum number of hex data panels based on the current
-    /// terminal width. By default, hexyl will show two panels, unless the
-    /// terminal is not wide enough for that.
-    #[arg(long, value_name("N"))]
-    panels: Option<String>,
-
-    /// Number of bytes/octets that should be grouped together. You can use the
-    /// '--endianness' option to control the ordering of the bytes within a
-    /// group. '--groupsize' can be used as an alias (xxd-compatibility).
-    #[arg(
-        short('g'),
-        long,
-        value_enum,
-        default_value_t,
-        alias("groupsize"),
-        value_name("N")
-    )]
-    group_size: GroupSize,
-
-    /// Whether to print out groups in little-endian or big-endian format. This
-    /// option only has an effect if the '--group-size' is larger than 1. '-e'
-    /// can be used as an alias for '--endianness=little'.
-    #[arg(long, value_enum, default_value_t, value_name("FORMAT"))]
-    endianness: Endianness,
-
-    /// An alias for '--endianness=little'.
-    #[arg(short('e'), hide(true), overrides_with("endianness"))]
-    little_endian_format: bool,
-
-    /// Sets the base used for the bytes. The possible options are binary,
-    /// octal, decimal, and hexadecimal.
-    #[arg(short('b'), long, default_value("hexadecimal"), value_name("B"))]
-    base: String,
-
-    #[arg(
-        help(TERMINAL_WIDTH_HELP_TEXT),
-        long,
-        value_name("N"),
-        conflicts_with("panels")
-    )]
-    terminal_width: Option<NonZeroU64>,
-
-    /// Print a table showing how different types of bytes are colored.
-    #[arg(long)]
-    print_color_table: bool,
-
-    /// Output in C include file style (similar to xxd -i).
-    #[arg(
-        short('i'),
-        long("include"),
-        help = "Output in C include file style",
-        conflicts_with("little_endian_format"),
-        conflicts_with("endianness")
-    )]
-    include_mode: bool,
-
-    /// Show shell completion for a certain shell
-    #[arg(long, value_name("SHELL"))]
-    completion: Option<Shell>,
-}
-
-#[derive(Clone, Debug, Default, ValueEnum)]
-enum ColorWhen {
-    /// Always use colorized output.
-    #[default]
-    Always,
-
-    /// Only displays colors if the output goes to an interactive terminal.
-    Auto,
-
-    /// Do not use colorized output.
-    Never,
-
-    /// Override the NO_COLOR environment variable.
-    Force,
-}
-
-#[derive(Clone, Debug, Default, ValueEnum)]
-enum GroupSize {
-    /// Grouped together every byte/octet.
-    #[default]
-    #[value(name = "1")]
-    One,
-
-    /// Grouped together every 2 bytes/octets.
-    #[value(name = "2")]
-    Two,
-
-    /// Grouped together every 4 bytes/octets.
-    #[value(name = "4")]
-    Four,
-
-    /// Grouped together every 8 bytes/octets.
-    #[value(name = "8")]
-    Eight,
-}
-
-impl From<GroupSize> for u8 {
-    fn from(number: GroupSize) -> Self {
-        match number {
-            GroupSize::One => 1,
-            GroupSize::Two => 2,
-            GroupSize::Four => 4,
-            GroupSize::Eight => 8,
-        }
-    }
-}
-
-fn run() -> Result<()> {
-    let opt = Opt::parse();
-
-    if opt.print_color_table {
-        return print_color_table().map_err(|e| anyhow!(e));
-    }
-
-    if let Some(sh) = opt.completion {
-        let mut cmd = Opt::command();
-        let name = cmd.get_name().to_string();
-        generate(sh, &mut cmd, name, &mut io::stdout());
-        return Ok(());
-    }
-
-    let stdin = io::stdin();
-
-    let mut reader = match &opt.file {
-        Some(filename) => {
-            if filename.as_os_str() == "-" {
-                Input::Stdin(stdin.lock())
-            } else {
-                if filename.is_dir() {
-                    bail!("'{}' is a directory.", filename.to_string_lossy());
-                }
-                let file = File::open(filename)?;
-
-                Input::File(file)
-            }
-        }
-        None => Input::Stdin(stdin.lock()),
-    };
-
-    if let Some(hex_number) = try_parse_as_hex_number(&opt.block_size) {
-        return hex_number
-            .map_err(|e| anyhow!(e))
-            .and_then(|x| {
-                PositiveI64::new(x).ok_or_else(|| anyhow!("block size argument must be positive"))
-            })
-            .map(|_| ());
-    }
-    let (num, unit) = extract_num_and_unit_from(&opt.block_size)?;
-    if let Unit::Block { custom_size: _ } = unit {
-        return Err(anyhow!(
-            "can not use 'block(s)' as a unit to specify block size"
-        ));
-    };
-    let block_size = num
-        .checked_mul(unit.get_multiplier())
-        .ok_or_else(|| anyhow!(ByteOffsetParseError::UnitMultiplicationOverflow))
-        .and_then(|x| {
-            PositiveI64::new(x).ok_or_else(|| anyhow!("block size argument must be positive"))
-        })?;
-
-    let skip_arg = opt
-        .skip
-        .as_ref()
-        .map(|s| {
-            parse_byte_offset(s, block_size).context(anyhow!(
-                "failed to parse `--skip` arg {:?} as byte count",
-                s
-            ))
-        })
-        .transpose()?;
-
-    let skip_offset = if let Some(ByteOffset { kind, value }) = skip_arg {
-        let value = value.into_inner();
-        reader
-            .seek(match kind {
-                ByteOffsetKind::ForwardFromBeginning | ByteOffsetKind::ForwardFromLastOffset => {
-                    SeekFrom::Current(value)
-                }
-                ByteOffsetKind::BackwardFromEnd => SeekFrom::End(value.checked_neg().unwrap()),
-            })
-            .map_err(|_| {
-                anyhow!(
-                    "Failed to jump to the desired input position. \
-                     This could be caused by a negative offset that is too large or by \
-                     an input that is not seek-able (e.g. if the input comes from a pipe)."
-                )
-            })?
-    } else {
-        0
-    };
-
-    let parse_byte_count = |s| -> Result<u64> {
-        Ok(parse_byte_offset(s, block_size)?
-            .assume_forward_offset_from_start()?
-            .into())
-    };
-
-    let mut reader = if let Some(ref length) = opt.length {
-        let length = parse_byte_count(length).context(anyhow!(
-            "failed to parse `--length` arg {:?} as byte count",
-            length
-        ))?;
-        Box::new(reader.take(length))
-    } else {
-        reader.into_inner()
-    };
-
-    let no_color = std::env::var_os("NO_COLOR").is_some();
-    let show_color = match opt.color {
-        ColorWhen::Never => false,
-        ColorWhen::Always => !no_color,
-        ColorWhen::Force => true,
-        ColorWhen::Auto => {
-            if no_color {
-                false
-            } else {
-                supports_color::on(supports_color::Stream::Stdout)
-                    .map(|level| level.has_basic)
-                    .unwrap_or(false)
-            }
-        }
-    };
-
-    let border_style = opt.border;
-
-    let &squeeze = &!opt.no_squeezing;
-
-    let show_char_panel = !opt.no_characters && !opt.plain;
-
-    let show_position_panel = !opt.no_position && !opt.plain;
-
-    let display_offset: u64 = parse_byte_count(&opt.display_offset).context(anyhow!(
-        "failed to parse `--display-offset` arg {:?} as byte count",
-        opt.display_offset
-    ))?;
-
-    let max_panels_fn = |terminal_width: u64, base_digits: u64, group_size: u64| {
-        let offset = if show_position_panel { 10 } else { 1 };
-        let col_width = if show_char_panel {
-            ((8 / group_size) * (base_digits * group_size + 1)) + 2 + 8
-        } else {
-            ((8 / group_size) * (base_digits * group_size + 1)) + 2
-        };
-        if (terminal_width.saturating_sub(offset)) / col_width < 1 {
-            1
-        } else {
-            (terminal_width - offset) / col_width
-        }
-    };
-
-    let base = if let Ok(base_num) = opt.base.parse::<u8>() {
-        match base_num {
-            2 => Ok(Base::Binary),
-            8 => Ok(Base::Octal),
-            10 => Ok(Base::Decimal),
-            16 => Ok(Base::Hexadecimal),
-            _ => Err(anyhow!(
-                "The number provided is not a valid base. Valid bases are 2, 8, 10, and 16."
-            )),
-        }
-    } else {
-        match opt.base.as_str() {
-            "b" | "bin" | "binary" => Ok(Base::Binary),
-            "o" | "oct" | "octal" => Ok(Base::Octal),
-            "d" | "dec" | "decimal" => Ok(Base::Decimal),
-            "x" | "hex" | "hexadecimal" => Ok(Base::Hexadecimal),
-            _ => Err(anyhow!(
-                "The base provided is not valid. Valid bases are \"b\", \"o\", \"d\", and \"x\"."
-            )),
-        }
-    }?;
-
-    let base_digits = match base {
-        Base::Binary => 8,
-        Base::Octal => 3,
-        Base::Decimal => 3,
-        Base::Hexadecimal => 2,
-    };
-
-    let group_size = u8::from(opt.group_size);
-
-    let terminal_width = terminal_size().map(|s| s.0 .0 as u64).unwrap_or(80);
-
-    let panels = if opt.panels.as_deref() == Some("auto") {
-        max_panels_fn(terminal_width, base_digits, group_size.into())
-    } else if let Some(panels) = opt.panels {
-        panels
-            .parse::<NonZeroU64>()
-            .map(u64::from)
-            .context(anyhow!(
-                "failed to parse `--panels` arg {:?} as unsigned nonzero integer",
-                panels
-            ))?
-    } else if let Some(terminal_width) = opt.terminal_width {
-        max_panels_fn(terminal_width.into(), base_digits, group_size.into())
-    } else {
-        std::cmp::min(
-            2,
-            max_panels_fn(terminal_width, base_digits, group_size.into()),
-        )
-    };
-
-    let endianness = if opt.little_endian_format {
-        Endianness::Little
-    } else {
-        opt.endianness
-    };
-
-    let character_table = opt.character_table;
-
-    let color_scheme = opt.color_scheme;
-
-    let mut stdout = BufWriter::new(io::stdout().lock());
-
-    let include_mode = match opt.include_mode {
-        // include mode on
-        true => {
-            if let Some(include_file) = opt.file {
-                // input from a file
-                if include_file.as_os_str() == "-" {
-                    IncludeMode::File("stdin".to_string())
-                } else {
-                    IncludeMode::File(
-                        include_file
-                            .file_name()
-                            .and_then(|n| n.to_str())
-                            .unwrap_or("file")
-                            .to_string(),
-                    )
-                }
-            } else {
-                // input from stdin
-                IncludeMode::Stdin
-            }
-        }
-        // include mode off
-        false => IncludeMode::Off,
-    };
-
-    let mut printer = PrinterBuilder::new(&mut stdout)
-        .show_color(show_color)
-        .show_char_panel(show_char_panel)
-        .show_position_panel(show_position_panel)
-        .with_border_style(border_style)
-        .enable_squeezing(squeeze)
-        .num_panels(panels)
-        .group_size(group_size)
-        .with_base(base)
-        .endianness(endianness)
-        .character_table(character_table)
-        .include_mode(include_mode)
-        .color_scheme(color_scheme)
-        .build();
-    printer.display_offset(skip_offset + display_offset);
-    printer.print_all(&mut reader).map_err(|e| anyhow!(e))?;
-
-    Ok(())
-}
-
-fn main() {
-    let result = run();
-
-    if let Err(err) = result {
-        if let Some(io_error) = err.downcast_ref::<io::Error>() {
-            if io_error.kind() == ::std::io::ErrorKind::BrokenPipe {
-                std::process::exit(0);
-            }
-        }
-        eprintln!("Error: {err:?}");
-        std::process::exit(1);
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, Hash, Eq, Ord, PartialEq, PartialOrd)]
-pub struct NonNegativeI64(i64);
-
-impl NonNegativeI64 {
-    pub fn new(x: i64) -> Option<Self> {
-        if x.is_negative() {
-            None
-        } else {
-            Some(Self(x))
-        }
-    }
-
-    pub fn into_inner(self) -> i64 {
-        self.0
-    }
-}
-
-impl From<NonNegativeI64> for u64 {
-    fn from(x: NonNegativeI64) -> u64 {
-        u64::try_from(x.0)
-            .expect("invariant broken: NonNegativeI64 should contain a non-negative i64 value")
-    }
-}
-
-fn print_color_table() -> io::Result<()> {
-    let mut stdout = BufWriter::new(io::stdout().lock());
-
-    writeln!(stdout, "hexyl color reference:\n")?;
-
-    // NULL bytes
-    stdout.write_all(COLOR_NULL.as_bytes())?;
-    writeln!(stdout, "⋄ NULL bytes (0x00)")?;
-    stdout.write_all(COLOR_RESET.as_bytes())?;
-
-    // ASCII printable
-    stdout.write_all(COLOR_ASCII_PRINTABLE.as_bytes())?;
-    writeln!(stdout, "a ASCII printable characters (0x20 - 0x7E)")?;
-    stdout.write_all(COLOR_RESET.as_bytes())?;
-
-    // ASCII whitespace
-    stdout.write_all(COLOR_ASCII_WHITESPACE.as_bytes())?;
-    writeln!(stdout, "_ ASCII whitespace (0x09 - 0x0D, 0x20)")?;
-    stdout.write_all(COLOR_RESET.as_bytes())?;
-
-    // ASCII other
-    stdout.write_all(COLOR_ASCII_OTHER.as_bytes())?;
-    writeln!(
-        stdout,
-        "• ASCII control characters (except NULL and whitespace)"
-    )?;
-    stdout.write_all(COLOR_RESET.as_bytes())?;
-
-    // Non-ASCII
-    stdout.write_all(COLOR_NONASCII.as_bytes())?;
-    writeln!(stdout, "× Non-ASCII bytes (0x80 - 0xFF)")?;
-    stdout.write_all(COLOR_RESET.as_bytes())?;
-
-    Ok(())
-}
-
-#[derive(Clone, Copy, Debug, Default, Hash, Eq, Ord, PartialEq, PartialOrd)]
-pub struct PositiveI64(i64);
-
-impl PositiveI64 {
-    pub fn new(x: i64) -> Option<Self> {
-        if x < 1 {
-            None
-        } else {
-            Some(Self(x))
-        }
-    }
-
-    pub fn into_inner(self) -> i64 {
-        self.0
-    }
-}
-
-impl From<PositiveI64> for u64 {
-    fn from(x: PositiveI64) -> u64 {
-        u64::try_from(x.0)
-            .expect("invariant broken: PositiveI64 should contain a positive i64 value")
-    }
-}
-
-#[derive(Debug, PartialEq)]
-enum Unit {
-    Byte,
-    Kilobyte,
-    Megabyte,
-    Gigabyte,
-    Terabyte,
-    Kibibyte,
-    Mebibyte,
-    Gibibyte,
-    Tebibyte,
-    /// a customizable amount of bytes
-    Block {
-        custom_size: Option<NonZeroI64>,
-    },
-}
-
-impl Unit {
-    const fn get_multiplier(self) -> i64 {
-        match self {
-            Self::Byte => 1,
-            Self::Kilobyte => 1000,
-            Self::Megabyte => 1_000_000,
-            Self::Gigabyte => 1_000_000_000,
-            Self::Terabyte => 1_000_000_000_000,
-            Self::Kibibyte => 1 << 10,
-            Self::Mebibyte => 1 << 20,
-            Self::Gibibyte => 1 << 30,
-            Self::Tebibyte => 1 << 40,
-            Self::Block {
-                custom_size: Some(size),
-            } => size.get(),
-            Self::Block { custom_size: None } => DEFAULT_BLOCK_SIZE,
-        }
-    }
-}
-
-const HEX_PREFIX: &str = "0x";
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-enum ByteOffsetKind {
-    ForwardFromBeginning,
-    ForwardFromLastOffset,
-    BackwardFromEnd,
-}
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-struct ByteOffset {
-    value: NonNegativeI64,
-    kind: ByteOffsetKind,
-}
-
-#[derive(Clone, Debug, ThisError)]
-#[error(
-    "negative offset specified, but only positive offsets (counts) are accepted in this context"
-)]
-struct NegativeOffsetSpecifiedError;
-
-impl ByteOffset {
-    fn assume_forward_offset_from_start(
-        &self,
-    ) -> Result<NonNegativeI64, NegativeOffsetSpecifiedError> {
-        let &Self { value, kind } = self;
-        match kind {
-            ByteOffsetKind::ForwardFromBeginning | ByteOffsetKind::ForwardFromLastOffset => {
-                Ok(value)
-            }
-            ByteOffsetKind::BackwardFromEnd => Err(NegativeOffsetSpecifiedError),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, ThisError)]
-enum ByteOffsetParseError {
-    #[error("no character data found, did you forget to write it?")]
-    Empty,
-    #[error("no digits found after sign, did you forget to write them?")]
-    EmptyAfterSign,
-    #[error(
-        "found {0:?} sign after hex prefix ({:?}); signs should go before it",
-        HEX_PREFIX
-    )]
-    SignFoundAfterHexPrefix(char),
-    #[error("{0:?} is not of the expected form <pos-integer>[<unit>]")]
-    InvalidNumAndUnit(String),
-    #[error("{0:?} is a valid unit, but an integer should come before it")]
-    EmptyWithUnit(String),
-    #[error("invalid unit {0:?}")]
-    InvalidUnit(String),
-    #[error("failed to parse integer part")]
-    ParseNum(#[source] std::num::ParseIntError),
-    #[error("count multiplied by the unit overflowed a signed 64-bit integer; are you sure it should be that big?")]
-    UnitMultiplicationOverflow,
-}
-
-fn parse_byte_offset(n: &str, block_size: PositiveI64) -> Result<ByteOffset, ByteOffsetParseError> {
-    use ByteOffsetParseError::*;
-
-    let (n, kind) = process_sign_of(n)?;
-
-    let into_byte_offset = |value| {
-        Ok(ByteOffset {
-            value: NonNegativeI64::new(value).unwrap(),
-            kind,
-        })
-    };
-
-    if let Some(hex_number) = try_parse_as_hex_number(n) {
-        return hex_number.map(into_byte_offset)?;
-    }
-
-    let (num, mut unit) = extract_num_and_unit_from(n)?;
-    if let Unit::Block { custom_size: None } = unit {
-        unit = Unit::Block {
-            custom_size: Some(
-                NonZeroI64::new(block_size.into_inner()).expect("PositiveI64 was zero"),
-            ),
-        };
-    }
-
-    num.checked_mul(unit.get_multiplier())
-        .ok_or(UnitMultiplicationOverflow)
-        .and_then(into_byte_offset)
-}
-
-/// Takes a string containing a base-10 number and an optional unit, and returns them with their proper types.
-/// The unit must directly follow the number (e.g. no whitespace is allowed between them).
-/// When no unit is given, [Unit::Byte] is assumed.
-/// When the unit is [Unit::Block], it is returned without custom size.
-/// No normalization is performed, that is "1024" is extracted to (1024, Byte), not (1, Kibibyte).
-fn extract_num_and_unit_from(n: &str) -> Result<(i64, Unit), ByteOffsetParseError> {
-    use ByteOffsetParseError::*;
-    if n.is_empty() {
-        return Err(Empty);
-    }
-    match n.chars().position(|c| !c.is_ascii_digit()) {
-        Some(unit_begin_idx) => {
-            let (n, raw_unit) = n.split_at(unit_begin_idx);
-            let unit = match raw_unit.to_lowercase().as_str() {
-                "" => Unit::Byte, // no "b" => Byte to allow hex nums with units
-                "kb" => Unit::Kilobyte,
-                "mb" => Unit::Megabyte,
-                "gb" => Unit::Gigabyte,
-                "tb" => Unit::Terabyte,
-                "kib" => Unit::Kibibyte,
-                "mib" => Unit::Mebibyte,
-                "gib" => Unit::Gibibyte,
-                "tib" => Unit::Tebibyte,
-                "block" | "blocks" => Unit::Block { custom_size: None },
-                _ => {
-                    return if n.is_empty() {
-                        Err(InvalidNumAndUnit(raw_unit.to_string()))
-                    } else {
-                        Err(InvalidUnit(raw_unit.to_string()))
-                    }
-                }
-            };
-            let num = n.parse::<i64>().map_err(|e| {
-                if n.is_empty() {
-                    EmptyWithUnit(raw_unit.to_owned())
-                } else {
-                    ParseNum(e)
-                }
-            })?;
-            Ok((num, unit))
-        }
-        None => {
-            // no unit part
-            let num = n.parse::<i64>().map_err(ParseNum)?;
-            Ok((num, Unit::Byte))
-        }
-    }
-}
-
-/// Extracts a [ByteOffsetKind] based on the sign at the beginning of the given string.
-/// Returns the input string without the sign (or an equal string if there wasn't any sign).
-fn process_sign_of(n: &str) -> Result<(&str, ByteOffsetKind), ByteOffsetParseError> {
-    use ByteOffsetParseError::*;
-    let mut chars = n.chars();
-    let next_char = chars.next();
-    let check_empty_after_sign = || {
-        if chars.clone().next().is_none() {
-            Err(EmptyAfterSign)
-        } else {
-            Ok(chars.as_str())
-        }
-    };
-    match next_char {
-        Some('+') => Ok((
-            check_empty_after_sign()?,
-            ByteOffsetKind::ForwardFromLastOffset,
-        )),
-        Some('-') => Ok((check_empty_after_sign()?, ByteOffsetKind::BackwardFromEnd)),
-        None => Err(Empty),
-        _ => Ok((n, ByteOffsetKind::ForwardFromBeginning)),
-    }
-}
-
-/// If `n` starts with a hex prefix, its remaining part is returned as some number (if possible),
-/// otherwise None is returned.
-fn try_parse_as_hex_number(n: &str) -> Option<Result<i64, ByteOffsetParseError>> {
-    use ByteOffsetParseError::*;
-    n.strip_prefix(HEX_PREFIX).map(|num| {
-        let mut chars = num.chars();
-        match chars.next() {
-            Some(c @ '+') | Some(c @ '-') => {
-                return if chars.next().is_none() {
-                    Err(EmptyAfterSign)
-                } else {
-                    Err(SignFoundAfterHexPrefix(c))
-                }
-            }
-            _ => (),
-        }
-        i64::from_str_radix(num, 16).map_err(ParseNum)
-    })
-}
@@ -0,0 +1,407 @@
+#[derive(Debug, PartialEq)]
+enum SqueezeState {
+    /// not enabled
+    Disabled,
+    /// Will be set from all states if equal condition can't be hold up.
+    /// Set if previous byte is not equal the current processed byte.
+    NoSqueeze,
+    /// Valid for a whole line to identify if it is candidate for squeezing
+    Probe,
+    /// Squeeze line parsing is active, but EOL is not reached yet
+    SqueezeActive,
+    /// Squeeze line, EOL is reached, will influence the action
+    Squeeze,
+    /// same as Squeeze, however this is only for the first line after
+    /// the squeeze candidate has been set.
+    SqueezeFirstLine,
+    /// same as SqueezeActive, however this is only for the first line after
+    /// the squeeze candidate has been set.
+    SqueezeActiveFirstLine,
+}
+
+pub struct Squeezer {
+    state: SqueezeState,
+    byte: u8,
+    lsize: u64,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum SqueezeAction {
+    Ignore,
+    Print,
+    Delete,
+}
+
+impl Squeezer {
+    pub fn new(enabled: bool, lsize: u64) -> Squeezer {
+        Squeezer {
+            state: if enabled {
+                SqueezeState::Probe
+            } else {
+                SqueezeState::Disabled
+            },
+            byte: 0,
+            lsize,
+        }
+    }
+
+    pub fn process(&mut self, b: u8, i: u64) {
+        use self::SqueezeState::*;
+        if self.state == Disabled {
+            return;
+        }
+        let eq = b == self.byte;
+
+        if i % self.lsize == 0 {
+            if !eq {
+                self.state = Probe;
+            } else {
+                self.state = match self.state {
+                    NoSqueeze => Probe,
+                    Probe => SqueezeActiveFirstLine,
+                    SqueezeActiveFirstLine => SqueezeFirstLine,
+                    SqueezeFirstLine => SqueezeActive,
+                    SqueezeActive => Squeeze,
+                    Squeeze => SqueezeActive,
+                    Disabled => Disabled,
+                };
+            }
+        } else if !eq {
+            if i % self.lsize == 1 {
+                self.state = Probe;
+            } else if i % self.lsize != 1 {
+                self.state = NoSqueeze;
+            }
+        }
+
+        self.byte = b;
+    }
+
+    pub fn active(&self) -> bool {
+        use self::SqueezeState::*;
+        matches!(
+            self.state,
+            Squeeze | SqueezeActive | SqueezeFirstLine | SqueezeActiveFirstLine
+        )
+    }
+
+    pub fn action(&self) -> SqueezeAction {
+        match self.state {
+            SqueezeState::SqueezeFirstLine => SqueezeAction::Print,
+            SqueezeState::Squeeze => SqueezeAction::Delete,
+            _ => SqueezeAction::Ignore,
+        }
+    }
+
+    pub fn advance(&mut self) {
+        match self.state {
+            SqueezeState::SqueezeFirstLine => {
+                self.state = SqueezeState::SqueezeActive;
+            }
+            SqueezeState::Squeeze => {
+                self.state = SqueezeState::SqueezeActive;
+            }
+            _ => {}
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const LSIZE: u64 = 16;
+    const LSIZE_USIZE: usize = LSIZE as usize;
+
+    #[test]
+    fn three_same_lines() {
+        const LINES: usize = 3;
+        let v = vec![0u8; LINES * LSIZE_USIZE];
+        let mut s = Squeezer::new(true, LSIZE);
+        // just initialized
+        assert_eq!(s.action(), SqueezeAction::Ignore);
+        s.advance();
+
+        let exp = vec![
+            SqueezeAction::Ignore, // first line, print as is
+            SqueezeAction::Print,  // print squeeze symbol
+            SqueezeAction::Delete, // delete reoccurring line
+        ];
+
+        let mut idx = 1;
+        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
+            for i in z {
+                s.process(*i, idx);
+                idx += 1;
+            }
+            let action = s.action();
+            s.advance();
+            assert_eq!(action, exp[line]);
+        }
+    }
+
+    #[test]
+    fn incomplete_while_squeeze() {
+        // fourth line only has 12 bytes and should be printed
+        let v = vec![0u8; 3 * LSIZE_USIZE + 12];
+        let mut s = Squeezer::new(true, LSIZE);
+        // just initialized
+        assert_eq!(s.action(), SqueezeAction::Ignore);
+        s.advance();
+
+        let exp = vec![
+            SqueezeAction::Ignore, // first line, print as is
+            SqueezeAction::Print,  // print squeeze symbol
+            SqueezeAction::Delete, // delete reoccurring line
+            SqueezeAction::Ignore, // last line only 12 bytes, print it
+        ];
+
+        let mut idx = 1;
+        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
+            for i in z {
+                s.process(*i, idx);
+                idx += 1;
+            }
+            assert_eq!(s.action(), exp[line]);
+            s.advance();
+        }
+    }
+
+    #[test]
+    /// all three lines are different, print all
+    fn three_different_lines() {
+        let mut v: Vec<u8> = vec![];
+        v.extend(vec![0u8; 16]);
+        v.extend(vec![1u8; 16]);
+        v.extend(vec![2u8; 16]);
+
+        let mut s = Squeezer::new(true, LSIZE);
+        // just initialized
+        assert_eq!(s.action(), SqueezeAction::Ignore);
+        s.advance();
+
+        let exp = vec![
+            SqueezeAction::Ignore, // first line, print as is
+            SqueezeAction::Ignore, // different
+            SqueezeAction::Ignore, // different
+        ];
+
+        let mut idx = 1;
+        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
+            for i in z {
+                s.process(*i, idx);
+                idx += 1;
+            }
+            let action = s.action();
+            assert_eq!(action, exp[line]);
+            s.advance();
+        }
+    }
+
+    #[test]
+    /// first two lines same, hence squeeze symbol, third line diff, hence
+    /// print
+    fn one_squeeze_no_delete() {
+        const LINES: usize = 3;
+        let mut v = vec![0u8; (LINES - 1) * LSIZE_USIZE];
+        v.extend(vec![1u8; 16]);
+
+        let mut s = Squeezer::new(true, LSIZE);
+        // just initialized
+        assert_eq!(s.action(), SqueezeAction::Ignore);
+        s.advance();
+
+        let exp = vec![
+            SqueezeAction::Ignore, // first line, print as is
+            SqueezeAction::Print,  // print squeeze symbol
+            SqueezeAction::Ignore, // different lines, print again
+        ];
+
+        let mut idx = 1;
+        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
+            for i in z {
+                s.process(*i, idx);
+                idx += 1;
+            }
+            let action = s.action();
+            s.advance();
+            assert_eq!(action, exp[line]);
+        }
+    }
+
+    #[test]
+    /// First line all eq, 2nd half eq with first line, then change
+    fn second_line_different() {
+        const LINES: usize = 2;
+        let mut v = vec![0u8; (LINES - 1) * LSIZE_USIZE];
+        v.extend(vec![0u8; 8]);
+        v.extend(vec![1u8; 8]);
+
+        let mut s = Squeezer::new(true, LSIZE);
+        // just initialized
+        assert_eq!(s.action(), SqueezeAction::Ignore);
+        s.advance();
+
+        let exp = vec![
+            SqueezeAction::Ignore, // first line, print as is
+            SqueezeAction::Ignore, // print squeeze symbol
+        ];
+
+        let mut idx = 1;
+        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
+            for i in z {
+                s.process(*i, idx);
+                idx += 1;
+            }
+            let action = s.action();
+            s.advance();
+            assert_eq!(action, exp[line]);
+        }
+    }
+
+    #[test]
+    /// all three lines never become squeeze candidate (diff within line)
+    fn never_squeeze_candidate() {
+        let mut v = vec![];
+        v.extend(vec![0u8; 8]);
+        v.extend(vec![1u8; 8]);
+        v.extend(vec![0u8; 8]);
+        v.extend(vec![1u8; 8]);
+        v.extend(vec![0u8; 8]);
+        v.extend(vec![1u8; 8]);
+
+        let mut s = Squeezer::new(true, LSIZE);
+        // just initialized
+        assert_eq!(s.action(), SqueezeAction::Ignore);
+        s.advance();
+
+        let exp = vec![
+            SqueezeAction::Ignore, // first line, print as is
+            SqueezeAction::Ignore, // print squeeze symbol
+            SqueezeAction::Ignore, // print squeeze symbol
+        ];
+
+        let mut idx = 1;
+        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
+            for i in z {
+                s.process(*i, idx);
+                idx += 1;
+            }
+            let action = s.action();
+            s.advance();
+            assert_eq!(action, exp[line]);
+        }
+    }
+
+    #[test]
+    fn mix_everything() {
+        let mut v = vec![];
+        v.extend(vec![10u8; 16]); // print
+        v.extend(vec![20u8; 16]); // print
+        v.extend(vec![0u8; 16]); // print
+        v.extend(vec![0u8; 16]); // *
+        v.extend(vec![10u8; 16]); // print
+        v.extend(vec![20u8; 16]); // print
+        v.extend(vec![0u8; 16]); // print
+        v.extend(vec![0u8; 16]); // *
+        v.extend(vec![0u8; 16]); // delete
+        v.extend(vec![0u8; 16]); // delete*
+        v.extend(vec![20u8; 16]); // print
+        v.extend(vec![0u8; 12]); // print, only 12 bytes
+
+        let mut s = Squeezer::new(true, LSIZE);
+        // just initialized
+        assert_eq!(s.action(), SqueezeAction::Ignore);
+        s.advance();
+
+        let exp = vec![
+            SqueezeAction::Ignore,
+            SqueezeAction::Ignore,
+            SqueezeAction::Ignore,
+            SqueezeAction::Print,
+            SqueezeAction::Ignore,
+            SqueezeAction::Ignore,
+            SqueezeAction::Ignore,
+            SqueezeAction::Print,
+            SqueezeAction::Delete,
+            SqueezeAction::Delete,
+            SqueezeAction::Ignore,
+            SqueezeAction::Ignore,
+        ];
+
+        let mut idx = 1;
+        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
+            for i in z {
+                s.process(*i, idx);
+                idx += 1;
+            }
+            let action = s.action();
+            s.advance();
+            assert_eq!(action, exp[line]);
+        }
+    }
+
+    #[test]
+    fn last_char_diff() {
+        // see issue #62
+        let mut v = vec![];
+        v.extend(vec![20u8; 16]);
+        v.extend(vec![20u8; 15]);
+        v.push(61);
+        v.extend(vec![20u8; 16]);
+        v.extend(vec![20u8; 16]);
+
+        let mut s = Squeezer::new(true, LSIZE);
+        // just initialized
+        assert_eq!(s.action(), SqueezeAction::Ignore);
+        s.advance();
+
+        let exp = vec![
+            SqueezeAction::Ignore, // print as is
+            SqueezeAction::Ignore, // print as is
+            SqueezeAction::Ignore, // print as is
+            SqueezeAction::Print,  // print '*' char
+        ];
+
+        let mut idx = 1;
+        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
+            for i in z {
+                s.process(*i, idx);
+                idx += 1;
+            }
+            assert_eq!(s.action(), exp[line]);
+            s.advance();
+        }
+    }
+
+    #[test]
+    fn first_char_diff() {
+        // see issue #62
+        let mut v = vec![];
+        v.extend(vec![20u8; 16]);
+        v.push(61);
+        v.extend(vec![20u8; 15]);
+        v.extend(vec![20u8; 16]);
+
+        let mut s = Squeezer::new(true, LSIZE);
+        // just initialized
+        assert_eq!(s.action(), SqueezeAction::Ignore);
+        s.advance();
+
+        let exp = vec![
+            SqueezeAction::Ignore, // print as is
+            SqueezeAction::Ignore, // print as is
+            SqueezeAction::Ignore, // print as is
+        ];
+
+        let mut idx = 1;
+        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
+            for i in z {
+                s.process(*i, idx);
+                idx += 1;
+            }
+            assert_eq!(s.action(), exp[line]);
+            s.advance();
+        }
+    }
+}
@@ -1,156 +0,0 @@
-use super::*;
-
-#[test]
-fn unit_multipliers() {
-    use Unit::*;
-    assert_eq!(Kilobyte.get_multiplier(), 1000 * Byte.get_multiplier());
-    assert_eq!(Megabyte.get_multiplier(), 1000 * Kilobyte.get_multiplier());
-    assert_eq!(Gigabyte.get_multiplier(), 1000 * Megabyte.get_multiplier());
-    assert_eq!(Terabyte.get_multiplier(), 1000 * Gigabyte.get_multiplier());
-
-    assert_eq!(Kibibyte.get_multiplier(), 1024 * Byte.get_multiplier());
-    assert_eq!(Mebibyte.get_multiplier(), 1024 * Kibibyte.get_multiplier());
-    assert_eq!(Gibibyte.get_multiplier(), 1024 * Mebibyte.get_multiplier());
-    assert_eq!(Tebibyte.get_multiplier(), 1024 * Gibibyte.get_multiplier());
-}
-
-#[test]
-fn test_process_sign() {
-    use ByteOffsetKind::*;
-    use ByteOffsetParseError::*;
-    assert_eq!(process_sign_of("123"), Ok(("123", ForwardFromBeginning)));
-    assert_eq!(process_sign_of("+123"), Ok(("123", ForwardFromLastOffset)));
-    assert_eq!(process_sign_of("-123"), Ok(("123", BackwardFromEnd)));
-    assert_eq!(process_sign_of("-"), Err(EmptyAfterSign));
-    assert_eq!(process_sign_of("+"), Err(EmptyAfterSign));
-    assert_eq!(process_sign_of(""), Err(Empty));
-}
-
-#[test]
-fn test_parse_as_hex() {
-    assert_eq!(try_parse_as_hex_number("73"), None);
-    assert_eq!(try_parse_as_hex_number("0x1337"), Some(Ok(0x1337)));
-    assert!(matches!(try_parse_as_hex_number("0xnope"), Some(Err(_))));
-    assert!(matches!(try_parse_as_hex_number("0x-1"), Some(Err(_))));
-}
-
-#[test]
-fn extract_num_and_unit() {
-    use ByteOffsetParseError::*;
-    use Unit::*;
-    // byte is default unit
-    assert_eq!(extract_num_and_unit_from("4"), Ok((4, Byte)));
-    // blocks are returned without customization
-    assert_eq!(
-        extract_num_and_unit_from("2blocks"),
-        Ok((2, Block { custom_size: None }))
-    );
-    // no normalization is performed
-    assert_eq!(extract_num_and_unit_from("1024kb"), Ok((1024, Kilobyte)));
-
-    // unit without number results in error
-    assert_eq!(
-        extract_num_and_unit_from("gib"),
-        Err(EmptyWithUnit("gib".to_string()))
-    );
-    // empty string results in error
-    assert_eq!(extract_num_and_unit_from(""), Err(Empty));
-    // an invalid unit results in an error
-    assert_eq!(
-        extract_num_and_unit_from("25litres"),
-        Err(InvalidUnit("litres".to_string()))
-    );
-}
-
-#[test]
-fn test_parse_byte_offset() {
-    use ByteOffsetParseError::*;
-
-    macro_rules! success {
-        ($input: expr, $expected_kind: ident $expected_value: expr) => {
-            success!($input, $expected_kind $expected_value; block_size: DEFAULT_BLOCK_SIZE)
-        };
-        ($input: expr, $expected_kind: ident $expected_value: expr; block_size: $block_size: expr) => {
-            assert_eq!(
-                parse_byte_offset($input, PositiveI64::new($block_size).unwrap()),
-                Ok(
-                    ByteOffset {
-                        value: NonNegativeI64::new($expected_value).unwrap(),
-                        kind: ByteOffsetKind::$expected_kind,
-                    }
-                ),
-            );
-        };
-    }
-
-    macro_rules! error {
-        ($input: expr, $expected_err: expr) => {
-            assert_eq!(
-                parse_byte_offset($input, PositiveI64::new(DEFAULT_BLOCK_SIZE).unwrap()),
-                Err($expected_err),
-            );
-        };
-    }
-
-    success!("0", ForwardFromBeginning 0);
-    success!("1", ForwardFromBeginning 1);
-    success!("1", ForwardFromBeginning 1);
-    success!("100", ForwardFromBeginning 100);
-    success!("+100", ForwardFromLastOffset 100);
-
-    success!("0x0", ForwardFromBeginning 0);
-    success!("0xf", ForwardFromBeginning 15);
-    success!("0xdeadbeef", ForwardFromBeginning 3_735_928_559);
-
-    success!("1KB", ForwardFromBeginning 1000);
-    success!("2MB", ForwardFromBeginning 2000000);
-    success!("3GB", ForwardFromBeginning 3000000000);
-    success!("4TB", ForwardFromBeginning 4000000000000);
-    success!("+4TB", ForwardFromLastOffset 4000000000000);
-
-    success!("1GiB", ForwardFromBeginning 1073741824);
-    success!("2TiB", ForwardFromBeginning 2199023255552);
-    success!("+2TiB", ForwardFromLastOffset 2199023255552);
-
-    success!("0xff", ForwardFromBeginning 255);
-    success!("0xEE", ForwardFromBeginning 238);
-    success!("+0xFF", ForwardFromLastOffset 255);
-
-    success!("1block", ForwardFromBeginning 512; block_size: 512);
-    success!("2block", ForwardFromBeginning 1024; block_size: 512);
-    success!("1block", ForwardFromBeginning 4; block_size: 4);
-    success!("2block", ForwardFromBeginning 8; block_size: 4);
-
-    // empty string is invalid
-    error!("", Empty);
-    // These are also bad.
-    error!("+", EmptyAfterSign);
-    error!("-", EmptyAfterSign);
-    error!("K", InvalidNumAndUnit("K".to_owned()));
-    error!("k", InvalidNumAndUnit("k".to_owned()));
-    error!("m", InvalidNumAndUnit("m".to_owned()));
-    error!("block", EmptyWithUnit("block".to_owned()));
-    // leading/trailing space is invalid
-    error!(" 0", InvalidNumAndUnit(" 0".to_owned()));
-    error!("0 ", InvalidUnit(" ".to_owned()));
-    // Signs after the hex prefix make no sense
-    error!("0x-12", SignFoundAfterHexPrefix('-'));
-    // This was previously accepted but shouldn't be.
-    error!("0x+12", SignFoundAfterHexPrefix('+'));
-    // invalid suffix
-    error!("1234asdf", InvalidUnit("asdf".to_owned()));
-    // bad numbers
-    error!("asdf1234", InvalidNumAndUnit("asdf1234".to_owned()));
-    error!("a1s2d3f4", InvalidNumAndUnit("a1s2d3f4".to_owned()));
-    // multiplication overflows u64
-    error!("20000000TiB", UnitMultiplicationOverflow);
-
-    assert!(
-        match parse_byte_offset("99999999999999999999", PositiveI64::new(512).unwrap()) {
-            // We can't check against the kind of the `ParseIntError`, so we'll just make sure it's the
-            // same as trying to do the parse directly.
-            Err(ParseNum(e)) => e == "99999999999999999999".parse::<i64>().unwrap_err(),
-            _ => false,
-        }
-    );
-}
@@ -5,26 +5,6 @@ fn hexyl() -> Command {
    cmd.current_dir("tests/examples");
    cmd
 }
-trait PrettyAssert<S>
-where
-    S: AsRef<str>,
-{
-    fn pretty_stdout(self, other: S);
-}
-
-// https://github.com/assert-rs/assert_cmd/issues/121#issuecomment-849937376
-//
-impl<S> PrettyAssert<S> for assert_cmd::assert::Assert
-where
-    S: AsRef<str>,
-{
-    fn pretty_stdout(self, other: S) {
-        println!("{}", other.as_ref().len());
-        let self_str = String::from_utf8(self.get_output().stdout.clone()).unwrap();
-        println!("{}", self_str.len());
-        pretty_assertions::assert_eq!(self_str, other.as_ref());
-    }
-}

 mod basic {
    use super::hexyl;
@@ -71,7 +51,7 @@ mod basic {
        .success()
        .stdout(
            "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-             │        │ No content              │                         │        │        │\n\
+             │        │ No content to print     │                         │        │        │\n\
             └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n",
        );
    }
@@ -90,8 +70,8 @@ mod length {
        .success()
        .stdout(
            "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-             │00000000│ 7f 45 4c 46 02 01 01 00 ┊ 00 00 00 00 00 00 00 00 │•ELF•••⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│\n\
-             │00000010│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │•⋄>⋄•⋄⋄⋄┊⋄•@⋄⋄⋄⋄⋄│\n\
+             │00000000│ 7f 45 4c 46 02 01 01 00 ┊ 00 00 00 00 00 00 00 00 │•ELF•••0┊00000000│\n\
+             │00000010│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │•0>0•000┊0•@00000│\n\
             └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n",
        );
    }
@@ -160,7 +140,7 @@ mod skip {
        .success()
        .stdout(
            "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-             │        │ No content              │                         │        │        │\n\
+             │        │ No content to print     │                         │        │        │\n\
             └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n",
        );
    }
@@ -223,7 +203,7 @@ mod display_offset {
        .success()
        .stdout(
            "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-             │00000030│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │•⋄>⋄•⋄⋄⋄┊⋄•@⋄⋄⋄⋄⋄│\n\
+             │00000030│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │•0>0•000┊0•@00000│\n\
             └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n",
        );
    }
@@ -291,674 +271,3 @@ mod display_settings {
            );
    }
 }
-
-mod group_and_endianness {
-    use super::hexyl;
-    use super::PrettyAssert;
-
-    #[test]
-    fn group_2_bytes_be() {
-        hexyl()
-            .arg("ascii")
-            .arg("--color=never")
-            .arg("--group-size=2")
-            .assert()
-            .success()
-            .stdout(
-                "┌────────┬─────────────────────┬─────────────────────┬────────┬────────┐\n\
-                 │00000000│ 3031 3233 3435 3637 ┊ 3839 6162 6364 650a │01234567┊89abcde_│\n\
-                 └────────┴─────────────────────┴─────────────────────┴────────┴────────┘\n",
-            );
-    }
-
-    #[test]
-    fn group_2_bytes_le() {
-        hexyl()
-            .arg("ascii")
-            .arg("--color=never")
-            .arg("--group-size=2")
-            .arg("--endianness=little")
-            .assert()
-            .success()
-            .stdout(
-                "┌────────┬─────────────────────┬─────────────────────┬────────┬────────┐\n\
-                 │00000000│ 3130 3332 3534 3736 ┊ 3938 6261 6463 0a65 │01234567┊89abcde_│\n\
-                 └────────┴─────────────────────┴─────────────────────┴────────┴────────┘\n",
-            );
-    }
-
-    #[test]
-    fn group_4_bytes_be() {
-        hexyl()
-            .arg("ascii")
-            .arg("--color=never")
-            .arg("--group-size=4")
-            .assert()
-            .success()
-            .stdout(
-                "┌────────┬───────────────────┬───────────────────┬────────┬────────┐\n\
-                 │00000000│ 30313233 34353637 ┊ 38396162 6364650a │01234567┊89abcde_│\n\
-                 └────────┴───────────────────┴───────────────────┴────────┴────────┘\n",
-            );
-    }
-
-    #[test]
-    fn group_4_bytes_le() {
-        hexyl()
-            .arg("ascii")
-            .arg("--color=never")
-            .arg("--group-size=4")
-            .arg("--endianness=little")
-            .assert()
-            .success()
-            .stdout(
-                "┌────────┬───────────────────┬───────────────────┬────────┬────────┐\n\
-                 │00000000│ 33323130 37363534 ┊ 62613938 0a656463 │01234567┊89abcde_│\n\
-                 └────────┴───────────────────┴───────────────────┴────────┴────────┘\n",
-            );
-    }
-
-    #[test]
-    fn group_8_bytes_be() {
-        hexyl()
-            .arg("ascii")
-            .arg("--color=never")
-            .arg("--group-size=8")
-            .assert()
-            .success()
-            .stdout(
-                "┌────────┬──────────────────┬──────────────────┬────────┬────────┐\n\
-                 │00000000│ 3031323334353637 ┊ 383961626364650a │01234567┊89abcde_│\n\
-                 └────────┴──────────────────┴──────────────────┴────────┴────────┘\n",
-            );
-    }
-
-    #[test]
-    fn group_8_bytes_le() {
-        hexyl()
-            .arg("ascii")
-            .arg("--color=never")
-            .arg("--group-size=8")
-            .arg("--endianness=little")
-            .assert()
-            .success()
-            .stdout(
-                "┌────────┬──────────────────┬──────────────────┬────────┬────────┐\n\
-                 │00000000│ 3736353433323130 ┊ 0a65646362613938 │01234567┊89abcde_│\n\
-                 └────────┴──────────────────┴──────────────────┴────────┴────────┘\n",
-            );
-    }
-
-    #[test]
-    fn group_size_plain() {
-        hexyl()
-            .arg("ascii")
-            .arg("--color=never")
-            .arg("--plain")
-            .arg("--group-size=2")
-            .assert()
-            .success()
-            .stdout("  3031 3233 3435 3637   3839 6162 6364 650a  \n");
-    }
-
-    #[test]
-    fn group_size_fill_space() {
-        hexyl()
-            .arg("--color=never")
-            .arg("--group-size=2")
-            .write_stdin("abc")
-            .assert()
-            .success()
-            .stdout(
-                "┌────────┬─────────────────────┬─────────────────────┬────────┬────────┐\n\
-                 │00000000│ 6162 63             ┊                     │abc     ┊        │\n\
-                 └────────┴─────────────────────┴─────────────────────┴────────┴────────┘\n",
-            );
-    }
-
-    #[test]
-    fn group_size_invalid() {
-        hexyl()
-            .arg("ascii")
-            .arg("--color=never")
-            .arg("--plain")
-            .arg("--group-size=3")
-            .assert()
-            .failure();
-    }
-    #[test]
-    fn squeeze_no_chars() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--skip=1024")
-            .arg("--length=4096")
-            .arg("--no-characters")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "\
-┌────────┬─────────────────────────┬─────────────────────────┐
-│00000400│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │
-│*       │                         ┊                         │
-│00001000│ ba 0e 00 00 00 b9 00 20 ┊ 40 00 bb 01 00 00 00 b8 │
-│00001010│ 04 00 00 00 cd 80 b8 01 ┊ 00 00 00 cd 80 00 00 00 │
-│00001020│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │
-│*       │                         ┊                         │
-│00001400│                         ┊                         │
-└────────┴─────────────────────────┴─────────────────────────┘
-",
-            );
-    }
-    #[test]
-    fn squeeze_no_chars_one_panel() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--skip=1024")
-            .arg("--length=4096")
-            .arg("--no-characters")
-            .arg("--panels=1")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "\
-┌────────┬─────────────────────────┐
-│00000400│ 00 00 00 00 00 00 00 00 │
-│*       │                         │
-│00001000│ ba 0e 00 00 00 b9 00 20 │
-│00001008│ 40 00 bb 01 00 00 00 b8 │
-│00001010│ 04 00 00 00 cd 80 b8 01 │
-│00001018│ 00 00 00 cd 80 00 00 00 │
-│00001020│ 00 00 00 00 00 00 00 00 │
-│*       │                         │
-│00001400│                         │
-└────────┴─────────────────────────┘
-",
-            );
-    }
-    #[test]
-    fn squeeze_no_position() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--skip=1024")
-            .arg("--length=4096")
-            .arg("--no-position")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "\
-┌─────────────────────────┬─────────────────────────┬────────┬────────┐
-│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│*                        ┊                         │        ┊        │
-│ ba 0e 00 00 00 b9 00 20 ┊ 40 00 bb 01 00 00 00 b8 │×•⋄⋄⋄×⋄ ┊@⋄×•⋄⋄⋄×│
-│ 04 00 00 00 cd 80 b8 01 ┊ 00 00 00 cd 80 00 00 00 │•⋄⋄⋄×××•┊⋄⋄⋄××⋄⋄⋄│
-│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│*                        ┊                         │        ┊        │
-│*                        ┊                         │        ┊        │
-└─────────────────────────┴─────────────────────────┴────────┴────────┘
-",
-            );
-    }
-    #[test]
-    fn squeeze_no_position_one_panel() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--skip=1024")
-            .arg("--length=4096")
-            .arg("--no-position")
-            .arg("--panels=1")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "\
-┌─────────────────────────┬────────┐
-│ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄│
-│*                        │        │
-│ ba 0e 00 00 00 b9 00 20 │×•⋄⋄⋄×⋄ │
-│ 40 00 bb 01 00 00 00 b8 │@⋄×•⋄⋄⋄×│
-│ 04 00 00 00 cd 80 b8 01 │•⋄⋄⋄×××•│
-│ 00 00 00 cd 80 00 00 00 │⋄⋄⋄××⋄⋄⋄│
-│ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄│
-│*                        │        │
-│*                        │        │
-└─────────────────────────┴────────┘
-",
-            );
-    }
-    #[test]
-    fn squeeze_odd_panels_remainder_bytes() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--skip=1024")
-            .arg("--length=4092") // 4 byte remainder
-            .arg("--panels=3")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "\
-┌────────┬─────────────────────────┬─────────────────────────┬─────────────────────────┬────────┬────────┬────────┐
-│00000400│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│*       │                         ┊                         ┊                         │        ┊        ┊        │
-│00001000│ ba 0e 00 00 00 b9 00 20 ┊ 40 00 bb 01 00 00 00 b8 ┊ 04 00 00 00 cd 80 b8 01 │×•⋄⋄⋄×⋄ ┊@⋄×•⋄⋄⋄×┊•⋄⋄⋄×××•│
-│00001018│ 00 00 00 cd 80 00 00 00 ┊ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄××⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│00001030│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│*       │                         ┊                         ┊                         │        ┊        ┊        │
-│000013f0│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00             ┊                         │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄    ┊        │
-└────────┴─────────────────────────┴─────────────────────────┴─────────────────────────┴────────┴────────┴────────┘
-",
-            );
-    }
-
-    #[test]
-    fn squeeze_plain() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--skip=1024")
-            .arg("--length=4096")
-            .arg("--plain")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "  \
-  00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00  
- *                                                   
-  ba 0e 00 00 00 b9 00 20   40 00 bb 01 00 00 00 b8  
-  04 00 00 00 cd 80 b8 01   00 00 00 cd 80 00 00 00  
-  00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00  
- *                                                   
- *                                                   
-",
-            );
-    }
-
-    #[test]
-    fn squeeze_plain_remainder() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--skip=1024")
-            .arg("--length=4092") // 4 byte remainder
-            .arg("--plain")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "  \
-  00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00  
- *                                                   
-  ba 0e 00 00 00 b9 00 20   40 00 bb 01 00 00 00 b8  
-  04 00 00 00 cd 80 b8 01   00 00 00 cd 80 00 00 00  
-  00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00  
- *                                                   
-  00 00 00 00 00 00 00 00   00 00 00 00              
-",
-            );
-    }
-}
-
-mod base {
-    use super::hexyl;
-    use super::PrettyAssert;
-
-    #[test]
-    fn base2() {
-        hexyl()
-            .arg("ascii")
-            .arg("--plain")
-            .arg("--base=binary")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "  00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111  \n  \
-                   00111000 00111001 01100001 01100010 01100011 01100100 01100101 00001010  \n",
-            );
-    }
-}
-
-mod character_table {
-    use super::hexyl;
-    use super::PrettyAssert;
-
-    #[test]
-    fn ascii() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--character-table=ascii")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
-│00000000│ 7f 45 4c 46 02 01 01 00 ┊ 00 00 00 00 00 00 00 00 │.ELF....┊........│
-│00000010│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │..>.....┊..@.....│
-│00000020│ 40 00 00 00 00 00 00 00 ┊ 28 20 00 00 00 00 00 00 │@.......┊( ......│
-│00000030│ 00 00 00 00 40 00 38 00 ┊ 03 00 40 00 04 00 03 00 │....@.8.┊..@.....│
-│00000040│ 01 00 00 00 04 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│00000050│ 00 00 40 00 00 00 00 00 ┊ 00 00 40 00 00 00 00 00 │..@.....┊..@.....│
-│00000060│ e8 00 00 00 00 00 00 00 ┊ e8 00 00 00 00 00 00 00 │........┊........│
-│00000070│ 00 10 00 00 00 00 00 00 ┊ 01 00 00 00 05 00 00 00 │........┊........│
-│00000080│ 00 10 00 00 00 00 00 00 ┊ 00 10 40 00 00 00 00 00 │........┊..@.....│
-│00000090│ 00 10 40 00 00 00 00 00 ┊ 1d 00 00 00 00 00 00 00 │..@.....┊........│
-│000000a0│ 1d 00 00 00 00 00 00 00 ┊ 00 10 00 00 00 00 00 00 │........┊........│
-│000000b0│ 01 00 00 00 06 00 00 00 ┊ 00 20 00 00 00 00 00 00 │........┊. ......│
-│000000c0│ 00 20 40 00 00 00 00 00 ┊ 00 20 40 00 00 00 00 00 │. @.....┊. @.....│
-│000000d0│ 0e 00 00 00 00 00 00 00 ┊ 0e 00 00 00 00 00 00 00 │........┊........│
-│000000e0│ 00 10 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│000000f0│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│*       │                         ┊                         │        ┊        │
-│00001000│ ba 0e 00 00 00 b9 00 20 ┊ 40 00 bb 01 00 00 00 b8 │....... ┊@.......│
-│00001010│ 04 00 00 00 cd 80 b8 01 ┊ 00 00 00 cd 80 00 00 00 │........┊........│
-│00001020│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│*       │                         ┊                         │        ┊        │
-│00002000│ 48 65 6c 6c 6f 2c 20 77 ┊ 6f 72 6c 64 21 0a 00 2e │Hello, w┊orld!...│
-│00002010│ 73 68 73 74 72 74 61 62 ┊ 00 2e 74 65 78 74 00 2e │shstrtab┊..text..│
-│00002020│ 64 61 74 61 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │data....┊........│
-│00002030│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│*       │                         ┊                         │        ┊        │
-│00002060│ 00 00 00 00 00 00 00 00 ┊ 0b 00 00 00 01 00 00 00 │........┊........│
-│00002070│ 06 00 00 00 00 00 00 00 ┊ 00 10 40 00 00 00 00 00 │........┊..@.....│
-│00002080│ 00 10 00 00 00 00 00 00 ┊ 1d 00 00 00 00 00 00 00 │........┊........│
-│00002090│ 00 00 00 00 00 00 00 00 ┊ 10 00 00 00 00 00 00 00 │........┊........│
-│000020a0│ 00 00 00 00 00 00 00 00 ┊ 11 00 00 00 01 00 00 00 │........┊........│
-│000020b0│ 03 00 00 00 00 00 00 00 ┊ 00 20 40 00 00 00 00 00 │........┊. @.....│
-│000020c0│ 00 20 00 00 00 00 00 00 ┊ 0e 00 00 00 00 00 00 00 │. ......┊........│
-│000020d0│ 00 00 00 00 00 00 00 00 ┊ 04 00 00 00 00 00 00 00 │........┊........│
-│000020e0│ 00 00 00 00 00 00 00 00 ┊ 01 00 00 00 03 00 00 00 │........┊........│
-│000020f0│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│00002100│ 0e 20 00 00 00 00 00 00 ┊ 17 00 00 00 00 00 00 00 │. ......┊........│
-│00002110│ 00 00 00 00 00 00 00 00 ┊ 01 00 00 00 00 00 00 00 │........┊........│
-│00002120│ 00 00 00 00 00 00 00 00 ┊                         │........┊        │
-└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘
-",
-            );
-    }
-
-    #[test]
-    fn codepage_437() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--character-table=codepage-437")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
-│00000000│ 7f 45 4c 46 02 01 01 00 ┊ 00 00 00 00 00 00 00 00 │⌂ELF☻☺☺⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│00000010│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │☻⋄>⋄☺⋄⋄⋄┊⋄►@⋄⋄⋄⋄⋄│
-│00000020│ 40 00 00 00 00 00 00 00 ┊ 28 20 00 00 00 00 00 00 │@⋄⋄⋄⋄⋄⋄⋄┊( ⋄⋄⋄⋄⋄⋄│
-│00000030│ 00 00 00 00 40 00 38 00 ┊ 03 00 40 00 04 00 03 00 │⋄⋄⋄⋄@⋄8⋄┊♥⋄@⋄♦⋄♥⋄│
-│00000040│ 01 00 00 00 04 00 00 00 ┊ 00 00 00 00 00 00 00 00 │☺⋄⋄⋄♦⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│00000050│ 00 00 40 00 00 00 00 00 ┊ 00 00 40 00 00 00 00 00 │⋄⋄@⋄⋄⋄⋄⋄┊⋄⋄@⋄⋄⋄⋄⋄│
-│00000060│ e8 00 00 00 00 00 00 00 ┊ e8 00 00 00 00 00 00 00 │Φ⋄⋄⋄⋄⋄⋄⋄┊Φ⋄⋄⋄⋄⋄⋄⋄│
-│00000070│ 00 10 00 00 00 00 00 00 ┊ 01 00 00 00 05 00 00 00 │⋄►⋄⋄⋄⋄⋄⋄┊☺⋄⋄⋄♣⋄⋄⋄│
-│00000080│ 00 10 00 00 00 00 00 00 ┊ 00 10 40 00 00 00 00 00 │⋄►⋄⋄⋄⋄⋄⋄┊⋄►@⋄⋄⋄⋄⋄│
-│00000090│ 00 10 40 00 00 00 00 00 ┊ 1d 00 00 00 00 00 00 00 │⋄►@⋄⋄⋄⋄⋄┊↔⋄⋄⋄⋄⋄⋄⋄│
-│000000a0│ 1d 00 00 00 00 00 00 00 ┊ 00 10 00 00 00 00 00 00 │↔⋄⋄⋄⋄⋄⋄⋄┊⋄►⋄⋄⋄⋄⋄⋄│
-│000000b0│ 01 00 00 00 06 00 00 00 ┊ 00 20 00 00 00 00 00 00 │☺⋄⋄⋄♠⋄⋄⋄┊⋄ ⋄⋄⋄⋄⋄⋄│
-│000000c0│ 00 20 40 00 00 00 00 00 ┊ 00 20 40 00 00 00 00 00 │⋄ @⋄⋄⋄⋄⋄┊⋄ @⋄⋄⋄⋄⋄│
-│000000d0│ 0e 00 00 00 00 00 00 00 ┊ 0e 00 00 00 00 00 00 00 │♫⋄⋄⋄⋄⋄⋄⋄┊♫⋄⋄⋄⋄⋄⋄⋄│
-│000000e0│ 00 10 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄►⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│000000f0│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│*       │                         ┊                         │        ┊        │
-│00001000│ ba 0e 00 00 00 b9 00 20 ┊ 40 00 bb 01 00 00 00 b8 │║♫⋄⋄⋄╣⋄ ┊@⋄╗☺⋄⋄⋄╕│
-│00001010│ 04 00 00 00 cd 80 b8 01 ┊ 00 00 00 cd 80 00 00 00 │♦⋄⋄⋄═Ç╕☺┊⋄⋄⋄═Ç⋄⋄⋄│
-│00001020│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│*       │                         ┊                         │        ┊        │
-│00002000│ 48 65 6c 6c 6f 2c 20 77 ┊ 6f 72 6c 64 21 0a 00 2e │Hello, w┊orld!◙⋄.│
-│00002010│ 73 68 73 74 72 74 61 62 ┊ 00 2e 74 65 78 74 00 2e │shstrtab┊⋄.text⋄.│
-│00002020│ 64 61 74 61 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │data⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│00002030│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│*       │                         ┊                         │        ┊        │
-│00002060│ 00 00 00 00 00 00 00 00 ┊ 0b 00 00 00 01 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊♂⋄⋄⋄☺⋄⋄⋄│
-│00002070│ 06 00 00 00 00 00 00 00 ┊ 00 10 40 00 00 00 00 00 │♠⋄⋄⋄⋄⋄⋄⋄┊⋄►@⋄⋄⋄⋄⋄│
-│00002080│ 00 10 00 00 00 00 00 00 ┊ 1d 00 00 00 00 00 00 00 │⋄►⋄⋄⋄⋄⋄⋄┊↔⋄⋄⋄⋄⋄⋄⋄│
-│00002090│ 00 00 00 00 00 00 00 00 ┊ 10 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊►⋄⋄⋄⋄⋄⋄⋄│
-│000020a0│ 00 00 00 00 00 00 00 00 ┊ 11 00 00 00 01 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊◄⋄⋄⋄☺⋄⋄⋄│
-│000020b0│ 03 00 00 00 00 00 00 00 ┊ 00 20 40 00 00 00 00 00 │♥⋄⋄⋄⋄⋄⋄⋄┊⋄ @⋄⋄⋄⋄⋄│
-│000020c0│ 00 20 00 00 00 00 00 00 ┊ 0e 00 00 00 00 00 00 00 │⋄ ⋄⋄⋄⋄⋄⋄┊♫⋄⋄⋄⋄⋄⋄⋄│
-│000020d0│ 00 00 00 00 00 00 00 00 ┊ 04 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊♦⋄⋄⋄⋄⋄⋄⋄│
-│000020e0│ 00 00 00 00 00 00 00 00 ┊ 01 00 00 00 03 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊☺⋄⋄⋄♥⋄⋄⋄│
-│000020f0│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
-│00002100│ 0e 20 00 00 00 00 00 00 ┊ 17 00 00 00 00 00 00 00 │♫ ⋄⋄⋄⋄⋄⋄┊↨⋄⋄⋄⋄⋄⋄⋄│
-│00002110│ 00 00 00 00 00 00 00 00 ┊ 01 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊☺⋄⋄⋄⋄⋄⋄⋄│
-│00002120│ 00 00 00 00 00 00 00 00 ┊                         │⋄⋄⋄⋄⋄⋄⋄⋄┊        │
-└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘
-",
-            );
-    }
-
-    #[test]
-    fn codepage_1047() {
-        hexyl()
-            .arg("hello_world_elf64")
-            .arg("--color=never")
-            .arg("--character-table=codepage-1047")
-            .assert()
-            .success()
-            .pretty_stdout(
-                "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
-│00000000│ 7f 45 4c 46 02 01 01 00 ┊ 00 00 00 00 00 00 00 00 │..<.....┊........│
-│00000010│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │........┊.. .....│
-│00000020│ 40 00 00 00 00 00 00 00 ┊ 28 20 00 00 00 00 00 00 │ .......┊........│
-│00000030│ 00 00 00 00 40 00 38 00 ┊ 03 00 40 00 04 00 03 00 │.... ...┊.. .....│
-│00000040│ 01 00 00 00 04 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│00000050│ 00 00 40 00 00 00 00 00 ┊ 00 00 40 00 00 00 00 00 │.. .....┊.. .....│
-│00000060│ e8 00 00 00 00 00 00 00 ┊ e8 00 00 00 00 00 00 00 │Y.......┊Y.......│
-│00000070│ 00 10 00 00 00 00 00 00 ┊ 01 00 00 00 05 00 00 00 │........┊........│
-│00000080│ 00 10 00 00 00 00 00 00 ┊ 00 10 40 00 00 00 00 00 │........┊.. .....│
-│00000090│ 00 10 40 00 00 00 00 00 ┊ 1d 00 00 00 00 00 00 00 │.. .....┊........│
-│000000a0│ 1d 00 00 00 00 00 00 00 ┊ 00 10 00 00 00 00 00 00 │........┊........│
-│000000b0│ 01 00 00 00 06 00 00 00 ┊ 00 20 00 00 00 00 00 00 │........┊........│
-│000000c0│ 00 20 40 00 00 00 00 00 ┊ 00 20 40 00 00 00 00 00 │.. .....┊.. .....│
-│000000d0│ 0e 00 00 00 00 00 00 00 ┊ 0e 00 00 00 00 00 00 00 │........┊........│
-│000000e0│ 00 10 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│000000f0│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│*       │                         ┊                         │        ┊        │
-│00001000│ ba 0e 00 00 00 b9 00 20 ┊ 40 00 bb 01 00 00 00 b8 │[.......┊ .].....│
-│00001010│ 04 00 00 00 cd 80 b8 01 ┊ 00 00 00 cd 80 00 00 00 │........┊........│
-│00001020│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│*       │                         ┊                         │        ┊        │
-│00002000│ 48 65 6c 6c 6f 2c 20 77 ┊ 6f 72 6c 64 21 0a 00 2e │..%%?...┊?.%.....│
-│00002010│ 73 68 73 74 72 74 61 62 ┊ 00 2e 74 65 78 74 00 2e │....../.┊........│
-│00002020│ 64 61 74 61 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │././....┊........│
-│00002030│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│*       │                         ┊                         │        ┊        │
-│00002060│ 00 00 00 00 00 00 00 00 ┊ 0b 00 00 00 01 00 00 00 │........┊........│
-│00002070│ 06 00 00 00 00 00 00 00 ┊ 00 10 40 00 00 00 00 00 │........┊.. .....│
-│00002080│ 00 10 00 00 00 00 00 00 ┊ 1d 00 00 00 00 00 00 00 │........┊........│
-│00002090│ 00 00 00 00 00 00 00 00 ┊ 10 00 00 00 00 00 00 00 │........┊........│
-│000020a0│ 00 00 00 00 00 00 00 00 ┊ 11 00 00 00 01 00 00 00 │........┊........│
-│000020b0│ 03 00 00 00 00 00 00 00 ┊ 00 20 40 00 00 00 00 00 │........┊.. .....│
-│000020c0│ 00 20 00 00 00 00 00 00 ┊ 0e 00 00 00 00 00 00 00 │........┊........│
-│000020d0│ 00 00 00 00 00 00 00 00 ┊ 04 00 00 00 00 00 00 00 │........┊........│
-│000020e0│ 00 00 00 00 00 00 00 00 ┊ 01 00 00 00 03 00 00 00 │........┊........│
-│000020f0│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │........┊........│
-│00002100│ 0e 20 00 00 00 00 00 00 ┊ 17 00 00 00 00 00 00 00 │........┊........│
-│00002110│ 00 00 00 00 00 00 00 00 ┊ 01 00 00 00 00 00 00 00 │........┊........│
-│00002120│ 00 00 00 00 00 00 00 00 ┊                         │........┊        │
-└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘
-",
-            );
-    }
-}
-
-mod colors {
-    use super::hexyl;
-    use owo_colors::{colors, Color};
-    use std::collections::HashMap;
-
-    // This is a helper for testing color in output. Writing tests to expect
-    // raw color codes is ugly and hard to look at. Loading expected output
-    // from files works fine, but you end up with a lot of files for all the
-    // tests, and you have to cross-reference the file with the test that uses
-    // it. The files also suffer from the same problem of being hard to
-    // visually inspect. Just catting the file to see the colorized output
-    // loses the nuance of where exactly the color codes appear (before or
-    // after spaces, for example), or whether there are redundant codes.
-    //
-    // So this ColorMap solves the problem neatly by having two inputs:
-    // - the easy to read expected output in plain format without any colors
-    // - a mapping with identical structure except some characters replaced
-    //   with single character color codes.
-    // This makes it easy to reference the output and expected colors side by
-    // side, and provides fairly precise control over exactly where color codes
-    // are expected (the only caveat being you can't have two color codes back
-    // to back). ColorMap combines these into the actual expected output.
-    //
-    // The color mapping needs to be identical to the expected output, except
-    // it has some chars replaced by color code stand ins. These are replaced
-    // with the actual color codes by the colorize method. The '.' character
-    // is also ignored (it doesn't need to match the input). This makes the
-    // color map more readable and avoids input characters from conflicting
-    // with color chars.
-    struct ColorMap {
-        text_map: &'static str,
-        char_to_color: HashMap<char, &'static str>,
-    }
-
-    impl ColorMap {
-        fn from(text_map: &'static str) -> Self {
-            ColorMap {
-                text_map,
-                char_to_color: HashMap::new(),
-            }
-        }
-
-        fn with<C: Color>(&mut self, c: char) -> &mut Self {
-            self.char_to_color.insert(c, C::ANSI_FG);
-            self
-        }
-
-        fn colorize(&self, input: &str) -> String {
-            let mut output = String::new();
-            let mut input_chars = input.chars();
-            for c in self.text_map.chars() {
-                let next_input = input_chars.next().expect("input and color map don't match");
-                if let Some(color) = self.char_to_color.get(&c) {
-                    output.push_str(color);
-                } else if c != '.' {
-                    // ignore '.' in the mapping for readability
-                    assert_eq!(c, next_input, "input and color map don't match");
-                }
-                output.push(next_input);
-            }
-            output
-        }
-    }
-
-    #[test]
-    fn hex_colors() {
-        let input = b"He\x11\0 \xff\0\xdd";
-        let expected_text = "\
-            ┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-            │00000000│ 48 65 11 00 20 ff 00 dd ┊                         │He•⋄ ×⋄×┊        │\n\
-            └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n";
-        let expected = ColorMap::from(
-            "\
-            ┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-            │r.......d y. .. b. c. g. m. c. m.d┊                        d│y.bcgmcmd        d\n\
-            └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n",
-        )
-        .with::<colors::Red>('r')
-        .with::<colors::Default>('d')
-        .with::<colors::Yellow>('y')
-        .with::<colors::Blue>('b')
-        .with::<colors::Green>('g')
-        .with::<colors::BrightMagenta>('m')
-        .with::<colors::CustomColor<0xab, 0xcd, 0xef>>('c')
-        .colorize(expected_text);
-
-        hexyl()
-            .write_stdin(input)
-            .arg("--color=always")
-            .env("HEXYL_COLOR_OFFSET", "red")
-            .env("HEXYL_COLOR_ASCII_PRINTABLE", "yellow")
-            .env("HEXYL_COLOR_ASCII_WHITESPACE", "green")
-            .env("HEXYL_COLOR_ASCII_OTHER", "blue")
-            .env("HEXYL_COLOR_NONASCII", "bright magenta")
-            .env("HEXYL_COLOR_NULL", "#abcdef")
-            .assert()
-            .success()
-            .stdout(expected);
-    }
-
-    #[test]
-    fn binary_colors() {
-        let input = b"He\x11\0 \xff\0\xdd";
-        let expected_text = "\
-            ┌────────┬─────────────────────────────────────────────────────────────────────────┬────────┐\n\
-            │00000000│ 01001000 01100101 00010001 00000000 00100000 11111111 00000000 11011101 │He•⋄ ×⋄×│\n\
-            └────────┴─────────────────────────────────────────────────────────────────────────┴────────┘\n";
-        let expected = ColorMap::from(
-            "\
-            ┌────────┬─────────────────────────────────────────────────────────────────────────┬────────┐\n\
-            │r.......d y....... ........ b....... c....... g....... m....... c....... m.......d│y.bcgmcmd\n\
-            └────────┴─────────────────────────────────────────────────────────────────────────┴────────┘\n"
-        )
-        .with::<colors::Red>('r')
-        .with::<colors::Default>('d')
-        .with::<colors::Yellow>('y')
-        .with::<colors::Blue>('b')
-        .with::<colors::Green>('g')
-        .with::<colors::BrightMagenta>('m')
-        .with::<colors::CustomColor<0xab, 0xcd, 0xef>>('c')
-        .colorize(expected_text);
-
-        hexyl()
-            .write_stdin(input)
-            .arg("--color=always")
-            .arg("--panels=1")
-            .arg("--base=binary")
-            .env("HEXYL_COLOR_OFFSET", "red")
-            .env("HEXYL_COLOR_ASCII_PRINTABLE", "yellow")
-            .env("HEXYL_COLOR_ASCII_WHITESPACE", "green")
-            .env("HEXYL_COLOR_ASCII_OTHER", "blue")
-            .env("HEXYL_COLOR_NONASCII", "bright magenta")
-            .env("HEXYL_COLOR_NULL", "#abcdef")
-            .assert()
-            .success()
-            .stdout(expected);
-    }
-
-    #[test]
-    fn groupsize_colors() {
-        let input = b"He\x11\0 \xff\0\xdd";
-        let expected_text = "\
-            ┌────────┬─────────────────────┬────────┐\n\
-            │00000000│ 4865 1100 20ff 00dd │He•⋄ ×⋄×│\n\
-            └────────┴─────────────────────┴────────┘\n";
-        let expected = ColorMap::from(
-            "\
-            ┌────────┬─────────────────────┬────────┐\n\
-            │r.......d y... b.c. g.m. c.m.d│y.bcgmcmd\n\
-            └────────┴─────────────────────┴────────┘\n",
-        )
-        .with::<colors::Red>('r')
-        .with::<colors::Default>('d')
-        .with::<colors::Yellow>('y')
-        .with::<colors::Blue>('b')
-        .with::<colors::Green>('g')
-        .with::<colors::BrightMagenta>('m')
-        .with::<colors::CustomColor<0xab, 0xcd, 0xef>>('c')
-        .colorize(expected_text);
-
-        hexyl()
-            .write_stdin(input)
-            .arg("--color=always")
-            .arg("--panels=1")
-            .arg("--groupsize=2")
-            .env("HEXYL_COLOR_OFFSET", "red")
-            .env("HEXYL_COLOR_ASCII_PRINTABLE", "yellow")
-            .env("HEXYL_COLOR_ASCII_WHITESPACE", "green")
-            .env("HEXYL_COLOR_ASCII_OTHER", "blue")
-            .env("HEXYL_COLOR_NONASCII", "bright magenta")
-            .env("HEXYL_COLOR_NULL", "#abcdef")
-            .assert()
-            .success()
-            .stdout(expected);
-    }
-}
Author	SHA1	Message	Date
David Peter	becc75caf1	Fix #254	2026-02-14 13:42:51 +01:00
Sharif Haason	cc9476d665	Return a proper error if terminal size fails	2022-07-17 15:53:56 -04:00
Sharif Haason	ab381e88f8	Change columns type to `u16`	2022-07-17 15:53:23 -04:00
Sharif Haason	361ded43fd	Remove debugging line	2022-07-17 15:48:05 -04:00
Sharif Haason	20056fb4d9	Bump MSRV	2022-07-17 15:26:43 -04:00
Sharif Haason	34c55b5e55	Implement -a and -t for terminal width setting	2022-07-17 15:20:00 -04:00
Sharif Haason	f4c4b22c57	Added test for multiple columns	2022-07-17 13:37:25 -04:00
Sharif Haason	98c65d94e7	Prevent overflow when columns >= 32	2022-07-17 11:31:46 -04:00
sharifandDavid Peter	d74520fbab	Update src/squeezer.rs Co-authored-by: David Peter <sharkdp@users.noreply.github.com>	2022-07-17 08:54:24 -04:00
Sharif Haason	c8b05ff96f	`cargo fmt`	2022-07-12 11:49:50 -04:00
Sharif Haason	734365723b	Adds --columns for Print using custom width #13	2022-07-12 11:39:24 -04:00