Merge a4379c6305 into 692e359ad9

Fixes #783.

.gitattributes

@@ -1,8 +0,0 @@
-.gitignore export-ignore
-.gitattributes export-ignore
-build export-ignore
-README.md export-ignore
-/spec export-ignore
-Gemfile export-ignore
-Gemfile.lock export-ignore
-.travis.yml export-ignore

.github/ISSUE_TEMPLATE/add-language.md

@@ -0,0 +1,24 @@
+---
+name: Add language
+about: Add support for new language
+title: ''
+labels: 'enhancement'
+assignees: ''
+
+---
+
+**What is the name of this language in Linguist?**
+
+<!-- https://github.com/github/linguist/blob/master/lib/linguist/languages.yml -->
+
+**Link to GitHub repository of Vim plugin**
+
+
+
+**Is this plugin well maintained?**
+
+
+
+**Is this plugin lightweight? (no advanced functionality, just indent and syntax support)**
+
+

.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:**

.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: Vim Polyglot CI
+
+on: 
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 0 * * 0' # weekly
+
+jobs:
+  test:
+    runs-on: ubuntu-latest 
+    steps:
+    - name: Install Vim
+      run: |
+        sudo add-apt-repository ppa:jonathonf/vim -y
+        sudo apt-get update -q
+        sudo apt-get install -y vim expect
+        vim --version
+    - uses: actions/checkout@v2
+    - name: Run Tests
+      run: make test

.gitignore

@@ -1 +1,3 @@
 /tmp
+!*ctags*
+tags

.travis.yml

@@ -1,8 +0,0 @@
-language: ruby
-rvm:
-  - 1.9.3
-before_install: sudo apt-get install vim-gtk
-before_script:
-  - "export DISPLAY=:99.0"
-  - "sh -e /etc/init.d/xvfb start"
-script: bundle exec rspec

Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'vimrunner'
-gem 'rspec'

Gemfile.lock

@@ -1,20 +0,0 @@
-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)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  rspec
-  vimrunner

Makefile

@@ -0,0 +1,10 @@
+.PHONY: build test dev
+
+build:
+	@ scripts/build
+
+test:
+	@ scripts/test
+
+dev:
+	@ find scripts autoload/polyglot ftdetect tests . -type f -maxdepth 1 | DEV=1 entr bash -c 'make'

README.md

@@ -1,88 +1,303 @@
-# vim-polyglot [![Build Status][travis-img-url]][travis-url]
+This is my top-starred repository on Github, so I've decided to put this ad here:
 
