Add brewfile support, closes #469

Bash expands patterns to an alphabetically sorted list of filenames, but
the order depends on LC_COLLATE. On both Linux and BSD, `sort -V` uses
the C locale.

.github/ISSUE_TEMPLATE/add-language.md

@@ -0,0 +1,18 @@
+---
+name: Add language
+about: Add support for new language
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!--- vim-polyglot accepts only lightweight, maintained github-hosted vim plugins -->
+
+**GitHub repository url**
+
+
+**Is this plugin well maintained?**
+
+
+**Is this plugin lightweight? (no advanced functionality, just indent and syntax support)**

.github/ISSUE_TEMPLATE/add-support-for-language.md

@@ -0,0 +1,20 @@
+---
+name: Add support for language
+about: ''
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,16 @@
+---
+name: Bug report
+about: Report vim-polyglot bug
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!-- Vim-polyglot is not responsible for bugs of plugins it uses. Please report only bugs that happen when plugin is used as part of vim-polyglot and doesn't happen when just install the plugin -->
+
+**Does this bug happen when you install plugin without vim-polyglot?**
+
+**Describe the bug:**
+
+**To Reproduce:**

.gitignore

@@ -1 +1,2 @@
 /tmp
+!*ctags*

.travis.yml

@@ -1,12 +1,11 @@
 language: ruby
 rvm:
-  - 1.9.3
+  - 2.6
 sudo: false
 addons:
   apt:
     packages:
       - vim-gtk
 before_script:
-  - "export DISPLAY=:99.0"
-  - "sh -e /etc/init.d/xvfb start"
-script: bundle exec rspec --format=documentation
+  - "./build"
+script: xvfb-run bundle exec rspec --format=documentation

Gemfile.lock

@@ -1,16 +1,21 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.1.3)
-    rspec (2.12.0)
-      rspec-core (~> 2.12.0)
-      rspec-expectations (~> 2.12.0)
-      rspec-mocks (~> 2.12.0)
-    rspec-core (2.12.2)
-    rspec-expectations (2.12.1)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.12.0)
-    vimrunner (0.3.0)
+    diff-lcs (1.3)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    vimrunner (0.3.4)
 
 PLATFORMS
   ruby
@@ -18,3 +23,6 @@ PLATFORMS
 DEPENDENCIES
   rspec
   vimrunner
+
+BUNDLED WITH
+   1.16.2

README.md

@@ -1,6 +1,8 @@
-# vim-polyglot [![Build Status][travis-img-url]][travis-url]
+![vim-polyglot](https://i.imgur.com/9RxQK6k.png)
 
-[travis-img-url]: https://travis-ci.org/sheerun/vim-polyglot.png
+[![Build Status][travis-img-url]][travis-url] [![Maintenance](https://img.shields.io/maintenance/yes/2019.svg?maxAge=2592000)]()
+
+[travis-img-url]: https://travis-ci.org/sheerun/vim-polyglot.svg
 [travis-url]: https://travis-ci.org/sheerun/vim-polyglot
 
 A collection of language packs for Vim.
@@ -8,123 +10,219 @@ A collection of language packs for Vim.
 > One to rule them all, one to find them, one to bring them all and in the darkness bind them.
 
 - It **won't affect your startup time**, as scripts are loaded only on demand\*.
-- It **installs and updates 70+ times faster** than 70+ packages it consist of.
-- Solid syntax and indentation support. Only the best language packs.
+- It **installs and updates 120+ times faster** than the <!--Package Count-->149<!--/Package Count--> packages it consists of.
+- Solid syntax and indentation support (other features skipped). Only the best language packs.
 - All unnecessary files are ignored (like enormous documentation from php support).
 - No support for esoteric languages, only most popular ones (modern too, like `slim`).
 - Each build is tested by automated vimrunner script on CI. See `spec` directory.
 
-\*To be completely honest, concatenated `ftdetect` script takes around `3ms` to load.
+\*To be completely honest, concatenated `ftdetect` script takes up to `17ms` to load.
 
 ## Installation
 
 1. Install [Pathogen](https://github.com/tpope/vim-pathogen), [Vundle](https://github.com/VundleVim/Vundle.vim), [NeoBundle](https://github.com/Shougo/neobundle.vim), or [Plug](https://github.com/junegunn/vim-plug) package manager for Vim.
 2. Use this repository as submodule or package.
 
+For example when using [Plug](https://github.com/junegunn/vim-plug):
+
+```
+Plug 'sheerun/vim-polyglot'
+```
+
 Optionally download one of the [releases](https://github.com/sheerun/vim-polyglot/releases) and unpack it directly under `~/.vim` directory.
 
+You can also use Vim 8 built-in package manager:
+
+```
+mkdir -p ~/.vim/pack/default/start
+git clone https://github.com/sheerun/vim-polyglot ~/.vim/pack/default/start/vim-polyglot
+```
+
+NOTE: Not all features of listed language packs are available. We strip them from functionality slowing vim startup in general (for example we ignore `plugins` folder that is loaded regardless of file type, use `ftplugin` instead).
+
+If you need full functionality of any plugin, please use it directly with your plugin manager.
+
 ## Language packs
 
-- [ansible](https://github.com/pearofducks/ansible-vim) (syntax, indent, ftplugin, ftdetect)
-- [arduino](https://github.com/sudar/vim-arduino-syntax) (syntax, indent, ftdetect)
-- [blade](https://github.com/jwalton512/vim-blade) (syntax, indent, ftdetect)
+<!--Language Packs-->
+- [acpiasl](https://github.com/martinlroth/vim-acpi-asl) (syntax)
+- [ansible](https://github.com/pearofducks/ansible-vim) (syntax, indent, ftplugin)
+- [apiblueprint](https://github.com/sheerun/apiblueprint.vim) (syntax, ctags)
+- [applescript](https://github.com/mityu/vim-applescript) (syntax, indent)
+- [arduino](https://github.com/sudar/vim-arduino-syntax) (syntax, indent)
+- [asciidoc](https://github.com/asciidoc/vim-asciidoc) (syntax)
+- [autohotkey](https://github.com/hnamikaw/vim-autohotkey) (indent)
+- [blade](https://github.com/jwalton512/vim-blade) (syntax, indent, ftplugin)
+- [brewfile](https://github.com/bfontaine/Brewfile.vim) (syntax)
 - [c++11](https://github.com/octol/vim-cpp-enhanced-highlight) (syntax)
 - [c/c++](https://github.com/vim-jp/vim-cpp) (syntax)
-- [cjsx](https://github.com/mtscout6/vim-cjsx) (ftdetect, syntax, ftplugin)
-- [clojure](https://github.com/guns/vim-clojure-static) (syntax, indent, autoload, ftplugin, ftdetect)
-- [coffee-script](https://github.com/kchmck/vim-coffee-script) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [cql](https://github.com/elubow/cql-vim) (syntax, ftdetect)
-- [css](https://github.com/JulesWang/css.vim) (syntax)
-- [cucumber](https://github.com/tpope/vim-cucumber) (syntax, indent, compiler, ftplugin, ftdetect)
-- [dart](https://github.com/dart-lang/dart-vim-plugin) (syntax, indent, autoload, ftplugin, ftdetect)
-- [dockerfile](https://github.com/honza/dockerfile.vim) (syntax, ftdetect)
-- [elixir](https://github.com/elixir-lang/vim-elixir) (syntax, indent, compiler, ftplugin, ftdetect)
-- [elm](https://github.com/lambdatoast/elm.vim) (syntax, indent, autoload, ftplugin, ftdetect)
-- [emberscript](https://github.com/heartsentwined/vim-ember-script) (syntax, indent, ftplugin, ftdetect)
-- [emblem](https://github.com/heartsentwined/vim-emblem) (syntax, indent, ftplugin, ftdetect)
-- [erlang](https://github.com/vim-erlang/vim-erlang-runtime) (syntax, indent, ftdetect)
-- [git](https://github.com/tpope/vim-git) (syntax, indent, ftplugin, ftdetect)
-- [glsl](https://github.com/tikhomirov/vim-glsl) (syntax, indent, ftdetect)
-- [go](https://github.com/fatih/vim-go) (syntax, compiler, indent, ftdetect)
-- [groovy](https://github.com/vim-scripts/groovy.vim) (syntax)
-- [haml](https://github.com/tpope/vim-haml) (syntax, indent, compiler, ftplugin, ftdetect)
-- [handlebars](https://github.com/mustache/vim-mustache-handlebars) (syntax, indent, ftplugin, ftdetect)
-- [haskell](https://github.com/neovimhaskell/haskell-vim) (syntax, indent, ftplugin, ftdetect)
-- [haxe](https://github.com/yaymukund/vim-haxe) (syntax, ftdetect)
+- [caddyfile](https://github.com/isobit/vim-caddyfile) (syntax, indent, ftplugin)
+- [carp](https://github.com/hellerve/carp-vim) (syntax)
+- [cjsx](https://github.com/mtscout6/vim-cjsx) (syntax, ftplugin)
+- [clojure](https://github.com/guns/vim-clojure-static) (syntax, indent, autoload, ftplugin)
+- [cmake](https://github.com/pboettch/vim-cmake-syntax) (syntax, indent)
+- [coffee-script](https://github.com/kchmck/vim-coffee-script) (syntax, compiler, indent, autoload, ftplugin)
+- [cql](https://github.com/elubow/cql-vim) (syntax)
+- [cryptol](https://github.com/victoredwardocallaghan/cryptol.vim) (syntax, compiler, ftplugin)
+- [crystal](https://github.com/rhysd/vim-crystal) (syntax, indent, autoload, ftplugin)
+- [csv](https://github.com/chrisbra/csv.vim) (syntax, autoload, ftplugin)
+- [cucumber](https://github.com/tpope/vim-cucumber) (syntax, indent, compiler, ftplugin)
+- [cue](https://github.com/mgrabovsky/vim-cuesheet) (syntax)
+- [dart](https://github.com/dart-lang/dart-vim-plugin) (syntax, indent, autoload, ftplugin)
+- [dhall](https://github.com/vmchale/dhall-vim) (syntax, ftplugin)
+- [dlang](https://github.com/JesseKPhillips/d.vim) (syntax, indent)
+- [dockerfile](https://github.com/ekalinin/Dockerfile.vim) (syntax, indent, ftplugin)
+- [elixir](https://github.com/elixir-lang/vim-elixir) (syntax, indent, compiler, autoload, ftplugin)
+- [elm](https://github.com/andys8/vim-elm-syntax) (syntax, indent)
+- [emberscript](https://github.com/yalesov/vim-ember-script) (syntax, indent, ftplugin)
+- [emblem](https://github.com/yalesov/vim-emblem) (syntax, indent, ftplugin)
+- [erlang](https://github.com/vim-erlang/vim-erlang-runtime) (syntax, indent)
+- [ferm](https://github.com/vim-scripts/ferm.vim) (syntax)
+- [fish](https://github.com/georgewitteman/vim-fish) (syntax, indent, compiler, autoload, ftplugin)
+- [flatbuffers](https://github.com/dcharbon/vim-flatbuffers) (syntax)
+- [fsharp](https://github.com/ionide/Ionide-vim) (syntax, indent)
+- [gdscript](https://github.com/calviken/vim-gdscript3) (syntax, indent, ftplugin)
+- [git](https://github.com/tpope/vim-git) (syntax, indent, ftplugin)
+- [glsl](https://github.com/tikhomirov/vim-glsl) (syntax, indent)
+- [gmpl](https://github.com/maelvalais/gmpl.vim) (syntax)
+- [gnuplot](https://github.com/vim-scripts/gnuplot-syntax-highlighting) (syntax)
+- [go](https://github.com/fatih/vim-go) (syntax, compiler, indent)
+- [gradle](https://github.com/tfnico/vim-gradle) (compiler)
+- [graphql](https://github.com/jparise/vim-graphql) (syntax, indent, autoload, ftplugin, after)
+- [haml](https://github.com/sheerun/vim-haml) (syntax, indent, compiler, ftplugin)
+- [handlebars](https://github.com/mustache/vim-mustache-handlebars) (syntax, indent, ftplugin)
+- [haproxy](https://github.com/CH-DanReif/haproxy.vim) (syntax)
+- [haskell](https://github.com/neovimhaskell/haskell-vim) (syntax, indent, ftplugin)
+- [haxe](https://github.com/yaymukund/vim-haxe) (syntax)
+- [hcl](https://github.com/b4b4r07/vim-hcl) (syntax, indent, ftplugin)
+- [helm](https://github.com/towolf/vim-helm) (syntax)
+- [hive](https://github.com/zebradil/hive.vim) (syntax, ftplugin)
 - [html5](https://github.com/othree/html5.vim) (syntax, indent, autoload, ftplugin)
-- [jade](https://github.com/digitaltoad/vim-jade) (syntax, indent, ftplugin, ftdetect)
-- [jasmine](https://github.com/glanotte/vim-jasmine) (syntax, ftdetect)
-- [javascript](https://github.com/sheerun/yajs.vim) (syntax, indent)
-- [jinja](https://github.com/Glench/Vim-Jinja2-Syntax) (syntax, indent, ftdetect)
-- [json](https://github.com/sheerun/vim-json) (syntax, indent, ftdetect)
-- [jst](https://github.com/briancollins/vim-jst) (syntax, indent, ftdetect)
-- [jsx](https://github.com/mxw/vim-jsx) (ftdetect, after)
-- [julia](https://github.com/dcjones/julia-minimalist-vim) (syntax, indent, ftdetect)
-- [kotlin](https://github.com/udalov/kotlin-vim) (syntax, indent, ftdetect)
-- [latex](https://github.com/LaTeX-Box-Team/LaTeX-Box) (syntax, indent, ftplugin)
-- [less](https://github.com/groenewege/vim-less) (syntax, indent, ftplugin, ftdetect)
-- [liquid](https://github.com/tpope/vim-liquid) (syntax, indent, ftplugin, ftdetect)
-- [markdown](https://github.com/tpope/vim-markdown) (syntax, ftplugin, ftdetect)
-- [nginx](https://github.com/nginx/nginx) (syntax, indent, ftdetect)
-- [nix](https://github.com/spwhitt/vim-nix) (syntax, ftplugin, ftdetect)
+- [i3](https://github.com/mboughaba/i3config.vim) (syntax, ftplugin)
+- [idris](https://github.com/idris-hackers/idris-vim) (syntax, indent, ftplugin)
+- [ion](https://github.com/vmchale/ion-vim) (syntax, ftplugin)
+- [javascript](https://github.com/pangloss/vim-javascript) (syntax, indent, compiler, ftplugin, extras)
+- [jenkins](https://github.com/martinda/Jenkinsfile-vim-syntax) (syntax, indent)
+- [jinja](https://github.com/lepture/vim-jinja) (syntax, indent)
+- [json5](https://github.com/GutenYe/json5.vim) (syntax)
+- [json](https://github.com/elzr/vim-json) (syntax, indent, ftplugin)
+- [jst](https://github.com/briancollins/vim-jst) (syntax, indent)
+- [jsx](https://github.com/MaxMEllon/vim-jsx-pretty) (autoload, after)
+- [julia](https://github.com/JuliaEditorSupport/julia-vim) (syntax, indent, autoload, ftplugin)
+- [kotlin](https://github.com/udalov/kotlin-vim) (syntax, indent, ftplugin)
+- [latex](https://github.com/lervag/vimtex) (indent, compiler, autoload, ftplugin, syntax)
+- [less](https://github.com/groenewege/vim-less) (syntax, indent, ftplugin)
+- [lilypond](https://github.com/anowlcalledjosh/vim-lilypond) (syntax, indent, compiler, ftplugin)
+- [livescript](https://github.com/gkz/vim-ls) (syntax, indent, compiler, ftplugin)
+- [llvm](https://github.com/rhysd/vim-llvm) (syntax, indent, ftplugin)
+- [log](https://github.com/MTDL9/vim-log-highlighting) (syntax)
+- [lua](https://github.com/tbastos/vim-lua) (syntax, indent)
+- [mako](https://github.com/sophacles/vim-bundle-mako) (syntax, indent, ftplugin)
+- [markdown](https://github.com/plasticboy/vim-markdown) (syntax, indent, ftplugin)
+- [mathematica](https://github.com/voldikss/vim-mma) (syntax, ftplugin)
+- [mdx](https://github.com/jxnblk/vim-mdx-js) (syntax)
+- [meson](https://github.com/mesonbuild/meson) (syntax, indent, ftplugin)
+- [moonscript](https://github.com/leafo/moonscript-vim) (syntax, indent, ftplugin)
+- [nginx](https://github.com/chr4/nginx.vim) (syntax, indent, ftplugin)
+- [nim](https://github.com/zah/nim.vim) (syntax, compiler, indent)
+- [nix](https://github.com/LnL7/vim-nix) (syntax, indent, compiler, ftplugin)
 - [objc](https://github.com/b4winckler/vim-objc) (ftplugin, syntax, indent)
-- [ocaml](https://github.com/jrk/vim-ocaml) (syntax, indent, ftplugin)
-- [octave](https://github.com/vim-scripts/octave.vim--) (syntax)
-- [opencl](https://github.com/petRUShka/vim-opencl) (syntax, indent, ftplugin, ftdetect)
-- [perl](https://github.com/vim-perl/vim-perl) (syntax, indent, ftplugin, ftdetect)
+- [ocaml](https://github.com/rgrinberg/vim-ocaml) (syntax, indent, compiler, ftplugin)
+- [octave](https://github.com/McSinyx/vim-octave) (syntax, indent)
+- [opencl](https://github.com/petRUShka/vim-opencl) (syntax, indent, ftplugin)
+- [perl](https://github.com/vim-perl/vim-perl) (syntax, indent, ftplugin)
+- [pgsql](https://github.com/lifepillar/pgsql.vim) (syntax, indent)
 - [php](https://github.com/StanAngeloff/php.vim) (syntax)
-- [powershell](https://github.com/Persistent13/vim-ps1) (syntax, indent, ftplugin, ftdetect)
-- [protobuf](https://github.com/uarun/vim-protobuf) (syntax, ftdetect)
-- [puppet](https://github.com/rodjek/vim-puppet) (syntax, indent, ftplugin, ftdetect)
-- [python](https://github.com/mitsuhiko/vim-python-combined) (syntax, indent)
-- [qml](https://github.com/peterhoeg/vim-qml) (syntax, indent, ftplugin, ftdetect)
-- [r-lang](https://github.com/vim-scripts/R.vim) (syntax, ftplugin)
+- [plantuml](https://github.com/aklt/plantuml-syntax) (syntax, indent, ftplugin)
+- [pony](https://github.com/jakwings/vim-pony) (syntax, indent, autoload, ftplugin)
+- [powershell](https://github.com/PProvost/vim-ps1) (syntax, indent, compiler, ftplugin)
+- [protobuf](https://github.com/uarun/vim-protobuf) (syntax, indent)
+- [pug](https://github.com/digitaltoad/vim-pug) (syntax, indent, ftplugin)
+- [puppet](https://github.com/rodjek/vim-puppet) (syntax, indent, autoload, ftplugin, ctags)
+- [purescript](https://github.com/purescript-contrib/purescript-vim) (syntax, indent, ftplugin)
+- [python-compiler](https://github.com/aliev/vim-compiler-python) (compiler, autoload)
+- [python-indent](https://github.com/Vimjas/vim-python-pep8-indent) (indent)
+- [python](https://github.com/vim-python/python-syntax) (syntax)
+- [qmake](https://github.com/artoj/qmake-syntax-vim) (syntax)
+- [qml](https://github.com/peterhoeg/vim-qml) (syntax, indent, ftplugin)
+- [r-lang](https://github.com/vim-scripts/R.vim) (syntax)
+- [racket](https://github.com/wlangstroth/vim-racket) (syntax, indent, ftplugin)
 - [ragel](https://github.com/jneen/ragel.vim) (syntax)
-- [rspec](https://github.com/sheerun/rspec.vim) (syntax, ftdetect)
-- [ruby](https://github.com/vim-ruby/vim-ruby) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [rust](https://github.com/rust-lang/rust.vim) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [sbt](https://github.com/derekwyatt/vim-sbt) (syntax, ftdetect)
-- [scala](https://github.com/derekwyatt/vim-scala) (syntax, indent, compiler, ftplugin, ftdetect)
-- [slim](https://github.com/slim-template/vim-slim) (syntax, indent, ftdetect)
-- [solidity](https://github.com/ethereum/vim-solidity) (syntax, indent, ftdetect)
-- [stylus](https://github.com/wavded/vim-stylus) (syntax, indent, ftplugin, ftdetect)
-- [swift](https://github.com/keith/swift.vim) (syntax, indent, ftplugin, ftdetect)
-- [systemd](https://github.com/kurayama/systemd-vim-syntax) (syntax, ftdetect)
-- [textile](https://github.com/timcharper/textile.vim) (syntax, ftplugin, ftdetect)
-- [thrift](https://github.com/solarnz/thrift.vim) (syntax, ftdetect)
-- [tmux](https://github.com/tejr/vim-tmux) (syntax, ftdetect)
+- [raml](https://github.com/IN3D/vim-raml) (syntax, ftplugin)
+- [razor](https://github.com/adamclerk/vim-razor) (syntax, indent, ftplugin)
+- [reason](https://github.com/reasonml-editor/vim-reason-plus) (syntax, indent)
+- [rego](https://github.com/tsandall/vim-rego) (syntax)
+- [rspec](https://github.com/keith/rspec.vim) (syntax)
+- [rst](https://github.com/marshallward/vim-restructuredtext) (syntax, indent, autoload, ftplugin)
+- [ruby](https://github.com/vim-ruby/vim-ruby) (syntax, indent, compiler, autoload, ftplugin)
+- [rust](https://github.com/rust-lang/rust.vim) (syntax, indent, compiler, autoload, ftplugin, ctags)
+- [sbt](https://github.com/derekwyatt/vim-sbt) (syntax)
+- [scala](https://github.com/derekwyatt/vim-scala) (syntax, indent, compiler, ftplugin, ctags)
+- [scss](https://github.com/cakebaker/scss-syntax.vim) (syntax, indent, ftplugin)
+- [slim](https://github.com/slim-template/vim-slim) (syntax, indent, ftplugin)
+- [slime](https://github.com/slime-lang/vim-slime-syntax) (syntax, indent)
+- [smt2](https://github.com/bohlender/vim-smt2) (syntax, autoload, ftplugin)
+- [solidity](https://github.com/tomlion/vim-solidity) (syntax, indent, ftplugin)
+- [stylus](https://github.com/wavded/vim-stylus) (syntax, indent, ftplugin)
+- [svelte](https://github.com/evanleck/vim-svelte) (syntax, indent, ftplugin)
+- [svg-indent](https://github.com/jasonshell/vim-svg-indent) (indent)
+- [svg](https://github.com/vim-scripts/svg.vim) (syntax)
+- [swift](https://github.com/keith/swift.vim) (syntax, indent, compiler, ftplugin, ctags)
+- [sxhkd](https://github.com/baskerville/vim-sxhkdrc) (syntax)
+- [systemd](https://github.com/wgwoods/vim-systemd-syntax) (syntax, ftplugin)
+- [terraform](https://github.com/hashivim/vim-terraform) (syntax, indent, autoload, ftplugin)
+- [textile](https://github.com/timcharper/textile.vim) (syntax, ftplugin)
+- [thrift](https://github.com/solarnz/thrift.vim) (syntax)
+- [tmux](https://github.com/ericpruitt/tmux.vim) (syntax, ftplugin)
 - [tomdoc](https://github.com/wellbredgrapefruit/tomdoc.vim) (syntax)
-- [toml](https://github.com/cespare/vim-toml) (syntax, ftplugin, ftdetect)
-- [twig](https://github.com/beyondwords/vim-twig) (syntax, ftplugin, ftdetect)
-- [typescript](https://github.com/leafgarland/typescript-vim) (syntax, indent, compiler, ftplugin, ftdetect)
-- [vala](https://github.com/tkztmk/vim-vala) (syntax, indent, ftdetect)
+- [toml](https://github.com/cespare/vim-toml) (syntax, ftplugin)
+- [tptp](https://github.com/c-cube/vim-tptp) (syntax)
+- [twig](https://github.com/lumiliet/vim-twig) (syntax, indent, ftplugin)
+- [typescript](https://github.com/HerringtonDarkholme/yats.vim) (syntax, indent, compiler, ftplugin, ctags)
+- [v](https://github.com/ollykel/v-vim) (syntax, indent, ftplugin)
+- [vala](https://github.com/arrufat/vala.vim) (syntax, indent, ftplugin)
 - [vbnet](https://github.com/vim-scripts/vbnet.vim) (syntax)
-- [vcl](https://github.com/smerrill/vcl-vim-plugin) (syntax, ftdetect)
-- [vm](https://github.com/lepture/vim-velocity) (syntax, indent, ftdetect)
+- [vcl](https://github.com/smerrill/vcl-vim-plugin) (syntax)
+- [vifm](https://github.com/vifm/vifm.vim) (syntax, autoload, ftplugin)
+- [vm](https://github.com/lepture/vim-velocity) (syntax, indent)
+- [vue](https://github.com/posva/vim-vue) (syntax, indent, ftplugin)
+- [xdc](https://github.com/amal-khailtash/vim-xdc-syntax) (syntax)
 - [xls](https://github.com/vim-scripts/XSLT-syntax) (syntax)
+- [xml](https://github.com/amadeus/vim-xml) (syntax)
 - [yaml](https://github.com/stephpy/vim-yaml) (syntax, ftplugin)
 - [yard](https://github.com/sheerun/vim-yardoc) (syntax)
-
-## Disabling a language pack
-
-Individual language packs can be disabled by setting `g:polyglot_disabled`.
-
-```viml
-" ~/.vimrc
-let g:polyglot_disabled = ['css']
-```
-
-Note that disabiling languages won't make in general your vim startup any faster / slower (only for specific file type). Vim-polyglot is selection of language plugins that are loaded only on demand.
+- [zephir](https://github.com/xwsoul/vim-zephir) (syntax)
+- [zig](https://github.com/ziglang/zig.vim) (syntax, autoload, ftplugin)
+- [zinit](https://github.com/zinit-zsh/zplugin-vim-syntax) (syntax)
+<!--/Language Packs-->
 
 ## Updating
 
 You can either wait for new patch release with updates or run the `./build` script by yourself.
 
+## Troubleshooting
+
+Please make sure you have `syntax on` in your `.vimrc`, otherwise syntax files are not loaded at all.
+
+Individual language packs can be disabled by setting `g:polyglot_disabled` as follows:
+
+```viml
+" ~/.vimrc, declare this variable before polyglot is loaded
+let g:polyglot_disabled = ['css']
+```
+
+Note that disabling languages won't make in general your vim startup any faster / slower (only for specific file type). Vim-polyglot is selection of language plugins that are loaded only on demand.
+
 ## Contributing
 
 Language packs are periodically updated using automated `build` script.
 
-Feel free to add your language, and send pull-request.
+Feel free to add your language, and send pull-request.  In your pull request, please include:
+1. How you chose the particular repo from which to pull support for this language.
+2. An updated https://github.com/sheerun/vim-polyglot/blob/master/build .
+3. If at all possible, absolutely nothing else (in particular, please don't run `build` and include that in your PR).
+
+The easier it is to validate that the new language won't do anything wacky, the faster it'll be merged.  In particular, languages that utilize global plugins (loaded for every filetype), or plugins with dangerous features (like `call` based on the contents of a file being edited), will never be merged, as they will be slow or dangerous, respectively.
 
 ## License
 

after/ftdetect/rspec.vim

@@ -1,6 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rspec') == -1
-  
-autocmd BufReadPost,BufNewFile *_spec.rb set syntax=rspec
-autocmd BufReadPost,BufNewFile *_spec.rb setlocal commentstring=#\ %s
-
-endif

after/ftplugin/cabal.vim

@@ -1,7 +1,6 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haskell') == -1
 
 setlocal comments=s1fl:{-,mb:-,ex:-},:--
-setlocal formatoptions-=cro formatoptions+=j
 setlocal iskeyword+=-,.,*
 setlocal commentstring=--\ %s
 

after/ftplugin/haskell.vim

@@ -1,7 +1,6 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haskell') == -1
 
-setlocal comments=s1fl:{-,mb:-,ex:-},:--
-setlocal formatoptions-=cro formatoptions+=j
+setlocal comments=s1fl:{-,mb:\ \ ,ex:-},:--
 setlocal iskeyword+='
 
 endif

after/ftplugin/idris.vim

@@ -1,4 +1,5 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') == -1
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'idris') == -1
 
+setlocal iskeyword+='
 
 endif

after/ftplugin/javascript.vim

@@ -0,0 +1,51 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') == -1
+
+" Vim filetype plugin file
+" Language:     JavaScript
+" Maintainer:   vim-javascript community
+" URL:          https://github.com/pangloss/vim-javascript
+
+setlocal iskeyword+=$ suffixesadd+=.js
+
+if exists('b:undo_ftplugin')
+  let b:undo_ftplugin .= ' | setlocal iskeyword< suffixesadd<'
+else
+  let b:undo_ftplugin = 'setlocal iskeyword< suffixesadd<'
+endif
+
+endif
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Vim ftplugin file
+"
+" Language: javascript.jsx
+" Maintainer: MaxMEllon <maxmellon1994@gmail.com>
+"
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+" modified from html.vim
+" For matchit plugin
+if exists("loaded_matchit")
+  let b:match_ignorecase = 0
+  let b:match_words = '(:),\[:\],{:},<:>,' .
+        \ '<\@<=\([^/][^ \t>]*\)[^>]*\%(>\|$\):<\@<=/\1>'
+endif
+
+" For andymass/vim-matchup plugin
+if exists("loaded_matchup")
+  setlocal matchpairs=(:),{:},[:],<:>
+  let b:match_words = '<\@<=\([^/][^ \t>]*\)\g{hlend}[^>]*\%(/\@<!>\|$\):<\@<=/\1>'
+  let b:match_skip = 's:comment\|string'
+endif
+
+let b:jsx_pretty_old_cms = &l:commentstring
+
+augroup jsx_comment
+  autocmd! CursorMoved <buffer>
+  autocmd CursorMoved <buffer> call jsx_pretty#comment#update_commentstring(b:jsx_pretty_old_cms)
+augroup end
+
+setlocal suffixesadd+=.jsx
+
+endif

after/ftplugin/javascriptreact.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+source <sfile>:h/javascript.vim
+
+endif

after/ftplugin/jsx.vim

@@ -1,21 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'jsx') == -1
-  
-"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-" Vim ftplugin file
-"
-" Language: JSX (JavaScript)
-" Maintainer: Max Wang <mxawng@gmail.com>
-" Depends: pangloss/vim-javascript
-"
-"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-
-" modified from html.vim
-if exists("loaded_matchit")
-  let b:match_ignorecase = 0
-  let b:match_words = '(:),\[:\],{:},<:>,' .
-        \ '<\@<=\([^/][^ \t>]*\)[^>]*\%(>\|$\):<\@<=/\1>'
-endif
-
-setlocal suffixesadd+=.jsx
-
-endif

after/ftplugin/llvm.vim

@@ -0,0 +1,487 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'llvm') == -1
+
+" Copyright (c) 2018 rhysd
+"
+" 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.
+
+if get(g:, 'llvm_extends_official', 1) == 0
+    finish
+endif
+
+let g:llvm_ext_no_mapping = get(g:, 'llvm_ext_no_mapping', 0)
+let g:llvm_ext_lli_executable = get(g:, 'llvm_ext_lli_executable', 'lli')
+
+let s:KIND_BLOCK_PREC = 0
+let s:KIND_BLOCK_FOLLOW = 1
+let s:KIND_FUNC_BEGIN = 2
+let s:KIND_FUNC_END = 3
+
+function! s:section_delim_at(lnum) abort
+    let line = getline(a:lnum)
+    let m = matchlist(line, '^\([^:]\+\):\%( \+; preds = \(%.\+\)\)\=$')
+    if !empty(m)
+        if m[2] ==# ''
+            return [s:KIND_BLOCK_PREC, m[1]]
+        else
+            return [s:KIND_BLOCK_FOLLOW, m[1], split(m[2], ',\s*')]
+        endif
+    endif
+    if line =~# '^}$'
+        return [s:KIND_FUNC_END]
+    endif
+    if line =~# '^define\>'
+        return [s:KIND_FUNC_BEGIN]
+    endif
+    return []
+endfunction
+
+function! s:is_section_delim(line, func_delim) abort
+    let sec = s:section_delim_at(a:line)
+    if empty(sec)
+        return 0
+    endif
+    let kind = sec[0]
+    return kind == s:KIND_BLOCK_PREC || kind == s:KIND_BLOCK_FOLLOW || kind == a:func_delim
+endfunction
+
+function! s:next_section(stop_func_begin) abort
+    let func_delim = a:stop_func_begin ? s:KIND_FUNC_BEGIN : s:KIND_FUNC_END
+    let last = line('$') - 1
+    let line = line('.')
+    while line < last
+        let line += 1
+        if s:is_section_delim(line, func_delim)
+            call cursor(line, col('.'))
+            return
+        endif
+    endwhile
+endfunction
+
+function! s:prev_section(stop_func_begin) abort
+    let func_delim = a:stop_func_begin ? s:KIND_FUNC_BEGIN : s:KIND_FUNC_END
+    let line = line('.')
+    while line > 1
+        let line -= 1
+        if s:is_section_delim(line, func_delim)
+            call cursor(line, col('.'))
+            return
+        endif
+    endwhile
+endfunction
+
+nnoremap <buffer><Plug>(llvm-next-section-begin) :<C-u>call <SID>next_section(1)<CR>
+nnoremap <buffer><Plug>(llvm-prev-section-begin) :<C-u>call <SID>prev_section(1)<CR>
+nnoremap <buffer><Plug>(llvm-next-section-end) :<C-u>call <SID>next_section(0)<CR>
+nnoremap <buffer><Plug>(llvm-prev-section-end) :<C-u>call <SID>prev_section(0)<CR>
+
+if !g:llvm_ext_no_mapping
+    nmap <buffer><silent>]] <Plug>(llvm-next-section-begin)
+    nmap <buffer><silent>[[ <Plug>(llvm-prev-section-begin)
+    nmap <buffer><silent>][ <Plug>(llvm-next-section-end)
+    nmap <buffer><silent>[] <Plug>(llvm-prev-section-end)
+endif
+
+function! s:function_range_at(linum) abort
+    let line = a:linum
+    while line >= 1
+        let s = getline(line)
+        if s =~# '^define\>'
+            let start = line
+            break
+        elseif s =~# '^}$'
+            return []
+        endif
+        let line -= 1
+    endwhile
+    if line < 1
+        return []
+    endif
+
+    let line = a:linum
+    let last = line('$')
+    while line <= last
+        let s = getline(line)
+        if s =~# '^}$'
+            let end = line
+            break
+        elseif s =~# '^define\>'
+            return []
+        endif
+        let line += 1
+    endwhile
+    if line > last
+        return []
+    endif
+
+    return [start, end]
+endfunction
+
+function! s:blocks_graph_at(linum) abort
+    let func_range = s:function_range_at(a:linum)
+    if empty(func_range)
+        return {}
+    endif
+    let line = func_range[0] + 1
+    let last = func_range[1] - 1
+    let graph = {}
+    while line <= last
+        let block = s:section_delim_at(line)
+        if empty(block)
+            let line += 1
+            continue
+        endif
+        let block_name = '%' . block[1]
+        if block[0] == s:KIND_BLOCK_PREC
+            let graph[block_name] = {'line': line, 'follows': [], 'preds': []}
+        elseif block[0] == s:KIND_BLOCK_FOLLOW
+            let graph[block_name] = {'line': line, 'follows': [], 'preds': block[2]}
+            for follow in block[2]
+                call add(graph[follow].follows, block_name)
+            endfor
+        else
+            echoerr 'unreachable'
+        endif
+        let line += 1
+    endwhile
+    return graph
+endfunction
+
+function! s:find_pred_block(linum) abort
+    let sec = s:section_delim_at(a:linum)
+    if empty(sec) || sec[0] != s:KIND_BLOCK_PREC && sec[0] != s:KIND_BLOCK_FOLLOW
+        throw 'No block is starting at line ' . a:linum
+    endif
+    if sec[0] != s:KIND_BLOCK_FOLLOW
+        throw printf("Block '%s' has no pred block", sec[1])
+    endif
+    let block_name = '%' . sec[1]
+    let pred_block = sec[2][0]
+
+    let graph = s:blocks_graph_at(a:linum)
+    if empty(graph)
+        throw 'No block is found in function at line ' . a:linum
+    endif
+
+    if !has_key(graph, pred_block)
+        throw printf("Block '%s' (pred block of '%s') not found in function", pred_block, block_name)
+    endif
+    return graph[pred_block]
+endfunction
+
+function! s:move_to_pred_block() abort
+    try
+        let b = s:find_pred_block(line('.'))
+        call cursor(b.line, col('.'))
+    catch
+        echohl ErrorMsg | echom v:exception | echohl None
+    endtry
+endfunction
+
+function! s:find_following_block(linum) abort
+    let sec = s:section_delim_at(a:linum)
+    if empty(sec) || sec[0] != s:KIND_BLOCK_PREC && sec[0] != s:KIND_BLOCK_FOLLOW
+        throw 'No block is starting at line ' . a:linum
+    endif
+    let block_name = '%' . sec[1]
+
+    let graph = s:blocks_graph_at(a:linum)
+    if empty(graph)
+        throw 'No block is found in function at line ' . a:linum
+    endif
+
+    let follows = graph[block_name].follows
+    if empty(follows)
+        throw printf("Block '%s' has no following block", block_name)
+    endif
+
+    echom printf("Block '%s' has %d following blocks: %s", block_name, len(follows), join(follows, ', '))
+
+    if !has_key(graph, follows[0])
+        throw printf("Block '%s' is not defined in function at line %d", follows[0], a:linum)
+    endif
+    return graph[follows[0]]
+endfunction
+
+function! s:move_to_following_block() abort
+    try
+        let b = s:find_following_block(line('.'))
+        call cursor(b.line, col('.'))
+    catch
+        echohl ErrorMsg | echom v:exception | echohl None
+    endtry
+endfunction
+
+nnoremap <buffer><Plug>(llvm-move-block-prev) :<C-u>call <SID>move_to_pred_block()<CR>
+nnoremap <buffer><Plug>(llvm-move-block-next) :<C-u>call <SID>move_to_following_block()<CR>
+
+if !g:llvm_ext_no_mapping
+    nmap <buffer><silent>[b <Plug>(llvm-move-block-prev)
+    nmap <buffer><silent>]b <Plug>(llvm-move-block-next)
+endif
+
+function! s:get_func_identifiers(line) abort
+    let idx = stridx(a:line, '@')
+    if idx == -1
+        " Invalid signature
+        return []
+    endif
+
+    " e.g. define internal i32 @foo(...) { -> @foo(...) {
+    let sig = a:line[idx:]
+
+    let idx = stridx(sig, '(')
+    if idx == -1
+        " Invalid signature
+        return []
+    endif
+
+    " @foo(...) { -> @foo
+    let idents = [sig[:idx-1]]
+
+    " @foo(...) { -> ...) {
+    let params = sig[idx+1:]
+
+    let idx = strridx(sig, ')')
+    if idx == -1
+        return idents
+    endif
+
+    " ...) { -> ...
+    let params = params[:idx-1]
+
+    " Gather parameters in function signature
+    while params !=# ''
+        let m = matchlist(params, '^[^%]*\(%\%("[^"]\+"\|[[:alnum:]_.]\+\)\)\s*\(.*\)$')
+        if empty(m)
+            break
+        endif
+        let idents += [m[1]]
+        let params = m[2]
+    endwhile
+
+    return idents
+endfunction
+
+function! s:get_identifiers(line) abort
+    " Registers and type defs
+    let m = matchlist(a:line, '^\s*\(%\S\+\)\s\+=')
+    if !empty(m)
+        return [m[1]]
+    endif
+
+    " Constants
+    let m = matchlist(a:line, '^\(@\S\+\)\s\+=.\+\<constant\>')
+    if !empty(m)
+        return [m[1]]
+    endif
+
+    " Labels for basic blocks
+    let m = matchlist(a:line, '^\([^:]\+\):\%(\s\+; preds = .\+\)\=$')
+    if !empty(m)
+        return ['%' . m[1]]
+    endif
+
+    " Meta variables
+    let m = matchlist(a:line, '^\(!\S\+\)\s\+=')
+    if !empty(m)
+        return [m[1]]
+    endif
+
+    " Attributes
+    let m = matchlist(a:line, '^attributes\s\+\(#\d\+\)\s\+=')
+    if !empty(m)
+        return [m[1]]
+    endif
+
+    if a:line =~# '^\%(declare\|define\)\>'
+        return s:get_func_identifiers(a:line)
+    endif
+
+    return []
+endfunction
+
+function! s:extract_identifier(word) abort
+    if strlen(a:word) <= 1
+        return ''
+    endif
+
+    let prefix = a:word[0]
+    if prefix ==# '@' || prefix ==# '%' || prefix ==# '!'
+        if prefix ==# '!' && a:word[1] ==# '{'
+            return ''
+        endif
+
+        if a:word[1] == '"'
+            let idx = stridx(a:word, '"', 2)
+            if idx == -1
+                return ''
+            endif
+            " @"foo" or %"foo"
+            return a:word[:idx]
+        else
+            " @foo or %foo
+            return matchstr(a:word, '^[@%!][[:alnum:]_.]\+')
+        endif
+    endif
+
+    if prefix ==# '#'
+        return matchstr(a:word, '^#\d\+')
+    endif
+
+    return ''
+endfunction
+
+function! s:jump_to_identifier_at(linum, ident) abort
+    let line = getline(a:linum)
+    let column = stridx(line, a:ident) + 1
+    if column == 0
+        let column = col('.')
+    endif
+    call cursor(a:linum, column)
+endfunction
+
+function! s:browser_open_command() abort
+    if exists('g:llvm_ext_browser_open_command')
+        return g:llvm_ext_browser_open_command
+    endif
+    if exists('s:browser_opener')
+        return s:browser_opener
+    endif
+    let s:browser_opener = ''
+    if has('mac')
+        let s:browser_opener = 'open'
+    elseif has('win32') || has('win64')
+        let s:browser_opener =  'cmd /q /c start ""'
+    else
+        for cmd in ['xdg-open', 'chromium', 'google-chrome', 'firefox']
+            if executable(cmd)
+                let s:browser_opener = cmd
+                break
+            endif
+        endfor
+    endif
+    return s:browser_opener
+endfunction
+
+function! s:open_browser(url) abort
+    let cmd = s:browser_open_command()
+    if cmd ==# ''
+        throw "Failed to open a browser. I don't know how to open a browser: Please set g:llvm_ext_browser_open_command"
+    endif
+    let cmdline = cmd . ' ' . shellescape(a:url)
+    let out = system(cmdline)
+    if v:shell_error
+        throw printf("Failed to open a browser with command '%s': %s", cmdline, out)
+    endif
+endfunction
+
+function! s:goto_definition() abort
+    " Open language reference manual under the cursor in browser
+    let syn_name = synIDattr(synID(line('.'),col('.'),1),'name')
+    if syn_name ==# 'llvmStatement'
+        let word = expand('<cword>')
+        if word !=# ''
+            try
+                " Open browser assuming a word under the cursor is an instruction
+                call s:open_browser('https://llvm.org/docs/LangRef.html#' . word . '-instruction')
+            catch /^Failed to open a browser/
+                echohl ErrorMsg | echom v:exception | echohl None
+            endtry
+        endif
+        return
+    endif
+
+    " XXX: This does not support identifiers which contains spaces
+    let word = expand('<cWORD>')
+    if word ==# ''
+        echom 'No identifier found under the cursor'
+        return
+    endif
+    let ident = s:extract_identifier(word)
+    if ident ==# ''
+        echom 'No identifier found under the cursor'
+        return
+    endif
+
+    " Definition tends to be near its usages. Look back at first.
+    let line = line('.')
+    while line > 0
+        for found in s:get_identifiers(getline(line))
+            if ident ==# found
+                call s:jump_to_identifier_at(line, ident)
+                return
+            endif
+        endfor
+        let line -= 1
+    endwhile
+
+    let line = line('.') + 1
+    let last = line('$')
+    while line <= last
+        for found in s:get_identifiers(getline(line))
+            if ident ==# found
+                call s:jump_to_identifier_at(line, ident)
+                return
+            endif
+        endfor
+        let line += 1
+    endwhile
+
+    echom "No definition for '" . ident . "' found"
+endfunction
+
+nnoremap <buffer><Plug>(llvm-goto-definition) :<C-u>call <SID>goto_definition()<CR>
+
+if !g:llvm_ext_no_mapping
+    nmap <buffer><silent>K <Plug>(llvm-goto-definition)
+endif
+
+function! s:run_lli(...) abort
+    if !has('job') || !has('channel') || !has('terminal')
+        echohl ErrorMsg
+        echomsg ':LLI requires terminal feature. Please update your Vim to 8.0+'
+        echohl None
+        return
+    endif
+
+    if !executable(g:llvm_ext_lli_executable)
+        echohl ErrorMsg
+        echomsg g:llvm_ext_lli_executable . ' is not executable. Please set g:llvm_ext_lli_executable'
+        echohl None
+        return
+    endif
+
+    if a:0 > 0
+        let bufnr = term_start([g:llvm_ext_lli_executable, a:1])
+        echo 'Run lli in termnal buffer(' . bufnr . ')'
+        return
+    endif
+
+    let tmpfile = tempname()
+    call writefile(getline(1, '$'), tmpfile)
+    let Cleanup = {ch -> filereadable(tmpfile) ? delete(tmpfile) : 0}
+    let bufnr = term_start([g:llvm_ext_lli_executable, tmpfile], {'close_cb': Cleanup, 'exit_cb': Cleanup})
+    echo 'Run lli in termnal buffer(' . bufnr . ')'
+endfunction
+
+if !exists(':LLI')
+    command! -buffer -nargs=? -bar -complete=file LLI call <SID>run_lli(<f-args>)
+endif
+
+endif

after/ftplugin/puppet.vim

@@ -4,17 +4,8 @@ if !exists('g:puppet_align_hashes')
     let g:puppet_align_hashes = 1
 endif
 
-if g:puppet_align_hashes && exists(':Tabularize')
-    inoremap <buffer> <silent> > ><Esc>:call <SID>puppetalign()<CR>a
-    function! s:puppetalign()
-        let p = '^\s*\w+\s*[=+]>.*$'
-        let column = strlen(substitute(getline('.')[0:col('.')],'\([^=]\|=[^>]\)','','g'))
-        let position = strlen(matchstr(getline('.')[0:col('.')],'.*=>\s*\zs.*'))
-        Tabularize /=>/l1
-        normal! 0
-        echo repeat('\([^=]\|=[^>]\)*=>',column).'\s\{-\}'.repeat('.',position)
-        call search(repeat('\([^=]\|=[^>]\)*=>',column).'\s\{-\}'.repeat('.',position),'ce',line('.'))
-    endfunction
+if g:puppet_align_hashes
+    inoremap <buffer> <silent> => =><Esc>:call puppet#align#AlignHashrockets()<CR>$a
 endif
 
 endif

after/ftplugin/tex.vim

@@ -0,0 +1,20 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+if !get(g:, 'vimtex_enabled', 1)
+  finish
+endif
+
+if exists('b:did_ftplugin_vimtex')
+  finish
+endif
+let b:did_ftplugin_vimtex = 1
+
+call vimtex#check_plugin_clash()
+
+endif

after/ftplugin/tsx.vim

@@ -0,0 +1,32 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+" modified from html.vim
+" For matchit plugin
+
+if get(g:, 'vim_jsx_pretty_disable_tsx', 0)
+  finish
+endif
+
+if exists("loaded_matchit")
+  let b:match_ignorecase = 0
+  let b:match_words = '(:),\[:\],{:},<:>,' .
+        \ '<\@<=\([^/][^ \t>]*\)[^>]*\%(>\|$\):<\@<=/\1>'
+endif
+
+" For andymass/vim-matchup plugin
+if exists("loaded_matchup")
+  setlocal matchpairs=(:),{:},[:],<:>
+  let b:match_words = '<\@<=\([^/][^ \t>]*\)\g{hlend}[^>]*\%(/\@<!>\|$\):<\@<=/\1>'
+  let b:match_skip = 's:comment\|string'
+endif
+
+let b:jsx_pretty_old_cms = &l:commentstring
+
+augroup jsx_comment
+  autocmd! CursorMoved <buffer>
+  autocmd CursorMoved <buffer> call jsx_pretty#comment#update_commentstring(b:jsx_pretty_old_cms)
+augroup end
+
+setlocal suffixesadd+=.tsx
+
+endif

after/ftplugin/typescriptreact.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+source <sfile>:h/tsx.vim
+
+endif

after/indent/html.vim

@@ -1,37 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'coffee-script') == -1
-  
-" Language:    CoffeeScript
-" Maintainer:  Mick Koch <mick@kochm.co>
-" URL:         http://github.com/kchmck/vim-coffee-script
-" License:     WTFPL
-
-" Load the coffee and html indent functions.
-silent! unlet b:did_indent
-runtime indent/coffee.vim
-let s:coffeeIndentExpr = &l:indentexpr
-
-" Load html last so it can overwrite coffee settings.
-silent! unlet b:did_indent
-runtime indent/html.vim
-let s:htmlIndentExpr = &l:indentexpr
-
-" Inject our wrapper indent function.
-setlocal indentexpr=GetCoffeeHtmlIndent(v:lnum)
-
-function! GetCoffeeHtmlIndent(curlinenum)
-  " See if we're inside a coffeescript block.
-  let scriptlnum = searchpair('<script [^>]*type="text/coffeescript"[^>]*>', '',
-  \                           '</script>', 'bWn')
-  let prevlnum = prevnonblank(a:curlinenum)
-
-  " If we're in the script block and the previous line isn't the script tag
-  " itself, use coffee indenting.
-  if scriptlnum && scriptlnum != prevlnum
-    exec 'return ' s:coffeeIndentExpr
-  endif
-
-  " Otherwise use html indenting.
-  exec 'return ' s:htmlIndentExpr
-endfunction
-
-endif

after/indent/javascript.vim

@@ -0,0 +1,33 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Vim indent file
+"
+" Language: javascript.jsx
+" Maintainer: MaxMellon <maxmellon1994@gmail.com>
+"
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+if exists('b:did_indent')
+  let s:did_indent = b:did_indent
+  unlet b:did_indent
+endif
+
+let s:keepcpo = &cpo
+set cpo&vim
+
+if exists('s:did_indent')
+  let b:did_indent = s:did_indent
+endif
+
+setlocal indentexpr=GetJsxIndent()
+setlocal indentkeys=0.,0{,0},0),0],0?,0\*,0\,,!^F,:,<:>,o,O,e,<>>,=*/
+
+function! GetJsxIndent()
+  return jsx_pretty#indent#get(function('GetJavascriptIndent'))
+endfunction
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+endif

after/indent/javascriptreact.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+source <sfile>:h/javascript.vim
+
+endif

after/indent/jsx.vim

@@ -1,95 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'jsx') == -1
-  
-"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-" Vim indent file
-"
-" Language: JSX (JavaScript)
-" Maintainer: Max Wang <mxawng@gmail.com>
-" Depends: pangloss/vim-javascript
-"
-"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-
-" Prologue; load in XML indentation.
-if exists('b:did_indent')
-  let s:did_indent=b:did_indent
-  unlet b:did_indent
-endif
-exe 'runtime! indent/xml.vim'
-if exists('s:did_indent')
-  let b:did_indent=s:did_indent
-endif
-
-setlocal indentexpr=GetJsxIndent()
-
-" JS indentkeys
-setlocal indentkeys=0{,0},0),0],0\,,!^F,o,O,e
-" XML indentkeys
-setlocal indentkeys+=*<Return>,<>>,<<>,/
-
-" Self-closing tag regex.
-let s:sctag = '^\s*\/>\s*;\='
-
-" Get all syntax types at the beginning of a given line.
-fu! SynSOL(lnum)
-  return map(synstack(a:lnum, 1), 'synIDattr(v:val, "name")')
-endfu
-
-" Get all syntax types at the end of a given line.
-fu! SynEOL(lnum)
-  let lnum = prevnonblank(a:lnum)
-  let col = strlen(getline(lnum))
-  return map(synstack(lnum, col), 'synIDattr(v:val, "name")')
-endfu
-
-" Check if a syntax attribute is XMLish.
-fu! SynAttrXMLish(synattr)
-  return a:synattr =~ "^xml" || a:synattr =~ "^jsx"
-endfu
-
-" Check if a synstack is XMLish (i.e., has an XMLish last attribute).
-fu! SynXMLish(syns)
-  return SynAttrXMLish(get(a:syns, -1))
-endfu
-
-" Check if a synstack has any XMLish attribute.
-fu! SynXMLishAny(syns)
-  for synattr in a:syns
-    if SynAttrXMLish(synattr)
-      return 1
-    endif
-  endfor
-  return 0
-endfu
-
-" Check if a synstack denotes the end of a JSX block.
-fu! SynJSXBlockEnd(syns)
-  return get(a:syns, -1) == 'jsBraces' && SynAttrXMLish(get(a:syns, -2))
-endfu
-
-" Cleverly mix JS and XML indentation.
-fu! GetJsxIndent()
-  let cursyn  = SynSOL(v:lnum)
-  let prevsyn = SynEOL(v:lnum - 1)
-
-  " Use XML indenting if the syntax at the end of the previous line was either
-  " JSX or was the closing brace of a jsBlock whose parent syntax was JSX.
-  if (SynXMLish(prevsyn) || SynJSXBlockEnd(prevsyn)) && SynXMLishAny(cursyn)
-    let ind = XmlIndentGet(v:lnum, 0)
-
-    " Align '/>' with '<' for multiline self-closing tags.
-    if getline(v:lnum) =~? s:sctag
-      let ind = ind - &sw
-    endif
-
-    " Then correct the indentation of any JSX following '/>'.
-    if getline(v:lnum - 1) =~? s:sctag
-      let ind = ind + &sw
-    endif
-  else
-    let ind = GetJavascriptIndent()
-  endif
-
-  return ind
-endfu
-
-endif

after/indent/tsx.vim

@@ -0,0 +1,40 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Vim indent file
+"
+" Language: typescript.jsx
+" Maintainer: MaxMellon <maxmellon1994@gmail.com>
+" Depends: leafgarland/typescript-vim
+"
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+if get(g:, 'vim_jsx_pretty_disable_tsx', 0)
+  finish
+endif
+
+if exists('b:did_indent')
+  let s:did_indent = b:did_indent
+  unlet b:did_indent
+endif
+
+let s:keepcpo = &cpo
+set cpo&vim
+
+if exists('s:did_indent')
+  let b:did_indent = s:did_indent
+endif
+
+runtime! indent/typescript.vim
+
+setlocal indentexpr=GetJsxIndent()
+setlocal indentkeys=0.,0{,0},0),0],0?,0\*,0\,,!^F,:,<:>,o,O,e,<>>,=*/
+
+function! GetJsxIndent()
+  return jsx_pretty#indent#get(function('GetTypescriptIndent'))
+endfunction
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+endif

after/indent/typescriptreact.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+source <sfile>:h/tsx.vim
+
+endif

after/syntax/c.vim

@@ -20,9 +20,34 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'c++11') == -1
 " -----------------------------------------------------------------------------
 "  Highlight function names.
 " -----------------------------------------------------------------------------
-syn match    cCustomParen    "(" contains=cParen contains=cCppParen
-syn match    cCustomFunc     "\w\+\s*(\@=" contains=cCustomParen
-hi def link cCustomFunc  Function
+if !exists('g:cpp_no_function_highlight')
+    syn match    cCustomParen    transparent "(" contains=cParen contains=cCppParen
+    syn match    cCustomFunc     "\w\+\s*(\@=" contains=cCustomParen
+    hi def link cCustomFunc  Function
+endif
+
+" -----------------------------------------------------------------------------
+"  Highlight member variable names.
+" -----------------------------------------------------------------------------
+if exists('g:cpp_member_variable_highlight') && g:cpp_member_variable_highlight
+    syn match   cCustomDot    "\." contained
+    syn match   cCustomPtr    "->" contained
+    syn match   cCustomMemVar "\(\.\|->\)\h\w*" contains=cCustomDot,cCustomPtr
+    hi def link cCustomMemVar Function
+endif
+
+" -----------------------------------------------------------------------------
+"  Highlight POSIX functions.
+" -----------------------------------------------------------------------------
+if exists('g:cpp_posix_standard') && g:cpp_posix_standard
+	syn keyword cPOSIXFunction 	socket accept bind connect getsockname
+	syn keyword cPOSIXFunction 	listen recv recvfrom recvmsg
+	syn keyword cPOSIXFunction 	send sendto sendmsg setsockopt socketpair
+	syn keyword cPOSIXFunction 	htonl htons ntohl ntohs
+	syn keyword cPOSIXFunction 	inet_ntop inet_pton getaddrinfo
+	syn keyword cPOSIXFunction 	poll select pselect
+	hi def link cPOSIXFunction Function
+endif
 
 " -----------------------------------------------------------------------------
 "  Source: aftersyntaxc.vim

after/syntax/haml.vim

@@ -1,17 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'coffee-script') == -1
-  
-" Language:    CoffeeScript
-" Maintainer:  Sven Felix Oberquelle <Svelix.Github@gmail.com>
-" URL:         http://github.com/kchmck/vim-coffee-script
-" License:     WTFPL
-
-" Inherit coffee from html so coffeeComment isn't redefined and given higher
-" priority than hamlInterpolation.
-syn cluster hamlCoffeescript contains=@htmlCoffeeScript
-syn region  hamlCoffeescriptFilter matchgroup=hamlFilter
-\                                  start="^\z(\s*\):coffee\z(script\)\?\s*$"
-\                                  end="^\%(\z1 \| *$\)\@!"
-\                                  contains=@hamlCoffeeScript,hamlInterpolation
-\                                  keepend
-
-endif

after/syntax/haskell.vim

@@ -0,0 +1,17 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'dhall') == -1
+
+" store and remove current syntax value
+let old_syntax = b:current_syntax
+unlet b:current_syntax
+
+syn include @dhall syntax/dhall.vim
+unlet b:current_syntax
+
+syn region dhallBlock matchgroup=quasiQuote start=/\[\$\?staticDhallExpression|/       end=/|\]/ contains=@dhall
+
+hi def link quasiQuote Underlined
+
+" restore current syntax value
+let b:current_syntax = old_syntax
+
+endif

after/syntax/html.vim

@@ -1,58 +1,16 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'coffee-script') == -1
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'html5') == -1
 
-" Language:    CoffeeScript
-" Maintainer:  Mick Koch <mick@kochm.co>
-" URL:         http://github.com/kchmck/vim-coffee-script
-" License:     WTFPL
+" Vim syntax file
+" Language:     HTML (version 5.1)
+" Last Change:  2017 Feb 15
+" License:      Public domain
+"               (but let me know if you like :) )
+"
+" Maintainer:   Kao, Wei-Ko(othree) ( othree AT gmail DOT com )
 
-" Syntax highlighting for text/coffeescript script tags
-syn include @htmlCoffeeScript syntax/coffee.vim
-syn region coffeeScript start=#<script [^>]*type="text/coffeescript"[^>]*>#
-\                       end=#</script>#me=s-1 keepend
-\                       contains=@htmlCoffeeScript,htmlScriptTag,@htmlPreproc
-\                       containedin=htmlHead
-
-endif
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'glsl') == -1
-  
-" Language: OpenGL Shading Language
-" Maintainer: Sergey Tikhomirov <sergey@tikhomirov.io>
-
-syn include @GLSL syntax/glsl.vim
-syn region ShaderScript
-      \ start="<script [^>]*type=\('\|\"\)x-shader/x-\(vertex\|fragment\)\('\|\"\)[^>]*>"
-      \ keepend
-      \ end="</script>"me=s-1
-      \ contains=@GLSL,htmlScriptTag,@htmlPreproc
-
-endif
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'less') == -1
-  
-if !exists("g:less_html_style_tags")
-  let g:less_html_style_tags = 1
-endif
-
-if !g:less_html_style_tags
-  finish
-endif
-
-" Unset (but preserve) so that less will run.
-if exists("b:current_syntax")
-   let s:pre_less_cur_syn = b:current_syntax
-   unlet b:current_syntax
-endif
-
-" Inspired by code from github.com/kchmck/vim-coffee-script
-" and the html syntax file included with vim 7.4.
-
-syn include @htmlLess syntax/less.vim
-
-" We have to explicitly add to htmlHead (containedin) as that region specifies 'contains'.
-syn region lessStyle start=+<style [^>]*type *=[^>]*text/less[^>]*>+ keepend end=+</style>+ contains=@htmlLess,htmlTag,htmlEndTag,htmlCssStyleComment,@htmlPreproc containedin=htmlHead
-
-" Reset since 'less' isn't really the current_syntax.
-if exists("s:pre_less_cur_syn")
-   let b:current_syntax = s:pre_less_cur_syn
-endif
+" Comment
+" https://github.com/w3c/html/issues/694
+syntax region htmlComment start=+<!--+ end=+-->+ contains=@Spell
+syntax region htmlComment start=+<!DOCTYPE+ keepend end=+>+
 
 endif

after/syntax/idris.vim

@@ -0,0 +1,82 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'idris') == -1
+
+" This script allows for unicode concealing of certain characters
+" For instance -> goes to →
+"
+" It needs vim >= 7.3, set nocompatible, set enc=utf-8
+"
+" If you want to turn this on, let g:idris_conceal = 1
+
+if !exists('g:idris_conceal') || !has('conceal') || &enc != 'utf-8'
+    finish
+endif
+
+" vim: set fenc=utf-8:
+syntax match idrNiceOperator "\\\ze[[:alpha:][:space:]_([]" conceal cchar=λ
+syntax match idrNiceOperator "<-" conceal cchar=←
+syntax match idrNiceOperator "->" conceal cchar=→
+syntax match idrNiceOperator "\<sum\>" conceal cchar=∑
+syntax match idrNiceOperator "\<product\>" conceal cchar=∏
+syntax match idrNiceOperator "\<sqrt\>" conceal cchar=√
+syntax match idrNiceOperator "\<pi\>" conceal cchar=π
+syntax match idrNiceOperator "==" conceal cchar=≡
+syntax match idrNiceOperator "\/=" conceal cchar=≠
+
+
+let s:extraConceal = 1
+
+let s:doubleArrow = 1
+" Set this to 0 to use the more technically correct arrow from bar
+
+" Some windows font don't support some of the characters,
+" so if they are the main font, we don't load them :)
+if has("win32")
+    let s:incompleteFont = [ 'Consolas'
+                        \ , 'Lucida Console'
+                        \ , 'Courier New'
+                        \ ]
+    let s:mainfont = substitute( &guifont, '^\([^:,]\+\).*', '\1', '')
+    for s:fontName in s:incompleteFont
+        if s:mainfont ==? s:fontName
+            let s:extraConceal = 0
+            break
+        endif
+    endfor
+endif
+
+if s:extraConceal
+    syntax match idrNiceOperator "Void" conceal cchar=⊥
+
+    " Match greater than and lower than w/o messing with Kleisli composition
+    syntax match idrNiceOperator "<=\ze[^<]" conceal cchar=≤
+    syntax match idrNiceOperator ">=\ze[^>]" conceal cchar=≥
+
+    if s:doubleArrow
+      syntax match idrNiceOperator "=>" conceal cchar=⇒
+    else
+      syntax match idrNiceOperator "=>" conceal cchar=↦
+    endif
+
+    syntax match idrNiceOperator "=\zs<<" conceal cchar=«
+
+    syntax match idrNiceOperator "++" conceal cchar=⧺
+    syntax match idrNiceOperator "::" conceal cchar=∷
+    syntax match idrNiceOperator "-<" conceal cchar=↢
+    syntax match idrNiceOperator ">-" conceal cchar=↣
+    syntax match idrNiceOperator "-<<" conceal cchar=⤛
+    syntax match idrNiceOperator ">>-" conceal cchar=⤜
+
+    " Only replace the dot, avoid taking spaces around.
+    syntax match idrNiceOperator /\s\.\s/ms=s+1,me=e-1 conceal cchar=∘
+    syntax match idrNiceOperator "\.\." conceal cchar=‥
+
+    syntax match idrNiceOperator "`elem`" conceal cchar=∈
+    syntax match idrNiceOperator "`notElem`" conceal cchar=∉
+endif
+
+hi link idrNiceOperator Operator
+hi! link Conceal Operator
+setlocal conceallevel=2
+
+
+endif

after/syntax/javascript.vim

@@ -0,0 +1,59 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Vim syntax file
+"
+" Language: javascript.jsx
+" Maintainer: MaxMellon <maxmellon1994@gmail.com>
+"
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+let s:jsx_cpo = &cpo
+set cpo&vim
+
+syntax case match
+
+if exists('b:current_syntax')
+  let s:current_syntax = b:current_syntax
+  unlet b:current_syntax
+endif
+
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+if hlexists("jsDebugger") || hlexists("jsNoise")    " yuezk/vim-js or pangloss/vim-javascript
+  syntax cluster jsExpression add=jsxRegion
+elseif hlexists("javascriptOpSymbols")    " othree/yajs.vim
+  " refine the javascript line comment
+  syntax region javascriptLineComment start=+//+ end=/$/ contains=@Spell,javascriptCommentTodo extend keepend
+  syntax cluster javascriptValue add=jsxRegion
+  syntax cluster javascriptNoReserved add=jsxElement,jsxTag
+else    " build-in javascript syntax
+  " refine the javascript line comment
+  syntax region javaScriptLineComment start=+//+ end=/$/ contains=@Spell,javascriptCommentTodo extend keepend
+
+  " refine the template string syntax
+  syntax region javaScriptEmbed matchgroup=javaScriptEmbedBraces start=+\${+ end=+}+ contained contains=@javaScriptEmbededExpr
+
+  " add a javaScriptBlock group for build-in syntax
+  syntax region javaScriptBlock
+        \ matchgroup=javaScriptBraces
+        \ start="{"
+        \ end="}"
+        \ contained
+        \ extend
+        \ contains=javaScriptBlock,@javaScriptEmbededExpr,javaScript.*
+        \ fold
+
+  syntax cluster javaScriptEmbededExpr add=jsxRegion,javaScript.*
+endif
+
+runtime syntax/jsx_pretty.vim
+
+let b:current_syntax = 'javascript.jsx'
+
+let &cpo = s:jsx_cpo
+unlet s:jsx_cpo
+
+endif

after/syntax/javascript/graphql.vim

@@ -0,0 +1,64 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+
+" Copyright (c) 2016-2020 Jon Parise <jon@indelible.org>
+"
+" 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.
+"
+" Language: GraphQL
+" Maintainer: Jon Parise <jon@indelible.org>
+
+if exists('b:current_syntax')
+  let s:current_syntax = b:current_syntax
+  unlet b:current_syntax
+endif
+syn include @GraphQLSyntax syntax/graphql.vim
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+let s:tags = '\%(' . join(graphql#javascript_tags(), '\|') . '\)'
+
+if graphql#has_syntax_group('jsTemplateExpression')
+  " pangloss/vim-javascript
+  exec 'syntax region graphqlTemplateString start=+' . s:tags . '\@20<=`+ skip=+\\\\\|\\`+ end=+`+ contains=@GraphQLSyntax,jsTemplateExpression,jsSpecial extend'
+  exec 'syntax match graphqlTaggedTemplate +' . s:tags . '\ze`+ nextgroup=graphqlTemplateString'
+  syntax region graphqlTemplateExpression start=+${+ end=+}+ contained contains=jsTemplateExpression containedin=graphqlFold keepend
+
+  hi def link graphqlTemplateString jsTemplateString
+  hi def link graphqlTaggedTemplate jsTaggedTemplate
+  hi def link graphqlTemplateExpression jsTemplateExpression
+
+  syn cluster jsExpression add=graphqlTaggedTemplate
+  syn cluster graphqlTaggedTemplate add=graphqlTemplateString
+elseif graphql#has_syntax_group('javaScriptStringT')
+  " runtime/syntax/javascript.vim
+  exec 'syntax region graphqlTemplateString start=+' . s:tags . '\@20<=`+ skip=+\\\\\|\\`+ end=+`+ contains=@GraphQLSyntax,javaScriptSpecial,javaScriptEmbed,@htmlPreproc extend'
+  exec 'syntax match graphqlTaggedTemplate +' . s:tags . '\ze`+ nextgroup=graphqlTemplateString'
+  syntax region graphqlTemplateExpression start=+${+ end=+}+ contained contains=@javaScriptEmbededExpr containedin=graphqlFold keepend
+
+  hi def link graphqlTemplateString javaScriptStringT
+  hi def link graphqlTaggedTemplate javaScriptEmbed
+  hi def link graphqlTemplateExpression javaScriptEmbed
+
+  syn cluster htmlJavaScript add=graphqlTaggedTemplate
+  syn cluster javaScriptEmbededExpr add=graphqlTaggedTemplate
+  syn cluster graphqlTaggedTemplate add=graphqlTemplateString
+endif
+
+endif

after/syntax/javascriptreact.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+source <sfile>:h/javascript.vim
+
+endif

after/syntax/javascriptreact/graphql.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+
+runtime! after/syntax/javascript/graphql.vim
+
+endif

after/syntax/jsx_pretty.vim

@@ -0,0 +1,225 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+let s:highlight_close_tag = get(g:, 'vim_jsx_pretty_highlight_close_tag', 0)
+
+" detect jsx region
+syntax region jsxRegion
+      \ start=+\%(\%(\_[([,?:=+\-*/>{}]\|<\s\+\|&&\|||\|=>\|\<return\|\<default\|\<await\|\<yield\)\_s*\)\@<=<\_s*\%(>\|\z(\%(script\|T\s*>\s*(\)\@!\<[_$A-Za-z][-:._$A-Za-z0-9]*\>\)\%(\_s*\%([-+*)\]}&|?,]\|/\%([/*]\|\_s*>\)\@!\)\)\@!\)+
+      \ end=++
+      \ contains=jsxElement
+
+" <tag id="sample">
+" ~~~~~~~~~~~~~~~~~
+" and self close tag
+" <tag id="sample"   />
+" ~~~~~~~~~~~~~~~~~~~
+syntax region jsxTag
+      \ start=+<+
+      \ matchgroup=jsxOpenPunct
+      \ end=+>+
+      \ matchgroup=NONE
+      \ end=+\%(/\_s*>\)\@=+
+      \ contained
+      \ contains=jsxOpenTag,jsxAttrib,jsxExpressionBlock,jsxSpreadOperator,jsComment,@javascriptComments,javaScriptLineComment,javaScriptComment,typescriptLineComment,typescriptComment
+      \ keepend
+      \ extend
+      \ skipwhite
+      \ skipempty
+      \ nextgroup=jsxCloseString
+
+" <tag></tag>
+" ~~~~~~~~~~~
+" and fragment
+" <></>
+" ~~~~~
+" and self close tag
+" <tag />
+" ~~~~~~~
+syntax region jsxElement
+      \ start=+<\_s*\%(>\|\${\|\z(\<[-:._$A-Za-z0-9]\+\>\)\)+
+      \ end=+/\_s*>+
+      \ end=+<\_s*/\_s*\z1\_s*>+
+      \ contains=jsxElement,jsxTag,jsxExpressionBlock,jsxComment,jsxCloseTag,@Spell
+      \ keepend
+      \ extend
+      \ contained
+      \ fold
+
+" <tag key={this.props.key}>
+" ~~~~
+" and fragment start tag
+" <>
+" ~~
+exe 'syntax region jsxOpenTag
+      \ matchgroup=jsxOpenPunct
+      \ start=+<+
+      \ end=+>+
+      \ matchgroup=NONE
+      \ end=+\>+
+      \ contained
+      \ contains=jsxTagName
+      \ nextgroup=jsxAttrib
+      \ skipwhite
+      \ skipempty
+      \ ' .(s:highlight_close_tag ? 'transparent' : '')
+
+
+" <tag key={this.props.key}>
+"          ~~~~~~~~~~~~~~~~
+syntax region jsxExpressionBlock
+      \ matchgroup=jsxBraces
+      \ start=+{+
+      \ end=+}+
+      \ contained
+      \ extend
+      \ contains=@jsExpression,jsSpreadExpression,@javascriptExpression,javascriptSpreadOp,@javaScriptEmbededExpr,@typescriptExpression,typescriptObjectSpread,jsComment,@javascriptComments,javaScriptLineComment,javaScriptComment,typescriptLineComment,typescriptComment
+
+" <foo.bar>
+"     ~
+syntax match jsxDot +\.+ contained
+
+" <foo:bar>
+"     ~
+syntax match jsxNamespace +:+ contained
+
+" <tag id="sample">
+"        ~
+syntax match jsxEqual +=+ contained skipwhite skipempty nextgroup=jsxString,jsxExpressionBlock,jsxRegion
+
+" <tag />
+"      ~~
+syntax match jsxCloseString +/\_s*>+ contained
+
+" </tag>
+" ~~~~~~
+" and fragment close tag
+" </>
+" ~~~
+syntax region jsxCloseTag
+      \ matchgroup=jsxClosePunct
+      \ start=+<\_s*/+
+      \ end=+>+
+      \ contained
+      \ contains=jsxTagName
+
+" <tag key={this.props.key}>
+"      ~~~
+syntax match jsxAttrib
+      \ +\<[_$A-Za-z][-:_$A-Za-z0-9]*\>+
+      \ contained
+      \ nextgroup=jsxEqual
+      \ skipwhite
+      \ skipempty
+      \ contains=jsxAttribKeyword,jsxNamespace
+
+" <MyComponent ...>
+"  ~~~~~~~~~~~
+" NOT
+" <someCamel ...>
+"      ~~~~~
+exe 'syntax match jsxComponentName
+      \ +\<[_$]\?[A-Z][-_$A-Za-z0-9]*\>+
+      \ contained
+      \ ' .(s:highlight_close_tag ? 'transparent' : '')
+
+" <tag key={this.props.key}>
+"  ~~~
+exe 'syntax match jsxTagName
+      \ +\<[-:._$A-Za-z0-9]\+\>+
+      \ contained
+      \ contains=jsxComponentName,jsxDot,jsxNamespace
+      \ nextgroup=jsxAttrib
+      \ skipempty
+      \ skipwhite
+      \ ' .(s:highlight_close_tag ? 'transparent' : '')
+
+" <tag id="sample">
+"         ~~~~~~~~
+" and
+" <tag id='sample'>
+"         ~~~~~~~~
+syntax region jsxString start=+\z(["']\)+  skip=+\\\\\|\\\z1\|\\\n+  end=+\z1+ contained contains=@Spell
+
+let s:tags = get(g:, 'vim_jsx_pretty_template_tags', ['html', 'jsx'])
+let s:enable_tagged_jsx = !empty(s:tags)
+
+" add support to JSX inside the tagged template string
+" https://github.com/developit/htm
+if s:enable_tagged_jsx
+  exe 'syntax match jsxRegion +\%(' . join(s:tags, '\|') . '\)\%(\_s*`\)\@=+ contains=jsTemplateStringTag,jsTaggedTemplate,javascriptTagRef skipwhite skipempty nextgroup=jsxTaggedRegion'
+
+  syntax region jsxTaggedRegion
+        \ matchgroup=jsxBackticks
+        \ start=+`+
+        \ end=+`+
+        \ extend
+        \ contained
+        \ contains=jsxElement,jsxExpressionBlock
+        \ transparent
+
+  syntax region jsxExpressionBlock
+        \ matchgroup=jsxBraces
+        \ start=+\${+
+        \ end=+}+
+        \ extend
+        \ contained
+        \ contains=@jsExpression,jsSpreadExpression,@javascriptExpression,javascriptSpreadOp,@javaScriptEmbededExpr,@typescriptExpression,typescriptObjectSpread
+
+  syntax region jsxOpenTag
+        \ matchgroup=jsxOpenPunct
+        \ start=+<\%(\${\)\@=+
+        \ matchgroup=NONE
+        \ end=+}\@1<=+
+        \ contained
+        \ contains=jsxExpressionBlock
+        \ skipwhite
+        \ skipempty
+        \ nextgroup=jsxAttrib,jsxSpreadOperator
+
+  syntax keyword jsxAttribKeyword class contained
+
+  syntax match jsxSpreadOperator +\.\.\.+ contained nextgroup=jsxExpressionBlock skipwhite
+
+  syntax match jsxCloseTag +<//>+ contained
+
+  syntax match jsxComment +<!--\_.\{-}-->+
+endif
+
+" Highlight the tag name
+highlight def link jsxTag Function
+highlight def link jsxTagName Identifier
+highlight def link jsxComponentName Function
+
+highlight def link jsxAttrib Type
+highlight def link jsxAttribKeyword jsxAttrib
+highlight def link jsxString String
+highlight def link jsxComment Comment
+
+highlight def link jsxDot Operator
+highlight def link jsxNamespace Operator
+highlight def link jsxEqual Operator
+highlight def link jsxSpreadOperator Operator
+highlight def link jsxBraces Special
+
+if s:highlight_close_tag
+  highlight def link jsxCloseString Identifier
+  highlight def link jsxOpenPunct jsxTag
+else
+  " Highlight the jsxCloseString (i.e. />), jsxPunct (i.e. <,>) and jsxCloseTag (i.e. <//>)
+  highlight def link jsxCloseString Comment
+  highlight def link jsxOpenPunct jsxPunct
+endif
+
+highlight def link jsxPunct jsxCloseString
+highlight def link jsxClosePunct jsxPunct
+highlight def link jsxCloseTag jsxCloseString
+
+let s:vim_jsx_pretty_colorful_config = get(g:, 'vim_jsx_pretty_colorful_config', 0)
+
+if s:vim_jsx_pretty_colorful_config == 1
+  highlight def link jsObjectKey Label
+  highlight def link jsArrowFuncArgs Type
+  highlight def link jsFuncArgs Type
+endif
+
+endif

after/syntax/llvm.vim

@@ -0,0 +1,26 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'llvm') == -1
+
+" Copyright (c) 2018 rhysd
+"
+" 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.
+
+syn keyword llvmKeyword attributes
+syn match llvmNoName /#\d\+\>/
+
+endif

after/syntax/mdx.vim

@@ -1,17 +1,8 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'jsx') == -1
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'mdx') == -1
 
-"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-" Vim syntax file
-"
-" Language: JSX (JavaScript)
-" Maintainer: Max Wang <mxawng@gmail.com>
-" Depends: pangloss/vim-javascript
-"
-" CREDITS: Inspired by Facebook.
-"
-"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 
-" Prologue; load in XML syntax.
+" based on mxw/vim-jsx
+
 if exists('b:current_syntax')
   let s:current_syntax=b:current_syntax
   unlet b:current_syntax
@@ -21,23 +12,23 @@ if exists('s:current_syntax')
   let b:current_syntax=s:current_syntax
 endif
 
-" Officially, vim-jsx depends on the pangloss/vim-javascript syntax package
-" (and is tested against it exclusively).  However, in practice, we make some
-" effort towards compatibility with other packages.
-"
-" These are the plugin-to-syntax-element correspondences:
-"
-"   - pangloss/vim-javascript:      jsBlock, jsExpression
-"   - jelera/vim-javascript-syntax: javascriptBlock
-"   - othree/yajs.vim:              javascriptNoReserved
+" JSX attributes should color as JS.  Note the trivial end pattern; we let
+" jsBlock take care of ending the region.
+syn region xmlString contained start=+{+ end=++ contains=jsBlock,javascriptBlock
 
+" JSX child blocks behave just like JSX attributes, except that (a) they are
+" syntactically distinct, and (b) they need the syn-extend argument, or else
+" nested XML end-tag patterns may end the outer jsxRegion.
+syn region jsxChild contained start=+{+ end=++ contains=jsBlock,javascriptBlock
+  \ extend
 
 " Highlight JSX regions as XML; recursively match.
 "
 " Note that we prohibit JSX tags from having a < or word character immediately
 " preceding it, to avoid conflicts with, respectively, the left shift operator
 " and generic Flow type annotations (http://flowtype.org/).
-syn region jsxRegion contains=@XMLSyntax,jsxRegion,jsBlock,javascriptBlock
+syn region jsxRegion
+  \ contains=@Spell,@XMLSyntax,jsxRegion,jsxChild,jsBlock,javascriptBlock
   \ start=+\%(<\|\w\)\@<!<\z([a-zA-Z][a-zA-Z0-9:\-.]*\)+
   \ skip=+<!--\_.\{-}-->+
   \ end=+</\z1\_\s\{-}>+
@@ -45,10 +36,6 @@ syn region jsxRegion contains=@XMLSyntax,jsxRegion,jsBlock,javascriptBlock
   \ keepend
   \ extend
 
-" JSX attributes should color as JS.  Note the trivial end pattern; we let
-" jsBlock take care of ending the region.
-syn region xmlString contained start=+{+ end=++ contains=jsBlock,javascriptBlock
-
 " Add jsxRegion to the lowest-level JS syntax cluster.
 syn cluster jsExpression add=jsxRegion
 

after/syntax/reason.vim

@@ -1,4 +1,4 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') == -1
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'reason') == -1
 
 
 endif

after/syntax/rspec.vim

@@ -9,26 +9,183 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rspec') == -1
 runtime! syntax/ruby.vim
 unlet! b:current_syntax
 
-syntax keyword rspecGroupMethods context describe example it its let it_should_behave_like shared_examples_for subject it_behaves_like pending specify When Then Given Invariant feature scenario given
-highlight link rspecGroupMethods Type
+setlocal commentstring=#\ %s
 
-syntax keyword rspecBeforeAndAfter after after_suite_parts append_after append_before before before_suite_parts prepend_after prepend_before around
-highlight link rspecBeforeAndAfter Statement
+syntax keyword rspecGroupMethods
+      \ aggregate_failures
+      \ context
+      \ describe
+      \ example
+      \ feature
+      \ fcontext
+      \ fdescribe
+      \ fexample
+      \ fit
+      \ focus
+      \ fspecify
+      \ Given
+      \ given\!
+      \ include_context
+      \ include_examples
+      \ Invariant
+      \ it
+      \ it_behaves_like
+      \ it_should_behave_like
+      \ its
+      \ let
+      \ let\!
+      \ pending
+      \ scenario
+      \ shared_examples
+      \ shared_examples_for
+      \ skip
+      \ specify
+      \ subject
+      \ Then
+      \ When
 
-syntax keyword rspecMocks double mock stub stub_chain
-highlight link rspecMocks Constant
+syntax keyword rspecBeforeAndAfter
+      \ after
+      \ after_suite_parts
+      \ append_after
+      \ append_before
+      \ around
+      \ before
+      \ before_suite_parts
+      \ prepend_after
+      \ prepend_before
 
-syntax keyword rspecMockMethods and_raise and_return and_throw and_yield build_child called_max_times expected_args invoke matches
-highlight link rspecMockMethods Function
+syntax keyword rspecMocks
+      \ double
+      \ instance_double
+      \ instance_spy
+      \ mock
+      \ spy
+      \ stub
+      \ stub_chain
+      \ stub_const
 
-syntax keyword rspecKeywords should should_not should_not_receive should_receive
-highlight link rspecKeywords Constant
+syntax keyword rspecMockMethods
+      \ and_call_original
+      \ and_raise
+      \ and_return
+      \ and_throw
+      \ and_yield
+      \ build_child
+      \ called_max_times
+      \ expected_args
+      \ invoke
+      \ matches
+
+syntax keyword rspecKeywords
+      \ should
+      \ should_not
+      \ should_not_receive
+      \ should_receive
+
+syntax keyword rspecMatchers
+      \ all
+      \ allow
+      \ allow_any_instance_of
+      \ assigns
+      \ be
+      \ change
+      \ described_class
+      \ eq
+      \ eql
+      \ equal
+      \ errors_on
+      \ exist
+      \ expect
+      \ expect_any_instance_of
+      \ have
+      \ have_at_least
+      \ have_at_most
+      \ have_exactly
+      \ include
+      \ is_expected
+      \ match
+      \ match_array
+      \ matcher
+      \ not_to
+      \ raise_error
+      \ raise_exception
+      \ receive
+      \ receive_messages
+      \ receive_message_chain
+      \ respond_to
+      \ satisfy
+      \ throw_symbol
+      \ to
+      \ to_not
+      \ when
+      \ wrap_expectation
+
+" rspec-mongoid exclusive matchers
+syntax keyword rspecMatchers
+      \ accept_nested_attributes_for
+      \ belong_to
+      \ custom_validate
+      \ embed_many
+      \ embed_one
+      \ validate_associated
+      \ validate_exclusion_of
+      \ validate_format_of
+      \ validate_inclusion_of
+      \ validate_length_of
+
+" shoulda matchers
+syntax keyword rspecMatchers
+      \ allow_mass_assignment_of
+      \ allow_value
+      \ ensure_exclusion_of
+      \ ensure_length_of
+      \ have_secure_password
+      \ validate_absence_of
+      \ validate_acceptance_of
+      \ validate_confirmation_of
+      \ validate_numericality_of
+      \ validate_presence_of
+      \ validate_uniqueness_of
+
+syntax keyword rspecMessageExpectation
+      \ advise
+      \ any_args
+      \ any_number_of_times
+      \ anything
+      \ at_least
+      \ at_most
+      \ exactly
+      \ expected_messages_received
+      \ generate_error
+      \ hash_including
+      \ hash_not_including
+      \ ignoring_args
+      \ instance_of
+      \ matches_at_least_count
+      \ matches_at_most_count
+      \ matches_exact_count
+      \ matches_name_but_not_args
+      \ negative_expectation_for
+      \ never
+      \ no_args
+      \ once
+      \ ordered
+      \ similar_messages
+      \ times
+      \ twice
+      \ verify_messages_received
+      \ with
 
-syntax keyword rspecMatchers be change eql equal exist expect have have_at_least have_at_most have_exactly include match matcher raise_error raise_exception respond_to satisfy throw_symbol to to_not not_to when wrap_expectation
 syntax match rspecMatchers /\<\(be\|have\)_\w\+\>/
-highlight link rspecMatchers Function
+syntax match rspecGroupMethods /\.describe/
 
-syntax keyword rspecMessageExpectation advise any_args any_number_of_times anything at_least at_most exactly expected_messages_received generate_error hash_including hash_not_including ignoring_args instance_of matches_at_least_count matches_at_most_count matches_exact_count matches_name_but_not_args negative_expectation_for never no_args once ordered similar_messages times twice verify_messages_received with 
+highlight link rspecGroupMethods Statement
+highlight link rspecBeforeAndAfter Identifier
+highlight link rspecMocks Constant
+highlight link rspecMockMethods Function
+highlight link rspecKeywords Constant
+highlight link rspecMatchers Function
 highlight link rspecMessageExpectation Function
 
 let b:current_syntax = 'rspec'

after/syntax/rust.vim

@@ -1,11 +1,13 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 
-if !exists('g:rust_conceal') || g:rust_conceal == 0 || !has('conceal') || &enc != 'utf-8'
+scriptencoding utf-8
+
+if !get(g:, 'rust_conceal', 0) || !has('conceal') || &encoding !=# 'utf-8'
     finish
 endif
 
 " For those who don't want to see `::`...
-if exists('g:rust_conceal_mod_path') && g:rust_conceal_mod_path != 0
+if get(g:, 'rust_conceal_mod_path', 0)
     syn match rustNiceOperator "::" conceal cchar=ㆍ
 endif
 
@@ -20,7 +22,7 @@ syn match rustNiceOperator "=>" contains=rustFatRightArrowHead,rustFatRightArrow
 syn match rustNiceOperator /\<\@!_\(_*\>\)\@=/ conceal cchar=′
 
 " For those who don't want to see `pub`...
-if exists('g:rust_conceal_pub') && g:rust_conceal_pub != 0
+if get(g:, 'rust_conceal_pub', 0)
     syn match rustPublicSigil contained "pu" conceal cchar=＊
     syn match rustPublicRest contained "b" conceal cchar= 
     syn match rustNiceOperator "pub " contains=rustPublicSigil,rustPublicRest
@@ -28,8 +30,16 @@ endif
 
 hi link rustNiceOperator Operator
 
-if !exists('g:rust_conceal_mod_path') && g:rust_conceal_mod_path != 0
+if !get(g:, 'rust_conceal_mod_path', 0)
     hi! link Conceal Operator
+
+    augroup rust.vim.after
+        autocmd!
+        " And keep it after a colorscheme change
+        autocmd ColorScheme <buffer> hi! link Conceal Operator
+    augroup END
 endif
 
+" vim: set et sw=4 sts=4 ts=8:
+
 endif

after/syntax/tex.vim

@@ -1,13 +1,11 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
 
-" adds support for cleverref package
-" \Cref, \cref, \cpageref, \labelcref, \labelcpageref
-syn region texRefZone		matchgroup=texStatement start="\\Cref{"				end="}\|%stopzone\>"	contains=@texRefGroup
-syn region texRefZone		matchgroup=texStatement start="\\\(label\|\)c\(page\|\)ref{"	end="}\|%stopzone\>"	contains=@texRefGroup
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
 
-" adds support for listings package
-syn region texZone start="\\begin{lstlisting}" end="\\end{lstlisting}\|%stopzone\>"
-syn match texInputFile  "\\lstinputlisting\s*\(\[.*\]\)\={.\{-}}" contains=texStatement,texInputCurlies,texInputFileOpt
-syn match texZone "\\lstinline\s*\(\[.*\]\)\={.\{-}}"
+call vimtex#syntax#init()
 
 endif

after/syntax/tsx.vim

@@ -0,0 +1,63 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Vim syntax file
+"
+" Language: javascript.jsx
+" Maintainer: MaxMellon <maxmellon1994@gmail.com>
+" Depends:  leafgarland/typescript-vim
+"
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+if get(g:, 'vim_jsx_pretty_disable_tsx', 0)
+  finish
+endif
+
+let s:jsx_cpo = &cpo
+set cpo&vim
+
+syntax case match
+
+if exists('b:current_syntax')
+  let s:current_syntax = b:current_syntax
+  unlet b:current_syntax
+endif
+
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+" refine the typescript line comment
+syntax region typescriptLineComment start=+//+ end=/$/ contains=@Spell,typescriptCommentTodo,typescriptRef extend keepend
+
+for syntax_name in ['tsxRegion', 'tsxFragment']
+  if hlexists(syntax_name)
+    exe 'syntax clear ' . syntax_name
+  endif
+endfor
+
+if !hlexists('typescriptTypeCast')
+  " add a typescriptBlock group for typescript
+  syntax region typescriptBlock
+        \ matchgroup=typescriptBraces
+        \ start="{"
+        \ end="}"
+        \ contained
+        \ extend
+        \ contains=@typescriptExpression,typescriptBlock
+        \ fold
+  hi def link typescriptTypeBrackets typescriptOpSymbols
+endif
+
+runtime syntax/jsx_pretty.vim
+syntax cluster typescriptExpression add=jsxRegion,typescriptParens
+" Fix type casting ambiguity with JSX syntax
+syntax match typescriptTypeBrackets +[<>]+ contained
+syntax match typescriptTypeCast +<\([_$A-Za-z0-9]\+\)>\%(\s*\%([_$A-Za-z0-9]\+\s*;\?\|(\)\%(\_[^<]*</\1>\)\@!\)\@=+ contains=typescriptTypeBrackets,@typescriptType,typescriptType nextgroup=@typescriptExpression
+
+let b:current_syntax = 'typescript.tsx'
+
+let &cpo = s:jsx_cpo
+unlet s:jsx_cpo
+
+endif

after/syntax/typescript/graphql.vim

@@ -0,0 +1,49 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+
+" Copyright (c) 2016-2020 Jon Parise <jon@indelible.org>
+"
+" 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.
+"
+" Language: GraphQL
+" Maintainer: Jon Parise <jon@indelible.org>
+
+if exists('b:current_syntax')
+  let s:current_syntax = b:current_syntax
+  unlet b:current_syntax
+endif
+syn include @GraphQLSyntax syntax/graphql.vim
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+let s:tags = '\%(' . join(graphql#javascript_tags(), '\|') . '\)'
+
+exec 'syntax region graphqlTemplateString start=+' . s:tags . '\@20<=`+ skip=+\\`+ end=+`+ contains=@GraphQLSyntax,typescriptTemplateSubstitution extend'
+exec 'syntax match graphqlTaggedTemplate +' . s:tags . '\ze`+ nextgroup=graphqlTemplateString'
+
+" Support expression interpolation ((${...})) inside template strings.
+syntax region graphqlTemplateExpression start=+${+ end=+}+ contained contains=typescriptTemplateSubstitution containedin=graphqlFold keepend
+
+hi def link graphqlTemplateString typescriptTemplate
+hi def link graphqlTemplateExpression typescriptTemplateSubstitution
+
+syn cluster typescriptExpression add=graphqlTaggedTemplate
+syn cluster graphqlTaggedTemplate add=graphqlTemplateString
+
+endif

after/syntax/typescriptreact.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+source <sfile>:h/tsx.vim
+
+endif

after/syntax/typescriptreact/graphql.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+
+runtime! after/syntax/typescript/graphql.vim
+
+endif

after/syntax/vue/graphql.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+
+runtime! after/syntax/javascript/graphql.vim
+
+endif

after/syntax/yaml.vim

@@ -21,15 +21,17 @@ if version < 600
 endif
 syntax clear
 
-syn match yamlDelimiter	"[:,-]"
-syn match yamlBlock "[\[\]\{\}\|\>]"
-syn match yamlOperator "[?^+-]\|=>"
+syn match yamlInline "[\[\]\{\}]"
+syn match yamlBlock "[>|]\d\?[+-]"
 
 syn region yamlComment	start="\#" end="$"
 syn match yamlIndicator	"#YAML:\S\+"
 
-syn region yamlString	start="'" end="'" skip="\\'"
+syn region yamlString	start="\(^\|\s\|\[\|\,\|\-\)\@<='" end="'" skip="\\'"
 syn region yamlString	start='"' end='"' skip='\\"' contains=yamlEscape
+syn region yamlString	matchgroup=yamlBlock start=/[>|]\s*\n\+\z(\s\+\)\S/rs=s+1 skip=/^\%(\z1\S\|^$\)/ end=/^\z1\@!.*/me=s-1
+syn region yamlString	matchgroup=yamlBlock start=/[>|]\(\d\|[+-]\)\s*\n\+\z(\s\+\)\S/rs=s+2 skip=/^\%(\z1\S\|^$\)/ end=/^\z1\@!.*/me=s-1
+syn region yamlString	matchgroup=yamlBlock start=/[>|]\d\(\d\|[+-]\)\s*\n\+\z(\s\+\)\S/rs=s+3 skip=/^\%(\z1\S\|^$\)/ end=/^\z1\@!.*/me=s-1
 syn match  yamlEscape	+\\[abfnrtv'"\\]+ contained
 syn match  yamlEscape	"\\\o\o\=\o\=" contained
 syn match  yamlEscape	"\\x\x\+" contained
@@ -40,11 +42,12 @@ syn keyword yamlConstant NULL Null null NONE None none NIL Nil nil
 syn keyword yamlConstant TRUE True true YES Yes yes ON On on
 syn keyword yamlConstant FALSE False false NO No no OFF Off off
 
-syn match  yamlKey	"\w\+\ze\s*:"
+syn match  yamlKey	"^\s*\zs[^ \t\"\'#]\+\ze\s*:"
+ syn match  yamlKey	"^\s*-\s*\zs[^ \t\"\'#]\+\ze\s*:"
 syn match  yamlAnchor	"&\S\+"
 syn match  yamlAlias	"*\S\+"
 
-" Setupt the hilighting links
+" Setup the highlighting links
 
 hi link yamlConstant Keyword
 hi link yamlIndicator PreCondit
@@ -54,11 +57,9 @@ hi link yamlKey		Identifier
 hi link yamlType	Type
 
 hi link yamlComment	Comment
+hi link yamlInline	Operator
 hi link yamlBlock	Operator
-hi link yamlOperator	Operator
-hi link yamlDelimiter	Delimiter
 hi link yamlString	String
 hi link yamlEscape	Special
 
-
 endif

after/syntax/zsh.vim

@@ -0,0 +1,126 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'zinit') == -1
+
+" Copyright (c) 2019 Sebastian Gniazdowski
+"
+" Syntax highlighting for Zinit commands in any file of type `zsh'.
+" It adds definitions for the Zinit syntax to the ones from the
+" existing zsh.vim definitions-file.
+
+" Main Zinit command.
+" Should be the only TOP rule for the whole syntax.
+syntax match ZinitCommand     /\<zinit\>\s/me=e-1
+            \ skipwhite
+            \ nextgroup=ZinitSubCommands,ZinitPluginSubCommands,ZinitSnippetSubCommands
+            \ contains=ZinitSubCommands,ZinitPluginSubCommands,ZinitSnippetSubCommands
+
+" TODO: add options for e.g. light
+syntax match ZinitSubCommands /\s\<\%(ice\|compinit\|env-whitelist\|cdreplay\|cdclear\|update\)\>\s/ms=s+1,me=e-1
+            \ contained
+
+syntax match ZinitPluginSubCommands /\s\<\%(light\|load\)\>\s/ms=s+1,me=e-1
+            \ skipwhite nextgroup=ZinitPlugin1,ZinitPlugin2,ZinitPlugin3
+            \ contains=ZinitPlugin1,ZinitPlugin2,ZinitPlugin3
+
+syntax match ZinitSnippetSubCommands /\s\<\%(snippet\)\>\s/ms=s+1,me=e-1
+            \ skipwhite
+            \ nextgroup=ZinitSnippetShorthands1,ZinitSnippetShorthands2
+            \ contains=ZinitSnippetShorthands1,ZinitSnippetShorthands2
+
+" "user/plugin"
+syntax match ZinitPlugin1 /\s["]\%([!-_]*\%(\/[!-_]\+\)\+\|[!-_]\+\)["]/ms=s+1,hs=s+2,he=e-1
+            \ contained
+            \ nextgroup=ZinitTrailingWhiteSpace
+            \ contains=ZinitTrailingWhiteSpace
+
+" 'user/plugin'
+syntax match ZinitPlugin2 /\s[']\%([!-_]*\%(\/[!-_]\+\)\+\|[!-_]\+\)[']/ms=s+1,hs=s+2,he=e-1
+            \ contained
+            \ nextgroup=ZinitTrailingWhiteSpace
+            \ contains=ZinitTrailingWhiteSpace
+
+" user/plugin
+syntax match ZinitPlugin3 /\s\%([!-_]*\%(\/[!-_]\+\)\+\|[!-_]\+\)/ms=s+1,me=e+2 
+            \ contained
+            \ nextgroup=ZinitTrailingWhiteSpace
+            \ contains=ZinitTrailingWhiteSpace
+
+" OMZ:: or PZT::
+" TODO: 'OMZ:: or 'PZT::
+syntax match ZinitSnippetShorthands1 /\s\<\%(\%(OMZ\|PZT\)\>::\|\)/hs=s+1,he=e-2
+            \ contained
+            \ skipwhite
+            \ nextgroup=ZinitSnippetUrl1,ZinitSnippetUrl2
+            \ contains=ZinitSnippetUrl1,ZinitSnippetUrl2
+
+" "OMZ:: or "PZT::
+syntax match ZinitSnippetShorthands2 /\s["]\%(\%(OMZ\|PZT\)\>::\|\)/hs=s+2,he=e-2
+            \ contained
+            \ skipwhite
+            \ nextgroup=ZinitSnippetUrl3,ZinitSnippetUrl4
+            \ contains=ZinitSnippetUrl3,ZinitSnippetUrl4
+
+syntax match ZinitSnippetUrl3 /\<\%(http:\/\/\|https:\/\/\|ftp:\/\/\|\$HOME\|\/\)[!-_]\+\%(\/[!-_]\+\)*\/\?["]/he=e-1
+            \ contained
+            \ nextgroup=ZinitTrailingWhiteSpace
+            \ contains=ZinitTrailingWhiteSpace
+
+" TODO: Fix ZinitTrailingWhiteSpace not matching
+syntax match ZinitSnippetUrl4 /\%(\%(OMZ\|PZT\)::\)[!-_]\+\%(\/[!-_]\+\)*\/\?["]/hs=s+5,he=e-1
+            \ contained
+            \ nextgroup=ZinitTrailingWhiteSpace
+            \ contains=ZinitTrailingWhiteSpace
+
+" http://… or https://… or ftp://… or $HOME/… or /…
+" TODO: Fix $HOME/… and /… not matching
+syntax match ZinitSnippetUrl1 /\<\%(http:\/\/\|https:\/\/\|ftp:\/\/\|\$HOME\|\/\)[!-_]\+\%(\/[!-_]\+\)*\/\?/
+            \ contained
+            \ nextgroup=ZinitTrailingWhiteSpace
+            \ contains=ZinitTrailingWhiteSpace
+
+" TODO: Fix ZinitTrailingWhiteSpace not matching
+syntax match ZinitSnippetUrl2 /\<\%(\%(OMZ\|PZT\)::\)[!-_]\+\%(\/[!-_]\+\)*\/\?/hs=s+5
+            \ contained
+            \ nextgroup=ZinitTrailingWhiteSpace
+            \ contains=ZinitTrailingWhiteSpace
+
+syntax match ZinitTrailingWhiteSpace /[[:space:]]\+$/ contained
+
+" TODO: differentiate the no-value ices
+" TODO: use contained
+syntax match ZinitIceSubCommand /\sice\s/ms=s+1,me=e-1 nextgroup=ZinitIceModifiers
+syntax match ZinitIceModifiers  /\s\<\%(svn\|proto\|from\|teleid\|bindmap\|cloneopts\|id-as\|depth\|if\|wait\|load\)\>/ms=s+1
+syntax match ZinitIceModifiers  /\s\<\%(unload\|blockf\|on-update-of\|subscribe\|pick\|bpick\|src\|as\|ver\|silent\)\>/ms=s+1
+syntax match ZinitIceModifiers  /\s\<\%(lucid\|notify\|mv\|cp\|atinit\|atclone\|atload\|atpull\|nocd\|run-atpull\|has\)\>/ms=s+1
+syntax match ZinitIceModifiers  /\s\<\%(cloneonly\|make\|service\|trackbinds\|multisrc\|compile\|nocompile\)\>/ms=s+1
+syntax match ZinitIceModifiers  /\s\<\%(nocompletions\|reset-prompt\|wrap-track\|reset\|aliases\|sh\|bash\|ksh\|csh\)\>/ms=s+1
+syntax match ZinitIceModifiers  /\s\<\%(\\!sh\|!sh\|\\!bash\|!bash\|\\!ksh\|!ksh\|\\!csh\|!csh\)\>/ms=s+1
+syntax match ZinitIceModifiers  /\s\<\%(blockf\|silent\|lucid\|trackbinds\|cloneonly\|nocd\|run-atpull\)\>/ms=s+1
+syntax match ZinitIceModifiers  /\s\<\%(\|sh\|\!sh\|bash\|\!bash\|ksh\|\!ksh\|csh\|\!csh\)\>/ms=s+1
+syntax match ZinitIceModifiers  /\s\<\%(nocompletions\|svn\|aliases\|trigger-load\)\>/ms=s+1
+syntax match ZinitIceModifiers  /\s\<\%(light-mode\|is-snippet\|countdown\|ps-on-unload\|ps-on-update\)\>/ms=s+1
+            
+" Include also ices added by the existing annexes
+syntax match ZinitIceModifiers  /\s\<\%(test\|zman\|submod\|dl\|patch\|fbin\|sbin\|fsrc\|ferc\|fmod\|gem\|node\|rustup\|cargo\)\>/ms=s+1
+        
+" Additional Zsh and Zinit functions
+syntax match ZshAndZinitFunctions     /\<\%(compdef\|compinit\|zpcdreplay\|zpcdclear\|zpcompinit\|zpcompdef\)\>/
+
+" Link
+highlight def link ZshAndZinitFunctions    Keyword
+highlight def link ZinitCommand            Statement
+highlight def link ZinitSubCommands        Title
+highlight def link ZinitPluginSubCommands  Title
+highlight def link ZinitSnippetSubCommands Title
+highlight def link ZinitIceModifiers       Type
+highlight def link ZinitSnippetShorthands1 Keyword
+highlight def link ZinitSnippetShorthands2 Keyword
+highlight def link ZinitPlugin1            Macro
+highlight def link ZinitPlugin2            Macro
+highlight def link ZinitPlugin3            Macro
+highlight def link ZinitSnippetUrl1        Macro
+highlight def link ZinitSnippetUrl2        Macro
+highlight def link ZinitSnippetUrl3        Macro
+highlight def link ZinitSnippetUrl4        Macro
+highlight def link ZinitTrailingWhiteSpace Error
+
+endif

autoload/LaTeXtoUnicode.vim

@@ -0,0 +1,656 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Support for LaTex-to-Unicode conversion as in the Julia REPL "
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
+function! s:L2U_Setup()
+
+  call s:L2U_SetupGlobal()
+
+  " Keep track of whether LaTeX-to-Unicode is activated
+  " (used when filetype changes)
+  if !has_key(b:, "l2u_enabled")
+    let b:l2u_enabled = 0
+  endif
+  if !has_key(b:, "l2u_autodetect_enable")
+    let b:l2u_autodetect_enable = 1
+  endif
+
+  " Did we install the L2U tab mappings?
+  if !has_key(b:, "l2u_tab_set")
+    let b:l2u_tab_set = 0
+  endif
+  if !has_key(b:, "l2u_cmdtab_set")
+    let b:l2u_cmdtab_set = 0
+  endif
+  if !has_key(b:, "l2u_keymap_set")
+    let b:l2u_keymap_set = 0
+  endif
+
+  " Did we activate the L2U as-you-type substitutions?
+  if !has_key(b:, "l2u_autosub_set")
+    let b:l2u_autosub_set = 0
+  endif
+
+  " Following are some flags used to pass information between the function which
+  " attempts the LaTeX-to-Unicode completion and the fallback function
+
+  " Was a (possibly partial) completion found?
+  let b:l2u_found_completion = 0
+  " Is the cursor just after a single backslash
+  let b:l2u_singlebslash = 0
+  " Backup value of the completeopt settings
+  " (since we temporarily add the 'longest' setting while
+  "  attempting LaTeX-to-Unicode)
+  let b:l2u_backup_commpleteopt = &completeopt
+  " Are we in the middle of a L2U tab completion?
+  let b:l2u_tab_completing = 0
+  " Are we calling the tab fallback?
+  let b:l2u_in_fallback = 0
+
+endfunction
+
+function! s:L2U_SetupGlobal()
+
+  " Initialization of global and script-local variables
+  " is only performed once
+  if get(g:, "l2u_did_global_setup", 0)
+    return
+  endif
+
+  let g:l2u_did_global_setup = 1
+
+  let g:l2u_symbols_dict = julia_latex_symbols#get_dict()
+
+  call s:L2U_deprecated_options()
+
+  if v:version < 704
+      let g:latex_to_unicode_tab = 0
+      let g:latex_to_unicode_auto = 0
+  endif
+
+  " YouCompleteMe and neocomplcache/neocomplete/deoplete plug-ins do not work well
+  " with LaTeX symbols suggestions
+  if exists("g:loaded_youcompleteme") ||
+        \ exists("g:loaded_neocomplcache") ||
+        \ exists("g:loaded_neocomplete") ||
+        \ exists("g:loaded_deoplete")
+    let g:latex_to_unicode_suggestions = 0
+  endif
+
+  " A hack to forcibly get out of completion mode: feed
+  " this string with feedkeys()
+  if has("win32") || has("win64")
+    let s:l2u_esc_sequence = "\u0006"
+  else
+    let s:l2u_esc_sequence = "\u0091\b"
+  end
+
+  " Trigger for the previous mapping of <Tab>
+  let s:l2u_fallback_trigger = "\u0091L2UFallbackTab"
+
+endfunction
+
+" Each time the filetype changes, we may need to enable or
+" disable the LaTeX-to-Unicode functionality
+function! LaTeXtoUnicode#Refresh()
+  call s:L2U_Setup()
+
+  " skip if manually overridden
+  if !b:l2u_autodetect_enable
+    return ''
+  endif
+
+  " by default, LaTeX-to-Unicode is only active on julia files
+  let file_types = s:L2U_file_type_regex(get(g:, "latex_to_unicode_file_types", "julia"))
+  let file_types_blacklist = s:L2U_file_type_regex(get(g:, "latex_to_unicode_file_types_blacklist", "$^"))
+
+  if match(&filetype, file_types) < 0 || match(&filetype, file_types_blacklist) >= 0
+    if b:l2u_enabled
+      call LaTeXtoUnicode#Disable(1)
+    else
+      return ''
+    endif
+  elseif !b:l2u_enabled
+    call LaTeXtoUnicode#Enable(1)
+  endif
+endfunction
+
+function! LaTeXtoUnicode#Enable(...)
+  let auto_set = a:0 > 0 ? a:1 : 0
+
+  if b:l2u_enabled
+    return ''
+  end
+
+  call s:L2U_ResetLastCompletionInfo()
+
+  let b:l2u_enabled = 1
+  let b:l2u_autodetect_enable = auto_set
+
+  " If we're editing the first file upon opening vim, this will only init the
+  " command line mode mapping, and the full initialization will be performed by
+  " the autocmd triggered by InsertEnter, defined in /ftdetect.vim.
+  " Otherwise, if we're opening a file from within a running vim session, this
+  " will actually initialize all the LaTeX-to-Unicode substitutions.
+  call LaTeXtoUnicode#Init()
+  return ''
+endfunction
+
+function! LaTeXtoUnicode#Disable(...)
+  let auto_set = a:0 > 0 ? a:1 : 0
+  if !b:l2u_enabled
+    return ''
+  endif
+  let b:l2u_enabled = 0
+  let b:l2u_autodetect_enable = auto_set
+  call LaTeXtoUnicode#Init()
+  return ''
+endfunction
+
+" Translate old options to their new equivalents
+function! s:L2U_deprecated_options()
+  for [new, old] in [["latex_to_unicode_tab",         "julia_latex_to_unicode"],
+                 \   ["latex_to_unicode_auto",        "julia_auto_latex_to_unicode"],
+                 \   ["latex_to_unicode_suggestions", "julia_latex_suggestions_enabled"],
+                 \   ["latex_to_unicode_eager",       "julia_latex_to_unicode_eager"]]
+    if !has_key(g:, new) && has_key(g:, old)
+      exec "let g:" . new . " = g:" . old
+    endif
+  endfor
+endfunction
+
+function! s:L2U_file_type_regex(ft)
+  if type(a:ft) == 3
+    let file_types = "\\%(" . join(a:ft, "\\|") . "\\)"
+  elseif type(a:ft) == 1
+    let file_types = a:ft
+  else
+    echoerr "invalid file_type specification"
+  endif
+  return "^" . file_types . "$"
+endfunction
+
+" Some data used to keep track of the previous completion attempt.
+" Used to detect
+" 1) if we just attempted the same completion, or
+" 2) if backspace was just pressed while completing
+" This function initializes and resets the required info
+
+function! s:L2U_ResetLastCompletionInfo()
+  let b:l2u_completed_once = 0
+  let b:l2u_bs_while_completing = 0
+  let b:l2u_last_compl = {
+        \ 'line': '',
+        \ 'col0': -1,
+        \ 'col1': -1,
+        \ }
+endfunction
+
+" This function only detects whether an exact match is found for a LaTeX
+" symbol in front of the cursor
+function! s:L2U_ismatch()
+  let col1 = col('.')
+  let l = getline('.')
+  let col0 = match(l[0:col1-2], '\\[^[:space:]\\]\+$')
+  if col0 == -1
+    return 0
+  endif
+  let base = l[col0 : col1-1]
+  return has_key(g:l2u_symbols_dict, base)
+endfunction
+
+" Helper function to sort suggestion entries
+function! s:L2U_partmatches_sort(p1, p2)
+  return a:p1.word > a:p2.word ? 1 : a:p1.word < a:p2.word ? -1 : 0
+endfunction
+
+" Helper function to fix display of Unicode compose characters
+" in the suggestions menu (they are displayed on top of '◌')
+function! s:L2U_fix_compose_chars(uni)
+  let u = matchstr(a:uni, '^.')
+  let isc = ("\u0300" <= u && u <= "\u036F") ||
+          \ ("\u1DC0" <= u && u <= "\u1DFF") ||
+          \ ("\u20D0" <= u && u <= "\u20FF") ||
+          \ ("\uFE20" <= u && u <= "\uFE2F")
+  return isc ? "\u25CC" . a:uni : a:uni
+endfunction
+
+" Helper function to find the longest common prefix among
+" partial completion matches (used when suggestions are disabled
+" and in command line mode)
+function! s:L2U_longest_common_prefix(partmatches)
+  let common = a:partmatches[0]
+  for i in range(1, len(a:partmatches)-1)
+    let p = a:partmatches[i]
+    if len(p) < len(common)
+      let common = common[0 : len(p)-1]
+    endif
+    for j in range(1, len(common)-1)
+      if p[j] != common[j]
+        let common = common[0 : j-1]
+        break
+      endif
+    endfor
+  endfor
+  return common
+endfunction
+
+" Omnicompletion function. Besides the usual two-stage omnifunc behaviour,
+" it has the following peculiar features:
+"  *) keeps track of the previous completion attempt
+"  *) sets some info to be used by the fallback function
+"  *) either returns a list of completions if a partial match is found, or a
+"     Unicode char if an exact match is found
+"  *) forces its way out of completion mode through a hack in some cases
+function! LaTeXtoUnicode#omnifunc(findstart, base)
+  if a:findstart
+    " first stage
+    " avoid infinite loop if the fallback happens to call omnicompletion
+    if b:l2u_in_fallback
+      let b:l2u_in_fallback = 0
+      return -3
+    endif
+    let b:l2u_in_fallback = 0
+    " set info for the callback
+    let b:l2u_found_completion = 1
+    " analyse current line
+    let col1 = col('.')
+    let l = getline('.')
+    let col0 = match(l[0:col1-2], '\\[^[:space:]\\]\+$')
+    " compare with previous completion attempt
+    let b:l2u_bs_while_completing = 0
+    let b:l2u_completed_once = 0
+    if col0 == b:l2u_last_compl['col0']
+      let prevl = b:l2u_last_compl['line']
+      if col1 == b:l2u_last_compl['col1'] && l ==# prevl
+        let b:l2u_completed_once = 1
+      elseif col1 == b:l2u_last_compl['col1'] - 1 && l ==# prevl[0 : col1-2] . prevl[col1 : -1]
+        let b:l2u_bs_while_completing = 1
+      endif
+    endif
+    " store completion info for next attempt
+    let b:l2u_last_compl['col0'] = col0
+    let b:l2u_last_compl['col1'] = col1
+    let b:l2u_last_compl['line'] = l
+    " is the cursor right after a backslash?
+    let b:l2u_singlebslash = (match(l[0:col1-2], '\\$') >= 0)
+    " completion not found
+    if col0 == -1
+      let b:l2u_found_completion = 0
+      call feedkeys(s:l2u_esc_sequence, 'n')
+      let col0 = -2
+    endif
+    return col0
+  else
+    " read settings (eager mode is implicit when suggestions are disabled)
+    let suggestions = get(g:, "latex_to_unicode_suggestions", 1)
+    let eager = get(g:, "latex_to_unicode_eager", 1) || !suggestions
+    " search for matches
+    let partmatches = []
+    let exact_match = 0
+    for k in keys(g:l2u_symbols_dict)
+      if k ==# a:base
+        let exact_match = 1
+      endif
+      if len(k) >= len(a:base) && k[0 : len(a:base)-1] ==# a:base
+        let menu = s:L2U_fix_compose_chars(g:l2u_symbols_dict[k])
+        if suggestions
+          call add(partmatches, {'word': k, 'menu': menu})
+        else
+          call add(partmatches, k)
+        endif
+      endif
+    endfor
+    " exact matches are replaced with Unicode
+    " exceptions:
+    "  *) we reached an exact match by pressing backspace while completing
+    "  *) the exact match is one among many, and the eager setting is
+    "     disabled, and it's the first time this completion is attempted
+    if exact_match && !b:l2u_bs_while_completing && (len(partmatches) == 1 || eager || b:l2u_completed_once)
+      " the completion is successful: reset the last completion info...
+      call s:L2U_ResetLastCompletionInfo()
+      " ...force our way out of completion mode...
+      call feedkeys(s:l2u_esc_sequence, 'n')
+      " ...return the Unicode symbol
+      return [g:l2u_symbols_dict[a:base]]
+    endif
+    if !empty(partmatches)
+      " here, only partial matches were found; either keep just the longest
+      " common prefix, or pass them on
+      if !suggestions
+        let partmatches = [s:L2U_longest_common_prefix(partmatches)]
+      else
+        call sort(partmatches, "s:L2U_partmatches_sort")
+      endif
+    endif
+    if empty(partmatches)
+      call feedkeys(s:l2u_esc_sequence, 'n')
+      let b:l2u_found_completion = 0
+    endif
+    return partmatches
+  endif
+endfunction
+
+function! LaTeXtoUnicode#PutLiteral(k)
+  call feedkeys(a:k, 'ni')
+  return ''
+endfunction
+
+" Function which saves the current insert-mode mapping of a key sequence `s`
+" and associates it with another key sequence `k` (e.g. stores the current
+" <Tab> mapping into the Fallback trigger)
+function! s:L2U_SetFallbackMapping(s, k)
+  let mmdict = maparg(a:s, 'i', 0, 1)
+  if empty(mmdict)
+    exe 'inoremap <buffer> ' . a:k . ' ' . a:s
+    return
+  endif
+  let rhs = mmdict["rhs"]
+  if rhs =~# '^<Plug>L2U'
+    return
+  endif
+  let pre = '<buffer>'
+  if mmdict["silent"]
+    let pre = pre . '<silent>'
+  endif
+  if mmdict["expr"]
+    let pre = pre . '<expr>'
+  endif
+  if mmdict["noremap"]
+    let cmd = 'inoremap '
+  else
+    let cmd = 'imap '
+    " This is a nasty hack used to prevent infinite recursion. It's not a
+    " general solution.
+    if mmdict["expr"]
+      let rhs = substitute(rhs, '\c' . a:s, "\<C-R>=LaTeXtoUnicode#PutLiteral('" . a:s . "')\<CR>", 'g')
+    endif
+  endif
+  exe cmd . pre . ' ' . a:k . ' ' . rhs
+endfunction
+
+" This is the function which is mapped to <Tab>
+function! LaTeXtoUnicode#Tab()
+  " the <Tab> is passed through to the fallback mapping if the completion
+  " menu is present, and it hasn't been raised by the L2U tab, and there
+  " isn't an exact match before the cursor when suggestions are disabled
+  if pumvisible() && !b:l2u_tab_completing && (get(g:, "latex_to_unicode_suggestions", 1) || !s:L2U_ismatch())
+    call feedkeys(s:l2u_fallback_trigger)
+    return ''
+  endif
+  " reset the in_fallback info
+  let b:l2u_in_fallback = 0
+  let b:l2u_tab_completing = 1
+  " temporary change to completeopt to use the `longest` setting, which is
+  " probably the only one which makes sense given that the goal of the
+  " completion is to substitute the final string
+  let b:l2u_backup_commpleteopt = &completeopt
+  set completeopt+=longest
+  set completeopt-=noinsert
+  " invoke omnicompletion; failure to perform LaTeX-to-Unicode completion is
+  " handled by the CompleteDone autocommand.
+  call feedkeys("\<C-X>\<C-O>", 'n')
+  return ""
+endfunction
+
+" This function is called at every CompleteDone event, and is meant to handle
+" the failures of LaTeX-to-Unicode completion by calling a fallback
+function! LaTeXtoUnicode#FallbackCallback()
+  if !b:l2u_tab_completing
+    " completion was not initiated by L2U, nothing to do
+    return
+  else
+    " completion was initiated by L2U, restore completeopt
+    let &completeopt = b:l2u_backup_commpleteopt
+  endif
+  " at this point L2U tab completion is over
+  let b:l2u_tab_completing = 0
+  " if the completion was successful do nothing
+  if b:l2u_found_completion == 1 || b:l2u_singlebslash == 1
+    return
+  endif
+  " fallback
+  let b:l2u_in_fallback = 1
+  call feedkeys(s:l2u_fallback_trigger)
+  return
+endfunction
+
+" This is the function that performs the substitution in command-line mode
+function! LaTeXtoUnicode#CmdTab(trigger)
+  " first stage
+  " analyse command line
+  let col1 = getcmdpos() - 1
+  let l = getcmdline()
+  let col0 = match(l[0:col1-1], '\\[^[:space:]\\]\+$')
+  let b:l2u_singlebslash = (match(l[0:col1-1], '\\$') >= 0)
+  " completion not found
+  if col0 == -1
+    if a:trigger == &wildchar
+      call feedkeys(nr2char(a:trigger), 'nt') " fall-back to the default wildchar
+    elseif a:trigger == char2nr("\<S-Tab>")
+      call feedkeys("\<S-Tab>", 'nt') " fall-back to the default <S-Tab>
+    endif
+    return ''
+  endif
+  let base = l[col0 : col1-1]
+  " search for matches
+  let partmatches = []
+  let exact_match = 0
+  for k in keys(g:l2u_symbols_dict)
+    if k ==# base
+      let exact_match = 1
+      break
+    elseif len(k) >= len(base) && k[0 : len(base)-1] ==# base
+      call add(partmatches, k)
+    endif
+  endfor
+  if !exact_match && len(partmatches) == 0
+    " no matches, call fallbacks
+    if a:trigger == &wildchar
+      call feedkeys(nr2char(a:trigger), 'nt') " fall-back to the default wildchar
+    elseif a:trigger == char2nr("\<S-Tab>")
+      call feedkeys("\<S-Tab>", 'nt') " fall-back to the default <S-Tab>
+    endif
+  elseif exact_match
+    " exact matches are replaced with Unicode
+    let unicode = g:l2u_symbols_dict[base]
+    call feedkeys(repeat("\b", len(base)) . unicode, 'nt')
+  else
+    " no exact match: complete with the longest common prefix
+    let common = s:L2U_longest_common_prefix(partmatches)
+    call feedkeys(common[len(base):], 'nt')
+  endif
+  return ''
+endfunction
+
+" Setup the L2U tab mapping
+function! s:L2U_SetTab(wait_insert_enter)
+  if !b:l2u_cmdtab_set && get(g:, "latex_to_unicode_tab", 1) && b:l2u_enabled
+    let b:l2u_cmdtab_keys = get(g:, "latex_to_unicode_cmd_mapping", ['<Tab>','<S-Tab>'])
+    if type(b:l2u_cmdtab_keys) != type([]) " avoid using v:t_list for backward compatibility
+      let b:l2u_cmdtab_keys = [b:l2u_cmdtab_keys]
+    endif
+    for k in b:l2u_cmdtab_keys
+      exec 'let trigger = char2nr("'.(k[0] == '<' ? '\' : '').k.'")'
+      exec 'cnoremap <buffer><expr> '.k.' LaTeXtoUnicode#CmdTab('.trigger.')'
+    endfor
+    let b:l2u_cmdtab_set = 1
+  endif
+  if b:l2u_tab_set
+    return
+  endif
+  " g:did_insert_enter is set from an autocommand in ftdetect
+  if a:wait_insert_enter && !get(g:, "did_insert_enter", 0)
+    return
+  endif
+  if !get(g:, "latex_to_unicode_tab", 1) || !b:l2u_enabled
+    return
+  endif
+
+  " Backup the previous omnifunc (the check is probably not really needed)
+  if get(b:, "prev_omnifunc", "") != "LaTeXtoUnicode#omnifunc"
+    let b:prev_omnifunc = &omnifunc
+  endif
+  setlocal omnifunc=LaTeXtoUnicode#omnifunc
+
+  call s:L2U_SetFallbackMapping('<Tab>', s:l2u_fallback_trigger)
+  imap <buffer> <Tab> <Plug>L2UTab
+  inoremap <buffer><expr> <Plug>L2UTab LaTeXtoUnicode#Tab()
+
+  augroup L2UTab
+    autocmd! * <buffer>
+    " Every time a completion finishes, the fallback may be invoked
+    autocmd CompleteDone <buffer> call LaTeXtoUnicode#FallbackCallback()
+  augroup END
+
+  let b:l2u_tab_set = 1
+endfunction
+
+" Revert the LaTeX-to-Unicode tab mapping settings
+function! s:L2U_UnsetTab()
+  if b:l2u_cmdtab_set
+    for k in b:l2u_cmdtab_keys
+      exec 'cunmap <buffer> '.k
+    endfor
+    let b:l2u_cmdtab_set = 0
+  endif
+  if !b:l2u_tab_set
+    return
+  endif
+  exec "setlocal omnifunc=" . get(b:, "prev_omnifunc", "")
+  iunmap <buffer> <Tab>
+  if empty(maparg("<Tab>", "i"))
+    call s:L2U_SetFallbackMapping(s:l2u_fallback_trigger, '<Tab>')
+  endif
+  iunmap <buffer> <Plug>L2UTab
+  exe 'iunmap <buffer> ' . s:l2u_fallback_trigger
+  augroup L2UTab
+    autocmd! * <buffer>
+  augroup END
+  let b:l2u_tab_set = 0
+endfunction
+
+" Function which looks for viable LaTeX-to-Unicode supstitutions as you type
+function! LaTeXtoUnicode#AutoSub(...)
+  let vc = a:0 == 0 ? v:char : a:1
+  let col1 = col('.')
+  let lnum = line('.')
+  if col1 == 1
+    if a:0 > 1
+      call feedkeys(a:2, 'n')
+    endif
+    return ''
+  endif
+  let bs = (vc != "\n")
+  let l = getline(lnum)[0 : col1-1-bs] . v:char
+  let col0 = match(l, '\\\%([_^]\?[A-Za-z]\+\%' . col1 . 'c\%([^A-Za-z]\|$\)\|[_^]\%([0-9()=+-]\)\%' . col1 .'c\%(.\|$\)\)')
+  if col0 == -1
+    if a:0 > 1
+      call feedkeys(a:2, 'n')
+    endif
+    return ''
+  endif
+  let base = l[col0 : -1-bs]
+  let unicode = get(g:l2u_symbols_dict, base, '')
+  if empty(unicode)
+    if a:0 > 1
+      call feedkeys(a:2, 'n')
+    endif
+    return ''
+  endif
+  call feedkeys("\<C-G>u", 'n')
+  call feedkeys(repeat("\b", len(base) + bs) . unicode . vc . s:l2u_esc_sequence, 'nt')
+  call feedkeys("\<C-G>u", 'n')
+  return ''
+endfunction
+
+" Setup the auto as-you-type LaTeX-to-Unicode substitution
+function! s:L2U_SetAutoSub(wait_insert_enter)
+  if b:l2u_autosub_set
+    return
+  endif
+  " g:did_insert_enter is set from an autocommand in ftdetect
+  if a:wait_insert_enter && !get(g:, "did_insert_enter", 0)
+    return
+  endif
+  if !get(g:, "latex_to_unicode_auto", 0) || !b:l2u_enabled
+    return
+  endif
+  " Viable substitutions are searched at every character insertion via the
+  " autocmd InsertCharPre. The <Enter> key does not seem to be catched in
+  " this way though, so we use a mapping for that case.
+  imap <buffer> <CR> <Plug>L2UAutoSub
+  inoremap <buffer><expr> <Plug>L2UAutoSub LaTeXtoUnicode#AutoSub("\n", "\<CR>")
+
+  augroup L2UAutoSub
+    autocmd! * <buffer>
+    autocmd InsertCharPre <buffer> call LaTeXtoUnicode#AutoSub()
+  augroup END
+
+  let b:l2u_autosub_set = 1
+endfunction
+
+" Revert the auto LaTeX-to-Unicode settings
+function! s:L2U_UnsetAutoSub()
+  if !b:l2u_autosub_set
+    return
+  endif
+
+  iunmap <buffer> <CR>
+  iunmap <buffer> <Plug>L2UAutoSub
+  augroup L2UAutoSub
+    autocmd! * <buffer>
+  augroup END
+  let b:l2u_autosub_set = 0
+endfunction
+
+function! s:L2U_SetKeymap()
+  if !b:l2u_keymap_set && get(g:, "latex_to_unicode_keymap", 0) && b:l2u_enabled
+    setlocal keymap=latex2unicode
+    let b:l2u_keymap_set = 1
+  endif
+endfunction
+
+function! s:L2U_UnsetKeymap()
+  if !b:l2u_keymap_set
+    return
+  endif
+  setlocal keymap=
+  let b:l2u_keymap_set = 0
+endfunction
+
+" Initialization. Can be used to re-init when global settings have changed.
+function! LaTeXtoUnicode#Init(...)
+  let wait_insert_enter = a:0 > 0 ? a:1 : 1
+
+  if !wait_insert_enter
+    augroup L2UInit
+      autocmd!
+    augroup END
+  endif
+
+  call s:L2U_UnsetTab()
+  call s:L2U_UnsetAutoSub()
+  call s:L2U_UnsetKeymap()
+
+  call s:L2U_SetTab(wait_insert_enter)
+  call s:L2U_SetAutoSub(wait_insert_enter)
+  call s:L2U_SetKeymap()
+  return ''
+endfunction
+
+function! LaTeXtoUnicode#Toggle()
+  call s:L2U_Setup()
+  if b:l2u_enabled
+    call LaTeXtoUnicode#Disable()
+    echo "LaTeX-to-Unicode disabled"
+  else
+    call LaTeXtoUnicode#Enable()
+    echo "LaTeX-to-Unicode enabled"
+  endif
+  return ''
+endfunction
+
+endif

autoload/RstFold.vim

@@ -0,0 +1,66 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rst') == -1
+
+" Author: Antony Lee <anntzer.lee@gmail.com>
+" Description: Helper functions for reStructuredText syntax folding
+" Last Modified: 2018-12-29
+
+function s:CacheRstFold()
+  if !g:rst_fold_enabled
+    return
+  endif
+
+  let closure = {'header_types': {}, 'max_level': 0, 'levels': {}}
+  function closure.Process(match) dict
+    let curline = getcurpos()[1]
+    if has_key(self.levels, curline - 1)
+      " For over+under-lined headers, the regex will match both at the
+      " overline and at the title itself; in that case, skip the second match.
+      return
+    endif
+    let lines = split(a:match, '\n')
+    let key = repeat(lines[-1][0], len(lines))
+    if !has_key(self.header_types, key)
+      let self.max_level += 1
+      let self.header_types[key] = self.max_level
+    endif
+    let self.levels[curline] = self.header_types[key]
+  endfunction
+  let save_cursor = getcurpos()
+  let save_mark = getpos("'[")
+  silent keeppatterns %s/\v^%(%(([=`:.'"~^_*+#-])\1+\n)?.{1,2}\n([=`:.'"~^_*+#-])\2+)|%(%(([=`:.''"~^_*+#-])\3{2,}\n)?.{3,}\n([=`:.''"~^_*+#-])\4{2,})$/\=closure.Process(submatch(0))/gn
+  call setpos('.', save_cursor)
+  call setpos("'[", save_mark)
+  let b:RstFoldCache = closure.levels
+endfunction
+
+function RstFold#GetRstFold()
+  if !g:rst_fold_enabled
+    return
+  endif
+
+  if !has_key(b:, 'RstFoldCache')
+    call s:CacheRstFold()
+  endif
+  if has_key(b:RstFoldCache, v:lnum)
+    return '>' . b:RstFoldCache[v:lnum]
+  else
+    return '='
+  endif
+endfunction
+
+function RstFold#GetRstFoldText()
+  if !g:rst_fold_enabled
+    return
+  endif
+
+  if !has_key(b:, 'RstFoldCache')
+    call s:CacheRstFold()
+  endif
+  let indent = repeat('  ', b:RstFoldCache[v:foldstart] - 1)
+  let thisline = getline(v:foldstart)
+  " For over+under-lined headers, skip the overline.
+  let text = thisline =~ '^\([=`:.''"~^_*+#-]\)\1\+$' ? getline(v:foldstart + 1) : thisline
+  return indent . text
+endfunction
+
+endif

autoload/cargo.vim

@@ -0,0 +1,151 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+
+function! cargo#Load()
+    " Utility call to get this script loaded, for debugging
+endfunction
+
+function! cargo#cmd(args) abort
+    " Trim trailing spaces. This is necessary since :terminal command parses
+    " trailing spaces as an empty argument.
+    let args = substitute(a:args, '\s\+$', '', '')
+    if exists('g:cargo_shell_command_runner')
+        let cmd = g:cargo_shell_command_runner
+    elseif has('terminal')
+        let cmd = 'terminal'
+    elseif has('nvim')
+        let cmd = 'noautocmd new | terminal'
+    else
+        let cmd = '!'
+    endif
+    execute cmd 'cargo' args
+endfunction
+
+function! s:nearest_cargo(...) abort
+    " If the second argument is not specified, the first argument determines
+    " whether we will start from the current directory or the directory of the
+    " current buffer, otherwise, we start with the provided path on the 
+    " second argument.
+
+    let l:is_getcwd = get(a:, 1, 0)
+    if l:is_getcwd 
+        let l:starting_path = get(a:, 2, getcwd())
+    else
+        let l:starting_path = get(a:, 2, expand('%:p:h'))
+    endif
+
+    return findfile('Cargo.toml', l:starting_path . ';')
+endfunction
+
+function! cargo#nearestCargo(is_getcwd) abort
+    return s:nearest_cargo(a:is_getcwd)
+endfunction
+
+function! cargo#nearestWorkspaceCargo(is_getcwd) abort
+    let l:nearest = s:nearest_cargo(a:is_getcwd)
+    while l:nearest !=# ''
+        for l:line in readfile(l:nearest, '', 0x100)
+            if l:line =~# '\V[workspace]'
+                return l:nearest
+            endif
+        endfor
+        let l:next = fnamemodify(l:nearest, ':p:h:h')
+        let l:nearest = s:nearest_cargo(0, l:next)
+    endwhile
+    return ''
+endfunction
+
+function! cargo#nearestRootCargo(is_getcwd) abort
+    " Try to find a workspace Cargo.toml, and if not found, take the nearest
+    " regular Cargo.toml
+    let l:workspace_cargo = cargo#nearestWorkspaceCargo(a:is_getcwd)
+    if l:workspace_cargo !=# ''
+        return l:workspace_cargo
+    endif
+    return s:nearest_cargo(a:is_getcwd)
+endfunction
+
+
+function! cargo#build(args)
+    call cargo#cmd("build " . a:args)
+endfunction
+
+function! cargo#check(args)
+    call cargo#cmd("check " . a:args)
+endfunction
+
+function! cargo#clean(args)
+    call cargo#cmd("clean " . a:args)
+endfunction
+
+function! cargo#doc(args)
+    call cargo#cmd("doc " . a:args)
+endfunction
+
+function! cargo#new(args)
+    call cargo#cmd("new " . a:args)
+    cd `=a:args`
+endfunction
+
+function! cargo#init(args)
+    call cargo#cmd("init " . a:args)
+endfunction
+
+function! cargo#run(args)
+    call cargo#cmd("run " . a:args)
+endfunction
+
+function! cargo#test(args)
+    call cargo#cmd("test " . a:args)
+endfunction
+
+function! cargo#bench(args)
+    call cargo#cmd("bench " . a:args)
+endfunction
+
+function! cargo#update(args)
+    call cargo#cmd("update " . a:args)
+endfunction
+
+function! cargo#search(args)
+    call cargo#cmd("search " . a:args)
+endfunction
+
+function! cargo#publish(args)
+    call cargo#cmd("publish " . a:args)
+endfunction
+
+function! cargo#install(args)
+    call cargo#cmd("install " . a:args)
+endfunction
+
+function! cargo#runtarget(args)
+    let l:filename = expand('%:p')
+    let l:read_manifest = system('cargo read-manifest')
+    let l:metadata = json_decode(l:read_manifest)
+    let l:targets = get(l:metadata, 'targets', [])
+    let l:did_run = 0
+    for l:target in l:targets
+        let l:src_path = get(l:target, 'src_path', '')
+        let l:kinds = get(l:target, 'kind', [])
+        let l:name = get(l:target, 'name', '')
+        if l:src_path == l:filename
+        if index(l:kinds, 'example') != -1
+            let l:did_run = 1
+            call cargo#run("--example " . shellescape(l:name) . " " . a:args)
+            return
+        elseif index(l:kinds, 'bin') != -1
+            let l:did_run = 1
+            call cargo#run("--bin " . shellescape(l:name) . " " . a:args)
+            return
+        endif
+        endif
+    endfor
+    if l:did_run != 1
+        call cargo#run(a:args)
+        return
+    endif
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:
+
+endif

autoload/cargo/quickfix.vim

@@ -0,0 +1,30 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+
+function! cargo#quickfix#CmdPre() abort
+    if &filetype ==# 'rust' && get(b:, 'current_compiler', '') ==# 'cargo'
+        " Preserve the current directory, and 'lcd' to the nearest Cargo file.
+        let b:rust_compiler_cargo_qf_has_lcd = haslocaldir()
+        let b:rust_compiler_cargo_qf_prev_cd = getcwd()
+        let b:rust_compiler_cargo_qf_prev_cd_saved = 1
+        let l:nearest = fnamemodify(cargo#nearestRootCargo(0), ':h')
+        execute 'lchdir! '.l:nearest
+    else
+        let b:rust_compiler_cargo_qf_prev_cd_saved = 0
+    endif
+endfunction
+
+function! cargo#quickfix#CmdPost() abort
+    if exists("b:rust_compiler_cargo_qf_prev_cd_saved") && b:rust_compiler_cargo_qf_prev_cd_saved
+        " Restore the current directory.
+        if b:rust_compiler_cargo_qf_has_lcd
+            execute 'lchdir! '.b:rust_compiler_cargo_qf_prev_cd
+        else
+            execute 'chdir! '.b:rust_compiler_cargo_qf_prev_cd
+        endif
+        let b:rust_compiler_cargo_qf_prev_cd_saved = 0
+    endif
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:
+
+endif

autoload/crystal/indent.vim

@@ -0,0 +1,367 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
+
+" Variables {{{1
+" =========
+
+" Regex of syntax group names that are strings or characters.
+let g:crystal#indent#syng_string =
+      \ '\<crystal\%(String\|Interpolation\|NoInterpolation\|StringEscape\|CharLiteral\|ASCIICode\)\>'
+lockvar g:crystal#indent#syng_string
+
+" Regex of syntax group names that are strings, characters, symbols,
+" regexps, or comments.
+let g:crystal#indent#syng_strcom =
+      \ g:crystal#indent#syng_string.'\|' .
+      \ '\<crystal\%(Regexp\|RegexpEscape\|Symbol\|Comment\)\>'
+lockvar g:crystal#indent#syng_strcom
+
+" Expression used to check whether we should skip a match with searchpair().
+let g:crystal#indent#skip_expr =
+      \ 'synIDattr(synID(line("."), col("."), 1), "name") =~# "'.g:crystal#indent#syng_strcom.'"'
+lockvar g:crystal#indent#skip_expr
+
+" Regex for the start of a line:
+" start of line + whitespace + optional opening macro delimiter
+let g:crystal#indent#sol = '^\s*\zs\%(\\\={%\s*\)\='
+lockvar g:crystal#indent#sol
+
+" Regex for the end of a line:
+" whitespace + optional closing macro delimiter + whitespace +
+" optional comment + end of line
+let g:crystal#indent#eol = '\s*\%(%}\)\=\ze\s*\%(#.*\)\=$'
+lockvar g:crystal#indent#eol
+
+" Regex that defines blocks.
+let g:crystal#indent#block_regex =
+      \ '\%(\<do\>\|%\@1<!{\)\s*\%(|[^|]*|\)\='.g:crystal#indent#eol
+lockvar g:crystal#indent#block_regex
+
+" Regex that defines the start-match for the 'end' keyword.
+" NOTE: This *should* properly match the 'do' only at the end of the
+" line
+let g:crystal#indent#end_start_regex =
+      \ g:crystal#indent#sol .
+      \ '\%(' .
+      \ '\%(\<\%(private\|protected\)\s\+\)\=' .
+      \ '\%(\<\%(abstract\s\+\)\=\%(class\|struct\)\>\|\<\%(def\|module\|macro\|lib\|enum\)\>\)' .
+      \ '\|' .
+      \ '\<\%(if\|unless\|while\|until\|case\|begin\|for\|union\)\>' .
+      \ '\)' .
+      \ '\|' .
+      \ g:crystal#indent#block_regex
+lockvar g:crystal#indent#end_start_regex
+
+" Regex that defines the middle-match for the 'end' keyword.
+let g:crystal#indent#end_middle_regex =
+      \ g:crystal#indent#sol .
+      \ '\<\%(else\|elsif\|rescue\|ensure\|when\)\>'
+lockvar g:crystal#indent#end_middle_regex
+
+" Regex that defines the end-match for the 'end' keyword.
+let g:crystal#indent#end_end_regex =
+      \ g:crystal#indent#sol .
+      \ '\<end\>'
+lockvar g:crystal#indent#end_end_regex
+
+" Regex used for words that add a level of indent.
+let g:crystal#indent#crystal_indent_keywords =
+      \ g:crystal#indent#end_start_regex .
+      \ '\|' .
+      \ g:crystal#indent#end_middle_regex
+lockvar g:crystal#indent#crystal_indent_keywords
+
+" Regex used for words that remove a level of indent.
+let g:crystal#indent#crystal_deindent_keywords =
+      \ g:crystal#indent#end_middle_regex .
+      \ '\|' .
+      \ g:crystal#indent#end_end_regex
+lockvar g:crystal#indent#crystal_deindent_keywords
+
+" Regex that defines a type declaration
+let g:crystal#indent#crystal_type_declaration =
+      \ '@\=\h\k*\s\+:\s\+\S.*'
+lockvar g:crystal#indent#crystal_type_declaration
+
+" Regex that defines continuation lines, not including (, {, or [.
+let g:crystal#indent#non_bracket_continuation_regex =
+      \ '\%(' .
+      \ '[\\.,:/%+\-=~<>&^]' .
+      \ '\|' .
+      \ '\%(\%(\<do\>\|%\@1<!{\)\s*|[^|]*\)\@<!|' .
+      \ '\|' .
+      \ '\W?' .
+      \ '\|' .
+      \ '\<\%(if\|unless\)\>' .
+      \ '\|' .
+      \ '\%('.g:crystal#indent#crystal_type_declaration.'\h\k*\)\@<!\*' .
+      \ '\)' .
+      \ g:crystal#indent#eol
+lockvar g:crystal#indent#non_bracket_continuation_regex
+
+" Regex that defines bracket continuations
+let g:crystal#indent#bracket_continuation_regex = '%\@1<!\%([({[]\)\s*\%(#.*\)\=$'
+lockvar g:crystal#indent#bracket_continuation_regex
+
+" Regex that defines continuation lines.
+let g:crystal#indent#continuation_regex =
+      \ g:crystal#indent#non_bracket_continuation_regex .
+      \ '\|' .
+      \ g:crystal#indent#bracket_continuation_regex
+lockvar g:crystal#indent#continuation_regex
+
+" Regex that defines end of bracket continuation followed by another continuation
+let g:crystal#indent#bracket_switch_continuation_regex =
+      \ '^\([^(]\+\zs).\+\)\+'.g:crystal#indent#continuation_regex
+lockvar g:crystal#indent#bracket_switch_continuation_regex
+
+" Regex that defines continuable keywords
+let g:crystal#indent#continuable_regex =
+      \ '\%(^\s*\|[=,*/%+\-|;{]\|<<\|>>\|:\s\)\s*\zs' .
+      \ '\<\%(if\|for\|while\|until\|unless\):\@!\>'
+lockvar g:crystal#indent#continuable_regex
+
+" Regex that defines the first part of a splat pattern
+let g:crystal#indent#splat_regex = '[[,(]\s*\*\s*\%(#.*\)\=$'
+lockvar g:crystal#indent#splat_regex
+
+let g:crystal#indent#block_continuation_regex = '^\s*[^])}\t ].*'.g:crystal#indent#block_regex
+lockvar g:crystal#indent#block_continuation_regex
+
+" Regex that describes a leading operator (only a method call's dot for now)
+let g:crystal#indent#leading_operator_regex = '^\s*[.]'
+lockvar g:crystal#indent#leading_operator_regex
+
+" Auxiliary Functions {{{1
+" ===================
+
+" Check if the character at lnum:col is inside a string, comment, or is ascii.
+function! crystal#indent#IsInStringOrComment(lnum, col) abort
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~# g:crystal#indent#syng_strcom
+endfunction
+
+" Check if the character at lnum:col is inside a string or character.
+function! crystal#indent#IsInString(lnum, col) abort
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~# g:crystal#indent#syng_string
+endfunction
+
+" Check if the character at lnum:col is inside a string or regexp
+" delimiter
+function! crystal#indent#IsInStringDelimiter(lnum, col) abort
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~# '\<crystal\%(StringDelimiter\|RegexpDelimiter\)\>'
+endfunction
+
+" Find line above 'lnum' that isn't empty, in a comment, or in a string.
+function! crystal#indent#PrevNonBlankNonString(lnum) abort
+  let lnum = prevnonblank(a:lnum)
+
+  while lnum > 0
+    let line = getline(lnum)
+    let start = match(line, '\S')
+
+    if !crystal#indent#IsInStringOrComment(lnum, start + 1)
+      break
+    endif
+
+    let lnum = prevnonblank(lnum - 1)
+  endwhile
+
+  return lnum
+endfunction
+
+" Find line above 'lnum' that started the continuation 'lnum' may be part of.
+function! crystal#indent#GetMSL(lnum) abort
+  " Start on the line we're at and use its indent.
+  let msl = a:lnum
+  let msl_body = getline(msl)
+  let lnum = crystal#indent#PrevNonBlankNonString(a:lnum - 1)
+
+  while lnum > 0
+    " If we have a continuation line, or we're in a string, use line as MSL.
+    " Otherwise, terminate search as we have found our MSL already.
+    let line = getline(lnum)
+
+    if crystal#indent#Match(msl, g:crystal#indent#leading_operator_regex)
+      " If the current line starts with a leading operator, keep its indent
+      " and keep looking for an MSL.
+      let msl = lnum
+    elseif crystal#indent#Match(lnum, g:crystal#indent#splat_regex)
+      " If the above line looks like the "*" of a splat, use the current one's
+      " indentation.
+      "
+      " Example:
+      "   Hash[*
+      "     method_call do
+      "       something
+      "
+      return msl
+    elseif crystal#indent#Match(lnum, g:crystal#indent#non_bracket_continuation_regex) &&
+          \ crystal#indent#Match(msl, g:crystal#indent#non_bracket_continuation_regex)
+      " If the current line is a non-bracket continuation and so is the
+      " previous one, keep its indent and continue looking for an MSL.
+      "
+      " Example:
+      "   method_call one,
+      "     two,
+      "     three
+      "
+      let msl = lnum
+    elseif crystal#indent#Match(lnum, g:crystal#indent#non_bracket_continuation_regex) &&
+          \ (
+          \ crystal#indent#Match(msl, g:crystal#indent#bracket_continuation_regex) ||
+          \ crystal#indent#Match(msl, g:crystal#indent#block_continuation_regex)
+          \ )
+      " If the current line is a bracket continuation or a block-starter, but
+      " the previous is a non-bracket one, respect the previous' indentation,
+      " and stop here.
+      "
+      " Example:
+      "   method_call one,
+      "     two {
+      "     three
+      "
+      return lnum
+    elseif crystal#indent#Match(lnum, g:crystal#indent#bracket_continuation_regex) &&
+          \ (
+          \ crystal#indent#Match(msl, g:crystal#indent#bracket_continuation_regex) ||
+          \ crystal#indent#Match(msl, g:crystal#indent#block_continuation_regex)
+          \ )
+      " If both lines are bracket continuations (the current may also be a
+      " block-starter), use the current one's and stop here
+      "
+      " Example:
+      "   method_call(
+      "     other_method_call(
+      "       foo
+      return msl
+    elseif crystal#indent#Match(lnum, g:crystal#indent#block_regex) &&
+          \ !crystal#indent#Match(msl, g:crystal#indent#continuation_regex) &&
+          \ !crystal#indent#Match(msl, g:crystal#indent#block_continuation_regex)
+      " If the previous line is a block-starter and the current one is
+      " mostly ordinary, use the current one as the MSL.
+      "
+      " Example:
+      "   method_call do
+      "     something
+      "     something_else
+      return msl
+    else
+      let col = match(line, g:crystal#indent#continuation_regex) + 1
+
+      if (col > 0 && !crystal#indent#IsInStringOrComment(lnum, col))
+            \ || crystal#indent#IsInString(lnum, strlen(line))
+        let msl = lnum
+      else
+        break
+      endif
+    endif
+
+    let msl_body = getline(msl)
+    let lnum = crystal#indent#PrevNonBlankNonString(lnum - 1)
+  endwhile
+
+  return msl
+endfunction
+
+" Check if line 'lnum' has more opening brackets than closing ones.
+function! crystal#indent#ExtraBrackets(lnum) abort
+  let opening = {'parentheses': [], 'braces': [], 'brackets': []}
+  let closing = {'parentheses': [], 'braces': [], 'brackets': []}
+
+  let line = getline(a:lnum)
+  let pos  = match(line, '[][(){}]', 0)
+
+  " Save any encountered opening brackets, and remove them once a matching
+  " closing one has been found. If a closing bracket shows up that doesn't
+  " close anything, save it for later.
+  while pos != -1
+    if !crystal#indent#IsInStringOrComment(a:lnum, pos + 1)
+      if line[pos] ==# '('
+        call add(opening.parentheses, {'type': '(', 'pos': pos})
+      elseif line[pos] ==# ')'
+        if empty(opening.parentheses)
+          call add(closing.parentheses, {'type': ')', 'pos': pos})
+        else
+          let opening.parentheses = opening.parentheses[0:-2]
+        endif
+      elseif line[pos] ==# '{'
+        call add(opening.braces, {'type': '{', 'pos': pos})
+      elseif line[pos] ==# '}'
+        if empty(opening.braces)
+          call add(closing.braces, {'type': '}', 'pos': pos})
+        else
+          let opening.braces = opening.braces[0:-2]
+        endif
+      elseif line[pos] ==# '['
+        call add(opening.brackets, {'type': '[', 'pos': pos})
+      elseif line[pos] ==# ']'
+        if empty(opening.brackets)
+          call add(closing.brackets, {'type': ']', 'pos': pos})
+        else
+          let opening.brackets = opening.brackets[0:-2]
+        endif
+      endif
+    endif
+
+    let pos = match(line, '[][(){}]', pos + 1)
+  endwhile
+
+  " Find the rightmost brackets, since they're the ones that are important in
+  " both opening and closing cases
+  let rightmost_opening = {'type': '(', 'pos': -1}
+  let rightmost_closing = {'type': ')', 'pos': -1}
+
+  for opening in opening.parentheses + opening.braces + opening.brackets
+    if opening.pos > rightmost_opening.pos
+      let rightmost_opening = opening
+    endif
+  endfor
+
+  for closing in closing.parentheses + closing.braces + closing.brackets
+    if closing.pos > rightmost_closing.pos
+      let rightmost_closing = closing
+    endif
+  endfor
+
+  return [rightmost_opening, rightmost_closing]
+endfunction
+
+function! crystal#indent#Match(lnum, regex) abort
+  let regex = '\C'.a:regex
+
+  let line = getline(a:lnum)
+  let col  = match(line, regex) + 1
+
+  while col &&
+        \ crystal#indent#IsInStringOrComment(a:lnum, col) ||
+        \ crystal#indent#IsInStringDelimiter(a:lnum, col)
+    let col = match(line, regex, col) + 1
+  endwhile
+
+  return col
+endfunction
+
+" Locates the containing class/module/struct/enum/lib's definition line,
+" ignoring nested classes along the way.
+function! crystal#indent#FindContainingClass() abort
+  let saved_position = getcurpos()
+
+  while searchpair(
+        \ g:crystal#indent#end_start_regex,
+        \ g:crystal#indent#end_middle_regex,
+        \ g:crystal#indent#end_end_regex,
+        \ 'bWz',
+        \ g:crystal#indent#skip_expr) > 0
+    if expand('<cword>') =~# '\<\%(class\|module\|struct\|enum\|lib\)\>'
+      let found_lnum = line('.')
+      call setpos('.', saved_position)
+      return found_lnum
+    endif
+  endwhile
+
+  call setpos('.', saved_position)
+  return 0
+endfunction
+
+" vim: sw=2 sts=2 et:
+
+endif

autoload/crystal_lang.vim

@@ -0,0 +1,373 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+let s:V = vital#crystal#new()
+let s:P = s:V.import('Process')
+let s:C = s:V.import('ColorEcho')
+
+let s:IS_WINDOWS = has('win32')
+
+if exists('*json_decode')
+  function! s:decode_json(text) abort
+    return json_decode(a:text)
+  endfunction
+else
+  let s:J = s:V.import('Web.JSON')
+  function! s:decode_json(text) abort
+    return s:J.decode(a:text)
+  endfunction
+endif
+
+function! s:echo_error(msg, ...) abort
+  echohl ErrorMsg
+  if a:0 == 0
+    echomsg a:msg
+  else
+    echomsg call('printf', [a:msg] + a:000)
+  endif
+  echohl None
+endfunction
+
+function! s:run_cmd(cmd) abort
+  if !executable(g:crystal_compiler_command)
+    throw "vim-crystal: Error: '" . g:crystal_compiler_command . "' command is not found."
+  endif
+  return s:P.system(a:cmd)
+endfunction
+
+function! s:find_root_by(search_dir, d) abort
+  let found_dir = finddir(a:search_dir, a:d . ';')
+  if found_dir ==# ''
+    return ''
+  endif
+
+  " Note: ':h:h' for {root}/{search_dir}/ -> {root}/{search_dir} -> {root}
+  return fnamemodify(found_dir, ':p:h:h')
+endfunction
+
+" Search the root directory containing a 'spec/' and a 'src/' directories.
+"
+" Searching for the 'spec/' directory is not enough: for example the crystal
+" compiler has a 'cr_sources/src/spec/' directory that would otherwise give the root
+" directory as 'cr_source/src/' instead of 'cr_sources/'.
+function! s:find_root_by_spec_and_src(d) abort
+  " Search for 'spec/'
+  let root = s:find_root_by('spec', a:d)
+  " Check that 'src/' is also there
+  if root !=# '' && isdirectory(root . '/src')
+    return root
+  endif
+
+  " Search for 'src/'
+  let root = s:find_root_by('src', a:d)
+  " Check that 'spec/' is also there
+  if root !=# '' && isdirectory(root . '/spec')
+    return root
+  endif
+
+  " Cannot find a directory containing both 'src/' and 'spec/'
+  return ''
+endfunction
+
+function! crystal_lang#entrypoint_for(file_path) abort
+  let parent_dir = fnamemodify(a:file_path, ':p:h')
+  let root_dir = s:find_root_by_spec_and_src(parent_dir)
+  if root_dir ==# ''
+    " No spec directory found. No need to make temporary file
+    return a:file_path
+  endif
+
+  let required_spec_path = get(b:, 'crystal_required_spec_path', get(g:, 'crystal_required_spec_path', ''))
+  if required_spec_path !=# ''
+    let require_spec_str = './' . required_spec_path
+  else
+    let require_spec_str = './spec/**'
+  endif
+
+  let temp_name = root_dir . '/__vim-crystal-temporary-entrypoint-' . fnamemodify(a:file_path, ':t')
+  let contents = [
+        \   'require "spec"',
+        \   'require "' . require_spec_str . '"',
+        \   printf('require "./%s"', fnamemodify(a:file_path, ':p')[strlen(root_dir)+1 : ])
+        \ ]
+
+  let result = writefile(contents, temp_name)
+  if result == -1
+    " Note: When writefile() failed
+    return a:file_path
+  endif
+
+  return temp_name
+endfunction
+
+function! crystal_lang#tool(name, file, pos, option_str) abort
+  let entrypoint = crystal_lang#entrypoint_for(a:file)
+  let cmd = printf(
+        \   '%s tool %s --no-color %s --cursor %s:%d:%d %s',
+        \   g:crystal_compiler_command,
+        \   a:name,
+        \   a:option_str,
+        \   a:file,
+        \   a:pos[1],
+        \   a:pos[2],
+        \   entrypoint
+        \ )
+
+  try
+    let output = s:run_cmd(cmd)
+    return {'failed': s:P.get_last_status(), 'output': output}
+  finally
+    " Note:
+    " If the entry point is temporary file, delete it finally.
+    if a:file !=# entrypoint
+      call delete(entrypoint)
+    endif
+  endtry
+endfunction
+
+" `pos` is assumed a returned value from getpos()
+function! crystal_lang#impl(file, pos, option_str) abort
+  return crystal_lang#tool('implementations', a:file, a:pos, a:option_str)
+endfunction
+
+function! s:jump_to_impl(impl) abort
+  execute 'edit' a:impl.filename
+  call cursor(a:impl.line, a:impl.column)
+endfunction
+
+function! crystal_lang#jump_to_definition(file, pos) abort
+  echo 'analyzing definitions under cursor...'
+
+  let cmd_result = crystal_lang#impl(a:file, a:pos, '--format json')
+  if cmd_result.failed
+    return s:echo_error(cmd_result.output)
+  endif
+
+  let impl = s:decode_json(cmd_result.output)
+  if impl.status !=# 'ok'
+    return s:echo_error(impl.message)
+  endif
+
+  if len(impl.implementations) == 1
+    call s:jump_to_impl(impl.implementations[0])
+    return
+  endif
+
+  let message = "Multiple definitions detected.  Choose a number\n\n"
+  for idx in range(len(impl.implementations))
+    let i = impl.implementations[idx]
+    let message .= printf("[%d] %s:%d:%d\n", idx, i.filename, i.line, i.column)
+  endfor
+  let message .= "\n"
+  let idx = str2nr(input(message, "\n> "))
+  call s:jump_to_impl(impl.implementations[idx])
+endfunction
+
+function! crystal_lang#context(file, pos, option_str) abort
+  return crystal_lang#tool('context', a:file, a:pos, a:option_str)
+endfunction
+
+function! crystal_lang#type_hierarchy(file, option_str) abort
+  let cmd = printf(
+        \   '%s tool hierarchy --no-color %s %s',
+        \   g:crystal_compiler_command,
+        \   a:option_str,
+        \   a:file
+        \ )
+
+  return s:run_cmd(cmd)
+endfunction
+
+function! s:find_completion_start() abort
+  let c = col('.')
+  if c <= 1
+    return -1
+  endif
+
+  let line = getline('.')[:c-2]
+  return match(line, '\w\+$')
+endfunction
+
+function! crystal_lang#complete(findstart, base) abort
+  if a:findstart
+    return s:find_completion_start()
+  endif
+
+  let cmd_result = crystal_lang#context(expand('%'), getpos('.'), '--format json')
+  if cmd_result.failed
+    return
+  endif
+
+  let contexts = s:decode_json(cmd_result.output)
+  if contexts.status !=# 'ok'
+    return
+  endif
+
+  let candidates = []
+
+  for c in contexts.contexts
+    for [name, desc] in items(c)
+      let candidates += [{
+            \   'word': name,
+            \   'menu': ': ' . desc . ' [var]',
+            \ }]
+    endfor
+  endfor
+
+  return candidates
+endfunction
+
+function! crystal_lang#get_spec_switched_path(absolute_path) abort
+  let base = fnamemodify(a:absolute_path, ':t:r')
+
+  " TODO: Make cleverer
+  if base =~# '_spec$'
+    let parent = fnamemodify(substitute(a:absolute_path, '/spec/', '/src/', ''), ':h')
+    return parent . '/' . matchstr(base, '.\+\ze_spec$') . '.cr'
+  else
+    let parent = fnamemodify(substitute(a:absolute_path, '/src/', '/spec/', ''), ':h')
+    return parent . '/' . base . '_spec.cr'
+  endif
+endfunction
+
+function! crystal_lang#switch_spec_file(...) abort
+  let path = a:0 == 0 ? expand('%:p') : fnamemodify(a:1, ':p')
+  if path !~# '.cr$'
+    return s:echo_error('Not crystal source file: ' . path)
+  endif
+
+  execute 'edit!' crystal_lang#get_spec_switched_path(path)
+endfunction
+
+function! s:run_spec(root, path, ...) abort
+  " Note:
+  " `crystal spec` can't understand absolute path.
+  let cmd = printf(
+        \   '%s spec %s%s',
+        \   g:crystal_compiler_command,
+        \   a:path,
+        \   a:0 == 0 ? '' : (':' . a:1)
+        \ )
+
+  let saved_cwd = getcwd()
+  let cd = haslocaldir() ? 'lcd' : 'cd'
+  try
+    execute cd a:root
+    call s:C.echo(s:run_cmd(cmd))
+  finally
+    execute cd saved_cwd
+  endtry
+endfunction
+
+function! crystal_lang#run_all_spec(...) abort
+  let path = a:0 == 0 ? expand('%:p:h') : a:1
+  let root_path = s:find_root_by_spec_and_src(path)
+  if root_path ==# ''
+    return s:echo_error("'spec' directory is not found")
+  endif
+  call s:run_spec(root_path, 'spec')
+endfunction
+
+function! crystal_lang#run_current_spec(...) abort
+  " /foo/bar/src/poyo.cr
+  let path = a:0 == 0 ? expand('%:p') : fnamemodify(a:1, ':p')
+  if path !~# '.cr$'
+    return s:echo_error('Not crystal source file: ' . path)
+  endif
+
+  " /foo/bar/src
+  let source_dir = fnamemodify(path, ':h')
+
+  " /foo/bar
+  let root_dir = s:find_root_by_spec_and_src(source_dir)
+  if root_dir ==# ''
+    return s:echo_error("Root directory with 'src/' and 'spec/' not found")
+  endif
+
+  " src
+  let rel_path = source_dir[strlen(root_dir)+1 : ]
+
+  if path =~# '_spec.cr$'
+    call s:run_spec(root_dir, path[strlen(root_dir)+1 : ], line('.'))
+  else
+    let spec_path = substitute(rel_path, '^src', 'spec', '') . '/' . fnamemodify(path, ':t:r') . '_spec.cr'
+    if !filereadable(root_dir . '/' . spec_path)
+      return s:echo_error('Error: Could not find a spec source corresponding to ' . path)
+    endif
+    call s:run_spec(root_dir, spec_path)
+  endif
+endfunction
+
+function! crystal_lang#format_string(code, ...) abort
+  if s:IS_WINDOWS
+    let redirect = '2> nul'
+  else
+    let redirect = '2>/dev/null'
+  endif
+  let cmd = printf(
+        \   '%s tool format --no-color %s - %s',
+        \   g:crystal_compiler_command,
+        \   get(a:, 1, ''),
+        \   redirect,
+        \ )
+  let output = s:P.system(cmd, a:code)
+  if s:P.get_last_status()
+    throw 'vim-crystal: Error on formatting with command: ' . cmd
+  endif
+  return output
+endfunction
+
+" crystal_lang#format(option_str [, on_save])
+function! crystal_lang#format(option_str, ...) abort
+  let on_save = a:0 > 0 ? a:1 : 0
+
+  if !executable(g:crystal_compiler_command)
+    if on_save
+      " Finish command silently on save
+      return
+    else
+      throw 'vim-crystal: Command for formatting is not executable: ' . g:crystal_compiler_command
+    endif
+  endif
+
+  let before = join(getline(1, '$'), "\n")
+  try
+    let formatted = crystal_lang#format_string(before, a:option_str)
+  catch /^vim-crystal: /
+    echohl ErrorMsg
+    echomsg v:exception . ': Your code was not formatted. Exception was thrown at ' . v:throwpoint
+    echohl None
+    return
+  endtry
+
+  if !on_save
+    let after = substitute(formatted, '\n$', '', '')
+    if before ==# after
+      return
+    endif
+  endif
+
+  let view_save = winsaveview()
+  let pos_save = getpos('.')
+  let lines = split(formatted, '\n')
+  silent! undojoin
+  if line('$') > len(lines)
+    execute len(lines) . ',$delete' '_'
+  endif
+  call setline(1, lines)
+  call winrestview(view_save)
+  call setpos('.', pos_save)
+endfunction
+
+function! crystal_lang#expand(file, pos, ...) abort
+  return crystal_lang#tool('expand', a:file, a:pos, get(a:, 1, ''))
+endfunction
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: sw=2 sts=2 et:
+
+endif

autoload/dart.vim

@@ -7,64 +7,177 @@ function! s:error(text) abort
   echohl None
 endfunction
 
-function! s:cexpr(errorformat, joined_lines) abort
-  let temp_errorfomat = &errorformat
-  try
-    let &errorformat = a:errorformat
-    cexpr a:joined_lines
+function! s:cexpr(errorformat, lines, reason) abort
+  call setqflist([], ' ', {
+      \ 'lines': a:lines,
+      \ 'efm': a:errorformat,
+      \ 'context': {'reason': a:reason},
+      \})
   copen
-  finally
-    let &errorformat = temp_errorfomat
-  endtry
+endfunction
+
+" If the quickfix list has a context matching [reason], clear and close it.
+function! s:clearQfList(reason) abort
+  let context = get(getqflist({'context': 1}), 'context', {})
+  if type(context) == v:t_dict &&
+      \ has_key(context, 'reason') &&
+      \ context.reason == a:reason
+    call setqflist([], 'r')
+    cclose
+  endif
 endfunction
 
 function! dart#fmt(q_args) abort
-  if executable('dartfmt')
-    let path = expand('%:p:gs:\:/:')
-    if filereadable(path)
-      let joined_lines = system(printf('dartfmt %s %s', a:q_args, shellescape(path)))
+  let cmd = s:FindDartFmt()
+  if type(cmd) != type('') | return | endif
+  let buffer_content = getline(1, '$')
+  let args = '--stdin-name '.expand('%').' '.a:q_args
+  let lines = systemlist(printf('%s %s', cmd, args), join(buffer_content, "\n"))
+  " TODO(https://github.com/dart-lang/sdk/issues/38507) - Remove once the
+  " tool no longer emits this line on SDK upgrades.
+  if lines[-1] ==# 'Isolate creation failed'
+    let lines = lines[:-2]
+  endif
+  if buffer_content == lines
+    call s:clearQfList('dartfmt')
+    return
+  endif
   if 0 == v:shell_error
-        silent % delete _
-        silent put=joined_lines
-        silent 1 delete _
-      else
-        call s:cexpr('line %l\, column %c of %f: %m', joined_lines)
+    let win_view = winsaveview()
+    silent keepjumps call setline(1, lines)
+    if line('$') > len(lines)
+      silent keepjumps execute string(len(lines)+1).',$ delete'
     endif
+    call winrestview(win_view)
+    call s:clearQfList('dartfmt')
   else
-      call s:error(printf('cannot read a file: "%s"', path))
+    let errors = lines[2:]
+    let error_format = '%Aline %l\, column %c of %f: %m,%C%.%#'
+    call s:cexpr(error_format, errors, 'dartfmt')
   endif
-  else
-    call s:error('cannot execute binary file: dartfmt')
+endfunction
+
+function! s:FindDartFmt() abort
+  if executable('dartfmt') | return 'dartfmt' | endif
+  if executable('flutter')
+    let l:flutter_cmd = resolve(exepath('flutter'))
+    let l:bin = fnamemodify(l:flutter_cmd, ':h')
+    let l:dartfmt = l:bin.'/cache/dart-sdk/bin/dartfmt'
+    if executable(l:dartfmt) | return l:dartfmt | endif
   endif
+  call s:error('Cannot find a `dartfmt` command')
 endfunction
 
 function! dart#analyzer(q_args) abort
-  if executable('dartanalyzer')
-    let path = expand('%:p:gs:\:/:')
-    if filereadable(path)
-      let joined_lines = system(printf('dartanalyzer %s %s', a:q_args, shellescape(path)))
-      call s:cexpr('%m (%f\, line %l\, col %c)', joined_lines)
-    else
-      call s:error(printf('cannot read a file: "%s"', path))
-    endif
-  else
-    call s:error('cannot execute binary file: dartanalyzer')
-  endif
+  call s:error('DartAnalyzer support has been removed. '.
+      \'If this broke your workflow please comment on '.
+      \'https://github.com/dart-lang/dart-vim-plugin/issues/89')
 endfunction
 
 function! dart#tojs(q_args) abort
-  if executable('dart2js')
-    let path = expand('%:p:gs:\:/:')
-    if filereadable(path)
-      let joined_lines = system(printf('dart2js %s %s', a:q_args, shellescape(path)))
-      call s:cexpr('%m (%f\, line %l\, col %c)', joined_lines)
-    else
-      call s:error(printf('cannot read a file: "%s"', path))
+  call s:error('Dart2JS support has been removed. '.
+      \'If this broke your workflow please comment on '.
+      \'https://github.com/dart-lang/dart-vim-plugin/issues/89')
+endfunction
+
+" Finds the path to `uri`.
+"
+" If the file is a package: uri, looks for a .packages file to resolve the path.
+" If the path cannot be resolved, or is not a package: uri, returns the
+" original.
+function! dart#resolveUri(uri) abort
+  if a:uri !~# 'package:'
+    return a:uri
+  endif
+  let package_name = substitute(a:uri, 'package:\(\w\+\)\/.*', '\1', '')
+  let [found, package_map] = s:PackageMap()
+  if !found
+    call s:error('cannot find .packages file')
+    return a:uri
+  endif
+  if !has_key(package_map, package_name)
+    call s:error('no package mapping for '.package_name)
+    return a:uri
+  endif
+  let package_lib = package_map[package_name]
+  return substitute(a:uri,
+      \ 'package:'.package_name,
+      \ escape(package_map[package_name], '\'),
+      \ '')
+endfunction
+
+" A map from package name to lib directory parse from a '.packages' file.
+"
+" Returns [found, package_map]
+function! s:PackageMap() abort
+  let [found, dot_packages] = s:DotPackagesFile()
+  if !found
+    return [v:false, {}]
+  endif
+  let dot_packages_dir = fnamemodify(dot_packages, ':p:h')
+  let lines = readfile(dot_packages)
+  let map = {}
+  for line in lines
+    if line =~# '\s*#'
+      continue
+    endif
+    let package = substitute(line, ':.*$', '', '')
+    let lib_dir = substitute(line, '^[^:]*:', '', '')
+    if lib_dir =~# 'file:/'
+      let lib_dir = substitute(lib_dir, 'file://', '', '')
+      if lib_dir =~# '/[A-Z]:/'
+        let lib_dir = lib_dir[1:]
       endif
     else
-    call s:error('cannot execute binary file: dartanalyzer')
+      let lib_dir = resolve(dot_packages_dir.'/'.lib_dir)
+    endif
+    if lib_dir =~# '/$'
+      let lib_dir = lib_dir[:len(lib_dir) - 2]
+    endif
+    let map[package] = lib_dir
+  endfor
+  return [v:true, map]
+endfunction
+
+" Toggle whether dartfmt is run on save or not.
+function! dart#ToggleFormatOnSave() abort
+  if get(g:, 'dart_format_on_save', 0)
+    let g:dart_format_on_save = 0
+    return
+  endif
+  let g:dart_format_on_save = 1
+endfunction
+
+" Finds a file name '.packages' in the cwd, or in any directory above the open
+" file.
+"
+" Returns [found, file].
+function! s:DotPackagesFile() abort
+  if filereadable('.packages')
+    return [v:true, '.packages']
+  endif
+  let dir_path = expand('%:p:h')
+  while v:true
+    let file_path = dir_path.'/.packages'
+    if filereadable(file_path)
+      return [v:true, file_path]
+    endif
+    let parent = fnamemodify(dir_path, ':h')
+    if dir_path == parent
+      break
+    endif
+    let dir_path = parent
+  endwhile
+  return [v:false, '']
+endfunction
+
+" Prevent writes to files in the pub cache.
+function! dart#setModifiable() abort
+  let full_path = expand('%:p')
+  if full_path =~# '.pub-cache' ||
+      \ full_path =~# 'Pub\Cache'
+    setlocal nomodifiable
   endif
 endfunction
 
-
 endif

autoload/db/adapter/ecto.vim

@@ -0,0 +1,24 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elixir') == -1
+
+let s:path = expand('<sfile>:h')
+let s:cmd = join(['mix', 'run', '--no-start', '--no-compile', shellescape(s:path.'/get_repos.exs')])
+
+function! s:repo_list() abort
+    return map(systemlist(s:cmd), 'split(v:val)')
+endfunction
+
+function! db#adapter#ecto#canonicalize(url) abort
+    for l:item in s:repo_list()
+        let l:name = get(l:item, 0)
+        let l:url = get(l:item, 1)
+        if !empty(l:name) && 'ecto:'.l:name ==# a:url
+            return l:url
+        endif
+    endfor
+endfunction
+
+function! db#adapter#ecto#complete_opaque(url) abort
+    return map(s:repo_list(), 'v:val[0]')
+endfunction
+
+endif

autoload/ecrystal.vim

@@ -0,0 +1,36 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'crystal') == -1
+
+let s:ecrystal_extensions = {
+      \ 'cr': 'crystal',
+      \ 'yml': 'yaml',
+      \ 'js': 'javascript',
+      \ 'txt': 'text',
+      \ 'md': 'markdown'
+      \ }
+
+if exists('g:ecrystal_extensions')
+  call extend(s:ecrystal_extensions, g:ecrystal_extensions, 'force')
+endif
+
+function! ecrystal#SetSubtype() abort
+  if exists('b:ecrystal_subtype')
+    return
+  endif
+
+  let b:ecrystal_subtype = matchstr(substitute(expand('%:t'), '\c\%(\.ecr\)\+$', '', ''), '\.\zs\w\+\%(\ze+\w\+\)\=$')
+
+  let b:ecrystal_subtype = get(s:ecrystal_extensions, b:ecrystal_subtype, b:ecrystal_subtype)
+
+  if b:ecrystal_subtype ==# ''
+    let b:ecrystal_subtype = get(g:, 'ecrystal_default_subtype', 'html')
+  endif
+
+  if b:ecrystal_subtype !=# ''
+    exec 'setlocal filetype=ecrystal.' . b:ecrystal_subtype
+    exec 'setlocal syntax=ecrystal.' . b:ecrystal_subtype
+  endif
+endfunction
+
+" vim: sw=2 sts=2 et:
+
+endif

autoload/elixir/indent.vim

@@ -0,0 +1,365 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elixir') == -1
+
+if !exists("g:elixir_indent_max_lookbehind")
+  let g:elixir_indent_max_lookbehind = 30
+endif
+
+" Return the effective value of 'shiftwidth'
+function! s:sw()
+  return &shiftwidth == 0 ? &tabstop : &shiftwidth
+endfunction
+
+function! elixir#indent#indent(lnum)
+  let lnum = a:lnum
+  let text = getline(lnum)
+  let prev_nb_lnum = prevnonblank(lnum-1)
+  let prev_nb_text = getline(prev_nb_lnum)
+
+  call s:debug("==> Indenting line " . lnum)
+  call s:debug("text = '" . text . "'")
+
+  let [_, curs_lnum, curs_col, _] = getpos('.')
+  call cursor(lnum, 0)
+
+  let handlers = [
+        \'top_of_file',
+        \'starts_with_string_continuation',
+        \'following_trailing_binary_operator',
+        \'starts_with_pipe',
+        \'starts_with_binary_operator',
+        \'inside_block',
+        \'starts_with_end',
+        \'inside_generic_block',
+        \'follow_prev_nb'
+        \]
+  for handler in handlers
+    call s:debug('testing handler elixir#indent#handle_'.handler)
+    let context = {'lnum': lnum, 'text': text, 'first_nb_char_idx': match(text, '\w'), 'prev_nb_lnum': prev_nb_lnum, 'prev_nb_text': prev_nb_text}
+    let indent = function('elixir#indent#handle_'.handler)(context)
+    if indent == -2
+      " Keep indent the same
+      call s:debug('line '.lnum.': elixir#indent#handle_'.handler.' returned -2; returning indent of -1')
+      call cursor(curs_lnum, curs_col)
+      return -1
+    elseif indent != -1
+      call s:debug('line '.lnum.': elixir#indent#handle_'.handler.' returned '.indent)
+      call cursor(curs_lnum, curs_col)
+      return indent
+    endif
+  endfor
+
+  call s:debug("defaulting")
+  call cursor(curs_lnum, curs_col)
+  return 0
+endfunction
+
+function! s:debug(str)
+  if exists("g:elixir_indent_debug") && g:elixir_indent_debug
+    echom a:str
+  endif
+endfunction
+
+function! s:starts_with(context, expr)
+  return s:_starts_with(a:context.text, a:expr, a:context.lnum)
+endfunction
+
+function! s:prev_starts_with(context, expr)
+  return s:_starts_with(a:context.prev_nb_text, a:expr, a:context.prev_nb_lnum)
+endfunction
+
+" Returns 0 or 1 based on whether or not the text starts with the given
+" expression and is not a string or comment
+function! s:_starts_with(text, expr, lnum)
+  let pos = match(a:text, '^\s*'.a:expr)
+  if pos == -1
+    return 0
+  else
+    " NOTE: @jbodah 2017-02-24: pos is the index of the match which is
+    " zero-indexed. Add one to make it the column number
+    if s:is_string_or_comment(a:lnum, pos + 1)
+      return 0
+    else
+      return 1
+    end
+  end
+endfunction
+
+function! s:prev_ends_with(context, expr)
+  return s:_ends_with(a:context.prev_nb_text, a:expr, a:context.prev_nb_lnum)
+endfunction
+
+" Returns 0 or 1 based on whether or not the text ends with the given
+" expression and is not a string or comment
+function! s:_ends_with(text, expr, lnum)
+  let pos = match(a:text, a:expr.'\s*$')
+  if pos == -1
+    return 0
+  else
+    if s:is_string_or_comment(a:lnum, pos)
+      return 0
+    else
+      return 1
+    end
+  end
+endfunction
+
+" Returns 0 or 1 based on whether or not the given line number and column
+" number pair is a string or comment
+function! s:is_string_or_comment(line, col)
+  return s:syntax_name(a:line, a:col) =~ '\%(String\|Comment\)'
+endfunction
+
+function! s:syntax_name(line, col)
+  return synIDattr(synID(a:line, a:col, 1), "name")
+endfunction
+
+" Skip expression for searchpair. Returns 0 or 1 based on whether the value
+" under the cursor is a string or comment
+function! elixir#indent#searchpair_back_skip()
+  " NOTE: @jbodah 2017-02-27: for some reason this function gets called with
+  " and index that doesn't exist in the line sometimes. Detect and account for
+  " that situation
+  let curr_col = col('.')
+  if getline('.')[curr_col-1] == ''
+    let curr_col = curr_col-1
+  endif
+  return s:is_string_or_comment(line('.'), curr_col)
+endfunction
+
+" DRY up regex for keywords that 1) makes sure we only look at complete words
+" and 2) ignores atoms
+function! s:keyword(expr)
+  return ':\@<!\<\C\%('.a:expr.'\)\>:\@!'
+endfunction
+
+" Start at the end of text and search backwards looking for a match. Also peek
+" ahead if we get a match to make sure we get a complete match. This means
+" that the result should be the position of the start of the right-most match
+function! s:find_last_pos(lnum, text, match)
+  let last = len(a:text) - 1
+  let c = last
+
+  while c >= 0
+    let substr = strpart(a:text, c, last)
+    let peek = strpart(a:text, c - 1, last)
+    let ss_match = match(substr, a:match)
+    if ss_match != -1
+      let peek_match = match(peek, a:match)
+      if peek_match == ss_match + 1
+        let syng = synIDattr(synID(a:lnum, c + ss_match, 1), 'name')
+        if syng !~ '\%(String\|Comment\)'
+          return c + ss_match
+        end
+      end
+    end
+    let c -= 1
+  endwhile
+
+  return -1
+endfunction
+
+function! elixir#indent#handle_top_of_file(context)
+  if a:context.prev_nb_lnum == 0
+    return 0
+  else
+    return -1
+  end
+endfunction
+
+function! elixir#indent#handle_starts_with_string_continuation(context)
+  if s:syntax_name(a:context.lnum, a:context.first_nb_char_idx) =~ '\(String\|Comment\)$'
+    return -2
+  else
+    return -1
+  end
+endfunction
+
+function! elixir#indent#handle_follow_prev_nb(context)
+  return s:get_base_indent(a:context.prev_nb_lnum, a:context.prev_nb_text)
+endfunction
+
+" Given the line at `lnum`, returns the indent of the line that acts as the 'base indent'
+" for this line. In particular it traverses backwards up things like pipelines
+" to find the beginning of the expression
+function! s:get_base_indent(lnum, text)
+  let prev_nb_lnum = prevnonblank(a:lnum - 1)
+  let prev_nb_text = getline(prev_nb_lnum)
+
+  let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
+  let data_structure_close = '\%(\]\|}\|)\)'
+  let pipe = '|>'
+
+  if s:_starts_with(a:text, binary_operator, a:lnum)
+    return s:get_base_indent(prev_nb_lnum, prev_nb_text)
+  elseif s:_starts_with(a:text, pipe, a:lnum)
+    return s:get_base_indent(prev_nb_lnum, prev_nb_text)
+  elseif s:_ends_with(prev_nb_text, binary_operator, prev_nb_lnum)
+    return s:get_base_indent(prev_nb_lnum, prev_nb_text)
+  elseif s:_ends_with(a:text, data_structure_close, a:lnum)
+    let data_structure_open = '\%(\[\|{\|(\)'
+    let close_match_idx = match(a:text, data_structure_close . '\s*$')
+    call cursor(a:lnum, close_match_idx + 1)
+    let [open_match_lnum, open_match_col] = searchpairpos(data_structure_open, '', data_structure_close, 'bnW')
+    let open_match_text = getline(open_match_lnum)
+    return s:get_base_indent(open_match_lnum, open_match_text)
+  else
+    return indent(a:lnum)
+  endif
+endfunction
+
+function! elixir#indent#handle_following_trailing_binary_operator(context)
+  let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
+
+  if s:prev_ends_with(a:context, binary_operator)
+    return indent(a:context.prev_nb_lnum) + s:sw()
+  else
+    return -1
+  endif
+endfunction
+
+function! elixir#indent#handle_starts_with_pipe(context)
+  if s:starts_with(a:context, '|>')
+    let match_operator = '\%(!\|=\|<\|>\)\@<!=\%(=\|>\|\~\)\@!'
+    let pos = s:find_last_pos(a:context.prev_nb_lnum, a:context.prev_nb_text, match_operator)
+    if pos == -1
+      return indent(a:context.prev_nb_lnum)
+    else
+      let next_word_pos = match(strpart(a:context.prev_nb_text, pos+1, len(a:context.prev_nb_text)-1), '\S')
+      if next_word_pos == -1
+        return indent(a:context.prev_nb_lnum) + s:sw()
+      else
+        return pos + 1 + next_word_pos
+      end
+    end
+  else
+    return -1
+  endif
+endfunction
+
+function! elixir#indent#handle_starts_with_end(context)
+  if s:starts_with(a:context, s:keyword('end'))
+    let pair_lnum = searchpair(s:keyword('do\|fn'), '', s:keyword('end').'\zs', 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()")
+    return indent(pair_lnum)
+  else
+    return -1
+  endif
+endfunction
+
+function! elixir#indent#handle_starts_with_binary_operator(context)
+  let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
+
+  if s:starts_with(a:context, binary_operator)
+    let match_operator = '\%(!\|=\|<\|>\)\@<!=\%(=\|>\|\~\)\@!'
+    let pos = s:find_last_pos(a:context.prev_nb_lnum, a:context.prev_nb_text, match_operator)
+    if pos == -1
+      return indent(a:context.prev_nb_lnum)
+    else
+      let next_word_pos = match(strpart(a:context.prev_nb_text, pos+1, len(a:context.prev_nb_text)-1), '\S')
+      if next_word_pos == -1
+        return indent(a:context.prev_nb_lnum) + s:sw()
+      else
+        return pos + 1 + next_word_pos
+      end
+    end
+  else
+    return -1
+  endif
+endfunction
+
+" To handle nested structures properly we need to find the innermost
+" nested structure. For example, we might be in a function in a map in a
+" function, etc... so we need to first figure out what the innermost structure
+" is then forward execution to the proper handler
+function! elixir#indent#handle_inside_block(context)
+  let start_pattern = '\C\%(\<with\>\|\<if\>\|\<case\>\|\<cond\>\|\<try\>\|\<receive\>\|\<fn\>\|{\|\[\|(\)'
+  let end_pattern = '\C\%(\<end\>\|\]\|}\|)\)'
+  " hack - handle do: better
+  let block_info = searchpairpos(start_pattern, '', end_pattern, 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip() || getline(line('.')) =~ 'do:'", max([0, a:context.lnum - g:elixir_indent_max_lookbehind]))
+  let block_start_lnum = block_info[0]
+  let block_start_col = block_info[1]
+  if block_start_lnum != 0 || block_start_col != 0
+    let block_text = getline(block_start_lnum)
+    let block_start_char = block_text[block_start_col - 1]
+
+    let never_match = '\(a\)\@=b'
+    let config = {
+          \'f': {'aligned_clauses': s:keyword('end'), 'pattern_match_clauses': never_match},
+          \'c': {'aligned_clauses': s:keyword('end'), 'pattern_match_clauses': never_match},
+          \'t': {'aligned_clauses': s:keyword('end\|catch\|rescue\|after\|else'), 'pattern_match_clauses': s:keyword('catch\|rescue\|else')},
+          \'r': {'aligned_clauses': s:keyword('end\|after'), 'pattern_match_clauses': s:keyword('after')},
+          \'i': {'aligned_clauses': s:keyword('end\|else'), 'pattern_match_clauses': never_match},
+          \'[': {'aligned_clauses': ']', 'pattern_match_clauses': never_match},
+          \'{': {'aligned_clauses': '}', 'pattern_match_clauses': never_match},
+          \'(': {'aligned_clauses': ')', 'pattern_match_clauses': never_match}
+          \}
+
+    if block_start_char == 'w'
+      call s:debug("testing s:handle_with")
+      return s:handle_with(block_start_lnum, block_start_col, a:context)
+    else
+      let block_config = config[block_start_char]
+      if s:starts_with(a:context, block_config.aligned_clauses)
+        call s:debug("clause")
+        return indent(block_start_lnum)
+      else
+        let clause_lnum = searchpair(block_config.pattern_match_clauses, '', '*', 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()", block_start_lnum)
+        let relative_lnum = max([clause_lnum, block_start_lnum])
+        call s:debug("pattern matching relative to lnum " . relative_lnum)
+        return s:do_handle_pattern_match_block(relative_lnum, a:context)
+      endif
+    end
+  else
+    return -1
+  end
+endfunction
+
+function! s:handle_with(start_lnum, start_col, context)
+  let block_info = searchpairpos('\C\%(\<with\>\|\<do\>\|\<else\>\)', '', s:keyword('end'), 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()")
+  let block_start_lnum = block_info[0]
+  let block_start_col = block_info[1]
+
+  let block_start_text = getline(block_start_lnum)
+  let block_start_char = block_start_text[block_start_col - 1]
+
+  if s:starts_with(a:context, s:keyword('do\|else\|end'))
+    return indent(a:start_lnum)
+  elseif block_start_char == 'w' || s:starts_with(a:context, '\C\(do\|else\):')
+    return indent(a:start_lnum) + 5
+  elseif s:_starts_with(block_start_text, '\C\(do\|else\):', a:start_lnum)
+    return indent(block_start_lnum) + s:sw()
+  else
+    return s:do_handle_pattern_match_block(a:start_lnum, a:context)
+  end
+endfunction
+
+function! s:do_handle_pattern_match_block(relative_line, context)
+  let relative_indent = indent(a:relative_line)
+  " hack!
+  if a:context.text =~ '\(fn.*\)\@<!->'
+    call s:debug("current line contains ->; assuming match definition")
+    return relative_indent + s:sw()
+  elseif search('\(fn.*\)\@<!->', 'bnW', a:relative_line) != 0
+    call s:debug("a previous line contains ->; assuming match handler")
+    return relative_indent + 2 * s:sw()
+  else
+    call s:debug("couldn't find any previous ->; assuming body text")
+    return relative_indent + s:sw()
+  end
+endfunction
+
+function! elixir#indent#handle_inside_generic_block(context)
+  let pair_lnum = searchpair(s:keyword('do\|fn'), '', s:keyword('end'), 'bW', "line('.') == ".a:context.lnum." || s:is_string_or_comment(line('.'), col('.'))", max([0, a:context.lnum - g:elixir_indent_max_lookbehind]))
+  if pair_lnum
+    " TODO: @jbodah 2017-03-29: this should probably be the case in *all*
+    " blocks
+    if s:prev_ends_with(a:context, ',')
+      return indent(pair_lnum) + 2 * s:sw()
+    else
+      return indent(pair_lnum) + s:sw()
+    endif
+  else
+    return -1
+  endif
+endfunction
+
+endif

autoload/elixir/util.vim

@@ -0,0 +1,28 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elixir') == -1
+
+function! elixir#util#get_filename(word) abort
+  let word = a:word
+
+  " get first thing that starts uppercase, until the first space or end of line
+  let word = substitute(word,'^\s*\(\u[^ ]\+\).*$','\1','g')
+
+  " remove any trailing characters that don't look like a nested module
+  let word = substitute(word,'\.\U.*$','','g')
+
+  " replace module dots with slash
+  let word = substitute(word,'\.','/','g')
+
+  " remove any special chars
+  let word = substitute(word,'[^A-z0-9-_/]','','g')
+
+  " convert to snake_case
+  let word = substitute(word,'\(\u\+\)\(\u\l\)','\1_\2','g')
+  let word = substitute(word,'\(\u\+\)\(\u\l\)','\1_\2','g')
+  let word = substitute(word,'\(\l\|\d\)\(\u\)','\1_\2','g')
+  let word = substitute(word,'-','_','g')
+  let word = tolower(word)
+
+  return word
+endfunction
+
+endif

autoload/elm/io.vim

@@ -1,12 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elm') == -1
-  
-" System IO
-
-" Craft a system command and run it, returning the output.
-function! elm#io#system(program, args)
-  let cmd ="which " . a:program . " && " . a:program . " " . a:args
-  return system(cmd)
-endfunction
-
-
-endif

autoload/fish.vim

@@ -0,0 +1,71 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'fish') == -1
+
+function! fish#Indent()
+    let l:shiftwidth = shiftwidth()
+    let l:prevlnum = prevnonblank(v:lnum - 1)
+    if l:prevlnum ==# 0
+        return 0
+    endif
+    let l:indent = 0
+    let l:prevline = getline(l:prevlnum)
+    if l:prevline =~# '\v^\s*switch>'
+        return indent(l:prevlnum) + l:shiftwidth
+    elseif l:prevline =~# '\v^\s*%(begin|if|else|while|for|function|case)>'
+        let l:indent = l:shiftwidth
+    endif
+    let l:line = getline(v:lnum)
+    if l:line =~# '\v^\s*end>'
+        return indent(l:prevlnum) - (l:indent ==# 0 ? l:shiftwidth : l:indent)
+    elseif l:line =~# '\v^\s*%(case|else)>'
+        return indent(l:prevlnum) - l:shiftwidth
+    endif
+    return indent(l:prevlnum) + l:indent
+endfunction
+
+function! fish#Format()
+    if mode() =~# '\v^%(i|R)$'
+        return 1
+    else
+        let l:command = v:lnum.','.(v:lnum+v:count-1).'!fish_indent'
+        echo l:command
+        execute l:command
+    endif
+endfunction
+
+function! fish#Fold()
+    let l:line = getline(v:lnum)
+    if l:line =~# '\v^\s*%(begin|if|while|for|function|switch)>'
+        return 'a1'
+    elseif l:line =~# '\v^\s*end>'
+        return 's1'
+    else
+        return '='
+    end
+endfunction
+
+function! fish#Complete(findstart, base)
+    if a:findstart
+        return getline('.') =~# '\v^\s*$' ? -1 : 0
+    else
+        if empty(a:base)
+            return []
+        endif
+        let l:results = []
+        let l:completions =
+                    \ system('fish -c "complete -C'.shellescape(a:base).'"')
+        let l:cmd = substitute(a:base, '\v\S+$', '', '')
+        for l:line in filter(split(l:completions, '\n'), 'len(v:val)')
+            let l:tokens = split(l:line, '\t')
+            call add(l:results, {'word': l:cmd.l:tokens[0],
+                                \'abbr': l:tokens[0],
+                                \'menu': get(l:tokens, 1, '')})
+        endfor
+        return l:results
+    endif
+endfunction
+
+function! fish#errorformat()
+    return '%Afish: %m,%-G%*\\ ^,%-Z%f (line %l):%s'
+endfunction
+
+endif

autoload/go/config.vim

@@ -0,0 +1,583 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'go') == -1
+
+" don't spam the user when Vim is started in Vi compatibility mode
+let s:cpo_save = &cpo
+set cpo&vim
+
+function! go#config#AutodetectGopath() abort
+	return get(g:, 'go_autodetect_gopath', 0)
+endfunction
+
+function! go#config#ListTypeCommands() abort
+  return get(g:, 'go_list_type_commands', {})
+endfunction
+
+function! go#config#VersionWarning() abort
+  return get(g:, 'go_version_warning', 1)
+endfunction
+
+function! go#config#BuildTags() abort
+  return get(g:, 'go_build_tags', '')
+endfunction
+
+function! go#config#SetBuildTags(value) abort
+  if a:value is ''
+    silent! unlet g:go_build_tags
+    call go#lsp#ResetWorkspaceDirectories()
+    return
+  endif
+
+  let g:go_build_tags = a:value
+  call go#lsp#ResetWorkspaceDirectories()
+endfunction
+
+function! go#config#TestTimeout() abort
+ return get(g:, 'go_test_timeout', '10s')
+endfunction
+
+function! go#config#TestShowName() abort
+  return get(g:, 'go_test_show_name', 0)
+endfunction
+
+function! go#config#TermHeight() abort
+  return get(g:, 'go_term_height', winheight(0))
+endfunction
+
+function! go#config#TermWidth() abort
+  return get(g:, 'go_term_width', winwidth(0))
+endfunction
+
+function! go#config#TermMode() abort
+  return get(g:, 'go_term_mode', 'vsplit')
+endfunction
+
+function! go#config#TermCloseOnExit() abort
+  return get(g:, 'go_term_close_on_exit', 1)
+endfunction
+
+function! go#config#SetTermCloseOnExit(value) abort
+  let g:go_term_close_on_exit = a:value
+endfunction
+
+function! go#config#TermEnabled() abort
+  " nvim always support
+  " vim will support if terminal feature exists
+  let l:support = has('nvim') || has('terminal')
+  return support && get(g:, 'go_term_enabled', 0)
+endfunction
+
+function! go#config#SetTermEnabled(value) abort
+  let g:go_term_enabled = a:value
+endfunction
+
+function! go#config#TemplateUsePkg() abort
+  return get(g:, 'go_template_use_pkg', 0)
+endfunction
+
+function! go#config#TemplateTestFile() abort
+  return get(g:, 'go_template_test_file', "hello_world_test.go")
+endfunction
+
+function! go#config#TemplateFile() abort
+  return get(g:, 'go_template_file', "hello_world.go")
+endfunction
+
+function! go#config#StatuslineDuration() abort
+  return get(g:, 'go_statusline_duration', 60000)
+endfunction
+
+function! go#config#SnippetEngine() abort
+  let l:engine = get(g:, 'go_snippet_engine', 'automatic')
+  if l:engine is? "automatic"
+    if get(g:, 'did_plugin_ultisnips') is 1
+      let l:engine = 'ultisnips'
+    elseif get(g:, 'loaded_neosnippet') is 1
+      let l:engine = 'neosnippet'
+    elseif get(g:, 'loaded_minisnip') is 1
+      let l:engine = 'minisnip'
+    endif
+  endif
+
+  return l:engine
+endfunction
+
+function! go#config#PlayBrowserCommand() abort
+    if go#util#IsWin()
+        let go_play_browser_command = '!start rundll32 url.dll,FileProtocolHandler %URL%'
+    elseif go#util#IsMac()
+        let go_play_browser_command = 'open %URL%'
+    elseif executable('xdg-open')
+        let go_play_browser_command = 'xdg-open %URL%'
+    elseif executable('firefox')
+        let go_play_browser_command = 'firefox %URL% &'
+    elseif executable('chromium')
+        let go_play_browser_command = 'chromium %URL% &'
+    else
+        let go_play_browser_command = ''
+    endif
+
+    return get(g:, 'go_play_browser_command', go_play_browser_command)
+endfunction
+
+function! go#config#MetalinterDeadline() abort
+  " gometalinter has a default deadline of 5 seconds only when asynchronous
+  " jobs are not supported.
+
+  let deadline = '5s'
+  if go#util#has_job() && has('lambda')
+    let deadline = ''
+  endif
+
+  return get(g:, 'go_metalinter_deadline', deadline)
+endfunction
+
+function! go#config#ListType() abort
+  return get(g:, 'go_list_type', '')
+endfunction
+
+function! go#config#ListAutoclose() abort
+  return get(g:, 'go_list_autoclose', 1)
+endfunction
+
+function! go#config#InfoMode() abort
+  return get(g:, 'go_info_mode', 'gopls')
+endfunction
+
+function! go#config#GuruScope() abort
+  let scope = get(g:, 'go_guru_scope', [])
+
+  if !empty(scope)
+    " strip trailing slashes for each path in scope. bug:
+    " https://github.com/golang/go/issues/14584
+    let scopes = go#util#StripTrailingSlash(scope)
+  endif
+
+  return scope
+endfunction
+
+function! go#config#SetGuruScope(scope) abort
+  if empty(a:scope)
+    if exists('g:go_guru_scope')
+      unlet g:go_guru_scope
+    endif
+  else
+    let g:go_guru_scope = a:scope
+  endif
+endfunction
+
+function! go#config#EchoCommandInfo() abort
+  return get(g:, 'go_echo_command_info', 1)
+endfunction
+
+function! go#config#DocUrl() abort
+  let godoc_url = get(g:, 'go_doc_url', 'https://godoc.org')
+  if godoc_url isnot 'https://godoc.org'
+    " strip last '/' character if available
+    let last_char = strlen(godoc_url) - 1
+    if godoc_url[last_char] == '/'
+      let godoc_url = strpart(godoc_url, 0, last_char)
+    endif
+    " custom godoc installations expect /pkg before package names
+    let godoc_url .= "/pkg"
+  endif
+  return godoc_url
+endfunction
+
+function! go#config#DocPopupWindow() abort
+  return get(g:, 'go_doc_popup_window', 0)
+endfunction
+function! go#config#DefReuseBuffer() abort
+  return get(g:, 'go_def_reuse_buffer', 0)
+endfunction
+
+function! go#config#DefMode() abort
+  return get(g:, 'go_def_mode', 'gopls')
+endfunction
+
+function! go#config#DeclsIncludes() abort
+  return get(g:, 'go_decls_includes', 'func,type')
+endfunction
+
+function! go#config#Debug() abort
+  return get(g:, 'go_debug', [])
+endfunction
+
+function! go#config#DebugWindows() abort
+  return get(g:, 'go_debug_windows', {
+            \ 'vars':  'leftabove 30vnew',
+            \ 'stack': 'leftabove 20new',
+            \ 'goroutines': 'botright 10new',
+            \ 'out':        'botright 5new',
+            \ }
+         \ )
+
+endfunction
+
+function! go#config#DebugAddress() abort
+  return get(g:, 'go_debug_address', '127.0.0.1:8181')
+endfunction
+
+function! go#config#DebugCommands() abort
+  " make sure g:go_debug_commands is set so that it can be added to easily.
+  let g:go_debug_commands = get(g:, 'go_debug_commands', [])
+  return g:go_debug_commands
+endfunction
+
+function! go#config#DebugLogOutput() abort
+  return get(g:, 'go_debug_log_output', 'debugger,rpc')
+endfunction
+
+function! go#config#LspLog() abort
+  " make sure g:go_lsp_log is set so that it can be added to easily.
+  let g:go_lsp_log = get(g:, 'go_lsp_log', [])
+  return g:go_lsp_log
+endfunction
+
+function! go#config#SetDebugDiag(value) abort
+  let g:go_debug_diag = a:value
+endfunction
+
+function! go#config#AutoSameids() abort
+    return get(g:, 'go_auto_sameids', 0)
+endfunction
+
+function! go#config#SetAutoSameids(value) abort
+  let g:go_auto_sameids = a:value
+endfunction
+
+function! go#config#AddtagsTransform() abort
+  return get(g:, 'go_addtags_transform', "snakecase")
+endfunction
+
+function! go#config#AddtagsSkipUnexported() abort
+  return get(g:, 'go_addtags_skip_unexported', 0)
+endfunction
+
+function! go#config#TemplateAutocreate() abort
+  return get(g:, "go_template_autocreate", 1)
+endfunction
+
+function! go#config#SetTemplateAutocreate(value) abort
+  let g:go_template_autocreate = a:value
+endfunction
+
+function! go#config#MetalinterCommand() abort
+  return get(g:, "go_metalinter_command", "golangci-lint")
+endfunction
+
+function! go#config#MetalinterAutosaveEnabled() abort
+  let l:default_enabled = ["vet", "golint"]
+
+  if go#config#MetalinterCommand() == "golangci-lint"
+    let l:default_enabled = ["govet", "golint"]
+  endif
+
+  return get(g:, "go_metalinter_autosave_enabled", default_enabled)
+endfunction
+
+function! go#config#MetalinterEnabled() abort
+  let l:default_enabled = ["vet", "golint", "errcheck"]
+
+  if go#config#MetalinterCommand() == "golangci-lint"
+    let l:default_enabled = ["govet", "golint"]
+  endif
+
+  return get(g:, "go_metalinter_enabled", default_enabled)
+endfunction
+
+function! go#config#GolintBin() abort
+  return get(g:, "go_golint_bin", "golint")
+endfunction
+
+function! go#config#ErrcheckBin() abort
+  return get(g:, "go_errcheck_bin", "errcheck")
+endfunction
+
+function! go#config#MetalinterAutosave() abort
+  return get(g:, "go_metalinter_autosave", 0)
+endfunction
+
+function! go#config#SetMetalinterAutosave(value) abort
+  let g:go_metalinter_autosave = a:value
+endfunction
+
+function! go#config#ListHeight() abort
+  return get(g:, "go_list_height", 0)
+endfunction
+
+function! go#config#FmtAutosave() abort
+	return get(g:, "go_fmt_autosave", 1)
+endfunction
+
+function! go#config#ImportsAutosave() abort
+  return get(g:, 'go_imports_autosave', 0)
+endfunction
+
+function! go#config#SetFmtAutosave(value) abort
+  let g:go_fmt_autosave = a:value
+endfunction
+
+function! go#config#AsmfmtAutosave() abort
+  return get(g:, "go_asmfmt_autosave", 0)
+endfunction
+
+function! go#config#SetAsmfmtAutosave(value) abort
+  let g:go_asmfmt_autosave = a:value
+endfunction
+
+function! go#config#ModFmtAutosave() abort
+	return get(g:, "go_mod_fmt_autosave", 1)
+endfunction
+
+function! go#config#SetModFmtAutosave(value) abort
+  let g:go_mod_fmt_autosave = a:value
+endfunction
+
+function! go#config#DocMaxHeight() abort
+  return get(g:, "go_doc_max_height", 20)
+endfunction
+
+function! go#config#AutoTypeInfo() abort
+  return get(g:, "go_auto_type_info", 0)
+endfunction
+
+function! go#config#SetAutoTypeInfo(value) abort
+  let g:go_auto_type_info = a:value
+endfunction
+
+function! go#config#AlternateMode() abort
+  return get(g:, "go_alternate_mode", "edit")
+endfunction
+
+function! go#config#DeclsMode() abort
+  return get(g:, "go_decls_mode", "")
+endfunction
+
+function! go#config#FmtCommand() abort
+  return get(g:, "go_fmt_command", "gofmt")
+endfunction
+
+function! go#config#ImportsMode() abort
+  return get(g:, "go_imports_mode", "goimports")
+endfunction
+
+function! go#config#FmtOptions() abort
+  return get(b:, "go_fmt_options", get(g:, "go_fmt_options", {}))
+endfunction
+
+function! go#config#FmtFailSilently() abort
+  return get(g:, "go_fmt_fail_silently", 0)
+endfunction
+
+function! go#config#FmtExperimental() abort
+  return get(g:, "go_fmt_experimental", 0 )
+endfunction
+
+function! go#config#PlayOpenBrowser() abort
+  return get(g:, "go_play_open_browser", 1)
+endfunction
+
+function! go#config#RenameCommand() abort
+  " delegate to go#config#GorenameBin for backwards compatability.
+  return get(g:, "go_rename_command", go#config#GorenameBin())
+endfunction
+
+function! go#config#GorenameBin() abort
+  return get(g:, "go_gorename_bin", "gorename")
+endfunction
+
+function! go#config#GorenamePrefill() abort
+  return get(g:, "go_gorename_prefill", 'expand("<cword>") =~# "^[A-Z]"' .
+          \ '? go#util#pascalcase(expand("<cword>"))' .
+          \ ': go#util#camelcase(expand("<cword>"))')
+endfunction
+
+function! go#config#TextobjIncludeFunctionDoc() abort
+  return get(g:, "go_textobj_include_function_doc", 1)
+endfunction
+
+function! go#config#TextobjIncludeVariable() abort
+  return get(g:, "go_textobj_include_variable", 1)
+endfunction
+
+function! go#config#BinPath() abort
+  return get(g:, "go_bin_path", "")
+endfunction
+
+function! go#config#SearchBinPathFirst() abort
+  return get(g:, 'go_search_bin_path_first', 1)
+endfunction
+
+function! go#config#HighlightArrayWhitespaceError() abort
+  return get(g:, 'go_highlight_array_whitespace_error', 0)
+endfunction
+
+function! go#config#HighlightChanWhitespaceError() abort
+  return get(g:, 'go_highlight_chan_whitespace_error', 0)
+endfunction
+
+function! go#config#HighlightExtraTypes() abort
+  return get(g:, 'go_highlight_extra_types', 0)
+endfunction
+
+function! go#config#HighlightSpaceTabError() abort
+  return get(g:, 'go_highlight_space_tab_error', 0)
+endfunction
+
+function! go#config#HighlightTrailingWhitespaceError() abort
+  return get(g:, 'go_highlight_trailing_whitespace_error', 0)
+endfunction
+
+function! go#config#HighlightOperators() abort
+  return get(g:, 'go_highlight_operators', 0)
+endfunction
+
+function! go#config#HighlightFunctions() abort
+  return get(g:, 'go_highlight_functions', 0)
+endfunction
+
+function! go#config#HighlightFunctionParameters() abort
+  " fallback to highlight_function_arguments for backwards compatibility
+  return get(g:, 'go_highlight_function_parameters', get(g:, 'go_highlight_function_arguments', 0))
+endfunction
+
+function! go#config#HighlightFunctionCalls() abort
+  return get(g:, 'go_highlight_function_calls', 0)
+endfunction
+
+function! go#config#HighlightFields() abort
+  return get(g:, 'go_highlight_fields', 0)
+endfunction
+
+function! go#config#HighlightTypes() abort
+  return get(g:, 'go_highlight_types', 0)
+endfunction
+
+function! go#config#HighlightBuildConstraints() abort
+  return get(g:, 'go_highlight_build_constraints', 0)
+endfunction
+
+function! go#config#HighlightStringSpellcheck() abort
+  return get(g:, 'go_highlight_string_spellcheck', 1)
+endfunction
+
+function! go#config#HighlightFormatStrings() abort
+  return get(g:, 'go_highlight_format_strings', 1)
+endfunction
+
+function! go#config#HighlightGenerateTags() abort
+  return get(g:, 'go_highlight_generate_tags', 0)
+endfunction
+
+function! go#config#HighlightVariableAssignments() abort
+  return get(g:, 'go_highlight_variable_assignments', 0)
+endfunction
+
+function! go#config#HighlightVariableDeclarations() abort
+  return get(g:, 'go_highlight_variable_declarations', 0)
+endfunction
+
+function! go#config#HighlightDiagnosticErrors() abort
+  return get(g:, 'go_highlight_diagnostic_errors', 1)
+endfunction
+
+function! go#config#HighlightDiagnosticWarnings() abort
+  return get(g:, 'go_highlight_diagnostic_warnings', 1)
+endfunction
+
+function! go#config#HighlightDebug() abort
+  return get(g:, 'go_highlight_debug', 1)
+endfunction
+
+function! go#config#DebugBreakpointSignText() abort
+  return get(g:, 'go_debug_breakpoint_sign_text', '>')
+endfunction
+
+function! go#config#FoldEnable(...) abort
+  if a:0 > 0
+    return index(go#config#FoldEnable(), a:1) > -1
+  endif
+  return get(g:, 'go_fold_enable', ['block', 'import', 'varconst', 'package_comment'])
+endfunction
+
+function! go#config#EchoGoInfo() abort
+  return get(g:, "go_echo_go_info", 1)
+endfunction
+
+function! go#config#CodeCompletionEnabled() abort
+  return get(g:, "go_code_completion_enabled", 1)
+endfunction
+
+function! go#config#Updatetime() abort
+  let go_updatetime = get(g:, 'go_updatetime', 800)
+  return go_updatetime == 0 ? &updatetime : go_updatetime
+endfunction
+
+function! go#config#ReferrersMode() abort
+  return get(g:, 'go_referrers_mode', 'gopls')
+endfunction
+
+function! go#config#ImplementsMode() abort
+  return get(g:, 'go_implements_mode', 'guru')
+endfunction
+
+function! go#config#GoplsCompleteUnimported() abort
+  return get(g:, 'go_gopls_complete_unimported', v:null)
+endfunction
+
+function! go#config#GoplsDeepCompletion() abort
+  return get(g:, 'go_gopls_deep_completion', v:null)
+endfunction
+
+function! go#config#GoplsMatcher() abort
+  if !exists('g:go_gopls_matcher') && get(g:, 'g:go_gopls_fuzzy_matching', v:null) is 1
+    return 'fuzzy'
+  endif
+  return get(g:, 'go_gopls_matcher', v:null)
+endfunction
+
+function! go#config#GoplsStaticCheck() abort
+  return get(g:, 'go_gopls_staticcheck', v:null)
+endfunction
+
+function! go#config#GoplsUsePlaceholders() abort
+  return get(g:, 'go_gopls_use_placeholders', v:null)
+endfunction
+
+function! go#config#GoplsTempModfile() abort
+  return get(g:, 'go_gopls_temp_modfile', v:null)
+endfunction
+
+function! go#config#GoplsAnalyses() abort
+  return get(g:, 'go_gopls_analyses', v:null)
+endfunction
+
+function! go#config#GoplsLocal() abort
+  return get(g:, 'go_gopls_local', v:null)
+endfunction
+
+function! go#config#GoplsEnabled() abort
+  return get(g:, 'go_gopls_enabled', 1)
+endfunction
+
+function! go#config#DiagnosticsEnabled() abort
+  return get(g:, 'go_diagnostics_enabled', 0)
+endfunction
+
+function! go#config#GoplsOptions() abort
+  return get(g:, 'go_gopls_options', [])
+endfunction
+
+" Set the default value. A value of "1" is a shortcut for this, for
+" compatibility reasons.
+if exists("g:go_gorename_prefill") && g:go_gorename_prefill == 1
+  unlet g:go_gorename_prefill
+endif
+
+" restore Vi compatibility settings
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim: sw=2 ts=2 et
+
+endif

autoload/graphql.vim

@@ -0,0 +1,39 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'graphql') == -1
+
+" Copyright (c) 2016-2020 Jon Parise <jon@indelible.org>
+"
+" 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.
+"
+" Language: GraphQL
+" Maintainer: Jon Parise <jon@indelible.org>
+
+function! graphql#has_syntax_group(group) abort
+  try
+    silent execute 'silent highlight ' . a:group
+  catch
+    return v:false
+  endtry
+  return v:true
+endfunction
+
+function! graphql#javascript_tags() abort
+  return get(g:, 'graphql_javascript_tags', ['gql', 'graphql', 'Relay.QL'])
+endfunction
+
+endif

autoload/health/vimtex.vim

@@ -0,0 +1,164 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+function! health#vimtex#check() abort
+  call vimtex#init_options()
+
+  call health#report_start('vimtex')
+
+  call s:check_general()
+  call s:check_plugin_clash()
+  call s:check_view()
+  call s:check_compiler()
+endfunction
+
+function! s:check_general() abort " {{{1
+  if !has('nvim') || v:version < 800
+    call health#report_warn('vimtex works best with Vim 8 or neovim')
+  else
+    call health#report_ok('Vim version should have full support!')
+  endif
+
+  if !executable('bibtex')
+    call health#report_warn('bibtex is not executable, so bibtex completions are disabled.')
+  endif
+endfunction
+
+" }}}1
+
+function! s:check_compiler() abort " {{{1
+  if !g:vimtex_compiler_enabled | return | endif
+
+  if !executable(g:vimtex_compiler_method)
+    let l:ind = '        '
+    call health#report_error(printf(
+          \ '|g:vimtex_compiler_method| (`%s`) is not executable!',
+          \ g:vimtex_compiler_method))
+    return
+  endif
+
+  let l:ok = 1
+  if !executable(g:vimtex_compiler_progname)
+    call health#report_warn(printf(
+          \ '|g:vimtex_compiler_progname| (`%s`) is not executable!',
+          \ g:vimtex_compiler_progname))
+    let l:ok = 0
+  endif
+
+  if has('nvim')
+        \ && fnamemodify(g:vimtex_compiler_progname, ':t') !=# 'nvr'
+    call health#report_warn('Compiler callbacks will not work!', [
+          \ '`neovim-remote` / `nvr` is required for callbacks to work with neovim',
+          \ "Please also set |g:vimtex_compiler_progname| = 'nvr'",
+          \ 'For more info, see :help |vimtex-faq-neovim|',
+          \])
+    let l:ok = 0
+  endif
+
+  if l:ok
+    call health#report_ok('Compiler should work!')
+  endif
+endfunction
+
+" }}}1
+
+function! s:check_plugin_clash() abort " {{{1
+  let l:scriptnames = split(execute('scriptnames'), "\n")
+
+  let l:latexbox = !empty(filter(copy(l:scriptnames), "v:val =~# 'latex-box'"))
+  if l:latexbox
+    call health#report_warn('Conflicting plugin detected: LaTeX-Box')
+    call health#report_info('vimtex does not work as expected when LaTeX-Box is installed!')
+    call health#report_info('Please disable or remove it to use vimtex!')
+
+    let l:polyglot = !empty(filter(copy(l:scriptnames), "v:val =~# 'polyglot'"))
+    if l:polyglot
+      call health#report_info('LaTeX-Box is included with vim-polyglot and may be disabled with:')
+      call health#report_info('let g:polyglot_disabled = [''latex'']')
+    endif
+  endif
+endfunction
+
+" }}}1
+
+function! s:check_view() abort " {{{1
+  call s:check_view_{g:vimtex_view_method}()
+
+  if executable('xdotool') && !executable('pstree')
+    call health#report_warn('pstree is not available',
+          \ 'vimtex#view#reverse_goto is better if pstree is available.')
+  endif
+endfunction
+
+" }}}1
+function! s:check_view_general() abort " {{{1
+  if executable(g:vimtex_view_general_viewer)
+    call health#report_ok('General viewer should work properly!')
+  else
+    call health#report_error(
+          \ 'Selected viewer is not executable!',
+          \ '- Selection: ' . g:vimtex_view_general_viewer,
+          \ '- Please see :h g:vimtex_view_general_viewer')
+  endif
+endfunction
+
+" }}}1
+function! s:check_view_zathura() abort " {{{1
+  let l:ok = 1
+
+  if !executable('zathura')
+    call health#report_error('Zathura is not executable!')
+    let l:ok = 0
+  endif
+
+  if !executable('xdotool')
+    call health#report_warn('Zathura requires xdotool for forward search!')
+    let l:ok = 0
+  endif
+
+  if l:ok
+    call health#report_ok('Zathura should work properly!')
+  endif
+endfunction
+
+" }}}1
+function! s:check_view_mupdf() abort " {{{1
+  let l:ok = 1
+
+  if !executable('mupdf')
+    call health#report_error('MuPDF is not executable!')
+    let l:ok = 0
+  endif
+
+  if !executable('xdotool')
+    call health#report_warn('MuPDF requires xdotool for forward search!')
+    let l:ok = 0
+  endif
+
+  if !executable('synctex')
+    call health#report_warn('MuPDF requires synctex for forward search!')
+    let l:ok = 0
+  endif
+
+  if l:ok
+    call health#report_ok('MuPDF should work properly!')
+  endif
+endfunction
+
+" }}}1
+function! s:check_view_skim() abort " {{{1
+  let l:cmd = join([
+        \ 'osascript -e ',
+        \ '''tell application "Finder" to POSIX path of ',
+        \ '(get application file id (id of application "Skim") as alias)''',
+        \])
+
+  if system(l:cmd)
+    call health#report_error('Skim is not installed!')
+  else
+    call health#report_ok('Skim viewer should work!')
+  endif
+endfunction
+
+" }}}1
+
+endif

autoload/htmlcomplete.vim

@@ -6,7 +6,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'html5') == -1
 " Last Change:  2006 Oct 19
 " Modified:     othree <othree@gmail.com>
 " Changes:      Add HTML5, WAI-ARIA support
-" Last Change:	2010 Sep 25
+" Last Change:  2016 Oct 11
 
 if !exists('g:aria_attributes_complete')
   let g:aria_attributes_complete = 1
@@ -276,7 +276,9 @@ function! htmlcomplete#CompleteTags(findstart, base)
   " 1. Events attributes
   if context =~ '\s'
     " Sort out style, class, and on* cases
-		if context =~? "\\s\\(on[a-z]+\\|id\\|style\\|class\\)\\s*=\\s*[\"']"
+    if context =~? "\\(id\\|class\\)\\s*=\\s*[\"'][a-zA-Z0-9_ -]*$"
+     \ || context =~? "style\\s*=\\s*[\"'][^\"']*$"
+     \ || context =~? 'on[a-z]*\s*=\s*\(''[^'']*\|"[^"]*\)$'
       " Id, class completion {{{
       if context =~? "\\(id\\|class\\)\\s*=\\s*[\"'][a-zA-Z0-9_ -]*$"
         if context =~? "class\\s*=\\s*[\"'][a-zA-Z0-9_ -]*$"

autoload/jsx_pretty/comment.vim

@@ -0,0 +1,41 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+function! jsx_pretty#comment#update_commentstring(original)
+  let line = getline(".")
+  let col = col('.')
+  if line !~# '^\s*$' && line[: col - 1] =~# '^\s*$'    " skip indent
+    let col = indent('.') + 1
+  endif
+  let syn_start = s:syn_name(line('.'), col)
+  let save_cursor = getcurpos()
+
+  if syn_start =~? '^jsx'
+    if line =~ '^\s*//'
+      let &l:commentstring = '// %s'
+    elseif s:syn_contains(line('.'), col, 'jsxTaggedRegion')
+      let &l:commentstring = '<!-- %s -->'
+    elseif syn_start =~? '^jsxAttrib'
+      let &l:commentstring = '// %s'
+    else
+      let &l:commentstring = '{/* %s */}'
+    endif
+  else
+    let &l:commentstring = a:original
+  endif
+
+  " Restore the cursor position
+  call setpos('.', save_cursor)
+endfunction
+
+function! s:syn_name(lnum, cnum)
+  let syn_id = get(synstack(a:lnum, a:cnum), -1)
+  return synIDattr(syn_id, "name")
+endfunction
+
+function! s:syn_contains(lnum, cnum, syn_name)
+  let stack = synstack(a:lnum, a:cnum)
+  let syn_names = map(stack, 'synIDattr(v:val, "name")')
+  return index(syn_names, a:syn_name) >= 0
+endfunction
+
+endif

autoload/jsx_pretty/indent.vim

@@ -0,0 +1,306 @@
+if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
+
+if exists('*shiftwidth')
+  function! s:sw()
+    return shiftwidth()
+  endfunction
+else
+  function! s:sw()
+    return &sw
+  endfunction
+endif
+
+" Regexp for the start tag
+let s:start_tag = '<\_s*\%(>\|\${\|\%(\<[-:._$A-Za-z0-9]\+\>\)\)'
+" Regexp for the end tag
+let s:end_tag = '\%(<\_s*/\_s*\%(\<[-:._$A-Za-z0-9]\+\>\)\_s*>\|/\_s*>\)'
+
+function s:trim(line)
+  return substitute(a:line, '^\s*\|\s*$', '', 'g')
+endfunction
+
+" Get the syntax stack at the given position
+function s:syntax_stack_at(lnum, col)
+  return map(synstack(a:lnum, a:col), 'synIDattr(v:val, "name")')
+endfunction
+
+" Get the syntax at the given position
+function s:syntax_at(lnum, col)
+  return synIDattr(synID(a:lnum, a:col, 1), 'name')
+endfunction
+
+" Get the start col of the non-space charactor
+function s:start_col(lnum)
+  return len(matchstr(getline(a:lnum), '^\s*')) + 1
+endfunction
+
+" Get the start syntax of a given line number
+function s:start_syntax(lnum)
+  return s:syntax_at(a:lnum, s:start_col(a:lnum))
+endfunction
+
+" The skip function for searchpair
+function s:skip_if_not(current_lnum, ...)
+  " Skip the match in current line
+  if line('.') == a:current_lnum
+    return 1
+  endif
+
+  let syntax = s:syntax_at(line('.'), col('.'))
+  return syntax !~? join(a:000, '\|')
+endfunction
+
+" Whether the specified stytax group is the opening tag
+function s:is_opening_tag(syntax)
+  return a:syntax =~? 'jsxOpenPunct'
+endfunction
+
+" Whether the specified stytax group is the closing tag
+function s:is_closing_tag(syntax)
+  return a:syntax =~? 'jsxClose'
+endfunction
+
+" Whether the specified syntax group is the jsxRegion
+function s:is_jsx_region(syntax)
+  return a:syntax =~? 'jsxRegion'
+endfunction
+
+" Whether the specified syntax group is the jsxElement
+function s:is_jsx_element(syntax)
+  return a:syntax =~? 'jsxElement'
+endfunction
+
+" Whether the specified syntax group is the jsxExpressionBlock
+function s:is_jsx_expression(syntax)
+  return a:syntax =~? 'jsxExpressionBlock'
+endfunction
+
+" Whether the specified syntax group is the jsxBraces
+function s:is_jsx_brace(syntax)
+  return a:syntax =~? 'jsxBraces'
+endfunction
+
+" Whether the specified syntax group is the jsxComment
+function s:is_jsx_comment(syntax)
+  return a:syntax =~? 'jsxComment'
+endfunction
+
+" Whether the specified line is comment related syntax
+function s:is_comment(syntax)
+  return a:syntax =~? 'comment'
+endfunction
+
+" Whether the specified syntax group is the jsxComment
+function s:is_jsx_backticks(syntax)
+  return a:syntax =~? 'jsxBackticks'
+endfunction
+
+" Get the prvious line number
+function s:prev_lnum(lnum)
+  return prevnonblank(a:lnum - 1)
+endfunction
+
+" Whether the given pos is the parent of the given element who has
+" element_count jsxElement syntax
+function s:is_parent_element(pos, element_count)
+  let syntax_stack = s:syntax_stack_at(a:pos[0], a:pos[1])
+  return s:is_opening_tag(syntax_stack[-1]) &&
+        \ count(syntax_stack, 'jsxElement') <= a:element_count
+endfunction
+
+" Compute the indention of the trail punct
+function s:jsx_indent_trail_punct(lnum)
+  let pair_line = searchpair('<', '', '>', 'bW', 's:skip_if_not(a:lnum, "jsxOpenPunct", "jsxClose")')
+  return indent(pair_line)
+endfunction
+
+" Compute the indention of the closing tag
+function s:jsx_indent_closing_tag(lnum)
+  let pair_line = searchpair(s:start_tag, '', s:end_tag, 'bW', 's:skip_if_not(a:lnum, "jsxOpenPunct", "jsxClose")')
+  return pair_line ? indent(pair_line) : indent(a:lnum)
+endfunction
+
+" Compute the indentation of the jsxElement
+function s:jsx_indent_element(lnum)
+  let syntax_stack = s:syntax_stack_at(a:lnum, s:start_col(a:lnum))
+  let syntax_name = syntax_stack[-1]
+  let element_count = count(syntax_stack, 'jsxElement')
+
+  if s:trim(getline(a:lnum)) =~ '^>'
+    return s:jsx_indent_trail_punct(a:lnum)
+  endif
+
+  " If current tag is closing tag
+  if s:is_closing_tag(syntax_name)
+    return s:jsx_indent_closing_tag(a:lnum)
+  endif
+
+  " Normalize the jsxElement count for opening tag
+  if s:is_opening_tag(syntax_name)
+    " <div>
+    "   <div></div> <-- jsxRegion->jsxElement->jsxElement->jsxTag->jsxOpenTag->jsxOpenPunct
+    " </div>
+    if s:is_jsx_element(syntax_stack[-4]) && s:is_jsx_element(syntax_stack[-5])
+      let element_count = element_count - 1
+    endif
+  endif
+
+  let start_time = localtime()
+  let pos = searchpos(s:start_tag, 'bW')
+
+  while !s:is_parent_element(pos, element_count)
+    if localtime() - start_time >= 0.5
+      return -1
+    endif
+    let pos = searchpos(s:start_tag, 'bW')
+  endwhile
+
+  return indent(pos[0]) + s:sw()
+endfunction
+
+" Compute the indentation of the comment
+function s:jsx_indent_comment(lnum)
+  let line = s:trim(getline(a:lnum))
+
+  if s:is_jsx_comment(s:start_syntax(a:lnum))
+    if line =~ '^<!--' || line =~ '^-->'
+      return s:jsx_indent_element(a:lnum)
+    else
+      return s:jsx_indent_element(a:lnum) + s:sw()
+    endif
+  else
+    if line =~ '^/\*' || line =~ '^//'
+      return s:jsx_indent_element(a:lnum)
+    else
+      return s:jsx_indent_element(a:lnum) + 1
+    endif
+  endif
+endfunction
+
+" Compute the indentation of jsxBackticks
+function s:jsx_indent_backticks(lnum)
+  let tags = get(g:, 'vim_jsx_pretty_template_tags', ['html', 'jsx'])
+  let start_tag = '\%(' . join(tags, '\|') . '\)`'
+  let end_tag = '\%(' . join(tags, '\|') . '\)\@<!`'
+  let pair_line = searchpair(start_tag, '', end_tag, 'bW', 's:skip_if_not(a:lnum)')
+
+  return indent(pair_line)
+endfunction
+
+" Syntax context types:
+" - jsxRegion
+" - jsxTaggedRegion
+" - jsxElement
+" - jsxExpressionBlock
+" - Other
+function s:syntax_context(lnum)
+  let start_col = s:start_col(a:lnum)
+  let syntax_stack = s:syntax_stack_at(a:lnum, start_col)
+  let start_syntax = syntax_stack[-1]
+  let reversed = reverse(syntax_stack)
+  let i = 0
+
+  for syntax_name in reversed
+    " If the current line is jsxExpressionBlock and not starts with jsxBraces
+    if s:is_jsx_expression(syntax_name)
+      return 'jsxExpressionBlock'
+    endif
+
+    if s:is_jsx_region(syntax_name)
+      return 'jsxRegion'
+    endif
+
+    if s:is_jsx_element(syntax_name)
+      " If current line starts with the opening tag
+      if s:is_opening_tag(start_syntax) || s:is_closing_tag(start_syntax)
+        " And the next syntax is jsxRegion
+        if s:is_jsx_region(reversed[i+1])
+          return 'jsxRegion'
+        elseif reversed[i+1] =~ 'jsxTaggedRegion'
+          return 'jsxTaggedRegion'
+        else
+          return 'jsxElement'
+        endif
+      elseif reversed[i+1] =~ 'jsxTaggedRegion'
+        return 'jsxTaggedRegion'
+      else
+        return 'jsxElement'
+      endif
+    endif
+
+    let i = i + 1
+  endfor
+  
+  return 'Other'
+endfunction
+
+
+function! jsx_pretty#indent#get(js_indent)
+  let line = s:trim(getline(v:lnum))
+  let start_syntax = s:start_syntax(v:lnum)
+
+  if s:is_jsx_backticks(start_syntax)
+    return s:jsx_indent_backticks(v:lnum)
+  endif
+
+  if s:is_jsx_brace(start_syntax)
+    return s:jsx_indent_element(v:lnum)
+  endif
+
+  if s:is_opening_tag(start_syntax) && line =~ '^>'
+    return s:jsx_indent_trail_punct(v:lnum)
+  endif
+
+  let syntax_context = s:syntax_context(v:lnum)
+
+  if syntax_context == 'jsxRegion'
+    if s:is_closing_tag(start_syntax)
+      return s:jsx_indent_closing_tag(v:lnum)
+    endif
+
+    let prev_lnum = s:prev_lnum(v:lnum)
+    let prev_line = s:trim(getline(prev_lnum))
+
+    if prev_line =~ '[([{=?]$'
+      return indent(prev_lnum) + s:sw()
+    elseif prev_line =~ '[:|&<>]$' &&
+          \ s:trim(getline(s:prev_lnum(prev_lnum))) !~ '[?:|&<>]$'
+      return indent(prev_lnum) + s:sw()
+    else
+      return indent(prev_lnum)
+    endif
+  elseif syntax_context == 'jsxTaggedRegion'
+    if s:is_closing_tag(start_syntax)
+      return s:jsx_indent_closing_tag(v:lnum)
+    elseif s:is_jsx_comment(start_syntax)
+      return s:jsx_indent_comment(v:lnum)
+    else
+      return indent(s:prev_lnum(v:lnum)) + s:sw()
+    endif
+  elseif syntax_context == 'jsxElement'
+    if s:is_jsx_comment(start_syntax)
+      return s:jsx_indent_comment(v:lnum)
+    endif
+
+    if s:is_comment(start_syntax)
+      return s:jsx_indent_comment(v:lnum)
+    endif
+
+    return s:jsx_indent_element(v:lnum)
+  elseif syntax_context == 'jsxExpressionBlock'
+    let prev_lnum = s:prev_lnum(v:lnum)
+    let prev_line = s:trim(getline(prev_lnum))
+
+    if line =~ '^?'
+      return indent(prev_lnum) + s:sw()
+    elseif line =~ '^:'
+      return indent(prev_lnum)
+    else
+      return a:js_indent()
+    endif
+  endif
+
+  return a:js_indent()
+endfunction
+
+endif

autoload/julia.vim

@@ -0,0 +1,169 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+
+function! julia#set_syntax_version(jvers)
+  echo "The julia#set_syntax_version function is deprecated"
+endfunction
+
+function! julia#toggle_deprecated_syntax()
+  echo "The julia#toggle_deprecated_syntax function is deprecated"
+endfunction
+
+if exists("loaded_matchit")
+
+function! julia#toggle_function_blockassign()
+    let sav_pos = getcurpos()
+    let l = getline('.')
+    let c = match(l, '\C\m\<function\s\+.\+(')
+    if c != -1
+        return julia#function_block2assign()
+    endif
+    let c = match(l, '\C\m)\%(::\S\+\)\?\%(\s\+where\s\+.*\)\?\s*=\s*')
+    if c == -1
+        echohl WarningMsg | echo "Not on a function definition or assignment line" | echohl None
+        return
+    endif
+    return julia#function_assign2block()
+endfunction
+
+function! julia#function_block2assign()
+    let sav_pos = getcurpos()
+    let l = getline('.')
+    let c = match(l, '\C\m\<function\s\+.\+(')
+    if c == -1
+        echohl WarningMsg | echo "Not on a function definition line" | echohl None
+        return
+    endif
+    let fpos = copy(sav_pos)
+    let fpos[2] = c+1
+    call setpos('.', fpos)
+    normal %
+    if line('.') != fpos[1]+2 || match(getline('.'), '\C\m^\s*end\s*$') == -1
+        echohl WarningMsg | echo "Only works with 3-lines functions" | echohl None
+        call setpos('.', sav_pos)
+        return
+    endif
+    call setpos('.', fpos)
+    normal! f(
+    normal %
+    while line('.') == fpos[1] && match(l[col('.')-1:], '\C\m)(') == 0
+        normal! l
+        normal %
+    endwhile
+    if line('.') != fpos[1] || match(l[(col('.')-1):], '\C\m)\%(::\S\+\)\?\%(\s\+where\s\+.*\)\?\s*$') != 0
+        echohl WarningMsg | echo "Unrecognized function definition format" | echohl None
+        call setpos('.', sav_pos)
+        return
+    endif
+
+    call setpos('.', fpos)
+    normal! dwA = J
+    if match(getline('.')[(col('.')-1):], '\C\mreturn\>') == 0
+        normal! dw
+    endif
+    if match(getline('.')[(col('.')-1):], '\C\m\s*$') == 0
+        normal! F=C= nothing
+    endif
+    normal! jddk^
+    return
+endfunction
+
+function! julia#function_assign2block()
+    let sav_pos = getcurpos()
+    let l = getline('.')
+    let c = match(l, '\C\m)\%(::\S\+\)\?\%(\s\+where\s\+.*\)\?\s*=\s*')
+    if c == -1
+        echohl WarningMsg | echo "Not on a function assignment-definition line" | echohl None
+        return
+    endif
+    normal ^
+    while match(l[(col('.')-1):], '\%(\S\+\.\)*@') == 0
+        normal! W
+    endwhile
+    normal! ifunction 
+    let l = getline('.')
+    let c = match(l, '\C\m)\%(::\S\+\)\?\%(\s\+where\s\+.*\)\?\s*\zs=\s*')
+    let eqpos = copy(sav_pos)
+    let eqpos[2] = c+1
+    call setpos('.', eqpos)
+    normal! cw
+oend
+    normal %
+    s/\s*$// | noh
+    return
+endfunction
+
+
+let s:nonid_chars = "\U01-\U07" . "\U0E-\U1F" .
+      \             "\"#$'(,.:;=?@`\\U5B{" .
+      \             "\U80-\UA1" . "\UA7\UA8\UAB\UAD\UAF\UB4" . "\UB6-\UB8" . "\UBB\UBF"
+
+let s:nonidS_chars = "[:space:])\\U5D}" . s:nonid_chars
+
+" the following excludes '!' since it can be used as an identifier,
+" and '$' since it can be used in interpolations
+" note that \U2D is '-'
+let s:uniop_chars = "+\\U2D~¬√∛∜"
+
+let s:binop_chars = "=+\\U2D*/\\%÷^&|⊻<>≤≥≡≠≢∈∉⋅×∪∩⊆⊈⊂⊄⊊←→∋∌⊕⊖⊞⊟∘∧⊗⊘↑↓∨⊠±"
+
+" the following is a list of all remainig valid operator chars,
+" but it's more efficient when expressed with ranges (see below)
+" let s:binop_chars_extra = "↔↚↛↠↣↦↮⇎⇏⇒⇔⇴⇶⇷⇸⇹⇺⇻⇼⇽⇾⇿⟵⟶⟷⟷⟹⟺⟻⟼⟽⟾⟿⤀⤁⤂⤃⤄⤅⤆⤇⤌⤍⤎⤏⤐⤑⤔⤕⤖⤗⤘⤝⤞⤟⤠⥄⥅⥆⥇⥈⥊⥋⥎⥐⥒⥓⥖⥗⥚⥛⥞⥟⥢⥤⥦⥧⥨⥩⥪⥫⥬⥭⥰⧴⬱⬰⬲⬳⬴⬵⬶⬷⬸⬹⬺⬻⬼⬽⬾⬿⭀⭁⭂⭃⭄⭇⭈⭉⭊⭋⭌￩￫" .
+"       \                   "∝∊∍∥∦∷∺∻∽∾≁≃≄≅≆≇≈≉≊≋≌≍≎≐≑≒≓≔≕≖≗≘≙≚≛≜≝≞≟≣≦≧≨≩≪≫≬≭≮≯≰≱≲≳≴≵≶≷≸≹≺≻≼≽≾≿⊀⊁⊃⊅⊇⊉⊋⊏⊐⊑⊒⊜⊩⊬⊮⊰⊱⊲⊳⊴⊵⊶⊷⋍⋐⋑⋕⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩⋪⋫⋬⋭⋲⋳⋴⋵⋶⋷⋸⋹⋺⋻⋼⋽⋾⋿⟈⟉⟒⦷⧀⧁⧡⧣⧤⧥⩦⩧⩪⩫⩬⩭⩮⩯⩰⩱⩲⩳⩴⩵⩶⩷⩸⩹⩺⩻⩼⩽⩾⩿⪀⪁⪂⪃⪄⪅⪆⪇⪈⪉⪊⪋⪌⪍⪎⪏⪐⪑⪒⪓⪔⪕⪖⪗⪘⪙⪚⪛⪜⪝⪞⪟⪠⪡⪢⪣⪤⪥⪦⪧⪨⪩⪪⪫⪬⪭⪮⪯⪰⪱⪲⪳⪴⪵⪶⪷⪸⪹⪺⪻⪼⪽⪾⪿⫀⫁⫂⫃⫄⫅⫆⫇⫈⫉⫊⫋⫌⫍⫎⫏⫐⫑⫒⫓⫔⫕⫖⫗⫘⫙⫷⫸⫹⫺⊢⊣" .
+"       \                   "⊔∓∔∸≂≏⊎⊽⋎⋓⧺⧻⨈⨢⨣⨤⨥⨦⨧⨨⨩⨪⨫⨬⨭⨮⨹⨺⩁⩂⩅⩊⩌⩏⩐⩒⩔⩖⩗⩛⩝⩡⩢⩣" .
+"       \                   "⊙⊚⊛⊡⊓∗∙∤⅋≀⊼⋄⋆⋇⋉⋊⋋⋌⋏⋒⟑⦸⦼⦾⦿⧶⧷⨇⨰⨱⨲⨳⨴⨵⨶⨷⨸⨻⨼⨽⩀⩃⩄⩋⩍⩎⩑⩓⩕⩘⩚⩜⩞⩟⩠⫛⊍▷⨝⟕⟖⟗" .
+"       \                   "⇵⟰⟱⤈⤉⤊⤋⤒⤓⥉⥌⥍⥏⥑⥔⥕⥘⥙⥜⥝⥠⥡⥣⥥⥮⥯￪￬"
+
+" same as above, but with character ranges, for performance
+let s:binop_chars_extra = "\\U214B\\U2190-\\U2194\\U219A\\U219B\\U21A0\\U21A3\\U21A6\\U21AE\\U21CE\\U21CF\\U21D2\\U21D4\\U21F4-\\U21FF\\U2208-\\U220D\\U2213\\U2214\\U2217-\\U2219\\U221D\\U2224-\\U222A\\U2237\\U2238\\U223A\\U223B\\U223D\\U223E\\U2240-\\U228B\\U228D-\\U229C\\U229E-\\U22A3\\U22A9\\U22AC\\U22AE\\U22B0-\\U22B7\\U22BB-\\U22BD\\U22C4-\\U22C7\\U22C9-\\U22D3\\U22D5-\\U22ED\\U22F2-\\U22FF\\U25B7\\U27C8\\U27C9\\U27D1\\U27D2\\U27D5-\\U27D7\\U27F0\\U27F1\\U27F5-\\U27F7\\U27F7\\U27F9-\\U27FF\\U2900-\\U2918\\U291D-\\U2920\\U2944-\\U2970\\U29B7\\U29B8\\U29BC\\U29BE-\\U29C1\\U29E1\\U29E3-\\U29E5\\U29F4\\U29F6\\U29F7\\U29FA\\U29FB\\U2A07\\U2A08\\U2A1D\\U2A22-\\U2A2E\\U2A30-\\U2A3D\\U2A40-\\U2A45\\U2A4A-\\U2A58\\U2A5A-\\U2A63\\U2A66\\U2A67\\U2A6A-\\U2AD9\\U2ADB\\U2AF7-\\U2AFA\\U2B30-\\U2B44\\U2B47-\\U2B4C\\UFFE9-\\UFFEC"
+
+" a Julia identifier, sort of
+let s:idregex = '[^' . s:nonidS_chars . '0-9!' . s:uniop_chars . s:binop_chars . '][^' . s:nonidS_chars . s:uniop_chars . s:binop_chars . s:binop_chars_extra . ']*'
+
+let s:operators = '\%(' . '\.\%([-+*/^÷%|&!]\|//\|\\\|<<\|>>>\?\)\?=' .
+      \           '\|'  . '[:$<>]=\|||\|&&\||>\|<|\|<:\|:>\|::\|<<\|>>>\?\|//\|[-=]>\|\.\{3\}' .
+      \           '\|'  . '[' . s:uniop_chars . '!$]' .
+      \           '\|'  . '\.\?[' . s:binop_chars . s:binop_chars_extra . ']' .
+      \           '\)'
+
+function! julia#idundercursor()
+    " TODO...
+    let w = expand('<cword>')
+    " let [l,c] = [line('.'),col('.')]
+    " let ll = getline(l)
+    return w
+endfunction
+
+function! julia#gotodefinition()
+    let w = julia#idundercursor()
+    if empty(w)
+        return ''
+    endif
+    let [l,c] = [line('.'),col('.')]
+    let st = map(synstack(l,c), 'synIDattr(v:val, "name")')
+    let n = len(st)
+    if n > 0 && st[-1] =~# '^julia\%(\%(Range\|Ternary\|CTrans\)\?Operator\|\%(Possible\)\?SymbolS\?\|\%(Bl\|Rep\)\?Keyword\|Conditional\|ParDelim\|Char\|Colon\|Typedef\|Number\|Float\|Const\%(Generic\|Bool\)\|ComplexUnit\|\%(Special\|\%(Octal\|Hex\)Escape\)Char\|UniChar\%(Small\|Large\)\|Comment[LM]\|Todo\|Semicolon\)$'
+        return ''
+    endif
+
+    let comprehension = 0
+    let indollar = 0
+    for i in range(n-1, 0, -1)
+        if st[i] =~# '^juliaDollar\%(Var\|Par\|SqBra\)$'
+            let indollar = 1
+        endif
+        if !indollar && st[i] =~# '^julia\%(\a*String\|QuotedParBlockS\?\)$'
+            return ''
+        endif
+        if st[i] =~# '^julia\%(ParBlock\%(InRange\)\?\|SqBraBlock\|\%(Dollar\|StringVars\)\%(Par\|SqBra\)\)$'
+            let comprehension = 1
+        endif
+    endfor
+
+    let s1 = search('\C\<' . w . '\s*=[^=]', 'bcWzs')
+
+    return
+endfunction
+
+endif
+

autoload/julia/doc.vim

@@ -0,0 +1,246 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+
+" path to the julia binary to communicate with
+if has('win32') || has('win64')
+  if exists('g:julia#doc#juliapath')
+    " use assigned g:julia#doc#juliapath
+  elseif executable('julia')
+    " use julia command in PATH
+    let g:julia#doc#juliapath = 'julia'
+  else
+    " search julia binary in the default installation paths
+    let pathlist = sort(glob($LOCALAPPDATA . '\Julia-*\bin\julia.exe', 1, 1))
+    let g:julia#doc#juliapath = get(pathlist, -1, 'julia')
+  endif
+else
+  let g:julia#doc#juliapath = get(g:, 'julia#doc#juliapath', 'julia')
+endif
+
+function! s:version() abort
+  let VERSION = {'major': 0, 'minor': 0}
+  if !executable(g:julia#doc#juliapath)
+    return VERSION
+  endif
+
+  let cmd = printf('%s -v', g:julia#doc#juliapath)
+  let output = system(cmd)
+  let versionstr = matchstr(output, '\C^julia version \zs\d\+\.\d\+\ze')
+  let [major, minor] = map(split(versionstr, '\.'), 'str2nr(v:val)')
+  let VERSION.major = major
+  let VERSION.minor = minor
+  return VERSION
+endfunction
+
+let s:VERSION = s:version()
+let s:NODOCPATTERN = '\C\VNo documentation found.'
+
+function! julia#doc#lookup(keyword, ...) abort
+  let juliapath = get(a:000, 0, g:julia#doc#juliapath)
+  let keyword = escape(a:keyword, '"\')
+  let cmd = printf('%s -E "@doc %s"', juliapath, keyword)
+  return systemlist(cmd)
+endfunction
+
+function! julia#doc#open(keyword) abort
+  if empty(a:keyword)
+    call s:warn('Not an appropriate keyword.')
+    return
+  endif
+
+  if !executable(g:julia#doc#juliapath)
+    call s:warn('%s command is not executable', g:julia#doc#juliapath)
+    return
+  endif
+
+  let doc = julia#doc#lookup(a:keyword, g:julia#doc#juliapath)
+  if empty(doc) || match(doc[0], s:NODOCPATTERN) > -1
+    call s:warn('No documentation found for "%s".', a:keyword)
+    return
+  endif
+
+  " workaround for * and ? since a buffername cannot include them
+  let keyword = a:keyword
+  let keyword = substitute(keyword, '\*', ':asterisk:', 'g')
+  let keyword = substitute(keyword, '?', ':question:', 'g')
+  let buffername = printf('juliadoc: %s', keyword)
+
+  call s:write_to_preview_window(doc, "juliadoc", buffername)
+
+  call filter(s:HELPHISTORY, 'v:val isnot# a:keyword')
+  call add(s:HELPHISTORY, a:keyword)
+endfunction
+
+function! s:write_to_preview_window(content, ftype, buffername)
+  " Are we in the preview window from the outset? If not, best to close any
+  " preview windows that might exist.
+  let pvw = &previewwindow
+  if !pvw
+    silent! pclose!
+  endif
+  execute "silent! pedit +setlocal\\ nobuflisted\\ noswapfile\\"
+        \ "buftype=nofile\\ bufhidden=wipe" a:buffername
+  silent! wincmd P
+  if &previewwindow
+    setlocal modifiable noreadonly
+    silent! %delete _
+    call append(0, a:content)
+    silent! $delete _
+    normal! ggj
+    setlocal nomodified readonly nomodifiable
+    execute "setfiletype" a:ftype
+    " Only return to a normal window if we didn't start in a preview window.
+    if !pvw
+      silent! wincmd p
+    endif
+  else
+    " We couldn't make it to the preview window, so as a fallback we dump the
+    " contents in the status area.
+    execute printf("echo '%s'", join(a:content, "\n"))
+  endif
+endfunction
+
+function! s:warn(...) abort
+  if a:0 == 0
+    return
+  endif
+
+  echohl WarningMsg
+  try
+    if a:0 == 1
+      echo a:1
+    else
+      echo call('printf', a:000)
+    endif
+  finally
+    echohl None
+  endtry
+endfunction
+
+
+
+let s:KEYWORDPATTERN = '\m@\?\h\k*!\?'
+
+" This function is called in normal mode or visual mode.
+function! julia#doc#keywordprg(word) abort
+  if a:word is# ''
+    return
+  endif
+
+  let word = s:unfnameescape(a:word)
+  if word is# expand('<cword>')
+    " 'K' in normal mode
+    " NOTE: Because ! and @ is not in 'iskeyword' option, this func ignore
+    "       the argument to recognize keywords like "@time" and "push!"
+    let view = winsaveview()
+    let lnum = line('.')
+    let tail = searchpos(s:KEYWORDPATTERN, 'ce', lnum)
+    let head = searchpos(s:KEYWORDPATTERN, 'bc', lnum)
+    call winrestview(view)
+    if head == [0, 0] || tail == [0, 0]
+      return
+    else
+      let start = head[1] - 1
+      let end = tail[1] - 1
+      let word = getline(lnum)[start : end]
+    endif
+  endif
+  call julia#doc#open(word)
+endfunction
+
+if exists('+shellslash')
+  let s:ESCAPEDCHARS = " \t\n\"#%'*<?`|"
+else
+  let s:ESCAPEDCHARS = " \t\n*?[{`$\\%#'\"|!<"
+endif
+let s:FNAMEESCAPEPATTERN = '\\\ze[' . escape(s:ESCAPEDCHARS, ']^-\') . ']'
+
+" this function reproduces an original string escaped by fnameescape()
+function! s:unfnameescape(str) abort
+  if a:str is# ''
+    return ''
+  endif
+
+  " NOTE: We cannot determine the original string if a:str starts from '\-',
+  "       '\+' or '\>' because fnameescape('-') ==# fnameescape('\-').
+  if a:str is# '\-'
+    " Remove escape anyway.
+    return '-'
+  endif
+
+  if a:str =~# '^\\[+>]'
+    let str = a:str[1:]
+  else
+    let str = a:str
+  endif
+  return substitute(str, s:FNAMEESCAPEPATTERN, '', 'g')
+endfunction
+
+
+
+let s:HELPPROMPT = 'help?> '
+let s:HELPHISTORY = []
+
+function! julia#doc#prompt() abort
+  let inputhist = s:savehistory('input')
+  echohl MoreMsg
+  try
+    call s:restorehistory('input', s:HELPHISTORY)
+    let keyword = input(s:HELPPROMPT, '', 'customlist,julia#doc#complete')
+
+    " Clear the last prompt
+    normal! :
+  finally
+    echohl None
+    call s:restorehistory('input', inputhist)
+  endtry
+
+  if empty(keyword)
+    return
+  endif
+
+  call julia#doc#open(keyword)
+endfunction
+
+function! s:savehistory(name) abort
+  if histnr(a:name) == -1
+    return []
+  endif
+
+  let history = []
+  for i in range(1, histnr(a:name))
+    let item = histget(a:name, i)
+    if !empty(item)
+      call add(history, item)
+    endif
+  endfor
+  return history
+endfunction
+
+function! s:restorehistory(name, history) abort
+  call histdel(a:name)
+  for item in a:history
+    call histadd(a:name, item)
+  endfor
+endfunction
+
+
+
+if s:VERSION.major == 0 && s:VERSION.minor <= 6
+  let s:REPL_SEARCH = 'Base.Docs.repl_search'
+else
+  let s:REPL_SEARCH = 'import REPL.repl_search; repl_search'
+endif
+
+function! julia#doc#complete(ArgLead, CmdLine, CursorPos) abort
+  return s:likely(a:ArgLead)
+endfunction
+
+function! s:likely(str) abort
+  " escape twice
+  let str = escape(escape(a:str, '"\'), '"\')
+  let cmd = printf('%s -E "%s(\"%s\")"', g:julia#doc#juliapath, s:REPL_SEARCH, str)
+  let output = systemlist(cmd)
+  return split(matchstr(output[0], '\C^search: \zs.*'))
+endfunction
+
+endif

autoload/julia_blocks.vim

@@ -0,0 +1,798 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'julia') == -1
+
+" Facilities for moving around Julia blocks (e.g. if/end, function/end etc.)
+" (AKA a collection of horrible hacks)
+
+let s:default_mappings = {
+  \  "moveblock_n" : "]]",
+  \  "moveblock_N" : "][",
+  \  "moveblock_p" : "[[",
+  \  "moveblock_P" : "[]",
+  \
+  \  "move_n" : "]j",
+  \  "move_N" : "]J",
+  \  "move_p" : "[j",
+  \  "move_P" : "[J",
+  \
+  \  "select_a" : "aj",
+  \  "select_i" : "ij",
+  \
+  \  "whereami" : "",
+  \  }
+
+function! s:getmapchars(function)
+  if exists("g:julia_blocks_mappings") && has_key(g:julia_blocks_mappings, a:function)
+    return s:escape(g:julia_blocks_mappings[a:function])
+  else
+    return s:escape(s:default_mappings[a:function])
+  endif
+endfunction
+
+function! s:map_move(function, toend, backwards)
+  let chars = s:getmapchars(a:function)
+  if empty(chars)
+    return
+  endif
+  let fn = "julia_blocks#" . a:function
+  let lhs = "<buffer> <nowait> <silent> " . chars . " "
+  let cnt = ":<C-U>let b:jlblk_count=v:count1"
+  exe "nnoremap " . lhs . cnt
+    \ . " <Bar> call " . fn . "()<CR>"
+  exe "onoremap " . lhs . cnt
+    \ . "<CR><Esc>:call julia_blocks#owrapper_move(v:operator, \"" . fn . "\", " . a:toend . ", " . a:backwards . ")<CR>"
+  exe "xnoremap " . lhs . cnt
+    \ . "<CR>gv<Esc>:call julia_blocks#vwrapper_move(\"" . fn . "\")<CR>"
+  let b:jlblk_mapped[a:function] = 1
+endfunction
+
+function! julia_blocks#owrapper_move(oper, function, toend, backwards)
+  let F = function(a:function)
+
+  let save_redraw = &lazyredraw
+  let save_select = &selection
+
+  let restore_cmds = "\<Esc>"
+    \ . ":let &l:selection = \"" . save_select . "\"\<CR>"
+    \ . ":let &l:lazyredraw = " . save_redraw . "\<CR>"
+    \ . ":\<BS>"
+
+  setlocal lazyredraw
+
+  let start_pos = getpos('.')
+  let b:jlblk_abort_calls_esc = 0
+  call F()
+  let b:jlblk_abort_calls_esc = 1
+  let end_pos = getpos('.')
+  if start_pos == end_pos
+    call feedkeys(restore_cmds, 'n')
+  endif
+
+  let &l:selection = "inclusive"
+  if a:backwards || !a:toend
+    let &l:selection = "exclusive"
+  endif
+  if a:toend && a:backwards
+    let end_pos[2] += 1
+  endif
+
+  if s:compare_pos(start_pos, end_pos) > 0
+    let [start_pos, end_pos] = [end_pos, start_pos]
+  endif
+
+  call setpos("'<", start_pos)
+  call setpos("'>", end_pos)
+
+  " NOTE: the 'c' operator behaves differently, for mysterious reasons. We
+  "       simulate it with 'd' followed by 'i' instead
+  call feedkeys("gv" . (a:oper == "c" ? "d" : a:oper) . restore_cmds . (a:oper == "c" ? "i" : ""), 'n')
+endfunction
+
+function! julia_blocks#vwrapper_move(function)
+  let F = function(a:function)
+
+  let s = getpos('.')
+  let b1 = getpos("'<")
+  let b2 = getpos("'>")
+
+  let b = b1 == s ? b2 : b1
+  call setpos('.', s)
+  let b:jlblk_abort_calls_esc = 0
+  call F()
+  let b:jlblk_abort_calls_esc = 1
+  let e = getpos('.')
+  call setpos('.', b)
+  exe "normal " . visualmode()
+  call setpos('.', e)
+endfunction
+
+function! s:unmap(function)
+  if !get(b:jlblk_mapped, a:function, 0)
+    return
+  endif
+  let chars = s:getmapchars(a:function)
+  if empty(chars)
+    " shouldn't happen
+    return
+  endif
+  let mapids = a:function =~# "^move" ? ["n", "x", "o"] :
+	\      a:function =~# "^select" ? ["x", "o"] :
+	\      ["n"]
+  let fn = "julia_blocks#" . a:function
+  let cmd = "<buffer> " . chars
+  for m in mapids
+    exe m . "unmap " . cmd
+  endfor
+  let b:jlblk_mapped[a:function] = 0
+endfunction
+
+function! s:escape(chars)
+  let c = a:chars
+  let c = substitute(c, '|', '<Bar>', 'g')
+  return c
+endfunction
+
+function! s:map_select(function)
+  let chars = s:getmapchars(a:function)
+  if empty(chars)
+    return
+  endif
+  let fn = "julia_blocks#" . a:function
+  let lhs = "<buffer> <nowait> <silent> " . chars . " "
+  let cnt = ":<C-U>let b:jlblk_inwrapper=1<CR>:let b:jlblk_count=max([v:prevcount,1])<CR>"
+  exe "onoremap " . lhs . "<Esc>" . cnt
+    \ . ":call julia_blocks#owrapper_select(v:operator, \"" . fn . "\")<CR>"
+  exe "xnoremap " . lhs . cnt
+    \ . ":call julia_blocks#vwrapper_select(\"" . fn . "\")<CR>"
+  let b:jlblk_mapped[a:function] = 1
+endfunction
+
+function! julia_blocks#owrapper_select(oper, function) ", toend, backwards)
+  let F = function(a:function)
+
+  let save_redraw = &lazyredraw
+  let save_select = &selection
+
+  let restore_cmds = "\<Esc>"
+    \ . ":let &l:selection = \"" . save_select . "\"\<CR>"
+    \ . ":let &l:lazyredraw = " . save_redraw . "\<CR>"
+    \ . ":\<BS>"
+
+  setlocal lazyredraw
+
+  let b:jlblk_abort_calls_esc = 0
+  let retF = F()
+  let b:jlblk_abort_calls_esc = 1
+  if empty(retF)
+    let b:jlblk_inwrapper = 0
+    call feedkeys(restore_cmds, 'n')
+    return
+  end
+  let [start_pos, end_pos] = retF
+
+  if start_pos == end_pos
+    call feedkeys(restore_cmds, 'n')
+  endif
+
+  let &l:selection = "inclusive"
+
+  call setpos("'<", start_pos)
+  call setpos("'>", end_pos)
+
+  let b:jlblk_inwrapper = 0
+  " NOTE: the 'c' operator behaves differently, for mysterious reasons. We
+  "       simulate it with 'd' followed by 'i' instead
+  call feedkeys("gv" . (a:oper == "c" ? "d" : a:oper) . restore_cmds . (a:oper == "c" ? "i" : ""), 'n')
+endfunction
+
+function! julia_blocks#vwrapper_select(function)
+  let F = function(a:function)
+
+  let b:jlblk_abort_calls_esc = 0
+  let retF = F()
+  let b:jlblk_abort_calls_esc = 1
+  if empty(retF)
+    let b:jlblk_inwrapper = 0
+    return
+  end
+  let [start_pos, end_pos] = retF
+  call setpos("'<", start_pos)
+  call setpos("'>", end_pos)
+  normal! gv
+  let b:jlblk_inwrapper = 0
+endfunction
+
+function! s:map_aux(function)
+  let chars = s:getmapchars(a:function)
+  if empty(chars)
+    return
+  endif
+  let fn = "julia_blocks#" . a:function
+  let lhs = "<buffer> <nowait> <silent> " . chars . " "
+  exe "nnoremap " . lhs . ":<C-U>echo " . fn . "()<CR>"
+  let b:jlblk_mapped[a:function] = 1
+endfunction
+
+let s:julia_blocks_functions = {
+      \  "moveblock_N": [1, 0],
+      \  "moveblock_n": [0, 0],
+      \  "moveblock_p": [0, 1],
+      \  "moveblock_P": [1, 1],
+      \
+      \  "move_N": [1, 0],
+      \  "move_n": [0, 0],
+      \  "move_p": [0, 1],
+      \  "move_P": [1, 1],
+      \
+      \  "select_a": [],
+      \  "select_i": [],
+      \
+      \  "whereami": [],
+      \  }
+
+function! julia_blocks#init_mappings()
+  let b:jlblk_mapped = {}
+  for f in keys(s:julia_blocks_functions)
+    if f =~# "^move"
+      let [te, bw] = s:julia_blocks_functions[f]
+      call s:map_move(f, te, bw)
+    elseif f =~# "^select"
+      call s:map_select(f)
+    else
+      call s:map_aux(f)
+    endif
+  endfor
+  call julia_blocks#select_reset()
+  augroup JuliaBlocks
+    au!
+    au InsertEnter <buffer> call julia_blocks#select_reset()
+    au CursorMoved <buffer> call s:cursor_moved()
+  augroup END
+
+  " we would need some autocmd event associated with exiting from
+  " visual mode, but there isn't any, so we resort to this crude
+  " hack
+  " ACTUALLY this creates more problems than it solves, so the crude hack
+  " is just disabled
+  "vnoremap <buffer><silent><unique> <Esc> <Esc>:call julia_blocks#select_reset()<CR>
+endfunction
+
+function! julia_blocks#remove_mappings()
+  if exists("b:jlblk_mapped")
+    for f in keys(s:julia_blocks_functions)
+      call s:unmap(f)
+    endfor
+  endif
+  unlet! b:jlblk_save_pos b:jlblk_view b:jlblk_count b:jlblk_abort_calls_esc
+  unlet! b:jlblk_inwrapper b:jlblk_did_select b:jlblk_doing_select
+  unlet! b:jlblk_last_start_pos b:jlblk_last_end_pos b:jlblk_last_mode
+  augroup JuliaBlocks
+    au!
+  augroup END
+  augroup! JuliaBlocks
+  let md = maparg("<Esc>", "x", 0, 1)
+  if !empty(md) && md["buffer"]
+    vunmap <buffer> <Esc>
+  endif
+endfunction
+
+function! s:restore_view()
+  "redraw! " would ensure correct behaviour, but is annoying
+  let pos = getpos('.')
+  if pos == b:jlblk_save_pos
+    call winrestview(b:jlblk_view)
+    return
+  endif
+  let oldtopline = b:jlblk_view["topline"]
+  let newtopline = winsaveview()["topline"]
+  let l = pos[1]
+  if l >= oldtopline + &l:scrolloff && l <= oldtopline + winheight(0) - 1 - &l:scrolloff
+    if newtopline > oldtopline
+      exe ":normal! " . (newtopline - oldtopline) . "\<C-Y>"
+    elseif newtopline < oldtopline
+      exe ":normal! " . (oldtopline - newtopline) . "\<C-E>"
+    endif
+  " these reduce the scrolling to the minimum (which is maybe not
+  " standard ViM behaviour?)
+  elseif newtopline < oldtopline && (l - newtopline - &l:scrolloff) > 0
+    exe ":normal! " . (l - newtopline - &l:scrolloff) . "\<C-E>"
+  elseif newtopline > oldtopline && (newtopline + &l:scrolloff - l) > 0
+    exe ":normal! " . (l - newtopline - &l:scrolloff) . "\<C-E>"
+  endif
+  call setpos('.', pos) " make sure we didn't screw up
+                        " (since winsaveview may not be up to date)
+endfunction
+
+function! s:abort()
+  call setpos('.', b:jlblk_save_pos)
+  call s:restore_view()
+  if get(b:, "jlblk_abort_calls_esc", 1)
+    call feedkeys("\<Esc>", 'n')
+  endif
+  return 0
+endfunction
+
+function! s:set_mark_tick(...)
+  " This could be a one-liner:
+  "   call setpos("''", b:jlblk_save_pos)
+  " but we want to append to the jumplist,
+  " which setpos doesn't do
+  let p = getpos('.')
+  call setpos('.', b:jlblk_save_pos)
+  normal! m'
+  call setpos('.', p)
+endfunction
+
+function! s:get_save_pos(...)
+  if !exists("b:jlblk_save_pos") || (a:0 == 0) || (a:0 > 0 && a:1)
+    let b:jlblk_save_pos = getpos('.')
+  endif
+  let b:jlblk_view = winsaveview()
+endfunction
+
+function! s:on_end()
+  return getline('.')[col('.')-1] =~# '\k' && expand("<cword>") =~# b:julia_end_keywords
+endfunction
+
+function! s:on_begin()
+  let [l,c] = [line('.'), col('.')]
+  normal! ^
+  let patt = '\%<'.(c+1).'c\(' . b:julia_begin_keywordsm . '\)\%>'.(c-1).'c'
+  let n = search(patt, 'Wnc', l)
+  call cursor(l, c)
+  return n > 0
+endfunction
+
+function! s:matchit()
+  let lkj = exists(":lockjumps") == 2 ? "lockjumps " : ""
+  exe lkj . "normal %"
+endfunction
+
+function! s:move_before_begin()
+  call search(b:julia_begin_keywordsm, 'Wbc')
+  normal! h
+endfunction
+
+function! s:cycle_until_end()
+  let pos = getpos('.')
+  while !s:on_end()
+    call s:matchit()
+    let c = 0
+    if getpos('.') == pos || c > 1000
+      " shouldn't happen, but let's avoid infinite loops anyway
+      return 0
+    endif
+    let c += 1
+  endwhile
+  return 1
+endfunction
+
+function! s:moveto_block_delim(toend, backwards, ...)
+  let pattern = a:toend ? b:julia_end_keywords : b:julia_begin_keywordsm
+  let flags = a:backwards ? 'Wb' : 'W'
+  let cnt = a:0 > 0 ? a:1 : b:jlblk_count
+  if !a:toend && a:backwards && s:on_begin()
+    call s:move_before_begin()
+  endif
+  let ret = 0
+  for c in range(cnt)
+    if a:toend && a:backwards && s:on_end()
+      normal! l
+      normal! bh
+    endif
+    while 1
+      let searchret = search(pattern, flags)
+      if !searchret
+	return ret
+      endif
+      exe "let skip = " . b:match_skip
+      if !skip
+	let ret = 1
+	break
+      endif
+    endwhile
+  endfor
+  return ret
+endfunction
+
+function! s:compare_pos(pos1, pos2)
+  if a:pos1[1] < a:pos2[1]
+    return -1
+  elseif a:pos1[1] > a:pos2[1]
+    return 1
+  elseif a:pos1[2] < a:pos2[2]
+    return -1
+  elseif a:pos1[2] > a:pos2[2]
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! julia_blocks#move_N()
+  call s:get_save_pos()
+
+  let ret = s:moveto_block_delim(1, 0)
+  if !ret
+    return s:abort()
+  endif
+
+  normal! e
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#move_n()
+  call s:get_save_pos()
+
+  let ret = s:moveto_block_delim(0, 0)
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#move_p()
+  call s:get_save_pos()
+
+  let ret = s:moveto_block_delim(0, 1)
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#move_P()
+  call s:get_save_pos()
+
+  let ret = s:moveto_block_delim(1, 1)
+  if !ret
+    return s:abort()
+  endif
+
+  normal! e
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! s:moveto_currentblock_end()
+  let flags = 'W'
+  if s:on_end()
+    let flags .= 'c'
+    " NOTE: using "normal! lb" fails at the end of the file (?!)
+    normal! l
+    normal! b
+  endif
+
+  let ret = searchpair(b:julia_begin_keywordsm, '', b:julia_end_keywords, flags, b:match_skip)
+  if ret <= 0
+    return s:abort()
+  endif
+
+  normal! e
+  return 1
+endfunction
+
+function! julia_blocks#moveblock_N()
+  call s:get_save_pos()
+
+  let ret = 0
+  for c in range(b:jlblk_count)
+    let last_seen_pos = getpos('.')
+    if s:on_end()
+      normal! hel
+      let save_pos = getpos('.')
+      let ret_start = s:moveto_block_delim(0, 0, 1)
+      let start1_pos = ret_start ? getpos('.') : [0,0,0,0]
+      call setpos('.', save_pos)
+      if s:on_end()
+	normal! h
+      endif
+      let ret_end = s:moveto_block_delim(1, 0, 1)
+      let end1_pos = ret_end ? getpos('.')  : [0,0,0,0]
+
+      if ret_start && (!ret_end || s:compare_pos(start1_pos, end1_pos) < 0)
+	call setpos('.', start1_pos)
+      else
+	call setpos('.', save_pos)
+      endif
+    endif
+
+    let moveret = s:moveto_currentblock_end()
+    if !moveret && c == 0
+      let moveret = s:moveto_block_delim(0, 0, 1) && s:cycle_until_end()
+      if moveret
+        normal! e
+      endif
+    endif
+    if !moveret
+      call setpos('.', last_seen_pos)
+      break
+    endif
+
+    let ret = 1
+  endfor
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#moveblock_n()
+  call s:get_save_pos()
+
+  let ret = 0
+  for c in range(b:jlblk_count)
+    let last_seen_pos = getpos('.')
+
+    call s:moveto_currentblock_end()
+    if s:moveto_block_delim(0, 0, 1)
+      let ret = 1
+    else
+      call setpos('.', last_seen_pos)
+      break
+    endif
+  endfor
+
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+
+  return 1
+endfunction
+
+function! julia_blocks#moveblock_p()
+  call s:get_save_pos()
+
+  let ret = 0
+  for c in range(b:jlblk_count)
+    let last_seen_pos = getpos('.')
+    if s:on_begin()
+      call s:move_before_begin()
+      if s:on_end()
+	normal! l
+      endif
+      let save_pos = getpos('.')
+      let ret_start = s:moveto_block_delim(0, 1, 1)
+      let start1_pos = ret_start ? getpos('.') : [0,0,0,0]
+      call setpos('.', save_pos)
+      let ret_end = s:moveto_block_delim(1, 1, 1)
+      let end1_pos = ret_end ? getpos('.') : [0,0,0,0]
+
+      if ret_end && (!ret_start || s:compare_pos(start1_pos, end1_pos) < 0)
+	call setpos('.', end1_pos)
+      else
+	call setpos('.', save_pos)
+      endif
+    endif
+
+    let moveret = s:moveto_currentblock_end()
+    if !moveret && c == 0
+      let moveret = s:moveto_block_delim(1, 1, 1)
+    endif
+    if !moveret
+      call setpos('.', last_seen_pos)
+      break
+    endif
+
+    call s:matchit()
+    let ret = 1
+  endfor
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+  call s:restore_view()
+
+  return 1
+endfunction
+
+function! julia_blocks#moveblock_P()
+  call s:get_save_pos()
+
+  let ret = 0
+  for c in range(b:jlblk_count)
+    let last_seen_pos = getpos('.')
+
+    call s:moveto_currentblock_end()
+    if s:on_end()
+      call s:matchit()
+    endif
+
+    if s:moveto_block_delim(1, 1, 1)
+      " NOTE: normal! he does not work unless &whichwrap inlcudes h
+      normal! h
+      normal! e
+      let ret = 1
+    else
+      call setpos('.', last_seen_pos)
+    endif
+  endfor
+
+  if !ret
+    return s:abort()
+  endif
+
+  call s:set_mark_tick()
+  call s:restore_view()
+
+  return 1
+endfunction
+
+function! julia_blocks#whereami()
+  let b:jlblk_count = v:count1
+  let save_redraw = &lazyredraw
+  setlocal lazyredraw
+  let pos = getpos('.')
+  let ret = julia_blocks#select_a('w')
+  if empty(ret)
+    call setpos('.', pos)
+    let &l:lazyredraw = save_redraw
+    return ""
+  end
+  let [start_pos, end_pos] = ret
+  let m = getline(start_pos[1])[start_pos[2]-1:]
+
+  " If cursor_moved was not forced from select_a, we force it now
+  " (TODO: this is *really* ugly)
+  if end_pos != pos
+    call s:cursor_moved(1)
+  endif
+  call setpos('.', pos)
+  call s:restore_view()
+  let &l:lazyredraw = save_redraw
+  return m
+endfunction
+
+" Block text objects
+
+function! s:find_block(current_mode)
+
+  let flags = 'W'
+
+  if b:jlblk_did_select
+    call setpos('.', b:jlblk_last_start_pos)
+    if !s:cycle_until_end()
+      return s:abort()
+    endif
+    if !(a:current_mode[0] == 'a' && a:current_mode == b:jlblk_last_mode)
+      let flags .= 'c'
+    endif
+  elseif s:on_end()
+    let flags .= 'c'
+    " NOTE: using "normal! lb" fails at the end of the file (?!)
+    normal! l
+    normal! b
+  endif
+  let searchret = searchpair(b:julia_begin_keywordsm, '', b:julia_end_keywords, flags, b:match_skip)
+  if searchret <= 0
+    if !b:jlblk_did_select
+      return s:abort()
+    else
+     call setpos('.', b:jlblk_last_end_pos)
+    endif
+  endif
+
+  let end_pos = getpos('.')
+  " Jump to match
+  call s:matchit()
+  let start_pos = getpos('.')
+
+  let b:jlblk_last_start_pos = copy(start_pos)
+  let b:jlblk_last_end_pos = copy(end_pos)
+
+  return [start_pos, end_pos]
+endfunction
+
+function! s:repeated_find(ai_mode)
+  let repeat = b:jlblk_count + (a:ai_mode == 'i' && v:count1 > 1 ? 1 : 0)
+  for c in range(repeat)
+    let current_mode = (c < repeat - 1 ? 'a' : a:ai_mode)
+    let ret_find_block = s:find_block(current_mode)
+    if empty(ret_find_block)
+      return 0
+    endif
+    let [start_pos, end_pos] = ret_find_block
+    call setpos('.', end_pos)
+    let b:jlblk_last_mode = current_mode
+    if c < repeat - 1
+      let b:jlblk_doing_select = 0
+      let b:jlblk_did_select = 1
+    endif
+  endfor
+  return [start_pos, end_pos]
+endfunction
+
+function! julia_blocks#select_a(...)
+  let mode_flag = a:0 > 0 ? a:1 : ''
+  call s:get_save_pos(!b:jlblk_did_select)
+  let current_pos = getpos('.')
+  let ret_find_block = s:repeated_find('a' . mode_flag)
+  if empty(ret_find_block)
+    return 0
+  endif
+  let [start_pos, end_pos] = ret_find_block
+
+  call setpos('.', end_pos)
+  normal! e
+  let end_pos = getpos('.')
+
+  let b:jlblk_doing_select = 1
+
+  " CursorMove is only triggered if end_pos
+  " end_pos is different than the staring position;
+  " so when starting from the 'd' in 'end' we need to
+  " force it
+  if current_pos == end_pos
+    call s:cursor_moved(1)
+  endif
+
+  call s:set_mark_tick()
+  return [start_pos, end_pos]
+endfunction
+
+function! julia_blocks#select_i()
+  call s:get_save_pos(!b:jlblk_did_select)
+  let current_pos = getpos('.')
+  let ret_find_block = s:repeated_find('i')
+  if empty(ret_find_block)
+    return 0
+  endif
+  let [start_pos, end_pos] = ret_find_block
+
+  if end_pos[1] <= start_pos[1]+1
+    return s:abort()
+  endif
+
+  call setpos('.', end_pos)
+
+  let b:jlblk_doing_select = 1
+
+  let start_pos[1] += 1
+  call setpos('.', start_pos)
+  normal! ^
+  let start_pos = getpos('.')
+  let end_pos[1] -= 1
+  let end_pos[2] = len(getline(end_pos[1]))
+
+  " CursorMove is only triggered if end_pos
+  " end_pos is different than the staring position;
+  " so when starting from the 'd' in 'end' we need to
+  " force it
+  if current_pos == end_pos
+    call s:cursor_moved(1)
+  endif
+
+  call s:set_mark_tick()
+  return [start_pos, end_pos]
+endfunction
+
+function julia_blocks#select_reset()
+  let b:jlblk_did_select = 0
+  let b:jlblk_doing_select = 0
+  let b:jlblk_inwrapper = 0
+  let b:jlblk_last_mode = ""
+endfunction
+
+function! s:cursor_moved(...)
+  if b:jlblk_inwrapper && !(a:0 > 0 && a:1)
+    return
+  endif
+  let b:jlblk_did_select = b:jlblk_doing_select
+  let b:jlblk_doing_select = 0
+endfunction
+
+endif

autoload/pony.vim

@@ -0,0 +1,536 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'pony') == -1
+
+" Vim plugin file
+" Language:     Pony
+" Maintainer:   Jak Wings
+
+" TODO: Make sure echomsg is off for release.
+let s:cpo_save = &cpo
+set cpo&vim
+
+
+"let s:skip = '<SID>InCommentOrLiteral(line("."), col("."))'
+let s:skip2 = '<SID>InLiteral(line("."), col(".")) || <SID>InComment(line("."), col(".")) == 1'
+let s:skip3 = '!<SID>InKeyword(line("."), col("."))'
+let s:skip4 = '!<SID>InBracket(line("."), col("."))'
+let s:cfstart = '\v<%(ifdef|if|match|while|for|repeat|try|with|recover|object|lambda|iftype)>'
+let s:cfmiddle = '\v<%(then|elseif|else|until|do|in|elseiftype)>|\|'
+let s:cfend = '\v<end>'
+let s:bstartp = '\v<%(ifdef|if|then|elseif|else|(match)|while|for|in|do|try|with|recover|repeat|until|(object)|lambda|iftype|elseiftype)>'
+
+function! pony#Indent()
+  if v:lnum <= 1
+    return 0
+  endif
+
+  call cursor(v:lnum, 1)
+  let l:pnzpos = searchpos('.', 'cbnW')
+  if l:pnzpos == [0, 0]
+    return 0
+  endif
+
+  if s:InComment2(l:pnzpos) > 1
+    "echomsg 'Comment' (l:pnzpos[0] . '-' . v:lnum) -1
+    return cindent(v:lnum)
+  endif
+
+  if s:InLiteral2(l:pnzpos)
+    "echomsg 'String' (l:pnzpos[0] . '-' . v:lnum) -1
+    return -1
+  endif
+
+  unlet! l:pnzpos
+
+  " NOTE: Lines started in comments and strings are checked already.
+
+  let l:pnblnum = s:PrevNonblank(v:lnum - 1)
+  if l:pnblnum < 1
+    return 0
+  endif
+
+  let l:pnbline = getline(l:pnblnum)
+  let l:pnbindent = indent(l:pnblnum)
+
+  let l:line = getline(v:lnum)
+  let l:indent = l:pnbindent
+  let l:shiftwidth = shiftwidth()
+
+  " FIXME?
+  let l:continuing = 0
+  " If the previous line ends with a unary or binary operator,
+  if s:IsContinued(l:pnblnum)
+    let l:contlnum = l:pnblnum
+    let l:ppcontinued = 0
+    let l:ppnblnum = s:PrevNonblank(l:pnblnum - 1)
+    while s:IsContinued(l:ppnblnum)
+      let l:ppcontinued += 1
+      let l:contlnum = l:ppnblnum
+      let l:ppnblnum = s:PrevNonblank(l:ppnblnum - 1)
+    endwhile
+    "echomsg 'Continued1' l:pnblnum l:contlnum
+    " If the previous line is also continuing another line,
+    if l:ppcontinued
+      let l:continuing = 1
+      if getline(l:contlnum) =~# '\v^\s*%(actor|class|struct|primitive|trait|type|interface)>'
+        " reset the indent level.
+        "echomsg 'Continuing0' (l:contlnum . '-' . v:lnum) (l:shiftwidth * 2)
+        let l:indent = l:shiftwidth * 2
+      else
+        " keep using the previous indent.
+        "echomsg 'Continuing1' (l:pnblnum . '-' . v:lnum) l:pnbindent
+        let l:indent = l:pnbindent
+      endif
+    " if the previous line is part of the definition of a class,
+    elseif l:pnbline =~# '\v^\s*%(actor|class|struct|primitive|trait|type|interface)>'
+      " reset the indent level.
+      "echomsg 'Continuing2' (l:pnblnum . '-' . v:lnum) (l:shiftwidth * 2)
+      let l:continuing = 1
+      let l:indent = l:shiftwidth * 2
+    " if the previous line is part of the definition of a method,
+    elseif l:pnbline =~# '\v^\s*%(fun|new|be)>'
+      " reset the indent level.
+      "echomsg 'Continuing3' (l:pnblnum . '-' . v:lnum) (l:pnbindent + l:shiftwidth)
+      let l:continuing = 1
+      let l:indent = l:pnbindent + l:shiftwidth
+    " if the previous line is the start of a definition body,
+    elseif l:pnbline =~# '=>\s*$'
+      " indent this line.
+      "echomsg 'Continuing4' (l:pnblnum . '-' . v:lnum) (l:pnbindent + l:shiftwidth)
+      let l:continuing = 1
+      let l:indent = l:pnbindent + l:shiftwidth
+    else
+      " indent this line twice as far.
+      "echomsg 'Continuing5' (l:pnblnum . '-' . v:lnum) (l:pnbindent + l:shiftwidth * 2)
+      let l:continuing = 1
+      let l:indent = l:pnbindent + l:shiftwidth * 2
+    endif
+
+    unlet! l:contlnum l:ppnblnum l:ppcontinued
+  endif
+
+  " If this line starts a document string,
+  if !l:continuing && l:line =~# '^\s*"""'
+    let l:ppnblnum = s:PrevNonblank(l:pnblnum - 1)
+    if s:IsContinued(l:ppnblnum)
+      let l:contlnum = l:ppnblnum
+      while s:IsContinued(l:ppnblnum)
+        let l:contlnum = l:ppnblnum
+        let l:ppnblnum = s:PrevNonblank(l:ppnblnum - 1)
+      endwhile
+      if getline(l:contlnum) =~# '\v^\s*%(actor|class|struct|primitive|trait|type|interface)>'
+        " reset the indent level.
+        "echomsg 'DocString' (l:contlnum . '-' . v:lnum) l:shiftwidth
+        return l:shiftwidth
+      endif
+    endif
+
+    unlet! l:contlnum l:ppnblnum
+  endif
+
+  " If the previous line contains an unmatched opening bracket
+  if !l:continuing && l:pnbline =~# '[{[(]'
+    " if the line ends with an opening bracket,
+    if l:pnbline =~# '[{[(]\s*$' && !s:InCommentOrLiteral(l:pnblnum, col([l:pnblnum, '$']) - 1)
+      " indent this line.
+      let l:indent += l:shiftwidth
+    else
+      " find the unmatched opening bracket,
+      let l:start = [0, 0]
+      let l:end = col([l:pnblnum, '$']) - 1
+      call cursor(l:pnblnum, l:end)
+      while l:end > 0
+        let l:start = s:OuterPos(l:start, searchpairpos('(', '', ')', 'bnW', s:skip4, l:pnblnum))
+        let l:start = s:OuterPos(l:start, searchpairpos('\[', '', '\]', 'bnW', s:skip4, l:pnblnum))
+        let l:start = s:OuterPos(l:start, searchpairpos('{', '', '}', 'bnW', s:skip4, l:pnblnum))
+        if l:start == [0, 0]
+          break
+        endif
+        " find the matched closing bracket on the same line,
+        call cursor(l:start[0], l:start[1])
+        let l:c = s:CharAtCursor(l:start[0], l:start[1])
+        if searchpair(escape(l:c, '['), '', escape(tr(l:c, '([{', ')]}'), ']'),
+              \ 'znW', s:skip4, l:pnblnum) < 1
+          " the unmatched opening bracket is found,
+          break
+        endif
+        let l:end = l:start[1]
+        let l:start = [0, 0]
+      endwhile
+      if l:start != [0, 0]
+        " indent this line.
+        "echomsg 'Open bracket' (l:pnblnum . '-' . v:lnum) (l:indent + l:shiftwidth)
+        let l:indent += l:shiftwidth
+      endif
+    endif
+
+    unlet! l:start l:end l:c
+  endif
+
+  " If there is a matched closing bracket on the previous line,
+  " NOTE:
+  " >|[
+  "  |  (1 -
+  "  |      1) * 2]
+  "  |  command
+  "   ^
+  if !l:continuing
+    call cursor(l:pnblnum, 1)
+    " find the last closing bracket,
+    let l:end = [0, 0]
+    let l:end = s:OuterPos(l:end, searchpairpos('(', '', ')', 'zncr', s:skip4, l:pnblnum))
+    let l:end = s:OuterPos(l:end, searchpairpos('\[', '', '\]', 'zncr', s:skip4, l:pnblnum))
+    let l:end = s:OuterPos(l:end, searchpairpos('{', '', '}', 'zncr', s:skip4, l:pnblnum))
+    if l:end != [0, 0]
+      " find the matched opening bracket on another line,
+      let l:c = s:CharAtCursor(l:end[0], l:end[1])
+      let l:start = searchpairpos(escape(tr(l:c, ')]}', '([{'), '['), '', escape(l:c, ']'), 'nbW', s:skip4)
+      if l:start[0] != l:end[0]
+        " and then this line has the same indent as the line the matched bracket stays.
+        "echomsg 'Matched bracket' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+        let l:indent = indent(l:start[0])
+      endif
+    endif
+
+    unlet! l:start l:end l:c
+  endif
+
+  " If there is a matched closing bracket on this line,
+  " NOTE:
+  "  |[
+  " >|  (1 -
+  "  |      1) * 2
+  "  |]
+  "   ^     ^
+  if l:line =~# '^\s*[)\]}]'
+    " find the first closing bracket,
+    call cursor(v:lnum, 1)
+    let l:end = [0, 0]
+    let l:end = s:InnerPos(l:end, searchpairpos('(', '', ')', 'zncW', s:skip4, v:lnum))
+    let l:end = s:InnerPos(l:end, searchpairpos('\[', '', '\]', 'zncW', s:skip4, v:lnum))
+    let l:end = s:InnerPos(l:end, searchpairpos('{', '', '}', 'zncW', s:skip4, v:lnum))
+    if l:end != [0, 0]
+      " find the matched opening bracket on another line,
+      let l:c = s:CharAtCursor(l:end[0], l:end[1])
+      let l:start = searchpairpos(escape(tr(l:c, ')]}', '([{'), '['), '', escape(l:c, ']'), 'nbW', s:skip4)
+      if l:start[0] != l:end[0]
+        " and then this line has the same indent as the line the matched bracket stays.
+        "echomsg 'Closing Bracket' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+        let l:indent = indent(l:start[0])
+      endif
+    endif
+
+    unlet! l:start l:end l:c
+  endif
+
+  " If this line starts the definition of a method, closure or match case,
+  if l:line =~# '^\s*=>'
+    " find the start of the definition,
+    call cursor(v:lnum, 1)
+    let l:start = searchpairpos('\v<%(new|be|fun|lambda)>|\|', '', '=>\zs', 'bnW', s:skip3)
+    if l:start != [0, 0]
+      " then this line has the same indent as the start.
+      "echomsg 'Method body' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+      return indent(l:start[0])
+    endif
+
+    unlet! l:start
+  endif
+
+  " If this line starts a class definition or starts an alias,
+  if l:line =~# '\v^\s*%(actor|class|struct|primitive|trait|interface|use|type)>'
+    " reset the indent level.
+    return 0
+  endif
+
+  " If this line starts a method definition,
+  if l:line =~# '\v^\s*%(new|be|fun)>'
+    call cursor(v:lnum, 1)
+    let l:start = searchpairpos(s:cfstart, s:cfmiddle, s:cfend, 'bW', s:skip3)
+    if l:start != [0, 0]
+      let l:start = searchpos(s:bstartp, 'zcnpW', l:start[0])
+      " see if it is in an object block,
+      if l:start[2] == 3
+        "echomsg 'Method in object' (l:start[0] . '-' . v:lnum) (l:shiftwidth + indent(l:start[0]))
+        return l:shiftwidth + indent(l:start[0])
+      endif
+    endif
+    return l:shiftwidth
+  endif
+
+  " If this line starts a match case,
+  call cursor(v:lnum, 1)
+  if l:line =~# '^\s*|' && s:InKeyword(searchpos('|', 'znW', v:lnum))
+    " find the start or the previous case of the match block,
+    let l:start = searchpairpos(s:cfstart, s:cfmiddle, s:cfend, 'bnW', s:skip3)
+    if l:start != [0, 0]
+      " then this line has the same indent as the start.
+      "echomsg 'Match case' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+      return indent(l:start[0])
+    endif
+
+    unlet! l:start
+  endif
+
+  " If this line ends (part of) a control flow,
+  if l:line =~# '\v^\s*%(end|elseif|else|then|in|do|until|elseiftype)>'
+    " find the start or middle of the control block,
+    call cursor(v:lnum, 1)
+    let l:start = searchpairpos(s:cfstart, s:cfmiddle, s:cfend, 'bnW', s:skip3)
+    if l:start != [0, 0]
+      " then this line has the same indent as the start.
+      "echomsg 'Block end' (l:start[0] . '-' . v:lnum) indent(l:start[0])
+      return indent(l:start[0])
+    endif
+
+    unlet! l:start
+  endif
+
+  " If the previous line starts a class definition,
+  if l:pnbline =~# '\v^\s*%(actor|class|struct|primitive|trait|type|interface)>'
+    " reset the indent level.
+    if s:IsContinued(l:pnblnum)
+      return l:shiftwidth * 2
+    else
+      return l:shiftwidth
+    endif
+  endif
+
+  " If the previous line starts a method definition,
+  if l:pnbline =~# '\v^\s*%(new|be|fun)>'
+    return l:pnbindent + l:shiftwidth
+  endif
+
+  " If the previous line starts (part of) a control flow,
+  call cursor(l:pnblnum, 1)
+  while 1
+    " find the start of the control block,
+    let l:start = searchpos(s:bstartp, 'zcepW', l:pnblnum)
+    if l:start[2] == 0
+      break
+    endif
+    if !s:InKeyword(l:start[0:1])
+      call cursor(l:pnblnum, l:start[1] + 3)
+      continue
+    endif
+    let l:index = l:start[2]
+    " find the end of the control block on the same line,
+    let l:end = searchpair(s:cfstart, '', s:cfend, 'znW', s:skip3, l:pnblnum)
+    " if the control block is not ended,
+    if l:end < 1
+      " if this line is a case for a match,
+      if l:index == 2 && l:line =~# '^\s*|'
+        " then this line has the same indent as the start of the match block.
+        return l:pnbindent
+      else
+        " then indent this line.
+        "echomsg 'Block start' (l:pnblnum . '-' . v:lnum) (l:pnbindent + l:shiftwidth)
+        return l:pnbindent + l:shiftwidth
+      endif
+    endif
+  endwhile
+
+  unlet! l:start l:end l:index
+
+  return l:indent
+endfunction
+
+function! s:PrevNonblank(lnum)
+  let l:lnum = prevnonblank(a:lnum)
+  while l:lnum > 0 && (s:InComment2(l:lnum, 1) || s:InLiteral2(l:lnum, 1))
+    let l:lnum = prevnonblank(l:lnum - 1)
+  endwhile
+  return l:lnum
+endfunction
+
+" NOTE:
+"                 v
+"  |1 /* comment */
+"  |2
+function! s:IsContinued(lnum)
+  let l:lnum = s:PrevNonblank(a:lnum)
+  if l:lnum < 1
+    return 0
+  endif
+  let l:line = getline(l:lnum)
+  let l:width = strwidth(substitute(l:line, '\s*$', '', ''))
+  " FIXME?
+  "  | 1 + //
+  "  | //
+  "  |     2
+  return !s:InCommentOrLiteral(a:lnum, l:width)
+        \ && (l:line =~# '\v<%(and|or|xor|is|isnt|as|not|consume|addressof|digestof)\s*$'
+        \ || l:line =~# '\v%([=\-.]\>|[<!=>]\=\~?|\<\<\~?|\>\>\~?|\<:|[+\-*/%<>]\~?|[.,|:@~])\s*$'
+        \ )
+endfunction
+
+function! s:InCommentOrLiteral(...)
+  return call('s:InComment', a:000) || call('s:InLiteral', a:000)
+endfunction
+
+function! s:InKeyword(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  for id in s:Or(synstack(l:lnum, l:col), [])
+    if synIDattr(id, 'name') =~# '^ponyKw'
+      return 1
+    endif
+  endfor
+  return 0
+endfunction
+
+function! s:InBracket(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  for id in s:Or(synstack(l:lnum, l:col), [])
+    if synIDattr(id, 'name') ==# 'ponyBracket'
+      return 1
+    endif
+  endfor
+  return 0
+endfunction
+
+function! s:InComment(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  let l:stack = synstack(l:lnum, l:col)
+  let l:i = len(l:stack)
+  while l:i > 0
+    let l:sname = synIDattr(l:stack[l:i - 1], 'name')
+    if l:sname =~# '^ponyNestedCommentX\?$'
+      return 1 + l:i - (l:sname =~# 'X$')
+    elseif l:sname =~# '^ponyCommentX\?$'
+      return 1
+    endif
+    let l:i -= 1
+  endwhile
+  return 0
+endfunction
+
+function! s:InLiteral(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  let l:stack = synstack(l:lnum, l:col)
+  let l:i = len(l:stack)
+  while l:i > 0
+    let l:sname = synIDattr(l:stack[l:i - 1], 'name')
+    if l:sname =~# '^ponyDocumentStringX\?$'
+      return 3
+    elseif l:sname =~# '^ponyStringX\?$'
+      return 2
+    elseif l:sname =~# '^ponyCharacterX\?$'
+      return 1
+    endif
+    let l:i -= 1
+  endwhile
+  return 0
+endfunction
+
+" NOTE:
+" |// //inside
+"   ^^^^^^^^^^
+" |/* /*inside*/ */
+"   ^^^^^^^^^^^^^^
+function! s:InComment2(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  let l:stack = synstack(l:lnum, l:col)
+  let l:i = len(l:stack)
+  while l:i > 0
+    let l:sname = synIDattr(l:stack[l:i - 1], 'name')
+    if l:sname ==# 'ponyNestedComment'
+      return 1 + l:i
+    elseif l:sname ==# 'ponyComment'
+      return 1
+    elseif l:sname =~# '\v^pony%(Nested)?CommentX$'
+      return 0
+    endif
+    let l:i -= 1
+  endwhile
+  return 0
+endfunction
+
+" NOTE:
+" |"inside"
+"   ^^^^^^
+" |"""inside"""""
+"   ^^^^^^^^^^^^
+function! s:InLiteral2(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  let l:stack = synstack(l:lnum, l:col)
+  let l:i = len(l:stack)
+  while l:i > 0
+    let l:sname = synIDattr(l:stack[l:i - 1], 'name')
+    if l:sname ==# 'ponyDocumentString'
+      return 3
+    elseif l:sname ==# 'ponyString'
+      return 2
+    elseif l:sname ==# 'ponyCharacter'
+      return 1
+    elseif l:sname =~# '\v^pony%(DocumentString|String|Character)X$'
+      return 0
+    endif
+    let l:i -= 1
+  endwhile
+  return 0
+endfunction
+
+function! s:CharAtCursor(...)
+  let [l:lnum, l:col] = (type(a:1) == type([]) ? a:1 : a:000)
+  return matchstr(getline(l:lnum), '\%' . l:col . 'c.')
+endfunction
+
+function! s:Or(x, y)
+  return !empty(a:x) ? a:x : a:y
+endfunction
+
+function! s:InnerPos(x, y)
+  if a:x == [0, 0]
+    return a:y
+  elseif a:y == [0, 0]
+    return a:x
+  else
+    return a:x[1] < a:y[1] ? a:x : a:y
+  end
+endfunction
+
+function! s:OuterPos(x, y)
+  if a:x == [0, 0]
+    return a:y
+  elseif a:y == [0, 0]
+    return a:x
+  else
+    return a:x[1] > a:y[1] ? a:x : a:y
+  end
+endfunction
+
+function! pony#ClearTrailingSpace(all, alt, ...)
+  let l:force = (a:0 > 0 ? a:1 : 0)
+  if !l:force && (&readonly || !&modifiable || !&modified)
+    return
+  endif
+  if a:all
+    for lnum in range(1, line('$'))
+      let l:line = getline(lnum)
+      let l:end = col([lnum, '$']) - 1
+      if l:end > 0 && l:line =~# '\s$' && !s:InLiteral(lnum, l:end)
+        if a:alt
+          call setline(lnum, substitute(l:line, '\S\@<=\s\s*$', '', ''))
+        else
+          call setline(lnum, substitute(l:line, '\s\+$', '', ''))
+        endif
+      endif
+    endfor
+  else
+    let l:lnum = line('.')
+    let l:end = col('$') - 1
+    let l:line = getline(l:lnum)
+    if l:line =~# '\s$' && !s:InLiteral(l:lnum, l:end)
+      if a:alt
+        call setline(l:lnum, substitute(l:line, '\s\+$', '', ''))
+      else
+        call setline(l:lnum, substitute(l:line, '\S\@<=\s\s*$', '', ''))
+      endif
+    endif
+  endif
+endfunction
+
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+endif

autoload/puppet/align.vim

@@ -0,0 +1,72 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'puppet') == -1
+
+function! puppet#align#IndentLevel(lnum)
+    return indent(a:lnum) / &shiftwidth
+endfunction
+
+function! puppet#align#LinesInBlock(lnum)
+    let lines = []
+    let indent_level = puppet#align#IndentLevel(a:lnum)
+
+    let marker = a:lnum - 1
+    while marker >= 1
+        let line_text = getline(marker)
+        let line_indent = puppet#align#IndentLevel(marker)
+
+        if line_text =~? '\v\S'
+            if line_indent < indent_level
+                break
+            elseif line_indent == indent_level
+                call add(lines, marker)
+            endif
+        endif
+
+        let marker -= 1
+    endwhile
+
+    let marker = a:lnum
+    while marker <= line('$')
+        let line_text = getline(marker)
+        let line_indent = puppet#align#IndentLevel(marker)
+
+        if line_text =~? '\v\S'
+            if line_indent < indent_level
+                break
+            elseif line_indent == indent_level
+                call add(lines, marker)
+            endif
+        endif
+
+        let marker += 1
+    endwhile
+
+    return lines
+endfunction
+
+""
+" Format lines with hashrocket (=>)
+" @param a:1 a line where function should search for first hashrocket
+"   expression, if param is not given, line with active cursor is used
+function! puppet#align#AlignHashrockets(...) abort
+    let l:lnum = get(a:, 1, line('.'))
+    let lines_in_block = puppet#align#LinesInBlock(l:lnum)
+    let max_left_len = 0
+    let indent_str = printf('%' . indent(l:lnum) . 's', '')
+
+    for line_num in lines_in_block
+        let data = matchlist(getline(line_num), '^\s*\(.\{-}\S\)\s*=>\s*\(.*\)$')
+        if !empty(data)
+            let max_left_len = max([max_left_len, strlen(data[1])])
+        endif
+    endfor
+
+    for line_num in lines_in_block
+        let data = matchlist(getline(line_num), '^\s*\(.\{-}\S\)\s*=>\s*\(.*\)$')
+        if !empty(data)
+            let new_line = printf('%s%-' . max_left_len . 's => %s', indent_str, data[1], data[2])
+            call setline(line_num, new_line)
+        endif
+    endfor
+endfunction
+
+endif

autoload/puppet/ctags.vim

@@ -0,0 +1,40 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'puppet') == -1
+
+
+if !exists('s:ctags_type')
+  let s:ctags_type = 0
+endif
+
+let s:ctags_options_dir = expand('<sfile>:p:h:h:h') . '/ctags/'
+
+" Return full path to option file for ctags application
+function! puppet#ctags#OptionFile()
+
+  if puppet#ctags#Type() == 'universal'
+    let l:ctags_options = 'puppet_u.ctags'
+  else
+    let l:ctags_options = 'puppet.ctags'
+  endif
+  return s:ctags_options_dir . l:ctags_options
+endfunction
+
+" Return type of installed ctags application,
+" can be 'universal' or 'exuberant'
+function! puppet#ctags#Type()
+
+  if !s:ctags_type
+    let l:version = system('ctags --version')
+    if l:version =~ 'Universal Ctags'
+      let s:ctags_type = 'universal'
+    elseif l:version =~ 'Exuberant Ctags'
+      let s:ctags_type = 'exuberant'
+    else
+       echoerr 'Unknown version of Ctags'
+    endif
+  endif
+
+  return s:ctags_type
+endfunction
+
+
+endif

autoload/puppet/format.vim

@@ -0,0 +1,74 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'puppet') == -1
+
+"
+" Simple format using puppet's l:indents and align hashrockets function
+function! puppet#format#Format() abort
+  let l:start_lnum = v:lnum
+  let l:end_lnum = v:lnum + v:count - 1
+  " Don't modify indentation or alignment if called by textwidth. We'll only
+  " let the fallback function do its thing in this case so that textwidth
+  " still performs the expected feature.
+  if mode() !~# '[iR]'
+    call puppet#format#Indention(l:start_lnum, l:end_lnum)
+    call puppet#format#Hashrocket(l:start_lnum, l:end_lnum)
+  endif
+  call puppet#format#Fallback(l:start_lnum, l:end_lnum)
+  " explicitly avoid falling back to default formatting
+  return 0
+endfunction
+
+""
+" Format hashrockets expressions in every line in range start_lnum and
+" end_lnum, both ends included
+"
+" TODO way of using AlignHashrockets function is ineffective, because it
+" formats same lines again and again, find better way to do it
+function! puppet#format#Hashrocket(start_lnum, end_lnum) abort
+  let l:lnum = a:start_lnum
+  while l:lnum <= a:end_lnum
+    call puppet#align#AlignHashrockets(l:lnum)
+    let l:lnum += 1
+  endwhile
+endfunction
+
+""
+" Format indention in every line in range start_lnum and end_lnum, both ends
+" included
+"
+function! puppet#format#Indention(start_lnum, end_lnum) abort
+  execute 'normal! ' . a:start_lnum . 'gg=' . a:end_lnum . 'gg'
+endfunction
+
+""
+" Use internal vim default autoformat method for every line in range, only
+" lines which exeed &widthline are formated
+"
+function! puppet#format#Fallback(start_lnum, end_lnum) abort
+  " We shouldn't wrap lines based on textwidth if it is disabled
+  if &textwidth == 0
+    return
+  endif
+
+  " I'm using it to check if autoformat expand range
+  let l:eof_lnum = line('$')
+  let l:lnum = a:start_lnum
+  let l:end_lnum = a:end_lnum
+
+  while l:lnum <= l:end_lnum
+    if strlen(getline(l:lnum)) > &textwidth
+      call cursor(l:lnum)
+      execute 'normal! gww'
+      " Checking if autoformat expand number of lines if yes, I will extend
+      " range too
+      if l:eof_lnum < line('$')
+        let l:end_lnum += line('$') - l:eof_lnum
+        let l:eof_lnum = line('$')
+      endif
+    endif
+    let l:lnum += 1
+  endwhile
+
+endfunction
+
+
+endif

autoload/python/utils.vim

@@ -0,0 +1,21 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'python-compiler') == -1
+
+" Sometimes Python issues debugging messages
+" which don't belong to a call stack context
+" this function filters these messages
+function! python#utils#fix_qflist() " {{{
+  let l:traceback = []
+  let l:qflist = getqflist()
+
+  for l:item in l:qflist
+    if !empty(l:item.type)
+      call add(l:traceback, l:item)
+    endif
+  endfor
+
+  if !empty(l:traceback)
+    call setqflist(l:traceback)
+  endif
+endfunction " }}}
+
+endif

autoload/rubycomplete.vim

@@ -5,7 +5,6 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'ruby') == -1
 " Maintainer:		Mark Guzman <segfault@hasno.info>
 " URL:			https://github.com/vim-ruby/vim-ruby
 " Release Coordinator:	Doug Kearns <dougkearns@gmail.com>
-" Maintainer Version:   0.8.1
 " ----------------------------------------------------------------------------
 "
 " Ruby IRB/Complete author: Keiju ISHITSUKA(keiju@ishitsuka.com)
@@ -55,6 +54,23 @@ if !exists("g:rubycomplete_include_objectspace")
 endif
 " }}} configuration failsafe initialization
 
+" {{{ regex patterns
+
+" Regex that defines the start-match for the 'end' keyword.
+let s:end_start_regex =
+      \ '\C\%(^\s*\|[=,*/%+\-|;{]\|<<\|>>\|:\s\)\s*\zs' .
+      \ '\<\%(module\|class\|if\|for\|while\|until\|case\|unless\|begin' .
+      \   '\|\%(\K\k*[!?]\?\s\+\)\=def\):\@!\>' .
+      \ '\|\%(^\|[^.:@$]\)\@<=\<do:\@!\>'
+
+" Regex that defines the middle-match for the 'end' keyword.
+let s:end_middle_regex = '\<\%(ensure\|else\|\%(\%(^\|;\)\s*\)\@<=\<rescue:\@!\>\|when\|elsif\):\@!\>'
+
+" Regex that defines the end-match for the 'end' keyword.
+let s:end_end_regex = '\%(^\|[^.:@$]\)\@<=\<end:\@!\>'
+
+" }}} regex patterns
+
 " {{{ vim-side support functions
 let s:rubycomplete_debug = 0
 
@@ -105,7 +121,7 @@ function! s:GetBufferRubyEntity( name, type, ... )
     endif
 
     let curpos = getpos(".")
-    let [enum,ecol] = searchpairpos( crex, '', '\(end\|}\)', 'wr' )
+    let [enum,ecol] = searchpairpos( s:end_start_regex, s:end_middle_regex, s:end_end_regex, 'W' )
     call cursor(lastpos[1], lastpos[2])
 
     if lnum > enum
@@ -130,19 +146,28 @@ function! s:IsPosInClassDef(pos)
     return ret
 endfunction
 
+function! s:IsInComment(pos)
+    let stack = synstack(a:pos[0], a:pos[1])
+    if !empty(stack)
+        return synIDattr(stack[0], 'name') =~ 'ruby\%(.*Comment\|Documentation\)'
+    else
+        return 0
+    endif
+endfunction
+
 function! s:GetRubyVarType(v)
     let stopline = 1
     let vtp = ''
-    let pos = getpos('.')
+    let curpos = getpos('.')
     let sstr = '^\s*#\s*@var\s*'.escape(a:v, '*').'\>\s\+[^ \t]\+\s*$'
     let [lnum,lcol] = searchpos(sstr,'nb',stopline)
     if lnum != 0 && lcol != 0
-        call setpos('.',pos)
+        call setpos('.',curpos)
         let str = getline(lnum)
         let vtp = substitute(str,sstr,'\1','')
         return vtp
     endif
-    call setpos('.',pos)
+    call setpos('.',curpos)
     let ctors = '\(now\|new\|open\|get_instance'
     if exists('g:rubycomplete_rails') && g:rubycomplete_rails == 1 && s:rubycomplete_rails_loaded == 1
         let ctors = ctors.'\|find\|create'
@@ -152,9 +177,13 @@ function! s:GetRubyVarType(v)
 
     let fstr = '=\s*\([^ \t]\+.' . ctors .'\>\|[\[{"''/]\|%[xwQqr][(\[{@]\|[A-Za-z0-9@:\-()\.]\+...\?\|lambda\|&\)'
     let sstr = ''.escape(a:v, '*').'\>\s*[+\-*/]*'.fstr
-    let [lnum,lcol] = searchpos(sstr,'nb',stopline)
-    if lnum != 0 && lcol != 0
-        let str = matchstr(getline(lnum),fstr,lcol)
+    let pos = searchpos(sstr,'bW')
+    while pos != [0,0] && s:IsInComment(pos)
+        let pos = searchpos(sstr,'bW')
+    endwhile
+    if pos != [0,0]
+        let [lnum, col] = pos
+        let str = matchstr(getline(lnum),fstr,col)
         let str = substitute(str,'^=\s*','','')
 
         call setpos('.',pos)
@@ -176,7 +205,7 @@ function! s:GetRubyVarType(v)
         end
         return ''
     endif
-    call setpos('.',pos)
+    call setpos('.',curpos)
     return ''
 endfunction
 
@@ -198,7 +227,7 @@ function! rubycomplete#Complete(findstart, base)
             if c =~ '\w'
                 continue
             elseif ! c =~ '\.'
-                idx = -1
+                let idx = -1
                 break
             else
                 break
@@ -255,15 +284,27 @@ class VimRubyCompletion
 
 # {{{ buffer analysis magic
   def load_requires
+
+    custom_paths = VIM::evaluate("get(g:, 'rubycomplete_load_paths', [])")
+
+    if !custom_paths.empty?
+      $LOAD_PATH.concat(custom_paths).uniq!
+    end
+
     buf = VIM::Buffer.current
     enum = buf.line_number
     nums = Range.new( 1, enum )
     nums.each do |x|
+
       ln = buf[x]
       begin
-        eval( "require %s" % $1 ) if /.*require\s*(.*)$/.match( ln )
-      rescue Exception
-        #ignore?
+        if /.*require_relative\s*(.*)$/.match( ln )
+          eval( "require %s" % File.expand_path($1) )
+        elsif /.*require\s*(["'].*?["'])/.match( ln )
+          eval( "require %s" % $1 )
+        end
+      rescue Exception => e
+        dprint e.inspect
       end
     end
   end
@@ -346,8 +387,13 @@ class VimRubyCompletion
         if x != cur_line
           next if x == 0
           ln = buf[x]
-          if /^\s*(module|class|def|include)\s+/.match(ln)
-            clscnt += 1 if $1 == "class"
+          is_const = false
+          if /^\s*(module|class|def|include)\s+/.match(ln) || is_const = /^\s*?[A-Z]([A-z]|[1-9])*\s*?[|]{0,2}=\s*?.+\s*?/.match(ln)
+            clscnt += 1 if /class|module/.match($1)
+            # We must make sure to load each constant only once to avoid errors
+            if is_const
+                ln.gsub!(/\s*?[|]{0,2}=\s*?/, '||=')
+            end
             #dprint "\$1$1
             classdef += "%s\n" % ln
             classdef += "end\n" if /def\s+/.match(ln)
@@ -425,7 +471,6 @@ class VimRubyCompletion
     return get_buffer_entity_list( "class" )
   end
 
-
   def load_rails
     allow_rails = VIM::evaluate("exists('g:rubycomplete_rails') && g:rubycomplete_rails")
     return if allow_rails.to_i.zero?
@@ -457,13 +502,8 @@ class VimRubyCompletion
     return if rails_base == nil
     $:.push rails_base unless $:.index( rails_base )
 
-    rails_config = rails_base + "config/"
-    rails_lib = rails_base + "lib/"
-    $:.push rails_config unless $:.index( rails_config )
-    $:.push rails_lib unless $:.index( rails_lib )
-
-    bootfile = rails_config + "boot.rb"
-    envfile = rails_config + "environment.rb"
+    bootfile = rails_base + "config/boot.rb"
+    envfile = rails_base + "config/environment.rb"
     if File.exists?( bootfile ) && File.exists?( envfile )
       begin
         require bootfile
@@ -531,7 +571,6 @@ class VimRubyCompletion
         ret += ActiveRecord::ConnectionAdapters::SchemaStatements.methods
     end
 
-
     return ret
   end
 
@@ -589,13 +628,15 @@ class VimRubyCompletion
 # {{{ main completion code
   def self.preload_rails
     a = VimRubyCompletion.new
-    require 'Thread'
+    if VIM::evaluate("has('nvim')") == 0
+      require 'thread'
       Thread.new(a) do |b|
         begin
         b.load_rails
         rescue
         end
       end
+    end
     a.load_rails
   rescue
   end
@@ -615,7 +656,6 @@ class VimRubyCompletion
     want_gems = VIM::evaluate("get(g:, 'rubycomplete_load_gemfile')")
     load_gems unless want_gems.to_i.zero?
 
-
     input = VIM::Buffer.current.line
     cpos = VIM::Window.current.cursor[1] - 1
     input = input[0..cpos]
@@ -657,25 +697,25 @@ class VimRubyCompletion
           methods.delete_if { |c| c.match( /'/ ) }
         end
 
-      when /^::([A-Z][^:\.\(]*)$/ # Absolute Constant or class methods
+      when /^::([A-Z][^:\.\(]*)?$/ # Absolute Constant or class methods
         dprint "const or cls"
         receiver = $1
-        methods = Object.constants
-        methods.grep(/^#{receiver}/).collect{|e| "::" + e}
+        methods = Object.constants.collect{ |c| c.to_s }.grep(/^#{receiver}/)
 
       when /^(((::)?[A-Z][^:.\(]*)+?)::?([^:.]*)$/ # Constant or class methods
         receiver = $1
         message = Regexp.quote($4)
         dprint "const or cls 2 [recv: \'%s\', msg: \'%s\']" % [ receiver, message ]
         load_buffer_class( receiver )
+        load_buffer_module( receiver )
         begin
-          classes = eval("#{receiver}.constants")
-          #methods = eval("#{receiver}.methods")
+          constants = eval("#{receiver}.constants").collect{ |c| c.to_s }.grep(/^#{message}/)
+          methods = eval("#{receiver}.methods").collect{ |m| m.to_s }.grep(/^#{message}/)
         rescue Exception
           dprint "exception: %s" % $!
+          constants = []
           methods = []
         end
-        methods.grep(/^#{message}/).collect{|e| receiver + "::" + e}
 
       when /^(:[^:.]+)\.([^.]*)$/ # Symbol
         dprint "symbol"
@@ -788,7 +828,6 @@ class VimRubyCompletion
       methods += Kernel.public_methods
     end
 
-
     include_object = VIM::evaluate("exists('g:rubycomplete_include_object') && g:rubycomplete_include_object")
     methods = clean_sel( methods, message )
     methods = (methods-Object.instance_methods) if include_object == "0"
@@ -831,7 +870,6 @@ let s:rubycomplete_rails_loaded = 0
 call s:DefRuby()
 "}}} ruby-side code
 
-
 " vim:tw=78:sw=4:ts=8:et:fdm=marker:ft=vim:norl:
 
 endif

autoload/rust.vim

@@ -1,8 +1,60 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 
-" Author: Kevin Ballard
 " Description: Helper functions for Rust commands/mappings
 " Last Modified: May 27, 2014
+" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
+
+function! rust#Load()
+    " Utility call to get this script loaded, for debugging
+endfunction
+
+function! rust#GetConfigVar(name, default)
+    " Local buffer variable with same name takes predeence over global
+    if has_key(b:, a:name)
+        return get(b:, a:name)
+    endif
+    if has_key(g:, a:name)
+        return get(g:, a:name)
+    endif
+    return a:default
+endfunction
+
+" Include expression {{{1
+
+function! rust#IncludeExpr(fname) abort
+    " Remove leading 'crate::' to deal with 2018 edition style 'use'
+    " statements
+    let l:fname = substitute(a:fname, '^crate::', '', '')
+
+    " Remove trailing colons arising from lines like
+    "
+    "     use foo::{Bar, Baz};
+    let l:fname = substitute(l:fname, ':\+$', '', '')
+
+    " Replace '::' with '/'
+    let l:fname = substitute(l:fname, '::', '/', 'g')
+
+    " When we have
+    "
+    "    use foo::bar::baz;
+    "
+    " we can't tell whether baz is a module or a function; and we can't tell
+    " which modules correspond to files.
+    "
+    " So we work our way up, trying
+    "
+    "     foo/bar/baz.rs
+    "     foo/bar.rs
+    "     foo.rs
+    while l:fname !=# '.'
+        let l:path = findfile(l:fname)
+        if !empty(l:path)
+            return l:fname
+        endif
+        let l:fname = fnamemodify(l:fname, ':h')
+    endwhile
+    return l:fname
+endfunction
 
 " Jump {{{1
 
@@ -69,7 +121,7 @@ function! s:Run(dict, rustc_args, args)
 
     let pwd = a:dict.istemp ? a:dict.tmpdir : ''
     let output = s:system(pwd, shellescape(rustc) . " " . join(map(rustc_args, 'shellescape(v:val)')))
-	if output != ''
+    if output !=# ''
         echohl WarningMsg
         echo output
         echohl None
@@ -136,7 +188,7 @@ function! s:Expand(dict, pretty, args)
 endfunction
 
 function! rust#CompleteExpand(lead, line, pos)
-	if a:line[: a:pos-1] =~ '^RustExpand!\s*\S*$'
+    if a:line[: a:pos-1] =~# '^RustExpand!\s*\S*$'
         " first argument and it has a !
         let list = ["normal", "expanded", "typed", "expanded,identified", "flowgraph=", "everybody_loops"]
         if !empty(a:lead)
@@ -165,7 +217,7 @@ function! s:Emit(dict, type, args)
         let args = [relpath, '--emit', a:type, '-o', output_path] + a:args
         let pwd = a:dict.istemp ? a:dict.tmpdir : ''
         let output = s:system(pwd, shellescape(rustc) . " " . join(map(args, 'shellescape(v:val)')))
-		if output != ''
+        if output !=# ''
             echohl WarningMsg
             echo output
             echohl None
@@ -175,10 +227,10 @@ function! s:Emit(dict, type, args)
             exe 'silent keepalt read' fnameescape(output_path)
             1
             d
-			if a:type == "llvm-ir"
+            if a:type ==# "llvm-ir"
                 setl filetype=llvm
                 let extension = 'll'
-			elseif a:type == "asm"
+            elseif a:type ==# "asm"
                 setl filetype=asm
                 let extension = 's'
             endif
@@ -244,8 +296,8 @@ function! s:WithPath(func, ...)
             let dict.tmpdir_relpath = filename
             let dict.path = dict.tmpdir.'/'.filename
 
-			let saved.mod = &mod
-			set nomod
+            let saved.mod = &modified
+            set nomodified
 
             silent exe 'keepalt write! ' . fnameescape(dict.path)
             if pathisempty
@@ -326,7 +378,7 @@ function! s:ShellTokenize(text)
             endif
             let l:state = 3
         elseif l:state == 5 " single-quoted
-			if l:c == "'"
+            if l:c ==# "'"
                 let l:state = 1
             else
                 let l:current .= l:c
@@ -344,11 +396,20 @@ function! s:RmDir(path)
     if empty(a:path)
         echoerr 'Attempted to delete empty path'
         return 0
-	elseif a:path == '/' || a:path == $HOME
+    elseif a:path ==# '/' || a:path ==# $HOME
+        let l:path = expand(a:path)
+        if l:path ==# '/' || l:path ==# $HOME
             echoerr 'Attempted to delete protected path: ' . a:path
             return 0
         endif
-	silent exe "!rm -rf " . shellescape(a:path)
+    endif
+
+    if !isdirectory(a:path)
+        return 0
+    endif
+
+    " delete() returns 0 when removing file successfully
+    return delete(a:path, 'rf') == 0
 endfunction
 
 " Executes {cmd} with the cwd set to {pwd}, without changing Vim's cwd.
@@ -397,22 +458,117 @@ function! rust#Play(count, line1, line2, ...) abort
         call setreg('"', save_regcont, save_regtype)
     endif
 
-  let body = l:rust_playpen_url."?code=".webapi#http#encodeURI(content)
+    let url = l:rust_playpen_url."?code=".webapi#http#encodeURI(content)
 
-  if strlen(body) > 5000
-    echohl ErrorMsg | echomsg 'Buffer too large, max 5000 encoded characters ('.strlen(body).')' | echohl None
+    if strlen(url) > 5000
+        echohl ErrorMsg | echomsg 'Buffer too large, max 5000 encoded characters ('.strlen(url).')' | echohl None
         return
     endif
 
-  let payload = "format=simple&url=".webapi#http#encodeURI(body)
+    let payload = "format=simple&url=".webapi#http#encodeURI(url)
     let res = webapi#http#post(l:rust_shortener_url.'create.php', payload, {})
+    if res.status[0] ==# '2'
         let url = res.content
+    endif
 
-  redraw | echomsg 'Done: '.url
+    let footer = ''
+    if exists('g:rust_clip_command')
+        call system(g:rust_clip_command, url)
+        if !v:shell_error
+            let footer = ' (copied to clipboard)'
+        endif
+    endif
+    redraw | echomsg 'Done: '.url.footer
+endfunction
+
+" Run a test under the cursor or all tests {{{1
+
+" Finds a test function name under the cursor. Returns empty string when a
+" test function is not found.
+function! s:SearchTestFunctionNameUnderCursor() abort
+    let cursor_line = line('.')
+
+    " Find #[test] attribute
+    if search('\m\C#\[test\]', 'bcW') is 0
+        return ''
+    endif
+
+    " Move to an opening brace of the test function
+    let test_func_line = search('\m\C^\s*fn\s\+\h\w*\s*(.\+{$', 'eW')
+    if test_func_line is 0
+        return ''
+    endif
+
+    " Search the end of test function (closing brace) to ensure that the
+    " cursor position is within function definition
+    if maparg('<Plug>(MatchitNormalForward)') ==# ''
+        keepjumps normal! %
+    else
+        " Prefer matchit.vim official plugin to native % since the plugin
+        " provides better behavior than original % (#391)
+        " To load the plugin, run:
+        "   :packadd matchit
+        execute 'keepjumps' 'normal' "\<Plug>(MatchitNormalForward)"
+    endif
+    if line('.') < cursor_line
+        return ''
+    endif
+
+    return matchstr(getline(test_func_line), '\m\C^\s*fn\s\+\zs\h\w*')
+endfunction
+
+function! rust#Test(mods, winsize, all, options) abort
+    let manifest = findfile('Cargo.toml', expand('%:p:h') . ';')
+    if manifest ==# ''
+        return rust#Run(1, '--test ' . a:options)
+    endif
+
+    " <count> defaults to 0, but we prefer an empty string
+    let winsize = a:winsize ? a:winsize : ''
+
+    if has('terminal')
+        if has('patch-8.0.910')
+            let cmd = printf('%s noautocmd %snew | terminal ++curwin ', a:mods, winsize)
+        else
+            let cmd = printf('%s terminal ', a:mods)
+        endif
+    elseif has('nvim')
+        let cmd = printf('%s noautocmd %snew | terminal ', a:mods, winsize)
+    else
+        let cmd = '!'
+        let manifest = shellescape(manifest)
+    endif
+
+    if a:all
+        if a:options ==# ''
+            execute cmd . 'cargo test --manifest-path' manifest
+        else
+            execute cmd . 'cargo test --manifest-path' manifest a:options
+        endif
+        return
+    endif
+
+    let saved = getpos('.')
+    try
+        let func_name = s:SearchTestFunctionNameUnderCursor()
+    finally
+        call setpos('.', saved)
+    endtry
+    if func_name ==# ''
+        echohl ErrorMsg
+        echomsg 'No test function was found under the cursor. Please add ! to command if you want to run all tests'
+        echohl None
+        return
+    endif
+    if a:options ==# ''
+        execute cmd . 'cargo test --manifest-path' manifest func_name
+    else
+        execute cmd . 'cargo test --manifest-path' manifest func_name a:options
+    endif
 endfunction
 
 " }}}1
 
-" vim: set noet sw=4 ts=4:
+" vim: set et sw=4 sts=4 ts=8:
 
 endif

autoload/rust/debugging.vim

@@ -0,0 +1,107 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+
+" For debugging, inspired by https://github.com/w0rp/rust/blob/master/autoload/rust/debugging.vim
+
+let s:global_variable_list = [
+            \ '_rustfmt_autosave_because_of_config',
+            \ 'ftplugin_rust_source_path',
+            \ 'loaded_syntastic_rust_cargo_checker',
+            \ 'loaded_syntastic_rust_filetype',
+            \ 'loaded_syntastic_rust_rustc_checker',
+            \ 'rust_bang_comment_leader',
+            \ 'rust_cargo_avoid_whole_workspace',
+            \ 'rust_clip_command',
+            \ 'rust_conceal',
+            \ 'rust_conceal_mod_path',
+            \ 'rust_conceal_pub',
+            \ 'rust_fold',
+            \ 'rust_last_args',
+            \ 'rust_last_rustc_args',
+            \ 'rust_original_delimitMate_excluded_regions',
+            \ 'rust_playpen_url',
+            \ 'rust_prev_delimitMate_quotes',
+            \ 'rust_recent_nearest_cargo_tol',
+            \ 'rust_recent_root_cargo_toml',
+            \ 'rust_recommended_style',
+            \ 'rust_set_conceallevel',
+            \ 'rust_set_conceallevel=1',
+            \ 'rust_set_foldmethod',
+            \ 'rust_set_foldmethod=1',
+            \ 'rust_shortener_url',
+            \ 'rustc_makeprg_no_percent',
+            \ 'rustc_path',
+            \ 'rustfmt_autosave',
+            \ 'rustfmt_autosave_if_config_present',
+            \ 'rustfmt_command',
+            \ 'rustfmt_emit_files',
+            \ 'rustfmt_fail_silently',
+            \ 'rustfmt_options',
+            \ 'syntastic_extra_filetypes',
+            \ 'syntastic_rust_cargo_fname',
+            \]
+
+function! s:Echo(message) abort
+    execute 'echo a:message'
+endfunction
+
+function! s:EchoGlobalVariables() abort
+    for l:key in s:global_variable_list
+        if l:key !~# '^_'
+            call s:Echo('let g:' . l:key . ' = ' . string(get(g:, l:key, v:null)))
+        endif
+
+        if has_key(b:, l:key)
+            call s:Echo('let b:' . l:key . ' = ' . string(b:[l:key]))
+        endif
+    endfor
+endfunction
+
+function! rust#debugging#Info() abort
+    call cargo#Load()
+    call rust#Load()
+    call rustfmt#Load()
+    call s:Echo('rust.vim Global Variables:')
+    call s:Echo('')
+    call s:EchoGlobalVariables()
+
+    silent let l:output = system(g:rustfmt_command . ' --version')
+    echo l:output
+
+    let l:rustc = exists("g:rustc_path") ? g:rustc_path : "rustc"
+    silent let l:output = system(l:rustc . ' --version')
+    echo l:output
+
+    silent let l:output = system('cargo --version')
+    echo l:output
+
+    version
+
+    if exists(":SyntasticInfo")
+        echo "----"
+        echo "Info from Syntastic:"
+        execute "SyntasticInfo"
+    endif
+endfunction
+
+function! rust#debugging#InfoToClipboard() abort
+    redir @"
+    silent call rust#debugging#Info()
+    redir END
+
+    call s:Echo('RustInfo copied to your clipboard')
+endfunction
+
+function! rust#debugging#InfoToFile(filename) abort
+    let l:expanded_filename = expand(a:filename)
+
+    redir => l:output
+    silent call rust#debugging#Info()
+    redir END
+
+    call writefile(split(l:output, "\n"), l:expanded_filename)
+    call s:Echo('RustInfo written to ' . l:expanded_filename)
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:
+
+endif

autoload/rust/delimitmate.vim

@@ -0,0 +1,48 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+
+let s:delimitMate_extra_excluded_regions = ',rustLifetimeCandidate,rustGenericLifetimeCandidate'
+
+" For this buffer, when delimitMate issues the `User delimitMate_map`
+" event in the autocommand system, add the above-defined extra excluded
+" regions to delimitMate's state, if they have not already been added.
+function! rust#delimitmate#onMap() abort
+    if &filetype !=# 'rust'
+        return
+    endif
+
+    if get(b:, "delimitMate_quotes")
+        let b:rust_prev_delimitMate_quotes = b:delimitMate_quotes
+    endif
+    let b:delimitMate_quotes = "\" `"
+
+    if match(delimitMate#Get("excluded_regions"),
+                \ s:delimitMate_extra_excluded_regions) == -1
+        call delimitMate#Set("excluded_regions",
+                    \delimitMate#Get("excluded_regions").s:delimitMate_extra_excluded_regions)
+    endif
+endfunction
+
+" For this buffer, when delimitMate issues the `User delimitMate_unmap`
+" event in the autocommand system, delete the above-defined extra excluded
+" regions from delimitMate's state (the deletion being idempotent and
+" having no effect if the extra excluded regions are not present in the
+" targeted part of delimitMate's state).
+function! rust#delimitmate#onUnmap() abort
+    if &filetype !=# 'rust'
+        return
+    endif
+
+    if get(b:, "rust_prev_delimitMate_quotes")
+        let b:delimitMate_quotes = b:rust_prev_delimitMate_quotes
+    endif
+
+    call delimitMate#Set("excluded_regions", substitute(
+               \ delimitMate#Get("excluded_regions"),
+               \ '\C\V' . s:delimitMate_extra_excluded_regions,
+               \ '', 'g'))
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:
+
+
+endif

autoload/rust/tags.vim

@@ -0,0 +1,22 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
+
+" Tagbar support code, for the sake of not automatically overriding its
+" configuration in case Universal Ctags is detected.
+
+let s:ctags_is_uctags = 0
+let s:checked_ctags = 0
+
+function! rust#tags#IsUCtags() abort
+    if s:checked_ctags == 0
+        let l:ctags_bin = get(g:, 'tagbar_ctags_bin', 'ctags')
+        if system(l:ctags_bin.' --version') =~? 'universal ctags'
+            let s:ctags_is_uctags = 1
+        endif
+        let s:checked_ctags = 1
+    endif
+    return s:ctags_is_uctags
+endfunction
+
+" vim: set et sw=4 sts=4 ts=8:
+
+endif

autoload/rustfmt.vim

@@ -3,6 +3,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 " Author: Stephen Sugden <stephen@stephensugden.com>
 "
 " Adapted from https://github.com/fatih/vim-go
+" For bugs, patches and license go to https://github.com/rust-lang/rust.vim
 
 if !exists("g:rustfmt_autosave")
     let g:rustfmt_autosave = 0
@@ -20,64 +21,244 @@ if !exists("g:rustfmt_fail_silently")
     let g:rustfmt_fail_silently = 0
 endif
 
+function! rustfmt#DetectVersion()
+    " Save rustfmt '--help' for feature inspection
+    silent let s:rustfmt_help = system(g:rustfmt_command . " --help")
+    let s:rustfmt_unstable_features = s:rustfmt_help =~# "--unstable-features"
+
+    " Build a comparable rustfmt version varible out of its `--version` output:
+    silent let l:rustfmt_version_full = system(g:rustfmt_command . " --version")
+    let l:rustfmt_version_list = matchlist(l:rustfmt_version_full,
+        \    '\vrustfmt ([0-9]+[.][0-9]+[.][0-9]+)')
+    if len(l:rustfmt_version_list) < 3
+        let s:rustfmt_version = "0"
+    else
+        let s:rustfmt_version = l:rustfmt_version_list[1]
+    endif
+    return s:rustfmt_version
+endfunction
+
+call rustfmt#DetectVersion()
+
+if !exists("g:rustfmt_emit_files")
+    let g:rustfmt_emit_files = s:rustfmt_version >= "0.8.2"
+endif
+
+if !exists("g:rustfmt_file_lines")
+    let g:rustfmt_file_lines = s:rustfmt_help =~# "--file-lines JSON"
+endif
+
 let s:got_fmt_error = 0
 
-function! rustfmt#Format()
-  let l:curw = winsaveview()
-  let l:tmpname = expand("%:p:h") . "/." . expand("%:p:t") . ".rustfmt"
-  call writefile(getline(1, '$'), l:tmpname)
+function! rustfmt#Load()
+    " Utility call to get this script loaded, for debugging
+endfunction
 
-  let command = g:rustfmt_command . " --write-mode=overwrite "
+function! s:RustfmtWriteMode()
+    if g:rustfmt_emit_files
+        return "--emit=files"
+    else
+        return "--write-mode=overwrite"
+    endif
+endfunction
 
-  let out = systemlist(command . g:rustfmt_options . " " . shellescape(l:tmpname))
+function! s:RustfmtConfigOptions()
+    let l:rustfmt_toml = findfile('rustfmt.toml', expand('%:p:h') . ';')
+    if l:rustfmt_toml !=# ''
+        return '--config-path '.fnamemodify(l:rustfmt_toml, ":p")
+    endif
 
+    let l:_rustfmt_toml = findfile('.rustfmt.toml', expand('%:p:h') . ';')
+    if l:_rustfmt_toml !=# ''
+        return '--config-path '.fnamemodify(l:_rustfmt_toml, ":p")
+    endif
+
+    " Default to edition 2018 in case no rustfmt.toml was found.
+    return '--edition 2018'
+endfunction
+
+function! s:RustfmtCommandRange(filename, line1, line2)
+    if g:rustfmt_file_lines == 0
+        echo "--file-lines is not supported in the installed `rustfmt` executable"
+        return
+    endif
+
+    let l:arg = {"file": shellescape(a:filename), "range": [a:line1, a:line2]}
+    let l:write_mode = s:RustfmtWriteMode()
+    let l:rustfmt_config = s:RustfmtConfigOptions()
+
+    " FIXME: When --file-lines gets to be stable, add version range checking
+    " accordingly.
+    let l:unstable_features = s:rustfmt_unstable_features ? '--unstable-features' : ''
+
+    let l:cmd = printf("%s %s %s %s %s --file-lines '[%s]' %s", g:rustfmt_command,
+                \ l:write_mode, g:rustfmt_options,
+                \ l:unstable_features, l:rustfmt_config,
+                \ json_encode(l:arg), shellescape(a:filename))
+    return l:cmd
+endfunction
+
+function! s:RustfmtCommand()
+    let write_mode = g:rustfmt_emit_files ? '--emit=stdout' : '--write-mode=display'
+    let config = s:RustfmtConfigOptions()
+    return join([g:rustfmt_command, write_mode, config, g:rustfmt_options])
+endfunction
+
+function! s:DeleteLines(start, end) abort
+    silent! execute a:start . ',' . a:end . 'delete _'
+endfunction
+
+function! s:RunRustfmt(command, tmpname, from_writepre)
+    mkview!
+
+    let l:stderr_tmpname = tempname()
+    call writefile([], l:stderr_tmpname)
+
+    let l:command = a:command . ' 2> ' . l:stderr_tmpname
+
+    if a:tmpname ==# ''
+        " Rustfmt in stdin/stdout mode
+
+        " chdir to the directory of the file
+        let l:has_lcd = haslocaldir()
+        let l:prev_cd = getcwd()
+        execute 'lchdir! '.expand('%:h')
+
+        let l:buffer = getline(1, '$')
+        if exists("*systemlist")
+            silent let out = systemlist(l:command, l:buffer)
+        else
+            silent let out = split(system(l:command,
+                        \ join(l:buffer, "\n")), '\r\?\n')
+        endif
+    else
+        if exists("*systemlist")
+            silent let out = systemlist(l:command)
+        else
+            silent let out = split(system(l:command), '\r\?\n')
+        endif
+    endif
+
+    let l:stderr = readfile(l:stderr_tmpname)
+
+    call delete(l:stderr_tmpname)
+
+    let l:open_lwindow = 0
     if v:shell_error == 0
+        if a:from_writepre
             " remove undo point caused via BufWritePre
             try | silent undojoin | catch | endtry
+        endif
 
-    " Replace current file with temp file, then reload buffer
-    call rename(l:tmpname, expand('%'))
-    silent edit!
-    let &syntax = &syntax
+        if a:tmpname ==# ''
+            let l:content = l:out
+        else
+            " take the tmpfile's content, this is better than rename
+            " because it preserves file modes.
+            let l:content = readfile(a:tmpname)
+        endif
+
+        call s:DeleteLines(len(l:content), line('$'))
+        call setline(1, l:content)
 
         " only clear location list if it was previously filled to prevent
         " clobbering other additions
         if s:got_fmt_error
             let s:got_fmt_error = 0
             call setloclist(0, [])
-      lwindow
+            let l:open_lwindow = 1
         endif
-  elseif g:rustfmt_fail_silently == 0
+    elseif g:rustfmt_fail_silently == 0 && !a:from_writepre
         " otherwise get the errors and put them in the location list
-    let errors = []
+        let l:errors = []
 
-    for line in out
-      " src/lib.rs:13:5: 13:10 error: expected `,`, or `}`, found `value`
-      let tokens = matchlist(line, '^\(.\{-}\):\(\d\+\):\(\d\+\):\s*\(\d\+:\d\+\s*\)\?\s*error: \(.*\)')
+        let l:prev_line = ""
+        for l:line in l:stderr
+            " error: expected one of `;` or `as`, found `extern`
+            "  --> src/main.rs:2:1
+            let tokens = matchlist(l:line, '^\s\+-->\s\(.\{-}\):\(\d\+\):\(\d\+\)$')
             if !empty(tokens)
-        call add(errors, {"filename": @%,
+                call add(l:errors, {"filename": @%,
                             \"lnum":	tokens[2],
                             \"col":	tokens[3],
-                         \"text":     tokens[5]})
+                            \"text":	l:prev_line})
             endif
+            let l:prev_line = l:line
         endfor
 
-    if empty(errors)
-      % | " Couldn't detect rustfmt error format, output errors
-    endif
-
-    if !empty(errors)
-      call setloclist(0, errors, 'r')
+        if !empty(l:errors)
+            call setloclist(0, l:errors, 'r')
             echohl Error | echomsg "rustfmt returned error" | echohl None
+        else
+            echo "rust.vim: was not able to parse rustfmt messages. Here is the raw output:"
+            echo "\n"
+            for l:line in l:stderr
+                echo l:line
+            endfor
         endif
 
         let s:got_fmt_error = 1
-    lwindow
-    " We didn't use the temp file, so clean up
-    call delete(l:tmpname)
+        let l:open_lwindow = 1
     endif
 
-  call winrestview(l:curw)
+    " Restore the current directory if needed
+    if a:tmpname ==# ''
+        if l:has_lcd
+            execute 'lchdir! '.l:prev_cd
+        else
+            execute 'chdir! '.l:prev_cd
+        endif
+    endif
+
+    " Open lwindow after we have changed back to the previous directory
+    if l:open_lwindow == 1
+        lwindow
+    endif
+
+    silent! loadview
 endfunction
 
+function! rustfmt#FormatRange(line1, line2)
+    let l:tmpname = tempname()
+    call writefile(getline(1, '$'), l:tmpname)
+    let command = s:RustfmtCommandRange(l:tmpname, a:line1, a:line2)
+    call s:RunRustfmt(command, l:tmpname, v:false)
+    call delete(l:tmpname)
+endfunction
+
+function! rustfmt#Format()
+    call s:RunRustfmt(s:RustfmtCommand(), '', v:false)
+endfunction
+
+function! rustfmt#Cmd()
+    " Mainly for debugging
+    return s:RustfmtCommand()
+endfunction
+
+function! rustfmt#PreWrite()
+    if !filereadable(expand("%@"))
+        return
+    endif
+    if rust#GetConfigVar('rustfmt_autosave_if_config_present', 0)
+        if findfile('rustfmt.toml', '.;') !=# '' || findfile('.rustfmt.toml', '.;') !=# ''
+            let b:rustfmt_autosave = 1
+            let b:_rustfmt_autosave_because_of_config = 1
+        endif
+    else
+        if has_key(b:, '_rustfmt_autosave_because_of_config')
+            unlet b:_rustfmt_autosave_because_of_config
+            unlet b:rustfmt_autosave
+        endif
+    endif
+
+    if !rust#GetConfigVar("rustfmt_autosave", 0)
+        return
+    endif
+
+    call s:RunRustfmt(s:RustfmtCommand(), '', v:true)
+endfunction
+
+
+" vim: set et sw=4 sts=4 ts=8:
+
 endif

autoload/smt2.vim

@@ -0,0 +1,34 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'smt2') == -1
+
+" Invokes the solver on current file
+function! smt2#RunSolver()
+    silent !clear
+    execute "!" . g:smt2_solver_command . " " . bufname("%")
+endfunction
+
+" Puts the solver's output in new split (replaces old split)
+function! smt2#RunSolverAndShowResult()
+    let output = system(g:smt2_solver_command . " " . bufname("%") . " 2>&1")
+
+    " Create split (or reuse existent)
+    if exists("s:outputbufnr") && bufwinnr(s:outputbufnr) > 0
+        execute bufwinnr(s:outputbufnr) . 'wincmd w'
+    else
+        silent! vnew
+        let s:outputbufnr=bufnr('%')
+    endif
+
+    " Clear & (re-)fill contents
+    silent! normal! ggdG
+    setlocal filetype=smt2 buftype=nofile nobuflisted noswapfile
+    call append(0, split(output, '\v\n'))
+    normal! gg
+endfunction
+
+" Requests the solver's version
+function! smt2#PrintSolverVersion()
+    silent !clear
+    execute "!" . g:smt2_solver_command . " " . g:smt2_solver_version_switch
+endfunction
+
+endif

autoload/terraform.vim

@@ -0,0 +1,80 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'terraform') == -1
+
+let s:cpo_save = &cpoptions
+set cpoptions&vim
+
+" Ensure no conflict with arguments from the environment
+let $TF_CLI_ARGS_fmt=''
+
+function! terraform#fmt() abort
+  " Save the view.
+  let curw = winsaveview()
+
+  " Make a fake change so that the undo point is right.
+  normal! ix
+  normal! "_x
+
+  " Execute `terraform fmt`, redirecting stderr to a temporary file.
+  let tmpfile = tempname()
+  let shellredir_save = &shellredir
+  let &shellredir = '>%s 2>'.tmpfile
+  silent execute '%!terraform fmt -no-color -'
+  let &shellredir = shellredir_save
+
+  " If there was an error, undo any changes and show stderr.
+  if v:shell_error != 0
+    silent undo
+    let output = readfile(tmpfile)
+    echo join(output, "\n")
+  endif
+
+  " Delete the temporary file, and restore the view.
+  call delete(tmpfile)
+  call winrestview(curw)
+endfunction
+
+function! terraform#align() abort
+  let p = '^.*=[^>]*$'
+  if exists(':Tabularize') && getline('.') =~# '^.*=' && (getline(line('.')-1) =~# p || getline(line('.')+1) =~# p)
+    let column = strlen(substitute(getline('.')[0:col('.')],'[^=]','','g'))
+    let position = strlen(matchstr(getline('.')[0:col('.')],'.*=\s*\zs.*'))
+    Tabularize/=/l1
+    normal! 0
+    call search(repeat('[^=]*=',column).'\s\{-\}'.repeat('.',position),'ce',line('.'))
+  endif
+endfunction
+
+function! terraform#commands(ArgLead, CmdLine, CursorPos) abort
+  let commands = [
+    \ 'apply',
+    \ 'console',
+    \ 'destroy',
+    \ 'env',
+    \ 'fmt',
+    \ 'get',
+    \ 'graph',
+    \ 'import',
+    \ 'init',
+    \ 'output',
+    \ 'plan',
+    \ 'providers',
+    \ 'refresh',
+    \ 'show',
+    \ 'taint',
+    \ 'untaint',
+    \ 'validate',
+    \ 'version',
+    \ 'workspace',
+    \ '0.12upgrade',
+    \ 'debug',
+    \ 'force-unlock',
+    \ 'push',
+    \ 'state'
+  \ ]
+  return join(commands, "\n")
+endfunction
+
+let &cpoptions = s:cpo_save
+unlet s:cpo_save
+
+endif

autoload/unite/sources/vimtex.vim

@@ -0,0 +1,87 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+let s:source = {
+      \ 'name' : 'vimtex',
+      \ 'sorters' : 'sorter_nothing',
+      \ 'default_kind' : 'jump_list',
+      \ 'syntax' : 'uniteSource__vimtex',
+      \ 'entries' : [],
+      \ 'maxlevel' : 1,
+      \ 'hooks' : {},
+      \}
+
+function! s:source.gather_candidates(args, context) abort " {{{1
+  if exists('b:vimtex')
+    let s:source.entries = vimtex#parser#toc()
+    let s:source.maxlevel = max(map(copy(s:source.entries), 'v:val.level'))
+  endif
+  return map(copy(s:source.entries),
+        \ 's:create_candidate(v:val, s:source.maxlevel)')
+endfunction
+
+" }}}1
+function! s:source.hooks.on_syntax(args, context) abort " {{{1
+  syntax match VimtexTocSecs /.* @\d$/
+        \ contains=VimtexTocNum,VimtexTocTag,@Tex
+        \ contained containedin=uniteSource__vimtex
+  syntax match VimtexTocSec0 /.* @0$/
+        \ contains=VimtexTocNum,VimtexTocTag,@Tex
+        \ contained containedin=uniteSource__vimtex
+  syntax match VimtexTocSec1 /.* @1$/
+        \ contains=VimtexTocNum,VimtexTocTag,@Tex
+        \ contained containedin=uniteSource__vimtex
+  syntax match VimtexTocSec2 /.* @2$/
+        \ contains=VimtexTocNum,VimtexTocTag,@Tex
+        \ contained containedin=uniteSource__vimtex
+  syntax match VimtexTocSec3 /.* @3$/
+        \ contains=VimtexTocNum,VimtexTocTag,@Tex
+        \ contained containedin=uniteSource__vimtex
+  syntax match VimtexTocSec4 /.* @4$/
+        \ contains=VimtexTocNum,VimtexTocTag,@Tex
+        \ contained containedin=uniteSource__vimtex
+  syntax match VimtexTocNum
+        \ /\%69v\%(\%([A-Z]\+\>\|\d\+\)\%(\.\d\+\)*\)\?\s*@\d$/
+        \ contains=VimtexTocLevel
+        \ contained containedin=VimtexTocSec[0-9*]
+  syntax match VimtexTocTag
+        \ /\[.\]\s*@\d$/
+        \ contains=VimtexTocLevel
+        \ contained containedin=VimtexTocSec[0-9*]
+  syntax match VimtexTocLevel
+        \ /@\d$/ conceal
+        \ contained containedin=VimtexTocNum,VimtexTocTag
+endfunction
+
+" }}}1
+
+function! s:create_candidate(entry, maxlevel) abort " {{{1
+  let level = a:maxlevel - a:entry.level
+  let title = printf('%-65S%-10s',
+        \ strpart(repeat(' ', 2*level) . a:entry.title, 0, 60),
+        \ b:vimtex.toc.print_number(a:entry.number))
+  return {
+        \ 'word' : title,
+        \ 'abbr' : title . ' @' . level,
+        \ 'action__path' : a:entry.file,
+        \ 'action__line' : get(a:entry, 'line', 0),
+        \ }
+endfunction
+
+" }}}1
+
+function! unite#sources#vimtex#define() abort
+  return s:source
+endfunction
+
+let &cpo = s:save_cpo
+
+endif

autoload/vifm/edit.vim

@@ -0,0 +1,18 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vifm') == -1
+
+" common functions for vifm command-line editing buffer filetype plugins
+" Maintainer:  xaizek <xaizek@posteo.net>
+" Last Change: August 18, 2013
+
+" Prepare buffer
+function! vifm#edit#Init()
+    " Mappings for quick leaving the buffer (behavior similar to Command line
+    " buffer in Vim)
+    nnoremap <buffer> <cr> :copy 0 \| wq<cr>
+    imap <buffer> <cr> <esc><cr>
+
+    " Start buffer editing in insert mode
+    startinsert
+endfunction
+
+endif

autoload/vifm/globals.vim

@@ -0,0 +1,35 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vifm') == -1
+
+" common functions for vifm plugin related to globals
+" Maintainer:  xaizek <xaizek@posteo.net>
+" Last Change: November 03, 2018
+
+" Initializes global variables to defaults unless they are already set
+function! vifm#globals#Init()
+    if !exists('g:vifm_exec')
+        let g:vifm_exec = 'vifm'
+    endif
+
+    if !exists('g:vifm_exec_args')
+        let g:vifm_exec_args = ''
+    endif
+
+    if !exists('g:vifm_term')
+        if has('win32')
+            if filereadable('C:\Windows\system32\cmd.exe')
+                let g:vifm_term = 'C:\Windows\system32\cmd.exe /C'
+            else
+                " If don't find use the integrate shell it work too
+                let g:vifm_term = ''
+            endif
+        else
+            let g:vifm_term = 'xterm -e'
+        endif
+    endif
+
+    if !exists('g:vifm_embed_term')
+        let g:vifm_embed_term = has('gui_running')
+    endif
+endfunction
+
+endif

autoload/vimtex.vim

@@ -0,0 +1,707 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+function! vimtex#init() abort " {{{1
+  call vimtex#init_options()
+
+  call s:init_highlights()
+  call s:init_state()
+  call s:init_buffer()
+  call s:init_default_mappings()
+
+  if exists('#User#VimtexEventInitPost')
+    doautocmd <nomodeline> User VimtexEventInitPost
+  endif
+
+  augroup vimtex_main
+    autocmd!
+    autocmd VimLeave * call s:quit()
+  augroup END
+endfunction
+
+" }}}1
+function! vimtex#init_options() abort " {{{1
+  call s:init_option('vimtex_compiler_enabled', 1)
+  call s:init_option('vimtex_compiler_method', 'latexmk')
+  call s:init_option('vimtex_compiler_progname',
+        \ has('nvim') && executable('nvr')
+        \   ? 'nvr'
+        \   : get(v:, 'progpath', get(v:, 'progname', '')))
+  call s:init_option('vimtex_compiler_callback_hooks', [])
+  call s:init_option('vimtex_compiler_latexmk_engines', {})
+  call s:init_option('vimtex_compiler_latexrun_engines', {})
+
+  call s:init_option('vimtex_complete_enabled', 1)
+  call s:init_option('vimtex_complete_close_braces', 0)
+  call s:init_option('vimtex_complete_ignore_case', &ignorecase)
+  call s:init_option('vimtex_complete_smart_case', &smartcase)
+  call s:init_option('vimtex_complete_bib', {
+        \ 'simple': 0,
+        \ 'menu_fmt': '[@type] @author_short (@year), "@title"',
+        \ 'abbr_fmt': '',
+        \ 'custom_patterns': [],
+        \})
+  call s:init_option('vimtex_complete_ref', {
+        \ 'custom_patterns': [],
+        \})
+
+  call s:init_option('vimtex_delim_timeout', 300)
+  call s:init_option('vimtex_delim_insert_timeout', 60)
+  call s:init_option('vimtex_delim_stopline', 500)
+
+  call s:init_option('vimtex_include_search_enabled', 1)
+
+  call s:init_option('vimtex_doc_enabled', 1)
+  call s:init_option('vimtex_doc_handlers', [])
+
+  call s:init_option('vimtex_echo_verbose_input', 1)
+
+  call s:init_option('vimtex_env_change_autofill', 0)
+
+  if &diff
+    let g:vimtex_fold_enabled = 0
+  else
+    call s:init_option('vimtex_fold_enabled', 0)
+  endif
+  call s:init_option('vimtex_fold_manual', 0)
+  call s:init_option('vimtex_fold_levelmarker', '*')
+  call s:init_option('vimtex_fold_types', {})
+  call s:init_option('vimtex_fold_types_defaults', {
+        \ 'preamble' : {},
+        \ 'comments' : { 'enabled' : 0 },
+        \ 'envs' : {
+        \   'blacklist' : [],
+        \   'whitelist' : [],
+        \ },
+        \ 'env_options' : {},
+        \ 'markers' : {},
+        \ 'sections' : {
+        \   'parse_levels' : 0,
+        \   'sections' : [
+        \     'part',
+        \     'chapter',
+        \     'section',
+        \     'subsection',
+        \     'subsubsection',
+        \   ],
+        \   'parts' : [
+        \     'appendix',
+        \     'frontmatter',
+        \     'mainmatter',
+        \     'backmatter',
+        \   ],
+        \ },
+        \ 'cmd_single' : {
+        \   'cmds' : [
+        \     'hypersetup',
+        \     'tikzset',
+        \     'pgfplotstableread',
+        \     'lstset',
+        \   ],
+        \ },
+        \ 'cmd_single_opt' : {
+        \   'cmds' : [
+        \     'usepackage',
+        \     'includepdf',
+        \   ],
+        \ },
+        \ 'cmd_multi' : {
+        \   'cmds' : [
+        \     '%(re)?new%(command|environment)',
+        \     'providecommand',
+        \     'presetkeys',
+        \     'Declare%(Multi|Auto)?CiteCommand',
+        \     'Declare%(Index)?%(Field|List|Name)%(Format|Alias)',
+        \   ],
+        \ },
+        \ 'cmd_addplot' : {
+        \   'cmds' : [
+        \     'addplot[+3]?',
+        \   ],
+        \ },
+        \})
+
+  call s:init_option('vimtex_format_enabled', 0)
+
+  call s:init_option('vimtex_imaps_enabled', 1)
+  call s:init_option('vimtex_imaps_disabled', [])
+  call s:init_option('vimtex_imaps_list', [
+        \ { 'lhs' : '0',  'rhs' : '\emptyset' },
+        \ { 'lhs' : '6',  'rhs' : '\partial' },
+        \ { 'lhs' : '8',  'rhs' : '\infty' },
+        \ { 'lhs' : '=',  'rhs' : '\equiv' },
+        \ { 'lhs' : '\',  'rhs' : '\setminus' },
+        \ { 'lhs' : '.',  'rhs' : '\cdot' },
+        \ { 'lhs' : '*',  'rhs' : '\times' },
+        \ { 'lhs' : '<',  'rhs' : '\langle' },
+        \ { 'lhs' : '>',  'rhs' : '\rangle' },
+        \ { 'lhs' : 'H',  'rhs' : '\hbar' },
+        \ { 'lhs' : '+',  'rhs' : '\dagger' },
+        \ { 'lhs' : '[',  'rhs' : '\subseteq' },
+        \ { 'lhs' : ']',  'rhs' : '\supseteq' },
+        \ { 'lhs' : '(',  'rhs' : '\subset' },
+        \ { 'lhs' : ')',  'rhs' : '\supset' },
+        \ { 'lhs' : 'A',  'rhs' : '\forall' },
+        \ { 'lhs' : 'E',  'rhs' : '\exists' },
+        \ { 'lhs' : 'jj', 'rhs' : '\downarrow' },
+        \ { 'lhs' : 'jJ', 'rhs' : '\Downarrow' },
+        \ { 'lhs' : 'jk', 'rhs' : '\uparrow' },
+        \ { 'lhs' : 'jK', 'rhs' : '\Uparrow' },
+        \ { 'lhs' : 'jh', 'rhs' : '\leftarrow' },
+        \ { 'lhs' : 'jH', 'rhs' : '\Leftarrow' },
+        \ { 'lhs' : 'jl', 'rhs' : '\rightarrow' },
+        \ { 'lhs' : 'jL', 'rhs' : '\Rightarrow' },
+        \ { 'lhs' : 'a',  'rhs' : '\alpha' },
+        \ { 'lhs' : 'b',  'rhs' : '\beta' },
+        \ { 'lhs' : 'c',  'rhs' : '\chi' },
+        \ { 'lhs' : 'd',  'rhs' : '\delta' },
+        \ { 'lhs' : 'e',  'rhs' : '\epsilon' },
+        \ { 'lhs' : 'f',  'rhs' : '\phi' },
+        \ { 'lhs' : 'g',  'rhs' : '\gamma' },
+        \ { 'lhs' : 'h',  'rhs' : '\eta' },
+        \ { 'lhs' : 'i',  'rhs' : '\iota' },
+        \ { 'lhs' : 'k',  'rhs' : '\kappa' },
+        \ { 'lhs' : 'l',  'rhs' : '\lambda' },
+        \ { 'lhs' : 'm',  'rhs' : '\mu' },
+        \ { 'lhs' : 'n',  'rhs' : '\nu' },
+        \ { 'lhs' : 'p',  'rhs' : '\pi' },
+        \ { 'lhs' : 'q',  'rhs' : '\theta' },
+        \ { 'lhs' : 'r',  'rhs' : '\rho' },
+        \ { 'lhs' : 's',  'rhs' : '\sigma' },
+        \ { 'lhs' : 't',  'rhs' : '\tau' },
+        \ { 'lhs' : 'y',  'rhs' : '\psi' },
+        \ { 'lhs' : 'u',  'rhs' : '\upsilon' },
+        \ { 'lhs' : 'w',  'rhs' : '\omega' },
+        \ { 'lhs' : 'z',  'rhs' : '\zeta' },
+        \ { 'lhs' : 'x',  'rhs' : '\xi' },
+        \ { 'lhs' : 'G',  'rhs' : '\Gamma' },
+        \ { 'lhs' : 'D',  'rhs' : '\Delta' },
+        \ { 'lhs' : 'F',  'rhs' : '\Phi' },
+        \ { 'lhs' : 'G',  'rhs' : '\Gamma' },
+        \ { 'lhs' : 'L',  'rhs' : '\Lambda' },
+        \ { 'lhs' : 'P',  'rhs' : '\Pi' },
+        \ { 'lhs' : 'Q',  'rhs' : '\Theta' },
+        \ { 'lhs' : 'S',  'rhs' : '\Sigma' },
+        \ { 'lhs' : 'U',  'rhs' : '\Upsilon' },
+        \ { 'lhs' : 'W',  'rhs' : '\Omega' },
+        \ { 'lhs' : 'X',  'rhs' : '\Xi' },
+        \ { 'lhs' : 'Y',  'rhs' : '\Psi' },
+        \ { 'lhs' : 've', 'rhs' : '\varepsilon' },
+        \ { 'lhs' : 'vf', 'rhs' : '\varphi' },
+        \ { 'lhs' : 'vk', 'rhs' : '\varkappa' },
+        \ { 'lhs' : 'vq', 'rhs' : '\vartheta' },
+        \ { 'lhs' : 'vr', 'rhs' : '\varrho' },
+        \ { 'lhs' : '/',  'rhs' : 'vimtex#imaps#style_math("slashed")', 'expr' : 1, 'leader' : '#'},
+        \ { 'lhs' : 'b',  'rhs' : 'vimtex#imaps#style_math("mathbf")', 'expr' : 1, 'leader' : '#'},
+        \ { 'lhs' : 'f',  'rhs' : 'vimtex#imaps#style_math("mathfrak")', 'expr' : 1, 'leader' : '#'},
+        \ { 'lhs' : 'c',  'rhs' : 'vimtex#imaps#style_math("mathcal")', 'expr' : 1, 'leader' : '#'},
+        \ { 'lhs' : '-',  'rhs' : 'vimtex#imaps#style_math("overline")', 'expr' : 1, 'leader' : '#'},
+        \ { 'lhs' : 'B',  'rhs' : 'vimtex#imaps#style_math("mathbb")', 'expr' : 1, 'leader' : '#'},
+        \])
+
+  call s:init_option('vimtex_mappings_enabled', 1)
+  call s:init_option('vimtex_mappings_disable', {})
+
+  call s:init_option('vimtex_matchparen_enabled', 1)
+  call s:init_option('vimtex_motion_enabled', 1)
+
+  call s:init_option('vimtex_labels_enabled', 1)
+  call s:init_option('vimtex_labels_refresh_always', 1)
+
+  call s:init_option('vimtex_parser_bib_backend', 'bibtex')
+
+  call s:init_option('vimtex_quickfix_enabled', 1)
+  call s:init_option('vimtex_quickfix_method', 'latexlog')
+  call s:init_option('vimtex_quickfix_autojump', '0')
+  call s:init_option('vimtex_quickfix_ignore_filters', [])
+  call s:init_option('vimtex_quickfix_mode', '2')
+  call s:init_option('vimtex_quickfix_open_on_warning', '1')
+  call s:init_option('vimtex_quickfix_blgparser', {})
+  call s:init_option('vimtex_quickfix_autoclose_after_keystrokes', '0')
+
+  call s:init_option('vimtex_syntax_enabled', 1)
+  call s:init_option('vimtex_syntax_nested', {
+        \ 'aliases' : {
+        \   'C' : 'c',
+        \   'csharp' : 'cs',
+        \ },
+        \ 'ignored' : {
+        \   'cs' : [
+        \     'csBraces',
+        \   ],
+        \   'python' : [
+        \     'pythonEscape',
+        \     'pythonBEscape',
+        \     'pythonBytesEscape',
+        \   ],
+        \   'java' : [
+        \     'javaError',
+        \   ],
+        \   'haskell' : [
+        \     'hsVarSym',
+        \   ],
+        \ }
+        \})
+
+  call s:init_option('vimtex_texcount_custom_arg', '')
+
+  call s:init_option('vimtex_text_obj_enabled', 1)
+  call s:init_option('vimtex_text_obj_variant', 'auto')
+  call s:init_option('vimtex_text_obj_linewise_operators', ['d', 'y'])
+
+  call s:init_option('vimtex_toc_enabled', 1)
+  call s:init_option('vimtex_toc_custom_matchers', [])
+  call s:init_option('vimtex_toc_show_preamble', 1)
+  call s:init_option('vimtex_toc_todo_keywords', ['TODO', 'FIXME'])
+  call s:init_option('vimtex_toc_config', {
+        \ 'name' : 'Table of contents (vimtex)',
+        \ 'mode' : 1,
+        \ 'fold_enable' : 0,
+        \ 'fold_level_start' : -1,
+        \ 'hide_line_numbers' : 1,
+        \ 'hotkeys_enabled' : 0,
+        \ 'hotkeys' : 'abcdeilmnopuvxyz',
+        \ 'hotkeys_leader' : ';',
+        \ 'layer_status' : {
+        \   'content': 1,
+        \   'label': 1,
+        \   'todo': 1,
+        \   'include': 1,
+        \ },
+        \ 'layer_keys' : {
+        \   'content': 'C',
+        \   'label': 'L',
+        \   'todo': 'T',
+        \   'include': 'I',
+        \ },
+        \ 'resize' : 0,
+        \ 'refresh_always' : 1,
+        \ 'show_help' : 1,
+        \ 'show_numbers' : 1,
+        \ 'split_pos' : 'vert leftabove',
+        \ 'split_width' : 30,
+        \ 'tocdepth' : 3,
+        \ 'todo_sorted' : 1,
+        \})
+
+  call s:init_option('vimtex_view_enabled', 1)
+  call s:init_option('vimtex_view_automatic', 1)
+  call s:init_option('vimtex_view_method', 'general')
+  call s:init_option('vimtex_view_use_temp_files', 0)
+  call s:init_option('vimtex_view_forward_search_on_start', 1)
+
+  " OS dependent defaults
+  let l:os = vimtex#util#get_os()
+  if l:os ==# 'win'
+    if executable('SumatraPDF')
+      call s:init_option('vimtex_view_general_viewer', 'SumatraPDF')
+      call s:init_option('vimtex_view_general_options',
+            \ '-reuse-instance -forward-search @tex @line @pdf')
+      call s:init_option('vimtex_view_general_options_latexmk',
+            \ 'reuse-instance')
+    elseif executable('mupdf')
+      call s:init_option('vimtex_view_general_viewer', 'mupdf')
+    else
+      call s:init_option('vimtex_view_general_viewer', '')
+    endif
+  else
+    call s:init_option('vimtex_view_general_viewer', get({
+          \ 'linux' : 'xdg-open',
+          \ 'mac'   : 'open',
+          \ 'win'   : 'start',
+          \}, l:os, ''))
+    call s:init_option('vimtex_view_general_options', '@pdf')
+    call s:init_option('vimtex_view_general_options_latexmk', '')
+  endif
+
+  call s:init_option('vimtex_view_mupdf_options', '')
+  call s:init_option('vimtex_view_mupdf_send_keys', '')
+  call s:init_option('vimtex_view_skim_activate', 0)
+  call s:init_option('vimtex_view_skim_reading_bar', 1)
+  call s:init_option('vimtex_view_zathura_options', '')
+endfunction
+
+" }}}1
+function! vimtex#check_plugin_clash() abort " {{{1
+  let l:scriptnames = vimtex#util#command('scriptnames')
+
+  let l:latexbox = !empty(filter(copy(l:scriptnames), "v:val =~# 'latex-box'"))
+  if l:latexbox
+    let l:polyglot = !empty(filter(copy(l:scriptnames), "v:val =~# 'polyglot'"))
+    call vimtex#log#warning([
+          \ 'Conflicting plugin detected: LaTeX-Box',
+          \ 'vimtex does not work as expected when LaTeX-Box is installed!',
+          \ 'Please disable or remove it to use vimtex!',
+          \])
+    if l:polyglot
+      call vimtex#log#warning([
+            \ 'LaTeX-Box is included with vim-polyglot and may be disabled with:',
+            \ 'let g:polyglot_disabled = [''latex'']',
+            \])
+    endif
+  endif
+endfunction
+
+" }}}1
+
+function! s:init_option(option, default) abort " {{{1
+  let l:option = 'g:' . a:option
+  if !exists(l:option)
+    let {l:option} = a:default
+  elseif type(a:default) == type({})
+    call vimtex#util#extend_recursive({l:option}, a:default, 'keep')
+  endif
+endfunction
+
+" }}}1
+function! s:init_highlights() abort " {{{1
+  for [l:name, l:target] in [
+        \ ['VimtexImapsArrow', 'Comment'],
+        \ ['VimtexImapsLhs', 'ModeMsg'],
+        \ ['VimtexImapsRhs', 'ModeMsg'],
+        \ ['VimtexImapsWrapper', 'Type'],
+        \ ['VimtexInfo', 'Question'],
+        \ ['VimtexInfoTitle', 'PreProc'],
+        \ ['VimtexInfoKey', 'PreProc'],
+        \ ['VimtexInfoValue', 'Statement'],
+        \ ['VimtexInfoOther', 'Normal'],
+        \ ['VimtexMsg', 'ModeMsg'],
+        \ ['VimtexSuccess', 'Statement'],
+        \ ['VimtexTocHelp', 'helpVim'],
+        \ ['VimtexTocHelpKey', 'ModeMsg'],
+        \ ['VimtexTocHelpLayerOn', 'Statement'],
+        \ ['VimtexTocHelpLayerOff', 'Comment'],
+        \ ['VimtexTocTodo', 'Todo'],
+        \ ['VimtexTocNum', 'Number'],
+        \ ['VimtexTocSec0', 'Title'],
+        \ ['VimtexTocSec1', 'Normal'],
+        \ ['VimtexTocSec2', 'helpVim'],
+        \ ['VimtexTocSec3', 'NonText'],
+        \ ['VimtexTocSec4', 'Comment'],
+        \ ['VimtexTocHotkey', 'Comment'],
+        \ ['VimtexTocLabelsSecs', 'Statement'],
+        \ ['VimtexTocLabelsEq', 'PreProc'],
+        \ ['VimtexTocLabelsFig', 'Identifier'],
+        \ ['VimtexTocLabelsTab', 'String'],
+        \ ['VimtexTocIncl', 'Number'],
+        \ ['VimtexTocInclPath', 'Normal'],
+        \ ['VimtexWarning', 'WarningMsg'],
+        \ ['VimtexError', 'ErrorMsg'],
+        \]
+    if !hlexists(l:name)
+      silent execute 'highlight default link' l:name l:target
+    endif
+  endfor
+endfunction
+
+" }}}1
+function! s:init_state() abort " {{{1
+  call vimtex#state#init()
+  call vimtex#state#init_local()
+endfunction
+
+" }}}1
+function! s:init_buffer() abort " {{{1
+  " Set Vim options
+  for l:suf in [
+        \ '.sty',
+        \ '.cls',
+        \ '.log',
+        \ '.aux',
+        \ '.bbl',
+        \ '.out',
+        \ '.blg',
+        \ '.brf',
+        \ '.cb',
+        \ '.dvi',
+        \ '.fdb_latexmk',
+        \ '.fls',
+        \ '.idx',
+        \ '.ilg',
+        \ '.ind',
+        \ '.inx',
+        \ '.pdf',
+        \ '.synctex.gz',
+        \ '.toc',
+        \ ]
+    execute 'set suffixes+=' . l:suf
+  endfor
+  setlocal suffixesadd=.sty,.tex,.cls
+  setlocal comments=sO:%\ -,mO:%\ \ ,eO:%%,:%
+  setlocal commentstring=%%s
+  setlocal iskeyword+=:
+  setlocal includeexpr=vimtex#include#expr()
+  let &l:include = g:vimtex#re#tex_include
+  let &l:define  = '\\\([egx]\|char\|mathchar\|count\|dimen\|muskip\|skip'
+  let &l:define .= '\|toks\)\=def\|\\font\|\\\(future\)\=let'
+  let &l:define .= '\|\\new\(count\|dimen\|skip'
+  let &l:define .= '\|muskip\|box\|toks\|read\|write\|fam\|insert\)'
+  let &l:define .= '\|\\\(re\)\=new\(boolean\|command\|counter\|environment'
+  let &l:define .= '\|font\|if\|length\|savebox'
+  let &l:define .= '\|theorem\(style\)\=\)\s*\*\=\s*{\='
+  let &l:define .= '\|DeclareMathOperator\s*{\=\s*'
+
+  " Define autocommands
+  augroup vimtex_buffers
+    autocmd! * <buffer>
+    autocmd BufFilePre  <buffer> call s:filename_changed_pre()
+    autocmd BufFilePost <buffer> call s:filename_changed_post()
+    autocmd BufUnload   <buffer> call s:buffer_deleted('unload')
+    autocmd BufWipeout  <buffer> call s:buffer_deleted('wipe')
+  augroup END
+
+  " Initialize buffer settings for sub modules
+  for l:mod in s:modules
+    if index(get(b:vimtex, 'disabled_modules', []), l:mod) >= 0 | continue | endif
+
+    try
+      call vimtex#{l:mod}#init_buffer()
+    catch /E117.*#init_/
+    catch /E127.*vimtex#profile#/
+    endtry
+  endfor
+endfunction
+
+" }}}1
+function! s:init_default_mappings() abort " {{{1
+  if !g:vimtex_mappings_enabled | return | endif
+
+  function! s:map(mode, lhs, rhs, ...) abort
+    if !hasmapto(a:rhs, a:mode)
+          \ && index(get(g:vimtex_mappings_disable, a:mode, []), a:lhs) < 0
+          \ && (empty(maparg(a:lhs, a:mode)) || a:0 > 0)
+      silent execute a:mode . 'map <silent><nowait><buffer>' a:lhs a:rhs
+    endif
+  endfunction
+
+  call s:map('n', '<localleader>li', '<plug>(vimtex-info)')
+  call s:map('n', '<localleader>lI', '<plug>(vimtex-info-full)')
+  call s:map('n', '<localleader>lx', '<plug>(vimtex-reload)')
+  call s:map('n', '<localleader>lX', '<plug>(vimtex-reload-state)')
+  call s:map('n', '<localleader>ls', '<plug>(vimtex-toggle-main)')
+  call s:map('n', '<localleader>lq', '<plug>(vimtex-log)')
+
+  call s:map('n', 'ds$', '<plug>(vimtex-env-delete-math)')
+  call s:map('n', 'cs$', '<plug>(vimtex-env-change-math)')
+  call s:map('n', 'dse', '<plug>(vimtex-env-delete)')
+  call s:map('n', 'cse', '<plug>(vimtex-env-change)')
+  call s:map('n', 'tse', '<plug>(vimtex-env-toggle-star)')
+
+  call s:map('n', 'dsc',  '<plug>(vimtex-cmd-delete)')
+  call s:map('n', 'csc',  '<plug>(vimtex-cmd-change)')
+  call s:map('n', 'tsc',  '<plug>(vimtex-cmd-toggle-star)')
+  call s:map('n', 'tsf',  '<plug>(vimtex-cmd-toggle-frac)')
+  call s:map('x', 'tsf',  '<plug>(vimtex-cmd-toggle-frac)')
+  call s:map('i', '<F7>', '<plug>(vimtex-cmd-create)')
+  call s:map('n', '<F7>', '<plug>(vimtex-cmd-create)')
+  call s:map('x', '<F7>', '<plug>(vimtex-cmd-create)')
+
+  call s:map('n', 'dsd', '<plug>(vimtex-delim-delete)')
+  call s:map('n', 'csd', '<plug>(vimtex-delim-change-math)')
+  call s:map('n', 'tsd', '<plug>(vimtex-delim-toggle-modifier)')
+  call s:map('x', 'tsd', '<plug>(vimtex-delim-toggle-modifier)')
+  call s:map('n', 'tsD', '<plug>(vimtex-delim-toggle-modifier-reverse)')
+  call s:map('x', 'tsD', '<plug>(vimtex-delim-toggle-modifier-reverse)')
+  call s:map('i', ']]',  '<plug>(vimtex-delim-close)')
+
+  if g:vimtex_compiler_enabled
+    call s:map('n', '<localleader>ll', '<plug>(vimtex-compile)')
+    call s:map('n', '<localleader>lo', '<plug>(vimtex-compile-output)')
+    call s:map('n', '<localleader>lL', '<plug>(vimtex-compile-selected)')
+    call s:map('x', '<localleader>lL', '<plug>(vimtex-compile-selected)')
+    call s:map('n', '<localleader>lk', '<plug>(vimtex-stop)')
+    call s:map('n', '<localleader>lK', '<plug>(vimtex-stop-all)')
+    call s:map('n', '<localleader>le', '<plug>(vimtex-errors)')
+    call s:map('n', '<localleader>lc', '<plug>(vimtex-clean)')
+    call s:map('n', '<localleader>lC', '<plug>(vimtex-clean-full)')
+    call s:map('n', '<localleader>lg', '<plug>(vimtex-status)')
+    call s:map('n', '<localleader>lG', '<plug>(vimtex-status-all)')
+  endif
+
+  if g:vimtex_motion_enabled
+    " These are forced in order to overwrite matchit mappings
+    call s:map('n', '%', '<plug>(vimtex-%)', 1)
+    call s:map('x', '%', '<plug>(vimtex-%)', 1)
+    call s:map('o', '%', '<plug>(vimtex-%)', 1)
+
+    call s:map('n', ']]', '<plug>(vimtex-]])')
+    call s:map('n', '][', '<plug>(vimtex-][)')
+    call s:map('n', '[]', '<plug>(vimtex-[])')
+    call s:map('n', '[[', '<plug>(vimtex-[[)')
+    call s:map('x', ']]', '<plug>(vimtex-]])')
+    call s:map('x', '][', '<plug>(vimtex-][)')
+    call s:map('x', '[]', '<plug>(vimtex-[])')
+    call s:map('x', '[[', '<plug>(vimtex-[[)')
+    call s:map('o', ']]', '<plug>(vimtex-]])')
+    call s:map('o', '][', '<plug>(vimtex-][)')
+    call s:map('o', '[]', '<plug>(vimtex-[])')
+    call s:map('o', '[[', '<plug>(vimtex-[[)')
+
+    call s:map('n', ']M', '<plug>(vimtex-]M)')
+    call s:map('n', ']m', '<plug>(vimtex-]m)')
+    call s:map('n', '[M', '<plug>(vimtex-[M)')
+    call s:map('n', '[m', '<plug>(vimtex-[m)')
+    call s:map('x', ']M', '<plug>(vimtex-]M)')
+    call s:map('x', ']m', '<plug>(vimtex-]m)')
+    call s:map('x', '[M', '<plug>(vimtex-[M)')
+    call s:map('x', '[m', '<plug>(vimtex-[m)')
+    call s:map('o', ']M', '<plug>(vimtex-]M)')
+    call s:map('o', ']m', '<plug>(vimtex-]m)')
+    call s:map('o', '[M', '<plug>(vimtex-[M)')
+    call s:map('o', '[m', '<plug>(vimtex-[m)')
+
+    call s:map('n', ']/', '<plug>(vimtex-]/)')
+    call s:map('n', ']*', '<plug>(vimtex-]*)')
+    call s:map('n', '[/', '<plug>(vimtex-[/)')
+    call s:map('n', '[*', '<plug>(vimtex-[*)')
+    call s:map('x', ']/', '<plug>(vimtex-]/)')
+    call s:map('x', ']*', '<plug>(vimtex-]*)')
+    call s:map('x', '[/', '<plug>(vimtex-[/)')
+    call s:map('x', '[*', '<plug>(vimtex-[*)')
+    call s:map('o', ']/', '<plug>(vimtex-]/)')
+    call s:map('o', ']*', '<plug>(vimtex-]*)')
+    call s:map('o', '[/', '<plug>(vimtex-[/)')
+    call s:map('o', '[*', '<plug>(vimtex-[*)')
+  endif
+
+  if g:vimtex_text_obj_enabled
+    call s:map('x', 'id', '<plug>(vimtex-id)')
+    call s:map('x', 'ad', '<plug>(vimtex-ad)')
+    call s:map('o', 'id', '<plug>(vimtex-id)')
+    call s:map('o', 'ad', '<plug>(vimtex-ad)')
+    call s:map('x', 'i$', '<plug>(vimtex-i$)')
+    call s:map('x', 'a$', '<plug>(vimtex-a$)')
+    call s:map('o', 'i$', '<plug>(vimtex-i$)')
+    call s:map('o', 'a$', '<plug>(vimtex-a$)')
+    call s:map('x', 'iP', '<plug>(vimtex-iP)')
+    call s:map('x', 'aP', '<plug>(vimtex-aP)')
+    call s:map('o', 'iP', '<plug>(vimtex-iP)')
+    call s:map('o', 'aP', '<plug>(vimtex-aP)')
+    call s:map('x', 'im', '<plug>(vimtex-im)')
+    call s:map('x', 'am', '<plug>(vimtex-am)')
+    call s:map('o', 'im', '<plug>(vimtex-im)')
+    call s:map('o', 'am', '<plug>(vimtex-am)')
+
+    if vimtex#text_obj#targets#enabled()
+      call vimtex#text_obj#targets#init()
+
+      " These are handled explicitly to avoid conflict with gitgutter
+      call s:map('x', 'ic', '<plug>(vimtex-targets-i)c')
+      call s:map('x', 'ac', '<plug>(vimtex-targets-a)c')
+      call s:map('o', 'ic', '<plug>(vimtex-targets-i)c')
+      call s:map('o', 'ac', '<plug>(vimtex-targets-a)c')
+    else
+      if g:vimtex_text_obj_variant ==# 'targets'
+        call vimtex#log#warning(
+              \ "Ignoring g:vimtex_text_obj_variant = 'targets'"
+              \ . " because 'g:loaded_targets' does not exist or is 0.")
+      endif
+      let g:vimtex_text_obj_variant = 'vimtex'
+
+      call s:map('x', 'ie', '<plug>(vimtex-ie)')
+      call s:map('x', 'ae', '<plug>(vimtex-ae)')
+      call s:map('o', 'ie', '<plug>(vimtex-ie)')
+      call s:map('o', 'ae', '<plug>(vimtex-ae)')
+      call s:map('x', 'ic', '<plug>(vimtex-ic)')
+      call s:map('x', 'ac', '<plug>(vimtex-ac)')
+      call s:map('o', 'ic', '<plug>(vimtex-ic)')
+      call s:map('o', 'ac', '<plug>(vimtex-ac)')
+    endif
+  endif
+
+  if g:vimtex_toc_enabled
+    call s:map('n', '<localleader>lt', '<plug>(vimtex-toc-open)')
+    call s:map('n', '<localleader>lT', '<plug>(vimtex-toc-toggle)')
+  endif
+
+  if has_key(b:vimtex, 'viewer')
+    call s:map('n', '<localleader>lv', '<plug>(vimtex-view)')
+    if has_key(b:vimtex.viewer, 'reverse_search')
+      call s:map('n', '<localleader>lr', '<plug>(vimtex-reverse-search)')
+    endif
+  endif
+
+  if g:vimtex_imaps_enabled
+    call s:map('n', '<localleader>lm', '<plug>(vimtex-imaps-list)')
+  endif
+
+  if g:vimtex_doc_enabled
+    call s:map('n', 'K', '<plug>(vimtex-doc-package)')
+  endif
+endfunction
+
+" }}}1
+
+function! s:filename_changed_pre() abort " {{{1
+  let s:filename_changed = expand('%:p') ==# b:vimtex.tex
+endfunction
+
+" }}}1
+function! s:filename_changed_post() abort " {{{1
+  if s:filename_changed
+    let l:base_old = b:vimtex.base
+    let b:vimtex.tex = fnamemodify(expand('%'), ':p')
+    let b:vimtex.base = fnamemodify(b:vimtex.tex, ':t')
+    let b:vimtex.name = fnamemodify(b:vimtex.tex, ':t:r')
+
+    call vimtex#log#warning('Filename change detected')
+    call vimtex#log#info('Old filename: ' . l:base_old)
+    call vimtex#log#info('New filename: ' . b:vimtex.base)
+
+    if has_key(b:vimtex, 'compiler')
+      if b:vimtex.compiler.is_running()
+        call vimtex#log#warning('Compilation stopped!')
+        call vimtex#compiler#stop()
+      endif
+      let b:vimtex.compiler.target = b:vimtex.base
+      let b:vimtex.compiler.target_path = b:vimtex.tex
+    endif
+  endif
+endfunction
+
+" }}}1
+function! s:buffer_deleted(reason) abort " {{{1
+  "
+  " We need a simple cache of buffer ids because a buffer unload might clear
+  " buffer variables, so that a subsequent buffer wipe will not trigger a full
+  " cleanup. By caching the buffer id, we should avoid this issue.
+  "
+  let s:buffer_cache = get(s:, 'buffer_cache', {})
+  let l:file = expand('<afile>')
+
+  if !has_key(s:buffer_cache, l:file)
+    let s:buffer_cache[l:file] = getbufvar(l:file, 'vimtex_id', -1)
+  endif
+
+  if a:reason ==# 'wipe'
+    call vimtex#state#cleanup(s:buffer_cache[l:file])
+    call remove(s:buffer_cache, l:file)
+  endif
+endfunction
+
+" }}}1
+function! s:quit() abort " {{{1
+  for l:state in vimtex#state#list_all()
+    call l:state.cleanup()
+  endfor
+
+  call vimtex#cache#write_all()
+endfunction
+
+" }}}1
+
+
+" {{{1 Initialize module
+
+let s:modules = map(
+      \ glob(fnamemodify(expand('<sfile>'), ':r') . '/*.vim', 0, 1),
+      \ 'fnamemodify(v:val, '':t:r'')')
+
+" }}}1
+
+endif

autoload/vimtex/cache.vim

@@ -0,0 +1,179 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+function! vimtex#cache#open(name, ...) abort " {{{1
+  let l:opts = a:0 > 0 ? a:1 : {}
+  let l:name = get(l:opts, 'local') ? s:local_name(a:name) : a:name
+
+  let s:caches = get(s:, 'caches', {})
+  if has_key(s:caches, l:name)
+    return s:caches[l:name]
+  endif
+
+  let s:caches[l:name] = s:cache.init(l:name, l:opts)
+  return s:caches[l:name]
+endfunction
+
+" }}}1
+function! vimtex#cache#close(name) abort " {{{1
+  let s:caches = get(s:, 'caches', {})
+
+  " Try global name first, then local name
+  let l:name = a:name
+  if !has_key(s:caches, l:name)
+    let l:name = s:local_name(l:name)
+  endif
+  if !has_key(s:caches, l:name) | return | endif
+
+  let l:cache = s:caches[l:name]
+  call l:cache.write()
+  unlet s:caches[l:name]
+endfunction
+
+" }}}1
+function! vimtex#cache#wrap(Func, name, ...) abort " {{{1
+  if !has('lambda')
+    throw 'error: vimtex#cache#wrap requires +lambda'
+  endif
+
+  let l:opts = a:0 > 0 ? a:1 : {}
+  let l:cache = vimtex#cache#open(a:name, l:opts)
+
+  function! CachedFunc(key) closure
+    if l:cache.has(a:key)
+      return l:cache.get(a:key)
+    else
+      return l:cache.set(a:key, a:Func(a:key))
+    endif
+  endfunction
+
+  return function('CachedFunc')
+endfunction
+
+" }}}1
+function! vimtex#cache#clear(name, local) abort " {{{1
+  let l:cache = vimtex#cache#open(a:name, {'local': a:local})
+
+  call l:cache.read()
+  if !empty(l:cache.data)
+    let l:cache.data = {}
+    call l:cache.write()
+  endif
+endfunction
+
+" }}}1
+function! vimtex#cache#write_all() abort " {{{1
+  for l:cache in values(get(s:, 'caches', {}))
+    call l:cache.write()
+  endfor
+endfunction
+
+" }}}1
+
+let s:cache = {}
+
+function! s:cache.init(name, opts) dict abort " {{{1
+  let new = deepcopy(self)
+  unlet new.init
+
+  let l:root = get(g:, 'vimtex_cache_root', $HOME . '/.cache/vimtex')
+  if !isdirectory(l:root)
+    call mkdir(l:root, 'p')
+  endif
+
+  let new.name = a:name
+  let new.path = l:root . '/' . a:name . '.json'
+  let new.local = get(a:opts, 'local')
+  let new.persistent = get(a:opts, 'persistent',
+        \ get(g:, 'vimtex_cache_persistent', 1))
+
+  if has_key(a:opts, 'default')
+    let new.default = a:opts.default
+  endif
+
+  let new.data = {}
+  let new.ftime = -1
+  let new.modified = 0
+
+  return new
+endfunction
+
+" }}}1
+function! s:cache.get(key) dict abort " {{{1
+  call self.read()
+
+  if has_key(self, 'default') && !has_key(self.data, a:key)
+    let self.data[a:key] = deepcopy(self.default)
+  endif
+
+  return get(self.data, a:key)
+endfunction
+
+" }}}1
+function! s:cache.has(key) dict abort " {{{1
+  call self.read()
+
+  return has_key(self.data, a:key)
+endfunction
+
+" }}}1
+function! s:cache.set(key, value) dict abort " {{{1
+  call self.read()
+
+  let self.data[a:key] = a:value
+  let self.modified = 1
+  call self.write()
+
+  return a:value
+endfunction
+
+" }}}1
+function! s:cache.write() dict abort " {{{1
+  if !self.persistent
+    let self.modified = 0
+    return
+  endif
+
+  if !self.modified | return | endif
+
+  call self.read()
+  call writefile([json_encode(self.data)], self.path)
+  let self.ftime = getftime(self.path)
+  let self.modified = 0
+endfunction
+
+" }}}1
+function! s:cache.read() dict abort " {{{1
+  if !self.persistent | return | endif
+
+  if getftime(self.path) > self.ftime
+    let self.ftime = getftime(self.path)
+    call extend(self.data,
+          \ json_decode(join(readfile(self.path))), 'keep')
+  endif
+endfunction
+
+" }}}1
+
+"
+" Utility functions
+"
+function! s:local_name(name) abort " {{{1
+  let l:filename = exists('b:vimtex.tex')
+        \ ? fnamemodify(b:vimtex.tex, ':r')
+        \ : expand('%:p:r')
+  let l:filename = substitute(l:filename, '\s\+', '_', 'g')
+  let l:filename = substitute(l:filename, '\/', '%', 'g')
+  let l:filename = substitute(l:filename, '\\', '%', 'g')
+  let l:filename = substitute(l:filename, ':', '%', 'g')
+  return a:name . l:filename
+endfunction
+
+" }}}1
+
+endif

autoload/vimtex/cmd.vim

@@ -0,0 +1,718 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+function! vimtex#cmd#init_buffer() abort " {{{1
+  nnoremap <silent><buffer> <plug>(vimtex-cmd-delete)
+        \ :<c-u>call <sid>operator_setup('delete')<bar>normal! g@l<cr>
+
+  nnoremap <silent><buffer> <plug>(vimtex-cmd-change)
+        \ :<c-u>call <sid>operator_setup('change')<bar>normal! g@l<cr>
+
+  inoremap <silent><buffer> <plug>(vimtex-cmd-create)
+        \ <c-r>=vimtex#cmd#create_insert()<cr>
+
+  nnoremap <silent><buffer> <plug>(vimtex-cmd-create)
+        \ :<c-u>call <sid>operator_setup('create')<bar>normal! g@l<cr>
+
+  xnoremap <silent><buffer> <plug>(vimtex-cmd-create)
+        \ :<c-u>call vimtex#cmd#create_visual()<cr>
+
+  nnoremap <silent><buffer> <plug>(vimtex-cmd-toggle-star)
+        \ :<c-u>call <sid>operator_setup('toggle_star')<bar>normal! g@l<cr>
+
+  nnoremap <silent><buffer> <plug>(vimtex-cmd-toggle-frac)
+        \ :<c-u>call <sid>operator_setup('toggle_frac')<bar>normal! g@l<cr>
+
+  xnoremap <silent><buffer> <plug>(vimtex-cmd-toggle-frac)
+        \ :<c-u>call vimtex#cmd#toggle_frac_visual()<cr>
+endfunction
+
+" }}}1
+
+function! vimtex#cmd#change(new_name) abort " {{{1
+  let l:cmd = vimtex#cmd#get_current()
+  if empty(l:cmd) | return | endif
+
+  let l:old_name = l:cmd.name
+  let l:lnum = l:cmd.pos_start.lnum
+  let l:cnum = l:cmd.pos_start.cnum
+
+  " Get new command name
+  let l:new_name = substitute(a:new_name, '^\\', '', '')
+  if empty(l:new_name) | return | endif
+
+  " Update current position
+  let l:save_pos = vimtex#pos#get_cursor()
+  if strlen(l:new_name) < strlen(l:old_name)
+    let l:col = searchpos('\\\k', 'bcnW')[1] + strlen(l:new_name)
+    if l:col < l:save_pos[2]
+      let l:save_pos[2] = l:col
+    endif
+  endif
+
+  " Perform the change
+  let l:line = getline(l:lnum)
+  call setline(l:lnum,
+        \   strpart(l:line, 0, l:cnum)
+        \ . l:new_name
+        \ . strpart(l:line, l:cnum + strlen(l:old_name) - 1))
+
+  " Restore cursor position
+  cal vimtex#pos#set_cursor(l:save_pos)
+endfunction
+
+function! vimtex#cmd#delete(...) abort " {{{1
+  if a:0 > 0
+    let l:cmd = call('vimtex#cmd#get_at', a:000)
+  else
+    let l:cmd = vimtex#cmd#get_current()
+  endif
+  if empty(l:cmd) | return | endif
+
+  " Save current position
+  let l:save_pos = vimtex#pos#get_cursor()
+  let l:lnum_cur = l:save_pos[1]
+  let l:cnum_cur = l:save_pos[2]
+
+  " Remove closing bracket (if exactly one argument)
+  if len(l:cmd.args) == 1
+    let l:lnum = l:cmd.args[0].close.lnum
+    let l:cnum = l:cmd.args[0].close.cnum
+    let l:line = getline(l:lnum)
+    call setline(l:lnum,
+          \   strpart(l:line, 0, l:cnum - 1)
+          \ . strpart(l:line, l:cnum))
+
+    let l:cnum2 = l:cmd.args[0].open.cnum
+  endif
+
+  " Remove command (and possibly the opening bracket)
+  let l:lnum = l:cmd.pos_start.lnum
+  let l:cnum = l:cmd.pos_start.cnum
+  let l:cnum2 = get(l:, 'cnum2', l:cnum + strlen(l:cmd.name) - 1)
+  let l:line = getline(l:lnum)
+  call setline(l:lnum,
+        \   strpart(l:line, 0, l:cnum - 1)
+        \ . strpart(l:line, l:cnum2))
+
+  " Restore appropriate cursor position
+  if l:lnum_cur == l:lnum
+    if l:cnum_cur > l:cnum2
+      let l:save_pos[2] -= l:cnum2 - l:cnum + 1
+    else
+      let l:save_pos[2] -= l:cnum_cur - l:cnum
+    endif
+  endif
+  cal vimtex#pos#set_cursor(l:save_pos)
+endfunction
+
+function! vimtex#cmd#delete_all(...) abort " {{{1
+  if a:0 > 0
+    let l:cmd = call('vimtex#cmd#get_at', a:000)
+  else
+    let l:cmd = vimtex#cmd#get_current()
+  endif
+  if empty(l:cmd) | return | endif
+
+  call vimtex#pos#set_cursor(l:cmd.pos_start)
+  normal! v
+  call vimtex#pos#set_cursor(l:cmd.pos_end)
+  normal! d
+endfunction
+
+function! vimtex#cmd#create_insert() abort " {{{1
+  if mode() !=# 'i' | return | endif
+
+  let l:re = '\v%(^|\A)\zs\a+\ze%(\A|$)'
+  let l:c0 = col('.') - 1
+
+  let [l:l1, l:c1] = searchpos(l:re, 'bcn', line('.'))
+  let l:c1 -= 1
+  let l:line = getline(l:l1)
+  let l:match = matchstr(l:line, l:re, l:c1)
+  let l:c2 = l:c1 + strlen(l:match)
+
+  if l:c0 > l:c2
+    call vimtex#log#warning('Could not create command')
+    return ''
+  endif
+
+  let l:strpart1 = strpart(l:line, 0, l:c1)
+  let l:strpart2 = '\' . strpart(l:match, 0, l:c0 - l:c1) . '{'
+  let l:strpart3 = strpart(l:line, l:c0)
+  call setline(l:l1, l:strpart1 . l:strpart2 . l:strpart3)
+
+  call vimtex#pos#set_cursor(l:l1, l:c2+3)
+  return ''
+endfunction
+
+" }}}1
+function! vimtex#cmd#create(cmd, visualmode) abort " {{{1
+  if empty(a:cmd) | return | endif
+
+  " Avoid autoindent (disable indentkeys)
+  let l:save_indentkeys = &l:indentkeys
+  setlocal indentkeys=
+
+  if a:visualmode
+    let l:pos_start = getpos("'<")
+    let l:pos_end = getpos("'>")
+
+    if visualmode() ==# ''
+      normal! gvA}
+      execute 'normal! gvI\' . a:cmd . '{'
+
+      let l:pos_end[2] += strlen(a:cmd) + 3
+    else
+      normal! `>a}
+      normal! `<
+      execute 'normal! i\' . a:cmd . '{'
+
+      let l:pos_end[2] +=
+            \ l:pos_end[1] == l:pos_start[1] ? strlen(a:cmd) + 3 : 1
+    endif
+
+    call vimtex#pos#set_cursor(l:pos_end)
+  else
+    let l:pos = vimtex#pos#get_cursor()
+    let l:save_reg = getreg('"')
+    let l:pos[2] += strlen(a:cmd) + 2
+    execute 'normal! ciw\' . a:cmd . '{"}'
+    call setreg('"', l:save_reg)
+    call vimtex#pos#set_cursor(l:pos)
+  endif
+
+  " Restore indentkeys setting
+  let &l:indentkeys = l:save_indentkeys
+endfunction
+
+" }}}1
+function! vimtex#cmd#create_visual() abort " {{{1
+  let l:cmd = vimtex#echo#input({
+        \ 'info' :
+        \   ['Create command: ', ['VimtexWarning', '(empty to cancel)']],
+        \})
+  let l:cmd = substitute(l:cmd, '^\\', '', '')
+  call vimtex#cmd#create(l:cmd, 1)
+endfunction
+
+" }}}1
+function! vimtex#cmd#toggle_star() abort " {{{1
+  let l:cmd = vimtex#cmd#get_current()
+  if empty(l:cmd) | return | endif
+
+  let l:old_name = l:cmd.name
+  let l:lnum = l:cmd.pos_start.lnum
+  let l:cnum = l:cmd.pos_start.cnum
+
+  " Set new command name
+  if match(l:old_name, '\*$') == -1
+    let l:new_name = l:old_name.'*'
+  else
+    let l:new_name = strpart(l:old_name, 0, strlen(l:old_name)-1)
+  endif
+  let l:new_name = substitute(l:new_name, '^\\', '', '')
+  if empty(l:new_name) | return | endif
+
+  " Update current position
+  let l:save_pos = vimtex#pos#get_cursor()
+  let l:save_pos[2] += strlen(l:new_name) - strlen(l:old_name) + 1
+
+  " Perform the change
+  let l:line = getline(l:lnum)
+  call setline(l:lnum,
+        \   strpart(l:line, 0, l:cnum)
+        \ . l:new_name
+        \ . strpart(l:line, l:cnum + strlen(l:old_name) - 1))
+
+  " Restore cursor position
+  cal vimtex#pos#set_cursor(l:save_pos)
+endfunction
+
+" }}}1
+function! vimtex#cmd#toggle_frac() abort " {{{1
+  let l:frac = s:get_frac_cmd()
+  if empty(l:frac)
+    let l:frac = s:get_frac_inline()
+  endif
+  if empty(l:frac) | return | endif
+
+  let l:lnum = line('.')
+  let l:line = getline(l:lnum)
+  call setline(l:lnum,
+        \ strpart(l:line, 0, l:frac.col_start)
+        \ . l:frac.text_toggled
+        \ . strpart(l:line, l:frac.col_end+1))
+endfunction
+
+" }}}1
+function! vimtex#cmd#toggle_frac_visual() abort " {{{1
+  let l:save_reg = getreg('a')
+  normal! gv"ay
+  let l:selected = substitute(getreg('a'), '\n\s*', ' ', '')
+  call setreg('a', l:save_reg)
+
+  let l:frac = s:get_frac_inline_visual(l:selected)
+  if empty(l:frac)
+    let l:frac = s:get_frac_cmd_visual(l:selected)
+  endif
+
+  if empty(l:frac) | return | endif
+
+  let l:save_reg = getreg('a')
+  call setreg('a', l:frac.text_toggled)
+  normal! gv"ap
+  call setreg('a', l:save_reg)
+endfunction
+
+" }}}1
+
+function! s:get_frac_cmd() abort " {{{1
+  let l:save_pos = vimtex#pos#get_cursor()
+  while v:true
+    let l:cmd = s:get_cmd('prev')
+    if empty(l:cmd) || l:cmd.pos_start.lnum < line('.')
+      call vimtex#pos#set_cursor(l:save_pos)
+      return {}
+    endif
+
+    if l:cmd.name ==# '\frac'
+      break
+    endif
+
+    call vimtex#pos#set_cursor(vimtex#pos#prev(l:cmd.pos_start))
+  endwhile
+  call vimtex#pos#set_cursor(l:save_pos)
+
+  let l:frac = {
+        \ 'type': 'cmd',
+        \ 'col_start': l:cmd.pos_start.cnum - 1,
+        \ 'col_end': l:cmd.pos_end.cnum - 1,
+        \}
+
+  if len(l:cmd.args) >= 2
+    let l:consume = []
+    let l:frac.denominator = l:cmd.args[0].text
+    let l:frac.numerator = l:cmd.args[1].text
+  elseif len(l:cmd.args) == 1
+    let l:consume = ['numerator']
+    let l:frac.denominator = l:cmd.args[0].text
+    let l:frac.numerator = ''
+  else
+    let l:consume = ['denominator', 'numerator']
+    let l:frac.denominator = ''
+    let l:frac.numerator = ''
+  endif
+
+  " Handle unfinished cases
+  let l:line = getline('.')
+  let l:pos = l:frac.col_end + 1
+  for l:key in l:consume
+    let l:part = strpart(l:line, l:frac.col_end + 1)
+
+    let l:blurp = matchstr(l:part, '^\s*{[^}]*}')
+    if !empty(l:blurp)
+      let l:frac[l:key] = vimtex#util#trim(l:blurp)[1:-2]
+      let l:frac.col_end += len(l:blurp)
+      continue
+    endif
+
+    let l:blurp = matchstr(l:part, '^\s*\w')
+    if !empty(l:blurp)
+      let l:frac[l:key] = vimtex#util#trim(l:blurp)
+      let l:frac.col_end += len(l:blurp)
+    endif
+  endfor
+
+  " Abort if \frac region does not cover cursor
+  if l:frac.col_end < col('.') | return {} | endif
+
+  let l:frac.text = strpart(getline('.'),
+        \ l:frac.col_start, l:frac.col_end - l:frac.col_start + 1)
+
+  return s:get_frac_cmd_aux(l:frac)
+endfunction
+
+" }}}1
+function! s:get_frac_cmd_visual(selected) abort " {{{1
+  let l:matches = matchlist(a:selected, '^\s*\\frac\s*{\(.*\)}\s*{\(.*\)}\s*$')
+  if empty(l:matches) | return {} | endif
+
+  let l:frac = {
+        \ 'type': 'cmd',
+        \ 'text': a:selected,
+        \ 'denominator': l:matches[1],
+        \ 'numerator': l:matches[2],
+        \}
+
+  return s:get_frac_cmd_aux(l:frac)
+endfunction
+
+" }}}1
+function! s:get_frac_cmd_aux(frac) abort " {{{1
+  let l:denominator = (a:frac.denominator =~# '^\\\?\w*$')
+        \ ? a:frac.denominator
+        \ : '(' . a:frac.denominator . ')'
+
+  let l:numerator = (a:frac.numerator =~# '^\\\?\w*$')
+        \ ? a:frac.numerator
+        \ : '(' . a:frac.numerator . ')'
+
+  let a:frac.text_toggled = l:denominator . '/' . l:numerator
+
+  return a:frac
+endfunction
+
+" }}}1
+function! s:get_frac_inline() abort " {{{1
+  let l:line = getline('.')
+  let l:col = col('.') - 1
+
+  let l:pos_after = -1
+  let l:pos_before = -1
+  while v:true
+    let l:pos_before = l:pos_after
+    let l:pos_after = match(l:line, '\/', l:pos_after+1)
+    if l:pos_after < 0 || l:pos_after >= l:col | break | endif
+  endwhile
+
+  if l:pos_after == -1 && l:pos_before == -1
+    return {}
+  endif
+
+  let l:positions = []
+  if l:pos_before > 0
+    let l:positions += [l:pos_before]
+  endif
+  if l:pos_after > 0
+    let l:positions += [l:pos_after]
+  endif
+
+  for l:pos in l:positions
+    let l:frac = {'type': 'inline'}
+
+    "
+    " Parse numerator
+    "
+    let l:before = strpart(l:line, 0, l:pos)
+    if l:before =~# ')\s*$'
+      let l:pos_before = s:get_inline_limit(l:before, -1) - 1
+      let l:parens = strpart(l:before, l:pos_before)
+    else
+      let l:pos_before = match(l:before, '\s*$')
+      let l:parens = ''
+    endif
+
+    let l:before = strpart(l:line, 0, l:pos_before)
+    let l:atoms = matchstr(l:before, '\(\\(\)\?\zs[^-$(){} ]*$')
+    let l:pos_before = l:pos_before - strlen(l:atoms)
+    let l:frac.numerator = s:get_inline_trim(l:atoms . l:parens)
+    let l:frac.col_start = l:pos_before
+
+    "
+    " Parse denominator
+    "
+    let l:after = strpart(l:line, l:pos+1)
+    let l:atoms = l:after =~# '^\s*[^$()} ]*\\)'
+          \ ? matchstr(l:after, '^\s*[^$()} ]*\ze\\)')
+          \ : matchstr(l:after, '^\s*[^$()} ]*')
+    let l:pos_after = l:pos + strlen(l:atoms)
+    let l:after = strpart(l:line, l:pos_after+1)
+    if l:after =~# '^('
+      let l:index = s:get_inline_limit(l:after, 1)
+      let l:pos_after = l:pos_after + l:index + 1
+      let l:parens = strpart(l:after, 0, l:index+1)
+    else
+      let l:parens = ''
+    endif
+    let l:frac.denominator = s:get_inline_trim(l:atoms . l:parens)
+    let l:frac.col_end = l:pos_after
+
+    "
+    " Combine/Parse inline and frac expressions
+    "
+    let l:frac.text = strpart(l:line,
+          \ l:frac.col_start,
+          \ l:frac.col_end - l:frac.col_start + 1)
+    let l:frac.text_toggled  = printf('\frac{%s}{%s}',
+          \ l:frac.numerator, l:frac.denominator)
+
+    "
+    " Accept result if the range contains the cursor column
+    "
+    if l:col >= l:frac.col_start && l:col <= l:frac.col_end
+      return l:frac
+    endif
+  endfor
+
+  return {}
+endfunction
+
+" }}}1
+function! s:get_frac_inline_visual(selected) abort " {{{1
+  let l:parts = split(a:selected, '/')
+  if len(l:parts) != 2 | return {} | endif
+
+  let l:frac = {
+        \ 'type': 'inline',
+        \ 'text': a:selected,
+        \ 'numerator': s:get_inline_trim(l:parts[0]),
+        \ 'denominator': s:get_inline_trim(l:parts[1]),
+        \}
+
+  let l:frac.text_toggled  = printf('\frac{%s}{%s}',
+        \ l:frac.numerator, l:frac.denominator)
+
+  return l:frac
+endfunction
+
+" }}}1
+function! s:get_inline_limit(str, dir) abort " {{{1
+  if a:dir > 0
+    let l:open = '('
+    let l:string = a:str
+  else
+    let l:open = ')'
+    let l:string = join(reverse(split(a:str, '\zs')), '')
+  endif
+
+  let idx = -1
+  let depth = 0
+
+  while idx < len(l:string)
+    let idx = match(l:string, '[()]', idx + 1)
+    if idx < 0
+      let idx = len(l:string)
+    endif
+    if idx >= len(l:string) || l:string[idx] ==# l:open
+      let depth += 1
+    else
+      let depth -= 1
+      if depth == 0
+        return a:dir < 0 ? len(a:str) - idx : idx
+      endif
+    endif
+  endwhile
+
+  return -1
+endfunction
+
+" }}}1
+function! s:get_inline_trim(str) abort " {{{1
+  let l:str = vimtex#util#trim(a:str)
+  return substitute(l:str, '^(\(.*\))$', '\1', '')
+endfunction
+
+" }}}1
+
+function! vimtex#cmd#get_next() abort " {{{1
+  return s:get_cmd('next')
+endfunction
+
+" }}}1
+function! vimtex#cmd#get_prev() abort " {{{1
+  return s:get_cmd('prev')
+endfunction
+
+" }}}1
+function! vimtex#cmd#get_current() abort " {{{1
+  let l:save_pos = vimtex#pos#get_cursor()
+  let l:pos_val_cursor = vimtex#pos#val(l:save_pos)
+
+  let l:depth = 3
+  while l:depth > 0
+    let l:depth -= 1
+    let l:cmd = s:get_cmd('prev')
+    if empty(l:cmd) | break | endif
+
+    let l:pos_val = vimtex#pos#val(l:cmd.pos_end)
+    if l:pos_val >= l:pos_val_cursor
+      call vimtex#pos#set_cursor(l:save_pos)
+      return l:cmd
+    else
+      call vimtex#pos#set_cursor(vimtex#pos#prev(l:cmd.pos_start))
+    endif
+  endwhile
+
+  call vimtex#pos#set_cursor(l:save_pos)
+
+  return {}
+endfunction
+
+" }}}1
+function! vimtex#cmd#get_at(...) abort " {{{1
+  let l:pos_saved = vimtex#pos#get_cursor()
+  call call('vimtex#pos#set_cursor', a:000)
+  let l:cmd = vimtex#cmd#get_current()
+  call vimtex#pos#set_cursor(l:pos_saved)
+  return l:cmd
+endfunction
+
+" }}}1
+
+function! s:operator_setup(operator) abort " {{{1
+  let s:operator = a:operator
+  let &opfunc = s:snr() . 'operator_function'
+
+  " Ask for user input if necessary/relevant
+  if s:operator ==# 'change'
+    let l:current = vimtex#cmd#get_current()
+    if empty(l:current) | return | endif
+
+    let s:operator_cmd_name = substitute(vimtex#echo#input({
+          \ 'info' : ['Change command: ', ['VimtexWarning', l:current.name]],
+          \}), '^\\', '', '')
+  elseif s:operator ==# 'create'
+    let s:operator_cmd_name = substitute(vimtex#echo#input({
+          \ 'info' : ['Create command: ', ['VimtexWarning', '(empty to cancel)']],
+          \}), '^\\', '', '')
+  endif
+endfunction
+
+" }}}1
+function! s:operator_function(_) abort " {{{1
+  let l:name = get(s:, 'operator_cmd_name', '')
+
+  execute 'call vimtex#cmd#' . {
+        \   'change': 'change(l:name)',
+        \   'create': 'create(l:name, 0)',
+        \   'delete': 'delete()',
+        \   'toggle_star': 'toggle_star()',
+        \   'toggle_frac': 'toggle_frac()',
+        \ }[s:operator]
+endfunction
+
+" }}}1
+function! s:snr() abort " {{{1
+  return matchstr(expand('<sfile>'), '<SNR>\d\+_')
+endfunction
+
+" }}}1
+
+function! s:get_cmd(direction) abort " {{{1
+  let [lnum, cnum, match] = s:get_cmd_name(a:direction ==# 'next')
+  if lnum == 0 | return {} | endif
+
+  let res = {
+        \ 'name' : match,
+        \ 'text' : '',
+        \ 'pos_start' : { 'lnum' : lnum, 'cnum' : cnum },
+        \ 'pos_end' : { 'lnum' : lnum, 'cnum' : cnum + strlen(match) - 1 },
+        \ 'args' : [],
+        \}
+
+  " Environments always start with environment name and allows option
+  " afterwords
+  if res.name ==# '\begin'
+    let arg = s:get_cmd_part('{', res.pos_end)
+    if empty(arg) | return res | endif
+
+    call add(res.args, arg)
+    let res.pos_end.lnum = arg.close.lnum
+    let res.pos_end.cnum = arg.close.cnum
+  endif
+
+  " Get overlay specification
+  let res.overlay = s:get_cmd_overlay(res.pos_end.lnum, res.pos_end.cnum)
+  if !empty(res.overlay)
+    let res.pos_end.lnum = res.overlay.close.lnum
+    let res.pos_end.cnum = res.overlay.close.cnum
+  endif
+
+  " Get options
+  let res.opt = s:get_cmd_part('[', res.pos_end)
+  if !empty(res.opt)
+    let res.pos_end.lnum = res.opt.close.lnum
+    let res.pos_end.cnum = res.opt.close.cnum
+  endif
+
+  " Get arguments
+  let arg = s:get_cmd_part('{', res.pos_end)
+  while !empty(arg)
+    call add(res.args, arg)
+    let res.pos_end.lnum = arg.close.lnum
+    let res.pos_end.cnum = arg.close.cnum
+    let arg = s:get_cmd_part('{', res.pos_end)
+  endwhile
+
+  " Include entire cmd text
+  let res.text = s:text_between(res.pos_start, res.pos_end, 1)
+
+  return res
+endfunction
+
+" }}}1
+function! s:get_cmd_name(next) abort " {{{1
+  let [l:lnum, l:cnum] = searchpos('\v\\\a+\*?', a:next ? 'nW' : 'cbnW')
+  let l:match = matchstr(getline(l:lnum), '^\v\\\a*\*?', l:cnum-1)
+  return [l:lnum, l:cnum, l:match]
+endfunction
+
+" }}}1
+function! s:get_cmd_part(part, start_pos) abort " {{{1
+  let l:save_pos = vimtex#pos#get_cursor()
+  call vimtex#pos#set_cursor(a:start_pos)
+  let l:open = vimtex#delim#get_next('delim_tex', 'open')
+  call vimtex#pos#set_cursor(l:save_pos)
+
+  "
+  " Ensure that the delimiter
+  " 1) exists,
+  " 2) is of the right type,
+  " 3) and is the next non-whitespace character.
+  "
+  if empty(l:open)
+        \ || l:open.match !=# a:part
+        \ || strlen(substitute(
+        \        s:text_between(a:start_pos, l:open), '\_s', '', 'g')) != 0
+    return {}
+  endif
+
+  let l:close = vimtex#delim#get_matching(l:open)
+  if empty(l:close)
+    return {}
+  endif
+
+  return {
+        \ 'open' : l:open,
+        \ 'close' : l:close,
+        \ 'text' : s:text_between(l:open, l:close),
+        \}
+endfunction
+
+" }}}1
+function! s:get_cmd_overlay(lnum, cnum) abort " {{{1
+  let l:match = matchstr(getline(a:lnum), '^\s*[^>]*>', a:cnum)
+
+  return empty(l:match)
+        \ ? {}
+        \ : {
+        \    'open' : {'lnum' : a:lnum, 'cnum' : a:cnum + 1},
+        \    'close' : {'lnum' : a:lnum, 'cnum' : a:cnum + strlen(l:match)},
+        \    'text' : l:match
+        \   }
+endfunction
+
+" }}}1
+
+function! s:text_between(p1, p2, ...) abort " {{{1
+  let [l1, c1] = [a:p1.lnum, a:p1.cnum - (a:0 > 0)]
+  let [l2, c2] = [a:p2.lnum, a:p2.cnum - (a:0 <= 0)]
+
+  let lines = getline(l1, l2)
+  if !empty(lines)
+    let lines[0] = strpart(lines[0], c1)
+    let lines[-1] = strpart(lines[-1], 0,
+          \ l1 == l2 ? c2 - c1 : c2)
+  endif
+  return join(lines, "\n")
+endfunction
+
+" }}}1
+
+endif

autoload/vimtex/compiler.vim

@@ -0,0 +1,334 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+function! vimtex#compiler#init_buffer() abort " {{{1
+  if !g:vimtex_compiler_enabled | return | endif
+
+  " Define commands
+  command! -buffer        VimtexCompile                        call vimtex#compiler#compile()
+  command! -buffer -bang  VimtexCompileSS                      call vimtex#compiler#compile_ss()
+  command! -buffer -range VimtexCompileSelected <line1>,<line2>call vimtex#compiler#compile_selected('cmd')
+  command! -buffer        VimtexCompileOutput                  call vimtex#compiler#output()
+  command! -buffer        VimtexStop                           call vimtex#compiler#stop()
+  command! -buffer        VimtexStopAll                        call vimtex#compiler#stop_all()
+  command! -buffer -bang  VimtexClean                          call vimtex#compiler#clean(<q-bang> == "!")
+  command! -buffer -bang  VimtexStatus                         call vimtex#compiler#status(<q-bang> == "!")
+
+  " Define mappings
+  nnoremap <buffer> <plug>(vimtex-compile)          :call vimtex#compiler#compile()<cr>
+  nnoremap <buffer> <plug>(vimtex-compile-ss)       :call vimtex#compiler#compile_ss()<cr>
+  nnoremap <buffer> <plug>(vimtex-compile-selected) :set opfunc=vimtex#compiler#compile_selected<cr>g@
+  xnoremap <buffer> <plug>(vimtex-compile-selected) :<c-u>call vimtex#compiler#compile_selected('visual')<cr>
+  nnoremap <buffer> <plug>(vimtex-compile-output)   :call vimtex#compiler#output()<cr>
+  nnoremap <buffer> <plug>(vimtex-stop)             :call vimtex#compiler#stop()<cr>
+  nnoremap <buffer> <plug>(vimtex-stop-all)         :call vimtex#compiler#stop_all()<cr>
+  nnoremap <buffer> <plug>(vimtex-clean)            :call vimtex#compiler#clean(0)<cr>
+  nnoremap <buffer> <plug>(vimtex-clean-full)       :call vimtex#compiler#clean(1)<cr>
+  nnoremap <buffer> <plug>(vimtex-status)           :call vimtex#compiler#status(0)<cr>
+  nnoremap <buffer> <plug>(vimtex-status-all)       :call vimtex#compiler#status(1)<cr>
+endfunction
+
+" }}}1
+function! vimtex#compiler#init_state(state) abort " {{{1
+  if !g:vimtex_compiler_enabled | return | endif
+
+  try
+    let l:options = {
+          \ 'root': a:state.root,
+          \ 'target' : a:state.base,
+          \ 'target_path' : a:state.tex,
+          \ 'tex_program' : a:state.tex_program,
+          \}
+    let a:state.compiler
+          \ = vimtex#compiler#{g:vimtex_compiler_method}#init(l:options)
+  catch /vimtex: Requirements not met/
+    call vimtex#log#error('Compiler was not initialized!')
+  catch /E117/
+    call vimtex#log#error(
+          \ 'Invalid compiler: ' . g:vimtex_compiler_method,
+          \ 'Please see :h g:vimtex_compiler_method')
+  endtry
+endfunction
+
+" }}}1
+
+function! vimtex#compiler#callback(status) abort " {{{1
+  if exists('b:vimtex') && get(b:vimtex.compiler, 'silence_next_callback')
+    let b:vimtex.compiler.silence_next_callback = 0
+    return
+  endif
+
+  call vimtex#qf#open(0)
+  redraw
+
+  if exists('s:output')
+    call s:output.update()
+  endif
+
+  if a:status
+    call vimtex#log#info('Compilation completed')
+  else
+    call vimtex#log#warning('Compilation failed!')
+  endif
+
+  if a:status && exists('b:vimtex')
+    call b:vimtex.parse_packages()
+    call vimtex#syntax#load#packages()
+  endif
+
+  for l:hook in g:vimtex_compiler_callback_hooks
+    if exists('*' . l:hook)
+      execute 'call' l:hook . '(' . a:status . ')'
+    endif
+  endfor
+
+  return ''
+endfunction
+
+" }}}1
+
+function! vimtex#compiler#compile() abort " {{{1
+  if get(b:vimtex.compiler, 'continuous')
+    if b:vimtex.compiler.is_running()
+      call vimtex#compiler#stop()
+    else
+      call b:vimtex.compiler.start()
+      let b:vimtex.compiler.check_timer = s:check_if_running_start()
+    endif
+  else
+    call b:vimtex.compiler.start_single()
+  endif
+endfunction
+
+" }}}1
+function! vimtex#compiler#compile_ss() abort " {{{1
+  call b:vimtex.compiler.start_single()
+endfunction
+
+" }}}1
+function! vimtex#compiler#compile_selected(type) abort range " {{{1
+  let l:file = vimtex#parser#selection_to_texfile(a:type)
+  if empty(l:file) | return | endif
+
+  " Create and initialize temporary compiler
+  let l:options = {
+        \ 'root' : l:file.root,
+        \ 'target' : l:file.base,
+        \ 'target_path' : l:file.tex,
+        \ 'backend' : 'process',
+        \ 'tex_program' : b:vimtex.tex_program,
+        \ 'background' : 1,
+        \ 'continuous' : 0,
+        \ 'callback' : 0,
+        \}
+  let l:compiler = vimtex#compiler#{g:vimtex_compiler_method}#init(l:options)
+
+  call vimtex#log#toggle_verbose()
+  call l:compiler.start()
+
+  " Check if successful
+  if vimtex#qf#inquire(l:file.base)
+    call vimtex#log#toggle_verbose()
+    call vimtex#log#warning('Compiling selected lines ... failed!')
+    botright cwindow
+    return
+  else
+    call l:compiler.clean(0)
+    call b:vimtex.viewer.view(l:file.pdf)
+    call vimtex#log#toggle_verbose()
+    call vimtex#log#info('Compiling selected lines ... done')
+  endif
+endfunction
+
+" }}}1
+function! vimtex#compiler#output() abort " {{{1
+  let l:file = get(b:vimtex.compiler, 'output', '')
+  if empty(l:file)
+    call vimtex#log#warning('No output exists!')
+    return
+  endif
+
+  " If window already open, then go there
+  if exists('s:output')
+    if bufwinnr(l:file) == s:output.winnr
+      execute s:output.winnr . 'wincmd w'
+      return
+    else
+      call s:output.destroy()
+    endif
+  endif
+
+  " Create new output window
+  silent execute 'split' l:file
+
+  " Create the output object
+  let s:output = {}
+  let s:output.name = l:file
+  let s:output.bufnr = bufnr('%')
+  let s:output.winnr = bufwinnr('%')
+  function! s:output.update() dict abort
+    if bufwinnr(self.name) != self.winnr
+      return
+    endif
+
+    if mode() ==? 'v' || mode() ==# "\<c-v>"
+      return
+    endif
+
+    " Go to last line of file if it is not the current window
+    if bufwinnr('%') != self.winnr
+      let l:return = bufwinnr('%')
+      execute 'keepalt' self.winnr . 'wincmd w'
+      edit
+      normal! Gzb
+      execute 'keepalt' l:return . 'wincmd w'
+      redraw
+    endif
+  endfunction
+  function! s:output.destroy() dict abort
+    autocmd! vimtex_output_window
+    augroup! vimtex_output_window
+    unlet s:output
+  endfunction
+
+  " Better automatic update
+  augroup vimtex_output_window
+    autocmd!
+    autocmd BufDelete <buffer> call s:output.destroy()
+    autocmd BufEnter     *     call s:output.update()
+    autocmd FocusGained  *     call s:output.update()
+    autocmd CursorHold   *     call s:output.update()
+    autocmd CursorHoldI  *     call s:output.update()
+    autocmd CursorMoved  *     call s:output.update()
+    autocmd CursorMovedI *     call s:output.update()
+  augroup END
+
+  " Set some mappings
+  nnoremap <silent><nowait><buffer> q :bwipeout<cr>
+  if has('nvim') || has('gui_running')
+    nnoremap <silent><nowait><buffer> <esc> :bwipeout<cr>
+  endif
+
+  " Set some buffer options
+  setlocal autoread
+  setlocal nomodifiable
+  setlocal bufhidden=wipe
+endfunction
+
+" }}}1
+function! vimtex#compiler#stop() abort " {{{1
+  call b:vimtex.compiler.stop()
+  silent! call timer_stop(b:vimtex.compiler.check_timer)
+endfunction
+
+" }}}1
+function! vimtex#compiler#stop_all() abort " {{{1
+  for l:state in vimtex#state#list_all()
+    if exists('l:state.compiler.is_running')
+          \ && l:state.compiler.is_running()
+      call l:state.compiler.stop()
+    endif
+  endfor
+endfunction
+
+" }}}1
+function! vimtex#compiler#clean(full) abort " {{{1
+  call b:vimtex.compiler.clean(a:full)
+
+  if empty(b:vimtex.compiler.build_dir) | return | endif
+  sleep 100m
+
+  " Remove auxilliary output directories if they are empty
+  let l:build_dir = (vimtex#paths#is_abs(b:vimtex.compiler.build_dir)
+        \ ? '' : b:vimtex.root . '/')
+        \ . b:vimtex.compiler.build_dir
+  let l:tree = glob(l:build_dir . '/**/*', 0, 1)
+  let l:files = filter(copy(l:tree), 'filereadable(v:val)')
+  if !empty(l:files) | return | endif
+
+  for l:dir in sort(l:tree) + [l:build_dir]
+    call delete(l:dir, 'd')
+  endfor
+endfunction
+
+" }}}1
+function! vimtex#compiler#status(detailed) abort " {{{1
+  if a:detailed
+    let l:running = []
+    for l:data in vimtex#state#list_all()
+      if l:data.compiler.is_running()
+        let l:name = l:data.tex
+        if len(l:name) >= winwidth('.') - 20
+          let l:name = '...' . l:name[-winwidth('.')+23:]
+        endif
+        call add(l:running, printf('%-6s %s',
+              \ string(l:data.compiler.get_pid()) . ':', l:name))
+      endif
+    endfor
+
+    if empty(l:running)
+      call vimtex#log#warning('Compiler is not running!')
+    else
+      call vimtex#log#info('Compiler is running', l:running)
+    endif
+  else
+    if b:vimtex.compiler.is_running()
+      call vimtex#log#info('Compiler is running')
+    else
+      call vimtex#log#warning('Compiler is not running!')
+    endif
+  endif
+endfunction
+
+" }}}1
+
+
+let s:check_timers = {}
+function! s:check_if_running_start() abort " {{{1
+  if !exists('*timer_start') | return -1 | endif
+
+  let l:timer = timer_start(50, function('s:check_if_running'), {'repeat': 20})
+
+  let s:check_timers[l:timer] = {
+        \ 'compiler' : b:vimtex.compiler,
+        \ 'vimtex_id' : b:vimtex_id,
+        \}
+
+  return l:timer
+endfunction
+
+" }}}1
+function! s:check_if_running(timer) abort " {{{1
+  if s:check_timers[a:timer].compiler.is_running() | return | endif
+
+  call timer_stop(a:timer)
+
+  if get(b:, 'vimtex_id', -1) == s:check_timers[a:timer].vimtex_id
+    call vimtex#compiler#output()
+  endif
+  call vimtex#log#error('Compiler did not start successfully!')
+
+  unlet s:check_timers[a:timer].compiler.check_timer
+  unlet s:check_timers[a:timer]
+endfunction
+
+" }}}1
+
+
+" {{{1 Initialize module
+
+if !g:vimtex_compiler_enabled | finish | endif
+
+augroup vimtex_compiler
+  autocmd!
+  autocmd VimLeave * call vimtex#compiler#stop_all()
+augroup END
+
+" }}}1
+
+endif

autoload/vimtex/compiler/arara.vim

@@ -0,0 +1,218 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+function! vimtex#compiler#arara#init(options) abort " {{{1
+  let l:compiler = deepcopy(s:compiler)
+
+  call l:compiler.init(extend(a:options,
+        \ get(g:, 'vimtex_compiler_arara', {}), 'keep'))
+
+  return l:compiler
+endfunction
+
+" }}}1
+
+let s:compiler = {
+      \ 'name' : 'arara',
+      \ 'backend' : has('nvim') ? 'nvim'
+      \                         : v:version >= 800 ? 'jobs' : 'process',
+      \ 'root' : '',
+      \ 'target' : '',
+      \ 'target_path' : '',
+      \ 'background' : 1,
+      \ 'output' : tempname(),
+      \ 'options' : ['--log'],
+      \}
+
+function! s:compiler.init(options) abort dict " {{{1
+  call extend(self, a:options)
+
+  if !executable('arara')
+    call vimtex#log#warning('arara is not executable!')
+    throw 'vimtex: Requirements not met'
+  endif
+
+  call extend(self, deepcopy(s:compiler_{self.backend}))
+
+  " Processes run with the new jobs api will not run in the foreground
+  if self.backend !=# 'process'
+    let self.background = 1
+  endif
+endfunction
+
+" }}}1
+
+function! s:compiler.build_cmd() abort dict " {{{1
+  let l:cmd = 'arara'
+
+  for l:opt in self.options
+    let l:cmd .= ' ' . l:opt
+  endfor
+
+  return l:cmd . ' ' . vimtex#util#shellescape(self.target)
+endfunction
+
+" }}}1
+function! s:compiler.cleanup() abort dict " {{{1
+  " Pass
+endfunction
+
+" }}}1
+function! s:compiler.pprint_items() abort dict " {{{1
+  let l:configuration = []
+
+  if self.backend ==# 'process'
+    call add(l:configuration, ['background', self.background])
+  endif
+
+  call add(l:configuration, ['arara options', self.options])
+
+  let l:list = []
+  call add(l:list, ['backend', self.backend])
+  if self.background
+    call add(l:list, ['output', self.output])
+  endif
+
+  if self.target_path !=# b:vimtex.tex
+    call add(l:list, ['root', self.root])
+    call add(l:list, ['target', self.target_path])
+  endif
+
+  call add(l:list, ['configuration', l:configuration])
+
+  if has_key(self, 'process')
+    call add(l:list, ['process', self.process])
+  endif
+
+  if has_key(self, 'job')
+    call add(l:list, ['cmd', self.cmd])
+  endif
+
+  return l:list
+endfunction
+
+" }}}1
+
+function! s:compiler.clean(...) abort dict " {{{1
+  call vimtex#log#warning('Clean not implemented for arara')
+endfunction
+
+" }}}1
+function! s:compiler.start(...) abort dict " {{{1
+  call self.exec()
+
+  if self.background
+    call vimtex#log#info('Compiler started in background')
+  else
+    call vimtex#compiler#callback(!vimtex#qf#inquire(self.target))
+  endif
+endfunction
+
+" }}}1
+function! s:compiler.start_single() abort dict " {{{1
+  call self.start()
+endfunction
+
+" }}}1
+function! s:compiler.stop() abort dict " {{{1
+  " Pass
+endfunction
+
+" }}}1
+function! s:compiler.is_running() abort dict " {{{1
+  return 0
+endfunction
+
+" }}}1
+function! s:compiler.kill() abort dict " {{{1
+  " Pass
+endfunction
+
+" }}}1
+function! s:compiler.get_pid() abort dict " {{{1
+  return 0
+endfunction
+
+" }}}1
+
+let s:compiler_process = {}
+function! s:compiler_process.exec() abort dict " {{{1
+  let self.process = vimtex#process#new()
+  let self.process.name = 'arara'
+  let self.process.background = self.background
+  let self.process.workdir = self.root
+  let self.process.output = self.output
+  let self.process.cmd = self.build_cmd()
+  call self.process.run()
+endfunction
+
+" }}}1
+
+let s:compiler_jobs = {}
+function! s:compiler_jobs.exec() abort dict " {{{1
+  let self.cmd = self.build_cmd()
+  let l:cmd = has('win32')
+        \ ? 'cmd /s /c "' . self.cmd . '"'
+        \ : ['sh', '-c', self.cmd]
+  let l:options = {
+        \ 'out_io' : 'file',
+        \ 'err_io' : 'file',
+        \ 'out_name' : self.output,
+        \ 'err_name' : self.output,
+        \}
+
+  let s:cb_target = self.target_path !=# b:vimtex.tex ? self.target_path : ''
+  let l:options.exit_cb = function('s:callback')
+
+  call vimtex#paths#pushd(self.root)
+  let self.job = job_start(l:cmd, l:options)
+  call vimtex#paths#popd()
+endfunction
+
+" }}}1
+function! s:callback(ch, msg) abort " {{{1
+  call vimtex#compiler#callback(!vimtex#qf#inquire(s:cb_target))
+endfunction
+
+" }}}1
+
+let s:compiler_nvim = {}
+function! s:compiler_nvim.exec() abort dict " {{{1
+  let self.cmd = self.build_cmd()
+  let l:cmd = has('win32')
+        \ ? 'cmd /s /c "' . self.cmd . '"'
+        \ : ['sh', '-c', self.cmd]
+
+  let l:shell = {
+        \ 'on_stdout' : function('s:callback_nvim_output'),
+        \ 'on_stderr' : function('s:callback_nvim_output'),
+        \ 'on_exit' : function('s:callback_nvim_exit'),
+        \ 'cwd' : self.root,
+        \ 'target' : self.target_path,
+        \ 'output' : self.output,
+        \}
+
+  let self.job = jobstart(l:cmd, l:shell)
+endfunction
+
+" }}}1
+function! s:callback_nvim_output(id, data, event) abort dict " {{{1
+  if !empty(a:data)
+    call writefile(filter(a:data, '!empty(v:val)'), self.output, 'a')
+  endif
+endfunction
+
+" }}}1
+function! s:callback_nvim_exit(id, data, event) abort dict " {{{1
+  let l:target = self.target !=# b:vimtex.tex ? self.target : ''
+  call vimtex#compiler#callback(!vimtex#qf#inquire(l:target))
+endfunction
+
+" }}}1
+
+endif

autoload/vimtex/compiler/latexmk.vim

@@ -0,0 +1,700 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+function! vimtex#compiler#latexmk#init(options) abort " {{{1
+  let l:compiler = deepcopy(s:compiler)
+
+  call l:compiler.init(extend(a:options,
+        \ get(g:, 'vimtex_compiler_latexmk', {}), 'keep'))
+
+  return l:compiler
+endfunction
+
+" }}}1
+function! vimtex#compiler#latexmk#wrap_option(name, value) abort " {{{1
+  return has('win32')
+        \ ? ' -e "$' . a:name . ' = ''' . a:value . '''"'
+        \ : ' -e ''$' . a:name . ' = "' . a:value . '"'''
+endfunction
+
+"}}}1
+
+function! vimtex#compiler#latexmk#get_rc_opt(root, opt, type, default) abort " {{{1
+  "
+  " Parse option from .latexmkrc.
+  "
+  " Arguments:
+  "   root         Root of LaTeX project
+  "   opt          Name of options
+  "   type         0 if string, 1 if integer, 2 if list
+  "   default      Value to return if option not found in latexmkrc file
+  "
+  " Output:
+  "   [value, location]
+  "
+  "   value        Option value (integer or string)
+  "   location     An integer that indicates where option was found
+  "                 -1: not found (default value returned)
+  "                  0: global latexmkrc file
+  "                  1: local latexmkrc file
+  "
+
+  if a:type == 0
+    let l:pattern = '^\s*\$' . a:opt . '\s*=\s*[''"]\(.\+\)[''"]'
+  elseif a:type == 1
+    let l:pattern = '^\s*\$' . a:opt . '\s*=\s*\(\d\+\)'
+  elseif a:type == 2
+    let l:pattern = '^\s*@' . a:opt . '\s*=\s*(\(.*\))'
+  else
+    throw 'vimtex: argument error'
+  endif
+
+  " Candidate files
+  " - each element is a pair [path_to_file, is_local_rc_file].
+  let l:files = [
+        \ [a:root . '/latexmkrc', 1],
+        \ [a:root . '/.latexmkrc', 1],
+        \ [fnamemodify('~/.latexmkrc', ':p'), 0],
+        \]
+  if !empty($XDG_CONFIG_HOME)
+    call add(l:files, [$XDG_CONFIG_HOME . '/latexmk/latexmkrc', 0])
+  endif
+
+  let l:result = [a:default, -1]
+
+  for [l:file, l:is_local] in l:files
+    if filereadable(l:file)
+      let l:match = matchlist(readfile(l:file), l:pattern)
+      if len(l:match) > 1
+        let l:result = [l:match[1], l:is_local]
+        break
+      end
+    endif
+  endfor
+
+  " Parse the list
+  if a:type == 2 && l:result[1] > -1
+    let l:array = split(l:result[0], ',')
+    let l:result[0] = []
+    for l:x in l:array
+      let l:x = substitute(l:x, "^'", '', '')
+      let l:x = substitute(l:x, "'$", '', '')
+      let l:result[0] += [l:x]
+    endfor
+  endif
+
+  return l:result
+endfunction
+
+" }}}1
+
+let s:compiler = {
+      \ 'name' : 'latexmk',
+      \ 'executable' : 'latexmk',
+      \ 'backend' : has('nvim') ? 'nvim'
+      \                         : v:version >= 800 ? 'jobs' : 'process',
+      \ 'root' : '',
+      \ 'target' : '',
+      \ 'target_path' : '',
+      \ 'background' : 1,
+      \ 'build_dir' : '',
+      \ 'callback' : 1,
+      \ 'continuous' : 1,
+      \ 'output' : tempname(),
+      \ 'options' : [
+      \   '-verbose',
+      \   '-file-line-error',
+      \   '-synctex=1',
+      \   '-interaction=nonstopmode',
+      \ ],
+      \ 'hooks' : [],
+      \ 'shell' : fnamemodify(&shell, ':t'),
+      \}
+
+function! s:compiler.init(options) abort dict " {{{1
+  call extend(self, a:options)
+
+  call self.init_check_requirements()
+  call self.init_build_dir_option()
+  call self.init_pdf_mode_option()
+
+  call extend(self, deepcopy(s:compiler_{self.backend}))
+
+  " Continuous processes can't run in foreground, neither can processes run
+  " with the new jobs api
+  if self.continuous || self.backend !=# 'process'
+    let self.background = 1
+  endif
+
+  if self.backend !=# 'process'
+    let self.shell = 'sh'
+  endif
+endfunction
+
+" }}}1
+function! s:compiler.init_build_dir_option() abort dict " {{{1
+  "
+  " Check if .latexmkrc sets the build_dir - if so this should be respected
+  "
+  let l:out_dir =
+        \ vimtex#compiler#latexmk#get_rc_opt(self.root, 'out_dir', 0, '')[0]
+
+  if !empty(l:out_dir)
+    if !empty(self.build_dir) && (self.build_dir !=# l:out_dir)
+      call vimtex#log#warning(
+            \ 'Setting out_dir from latexmkrc overrides build_dir!',
+            \ 'Changed build_dir from: ' . self.build_dir,
+            \ 'Changed build_dir to: ' . l:out_dir)
+    endif
+    let self.build_dir = l:out_dir
+  endif
+endfunction
+
+" }}}1
+function! s:compiler.init_pdf_mode_option() abort dict " {{{1
+  " If the TeX program directive was not set, and if the pdf_mode is set in
+  " a .latexmkrc file, then deduce the compiler engine from the value of
+  " pdf_mode.
+
+  " Parse the pdf_mode option. If not found, it is set to -1.
+  let [l:pdf_mode, l:is_local] =
+        \ vimtex#compiler#latexmk#get_rc_opt(self.root, 'pdf_mode', 1, -1)
+
+  " If pdf_mode has a supported value (1: pdflatex, 4: lualatex, 5: xelatex),
+  " override the value of self.tex_program.
+  if l:pdf_mode == 1
+    let l:tex_program = 'pdflatex'
+  elseif l:pdf_mode == 3
+    let l:tex_program = 'pdfdvi'
+  elseif l:pdf_mode == 4
+    let l:tex_program = 'lualatex'
+  elseif l:pdf_mode == 5
+    let l:tex_program = 'xelatex'
+  else
+    return
+  endif
+
+  if self.tex_program ==# '_'
+    " The TeX program directive was not specified
+    let self.tex_program = l:tex_program
+  elseif l:is_local && self.tex_program !=# l:tex_program
+    call vimtex#log#warning(
+          \ 'Value of pdf_mode from latexmkrc is inconsistent with ' .
+          \ 'TeX program directive!',
+          \ 'TeX program: ' . self.tex_program,
+          \ 'pdf_mode:    ' . l:tex_program,
+          \ 'The value of pdf_mode will be ignored.')
+  endif
+endfunction
+
+" }}}1
+function! s:compiler.init_check_requirements() abort dict " {{{1
+  " Check option validity
+  if self.callback
+    if !(has('clientserver') || has('nvim') || has('job'))
+      let self.callback = 0
+      call vimtex#log#warning(
+            \ 'Can''t use callbacks without +job, +nvim, or +clientserver',
+            \ 'Callback option has been disabled.')
+    endif
+  endif
+
+  " Check for required executables
+  let l:required = [self.executable]
+  if self.continuous && !(has('win32') || has('win32unix'))
+    let l:required += ['pgrep']
+  endif
+  let l:missing = filter(l:required, '!executable(v:val)')
+
+  " Disable latexmk if required programs are missing
+  if len(l:missing) > 0
+    for l:cmd in l:missing
+      call vimtex#log#warning(l:cmd . ' is not executable')
+    endfor
+    throw 'vimtex: Requirements not met'
+  endif
+endfunction
+
+" }}}1
+
+function! s:compiler.build_cmd() abort dict " {{{1
+  if has('win32')
+    let l:cmd = 'set max_print_line=2000 & ' . self.executable
+  else
+    if self.shell ==# 'fish'
+      let l:cmd = 'set max_print_line 2000; and ' . self.executable
+    else
+      let l:cmd = 'max_print_line=2000 ' . self.executable
+    endif
+  endif
+
+  for l:opt in self.options
+    let l:cmd .= ' ' . l:opt
+  endfor
+
+  let l:cmd .= ' ' . self.get_engine()
+
+  if !empty(self.build_dir)
+    let l:cmd .= ' -outdir=' . fnameescape(self.build_dir)
+  endif
+
+  if self.continuous
+    let l:cmd .= ' -pvc'
+
+    " Set viewer options
+    if !get(g:, 'vimtex_view_automatic', 1)
+          \ || get(get(b:vimtex, 'viewer', {}), 'xwin_id') > 0
+          \ || get(s:, 'silence_next_callback', 0)
+      let l:cmd .= ' -view=none'
+    elseif g:vimtex_view_enabled
+          \ && has_key(b:vimtex.viewer, 'latexmk_append_argument')
+      let l:cmd .= b:vimtex.viewer.latexmk_append_argument()
+    endif
+
+    if self.callback
+      if has('job') || has('nvim')
+        for [l:opt, l:val] in items({
+              \ 'success_cmd' : 'vimtex_compiler_callback_success',
+              \ 'failure_cmd' : 'vimtex_compiler_callback_failure',
+              \})
+          let l:func = 'echo ' . l:val
+          let l:cmd .= vimtex#compiler#latexmk#wrap_option(l:opt, l:func)
+        endfor
+      elseif empty(v:servername)
+        call vimtex#log#warning('Can''t use callbacks with empty v:servername')
+      else
+        " Some notes:
+        " - We excape the v:servername because this seems necessary on Windows
+        "   for neovim, see e.g. Github Issue #877
+        for [l:opt, l:val] in items({'success_cmd' : 1, 'failure_cmd' : 0})
+          let l:callback = has('win32')
+                \   ? '"vimtex#compiler#callback(' . l:val . ')"'
+                \   : '\"vimtex\#compiler\#callback(' . l:val . ')\"'
+          let l:func = vimtex#util#shellescape('""')
+                \ . g:vimtex_compiler_progname
+                \ . vimtex#util#shellescape('""')
+                \ . ' --servername ' . vimtex#util#shellescape(v:servername)
+                \ . ' --remote-expr ' . l:callback
+          let l:cmd .= vimtex#compiler#latexmk#wrap_option(l:opt, l:func)
+        endfor
+      endif
+    endif
+  endif
+
+  return l:cmd . ' ' . vimtex#util#shellescape(self.target)
+endfunction
+
+" }}}1
+function! s:compiler.get_engine() abort dict " {{{1
+  return get(extend(g:vimtex_compiler_latexmk_engines,
+        \ {
+        \  'pdfdvi'           : '-pdfdvi',
+        \  'pdflatex'         : '-pdf',
+        \  'luatex'           : '-lualatex',
+        \  'lualatex'         : '-lualatex',
+        \  'xelatex'          : '-xelatex',
+        \  'context (pdftex)' : '-pdf -pdflatex=texexec',
+        \  'context (luatex)' : '-pdf -pdflatex=context',
+        \  'context (xetex)'  : '-pdf -pdflatex=''texexec --xtx''',
+        \ }, 'keep'), self.tex_program, '-pdf')
+endfunction
+
+" }}}1
+function! s:compiler.cleanup() abort dict " {{{1
+  if self.is_running()
+    call self.kill()
+  endif
+endfunction
+
+" }}}1
+function! s:compiler.pprint_items() abort dict " {{{1
+  let l:configuration = [
+        \ ['continuous', self.continuous],
+        \ ['callback', self.callback],
+        \]
+
+  if self.backend ==# 'process' && !self.continuous
+    call add(l:configuration, ['background', self.background])
+  endif
+
+  if !empty(self.build_dir)
+    call add(l:configuration, ['build_dir', self.build_dir])
+  endif
+  call add(l:configuration, ['latexmk options', self.options])
+  call add(l:configuration, ['latexmk engine', self.get_engine()])
+
+  let l:list = []
+  call add(l:list, ['backend', self.backend])
+  if self.executable !=# s:compiler.executable
+    call add(l:list, ['latexmk executable', self.executable])
+  endif
+  if self.background
+    call add(l:list, ['output', self.output])
+  endif
+
+  if self.target_path !=# b:vimtex.tex
+    call add(l:list, ['root', self.root])
+    call add(l:list, ['target', self.target_path])
+  endif
+
+  call add(l:list, ['configuration', l:configuration])
+
+  if has_key(self, 'process')
+    call add(l:list, ['process', self.process])
+  endif
+
+  if has_key(self, 'job')
+    if self.continuous
+      if self.backend ==# 'jobs'
+        call add(l:list, ['job', self.job])
+      else
+        call add(l:list, ['pid', self.get_pid()])
+      endif
+    endif
+    call add(l:list, ['cmd', self.cmd])
+  endif
+
+  return l:list
+endfunction
+
+" }}}1
+
+function! s:compiler.clean(full) abort dict " {{{1
+  let l:restart = self.is_running()
+  if l:restart
+    call self.stop()
+  endif
+
+  " Define and run the latexmk clean cmd
+  let l:cmd = (has('win32')
+        \   ? 'cd /D "' . self.root . '" & '
+        \   : 'cd ' . vimtex#util#shellescape(self.root) . '; ')
+        \ . self.executable . ' ' . (a:full ? '-C ' : '-c ')
+  if !empty(self.build_dir)
+    let l:cmd .= printf(' -outdir=%s ', fnameescape(self.build_dir))
+  endif
+  let l:cmd .= vimtex#util#shellescape(self.target)
+  call vimtex#process#run(l:cmd)
+
+  call vimtex#log#info('Compiler clean finished' . (a:full ? ' (full)' : ''))
+
+  if l:restart
+    let self.silent_next_callback = 1
+    silent call self.start()
+  endif
+endfunction
+
+" }}}1
+function! s:compiler.start(...) abort dict " {{{1
+  if self.is_running()
+    call vimtex#log#warning(
+          \ 'Compiler is already running for `' . self.target . "'")
+    return
+  endif
+
+  "
+  " Create build dir if it does not exist
+  "
+  if !empty(self.build_dir)
+    let l:dirs = split(glob(self.root . '/**/*.tex'), '\n')
+    call map(l:dirs, 'fnamemodify(v:val, '':h'')')
+    call map(l:dirs, 'strpart(v:val, strlen(self.root) + 1)')
+    call vimtex#util#uniq(sort(filter(l:dirs, "v:val !=# ''")))
+    call map(l:dirs,
+          \ (vimtex#paths#is_abs(self.build_dir) ? '' : "self.root . '/' . ")
+          \ . "self.build_dir . '/' . v:val")
+    call filter(l:dirs, '!isdirectory(v:val)')
+
+    " Create the non-existing directories
+    for l:dir in l:dirs
+      call mkdir(l:dir, 'p')
+    endfor
+  endif
+
+  call self.exec()
+
+  if self.continuous
+    call vimtex#log#info('Compiler started in continuous mode'
+          \ . (a:0 > 0 ? ' (single shot)' : ''))
+    if exists('#User#VimtexEventCompileStarted')
+      doautocmd <nomodeline> User VimtexEventCompileStarted
+    endif
+  else
+    if self.background
+      call vimtex#log#info('Compiler started in background!')
+    else
+      call vimtex#compiler#callback(!vimtex#qf#inquire(self.target))
+    endif
+  endif
+endfunction
+
+" }}}1
+function! s:compiler.stop() abort dict " {{{1
+  if self.is_running()
+    call self.kill()
+    call vimtex#log#info('Compiler stopped (' . self.target . ')')
+    if exists('#User#VimtexEventCompileStopped')
+      doautocmd <nomodeline> User VimtexEventCompileStopped
+    endif
+  else
+    call vimtex#log#warning(
+          \ 'There is no process to stop (' . self.target . ')')
+  endif
+endfunction
+
+" }}}1
+
+let s:compiler_process = {}
+function! s:compiler_process.exec() abort dict " {{{1
+  let l:process = vimtex#process#new()
+  let l:process.name = 'latexmk'
+  let l:process.continuous = self.continuous
+  let l:process.background = self.background
+  let l:process.workdir = self.root
+  let l:process.output = self.output
+  let l:process.cmd = self.build_cmd()
+
+  if l:process.continuous
+    if (has('win32') || has('win32unix'))
+      " Not implemented
+    else
+      for l:pid in split(system(
+            \ 'pgrep -f "^[^ ]*perl.*latexmk.*' . self.target . '"'), "\n")
+        let l:path = resolve('/proc/' . l:pid . '/cwd') . '/' . self.target
+        if l:path ==# self.target_path
+          let l:process.pid = str2nr(l:pid)
+          break
+        endif
+      endfor
+    endif
+  endif
+
+  function! l:process.set_pid() abort dict " {{{2
+    if (has('win32') || has('win32unix'))
+      let pidcmd = 'tasklist /fi "imagename eq latexmk.exe"'
+      let pidinfo = vimtex#process#capture(pidcmd)[-1]
+      let self.pid = str2nr(split(pidinfo,'\s\+')[1])
+    else
+      let self.pid = str2nr(system('pgrep -nf "^[^ ]*perl.*latexmk"')[:-2])
+    endif
+
+    return self.pid
+  endfunction
+
+  " }}}2
+
+  let self.process = l:process
+  call self.process.run()
+endfunction
+
+" }}}1
+function! s:compiler_process.start_single() abort dict " {{{1
+  let l:continuous = self.continuous
+  let self.continuous = self.background && self.callback && !empty(v:servername)
+
+  if self.continuous
+    let g:vimtex_compiler_callback_hooks += ['VimtexSSCallback']
+    function! VimtexSSCallback(status) abort
+      silent call vimtex#compiler#stop()
+      call remove(g:vimtex_compiler_callback_hooks, 'VimtexSSCallback')
+    endfunction
+  endif
+
+  call self.start(1)
+  let self.continuous = l:continuous
+endfunction
+
+" }}}1
+function! s:compiler_process.is_running() abort dict " {{{1
+  return exists('self.process.pid') && self.process.pid > 0
+endfunction
+
+" }}}1
+function! s:compiler_process.kill() abort dict " {{{1
+  call self.process.stop()
+endfunction
+
+" }}}1
+function! s:compiler_process.get_pid() abort dict " {{{1
+  return has_key(self, 'process') ? self.process.pid : 0
+endfunction
+
+" }}}1
+
+let s:compiler_jobs = {}
+function! s:compiler_jobs.exec() abort dict " {{{1
+  let self.cmd = self.build_cmd()
+  let l:cmd = has('win32')
+        \ ? 'cmd /s /c "' . self.cmd . '"'
+        \ : ['sh', '-c', self.cmd]
+
+  let l:options = {
+        \ 'out_io' : 'file',
+        \ 'err_io' : 'file',
+        \ 'out_name' : self.output,
+        \ 'err_name' : self.output,
+        \}
+  if self.continuous
+    let l:options.out_io = 'pipe'
+    let l:options.err_io = 'pipe'
+    let l:options.out_cb = function('s:callback_continuous_output')
+    let l:options.err_cb = function('s:callback_continuous_output')
+    call writefile([], self.output, 'a')
+  else
+    let s:cb_target = self.target_path !=# b:vimtex.tex
+          \ ? self.target_path : ''
+    let l:options.exit_cb = function('s:callback')
+  endif
+
+  call vimtex#paths#pushd(self.root)
+  let self.job = job_start(l:cmd, l:options)
+  call vimtex#paths#popd()
+endfunction
+
+" }}}1
+function! s:compiler_jobs.start_single() abort dict " {{{1
+  let l:continuous = self.continuous
+  let self.continuous = 0
+  call self.start()
+  let self.continuous = l:continuous
+endfunction
+
+" }}}1
+function! s:compiler_jobs.kill() abort dict " {{{1
+  call job_stop(self.job)
+endfunction
+
+" }}}1
+function! s:compiler_jobs.is_running() abort dict " {{{1
+  return has_key(self, 'job') && job_status(self.job) ==# 'run'
+endfunction
+
+" }}}1
+function! s:compiler_jobs.get_pid() abort dict " {{{1
+  return has_key(self, 'job')
+        \ ? get(job_info(self.job), 'process') : 0
+endfunction
+
+" }}}1
+function! s:callback(ch, msg) abort " {{{1
+  call vimtex#compiler#callback(!vimtex#qf#inquire(s:cb_target))
+endfunction
+
+" }}}1
+function! s:callback_continuous_output(channel, msg) abort " {{{1
+  if exists('b:vimtex') && filewritable(b:vimtex.compiler.output)
+    call writefile([a:msg], b:vimtex.compiler.output, 'a')
+  endif
+
+  if a:msg ==# 'vimtex_compiler_callback_success'
+    call vimtex#compiler#callback(1)
+  elseif a:msg ==# 'vimtex_compiler_callback_failure'
+    call vimtex#compiler#callback(0)
+  endif
+
+  try
+    for l:Hook in get(get(get(b:, 'vimtex', {}), 'compiler', {}), 'hooks', [])
+      call l:Hook(a:msg)
+    endfor
+  catch /E716/
+  endtry
+endfunction
+
+" }}}1
+
+let s:compiler_nvim = {}
+function! s:compiler_nvim.exec() abort dict " {{{1
+  let self.cmd = self.build_cmd()
+  let l:cmd = has('win32')
+        \ ? 'cmd /s /c "' . self.cmd . '"'
+        \ : ['sh', '-c', self.cmd]
+
+  let l:shell = {
+        \ 'on_stdout' : function('s:callback_nvim_output'),
+        \ 'on_stderr' : function('s:callback_nvim_output'),
+        \ 'cwd' : self.root,
+        \ 'target' : self.target_path,
+        \ 'output' : self.output,
+        \}
+
+  if !self.continuous
+    let l:shell.on_exit = function('s:callback_nvim_exit')
+  endif
+
+  " Initialize output file
+  try
+    call writefile([], self.output)
+  endtry
+
+  let self.job = jobstart(l:cmd, l:shell)
+endfunction
+
+" }}}1
+function! s:compiler_nvim.start_single() abort dict " {{{1
+  let l:continuous = self.continuous
+  let self.continuous = 0
+  call self.start()
+  let self.continuous = l:continuous
+endfunction
+
+" }}}1
+function! s:compiler_nvim.kill() abort dict " {{{1
+  call jobstop(self.job)
+endfunction
+
+" }}}1
+function! s:compiler_nvim.is_running() abort dict " {{{1
+  try
+    let pid = jobpid(self.job)
+    return 1
+  catch
+    return 0
+  endtry
+endfunction
+
+" }}}1
+function! s:compiler_nvim.get_pid() abort dict " {{{1
+  try
+    return jobpid(self.job)
+  catch
+    return 0
+  endtry
+endfunction
+
+" }}}1
+function! s:callback_nvim_output(id, data, event) abort dict " {{{1
+  " Filter out unwanted newlines
+  let l:data = split(substitute(join(a:data, 'QQ'), '^QQ\|QQ$', '', ''), 'QQ')
+
+  if !empty(l:data) && filewritable(self.output)
+    call writefile(l:data, self.output, 'a')
+  endif
+
+  if match(a:data, 'vimtex_compiler_callback_success') != -1
+    call vimtex#compiler#callback(!vimtex#qf#inquire(self.target))
+  elseif match(a:data, 'vimtex_compiler_callback_failure') != -1
+    call vimtex#compiler#callback(0)
+  endif
+
+  try
+    for l:Hook in get(get(get(b:, 'vimtex', {}), 'compiler', {}), 'hooks', [])
+      call l:Hook(join(a:data, "\n"))
+    endfor
+  catch /E716/
+  endtry
+endfunction
+
+" }}}1
+function! s:callback_nvim_exit(id, data, event) abort dict " {{{1
+  let l:target = self.target !=# b:vimtex.tex ? self.target : ''
+  call vimtex#compiler#callback(!vimtex#qf#inquire(l:target))
+endfunction
+
+" }}}1
+
+endif

autoload/vimtex/compiler/latexrun.vim

@@ -0,0 +1,250 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+function! vimtex#compiler#latexrun#init(options) abort " {{{1
+  let l:compiler = deepcopy(s:compiler)
+
+  call l:compiler.init(extend(a:options,
+        \ get(g:, 'vimtex_compiler_latexrun', {}), 'keep'))
+
+  return l:compiler
+endfunction
+
+" }}}1
+
+let s:compiler = {
+      \ 'name' : 'latexrun',
+      \ 'backend' : has('nvim') ? 'nvim'
+      \                         : v:version >= 800 ? 'jobs' : 'process',
+      \ 'root' : '',
+      \ 'target' : '',
+      \ 'target_path' : '',
+      \ 'background' : 1,
+      \ 'build_dir' : '',
+      \ 'output' : tempname(),
+      \ 'options' : [
+      \   '--verbose-cmds',
+      \   '--latex-args="-synctex=1"',
+      \ ],
+      \}
+
+function! s:compiler.init(options) abort dict " {{{1
+  call extend(self, a:options)
+
+  if !executable('latexrun')
+    call vimtex#log#warning('latexrun is not executable!')
+    throw 'vimtex: Requirements not met'
+  endif
+
+  call extend(self, deepcopy(s:compiler_{self.backend}))
+
+  " Processes run with the new jobs api will not run in the foreground
+  if self.backend !=# 'process'
+    let self.background = 1
+  endif
+endfunction
+
+" }}}1
+
+function! s:compiler.build_cmd() abort dict " {{{1
+  let l:cmd = 'latexrun'
+
+  for l:opt in self.options
+    let l:cmd .= ' ' . l:opt
+  endfor
+
+  let l:cmd .= ' --latex-cmd ' . self.get_engine()
+
+  let l:cmd .= ' -O '
+        \ . (empty(self.build_dir) ? '.' : fnameescape(self.build_dir))
+
+  return l:cmd . ' ' . vimtex#util#shellescape(self.target)
+endfunction
+
+" }}}1
+function! s:compiler.get_engine() abort dict " {{{1
+  return get(extend(g:vimtex_compiler_latexrun_engines,
+        \ {
+        \  '_'                : 'pdflatex',
+        \  'pdflatex'         : 'pdflatex',
+        \  'lualatex'         : 'lualatex',
+        \  'xelatex'          : 'xelatex',
+        \ }, 'keep'), self.tex_program, '_')
+endfunction
+
+" }}}1
+function! s:compiler.cleanup() abort dict " {{{1
+  " Pass
+endfunction
+
+" }}}1
+function! s:compiler.pprint_items() abort dict " {{{1
+  let l:configuration = []
+
+  if self.backend ==# 'process'
+    call add(l:configuration, ['background', self.background])
+  endif
+
+  if !empty(self.build_dir)
+    call add(l:configuration, ['build_dir', self.build_dir])
+  endif
+  call add(l:configuration, ['latexrun options', self.options])
+  call add(l:configuration, ['latexrun engine', self.get_engine()])
+
+  let l:list = []
+  call add(l:list, ['backend', self.backend])
+  if self.background
+    call add(l:list, ['output', self.output])
+  endif
+
+  if self.target_path !=# b:vimtex.tex
+    call add(l:list, ['root', self.root])
+    call add(l:list, ['target', self.target_path])
+  endif
+
+  call add(l:list, ['configuration', l:configuration])
+
+  if has_key(self, 'process')
+    call add(l:list, ['process', self.process])
+  endif
+
+  if has_key(self, 'job')
+    call add(l:list, ['cmd', self.cmd])
+  endif
+
+  return l:list
+endfunction
+
+" }}}1
+
+function! s:compiler.clean(...) abort dict " {{{1
+  let l:cmd = (has('win32')
+        \   ? 'cd /D "' . self.root . '" & '
+        \   : 'cd ' . vimtex#util#shellescape(self.root) . '; ')
+        \ . 'latexrun --clean-all'
+        \ . ' -O '
+        \   . (empty(self.build_dir) ? '.' : fnameescape(self.build_dir))
+  call vimtex#process#run(l:cmd)
+
+  call vimtex#log#info('Compiler clean finished')
+endfunction
+
+" }}}1
+function! s:compiler.start(...) abort dict " {{{1
+  call self.exec()
+
+  if self.background
+    call vimtex#log#info('Compiler started in background')
+  else
+    call vimtex#compiler#callback(!vimtex#qf#inquire(self.target))
+  endif
+endfunction
+
+" }}}1
+function! s:compiler.start_single() abort dict " {{{1
+  call self.start()
+endfunction
+
+" }}}1
+function! s:compiler.stop() abort dict " {{{1
+  " Pass
+endfunction
+
+" }}}1
+function! s:compiler.is_running() abort dict " {{{1
+  return 0
+endfunction
+
+" }}}1
+function! s:compiler.kill() abort dict " {{{1
+  " Pass
+endfunction
+
+" }}}1
+function! s:compiler.get_pid() abort dict " {{{1
+  return 0
+endfunction
+
+" }}}1
+
+let s:compiler_process = {}
+function! s:compiler_process.exec() abort dict " {{{1
+  let self.process = vimtex#process#new()
+  let self.process.name = 'latexrun'
+  let self.process.background = self.background
+  let self.process.workdir = self.root
+  let self.process.output = self.output
+  let self.process.cmd = self.build_cmd()
+  call self.process.run()
+endfunction
+
+" }}}1
+
+let s:compiler_jobs = {}
+function! s:compiler_jobs.exec() abort dict " {{{1
+  let self.cmd = self.build_cmd()
+  let l:cmd = has('win32')
+        \ ? 'cmd /s /c "' . self.cmd . '"'
+        \ : ['sh', '-c', self.cmd]
+  let l:options = {
+        \ 'out_io' : 'file',
+        \ 'err_io' : 'file',
+        \ 'out_name' : self.output,
+        \ 'err_name' : self.output,
+        \}
+
+  let s:cb_target = self.target_path !=# b:vimtex.tex ? self.target_path : ''
+  let l:options.exit_cb = function('s:callback')
+
+  call vimtex#paths#pushd(self.root)
+  let self.job = job_start(l:cmd, l:options)
+  call vimtex#paths#popd()
+endfunction
+
+" }}}1
+function! s:callback(ch, msg) abort " {{{1
+  call vimtex#compiler#callback(!vimtex#qf#inquire(s:cb_target))
+endfunction
+
+" }}}1
+
+let s:compiler_nvim = {}
+function! s:compiler_nvim.exec() abort dict " {{{1
+  let self.cmd = self.build_cmd()
+  let l:cmd = has('win32')
+        \ ? 'cmd /s /c "' . self.cmd . '"'
+        \ : ['sh', '-c', self.cmd]
+
+  let l:shell = {
+        \ 'on_stdout' : function('s:callback_nvim_output'),
+        \ 'on_stderr' : function('s:callback_nvim_output'),
+        \ 'on_exit' : function('s:callback_nvim_exit'),
+        \ 'cwd' : self.root,
+        \ 'target' : self.target_path,
+        \ 'output' : self.output,
+        \}
+
+  let self.job = jobstart(l:cmd, l:shell)
+endfunction
+
+" }}}1
+function! s:callback_nvim_output(id, data, event) abort dict " {{{1
+  if !empty(a:data)
+    call writefile(filter(a:data, '!empty(v:val)'), self.output, 'a')
+  endif
+endfunction
+
+" }}}1
+function! s:callback_nvim_exit(id, data, event) abort dict " {{{1
+  let l:target = self.target !=# b:vimtex.tex ? self.target : ''
+  call vimtex#compiler#callback(!vimtex#qf#inquire(l:target))
+endfunction
+
+" }}}1
+
+endif

autoload/vimtex/compiler/tectonic.vim

@@ -0,0 +1,255 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'latex') == -1
+
+" vimtex - LaTeX plugin for Vim
+"
+" Maintainer: Karl Yngve Lervåg
+" Email:      karl.yngve@gmail.com
+"
+
+function! vimtex#compiler#tectonic#init(options) abort " {{{1
+  let l:compiler = deepcopy(s:compiler)
+
+  call l:compiler.init(extend(a:options,
+        \ get(g:, 'vimtex_compiler_tectonic', {}), 'keep'))
+
+  return l:compiler
+endfunction
+
+" }}}1
+
+let s:compiler = {
+      \ 'name' : 'tectonic',
+      \ 'backend' : has('nvim') ? 'nvim'
+      \                         : v:version >= 800 ? 'jobs' : 'process',
+      \ 'root' : '',
+      \ 'target' : '',
+      \ 'target_path' : '',
+      \ 'background' : 1,
+      \ 'build_dir' : '',
+      \ 'output' : tempname(),
+      \ 'options' : [
+      \   '--keep-logs',
+      \   '--synctex'
+      \ ],
+      \}
+
+function! s:compiler.init(options) abort dict " {{{1
+  call extend(self, a:options)
+
+  if !executable('tectonic')
+    call vimtex#log#warning('tectonic is not executable!')
+    throw 'vimtex: Requirements not met'
+  endif
+
+  call extend(self, deepcopy(s:compiler_{self.backend}))
+
+  " Processes run with the new jobs api will not run in the foreground
+  if self.backend !=# 'process'
+    let self.background = 1
+  endif
+endfunction
+
+" }}}1
+
+function! s:compiler.build_cmd() abort dict " {{{1
+  let l:cmd = 'tectonic'
+
+  for l:opt in self.options
+    if l:opt =~# '^-\%(o\|-outdir\)'
+      call vimtex#log#warning("Don't use --outdir or -o in compiler options,"
+            \ . ' use build_dir instead, see :help g:vimtex_compiler_tectonic'
+            \ . ' for more details')
+      continue
+    endif
+
+    let l:cmd .= ' ' . l:opt
+  endfor
+
+  if empty(self.build_dir)
+    let self.build_dir = fnamemodify(self.target_path, ':p:h')
+  elseif !isdirectory(self.build_dir)
+    call vimtex#log#warning(
+          \ "build_dir doesn't exist, it will be created: " . self.build_dir)
+    call mkdir(self.build_dir, 'p')
+  endif
+
+  return l:cmd
+        \ . ' --outdir=' . self.build_dir
+        \ . ' ' . vimtex#util#shellescape(self.target)
+endfunction
+
+" }}}1
+function! s:compiler.cleanup() abort dict " {{{1
+  " Pass
+endfunction
+
+" }}}1
+function! s:compiler.pprint_items() abort dict " {{{1
+  let l:configuration = []
+
+  if self.backend ==# 'process'
+    call add(l:configuration, ['background', self.background])
+  endif
+
+  call add(l:configuration, ['tectonic options', self.options])
+
+  let l:list = []
+  call add(l:list, ['backend', self.backend])
+  if self.background
+    call add(l:list, ['output', self.output])
+  endif
+
+  if self.target_path !=# b:vimtex.tex
+    call add(l:list, ['root', self.root])
+    call add(l:list, ['target', self.target_path])
+  endif
+
+  call add(l:list, ['configuration', l:configuration])
+
+  if has_key(self, 'process')
+    call add(l:list, ['process', self.process])
+  endif
+
+  if has_key(self, 'job')
+    call add(l:list, ['cmd', self.cmd])
+  endif
+
+  return l:list
+endfunction
+
+" }}}1
+
+function! s:compiler.clean(...) abort dict " {{{1
+  let l:files = ['synctex.gz', 'toc', 'out', 'aux', 'log']
+
+  " If a full clean is required
+  if a:0 > 0 && a:1
+    call extend(l:intermediate, ['pdf'])
+  endif
+
+  let l:basename = self.build_dir . '/' . fnamemodify(self.target_path, ':t:r')
+  call map(l:files, 'l:basename . v:val')
+
+  call vimtex#process#run('rm -f ' . join(l:files))
+  call vimtex#log#info('Compiler clean finished')
+endfunction
+
+" }}}1
+function! s:compiler.start(...) abort dict " {{{1
+  call self.exec()
+
+  if self.background
+    call vimtex#log#info('Compiler started in background')
+  else
+    call vimtex#compiler#callback(!vimtex#qf#inquire(self.target))
+  endif
+endfunction
+
+" }}}1
+function! s:compiler.start_single() abort dict " {{{1
+  call self.start()
+endfunction
+
+" }}}1
+function! s:compiler.stop() abort dict " {{{1
+  " Pass
+endfunction
+
+" }}}1
+function! s:compiler.is_running() abort dict " {{{1
+  return 0
+endfunction
+
+" }}}1
+function! s:compiler.kill() abort dict " {{{1
+  " Pass
+endfunction
+
+" }}}1
+function! s:compiler.get_pid() abort dict " {{{1
+  return 0
+endfunction
+
+" }}}1
+
+let s:compiler_process = {}
+function! s:compiler_process.exec() abort dict " {{{1
+  let self.process = vimtex#process#new()
+  let self.process.name = 'tectonic'
+  let self.process.background = self.background
+  let self.process.workdir = self.root
+  let self.process.output = self.output
+  let self.process.cmd = self.build_cmd()
+  call self.process.run()
+endfunction
+
+" }}}1
+
+let s:compiler_jobs = {}
+function! s:compiler_jobs.exec() abort dict " {{{1
+  let self.cmd = self.build_cmd()
+  let l:cmd = has('win32')
+        \ ? 'cmd /s /c "' . self.cmd . '"'
+        \ : ['sh', '-c', self.cmd]
+  let l:options = {
+        \ 'out_io' : 'file',
+        \ 'err_io' : 'file',
+        \ 'out_name' : self.output,
+        \ 'err_name' : self.output,
+        \}
+
+  let s:cb_target = self.target_path !=# b:vimtex.tex ? self.target_path : ''
+  let l:options.exit_cb = function('s:callback')
+
+  if !empty(self.root)
+    let l:save_pwd = getcwd()
+    execute 'lcd' fnameescape(self.root)
+  endif
+  let self.job = job_start(l:cmd, l:options)
+  if !empty(self.root)
+    execute 'lcd' fnameescape(l:save_pwd)
+  endif
+endfunction
+
+" }}}1
+function! s:callback(ch, msg) abort " {{{1
+  call vimtex#compiler#callback(!vimtex#qf#inquire(s:cb_target))
+endfunction
+
+" }}}1
+
+let s:compiler_nvim = {}
+function! s:compiler_nvim.exec() abort dict " {{{1
+  let self.cmd = self.build_cmd()
+  let l:cmd = has('win32')
+        \ ? 'cmd /s /c "' . self.cmd . '"'
+        \ : ['sh', '-c', self.cmd]
+
+  let l:shell = {
+        \ 'on_stdout' : function('s:callback_nvim_output'),
+        \ 'on_stderr' : function('s:callback_nvim_output'),
+        \ 'on_exit' : function('s:callback_nvim_exit'),
+        \ 'cwd' : self.root,
+        \ 'target' : self.target_path,
+        \ 'output' : self.output,
+        \}
+
+  let self.job = jobstart(l:cmd, l:shell)
+endfunction
+
+" }}}1
+function! s:callback_nvim_output(id, data, event) abort dict " {{{1
+  if !empty(a:data)
+    call writefile(filter(a:data, '!empty(v:val)'), self.output, 'a')
+  endif
+endfunction
+
+" }}}1
+function! s:callback_nvim_exit(id, data, event) abort dict " {{{1
+  let l:target = self.target !=# b:vimtex.tex ? self.target : ''
+  call vimtex#compiler#callback(!vimtex#qf#inquire(l:target))
+endfunction
+
+" }}}1
+
+endif