Add api blueprint support, closes #182

Also fixes #154

README.md

@@ -1,4 +1,4 @@
-# vim-polyglot [![Build Status][travis-img-url]][travis-url] [![Maintenance](https://img.shields.io/maintenance/yes/2016.svg?maxAge=2592000)]()
+# vim-polyglot [![Build Status][travis-img-url]][travis-url] [![Maintenance](https://img.shields.io/maintenance/yes/2017.svg?maxAge=2592000)]()
 
 [travis-img-url]: https://travis-ci.org/sheerun/vim-polyglot.svg
 [travis-url]: https://travis-ci.org/sheerun/vim-polyglot
@@ -23,98 +23,129 @@ A collection of language packs for Vim.
 
 Optionally download one of the [releases](https://github.com/sheerun/vim-polyglot/releases) and unpack it directly under `~/.vim` directory.
 
+You can also use Vim 8 built-in package manager:
+
+```
+mkdir -p ~/.vim/pack/default/start
+git clone https://github.com/sheerun/vim-polyglot ~/.vim/pack/default/start/vim-polyglot
+```
+
+NOTE: Not all features of listed language packs are available. We strip them from functionality slowing vim startup in general (for example we ignore `plugins` folder that is loaded regardless of file type, use `ftplugin` instead).
+
+If you need full functionality of any plugin, please use it directly with your plugin manager.
+
 ## Language packs
 
-- [ansible](https://github.com/pearofducks/ansible-vim) (syntax, indent, ftplugin, ftdetect)
-- [arduino](https://github.com/sudar/vim-arduino-syntax) (syntax, indent, ftdetect)
-- [blade](https://github.com/jwalton512/vim-blade) (syntax, indent, ftplugin, ftdetect)
+- [ansible](https://github.com/pearofducks/ansible-vim) (syntax, indent, ftplugin)
+- [apiblueprint](https://github.com/sheerun/apiblueprint.vim) (syntax)
+- [applescript](https://github.com/vim-scripts/applescript.vim) (syntax)
+- [arduino](https://github.com/sudar/vim-arduino-syntax) (syntax, indent)
+- [blade](https://github.com/jwalton512/vim-blade) (syntax, indent, ftplugin)
 - [c++11](https://github.com/octol/vim-cpp-enhanced-highlight) (syntax)
 - [c/c++](https://github.com/vim-jp/vim-cpp) (syntax)
-- [cjsx](https://github.com/mtscout6/vim-cjsx) (ftdetect, syntax, ftplugin)
-- [clojure](https://github.com/guns/vim-clojure-static) (syntax, indent, autoload, ftplugin, ftdetect)
-- [coffee-script](https://github.com/kchmck/vim-coffee-script) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [cryptol](https://github.com/victoredwardocallaghan/cryptol.vim) (syntax, compiler, ftplugin, ftdetect)
-- [crystal](https://github.com/rhysd/vim-crystal) (syntax, indent, autoload, ftplugin, ftdetect)
-- [cql](https://github.com/elubow/cql-vim) (syntax, ftdetect)
+- [caddyfile](https://github.com/joshglendenning/vim-caddyfile) (syntax, indent, ftplugin)
+- [cjsx](https://github.com/mtscout6/vim-cjsx) (syntax, ftplugin)
+- [clojure](https://github.com/guns/vim-clojure-static) (syntax, indent, autoload, ftplugin)
+- [coffee-script](https://github.com/kchmck/vim-coffee-script) (syntax, indent, compiler, autoload, ftplugin)
+- [cql](https://github.com/elubow/cql-vim) (syntax)
+- [cryptol](https://github.com/victoredwardocallaghan/cryptol.vim) (syntax, compiler, ftplugin)
+- [crystal](https://github.com/rhysd/vim-crystal) (syntax, indent, autoload, ftplugin)
 - [css](https://github.com/JulesWang/css.vim) (syntax)
-- [cucumber](https://github.com/tpope/vim-cucumber) (syntax, indent, compiler, ftplugin, ftdetect)
-- [dart](https://github.com/dart-lang/dart-vim-plugin) (syntax, indent, autoload, ftplugin, ftdetect)
-- [dockerfile](https://github.com/honza/dockerfile.vim) (syntax, ftdetect)
-- [elixir](https://github.com/elixir-lang/vim-elixir) (syntax, indent, compiler, ftplugin, ftdetect)
-- [elm](https://github.com/lambdatoast/elm.vim) (syntax, indent, autoload, ftplugin, ftdetect)
-- [emberscript](https://github.com/heartsentwined/vim-ember-script) (syntax, indent, ftplugin, ftdetect)
-- [emblem](https://github.com/heartsentwined/vim-emblem) (syntax, indent, ftplugin, ftdetect)
-- [erlang](https://github.com/vim-erlang/vim-erlang-runtime) (syntax, indent, ftdetect)
-- [fish](https://github.com/dag/vim-fish) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [git](https://github.com/tpope/vim-git) (syntax, indent, ftplugin, ftdetect)
-- [glsl](https://github.com/tikhomirov/vim-glsl) (syntax, indent, ftdetect)
-- [go](https://github.com/fatih/vim-go) (syntax, compiler, indent, ftdetect)
+- [cucumber](https://github.com/tpope/vim-cucumber) (syntax, indent, compiler, ftplugin)
+- [dart](https://github.com/dart-lang/dart-vim-plugin) (syntax, indent, autoload, ftplugin)
+- [dockerfile](https://github.com/docker/docker) (syntax)
+- [elixir](https://github.com/elixir-lang/vim-elixir) (syntax, indent, compiler, autoload, ftplugin)
+- [elm](https://github.com/lambdatoast/elm.vim) (syntax, indent, autoload, ftplugin)
+- [emberscript](https://github.com/yalesov/vim-ember-script) (syntax, indent, ftplugin)
+- [emblem](https://github.com/yalesov/vim-emblem) (syntax, indent, ftplugin)
+- [erlang](https://github.com/vim-erlang/vim-erlang-runtime) (syntax, indent)
+- [fish](https://github.com/dag/vim-fish) (syntax, indent, compiler, autoload, ftplugin)
+- [git](https://github.com/tpope/vim-git) (syntax, indent, ftplugin)
+- [glsl](https://github.com/tikhomirov/vim-glsl) (syntax, indent)
+- [gnuplot](https://github.com/vim-scripts/gnuplot-syntax-highlighting) (syntax)
+- [go](https://github.com/fatih/vim-go) (syntax, compiler, indent)
 - [groovy](https://github.com/vim-scripts/groovy.vim) (syntax)
-- [haml](https://github.com/tpope/vim-haml) (syntax, indent, compiler, ftplugin, ftdetect)
-- [handlebars](https://github.com/mustache/vim-mustache-handlebars) (syntax, indent, ftplugin, ftdetect)
-- [haskell](https://github.com/neovimhaskell/haskell-vim) (syntax, indent, ftplugin, ftdetect)
-- [haxe](https://github.com/yaymukund/vim-haxe) (syntax, ftdetect)
+- [haml](https://github.com/sheerun/vim-haml) (syntax, indent, compiler, ftplugin)
+- [handlebars](https://github.com/mustache/vim-mustache-handlebars) (syntax, indent, ftplugin)
+- [haskell](https://github.com/neovimhaskell/haskell-vim) (syntax, indent, ftplugin)
+- [haxe](https://github.com/yaymukund/vim-haxe) (syntax)
 - [html5](https://github.com/othree/html5.vim) (syntax, indent, autoload, ftplugin)
-- [jasmine](https://github.com/glanotte/vim-jasmine) (syntax, ftdetect)
-- [javascript](https://github.com/pangloss/vim-javascript) (syntax, indent, ftplugin, ftdetect)
-- [json](https://github.com/sheerun/vim-json) (syntax, indent, ftdetect)
-- [jst](https://github.com/briancollins/vim-jst) (syntax, indent, ftdetect)
-- [jsx](https://github.com/mxw/vim-jsx) (ftdetect, after)
-- [julia](https://github.com/dcjones/julia-minimalist-vim) (syntax, indent, ftdetect)
-- [kotlin](https://github.com/udalov/kotlin-vim) (syntax, indent, ftdetect)
+- [i3](https://github.com/PotatoesMaster/i3-vim-syntax) (syntax, ftplugin)
+- [jasmine](https://github.com/glanotte/vim-jasmine) (syntax)
+- [javascript](https://github.com/pangloss/vim-javascript) (syntax, indent, compiler, ftplugin, extras)
+- [json](https://github.com/elzr/vim-json) (syntax, indent, ftplugin)
+- [jst](https://github.com/briancollins/vim-jst) (syntax, indent)
+- [jsx](https://github.com/mxw/vim-jsx) (after)
+- [julia](https://github.com/dcjones/julia-minimalist-vim) (syntax, indent)
+- [kotlin](https://github.com/udalov/kotlin-vim) (syntax, indent)
 - [latex](https://github.com/LaTeX-Box-Team/LaTeX-Box) (syntax, indent, ftplugin)
-- [less](https://github.com/groenewege/vim-less) (syntax, indent, ftplugin, ftdetect)
-- [liquid](https://github.com/tpope/vim-liquid) (syntax, indent, ftplugin, ftdetect)
-- [mako](https://github.com/sophacles/vim-bundle-mako) (syntax, indent, ftplugin, ftdetect)
-- [markdown](https://github.com/tpope/vim-markdown) (syntax, ftplugin, ftdetect)
-- [nginx](https://github.com/othree/nginx-contrib-vim) (syntax, indent, ftdetect)
-- [nim](https://github.com/zah/nim.vim) (syntax, compiler, indent, ftdetect)
-- [nix](https://github.com/spwhitt/vim-nix) (syntax, ftplugin, ftdetect)
+- [less](https://github.com/groenewege/vim-less) (syntax, indent, ftplugin)
+- [liquid](https://github.com/tpope/vim-liquid) (syntax, indent, ftplugin)
+- [livescript](https://github.com/gkz/vim-ls) (syntax, indent, compiler, ftplugin)
+- [lua](https://github.com/tbastos/vim-lua) (syntax, indent)
+- [mako](https://github.com/sophacles/vim-bundle-mako) (syntax, indent, ftplugin)
+- [markdown](https://github.com/plasticboy/vim-markdown) (syntax)
+- [mathematica](https://github.com/rsmenon/vim-mathematica) (syntax, ftplugin)
+- [nginx](https://github.com/othree/nginx-contrib-vim) (syntax, indent, ftplugin)
+- [nim](https://github.com/zah/nim.vim) (syntax, compiler, indent)
+- [nix](https://github.com/spwhitt/vim-nix) (syntax, ftplugin)
 - [objc](https://github.com/b4winckler/vim-objc) (ftplugin, syntax, indent)
 - [ocaml](https://github.com/jrk/vim-ocaml) (syntax, indent, ftplugin)
 - [octave](https://github.com/vim-scripts/octave.vim--) (syntax)
-- [opencl](https://github.com/petRUShka/vim-opencl) (syntax, indent, ftplugin, ftdetect)
-- [perl](https://github.com/vim-perl/vim-perl) (syntax, indent, ftplugin, ftdetect)
-- [pgsql](https://github.com/exu/pgsql.vim) (syntax, ftdetect)
+- [opencl](https://github.com/petRUShka/vim-opencl) (syntax, indent, ftplugin)
+- [perl](https://github.com/vim-perl/vim-perl) (syntax, indent, ftplugin)
+- [pgsql](https://github.com/exu/pgsql.vim) (syntax)
 - [php](https://github.com/StanAngeloff/php.vim) (syntax)
-- [plantuml](https://github.com/aklt/plantuml-syntax) (syntax, ftplugin, ftdetect)
-- [powershell](https://github.com/Persistent13/vim-ps1) (syntax, indent, ftplugin, ftdetect)
-- [protobuf](https://github.com/uarun/vim-protobuf) (syntax, indent, ftdetect)
-- [pug](https://github.com/digitaltoad/vim-pug) (syntax, indent, ftplugin, ftdetect)
-- [puppet](https://github.com/voxpupuli/vim-puppet) (syntax, indent, ftplugin, ftdetect)
-- [purescript](https://github.com/raichoo/purescript-vim) (syntax, indent, ftdetect)
+- [plantuml](https://github.com/aklt/plantuml-syntax) (syntax, indent, ftplugin)
+- [powershell](https://github.com/PProvost/vim-ps1) (syntax, indent, ftplugin)
+- [protobuf](https://github.com/uarun/vim-protobuf) (syntax, indent)
+- [pug](https://github.com/digitaltoad/vim-pug) (syntax, indent, ftplugin)
+- [puppet](https://github.com/voxpupuli/vim-puppet) (syntax, indent, ftplugin)
+- [purescript](https://github.com/raichoo/purescript-vim) (syntax, indent, ftplugin)
+- [python-compiler](https://github.com/aliev/vim-compiler-python) (compiler, autoload)
 - [python](https://github.com/mitsuhiko/vim-python-combined) (syntax, indent)
-- [qml](https://github.com/peterhoeg/vim-qml) (syntax, indent, ftplugin, ftdetect)
+- [qml](https://github.com/peterhoeg/vim-qml) (syntax, indent, ftplugin)
 - [r-lang](https://github.com/vim-scripts/R.vim) (syntax, ftplugin)
 - [ragel](https://github.com/jneen/ragel.vim) (syntax)
-- [rspec](https://github.com/sheerun/rspec.vim) (syntax, ftdetect)
-- [ruby](https://github.com/vim-ruby/vim-ruby) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [rust](https://github.com/rust-lang/rust.vim) (syntax, indent, compiler, autoload, ftplugin, ftdetect)
-- [sbt](https://github.com/derekwyatt/vim-sbt) (syntax, ftdetect)
-- [scala](https://github.com/derekwyatt/vim-scala) (syntax, indent, compiler, ftplugin, ftdetect)
-- [slim](https://github.com/slim-template/vim-slim) (syntax, indent, ftplugin, ftdetect)
-- [solidity](https://github.com/ethereum/vim-solidity) (syntax, indent, ftdetect)
-- [stylus](https://github.com/wavded/vim-stylus) (syntax, indent, ftplugin, ftdetect)
-- [swift](https://github.com/keith/swift.vim) (syntax, indent, ftplugin, ftdetect)
-- [systemd](https://github.com/kurayama/systemd-vim-syntax) (syntax, ftdetect)
-- [textile](https://github.com/timcharper/textile.vim) (syntax, ftplugin, ftdetect)
-- [thrift](https://github.com/solarnz/thrift.vim) (syntax, ftdetect)
-- [tmux](https://github.com/keith/tmux.vim) (syntax, ftplugin, ftdetect)
+- [raml](https://github.com/IN3D/vim-raml) (syntax, ftplugin)
+- [rspec](https://github.com/sheerun/rspec.vim) (syntax)
+- [ruby](https://github.com/vim-ruby/vim-ruby) (syntax, indent, compiler, autoload, ftplugin)
+- [rust](https://github.com/rust-lang/rust.vim) (syntax, indent, compiler, autoload, ftplugin)
+- [sbt](https://github.com/derekwyatt/vim-sbt) (syntax)
+- [scala](https://github.com/derekwyatt/vim-scala) (syntax, indent, compiler, ftplugin)
+- [scss](https://github.com/cakebaker/scss-syntax.vim) (syntax, autoload, ftplugin)
+- [slim](https://github.com/slim-template/vim-slim) (syntax, indent, ftplugin)
+- [solidity](https://github.com/ethereum/vim-solidity) (syntax, indent)
+- [stylus](https://github.com/wavded/vim-stylus) (syntax, indent, ftplugin)
+- [swift](https://github.com/keith/swift.vim) (syntax, indent, ftplugin)
+- [sxhkd](https://github.com/baskerville/vim-sxhkdrc) (syntax)
+- [systemd](https://github.com/kurayama/systemd-vim-syntax) (syntax)
+- [terraform](https://github.com/hashivim/vim-terraform) (syntax, indent, ftplugin)
+- [textile](https://github.com/timcharper/textile.vim) (syntax, ftplugin)
+- [thrift](https://github.com/solarnz/thrift.vim) (syntax)
+- [tmux](https://github.com/keith/tmux.vim) (syntax, ftplugin)
 - [tomdoc](https://github.com/wellbredgrapefruit/tomdoc.vim) (syntax)
-- [toml](https://github.com/cespare/vim-toml) (syntax, ftplugin, ftdetect)
-- [twig](https://github.com/evidens/vim-twig) (syntax, ftplugin)
-- [typescript](https://github.com/leafgarland/typescript-vim) (syntax, indent, compiler, ftplugin, ftdetect)
-- [vala](https://github.com/tkztmk/vim-vala) (syntax, indent, ftdetect)
+- [toml](https://github.com/cespare/vim-toml) (syntax, ftplugin)
+- [twig](https://github.com/lumiliet/vim-twig) (syntax, indent, ftplugin)
+- [typescript](https://github.com/leafgarland/typescript-vim) (syntax, indent, compiler, ftplugin)
+- [vala](https://github.com/arrufat/vala.vim) (syntax, indent)
 - [vbnet](https://github.com/vim-scripts/vbnet.vim) (syntax)
-- [vcl](https://github.com/smerrill/vcl-vim-plugin) (syntax, ftdetect)
-- [vm](https://github.com/lepture/vim-velocity) (syntax, indent, ftdetect)
+- [vcl](https://github.com/smerrill/vcl-vim-plugin) (syntax)
+- [vm](https://github.com/lepture/vim-velocity) (syntax, indent)
+- [vue](https://github.com/posva/vim-vue) (syntax, indent, ftplugin)
 - [xls](https://github.com/vim-scripts/XSLT-syntax) (syntax)
 - [yaml](https://github.com/stephpy/vim-yaml) (syntax, ftplugin)
 - [yard](https://github.com/sheerun/vim-yardoc) (syntax)
 
-## Disabling a language pack
+## Updating
 
-Individual language packs can be disabled by setting `g:polyglot_disabled`.
+You can either wait for new patch release with updates or run the `./build` script by yourself.
+
+## Troubleshooting
+
+Please make sure you have `syntax on` in your `.vimrc`, otherwise syntax files are not loaded at all.
+
+Individual language packs can be disabled by setting `g:polyglot_disabled` as follows:
 
 ```viml
 " ~/.vimrc
@@ -123,10 +154,6 @@ let g:polyglot_disabled = ['css']
 
 Note that disabiling languages won't make in general your vim startup any faster / slower (only for specific file type). Vim-polyglot is selection of language plugins that are loaded only on demand.
 
-## Updating
-
-You can either wait for new patch release with updates or run the `./build` script by yourself.
-
 ## Contributing
 
 Language packs are periodically updated using automated `build` script.

after/ftplugin/javascript.vim

@@ -0,0 +1,16 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') == -1
+  
+" Vim filetype plugin file
+" Language:     JavaScript
+" Maintainer:   vim-javascript community
+" URL:          https://github.com/pangloss/vim-javascript
+
+setlocal iskeyword+=$ suffixesadd+=.js
+
+if exists('b:undo_ftplugin')
+  let b:undo_ftplugin .= ' | setlocal iskeyword< suffixesadd<'
+else
+  let b:undo_ftplugin = 'setlocal iskeyword< suffixesadd<'
+endif
+
+endif

after/ftplugin/jsx.vim

@@ -5,7 +5,6 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'jsx') == -1
 "
 " Language: JSX (JavaScript)
 " Maintainer: Max Wang <mxawng@gmail.com>
-" Depends: pangloss/vim-javascript
 "
 """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 

after/ftplugin/terraform.vim

@@ -0,0 +1,28 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'terraform') == -1
+  
+if !exists('g:terraform_align')
+  let g:terraform_align = 0
+endif
+
+if g:terraform_align && exists(':Tabularize')
+  inoremap <buffer> <silent> = =<Esc>:call <SID>terraformalign()<CR>a
+  function! s:terraformalign()
+    let p = '^.*=[^>]*$'
+    if exists(':Tabularize') && getline('.') =~# '^.*=' && (getline(line('.')-1) =~# p || getline(line('.')+1) =~# p)
+      let column = strlen(substitute(getline('.')[0:col('.')],'[^=]','','g'))
+      let position = strlen(matchstr(getline('.')[0:col('.')],'.*=\s*\zs.*'))
+      Tabularize/=/l1
+      normal! 0
+      call search(repeat('[^=]*=',column).'\s\{-\}'.repeat('.',position),'ce',line('.'))
+    endif
+  endfunction
+endif
+
+" Match the identation put in place by Hashicorp and :TerraformFmt, https://github.com/hashivim/vim-terraform/issues/21
+if get(g:, "terraform_align", 1)
+  setlocal tabstop=2
+  setlocal softtabstop=2
+  setlocal shiftwidth=2
+endif
+
+endif

after/indent/html.vim

@@ -20,7 +20,7 @@ setlocal indentexpr=GetCoffeeHtmlIndent(v:lnum)
 
 function! GetCoffeeHtmlIndent(curlinenum)
   " See if we're inside a coffeescript block.
-  let scriptlnum = searchpair('<script [^>]*type="text/coffeescript"[^>]*>', '',
+  let scriptlnum = searchpair('<script [^>]*type=[''"]\?text/coffeescript[''"]\?[^>]*>', '',
   \                           '</script>', 'bWn')
   let prevlnum = prevnonblank(a:curlinenum)
 

after/indent/jsx.vim

@@ -5,10 +5,12 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'jsx') == -1
 "
 " Language: JSX (JavaScript)
 " Maintainer: Max Wang <mxawng@gmail.com>
-" Depends: pangloss/vim-javascript
 "
 """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 
+" Save the current JavaScript indentexpr.
+let b:jsx_js_indentexpr = &indentexpr
+
 " Prologue; load in XML indentation.
 if exists('b:did_indent')
   let s:did_indent=b:did_indent
@@ -51,19 +53,31 @@ fu! SynXMLish(syns)
   return SynAttrXMLish(get(a:syns, -1))
 endfu
 
-" Check if a synstack has any XMLish attribute.
-fu! SynXMLishAny(syns)
-  for synattr in a:syns
-    if SynAttrXMLish(synattr)
-      return 1
-    endif
-  endfor
-  return 0
-endfu
-
 " Check if a synstack denotes the end of a JSX block.
 fu! SynJSXBlockEnd(syns)
-  return get(a:syns, -1) == 'jsBraces' && SynAttrXMLish(get(a:syns, -2))
+  return get(a:syns, -1) =~ '\%(js\|javascript\)Braces' &&
+       \ SynAttrXMLish(get(a:syns, -2))
+endfu
+
+" Determine how many jsxRegions deep a synstack is.
+fu! SynJSXDepth(syns)
+  return len(filter(copy(a:syns), 'v:val ==# "jsxRegion"'))
+endfu
+
+" Check whether `cursyn' continues the same jsxRegion as `prevsyn'.
+fu! SynJSXContinues(cursyn, prevsyn)
+  let curdepth = SynJSXDepth(a:cursyn)
+  let prevdepth = SynJSXDepth(a:prevsyn)
+
+  " In most places, we expect the nesting depths to be the same between any
+  " two consecutive positions within a jsxRegion (e.g., between a parent and
+  " child node, between two JSX attributes, etc.).  The exception is between
+  " sibling nodes, where after a completed element (with depth N), we return
+  " to the parent's nesting (depth N - 1).  This case is easily detected,
+  " since it is the only time when the top syntax element in the synstack is
+  " jsxRegion---specifically, the jsxRegion corresponding to the parent.
+  return prevdepth == curdepth ||
+      \ (prevdepth == curdepth + 1 && get(a:cursyn, -1) ==# 'jsxRegion')
 endfu
 
 " Cleverly mix JS and XML indentation.
@@ -71,9 +85,12 @@ fu! GetJsxIndent()
   let cursyn  = SynSOL(v:lnum)
   let prevsyn = SynEOL(v:lnum - 1)
 
-  " Use XML indenting if the syntax at the end of the previous line was either
-  " JSX or was the closing brace of a jsBlock whose parent syntax was JSX.
-  if (SynXMLish(prevsyn) || SynJSXBlockEnd(prevsyn)) && SynXMLishAny(cursyn)
+  " Use XML indenting iff:
+  "   - the syntax at the end of the previous line was either JSX or was the
+  "     closing brace of a jsBlock whose parent syntax was JSX; and
+  "   - the current line continues the same jsxRegion as the previous line.
+  if (SynXMLish(prevsyn) || SynJSXBlockEnd(prevsyn)) &&
+        \ SynJSXContinues(cursyn, prevsyn)
     let ind = XmlIndentGet(v:lnum, 0)
 
     " Align '/>' and '>' with '<' for multiline tags.
@@ -86,7 +103,13 @@ fu! GetJsxIndent()
       let ind = ind + &sw
     endif
   else
-    let ind = GetJavascriptIndent()
+    if len(b:jsx_js_indentexpr)
+      " Invoke the base JS package's custom indenter.  (For vim-javascript,
+      " e.g., this will be GetJavascriptIndent().)
+      let ind = eval(b:jsx_js_indentexpr)
+    else
+      let ind = cindent(v:lnum)
+    endif
   endif
 
   return ind

after/syntax/c.vim

@@ -24,6 +24,16 @@ syn match    cCustomParen    "(" contains=cParen contains=cCppParen
 syn match    cCustomFunc     "\w\+\s*(\@=" contains=cCustomParen
 hi def link cCustomFunc  Function
 
+" -----------------------------------------------------------------------------
+"  Highlight member variable names.
+" -----------------------------------------------------------------------------
+if exists('g:cpp_member_variable_highlight') && g:cpp_member_variable_highlight
+    syn match   cCustomDot    "\." contained
+    syn match   cCustomPtr    "->" contained
+    syn match   cCustomMemVar "\(\.\|->\)\w\+" contains=cCustomDot,cCustomPtr
+    hi def link cCustomMemVar Function
+endif
+
 " -----------------------------------------------------------------------------
 "  Source: aftersyntaxc.vim
 " -----------------------------------------------------------------------------

after/syntax/haml.vim

@@ -5,6 +5,11 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'coffee-script')
 " URL:         http://github.com/kchmck/vim-coffee-script
 " License:     WTFPL
 
+
+if exists('b:current_syntax')
+  let s:current_syntax_save = b:current_syntax
+endif
+
 " Inherit coffee from html so coffeeComment isn't redefined and given higher
 " priority than hamlInterpolation.
 syn cluster hamlCoffeescript contains=@htmlCoffeeScript
@@ -14,4 +19,9 @@ syn region  hamlCoffeescriptFilter matchgroup=hamlFilter
 \                                  contains=@hamlCoffeeScript,hamlInterpolation
 \                                  keepend
 
+if exists('s:current_syntax_save')
+  let b:current_syntax = s:current_syntax_save
+  unlet s:current_syntax_save
+endif
+
 endif

after/syntax/html.vim

@@ -5,13 +5,22 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'coffee-script')
 " URL:         http://github.com/kchmck/vim-coffee-script
 " License:     WTFPL
 
+if exists('b:current_syntax')
+  let s:current_syntax_save = b:current_syntax
+endif
+
 " Syntax highlighting for text/coffeescript script tags
 syn include @htmlCoffeeScript syntax/coffee.vim
-syn region coffeeScript start=#<script [^>]*type="text/coffeescript"[^>]*>#
+syn region coffeeScript start=#<script [^>]*type=['"]\?text/coffeescript['"]\?[^>]*>#
 \                       end=#</script>#me=s-1 keepend
 \                       contains=@htmlCoffeeScript,htmlScriptTag,@htmlPreproc
 \                       containedin=htmlHead
 
+if exists('s:current_syntax_save')
+  let b:current_syntax = s:current_syntax_save
+  unlet s:current_syntax_save
+endif
+
 endif
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'glsl') == -1
   
@@ -25,6 +34,22 @@ syn region ShaderScript
       \ end="</script>"me=s-1
       \ contains=@GLSL,htmlScriptTag,@htmlPreproc
 
+endif
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'html5') == -1
+  
+" 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=+>+
+
 endif
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'less') == -1
   

after/syntax/jsx.vim

@@ -48,7 +48,7 @@ syn region jsxChild contained start=+{+ end=++ contains=jsBlock,javascriptBlock
 " preceding it, to avoid conflicts with, respectively, the left shift operator
 " and generic Flow type annotations (http://flowtype.org/).
 syn region jsxRegion
-  \ contains=@XMLSyntax,jsxRegion,jsxChild,jsBlock,javascriptBlock
+  \ contains=@Spell,@XMLSyntax,jsxRegion,jsxChild,jsBlock,javascriptBlock
   \ start=+\%(<\|\w\)\@<!<\z([a-zA-Z][a-zA-Z0-9:\-.]*\)+
   \ skip=+<!--\_.\{-}-->+
   \ end=+</\z1\_\s\{-}>+

after/syntax/mma.vim

@@ -0,0 +1,107 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'mathematica') == -1
+  
+"Vim conceal file
+" Language: Mathematica
+" Maintainer: R. Menon <rsmenon@icloud.com>
+" Last Change: Feb 25, 2013
+
+if (exists('g:mma_candy') && g:mma_candy == 0) || !has('conceal') || &enc != 'utf-8'
+    finish
+endif
+
+"These are fairly safe and straightforward conceals
+if exists('g:mma_candy') && g:mma_candy > 0
+	"Rules
+	syntax match mmaOperator "->" conceal cchar=→ "Rule
+	syntax match mmaOperator ":>" conceal cchar=⧴ "RuleDelayed
+
+	"Logicals
+	syntax match mmaOperator "===" conceal cchar=≡ "SameQ
+	syntax match mmaOperator "=!=" conceal cchar=≢ "UnsameQ
+	syntax match mmaOperator "!=" conceal cchar=≠ "NotEqual
+	syntax match mmaOperator "<=" conceal cchar=≤ "LessEqual
+	syntax match mmaOperator ">=" conceal cchar=≥ "GreaterEqual
+
+	"Constants
+	syntax keyword mmaSystemSymbol Pi conceal cchar=π
+	syntax keyword mmaSystemSymbol Infinity conceal cchar=∞
+	syntax keyword mmaSystemSymbol Degree conceal cchar=°
+
+	"Domains
+	syntax keyword mmaSystemSymbol Reals conceal cchar=ℝ
+	syntax keyword mmaSystemSymbol Integers conceal cchar=ℤ
+	syntax keyword mmaSystemSymbol Complexes conceal cchar=ℂ
+	syntax keyword mmaSystemSymbol Rationals conceal cchar=ℚ
+
+	"Greek
+	syntax match mmaSymbol "\\\[CapitalAlpha\]" conceal cchar=Α
+	syntax match mmaSymbol "\\\[CapitalBeta\]" conceal cchar=Β
+	syntax match mmaSymbol "\\\[CapitalGamma\]" conceal cchar=Γ
+	syntax match mmaSymbol "\\\[CapitalDelta\]" conceal cchar=Δ
+	syntax match mmaSymbol "\\\[CapitalEpsilon\]" conceal cchar=Ε
+	syntax match mmaSymbol "\\\[CapitalZeta\]" conceal cchar=Ζ
+	syntax match mmaSymbol "\\\[CapitalEta\]" conceal cchar=Η
+	syntax match mmaSymbol "\\\[CapitalTheta\]" conceal cchar=Θ
+	syntax match mmaSymbol "\\\[CapitalIota\]" conceal cchar=Ι
+	syntax match mmaSymbol "\\\[CapitalKappa\]" conceal cchar=Κ
+	syntax match mmaSymbol "\\\[CapitalLambda\]" conceal cchar=Λ
+	syntax match mmaSymbol "\\\[CapitalMu\]" conceal cchar=Μ
+	syntax match mmaSymbol "\\\[CapitalNu\]" conceal cchar=Ν
+	syntax match mmaSymbol "\\\[CapitalXi\]" conceal cchar=Ξ
+	syntax match mmaSymbol "\\\[CapitalOmicron\]" conceal cchar=Ο
+	syntax match mmaSymbol "\\\[CapitalPi\]" conceal cchar=Π
+	syntax match mmaSymbol "\\\[CapitalRho\]" conceal cchar=Ρ
+	syntax match mmaSymbol "\\\[CapitalSigma\]" conceal cchar=Σ
+	syntax match mmaSymbol "\\\[CapitalTau\]" conceal cchar=Τ
+	syntax match mmaSymbol "\\\[CapitalUpsilon\]" conceal cchar=Υ
+	syntax match mmaSymbol "\\\[CapitalPhi\]" conceal cchar=Φ
+	syntax match mmaSymbol "\\\[CapitalChi\]" conceal cchar=Χ
+	syntax match mmaSymbol "\\\[CapitalPsi\]" conceal cchar=Ψ
+	syntax match mmaSymbol "\\\[CapitalOmega\]" conceal cchar=Ω
+	syntax match mmaSymbol "\\\[Alpha\]" conceal cchar=α
+	syntax match mmaSymbol "\\\[Beta\]" conceal cchar=β
+	syntax match mmaSymbol "\\\[Gamma\]" conceal cchar=γ
+	syntax match mmaSymbol "\\\[Delta\]" conceal cchar=δ
+	syntax match mmaSymbol "\\\[Epsilon\]" conceal cchar=ε
+	syntax match mmaSymbol "\\\[Zeta\]" conceal cchar=ζ
+	syntax match mmaSymbol "\\\[Eta\]" conceal cchar=η
+	syntax match mmaSymbol "\\\[Theta\]" conceal cchar=θ
+	syntax match mmaSymbol "\\\[Iota\]" conceal cchar=ι
+	syntax match mmaSymbol "\\\[Kappa\]" conceal cchar=κ
+	syntax match mmaSymbol "\\\[Lambda\]" conceal cchar=λ
+	syntax match mmaSymbol "\\\[Mu\]" conceal cchar=μ
+	syntax match mmaSymbol "\\\[Nu\]" conceal cchar=ν
+	syntax match mmaSymbol "\\\[Xi\]" conceal cchar=ξ
+	syntax match mmaSymbol "\\\[Omicron\]" conceal cchar=ο
+	syntax match mmaSymbol "\\\[Pi\]" conceal cchar=π
+	syntax match mmaSymbol "\\\[Rho\]" conceal cchar=ρ
+	syntax match mmaSymbol "\\\[Sigma\]" conceal cchar=σ
+	syntax match mmaSymbol "\\\[Tau\]" conceal cchar=τ
+	syntax match mmaSymbol "\\\[Upsilon\]" conceal cchar=υ
+	syntax match mmaSymbol "\\\[Phi\]" conceal cchar=φ
+	syntax match mmaSymbol "\\\[Chi\]" conceal cchar=χ
+	syntax match mmaSymbol "\\\[Psi\]" conceal cchar=ψ
+	syntax match mmaSymbol "\\\[Omega\]" conceal cchar=ω
+endif
+
+"These might be troublesome if the appropriate fonts are missing. Also, they don't
+"look quite as good as the earlier ones, so enable only if the user chooses to
+if exists('g:mma_candy') && g:mma_candy == 2
+	"Constants
+	syntax keyword mmaSystemSymbol I conceal cchar=ⅈ
+	syntax keyword mmaSystemSymbol E conceal cchar=ⅇ
+
+	"Functions
+	syntax keyword mmaSystemSymbol Sum conceal cchar=∑
+	syntax keyword mmaSystemSymbol Product conceal cchar=∏
+	syntax keyword mmaSystemSymbol Sqrt conceal cchar=√
+
+	"Misc
+	syntax match mmaOperator ">>" conceal cchar=» "Put
+	syntax match mmaOperator "<<" conceal cchar=« "Get
+endif
+
+hi! link Conceal Normal
+setlocal conceallevel=2
+
+endif

after/syntax/yaml.vim

@@ -21,9 +21,7 @@ if version < 600
 endif
 syntax clear
 
-syn match yamlDelimiter	"[:,-]"
 syn match yamlBlock "[\[\]\{\}\|\>]"
-syn match yamlOperator "[?^+-]\|=>"
 
 syn region yamlComment	start="\#" end="$"
 syn match yamlIndicator	"#YAML:\S\+"
@@ -40,11 +38,12 @@ syn keyword yamlConstant NULL Null null NONE None none NIL Nil nil
 syn keyword yamlConstant TRUE True true YES Yes yes ON On on
 syn keyword yamlConstant FALSE False false NO No no OFF Off off
 
-syn match  yamlKey	"\w\+\ze\s*:"
+syn match  yamlKey	"^\s*\zs\S\+\ze\s*:"
+syn match  yamlKey	"^\s*-\s*\zs\S\+\ze\s*:"
 syn match  yamlAnchor	"&\S\+"
 syn match  yamlAlias	"*\S\+"
 
-" Setupt the hilighting links
+" Setup the highlighting links
 
 hi link yamlConstant Keyword
 hi link yamlIndicator PreCondit
@@ -55,10 +54,7 @@ hi link yamlType	Type
 
 hi link yamlComment	Comment
 hi link yamlBlock	Operator
-hi link yamlOperator	Operator
-hi link yamlDelimiter	Delimiter
 hi link yamlString	String
 hi link yamlEscape	Special
 
-
 endif

autoload/dart.vim

@@ -20,18 +20,20 @@ endfunction
 
 function! dart#fmt(q_args) abort
   if executable('dartfmt')
-    let path = expand('%:p:gs:\:/:')
-    if filereadable(path)
-      let joined_lines = system(printf('dartfmt %s %s', a:q_args, shellescape(path)))
-      if 0 == v:shell_error
-        silent % delete _
-        silent put=joined_lines
-        silent 1 delete _
-      else
-        call s:cexpr('line %l\, column %c of %f: %m', joined_lines)
-      endif
+    let buffer_content = join(getline(1, '$'), "\n")
+    let joined_lines = system(printf('dartfmt %s', a:q_args), buffer_content)
+    if 0 == v:shell_error
+      let win_view = winsaveview()
+      silent % delete _
+      silent put=joined_lines
+      silent 1 delete _
+      call winrestview(win_view)
     else
-      call s:error(printf('cannot read a file: "%s"', path))
+      let errors = split(joined_lines, "\n")[2:]
+      let file_path = expand('%')
+      call map(errors, 'file_path.":".v:val')
+      let error_format = '%A%f:line %l\, column %c of stdin: %m,%C%.%#'
+      call s:cexpr(error_format, join(errors, "\n"))
     endif
   else
     call s:error('cannot execute binary file: dartfmt')
@@ -66,5 +68,86 @@ function! dart#tojs(q_args) abort
   endif
 endfunction
 
+" Finds the path to `uri`.
+"
+" If the file is a package: uri, looks for a .packages file to resolve the path.
+" If the path cannot be resolved, or is not a package: uri, returns the
+" original.
+function! dart#resolveUri(uri) abort
+  if a:uri !~ 'package:'
+    return a:uri
+  endif
+  let package_name = substitute(a:uri, 'package:\(\w\+\)\/.*', '\1', '')
+  let [found, package_map] = s:PackageMap()
+  if !found
+    call s:error('cannot find .packages file')
+    return a:uri
+  endif
+  if !has_key(package_map, package_name)
+    call s:error('no package mapping for '.package_name)
+    return a:uri
+  endif
+  let package_lib = package_map[package_name]
+  return substitute(a:uri,
+      \ 'package:'.package_name,
+      \ escape(package_map[package_name], '\'),
+      \ '')
+endfunction
+
+" A map from package name to lib directory parse from a '.packages' file.
+"
+" Returns [found, package_map]
+function! s:PackageMap() abort
+  let [found, dot_packages] = s:DotPackagesFile()
+  if !found
+    return [v:false, {}]
+  endif
+  let dot_packages_dir = fnamemodify(dot_packages, ':p:h')
+  let lines = readfile(dot_packages)
+  let map = {}
+  for line in lines
+    if line =~ '\s*#'
+      continue
+    endif
+    let package = substitute(line, ':.*$', '', '')
+    let lib_dir = substitute(line, '^[^:]*:', '', '')
+    if lib_dir =~ 'file:/'
+      let lib_dir = substitute(lib_dir, 'file://', '', '')
+      if lib_dir =~ '/[A-Z]:/'
+        let lib_dir = lib_dir[1:]
+      endif
+    else
+      let lib_dir = resolve(dot_packages_dir.'/'.lib_dir)
+    endif
+    if lib_dir =~ '/$'
+      let lib_dir = lib_dir[:len(lib_dir) - 2]
+    endif
+    let map[package] = lib_dir
+  endfor
+  return [v:true, map]
+endfunction
+
+" Finds a file name '.packages' in the cwd, or in any directory above the open
+" file.
+"
+" Returns [found, file].
+function! s:DotPackagesFile() abort
+  if filereadable('.packages')
+    return [v:true, '.packages']
+  endif
+  let dir_path = expand('%:p:h')
+  while v:true
+    let file_path = dir_path.'/.packages'
+    if filereadable(file_path)
+      return [v:true, file_path]
+    endif
+    let parent = fnamemodify(dir_path, ':h')
+    if dir_path == parent
+      break
+    endif
+    let dir_path = parent
+  endwhile
+  return [v:false, '']
+endfunction
 
 endif

autoload/elixir/indent.vim

@@ -0,0 +1,219 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elixir') == -1
+  
+let s:NO_COLON_BEFORE = ':\@<!'
+let s:NO_COLON_AFTER = ':\@!'
+let s:ENDING_SYMBOLS = '\]\|}\|)'
+let s:ARROW = '->'
+let s:END_WITH_ARROW = s:ARROW.'$'
+let s:SKIP_SYNTAX = '\%(Comment\|String\)$'
+let s:BLOCK_SKIP = "synIDattr(synID(line('.'),col('.'),1),'name') =~? '".s:SKIP_SYNTAX."'"
+let s:DEF = '^\s*def'
+let s:FN = '\<fn\>'
+let s:MULTILINE_FN = s:FN.'\%(.*end\)\@!'
+let s:BLOCK_START = '\%(\<do\>\|'.s:FN.'\)\>'
+let s:MULTILINE_BLOCK = '\%(\<do\>'.s:NO_COLON_AFTER.'\|'.s:MULTILINE_FN.'\)'
+let s:BLOCK_MIDDLE = '\<\%(else\|match\|elsif\|catch\|after\|rescue\)\>'
+let s:BLOCK_END = 'end'
+let s:STARTS_WITH_PIPELINE = '^\s*|>.*$'
+let s:QUERY_FROM = '^\s*\<from\>.*\<in\>.*,'
+let s:ENDING_WITH_ASSIGNMENT = '=\s*$'
+let s:INDENT_KEYWORDS = s:NO_COLON_BEFORE.'\%('.s:MULTILINE_BLOCK.'\|'.s:BLOCK_MIDDLE.'\)'
+let s:DEINDENT_KEYWORDS = '^\s*\<\%('.s:BLOCK_END.'\|'.s:BLOCK_MIDDLE.'\)\>'
+let s:PAIR_START = '\<\%('.s:NO_COLON_BEFORE.s:BLOCK_START.'\)\>'.s:NO_COLON_AFTER
+let s:PAIR_MIDDLE = '^\s*\%('.s:BLOCK_MIDDLE.'\)\>'.s:NO_COLON_AFTER.'\zs'
+let s:PAIR_END = '\<\%('.s:NO_COLON_BEFORE.s:BLOCK_END.'\)\>\zs'
+let s:LINE_COMMENT = '^\s*#'
+let s:MATCH_OPERATOR = '[^!><=]=[^~=>]'
+
+function! s:pending_parenthesis(line)
+  if a:line.last_non_blank.text !~ s:ARROW
+    return elixir#util#count_indentable_symbol_diff(a:line.last_non_blank, '(', '\%(end\s*\)\@<!)')
+  end
+endfunction
+
+function! s:pending_square_brackets(line)
+  if a:line.last_non_blank.text !~ s:ARROW
+    return elixir#util#count_indentable_symbol_diff(a:line.last_non_blank, '[', ']')
+  end
+endfunction
+
+function! s:pending_brackets(line)
+  if a:line.last_non_blank.text !~ s:ARROW
+    return elixir#util#count_indentable_symbol_diff(a:line.last_non_blank, '{', '}')
+  end
+endfunction
+
+function! elixir#indent#deindent_case_arrow(ind, line)
+  if get(b:old_ind, 'arrow', 0) > 0
+        \ && (a:line.current.text =~ s:ARROW
+        \ || a:line.current.text =~ s:BLOCK_END)
+    let ind = b:old_ind.arrow
+    let b:old_ind.arrow = 0
+    return ind
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#deindent_ending_symbols(ind, line)
+  if a:line.current.text =~ '^\s*\('.s:ENDING_SYMBOLS.'\)'
+    return a:ind - &sw
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#deindent_keywords(ind, line)
+  if a:line.current.text =~ s:DEINDENT_KEYWORDS
+    let bslnum = searchpair(
+          \ s:PAIR_START,
+          \ s:PAIR_MIDDLE,
+          \ s:PAIR_END,
+          \ 'nbW',
+          \ s:BLOCK_SKIP
+          \ )
+
+    return indent(bslnum)
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#deindent_opened_symbols(ind, line)
+  let s:opened_symbol =
+        \   s:pending_parenthesis(a:line)
+        \ + s:pending_square_brackets(a:line)
+        \ + s:pending_brackets(a:line)
+
+  if s:opened_symbol < 0
+    let ind = get(b:old_ind, 'symbol', a:ind + (s:opened_symbol * &sw))
+    let ind = float2nr(ceil(floor(ind)/&sw)*&sw)
+    return ind <= 0 ? 0 : ind
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_after_pipeline(ind, line)
+  if exists("b:old_ind.pipeline")
+        \ && elixir#util#is_blank(a:line.last.text)
+        \ && a:line.current.text !~ s:STARTS_WITH_PIPELINE
+    " Reset indentation in pipelines if there is a blank line between
+    " pipes
+    let ind = b:old_ind.pipeline
+    unlet b:old_ind.pipeline
+    return ind
+  elseif a:line.last_non_blank.text =~ s:STARTS_WITH_PIPELINE
+    if empty(substitute(a:line.current.text, ' ', '', 'g'))
+          \ || a:line.current.text =~ s:STARTS_WITH_PIPELINE
+      return indent(a:line.last_non_blank.num)
+    elseif a:line.last_non_blank.text !~ s:INDENT_KEYWORDS
+      let ind = b:old_ind.pipeline
+      unlet b:old_ind.pipeline
+      return ind
+    end
+  end
+
+  return a:ind
+endfunction
+
+function! elixir#indent#indent_assignment(ind, line)
+  if a:line.last_non_blank.text =~ s:ENDING_WITH_ASSIGNMENT
+    let b:old_ind.pipeline = indent(a:line.last_non_blank.num) " FIXME: side effect
+    return a:ind + &sw
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_brackets(ind, line)
+  if s:pending_brackets(a:line) > 0
+    return a:ind + &sw
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_case_arrow(ind, line)
+  if a:line.last_non_blank.text =~ s:END_WITH_ARROW && a:line.last_non_blank.text !~ '\<fn\>'
+    let b:old_ind.arrow = a:ind
+    return a:ind + &sw
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_ending_symbols(ind, line)
+  if a:line.last_non_blank.text =~ '^\s*\('.s:ENDING_SYMBOLS.'\)\s*$'
+    return a:ind + &sw
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_keywords(ind, line)
+  if a:line.last_non_blank.text =~ s:INDENT_KEYWORDS && a:line.last_non_blank.text !~ s:LINE_COMMENT
+    return a:ind + &sw
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_parenthesis(ind, line)
+  if s:pending_parenthesis(a:line) > 0
+        \ && a:line.last_non_blank.text !~ s:DEF
+        \ && a:line.last_non_blank.text !~ s:END_WITH_ARROW
+    let b:old_ind.symbol = a:ind
+    return matchend(a:line.last_non_blank.text, '(')
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_pipeline_assignment(ind, line)
+  if a:line.current.text =~ s:STARTS_WITH_PIPELINE
+        \ && a:line.last_non_blank.text =~ s:MATCH_OPERATOR
+    let b:old_ind.pipeline = indent(a:line.last_non_blank.num)
+    " if line starts with pipeline
+    " and last_non_blank line is an attribution
+    " indents pipeline in same level as attribution
+    let assign_pos = match(a:line.last_non_blank.text, '=\s*\zs[^ ]')
+    return (elixir#util#is_indentable_at(a:line.last_non_blank.num, assign_pos) ? assign_pos : a:ind)
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_pipeline_continuation(ind, line)
+  if a:line.last_non_blank.text =~ s:STARTS_WITH_PIPELINE
+        \ && a:line.current.text =~ s:STARTS_WITH_PIPELINE
+    return indent(a:line.last_non_blank.num)
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_square_brackets(ind, line)
+  if s:pending_square_brackets(a:line) > 0
+    if a:line.last_non_blank.text =~ '[\s*$'
+      return a:ind + &sw
+    else
+      " if start symbol is followed by a character, indent based on the
+      " whitespace after the symbol, otherwise use the default shiftwidth
+      " Avoid negative indentation index
+      return matchend(a:line.last_non_blank.text, '[\s*')
+    end
+  else
+    return a:ind
+  end
+endfunction
+
+function! elixir#indent#indent_ecto_queries(ind, line)
+  if a:line.last_non_blank.text =~ s:QUERY_FROM
+    return a:ind + &sw
+  else
+    return a:ind
+  end
+endfunction
+
+endif

autoload/elixir/util.vim

@@ -0,0 +1,52 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elixir') == -1
+  
+let s:SKIP_SYNTAX = '\%(Comment\|String\)$'
+
+function! elixir#util#is_indentable_at(line, col)
+  if a:col == -1 " skip synID lookup for not found match
+    return 1
+  end
+  " TODO: Remove these 2 lines
+  " I don't know why, but for the test on spec/indent/lists_spec.rb:24.
+  " Vim is making some mess on parsing the syntax of 'end', it is being
+  " recognized as 'elixirString' when should be recognized as 'elixirBlock'.
+  call synID(a:line, a:col, 1)
+  " This forces vim to sync the syntax. Using fromstart is very slow on files
+  " over 1k lines
+  syntax sync minlines=20 maxlines=150
+
+  return synIDattr(synID(a:line, a:col, 1), "name")
+        \ !~ s:SKIP_SYNTAX
+endfunction
+
+function! elixir#util#count_indentable_symbol_diff(line, open, close)
+  return
+        \   s:match_count(a:line, a:open)
+        \ - s:match_count(a:line, a:close)
+endfunction
+
+function! s:match_count(line, pattern)
+  let size = strlen(a:line.text)
+  let index = 0
+  let counter = 0
+
+  while index < size
+    let index = match(a:line.text, a:pattern, index)
+    if index >= 0
+      let index += 1
+      if elixir#util#is_indentable_at(a:line.num, index)
+        let counter +=1
+      end
+    else
+      break
+    end
+  endwhile
+
+  return counter
+endfunction
+
+function elixir#util#is_blank(string)
+  return a:string =~ '^\s*$'
+endfunction
+
+endif

autoload/python/utils.vim

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

autoload/rubycomplete.vim

@@ -198,7 +198,7 @@ function! rubycomplete#Complete(findstart, base)
             if c =~ '\w'
                 continue
             elseif ! c =~ '\.'
-                idx = -1
+                let idx = -1
                 break
             else
                 break
@@ -589,11 +589,13 @@ class VimRubyCompletion
 # {{{ main completion code
   def self.preload_rails
     a = VimRubyCompletion.new
-    require 'Thread'
-    Thread.new(a) do |b|
-      begin
-      b.load_rails
-      rescue
+    if VIM::evaluate("has('nvim')") == 0
+      require 'thread'
+      Thread.new(a) do |b|
+        begin
+        b.load_rails
+        rescue
+        end
       end
     end
     a.load_rails

autoload/rustfmt.vim

@@ -22,17 +22,20 @@ endif
 
 let s:got_fmt_error = 0
 
-function! rustfmt#Format()
-  let l:curw = winsaveview()
-  let l:tmpname = expand("%:p:h") . "/." . expand("%:p:t") . ".rustfmt"
-  call writefile(getline(1, '$'), l:tmpname)
+function! s:RustfmtCommandRange(filename, line1, line2)
+  let l:arg = {"file": shellescape(a:filename), "range": [a:line1, a:line2]}
+  return printf("%s %s --write-mode=overwrite --file-lines '[%s]'", g:rustfmt_command, g:rustfmt_options, json_encode(l:arg))
+endfunction
 
-  let command = g:rustfmt_command . " --write-mode=overwrite "
+function! s:RustfmtCommand(filename)
+  return g:rustfmt_command . " --write-mode=overwrite " . g:rustfmt_options . " " . shellescape(a:filename)
+endfunction
 
+function! s:RunRustfmt(command, curw, tmpname)
   if exists("*systemlist")
-    let out = systemlist(command . g:rustfmt_options . " " . shellescape(l:tmpname))
+    let out = systemlist(a:command)
   else
-    let out = split(system(command . g:rustfmt_options . " " . shellescape(l:tmpname)), '\r\?\n')
+    let out = split(system(a:command), '\r\?\n')
   endif
 
   if v:shell_error == 0 || v:shell_error == 3
@@ -40,7 +43,7 @@ function! rustfmt#Format()
     try | silent undojoin | catch | endtry
 
     " Replace current file with temp file, then reload buffer
-    call rename(l:tmpname, expand('%'))
+    call rename(a:tmpname, expand('%'))
     silent edit!
     let &syntax = &syntax
 
@@ -78,10 +81,30 @@ function! rustfmt#Format()
     let s:got_fmt_error = 1
     lwindow
     " We didn't use the temp file, so clean up
-    call delete(l:tmpname)
+    call delete(a:tmpname)
   endif
 
-  call winrestview(l:curw)
+  call winrestview(a:curw)
+endfunction
+
+function! rustfmt#FormatRange(line1, line2)
+  let l:curw = winsaveview()
+  let l:tmpname = expand("%:p:h") . "/." . expand("%:p:t") . ".rustfmt"
+  call writefile(getline(1, '$'), l:tmpname)
+
+  let command = s:RustfmtCommandRange(l:tmpname, a:line1, a:line2)
+
+  call s:RunRustfmt(command, l:curw, l:tmpname)
+endfunction
+
+function! rustfmt#Format()
+  let l:curw = winsaveview()
+  let l:tmpname = expand("%:p:h") . "/." . expand("%:p:t") . ".rustfmt"
+  call writefile(getline(1, '$'), l:tmpname)
+
+  let command = s:RustfmtCommand(l:tmpname)
+
+  call s:RunRustfmt(command, l:curw, l:tmpname)
 endfunction
 
 endif

autoload/scss_indent.vim

@@ -0,0 +1,41 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'scss') == -1
+  
+" usage:
+" set indentexpr=scss_indent#GetIndent(v:lnum)
+fun! scss_indent#GetIndent(lnum)
+  " { -> increase indent
+  " } -> decrease indent
+  if a:lnum == 1
+    " start at 0 indentation
+    return 0
+  endif
+
+  " try to find last line ending with { or }
+  " ignoring // comments
+  let regex = '\([{}]\)\%(\/\/.*\)\?$'
+  let nr = search(regex, 'bnW')
+  if nr > 0
+    let last = indent(nr)
+    let m = matchlist(getline(nr), regex)
+    let m_curr = matchlist(getline(a:lnum), regex)
+    echoe string(m).string(m_curr)
+    if !empty(m_curr) && m_curr[1] == '}' && m[1] == '{'
+      " last was open, current is close, use same indent
+      return last
+    elseif !empty(m_curr) && m_curr[1] == '}' && m[1] == '}'
+      " } line and last line was }: decrease
+      return last - &sw
+    endif
+    if m[1] == '{'
+      " line after {: increase indent
+      return last + &sw
+    else
+      " line after } or { - same indent
+      return last
+    endif
+  else
+    return 0
+  endif
+endfun
+
+endif

autoload/xml/aria.vim

@@ -3,31 +3,220 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'html5') == -1
 " Vim completion for WAI-ARIA data file
 " Language:       HTML + WAI-ARIA
 " Maintainer:     othree <othree@gmail.com>
-" Last Change:    2010 Sep 09
+" Last Change:    2017 Mar 07
 
 " WAI_ARIA: {{{
-" Ref: http://www.w3.org/TR/wai-aria/
-" Version: Draft 15 December 2009
+" Ref: https://www.w3.org/TR/wai-aria-1.1/
+" Version: W3C Candidate Recommendation 27 October 2016
 
 let abstract_role = {}
 let role_attributes = {}
 let default_role = {}
 
-" Ref: http://www.w3.org/TR/wai-aria/roles
-" Version: Draft 15 December 2009
-let widget_role = ['alert', 'alertdialog', 'button', 'checkbox', 'combobox', 'dialog', 'gridcell', 'link', 'log', 'marquee', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'progressbar', 'radio', 'radiogroup', 'scrollbar', 'slider', 'spinbutton', 'status', 'tab', 'tabpanel', 'textbox', 'timer', 'tooltip', 'treeitem', 'combobox', 'grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'tablist', 'tree', 'treegrid']
-let document_structure = ['article', 'columnheader', 'definition', 'directory', 'document', 'group', 'heading', 'img', 'list', 'listitem', 'math', 'note', 'presentation', 'region', 'row', 'rowheader', 'separator']
-let landmark_role = ['application', 'banner', 'complementary', 'contentinfo', 'form', 'main', 'navigation', 'search']
+" Ref: https://www.w3.org/TR/wai-aria-1.1/#roles_categorization
+" Version: W3C Candidate Recommendation 27 October 2016
+let widget_role = [
+    \ 'alert',
+    \ 'alertdialog',
+    \ 'button',
+    \ 'checkbox',
+    \ 'combobox',
+    \ 'dialog',
+    \ 'gridcell',
+    \ 'link',
+    \ 'log',
+    \ 'marquee',
+    \ 'menuitem',
+    \ 'menuitemcheckbox',
+    \ 'menuitemradio',
+    \ 'option',
+    \ 'progressbar',
+    \ 'radio',
+    \ 'radiogroup',
+    \ 'scrollbar',
+    \ 'searchbox',
+    \ 'slider',
+    \ 'spinbutton',
+    \ 'status',
+    \ 'switch',
+    \ 'tab',
+    \ 'tabpanel',
+    \ 'textbox',
+    \ 'timer',
+    \ 'tooltip',
+    \ 'treeitem',
+    \ 'combobox',
+    \ 'grid',
+    \ 'listbox',
+    \ 'menu',
+    \ 'menubar',
+    \ 'radiogroup',
+    \ 'tablist',
+    \ 'tree',
+    \ 'treegrid'
+\ ]
+
+let document_structure = [
+    \ 'article',
+    \ 'cell',
+    \ 'columnheader',
+    \ 'definition',
+    \ 'directory',
+    \ 'document',
+    \ 'feed',
+    \ 'figure',
+    \ 'group',
+    \ 'heading',
+    \ 'img',
+    \ 'list',
+    \ 'listitem',
+    \ 'math',
+    \ 'none',
+    \ 'note',
+    \ 'presentation',
+    \ 'region',
+    \ 'row',
+    \ 'rowheader',
+    \ 'separator',
+    \ 'table',
+    \ 'term'
+\ ]
+
+let landmark_role = [
+    \ 'application',
+    \ 'banner',
+    \ 'complementary',
+    \ 'contentinfo',
+    \ 'form',
+    \ 'main',
+    \ 'navigation',
+    \ 'search'
+\ ]
+
+" Ref: https://www.w3.org/TR/dpub-aria-1.0/
+" Version: W3C Candidate Recommendation 15 December 2016
+let dpub_role = [
+    \ 'dpub-abstract',
+    \ 'dpub-afterword',
+    \ 'dpub-appendix',
+    \ 'dpub-biblioentry',
+    \ 'dpub-bibliography',
+    \ 'dpub-biblioref',
+    \ 'dpub-chapter',
+    \ 'dpub-cover',
+    \ 'dpub-epilogue',
+    \ 'dpub-footnote',
+    \ 'dpub-footnotes',
+    \ 'dpub-foreword',
+    \ 'dpub-glossary',
+    \ 'dpub-glossdef',
+    \ 'dpub-glossref',
+    \ 'dpub-glossterm',
+    \ 'dpub-index',
+    \ 'dpub-locator',
+    \ 'dpub-noteref',
+    \ 'dpub-notice',
+    \ 'dpub-pagebreak',
+    \ 'dpub-pagelist',
+    \ 'dpub-part',
+    \ 'dpub-preface',
+    \ 'dpub-prologue',
+    \ 'dpub-pullquote',
+    \ 'dpub-qna',
+    \ 'dpub-subtitle',
+    \ 'dpub-tip',
+    \ 'dpub-title',
+    \ 'dpub-toc'
+\ ]
+
 let role = extend(widget_role, document_structure)
 let role = extend(role, landmark_role)
+let role = extend(role, dpub_role)
 
-" http://www.w3.org/TR/wai-aria/states_and_properties#state_prop_taxonomy
-"let global_states_and_properties = {'aria-atomic': ['true', 'false'], 'aria-busy': ['true', 'false'], 'aria-controls': [], 'aria-describedby': [], 'aria-disabled': ['true', 'false'], 'aria-dropeffect': ['copy', 'move', 'link', 'execute', 'popup', 'none'], 'aria-flowto': [], 'aria-grabbed': ['true', 'false', 'undefined'], 'aria-haspopup': ['true', 'false'], 'aria-hidden': ['true', 'false'], 'aria-invalid': ['grammar', 'spelling', 'true', 'false'], 'aria-label': [], 'aria-labelledby': [], 'aria-live': ['off', 'polite', 'assertive'], 'aria-owns': [], 'aria-relevant': ['additions', 'removals', 'text', 'all']}
-let widget_attributes = {'aria-autocomplete': ['inline', 'list', 'both', 'none'], 'aria-checked': ['true', 'false', 'mixed', 'undefined'], 'aria-disabled': ['true', 'false'], 'aria-expanded': ['true', 'false', 'undefined'], 'aria-haspopup': ['true', 'false'], 'aria-hidden': ['true', 'false'], 'aria-invalid': ['grammar', 'spelling', 'true', 'false'], 'aria-label': [], 'aria-level': [], 'aria-multiline': ['true', 'false'], 'aria-multiselectable': ['true', 'false'], 'aria-orientation': ['horizontal', 'vertical'], 'aria-pressed': ['true', 'false', 'mixed', 'undefined'], 'aria-readonly': ['true', 'false'], 'aria-required': ['true', 'false'], 'aria-selected': ['true', 'false', 'undefined'], 'aria-sort': ['ascending', 'descending', 'none', 'other'], 'aria-valuemax': [], 'aria-valuemin': [], 'aria-valuenow': [], 'aria-valuetext': []}
-let live_region_attributes = {'aria-atomic': ['true', 'false'], 'aria-busy': ['true', 'false'], 'aria-live': ['off', 'polite', 'assertive'], 'aria-relevant': ['additions', 'removals', 'text', 'all', 'additions text']}
-let drag_and_drop_attributes = {'aria-dropeffect': ['copy', 'move', 'link', 'execute', 'popup', 'none'], 'aria-grabbed': ['true', 'false', 'undefined']}
-let relationship_attributes = {'aria-activedescendant': [], 'aria-controls': [], 'aria-describedby': [], 'aria-flowto': [], 'aria-labelledby': [], 'aria-owns': [], 'aria-posinset': [], 'aria-setsize': []}
-let aria_attributes = widget_attributes
+" https://www.w3.org/TR/wai-aria-1.1/#states_and_properties
+let global_states_and_properties = {
+    \ 'aria-atomic': ['true', 'false'],
+    \ 'aria-busy': ['true', 'false'],
+    \ 'aria-controls': [],
+    \ 'aria-current': [],
+    \ 'aria-describedby': [],
+    \ 'aria-disabled': ['true', 'false'],
+    \ 'aria-dropeffect': ['copy', 'move', 'link', 'execute', 'popup', 'none'],
+    \ 'aria-errormessage': [],
+    \ 'aria-flowto': [],
+    \ 'aria-grabbed': ['true', 'false', 'undefined'],
+    \ 'aria-haspopup': ['true', 'false'],
+    \ 'aria-hidden': ['true', 'false'],
+    \ 'aria-invalid': ['grammar', 'spelling', 'true', 'false'],
+    \ 'aria-keyshortcuts': [],
+    \ 'aria-label': [],
+    \ 'aria-labelledby': [],
+    \ 'aria-live': ['off', 'polite', 'assertive'],
+    \ 'aria-owns': [],
+    \ 'aria-relevant': ['additions', 'removals', 'text', 'all'],
+    \ 'aria-roledescription': [],
+\ }
+
+let widget_attributes = {
+    \ 'aria-autocomplete': ['inline', 'list', 'both', 'none'],
+    \ 'aria-checked': ['true', 'false', 'mixed', 'undefined'],
+    \ 'aria-disabled': ['true', 'false'],
+    \ 'aria-errormessage': [],
+    \ 'aria-expanded': ['true', 'false', 'undefined'],
+    \ 'aria-haspopup': ['true', 'false'],
+    \ 'aria-hidden': ['true', 'false'],
+    \ 'aria-invalid': ['grammar', 'spelling', 'true', 'false'],
+    \ 'aria-label': [],
+    \ 'aria-level': [],
+    \ 'aria-modal': ['true', 'false'],
+    \ 'aria-multiline': ['true', 'false'],
+    \ 'aria-multiselectable': ['true', 'false'],
+    \ 'aria-orientation': ['horizontal', 'vertical'],
+    \ 'aria-placeholder': [],
+    \ 'aria-pressed': ['true', 'false', 'mixed', 'undefined'],
+    \ 'aria-readonly': ['true', 'false'],
+    \ 'aria-required': ['true', 'false'],
+    \ 'aria-selected': ['true', 'false', 'undefined'],
+    \ 'aria-sort': ['ascending', 'descending', 'none', 'other'],
+    \ 'aria-valuemax': [],
+    \ 'aria-valuemin': [],
+    \ 'aria-valuenow': [],
+    \ 'aria-valuetext': []
+\ }
+
+let live_region_attributes = {
+    \ 'aria-atomic': ['true', 'false'],
+    \ 'aria-busy': ['true', 'false'],
+    \ 'aria-live': ['off', 'polite', 'assertive'],
+    \ 'aria-relevant': ['additions', 'removals', 'text', 'all', 'additions text']
+\ }
+
+let drag_and_drop_attributes = {
+    \ 'aria-dropeffect': ['copy', 'move', 'link', 'execute', 'popup', 'none'],
+    \ 'aria-grabbed': ['true', 'false', 'undefined']
+\ }
+
+let relationship_attributes = {
+    \ 'aria-activedescendant': [],
+    \ 'aria-colcount': [],
+    \ 'aria-colindex': [],
+    \ 'aria-colspan': [],
+    \ 'aria-controls': [],
+    \ 'aria-describedby': [],
+    \ 'aria-details': [],
+    \ 'aria-errormessage': [],
+    \ 'aria-flowto': [],
+    \ 'aria-labelledby': [],
+    \ 'aria-owns': [],
+    \ 'aria-posinset': [],
+    \ 'aria-rowcount': [],
+    \ 'aria-rowindex': [],
+    \ 'aria-rowspan': [],
+    \ 'aria-setsize': []
+\ }
+
+let aria_attributes = global_states_and_properties
+let aria_attributes = extend(aria_attributes, widget_attributes)
 let aria_attributes = extend(aria_attributes, live_region_attributes)
 let aria_attributes = extend(aria_attributes, drag_and_drop_attributes)
 let aria_attributes = extend(aria_attributes, relationship_attributes)
@@ -82,6 +271,8 @@ let role_attributes['status'] = abstract_role['composite'] + role_attributes['re
 let role_attributes['tab'] = abstract_role['sectionhead'] + abstract_role['widget'] + ['aria-selected']
 let role_attributes['tabpanel'] = role_attributes['region']
 let role_attributes['textbox'] = abstract_role['input'] + ['aria-autocomplete', 'aria-multiline', 'aria-readonly', 'aria-required']
+let role_attributes['searchbox'] = role_attributes['textbox']
+let role_attributes['switch'] = role_attributes['checkbox']
 let role_attributes['timer'] = role_attributes['status'] 
 let role_attributes['tooltip'] = abstract_role['section'] 
 let role_attributes['treeitem'] = role_attributes['listitem'] + role_attributes['option']
@@ -99,16 +290,22 @@ let role_attributes['treegrid'] = role_attributes['grid'] + role_attributes['tre
 let role_attributes['document'] = abstract_role['structure'] + ['aria-expanded'] 
 
 let role_attributes['article'] = role_attributes['document'] + role_attributes['region'] 
+let role_attributes['cell'] = abstract_role['section'] + ['aria-colindex', 'aria-colspan', 'aria-rowindex', 'aria-rowspan']
 let role_attributes['columnheader'] = role_attributes['gridcell'] + abstract_role['sectionhead'] + ['aria-sort']
 let role_attributes['definition'] = abstract_role['section'] 
+let role_attributes['feed'] = role_attributes['list']
+let role_attributes['figure'] = abstract_role['section'] 
 let role_attributes['heading'] = abstract_role['sectionhead'] + ['aria-level'] 
 let role_attributes['img'] = abstract_role['section'] 
 let role_attributes['math'] = abstract_role['section'] 
 let role_attributes['note'] = abstract_role['section'] 
 let role_attributes['presentation'] = abstract_role['structure']
+let role_attributes['none'] = role_attributes['presentation']
 let role_attributes['row'] = role_attributes['group'] + ['aria-level', 'aria-selected']
 let role_attributes['rowheader'] = role_attributes['gridcell'] + abstract_role['sectionhead']
 let role_attributes['separator'] = abstract_role['structure'] + ['aria-expanded'] 
+let role_attributes['table'] = abstract_role['section'] + ['aria-colcount', 'aria-rowcount']
+let role_attributes['term'] = abstract_role['section']
 
 " Landmark Roles
 let role_attributes['application'] = abstract_role['landmark'] 
@@ -124,19 +321,30 @@ let role_attributes['search'] = abstract_role['landmark']
 let aria_attributes_value = {
     \ 'aria-autocomplete': ['ID', ''],
     \ 'aria-checked': ['Token', ''],
+    \ 'aria-colcount': ['Number', ''],
+    \ 'aria-colindex': ['Number', ''],
+    \ 'aria-colspan': ['Number', ''],
     \ 'aria-disabled': ['true/false', ''],
+    \ 'aria-errormessage': ['ID', ''],
     \ 'aria-expanded': ['Token', ''],
-    \ 'aria-haspopup': ['true/false', ''],
+    \ 'aria-haspopup': ['Token', ''],
     \ 'aria-hidden': ['true/false', ''],
     \ 'aria-invalid': ['Token', ''],
+    \ 'aria-keyshortcuts': ['String', ''],
     \ 'aria-label': ['String', ''],
     \ 'aria-level': ['Int', ''],
+    \ 'aria-modal': ['true/false', ''],
     \ 'aria-multiline': ['true/false', ''],
     \ 'aria-multiselectable': ['true/false', ''],
     \ 'aria-orientation': ['Token', ''],
+    \ 'aria-placeholder': ['String', ''],
     \ 'aria-pressed': ['Token', ''],
     \ 'aria-readonly': ['true/false', ''],
     \ 'aria-required': ['true/false', ''],
+    \ 'aria-roledescription': ['String', ''],
+    \ 'aria-rowcount': ['Number', ''],
+    \ 'aria-rowindex': ['Number', ''],
+    \ 'aria-rowspan': ['Number', ''],
     \ 'aria-selected': ['Token', ''],
     \ 'aria-sort': ['Token', ''],
     \ 'aria-valuemax': ['Number', ''],

autoload/xml/html5.vim

@@ -62,6 +62,8 @@ let charset = [
     \ 'windows-1256', 'windows-1257', 'windows-1258', 'TIS-620', ]
 " }}}
 
+let autofill_tokens = ['on', 'off', 'name', 'honorific-prefix', 'given-name', 'additional-name', 'family-name', 'honorific-suffix', 'nickname', 'username', 'new-password', 'current-password', 'organization-title', 'organization', 'street-address', 'address-line1', 'address-line2', 'address-line3', 'address-level4', 'address-level3', 'address-level2', 'address-level1', 'country', 'country-name', 'postal-code', 'cc-name', 'cc-given-name', 'cc-additional-name', 'cc-family-name', 'cc-number', 'cc-exp', 'cc-exp-month', 'cc-exp-year', 'cc-csc', 'cc-type', 'transaction-currency', 'transaction-amount', 'language', 'bday', 'bday-day', 'bday-month', 'bday-year', 'sex', 'url', 'photo']
+
 " Attributes_and_Settings: {{{
 let core_attributes = {'accesskey': [], 'class': [], 'contenteditable': ['true', 'false', ''], 'contextmenu': [], 'dir': ['ltr', 'rtl'], 'draggable': ['true', 'false'], 'hidden': ['hidden', ''], 'id': [], 'is': [], 'lang': lang_tag, 'spellcheck': ['true', 'false', ''], 'style': [], 'tabindex': [], 'title': []}
 let xml_attributes = {'xml:lang': lang_tag, 'xml:space': ['preserve'], 'xml:base': [], 'xmlns': ['http://www.w3.org/1999/xhtml', 'http://www.w3.org/1998/Math/MathML', 'http://www.w3.org/2000/svg', 'http://www.w3.org/1999/xlink']}
@@ -78,9 +80,12 @@ let attributes_value = {
     \ 'accept-charset': ['Charset', ''],
     \ 'accesskey': ['Character', ''],
     \ 'action': ['URL', ''],
+    \ 'allowfullscreen': ['Bool', ''],
+    \ 'allowpaymentrequest': ['Bool', ''],
+    \ 'allowusermedia': ['Bool', ''],
     \ 'alt': ['Text', ''],
     \ 'async': ['Bool', ''],
-    \ 'autocomplete': ['on/off', ''],
+    \ 'autocomplete': ['*Token', ''],
     \ 'autofocus': ['Bool', ''],
     \ 'autoplay': ['Bool', ''],
     \ 'border': ['1', ''],
@@ -140,6 +145,7 @@ let attributes_value = {
     \ 'optimum': ['Number', ''],
     \ 'pattern': ['Pattern', ''],
     \ 'placeholder': ['Text', ''],
+    \ 'playsinline': ['Bool', ''],
     \ 'poster': ['URL', ''],
     \ 'preload': ['Token', ''],
     \ 'pubdate': ['Bool', ''],
@@ -313,13 +319,15 @@ if !exists('g:html5_aria_attributes_complete')
     let g:html5_aria_attributes_complete = 1
 endif
 if g:html5_aria_attributes_complete == 1
-    " Ref: http://www.w3.org/TR/wai-aria/roles
-    " Version: Draft 15 December 2009
-    let widget_role = ['alert', 'alertdialog', 'button', 'checkbox', 'combobox', 'dialog', 'gridcell', 'link', 'log', 'marquee', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'progressbar', 'radio', 'radiogroup', 'scrollbar', 'slider', 'spinbutton', 'status', 'tab', 'tabpanel', 'textbox', 'timer', 'tooltip', 'treeitem', 'combobox', 'grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'tablist', 'tree', 'treegrid']
-    let document_structure = ['article', 'columnheader', 'definition', 'directory', 'document', 'group', 'heading', 'img', 'list', 'listitem', 'math', 'note', 'presentation', 'region', 'row', 'rowheader', 'separator']
+    " Ref: https://www.w3.org/TR/wai-aria-1.1/#role_definitions
+    " Version: W3C Candidate Recommendation 27 October 2016
+    let widget_role = ['alert', 'alertdialog', 'button', 'checkbox', 'combobox', 'dialog', 'gridcell', 'link', 'log', 'marquee', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'progressbar', 'radio', 'radiogroup', 'scrollbar', 'searchbox', 'slider', 'spinbutton', 'status', 'switch', 'tab', 'tabpanel', 'textbox', 'timer', 'tooltip', 'treeitem', 'combobox', 'grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'tablist', 'tree', 'treegrid']
+    let document_structure = ['article', 'cell', 'columnheader', 'definition', 'directory', 'document', 'feed', 'figure', 'group', 'heading', 'img', 'list', 'listitem', 'math', 'none', 'note', 'presentation', 'region', 'row', 'rowheader', 'separator', 'table', 'term']
     let landmark_role = ['application', 'banner', 'complementary', 'contentinfo', 'form', 'main', 'navigation', 'search']
+    let dpub_role = ['dpub-abstract', 'dpub-afterword', 'dpub-appendix', 'dpub-biblioentry', 'dpub-bibliography', 'dpub-biblioref', 'dpub-chapter', 'dpub-cover', 'dpub-epilogue', 'dpub-footnote', 'dpub-footnotes', 'dpub-foreword', 'dpub-glossary', 'dpub-glossdef', 'dpub-glossref', 'dpub-glossterm', 'dpub-index', 'dpub-locator', 'dpub-noteref', 'dpub-notice', 'dpub-pagebreak', 'dpub-pagelist', 'dpub-part', 'dpub-preface', 'dpub-prologue', 'dpub-pullquote', 'dpub-qna', 'dpub-subtitle', 'dpub-tip', 'dpub-title', 'dpub-toc']
     let role = extend(widget_role, document_structure)
     let role = extend(role, landmark_role)
+    let role = extend(role, dpub_role)
     let global_attributes = extend(global_attributes, {'role': role})
 endif
 " }}}
@@ -332,10 +340,33 @@ let metadata_elements = ['link', 'style', 'meta', 'script', 'noscript', 'command
 
 let flow_elements = phrasing_elements + ['p', 'hr', 'pre', 'ul', 'ol', 'dl', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hgroup', 'address', 'blockquote', 'ins', 'del', 'element', 'object', 'main', 'map', 'noscript', 'section', 'nav', 'article', 'aside', 'header', 'footer', 'video', 'audio', 'figure', 'table', 'template', 'form', 'fieldset', 'menu', 'canvas', 'details']
 
-" http://dev.w3.org/html5/spec/Overview.html#linkTypes
-let linktypes = ['alternate', 'author', 'bookmark', 'external', 'help', 'icon', 'license', 'next', 'nofollow', 'noreferrer', 'pingback', 'prefetch', 'prev', 'search', 'stylesheet', 'sidebar', 'tag']
+" https://html.spec.whatwg.org/#linkTypes
+let linktypes = ['alternate', 'author', 'bookmark', 'dns-prefetch', 'external', 'help', 'icon', 'license', 'next', 'nofollow', 'noreferrer', 'noopener', 'pingback', 'preconnect', 'prefetch', 'preload', 'prerender', 'prev', 'search', 'stylesheet', 'tag']
+" https://w3c.github.io/manifest/
+let linkreltypes = linktypes
+let linkreltypes = linkreltypes + ['manifest']
 " http://googlewebmastercentral.blogspot.com/2009/02/specify-your-canonical.html
-let linkreltypes = linktypes + ['canonical', 'import']
+" http://www.ysearchblog.com/2009/02/12/fighting-duplication-adding-more-arrows-to-your-quiver/
+" http://blogs.bing.com/webmaster/2009/02/12/partnering-to-help-solve-duplicate-content-issues
+let linkreltypes = linkreltypes + ['canonical']
+" http://w3c.github.io/webcomponents/spec/imports/
+let linkreltypes = linkreltypes + ['import']
+" https://www.w3.org/TR/webmention/#sender-discovers-receiver-webmention-endpoint
+let linkreltypes = linkreltypes + ['webmention']
+" http://www.opensearch.org/Specifications/OpenSearch/1.1#Autodiscovery_in_HTML.2FXHTML
+let linkreltypes = linkreltypes + ['search']
+" http://microformats.org/wiki/rel-sitemap
+let linkreltypes = linkreltypes + ['sitemap']
+" https://www.ampproject.org/docs/get_started/create/prepare_for_discovery
+let linkreltypes = linkreltypes + ['amphtml']
+" https://developer.apple.com/library/content/documentation/AppleApplications/Reference/SafariWebContent/ConfiguringWebApplications/ConfiguringWebApplications.html
+let linkreltypes = linkreltypes + ['apple-touch-icon', 'apple-touch-icon-precomposed', 'apple-touch-startup-image']
+" https://developer.chrome.com/webstore/inline_installation
+let linkreltypes = linkreltypes + ['chrome-webstore-item']
+" http://pubsubhubbub.github.io/PubSubHubbub/pubsubhubbub-core-0.4.html#rfc.section.4
+let linkreltypes = linkreltypes + ['hub']
+" https://golem.ph.utexas.edu/~distler/blog/archives/000320.html
+let linkreltypes = linkreltypes + ['pgpkey']
 
 " a and button are special elements for interactive, some element can't be its descendent
 let abutton_dec = 'details\\|embed\\|iframe\\|keygen\\|label\\|menu\\|select\\|textarea'
@@ -347,7 +378,7 @@ let g:xmldata_html5 = {
 \ 'vimxmlroot': ['html', 'head', 'body'] + flow_elements, 
 \ 'a': [
     \ filter(copy(flow_elements), "!(v:val =~ '". abutton_dec ."')"),
-    \ extend(copy(global_attributes), {'name': [], 'href': [], 'target': [], 'rel': linktypes, 'hreflang': lang_tag, 'media': [], 'type': []}) 
+    \ extend(copy(global_attributes), {'name': [], 'href': [], 'target': [], 'rel': linktypes, 'hreflang': lang_tag, 'media': [], 'type': [], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url']}) 
 \ ],
 \ 'abbr': [
     \ phrasing_elements,
@@ -359,7 +390,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'area': [
     \ [],
-    \ extend(copy(global_attributes), {'alt': [], 'href': [], 'target': [], 'rel': linktypes, 'media': [], 'hreflang': lang_tag, 'type': [], 'shape': ['rect', 'circle', 'poly', 'default'], 'coords': []})
+    \ extend(copy(global_attributes), {'alt': [], 'href': [], 'target': [], 'rel': linktypes, 'media': [], 'hreflang': lang_tag, 'type': [], 'shape': ['rect', 'circle', 'poly', 'default'], 'coords': [], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url']})
 \ ],
 \ 'article': [
     \ flow_elements + ['style'],
@@ -495,7 +526,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'form': [
     \ flow_elements,
-    \ extend(copy(global_attributes), {'name': [], 'action': [], 'enctype': ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'], 'method': ['get', 'post', 'put', 'delete'], 'target': [], 'novalidate': ['novalidate', ''], 'accept-charset': charset, 'autocomplete': ['on', 'off']})
+    \ extend(copy(global_attributes), {'name': [], 'action': [], 'enctype': ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'], 'method': ['get', 'post', 'put', 'delete'], 'target': [], 'novalidate': ['novalidate', ''], 'accept-charset': charset, 'autocomplete': autofill_tokens})
 \ ],
 \ 'h1': [
     \ phrasing_elements,
@@ -547,15 +578,15 @@ let g:xmldata_html5 = {
 \ ],
 \ 'iframe': [
     \ [],
-    \ extend(copy(global_attributes), {'src': [], 'srcdoc': [], 'name': [], 'width': [], 'height': [], 'sandbox': ['allow-same-origin', 'allow-forms', 'allow-scripts'], 'seamless': ['seamless', '']})
+    \ extend(copy(global_attributes), {'src': [], 'srcdoc': [], 'name': [], 'width': [], 'height': [], 'sandbox': ['allow-same-origin', 'allow-forms', 'allow-scripts'], 'seamless': ['seamless', ''], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url'], 'allowfullscreen': [], 'allowpaymentrequest': [], 'allowusermedia': []})
 \ ],
 \ 'img': [
     \ [],
-    \ extend(copy(global_attributes), {'src': [], 'alt': [], 'height': [], 'width': [], 'usemap': [], 'ismap': ['ismap', '']})
+    \ extend(copy(global_attributes), {'src': [], 'alt': [], 'height': [], 'width': [], 'usemap': [], 'ismap': ['ismap', ''], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url']})
 \ ],
 \ 'input': [
     \ [],
-    \ extend(copy(global_attributes), {'type': ['text', 'password', 'checkbox', 'radio', 'button', 'submit', 'reset', 'file', 'hidden', 'image', 'datetime', 'datetime-local', 'date', 'month', 'time', 'week', 'number', 'range', 'email', 'url', 'search', 'tel', 'color'], 'name': [], 'disabled': ['disabled', ''], 'form': [], 'maxlength': [], 'readonly': ['readonly', ''], 'size': [], 'value': [], 'autocomplete': ['on', 'off'], 'autofocus': ['autofocus', ''], 'list': [], 'pattern': [], 'required': ['required', ''], 'placeholder': [], 'checked': ['checked'], 'accept': [], 'multiple': ['multiple', ''], 'alt': [], 'src': [], 'height': [], 'width': [], 'min': [], 'max': [], 'step': [], 'formenctype': ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'], 'formmethod': ['get', 'post', 'put', 'delete'], 'formtarget': [], 'formnovalidate': ['formnovalidate', '']})
+    \ extend(copy(global_attributes), {'type': ['text', 'password', 'checkbox', 'radio', 'button', 'submit', 'reset', 'file', 'hidden', 'image', 'datetime', 'datetime-local', 'date', 'month', 'time', 'week', 'number', 'range', 'email', 'url', 'search', 'tel', 'color'], 'name': [], 'disabled': ['disabled', ''], 'form': [], 'maxlength': [], 'readonly': ['readonly', ''], 'size': [], 'value': [], 'autocomplete': autofill_tokens, 'autofocus': ['autofocus', ''], 'list': [], 'pattern': [], 'required': ['required', ''], 'placeholder': [], 'checked': ['checked'], 'accept': [], 'multiple': ['multiple', ''], 'alt': [], 'src': [], 'height': [], 'width': [], 'min': [], 'max': [], 'step': [], 'formenctype': ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'], 'formmethod': ['get', 'post', 'put', 'delete'], 'formtarget': [], 'formnovalidate': ['formnovalidate', '']})
 \ ],
 \ 'ins': [
     \ flow_elements,
@@ -583,7 +614,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'link': [
     \ [],
-    \ extend(copy(global_attributes), {'href': [], 'rel': linkreltypes, 'hreflang': lang_tag, 'media': [], 'type': [], 'sizes': ['any']})
+    \ extend(copy(global_attributes), {'href': [], 'rel': linkreltypes, 'hreflang': lang_tag, 'media': [], 'type': [], 'sizes': ['any'], 'referrerpolicy': ['no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-cross-origin', 'unsafe-url']})
 \ ],
 \ 'main': [
     \ flow_elements + ['style'],
@@ -691,7 +722,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'script': [
     \ [],
-    \ extend(copy(global_attributes), {'src': [], 'defer': ['defer', ''], 'async': ['async', ''], 'type': [], 'charset': charset})
+    \ extend(copy(global_attributes), {'src': [], 'defer': ['defer', ''], 'async': ['async', ''], 'type': [], 'charset': charset, 'nonce': []})
 \ ],
 \ 'section': [
     \ flow_elements + ['style'],
@@ -723,7 +754,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'style': [
     \ [],
-    \ extend(copy(global_attributes), {'type': [], 'media': [], 'scoped': ['scoped', '']})
+    \ extend(copy(global_attributes), {'type': [], 'media': [], 'scoped': ['scoped', ''], 'nonce': []})
 \ ],
 \ 'sub': [
     \ phrasing_elements,
@@ -803,7 +834,7 @@ let g:xmldata_html5 = {
 \ ],
 \ 'video': [
     \ flow_elements + ['source', 'track'],
-    \ extend(copy(global_attributes), {'autoplay': ['autoplay', ''], 'preload': ['none', 'metadata', 'auto', ''], 'controls': ['controls', ''], 'loop': ['loop', ''], 'poster': [], 'height': [], 'width': [], 'src': []})
+    \ extend(copy(global_attributes), {'autoplay': ['autoplay', ''], 'preload': ['none', 'metadata', 'auto', ''], 'controls': ['controls', ''], 'loop': ['loop', ''], 'playsinline': ['playsinline', ''], 'poster': [], 'height': [], 'width': [], 'src': []})
 \ ],
 \ 'wbr': [
     \ [],

build

@@ -2,9 +2,12 @@
 
 set -E
 
-DIRS="syntax indent compiler autoload ftplugin ftdetect after/syntax after/indent after/ftplugin after/ftdetect"
-DIRS_BASIC="syntax compiler indent ftdetect after/syntax after/indent after/ftdetect"
-DIRS_ALL="syntax indent compiler autoload ftplugin ftdetect after"
+DIRS="syntax indent compiler autoload ftplugin after/syntax after/indent after/ftplugin"
+DIRS_BASIC="syntax compiler indent after/syntax after/indent"
+DIRS_ALL="syntax indent compiler autoload ftplugin after"
+DIRS_SYNTAX="syntax after/syntax"
+DIRS_JAVASCRIPT="${DIRS} extras"
+DIRS_RM="$DIRS_JAVASCRIPT"
 
 OUTPUT=""
 
@@ -46,10 +49,21 @@ extract() {
       fi
     done
 
+    for f in ${dir}/ftdetect/*; do
+      (
+        echo "augroup filetypedetect";
+        echo '" '"$pack";
+        cat "${f}";
+        echo "augroup END";
+        echo
+      ) >> tmp/polyglot.vim;
+    done
 
     output "${subdirs##, })\n"
   done
 
+  mv tmp/polyglot.vim ftdetect/
+
   for pack in $1; do
     name="$(printf "$pack" | cut -d ':' -f 1)"
     path="$(printf "$pack" | cut -d ':' -f 2)"
@@ -73,12 +87,6 @@ copy_dir() {
   done
 }
 
-concat_ftdetect() {
-  cat ftdetect/* | grep -E '^[^"]' > tmp/polyglot.vim
-  rm -f ftdetect/*
-  mv tmp/polyglot.vim ftdetect/
-}
-
 update_readme() {
   OLD_README="$(cat README.md)"
 
@@ -87,7 +95,7 @@ update_readme() {
 +2kb
 /##
 'b,-2c
-$(printf -- "$OUTPUT")
+$(printf -- "$OUTPUT" | sort)
 .
 w
 q
@@ -96,11 +104,15 @@ EOF
 }
 
 PACKS="
+  apiblueprint:sheerun/apiblueprint.vim
+  applescript:vim-scripts/applescript.vim
+  yaml:stephpy/vim-yaml
   ansible:pearofducks/ansible-vim
   arduino:sudar/vim-arduino-syntax
   blade:jwalton512/vim-blade
   c++11:octol/vim-cpp-enhanced-highlight
   c/c++:vim-jp/vim-cpp
+  caddyfile:joshglendenning/vim-caddyfile
   cjsx:mtscout6/vim-cjsx
   clojure:guns/vim-clojure-static
   coffee-script:kchmck/vim-coffee-script
@@ -110,25 +122,27 @@ PACKS="
   css:JulesWang/css.vim
   cucumber:tpope/vim-cucumber
   dart:dart-lang/dart-vim-plugin
-  dockerfile:honza/dockerfile.vim
+  dockerfile:docker/docker::/contrib/syntax/vim/
   elixir:elixir-lang/vim-elixir
   elm:lambdatoast/elm.vim
-  emberscript:heartsentwined/vim-ember-script
-  emblem:heartsentwined/vim-emblem
+  emberscript:yalesov/vim-ember-script
+  emblem:yalesov/vim-emblem
   erlang:vim-erlang/vim-erlang-runtime
   fish:dag/vim-fish
   git:tpope/vim-git
   glsl:tikhomirov/vim-glsl
+  gnuplot:vim-scripts/gnuplot-syntax-highlighting
   go:fatih/vim-go:_BASIC
   groovy:vim-scripts/groovy.vim
-  haml:tpope/vim-haml
+  haml:sheerun/vim-haml
   handlebars:mustache/vim-mustache-handlebars
   haskell:neovimhaskell/haskell-vim
   haxe:yaymukund/vim-haxe
   html5:othree/html5.vim
+  i3:PotatoesMaster/i3-vim-syntax
   jasmine:glanotte/vim-jasmine
-  javascript:pangloss/vim-javascript
-  json:sheerun/vim-json
+  javascript:pangloss/vim-javascript:_JAVASCRIPT
+  json:elzr/vim-json
   jst:briancollins/vim-jst
   jsx:mxw/vim-jsx:_ALL
   julia:dcjones/julia-minimalist-vim
@@ -136,8 +150,11 @@ PACKS="
   latex:LaTeX-Box-Team/LaTeX-Box
   less:groenewege/vim-less
   liquid:tpope/vim-liquid
+  livescript:gkz/vim-ls
+  lua:tbastos/vim-lua
   mako:sophacles/vim-bundle-mako
-  markdown:tpope/vim-markdown
+  markdown:plasticboy/vim-markdown:_SYNTAX
+  mathematica:rsmenon/vim-mathematica
   nginx:othree/nginx-contrib-vim
   nim:zah/nim.vim:_BASIC
   nix:spwhitt/vim-nix
@@ -149,49 +166,53 @@ PACKS="
   pgsql:exu/pgsql.vim
   php:StanAngeloff/php.vim
   plantuml:aklt/plantuml-syntax
-  powershell:Persistent13/vim-ps1
+  powershell:PProvost/vim-ps1
   protobuf:uarun/vim-protobuf
   pug:digitaltoad/vim-pug
   puppet:voxpupuli/vim-puppet
   purescript:raichoo/purescript-vim
   python:mitsuhiko/vim-python-combined
+  python-compiler:aliev/vim-compiler-python
   qml:peterhoeg/vim-qml
   r-lang:vim-scripts/R.vim
+  raml:IN3D/vim-raml
   ragel:jneen/ragel.vim
   rspec:sheerun/rspec.vim
   ruby:vim-ruby/vim-ruby
   rust:rust-lang/rust.vim
   sbt:derekwyatt/vim-sbt
   scala:derekwyatt/vim-scala
+  scss:cakebaker/scss-syntax.vim
   slim:slim-template/vim-slim
   solidity:ethereum/vim-solidity
   stylus:wavded/vim-stylus
   swift:keith/swift.vim
+  sxhkd:baskerville/vim-sxhkdrc
   systemd:kurayama/systemd-vim-syntax
+  terraform:hashivim/vim-terraform
   textile:timcharper/textile.vim
   thrift:solarnz/thrift.vim
   tmux:keith/tmux.vim
   tomdoc:wellbredgrapefruit/tomdoc.vim
   toml:cespare/vim-toml
-  twig:evidens/vim-twig
+  twig:lumiliet/vim-twig
   typescript:leafgarland/typescript-vim
-  vala:tkztmk/vim-vala
+  vala:arrufat/vala.vim
   vbnet:vim-scripts/vbnet.vim
   vcl:smerrill/vcl-vim-plugin
+  vue:posva/vim-vue
   vm:lepture/vim-velocity
   xls:vim-scripts/XSLT-syntax
-  yaml:stephpy/vim-yaml
   yard:sheerun/vim-yardoc
 "
 
 rm -rf tmp
-rm -rf $DIRS_ALL
+rm -rf $DIRS_RM
 mkdir tmp
 
 printf "Downloading packs..."
 download "$PACKS"
 extract "$PACKS"
-concat_ftdetect
 update_readme
 
 rm -rf tmp

compiler/cargo.vim

@@ -21,49 +21,12 @@ else
     CompilerSet makeprg=cargo\ $*
 endif
 
-" Allow a configurable global Cargo.toml name. This makes it easy to
-" support variations like 'cargo.toml'.
-let s:cargo_manifest_name = get(g:, 'cargo_manifest_name', 'Cargo.toml')
-
-function! s:is_absolute(path)
-    return a:path[0] == '/' || a:path =~ '[A-Z]\+:'
-endfunction
-
-let s:local_manifest = findfile(s:cargo_manifest_name, '.;')
-if s:local_manifest != ''
-    let s:local_manifest = fnamemodify(s:local_manifest, ':p:h').'/'
-    augroup cargo
-        au!
-        au QuickfixCmdPost make call s:FixPaths()
-    augroup END
-
-    " FixPaths() is run after Cargo, and is used to change the file paths
-    " to be relative to the current directory instead of Cargo.toml.
-    function! s:FixPaths()
-        let qflist = getqflist()
-        let manifest = s:local_manifest
-        for qf in qflist
-            if !qf.valid
-                let m = matchlist(qf.text, '(file://\(.*\))$')
-                if !empty(m)
-                    let manifest = m[1].'/'
-                    " Manually strip another slash if needed; usually just an
-                    " issue on Windows.
-                    if manifest =~ '^/[A-Z]\+:/'
-                        let manifest = manifest[1:]
-                    endif
-                endif
-                continue
-            endif
-            let filename = bufname(qf.bufnr)
-            if s:is_absolute(filename)
-                continue
-            endif
-            let qf.filename = simplify(manifest.filename)
-            call remove(qf, 'bufnr')
-        endfor
-        call setqflist(qflist, 'r')
-    endfunction
-endif
+" Ignore general cargo progress messages
+CompilerSet errorformat+=
+			\%-G%\\s%#Downloading%.%#,
+			\%-G%\\s%#Compiling%.%#,
+			\%-G%\\s%#Finished%.%#,
+			\%-G%\\s%#error:\ Could\ not\ compile\ %.%#,
+			\%-G%\\s%#To\ learn\ more\\,%.%#
 
 endif

compiler/eslint.vim

@@ -0,0 +1,15 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') == -1
+  
+if exists("current_compiler")
+  finish
+endif
+let current_compiler = "eslint"
+
+if exists(":CompilerSet") != 2
+  command! -nargs=* CompilerSet setlocal <args>
+endif
+
+CompilerSet makeprg=eslint\ -f\ compact\ %
+CompilerSet errorformat=%f:\ line\ %l\\,\ col\ %c\\,\ %m
+
+endif

compiler/ls.vim

@@ -0,0 +1,78 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'livescript') == -1
+  
+" Language:    LiveScript
+" Maintainer:  George Zahariev
+" URL:         http://github.com/gkz/vim-ls
+" License:     WTFPL
+
+if exists('current_compiler')
+  finish
+endif
+
+let current_compiler = 'ls'
+" Pattern to check if livescript is the compiler
+let s:pat = '^' . current_compiler
+
+" Path to LiveScript compiler
+if !exists('livescript_compiler')
+  let livescript_compiler = 'lsc'
+endif
+
+if !exists('livescript_make_options')
+  let livescript_make_options = ''
+endif
+
+" Get a `makeprg` for the current filename. This is needed to support filenames
+" with spaces and quotes, but also not break generic `make`.
+function! s:GetMakePrg()
+  return g:livescript_compiler . ' -c ' . g:livescript_make_options . ' $* '
+  \                      . fnameescape(expand('%'))
+endfunction
+
+" Set `makeprg` and return 1 if coffee is still the compiler, else return 0.
+function! s:SetMakePrg()
+  if &l:makeprg =~ s:pat
+    let &l:makeprg = s:GetMakePrg()
+  elseif &g:makeprg =~ s:pat
+    let &g:makeprg = s:GetMakePrg()
+  else
+    return 0
+  endif
+
+  return 1
+endfunction
+
+" Set a dummy compiler so we can check whether to set locally or globally.
+CompilerSet makeprg=ls
+call s:SetMakePrg()
+
+CompilerSet errorformat=%EFailed\ at:\ %f,
+                       \%ECan't\ find:\ %f,
+                       \%CSyntaxError:\ %m\ on\ line\ %l,
+                       \%CError:\ Parse\ error\ on\ line\ %l:\ %m,
+                       \%C,%C\ %.%#
+
+" Compile the current file.
+command! -bang -bar -nargs=* LiveScriptMake make<bang> <args>
+
+" Set `makeprg` on rename since we embed the filename in the setting.
+augroup LiveScriptUpdateMakePrg
+  autocmd!
+
+  " Update `makeprg` if livescript is still the compiler, else stop running this
+  " function.
+  function! s:UpdateMakePrg()
+    if !s:SetMakePrg()
+      autocmd! LiveScriptUpdateMakePrg
+    endif
+  endfunction
+
+  " Set autocmd locally if compiler was set locally.
+  if &l:makeprg =~ s:pat
+    autocmd BufFilePost,BufWritePost <buffer> call s:UpdateMakePrg()
+  else
+    autocmd BufFilePost,BufWritePost          call s:UpdateMakePrg()
+  endif
+augroup END
+
+endif

compiler/python.vim

@@ -0,0 +1,71 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'python-compiler') == -1
+  
+" Vim compiler file
+" Compiler:	Unit testing tool for Python
+" Maintainer:	Ali Aliev <ali@aliev.me>
+" Last Change: 2015 Nov 2
+
+if exists("current_compiler")
+  finish
+endif
+
+let current_compiler = "python"
+
+if exists(":CompilerSet") != 2		" older Vim always used :setlocal
+  command -nargs=* CompilerSet setlocal <args>
+endif
+
+" Disable Python warnings
+if !exists('$PYTHONWARNINGS')
+  let $PYTHONWARNINGS="ignore"
+endif
+
+" For Flake8 first
+CompilerSet efm  =%E%f:%l:\ could\ not\ compile,
+CompilerSet efm +=%-Z%p^,
+CompilerSet efm +=%A%f:%l:%c:\ %t%n\ %m,
+CompilerSet efm +=%A%f:%l:\ %t%n\ %m,
+
+" Python errors are multi-lined. They often start with 'Traceback', so
+" we want to capture that (with +G) and show it in the quickfix window
+" because it explains the order of error messages.
+
+CompilerSet efm +=%+GTraceback%.%#,
+
+" The error message itself starts with a line with 'File' in it. There
+" are a couple of variations, and we need to process a line beginning
+" with whitespace followed by File, the filename in "", a line number,
+" and optional further text. %E here indicates the start of a multi-line
+" error message. The %\C at the end means that a case-sensitive search is
+" required.
+CompilerSet efm +=%E\ \ File\ \"%f\"\\,\ line\ %l\\,%m%\\C,
+CompilerSet efm +=%E\ \ File\ \"%f\"\\,\ line\ %l%\\C,
+
+" The possible continutation lines are idenitifed to Vim by %C. We deal
+" with these in order of most to least specific to ensure a proper
+" match. A pointer (^) identifies the column in which the error occurs
+" (but will not be entirely accurate due to indention of Python code).
+CompilerSet efm +=%C%p^,
+
+" Any text, indented by more than two spaces contain useful information.
+" We want this to appear in the quickfix window, hence %+.
+CompilerSet efm +=%+C\ \ \ \ %.%#,
+CompilerSet efm +=%+C\ \ %.%#,
+
+" The last line (%Z) does not begin with any whitespace. We use a zero
+" width lookahead (\&) to check this. The line contains the error
+" message itself (%m)
+CompilerSet efm +=%Z%\\S%\\&%m,
+
+" We can ignore any other lines (%-G)
+CompilerSet efm +=%-G%.%#
+
+if filereadable("Makefile")
+  CompilerSet makeprg=make
+else
+  CompilerSet makeprg=python
+endif
+
+" vim:foldmethod=marker:foldlevel=0
+
+endif

compiler/rustc.vim

@@ -23,6 +23,7 @@ else
 	CompilerSet makeprg=rustc\ \%
 endif
 
+" Old errorformat (before nightly 2016/08/10)
 CompilerSet errorformat=
 			\%f:%l:%c:\ %t%*[^:]:\ %m,
 			\%f:%l:%c:\ %*\\d:%*\\d\ %t%*[^:]:\ %m,
@@ -31,6 +32,17 @@ CompilerSet errorformat=
 			\%-G%*[\ ]^%*[~],
 			\%-G%*[\ ]...
 
+" New errorformat (after nightly 2016/08/10)
+CompilerSet errorformat+=
+			\%-G,
+			\%-Gerror:\ aborting\ %.%#,
+			\%-Gerror:\ Could\ not\ compile\ %.%#,
+			\%Eerror:\ %m,
+			\%Eerror[E%n]:\ %m,
+			\%Wwarning:\ %m,
+			\%Inote:\ %m,
+			\%C\ %#-->\ %f:%l:%c
+
 let &cpo = s:cpo_save
 unlet s:cpo_save
 

compiler/sass.vim

@@ -1,34 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haml') == -1
-  
-" Vim compiler file
-" Compiler:	Sass
-" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2013 May 30
-
-if exists("current_compiler")
-  finish
-endif
-let current_compiler = "sass"
-
-if exists(":CompilerSet") != 2		" older Vim always used :setlocal
-  command -nargs=* CompilerSet setlocal <args>
-endif
-
-let s:cpo_save = &cpo
-set cpo-=C
-
-CompilerSet makeprg=sass
-
-CompilerSet errorformat=
-      \%f:%l:%m\ (Sass::Syntax%trror),
-      \%ESyntax\ %trror:%m,
-      \%C%\\s%\\+on\ line\ %l\ of\ %f,
-      \%Z%.%#,
-      \%-G%.%#
-
-let &cpo = s:cpo_save
-unlet s:cpo_save
-
-" vim:set sw=2 sts=2:
-
-endif

compiler/typescript.vim

@@ -13,6 +13,10 @@ if !exists("g:typescript_compiler_options")
   let g:typescript_compiler_options = ""
 endif
 
+if exists(":CompilerSet") != 2
+  command! -nargs=* CompilerSet setlocal <args>
+endif
+
 let &l:makeprg = g:typescript_compiler_binary . ' ' . g:typescript_compiler_options . ' $*  %'
 
 CompilerSet errorformat=%+A\ %#%f\ %#(%l\\\,%c):\ %m,%C%m

config.vim

@@ -0,0 +1,11 @@
+" Enable jsx syntax by default
+if !exists('g:jsx_ext_required')
+  let g:jsx_ext_required = 0
+endif
+
+" Disable json concealing by default
+if !exists('g:vim_json_syntax_conceal')
+  let g:vim_json_syntax_conceal = 0
+endif
+
+let g:filetype_euphoria = 'elixir'

extras/flow.vim

@@ -0,0 +1,96 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') == -1
+  
+syntax region  jsFlowDefinition     contained                        start=/:/    end=/\%(\s*[,=;)\n]\)\@=/ contains=@jsFlowCluster containedin=jsParen
+syntax region  jsFlowArgumentDef    contained                        start=/:/    end=/\%(\s*[,)]\|=>\@!\)\@=/ contains=@jsFlowCluster
+syntax region  jsFlowArray          contained matchgroup=jsFlowNoise start=/\[/   end=/\]/        contains=@jsFlowCluster
+syntax region  jsFlowObject         contained matchgroup=jsFlowNoise start=/{/    end=/}/         contains=@jsFlowCluster
+syntax region  jsFlowParens         contained matchgroup=jsFlowNoise start=/(/  end=/)/ contains=@jsFlowCluster
+syntax match   jsFlowNoise          contained /[:;,<>]/
+syntax keyword jsFlowType           contained boolean number string null void any mixed JSON array Function object array bool class
+syntax keyword jsFlowTypeof         contained typeof skipempty skipempty nextgroup=jsFlowTypeCustom,jsFlowType
+syntax match   jsFlowTypeCustom     contained /[0-9a-zA-Z_.]*/ skipwhite skipempty nextgroup=jsFlowGroup
+syntax region  jsFlowGroup          contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster
+syntax region  jsFlowArrowArguments contained matchgroup=jsFlowNoise start=/(/  end=/)\%(\s*=>\)\@=/ oneline skipwhite skipempty nextgroup=jsFlowArrow contains=@jsFlowCluster
+syntax match   jsFlowArrow          contained /=>/ skipwhite skipempty nextgroup=jsFlowType,jsFlowTypeCustom,jsFlowParens
+syntax match   jsFlowMaybe          contained /?/ skipwhite skipempty nextgroup=jsFlowType,jsFlowTypeCustom,jsFlowParens,jsFlowArrowArguments,jsFlowObject,jsFlowReturnObject
+syntax match   jsFlowObjectKey      contained /[0-9a-zA-Z_$?]*\(\s*:\)\@=/ contains=jsFunctionKey,jsFlowMaybe skipwhite skipempty nextgroup=jsObjectValue containedin=jsObject
+syntax match   jsFlowOrOperator     contained /|/ skipwhite skipempty nextgroup=@jsFlowCluster
+syntax keyword jsFlowImportType     contained type skipwhite skipempty nextgroup=jsModuleAsterisk,jsModuleKeyword,jsModuleGroup
+syntax match   jsFlowWildcard       contained /*/
+
+syntax match   jsFlowReturn         contained /:\s*/ contains=jsFlowNoise skipwhite skipempty nextgroup=@jsFlowReturnCluster
+syntax region  jsFlowReturnObject   contained matchgroup=jsFlowNoise start=/{/    end=/}/  contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncBlock,jsFlowReturnOrOp
+syntax region  jsFlowReturnArray    contained matchgroup=jsFlowNoise start=/\[/   end=/\]/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncBlock,jsFlowReturnOrOp
+syntax region  jsFlowReturnParens   contained matchgroup=jsFlowNoise start=/(/    end=/)/  contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncBlock,jsFlowReturnOrOp
+syntax match   jsFlowReturnKeyword  contained /\k\+/ contains=jsFlowType,jsFlowTypeCustom skipwhite skipempty nextgroup=jsFlowReturnGroup,jsFuncBlock,jsFlowReturnOrOp
+syntax match   jsFlowReturnMaybe    contained /?/ skipwhite skipempty nextgroup=jsFlowReturnKeyword
+syntax region  jsFlowReturnGroup    contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncBlock,jsFlowReturnOrOp
+syntax match   jsFlowReturnOrOp     contained /\s*|\s*/ skipwhite skipempty nextgroup=@jsFlowReturnCluster
+syntax match   jsFlowWildcardReturn contained /*/ skipwhite skipempty nextgroup=jsFuncBlock
+
+syntax region  jsFlowFunctionGroup  contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsFuncArgs
+syntax region  jsFlowClassGroup     contained matchgroup=jsFlowNoise start=/</ end=/>/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsClassBlock
+
+syntax region  jsFlowTypeStatement                                   start=/type\%(\s\+\k\)\@=/    end=/=\@=/ contains=jsFlowTypeOperator oneline skipwhite skipempty nextgroup=jsFlowTypeValue keepend
+syntax region  jsFlowTypeValue      contained                        start=/=/       end=/[;\n]/ contains=@jsExpression,jsFlowGroup,jsFlowMaybe
+syntax match   jsFlowTypeOperator   contained /=/
+syntax keyword jsFlowTypeKeyword    contained type
+
+syntax keyword jsFlowDeclare                  declare skipwhite skipempty nextgroup=jsFlowTypeStatement,jsClassDefinition,jsStorageClass,jsFlowModule,jsFlowInterface
+syntax match   jsFlowClassProperty  contained /\<[0-9a-zA-Z_$]*\>:\@=/ skipwhite skipempty nextgroup=jsFlowClassDef containedin=jsClassBlock
+syntax region  jsFlowClassDef       contained start=/:/    end=/\%(\s*[,=;)\n]\)\@=/ contains=@jsFlowCluster skipwhite skipempty nextgroup=jsClassValue
+
+syntax region  jsFlowModule         contained start=/module/ end=/{\@=/ skipempty skipempty nextgroup=jsFlowDeclareBlock contains=jsString
+syntax region  jsFlowInterface      contained start=/interface/ end=/{\@=/ skipempty skipempty nextgroup=jsFlowInterfaceBlock contains=@jsFlowCluster
+syntax region  jsFlowDeclareBlock   contained matchgroup=jsFlowNoise start=/{/ end=/}/ contains=jsFlowDeclare,jsFlowNoise
+
+syntax region jsFlowInterfaceBlock  contained matchgroup=jsFlowNoise start=/{/ end=/}/ contains=jsObjectKey,jsObjectKeyString,jsObjectKeyComputed,jsObjectSeparator,jsObjectFuncName,jsObjectMethodType,jsGenerator,jsComment,jsObjectStringKey,jsSpreadExpression,jsFlowNoise keepend
+
+syntax cluster jsFlowReturnCluster            contains=jsFlowNoise,jsFlowReturnObject,jsFlowReturnArray,jsFlowReturnKeyword,jsFlowReturnGroup,jsFlowReturnMaybe,jsFlowReturnOrOp,jsFlowWildcardReturn
+syntax cluster jsFlowCluster                  contains=jsFlowArray,jsFlowObject,jsFlowNoise,jsFlowTypeof,jsFlowType,jsFlowGroup,jsFlowArrowArguments,jsFlowMaybe,jsFlowParens,jsFlowOrOperator,jsFlowWildcard
+
+if version >= 508 || !exists("did_javascript_syn_inits")
+  if version < 508
+    let did_javascript_syn_inits = 1
+    command -nargs=+ HiLink hi link <args>
+  else
+    command -nargs=+ HiLink hi def link <args>
+  endif
+  HiLink jsFlowDefinition         PreProc
+  HiLink jsFlowClassDef           jsFlowDefinition
+  HiLink jsFlowArgumentDef        jsFlowDefinition
+  HiLink jsFlowType               Type
+  HiLink jsFlowTypeCustom         PreProc
+  HiLink jsFlowTypeof             PreProc
+  HiLink jsFlowArray              PreProc
+  HiLink jsFlowObject             PreProc
+  HiLink jsFlowParens             PreProc
+  HiLink jsFlowGroup              PreProc
+  HiLink jsFlowReturn             PreProc
+  HiLink jsFlowReturnObject       jsFlowReturn
+  HiLink jsFlowReturnArray        jsFlowArray
+  HiLink jsFlowReturnParens       jsFlowParens
+  HiLink jsFlowReturnGroup        jsFlowGroup
+  HiLink jsFlowFunctionGroup      PreProc
+  HiLink jsFlowClassGroup         PreProc
+  HiLink jsFlowArrowArguments     PreProc
+  HiLink jsFlowArrow              PreProc
+  HiLink jsFlowTypeStatement      PreProc
+  HiLink jsFlowTypeKeyword        PreProc
+  HiLink jsFlowTypeOperator       PreProc
+  HiLink jsFlowMaybe              PreProc
+  HiLink jsFlowReturnMaybe        PreProc
+  HiLink jsFlowClassProperty      jsClassProperty
+  HiLink jsFlowDeclare            PreProc
+  HiLink jsFlowModule             PreProc
+  HiLink jsFlowInterface          PreProc
+  HiLink jsFlowNoise              Noise
+  HiLink jsFlowObjectKey          jsObjectKey
+  HiLink jsFlowOrOperator         PreProc
+  HiLink jsFlowReturnOrOp         jsFlowOrOperator
+  HiLink jsFlowWildcard           PreProc
+  HiLink jsFlowWildcardReturn     PreProc
+  delcommand HiLink
+endif
+
+endif

extras/jsdoc.vim

@@ -0,0 +1,43 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') == -1
+  
+"" syntax coloring for javadoc comments (HTML)
+syntax region jsComment    matchgroup=jsComment start="/\*\s*"  end="\*/" contains=jsDocTags,jsCommentTodo,jsCvsTag,@jsHtml,@Spell fold
+
+" tags containing a param
+syntax match  jsDocTags         contained "@\(alias\|api\|augments\|borrows\|class\|constructs\|default\|defaultvalue\|emits\|exception\|exports\|extends\|fires\|kind\|link\|listens\|member\|member[oO]f\|mixes\|module\|name\|namespace\|requires\|template\|throws\|var\|variation\|version\)\>" skipwhite nextgroup=jsDocParam
+" tags containing type and param
+syntax match  jsDocTags         contained "@\(arg\|argument\|cfg\|param\|property\|prop\|typedef\)\>" skipwhite nextgroup=jsDocType
+" tags containing type but no param
+syntax match  jsDocTags         contained "@\(callback\|define\|enum\|external\|implements\|this\|type\|return\|returns\)\>" skipwhite nextgroup=jsDocTypeNoParam
+" tags containing references
+syntax match  jsDocTags         contained "@\(lends\|see\|tutorial\)\>" skipwhite nextgroup=jsDocSeeTag
+" other tags (no extra syntax)
+syntax match  jsDocTags         contained "@\(abstract\|access\|accessor\|author\|classdesc\|constant\|const\|constructor\|copyright\|deprecated\|desc\|description\|dict\|event\|example\|file\|file[oO]verview\|final\|function\|global\|ignore\|inheritDoc\|inner\|instance\|interface\|license\|localdoc\|method\|mixin\|nosideeffects\|override\|overview\|preserve\|private\|protected\|public\|readonly\|since\|static\|struct\|todo\|summary\|undocumented\|virtual\)\>"
+
+syntax region jsDocType         contained matchgroup=jsDocTypeBrackets start="{" end="}" contains=jsDocTypeRecord oneline skipwhite nextgroup=jsDocParam
+syntax match  jsDocType         contained "\%(#\|\"\|\w\|\.\|:\|\/\)\+" skipwhite nextgroup=jsDocParam
+syntax region jsDocTypeRecord   contained start=/{/ end=/}/ contains=jsDocTypeRecord extend
+syntax region jsDocTypeRecord   contained start=/\[/ end=/\]/ contains=jsDocTypeRecord extend
+syntax region jsDocTypeNoParam  contained start="{" end="}" oneline
+syntax match  jsDocTypeNoParam  contained "\%(#\|\"\|\w\|\.\|:\|\/\)\+"
+syntax match  jsDocParam        contained "\%(#\|\$\|-\|'\|\"\|{.\{-}}\|\w\|\.\|:\|\/\|\[.\{-}]\|=\)\+"
+syntax region jsDocSeeTag       contained matchgroup=jsDocSeeTag start="{" end="}" contains=jsDocTags
+
+if version >= 508 || !exists("did_javascript_syn_inits")
+  if version < 508
+    let did_javascript_syn_inits = 1
+    command -nargs=+ HiLink hi link <args>
+  else
+    command -nargs=+ HiLink hi def link <args>
+  endif
+  HiLink jsDocTags              Special
+  HiLink jsDocSeeTag            Function
+  HiLink jsDocType              Type
+  HiLink jsDocTypeBrackets      jsDocType
+  HiLink jsDocTypeRecord        jsDocType
+  HiLink jsDocTypeNoParam       Type
+  HiLink jsDocParam             Label
+  delcommand HiLink
+endif
+
+endif

extras/ngdoc.vim

@@ -0,0 +1,7 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') == -1
+  
+syntax match  jsDocTags         contained /@\(link\|method[oO]f\|ngdoc\|ng[iI]nject\|restrict\)/ nextgroup=jsDocParam skipwhite
+syntax match  jsDocType         contained "\%(#\|\$\|\w\|\"\|-\|\.\|:\|\/\)\+" nextgroup=jsDocParam skipwhite
+syntax match  jsDocParam        contained "\%(#\|\$\|\w\|\"\|-\|\.\|:\|{\|}\|\/\|\[\|]\|=\)\+"
+
+endif

ftplugin/ansible.vim

@@ -4,5 +4,6 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'ansible') == -1
 if exists('+regexpengine') && ('&regexpengine' == 0)
   setlocal regexpengine=1
 endif
+set path+=./../templates,./../files
 
 endif

ftplugin/blade.vim

@@ -11,6 +11,27 @@ endif
 runtime! ftplugin/html.vim
 let b:did_ftplugin = 1
 
-setlocal iskeyword+=@-@
+setlocal suffixesadd=.blade.php,.php
+setlocal includeexpr=substitute(v:fname,'\\.','/','g')
+setlocal path+=resources/views;
+setlocal include=\\w\\@<!@\\%(include\\\|extends\\)
+setlocal define=\\w\\@<!@\\%(yield\\\|stack\\)
+
+setlocal commentstring={{--%s--}}
+setlocal comments+=s:{{--,m:\ \ \ \ ,e:--}}
+
+if exists('loaded_matchit') && exists('b:match_words')
+    " Append to html matchit words
+    let b:match_words .= ',' .
+                \ '@\%(section\s*([^\,]*)\|if\|unless\|foreach\|forelse\|for\|while\|push\|can\|cannot\|hasSection\|' .
+                \     'php\s*(\@!\|verbatim\|component\|slot\|prepend\)' .
+                \ ':' .
+                \ '@\%(else\|elseif\|empty\|break\|continue\|elsecan\|elsecannot\)\>' .
+                \ ':' .
+                \ '@\%(end\w\+\|stop\|show\|append\|overwrite\)' .
+                \ ',{:},\[:\],(:)'
+    let b:match_skip = 'synIDattr(synID(line("."), col("."), 0), "name") !=# "bladeKeyword"'
+    let b:match_ignorecase = 0
+endif
 
 endif

ftplugin/caddyfile.vim

@@ -0,0 +1,28 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'caddyfile') == -1
+  
+" Language:	    Caddyfile
+" Author:	    Josh Glendenning <josh@isobit.io>
+
+if exists('b:did_ftplugin')
+	finish
+endif
+let b:did_ftplugin = 1
+
+setlocal commentstring=#\ %s
+
+" Add NERDCommenter delimiters
+let s:delimiters = {'left': '#'}
+if exists('g:NERDDelimiterMap')
+	if !has_key(g:NERDDelimiterMap, 'caddyfile')
+		let g:NERDDelimiterMap.caddyfile = s:delimiters
+	endif
+elseif exists('g:NERDCustomDelimiters')
+	if !has_key(g:NERDCustomDelimiters, 'caddyfile')
+		let g:NERDDelimiterMap.caddyfile = s:delimiters
+	endif
+else
+	let g:NERDCustomDelimiters = {'caddyfile': s:delimiters}
+endif
+unlet s:delimiters
+
+endif

ftplugin/clojure.vim

@@ -1,13 +1,13 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'clojure') == -1
   
 " Vim filetype plugin file
-" Language:	Clojure
-" Author:	Meikel Brandmeyer <mb@kotka.de>
+" Language:     Clojure
+" Author:       Meikel Brandmeyer <mb@kotka.de>
 "
-" Maintainer:	Sung Pae <self@sungpae.com>
-" URL:		https://github.com/guns/vim-clojure-static
-" License:	Same as Vim
-" Last Change:	%%RELEASE_DATE%%
+" Maintainer:   Sung Pae <self@sungpae.com>
+" URL:          https://github.com/guns/vim-clojure-static
+" License:      Same as Vim
+" Last Change:  %%RELEASE_DATE%%
 
 if exists("b:did_ftplugin")
 	finish
@@ -84,9 +84,9 @@ endif
 " Win32 can filter files in the browse dialog
 if has("gui_win32") && !exists("b:browsefilter")
 	let b:browsefilter = "Clojure Source Files (*.clj)\t*.clj\n" .
-			   \ "ClojureScript Source Files (*.cljs)\t*.cljs\n" .
-			   \ "Java Source Files (*.java)\t*.java\n" .
-			   \ "All Files (*.*)\t*.*\n"
+	                   \ "ClojureScript Source Files (*.cljs)\t*.cljs\n" .
+	                   \ "Java Source Files (*.java)\t*.java\n" .
+	                   \ "All Files (*.*)\t*.*\n"
 	let b:undo_ftplugin .= ' | unlet! b:browsefilter'
 endif
 

ftplugin/coffee.vim

@@ -15,7 +15,7 @@ call coffee#CoffeeSetUpVariables()
 setlocal formatoptions-=t formatoptions+=croql
 setlocal comments=:# commentstring=#\ %s
 setlocal omnifunc=javascriptcomplete#CompleteJS
-setlocal suffixesadd+=coffee
+setlocal suffixesadd+=.coffee
 
 " Create custom augroups.
 augroup CoffeeBufUpdate | augroup END

ftplugin/crystal.vim

@@ -12,7 +12,7 @@ if exists('loaded_matchit') && !exists('b:match_words')
   let b:match_ignorecase = 0
 
   let b:match_words =
-        \ '\<\%(if\|unless\|case\|while\|until\|for\|do\|class\|module\|struct\|lib\|macro\|ifdef\|def\|fun\|begin\)\>=\@!' .
+        \ '\<\%(if\|unless\|case\|while\|until\|for\|do\|class\|module\|struct\|lib\|macro\|ifdef\|def\|fun\|begin\|enum\)\>=\@!' .
         \ ':' .
         \ '\<\%(else\|elsif\|ensure\|when\|rescue\|break\|redo\|next\|retry\)\>' .
         \ ':' .

ftplugin/dart.vim

@@ -25,7 +25,9 @@ let &l:errorformat =
   \   '%m'
   \ ], ',')
 
+setlocal includeexpr=dart#resolveUri(v:fname)
+setlocal isfname+=:
 
-let b:undo_ftplugin = 'setl et< fo< sw< sts< com< cms<'
+let b:undo_ftplugin = 'setl et< fo< sw< sts< com< cms< inex< isf<'
 
 endif

ftplugin/eelixir.vim

@@ -80,6 +80,23 @@ if exists("loaded_matchit")
   let b:match_words = s:match_words
 endif
 
+if !exists('b:surround_45')
+  " When using surround `-` (ASCII 45) would provide `<% selection %>`
+  let b:surround_45 = "<% \r %>"
+endif
+if !exists('b:surround_61')
+  " When using surround `=` (ASCII 61) would provide `<%= selection %>`
+  let b:surround_61 = "<%= \r %>"
+endif
+if !exists('b:surround_35')
+  " When using surround `#` (ASCII 35) would provide `<%# selection %>`
+  let b:surround_35 = "<%# \r %>"
+endif
+if !exists('b:surround_5')
+  " When using surround `<C-e>` (ASCII 5 `ENQ`) would provide `<% selection %>\n<% end %>`
+  let b:surround_5 = "<% \r %>\n<% end %>"
+endif
+
 setlocal comments=:<%#
 setlocal commentstring=<%#\ %s\ %>
 

ftplugin/elixir.vim

@@ -56,6 +56,6 @@ let &l:path =
 setlocal includeexpr=GetElixirFilename(v:fname)
 setlocal suffixesadd=.ex,.exs,.eex,.erl,.yrl,.hrl
 
-setlocal formatoptions-=t formatoptions+=croqlj
+silent! setlocal formatoptions-=t formatoptions+=croqlj
 
 endif

ftplugin/ember-script.vim

@@ -1,11 +1,11 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'emberscript') == -1
   
 " Language:    ember-script
-" Maintainer:  heartsentwined <heartsentwined@cogito-lab.com>
-" URL:         http://github.com/heartsentwined/vim-ember-script
-" Version:     1.0.1
-" Last Change: 2013 Apr 17
-" License:     GPL-3.0
+" Maintainer:  Yulij Andreevich Lesov <yalesov@gmail.com>>
+" URL:         http://github.com/yalesov/vim-ember-script
+" Version:     1.0.4
+" Last Change: 2016 Jul 6
+" License:     ISC
 
 setlocal tabstop=2
 setlocal softtabstop=2
@@ -14,7 +14,11 @@ setlocal smarttab
 setlocal expandtab
 setlocal smartindent
 
-setlocal formatoptions-=t formatoptions+=croqlj
+if v:version < 703
+  setlocal formatoptions-=t formatoptions+=croql
+else
+  setlocal formatoptions-=t formatoptions+=croqlj
+endif
 setlocal comments=:#
 setlocal commentstring=#\ %s
 

ftplugin/emblem.vim

@@ -1,11 +1,11 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'emblem') == -1
   
 " Language:    emblem
-" Maintainer:  heartsentwined <heartsentwined@cogito-lab.com>
-" URL:         http://github.com/heartsentwined/vim-emblem
-" Version:     1.2.0
-" Last Change: 2013 Apr 22
-" License:     GPL-3.0
+" Maintainer:  Yulij Andreevich Lesov <yalesov@gmail.com>
+" URL:         http://github.com/yalesov/vim-emblem
+" Version:     2.0.1
+" Last Change: 2016 Jul 6
+" License:     ISC
 
 setlocal tabstop=2
 setlocal softtabstop=2

ftplugin/i3.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'i3') == -1
+  
+setlocal commentstring=#\ %s
+
+endif

ftplugin/javascript.vim

@@ -1,8 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') == -1
-  
-setlocal suffixesadd+=.js
-if (v:version < 704 || (v:version == 704 && !has('patch002'))) && exists('&regexpengine')
-  set re=1
-end
-
-endif

ftplugin/json.vim

@@ -0,0 +1,42 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'json') == -1
+  
+" Vim syntax file
+" Language:	JSON
+" Maintainer:	Eli Parra <eli@elzr.com> https://github.com/elzr/vim-json
+" Last Change:	2014-05-20 added warning toggle
+
+"uncomment to enable folding of `{...}` and `[...]` blocks
+"setlocal foldmethod=syntax
+
+"conceal by default
+if !exists("g:vim_json_syntax_conceal")
+	let g:vim_json_syntax_conceal = 1
+end
+
+"have warnings by default
+if !exists("g:vim_json_warnings")
+	let g:vim_json_warnings = 1
+end
+
+"set concealcursor blank by default
+"this should turn off the concealing in the current line (where the cursor is at),
+"on all modes (normal, visual, insert)
+if !exists("g:vim_json_syntax_concealcursor")
+	let g:vim_json_syntax_concealcursor = ""
+end
+
+if has('conceal')
+	if (g:vim_json_syntax_conceal == 1)
+		"level 2 means concealed text gets completely hidden unless a
+		"replacement is defined (none is defined by us)
+		setlocal conceallevel=2
+		let &l:concealcursor = g:vim_json_syntax_concealcursor
+	else
+		"level 0 means text is shown normally = no concealing
+		setlocal conceallevel=0
+	endif
+	"maybe g:vim_json_syntax_conceal could be settable to 0,1,2 to map
+	"directly to vim's conceallevels? unsure if anyone cares
+endif
+
+endif

ftplugin/litcoffee.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'coffee-script') == -1
+  
+runtime ftplugin/coffee.vim
+
+endif

ftplugin/ls.vim

@@ -0,0 +1,208 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'livescript') == -1
+  
+" Language:    LiveScript
+" Maintainer:  George Zahariev
+" URL:         http://github.com/gkz/vim-ls
+" License:     WTFPL
+"
+if exists("b:did_ftplugin")
+  finish
+endif
+
+let b:did_ftplugin = 1
+
+setlocal formatoptions-=t formatoptions+=croql
+setlocal comments=:#
+setlocal commentstring=#\ %s
+setlocal omnifunc=javascriptcomplete#CompleteJS
+
+" Enable LiveScriptMake if it won't overwrite any settings.
+if !len(&l:makeprg)
+  compiler ls
+endif
+
+" Check here too in case the compiler above isn't loaded.
+if !exists('livescript_compiler')
+  let livescript_compiler = 'lsc'
+endif
+
+" Reset the LiveScriptCompile variables for the current buffer.
+function! s:LiveScriptCompileResetVars()
+  " Compiled output buffer
+  let b:livescript_compile_buf = -1
+  let b:livescript_compile_pos = []
+
+  " If LiveScriptCompile is watching a buffer
+  let b:livescript_compile_watch = 0
+endfunction
+
+" Clean things up in the source buffer.
+function! s:LiveScriptCompileClose()
+  exec bufwinnr(b:livescript_compile_src_buf) 'wincmd w'
+  silent! autocmd! LiveScriptCompileAuWatch * <buffer>
+  call s:LiveScriptCompileResetVars()
+endfunction
+
+" Update the LiveScriptCompile buffer given some input lines.
+function! s:LiveScriptCompileUpdate(startline, endline)
+  let input = join(getline(a:startline, a:endline), "\n")
+
+  " Move to the LiveScriptCompile buffer.
+  exec bufwinnr(b:livescript_compile_buf) 'wincmd w'
+
+  " LiveScript doesn't like empty input.
+  if !len(input)
+    return
+  endif
+
+  " Compile input.
+  let output = system(g:livescript_compiler . ' -scb 2>&1', input)
+
+  " Be sure we're in the LiveScriptCompile buffer before overwriting.
+  if exists('b:livescript_compile_buf')
+    echoerr 'LiveScriptCompile buffers are messed up'
+    return
+  endif
+
+  " Replace buffer contents with new output and delete the last empty line.
+  setlocal modifiable
+    exec '% delete _'
+    put! =output
+    exec '$ delete _'
+  setlocal nomodifiable
+
+  " Highlight as JavaScript if there is no compile error.
+  if v:shell_error
+    setlocal filetype=
+  else
+    setlocal filetype=javascript
+  endif
+
+  call setpos('.', b:livescript_compile_pos)
+endfunction
+
+" Update the LiveScriptCompile buffer with the whole source buffer.
+function! s:LiveScriptCompileWatchUpdate()
+  call s:LiveScriptCompileUpdate(1, '$')
+  exec bufwinnr(b:livescript_compile_src_buf) 'wincmd w'
+endfunction
+
+" Peek at compiled LiveScript in a scratch buffer. We handle ranges like this
+" to prevent the cursor from being moved (and its position saved) before the
+" function is called.
+function! s:LiveScriptCompile(startline, endline, args)
+  if !executable(g:livescript_compiler)
+    echoerr "Can't find LiveScript compiler `" . g:livescript_compiler . "`"
+    return
+  endif
+
+  " If in the LiveScriptCompile buffer, switch back to the source buffer and
+  " continue.
+  if !exists('b:livescript_compile_buf')
+    exec bufwinnr(b:livescript_compile_src_buf) 'wincmd w'
+  endif
+
+  " Parse arguments.
+  let watch = a:args =~ '\<watch\>'
+  let unwatch = a:args =~ '\<unwatch\>'
+  let size = str2nr(matchstr(a:args, '\<\d\+\>'))
+
+  " Determine default split direction.
+  if exists('g:livescript_compile_vert')
+    let vert = 1
+  else
+    let vert = a:args =~ '\<vert\%[ical]\>'
+  endif
+
+  " Remove any watch listeners.
+  silent! autocmd! LiveScriptCompileAuWatch * <buffer>
+
+  " If just unwatching, don't compile.
+  if unwatch
+    let b:livescript_compile_watch = 0
+    return
+  endif
+
+  if watch
+    let b:livescript_compile_watch = 1
+  endif
+
+  " Build the LiveScriptCompile buffer if it doesn't exist.
+  if bufwinnr(b:livescript_compile_buf) == -1
+    let src_buf = bufnr('%')
+    let src_win = bufwinnr(src_buf)
+
+    " Create the new window and resize it.
+    if vert
+      let width = size ? size : winwidth(src_win) / 2
+
+      belowright vertical new
+      exec 'vertical resize' width
+    else
+      " Try to guess the compiled output's height.
+      let height = size ? size : min([winheight(src_win) / 2,
+      \                               a:endline - a:startline + 5])
+
+      belowright new
+      exec 'resize' height
+    endif
+
+    " We're now in the scratch buffer, so set it up.
+    setlocal bufhidden=wipe buftype=nofile
+    setlocal nobuflisted nomodifiable noswapfile nowrap
+
+    autocmd BufWipeout <buffer> call s:LiveScriptCompileClose()
+    " Save the cursor when leaving the LiveScriptCompile buffer.
+    autocmd BufLeave <buffer> let b:livescript_compile_pos = getpos('.')
+
+    nnoremap <buffer> <silent> q :hide<CR>
+
+    let b:livescript_compile_src_buf = src_buf
+    let buf = bufnr('%')
+
+    " Go back to the source buffer and set it up.
+    exec bufwinnr(b:livescript_compile_src_buf) 'wincmd w'
+    let b:livescript_compile_buf = buf
+  endif
+
+  if b:livescript_compile_watch
+    call s:LiveScriptCompileWatchUpdate()
+
+    augroup LiveScriptCompileAuWatch
+      autocmd InsertLeave <buffer> call s:LiveScriptCompileWatchUpdate()
+      autocmd BufWritePost <buffer> call s:LiveScriptCompileWatchUpdate()
+    augroup END
+  else
+    call s:LiveScriptCompileUpdate(a:startline, a:endline)
+  endif
+endfunction
+
+" Complete arguments for the LiveScriptCompile command.
+function! s:LiveScriptCompileComplete(arg, cmdline, cursor)
+  let args = ['unwatch', 'vertical', 'watch']
+
+  if !len(a:arg)
+    return args
+  endif
+
+  let match = '^' . a:arg
+
+  for arg in args
+    if arg =~ match
+      return [arg]
+    endif
+  endfor
+endfunction
+
+" Don't overwrite the CoffeeCompile variables.
+if !exists("s:livescript_compile_buf")
+  call s:LiveScriptCompileResetVars()
+endif
+
+" Peek at compiled LiveScript.
+command! -range=% -bar -nargs=* -complete=customlist,s:LiveScriptCompileComplete
+\        LiveScriptCompile call s:LiveScriptCompile(<line1>, <line2>, <q-args>)
+" Run some LiveScript.
+command! -range=% -bar LiveScriptRun <line1>,<line2>:w !lsc -sp
+
+endif

ftplugin/markdown.vim

@@ -1,54 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'markdown') == -1
-  
-" Vim filetype plugin
-" Language:		Markdown
-" Maintainer:		Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:		2013 May 30
-
-if exists("b:did_ftplugin")
-  finish
-endif
-
-runtime! ftplugin/html.vim ftplugin/html_*.vim ftplugin/html/*.vim
-
-setlocal comments=fb:*,fb:-,fb:+,n:> commentstring=<!--%s-->
-setlocal formatoptions+=tcqln formatoptions-=r formatoptions-=o
-setlocal formatlistpat=^\\s*\\d\\+\\.\\s\\+\\\|^[-*+]\\s\\+\\\|^\\[^\\ze[^\\]]\\+\\]:
-
-if exists('b:undo_ftplugin')
-  let b:undo_ftplugin .= "|setl cms< com< fo< flp<"
-else
-  let b:undo_ftplugin = "setl cms< com< fo< flp<"
-endif
-
-function! MarkdownFold()
-  let line = getline(v:lnum)
-
-  " Regular headers
-  let depth = match(line, '\(^#\+\)\@<=\( .*$\)\@=')
-  if depth > 0
-    return ">" . depth
-  endif
-
-  " Setext style headings
-  let nextline = getline(v:lnum + 1)
-  if (line =~ '^.\+$') && (nextline =~ '^=\+$')
-    return ">1"
-  endif
-
-  if (line =~ '^.\+$') && (nextline =~ '^-\+$')
-    return ">2"
-  endif
-
-  return "="
-endfunction
-
-if has("folding") && exists("g:markdown_folding")
-  setlocal foldexpr=MarkdownFold()
-  setlocal foldmethod=expr
-  let b:undo_ftplugin .= " foldexpr< foldmethod<"
-endif
-
-" vim:set sw=2:
-
-endif

ftplugin/mma.vim

@@ -0,0 +1,63 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'mathematica') == -1
+  
+"Vim filetype plugin
+" Language: Mathematica
+" Maintainer: R. Menon <rsmenon@icloud.com>
+" Last Change: Feb 26, 2013
+
+" Initialization {
+if exists("b:did_ftplugin")
+  finish
+endif
+let b:did_ftplugin = 1
+
+let s:cpo_save = &cpo
+set cpo&vim
+"}
+
+" Syntax completion function {
+if exists('&ofu')
+	setlocal omnifunc=syntaxcomplete#Complete
+	setlocal completefunc=syntaxcomplete#Complete
+endif
+"}
+
+" Main functions {
+if has('python')
+	" Random ID generator {
+	function! RandomID()
+
+"Python implementation follows; do not alter indentations/whitespace
+python << EOF
+import random, string, vim
+vim.command("let l:id = '" + (''.join(random.sample(string.ascii_uppercase + string.digits, 8))) + "'")
+EOF
+
+	return l:id
+	endfunction
+	"}
+
+	"Unit test template {
+	function! Test()
+		if exists("*strftime")
+			let l:date = strftime("%Y%m%d") . "-"
+		else
+			let l:date = ""
+		endif
+
+		let l:testid = expand("%:t") . "-" . l:date . RandomID()
+		let l:template = "Test[\rtest\r,\rresult\r,\rTestID -> \"" . l:testid . "\"\r\b]"
+		exe ":normal i" . l:template
+	endfunction
+	"}
+endif
+"}
+
+" Cleanup {
+let &cpo = s:cpo_save
+unlet s:cpo_save
+"}
+
+" vim: set foldmarker={,} foldlevel=0 foldmethod=marker:
+
+endif

ftplugin/nginx.vim

@@ -0,0 +1,9 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'nginx') == -1
+  
+setlocal commentstring=#\ %s
+
+setlocal iskeyword+=.
+setlocal iskeyword+=/
+setlocal iskeyword+=:
+
+endif

ftplugin/perl6.vim

@@ -1,92 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'perl') == -1
-  
-" Vim filetype plugin file
-" Language:      Perl 6
-" Maintainer:    vim-perl <vim-perl@googlegroups.com>
-" Homepage:      http://github.com/vim-perl/vim-perl
-" Bugs/requests: http://github.com/vim-perl/vim-perl/issues
-" Last Change:   {{LAST_CHANGE}}
-" Contributors:  Hinrik Örn Sigurðsson <hinrik.sig@gmail.com>
-"
-" Based on ftplugin/perl.vim by Dan Sharp <dwsharp at hotmail dot com>
-
-if exists("b:did_ftplugin") | finish | endif
-let b:did_ftplugin = 1
-
-" Make sure the continuation lines below do not cause problems in
-" compatibility mode.
-let s:save_cpo = &cpo
-set cpo-=C
-
-setlocal formatoptions-=t
-setlocal formatoptions+=crqol
-setlocal keywordprg=p6doc
-
-setlocal comments=:#\|,:#=,:#
-setlocal commentstring=#%s
-
-" Change the browse dialog on Win32 to show mainly Perl-related files
-if has("gui_win32")
-    let b:browsefilter = "Perl Source Files (*.pl)\t*.pl\n" .
-               \ "Perl Modules (*.pm)\t*.pm\n" .
-               \ "Perl Documentation Files (*.pod)\t*.pod\n" .
-               \ "All Files (*.*)\t*.*\n"
-endif
-
-" Provided by Ned Konz <ned at bike-nomad dot com>
-"---------------------------------------------
-setlocal include=\\<\\(use\\\|require\\)\\>
-setlocal includeexpr=substitute(substitute(v:fname,'::','/','g'),'$','.pm','')
-setlocal define=[^A-Za-z_]
-
-" The following line changes a global variable but is necessary to make
-" gf and similar commands work. Thanks to Andrew Pimlott for pointing out
-" the problem. If this causes a " problem for you, add an
-" after/ftplugin/perl6.vim file that contains
-"       set isfname-=:
-set isfname+=:
-setlocal iskeyword=@,48-57,_,192-255,-
-
-" Set this once, globally.
-if !exists("perlpath")
-    if executable("perl6")
-        try
-            if &shellxquote != '"'
-                let perlpath = system('perl6 -e  "@*INC.join(q/,/).say"')
-            else
-                let perlpath = system("perl6 -e  '@*INC.join(q/,/).say'")
-            endif
-            let perlpath = substitute(perlpath,',.$',',,','')
-        catch /E145:/
-            let perlpath = ".,,"
-        endtry
-    else
-        " If we can't call perl to get its path, just default to using the
-        " current directory and the directory of the current file.
-        let perlpath = ".,,"
-    endif
-endif
-
-" Append perlpath to the existing path value, if it is set.  Since we don't
-" use += to do it because of the commas in perlpath, we have to handle the
-" global / local settings, too.
-if &l:path == ""
-    if &g:path == ""
-        let &l:path=perlpath
-    else
-        let &l:path=&g:path.",".perlpath
-    endif
-else
-    let &l:path=&l:path.",".perlpath
-endif
-"---------------------------------------------
-
-" Undo the stuff we changed.
-let b:undo_ftplugin = "setlocal fo< com< cms< inc< inex< def< isf< isk< kp< path<" .
-        \         " | unlet! b:browsefilter"
-
-" Restore the saved compatibility options.
-let &cpo = s:save_cpo
-unlet s:save_cpo
-
-endif

ftplugin/plantuml.vim

@@ -3,20 +3,40 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'plantuml') == -
 " Vim plugin file
 " Language:     PlantUML
 " Maintainer:   Aaron C. Meadows < language name at shadowguarddev dot com>
-" Last Change:  19-Jun-2012
 " Version:      0.1
 
-if exists("g:loaded_plantuml_plugin")
-    finish
+if exists("b:loaded_plantuml_plugin")
+  finish
 endif
-let g:loaded_plantuml_plugin = 1
+let b:loaded_plantuml_plugin = 1
+let s:cpo_save = &cpo
+set cpo&vim
 
 if !exists("g:plantuml_executable_script")
-	let g:plantuml_executable_script="plantuml"
+  let g:plantuml_executable_script="plantuml"
 endif
 
-autocmd Filetype plantuml let &l:makeprg=g:plantuml_executable_script . " " .  fnameescape(expand("%"))
+if exists("loaded_matchit")
+  let b:match_ignorecase = 0
+  let b:match_words =
+        \ '\(\<ref\>\|\<box\>\|\<opt\>\|\<alt\>\|\<group\>\|\<loop\>\|\<note\>\|\<legend\>\):\<else\>:\<end\>' .
+        \ ',\<if\>:\<elseif\>:\<else\>:\<endif\>' .
+        \ ',\<rnote\>:\<endrnote\>' .
+        \ ',\<hnote\>:\<endhnote\>' .
+        \ ',\<title\>:\<endtitle\>' .
+        \ ',\<\while\>:\<endwhile\>'
+endif
+
+let &l:makeprg=g:plantuml_executable_script . " " .  fnameescape(expand("%"))
 
 setlocal comments=s1:/',mb:',ex:'/,:' commentstring=/'%s'/ formatoptions-=t formatoptions+=croql
 
+let b:endwise_addition = '\=index(["note","legend"], submatch(0))!=-1 ? "end " . submatch(0) : "end"'
+let b:endwise_words = 'loop,group,alt,note,legend'
+let b:endwise_pattern = '^\s*\zs\<\(loop\|group\|alt\|note\ze[^:]*$\|legend\)\>.*$'
+let b:endwise_syngroups = 'plantumlKeyword'
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
 endif

ftplugin/purescript.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'purescript') == -1
+  
+setlocal comments=s1fl:{-,mb:\ \ ,ex:-},:--
+
+endif

ftplugin/raml.vim

@@ -0,0 +1,5 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'raml') == -1
+  
+set ts=2 sts=2 sw=2 et
+
+endif

ftplugin/ruby.vim

@@ -77,20 +77,20 @@ function! s:query_path(root) abort
     let prefix = ''
   endif
   if &shellxquote == "'"
-    let path_check = prefix.'ruby -e "' . code . '"'
+    let path_check = prefix.'ruby --disable-gems -e "' . code . '"'
   else
-    let path_check = prefix."ruby -e '" . code . "'"
+    let path_check = prefix."ruby --disable-gems -e '" . code . "'"
   endif
 
   let cd = haslocaldir() ? 'lcd' : 'cd'
-  let cwd = getcwd()
+  let cwd = fnameescape(getcwd())
   try
     exe cd fnameescape(a:root)
     let path = split(system(path_check),',')
-    exe cd fnameescape(cwd)
+    exe cd cwd
     return path
   finally
-    exe cd fnameescape(cwd)
+    exe cd cwd
   endtry
 endfunction
 

ftplugin/rust.vim

@@ -48,7 +48,6 @@ endif
 " This includeexpr isn't perfect, but it's a good start
 setlocal includeexpr=substitute(v:fname,'::','/','g')
 
-" NOT adding .rc as it's being phased out (0.7)
 setlocal suffixesadd=.rs
 
 if exists("g:ftplugin_rust_source_path")
@@ -113,16 +112,6 @@ xnoremap <silent> <buffer> ]] :call rust#Jump('v', 'Forward')<CR>
 onoremap <silent> <buffer> [[ :call rust#Jump('o', 'Back')<CR>
 onoremap <silent> <buffer> ]] :call rust#Jump('o', 'Forward')<CR>
 
-" %-matching. <:> is handy for generics.
-set matchpairs+=<:>
-" There are two minor issues with it; (a) comparison operators in expressions,
-" where a less-than may match a greater-than later on—this is deemed a trivial
-" issue—and (b) `Fn() -> X` syntax. This latter issue is irremediable from the
-" highlighting perspective (built into Vim), but the actual % functionality
-" can be fixed by this use of matchit.vim.
-let b:match_skip = 's:comment\|string\|rustArrow'
-source $VIMRUNTIME/macros/matchit.vim
-
 " Commands {{{1
 
 " See |:RustRun| for docs
@@ -143,6 +132,9 @@ command! -range=% RustPlay :call rust#Play(<count>, <line1>, <line2>, <f-args>)
 " See |:RustFmt| for docs
 command! -buffer RustFmt call rustfmt#Format()
 
+" See |:RustFmtRange| for docs
+command! -range -buffer RustFmtRange call rustfmt#FormatRange(<line1>, <line2>)
+
 " Mappings {{{1
 
 " Bind ⌘R in MacVim to :RustRun
@@ -190,13 +182,27 @@ let b:undo_ftplugin = "
 		\|ounmap <buffer> ]]
 		\|set matchpairs-=<:>
 		\|unlet b:match_skip
-		\|augroup! rust.vim
 		\"
 
 " }}}1
 
+" Code formatting on save
+if get(g:, "rustfmt_autosave", 0)
+	autocmd BufWritePre *.rs silent! call rustfmt#Format()
+endif
+
 augroup END
 
+" %-matching. <:> is handy for generics.
+set matchpairs+=<:>
+" There are two minor issues with it; (a) comparison operators in expressions,
+" where a less-than may match a greater-than later on—this is deemed a trivial
+" issue—and (b) `Fn() -> X` syntax. This latter issue is irremediable from the
+" highlighting perspective (built into Vim), but the actual % functionality
+" can be fixed by this use of matchit.vim.
+let b:match_skip = 's:comment\|string\|rustArrow'
+source $VIMRUNTIME/macros/matchit.vim
+
 let &cpo = s:save_cpo
 unlet s:save_cpo
 

ftplugin/sass.vim

@@ -1,27 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haml') == -1
-  
-" Vim filetype plugin
-" Language:	Sass
-" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2010 Jul 26
-
-" Only do this when not done yet for this buffer
-if exists("b:did_ftplugin")
-  finish
-endif
-let b:did_ftplugin = 1
-
-let b:undo_ftplugin = "setl com< cms< def< inc< inex< ofu< sua<"
-
-setlocal comments=://
-setlocal commentstring=//\ %s
-setlocal define=^\\s*\\%(@mixin\\\|=\\)
-setlocal includeexpr=substitute(v:fname,'\\%(.*/\\\|^\\)\\zs','_','')
-setlocal omnifunc=csscomplete#CompleteCSS
-setlocal suffixesadd=.sass,.scss,.css
-
-let &l:include = '^\s*@import\s\+\%(url(\)\=["'']\='
-
-" vim:set sw=2:
-
-endif

ftplugin/scala.vim

@@ -18,7 +18,11 @@ silent! setlocal formatoptions+=j
 
 " Just like c.vim, but additionally doesn't wrap text onto /** line when
 " formatting. Doesn't bungle bulleted lists when formatting.
-setlocal comments=sO:*\ -,mO:*\ \ ,exO:*/,s1:/**,mb:*,ex:*/,s1:/*,mb:*,ex:*/,://
+if get(g:, 'scala_scaladoc_indent', 0)
+  setlocal comments=sO:*\ -,mO:*\ \ ,exO:*/,s2:/**,mb:*,ex:*/,s1:/*,mb:*,ex:*/,://
+else
+  setlocal comments=sO:*\ -,mO:*\ \ ,exO:*/,s1:/**,mb:*,ex:*/,s1:/*,mb:*,ex:*/,://
+endif
 setlocal commentstring=//\ %s
 
 setlocal shiftwidth=2 softtabstop=2 expandtab

ftplugin/scss.vim

@@ -1,17 +1,17 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haml') == -1
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'scss') == -1
   
-" Vim filetype plugin
-" Language:	SCSS
-" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2010 Jul 26
-
-if exists("b:did_ftplugin")
+if exists('b:did_indent') && b:did_indent
+  " be kind. allow users to override this. Does it work?
   finish
 endif
 
-runtime! ftplugin/sass.vim
+setlocal indentexpr=scss_indent#GetIndent(v:lnum)
+
+" Automatically insert the current comment leader after hitting <Enter>
+" in Insert mode respectively after hitting 'o' or 'O' in Normal mode
+setlocal formatoptions+=ro
+
+" SCSS comments are either /* */ or //
 setlocal comments=s1:/*,mb:*,ex:*/,://
 
-" vim:set sw=2:
-
 endif

ftplugin/vue.vim

@@ -0,0 +1,16 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vue') == -1
+  
+" Vim filetype plugin
+" Language: Vue.js
+" Maintainer: Eduardo San Martin Morote
+" Author: Adriaan Zonnenberg
+
+if exists("b:did_ftplugin")
+  finish
+endif
+
+runtime! ftplugin/html.vim
+
+setlocal suffixesadd+=.vue
+
+endif

indent/blade.vim

@@ -4,72 +4,96 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'blade') == -1
 " Language:     Blade (Laravel)
 " Maintainer:   Jason Walton <jwalton512@gmail.com>
 
-if exists("b:did_indent")
+if exists('b:did_indent')
     finish
 endif
 
 runtime! indent/html.vim
 let s:htmlindent = &indentexpr
-unlet! b:did_indent
 
+unlet! b:did_indent
 runtime! indent/php.vim
 let s:phpindent = &indentexpr
-unlet! b:did_indent
 
 let b:did_indent = 1
 
+" Doesn't include 'foreach' and 'forelse' because these already get matched by 'for'.
+let s:directives_start = 'if\|else\|unless\|for\|while\|empty\|push\|section\|can\|hasSection\|verbatim\|php\|' .
+            \ 'component\|slot\|prepend'
+let s:directives_end = 'else\|end\|empty\|show\|stop\|append\|overwrite'
+
+if exists('g:blade_custom_directives_pairs')
+    let s:directives_start .= '\|' . join(keys(g:blade_custom_directives_pairs), '\|')
+    let s:directives_end .= '\|' . join(values(g:blade_custom_directives_pairs), '\|')
+endif
+
 setlocal autoindent
 setlocal indentexpr=GetBladeIndent()
-setlocal indentkeys=o,O,*<Return>,<>>,!^F,=@else,=@end,=@empty,=@show,=@stop
+exe 'setlocal indentkeys=o,O,<>>,!^F,0=}},0=!!},=@' . substitute(s:directives_end, '\\|', ',=@', 'g')
 
 " Only define the function once.
-if exists("*GetBladeIndent")
+if exists('*GetBladeIndent')
     finish
 endif
 
+function! s:IsStartingDelimiter(lnum)
+    let line = getline(a:lnum)
+    return line =~# '\%(\w\|@\)\@<!@\%(' . s:directives_start . '\)\%(.*@end\|.*@stop\)\@!'
+                \ || line =~# '{{\%(.*}}\)\@!'
+                \ || line =~# '{!!\%(.*!!}\)\@!'
+                \ || line =~# '<?\%(.*?>\)\@!'
+endfunction
+
 function! GetBladeIndent()
-    let lnum = prevnonblank(v:lnum-1)
+    let lnum = prevnonblank(v:lnum - 1)
     if lnum == 0
         return 0
     endif
 
-    let line = substitute(substitute(getline(lnum), '\s\+$', '', ''), '^\s\+', '', '')
-    let cline = substitute(substitute(getline(v:lnum), '\s\+$', '', ''), '^\s\+', '', '')
+    let line = getline(lnum)
+    let cline = getline(v:lnum)
     let indent = indent(lnum)
-    let cindent = indent(v:lnum)
-    if cline =~# '@\%(else\|elseif\|empty\|end\|show\|stop\)' ||
-                \ cline =~# '\%(<?.*\)\@<!?>\|\%({{.*\)\@<!}}\|\%({!!.*\)\@<!!!}'
-        let indent = indent - &sw
-    else
-        if exists("*GetBladeIndentCustom")
-            let hindent = GetBladeIndentCustom()
-        elseif searchpair('@include\s*(', '', ')', 'bWr') ||
-                    \ searchpair('{!!', '', '!!}', 'bWr') ||
-                    \ searchpair('{{', '', '}}', 'bWr') ||
-                    \ searchpair('<?', '', '?>', 'bWr')
-            execute 'let hindent = ' . s:phpindent
-        else
-            execute 'let hindent = ' . s:htmlindent
-        endif
-        if hindent > -1
-            let indent = hindent
-        endif
-    endif
-    let increase = indent + &sw
-    if indent = indent(lnum)
-        let indent = cindent <= indent ? -1 : increase
+
+    " 1. Check for special directives
+    " @section is a single-line directive if it has a second argument.
+    " @php is a single-line directive if it is followed by parentheses.
+    if (line =~# '@section\%(.*@end\)\@!' && line !~# '@section\s*([^,]*)')
+                \ || line =~# '@php\s*('
+        return indent
     endif
 
-    if line =~# '@\%(section\)\%(.*@end\)\@!' && line !~# '@\%(section\)\s*([^,]*)'
-        return indent
-    elseif line =~# '@\%(if\|elseif\|else\|unless\|foreach\|forelse\|for\|while\|empty\|push\|section\|can\|hasSection\)\%(.*@end\|.*@stop\)\@!' ||
-                \ line =~# '{{\%(.*}}\)\@!' || line =~# '{!!\%(.*!!}\)\@!'
-        return increase
-    elseif line =~# '<?\%(.*?>\)\@!'
-        return indent(lnum-1) == -1 ? increase : indent(lnum) + increase
-    else
-        return indent
+    " 2. When the current line is an ending delimiter: decrease indentation
+    "    if the previous line wasn't a starting delimiter.
+    if cline =~# '^\s*@\%(' . s:directives_end . '\)'
+                \ || cline =~# '\%(<?.*\)\@<!?>'
+                \ || cline =~# '\%({{.*\)\@<!}}'
+                \ || cline =~# '\%({!!.*\)\@<!!!}'
+        return s:IsStartingDelimiter(lnum) ? indent : indent - &sw
     endif
+
+    " 3. Increase indentation if the line contains a starting delimiter.
+    if s:IsStartingDelimiter(lnum)
+        return indent + &sw
+    endif
+
+    " 4. External indent scripts (PHP and HTML)
+    execute 'let indent = ' . s:htmlindent
+
+    if exists('*GetBladeIndentCustom')
+        let indent = GetBladeIndentCustom()
+    elseif line !~# '^\s*\%(#\|//\)\|\*/\s*$' && (
+                \ searchpair('@include\%(If\)\?\s*(', '', ')', 'bWr') ||
+                \ searchpair('{!!', '', '!!}', 'bWr') ||
+                \ searchpair('{{', '', '}}', 'bWr') ||
+                \ searchpair('<?', '', '?>', 'bWr') ||
+                \ searchpair('@php\s*(\@!', '', '@endphp', 'bWr') )
+        " Only use PHP's indent if the region spans multiple lines
+        if !s:IsStartingDelimiter(v:lnum)
+            execute 'let indent = ' . s:phpindent
+        endif
+    endif
+
+    return indent
 endfunction
 
 endif

indent/caddyfile.vim

@@ -0,0 +1,46 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'caddyfile') == -1
+  
+if exists('b:did_indent')
+	finish
+endif
+let b:did_indent = 1
+
+setlocal nolisp
+setlocal autoindent
+setlocal indentexpr=GetCaddyfileIndent(v:lnum)
+setlocal indentkeys+=<:>,0=},0=)
+" setlocal cindent
+
+if exists('*shiftwidth')
+	func s:sw()
+		return shiftwidth()
+	endfunc
+else
+	func s:sw()
+		return &sw
+	endfunc
+endif
+
+function! GetCaddyfileIndent(lnum)
+	let prevlnum = prevnonblank(a:lnum-1)
+	if prevlnum == 0
+		return 0
+	endif
+
+	let thisl = substitute(getline(a:lnum), '#.*$', '', '')
+	let prevl = substitute(getline(prevlnum), '#.*$', '', '')
+
+	let ind = indent(prevlnum)
+
+	if prevl =~ '{\s*$'
+		let ind += s:sw()
+	endif
+
+	if thisl =~ '^\s*}\s*$'
+		let ind -= s:sw()
+	endif
+
+	return ind
+endfunction
+
+endif

indent/clojure.vim

@@ -1,14 +1,14 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'clojure') == -1
   
 " Vim indent file
-" Language:	Clojure
-" Author:	Meikel Brandmeyer <mb@kotka.de>
-" URL:		http://kotka.de/projects/clojure/vimclojure.html
+" Language:     Clojure
+" Author:       Meikel Brandmeyer <mb@kotka.de>
+" URL:          http://kotka.de/projects/clojure/vimclojure.html
 "
-" Maintainer:	Sung Pae <self@sungpae.com>
-" URL:		https://github.com/guns/vim-clojure-static
-" License:	Same as Vim
-" Last Change:	%%RELEASE_DATE%%
+" Maintainer:   Sung Pae <self@sungpae.com>
+" URL:          https://github.com/guns/vim-clojure-static
+" License:      Same as Vim
+" Last Change:  %%RELEASE_DATE%%
 
 if exists("b:did_indent")
 	finish
@@ -79,8 +79,8 @@ if exists("*searchpairpos")
 	" patterns.
 	function! s:match_one(patterns, string)
 		let list = type(a:patterns) == type([])
-			   \ ? a:patterns
-			   \ : map(split(a:patterns, ','), '"^" . v:val . "$"')
+		           \ ? a:patterns
+		           \ : map(split(a:patterns, ','), '"^" . v:val . "$"')
 		for pat in list
 			if a:string =~# pat | return 1 | endif
 		endfor
@@ -89,7 +89,7 @@ if exists("*searchpairpos")
 	function! s:match_pairs(open, close, stopat)
 		" Stop only on vector and map [ resp. {. Ignore the ones in strings and
 		" comments.
-		if a:stopat == 0
+		if a:stopat == 0 && g:clojure_maxlines > 0
 			let stopat = max([line(".") - g:clojure_maxlines, 0])
 		else
 			let stopat = a:stopat
@@ -123,7 +123,7 @@ if exists("*searchpairpos")
 			if s:syn_id_name() !~? "string"
 				return -1
 			endif
-			if s:current_char() != '\\'
+			if s:current_char() != '\'
 				return -1
 			endif
 			call cursor(0, col("$") - 1)
@@ -189,6 +189,16 @@ if exists("*searchpairpos")
 		return val
 	endfunction
 
+	" Check if form is a reader conditional, that is, it is prefixed by #?
+	" or @#?
+	function! s:is_reader_conditional_special_case(position)
+		if getline(a:position[0])[a:position[1] - 3 : a:position[1] - 2] == "#?"
+			return 1
+		endif
+
+		return 0
+	endfunction
+
 	" Returns 1 for opening brackets, -1 for _anything else_.
 	function! s:bracket_type(char)
 		return stridx('([{', a:char) > -1 ? 1 : -1
@@ -256,6 +266,10 @@ if exists("*searchpairpos")
 			return [paren[0], paren[1] + &shiftwidth - 1]
 		endif
 
+		if s:is_reader_conditional_special_case(paren)
+			return paren
+		endif
+
 		" In case we are at the last character, we use the paren position.
 		if col("$") - 1 == paren[1]
 			return paren

indent/dart.vim

@@ -8,6 +8,32 @@ let b:did_indent = 1
 setlocal cindent
 setlocal cinoptions+=j1,J1
 
+setlocal indentexpr=DartIndent()
+
 let b:undo_indent = 'setl cin< cino<'
 
+if exists("*DartIndent")
+  finish
+endif
+
+function! DartIndent()
+  " Default to cindent in most cases
+  let indentTo = cindent(v:lnum)
+
+  let previousLine = getline(prevnonblank(v:lnum - 1))
+  let currentLine = getline(v:lnum)
+
+  " Don't indent after an annotation
+  if previousLine =~# '^\s*@.*$'
+    let indentTo = indent(v:lnum - 1)
+  endif
+
+  " Indent after opening List literal
+  if previousLine =~# '\[$' && !(currentLine =~# '^\s*\]')
+    let indentTo = indent(v:lnum - 1) + &shiftwidth
+  endif
+
+  return indentTo
+endfunction
+
 endif

indent/eelixir.vim

@@ -8,6 +8,9 @@ runtime! indent/elixir.vim
 unlet! b:did_indent
 setlocal indentexpr=
 
+let s:cpo_save = &cpo
+set cpo&vim
+
 if exists("b:eelixir_subtype")
   exe "runtime! indent/".b:eelixir_subtype.".vim"
 else
@@ -53,19 +56,21 @@ function! GetEelixirIndent(...)
   let line = getline(lnum)
   let cline = getline(v:lnum)
   if cline =~# '^\s*<%\s*\%(end\|else\|elsif\|catch\|after\|rescue\)\>.*%>'
-    let ind = ind - &sw
+    let ind -= &sw
   elseif line =~# '\S\s*<%\s*end\s*%>'
-    let ind = ind - &sw
+    let ind -= &sw
   endif
-  if line =~# '<%[=%]\=\s*.*\<do\s*%>'
-    let ind = ind + &sw
-  elseif line =~# '<%\s*\%(else\|elsif\|catch\|after\|rescue\)\>.*%>'
-    let ind = ind + &sw
+  if line =~# '<%[=%]\=\s*.*\(\<do\|->\)\s*%>' ||
+        \ line =~# '<%\s*\%(else\|elsif\|catch\|after\|rescue\)\>.*%>'
+    let ind += &sw
   endif
   if cline =~# '^\s*%>\s*$'
-    let ind = ind - &sw
+    let ind -= &sw
   endif
   return ind
 endfunction
 
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
 endif

indent/elixir.vim

@@ -1,144 +1,96 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'elixir') == -1
   
-if exists("b:did_indent")
-  finish
-endif
-let b:did_indent = 1
-
 setlocal nosmartindent
+setlocal indentexpr=elixir#indent()
+setlocal indentkeys+=0),0],0=\|>,=->
+setlocal indentkeys+=0=end,0=else,0=match,0=elsif,0=catch,0=after,0=rescue
 
-setlocal indentexpr=GetElixirIndent()
-setlocal indentkeys+=0),0],0=end,0=else,0=match,0=elsif,0=catch,0=after,0=rescue
-
-if exists("*GetElixirIndent")
+if exists("b:did_indent") || exists("*elixir#indent")
   finish
-endif
+end
+let b:did_indent = 1
 
 let s:cpo_save = &cpo
 set cpo&vim
 
-let s:no_colon_before        = ':\@<!'
-let s:no_colon_after         = ':\@!'
-let s:symbols_end            = '\]\|}\|)'
-let s:symbols_start          = '\[\|{\|('
-let s:arrow                  = '^.*->$'
-let s:skip_syntax            = '\%(Comment\|String\)$'
-let s:block_skip             = "synIDattr(synID(line('.'),col('.'),1),'name') =~? '".s:skip_syntax."'"
-let s:block_start            = '\<\%(do\|fn\)\>'
-let s:block_middle           = 'else\|match\|elsif\|catch\|after\|rescue'
-let s:block_end              = 'end'
-let s:starts_with_pipeline   = '^\s*|>.*$'
-let s:ending_with_assignment = '=\s*$'
+function! elixir#indent()
+  " initiates the `old_ind` dictionary
+  let b:old_ind = get(b:, 'old_ind', {})
+  " initiates the `line` dictionary
+  let line = s:build_line(v:lnum)
 
-let s:indent_keywords   = '\<'.s:no_colon_before.'\%('.s:block_start.'\|'.s:block_middle.'\)$'.'\|'.s:arrow
-let s:deindent_keywords = '^\s*\<\%('.s:block_end.'\|'.s:block_middle.'\)\>'.'\|'.s:arrow
-
-let s:pair_start  = '\<\%('.s:no_colon_before.s:block_start.'\)\>'.s:no_colon_after
-let s:pair_middle = '\<\%('.s:block_middle.'\)\>'.s:no_colon_after.'\zs'
-let s:pair_end    = '\<\%('.s:no_colon_before.s:block_end.'\)\>\zs'
-
-let s:inside_block = 0
-
-function! GetElixirIndent()
-  let lnum = prevnonblank(v:lnum - 1)
-
-  " At the start of the file use zero indent.
-  if lnum == 0
+  if s:is_beginning_of_file(line)
+    " Reset `old_ind` dictionary at the beginning of the file
+    let b:old_ind = {}
+    " At the start of the file use zero indent.
     return 0
-  endif
-
-  let opened_symbol = 0
-  let current_line  = getline(v:lnum)
-  let last_line     = getline(lnum)
-  let ind           = indent(lnum)
-
-  " TODO: Remove these 2 lines
-  " I don't know why, but for the test on spec/indent/lists_spec.rb:24.
-  " Vim is making some mess on parsing the syntax of 'end', it is being
-  " recognized as 'elixirString' when should be recognized as 'elixirBlock'.
-  " This forces vim to sync the syntax.
-  call synID(v:lnum, 1, 1)
-  syntax sync fromstart
-
-  if synIDattr(synID(v:lnum, 1, 1), "name") !~ s:skip_syntax
-
-    if last_line !~ s:arrow
-      let split_line = split(last_line, '\zs')
-      let opened_symbol += count(split_line, '(') - count(split_line, ')')
-      let opened_symbol += count(split_line, '[') - count(split_line, ']')
-      let opened_symbol += count(split_line, '{') - count(split_line, '}')
-    end
-
-    " if start symbol is followed by a character, indent based on the
-    " whitespace after the symbol, otherwise use the default shiftwidth
-    if last_line =~ '\('.s:symbols_start.'\).'
-      let opened_prefix = matchlist(last_line, '\('.s:symbols_start.'\)\s*')[0]
-      let ind += (opened_symbol * strlen(opened_prefix))
-    else
-      let ind += (opened_symbol * &sw)
-    endif
-
-    if last_line =~ '^\s*\('.s:symbols_end.'\)' || last_line =~ s:indent_keywords
-      let ind += &sw
-    endif
-
-    if current_line =~ '^\s*\('.s:symbols_end.'\)'
-      let ind -= &sw
-    endif
-
-    if last_line =~ s:ending_with_assignment && opened_symbol == 0
-      let b:old_ind = indent(lnum)
-      let ind += &sw
-    end
-
-    " if line starts with pipeline
-    " and last line ends with a pipeline,
-    " align them
-    if last_line =~ '|>.*$' &&
-          \ current_line =~ s:starts_with_pipeline
-      let ind = float2nr(match(last_line, '|>') / &sw) * &sw
-
-    " if line starts with pipeline
-    " and last line is an attribution
-    " indents pipeline in same level as attribution
-    elseif current_line =~ s:starts_with_pipeline &&
-          \ last_line =~ '^[^=]\+=.\+$'
-
-      if !exists('b:old_ind') || b:old_ind == 0
-        let b:old_ind = indent(lnum)
-      end
-      let ind = float2nr(matchend(last_line, '=\s*[^ ]') / &sw) * &sw
-    endif
-
-    " if last line starts with pipeline
-    " and current line doesn't start with pipeline
-    " returns the indentation before the pipeline
-    if last_line =~ s:starts_with_pipeline &&
-          \ current_line !~ s:starts_with_pipeline
-      let ind = b:old_ind
-    endif
-
-    if current_line =~ s:deindent_keywords
-      let bslnum = searchpair(
-            \ s:pair_start,
-            \ s:pair_middle,
-            \ s:pair_end,
-            \ 'nbW',
-            \ s:block_skip
-            \ )
-
-      let ind = indent(bslnum)
-    endif
-
-    " indent case statements '->'
-    if current_line =~ s:arrow
-      let ind += &sw
-    endif
-  endif
+  elseif !s:is_indentable_line(line)
+    " Keep last line indentation if the current line does not have an
+    " indentable syntax
+    return indent(line.last_non_blank.num)
+  else
+    " Calculates the indenation level based on the rules
+    " All the rules are defined in `autoload/elixir/indent.vim`
+    let ind = indent(line.last_non_blank.num)
+    call s:debug('>>> line = ' . string(line.current))
+    call s:debug('>>> ind = ' . ind)
+    let ind = s:indent('deindent_case_arrow', ind, line)
+    let ind = s:indent('indent_parenthesis', ind, line)
+    let ind = s:indent('indent_square_brackets', ind, line)
+    let ind = s:indent('indent_brackets', ind, line)
+    let ind = s:indent('deindent_opened_symbols', ind, line)
+    let ind = s:indent('indent_pipeline_assignment', ind, line)
+    let ind = s:indent('indent_pipeline_continuation', ind, line)
+    let ind = s:indent('indent_after_pipeline', ind, line)
+    let ind = s:indent('indent_assignment', ind, line)
+    let ind = s:indent('indent_ending_symbols', ind, line)
+    let ind = s:indent('indent_keywords', ind, line)
+    let ind = s:indent('deindent_keywords', ind, line)
+    let ind = s:indent('deindent_ending_symbols', ind, line)
+    let ind = s:indent('indent_case_arrow', ind, line)
+    let ind = s:indent('indent_ecto_queries', ind, line)
+    call s:debug('<<< final = ' . ind)
+    return ind
+  end
+endfunction
 
+function s:indent(rule, ind, line)
+  let Fn = function('elixir#indent#'.a:rule)
+  let ind = Fn(a:ind, a:line)
+  call s:debug(a:rule . ' = ' . ind)
   return ind
 endfunction
 
+function s:debug(message)
+  if get(g:, 'elixir_indent_debug', 0)
+    echom a:message
+  end
+endfunction
+
+function! s:is_beginning_of_file(line)
+  return a:line.last_non_blank.num == 0
+endfunction
+
+function! s:is_indentable_line(line)
+  return elixir#util#is_indentable_at(a:line.current.num, 1)
+endfunction
+
+function! s:build_line(line)
+  let line = { 'current': {}, 'last': {}, 'last_non_blank': {} }
+  let line.current = s:new_line(a:line)
+  let line.last = s:new_line(line.current.num - 1)
+  let line.last_non_blank = s:new_line(prevnonblank(line.current.num - 1))
+
+  return line
+endfunction
+
+function! s:new_line(num)
+  return {
+        \ "num": a:num,
+        \ "text": getline(a:num)
+        \ }
+endfunction
+
 let &cpo = s:cpo_save
 unlet s:cpo_save
 

indent/ember-script.vim

@@ -1,11 +1,11 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'emberscript') == -1
   
 " Language:    ember-script
-" Maintainer:  heartsentwined <heartsentwined@cogito-lab.com>
-" URL:         http://github.com/heartsentwined/vim-ember-script
-" Version:     1.0.1
-" Last Change: 2013 Apr 17
-" License:     GPL-3.0
+" Maintainer:  Yulij Andreevich Lesov <yalesov@gmail.com>>
+" URL:         http://github.com/yalesov/vim-ember-script
+" Version:     1.0.4
+" Last Change: 2016 Jul 6
+" License:     ISC
 
 if exists('b:did_indent')
   finish

indent/emblem.vim

@@ -1,10 +1,10 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'emblem') == -1
   
 " Language:    emblem
-" Maintainer:  heartsentwined <heartsentwined@cogito-lab.com>
-" URL:         http://github.com/heartsentwined/vim-emblem
-" Version:     1.2.0
-" Last Change: 2013 Apr 22
-" License:     GPL-3.0
+" Maintainer:  Yulij Andreevich Lesov <yalesov@gmail.com>
+" URL:         http://github.com/yalesov/vim-emblem
+" Version:     2.0.1
+" Last Change: 2016 Jul 6
+" License:     ISC
 
 endif

indent/erlang.vim

@@ -6,9 +6,9 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'erlang') == -1
 " Contributors: Edwin Fine <efine145_nospam01 at usa dot net>
 "               Pawel 'kTT' Salata <rockplayer.pl@gmail.com>
 "               Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
-" Last Update:  2013-Jul-21
+" Last Update:  2017-Feb-28
 " License:      Vim license
-" URL:          https://github.com/hcs42/vim-erlang
+" URL:          https://github.com/vim-erlang/vim-erlang-runtime
 
 " Note About Usage:
 "   This indentation script works best with the Erlang syntax file created by
@@ -528,7 +528,9 @@ endfunction
 "       ok.          % IsLineAtomContinuation = false
 function! s:IsLineAtomContinuation(lnum)
   if has('syntax_items')
-    return synIDattr(synID(a:lnum, 1, 0), 'name') =~# '^erlangQuotedAtom'
+    let syn_name = synIDattr(synID(a:lnum, 1, 0), 'name')
+    return syn_name =~# '^erlangQuotedAtom' ||
+         \ syn_name =~# '^erlangQuotedRecord'
   else
     return 0
   endif
@@ -682,7 +684,7 @@ function! s:BeginningOfClauseFound(stack, token, stored_vcol, lnum, i)
     call s:Pop(a:stack)
     if empty(a:stack)
       call s:Log('    Stack is ["when"], so LTI is in a guard -> return')
-      return [1, a:stored_vcol + &sw + 2]
+      return [1, a:stored_vcol + shiftwidth() + 2]
     else
       return [1, s:UnexpectedToken(a:token, a:stack)]
     endif
@@ -691,7 +693,7 @@ function! s:BeginningOfClauseFound(stack, token, stored_vcol, lnum, i)
     call s:Pop(a:stack)
     if empty(a:stack)
       call s:Log('    Stack is ["->"], so LTI is in function body -> return')
-      return [1, a:stored_vcol + &sw]
+      return [1, a:stored_vcol + shiftwidth()]
     elseif a:stack[0] ==# ';'
       call s:Pop(a:stack)
 
@@ -843,7 +845,7 @@ function! s:ErlangCalcIndent2(lnum, stack)
 
       elseif token ==# 'begin'
         let [ret, res] = s:BeginElementFound(stack, token, curr_vcol,
-                                            \stored_vcol, 'end', &sw)
+                                            \stored_vcol, 'end', shiftwidth())
         if ret | return res | endif
 
       " case EXPR of BRANCHES end
@@ -894,11 +896,11 @@ function! s:ErlangCalcIndent2(lnum, stack)
         elseif stack == ['->']
           call s:Log('    LTI is in a branch after ' .
                     \'"of/receive/after/if/catch" -> return')
-          return stored_vcol + &sw
+          return stored_vcol + shiftwidth()
         elseif stack == ['when']
           call s:Log('    LTI is in a guard after ' .
                     \'"of/receive/after/if/catch" -> return')
-          return stored_vcol + &sw
+          return stored_vcol + shiftwidth()
         else
           return s:UnexpectedToken(token, stack)
         endif
@@ -934,7 +936,7 @@ function! s:ErlangCalcIndent2(lnum, stack)
           if empty(stack)
             call s:Log('    LTI is in a condition; matching ' .
                       \'"case/if/try/receive" found')
-            let stored_vcol = curr_vcol + &sw
+            let stored_vcol = curr_vcol + shiftwidth()
           elseif stack[0] ==# 'align_to_begin_element'
             call s:Pop(stack)
             let stored_vcol = curr_vcol
@@ -943,23 +945,23 @@ function! s:ErlangCalcIndent2(lnum, stack)
                       \'"case/if/try/receive" found')
             call s:Pop(stack)
             call s:Pop(stack)
-            let stored_vcol = curr_vcol + &sw
+            let stored_vcol = curr_vcol + shiftwidth()
           elseif stack[0] ==# '->'
             call s:Log('    LTI is in a branch; matching ' .
                       \'"case/if/try/receive" found')
             call s:Pop(stack)
-            let stored_vcol = curr_vcol + 2 * &sw
+            let stored_vcol = curr_vcol + 2 * shiftwidth()
           elseif stack[0] ==# 'when'
             call s:Log('    LTI is in a guard; matching ' .
                       \'"case/if/try/receive" found')
             call s:Pop(stack)
-            let stored_vcol = curr_vcol + 2 * &sw + 2
+            let stored_vcol = curr_vcol + 2 * shiftwidth() + 2
           endif
 
         endif
 
         let [ret, res] = s:BeginElementFound(stack, token, curr_vcol,
-                                            \stored_vcol, 'end', &sw)
+                                            \stored_vcol, 'end', shiftwidth())
         if ret | return res | endif
 
       elseif token ==# 'fun'
@@ -985,7 +987,7 @@ function! s:ErlangCalcIndent2(lnum, stack)
           " stack = ['when']  =>  LTI is in a guard
           if empty(stack)
             call s:Log('    LTI is in a condition; matching "fun" found')
-            let stored_vcol = curr_vcol + &sw
+            let stored_vcol = curr_vcol + shiftwidth()
           elseif len(stack) > 1 && stack[0] ==# '->' && stack[1] ==# ';'
             call s:Log('    LTI is in a condition; matching "fun" found')
             call s:Pop(stack)
@@ -993,15 +995,15 @@ function! s:ErlangCalcIndent2(lnum, stack)
           elseif stack[0] ==# '->'
             call s:Log('    LTI is in a branch; matching "fun" found')
             call s:Pop(stack)
-            let stored_vcol = curr_vcol + 2 * &sw
+            let stored_vcol = curr_vcol + 2 * shiftwidth()
           elseif stack[0] ==# 'when'
             call s:Log('    LTI is in a guard; matching "fun" found')
             call s:Pop(stack)
-            let stored_vcol = curr_vcol + 2 * &sw + 2
+            let stored_vcol = curr_vcol + 2 * shiftwidth() + 2
           endif
 
           let [ret, res] = s:BeginElementFound(stack, token, curr_vcol,
-                                              \stored_vcol, 'end', &sw)
+                                              \stored_vcol, 'end', shiftwidth())
           if ret | return res | endif
         else
           " Pass: we have a function reference (e.g. "fun f/0")
@@ -1275,7 +1277,7 @@ function! s:ErlangCalcIndent2(lnum, stack)
             "   when A,
             "        LTI
             let [ret, res] = s:BeginElementFoundIfEmpty(stack, token, curr_vcol,
-                                                       \stored_vcol, &sw)
+                                                       \stored_vcol, shiftwidth())
             if ret | return res | endif
           else
             " Example:
@@ -1307,7 +1309,7 @@ function! s:ErlangCalcIndent2(lnum, stack)
           " If LTI is between an 'after' and the corresponding
           " 'end', then let's return
           let [ret, res] = s:BeginElementFoundIfEmpty(stack, token, curr_vcol,
-                                                     \stored_vcol, &sw)
+                                                     \stored_vcol, shiftwidth())
           if ret | return res | endif
         endif
 

indent/eruby.vim

@@ -43,6 +43,10 @@ if exists("*GetErubyIndent")
   finish
 endif
 
+" this file uses line continuations
+let s:cpo_sav = &cpo
+set cpo&vim
+
 function! GetErubyIndent(...)
   " The value of a single shift-width
   if exists('*shiftwidth')
@@ -93,6 +97,7 @@ function! GetErubyIndent(...)
     let ind = ind + sw
   endif
   if line !~# '^\s*<%' && line =~# '%>\s*$' && line !~# '^\s*end\>'
+	\ && synID(v:lnum, match(cline, '\S') + 1, 1) != hlID('htmlEndTag')
     let ind = ind - sw
   endif
   if cline =~# '^\s*[-=]\=%>\s*$'
@@ -101,6 +106,9 @@ function! GetErubyIndent(...)
   return ind
 endfunction
 
+let &cpo = s:cpo_sav
+unlet! s:cpo_sav
+
 " vim:set sw=2 sts=2 ts=8 noet:
 
 endif

indent/gohtmltmpl.vim

@@ -32,13 +32,13 @@ function! GetGoHTMLTmplIndent(lnum)
 
   " If need to indent based on last line
   let last_line = getline(a:lnum-1)
-  if last_line =~ '^\s*{{\s*\%(if\|else\|range\|with\|define\|block\).*}}'
+  if last_line =~ '^\s*{{-\=\s*\%(if\|else\|range\|with\|define\|block\).*}}'
     let ind += sw
   endif
 
   " End of FuncMap block
   let current_line = getline(a:lnum)
-  if current_line =~ '^\s*{{\s*\%(else\|end\).*}}'
+  if current_line =~ '^\s*{{-\=\s*\%(else\|end\).*}}'
     let ind -= sw
   endif
 

indent/haskell.vim

@@ -13,6 +13,14 @@ if exists('b:did_indent')
   finish
 endif
 
+if !exists('g:haskell_indent_disable')
+    let g:haskell_indent_disable = 0
+endif
+
+if g:haskell_indent_disable != 0
+  finish
+endif
+
 let b:did_indent = 1
 
 if !exists('g:haskell_indent_if')
@@ -60,18 +68,35 @@ if !exists('g:haskell_indent_guard')
 endif
 
 setlocal indentexpr=GetHaskellIndent()
-setlocal indentkeys=0{,0},0(,0),0[,0],!^F,o,O,0\=,0=where,0=let,0=deriving,0\,,<space>
+setlocal indentkeys=0},0),0],!^F,o,O,0\=,0=where,0=let,0=deriving,<space>
 
 function! s:isInBlock(hlstack)
-  return index(a:hlstack, 'haskellParens') > -1 || index(a:hlstack, 'haskellBrackets') > -1 || index(a:hlstack, 'haskellBlock') > -1
+  return index(a:hlstack, 'haskellDelimiter') > -1 || index(a:hlstack, 'haskellParens') > -1 || index(a:hlstack, 'haskellBrackets') > -1 || index(a:hlstack, 'haskellBlock') > -1 || index(a:hlstack, 'haskellBlockComment') > -1 || index(a:hlstack, 'haskellPragma') > -1
+endfunction
+
+function! s:stripComment(line)
+  if a:line =~ '^\s*--\(-*\s\+\|$\)'
+    return ''
+  else
+    let l:stripped = split(a:line, '-- ')
+    if len(l:stripped) > 1
+      return substitute(l:stripped[0], '\s*$', '', '')
+    else
+      return a:line
+    endif
+  endif
+endfunction
+
+function! s:isSYN(grp, line, col)
+  return index(s:getHLStack(a:line, a:col), a:grp) != -1
 endfunction
 
 function! s:getNesting(hlstack)
-  return filter(a:hlstack, 'v:val == "haskellBlock" || v:val == "haskellBrackets" || v:val == "haskellParens"')
+  return filter(a:hlstack, 'v:val == "haskellBlock" || v:val == "haskellBrackets" || v:val == "haskellParens" || v:val == "haskellBlockComment" || v:val == "haskellPragma" ')
 endfunction
 
-function! s:getHLStack()
-  return map(synstack(line('.'), col('.')), 'synIDattr(v:val, "name")')
+function! s:getHLStack(line, col)
+  return map(synstack(a:line, a:col), 'synIDattr(v:val, "name")')
 endfunction
 
 " indent matching character
@@ -110,14 +135,14 @@ function! s:indentGuard(pos, prevline)
 endfunction
 
 function! GetHaskellIndent()
-  let l:hlstack = s:getHLStack()
+  let l:hlstack = s:getHLStack(line('.'), col('.'))
 
   " do not indent in strings and quasiquotes
   if index(l:hlstack, 'haskellQuasiQuote') > -1 || index(l:hlstack, 'haskellBlockComment') > -1
     return -1
   endif
 
-  let l:prevline = getline(v:lnum - 1)
+  let l:prevline = s:stripComment(getline(v:lnum - 1))
   let l:line     = getline(v:lnum)
 
   " indent multiline strings
@@ -134,9 +159,43 @@ function! GetHaskellIndent()
     return 0
   endif
 
-  " comment indentation
-  if l:prevline =~ '^\s*--'
-    return match(l:prevline, '\S')
+  " " comment indentation
+  " if l:line =~ '^\s*--'
+  "   let l:s = match(l:prevline, '-- ')
+  "   if l:s > -1
+  " endif
+  " " if l:prevline =~ '^\s*--'
+  " "   return match(l:prevline, '\S')
+  " " endif
+
+  "   { foo :: Int
+  " >>,
+  "
+  "   |
+  "   ...
+  " >>,
+  if l:line =~ '^\s*,'
+    if s:isInBlock(s:getHLStack(line('.'), col('.')))
+      normal! 0
+      call search(',', 'cW')
+      let l:n = s:getNesting(s:getHLStack(line('.'), col('.')))
+      call search('[([{]', 'bW')
+      let l:cl = line('.')
+      let l:cc = col('.')
+
+      while l:n != s:getNesting(s:getHLStack(l:cl, l:cc)) || s:isSYN('haskellString', l:cl, l:cc) || s:isSYN('haskellChar', l:cl, l:cc)
+        call search('[([{]', 'bW')
+        let l:cl = line('.')
+        let l:cc = col('.')
+      endwhile
+
+      return l:cc - 1
+    else
+      let l:s = s:indentGuard(match(l:line, ','), l:prevline)
+      if l:s > -1
+        return l:s
+      end
+    endif
   endif
 
   " operator at end of previous line
@@ -166,11 +225,20 @@ function! GetHaskellIndent()
   " >>>>y = 2
   if l:prevline =~ '\C\<let\>\s\+.\+$'
     if l:line =~ '\C^\s*\<let\>'
-      return match(l:prevline, '\C\<let\>')
+      let l:s = match(l:prevline, '\C\<let\>')
+      if s:isSYN('haskellLet', v:lnum - 1, l:s + 1)
+        return l:s
+      endif
     elseif l:line =~ '\C^\s*\<in\>'
-      return match(l:prevline, '\C\<let\>') + g:haskell_indent_in
+      let l:s = match(l:prevline, '\C\<let\>')
+      if s:isSYN('haskellLet', v:lnum - 1, l:s + 1)
+        return l:s + g:haskell_indent_in
+      endif
     else
-      return match(l:prevline, '\C\<let\>') + g:haskell_indent_let
+      let l:s = match(l:prevline, '\C\<let\>')
+      if s:isSYN('haskellLet', v:lnum - 1, l:s + 1)
+        return l:s + g:haskell_indent_let
+      endif
     endif
   endif
 
@@ -199,26 +267,36 @@ function! GetHaskellIndent()
     return match(l:prevline, '\S') + &shiftwidth
   endif
 
+  " do foo
+  " >>>bar
+  if l:prevline =~ '\C\<do\>\s\+\S\+.*$'
+    let l:s = match(l:prevline, '\C\<do\>')
+    if s:isSYN('haskellKeyword', v:lnum - 1, l:s + 1)
+      return l:s + g:haskell_indent_do
+    endif
+  endif
+
+  " case foo of
+  " >>bar -> quux
+  if l:prevline =~ '\C\<case\>.\+\<of\>\s*$'
+    if exists('g:haskell_indent_case_alternative') && g:haskell_indent_case_alternative
+      return match(l:prevline, '\S') + &shiftwidth
+    else
+      return match(l:prevline, '\C\<case\>') + g:haskell_indent_case
+    endif
+  endif
+
   "" where foo
   "" >>>>>>bar
   if l:prevline =~ '\C\<where\>\s\+\S\+.*$'
     if  l:line =~ '^\s*[=-]>\s' && l:prevline =~ ' :: '
       return match(l:prevline, ':: ')
     else
-      return match(l:prevline, '\C\<where\>') + g:haskell_indent_where
-  endif
-  endif
-
-  " do foo
-  " >>>bar
-  if l:prevline =~ '\C\<do\>\s\+\S\+.*$'
-    return match(l:prevline, '\C\<do\>') + g:haskell_indent_do
-  endif
-
-  " case foo of
-  " >>bar -> quux
-  if l:prevline =~ '\C\<case\>.\+\<of\>\s*$'
-    return match(l:prevline, '\C\<case\>') + g:haskell_indent_case
+      let l:s = match(l:prevline, '\C\<where\>')
+      if s:isSYN('haskellWhere', v:lnum - 1, l:s + 1)
+        return l:s + g:haskell_indent_where
+      endif
+    endif
   endif
 
   " newtype Foo = Foo
@@ -259,8 +337,8 @@ function! GetHaskellIndent()
 
       while v:lnum != l:c
         " fun decl
-        let l:s = match(l:l, l:m)
-        if l:s >= 0
+        if l:l =~ ('^\s*' . l:m . '\(\s*::\|\n\s\+::\)')
+          let l:s = match(l:l, l:m)
           if match(l:l, '\C^\s*\<default\>') > -1
             return l:s - 8
           else
@@ -316,7 +394,7 @@ function! GetHaskellIndent()
 
   " foo
   " >>{
-  if l:line =~ '^\s*{' && l:prevline !~ '^{'
+  if l:line =~ '^\s*{ '
     let l:s = match(l:prevline, '\S')
     if l:s >= 0
       return l:s + &shiftwidth
@@ -362,32 +440,6 @@ function! GetHaskellIndent()
     endif
   endif
 
-  "   { foo :: Int
-  " >>,
-  "
-  "   |
-  "   ...
-  " >>,
-  if l:line =~ '^\s*,'
-    if s:isInBlock(l:hlstack)
-      normal! 0
-      call search(',', 'cW')
-      let l:n = s:getNesting(s:getHLStack())
-      call search('[(\[{]', 'bW')
-
-      while l:n != s:getNesting(s:getHLStack())
-        call search('[(\[{]', 'bW')
-      endwhile
-
-      return col('.') - 1
-    else
-      let l:s = s:indentGuard(match(l:line, ','), l:prevline)
-      if l:s > -1
-        return l:s
-      end
-    endif
-  endif
-
   "   |
   "   ...
   " >>|
@@ -423,22 +475,8 @@ function! GetHaskellIndent()
   if l:line =~ '^\s*]'
     return s:indentMatching(']')
   endif
-  "
-  " indent import
-  if l:line =~ '\C^\s*import'
-    return 0
-  endif
 
-  " do not reindent indented lines
-  if match(l:prevline, '\S') < match(l:line, '\S')
-    return -1
-  endif
-
-  if l:line !~ '^\s*[=-]>\s' && l:line =~ '^\s*[!#$%&*+./<>?@\\^|~-]\+'
-    return -1
-  endif
-
-  return match(l:prevline, '\S')
+  return -1
 endfunction
 
 endif

indent/html.vim

@@ -42,6 +42,7 @@ setlocal indentkeys=o,O,*<Return>,<>>,{,},!^F
 
 
 let s:tags = []
+let s:no_tags = []
 
 " [-- <ELEMENT ? - - ...> --]
 call add(s:tags, 'a')
@@ -165,6 +166,44 @@ call add(s:tags, 'text')
 call add(s:tags, 'textPath')
 call add(s:tags, 'tref')
 call add(s:tags, 'tspan')
+" Common self closing SVG elements
+call add(s:no_tags, 'animate')
+call add(s:no_tags, 'animateTransform')
+call add(s:no_tags, 'circle')
+call add(s:no_tags, 'ellipse')
+call add(s:no_tags, 'feBlend')
+call add(s:no_tags, 'feColorMatrix')
+call add(s:no_tags, 'feComposite')
+call add(s:no_tags, 'feConvolveMatrix')
+call add(s:no_tags, 'feDisplacementMap')
+call add(s:no_tags, 'feFlood')
+call add(s:no_tags, 'feFuncR')
+call add(s:no_tags, 'feFuncG')
+call add(s:no_tags, 'feFuncB')
+call add(s:no_tags, 'feFuncA')
+call add(s:no_tags, 'feGaussianBlur')
+call add(s:no_tags, 'feImage')
+call add(s:no_tags, 'feMergeNode')
+call add(s:no_tags, 'feMorphology')
+call add(s:no_tags, 'feOffset')
+call add(s:no_tags, 'fePointLight')
+call add(s:no_tags, 'feSpotLight')
+call add(s:no_tags, 'feTile')
+call add(s:no_tags, 'feTurbulence')
+call add(s:no_tags, 'hatchpath')
+call add(s:no_tags, 'hkern')
+call add(s:no_tags, 'image')
+call add(s:no_tags, 'line')
+call add(s:no_tags, 'mpath')
+call add(s:no_tags, 'polygon')
+call add(s:no_tags, 'polyline')
+call add(s:no_tags, 'path')
+call add(s:no_tags, 'rect')
+call add(s:no_tags, 'solidColor')
+call add(s:no_tags, 'stop')
+call add(s:no_tags, 'use')
+call add(s:no_tags, 'view')
+call add(s:no_tags, 'vkern')
 
 call add(s:tags, 'html')
 call add(s:tags, 'head')
@@ -177,8 +216,6 @@ call add(s:tags, 'tr')
 call add(s:tags, 'th')
 call add(s:tags, 'td')
 
-let s:no_tags = []
-
 call add(s:no_tags, 'base')
 call add(s:no_tags, 'link')
 call add(s:no_tags, 'meta')

indent/javascript.vim

@@ -2,27 +2,29 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'javascript') ==
   
 " Vim indent file
 " Language: Javascript
-" Acknowledgement: Based off of vim-ruby maintained by Nikolai Weibull http://vim-ruby.rubyforge.org
-
-" 0. Initialization {{{1
-" =================
+" Maintainer: Chris Paul ( https://github.com/bounceme )
+" URL: https://github.com/pangloss/vim-javascript
+" Last Change: March 9, 2017
 
 " Only load this indent file when no other was loaded.
-if exists("b:did_indent")
+if exists('b:did_indent')
   finish
 endif
 let b:did_indent = 1
 
-setlocal nosmartindent
-
 " Now, set up our indentation expression and keys that trigger it.
 setlocal indentexpr=GetJavascriptIndent()
-setlocal formatexpr=Fixedgq(v:lnum,v:count)
-setlocal indentkeys=0{,0},0),0],0\,*<Return>,:,!^F,o,O,e
-setlocal cinoptions+=j1,J1,c1
+setlocal autoindent nolisp nosmartindent
+setlocal indentkeys+=0],0)
+" Testable with something like:
+" vim  -eNs "+filetype plugin indent on" "+syntax on" "+set ft=javascript" \
+"       "+norm! gg=G" '+%print' '+:q!' testfile.js \
+"       | diff -uBZ testfile.js -
+
+let b:undo_indent = 'setlocal indentexpr< smartindent< autoindent< indentkeys<'
 
 " Only define the function once.
-if exists("*GetJavascriptIndent")
+if exists('*GetJavascriptIndent')
   finish
 endif
 
@@ -31,536 +33,349 @@ set cpo&vim
 
 " Get shiftwidth value
 if exists('*shiftwidth')
-  func s:sw()
+  function s:sw()
     return shiftwidth()
-  endfunc
+  endfunction
 else
-  func s:sw()
-    return &sw
-  endfunc
+  function s:sw()
+    return &l:shiftwidth == 0 ? &l:tabstop : &l:shiftwidth
+  endfunction
 endif
 
-" 1. Variables {{{1
-" ============
+" Performance for forwards search(): start search at pos rather than masking
+" matches before pos.
+let s:z = has('patch-7.4.984') ? 'z' : ''
+
+" searchpair() wrapper
+if has('reltime')
+  function s:GetPair(start,end,flags,skip,time,...)
+    return searchpair('\m'.a:start,'','\m'.a:end,a:flags,a:skip,max([prevnonblank(v:lnum) - 2000,0] + a:000),a:time)
+  endfunction
+else
+  function s:GetPair(start,end,flags,skip,...)
+    return searchpair('\m'.a:start,'','\m'.a:end,a:flags,a:skip,max([prevnonblank(v:lnum) - 1000,get(a:000,1)]))
+  endfunction
+endif
 
-let s:line_pre = '^\s*\%(\/\*.*\*\/\s*\)*'
-let s:js_keywords = s:line_pre . '\%(break\|import\|export\|catch\|const\|continue\|debugger\|delete\|do\|else\|finally\|for\|function\|if\|in\|instanceof\|let\|new\|return\|switch\|this\|throw\|try\|typeof\|var\|void\|while\|with\)\>\C'
-let s:expr_case = s:line_pre . '\%(\%(case\>.*\)\|default\)\s*:\C'
 " Regex of syntax group names that are or delimit string or are comments.
-let s:syng_strcom = '\%(string\|regex\|special\|doc\|comment\|template\)\c'
-
-" Regex of syntax group names that are strings.
-let s:syng_string = 'regex\c'
-
-" Regex of syntax group names that are strings or documentation.
-let s:syng_comment = '\%(comment\|doc\)\c'
-
+let s:syng_strcom = 'string\|comment\|regex\|special\|doc\|template\%(braces\)\@!'
+let s:syng_str = 'string\|template\|special'
+let s:syng_com = 'comment\|doc'
 " Expression used to check whether we should skip a match with searchpair().
-let s:skip_expr = "synIDattr(synID(line('.'),col('.'),1),'name') =~ '".s:syng_strcom."'"
+let s:skip_expr = "synIDattr(synID(line('.'),col('.'),0),'name') =~? '".s:syng_strcom."'"
 
-func s:lookForParens(start,end,flags,stop)
-  try 
-    return searchpair(a:start,'',a:end,a:flags,s:skip_expr,a:stop,300)
-  catch /E118/
-    return searchpair(a:start,'',a:end,a:flags,0,a:stop)
-  endtry
-endfunc
+function s:parse_cino(f) abort
+  return float2nr(eval(substitute(substitute(join(split(
+        \ matchstr(&cino,'\C.*'.a:f.'\zs[^,]*'), 's',1), '*'.s:W)
+        \ , '^-\=\zs\*','',''), '^-\=\zs\.','0.','')))
+endfunction
 
-let s:line_term = '\s*\%(\%(\/\/.*\)\=\|\%(\/\*.*\*\/\s*\)*\)$'
+function s:skip_func()
+  if getline('.') =~ '\%<'.col('.').'c\/.\{-}\/\|\%>'.col('.').'c[''"]\|\\$'
+    return eval(s:skip_expr)
+  elseif s:checkIn || search('\m`\|\${\|\*\/','nW'.s:z,s:looksyn)
+    let s:checkIn = eval(s:skip_expr)
+  endif
+  let s:looksyn = line('.')
+  return s:checkIn
+endfunction
 
-" Regex that defines continuation lines, not including (, {, or [.
-let s:continuation_regex = '\%([*.?:]\|+\@<!+\|-\@<!-\|\*\@<!\/\|=\|||\|&&\)' . s:line_term
+function s:alternatePair(stop)
+  let pos = getpos('.')[1:2]
+  let pat = '[][(){};]'
+  while search('\m'.pat,'bW',a:stop)
+    if s:skip_func() | continue | endif
+    let idx = stridx('])};',s:looking_at())
+    if idx is 3 | let pat = '[{}()]' | continue | endif
+    if idx + 1
+      if s:GetPair(['\[','(','{'][idx], '])}'[idx],'bW','s:skip_func()',2000,a:stop) <= 0
+        break
+      endif
+    else
+      return
+    endif
+  endwhile
+  call call('cursor',pos)
+endfunction
 
-let s:one_line_scope_regex = '\%(\<else\>\|=>\)\C' . s:line_term
+function s:save_pos(f,...)
+  let l:pos = getpos('.')[1:2]
+  let ret = call(a:f,a:000)
+  call call('cursor',l:pos)
+  return ret
+endfunction
 
-function s:Onescope(lnum)
-  if getline(a:lnum) =~ s:one_line_scope_regex
+function s:syn_at(l,c)
+  return synIDattr(synID(a:l,a:c,0),'name')
+endfunction
+
+function s:looking_at()
+  return getline('.')[col('.')-1]
+endfunction
+
+function s:token()
+  return s:looking_at() =~ '\k' ? expand('<cword>') : s:looking_at()
+endfunction
+
+function s:previous_token()
+  let l:pos = getpos('.')[1:2]
+  if search('\m\k\{1,}\|\S','ebW')
+    if (getline('.')[col('.')-2:col('.')-1] == '*/' || line('.') != l:pos[0] &&
+          \ getline('.') =~ '\%<'.col('.').'c\/\/') && s:syn_at(line('.'),col('.')) =~? s:syng_com
+      while search('\m\S\ze\_s*\/[/*]','bW')
+        if s:syn_at(line('.'),col('.')) !~? s:syng_com
+          return s:token()
+        endif
+      endwhile
+    else
+      return s:token()
+    endif
+  endif
+  call call('cursor',l:pos)
+  return ''
+endfunction
+
+function s:expr_col()
+  if getline('.')[col('.')-2] == ':'
     return 1
-  end
-  let mypos = col('.')
-  call cursor(a:lnum, 1)
-  if search('.*\zs\<\%(while\|for\|if\)\>\s*(\C', 'ce', a:lnum) > 0 &&
-        \ s:lookForParens('(', ')', 'W', a:lnum) > 0 &&
-        \ col('.') == strlen(s:RemoveTrailingComments(getline(a:lnum)))
-    call cursor(a:lnum, mypos)
+  endif
+  let bal = 0
+  while search('\m[{}?:;]','bW')
+    if eval(s:skip_expr) | continue | endif
+    " switch (looking_at())
+    exe {   '}': "if s:GetPair('{','}','bW',s:skip_expr,200) <= 0 | return | endif",
+          \ ';': "return",
+          \ '{': "return getpos('.')[1:2] != b:js_cache[1:] && !s:IsBlock()",
+          \ ':': "let bal -= getline('.')[max([col('.')-2,0]):col('.')] !~ '::'",
+          \ '?': "let bal += 1 | if bal > 0 | return 1 | endif" }[s:looking_at()]
+  endwhile
+endfunction
+
+" configurable regexes that define continuation lines, not including (, {, or [.
+let s:opfirst = '^' . get(g:,'javascript_opfirst',
+      \ '\C\%([<>=,?^%|*/&]\|\([-.:+]\)\1\@!\|!=\|in\%(stanceof\)\=\>\)')
+let s:continuation = get(g:,'javascript_continuation',
+      \ '\C\%([-+<>=,.~!?/*^%|&:]\|\<\%(typeof\|new\|delete\|void\|in\|instanceof\|await\)\)') . '$'
+
+function s:continues(ln,con)
+  if !cursor(a:ln, match(' '.a:con,s:continuation))
+    let teol = s:looking_at()
+    if teol == '/'
+      return s:syn_at(line('.'),col('.')) !~? 'regex'
+    elseif teol =~ '[-+>]'
+      return getline('.')[col('.')-2] != tr(teol,'>','=')
+    elseif teol =~ '\l'
+      return s:previous_token() != '.'
+    elseif teol == ':'
+      return s:expr_col()
+    endif
     return 1
-  else
-    call cursor(a:lnum, mypos)
-    return 0
-  end
+  endif
 endfunction
 
-" Regex that defines blocks.
-let s:block_regex = '[{([]' . s:line_term
-
-let s:operator_first = s:line_pre . '\%([,:?]\|\([-/.+*]\)\%(\1\|\*\|\/\)\@!\|||\|&&\)'
-
-let s:var_stmt = s:line_pre . '\%(const\|let\|var\)\s\+\C'
-
-let s:comma_last = ',' . s:line_term
-
-" 2. Auxiliary Functions {{{1
-" ======================
-
-" Check if the character at lnum:col is inside a string, comment, or is ascii.
-function s:IsInStringOrComment(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_strcom
+" get the line of code stripped of comments and move cursor to the last
+" non-comment char.
+function s:Trim(ln)
+  let pline = substitute(getline(a:ln),'\s*$','','')
+  let l:max = max([strridx(pline,'//'), strridx(pline,'/*')])
+  while l:max != -1 && s:syn_at(a:ln, strlen(pline)) =~? s:syng_com
+    let pline = pline[: l:max]
+    let l:max = max([strridx(pline,'//'), strridx(pline,'/*')])
+    let pline = substitute(pline[:-2],'\s*$','','')
+  endwhile
+  return pline is '' || cursor(a:ln,strlen(pline)) ? pline : pline
 endfunction
 
-" Check if the character at lnum:col is inside a string.
-function s:IsInString(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_string
-endfunction
-
-" Check if the character at lnum:col is inside a multi-line comment.
-function s:IsInComment(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_comment
-endfunction
-
-" Find line above 'lnum' that isn't empty, in a comment, or in a string.
-function s:PrevNonBlankNonString(lnum)
-  let lnum = prevnonblank(a:lnum)
-  while lnum > 0
-    let line = getline(lnum)
-    let com = match(line, '\%(\/\*.*\)\@<!\*\/') + 1
-    if s:IsInComment(lnum, com)
-      call cursor(lnum, com)
-      let parlnum = search('\%(\/\/.*\)\@<!\/\*', 'nbW')
-      if parlnum > 0
-        let lnum = parlnum
-      end
-    elseif line !~ '^' . s:line_term && !s:IsInStringOrComment(lnum,1)
+" Find line above 'lnum' that isn't empty or in a comment
+function s:PrevCodeLine(lnum)
+  let [l:pos, l:n] = [getpos('.')[1:2], prevnonblank(a:lnum)]
+  while l:n
+    if getline(l:n) =~ '^\s*\/[/*]'
+      let l:n = prevnonblank(l:n-1)
+    elseif stridx(getline(l:n), '*/') + 1 && s:syn_at(l:n,1) =~? s:syng_com
+      call cursor(l:n,1)
+      keepjumps norm! [*
+      let l:n = search('\m\S','nbW')
+    else
       break
     endif
-    let lnum = prevnonblank(lnum - 1)
   endwhile
-  return lnum
+  call call('cursor',l:pos)
+  return l:n
 endfunction
 
-" Find line above 'lnum' that started the continuation 'lnum' may be part of.
-function s:GetMSL(lnum, in_one_line_scope)
-  " Start on the line we're at and use its indent.
-  let msl = a:lnum
-  let lnum = s:PrevNonBlankNonString(a:lnum - 1)
-  while lnum > 0 && !s:Match(msl,s:line_pre . '[])}]')
-    " If we have a continuation line, or we're in a string, use line as MSL.
-    " Otherwise, terminate search as we have found our MSL already.
-    let line = getline(lnum)
-    let line2 = getline(msl)
-    if ((s:Match(lnum,s:continuation_regex) || s:Match(lnum, s:comma_last)) &&
-          \ !s:Match(lnum, s:expr_case)) || s:IsInString(lnum, strlen(line))
-      let msl = lnum
-      if s:Match(lnum, s:line_pre . '[]})]') && !a:in_one_line_scope
-        call cursor(lnum,1)
-        let parlnum = s:lookForParens('(\|{\|\[', ')\|}\|\]', 'nbW', 0)
-        if parlnum > 0
-          let lnum = parlnum
-          continue
-        end
-      end
-
-    else
-
-      " Don't use lines that are part of a one line scope as msl unless the
-      " flag in_one_line_scope is set to 1
-      "
-      if a:in_one_line_scope
-        break
-      end
-      let msl_one_line = s:Onescope(lnum)
-      if msl_one_line == 0
-        break
-      endif
-    end
-    let lnum = s:PrevNonBlankNonString(lnum - 1)
-  endwhile
-  return msl
-endfunction
-
-function s:RemoveTrailingComments(content)
-  let single = '\/\/\%(.*\)\s*$'
-  let multi = '\/\*\%(.*\)\*\/\s*$'
-  return substitute(substitute(substitute(a:content, single, '', ''), multi, '', ''), '\s\+$', '', '')
-endfunction
-
-" Find if the string is inside var statement (but not the first string)
-function s:InMultiVarStatement(lnum, cont, prev)
-  let lnum = s:PrevNonBlankNonString(a:lnum - 1)
-  let cont = a:cont
-  let prev = a:prev
-
-  "  let type = synIDattr(synID(lnum, indent(lnum) + 1, 0), 'name')
-
-  " loop through previous expressions to find a var statement
-  while lnum > 0 && (s:Match(lnum, s:comma_last) ||(cont && getline(lnum) =~ s:line_pre . '[]})]') ||
-        \ s:Match(lnum,s:continuation_regex)) || (prev && (s:Match(prev, s:comma_last) ||
-        \ s:Match(prev,s:continuation_regex)))
-    " if the line is a js keyword
-    if cont
-      let cont = 0
-      call cursor(lnum,1)
-      let parlnum = s:lookForParens('(\|{\|\[', ')\|}\|\]', 'nbW', 0)
-      if parlnum > 0
-        let lnum = parlnum
-      end
-    end
-    if s:Match(lnum, s:js_keywords)
-      " check if the line is a var stmt
-      " if the line has a comma first or comma last then we can assume that we
-      " are in a multiple var statement
-      if s:Match(lnum, s:var_stmt) && (s:Match(lnum, s:comma_last)||s:Match(lnum,s:continuation_regex))
-        return lnum
-      endif
-
-      " other js keywords, not a var
-      if !s:Match(lnum, s:comma_last)||!s:Match(lnum,s:continuation_regex)
-        return 0
-      end
-    endif
-    let lnum = s:PrevNonBlankNonString(lnum - 1)
-    let prev = prev && lnum > 0 ? prev : 0
-  endwhile
-
-  " beginning of program, not a var
-  return 0
-endfunction
-
-" Check if line 'lnum' has more opening brackets than closing ones.
-function s:LineHasOpeningBrackets(lnum)
-  let open_0 = 0
-  let open_2 = 0
-  let open_4 = 0
-  let line = getline(a:lnum)
-  let pos = match(line, '[][(){}]', 0)
+" Check if line 'lnum' has a balanced amount of parentheses.
+function s:Balanced(lnum)
+  let l:open = 0
+  let l:line = getline(a:lnum)
+  let pos = match(l:line, '[][(){}]', 0)
   while pos != -1
-    if !s:IsInStringOrComment(a:lnum, pos + 1)
-      let idx = stridx('(){}[]', line[pos])
-      if idx % 2 == 0
-        let open_{idx} = open_{idx} + 1
-      else
-        let open_{idx - 1} = open_{idx - 1} - 1
+    if s:syn_at(a:lnum,pos + 1) !~? s:syng_strcom
+      let l:open += match(' ' . l:line[pos],'[[({]')
+      if l:open < 0
+        return
       endif
     endif
-    let pos = match(line, '[][(){}]', pos + 1)
+    let pos = match(l:line, (l:open ?
+          \ '['.escape(tr(l:line[pos],'({[]})',')}][{(').l:line[pos],']').']' :
+          \ '[][(){}]'), pos + 1)
   endwhile
-  return (open_0 > 0 ? 1 : (open_0 == 0 ? 0 : 2)) . (open_2 > 0 ? 1 : (open_2 == 0 ? 0 : 2)) . (open_4 > 0 ? 1 : (open_4 == 0 ? 0 : 2))
+  return !l:open
 endfunction
 
-function s:Match(lnum, regex)
-  let col = match(getline(a:lnum), a:regex) + 1
-  return col > 0 && !s:IsInStringOrComment(a:lnum, col) ? col : 0
-endfunction
-
-function s:IndentWithContinuation(lnum, ind, width)
-  " Set up variables to use and search for MSL to the previous line.
-  let p_lnum = a:lnum
-  let lnum = s:GetMSL(a:lnum, 1)
-  let line = getline(lnum)
-
-  " If the previous line wasn't a MSL and is continuation return its indent.
-  " TODO: the || s:IsInString() thing worries me a bit.
-  if p_lnum != lnum
-    if s:Match(p_lnum,s:continuation_regex)||s:IsInString(p_lnum,strlen(line))
-      return a:ind
+function s:OneScope(lnum)
+  let pline = s:Trim(a:lnum)
+  let kw = 'else do'
+  if pline[-1:] == ')' && s:GetPair('(', ')', 'bW', s:skip_expr, 100) > 0
+    if s:previous_token() =~# '^\%(await\|each\)$'
+      call s:previous_token()
+      let kw = 'for'
+    else
+      let kw = 'for if let while with'
     endif
   endif
-
-  " Set up more variables now that we know we aren't continuation bound.
-  let msl_ind = indent(lnum)
-
-  " If the previous line ended with [*+/.-=], start a continuation that
-  " indents an extra level.
-  if s:Match(lnum, s:continuation_regex)
-    if lnum == p_lnum
-      return msl_ind + a:width
-    else
-      return msl_ind
-    end
-  elseif s:InMultiVarStatement(p_lnum, 0, s:PrevNonBlankNonString(p_lnum - 1))
-    return indent(p_lnum) - s:sw()
-  endif
-
-  return a:ind
+  return pline[-2:] == '=>' || index(split(kw),s:token()) + 1 &&
+        \ s:save_pos('s:previous_token') != '.'
 endfunction
 
-function s:InOneLineScope(lnum)
-  let msl = s:GetMSL(a:lnum, 1)
-  if msl > 0 && s:Onescope(msl)
-    return msl
-  endif
-  return 0
+" returns braceless levels started by 'i' and above lines * &sw. 'num' is the
+" lineNr which encloses the entire context, 'cont' if whether line 'i' + 1 is
+" a continued expression, which could have started in a braceless context
+function s:iscontOne(i,num,cont)
+  let [l:i, l:num, bL] = [a:i, a:num + !a:num, 0]
+  let pind = a:num ? indent(l:num) + s:W : 0
+  let ind = indent(l:i) + (a:cont ? 0 : s:W)
+  while l:i >= l:num && (ind > pind || l:i == l:num)
+    if indent(l:i) < ind && s:OneScope(l:i)
+      let bL += s:W
+      let l:i = line('.')
+    elseif !a:cont || bL || ind < indent(a:i)
+      break
+    endif
+    let ind = min([ind, indent(l:i)])
+    let l:i = s:PrevCodeLine(l:i - 1)
+  endwhile
+  return bL
 endfunction
 
-function s:ExitingOneLineScope(lnum)
-  let msl = s:GetMSL(a:lnum, 1)
-  if msl > 0
-    " if the current line is in a one line scope ..
-    if s:Onescope(msl)
-      return 0
-    else
-      let prev_msl = s:GetMSL(msl - 1, 1)
-      if s:Onescope(prev_msl)
-        return prev_msl
+" https://github.com/sweet-js/sweet.js/wiki/design#give-lookbehind-to-the-reader
+function s:IsBlock()
+  if s:looking_at() == '{'
+    let l:n = line('.')
+    let char = s:previous_token()
+    if match(s:stack,'\cxml\|jsx') + 1 && s:syn_at(line('.'),col('.')-1) =~? 'xml\|jsx'
+      return char != '{'
+    elseif char =~ '\k'
+      if char ==# 'type'
+        return s:previous_token() !~# '^\%(im\|ex\)port$'
       endif
+      return index(split('return const let import export extends yield default delete var await void typeof throw case new of in instanceof')
+            \ ,char) < (line('.') != l:n) || s:save_pos('s:previous_token') == '.'
+    elseif char == '>'
+      return getline('.')[col('.')-2] == '=' || s:syn_at(line('.'),col('.')) =~? '^jsflow'
+    elseif char == ':'
+      return !s:save_pos('s:expr_col')
+    elseif char == '/'
+      return s:syn_at(line('.'),col('.')) =~? 'regex'
     endif
+    return char !~ '[=~!<*,?^%|&([]' &&
+          \ (char !~ '[-+]' || l:n != line('.') && getline('.')[col('.')-2] == char)
   endif
-  return 0
 endfunction
 
-" 3. GetJavascriptIndent Function {{{1
-" =========================
-
 function GetJavascriptIndent()
-  " 3.1. Setup {{{1
-  " ----------
-  " Set up variables for restoring position in file.  Could use v:lnum here.
-  " Avoid use of line('.')/col('.') type functions as the curpos can change
-  let vcol = col('.')
-
-  " 3.2. Work on the current line {{{1
-  " -----------------------------
-
-  let ind = -1
+  let b:js_cache = get(b:,'js_cache',[0,0,0])
   " Get the current line.
-  let line = getline(v:lnum)
-  " previous nonblank line number
-  let prevline = prevnonblank(v:lnum - 1)
-  " previous line of code
-  let lnum = s:PrevNonBlankNonString(v:lnum - 1)
+  call cursor(v:lnum,1)
+  let l:line = getline('.')
+  " use synstack as it validates syn state and works in an empty line
+  let s:stack = map(synstack(v:lnum,1),"synIDattr(v:val,'name')")
+  let syns = get(s:stack,-1,'')
 
-  " to not change multiline string values 
-  if line !~ '^[''"`]' && synIDattr(synID(v:lnum, 1, 1), 'name') =~? 'string\|template'
+  " start with strings,comments,etc.
+  if syns =~? s:syng_com
+    if l:line =~ '^\s*\*'
+      return cindent(v:lnum)
+    elseif l:line !~ '^\s*\/[/*]'
+      return -1
+    endif
+  elseif syns =~? s:syng_str
+    if b:js_cache[0] == v:lnum - 1 && s:Balanced(v:lnum-1)
+      let b:js_cache[0] = v:lnum
+    endif
     return -1
   endif
-
-  " If we are in a multi-line comment, cindent does the right thing.
-  if line !~ '^\%(\/\*\|\s*\/\/\)' && s:IsInComment(v:lnum, 1)
-    return cindent(v:lnum)
+  let l:lnum = s:PrevCodeLine(v:lnum - 1)
+  if !l:lnum
+    return
   endif
 
-  " single opening bracket will assume you want a c style of indenting
-  if line =~ s:line_pre . '{' && !s:Match(lnum,s:block_regex) &&
-        \ !s:Match(lnum,s:comma_last)
-    return cindent(v:lnum)
+  let l:line = substitute(l:line,'^\s*','','')
+  if l:line[:1] == '/*'
+    let l:line = substitute(l:line,'^\%(\/\*.\{-}\*\/\s*\)*','','')
+  endif
+  if l:line =~ '^\/[/*]'
+    let l:line = ''
   endif
 
-  " cindent each line which has a switch label
-  if (line =~ s:expr_case)
-    let s:cpo_switch = &cpo
-    set cpo+=%
-    let ind = cindent(v:lnum)
-    let &cpo = s:cpo_switch
-    return ind
-  endif
-
-  " If we got a closing bracket on an empty line, find its match and indent
-  " according to it.
-  let col = line =~ s:line_pre . '[]})]'
-  if col > 0
-    let parlnum = v:lnum
-    while col
-      call cursor(parlnum, 1)
-      let parlnum = s:lookForParens('(\|{\|\[', ')\|}\|\]', 'nbW', 0)
-      let col = s:Match(parlnum,  s:line_pre . '[]})]')
-      if col
-        continue
-      end
-      if parlnum > 0
-        let ind = s:InMultiVarStatement(parlnum, 0, 0)|| s:LineHasOpeningBrackets(parlnum) !~ '2' ?
-              \ indent(parlnum) : indent(s:GetMSL(parlnum, 0))
-      endif
-    endwhile
-    return ind
-  endif
-
-
-  " If line starts with an operator...
-  if (line =~ s:operator_first)
-    if (s:Match(lnum, s:operator_first) || (s:Match(lnum, s:line_pre . '[])}]') &&
-          \ !(s:Match(v:lnum,s:line_pre . '\.') && s:Match(lnum, ')' . s:line_term))))
-      " and so does previous line, don't indent
-      return indent(lnum)
-    end
-    let counts = s:LineHasOpeningBrackets(lnum)
-    if counts =~ '2'
-      call cursor(lnum, 1)
-      " Search for the opening tag
-      let parlnum = s:lookForParens('(\|{\|\[', ')\|}\|\]', 'nbW', 0)
-      if parlnum > 0
-        return !s:Match(parlnum, s:operator_first) &&
-              \ synIDattr(synID(v:lnum, 1, 1), 'name') !~? 'jsbracket\|jsparen\|jsobject' ?
-              \ indent(lnum) + s:sw() : indent(parlnum)
-      end
-    elseif synIDattr(synID(v:lnum, 1, 1), 'name') !~? 'jsbracket\|jsparen\|jsobject'
-      " otherwise, if not in an key/val;array item;param, indent 1 level
-      return indent(lnum) + s:sw()
-    end
-
-    " If previous line starts with an operator...
-  elseif (s:Match(lnum, s:operator_first) && !s:Match(lnum,s:continuation_regex)) ||
-        \ getline(lnum) =~ '[]})];\=' . s:line_term
-    let counts = s:LineHasOpeningBrackets(lnum)
-    if counts =~ '2' && !s:Match(lnum, s:operator_first)
-      call cursor(lnum, 1)
-      " Search for the opening tag
-      let mnum = s:lookForParens('(\|{\|\[', ')\|}\|\]', 'nbW', 0)
-      if mnum > 0 && (s:Match(mnum, s:operator_first) ||
-            \ (s:Onescope(s:PrevNonBlankNonString(mnum - 1))) && !s:Match(mnum, s:line_pre . '{'))
-        return indent(mnum) - s:sw()
-      end
-    elseif s:Match(lnum, s:operator_first)
-      if counts !~ '1'
-        return indent(lnum) - s:sw()
-      end
-    end
-  end
-
-  " 3.3. Work on the previous line. {{{1
-  " -------------------------------
-
-  " If the line is empty and the previous nonblank line was a multi-line
-  " comment, use that comment's indent. Deduct one char to account for the
-  " space in ' */'.
-  if line =~ '^\s*$' && getline(prevline) =~ '\%(\%(^\s*\/\/\|\/\*\).*\)\@<!\*\/' &&
-        \ s:IsInComment(prevline, 1)
-    return indent(prevline) - 1
-  endif
-
-  " Find a non-blank, non-multi-line string line above the current line.
-
-  " If the line is empty and inside a string, use the previous line.
-  if line =~ '^\s*$' && lnum != prevline
-    return indent(prevnonblank(v:lnum))
-  endif
-
-  " At the start of the file use zero indent.
-  if lnum == 0
-    return 0
-  endif
-
-  " If the previous line ended with a block opening, add a level of indent.
-  if s:Match(lnum, s:block_regex)
-    return s:InMultiVarStatement(lnum, 0, 0) || s:LineHasOpeningBrackets(lnum) !~ '2' ?
-          \ indent(lnum) + s:sw() : indent(s:GetMSL(lnum, 0)) + s:sw()
-  endif
-
-  " Set up variables for current line.
-  let line = getline(lnum)
-  let ind = indent(lnum)
-  " If the previous line contained an opening bracket, and we are still in it,
-  " add indent depending on the bracket type.
-  if s:Match(lnum, '[[({})\]]')
-    let counts = s:LineHasOpeningBrackets(lnum)
-    if counts =~ '2'
-      call cursor(lnum,matchend(s:RemoveTrailingComments(line), '.*\zs[])}]'))
-      while s:lookForParens('(\|{\|\[', ')\|}\|\]', 'bW', 0) == lnum
-        call cursor(lnum, matchend(s:RemoveTrailingComments(strpart(line,0,col('.'))), '.*\zs[])}]'))
-      endwhile
-      let cur = line('.')
-      if cur < lnum && !s:InMultiVarStatement(cur,0,0)
-        return indent(s:GetMSL(cur, 0))
-      end
-    elseif counts =~ '1' || s:Onescope(lnum)
-      return ind + s:sw()
-    end
-  end
-
-  " 3.4. Work on the MSL line. {{{1
-  " --------------------------
-  if s:Match(lnum, s:comma_last) && !s:Match(lnum,  s:continuation_regex)
-    return s:Match(lnum, s:var_stmt) ? indent(lnum) + s:sw() : indent(lnum)
-
-  elseif s:Match(s:PrevNonBlankNonString(lnum - 1), s:comma_last)
-    if !s:Match(lnum, s:comma_last) && s:InMultiVarStatement(lnum,1,0)
-      return indent(lnum) - s:sw()
-    end
-  end
-  let ind_con = ind
-  let ind = s:IndentWithContinuation(lnum, ind_con, s:sw())
-
-  " }}}2
-  "
-  "
-  let ols = s:InOneLineScope(lnum)
-  if ols > 0
-    let ind = ind + s:sw()
+  " the containing paren, bracket, or curly. Many hacks for performance
+  let idx = index([']',')','}'],l:line[0])
+  if b:js_cache[0] >= l:lnum && b:js_cache[0] < v:lnum &&
+        \ (b:js_cache[0] > l:lnum || s:Balanced(l:lnum))
+    call call('cursor',b:js_cache[1:])
   else
-    let ols = s:ExitingOneLineScope(lnum)
-    while ols > 0 && ind > 0
-      let ind = ind - s:sw()
-      let ols = s:InOneLineScope(ols - 1)
-    endwhile
+    let [s:looksyn, s:checkIn, top] = [v:lnum - 1, 0, (!indent(l:lnum) &&
+          \ s:syn_at(l:lnum,1) !~? s:syng_str) * l:lnum]
+    if idx + 1
+      call s:GetPair(['\[','(','{'][idx],'])}'[idx],'bW','s:skip_func()',2000,top)
+    elseif getline(v:lnum) !~ '^\S' && syns =~? 'block'
+      call s:GetPair('{','}','bW','s:skip_func()',2000,top)
+    else
+      call s:alternatePair(top)
+    endif
   endif
 
-  return ind
-endfunction
+  let b:js_cache = [v:lnum] + (line('.') == v:lnum ? [0,0] : getpos('.')[1:2])
+  let num = b:js_cache[1]
 
-" }}}1
+  let [s:W, isOp, bL, switch_offset] = [s:sw(),0,0,0]
+  if !num || s:IsBlock()
+    let ilnum = line('.')
+    let pline = s:save_pos('s:Trim',l:lnum)
+    if num && s:looking_at() == ')' && s:GetPair('(', ')', 'bW', s:skip_expr, 100) > 0
+      let num = ilnum == num ? line('.') : num
+      if idx < 0 && s:previous_token() ==# 'switch' && s:previous_token() != '.'
+        if &cino !~ ':'
+          let switch_offset = s:W
+        else
+          let switch_offset = max([-indent(num),s:parse_cino(':')])
+        endif
+        if pline[-1:] != '.' && l:line =~# '^\%(default\|case\)\>'
+          return indent(num) + switch_offset
+        endif
+      endif
+    endif
+    if idx < 0 && pline[-1:] !~ '[{;]'
+      let isOp = (l:line =~# s:opfirst || s:continues(l:lnum,pline)) * s:W
+      let bL = s:iscontOne(l:lnum,b:js_cache[1],isOp)
+      let bL -= (bL && l:line[0] == '{') * s:W
+    endif
+  elseif idx < 0 && getline(b:js_cache[1])[b:js_cache[2]-1] == '(' && &cino =~ '('
+    let pval = s:parse_cino('(')
+    return !pval ? (s:parse_cino('w') ? 0 : -(!!search('\m\S','W'.s:z,num))) + virtcol('.') :
+          \ max([indent('.') + pval + (s:GetPair('(',')','nbrmW',s:skip_expr,100,num) * s:W),0])
+  endif
+
+  " main return
+  if l:line =~ '^\%([])}]\||}\)'
+    return max([indent(num),0])
+  elseif num
+    return indent(num) + s:W + switch_offset + bL + isOp
+  endif
+  return bL + isOp
+endfunction
 
 let &cpo = s:cpo_save
 unlet s:cpo_save
-" gq{{{2
-function! Fixedgq(lnum, count)
-  let l:tw = &tw ? &tw : 80;
-
-  let l:count = a:count
-  let l:first_char = indent(a:lnum) + 1
-
-  if mode() == 'i' " gq was not pressed, but tw was set
-    return 1
-  endif
-
-  " This gq is only meant to do code with strings, not comments
-  if s:IsInComment(a:lnum, l:first_char)
-    return 1
-  endif
-
-  if len(getline(a:lnum)) < l:tw && l:count == 1 " No need for gq
-    return 1
-  endif
-
-  " Put all the lines on one line and do normal spliting after that
-  if l:count > 1
-    while l:count > 1
-      let l:count -= 1
-      normal J
-    endwhile
-  endif
-
-  let l:winview = winsaveview()
-
-  call cursor(a:lnum, l:tw + 1)
-  let orig_breakpoint = searchpairpos(' ', '', '\.', 'bcW', '', a:lnum)
-  call cursor(a:lnum, l:tw + 1)
-  let breakpoint = searchpairpos(' ', '', '\.', 'bcW', s:skip_expr, a:lnum)
-
-  " No need for special treatment, normal gq handles edgecases better
-  if breakpoint[1] == orig_breakpoint[1]
-    call winrestview(l:winview)
-    return 1
-  endif
-
-  " Try breaking after string
-  if breakpoint[1] <= indent(a:lnum)
-    call cursor(a:lnum, l:tw + 1)
-    let breakpoint = searchpairpos('\.', '', ' ', 'cW', s:skip_expr, a:lnum)
-  endif
-
-
-  if breakpoint[1] != 0
-    call feedkeys("r\<CR>")
-  else
-    let l:count = l:count - 1
-  endif
-
-  " run gq on new lines
-  if l:count == 1
-    call feedkeys("gqq")
-  endif
-
-  return 0
-endfunction
-"}}}
-" vim: foldmethod=marker:foldlevel=1
 
 endif

indent/json.vim

@@ -44,7 +44,7 @@ let s:block_regex = '\%({\)\s*\%(|\%([*@]\=\h\w*,\=\s*\)\%(,\s*[*@]\=\h\w*\)*|\)
 
 " Check if the character at lnum:col is inside a string.
 function s:IsInString(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') == jsonString
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') == "jsonString"
 endfunction
 
 " Find line above 'lnum' that isn't empty, or in a string.
@@ -143,7 +143,11 @@ function GetJSONIndent()
 
   " If the previous line ended with a block opening, add a level of indent.
   " if s:Match(lnum, s:block_regex)
-    " return indent(lnum) + shiftwidth()
+  "   if exists('*shiftwidth')
+  "     return indent(lnum) + shiftwidth()
+  "   else
+  "     return indent(lnum) + &sw
+  "   endif
   " endif
 
   " If the previous line contained an opening bracket, and we are still in it,
@@ -151,7 +155,11 @@ function GetJSONIndent()
   if line =~ '[[({]'
     let counts = s:LineHasOpeningBrackets(lnum)
     if counts[0] == '1' || counts[1] == '1' || counts[2] == '1'
-      return ind + shiftwidth()
+      if exists('*shiftwidth')
+        return ind + shiftwidth()
+      else
+        return ind + &sw
+      endif
     else
       call cursor(v:lnum, vcol)
     end

indent/litcoffee.vim

@@ -0,0 +1,26 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'coffee-script') == -1
+  
+if exists('b:did_indent')
+  finish
+endif
+
+runtime! indent/coffee.vim
+
+let b:did_indent = 1
+
+setlocal indentexpr=GetLitCoffeeIndent()
+
+if exists('*GetLitCoffeeIndent')
+  finish
+endif
+
+function GetLitCoffeeIndent()
+  if searchpair('^    \|\t', '', '$', 'bWnm') > 0
+    return GetCoffeeIndent(v:lnum)
+  else
+    return -1
+  endif
+endfunc
+
+
+endif

indent/ls.vim

@@ -0,0 +1,268 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'livescript') == -1
+  
+" Language:    LiveScript
+" Maintainer:  George Zahariev
+" URL:         http://github.com/gkz/vim-ls
+" License:     WTFPL
+
+if exists("b:did_indent")
+  finish
+endif
+
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal indentexpr=GetLiveScriptIndent(v:lnum)
+" Make sure GetLiveScriptIndent is run when these are typed so they can be
+" indented or outdented.
+setlocal indentkeys+=0],0),0.,=else,=when,=catch,=finally
+
+" Only define the function once.
+if exists("*GetLiveScriptIndent")
+  finish
+endif
+
+" Keywords to indent after
+let s:INDENT_AFTER_KEYWORD = '^\%(if\|unless\|else\|for\|while\|until\|'
+\                          . 'loop\|case\|default\|try\|catch\|finally\|'
+\                          . 'class\|do\|new\|let\|with\|function\)\>'
+
+" Operators to indent after
+let s:INDENT_AFTER_OPERATOR = '\%([([{:=]\|[-=]>\)$'
+
+" Keywords and operators that continue a line
+let s:CONTINUATION = '\<\%(is\|isnt\|and\|or\|do\)\>$'
+\                  . '\|'
+\                  . '\%(-\@<!-\|+\@<!+\|<\|[-~]\@<!>\|\*\|/\@<!/\|%\||\|'
+\                  . '&\|,\|\.\@<!\.\)$'
+
+" Operators that block continuation indenting
+let s:CONTINUATION_BLOCK = '[([{:=]$'
+
+" A continuation dot access
+let s:DOT_ACCESS = '^\.'
+
+" Keywords to outdent after
+let s:OUTDENT_AFTER = '^\%(return\|break\|continue\|throw\)\>'
+
+" A compound assignment like `... = if ...`
+let s:COMPOUND_ASSIGNMENT = '[:=]\s*\%(if\|unless\|for\|while\|until\|'
+\                         . 'try\|class\|do\|new\|let\|with\)\>'
+
+" A postfix condition like `return ... if ...`.
+let s:POSTFIX_CONDITION = '\S\s\+\zs\<\%(if\|unless\)\>'
+
+" A single-line else statement like `else ...` but not `else if ...
+let s:SINGLE_LINE_ELSE = '^else\s\+\%(\<\%(if\|unless\)\>\)\@!'
+
+" Max lines to look back for a match
+let s:MAX_LOOKBACK = 50
+
+" Get the linked syntax name of a character.
+function! s:SyntaxName(linenum, col)
+  return synIDattr(synIDtrans(synID(a:linenum, a:col, 1)), 'name')
+endfunction
+
+" Check if a character is in a comment.
+function! s:IsComment(linenum, col)
+  return s:SyntaxName(a:linenum, a:col) == 'Comment'
+endfunction
+
+" Check if a character is in a string.
+function! s:IsString(linenum, col)
+  return s:SyntaxName(a:linenum, a:col) == 'Constant'
+endfunction
+
+" Check if a character is in a comment or string.
+function! s:IsCommentOrString(linenum, col)
+  return s:SyntaxName(a:linenum, a:col) =~ 'Comment\|Constant'
+endfunction
+
+" Check if a whole line is a comment.
+function! s:IsCommentLine(linenum)
+  " Check the first non-whitespace character.
+  return s:IsComment(a:linenum, indent(a:linenum) + 1)
+endfunction
+
+" Repeatedly search a line for a regex until one is found outside a string or
+" comment.
+function! s:SmartSearch(linenum, regex)
+  " Start at the first column.
+  let col = 0
+
+  " Search until there are no more matches, unless a good match is found.
+  while 1
+    call cursor(a:linenum, col + 1)
+    let [_, col] = searchpos(a:regex, 'cn', a:linenum)
+
+    " No more matches.
+    if !col
+      break
+    endif
+
+    if !s:IsCommentOrString(a:linenum, col)
+      return 1
+    endif
+  endwhile
+
+  " No good match found.
+  return 0
+endfunction
+
+" Skip a match if it's in a comment or string, is a single-line statement that
+" isn't adjacent, or is a postfix condition.
+function! s:ShouldSkip(startlinenum, linenum, col)
+  if s:IsCommentOrString(a:linenum, a:col)
+    return 1
+  endif
+
+  " Check for a single-line statement that isn't adjacent.
+  if s:SmartSearch(a:linenum, '\<then\>') && a:startlinenum - a:linenum > 1
+    return 1
+  endif
+
+  if s:SmartSearch(a:linenum, s:POSTFIX_CONDITION) &&
+  \ !s:SmartSearch(a:linenum, s:COMPOUND_ASSIGNMENT)
+    return 1
+  endif
+
+  return 0
+endfunction
+
+" Find the farthest line to look back to, capped to line 1 (zero and negative
+" numbers cause bad things).
+function! s:MaxLookback(startlinenum)
+  return max([1, a:startlinenum - s:MAX_LOOKBACK])
+endfunction
+
+" Get the skip expression for searchpair().
+function! s:SkipExpr(startlinenum)
+  return "s:ShouldSkip(" . a:startlinenum . ", line('.'), col('.'))"
+endfunction
+
+" Search for pairs of text.
+function! s:SearchPair(start, end)
+  " The cursor must be in the first column for regexes to match.
+  call cursor(0, 1)
+
+  let startlinenum = line('.')
+
+  " Don't need the W flag since MaxLookback caps the search to line 1.
+  return searchpair(a:start, '', a:end, 'bcn',
+  \                 s:SkipExpr(startlinenum),
+  \                 s:MaxLookback(startlinenum))
+endfunction
+
+" Try to find a previous matching line.
+function! s:GetMatch(curline)
+  let firstchar = a:curline[0]
+
+  if firstchar == '}'
+    return s:SearchPair('{', '}')
+  elseif firstchar == ')'
+    return s:SearchPair('(', ')')
+  elseif firstchar == ']'
+    return s:SearchPair('\[', '\]')
+  elseif a:curline =~ '^else\>'
+    return s:SearchPair('\<\%(if\|unless\|case\|when\)\>', '\<else\>')
+  elseif a:curline =~ '^catch\>'
+    return s:SearchPair('\<try\>', '\<catch\>')
+  elseif a:curline =~ '^finally\>'
+    return s:SearchPair('\<try\>', '\<finally\>')
+  endif
+
+  return 0
+endfunction
+
+" Get the nearest previous line that isn't a comment.
+function! s:GetPrevNormalLine(startlinenum)
+  let curlinenum = a:startlinenum
+
+  while curlinenum > 0
+    let curlinenum = prevnonblank(curlinenum - 1)
+
+    if !s:IsCommentLine(curlinenum)
+      return curlinenum
+    endif
+  endwhile
+
+  return 0
+endfunction
+
+" Get the contents of a line without leading or trailing whitespace.
+function! s:GetTrimmedLine(linenum)
+  return substitute(substitute(getline(a:linenum), '^\s\+', '', ''),
+  \                                                '\s\+$', '', '')
+endfunction
+
+function! s:GetLiveScriptIndent(curlinenum)
+  let prevlinenum = s:GetPrevNormalLine(a:curlinenum)
+
+  " Don't do anything if there's no previous line.
+  if !prevlinenum
+    return -1
+  endif
+
+  let curline = s:GetTrimmedLine(a:curlinenum)
+
+  " Try to find a previous matching statement. This handles outdenting.
+  let matchlinenum = s:GetMatch(curline)
+
+  if matchlinenum
+    return indent(matchlinenum)
+  endif
+
+  let prevline = s:GetTrimmedLine(prevlinenum)
+  let previndent = indent(prevlinenum)
+
+  " Always indent after these operators.
+  if prevline =~ s:INDENT_AFTER_OPERATOR
+    return previndent + &shiftwidth
+  endif
+
+  " Indent after a continuation if it's the first.
+  if prevline =~ s:CONTINUATION
+    let prevprevlinenum = s:GetPrevNormalLine(prevlinenum)
+    let prevprevline = s:GetTrimmedLine(prevprevlinenum)
+
+    if prevprevline !~ s:CONTINUATION && prevprevline !~ s:CONTINUATION_BLOCK
+      return previndent + &shiftwidth
+    endif
+  endif
+
+  " Indent after these keywords and compound assignments if they aren't a
+  " single-line statement.
+  if prevline =~ s:INDENT_AFTER_KEYWORD || prevline =~ s:COMPOUND_ASSIGNMENT
+    if !s:SmartSearch(prevlinenum, '\<then\>') && prevline !~ s:SINGLE_LINE_ELSE
+      return previndent + &shiftwidth
+    endif
+  endif
+
+  " Indent a dot access if it's the first.
+  if curline =~ s:DOT_ACCESS && prevline !~ s:DOT_ACCESS
+    return previndent + &shiftwidth
+  endif
+
+  " Outdent after these keywords if they don't have a postfix condition and
+  " aren't a single-line statement.
+  if prevline =~ s:OUTDENT_AFTER
+    if !s:SmartSearch(prevlinenum, s:POSTFIX_CONDITION) ||
+    \   s:SmartSearch(prevlinenum, '\<then\>')
+      return previndent - &shiftwidth
+    endif
+  endif
+
+  " No indenting or outdenting is needed.
+  return -1
+endfunction
+
+" Wrap s:GetLiveScriptIndent to keep the cursor position.
+function! GetLiveScriptIndent(curlinenum)
+  let oldcursor = getpos('.')
+  let indent = s:GetLiveScriptIndent(a:curlinenum)
+  call setpos('.', oldcursor)
+
+  return indent
+endfunction
+
+endif

indent/lua.vim

@@ -0,0 +1,126 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'lua') == -1
+  
+" Vim indent file
+" Language: Lua
+" URL: https://github.com/tbastos/vim-lua
+
+" Initialization ------------------------------------------{{{1
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal nosmartindent
+
+setlocal indentexpr=GetLuaIndent()
+setlocal indentkeys+=0=end,0=until,0=elseif,0=else
+
+" Only define the function once.
+if exists("*GetLuaIndent")
+  finish
+endif
+
+" Variables -----------------------------------------------{{{1
+
+let s:open_patt = '\%(\<\%(function\|if\|repeat\|do\)\>\|(\|{\)'
+let s:middle_patt = '\<\%(else\|elseif\)\>'
+let s:close_patt = '\%(\<\%(end\|until\)\>\|)\|}\)'
+
+let s:anon_func_start = '\S\+\s*[({].*\<function\s*(.*)\s*$'
+let s:anon_func_end = '\<end\%(\s*[)}]\)\+'
+
+" Expression used to check whether we should skip a match with searchpair().
+let s:skip_expr = "synIDattr(synID(line('.'),col('.'),1),'name') =~ 'luaComment\\|luaString'"
+
+" Auxiliary Functions -------------------------------------{{{1
+
+function s:IsInCommentOrString(lnum, col)
+  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ 'luaCommentLong\|luaStringLong'
+        \ && !(getline(a:lnum) =~ '^\s*\%(--\)\?\[=*\[') " opening tag is not considered 'in'
+endfunction
+
+" Find line above 'lnum' that isn't blank, in a comment or string.
+function s:PrevLineOfCode(lnum)
+  let lnum = prevnonblank(a:lnum)
+  while s:IsInCommentOrString(lnum, 1)
+    let lnum = prevnonblank(lnum - 1)
+  endwhile
+  return lnum
+endfunction
+
+" Gets line contents, excluding trailing comments.
+function s:GetContents(lnum)
+  return substitute(getline(a:lnum), '\v\m--.*$', '', '')
+endfunction
+
+" GetLuaIndent Function -----------------------------------{{{1
+
+function GetLuaIndent()
+  " if the line is in a long comment or string, don't change the indent
+  if s:IsInCommentOrString(v:lnum, 1)
+    return -1
+  endif
+
+  let prev_line = s:PrevLineOfCode(v:lnum - 1)
+  if prev_line == 0
+    " this is the first non-empty line
+    return 0
+  endif
+
+  let contents_cur = s:GetContents(v:lnum)
+  let contents_prev = s:GetContents(prev_line)
+
+  let original_cursor_pos = getpos(".")
+
+  let i = 0
+
+  " check if the previous line opens blocks
+  call cursor(v:lnum, 1)
+  let num_pairs = searchpair(s:open_patt, s:middle_patt, s:close_patt,
+        \ 'mrb', s:skip_expr, prev_line)
+  if num_pairs > 0
+    let i += num_pairs
+  endif
+
+  " special case: call(with, {anon = function() -- should indent only once
+  if num_pairs > 1 && contents_prev =~ s:anon_func_start
+    let i = 1
+  endif
+
+  " check if current line closes blocks
+  call cursor(prev_line, col([prev_line,'$']))
+  let num_pairs = searchpair(s:open_patt, s:middle_patt, s:close_patt,
+        \ 'mr', s:skip_expr, v:lnum)
+  if num_pairs > 0
+    let i -= num_pairs
+  endif
+
+  " special case: end}) -- end of call with anon func should unindent once
+  if num_pairs > 1 && contents_cur =~ s:anon_func_end
+    let i = -1
+  endif
+
+  " if the previous line closed a paren, unindent (except with anon funcs)
+  call cursor(prev_line - 1, col([prev_line - 1, '$']))
+  let num_pairs = searchpair('(', '', ')', 'mr', s:skip_expr, prev_line)
+  if num_pairs > 0 && contents_prev !~ s:anon_func_end
+    let i -= 1
+  endif
+
+  " if this line closed a paren, indent (except with anon funcs)
+  call cursor(prev_line, col([prev_line, '$']))
+  let num_pairs = searchpair('(', '', ')', 'mr', s:skip_expr, v:lnum)
+  if num_pairs > 0 && contents_cur !~ s:anon_func_end
+    let i += 1
+  endif
+
+  " restore cursor
+  call setpos(".", original_cursor_pos)
+
+  return indent(prev_line) + (&sw * i)
+
+endfunction
+
+endif

indent/perl6.vim

@@ -1,131 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'perl') == -1
-  
-" Vim indent file
-" Language:      Perl 6
-" Maintainer:    vim-perl <vim-perl@googlegroups.com>
-" Homepage:      http://github.com/vim-perl/vim-perl
-" Bugs/requests: http://github.com/vim-perl/vim-perl/issues
-" Last Change:   {{LAST_CHANGE}}
-" Contributors:  Andy Lester <andy@petdance.com>
-"                Hinrik Örn Sigurðsson <hinrik.sig@gmail.com>
-"
-" Adapted from indent/perl.vim by Rafael Garcia-Suarez <rgarciasuarez@free.fr>
-
-" Suggestions and improvements by :
-"   Aaron J. Sherman (use syntax for hints)
-"   Artem Chuprina (play nice with folding)
-" TODO:
-" This file still relies on stuff from the Perl 5 syntax file, which Perl 6
-" does not use.
-"
-" Things that are not or not properly indented (yet) :
-" - Continued statements
-"     print "foo",
-"       "bar";
-"     print "foo"
-"       if bar();
-" - Multiline regular expressions (m//x)
-" (The following probably needs modifying the perl syntax file)
-" - qw() lists
-" - Heredocs with terminators that don't match \I\i*
-
-" Only load this indent file when no other was loaded.
-if exists("b:did_indent")
-    finish
-endif
-let b:did_indent = 1
-
-" Is syntax highlighting active ?
-let b:indent_use_syntax = has("syntax")
-
-setlocal indentexpr=GetPerl6Indent()
-
-" we reset it first because the Perl 5 indent file might have been loaded due
-" to a .pl/pm file extension, and indent files don't clean up afterwards
-setlocal indentkeys&
-
-setlocal indentkeys+=0=,0),0],0>,0»,0=or,0=and
-if !b:indent_use_syntax
-    setlocal indentkeys+=0=EO
-endif
-
-let s:cpo_save = &cpo
-set cpo-=C
-
-function! GetPerl6Indent()
-
-    " Get the line to be indented
-    let cline = getline(v:lnum)
-
-    " Indent POD markers to column 0
-    if cline =~ '^\s*=\L\@!'
-        return 0
-    endif
-
-    " Get current syntax item at the line's first char
-    let csynid = ''
-    if b:indent_use_syntax
-        let csynid = synIDattr(synID(v:lnum,1,0),"name")
-    endif
-
-    " Don't reindent POD and heredocs
-    if csynid =~ "^p6Pod"
-        return indent(v:lnum)
-    endif
-
-
-    " Now get the indent of the previous perl line.
-
-    " Find a non-blank line above the current line.
-    let lnum = prevnonblank(v:lnum - 1)
-    " Hit the start of the file, use zero indent.
-    if lnum == 0
-        return 0
-    endif
-    let line = getline(lnum)
-    let ind = indent(lnum)
-    " Skip heredocs, POD, and comments on 1st column
-    if b:indent_use_syntax
-        let skippin = 2
-        while skippin
-            let synid = synIDattr(synID(lnum,1,0),"name")
-            if (synid =~ "^p6Pod" || synid =~ "p6Comment")
-                let lnum = prevnonblank(lnum - 1)
-                if lnum == 0
-                    return 0
-                endif
-                let line = getline(lnum)
-                let ind = indent(lnum)
-                let skippin = 1
-            else
-                let skippin = 0
-            endif
-        endwhile
-    endif
-
-        if line =~ '[<«\[{(]\s*\(#[^)}\]»>]*\)\=$'
-            let ind = ind + &sw
-        endif
-        if cline =~ '^\s*[)}\]»>]'
-            let ind = ind - &sw
-        endif
-
-    " Indent lines that begin with 'or' or 'and'
-    if cline =~ '^\s*\(or\|and\)\>'
-        if line !~ '^\s*\(or\|and\)\>'
-            let ind = ind + &sw
-        endif
-    elseif line =~ '^\s*\(or\|and\)\>'
-        let ind = ind - &sw
-    endif
-
-    return ind
-
-endfunction
-
-let &cpo = s:cpo_save
-unlet s:cpo_save
-
-" vim:ts=8:sts=4:sw=4:expandtab:ft=vim
-
-endif

indent/plantuml.vim

@@ -0,0 +1,59 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'plantuml') == -1
+  
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal indentexpr=GetPlantUMLIndent()
+setlocal indentkeys=o,O,<CR>,<:>,!^F,0end,0else,}
+
+" only define the indent code once
+if exists("*GetPlantUMLIndent")
+  finish
+endif
+
+let s:incIndent =
+      \ '^\s*\%(loop\|alt\|opt\|group\|critical\|else\|legend\|box\|if\|while\)\>\|' .
+      \ '^\s*ref\>[^:]*$\|' .
+      \ '^\s*[hr]\?note\>\%(\%("[^"]*" \<as\>\)\@![^:]\)*$\|' .
+      \ '^\s*title\s*$\|' .
+      \ '^\s*skinparam\>.*{\s*$\|' .
+      \ '^\s*\%(state\|class\|partition\|rectangle\|enum\|interface\|namespace\)\>.*{'
+
+let s:decIndent = '^\s*\%(end\|else\|}\)'
+
+function! GetPlantUMLIndent(...) abort
+  "for current line, use arg if given or v:lnum otherwise
+  let clnum = a:0 ? a:1 : v:lnum
+
+  if !s:insidePlantUMLTags(clnum)
+    return indent(clnum)
+  endif
+
+  let pnum = prevnonblank(clnum-1)
+  let pindent = indent(pnum)
+  let pline = getline(pnum)
+  let cline = getline(clnum)
+
+  if cline =~ s:decIndent
+    if pline =~ s:incIndent
+      return pindent
+    else
+      return pindent - shiftwidth()
+    endif
+
+  elseif pline =~ s:incIndent
+    return pindent + shiftwidth()
+  endif
+
+  return pindent
+
+endfunction
+
+function! s:insidePlantUMLTags(lnum) abort
+  call cursor(a:lnum, 1)
+  return search('@startuml', 'Wbn') && search('@enduml', 'Wn')
+endfunction
+
+endif

indent/ruby.vim

@@ -20,6 +20,11 @@ if !exists('g:ruby_indent_access_modifier_style')
   let g:ruby_indent_access_modifier_style = 'normal'
 endif
 
+if !exists('g:ruby_indent_assignment_style')
+  " Possible values: "variable", "hanging"
+  let g:ruby_indent_assignment_style = 'hanging'
+endif
+
 if !exists('g:ruby_indent_block_style')
   " Possible values: "expression", "do"
   let g:ruby_indent_block_style = 'expression'
@@ -51,11 +56,11 @@ let s:syng_strcom = '\<ruby\%(Regexp\|RegexpDelimiter\|RegexpEscape' .
 
 " Regex of syntax group names that are strings.
 let s:syng_string =
-      \ '\<ruby\%(String\|Interpolation\|NoInterpolation\|StringEscape\)\>'
+      \ '\<ruby\%(String\|Interpolation\|InterpolationDelimiter\|NoInterpolation\|StringEscape\)\>'
 
 " Regex of syntax group names that are strings or documentation.
 let s:syng_stringdoc =
-      \'\<ruby\%(String\|Interpolation\|NoInterpolation\|StringEscape\|Documentation\)\>'
+      \ '\<ruby\%(String\|Interpolation\|InterpolationDelimiter\|NoInterpolation\|StringEscape\|Documentation\)\>'
 
 " Expression used to check whether we should skip a match with searchpair().
 let s:skip_expr =
@@ -94,11 +99,12 @@ let s:end_skip_expr = s:skip_expr .
       \ ' && getline(".") =~ "^\\s*\\<\\(while\\|until\\|for\\):\\@!\\>")'
 
 " Regex that defines continuation lines, not including (, {, or [.
-let s:non_bracket_continuation_regex = '\%([\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|\W[|&?]\|||\|&&\)\s*\%(#.*\)\=$'
+let s:non_bracket_continuation_regex =
+      \ '\%([\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|:\@<![^[:alnum:]:][|&?]\|||\|&&\)\s*\%(#.*\)\=$'
 
 " Regex that defines continuation lines.
 let s:continuation_regex =
-      \ '\%(%\@<![({[\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|\W[|&?]\|||\|&&\)\s*\%(#.*\)\=$'
+      \ '\%(%\@<![({[\\.,:*/%+]\|\<and\|\<or\|\%(<%\)\@<![=-]\|:\@<![^[:alnum:]:][|&?]\|||\|&&\)\s*\%(#.*\)\=$'
 
 " Regex that defines continuable keywords
 let s:continuable_regex =
@@ -108,6 +114,12 @@ let s:continuable_regex =
 " Regex that defines bracket continuations
 let s:bracket_continuation_regex = '%\@<!\%([({[]\)\s*\%(#.*\)\=$'
 
+" Regex that defines dot continuations
+let s:dot_continuation_regex = '%\@<!\.\s*\%(#.*\)\=$'
+
+" Regex that defines backslash continuations
+let s:backslash_continuation_regex = '%\@<!\\\s*$'
+
 " Regex that defines end of bracket continuation followed by another continuation
 let s:bracket_switch_continuation_regex = '^\([^(]\+\zs).\+\)\+'.s:continuation_regex
 
@@ -137,7 +149,507 @@ let s:block_continuation_regex = '^\s*[^])}\t ].*'.s:block_regex
 " Regex that describes a leading operator (only a method call's dot for now)
 let s:leading_operator_regex = '^\s*[.]'
 
-" 2. Auxiliary Functions {{{1
+" 2. GetRubyIndent Function {{{1
+" =========================
+
+function GetRubyIndent(...)
+  " 2.1. Setup {{{2
+  " ----------
+
+  let indent_info = {}
+
+  " The value of a single shift-width
+  if exists('*shiftwidth')
+    let indent_info.sw = shiftwidth()
+  else
+    let indent_info.sw = &sw
+  endif
+
+  " For the current line, use the first argument if given, else v:lnum
+  let indent_info.clnum = a:0 ? a:1 : v:lnum
+  let indent_info.cline = getline(indent_info.clnum)
+
+  " Set up variables for restoring position in file.  Could use clnum here.
+  let indent_info.col = col('.')
+
+  " 2.2. Work on the current line {{{2
+  " -----------------------------
+  let indent_callback_names = [
+        \ 's:AccessModifier',
+        \ 's:ClosingBracketOnEmptyLine',
+        \ 's:BlockComment',
+        \ 's:DeindentingKeyword',
+        \ 's:MultilineStringOrLineComment',
+        \ 's:ClosingHeredocDelimiter',
+        \ 's:LeadingOperator',
+        \ ]
+
+  for callback_name in indent_callback_names
+"    Decho "Running: ".callback_name
+    let indent = call(function(callback_name), [indent_info])
+
+    if indent >= 0
+"      Decho "Match: ".callback_name." indent=".indent." info=".string(indent_info)
+      return indent
+    endif
+  endfor
+
+  " 2.3. Work on the previous line. {{{2
+  " -------------------------------
+  let indent_callback_names = [
+        \ 's:EmptyInsideString',
+        \ 's:StartOfFile',
+        \ 's:AfterAccessModifier',
+        \ 's:ContinuedLine',
+        \ 's:AfterBlockOpening',
+        \ 's:AfterHangingSplat',
+        \ 's:AfterUnbalancedBracket',
+        \ 's:AfterLeadingOperator',
+        \ 's:AfterEndKeyword',
+        \ 's:AfterIndentKeyword',
+        \ ]
+
+  " Previous line number
+  let indent_info.plnum = s:PrevNonBlankNonString(indent_info.clnum - 1)
+  let indent_info.pline = getline(indent_info.plnum)
+
+  for callback_name in indent_callback_names
+"    Decho "Running: ".callback_name
+    let indent = call(function(callback_name), [indent_info])
+
+    if indent >= 0
+"      Decho "Match: ".callback_name." indent=".indent." info=".string(indent_info)
+      return indent
+    endif
+  endfor
+
+  " 2.4. Work on the MSL line. {{{2
+  " --------------------------
+  let indent_callback_names = [
+        \ 's:PreviousNotMSL',
+        \ 's:IndentingKeywordInMSL',
+        \ 's:ContinuedHangingOperator',
+        \ ]
+
+  " Most Significant line based on the previous one -- in case it's a
+  " contination of something above
+  let indent_info.plnum_msl = s:GetMSL(indent_info.plnum)
+
+  for callback_name in indent_callback_names
+"    Decho "Running: ".callback_name
+    let indent = call(function(callback_name), [indent_info])
+
+    if indent >= 0
+"      Decho "Match: ".callback_name." indent=".indent." info=".string(indent_info)
+      return indent
+    endif
+  endfor
+
+  " }}}2
+
+  " By default, just return the previous line's indent
+"  Decho "Default case matched"
+  return indent(indent_info.plnum)
+endfunction
+
+" 3. Indenting Logic Callbacks {{{1
+" ============================
+
+function! s:AccessModifier(cline_info)
+  let info = a:cline_info
+
+  " If this line is an access modifier keyword, align according to the closest
+  " class declaration.
+  if g:ruby_indent_access_modifier_style == 'indent'
+    if s:Match(info.clnum, s:access_modifier_regex)
+      let class_lnum = s:FindContainingClass()
+      if class_lnum > 0
+        return indent(class_lnum) + info.sw
+      endif
+    endif
+  elseif g:ruby_indent_access_modifier_style == 'outdent'
+    if s:Match(info.clnum, s:access_modifier_regex)
+      let class_lnum = s:FindContainingClass()
+      if class_lnum > 0
+        return indent(class_lnum)
+      endif
+    endif
+  endif
+
+  return -1
+endfunction
+
+function! s:ClosingBracketOnEmptyLine(cline_info)
+  let info = a:cline_info
+
+  " If we got a closing bracket on an empty line, find its match and indent
+  " according to it.  For parentheses we indent to its column - 1, for the
+  " others we indent to the containing line's MSL's level.  Return -1 if fail.
+  let col = matchend(info.cline, '^\s*[]})]')
+
+  if col > 0 && !s:IsInStringOrComment(info.clnum, col)
+    call cursor(info.clnum, col)
+    let closing_bracket = info.cline[col - 1]
+    let bracket_pair = strpart('(){}[]', stridx(')}]', closing_bracket) * 2, 2)
+
+    if searchpair(escape(bracket_pair[0], '\['), '', bracket_pair[1], 'bW', s:skip_expr) > 0
+      if closing_bracket == ')' && col('.') != col('$') - 1
+        let ind = virtcol('.') - 1
+      elseif g:ruby_indent_block_style == 'do'
+        let ind = indent(line('.'))
+      else " g:ruby_indent_block_style == 'expression'
+        let ind = indent(s:GetMSL(line('.')))
+      endif
+    endif
+
+    return ind
+  endif
+
+  return -1
+endfunction
+
+function! s:BlockComment(cline_info)
+  " If we have a =begin or =end set indent to first column.
+  if match(a:cline_info.cline, '^\s*\%(=begin\|=end\)$') != -1
+    return 0
+  endif
+  return -1
+endfunction
+
+function! s:DeindentingKeyword(cline_info)
+  let info = a:cline_info
+
+  " If we have a deindenting keyword, find its match and indent to its level.
+  " TODO: this is messy
+  if s:Match(info.clnum, s:ruby_deindent_keywords)
+    call cursor(info.clnum, 1)
+
+    if searchpair(s:end_start_regex, s:end_middle_regex, s:end_end_regex, 'bW',
+          \ s:end_skip_expr) > 0
+      let msl  = s:GetMSL(line('.'))
+      let line = getline(line('.'))
+
+      if s:IsAssignment(line, col('.')) &&
+            \ strpart(line, col('.') - 1, 2) !~ 'do'
+        " assignment to case/begin/etc, on the same line
+        if g:ruby_indent_assignment_style == 'hanging'
+          " hanging indent
+          let ind = virtcol('.') - 1
+        else
+          " align with variable
+          let ind = indent(line('.'))
+        endif
+      elseif g:ruby_indent_block_style == 'do'
+        " align to line of the "do", not to the MSL
+        let ind = indent(line('.'))
+      elseif getline(msl) =~ '=\s*\(#.*\)\=$'
+        " in the case of assignment to the MSL, align to the starting line,
+        " not to the MSL
+        let ind = indent(line('.'))
+      else
+        " align to the MSL
+        let ind = indent(msl)
+      endif
+    endif
+    return ind
+  endif
+
+  return -1
+endfunction
+
+function! s:MultilineStringOrLineComment(cline_info)
+  let info = a:cline_info
+
+  " If we are in a multi-line string or line-comment, don't do anything to it.
+  if s:IsInStringOrDocumentation(info.clnum, matchend(info.cline, '^\s*') + 1)
+    return indent(info.clnum)
+  endif
+  return -1
+endfunction
+
+function! s:ClosingHeredocDelimiter(cline_info)
+  let info = a:cline_info
+
+  " If we are at the closing delimiter of a "<<" heredoc-style string, set the
+  " indent to 0.
+  if info.cline =~ '^\k\+\s*$'
+        \ && s:IsInStringDelimiter(info.clnum, 1)
+        \ && search('\V<<'.info.cline, 'nbW') > 0
+    return 0
+  endif
+
+  return -1
+endfunction
+
+function! s:LeadingOperator(cline_info)
+  " If the current line starts with a leading operator, add a level of indent.
+  if s:Match(a:cline_info.clnum, s:leading_operator_regex)
+    return indent(s:GetMSL(a:cline_info.clnum)) + a:cline_info.sw
+  endif
+  return -1
+endfunction
+
+function! s:EmptyInsideString(pline_info)
+  " If the line is empty and inside a string (plnum would not be the real
+  " prevnonblank in that case), use the previous line's indent
+  let info = a:pline_info
+
+  if info.cline =~ '^\s*$' && info.plnum != prevnonblank(info.clnum - 1)
+    return indent(prevnonblank(info.clnum))
+  endif
+  return -1
+endfunction
+
+function! s:StartOfFile(pline_info)
+  " At the start of the file use zero indent.
+  if a:pline_info.plnum == 0
+    return 0
+  endif
+  return -1
+endfunction
+
+function! s:AfterAccessModifier(pline_info)
+  let info = a:pline_info
+
+  if g:ruby_indent_access_modifier_style == 'indent'
+    " If the previous line was a private/protected keyword, add a
+    " level of indent.
+    if s:Match(info.plnum, s:indent_access_modifier_regex)
+      return indent(info.plnum) + info.sw
+    endif
+  elseif g:ruby_indent_access_modifier_style == 'outdent'
+    " If the previous line was a private/protected/public keyword, add
+    " a level of indent, since the keyword has been out-dented.
+    if s:Match(info.plnum, s:access_modifier_regex)
+      return indent(info.plnum) + info.sw
+    endif
+  endif
+  return -1
+endfunction
+
+" Example:
+"
+"   if foo || bar ||
+"       baz || bing
+"     puts "foo"
+"   end
+"
+function! s:ContinuedLine(pline_info)
+  let info = a:pline_info
+
+  let col = s:Match(info.plnum, s:ruby_indent_keywords)
+  if s:Match(info.plnum, s:continuable_regex) &&
+        \ s:Match(info.plnum, s:continuation_regex)
+    if col > 0 && s:IsAssignment(info.pline, col)
+      if g:ruby_indent_assignment_style == 'hanging'
+        " hanging indent
+        let ind = col - 1
+      else
+        " align with variable
+        let ind = indent(info.plnum)
+      endif
+    else
+      let ind = indent(s:GetMSL(info.plnum))
+    endif
+    return ind + info.sw + info.sw
+  endif
+  return -1
+endfunction
+
+function! s:AfterBlockOpening(pline_info)
+  let info = a:pline_info
+
+  " If the previous line ended with a block opening, add a level of indent.
+  if s:Match(info.plnum, s:block_regex)
+    if g:ruby_indent_block_style == 'do'
+      " don't align to the msl, align to the "do"
+      let ind = indent(info.plnum) + info.sw
+    else
+      let plnum_msl = s:GetMSL(info.plnum)
+
+      if getline(plnum_msl) =~ '=\s*\(#.*\)\=$'
+        " in the case of assignment to the msl, align to the starting line,
+        " not to the msl
+        let ind = indent(info.plnum) + info.sw
+      else
+        let ind = indent(plnum_msl) + info.sw
+      endif
+    endif
+
+    return ind
+  endif
+
+  return -1
+endfunction
+
+function! s:AfterLeadingOperator(pline_info)
+  " If the previous line started with a leading operator, use its MSL's level
+  " of indent
+  if s:Match(a:pline_info.plnum, s:leading_operator_regex)
+    return indent(s:GetMSL(a:pline_info.plnum))
+  endif
+  return -1
+endfunction
+
+function! s:AfterHangingSplat(pline_info)
+  let info = a:pline_info
+
+  " If the previous line ended with the "*" of a splat, add a level of indent
+  if info.pline =~ s:splat_regex
+    return indent(info.plnum) + info.sw
+  endif
+  return -1
+endfunction
+
+function! s:AfterUnbalancedBracket(pline_info)
+  let info = a:pline_info
+
+  " If the previous line contained unclosed opening brackets and we are still
+  " in them, find the rightmost one and add indent depending on the bracket
+  " type.
+  "
+  " If it contained hanging closing brackets, find the rightmost one, find its
+  " match and indent according to that.
+  if info.pline =~ '[[({]' || info.pline =~ '[])}]\s*\%(#.*\)\=$'
+    let [opening, closing] = s:ExtraBrackets(info.plnum)
+
+    if opening.pos != -1
+      if opening.type == '(' && searchpair('(', '', ')', 'bW', s:skip_expr) > 0
+        if col('.') + 1 == col('$')
+          return indent(info.plnum) + info.sw
+        else
+          return virtcol('.')
+        endif
+      else
+        let nonspace = matchend(info.pline, '\S', opening.pos + 1) - 1
+        return nonspace > 0 ? nonspace : indent(info.plnum) + info.sw
+      endif
+    elseif closing.pos != -1
+      call cursor(info.plnum, closing.pos + 1)
+      normal! %
+
+      if s:Match(line('.'), s:ruby_indent_keywords)
+        return indent('.') + info.sw
+      else
+        return indent(s:GetMSL(line('.')))
+      endif
+    else
+      call cursor(info.clnum, info.col)
+    end
+  endif
+
+  return -1
+endfunction
+
+function! s:AfterEndKeyword(pline_info)
+  let info = a:pline_info
+  " If the previous line ended with an "end", match that "end"s beginning's
+  " indent.
+  let col = s:Match(info.plnum, '\%(^\|[^.:@$]\)\<end\>\s*\%(#.*\)\=$')
+  if col > 0
+    call cursor(info.plnum, col)
+    if searchpair(s:end_start_regex, '', s:end_end_regex, 'bW',
+          \ s:end_skip_expr) > 0
+      let n = line('.')
+      let ind = indent('.')
+      let msl = s:GetMSL(n)
+      if msl != n
+        let ind = indent(msl)
+      end
+      return ind
+    endif
+  end
+  return -1
+endfunction
+
+function! s:AfterIndentKeyword(pline_info)
+  let info = a:pline_info
+  let col = s:Match(info.plnum, s:ruby_indent_keywords)
+
+  if col > 0
+    call cursor(info.plnum, col)
+    let ind = virtcol('.') - 1 + info.sw
+    " TODO: make this better (we need to count them) (or, if a searchpair
+    " fails, we know that something is lacking an end and thus we indent a
+    " level
+    if s:Match(info.plnum, s:end_end_regex)
+      let ind = indent('.')
+    elseif s:IsAssignment(info.pline, col)
+      if g:ruby_indent_assignment_style == 'hanging'
+        " hanging indent
+        let ind = col + info.sw - 1
+      else
+        " align with variable
+        let ind = indent(info.plnum) + info.sw
+      endif
+    endif
+    return ind
+  endif
+
+  return -1
+endfunction
+
+function! s:PreviousNotMSL(msl_info)
+  let info = a:msl_info
+
+  " If the previous line wasn't a MSL
+  if info.plnum != info.plnum_msl
+    " If previous line ends bracket and begins non-bracket continuation decrease indent by 1.
+    if s:Match(info.plnum, s:bracket_switch_continuation_regex)
+      " TODO (2016-10-07) Wrong/unused? How could it be "1"?
+      return indent(info.plnum) - 1
+      " If previous line is a continuation return its indent.
+      " TODO: the || s:IsInString() thing worries me a bit.
+    elseif s:Match(info.plnum, s:non_bracket_continuation_regex) || s:IsInString(info.plnum, strlen(line))
+      return indent(info.plnum)
+    endif
+  endif
+
+  return -1
+endfunction
+
+function! s:IndentingKeywordInMSL(msl_info)
+  let info = a:msl_info
+  " If the MSL line had an indenting keyword in it, add a level of indent.
+  " TODO: this does not take into account contrived things such as
+  " module Foo; class Bar; end
+  let col = s:Match(info.plnum_msl, s:ruby_indent_keywords)
+  if col > 0
+    let ind = indent(info.plnum_msl) + info.sw
+    if s:Match(info.plnum_msl, s:end_end_regex)
+      let ind = ind - info.sw
+    elseif s:IsAssignment(getline(info.plnum_msl), col)
+      if g:ruby_indent_assignment_style == 'hanging'
+        " hanging indent
+        let ind = col + info.sw - 1
+      else
+        " align with variable
+        let ind = indent(info.plnum_msl) + info.sw
+      endif
+    endif
+    return ind
+  endif
+  return -1
+endfunction
+
+function! s:ContinuedHangingOperator(msl_info)
+  let info = a:msl_info
+
+  " If the previous line ended with [*+/.,-=], but wasn't a block ending or a
+  " closing bracket, indent one extra level.
+  if s:Match(info.plnum_msl, s:non_bracket_continuation_regex) && !s:Match(info.plnum_msl, '^\s*\([\])}]\|end\)')
+    if info.plnum_msl == info.plnum
+      let ind = indent(info.plnum_msl) + info.sw
+    else
+      let ind = indent(info.plnum_msl)
+    endif
+    return ind
+  endif
+
+  return -1
+endfunction
+
+" 4. Auxiliary Functions {{{1
 " ======================
 
 " Check if the character at lnum:col is inside a string, comment, or is ascii.
@@ -160,6 +672,10 @@ function s:IsInStringDelimiter(lnum, col)
   return synIDattr(synID(a:lnum, a:col, 1), 'name') == 'rubyStringDelimiter'
 endfunction
 
+function s:IsAssignment(str, pos)
+  return strpart(a:str, 0, a:pos - 1) =~ '=\s*$'
+endfunction
+
 " Find line above 'lnum' that isn't empty, in a comment, or in a string.
 function s:PrevNonBlankNonString(lnum)
   let in_block = 0
@@ -189,14 +705,23 @@ endfunction
 function s:GetMSL(lnum)
   " Start on the line we're at and use its indent.
   let msl = a:lnum
-  let msl_body = getline(msl)
   let lnum = s:PrevNonBlankNonString(a:lnum - 1)
   while lnum > 0
     " If we have a continuation line, or we're in a string, use line as MSL.
     " Otherwise, terminate search as we have found our MSL already.
     let line = getline(lnum)
 
-    if s:Match(msl, s:leading_operator_regex)
+    if !s:Match(msl, s:backslash_continuation_regex) &&
+          \ s:Match(lnum, s:backslash_continuation_regex)
+      " If the current line doesn't end in a backslash, but the previous one
+      " does, look for that line's msl
+      "
+      " Example:
+      "   foo = "bar" \
+      "     "baz"
+      "
+      let msl = lnum
+    elseif s:Match(msl, s:leading_operator_regex)
       " If the current line starts with a leading operator, keep its indent
       " and keep looking for an MSL.
       let msl = lnum
@@ -221,18 +746,30 @@ function s:GetMSL(lnum)
       "     three
       "
       let msl = lnum
+    elseif s:Match(lnum, s:dot_continuation_regex) &&
+          \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
+      " If the current line is a bracket continuation or a block-starter, but
+      " the previous is a dot, keep going to see if the previous line is the
+      " start of another continuation.
+      "
+      " Example:
+      "   parent.
+      "     method_call {
+      "     three
+      "
+      let msl = lnum
     elseif s:Match(lnum, s:non_bracket_continuation_regex) &&
           \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
       " If the current line is a bracket continuation or a block-starter, but
-      " the previous is a non-bracket one, keep going to see if the previous
-      " line is a part of another continuation.
+      " the previous is a non-bracket one, respect the previous' indentation,
+      " and stop here.
       "
       " Example:
       "   method_call one,
       "     two {
       "     three
       "
-      let msl = lnum
+      return lnum
     elseif s:Match(lnum, s:bracket_continuation_regex) &&
           \ (s:Match(msl, s:bracket_continuation_regex) || s:Match(msl, s:block_continuation_regex))
       " If both lines are bracket continuations (the current may also be a
@@ -264,7 +801,6 @@ function s:GetMSL(lnum)
       endif
     endif
 
-    let msl_body = getline(msl)
     let lnum = s:PrevNonBlankNonString(lnum - 1)
   endwhile
   return msl
@@ -363,307 +899,12 @@ function! s:FindContainingClass()
       call setpos('.', saved_position)
       return found_lnum
     endif
-  endif
+  endwhile
 
   call setpos('.', saved_position)
   return 0
 endfunction
 
-" 3. GetRubyIndent Function {{{1
-" =========================
-
-function GetRubyIndent(...)
-  " 3.1. Setup {{{2
-  " ----------
-
-  " The value of a single shift-width
-  if exists('*shiftwidth')
-    let sw = shiftwidth()
-  else
-    let sw = &sw
-  endif
-
-  " For the current line, use the first argument if given, else v:lnum
-  let clnum = a:0 ? a:1 : v:lnum
-
-  " Set up variables for restoring position in file.  Could use clnum here.
-  let vcol = col('.')
-
-  " 3.2. Work on the current line {{{2
-  " -----------------------------
-
-  " Get the current line.
-  let line = getline(clnum)
-  let ind = -1
-
-  " If this line is an access modifier keyword, align according to the closest
-  " class declaration.
-  if g:ruby_indent_access_modifier_style == 'indent'
-    if s:Match(clnum, s:access_modifier_regex)
-      let class_line = s:FindContainingClass()
-      if class_line > 0
-        return indent(class_line) + sw
-      endif
-    endif
-  elseif g:ruby_indent_access_modifier_style == 'outdent'
-    if s:Match(clnum, s:access_modifier_regex)
-      let class_line = s:FindContainingClass()
-      if class_line > 0
-        return indent(class_line)
-      endif
-    endif
-  endif
-
-  " If we got a closing bracket on an empty line, find its match and indent
-  " according to it.  For parentheses we indent to its column - 1, for the
-  " others we indent to the containing line's MSL's level.  Return -1 if fail.
-  let col = matchend(line, '^\s*[]})]')
-  if col > 0 && !s:IsInStringOrComment(clnum, col)
-    call cursor(clnum, col)
-    let bs = strpart('(){}[]', stridx(')}]', line[col - 1]) * 2, 2)
-    if searchpair(escape(bs[0], '\['), '', bs[1], 'bW', s:skip_expr) > 0
-      if line[col-1]==')' && col('.') != col('$') - 1
-        let ind = virtcol('.') - 1
-      elseif g:ruby_indent_block_style == 'do'
-        let ind = indent(line('.'))
-      else " g:ruby_indent_block_style == 'expression'
-        let ind = indent(s:GetMSL(line('.')))
-      endif
-    endif
-    return ind
-  endif
-
-  " If we have a =begin or =end set indent to first column.
-  if match(line, '^\s*\%(=begin\|=end\)$') != -1
-    return 0
-  endif
-
-  " If we have a deindenting keyword, find its match and indent to its level.
-  " TODO: this is messy
-  if s:Match(clnum, s:ruby_deindent_keywords)
-    call cursor(clnum, 1)
-    if searchpair(s:end_start_regex, s:end_middle_regex, s:end_end_regex, 'bW',
-          \ s:end_skip_expr) > 0
-      let msl  = s:GetMSL(line('.'))
-      let line = getline(line('.'))
-
-      if strpart(line, 0, col('.') - 1) =~ '=\s*$' &&
-            \ strpart(line, col('.') - 1, 2) !~ 'do'
-        " assignment to case/begin/etc, on the same line, hanging indent
-        let ind = virtcol('.') - 1
-      elseif g:ruby_indent_block_style == 'do'
-        " align to line of the "do", not to the MSL
-        let ind = indent(line('.'))
-      elseif getline(msl) =~ '=\s*\(#.*\)\=$'
-        " in the case of assignment to the MSL, align to the starting line,
-        " not to the MSL
-        let ind = indent(line('.'))
-      else
-        " align to the MSL
-        let ind = indent(msl)
-      endif
-    endif
-    return ind
-  endif
-
-  " If we are in a multi-line string or line-comment, don't do anything to it.
-  if s:IsInStringOrDocumentation(clnum, matchend(line, '^\s*') + 1)
-    return indent('.')
-  endif
-
-  " If we are at the closing delimiter of a "<<" heredoc-style string, set the
-  " indent to 0.
-  if line =~ '^\k\+\s*$'
-        \ && s:IsInStringDelimiter(clnum, 1)
-        \ && search('\V<<'.line, 'nbW') > 0
-    return 0
-  endif
-
-  " If the current line starts with a leading operator, add a level of indent.
-  if s:Match(clnum, s:leading_operator_regex)
-    return indent(s:GetMSL(clnum)) + sw
-  endif
-
-  " 3.3. Work on the previous line. {{{2
-  " -------------------------------
-
-  " Find a non-blank, non-multi-line string line above the current line.
-  let lnum = s:PrevNonBlankNonString(clnum - 1)
-
-  " If the line is empty and inside a string, use the previous line.
-  if line =~ '^\s*$' && lnum != prevnonblank(clnum - 1)
-    return indent(prevnonblank(clnum))
-  endif
-
-  " At the start of the file use zero indent.
-  if lnum == 0
-    return 0
-  endif
-
-  " Set up variables for the previous line.
-  let line = getline(lnum)
-  let ind = indent(lnum)
-
-  if g:ruby_indent_access_modifier_style == 'indent'
-    " If the previous line was a private/protected keyword, add a
-    " level of indent.
-    if s:Match(lnum, s:indent_access_modifier_regex)
-      return indent(lnum) + sw
-    endif
-  elseif g:ruby_indent_access_modifier_style == 'outdent'
-    " If the previous line was a private/protected/public keyword, add
-    " a level of indent, since the keyword has been out-dented.
-    if s:Match(lnum, s:access_modifier_regex)
-      return indent(lnum) + sw
-    endif
-  endif
-
-  if s:Match(lnum, s:continuable_regex) && s:Match(lnum, s:continuation_regex)
-    return indent(s:GetMSL(lnum)) + sw + sw
-  endif
-
-  " If the previous line ended with a block opening, add a level of indent.
-  if s:Match(lnum, s:block_regex)
-    let msl = s:GetMSL(lnum)
-
-    if g:ruby_indent_block_style == 'do'
-      " don't align to the msl, align to the "do"
-      let ind = indent(lnum) + sw
-    elseif getline(msl) =~ '=\s*\(#.*\)\=$'
-      " in the case of assignment to the msl, align to the starting line,
-      " not to the msl
-      let ind = indent(lnum) + sw
-    else
-      let ind = indent(msl) + sw
-    endif
-    return ind
-  endif
-
-  " If the previous line started with a leading operator, use its MSL's level
-  " of indent
-  if s:Match(lnum, s:leading_operator_regex)
-    return indent(s:GetMSL(lnum))
-  endif
-
-  " If the previous line ended with the "*" of a splat, add a level of indent
-  if line =~ s:splat_regex
-    return indent(lnum) + sw
-  endif
-
-  " If the previous line contained unclosed opening brackets and we are still
-  " in them, find the rightmost one and add indent depending on the bracket
-  " type.
-  "
-  " If it contained hanging closing brackets, find the rightmost one, find its
-  " match and indent according to that.
-  if line =~ '[[({]' || line =~ '[])}]\s*\%(#.*\)\=$'
-    let [opening, closing] = s:ExtraBrackets(lnum)
-
-    if opening.pos != -1
-      if opening.type == '(' && searchpair('(', '', ')', 'bW', s:skip_expr) > 0
-        if col('.') + 1 == col('$')
-          return ind + sw
-        else
-          return virtcol('.')
-        endif
-      else
-        let nonspace = matchend(line, '\S', opening.pos + 1) - 1
-        return nonspace > 0 ? nonspace : ind + sw
-      endif
-    elseif closing.pos != -1
-      call cursor(lnum, closing.pos + 1)
-      normal! %
-
-      if s:Match(line('.'), s:ruby_indent_keywords)
-        return indent('.') + sw
-      else
-        return indent(s:GetMSL(line('.')))
-      endif
-    else
-      call cursor(clnum, vcol)
-    end
-  endif
-
-  " If the previous line ended with an "end", match that "end"s beginning's
-  " indent.
-  let col = s:Match(lnum, '\%(^\|[^.:@$]\)\<end\>\s*\%(#.*\)\=$')
-  if col > 0
-    call cursor(lnum, col)
-    if searchpair(s:end_start_regex, '', s:end_end_regex, 'bW',
-          \ s:end_skip_expr) > 0
-      let n = line('.')
-      let ind = indent('.')
-      let msl = s:GetMSL(n)
-      if msl != n
-        let ind = indent(msl)
-      end
-      return ind
-    endif
-  end
-
-  let col = s:Match(lnum, s:ruby_indent_keywords)
-  if col > 0
-    call cursor(lnum, col)
-    let ind = virtcol('.') - 1 + sw
-    " TODO: make this better (we need to count them) (or, if a searchpair
-    " fails, we know that something is lacking an end and thus we indent a
-    " level
-    if s:Match(lnum, s:end_end_regex)
-      let ind = indent('.')
-    endif
-    return ind
-  endif
-
-  " 3.4. Work on the MSL line. {{{2
-  " --------------------------
-
-  " Set up variables to use and search for MSL to the previous line.
-  let p_lnum = lnum
-  let lnum = s:GetMSL(lnum)
-
-  " If the previous line wasn't a MSL.
-  if p_lnum != lnum
-    " If previous line ends bracket and begins non-bracket continuation decrease indent by 1.
-    if s:Match(p_lnum, s:bracket_switch_continuation_regex)
-      return ind - 1
-    " If previous line is a continuation return its indent.
-    " TODO: the || s:IsInString() thing worries me a bit.
-    elseif s:Match(p_lnum, s:non_bracket_continuation_regex) || s:IsInString(p_lnum,strlen(line))
-      return ind
-    endif
-  endif
-
-  " Set up more variables, now that we know we wasn't continuation bound.
-  let line = getline(lnum)
-  let msl_ind = indent(lnum)
-
-  " If the MSL line had an indenting keyword in it, add a level of indent.
-  " TODO: this does not take into account contrived things such as
-  " module Foo; class Bar; end
-  if s:Match(lnum, s:ruby_indent_keywords)
-    let ind = msl_ind + sw
-    if s:Match(lnum, s:end_end_regex)
-      let ind = ind - sw
-    endif
-    return ind
-  endif
-
-  " If the previous line ended with [*+/.,-=], but wasn't a block ending or a
-  " closing bracket, indent one extra level.
-  if s:Match(lnum, s:non_bracket_continuation_regex) && !s:Match(lnum, '^\s*\([\])}]\|end\)')
-    if lnum == p_lnum
-      let ind = msl_ind + sw
-    else
-      let ind = msl_ind
-    endif
-    return ind
-  endif
-
-  " }}}2
-
-  return ind
-endfunction
-
 " }}}1
 
 let &cpo = s:cpo_save

indent/rust.vim

@@ -3,7 +3,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'rust') == -1
 " Vim indent file
 " Language:         Rust
 " Author:           Chris Morgan <me@chrismorgan.info>
-" Last Change:      2014 Sep 13
+" Last Change:      2016 Jul 15
 
 " Only load this indent file when no other was loaded.
 if exists("b:did_indent")
@@ -134,6 +134,7 @@ function GetRustIndent(lnum)
 				\ && s:get_line_trimmed(a:lnum) !~ '^\s*[\[\]{}]'
 				\ && prevline !~ '^\s*fn\s'
 				\ && prevline !~ '([^()]\+,$'
+				\ && s:get_line_trimmed(a:lnum) !~ '^\s*\S\+\s*=>'
 		" Oh ho! The previous line ended in a comma! I bet cindent will try to
 		" take this too far... For now, let's normally use the previous line's
 		" indent.
@@ -158,6 +159,8 @@ function GetRustIndent(lnum)
 		" if baz && (foo ||
 		"            bar) {
 		"
+		" Another case is when the current line is a new match arm.
+		"
 		" There are probably other cases where we don't want to do this as
 		" well. Add them as needed.
 		return indent(prevlinenum)

indent/sass.vim

@@ -1,42 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haml') == -1
-  
-" Vim indent file
-" Language:	Sass
-" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2010 May 21
-
-if exists("b:did_indent")
-  finish
-endif
-let b:did_indent = 1
-
-setlocal autoindent sw=2 et
-setlocal indentexpr=GetSassIndent()
-setlocal indentkeys=o,O,*<Return>,<:>,!^F
-
-" Only define the function once.
-if exists("*GetSassIndent")
-  finish
-endif
-
-let s:property = '^\s*:\|^\s*[[:alnum:]#{}-]\+\%(:\|\s*=\)'
-let s:extend = '^\s*\%(@extend\|@include\|+\)'
-
-function! GetSassIndent()
-  let lnum = prevnonblank(v:lnum-1)
-  let line = substitute(getline(lnum),'\s\+$','','')
-  let cline = substitute(substitute(getline(v:lnum),'\s\+$','',''),'^\s\+','','')
-  let lastcol = strlen(line)
-  let line = substitute(line,'^\s\+','','')
-  let indent = indent(lnum)
-  let cindent = indent(v:lnum)
-  if line !~ s:property && line !~ s:extend && cline =~ s:property
-    return indent + (exists('*shiftwidth') ? shiftwidth() : &sw)
-  else
-    return -1
-  endif
-endfunction
-
-" vim:set sw=2:
-
-endif

indent/scala.vim

@@ -378,12 +378,17 @@ function! GetScalaIndent()
   let prevline = scala#GetLine(prevlnum)
   let curlnum = v:lnum
   let curline = scala#GetLine(curlnum)
+  if get(g:, 'scala_scaladoc_indent', 0)
+    let star_indent = 2
+  else
+    let star_indent = 1
+  end
 
   if prevline =~ '^\s*/\*\*'
     if prevline =~ '\*/\s*$'
       return ind
     else
-      return ind + 1
+      return ind + star_indent
     endif
   endif
 
@@ -538,7 +543,7 @@ function! GetScalaIndent()
   if prevline =~ '^\s*\*/'
    \ || prevline =~ '*/\s*$'
     call scala#ConditionalConfirm("18")
-    let ind = ind - 1
+    let ind = ind - star_indent
   endif
 
   if scala#LineEndsInIncomplete(prevline)

indent/scss.vim

@@ -1,16 +0,0 @@
-if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'haml') == -1
-  
-" Vim indent file
-" Language:	SCSS
-" Maintainer:	Tim Pope <vimNOSPAM@tpope.org>
-" Last Change:	2010 Jul 26
-
-if exists("b:did_indent")
-  finish
-endif
-
-runtime! indent/css.vim
-
-" vim:set sw=2:
-
-endif

indent/terraform.vim

@@ -0,0 +1,48 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'terraform') == -1
+  
+if exists("b:did_indent")
+  finish
+endif
+
+let b:did_indent = 1
+
+setlocal nolisp
+setlocal autoindent
+setlocal indentexpr=TerraformIndent(v:lnum)
+setlocal indentkeys+=<:>,0=},0=)
+
+if exists("*TerraformIndent")
+  finish
+endif
+
+function! TerraformIndent(lnum)
+  " previous non-blank line
+  let prevlnum = prevnonblank(a:lnum-1)
+
+  " beginning of file?
+  if prevlnum == 0
+    return 0
+  endif
+
+  " previous line without comments
+  let prevline = substitute(getline(prevlnum), '//.*$', '', '')
+  let previndent = indent(prevlnum)
+  let thisindent = previndent
+
+  " block open?
+  if prevline =~ '[\[{]\s*$'
+    let thisindent += &sw
+  endif
+
+  " current line without comments
+  let thisline = substitute(getline(a:lnum), '//.*$', '', '')
+
+  " block close?
+  if thisline =~ '^\s*[\]}]'
+    let thisindent -= &sw
+  endif
+
+  return thisindent
+endfunction
+
+endif

indent/twig.vim

@@ -0,0 +1,80 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'twig') == -1
+  
+if exists("b:ran_once")
+	finish
+endif
+
+let b:ran_once = 1
+
+let s:baseIndentExpr=&indentexpr
+setlocal indentexpr=GetTwigIndent(v:lnum)
+
+fun! GetTwigIndent(currentLineNumber)
+	let currentLine = getline(a:currentLineNumber)
+	let previousLineNumber = prevnonblank(a:currentLineNumber - 1)
+	let previousLine = getline(previousLineNumber)
+
+	if (previousLine =~ s:startStructures || previousLine =~ s:middleStructures) && (currentLine !~ s:endStructures && currentLine !~ s:middleStructures)
+		return indent(previousLineNumber) + &shiftwidth
+	elseif currentLine =~ s:endStructures || currentLine =~ s:middleStructures
+		let previousOpenStructureNumber = s:FindPreviousOpenStructure(a:currentLineNumber)
+		let previousOpenStructureLine = getline(previousOpenStructureNumber)
+		return indent(previousOpenStructureNumber)
+	endif
+
+    return s:CallBaseIndent()
+endf
+
+function! s:CallBaseIndent()
+    exe 'redir => s:outputOfBaseIndent'
+    exe 'silent echo ' . s:baseIndentExpr
+    exe 'redir END'
+    return split(s:outputOfBaseIndent)[0]
+endf
+
+
+function! s:FindPreviousOpenStructure(lineNumber)
+	let countOpen = 0
+	let countClosed = 0
+	let lineNumber = a:lineNumber
+	while lineNumber != 1 && countOpen <= countClosed
+		let lineNumber -= 1
+		let currentLine = getline(lineNumber)
+
+		if currentLine =~ s:startStructures
+			let countOpen += 1
+		elseif currentLine =~ s:endStructures
+			let countClosed += 1
+		endif
+	endwhile
+
+	return lineNumber
+endfunction
+
+function! s:StartStructure(name)
+	return '^\s*{%\s*' . a:name . '.*%}'
+endfunction
+
+function! s:EndStructure(name)
+	return '^\s*{%\s*end' . a:name . '.*%}'
+endfunction
+
+function! s:Map(Fun, list)
+    if len(a:list) == 0
+        return []
+    else
+        return [a:Fun(a:list[0])] + s:Map(a:Fun, a:list[1:])
+    endif
+endfunction
+
+fun! s:BuildStructures()
+	let structures = ['if','for','block']
+	let mStructures = ['elseif','else']
+	let s:startStructures = join(s:Map(function('s:StartStructure'), structures), '\|')
+	let s:endStructures = join(s:Map(function('s:EndStructure'), structures), '\|')
+	let s:middleStructures = join(s:Map(function('s:StartStructure'), mStructures), '\|')
+endfun
+
+call s:BuildStructures()
+
+endif

indent/typescript.vim

@@ -2,504 +2,362 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'typescript') ==
   
 " Vim indent file
 " Language: Typescript
-" Acknowledgement: Based off of vim-ruby maintained by Nikolai Weibull http://vim-ruby.rubyforge.org
-
-" 0. Initialization {{{1
-" =================
+" Acknowledgement: Almost direct copy from https://github.com/pangloss/vim-javascript
 
 " Only load this indent file when no other was loaded.
-if exists("b:did_indent")
+if exists('b:did_indent') || get(g:, 'typescript_indent_disable', 0)
   finish
 endif
 let b:did_indent = 1
 
-setlocal nosmartindent
-
 " Now, set up our indentation expression and keys that trigger it.
 setlocal indentexpr=GetTypescriptIndent()
-setlocal formatexpr=Fixedgq(v:lnum,v:count)
-setlocal indentkeys=0{,0},0),0],0\,,!^F,o,O,e
+setlocal autoindent nolisp nosmartindent
+setlocal indentkeys+=0],0)
+
+let b:undo_indent = 'setlocal indentexpr< smartindent< autoindent< indentkeys<'
 
 " Only define the function once.
-if exists("*GetTypescriptIndent")
+if exists('*GetTypescriptIndent')
   finish
 endif
 
 let s:cpo_save = &cpo
 set cpo&vim
 
-" 1. Variables {{{1
-" ============
+" Get shiftwidth value
+if exists('*shiftwidth')
+  function s:sw()
+	return shiftwidth()
+  endfunction
+else
+  function s:sw()
+	return &sw
+  endfunction
+endif
 
-let s:ts_keywords = '^\s*\(break\|case\|catch\|continue\|debugger\|default\|delete\|do\|else\|finally\|for\|function\|if\|in\|instanceof\|new\|return\|switch\|this\|throw\|try\|typeof\|var\|void\|while\|with\)'
+" searchpair() wrapper
+if has('reltime')
+  function s:GetPair(start,end,flags,skip,time,...)
+	return searchpair('\m'.a:start,'','\m'.a:end,a:flags,a:skip,max([prevnonblank(v:lnum) - 2000,0] + a:000),a:time)
+  endfunction
+else
+  function s:GetPair(start,end,flags,skip,...)
+	return searchpair('\m'.a:start,'','\m'.a:end,a:flags,a:skip,max([prevnonblank(v:lnum) - 1000,get(a:000,1)]))
+  endfunction
+endif
 
 " Regex of syntax group names that are or delimit string or are comments.
-let s:syng_strcom = 'string\|regex\|comment\c'
-
-" Regex of syntax group names that are strings.
-let s:syng_string = 'regex\c'
-
-" Regex of syntax group names that are strings or documentation.
-let s:syng_multiline = 'comment\c'
-
-" Regex of syntax group names that are line comment.
-let s:syng_linecom = 'linecomment\c'
-
+let s:syng_strcom = 'string\|comment\|regex\|special\|doc\|template\%(braces\)\@!'
+let s:syng_str = 'string\|template\|special'
+let s:syng_com = 'comment\|doc'
 " Expression used to check whether we should skip a match with searchpair().
-let s:skip_expr = "synIDattr(synID(line('.'),col('.'),1),'name') =~ '".s:syng_strcom."'"
+let s:skip_expr = "synIDattr(synID(line('.'),col('.'),0),'name') =~? '".s:syng_strcom."'"
 
-let s:line_term = '\s*\%(\%(\/\/\).*\)\=$'
-
-" Regex that defines continuation lines, not including (, {, or [.
-let s:continuation_regex = '\%([\\*+/.:]\|\%(<%\)\@<![=-]\|\W[|&?]\|||\|&&\|[^=]=[^=].*,\)' . s:line_term
-
-" Regex that defines continuation lines.
-" TODO: this needs to deal with if ...: and so on
-let s:msl_regex = s:continuation_regex
-
-let s:one_line_scope_regex = '\<\%(if\|else\|for\|while\)\>[^{;]*' . s:line_term
-
-" Regex that defines blocks.
-let s:block_regex = '\%([{[]\)\s*\%(|\%([*@]\=\h\w*,\=\s*\)\%(,\s*[*@]\=\h\w*\)*|\)\=' . s:line_term
-
-let s:var_stmt = '^\s*var'
-
-let s:comma_first = '^\s*,'
-let s:comma_last = ',\s*$'
-
-let s:ternary = '^\s\+[?|:]'
-let s:ternary_q = '^\s\+?'
-
-" 2. Auxiliary Functions {{{1
-" ======================
-
-" Check if the character at lnum:col is inside a string, comment, or is ascii.
-function s:IsInStringOrComment(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_strcom
-endfunction
-
-" Check if the character at lnum:col is inside a string.
-function s:IsInString(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_string
-endfunction
-
-" Check if the character at lnum:col is inside a multi-line comment.
-function s:IsInMultilineComment(lnum, col)
-  return !s:IsLineComment(a:lnum, a:col) && synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_multiline
-endfunction
-
-" Check if the character at lnum:col is a line comment.
-function s:IsLineComment(lnum, col)
-  return synIDattr(synID(a:lnum, a:col, 1), 'name') =~ s:syng_linecom
-endfunction
-
-" Find line above 'lnum' that isn't empty, in a comment, or in a string.
-function s:PrevNonBlankNonString(lnum)
-  let in_block = 0
-  let lnum = prevnonblank(a:lnum)
-  while lnum > 0
-    " Go in and out of blocks comments as necessary.
-    " If the line isn't empty (with opt. comment) or in a string, end search.
-    let line = getline(lnum)
-    if line =~ '/\*'
-      if in_block
-        let in_block = 0
-      else
-        break
-      endif
-    elseif !in_block && line =~ '\*/'
-      let in_block = 1
-    elseif !in_block && line !~ '^\s*\%(//\).*$' && !(s:IsInStringOrComment(lnum, 1) && s:IsInStringOrComment(lnum, strlen(line)))
-      break
-    endif
-    let lnum = prevnonblank(lnum - 1)
-  endwhile
-  return lnum
-endfunction
-
-" Find line above 'lnum' that started the continuation 'lnum' may be part of.
-function s:GetMSL(lnum, in_one_line_scope)
-  " Start on the line we're at and use its indent.
-  let msl = a:lnum
-  let lnum = s:PrevNonBlankNonString(a:lnum - 1)
-  while lnum > 0
-    " If we have a continuation line, or we're in a string, use line as MSL.
-    " Otherwise, terminate search as we have found our MSL already.
-    let line = getline(lnum)
-    let col = match(line, s:msl_regex) + 1
-    if (col > 0 && !s:IsInStringOrComment(lnum, col)) || s:IsInString(lnum, strlen(line))
-      let msl = lnum
-    else
-      " Don't use lines that are part of a one line scope as msl unless the
-      " flag in_one_line_scope is set to 1
-      "
-      if a:in_one_line_scope
-        break
-      end
-      let msl_one_line = s:Match(lnum, s:one_line_scope_regex)
-      if msl_one_line == 0
-        break
-      endif
-    endif
-    let lnum = s:PrevNonBlankNonString(lnum - 1)
-  endwhile
-  return msl
-endfunction
-
-function s:RemoveTrailingComments(content)
-  let single = '\/\/\(.*\)\s*$'
-  let multi = '\/\*\(.*\)\*\/\s*$'
-  return substitute(substitute(a:content, single, '', ''), multi, '', '')
-endfunction
-
-" Find if the string is inside var statement (but not the first string)
-function s:InMultiVarStatement(lnum)
-  let lnum = s:PrevNonBlankNonString(a:lnum - 1)
-
-"  let type = synIDattr(synID(lnum, indent(lnum) + 1, 0), 'name')
-
-  " loop through previous expressions to find a var statement
-  while lnum > 0
-    let line = getline(lnum)
-
-    " if the line is a ts keyword
-    if (line =~ s:ts_keywords)
-      " check if the line is a var stmt
-      " if the line has a comma first or comma last then we can assume that we
-      " are in a multiple var statement
-      if (line =~ s:var_stmt)
-        return lnum
-      endif
-
-      " other ts keywords, not a var
-      return 0
-    endif
-
-    let lnum = s:PrevNonBlankNonString(lnum - 1)
-  endwhile
-
-  " beginning of program, not a var
-  return 0
-endfunction
-
-" Find line above with beginning of the var statement or returns 0 if it's not
-" this statement
-function s:GetVarIndent(lnum)
-  let lvar = s:InMultiVarStatement(a:lnum)
-  let prev_lnum = s:PrevNonBlankNonString(a:lnum - 1)
-
-  if lvar
-    let line = s:RemoveTrailingComments(getline(prev_lnum))
-
-    " if the previous line doesn't end in a comma, return to regular indent
-    if (line !~ s:comma_last)
-      return indent(prev_lnum) - &sw
-    else
-      return indent(lvar) + &sw
-    endif
+function s:skip_func()
+  if !s:free || search('\m`\|\${\|\*\/','nW',s:looksyn)
+	let s:free = !eval(s:skip_expr)
+	let s:looksyn = line('.')
+	return !s:free
   endif
-
-  return -1
+  let s:looksyn = line('.')
+  return getline('.') =~ '\%<'.col('.').'c\/.\{-}\/\|\%>'.col('.').'c[''"]\|\\$' &&
+		\ eval(s:skip_expr)
 endfunction
 
+function s:alternatePair(stop)
+  let pos = getpos('.')[1:2]
+  while search('\m[][(){}]','bW',a:stop)
+	if !s:skip_func()
+	  let idx = stridx('])}',s:looking_at())
+	  if idx + 1
+		if s:GetPair(['\[','(','{'][idx], '])}'[idx],'bW','s:skip_func()',2000,a:stop) <= 0
+		  break
+		endif
+	  else
+		return
+	  endif
+	endif
+  endwhile
+  call call('cursor',pos)
+endfunction
 
-" Check if line 'lnum' has more opening brackets than closing ones.
-function s:LineHasOpeningBrackets(lnum)
-  let open_0 = 0
-  let open_2 = 0
-  let open_4 = 0
-  let line = getline(a:lnum)
-  let pos = match(line, '[][(){}]', 0)
+function s:save_pos(f,...)
+  let l:pos = getpos('.')[1:2]
+  let ret = call(a:f,a:000)
+  call call('cursor',l:pos)
+  return ret
+endfunction
+
+function s:syn_at(l,c)
+  return synIDattr(synID(a:l,a:c,0),'name')
+endfunction
+
+function s:looking_at()
+  return getline('.')[col('.')-1]
+endfunction
+
+function s:token()
+  return s:looking_at() =~ '\k' ? expand('<cword>') : s:looking_at()
+endfunction
+
+function s:previous_token()
+  let l:n = line('.')
+  if (s:looking_at() !~ '\k' || search('\m\<','cbW')) && search('\m\S','bW')
+	if (getline('.')[col('.')-2:col('.')-1] == '*/' || line('.') != l:n &&
+		  \ getline('.') =~ '\%<'.col('.').'c\/\/') && s:syn_at(line('.'),col('.')) =~? s:syng_com
+	  while search('\m\/\ze[/*]','cbW')
+		if !search('\m\S','bW')
+		  break
+		elseif s:syn_at(line('.'),col('.')) !~? s:syng_com
+		  return s:token()
+		endif
+	  endwhile
+	else
+	  return s:token()
+	endif
+  endif
+  return ''
+endfunction
+
+function s:others(p)
+  return "((line2byte(line('.')) + col('.')) <= ".(line2byte(a:p[0]) + a:p[1]).") || ".s:skip_expr
+endfunction
+
+function s:tern_skip(p)
+  return s:GetPair('{','}','nbW',s:others(a:p),200,a:p[0]) > 0
+endfunction
+
+function s:tern_col(p)
+  return s:GetPair('?',':\@<!::\@!','nbW',s:others(a:p)
+		\ .' || s:tern_skip('.string(a:p).')',200,a:p[0]) > 0
+endfunction
+
+function s:label_col()
+  let pos = getpos('.')[1:2]
+  let [s:looksyn,s:free] = pos
+  call s:alternatePair(0)
+  if s:save_pos('s:IsBlock')
+	let poss = getpos('.')[1:2]
+	return call('cursor',pos) || !s:tern_col(poss)
+  elseif s:looking_at() == ':'
+	return !s:tern_col([0,0])
+  endif
+endfunction
+
+" configurable regexes that define continuation lines, not including (, {, or [.
+let s:opfirst = '^' . get(g:,'typescript_opfirst',
+	  \ '\%([<>=,?^%|*/&]\|\([-.:+]\)\1\@!\|!=\|in\%(stanceof\)\=\>\)')
+let s:continuation = get(g:,'typescript_continuation',
+	  \ '\%([-+<>=,.~!?/*^%|&:]\|\<\%(typeof\|delete\|void\|in\|instanceof\)\)') . '$'
+
+function s:continues(ln,con)
+  return !cursor(a:ln, match(' '.a:con,s:continuation)) &&
+		\ eval( (['s:syn_at(line("."),col(".")) !~? "regex"'] +
+		\ repeat(['getline(".")[col(".")-2] != tr(s:looking_at(),">","=")'],3) +
+		\ repeat(['s:previous_token() != "."'],5) + [1])[
+		\ index(split('/ > - + typeof in instanceof void delete'),s:token())])
+endfunction
+
+" get the line of code stripped of comments and move cursor to the last
+" non-comment char.
+function s:Trim(ln)
+  call cursor(a:ln+1,1)
+  call s:previous_token()
+  return strpart(getline('.'),0,col('.'))
+endfunction
+
+" Find line above 'lnum' that isn't empty or in a comment
+function s:PrevCodeLine(lnum)
+  let l:n = prevnonblank(a:lnum)
+  while l:n
+	if getline(l:n) =~ '^\s*\/[/*]' 
+	  if (stridx(getline(l:n),'`') > 0 || getline(l:n-1)[-1:] == '\') &&
+			\ s:syn_at(l:n,1) =~? s:syng_str
+		return l:n
+	  endif
+	  let l:n = prevnonblank(l:n-1)
+	elseif getline(l:n) =~ '\([/*]\)\1\@![/*]' && s:syn_at(l:n,1) =~? s:syng_com
+	  let l:n = s:save_pos('eval',
+			\ 'cursor('.l:n.',1) + search(''\m\/\*'',"bW")')
+	else
+	  return l:n
+	endif
+  endwhile
+endfunction
+
+" Check if line 'lnum' has a balanced amount of parentheses.
+function s:Balanced(lnum)
+  let l:open = 0
+  let l:line = getline(a:lnum)
+  let pos = match(l:line, '[][(){}]', 0)
   while pos != -1
-    if !s:IsInStringOrComment(a:lnum, pos + 1)
-      let idx = stridx('(){}[]', line[pos])
-      if idx % 2 == 0
-        let open_{idx} = open_{idx} + 1
-      else
-        let open_{idx - 1} = open_{idx - 1} - 1
-      endif
-    endif
-    let pos = match(line, '[][(){}]', pos + 1)
+	if s:syn_at(a:lnum,pos + 1) !~? s:syng_strcom
+	  let l:open += match(' ' . l:line[pos],'[[({]')
+	  if l:open < 0
+		return
+	  endif
+	endif
+	let pos = match(l:line, '[][(){}]', pos + 1)
   endwhile
-  return (open_0 > 0) . (open_2 > 0) . (open_4 > 0)
+  return !l:open
 endfunction
 
-function s:Match(lnum, regex)
-  let col = match(getline(a:lnum), a:regex) + 1
-  return col > 0 && !s:IsInStringOrComment(a:lnum, col) ? col : 0
-endfunction
-
-function s:IndentWithContinuation(lnum, ind, width)
-  " Set up variables to use and search for MSL to the previous line.
-  let p_lnum = a:lnum
-  let lnum = s:GetMSL(a:lnum, 1)
-  let line = getline(lnum)
-
-  " If the previous line wasn't a MSL and is continuation return its indent.
-  " TODO: the || s:IsInString() thing worries me a bit.
-  if p_lnum != lnum
-    if s:Match(p_lnum,s:continuation_regex)||s:IsInString(p_lnum,strlen(line))
-      return a:ind
-    endif
+function s:OneScope(lnum)
+  let pline = s:Trim(a:lnum)
+  let kw = 'else do'
+  if pline[-1:] == ')' && s:GetPair('(', ')', 'bW', s:skip_expr, 100) > 0
+	call s:previous_token()
+	let kw = 'for if let while with'
+	if index(split('await each'),s:token()) + 1
+	  call s:previous_token()
+	  let kw = 'for'
+	endif
   endif
-
-  " Set up more variables now that we know we aren't continuation bound.
-  let msl_ind = indent(lnum)
-
-  " If the previous line ended with [*+/.-=], start a continuation that
-  " indents an extra level.
-  if s:Match(lnum, s:continuation_regex)
-    if lnum == p_lnum
-      return msl_ind + a:width
-    else
-      return msl_ind
-    endif
-  endif
-
-  return a:ind
+  return pline[-2:] == '=>' || index(split(kw),s:token()) + 1 &&
+		\ s:save_pos('s:previous_token') != '.'
 endfunction
 
-function s:InOneLineScope(lnum)
-  let msl = s:GetMSL(a:lnum, 1)
-  if msl > 0 && s:Match(msl, s:one_line_scope_regex)
-    return msl
-  endif
-  return 0
+" returns braceless levels started by 'i' and above lines * &sw. 'num' is the
+" lineNr which encloses the entire context, 'cont' if whether line 'i' + 1 is
+" a continued expression, which could have started in a braceless context
+function s:iscontOne(i,num,cont)
+  let [l:i, l:num, bL] = [a:i, a:num + !a:num, 0]
+  let pind = a:num ? indent(l:num) + s:W : 0
+  let ind = indent(l:i) + (a:cont ? 0 : s:W)
+  while l:i >= l:num && (ind > pind || l:i == l:num)
+	if indent(l:i) < ind && s:OneScope(l:i)
+	  let bL += s:W
+	  let l:i = line('.')
+	elseif !a:cont || bL || ind < indent(a:i)
+	  break
+	endif
+	let ind = min([ind, indent(l:i)])
+	let l:i = s:PrevCodeLine(l:i - 1)
+  endwhile
+  return bL
 endfunction
 
-function s:ExitingOneLineScope(lnum)
-  let msl = s:GetMSL(a:lnum, 1)
-  if msl > 0
-    " if the current line is in a one line scope ..
-    if s:Match(msl, s:one_line_scope_regex)
-      return 0
-    else
-      let prev_msl = s:GetMSL(msl - 1, 1)
-      if s:Match(prev_msl, s:one_line_scope_regex)
-        return prev_msl
-      endif
-    endif
+" https://github.com/sweet-js/sweet.js/wiki/design#give-lookbehind-to-the-reader
+function s:IsBlock()
+  if s:looking_at() == '{'
+	let l:n = line('.')
+	let char = s:previous_token()
+	if match(s:stack,'xml\|jsx') + 1 && s:syn_at(line('.'),col('.')-1) =~? 'xml\|jsx'
+	  return char != '{'
+	elseif char =~ '\k'
+	  return index(split('return const let import export yield default delete var await void typeof throw case new in instanceof')
+			\ ,char) < (line('.') != l:n) || s:previous_token() == '.'
+	elseif char == '>'
+	  return getline('.')[col('.')-2] == '=' || s:syn_at(line('.'),col('.')) =~? '^jsflow'
+	elseif char == ':'
+	  return getline('.')[col('.')-2] != ':' && s:label_col()
+	elseif char == '/'
+	  return s:syn_at(line('.'),col('.')) =~? 'regex'
+	endif
+	return char !~ '[=~!<*,?^%|&([]' &&
+		  \ (char !~ '[-+]' || l:n != line('.') && getline('.')[col('.')-2] == char)
   endif
-  return 0
 endfunction
 
-" 3. GetTypescriptIndent Function {{{1
-" =========================
-
 function GetTypescriptIndent()
-  " 3.1. Setup {{{2
-  " ----------
-
-  " Set up variables for restoring position in file.  Could use v:lnum here.
-  let vcol = col('.')
-
-  " 3.2. Work on the current line {{{2
-  " -----------------------------
-
-  let ind = -1
+  let b:js_cache = get(b:,'js_cache',[0,0,0])
   " Get the current line.
-  let line = getline(v:lnum)
-  " previous nonblank line number
-  let prevline = prevnonblank(v:lnum - 1)
+  call cursor(v:lnum,1)
+  let l:line = getline('.')
+  " use synstack as it validates syn state and works in an empty line
+  let s:stack = synstack(v:lnum,1)
+  let syns = synIDattr(get(s:stack,-1),'name')
 
-  " If we got a closing bracket on an empty line, find its match and indent
-  " according to it.  For parentheses we indent to its column - 1, for the
-  " others we indent to the containing line's MSL's level.  Return -1 if fail.
-  let col = matchend(line, '^\s*[],})]')
-  if col > 0 && !s:IsInStringOrComment(v:lnum, col)
-    call cursor(v:lnum, col)
-
-    let lvar = s:InMultiVarStatement(v:lnum)
-    if lvar
-      let prevline_contents = s:RemoveTrailingComments(getline(prevline))
-
-      " check for comma first
-      if (line[col - 1] =~ ',')
-        " if the previous line ends in comma or semicolon don't indent
-        if (prevline_contents =~ '[;,]\s*$')
-          return indent(s:GetMSL(line('.'), 0))
-        " get previous line indent, if it's comma first return prevline indent
-        elseif (prevline_contents =~ s:comma_first)
-          return indent(prevline)
-        " otherwise we indent 1 level
-        else
-          return indent(lvar) + &sw
-        endif
-      endif
-    endif
-
-
-    let bs = strpart('(){}[]', stridx(')}]', line[col - 1]) * 2, 2)
-    if searchpair(escape(bs[0], '\['), '', bs[1], 'bW', s:skip_expr) > 0
-      if line[col-1]==')' && col('.') != col('$') - 1
-        let ind = virtcol('.')-1
-      else
-        let ind = indent(s:GetMSL(line('.'), 0))
-      endif
-    endif
-    return ind
+  " start with strings,comments,etc.
+  if syns =~? s:syng_com
+	if l:line =~ '^\s*\*'
+	  return cindent(v:lnum)
+	elseif l:line !~ '^\s*\/[/*]'
+	  return -1
+	endif
+  elseif syns =~? s:syng_str && l:line !~ '^[''"]'
+	if b:js_cache[0] == v:lnum - 1 && s:Balanced(v:lnum-1)
+	  let b:js_cache[0] = v:lnum
+	endif
+	return -1
+  endif
+  let l:lnum = s:PrevCodeLine(v:lnum - 1)
+  if !l:lnum
+	return
   endif
 
-  " If the line is comma first, dedent 1 level
-  if (getline(prevline) =~ s:comma_first)
-    return indent(prevline) - &sw
+  let l:line = substitute(l:line,'^\s*','','')
+  if l:line[:1] == '/*'
+	let l:line = substitute(l:line,'^\%(\/\*.\{-}\*\/\s*\)*','','')
+  endif
+  if l:line =~ '^\/[/*]'
+	let l:line = ''
   endif
 
-  if (line =~ s:ternary)
-    if (getline(prevline) =~ s:ternary_q)
-      return indent(prevline)
-    else
-      return indent(prevline) + &sw
-    endif
-  endif
-
-  " If we are in a multi-line comment, cindent does the right thing.
-  if s:IsInMultilineComment(v:lnum, 1) && !s:IsLineComment(v:lnum, 1)
-    return cindent(v:lnum)
-  endif
-
-  " Check for multiple var assignments
-"  let var_indent = s:GetVarIndent(v:lnum)
-"  if var_indent >= 0
-"    return var_indent
-"  endif
-
-  " 3.3. Work on the previous line. {{{2
-  " -------------------------------
-
-  " If the line is empty and the previous nonblank line was a multi-line
-  " comment, use that comment's indent. Deduct one char to account for the
-  " space in ' */'.
-  if line =~ '^\s*$' && s:IsInMultilineComment(prevline, 1)
-    return indent(prevline) - 1
-  endif
-
-  " Find a non-blank, non-multi-line string line above the current line.
-  let lnum = s:PrevNonBlankNonString(v:lnum - 1)
-
-  " If the line is empty and inside a string, use the previous line.
-  if line =~ '^\s*$' && lnum != prevline
-    return indent(prevnonblank(v:lnum))
-  endif
-
-  " At the start of the file use zero indent.
-  if lnum == 0
-    return 0
-  endif
-
-  " Set up variables for current line.
-  let line = getline(lnum)
-  let ind = indent(lnum)
-
-  " If the previous line ended with a block opening, add a level of indent.
-  if s:Match(lnum, s:block_regex)
-    return indent(s:GetMSL(lnum, 0)) + &sw
-  endif
-
-  " If the previous line contained an opening bracket, and we are still in it,
-  " add indent depending on the bracket type.
-  if line =~ '[[({]'
-    let counts = s:LineHasOpeningBrackets(lnum)
-    if counts[0] == '1' && searchpair('(', '', ')', 'bW', s:skip_expr) > 0
-      if col('.') + 1 == col('$')
-        return ind + &sw
-      else
-        return virtcol('.')
-      endif
-    elseif counts[1] == '1' || counts[2] == '1'
-      return ind + &sw
-    else
-      call cursor(v:lnum, vcol)
-    end
-  endif
-
-  " 3.4. Work on the MSL line. {{{2
-  " --------------------------
-
-  let ind_con = ind
-  let ind = s:IndentWithContinuation(lnum, ind_con, &sw)
-
-  " }}}2
-  "
-  "
-  let ols = s:InOneLineScope(lnum)
-  if ols > 0
-    let ind = ind + &sw
+  " the containing paren, bracket, or curly. Many hacks for performance
+  let idx = index([']',')','}'],l:line[0])
+  if b:js_cache[0] >= l:lnum && b:js_cache[0] < v:lnum &&
+		\ (b:js_cache[0] > l:lnum || s:Balanced(l:lnum))
+	call call('cursor',b:js_cache[1:])
   else
-    let ols = s:ExitingOneLineScope(lnum)
-    while ols > 0 && ind > 0
-      let ind = ind - &sw
-      let ols = s:InOneLineScope(ols - 1)
-    endwhile
+	let [s:looksyn, s:free, top] = [v:lnum - 1, 1, (!indent(l:lnum) &&
+		  \ s:syn_at(l:lnum,1) !~? s:syng_str) * l:lnum]
+	if idx + 1
+	  call s:GetPair(['\[','(','{'][idx],'])}'[idx],'bW','s:skip_func()',2000,top)
+	elseif getline(v:lnum) !~ '^\S' && syns =~? 'block'
+	  call s:GetPair('{','}','bW','s:skip_func()',2000,top)
+	else
+	  call s:alternatePair(top)
+	endif
   endif
 
-  return ind
-endfunction
+  let b:js_cache = [v:lnum] + (line('.') == v:lnum ? [0,0] : getpos('.')[1:2])
+  let num = b:js_cache[1]
 
-" }}}1
+  let [s:W, isOp, bL, switch_offset] = [s:sw(),0,0,0]
+  if !num || s:IsBlock()
+	let ilnum = line('.')
+	let pline = s:save_pos('s:Trim',l:lnum)
+	if num && s:looking_at() == ')' && s:GetPair('(', ')', 'bW', s:skip_expr, 100) > 0
+	  let num = ilnum == num ? line('.') : num
+	  if idx < 0 && s:previous_token() ==# 'switch' && s:previous_token() != '.'
+		if &cino !~ ':'
+		  let switch_offset = s:W
+		else
+		  let cinc = matchlist(&cino,'.*:\zs\(-\)\=\(\d*\)\(\.\d\+\)\=\(s\)\=\C')
+		  let switch_offset = max([cinc[0] is '' ? 0 : (cinc[1].1) *
+				\ ((strlen(cinc[2].cinc[3]) ? str2nr(cinc[2].str2nr(cinc[3][1])) : 10) *
+				\ (cinc[4] is '' ? 1 : s:W)) / 10, -indent(num)])
+		endif
+		if pline[-1:] != '.' && l:line =~# '^\%(default\|case\)\>'
+		  return indent(num) + switch_offset
+		endif
+	  endif
+	endif
+	if idx < 0 && pline !~ '[{;]$'
+	  if pline =~# ':\@<!:$'
+		call cursor(l:lnum,strlen(pline))
+		let isOp = s:tern_col(b:js_cache[1:2]) * s:W
+	  else
+		let isOp = (l:line =~# s:opfirst || s:continues(l:lnum,pline)) * s:W
+	  endif
+	  let bL = s:iscontOne(l:lnum,b:js_cache[1],isOp)
+	  let bL -= (bL && l:line[0] == '{') * s:W
+	endif
+  endif
+
+  " main return
+  if idx + 1 || l:line[:1] == '|}'
+	return indent(num)
+  elseif num
+	return indent(num) + s:W + switch_offset + bL + isOp
+  endif
+  return bL + isOp
+endfunction
 
 let &cpo = s:cpo_save
 unlet s:cpo_save
 
-function! Fixedgq(lnum, count)
-    let l:tw = &tw ? &tw : 80
-
-    let l:count = a:count
-    let l:first_char = indent(a:lnum) + 1
-
-    if mode() == 'i' " gq was not pressed, but tw was set
-        return 1
-    endif
-
-    " This gq is only meant to do code with strings, not comments
-    if s:IsLineComment(a:lnum, l:first_char) || s:IsInMultilineComment(a:lnum, l:first_char)
-        return 1
-    endif
-
-    if len(getline(a:lnum)) < l:tw && l:count == 1 " No need for gq
-        return 1
-    endif
-
-    " Put all the lines on one line and do normal spliting after that
-    if l:count > 1
-        while l:count > 1
-            let l:count -= 1
-            normal J
-        endwhile
-    endif
-
-    let l:winview = winsaveview()
-
-    call cursor(a:lnum, l:tw + 1)
-    let orig_breakpoint = searchpairpos(' ', '', '\.', 'bcW', '', a:lnum)
-    call cursor(a:lnum, l:tw + 1)
-    let breakpoint = searchpairpos(' ', '', '\.', 'bcW', s:skip_expr, a:lnum)
-
-    " No need for special treatment, normal gq handles edgecases better
-    if breakpoint[1] == orig_breakpoint[1]
-        call winrestview(l:winview)
-        return 1
-    endif
-
-    " Try breaking after string
-    if breakpoint[1] <= indent(a:lnum)
-        call cursor(a:lnum, l:tw + 1)
-        let breakpoint = searchpairpos('\.', '', ' ', 'cW', s:skip_expr, a:lnum)
-    endif
-
-
-    if breakpoint[1] != 0
-        call feedkeys("r\<CR>")
-    else
-        let l:count = l:count - 1
-    endif
-
-    " run gq on new lines
-    if l:count == 1
-        call feedkeys("gqq")
-    endif
-
-    return 0
-endfunction
 
 endif

indent/vala.vim

@@ -1,36 +1,87 @@
 if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vala') == -1
   
-" Copyright (c) 2012 Takezoe Tomoaki <tkztmk@outlook.com>
-"
-" 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.
+" Vim indent file
+" Language:         Vala
+" Author:           Adrià Arrufat <adria.arrufat@protonmail.ch>
+" Last Change:      2016 Dec 04
 
-" Vim indent file for Vala. 
-" It just sets cindent for Vala files...
+" Only load this indent file when no other was loaded.
 if exists("b:did_indent")
   finish
 endif
 let b:did_indent = 1
-setl cin
-let b:undo_indent = "setl cin<"
 
+setlocal cindent
+setlocal cinoptions=L0,(0,Ws,J1,j1
+setlocal cinkeys=0{,0},!^F,o,O,0[,0]
+
+" Some preliminary settings
+setlocal nolisp		" Make sure lisp indenting doesn't supersede us
+setlocal autoindent	" indentexpr isn't much help otherwise
+
+setlocal indentexpr=GetValaIndent(v:lnum)
+
+" Only define the function once.
+if exists("*GetValaIndent")
+  finish
+endif
+
+" Come here when loading the script the first time.
+
+function GetValaIndent(lnum)
+
+	" Hit the start of the file, use zero indent.
+	if a:lnum == 0
+		return 0
+	endif
+
+	" Starting assumption: cindent (called at the end) will do it right
+	" normally. We just want to fix up a few cases.
+
+	let line = getline(a:lnum)
+	" Search backwards for the previous non-empty line.
+	let prevlinenum = prevnonblank(a:lnum - 1)
+	let prevline = getline(prevlinenum)
+	while prevlinenum > 1 && prevline !~ '[^[:blank:]]'
+		let prevlinenum = prevnonblank(prevlinenum - 1)
+		let prevline = s:getline(prevlinenum)
+	endwhile
+
+	" If previous line contains a code attribute (e.g. [CCode (...)])
+	" don't increase the indentation
+	if prevline =~? '^\s*\[[A-Za-z]' && prevline =~? '\]$'
+		return indent(prevlinenum)
+	endif
+
+	" cindent gets lambda body wrong, as it treats the comma as indicating an
+	" unfinished statement (fix borrowed from rust.vim indent file):
+	"
+	" list.foreach ((entry) => {
+	"		stdout.puts (entry);
+	"		stdout.putc ('\n');
+	"		if (entry == null) {
+	" 		print ("empty entry\n");
+	"		}
+	" });
+	"
+	" and we want it to be:
+	" list.foreach ((entry) => {
+	"	stdout.puts (entry);
+	"	stdout.putc ('\n');
+	" 	if (entry == null) {
+	" 		print ("empty entry\n");
+	" 	}
+	" });
+
+	if prevline[len(prevline) - 1] == ","
+				\ && line !~ '^\s*[\[\]{}]'
+				\ && prevline !~ '([^()]\+,$'
+				\ && line !~ '^\s*\S\+\s*=>'
+		return indent(prevlinenum)
+	endif
+
+	" Fall back on cindent, which does it mostly right
+	return cindent(a:lnum)
+endfunction
 
 endif

indent/vue.vim

@@ -0,0 +1,45 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'vue') == -1
+  
+" Vim indent file
+" Language: Vue.js
+" Maintainer: Eduardo San Martin Morote
+" Author: Adriaan Zonnenberg
+
+if exists("b:did_indent")
+  finish
+endif
+
+" Load indent files for required languages
+for language in ['stylus', 'pug', 'css', 'javascript', 'html', 'coffee']
+  unlet! b:did_indent
+  exe "runtime! indent/".language.".vim"
+  exe "let s:".language."indent = &indentexpr"
+endfor
+
+let b:did_indent = 1
+
+setlocal indentexpr=GetVueIndent()
+
+if exists("*GetVueIndent")
+  finish
+endif
+
+function! GetVueIndent()
+  if searchpair('<template lang="pug"', '', '</template>', 'bWr')
+    exe "let indent = ".s:pugindent
+  elseif searchpair('<style lang="stylus"', '', '</style>', 'bWr')
+    exe "let indent = ".s:stylusindent
+  elseif searchpair('<style', '', '</style>', 'bWr')
+    exe "let indent = ".s:cssindent
+  elseif searchpair('<script lang="coffee"', '', '</script>', 'bWr')
+    exe "let indent = ".s:coffeeindent
+  elseif searchpair('<script', '', '</script>', 'bWr')
+    exe "let indent = ".s:javascriptindent
+  else
+    exe "let indent = ".s:htmlindent
+  endif
+
+  return indent > -1 ? indent : s:htmlindent
+endfunction
+
+endif

syntax/apiblueprint.vim

@@ -0,0 +1,38 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'apiblueprint') == -1
+  
+runtime! syntax/markdown.vim
+unlet! b:current_syntax
+
+" Metadata
+syntax region apibMarkdownMetadata start=/\%^.*:.*$/ end=/^$/ contains=apibMarkdownMetadataKey,apibMarkdownMetadataValue fold
+syntax match apibMarkdownMetadataKey /^[^:]*\ze:/ contained
+syntax match apibMarkdownMetadataValue /:.*/ contained
+
+syntax region apibHTTPStatusCode start=/\d\d\d/ end=// contained containedin=apibResponseSection
+syntax region apibHTTPContentType start=/(.*)/ end=// contained containedin=apibResponseSection
+
+syntax region apibModelSection start=/^+ Model/ end=/$/ oneline
+syntax region apibRequestSection start=/^[-+*] Request.*/ end=/^$/ contains=apibHTTPContentType
+syntax region apibResponseSection start=/^[-+*] Response \d\d\d/ end=/^$/ contains=apibHTTPStatusCode,apibHTTPContentType
+syntax region apibHeadersSection start=/^+ Headers$/ end=/^\S.*$/ contains=apibHeadersSectionKey,apibHeadersSectionValue
+
+syntax region apibActionRelationKey start=/: .*/ end=/$/ contained
+syntax region apibActionRelation start=/^[-+*] Relation: .*$/ end=/$/ oneline contains=apibActionRelationKey
+
+syntax match apibHeadersSectionKey /^[^:]*\ze:/ contained
+syntax match apibHeadersSectionValue /:.*/ contained
+
+highlight default link apibMarkdownMetadataKey Function
+highlight default link apibRequestSection Function
+highlight default link apibResponseSection Function
+highlight default link apibModelSection Function
+highlight default link apibHeadersSectionKey Function
+highlight default link apibHTTPStatusCode Delimiter
+highlight default link apibHTTPContentType Comment
+highlight default link apibActionRelation Function
+highlight default link apibActionRelationKey Identifier
+
+let b:current_syntax = 'apiblueprint'
+
+
+endif

syntax/applescript.vim

@@ -0,0 +1,249 @@
+if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'applescript') == -1
+  
+" Vim syntax file
+" Language:    AppleScript
+" Maintainer:  Jim Eberle <jim.eberle@fastnlight.com>
+" Last Change: Mar 18, 2010
+" URL:         http://www.fastnlight.com/syntax/applescript.vim
+
+" Use :syn w/in a buffer to see language element breakdown
+
+if version < 600
+  syntax clear
+elseif exists("b:current_syntax")
+  finish
+endif
+
+" --- Statement ---
+syn keyword scptStmt get set count copy run global local prop property
+syn keyword scptStmt close put delete duplicate exists
+syn keyword scptStmt launch open print quit make move reopen save
+syn keyword scptStmt saving into
+hi def link scptStmt Statement
+
+" --- Type ---
+syn keyword scptType text string number integer real color date
+hi def link scptType Type
+
+" --- Operator ---
+syn keyword scptOp div mod not and or as
+syn match   scptOp "[-+*/^&]"
+" MacRoman single char :- (divide)
+exec 'syn match scptOp "'.nr2char(214).'"'
+syn match scptOp "\<\(a \)\?\(ref\( to\)\?\|reference to\)\>"
+hi def link scptOp Operator
+
+" Containment
+syn match   scptIN "\<starts\? with\>"
+syn match   scptIN "\<begins\? with\>"
+syn match   scptIN "\<ends\? with\>"
+syn match   scptIN "\<contains\>"
+syn match   scptIN "\<does not contain\>"
+syn match   scptIN "\<doesn't contain\>"
+syn match   scptIN "\<is in\>"
+syn match   scptIN "\<is contained by\>"
+syn match   scptIN "\<is not in\>"
+syn match   scptIN "\<is not contained by\>"
+syn match   scptIN "\<isn't contained by\>"
+hi def link scptIN scptOp
+
+" Equals
+syn match   scptEQ "="
+syn match   scptEQ "\<equal\>"
+syn match   scptEQ "\<equals\>"
+syn match   scptEQ "\<equal to\>"
+syn match   scptEQ "\<is\>"
+syn match   scptEQ "\<is equal to\>"
+hi def link scptEQ scptOp
+
+" Not Equals
+syn match   scptNE "\<does not equal\>"
+syn match   scptNE "\<doesn't equal\>"
+syn match   scptNE "\<is not\>"
+syn match   scptNE "\<is not equal\( to\)\?\>"
+syn match   scptNE "\<isn't\>"
+syn match   scptNE "\<isn't equal\( to\)\?\>"
+hi def link scptNE scptOp
+" MacRoman single char /=
+exec 'syn match scptNE "'.nr2char(173).'"'
+
+" Less Than
+syn match   scptLT "<"
+syn match   scptLT "\<comes before\>"
+syn match   scptLT "\(is \)\?less than"
+syn match   scptLT "\<is not greater than or equal\( to\)\?\>"
+syn match   scptLT "\<isn't greater than or equal\( to\)\?\>"
+hi def link scptLT scptOp
+
+" Greater Than
+syn match   scptGT ">"
+syn match   scptGT "\<comes after\>"
+syn match   scptGT "\(is \)\?greater than"
+syn match   scptGT "\<is not less than or equal\( to\)\?\>"
+syn match   scptGT "\<isn't less than or equal\( to\)\?\>"
+hi def link scptGT scptOp
+
+" Less Than or Equals
+syn match   scptLE "<="
+syn match   scptLE "\<does not come after\>"
+syn match   scptLE "\<doesn't come after\>"
+syn match   scptLE "\(is \)\?less than or equal\( to\)\?"
+syn match   scptLE "\<is not greater than\>"
+syn match   scptLE "\<isn't greater than\>"
+hi def link scptLE scptOp
+" MacRoman single char <=
+exec 'syn match scptLE "'.nr2char(178).'"'
+
+" Greater Than or Equals
+syn match   scptGE ">="
+syn match   scptGE "\<does not come before\>"
+syn match   scptGE "\<doesn't come before\>"
+syn match   scptGE "\(is \)\?greater than or equal\( to\)\?"
+syn match   scptGE "\<is not less than\>"
+syn match   scptGE "\<isn't less than\>"
+hi def link scptGE scptOp
+" MacRoman single char >=
+exec 'syn match scptGE "'.nr2char(179).'"'
+
+" --- Constant String ---
+syn region  scptString start=+"+ skip=+\\\\\|\\"+ end=+"+
+hi def link scptString String
+
+" --- Constant Number ---
+syn match   scptNumber "\<-\?\d\+\>"
+hi def link scptNumber Number
+
+" --- Constant Float ---
+syn match   scptFloat display contained "\d\+\.\d*\(e[-+]\=\d\+\)\="
+syn match   scptFloat display contained "\.\d\+\(e[-+]\=\d\+\)\=\>"
+syn match   scptFloat display contained "\d\+e[-+]\>"
+hi def link scptFloat Float
+
+" --- Constant Boolean ---
+syn keyword scptBoolean true false yes no ask
+hi def link scptBoolean Boolean
+
+" --- Other Constants ---
+syn keyword scptConst it me version pi result space tab anything
+syn match   scptConst "\<missing value\>"
+
+" Considering and Ignoring
+syn match   scptConst "\<application responses\>"
+syn match   scptConst "\<current application\>"
+syn match   scptConst "\<white space\>"
+syn keyword scptConst case diacriticals expansion hyphens punctuation
+hi def link scptConst Constant
+
+" Style
+syn match   scptStyle "\<all caps\>"
+syn match   scptStyle "\<all lowercase\>"
+syn match   scptStyle "\<small caps\>"
+syn keyword scptStyle bold condensed expanded hidden italic outline plain
+syn keyword scptStyle shadow strikethrough subscript superscript underline
+hi def link scptStyle scptConst
+
+" Day
+syn keyword scptDay Mon Tue Wed Thu Fri Sat Sun
+syn keyword scptDay Monday Tuesday Wednesday Thursday Friday Saturday Sunday
+syn keyword scptDay weekday
+hi def link scptDay scptConst
+
+" Month
+syn keyword scptMonth Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
+syn keyword scptMonth January February March
+syn keyword scptMonth April May June
+syn keyword scptMonth July August September
+syn keyword scptMonth October November December
+syn keyword scptMonth month
+hi def link scptMonth scptConst
+
+" Time
+syn keyword scptTime minutes hours days weeks
+hi def link scptTime scptConstant
+
+" --- Conditional ---
+syn keyword scptCond if then else
+syn match   scptCond "\<end if\>"
+hi def link scptCond Conditional
+
+" --- Repeat ---
+syn keyword scptRepeat repeat with from to by continue 
+syn match   scptRepeat "\<repeat while\>"
+syn match   scptRepeat "\<repeat until\>"
+syn match   scptRepeat "\<repeat with\>"
+syn match   scptRepeat "\<end repeat\>"
+hi def link scptRepeat Repeat
+
+" --- Exception ---
+syn keyword scptException try error
+syn match   scptException "\<on error\>"
+syn match   scptException "\<end try\>"
+syn match   scptException "\<end error\>"
+hi def link scptException Exception
+
+" --- Keyword ---
+syn keyword scptKeyword end tell times exit 
+syn keyword scptKeyword application file alias activate
+syn keyword scptKeyword script on return without given
+syn keyword scptKeyword considering ignoring items delimiters
+syn keyword scptKeyword some each every whose where id index item its
+syn keyword scptKeyword first second third fourth fifth sixth seventh
+syn keyword scptKeyword eighth ninth tenth container
+syn match   scptKeyword "\d\+\(st\|nd\|rd\|th\)"
+syn keyword scptKeyword last front back middle named thru through
+syn keyword scptKeyword before after in of the
+syn match   scptKeyword "\<text \>"
+syn match   scptKeyword "\<partial result\>"
+syn match   scptKeyword "\<but ignoring\>"
+syn match   scptKeyword "\<but considering\>"
+syn match   scptKeyword "\<with timeout\>"
+syn match   scptKeyword "\<with transaction\>"
+syn match   scptKeyword "\<do script\>"
+syn match   scptKeyword "\<POSIX path\>"
+syn match   scptKeyword "\<quoted form\>"
+syn match   scptKeyword "'s"
+hi def link scptKeyword Keyword
+
+" US Units
+syn keyword scptUnitUS quarts gallons ounces pounds inches feet yards miles
+syn match   scptUnitUS "\<square feet\>"
+syn match   scptUnitUS "\<square yards\>"
+syn match   scptUnitUS "\<square miles\>"
+syn match   scptUnitUS "\<cubic inches\>"
+syn match   scptUnitUS "\<cubic feet\>"
+syn match   scptUnitUS "\<cubic yards\>"
+syn match   scptUnitUS "\<degrees Fahrenheit\>"
+hi def link scptUnitUS scptKey
+
+" British Units
+syn keyword scptUnitBT litres centimetres metres kilometres
+syn match   scptUnitBT "\<square metres\>"
+syn match   scptUnitBT "\<square kilometres\>"
+syn match   scptUnitBT "\<cubic centimetres\>"
+syn match   scptUnitBT "\<cubic metres\>"
+hi def link scptUnitBT scptKey
+
+" Metric Units
+syn keyword scptUnitMT liters centimeters meters kilometers grams kilograms 
+syn match   scptUnitMT "\<square meters\>"
+syn match   scptUnitMT "\<square kilometers\>"
+syn match   scptUnitMT "\<cubic centimeters\>"
+syn match   scptUnitMT "\<cubic meters\>"
+syn match   scptUnitMT "\<degrees Celsius\>"
+syn match   scptUnitMT "\<degrees Kelvin\>"
+hi def link scptUnitMT scptKey
+
+" --- Comment ---
+syn match   scptComment "--.*"
+syn match   scptComment "#.*"
+syn region  scptComment start="(\*" end="\*)"
+hi def link scptComment Comment
+
+" --- Todo ---
+syn keyword scptTodo contained TODO FIXME XXX
+hi def link scptTodo Todo
+
+let b:current_syntax = "applescript"
+
+
+endif

syntax/blade.vim

@@ -21,21 +21,46 @@ unlet! b:current_syntax
 syn case match
 syn clear htmlError
 
+if has('patch-7.4.1142')
+    syn iskeyword @,48-57,_,192-255,@-@,:
+else
+    setlocal iskeyword+=@-@
+endif
+
 syn region  bladeEcho       matchgroup=bladeDelimiter start="@\@<!{{" end="}}"  contains=@bladePhp,bladePhpParenBlock  containedin=ALLBUT,@bladeExempt keepend
 syn region  bladeEcho       matchgroup=bladeDelimiter start="{!!" end="!!}"  contains=@bladePhp,bladePhpParenBlock  containedin=ALLBUT,@bladeExempt keepend
 syn region  bladeComment    matchgroup=bladeDelimiter start="{{--" end="--}}"  contains=bladeTodo  containedin=ALLBUT,@bladeExempt keepend
 
-syn keyword bladeKeyword    @if @elseif @foreach @forelse @for @while @can @include @each @inject @extends @section @stack @push @unless @yield @parent @hasSection nextgroup=bladePhpParenBlock skipwhite containedin=ALLBUT,@bladeExempt
-syn keyword bladeKeyword    @else @endif @endunless @endfor @endforeach @empty @endforelse @endwhile @endcan @stop @append @endsection @endpush @show containedin=ALLBUT,@bladeExempt
+syn keyword bladeKeyword @if @elseif @foreach @forelse @for @while @can @cannot @elsecan @elsecannot @include
+    \ @includeIf @each @inject @extends @section @stack @push @unless @yield @parent @hasSection @break @continue
+    \ @unset @lang @choice @component @slot @prepend
+    \ nextgroup=bladePhpParenBlock skipwhite containedin=ALLBUT,@bladeExempt
+
+syn keyword bladeKeyword @else @endif @endunless @endfor @endforeach @empty @endforelse @endwhile @endcan
+    \ @endcannot @stop @append @endsection @endpush @show @overwrite @verbatim @endverbatim @endcomponent
+    \ @endslot @endprepend
+    \ containedin=ALLBUT,@bladeExempt
+
+if exists('g:blade_custom_directives')
+    exe "syn keyword bladeKeyword @" . join(g:blade_custom_directives, ' @') . " nextgroup=bladePhpParenBlock skipwhite containedin=ALLBUT,@bladeExempt"
+endif
+if exists('g:blade_custom_directives_pairs')
+    exe "syn keyword bladeKeyword @" . join(keys(g:blade_custom_directives_pairs), ' @') . " nextgroup=bladePhpParenBlock skipwhite containedin=ALLBUT,@bladeExempt"
+    exe "syn keyword bladeKeyword @" . join(values(g:blade_custom_directives_pairs), ' @') . " containedin=ALLBUT,@bladeExempt"
+endif
+
+syn region  bladePhpRegion  matchgroup=bladeKeyword start="\<@php\>\s*(\@!" end="\<@endphp\>"  contains=@bladePhp  containedin=ALLBUT,@bladeExempt keepend
+syn match   bladeKeyword "@php\ze\s*(" nextgroup=bladePhpParenBlock skipwhite containedin=ALLBUT,@bladeExempt
 
 syn region  bladePhpParenBlock  matchgroup=bladeDelimiter start="\s*(" end=")" contains=@bladePhp,bladePhpParenBlock skipwhite contained
 
 syn cluster bladePhp contains=@phpClTop
-syn cluster bladeExempt contains=bladeComment,@htmlTop
+syn cluster bladeExempt contains=bladeComment,bladePhpRegion,bladePhpParenBlock,@htmlTop
 
-syn cluster htmlPreproc add=bladeEcho,bladeComment
+syn cluster htmlPreproc add=bladeEcho,bladeComment,bladePhpRegion
 
-syn keyword bladeTodo todo fixme xxx  contained
+syn case ignore
+syn keyword bladeTodo todo fixme xxx note  contained
 
 hi def link bladeDelimiter      PreProc
 hi def link bladeComment        Comment

syntax/c.vim

@@ -3,7 +3,7 @@ if !exists('g:polyglot_disabled') || index(g:polyglot_disabled, 'c/c++') == -1
 " Vim syntax file
 " Language:	C
 " Maintainer:	Bram Moolenaar <Bram@vim.org>
-" Last Change:	2016 Apr 10
+" Last Change:	2016 Nov 17
 
 " Quit when a (custom) syntax file was already loaded
 if exists("b:current_syntax")
@@ -297,7 +297,7 @@ if !exists("c_no_ansi") || exists("c_ansi_constants") || exists("c_gnu")
   syn keyword cConstant SCHAR_MIN SINT_MIN SLONG_MIN SSHRT_MIN
   syn keyword cConstant SCHAR_MAX SINT_MAX SLONG_MAX SSHRT_MAX
   if !exists("c_no_c99")
-    syn keyword cConstant __func__
+    syn keyword cConstant __func__ __VA_ARGS__
     syn keyword cConstant LLONG_MIN LLONG_MAX ULLONG_MAX
     syn keyword cConstant INT8_MIN INT16_MIN INT32_MIN INT64_MIN
     syn keyword cConstant INT8_MAX INT16_MAX INT32_MAX INT64_MAX
@@ -360,36 +360,36 @@ if !exists("c_no_c99") " ISO C99
 endif
 
 " Accept %: for # (C99)
-syn region	cPreCondit	start="^\s*\(%:\|#\)\s*\(if\|ifdef\|ifndef\|elif\)\>" skip="\\$" end="$" keepend contains=cComment,cCommentL,cCppString,cCharacter,cCppParen,cParenError,cNumbers,cCommentError,cSpaceError
-syn match	cPreConditMatch	display "^\s*\(%:\|#\)\s*\(else\|endif\)\>"
+syn region	cPreCondit	start="^\s*\zs\(%:\|#\)\s*\(if\|ifdef\|ifndef\|elif\)\>" skip="\\$" end="$" keepend contains=cComment,cCommentL,cCppString,cCharacter,cCppParen,cParenError,cNumbers,cCommentError,cSpaceError
+syn match	cPreConditMatch	display "^\s*\zs\(%:\|#\)\s*\(else\|endif\)\>"
 if !exists("c_no_if0")
   syn cluster	cCppOutInGroup	contains=cCppInIf,cCppInElse,cCppInElse2,cCppOutIf,cCppOutIf2,cCppOutElse,cCppInSkip,cCppOutSkip
-  syn region	cCppOutWrapper	start="^\s*\(%:\|#\)\s*if\s\+0\+\s*\($\|//\|/\*\|&\)" end=".\@=\|$" contains=cCppOutIf,cCppOutElse,@NoSpell fold
-  syn region	cCppOutIf	contained start="0\+" matchgroup=cCppOutWrapper end="^\s*\(%:\|#\)\s*endif\>" contains=cCppOutIf2,cCppOutElse
+  syn region	cCppOutWrapper	start="^\s*\zs\(%:\|#\)\s*if\s\+0\+\s*\($\|//\|/\*\|&\)" end=".\@=\|$" contains=cCppOutIf,cCppOutElse,@NoSpell fold
+  syn region	cCppOutIf	contained start="0\+" matchgroup=cCppOutWrapper end="^\s*\zs\(%:\|#\)\s*endif\>" contains=cCppOutIf2,cCppOutElse
   if !exists("c_no_if0_fold")
     syn region	cCppOutIf2	contained matchgroup=cCppOutWrapper start="0\+" end="^\s*\(%:\|#\)\s*\(else\>\|elif\s\+\(0\+\s*\($\|//\|/\*\|&\)\)\@!\|endif\>\)"me=s-1 contains=cSpaceError,cCppOutSkip,@Spell fold
   else
     syn region	cCppOutIf2	contained matchgroup=cCppOutWrapper start="0\+" end="^\s*\(%:\|#\)\s*\(else\>\|elif\s\+\(0\+\s*\($\|//\|/\*\|&\)\)\@!\|endif\>\)"me=s-1 contains=cSpaceError,cCppOutSkip,@Spell
   endif
-  syn region	cCppOutElse	contained matchgroup=cCppOutWrapper start="^\s*\(%:\|#\)\s*\(else\|elif\)" end="^\s*\(%:\|#\)\s*endif\>"me=s-1 contains=TOP,cPreCondit
-  syn region	cCppInWrapper	start="^\s*\(%:\|#\)\s*if\s\+0*[1-9]\d*\s*\($\|//\|/\*\||\)" end=".\@=\|$" contains=cCppInIf,cCppInElse fold
-  syn region	cCppInIf	contained matchgroup=cCppInWrapper start="\d\+" end="^\s*\(%:\|#\)\s*endif\>" contains=TOP,cPreCondit
+  syn region	cCppOutElse	contained matchgroup=cCppOutWrapper start="^\s*\zs\(%:\|#\)\s*\(else\|elif\)" end="^\s*\zs\(%:\|#\)\s*endif\>"me=s-1 contains=TOP,cPreCondit
+  syn region	cCppInWrapper	start="^\s*\zs\(%:\|#\)\s*if\s\+0*[1-9]\d*\s*\($\|//\|/\*\||\)" end=".\@=\|$" contains=cCppInIf,cCppInElse fold
+  syn region	cCppInIf	contained matchgroup=cCppInWrapper start="\d\+" end="^\s*\zs\(%:\|#\)\s*endif\>" contains=TOP,cPreCondit
   if !exists("c_no_if0_fold")
-    syn region	cCppInElse	contained start="^\s*\(%:\|#\)\s*\(else\>\|elif\s\+\(0*[1-9]\d*\s*\($\|//\|/\*\||\)\)\@!\)" end=".\@=\|$" containedin=cCppInIf contains=cCppInElse2 fold
+    syn region	cCppInElse	contained start="^\s*\zs\(%:\|#\)\s*\(else\>\|elif\s\+\(0*[1-9]\d*\s*\($\|//\|/\*\||\)\)\@!\)" end=".\@=\|$" containedin=cCppInIf contains=cCppInElse2 fold
   else
-    syn region	cCppInElse	contained start="^\s*\(%:\|#\)\s*\(else\>\|elif\s\+\(0*[1-9]\d*\s*\($\|//\|/\*\||\)\)\@!\)" end=".\@=\|$" containedin=cCppInIf contains=cCppInElse2
+    syn region	cCppInElse	contained start="^\s*\zs\(%:\|#\)\s*\(else\>\|elif\s\+\(0*[1-9]\d*\s*\($\|//\|/\*\||\)\)\@!\)" end=".\@=\|$" containedin=cCppInIf contains=cCppInElse2
   endif
-  syn region	cCppInElse2	contained matchgroup=cCppInWrapper start="^\s*\(%:\|#\)\s*\(else\|elif\)\([^/]\|/[^/*]\)*" end="^\s*\(%:\|#\)\s*endif\>"me=s-1 contains=cSpaceError,cCppOutSkip,@Spell
-  syn region	cCppOutSkip	contained start="^\s*\(%:\|#\)\s*\(if\>\|ifdef\>\|ifndef\>\)" skip="\\$" end="^\s*\(%:\|#\)\s*endif\>" contains=cSpaceError,cCppOutSkip
-  syn region	cCppInSkip	contained matchgroup=cCppInWrapper start="^\s*\(%:\|#\)\s*\(if\s\+\(\d\+\s*\($\|//\|/\*\||\|&\)\)\@!\|ifdef\>\|ifndef\>\)" skip="\\$" end="^\s*\(%:\|#\)\s*endif\>" containedin=cCppOutElse,cCppInIf,cCppInSkip contains=TOP,cPreProc
+  syn region	cCppInElse2	contained matchgroup=cCppInWrapper start="^\s*\zs\(%:\|#\)\s*\(else\|elif\)\([^/]\|/[^/*]\)*" end="^\s*\zs\(%:\|#\)\s*endif\>"me=s-1 contains=cSpaceError,cCppOutSkip,@Spell
+  syn region	cCppOutSkip	contained start="^\s*\zs\(%:\|#\)\s*\(if\>\|ifdef\>\|ifndef\>\)" skip="\\$" end="^\s*\zs\(%:\|#\)\s*endif\>" contains=cSpaceError,cCppOutSkip
+  syn region	cCppInSkip	contained matchgroup=cCppInWrapper start="^\s*\zs\(%:\|#\)\s*\(if\s\+\(\d\+\s*\($\|//\|/\*\||\|&\)\)\@!\|ifdef\>\|ifndef\>\)" skip="\\$" end="^\s*\zs\(%:\|#\)\s*endif\>" containedin=cCppOutElse,cCppInIf,cCppInSkip contains=TOP,cPreProc
 endif
 syn region	cIncluded	display contained start=+"+ skip=+\\\\\|\\"+ end=+"+
 syn match	cIncluded	display contained "<[^>]*>"
-syn match	cInclude	display "^\s*\(%:\|#\)\s*include\>\s*["<]" contains=cIncluded
+syn match	cInclude	display "^\s*\zs\(%:\|#\)\s*include\>\s*["<]" contains=cIncluded
 "syn match cLineSkip	"\\$"
 syn cluster	cPreProcGroup	contains=cPreCondit,cIncluded,cInclude,cDefine,cErrInParen,cErrInBracket,cUserLabel,cSpecial,cOctalZero,cCppOutWrapper,cCppInWrapper,@cCppOutInGroup,cFormat,cNumber,cFloat,cOctal,cOctalError,cNumbersCom,cString,cCommentSkip,cCommentString,cComment2String,@cCommentGroup,cCommentStartError,cParen,cBracket,cMulti,cBadBlock
-syn region	cDefine		start="^\s*\(%:\|#\)\s*\(define\|undef\)\>" skip="\\$" end="$" keepend contains=ALLBUT,@cPreProcGroup,@Spell
-syn region	cPreProc	start="^\s*\(%:\|#\)\s*\(pragma\>\|line\>\|warning\>\|warn\>\|error\>\)" skip="\\$" end="$" keepend contains=ALLBUT,@cPreProcGroup,@Spell
+syn region	cDefine		start="^\s*\zs\(%:\|#\)\s*\(define\|undef\)\>" skip="\\$" end="$" keepend contains=ALLBUT,@cPreProcGroup,@Spell
+syn region	cPreProc	start="^\s*\zs\(%:\|#\)\s*\(pragma\>\|line\>\|warning\>\|warn\>\|error\>\)" skip="\\$" end="$" keepend contains=ALLBUT,@cPreProcGroup,@Spell
 
 " Highlight User Labels
 syn cluster	cMultiGroup	contains=cIncluded,cSpecial,cCommentSkip,cCommentString,cComment2String,@cCommentGroup,cCommentStartError,cUserCont,cUserLabel,cBitField,cOctalZero,cCppOutWrapper,cCppInWrapper,@cCppOutInGroup,cFormat,cNumber,cFloat,cOctal,cOctalError,cNumbersCom,cCppParen,cCppBracket,cCppString
@@ -398,21 +398,21 @@ if s:ft ==# 'c' || exists("cpp_no_cpp11")
 endif
 " Avoid matching foo::bar() in C++ by requiring that the next char is not ':'
 syn cluster	cLabelGroup	contains=cUserLabel
-syn match	cUserCont	display "^\s*\I\i*\s*:$" contains=@cLabelGroup
-syn match	cUserCont	display ";\s*\I\i*\s*:$" contains=@cLabelGroup
+syn match	cUserCont	display "^\s*\zs\I\i*\s*:$" contains=@cLabelGroup
+syn match	cUserCont	display ";\s*\zs\I\i*\s*:$" contains=@cLabelGroup
 if s:ft ==# 'cpp'
-  syn match	cUserCont	display "^\s*\%(class\|struct\|enum\)\@!\I\i*\s*:[^:]"me=e-1 contains=@cLabelGroup
-  syn match	cUserCont	display ";\s*\%(class\|struct\|enum\)\@!\I\i*\s*:[^:]"me=e-1 contains=@cLabelGroup
+  syn match	cUserCont	display "^\s*\zs\%(class\|struct\|enum\)\@!\I\i*\s*:[^:]"me=e-1 contains=@cLabelGroup
+  syn match	cUserCont	display ";\s*\zs\%(class\|struct\|enum\)\@!\I\i*\s*:[^:]"me=e-1 contains=@cLabelGroup
 else
-  syn match	cUserCont	display "^\s*\I\i*\s*:[^:]"me=e-1 contains=@cLabelGroup
-  syn match	cUserCont	display ";\s*\I\i*\s*:[^:]"me=e-1 contains=@cLabelGroup
+  syn match	cUserCont	display "^\s*\zs\I\i*\s*:[^:]"me=e-1 contains=@cLabelGroup
+  syn match	cUserCont	display ";\s*\zs\I\i*\s*:[^:]"me=e-1 contains=@cLabelGroup
 endif
 
 syn match	cUserLabel	display "\I\i*" contained
 
 " Avoid recognizing most bitfields as labels
-syn match	cBitField	display "^\s*\I\i*\s*:\s*[1-9]"me=e-1 contains=cType
-syn match	cBitField	display ";\s*\I\i*\s*:\s*[1-9]"me=e-1 contains=cType
+syn match	cBitField	display "^\s*\zs\I\i*\s*:\s*[1-9]"me=e-1 contains=cType
+syn match	cBitField	display ";\s*\zs\I\i*\s*:\s*[1-9]"me=e-1 contains=cType
 
 if exists("c_minlines")
   let b:c_minlines = c_minlines