Add bat panic regression test when LiveScript is missing

* Fix links in Russian translation.
* Simplify links in Korean translation.
* Fix build status badge in Japanese and Russian translations.
* Add link from Japanese to Russian translation.
* Add line break between "topics" row and "translations" row.
* Remove "translations" from translations row in Japanese and Russian.
* Add consistent spacing between translation links.
* Add backreferences to English README.
* Remove self references.
* Split translations row across multiple lines for easier maintenance.

Co-authored-by: David Peter <sharkdp@users.noreply.github.com>

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [sharkdp, keith-hall, Enselic]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,33 +7,41 @@ assignees: ''
 
 ---
 
-<!--
-Hey there, thanks for creating an issue!
-
-In order to reproduce your issue, we might need to know a little bit more about the environment
-which you're running `bat` on.
-
-If you're on Linux or MacOS:
-  Please run the script at https://github.com/sharkdp/bat/blob/master/diagnostics/info.sh and
-  paste the output at the bottom of the bug report.
-
-If you're on Windows:
-  Please tell us about your Windows Version (e.g. "Windows 10 1908") at the
-  bottom of the bug report.
--->
-
-**What version of `bat` are you using?**
-[paste the output of `bat --version` here]
+<!-- Hey there, thank you for creating an issue! -->
 
 **Describe the bug you encountered:**
+
 ...
 
 **What did you expect to happen instead?**
+
 ...
 
+
 **How did you install `bat`?**
+
 <!-- apt-get, homebrew, GitHub release, etc. -->
 
 ---
 
-[paste the output of `info.sh` here]
+**bat version and environment**
+
+<!--
+In order to reproduce your issue, please add some information about the environment
+in which you're running bat. To do this, run the full `bat` command that demonstrates
+the bug, and attach the `--diagnostic` option:
+
+    bat [other options and arguments…] --diagnostic
+
+Finally, paste the Markdown output here. Please make sure that it does not reveal any
+personal information.
+
+
+If you are running bat 0.17.1 or older (where --diagnostic is not available), please
+run the script at
+
+    https://github.com/sharkdp/bat/blob/master/diagnostics/info.sh
+
+(click "Raw" to get the actual source code) and paste the Markdown output here. If you
+are on Windows, please let us know your bat version and your Windows version.
+-->

.github/ISSUE_TEMPLATE/config.yml

@@ -1,2 +1 @@
 blank_issues_enabled: true
-

.github/ISSUE_TEMPLATE/feature_request.md

@@ -7,4 +7,3 @@ assignees: ''
 
 ---
 
-

.github/ISSUE_TEMPLATE/question.md

@@ -7,4 +7,3 @@ assignees: ''
 
 ---
 
-

.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+- package-ecosystem: cargo
+  directory: "/"
+  schedule:
+    interval: monthly
+    time: "04:00"
+    timezone: Europe/Berlin
+  ignore:
+  - dependency-name: git2
+    versions:
+    - 0.13.17
+- package-ecosystem: gitsubmodule
+  directory: "/"
+  schedule:
+    interval: monthly
+    time: "04:00"
+    timezone: Europe/Berlin

.github/workflows/CICD.yml

@@ -1,35 +1,60 @@
 name: CICD
 
 env:
-  PROJECT_NAME: bat
-  PROJECT_DESC: "A `cat` clone with wings"
-  PROJECT_MAINTAINER: "David Peter <mail@david-peter.de>"
-  PROJECT_HOMEPAGE: "https://github.com/sharkdp/bat"
-  MIN_SUPPORTED_RUST_VERSION: "1.40.0"
+  MIN_SUPPORTED_RUST_VERSION: "1.46.0"
+  CICD_INTERMEDIATES_DIR: "_cicd-intermediates"
 
-on: [push, pull_request]
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - master
+    tags:
+      - '*'
 
 jobs:
+  ensure_cargo_fmt:
+    name: Ensure 'cargo fmt' has been run
+    runs-on: ubuntu-20.04
+    steps:
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        default: true
+        profile: minimal
+        components: rustfmt
+    - uses: actions/checkout@v2
+    - run: cargo fmt -- --check
+
   min_version:
     name: Minimum supported rust version
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
     steps:
-    - name: Git checkout
+    - name: Checkout source code
       uses: actions/checkout@v2
+
     - name: Install rust toolchain (v${{ env.MIN_SUPPORTED_RUST_VERSION }})
       uses: actions-rs/toolchain@v1
       with:
         toolchain: ${{ env.MIN_SUPPORTED_RUST_VERSION }}
         default: true
         profile: minimal # minimal component installation (ie, no documentation)
-    - name: Test
+        components: clippy
+    - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)
+      uses: actions-rs/cargo@v1
+      with:
+        command: clippy
+        args: --locked --all-targets --all-features -- --allow clippy::unknown_clippy_lints
+    - name: Run tests
       uses: actions-rs/cargo@v1
       with:
         command: test
+        args: --locked
 
   test_with_new_syntaxes_and_themes:
-    name: Test with new syntaxes and themes
-    runs-on: ubuntu-latest
+    name: Run tests with updated syntaxes and themes
+    runs-on: ubuntu-20.04
     steps:
     - name: Git checkout
       uses: actions/checkout@v2
@@ -57,164 +82,88 @@ jobs:
       uses: actions-rs/cargo@v1
       with:
         command: test
-        args: --release
+        args: --locked --release
     - name: Run ignored-by-default unit tests with new syntaxes and themes
       uses: actions-rs/cargo@v1
       with:
         command: test
-        args: --release -- --ignored
+        args: --locked --release -- --ignored
     - name: Syntax highlighting regression test
       run: tests/syntax-tests/regression_test.sh
     - name: List of languages
       run: bat --list-languages
     - name: List of themes
       run: bat --list-themes
+    - name: Test custom assets
+      run: tests/syntax-tests/test_custom_assets.sh
+
+  documentation:
+    name: Documentation
+    runs-on: ubuntu-20.04
+    steps:
+    - name: Git checkout
+      uses: actions/checkout@v2
+    - name: Install Rust toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        default: true
+        profile: minimal
+    - name: Check documentation
+      env:
+        RUSTDOCFLAGS: -D warnings
+      uses: actions-rs/cargo@v1
+      with:
+        command: doc
+        args: --locked --no-deps --document-private-items --all-features
 
   build:
-    name: Build
+    name: ${{ matrix.job.target }} (${{ matrix.job.os }})
     runs-on: ${{ matrix.job.os }}
     strategy:
       fail-fast: false
       matrix:
         job:
-          # { os, target, cargo-options, features, use-cross, toolchain }
-          - { os: ubuntu-latest  , target: arm-unknown-linux-gnueabihf , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: aarch64-unknown-linux-gnu   , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: i686-unknown-linux-gnu      , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: i686-unknown-linux-musl     , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-musl   , use-cross: use-cross }
-          - { os: ubuntu-16.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
-          - { os: macos-latest   , target: x86_64-apple-darwin         }
-          # - { os: windows-latest , target: i686-pc-windows-gnu         }  ## disabled; linker errors (missing '_imp____acrt_iob_func')
-          - { os: windows-latest , target: i686-pc-windows-msvc        }
-          # - { os: windows-latest , target: x86_64-pc-windows-gnu       }  ## disabled; linker errors (missing '_imp____acrt_iob_func')
-          - { os: windows-latest , target: x86_64-pc-windows-msvc      }
+          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-20.04, use-cross: true }
+          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-20.04, use-cross: true }
+          - { target: arm-unknown-linux-musleabihf, os: ubuntu-20.04, use-cross: true }
+          - { target: i686-pc-windows-msvc        , os: windows-2019                  }
+          - { target: i686-unknown-linux-gnu      , os: ubuntu-20.04, use-cross: true }
+          - { target: i686-unknown-linux-musl     , os: ubuntu-20.04, use-cross: true }
+          - { target: x86_64-apple-darwin         , os: macos-10.15                   }
+          - { target: x86_64-pc-windows-gnu       , os: windows-2019                  }
+          - { target: x86_64-pc-windows-msvc      , os: windows-2019                  }
+          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-20.04                  }
+          - { target: x86_64-unknown-linux-musl   , os: ubuntu-20.04, use-cross: true }
     steps:
-    - name: Git checkout
+    - name: Checkout source code
       uses: actions/checkout@v2
+
     - name: Install prerequisites
       shell: bash
       run: |
         case ${{ matrix.job.target }} in
-          arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
+          arm-unknown-linux-*) 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: Initialize workflow variables
-      id: vars
+
+    - name: Extract crate information
       shell: bash
       run: |