-[travis-img-url]: https://travis-ci.org/sheerun/vim-polyglot.png
-[travis-url]: https://travis-ci.org/sheerun/vim-polyglot
+If you work for big corp and seek consulting, please visit following repository: https://github.com/sheerun/consultation
+
+![vim-polyglot](https://i.imgur.com/9RxQK6k.png
 
 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.
+> 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 40x faster** (unparallelized), as language packs are not submoduled, but merged.
-- It clones even faster as all unnecessary files are ignored (like enormous documentation from php support).
-- Best syntax and indentation support. If someone releases better language pack, it will be replaced here.
-- No support for esoteric languages (vim-polyglot supports modern ones like `slim` though).
-- Each build is tested by automated Travis CI setup using vimrunner gem. Spee `spec` directory.
+- It **won't affect your startup time**, as scripts are loaded only on demand\*.
+- It **installs and updates 120+ times faster** than the <!--Package Count-->598<!--/Package Count--> packages it consists of.
+- It is also more secure (scripts loaded for every filetype are generated by vim-polyglot)
+- Best syntax and indentation support (no other features). Hand-selected language packs.
+- Automatically detects indentation (includes performance-optimized version of [vim-sleuth](https://github.com/tpope/vim-sleuth), can be disabled)
 
-\*To be completely honest, concatenated `ftdetect` script takes around `3ms` to load.
+\*To be completely honest, optimized `ftdetect` script takes around `10ms` to load.
 
 ## Installation
 
-1. Install pathogen, Vundle or NeoBundle package manager.
+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) (which I recommend):
+
+```vim
+set nocompatible
+
+call plug#begin()
+
+Plug 'sheerun/vim-polyglot'
+
+call plug#end()
+```
+
 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:
+
+```
+git clone --depth 1 https://github.com/sheerun/vim-polyglot ~/.vim/pack/plugins/start/vim-polyglot
+```
+
 ## Language packs
 
-- [arduino](https://github.com/sudar/vim-arduino-syntax) (syntax, ftdetect)
-- [c++11](https://github.com/octol/vim-cpp-enhanced-highlight) (syntax)
-- [c/c++](https://github.com/vim-jp/cpp-vim) (syntax)
-- [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)
-- [css-color](https://github.com/ap/vim-css-color) (syntax)
-- [csv](https://github.com/chrisbra/csv.vim) (syntax, ftplugin, ftdetect)
-- [cucumber](https://github.com/tpope/vim-cucumber) (syntax, indent, compiler, ftplugin, ftdetect)
-- [dockerfile](https://github.com/honza/dockerfile.vim) (syntax, ftdetect)
-- [elixir](https://github.com/elixir-lang/vim-elixir) (syntax, indent, compiler, ftplugin, ftdetect)
-- [erlang](https://github.com/oscarh/vimerl) (syntax, indent, compiler, autoload, ftplugin)
-- [git](https://github.com/tpope/vim-git) (syntax, indent, ftplugin, ftdetect)
-- [go](https://github.com/jnwhiteh/vim-golang) (syntax, indent, autoload, ftplugin, ftdetect)
-- [haml](https://github.com/tpope/vim-haml) (syntax, indent, compiler, ftplugin, ftdetect)
-- [handlebars](https://github.com/nono/vim-handlebars) (syntax, ftplugin, ftdetect)
-- [haskell](https://github.com/travitch/hasksyn) (syntax, indent, ftplugin)
-- [html5](https://github.com/othree/html5.vim) (syntax, indent, autoload)
-- [jade](https://github.com/digitaltoad/vim-jade) (syntax, indent, ftplugin, ftdetect)
-- [javascript](https://github.com/pangloss/vim-javascript) (syntax, indent, ftdetect)
-- [json](https://github.com/leshill/vim-json) (syntax, ftdetect)
-- [jst](https://github.com/briancollins/vim-jst) (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)
-- [markdown](https://github.com/tpope/vim-markdown) (syntax, ftplugin, ftdetect)
-- [nginx](https://github.com/mutewinter/nginx.vim) (syntax, ftdetect)
-- [ocaml](https://github.com/jrk/vim-ocaml) (syntax, indent, ftplugin)
-- [octave](https://github.com/vim-scripts/octave.vim--) (syntax)
-- [perl](https://github.com/vim-perl/vim-perl) (syntax, indent, ftplugin)
-- [php](https://github.com/StanAngeloff/php.vim) (syntax)
-- [puppet](https://github.com/ajf/puppet-vim) (syntax, indent, ftplugin, ftdetect)
-- [protobuf](https://github.com/uarun/vim-protobuf) (syntax, ftdetect)
-- [python](https://github.com/vim-scripts/python.vim--Vasiliev) (syntax)
-- [r-lang](https://github.com/vim-scripts/R.vim) (syntax, ftplugin)
-- [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/wting/rust.vim) (syntax, indent, compiler, ftplugin, ftdetect)
-- [sbt](https://github.com/derekwyatt/vim-sbt) (syntax, ftdetect)
-- [scala](https://github.com/derekwyatt/vim-scala) (syntax, indent, ftplugin, ftdetect)
-- [slim](https://github.com/slim-template/vim-slim) (syntax, indent, ftdetect)
-- [stylus](https://github.com/wavded/vim-stylus) (syntax, indent, ftplugin, ftdetect)
-- [textile](https://github.com/timcharper/textile.vim) (syntax, ftplugin, ftdetect)
-- [tmux](https://github.com/acustodioo/vim-tmux) (syntax, ftdetect)
-- [tomdoc](https://github.com/duwanis/tomdoc.vim) (syntax)
-- [typescript](https://github.com/leafgarland/typescript-vim) (syntax, compiler, ftplugin, ftdetect)
-- [vbnet](https://github.com/vim-scripts/vbnet.vim) (syntax)
-- [twig](https://github.com/beyondwords/vim-twig) (syntax, ftplugin, ftdetect)
-- [xls](https://github.com/vim-scripts/XSLT-syntax) (syntax)
+On top of all language packs from [vim repository](https://github.com/vim/vim/tree/master/runtime/syntax), vim-polyglot includes:
+
+<!--Language Packs-->
+- [acpiasl](https://github.com/martinlroth/vim-acpi-asl) (Syntax highlighting for asl and dsl files)
+- [ansible](https://github.com/pearofducks/ansible-vim)
+- [apiblueprint](https://github.com/kylef/apiblueprint.vim) (API Blueprint syntax highlighting for apib files)
+- [applescript](https://github.com/mityu/vim-applescript) (AppleScript syntax highlighting for applescript and scpt files)
+- [arduino](https://github.com/sudar/vim-arduino-syntax) (Processing syntax highlighting for pde and ino files)
+- [asciidoc](https://github.com/asciidoc/vim-asciidoc) (AsciiDoc syntax highlighting for asciidoc, adoc and asc files)
+- [autohotkey](https://github.com/hnamikaw/vim-autohotkey) (AutoHotkey syntax highlighting for ahk and ahkl files)
+- [bicep](https://github.com/carlsmedstad/vim-bicep) (Syntax highlighting for bicep files)
+- [blade](https://github.com/jwalton512/vim-blade) (Blade syntax highlighting for blade and blade.php files)
+- [brewfile](https://github.com/bfontaine/Brewfile.vim)
+- [c/c++](https://github.com/vim-jp/vim-cpp) (C++ and C syntax highlighting for cpp, c++, cc, cp, cxx and 18 more files)
+- [caddyfile](https://github.com/isobit/vim-caddyfile)
+- [carp](https://github.com/hellerve/carp-vim) (Syntax highlighting for carp files)
+- [cjsx](https://github.com/mtscout6/vim-cjsx)
+- [clojure](https://github.com/clojure-vim/clojure.vim) (Clojure syntax highlighting for clj, bb, boot, cl2, cljc and 6 more files)
+- [cmake](https://github.com/pboettch/vim-cmake-syntax) (CMake syntax highlighting for cmake and cmake.in files)
+- [coffee-script](https://github.com/kchmck/vim-coffee-script) (CoffeeScript and Literate CoffeeScript syntax highlighting for coffee, cake, cjsx, iced, coffeekup, cson, litcoffee and coffee.md files)
+- [cpp-modern](https://github.com/bfrg/vim-cpp-modern)
+- [cql](https://github.com/elubow/cql-vim) (Syntax highlighting for cql files)
+- [cryptol](https://github.com/victoredwardocallaghan/cryptol.vim) (Syntax highlighting for cry, cyl, lcry and lcyl files)
+- [crystal](https://github.com/rhysd/vim-crystal) (Crystal and HTML+ECR syntax highlighting for cr and ecr files)
+- [csv](https://github.com/chrisbra/csv.vim) (CSV syntax highlighting for csv, tsv and tab files)
+- [cucumber](https://github.com/tpope/vim-cucumber) (Gherkin syntax highlighting for feature and story files)
+- [cue](https://github.com/mgrabovsky/vim-cuesheet) (Syntax highlighting for cue files)
+- [dart](https://github.com/dart-lang/dart-vim-plugin) (Dart syntax highlighting for dart and drt files)
+- [dhall](https://github.com/vmchale/dhall-vim) (Dhall syntax highlighting for dhall files)
+- [dlang](https://github.com/JesseKPhillips/d.vim) (D syntax highlighting for d, di, lst, dd, ddoc and sdl files)
+- [docker-compose](https://github.com/ekalinin/Dockerfile.vim)
+- [elixir](https://github.com/elixir-lang/vim-elixir) (Elixir and HTML+EEX syntax highlighting for ex, exs, eex, html.heex, html.leex and leex files)
+- [elm](https://github.com/andys8/vim-elm-syntax) (Elm syntax highlighting for elm files)
+- [emberscript](https://github.com/yalesov/vim-ember-script) (EmberScript syntax highlighting for em and emberscript files)
+- [emblem](https://github.com/yalesov/vim-emblem) (Syntax highlighting for emblem and em files)
+- [erlang](https://github.com/vim-erlang/vim-erlang-runtime) (Erlang syntax highlighting for erl, app.src, es, escript, hrl, xrl, yrl, app and yaws files)
+- [fennel](https://github.com/bakpakin/fennel.vim) (Syntax highlighting for fnl files)
+- [ferm](https://github.com/vim-scripts/ferm.vim) (Syntax highlighting for ferm files)
+- [fish](https://github.com/blankname/vim-fish) (fish syntax highlighting for fish files)
+- [flatbuffers](https://github.com/dcharbon/vim-flatbuffers) (Syntax highlighting for fbs files)
+- [fsharp](https://github.com/ionide/Ionide-vim) (F# syntax highlighting for fs, fsi and fsx files)
+- [git](https://github.com/tpope/vim-git) (Git Config syntax highlighting for gitconfig files)
+- [gitignore](https://github.com/SirJson/fzf-gitignore)
+- [gleam](https://github.com/gleam-lang/gleam.vim) (Syntax highlighting for gleam files)
+- [glsl](https://github.com/tikhomirov/vim-glsl) (GLSL syntax highlighting for glsl, fp, frag, frg, fs and 18 more files)
+- [gmpl](https://github.com/maelvalais/gmpl.vim) (Syntax highlighting for mod files)
+- [gnuplot](https://github.com/vim-scripts/gnuplot-syntax-highlighting) (Gnuplot syntax highlighting for gp, gnu, gnuplot, p, plot, plt and gpi files)
+- [go](https://github.com/fatih/vim-go) (Go syntax highlighting for go and tmpl files)
+- [gradle](https://github.com/tfnico/vim-gradle)
+- [graphql](https://github.com/jparise/vim-graphql) (GraphQL syntax highlighting for graphql, gql and graphqls files)
+- [haml](https://github.com/tpope/vim-haml) (Haml syntax highlighting for haml, haml.deface, hamlc and hamlbars files)
+- [handlebars](https://github.com/mustache/vim-mustache-handlebars) (Mustache and Handlebars syntax highlighting for mustache, hogan, hulk, hjs, handlebars, hbs, hdbs and hb files)
+- [haproxy](https://github.com/CH-DanReif/haproxy.vim) (HAProxy syntax highlighting)
+- [haskell](https://github.com/neovimhaskell/haskell-vim) (Haskell syntax highlighting for hs, hs-boot, hsc, bpk and hsig files)
+- [haxe](https://github.com/jdonaldson/vaxe) (Haxe and HXML syntax highlighting for hx, hxsl, hxml and hss files)
+- [helm](https://github.com/towolf/vim-helm)
+- [help](https://github.com/neovim/neovim/tree/master/runtime)
+- [hive](https://github.com/zebradil/hive.vim) (HiveQL syntax highlighting for q, hql and ql files)
+- [hjson](https://github.com/hjson/vim-hjson) (Syntax highlighting for hjson files)
+- [html5](https://github.com/othree/html5.vim)
+- [icalendar](https://github.com/chutzpah/icalendar.vim) (Syntax highlighting for ics files)
+- [idris2](https://github.com/edwinb/idris2-vim) (Syntax highlighting for idr, ipkg and lidr files)
+- [idris](https://github.com/idris-hackers/idris-vim) (Idris syntax highlighting for idr and lidr files)
+- [ion](https://github.com/vmchale/ion-vim) (Syntax highlighting for ion files)
+- [javascript-sql](https://github.com/statico/vim-javascript-sql)
+- [javascript](https://github.com/pangloss/vim-javascript) (JavaScript syntax highlighting for js, bones, cjs, es, es6 and 20 more files)
+- [jenkins](https://github.com/martinda/Jenkinsfile-vim-syntax) (Syntax highlighting for jenkinsfile and Jenkinsfile files)
+- [jq](https://github.com/vito-c/jq.vim) (JSONiq syntax highlighting for jq files)
+- [json5](https://github.com/GutenYe/json5.vim) (JSON5 syntax highlighting for json5 files)
+- [json](https://github.com/elzr/vim-json) (JSON syntax highlighting for json, 4DForm, 4DProject, avsc, geojson and 15 more files)
+- [jsonc](https://github.com/neoclide/jsonc.vim) (Syntax highlighting for cjson and jsonc files)
+- [jsonnet](https://github.com/google/vim-jsonnet) (Jsonnet syntax highlighting for jsonnet and libsonnet files)
+- [jst](https://github.com/briancollins/vim-jst) (EJS syntax highlighting for ejs, ect, ejs.t and jst files)
+- [jsx](https://github.com/MaxMEllon/vim-jsx-pretty) (Syntax highlighting for jsx files)
+- [julia](https://github.com/JuliaEditorSupport/julia-vim) (Julia syntax highlighting for jl files)
+- [just](https://github.com/NoahTheDuke/vim-just) (Syntax highlighting for just files)
+- [kotlin](https://github.com/udalov/kotlin-vim) (Kotlin syntax highlighting for kt, ktm and kts files)
+- [ledger](https://github.com/ledger/vim-ledger) (Syntax highlighting for ldg, ledger and journal files)
+- [lilypond](https://github.com/anowlcalledjosh/vim-lilypond/tree/main) (LilyPond syntax highlighting for ly and ily files)
+- [livescript](https://github.com/gkz/vim-ls) (LiveScript syntax highlighting for ls files)
+- [llvm](https://github.com/rhysd/vim-llvm) (LLVM syntax highlighting for ll and td files)
+- [log](https://github.com/MTDL9/vim-log-highlighting) (Syntax highlighting for log and LOG files)
+- [lua](https://github.com/tbastos/vim-lua) (Lua syntax highlighting for lua, fcgi, nse, p8, rbxs, rockspec and wlua files)
+- [mako](https://github.com/sophacles/vim-bundle-mako) (Mako syntax highlighting for mako and mao files)
+- [markdown](https://github.com/plasticboy/vim-markdown) (Markdown syntax highlighting for md, livemd, markdown, mdown, mdwn and 6 more files)
+- [mathematica](https://github.com/voldikss/vim-mma) (Mathematica syntax highlighting for mathematica, cdf, m, ma, mt and 6 more files)
+- [mdx](https://github.com/jxnblk/vim-mdx-js) (Syntax highlighting for mdx files)
+- [mermaid](https://github.com/mracos/mermaid.vim/tree/main) (Syntax highlighting for mermaid, mm and mmd files)
+- [meson](https://github.com/mesonbuild/meson/tree/master/data/syntax-highlighting/vim) (Meson syntax highlighting for wrap files)
+- [mint](https://github.com/IrenejMarc/vim-mint) (Syntax highlighting for mint files)
+- [moonscript](https://github.com/leafo/moonscript-vim) (MoonScript syntax highlighting for moon files)
+- [nftables](https://github.com/nfnty/vim-nftables) (Syntax highlighting for nft files)
+- [nginx](https://github.com/chr4/nginx.vim) (Nginx syntax highlighting for nginx, nginxconf and vhost files)
+- [nim](https://github.com/zah/nim.vim) (Nim syntax highlighting for nim, nim.cfg, nimble, nimrod and nims files)
+- [nix](https://github.com/LnL7/vim-nix) (Nix syntax highlighting for nix files)
+- [objc](https://github.com/b4winckler/vim-objc) (Objective-C syntax highlighting for m and h files)
+- [ocaml](https://github.com/rgrinberg/vim-ocaml) (OCaml syntax highlighting for ml, eliom, eliomi, ml4, mli and 13 more files)
+- [octave](https://github.com/McSinyx/vim-octave) (Syntax highlighting for oct and m files)
+- [odin](https://github.com/Tetralux/odin.vim) (Odin syntax highlighting for odin files)
+- [opencl](https://github.com/petRUShka/vim-opencl) (OpenCL syntax highlighting for cl and opencl files)
+- [openscad](https://github.com/sirtaj/vim-openscad) (Syntax highlighting for scad files)
+- [org](https://github.com/axvr/org.vim) (Syntax highlighting for org files)
+- [perl](https://github.com/vim-perl/vim-perl) (Perl syntax highlighting for pl, al, cgi, fcgi, perl and 12 more files)
+- [pest](https://github.com/pest-parser/pest.vim) (Syntax highlighting for pest files)
+- [pgsql](https://github.com/lifepillar/pgsql.vim) (PLpgSQL syntax highlighting for pgsql files)
+- [php](https://github.com/StanAngeloff/php.vim) (PHP syntax highlighting for php, aw, ctp, fcgi, inc and 7 more files)
+- [plantuml](https://github.com/aklt/plantuml-syntax) (PlantUML syntax highlighting for puml, iuml, plantuml, uml and pu files)
+- [pony](https://github.com/jakwings/vim-pony) (Pony syntax highlighting for pony files)
+- [powershell](https://github.com/PProvost/vim-ps1) (PowerShell syntax highlighting for ps1, psd1, psm1, pssc and ps1xml files)
+- [protobuf](https://github.com/uarun/vim-protobuf) (Protocol Buffer syntax highlighting for proto files)
+- [pug](https://github.com/digitaltoad/vim-pug) (Pug syntax highlighting for jade and pug files)
+- [puppet](https://github.com/rodjek/vim-puppet) (Puppet syntax highlighting for pp and epp files)
+- [purescript](https://github.com/purescript-contrib/purescript-vim) (PureScript syntax highlighting for purs files)
+- [python-compiler](https://github.com/aliev/vim-compiler-python)
+- [python-indent](https://github.com/Vimjas/vim-python-pep8-indent)
+- [python](https://github.com/vim-python/python-syntax) (Python syntax highlighting for py, cgi, fcgi, gyp, gypi and 14 more files)
+- [qmake](https://github.com/artoj/qmake-syntax-vim) (QMake syntax highlighting for pro and pri files)
+- [qml](https://github.com/peterhoeg/vim-qml) (QML syntax highlighting for qml and qbs files)
+- [r-lang](https://github.com/vim-scripts/R.vim) (R syntax highlighting for r, rsx, s, S and rd files)
+- [racket](https://github.com/wlangstroth/vim-racket) (Racket syntax highlighting for rkt, rktd, rktl and scrbl files)
+- [ragel](https://github.com/jneen/ragel.vim) (Ragel syntax highlighting for rl files)
+- [raku](https://github.com/Raku/vim-raku) (Raku syntax highlighting for 6pl, 6pm, nqp, p6, p6l and 12 more files)
+- [raml](https://github.com/IN3D/vim-raml) (RAML syntax highlighting for raml files)
+- [razor](https://github.com/adamclerk/vim-razor) (HTML+Razor syntax highlighting for cshtml and razor files)
+- [reason](https://github.com/reasonml-editor/vim-reason-plus) (Reason syntax highlighting for re and rei files)
+- [requirements](https://github.com/raimon49/requirements.txt.vim) (Syntax highlighting for pip files)
+- [rspec](https://github.com/keith/rspec.vim)
+- [rst](https://github.com/marshallward/vim-restructuredtext) (reStructuredText syntax highlighting for rst, rest, rest.txt and rst.txt files)
+- [ruby](https://github.com/vim-ruby/vim-ruby) (Ruby and HTML+ERB syntax highlighting for rb, builder, eye, fcgi, gemspec and 26 more files)
+- [rust](https://github.com/rust-lang/rust.vim) (Rust syntax highlighting for rs and rs.in files)
+- [scala](https://github.com/derekwyatt/vim-scala) (Scala syntax highlighting for scala, kojo and sc files)
+- [scss](https://github.com/cakebaker/scss-syntax.vim) (SCSS syntax highlighting for scss files)
+- [sh](https://github.com/arzg/vim-sh) (Shell syntax highlighting for sh, bash, bats, cgi, command and 8 more files)
+- [slim](https://github.com/slim-template/vim-slim) (Slim syntax highlighting for slim files)
+- [slime](https://github.com/slime-lang/vim-slime-syntax) (Syntax highlighting for slime files)
+- [smt2](https://github.com/bohlender/vim-smt2) (SMT syntax highlighting for smt2 and smt files)
+- [solidity](https://github.com/TovarishFin/vim-solidity) (Solidity syntax highlighting for sol files)
+- [stylus](https://github.com/wavded/vim-stylus) (Stylus syntax highlighting for styl and stylus files)
+- [svelte](https://github.com/leafOfTree/vim-svelte-plugin) (Svelte syntax highlighting for svelte files)
+- [svg-indent](https://github.com/jasonshell/vim-svg-indent)
+- [svg](https://github.com/vim-scripts/svg.vim) (SVG syntax highlighting for svg files)
+- [sway](https://github.com/jamespeapen/swayconfig.vim) (Syntax highlighting for swayconfig and sway.config files)
+- [swift](https://github.com/keith/swift.vim) (Swift syntax highlighting for swift files)
+- [sxhkd](https://github.com/baskerville/vim-sxhkdrc) (Syntax highlighting for sxhkdrc files)
+- [systemd](https://github.com/wgwoods/vim-systemd-syntax) (Syntax highlighting for automount, dnssd, link, mount, netdev and 9 more files)
+- [terraform](https://github.com/hashivim/vim-terraform) (HCL syntax highlighting for tf, tfvars, hcl, nomad and workflow files)
+- [textile](https://github.com/timcharper/textile.vim) (Textile syntax highlighting for textile files)
+- [thrift](https://github.com/solarnz/thrift.vim) (Thrift syntax highlighting for thrift files)
+- [tmux](https://github.com/ericpruitt/tmux.vim/tree/master/vim)
+- [toml](https://github.com/cespare/vim-toml/tree/main) (TOML syntax highlighting for toml files)
+- [tptp](https://github.com/c-cube/vim-tptp) (Syntax highlighting for p, tptp and ax files)
+- [twig](https://github.com/lumiliet/vim-twig) (Twig syntax highlighting for twig and xml.twig files)
+- [typescript](https://github.com/HerringtonDarkholme/yats.vim) (TypeScript and TSX syntax highlighting for ts, cts, mts and tsx files)
+- [unison](https://github.com/unisonweb/unison/tree/trunk/editor-support/vim) (Syntax highlighting for u and uu files)
+- [v](https://github.com/ollykel/v-vim) (V syntax highlighting for v, vv and vsh files)
+- [vala](https://github.com/arrufat/vala.vim) (Vala syntax highlighting for vala, vapi and valadoc files)
+- [vbnet](https://github.com/vim-scripts/vbnet.vim) (Visual Basic .NET syntax highlighting for vb and vbhtml files)
+- [vcl](https://github.com/smerrill/vcl-vim-plugin) (VCL syntax highlighting for vcl files)
+- [velocity](https://github.com/lepture/vim-velocity) (Syntax highlighting for vm files)
+- [vue](https://github.com/posva/vim-vue) (Vue syntax highlighting for vue and wpy files)
+- [xdc](https://github.com/amal-khailtash/vim-xdc-syntax) (Syntax highlighting for xdc files)
+- [xml](https://github.com/amadeus/vim-xml) (XML syntax highlighting for xml, adml, admx, ant, axaml and 97 more files)
+- [xsl](https://github.com/vim-scripts/XSLT-syntax) (XSLT syntax highlighting for xslt and xsl files)
+- [yard](https://github.com/noprompt/vim-yardoc)
+- [zephir](https://github.com/xwsoul/vim-zephir) (Zephir syntax highlighting for zep files)
+- [zig](https://github.com/ziglang/zig.vim) (Zig syntax highlighting for zir, zig and zir files)
+- [zinit](https://github.com/zdharma-continuum/zinit-vim-syntax/tree/main)
+<!--/Language Packs-->
+
+## Updating
+
+You can either wait for new patch release with updates or run `make` by yourself.
+
+## Troubleshooting
+
+Please make sure you have `set nocompatible` in your `.vimrc` (or use something like [sheerun/vimrc](https://github.com/sheerun/vimrc))
+
+Individual language packs can be disabled by setting `g:polyglot_disabled` as follows:
+
+**Please declare this variable before polyglot is loaded (at the top of .vimrc)**
+
+```vim
+let g:polyglot_disabled = ['markdown']
+```
+
+The list of available languages to disable is shown above.
+
+If you wish to use filetype detection by Vim Polyglot but you'd like to use your own syntax-highlighting plugin, you can append `.plugin` to disabled entry, like below. Disabling Vim Polyglot filetype plugin won't disable native Vim filetype plugin.
+
+```vim
+let g:polyglot_disabled = ['markdown.plugin']
+```
+
+Please note that disabling a language won't make in your vim startup any faster / slower (only for specific this specific filetype). All plugins are lazily loaded only when they are really needed. 
+
+## Autoindent
+
+Vim Polyglot tries to automatically detect indentation settings (just like vim-sleuth). If this feature is not working for you for some reason, please file an issue and disable it temporarily with:
+
+```vim
+let g:polyglot_disabled = ['autoindent']
+```
+
+## Reindent
+
+If you want to disable reindenting of the current line in insert mode (see vim 'indentkeys') you can turn it off with:
+
+```vim
+autocmd BufEnter * set indentexpr=
+```
+
+This will not affect smart autoindenting when starting a new line.
+
+
+## Default settings
+
+Vim Polyglot sets defaults of some settings that are relevant for good language support. You can disable them by:
+
+
+```vim
+let g:polyglot_disabled = ['sensible']
+```
+
+These defaults include:
+- Use utf-8 encoding by default
+- Automatically reload file if changed somewhere else
+- Disable existing swapfile warnings, instead just create multiple swapfiles
+- Don't create swapfiles in current directory, instead in data directory
+- Whitespace characters when using `:set list`
+- Delete comment character when joining commented lines
+- Search upwards for tags file(s) instead only locally
+- Fix issues with fish shell
+- Increase history size to 1000 items
+- Allow for up to 50 opened tabs on Vim start.
+- Reduce updatetime from 4000 to 300 to avoid issues with coc.nvim
+- Always save upper case variables to viminfo file
+- Don't save options in sessions and views
+- Allow color schemes to do bright colors without forcing bold
+- Load vim's built-in matchit plugin
+
+## No ftdetect
+
+If you want to use vim-polyglot plugins, but not ftdetect autocommands, the you can disable it as so:
+
+
+```vim
+let g:polyglot_disabled = ['ftdetect']
+```
 
 ## Contributing
 
-Language packs are periodically updated using automated `build` script.
+Language packs are periodically updated using automated `scripts/build` script.
 
-Feel free to add your language, and send pull-request.
+Feel free to add your language to `packages.yaml` + `heuristics.yaml`, and send pull-request. You can run `make test` to run rough tests. And `make dev` for easy development.
 
 ## License
 
-See linked repositories for detailed license information.
-
-
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/sheerun/vim-polyglot/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
-
+See linked repositories for detailed license information. This repository is MIT-licensed.

after/compiler/tex.vim

@@ -0,0 +1,71 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'tex', 'after/compiler/tex.vim')
+  finish
+endif
+
+" Vim compiler file
+" Compiler:     TeX
+" Maintainer:   Artem Chuprina <ran@ran.pp.ru>
+" Last Change:  2012 Apr 30
+
+if exists("current_compiler")
+	finish
+endif
+let s:keepcpo= &cpo
+set cpo&vim
+
+if exists(":CompilerSet") != 2		" older Vim always used :setlocal
+  command -nargs=* CompilerSet setlocal <args>
+endif
+
+" If makefile exists and we are not asked to ignore it, we use standard make
+" (do not redefine makeprg)
+if exists('b:tex_ignore_makefile') || exists('g:tex_ignore_makefile') ||
+			\(!filereadable('Makefile') && !filereadable('makefile'))
+	" If buffer-local variable 'tex_flavor' exists, it defines TeX flavor,
+	" otherwise the same for global variable with same name, else it will be
+	" LaTeX
+	if exists("b:tex_flavor")
+		let current_compiler = b:tex_flavor
+	elseif exists("g:tex_flavor")
+		let current_compiler = g:tex_flavor
+	else
+		let current_compiler = "latex"
+	endif
+	let &l:makeprg=current_compiler.' -interaction=nonstopmode'
+else
+	let current_compiler = 'make'
+endif
+
+" Value errorformat are taken from vim help, see :help errorformat-LaTeX, with
+" addition from Srinath Avadhanula <srinath@fastmail.fm>
+CompilerSet errorformat=%E!\ LaTeX\ %trror:\ %m,
+	\%E!\ %m,
+	\%+WLaTeX\ %.%#Warning:\ %.%#line\ %l%.%#,
+	\%+W%.%#\ at\ lines\ %l--%*\\d,
+	\%WLaTeX\ %.%#Warning:\ %m,
+	\%Cl.%l\ %m,
+	\%+C\ \ %m.,
+	\%+C%.%#-%.%#,
+	\%+C%.%#[]%.%#,
+	\%+C[]%.%#,
+	\%+C%.%#%[{}\\]%.%#,
+	\%+C<%.%#>%.%#,
+	\%C\ \ %m,
+	\%-GSee\ the\ LaTeX%m,
+	\%-GType\ \ H\ <return>%m,
+	\%-G\ ...%.%#,
+	\%-G%.%#\ (C)\ %.%#,
+	\%-G(see\ the\ transcript%.%#),
+	\%-G\\s%#,
+	\%+O(%*[^()])%r,
+	\%+O%*[^()](%*[^()])%r,
+	\%+P(%f%r,
+	\%+P\ %\\=(%f%r,
+	\%+P%*[^()](%f%r,
+	\%+P[%\\d%[^()]%#(%f%r,
+	\%+Q)%r,
+	\%+Q%*[^()])%r,
+	\%+Q[%\\d%*[^()])%r
+
+let &cpo = s:keepcpo
+unlet s:keepcpo

after/ftdetect/rspec.vim

@@ -1,2 +0,0 @@
-autocmd BufReadPost,BufNewFile *_spec.rb set syntax=rspec
-autocmd BufReadPost,BufNewFile *_spec.rb setlocal commentstring=#\ %s

after/ftplugin/cabal.vim

@@ -0,0 +1,7 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'haskell', 'after/ftplugin/cabal.vim')
+  finish
+endif
+
+setlocal comments=s1fl:{-,mb:-,ex:-},:--
+setlocal iskeyword+=-,.,*
+setlocal commentstring=--\ %s

after/ftplugin/coffee.vim

@@ -0,0 +1,9 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'cjsx', 'after/ftplugin/coffee.vim')
+  finish
+endif
+
+if exists("loaded_matchit")
+  let b:match_ignorecase = 0
+  let b:match_words = '(:),\[:\],{:},<:>,' .
+    \ '<\@<=\([^/][^ \t>]*\)[^>]*\%(>\|$\):<\@<=/\1>'
+endif

after/ftplugin/haskell.vim

@@ -1,9 +1,6 @@
-" Vim ftplugin file
-" Language: Haskell
-" Maintainer: Tristan Ravitch
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'haskell', 'after/ftplugin/haskell.vim')
+  finish
+endif
 
-" I don't fully understand what the vim-default ftplugin does, but I do know
-" that the three-part comment entry really messes up this indenter (I also
-" hate the leading '-'s it puts in on each line).  Disable it here.
-setlocal comments&
-setlocal comments=:--
+setlocal comments=s1fl:{-,mb:\ \ ,ex:-},:--
+setlocal iskeyword+='

after/ftplugin/idris.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'idris', 'after/ftplugin/idris.vim')
+  finish
+endif
+
+setlocal iskeyword+='

after/ftplugin/idris2.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'idris2', 'after/ftplugin/idris2.vim')
+  finish
+endif
+
+setlocal iskeyword+='

after/ftplugin/javascript-1.vim

@@ -0,0 +1,16 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'javascript', 'after/ftplugin/javascript.vim')
+  finish
+endif
+
+" 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

after/ftplugin/javascript-2.vim

@@ -0,0 +1,9 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/ftplugin/javascript-2.vim')
+  finish
+endif
+
+if get(g:, 'vim_jsx_pretty_disable_js', 0)
+  finish
+endif
+
+source <sfile>:h/jsx.vim

after/ftplugin/javascript.vim

@@ -0,0 +1,3 @@
+" Polyglot metafile
+source <sfile>:h/javascript-1.vim
+source <sfile>:h/javascript-2.vim

after/ftplugin/javascriptreact.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/ftplugin/javascriptreact.vim')
+  finish
+endif
+
+source <sfile>:h/jsx.vim

after/ftplugin/jsx.vim

@@ -0,0 +1,35 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/ftplugin/jsx.vim')
+  finish
+endif
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" 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 = '(:),\[:\],{:},<:>,' .
+        \ '<\@<=\([A-z0-9.]\+\):\(</\)\@<=\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

after/ftplugin/just.vim

@@ -0,0 +1,11 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'just', 'after/ftplugin/just.vim')
+  finish
+endif
+
+" Vim ftplugin file
+" Language:	Justfile
+" Maintainer:	Noah Bogart <noah.bogart@hey.com>
+" URL:		https://github.com/NoahTheDuke/vim-just.git
+" Last Change:	2021 May 19
+
+setlocal iskeyword+=-

after/ftplugin/llvm.vim

@@ -0,0 +1,493 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'llvm', 'after/ftplugin/llvm.vim')
+  finish
+endif
+
+" 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}
+    try
+        let bufnr = term_start([g:llvm_ext_lli_executable, tmpfile], {'close_cb': Cleanup, 'exit_cb': Cleanup})
+        echo 'Run lli in termnal buffer(' . bufnr . ')'
+    catch
+        if filereadable(tmpfile)
+            delete(tmpfile)
+        endif
+    endtry
+endfunction
+
+if !exists(':LLI')
+    command! -buffer -nargs=? -bar -complete=file LLI call <SID>run_lli(<f-args>)
+endif

after/ftplugin/puppet.vim

@@ -0,0 +1,11 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'puppet', 'after/ftplugin/puppet.vim')
+  finish
+endif
+
+if !exists('g:puppet_align_hashes')
+    let g:puppet_align_hashes = 1
+endif
+
+if g:puppet_align_hashes
+    inoremap <buffer> <silent> => =><Esc>:call puppet#align#AlignHashrockets()<CR>$a
+endif

after/ftplugin/tex.vim

@@ -0,0 +1,50 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'tex', 'after/ftplugin/tex.vim')
+  finish
+endif
+
+" LaTeX filetype plugin
+" Language:     LaTeX (ft=tex)
+" Maintainer:   Benji Fisher, Ph.D. <benji@member.AMS.org>
+" Version:	1.4
+" Last Change:	Wed 19 Apr 2006
+"  URL:		http://www.vim.org/script.php?script_id=411
+
+" Only do this when not done yet for this buffer.
+if exists("b:did_ftplugin")
+  finish
+endif
+
+" Start with plain TeX.  This will also define b:did_ftplugin .
+source $VIMRUNTIME/ftplugin/plaintex.vim
+
+" Avoid problems if running in 'compatible' mode.
+let s:save_cpo = &cpo
+set cpo&vim
+
+let b:undo_ftplugin .= "| setl inex<"
+
+" Allow "[d" to be used to find a macro definition:
+" Recognize plain TeX \def as well as LaTeX \newcommand and \renewcommand .
+" I may as well add the AMS-LaTeX DeclareMathOperator as well.
+let &l:define .= '\|\\\(re\)\=new\(boolean\|command\|counter\|environment\|font'
+	\ . '\|if\|length\|savebox\|theorem\(style\)\=\)\s*\*\=\s*{\='
+	\ . '\|DeclareMathOperator\s*{\=\s*'
+
+" Tell Vim how to recognize LaTeX \include{foo} and plain \input bar :
+let &l:include .= '\|\\include{'
+" On some file systems, "{" and "}" are included in 'isfname'.  In case the
+" TeX file has \include{fname} (LaTeX only), strip everything except "fname".
+let &l:includeexpr = "substitute(v:fname, '^.\\{-}{\\|}.*', '', 'g')"
+
+" The following lines enable the macros/matchit.vim plugin for
+" extended matching with the % key.
+" ftplugin/plaintex.vim already defines b:match_skip and b:match_ignorecase
+" and matches \(, \), \[, \], \{, and \} .
+if exists("loaded_matchit")
+  let b:match_words .= ',\\begin\s*\({\a\+\*\=}\):\\end\s*\1'
+endif " exists("loaded_matchit")
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim:sts=2:sw=2:

after/ftplugin/tsx.vim

@@ -0,0 +1,32 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/ftplugin/tsx.vim')
+  finish
+endif
+
+" 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

after/ftplugin/typescriptreact.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/ftplugin/typescriptreact.vim')
+  finish
+endif
+
+source <sfile>:h/tsx.vim

after/indent/html.vim

@@ -1,33 +0,0 @@
-" Language:    CoffeeScript
-" Maintainer:  Mick Koch <kchmck@gmail.com>
-" 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

after/indent/javascript-1.vim

@@ -0,0 +1,9 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/indent/javascript.vim')
+  finish
+endif
+
+if get(g:, 'vim_jsx_pretty_disable_js', 0)
+  finish
+endif
+
+source <sfile>:h/jsx.vim

after/indent/javascript-2.vim

@@ -0,0 +1,46 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/indent/javascript-2.vim')
+  finish
+endif
+
+" Copyright (c) 2016-2021 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('*GetJavascriptGraphQLIndent') && !empty(&indentexpr)
+  finish
+endif
+
+runtime! indent/graphql.vim
+
+" Set the indentexpr with our own version that will call GetGraphQLIndent when
+" we're inside of a GraphQL string and otherwise defer to the base function.
+let b:indentexpr_base = &indentexpr
+setlocal indentexpr=GetJavascriptGraphQLIndent()
+
+function GetJavascriptGraphQLIndent()
+  let l:stack = map(synstack(v:lnum, 1), "synIDattr(v:val, 'name')")
+  if get(l:stack, 0, '') ==# 'graphqlTemplateString'
+    return GetGraphQLIndent()
+  endif
+
+  return eval(b:indentexpr_base)
+endfunction

after/indent/javascript.vim

@@ -0,0 +1,3 @@
+" Polyglot metafile
+source <sfile>:h/javascript-1.vim
+source <sfile>:h/javascript-2.vim

after/indent/javascriptreact.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/indent/javascriptreact.vim')
+  finish
+endif
+
+source <sfile>:h/jsx.vim

after/indent/jsx.vim

@@ -0,0 +1,33 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/indent/jsx.vim')
+  finish
+endif
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" 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

after/indent/objc.vim

@@ -0,0 +1,97 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'objc', 'after/indent/objc.vim')
+  finish
+endif
+
+" Vim indent file
+" Language:	Objective-C
+" Maintainer:	Bjorn Winckler <bjorn.winckler@gmail.com>
+" Last Change:	2012 Jan 01
+
+" Ensure 'cpo' is set to Vim default values and restore later
+let s:save_cpo = &cpo
+set cpo&vim
+
+" Only load this indent file when no other was loaded.
+"if exists("b:did_indent")
+"    finish
+"endif
+"let b:did_indent = 1
+"setlocal cindent
+
+setl indentkeys=0{,0},:,0#,!^F,o,O,e,<:>
+
+setlocal indentexpr=GetObjCIndentImproved()
+
+" Top level statements which should not be indented, and which should not
+" cause next (non-blank) line to be indented either.
+let s:topLev = '^\s*@\%(class\|end\|implementation\|interface\|protocol\|\)\>'
+
+function! GetObjCIndentImproved()
+  " NOTE: Ignore leading white space to avoid having to deal with space vs.
+  " tab issues.  Rely on the indent() function instead.
+  let thisLine = substitute(getline(v:lnum), '^\s*', '', '')
+
+  if thisLine =~# s:topLev || getline(prevnonblank(v:lnum - 1)) =~# s:topLev
+    return 0
+  endif
+
+  " If current line looks like an argument to a message dispatch, then line
+  " up colon with previous line.  This will indent the second line so that
+  " the colons line up in
+  "
+  "   [obj firstParameter:value
+  "                paramB:value2];
+  "
+  " but it will not line up colons in
+  "
+  "   if ([obj something:here])
+  "       [obj other:here];
+  "
+  let thisColon = match(thisLine, '^\s*\K\k*\zs:')
+  if thisColon > 0
+    let prevLine = substitute(getline(v:lnum - 1), '^\s*', '', '')
+    let prevColon = match(prevLine, ':')
+    if prevColon > 0
+      " Try to align colons, always making sure line is indented at least
+      " one shiftwidth more than the indentation at the beginning of the
+      " message.  Avoids situations like this:
+      "
+      "     if ([obj a:x
+      "  aLongParameter:y])
+      "
+      let [lnum,lcol] = searchpairpos('\[', '', '\]', 'b', 0,
+            \ max([1, v:lnum - 10]))
+      let minInd = &sw + (lnum > 0 ? indent(lnum) : 0)
+      let alignedInd = indent(v:lnum - 1) + prevColon - thisColon
+      return alignedInd > minInd ? alignedInd : minInd
+    endif
+  endif
+
+  let prevLnum = v:lnum - 1
+  let ind      = indent(prevLnum)
+
+  " Indent one shiftwidth after opening block, e.g.:
+  "
+  "   call_func_with_block(param, ^{
+  "       do_stuff();
+  "   });
+  "
+  let blockPat = '\^\s*\(([^)]*)\)\?\s*{$'
+  if thisLine =~ '^}'
+    norm '^%'
+    if getline(".") =~ blockPat
+      return indent(".")
+    endif
+  endif
+
+  if getline(prevLnum) =~ blockPat
+    return ind + &sw
+  endif
+
+  return cindent(v:lnum)
+endfunction
+
+
+" Restore 'cpo' options
+let &cpo = s:save_cpo
+unlet s:save_cpo

after/indent/php.vim

@@ -0,0 +1,46 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/indent/php.vim')
+  finish
+endif
+
+" Copyright (c) 2016-2021 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('*GetPHPGraphQLIndent') && !empty(&indentexpr)
+  finish
+endif
+
+runtime! indent/graphql.vim
+
+" Set the indentexpr with our own version that will call GetGraphQLIndent when
+" we're inside of a GraphQL string and otherwise defer to the base function.
+let b:indentexpr_base = &indentexpr
+setlocal indentexpr=GetPHPGraphQLIndent()
+
+function GetPHPGraphQLIndent()
+  let l:stack = map(synstack(v:lnum, 1), "synIDattr(v:val, 'name')")
+  if get(l:stack, 0, '') ==# 'phpRegion' && count(l:stack, 'graphqlFold') > 0
+    return GetGraphQLIndent()
+  endif
+
+  return eval(b:indentexpr_base)
+endfunction

after/indent/tex.vim

@@ -0,0 +1,427 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'tex', 'after/indent/tex.vim')
+  finish
+endif
+
+" Vim indent file
+" Language:     LaTeX
+" Maintainer:   Yichao Zhou <broken.zhou AT gmail.com>
+" Created:      Sat, 16 Feb 2002 16:50:19 +0100
+" Version: 1.0.0
+"   Please email me if you found something I can do.  Comments, bug report and
+"   feature request are welcome.
+
+" Last Update:  {{{
+"               25th Sep 2002, by LH :
+"               (*) better support for the option
+"               (*) use some regex instead of several '||'.
+"               Oct 9th, 2003, by JT:
+"               (*) don't change indentation of lines starting with '%'
+"               2005/06/15, Moshe Kaminsky <kaminsky AT math.huji.ac.il>
+"               (*) New variables:
+"                   g:tex_items, g:tex_itemize_env, g:tex_noindent_env
+"               2011/3/6, by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Don't change indentation of lines starting with '%'
+"                   I don't see any code with '%' and it doesn't work properly
+"                   so I add some code.
+"               (*) New features: Add smartindent-like indent for "{}" and  "[]".
+"               (*) New variables: g:tex_indent_brace
+"               2011/9/25, by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Bug fix: smartindent-like indent for "[]"
+"               (*) New features: Align with "&".
+"               (*) New variable: g:tex_indent_and.
+"               2011/10/23 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Bug fix: improve the smartindent-like indent for "{}" and
+"               "[]".
+"               2012/02/27 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Bug fix: support default folding marker.
+"               (*) Indent with "&" is not very handy.  Make it not enable by
+"               default.
+"               2012/03/06 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Modify "&" behavior and make it default again.  Now "&"
+"               won't align when there are more then one "&" in the previous
+"               line.
+"               (*) Add indent "\left(" and "\right)"
+"               (*) Trust user when in "verbatim" and "lstlisting"
+"               2012/03/11 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Modify "&" so that only indent when current line start with
+"                   "&".
+"               2012/03/12 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Modify indentkeys.
+"               2012/03/18 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Add &cpo
+"               2013/05/02 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Fix problem about GetTeXIndent checker. Thank Albert Netymk
+"                   for reporting this.
+"               2014/06/23 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Remove the feature g:tex_indent_and because it is buggy.
+"               (*) If there is not any obvious indentation hints, we do not
+"                   alert our user's current indentation.
+"               (*) g:tex_indent_brace now only works if the open brace is the
+"                   last character of that line.
+"               2014/08/03 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Indent current line if last line has larger indentation
+"               2016/11/08 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Fix problems for \[ and \].  Thanks Bruno for reporting.
+"               2017/04/30 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Fix a bug between g:tex_noindent_env and g:tex_indent_items
+"                   Now g:tex_noindent_env='document\|verbatim\|itemize' (Emacs
+"                   style) is supported.  Thanks Miles Wheeler for reporting.
+"               2018/02/07 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Make indentation more smart in the normal mode
+"               2020/04/26 by Yichao Zhou <broken.zhou AT gmail.com>
+"               (*) Fix a bug related to \[ & \].  Thanks Manuel Boni for
+"               reporting.
+"
+" }}}
+
+" Document: {{{
+"
+" For proper latex experience, please put
+"         let g:tex_flavor = "latex"
+" into your vimrc.
+"
+" * g:tex_indent_brace
+"
+"   If this variable is unset or non-zero, it will use smartindent-like style
+"   for "{}" and "[]".  Now this only works if the open brace is the last
+"   character of that line.
+"
+"         % Example 1
+"         \usetikzlibrary{
+"           external
+"         }
+"
+"         % Example 2
+"         \tikzexternalize[
+"           prefix=tikz]
+"
+" * g:tex_indent_items
+"
+"   If this variable is set, item-environments are indented like Emacs does
+"   it, i.e., continuation lines are indented with a shiftwidth.
+"
+"              set                      unset
+"   ------------------------------------------------------
+"       \begin{itemize}            \begin{itemize}
+"         \item blablabla            \item blablabla
+"           bla bla bla              bla bla bla
+"         \item blablabla            \item blablabla
+"           bla bla bla              bla bla bla
+"       \end{itemize}              \end{itemize}
+"
+"
+" * g:tex_items
+"
+"   A list of tokens to be considered as commands for the beginning of an item
+"   command. The tokens should be separated with '\|'. The initial '\' should
+"   be escaped. The default is '\\bibitem\|\\item'.
+"
+" * g:tex_itemize_env
+"
+"   A list of environment names, separated with '\|', where the items (item
+"   commands matching g:tex_items) may appear. The default is
+"   'itemize\|description\|enumerate\|thebibliography'.
+"
+" * g:tex_noindent_env
+"
+"   A list of environment names. separated with '\|', where no indentation is
+"   required. The default is 'document\|verbatim'.
+" }}}
+
+" Only define the function once
+if exists("b:did_indent")
+    finish
+endif
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+" Define global variable {{{
+
+let b:did_indent = 1
+
+if !exists("g:tex_indent_items")
+    let g:tex_indent_items = 1
+endif
+if !exists("g:tex_indent_brace")
+    let g:tex_indent_brace = 1
+endif
+if !exists("g:tex_max_scan_line")
+    let g:tex_max_scan_line = 60
+endif
+if g:tex_indent_items
+    if !exists("g:tex_itemize_env")
+        let g:tex_itemize_env = 'itemize\|description\|enumerate\|thebibliography'
+    endif
+    if !exists('g:tex_items')
+        let g:tex_items = '\\bibitem\|\\item'
+    endif
+else
+    let g:tex_items = ''
+endif
+
+if !exists("g:tex_noindent_env")
+    let g:tex_noindent_env = 'document\|verbatim\|lstlisting'
+endif "}}}
+
+" VIM Setting " {{{
+setlocal autoindent
+setlocal nosmartindent
+setlocal indentexpr=GetTeXIndent()
+setlocal indentkeys&
+exec 'setlocal indentkeys+=[,(,{,),},],\&' . substitute(g:tex_items, '^\|\(\\|\)', ',=', 'g')
+let g:tex_items = '^\s*' . substitute(g:tex_items, '^\(\^\\s\*\)*', '', '')
+" }}}
+
+function! GetTeXIndent() " {{{
+    " Find a non-blank line above the current line.
+    let lnum = prevnonblank(v:lnum - 1)
+    let cnum = v:lnum
+
+    " Comment line is not what we need.
+    while lnum != 0 && getline(lnum) =~ '^\s*%'
+        let lnum = prevnonblank(lnum - 1)
+    endwhile
+
+    " At the start of the file use zero indent.
+    if lnum == 0
+        return 0
+    endif
+
+    let line = substitute(getline(lnum), '\s*%.*', '','g')     " last line
+    let cline = substitute(getline(v:lnum), '\s*%.*', '', 'g') " current line
+
+    let ccol = 1
+    while cline[ccol] =~ '\s'
+        let ccol += 1
+    endwhile
+
+    "  We are in verbatim, so do what our user what.
+    if synIDattr(synID(v:lnum, ccol, 1), "name") == "texZone"
+        if empty(cline)
+            return indent(lnum)
+        else
+            return indent(v:lnum)
+        endif
+    endif
+
+    if lnum == 0
+        return 0
+    endif
+
+    let ind = indent(lnum)
+    let stay = 1
+
+    " New code for comment: retain the indent of current line
+    if cline =~ '^\s*%'
+        return indent(v:lnum)
+    endif
+
+    " Add a 'shiftwidth' after beginning of environments.
+    " Don't add it for \begin{document} and \begin{verbatim}
+    " if line =~ '^\s*\\begin{\(.*\)}'  && line !~ 'verbatim'
+    " LH modification : \begin does not always start a line
+    " ZYC modification : \end after \begin won't cause wrong indent anymore
+    if line =~ '\\begin{.*}' 
+        if line !~ g:tex_noindent_env
+            let ind = ind + shiftwidth()
+            let stay = 0
+        endif
+
+        if g:tex_indent_items
+            " Add another sw for item-environments
+            if line =~ g:tex_itemize_env
+                let ind = ind + shiftwidth()
+                let stay = 0
+            endif
+        endif
+    endif
+
+    if cline =~ '\\end{.*}'
+        let retn = s:GetEndIndentation(v:lnum)
+        if retn != -1
+            return retn
+        endif
+    end
+    " Subtract a 'shiftwidth' when an environment ends
+    if cline =~ '\\end{.*}'
+                \ && cline !~ g:tex_noindent_env
+                \ && cline !~ '\\begin{.*}.*\\end{.*}'
+        if g:tex_indent_items
+            " Remove another sw for item-environments
+            if cline =~ g:tex_itemize_env
+                let ind = ind - shiftwidth()
+                let stay = 0
+            endif
+        endif
+
+        let ind = ind - shiftwidth()
+        let stay = 0
+    endif
+
+    if g:tex_indent_brace
+        if line =~ '[[{]$'
+            let ind += shiftwidth()
+            let stay = 0
+        endif
+
+        if cline =~ '^\s*\\\?[\]}]' && s:CheckPairedIsLastCharacter(v:lnum, ccol)
+            let ind -= shiftwidth()
+            let stay = 0
+        endif
+
+        if line !~ '^\s*\\\?[\]}]'
+            for i in range(1, strlen(line)-1)
+                let char = line[i]
+                if char == ']' || char == '}'
+                    if s:CheckPairedIsLastCharacter(lnum, i)
+                        let ind -= shiftwidth()
+                        let stay = 0
+                    endif
+                endif
+            endfor
+        endif
+    endif
+
+    " Special treatment for 'item'
+    " ----------------------------
+
+    if g:tex_indent_items
+        " '\item' or '\bibitem' itself:
+        if cline =~ g:tex_items
+            let ind = ind - shiftwidth()
+            let stay = 0
+        endif
+        " lines following to '\item' are indented once again:
+        if line =~ g:tex_items
+            let ind = ind + shiftwidth()
+            let stay = 0
+        endif
+    endif
+
+    if stay && mode() == 'i'
+        " If there is no obvious indentation hint, and indentation is triggered
+        " in insert mode, we trust our user.
+        if empty(cline)
+            return ind
+        else
+            return max([indent(v:lnum), s:GetLastBeginIndentation(v:lnum)])
+        endif
+    else
+        return ind
+    endif
+endfunction "}}}
+
+function! s:GetLastBeginIndentation(lnum) " {{{
+    let matchend = 1
+    for lnum in range(a:lnum-1, max([a:lnum - g:tex_max_scan_line, 1]), -1)
+        let line = getline(lnum)
+        if line =~ '\\end{.*}'
+            let matchend += 1
+        endif
+        if line =~ '\\begin{.*}'
+            let matchend -= 1
+        endif
+        if matchend == 0
+            if line =~ g:tex_noindent_env
+                return indent(lnum)
+            endif
+            if line =~ g:tex_itemize_env
+                return indent(lnum) + 2 * shiftwidth()
+            endif
+            return indent(lnum) + shiftwidth()
+        endif
+    endfor
+    return -1
+endfunction
+
+function! s:GetEndIndentation(lnum) " {{{
+    if getline(a:lnum) =~ '\\begin{.*}.*\\end{.*}'
+        return -1
+    endif
+
+    let min_indent = 100
+    let matchend = 1
+    for lnum in range(a:lnum-1, max([a:lnum-g:tex_max_scan_line, 1]), -1)
+        let line = getline(lnum)
+        if line =~ '\\end{.*}'
+            let matchend += 1
+        endif
+        if line =~ '\\begin{.*}'
+            let matchend -= 1
+        endif
+        if matchend == 0
+            return indent(lnum)
+        endif
+        if !empty(line)
+            let min_indent = min([min_indent, indent(lnum)])
+        endif
+    endfor
+    return min_indent - shiftwidth()
+endfunction
+
+" Most of the code is from matchparen.vim
+function! s:CheckPairedIsLastCharacter(lnum, col) "{{{
+    let c_lnum = a:lnum
+    let c_col = a:col+1
+
+    let line = getline(c_lnum)
+    if line[c_col-1] == '\'
+        let c_col = c_col + 1
+    endif
+    let c = line[c_col-1]
+
+    let plist = split(&matchpairs, '.\zs[:,]')
+    let i = index(plist, c)
+    if i < 0
+        return 0
+    endif
+
+    " Figure out the arguments for searchpairpos().
+    if i % 2 == 0
+        let s_flags = 'nW'
+        let c2 = plist[i + 1]
+    else
+        let s_flags = 'nbW'
+        let c2 = c
+        let c = plist[i - 1]
+    endif
+    if c == '['
+        let c = '\['
+        let c2 = '\]'
+    endif
+
+    " Find the match.  When it was just before the cursor move it there for a
+    " moment.
+    let save_cursor = winsaveview()
+    call cursor(c_lnum, c_col)
+
+    " When not in a string or comment ignore matches inside them.
+    " We match "escape" for special items, such as lispEscapeSpecial.
+    let s_skip ='synIDattr(synID(line("."), col("."), 0), "name") ' .
+                \ '=~?  "string\\|character\\|singlequote\\|escape\\|comment"'
+    execute 'if' s_skip '| let s_skip = 0 | endif'
+
+    let stopline = max([0, c_lnum - g:tex_max_scan_line])
+
+    " Limit the search time to 300 msec to avoid a hang on very long lines.
+    " This fails when a timeout is not supported.
+    try
+        let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, 100)
+    catch /E118/
+    endtry
+
+    call winrestview(save_cursor)
+
+    if m_lnum > 0
+        let line = getline(m_lnum)
+        return strlen(line) == m_col
+    endif
+
+    return 0
+endfunction "}}}
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim: set sw=4 textwidth=80:

after/indent/tsx.vim

@@ -0,0 +1,40 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/indent/tsx.vim')
+  finish
+endif
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" 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

after/indent/typescript.vim

@@ -0,0 +1,46 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/indent/typescript.vim')
+  finish
+endif
+
+" Copyright (c) 2016-2021 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('*GetTypescriptGraphQLIndent') && !empty(&indentexpr)
+  finish
+endif
+
+runtime! indent/graphql.vim
+
+" Set the indentexpr with our own version that will call GetGraphQLIndent when
+" we're inside of a GraphQL string and otherwise defer to the base function.
+let b:indentexpr_base = &indentexpr
+setlocal indentexpr=GetTypescriptGraphQLIndent()
+
+function GetTypescriptGraphQLIndent()
+  let l:stack = map(synstack(v:lnum, 1), "synIDattr(v:val, 'name')")
+  if get(l:stack, 0, '') ==# 'graphqlTemplateString'
+    return GetGraphQLIndent()
+  endif
+
+  return eval(b:indentexpr_base)
+endfunction

after/indent/typescriptreact.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/indent/typescriptreact.vim')
+  finish
+endif
+
+source <sfile>:h/tsx.vim

after/syntax/c.vim

@@ -0,0 +1,66 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'cpp-modern', 'after/syntax/c.vim')
+  finish
+endif
+
+" ==============================================================================
+" Vim syntax file
+" Language:        C Additions
+" Original Author: Mikhail Wolfson <mywolfson@gmail.com>
+" Maintainer:      bfrg <https://github.com/bfrg>
+" Website:         https://github.com/bfrg/vim-cpp-modern
+" Last Change:     Jul 24, 2021
+"
+" This syntax file is based on:
+" https://github.com/octol/vim-cpp-enhanced-highlight
+" ==============================================================================
+
+
+" Highlight additional keywords in the comments
+syn keyword cTodo contained BUG NOTE
+
+
+" Highlight function names
+if get(g:, 'cpp_function_highlight', 1)
+    syn match cUserFunction "\<\h\w*\>\(\s\|\n\)*("me=e-1 contains=cParen,cCppParen
+    hi def link cUserFunction Function
+endif
+
+
+" Highlight struct/class member variables
+if get(g:, 'cpp_member_highlight', 0)
+    syn match cMemberAccess "\.\|->" nextgroup=cStructMember,cppTemplateKeyword
+    syn match cStructMember "\<\h\w*\>\%((\|<\)\@!" contained
+    syn cluster cParenGroup add=cStructMember
+    syn cluster cPreProcGroup add=cStructMember
+    syn cluster cMultiGroup add=cStructMember
+    hi def link cStructMember Identifier
+
+    if &filetype ==# 'cpp'
+        syn keyword cppTemplateKeyword template
+        hi def link cppTemplateKeyword cppStructure
+    endif
+endif
+
+
+" Common ANSI-standard Names
+syn keyword cAnsiName
+        \ PRId8 PRIi16 PRIo32 PRIu64 PRId16 PRIi32 PRIo64 PRIuLEAST8 PRId32 PRIi64 PRIoLEAST8 PRIuLEAST16 PRId64 PRIiLEAST8 PRIoLEAST16 PRIuLEAST32 PRIdLEAST8 PRIiLEAST16 PRIoLEAST32 PRIuLEAST64 PRIdLEAST16 PRIiLEAST32 PRIoLEAST64 PRIuFAST8 PRIdLEAST32 PRIiLEAST64 PRIoFAST8 PRIuFAST16 PRIdLEAST64 PRIiFAST8 PRIoFAST16 PRIuFAST32 PRIdFAST8 PRIiFAST16 PRIoFAST32 PRIuFAST64 PRIdFAST16 PRIiFAST32 PRIoFAST64 PRIuMAX PRIdFAST32 PRIiFAST64 PRIoMAX PRIuPTR PRIdFAST64 PRIiMAX PRIoPTR PRIx8 PRIdMAX PRIiPTR PRIu8 PRIx16 PRIdPTR PRIo8 PRIu16 PRIx32 PRIi8 PRIo16 PRIu32 PRIx64 PRIxLEAST8 SCNd8 SCNiFAST32 SCNuLEAST32 PRIxLEAST16 SCNd16 SCNiFAST64 SCNuLEAST64 PRIxLEAST32 SCNd32 SCNiMAX SCNuFAST8 PRIxLEAST64 SCNd64 SCNiPTR SCNuFAST16 PRIxFAST8 SCNdLEAST8 SCNo8 SCNuFAST32 PRIxFAST16 SCNdLEAST16 SCNo16 SCNuFAST64 PRIxFAST32 SCNdLEAST32 SCNo32 SCNuMAX PRIxFAST64 SCNdLEAST64 SCNo64 SCNuPTR PRIxMAX SCNdFAST8 SCNoLEAST8 SCNx8 PRIxPTR SCNdFAST16 SCNoLEAST16 SCNx16 PRIX8 SCNdFAST32 SCNoLEAST32 SCNx32 PRIX16 SCNdFAST64 SCNoLEAST64 SCNx64 PRIX32 SCNdMAX SCNoFAST8 SCNxLEAST8 PRIX64 SCNdPTR SCNoFAST16 SCNxLEAST16 PRIXLEAST8 SCNi8 SCNoFAST32 SCNxLEAST32 PRIXLEAST16 SCNi16 SCNoFAST64 SCNxLEAST64 PRIXLEAST32 SCNi32 SCNoMAX SCNxFAST8 PRIXLEAST64 SCNi64 SCNoPTR SCNxFAST16 PRIXFAST8 SCNiLEAST8 SCNu8 SCNxFAST32 PRIXFAST16 SCNiLEAST16 SCNu16 SCNxFAST64 PRIXFAST32 SCNiLEAST32 SCNu32 SCNxMAX PRIXFAST64 SCNiLEAST64 SCNu64 SCNxPTR PRIXMAX SCNiFAST8 SCNuLEAST8 PRIXPTR SCNiFAST16 SCNuLEAST16 STDC CX_LIMITED_RANGE STDC FENV_ACCESS STDC FP_CONTRACT
+        \ errno environ and bitor not_eq xor and_eq compl or xor_eq bitand not or_eq
+
+" Booleans
+syn keyword cBoolean true false TRUE FALSE
+
+
+" Default highlighting
+hi def link cBoolean  Boolean
+hi def link cAnsiName Identifier
+
+
+" Highlight all standard C keywords as Statement
+" This is very similar to what other IDEs and editors do
+if get(g:, 'cpp_simple_highlight', 0)
+    hi! def link cStorageClass Statement
+    hi! def link cStructure    Statement
+    hi! def link cTypedef      Statement
+    hi! def link cLabel        Statement
+endif

after/syntax/coffee.vim

@@ -1,20 +1,31 @@
-" This file describes a very basic syntax for TomDoc comments in a
-" CoffeeScript file.
-"
-" For more information on TomDoc, check it out here: http://tomdoc.org/
-"
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'cjsx', 'after/syntax/coffee.vim')
+  finish
+endif
 
-syn keyword tomdocKeywords Returns containedin=coffeeComment contained
-syn keyword tomdocKeywords Throws containedin=coffeeComment contained
-syn keyword tomdocKeywords Examples containedin=coffeeComment contained
-syn keyword tomdocKeywords Signature containedin=coffeeComment contained
+if exists('b:current_syntax')
+  let s:current_syntax=b:current_syntax
+  unlet b:current_syntax
+endif
 
-syn match tomdocArguments +\s*[A-Za-z0-9_\-&\*:]*\(\s*- \)+he=e-3 containedin=coffeeComment contained
+if exists('s:current_syntax')
+  let b:current_syntax=s:current_syntax
+endif
 
-syn match tomdocDescriptions +\s*Public:+he=e-1 containedin=coffeeComment contained
-syn match tomdocDescriptions +\s*Internal:+he=e-1 containedin=coffeeComment contained
-syn match tomdocDescriptions +\s*Deprecated:+he=e-1 containedin=coffeeComment contained
+syn match   cjsxEntity       contained "&[^; \t]*;" contains=cjsxEntityPunct
+syn match   cjsxEntityPunct  contained "[&.;]"
 
-hi default link tomdocDescriptions String
-hi default link tomdocKeywords String
-hi default link tomdocArguments HELP
+syn match   cjsxAttribProperty /[A-Za-z_][A-Za-z0-9_-]*/ contained
+syn region  cjsxAttrib start=/\s[A-Za-z_][A-Za-z0-9_-]/hs=s+1 end=/=/ end=/\s[A-Za-z_]/me=e-2 end=+[/>]+me=e-1 contained contains=cjsxAttribProperty
+
+syn region  cjsxBody start=+[^/]>+ms=s+2 start=/>/ms=s+1 end=+<\/+me=e-2 contained contains=cjsxElement,coffeeCurlies,cjsxEntity
+
+syn region  cjsxElement start=/<@\=[A-Za-z_][A-Za-z0-9-_\.]*/ end=/\/>/ end=/<\/@\=[A-Za-z_][A-Za-z0-9-_\.]*>/ contains=cjsxOpenTag,cjsxBody,coffeeCurlies,coffeeString,cjsxAttrib,coffeeNumber,coffeeFloat
+
+syn cluster coffeeAll add=cjsxElement
+
+" The default highlighting.
+hi def link cjsxElement         Function
+hi def link cjsxTagName         Function
+hi def link cjsxEntity          Statement
+hi def link cjsxEntityPunct     Type
+hi def link cjsxAttribProperty  Type

after/syntax/css.vim

@@ -1,501 +0,0 @@
-" Language:     Colorful CSS Color Preview
-" Author:       Aristotle Pagaltzis <pagaltzis@gmx.de>
-" Last Change:  2013-03-09
-" Licence:      No Warranties. WTFPL. But please tell me!
-" Version:      0.7.3
-" vim:et:ts=2 sw=2 sts=2
-"
-" KNOWN PROBLEMS: compatibility with `cursorline` -- https://github.com/ap/vim-css-color/issues/24
-
-let s:hex={}
-for i in range(0, 255)
-  let s:hex[ printf( '%02x', i ) ] = i
-endfor
-
-let s:black = '#000000'
-let s:white = '#ffffff'
-
-function! s:FGForBG(color)
-  " pick suitable text color given a background color
-  let color = tolower(a:color)
-  let r = s:hex[color[0:1]]
-  let g = s:hex[color[2:3]]
-  let b = s:hex[color[4:5]]
-  return r*30 + g*59 + b*11 > 12000 ? s:black : s:white
-endfunction
-
-let b:color_pattern = {}
-let s:color_prefix  = 'gui'
-let s:fg_color_calc = 'let color = "#" . toupper(a:color)'
-
-function! s:MatchColorValue(color, pattern)
-  if ! len(a:color) | return | endif
-
-  if has_key( b:color_pattern, a:pattern ) | return | endif
-  let b:color_pattern[a:pattern] = 1
-
-  let pattern = a:pattern
-  " iff pattern ends on word character, require word break to match
-  if pattern =~ '\>$' | let pattern .= '\>' | endif
-
-  let group = 'cssColor' . tolower(a:color)
-  exe 'syn match' group '/'.escape(pattern, '/').'/ contained'
-  exe 'syn cluster cssColors add='.group
-  exe s:fg_color_calc
-  exe 'hi' group s:color_prefix.'bg='.color s:color_prefix.'fg='.s:FGForBG(a:color)
-  return ''
-endfunction
-
-function! s:HexForRGBValue(r,g,b)
-  " Convert 80% -> 204, 100% -> 255, etc.
-  let rgb = map( [a:r,a:g,a:b], 'v:val =~ "%$" ? ( 255 * v:val ) / 100 : v:val' )
-  return printf( '%02x%02x%02x', rgb[0], rgb[1], rgb[2] )
-endfunction
-
-function! s:HexForHSLValue(h,s,l)
-  " Convert 80% -> 0.8, 100% -> 1.0, etc.
-  let [s,l] = map( [a:s, a:l], 'v:val =~ "%$" ? v:val / 100.0 : str2float(v:val)' )
-  " algorithm transcoded to vim from http://www.w3.org/TR/css3-color/#hsl-color
-  let hh = ( a:h % 360 ) / 360.0
-  let m2 = l <= 0.5 ? l * ( s + 1 ) : l + s - l * s
-  let m1 = l * 2 - m2
-  let rgb = []
-  for h in [ hh + (1/3.0), hh, hh - (1/3.0) ]
-    let h = h < 0 ? h + 1 : h > 1 ? h - 1 : h
-    let v =
-          \ h * 6 < 1 ? m1 + ( m2 - m1 ) * h * 6 :
-          \ h * 2 < 1 ? m2 :
-          \ h * 3 < 2 ? m1 + ( m2 - m1 ) * ( 2/3.0 - h ) * 6 :
-          \ m1
-    if v > 1.0 | return '' | endif
-    let rgb += [ float2nr( 255 * v ) ]
-  endfor
-  return printf( '%02x%02x%02x', rgb[0], rgb[1], rgb[2] )
-endfunction
-
-function! s:PreviewCSSColorInLine()
-  " TODO use cssColor matchdata
-  "
-  " N.B. these substitute() calls are here just for the side effect
-  "      of invoking s:MatchColorValue during substitution -- because
-  "      match() and friends do not allow finding all matches in a single
-  "      scan without examining the start of the string over and over
-  call substitute( substitute( substitute( substitute( getline('.'),
-    \ '#\(\x\)\(\x\)\(\x\)\>', '\=s:MatchColorValue(submatch(1).submatch(1).submatch(2).submatch(2).submatch(3).submatch(3), submatch(0))', 'g' ),
-    \ '#\(\x\{6}\)\>', '\=s:MatchColorValue(submatch(1), submatch(0))', 'g' ),
-    \ 'rgba\?(\s*\(\d\{1,3}%\?\)\s*,\s*\(\d\{1,3}%\?\)\s*,\s*\(\d\{1,3}%\?\)\s*\%(,[^)]*\)\?)', '\=s:MatchColorValue(s:HexForRGBValue(submatch(1),submatch(2),submatch(3)),submatch(0))', 'g' ),
-    \ 'hsla\?(\s*\(\d\{1,3}%\?\)\s*,\s*\(\d\{1,3}%\?\)\s*,\s*\(\d\{1,3}%\?\)\s*\%(,[^)]*\)\?)', '\=s:MatchColorValue(s:HexForHSLValue(submatch(1),submatch(2),submatch(3)),submatch(0))', 'g' )
-endfunction
-
-if has("gui_running") || &t_Co==256
-  " HACK modify cssDefinition to add @cssColors to its contains
-  redir => cssdef
-  silent! syn list cssDefinition
-  redir END
-  if len( cssdef )
-    for out in split( cssdef, "\n" )
-      if out !~ '^cssDefinition ' | continue | endif
-      let out = substitute( out, ' \+xxx \+', ' ', '' )
-      let out = substitute( out, ' contains=\zs', '@cssColors,', '' )
-      syn clear cssDefinition
-      exe 'syn region' out
-    endfor
-  endif
-
-  if ! has('gui_running')
-
-    let s:black = 0
-    let s:white = 15
-
-    let s:color_prefix  = 'cterm'
-    let s:fg_color_calc = 'let color = s:XTermColorForRGB(a:color)'
-
-    " preset 16 vt100 colors
-    let s:xtermcolor = [
-      \ [ 0x00, 0x00, 0x00,  0 ],
-      \ [ 0xCD, 0x00, 0x00,  1 ],
-      \ [ 0x00, 0xCD, 0x00,  2 ],
-      \ [ 0xCD, 0xCD, 0x00,  3 ],
-      \ [ 0x00, 0x00, 0xEE,  4 ],
-      \ [ 0xCD, 0x00, 0xCD,  5 ],
-      \ [ 0x00, 0xCD, 0xCD,  6 ],
-      \ [ 0xE5, 0xE5, 0xE5,  7 ],
-      \ [ 0x7F, 0x7F, 0x7F,  8 ],
-      \ [ 0xFF, 0x00, 0x00,  9 ],
-      \ [ 0x00, 0xFF, 0x00, 10 ],
-      \ [ 0xFF, 0xFF, 0x00, 11 ],
-      \ [ 0x5C, 0x5C, 0xFF, 12 ],
-      \ [ 0xFF, 0x00, 0xFF, 13 ],
-      \ [ 0x00, 0xFF, 0xFF, 14 ],
-      \ [ 0xFF, 0xFF, 0xFF, 15 ]]
-    " grayscale ramp
-    " (value is 8+10*lum for lum in 0..23)
-    let s:xtermcolor += [
-      \ [ 0x08, 0x08, 0x08, 232 ],
-      \ [ 0x12, 0x12, 0x12, 233 ],
-      \ [ 0x1C, 0x1C, 0x1C, 234 ],
-      \ [ 0x26, 0x26, 0x26, 235 ],
-      \ [ 0x30, 0x30, 0x30, 236 ],
-      \ [ 0x3A, 0x3A, 0x3A, 237 ],
-      \ [ 0x44, 0x44, 0x44, 238 ],
-      \ [ 0x4E, 0x4E, 0x4E, 239 ],
-      \ [ 0x58, 0x58, 0x58, 240 ],
-      \ [ 0x62, 0x62, 0x62, 241 ],
-      \ [ 0x6C, 0x6C, 0x6C, 242 ],
-      \ [ 0x76, 0x76, 0x76, 243 ],
-      \ [ 0x80, 0x80, 0x80, 244 ],
-      \ [ 0x8A, 0x8A, 0x8A, 245 ],
-      \ [ 0x94, 0x94, 0x94, 246 ],
-      \ [ 0x9E, 0x9E, 0x9E, 247 ],
-      \ [ 0xA8, 0xA8, 0xA8, 248 ],
-      \ [ 0xB2, 0xB2, 0xB2, 249 ],
-      \ [ 0xBC, 0xBC, 0xBC, 250 ],
-      \ [ 0xC6, 0xC6, 0xC6, 251 ],
-      \ [ 0xD0, 0xD0, 0xD0, 252 ],
-      \ [ 0xDA, 0xDA, 0xDA, 253 ],
-      \ [ 0xE4, 0xE4, 0xE4, 254 ],
-      \ [ 0xEE, 0xEE, 0xEE, 255 ]]
-
-    " the 6 values used in the xterm color cube
-    "                    0    95   135   175   215   255
-    let s:cubergb = [ 0x00, 0x5F, 0x87, 0xAF, 0xD7, 0xFF ]
-
-    " 0..255 mapped to 0..5 based on the color cube values
-    let s:xvquant = repeat([0],48)
-        \         + repeat([1],68)
-        \         + repeat([2],40)
-        \         + repeat([3],40)
-        \         + repeat([4],40)
-        \         + repeat([5],20)
-    " tweak the mapping for the exact matches (0 and 1 already correct)
-    let s:xvquant[s:cubergb[2]] = 2
-    let s:xvquant[s:cubergb[3]] = 3
-    let s:xvquant[s:cubergb[4]] = 4
-    let s:xvquant[s:cubergb[5]] = 5
-
-    " selects the nearest xterm color for a rgb value like #FF0000
-    function! s:XTermColorForRGB(color)
-      let best_match=0
-      let smallest_distance = 10000000000
-      let color = tolower(a:color)
-      let r = s:hex[color[0:1]]
-      let g = s:hex[color[2:3]]
-      let b = s:hex[color[4:5]]
-
-      let vr = s:xvquant[r]
-      let vg = s:xvquant[g]
-      let vb = s:xvquant[b]
-      let cidx = vr * 36 + vg * 6 + vb + 16
-      let ccol = [ s:cubergb[vr], s:cubergb[vg], s:cubergb[vb], cidx ]
-
-      for [tr,tg,tb,idx] in [ ccol ] + s:xtermcolor
-        let dr = tr - r
-        let dg = tg - g
-        let db = tb - b
-        let distance = dr*dr + dg*dg + db*db
-        if distance == 0 | return idx | endif
-        if distance > smallest_distance | continue | endif
-        let smallest_distance = distance
-        let best_match = idx
-      endfor
-      return best_match
-    endfunction
-  endif
-
-  hi cssColor000000 guibg=#000000 guifg=#FFFFFF ctermbg=16  ctermfg=231 | syn cluster cssColors add=cssColor000000
-  hi cssColor000080 guibg=#000080 guifg=#FFFFFF ctermbg=235 ctermfg=231 | syn cluster cssColors add=cssColor000080
-  hi cssColor00008b guibg=#00008B guifg=#FFFFFF ctermbg=4   ctermfg=231 | syn cluster cssColors add=cssColor00008b
-  hi cssColor0000cd guibg=#0000CD guifg=#FFFFFF ctermbg=4   ctermfg=231 | syn cluster cssColors add=cssColor0000cd
-  hi cssColor0000ff guibg=#0000FF guifg=#FFFFFF ctermbg=4   ctermfg=231 | syn cluster cssColors add=cssColor0000ff
-  hi cssColor006400 guibg=#006400 guifg=#FFFFFF ctermbg=235 ctermfg=231 | syn cluster cssColors add=cssColor006400
-  hi cssColor008000 guibg=#008000 guifg=#FFFFFF ctermbg=2   ctermfg=231 | syn cluster cssColors add=cssColor008000
-  hi cssColor008080 guibg=#008080 guifg=#FFFFFF ctermbg=30  ctermfg=231 | syn cluster cssColors add=cssColor008080
-  hi cssColor008b8b guibg=#008B8B guifg=#FFFFFF ctermbg=30  ctermfg=231 | syn cluster cssColors add=cssColor008b8b
-  hi cssColor00bfff guibg=#00BFFF guifg=#000000 ctermbg=6   ctermfg=16  | syn cluster cssColors add=cssColor00bfff
-  hi cssColor00ced1 guibg=#00CED1 guifg=#000000 ctermbg=6   ctermfg=16  | syn cluster cssColors add=cssColor00ced1
-  hi cssColor00fa9a guibg=#00FA9A guifg=#000000 ctermbg=6   ctermfg=16  | syn cluster cssColors add=cssColor00fa9a
-  hi cssColor00ff00 guibg=#00FF00 guifg=#000000 ctermbg=10  ctermfg=16  | syn cluster cssColors add=cssColor00ff00
-  hi cssColor00ff7f guibg=#00FF7F guifg=#000000 ctermbg=6   ctermfg=16  | syn cluster cssColors add=cssColor00ff7f
-  hi cssColor00ffff guibg=#00FFFF guifg=#000000 ctermbg=51  ctermfg=16  | syn cluster cssColors add=cssColor00ffff
-  hi cssColor191970 guibg=#191970 guifg=#FFFFFF ctermbg=237 ctermfg=231 | syn cluster cssColors add=cssColor191970
-  hi cssColor1e90ff guibg=#1E90FF guifg=#000000 ctermbg=12  ctermfg=16  | syn cluster cssColors add=cssColor1e90ff
-  hi cssColor20b2aa guibg=#20B2AA guifg=#000000 ctermbg=37  ctermfg=16  | syn cluster cssColors add=cssColor20b2aa
-  hi cssColor228b22 guibg=#228B22 guifg=#FFFFFF ctermbg=2   ctermfg=231 | syn cluster cssColors add=cssColor228b22
-  hi cssColor2e8b57 guibg=#2E8B57 guifg=#FFFFFF ctermbg=240 ctermfg=231 | syn cluster cssColors add=cssColor2e8b57
-  hi cssColor2f4f4f guibg=#2F4F4F guifg=#FFFFFF ctermbg=238 ctermfg=231 | syn cluster cssColors add=cssColor2f4f4f
-  hi cssColor32cd32 guibg=#32CD32 guifg=#000000 ctermbg=2   ctermfg=16  | syn cluster cssColors add=cssColor32cd32
-  hi cssColor3cb371 guibg=#3CB371 guifg=#000000 ctermbg=71  ctermfg=16  | syn cluster cssColors add=cssColor3cb371
-  hi cssColor40e0d0 guibg=#40E0D0 guifg=#000000 ctermbg=80  ctermfg=16  | syn cluster cssColors add=cssColor40e0d0
-  hi cssColor4169e1 guibg=#4169E1 guifg=#FFFFFF ctermbg=12  ctermfg=231 | syn cluster cssColors add=cssColor4169e1
-  hi cssColor4682b4 guibg=#4682B4 guifg=#FFFFFF ctermbg=67  ctermfg=231 | syn cluster cssColors add=cssColor4682b4
-  hi cssColor483d8b guibg=#483D8B guifg=#FFFFFF ctermbg=240 ctermfg=231 | syn cluster cssColors add=cssColor483d8b
-  hi cssColor48d1cc guibg=#48D1CC guifg=#000000 ctermbg=80  ctermfg=16  | syn cluster cssColors add=cssColor48d1cc
-  hi cssColor4b0082 guibg=#4B0082 guifg=#FFFFFF ctermbg=238 ctermfg=231 | syn cluster cssColors add=cssColor4b0082
-  hi cssColor556b2f guibg=#556B2F guifg=#FFFFFF ctermbg=239 ctermfg=231 | syn cluster cssColors add=cssColor556b2f
-  hi cssColor5f9ea0 guibg=#5F9EA0 guifg=#000000 ctermbg=73  ctermfg=16  | syn cluster cssColors add=cssColor5f9ea0
-  hi cssColor6495ed guibg=#6495ED guifg=#000000 ctermbg=12  ctermfg=16  | syn cluster cssColors add=cssColor6495ed
-  hi cssColor66cdaa guibg=#66CDAA guifg=#000000 ctermbg=79  ctermfg=16  | syn cluster cssColors add=cssColor66cdaa
-  hi cssColor696969 guibg=#696969 guifg=#FFFFFF ctermbg=242 ctermfg=231 | syn cluster cssColors add=cssColor696969
-  hi cssColor6a5acd guibg=#6A5ACD guifg=#FFFFFF ctermbg=12  ctermfg=231 | syn cluster cssColors add=cssColor6a5acd
-  hi cssColor6b8e23 guibg=#6B8E23 guifg=#FFFFFF ctermbg=241 ctermfg=231 | syn cluster cssColors add=cssColor6b8e23
-  hi cssColor708090 guibg=#708090 guifg=#000000 ctermbg=66  ctermfg=16  | syn cluster cssColors add=cssColor708090
-  hi cssColor778899 guibg=#778899 guifg=#000000 ctermbg=102 ctermfg=16  | syn cluster cssColors add=cssColor778899
-  hi cssColor7b68ee guibg=#7B68EE guifg=#000000 ctermbg=12  ctermfg=16  | syn cluster cssColors add=cssColor7b68ee
-  hi cssColor7cfc00 guibg=#7CFC00 guifg=#000000 ctermbg=3   ctermfg=16  | syn cluster cssColors add=cssColor7cfc00
-  hi cssColor7fff00 guibg=#7FFF00 guifg=#000000 ctermbg=3   ctermfg=16  | syn cluster cssColors add=cssColor7fff00
-  hi cssColor7fffd4 guibg=#7FFFD4 guifg=#000000 ctermbg=122 ctermfg=16  | syn cluster cssColors add=cssColor7fffd4
-  hi cssColor800000 guibg=#800000 guifg=#FFFFFF ctermbg=88  ctermfg=231 | syn cluster cssColors add=cssColor800000
-  hi cssColor800080 guibg=#800080 guifg=#FFFFFF ctermbg=240 ctermfg=231 | syn cluster cssColors add=cssColor800080
-  hi cssColor808000 guibg=#808000 guifg=#FFFFFF ctermbg=240 ctermfg=231 | syn cluster cssColors add=cssColor808000
-  hi cssColor808080 guibg=#808080 guifg=#000000 ctermbg=244 ctermfg=16  | syn cluster cssColors add=cssColor808080
-  hi cssColor87ceeb guibg=#87CEEB guifg=#000000 ctermbg=117 ctermfg=16  | syn cluster cssColors add=cssColor87ceeb
-  hi cssColor87cefa guibg=#87CEFA guifg=#000000 ctermbg=117 ctermfg=16  | syn cluster cssColors add=cssColor87cefa
-  hi cssColor8a2be2 guibg=#8A2BE2 guifg=#FFFFFF ctermbg=12  ctermfg=231 | syn cluster cssColors add=cssColor8a2be2
-  hi cssColor8b0000 guibg=#8B0000 guifg=#FFFFFF ctermbg=88  ctermfg=231 | syn cluster cssColors add=cssColor8b0000
-  hi cssColor8b008b guibg=#8B008B guifg=#FFFFFF ctermbg=5   ctermfg=231 | syn cluster cssColors add=cssColor8b008b
-  hi cssColor8b4513 guibg=#8B4513 guifg=#FFFFFF ctermbg=94  ctermfg=231 | syn cluster cssColors add=cssColor8b4513
-  hi cssColor8fbc8f guibg=#8FBC8F guifg=#000000 ctermbg=108 ctermfg=16  | syn cluster cssColors add=cssColor8fbc8f
-  hi cssColor90ee90 guibg=#90EE90 guifg=#000000 ctermbg=249 ctermfg=16  | syn cluster cssColors add=cssColor90ee90
-  hi cssColor9370d8 guibg=#9370D8 guifg=#000000 ctermbg=12  ctermfg=16  | syn cluster cssColors add=cssColor9370d8
-  hi cssColor9400d3 guibg=#9400D3 guifg=#FFFFFF ctermbg=5   ctermfg=231 | syn cluster cssColors add=cssColor9400d3
-  hi cssColor98fb98 guibg=#98FB98 guifg=#000000 ctermbg=250 ctermfg=16  | syn cluster cssColors add=cssColor98fb98
-  hi cssColor9932cc guibg=#9932CC guifg=#FFFFFF ctermbg=5   ctermfg=231 | syn cluster cssColors add=cssColor9932cc
-  hi cssColor9acd32 guibg=#9ACD32 guifg=#000000 ctermbg=3   ctermfg=16  | syn cluster cssColors add=cssColor9acd32
-  hi cssColora0522d guibg=#A0522D guifg=#FFFFFF ctermbg=130 ctermfg=231 | syn cluster cssColors add=cssColora0522d
-  hi cssColora52a2a guibg=#A52A2A guifg=#FFFFFF ctermbg=124 ctermfg=231 | syn cluster cssColors add=cssColora52a2a
-  hi cssColora9a9a9 guibg=#A9A9A9 guifg=#000000 ctermbg=248 ctermfg=16  | syn cluster cssColors add=cssColora9a9a9
-  hi cssColoradd8e6 guibg=#ADD8E6 guifg=#000000 ctermbg=152 ctermfg=16  | syn cluster cssColors add=cssColoradd8e6
-  hi cssColoradff2f guibg=#ADFF2F guifg=#000000 ctermbg=3   ctermfg=16  | syn cluster cssColors add=cssColoradff2f
-  hi cssColorafeeee guibg=#AFEEEE guifg=#000000 ctermbg=159 ctermfg=16  | syn cluster cssColors add=cssColorafeeee
-  hi cssColorb0c4de guibg=#B0C4DE guifg=#000000 ctermbg=152 ctermfg=16  | syn cluster cssColors add=cssColorb0c4de
-  hi cssColorb0e0e6 guibg=#B0E0E6 guifg=#000000 ctermbg=152 ctermfg=16  | syn cluster cssColors add=cssColorb0e0e6
-  hi cssColorb22222 guibg=#B22222 guifg=#FFFFFF ctermbg=124 ctermfg=231 | syn cluster cssColors add=cssColorb22222
-  hi cssColorb8860b guibg=#B8860B guifg=#000000 ctermbg=3   ctermfg=16  | syn cluster cssColors add=cssColorb8860b
-  hi cssColorba55d3 guibg=#BA55D3 guifg=#000000 ctermbg=5   ctermfg=16  | syn cluster cssColors add=cssColorba55d3
-  hi cssColorbc8f8f guibg=#BC8F8F guifg=#000000 ctermbg=138 ctermfg=16  | syn cluster cssColors add=cssColorbc8f8f
-  hi cssColorbdb76b guibg=#BDB76B guifg=#000000 ctermbg=247 ctermfg=16  | syn cluster cssColors add=cssColorbdb76b
-  hi cssColorc0c0c0 guibg=#C0C0C0 guifg=#000000 ctermbg=250 ctermfg=16  | syn cluster cssColors add=cssColorc0c0c0
-  hi cssColorc71585 guibg=#C71585 guifg=#FFFFFF ctermbg=5   ctermfg=231 | syn cluster cssColors add=cssColorc71585
-  hi cssColorcd5c5c guibg=#CD5C5C guifg=#000000 ctermbg=167 ctermfg=16  | syn cluster cssColors add=cssColorcd5c5c
-  hi cssColorcd853f guibg=#CD853F guifg=#000000 ctermbg=173 ctermfg=16  | syn cluster cssColors add=cssColorcd853f
-  hi cssColord2691e guibg=#D2691E guifg=#000000 ctermbg=166 ctermfg=16  | syn cluster cssColors add=cssColord2691e
-  hi cssColord2b48c guibg=#D2B48C guifg=#000000 ctermbg=180 ctermfg=16  | syn cluster cssColors add=cssColord2b48c
-  hi cssColord3d3d3 guibg=#D3D3D3 guifg=#000000 ctermbg=252 ctermfg=16  | syn cluster cssColors add=cssColord3d3d3
-  hi cssColord87093 guibg=#D87093 guifg=#000000 ctermbg=168 ctermfg=16  | syn cluster cssColors add=cssColord87093
-  hi cssColord8bfd8 guibg=#D8BFD8 guifg=#000000 ctermbg=252 ctermfg=16  | syn cluster cssColors add=cssColord8bfd8
-  hi cssColorda70d6 guibg=#DA70D6 guifg=#000000 ctermbg=249 ctermfg=16  | syn cluster cssColors add=cssColorda70d6
-  hi cssColordaa520 guibg=#DAA520 guifg=#000000 ctermbg=3   ctermfg=16  | syn cluster cssColors add=cssColordaa520
-  hi cssColordc143c guibg=#DC143C guifg=#FFFFFF ctermbg=161 ctermfg=231 | syn cluster cssColors add=cssColordc143c
-  hi cssColordcdcdc guibg=#DCDCDC guifg=#000000 ctermbg=253 ctermfg=16  | syn cluster cssColors add=cssColordcdcdc
-  hi cssColordda0dd guibg=#DDA0DD guifg=#000000 ctermbg=182 ctermfg=16  | syn cluster cssColors add=cssColordda0dd
-  hi cssColordeb887 guibg=#DEB887 guifg=#000000 ctermbg=180 ctermfg=16  | syn cluster cssColors add=cssColordeb887
-  hi cssColore0ffff guibg=#E0FFFF guifg=#000000 ctermbg=195 ctermfg=16  | syn cluster cssColors add=cssColore0ffff
-  hi cssColore6e6fa guibg=#E6E6FA guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColore6e6fa
-  hi cssColore9967a guibg=#E9967A guifg=#000000 ctermbg=174 ctermfg=16  | syn cluster cssColors add=cssColore9967a
-  hi cssColoree82ee guibg=#EE82EE guifg=#000000 ctermbg=251 ctermfg=16  | syn cluster cssColors add=cssColoree82ee
-  hi cssColoreee8aa guibg=#EEE8AA guifg=#000000 ctermbg=223 ctermfg=16  | syn cluster cssColors add=cssColoreee8aa
-  hi cssColorf08080 guibg=#F08080 guifg=#000000 ctermbg=210 ctermfg=16  | syn cluster cssColors add=cssColorf08080
-  hi cssColorf0e68c guibg=#F0E68C guifg=#000000 ctermbg=222 ctermfg=16  | syn cluster cssColors add=cssColorf0e68c
-  hi cssColorf0f8ff guibg=#F0F8FF guifg=#000000 ctermbg=15  ctermfg=16  | syn cluster cssColors add=cssColorf0f8ff
-  hi cssColorf0fff0 guibg=#F0FFF0 guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorf0fff0
-  hi cssColorf0ffff guibg=#F0FFFF guifg=#000000 ctermbg=15  ctermfg=16  | syn cluster cssColors add=cssColorf0ffff
-  hi cssColorf4a460 guibg=#F4A460 guifg=#000000 ctermbg=215 ctermfg=16  | syn cluster cssColors add=cssColorf4a460
-  hi cssColorf5deb3 guibg=#F5DEB3 guifg=#000000 ctermbg=223 ctermfg=16  | syn cluster cssColors add=cssColorf5deb3
-  hi cssColorf5f5dc guibg=#F5F5DC guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorf5f5dc
-  hi cssColorf5f5f5 guibg=#F5F5F5 guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorf5f5f5
-  hi cssColorf5fffa guibg=#F5FFFA guifg=#000000 ctermbg=15  ctermfg=16  | syn cluster cssColors add=cssColorf5fffa
-  hi cssColorf8f8ff guibg=#F8F8FF guifg=#000000 ctermbg=15  ctermfg=16  | syn cluster cssColors add=cssColorf8f8ff
-  hi cssColorfa8072 guibg=#FA8072 guifg=#000000 ctermbg=209 ctermfg=16  | syn cluster cssColors add=cssColorfa8072
-  hi cssColorfaebd7 guibg=#FAEBD7 guifg=#000000 ctermbg=7   ctermfg=16  | syn cluster cssColors add=cssColorfaebd7
-  hi cssColorfaf0e6 guibg=#FAF0E6 guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorfaf0e6
-  hi cssColorfafad2 guibg=#FAFAD2 guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorfafad2
-  hi cssColorfdf5e6 guibg=#FDF5E6 guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorfdf5e6
-  hi cssColorff0000 guibg=#FF0000 guifg=#FFFFFF ctermbg=196 ctermfg=231 | syn cluster cssColors add=cssColorff0000
-  hi cssColorff00ff guibg=#FF00FF guifg=#FFFFFF ctermbg=13  ctermfg=231 | syn cluster cssColors add=cssColorff00ff
-  hi cssColorff1493 guibg=#FF1493 guifg=#FFFFFF ctermbg=5   ctermfg=231 | syn cluster cssColors add=cssColorff1493
-  hi cssColorff4500 guibg=#FF4500 guifg=#FFFFFF ctermbg=9   ctermfg=231 | syn cluster cssColors add=cssColorff4500
-  hi cssColorff6347 guibg=#FF6347 guifg=#000000 ctermbg=203 ctermfg=16  | syn cluster cssColors add=cssColorff6347
-  hi cssColorff69b4 guibg=#FF69B4 guifg=#000000 ctermbg=205 ctermfg=16  | syn cluster cssColors add=cssColorff69b4
-  hi cssColorff7f50 guibg=#FF7F50 guifg=#000000 ctermbg=209 ctermfg=16  | syn cluster cssColors add=cssColorff7f50
-  hi cssColorff8c00 guibg=#FF8C00 guifg=#000000 ctermbg=3   ctermfg=16  | syn cluster cssColors add=cssColorff8c00
-  hi cssColorffa07a guibg=#FFA07A guifg=#000000 ctermbg=216 ctermfg=16  | syn cluster cssColors add=cssColorffa07a
-  hi cssColorffa500 guibg=#FFA500 guifg=#000000 ctermbg=3   ctermfg=16  | syn cluster cssColors add=cssColorffa500
-  hi cssColorffb6c1 guibg=#FFB6C1 guifg=#000000 ctermbg=217 ctermfg=16  | syn cluster cssColors add=cssColorffb6c1
-  hi cssColorffc0cb guibg=#FFC0CB guifg=#000000 ctermbg=218 ctermfg=16  | syn cluster cssColors add=cssColorffc0cb
-  hi cssColorffd700 guibg=#FFD700 guifg=#000000 ctermbg=11  ctermfg=16  | syn cluster cssColors add=cssColorffd700
-  hi cssColorffdab9 guibg=#FFDAB9 guifg=#000000 ctermbg=223 ctermfg=16  | syn cluster cssColors add=cssColorffdab9
-  hi cssColorffdead guibg=#FFDEAD guifg=#000000 ctermbg=223 ctermfg=16  | syn cluster cssColors add=cssColorffdead
-  hi cssColorffe4b5 guibg=#FFE4B5 guifg=#000000 ctermbg=223 ctermfg=16  | syn cluster cssColors add=cssColorffe4b5
-  hi cssColorffe4c4 guibg=#FFE4C4 guifg=#000000 ctermbg=224 ctermfg=16  | syn cluster cssColors add=cssColorffe4c4
-  hi cssColorffe4e1 guibg=#FFE4E1 guifg=#000000 ctermbg=224 ctermfg=16  | syn cluster cssColors add=cssColorffe4e1
-  hi cssColorffebcd guibg=#FFEBCD guifg=#000000 ctermbg=7   ctermfg=16  | syn cluster cssColors add=cssColorffebcd
-  hi cssColorffefd5 guibg=#FFEFD5 guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorffefd5
-  hi cssColorfff0f5 guibg=#FFF0F5 guifg=#000000 ctermbg=15  ctermfg=16  | syn cluster cssColors add=cssColorfff0f5
-  hi cssColorfff5ee guibg=#FFF5EE guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorfff5ee
-  hi cssColorfff8dc guibg=#FFF8DC guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorfff8dc
-  hi cssColorfffacd guibg=#FFFACD guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorfffacd
-  hi cssColorfffaf0 guibg=#FFFAF0 guifg=#000000 ctermbg=15  ctermfg=16  | syn cluster cssColors add=cssColorfffaf0
-  hi cssColorfffafa guibg=#FFFAFA guifg=#000000 ctermbg=15  ctermfg=16  | syn cluster cssColors add=cssColorfffafa
-  hi cssColorffff00 guibg=#FFFF00 guifg=#000000 ctermbg=11  ctermfg=16  | syn cluster cssColors add=cssColorffff00
-  hi cssColorffffe0 guibg=#FFFFE0 guifg=#000000 ctermbg=255 ctermfg=16  | syn cluster cssColors add=cssColorffffe0
-  hi cssColorfffff0 guibg=#FFFFF0 guifg=#000000 ctermbg=15  ctermfg=16  | syn cluster cssColors add=cssColorfffff0
-  hi cssColorffffff guibg=#FFFFFF guifg=#000000 ctermbg=231 ctermfg=16  | syn cluster cssColors add=cssColorffffff
-
-  " w3c Colors
-  syn keyword cssColor000000 black   contained
-  syn keyword cssColorc0c0c0 silver  contained
-  syn keyword cssColor808080 gray    contained
-  syn match cssColorffffff "\<white\(-\)\@!\>" contained
-  syn keyword cssColor800000 maroon  contained
-  syn keyword cssColorff0000 red     contained
-  syn keyword cssColor800080 purple  contained
-  syn keyword cssColorff00ff fuchsia contained
-  syn keyword cssColor008000 green   contained
-  syn keyword cssColor00ff00 lime    contained
-  syn keyword cssColor808000 olive   contained
-  syn keyword cssColorffff00 yellow  contained
-  syn keyword cssColor000080 navy    contained
-  syn keyword cssColor0000ff blue    contained
-  syn keyword cssColor008080 teal    contained
-  syn keyword cssColor00ffff aqua    contained
-
-  " extra colors
-  syn keyword cssColorf0f8ff AliceBlue            contained
-  syn keyword cssColorfaebd7 AntiqueWhite         contained
-  syn keyword cssColor7fffd4 Aquamarine           contained
-  syn keyword cssColorf0ffff Azure                contained
-  syn keyword cssColorf5f5dc Beige                contained
-  syn keyword cssColorffe4c4 Bisque               contained
-  syn keyword cssColorffebcd BlanchedAlmond       contained
-  syn keyword cssColor8a2be2 BlueViolet           contained
-  syn keyword cssColora52a2a Brown                contained
-  syn keyword cssColordeb887 BurlyWood            contained
-  syn keyword cssColor5f9ea0 CadetBlue            contained
-  syn keyword cssColor7fff00 Chartreuse           contained
-  syn keyword cssColord2691e Chocolate            contained
-  syn keyword cssColorff7f50 Coral                contained
-  syn keyword cssColor6495ed CornflowerBlue       contained
-  syn keyword cssColorfff8dc Cornsilk             contained
-  syn keyword cssColordc143c Crimson              contained
-  syn keyword cssColor00ffff Cyan                 contained
-  syn keyword cssColor00008b DarkBlue             contained
-  syn keyword cssColor008b8b DarkCyan             contained
-  syn keyword cssColorb8860b DarkGoldenRod        contained
-  syn keyword cssColora9a9a9 DarkGray             contained
-  syn keyword cssColor006400 DarkGreen            contained
-  syn keyword cssColora9a9a9 DarkGrey             contained
-  syn keyword cssColorbdb76b DarkKhaki            contained
-  syn keyword cssColor8b008b DarkMagenta          contained
-  syn keyword cssColor556b2f DarkOliveGreen       contained
-  syn keyword cssColor9932cc DarkOrchid           contained
-  syn keyword cssColor8b0000 DarkRed              contained
-  syn keyword cssColore9967a DarkSalmon           contained
-  syn keyword cssColor8fbc8f DarkSeaGreen         contained
-  syn keyword cssColor483d8b DarkSlateBlue        contained
-  syn keyword cssColor2f4f4f DarkSlateGray        contained
-  syn keyword cssColor2f4f4f DarkSlateGrey        contained
-  syn keyword cssColor00ced1 DarkTurquoise        contained
-  syn keyword cssColor9400d3 DarkViolet           contained
-  syn keyword cssColorff8c00 Darkorange           contained
-  syn keyword cssColorff1493 DeepPink             contained
-  syn keyword cssColor00bfff DeepSkyBlue          contained
-  syn keyword cssColor696969 DimGray              contained
-  syn keyword cssColor696969 DimGrey              contained
-  syn keyword cssColor1e90ff DodgerBlue           contained
-  syn keyword cssColorb22222 FireBrick            contained
-  syn keyword cssColorfffaf0 FloralWhite          contained
-  syn keyword cssColor228b22 ForestGreen          contained
-  syn keyword cssColordcdcdc Gainsboro            contained
-  syn keyword cssColorf8f8ff GhostWhite           contained
-  syn keyword cssColorffd700 Gold                 contained
-  syn keyword cssColordaa520 GoldenRod            contained
-  syn keyword cssColoradff2f GreenYellow          contained
-  syn keyword cssColor808080 Grey                 contained
-  syn keyword cssColorf0fff0 HoneyDew             contained
-  syn keyword cssColorff69b4 HotPink              contained
-  syn keyword cssColorcd5c5c IndianRed            contained
-  syn keyword cssColor4b0082 Indigo               contained
-  syn keyword cssColorfffff0 Ivory                contained
-  syn keyword cssColorf0e68c Khaki                contained
-  syn keyword cssColore6e6fa Lavender             contained
-  syn keyword cssColorfff0f5 LavenderBlush        contained
-  syn keyword cssColor7cfc00 LawnGreen            contained
-  syn keyword cssColorfffacd LemonChiffon         contained
-  syn keyword cssColoradd8e6 LightBlue            contained
-  syn keyword cssColorf08080 LightCoral           contained
-  syn keyword cssColore0ffff LightCyan            contained
-  syn keyword cssColorfafad2 LightGoldenRodYellow contained
-  syn keyword cssColord3d3d3 LightGray            contained
-  syn keyword cssColor90ee90 LightGreen           contained
-  syn keyword cssColord3d3d3 LightGrey            contained
-  syn keyword cssColorffb6c1 LightPink            contained
-  syn keyword cssColorffa07a LightSalmon          contained
-  syn keyword cssColor20b2aa LightSeaGreen        contained
-  syn keyword cssColor87cefa LightSkyBlue         contained
-  syn keyword cssColor778899 LightSlateGray       contained
-  syn keyword cssColor778899 LightSlateGrey       contained
-  syn keyword cssColorb0c4de LightSteelBlue       contained
-  syn keyword cssColorffffe0 LightYellow          contained
-  syn keyword cssColor32cd32 LimeGreen            contained
-  syn keyword cssColorfaf0e6 Linen                contained
-  syn keyword cssColorff00ff Magenta              contained
-  syn keyword cssColor66cdaa MediumAquaMarine     contained
-  syn keyword cssColor0000cd MediumBlue           contained
-  syn keyword cssColorba55d3 MediumOrchid         contained
-  syn keyword cssColor9370d8 MediumPurple         contained
-  syn keyword cssColor3cb371 MediumSeaGreen       contained
-  syn keyword cssColor7b68ee MediumSlateBlue      contained
-  syn keyword cssColor00fa9a MediumSpringGreen    contained
-  syn keyword cssColor48d1cc MediumTurquoise      contained
-  syn keyword cssColorc71585 MediumVioletRed      contained
-  syn keyword cssColor191970 MidnightBlue         contained
-  syn keyword cssColorf5fffa MintCream            contained
-  syn keyword cssColorffe4e1 MistyRose            contained
-  syn keyword cssColorffe4b5 Moccasin             contained
-  syn keyword cssColorffdead NavajoWhite          contained
-  syn keyword cssColorfdf5e6 OldLace              contained
-  syn keyword cssColor6b8e23 OliveDrab            contained
-  syn keyword cssColorffa500 Orange               contained
-  syn keyword cssColorff4500 OrangeRed            contained
-  syn keyword cssColorda70d6 Orchid               contained
-  syn keyword cssColoreee8aa PaleGoldenRod        contained
-  syn keyword cssColor98fb98 PaleGreen            contained
-  syn keyword cssColorafeeee PaleTurquoise        contained
-  syn keyword cssColord87093 PaleVioletRed        contained
-  syn keyword cssColorffefd5 PapayaWhip           contained
-  syn keyword cssColorffdab9 PeachPuff            contained
-  syn keyword cssColorcd853f Peru                 contained
-  syn keyword cssColorffc0cb Pink                 contained
-  syn keyword cssColordda0dd Plum                 contained
-  syn keyword cssColorb0e0e6 PowderBlue           contained
-  syn keyword cssColorbc8f8f RosyBrown            contained
-  syn keyword cssColor4169e1 RoyalBlue            contained
-  syn keyword cssColor8b4513 SaddleBrown          contained
-  syn keyword cssColorfa8072 Salmon               contained
-  syn keyword cssColorf4a460 SandyBrown           contained
-  syn keyword cssColor2e8b57 SeaGreen             contained
-  syn keyword cssColorfff5ee SeaShell             contained
-  syn keyword cssColora0522d Sienna               contained
-  syn keyword cssColor87ceeb SkyBlue              contained
-  syn keyword cssColor6a5acd SlateBlue            contained
-  syn keyword cssColor708090 SlateGray            contained
-  syn keyword cssColor708090 SlateGrey            contained
-  syn keyword cssColorfffafa Snow                 contained
-  syn keyword cssColor00ff7f SpringGreen          contained
-  syn keyword cssColor4682b4 SteelBlue            contained
-  syn keyword cssColord2b48c Tan                  contained
-  syn keyword cssColord8bfd8 Thistle              contained
-  syn keyword cssColorff6347 Tomato               contained
-  syn keyword cssColor40e0d0 Turquoise            contained
-  syn keyword cssColoree82ee Violet               contained
-  syn keyword cssColorf5deb3 Wheat                contained
-  syn keyword cssColorf5f5f5 WhiteSmoke           contained
-  syn keyword cssColor9acd32 YellowGreen          contained
-
-  let view = winsaveview()
-  %call s:PreviewCSSColorInLine()
-  call winrestview(view)
-
-  autocmd CursorMoved  <buffer> silent call s:PreviewCSSColorInLine()
-  autocmd CursorMovedI <buffer> silent call s:PreviewCSSColorInLine()
-endif

after/syntax/haml.vim

@@ -1,13 +0,0 @@
-" 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

after/syntax/haskell.vim

@@ -0,0 +1,17 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'dhall', 'after/syntax/haskell.vim')
+  finish
+endif
+
+" 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

after/syntax/help.vim

@@ -1,6 +1,16 @@
-let b:current_syntax = ''
-unlet b:current_syntax
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'scala', 'after/syntax/help.vim')
+  finish
+endif
+
+" Extends standard help syntax with highlighting of Scala code.
+"
+" Place code between !sc! and !/sc! delimiters. These will be hidden if Vim is
+" built with conceal support.
+
+unlet! b:current_syntax
+
 syntax include @ScalaCode syntax/scala.vim
+
 if has('conceal')
   syntax region rgnScala matchgroup=Ignore concealends start='!sc!' end='!/sc!' contains=@ScalaCode
 else

after/syntax/html.vim

@@ -1,11 +1,16 @@
-" Language:    CoffeeScript
-" Maintainer:  Mick Koch <kchmck@gmail.com>
-" URL:         http://github.com/kchmck/vim-coffee-script
-" License:     WTFPL
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'html5', 'after/syntax/html.vim')
+  finish
+endif
 
-" 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
+" 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 )
+
+" Comment
+" https://github.com/w3c/html/issues/694
+syntax region htmlComment start=+<!--+ end=+-->+ contains=@Spell
+syntax region htmlComment start=+<!DOCTYPE+ keepend end=+>+

after/syntax/idris.vim

@@ -0,0 +1,82 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'idris', 'after/syntax/idris.vim')
+  finish
+endif
+
+" 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
+

after/syntax/idris2.vim

@@ -0,0 +1,82 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'idris2', 'after/syntax/idris2.vim')
+  finish
+endif
+
+" 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
+

after/syntax/javascript.vim

@@ -0,0 +1,9 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/syntax/javascript.vim')
+  finish
+endif
+
+if get(g:, 'vim_jsx_pretty_disable_js', 0)
+  finish
+endif
+
+source <sfile>:h/jsx.vim

after/syntax/javascript/graphql.vim

@@ -0,0 +1,72 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/syntax/javascript/graphql.vim')
+  finish
+endif
+
+" Copyright (c) 2016-2021 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
+
+let b:graphql_nested_syntax = 1
+syn include @GraphQLSyntax syntax/graphql.vim
+unlet b:graphql_nested_syntax
+
+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 matchgroup=jsTemplateString 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
+
+  syntax region graphqlTemplateString matchgroup=jsTemplateString start=+`#\s\{,4\}\(gql\|graphql\)\>\s*$+ skip=+\\\\\|\\`+ end=+`+ contains=@GraphQLSyntax,jsTemplateExpression,jsSpecial extend
+
+  hi def link graphqlTemplateString jsTemplateString
+  hi def link graphqlTaggedTemplate jsTaggedTemplate
+  hi def link graphqlTemplateExpression jsTemplateExpression
+
+  syn cluster jsExpression add=graphqlTemplateString,graphqlTaggedTemplate
+  syn cluster graphqlTaggedTemplate add=graphqlTemplateString
+elseif graphql#has_syntax_group('javaScriptStringT')
+  " runtime/syntax/javascript.vim
+  exec 'syntax region graphqlTemplateString matchgroup=javaScriptStringT 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
+
+  syntax region graphqlTemplateString matchgroup=javaScriptStringT start=+`#\s\{,4\}\(gql\|graphql\)\>\s*$+ skip=+\\\\\|\\`+ end=+`+ contains=@GraphQLSyntax,javaScriptSpecial,javaScriptEmbed,@htmlPreproc extend
+
+  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

after/syntax/javascript/sql.vim

@@ -0,0 +1,26 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'javascript-sql', 'after/syntax/javascript/sql.vim')
+  finish
+endif
+
+" Vim plugin
+" Language: JavaScript
+" Maintainer: Ian Langworth <ian@langworth.com>
+
+if exists('b:current_syntax')
+  let s:current_syntax = b:current_syntax
+  unlet b:current_syntax
+endif
+
+exec 'syntax include @SQLSyntax syntax/' . g:javascript_sql_dialect . '.vim'
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+syntax region sqlTemplateString start=+`+ skip=+\\\(`\|$\)+ end=+`+ contains=@SQLSyntax,jsTemplateExpression,jsSpecial extend
+exec 'syntax match sqlTaggedTemplate +\%(SQL\)\%(`\)\@=+ nextgroup=sqlTemplateString'
+
+hi def link sqlTemplateString jsTemplateString
+hi def link sqlTaggedTemplate jsTaggedTemplate
+
+syn cluster jsExpression add=sqlTaggedTemplate
+syn cluster sqlTaggedTemplate add=sqlTemplateString

after/syntax/javascriptreact.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/syntax/javascriptreact.vim')
+  finish
+endif
+
+source <sfile>:h/jsx.vim

after/syntax/javascriptreact/graphql.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/syntax/javascriptreact/graphql.vim')
+  finish
+endif
+
+runtime! after/syntax/javascript/graphql.vim

after/syntax/jsx.vim

@@ -0,0 +1,59 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/syntax/jsx.vim')
+  finish
+endif
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" 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

after/syntax/jsx_pretty.vim

@@ -0,0 +1,225 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/syntax/jsx_pretty.vim')
+  finish
+endif
+
+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\|\s*\<T\>\)\@!\<[_$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+ extend 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

after/syntax/llvm.vim

@@ -0,0 +1,26 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'llvm', 'after/syntax/llvm.vim')
+  finish
+endif
+
+" 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\+\>/

after/syntax/mdx.vim

@@ -0,0 +1,45 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'mdx', 'after/syntax/mdx.vim')
+  finish
+endif
+
+
+" based on mxw/vim-jsx
+
+if exists('b:current_syntax')
+  let s:current_syntax=b:current_syntax
+  unlet b:current_syntax
+endif
+syn include @XMLSyntax syntax/xml.vim
+if exists('s:current_syntax')
+  let b:current_syntax=s:current_syntax
+endif
+
+" 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=@Spell,@XMLSyntax,jsxRegion,jsxChild,jsBlock,javascriptBlock
+  \ start=+\%(<\|\w\)\@<!<\z([a-zA-Z][a-zA-Z0-9:\-.]*\)+
+  \ skip=+<!--\_.\{-}-->+
+  \ end=+</\z1\_\s\{-}>+
+  \ end=+/>+
+  \ keepend
+  \ extend
+
+" Add jsxRegion to the lowest-level JS syntax cluster.
+syn cluster jsExpression add=jsxRegion
+
+" Allow jsxRegion to contain reserved words.
+syn cluster javascriptNoReserved add=jsxRegion

after/syntax/objc.vim

@@ -0,0 +1,23 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'objc', 'after/syntax/objc.vim')
+  finish
+endif
+
+" ARC type modifiers
+syn keyword objcTypeModifier __bridge __bridge_retained __bridge_transfer __autoreleasing __strong __weak __unsafe_unretained
+
+" Block modifiers
+syn keyword objcTypeModifier __block
+
+" Remote messaging modifiers
+syn keyword objcTypeModifier byref
+
+" Property keywords - these are only highlighted inside '@property (...)'
+syn keyword objcPropertyAttribute contained getter setter readwrite readonly strong weak copy assign retain nonatomic
+syn match objcProperty display "^\s*@property\>\s*([^)]*)" contains=objcPropertyAttribute
+
+" The @property directive must be defined after objcProperty or it won't be
+" highlighted
+syn match objcDirective "@property\|@synthesize\|@dynamic\|@package"
+
+" Highlight property attributes as if they were type modifiers
+hi def link objcPropertyAttribute objcTypeModifier

after/syntax/php/graphql.vim

@@ -0,0 +1,42 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/syntax/php/graphql.vim')
+  finish
+endif
+
+" Copyright (c) 2016-2021 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
+
+let b:graphql_nested_syntax = 1
+syn include @GraphQLSyntax syntax/graphql.vim
+unlet b:graphql_nested_syntax
+
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+syn region phpHereDoc matchgroup=Delimiter start="\(<<<\)\@<=\(\"\=\)\z(\(\I\i*\)\=\(gql\)\c\(\i*\)\)\2$" end="^\s*\z1\>" contained contains=@GraphQLSyntax,phpIdentifier,phpIdentifierSimply,phpIdentifierComplex,phpBackslashSequences,phpMethodsVar,@Spell keepend extend
+syntax region phpNowDoc matchgroup=Delimiter start="\(<<<\)\@<='\z(\(\I\i*\)\=\(gql\)\c\(\i*\)\)'$" end="^\s*\z1\>" contained contains=@GraphQLSyntax,@Spell keepend extend

after/syntax/puppet.vim

@@ -0,0 +1,28 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'yard', 'after/syntax/puppet.vim')
+  finish
+endif
+
+" Puppet syntax extensions for highlighting YARD documentation.
+"
+" Author: Gabriel Filion <gabster@lelutin.ca>
+" URI: https://github.com/noprompt/vim-yardoc
+" Version: 0.0.1
+"
+" This file reuses the main yardoc syntax definitions and glues them together
+" with puppet syntax groups from vim-puppet
+
+runtime! after/syntax/yardoc_support.vim
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Yard glue to puppet
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+syn match  puppetComment "\s*#.*$" contains=puppetTodo,@Spell,yardComment
+syn region puppetComment start="/\*" end="\*/" contains=puppetTodo,@Spell,yardComment extend fold keepend
+syn cluster puppetNotTop add=@yardTags,@yardDirectives,@yardTypes,@yardLists,@yardHashes
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Tacking on Yard to puppet syntax classes
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+hi def link yardComment puppetComment
+hi def link yardGenericTag puppetKeyword
+hi def link yardGenericDirective puppetKeyword

after/syntax/reason.vim

@@ -0,0 +1,4 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'reason', 'after/syntax/reason.vim')
+  finish
+endif
+

after/syntax/reason/graphql.vim

@@ -0,0 +1,42 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/syntax/reason/graphql.vim')
+  finish
+endif
+
+" Copyright (c) 2016-2021 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
+
+let b:graphql_nested_syntax = 1
+syn include @GraphQLSyntax syntax/graphql.vim
+unlet b:graphql_nested_syntax
+
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+syntax region graphqlExtensionPoint start=+\[%\(graphql\|relay\)+ end=+\]+ contains=graphqlExtensionPointS
+syntax region graphqlExtensionPointS matchgroup=String start=+{|+ end=+|}+ contains=@GraphQLSyntax contained

after/syntax/rescript/graphql.vim

@@ -0,0 +1,42 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/syntax/rescript/graphql.vim')
+  finish
+endif
+
+" Copyright (c) 2016-2021 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
+
+let b:graphql_nested_syntax = 1
+syn include @GraphQLSyntax syntax/graphql.vim
+unlet b:graphql_nested_syntax
+
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+syntax region graphqlExtensionPoint start=+%\(graphql\|relay\)(+ end=+)+ contains=graphqlExtensionPointS
+syntax region graphqlExtensionPointS matchgroup=String start=+`+ end=+`+ contains=@GraphQLSyntax contained

after/syntax/rspec.vim

@@ -1,3 +1,7 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'rspec', 'after/syntax/rspec.vim')
+  finish
+endif
+
 "
 " An rspec syntax file
 " Originally from http://www.vim.org/scripts/script.php?script_id=2286
@@ -7,26 +11,183 @@
 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/ruby.vim

@@ -1,20 +1,28 @@
-" This file describes a very basic syntax for TomDoc comments in a Ruby file.
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'yard', 'after/syntax/ruby.vim')
+  finish
+endif
+
+" Ruby syntax extensions for highlighting YARD documentation.
 "
-" For more information on TomDoc, check it out here: http://tomdoc.org/
+" Author: Joel Holdbrooks <https://github.com/noprompt>
+" URI: https://github.com/noprompt/vim-yardoc
+" Version: 0.0.1
 "
+" This file reuses the main yardoc syntax definitions and glues them together
+" with Vim's builtin ruby syntax groups
 
-syn keyword tomdocKeywords Returns containedin=rubyComment contained
-syn keyword tomdocKeywords Yields containedin=rubyComment contained
-syn keyword tomdocKeywords Raises containedin=rubyComment contained
-syn keyword tomdocKeywords Examples containedin=rubyComment contained
-syn keyword tomdocKeywords Signature containedin=rubyComment contained
+runtime! after/syntax/yardoc_support.vim
 
-syn match tomdocArguments +\s*[A-Za-z0-9_\-&\*:]*\(\s*- \)+he=e-3 containedin=rubyComment contained
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Yard glue to ruby
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+syn match rubyComment "#.*" contains=rubySharpBang,rubySpaceError,rubyTodo,@Spell,yardComment
+syn region rubyMultilineComment start="\%(\%(^\s*#.*\n\)\@<!\%(^\s*#.*\n\)\)\%(\(^\s*#.*\n\)\{1,}\)\@=" end="\%(^\s*#.*\n\)\@<=\%(^\s*#.*\n\)\%(^\s*#\)\@!" contains=rubyComment transparent fold keepend
+syn cluster rubyNotTop add=@yardTags,@yardDirectives,@yardTypes,@yardLists,@yardHashes
 
-syn match tomdocDescriptions +\s*Public:+he=e-1 containedin=rubyComment contained
-syn match tomdocDescriptions +\s*Internal:+he=e-1 containedin=rubyComment contained
-syn match tomdocDescriptions +\s*Deprecated:+he=e-1 containedin=rubyComment contained
-
-hi default link tomdocDescriptions String
-hi default link tomdocKeywords String
-hi default link tomdocArguments HELP
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Tacking on Yard to ruby syntax classes
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+hi def link yardComment rubyComment
+hi def link yardGenericTag rubyKeyword
+hi def link yardGenericDirective rubyKeyword

after/syntax/rust.vim

@@ -1,10 +1,16 @@
-if !exists('g:rust_conceal') || !has('conceal') || &enc != 'utf-8'
-	finish
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'rust', 'after/syntax/rust.vim')
+  finish
+endif
+
+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')
-	syn match rustNiceOperator "::" conceal cchar=ㆍ
+if get(g:, 'rust_conceal_mod_path', 0)
+    syn match rustNiceOperator "::" conceal cchar=ㆍ
 endif
 
 syn match rustRightArrowHead contained ">" conceal cchar= 
@@ -18,7 +24,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')
+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
@@ -26,8 +32,14 @@ endif
 
 hi link rustNiceOperator Operator
 
-if !exists('g:rust_conceal_mod_path')
+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
 
-setlocal conceallevel=2
+" vim: set et sw=4 sts=4 ts=8:

after/syntax/sass.vim

@@ -1 +0,0 @@
-syn cluster sassCssAttributes add=@cssColors

after/syntax/stylus.vim

@@ -1 +0,0 @@
-syn cluster stylusCssAttributes add=@cssColors

after/syntax/tsx.vim

@@ -0,0 +1,63 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/syntax/tsx.vim')
+  finish
+endif
+
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" 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

after/syntax/typescript/graphql.vim

@@ -0,0 +1,62 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/syntax/typescript/graphql.vim')
+  finish
+endif
+
+" Copyright (c) 2016-2021 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
+
+let b:graphql_nested_syntax = 1
+syn include @GraphQLSyntax syntax/graphql.vim
+unlet b:graphql_nested_syntax
+
+if exists('s:current_syntax')
+  let b:current_syntax = s:current_syntax
+endif
+
+let s:tags = '\%(' . join(graphql#javascript_tags(), '\|') . '\)'
+
+exec 'syntax region graphqlTemplateString matchgroup=typescriptTemplate 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
+
+" support #graphql , #gql comment strings
+syntax region graphqlTemplateString
+      \ start=+`\(#\s\{,4\}\(gql\|graphql\)\)\@=+
+      \ skip=+\\\\\|\\`+
+      \ end=+`+me=s-1
+      \ containedin=typescriptTemplate
+      \ contained
+      \ contains=@GraphQLSyntax,typescriptTemplateSubstitution extend
+
+hi def link graphqlTemplateString typescriptTemplate
+hi def link graphqlTemplateExpression typescriptTemplateSubstitution
+
+syn cluster typescriptExpression add=graphqlTaggedTemplate
+syn cluster graphqlTaggedTemplate add=graphqlTemplateString

after/syntax/typescriptreact.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'jsx', 'after/syntax/typescriptreact.vim')
+  finish
+endif
+
+source <sfile>:h/tsx.vim

after/syntax/typescriptreact/graphql.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/syntax/typescriptreact/graphql.vim')
+  finish
+endif
+
+runtime! after/syntax/typescript/graphql.vim

after/syntax/vue/graphql.vim

@@ -0,0 +1,5 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'graphql', 'after/syntax/vue/graphql.vim')
+  finish
+endif
+
+runtime! after/syntax/javascript/graphql.vim

after/syntax/yardoc_support.vim

@@ -0,0 +1,128 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'yard', 'after/syntax/yardoc_support.vim')
+  finish
+endif
+
+" Generic syntax extensions for highlighting YARD documentation.
+"
+" Author: Joel Holdbrooks <https://github.com/noprompt>
+" URI: https://github.com/noprompt/vim-yardoc
+" Version: 0.0.1
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Tags
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+syn match yardGenericTag "@\h\+" contained
+syn match yardAbstract "@abstract" contained
+syn match yardApi "@api" contained
+syn match yardAttr "@attr" contained
+syn match yardAttrReader "@attr_reader" contained
+syn match yardAttrWriter "@attr_writer" contained
+syn match yardAuthor "@author" contained
+syn match yardDeprecated "@deprecated" contained
+syn match yardExample "@example" contained
+syn match yardNote "@note" contained
+syn match yardOption "@option" contained
+syn match yardOverload "@overload" contained
+syn match yardParam "@param" contained
+syn match yardParamName /@param \h\+/hs=s+7 contained contains=yardParam
+syn match yardPrivate "@private" contained
+syn match yardRaise "@raise" contained
+syn match yardReturn "@return" contained
+syn match yardSee "@see" contained
+syn match yardSince "@since" contained
+syn match yardTodo "@todo" contained
+syn match yardVersion "@version" contained
+syn match yardYield "@yield" contained
+syn match yardYieldParam "@yieldparam" contained
+syn match yardYieldReturn "@yieldreturn" contained
+syn cluster yardTags contains=yardGenericTag,yardAbstract,yardApi,yardAttr,yardAttrReader,yardAttrWriter,yardAuthor,yardDeprecated,yardExample,yardNote,yardOption,yardOverload,yardParam,yardParamName,yardPrivate,yardRaise,yardReturn,yardSee,yardSince,yardTodo,yardVersion,yardYield,yardYieldParam,yardYieldReturn
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Directives
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+syn match yardGenericDirective "@!\h\+" contained
+syn match yardAttribute "@!attribute" contained
+syn match yardEndGroup "@!endgroup" contained
+syn match yardGroup "@!group" contained
+syn match yardMacro "@!macro" contained
+syn match yardMethod "@!method" contained
+syn match yardParse "@!parse" contained
+syn match yardScope "@!scope" contained
+syn match yardVisibility "@!visibility" contained
+
+syn cluster yardDirectives contains=yardGenericDirective,yardAttribute,yardEndGroup,yardGroup,yardMacro,yardMethod,yardParse,yardScope,yardVisibility
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Types, Lists, and Hashes
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+syn match yardDuckType "#\h\+" contained
+syn match yardType "[A-Z]\h\+" contained
+syn match yardLiteral "\(true\|false\|nil\|self\|void\)" contained
+syn match yardComma "," nextgroup=@yardTypes contained
+syn match yardArrow "=>" nextgroup=@yardTypes contained
+
+syn region yardParametricType start="[A-Z]\+\h\+<" end=">" contains=yardType,yardOrderDependentList,yardComma skipwhite contained
+syn region yardOrderDependentList start="(" end=")" contains=@yardTypes,yardComma skipwhite contained
+syn region yardTypeList start="\[" end="]" contains=@yardTypes,yardOrderDependentList,@yardHashes skipwhite contained
+syn region yardHashAngle start="Hash<" end=">" contains=yardDuckType,yardType,yardLiteral,yardArrow,yardComma skipwhite contained
+syn region yardHashCurly start="Hash{" end="}" contains=@yardTypes,yardArrow,yardComma skipwhite contained
+
+syn cluster yardTypes contains=yardDuckType,yardType,yardLiteral,yardParametricType
+syn cluster yardHashes contains=yardArrow,yardHashAngle,yardHashCurly
+syn cluster yardLists contains=yardComma,yardTypeList,yardOrderDependentList
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Yard
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+syn match yardComment "#\s*@!\{,1}\h\+.*" contains=@yardTags,@yardDirectives,yardTypeList
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" Links
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" @note The links to language syntax classes is done in each language syntax
+"   script.
+"
+" Tags
+hi def link yardAbstract yardGenericTag
+hi def link yardApi yardGenericTag
+hi def link yardAttr yardGenericTag
+hi def link yardAttrReader yardGenericTag
+hi def link yardAttrWriter yardGenericTag
+hi def link yardAuthor yardGenericTag
+hi def link yardDeprecated yardGenericTag
+hi def link yardExample yardGenericTag
+hi def link yardNote yardGenericTag
+hi def link yardOption yardGenericTag
+hi def link yardOverload yardGenericTag
+hi def link yardParam yardGenericTag
+hi def link yardPrivate yardGenericTag
+hi def link yardRaise yardGenericTag
+hi def link yardReturn yardGenericTag
+hi def link yardSee yardGenericTag
+hi def link yardSince yardGenericTag
+hi def link yardTodo yardGenericTag
+hi def link yardVersion yardGenericTag
+hi def link yardYield yardGenericTag
+hi def link yardYieldParam yardGenericTag
+hi def link yardYieldReturn yardGenericTag
+" Directives
+hi def link yardAttribute yardGenericDirective
+hi def link yardEndGroup yardGenericDirective
+hi def link yardGroup yardGenericDirective
+hi def link yardMacro yardGenericDirective
+hi def link yardMethod yardGenericDirective
+hi def link yardParse yardGenericDirective
+hi def link yardScope yardGenericDirective
+hi def link yardVisibility yardGenericDirective
+" Types
+hi def link yardComma yardComment
+hi def link yardType yardComment
+hi def link yardDuckType yardComment
+hi def link yardLiteral yardComment
+" Lists
+hi def link yardTypeList yardComment
+hi def link yardParametricType yardComment
+" Hashes
+hi def link yardArrow yardComment
+hi def link yardHashAngle yardComment
+hi def link yardHashCurly yardComment

after/syntax/zsh.vim

@@ -0,0 +1,173 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'zinit', 'after/syntax/zsh.vim')
+  finish
+endif
+
+" Copyright (c) 2019 Sebastian Gniazdowski
+" Copyright (c) 2021 Joakim Gottzén
+"
+" 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.
+syn match ZinitCommand '\(^\|\s\)zinit\s'ms=e-5,me=e-1 skipwhite
+            \ nextgroup=ZinitCommand,ZinitIceCommand,ZinitPluginCommand,ZinitSnippetCommand,ZinitForCommand,ZinitContinue,ZinitIceWithParam,ZinitIce
+
+syn match ZinitCommand '\s\%(help\|man\)\>'ms=s+1 skipwhite contained
+syn match ZinitCommand '\s\%(unload\)\>'ms=s+1 skipwhite contained " load,light and snippet are handled elsewhere
+syn match ZinitCommand '\s\%(clist\|completions\|cdisable\|cenable\|creinstall\|cuninstall\)\>'ms=s+1 skipwhite contained
+syn match ZinitCommand '\s\%(csearch\|compinit\|cclear\|cdlist\|cdreplay\|cdclear\)\>'ms=s+1 skipwhite contained
+syn match ZinitCommand '\s\%(dtrace\|dstart\|dstop\|dunload\|dreport\|dclear\)\>'ms=s+1 skipwhite contained
+syn match ZinitCommand '\s\%(times\|zstatus\|report\|loaded\|list\|ls\|status\|recently\|bindkeys\)\>'ms=s+1 skipwhite contained
+syn match ZinitCommand '\s\%(compile\|uncompile\|compiled\)\>'ms=s+1 skipwhite contained
+syn match ZinitCommand '\s\%(self-update\|update\|delete\|cd\|edit\|glance\|stress\|changes\|create\)\>'ms=s+1 skipwhite contained
+syn match ZinitCommand '\s\%(srv\|recall\|env-whitelist\|module\|add-fpath\|fpath\|run\)\>'ms=s+1 skipwhite contained
+
+syn match ZinitIceCommand '\sice\s'ms=s+1,me=e-1 skipwhite contained nextgroup=ZinitIce,ZinitIceWithParam
+
+syn match ZinitPluginCommand '\s\%(light\|load\)\s'ms=s+1,me=e-1 skipwhite contained nextgroup=ZinitPlugin,ZinitContinue
+
+syn match ZinitSnippetCommand '\s\%(snippet\)\s'ms=s+1,me=e-1 skipwhite contained nextgroup=ZinitSnippet,ZinitContinue
+
+syn match ZinitForCommand '\sfor\s'ms=s+1,me=e-1 skipwhite contained
+            \ nextgroup=ZinitPlugin,ZinitSnippet,ZinitContinue
+
+syn cluster ZinitLine contains=ZinitIce,ZinitIceWithParam,ZinitPlugin,ZinitSnippet,ZinitForCommand
+
+syn match ZinitContinue '\s\\\s*$'ms=s+1,me=s+2 skipwhite contained skipnl
+            \ nextgroup=@ZinitLine
+
+" user/plugin or @user/plugin
+syn match ZinitPlugin '\s@\?\<[a-zA-Z0-9][a-zA-Z0-9_\-]*\/[a-zA-Z0-9_\-\.]\+\>'ms=s+1 skipwhite contained
+            \ nextgroup=ZinitPlugin,ZinitSnippet,ZinitContinue
+
+" shorthands
+syn match ZinitSnippet '\s\%(OMZ[LPT]\?\|PZT[M]\?\)::[a-zA-Z0-9_\-\.\/]\+\>'ms=s+1 skipwhite contained
+            \ nextgroup=ZinitPlugin,ZinitSnippet,ZinitContinue
+" url
+syn match ZinitSnippet '\s\%(http[s]\?\|ftp\):\/\/[[:alnum:]%\/_#.-]*\>'ms=s+1 skipwhite contained
+            \ nextgroup=ZinitPlugin,ZinitSnippet,ZinitContinue
+" "$VAR" local path
+syn match ZinitSnippet +\s"\$\<[a-zA-Z0-9_]\+[^"]*"+ms=s+1 skipwhite contained
+            \ nextgroup=ZinitPlugin,ZinitSnippet,ZinitContinue
+" "${VAR}" local path
+syn match ZinitSnippet +\s"\${\<[a-zA-Z0-9_]\+}[^"]*"+ms=s+1 skipwhite contained
+            \ nextgroup=ZinitPlugin,ZinitSnippet,ZinitContinue
+
+" ices which takes a param enclosed in "
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(proto\|from\|ver\|bpick\|depth\|cloneopts\|pullopts\)"+ skip=+\\"+ end=+"+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceDoubleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(pick\|src\|multisrc\)"+ skip=+\\"+ end=+"+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceDoubleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(wait\|load\|unload\|if\|has\|subscribe\|on-update-of\|trigger-load\)"+ skip=+\\"+ end=+"+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceDoubleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(mv\|cp\|atclone\|atpull\|atinit\|atload\|atdelete\|make\)"+ skip=+\\"+ end=+"+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceDoubleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(as\|id-as\|compile\|nocompile\|service\|bindmap\|wrap-track\)"+ skip=+\\"+ end=+"+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceDoubleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(extract\|subst\|autoload\)"+ skip=+\\"+ end=+"+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceDoubleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(wrap\|ps-on-unload\|ps-on-update\)"+ skip=+\\"+ end=+"+ skipwhite contained
+
+" zinit packages
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(param\)"+ skip=+\\"+ end=+"+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceDoubleQuoteParam
+
+" added by the existing annexes
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(fbin\|lbin\|sbin\|gem\|node\|pip\|fmod\|fsrc\|ferc\)"+ skip=+\\"+ end=+"+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceDoubleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(dl\|patch\|submods\|cargo\|dlink\|dlink0\)"+ skip=+\\"+ end=+"+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceDoubleQuoteParam
+
+syn match ZinitIceDoubleQuoteParam +[^"]*+ contained
+
+" ices that takes a param enclosed in '
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(proto\|from\|ver\|bpick\|depth\|cloneopts\|pullopts\)'+ skip=+\\'+ end=+'+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceSingleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(pick\|src\|multisrc\)'+ skip=+\\'+ end=+'+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceSingleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(wait\|load\|unload\|if\|has\|subscribe\|on-update-of\|trigger-load\)'+ skip=+\\'+ end=+'+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceSingleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(mv\|cp\|atclone\|atpull\|atinit\|atload\|atdelete\|make\)'+ skip=+\\'+ end=+'+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceSingleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(as\|id-as\|compile\|nocompile\|service\|bindmap\|wrap-track\)'+ skip=+\\'+ end=+'+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceSingleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(extract\|subst\|autoload\)'+ skip=+\\'+ end=+'+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceSingleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(wrap\|ps-on-unload\|ps-on-update\)'+ skip=+\\'+ end=+'+ skipwhite contained
+
+" zinit packages
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(param\)'+ skip=+\\'+ end=+'+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceSingleQuoteParam
+
+" added by the existing annexes
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(fbin\|lbin\|sbin\|gem\|node\|pip\|fmod\|fsrc\|ferc\)'+ skip=+\\'+ end=+'+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceSingleQuoteParam
+syn region ZinitIceWithParam matchgroup=ZinitIce start=+\s\%(dl\|patch\|submods\|cargo\|dlink\|dlink0\)'+ skip=+\\'+ end=+'+ skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+            \ contains=ZinitIceSingleQuoteParam
+
+syn match ZinitIceSingleQuoteParam +[^']*+ contained
+
+" ices that doens't take a param
+syn match ZinitIce '\s\%(teleid\|svn\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+syn match ZinitIce '\s\%(wait\|cloneonly\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+syn match ZinitIce '\s\%(silent\|lucid\|notify\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+syn match ZinitIce '\s\%(blockf\|nocompletions\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+syn match ZinitIce '\s\%(run-atpull\|nocd\|make\|countdown\|reset\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+syn match ZinitIce '\s!\?\%(sh\|bash\|ksh\|csh\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+syn match ZinitIce '\s\%(id-as\|nocompile\|reset-prompt\|trackbinds\|aliases\|light-mode\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+syn match ZinitIce '\s\%(is-snippet\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+
+" ices that doens't take a param, from zinit packages
+syn match ZinitIce '\s\%(pack\|git\|null\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+
+" ices that doens't take a param, added by the existing annexes
+syn match ZinitIce '\s\%(notest\|rustup\|default-ice\|skip\|debug\)\>'ms=s+1 skipwhite contained
+            \ nextgroup=@ZinitLine,ZinitContinue
+
+" additional Zsh and zinit functions
+syn match ZshAndZinitFunctions '\<\%(compdef\|compinit\|zpcdreplay\|zpcdclear\|zpcompinit\|zpcompdef\)\>'
+
+" highlights
+hi def link ZinitCommand             Statement
+hi def link ZinitCommand             Title
+hi def link ZinitIceCommand          Title
+hi def link ZinitPluginCommand       Title
+hi def link ZinitSnippetCommand      Title
+hi def link ZinitForCommand          zshRepeat
+hi def link ZinitContinue            Normal
+hi def link ZinitPlugin              Macro
+hi def link ZinitSnippet             Macro
+hi def link ZinitIce                 Type
+hi def link ZinitIceDoubleQuoteParam Special
+hi def link ZinitIceSingleQuoteParam Special
+hi def link ZshAndZinitFunctions     Keyword
+

autoload/LaTeXtoUnicode.vim

@@ -0,0 +1,758 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'julia', 'autoload/LaTeXtoUnicode.vim')
+  finish
+endif
+
+""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+" 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)
+  let b:l2u_enabled = get(b:, "l2u_enabled", 0)
+  let b:l2u_autodetect_enable = get(b:, "l2u_autodetect_enable", 1)
+
+  " Did we install the L2U tab/as-you-type/keymap... mappings?
+  let b:l2u_tab_set = get(b:, "l2u_tab_set", 0)
+  let b:l2u_cmdtab_set = get(b:, "l2u_cmdtab_set", 0)
+  let b:l2u_autosub_set = get(b:, "l2u_autosub_set", 0)
+  let b:l2u_keymap_set = get(b:, "l2u_keymap_set", 0)
+
+  " 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
+  " 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 = "off"
+      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
+
+  " Forcibly get out of completion mode: feed
+  " this string with feedkeys(s:l2u_esc_sequence, 'n')
+  let s:l2u_esc_sequence = " \b"
+
+  " Trigger for the previous mapping of <Tab>
+  let s:l2u_fallback_trigger = "\u0091L2UFallbackTab"
+
+  " Trigger for the previous mapping of <CR>
+  let s:l2u_fallback_trigger_cr = "\u0091L2UFallbackCR"
+
+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
+
+  if has_key(g:, "latex_to_unicode_tab")
+    if g:latex_to_unicode_tab is# 1
+      let g:latex_to_unicode_tab = "on"
+    elseif g:latex_to_unicode_tab is# 0
+      let g:latex_to_unicode_tab = "off"
+    endif
+  endif
+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-2]
+  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
+
+" Completion function. Besides the usual two-stage completefunc 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#completefunc(findstart, base)
+  if a:findstart
+    " first stage
+    " avoid infinite loop if the fallback happens to call completion
+    if b:l2u_in_fallback
+      let b:l2u_in_fallback = 0
+      return -3
+    endif
+    " make sure that the options are still set
+    " (it may happen that <C-X><C-U> itself triggers the fallback before
+    " restarting, thus reseetting them; this happens when the prompt is
+    " waiting for ^U^N^P during a partial completion)
+    call s:L2U_SetCompleteopt()
+    " setup the cleanup/fallback operations when we're done
+    call s:L2U_InsertCompleteDoneAutocommand()
+    call s:L2U_InsertInsertLeaveAutocommand()
+    " 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! LaTeXtoUnicode#PutLiteralCR()
+  call feedkeys('
+', '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).
+" It returns the previous maparg dictionary, so that the previous mapping can
+" be reinstated if needed.
+function! s:L2U_SetFallbackMapping(s, k)
+  let mmdict = maparg(a:s, 'i', 0, 1)
+  if empty(mmdict) || !has_key(mmdict, "rhs")
+    exe 'inoremap <buffer> ' . a:k . ' ' . a:s
+    return mmdict
+  endif
+  let rhs = mmdict["rhs"]
+  if rhs =~# '^<Plug>L2U'
+    return mmdict
+  endif
+  let pre = '<buffer>'
+  let pre = pre . (mmdict["silent"] ? '<silent>' : '')
+  let pre = pre . (mmdict["expr"] ? '<expr>' : '')
+  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. Also, it doesn't work with <CR> since that stops
+    " parsing of the <C-R>=... expression, so we need to special-case it.
+    " Also, if the original mapping was intended to be recursive, this
+    " will break it.
+    if a:s != "<CR>"
+      let rhs = substitute(rhs, '\c' . a:s, "\<C-R>=LaTeXtoUnicode#PutLiteral('" . a:s . "')\<CR>", 'g')
+    else
+      let rhs = substitute(rhs, '\c' . a:s, "\<C-R>=LaTeXtoUnicode#PutLiteralCR()\<CR>", 'g')
+    endif
+    " Make the mapping silent even if it wasn't originally
+    if !mmdict["silent"]
+      let pre = pre . '<silent>'
+    endif
+  endif
+  exe cmd . pre . ' ' . a:k . ' ' . rhs
+  return mmdict
+endfunction
+
+" Reinstate a mapping from the maparg dict returned by SetFallbackMapping
+" (only if buffer-local, since otherwise it should still be available)
+function! s:L2U_ReinstateMapping(mmdict)
+  if empty(a:mmdict) || !a:mmdict["buffer"]
+    return ''
+  endif
+  let lhs = a:mmdict["lhs"]
+  let rhs = a:mmdict["rhs"]
+  if rhs =~# '^<Plug>L2U'
+    return ''
+  endif
+  let pre = '<buffer>'
+  let pre = pre . (a:mmdict["silent"] ? '<silent>' : '')
+  let pre = pre . (a:mmdict["expr"] ? '<expr>' : '')
+  let cmd = a:mmdict["noremap"] ? 'inoremap ' : 'imap '
+  exe cmd . pre . ' ' . lhs . ' ' . 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
+  if pumvisible() && !b:l2u_tab_completing && !s:L2U_ismatch()
+    call feedkeys(s:l2u_fallback_trigger)
+    return ''
+  endif
+  " ensure that we start completion with some reasonable options
+  call s:L2U_SetCompleteopt()
+  " reset the in_fallback info
+  let b:l2u_in_fallback = 0
+  let b:l2u_tab_completing = 1
+  " invoke completion; failure to perform LaTeX-to-Unicode completion is
+  " handled by the CompleteDone autocommand.
+  call feedkeys("\<C-X>\<C-U>", '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()
+  call s:L2U_RemoveCompleteDoneAutocommand()
+  call s:L2U_RestoreCompleteopt()
+  if !b:l2u_tab_completing
+    " completion was not initiated by L2U, nothing to do
+    return
+  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
+
+function! s:L2U_SetCompleteopt()
+  " temporary change completeopt to use settings which make sense
+  " for L2U
+  let backup_new = 0
+  if !exists('b:l2u_backup_completeopt')
+    let b:l2u_backup_completeopt = &completeopt
+    let backup_new = 1
+  endif
+  noautocmd set completeopt+=longest
+  noautocmd set completeopt-=noinsert
+  noautocmd set completeopt-=noselect
+  noautocmd set completeopt-=menuone
+  if backup_new
+    let b:l2u_modified_completeopt = &completeopt
+  endif
+endfunction
+
+function! s:L2U_RestoreCompleteopt()
+  " restore completeopt, but only if nothing else has
+  " messed with it in the meanwhile
+  if exists('b:l2u_backup_completeopt')
+    if exists('b:l2u_modified_completeopt')
+      if &completeopt ==# b:l2u_modified_completeopt
+        noautocmd let &completeopt = b:l2u_backup_completeopt
+      endif
+      unlet b:l2u_modified_completeopt
+    endif
+    unlet b:l2u_backup_completeopt
+  endif
+endfunction
+
+function! s:L2U_InsertCompleteDoneAutocommand()
+  augroup L2UCompleteDone
+    autocmd! * <buffer>
+    " Every time a L2U completion finishes, the fallback may be invoked
+    autocmd CompleteDone <buffer> call LaTeXtoUnicode#FallbackCallback()
+  augroup END
+endfunction
+
+function! s:L2U_RemoveCompleteDoneAutocommand()
+  augroup L2UCompleteDone
+    autocmd! * <buffer>
+  augroup END
+endfunction
+
+function s:L2U_InsertLeaveClenup()
+    call s:L2U_ResetLastCompletionInfo()
+    augroup L2UInsertLeave
+      autocmd! * <buffer>
+    augroup END
+endfunction
+
+function! s:L2U_InsertInsertLeaveAutocommand()
+  augroup L2UInsertLeave
+    autocmd! * <buffer>
+    autocmd InsertLeave <buffer> call s:L2U_InsertLeaveClenup()
+  augroup END
+endfunction
+
+" Setup the L2U tab mapping
+function! s:L2U_SetTab(wait_insert_enter)
+  let opt_do_cmdtab = index(["on", "command", "cmd"], get(g:, "latex_to_unicode_tab", "on")) != -1
+  let opt_do_instab = index(["on", "insert", "ins"], get(g:, "latex_to_unicode_tab", "on")) != -1
+  if !b:l2u_cmdtab_set && opt_do_cmdtab && 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 !opt_do_instab || !b:l2u_enabled
+    return
+  endif
+
+  " Backup the previous completefunc (the check is probably not really needed)
+  if get(b:, "l2u_prev_completefunc", "") != "LaTeXtoUnicode#completefunc"
+    let b:l2u_prev_completefunc = &completefunc
+  endif
+  setlocal completefunc=LaTeXtoUnicode#completefunc
+
+  let b:l2u_prev_map_tab = s:L2U_SetFallbackMapping('<Tab>', s:l2u_fallback_trigger)
+  imap <buffer> <Tab> <Plug>L2UTab
+  inoremap <buffer><expr> <Plug>L2UTab LaTeXtoUnicode#Tab()
+
+  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 completefunc=" . get(b:, "l2u_prev_completefunc", "")
+  iunmap <buffer> <Tab>
+  if empty(maparg("<Tab>", "i"))
+    call s:L2U_ReinstateMapping(b:l2u_prev_map_tab)
+  endif
+  iunmap <buffer> <Plug>L2UTab
+  exe 'iunmap <buffer> ' . s:l2u_fallback_trigger
+  let b:l2u_tab_set = 0
+endfunction
+
+" Function which looks for viable LaTeX-to-Unicode supstitutions as you type
+function! LaTeXtoUnicode#AutoSub(...)
+  " avoid recursive calls
+  if get(b:, "l2u_in_autosub", 0)
+    return ''
+  endif
+  let vc = a:0 == 0 ? v:char : a:1
+  " for some reason function keys seem to be passed as characters 149 (F1-F12)
+  " or 186 (F13-F37, these are entered with shift/ctrl). In such cases, we
+  " can't really do any better than giving up.
+  if char2nr(vc) == 149 || char2nr(vc) == 186
+    return ''
+  endif
+  let b:l2u_in_autosub = 1
+  let col1 = col('.')
+  let lnum = line('.')
+  if col1 == 1
+    if a:0 > 1
+      call feedkeys(a:2, 'mi')
+    endif
+    let b:l2u_in_autosub = 0
+    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, 'mi')
+    endif
+    let b:l2u_in_autosub = 0
+    return ''
+  endif
+  let base = l[col0 : col1-1-bs]
+  let unicode = get(g:l2u_symbols_dict, base, '')
+  if empty(unicode)
+    if a:0 > 1
+      call feedkeys(a:2, 'mi')
+    endif
+    let b:l2u_in_autosub = 0
+    return ''
+  endif
+
+  " perform the substitution, wrapping it in undo breakpoints so that
+  " we can revert it as a whole
+  " at the end, reset the l2u_in_autosub variable without leaving insert mode
+  " the 'i' mode is the only one that works correctly when executing macros
+  " the 'n' mode is to avoid user-defined mappings of \b, <C-G> and <C-\><C-O>
+  call feedkeys("\<C-G>u" .
+             \  repeat("\b", len(base) + bs) . unicode . vc . s:l2u_esc_sequence .
+             \  "\<C-G>u" .
+             \  "\<C-\>\<C-O>:let b:l2u_in_autosub = 0\<CR>",
+             \  'ni')
+  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.
+
+  let b:l2u_prev_map_cr = s:L2U_SetFallbackMapping('<CR>', s:l2u_fallback_trigger_cr)
+  imap <buffer> <CR> <Plug>L2UAutoSub
+  exec 'inoremap <buffer><expr> <Plug>L2UAutoSub LaTeXtoUnicode#AutoSub("\n", "' . s:l2u_fallback_trigger_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>
+  if empty(maparg("<CR>", "i"))
+    call s:L2U_ReinstateMapping(b:l2u_prev_map_cr)
+  endif
+  iunmap <buffer> <Plug>L2UAutoSub
+  exe 'iunmap <buffer> ' . s:l2u_fallback_trigger_cr
+  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 ''

autoload/RstFold.vim

@@ -0,0 +1,66 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'rst', 'autoload/RstFold.vim')
+  finish
+endif
+
+" 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

autoload/ada.vim

@@ -0,0 +1,641 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'ada', 'autoload/ada.vim')
+  finish
+endif
+
+"------------------------------------------------------------------------------
+"  Description: Perform Ada specific completion & tagging.
+"     Language: Ada (2005)
+"	   $Id: ada.vim 887 2008-07-08 14:29:01Z krischik $
+"   Maintainer: Mathias Brousset <mathiasb17@gmail.com>
+"		Martin Krischik <krischik@users.sourceforge.net>
+"		Taylor Venable <taylor@metasyntax.net>
+"		Neil Bird <neil@fnxweb.com>
+"		Ned Okie <nokie@radford.edu>
+"      $Author: krischik $
+"	 $Date: 2017-01-31 20:20:05 +0200 (Mon, 01 Jan 2017) $
+"      Version: 4.6
+"    $Revision: 887 $
+"     $HeadURL: https://gnuada.svn.sourceforge.net/svnroot/gnuada/trunk/tools/vim/autoload/ada.vim $
+"      History: 24.05.2006 MK Unified Headers
+"		26.05.2006 MK ' should not be in iskeyword.
+"		16.07.2006 MK Ada-Mode as vim-ball
+"		02.10.2006 MK Better folding.
+"		15.10.2006 MK Bram's suggestion for runtime integration
+"		05.11.2006 MK Bram suggested not to use include protection for
+"			      autoload
+"		05.11.2006 MK Bram suggested to save on spaces
+"		08.07.2007 TV fix mapleader problems.
+"	        09.05.2007 MK Session just won't work no matter how much
+"			      tweaking is done
+"		19.09.2007 NO still some mapleader problems
+"		31.01.2017 MB fix more mapleader problems
+"    Help Page: ft-ada-functions
+"------------------------------------------------------------------------------
+
+if version < 700
+   finish
+endif 
+let s:keepcpo= &cpo
+set cpo&vim
+
+" Section: Constants {{{1
+"
+let g:ada#DotWordRegex	   = '\a\w*\(\_s*\.\_s*\a\w*\)*'
+let g:ada#WordRegex	   = '\a\w*'
+let g:ada#Comment	   = "\\v^(\"[^\"]*\"|'.'|[^\"']){-}\\zs\\s*--.*"
+let g:ada#Keywords	   = []
+
+" Section: g:ada#Keywords {{{1
+"
+" Section: add Ada keywords {{{2
+"
+for Item in ['abort', 'else', 'new', 'return', 'abs', 'elsif', 'not', 'reverse', 'abstract', 'end', 'null', 'accept', 'entry', 'select', 'access', 'exception', 'of', 'separate', 'aliased', 'exit', 'or', 'subtype', 'all', 'others', 'synchronized', 'and', 'for', 'out', 'array', 'function', 'overriding', 'tagged', 'at', 'task', 'generic', 'package', 'terminate', 'begin', 'goto', 'pragma', 'then', 'body', 'private', 'type', 'if', 'procedure', 'case', 'in', 'protected', 'until', 'constant', 'interface', 'use', 'is', 'raise', 'declare', 'range', 'when', 'delay', 'limited', 'record', 'while', 'delta', 'loop', 'rem', 'with', 'digits', 'renames', 'do', 'mod', 'requeue', 'xor']
+    let g:ada#Keywords += [{
+	    \ 'word':  Item,
+	    \ 'menu':  'keyword',
+	    \ 'info':  'Ada keyword.',
+	    \ 'kind':  'k',
+	    \ 'icase': 1}]
+endfor
+
+" Section: GNAT Project Files {{{3
+"
+if exists ('g:ada_with_gnat_project_files')
+    for Item in ['project']
+       let g:ada#Keywords += [{
+	       \ 'word':  Item,
+	       \ 'menu':  'keyword',
+	       \ 'info':  'GNAT projectfile keyword.',
+	       \ 'kind':  'k',
+	       \ 'icase': 1}]
+    endfor
+endif
+
+" Section: add	standard exception {{{2
+"
+for Item in ['Constraint_Error', 'Program_Error', 'Storage_Error', 'Tasking_Error', 'Status_Error', 'Mode_Error', 'Name_Error', 'Use_Error', 'Device_Error', 'End_Error', 'Data_Error', 'Layout_Error', 'Length_Error', 'Pattern_Error', 'Index_Error', 'Translation_Error', 'Time_Error', 'Argument_Error', 'Tag_Error', 'Picture_Error', 'Terminator_Error', 'Conversion_Error', 'Pointer_Error', 'Dereference_Error', 'Update_Error']
+    let g:ada#Keywords += [{
+	    \ 'word':  Item,
+	    \ 'menu':  'exception',
+	    \ 'info':  'Ada standard exception.',
+	    \ 'kind':  'x',
+	    \ 'icase': 1}]
+endfor
+
+" Section: add	GNAT exception {{{3
+"
+if exists ('g:ada_gnat_extensions')
+    for Item in ['Assert_Failure']
+	let g:ada#Keywords += [{
+		\ 'word':  Item,
+		\ 'menu':  'exception',
+		\ 'info':  'GNAT exception.',
+		\ 'kind':  'x',
+		\ 'icase': 1}]
+    endfor
+endif
+
+" Section: add Ada buildin types {{{2
+"
+for Item in ['Boolean', 'Integer', 'Natural', 'Positive', 'Float', 'Character', 'Wide_Character', 'Wide_Wide_Character', 'String', 'Wide_String', 'Wide_Wide_String', 'Duration']
+    let g:ada#Keywords += [{
+	    \ 'word':  Item,
+	    \ 'menu':  'type',
+	    \ 'info':  'Ada buildin type.',
+	    \ 'kind':  't',
+	    \ 'icase': 1}]
+endfor
+
+" Section: add GNAT buildin types {{{3
+"
+if exists ('g:ada_gnat_extensions')
+    for Item in ['Short_Integer', 'Short_Short_Integer', 'Long_Integer', 'Long_Long_Integer', 'Short_Float', 'Short_Short_Float', 'Long_Float', 'Long_Long_Float']
+	let g:ada#Keywords += [{
+		\ 'word':  Item,
+		\ 'menu':  'type',
+		\ 'info':  'GNAT buildin type.',
+		\ 'kind':  't',
+		\ 'icase': 1}]
+    endfor
+endif
+
+" Section: add Ada Attributes {{{2
+"
+for Item in ['''Access', '''Address', '''Adjacent', '''Aft', '''Alignment', '''Base', '''Bit_Order', '''Body_Version', '''Callable', '''Caller', '''Ceiling', '''Class', '''Component_Size', '''Compose', '''Constrained', '''Copy_Sign', '''Count', '''Definite', '''Delta', '''Denorm', '''Digits', '''Emax', '''Exponent', '''External_Tag', '''Epsilon', '''First', '''First_Bit', '''Floor', '''Fore', '''Fraction', '''Identity', '''Image', '''Input', '''Large', '''Last', '''Last_Bit', '''Leading_Part', '''Length', '''Machine', '''Machine_Emax', '''Machine_Emin', '''Machine_Mantissa', '''Machine_Overflows', '''Machine_Radix', '''Machine_Rounding', '''Machine_Rounds', '''Mantissa', '''Max', '''Max_Size_In_Storage_Elements', '''Min', '''Mod', '''Model', '''Model_Emin', '''Model_Epsilon', '''Model_Mantissa', '''Model_Small', '''Modulus', '''Output', '''Partition_ID', '''Pos', '''Position', '''Pred', '''Priority', '''Range', '''Read', '''Remainder', '''Round', '''Rounding', '''Safe_Emax', '''Safe_First', '''Safe_Large', '''Safe_Last', '''Safe_Small', '''Scale', '''Scaling', '''Signed_Zeros', '''Size', '''Small', '''Storage_Pool', '''Storage_Size', '''Stream_Size', '''Succ', '''Tag', '''Terminated', '''Truncation', '''Unbiased_Rounding', '''Unchecked_Access', '''Val', '''Valid', '''Value', '''Version', '''Wide_Image', '''Wide_Value', '''Wide_Wide_Image', '''Wide_Wide_Value', '''Wide_Wide_Width', '''Wide_Width', '''Width', '''Write']
+    let g:ada#Keywords += [{
+	    \ 'word':  Item,
+	    \ 'menu':  'attribute',
+	    \ 'info':  'Ada attribute.',
+	    \ 'kind':  'a',
+	    \ 'icase': 1}]
+endfor
+
+" Section: add GNAT Attributes {{{3
+"
+if exists ('g:ada_gnat_extensions')
+    for Item in ['''Abort_Signal', '''Address_Size', '''Asm_Input', '''Asm_Output', '''AST_Entry', '''Bit', '''Bit_Position', '''Code_Address', '''Default_Bit_Order', '''Elaborated', '''Elab_Body', '''Elab_Spec', '''Emax', '''Enum_Rep', '''Epsilon', '''Fixed_Value', '''Has_Access_Values', '''Has_Discriminants', '''Img', '''Integer_Value', '''Machine_Size', '''Max_Interrupt_Priority', '''Max_Priority', '''Maximum_Alignment', '''Mechanism_Code', '''Null_Parameter', '''Object_Size', '''Passed_By_Reference', '''Range_Length', '''Storage_Unit', '''Target_Name', '''Tick', '''To_Address', '''Type_Class', '''UET_Address', '''Unconstrained_Array', '''Universal_Literal_String', '''Unrestricted_Access', '''VADS_Size', '''Value_Size', '''Wchar_T_Size', '''Word_Size']
+    let g:ada#Keywords += [{
+	    \ 'word':  Item,
+	    \ 'menu':  'attribute',
+	    \ 'info':  'GNAT attribute.',
+	    \ 'kind':  'a',
+	    \ 'icase': 1}]
+    endfor
+endif
+
+" Section: add Ada Pragmas {{{2
+"
+for Item in ['All_Calls_Remote', 'Assert', 'Assertion_Policy', 'Asynchronous', 'Atomic', 'Atomic_Components', 'Attach_Handler', 'Controlled', 'Convention', 'Detect_Blocking', 'Discard_Names', 'Elaborate', 'Elaborate_All', 'Elaborate_Body', 'Export', 'Import', 'Inline', 'Inspection_Point', 'Interface (Obsolescent)', 'Interrupt_Handler', 'Interrupt_Priority', 'Linker_Options', 'List', 'Locking_Policy', 'Memory_Size (Obsolescent)', 'No_Return', 'Normalize_Scalars', 'Optimize', 'Pack', 'Page', 'Partition_Elaboration_Policy', 'Preelaborable_Initialization', 'Preelaborate', 'Priority', 'Priority_Specific_Dispatching', 'Profile', 'Pure', 'Queueing_Policy', 'Relative_Deadline', 'Remote_Call_Interface', 'Remote_Types', 'Restrictions', 'Reviewable', 'Shared (Obsolescent)', 'Shared_Passive', 'Storage_Size', 'Storage_Unit (Obsolescent)', 'Suppress', 'System_Name (Obsolescent)', 'Task_Dispatching_Policy', 'Unchecked_Union', 'Unsuppress', 'Volatile', 'Volatile_Components']
+    let g:ada#Keywords += [{
+	    \ 'word':  Item,
+	    \ 'menu':  'pragma',
+	    \ 'info':  'Ada pragma.',
+	    \ 'kind':  'p',
+	    \ 'icase': 1}]
+endfor
+
+" Section: add GNAT Pragmas {{{3
+"
+if exists ('g:ada_gnat_extensions')
+    for Item in ['Abort_Defer', 'Ada_83', 'Ada_95', 'Ada_05', 'Annotate', 'Ast_Entry', 'C_Pass_By_Copy', 'Comment', 'Common_Object', 'Compile_Time_Warning', 'Complex_Representation', 'Component_Alignment', 'Convention_Identifier', 'CPP_Class', 'CPP_Constructor', 'CPP_Virtual', 'CPP_Vtable', 'Debug', 'Elaboration_Checks', 'Eliminate', 'Export_Exception', 'Export_Function', 'Export_Object', 'Export_Procedure', 'Export_Value', 'Export_Valued_Procedure', 'Extend_System', 'External', 'External_Name_Casing', 'Finalize_Storage_Only', 'Float_Representation', 'Ident', 'Import_Exception', 'Import_Function', 'Import_Object', 'Import_Procedure', 'Import_Valued_Procedure', 'Initialize_Scalars', 'Inline_Always', 'Inline_Generic', 'Interface_Name', 'Interrupt_State', 'Keep_Names', 'License', 'Link_With', 'Linker_Alias', 'Linker_Section', 'Long_Float', 'Machine_Attribute', 'Main_Storage', 'Obsolescent', 'Passive', 'Polling', 'Profile_Warnings', 'Propagate_Exceptions', 'Psect_Object', 'Pure_Function', 'Restriction_Warnings', 'Source_File_Name', 'Source_File_Name_Project', 'Source_Reference', 'Stream_Convert', 'Style_Checks', 'Subtitle', 'Suppress_All', 'Suppress_Exception_Locations', 'Suppress_Initialization', 'Task_Info', 'Task_Name', 'Task_Storage', 'Thread_Body', 'Time_Slice', 'Title', 'Unimplemented_Unit', 'Universal_Data', 'Unreferenced', 'Unreserve_All_Interrupts', 'Use_VADS_Size', 'Validity_Checks', 'Warnings', 'Weak_External']
+	let g:ada#Keywords += [{
+		\ 'word':  Item,
+		\ 'menu':  'pragma',
+		\ 'info':  'GNAT pragma.',
+		\ 'kind':  'p',
+		\ 'icase': 1}]
+    endfor
+endif
+" 1}}}
+
+" Section: g:ada#Ctags_Kinds {{{1
+"
+let g:ada#Ctags_Kinds = {
+   \ 'P': ["packspec",	  "package specifications"],
+   \ 'p': ["package",	  "packages"],
+   \ 'T': ["typespec",	  "type specifications"],
+   \ 't': ["type",	  "types"],
+   \ 'U': ["subspec",	  "subtype specifications"],
+   \ 'u': ["subtype",	  "subtypes"],
+   \ 'c': ["component",   "record type components"],
+   \ 'l': ["literal",	  "enum type literals"],
+   \ 'V': ["varspec",	  "variable specifications"],
+   \ 'v': ["variable",	  "variables"],
+   \ 'f': ["formal",	  "generic formal parameters"],
+   \ 'n': ["constant",	  "constants"],
+   \ 'x': ["exception",   "user defined exceptions"],
+   \ 'R': ["subprogspec", "subprogram specifications"],
+   \ 'r': ["subprogram",  "subprograms"],
+   \ 'K': ["taskspec",	  "task specifications"],
+   \ 'k': ["task",	  "tasks"],
+   \ 'O': ["protectspec", "protected data specifications"],
+   \ 'o': ["protected",   "protected data"],
+   \ 'E': ["entryspec",   "task/protected data entry specifications"],
+   \ 'e': ["entry",	  "task/protected data entries"],
+   \ 'b': ["label",	  "labels"],
+   \ 'i': ["identifier",  "loop/declare identifiers"],
+   \ 'a': ["autovar",	  "automatic variables"],
+   \ 'y': ["annon",	  "loops and blocks with no identifier"]}
+
+" Section: ada#Word (...) {{{1
+"
+" Extract current Ada word across multiple lines
+" AdaWord ([line, column])\
+"
+function ada#Word (...)
+   if a:0 > 1
+      let l:Line_Nr    = a:1
+      let l:Column_Nr  = a:2 - 1
+   else
+      let l:Line_Nr    = line('.')
+      let l:Column_Nr  = col('.') - 1
+   endif
+
+   let l:Line = substitute (getline (l:Line_Nr), g:ada#Comment, '', '' )
+
+   " Cope with tag searching for items in comments; if we are, don't loop
+   " backwards looking for previous lines
+   if l:Column_Nr > strlen(l:Line)
+      " We were in a comment
+      let l:Line = getline(l:Line_Nr)
+      let l:Search_Prev_Lines = 0
+   else
+      let l:Search_Prev_Lines = 1
+   endif
+
+   " Go backwards until we find a match (Ada ID) that *doesn't* include our
+   " location - i.e., the previous ID. This is because the current 'correct'
+   " match will toggle matching/not matching as we traverse characters
+   " backwards. Thus, we have to find the previous unrelated match, exclude
+   " it, then use the next full match (ours).
+   " Remember to convert vim column 'l:Column_Nr' [1..n] to string offset [0..(n-1)]
+   " ... but start, here, one after the required char.
+   let l:New_Column = l:Column_Nr + 1
+   while 1
+      let l:New_Column = l:New_Column - 1
+      if l:New_Column < 0
+	 " Have to include previous l:Line from file
+	 let l:Line_Nr = l:Line_Nr - 1
+	 if l:Line_Nr < 1  ||  !l:Search_Prev_Lines
+	    " Start of file or matching in a comment
+	    let l:Line_Nr     = 1
+	    let l:New_Column  = 0
+	    let l:Our_Match   = match (l:Line, g:ada#WordRegex )
+	    break
+	 endif
+	 " Get previous l:Line, and prepend it to our search string
+	 let l:New_Line    = substitute (getline (l:Line_Nr), g:ada#Comment, '', '' )
+	 let l:New_Column  = strlen (l:New_Line) - 1
+	 let l:Column_Nr   = l:Column_Nr + l:New_Column
+	 let l:Line	   = l:New_Line . l:Line
+      endif
+      " Check to see if this is a match excluding 'us'
+      let l:Match_End = l:New_Column +
+		      \ matchend (strpart (l:Line,l:New_Column), g:ada#WordRegex ) - 1
+      if l:Match_End >= l:New_Column  &&
+       \ l:Match_End < l:Column_Nr
+	 " Yes
+	 let l:Our_Match = l:Match_End+1 +
+			 \ match (strpart (l:Line,l:Match_End+1), g:ada#WordRegex )
+	 break
+      endif
+   endwhile
+
+   " Got anything?
+   if l:Our_Match < 0
+      return ''
+   else
+      let l:Line = strpart (l:Line, l:Our_Match)
+   endif
+
+   " Now simply add further lines until the match gets no bigger
+   let l:Match_String = matchstr (l:Line, g:ada#WordRegex)
+   let l:Last_Line    = line ('$')
+   let l:Line_Nr      = line ('.') + 1
+   while l:Line_Nr <= l:Last_Line
+      let l:Last_Match = l:Match_String
+      let l:Line = l:Line .
+	 \ substitute (getline (l:Line_Nr), g:ada#Comment, '', '')
+      let l:Match_String = matchstr (l:Line, g:ada#WordRegex)
+      if l:Match_String == l:Last_Match
+	 break
+      endif
+   endwhile
+
+   " Strip whitespace & return
+   return substitute (l:Match_String, '\s\+', '', 'g')
+endfunction ada#Word
+
+" Section: ada#List_Tag (...) {{{1
+"
+"  List tags in quickfix window
+"
+function ada#List_Tag (...)
+   if a:0 > 1
+      let l:Tag_Word = ada#Word (a:1, a:2)
+   elseif a:0 > 0
+      let l:Tag_Word = a:1
+   else
+      let l:Tag_Word = ada#Word ()
+   endif
+
+   echo "Searching for" l:Tag_Word
+
+   let l:Pattern = '^' . l:Tag_Word . '$'
+   let l:Tag_List = taglist (l:Pattern)
+   let l:Error_List = []
+   "
+   " add symbols
+   "
+   for Tag_Item in l:Tag_List
+      if l:Tag_Item['kind'] == ''
+	 let l:Tag_Item['kind'] = 's'
+      endif
+
+      let l:Error_List += [
+	 \ l:Tag_Item['filename'] . '|' .
+	 \ l:Tag_Item['cmd']	  . '|' .
+	 \ l:Tag_Item['kind']	  . "\t" .
+	 \ l:Tag_Item['name'] ]
+   endfor
+   set errorformat=%f\|%l\|%m
+   cexpr l:Error_List
+   cwindow
+endfunction ada#List_Tag
+
+" Section: ada#Jump_Tag (Word, Mode) {{{1
+"
+" Word tag - include '.' and if Ada make uppercase
+"
+function ada#Jump_Tag (Word, Mode)
+   if a:Word == ''
+      " Get current word
+      let l:Word = ada#Word()
+      if l:Word == ''
+	 throw "NOT_FOUND: no identifier found."
+      endif
+   else
+      let l:Word = a:Word
+   endif
+
+   echo "Searching for " . l:Word
+
+   try
+      execute a:Mode l:Word
+   catch /.*:E426:.*/
+      let ignorecase = &ignorecase
+      set ignorecase
+      execute a:Mode l:Word
+      let &ignorecase = ignorecase
+   endtry
+
+   return
+endfunction ada#Jump_Tag
+
+" Section: ada#Insert_Backspace () {{{1
+"
+" Backspace at end of line after auto-inserted commentstring '-- ' wipes it
+"
+function ada#Insert_Backspace ()
+   let l:Line = getline ('.')
+   if col ('.') > strlen (l:Line) &&
+    \ match (l:Line, '-- $') != -1 &&
+    \ match (&comments,'--') != -1
+      return "\<bs>\<bs>\<bs>"
+   else
+      return "\<bs>"
+   endif
+
+   return
+endfunction ada#InsertBackspace
+
+" Section: Insert Completions {{{1
+"
+" Section: ada#User_Complete(findstart, base) {{{2
+"
+" This function is used for the 'complete' option.
+"
+function! ada#User_Complete(findstart, base)
+   if a:findstart == 1
+      "
+      " locate the start of the word
+      "
+      let line = getline ('.')
+      let start = col ('.') - 1
+      while start > 0 && line[start - 1] =~ '\i\|'''
+	 let start -= 1
+      endwhile
+      return start
+   else
+      "
+      " look up matches
+      "
+      let l:Pattern = '^' . a:base . '.*$'
+      "
+      " add keywords
+      "
+      for Tag_Item in g:ada#Keywords
+	 if l:Tag_Item['word'] =~? l:Pattern
+	    if complete_add (l:Tag_Item) == 0
+	       return []
+	    endif
+	    if complete_check ()
+	       return []
+	    endif
+	 endif
+      endfor
+      return []
+   endif
+endfunction ada#User_Complete
+
+" Section: ada#Completion (cmd) {{{2
+"
+" Word completion (^N/^R/^X^]) - force '.' inclusion
+function ada#Completion (cmd)
+   set iskeyword+=46
+   return a:cmd . "\<C-R>=ada#Completion_End ()\<CR>"
+endfunction ada#Completion
+
+" Section: ada#Completion_End () {{{2
+"
+function ada#Completion_End ()
+   set iskeyword-=46
+   return ''
+endfunction ada#Completion_End
+
+" Section: ada#Create_Tags {{{1
+"
+function ada#Create_Tags (option)
+   if a:option == 'file'
+      let l:Filename = fnamemodify (bufname ('%'), ':p')
+   elseif a:option == 'dir'
+      let l:Filename =
+	 \ fnamemodify (bufname ('%'), ':p:h') . "*.ada " .
+	 \ fnamemodify (bufname ('%'), ':p:h') . "*.adb " .
+	 \ fnamemodify (bufname ('%'), ':p:h') . "*.ads"
+   else
+      let l:Filename = a:option
+   endif
+   execute '!ctags --excmd=number ' . l:Filename
+endfunction ada#Create_Tags
+
+" Section: ada#Switch_Session {{{1
+"
+function ada#Switch_Session (New_Session)
+   " 
+   " you should not save to much date into the seession since they will
+   " be sourced
+   "
+   let l:sessionoptions=&sessionoptions
+
+   try
+      set sessionoptions=buffers,curdir,folds,globals,resize,slash,tabpages,tabpages,unix,winpos,winsize
+
+      if a:New_Session != v:this_session
+	 "
+	 "  We actually got a new session - otherwise there
+	 "  is nothing to do.
+	 "
+	 if strlen (v:this_session) > 0
+	    execute 'mksession! ' . v:this_session
+	 endif
+
+	 let v:this_session = a:New_Session
+
+	 "if filereadable (v:this_session)
+	    "execute 'source ' . v:this_session
+	 "endif
+
+	 augroup ada_session
+	    autocmd!
+	    autocmd VimLeavePre * execute 'mksession! ' . v:this_session
+	 augroup END
+	 
+	 "if exists ("g:Tlist_Auto_Open") && g:Tlist_Auto_Open
+	    "TlistOpen
+	 "endif
+
+      endif
+   finally
+      let &sessionoptions=l:sessionoptions
+   endtry
+
+   return
+endfunction ada#Switch_Session	
+
+" Section: GNAT Pretty Printer folding {{{1
+"
+if exists('g:ada_folding') && g:ada_folding[0] == 'g'
+   "
+   " Lines consisting only of ')' ';' are due to a gnat pretty bug and
+   " have the same level as the line above (can't happen in the first
+   " line).
+   "
+   let s:Fold_Collate = '^\([;)]*$\|'
+
+   "
+   " some lone statements are folded with the line above
+   "
+   if stridx (g:ada_folding, 'i') >= 0
+      let s:Fold_Collate .= '\s\+\<is\>$\|'
+   endif
+   if stridx (g:ada_folding, 'b') >= 0
+      let s:Fold_Collate .= '\s\+\<begin\>$\|'
+   endif
+   if stridx (g:ada_folding, 'p') >= 0
+      let s:Fold_Collate .= '\s\+\<private\>$\|'
+   endif
+   if stridx (g:ada_folding, 'x') >= 0
+      let s:Fold_Collate .= '\s\+\<exception\>$\|'
+   endif
+
+   " We also handle empty lines and
+   " comments here.
+   let s:Fold_Collate .= '--\)'
+
+   function ada#Pretty_Print_Folding (Line)			     " {{{2
+      let l:Text = getline (a:Line)
+
+      if l:Text =~ s:Fold_Collate
+	 "
+	 "  fold with line above
+	 "
+	 let l:Level = "="
+      elseif l:Text =~ '^\s\+('
+	 "
+	 " gnat outdents a line which stards with a ( by one characters so
+	 " that parameters which follow are aligned.
+	 "
+	 let l:Level = (indent (a:Line) + 1) / &shiftwidth
+      else
+	 let l:Level = indent (a:Line) / &shiftwidth
+      endif
+
+      return l:Level
+   endfunction ada#Pretty_Print_Folding				     " }}}2
+endif
+
+" Section: Options and Menus {{{1
+"
+" Section: ada#Switch_Syntax_Options {{{2
+"
+function ada#Switch_Syntax_Option (option)
+   syntax off
+   if exists ('g:ada_' . a:option)
+      unlet g:ada_{a:option}
+      echo  a:option . 'now off'
+   else
+      let g:ada_{a:option}=1
+      echo  a:option . 'now on'
+   endif
+   syntax on
+endfunction ada#Switch_Syntax_Option
+
+" Section: ada#Map_Menu {{{2
+"
+function ada#Map_Menu (Text, Keys, Command)
+   if a:Keys[0] == ':'
+      execute
+	\ "50amenu " .
+	\ "Ada."     . escape(a:Text, ' ') .
+	\ "<Tab>"    . a:Keys .
+	\ " :"	     . a:Command . "<CR>"
+      execute
+	\ "command -buffer " .
+	\ a:Keys[1:] .
+	\" :" . a:Command . "<CR>"
+   elseif a:Keys[0] == '<'
+      execute
+	\ "50amenu " .
+	\ "Ada."     . escape(a:Text, ' ') .
+	\ "<Tab>"    . a:Keys .
+	\ " :"	     . a:Command . "<CR>"
+      execute
+	\ "nnoremap <buffer> "	 .
+	\ a:Keys		 .
+	\" :" . a:Command . "<CR>"
+      execute
+	\ "inoremap <buffer> "	 .
+	\ a:Keys		 .
+	\" <C-O>:" . a:Command . "<CR>"
+   else
+      if exists("g:mapleader")
+         let l:leader = g:mapleader
+      else
+         let l:leader = '\'
+      endif
+      execute
+	\ "50amenu " .
+	\ "Ada."  . escape(a:Text, ' ') .
+	\ "<Tab>" . escape(l:leader . "a" . a:Keys , '\') .
+	\ " :"	  . a:Command . "<CR>"
+      execute
+	\ "nnoremap <buffer>" .
+	\ " <Leader>a" . a:Keys .
+	\" :" . a:Command
+      execute
+	\ "inoremap <buffer>" .
+	\ " <Leader>a" . a:Keys .
+	\" <C-O>:" . a:Command
+   endif
+   return
+endfunction
+
+" Section: ada#Map_Popup {{{2
+"
+function ada#Map_Popup (Text, Keys, Command)
+   if exists("g:mapleader")
+      let l:leader = g:mapleader
+   else
+      let l:leader = '\'
+   endif
+   execute
+     \ "50amenu " .
+     \ "PopUp."   . escape(a:Text, ' ') .
+     \ "<Tab>"	  . escape(l:leader . "a" . a:Keys , '\') .
+     \ " :"	  . a:Command . "<CR>"
+
+   call ada#Map_Menu (a:Text, a:Keys, a:Command)
+   return
+endfunction ada#Map_Popup
+
+" }}}1
+
+lockvar  g:ada#WordRegex
+lockvar  g:ada#DotWordRegex
+lockvar  g:ada#Comment
+lockvar! g:ada#Keywords
+lockvar! g:ada#Ctags_Kinds
+
+let &cpo = s:keepcpo
+unlet s:keepcpo
+
+finish " 1}}}
+
+"------------------------------------------------------------------------------
+"   Copyright (C) 2006	Martin Krischik
+"
+"   Vim is Charityware - see ":help license" or uganda.txt for licence details.
+"------------------------------------------------------------------------------
+" vim: textwidth=78 wrap tabstop=8 shiftwidth=3 softtabstop=3 noexpandtab
+" vim: foldmethod=marker

autoload/cargo.vim

@@ -0,0 +1,151 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'rust', 'autoload/cargo.vim')
+  finish
+endif
+
+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:

autoload/cargo/quickfix.vim

@@ -0,0 +1,31 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'rust', 'autoload/cargo/quickfix.vim')
+  finish
+endif
+
+function! cargo#quickfix#CmdPre() abort
+    if &filetype ==# 'rust' && get(b:, 'current_compiler', '') ==# 'cargo' &&
+         \ &makeprg =~ '\V\^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:

autoload/coc/source/requirements.vim

@@ -0,0 +1,24 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'requirements', 'autoload/coc/source/requirements.vim')
+  finish
+endif
+
+""
+" https://github.com/neoclide/coc.nvim/wiki/Create-custom-source
+function! coc#source#requirements#init() abort
+    return {
+                \ 'shortcut': 'pip',
+                \ 'priority': 9,
+                \ 'filetypes': ['requirements'],
+                \ }
+endfunction
+
+""
+" https://github.com/neoclide/coc.nvim/wiki/Create-custom-source
+"
+" Completion pip option and PYPI package names.
+" Note: completion PYPI package names need install pip-cache from PYPI,
+" and run `pip-cache update` first to generate cache.
+function! coc#source#requirements#complete(opt, cb) abort
+    call a:cb(g:requirements#items)
+endfunction
+" vim: et sw=4 ts=4 sts=4:

autoload/coffee.vim

@@ -1,5 +1,9 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'coffee-script', 'autoload/coffee.vim')
+  finish
+endif
+
 " Language:    CoffeeScript
-" Maintainer:  Mick Koch <kchmck@gmail.com>
+" Maintainer:  Mick Koch <mick@kochm.co>
 " URL:         http://github.com/kchmck/vim-coffee-script
 " License:     WTFPL
 

autoload/crystal_lang.vim

@@ -0,0 +1,367 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'crystal', 'autoload/crystal_lang.vim')
+  finish
+endif
+
+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
+
+" vim: sw=2 sts=2 et:

autoload/dart.vim

@@ -0,0 +1,217 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'dart', 'autoload/dart.vim')
+  finish
+endif
+
+
+function! s:error(text) abort
+  echohl Error
+  echomsg printf('[dart-vim-plugin] %s', a:text)
+  echohl None
+endfunction
+
+function! s:cexpr(errorformat, lines, reason) abort
+  call setqflist([], ' ', {
+      \ 'lines': a:lines,
+      \ 'efm': a:errorformat,
+      \ 'context': {'reason': a:reason},
+      \})
+  copen
+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(...) abort
+  let l:dartfmt = s:FindDartFmt()
+  if empty(l:dartfmt) | return | endif
+  let buffer_content = getline(1, '$')
+  let l:cmd = extend(l:dartfmt, ['--stdin-name', shellescape(expand('%'))])
+  if exists('g:dartfmt_options')
+    call extend(l:cmd, g:dartfmt_options)
+  endif
+  call extend(l:cmd, a:000)
+  let lines = systemlist(join(l:cmd), 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
+    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
+    let errors = lines[2:]
+    let error_format = '%Aline %l\, column %c of %f: %m,%C%.%#'
+    call s:cexpr(error_format, errors, 'dartfmt')
+  endif
+endfunction
+
+function! s:FindDartFmt() abort
+  if executable('dart')
+    let l:version_text = system('dart --version')
+    let l:match = matchlist(l:version_text,
+        \ '\vDart SDK version: (\d+)\.(\d+)\.\d+.*')
+    if empty(l:match)
+      call s:error('Unable to determine dart version')
+      return []
+    endif
+    let l:major = l:match[1]
+    let l:minor = l:match[2]
+    if l:major > 2 || l:major == 2 && l:minor >= 14
+      return ['dart', 'format']
+    endif
+  endif
+  " Legacy fallback for Dart SDK pre 2.14
+  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')
+  return []
+endfunction
+
+" Finds the path to `uri`.
+"
+" If the file is a package: uri, looks for a package_config.json or .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 or package_config.json 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 'package_config.json'
+" or '.packages' file.
+"
+" Returns [found, package_map]
+function! s:PackageMap() abort
+  let [found, package_config] = s:FindFile('.dart_tool/package_config.json')
+  if found
+    let dart_tool_dir = fnamemodify(package_config, ':p:h')
+    let content = join(readfile(package_config), "\n")
+    let packages_dict = json_decode(content)
+    if packages_dict['configVersion'] != '2'
+      s:error('Unsupported version of package_config.json')
+      return [v:false, {}]
+    endif
+    let map = {}
+    for package in packages_dict['packages']
+      let name = package['name']
+      let uri = package['rootUri']
+      let package_uri = package['packageUri']
+      if uri =~# 'file:/'
+        let uri = substitute(uri, 'file://', '', '')
+        let lib_dir = resolve(uri.'/'.package_uri)
+      else
+        let lib_dir = resolve(dart_tool_dir.'/'.uri.'/'.package_uri)
+      endif
+      let map[name] = lib_dir
+    endfor
+    return [v:true, map]
+  endif
+
+  let [found, dot_packages] = s:FindFile('.packages')
+  if found
+    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
+        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]
+  endif
+  return [v:false, {}]
+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 named [a:path] in the cwd, or in any directory above the open
+" file.
+"
+" Returns [found, file]
+function! s:FindFile(path) abort
+  if filereadable(a:path)
+    return [v:true, a:path]
+  endif
+  let dir_path = expand('%:p:h')
+  while v:true
+    let file_path = dir_path.'/'.a:path
+    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

autoload/db/adapter/ecto.vim

@@ -0,0 +1,24 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'elixir', 'autoload/db/adapter/ecto.vim')
+  finish
+endif
+
+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

autoload/ecrystal.vim

@@ -0,0 +1,36 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'crystal', 'autoload/ecrystal.vim')
+  finish
+endif
+
+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:

autoload/elixir/indent.vim

@@ -0,0 +1,485 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'elixir', 'autoload/elixir/indent.vim')
+  finish
+endif
+
+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 = [
+        \'inside_embedded_view',
+        \'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
+
+function! s:in_embedded_view()
+  let groups = map(synstack(line('.'), col('.')), "synIDattr(v:val, 'name')")
+  for group in ['elixirPhoenixESigil', 'elixirLiveViewSigil', 'elixirSurfaceSigil']
+    if index(groups, group) >= 0
+      return 1
+    endif
+  endfor
+
+  return 0
+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\|CharList\)'
+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\|CharList\)'
+          return c + ss_match
+        end
+      end
+    end
+    let c -= 1
+  endwhile
+
+  return -1
+endfunction
+
+function! elixir#indent#handle_inside_embedded_view(context)
+  if !s:in_embedded_view()
+    return -1
+  endif
+
+  " Multi-line Surface data delimiters
+  let pair_lnum = searchpair('{{', '', '}}', '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
+    if a:context.text =~ '}}$'
+      return indent(pair_lnum)
+    elseif a:context.text =~ '}}*>$'
+      return -1
+    elseif s:prev_ends_with(a:context, '[\|%{')
+      return indent(a:context.prev_nb_lnum) + s:sw()
+    elseif a:context.prev_nb_text =~ ',$'
+      return indent(a:context.prev_nb_lnum)
+    else
+      return indent(pair_lnum) + s:sw()
+    endif
+  endif
+
+  " Multi-line opening tag -- >, />, or %> are on a different line that their opening <
+  let pair_lnum = searchpair('^\s\+<.*[^>]$', '', '^[^<]*[/%}]\?>$', '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
+    if a:context.text =~ '^\s\+\%\(>\|\/>\|%>\|}}>\)$'
+      call s:debug("current line is a lone >, />, or %>")
+      return indent(pair_lnum)
+    elseif a:context.text =~ '\%\(>\|\/>\|%>\|}}>\)$'
+      call s:debug("current line ends in >, />, or %>")
+      if s:prev_ends_with(a:context, ',')
+        return indent(a:context.prev_nb_lnum)
+      else
+        return -1
+      endif
+    else
+      call s:debug("in the body of a multi-line opening tag")
+      return indent(pair_lnum) + s:sw()
+    endif
+  endif
+
+  " Special cases
+  if s:prev_ends_with(a:context, '^[^<]*do\s%>')
+    call s:debug("prev line closes a multi-line do block")
+    return indent(a:context.prev_nb_lnum)
+  elseif a:context.prev_nb_text =~ 'do\s*%>$'
+    call s:debug("prev line opens a do block")
+    return indent(a:context.prev_nb_lnum) + s:sw()
+  elseif a:context.text =~ '^\s\+<\/[a-zA-Z0-9\.\-_]\+>\|<% end %>'
+    call s:debug("a single closing tag")
+    if a:context.prev_nb_text =~ '^\s\+<[^%\/]*[^/]>.*<\/[a-zA-Z0-9\.\-_]\+>$'
+      call s:debug("opening and closing tags are on the same line")
+      return indent(a:context.prev_nb_lnum) - s:sw()
+    elseif a:context.prev_nb_text =~ '^\s\+<[^%\/]*[^/]>\|\s\+>' 
+      call s:debug("prev line is opening html tag or single >")
+      return indent(a:context.prev_nb_lnum)
+    elseif s:prev_ends_with(a:context, '^[^<]*\%\(do\s\)\@<!%>')
+      call s:debug("prev line closes a multi-line eex tag")
+      return indent(a:context.prev_nb_lnum) - 2 * s:sw()
+    else
+      return indent(a:context.prev_nb_lnum) - s:sw()
+    endif
+  elseif a:context.text =~ '^\s*<%\s*\%(end\|else\|catch\|rescue\)\>.*%>'
+    call s:debug("eex middle or closing eex tag")
+    return indent(a:context.prev_nb_lnum) - s:sw()
+  elseif a:context.prev_nb_text =~ '\s*<\/\|<% end %>$'
+    call s:debug("prev is closing tag")
+    return indent(a:context.prev_nb_lnum)
+  elseif a:context.prev_nb_text =~ '^\s\+<[^%\/]*[^/]>.*<\/[a-zA-Z0-9\.\-_]\+>$'
+    call s:debug("opening and closing tags are on the same line")
+    return indent(a:context.prev_nb_lnum)
+  elseif s:prev_ends_with(a:context, '\s\+\/>')
+    call s:debug("prev ends with a single \>")
+    return indent(a:context.prev_nb_lnum)
+  elseif s:prev_ends_with(a:context, '^[^<]*\/>')
+    call s:debug("prev line is closing a multi-line self-closing tag")
+    return indent(a:context.prev_nb_lnum) - s:sw()
+  elseif s:prev_ends_with(a:context, '^\s\+<.*\/>')
+    call s:debug("prev line is closing self-closing tag")
+    return indent(a:context.prev_nb_lnum)
+  elseif a:context.prev_nb_text =~ '^\s\+%\?>$'
+    call s:debug("prev line is a single > or %>")
+    return indent(a:context.prev_nb_lnum) + s:sw()
+  endif
+
+  " Simple HTML (ie, opening tag is not split across lines)
+  let pair_lnum = searchpair('^\s\+<[^%\/].*[^\/>]>$', '', '^\s\+<\/\w\+>$', '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
+    call s:debug("simple HTML")
+    if a:context.text =~ '^\s\+<\/\w\+>$'
+      return indent(pair_lnum)
+    else
+      return indent(pair_lnum) + s:sw()
+    endif
+  endif
+
+  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\|CharList\)$'
+    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]
+  call s:debug("block_start_lnum=" . block_start_lnum)
+  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]
+    call s:debug("block_start_char=" . block_start_char)
+
+    let never_match = ''
+    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 `with` clause...
+    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 aligned clause (closing tag/`else` clause/etc...) then indent this
+      " at the same level as the block open tag (e.g. `if`/`case`/etc...)
+      if s:starts_with(a:context, block_config.aligned_clauses)
+        call s:debug("clause")
+        return indent(block_start_lnum)
+      else
+        if block_config.pattern_match_clauses == never_match
+          let relative_lnum = block_start_lnum
+        else
+          let clause_lnum = searchpair(block_config.pattern_match_clauses, '', '*', 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()", block_start_lnum)
+          call s:debug("clause_lum=" . clause_lnum)
+          let relative_lnum = max([clause_lnum, block_start_lnum])
+        end
+        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

autoload/elixir/util.vim

@@ -0,0 +1,28 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'elixir', 'autoload/elixir/util.vim')
+  finish
+endif
+
+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

autoload/erlangcomplete.vim

@@ -1,161 +0,0 @@
-" ------------------------------------------------------------------------------
-" Vim omni-completion script
-" Author: Oscar Hellström
-" Email: oscar@oscarh.net
-" Version: 2010-08-10
-" Contributors: kTT (http://github.com/kTT)
-" 		Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
-" ------------------------------------------------------------------------------
-
-" Patterns for completions {{{1
-let s:erlangLocalFuncBeg    = '\(\<[0-9A-Za-z_-]*\|\s*\)$'
-let s:erlangExternalFuncBeg = '\<[0-9A-Za-z_-]\+:[0-9A-Za-z_-]*$'
-let s:ErlangBlankLine       = '^\s*\(%.*\)\?$'
-let s:erlangCompletionPath  = expand('<sfile>:p:h') . '/erlang_completion.erl'
-
-if !exists('g:erlangCompletionGrep')
-	let g:erlangCompletionGrep = 'grep'
-endif
-
-if !exists('g:erlangManSuffix')
-	let g:erlangManSuffix = ''
-endif
-
-if !exists('g:erlangManPath')
-	let g:erlangManPath = '/usr/lib/erlang/man'
-endif
-
-if !exists('g:erlangCompletionDisplayDoc')
-	let g:erlangCompletionDisplayDoc = 1
-endif
-
-" Main function for completion {{{1
-function! erlangcomplete#Complete(findstart, base)
-	" 0) Init {{{2
-	let lnum = line('.')
-	let column = col('.') 
-	let line = strpart(getline('.'), 0, column - 1)
-
-	" 1) First, check if completion is impossible {{{2
-	if line =~ '[^~\\]%'
-		return -1
-	endif
-
-	"echo "line[col - 1]:" . line[column - 1] . " line[col - 2]:" . line[column - 2] .  "\n" . line . "\n"
-
-	" 2) Check if the char to the left of us are part of a function call {{{2
-	"
-	" Nothing interesting is written at the char just before the cursor
-	" This means _anything_ could be started here
-	" In this case, keyword completion should probably be used,
-	" for now we'll only try and complete local functions.
-	" TODO: Examine if we can stare Identifiers end complete on them
-	" Is this worth it? Is /completion/ of a "blank" wanted? Can we consider (
-	" interesting and check if we are in a function call etc.?
-	if line[column - 2] !~ '[0-9A-Za-z:_-]'
-		if a:findstart
-			return column
-		else
-			return s:erlangFindLocalFunc(a:base)
-		endif
-	endif
-	
-
-	" 3) Function in external module {{{2
-	if line =~ s:erlangExternalFuncBeg
-		let delimiter = match(line, ':[0-9A-Za-z_-]*$') + 1
-		if a:findstart
-			return delimiter
-		else
-                        let module = matchstr(line[:-2], '\<\k*\>$')
-			return s:erlangFindExternalFunc(module, a:base)
-		endif
-	endif
-
-	" 4) Local function {{{2
-	if line =~ s:erlangLocalFuncBeg
-		let funcstart = match(line, ':\@<![0-9A-Za-z_-]*$')
-		if a:findstart
-			return funcstart
-		else
-			return s:erlangFindLocalFunc(a:base)
-		endif
-	endif
-
-	" 5) Unhandled situation {{{2
-	if a:findstart
-		return -1
-	else
-		return []
-	endif
-endfunction
-
-" Auxiliary functions for completion {{{1 
-" Find the next non-blank line {{{2
-function s:erlangFindNextNonBlank(lnum)
-	let lnum = nextnonblank(a:lnum + 1)
-	let line = getline(lnum)
-	while line =~ s:ErlangBlankLine && 0 != lnum
-		let lnum = nextnonblank(lnum + 1)
-		let line = getline(lnum)
-   endwhile
-   return lnum
-endfunction
-			
-" vim: foldmethod=marker:
-" Find external function names {{{2
-function s:erlangFindExternalFunc(module, base)
-        " If it's a local module, try to compile it
-        if filereadable(a:module . '.erl') && !filereadable(a:module . '.beam')
-            silent execute '!erlc' a:module . '.erl' '>/dev/null' '2>/dev/null'
-            redraw!
-        endif
-        let functions = system(s:erlangCompletionPath . ' ' . a:module)
-        for element in sort(split(functions, '\n'))
-            if match(element, a:base) == 0
-                let function_name = matchstr(element, a:base . '\w\+')
-                let number_of_args = matchstr(element, '\d\+', len(function_name))
-                let number_of_comma = max([number_of_args - 1, 0])
-                let file_path = g:erlangManPath . '/man?/' . a:module . '\.?' . g:erlangManSuffix
-                " [:-2] cutting some weird characters at the end
-                " becouse grep doesn't support multilines, we have to filter
-                " first by .B and next by looking via function name
-                " if someone have better idea, please change it
-                let description = ''
-                " Don't look man pages if the module is present in the current directory
-                if g:erlangCompletionDisplayDoc != 0 && !filereadable(a:module . '.erl')
-                    let system_command = g:erlangCompletionGrep . ' -A 1 "\.B" ' . file_path . ' | grep -EZo "\<' .
-\                           function_name . '\>\((\w+, ){' . number_of_comma . '}[^),]*\) -> .*"'
-                    let description = system(system_command)
-                    let description = description[:-2]
-                endif
-                if description == ''
-                    let description = element " if function doesn't have description e.g. lists:rmerge, put rmerge/2 instead
-                endif
-                let field = {'word': function_name . '(', 'abbr': description, 'kind': 'f', 'dup': 1} " always duplicate functions
-                call complete_add(field)
-            endif
-        endfor
-        return []
-endfunction
-
-" Find local function names {{{2
-function s:erlangFindLocalFunc(base)
-	" begin at line 1
-	let lnum = s:erlangFindNextNonBlank(1)
-	if "" == a:base
-		let base = '\w' " used to match against word symbol
-	else
-		let base = a:base
-	endif
-	while 0 != lnum && !complete_check()
-		let line = getline(lnum)
-		let function_name = matchstr(line, '^' . base . '[0-9A-Za-z_-]\+(\@=')
-		if function_name != ""
-			call complete_add(function_name)
-		endif
-		let lnum = s:erlangFindNextNonBlank(lnum)
-	endwhile
-	return []
-endfunction
-

autoload/fish.vim

@@ -0,0 +1,157 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'fish', 'autoload/fish.vim')
+  finish
+endif
+
+function! s:IsString(lnum, col)
+    " Returns "true" if syntax item at the given position is part of fishString.
+    let l:stack = map(synstack(a:lnum, a:col), 'synIDattr(v:val, "name")')
+    return len(filter(l:stack, 'v:val ==# "fishString"'))
+endfunction
+
+function! s:IsContinuedLine(lnum)
+    " Returns "true" if the given line is a continued line.
+    return getline(a:lnum - 1) =~ '\v\\$'
+endfunction
+
+function! s:FindPrevLnum(lnum)
+    " Starting on the given line, search backwards for a line that is not
+    " empty, not part of a string and not a continued line.
+    if a:lnum < 1 || a:lnum > line('$')
+        " First line or wrong value, follow prevnonblank() behaviour and
+        " return zero.
+        return 0
+    endif
+    let l:lnum = prevnonblank(a:lnum)
+    while l:lnum > 0 && ( s:IsContinuedLine(l:lnum) || s:IsString(l:lnum, 1) )
+        let l:lnum = prevnonblank(l:lnum - 1)
+    endwhile
+    return l:lnum
+endfunction
+
+function! s:IsSwitch(lnum)
+    " Returns "true" if the given line is part of a switch block.
+    let l:lnum = a:lnum
+    let l:line = getline(l:lnum)
+    let l:in_block = 0
+    let l:stop_pat = '\v^\s*%(if|else|while|for|begin)>'
+    let l:block_start_pat = '\v^\s*%(if|while|for|switch|begin)>'
+    while l:lnum > 0
+        let l:lnum = prevnonblank(l:lnum - 1)
+        let l:line = getline(l:lnum)
+        if l:line =~# '\v^\s*end>'
+            let l:in_block += 1
+        elseif l:in_block && l:line =~# l:block_start_pat
+            let l:in_block -= 1
+        elseif !l:in_block && l:line =~# l:stop_pat
+            return 0
+        elseif !l:in_block && l:line =~# '\v^\s*switch>'
+            return 1
+        endif
+    endwhile
+    return 0
+endfunction
+
+function! fish#Indent()
+    let l:line = getline(v:lnum)
+    if s:IsString(v:lnum, 1)
+        return indent(v:lnum)
+    endif
+    " shiftwidth can be misleading in recent versions, use shiftwidth() if
+    " it is available.
+    if exists('*shiftwidth')
+        let l:shiftwidth = shiftwidth()
+    else
+        let l:shiftwidth = &shiftwidth
+    endif
+    let l:prevlnum = s:FindPrevLnum(v:lnum - 1)
+    if l:prevlnum == 0
+        return 0
+    endif
+    let l:shift = 0
+    let l:prevline = getline(l:prevlnum)
+    let l:previndent = indent(l:prevlnum)
+    if s:IsContinuedLine(v:lnum)
+        let l:previndent = indent(v:lnum - 1)
+        if s:IsContinuedLine(v:lnum - 1)
+            return l:previndent
+        elseif exists('g:fish_indent_cont')
+            return l:previndent + g:fish_indent_cont
+        elseif exists('g:indent_cont')
+            return l:previndent + g:indent_cont
+        else
+            return l:previndent + l:shiftwidth
+        endif
+    endif
+    if l:prevline =~# '\v^\s*%(begin|if|else|while|for|function|case|switch)>'
+        " First line inside a block, increase by one.
+        let l:shift += 1
+    endif
+    if l:line =~# '\v^\s*%(end|case|else)>'
+        " "end", "case" or "else", decrease by one.
+        let l:shift -= 1
+    endif
+    if l:line =~# '\v^\s*<case>' && l:prevline =~# '\v<switch>'
+        " "case" following "switch", increase by one.
+        let l:shift += 1
+    endif
+    if l:line =~# '\v\s*end>' && s:IsSwitch(v:lnum)
+        " "end" ends switch block, decrease by one more so it matches
+        " the indentation of "switch".
+        let l:shift -= 1
+    endif
+    if l:prevline =~# '\v^\s*%(if|while|for|else|switch|end)>.*<begin>'
+        " "begin" after start of block, increase by one.
+        let l:shift += 1
+    endif
+    let l:indent = l:previndent + l:shift * l:shiftwidth
+    " Only return zero or positive numbers.
+    return l:indent < 0 ? 0 : 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
+        " Fix indentation and replace tabs with spaces if necessary.
+        normal! '[=']
+    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

autoload/freebasic.vim

@@ -0,0 +1,45 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'freebasic', 'autoload/freebasic.vim')
+  finish
+endif
+
+" Vim filetype plugin file
+" Language:	FreeBASIC
+" Maintainer:	Doug Kearns <dougkearns@gmail.com>
+" Last Change:	2021 Mar 16
+
+" Dialects can be one of fb, qb, fblite, or deprecated
+" Precedence is forcelang > #lang > lang
+function! freebasic#GetDialect() abort
+  if exists("g:freebasic_forcelang")
+    return g:freebasic_forcelang
+  endif
+
+  if exists("g:freebasic_lang")
+    let dialect = g:freebasic_lang
+  else
+    let dialect = "fb"
+  endif
+
+  " override with #lang directive or metacommand
+
+  let skip = "has('syntax_items') && synIDattr(synID(line('.'), col('.'), 1), 'name') =~ 'Comment$'"
+  let pat = '\c^\s*\%(#\s*lang\s\+\|''\s*$lang\s*:\s*\)"\([^"]*\)"'
+
+  let save_cursor = getcurpos()
+  call cursor(1, 1)
+  let lnum = search(pat, 'n', '', '', skip)
+  call setpos('.', save_cursor)
+
+  if lnum
+    let word = matchlist(getline(lnum), pat)[1]
+    if word =~? '\%(fb\|deprecated\|fblite\|qb\)'
+      let dialect = word
+    else
+      echomsg "freebasic#GetDialect: Invalid lang, found '" .. word .. "' at line " .. lnum .. " " .. getline(lnum)
+    endif
+  endif
+
+  return dialect
+endfunction
+
+" vim: nowrap sw=2 sts=2 ts=8 noet fdm=marker:

autoload/fsharp.vim

@@ -0,0 +1,678 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'fsharp', 'autoload/fsharp.vim')
+  finish
+endif
+
+" Vim autoload functions
+if exists('g:loaded_autoload_fsharp')
+    finish
+endif
+let g:loaded_autoload_fsharp = 1
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+
+" basic setups
+
+let s:script_root_dir = expand('<sfile>:p:h') . "/../"
+
+if has('nvim-0.5')
+    lua ionide = require("ionide")
+endif
+
+function! s:prompt(msg)
+    let height = &cmdheight
+    if height < 2
+        set cmdheight=2
+    endif
+    echom a:msg
+    let &cmdheight = height
+endfunction
+
+
+" FSAC payload interfaces
+
+function! s:PlainNotification(content)
+    return { 'Content': a:content }
+endfunction
+
+function! s:TextDocumentIdentifier(path)
+    let usr_ss_opt = &shellslash
+    set shellslash
+    let uri = fnamemodify(a:path, ":p")
+    if uri[0] == "/"
+        let uri = "file://" . uri
+    else
+        let uri = "file:///" . uri
+    endif
+    let &shellslash = usr_ss_opt
+    return { 'Uri': uri }
+endfunction
+
+function! s:Position(line, character)
+    return { 'Line': a:line, 'Character': a:character }
+endfunction
+
+function! s:TextDocumentPositionParams(documentUri, line, character)
+    return {
+        \ 'TextDocument': s:TextDocumentIdentifier(a:documentUri),
+        \ 'Position':     s:Position(a:line, a:character)
+        \ }
+endfunction
+
+function! s:DocumentationForSymbolRequest(xmlSig, assembly)
+    return {
+        \ 'XmlSig': a:xmlSig,
+        \ 'Assembly': a:assembly
+        \ }
+endfunction
+
+function! s:ProjectParms(projectUri)
+    return { 'Project': s:TextDocumentIdentifier(a:projectUri) }
+endfunction
+
+function! s:WorkspacePeekRequest(directory, deep, excludedDirs)
+    return {
+        \ 'Directory': fnamemodify(a:directory, ":p"),
+        \ 'Deep': a:deep,
+        \ 'ExcludedDirs': a:excludedDirs
+        \ }
+endfunction
+
+function! s:WorkspaceLoadParms(files)
+    let prm = []
+    for file in a:files
+        call add(prm, s:TextDocumentIdentifier(file))
+    endfor
+    return { 'TextDocuments': prm }
+endfunction
+
+function! s:FsdnRequest(query)
+    return { 'Query': a:query }
+endfunction
+
+
+" LSP functions
+
+function! s:call(method, params, cont)
+    if g:fsharp#backend == 'languageclient-neovim'
+        call LanguageClient#Call(a:method, a:params, a:cont)
+    elseif g:fsharp#backend == 'nvim'
+        let key = fsharp#register_callback(a:cont)
+        call luaeval('ionide.call(_A[1], _A[2], _A[3])', [a:method, a:params, key])
+    endif
+endfunction
+
+function! s:notify(method, params)
+    if g:fsharp#backend == 'languageclient-neovim'
+        call LanguageClient#Notify(a:method, a:params)
+    elseif g:fsharp#backend == 'nvim'
+        call luaeval('ionide.notify(_A[1], _A[2])', [a:method, a:params])
+    endif
+endfunction
+
+function! s:signature(filePath, line, character, cont)
+    return s:call('fsharp/signature', s:TextDocumentPositionParams(a:filePath, a:line, a:character), a:cont)
+endfunction
+function! s:signatureData(filePath, line, character, cont)
+    return s:call('fsharp/signatureData', s:TextDocumentPositionParams(a:filePath, a:line, a:character), a:cont)
+endfunction
+function! s:lineLens(projectPath, cont)
+    return s:call('fsharp/lineLens', s:ProjectParms(a:projectPath), a:cont)
+endfunction
+function! s:compilerLocation(cont)
+    return s:call('fsharp/compilerLocation', {}, a:cont)
+endfunction
+function! s:compile(projectPath, cont)
+    return s:call('fsharp/compile', s:ProjectParms(a:projectPath), a:cont)
+endfunction
+function! s:workspacePeek(directory, depth, excludedDirs, cont)
+    return s:call('fsharp/workspacePeek', s:WorkspacePeekRequest(a:directory, a:depth, a:excludedDirs), a:cont)
+endfunction
+function! s:workspaceLoad(files, cont)
+    return s:call('fsharp/workspaceLoad', s:WorkspaceLoadParms(a:files), a:cont)
+endfunction
+function! s:project(projectPath, cont)
+    return s:call('fsharp/project', s:ProjectParms(a:projectPath), a:cont)
+endfunction
+function! s:fsdn(signature, cont)
+    return s:call('fsharp/fsdn', s:FsdnRequest(a:signature), a:cont)
+endfunction
+function! s:f1Help(filePath, line, character, cont)
+    return s:call('fsharp/f1Help', s:TextDocumentPositionParams(a:filePath, a:line, a:character), a:cont)
+endfunction
+function! fsharp#documentation(filePath, line, character, cont)
+    return s:call('fsharp/documentation', s:TextDocumentPositionParams(a:filePath, a:line, a:character), a:cont)
+endfunction
+function! s:documentationSymbol(xmlSig, assembly, cont)
+    return s:call('fsharp/documentationSymbol', s:DocumentationForSymbolRequest(a:xmlSig, a:assembly), a:cont)
+endfunction
+
+
+" FSAC configuration
+
+" FSharpConfigDto from https://github.com/fsharp/FsAutoComplete/blob/master/src/FsAutoComplete/LspHelpers.fs
+"
+" * The following options seems not working with workspace/didChangeConfiguration
+"   since the initialization has already completed?
+"     'AutomaticWorkspaceInit',
+"     'WorkspaceModePeekDeepLevel',
+"
+" * Changes made to linter/unused analyzer settings seems not reflected after sending them to FSAC?
+"
+let s:config_keys_camel =
+    \ [
+    \     {'key': 'AutomaticWorkspaceInit', 'default': 1},
+    \     {'key': 'WorkspaceModePeekDeepLevel', 'default': 2},
+    \     {'key': 'ExcludeProjectDirectories', 'default': []},
+    \     {'key': 'keywordsAutocomplete', 'default': 1},
+    \     {'key': 'ExternalAutocomplete', 'default': 0},
+    \     {'key': 'Linter', 'default': 1},
+    \     {'key': 'UnionCaseStubGeneration', 'default': 1},
+    \     {'key': 'UnionCaseStubGenerationBody'},
+    \     {'key': 'RecordStubGeneration', 'default': 1},
+    \     {'key': 'RecordStubGenerationBody'},
+    \     {'key': 'InterfaceStubGeneration', 'default': 1},
+    \     {'key': 'InterfaceStubGenerationObjectIdentifier', 'default': 'this'},
+    \     {'key': 'InterfaceStubGenerationMethodBody'},
+    \     {'key': 'UnusedOpensAnalyzer', 'default': 1},
+    \     {'key': 'UnusedDeclarationsAnalyzer', 'default': 1},
+    \     {'key': 'SimplifyNameAnalyzer', 'default': 0},
+    \     {'key': 'ResolveNamespaces', 'default': 1},
+    \     {'key': 'EnableReferenceCodeLens', 'default': 1},
+    \     {'key': 'EnableAnalyzers', 'default': 0},
+    \     {'key': 'AnalyzersPath'},
+    \     {'key': 'DisableInMemoryProjectReferences', 'default': 0},
+    \     {'key': 'LineLens', 'default': {'enabled': 'never', 'prefix': ''}},
+    \     {'key': 'UseSdkScripts', 'default': 1},
+    \     {'key': 'dotNetRoot'},
+    \     {'key': 'fsiExtraParameters', 'default': []},
+    \ ]
+let s:config_keys = []
+
+function! s:toSnakeCase(str)
+    let sn = substitute(a:str, '\(\<\u\l\+\|\l\+\)\(\u\)', '\l\1_\l\2', 'g')
+    if sn == a:str | return tolower(a:str) | endif
+    return sn
+endfunction
+
+function! s:buildConfigKeys()
+    if len(s:config_keys) == 0
+        for key_camel in s:config_keys_camel
+            let key = {}
+            let key.snake = s:toSnakeCase(key_camel.key)
+            let key.camel = key_camel.key
+            if has_key(key_camel, 'default')
+                let key.default = key_camel.default
+            endif
+            call add(s:config_keys, key)
+        endfor
+    endif
+endfunction
+
+function! fsharp#getServerConfig()
+    let fsharp = {}
+    call s:buildConfigKeys()
+    for key in s:config_keys
+        if exists('g:fsharp#' . key.snake)
+            let fsharp[key.camel] = g:fsharp#{key.snake}
+        elseif exists('g:fsharp#' . key.camel)
+            let fsharp[key.camel] = g:fsharp#{key.camel}
+        elseif has_key(key, 'default') && g:fsharp#use_recommended_server_config
+            let g:fsharp#{key.snake} = key.default
+            let fsharp[key.camel] = key.default
+        endif
+    endfor
+    return fsharp
+endfunction
+
+function! fsharp#updateServerConfig()
+    let fsharp = fsharp#getServerConfig()
+    let settings = {'settings': {'FSharp': fsharp}}
+    call s:notify('workspace/didChangeConfiguration', settings)
+endfunction
+
+function! fsharp#loadConfig()
+    if exists('s:config_is_loaded')
+        return
+    endif
+
+    if !exists('g:fsharp#fsautocomplete_command')
+        let g:fsharp#fsautocomplete_command = ['fsautocomplete', '--background-service-enabled']
+    endif
+    if !exists('g:fsharp#use_recommended_server_config')
+        let g:fsharp#use_recommended_server_config = 1
+    endif
+    call fsharp#getServerConfig()
+    if !exists('g:fsharp#automatic_workspace_init')
+        let g:fsharp#automatic_workspace_init = 1
+    endif
+    if !exists('g:fsharp#automatic_reload_workspace')
+        let g:fsharp#automatic_reload_workspace = 1
+    endif
+    if !exists('g:fsharp#show_signature_on_cursor_move')
+        let g:fsharp#show_signature_on_cursor_move = 0
+    endif
+    if !exists('g:fsharp#fsi_command')
+        let g:fsharp#fsi_command = "dotnet fsi"
+    endif
+    if !exists('g:fsharp#fsi_keymap')
+        let g:fsharp#fsi_keymap = "vscode"
+    endif
+    if !exists('g:fsharp#fsi_window_command')
+        let g:fsharp#fsi_window_command = "botright 10new"
+    endif
+    if !exists('g:fsharp#fsi_focus_on_send')
+        let g:fsharp#fsi_focus_on_send = 0
+    endif
+    if !exists('g:fsharp#backend')
+        if has('nvim-0.5')
+            if exists('g:LanguageClient_loaded')
+                let g:fsharp#backend = "languageclient-neovim"
+            else
+                let g:fsharp#backend = "nvim"
+            endif
+        else
+            let g:fsharp#backend = "languageclient-neovim"
+        endif
+    endif
+
+    " backend configuration
+    if g:fsharp#backend == 'languageclient-neovim'
+        let $DOTNET_ROLL_FORWARD='LatestMajor'
+        if !exists('g:LanguageClient_serverCommands')
+            let g:LanguageClient_serverCommands = {}
+        endif
+        if !has_key(g:LanguageClient_serverCommands, 'fsharp')
+            let g:LanguageClient_serverCommands.fsharp = {
+                \ 'name': 'fsautocomplete',
+                \ 'command': g:fsharp#fsautocomplete_command,
+                \ 'initializationOptions': {},
+                \}
+            if g:fsharp#automatic_workspace_init
+                let g:LanguageClient_serverCommands.fsharp.initializationOptions = {
+                    \ 'AutomaticWorkspaceInit': v:true,
+                    \}
+            endif
+        endif
+
+        if !exists('g:LanguageClient_rootMarkers')
+            let g:LanguageClient_rootMarkers = {}
+        endif
+        if !has_key(g:LanguageClient_rootMarkers, 'fsharp')
+            let g:LanguageClient_rootMarkers.fsharp = ['*.sln', '*.fsproj', '.git']
+        endif
+    elseif g:fsharp#backend == 'nvim'
+        if !exists('g:fsharp#lsp_auto_setup')
+            let g:fsharp#lsp_auto_setup = 1
+        endif
+        if !exists('g:fsharp#lsp_recommended_colorscheme')
+            let g:fsharp#lsp_recommended_colorscheme = 1
+        endif
+        if !exists('g:fsharp#lsp_codelens')
+            let g:fsharp#lsp_codelens = 1
+        endif
+
+    else
+        if g:fsharp#backend != 'disable'
+            echoerr "[FSAC] Invalid backend: " . g:fsharp#backend
+        endif
+    endif
+
+    " FSI keymaps
+    if g:fsharp#fsi_keymap == "vscode"
+        if has('nvim')
+            let g:fsharp#fsi_keymap_send   = "<M-cr>"
+            let g:fsharp#fsi_keymap_toggle = "<M-@>"
+        else
+            let g:fsharp#fsi_keymap_send   = "<esc><cr>"
+            let g:fsharp#fsi_keymap_toggle = "<esc>@"
+        endif
+    elseif g:fsharp#fsi_keymap == "vim-fsharp"
+        let g:fsharp#fsi_keymap_send   = "<leader>i"
+        let g:fsharp#fsi_keymap_toggle = "<leader>e"
+    elseif g:fsharp#fsi_keymap == "custom"
+        let g:fsharp#fsi_keymap = "none"
+        if !exists('g:fsharp#fsi_keymap_send')
+            echoerr "g:fsharp#fsi_keymap_send is not set"
+        elseif !exists('g:fsharp#fsi_keymap_toggle')
+            echoerr "g:fsharp#fsi_keymap_toggle is not set"
+        else
+            let g:fsharp#fsi_keymap = "custom"
+        endif
+    endif
+
+    let s:config_is_loaded = 1
+endfunction
+
+
+" handlers for notifications
+
+let s:handlers = {
+    \ 'fsharp/notifyWorkspace': 'fsharp#handle_notifyWorkspace',
+    \ }
+
+function! s:registerAutocmds()
+    if g:fsharp#backend == 'nvim' && g:fsharp#lsp_codelens
+        augroup FSharp_AutoRefreshCodeLens
+            autocmd!
+            autocmd CursorHold,InsertLeave <buffer> lua vim.lsp.codelens.refresh()
+        augroup END
+    endif
+    if g:fsharp#backend != 'disable'
+        augroup FSharp_OnCursorMove
+            autocmd!
+            autocmd CursorMoved *.fs,*.fsi,*.fsx  call fsharp#OnCursorMove()
+        augroup END
+    endif
+endfunction
+
+function! fsharp#initialize()
+    echom '[FSAC] Initialized'
+    if g:fsharp#backend == 'languageclient-neovim'
+        call LanguageClient_registerHandlers(s:handlers)
+    endif
+    call fsharp#updateServerConfig()
+    call s:registerAutocmds()
+endfunction
+
+
+" nvim-lsp specific functions
+
+" handlers are picked up by ionide.setup()
+function! fsharp#get_handlers()
+    return s:handlers
+endfunction
+
+let s:callbacks = {}
+
+function! fsharp#register_callback(fn)
+    if g:fsharp#backend != 'nvim'
+        return -1
+    endif
+    let rnd = reltimestr(reltime())
+    let s:callbacks[rnd] = a:fn
+    return rnd
+endfunction
+
+function! fsharp#resolve_callback(key, arg)
+    if g:fsharp#backend != 'nvim'
+        return
+    endif
+    if has_key(s:callbacks, a:key)
+        let Callback = s:callbacks[a:key]
+        call Callback(a:arg)
+        call remove(s:callbacks, a:key)
+    endif
+endfunction
+
+
+" .NET/F# specific operations
+
+let s:workspace = []
+
+function! fsharp#handle_notifyWorkspace(payload) abort
+    let content = json_decode(a:payload.content)
+    if content.Kind == 'projectLoading'
+        echom "[FSAC] Loading" content.Data.Project
+        let s:workspace = uniq(sort(add(s:workspace, content.Data.Project)))
+    elseif content.Kind == 'workspaceLoad' && content.Data.Status == 'finished'
+        echom printf("[FSAC] Workspace loaded (%d project(s))", len(s:workspace))
+        call fsharp#updateServerConfig()
+    endif
+endfunction
+
+
+function! s:load(arg)
+    call s:workspaceLoad(a:arg, v:null)
+endfunction
+
+function! fsharp#loadProject(...)
+    let prjs = []
+    for proj in a:000
+        call add(prjs, fnamemodify(proj, ':p'))
+    endfor
+    call s:load(prjs)
+endfunction
+
+function! fsharp#showLoadedProjects()
+    for proj in s:workspace
+        echo "-" proj
+    endfor
+endfunction
+
+function! fsharp#reloadProjects()
+    if len(s:workspace) > 0
+        call s:workspaceLoad(s:workspace, v:null)
+    else
+        echom "[FSAC] Workspace is empty"
+    endif
+endfunction
+
+function! fsharp#OnFSProjSave()
+    if &ft == "fsharp_project" && exists('g:fsharp#automatic_reload_workspace') && g:fsharp#automatic_reload_workspace
+        call fsharp#reloadProjects()
+    endif
+endfunction
+
+function! fsharp#showSignature()
+    function! s:callback_showSignature(result)
+        let result = a:result
+        if exists('result.result.content')
+            let content = json_decode(result.result.content)
+            if exists('content.Data')
+                echo substitute(content.Data, '\n\+$', ' ', 'g')
+            endif
+        endif
+    endfunction
+    call s:signature(expand('%:p'), line('.') - 1, col('.') - 1, function("s:callback_showSignature"))
+endfunction
+
+function! fsharp#OnCursorMove()
+    if g:fsharp#show_signature_on_cursor_move
+        call fsharp#showSignature()
+    endif
+endfunction
+
+function! fsharp#showF1Help()
+    function! s:callback_showF1Help(result)
+        let result = a:result
+        if exists('result.result.content')
+            let content = json_decode(result.result.content)
+            if exists('content.Data')
+                let url = 'https://docs.microsoft.com/en-us/dotnet/api/' . substitute(content.Data, '#ctor', '-ctor', 'g')
+                echo url
+            endif
+        endif
+    endfunction
+    call s:f1Help(expand('%:p'), line('.') - 1, col('.') - 1, function("s:callback_showF1Help"))
+endfunction
+
+function! s:hover()
+    if g:fsharp#backend == 'languageclient-neovim'
+        call LanguageClient#textDocument_hover()
+    elseif g:fsharp#backend == 'nvim'
+        lua vim.lsp.buf.hover()
+    endif
+endfunction
+
+function! fsharp#showTooltip()
+    function! s:callback_showTooltip(result)
+        let result = a:result
+        if exists('result.result.content')
+            let content = json_decode(result.result.content)
+            if exists('content.Data')
+                call s:hover()
+            endif
+        endif
+    endfunction
+    " show hover only if signature exists for the current position
+    call s:signature(expand('%:p'), line('.') - 1, col('.') - 1, function("s:callback_showTooltip"))
+endfunction
+
+
+" FSI integration
+
+let s:fsi_buffer = -1
+let s:fsi_job    = -1
+let s:fsi_width  = 0
+let s:fsi_height = 0
+
+function! s:win_gotoid_safe(winid)
+    function! s:vimReturnFocus(window)
+        call win_gotoid(a:window)
+        redraw!
+    endfunction
+    if has('nvim')
+        call win_gotoid(a:winid)
+    else
+        call timer_start(1, { -> s:vimReturnFocus(a:winid) })
+    endif
+endfunction
+
+function! s:get_fsi_command()
+    let cmd = g:fsharp#fsi_command
+    for prm in g:fsharp#fsi_extra_parameters
+        let cmd = cmd . " " . prm
+    endfor
+    return cmd
+endfunction
+
+function! fsharp#openFsi(returnFocus)
+    if bufwinid(s:fsi_buffer) <= 0
+        let fsi_command = s:get_fsi_command()
+        if exists('*termopen') || exists('*term_start')
+            let current_win = win_getid()
+            execute g:fsharp#fsi_window_command
+            if s:fsi_width  > 0 | execute 'vertical resize' s:fsi_width | endif
+            if s:fsi_height > 0 | execute 'resize' s:fsi_height | endif
+            " if window is closed but FSI is still alive then reuse it
+            if s:fsi_buffer >= 0 && bufexists(str2nr(s:fsi_buffer))
+                exec 'b' s:fsi_buffer
+                normal G
+                if !has('nvim') && mode() == 'n' | execute "normal A" | endif
+                if a:returnFocus | call s:win_gotoid_safe(current_win) | endif
+            " open FSI: Neovim
+            elseif has('nvim')
+                let s:fsi_job = termopen(fsi_command)
+                if s:fsi_job > 0
+                    let s:fsi_buffer = bufnr("%")
+                else
+                    close
+                    echom "[FSAC] Failed to open FSI."
+                    return -1
+                endif
+            " open FSI: Vim
+            else
+                let options = {
+                \ "term_name": "F# Interactive",
+                \ "curwin": 1,
+                \ "term_finish": "close"
+                \ }
+                let s:fsi_buffer = term_start(fsi_command, options)
+                if s:fsi_buffer != 0
+                    if exists('*term_setkill') | call term_setkill(s:fsi_buffer, "term") | endif
+                    let s:fsi_job = term_getjob(s:fsi_buffer)
+                else
+                    close
+                    echom "[FSAC] Failed to open FSI."
+                    return -1
+                endif
+            endif
+            setlocal bufhidden=hide
+            normal G
+            if a:returnFocus | call s:win_gotoid_safe(current_win) | endif
+            return s:fsi_buffer
+        else
+            echom "[FSAC] Your (neo)vim does not support terminal".
+            return 0
+        endif
+    endif
+    return s:fsi_buffer
+endfunction
+
+function! fsharp#toggleFsi()
+    let fsiWindowId = bufwinid(s:fsi_buffer)
+    if fsiWindowId > 0
+        let current_win = win_getid()
+        call win_gotoid(fsiWindowId)
+        let s:fsi_width = winwidth('%')
+        let s:fsi_height = winheight('%')
+        close
+        call win_gotoid(current_win)
+    else
+        call fsharp#openFsi(0)
+    endif
+endfunction
+
+function! fsharp#quitFsi()
+    if s:fsi_buffer >= 0 && bufexists(str2nr(s:fsi_buffer))
+        if has('nvim')
+            let winid = bufwinid(s:fsi_buffer)
+            if winid > 0 | execute "close " . winid | endif
+            call jobstop(s:fsi_job)
+        else
+            call job_stop(s:fsi_job, "term")
+        endif
+        let s:fsi_buffer = -1
+        let s:fsi_job = -1
+    endif
+endfunction
+
+function! fsharp#resetFsi()
+    call fsharp#quitFsi()
+    return fsharp#openFsi(1)
+endfunction
+
+function! fsharp#sendFsi(text)
+    if fsharp#openFsi(!g:fsharp#fsi_focus_on_send) > 0
+        " Neovim
+        if has('nvim')
+            call chansend(s:fsi_job, a:text . "\n" . ";;". "\n")
+        " Vim 8
+        else
+            call term_sendkeys(s:fsi_buffer, a:text . "\<cr>" . ";;" . "\<cr>")
+            call term_wait(s:fsi_buffer)
+        endif
+    endif
+endfunction
+
+" https://stackoverflow.com/a/6271254
+function! s:get_visual_selection()
+    let [line_start, column_start] = getpos("'<")[1:2]
+    let [line_end, column_end] = getpos("'>")[1:2]
+    let lines = getline(line_start, line_end)
+    if len(lines) == 0
+        return ''
+    endif
+    let lines[-1] = lines[-1][: column_end - (&selection == 'inclusive' ? 1 : 2)]
+    let lines[0] = lines[0][column_start - 1:]
+    return lines
+endfunction
+
+function! s:get_complete_buffer()
+    return join(getline(1, '$'), "\n")
+endfunction
+
+function! fsharp#sendSelectionToFsi() range
+    let lines = s:get_visual_selection()
+    exec 'normal' len(lines) . 'j'
+    let text = join(lines, "\n")
+    return fsharp#sendFsi(text)
+endfunction
+
+function! fsharp#sendLineToFsi()
+    let text = getline('.')
+    exec 'normal j'
+    return fsharp#sendFsi(text)
+endfunction
+
+function! fsharp#sendAllToFsi()
+    let text = s:get_complete_buffer()
+    return fsharp#sendFsi(text)
+endfunction
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim: sw=4 et sts=4

autoload/fzf_gitignore.vim

@@ -0,0 +1,41 @@
+if polyglot#init#is_disabled(expand('<sfile>:p'), 'gitignore', 'autoload/fzf_gitignore.vim')
+  finish
+endif
+
+scriptencoding utf-8
+
+" Copyright (c) 2017-2020 Filip Szymański. All rights reserved.
+" Use of this source code is governed by an MIT license that can be
+" found in the LICENSE file.
+
+function! s:template_sink(templates) abort
+  try
+    let l:lines = _fzf_gitignore_create(a:templates)
+  catch /^Vim(\(let\|return\)):/
+    return
+  endtry
+
+  new
+  setlocal filetype=gitignore
+
+  call setline(1, l:lines)
+
+  $-2,$delete _
+  normal! gg
+endfunction
+
+function! fzf_gitignore#run() abort
+  try
+    let l:opts = {
+          \ 'source': _fzf_gitignore_get_all_templates(),
+          \ 'sink*': function('s:template_sink'),
+          \ 'options': '-m --prompt="Template> " --header="gitignore.io"'
+          \ }
+  catch /^Vim(\(let\|return\)):/
+    return
+  endtry
+
+  call fzf#run(fzf#wrap(l:opts))
+endfunction
+
+" vim: ts=2 et sw=2