Bump version

Bumps [ansi_term](https://github.com/ogham/rust-ansi-term) from 0.12.0 to 0.12.1.
- [Release notes](https://github.com/ogham/rust-ansi-term/releases)
- [Commits](https://github.com/ogham/rust-ansi-term/compare/v0.12.0...v0.12.1)

Signed-off-by: dependabot-preview[bot] <support@dependabot.com>

.gitmodules

@@ -123,3 +123,33 @@
 [submodule "assets/syntaxes/varlink"]
 	path = assets/syntaxes/varlink
 	url = https://github.com/varlink/syntax-highlight-varlink.git
+[submodule "assets/syntaxes/sublime-fish"]
+	path = assets/syntaxes/sublime-fish
+	url = https://github.com/Phidica/sublime-fish.git
+[submodule "assets/syntaxes/Org mode"]
+	path = assets/syntaxes/Org mode
+	url = https://github.com/jezcope/Org.tmbundle.git
+[submodule "assets/syntaxes/requirementstxt"]
+	path = assets/syntaxes/requirementstxt
+	url = https://github.com/wuub/requirementstxt
+[submodule "assets/syntaxes/DotENV"]
+	path = assets/syntaxes/DotENV
+	url = https://github.com/zaynali53/DotENV
+[submodule "assets/syntaxes/hosts"]
+	path = assets/syntaxes/hosts
+	url = https://github.com/brandonwamboldt/sublime-hosts
+[submodule "assets/syntaxes/ssh-config"]
+	path = assets/syntaxes/ssh-config
+	url = https://github.com/robballou/sublimetext-sshconfig.git
+[submodule "assets/syntaxes/GraphQL"]
+	path = assets/syntaxes/GraphQL
+	url = https://github.com/dncrews/GraphQL-SublimeText3.git
+[submodule "assets/syntaxes/Verilog"]
+	path = assets/syntaxes/Verilog
+	url = https://github.com/pro711/sublime-verilog
+[submodule "assets/syntaxes/SCSS_Sass"]
+	path = assets/syntaxes/SCSS_Sass
+	url = https://github.com/braver/SublimeSass
+[submodule "assets/syntaxes/Strace"]
+	path = assets/syntaxes/Strace
+	url = https://github.com/djuretic/SublimeStrace

.travis.yml

@@ -32,15 +32,15 @@ matrix:
 
     # Minimum Rust supported channel.
     - os: linux
-      rust: 1.30.0
+      rust: 1.35.0
       env: TARGET=x86_64-unknown-linux-gnu
     - os: linux
-      rust: 1.30.0
+      rust: 1.35.0
       env:
         - TARGET=x86_64-unknown-linux-musl
         - CC_x86_64_unknown_linux_musl=/usr/bin/musl-gcc
     - os: osx
-      rust: 1.30.0
+      rust: 1.35.0
       env: TARGET=x86_64-apple-darwin
 
     # Code formatting check

Cargo.toml

@@ -7,37 +7,38 @@ license = "MIT/Apache-2.0"
 name = "bat"
 readme = "README.md"
 repository = "https://github.com/sharkdp/bat"
-version = "0.10.0"
+version = "0.12.1"
 exclude = [
     "assets/syntaxes/*",
     "assets/themes/*",
 ]
 build = "build.rs"
+edition = '2018'
 
 [dependencies]
-atty = "0.2.2"
-ansi_term = "0.11"
+atty = "0.2.13"
+ansi_term = "^0.12.1"
 ansi_colours = "^1.0"
-console = "0.7"
-dirs = "1.0"
-lazy_static = "1.2"
+console = "0.8"
+dirs = "2.0"
+lazy_static = "1.4"
 wild = "2.0"
 content_inspector = "0.2.4"
 encoding = "0.2"
 shell-words = "0.1.0"
 
 [dependencies.git2]
-version = "0.8"
+version = "0.10"
 default-features = false
 features = []
 
 [dependencies.syntect]
-version = "3.0.2"
+version = "3.2.1"
 default-features = false
 features = ["parsing", "yaml-load", "dump-load", "dump-create"]
 
 [dependencies.clap]
-version = "2.32"
+version = "2.33"
 default-features = false
 features = ["suggestions", "color", "wrap_help"]
 
@@ -48,8 +49,8 @@ features = []
 
 [dev-dependencies]
 tempdir = "0.3"
-assert_cmd = "0.11.0"
-escargot = "0.4.0"
+assert_cmd = "0.11.1"
+escargot = "0.5.0"
 
 [build-dependencies]
-clap = "2.32"
+clap = "2.33"

README.md

@@ -91,15 +91,78 @@ bat -n main.rs  # show line numbers (only)
 bat f - g  # output 'f', then stdin, then 'g'.
 ```
 
+### Integration with other tools
+
+#### `find` or `fd`
+
+You can use the `-exec` option of `find` to preview all search results with `bat`:
+```bash
+find … -exec bat {} +
+```
+
+If you happen to use [`fd`](https://github.com/sharkdp/fd), you can use the `-X`/`--exec-batch` option to do the same:
+```bash
+fd … -X bat
+```
+
+#### `tail -f`
+
+`bat` can be combined with `tail -f` to continuously monitor a given file with syntax highlighting.
+```bash
+tail -f /var/log/pacman.log | bat --paging=never -l log
+```
+Note that we have to switch off paging in order for this to work. We have also specified the syntax
+explicitly (`-l log`), as it can not be auto-detected in this case.
+
+#### `git show`
+
+You can combine `bat` with `git show` to view an older version of a given file with proper syntax
+highlighting:
+```bash
+git show v0.6.0:src/main.rs | bat -l rs
+```
+
+#### `xclip`
+
+The line numbers and Git modification markers in the output of `bat` can make it hard to copy
+the contents of a file. To prevent this, you can call `bat` with the `-p`/`--plain` option or
+simply pipe the output into `xclip`:
+```bash
+bat main.cpp | xclip
+```
+`bat` will detect that the output is being redirected and print the plain file contents.
+
+#### `man`
+
+`bat` can be used as a pager for `man`. It can be used like this:
+```
+export MANPAGER="sh -c 'col -b | bat -l man -p'"
+
+man 2 select
+```
+
+The [Manpage syntax](assets/syntaxes/Manpage.sublime-syntax) is developed in this repository and still needs some work.
+
 ## Installation
 
+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat.svg)](https://repology.org/project/bat/versions)
+
 ### On Ubuntu
 *... and other Debian-based Linux distributions.*
 
 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.10.0_amd64.deb  # adapt version number and architecture
+sudo dpkg -i bat_0.12.1_amd64.deb  # adapt version number and architecture
+```
+
+### On Alpine Linux
+
+You can install [the `bat` package](https://pkgs.alpinelinux.org/packages?name=bat)
+from the official sources, provided you have the appropriate repository enabled:
+
+```bash
+apk add bat
 ```
 
 ### On Arch Linux
@@ -113,10 +176,19 @@ pacman -S bat
 
 ### On Fedora
 
-You can install `bat` from the [Fedora Modular](https://docs.fedoraproject.org/en-US/modularity/using-modules/) repository. On Fedora 29 and higher, it is enabled by default. Otherwise, run `dnf install fedora-repos-modular` to set up, and make sure that the `fedora-modular` and `fedora-updates-modular` repos are enabled in `/etc/yum.repos.d`.
+You can install [the `bat` package](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506) from the official [Fedora Modular](https://docs.fedoraproject.org/en-US/modularity/using-modules/) repository.
 
 ```bash
-dnf module install bat
+dnf install bat
+```
+
+### On Gentoo Linux
+
+You can install [the `bat` package](https://packages.gentoo.org/packages/sys-apps/bat)
+from the official sources:
+
+```bash
+emerge sys-apps/bat
 ```
 
 ### On Void Linux
@@ -168,12 +240,16 @@ brew install bat
 ### On Windows
 
 You can download prebuilt binaries from the [Release page](https://github.com/sharkdp/bat/releases),
-or install it with [scoop](https://scoop.sh/):
+or install it with [scoop](https://scoop.sh/) or [Chocolatey](https://chocolatey.org):
 
 ```bash
 scoop install bat
 ```
 
+```bash
+choco install bat
+```
+
 [See below](#using-bat-on-windows) for notes.
 
 ### Via Docker
@@ -220,7 +296,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.30 or
+If you want to build `bat` from source, you need Rust 1.35 or
 higher. You can then use `cargo` to build everything:
 
 ```bash
@@ -389,7 +465,7 @@ Example configuration file:
 Windows only includes a very limited pager in the form of `more`. You can download a Windows binary
 for `less` [from its homepage](http://www.greenwoodsoftware.com/less/download.html) or [through
 Chocolatey](https://chocolatey.org/packages/Less). To use it, place the binary in a directory in
-your `PATH` or [define an environment variable](#using-a-different-pager).
+your `PATH` or [define an environment variable](#using-a-different-pager). The [Chocolatey package](#on-windows) installs `less` automatically.
 
 ### Colors
 

assets/README.md

@@ -33,6 +33,7 @@ The following files have been manually modified after converting from a `.tmLang
 
 * `Dart.sublime-syntax` => removed `#regex.dart` include.
 * `INI.sublime-syntax` => added `.hgrc`, `hgrc`, and `desktop` file types.
+* `Org mode.sublime-syntax` => removed `task` file type.
 
 ### Non-submodule additions
 

assets/completions/bat.fish

@@ -0,0 +1,76 @@
+# Fish Shell Completions
+# Place or symlink to $XDG_CONFIG_HOME/fish/completions/bat.fish ($XDG_CONFIG_HOME is usually set to ~/.config)
+
+# Helper function:
+function __bat_autocomplete_languages --description "A helper function used by "(status filename)
+	bat --list-languages | awk -F':' '
+		{
+			lang=$1
+			split($2, exts, ",")
+
+			for (i in exts) {
+				ext=exts[i]
+				if (ext !~ /[A-Z].*/ && ext !~ /^\..*rc$/) {
+					print ext"\t"lang
+				}
+			}
+		}
+	' | sort
+end
+
+# Completions:
+
+complete -c bat -l color -xka "auto never always" -d "Specify when to use colored output (default: auto)" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -l config-dir -d "Display location of 'bat' configuration directory" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -l config-file -d "Display location of 'bat' configuration file" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -l decorations -xka "auto never always" -d "Specify when to use the decorations specified with '--style' (default: auto)" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -s h -l help -d "Print help message" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -s H -l highlight-line -x -d "<N> Highlight the N-th line with a different background color" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -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 bat -s l -l language -d "Set the language for syntax highlighting" -n "not __fish_seen_subcommand_from cache" -xa "(__bat_autocomplete_languages)" 
+
+complete -c bat -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"
+
+complete -c bat -l list-languages -d "Display list of supported languages for syntax highlighting" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -l list-themes -d "Display a list of supported themes for syntax highlighting" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -s m -l map-syntax -x -d "<from:to> Map a file extension or file name to an existing syntax" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -s n -l number -d "Only show line numbers, no other decorations. Alias for '--style=numbers'" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -l pager -x -d "<command> Specify which pager program to use (default: less)" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -l paging -xka "auto never always" -d "Specify when to use the pager (default: auto)" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -s p -l plain -d "Only show plain style, no decorations. Alias for '--style=plain'" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -s A -l show-all -d "Show non-printable characters like space/tab/newline" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -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 bat -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"
+
+complete -c bat -l terminal-width -x -d "<width> Explicitly set terminal width; Prefix with '+' or '-' to offset (default width is auto determined)" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -l theme -xka "(bat --list-themes | cat)" -d "Set the theme for syntax highlighting" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -s u -l unbuffered -d "POSIX-compliant unbuffered output. Option is ignored" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -s V -l version -d "Show version information" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -l wrap -xka "auto never character" -d "<mode> Specify the text-wrapping mode (default: auto)" -n "not __fish_seen_subcommand_from cache"
+
+# Sub-command 'cache' completions
+complete -c bat -a "cache" -d "Modify the syntax/language definition cache" -n "not __fish_seen_subcommand_from cache"
+
+complete -c bat -l build -f -d "Parse syntaxes/language definitions into cache" -n "__fish_seen_subcommand_from cache"
+
+complete -c bat -l clear -f -d "Reset syntaxes/language definitions to default settings" -n "__fish_seen_subcommand_from cache"

assets/create.sh

@@ -1,4 +1,5 @@
 #!/bin/bash
+set -euo pipefail
 
 ASSET_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 

assets/syntaxes/DotENV.sublime-syntax

@@ -0,0 +1,88 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: DotENV
+file_extensions:
+  - .env
+  - .envrc
+  - .env.dist
+  - .env.local
+  - .env.sample
+  - .env.example
+  - .env.test
+  - .env.test.local
+  - .env.dev
+  - .env.development
+  - .env.development.local
+  - .env.prod
+  - .env.production
+  - .env.production.local
+  - .env.dusk.local
+scope: source.env
+contexts:
+  main:
+    - match: (#).*$\n?
+      comment: "Comments - starts with #"
+      scope: comment.line.number-sign.env
+      captures:
+        1: punctuation.definition.comment.env
+    - match: (\")
+      comment: Strings (double)
+      captures:
+        1: punctuation.definition.string.begin.env
+      push:
+        - meta_scope: string.quoted.double.env
+        - match: (\")
+          captures:
+            1: punctuation.definition.string.end
+          pop: true
+        - include: interpolation
+        - include: variable
+        - include: escape-characters
+    - match: (\')
+      comment: Strings (single)
+      captures:
+        1: punctuation.definition.string.begin.env
+      push:
+        - meta_scope: string.quoted.single.env
+        - match: (\')
+          captures:
+            1: punctuation.definition.string.end
+          pop: true
+    - match: '(?<=[\w])\s?='
+      comment: Assignment Operator
+      scope: keyword.operator.assignment.env
+    - match: '([\w]+)(?=\s?\=)'
+      comment: Variable
+      scope: variable.other.env
+    - match: (?i)\s?(export)
+      comment: Keywords
+      scope: keyword.other.env
+    - match: (?i)(?<=\=)\s?(true|false|null)
+      comment: Constants
+      scope: constant.language.env
+    - match: '\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b'
+      comment: Numeric
+      scope: constant.numeric.env
+  escape-characters:
+    - match: '\\[nrt\\\$\"\'']'
+      scope: constant.character.escape.env
+  interpolation:
+    - match: '(\$\{|\{)'
+      comment: 'Template Syntax: "foo ${bar} {$baz}"'
+      captures:
+        1: string.interpolated.env keyword.other.template.begin.env
+      push:
+        - match: '(\})'
+          captures:
+            1: string.interpolated.env keyword.other.template.end.env
+          pop: true
+        - match: '(?x)(\$+)?([a-zA-Z_\x{7f}-\x{ff}][a-zA-Z0-9_\x{7f}-\x{ff}]*?\b)'
+          captures:
+            1: punctuation.definition.variable.env variable.other.env
+            2: variable.other.env
+  variable:
+    - match: '(?x)(\$+)([a-zA-Z_\x{7f}-\x{ff}][a-zA-Z0-9_\x{7f}-\x{ff}]*?\b)'
+      captures:
+        1: punctuation.definition.variable.env variable.other.env
+        2: variable.other.env

assets/syntaxes/FSharp.sublime-syntax

@@ -9,63 +9,230 @@ file_extensions:
 scope: source.fsharp
 contexts:
   main:
+    - include: compiler_directives
     - include: comments
     - include: constants
-    - include: structure
-    - include: attributes
     - include: strings
+    - include: chars
+    - include: double_tick
     - include: definition
-    - include: method_calls
+    - include: abstract_definition
+    - include: attributes
     - include: modules
     - include: anonymous_functions
+    - include: du_declaration
+    - include: record_declaration
+    - include: records
+    - include: strp_inlined
     - include: keywords
+    - include: cexprs
+    - include: text
+  abstract_definition:
+    - match: '\b(abstract)\s+(member)?(\s+\[\<.*\>\])?\s*([_[:alpha:]0-9,\._`\s]+)(:)'
+      captures:
+        1: keyword.fsharp
+        2: keyword.fsharp
+        3: support.function.attribute.fsharp
+        5: keyword.fsharp
+      push:
+        - meta_scope: abstract.definition.fsharp
+        - match: \s*(with)\b|=|$
+          captures:
+            1: keyword.fsharp
+          pop: true
+        - include: comments
+        - include: common_declaration
+        - match: '(\?{0,1})([[:alpha:]0-9''`^._ ]+)\s*(:)(\s*([[:alpha:]0-9''`^._ ]+)){0,1}'
+          captures:
+            1: keyword.symbol.fsharp
+            2: variable.parameter.fsharp
+            3: keyword.symbol.fsharp
+            4: entity.name.type.fsharp
+        - match: '(?!with|get|set\b)\b([\w0-9''`^._]+)'
+          captures:
+            1: entity.name.type.fsharp
+        - include: keywords
   anonymous_functions:
     - match: \b(fun)\b
       captures:
-        1: keyword.other.function-definition.fsharp
+        1: keyword.fsharp
       push:
-        - meta_scope: meta.function.anonymous
+        - meta_scope: function.anonymous
         - match: (->)
           captures:
-            1: keyword.other.fsharp
+            1: keyword.fsharp
           pop: true
+        - include: comments
+        - match: (\()
+          captures:
+            1: keyword.symbol.fsharp
+          push:
+            - match: \s*(?=(->))
+              captures:
+                1: keyword.symbol.fsharp
+              pop: true
+            - include: member_declaration
         - include: variables
   attributes:
     - match: '\[\<'
       push:
         - meta_scope: support.function.attribute.fsharp
-        - match: '\>\]'
+        - match: '\>\]|\]'
           pop: true
         - include: main
-  characters:
-    - match: (')
+  cexprs:
+    - match: '\b(async|seq|promise|task|maybe|asyncMaybe|controller|scope|application|pipeline)\s*\{'
+      scope: cexpr.fsharp
       captures:
-        1: punctuation.definition.string.begin.fsharp
-      push:
-        - meta_scope: string.quoted.single.fsharp
-        - match: (')
-          captures:
-            1: punctuation.definition.string.end.fsharp
-          pop: true
-        - match: '\\$[ \t]*'
-          scope: punctuation.separator.string.ignore-eol.fsharp
-        - match: '\\([\\""ntbr]|u[a-fA-F0-9]{4}|u[a-fA-F0-9]{8})'
-          scope: constant.character.string.escape.fsharp
-        - match: '\\(?![\\''ntbr]|u[a-fA-F0-9]{4}|u[a-fA-F0-9]{8}).'
-          scope: invalid.illeagal.character.string.fsharp
+        0: keyword.fsharp
+  chars:
+    - match: ('\\?.')
+      scope: char.fsharp
+      captures:
+        1: string.quoted.single.fsharp
   comments:
-    - match: \(\*\*?(\*)\)
-      scope: comment.block.fsharp
+    - match: (\(\*(?!\)))
       captures:
-        1: comment.block.empty.fsharp
-    - match: '\(\*[^\)]'
+        1: comment.block.fsharp
       push:
         - meta_scope: comment.block.fsharp
-        - match: \*\)
+        - match: (\*\))
+          captures:
+            1: comment.block.fsharp
           pop: true
-        - include: comments
     - match: //.*$
       scope: comment.line.double-slash.fsharp
+  common_binding_definition:
+    - include: comments
+    - include: attributes
+    - match: (:)\s*(\()\s*(static member|member)
+      captures:
+        1: keyword.symbol.fsharp
+        2: keyword.symbol.fsharp
+        3: keyword.fsharp
+      push:
+        - match: (\))\s*((?=,)|(?=\=))
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - match: '(\^[[:alpha:]0-9''._]+)'
+          captures:
+            1: entity.name.type.fsharp
+        - include: variables
+        - include: keywords
+    - match: (:)\s*(\()
+      captures:
+        1: keyword.symbol.fsharp
+        2: keyword.symbol.fsharp
+      push:
+        - match: '(\)\s*(([?[:alpha:]0-9''`^._ ]*)))'
+          captures:
+            1: keyword.symbol.fsharp
+            2: entity.name.type.fsharp
+          pop: true
+        - include: tuple_signature
+    - match: '(:)\s*(\^[[:alpha:]0-9''._]+)\s*(when)'
+      captures:
+        1: keyword.symbol.fsharp
+        2: entity.name.type.fsharp
+        3: keyword.fsharp
+      push:
+        - match: (?=:)
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - match: \b(and|when|or)\b
+          scope: keyword.fsharp
+        - match: "([[:alpha:]0-9'^._]+)"
+          comment: Because we first capture the keywords, we can capture what looks like a word and assume it's an entity definition
+          captures:
+            1: entity.name.type.fsharp
+        - match: (\(|\))
+          scope: keyword.symbol.fsharp
+    - match: '(:)\s*([?[:alpha:]0-9''`^._ ]+)'
+      captures:
+        1: keyword.symbol.fsharp
+        2: entity.name.type.fsharp
+    - match: '(->)\s*(\()?\s*([?[:alpha:]0-9''`^._ ]+)*'
+      captures:
+        1: keyword.symbol.fsharp
+        2: keyword.symbol.fsharp
+        3: entity.name.type.fsharp
+    - match: (\*)\s*(\()
+      captures:
+        1: keyword.symbol.fsharp
+        2: keyword.symbol.fsharp
+      push:
+        - match: '(\)\s*(([?[:alpha:]0-9''`^._ ]+))+)'
+          captures:
+            1: keyword.symbol.fsharp
+            2: entity.name.type.fsharp
+          pop: true
+        - include: tuple_signature
+    - match: '(\*)(\s*([?[:alpha:]0-9''`^._ ]+))*'
+      captures:
+        1: keyword.symbol.fsharp
+        2: entity.name.type.fsharp
+    - match: '(<(?![[:space:]]*\)))'
+      captures:
+        1: keyword.symbol.fsharp
+      push:
+        - match: ((?<!:)>)
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - include: generic_declaration
+    - match: "({)"
+      captures:
+        1: keyword.symbol.fsharp
+      push:
+        - match: "(})"
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - include: record_signature
+    - include: definition
+    - include: variables
+    - include: keywords
+  common_declaration:
+    - match: '\s*(->)\s*([[:alpha:]0-9''`^._ ]+)(<)'
+      captures:
+        1: keyword.symbol.fsharp
+        2: entity.name.type.fsharp
+        3: keyword.symbol.fsharp
+      push:
+        - match: (>)
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - match: "([[:alpha:]0-9'`^._ ]+)"
+          captures:
+            1: entity.name.type.fsharp
+        - include: keywords
+    - match: '\s*(->)\s*(?!with|get|set\b)\b([\w0-9''`^._]+)'
+      captures:
+        1: keyword.symbol.fsharp
+        2: entity.name.type.fsharp
+    - match: '(\?{0,1})([[:alpha:]0-9''`^._ ]+)\s*(:)(\s*([?[:alpha:]0-9''`^._ ]+)(<))'
+      captures:
+        1: keyword.symbol.fsharp
+        2: variable.parameter.fsharp
+        3: keyword.symbol.fsharp
+        4: keyword.symbol.fsharp
+        5: entity.name.type.fsharp
+      push:
+        - match: (>)
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - match: "([[:alpha:]0-9'`^._ ]+)"
+          captures:
+            1: entity.name.type.fsharp
+        - include: keywords
+  compiler_directives:
+    - match: \s?(#if|#elif|#else|#elseif|#endif|#light|#nowarn)
+      scope: compiler_directive.fsharp
+      captures:
   constants:
     - match: \(\)
       scope: constant.language.unit.fsharp
@@ -73,123 +240,349 @@ contexts:
       scope: constant.numeric.floating-point.fsharp
     - match: '\b(-?((0(x|X)[0-9a-fA-F][0-9a-fA-F_]*)|(0(o|O)[0-7][0-7_]*)|(0(b|B)[01][01_]*)|([0-9][0-9_]*)))'
       scope: constant.numeric.integer.nativeint.fsharp
+    - match: \b(true|false|null|unit)\b
+      scope: constant.others.fsharp
   definition:
-    - match: '\b(val|val|let|and|member|override|use)\s?(rec|inline|mutable)?(\s+\(?([a-zA-Z.\|_][a-zA-Z0-9.|_]*)\)?\w*)\b'
+    - match: '\b(let mutable|static let mutable|let inline|let|member val|static member inline|static member|default|member|override|let!)(\s+rec|mutable)?(\s+\[\<.*\>\])?\s*(private|internal|public)?\s+(\[[^-=]*\]|[_[:alpha:]]([_[:alpha:]0-9,\._]+)*|``[_[:alpha:]]([_[:alpha:]0-9,\._`\s]+|(?<=,)\s)*)?'
       captures:
-        1: keyword.other.binding.fsharp
-        2: keyword.other.function-recursive.fsharp
-        3: variable.other.binding.fsharp
+        1: keyword.fsharp
+        2: keyword.fsharp
+        3: support.function.attribute.fsharp
+        4: keyword.fsharp
+        5: variable.fsharp
       push:
-        - meta_scope: meta.binding.fsharp
-        - match: "=|$"
+        - meta_scope: binding.fsharp
+        - match: \s*(with\b|=|\n+=|(?<=\=))
           captures:
-            1: punctuation.separator.function.type-constraint.fsharp
+            1: keyword.fsharp
           pop: true
+        - include: common_binding_definition
+    - match: '\b(static val mutable|val mutable|val)(\s+rec|mutable)?(\s+\[\<.*\>\])?\s*(private|internal|public)?\s+(\[[^-=]*\]|[_[:alpha:]]([_[:alpha:]0-9,\._]+)*|``[_[:alpha:]]([_[:alpha:]0-9,\._`\s]+|(?<=,)\s)*)?'
+      captures:
+        1: keyword.fsharp
+        2: keyword.fsharp
+        3: support.function.attribute.fsharp
+        4: keyword.fsharp
+        5: variable.fsharp
+      push:
+        - meta_scope: binding.fsharp
+        - match: \n$
+          pop: true
+        - include: common_binding_definition
+  double_tick:
+    - match: (``)(.*)(``)
+      scope: variable.other.binding.fsharp
+      captures:
+        1: string.quoted.single.fsharp
+        2: variable.other.binding.fsharp
+        3: string.quoted.single.fsharp
+  du_declaration:
+    - match: \b(of)\b
+      captures:
+        1: keyword.fsharp
+      push:
+        - meta_scope: du_declaration.fsharp
+        - match: $|(\|)
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - include: comments
+        - match: '([[:alpha:]0-9''`<>^._]+|``[[:alpha:]0-9'' <>^._]+``)\s*(:)\s*([[:alpha:]0-9''`<>^._]+|``[[:alpha:]0-9'' <>^._]+``)'
+          captures:
+            1: variable.parameter.fsharp
+            2: keyword.symbol.fsharp
+            3: entity.name.type.fsharp
+        - match: "([[:alpha:]0-9'`^._]+)|``([[:alpha:]0-9'^._ ]+)``"
+          captures:
+            1: entity.name.type.fsharp
+        - include: keywords
+  generic_declaration:
+    - match: (:)\s*(\()\s*(static member|member)
+      captures:
+        1: keyword.symbol.fsharp
+        2: keyword.symbol.fsharp
+        3: keyword.fsharp
+      push:
+        - match: (\))
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - match: (\()
+          captures:
+            1: keyword.symbol.fsharp
+          push:
+            - match: (\))
+              captures:
+                1: keyword.symbol.fsharp
+              pop: true
+            - include: member_declaration
+        - match: '((''|\^)[[:alpha:]0-9''._]+)'
+          captures:
+            1: entity.name.type.fsharp
         - include: variables
-    - match: \b(let)\s+((\(\))|(_))\s+=
-      scope: meta.expression.fsharp
+        - include: keywords
+    - match: \b(private|to|public|internal|function|yield!|yield|class|exception|match|delegate|of|new|in|as|if|then|else|elif|for|begin|end|inherit|do|let\!|return\!|return|interface|with|abstract|property|union|enum|member|try|finally|and|when|use|use\!|struct|while|mutable)(?!')\b
+      scope: keyword.fsharp
+    - match: ":"
+      scope: keyword.fsharp
+    - include: constants
+    - match: '((''|\^)[[:alpha:]0-9''._]+)'
       captures:
-        1: keyword.other.binding.fsharp
-        2: keyword.other.function-recursive.fsharp
-        4: constant.language.unit.fsharp
-        5: constant.language.ignored.fsharp
-  keywords:
-    - match: ^\s*#\s*(light|if|else|endif|r|I|load|time|help|quit)\b
+        1: entity.name.type.fsharp
+    - match: (<)
+      captures:
+        1: keyword.symbol.fsharp
       push:
-        - meta_scope: meta.preprocessor.fsharp
-        - match: (\s|$)
-          pop: true
-    - match: \b(new|in|as|if|then|else|elif|for|begin|end|match|with|type|inherit|true|false|null|do)\b
-      scope: keyword.other.fsharp
-    - match: '(\|>|\|?>|\->|\<\-|:>|:|\[|\]|\;|\||_)'
-      scope: entity.name
-  method_calls:
-    - match: '(?<!\w)([a-z]\w*)(\.)'
-      push:
-        - meta_scope: meta.method-call.fsharp
-        - match: '[A-Z]\w*(\.)'
-          scope: meta.method.fsharp
+        - match: (>)
           captures:
-            1: punctuation.separator.method-call.fsharp
-        - match: (?=.)
+            1: keyword.symbol.fsharp
           pop: true
-  modules:
-    - match: '\b(namespace|module)\s+([a-zA-Z][a-zA-Z0-9''_.]*)'
+        - match: '((''|\^)[[:alpha:]0-9''._]+)'
+          captures:
+            1: entity.name.type.fsharp
+        - include: tuple_signature
+        - include: generic_declaration
+    - match: '(?!when|and|or\b)\b([\w0-9''`^._]+)'
       captures:
-        1: keyword.other.fsharp
+        1: entity.name.type.fsharp
+    - match: (\|)
+      captures:
+        1: keyword.symbol.fsharp
+    - include: keywords
+  keywords:
+    - match: \b(private|to|public|internal|function|yield!|yield|class|exception|match|delegate|of|new|in|as|if|then|else|elif|for|begin|end|inherit|do|let\!|return\!|return|interface|with|abstract|property|union|enum|member|try|finally|and|when|or|use|use\!|struct|while|mutable)(?!')\b
+      scope: keyword.fsharp
+    - match: '(&&&|\|\|\||\^\^\^|~~~|<<<|>>>|\|>|\->|\<\-|:>|:\?>|:|\[|\]|\;|<>|=|@|\|\||&&|{|}|\||_|\.\.|\,|\+|\-|\*|\/|\^|\!|\>|\>\=|\>\>|\<|\<\=|\(|\)|\<\<)'
+      scope: keyword.symbol.fsharp
+  member_declaration:
+    - include: comments
+    - include: common_declaration
+    - match: (:)\s*(\()\s*(static member|member)
+      captures:
+        1: keyword.symbol.fsharp
+        2: keyword.symbol.fsharp
+        3: keyword.fsharp
+      push:
+        - match: (\))\s*((?=,)|(?=\=))
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - match: (\()
+          captures:
+            1: keyword.symbol.fsharp
+          push:
+            - match: (\))
+              captures:
+                1: keyword.symbol.fsharp
+              pop: true
+            - include: member_declaration
+        - match: '(\^[[:alpha:]0-9''._]+)'
+          captures:
+            1: entity.name.type.fsharp
+        - include: variables
+        - include: keywords
+    - match: '(\^[[:alpha:]0-9''._]+)'
+      captures:
+        1: entity.name.type.fsharp
+    - match: \b(and|when|or)\b
+      scope: keyword.fsharp
+    - match: (\(|\))
+      scope: keyword.symbol.fsharp
+    - match: '(\?{0,1})([[:alpha:]0-9''`^._]+|``[[:alpha:]0-9''`^:,._ ]+``)\s*(:{0,1})(\s*([?[:alpha:]0-9''`<>._ ]+)){0,1}'
+      captures:
+        1: keyword.symbol.fsharp
+        2: variable.parameter.fsharp
+        3: keyword.symbol.fsharp
+        4: entity.name.type.fsharp
+    - include: keywords
+  modules:
+    - match: '\b(namespace|module)\s*(public|internal|private)?\s+([[:alpha:]][[:alpha:]0-9''_. ]*)'
+      captures:
+        1: keyword.fsharp
+        2: keyword.fsharp
+        3: entity.name.section.fsharp
+      push:
+        - meta_scope: entity.name.section.fsharp
+        - match: (\s?=|\s|$)
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - match: '(\.)([A-Z][[:alpha:]0-9''_]*)'
+          scope: entity.name.section.fsharp
+          captures:
+            1: punctuation.separator.namespace-reference.fsharp
+            2: entity.name.section.fsharp
+    - match: '\b(open)\s+([[:alpha:]][[:alpha:]0-9''_]*)(?=(\.[A-Z][[:alpha:]0-9_]*)*)'
+      captures:
+        1: keyword.fsharp
         2: entity.name.section.fsharp
       push:
-        - meta_scope: meta.module.namespace.fsharp
+        - meta_scope: namespace.open.fsharp
         - match: (\s|$)
           pop: true
-        - match: '(\.)([A-Z][a-zA-Z0-9''_]*)'
-          scope: support.other.module.fsharp
+        - match: '(\.)([[:alpha:]][[:alpha:]0-9''_]*)'
+          scope: entity.name.section.fsharp
           captures:
-            1: punctuation.separator.module-reference.fsharp
-            2: support.other.module.fsharp
-    - match: '\b(open)\s+([A-Z][a-zA-Z0-9''_]*)(?=(\.[A-Z][a-zA-Z0-9_]*)*)'
+            1: punctuation.separator.namespace-reference.fsharp
+            2: entity.name.section.fsharp
+    - match: '^\s*(module)\s+([A-Z][[:alpha:]0-9''_]*)\s*(=)\s*([A-Z][[:alpha:]0-9''_]*)'
       captures:
-        1: keyword.other.fsharp
-        2: support.other.module.fsharp
+        1: keyword.fsharp
+        2: entity.name.type.namespace.fsharp
+        3: punctuation.separator.namespace-definition.fsharp
+        4: entity.name.section.fsharp
       push:
-        - meta_scope: meta.module.open.fsharp
+        - meta_scope: namespace.alias.fsharp
         - match: (\s|$)
           pop: true
-        - match: '(\.)([A-Z][a-zA-Z0-9''_]*)'
-          scope: support.other.module.fsharp
+        - match: '(\.)([A-Z][[:alpha:]0-9''_]*)'
+          scope: entity.name.section.fsharp
           captures:
-            1: punctuation.separator.module-reference.fsharp
-            2: support.other.module.fsharp
-    - match: '^\s*(module)\s+([A-Z][a-zA-Z0-9''_]*)\s*(=)\s*([A-Z][a-zA-Z0-9''_]*)'
+            1: punctuation.separator.namespace-reference.fsharp
+            2: entity.name.section.fsharp
+  record_declaration:
+    - match: '(\{)'
       captures:
-        1: keyword.other.module-definition.fsharp
-        2: entity.name.type.module.fsharp
-        3: punctuation.separator.module-definition.fsharp
-        4: support.other.module.fsharp
+        1: keyword.symbol.fsharp
       push:
-        - meta_scope: meta.module.alias.fsharp
-        - match: (\s|$)
+        - match: '(?<=\})'
           pop: true
-        - match: '(\.)([A-Z][a-zA-Z0-9''_]*)'
-          scope: support.other.module.fsharp
+        - include: comments
+        - match: '(((mutable)\s[[:alpha:]]+)|[[:alpha:]0-9''`<>^._]*)\s*((?<!:):(?!:))\s*'
           captures:
-            1: punctuation.separator.module-reference.fsharp
-            2: support.other.module.fsharp
-    - match: '(?<!\w)([A-Z][a-zA-Z0-9_]*)(\.)'
+            3: keyword.fsharp
+            4: keyword.symbol.fsharp
+          push:
+            - match: '$|(;|\})'
+              captures:
+                1: keyword.symbol.fsharp
+              pop: true
+            - include: comments
+            - match: "([[:alpha:]0-9'`^_ ]+)"
+              captures:
+                1: entity.name.type.fsharp
+            - include: keywords
+        - include: compiler_directives
+        - include: constants
+        - include: strings
+        - include: chars
+        - include: double_tick
+        - include: definition
+        - include: attributes
+        - include: anonymous_functions
+        - include: keywords
+        - include: cexprs
+        - include: text
+  record_signature:
+    - match: "[[:alpha:]0-9'`^_ ]+(=)([[:alpha:]0-9'`^_ ]+)"
       captures:
-        1: support.other.module.fsharp
-        2: punctuation.separator.module-reference.fsharp
+        1: keyword.symbol.fsharp
+        2: variable.parameter.fsharp
+    - match: "({)"
+      captures:
+        1: keyword.symbol.fsharp
       push:
-        - meta_scope: meta.module.reference.fsharp
-        - match: '[A-Z][a-zA-Z0-9_]+(\.)'
-          scope: support.other.module.fsharp
+        - match: "(})"
           captures:
-            1: punctuation.separator.module-reference.fsharp
-        - match: (?=.)
+            1: keyword.symbol.fsharp
           pop: true
+        - match: "[[:alpha:]0-9'`^_ ]+(=)([[:alpha:]0-9'`^_ ]+)"
+          captures:
+            1: keyword.symbol.fsharp
+            2: variable.parameter.fsharp
+        - include: record_signature
+    - include: keywords
+  records:
+    - match: '\b(type)[\s]+(private|internal|public)?\s*'
+      captures:
+        1: keyword.fsharp
+        2: keyword.fsharp
+      push:
+        - meta_scope: record.fsharp
+        - match: '\s*((with)|((as)\s+([[:alpha:]0-9'']+))|(=)|[\n=]|(\(\)))'
+          captures:
+            2: keyword.fsharp
+            3: keyword.fsharp
+            4: keyword.fsharp
+            5: variable.parameter.fsharp
+            6: keyword.symbol.fsharp
+            7: constant.language.unit.fsharp
+          pop: true
+        - include: comments
+        - include: attributes
+        - match: "([[:alpha:]0-9'^._]+|``[[:alpha:]0-9'`^:,._ ]+``)"
+          captures:
+            1: entity.name.type.fsharp
+        - match: (<)
+          captures:
+            1: keyword.fsharp
+          push:
+            - match: ((?<!:)>)
+              captures:
+                1: keyword.fsharp
+              pop: true
+            - match: '((''|\^)``[[:alpha:]0-9`^:,._ ]+``|(''|\^)[[:alpha:]0-9`^:._]+)'
+              captures:
+                1: entity.name.type.fsharp
+            - match: \b(interface|with|abstract|and|when|or|not|struct|equality|comparison|unmanaged|delegate|enum)\b
+              scope: keyword.fsharp
+            - match: (\()
+              captures:
+                1: keyword.symbol.fsharp
+              push:
+                - match: (\))
+                  captures:
+                    1: keyword.symbol.fsharp
+                  pop: true
+                - match: (static member|member|new)
+                  captures:
+                    1: keyword.fsharp
+                - include: common_binding_definition
+            - match: '([\w0-9''`^._]+)'
+              captures:
+                1: entity.name.type.fsharp
+            - include: keywords
+        - match: \s*(private|internal|public)
+          captures:
+            1: keyword.symbol.fsharp
+            2: keyword.fsharp
+        - match: (\()
+          captures:
+            1: keyword.symbol.fsharp
+          push:
+            - match: '\s*(?=(=)|[\n=]|(\(\))|(as))'
+              captures:
+                1: keyword.symbol.fsharp
+              pop: true
+            - include: member_declaration
+        - include: keywords
+  string_formatter:
+    - match: (%0?-?(\d+)?((a|t)|(\.\d+)?(f|F|e|E|g|G|M)|(b|c|s|d|i|x|X|o|u)|(s|b|O)|(\+?A)))
+      scope: entity.name.type.format.specifier.fsharp
+      captures:
+        1: keyword.format.specifier.fsharp
   strings:
-    - match: '(?=[^\\])(""")'
-      captures:
-        1: punctuation.definition.string.begin.fsharp
-      push:
-        - meta_scope: string.quoted.double.fsharp
-        - match: (""")
-          captures:
-            1: punctuation.definition.string.end.fsharp
-          pop: true
-        - match: '\\$[ \t]*'
-          scope: punctuation.separator.string.ignore-eol.fsharp
     - match: '(?=[^\\])(@")'
       captures:
         1: punctuation.definition.string.begin.fsharp
       push:
-        - meta_scope: string.quoted.double.fsharp
-        - match: (")
+        - meta_scope: string.quoted.literal.fsharp
+        - match: (")(?!")
           captures:
             1: punctuation.definition.string.end.fsharp
           pop: true
-        - match: '\\$[ \t]*'
-          scope: punctuation.separator.string.ignore-eol.fsharp
+        - match: '"(")'
+          scope: constant.character.string.escape.fsharp
+    - match: '(?=[^\\])(""")'
+      captures:
+        1: punctuation.definition.string.begin.fsharp
+      push:
+        - meta_scope: string.quoted.triple.fsharp
+        - match: (""")
+          captures:
+            1: punctuation.definition.string.end.fsharp
+          pop: true
+        - include: string_formatter
     - match: '(?=[^\\])(")'
       captures:
         1: punctuation.definition.string.begin.fsharp
@@ -201,34 +594,79 @@ contexts:
           pop: true
         - match: '\\$[ \t]*'
           scope: punctuation.separator.string.ignore-eol.fsharp
-        - match: '\\([\\''ntbr]|u[a-fA-F0-9]{4}|u[a-fA-F0-9]{8})'
+        - match: '\\([\\''''ntbr]|u[a-fA-F0-9]{4}|u[a-fA-F0-9]{8})'
           scope: constant.character.string.escape.fsharp
-        - match: '\\(?![\\''ntbr]|u[a-fA-F0-9]{4}|u[a-fA-F0-9]{8}).'
+        - match: '\\(?![\\''''ntbr]|u[a-fA-F0-9]{4}|u[a-fA-F0-9]{8}).'
           scope: invalid.illeagal.character.string.fsharp
-    - match: '(?=[^\\])('')'
+        - include: string_formatter
+  strp_inlined:
+    - match: (\()
       captures:
-        1: punctuation.definition.string.begin.fsharp
+        1: keyword.symbol.fsharp
       push:
-        - meta_scope: string.quoted.double.fsharp
-        - match: (')
+        - match: (\))
           captures:
-            1: punctuation.definition.string.end.fsharp
+            1: keyword.symbol.fsharp
           pop: true
-        - match: '\\$[ \t]*'
-          scope: punctuation.separator.string.ignore-eol.fsharp
-        - match: '\\([\\"ntbr]|u[a-fA-F0-9]{4}|u[a-fA-F0-9]{8})'
-          scope: constant.character.string.escape.fsharp
-        - match: '\\(?![\\"ntbr]|u[a-fA-F0-9]{4}|u[a-fA-F0-9]{8}).'
-          scope: invalid.illeagal.character.string.fsharp
-  structure:
-    - match: \(
+        - include: strp_inlined_body
+  strp_inlined_body:
+    - include: comments
+    - include: anonymous_functions
+    - match: '(\^[[:alpha:]0-9''._]+)'
+      captures:
+        1: entity.name.type.fsharp
+    - match: \b(and|when|or)\b
+      scope: keyword.fsharp
+    - match: (\()
+      captures:
+        1: keyword.symbol.fsharp
       push:
-        - meta_scope: meta.paren-group.fsharp
-        - match: \)
+        - match: (\))
+          captures:
+            1: keyword.symbol.fsharp
           pop: true
-        - include: main
+        - include: strp_inlined_body
+    - match: '(static member|member)\s*([[:alpha:]0-9''`<>^._]+|``[[:alpha:]0-9'' <>^._]+``)\s*(:)'
+      captures:
+        1: keyword.fsharp
+        2: variable.fsharp
+        3: keyword.symbol.fsharp
+    - include: compiler_directives
+    - include: constants
+    - include: strings
+    - include: chars
+    - include: double_tick
+    - include: keywords
+    - include: text
+    - include: definition
+    - include: attributes
+    - include: keywords
+    - include: cexprs
+    - include: text
+  text:
+    - match: \\
+      scope: text.fsharp
+  tuple_signature:
+    - match: "(([?[:alpha:]0-9'`^._ ]+))+"
+      captures:
+        1: entity.name.type.fsharp
+    - match: (\()
+      captures:
+        1: keyword.symbol.fsharp
+      push:
+        - match: (\))
+          captures:
+            1: keyword.symbol.fsharp
+          pop: true
+        - match: "(([?[:alpha:]0-9'`^._ ]+))+"
+          captures:
+            1: entity.name.type.fsharp
+        - include: tuple_signature
+    - include: keywords
   variables:
     - match: \(\)
-      scope: variable.parameter.unit.fsharp
-    - match: '[a-zA-Z]\w*'
-      scope: variable.parameter.fsharp
+      scope: constant.language.unit.fsharp
+    - match: '(\?{0,1})(``[[:alpha:]0-9''`^:,._ ]+``|[[:alpha:]0-9''`<>^._ ]\w*)'
+      captures:
+        1: keyword.symbol.fsharp
+        2: variable.parameter.fsharp

assets/syntaxes/Hosts.sublime-syntax

@@ -0,0 +1,23 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: hosts
+file_extensions:
+  - hosts
+scope: source.hosts
+
+contexts:
+  main:
+    - scope: comment.line.number-sign
+      match: \#.*
+      comment: comment
+
+    - match: ^\s*([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}|[0-9a-f:]+)
+      comment: ipaddress
+      scope: constant.numeric.ipaddress
+
+
+    - match: \s(localhost|ip6-loopback|ip6-localhost|ip6-localnet|ip6-mcastprefix|ip6-allnodes|ip6-allrouters|ip6-allhosts|broadcasthost)\b
+      scope: keyword.host.predefined}
+      comment: prefdfined
+

assets/syntaxes/Manpage.sublime-syntax

@@ -0,0 +1,44 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: Manpage
+file_extensions:
+  - man
+scope: source.man
+
+variables:
+  section_heading: '^\S.*$'
+
+contexts:
+  main:
+    - match: ^
+      push: first_line
+
+  first_line:
+    - match: '([A-Z0-9]+)(\()([^)]+)(\))'
+      captures:
+        1: meta.preprocessor
+        2: keyword.operator
+        3: string.quoted.other
+        4: keyword.operator
+
+    - match: '$'
+      push: body
+
+  body:
+    - match: '^(SYNOPSIS|SYNTAX|SINTASSI|SKŁADNIA|СИНТАКСИС|書式)'
+      push: Packages/C/C.sublime-syntax
+      scope: markup.heading
+      with_prototype:
+        - match: '(?={{section_heading}})'
+          pop: true
+
+    - match: '^\S.*$'
+      scope: markup.heading
+
+    - match: '\b([a-z0-9_]+)(\()([^)]*)(\))'
+      captures:
+        1: entity.name.function
+        2: keyword.operator
+        3: constant.numeric
+        4: keyword.operator

assets/syntaxes/Org mode.sublime-syntax

@@ -0,0 +1,219 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: orgmode
+file_extensions:
+  - org
+scope: text.orgmode
+contexts:
+  main:
+    - match: |-
+        (?x)
+        ^(\*+)               # leading stars
+        \s*([A-Z_]{2,})?     # todo keywords
+        \s*(\[\#[A-Ca-c]\])? # priority
+        \s*(?=\s+[A-Za-z0-9]+)  # expected heading text
+      comment: Outline headings
+      captures:
+        1: punctuation.definition.heading.orgmode
+        2: keyword.other.todo.orgmode
+        3: constant.other.priority.orgmode
+      push:
+        - meta_scope: markup.heading.orgmode
+        - meta_content_scope: entity.name.section.orgmode
+        - match: (?=\s*$\n?)
+          pop: true
+        - include: heading-inline
+    - match: "^-{5,}$"
+      scope: meta.separator.orgmode
+    - match: '^\s*([-+]|\s+\*)\s+(.*?)\s+::'
+      captures:
+        1: keyword.operator.list.orgmode
+        2: markup.bold.definition.orgmode
+      push:
+        - meta_scope: meta.list.definition.orgmode
+        - match: $
+          pop: true
+        - include: inline
+    - match: '^\s*?([-+]|\s+\*|\d+[).])'
+      captures:
+        1: keyword.operator.list.orgmode
+      push:
+        - meta_scope: meta.list.plain.orgmode
+        - match: $
+          pop: true
+        - include: list-inline
+    - match: (?i)^#\+(BEGIN_(QUOTE|VERSE|CENTER))$
+      captures:
+        1: keyword.control.block.orgmode
+      push:
+        - meta_scope: markup.quote.orgmode
+        - match: (?i)^#\+(END_\2)$
+          captures:
+            1: keyword.control.block.orgmode
+          pop: true
+    - match: "^#[^+].*$"
+      scope: comment.line.number-sign.orgmode
+    - match: ^:(PROPERTIES):$
+      captures:
+        1: keyword.control.drawer.orgmode
+      push:
+        - meta_scope: meta.drawer.properties.orgmode
+        - match: ^:(END):$
+          captures:
+            1: keyword.control.drawer.orgmode
+          pop: true
+        - include: properties
+    - match: ^:(.+):$
+      captures:
+        1: keyword.control.drawer.orgmode
+      push:
+        - meta_scope: meta.drawer.other.orgmode
+        - match: ^:(END):$
+          captures:
+            1: keyword.control.drawer.orgmode
+          pop: true
+    - match: (?i)#\+(BEGIN_LaTeX)$
+      captures:
+        1: keyword.control.block.orgmode
+      push:
+        - meta_scope: meta.block.latex.orgmode
+        - match: (?i)#\+(END_LaTeX)$
+          captures:
+            1: keyword.control.block.orgmode
+          pop: true
+        - include: scope:text.tex.latex
+    - match: (?i)#\+(BEGIN_HTML)$
+      captures:
+        1: keyword.control.block.orgmode
+      push:
+        - meta_scope: meta.block.html.orgmode
+        - match: (?i)#\+(END_HTML)$
+          captures:
+            1: keyword.control.block.orgmode
+          pop: true
+        - include: scope:text.html.basic
+    - match: (?i)#\+(BEGIN_SRC)\s+(python)\s*(.*)$
+      captures:
+        1: keyword.control.block.orgmode
+        2: constant.other.language.orgmode
+        3: string.other.header-args.orgmode
+      push:
+        - meta_scope: meta.block.source.python.orgmode
+        - match: (?i)#\+(END_SRC)$
+          captures:
+            1: keyword.control.block.orgmode
+          pop: true
+        - include: scope:source.python
+    - match: (?i)#\+(BEGIN_SRC)\s+(ruby)\s*(.*)$
+      captures:
+        1: keyword.control.block.orgmode
+        2: constant.other.language.orgmode
+        3: string.other.header-args.orgmode
+      push:
+        - meta_scope: meta.block.source.ruby.orgmode
+        - match: (?i)#\+(END_SRC)$
+          captures:
+            1: keyword.control.block.orgmode
+          pop: true
+        - include: scope:source.ruby
+    - match: (?i)#\+(BEGIN_SRC)\s+((?:emacs-)?lisp)\s*(.*)$
+      captures:
+        1: keyword.control.block.orgmode
+        2: constant.other.language.orgmode
+        3: string.other.header-args.orgmode
+      push:
+        - meta_scope: meta.block.source.lisp.orgmode
+        - match: (?i)#\+(END_SRC)$
+          captures:
+            1: keyword.control.block.orgmode
+          pop: true
+        - include: scope:source.lisp
+    - match: (?i)#\+(BEGIN_SRC)\s+(sh)\s*(.*)$
+      captures:
+        1: keyword.control.block.orgmode
+        2: constant.other.language.orgmode
+        3: string.other.header-args.orgmode
+      push:
+        - meta_scope: meta.block.source.shell.orgmode
+        - match: (?i)#\+(END_SRC)$
+          captures:
+            1: keyword.control.block.orgmode
+          pop: true
+        - include: scope:source.shell
+    - match: '(?i)#\+(BEGIN_(SRC|EXAMPLE))(?:\s+([\w-]+)?\s*(.*))?$'
+      captures:
+        1: keyword.control.block.orgmode
+        3: constant.other.language.orgmode
+        4: string.other.header-args.orgmode
+      push:
+        - meta_scope: meta.block.source.other.orgmode
+        - meta_content_scope: markup.raw.block.orgmode
+        - match: (?i)#\+(END_\2)$
+          captures:
+            1: keyword.control.block.orgmode
+          pop: true
+    - match: '#\+(OPTIONS):'
+      captures:
+        1: keyword.control.pragma.orgmode
+      push:
+        - meta_scope: meta.pragma.options.orgmode
+        - match: $
+          pop: true
+        - match: '([^\s]+):([^\s]+)'
+          scope: meta.option.orgmode
+          captures:
+            1: variable.parameter.option.orgmode
+            2: string.other.option.orgmode
+    - match: '#\+(CALL):\s+[A-Za-z-]+(?:\[([^\]]*)\])?\(?'
+      captures:
+        1: keyword.control.pragma.orgmode
+        2: string.other.header-args.orgmode
+      push:
+        - meta_scope: meta.pragma.call.orgmode
+        - match: '\)?([^)]*)$'
+          captures:
+            1: string.other.header-args.orgmode
+          pop: true
+        - match: (\w+)=
+          scope: meta.assignment.orgmode
+          captures:
+            1: variable.parameter.header-args.orgmode
+    - match: '^#\+([a-zA-Z_-]+): ?(.*)$'
+      scope: meta.pragma.orgmode
+      captures:
+        1: keyword.control.pragma.orgmode
+        2: string.unquoted.pragma.orgmode
+    - include: inline
+  heading-inline:
+    - match: ':([^:^\s]*)(?=:)'
+      scope: meta.keyword.orgmode
+      captures:
+        1: string.quoted.keyword.orgmode
+    - include: inline
+  inline:
+    - match: '(?<=^|[.,:;\s])/[^/]+/(?=$|[.,:;\s])'
+      scope: markup.italic.orgmode
+    - match: '(?<=^|[.,:;\s])\*[^*]+\*(?=$|[.,:;\s])'
+      scope: markup.bold.orgmode
+    - match: '(?<=^|[.,:;\s])_[^_]+_(?=$|[.,:;\s])'
+      scope: markup.underline.orgmode
+    - match: '(?<=^|[.,:;\s])([~=]).+?\1(?=$|[.,:;\s])'
+      scope: markup.raw.inline.orgmode
+    - match: '\[(?:\[([^\]]*)\])?\[([^\]]*)\]\]'
+      scope: meta.link.orgmode
+      captures:
+        1: markup.underline.link.orgmode
+        2: string.other.link.orgmode
+    - match: (?:http|ftp)s?:\/\/\S+
+      scope: markup.underline.url.orgmode
+  list-inline:
+    - match: '\[[ -X]\]'
+      scope: keyword.operator.checkbox.orgmode
+    - include: inline
+  properties:
+    - match: '^:([A-Za-z_]+):\s(.*)$'
+      scope: meta.property.orgmode
+      captures:
+        1: keyword.control.property.orgmode
+        2: string.unquoted.propval.orgmode

assets/syntaxes/Verilog.sublime-syntax

@@ -0,0 +1,149 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: Verilog
+file_extensions:
+  - v
+  - V
+scope: source.verilog
+contexts:
+  main:
+    - match: '^\s*(module|function|primitive)\s+\b([a-zA-Z_][a-zA-Z0-9_]*)\b'
+      scope: meta.entity.module.verilog
+      captures:
+        1: storage.type.verilog
+        2: entity.name.type.class.verilog
+    - match: '^\s*(?!else)(?!begin)([a-zA-Z_][a-zA-Z0-9_]*)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*(\()'
+      scope: meta.definition.verilog
+      captures:
+        1: entity.name.type.class.verilog
+        2: entity.name.type.instance.verilog
+        3: keyword.operator.parenthesis.round.verilog
+    - match: '^\s*(?!else)(?!begin)([a-zA-Z_][a-zA-Z0-9_]*)\s+([#])(\()([ ._+`,a-zA-Z0-9]+)(\))\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*(\()'
+      scope: meta.definition.withparameter.verilog
+      captures:
+        1: entity.name.type.class.verilog
+        2: keyword.other.verilog
+        3: keyword.operator.parenthesis.round.verilog
+        4: keyword.other.verilog
+        5: keyword.operator.parenthesis.round.verilog
+        6: entity.name.type.instance.verilog
+        7: keyword.operator.parenthesis.round.verilog
+    - match: '^\s*\b(?!else)(?!begin)([a-zA-Z_][a-zA-Z0-9_]*)\b\s+([#])'
+      scope: meta.definition.withparameter.verilog
+      captures:
+        1: entity.name.type.class.verilog
+        2: keyword.other.verilog
+    - match: '^\s*(defparam)\s+([a-zA-Z_][a-zA-Z0-9_]*)(.[a-zA-Z_][a-zA-Z0-9_]*)\s*(=)'
+      scope: meta.definition.defparam.verilog
+      captures:
+        1: keyword.other.verilog
+        2: entity.name.type.instance.verilog
+        3: meta.module.parameters.verilog
+        4: keyword.other.verilog
+    - match: \b(automatic|cell|config|deassign|defparam|design|disable|edge|endconfig|endgenerate|endspecify|endtable|endtask|event|generate|genvar|ifnone|incdir|include|instance|liblist|library|localparam|macromodule|negedge|noshowcancelled|posedge|pulsestyle_onevent|pulsestyle_ondetect|real|realtime|scalared|showcancelled|specify|specparam|table|task|time|use|vectored)\b
+      scope: keyword.other.verilog
+    - match: "(#[0-9]+)"
+      scope: keyword.delay.verilog
+    - match: \b(initial|always|wait|force|release|assign)\b
+      scope: keyword.control.verilog
+    - match: \b(begin|end|fork|join)\b
+      scope: keyword.other.verilog
+    - match: \b(forever|repeat|while|for|if|else|case|casex|casez|default|endcase)\b
+      scope: keyword.control.verilog
+    - match: '^\s*(`include)\s+(["<].*[">])'
+      scope: meta.include.verilog
+      captures:
+        1: meta.preprocessor.verilog
+        2: entity.name.type.include.verilog
+    - match: '^\s*(`ifdef|`ifndef|`undef|`define)\s+([a-zA-Z_][a-zA-Z0-9_]*)\b'
+      scope: meta.preprocessor.ifdef.verilog
+      captures:
+        1: meta.preprocessor.verilog
+        2: constant.other.define.verilog
+    - match: '`(celldefine|default_nettype|define|else|elsif|endcelldefine|endif|ifdef|ifndef|include|line|nounconnected_drive|resetall|timescale|unconnected_drive|undef)\b'
+      scope: meta.preprocessor.verilog
+    - match: "[.][_a-zA-Z0-9]+"
+      scope: meta.module.parameters.verilog
+    - match: '`\b([a-zA-Z_][a-zA-Z0-9_]*)\b'
+      scope: constant.other.define.verilog
+    - include: comments
+    - match: \b(endmodule|endfunction|endprimitive)\b
+      scope: storage.type.verilog
+    - match: '^\s*\b([a-zA-Z_][a-zA-Z0-9_]*)\b\s*(:)\s*'
+      scope: meta.case.verilog
+      captures:
+        1: entity.name.state.verilog
+        2: keyword.operator.bitwise.verilog
+    - include: all-types
+    - match: (==|===|!=|!==|<=|>=|<|>)
+      scope: keyword.operator.comparison.verilog
+    - match: (\-|\+|\*|\/|%)
+      scope: keyword.operator.arithmetic.verilog
+    - match: (!|&&|\|\|)
+      scope: keyword.operator.logical.verilog
+    - match: (&|\||\^|~|<<|>>|\?|:)
+      scope: keyword.operator.bitwise.verilog
+    - match: "({|})"
+      scope: keyword.operator.parenthesis.curly.verilog
+    - match: (\(|\))
+      scope: keyword.operator.parenthesis.round.verilog
+    - match: '(\[|\])'
+      scope: keyword.operator.parenthesis.square.verilog
+    - match: "([;,])"
+      scope: keyword.delimiter.verilog
+    - match: (#|@|=)
+      scope: keyword.other.verilog
+    - match: '\b(output|input|inout|and|nand|nor|or|xor|xnor|buf|not|bufif[01]|notif[01]|r?[npc]mos|tran|r?tranif[01]|pullup|pulldown)\b'
+      scope: support.type.verilog
+    - match: '((\b\d+)?''s?([bB]\s*(([0-1_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*))|[oO]\s*(([0-7_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*))|[dD]\s*(([0-9_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*))|[hH]\s*(([0-9a-fA-F_xXzZ?]+)|(`[A-Z]+[_0-9a-zA-Z]*)))((e|E)(\+|-)?[0-9]+)?\b)|(\b\d+\b)'
+      scope: constant.numeric.verilog
+    - include: strings
+    - match: '\$\b([a-zA-Z_][a-zA-Z0-9_]*)\b'
+      scope: support.function.verilog
+  all-types:
+    - include: storage-type-verilog
+    - include: storage-modifier-verilog
+  comments:
+    - match: /\*
+      captures:
+        0: punctuation.definition.comment.verilog
+      push:
+        - meta_scope: comment.block.verilog
+        - match: \*/
+          captures:
+            0: punctuation.definition.comment.verilog
+          pop: true
+    - match: (//).*$\n?
+      scope: comment.line.double-slash.verilog
+      captures:
+        1: punctuation.definition.comment.verilog
+  storage-modifier-verilog:
+    - match: '\b(signed|unsigned|small|medium|large|supply[01]|strong[01]|pull[01]|weak[01]|highz[01])\b'
+      scope: storage.modifier.verilog
+  storage-type-verilog:
+    - match: '\b(wire|tri|tri[01]|supply[01]|wand|triand|wor|trior|trireg|reg|parameter|integer)\b'
+      scope: storage.type.verilog
+  strings:
+    - match: '"'
+      captures:
+        0: punctuation.definition.string.begin.verilog
+      push:
+        - meta_scope: string.quoted.double.verilog
+        - match: '"'
+          captures:
+            0: punctuation.definition.string.end.verilog
+          pop: true
+        - match: \\.
+          scope: constant.character.escape.verilog
+    - match: "'"
+      captures:
+        0: punctuation.definition.string.begin.verilog
+      push:
+        - meta_scope: string.quoted.single.verilog
+        - match: "'"
+          captures:
+            0: punctuation.definition.string.end.verilog
+          pop: true
+        - match: \\.
+          scope: constant.character.escape.verilog

assets/syntaxes/requirementstxt.sublime-syntax

@@ -0,0 +1,19 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: requirements.txt
+file_extensions:
+  - requirements.txt
+scope: source.requirementstxt
+contexts:
+  main:
+    - match: (#).*$\n?
+      scope: comment.line.requirementstxt
+      captures:
+        1: punctuation.definition.comment.requirementstxt
+    - match: '(?i)^[a-z0-9_\-\.]+'
+      scope: string.package_name.requirementstxt
+    - match: (?i)==|<|<=|>=|>
+      scope: keyword.operator.logical.punctuation.requirementstxt
+    - match: '(?i)\d+\.[\da-z\-_\.]*'
+      scope: constant.numeric.verions.requirementstxt

assets/syntaxes/show-nonprintable.sublime-syntax

@@ -25,3 +25,7 @@ contexts:
       scope: entity.other.attribute-name.show-nonprintable.escape
     - match: "␈"
       scope: entity.other.attribute-name.show-nonprintable.backspace
+    - match: "\\\\x[A-Z0-9][A-Z0-9]"
+      scope: comment.block.show-nonprintable.backspace
+    - match: "\\\\u\\{[a-z0-9]+\\}"
+      scope: comment.block.show-nonprintable.backspace

assets/themes/ansi-dark.tmTheme

@@ -0,0 +1,504 @@
+<?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 Dark</string>
+        <key>colorSpaceName</key>
+        <string>sRGB</string>
+        <key>settings</key>
+        <array>
+            <dict>
+                <key>settings</key>
+                <dict>
+                    <key>background</key>
+                    <string>#00000000</string>
+                    <key>caret</key>
+                    <string>#07000000</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>
+                    <key>gutter</key>
+                    <string>#00000000</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>
+                </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>#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>
+                <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>#07000000</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>#07000000</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>#07000000</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>#00000000</string>
+                </dict>
+            </dict>
+        </array>
+        <key>uuid</key>
+        <string>uuid</string>
+    </dict>
+</plist>

assets/themes/ansi-light.tmTheme

@@ -0,0 +1,504 @@
+<?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/base16.tmTheme

@@ -0,0 +1,543 @@
+<?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>Base16</string>
+        <key>colorSpaceName</key>
+        <string>sRGB</string>
+        <key>settings</key>
+        <array>
+            <dict>
+                <key>settings</key>
+                <dict>
+                    <key>background</key>
+                    <string>#00000000</string>
+                    <key>caret</key>
+                    <string>#07000000</string>
+                    <key>foreground</key>
+                    <string>#07000000</string>
+                    <key>invisibles</key>
+                    <string>#08000000</string>
+                    <key>lineHighlight</key>
+                    <string>#08000000</string>
+                    <key>selection</key>
+                    <string>#0b000000</string>
+                    <key>gutter</key>
+                    <string>#0a000000</string>
+                    <key>gutterForeground</key>
+                    <string>#08000000</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>
+                </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>#08000000</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>
+                <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>#07000000</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>#0e000000</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>#0f000000</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>#09000000</string>
+                </dict>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>Floats</string>
+                <key>scope</key>
+                <string>none</string>
+                <key>settings</key>
+                <dict>
+                    <key>foreground</key>
+                    <string>#09000000</string>
+                </dict>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>Boolean</string>
+                <key>scope</key>
+                <string>none</string>
+                <key>settings</key>
+                <dict>
+                    <key>foreground</key>
+                    <string>#09000000</string>
+                </dict>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>Constants</string>
+                <key>scope</key>
+                <string>constant</string>
+                <key>settings</key>
+                <dict>
+                    <key>foreground</key>
+                    <string>#09000000</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>#09000000</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>#09000000</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>#09000000</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>#09000000</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>#09000000</string>
+                </dict>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>Separator</string>
+                <key>scope</key>
+                <string>meta.separator</string>
+                <key>settings</key>
+                <dict>
+                    <key>background</key>
+                    <string>#0b000000</string>
+                    <key>foreground</key>
+                    <string>#07000000</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>#0f000000</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>#09000000</string>
+                    <key>foreground</key>
+                    <string>#00000000</string>
+                </dict>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>Deprecated</string>
+                <key>scope</key>
+                <string>invalid.deprecated</string>
+                <key>settings</key>
+                <dict>
+                    <key>background</key>
+                    <string>#0e000000</string>
+                    <key>foreground</key>
+                    <string>#0f000000</string>
+                </dict>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>Unimplemented</string>
+                <key>scope</key>
+                <string>invalid.unimplemented</string>
+                <key>settings</key>
+                <dict>
+                    <key>background</key>
+                    <string>#08000000</string>
+                    <key>foreground</key>
+                    <string>#0f000000</string>
+                </dict>
+            </dict>
+        </array>
+        <key>uuid</key>
+        <string>uuid</string>
+    </dict>
+</plist>

ci/before_deploy.bash

@@ -43,6 +43,7 @@ pack() {
     # TODO: disabled for now, see issue #372
     # cp target/"$TARGET"/release/build/"$PROJECT_NAME"-*/out/"$PROJECT_NAME".bash "$tempdir/$package_name/autocomplete/${PROJECT_NAME}.bash-completion"
     # cp target/"$TARGET"/release/build/"$PROJECT_NAME"-*/out/"$PROJECT_NAME".fish "$tempdir/$package_name/autocomplete"
+    cp assets/completions/bat.fish "$tempdir/$package_name/autocomplete"
     # cp target/"$TARGET"/release/build/"$PROJECT_NAME"-*/out/_"$PROJECT_NAME" "$tempdir/$package_name/autocomplete"
 
     # archiving
@@ -59,6 +60,11 @@ make_deb() {
     local dpkgname
     local conflictname
     local gcc_prefix
+    local homepage
+    local maintainer
+
+    homepage="https://github.com/sharkdp/bat"
+    maintainer="David Peter <mail@david-peter.de>"
 
     case $TARGET in
         x86_64*)
@@ -101,10 +107,51 @@ make_deb() {
     install -Dm644 "doc/$PROJECT_NAME.1" "$tempdir/usr/share/man/man1/$PROJECT_NAME.1"
     gzip --best "$tempdir/usr/share/man/man1/$PROJECT_NAME.1"
 
+    # completions
+    install -Dm644 assets/completions/bat.fish "$tempdir/usr/share/fish/completions/$PROJECT_NAME.fish"
+
     # readme and license
     install -Dm644 README.md "$tempdir/usr/share/doc/$PROJECT_NAME/README.md"
     install -Dm644 LICENSE-MIT "$tempdir/usr/share/doc/$PROJECT_NAME/LICENSE-MIT"
     install -Dm644 LICENSE-APACHE "$tempdir/usr/share/doc/$PROJECT_NAME/LICENSE-APACHE"
+    cat > "$tempdir/usr/share/doc/$PROJECT_NAME/copyright" <<EOF
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: $PROJECT_NAME
+Source: $homepage
+
+Files: *
+Copyright: $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.
+
+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.
+EOF
 
     # Control file
     mkdir "$tempdir/DEBIAN"

ci/before_install.bash

@@ -33,5 +33,6 @@ if [[ $TARGET == aarch64-unknown-linux-gnu ]]; then
     sudo apt-get install -y \
         gcc-4.8-aarch64-linux-gnu \
         binutils-aarch64-linux-gnu \
-        gcc-aarch64-linux-gnu
+        gcc-aarch64-linux-gnu \
+        libc6-dev-arm64-cross
 fi

doc/README-ja.md

@@ -97,7 +97,7 @@ bat f - g  # output 'f', then stdin, then 'g'.
 最新の `.deb` パッケージを[こちら](https://github.com/sharkdp/bat/releases)からダウンロードして、インストールしてください:
 
 ``` bash
-sudo dpkg -i bat_0.10.0_amd64.deb  # adapt version number and architecture
+sudo dpkg -i bat_0.12.1_amd64.deb  # adapt version number and architecture
 ```
 
 ###  Arch Linux
@@ -124,6 +124,14 @@ xbps-install -S bat
 dnf module install bat
 ```
 
+###  Gentoo Linux
+
+[Gentoo Linuxの公式リソース](https://packages.gentoo.org/packages/sys-apps/bat)からインストールできます。
+
+```bash
+emerge sys-apps/bat
+```
+
 ###  FreeBSD
 
 事前にコンパイル済みである[pkg](https://www.freshports.org/textproc/bat)をインストールできます:

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)                            | 100                                                                 | 300                              | 200                                                                 | 7                                        | 80                                                             | 130                                                 | 30                                                  | 130                                                 |
+| Languages (circa)                            | 110                                                                 | 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/bat.1

@@ -10,27 +10,35 @@ bat [OPTIONS] [FILE]...
 bat <SUBCOMMAND>
 .SH "OPTIONS"
 .HP
+General remarks
+.IP
+Command-line options like '-l'/'--language' that take values can be specified as
+either '--language value', '--language=value', '-l value' or '-lvalue'.
+.HP
 \fB\-l\fR, \fB\-\-language\fR <language>
 .IP
-Explicitly set the language for syntax highlighting. The language can be specified as a
-name (like 'C++' or 'LaTeX') or possible file extension (like 'cpp', 'hpp' or 'md'). Use
-\&'\-\-list\-languages' to show all supported language names and file extensions.
+Explicitly set the language for syntax highlighting. The language can be
+specified as a name (like 'C++' or 'LaTeX') or possible file extension
+(like 'cpp', 'hpp' or 'md'). Use '\-\-list\-languages' to show all supported
+language names and file extensions.
 .HP
-\fB\-\-list\-languages\fR
+\fB\-L\fR, \fB\-\-list\-languages\fR
 .IP
 Display a list of supported languages for syntax highlighting.
 .HP
 \fB\-m\fR, \fB\-\-map\-syntax\fR <from:to>...
 .IP
-Map a file extension or file name to an existing syntax. For example, to highlight
-*.conf files with the INI syntax, use '\-m conf:ini'. To highlight files named
-\&'.myignore' with the Git Ignore syntax, use '\-m .myignore:gitignore'.
+Map a file extension or file name to an existing syntax. For example, to
+highlight *.conf files with the INI syntax, use '\-m conf:ini'. To
+highlight files named '.myignore' with the Git Ignore syntax, use '\-m
+\&.myignore:gitignore'.
 .HP
 \fB\-\-theme\fR <theme>
 .IP
-Set the theme for syntax highlighting. Use '\-\-list\-themes' to see all available themes.
-To set a default theme, add the '\-\-theme="..."' option to the configuration file or
-export the BAT_THEME environment variable (e.g.: export BAT_THEME="...").
+Set the theme for syntax highlighting. Use '\-\-list\-themes' to see all
+available themes. To set a default theme, add the '\-\-theme="..."' option
+to the configuration file or export the BAT_THEME environment variable
+(e.g.: export BAT_THEME="...").
 .HP
 \fB\-\-list\-themes\fR
 .IP
@@ -38,27 +46,31 @@ Display a list of supported themes for syntax highlighting.
 .HP
 \fB\-\-style\fR <style\-components>
 .IP
-Configure which elements (line numbers, file headers, grid borders, Git modifications,
-\&..) to display in addition to the file contents. The argument is a comma\-separated list
-of 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, numbers.
+Configure which elements (line numbers, file headers, grid borders, Git
+modifications, ..) to display in addition to the file contents. The
+argument is a comma\-separated list of 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, numbers, snip.
 .HP
 \fB\-p\fR, \fB\-\-plain\fR
 .IP
-Only show plain style, no decorations. This is an alias for '\-\-style=plain'
+Only show plain style, no decorations. This is an alias for
+\&'\-\-style=plain'. When '\-p' is used twice ('\-pp'), it also disables
+automatic paging (alias for '\-\-style=plain \fB\-\-pager\fR=\fI\,never\/\fR').
 .HP
 \fB\-n\fR, \fB\-\-number\fR
 .IP
-Only show line numbers, no other decorations. This is an alias for '\-\-style=numbers'
+Only show line numbers, no other decorations. This is an alias for
+\&'\-\-style=numbers'
 .HP
 \fB\-A\fR, \fB\-\-show\-all\fR
 .IP
-Show non\-printable characters like space, tab or newline. Use '\-\-tabs' to control the
-width of the tab\-placeholders.
+Show non\-printable characters like space, tab or newline. Use '\-\-tabs' to
+control the width of the tab\-placeholders.
 .HP
-\fB\-\-line\-range\fR <N:M>...
+\fB\-r\fR, \fB\-\-line\-range\fR <N:M>...
 .IP
 Only print the specified range of lines for each file. For example:
 .RS
@@ -70,53 +82,63 @@ prints lines 1 to 40
 prints lines 40 to the end of the file
 .RE
 .HP
+\fB\-H\fR, \fB\-\-highlight\-line\fR <N>...
+.IP
+Highlight the N\-th line with a different background color
+.HP
 \fB\-\-color\fR <when>
 .IP
-Specify when to use colored output. The automatic mode only enables colors if an
-interactive terminal is detected. Possible values: *auto*, never, always.
+Specify when to use colored output. The automatic mode only enables colors
+if an interactive terminal is detected. Possible values: *auto*, never,
+always.
 .HP
 \fB\-\-italic\-text\fR <when>
 .IP
-Specify when to use ANSI sequences for italic text in the output. Possible values:
-always, *never*.
+Specify when to use ANSI sequences for italic text in the output. Possible
+values: always, *never*.
 .HP
 \fB\-\-decorations\fR <when>
 .IP
-Specify when to use the decorations that have been specified via '\-\-style'. The
-automatic mode only enables decorations if an interactive terminal is detected. Possible
-values: *auto*, never, always.
+Specify when to use the decorations that have been specified via
+\&'\-\-style'. The automatic mode only enables decorations if an interactive
+terminal is detected. Possible values: *auto*, never, always.
 .HP
 \fB\-\-paging\fR <when>
 .IP
-Specify when to use the pager. To control which pager is used, set the PAGER or
-BAT_PAGER environment variables (the latter takes precedence) or use the '\-\-pager'
-option. To disable the pager permanently, set BAT_PAGER to an empty string or set
-\&'\-\-paging=never' in the configuration file. Possible values: *auto*, never, always.
+Specify when to use the pager. To control which pager is used, set the
+PAGER or BAT_PAGER environment variables (the latter takes precedence) or
+use the '\-\-pager' option. To disable the pager permanently, set BAT_PAGER
+to an empty string or set '\-\-paging=never' in the configuration file.
+Possible values: *auto*, never, always.
 .HP
 \fB\-\-pager\fR <command>
 .IP
-Determine which pager is used. This option will overwrite the PAGER and BAT_PAGER
-environment variables. The default pager is 'less'. To disable the pager completely, use
-the '\-\-paging' option. Example: '\-\-pager "less \fB\-RF\fR"'.
+Determine which pager is used. This option will overwrite the PAGER and
+BAT_PAGER environment variables. The default pager is 'less'. To disable
+the pager completely, use the '\-\-paging' option. Example: '\-\-pager "less
+\fB\-RF\fR"'.
 .HP
 \fB\-\-wrap\fR <mode>
 .IP
-Specify the text\-wrapping mode (*auto*, never, character).
+Specify the text\-wrapping mode (*auto*, never, character). The
+\&'\-\-terminal\-width' option can be used in addition to control the output
+width.
 .HP
 \fB\-\-tabs\fR <T>
 .IP
-Set the tab width to T spaces. Use a width of 0 to pass tabs through directly
+Set the tab width to T spaces. Use a width of 0 to pass tabs through
+directly
 .HP
 \fB\-u\fR, \fB\-\-unbuffered\fR
 .IP
-This option exists for POSIX\-compliance reasons ('u' is for 'unbuffered'). The output is
-always unbuffered \- this option is simply ignored.
+This option exists for POSIX\-compliance reasons ('u' is for 'unbuffered').
+The output is always unbuffered \- this option is simply ignored.
 .HP
 \fB\-\-terminal\-width\fR <width>
 .IP
-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.
+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'.
 .HP
 \fB\-h\fR, \fB\-\-help\fR
 .IP

src/app.rs

@@ -4,8 +4,8 @@ use std::str::FromStr;
 
 use atty::{self, Stream};
 
+use crate::clap_app;
 use clap::ArgMatches;
-use clap_app;
 use wild;
 
 use console::Term;
@@ -13,14 +13,14 @@ use console::Term;
 #[cfg(windows)]
 use ansi_term;
 
-use assets::BAT_THEME_DEFAULT;
-use config::{get_args_from_config_file, get_args_from_env_var};
-use errors::*;
-use inputfile::InputFile;
-use line_range::{LineRange, LineRanges};
-use style::{OutputComponent, OutputComponents, OutputWrap};
-use syntax_mapping::SyntaxMapping;
-use util::transpose;
+use crate::assets::BAT_THEME_DEFAULT;
+use crate::config::{get_args_from_config_file, get_args_from_env_var};
+use crate::errors::*;
+use crate::inputfile::InputFile;
+use crate::line_range::{LineRange, LineRanges};
+use crate::style::{OutputComponent, OutputComponents, OutputWrap};
+use crate::syntax_mapping::SyntaxMapping;
+use crate::util::transpose;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum PagingMode {
@@ -120,7 +120,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())
+                .unwrap_or_else(get_args_from_config_file)
                 .chain_err(|| "Could not parse configuration file")?;
 
             // Put the zero-th CLI argument (program name) first
@@ -143,7 +143,10 @@ impl App {
             Some("always") => PagingMode::Always,
             Some("never") => PagingMode::Never,
             Some("auto") | _ => {
-                if files.contains(&InputFile::StdIn) {
+                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 files.contains(&InputFile::StdIn) {
                     // If we are reading from stdin, only enable paging if we write to an
                     // interactive terminal and if we do not *read* from an interactive
                     // terminal.
@@ -152,12 +155,10 @@ impl App {
                     } else {
                         PagingMode::Never
                     }
+                } else if self.interactive_output {
+                    PagingMode::QuitIfOneScreen
                 } else {
-                    if self.interactive_output {
-                        PagingMode::QuitIfOneScreen
-                    } else {
-                        PagingMode::Never
-                    }
+                    PagingMode::Never
                 }
             }
         };
@@ -166,7 +167,7 @@ impl App {
 
         if let Some(values) = self.matches.values_of("map-syntax") {
             for from_to in values {
-                let parts: Vec<_> = from_to.split(":").collect();
+                let parts: Vec<_> = from_to.split(':').collect();
 
                 if parts.len() != 2 {
                     return Err("Invalid syntax mapping. The format of the -m/--map-syntax option is 'from:to'.".into());
@@ -213,11 +214,11 @@ impl App {
                 .matches
                 .value_of("terminal-width")
                 .and_then(|w| {
-                    if w.starts_with("+") || w.starts_with("-") {
+                    if w.starts_with('+') || w.starts_with('-') {
                         // Treat argument as a delta to the current terminal width
                         w.parse().ok().map(|delta: i16| {
                             let old_width: u16 = Term::stdout().size().1;
-                            let new_width: i32 = old_width as i32 + delta as i32;
+                            let new_width: i32 = i32::from(old_width) + i32::from(delta);
 
                             if new_width <= 0 {
                                 old_width as usize
@@ -252,14 +253,14 @@ impl App {
                 .value_of("theme")
                 .map(String::from)
                 .or_else(|| env::var("BAT_THEME").ok())
-                .unwrap_or(String::from(BAT_THEME_DEFAULT)),
+                .unwrap_or_else(|| String::from(BAT_THEME_DEFAULT)),
             line_ranges: LineRanges::from(
                 transpose(
                     self.matches
                         .values_of("line-range")
                         .map(|vs| vs.map(LineRange::from).collect()),
                 )?
-                .unwrap_or(vec![]),
+                .unwrap_or_else(|| vec![]),
             ),
             output_components,
             syntax_mapping,
@@ -306,7 +307,7 @@ impl App {
                 let env_style_components: Option<Vec<OutputComponent>> =
                     transpose(env::var("BAT_STYLE").ok().map(|style_str| {
                         style_str
-                            .split(",")
+                            .split(',')
                             .map(|x| OutputComponent::from_str(&x))
                             .collect::<Result<Vec<OutputComponent>>>()
                     }))?;
@@ -315,13 +316,13 @@ impl App {
                     .value_of("style")
                     .map(|styles| {
                         styles
-                            .split(",")
+                            .split(',')
                             .map(|style| style.parse::<OutputComponent>())
                             .filter_map(|style| style.ok())
                             .collect::<Vec<_>>()
                     })
                     .or(env_style_components)
-                    .unwrap_or(vec![OutputComponent::Full])
+                    .unwrap_or_else(|| vec![OutputComponent::Full])
                     .into_iter()
                     .map(|style| style.components(self.interactive_output))
                     .fold(HashSet::new(), |mut acc, components| {

src/assets.rs

@@ -8,11 +8,11 @@ use syntect::dumps::{dump_to_file, from_binary, from_reader};
 use syntect::highlighting::{Theme, ThemeSet};
 use syntect::parsing::{SyntaxReference, SyntaxSet, SyntaxSetBuilder};
 
-use dirs::PROJECT_DIRS;
+use crate::dirs::PROJECT_DIRS;
 
-use errors::*;
-use inputfile::{InputFile, InputFileReader};
-use syntax_mapping::SyntaxMapping;
+use crate::errors::*;
+use crate::inputfile::{InputFile, InputFileReader};
+use crate::syntax_mapping::SyntaxMapping;
 
 pub const BAT_THEME_DEFAULT: &str = "Monokai Extended";
 
@@ -40,7 +40,7 @@ impl HighlightingAssets {
         let theme_dir = source_dir.join("themes");
 
         let res = theme_set.add_from_folder(&theme_dir);
-        if !res.is_ok() {
+        if res.is_err() {
             println!(
                 "No themes were found in '{}', using the default set",
                 theme_dir.to_string_lossy()
@@ -117,7 +117,7 @@ impl HighlightingAssets {
 
     pub fn save(&self, dir: Option<&Path>) -> Result<()> {
         let target_dir = dir.unwrap_or_else(|| PROJECT_DIRS.cache_dir());
-        let _ = fs::create_dir(target_dir);
+        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");
 
@@ -191,8 +191,8 @@ impl HighlightingAssets {
                 } else {
                     None
                 };
-                let syntax = ext_syntax.or(line_syntax);
-                syntax
+
+                ext_syntax.or(line_syntax)
             }
             (None, InputFile::StdIn) => String::from_utf8(reader.first_line.clone())
                 .ok()

src/clap_app.rs

@@ -18,8 +18,8 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
         .global_setting(AppSettings::DeriveDisplayOrder)
         .global_setting(AppSettings::UnifiedHelpMessage)
         .global_setting(AppSettings::HidePossibleValuesInHelp)
-        .setting(AppSettings::InferSubcommands)
         .setting(AppSettings::ArgsNegateSubcommands)
+        .setting(AppSettings::AllowExternalSubcommands)
         .setting(AppSettings::DisableHelpSubcommand)
         .setting(AppSettings::VersionlessSubcommands)
         .max_term_width(100)
@@ -55,6 +55,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
         .arg(
             Arg::with_name("list-languages")
                 .long("list-languages")
+                .short("L")
                 .conflicts_with("list-themes")
                 .help("Display all supported languages.")
                 .long_help("Display a list of supported languages for syntax highlighting."),
@@ -109,9 +110,9 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 .overrides_with("number")
                 // Cannot use clap's built in validation because we have to turn off clap's delimiters
                 .validator(|val| {
-                    let mut invalid_vals = val.split(",").filter(|style| {
+                    let mut invalid_vals = val.split(',').filter(|style| {
                         !&[
-                            "auto", "full", "plain", "changes", "header", "grid", "numbers",
+                            "auto", "full", "plain", "changes", "header", "grid", "numbers", "snip"
                         ]
                         .contains(style)
                     });
@@ -124,7 +125,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 })
                 .help(
                     "Comma-separated list of style elements to display \
-                     (*auto*, full, plain, changes, header, grid, numbers).",
+                     (*auto*, full, plain, changes, header, grid, numbers, snip).",
                 )
                 .long_help(
                     "Configure which elements (line numbers, file headers, grid \
@@ -134,7 +135,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                      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, numbers.",
+                     Possible values: *auto*, full, plain, changes, header, grid, numbers, snip.",
                 ),
         )
         .arg(
@@ -143,10 +144,12 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 .overrides_with("number")
                 .short("p")
                 .long("plain")
+                .multiple(true)
                 .help("Show plain style (alias for '--style=plain').")
                 .long_help(
                     "Only show plain style, no decorations. This is an alias for \
-                     '--style=plain'",
+                     '--style=plain'. When '-p' is used twice ('-pp'), it also disables \
+                     automatic paging (alias for '--style=plain --pager=never').",
                 ),
         )
         .arg(
@@ -169,7 +172,8 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 .help("Show non-printable characters (space, tab, newline, ..).")
                 .long_help(
                     "Show non-printable characters like space, tab or newline. \
-                     Use '--tabs' to control the width of the tab-placeholders.",
+                     This option can also be used to print binary files. \
+                     Use '--tabs' to control the width of the tab-placeholders."
                 ),
         )
         .arg(
@@ -290,7 +294,9 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 .default_value("auto")
                 .hide_default_value(true)
                 .help("Specify the text-wrapping mode (*auto*, never, character).")
-                .long_help("Specify the text-wrapping mode (*auto*, never, character)."),
+                .long_help("Specify the text-wrapping mode (*auto*, never, character). \
+                           The '--terminal-width' option can be used in addition to \
+                           control the output width."),
         )
         .arg(
             Arg::with_name("tabs")
@@ -329,10 +335,23 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                 .takes_value(true)
                 .value_name("width")
                 .hidden_short_help(true)
+                .allow_hyphen_values(true)
+                .validator(
+                    |t| {
+                        let is_offset = t.starts_with('+') || t.starts_with('-');
+                        t.parse::<i32>()
+                            .map_err(|_e| "must be an offset or number")
+                            .and_then(|v| if v == 0 && !is_offset {
+                                Err("terminal width cannot be zero".into())
+                            } else {
+                                Ok(())
+                            })
+                            .map_err(|e| e.to_string())
+                    })
                 .help(
                     "Explicitly set the width of the terminal instead of determining it \
                      automatically. If prefixed with '+' or '-', the value will be treated \
-                     as an offset to the actual terminal width.",
+                     as an offset to the actual terminal width. See also: '--wrap'.",
                 ),
         )
         .arg(

src/config.rs

@@ -5,15 +5,15 @@ use std::path::PathBuf;
 
 use shell_words;
 
-use dirs::PROJECT_DIRS;
-use util::transpose;
+use crate::dirs::PROJECT_DIRS;
+use crate::util::transpose;
 
 pub fn config_file() -> PathBuf {
     env::var("BAT_CONFIG_PATH")
         .ok()
         .map(PathBuf::from)
         .filter(|config_path| config_path.is_file())
-        .unwrap_or(PROJECT_DIRS.config_dir().join("config"))
+        .unwrap_or_else(|| PROJECT_DIRS.config_dir().join("config"))
 }
 
 pub fn get_args_from_config_file() -> Result<Vec<OsString>, shell_words::ParseError> {
@@ -22,19 +22,19 @@ pub fn get_args_from_config_file() -> Result<Vec<OsString>, shell_words::ParseEr
             .ok()
             .map(|content| get_args_from_str(&content)),
     )?
-    .unwrap_or(vec![]))
+    .unwrap_or_else(|| vec![]))
 }
 
 pub fn get_args_from_env_var() -> Option<Result<Vec<OsString>, shell_words::ParseError>> {
     env::var("BAT_OPTS").ok().map(|s| get_args_from_str(&s))
 }
 
-fn get_args_from_str<'a>(content: &'a str) -> Result<Vec<OsString>, shell_words::ParseError> {
+fn get_args_from_str(content: &str) -> Result<Vec<OsString>, shell_words::ParseError> {
     let args_per_line = content
         .split('\n')
         .map(|line| line.trim())
         .filter(|line| !line.is_empty())
-        .filter(|line| !line.starts_with("#"))
+        .filter(|line| !line.starts_with('#'))
         .map(|line| shell_words::split(line))
         .collect::<Result<Vec<_>, _>>()?;
 

src/controller.rs

@@ -1,13 +1,13 @@
 use std::io::{self, Write};
 use std::path::Path;
 
-use app::{Config, PagingMode};
-use assets::HighlightingAssets;
-use errors::*;
-use inputfile::{InputFile, InputFileReader};
-use line_range::{LineRanges, RangeCheckResult};
-use output::OutputType;
-use printer::{InteractivePrinter, Printer, SimplePrinter};
+use crate::app::{Config, PagingMode};
+use crate::assets::HighlightingAssets;
+use crate::errors::*;
+use crate::inputfile::{InputFile, InputFileReader};
+use crate::line_range::{LineRanges, RangeCheckResult};
+use crate::output::OutputType;
+use crate::printer::{InteractivePrinter, Printer, SimplePrinter};
 
 pub struct Controller<'a> {
     config: &'a Config<'a>,
@@ -43,7 +43,6 @@ impl<'b> Controller<'b> {
 
         for input_file in &self.config.files {
             match input_file.get_reader(&stdin) {
-                Err(Error(ErrorKind::ImmediateEOF, _)) => (),
                 Err(error) => {
                     handle_error(&error);
                     no_errors = false;
@@ -77,34 +76,51 @@ impl<'b> Controller<'b> {
         &self,
         reader: InputFileReader,
         printer: &mut P,
-        writer: &mut Write,
+        writer: &mut dyn Write,
         input_file: InputFile<'a>,
     ) -> Result<()> {
         printer.print_header(writer, input_file)?;
-        self.print_file_ranges(printer, writer, reader, &self.config.line_ranges)?;
+        if !reader.first_line.is_empty() {
+            self.print_file_ranges(printer, writer, reader, &self.config.line_ranges)?;
+        }
         printer.print_footer(writer)?;
 
         Ok(())
     }
 
-    fn print_file_ranges<'a, P: Printer>(
+    fn print_file_ranges<P: Printer>(
         &self,
         printer: &mut P,
-        writer: &mut Write,
+        writer: &mut dyn Write,
         mut reader: InputFileReader,
         line_ranges: &LineRanges,
     ) -> Result<()> {
         let mut line_buffer = Vec::new();
         let mut line_number: usize = 1;
 
+        let mut first_range: bool = true;
+        let mut mid_range: bool = false;
+
         while reader.read_line(&mut line_buffer)? {
             match line_ranges.check(line_number) {
                 RangeCheckResult::OutsideRange => {
                     // Call the printer in case we need to call the syntax highlighter
                     // for this line. However, set `out_of_range` to `true`.
                     printer.print_line(true, writer, line_number, &line_buffer)?;
+                    mid_range = false;
                 }
+
                 RangeCheckResult::InRange => {
+                    if self.config.output_components.snip() {
+                        if first_range {
+                            first_range = false;
+                            mid_range = true;
+                        } else if !mid_range {
+                            mid_range = true;
+                            printer.print_snip(writer)?;
+                        }
+                    }
+
                     printer.print_line(false, writer, line_number, &line_buffer)?;
                 }
                 RangeCheckResult::AfterLastRange => {

src/decorations.rs

@@ -1,6 +1,6 @@
+use crate::diff::LineChange;
+use crate::printer::{Colors, InteractivePrinter};
 use ansi_term::Style;
-use diff::LineChange;
-use printer::{Colors, InteractivePrinter};
 
 #[derive(Clone)]
 pub struct DecorationText {

src/dirs.rs

@@ -1,4 +1,4 @@
-use dirs_rs;
+use crate::dirs_rs;
 use std::path::{Path, PathBuf};
 
 #[cfg(target_os = "macos")]

src/inputfile.rs

@@ -3,41 +3,43 @@ use std::io::{self, BufRead, BufReader};
 
 use content_inspector::{self, ContentType};
 
-use errors::*;
+use crate::errors::*;
 
 const THEME_PREVIEW_FILE: &[u8] = include_bytes!("../assets/theme_preview.rs");
 
 pub struct InputFileReader<'a> {
     inner: Box<dyn BufRead + 'a>,
     pub first_line: Vec<u8>,
-    pub content_type: ContentType,
+    pub content_type: Option<ContentType>,
 }
 
 impl<'a> InputFileReader<'a> {
-    fn new<R: BufRead + 'a>(mut reader: R) -> Result<InputFileReader<'a>> {
+    fn new<R: BufRead + 'a>(mut reader: R) -> InputFileReader<'a> {
         let mut first_line = vec![];
-        if reader.read_until(b'\n', &mut first_line)? == 0 {
-            return Err(ErrorKind::ImmediateEOF.into());
-        }
+        reader.read_until(b'\n', &mut first_line).ok();
 
-        let content_type = content_inspector::inspect(&first_line[..]);
+        let content_type = if first_line.is_empty() {
+            None
+        } else {
+            Some(content_inspector::inspect(&first_line[..]))
+        };
 
-        if content_type == ContentType::UTF_16LE {
+        if content_type == Some(ContentType::UTF_16LE) {
             reader.read_until(0x00, &mut first_line).ok();
         }
 
-        Ok(InputFileReader {
+        InputFileReader {
             inner: Box::new(reader),
             first_line,
             content_type,
-        })
+        }
     }
 
     pub fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<bool> {
         if self.first_line.is_empty() {
             let res = self.inner.read_until(b'\n', buf).map(|size| size > 0)?;
 
-            if self.content_type == ContentType::UTF_16LE {
+            if self.content_type == Some(ContentType::UTF_16LE) {
                 self.inner.read_until(0x00, buf).ok();
             }
 
@@ -59,7 +61,7 @@ pub enum InputFile<'a> {
 impl<'a> InputFile<'a> {
     pub fn get_reader(&self, stdin: &'a io::Stdin) -> Result<InputFileReader> {
         match self {
-            InputFile::StdIn => InputFileReader::new(stdin.lock()),
+            InputFile::StdIn => Ok(InputFileReader::new(stdin.lock())),
             InputFile::Ordinary(filename) => {
                 let file = File::open(filename).map_err(|e| format!("'{}': {}", filename, e))?;
 
@@ -67,9 +69,9 @@ impl<'a> InputFile<'a> {
                     return Err(format!("'{}' is a directory.", filename).into());
                 }
 
-                InputFileReader::new(BufReader::new(file))
+                Ok(InputFileReader::new(BufReader::new(file)))
             }
-            InputFile::ThemePreviewFile => InputFileReader::new(THEME_PREVIEW_FILE),
+            InputFile::ThemePreviewFile => Ok(InputFileReader::new(THEME_PREVIEW_FILE)),
         }
     }
 }
@@ -77,7 +79,7 @@ impl<'a> InputFile<'a> {
 #[test]
 fn basic() {
     let content = b"#!/bin/bash\necho hello";
-    let mut reader = InputFileReader::new(&content[..]).unwrap();
+    let mut reader = InputFileReader::new(&content[..]);
 
     assert_eq!(b"#!/bin/bash\n", &reader.first_line[..]);
 
@@ -106,7 +108,7 @@ fn basic() {
 #[test]
 fn utf16le() {
     let content = b"\xFF\xFE\x73\x00\x0A\x00\x64\x00";
-    let mut reader = InputFileReader::new(&content[..]).unwrap();
+    let mut reader = InputFileReader::new(&content[..]);
 
     assert_eq!(b"\xFF\xFE\x73\x00\x0A\x00", &reader.first_line[..]);
 

src/line_range.rs

@@ -1,4 +1,4 @@
-use errors::*;
+use crate::errors::*;
 
 #[derive(Clone)]
 pub struct LineRange {
@@ -109,18 +109,12 @@ impl LineRanges {
     }
 
     pub fn check(&self, line: usize) -> RangeCheckResult {
-        if self.ranges.is_empty() {
+        if self.ranges.is_empty() | self.ranges.iter().any(|r| r.is_inside(line)) {
             RangeCheckResult::InRange
+        } else if line < self.largest_upper_bound {
+            RangeCheckResult::OutsideRange
         } else {
-            if self.ranges.iter().any(|r| r.is_inside(line)) {
-                RangeCheckResult::InRange
-            } else {
-                if line < self.largest_upper_bound {
-                    RangeCheckResult::OutsideRange
-                } else {
-                    RangeCheckResult::AfterLastRange
-                }
-            }
+            RangeCheckResult::AfterLastRange
         }
     }
 }

src/main.rs

@@ -48,12 +48,12 @@ use std::process;
 use ansi_term::Colour::Green;
 use ansi_term::Style;
 
-use app::{App, Config};
-use assets::{cache_dir, clear_assets, config_dir, HighlightingAssets};
-use config::config_file;
-use controller::Controller;
-use inputfile::InputFile;
-use style::{OutputComponent, OutputComponents};
+use crate::app::{App, Config};
+use crate::assets::{cache_dir, clear_assets, config_dir, HighlightingAssets};
+use crate::config::config_file;
+use crate::controller::Controller;
+use crate::inputfile::InputFile;
+use crate::style::{OutputComponent, OutputComponents};
 
 mod errors {
     error_chain! {
@@ -63,14 +63,11 @@ mod errors {
             SyntectError(::syntect::LoadingError);
             ParseIntError(::std::num::ParseIntError);
         }
-        errors {
-            ImmediateEOF
-        }
     }
 
     pub fn handle_error(error: &Error) {
         match error {
-            &Error(ErrorKind::Io(ref io_error), _)
+            Error(ErrorKind::Io(ref io_error), _)
                 if io_error.kind() == super::io::ErrorKind::BrokenPipe =>
             {
                 super::process::exit(0);
@@ -83,7 +80,7 @@ mod errors {
     }
 }
 
-use errors::*;
+use crate::errors::*;
 
 fn run_cache_subcommand(matches: &clap::ArgMatches) -> Result<()> {
     if matches.is_present("build") {
@@ -111,48 +108,54 @@ pub fn list_languages(config: &Config) -> Result<()> {
         .collect::<Vec<_>>();
     languages.sort_by_key(|lang| lang.name.to_uppercase());
 
-    let longest = languages
-        .iter()
-        .map(|syntax| syntax.name.len())
-        .max()
-        .unwrap_or(32); // Fallback width if they have no language definitions.
-
-    let comma_separator = ", ";
-    let separator = " ";
-    // Line-wrapping for the possible file extension overflow.
-    let desired_width = config.term_width - longest - separator.len();
-
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
 
-    let style = if config.colored_output {
-        Green.normal()
-    } else {
-        Style::default()
-    };
-
-    for lang in languages {
-        write!(stdout, "{:width$}{}", lang.name, separator, width = longest)?;
-
-        // Number of characters on this line so far, wrap before `desired_width`
-        let mut num_chars = 0;
-
-        let mut extension = lang.file_extensions.iter().peekable();
-        while let Some(word) = extension.next() {
-            // If we can't fit this word in, then create a line break and align it in.
-            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)?;
-            }
-
-            num_chars += new_chars;
-            write!(stdout, "{}", style.paint(&word[..]))?;
-            if extension.peek().is_some() {
-                write!(stdout, "{}", comma_separator)?;
-            }
+    if config.loop_through {
+        for lang in languages {
+            write!(stdout, "{}:{}\n", lang.name, lang.file_extensions.join(","))?;
+        }
+    } else {
+        let longest = languages
+            .iter()
+            .map(|syntax| syntax.name.len())
+            .max()
+            .unwrap_or(32); // Fallback width if they have no language definitions.
+
+        let comma_separator = ", ";
+        let separator = " ";
+        // Line-wrapping for the possible file extension overflow.
+        let desired_width = config.term_width - longest - separator.len();
+
+        let style = if config.colored_output {
+            Green.normal()
+        } else {
+            Style::default()
+        };
+
+        for lang in languages {
+            write!(stdout, "{:width$}{}", lang.name, separator, width = longest)?;
+
+            // Number of characters on this line so far, wrap before `desired_width`
+            let mut num_chars = 0;
+
+            let mut extension = lang.file_extensions.iter().peekable();
+            while let Some(word) = extension.next() {
+                // If we can't fit this word in, then create a line break and align it in.
+                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)?;
+                }
+
+                num_chars += new_chars;
+                write!(stdout, "{}", style.paint(&word[..]))?;
+                if extension.peek().is_some() {
+                    write!(stdout, "{}", comma_separator)?;
+                }
+            }
+            writeln!(stdout)?;
         }
-        writeln!(stdout)?;
     }
 
     Ok(())

src/output.rs

@@ -6,8 +6,8 @@ use std::process::{Child, Command, Stdio};
 
 use shell_words;
 
-use app::PagingMode;
-use errors::*;
+use crate::app::PagingMode;
+use crate::errors::*;
 
 pub enum OutputType {
     Pager(Child),
@@ -43,10 +43,15 @@ impl OutputType {
             _ => None,
         };
 
+        let pager_from_config = pager_from_config.map(|p| p.to_string());
+
+        if pager_from_config.is_some() {
+            replace_arguments_to_less = false;
+        }
+
         let pager = pager_from_config
-            .map(|p| p.to_string())
             .or(pager_from_env)
-            .unwrap_or(String::from("less"));
+            .unwrap_or_else(|| String::from("less"));
 
         let pagerflags =
             shell_words::split(&pager).chain_err(|| "Could not parse pager command.")?;
@@ -93,7 +98,7 @@ impl OutputType {
         OutputType::Stdout(io::stdout())
     }
 
-    pub fn handle(&mut self) -> Result<&mut Write> {
+    pub fn handle(&mut self) -> Result<&mut dyn Write> {
         Ok(match *self {
             OutputType::Pager(ref mut command) => command
                 .stdin

src/preprocessor.rs

@@ -33,41 +33,115 @@ pub fn expand_tabs(line: &str, width: usize, cursor: &mut usize) -> String {
     buffer
 }
 
-pub fn replace_nonprintable(input: &str, tab_width: usize) -> String {
+fn try_parse_utf8_char(input: &[u8]) -> Option<(char, usize)> {
+    let str_from_utf8 = |seq| std::str::from_utf8(seq).ok();
+
+    let decoded = None
+        .or(input.get(0..1).and_then(str_from_utf8).map(|c| (c, 1)))
+        .or(input.get(0..2).and_then(str_from_utf8).map(|c| (c, 2)))
+        .or(input.get(0..3).and_then(str_from_utf8).map(|c| (c, 3)))
+        .or(input.get(0..4).and_then(str_from_utf8).map(|c| (c, 4)));
+
+    let decoded_char = decoded.map(|(seq, n)| (seq.chars().next().unwrap(), n));
+
+    decoded_char
+}
+
+pub fn replace_nonprintable(input: &[u8], tab_width: usize) -> String {
     let mut output = String::new();
 
     let tab_width = if tab_width == 0 { 4 } else { tab_width };
 
-    for chr in input.chars() {
-        match chr {
-            // space
-            ' ' => output.push('•'),
-            // tab
-            '\t' => {
-                if tab_width == 1 {
-                    output.push('↹');
-                } else {
-                    output.push('├');
-                    output.push_str(&"─".repeat(tab_width - 2));
-                    output.push('┤');
+    let mut idx = 0;
+    let len = input.len();
+    while idx < len {
+        if let Some((chr, skip_ahead)) = try_parse_utf8_char(&input[idx..]) {
+            idx += skip_ahead;
+
+            match chr {
+                // space
+                ' ' => output.push('•'),
+                // tab
+                '\t' => {
+                    if tab_width == 1 {
+                        output.push('↹');
+                    } else {
+                        output.push('├');
+                        output.push_str(&"─".repeat(tab_width - 2));
+                        output.push('┤');
+                    }
                 }
+                // line feed
+                '\x0A' => output.push('␊'),
+                // carriage return
+                '\x0D' => output.push('␍'),
+                // null
+                '\x00' => output.push('␀'),
+                // bell
+                '\x07' => output.push('␇'),
+                // backspace
+                '\x08' => output.push('␈'),
+                // escape
+                '\x1B' => output.push('␛'),
+                // printable ASCII
+                c if c.is_ascii_alphanumeric()
+                    || c.is_ascii_punctuation()
+                    || c.is_ascii_graphic() =>
+                {
+                    output.push(c)
+                }
+                // everything else
+                c => output.push_str(&c.escape_unicode().collect::<String>()),
             }
-            // line feed
-            '\x0A' => output.push('␊'),
-            // carriage return
-            '\x0D' => output.push('␍'),
-            // null
-            '\x00' => output.push('␀'),
-            // bell
-            '\x07' => output.push('␇'),
-            // backspace
-            '\x08' => output.push('␈'),
-            // escape
-            '\x1B' => output.push('␛'),
-            // anything else
-            _ => output.push(chr),
+        } else {
+            output.push_str(&format!("\\x{:02X}", input[idx]));
+            idx += 1;
         }
     }
 
     output
 }
+
+#[test]
+fn test_try_parse_utf8_char() {
+    assert_eq!(try_parse_utf8_char(&[0x20]), Some((' ', 1)));
+    assert_eq!(try_parse_utf8_char(&[0x20, 0x20]), Some((' ', 1)));
+    assert_eq!(try_parse_utf8_char(&[0x20, 0xef]), Some((' ', 1)));
+
+    assert_eq!(try_parse_utf8_char(&[0x00]), Some(('\x00', 1)));
+    assert_eq!(try_parse_utf8_char(&[0x1b]), Some(('\x1b', 1)));
+
+    assert_eq!(try_parse_utf8_char(&[0xc3, 0xa4]), Some(('ä', 2)));
+    assert_eq!(try_parse_utf8_char(&[0xc3, 0xa4, 0xef]), Some(('ä', 2)));
+    assert_eq!(try_parse_utf8_char(&[0xc3, 0xa4, 0x20]), Some(('ä', 2)));
+
+    assert_eq!(try_parse_utf8_char(&[0xe2, 0x82, 0xac]), Some(('€', 3)));
+    assert_eq!(
+        try_parse_utf8_char(&[0xe2, 0x82, 0xac, 0xef]),
+        Some(('€', 3))
+    );
+    assert_eq!(
+        try_parse_utf8_char(&[0xe2, 0x82, 0xac, 0x20]),
+        Some(('€', 3))
+    );
+
+    assert_eq!(try_parse_utf8_char(&[0xe2, 0x88, 0xb0]), Some(('∰', 3)));
+
+    assert_eq!(
+        try_parse_utf8_char(&[0xf0, 0x9f, 0x8c, 0x82]),
+        Some(('🌂', 4))
+    );
+    assert_eq!(
+        try_parse_utf8_char(&[0xf0, 0x9f, 0x8c, 0x82, 0xef]),
+        Some(('🌂', 4))
+    );
+    assert_eq!(
+        try_parse_utf8_char(&[0xf0, 0x9f, 0x8c, 0x82, 0x20]),
+        Some(('🌂', 4))
+    );
+
+    assert_eq!(try_parse_utf8_char(&[]), None);
+    assert_eq!(try_parse_utf8_char(&[0xef]), None);
+    assert_eq!(try_parse_utf8_char(&[0xef, 0x20]), None);
+    assert_eq!(try_parse_utf8_char(&[0xf0, 0xf0]), None);
+}

src/printer.rs

@@ -16,24 +16,29 @@ use content_inspector::ContentType;
 use encoding::all::{UTF_16BE, UTF_16LE};
 use encoding::{DecoderTrap, Encoding};
 
-use app::Config;
-use assets::HighlightingAssets;
-use decorations::{Decoration, GridBorderDecoration, LineChangesDecoration, LineNumberDecoration};
-use diff::get_git_diff;
-use diff::LineChanges;
-use errors::*;
-use inputfile::{InputFile, InputFileReader};
-use preprocessor::{expand_tabs, replace_nonprintable};
-use style::OutputWrap;
-use terminal::{as_terminal_escaped, to_ansi_color};
+use crate::app::Config;
+use crate::assets::HighlightingAssets;
+use crate::decorations::{
+    Decoration, GridBorderDecoration, LineChangesDecoration, LineNumberDecoration,
+};
+use crate::diff::get_git_diff;
+use crate::diff::LineChanges;
+use crate::errors::*;
+use crate::inputfile::{InputFile, InputFileReader};
+use crate::preprocessor::{expand_tabs, replace_nonprintable};
+use crate::style::OutputWrap;
+use crate::terminal::{as_terminal_escaped, to_ansi_color};
 
 pub trait Printer {
-    fn print_header(&mut self, handle: &mut Write, file: InputFile) -> Result<()>;
-    fn print_footer(&mut self, handle: &mut Write) -> Result<()>;
+    fn print_header(&mut self, handle: &mut dyn Write, file: InputFile) -> Result<()>;
+    fn print_footer(&mut self, handle: &mut dyn Write) -> Result<()>;
+
+    fn print_snip(&mut self, handle: &mut dyn Write) -> Result<()>;
+
     fn print_line(
         &mut self,
         out_of_range: bool,
-        handle: &mut Write,
+        handle: &mut dyn Write,
         line_number: usize,
         line_buffer: &[u8],
     ) -> Result<()>;
@@ -48,23 +53,27 @@ impl SimplePrinter {
 }
 
 impl Printer for SimplePrinter {
-    fn print_header(&mut self, _handle: &mut Write, _file: InputFile) -> Result<()> {
+    fn print_header(&mut self, _handle: &mut dyn Write, _file: InputFile) -> Result<()> {
         Ok(())
     }
 
-    fn print_footer(&mut self, _handle: &mut Write) -> Result<()> {
+    fn print_footer(&mut self, _handle: &mut dyn Write) -> Result<()> {
+        Ok(())
+    }
+
+    fn print_snip(&mut self, _handle: &mut dyn Write) -> Result<()> {
         Ok(())
     }
 
     fn print_line(
         &mut self,
         out_of_range: bool,
-        handle: &mut Write,
+        handle: &mut dyn Write,
         _line_number: usize,
         line_buffer: &[u8],
     ) -> Result<()> {
         if !out_of_range {
-            handle.write(line_buffer)?;
+            handle.write_all(line_buffer)?;
         }
         Ok(())
     }
@@ -76,7 +85,7 @@ pub struct InteractivePrinter<'a> {
     decorations: Vec<Box<dyn Decoration>>,
     panel_width: usize,
     ansi_prefix_sgr: String,
-    content_type: ContentType,
+    content_type: Option<ContentType>,
     pub line_changes: Option<LineChanges>,
     highlighter: Option<HighlightLines<'a>>,
     syntax_set: &'a SyntaxSet,
@@ -132,7 +141,10 @@ impl<'a> InteractivePrinter<'a> {
 
         let mut line_changes = None;
 
-        let highlighter = if reader.content_type.is_binary() {
+        let highlighter = if reader
+            .content_type
+            .map_or(false, |c| c.is_binary() && !config.show_nonprintable)
+        {
             None
         } else {
             // Get the Git modifications
@@ -164,7 +176,7 @@ impl<'a> InteractivePrinter<'a> {
         }
     }
 
-    fn print_horizontal_line(&mut self, handle: &mut Write, grid_char: char) -> Result<()> {
+    fn print_horizontal_line(&mut self, handle: &mut dyn Write, grid_char: char) -> Result<()> {
         if self.panel_width == 0 {
             writeln!(
                 handle,
@@ -180,6 +192,24 @@ impl<'a> InteractivePrinter<'a> {
         Ok(())
     }
 
+    fn create_fake_panel(&self, text: &str) -> String {
+        if self.panel_width == 0 {
+            "".to_string()
+        } else {
+            let text_truncated: String = text.chars().take(self.panel_width - 1).collect();
+            let text_filled: String = format!(
+                "{}{}",
+                text_truncated,
+                " ".repeat(self.panel_width - 1 - text_truncated.len())
+            );
+            if self.config.output_components.grid() {
+                format!("{} │ ", text_filled)
+            } else {
+                format!("{}", text_filled)
+            }
+        }
+    }
+
     fn preprocess(&self, text: &str, cursor: &mut usize) -> String {
         if self.config.tab_width > 0 {
             expand_tabs(text, self.config.tab_width, cursor)
@@ -190,8 +220,27 @@ impl<'a> InteractivePrinter<'a> {
 }
 
 impl<'a> Printer for InteractivePrinter<'a> {
-    fn print_header(&mut self, handle: &mut Write, file: InputFile) -> Result<()> {
+    fn print_header(&mut self, handle: &mut dyn Write, file: InputFile) -> Result<()> {
         if !self.config.output_components.header() {
+            if Some(ContentType::BINARY) == self.content_type && !self.config.show_nonprintable {
+                let input = match file {
+                    InputFile::Ordinary(filename) => format!("file '{}'", filename),
+                    _ => "STDIN".into(),
+                };
+
+                writeln!(
+                    handle,
+                    "{}: Binary content from {} will not be printed to the terminal \
+                     (but will be present if the output of 'bat' is piped). You can use 'bat -A' \
+                     to show the binary file contents.",
+                    Yellow.paint("[bat warning]"),
+                    input
+                )?;
+            } else {
+                if self.config.output_components.grid() {
+                    self.print_horizontal_line(handle, '┬')?;
+                }
+            }
             return Ok(());
         }
 
@@ -216,9 +265,10 @@ impl<'a> Printer for InteractivePrinter<'a> {
         };
 
         let mode = match self.content_type {
-            ContentType::BINARY => "   <BINARY>",
-            ContentType::UTF_16LE => "   <UTF-16LE>",
-            ContentType::UTF_16BE => "   <UTF-16BE>",
+            Some(ContentType::BINARY) => "   <BINARY>",
+            Some(ContentType::UTF_16LE) => "   <UTF-16LE>",
+            Some(ContentType::UTF_16BE) => "   <UTF-16BE>",
+            None => "   <EMPTY>",
             _ => "",
         };
 
@@ -231,7 +281,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
         )?;
 
         if self.config.output_components.grid() {
-            if self.content_type.is_text() {
+            if self.content_type.map_or(false, |c| c.is_text()) || self.config.show_nonprintable {
                 self.print_horizontal_line(handle, '┼')?;
             } else {
                 self.print_horizontal_line(handle, '┴')?;
@@ -241,38 +291,64 @@ impl<'a> Printer for InteractivePrinter<'a> {
         Ok(())
     }
 
-    fn print_footer(&mut self, handle: &mut Write) -> Result<()> {
-        if self.config.output_components.grid() && self.content_type.is_text() {
+    fn print_footer(&mut self, handle: &mut dyn Write) -> Result<()> {
+        if self.config.output_components.grid()
+            && (self.content_type.map_or(false, |c| c.is_text()) || self.config.show_nonprintable)
+        {
             self.print_horizontal_line(handle, '┴')
         } else {
             Ok(())
         }
     }
 
+    fn print_snip(&mut self, handle: &mut dyn Write) -> Result<()> {
+        let panel = self.create_fake_panel(" ...");
+        let panel_count = panel.chars().count();
+
+        let title = "8<";
+        let title_count = title.chars().count();
+
+        let snip_left = "─ ".repeat((self.config.term_width - panel_count - (title_count / 2)) / 4);
+        let snip_left_count = snip_left.chars().count(); // Can't use .len() with Unicode.
+
+        let snip_right =
+            " ─".repeat((self.config.term_width - panel_count - snip_left_count - title_count) / 2);
+
+        write!(
+            handle,
+            "{}\n",
+            self.colors
+                .grid
+                .paint(format!("{}{}{}{}", panel, snip_left, title, snip_right))
+        )?;
+
+        Ok(())
+    }
+
     fn print_line(
         &mut self,
         out_of_range: bool,
-        handle: &mut Write,
+        handle: &mut dyn Write,
         line_number: usize,
         line_buffer: &[u8],
     ) -> Result<()> {
-        let mut line = match self.content_type {
-            ContentType::BINARY => {
-                return Ok(());
+        let line = if self.config.show_nonprintable {
+            replace_nonprintable(&line_buffer, self.config.tab_width)
+        } else {
+            match self.content_type {
+                Some(ContentType::BINARY) | None => {
+                    return Ok(());
+                }
+                Some(ContentType::UTF_16LE) => UTF_16LE
+                    .decode(&line_buffer, DecoderTrap::Replace)
+                    .map_err(|_| "Invalid UTF-16LE")?,
+                Some(ContentType::UTF_16BE) => UTF_16BE
+                    .decode(&line_buffer, DecoderTrap::Replace)
+                    .map_err(|_| "Invalid UTF-16BE")?,
+                _ => String::from_utf8_lossy(&line_buffer).to_string(),
             }
-            ContentType::UTF_16LE => UTF_16LE
-                .decode(&line_buffer, DecoderTrap::Strict)
-                .unwrap_or("Invalid UTF-16LE".into()),
-            ContentType::UTF_16BE => UTF_16BE
-                .decode(&line_buffer, DecoderTrap::Strict)
-                .unwrap_or("Invalid UTF-16BE".into()),
-            _ => String::from_utf8_lossy(&line_buffer).to_string(),
         };
 
-        if self.config.show_nonprintable {
-            line = replace_nonprintable(&mut line, self.config.tab_width);
-        }
-
         let regions = {
             let highlighter = match self.highlighter {
                 Some(ref mut highlighter) => highlighter,
@@ -355,25 +431,35 @@ impl<'a> Printer for InteractivePrinter<'a> {
             }
 
             if line.bytes().next_back() != Some(b'\n') {
-                write!(handle, "\n")?;
+                writeln!(handle)?;
             }
         } else {
             for &(style, region) in regions.iter() {
-                let mut ansi_iterator = AnsiCodeIterator::new(region);
+                let ansi_iterator = AnsiCodeIterator::new(region);
                 let mut ansi_prefix: String = String::new();
                 for chunk in ansi_iterator {
                     match chunk {
                         // ANSI escape passthrough.
                         (text, true) => {
-                            if text.chars().last().map_or(false, |c| c == 'm') {
+                            let is_ansi_csi = text.starts_with("\x1B[");
+
+                            if is_ansi_csi && text.ends_with('m') {
+                                // It's an ANSI SGR sequence.
+                                // We should be mostly safe to just append these together.
                                 ansi_prefix.push_str(text);
                                 if text == "\x1B[0m" {
                                     self.ansi_prefix_sgr = "\x1B[0m".to_owned();
                                 } else {
                                     self.ansi_prefix_sgr.push_str(text);
                                 }
-                            } else {
+                            } else if is_ansi_csi {
+                                // It's a regular CSI sequence.
+                                // We should be mostly safe to just append these together.
                                 ansi_prefix.push_str(text);
+                            } else {
+                                // It's probably a VT100 code.
+                                // Passing it through is the safest bet.
+                                write!(handle, "{}", text)?;
                             }
                         }
 
@@ -472,7 +558,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
                     ansi_style.paint(" ".repeat(cursor_max - cursor))
                 )?;
             }
-            write!(handle, "\n")?;
+            writeln!(handle)?;
         }
 
         Ok(())

src/style.rs

@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 use std::str::FromStr;
 
-use errors::*;
+use crate::errors::*;
 
 #[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
 pub enum OutputComponent {
@@ -10,6 +10,7 @@ pub enum OutputComponent {
     Grid,
     Header,
     Numbers,
+    Snip,
     Full,
     Plain,
 }
@@ -21,8 +22,8 @@ pub enum OutputWrap {
 }
 
 impl OutputComponent {
-    pub fn components(&self, interactive_terminal: bool) -> &'static [OutputComponent] {
-        match *self {
+    pub fn components(self, interactive_terminal: bool) -> &'static [OutputComponent] {
+        match self {
             OutputComponent::Auto => {
                 if interactive_terminal {
                     OutputComponent::Full.components(interactive_terminal)
@@ -34,11 +35,13 @@ impl OutputComponent {
             OutputComponent::Grid => &[OutputComponent::Grid],
             OutputComponent::Header => &[OutputComponent::Header],
             OutputComponent::Numbers => &[OutputComponent::Numbers],
+            OutputComponent::Snip => &[OutputComponent::Snip],
             OutputComponent::Full => &[
                 OutputComponent::Changes,
                 OutputComponent::Grid,
                 OutputComponent::Header,
                 OutputComponent::Numbers,
+                OutputComponent::Snip,
             ],
             OutputComponent::Plain => &[],
         }
@@ -55,6 +58,7 @@ impl FromStr for OutputComponent {
             "grid" => Ok(OutputComponent::Grid),
             "header" => Ok(OutputComponent::Header),
             "numbers" => Ok(OutputComponent::Numbers),
+            "snip" => Ok(OutputComponent::Snip),
             "full" => Ok(OutputComponent::Full),
             "plain" => Ok(OutputComponent::Plain),
             _ => Err(format!("Unknown style '{}'", s).into()),
@@ -82,6 +86,10 @@ impl OutputComponents {
         self.0.contains(&OutputComponent::Numbers)
     }
 
+    pub fn snip(&self) -> bool {
+        self.0.contains(&OutputComponent::Snip)
+    }
+
     pub fn plain(&self) -> bool {
         self.0.iter().all(|c| c == &OutputComponent::Plain)
     }

src/syntax_mapping.rs

@@ -1,12 +1,12 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct SyntaxMapping(HashMap<String, String>);
 
 impl SyntaxMapping {
     pub fn new() -> SyntaxMapping {
-        SyntaxMapping(HashMap::new())
+        Default::default()
     }
 
     pub fn insert(&mut self, from: impl Into<String>, to: impl Into<String>) -> Option<String> {

src/terminal.rs

@@ -6,7 +6,13 @@ use ansi_term::{self, Style};
 use syntect::highlighting::{self, FontStyle};
 
 pub fn to_ansi_color(color: highlighting::Color, true_color: bool) -> ansi_term::Colour {
-    if true_color {
+    if color.a == 0 {
+        // Themes can specify one of the user-configurable terminal colors by
+        // encoding them as #RRGGBBAA with AA set to 00 (transparent) and RR set
+        // to the color palette number. The built-in themes ansi-light,
+        // ansi-dark, and base16 use this.
+        Fixed(color.r)
+    } else if true_color {
         RGB(color.r, color.g, color.b)
     } else {
         Fixed(ansi_colours::ansi256_from_rgb((color.r, color.g, color.b)))

tests/examples/cache

@@ -0,0 +1 @@
+test

tests/examples/cache.c

@@ -0,0 +1 @@
+test

tests/examples/single-line.txt

@@ -0,0 +1 @@
+Single Line

tests/integration_tests.rs

@@ -76,6 +76,79 @@ fn concatenate_stdin() {
         .stdout("hello world\nstdin\nhello world\n");
 }
 
+#[test]
+fn concatenate_empty_first() {
+    bat()
+        .arg("empty.txt")
+        .arg("test.txt")
+        .assert()
+        .success()
+        .stdout("hello world\n");
+}
+
+#[test]
+fn concatenate_empty_last() {
+    bat()
+        .arg("test.txt")
+        .arg("empty.txt")
+        .assert()
+        .success()
+        .stdout("hello world\n");
+}
+
+#[test]
+fn concatenate_empty_both() {
+    bat()
+        .arg("empty.txt")
+        .arg("empty.txt")
+        .assert()
+        .success()
+        .stdout("");
+}
+
+#[test]
+fn concatenate_empty_between() {
+    bat()
+        .arg("test.txt")
+        .arg("empty.txt")
+        .arg("test.txt")
+        .assert()
+        .success()
+        .stdout("hello world\nhello world\n");
+}
+
+#[test]
+fn concatenate_empty_first_and_last() {
+    bat()
+        .arg("empty.txt")
+        .arg("test.txt")
+        .arg("empty.txt")
+        .assert()
+        .success()
+        .stdout("hello world\n");
+}
+
+#[test]
+fn concatenate_single_line() {
+    bat()
+        .arg("single-line.txt")
+        .arg("single-line.txt")
+        .assert()
+        .success()
+        .stdout("Single LineSingle Line");
+}
+
+#[test]
+fn concatenate_single_line_empty() {
+    bat()
+        .arg("single-line.txt")
+        .arg("empty.txt")
+        .arg("single-line.txt")
+        .assert()
+        .success()
+        .stdout("Single LineSingle Line");
+}
+
 #[test]
 fn line_numbers() {
     bat()
@@ -363,3 +436,60 @@ fn config_read_arguments_from_file() {
         .success()
         .stdout("dummy-pager-from-config\n");
 }
+
+#[test]
+fn utf16() {
+    // The output will be converted to UTF-8 with a leading UTF-8 BOM
+    bat()
+        .arg("--plain")
+        .arg("--decorations=always")
+        .arg("test_UTF-16LE.txt")
+        .assert()
+        .success()
+        .stdout(std::str::from_utf8(b"\xEF\xBB\xBFhello world\n").unwrap());
+}
+
+#[test]
+fn can_print_file_named_cache() {
+    bat_with_config()
+        .arg("cache")
+        .assert()
+        .success()
+        .stdout("test\n")
+        .stderr("");
+}
+
+#[test]
+fn can_print_file_starting_with_cache() {
+    bat_with_config()
+        .arg("cache.c")
+        .assert()
+        .success()
+        .stdout("test\n")
+        .stderr("");
+}
+
+#[test]
+fn does_not_print_unwanted_file_named_cache() {
+    bat_with_config().arg("cach").assert().failure();
+}
+
+#[test]
+fn snip() {
+    bat()
+        .arg("multiline.txt")
+        .arg("--style=numbers,snip")
+        .arg("--decorations=always")
+        .arg("--line-range=1:2")
+        .arg("--line-range=4:")
+        .arg("--terminal-width=80")
+        .assert()
+        .success()
+        .stdout(
+            "   1 line 1
+   2 line 2
+ ...─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ 8< ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+   4 line 4
+",
+        );
+}

tests/snapshot_tests.rs

@@ -1,6 +1,6 @@
 mod tester;
 
-use tester::BatTester;
+use crate::tester::BatTester;
 
 macro_rules! snapshot_tests {
     ($($test_name: ident: $style: expr,)*) => {

tests/snapshots/output/changes_grid.snapshot.txt

@@ -1,3 +1,4 @@
+──┬─────────────────────────────────────────────────────────────────────────────
   │ struct Rectangle {
   │     width: u32,
   │     height: u32,

tests/snapshots/output/changes_grid_numbers.snapshot.txt

@@ -1,3 +1,4 @@
+───────┬────────────────────────────────────────────────────────────────────────
    1   │ struct Rectangle {
    2   │     width: u32,
    3   │     height: u32,

tests/snapshots/output/grid.snapshot.txt

@@ -1,3 +1,4 @@
+────────────────────────────────────────────────────────────────────────────────
 struct Rectangle {
     width: u32,
     height: u32,

tests/snapshots/output/grid_numbers.snapshot.txt

@@ -1,3 +1,4 @@
+─────┬──────────────────────────────────────────────────────────────────────────
    1 │ struct Rectangle {
    2 │     width: u32,
    3 │     height: u32,