-        # toolchain
-        TOOLCHAIN="stable" ## default to "stable" toolchain
-        # * specify alternate TOOLCHAIN for *-pc-windows-gnu targets; gnu targets on Windows are broken for the standard *-pc-windows-msvc toolchain (refs: <https://github.com/rust-lang/rust/issues/47048>, <https://github.com/rust-lang/rust/issues/53454>, <https://github.com/rust-lang/cargo/issues/6754>)
-        case ${{ matrix.job.target }} in *-pc-windows-gnu) TOOLCHAIN="stable-${{ matrix.job.target }}" ;; esac;
-        # * use requested TOOLCHAIN if specified
-        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
-        echo set-output name=TOOLCHAIN::${TOOLCHAIN}
-        echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}
-        # staging directory
-        STAGING='_staging'
-        echo set-output name=STAGING::${STAGING}
-        echo ::set-output name=STAGING::${STAGING}
-        # determine EXE suffix
-        EXE_suffix="" ; case ${{ matrix.job.target }} in *-pc-windows-*) EXE_suffix=".exe" ;; esac;
-        echo set-output name=EXE_suffix::${EXE_suffix}
-        echo ::set-output name=EXE_suffix::${EXE_suffix}
-        # parse commit reference info
-        REF_NAME=${GITHUB_REF#refs/*/}
-        unset REF_BRANCH ; case ${GITHUB_REF} in refs/heads/*) REF_BRANCH=${GITHUB_REF#refs/heads/} ;; esac;
-        unset REF_TAG ; case ${GITHUB_REF} in refs/tags/*) REF_TAG=${GITHUB_REF#refs/tags/} ;; esac;
-        REF_SHAS=${GITHUB_SHA:0:8}
-        echo set-output name=REF_NAME::${REF_NAME}
-        echo set-output name=REF_BRANCH::${REF_BRANCH}
-        echo set-output name=REF_TAG::${REF_TAG}
-        echo set-output name=REF_SHAS::${REF_SHAS}
-        echo ::set-output name=REF_NAME::${REF_NAME}
-        echo ::set-output name=REF_BRANCH::${REF_BRANCH}
-        echo ::set-output name=REF_TAG::${REF_TAG}
-        echo ::set-output name=REF_SHAS::${REF_SHAS}
-        # parse target
-        unset TARGET_ARCH ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) TARGET_ARCH=arm ;; i686-*) TARGET_ARCH=i686 ;; x86_64-*) TARGET_ARCH=x86_64 ;; esac;
-        echo set-output name=TARGET_ARCH::${TARGET_ARCH}
-        echo ::set-output name=TARGET_ARCH::${TARGET_ARCH}
-        unset TARGET_OS ; case ${{ matrix.job.target }} in *-linux-*) TARGET_OS=linux ;; *-apple-*) TARGET_OS=macos ;; *-windows-*) TARGET_OS=windows ;; esac;
-        echo set-output name=TARGET_OS::${TARGET_OS}
-        echo ::set-output name=TARGET_OS::${TARGET_OS}
-        # package name
-        PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
-        PKG_BASENAME=${PROJECT_NAME}-${REF_TAG:-$REF_SHAS}-${{ matrix.job.target }}
-        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
-        echo set-output name=PKG_suffix::${PKG_suffix}
-        echo set-output name=PKG_BASENAME::${PKG_BASENAME}
-        echo set-output name=PKG_NAME::${PKG_NAME}
-        echo ::set-output name=PKG_suffix::${PKG_suffix}
-        echo ::set-output name=PKG_BASENAME::${PKG_BASENAME}
-        echo ::set-output name=PKG_NAME::${PKG_NAME}
-        # deployable tag? (ie, leading "vM" or "M"; M == version number)
-        unset DEPLOY ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DEPLOY='true' ; fi
-        echo set-output name=DEPLOY::${DEPLOY:-<empty>/false}
-        echo ::set-output name=DEPLOY::${DEPLOY}
-        # DPKG architecture?
-        unset DPKG_ARCH
-        case ${{ matrix.job.target }} in
-          aarch64-*-linux-*) DPKG_ARCH=arm64 ;;
-          arm-*-linux-*hf) DPKG_ARCH=armhf ;;
-          i686-*-linux-*) DPKG_ARCH=i686 ;;
-          x86_64-*-linux-*) DPKG_ARCH=amd64 ;;
-        esac;
-        echo set-output name=DPKG_ARCH::${DPKG_ARCH}
-        echo ::set-output name=DPKG_ARCH::${DPKG_ARCH}
-        # DPKG version?
-        unset DPKG_VERSION ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DPKG_VERSION=${REF_TAG/#[vV]/} ; fi
-        echo set-output name=DPKG_VERSION::${DPKG_VERSION}
-        echo ::set-output name=DPKG_VERSION::${DPKG_VERSION}
-        # DPKG base name/conflicts?
-        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;
-        echo set-output name=DPKG_BASENAME::${DPKG_BASENAME}
-        echo set-output name=DPKG_CONFLICTS::${DPKG_CONFLICTS}
-        echo ::set-output name=DPKG_BASENAME::${DPKG_BASENAME}
-        echo ::set-output name=DPKG_CONFLICTS::${DPKG_CONFLICTS}
-        # DPKG name
-        unset DPKG_NAME;
-        if [[ -n $DPKG_ARCH && -n $DPKG_VERSION ]]; then DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb" ; fi
-        echo set-output name=DPKG_NAME::${DPKG_NAME}
-        echo ::set-output name=DPKG_NAME::${DPKG_NAME}
-        # target-specific options
-        # * CARGO_USE_CROSS (truthy)
-        CARGO_USE_CROSS='true' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) unset CARGO_USE_CROSS ;; esac;
-        echo set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS:-<empty>/false}
-        echo ::set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS}
-        # # * `arm` cannot be tested on ubuntu-* hosts (b/c testing is currently primarily done via comparison of target outputs with built-in outputs and the `arm` target is not executable on the host)
-        JOB_DO_TESTING="true"
-        case ${{ matrix.job.target }} in arm-*) unset JOB_DO_TESTING ;; esac;
-        echo set-output name=JOB_DO_TESTING::${JOB_DO_TESTING:-<empty>/false}
-        echo ::set-output name=JOB_DO_TESTING::${JOB_DO_TESTING}
-        # # * test only library unit tests and binary for arm-type targets
-        unset CARGO_TEST_OPTIONS
-        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}
-        echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
-        # * executable for `strip`?
-        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;
-        echo set-output name=STRIP::${STRIP}
-        echo ::set-output name=STRIP::${STRIP}
-    - name: Create all needed build/work directories
-      shell: bash
-      run: |
-        mkdir -p '${{ steps.vars.outputs.STAGING }}'
-        mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}'
-        mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/autocomplete'
-        mkdir -p '${{ steps.vars.outputs.STAGING }}/dpkg'
+        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: ${{ steps.vars.outputs.TOOLCHAIN }}
+        toolchain: stable
         target: ${{ matrix.job.target }}
         override: true
         profile: minimal # minimal component installation (ie, no documentation)
-    - name: Info
+
+    - name: Show version information (Rust, cargo, GCC)
       shell: bash
       run: |
         gcc --version || true
@@ -223,221 +172,290 @@ jobs:
         rustup default
         cargo -V
         rustc -V
+
     - name: Build
       uses: actions-rs/cargo@v1
       with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
+        use-cross: ${{ matrix.job.use-cross }}
         command: build
-        args: --release --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }}
-    - name: Test
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: test
-        args: --target=${{ matrix.job.target }} ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }}
-    - name: bat test run
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: run
-        args: --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} -- --paging=never --color=always --theme=ansi-dark Cargo.toml src/config.rs
-    - name: Check features regex-onig
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: check
-        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig
-    - name: Check features regex-onig,git
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: check
-        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git
-    - name: Check features regex-onig,paging
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: check
-        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,paging
-    - name: Check features regex-onig,git,paging
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: check
-        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git,paging
-    - name: Upload build artifacts
-      uses: actions/upload-artifact@master
-      with:
-        name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}
-        path: target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}
-    - name: Package
+        args: --locked --release --target=${{ matrix.job.target }}
+
+    - name: Strip debug information from executable
+      id: strip
       shell: bash
       run: |
-        ARCHIVE_DIR='${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
-        # Binary
-        cp 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' "$ARCHIVE_DIR"
+        # Figure out suffix of binary
+        EXE_suffix=""
+        case ${{ matrix.job.target }} in
+          *-pc-windows-*) EXE_suffix=".exe" ;;
+        esac;
 
-        # `strip` binary (if needed)
-        if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" "$ARCHIVE_DIR/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}" ; fi
+        # Figure out what strip tool to use if any
+        STRIP="strip"
+        case ${{ matrix.job.target }} in
+          arm-unknown-linux-*) STRIP="arm-linux-gnueabihf-strip" ;;
+          aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;;
+          *-pc-windows-msvc) STRIP="" ;;
+        esac;
+
+        # 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
+      shell: bash
+      run: |
+        # test only library unit tests and binary for arm-type targets
+        unset CARGO_TEST_OPTIONS
+        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
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: test
+        args: --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}
+
+    - name: Run bat
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: run
+        args: --locked --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs
+
+    - name: Show diagnostics (bat --diagnostic)
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: run
+        args: --locked --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs --diagnostic
+
+    - name: "Feature check: regex-onig"
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: check
+        args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig
+
+    - name: "Feature check: regex-onig,git"
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: check
+        args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git
+
+    - name: "Feature check: regex-onig,paging"
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: check
+        args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,paging
+
+    - name: "Feature check: regex-onig,git,paging"
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: check
+        args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git,paging
+
+    - name: "Feature check: minimal-application"
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: check
+        args: --locked --target=${{ matrix.job.target }} --verbose --no-default-features --features minimal-application
+
+    - 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=${PROJECT_NAME}-v${PROJECT_VERSION}-${{ matrix.job.target }}
+        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
+        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}"
+        mkdir -p "${ARCHIVE_DIR}/autocomplete"
+
+        # Binary
+        cp "${{ steps.strip.outputs.BIN_PATH }}" "$ARCHIVE_DIR"
 
         # Man page
         cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "$ARCHIVE_DIR"
 
-        # README and LICENSE files
-        cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "$ARCHIVE_DIR"
+        # README, LICENSE and CHANGELOG files
+        cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "CHANGELOG.md" "$ARCHIVE_DIR"
 
         # Autocompletion files
+        cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.bash "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.bash"
         cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.fish "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.fish"
+        cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/_bat.ps1 "$ARCHIVE_DIR/autocomplete/_${{ env.PROJECT_NAME }}.ps1"
         cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.zsh "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.zsh"
 
         # base compressed package
-        pushd '${{ steps.vars.outputs.STAGING }}/' >/dev/null
+        pushd "${PKG_STAGING}/" >/dev/null
         case ${{ matrix.job.target }} in
-          *-pc-windows-*) 7z -y a '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* | tail -2 ;;
-          *) tar czf '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* ;;
+          *-pc-windows-*) 7z -y a "${PKG_NAME}" "${PKG_BASENAME}"/* | tail -2 ;;
+          *) tar czf "${PKG_NAME}" "${PKG_BASENAME}"/* ;;
         esac;
         popd >/dev/null
 
-        # Debian package
-        if [ -n "${{ steps.vars.outputs.DPKG_NAME }}" ]; then
-          DPKG_DIR="${{ steps.vars.outputs.STAGING }}/dpkg"
+        # Let subsequent steps know where to find the compressed package
+        echo ::set-output name=PKG_PATH::"${PKG_STAGING}/${PKG_NAME}"
 
-          # Binary
-          install -Dm755 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}"
-          if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}" ; fi
+    - name: Create Debian package
+      id: debian-package
+      shell: bash
+      if: startsWith(matrix.job.os, 'ubuntu')
+      run: |
+        COPYRIGHT_YEARS="2018 - "$(date "+%Y")
+        DPKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/debian-package"
+        DPKG_DIR="${DPKG_STAGING}/dpkg"
+        mkdir -p "${DPKG_DIR}"
 
-          # Man page
-          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
-          gzip --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        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}
 
-          # Autocompletion files
-          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.fish "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ env.PROJECT_NAME }}.fish"
-          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.zsh "${DPKG_DIR}/usr/share/zsh/vendor-completions/_${{ env.PROJECT_NAME }}"
+        unset DPKG_ARCH
+        case ${{ matrix.job.target }} in
+          aarch64-*-linux-*) DPKG_ARCH=arm64 ;;
+          arm-*-linux-*hf) DPKG_ARCH=armhf ;;
+          i686-*-linux-*) DPKG_ARCH=i686 ;;
+          x86_64-*-linux-*) DPKG_ARCH=amd64 ;;
+          *) DPKG_ARCH=notset ;;
+        esac;
 
-          # README and LICENSE
-          install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/README.md"
-          install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/LICENSE-MIT"
-          install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/LICENSE-APACHE"
+        DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
+        echo ::set-output name=DPKG_NAME::${DPKG_NAME}
 
-          cat > "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/copyright" <<EOF
+        # Binary
+        install -Dm755 "${{ steps.strip.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.strip.outputs.BIN_NAME }}"
+
+        # Man page
+        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+
+        # Autocompletion files
+        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.bash "${DPKG_DIR}/usr/share/bash-completion/completions/${{ env.PROJECT_NAME }}"
+        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.fish "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ env.PROJECT_NAME }}.fish"
+        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.zsh "${DPKG_DIR}/usr/share/zsh/vendor-completions/_${{ env.PROJECT_NAME }}"
+
+        # README and LICENSE
+        install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"
+        install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-MIT"
+        install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-APACHE"
+        install -Dm644 "CHANGELOG.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
+        gzip -n --best "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
+
+        cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF
         Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
         Upstream-Name: ${{ env.PROJECT_NAME }}
         Source: ${{ env.PROJECT_HOMEPAGE }}
 
         Files: *
         Copyright: ${{ env.PROJECT_MAINTAINER }}
+        Copyright: $COPYRIGHT_YEARS ${{ env.PROJECT_MAINTAINER }}
         License: Apache-2.0 or MIT
 
         License: Apache-2.0
-         On Debian systems, the complete text of the Apache-2.0 can be found in the
-         file /usr/share/common-licenses/Apache-2.0.
+          On Debian systems, the complete text of the Apache-2.0 can be found in the
+          file /usr/share/common-licenses/Apache-2.0.
 
         License: MIT
-         Permission is hereby granted, free of charge, to any
-         person obtaining a copy of this software and associated
-         documentation files (the "Software"), to deal in the
-         Software without restriction, including without
-         limitation the rights to use, copy, modify, merge,
-         publish, distribute, sublicense, and/or sell copies of
-         the Software, and to permit persons to whom the Software
-         is furnished to do so, subject to the following
-         conditions:
-         .
-         The above copyright notice and this permission notice
-         shall be included in all copies or substantial portions
-         of the Software.
-         .
-         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-         ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-         TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-         PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-         SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-         CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-         OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-         IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-         DEALINGS IN THE SOFTWARE.
+          Permission is hereby granted, free of charge, to any
+          person obtaining a copy of this software and associated
+          documentation files (the "Software"), to deal in the
+          Software without restriction, including without
+          limitation the rights to use, copy, modify, merge,
+          publish, distribute, sublicense, and/or sell copies of
+          the Software, and to permit persons to whom the Software
+          is furnished to do so, subject to the following
+          conditions:
+          .
+          The above copyright notice and this permission notice
+          shall be included in all copies or substantial portions
+          of the Software.
+          .
+          THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+          ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+          TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+          PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+          SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+          CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+          OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+          IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+          DEALINGS IN THE SOFTWARE.
         EOF
+          chmod 644 "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright"
 
           # control file
           mkdir -p "${DPKG_DIR}/DEBIAN"
           cat > "${DPKG_DIR}/DEBIAN/control" <<EOF
-        Package: ${{ steps.vars.outputs.DPKG_BASENAME }}
-        Version: ${{ steps.vars.outputs.DPKG_VERSION }}
+        Package: ${DPKG_BASENAME}
+        Version: ${DPKG_VERSION}
         Section: utils
         Priority: optional
         Maintainer: ${{ env.PROJECT_MAINTAINER }}
         Homepage: ${{ env.PROJECT_HOMEPAGE }}
-        Architecture: ${{ steps.vars.outputs.DPKG_ARCH }}
+        Architecture: ${DPKG_ARCH}
         Provides: ${{ env.PROJECT_NAME }}
-        Conflicts: ${{ steps.vars.outputs.DPKG_CONFLICTS }}
-        Description: A cat(1) clone with wings.
-         A cat(1) clone with syntax highlighting and Git integration.
+        Conflicts: ${DPKG_CONFLICTS}
+        Description: cat(1) clone with wings.
+          A cat(1) clone with syntax highlighting and Git integration.
         EOF
 
-          # build dpkg
-          fakeroot dpkg-deb --build "${DPKG_DIR}" "${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}"
-        fi
-    - name: Publish archives and packages
-      uses: softprops/action-gh-release@v1
-      if: steps.vars.outputs.DEPLOY
-      with:
-        files: |
-          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}
-          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
+        echo ::set-output name=DPKG_PATH::${DPKG_PATH}
 
-  coverage:
-    name: Code Coverage
-    runs-on: ${{ matrix.job.os }}
-    strategy:
-      fail-fast: true
-      matrix:
-        # job: [ { os: ubuntu-latest }, { os: macos-latest }, { os: windows-latest } ]
-        job:
-          - { os: ubuntu-latest , toolchain: nightly-2020-04-29 }
-          - { os: macos-latest , toolchain: nightly-2020-04-29 }
-          - { os: windows-latest , toolchain: nightly-2020-04-29-x86_64-pc-windows-gnu }
-    steps:
-    - uses: actions/checkout@v2
-    - name: Initialize workflow variables
-      id: vars
+        # build dpkg
+        fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"
+
+    - name: "Artifact upload: tarball"
+      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@master
+      if: steps.debian-package.outputs.DPKG_NAME
+      with:
+        name: ${{ steps.debian-package.outputs.DPKG_NAME }}
+        path: ${{ steps.debian-package.outputs.DPKG_PATH }}
+
+    - name: Check for release
+      id: is-release
       shell: bash
       run: |
-        # toolchain
-        TOOLCHAIN="nightly" ## default to "nightly" toolchain
-        # * use requested TOOLCHAIN if specified
-        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
-        # * use requested TOOLCHAIN if specified
-        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
-        echo set-output name=TOOLCHAIN::${TOOLCHAIN}
-        echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}
-        # target-specific options
-        # * CODECOV_FLAGS
-        CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )
-        echo set-output name=CODECOV_FLAGS::${CODECOV_FLAGS}
-        echo ::set-output name=CODECOV_FLAGS::${CODECOV_FLAGS}
-    - name: rust toolchain ~ install
-      uses: actions-rs/toolchain@v1
+        unset IS_RELEASE ; if [[ $GITHUB_REF =~ ^refs/tags/v[0-9].* ]]; then IS_RELEASE='true' ; fi
+        echo ::set-output name=IS_RELEASE::${IS_RELEASE}
+
+    - name: Publish archives and packages
+      uses: softprops/action-gh-release@v1
+      if: steps.is-release.outputs.IS_RELEASE
       with:
-        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
-        override: true
-        profile: minimal # minimal component installation (ie, no documentation)
-    - name: Test
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: --no-fail-fast
+        files: |
+          ${{ steps.package.outputs.PKG_PATH }}
+          ${{ steps.debian-package.outputs.DPKG_PATH }}
       env:
-        CARGO_INCREMENTAL: '0'
-        RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Zno-landing-pads'
-    - name: Generate coverage data
-      id: coverage
-      uses: actions-rs/grcov@v0.1
-    - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v1
-      with:
-        file: ${{ steps.coverage.outputs.report }}
-        flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
-        name: codecov-umbrella
-        fail_ci_if_error: false
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -2,6 +2,7 @@
 **/*.rs.bk
 
 # Generated files
+/assets/completions/bat.bash
 /assets/completions/bat.fish
 /assets/completions/bat.zsh
 /assets/manual/bat.1

.gitmodules

@@ -61,9 +61,6 @@
 [submodule "assets/syntaxes/Puppet"]
 	path = assets/syntaxes/02_Extra/Puppet
 	url = https://github.com/russCloak/SublimePuppet
-[submodule "assets/syntaxes/CSV"]
-	path = assets/syntaxes/02_Extra/CSV
-	url = https://github.com/wadetb/Sublime-Text-Advanced-CSV
 [submodule "assets/themes/onehalf"]
 	path = assets/themes/onehalf
 	url = https://github.com/sonph/onehalf
@@ -97,10 +94,6 @@
 [submodule "assets/syntaxes/Assembly (ARM)"]
 	path = assets/syntaxes/02_Extra/Assembly (ARM)
 	url = https://github.com/tvi/Sublime-ARM-Assembly
-[submodule "assets/syntaxes/syslog-syntax"]
-	path = assets/syntaxes/02_Extra/Syslog
-	url = https://github.com/caos21/syslog-syntax.git
-	branch = master
 [submodule "assets/syntaxes/protobuf-syntax-highlighting"]
 	path = assets/syntaxes/02_Extra/Protobuf
 	url = https://github.com/VcamX/protobuf-syntax-highlighting.git
@@ -185,9 +178,6 @@
 [submodule "assets/syntaxes/02_Extra/AsciiDoc"]
 	path = assets/syntaxes/02_Extra/AsciiDoc
 	url = https://github.com/asciidoctor/sublimetext-asciidoc.git
-[submodule "assets/themes/gruvbox"]
-	path = assets/themes/gruvbox
-	url = https://github.com/peaceant/gruvbox.git
 [submodule "assets/syntaxes/02_Extra/GLSL"]
 	path = assets/syntaxes/02_Extra/GLSL
 	url = https://github.com/euler0/sublime-glsl
@@ -206,3 +196,40 @@
 [submodule "assets/themes/Coldark"]
 	path = assets/themes/Coldark
 	url = https://github.com/ArmandPhilippot/coldark-bat.git
+[submodule "assets/themes/gruvbox"]
+	path = assets/themes/gruvbox
+	url = https://github.com/subnut/gruvbox-tmTheme.git
+	branch = bat-source
+[submodule "assets/syntaxes/02_Extra/Lean"]
+	path = assets/syntaxes/02_Extra/Lean
+	url = https://github.com/leanprover/vscode-lean.git
+[submodule "assets/syntaxes/02_Extra/Zig"]
+	path = assets/syntaxes/02_Extra/Zig
+	url = https://github.com/ziglang/sublime-zig-language.git
+[submodule "assets/syntaxes/02_Extra/gnuplot"]
+	path = assets/syntaxes/02_Extra/gnuplot
+	url = https://github.com/hesstobi/sublime_gnuplot
+[submodule "assets/syntaxes/02_Extra/SystemVerilog"]
+	path = assets/syntaxes/02_Extra/SystemVerilog
+	url = https://github.com/TheClams/SystemVerilog.git
+[submodule "assets/themes/visual-studio-dark-plus"]
+	path = assets/themes/visual-studio-dark-plus
+	url = https://github.com/vidann1/visual-studio-dark-plus.git
+[submodule "assets/syntaxes/02_Extra/SublimeEthereum"]
+	path = assets/syntaxes/02_Extra/SublimeEthereum
+	url = https://github.com/davidhq/SublimeEthereum.git
+[submodule "assets/syntaxes/02_Extra/Groff"]
+	path = assets/syntaxes/02_Extra/Groff
+	url = https://github.com/carsonoid/sublime_man_page_support
+[submodule "assets/syntaxes/02_Extra/http-request-response"]
+	path = assets/syntaxes/02_Extra/http-request-response
+	url = https://github.com/keith-hall/http-request-response-syntax.git
+[submodule "assets/syntaxes/02_Extra/LLVM"]
+	path = assets/syntaxes/02_Extra/LLVM
+	url = https://github.com/ioncodes/LLVM.tmBundle
+[submodule "assets/syntaxes/02_Extra/Slim"]
+	path = assets/syntaxes/02_Extra/Slim
+	url = https://github.com/slim-template/ruby-slim.tmbundle.git
+[submodule "assets/syntaxes/02_Extra/Racket"]
+	path = assets/syntaxes/02_Extra/Racket
+	url = https://github.com/follesoe/sublime-racket.git

CHANGELOG.md

@@ -1,19 +1,150 @@
 # unreleased
 
-
 ## Features
 
+- `$BAT_CONFIG_DIR` is now a recognized environment variable. It has precedence over `$XDG_CONFIG_HOME`, see #1727 (@billrisher)
+- Support for `x:+delta` syntax in line ranges (e.g. `20:+10`). See  #1810 (@bojan88)
+
 ## Bugfixes
 
+- Python syntax highlighting no longer suffers from abysmal performance in specific scenarios. See #1688 (@keith-hall)
+- First line not shown in diff context. See #1891 (@divagant-martian)
+
+## Performance
+
+- Load cached assets as fast as integrated assets, see #1753 (@Enselic)
+- Greatly reduce startup time in loop-through mode, e.g. when redirecting output. Instead of *50 ms* - *100 ms*, startup takes *5 ms* - *10 ms*. See #1747 (@Enselic)
+- Reduce startup time by approximately 80% for 91 out of 168 syntaxes when using `--language`. See #1787 (@Enselic)
+
 ## Other
 
+- Add PowerShell completion, see #1826 (@rashil2000)
+- Minimum supported Rust version (MSRV) bumped to 1.46
+
 ## Syntaxes
 
+- Groff, see #1685 (@scop)
+- HTTP Requests and Responses, see #1748 (@keith-hall)
+- LLVM, see #1777 (@ioncodes)
+- Highlight for `vimrc` and `gvimrc` files, see #1763 (@SuperSandro2000)
+- Syslog highlighting improvements, see #1793 (@scop)
+- Added support for `slim` syntax, see #1693 (@mfinelli)
+- Racket, see #1884 (@jubnzv)
+
 ## New themes
 
+
 ## `bat` as a library
 
-## Packaging
+- Deprecate `HighlightingAssets::syntaxes()` and `HighlightingAssets::syntax_for_file_name()`. Use `HighlightingAssets::get_syntaxes()` and `HighlightingAssets::get_syntax_for_path()` instead. They return a `Result` which is needed for upcoming lazy-loading work to improve startup performance. They also return which `SyntaxSet` the returned `SyntaxReference` belongs to. See #1747, #1755, #1776, #1862 (@Enselic)
+- Remove `HighlightingAssets::from_files` and `HighlightingAssets::save_to_cache`. Instead of calling the former and then the latter you now make a single call to `bat::assets::build`. See #1802 (@Enselic)
+- Replace  the `error::Error(error::ErrorKind, _)` struct and enum with an `error::Error` enum. `Error(ErrorKind::UnknownSyntax, _)` becomes `Error::UnknownSyntax`, etc. Also remove the `error::ResultExt` trait. These changes stem from replacing `error-chain` with `thiserror`. See #1820 (@Enselic)
+
+
+
+# v0.18.3
+
+## Bugfixes
+
+- Bump `git2` dependency to fix build with Rust 1.54, see #1761
+
+
+# v0.18.2
+
+## Features
+
+- Ignore known backup/template filename suffixes when selecting the syntax, see #1687 (@scop)
+
+## Bugfixes
+
+- Fix for a security vulnerability on Windows. Prior to this release, `bat` would execute programs called `less`/`less.exe` from the current working directory (instead of the one from `PATH`) with priority. An attacker might be able to use this by placing a malicious program in a shared directory where the user would execute `bat`. `bat` users on Windows are advised to upgrade to this version. See #1724 and #1472 (@Ry0taK).
+
+## Other
+
+- Add bash completion, see #1678 (@scop)
+- Fix Clippy lints, see #1661 (@mohamed-abdelnour)
+- Add syntax highlighting test files, see #1213 and #1668 (@mohamed-abdelnour)
+
+## Syntaxes
+
+- Upgraded Julia syntax to fix a highlighting bug, see #1692
+- Added support for `dash` syntax, see #1654 (@mohamed-abdelnour)
+- Added support for `XAML` syntax, see #1590 and #1655 (@mohamed-abdelnour)
+- Apply `DotENV` syntax also for `.env.default` and `.env.defaults` files, see #1669
+
+
+# v0.18.1
+
+## Bugfixes
+
+- Mouse support and screen clearing broken for `less` versions with minor version number (581.2), see #1629 and #1639 (@aswild)
+
+## Other
+
+- `Input::ordinary_file` and `Input::with_name` now accept `Path` rather than `OsStr` see #1571 (@matklad)
+- The `LESS` environment variable is now included in `bat --diagnostic`, see #1589 (@Enselic)
+- Increased min. required Rust version to 1.45
+
+## Syntaxes
+
+- Improved the Syslog syntax highlighting, see #1606 (@keith-hall)
+- Replaced "Advanced CSV" with a custom CSV syntax definition written especially for `bat`; see #1574 (@keith-hall)
+- Added SystemVerilog file syntax, see #1580 (@SeanMcLoughlin)
+- Added Solidity and Vyper syntax, see #1602 (@Ersikan)
+
+## New themes
+
+- Dark+ VS Code theme, see #1588 and #1598 (@PatriotRossii)
+
+
+
+# v0.18.0
+
+## Features
+
+- Use a pager when `bat --list-languages` is called, see #1394 (@stku1985)
+
+## Bugfixes
+
+- If the last line doesn't end with a newline character, don't add it if `--style=plain`, see #1438 (@Enselic)
+- Only print themes hint in interactive mode (`bat --list-themes`), see #1439 (@rsteube)
+- Make ./tests/syntax-tests/regression_test.sh work on recent versions of macOS, see #1443 (@Enselic)
+- VimL syntax highlighting fix, see #1450 (@esensar)
+- Print an 'Invalid syntax theme settings' error message if a custom theme is broken, see #614 (@Enselic)
+- If plain mode is set and wrap is not explicitly opted in, long lines will no be truncated, see #1426
+- If `PAGER` (but not `BAT_PAGER` or `--pager`) is `more` or `most`, silently use `less` instead to ensure support for colors, see #1063 (@Enselic)
+- If `PAGER` is `bat`, silently use `less` to prevent recursion. For `BAT_PAGER` or `--pager`, exit with error, see #1413 (@Enselic)
+- Manpage highlighting fix, see #1511 (@keith-hall)
+- `BAT_CONFIG_PATH` ignored by `bat` if non-existent, see #1550 (@sharkdp)
+
+## Other
+
+- Performance improvements, see #1421 (@LovecraftianHorror)
+- Added a new `--diagnostic` option to collect information for bug reports, see #1459 (@sharkdp)
+- Modified default theme colors to differentiate between a JSON key and a string value, see #1400 (@keith-hall)
+- Upped min required Rust version to 1.42
+
+## Syntaxes
+
+- Added Zig syntax, see #1470 (@paulsmith)
+- Added Lean syntax, see #1446 (@Julian)
+- Added `.resource` extension for Robot Framework files, see #1386
+- Added `gnuplot` syntax, see #1431 (@sharkdp)
+- Highlight *.pac (Proxy auto-config) files as JavaScript, see #1515 (@sharkdp)
+
+## New themes
+
+- `ansi` replaces `ansi-dark` and `ansi-light`, see #1104 and #1412 (@mk12). **Breaking change:** users that were previously using one of the `ansi-*` themes should switch to `ansi`.
+- The Gruvbox theme has been updated, see #1291 (@j0hnmeow). **Breaking change:** users that were previously using `gruvbox` or `gruvbox-white` should update and use `gruvbox-dark`/`gruvbox-light` instead.
+
+## `bat` as a library
+
+- The following `PrettyPrinter` methods have been removed (they were previously deprecated):
+   - `input_stdin_with_name`
+   - `input_from_bytes_with_name`
+   - `input_from_reader_with_name`
+   - `vcs_modification_markers` (if the `git` feature is not enabled)
+
 
 # v0.17.1
 
@@ -21,6 +152,7 @@
 
 - Running `bat` without arguments fails ("output file is also an input"), see #1396
 
+
 # v0.17.0
 
 ## Features
@@ -456,7 +588,7 @@ You can see the API documentation here: https://docs.rs/bat/
 
 - Added `BAT_CONFIG_PATH` environment variable to set a non-default path for `bat`s configuration file, see #375 (@deg4uss3r)
 
-- Allow for multiple occurences of `--style` to allow for the configuration
+- Allow for multiple occurrences of `--style` to allow for the configuration
   of styles from the config file, see #367 (@sindreij)
 
 - Allow for multiple `--line-range` arguments, see #23

CONTRIBUTING.md

@@ -8,12 +8,12 @@ Thank you for considering to contribute to `bat`!
 
 If your contribution changes the behavior of `bat` (as opposed to a typo-fix
 in the documentation), please update the [`CHANGELOG.md`](CHANGELOG.md) file
-and describe your changes. This makes the release proess much easier and
+and describe your changes. This makes the release process much easier and
 therefore helps to get your changes into a new `bat` release faster.
 
 The top of the `CHANGELOG` contains a *"unreleased"* section with a few
 subsections (Features, Bugfixes, …). Please add your entry to the subsection
-that best describes your change
+that best describes your change.
 
 Entries follow this format:
 ```

Cargo.toml

@@ -1,17 +1,13 @@
 [package]
 authors = ["David Peter <mail@david-peter.de>"]
 categories = ["command-line-utilities"]
-description="A cat(1) clone with wings."
+description = "A cat(1) clone with wings."
 homepage = "https://github.com/sharkdp/bat"
 license = "MIT/Apache-2.0"
 name = "bat"
-readme = "README.md"
 repository = "https://github.com/sharkdp/bat"
-version = "0.17.1"
-exclude = [
-    "assets/syntaxes/*",
-    "assets/themes/*",
-]
+version = "0.18.3"
+exclude = ["assets/syntaxes/*", "assets/themes/*"]
 build = "build.rs"
 edition = '2018'
 
@@ -20,17 +16,28 @@ default = ["application"]
 # Feature required for bat the application. Should be disabled when depending on
 # bat as a library.
 application = [
+    "bugreport",
+    "build-assets",
+    "git",
+    "minimal-application",
+]
+# Mainly for developers that want to iterate quickly
+# Be aware that the included features might change in the future
+minimal-application = [
     "atty",
     "clap",
-    "dirs",
-    "git",
+    "dirs-next",
     "lazy_static",
     "paging",
-    "wild",
     "regex-onig",
+    "wild",
 ]
 git = ["git2"] # Support indicating git modifications
-paging = ["shell-words"] # Support applying a pager on the output
+paging = ["shell-words", "grep-cli"] # Support applying a pager on the output
+# Add "syntect/plist-load" when https://github.com/trishume/syntect/pull/345 reaches us
+build-assets = ["syntect/yaml-load", "syntect/dump-create"]
+
+# You need to use one of these if you depend on bat as a library:
 regex-onig = ["syntect/regex-onig"] # Use the "oniguruma" regex engine
 regex-fancy = ["syntect/regex-fancy"] # Use the rust-only "fancy-regex" engine
 
@@ -38,19 +45,26 @@ regex-fancy = ["syntect/regex-fancy"] # Use the rust-only "fancy-regex" engine
 atty = { version = "0.2.14", optional = true }
 ansi_term = "^0.12.1"
 ansi_colours = "^1.0"
-console = "0.13.0"
-dirs = { version = "3.0", optional = true }
+bincode = "1.0"
+console = "0.14.1"
+flate2 = "1.0"
 lazy_static = { version = "1.4", optional = true }
+lazycell = "1.0"
+thiserror = "1.0"
 wild = { version = "2.0", optional = true }
 content_inspector = "0.2.4"
 encoding = "0.2"
 shell-words = { version = "1.0.0", optional = true }
-unicode-width = "0.1.8"
+unicode-width = "0.1.9"
 globset = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.8"
-semver = "0.11"
+semver = "1.0"
 path_abs = { version = "0.5", default-features = false }
+clircle = "0.3"
+bugreport = { version = "0.4", optional = true }
+dirs-next = { version = "2.0.0", optional = true }
+grep-cli = { version = "0.1.6", optional = true }
 
 [dependencies.git2]
 version = "0.13"
@@ -58,9 +72,9 @@ optional = true
 default-features = false
 
 [dependencies.syntect]
-version = "4.4.0"
+version = "4.6.0"
 default-features = false
-features = ["parsing", "yaml-load", "dump-load", "dump-create"]
+features = ["parsing"]
 
 [dependencies.clap]
 version = "2.33"
@@ -68,14 +82,15 @@ optional = true
 default-features = false
 features = ["suggestions", "color", "wrap_help"]
 
-[dependencies.error-chain]
-version = "0.12"
-default-features = false
-
 [dev-dependencies]
-tempdir = "0.3"
-assert_cmd = "1.0.1"
-predicates = "1.0.5"
+assert_cmd = "2.0.1"
+serial_test = "0.5.1"
+predicates = "2.0.2"
+wait-timeout = "0.2.0"
+tempfile = "3.2.0"
+
+[target.'cfg(unix)'.dev-dependencies]
+nix = "0.23.0"
 
 [build-dependencies]
 clap = { version = "2.33", optional = true }

LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2018-2020 bat-developers (https://github.com/sharkdp/bat).
+Copyright (c) 2018-2021 bat-developers (https://github.com/sharkdp/bat).
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -12,7 +12,11 @@
   <a href="#installation">Installation</a> •
   <a href="#customization">Customization</a> •
   <a href="#project-goals-and-alternatives">Project goals, alternatives</a><br>
-  [<a href="https://github.com/chinanf-boy/bat-zh">中文</a>] [<a href="doc/README-ja.md">日本語</a>] [<a href="doc/README-ko.md">한국어</a>] [<a href="doc/README-ru.md">Русский</a>]
+  [English]
+  [<a href="https://github.com/chinanf-boy/bat-zh">中文</a>]
+  [<a href="doc/README-ja.md">日本語</a>]
+  [<a href="doc/README-ko.md">한국어</a>]
+  [<a href="doc/README-ru.md">Русский</a>]
 </p>
 
 ### Syntax highlighting
@@ -94,6 +98,16 @@ bat f - g  # output 'f', then stdin, then 'g'.
 
 ### Integration with other tools
 
+#### `fzf`
+
+You can use `bat` as a previewer for [`fzf`](https://github.com/junegunn/fzf). To do this,
+use `bat`s `--color=always` option to force colorized output. You can also use `--line-range`
+option to restrict the load times for long files:
+```bash
+fzf --preview 'bat --color=always --style=numbers --line-range=:500 {}'
+```
+For more information, see [`fzf`s `README`](https://github.com/junegunn/fzf#preview-window).
+
 #### `find` or `fd`
 
 You can use the `-exec` option of `find` to preview all search results with `bat`:
@@ -163,6 +177,7 @@ bat main.cpp | xclip
 export MANPAGER="sh -c 'col -bx | bat -l man -p'"
 man 2 select
 ```
+(replace `bat` by `batcat` if you are on Debian or Ubuntu)
 
 It might also be necessary to set `MANROFFOPT="-c"` if you experience
 formatting problems.
@@ -180,15 +195,12 @@ The [`prettybat`](https://github.com/eth-p/bat-extras/blob/master/doc/prettybat.
 
 ## Installation
 
-[![Packaging status](https://repology.org/badge/vertical-allrepos/bat.svg)](https://repology.org/project/bat/versions)
+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat-cat.svg)](https://repology.org/project/bat-cat/versions)
 
 ### On Ubuntu (using `apt`)
 *... and other Debian-based Linux distributions.*
 
-`bat` is making its way through the [Ubuntu](https://packages.ubuntu.com/eoan/bat) and
-[Debian](https://packages.debian.org/sid/bat) package release process, and is available
-for Ubuntu as of Eoan 19.10. On Debian `bat` is currently only available on the unstable
-"Sid" branch.
+`bat` is available on [Ubuntu since 20.04 ("Focal")](https://packages.ubuntu.com/search?keywords=bat&exact=1) and [Debian since August 2021 (Debian 11 - "Bullseye")](https://packages.debian.org/bullseye/bat).
 
 If your Ubuntu/Debian installation is new enough you can simply run:
 
@@ -196,7 +208,7 @@ If your Ubuntu/Debian installation is new enough you can simply run:
 apt install bat
 ```
 
-If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name
+**Important**: If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name
 clash with another package](https://github.com/sharkdp/bat/issues/982)). You can set up a `bat -> batcat` symlink or alias to prevent any issues that may come up because of this and to be consistent with other distributions:
 ``` bash
 mkdir -p ~/.local/bin
@@ -211,7 +223,7 @@ the most recent release of `bat`, download the latest `.deb` package from the
 [release page](https://github.com/sharkdp/bat/releases) and install it via:
 
 ```bash
-sudo dpkg -i bat_0.17.1_amd64.deb  # adapt version number and architecture
+sudo dpkg -i bat_0.18.3_amd64.deb  # adapt version number and architecture
 ```
 
 ### On Alpine Linux
@@ -240,6 +252,14 @@ You can install [the `bat` package](https://koji.fedoraproject.org/koji/packagei
 dnf install bat
 ```
 
+### On Funtoo Linux
+
+You can install [the `bat` package](https://github.com/funtoo/dev-kit/tree/1.4-release/sys-apps/bat) from dev-kit.
+
+```bash
+emerge sys-apps/bat
+```
+
 ### On Gentoo Linux
 
 You can install [the `bat` package](https://packages.gentoo.org/packages/sys-apps/bat)
@@ -256,6 +276,13 @@ You can install `bat` via xbps-install:
 xbps-install -S bat
 ```
 
+### On Termux
+
+You can install `bat` via pkg:
+```bash
+pkg install bat
+```
+
 ### On FreeBSD
 
 You can install a precompiled [`bat` package](https://www.freshports.org/textproc/bat) with pkg:
@@ -271,6 +298,14 @@ cd /usr/ports/textproc/bat
 make install
 ```
 
+### On OpenBSD
+
+You can install `bat` package using [`pkg_add(1)`](https://man.openbsd.org/pkg_add.1):
+
+```bash
+pkg_add bat
+```
+
 ### Via nix
 
 You can install `bat` using the [nix package manager](https://nixos.org/nix):
@@ -287,6 +322,11 @@ You can install `bat` with zypper:
 zypper install bat
 ```
 
+### Via snap package
+
+There is currently no recommended snap package available.
+Existing packages may be available, but are not officially supported and may contain [issues](https://github.com/sharkdp/bat/issues/1519).
+
 ### On macOS (or Linux) via Homebrew
 
 You can install `bat` with [Homebrew on MacOS](https://formulae.brew.sh/formula/bat) or [Homebrew on Linux](https://formulae.brew.sh/formula-linux/bat):
@@ -340,7 +380,7 @@ binaries are also available: look for archives with `musl` in the file name.
 
 ### From source
 
-If you want to build `bat` from source, you need Rust 1.40 or
+If you want to build `bat` from source, you need Rust 1.46 or
 higher. You can then use `cargo` to build everything:
 
 ```bash
@@ -374,12 +414,11 @@ You can also use a custom theme by following the
 
 ### 8-bit themes
 
-`bat` has four themes that always use [8-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors),
+`bat` has three themes that always use [8-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors),
 even when truecolor support is available:
 
-- `ansi-dark` looks decent on any terminal with a dark background. It uses 3-bit colors: black, red,
-  green, yellow, blue, magenta, cyan, and white.
-- `ansi-light` is like `ansi-dark`, but for terminals with a light background.
+- `ansi` looks decent on any terminal. It uses 3-bit colors: black, red, green,
+  yellow, blue, magenta, cyan, and white.
 - `base16` is designed for [base16](https://github.com/chriskempson/base16) terminal themes. It uses
   4-bit colors (3-bit colors plus bright variants) in accordance with the
   [base16 styling guidelines](https://github.com/chriskempson/base16/blob/master/styling.md).
@@ -387,10 +426,11 @@ even when truecolor support is available:
   It replaces certain bright colors with 8-bit colors from 16 to 21. **Do not** use this simply
   because you have a 256-color terminal but are not using base16-shell.
 
-Although these themes are more restricted, they have two advantages over truecolor themes:
+Although these themes are more restricted, they have three advantages over truecolor themes. They:
 
-- They harmonize better with other terminal software using 3-bit or 4-bit colors.
-- When you change your terminal theme, `bat` output already on the screen will update to match.
+- Enjoy maximum compatibility. Some terminal utilities do not support more than 3-bit colors.
+- Adapt to terminal theme changes. Even for already printed output.
+- Visually harmonize better with other terminal software.
 
 ### Output style
 
@@ -466,7 +506,7 @@ You can add new (or change existing) file name patterns using the `--map-syntax`
 command line option. The option takes an argument of the form `pattern:syntax` where
 `pattern` is a glob pattern that is matched against the file name and
 the absolute file path. The `syntax` part is the full name of a supported language
-(use `bat --list-languages` for an overview)full .
+(use `bat --list-languages` for an overview).
 
 Note: You probably want to use this option as an entry in `bat`s configuration file instead
 of passing it on the command line (see below).
@@ -484,7 +524,7 @@ Example: To open all files called `.ignore` (exact match) with the "Git Ignore"
 Example: To open all `.conf` files in subfolders of `/etc/apache2` with the "Apache Conf"
 syntax, use (this mapping is already built in):
 ```bash
--map-syntax='/etc/apache2/**/*.conf:Apache Conf'
+--map-syntax='/etc/apache2/**/*.conf:Apache Conf'
 ```
 
 ### Using a different pager
@@ -494,6 +534,8 @@ set, `less` is used by default. If you want to use a different pager, you can ei
 `PAGER` variable or set the `BAT_PAGER` environment variable to override what is specified in
 `PAGER`.
 
+**Note**: If `PAGER` is `more` or `most`, `bat` will silently use `less` instead to ensure support for colors.
+
 If you want to pass command-line arguments to the pager, you can also set them via the
 `PAGER`/`BAT_PAGER` variables:
 
@@ -573,7 +615,7 @@ Example configuration file:
 # Use italic text on the terminal (not supported on all terminals)
 --italic-text=always
 
-# Use C++ syntax for .ino files
+# Use C++ syntax for Arduino .ino files
 --map-syntax "*.ino:C++"
 ```
 
@@ -676,6 +718,11 @@ bash assets/create.sh
 cargo install --path . --locked --force
 ```
 
+If you want to build an application that uses `bat`s pretty-printing
+features as a library, check out the [the API documentation](https://docs.rs/bat/).
+Note that you have to use either `regex-onig` or `regex-fancy` as a feature
+when you depend on `bat` as a library.
+
 ## Contributing
 
 Take a look at the [`CONTRIBUTING.md`](CONTRIBUTING.md) guide.
@@ -685,6 +732,11 @@ Take a look at the [`CONTRIBUTING.md`](CONTRIBUTING.md) guide.
 - [sharkdp](https://github.com/sharkdp)
 - [eth-p](https://github.com/eth-p)
 - [keith-hall](https://github.com/keith-hall)
+- [Enselic](https://github.com/Enselic)
+
+## Security vulnerabilities
+
+Please contact [David Peter](https://david-peter.de/) via email if you want to report a vulnerability in `bat`.
 
 ## Project goals and alternatives
 
@@ -699,7 +751,7 @@ There are a lot of alternatives, if you are looking for similar programs. See
 [this document](doc/alternatives.md) for a comparison.
 
 ## License
-Copyright (c) 2018-2020 [bat-developers](https://github.com/sharkdp/bat).
+Copyright (c) 2018-2021 [bat-developers](https://github.com/sharkdp/bat).
 
 `bat` is made available under the terms of either the MIT License or the Apache License 2.0, at your option.
 

assets/completions/_bat.ps1.in

@@ -0,0 +1,92 @@
+
+using namespace System.Management.Automation
+using namespace System.Management.Automation.Language
+
+Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $commandElements = $commandAst.CommandElements
+    $command = @(
+        '{{PROJECT_EXECUTABLE}}'
+        for ($i = 1; $i -lt $commandElements.Count; $i++) {
+            $element = $commandElements[$i]
+            if ($element -isnot [StringConstantExpressionAst] -or
+                $element.StringConstantType -ne [StringConstantType]::BareWord -or
+                $element.Value.StartsWith('-')) {
+                break
+        }
+        $element.Value
+    }) -join ';'
+
+    $completions = @(switch ($command) {
+        '{{PROJECT_EXECUTABLE}}' {
+            [CompletionResult]::new('-l', 'l', [CompletionResultType]::ParameterName, 'Set the language for syntax highlighting.')
+            [CompletionResult]::new('--language', 'language', [CompletionResultType]::ParameterName, 'Set the language for syntax highlighting.')
+            [CompletionResult]::new('-H', 'H', [CompletionResultType]::ParameterName, 'Highlight lines N through M.')
+            [CompletionResult]::new('--highlight-line', 'highlight-line', [CompletionResultType]::ParameterName, 'Highlight lines N through M.')
+            [CompletionResult]::new('--file-name', 'file-name', [CompletionResultType]::ParameterName, 'Specify the name to display for a file.')
+            [CompletionResult]::new('--diff-context', 'diff-context', [CompletionResultType]::ParameterName, 'diff-context')
+            [CompletionResult]::new('--tabs', 'tabs', [CompletionResultType]::ParameterName, 'Set the tab width to T spaces.')
+            [CompletionResult]::new('--wrap', 'wrap', [CompletionResultType]::ParameterName, 'Specify the text-wrapping mode (*auto*, never, character).')
+            [CompletionResult]::new('--terminal-width', 'terminal-width', [CompletionResultType]::ParameterName, 'Explicitly set the width of the terminal instead of determining it automatically. If prefixed with ''+'' or ''-'', the value will be treated as an offset to the actual terminal width. See also: ''--wrap''.')
+            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'When to use colors (*auto*, never, always).')
+            [CompletionResult]::new('--italic-text', 'italic-text', [CompletionResultType]::ParameterName, 'Use italics in output (always, *never*)')
+            [CompletionResult]::new('--decorations', 'decorations', [CompletionResultType]::ParameterName, 'When to show the decorations (*auto*, never, always).')
+            [CompletionResult]::new('--paging', 'paging', [CompletionResultType]::ParameterName, 'Specify when to use the pager, or use `-P` to disable (*auto*, never, always).')
+            [CompletionResult]::new('--pager', 'pager', [CompletionResultType]::ParameterName, 'Determine which pager to use.')
+            [CompletionResult]::new('-m', 'm', [CompletionResultType]::ParameterName, 'Use the specified syntax for files matching the glob pattern (''*.cpp:C++'').')
+            [CompletionResult]::new('--map-syntax', 'map-syntax', [CompletionResultType]::ParameterName, 'Use the specified syntax for files matching the glob pattern (''*.cpp:C++'').')
+            [CompletionResult]::new('--theme', 'theme', [CompletionResultType]::ParameterName, 'Set the color theme for syntax highlighting.')
+            [CompletionResult]::new('--style', 'style', [CompletionResultType]::ParameterName, 'Comma-separated list of style elements to display (*auto*, full, plain, changes, header, grid, rule, numbers, snip).')
+            [CompletionResult]::new('-r', 'r', [CompletionResultType]::ParameterName, 'Only print the lines from N to M.')
+            [CompletionResult]::new('--line-range', 'line-range', [CompletionResultType]::ParameterName, 'Only print the lines from N to M.')
+            [CompletionResult]::new('-A', 'A', [CompletionResultType]::ParameterName, 'Show non-printable characters (space, tab, newline, ..).')
+            [CompletionResult]::new('--show-all', 'show-all', [CompletionResultType]::ParameterName, 'Show non-printable characters (space, tab, newline, ..).')
+            [CompletionResult]::new('-p', 'p', [CompletionResultType]::ParameterName, 'Show plain style (alias for ''--style=plain'').')
+            [CompletionResult]::new('--plain', 'plain', [CompletionResultType]::ParameterName, 'Show plain style (alias for ''--style=plain'').')
+            [CompletionResult]::new('-d', 'd', [CompletionResultType]::ParameterName, 'Only show lines that have been added/removed/modified.')
+            [CompletionResult]::new('--diff', 'diff', [CompletionResultType]::ParameterName, 'Only show lines that have been added/removed/modified.')
+            [CompletionResult]::new('-n', 'n', [CompletionResultType]::ParameterName, 'Show line numbers (alias for ''--style=numbers'').')
+            [CompletionResult]::new('--number', 'number', [CompletionResultType]::ParameterName, 'Show line numbers (alias for ''--style=numbers'').')
+            [CompletionResult]::new('-f', 'f', [CompletionResultType]::ParameterName, 'f')
+            [CompletionResult]::new('--force-colorization', 'force-colorization', [CompletionResultType]::ParameterName, 'force-colorization')
+            [CompletionResult]::new('-P', 'P', [CompletionResultType]::ParameterName, 'Alias for ''--paging=never''')
+            [CompletionResult]::new('--no-paging', 'no-paging', [CompletionResultType]::ParameterName, 'Alias for ''--paging=never''')
+            [CompletionResult]::new('--list-themes', 'list-themes', [CompletionResultType]::ParameterName, 'Display all supported highlighting themes.')
+            [CompletionResult]::new('-L', 'L', [CompletionResultType]::ParameterName, 'Display all supported languages.')
+            [CompletionResult]::new('--list-languages', 'list-languages', [CompletionResultType]::ParameterName, 'Display all supported languages.')
+            [CompletionResult]::new('-u', 'u', [CompletionResultType]::ParameterName, 'u')
+            [CompletionResult]::new('--unbuffered', 'unbuffered', [CompletionResultType]::ParameterName, 'unbuffered')
+            [CompletionResult]::new('--no-config', 'no-config', [CompletionResultType]::ParameterName, 'Do not use the configuration file')
+            [CompletionResult]::new('--no-custom-assets', 'no-custom-assets', [CompletionResultType]::ParameterName, 'Do not load custom assets')
+            [CompletionResult]::new('--config-file', 'config-file', [CompletionResultType]::ParameterName, 'Show path to the configuration file.')
+            [CompletionResult]::new('--generate-config-file', 'generate-config-file', [CompletionResultType]::ParameterName, 'Generates a default configuration file.')
+            [CompletionResult]::new('--config-dir', 'config-dir', [CompletionResultType]::ParameterName, 'Show bat''s configuration directory.')
+            [CompletionResult]::new('--cache-dir', 'cache-dir', [CompletionResultType]::ParameterName, 'Show bat''s cache directory.')
+            [CompletionResult]::new('--diagnostic', 'diagnostic', [CompletionResultType]::ParameterName, 'Show diagnostic information for bug reports.')
+            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print this help message.')
+            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print this help message.')
+            [CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Show version information.')
+            [CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Show version information.')
+            [CompletionResult]::new('cache', 'cache', [CompletionResultType]::ParameterValue, 'Modify the syntax-definition and theme cache')
+            break
+        }
+        '{{PROJECT_EXECUTABLE}};cache' {
+            [CompletionResult]::new('--source', 'source', [CompletionResultType]::ParameterName, 'Use a different directory to load syntaxes and themes from.')
+            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'Use a different directory to store the cached syntax and theme set.')
+            [CompletionResult]::new('-b', 'b', [CompletionResultType]::ParameterName, 'Initialize (or update) the syntax/theme cache.')
+            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'Initialize (or update) the syntax/theme cache.')
+            [CompletionResult]::new('-c', 'c', [CompletionResultType]::ParameterName, 'Remove the cached syntax definitions and themes.')
+            [CompletionResult]::new('--clear', 'clear', [CompletionResultType]::ParameterName, 'Remove the cached syntax definitions and themes.')
+            [CompletionResult]::new('--blank', 'blank', [CompletionResultType]::ParameterName, 'Create completely new syntax and theme sets (instead of appending to the default sets).')
+            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
+            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
+            [CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
+            [CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
+            break
+        }
+    })
+
+    $completions.Where{ $_.CompletionText -like "$wordToComplete*" } |
+        Sort-Object -Property ListItemText
+}

assets/completions/bat.bash.in

@@ -0,0 +1,88 @@
+# shellcheck disable=SC2207
+
+# Requires https://github.com/scop/bash-completion
+
+_bat() {
+	local cur prev words cword split
+	_init_completion -s || return 0
+
+	if [[ ${words[1]-} == cache ]]; then
+		case $prev in
+		--source | --target)
+			_filedir -d
+			return 0
+			;;
+		esac
+		COMPREPLY=($(compgen -W "
+			--build --clear --source --target --blank --help
+		" -- "$cur"))
+		return 0
+	fi
+
+	case $prev in
+	-l | --language)
+		local IFS=$'\n'
+		COMPREPLY=($(compgen -W "$(
+			"$1" --list-languages | while IFS=: read -r lang _; do
+				printf "%s\n" "$lang"
+			done
+		)" -- "$cur"))
+		compopt -o filenames  # for escaping
+		return 0
+		;;
+	-H | --highlight-line | --diff-context | --tabs | --terminal-width | \
+	-m | --map-syntax | --style | --line-range | -h | --help | -V | \
+	--version | --diagnostic | --config-file | --config-dir | \
+	--cache-dir | --generate-config-file)
+		# argument required but no completion available, or option
+		# causes an exit
+		return 0
+		;;
+	--file-name)
+		_filedir
+		return 0
+		;;
+	--wrap)
+		COMPREPLY=($(compgen -W "auto never character" -- "$cur"))
+		return 0
+		;;
+	--color | --decorations | --paging)
+		COMPREPLY=($(compgen -W "auto never always" -- "$cur"))
+		return 0
+		;;
+	--italic-text)
+		COMPREPLY=($(compgen -W "always never" -- "$cur"))
+		return 0
+		;;
+	--pager)
+		COMPREPLY=($(compgen -c -- "$cur"))
+		return 0
+		;;
+	--theme)
+		local IFS=$'\n'
+		COMPREPLY=($(compgen -W "$("$1" --list-themes)" -- "$cur"))
+		compopt -o filenames  # for escaping
+		return 0
+		;;
+	esac
+
+	$split && return 0
+
+	if [[ $cur == -* ]]; then
+		COMPREPLY=($(compgen -W "
+			--show-all --plain --language --highlight-line
+			--file-name --diff --diff-context --tabs --wrap
+			--terminal-width --number --color --italic-text
+			--decorations --paging --pager --map-syntax --theme
+			--list-themes --style --line-range --list-languages
+			--help --version --force-colorization --unbuffered
+			--diagnostic --config-file --config-dir --cache-dir
+			--generate-config-file
+		" -- "$cur"))
+		return 0
+	fi
+
+	_filedir
+	((cword == 1)) && COMPREPLY+=($(compgen -W cache -- "$cur"))
+
+} && complete -F _bat {{PROJECT_EXECUTABLE}}

assets/completions/bat.fish.in

@@ -34,7 +34,7 @@ complete -c {{PROJECT_EXECUTABLE}} -s H -l highlight-line -x -d "<N> Highlight t
 
 complete -c {{PROJECT_EXECUTABLE}} -l italic-text -xka "always never" -d "Specify when to use ANSI sequences for italic text (default: never)" -n "not __fish_seen_subcommand_from cache"
 
-complete -c {{PROJECT_EXECUTABLE}} -s l -l language -d "Set the language for syntax highlighting" -n "not __fish_seen_subcommand_from cache" -xa "(__{{PROJECT_EXECUTABLE}}_autocomplete_languages)" 
+complete -c {{PROJECT_EXECUTABLE}} -s l -l language -d "Set the language for syntax highlighting" -n "not __fish_seen_subcommand_from cache" -xa "(__{{PROJECT_EXECUTABLE}}_autocomplete_languages)"
 
 complete -c {{PROJECT_EXECUTABLE}} -s r -l line-range -x -d "<N:M> Only print the specified range of lines for each file" -n "not __fish_seen_subcommand_from cache"
 
@@ -56,7 +56,7 @@ complete -c {{PROJECT_EXECUTABLE}} -s P -d "Disable paging. Alias for '--paging=
 
 complete -c {{PROJECT_EXECUTABLE}} -s A -l show-all -d "Show non-printable characters like space/tab/newline" -n "not __fish_seen_subcommand_from cache"
 
-complete -c {{PROJECT_EXECUTABLE}} -l style -xka "auto full plain changes header grid numbers" -d "Comma-separated list of style elements or presets to display with file contents" -n "not __fish_seen_subcommand_from cache"
+complete -c {{PROJECT_EXECUTABLE}} -l style -xka "auto full plain changes header grid rule numbers snip" -d "Comma-separated list of style elements or presets to display with file contents" -n "not __fish_seen_subcommand_from cache"
 
 complete -c {{PROJECT_EXECUTABLE}} -l tabs -x -d "<T> Set the tab width to T spaces (width of 0 passes tabs through directly)" -n "not __fish_seen_subcommand_from cache"
 

assets/completions/bat.zsh.in

@@ -44,6 +44,12 @@ _{{PROJECT_EXECUTABLE}}_main() {
         '(--style)'--style='[Comma-separated list of style elements to display]:<components>:->style'
         '(-r --line-range)'{-r+,--line-range=}'[Only print the lines from N to M]:<N\:M>...'
         '(: --list-themes --list-languages -L)'{-L,--list-languages}'[Display all supported languages]'
+        '(: --no-config)'--no-config'[Do not use the configuration file]'
+        '(: --no-custom-assets)'--no-custom-assets'[Do not load custom assets]'
+        '(: --config-dir)'--config-dir'[Show bat'"'"'s configuration directory]'
+        '(: --config-file)'--config-file'[Show path to the configuration file]'
+        '(: --generate-config-file)'--generate-config-file'[Generates a default configuration file]'
+        '(: --cache-dir)'--cache-dir'[Show bat'"'"'s cache directory]'
         '(: -)'{-h,--help}'[Print this help message]'
         '(: -)'{-V,--version}'[Show version information]'
         '*: :_files'
@@ -69,7 +75,7 @@ _{{PROJECT_EXECUTABLE}}_main() {
         ;;
 
         style)
-            _values -s , 'style' auto full plain changes header grid numbers snip
+            _values -s , 'style' auto full plain changes header grid rule numbers snip
         ;;
     esac
 }

assets/create.sh

@@ -5,7 +5,7 @@ ASSET_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 REPO_DIR="$ASSET_DIR/.."
 
 # Ensure submodules are initialized.
-function update_submodules() {
+update_submodules() {
 	local submodule
 	local submodule_prompt=unspecified
 	local submodule_path

assets/manual/bat.1.in

@@ -40,7 +40,7 @@ language names and file extensions.
 .HP
 \fB\-H\fR, \fB\-\-highlight\-line\fR <N:M>...
 .IP
-Highlight the specified line ranges with a different background color For example:
+Highlight the specified line ranges with a different background color. For example:
 .RS
 .IP "\-\-highlight\-line 40"
 highlights line 40
@@ -50,8 +50,22 @@ highlights lines 30 to 40
 highlights lines 1 to 40
 .IP "\-\-highlight\-line 40:"
 highlights lines 40 to the end of the file
+.IP "\-\-highlight\-line 30:+10"
+highlights lines 30 to 40
 .RE
 .HP
+\fB\-\-file\-name\fR <name>...
+.IP
+Specify the name to display for a file. Useful when piping data to {{PROJECT_EXECUTABLE}} from STDIN when {{PROJECT_EXECUTABLE}} does not otherwise know the filename. Note that the provided file name is also used for syntax detection.
+.HP
+\fB\-d\fR, \fB\-\-diff\fR
+.IP
+Only show lines that have been added/removed/modified with respect to the Git index. Use '\-\-diff\-context=N' to control how much context you want to see.
+.HP
+\fB\-\-diff\-context\fR <N>...
+.IP
+Include N lines of context around added/removed/modified lines when using '\-\-diff'.
+.HP
 \fB\-\-tabs\fR <T>
 .IP
 Set the tab width to T spaces. Use a width of 0 to pass tabs through directly
@@ -111,6 +125,7 @@ Map a glob pattern to an existing syntax name. The glob pattern is matched on th
 path and the filename. For example, to highlight *.build files with the Python syntax,
 use -m '*.build:Python'. To highlight files named '.myignore' with the Git Ignore
 syntax, use -m '.myignore:Git Ignore'.
+Note that the right-hand side is the *name* of the syntax, not a file extension.
 .HP
 \fB\-\-theme\fR <theme>
 .IP
@@ -129,7 +144,7 @@ Configure which elements (line numbers, file headers, grid borders, Git modifica
 of components to display (e.g. 'numbers,changes,grid') or a pre\-defined style ('full').
 To set a default style, add the '\-\-style=".."' option to the configuration file or
 export the BAT_STYLE environment variable (e.g.: export BAT_STYLE=".."). Possible
-values: *auto*, full, plain, changes, header, grid, rule, numbers, snip.
+values: *full*, auto, plain, changes, header, grid, rule, numbers, snip.
 .HP
 \fB\-r\fR, \fB\-\-line\-range\fR <N:M>...
 .IP
@@ -141,6 +156,8 @@ prints lines 30 to 40
 prints lines 1 to 40
 .IP "\-\-line\-range 40:"
 prints lines 40 to the end of the file
+.IP "\-\-line\-range 30:+10"
+prints lines 30 to 40
 .RE
 .HP
 \fB\-L\fR, \fB\-\-list\-languages\fR
@@ -176,6 +193,10 @@ is dependent on your operating system. To get the default path for your system,
 
 Alternatively, you can use the BAT_CONFIG_PATH environment variable to point {{PROJECT_EXECUTABLE}} to a non-default
 location of the configuration file.
+
+To generate a default configuration file, call:
+
+\fB{{PROJECT_EXECUTABLE}} --generate-config-file\fR
 .SH "ADDING CUSTOM LANGUAGES"
 {{PROJECT_EXECUTABLE}} supports Sublime Text \fB.sublime-syntax\fR language files, and can be
 customized to add additional languages to your local installation. To do this, add the \fB.sublime-syntax\fR language
@@ -201,7 +222,7 @@ git clone https://github.com/tellnobody1/sublime-purescript-syntax
 
 Once the cache is built, the new language will be visible in `\fB{{PROJECT_EXECUTABLE}} --list-languages\fR`.
 .br
-If you ever want to remove the custom languages, you can clear the cache with `\fB{{PROJECT_EXECUTABLE}} cache --clear\fR`. 
+If you ever want to remove the custom languages, you can clear the cache with `\fB{{PROJECT_EXECUTABLE}} cache --clear\fR`.
 
 .SH "ADDING CUSTOM THEMES"
 Similarly to custom languages, {{PROJECT_EXECUTABLE}} supports Sublime Text \fB.tmTheme\fR themes.

assets/patches/Groff.sublime-syntax.patch

@@ -0,0 +1,16 @@
+diff --git syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax
+index 57834af..6648664 100644
+--- syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax	
++++ syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax	
+@@ -4,9 +4,9 @@
+ #   - man-pages(7)
+ #   - groff(7)
+ ---
+-name: Man Page (groff/troff)
++name: Groff/troff
+ scope: text.groff
+-file_extensions: [man, groff, troff, '1', '2', '3', '4', '5', '6', '7']
++file_extensions: [groff, troff, '1', '2', '3', '4', '5', '6', '7', '8', '9']
+ 
+ contexts:
+   main:

assets/patches/Markdown.sublime-syntax.patch

@@ -1,5 +1,5 @@
 diff --git syntaxes/01_Packages/Markdown/Markdown.sublime-syntax syntaxes/01_Packages/Markdown/Markdown.sublime-syntax
-index 19dc685d..6afd87ae 100644
+index 19dc685d..44440c7f 100644
 --- syntaxes/01_Packages/Markdown/Markdown.sublime-syntax
 +++ syntaxes/01_Packages/Markdown/Markdown.sublime-syntax
 @@ -24,7 +24,6 @@ variables:
@@ -166,3 +166,12 @@ index 19dc685d..6afd87ae 100644
      - match: ^\s*$\n?
        scope: invalid.illegal.non-terminated.bold-italic.markdown
        pop: true
+@@ -1152,7 +1110,7 @@ contexts:
+     - match: |-
+          (?x)
+           {{fenced_code_block_start}}
+-          ((?i:rust))
++          ((?i:rust|rs))
+           {{fenced_code_block_trailing_infostring_characters}}
+       captures:
+         0: meta.code-fence.definition.begin.rust.markdown-gfm

assets/patches/Monokai-Extended.tmTheme.patch

@@ -0,0 +1,36 @@
+diff --git themes/sublime-monokai-extended/Monokai\ Extended.tmTheme themes/sublime-monokai-extended/Monokai\ Extended.tmTheme
+index 9c2aa3e..180cbbf 100644
+--- themes/sublime-monokai-extended/Monokai Extended.tmTheme	
++++ themes/sublime-monokai-extended/Monokai Extended.tmTheme	
+@@ -810,11 +810,11 @@
+       <key>name</key>
+       <string>JSON String</string>
+       <key>scope</key>
+-      <string>meta.structure.dictionary.json string.quoted.double.json</string>
++      <string>meta.mapping.key.json string.quoted.double.json, punctuation.separator.sequence.csv</string>
+       <key>settings</key>
+       <dict>
+         <key>foreground</key>
+-        <string>#cfcfc2</string>
++        <string>#fd971f</string>
+       </dict>
+     </dict>
+     <dict>
+@@ -1027,7 +1027,7 @@
+       <key>name</key>
+       <string>Invalid</string>
+       <key>scope</key>
+-      <string>invalid</string>
++      <string>invalid, markup.error</string>
+       <key>settings</key>
+       <dict>
+         <key>background</key>
+@@ -1042,7 +1042,7 @@
+       <key>name</key>
+       <string>Invalid deprecated</string>
+       <key>scope</key>
+-      <string>invalid.deprecated</string>
++      <string>invalid.deprecated, markup.warning</string>
+       <key>settings</key>
+       <dict>
+         <key>background</key>

assets/patches/Python.sublime-syntax.patch

@@ -0,0 +1,15 @@
+diff --git syntaxes/01_Packages/Python/Python.sublime-syntax syntaxes/01_Packages/Python/Python.sublime-syntax
+index 2acd86d8..86257f7b 100644
+--- syntaxes/01_Packages/Python/Python.sublime-syntax
++++ syntaxes/01_Packages/Python/Python.sublime-syntax
+@@ -988,10 +988,6 @@ contexts:
+         - match: \}
+           scope: punctuation.section.mapping-or-set.end.python
+           set: after-expression
+-        - match: (?={{simple_expression}}:|\s*\*\*)
+-          set: inside-dictionary
+-        - match: (?={{simple_expression}}[,}]|\s*\*)
+-          set: inside-set
+         - match: ','
+           scope: punctuation.separator.set.python
+           set: inside-set

assets/patches/ShellScript.sublime-syntax.patch

@@ -1,8 +1,8 @@
 diff --git syntaxes/01_Packages/ShellScript/Bash.sublime-syntax syntaxes/01_Packages/ShellScript/Bash.sublime-syntax
-index e973e319..a703cef8 100644
+index e973e319..07c170a7 100644
 --- syntaxes/01_Packages/ShellScript/Bash.sublime-syntax
 +++ syntaxes/01_Packages/ShellScript/Bash.sublime-syntax
-@@ -30,8 +30,8 @@ file_extensions:
+@@ -30,12 +30,12 @@ file_extensions:
    - .zshenv
    - .zshrc
    - PKGBUILD  # https://jlk.fjfi.cvut.cz/arch/manpages/man/PKGBUILD.5
@@ -13,3 +13,8 @@ index e973e319..a703cef8 100644
  
  first_line_match: |
    (?x)
+-    ^\#! .* \b(bash|zsh|sh|tcsh|ash)\b
++    ^\#! .* \b(bash|zsh|sh|tcsh|ash|dash)\b
+   | ^\# \s* -\*- [^*]* mode: \s* shell-script [^*]* -\*-
+ 
+ #-------------------------------------------------------------------------------

assets/patches/XML.sublime-syntax.patch

@@ -0,0 +1,12 @@
+diff --git syntaxes/01_Packages/XML/XML.sublime-syntax syntaxes/01_Packages/XML/XML.sublime-syntax
+index ad7d9c87..af4a00f0 100644
+--- syntaxes/01_Packages/XML/XML.sublime-syntax
++++ syntaxes/01_Packages/XML/XML.sublime-syntax
+@@ -12,6 +12,7 @@ file_extensions:
+   - rss
+   - opml
+   - svg
++  - xaml
+ first_line_match: |-
+     (?x:
+       ^(?:

assets/syntaxes/02_Extra/CSV.sublime-syntax

@@ -1,46 +1,78 @@
 %YAML 1.2
 ---
-# http://www.sublimetext.com/docs/3/syntax.html
-name: Advanced CSV
+# See http://www.sublimetext.com/docs/3/syntax.html
+name: Comma Separated Values
 file_extensions:
   - csv
   - tsv
-scope: text.advanced_csv
+scope: text.csv
+variables:
+  field_separator: (?:[,;\t])
+  record_separator: (?:$\n?)
 contexts:
+  prototype:
+    - match: (?={{record_separator}})
+      pop: true
+  fields:
+    - match: ''
+      push:
+        - field_or_record_separator
+        - field4
+        - field_or_record_separator
+        - field3
+        - field_or_record_separator
+        - field2
+        - field_or_record_separator
+        - field1
   main:
-    - match: (\")
-      captures:
-        1: string.quoted.double.advanced_csv
-      push:
-        - meta_scope: meta.quoted.advanced_csv
-        - match: (\")
-          captures:
-            1: string.quoted.double.advanced_csv
-          pop: true
-        - include: main
-    - match: '(\[([+-]?\d*)(\:)?([+-]?\d*)(\,)?([+-]?\d*)(\:)?([+-]?\d*)\])?\s*([<>v^])?\s*(=)'
-      captures:
-        1: keyword.operator.advanced_csv
-        2: constant.numeric.formula.advanced_csv
-        4: constant.numeric.formula.advanced_csv
-        6: constant.numeric.formula.advanced_csv
-        8: constant.numeric.formula.advanced_csv
-        9: keyword.operator.advanced_csv
-        10: keyword.operator.advanced_csv
-      push:
-        - meta_scope: meta.range.advanced_csv
-        - match: (?=(\")|$)
-          pop: true
-        - include: scope:source.python
-    - match: '(?<=^|,|\s|\")([0-9.eE+-]+)(?=$|,|\s|\")'
-      scope: meta.number.advanced_csv
-      captures:
-        1: constant.numeric.advanced_csv
-    - match: '(?<=^|,|\s|\")([^, \t\"]+)(?=$|,|\s|\")'
-      scope: meta.nonnumber.advanced_csv
-      captures:
-        1: storage.type.advanced_csv
-    - match: (\,)
-      scope: meta.delimiter.advanced_csv
-      captures:
-        1: keyword.operator.advanced_csv
+    - meta_include_prototype: false
+    - match: '^'
+      set: fields
+
+  field_or_record_separator:
+    - meta_include_prototype: false
+    - match: '{{record_separator}}'
+      scope: punctuation.terminator.record.csv
+      pop: true
+    - match: '{{field_separator}}'
+      scope: punctuation.separator.sequence.csv
+      pop: true
+
+  field_contents:
+    - match: '"'
+      scope: punctuation.definition.string.begin.csv
+      push: double_quoted_string
+
+    - match: (?={{field_separator}}|{{record_separator}})
+      pop: true
+
+  double_quoted_string:
+    - meta_include_prototype: false
+    - meta_scope: string.quoted.double.csv
+    - match: '""'
+      scope: constant.character.escape.csv
+    - match: '"'
+      scope: punctuation.definition.string.end.csv
+      pop: true
+
+  field1:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-1.csv support.type
+        - include: field_contents
+  field2:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-2.csv support.function
+        - include: field_contents
+  field3:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-3.csv constant.numeric
+        - include: field_contents
+  field4:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-4.csv keyword.operator
+        - include: field_contents
+

assets/syntaxes/02_Extra/DotENV.sublime-syntax

@@ -4,7 +4,6 @@
 name: DotENV
 file_extensions:
   - .env
-  - .envrc
   - .env.dist
   - .env.local
   - .env.sample
@@ -19,8 +18,11 @@ file_extensions:
   - .env.production
   - .env.production.local
   - .env.dusk.local
-  - .flaskenv
   - .env.staging
+  - .env.default
+  - .env.defaults
+  - .envrc
+  - .flaskenv
 scope: source.env
 contexts:
   main:

assets/syntaxes/02_Extra/Fstab.sublime-syntax

@@ -5,6 +5,7 @@ name: fstab
 file_extensions:
   - fstab
   - crypttab
+  - mtab
 scope: source.fstab
 
 contexts:

assets/syntaxes/02_Extra/Lean.sublime-syntax

@@ -0,0 +1,125 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: Lean
+file_extensions:
+  - lean
+scope: source.lean
+contexts:
+  main:
+    - include: comments
+    - match: '\b(?<!\.)(inductive|coinductive|structure|theorem|axiom|axioms|abbreviation|lemma|definition|def|instance|class|constant)\b\s+(\{[^}]*\})?'
+      captures:
+        1: keyword.other.definitioncommand.lean
+      push:
+        - meta_scope: meta.definitioncommand.lean
+        - match: '(?=\bwith\b|\bextends\b|[:\|\(\[\{⦃<>])'
+          pop: true
+        - include: comments
+        - include: definitionName
+        - match: ","
+    - match: \b(Prop|Type|Sort)\b
+      scope: storage.type.lean
+    - match: '\battribute\b\s*\[[^\]]*\]'
+      scope: storage.modifier.lean
+    - match: '@\[[^\]]*\]'
+      scope: storage.modifier.lean
+    - match: \b(?<!\.)(private|meta|mutual|protected|noncomputable)\b
+      scope: keyword.control.definition.modifier.lean
+    - match: \b(sorry)\b
+      scope: invalid.illegal.lean
+    - match: '#print\s+(def|definition|inductive|instance|structure|axiom|axioms|class)\b'
+      scope: keyword.other.command.lean
+    - match: '#(print|eval|reduce|check|help|exit|find|where)\b'
+      scope: keyword.other.command.lean
+    - match: \b(?<!\.)(import|export|prelude|theory|definition|def|abbreviation|instance|renaming|hiding|exposing|parameter|parameters|begin|constant|constants|lemma|variable|variables|theorem|example|open|axiom|inductive|coinductive|with|structure|universe|universes|alias|precedence|reserve|postfix|prefix|infix|infixl|infixr|notation|end|using|namespace|section|local|set_option|extends|include|omit|class|classes|instances|raw|run_cmd|restate_axiom)(?!\.)\b
+      scope: keyword.other.lean
+    - match: \b(?<!\.)(calc|have|this|match|do|suffices|show|by|in|at|let|forall|fun|exists|assume|from|obtain|haveI|λ)(?!\.)\b
+      scope: keyword.other.lean
+    - match: «
+      push:
+        - meta_content_scope: entity.name.lean
+        - match: »
+          pop: true
+    - match: \b(?<!\.)(if|then|else)\b
+      scope: keyword.control.lean
+    - match: '"'
+      captures:
+        0: punctuation.definition.string.begin.lean
+      push:
+        - meta_scope: string.quoted.double.lean
+        - match: '"'
+          captures:
+            0: punctuation.definition.string.end.lean
+          pop: true
+        - match: '\\[\\"nt'']'
+          scope: constant.character.escape.lean
+        - match: '\\x[0-9A-Fa-f][0-9A-Fa-f]'
+          scope: constant.character.escape.lean
+        - match: '\\u[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]'
+          scope: constant.character.escape.lean
+    - match: '''[^\\'']'''
+      scope: string.quoted.single.lean
+    - match: '''(\\(x..|u....|.))'''
+      scope: string.quoted.single.lean
+      captures:
+        1: constant.character.escape.lean
+    - match: '`+[^\[(]\S+'
+      scope: entity.name.lean
+    - match: '\b([0-9]+|0([xX][0-9a-fA-F]+))\b'
+      scope: constant.numeric.lean
+  blockComment:
+    - match: /-
+      push:
+        - meta_scope: comment.block.lean
+        - match: "-/"
+          pop: true
+        - include: scope:source.lean.markdown
+        - include: blockComment
+  comments:
+    - include: dashComment
+    - include: docComment
+    - include: stringBlock
+    - include: modDocComment
+    - include: blockComment
+  dashComment:
+    - match: (--)
+      captures:
+        0: punctuation.definition.comment.lean
+      push:
+        - meta_scope: comment.line.double-dash.lean
+        - match: $
+          pop: true
+        - include: scope:source.lean.markdown
+  definitionName:
+    - match: '\b[^:«»\(\)\{\}[:space:]=→λ∀?][^:«»\(\)\{\}[:space:]]*'
+      scope: entity.name.function.lean
+    - match: «
+      push:
+        - meta_content_scope: entity.name.function.lean
+        - match: »
+          pop: true
+  docComment:
+    - match: /--
+      push:
+        - meta_scope: comment.block.documentation.lean
+        - match: "-/"
+          pop: true
+        - include: scope:source.lean.markdown
+        - include: blockComment
+  modDocComment:
+    - match: /-!
+      push:
+        - meta_scope: comment.block.documentation.lean
+        - match: "-/"
+          pop: true
+        - include: scope:source.lean.markdown
+        - include: blockComment
+  stringBlock:
+    - match: /-"
+      push:
+        - meta_scope: comment.block.string.lean
+        - match: '"-/'
+          pop: true
+        - include: scope:source.lean.markdown
+        - include: blockComment

assets/syntaxes/02_Extra/Manpage.sublime-syntax

@@ -59,12 +59,19 @@ contexts:
       escape: '(?={{section_heading}})'
 
   function-call:
-    - match: '\b([A-Za-z0-9_\-]+)(\()([^)]*)(\))'
+    - match: '\b([A-Za-z0-9_\-]+\.)?([A-Za-z0-9_\-]+)(\()([^)]*)(\))'
       captures:
         1: entity.name.function.man
-        2: keyword.operator.man
-        3: constant.numeric.man
-        4: keyword.operator.man
+        2: entity.name.function.man
+        3: keyword.operator.man
+        4: constant.numeric.man
+        5: keyword.operator.man
+
+  env-var:
+    - match: '(\$)(?!\d)(\w+)\b'
+      captures:
+        1: punctuation.definition.variable.man
+        2: constant.other.man
 
   options:
     # command-line options like --option=value, --some-flag, or -x
@@ -86,6 +93,7 @@ contexts:
           pop: true
     - include: function-call
     - include: c-code
+    - include: env-var
 
   expect-command-line-option:
     - match: '[A-Za-z0-9-]+'

assets/syntaxes/02_Extra/Racket.sublime-syntax

@@ -0,0 +1,52 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: Racket
+file_extensions:
+  - rkt
+scope: source.racket
+contexts:
+  main:
+    - match: '[^\\](\"[^\"]*\")'
+      captures:
+        1: string.quoted.double.source.racket
+    - match: '\((define)\s+([a-zA-Z0-9_\-?\+^]+)\s*'
+      scope: meta.variable.source.racket
+      captures:
+        1: keyword.source.racket
+        2: entity.name.variable.source.racket
+    - match: '\((define)\s+\(([a-zA-Z0-9_\-?\+^]+)\s*'
+      scope: meta.function.source.racket
+      captures:
+        1: keyword.source.racket
+        2: entity.name.function
+    - match: '\((struct)\s+([a-zA-Z0-9_\-?\+^]+)\s+'
+      scope: meta.struct.source.racket
+      captures:
+        1: keyword.source.racket
+        2: entity.name.type
+    - match: '[\s\(](if|lambda|cond|define|type-case|let|letrec|let!|\#lang|require|test|else|first|rest|define-type|define-type-alias|define-struct|not|local|error|lang)[\s\)]'
+      scope: meta.keywords.source.racket
+      captures:
+        1: keyword.source.racket
+    - match: '[\s\(](true|false|empty|null)[\s\)]'
+      captures:
+        1: constant.language.source.racket
+    - match: '[\s\(\[\{](#t|#true|#f|#false)[\s\)\]\}]'
+      captures:
+        1: constant.language.source.racket
+    - match: '(#\\[a-zA-Z0-9_\-?\+\.\!\"]+)'
+      captures:
+        1: constant.language.source.racket
+    - match: '\b(0|([1-9][0-9_]*))\b'
+      scope: constant.numeric.integer.source.racket
+    - match: ;
+      push:
+        - meta_scope: comment.line.documentation.source.racket
+        - match: $\n
+          pop: true
+    - match: '#\|'
+      push:
+        - meta_scope: comment.block.source.racket
+        - match: '\|#'
+          pop: true

assets/syntaxes/02_Extra/Robot.sublime-syntax

@@ -4,6 +4,7 @@
 name: Robot Framework
 file_extensions:
   - robot
+  - resource
 scope: source.robot
 contexts:
   main:

assets/syntaxes/02_Extra/Slim.sublime-syntax

@@ -0,0 +1,306 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/syntax.html
+name: Ruby Slim
+file_extensions:
+  - slim
+  - skim
+scope: text.slim
+contexts:
+  main:
+    - match: ^(\s*)(ruby):$
+      captures:
+        2: constant.language.name.ruby.filter.slim
+      push:
+        - meta_scope: text.ruby.filter.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:source.ruby
+    - match: ^(\s*)(javascript):$
+      captures:
+        2: constant.language.name.javascript.filter.slim
+      push:
+        - meta_scope: source.js.filter.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:source.js
+    - match: ^(---)\s*\n
+      captures:
+        1: storage.frontmatter.slim
+      push:
+        - meta_scope: source.yaml.meta.slim
+        - match: ^(---)\s*\n
+          captures:
+            1: storage.frontmatter.slim
+          pop: true
+        - include: scope:source.yaml
+    - match: ^(\s*)(coffee):$
+      captures:
+        2: constant.language.name.coffeescript.filter.slim
+      push:
+        - meta_scope: text.coffeescript.filter.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:source.coffee
+    - match: ^(\s*)(markdown):$
+      captures:
+        2: constant.language.name.markdown.filter.slim
+      push:
+        - meta_scope: text.markdown.filter.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:text.html.markdown
+    - match: ^(\s*)(css):$
+      captures:
+        2: constant.language.name.css.filter.slim
+      push:
+        - meta_scope: text.css.filter.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:source.css
+    - match: ^(\s*)(sass):$
+      captures:
+        2: constant.language.name.sass.filter.slim
+      push:
+        - meta_scope: text.sass.filter.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:source.sass
+    - match: ^(\s*)(scss):$
+      captures:
+        2: constant.language.name.scss.filter.slim
+      push:
+        - meta_scope: text.scss.filter.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:source.scss
+    - match: ^(\s*)(less):$
+      captures:
+        2: constant.language.name.less.filter.slim
+      push:
+        - meta_scope: text.less.filter.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:source.less
+    - match: ^(\s*)(erb):$
+      captures:
+        2: constant.language.name.erb.filter.slim
+      push:
+        - meta_scope: text.erb.filter.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:source.erb
+    - match: ^(! )($|\s.*)
+      scope: meta.prolog.slim
+      captures:
+        1: punctuation.definition.prolog.slim
+    - match: ^(\s*)(/)\s*.*$
+      captures:
+        2: comment.line.slash.slim
+      push:
+        - meta_scope: comment.block.slim
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+    - match: ^\s*(?=-)
+      push:
+        - match: $
+          pop: true
+        - include: rubyline
+    - match: (?==+|~)
+      push:
+        - match: $
+          pop: true
+        - include: rubyline
+    - include: tag-attribute
+    - include: embedded-ruby
+    - match: ^(\s*)(\||')\s*
+      comment: Verbatim text (can include HTML tags and copied lines)
+      push:
+        - match: ^(?!(\1\s)|\s*$)
+          pop: true
+        - include: scope:text.html.basic
+        - include: embedded-ruby
+    - match: '^\s*(\.|#|[-a-zA-Z0-9]+)([\w-]+)?'
+      comment: '1 - dot OR hash OR any combination of word, number; 2 - OPTIONAL any combination of word, number, dash or underscore (following a . or'
+      captures:
+        1: entity.name.tag.slim
+        2: entity.other.attribute-name.event.slim
+      push:
+        - meta_scope: meta.tag
+        - match: '$|(?!\.|#|:|-|~|/|\}|\]|\*|\s?[\*\{])'
+          captures:
+            1: entity.name.tag.slim
+            2: entity.other.attribute-name.event.slim
+          pop: true
+        - match: '(:[\w\d]+)+'
+          comment: XML
+          push:
+            - meta_scope: entity.name.tag.slim
+            - match: $|\s
+              pop: true
+        - match: '(:\s)(\.|#|[a-zA-Z0-9]+)([\w-]+)?'
+          comment: Inline HTML / 1 - colon; 2 - dot OR hash OR any combination of word, number; 3 - OPTIONAL any combination of word, number, dash or underscore (following a . or
+          captures:
+            1: punctuation.definition.tag.end.slim
+            2: entity.name.tag.slim
+            3: entity.other.attribute-name.event.slim
+          push:
+            - match: '$|(?!\.|#|=|-|~|/|\}|\]|\*|\s?[\*\{])'
+              captures:
+                1: punctuation.definition.tag.end.slim
+                2: entity.name.tag.slim
+                3: entity.other.attribute-name.event.slim
+              pop: true
+            - include: root-class-id-tag
+            - include: tag-attribute
+        - match: '(\*\{)(?=.*\}|.*\|\s*$)'
+          comment: Splat attributes
+          captures:
+            1: punctuation.section.embedded.ruby
+          push:
+            - meta_scope: source.ruby.embedded.slim
+            - match: '(\})|$|^(?!.*\|\s*$)'
+              captures:
+                1: punctuation.section.embedded.ruby
+              pop: true
+            - include: embedded-ruby
+        - include: root-class-id-tag
+        - include: rubyline
+        - match: /
+          scope: punctuation.terminator.tag.slim
+    - match: ^\s*(\\.)
+      captures:
+        1: meta.escape.slim
+    - match: ^\s*(?=\||')
+      push:
+        - match: $
+          pop: true
+        - include: embedded-ruby
+        - include: scope:text.html.basic
+    - match: '(?=<[\w\d\:]+)'
+      comment: Inline and root-level HTML tags
+      push:
+        - match: $|\/\>
+          pop: true
+        - include: scope:text.html.basic
+  continuation:
+    - match: '([\\,])\s*\n'
+      captures:
+        1: punctuation.separator.continuation.slim
+  delimited-ruby-a:
+    - match: '=\('
+      push:
+        - meta_scope: source.ruby.embedded.slim
+        - match: \)(?=( \w|$))
+          pop: true
+        - include: scope:source.ruby.rails
+  delimited-ruby-b:
+    - match: '=\['
+      push:
+        - meta_scope: source.ruby.embedded.slim
+        - match: '\](?=( \w|$))'
+          pop: true
+        - include: scope:source.ruby.rails
+  delimited-ruby-c:
+    - match: '=\{'
+      push:
+        - meta_scope: source.ruby.embedded.slim
+        - match: '\}(?=( \w|$))'
+          pop: true
+        - include: scope:source.ruby.rails
+  embedded-ruby:
+    - match: '(?<!\\)#\{{1,2}'
+      captures:
+        0: punctuation.section.embedded.ruby
+      push:
+        - meta_scope: source.ruby.embedded.html
+        - match: '\}{1,2}'
+          captures:
+            0: punctuation.section.embedded.ruby
+          pop: true
+        - include: scope:source.ruby.rails
+  entities:
+    - match: '(&)([a-zA-Z0-9]+|#[0-9]+|#x[0-9a-fA-F]+)(;)'
+      scope: constant.character.entity.html
+      captures:
+        1: punctuation.definition.entity.html
+        3: punctuation.definition.entity.html
+    - match: '&'
+      scope: invalid.illegal.bad-ampersand.html
+  interpolated-ruby:
+    - match: '=(?=\b)'
+      push:
+        - meta_scope: source.ruby.embedded.html
+        - match: \s|\w$
+          pop: true
+  root-class-id-tag:
+    - match: '(\.|#)([\w\d\-]+)'
+      captures:
+        1: punctuation.separator.key-value.html
+        2: entity.other.attribute-name.html
+  rubyline:
+    - match: (==|=)(<>|><|<'|'<|<|>)?|-
+      comment: Hack to thwart Sublime's Ruby highlighter. It thinks do without a variable continues the next line (this can be muted with a / at the end of the line). For things like yields, do is unnecessary without an argument, so this hack will suffice
+      push:
+        - meta_scope: meta.line.ruby.slim
+        - meta_content_scope: source.ruby.embedded.slim
+        - match: (do\s*\n$)|(?<!\\|,|,\n|\\\n)$
+          captures:
+            1: keyword.control.start-block.ruby
+          pop: true
+        - match: '#.*$'
+          comment: Hack to let ruby comments work in this context properly
+          scope: comment.line.number-sign.ruby
+        - include: continuation
+        - include: scope:source.ruby.rails
+  string-double-quoted:
+    - match: (")(?=.*")
+      captures:
+        0: punctuation.definition.string.begin.html
+      push:
+        - meta_scope: string.quoted.double.html
+        - meta_content_scope: meta.toc-list.id.html
+        - match: '"'
+          captures:
+            0: punctuation.definition.string.end.html
+          pop: true
+        - include: embedded-ruby
+        - include: entities
+  string-single-quoted:
+    - match: (')(?=.*')
+      captures:
+        0: punctuation.definition.string.begin.html
+      push:
+        - meta_scope: string.quoted.single.html
+        - meta_content_scope: meta.toc-list.id.html
+        - match: "'"
+          captures:
+            0: punctuation.definition.string.end.html
+          pop: true
+        - include: embedded-ruby
+        - include: entities
+  tag-attribute:
+    - match: '([\w.#_-]+)(=)(?!\s)(true|false|nil)?(\s*\(|\{)?'
+      captures:
+        1: entity.other.attribute-name.event.slim
+        2: punctuation.separator.key-value.html
+        3: constant.language.slim
+      push:
+        - meta_scope: meta.attribute-with-value.slim
+        - match: '\}|\)|$'
+          captures:
+            1: entity.other.attribute-name.event.slim
+            2: punctuation.separator.key-value.html
+            3: constant.language.slim
+          pop: true
+        - include: tag-stuff
+        - include: string-double-quoted
+        - include: string-single-quoted
+  tag-stuff:
+    - include: tag-attribute
+    - include: interpolated-ruby
+    - include: delimited-ruby-a
+    - include: delimited-ruby-b
+    - include: delimited-ruby-c
+    - include: rubyline
+    - include: embedded-ruby

assets/syntaxes/02_Extra/VimL.sublime-syntax

@@ -1,91 +0,0 @@
-%YAML 1.2
----
-# http://www.sublimetext.com/docs/3/syntax.html
-name: VimL
-file_extensions:
-  - vim
-  - .vimrc
-scope: source.viml
-contexts:
-  main:
-    - include: comment
-    - include: string_quoted_double
-    - include: string_quoted_single
-    - include: string_regex
-    - include: inline_comment
-    - include: number_int
-    - include: number_hex
-    - include: keyword
-    - include: support_function
-    - include: support_variable
-    - include: support_type
-    - include: function_params
-    - include: function_definition
-    - include: function_call
-    - include: function
-    - include: variable
-    - include: expr
-  comment:
-    - match: ^\s*".*$
-      scope: comment.line.quotes.viml
-      captures:
-        1: punctuation.definition.comment.vim
-  expr:
-    - match: (\|\||&&|==(\?|#)?|(!|>|<)=(#|\?)?|(=|!)~(#|\?)?|(>|<)(#|\?)is|isnot|\.|\*|\\|%)
-      scope: storage.function.viml
-  function:
-    - match: \b(fu(n|nction)?|end(f|fu|fun|function)?)\b
-      scope: storage.function.viml
-  function_call:
-    - match: '(([sgbwtl]|)?:?[0-9a-zA-Z_#]+)(?=\()'
-      scope: support.function.any-method
-  function_definition:
-    - match: '^\s*(function)\s*!?\s+(?=(s:)?[0-9a-zA-Z_#]+\s*\()'
-      captures:
-        1: storage.function.viml
-      push:
-        - meta_scope: meta.function.viml
-        - match: (\()
-          captures:
-            1: punctuation.definition.parameters.begin.viml
-          pop: true
-        - match: "(s:)?[0-9a-zA-Z_#]+"
-          scope: entity.name.function.viml
-  function_params:
-    - match: '-\w+='
-      scope: support.type.viml
-  inline_comment:
-    - match: '(?!\$)(")(?!\{).*$\n?'
-      scope: comment.line.quotes.viml
-      captures:
-        1: punctuation.definition.comment.vim
-  keyword:
-    - match: \b(if|while|for|try|return|throw|end(if|for|while|try)?|au(g|group)|else(if|)?|do|in|catch|finally|:)\b
-      scope: keyword.control.viml
-  number_hex:
-    - match: "0x[0-9a-f]+"
-      scope: constant.numeric.hex
-  number_int:
-    - match: '-?\d+'
-      scope: constant.numeric.integer
-  string_quoted_double:
-    - match: '"(\\\\|\\"|\n[^\S\n]*\\|[^\n"])*"'
-      scope: string.quoted.double.viml
-  string_quoted_single:
-    - match: '''(''''|\n[^\S\n]*\\|[^\n''])*'''
-      scope: string.quoted.single.viml
-  string_regex:
-    - match: '/(\\\\|\\/|\n[^\S\n]*\\|[^\n/])*/'
-      scope: string.regexp.viml
-  support_function:
-    - match: \b(set(local|global)?|let|command|filetype|colorscheme|\w*map|\w*a(b|brev)?|syn|exe(c|cute)?|ec(ho|)?|au(tocmd|)?)\b
-      scope: support.function.viml
-  support_type:
-    - match: <.*?>
-      scope: support.type.viml
-  support_variable:
-    - match: '\b(am(enu|)?|(hl|inc)?search|[Bb]uf([Nn]ew[Ff]ile|[Rr]ead)?|[Ff]ile[Tt]ype)\b'
-      scope: support.variable.viml
-  variable:
-    - match: '([sSgGbBwWlLaAvV]:|@|$|&(?!&))\w*'
-      scope: variable.other.viml

assets/syntaxes/02_Extra/gnuplot.sublime-syntax

@@ -0,0 +1,182 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: gnuplot
+file_extensions:
+  - gp
+  - gpl
+  - gnuplot
+  - gnu
+  - plot
+  - plt
+scope: source.gnuplot
+contexts:
+  main:
+    - include: number
+    - include: string_single
+    - include: string_double
+    - match: '\b(for)\b\s*(\[)'
+      comment: |
+        gnuplot iteration statement.
+                    There are two forms:
+                        numeric [n = 1:2{:inc}]
+                        string based [str in "x y z"]
+                        but both can also iterate over lists etc, so this is kept loose.
+      captures:
+        1: keyword.other.iteration.gnuplot
+        2: punctuation.definition.range.begin.gnuplot
+      push:
+        - meta_scope: meta.structure.iteration.gnuplot
+        - match: '\]'
+          captures:
+            0: punctuation.definition.range.end.gnuplot
+          pop: true
+        - include: number
+        - include: operator
+        - include: string_double
+        - include: string_single
+        - match: ":"
+          scope: punctuation.separator.range.gnuplot
+        - match: '\b([a-zA-Z]\w*)\b\s*(=|in)'
+          scope: variable-assignment.range.gnuplot
+        - match: '(?i:[^\s(pi|e)\]])'
+          scope: invalid.illegal.expected-range-separator.gnuplot
+    - match: '\['
+      comment: "gnuplot range statement [a:b]. Lots of things are legal, still more make no sense!"
+      captures:
+        0: punctuation.definition.range.begin.gnuplot
+      push:
+        - meta_scope: meta.structure.range.gnuplot
+        - match: '\]'
+          captures:
+            0: punctuation.definition.range.end.gnuplot
+          pop: true
+        - include: number
+        - include: operator
+        - match: ":"
+          scope: punctuation.separator.range.gnuplot
+        - match: '(?i:[^\s(pi|e)\]])'
+          scope: invalid.illegal.expected-range-separator.gnuplot
+    - match: \\.
+      scope: constant.character.escape.gnuplot
+    - match: '(?<!\$)(#)(?!\{).*$\n?'
+      scope: comment.line.number-sign.gnuplot
+      captures:
+        1: punctuation.definition.comment.gnuplot
+    - match: for
+      comment: introduce in gnuplot 4.3.
+      scope: keyword.other.iteration.gnuplot
+    - match: \b(angles|arrow|autoscale|bars|border|boxwidth|clabel|clip|cntrparam|colorbox|contour|decimalsign|dgrid3d|dummy|encoding|fit|format|grid|hidden3d|historysize|isosamples|key|label|locale|logscale|macros|bmargin|lmargin|rmargin|tmargin|mapping|mouse|multiplot|offsets|origin|output|palette|parametric|pm3d|pointsize|polar|print|rrange|trange|urange|vrange|samples|size|style|surface|tics|ticscale|ticslevel|timestamp|timefmt|title|view|xyplane|x2data|xdata|y2data|ydata|z2data|zdata|x2label|xlabel|y2label|ylabel|z2label|zlabel|x2range|xrange|y2range|yrange|z2range|zrange|mx2tics|mxtics|my2tics|mytics|mz2tics|mztics|nomx2tics|nomxtics|nomy2tics|nomytics|nomz2tics|nomztics|nox2tics|noxtics|noy2tics|noytics|noz2tics|noztics|x2tics|xtics|y2tics|ytics|z2tics|ztics|x2dtics|x2mtics|xdtics|xmtics|y2dtics|y2mtics|ydtics|ymtics|z2dtics|z2mtics|zdtics|zmtics|x2zeroaxis|xzeroaxis|y2zeroaxis|yzeroaxis|z2zeroaxis|zeroaxis|zzeroaxis|zero|)\b
+      scope: keyword.other.setting.gnuplot
+    - match: \b(cd|call|clear|exit|plot|splot|help|load|pause|quit|fit|replot|if|FIT_LIMIT|FIT_MAXITER|FIT_START_LAMBDA|FIT_LAMBDA_FACTOR|FIT_LOG|FIT_SCRIPT|print|pwd|reread|reset|save|show|test|!|functions|var)\b
+      comment: missuse of scopes alert! Just for pretty colours
+      scope: keyword.other.command.gnuplot
+    - match: \b(abs|acos|acosh|arg|asin|asinh|atan|atan2|atanh|besj0|besj1|besy0|besy1|ceil|cos|cosh|erf|erfc|exp|floor|gamma|ibeta|igamma|imag|int|inverf|invnorm|lambertw|lgamma|log|log10|norm|rand|real|sgn|sin|sinh|sqrt|tan|tanh)\b
+      scope: support.function.gnuplot
+    - match: \b(gprintf|sprintf|strlen|strstrt|substr|system|word|words)\b
+      scope: support.function.string.gnuplot
+    - match: \b(on|off|default|inside|outside|lmargin|rmargin|tmargin|bmargin|at|left|right|center|top|bottom|center|vertical|horizontal|Left|Right|noreverse|noinvert|samplen|spacing|width|height|noautotitle|columnheader|title|noenhanced|nobox|linestyle|ls|linetype|lt|linewidth|lw)\b
+      scope: constant.other.type.gnuplot
+    - match: \b(aed512|aed767|aifm|aqua|bitgraph|cgm|corel|dumb|dxf|eepic|emf|emtex|epslatex|epson_180dpi|epson_60dpi|epson_lx800|fig|gif|gpic|hp2623A|hp2648|hp500c|hpdj|hpgl|hpljii|hppj|imagen|jpeg|kc_tek40xx|km_tek40xx|latex|mf|mif|mp|nec_cp6|okidata|pbm|pcl5|pdf|png|postscript|pslatex|pstex|pstricks|qms|regis|selanar|starc|svg|tandy_60dpi|tek40xx|tek410x|texdraw|tgif|tkcanvas|tpic|unknown|vttek)\b
+      scope: constant.other.terminal.gnuplot
+    - match: \b(u(sing)?|t(it(le)?)?|notit(le)?|w(i(th)?)?|steps|fs(teps)?|notitle|l(i(nes)?)?|linespoints|via)\b
+      scope: keyword.modifier.gnuplot
+    - match: |-
+        (?x:
+          \b # Start with a word boundary
+          (?=\b[\w$]*(\(|.*=))  # Look-ahead for a bracket or equals
+          (?![^(]*\)) # negative look ahead for a closing bracket without an opening one. This stops a from matching in f(a)
+          (         # Group variable name
+            [A-Za-z]      # A letter
+            [\w$]*      # Any word chars or $
+          )         # That is it for the name.
+        )
+      comment: user defined function / variable
+      scope: variable.other.gnuplot
+    - match: \b(if)\b
+      scope: keyword.control.gnuplot
+    - match: \b(show)\b
+      captures:
+        0: keyword.other.command.gnuplot
+      push:
+        - meta_scope: keyword.line.show.gnuplot
+        - meta_content_scope: keyword.line.show.gnuplot
+        - match: (?!\#)($\n?)
+          pop: true
+        - include: main
+    - match: \b(set)\b\s*\b(terminal|term)\b
+      captures:
+        1: keyword.other.command.gnuplot
+        2: keyword.other.setting.gnuplot
+      push:
+        - meta_scope: keyword.line.set.terminal.gnuplot
+        - match: (?!\#)($\n?)
+          pop: true
+        - include: main
+    - match: \b(set)\b\s*\b(key)\b
+      captures:
+        1: keyword.other.command.gnuplot
+        2: keyword.other.setting.gnuplot
+      push:
+        - meta_scope: keyword.line.set.key.gnuplot
+        - match: (?!\#)($\n?)
+          pop: true
+        - include: main
+    - match: \b(set|unset)\b\s*(?!\b(terminal|key|for)\b)
+      captures:
+        1: keyword.other.command.gnuplot
+        2: keyword.other.setting.gnuplot
+      push:
+        - meta_scope: keyword.line.set.gnuplot
+        - meta_content_scope: keyword.line.set.gnuplot
+        - match: (?!\#)($\n?)
+          pop: true
+        - include: main
+  number:
+    - match: |-
+        (?x:         # turn on extended mode
+            -?         # an optional minus
+            (?:
+              0        # a zero
+              |        # ...or...
+              [1-9]    # a 1-9 character
+              \d*      # followed by zero or more digits
+            )
+            (?:
+              \.       # a period
+              \d+      # followed by one or more digits
+              (?:
+                [eE]   # an e character
+                [+-]?  # followed by an option +/-
+                \d+    # followed by one or more digits
+              )?       # make exponent optional
+            )?         # make decimal portion optional
+        )
+      comment: borrowed from textmate book
+      scope: constant.numeric.gnuplot
+  operator:
+    - match: \s*(==|~=|>|>=|<|<=|&|&&|:|\||\|\||\+|-|\*|\.\*|/|\./|\\|\.\\|\^|\.\^)\s*
+      comment: Operator symbols
+      scope: keyword.operator.symbols.matlab
+  string_double:
+    - match: '"'
+      captures:
+        0: punctuation.definition.string.begin.gnuplot
+      push:
+        - meta_scope: string.quoted.double.gnuplot
+        - match: '"'
+          captures:
+            0: punctuation.definition.string.end.gnuplot
+          pop: true
+        - match: '\\[\$`"\\\n]'
+          scope: constant.character.escape.gnuplot
+  string_single:
+    - match: "'"
+      captures:
+        0: punctuation.definition.string.begin.gnuplot
+      push:
+        - meta_scope: string.quoted.single.gnuplot
+        - match: "'"
+          captures:
+            0: punctuation.definition.string.end.gnuplot
+          pop: true

assets/syntaxes/02_Extra/log.sublime-syntax

@@ -0,0 +1,116 @@
+%YAML 1.2
+---
+# See http://www.sublimetext.com/docs/3/syntax.html
+file_extensions:
+  - log
+scope: text.log
+variables:
+  ipv4_part: (?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)
+contexts:
+  main:
+    - match: (\w+)(=)
+      captures:
+        1: variable.parameter.log
+        2: keyword.operator.assignment.log
+    - match: (')([^']*)(')
+      scope: string.quoted.single.log
+      captures:
+        1: punctuation.definition.string.begin.log
+        3: punctuation.definition.string.end.log
+    - match: (")([^"]*)(")
+      scope: string.quoted.double.log
+      captures:
+        1: punctuation.definition.string.begin.log
+        3: punctuation.definition.string.end.log
+    - include: dates
+    - include: ip_addresses
+    - include: numbers
+    - match: \b(?i:fail(?:ure|ed)?|error|exception)\b
+      scope: markup.error.log
+    - match: \b(?i:warn(?:ing)?)\b
+      scope: markup.warning.log
+    #- include: scope:text.html.markdown#autolink-inet
+    - match: \b\w+:/{2,3}
+      scope: markup.underline.link.scheme.log
+      push: url-host
+  dates:
+    - match: \b\d{4}-\d{2}-\d{2}\b
+      scope: meta.date.log meta.number.integer.decimal.log constant.numeric.value.log
+    - match: \b\d{4}/\d{2}/\d{2}\b
+      scope: meta.date.log meta.number.integer.decimal.log constant.numeric.value.log
+    - match: \b(?:[01]\d|2[0-3]):(?:[0-5]\d):(?:[0-5]\d)(?:(\.)\d{3})?\b
+      scope: meta.time.log meta.number.integer.decimal.log constant.numeric.value.log
+      captures:
+        1: punctuation.separator.decimal.log
+  ip_addresses:
+    - match: \b(?=(?:{{ipv4_part}}\.){3}{{ipv4_part}}\b)
+      push:
+        - meta_scope: meta.ipaddress.v4.log meta.number.integer.decimal.log
+        - match: \d+
+          scope: constant.numeric.value.log
+        - match: \.
+          scope: punctuation.separator.sequence.log
+        - match: ''
+          pop: true
+    - match: (?=(?:\h{0,4}:){2,6}\h{1,4}\b)
+      push:
+        - meta_scope: meta.ipaddress.v6.log meta.number.integer.hexadecimal.log
+        - match: \h{1,4}
+          scope: constant.numeric.value.log
+        - match: ':'
+          scope: punctuation.separator.sequence.log
+        - match: ''
+          pop: true
+  numbers:
+    - match: \b(0x)(\h+)(?:(\.)(\h+))?\b
+      scope: meta.number.float.hexadecimal.log
+      captures:
+        1: constant.numeric.base.log
+        2: constant.numeric.value.log
+        3: constant.numeric.value.log punctuation.separator.decimal.log
+        4: constant.numeric.value.log
+    - match: \b\d+(\.)\d+\b
+      scope: meta.number.float.log constant.numeric.value.log
+      captures:
+        1: punctuation.separator.decimal.log
+    - match: \b\d+\b
+      scope: meta.number.integer.log constant.numeric.value.log
+  url-host:
+    - meta_content_scope: markup.underline.link.host.log
+    - match: \[
+      scope: punctuation.section.brackets.begin.log
+      push:
+        - match: \]
+          scope: punctuation.section.brackets.end.log
+          pop: true
+        - include: ip_addresses
+    - match: '[^:/\s]+'
+    - match: ''
+      set: url-after-host
+  url-after-host:
+    - match: (:)(\d+)
+      scope: markup.underline.link.port.log
+      captures:
+        1: punctuation.separator.mapping.port.log
+        2: constant.numeric.value.log
+    #- include: scope:text.html.markdown#url-escaped-chars
+    - match: (%)\h{2}
+      scope: markup.underline.link.path.log constant.character.escape.url.log
+      captures:
+        1: punctuation.definition.escape.log
+    # After a valid domain, zero or more non-space non-< characters may follow
+    - match: (?=[?!.,:*_~]*[\s<]) # Trailing punctuation (specifically, ?, !, ., ,, :, *, _, and ~) will not be considered part of the autolink, though they may be included in the interior of the link
+      pop: true
+    - match: \( # When an autolink ends in ), we scan the entire autolink for the total number of parentheses. If there is a greater number of closing parentheses than opening ones, we don’t consider the last character part of the autolink, in order to facilitate including an autolink inside a parenthesis
+      push:
+        - meta_scope: markup.underline.link.path.log
+        - match: (?=[?!.,:*_~]*[\s<])
+          pop: true
+        - match: \)
+          pop: true
+    - match: (?=\)[?!.,:*_~]*[\s<])
+      pop: true
+    - match: '[^?!.,:*_~\s<&()%]+|\S'
+      scope: markup.underline.link.path.log
+    - match: ''
+      pop: true

assets/syntaxes/02_Extra/syntax_test_csv.csv

@@ -0,0 +1,60 @@
+# SYNTAX TEST "CSV.sublime-syntax"
+Forename,Surname,House No.,Street,City,Postcode
+#^^^^^^^ meta.field-1
+#       ^ punctuation.separator.sequence
+#        ^^^^^^^ meta.field-2
+#               ^ punctuation.separator.sequence
+#                ^^^^^^^^^ meta.field-3
+#                         ^ punctuation.separator.sequence
+#                          ^^^^^^ meta.field-4
+#                                ^ punctuation.separator.sequence
+#                                 ^^^^ meta.field-1
+#                                     ^ punctuation.separator.sequence
+#                                      ^^^^^^^^ meta.field-2
+John,Doe,87,Logon Road,Citiville,TU43 6GH
+#^^^ meta.field-1
+#   ^ punctuation.separator.sequence
+#    ^^^ meta.field-2
+#       ^ punctuation.separator.sequence
+#        ^^ meta.field-3
+#          ^ punctuation.separator.sequence
+#           ^^^^^^^^^^ meta.field-4
+#                     ^ punctuation.separator.sequence
+#                      ^^^^^^^^^ meta.field-1
+#                               ^ punctuation.separator.sequence
+#                                ^^^^^^^^ meta.field-2
+Jane,Doe,22,"""Fun"" Street","The City, County",FA90 1XA
+#^^^ meta.field-1
+#   ^ punctuation.separator.sequence
+#    ^^^ meta.field-2
+#       ^ punctuation.separator.sequence
+#        ^^ meta.field-3
+#          ^ punctuation.separator.sequence
+#           ^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double
+#            ^^ constant.character.escape
+#                 ^^ constant.character.escape
+#                           ^ punctuation.separator.sequence
+#                            ^ meta.field-1 string.quoted.double punctuation.definition.string.begin
+#                             ^^^^^^^^^^^^^^^^^ meta.field-1 string.quoted.double
+#                                             ^ meta.field-1 string.quoted.double punctuation.definition.string.end
+#                                              ^ punctuation.separator.sequence
+#                                               ^^^^^^^^ meta.field-2
+Fred,Bloggs,"19","Street
+#^^^ meta.field-1
+#   ^ punctuation.separator.sequence
+#    ^^^^^^ meta.field-2
+#          ^ punctuation.separator.sequence
+#            ^^^ meta.field-3 string.quoted.double
+#               ^ punctuation.separator.sequence
+#                ^ meta.field-4 punctuation.definition.string.begin
+#                ^^^^^^^^ meta.field-4 string.quoted.double
+Spanning Multiple ""
+#^^^^^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double
+#                 ^^ constant.character.escape
+Lines",Citee,P0stc0d3
+#^^^^^ meta.field-4 string.quoted.double
+#    ^ meta.field-4 punctuation.definition.string.end
+#     ^ punctuation.separator.sequence
+#      ^^^^^ meta.field-1
+#           ^ punctuation.separator.sequence
+#            ^^^^^^^^ meta.field-2

assets/syntaxes/02_Extra/syntax_test_man.man

@@ -149,3 +149,14 @@ EXAMPLE
            #define POLLIN_SET  (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN |
                                 EPOLLHUP | EPOLLERR)
 #                                                  ^ source.c meta.preprocessor.macro meta.group punctuation.section.group.end
+
+ENVIRONMENT
+       $SYSTEMD_LOG_LEVEL
+#      ^ punctuation.definition.variable
+#       ^^^^^^^^^^^^^^^^^ constant.other
+           systemd reads the log level from this environment variable. This
+           can be overridden with --log-level=.
+
+SEE ALSO
+       The systemd Homepage[11], systemd-system.conf(5), locale.conf(5)
+#                                ^^^^^^^^^^^^^^^^^^^ entity.name.function

assets/syntaxes/02_Extra/syntax_test_tsv.tsv

@@ -0,0 +1,60 @@
+# SYNTAX TEST "CSV.sublime-syntax"
+Forename	Surname	House No.	Street	City	Postcode
+#^^^^^^^ meta.field-1
+#       ^ punctuation.separator.sequence
+#        ^^^^^^^ meta.field-2
+#               ^ punctuation.separator.sequence
+#                ^^^^^^^^^ meta.field-3
+#                         ^ punctuation.separator.sequence
+#                          ^^^^^^ meta.field-4
+#                                ^ punctuation.separator.sequence
+#                                 ^^^^ meta.field-1
+#                                     ^ punctuation.separator.sequence
+#                                      ^^^^^^^^ meta.field-2
+John	Doe	87	Logon Road	Citiville	TU43 6GH
+#^^^ meta.field-1
+#   ^ punctuation.separator.sequence
+#    ^^^ meta.field-2
+#       ^ punctuation.separator.sequence
+#        ^^ meta.field-3
+#          ^ punctuation.separator.sequence
+#           ^^^^^^^^^^ meta.field-4
+#                     ^ punctuation.separator.sequence
+#                      ^^^^^^^^^ meta.field-1
+#                               ^ punctuation.separator.sequence
+#                                ^^^^^^^^ meta.field-2
+Jane	Doe	22	"""Fun"" Street"	"The City	 County"	FA90 1XA
+#^^^ meta.field-1
+#   ^ punctuation.separator.sequence
+#    ^^^ meta.field-2
+#       ^ punctuation.separator.sequence
+#        ^^ meta.field-3
+#          ^ punctuation.separator.sequence
+#           ^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double
+#            ^^ constant.character.escape
+#                 ^^ constant.character.escape
+#                           ^ punctuation.separator.sequence
+#                            ^ meta.field-1 string.quoted.double punctuation.definition.string.begin
+#                             ^^^^^^^^^^^^^^^^^ meta.field-1 string.quoted.double
+#                                             ^ meta.field-1 string.quoted.double punctuation.definition.string.end
+#                                              ^ punctuation.separator.sequence
+#                                               ^^^^^^^^ meta.field-2
+Fred	Bloggs	"19"	"Street
+#^^^ meta.field-1
+#   ^ punctuation.separator.sequence
+#    ^^^^^^ meta.field-2
+#          ^ punctuation.separator.sequence
+#            ^^^ meta.field-3 string.quoted.double
+#               ^ punctuation.separator.sequence
+#                ^ meta.field-4 punctuation.definition.string.begin
+#                ^^^^^^^^ meta.field-4 string.quoted.double
+Spanning Multiple ""
+#^^^^^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double
+#                 ^^ constant.character.escape
+Lines"	Citee	P0stc0d3
+#^^^^^ meta.field-4 string.quoted.double
+#    ^ meta.field-4 punctuation.definition.string.end
+#     ^ punctuation.separator.sequence
+#      ^^^^^ meta.field-1
+#           ^ punctuation.separator.sequence
+#            ^^^^^^^^ meta.field-2

assets/syntaxes/02_Extra/syslog.sublime-syntax

@@ -0,0 +1,63 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: syslog
+file_extensions:
+  - syslog
+scope: text.log.syslog
+contexts:
+  main:
+    - match: ^(\w+\s+\d+)\s+(\d{2}:\d{2}:\d{2})
+      scope: meta.datetime.syslog constant.numeric.syslog
+      captures:
+        1: meta.date.syslog
+        2: meta.time.syslog
+      push: loghost
+    - match: ^
+      push: text
+  loghost:
+    - match: '[\w:.-]+'
+      scope: entity.other.attribute-name.loghost.syslog
+      set: process
+  process:
+    - match: ([\w.-]+)(?:(\[)(\d+)(\]))?([ :])
+      captures:
+        1: support.function.process.syslog
+        2: punctuation.separator.pid.begin.syslog
+        3: meta.pid.syslog meta.number.integer.syslog constant.numeric.value.syslog
+        4: punctuation.separator.pid.end.syslog
+        5: punctuation.separator.mapping.syslog
+      set: structured-data
+  structured-data:
+    - match: '\['
+      scope: punctuation.section.mapping.begin.syslog
+      push:
+        - match: \]
+          scope: punctuation.section.mapping.end.syslog
+          pop: true
+        - match: \w+
+          scope: variable.parameter.syslog
+        - match: =
+          scope: keyword.operator.assignment.syslog
+          push:
+            - match: '[^\s\]]+'
+              scope: constant.other.syslog
+              pop: true
+            - match: (?=\])
+              pop: true
+    - match: (?=\S)
+      set: text
+  text:
+    - match: $
+      pop: true
+    - match: '<\w+>'
+      scope: constant.language.syslog
+    - match: \b(CMD)\b\s+(\()
+      captures:
+        1: entity.name.label.syslog
+        2: punctuation.section.block.begin.syslog
+      embed: scope:source.shell.bash
+      escape: \)$
+      escape_captures:
+        0: punctuation.section.block.end.syslog
+    - include: scope:text.log

assets/themes/ansi-light.tmTheme

@@ -1,504 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-    <dict>
-        <!--
-        The colors in this theme are encoded as #RRGGBBAA where RR is an ANSI
-        palette number from 00 to 0f, and AA is the special value 00 to indicate
-        that this encoding is being used.
-        -->
-        <key>author</key>
-        <string>Template: Chris Kempson, Scheme: Mitchell Kember</string>
-        <key>name</key>
-        <string>ANSI Light</string>
-        <key>colorSpaceName</key>
-        <string>sRGB</string>
-        <key>settings</key>
-        <array>
-            <dict>
-                <key>settings</key>
-                <dict>
-                    <key>background</key>
-                    <string>#07000000</string>
-                    <key>caret</key>
-                    <string>#00000000</string>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                    <key>invisibles</key>
-                    <string>#00000000</string>
-                    <key>lineHighlight</key>
-                    <string>#00000000</string>
-                    <key>selection</key>
-                    <string>#00000000</string>
-                    <key>gutter</key>
-                    <string>#07000000</string>
-                    <key>gutterForeground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Text</string>
-                <key>scope</key>
-                <string>variable.parameter.function</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Comments</string>
-                <key>scope</key>
-                <string>comment, punctuation.definition.comment</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#02000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Punctuation</string>
-                <key>scope</key>
-                <string>punctuation.definition.string, punctuation.definition.variable, punctuation.definition.string, punctuation.definition.parameters, punctuation.definition.string, punctuation.definition.array</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Delimiters</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Operators</string>
-                <key>scope</key>
-                <string>keyword.operator</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Keywords</string>
-                <key>scope</key>
-                <string>keyword</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Variables</string>
-                <key>scope</key>
-                <string>variable</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Functions</string>
-                <key>scope</key>
-                <string>entity.name.function, meta.require, support.function.any-method</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#04000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Labels</string>
-                <key>scope</key>
-                <string>entity.name.label</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Classes</string>
-                <key>scope</key>
-                <string>support.class, entity.name.class, entity.name.type.class</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Classes</string>
-                <key>scope</key>
-                <string>meta.class</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Methods</string>
-                <key>scope</key>
-                <string>keyword.other.special-method</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#04000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Storage</string>
-                <key>scope</key>
-                <string>storage</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Support</string>
-                <key>scope</key>
-                <string>support.function</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Strings, Inherited Class</string>
-                <key>scope</key>
-                <string>string, constant.other.symbol, entity.other.inherited-class</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#02000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Integers</string>
-                <key>scope</key>
-                <string>constant.numeric</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Floats</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Boolean</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Constants</string>
-                <key>scope</key>
-                <string>constant</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Tags</string>
-                <key>scope</key>
-                <string>entity.name.tag</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#01000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Attributes</string>
-                <key>scope</key>
-                <string>entity.other.attribute-name</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Attribute IDs</string>
-                <key>scope</key>
-                <string>entity.other.attribute-name.id, punctuation.definition.entity</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#04000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Selector</string>
-                <key>scope</key>
-                <string>meta.selector</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Values</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Headings</string>
-                <key>scope</key>
-                <string>markup.heading punctuation.definition.heading, entity.name.section</string>
-                <key>settings</key>
-                <dict>
-                    <key>fontStyle</key>
-                    <string></string>
-                    <key>foreground</key>
-                    <string>#04000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Units</string>
-                <key>scope</key>
-                <string>keyword.other.unit</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Bold</string>
-                <key>scope</key>
-                <string>markup.bold, punctuation.definition.bold</string>
-                <key>settings</key>
-                <dict>
-                    <key>fontStyle</key>
-                    <string>bold</string>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Italic</string>
-                <key>scope</key>
-                <string>markup.italic, punctuation.definition.italic</string>
-                <key>settings</key>
-                <dict>
-                    <key>fontStyle</key>
-                    <string>italic</string>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Code</string>
-                <key>scope</key>
-                <string>markup.raw.inline</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#02000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Link Text</string>
-                <key>scope</key>
-                <string>string.other.link, punctuation.definition.string.end.markdown, punctuation.definition.string.begin.markdown</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#01000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Link Url</string>
-                <key>scope</key>
-                <string>meta.link</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Quotes</string>
-                <key>scope</key>
-                <string>markup.quote</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Inserted</string>
-                <key>scope</key>
-                <string>markup.inserted</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#02000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Deleted</string>
-                <key>scope</key>
-                <string>markup.deleted</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#01000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Changed</string>
-                <key>scope</key>
-                <string>markup.changed</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Colors</string>
-                <key>scope</key>
-                <string>constant.other.color</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Regular Expressions</string>
-                <key>scope</key>
-                <string>string.regexp</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Escape Characters</string>
-                <key>scope</key>
-                <string>constant.character.escape</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Embedded</string>
-                <key>scope</key>
-                <string>punctuation.section.embedded, variable.interpolation</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Illegal</string>
-                <key>scope</key>
-                <string>invalid.illegal</string>
-                <key>settings</key>
-                <dict>
-                    <key>background</key>
-                    <string>#01000000</string>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Broken</string>
-                <key>scope</key>
-                <string>invalid.broken</string>
-                <key>settings</key>
-                <dict>
-                    <key>background</key>
-                    <string>#03000000</string>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
-        </array>
-        <key>uuid</key>
-        <string>uuid</string>
-    </dict>
-</plist>

assets/themes/ansi.tmTheme

@@ -3,14 +3,14 @@
 <plist version="1.0">
     <dict>
         <!--
-        The colors in this theme are encoded as #RRGGBBAA where RR is an ANSI
-        palette number from 00 to 0f, and AA is the special value 00 to indicate
-        that this encoding is being used.
+        The colors in this theme are encoded as #RRGGBBAA where:
+        * If AA is 00, then RR is an ANSI palette number from 00 to 07.
+        * If AA is 01, the terminal's default fg/bg color is used.
         -->
         <key>author</key>
         <string>Template: Chris Kempson, Scheme: Mitchell Kember</string>
         <key>name</key>
-        <string>ANSI Dark</string>
+        <string>ANSI</string>
         <key>colorSpaceName</key>
         <string>sRGB</string>
         <key>settings</key>
@@ -19,32 +19,17 @@
                 <key>settings</key>
                 <dict>
                     <key>background</key>
-                    <string>#00000000</string>
-                    <key>caret</key>
-                    <string>#07000000</string>
+                    <string>#00000001</string>
                     <key>foreground</key>
-                    <string>#07000000</string>
-                    <key>invisibles</key>
-                    <string>#07000000</string>
-                    <key>lineHighlight</key>
-                    <string>#07000000</string>
-                    <key>selection</key>
-                    <string>#07000000</string>
+                    <string>#00000001</string>
+                    <!--
+                    Explicitly set the gutter color since bat falls back to a
+                    hardcoded DEFAULT_GUTTER_COLOR otherwise.
+                    -->
                     <key>gutter</key>
-                    <string>#00000000</string>
+                    <string>#00000001</string>
                     <key>gutterForeground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Text</string>
-                <key>scope</key>
-                <string>variable.parameter.function</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
+                    <string>#00000001</string>
                 </dict>
             </dict>
             <dict>
@@ -58,39 +43,6 @@
                     <string>#02000000</string>
                 </dict>
             </dict>
-            <dict>
-                <key>name</key>
-                <string>Punctuation</string>
-                <key>scope</key>
-                <string>punctuation.definition.string, punctuation.definition.variable, punctuation.definition.string, punctuation.definition.parameters, punctuation.definition.string, punctuation.definition.array</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Delimiters</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Operators</string>
-                <key>scope</key>
-                <string>keyword.operator</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
             <dict>
                 <key>name</key>
                 <string>Keywords</string>
@@ -102,17 +54,6 @@
                     <string>#05000000</string>
                 </dict>
             </dict>
-            <dict>
-                <key>name</key>
-                <string>Variables</string>
-                <key>scope</key>
-                <string>variable</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
             <dict>
                 <key>name</key>
                 <string>Functions</string>
@@ -146,17 +87,6 @@
                     <string>#03000000</string>
                 </dict>
             </dict>
-            <dict>
-                <key>name</key>
-                <string>Classes</string>
-                <key>scope</key>
-                <string>meta.class</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
             <dict>
                 <key>name</key>
                 <string>Methods</string>
@@ -480,8 +410,6 @@
                 <dict>
                     <key>background</key>
                     <string>#01000000</string>
-                    <key>foreground</key>
-                    <string>#07000000</string>
                 </dict>
             </dict>
             <dict>
@@ -493,8 +421,6 @@
                 <dict>
                     <key>background</key>
                     <string>#03000000</string>
-                    <key>foreground</key>
-                    <string>#00000000</string>
                 </dict>
             </dict>
         </array>

build.rs

@@ -54,11 +54,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         "assets/manual/bat.1.in",
         out_dir.join("assets/manual/bat.1"),
     )?;
+    template(
+        &variables,
+        "assets/completions/bat.bash.in",
+        out_dir.join("assets/completions/bat.bash"),
+    )?;
     template(
         &variables,
         "assets/completions/bat.fish.in",
         out_dir.join("assets/completions/bat.fish"),
     )?;
+    template(
+        &variables,
+        "assets/completions/_bat.ps1.in",
+        out_dir.join("assets/completions/_bat.ps1"),
+    )?;
     template(
         &variables,
         "assets/completions/bat.zsh.in",

diagnostics/info.sh

@@ -58,7 +58,8 @@ _bat_:run() {
 	_out "$BAT" --version
 	_out env | grep '^BAT_\|^PAGER='
 
-	local cache_dir="$($BAT --cache-dir)"
+	local cache_dir
+	cache_dir="$($BAT --cache-dir)"
 	if [[ -f "${cache_dir}/syntaxes.bin" ]]; then
 		_print_command "$BAT" "--list-languages"
 		echo "Found custom syntax set."
@@ -79,8 +80,8 @@ _bat_config_:run() {
 _bat_wrapper_:run() {
 	_bat_wrapper_:detect_wrapper() {
 		local bat="$1"
-		if file "$(which "${bat}")" | grep "text executable" &> /dev/null; then
-			_out_fence cat "$(which "${bat}")"
+		if file "$(command -v "${bat}")" | grep "text executable" &> /dev/null; then
+			_out_fence cat "$(command -v "${bat}")"
 			return
 		fi
 
@@ -104,7 +105,8 @@ _bat_wrapper_function_:run() {
 				fi ;;
 
 			*bash* | *zsh*)
-				local type="$("$SHELL" --login -i -c "type ${command}" 2>&1)"
+				local type
+				type="$("$SHELL" --login -i -c "type ${command}" 2>&1)"
 				if grep 'function' <<< "$type" &> /dev/null; then
 					_out_fence "$SHELL" --login -i -c "declare -f ${command}"
 					return

doc/README-ja.md

@@ -1,7 +1,6 @@
 <p align="center">
   <img src="logo-header.svg" alt="bat - a cat clone with wings"><br>
-  <a href="https://travis-ci.org/sharkdp/bat"><img src="https://travis-ci.org/sharkdp/bat.svg?branch=master" alt="Build Status"></a>
-  <a href="https://ci.appveyor.com/project/sharkdp/bat"><img src="https://ci.appveyor.com/api/projects/status/cptsmtbiwbnr2vhf?svg=true"></a>
+  <a href="https://github.com/sharkdp/bat/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/bat/workflows/CICD/badge.svg" alt="Build Status"></a>
   <img src="https://img.shields.io/crates/l/bat.svg" alt="license">
   <a href="https://crates.io/crates/bat"><img src="https://img.shields.io/crates/v/bat.svg?colorB=319e8c" alt="Version info"></a><br>
   シンタックスハイライトとGitとの連携機能付きの <i>cat(1)</i> クローン。
@@ -12,8 +11,12 @@
   <a href="#使い方">使い方</a> •
   <a href="#インストール">インストール</a> •
   <a href="#カスタマイズ">カスタマイズ</a> •
-  <a href="#プロジェクトの目標と既存の類似したOSS">プロジェクトの目標と既存の類似したOSS</a> •
-  翻訳 [<a href="https://github.com/chinanf-boy/bat-zh">中文</a>][<a href="README-ja.md">日本語</a>][<a href="README-ko.md">한국어</a>]
+  <a href="#プロジェクトの目標と既存の類似したOSS">プロジェクトの目標と既存の類似したOSS</a><br>
+  [<a href="../README.md">English</a>]
+  [<a href="https://github.com/chinanf-boy/bat-zh">中文</a>]
+  [日本語]
+  [<a href="README-ko.md">한국어</a>]
+  [<a href="README-ru.md">Русский</a>]
 </p>
 
 ### シンタックスハイライト
@@ -95,6 +98,17 @@ bat f - g  # output 'f', then stdin, then 'g'.
 
 ### 他のツールとの統合
 
+#### `fzf`
+
+[`fzf`](https://github.com/junegunn/fzf) のプレビューウィンドウに `bat` を使用できます。
+その場合、`bat` の `--color=always` オプションを用いてカラー出力を強制しなければなりません。
+また、`--line-range` オプションを用いることで巨大なファイルの読み込み時間を制限できます:
+```bash
+fzf --preview 'bat --color=always --style=numbers --line-range=:500 {}'
+```
+
+詳しくは [`fzf` の `README`](https://github.com/junegunn/fzf#preview-window) を参照してください。
+
 #### `find` or `fd`
 
 `find` の `-exec` オプションを使用して、`bat` ですべての検索結果をプレビューできます:
@@ -191,7 +205,7 @@ ln -s /usr/bin/batcat ~/.local/bin/bat
 batの最新リリースを実行する場合、または Ubuntu/Debian の古いバージョンを使用している場合は、[release page](https://github.com/sharkdp/bat/releases) から最新の `.deb` パッケージをダウンロードし、
 次の方法でインストールします:
 ```bash
-sudo dpkg -i bat_0.17.1_amd64.deb  # adapt version number and architecture
+sudo dpkg -i bat_0.18.3_amd64.deb  # adapt version number and architecture
 ```
 
 ### On Alpine Linux
@@ -393,7 +407,7 @@ bat --list-themes | fzf --preview="bat --theme={} --color=always /path/to/file"
 
 ### 新しい構文の追加 / 言語の定義
 
-`bat` はシンタックスハイライトのための [`syntext`](https://github.com/trishume/syntect/)
+`bat` はシンタックスハイライトのための [`syntect`](https://github.com/trishume/syntect/)
 という素晴らしいライブラリを使用しています。`syntect` は、
 [Sublime Text の `.sublime-syntax` ファイル](https://www.sublimetext.com/docs/3/syntax.html)
 とテーマを読み取ることができます。新しい構文を定義するために以下の手順を行います。
@@ -511,7 +525,7 @@ export BAT_CONFIG_PATH="/path/to/bat.conf"
 # Use italic text on the terminal (not supported on all terminals)
 --italic-text=always
 
-# Use C++ syntax for .ino files
+# Use C++ syntax for Arduino .ino files
 --map-syntax "*.ino:C++"
 
 # Use ".gitignore"-style highlighting for ".ignore" files
@@ -630,7 +644,7 @@ cargo install --locked --force
 比較については [このドキュメント](alternatives.md) を参照してください。
 
 ## ライセンス
-Copyright (c) 2018-2020 [bat-developers](https://github.com/sharkdp/bat).
+Copyright (c) 2018-2021 [bat-developers](https://github.com/sharkdp/bat).
 
 `bat` は MIT License 及び Apache License 2.0 の両方の条件の下で配布されています。
 

doc/README-ru.md

@@ -1,7 +1,6 @@
 <p align="center">
-  <img src="doc/logo-header.svg" alt="bat - a cat clone with wings"><br>
-  <a href="https://travis-ci.org/sharkdp/bat"><img src="https://travis-ci.org/sharkdp/bat.svg?branch=master" alt="Build Status"></a>
-  <a href="https://ci.appveyor.com/project/sharkdp/bat"><img src="https://ci.appveyor.com/api/projects/status/cptsmtbiwbnr2vhf/branch/master?svg=true"></a>
+  <img src="logo-header.svg" alt="bat - a cat clone with wings"><br>
+  <a href="https://github.com/sharkdp/bat/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/bat/workflows/CICD/badge.svg" alt="Build Status"></a>
   <img src="https://img.shields.io/crates/l/bat.svg" alt="license">
   <a href="https://crates.io/crates/bat"><img src="https://img.shields.io/crates/v/bat.svg?colorB=319e8c" alt="Version info"></a><br>
   Клон утилиты <i>cat(1)</i> с поддержкой выделения синтаксиса и Git
@@ -12,8 +11,12 @@
   <a href="#как-использовать">Использование</a> •
   <a href="#установка">Установка</a> •
   <a href="#кастомизация">Кастомизация</a> •
-  <a href="#цели-и-альтернативы">Цели и альтернативы </a> •
-  Перевод [<a href="https://github.com/chinanf-boy/bat-zh">中文</a>][<a href="doc/README-ja.md">日本語</a>][<a href="doc/README-ko.md">한국어</a>][<a href="doc/README-ru.md">Русский</a>]
+  <a href="#цели-и-альтернативы">Цели и альтернативы </a><br>
+  [<a href="../README.md">English]
+  [<a href="https://github.com/chinanf-boy/bat-zh">中文</a>]
+  [<a href="README-ja.md">日本語</a>]
+  [<a href="README-ko.md">한국어</a>]
+  [Русский]
 </p>
 
 ### Выделение синтаксиса
@@ -185,7 +188,7 @@ ln -s /usr/bin/batcat ~/.local/bin/bat
 [release page](https://github.com/sharkdp/bat/releases) и установить так:
 
 ```bash
-sudo dpkg -i bat_0.17.1_amd64.deb  # измените архитектуру и версию
+sudo dpkg -i bat_0.18.3_amd64.deb  # измените архитектуру и версию
 ```
 
 ### Alpine Linux
@@ -341,7 +344,7 @@ ansible-galaxy install aeimer.install_bat
 
 ### Из исходников
 
-Если вы желаете установить `bat` из исходников, вам понадобится Rust 1.40 или выше. После этого используйте `cargo`, чтобы все скомпилировать:
+Если вы желаете установить `bat` из исходников, вам понадобится Rust 1.46 или выше. После этого используйте `cargo`, чтобы все скомпилировать:
 
 ```bash
 cargo install --locked bat
@@ -434,11 +437,11 @@ export BAT_PAGER="less -RF"
  `-R`/`--RAW-CONTROL-CHARS`,
 `-F`/`--quit-if-one-screen` и `-X`/`--no-init`. Последний флаг(`-X`) используется только для `less`, чья версия раньше 530.
 
-Флаг `-R` нужен чтобы корректно воспроизвести ANSI цвета. Второй флаг (`-F`) говорит 
+Флаг `-R` нужен чтобы корректно воспроизвести ANSI цвета. Второй флаг (`-F`) говорит
 `less` чтобы тот сразу же завершился, если размер вывода меньше чем вертикальный размер терминала.
 Это удобно для небольших файлов, так как вам не надо каждый раз нажимать `q`, чтобы выйти из пейджера. Третий флаг (`-X`) нужен для того, чтобы исправить баг с `--quit-if-one-screen` в старых версиях `less`. К сожалению, это блокирует возможность использования колеса мышки.
 
-Если вы хотите все же его включить, вы можете добавить флаг `-R`. 
+Если вы хотите все же его включить, вы можете добавить флаг `-R`.
 Для `less` новее чем 530 оно должно работать из коробки.
 
 ### Темная тема
@@ -481,7 +484,7 @@ bat --generate-config-file
 # Использовать курсив (поддерживается не всеми терминалами)
 --italic-text=always
 
-# Использовать синтаксис C++ для всех .ino файлов
+# Использовать синтаксис C++ для всех Arduino .ino файлов
 --map-syntax "*.ino:C++"
 
 # Использовать синтаксик Git Ignore для всех файлов .ignore
@@ -499,7 +502,7 @@ Windows поддерживает только очень простой пейд
 ### Цвета
 
 Windows 10 поддерживает цвета и в `conhost.exe` (Command Prompt), и в PowerShell начиная с версии Windows
-[v1511](https://ru.wikipedia.org/wiki/Windows_10#Обновления и поддержка), так же как и в bash. На ранних версиях Windows вы можете использовать 
+[v1511](https://ru.wikipedia.org/wiki/Windows_10#Обновления и поддержка), так же как и в bash. На ранних версиях Windows вы можете использовать
 [Cmder](http://cmder.net/), в котором есть [ConEmu](https://conemu.github.io/).
 
 **Внимание:** Версия `less` в Git и MSYS2 воспроизводит цвета некорректно. Если у вас нет других пейджеров, мы можете отключить использование пейджеров с помощью флага `--paging=never`
@@ -587,7 +590,7 @@ cargo install --locked --force
 Есть очень много альтернатив `bat`. Смотрите [этот документ](doc/alternatives.md) для сравнения.
 
 ## Лицензия
-Copyright (c) 2018-2020 [Разработчики bat](https://github.com/sharkdp/bat).
+Copyright (c) 2018-2021 [Разработчики bat](https://github.com/sharkdp/bat).
 
 `bat` распостраняется под лицензями MIT License и Apache License 2.0 (на выбор пользователя).
 

doc/alternatives.md

@@ -9,7 +9,7 @@ if you are not looking for a program like `bat`, this comparison might not be fo
 | Drop-in `cat` replacement                    | :heavy_check_mark: [*](https://github.com/sharkdp/bat/issues/134)   | :x:                              | :x:                                                                 | (:heavy_check_mark:)                     | :x:                                                            | :x: [*](https://github.com/rstacruz/hicat/issues/6) | :x:                                                 | :x:                                                 |
 | Git integration                              | :heavy_check_mark:                                                  | :x:                              | :x:                                                                 | :x:                                      | :x:                                                            | :x:                                                 | :x:                                                 | :x:                                                 |
 | Automatic paging                             | :heavy_check_mark:                                                  | :x:                              | :x:                                                                 | :x:                                      | :x:                                                            | :heavy_check_mark:                                  | :x:                                                 | :x:                                                 |
-| Languages (circa)                            | 110                                                                 | 300                              | 200                                                                 | 7                                        | 80                                                             | 130                                                 | 30                                                  | 130                                                 |
+| Languages (circa)                            | 150                                                                 | 300                              | 200                                                                 | 7                                        | 80                                                             | 130                                                 | 30                                                  | 130                                                 |
 | Extensible (languages, themes)               | :heavy_check_mark:                                                  | (:heavy_check_mark:)             | (:heavy_check_mark:)                                                | :x:                                      | (:heavy_check_mark:)                                           | :x:                                                 | :x:                                                 | :x:                                                 |
 | Advanced highlighting (e.g. nested syntaxes) | :heavy_check_mark:                                                  | :heavy_check_mark:               | (:heavy_check_mark:) ?                                              | :x:                                      | :heavy_check_mark:                                             | :heavy_check_mark:                                  | :heavy_check_mark:                                  | :heavy_check_mark:                                  |
 | Execution time [ms] (`jquery-3.3.1.js`)      | 624                                                                 | 789                              | 400                                                                 | 80                                       | 300                                                            | 316                                                 | 157                                                 | 695                                                 |

doc/assets.md

@@ -9,22 +9,60 @@ in the `.sublime-syntax` format.
 **Important:** Before proceeding, verify that the syntax you wish to add meets the [criteria for inclusion](#Criteria-for-inclusion-of-new-syntaxes).
 
 1. Find a Sublime Text syntax for the given language, preferably in a separate Git repository
-   which can be included as a submodule (under `assets/syntaxes`).
+   which can be included as a submodule (under `assets/syntaxes`) using
+   `git submodule add <https github link> ./assets/syntaxes/02_Extra/<repo name>`, replacing
+   the contents of the angle brackets as appropriate.
 
 2. If the Sublime Text syntax is only available as a `.tmLanguage` file, open the file in
    Sublime Text and convert it to a `.sublime-syntax` file via *Tools* -> *Developer* ->
    *New Syntax from XXX.tmLanguage...*. Save the new file in the `assets/syntaxes` folder.
 
 3. Run the `assets/create.sh` script. It calls `bat cache --build` to parse all available
-   `.sublime-syntax` files and serialize them to a `syntaxes.bin` file (in this folder).
+   `.sublime-syntax` files and serialize them to a `syntaxes.bin` file.
 
 4. Re-compile `bat`. At compilation time, the `syntaxes.bin` file will be stored inside the
    `bat` binary.
 
 5. Use `bat --list-languages` to check if the new languages are available.
 
-6. If you send a pull request with your changes, please do *not* include the changed `syntaxes.bin`
-   file. A new binary cache file will be created once before every new release of `bat`.
+6. Add a syntax test for the new language. See [below](#Syntax-tests) for details.
+
+7. If you send a pull request with your changes, please do *not* include the changed `syntaxes.bin`
+   file. A new binary cache file will be created once before every new release of `bat`. This
+   avoids bloating the repository size unnecessarily.
+
+### Syntax tests
+
+`bat` has a set of syntax highlighting regression tests in `tests/syntax-tests`. The main idea is
+make sure that we do not run into issues we had in the past where either (1) syntax highlighting
+for some language is suddenly not working anymore or (2) `bat` suddenly crashes for some input (due
+to `regex` incompatibilities between `syntect` and Sublime Text).
+
+In order to add a new test file, please follow these steps (let's take "Ruby" as an example):
+
+1. Make sure that you are running the **latest version of `bat`** and that `bat` is available on
+   the path. If you are creating a syntax test for a new builtin syntax (see above), make sure that
+   your version of `bat` already has the new syntax builtin.
+2. Find an example Ruby source file or write one yourself. If possible, the file should aim to be
+   "comprehensive" (i.e. include a lot of the possible syntax), but this is not strictly necessary.
+   A simple file is better than none at all. Also, the files shouldn't be gigantic.
+3. Save the file in `tests/syntax-tests/source/Ruby` (adapt for your language). The file name could
+   be `test.rb` (adapt extension) but can also be adapted if that is necessary in order for `bat` to
+   highlight it correctly (e.g. `Makefile`).
+4. If you have copied the file from somewhere else, please make sure that the file *may* be copied
+   under the respective license and that the license is compatible with `bat`s license. If it
+   requires attribution, please add a `LICENSE.md` in the same folder with a text like this:
+    ```
+    The `test.rb` file has been added from [enter source here] under the following license:
+
+    [add license text here]
+    ```
+5. Go to `tests/syntax-tests` and run the `update.sh` Bash script. A new file should be generated
+   in the `highlighted` folder (e.g. `highlighted/Ruby/test.rb`).
+6. Use `cat` or `bat --language=txt` to display the content of this file and make sure that the
+   syntax highlighting looks correct.
+7. `git add` the new files in the `source` folder as well as the autogenerated files in the
+   `highlighted` folder.
 
 ### Troubleshooting
 
@@ -33,7 +71,7 @@ themes (`bat cache --clear`).
 
 ## Criteria for inclusion of new syntaxes
 
-* More than 10,000 downloads on packagecontrol.io/
+* More than 10,000 downloads at [Package Control](https://packagecontrol.io)
 
 ### Manual modifications
 
@@ -44,7 +82,7 @@ The following files have been manually modified after converting from a `.tmLang
 * `INI.sublime-syntax` => added `.hgrc`, `hgrc`, and `desktop` file types and support for comments after section headers
 * `Org mode.sublime-syntax` => removed `task` file type.
 * `SML.sublime_syntax` => removed `ml` file type.
-* `Robot.sublime_syntax` => changed name to "Robot Framework"
+* `Robot.sublime_syntax` => changed name to "Robot Framework", added `.resource` extension
 
 ### Non-submodule additions
 
@@ -59,3 +97,4 @@ The following files have been manually modified after converting from a `.tmLang
    https://github.com/seanjames777/SML-Language-Definition/blob/master/sml.tmLanguage
 * `Cabal.sublime_syntax` has been added manually from
   https://github.com/SublimeHaskell/SublimeHaskell/ - we don't want to include the whole submodule because it includes other syntaxes ("Haskell improved") as well.
+* `Lean.sublime-syntax` has been added manually from https://github.com/leanprover/vscode-lean/blob/master/syntaxes/lean.json via conversion.

doc/release-checklist.md

@@ -0,0 +1,58 @@
+# Release checklist
+
+## Dependencies
+
+See this page for a good overview: https://deps.rs/repo/github/sharkdp/bat
+
+- [ ] Optional: update dependencies with `cargo update`. This is also done by
+      dependabot, so it is not strictly necessary.
+- [ ] Check for outdated dependencies (`cargo outdated`) and decide for each of
+      them whether we want to (manually) upgrade. This will require changes to
+      `Cargo.toml`.
+
+## Version bump
+
+- [ ] Update version in `Cargo.toml`. Run `cargo build` to update `Cargo.lock`.
+      Make sure to `git add` the `Cargo.lock` changes as well.
+- [ ] Find the current min. supported Rust version by running
+      `grep '^\s*MIN_SUPPORTED_RUST_VERSION' .github/workflows/CICD.yml`.
+- [ ] Update the version and the min. supported Rust version in `README.md` and
+      `doc/README-*.md`.
+- [ ] Update `CHANGELOG.md`. Introduce a section for the new release and
+      prepare a new (empty) "unreleased" section at the top.
+
+## Update syntaxes and themes (build assets)
+
+- [ ] Install the latest master version (`cargo install -f --path .`) and make
+      sure that it is available on the `PATH` (`bat --version` should show the
+      new version).
+- [ ] Run `assets/create.sh` and check in the binary asset files.
+
+## Documentation
+
+- [ ] Review the `-h` and `--help` texts
+- [ ] Review the `man` page
+
+## Pre-release checks
+
+- [ ] Push all changes and wait for CI to succeed (before continuing with the
+      next section).
+- [ ] Optional: manually test the new features and command-line options. To do
+      this, install the latest `bat` version again (to include the new synaxes
+      and themes).
+- [ ] Run `cargo publish --dry-run --allow-dirty` to make sure that it will
+      succeed later (after creating the GitHub release).
+
+## Release
+
+- [ ] Create a tag and push it: `git tag vX.Y.Z; git push origin tag vX.Y.Z`.
+      This will trigger the deployment via GitHub Actions.
+- [ ] Go to https://github.com/sharkdp/bat/releases/new to create the new
+      release. Select the new tag and also use it as the release title. For the
+      release notes, copy the corresponding section from `CHANGELOG.md` and
+      possibly add additional remarks for package maintainers.
+      Publish the release.
+- [ ] Check if the binary deployment works (archives and Debian packages should
+      appear when the CI run for the Git tag has finished).
+- [ ] Publish to crates.io by running `cargo publish` in a *clean* repository.
+      The safest way to do this is to clone a fresh copy.

src/assets.rs

@@ -1,203 +1,212 @@
-use std::collections::BTreeMap;
 use std::ffi::OsStr;
-use std::fs::{self, File};
-use std::io::BufReader;
+use std::fs;
 use std::path::Path;
 
-use syntect::dumps::{dump_to_file, from_binary, from_reader};
+use lazycell::LazyCell;
+
 use syntect::highlighting::{Theme, ThemeSet};
-use syntect::parsing::{SyntaxReference, SyntaxSet, SyntaxSetBuilder};
+use syntect::parsing::{SyntaxReference, SyntaxSet};
 
 use path_abs::PathAbs;
 
-use crate::assets_metadata::AssetsMetadata;
+use crate::bat_warning;
 use crate::error::*;
-use crate::input::{InputReader, OpenedInput, OpenedInputKind};
+use crate::input::{InputReader, OpenedInput};
 use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
 
+use ignored_suffixes::*;
+use minimal_assets::*;
+use serialized_syntax_set::*;
+
+#[cfg(feature = "build-assets")]
+pub use crate::assets::build_assets::*;
+
+pub(crate) mod assets_metadata;
+#[cfg(feature = "build-assets")]
+mod build_assets;
+mod ignored_suffixes;
+mod minimal_assets;
+mod serialized_syntax_set;
+
 #[derive(Debug)]
 pub struct HighlightingAssets {
-    pub(crate) syntax_set: SyntaxSet,
-    pub(crate) theme_set: ThemeSet,
+    syntax_set_cell: LazyCell<SyntaxSet>,
+    serialized_syntax_set: SerializedSyntaxSet,
+
+    minimal_assets: MinimalAssets,
+
+    theme_set: ThemeSet,
     fallback_theme: Option<&'static str>,
 }
 
+#[derive(Debug)]
+pub struct SyntaxReferenceInSet<'a> {
+    pub syntax: &'a SyntaxReference,
+    pub syntax_set: &'a SyntaxSet,
+}
+
+/// Compress for size of ~700 kB instead of ~4600 kB at the cost of ~30% longer deserialization time
+pub(crate) const COMPRESS_SYNTAXES: bool = true;
+
+/// Compress for size of ~20 kB instead of ~200 kB at the cost of ~30% longer deserialization time
+pub(crate) const COMPRESS_THEMES: bool = true;
+
+/// Compress for size of ~400 kB instead of ~2100 kB at the cost of ~30% longer deserialization time
+pub(crate) const COMPRESS_SERIALIZED_MINIMAL_SYNTAXES: bool = true;
+
+/// Whether or not to compress the serialized form of [MinimalSyntaxes]. Shall
+/// always be `false`, because the data in
+/// [MinimalSyntaxes.serialized_syntax_sets] has already been compressed
+/// (assuming [COMPRESS_SERIALIZED_MINIMAL_SYNTAXES] is `true`). The "outer" data
+/// structures like `by_name` are tiny. If we compress, deserialization can't do
+/// efficient byte-by-byte copy of `serialized_syntax_sets`.
+pub(crate) const COMPRESS_MINIMAL_SYNTAXES: bool = false;
+
 impl HighlightingAssets {
+    fn new(
+        serialized_syntax_set: SerializedSyntaxSet,
+        minimal_syntaxes: MinimalSyntaxes,
+        theme_set: ThemeSet,
+    ) -> Self {
+        HighlightingAssets {
+            syntax_set_cell: LazyCell::new(),
+            serialized_syntax_set,
+            minimal_assets: MinimalAssets::new(minimal_syntaxes),
+            theme_set,
+            fallback_theme: None,
+        }
+    }
+
     pub fn default_theme() -> &'static str {
         "Monokai Extended"
     }
 
-    pub fn from_files(source_dir: &Path, include_integrated_assets: bool) -> Result<Self> {
-        let mut theme_set = if include_integrated_assets {
-            Self::get_integrated_themeset()
-        } else {
-            ThemeSet {
-                themes: BTreeMap::new(),
-            }
-        };
-
-        let theme_dir = source_dir.join("themes");
-
-        let res = theme_set.add_from_folder(&theme_dir);
-        if res.is_err() {
-            println!(
-                "No themes were found in '{}', using the default set",
-                theme_dir.to_string_lossy()
-            );
-        }
-
-        let mut syntax_set_builder = if !include_integrated_assets {
-            let mut builder = SyntaxSetBuilder::new();
-            builder.add_plain_text_syntax();
-            builder
-        } else {
-            Self::get_integrated_syntaxset().into_builder()
-        };
-
-        let syntax_dir = source_dir.join("syntaxes");
-        if syntax_dir.exists() {
-            syntax_set_builder.add_from_folder(syntax_dir, true)?;
-        } else {
-            println!(
-                "No syntaxes were found in '{}', using the default set.",
-                syntax_dir.to_string_lossy()
-            );
-        }
-
-        Ok(HighlightingAssets {
-            syntax_set: syntax_set_builder.build(),
-            theme_set,
-            fallback_theme: None,
-        })
-    }
-
     pub fn from_cache(cache_path: &Path) -> Result<Self> {
-        let syntax_set_path = cache_path.join("syntaxes.bin");
-        let theme_set_path = cache_path.join("themes.bin");
-
-        let syntax_set_file = File::open(&syntax_set_path).chain_err(|| {
-            format!(
-                "Could not load cached syntax set '{}'",
-                syntax_set_path.to_string_lossy()
-            )
-        })?;
-        let syntax_set: SyntaxSet = from_reader(BufReader::new(syntax_set_file))
-            .chain_err(|| "Could not parse cached syntax set")?;
-
-        let theme_set_file = File::open(&theme_set_path).chain_err(|| {
-            format!(
-                "Could not load cached theme set '{}'",
-                theme_set_path.to_string_lossy()
-            )
-        })?;
-        let theme_set: ThemeSet = from_reader(BufReader::new(theme_set_file))
-            .chain_err(|| "Could not parse cached theme set")?;
-
-        Ok(HighlightingAssets {
-            syntax_set,
-            theme_set,
-            fallback_theme: None,
-        })
-    }
-
-    fn get_integrated_syntaxset() -> SyntaxSet {
-        from_binary(include_bytes!("../assets/syntaxes.bin"))
-    }
-
-    fn get_integrated_themeset() -> ThemeSet {
-        from_binary(include_bytes!("../assets/themes.bin"))
+        Ok(HighlightingAssets::new(
+            SerializedSyntaxSet::FromFile(cache_path.join("syntaxes.bin")),
+            asset_from_cache(
+                &cache_path.join("minimal_syntaxes.bin"),
+                "minimal syntax sets",
+                COMPRESS_MINIMAL_SYNTAXES,
+            )?,
+            asset_from_cache(&cache_path.join("themes.bin"), "theme set", COMPRESS_THEMES)?,
+        ))
     }
 
     pub fn from_binary() -> Self {
-        let syntax_set = Self::get_integrated_syntaxset();
-        let theme_set = Self::get_integrated_themeset();
-
-        HighlightingAssets {
-            syntax_set,
-            theme_set,
-            fallback_theme: None,
-        }
-    }
-
-    pub fn save_to_cache(&self, target_dir: &Path, current_version: &str) -> Result<()> {
-        let _ = fs::create_dir_all(target_dir);
-        let theme_set_path = target_dir.join("themes.bin");
-        let syntax_set_path = target_dir.join("syntaxes.bin");
-
-        print!(
-            "Writing theme set to {} ... ",
-            theme_set_path.to_string_lossy()
-        );
-        dump_to_file(&self.theme_set, &theme_set_path).chain_err(|| {
-            format!(
-                "Could not save theme set to {}",
-                theme_set_path.to_string_lossy()
-            )
-        })?;
-        println!("okay");
-
-        print!(
-            "Writing syntax set to {} ... ",
-            syntax_set_path.to_string_lossy()
-        );
-        dump_to_file(&self.syntax_set, &syntax_set_path).chain_err(|| {
-            format!(
-                "Could not save syntax set to {}",
-                syntax_set_path.to_string_lossy()
-            )
-        })?;
-        println!("okay");
-
-        print!(
-            "Writing metadata to folder {} ... ",
-            target_dir.to_string_lossy()
-        );
-        AssetsMetadata::new(current_version).save_to_folder(target_dir)?;
-        println!("okay");
-
-        Ok(())
+        HighlightingAssets::new(
+            SerializedSyntaxSet::FromBinary(get_serialized_integrated_syntaxset()),
+            get_integrated_minimal_syntaxes(),
+            get_integrated_themeset(),
+        )
     }
 
     pub fn set_fallback_theme(&mut self, theme: &'static str) {
         self.fallback_theme = Some(theme);
     }
 
+    pub(crate) fn get_syntax_set(&self) -> Result<&SyntaxSet> {
+        self.syntax_set_cell
+            .try_borrow_with(|| self.serialized_syntax_set.deserialize())
+    }
+
+    /// Use [Self::get_syntaxes] instead
+    #[deprecated]
     pub fn syntaxes(&self) -> &[SyntaxReference] {
-        self.syntax_set.syntaxes()
+        self.get_syntax_set()
+            .expect(".syntaxes() is deprecated, use .get_syntaxes() instead")
+            .syntaxes()
+    }
+
+    pub fn get_syntaxes(&self) -> Result<&[SyntaxReference]> {
+        Ok(self.get_syntax_set()?.syntaxes())
+    }
+
+    fn get_theme_set(&self) -> &ThemeSet {
+        &self.theme_set
     }
 
     pub fn themes(&self) -> impl Iterator<Item = &str> {
-        self.theme_set.themes.keys().map(|s| s.as_ref())
+        self.get_theme_set().themes.keys().map(|s| s.as_ref())
     }
 
+    /// Finds a [SyntaxSet] that contains a [SyntaxReference] by its name. First
+    /// tries to find a minimal [SyntaxSet]. If none is found, returns the
+    /// [SyntaxSet] that contains all syntaxes.
+    fn get_syntax_set_by_name(&self, name: &str) -> Result<&SyntaxSet> {
+        match self.minimal_assets.get_syntax_set_by_name(name) {
+            Some(syntax_set) => Ok(syntax_set),
+            None => self.get_syntax_set(),
+        }
+    }
+
+    /// Use [Self::get_syntax_for_path] instead
+    #[deprecated]
     pub fn syntax_for_file_name(
         &self,
         file_name: impl AsRef<Path>,
         mapping: &SyntaxMapping,
     ) -> Option<&SyntaxReference> {
-        let file_name = file_name.as_ref();
-        match mapping.get_syntax_for(file_name) {
-            Some(MappingTarget::MapToUnknown) => None,
-            Some(MappingTarget::MapTo(syntax_name)) => {
-                self.syntax_set.find_syntax_by_name(syntax_name)
+        self.get_syntax_for_path(file_name, mapping)
+            .ok()
+            .map(|syntax_in_set| syntax_in_set.syntax)
+    }
+
+    /// Detect the syntax based on, in order:
+    ///  1. Syntax mappings (e.g. `/etc/profile` -> `Bourne Again Shell (bash)`)
+    ///  2. The file name (e.g. `Dockerfile`)
+    ///  3. The file name extension (e.g. `.rs`)
+    ///
+    /// When detecting syntax based on syntax mappings, the full path is taken
+    /// into account. When detecting syntax based on file name, no regard is
+    /// taken to the path of the file. Only the file name itself matters. When
+    /// detecting syntax based on file name extension, only the file name
+    /// extension itself matters.
+    ///
+    /// Returns [Error::UndetectedSyntax] if it was not possible detect syntax
+    /// based on path/file name/extension (or if the path was mapped to
+    /// [MappingTarget::MapToUnknown]). In this case it is appropriate to fall
+    /// back to other methods to detect syntax. Such as using the contents of
+    /// the first line of the file.
+    ///
+    /// Returns [Error::UnknownSyntax] if a syntax mapping exist, but the mapped
+    /// syntax does not exist.
+    pub fn get_syntax_for_path(
+        &self,
+        path: impl AsRef<Path>,
+        mapping: &SyntaxMapping,
+    ) -> Result<SyntaxReferenceInSet> {
+        let path = path.as_ref();
+        match mapping.get_syntax_for(path) {
+            Some(MappingTarget::MapToUnknown) => {
+                Err(Error::UndetectedSyntax(path.to_string_lossy().into()))
+            }
+
+            Some(MappingTarget::MapTo(syntax_name)) => self
+                .find_syntax_by_name(syntax_name)?
+                .ok_or_else(|| Error::UnknownSyntax(syntax_name.to_owned())),
+
+            None => {
+                let file_name = path.file_name().unwrap_or_default();
+                self.get_extension_syntax(file_name)?
+                    .ok_or_else(|| Error::UndetectedSyntax(path.to_string_lossy().into()))
             }
-            None => self.get_extension_syntax(file_name.as_os_str()),
         }
     }
 
     pub(crate) fn get_theme(&self, theme: &str) -> &Theme {
-        match self.theme_set.themes.get(theme) {
+        match self.get_theme_set().themes.get(theme) {
             Some(theme) => theme,
             None => {
-                if theme != "" {
-                    use ansi_term::Colour::Yellow;
-                    eprintln!(
-                        "{}: Unknown theme '{}', using default.",
-                        Yellow.paint("[bat warning]"),
-                        theme
-                    );
+                if theme == "ansi-light" || theme == "ansi-dark" {
+                    bat_warning!("Theme '{}' is deprecated, using 'ansi' instead.", theme);
+                    return self.get_theme("ansi");
                 }
-                &self.theme_set.themes[self.fallback_theme.unwrap_or_else(|| Self::default_theme())]
+                if !theme.is_empty() {
+                    bat_warning!("Unknown theme '{}', using default.", theme)
+                }
+                &self.get_theme_set().themes
+                    [self.fallback_theme.unwrap_or_else(|| Self::default_theme())]
             }
         }
     }
@@ -207,79 +216,125 @@ impl HighlightingAssets {
         language: Option<&str>,
         input: &mut OpenedInput,
         mapping: &SyntaxMapping,
-    ) -> Result<&SyntaxReference> {
+    ) -> Result<SyntaxReferenceInSet> {
         if let Some(language) = language {
-            self.syntax_set
+            let syntax_set = self.get_syntax_set_by_name(language)?;
+            return syntax_set
                 .find_syntax_by_token(language)
-                .ok_or_else(|| ErrorKind::UnknownSyntax(language.to_owned()).into())
+                .map(|syntax| SyntaxReferenceInSet { syntax, syntax_set })
+                .ok_or_else(|| Error::UnknownSyntax(language.to_owned()));
+        }
+
+        let path = input.path();
+        let path_syntax = if let Some(path) = path {
+            self.get_syntax_for_path(
+                PathAbs::new(path).map_or_else(|_| path.to_owned(), |p| p.as_path().to_path_buf()),
+                mapping,
+            )
         } else {
-            let line_syntax = self.get_first_line_syntax(&mut input.reader);
+            Err(Error::UndetectedSyntax("[unknown]".into()))
+        };
 
-            // Get the path of the file:
-            // If this was set by the metadata, that will take priority.
-            // If it wasn't, it will use the real file path (if available).
-            let path_str =
-                input
-                    .metadata
-                    .user_provided_name
-                    .as_ref()
-                    .or_else(|| match input.kind {
-                        OpenedInputKind::OrdinaryFile(ref path) => Some(path),
-                        _ => None,
-                    });
-
-            if let Some(path_str) = path_str {
-                // If a path was provided, we try and detect the syntax based on extension mappings.
-                let path = Path::new(path_str);
-                let absolute_path = PathAbs::new(path)
-                    .ok()
-                    .map(|p| p.as_path().to_path_buf())
-                    .unwrap_or_else(|| path.to_owned());
-
-                match mapping.get_syntax_for(absolute_path) {
-                    Some(MappingTarget::MapToUnknown) => line_syntax.ok_or_else(|| {
-                        ErrorKind::UndetectedSyntax(path.to_string_lossy().into()).into()
-                    }),
-
-                    Some(MappingTarget::MapTo(syntax_name)) => self
-                        .syntax_set
-                        .find_syntax_by_name(syntax_name)
-                        .ok_or_else(|| ErrorKind::UnknownSyntax(syntax_name.to_owned()).into()),
-
-                    None => {
-                        let file_name = path.file_name().unwrap_or_default();
-                        self.get_extension_syntax(file_name)
-                            .or(line_syntax)
-                            .ok_or_else(|| {
-                                ErrorKind::UndetectedSyntax(path.to_string_lossy().into()).into()
-                            })
-                    }
-                }
-            } else {
-                // If a path wasn't provided, we fall back to the detect first-line syntax.
-                line_syntax.ok_or_else(|| ErrorKind::UndetectedSyntax("[unknown]".into()).into())
-            }
+        match path_syntax {
+            // If a path wasn't provided, or if path based syntax detection
+            // above failed, we fall back to first-line syntax detection.
+            Err(Error::UndetectedSyntax(path)) => self
+                .get_first_line_syntax(&mut input.reader)?
+                .ok_or(Error::UndetectedSyntax(path)),
+            _ => path_syntax,
         }
     }
 
-    fn get_extension_syntax(&self, file_name: &OsStr) -> Option<&SyntaxReference> {
-        self.syntax_set
-            .find_syntax_by_extension(file_name.to_str().unwrap_or_default())
-            .or_else(|| {
-                self.syntax_set.find_syntax_by_extension(
-                    Path::new(file_name)
-                        .extension()
-                        .and_then(|x| x.to_str())
-                        .unwrap_or_default(),
-                )
-            })
+    pub(crate) fn find_syntax_by_name(
+        &self,
+        syntax_name: &str,
+    ) -> Result<Option<SyntaxReferenceInSet>> {
+        let syntax_set = self.get_syntax_set()?;
+        Ok(syntax_set
+            .find_syntax_by_name(syntax_name)
+            .map(|syntax| SyntaxReferenceInSet { syntax, syntax_set }))
     }
 
-    fn get_first_line_syntax(&self, reader: &mut InputReader) -> Option<&SyntaxReference> {
-        String::from_utf8(reader.first_line.clone())
-            .ok()
-            .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l))
+    fn find_syntax_by_extension(&self, e: Option<&OsStr>) -> Result<Option<SyntaxReferenceInSet>> {
+        let syntax_set = self.get_syntax_set()?;
+        let extension = e.and_then(|x| x.to_str()).unwrap_or_default();
+        Ok(syntax_set
+            .find_syntax_by_extension(extension)
+            .map(|syntax| SyntaxReferenceInSet { syntax, syntax_set }))
     }
+
+    fn get_extension_syntax(&self, file_name: &OsStr) -> Result<Option<SyntaxReferenceInSet>> {
+        let mut syntax = self.find_syntax_by_extension(Some(file_name))?;
+        if syntax.is_none() {
+            syntax = self.find_syntax_by_extension(Path::new(file_name).extension())?;
+        }
+        if syntax.is_none() {
+            syntax = try_with_stripped_suffix(file_name, |stripped_file_name| {
+                self.get_extension_syntax(stripped_file_name) // Note: recursion
+            })?;
+        }
+        Ok(syntax)
+    }
+
+    fn get_first_line_syntax(
+        &self,
+        reader: &mut InputReader,
+    ) -> Result<Option<SyntaxReferenceInSet>> {
+        let syntax_set = self.get_syntax_set()?;
+        Ok(String::from_utf8(reader.first_line.clone())
+            .ok()
+            .and_then(|l| syntax_set.find_syntax_by_first_line(&l))
+            .map(|syntax| SyntaxReferenceInSet { syntax, syntax_set }))
+    }
+}
+
+pub(crate) fn get_serialized_integrated_syntaxset() -> &'static [u8] {
+    include_bytes!("../assets/syntaxes.bin")
+}
+
+pub(crate) fn get_integrated_themeset() -> ThemeSet {
+    from_binary(include_bytes!("../assets/themes.bin"), COMPRESS_THEMES)
+}
+
+fn get_integrated_minimal_syntaxes() -> MinimalSyntaxes {
+    from_binary(
+        include_bytes!("../assets/minimal_syntaxes.bin"),
+        COMPRESS_MINIMAL_SYNTAXES,
+    )
+}
+
+pub(crate) fn from_binary<T: serde::de::DeserializeOwned>(v: &[u8], compressed: bool) -> T {
+    asset_from_contents(v, "n/a", compressed)
+        .expect("data integrated in binary is never faulty, but make sure `compressed` is in sync!")
+}
+
+fn asset_from_contents<T: serde::de::DeserializeOwned>(
+    contents: &[u8],
+    description: &str,
+    compressed: bool,
+) -> Result<T> {
+    if compressed {
+        bincode::deserialize_from(flate2::read::ZlibDecoder::new(contents))
+    } else {
+        bincode::deserialize_from(contents)
+    }
+    .map_err(|_| format!("Could not parse {}", description).into())
+}
+
+fn asset_from_cache<T: serde::de::DeserializeOwned>(
+    path: &Path,
+    description: &str,
+    compressed: bool,
+) -> Result<T> {
+    let contents = fs::read(path).map_err(|_| {
+        format!(
+            "Could not load cached {} '{}'",
+            description,
+            path.to_string_lossy()
+        )
+    })?;
+    asset_from_contents(&contents[..], description, compressed)
+        .map_err(|_| format!("Could not parse cached {}", description).into())
 }
 
 #[cfg(test)]
@@ -289,8 +344,8 @@ mod tests {
     use std::ffi::OsStr;
 
     use std::fs::File;
-    use std::io::Write;
-    use tempdir::TempDir;
+    use std::io::{BufReader, Write};
+    use tempfile::TempDir;
 
     use crate::input::Input;
 
@@ -305,11 +360,22 @@ mod tests {
             SyntaxDetectionTest {
                 assets: HighlightingAssets::from_binary(),
                 syntax_mapping: SyntaxMapping::builtin(),
-                temp_dir: TempDir::new("bat_syntax_detection_tests")
-                    .expect("creation of temporary directory"),
+                temp_dir: TempDir::new().expect("creation of temporary directory"),
             }
         }
 
+        fn get_syntax_name(
+            &self,
+            language: Option<&str>,
+            input: &mut OpenedInput,
+            mapping: &SyntaxMapping,
+        ) -> String {
+            self.assets
+                .get_syntax(language, input, mapping)
+                .map(|syntax_in_set| syntax_in_set.syntax.name.clone())
+                .unwrap_or_else(|_| "!no syntax!".to_owned())
+        }
+
         fn syntax_for_real_file_with_content_os(
             &self,
             file_name: &OsStr,
@@ -321,29 +387,21 @@ mod tests {
                 writeln!(temp_file, "{}", first_line).unwrap();
             }
 
-            let input = Input::ordinary_file(file_path.as_os_str());
+            let input = Input::ordinary_file(&file_path);
             let dummy_stdin: &[u8] = &[];
-            let mut opened_input = input.open(dummy_stdin).unwrap();
+            let mut opened_input = input.open(dummy_stdin, None).unwrap();
 
-            self.assets
-                .get_syntax(None, &mut opened_input, &self.syntax_mapping)
-                .unwrap_or_else(|_| self.assets.syntax_set.find_syntax_plain_text())
-                .name
-                .clone()
+            self.get_syntax_name(None, &mut opened_input, &self.syntax_mapping)
         }
 
         fn syntax_for_file_with_content_os(&self, file_name: &OsStr, first_line: &str) -> String {
             let file_path = self.temp_dir.path().join(file_name);
             let input = Input::from_reader(Box::new(BufReader::new(first_line.as_bytes())))
-                .with_name(Some(file_path.as_os_str()));
+                .with_name(Some(&file_path));
             let dummy_stdin: &[u8] = &[];
-            let mut opened_input = input.open(dummy_stdin).unwrap();
+            let mut opened_input = input.open(dummy_stdin, None).unwrap();
 
-            self.assets
-                .get_syntax(None, &mut opened_input, &self.syntax_mapping)
-                .unwrap_or_else(|_| self.assets.syntax_set.find_syntax_plain_text())
-                .name
-                .clone()
+            self.get_syntax_name(None, &mut opened_input, &self.syntax_mapping)
         }
 
         #[cfg(unix)]
@@ -360,14 +418,10 @@ mod tests {
         }
 
         fn syntax_for_stdin_with_content(&self, file_name: &str, content: &[u8]) -> String {
-            let input = Input::stdin().with_name(Some(OsStr::new(file_name)));
-            let mut opened_input = input.open(content).unwrap();
+            let input = Input::stdin().with_name(Some(file_name));
+            let mut opened_input = input.open(content, None).unwrap();
 
-            self.assets
-                .get_syntax(None, &mut opened_input, &self.syntax_mapping)
-                .unwrap_or_else(|_| self.assets.syntax_set.find_syntax_plain_text())
-                .name
-                .clone()
+            self.get_syntax_name(None, &mut opened_input, &self.syntax_mapping)
         }
 
         fn syntax_is_same_for_inputkinds(&self, file_name: &str, content: &str) -> bool {
@@ -444,6 +498,7 @@ mod tests {
         assert_eq!(test.syntax_for_file("test.sass"), "Sass");
         assert_eq!(test.syntax_for_file("test.js"), "JavaScript (Babel)");
         assert_eq!(test.syntax_for_file("test.fs"), "F#");
+        assert_eq!(test.syntax_for_file("test.v"), "Verilog");
     }
 
     #[test]
@@ -515,15 +570,12 @@ mod tests {
             .expect("creation of directory succeeds");
         symlink(&file_path, &file_path_symlink).expect("creation of symbolic link succeeds");
 
-        let input = Input::ordinary_file(file_path_symlink.as_os_str());
+        let input = Input::ordinary_file(&file_path_symlink);
         let dummy_stdin: &[u8] = &[];
-        let mut opened_input = input.open(dummy_stdin).unwrap();
+        let mut opened_input = input.open(dummy_stdin, None).unwrap();
 
         assert_eq!(
-            test.assets
-                .get_syntax(None, &mut opened_input, &test.syntax_mapping)
-                .unwrap_or_else(|_| test.assets.syntax_set.find_syntax_plain_text())
-                .name,
+            test.get_syntax_name(None, &mut opened_input, &test.syntax_mapping),
             "SSH Config"
         );
     }

src/assets/assets_metadata.rs

@@ -16,6 +16,7 @@ pub struct AssetsMetadata {
 const FILENAME: &str = "metadata.yaml";
 
 impl AssetsMetadata {
+    #[cfg(feature = "build-assets")]
     pub(crate) fn new(current_version: &str) -> AssetsMetadata {
         AssetsMetadata {
             bat_version: Some(current_version.to_owned()),
@@ -23,6 +24,7 @@ impl AssetsMetadata {
         }
     }
 
+    #[cfg(feature = "build-assets")]
     pub(crate) fn save_to_folder(&self, path: &Path) -> Result<()> {
         let file = File::create(path.join(FILENAME))?;
         serde_yaml::to_writer(file, self)?;
@@ -50,16 +52,15 @@ impl AssetsMetadata {
     pub fn load_from_folder(path: &Path) -> Result<Option<Self>> {
         match Self::try_load_from_folder(path) {
             Ok(metadata) => Ok(Some(metadata)),
-            Err(e) => match e.kind() {
-                ErrorKind::SerdeYamlError(_) => Err(e),
-                _ => {
-                    if path.join("syntaxes.bin").exists() || path.join("themes.bin").exists() {
-                        Ok(Some(Self::default()))
-                    } else {
-                        Ok(None)
-                    }
+            Err(e) => {
+                if let Error::SerdeYamlError(_) = e {
+                    Err(e)
+                } else if path.join("syntaxes.bin").exists() || path.join("themes.bin").exists() {
+                    Ok(Some(Self::default()))
+                } else {
+                    Ok(None)
                 }
-            },
+            }
         }
     }
 

src/assets/build_assets.rs

@@ -0,0 +1,500 @@
+use std::collections::HashMap;
+use std::path::Path;
+use syntect::highlighting::ThemeSet;
+use syntect::parsing::syntax_definition::{
+    ContextReference, MatchOperation, MatchPattern, Pattern, SyntaxDefinition,
+};
+use syntect::parsing::{Scope, SyntaxSet, SyntaxSetBuilder};
+
+use crate::assets::*;
+
+mod graphviz_utils;
+
+type SyntaxName = String;
+
+/// Used to look up which [SyntaxDefinition] corresponds to a given [OtherSyntax]
+type OtherSyntaxLookup<'a> = HashMap<OtherSyntax, &'a SyntaxDefinition>;
+
+/// Used to look up what dependencies a given [SyntaxDefinition] has
+type SyntaxToDependencies = HashMap<SyntaxName, Vec<OtherSyntax>>;
+
+/// Used to look up what other [SyntaxDefinition]s depend on a given [SyntaxDefinition]
+type SyntaxToDependents<'a> = HashMap<SyntaxName, Vec<OtherSyntax>>;
+
+/// Represents some other `*.sublime-syntax` file, i.e. another [SyntaxDefinition].
+#[derive(Debug, Eq, PartialEq, PartialOrd, Ord, Clone, Hash)]
+pub(crate) enum OtherSyntax {
+    /// By name. Example YAML: `include: C.sublime-syntax` (name is `"C"`)
+    ByName(String),
+
+    /// By scope. Example YAML: `embed: scope:source.c` (scope is `"source.c"`)
+    ByScope(Scope),
+}
+
+pub fn build(
+    source_dir: &Path,
+    include_integrated_assets: bool,
+    target_dir: &Path,
+    current_version: &str,
+) -> Result<()> {
+    let theme_set = build_theme_set(source_dir, include_integrated_assets);
+
+    let syntax_set_builder = build_syntax_set_builder(source_dir, include_integrated_assets)?;
+
+    let minimal_syntaxes = build_minimal_syntaxes(&syntax_set_builder, include_integrated_assets)?;
+
+    let syntax_set = syntax_set_builder.build();
+
+    print_unlinked_contexts(&syntax_set);
+
+    write_assets(
+        &theme_set,
+        &syntax_set,
+        &minimal_syntaxes,
+        target_dir,
+        current_version,
+    )
+}
+
+fn build_theme_set(source_dir: &Path, include_integrated_assets: bool) -> ThemeSet {
+    let mut theme_set = if include_integrated_assets {
+        crate::assets::get_integrated_themeset()
+    } else {
+        ThemeSet::new()
+    };
+
+    let theme_dir = source_dir.join("themes");
+    if theme_dir.exists() {
+        let res = theme_set.add_from_folder(&theme_dir);
+        if let Err(err) = res {
+            println!(
+                "Failed to load one or more themes from '{}' (reason: '{}')",
+                theme_dir.to_string_lossy(),
+                err,
+            );
+        }
+    } else {
+        println!(
+            "No themes were found in '{}', using the default set",
+            theme_dir.to_string_lossy()
+        );
+    }
+
+    theme_set
+}
+
+fn build_syntax_set_builder(
+    source_dir: &Path,
+    include_integrated_assets: bool,
+) -> Result<SyntaxSetBuilder> {
+    let mut syntax_set_builder = if !include_integrated_assets {
+        let mut builder = syntect::parsing::SyntaxSetBuilder::new();
+        builder.add_plain_text_syntax();
+        builder
+    } else {
+        from_binary::<SyntaxSet>(get_serialized_integrated_syntaxset(), COMPRESS_SYNTAXES)
+            .into_builder()
+    };
+
+    let syntax_dir = source_dir.join("syntaxes");
+    if syntax_dir.exists() {
+        syntax_set_builder.add_from_folder(syntax_dir, true)?;
+    } else {
+        println!(
+            "No syntaxes were found in '{}', using the default set.",
+            syntax_dir.to_string_lossy()
+        );
+    }
+
+    Ok(syntax_set_builder)
+}
+
+fn print_unlinked_contexts(syntax_set: &SyntaxSet) {
+    let missing_contexts = syntax_set.find_unlinked_contexts();
+    if !missing_contexts.is_empty() {
+        println!("Some referenced contexts could not be found!");
+        for context in missing_contexts {
+            println!("- {}", context);
+        }
+    }
+}
+
+fn write_assets(
+    theme_set: &ThemeSet,
+    syntax_set: &SyntaxSet,
+    minimal_syntaxes: &MinimalSyntaxes,
+    target_dir: &Path,
+    current_version: &str,
+) -> Result<()> {
+    let _ = std::fs::create_dir_all(target_dir);
+    asset_to_cache(
+        theme_set,
+        &target_dir.join("themes.bin"),
+        "theme set",
+        COMPRESS_THEMES,
+    )?;
+    asset_to_cache(
+        syntax_set,
+        &target_dir.join("syntaxes.bin"),
+        "syntax set",
+        COMPRESS_SYNTAXES,
+    )?;
+    asset_to_cache(
+        minimal_syntaxes,
+        &target_dir.join("minimal_syntaxes.bin"),
+        "minimal syntax sets",
+        COMPRESS_MINIMAL_SYNTAXES,
+    )?;
+
+    print!(
+        "Writing metadata to folder {} ... ",
+        target_dir.to_string_lossy()
+    );
+    crate::assets_metadata::AssetsMetadata::new(current_version).save_to_folder(target_dir)?;
+    println!("okay");
+
+    Ok(())
+}
+
+fn print_syntax_set_names(syntax_set: &SyntaxSet) {
+    let names = syntax_set
+        .syntaxes()
+        .iter()
+        .map(|syntax| &syntax.name)
+        .collect::<Vec<_>>();
+    println!("{:?}", names);
+}
+
+fn build_minimal_syntaxes(
+    syntax_set_builder: &'_ SyntaxSetBuilder,
+    include_integrated_assets: bool,
+) -> Result<MinimalSyntaxes> {
+    let mut minimal_syntaxes = MinimalSyntaxes {
+        by_name: HashMap::new(),
+        serialized_syntax_sets: vec![],
+    };
+
+    if include_integrated_assets {
+        // Dependency info is not present in integrated assets, so we can't
+        // calculate minimal syntax sets. Return early without any data filled
+        // in. This means that no minimal syntax sets will be available to use, and
+        // the full, slow-to-deserialize, fallback syntax set will be used instead.
+        return Ok(minimal_syntaxes);
+    }
+
+    let minimal_syntax_sets_to_serialize = build_minimal_syntax_sets(syntax_set_builder)
+        // For now, only store syntax sets with one syntax, otherwise
+        // the binary grows by several megs
+        .filter(|syntax_set| syntax_set.syntaxes().len() == 1);
+
+    for minimal_syntax_set in minimal_syntax_sets_to_serialize {
+        // Remember what index it is found at
+        let current_index = minimal_syntaxes.serialized_syntax_sets.len();
+
+        for syntax in minimal_syntax_set.syntaxes() {
+            minimal_syntaxes
+                .by_name
+                .insert(syntax.name.to_ascii_lowercase().clone(), current_index);
+        }
+
+        let serialized_syntax_set = asset_to_contents(
+            &minimal_syntax_set,
+            &format!("failed to serialize minimal syntax set {}", current_index),
+            COMPRESS_SERIALIZED_MINIMAL_SYNTAXES,
+        )?;
+
+        // Add last so that it ends up at `current_index`
+        minimal_syntaxes
+            .serialized_syntax_sets
+            .push(serialized_syntax_set);
+    }
+
+    Ok(minimal_syntaxes)
+}
+
+/// Analyzes dependencies between syntaxes in a [SyntaxSetBuilder].
+/// From that, it builds minimal [SyntaxSet]s.
+fn build_minimal_syntax_sets(
+    syntax_set_builder: &'_ SyntaxSetBuilder,
+) -> impl Iterator<Item = SyntaxSet> + '_ {
+    let syntaxes = syntax_set_builder.syntaxes();
+
+    // Build the data structures we need for dependency resolution
+    let (other_syntax_lookup, syntax_to_dependencies, syntax_to_dependents) =
+        generate_maps(syntaxes);
+
+    maybe_write_syntax_dependencies_to_graphviz_dot_file(
+        &other_syntax_lookup,
+        &syntax_to_dependencies,
+    );
+
+    // Create one minimal SyntaxSet from each (non-hidden) SyntaxDefinition
+    syntaxes.iter().filter_map(move |syntax| {
+        if syntax.hidden {
+            return None;
+        }
+
+        let mut builder = SyntaxSetDependencyBuilder::new();
+        builder.add_with_dependencies(
+            syntax,
+            &other_syntax_lookup,
+            &syntax_to_dependencies,
+            &syntax_to_dependents,
+        );
+        let syntax_set = builder.build();
+
+        if std::env::var("BAT_PRINT_SYNTAX_DEPENDENCIES").is_ok() {
+            // To trigger this code, run:
+            // BAT_PRINT_SYNTAX_DEPENDENCIES=1 cargo run -- cache --build --source assets --blank --target /tmp
+            print_syntax_set_names(&syntax_set);
+        }
+
+        Some(syntax_set)
+    })
+}
+
+/// In order to analyze dependencies, we need three key pieces of data.
+///
+///  * When we have a [OtherSyntax], we need to know what [SyntaxDefinition]
+///    that corresponds to
+///  * When we have a [SyntaxDefinition], we need to know what dependencies it
+///    has
+///  * When we have a [SyntaxDefinition], we need to know what other syntaxes
+///    depend on it
+///
+/// This functions generates that data for each syntax.
+fn generate_maps(
+    syntaxes: &[SyntaxDefinition],
+) -> (OtherSyntaxLookup, SyntaxToDependencies, SyntaxToDependents) {
+    let mut other_syntax_lookup = HashMap::new();
+    let mut syntax_to_dependencies = HashMap::new();
+    let mut syntax_to_dependents = HashMap::new();
+
+    for syntax in syntaxes {
+        other_syntax_lookup.insert(OtherSyntax::ByName(syntax.name.clone()), syntax);
+        other_syntax_lookup.insert(OtherSyntax::ByScope(syntax.scope), syntax);
+    }
+
+    for syntax in syntaxes {
+        let dependencies = dependencies_for_syntax(syntax);
+
+        for dependency in &dependencies {
+            if let Some(dependency) = other_syntax_lookup.get(dependency) {
+                syntax_to_dependents
+                    .entry(dependency.name.clone())
+                    .or_insert_with(Vec::new)
+                    .push(OtherSyntax::ByName(syntax.name.clone()));
+            }
+        }
+
+        syntax_to_dependencies.insert(syntax.name.clone(), dependencies);
+    }
+
+    (
+        other_syntax_lookup,
+        syntax_to_dependencies,
+        syntax_to_dependents,
+    )
+}
+
+/// Gets what external dependencies a given [SyntaxDefinition] has.
+/// An external dependency is another `.sublime-syntax` file.
+/// It does that by looking for variants of the following YAML patterns:
+/// - `include: C.sublime-syntax`
+/// - `embed: scope:source.c`
+fn dependencies_for_syntax(syntax: &SyntaxDefinition) -> Vec<OtherSyntax> {
+    let mut dependencies: Vec<OtherSyntax> = syntax
+        .contexts
+        .values()
+        .flat_map(|context| &context.patterns)
+        .flat_map(dependencies_from_pattern)
+        .collect();
+
+    // No need to track a dependency more than once
+    dependencies.sort();
+    dependencies.dedup();
+
+    dependencies
+}
+
+fn dependencies_from_pattern(pattern: &Pattern) -> Vec<OtherSyntax> {
+    match *pattern {
+        Pattern::Match(MatchPattern {
+            operation: MatchOperation::Push(ref context_references),
+            ..
+        }) => context_references
+            .iter()
+            .map(dependency_from_context_reference)
+            .collect(),
+        Pattern::Include(ref context_reference) => {
+            vec![dependency_from_context_reference(context_reference)]
+        }
+        _ => vec![],
+    }
+    .into_iter()
+    .flatten()
+    .collect()
+}
+
+/// To generate a Graphviz dot file of syntax dependencies, do this:
+/// ```bash
+/// sudo apt install graphviz
+/// BAT_SYNTAX_DEPENDENCIES_TO_GRAPHVIZ_DOT_FILE=/tmp/bat-syntax-dependencies.dot cargo run -- cache  --build --source assets --blank --target /tmp
+/// dot /tmp/bat-syntax-dependencies.dot -Tpng -o /tmp/bat-syntax-dependencies.png
+/// open /tmp/bat-syntax-dependencies.png
+/// ```
+fn maybe_write_syntax_dependencies_to_graphviz_dot_file(
+    other_syntax_lookup: &OtherSyntaxLookup,
+    syntax_to_dependencies: &SyntaxToDependencies,
+) {
+    if let Ok(dot_file_path) = std::env::var("BAT_SYNTAX_DEPENDENCIES_TO_GRAPHVIZ_DOT_FILE") {
+        graphviz_utils::try_syntax_dependencies_to_graphviz_dot_file(
+            other_syntax_lookup,
+            syntax_to_dependencies,
+            &dot_file_path,
+        );
+    }
+}
+
+/// Removes any context name from the syntax reference.
+///
+/// When we track dependencies between syntaxes, we are not interested in
+/// dependencies on specific contexts inside other syntaxes. We only care about
+/// the dependency on the syntax itself.
+///
+/// For example, if a syntax includes another syntax like this:
+/// ```yaml
+///   - include: scope:source.c++#unique-variables
+/// ```
+/// we only want to track the dependency on `source.c++`.
+fn remove_explicit_context(scope: Scope) -> Scope {
+    if let Some(without_context) = scope.build_string().split('#').next() {
+        Scope::new(without_context).expect("removing context reference must never fail")
+    } else {
+        scope
+    }
+}
+
+fn dependency_from_context_reference(context_reference: &ContextReference) -> Option<OtherSyntax> {
+    match &context_reference {
+        ContextReference::File { ref name, .. } => Some(OtherSyntax::ByName(name.clone())),
+        ContextReference::ByScope { ref scope, .. } => {
+            Some(OtherSyntax::ByScope(remove_explicit_context(*scope)))
+        }
+        _ => None,
+    }
+}
+
+/// Helper to construct a [SyntaxSetBuilder] that contains only [SyntaxDefinition]s
+/// that have dependencies among them.
+struct SyntaxSetDependencyBuilder {
+    syntax_set_builder: SyntaxSetBuilder,
+}
+
+impl SyntaxSetDependencyBuilder {
+    fn new() -> Self {
+        SyntaxSetDependencyBuilder {
+            syntax_set_builder: SyntaxSetBuilder::new(),
+        }
+    }
+
+    /// Add a [SyntaxDefinition] to the underlying [SyntaxSetBuilder].
+    /// Also resolve any dependencies it has and add those [SyntaxDefinition]s too.
+    /// This is a recursive process.
+    fn add_with_dependencies(
+        &mut self,
+        syntax: &SyntaxDefinition,
+        other_syntax_lookup: &OtherSyntaxLookup,
+        syntax_to_dependencies: &SyntaxToDependencies,
+        syntax_to_dependents: &SyntaxToDependents,
+    ) {
+        let name = &syntax.name;
+        if self.is_syntax_already_added(name) {
+            return;
+        }
+
+        self.syntax_set_builder.add(syntax.clone());
+
+        let mut syntaxes_to_add = vec![];
+        if let Some(dependencies) = syntax_to_dependencies.get(name) {
+            syntaxes_to_add.extend(dependencies);
+        }
+        if let Some(dependents) = syntax_to_dependents.get(name) {
+            // This will later be enabled intelligently
+            if std::env::var("BAT_INCLUDE_SYNTAX_DEPENDENTS").is_ok() {
+                syntaxes_to_add.extend(dependents);
+            }
+        }
+        for syntax_to_add in syntaxes_to_add {
+            if let Some(syntax_to_add) = other_syntax_lookup.get(syntax_to_add) {
+                self.add_with_dependencies(
+                    syntax_to_add,
+                    other_syntax_lookup,
+                    syntax_to_dependencies,
+                    syntax_to_dependents,
+                )
+            }
+        }
+    }
+
+    fn is_syntax_already_added(&self, name: &str) -> bool {
+        self.syntax_set_builder
+            .syntaxes()
+            .iter()
+            .any(|syntax| syntax.name == name)
+    }
+
+    fn build(self) -> SyntaxSet {
+        self.syntax_set_builder.build()
+    }
+}
+
+fn asset_to_contents<T: serde::Serialize>(
+    asset: &T,
+    description: &str,
+    compressed: bool,
+) -> Result<Vec<u8>> {
+    let mut contents = vec![];
+    if compressed {
+        bincode::serialize_into(
+            flate2::write::ZlibEncoder::new(&mut contents, flate2::Compression::best()),
+            asset,
+        )
+    } else {
+        bincode::serialize_into(&mut contents, asset)
+    }
+    .map_err(|_| format!("Could not serialize {}", description))?;
+    Ok(contents)
+}
+
+fn asset_to_cache<T: serde::Serialize>(
+    asset: &T,
+    path: &Path,
+    description: &str,
+    compressed: bool,
+) -> Result<()> {
+    print!("Writing {} to {} ... ", description, path.to_string_lossy());
+    let contents = asset_to_contents(asset, description, compressed)?;
+    std::fs::write(path, &contents[..]).map_err(|_| {
+        format!(
+            "Could not save {} to {}",
+            description,
+            path.to_string_lossy()
+        )
+    })?;
+    println!("okay");
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn remove_explicit_context_sanity() {
+        // Example from Objective-C++.sublime-syntax
+        let scope = Scope::new("source.c++#unique-variables").unwrap();
+        let expected = Scope::new("source.c++").unwrap();
+        assert_eq!(remove_explicit_context(scope), expected);
+    }
+}

src/assets/build_assets/graphviz_utils.rs

@@ -0,0 +1,41 @@
+use super::*;
+
+pub(crate) fn try_syntax_dependencies_to_graphviz_dot_file(
+    other_syntax_lookup: &OtherSyntaxLookup,
+    syntax_to_dependencies: &SyntaxToDependencies,
+    dot_file_path: &str,
+) {
+    match syntax_dependencies_to_graphviz_dot_file(
+        other_syntax_lookup,
+        syntax_to_dependencies,
+        dot_file_path,
+    ) {
+        Ok(_) => println!("Wrote graphviz dot file to {}", dot_file_path),
+        Err(e) => eprintln!(
+            "Failed to write graphviz dot file to {}: {}",
+            dot_file_path, e
+        ),
+    };
+}
+
+fn syntax_dependencies_to_graphviz_dot_file(
+    other_syntax_lookup: &OtherSyntaxLookup,
+    syntax_to_dependencies: &SyntaxToDependencies,
+    dot_file_path: &str,
+) -> Result<()> {
+    use std::io::Write;
+
+    let mut dot_file = std::fs::File::create(dot_file_path)?;
+
+    writeln!(dot_file, "digraph BatSyntaxDependencies {{")?;
+    for (key, dependencies) in syntax_to_dependencies {
+        for dependency in dependencies {
+            if let Some(dep) = other_syntax_lookup.get(dependency) {
+                writeln!(dot_file, "    \"{}\" -> \"{}\"", key, dep.name)?;
+            }
+        }
+    }
+    writeln!(dot_file, "}}")?;
+
+    Ok(())
+}

src/assets/ignored_suffixes.rs

@@ -0,0 +1,42 @@
+use std::ffi::OsStr;
+use std::path::Path;
+
+use crate::error::*;
+
+const IGNORED_SUFFIXES: [&str; 13] = [
+    // Editor etc backups
+    "~",
+    ".bak",
+    ".old",
+    ".orig",
+    // Debian and derivatives apt/dpkg/ucf backups
+    ".dpkg-dist",
+    ".dpkg-old",
+    ".ucf-dist",
+    ".ucf-new",
+    ".ucf-old",
+    // Red Hat and derivatives rpm backups
+    ".rpmnew",
+    ".rpmorig",
+    ".rpmsave",
+    // Build system input/template files
+    ".in",
+];
+
+/// If we find an ignored suffix on the file name, e.g. '~', we strip it and
+/// then try again without it.
+pub fn try_with_stripped_suffix<T, F>(file_name: &OsStr, func: F) -> Result<Option<T>>
+where
+    F: Fn(&OsStr) -> Result<Option<T>>,
+{
+    let mut from_stripped = None;
+    if let Some(file_str) = Path::new(file_name).to_str() {
+        for suffix in &IGNORED_SUFFIXES {
+            if let Some(stripped_filename) = file_str.strip_suffix(suffix) {
+                from_stripped = func(OsStr::new(stripped_filename))?;
+                break;
+            }
+        }
+    }
+    Ok(from_stripped)
+}

src/assets/minimal_assets.rs

@@ -0,0 +1,72 @@
+use std::collections::HashMap;
+
+use lazycell::LazyCell;
+
+use syntect::parsing::SyntaxSet;
+
+use super::*;
+
+#[derive(Debug)]
+pub(crate) struct MinimalAssets {
+    minimal_syntaxes: MinimalSyntaxes,
+
+    /// Lazily load serialized [SyntaxSet]s from [Self.minimal_syntaxes]. The
+    /// index in this vec matches the index in
+    /// [Self.minimal_syntaxes.serialized_syntax_sets]
+    deserialized_minimal_syntaxes: Vec<LazyCell<SyntaxSet>>,
+}
+
+/// Stores and allows lookup of minimal [SyntaxSet]s. The [SyntaxSet]s are
+/// stored in serialized form, and are deserialized on-demand. This gives good
+/// startup performance since only the necessary [SyntaxReference]s needs to be
+/// deserialized.
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+pub(crate) struct MinimalSyntaxes {
+    /// Lookup the index into `serialized_syntax_sets` of a [SyntaxSet] by the
+    /// name of any [SyntaxReference] inside the [SyntaxSet]
+    /// (We will later add `by_extension`, `by_first_line`, etc.)
+    pub(crate) by_name: HashMap<String, usize>,
+
+    /// Serialized [SyntaxSet]s. Whether or not this data is compressed is
+    /// decided by [COMPRESS_SERIALIZED_MINIMAL_SYNTAXES]
+    pub(crate) serialized_syntax_sets: Vec<Vec<u8>>,
+}
+
+impl MinimalAssets {
+    pub(crate) fn new(minimal_syntaxes: MinimalSyntaxes) -> Self {
+        // Prepare so we can lazily load minimal syntaxes without a mut reference
+        let deserialized_minimal_syntaxes =
+            vec![LazyCell::new(); minimal_syntaxes.serialized_syntax_sets.len()];
+
+        Self {
+            minimal_syntaxes,
+            deserialized_minimal_syntaxes,
+        }
+    }
+
+    pub fn get_syntax_set_by_name(&self, name: &str) -> Option<&SyntaxSet> {
+        self.minimal_syntaxes
+            .by_name
+            .get(&name.to_ascii_lowercase())
+            .and_then(|index| self.get_minimal_syntax_set_with_index(*index))
+    }
+
+    fn load_minimal_syntax_set_with_index(&self, index: usize) -> Result<SyntaxSet> {
+        let serialized_syntax_set = &self.minimal_syntaxes.serialized_syntax_sets[index];
+        asset_from_contents(
+            &serialized_syntax_set[..],
+            &format!("minimal syntax set {}", index),
+            COMPRESS_SERIALIZED_MINIMAL_SYNTAXES,
+        )
+        .map_err(|_| format!("Could not parse minimal syntax set {}", index).into())
+    }
+
+    fn get_minimal_syntax_set_with_index(&self, index: usize) -> Option<&SyntaxSet> {
+        self.deserialized_minimal_syntaxes
+            .get(index)
+            .and_then(|cell| {
+                cell.try_borrow_with(|| self.load_minimal_syntax_set_with_index(index))
+                    .ok()
+            })
+    }
+}

src/assets/serialized_syntax_set.rs

@@ -0,0 +1,27 @@
+use std::path::PathBuf;
+
+use syntect::parsing::SyntaxSet;
+
+use super::*;
+
+/// A SyntaxSet in serialized form, i.e. bincoded and flate2 compressed.
+/// We keep it in this format since we want to load it lazily.
+#[derive(Debug)]
+pub enum SerializedSyntaxSet {
+    /// The data comes from a user-generated cache file.
+    FromFile(PathBuf),
+
+    /// The data to use is embedded into the bat binary.
+    FromBinary(&'static [u8]),
+}
+
+impl SerializedSyntaxSet {
+    pub fn deserialize(&self) -> Result<SyntaxSet> {
+        match self {
+            SerializedSyntaxSet::FromBinary(data) => Ok(from_binary(data, COMPRESS_SYNTAXES)),
+            SerializedSyntaxSet::FromFile(ref path) => {
+                asset_from_cache(path, "syntax set", COMPRESS_SYNTAXES)
+            }
+        }
+    }
+}

src/bin/bat/app.rs

@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 use std::env;
-use std::ffi::OsStr;
+use std::path::Path;
 use std::str::FromStr;
 
 use atty::{self, Stream};
@@ -16,6 +16,7 @@ use console::Term;
 use crate::input::{new_file_input, new_stdin_input};
 use bat::{
     assets::HighlightingAssets,
+    bat_warning,
     config::{Config, VisibleLines},
     error::*,
     input::Input,
@@ -61,7 +62,7 @@ impl App {
             // Read arguments from bats config file
             let mut args = get_args_from_env_var()
                 .unwrap_or_else(get_args_from_config_file)
-                .chain_err(|| "Could not parse configuration file")?;
+                .map_err(|_| "Could not parse configuration file")?;
 
             // Put the zero-th CLI argument (program name) first
             args.insert(0, cli_args.next().unwrap());
@@ -82,10 +83,9 @@ impl App {
             Some("always") => PagingMode::Always,
             Some("never") => PagingMode::Never,
             Some("auto") | None => {
-                if self.matches.occurrences_of("plain") > 1 {
-                    // If we have -pp as an option when in auto mode, the pager should be disabled.
-                    PagingMode::Never
-                } else if self.matches.is_present("no-paging") {
+                // If we have -pp as an option when in auto mode, the pager should be disabled.
+                let extra_plain = self.matches.occurrences_of("plain") > 1;
+                if extra_plain || self.matches.is_present("no-paging") {
                     PagingMode::Never
                 } else if inputs.iter().any(Input::is_stdin) {
                     // If we are reading from stdin, only enable paging if we write to an
@@ -150,20 +150,20 @@ impl App {
             wrapping_mode: if self.interactive_output || maybe_term_width.is_some() {
                 match self.matches.value_of("wrap") {
                     Some("character") => WrappingMode::Character,
-                    Some("never") => WrappingMode::NoWrapping,
+                    Some("never") => WrappingMode::NoWrapping(true),
                     Some("auto") | None => {
                         if style_components.plain() {
-                            WrappingMode::NoWrapping
+                            WrappingMode::NoWrapping(false)
                         } else {
                             WrappingMode::Character
                         }
                     }
-                    _ => unreachable!("other values for --paging are not allowed"),
+                    _ => unreachable!("other values for --wrap are not allowed"),
                 }
             } else {
                 // We don't have the tty width when piping to another program.
                 // There's no point in wrapping when this is the case.
-                WrappingMode::NoWrapping
+                WrappingMode::NoWrapping(false)
             },
             colored_output: self.matches.is_present("force-colorization")
                 || match self.matches.value_of("color") {
@@ -234,6 +234,7 @@ impl App {
                 .map(LineRanges::from)
                 .map(HighlightedLineRanges)
                 .unwrap_or_default(),
+            use_custom_assets: !self.matches.is_present("no-custom-assets"),
         })
     }
 
@@ -248,16 +249,19 @@ impl App {
             }
             _ => {}
         }
-        let filenames: Option<Vec<&str>> = self
+        let filenames: Option<Vec<&Path>> = self
             .matches
-            .values_of("file-name")
-            .map(|values| values.collect());
+            .values_of_os("file-name")
+            .map(|values| values.map(Path::new).collect());
 
-        let mut filenames_or_none: Box<dyn Iterator<Item = _>> = match filenames {
-            Some(ref filenames) => Box::new(filenames.iter().map(|name| Some(OsStr::new(*name)))),
+        let mut filenames_or_none: Box<dyn Iterator<Item = Option<&Path>>> = match filenames {
+            Some(filenames) => Box::new(filenames.into_iter().map(Some)),
             None => Box::new(std::iter::repeat(None)),
         };
-        let files: Option<Vec<&OsStr>> = self.matches.values_of_os("FILE").map(|vs| vs.collect());
+        let files: Option<Vec<&Path>> = self
+            .matches
+            .values_of_os("FILE")
+            .map(|vs| vs.map(Path::new).collect());
 
         if files.is_none() {
             return Ok(vec![new_stdin_input(
@@ -297,7 +301,7 @@ impl App {
                     .map(|style_str| {
                         style_str
                             .split(',')
-                            .map(|x| StyleComponent::from_str(&x))
+                            .map(|x| StyleComponent::from_str(x))
                             .collect::<Result<Vec<StyleComponent>>>()
                     })
                     .transpose()?;
@@ -323,11 +327,7 @@ impl App {
 
         // If `grid` is set, remove `rule` as it is a subset of `grid`, and print a warning.
         if styled_components.grid() && styled_components.0.remove(&StyleComponent::Rule) {
-            use ansi_term::Colour::Yellow;
-            eprintln!(
-                "{}: Style 'rule' is a subset of style 'grid', 'rule' will not be visible.",
-                Yellow.paint("[bat warning]"),
-            );
+            bat_warning!("Style 'rule' is a subset of style 'grid', 'rule' will not be visible.");
         }
 
         Ok(styled_components)

src/bin/bat/assets.rs

@@ -18,26 +18,15 @@ pub fn cache_dir() -> Cow<'static, str> {
 }
 
 pub fn clear_assets() {
-    let theme_set_path = PROJECT_DIRS.cache_dir().join("themes.bin");
-    let syntax_set_path = PROJECT_DIRS.cache_dir().join("syntaxes.bin");
-    let metadata_file = PROJECT_DIRS.cache_dir().join("metadata.yaml");
-
-    print!("Clearing theme set cache ... ");
-    fs::remove_file(theme_set_path).ok();
-    println!("okay");
-
-    print!("Clearing syntax set cache ... ");
-    fs::remove_file(syntax_set_path).ok();
-    println!("okay");
-
-    print!("Clearing metadata file ... ");
-    fs::remove_file(metadata_file).ok();
-    println!("okay");
+    clear_asset("themes.bin", "theme set cache");
+    clear_asset("syntaxes.bin", "syntax set cache");
+    clear_asset("minimal_syntaxes.bin", "minimal syntax sets cache");
+    clear_asset("metadata.yaml", "metadata file");
 }
 
-pub fn assets_from_cache_or_binary() -> Result<HighlightingAssets> {
+pub fn assets_from_cache_or_binary(use_custom_assets: bool) -> Result<HighlightingAssets> {
     let cache_dir = PROJECT_DIRS.cache_dir();
-    if let Some(metadata) = AssetsMetadata::load_from_folder(&cache_dir)? {
+    if let Some(metadata) = AssetsMetadata::load_from_folder(cache_dir)? {
         if !metadata.is_compatible_with(crate_version!()) {
             return Err(format!(
                 "The binary caches for the user-customized syntaxes and themes \
@@ -53,6 +42,16 @@ pub fn assets_from_cache_or_binary() -> Result<HighlightingAssets> {
         }
     }
 
-    Ok(HighlightingAssets::from_cache(&cache_dir)
-        .unwrap_or_else(|_| HighlightingAssets::from_binary()))
+    let custom_assets = if use_custom_assets {
+        HighlightingAssets::from_cache(cache_dir).ok()
+    } else {
+        None
+    };
+    Ok(custom_assets.unwrap_or_else(HighlightingAssets::from_binary))
+}
+
+fn clear_asset(filename: &str, description: &str) {
+    print!("Clearing {} ... ", description);
+    fs::remove_file(PROJECT_DIRS.cache_dir().join(filename)).ok();
+    println!("okay");
 }

src/bin/bat/clap_app.rs

@@ -95,7 +95,8 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                      '--highlight-line 40' highlights line 40\n  \
                      '--highlight-line 30:40' highlights lines 30 to 40\n  \
                      '--highlight-line :40' highlights lines 1 to 40\n  \
-                     '--highlight-line 40:' highlights lines 40 to the end of the file",
+                     '--highlight-line 40:' highlights lines 40 to the end of the file\n  \
+                     '--highlight-line 30:+10' highlights lines 30 to 40",
                 ),
         )
         .arg(
@@ -294,6 +295,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
         .arg(
             Arg::with_name("no-paging")
                 .short("P")
+                .long("no-paging")
                 .alias("no-pager")
                 .overrides_with("no-paging")
                 .hidden(true)
@@ -328,7 +330,8 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                     "Map a glob pattern to an existing syntax name. The glob pattern is matched \
                      on the full path and the filename. For example, to highlight *.build files \
                      with the Python syntax, use -m '*.build:Python'. To highlight files named \
-                     '.myignore' with the Git Ignore syntax, use -m '.myignore:Git Ignore'.",
+                     '.myignore' with the Git Ignore syntax, use -m '.myignore:Git Ignore'. Note \
+                     that the right-hand side is the *name* of the syntax, not a file extension.",
                 )
                 .takes_value(true),
         )
@@ -393,8 +396,8 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                      '--style=\"..\"' option to the configuration file or export the \
                      BAT_STYLE environment variable (e.g.: export BAT_STYLE=\"..\").\n\n\
                      Possible values:\n\n  \
-                     * full: enables all available components.\n  \
-                     * auto: same as 'full', unless the output is piped (default).\n  \
+                     * full: enables all available components (default).\n  \
+                     * auto: same as 'full', unless the output is piped.\n  \
                      * plain: disables all available components.\n  \
                      * changes: show Git modification markers.\n  \
                      * header: show filenames before the content.\n  \
@@ -421,7 +424,8 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                      '--line-range 30:40' prints lines 30 to 40\n  \
                      '--line-range :40' prints lines 1 to 40\n  \
                      '--line-range 40:' prints lines 40 to the end of the file\n  \
-                     '--line-range 40' only prints line 40",
+                     '--line-range 40' only prints line 40\n  \
+                     '--line-range 30:+10' prints lines 30 to 40",
                 ),
         )
         .arg(
@@ -449,6 +453,12 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 .hidden(true)
                 .help("Do not use the configuration file"),
         )
+        .arg(
+            Arg::with_name("no-custom-assets")
+                .long("no-custom-assets")
+                .hidden(true)
+                .help("Do not load custom assets"),
+        )
         .arg(
             Arg::with_name("config-file")
                 .long("config-file")
@@ -477,6 +487,13 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 .hidden(true)
                 .help("Show bat's cache directory."),
         )
+        .arg(
+            Arg::with_name("diagnostic")
+                .long("diagnostic")
+                .alias("diagnostics")
+                .hidden_short_help(true)
+                .help("Show diagnostic information for bug reports.")
+        )
         .help_message("Print this help message.")
         .version_message("Show version information.");
 

src/bin/bat/config.rs

@@ -10,13 +10,12 @@ pub fn config_file() -> PathBuf {
     env::var("BAT_CONFIG_PATH")
         .ok()
         .map(PathBuf::from)
-        .filter(|config_path| config_path.is_file())
         .unwrap_or_else(|| PROJECT_DIRS.config_dir().join("config"))
 }
 
 pub fn generate_config_file() -> bat::error::Result<()> {
     let config_file = config_file();
-    if config_file.exists() {
+    if config_file.is_file() {
         println!(
             "A config file already exists at: {}",
             config_file.to_string_lossy()
@@ -65,13 +64,20 @@ pub fn generate_config_file() -> bat::error::Result<()> {
 #--pager="less --RAW-CONTROL-CHARS --quit-if-one-screen --mouse"
 
 # Syntax mappings: map a certain filename pattern to a language.
-#   Example 1: use the C++ syntax for .ino files
+#   Example 1: use the C++ syntax for Arduino .ino files
 #   Example 2: Use ".gitignore"-style highlighting for ".ignore" files
 #--map-syntax "*.ino:C++"
 #--map-syntax ".ignore:Git Ignore"
 "#;
 
-    fs::write(&config_file, default_config)?;
+    fs::write(&config_file, default_config).map_err(|e| {
+        format!(
+            "Failed to create config file at '{}': {}",
+            config_file.to_string_lossy(),
+            e
+        )
+    })?;
+
     println!(
         "Success! Config file written to {}",
         config_file.to_string_lossy()

src/bin/bat/directories.rs

@@ -4,8 +4,9 @@ use std::path::{Path, PathBuf};
 use lazy_static::lazy_static;
 
 /// Wrapper for 'dirs' that treats MacOS more like Linux, by following the XDG specification.
-/// This means that the `XDG_CACHE_HOME` and `XDG_CONFIG_HOME` environment variables are
-/// checked first. The fallback directories are `~/.cache/bat` and `~/.config/bat`, respectively.
+/// The `XDG_CACHE_HOME` environment variable is checked first. `BAT_CONFIG_DIR`
+///  is then checked before the `XDG_CONFIG_HOME` environment variable.
+///  The fallback directories are `~/.cache/bat` and `~/.config/bat`, respectively.
 pub struct BatProjectDirs {
     cache_dir: PathBuf,
     config_dir: PathBuf,
@@ -15,16 +16,23 @@ impl BatProjectDirs {
     fn new() -> Option<BatProjectDirs> {
         let cache_dir = BatProjectDirs::get_cache_dir()?;
 
-        #[cfg(target_os = "macos")]
-        let config_dir_op = env::var_os("XDG_CONFIG_HOME")
-            .map(PathBuf::from)
-            .filter(|p| p.is_absolute())
-            .or_else(|| dirs::home_dir().map(|d| d.join(".config")));
+        // Checks whether or not $BAT_CONFIG_DIR exists. If it doesn't, set our config dir
+        // to our system's default configuration home.
+        let config_dir =
+            if let Some(config_dir_op) = env::var_os("BAT_CONFIG_DIR").map(PathBuf::from) {
+                config_dir_op
+            } else {
+                #[cfg(target_os = "macos")]
+                let config_dir_op = env::var_os("XDG_CONFIG_HOME")
+                    .map(PathBuf::from)
+                    .filter(|p| p.is_absolute())
+                    .or_else(|| dirs_next::home_dir().map(|d| d.join(".config")));
 
-        #[cfg(not(target_os = "macos"))]
-        let config_dir_op = dirs::config_dir();
+                #[cfg(not(target_os = "macos"))]
+                let config_dir_op = dirs_next::config_dir();
 
-        let config_dir = config_dir_op.map(|d| d.join("bat"))?;
+                config_dir_op.map(|d| d.join("bat"))?
+            };
 
         Some(BatProjectDirs {
             cache_dir,
@@ -43,10 +51,10 @@ impl BatProjectDirs {
         let cache_dir_op = env::var_os("XDG_CACHE_HOME")
             .map(PathBuf::from)
             .filter(|p| p.is_absolute())
-            .or_else(|| dirs::home_dir().map(|d| d.join(".cache")));
+            .or_else(|| dirs_next::home_dir().map(|d| d.join(".cache")));
 
         #[cfg(not(target_os = "macos"))]
-        let cache_dir_op = dirs::cache_dir();
+        let cache_dir_op = dirs_next::cache_dir();
 
         cache_dir_op.map(|d| d.join("bat"))
     }

src/bin/bat/input.rs

@@ -1,15 +1,15 @@
 use bat::input::Input;
-use std::ffi::OsStr;
+use std::path::Path;
 
-pub fn new_file_input<'a>(file: &'a OsStr, name: Option<&'a OsStr>) -> Input<'a> {
-    named(Input::ordinary_file(file), name.or_else(|| Some(file)))
+pub fn new_file_input<'a>(file: &'a Path, name: Option<&'a Path>) -> Input<'a> {
+    named(Input::ordinary_file(file), name.or(Some(file)))
 }
 
-pub fn new_stdin_input(name: Option<&OsStr>) -> Input {
+pub fn new_stdin_input(name: Option<&Path>) -> Input {
     named(Input::stdin(), name)
 }
 
-fn named<'a>(input: Input<'a>, name: Option<&OsStr>) -> Input<'a> {
+fn named<'a>(input: Input<'a>, name: Option<&Path>) -> Input<'a> {
     if let Some(provided_name) = name {
         let mut input = input.with_name(Some(provided_name));
         input.description_mut().set_kind(Some("File".to_owned()));

src/bin/bat/main.rs

@@ -1,5 +1,4 @@
-// `error_chain!` can recurse deeply
-#![recursion_limit = "1024"]
+#![deny(unsafe_code)]
 
 mod app;
 mod assets;
@@ -9,7 +8,6 @@ mod directories;
 mod input;
 
 use std::collections::{HashMap, HashSet};
-use std::ffi::OsStr;
 use std::io;
 use std::io::{BufReader, Write};
 use std::path::Path;
@@ -24,37 +22,42 @@ use crate::{
 };
 
 use assets::{assets_from_cache_or_binary, cache_dir, clear_assets, config_dir};
-use clap::crate_version;
 use directories::PROJECT_DIRS;
 use globset::GlobMatcher;
 
 use bat::{
-    assets::HighlightingAssets,
     config::Config,
     controller::Controller,
     error::*,
     input::Input,
     style::{StyleComponent, StyleComponents},
-    MappingTarget,
+    MappingTarget, PagingMode,
 };
 
 const THEME_PREVIEW_DATA: &[u8] = include_bytes!("../../../assets/theme_preview.rs");
 
+#[cfg(feature = "build-assets")]
+fn build_assets(matches: &clap::ArgMatches) -> Result<()> {
+    let source_dir = matches
+        .value_of("source")
+        .map(Path::new)
+        .unwrap_or_else(|| PROJECT_DIRS.config_dir());
+    let target_dir = matches
+        .value_of("target")
+        .map(Path::new)
+        .unwrap_or_else(|| PROJECT_DIRS.cache_dir());
+
+    let blank = matches.is_present("blank");
+
+    bat::assets::build(source_dir, !blank, target_dir, clap::crate_version!())
+}
+
 fn run_cache_subcommand(matches: &clap::ArgMatches) -> Result<()> {
     if matches.is_present("build") {
-        let source_dir = matches
-            .value_of("source")
-            .map(Path::new)
-            .unwrap_or_else(|| PROJECT_DIRS.config_dir());
-        let target_dir = matches
-            .value_of("target")
-            .map(Path::new)
-            .unwrap_or_else(|| PROJECT_DIRS.cache_dir());
-
-        let blank = matches.is_present("blank");
-
-        let assets = HighlightingAssets::from_files(source_dir, !blank)?;
-        assets.save_to_cache(target_dir, crate_version!())?;
+        #[cfg(feature = "build-assets")]
+        build_assets(matches)?;
+        #[cfg(not(feature = "build-assets"))]
+        println!("bat has been built without the 'build-assets' feature. The 'cache --build' option is not available.");
     } else if matches.is_present("clear") {
         clear_assets();
     }
@@ -78,17 +81,19 @@ fn get_syntax_mapping_to_paths<'a>(
     map
 }
 
-pub fn list_languages(config: &Config) -> Result<()> {
-    let assets = assets_from_cache_or_binary()?;
+pub fn get_languages(config: &Config) -> Result<String> {
+    let mut result: String = String::new();
+
+    let assets = assets_from_cache_or_binary(config.use_custom_assets)?;
     let mut languages = assets
-        .syntaxes()
+        .get_syntaxes()?
         .iter()
         .filter(|syntax| !syntax.hidden && !syntax.file_extensions.is_empty())
         .cloned()
         .collect::<Vec<_>>();
 
     // Handling of file-extension conflicts, see issue #1076
-    for lang in languages.iter_mut() {
+    for lang in &mut languages {
         let lang_name = lang.name.clone();
         lang.file_extensions.retain(|extension| {
             // The 'extension' variable is not certainly a real extension.
@@ -97,14 +102,12 @@ pub fn list_languages(config: &Config) -> Result<()> {
             // Also skip if the 'extension' contains another real extension, likely
             // that is a full match file name like 'CMakeLists.txt' and 'Cargo.lock'
             if extension.starts_with('.') || Path::new(extension).extension().is_some() {
-                true
-            } else {
-                let test_file = Path::new("test").with_extension(extension);
-                match assets.syntax_for_file_name(test_file, &config.syntax_mapping) {
-                    Some(syntax) => syntax.name == lang_name,
-                    None => false,
-                }
+                return true;
             }
+
+            let test_file = Path::new("test").with_extension(extension);
+            let syntax_in_set = assets.get_syntax_for_path(test_file, &config.syntax_mapping);
+            matches!(syntax_in_set, Ok(syntax_in_set) if syntax_in_set.syntax.name == lang_name)
         });
     }
 
@@ -112,19 +115,16 @@ pub fn list_languages(config: &Config) -> Result<()> {
 
     let configured_languages = get_syntax_mapping_to_paths(config.syntax_mapping.mappings());
 
-    for lang in languages.iter_mut() {
+    for lang in &mut languages {
         if let Some(additional_paths) = configured_languages.get(lang.name.as_str()) {
             lang.file_extensions
                 .extend(additional_paths.iter().cloned());
         }
     }
 
-    let stdout = io::stdout();
-    let mut stdout = stdout.lock();
-
     if config.loop_through {
         for lang in languages {
-            writeln!(stdout, "{}:{}", lang.name, lang.file_extensions.join(","))?;
+            result += &format!("{}:{}\n", lang.name, lang.file_extensions.join(","));
         }
     } else {
         let longest = languages
@@ -145,7 +145,7 @@ pub fn list_languages(config: &Config) -> Result<()> {
         };
 
         for lang in languages {
-            write!(stdout, "{:width$}{}", lang.name, separator, width = longest)?;
+            result += &format!("{:width$}{}", lang.name, separator, width = longest);
 
             // Number of characters on this line so far, wrap before `desired_width`
             let mut num_chars = 0;
@@ -156,20 +156,20 @@ pub fn list_languages(config: &Config) -> Result<()> {
                 let new_chars = word.len() + comma_separator.len();
                 if num_chars + new_chars >= desired_width {
                     num_chars = 0;
-                    write!(stdout, "\n{:width$}{}", "", separator, width = longest)?;
+                    result += &format!("\n{:width$}{}", "", separator, width = longest);
                 }
 
                 num_chars += new_chars;
-                write!(stdout, "{}", style.paint(&word[..]))?;
+                result += &format!("{}", style.paint(&word[..]));
                 if extension.peek().is_some() {
-                    write!(stdout, "{}", comma_separator)?;
+                    result += comma_separator;
                 }
             }
-            writeln!(stdout)?;
+            result += "\n";
         }
     }
 
-    Ok(())
+    Ok(result)
 }
 
 fn theme_preview_file<'a>() -> Input<'a> {
@@ -177,7 +177,7 @@ fn theme_preview_file<'a>() -> Input<'a> {
 }
 
 pub fn list_themes(cfg: &Config) -> Result<()> {
-    let assets = assets_from_cache_or_binary()?;
+    let assets = assets_from_cache_or_binary(cfg.use_custom_assets)?;
     let mut config = cfg.clone();
     let mut style = HashSet::new();
     style.insert(StyleComponent::Plain);
@@ -200,34 +200,86 @@ pub fn list_themes(cfg: &Config) -> Result<()> {
                 .ok();
             writeln!(stdout)?;
         }
+        writeln!(
+            stdout,
+            "Further themes can be installed to '{}', \
+            and are added to the cache with `bat cache --build`. \
+            For more information, see:\n\n  \
+            https://github.com/sharkdp/bat#adding-new-themes",
+            PROJECT_DIRS.config_dir().join("themes").to_string_lossy()
+        )?;
     } else {
         for theme in assets.themes() {
             writeln!(stdout, "{}", theme)?;
         }
     }
-    writeln!(
-        stdout,
-        "Further themes can be installed to '{}', \
-        and are added to the cache with `bat cache --build`. \
-        For more information, see:\n\n  \
-        https://github.com/sharkdp/bat#adding-new-themes",
-        config_file().join("themes").to_string_lossy()
-    )?;
 
     Ok(())
 }
 
 fn run_controller(inputs: Vec<Input>, config: &Config) -> Result<bool> {
-    let assets = assets_from_cache_or_binary()?;
-    let controller = Controller::new(&config, &assets);
+    let assets = assets_from_cache_or_binary(config.use_custom_assets)?;
+    let controller = Controller::new(config, &assets);
     controller.run(inputs)
 }
 
+#[cfg(feature = "bugreport")]
+fn invoke_bugreport(app: &App) {
+    use bugreport::{bugreport, collector::*, format::Markdown};
+    let pager = bat::config::get_pager_executable(app.matches.value_of("pager"))
+        .unwrap_or_else(|| "less".to_owned()); // FIXME: Avoid non-canonical path to "less".
+
+    let mut report = bugreport!()
+        .info(SoftwareVersion::default())
+        .info(OperatingSystem::default())
+        .info(CommandLine::default())
+        .info(EnvironmentVariables::list(&[
+            "SHELL",
+            "PAGER",
+            "LESS",
+            "LANG",
+            "LC_ALL",
+            "BAT_PAGER",
+            "BAT_CACHE_PATH",
+            "BAT_CONFIG_PATH",
+            "BAT_OPTS",
+            "BAT_STYLE",
+            "BAT_TABS",
+            "BAT_THEME",
+            "XDG_CONFIG_HOME",
+            "XDG_CACHE_HOME",
+            "COLORTERM",
+            "NO_COLOR",
+            "MANPAGER",
+        ]))
+        .info(FileContent::new("Config file", config_file()))
+        .info(CompileTimeInformation::default());
+
+    #[cfg(feature = "paging")]
+    if let Ok(resolved_path) = grep_cli::resolve_binary(pager) {
+        report = report.info(CommandOutput::new(
+            "Less version",
+            resolved_path,
+            &["--version"],
+        ))
+    };
+
+    report.print::<Markdown>();
+}
+
 /// Returns `Err(..)` upon fatal errors. Otherwise, returns `Ok(true)` on full success and
 /// `Ok(false)` if any intermediate errors occurred (were printed).
 fn run() -> Result<bool> {
     let app = App::new()?;
 
+    if app.matches.is_present("diagnostic") {
+        #[cfg(feature = "bugreport")]
+        invoke_bugreport(&app);
+        #[cfg(not(feature = "bugreport"))]
+        println!("bat has been built without the 'bugreport' feature. The '--diagnostic' option is not available.");
+        return Ok(true);
+    }
+
     match app.matches.subcommand() {
         ("cache", Some(cache_matches)) => {
             // If there is a file named 'cache' in the current working directory,
@@ -237,7 +289,7 @@ fn run() -> Result<bool> {
                 run_cache_subcommand(cache_matches)?;
                 Ok(true)
             } else {
-                let inputs = vec![Input::ordinary_file(OsStr::new("cache"))];
+                let inputs = vec![Input::ordinary_file("cache")];
                 let config = app.config(&inputs)?;
 
                 run_controller(inputs, &config)
@@ -248,8 +300,14 @@ fn run() -> Result<bool> {
             let config = app.config(&inputs)?;
 
             if app.matches.is_present("list-languages") {
-                list_languages(&config)?;
-                Ok(true)
+                let languages: String = get_languages(&config)?;
+                let inputs: Vec<Input> = vec![Input::from_reader(Box::new(languages.as_bytes()))];
+                let plain_config = Config {
+                    style_components: StyleComponents::new(StyleComponent::Plain.components(false)),
+                    paging_mode: PagingMode::QuitIfOneScreen,
+                    ..Default::default()
+                };
+                run_controller(inputs, &plain_config)
             } else if app.matches.is_present("list-themes") {
                 list_themes(&config)?;
                 Ok(true)