Use sources_non_forked folder for pathogen path, with sources_non_forked_fallback folder as fallback.

sources_non_forked_fallback/tlib/autoload/tinykeymap/map/para_move.vim

@@ -0,0 +1,12 @@
+" para_move.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2012-08-28.
+" @Last Change: 2012-08-29.
+" @Revision:    3
+
+" Move paragraphs
+call tinykeymap#EnterMap("para_move", "gp", {'name': 'move paragraph'})
+call tinykeymap#Map("para_move", "j", "silent call tlib#paragraph#Move('Down', '<count>')")
+call tinykeymap#Map("para_move", "k", "silent call tlib#paragraph#Move('Up', '<count>')")
+

sources_non_forked_fallback/tlib/autoload/tlib.vim

@@ -0,0 +1,8 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    13
+
+" :nodefault:
+TLet g:tlib#debug = 0
+

sources_non_forked_fallback/tlib/autoload/tlib/Filter_cnf.vim

@@ -0,0 +1,152 @@
+" Filter_cnf.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-11-25.
+" @Last Change: 2017-09-28.
+" @Revision:    11.0.114
+
+let s:prototype = tlib#Object#New({'_class': ['Filter_cnf'], 'name': 'cnf'}) "{{{2
+let s:prototype.highlight = g:tlib#input#higroup
+
+" The search pattern for |tlib#input#List()| is in conjunctive normal 
+" form: (P1 OR P2 ...) AND (P3 OR P4 ...) ...
+" The pattern is a '/\V' very no-'/magic' regexp pattern.
+"
+" Pressing <space> joins two patterns with AND.
+" Pressing | joins two patterns with OR.
+" I.e. In order to get "lala AND (foo OR bar)", you type 
+" "lala foo|bar".
+"
+" This is also the base class for other filters.
+function! tlib#Filter_cnf#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+" :nodoc:
+function! s:prototype.Init(world) dict "{{{3
+endf
+
+
+" :nodoc:
+function! s:prototype.Help(world) dict "{{{3
+    call a:world.PushHelp(
+                \ printf('"%s", "%s", "%sWORD"', g:tlib#input#and, g:tlib#input#or, g:tlib#input#not),
+                \ 'AND, OR, NOT')
+endf
+
+
+" :nodoc:
+function! s:prototype.AssessName(world, name) dict "{{{3
+    let xa  = 0
+    let prefix = self.FilterRxPrefix()
+    for flt in a:world.filter_pos
+        " let flt = prefix . a:world.GetRx(fltl)
+        " if flt =~# '\u' && a:name =~# flt
+        "     let xa += 5
+        " endif
+        let rel = 1.0 + 5.0 * len(flt) / len(a:name)
+        let xa += float2nr(rel)
+        if a:name =~ '\^'. flt
+            let xa += 4
+        elseif a:name =~ '\<'. flt
+            let xa += 3
+        " elseif a:name =~ '[[:punct:][:space:][:digit:]]'. flt
+        "     let xa += 2
+        elseif a:name =~ '\A'. flt .'\|'. flt .'\A'
+            let xa += 1
+        endif
+    endfor
+    " TLogVAR a:name, xa
+    return xa
+endf
+
+
+" :nodoc:
+function! s:prototype.Match(world, text) dict "{{{3
+    " TLogVAR a:text
+    " let sc = &smartcase
+    " let ic = &ignorecase
+    " if &ignorecase
+    "     set smartcase
+    " endif
+    " try
+    if !empty(a:world.filter_neg)
+        for rx in a:world.filter_neg
+            " TLogVAR rx
+            if a:text =~ rx
+                return 0
+            endif
+        endfor
+    endif
+    if !empty(a:world.filter_pos)
+        for rx in a:world.filter_pos
+            " TLogVAR rx
+            if a:text !~ rx
+                return 0
+            endif
+        endfor
+    endif
+    " finally
+    "     let &smartcase = sc
+    "     let &ignorecase = ic
+    " endtry
+    return 1
+endf
+
+
+" :nodoc:
+function! s:prototype.DisplayFilter(filter) dict "{{{3
+    let filter1 = deepcopy(a:filter)
+    call map(filter1, '"(". join(reverse(self.Pretty(v:val)), " OR ") .")"')
+    return join(reverse(filter1), ' AND ')
+endf
+
+
+function! s:prototype.Pretty(filter) dict "{{{3
+    " call map(a:filter, 'substitute(v:val, ''\\\.\\{-}'', ''=>'', ''g'')')
+    call map(a:filter, 'self.CleanFilter(v:val)')
+    return a:filter
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
+    let a:world.filter[0] = reverse(split(a:pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
+endf
+
+
+" :nodoc:
+function! s:prototype.PushFrontFilter(world, char) dict "{{{3
+    let a:world.filter[0][0] .= nr2char(a:char)
+endf
+
+
+" :nodoc:
+function! s:prototype.ReduceFrontFilter(world) dict "{{{3
+    let filter = a:world.filter[0][0]
+    " TLogVAR filter
+    let str = matchstr(filter, '\(\\\(\.\\{-}\|[.?*+$^]\)\|\)$')
+    if empty(str)
+        let filter = filter[0 : -2]
+    else
+        let filter = tlib#string#Strcharpart(filter, 0, len(filter) - len(str))
+    endif
+    " TLogVAR str, filter
+    let a:world.filter[0][0] = filter
+endf
+
+
+" :nodoc:
+function! s:prototype.FilterRxPrefix() dict "{{{3
+    return '\V'
+endf
+
+
+" :nodoc:
+function! s:prototype.CleanFilter(filter) dict "{{{3
+    return a:filter
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/Filter_cnfd.vim

@@ -0,0 +1,53 @@
+" Filter_cnfd.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-11-25.
+" @Last Change: 2014-01-23.
+" @Revision:    0.0.57
+
+let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_cnfd'], 'name': 'cnfd'}) "{{{2
+let s:prototype.highlight = g:tlib#input#higroup
+
+
+" The same as |tlib#Filter_cnf#New()| but a dot is expanded to '\.\{-}'. 
+" As a consequence, patterns cannot match dots.
+" The pattern is a '/\V' very no-'/magic' regexp pattern.
+function! tlib#Filter_cnfd#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+" :nodoc:
+function! s:prototype.Init(world) dict "{{{3
+endf
+
+
+let s:Help = s:prototype.Help
+
+" :nodoc:
+function! s:prototype.Help(world) dict "{{{3
+    call call(s:Help, [a:world], self)
+    call a:world.PushHelp('.', 'Any characters')
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
+    let pattern = substitute(a:pattern, '\.', '\\.\\{-}', 'g')
+    let a:world.filter[0] = reverse(split(pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
+endf
+
+
+" :nodoc:
+function! s:prototype.PushFrontFilter(world, char) dict "{{{3
+    let a:world.filter[0][0] .= a:char == 46 ? '\.\{-}' : nr2char(a:char)
+endf
+
+
+" :nodoc:
+function! s:prototype.CleanFilter(filter) dict "{{{3
+    return substitute(a:filter, '\\.\\{-}', '.', 'g')
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/Filter_fuzzy.vim

@@ -0,0 +1,83 @@
+" Filter_fuzzy.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-11-25.
+" @Last Change: 2013-09-25.
+" @Revision:    0.0.47
+
+let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_fuzzy'], 'name': 'fuzzy'}) "{{{2
+let s:prototype.highlight = g:tlib#input#higroup
+
+
+" Support for "fuzzy" pattern matching in |tlib#input#List()|. 
+" Patterns are interpreted as if characters were connected with '.\{-}'.
+"
+" In "fuzzy" mode, the pretty printing of filenames is disabled.
+function! tlib#Filter_fuzzy#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+" :nodoc:
+function! s:prototype.Init(world) dict "{{{3
+    " TLogVAR a:world.display_format
+    " :nodoc:
+    function! a:world.Set_display_format(value) dict
+        if a:value == 'filename'
+            let self.display_format = ''
+        else
+            let self.display_format = a:value
+        endif
+    endf
+endf
+
+
+let s:Help = s:prototype.Help
+
+" :nodoc:
+function! s:prototype.Help(world) dict "{{{3
+    call call(s:Help, [a:world], self)
+    call a:world.PushHelp('Patterns are interpreted as if characters were connected with .\{-}')
+endf
+
+
+" :nodoc:
+function! s:prototype.DisplayFilter(filter) dict "{{{3
+    " TLogVAR a:filter
+    let filter1 = deepcopy(a:filter)
+    call map(filter1, '"{". join(reverse(v:val), " OR ") ."}"')
+    return join(reverse(filter1), ' AND ')
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
+    let a:world.filter[0] = map(reverse(split(a:pattern, '\s*|\s*')), 'join(map(split(v:val, ''\zs''), ''tlib#rx#Escape(v:val, "V")''), ''\.\{-}'')') + a:world.filter[0][1 : -1]
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.PushFrontFilter(world, char) dict "{{{3
+    let ch = tlib#rx#Escape(nr2char(a:char), 'V')
+    if empty(a:world.filter[0][0])
+        let a:world.filter[0][0] .= ch
+    else
+        let a:world.filter[0][0] .= '\.\{-}'. ch
+    endif
+endf
+
+
+" :nodoc:
+function! s:prototype.ReduceFrontFilter(world) dict "{{{3
+    let a:world.filter[0][0] = substitute(a:world.filter[0][0], '\(\\\.\\{-}\)\?.$', '', '')
+endf
+
+
+" :nodoc:
+function! s:prototype.CleanFilter(filter) dict "{{{3
+    return substitute(a:filter, '\\\.\\{-}', '', 'g')
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/Filter_glob.vim

@@ -0,0 +1,68 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-11-25.
+" @Last Change: 2014-11-18.
+" @Revision:    0.0.82
+
+let s:prototype = tlib#Filter_cnf#New({'_class': ['Filter_glob'], 'name': 'glob'}) "{{{2
+let s:prototype.highlight = g:tlib#input#higroup
+
+
+" A character that should be expanded to '\.\{-}'.
+TLet g:tlib#Filter_glob#seq = '*'
+
+
+" A character that should be expanded to '\.\?'.
+TLet g:tlib#Filter_glob#char = '?'
+
+
+" The same as |tlib#Filter_cnf#New()| but a a customizable character 
+" |see tlib#Filter_glob#seq| is expanded to '\.\{-}' and 
+" |g:tlib#Filter_glob#char| is expanded to '\.'.
+" The pattern is a '/\V' very no-'/magic' regexp pattern.
+function! tlib#Filter_glob#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+let s:Help = s:prototype.Help
+
+" :nodoc:
+function! s:prototype.Help(world) dict "{{{3
+    call call(s:Help, [a:world], self)
+    call a:world.PushHelp(g:tlib#Filter_glob#seq, 'Any characters')
+    call a:world.PushHelp(g:tlib#Filter_glob#char, 'Single characters')
+endf
+
+
+" :nodoc:
+function! s:prototype.SetFrontFilter(world, pattern) dict "{{{3
+    let pattern = substitute(a:pattern, tlib#rx#Escape(g:tlib#Filter_glob#seq, 'V'), '\\.\\{-}', 'g')
+    let pattern = substitute(a:pattern, tlib#rx#Escape(g:tlib#Filter_glob#char, 'V'), '\\.', 'g')
+    let a:world.filter[0] = reverse(split(pattern, '\s*|\s*')) + a:world.filter[0][1 : -1]
+endf
+
+
+" :nodoc:
+function! s:prototype.PushFrontFilter(world, char) dict "{{{3
+    " TLogVAR a:char, nr2char(a:char)
+    if a:char == char2nr(g:tlib#Filter_glob#seq)
+        let char = '\.\{-}'
+    elseif a:char == char2nr(g:tlib#Filter_glob#char)
+        let char = '\.'
+    else
+        let char = nr2char(a:char)
+    endif
+    let a:world.filter[0][0] .= char
+endf
+
+
+" :nodoc:
+function! s:prototype.CleanFilter(filter) dict "{{{3
+    let filter = substitute(a:filter, '\\\.\\{-}', g:tlib#Filter_glob#seq, 'g')
+    let filter = substitute(filter, '\\\.', g:tlib#Filter_glob#char, 'g')
+    return filter
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/Object.vim

@@ -0,0 +1,154 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    127
+
+" :filedoc:
+" Provides a prototype plus some OO-like methods.
+
+let s:id_counter = 0
+let s:prototype  = {'_class': ['object'], '_super': [], '_id': 0} "{{{2
+
+" :def: function! tlib#Object#New(?fields={})
+" This function creates a prototype that provides some kind of 
+" inheritance mechanism and a way to call parent/super methods.
+"
+" The usage demonstrated in the following example works best when every 
+" class/prototype is defined in a file of its own.
+"
+" The reason for why there is a dedicated constructor function is that 
+" this layout facilitates the use of templates and that methods are 
+" hidden from the user. Other solutions are possible.
+"
+" EXAMPLES: >
+"     let s:prototype = tlib#Object#New({
+"                 \ '_class': ['FooBar'],
+"                 \ 'foo': 1, 
+"                 \ 'bar': 2, 
+"                 \ })
+"     " Constructor
+"     function! FooBar(...)
+"         let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+"         return object
+"     endf
+"     function! s:prototype.babble() {
+"       echo "I think, therefore I am ". (self.foo * self.bar) ." months old."
+"     }
+"
+" < This could now be used like this: >
+"     let myfoo = FooBar({'foo': 3})
+"     call myfoo.babble()
+"     => I think, therefore I am 6 months old.
+"     echo myfoo.IsA('FooBar')
+"     => 1
+"     echo myfoo.IsA('object')
+"     => 1
+"     echo myfoo.IsA('Foo')
+"     => 0
+"     echo myfoo.RespondTo('babble')
+"     => 1
+"     echo myfoo.RespondTo('speak')
+"     => 0
+function! tlib#Object#New(...) "{{{3
+    return s:prototype.New(a:0 >= 1 ? a:1 : {})
+endf
+
+
+function! s:prototype.New(...) dict "{{{3
+    let object = deepcopy(self)
+    let s:id_counter += 1
+    let object._id = s:id_counter
+    if a:0 >= 1 && !empty(a:1)
+        " call object.Extend(deepcopy(a:1))
+        call object.Extend(a:1)
+    endif
+    return object
+endf
+
+
+function! s:prototype.Inherit(object) dict "{{{3
+    let class = copy(self._class)
+    " TLogVAR class
+    let objid = self._id
+    for c in get(a:object, '_class', [])
+        " TLogVAR c
+        if index(class, c) == -1
+            call add(class, c)
+        endif
+    endfor
+    call extend(self, a:object, 'keep')
+    let self._class = class
+    " TLogVAR self._class
+    let self._id    = objid
+    " let self._super = [super] + self._super
+    call insert(self._super, a:object)
+    return self
+endf
+
+
+function! s:prototype.Extend(dictionary) dict "{{{3
+    let super = copy(self)
+    let class = copy(self._class)
+    " TLogVAR class
+    let objid = self._id
+    let thisclass = get(a:dictionary, '_class', [])
+    for c in type(thisclass) == 3 ? thisclass : [thisclass]
+        " TLogVAR c
+        if index(class, c) == -1
+            call add(class, c)
+        endif
+    endfor
+    call extend(self, a:dictionary)
+    let self._class = class
+    " TLogVAR self._class
+    let self._id    = objid
+    " let self._super = [super] + self._super
+    call insert(self._super, super)
+    return self
+endf
+
+
+function! s:prototype.IsA(class) dict "{{{3
+    return index(self._class, a:class) != -1
+endf
+
+
+function! s:prototype.IsRelated(object) dict "{{{3
+    return len(filter(a:object._class, 'self.IsA(v:val)')) > 1
+endf
+
+
+function! s:prototype.RespondTo(name) dict "{{{3
+    " return has_key(self, a:name) && type(self[a:name]) == 2
+    return has_key(self, a:name)
+endf
+
+
+function! s:prototype.Super(method, arglist) dict "{{{3
+    for o in self._super
+        " TLogVAR o
+        if o.RespondTo(a:method)
+            " let self._tmp_method = o[a:method]
+            " TLogVAR self._tmp_method
+            " return call(self._tmp_method, a:arglist, self)
+            return call(o[a:method], a:arglist, self)
+        endif
+    endfor
+    echoerr 'tlib#Object: Does not respond to '. a:method .': '. string(self)
+endf
+
+
+function! tlib#Object#Methods(object, ...) "{{{3
+    TVarArg ['pattern', '\d\+']
+    let o = items(a:object)
+    call filter(o, 'type(v:val[1]) == 2 && string(v:val[1]) =~ "^function(''\\d\\+'')"')
+    let acc = {}
+    for e in o
+        let id = matchstr(string(e[1]), pattern)
+        if !empty(id)
+            let acc[id] = e[0]
+        endif
+    endfor
+    return acc
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/Test.vim

@@ -0,0 +1,19 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    11
+
+" :enddoc:
+
+
+let s:prototype = tlib#Object#New({'_class': ['Test']}) "{{{2
+function! tlib#Test#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+function! s:prototype.Dummy() dict "{{{3
+    return 'Test.vim'
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/TestChild.vim

@@ -0,0 +1,19 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    15
+
+" :enddoc:
+
+
+let s:prototype = tlib#Test#New({'_class': ['TestChild']}) "{{{2
+function! tlib#TestChild#New(...) "{{{3
+    let object = s:prototype.New(a:0 >= 1 ? a:1 : {})
+    return object
+endf
+
+
+function! s:prototype.Dummy() dict "{{{3
+    return 'TestChild.vim'
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/agent.vim

@@ -0,0 +1,716 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    362
+
+" :filedoc:
+" Various agents for use as key handlers in tlib#input#List()
+
+" Number of items to move when pressing <c-up/down> in the input list window.
+TLet g:tlib_scroll_lines = 10
+
+
+" General {{{1
+
+function! tlib#agent#Exit(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if a:world.key_mode ==# 'default'
+        call a:world.CloseScratch()
+        let a:world.state = 'exit empty escape'
+        let a:world.list = []
+        " let a:world.base = []
+        call a:world.ResetSelected()
+    else
+        let a:world.key_mode = 'default'
+        let a:world.state = 'redisplay'
+    endif
+    return a:world
+endf
+
+
+function! tlib#agent#CopyItems(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let @* = join(a:selected, "\n")
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+
+" InputList related {{{1
+
+function! tlib#agent#PageUp(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.offset -= (winheight(0) / 2)
+    let a:world.state = 'scroll'
+    return a:world
+endf
+
+
+function! tlib#agent#PageDown(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.offset += (winheight(0) / 2)
+    let a:world.state = 'scroll'
+    return a:world
+endf
+
+
+function! tlib#agent#Home(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.prefidx = 1
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#End(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.prefidx = len(a:world.list)
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#Up(world, selected, ...) "{{{3
+    TVarArg ['lines', 1]
+    Tlibtrace 'tlib', a:selected, lines
+    let a:world.idx = ''
+    if a:world.prefidx > lines
+        let a:world.prefidx -= lines
+    else
+        let a:world.prefidx = len(a:world.list)
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#Down(world, selected, ...) "{{{3
+    TVarArg ['lines', 1]
+    Tlibtrace 'tlib', a:selected, lines
+    let a:world.idx = ''
+    if a:world.prefidx <= (len(a:world.list) - lines)
+        let a:world.prefidx += lines
+    else
+        let a:world.prefidx = 1
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#UpN(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    return tlib#agent#Up(a:world, a:selected, g:tlib_scroll_lines)
+endf
+
+
+function! tlib#agent#DownN(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    return tlib#agent#Down(a:world, a:selected, g:tlib_scroll_lines)
+endf
+
+
+function! tlib#agent#ShiftLeft(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.offset_horizontal -= (winwidth(0) / 2)
+    if a:world.offset_horizontal < 0
+        let a:world.offset_horizontal = 0
+    endif
+    let a:world.state = 'display shift'
+    return a:world
+endf
+
+
+function! tlib#agent#ShiftRight(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.offset_horizontal += (winwidth(0) / 2)
+    let a:world.state = 'display shift'
+    return a:world
+endf
+
+
+function! tlib#agent#Reset(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#agent#ToggleRestrictView(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if empty(a:world.filtered_items)
+        return tlib#agent#RestrictView(a:world, a:selected)
+    else
+        return tlib#agent#UnrestrictView(a:world, a:selected)
+    endif
+endf
+
+
+function! tlib#agent#RestrictView(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let filtered_items = map(copy(a:selected), 'index(a:world.base, v:val) + 1')
+    Tlibtrace 'tlib', 1, filtered_items
+    let filtered_items = filter(filtered_items, 'v:val > 0')
+    Tlibtrace 'tlib', 2, filtered_items
+    if !empty(filtered_items)
+        let a:world.filtered_items = filtered_items
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#UnrestrictView(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.filtered_items = []
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#Input(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let flt0 = a:world.CleanFilter(a:world.filter[0][0])
+    let flt1 = input('Filter: ', flt0)
+    echo
+    if flt1 != flt0
+        if empty(flt1)
+            call getchar(0)
+        else
+            call a:world.SetFrontFilter(flt1)
+        endif
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+" Suspend (see |tlib#agent#Suspend|) the input loop and jump back to the 
+" original position in the parent window.
+function! tlib#agent#SuspendToParentWindow(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let world = a:world
+    let wid = world.win_id
+    Tlibtrace 'tlib', wid
+    if wid != -1
+        let world = tlib#agent#Suspend(world, a:selected)
+        if world.state =~# '\<suspend\>'
+            call world.SwitchWindow('win')
+            " let pos = world.cursor
+            " Tlibtrace 'tlib', pos
+            " if !empty(pos)
+            "     call setpos('.', pos)
+            " endif
+            return world
+        endif
+    endif
+    let world.state = 'redisplay'
+    return world
+endf
+
+
+" Suspend lets you temporarily leave the input loop of 
+" |tlib#input#List|. You can resume editing the list by pressing <c-z>, 
+" <m-z>. <space>, <c-LeftMouse> or <MiddleMouse> in the suspended window.
+" <cr> and <LeftMouse> will immediatly select the item under the cursor.
+" < will select the item but the window will remain opened.
+function! tlib#agent#Suspend(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if a:world.allow_suspend
+        " TAssert IsNotEmpty(a:world.scratch)
+        " TLogDBG bufnr('%')
+        let br = tlib#buffer#Set(a:world.scratch)
+        Tlibtrace 'tlib', br, a:world.bufnr, a:world.scratch
+        if bufnr('%') != a:world.scratch
+            echohl WarningMsg
+            echom "tlib#agent#Suspend: Internal error: Not a scratch buffer:" bufname('%')
+            echohl NONE
+        endif
+        Tlibtrace 'tlib', bufnr('%'), bufname('%'), a:world.scratch
+        call tlib#autocmdgroup#Init()
+        exec 'autocmd TLib BufEnter <buffer='. a:world.scratch .'> call tlib#input#Resume("world", 0, '. a:world.scratch .')'
+        let b:tlib_world = a:world
+        exec br
+        let a:world.state = 'exit suspend'
+    else
+        echom 'Suspend disabled'
+        let a:world.state = 'redisplay'
+    endif
+    return a:world
+endf
+
+
+function! tlib#agent#Help(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.state = 'help'
+    return a:world
+endf
+
+
+function! tlib#agent#OR(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if !empty(a:world.filter[0])
+        call insert(a:world.filter[0], '')
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#AND(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if !empty(a:world.filter[0])
+        call insert(a:world.filter, [''])
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#ReduceFilter(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    call a:world.ReduceFilter()
+    let a:world.offset = 1
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#PopFilter(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    call a:world.PopFilter()
+    let a:world.offset = 1
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#Debug(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    " echo string(world.state)
+    echo string(a:world.filter)
+    echo string(a:world.idx)
+    echo string(a:world.prefidx)
+    echo string(a:world.sel_idx)
+    call getchar()
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+function! tlib#agent#Select(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    call a:world.SelectItem('toggle', a:world.prefidx)
+    " let a:world.state = 'display keepcursor'
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#SelectUp(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    call a:world.SelectItem('toggle', a:world.prefidx)
+    if a:world.prefidx > 1
+        let a:world.prefidx -= 1
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#SelectDown(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    call a:world.SelectItem('toggle', a:world.prefidx)
+    if a:world.prefidx < len(a:world.list)
+        let a:world.prefidx += 1
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#SelectAll(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let listrange = range(1, len(a:world.list))
+    let mode = empty(filter(copy(listrange), 'index(a:world.sel_idx, a:world.GetBaseIdx(v:val)) == -1'))
+                \ ? 'toggle' : 'set'
+    for i in listrange
+        call a:world.SelectItem(mode, i)
+    endfor
+    let a:world.state = 'display keepcursor'
+    return a:world
+endf
+
+
+function! tlib#agent#ToggleStickyList(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.sticky = !a:world.sticky
+    let a:world.state = 'display keepcursor'
+    return a:world
+endf
+
+
+
+" EditList related {{{1
+
+function! tlib#agent#EditItem(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let lidx = a:world.prefidx
+    Tlibtrace 'tlib', lidx
+    let bidx = a:world.GetBaseIdx(lidx)
+    Tlibtrace 'tlib', bidx
+    let item = a:world.GetBaseItem(bidx)
+    let item = input(lidx .'@'. bidx .': ', item)
+    if item != ''
+        call a:world.SetBaseItem(bidx, item)
+    endif
+    let a:world.state = 'display'
+    return a:world
+endf
+
+
+" Insert a new item below the current one.
+function! tlib#agent#NewItem(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let basepi = a:world.GetBaseIdx(a:world.prefidx)
+    let item = input('New item: ')
+    call insert(a:world.base, item, basepi)
+    let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#agent#DeleteItems(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let remove = copy(a:world.sel_idx)
+    let basepi = a:world.GetBaseIdx(a:world.prefidx)
+    if index(remove, basepi) == -1
+        call add(remove, basepi)
+    endif
+    " call map(remove, 'a:world.GetBaseIdx(v:val)')
+    for idx in reverse(sort(remove))
+        call remove(a:world.base, idx - 1)
+    endfor
+    let a:world.state = 'display'
+    call a:world.ResetSelected()
+    " let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#agent#Cut(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let world = tlib#agent#Copy(a:world, a:selected)
+    return tlib#agent#DeleteItems(world, a:selected)
+endf
+
+
+function! tlib#agent#Copy(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.clipboard = []
+    let bidxs = copy(a:world.sel_idx)
+    call add(bidxs, a:world.GetBaseIdx(a:world.prefidx))
+    for bidx in sort(bidxs)
+        call add(a:world.clipboard, a:world.GetBaseItem(bidx))
+    endfor
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#Paste(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if has_key(a:world, 'clipboard')
+        for e in reverse(copy(a:world.clipboard))
+            call insert(a:world.base, e, a:world.prefidx)
+        endfor
+    endif
+    let a:world.state = 'display'
+    call a:world.ResetSelected()
+    return a:world
+endf
+
+
+function! tlib#agent#EditReturnValue(world, rv) "{{{3
+    Tlibtrace 'tlib', a:rv
+    return [a:world.state !~ '\<exit\>', a:world.base]
+endf
+
+
+
+" Files related {{{1
+
+function! tlib#agent#ViewFile(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if !empty(a:selected)
+        let back = a:world.SwitchWindow('win')
+        Tlibtrace 'tlib', back
+        for filename in a:selected
+            call tlib#file#Edit(filename)
+        endfor
+        call a:world.SetOrigin(1)
+        silent! exec back
+        let a:world.state = 'display'
+    endif
+    return a:world
+endf
+
+
+function! tlib#agent#EditFile(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    return tlib#agent#Exit(tlib#agent#ViewFile(a:world, a:selected), a:selected)
+endf
+
+
+function! tlib#agent#EditFileInSplit(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    call a:world.CloseScratch()
+    call tlib#file#With('split', 'sbuffer', a:selected, a:world, 1)
+    call a:world.SetOrigin(1)
+    return tlib#agent#Exit(a:world, a:selected)
+endf
+
+
+function! tlib#agent#EditFileInVSplit(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    call a:world.CloseScratch()
+    let winpos = tlib#fixes#Winpos()
+    call tlib#file#With('vertical split', 'vertical sbuffer', a:selected, a:world, 1)
+    if !empty(winpos)
+        exec winpos
+    endif
+    call a:world.SetOrigin(1)
+    return tlib#agent#Exit(a:world, a:selected)
+endf
+
+
+function! tlib#agent#EditFileInTab(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    call a:world.CloseScratch()
+    call tlib#file#With('tabedit', 'tab sbuffer', a:selected, a:world, 1)
+    call a:world.SetOrigin(1)
+    return tlib#agent#Exit(a:world, a:selected)
+endf
+
+
+function! tlib#agent#EditFileInWindow(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    call a:world.CloseScratch()
+    call tlib#file#With('hide edit', 'hide buffer', a:selected, a:world, 1)
+    call a:world.SetOrigin(1)
+    return tlib#agent#Exit(a:world, a:selected)
+endf
+
+
+function! tlib#agent#ToggleScrollbind(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.scrollbind = get(a:world, 'scrollbind') ? 0 : 1
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#ShowInfo(world, selected)
+    Tlibtrace 'tlib', a:selected
+    let lines = []
+    for f in a:selected
+        if filereadable(f)
+            let desc = [getfperm(f), strftime('%c', getftime(f)),  getfsize(f) .' bytes', getftype(f)]
+            call add(lines, fnamemodify(f, ':p'))
+            call add(lines, '  '. join(desc, '; '))
+        endif
+    endfor
+    let a:world.temp_lines = lines
+    let a:world.state = 'printlines'
+    return a:world
+endf
+
+
+
+" Buffer related {{{1
+
+function! tlib#agent#ViewBufferInWindow(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if !empty(a:selected)
+        let back = a:world.SwitchWindow('win')
+        Tlibtrace 'tlib', back
+        for bufname in a:selected
+            let cmd = &modified && !&hidden ? 'sbuffer' : 'buffer'
+            exec cmd fnameescape(bufname)
+        endfor
+        " exec back
+    endif
+    return tlib#agent#Exit(a:world, a:selected)
+endf
+
+
+function! tlib#agent#PreviewLine(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let l = a:selected[0]
+    " let ww = winnr()
+    let wid = tlib#win#GetID()
+    call tlib#agent#SuspendToParentWindow(a:world, a:selected)
+    call tlib#buffer#ViewLine(l, 1)
+    call tlib#win#GotoID(wid)
+    " exec ww .'wincmd w'
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+" If not called from the scratch, we assume/guess that we don't have to 
+" suspend the input-evaluation loop.
+function! tlib#agent#GotoLine(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if !empty(a:selected)
+        let l = a:selected[0]
+        if a:world.win_id != tlib#win#GetID()
+            let world = tlib#agent#Suspend(a:world, a:selected)
+            call tlib#win#GotoID(a:world.win_id)
+        endif
+        call tlib#buffer#ViewLine(l, 1)
+        
+    endif
+    return a:world
+endf
+
+
+function! tlib#agent#DoAtLine(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if !empty(a:selected)
+        let cmd = input('Command: ', '', 'command')
+        if !empty(cmd)
+            call a:world.SwitchWindow('win')
+            " let pos = getpos('.')
+            let view = winsaveview()
+            for l in a:selected
+                call tlib#buffer#ViewLine(l, '')
+                exec cmd
+            endfor
+            " call setpos('.', pos)
+            call winrestview(view)
+        endif
+    endif
+    call a:world.ResetSelected()
+    let a:world.state = 'exit'
+    return a:world
+endf
+
+
+function! tlib#agent#Wildcard(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    if !empty(a:world.filter[0])
+        let rx_type = a:world.matcher.FilterRxPrefix()
+        let flt0 = a:world.CleanFilter(a:world.filter[0][0])
+        if rx_type == '\V'
+            let flt0 .= '\.\{-}'
+        else
+            let flt0 .= '.\{-}'
+        endif
+        call a:world.SetFrontFilter(flt0)
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#Null(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#agent#ExecAgentByName(world, selected) "{{{3
+    Tlibtrace 'tlib', a:selected
+    let s:agent_names_world = a:world
+    let agent_names = {'Help': 'tlib#agent#Help'}
+    for def in values(a:world.key_map[a:world.key_mode])
+        if has_key(def, 'help') && !empty(def.help) && has_key(def, 'agent') && !empty(def.agent)
+            let agent_names[def.help] = def.agent
+        endif
+    endfor
+    let s:agent_names = sort(keys(agent_names))
+    let command = input('Command: ', '', 'customlist,tlib#agent#CompleteAgentNames')
+    Tlibtrace 'tlib', command
+    if !has_key(agent_names, command)
+        Tlibtrace 'tlib', command
+        silent! let matches = filter(keys(agent_names), 'v:val =~ command')
+        Tlibtrace 'tlib', matches
+        if len(matches) == 1
+            let command = matches[0]
+        endif
+    endif
+    if has_key(agent_names, command)
+        let agent = agent_names[command]
+        return call(agent, [a:world, a:selected])
+    else
+        if !empty(command)
+            echohl WarningMsg
+            echom "Unknown command:" command
+            echohl NONE
+            sleep 1
+        endif
+        let a:world.state = 'display'
+        return a:world
+    endif
+endf
+
+
+function! tlib#agent#CompleteAgentNames(ArgLead, CmdLine, CursorPos)
+    let arglead = tolower(a:Arglead)
+    return filter(copy(s:agent_names), 'stridx(tolower(v:val), arglead) != -1')
+endf
+
+
+function! tlib#agent#Complete(world, selected) abort "{{{3
+    Tlibtrace 'tlib', a:selected
+    let rxprefix = a:world.matcher.FilterRxPrefix()
+    let flt = a:world.filter[0][0]
+    Tlibtrace 'tlib', flt
+    let fltrx = rxprefix . flt . '\m[^[:space:][:cntrl:][:punct:]<>*+?&~{}()\[\]\\/]\+'
+    let fltrx0 = '\m^' . fltrx
+    Tlibtrace 'tlib', fltrx, fltrx0
+    let words = {}
+    for item in a:world.list
+        let parts = split(item, '\ze'. fltrx)
+        Tlibtrace 'tlib', item, parts
+        for part in parts
+            let word = matchstr(part, fltrx0)
+            Tlibtrace 'tlib', part, word
+            if !empty(word)
+                let words[word] = 1
+            endif
+        endfor
+    endfor
+    Tlibtrace 'tlib', keys(words)
+    let completions = keys(words)
+    " let completions = filter(keys(words), 'matchstr(v:val, fltrx0)')
+    let completions = sort(completions, 's:SortCompletions')
+    let completions = tlib#list#Uniq(completions)
+    Tlibtrace 'tlib', 0, completions
+    while len(completions) > 1
+        let nchar = strwidth(completions[0]) - 1
+        let completions = map(completions, 'tlib#string#Strcharpart(v:val, 0, nchar)')
+        Tlibtrace 'tlib', 'reduce', completions
+        let completions = tlib#list#Uniq(completions)
+        Tlibtrace 'tlib', 'unique', len(completions), completions
+    endwh
+    Tlibtrace 'tlib', 9, completions
+    if empty(completions)
+        let a:world.state = 'redisplay update'
+    else
+        let a:world.filter[0][0] = completions[0]
+        let a:world.state = 'display update'
+    endif
+    return a:world
+endf
+
+
+function! s:SortCompletions(a, b) abort "{{{3
+    let i1 = strwidth(a:a)
+    let i2 = strwidth(a:b)
+    return i2 - i1
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/arg.vim

@@ -0,0 +1,342 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2017-09-28.
+" @Revision:    273
+
+
+" :def: function! tlib#arg#Get(n, var, ?default="", ?test='')
+" Set a positional argument from a variable argument list.
+" See tlib#string#RemoveBackslashes() for an example.
+function! tlib#arg#Get(n, var, ...) "{{{3
+    let default = a:0 >= 1 ? a:1 : ''
+    let atest   = a:0 >= 2 ? a:2 : ''
+    " TLogVAR default, atest
+    if !empty(atest)
+        let atest = ' && (a:'. a:n .' '. atest .')'
+    endif
+    let test = printf('a:0 >= %d', a:n) . atest
+    return printf('let %s = %s ? a:%d : %s', a:var, test, a:n, string(default))
+endf
+
+
+" :def: function! tlib#arg#Let(list, ?default='')
+" Set a positional arguments from a variable argument list.
+" See tlib#input#List() for an example.
+function! tlib#arg#Let(list, ...) "{{{3
+    let default = a:0 >= 1 ? a:1 : ''
+    let list = map(copy(a:list), 'type(v:val) == 3 ? v:val : [v:val, default]')
+    let args = map(range(1, len(list)), 'call("tlib#arg#Get", [v:val] + list[v:val - 1])')
+    return join(args, ' | ')
+endf
+
+
+" :def: function! tlib#arg#StringAsKeyArgs(string, ?keys=[], ?evaluate=0, ?sep=':', ?booleans=0)
+function! tlib#arg#StringAsKeyArgs(string, ...) "{{{1
+    TVarArg ['keys', {}], ['evaluate', 0], ['sep', ':'], ['booleans', 0]
+    let keyargs = {}
+    let args = split(a:string, '\\\@<! ')
+    let key_rx = booleans ? '\([-+]\?\w\+\)' : '\(\w\+\)'
+    let arglist = map(args, 'matchlist(v:val, ''^\%('. key_rx . sep .'\(.*\)\|\(.*\)\)$'')')
+    " TLogVAR a:string, args, arglist
+    let pos = -1
+    for matchlist in arglist
+        if !empty(matchlist[3])
+            if booleans && matchlist[3] =~ '^[-+]'
+                let key = substitute(matchlist[3], '^[-+]', '', '')
+                let val = matchstr(matchlist[3], '^[-+]')
+                let keyargs[key] = val ==# '+'
+            else
+                let pos += 1
+                let keyargs[pos] = matchlist[3]
+            endif
+        else
+            let [match, key, val; rest] = matchlist
+            if empty(keys) || has_key(keys, key)
+                let val = substitute(val, '\\\\', '\\', 'g')
+                if evaluate
+                    let val = eval(val)
+                endif
+                let keyargs[key] = val
+            else
+                echom 'Unknown key: '. key .'='. val
+            endif
+        endif
+    endfor
+    if pos >= 0
+        let keyargs['__posargs__'] = range(0, pos)
+    endif
+    return keyargs
+endf
+
+
+function! tlib#arg#StringAsKeyArgsEqual(string) "{{{1
+    return tlib#arg#StringAsKeyArgs(a:string, [], 0, '=', 1)
+endf
+
+
+" :display: tlib#arg#GetOpts(args, ?def={})
+" Convert a list of strings of command-line arguments into a dictonary.
+"
+" The main use case is to pass [<f-args>], i.e. the command-line 
+" arguments of a command as list, from a command definition to this 
+" function.
+"
+" Example:
+" ['-h']
+" => If def contains a 'help' key, invoke |:help| on its value.
+"
+" ['-ab', '--foo', '--bar=BAR', 'bla', bla']
+" => {'a': 1, 'b': 1, 'foo': 1, 'bar': 'BAR', '__rest__': ['bla', 'bla']}
+"
+" ['-ab', '--', '--foo', '--bar=BAR']
+" => {'a': 1, 'b': 1, '__rest__': ['--foo', '--bar=BAR']}
+function! tlib#arg#GetOpts(args, ...) abort "{{{3
+    if type(a:args) == 4
+        reutrn a:args
+    else
+        let throw = a:0 == 0
+        TVarArg ['def', {}]
+        " TLogVAR def
+        let opts = {'__exit__': 0}
+        for [key, vdef] in items(get(def, 'values', {}))
+            if has_key(vdef, 'default')
+                let opts[key] = vdef.default
+            endif
+        endfor
+        let idx = 0
+        for o in a:args
+            let [break, idx] = s:SetOpt(def, opts, idx, o)
+            if break == 1
+                break
+            elseif break == 2
+                if throw
+                    throw 'tlib#arg#GetOpts: Show help'
+                else
+                    let opts.__exit__ = 5
+                endif
+            endif
+        endfor
+        let opts.__rest__ = a:args[idx : -1]
+        return opts
+    endif
+endf
+
+
+function! s:GetValueType(def) abort "{{{3
+    return get(a:def, 'type', type(get(a:def, 'default', '')))
+endf
+
+
+function! s:SetOpt(def, opts, idx, opt) abort "{{{3
+    " TLogVAR a:def
+    let idx = a:idx + 1
+    let break = 0
+    let long = get(a:def, 'long', 1)
+    let short = get(a:def, 'short', 1)
+    if (short && a:opt =~# '^-[?h]$') || (long && a:opt ==# '--help')
+        if has_key(a:def, 'help')
+            exec 'help' a:def.help
+        else
+            " TLogVAR a:def
+            let values = get(a:def, 'values', {})
+            let flags = get(a:def, 'flags', {})
+            if empty(values) && empty(flags)
+                echom 'No help'
+            else
+                if !empty(values)
+                    echom 'Options:'
+                    for [key, vdef] in sort(items(values))
+                        let opt = key
+                        let default = get(vdef, 'default', '')
+                        let type = s:GetValueType(vdef)
+                        if default =~ '^-\?\d\+\%(\.\d\+\)$'
+                            if type == -1 || type == 6
+                                let opt .= ' (flag)'
+                            elseif type == 1
+                                let opt .= '=INT'
+                            else
+                                let opt .= '=INT or maybe BOOL'
+                            endif
+                        elseif type(default) == 1
+                            let opt .= '=STRING'
+                        elseif type(default) == 3
+                            let opt .= '=COMMA-LIST'
+                        endif
+                        echom printf('  --%20s (default: %s)', opt, string(default))
+                    endfor
+                endif
+                if !empty(flags)
+                    echom 'Short flags:'
+                    for [sflag, lflag] in sort(items(flags))
+                        echom printf('  -%s -> %s', sflag, lflag)
+                    endfor
+                endif
+            endif
+        endif
+        let break = 2
+    elseif long &&  a:opt =~# '^--\%(no-\)\?debug$'
+        if has_key(a:def, 'trace')
+            let mod = a:opt =~# '--no-' ? '-' : '+'
+            exec 'Tlibtraceset' mod . a:def.trace
+        endif
+    elseif long &&  a:opt =~# '^--no-.\+'
+        let key = matchstr(a:opt, '^--no-\zs.\+$')
+        let a:opts[key] = s:Validate(a:def, key, 0)
+    elseif long &&  a:opt =~# '^--\w\+$'
+        let key = matchstr(a:opt, '^--\zs.\+$')
+        let a:opts[key] = s:Validate(a:def, key, 1)
+    elseif long &&  a:opt =~# '^--\w\+='
+        let ml = matchlist(a:opt, '^--\(\w\+\)=\(.*\)$')
+        if empty(ml)
+            throw 'tlib#arg#GetOpts: Cannot parse: '. a:opt
+        else
+            let values = get(a:def, 'values', {})
+            if has_key(values, ml[1])
+                let vdef = values[ml[1]]
+                let type = s:GetValueType(vdef)
+                if type == -1
+                    let opt_value = !!str2nr(ml[2])
+                elseif type == 0
+                    let opt_value = str2nr(ml[2])
+                elseif type == 1
+                    let opt_value = ml[2]
+                elseif type == 2
+                    let opt_value = function(ml[2])
+                elseif type == 3
+                    let opt_value = tlib#string#SplitCommaList(ml[2])
+                elseif type == 4
+                    throw 'tlib#arg#GetOpts: Unsupported type conversion for '. ml[1]
+                elseif type == 5
+                    let opt_value = str2float(ml[2])
+                endif
+            else
+                let opt_value = ml[2]
+            endif
+            let a:opts[ml[1]] = s:Validate(a:def, ml[1], opt_value)
+            unlet opt_value
+        endif
+    elseif short && a:opt =~# '^-\w='
+        let flagdefs = get(a:def, 'flags', {})
+        let flag = matchstr(a:opt, '^-\zs\w')
+        let rest = matchstr(a:opt, '^-\w\zs.*$')
+        call s:SetFlag(a:def, a:opts, idx, flag, rest, flagdefs)
+    elseif short && a:opt =~# '^-\w\+$'
+        let flagdefs = get(a:def, 'flags', {})
+        for flag in split(substitute(a:opt, '^-', '', ''), '\zs')
+            call s:SetFlag(a:def, a:opts, idx, flag, '', flagdefs)
+        endfor
+    else
+        let break = 1
+        if a:opt !=# '--'
+            let idx -= 1
+        endif
+    endif
+    return [break, idx]
+endf
+
+
+function! s:SetFlag(def, opts, idx, flag, rest, flagdefs) abort "{{{3
+    " TLogVAR a:def
+    if has_key(a:flagdefs, a:flag)
+        call s:SetOpt(a:def, a:opts, a:idx, a:flagdefs[a:flag] . a:rest)
+    else
+        let a:opts[a:flag] = s:Validate(a:def, a:flag, 1)
+    endif
+endf
+
+
+function! s:Validate(def, name, value) abort "{{{3
+    let values = get(a:def, 'values', {})
+    if has_key(values, a:name)
+        let vdef = values[a:name]
+        if has_key(vdef, 'validate')
+            if !call(vdef.validate, [a:value])
+                throw printf('tlib#arg: %s has invalid value: %s', string(a:name), string(a:value))
+            endif
+        endif
+    endif
+    return a:value
+endf
+
+
+":nodoc:
+function! tlib#arg#CComplete(def, ArgLead) abort "{{{3
+    let values = get(a:def, 'values', {})
+    let opt = matchstr(a:ArgLead, '^--\zs\w\+\ze=')
+    if has_key(values, opt)
+        let words = []
+        let vals = values[opt]
+        let complete_customlist = get(vals, 'complete_customlist', '')
+        if !empty(complete_customlist)
+            let words = eval(complete_customlist)
+        " else
+        "     let complete = get(vals, 'complete', '')
+        "     if !empty(complete)
+        "     endif
+        endif
+        if !empty(words)
+            let prefix = matchstr(a:ArgLead, '^--\w\+=\%([^,]\+,\s*\)*')
+            let lead = substitute(a:ArgLead, '^--\w\+=\%([^,]\+,\s*\)*', '', '')
+            " TLogVAR a:ArgLead, lead
+            if !empty(lead)
+                let nchar = len(lead)
+                call filter(words, 'tlib#string#Strcharpart(v:val, 0, nchar) ==# lead')
+            endif
+            let words = map(words, 'prefix . v:val')
+            return sort(words)
+        endif
+    endif
+    let cs = {'-h': 1, '--help': 1}
+    for [name, vdef] in items(values)
+        let type = s:GetValueType(vdef)
+        if type >= 0
+            let name .= '='
+        else
+            let cs['--no-'. name] = 1
+        endif
+        let cs['--'. name] = 1
+    endfor
+    for [name, subst] in items(get(a:def, 'flags', {}))
+        let ldef = get(values, substitute(subst, '^--', '', ''), {})
+        let type = s:GetValueType(ldef)
+        if type >= 0
+            let name .= '='
+        endif
+        let cs['-'. name] = 1
+    endfor
+    if has_key(a:def, 'trace')
+        let cs['--debug'] = 1
+    endif
+    let nchar = len(a:ArgLead)
+    if nchar > 0
+        call filter(cs, 'tlib#string#Strcharpart(v:key, 0, nchar) ==# a:ArgLead')
+    endif
+    return sort(keys(cs))
+endf
+
+
+
+""" Command line {{{1
+
+" :def: function! tlib#arg#Ex(arg, ?chars='%#! ')
+" Escape some characters in a string.
+"
+" Use |fnamescape()| if available.
+"
+" EXAMPLES: >
+"   exec 'edit '. tlib#arg#Ex('foo%#bar.txt')
+function! tlib#arg#Ex(arg, ...) "{{{3
+    if exists('*fnameescape') && a:0 == 0
+        return fnameescape(a:arg)
+    else
+        " let chars = '%# \'
+        let chars = '%#! '
+        if a:0 >= 1
+            let chars .= a:1
+        endif
+        return escape(a:arg, chars)
+    endif
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/assert.vim

@@ -0,0 +1,44 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2017-02-22
+" @Revision:    42
+
+
+" Enable tracing via |:Tlibassert|.
+function! tlib#assert#Enable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ -bang Tlibassert call tlib#assert#Assert(expand('<sfile>'), <q-args>, [<args>])
+endf
+
+
+" Disable tracing via |:Tlibassert|.
+function! tlib#assert#Disable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ -bang Tlibassert :
+endf
+
+
+function! tlib#assert#Assert(caller, check, vals) abort "{{{3
+    for val in a:vals
+        " TLogVAR val
+        if type(val) == 3
+            call tlib#assert#Assert(a:caller, a:check, val)
+        elseif !val
+            throw 'Tlibassert: '. tlib#trace#Backtrace(a:caller) .': '. a:check
+        endif
+    endfor
+endf
+
+
+function! tlib#assert#Map(vals, expr) abort "{{{3
+    return tlib#assert#All(map(a:vals, a:expr))
+endf
+
+
+function! tlib#assert#All(vals) abort "{{{3
+    " TLogVAR a:vals, empty(filter(a:vals, '!v:val'))
+    return empty(filter(a:vals, '!v:val'))
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/autocmdgroup.vim

@@ -0,0 +1,14 @@
+" autocmdgroup.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    7
+
+augroup TLib
+    autocmd!
+augroup END
+
+
+function! tlib#autocmdgroup#Init() "{{{3
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/balloon.vim

@@ -0,0 +1,73 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @GIT:         http://github.com/tomtom/tlib_vim/
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-08-30.
+" @Last Change: 2015-11-23.
+" @Revision:    48
+
+
+function! tlib#balloon#Register(expr) "{{{3
+    if !has('balloon_eval')
+        return
+    endif
+    if !exists('b:tlib_balloons')
+        let b:tlib_balloons = []
+    endif
+    if !&ballooneval
+        setlocal ballooneval
+    endif
+    if &balloonexpr != 'tlib#balloon#Expr()'
+        if !empty(&balloonexpr)
+            call add(b:tlib_balloons, &balloonexpr)
+        endif
+        setlocal ballooneval balloonexpr=tlib#balloon#Expr()
+    endif
+    if index(b:tlib_balloons, a:expr) == -1
+        call add(b:tlib_balloons, a:expr)
+    endif
+endf
+
+
+function! tlib#balloon#Remove(expr) "{{{3
+    if exists('b:tlib_balloons')
+        call filter(b:tlib_balloons, 'v:val != a:expr')
+        if empty(b:tlib_balloons)
+            setlocal ballooneval&
+            setlocal balloonexpr&
+            unlet b:tlib_balloons
+        endif
+    endif
+endf
+
+
+function! tlib#balloon#Expr() "{{{3
+    " TLogVAR exists('b:tlib_balloons')
+    if !exists('b:tlib_balloons')
+        return ''
+    endif
+    let text = map(copy(b:tlib_balloons), 'eval(v:val)')
+    " TLogVAR b:tlib_balloons, text
+    call filter(text, '!empty(v:val)')
+    if has('balloon_multiline')
+        return join(text, "\n----------------------------------\n")
+    else
+        return get(text, 0, '')
+    endif
+endf
+
+
+function! tlib#balloon#Expand(expr) abort "{{{3
+    if v:beval_bufnr != bufnr('%')
+        " TLogVAR v:beval_bufnr, bufnr('%')
+        return ''
+    endif
+    let win = winsaveview()
+    try
+        call setpos('.', [v:beval_bufnr, v:beval_lnum, v:beval_col, 0])
+        return expand(a:expr)
+    finally
+        call winrestview(win)
+    endtry
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/bitwise.vim

@@ -0,0 +1,141 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    124
+
+
+function! tlib#bitwise#Num2Bits(num) "{{{3
+    if type(a:num) <= 1 || type(a:num) == 5
+        let bits = reverse(tlib#number#ConvertBase(a:num, 2, 'list'))
+    elseif type(a:num) == 3
+        let bits = copy(a:num)
+    else
+        throw "tlib#bitwise#Num2Bits: Must be number of list: ". string(a:num)
+    endif
+    return bits
+endf
+
+
+function! tlib#bitwise#Bits2Num(bits, ...) "{{{3
+    let base = a:0 >= 1 ? a:1 : 10
+    " TLogVAR a:bits
+    let num = 0.0
+    for i in range(len(a:bits))
+        if get(a:bits, i, 0)
+            let num += pow(2, i)
+        endif
+    endfor
+    " TLogVAR num
+    if base == 10
+        if type(base) == 5
+            return num
+        else
+            return float2nr(num)
+        endif
+    else
+        return tlib#number#ConvertBase(num, base)
+    endif
+endf
+
+
+function! tlib#bitwise#AND(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    return s:BitwiseComparison(a:num1, a:num2, rtype,
+                \ 'get(bits1, v:val) && get(bits2, v:val)')
+endf
+
+
+function! tlib#bitwise#OR(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    return s:BitwiseComparison(a:num1, a:num2, rtype,
+                \ 'get(bits1, v:val) || get(bits2, v:val)')
+endf
+
+
+function! tlib#bitwise#XOR(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    return s:BitwiseComparison(a:num1, a:num2, rtype,
+                \ 'get(bits1, v:val) ? !get(bits2, v:val) : get(bits2, v:val)')
+endf
+
+
+function! s:BitwiseComparison(num1, num2, rtype, expr) "{{{3
+    let bits1 = tlib#bitwise#Num2Bits(a:num1)
+    let bits2 = tlib#bitwise#Num2Bits(a:num2)
+    let range = range(max([len(bits1), len(bits2)]))
+    let bits = map(range, a:expr)
+    if a:rtype == 'num' || (a:rtype == 'auto' && type(a:num1) <= 1)
+        return tlib#bitwise#Bits2Num(bits)
+    else
+        return bits
+    endif
+endf
+
+
+function! tlib#bitwise#ShiftRight(bits, n) "{{{3
+    let bits = a:bits[a:n : -1]
+    if empty(bits)
+        let bits = [0]
+    endif
+    return bits
+endf
+
+
+function! tlib#bitwise#ShiftLeft(bits, n) "{{{3
+    let bits = repeat([0], a:n) + a:bits
+    return bits
+endf
+
+
+function! tlib#bitwise#Add(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    let bits1 = tlib#bitwise#Num2Bits(a:num1)
+    let bits2 = tlib#bitwise#Num2Bits(a:num2)
+    let range = range(max([len(bits1), len(bits2)]))
+    " TLogVAR bits1, bits2, range
+    let carry = 0
+    let bits  = []
+    for i in range
+        let sum = get(bits1, i) + get(bits2, i) + carry
+        if sum == 3
+            let bit = 1
+            let carry = 1
+        elseif sum == 2
+            let bit = 0
+            let carry = 1
+        elseif sum == 1
+            let bit = 1
+            let carry = 0
+        elseif sum == 0
+            let bit = 0
+            let carry = 0
+        endif
+        call add(bits, bit)
+        " TLogVAR i, bits, bit
+    endfor
+    if carry == 1
+        call add(bits, carry)
+    endif
+    if rtype == 'num' || (rtype == 'auto' && type(a:num1) <= 1)
+        return tlib#bitwise#Bits2Num(bits)
+    else
+        return bits
+    endif
+endf
+
+
+function! tlib#bitwise#Sub(num1, num2, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'num'
+    let bits1 = tlib#bitwise#Num2Bits(a:num1)
+    let bits2 = tlib#bitwise#Num2Bits(a:num2)
+    let range = range(max([len(bits1), len(bits2)]))
+    let bits2 = map(range, '!get(bits2, v:val)')
+    let bits2 = tlib#bitwise#Add(bits2, [1], 'bits')
+    let bits3 = tlib#bitwise#Add(bits1, bits2, 'bits')
+    let bits = bits3[0 : -2]
+    if rtype == 'num' || (rtype == 'auto' && type(a:num1) <= 1)
+        return tlib#bitwise#Bits2Num(bits)
+    else
+        return bits
+    endif
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/buffer.vim

@@ -0,0 +1,401 @@
+" buffer.vim
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-06-30.
+" @Last Change: 2017-09-28.
+" @Revision:    12.1.352
+
+
+" Where to display the line when using |tlib#buffer#ViewLine|.
+" For possible values for position see |scroll-cursor|.
+TLet g:tlib_viewline_position = 'zz'
+
+
+let s:bmru = []
+
+
+function! tlib#buffer#EnableMRU() abort "{{{3
+    call tlib#autocmdgroup#Init()
+    autocmd TLib BufEnter * call s:BMRU_Push(bufnr('%'))
+endf
+
+
+function! tlib#buffer#DisableMRU() abort "{{{3
+    call tlib#autocmdgroup#Init()
+    autocmd! TLib BufEnter
+endf
+
+
+function! s:BMRU_Push(bnr) abort "{{{3
+    let i = index(s:bmru, a:bnr)
+    if i >= 0
+        call remove(s:bmru, i)
+    endif
+    call insert(s:bmru, a:bnr)
+endf
+
+
+function! s:CompareBuffernameByBasename(a, b) abort "{{{3
+    let rx = '"\zs.\{-}\ze" \+\S\+ \+\d\+$'
+    let an = matchstr(a:a, rx)
+    let an = fnamemodify(an, ':t')
+    let bn = matchstr(a:b, rx)
+    let bn = fnamemodify(bn, ':t')
+    let rv = an == bn ? 0 : an > bn ? 1 : -1
+    return rv
+endf
+
+
+function! s:CompareBufferNrByMRU(a, b) abort "{{{3
+    let an = matchstr(a:a, '\s*\zs\d\+\ze')
+    let bn = matchstr(a:b, '\s*\zs\d\+\ze')
+    let ai = index(s:bmru, 0 + an)
+    if ai == -1
+        return 1
+    else
+        let bi = index(s:bmru, 0 + bn)
+        if bi == -1
+            return -1
+        else
+            return ai == bi ? 0 : ai > bi ? 1 : -1
+        endif
+    endif
+endf
+
+
+" Set the buffer to buffer and return a command as string that can be 
+" evaluated by |:execute| in order to restore the original view.
+function! tlib#buffer#Set(buffer) abort "{{{3
+    let lazyredraw = &lazyredraw
+    set lazyredraw
+    try
+        let cb = bufnr('%')
+        let sn = bufnr(a:buffer)
+        if sn != cb
+            let ws = bufwinnr(sn)
+            if ws != -1
+                let wb = bufwinnr('%')
+                exec ws.'wincmd w'
+                return wb.'wincmd w'
+            else
+                silent exec 'sbuffer! '. sn
+                return 'wincmd c'
+            endif
+        else
+            return ''
+        endif
+    finally
+        let &lazyredraw = lazyredraw
+    endtry
+endf
+
+
+" :def: function! tlib#buffer#Eval(buffer, code) abort
+" Evaluate CODE in BUFFER.
+"
+" EXAMPLES: >
+"   call tlib#buffer#Eval('foo.txt', 'echo b:bar')
+function! tlib#buffer#Eval(buffer, code) abort "{{{3
+    " let cb = bufnr('%')
+    " let wb = bufwinnr('%')
+    " " TLogVAR cb
+    " let sn = bufnr(a:buffer)
+    " let sb = sn != cb
+    let lazyredraw = &lazyredraw
+    set lazyredraw
+    let restore = tlib#buffer#Set(a:buffer)
+    try
+        exec a:code
+        " if sb
+        "     let ws = bufwinnr(sn)
+        "     if ws != -1
+        "         try
+        "             exec ws.'wincmd w'
+        "             exec a:code
+        "         finally
+        "             exec wb.'wincmd w'
+        "         endtry
+        "     else
+        "         try
+        "             silent exec 'sbuffer! '. sn
+        "             exec a:code
+        "         finally
+        "             wincmd c
+        "         endtry
+        "     endif
+        " else
+        "     exec a:code
+        " endif
+    finally
+        exec restore
+        let &lazyredraw = lazyredraw
+    endtry
+endf
+
+
+" :def: function! tlib#buffer#GetList(?show_hidden=0, ?show_number=0, " ?order='bufnr') abort
+" Possible values for the "order" argument:
+"   bufnr    :: Default behaviour
+"   mru      :: Sort buffers according to most recent use
+"   basename :: Sort by the file's basename (last component)
+"
+" NOTE: MRU order works on second invocation only. If you want to always 
+" use MRU order, call tlib#buffer#EnableMRU() in your ~/.vimrc file.
+function! tlib#buffer#GetList(...) abort
+    TVarArg ['show_hidden', 0], ['show_number', 0], ['order', '']
+    " TLogVAR show_hidden, show_number, order
+    let ls_bang = show_hidden ? '!' : ''
+    redir => bfs
+    exec 'silent ls'. ls_bang
+    redir END
+    let buffer_list = split(bfs, '\n')
+    if order ==# 'mru'
+        if empty(s:bmru)
+            call tlib#buffer#EnableMRU()
+            echom 'tlib: Installed Buffer MRU logger; disable with: call tlib#buffer#DisableMRU()'
+        else
+            call sort(buffer_list, function('s:CompareBufferNrByMRU'))
+        endif
+    elseif order ==# 'basename'
+        call sort(buffer_list, function('s:CompareBuffernameByBasename'))
+    endif
+    let buffer_nr = map(copy(buffer_list), 'str2nr(matchstr(v:val, ''\s*\zs\d\+\ze''))')
+    " TLogVAR buffer_list, buffer_nr
+    if show_number
+        call map(buffer_list, 'matchstr(v:val, ''^\s*\d\+.\{-}\ze\s\+\S\+ \d\+\s*$'')')
+    else
+        call map(buffer_list, 'matchstr(v:val, ''^\s*\d\+\zs.\{-}\ze\s\+\S\+ \d\+\s*$'')')
+    endif
+    " TLogVAR buffer_list
+    " call map(buffer_list, 'matchstr(v:val, ''^.\{-}\ze\s\+line \d\+\s*$'')')
+    " TLogVAR buffer_list
+    call map(buffer_list, 'matchstr(v:val, ''^[^"]\+''). printf("%-20s   %s", fnamemodify(matchstr(v:val, ''"\zs.\{-}\ze"$''), ":t"), fnamemodify(matchstr(v:val, ''"\zs.\{-}\ze"$''), ":h"))')
+    " TLogVAR buffer_list
+    return [buffer_nr, buffer_list]
+endf
+
+
+" :def: function! tlib#buffer#ViewLine(line, ?position='z') abort
+" line is either a number or a string that begins with a number.
+" For possible values for position see |scroll-cursor|.
+" See also |g:tlib_viewline_position|.
+function! tlib#buffer#ViewLine(line, ...) abort "{{{3
+    if a:line
+        TVarArg 'pos'
+        let ln = matchstr(a:line, '^\d\+')
+        let lt = matchstr(a:line, '^\d\+: \zs.*')
+        " TLogVAR pos, ln, lt
+        exec ln
+        if empty(pos)
+            let pos = tlib#var#Get('tlib_viewline_position', 'wbg')
+        endif
+        " TLogVAR pos
+        if !empty(pos)
+            exec 'norm! '. pos
+        endif
+        call tlib#buffer#HighlightLine(ln)
+        " let @/ = '\%'. ln .'l.*'
+    endif
+endf
+
+
+function! s:UndoHighlightLine() abort "{{{3
+    2match none
+    autocmd! TLib CursorMoved,CursorMovedI <buffer>
+    autocmd! TLib CursorHold,CursorHoldI <buffer>
+    autocmd! TLib InsertEnter,InsertChange,InsertLeave <buffer>
+    autocmd! TLib BufLeave,BufWinLeave,WinLeave,BufHidden <buffer>
+endf
+
+
+function! tlib#buffer#HighlightLine(...) abort "{{{3
+    TVarArg ['line', line('.')]
+    " exec '2match MatchParen /^\%'. a:line .'l.*/'
+    exec '2match Search /^\%'. line .'l.*/'
+    call tlib#autocmdgroup#Init()
+    exec 'autocmd TLib CursorMoved,CursorMovedI <buffer> if line(".") != '. line .' | call s:UndoHighlightLine() | endif'
+    autocmd TLib CursorHold,CursorHoldI <buffer> call s:UndoHighlightLine()
+    autocmd TLib InsertEnter <buffer> call s:UndoHighlightLine()
+    " autocmd TLib BufLeave,BufWinLeave,WinLeave,BufHidden <buffer> call s:UndoHighlightLine()
+endf
+
+
+" Delete the lines in the current buffer. Wrapper for |:delete|.
+function! tlib#buffer#DeleteRange(line1, line2) abort "{{{3
+    let r = @t
+    try
+        exec a:line1.','.a:line2.'delete t'
+    finally
+        let @t = r
+    endtry
+endf
+
+
+" Replace a range of lines.
+function! tlib#buffer#ReplaceRange(line1, line2, lines) abort
+    call tlib#buffer#DeleteRange(a:line1, a:line2)
+    call append(a:line1 - 1, a:lines)
+endf
+
+
+" Initialize some scratch area at the bottom of the current buffer.
+function! tlib#buffer#ScratchStart() abort "{{{3
+    norm! Go
+    let b:tlib_inbuffer_scratch = line('$')
+    return b:tlib_inbuffer_scratch
+endf
+
+
+" Remove the in-buffer scratch area.
+function! tlib#buffer#ScratchEnd() abort "{{{3
+    if !exists('b:tlib_inbuffer_scratch')
+        echoerr 'tlib: In-buffer scratch not initalized'
+    endif
+    call tlib#buffer#DeleteRange(b:tlib_inbuffer_scratch, line('$'))
+    unlet b:tlib_inbuffer_scratch
+endf
+
+
+" Run exec on all buffers via bufdo and return to the original buffer.
+function! tlib#buffer#BufDo(exec) abort "{{{3
+    let bn = bufnr('%')
+    exec 'bufdo '. a:exec
+    exec 'buffer! '. bn
+endf
+
+
+" :def: function! tlib#buffer#InsertText(text, keyargs) abort
+" Keyargs:
+"   'shift': 0|N
+"   'col': col('.')|N
+"   'lineno': line('.')|N
+"   'indent': 0|1
+"   'pos': 'e'|'s' ... Where to locate the cursor (somewhat like s and e in {offset})
+" Insert text (a string) in the buffer.
+function! tlib#buffer#InsertText(text, ...) abort "{{{3
+    TVarArg ['keyargs', {}]
+    " TLogVAR a:text, keyargs
+    let keyargs = extend({
+                \ 'shift': 0, 'col': col('.'), 'lineno': line('.'), 'pos': 'e', 'indent': 0
+                \ }, keyargs)
+    " TLogVAR keyargs
+    let grow = 0
+    let post_del_last_line = line('$') == 1
+    let line = getline(keyargs.lineno)
+    if keyargs.col + keyargs.shift > 0
+        let pre  = line[0 : (keyargs.col - 1 + keyargs.shift)]
+        let post = line[(keyargs.col + keyargs.shift): -1]
+    else
+        let pre  = ''
+        let post = line
+    endif
+    " TLogVAR keyargs.lineno, line, pre, post
+    let text0 = pre . a:text . post
+    let text  = split(text0, '\n', 1)
+    " TLogVAR text
+    let icol = len(pre)
+    " exec 'norm! '. keyargs.lineno .'G'
+    call cursor(keyargs.lineno, keyargs.col)
+    if keyargs.indent && keyargs.col > 1
+		if &formatoptions =~# '[or]'
+            " FIXME: Is the simple version sufficient?
+            " VERSION 1
+			" " This doesn't work because it's not guaranteed that the 
+			" " cursor is set.
+			" let cline = getline('.')
+			" norm! a
+			" "norm! o
+			" " TAssertExec redraw | sleep 3
+			" let idt = tlib#string#Strcharpart(getline('.'), 0, keyargs.col('.') + keyargs.shift)
+			" " TLogVAR idt
+			" let idtl = len(idt)
+			" -1,.delete
+			" " TAssertExec redraw | sleep 3
+			" call append(keyargs.lineno - 1, cline)
+			" call cursor(keyargs.lineno, keyargs.col)
+			" " TAssertExec redraw | sleep 3
+			" if idtl == 0 && icol != 0
+			" 	let idt = matchstr(pre, '^\s\+')
+			" 	let idtl = len(idt)
+			" endif
+            " VERSION 2
+            let idt = matchstr(pre, '^\s\+')
+            let idtl = len(idt)
+		else
+			let [m_0, idt, iline; rest] = matchlist(pre, '^\(\s*\)\(.*\)$')
+			let idtl = len(idt)
+		endif
+		if idtl < icol
+			let idt .= repeat(' ', icol - idtl)
+		endif
+        " TLogVAR idt
+        let idtl1 = len(idt)
+        for i in range(1, len(text) - 1)
+            let text[i] = idt . text[i]
+            let grow += idtl1
+        endfor
+    endif
+    " TLogVAR text
+    " exec 'norm! '. keyargs.lineno .'Gdd'
+    call tlib#normal#WithRegister('"tdd', 't')
+    call append(keyargs.lineno - 1, text)
+    if post_del_last_line
+        call tlib#buffer#KeepCursorPosition('$delete')
+    endif
+    let tlen = len(text)
+    let posshift = matchstr(keyargs.pos, '\d\+')
+    " TLogVAR keyargs.pos
+    if keyargs.pos =~# '^e'
+        exec keyargs.lineno + tlen - 1
+        exec 'norm! 0'. (len(text[-1]) - len(post) + posshift - 1) .'l'
+    elseif keyargs.pos =~# '^s'
+        " TLogVAR keyargs.lineno, pre, posshift
+        exec keyargs.lineno
+        exec 'norm! '. len(pre) .'|'
+        if !empty(posshift)
+            exec 'norm! '. posshift .'h'
+        endif
+    endif
+    " TLogDBG getline(keyargs.lineno)
+    " TLogDBG string(getline(1, '$'))
+    return grow
+endf
+
+
+function! tlib#buffer#InsertText0(text, ...) abort "{{{3
+    TVarArg ['keyargs', {}]
+    let mode = get(keyargs, 'mode', 'i')
+    " TLogVAR mode
+    if !has_key(keyargs, 'shift')
+        let col = col('.')
+        " if mode =~ 'i'
+        "     let col += 1
+        " endif
+        let keyargs.shift = col >= col('$') ? 0 : -1
+        " let keyargs.shift = col('.') >= col('$') ? 0 : -1
+        " TLogVAR col
+        " TLogDBG col('.') .'-'. col('$') .': '. string(getline('.'))
+    endif
+    " TLogVAR keyargs.shift
+    return tlib#buffer#InsertText(a:text, keyargs)
+endf
+
+
+function! tlib#buffer#CurrentByte() abort "{{{3
+    return line2byte(line('.')) + col('.')
+endf
+
+
+" Evaluate cmd while maintaining the cursor position and jump registers.
+function! tlib#buffer#KeepCursorPosition(cmd) abort "{{{3
+    " let pos = getpos('.')
+    let view = winsaveview()
+    try
+        keepjumps exec a:cmd
+    finally
+        " call setpos('.', pos)
+        call winrestview(view)
+    endtry
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/cache.vim

@@ -0,0 +1,464 @@
+" cache.vim
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-06-30.
+" @Last Change: 2019-01-02.
+" @Revision:    125.1.243
+
+
+" The cache directory. If empty, use |tlib#dir#MyRuntime|.'/cache'.
+" You might want to delete old files from this directory from time to 
+" time with a command like: >
+"   find ~/vimfiles/cache/ -atime +31 -type f -print -delete
+TLet g:tlib_cache = ''
+
+" |tlib#cache#Purge()|: Remove cache files older than N days.
+TLet g:tlib#cache#purge_days = 31
+
+" Purge the cache every N days. Disable automatic purging by setting 
+" this value to a negative value.
+TLet g:tlib#cache#purge_every_days = 31
+
+" The encoding used for the purge-cache script.
+" Default: 'enc'
+TLet g:tlib#cache#script_encoding = &enc
+
+" Whether to run the directory removal script:
+"    0 ... No
+"    1 ... Query user
+"    2 ... Yes
+TLet g:tlib#cache#run_script = 1
+
+" Verbosity level:
+"     0 ... Be quiet
+"     1 ... Display informative message
+"     2 ... Display detailed messages
+TLet g:tlib#cache#verbosity = 1
+
+" A list of regexps that are matched against partial filenames of the 
+" cached files. If a regexp matches, the file won't be removed by 
+" |tlib#cache#Purge()|.
+TLet g:tlib#cache#dont_purge = ['[\/]\.last_purge$']
+
+" If the cache filename is longer than N characters, use 
+" |pathshorten()|.
+TLet g:tlib#cache#max_filename = 200
+
+TLet g:tlib#cache#use_json = 0
+
+TLet g:tlib#cache#use_encoding = ''
+
+
+let s:cache = {}
+
+
+" :display: tlib#cache#Dir(?mode = 'bg', ?ensure_dir = true)
+" The default cache directory.
+function! tlib#cache#Dir(...) "{{{3
+    TVarArg ['mode', 'bg'], ['ensure_dir', 1]
+    let dir = tlib#var#Get('tlib_cache', mode)
+    if empty(dir)
+        let dir = tlib#file#Join([tlib#dir#MyRuntime(), 'cache'])
+    endif
+    if ensure_dir
+        call tlib#dir#Ensure(dir)
+    endif
+    return dir
+endf
+
+
+" :display: tlib#cache#EncodedFilename(type, file, ?mkdir=0, ?dir='')
+" Encode `file` and call |tlib#cache#Filename()|.
+function! tlib#cache#EncodedFilename(type, file, ...) "{{{3
+    let file = tlib#url#Encode(a:file)
+    return call(function('tlib#cache#Filename'), [a:type, file] + a:000)
+endf
+
+
+" :def: function! tlib#cache#Filename(type, ?file=%, ?mkdir=0, ?dir='')
+function! tlib#cache#Filename(type, ...) "{{{3
+    " TLogDBG 'bufname='. bufname('.')
+    let dir0 = a:0 >= 3 && !empty(a:3) ? a:3 : tlib#cache#Dir()
+    let dir = dir0
+    if a:0 >= 1 && !empty(a:1)
+        let file  = a:1
+    else
+        if empty(expand('%:t'))
+            return ''
+        endif
+        let file  = expand('%:p')
+        let file  = tlib#file#Relative(file, tlib#file#Join([dir, '..']))
+    endif
+    " TLogVAR file, dir
+    let mkdir = a:0 >= 2 ? a:2 : 0
+    let file  = substitute(file, '\.\.\|[:&<>]\|//\+\|\\\\\+', '_', 'g')
+    let dirs  = [dir, a:type]
+    let dirf  = fnamemodify(file, ':h')
+    if dirf != '.'
+        call add(dirs, dirf)
+    endif
+    let dir   = tlib#file#Join(dirs)
+    " TLogVAR dir
+    let dir   = tlib#dir#PlainName(dir)
+    " TLogVAR dir
+    let file  = fnamemodify(file, ':t')
+    " TLogVAR file, dir, mkdir
+    let cache_file = tlib#file#Join([dir, file])
+    if len(cache_file) > g:tlib#cache#max_filename
+        " echom "DBG long filename" cache_file
+        " echom "DBG long filename" dir
+        if v:version >= 704
+            let shortfilename = sha256(file)
+        else
+            let shortfilename = tlib#hash#Adler32(file)
+        endif
+        " let cache_file = tlib#cache#Filename(a:type, shortfilename, mkdir, dir0)
+        let cache_file = tlib#file#Join([dir, shortfilename])
+    else
+        if mkdir && !isdirectory(dir)
+            try
+                call mkdir(dir, 'p')
+            catch /^Vim\%((\a\+)\)\=:E739:/
+                if filereadable(dir) && !isdirectory(dir)
+                    echoerr 'TLib: Cannot create directory for cache file because a file with the same name exists (please delete it):' dir
+                    " call delete(dir)
+                    " call mkdir(dir, 'p')
+                endif
+            endtry
+        endif
+    endif
+    " TLogVAR cache_file
+    return cache_file
+endf
+
+
+let s:timestamps = {}
+
+
+function! s:SetTimestamp(cfile, type) "{{{3
+    if !has_key(s:timestamps, a:cfile)
+        let s:timestamps[a:cfile] = {}
+    endif
+    let s:timestamps[a:cfile].atime = getftime(a:cfile)
+    let s:timestamps[a:cfile][a:type] = s:timestamps[a:cfile].atime
+endf
+
+
+function! s:PutValue(cfile, value) abort "{{{3
+    let s:cache[a:cfile] = {'mtime': localtime(), 'data': a:value}
+endf
+
+
+function! s:GetValue(cfile, default) abort "{{{3
+    return get(get(s:cache, a:cfile, {}), 'data', a:default)
+endf
+
+
+function! s:GetCacheTime(cfile) abort "{{{3
+    let not_found = !has_key(s:cache, a:cfile)
+    let cftime = not_found ? -1 : s:cache[a:cfile].mtime
+    return cftime
+endf
+
+
+function! tlib#cache#Save(cfile, value, ...) "{{{3
+    TVarArg ['options', {}]
+    let in_memory = get(options, 'in_memory', 0)
+    if in_memory
+        " TLogVAR in_memory, a:cfile, localtime()
+        call s:PutValue(a:cfile, a:value)
+    elseif !empty(a:cfile)
+        " TLogVAR a:value
+        let cfile = a:cfile
+        if g:tlib#cache#use_json && exists('*json_encode')
+            try
+                let value = json_encode(a:value)
+                let cfile .= '.json'
+            catch
+                echoerr v:exception
+                let value = string(a:value)
+            endtry
+        else
+            let value = string(a:value)
+        endif
+        Tlibtrace 'tlib', cfile, value
+        call writefile([value], cfile, 'b')
+        call s:SetTimestamp(a:cfile, 'write')
+    endif
+endf
+
+
+function! tlib#cache#MTime(cfile) "{{{3
+    let mtime = {'mtime': getftime(a:cfile)}
+    let mtime = extend(mtime, get(s:timestamps, a:cfile, {}))
+    return mtime
+endf
+
+
+function! tlib#cache#Get(cfile, ...) "{{{3
+    TVarArg ['default', {}], ['options', {}]
+    let in_memory = get(options, 'in_memory', 0)
+    if in_memory
+        " TLogVAR in_memory, a:cfile
+        return s:GetValue(a:cfile, default)
+    else
+        call tlib#cache#MaybePurge()
+        if !empty(a:cfile)
+            let jsonfile = a:cfile .'.json'
+            let use_json = g:tlib#cache#use_json && exists('*json_decode') && exists('v:none') && filereadable(jsonfile)
+            if use_json
+                let use_json = 1
+                let cfile = jsonfile
+            else
+                let cfile = a:cfile
+            endif
+            let mt = s:GetCacheTime(cfile)
+            let ft = getftime(cfile)
+            if mt != -1 && mt >= ft
+                return s:GetValue(cfile, default)
+            elseif ft != -1
+                call s:SetTimestamp(cfile, 'read')
+                let val = join(readfile(cfile, 'b'), '\n')
+                try
+                    if use_json
+                        " NOTE: Copy result of json_decode() in order to 
+                        " avoid "E741: value is locked" error in vim8.
+                        let value = json_decode(val)
+                        if value is v:none
+                            let value = default
+                        else
+                            let value = copy(value)
+                        endif
+                    else
+                        let value = eval(val)
+                    endif
+                    call s:PutValue(cfile, value)
+                    return value
+                catch
+                    echohl ErrorMsg
+                    echom v:exception
+                    echom 'tlib#cache#Get: Invalid value in:' cfile
+                    echom 'Value:' string(val)
+                    echom 'Please review the file and delete it if necessary'
+                    echom 'Will use default value:' string(default)
+                    echohl NONE
+                    if g:tlib#debug
+                        let @* = string(val)
+                    endif
+                    " call s:PutValue(cfile, default)
+                    return default
+                endtry
+            endif
+        endif
+        return default
+    endif
+endf
+
+
+" :display: tlib#cache#Value(cfile, generator, ftime, ?generator_args=[], ?options={})
+" Get a cached value from cfile. If it is outdated (compared to ftime) 
+" or does not exist, create it calling a generator function.
+function! tlib#cache#Value(cfile, generator, ftime, ...) "{{{3
+    TVarArg ['args', []], ['options', {}]
+    let in_memory = get(options, 'in_memory', 0)
+    if in_memory
+        let cftime = s:GetCacheTime(a:cfile)
+    else
+        let cftime = getftime(a:cfile)
+    endif
+    let ftime = a:ftime
+    " TLogVAR in_memory, cftime
+    if cftime == -1 || ftime == -1 || (ftime != 0 && cftime < ftime)
+        " TLogVAR a:generator, args
+        let val = call(a:generator, args)
+        " TLogVAR val
+        let cval = {'val': val}
+        " TLogVAR cval
+        call tlib#cache#Save(a:cfile, cval, options)
+        return val
+    else
+        let val = tlib#cache#Get(a:cfile, {}, options)
+        if !has_key(val, 'val')
+            throw 'tlib#cache#Value: Internal error: '. a:cfile
+        else
+            return val.val
+        endif
+    endif
+endf
+
+
+function! tlib#cache#ValueFromName(type, name, ...) abort "{{{3
+    let cfile = tlib#cache#Filename(a:type, tlib#url#Encode(a:name), 1)
+    return call(function('tlib#cache#Value'), [cfile] + a:000)
+endf
+
+
+" Call |tlib#cache#Purge()| if the last purge was done before 
+" |g:tlib#cache#purge_every_days|.
+function! tlib#cache#MaybePurge() "{{{3
+    if g:tlib#cache#purge_every_days < 0
+        return
+    endif
+    let dir = tlib#cache#Dir('g')
+    let last_purge = tlib#file#Join([dir, '.last_purge'])
+    let last_purge_exists = filereadable(last_purge)
+    if last_purge_exists
+        let threshold = localtime() - g:tlib#cache#purge_every_days * g:tlib#date#dayshift
+        let should_purge = getftime(last_purge) < threshold
+    else
+        let should_purge = 0 " should ignore empty dirs, like the tmru one: !empty(glob(tlib#file#Join([dir, '**'])))
+    endif
+    if should_purge
+        if last_purge_exists
+            let yn = 'y'
+        else
+            let txt = "TLib: The cache directory '". dir ."' should be purged of old files.\nDelete files older than ". g:tlib#cache#purge_days ." days now?"
+            let yn = tlib#input#Dialog(txt, ['yes', 'no'], 'no')
+        endif
+        if yn =~ '^y\%[es]$'
+            call tlib#cache#Purge()
+        else
+            let g:tlib#cache#purge_every_days = -1
+            if !last_purge_exists
+                call s:PurgeTimestamp(dir)
+            endif
+            echohl WarningMsg
+            echom "TLib: Please run :call tlib#cache#Purge() to clean up ". dir
+            echohl NONE
+        endif
+    elseif !last_purge_exists
+        call s:PurgeTimestamp(dir)
+    endif
+endf
+
+
+" Delete old files.
+function! tlib#cache#Purge() "{{{3
+    let threshold = localtime() - g:tlib#cache#purge_days * g:tlib#date#dayshift
+    let dir = tlib#cache#Dir('g')
+    if g:tlib#cache#verbosity >= 1
+        echohl WarningMsg
+        echom "TLib: Delete files older than ". g:tlib#cache#purge_days ." days from ". dir
+        echohl NONE
+    endif
+    let files = tlib#cache#ListFilesInCache()
+    let deldir = []
+    let newer = []
+    let msg = []
+    let more = &more
+    set nomore
+    try
+        for file in files
+            if isdirectory(file)
+                if empty(filter(copy(newer), 'tlib#string#Strcharpart(v:val, 0, len(file)) ==# file'))
+                    call add(deldir, file)
+                endif
+            else
+                if getftime(file) < threshold
+                    call s:Delete(msg, file, '')
+                else
+                    call add(newer, file)
+                endif
+            endif
+        endfor
+    finally
+        let &more = more
+    endtry
+    if !empty(msg) && g:tlib#cache#verbosity >= 1
+        echo join(msg, "\n")
+    endif
+    if !empty(deldir)
+        let deldir = filter(reverse(sort(deldir)), 's:Delete(msg, v:val, "d")')
+        if !empty(deldir)
+            if &shell =~ 'sh\(\.exe\)\?$'
+                let scriptfile = 'deldir.sh'
+                let rmdir = 'rm -rf %s'
+            else
+                let scriptfile = 'deldir.bat'
+                let rmdir = 'rmdir /S /Q %s'
+            endif
+            let enc = g:tlib#cache#script_encoding
+            if has('multi_byte') && enc != &enc
+                call map(deldir, 'iconv(v:val, &enc, enc)')
+            endif
+            let scriptfile = tlib#file#Join([dir, scriptfile])
+            if filereadable(scriptfile)
+                let script = readfile(scriptfile)
+            else
+                let script = []
+            endif
+            let script += map(copy(deldir), 'printf(rmdir, shellescape(v:val, 1))')
+            let script = tlib#list#Uniq(script)
+            call writefile(script, scriptfile)
+            call inputsave()
+            if g:tlib#cache#run_script == 0
+                if g:tlib#cache#verbosity >= 1
+                    echohl WarningMsg
+                    if g:tlib#cache#verbosity >= 2
+                        echom "TLib: Purged cache. Need to run script to delete directories"
+                    endif
+                    echom "TLib: Please review and execute: ". scriptfile
+                    echohl NONE
+                endif
+            else
+                try
+                    let yn = g:tlib#cache#run_script == 2 ? 'y' : tlib#input#Dialog("TLib: About to delete directories by means of a shell script.\nDirectory removal script: ". scriptfile ."\nRun script to delete directories now?", ['yes', 'no', 'edit'], 'no')
+                    if yn =~ '^y\%[es]$'
+                        exec 'silent cd '. fnameescape(dir)
+                        exec '! ' &shell shellescape(scriptfile, 1)
+                        exec 'silent cd -'
+                        call delete(scriptfile)
+                    elseif yn =~ '^e\%[dit]$'
+                        exec 'edit '. fnameescape(scriptfile)
+                    endif
+                finally
+                    call inputrestore()
+                endtry
+            endif
+        endif
+    endif
+    call s:PurgeTimestamp(dir)
+endf
+
+
+function! s:Delete(msg, file, flags) abort "{{{3
+    let rv = delete(a:file, a:flags)
+    if !rv && g:tlib#cache#verbosity >= 2
+        call add(a:msg, "TLib#cache: Delete ". file)
+    endif
+    return rv
+endf
+
+
+function! s:PurgeTimestamp(dir) "{{{3
+    let last_purge = tlib#file#Join([a:dir, '.last_purge'])
+    " TLogVAR last_purge
+    call writefile([" "], last_purge)
+endf
+
+function! tlib#cache#ListFilesInCache(...) "{{{3
+    let dir = a:0 >= 1 ? a:1 : tlib#cache#Dir('g')
+    if v:version > 702 || (v:version == 702 && has('patch51'))
+        let filess = glob(tlib#file#Join([dir, '**']), 1)
+    else
+        let filess = glob(tlib#file#Join([dir, '**']))
+    endif
+    let files = reverse(split(filess, '\n'))
+    let pos0 = len(tlib#dir#CanonicName(dir))
+    call filter(files, 's:ShouldPurge(tlib#string#Strcharpart(v:val, pos0))')
+    return files
+endf
+
+
+function! s:ShouldPurge(partial_filename) "{{{3
+    " TLogVAR a:partial_filename
+    for rx in g:tlib#cache#dont_purge
+        if a:partial_filename =~ rx
+            " TLogVAR a:partial_filename, rx
+            return 0
+        endif
+    endfor
+    return 1
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/char.vim

@@ -0,0 +1,59 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    38
+
+
+" :def: function! tlib#char#Get(?timeout=0)
+" Get a character.
+"
+" EXAMPLES: >
+"   echo tlib#char#Get()
+"   echo tlib#char#Get(5)
+function! tlib#char#Get(...) "{{{3
+    TVarArg ['timeout', 0], ['resolution', 0], ['getmod', 0]
+    let char = -1
+    let mode = 0
+    if timeout == 0 || !has('reltime')
+        let char = getchar()
+    else
+        let char = tlib#char#GetWithTimeout(timeout, resolution)
+    endif
+    if getmod
+        if char != -1
+            let mode = getcharmod()
+        endif
+        return [char, mode]
+    else
+        return char
+    endif
+endf
+
+
+function! tlib#char#IsAvailable() "{{{3
+    let ch = getchar(1)
+    return type(ch) == 0 && ch != 0
+endf
+
+
+function! tlib#char#GetWithTimeout(timeout, ...) "{{{3
+    TVarArg ['resolution', 2]
+    " TLogVAR a:timeout, resolution
+    let start = tlib#time#MSecs()
+    while 1
+        let c = getchar(0)
+        if type(c) != 0 || c != 0
+            return c
+        else
+            let now = tlib#time#MSecs()
+            let diff = tlib#time#DiffMSecs(now, start, resolution)
+            " TLogVAR diff
+            if diff > a:timeout
+                return -1
+            endif
+        endif
+    endwh
+    return -1
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/cmd.vim

@@ -0,0 +1,117 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    58
+
+
+let g:tlib#cmd#last_output = []
+
+
+function! tlib#cmd#OutputAsList(command) "{{{3
+    " TLogVAR a:command
+    if exists('s:redir_lines')
+        redir END
+        let cache = s:redir_lines
+    endif
+    let s:redir_lines = ''
+    redir =>> s:redir_lines
+    silent! exec a:command
+    redir END
+    let g:tlib#cmd#last_output = split(s:redir_lines, '\n')
+    unlet s:redir_lines
+    if exists('cache')
+        let s:redir_lines = cache
+        redir =>> s:redir_lines
+    endif
+    return g:tlib#cmd#last_output
+endf
+
+
+" See |:TBrowseOutput|.
+function! tlib#cmd#BrowseOutput(command) "{{{3
+    call tlib#cmd#BrowseOutputWithCallback("tlib#cmd#DefaultBrowseOutput", a:command)
+endf
+
+" :def: function! tlib#cmd#BrowseOutputWithCallback(callback, command)
+" Execute COMMAND and present its output in a |tlib#input#List()|;
+" when a line is selected, execute the function named as the CALLBACK
+" and pass in that line as an argument.
+"
+" The CALLBACK function gives you an opportunity to massage the COMMAND output
+" and possibly act on it in a meaningful way. For example, if COMMAND listed
+" all URIs found in the current buffer, CALLBACK could validate and then open
+" the selected URI in the system's default browser.
+"
+" This function is meant to be a tool to help compose the implementations of
+" powerful commands that use |tlib#input#List()| as a common interface. See
+" |TBrowseScriptnames| as an example.
+"
+" EXAMPLES: >
+"   call tlib#cmd#BrowseOutputWithCallback('tlib#cmd#ParseScriptname', 'scriptnames')
+function! tlib#cmd#BrowseOutputWithCallback(callback, command) "{{{3
+    let list = tlib#cmd#OutputAsList(a:command)
+    let cmds = tlib#input#List('m', 'Output of: '. a:command, list)
+    if !empty(cmds)
+        for cmd in cmds
+            let Callback = function(a:callback)
+            call call(Callback, [cmd])
+        endfor
+    endif
+endf
+
+function! tlib#cmd#DefaultBrowseOutput(cmd) "{{{3
+    call feedkeys(':'. a:cmd)
+endf
+
+function! tlib#cmd#ParseScriptname(line) "{{{3
+    " let parsedValue = substitute(a:line, '^.\{-}\/', '/', '')
+    let parsedValue = matchstr(a:line, '^\s*\d\+:\s*\zs.*$')
+    exe 'drop '. fnameescape(parsedValue)
+endf
+
+
+function! tlib#cmd#TBrowseScriptnames() abort "{{{3
+   call tlib#cmd#BrowseOutputWithCallback("tlib#cmd#ParseScriptname", "scriptnames")
+endf
+
+
+" :def: function! tlib#cmd#UseVertical(?rx='')
+" Look at the history whether the command was called with vertical. If 
+" an rx is provided check first if the last entry in the history matches 
+" this rx.
+function! tlib#cmd#UseVertical(...) "{{{3
+    TVarArg ['rx']
+    let h0 = histget(':')
+    let rx0 = '\C\<vert\%[ical]\>\s\+'
+    if !empty(rx)
+        let rx0 .= '.\{-}'.rx
+    endif
+    " TLogVAR h0, rx0
+    return h0 =~ rx0
+endf
+
+
+" Print the time in seconds or milliseconds (if your version of VIM 
+" has |+reltime|) a command takes.
+function! tlib#cmd#Time(cmd) "{{{3
+    if has('reltime')
+        let start = tlib#time#Now()
+        exec a:cmd
+        let end = tlib#time#Now()
+        let diff = string(tlib#time#Diff(end, start)) .'ms'
+    else
+        let start = localtime()
+        exec a:cmd
+        let diff = (localtime() - start) .'s'
+    endif
+    echom 'Time: '. diff .': '. a:cmd
+endf
+
+
+function! tlib#cmd#Capture(cmd) "{{{3
+    redir => s
+    silent exec a:cmd
+    redir END
+    return s
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/comments.vim

@@ -0,0 +1,26 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    25
+
+
+" function! tlib#comments#Comments(?rx='')
+function! tlib#comments#Comments(...)
+    TVarArg ['rx', '']
+    let comments = {}
+    let co = &comments
+    while !empty(co)
+        " TLogVAR co
+        let [m_0, m_key, m_val, m_val1, co0, co; rest] = matchlist(co, '^\([^:]*\):\(\(\\.\|[^,]*\)\+\)\(,\(.*\)$\|$\)')
+        " TLogVAR m_key, m_val, co
+        if empty(m_key)
+            let m_key = ':'
+        endif
+        if empty(rx) || m_key =~ rx
+            let comments[m_key] = m_val
+        endif
+    endwh
+    return comments
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/date.vim

@@ -0,0 +1,195 @@
+" date.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-03-25.
+" @Last Change: 2017-09-06.
+" @Revision:    44.0.34
+
+
+if !exists('g:tlib#date#ShortDatePrefix') | let g:tlib#date#ShortDatePrefix = '20' | endif "{{{2
+if !exists('g:tlib#date#TimeZoneShift')   | let g:tlib#date#TimeZoneShift = 0      | endif "{{{2
+
+let g:tlib#date#dayshift = 60 * 60 * 24
+" let g:tlib#date#date_rx = '\<\(\d\{4}\)-\(\d\d\)-\(\d\d\)\%(\s\+\(\(\d\d\):\(\d\d\)\)\)\?\>'
+let g:tlib#date#date_rx = '\<\(\d\{4}\)-\(\d\d\)-\(\d\d\)\>'
+let g:tlib#date#date_format = '%Y-%m-%d'
+
+
+function! tlib#date#IsDate(text) abort "{{{3
+    return a:text =~# '^'. g:tlib#date#date_rx .'$' &&
+                \ !empty(tlib#date#Parse(a:text, 0, 1))
+endf
+
+
+function! tlib#date#Format(...) abort "{{{3
+    let secs1970 = a:0 >= 1 ? a:1 : localtime()
+    return strftime(g:tlib#date#date_format, secs1970)
+endf
+
+
+" :display: tlib#date#DiffInDays(date1, ?date2=localtime(), ?allow_zero=0)
+function! tlib#date#DiffInDays(date, ...)
+    let allow_zero = a:0 >= 2 ? a:2 : 0
+    let s0 = tlib#date#SecondsSince1970(a:date, 0, allow_zero)
+    let s1 = a:0 >= 1 ? tlib#date#SecondsSince1970(a:1, 0, allow_zero) : localtime()
+    let dd = (s0 - s1) / g:tlib#date#dayshift
+    " TLogVAR dd
+    return dd
+endf
+
+
+" :display: tlib#date#Parse(date, ?allow_zero=0, ?silent=0) "{{{3
+function! tlib#date#Parse(date, ...) "{{{3
+    let min = a:0 >= 1 && a:1 ? 0 : 1
+    let silent = a:0 >= 2 ? a:2 : 0
+    Tlibtype 'tlib', a:date, min, silent
+    let m = matchlist(a:date, '^\(\d\{2}\|\d\{4}\)-\(\d\{1,2}\)-\(\d\{1,2}\)$')
+    Tlibtype 'tlib', m
+    let year = ''
+    let month = ''
+    let days = ''
+    if !empty(m)
+        let year = m[1]
+        let month = m[2]
+        let days = m[3]
+    else
+        let m = matchlist(a:date, '^\(\d\+\)/\(\d\{1,2}\)/\(\d\{1,2}\)$')
+        if !empty(m)
+            let year = m[1]
+            let month = m[3]
+            let days = m[2]
+        else
+            let m = matchlist(a:date, '^\(\d\{1,2}\)\.\s*\(\d\{1,2}\)\.\s*\(\d\d\{2}\|\d\{4}\)$')
+            if !empty(m)
+                let year = m[3]
+                let month = m[2]
+                let days = m[1]
+            endif
+        endif
+    endif
+    Tlibtype 'tlib', year, month, days
+    if empty(m) || year == '' || month == '' || days == '' || 
+                \ month < min || month > 12 || days < min || days > 31
+        if !silent
+            echoerr 'TLib: Invalid date: '. a:date
+        endif
+        return []
+    endif
+    if strlen(year) == 2
+        let year = g:tlib#date#ShortDatePrefix . year
+        Tlibtype 'tlib', year
+    endif
+    return [0 + year, 0 + month, 0 + days]
+endf
+
+
+" tlib#date#SecondsSince1970(date, ?daysshift=0, ?allow_zero=0)
+function! tlib#date#SecondsSince1970(date, ...) "{{{3
+    let allow_zero = a:0 >= 2 ? a:2 : 0
+    " TLogVAR a:date, allow_zero
+    let date = tlib#date#Parse(a:date, allow_zero)
+    if empty(date)
+        return 0
+    endif
+    let [year, month, days] = date
+    if a:0 >= 1 && a:1 > 0
+        let days = days + a:1
+    end
+    let days_passed = days
+    let i = 1970
+    while i < year
+        let days_passed = days_passed + 365
+        if i % 4 == 0 || i == 2000
+            let days_passed = days_passed + 1
+        endif
+        let i = i + 1
+    endwh
+    let i = 1
+    while i < month
+        if i == 1
+            let days_passed = days_passed + 31
+        elseif i == 2
+            let days_passed = days_passed + 28
+            if year % 4 == 0 || year == 2000
+                let days_passed = days_passed + 1
+            endif
+        elseif i == 3
+            let days_passed = days_passed + 31
+        elseif i == 4
+            let days_passed = days_passed + 30
+        elseif i == 5
+            let days_passed = days_passed + 31
+        elseif i == 6
+            let days_passed = days_passed + 30
+        elseif i == 7
+            let days_passed = days_passed + 31
+        elseif i == 8
+            let days_passed = days_passed + 31
+        elseif i == 9
+            let days_passed = days_passed + 30
+        elseif i == 10
+            let days_passed = days_passed + 31
+        elseif i == 11
+            let days_passed = days_passed + 30
+        endif
+        let i = i + 1
+    endwh
+    let seconds = (days_passed - 1) * 24 * 60 * 60
+    let seconds = seconds + (strftime('%H') + g:tlib#date#TimeZoneShift) * 60 * 60
+    let seconds = seconds + strftime('%M') * 60
+    let seconds = seconds + strftime('%S')
+    return seconds
+endf
+
+
+function! tlib#date#Shift(date, shift) abort "{{{3
+    let n = str2nr(matchstr(a:shift, '\d\+'))
+    let ml = matchlist(a:date, g:tlib#date#date_rx)
+    " TLogVAR a:date, a:shift, n, ml
+    if a:shift =~ 'd$'
+        let date = tlib#date#AddDays(a:date, n)
+    elseif a:shift =~ 'b$'
+        let n1 = n
+        let secs = tlib#date#SecondsSince1970(a:date)
+        while n1 > 0
+            let n1 -= 1
+            let secs += g:tlib#date#dayshift
+            let uday = strftime('%u', secs)
+            if uday == 6
+                let secs += g:tlib#date#dayshift * 2
+            elseif uday == 7
+                let secs += g:tlib#date#dayshift
+            endif
+        endwh
+        let date = tlib#date#Format(secs)
+    elseif a:shift =~ 'w$'
+        let date = tlib#date#AddDays(a:date, n * 7)
+    elseif a:shift =~ 'm$'
+        let d = str2nr(ml[3])
+        let ms = str2nr(ml[2]) + n
+        let m = (ms - 1) % 12 + 1
+        let yr = str2nr(ml[1]) + (ms - 1) / 12
+        let date = printf('%04d-%02d-%02d', yr, m, d)
+        " TLogVAR d, ms, m, yr, date
+    elseif a:shift =~ 'y$'
+        let yr = str2nr(ml[1]) + n
+        let date = substitute(a:date, '^\d\{4}', yr, '')
+    else
+        throw 'tlib#date#Shift: Unsupported arguments: '. string(a:shift)
+    endif
+    " if !empty(ml[4]) && date !~ '\s'. ml[4] .'$'
+    "     let date .= ' '. ml[4]
+    " endif
+    " TLogVAR date
+    return date
+endf
+
+
+function! tlib#date#AddDays(date, n) abort "{{{3
+    let secs = tlib#date#SecondsSince1970(a:date) + g:tlib#date#dayshift * a:n
+    " TLogVAR secs
+    let date = tlib#date#Format(secs)
+    return date
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/dictionary.vim

@@ -0,0 +1,45 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2016-04-06
+" @Revision:    22
+
+
+" :display: tlib#dictionary#Rev(dict, ?opts = {}) abort "{{{3
+function! tlib#dictionary#Rev(dict, ...) abort "{{{3
+    let opts = a:0 >= 1 ? a:1 : {}
+    Tlibtype a:dict, 'dict', opts, 'dict'
+    let rev = {}
+    let use_string = get(opts, 'use_string', 0)
+    let use_eval = get(opts, 'use_eval', 0)
+    let values_as_list = get(opts, 'values_as_list', 0)
+    for [m, f] in items(a:dict)
+        if use_string
+            let k = string(f)
+        else
+            let k = type(f) == 1 ? f : string(f)
+            if k ==# ''
+                let k = get(opts, 'empty', '')
+                if empty(k)
+                    continue
+                endif
+            endif
+        endif
+        if use_eval
+            let v = eval(m)
+        else
+            let v = m
+        endif
+        if values_as_list
+            if has_key(rev, k)
+                call add(rev[k], v)
+            else
+                let rev[k] = [v]
+            endif
+        else
+            let rev[k] = v
+        endif
+    endfor
+    return rev
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/dir.vim

@@ -0,0 +1,93 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    43
+
+" TLet g:tlib#dir#sep = '/'
+TLet g:tlib#dir#sep = exists('+shellslash') && !&shellslash ? '\' : '/'
+
+
+let s:dir_stack = []
+
+" EXAMPLES: >
+"   tlib#dir#CanonicName('foo/bar')
+"   => 'foo/bar/'
+function! tlib#dir#CanonicName(dirname) "{{{3
+    let dirname = tlib#file#Canonic(a:dirname)
+    if dirname !~ '[/\\]$'
+        return dirname . g:tlib#dir#sep
+    endif
+    return dirname
+endf
+
+
+" EXAMPLES: >
+"   tlib#dir#NativeName('foo/bar/')
+"   On Windows:
+"   => 'foo\bar\'
+"   On Linux:
+"   => 'foo/bar/'
+function! tlib#dir#NativeName(dirname) "{{{3
+    let sep = tlib#rx#EscapeReplace(g:tlib#dir#sep)
+    let dirname = substitute(a:dirname, '[\/]', sep, 'g')
+    return dirname
+endf
+
+
+" EXAMPLES: >
+"   tlib#dir#PlainName('foo/bar/')
+"   => 'foo/bar'
+function! tlib#dir#PlainName(dirname) "{{{3
+    let dirname = a:dirname
+    while index(['/', '\'], dirname[-1 : -1]) != -1
+        let dirname = dirname[0 : -2]
+    endwh
+    return dirname
+    " return substitute(a:dirname, tlib#rx#Escape(g:tlib#dir#sep).'\+$', '', '')
+endf
+
+
+" Create a directory if it doesn't already exist.
+function! tlib#dir#Ensure(dir) "{{{3
+    if !isdirectory(a:dir)
+        let dir = tlib#dir#PlainName(a:dir)
+        return mkdir(dir, 'p')
+    endif
+    return 1
+endf
+
+
+" Return the first directory in &rtp.
+function! tlib#dir#MyRuntime() "{{{3
+    return get(split(&rtp, ','), 0)
+endf
+
+
+" :def: function! tlib#dir#CD(dir, ?locally=0) => CWD
+function! tlib#dir#CD(dir, ...) "{{{3
+    TVarArg ['locally', haslocaldir()]
+    let cmd = locally ? 'lcd! ' : 'cd! '
+    " let cwd = getcwd()
+    let cmd .= tlib#arg#Ex(a:dir)
+    " TLogVAR a:dir, locally, cmd
+    exec 'silent' cmd
+    " return cwd
+    return getcwd()
+endf
+
+
+" :def: function! tlib#dir#Push(dir, ?locally=0) => CWD
+function! tlib#dir#Push(dir, ...) "{{{3
+    TVarArg ['locally', haslocaldir()]
+    call add(s:dir_stack, [getcwd(), locally])
+    return tlib#dir#CD(a:dir, locally)
+endf
+
+
+" :def: function! tlib#dir#Pop() => CWD
+function! tlib#dir#Pop() "{{{3
+    let [dir, locally] = remove(s:dir_stack, -1)
+    return tlib#dir#CD(dir, locally)
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/eval.vim

@@ -0,0 +1,72 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    56
+
+
+function! tlib#eval#FormatValue(value, ...) "{{{3
+    TVarArg ['indent', 0]
+    " TLogVAR a:value, indent
+    let indent1 = indent + 1
+    let indenti = repeat(' ', &sw)
+    let type = type(a:value)
+    let acc = []
+    if type == 0 || type == 1 || type == 2
+        " TLogDBG 'Use string() for type='. type
+        call add(acc, string(a:value))
+    elseif type == 3 "List
+        " TLogDBG 'List'
+        call add(acc, '[')
+        for e in a:value
+            call add(acc, printf('%s%s,', indenti, tlib#eval#FormatValue(e, indent1)))
+            unlet e
+        endfor
+        call add(acc, ']')
+    elseif type == 4 "Dictionary
+        " TLogDBG 'Dictionary'
+        call add(acc, '{')
+        let indent1 = indent + 1
+        for [k, v] in items(a:value)
+            call add(acc, printf("%s%s: %s,", indenti, string(k), tlib#eval#FormatValue(v, indent1)))
+            unlet k v
+        endfor
+        call add(acc, '}')
+    else
+        " TLogDBG 'Unknown type: '. string(a:value)
+        call add(acc, string(a:value))
+    endif
+    if indent > 0
+        let is = repeat(' ', indent * &sw)
+        for i in range(1,len(acc) - 1)
+            let acc[i] = is . acc[i]
+        endfor
+    endif
+    return join(acc, "\n")
+endf
+
+
+function! tlib#eval#Extend(a, b, ...) abort "{{{3
+    let mode = a:0 >= 1 ? a:1 : 'force'
+    if type(a:a) != type(a:b)
+        throw 'tlib#eval#Extend: Incompatible types: a='. string(a:a) .' b='. string(a:b)
+    elseif type(a:a) == 3 " list
+        return extend(a:a, a:b, mode)
+    elseif type(a:a) == 4 " dict
+        for k in keys(a:b)
+            if has_key(a:a, k)
+                if mode == 'force'
+                    let a:a[k] = tlib#eval#Extend(copy(a:a[k]), a:b[k], mode)
+                elseif mode == 'error'
+                    throw 'tlib#eval#Extend: Key already exists: '. k
+                endif
+            else
+                let a:a[k] = a:b[k]
+            endif
+            unlet! k
+        endfor
+        return a:a
+    else
+        return a:b
+    endif
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/file.vim

@@ -0,0 +1,356 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    225
+
+
+if !exists('g:tlib#file#drop')
+    " If true, use |:drop| to edit loaded buffers (only available with GUI).
+    let g:tlib#file#drop = has('gui')   "{{{2
+endif
+
+
+if !exists('g:tlib#file#use_tabs')
+    let g:tlib#file#use_tabs = 0   "{{{2
+endif
+
+
+if !exists('g:tlib#file#edit_cmds')
+    let g:tlib#file#edit_cmds = g:tlib#file#use_tabs ? {'buffer': 'tab split | buffer', 'edit': 'tabedit'} : {}  "{{{2
+endif
+
+
+if !exists('g:tlib#file#absolute_filename_rx')
+    let g:tlib#file#absolute_filename_rx = '^\~\?[\/]'   "{{{2
+endif
+
+
+if !exists('g:tlib#file#reject_rx')
+    let g:tlib#file#reject_rx = '\%(^\|[\/]\)\%(tags\|Thumbs\.db\)$'   "{{{2
+endif
+
+
+""" File related {{{1
+" For the following functions please see ../../test/tlib.vim for examples.
+
+
+" EXAMPLES: >
+"   tlib#file#Split('foo/bar/filename.txt')
+"   => ['foo', 'bar', 'filename.txt']
+function! tlib#file#Split(filename) abort "{{{3
+    let prefix = matchstr(a:filename, '^\(\w\+:\)\?/\+')
+    Tlibtrace 'tlib', prefix
+    if !empty(prefix)
+        let filename = a:filename[len(prefix) : -1]
+    else
+        let filename = a:filename
+    endif
+    let rv = split(filename, '[\/]')
+    " let rv = split(filename, '[\/]', 1)
+    if !empty(prefix)
+        call insert(rv, prefix[0:-2])
+    endif
+    return rv
+endf
+
+
+" :display: tlib#file#Join(filename_parts, ?strip_slashes=1, ?maybe_absolute=0)
+" EXAMPLES: >
+"   tlib#file#Join(['foo', 'bar', 'filename.txt'])
+"   => 'foo/bar/filename.txt'
+function! tlib#file#Join(filename_parts, ...) abort "{{{3
+    TVarArg ['strip_slashes', 1], 'maybe_absolute'
+    Tlibtrace 'tlib', a:filename_parts, strip_slashes
+    if maybe_absolute
+        let filename_parts = []
+        for part in a:filename_parts
+            if part =~ g:tlib#file#absolute_filename_rx
+                let filename_parts = []
+            endif
+            call add(filename_parts, part)
+        endfor
+    else
+        let filename_parts = a:filename_parts
+    endif
+    if strip_slashes
+        " let rx    = tlib#rx#Escape(g:tlib#dir#sep) .'$'
+        let rx    = '[/\\]\+$'
+        let parts = map(copy(filename_parts), 'substitute(v:val, rx, "", "")')
+        Tlibtrace 'tlib', parts
+        return join(parts, g:tlib#dir#sep)
+    else
+        return join(filename_parts, g:tlib#dir#sep)
+    endif
+endf
+
+
+" EXAMPLES: >
+"   tlib#file#Relative('foo/bar/filename.txt', 'foo')
+"   => 'bar/filename.txt'
+function! tlib#file#Relative(filename, basedir) abort "{{{3
+    Tlibtrace 'tlib', a:filename, a:basedir
+    " TLogDBG getcwd()
+    " TLogDBG expand('%:p')
+    let b0 = tlib#file#Absolute(a:basedir)
+    let b  = tlib#file#Split(b0)
+    Tlibtrace 'tlib', b
+    let f0 = tlib#file#Absolute(a:filename)
+    let fn = fnamemodify(f0, ':t')
+    let fd = fnamemodify(f0, ':h')
+    let f  = tlib#file#Split(fd)
+    Tlibtrace 'tlib', f0, fn, fd, f
+    if f[0] != b[0]
+        let rv = f0
+    else
+        while !empty(f) && !empty(b)
+            if f[0] != b[0]
+                break
+            endif
+            call remove(f, 0)
+            call remove(b, 0)
+        endwh
+        Tlibtrace 'tlib', f, b
+        let rv = tlib#file#Join(repeat(['..'], len(b)) + f + [fn])
+    endif
+    Tlibtrace 'tlib', rv
+    return rv
+endf
+
+
+function! tlib#file#IsAbsolute(filename) abort "{{{3
+    return a:filename =~? '^\%(/\|\w\+:/\)'
+endf
+
+
+function! tlib#file#Absolute(filename, ...) abort "{{{3
+    if filereadable(a:filename)
+        let filename = fnamemodify(a:filename, ':p')
+    elseif a:filename =~# '^\(/\|[^\/]\+:\)'
+        let filename = a:filename
+    else
+        let cwd = a:0 >= 1 ? a:1 : getcwd()
+        let filename = tlib#file#Join([cwd, a:filename])
+    endif
+    let filename = substitute(filename, '\(^\|[\/]\)\zs\.[\/]', '', 'g')
+    let filename = substitute(filename, '[\/]\zs[^\/]\+[\/]\.\.[\/]', '', 'g')
+    return filename
+endf
+
+
+function! tlib#file#Canonic(filename, ...) abort "{{{3
+    TVarArg ['mode', '']
+    if empty(mode)
+        if a:filename =~# '^\\\\'
+            let mode = 'windows'
+        elseif a:filename =~# '^\(file\|ftp\|http\)s\?:'
+            let mode = 'url'
+        elseif (empty(mode) && g:tlib#sys#windows)
+            let mode = 'windows'
+        endif
+    endif
+    let filename = a:filename
+    if mode ==# 'windows'
+        let filename = substitute(filename, '/', '\\', 'g')
+    else
+        let filename = substitute(filename, '\\', '/', 'g')
+    endif
+    return filename
+endf
+
+
+function! s:SetScrollBind(world) abort "{{{3
+    let sb = get(a:world, 'scrollbind', &scrollbind)
+    if sb != &scrollbind
+        let &scrollbind = sb
+    endif
+endf
+
+
+" :def: function! tlib#file#With(fcmd, bcmd, files, ?world={}) abort
+function! tlib#file#With(fcmd, bcmd, files, ...) abort "{{{3
+    Tlibtrace 'tlib', a:fcmd, a:bcmd, a:files
+    let world = a:0 >= 1 ? a:1 : {}
+    let unset_switchbuf = a:0 >= 2 ? a:2 : 0
+    exec tlib#arg#Let([['world', {}]])
+    call tlib#autocmdgroup#Init()
+    augroup TLibFileRead
+        autocmd!
+    augroup END
+    if unset_switchbuf
+        let switchbuf = &switchbuf
+        set switchbuf&
+    endif
+    try
+        for f in a:files
+            try
+                let bn = bufnr('^'.f.'$')
+                Tlibtrace 'tlib', f, bn
+                let bufloaded = bufloaded(bn)
+                let ok = 0
+                let s:bufread = ""
+                if bn != -1 && buflisted(bn)
+                    if !empty(a:bcmd)
+                        let bcmd = a:bcmd .' '. bn
+                        Tlibtrace 'tlib', bcmd
+                        exec bcmd
+                        let ok = 1
+                        call s:SetScrollBind(world)
+                    endif
+                else
+                    if filereadable(f)
+                        if !empty(a:fcmd)
+                            " TLogDBG a:fcmd .' '. tlib#arg#Ex(f)
+                            exec 'autocmd TLibFileRead BufRead' escape(f, '\ ') 'let s:bufread=expand("<afile>:p")'
+                            try 
+                                let fcmd = a:fcmd .' '. tlib#arg#Ex(f)
+                                Tlibtrace 'tlib', fcmd
+                                exec fcmd
+                            finally
+                                exec 'autocmd! TLibFileRead BufRead'
+                            endtry
+                            let ok = 1
+                            call s:SetScrollBind(world)
+                        endif
+                    else
+                        echohl error
+                        echom 'File not readable: '. f
+                        echohl NONE
+                    endif
+                endif
+                Tlibtrace 'tlib', ok, bufloaded, &filetype
+                if empty(s:bufread) && ok && !bufloaded && empty(&filetype)
+                    doautocmd BufRead
+                endif
+            catch /^Vim\%((\a\+)\)\=:E325/
+                echohl ErrorMsg
+                echom v:exception
+                echohl NONE
+            endtry
+        endfor
+    finally
+        augroup! TLibFileRead
+        if unset_switchbuf
+            let &switchbuf = switchbuf
+        endif
+        unlet! s:bufread
+    endtry
+    " TLogDBG "done"
+endf
+
+
+" Return 0 if the file isn't readable/doesn't exist.
+" Otherwise return 1.
+function! tlib#file#Edit(fileid) abort "{{{3
+    if type(a:fileid) == 0
+        let bn = a:fileid
+        let filename = fnamemodify(bufname(bn), ':p')
+    else
+        let filename = fnamemodify(a:fileid, ':p')
+        let bn = bufnr(filename)
+    endif
+    if filename == expand('%:p')
+        return 1
+    else
+        Tlibtrace 'tlib', a:fileid, bn, filename, g:tlib#file#drop, filereadable(filename), bufnr('%')
+        if bn != -1 && buflisted(bn)
+            if g:tlib#file#drop
+                " echom "DBG" get(g:tlib#file#edit_cmds, 'drop', 'drop') fnameescape(filename)
+                exec get(g:tlib#file#edit_cmds, 'drop', 'drop') fnameescape(filename)
+                " echom "DBG" bufnr('%')
+            else
+                " echom "DBG" get(g:tlib#file#edit_cmds, 'buffer', 'buffer') bn
+                exec get(g:tlib#file#edit_cmds, 'buffer', 'buffer') bn
+                " echom "DBG" bufnr('%')
+            endif
+            return 1
+        endif
+        if !filereadable(filename) && exists('#TLibPrepareFile#User')
+            exec 'doautocmd TLibPrepareFile User' filename
+        endif
+        if filereadable(filename)
+            try
+                " let file = tlib#arg#Ex(filename)
+                " Tlibtrace 'tlib', file
+                " echom "DBG" get(g:tlib#file#edit_cmds, 'edit', 'edit') fnameescape(filename)
+                exec get(g:tlib#file#edit_cmds, 'edit', 'edit') fnameescape(filename)
+            catch /E325/
+                " swap file exists, let the user handle it
+            catch
+                echohl error
+                echom v:exception
+                echohl NONE
+            endtry
+            return 1
+        else
+            echom "TLIB: File not readable: " . filename
+            if filename != a:fileid
+                echom "TLIB: original filename: " . a:fileid
+            endif
+        endif
+    endif
+    return 0
+endf
+
+
+function! tlib#file#FilterFiles(files, options) abort "{{{3
+    Tlibtrace 'tlib', a:files, a:options, g:tlib#file#reject_rx
+    if !get(a:options, 'all', 0)
+        call filter(a:files, 'v:val !~# g:tlib#file#reject_rx')
+    endif
+    Tlibtrace 'tlib', a:files
+    let type = get(a:options, 'type', 'fd')
+    Tlibtrace 'tlib', type
+    if type !~# 'd' || type !~# 'f'
+        call filter(a:files, 'isdirectory(v:val) ? type =~# "d" : type =~# "f"')
+    endif
+    Tlibtrace 'tlib', a:files
+    return a:files
+endf
+
+
+if v:version > 704 || (v:version == 704 && has('patch279'))
+
+    function! tlib#file#Glob(pattern, ...) abort "{{{3
+        let all = a:0 >= 1 ? a:1 : 0
+        let nosuf = a:0 >= 2 ? a:2 : 0
+        return tlib#file#FilterFiles(glob(a:pattern, nosuf, 1), {'all': all})
+    endf
+
+    function! tlib#file#Globpath(path, pattern, ...) abort "{{{3
+        let all = a:0 >= 1 ? a:1 : 0
+        let nosuf = a:0 >= 2 ? a:2 : 0
+        return tlib#file#FilterFiles(globpath(a:path, a:pattern, nosuf, 1), {'all': all})
+    endf
+
+else
+
+    " :nodoc:
+    function! tlib#file#Glob(pattern, ...) abort "{{{3
+        let all = a:0 >= 1 ? a:1 : 0
+        let nosuf = a:0 >= 2 ? a:2 : 0
+        return tlib#file#FilterFiles(split(glob(a:pattern, nosuf), '\n'), {'all': all})
+    endf
+
+    " :nodoc:
+    function! tlib#file#Globpath(path, pattern, ...) abort "{{{3
+        let all = a:0 >= 1 ? a:1 : 0
+        let nosuf = a:0 >= 2 ? a:2 : 0
+        return tlib#file#FilterFiles(split(globpath(a:path, a:pattern), '\n'), {'all': all})
+    endf
+
+endif
+
+
+let s:filereadable = {}
+
+augroup TLib
+	autocmd BufWritePost,FileWritePost,FocusLost * let s:filereadable = {}
+augroup end
+
+function! tlib#file#Filereadable(filename) abort "{{{3
+    if !has_key(s:filereadable, a:filename)
+        let s:filereadable[a:filename] = filereadable(a:filename)
+    endif
+    return s:filereadable[a:filename]
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/fixes.vim

@@ -0,0 +1,14 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2013-02-22.
+" @Revision:    3
+
+
+function! tlib#fixes#Winpos() "{{{3
+    if has('gui_win32')
+        return 'winpos '. getwinposx() .' '. getwinposy()
+    else
+        return ''
+    endif
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/grep.vim

@@ -0,0 +1,38 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2013-10-16.
+" @Revision:    31
+
+
+function! tlib#grep#Do(cmd, rx, files) "{{{3
+    " TLogVAR a:cmd, a:rx, a:files
+    let files = join(map(copy(a:files), 'tlib#arg#Ex(v:val, "")'), ' ')
+    let rx = '/'. escape(a:rx, '/') .'/j'
+    " TLogVAR rx, files
+    silent exec a:cmd rx files
+endf
+
+
+function! tlib#grep#LocList(rx, files) "{{{3
+    return tlib#grep#Do('noautocmd lvimgrep', a:rx, a:files)
+endf
+
+
+function! tlib#grep#QuickFixList(rx, files) "{{{3
+    return tlib#grep#Do('noautocmd vimgrep', a:rx, a:files)
+endf
+
+
+function! tlib#grep#List(rx, files) "{{{3
+    call setqflist([])
+    call tlib#grep#Do('noautocmd vimgrepadd', a:rx, a:files)
+    let qfl = getqflist()
+    " TLogVAR qfl
+    " try
+        silent! colder
+    " catch
+    "     call setqflist([], 'r')
+    " endtry
+    return qfl
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/hash.vim

@@ -0,0 +1,145 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    276
+
+
+if !exists('g:tlib#hash#use_crc32')
+    let g:tlib#hash#use_crc32 = ''   "{{{2
+endif
+
+
+if !exists('g:tlib#hash#use_adler32')
+    let g:tlib#hash#use_adler32 = ''   "{{{2
+endif
+
+
+function! tlib#hash#CRC32B(chars) "{{{3
+    if !empty(g:tlib#hash#use_crc32)
+        let use = g:tlib#hash#use_crc32
+    elseif has('ruby')
+        let use = 'ruby'
+    else
+        let use = 'vim'
+    endif
+    if exists('*tlib#hash#CRC32B_'. use)
+        return tlib#hash#CRC32B_{use}(a:chars)
+    else
+        throw "Unknown version of tlib#hash#CRC32B: ". use
+    endif
+endf
+
+
+function! tlib#hash#CRC32B_ruby(chars) "{{{3
+    if has('ruby')
+        let rv = ''
+        if !exists('s:loaded_ruby_zlib')
+            ruby require 'zlib'
+            let s:loaded_ruby_zlib = 1
+        endif
+        ruby VIM::command('let rv = "%08X"' % Zlib.crc32(VIM::evaluate("a:chars")))
+        return rv
+    else
+        throw "tlib#hash#CRC32B_ruby not supported in this version of vim"
+    endif
+endf
+
+
+function! tlib#hash#CRC32B_vim(chars) "{{{3
+    if !exists('s:crc_table')
+        let cfile = tlib#persistent#Filename('tlib', 'crc_table', 1)
+        let s:crc_table = tlib#persistent#Value(cfile, 'tlib#hash#CreateCrcTable', 0)
+    endif
+    let xFFFF_FFFF = repeat([1], 32)
+    let crc = tlib#bitwise#XOR([0], xFFFF_FFFF, 'bits')
+    for char in split(a:chars, '\zs')
+        let octet = char2nr(char)
+        let r1 = tlib#bitwise#ShiftRight(crc, 8)
+        let i0 = tlib#bitwise#AND(crc, xFFFF_FFFF, 'bits')
+        let i1 = tlib#bitwise#XOR(i0, octet, 'bits')
+        let i2 = tlib#bitwise#Bits2Num(tlib#bitwise#AND(i1, 0xff, 'bits'))
+        let r2 = s:crc_table[i2]
+        let crc = tlib#bitwise#XOR(r1, r2, 'bits')
+    endfor
+    let crc = tlib#bitwise#XOR(crc, xFFFF_FFFF, 'bits')
+    let rv = tlib#bitwise#Bits2Num(crc, 16)
+    if len(rv) < 8
+        let rv = repeat('0', 8 - len(rv)) . rv
+    endif
+    return rv
+endf
+
+
+" :nodoc:
+function! tlib#hash#CreateCrcTable() "{{{3
+    let sum = 0.0
+    for exponent in [0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26, 32]
+        let exp = tlib#bitwise#Bits2Num(repeat([0], 32 - exponent) + [1], 10.0)
+        let sum += exp
+    endfor
+    let divisor = tlib#bitwise#Num2Bits(sum)
+    let crc_table = []
+    for octet in range(256)
+        let remainder = tlib#bitwise#Num2Bits(octet)
+        for i in range(8)
+            if get(remainder, i) != 0
+                let remainder = tlib#bitwise#XOR(remainder, tlib#bitwise#ShiftLeft(divisor, i), "bits")
+            endif
+        endfor
+        let remainder = tlib#bitwise#ShiftRight(remainder, 8)
+        call add(crc_table, remainder)
+    endfor
+    return crc_table
+endf
+
+
+function! tlib#hash#Adler32(chars) "{{{3
+    if !empty(g:tlib#hash#use_adler32)
+        let use = g:tlib#hash#use_adler32
+    elseif exists('*or')
+        let use = 'vim'
+    else
+        let use = 'tlib'
+    endif
+    if exists('*tlib#hash#Adler32_'. use)
+        return tlib#hash#Adler32_{use}(a:chars)
+    else
+        throw "Unknown version of tlib#hash#Adler32_: ". use
+    endif
+endf
+
+
+function! tlib#hash#Adler32_vim(chars) "{{{3
+    if exists('*or')
+        let mod_adler = 65521
+        let a = 1
+        let b = 0
+        for index in range(len(a:chars))
+            let c = char2nr(a:chars[index])
+            let a = (a + c) % mod_adler
+            let b = (b + a) % mod_adler
+        endfor
+        let bb = b * float2nr(pow(2, 16))
+        let checksum = or(bb, a)
+        " TLogVAR checksum, a, b, bb
+        return printf("%08X", checksum)
+    else
+        throw "TLIB: Vim version doesn't support bitwise or()"
+    endif
+endf
+
+
+function! tlib#hash#Adler32_tlib(chars) "{{{3
+    let mod_adler = 65521
+    let a = 1
+    let b = 0
+    for index in range(len(a:chars))
+        let c = char2nr(a:chars[index])
+        let a = (a + c) % mod_adler
+        let b = (b + a) % mod_adler
+    endfor
+    let bb = tlib#bitwise#ShiftLeft(tlib#bitwise#Num2Bits(b), 16)
+    let checksum = tlib#bitwise#OR(bb, a, "bits")
+    return printf('%08s', tlib#bitwise#Bits2Num(checksum, 16))
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/hook.vim

@@ -0,0 +1,25 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    11
+
+
+" :def: function! tlib#hook#Run(hook, ?dict={})
+" Execute dict[hook], w:{hook}, b:{hook}, or g:{hook} if existent.
+function! tlib#hook#Run(hook, ...) "{{{3
+    TVarArg ['dict', {}]
+    if has_key(dict, a:hook)
+        let hook = dict[a:hook]
+    else
+        let hook = tlib#var#Get(a:hook, 'wbg')
+    endif
+    if empty(hook)
+        return 0
+    else
+        let world = dict
+        exec hook
+        return 1
+    endif
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/list.vim

@@ -0,0 +1,194 @@
+" list.vim
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-06-30.
+" @Last Change: 2017-03-26.
+" @Revision:    71
+
+
+""" List related functions {{{1
+" For the following functions please see ../../test/tlib.vim for examples.
+
+" :def: function! tlib#list#Inject(list, initial_value, funcref) abort
+" EXAMPLES: >
+"   echo tlib#list#Inject([1,2,3], 0, function('Add')
+"   => 6
+function! tlib#list#Inject(list, value, Function) abort "{{{3
+    if empty(a:list)
+        return a:value
+    else
+        let item  = a:list[0]
+        let rest  = a:list[1:-1]
+        let value = call(a:Function, [a:value, item])
+        return tlib#list#Inject(rest, value, a:Function)
+    endif
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#Compact([0,1,2,3,[], {}, ""])
+"   => [1,2,3]
+function! tlib#list#Compact(list) abort "{{{3
+    return filter(copy(a:list), '!empty(v:val)')
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#Flatten([0,[1,2,[3,""]]])
+"   => [0,1,2,3,""]
+function! tlib#list#Flatten(list) abort "{{{3
+    let acc = []
+    for e in a:list
+        if type(e) == 3
+            let acc += tlib#list#Flatten(e)
+        else
+            call add(acc, e)
+        endif
+        unlet e
+    endfor
+    return acc
+endf
+
+
+" :def: function! tlib#list#FindAll(list, filter, ?process_expr="") abort
+" Basically the same as filter()
+"
+" EXAMPLES: >
+"   tlib#list#FindAll([1,2,3], 'v:val >= 2')
+"   => [2, 3]
+function! tlib#list#FindAll(list, filter, ...) abort "{{{3
+    let rv   = filter(copy(a:list), a:filter)
+    if a:0 >= 1 && !empty(a:1)
+        let rv = map(rv, a:1)
+    endif
+    return rv
+endf
+
+
+" :def: function! tlib#list#Find(list, filter, ?default="", ?process_expr="") abort
+"
+" EXAMPLES: >
+"   tlib#list#Find([1,2,3], 'v:val >= 2')
+"   => 2
+function! tlib#list#Find(list, filter, ...) abort "{{{3
+    let default = a:0 >= 1 ? a:1 : ''
+    let expr    = a:0 >= 2 ? a:2 : ''
+    return get(tlib#list#FindAll(a:list, a:filter, expr), 0, default)
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#Any([1,2,3], 'v:val >= 2')
+"   => 1
+function! tlib#list#Any(list, expr) abort "{{{3
+    return !empty(tlib#list#FindAll(a:list, a:expr))
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#All([1,2,3], 'v:val >= 2')
+"   => 0
+function! tlib#list#All(list, expr) abort "{{{3
+    return len(tlib#list#FindAll(a:list, a:expr)) == len(a:list)
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#Remove([1,2,1,2], 2)
+"   => [1,1,2]
+function! tlib#list#Remove(list, element) abort "{{{3
+    let idx = index(a:list, a:element)
+    if idx != -1
+        call remove(a:list, idx)
+    endif
+    return a:list
+endf
+
+
+" EXAMPLES: >
+"   tlib#list#RemoveAll([1,2,1,2], 2)
+"   => [1,1]
+function! tlib#list#RemoveAll(list, element) abort "{{{3
+    call filter(a:list, 'v:val != a:element')
+    return a:list
+endf
+
+
+" :def: function! tlib#list#Zip(lists, ?default='') abort
+" EXAMPLES: >
+"   tlib#list#Zip([[1,2,3], [4,5,6]])
+"   => [[1,4], [2,5], [3,6]]
+function! tlib#list#Zip(lists, ...) abort "{{{3
+    TVarArg 'default'
+    let lists = copy(a:lists)
+    let max   = 0
+    for l in lists
+        let ll = len(l)
+        if ll > max
+            let max = ll
+        endif
+    endfor
+    " TLogVAR default, max
+    return map(range(0, max - 1), 's:GetNthElement(v:val, lists, default)')
+endf
+
+function! s:GetNthElement(n, lists, default) abort "{{{3
+    " TLogVAR a:n, a:lists, a:default
+    return map(copy(a:lists), 'get(v:val, a:n, a:default)')
+endf
+
+
+function! tlib#list#Uniq(list, ...) abort "{{{3
+    " TLogVAR a:list
+    TVarArg ['get_value', ''], ['remove_empty', 0]
+    if remove_empty
+        call filter(a:list, 'type(v:val) == 0 || !empty(v:val)')
+    endif
+    " CREDITS: Based on syntastic#util#unique(list) by scrooloose
+    let emptystring = 0
+    let seen = {}
+    let uniques = []
+    if empty(get_value)
+        for e in a:list
+            if empty(e)
+                if !emptystring
+                    let emptystring = 1
+                    call add(uniques, e)
+                endif
+            elseif !has_key(seen, e)
+                let seen[e] = 1
+                call add(uniques, e)
+            endif
+            unlet e
+        endfor
+    else
+        for e in a:list
+            let v = eval(printf(get_value, string(e)))
+            if empty(v)
+                if !emptystring
+                    let emptystring = 1
+                    call add(uniques, v)
+                endif
+            elseif !has_key(seen, v)
+                let seen[v] = 1
+                call add(uniques, v)
+            endif
+            unlet e v
+        endfor
+    endif
+    return uniques
+endf
+
+
+function! tlib#list#ToDictionary(list, default, ...) abort "{{{3
+    TVarArg ['generator', '']
+    let dict = {}
+    for item in a:list
+        if !empty(item)
+            let dict[item] = empty(generator) ? a:default : call(generator, [item, a:default])
+        endif
+    endfor
+    return dict
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/loclist.vim

@@ -0,0 +1,13 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2015-10-24
+" @Revision:    2
+
+
+function! tlib#loclist#Browse(...) abort "{{{3
+    let list = getloclist(0)
+    return call(function('tlib#qfl#QflList'), [list] + a:000)
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/map.vim

@@ -0,0 +1,23 @@
+" map.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2009-08-23.
+" @Last Change: 2009-08-23.
+" @Revision:    0.0.4
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" If |pumvisible()| is true, return "\<c-y>". Otherwise return a:key.
+" For use in maps like: >
+"   imap <expr> <cr> tlib#map#PumAccept("\<cr>")
+function! tlib#map#PumAccept(key) "{{{3
+    return pumvisible() ? "\<c-y>" : a:key
+endf
+
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

sources_non_forked_fallback/tlib/autoload/tlib/normal.vim

@@ -0,0 +1,34 @@
+" normal.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-10-06.
+" @Last Change: 2010-09-22.
+" @Revision:    28
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" :display: tlib#normal#WithRegister(cmd, ?register='t', ?norm_cmd='norm!')
+" Execute a normal command while maintaining all registers.
+function! tlib#normal#WithRegister(cmd, ...) "{{{3
+    TVarArg ['register', 't'], ['norm_cmd', 'norm!']
+    let registers = {}
+    for reg in split('123456789'. register, '\zs')
+        exec 'let registers[reg] = @'. reg
+    endfor
+    exec 'let reg = @'. register
+    try
+        exec norm_cmd .' '. a:cmd
+        exec 'return @'. register
+    finally
+        for [reg, value] in items(registers)
+            exec 'let @'. reg .' = value'
+        endfor
+    endtry
+endf
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

sources_non_forked_fallback/tlib/autoload/tlib/notify.vim

@@ -0,0 +1,113 @@
+" notify.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2008-09-19.
+" @Last Change: 2017-09-28.
+" @Revision:    3.3.19
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" :display: tlib#notify#Echo(text, ?style='')
+" Print text in the echo area. Temporarily disable 'ruler' and 'showcmd' 
+" in order to prevent |press-enter| messages.
+function! tlib#notify#Echo(text, ...)
+    TVarArg 'style'
+    let ruler = &ruler
+    let showcmd = &showcmd
+    let text = substitute(a:text, '\n', '|', 'g')
+    try
+        set noruler
+        set noshowcmd
+        if !empty(style)
+            exec 'echohl' style
+        endif
+        echo tlib#string#Strcharpart(text, 0, &columns - 1)
+    finally
+        if !empty(style)
+            echohl None
+        endif
+        let &ruler = ruler
+        let &showcmd = showcmd
+    endtry
+endf
+
+
+" Contributed by Erik Falor:
+" If the line containing the message is too long, echoing it will cause 
+" a 'Hit ENTER' prompt to appear.  This function cleans up the line so 
+" that does not happen.
+" The echoed line is too long if it is wider than the width of the 
+" window, minus cmdline space taken up by the ruler and showcmd 
+" features.
+function! tlib#notify#TrimMessage(message) "{{{3
+    let filler = '...'
+
+    " If length of message with tabs converted into spaces + length of 
+    " line number + 2 (for the ': ' that follows the line number) is 
+    " greater than the width of the screen, truncate in the middle
+    let to_fill = &columns
+    " TLogVAR to_fill
+
+    " Account for space used by elements in the command-line to avoid 
+    " 'Hit ENTER' prompts.
+    " If showcmd is on, it will take up 12 columns.
+    " If the ruler is enabled, but not displayed in the statusline, it 
+    " will in its default form take 17 columns.  If the user defines a 
+    " custom &rulerformat, they will need to specify how wide it is.
+    if has('cmdline_info')
+        if &showcmd
+            let to_fill -= 12
+        else
+            let to_fill -= 1
+        endif
+        " TLogVAR &showcmd, to_fill
+
+        " TLogVAR &laststatus, &ruler, &rulerformat
+        if &ruler
+            if &laststatus == 0 || winnr('$') == 1
+                if has('statusline')
+                    if &rulerformat == ''
+                        " default ruler is 17 chars wide
+                        let to_fill -= 17
+                    elseif exists('g:MP_rulerwidth')
+                        let to_fill -= g:MP_rulerwidth
+                    else
+                        " tml: fallback: guess length
+                        let to_fill -= strlen(&rulerformat)
+                    endif
+                else
+                endif
+            endif
+        else
+        endif
+    else
+        let to_fill -= 1
+    endif
+
+    " TLogVAR to_fill
+    " TLogDBG strlen(a:message)
+    if strlen(a:message) > to_fill
+        let front = to_fill / 2 - 1
+        let back  = front 
+        if to_fill % 2 == 0 | let back -= 1 | endif
+        return tlib#string#Strcharpart(a:message, 0, front) . filler .
+                    \ tlib#string#Strcharpart(a:message, strlen(a:message) - back)
+    else
+        return a:message
+    endif
+endfunction
+
+
+function! tlib#notify#PrintError() abort "{{{3
+    echohl ErrorMsg
+    echom v:exception
+    echom v:throwpoint
+    echohl NONE
+endf
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

sources_non_forked_fallback/tlib/autoload/tlib/number.vim

@@ -0,0 +1,36 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    26
+
+
+function! tlib#number#ConvertBase(num, base, ...) "{{{3
+    let rtype = a:0 >= 1 ? a:1 : 'string'
+    " TLogVAR a:num, a:base, rtype
+    if a:base == 32
+        let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+    elseif a:base == 63 || a:base == 64
+        let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+    elseif a:base == 85
+        let chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"
+    elseif a:base <= 62
+        let chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    else
+        throw 'tlib#number#ConvertBase: base is not supported'
+    endif
+    let rv = []
+    let num = 0.0 + a:num
+    while floor(num) > 0.0
+        let div = floor(num / a:base)
+        let num1 = float2nr(num - a:base * div)
+        call insert(rv, chars[num1])
+        let num = num / a:base
+    endwh
+    " TLogVAR rv
+    if rtype == 'list'
+        return rv
+    else
+        return join(rv, '')
+    endif
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/paragraph.vim

@@ -0,0 +1,97 @@
+" paragraph.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2009-10-26.
+" @Last Change: 2011-04-03.
+" @Revision:    62
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" Return an object describing a |paragraph|.
+function! tlib#paragraph#GetMetric() "{{{3
+    let sp = {'text_start': line("'{") + 1}
+    if line("'}") == line("$")
+        let sp.last = 1
+        let sp.text_end = line("'}")
+        if line("'{") == 1
+            let sp.ws_start = 0
+            let sp.ws_end = 0
+            let sp.top = sp.text_start
+            let sp.bottom = sp.text_end
+        else
+            let sp.ws_start = prevnonblank(line("'{")) + 1
+            let sp.ws_end = line("'{")
+            let sp.top = sp.ws_start
+            let sp.bottom = sp.text_end
+        endif
+    else
+        let sp.last = 0
+        let sp.text_end = line("'}") - 1
+        let sp.ws_start = line("'}")
+        for i in range(line("'}"), line('$'))
+            if getline(i) =~ '\w'
+                let sp.ws_end = i - 1
+                break
+            elseif i == line("$")
+                let sp.ws_end = i
+            endif
+        endfor
+        let sp.top = sp.text_start
+        let sp.bottom = sp.ws_end
+    endif
+    return sp
+endf
+
+
+" This function can be used with the tinymode plugin to move around 
+" paragraphs.
+"
+" Example configuration: >
+" 
+"   call tinymode#EnterMap("para_move", "gp")
+"   call tinymode#ModeMsg("para_move", "Move paragraph: j/k")
+"   call tinymode#Map("para_move", "j", "silent call tlib#paragraph#Move('Down', '[N]')")
+"   call tinymode#Map("para_move", "k", "silent call tlib#paragraph#Move('Up', '[N]')")
+"   call tinymode#ModeArg("para_move", "owncount", 1)
+function! tlib#paragraph#Move(direction, count)
+    " TLogVAR a:direction, a:count
+    let mycount = empty(a:count) ? 1 : a:count
+    for i in range(1, mycount)
+        let para = tlib#paragraph#GetMetric()
+        " TLogVAR para
+        let text = getline(para.text_start, para.text_end)
+        let ws = getline(para.ws_start, para.ws_end)
+        " TLogVAR text, ws
+        exec para.top .','. para.bottom .'delete'
+        if a:direction == "Down"
+            let other = tlib#paragraph#GetMetric()
+            let target = other.bottom + 1
+            if other.last
+                let lines = ws + text
+                let pos = target + len(ws)
+            else
+                let lines = text + ws
+                let pos = target
+            endif
+        elseif a:direction == "Up"
+            if !para.last
+                norm! {
+            endif
+            let other = tlib#paragraph#GetMetric()
+            let target = other.text_start
+            let lines = text + ws
+            let pos = target
+        endif
+        " TLogVAR other, target
+        " TLogVAR lines
+        call append(target - 1, lines)
+        exec pos
+    endfor
+endf
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

sources_non_forked_fallback/tlib/autoload/tlib/persistent.vim

@@ -0,0 +1,54 @@
+" persistent.vim -- Persistent data
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2012-05-11.
+" @Last Change: 2017-03-29.
+" @Revision:    15
+
+" The directory for persistent data files. If empty, use 
+" |tlib#dir#MyRuntime|.'/share'.
+TLet g:tlib_persistent = ''
+
+
+" :display: tlib#persistent#Dir(?mode = 'bg')
+" Return the full directory name for persistent data files.
+function! tlib#persistent#Dir() "{{{3
+    TVarArg ['mode', 'bg']
+    let dir = tlib#var#Get('tlib_persistent', mode)
+    if empty(dir)
+        let dir = tlib#file#Join([tlib#dir#MyRuntime(), 'share'])
+    endif
+    return dir
+endf
+
+" :display: tlib#persistent#EncodedFilename(type, file, ?mkdir=0, ?dir='')
+" Encode `file` and call |tlib#persistent#Filename()|.
+function! tlib#persistent#EncodedFilename(type, file, ...) "{{{3
+    let file = tlib#url#Encode(a:file)
+    return call(function('tlib#persistent#Filename'), [a:type, file] + a:000)
+endf
+
+" :def: function! tlib#persistent#Filename(type, ?file=%, ?mkdir=0)
+function! tlib#persistent#Filename(type, ...) "{{{3
+    " TLogDBG 'bufname='. bufname('.')
+    let file = a:0 >= 1 ? a:1 : ''
+    let mkdir = a:0 >= 2 ? a:2 : 0
+    return tlib#cache#Filename(a:type, file, mkdir, tlib#persistent#Dir())
+endf
+
+function! tlib#persistent#Get(...) "{{{3
+    return call('tlib#cache#Get', a:000)
+endf
+
+function! tlib#persistent#MTime(cfile) "{{{3
+    return tlib#cache#MTime(a:cfile)
+endf
+
+function! tlib#persistent#Value(...) "{{{3
+    return call('tlib#cache#Value', a:000)
+endf
+
+function! tlib#persistent#Save(...) "{{{3
+    call call(function('tlib#cache#Save'), a:000)
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/progressbar.vim

@@ -0,0 +1,95 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    86
+
+let s:id = 0
+let s:ids = []
+let s:statusline = []
+let s:laststatus = []
+let s:max = []
+let s:format = []
+let s:width = []
+let s:value = []
+let s:timestamp = -1
+
+" EXAMPLE: >
+"     call tlib#progressbar#Init(20)
+"     try
+"         for i in range(20)
+"             call tlib#progressbar#Display(i)
+"             call DoSomethingThatTakesSomeTime(i)
+"         endfor
+"     finally
+"         call tlib#progressbar#Restore()
+"     endtry
+function! tlib#progressbar#Init(max, ...) "{{{3
+    TVarArg ['format', '%s'], ['width', 10]
+    let s:id += 1
+    call insert(s:ids, s:id)
+    call insert(s:statusline, &statusline)
+    call insert(s:laststatus, &laststatus)
+    call insert(s:max, a:max)
+    call insert(s:format, format)
+    call insert(s:width, width)
+    call insert(s:value, -1)
+    let sl = {
+                \ 'id': s:id,
+                \ 'statusline': &statusline,
+                \ 'laststatus': &laststatus,
+                \ 'max': a:max,
+                \ 'format': format,
+                \ 'width': width,
+                \ 'value': -1
+                \ }
+    let &laststatus = 2
+    let s:timestamp = localtime()
+    return sl
+endf
+
+
+function! tlib#progressbar#Restore(...) "{{{3
+    if a:0 >= 1
+        let sl = a:1
+        let idx = index(s:ids, sl.id)
+        let &statusline = sl.statusline
+        let &laststatus = sl.laststatus
+    else
+        let idx = 0
+        let &statusline = remove(s:statusline, idx)
+        let &laststatus = remove(s:laststatus, idx)
+    endif
+    call remove(s:ids, idx)
+    call remove(s:max, idx)
+    call remove(s:format, idx)
+    call remove(s:width, idx)
+    call remove(s:value, idx)
+    redrawstatus
+    " redraw
+    " echo
+endf
+
+
+function! tlib#progressbar#Display(value, ...) "{{{3
+    TVarArg 'extra', ['always', 0]
+    let ts = localtime()
+    if !always && ts == s:timestamp
+        return
+    else
+        let s:timestamp = ts
+    endif
+    let val = a:value * s:width[0] / s:max[0]
+    if always || val != s:value[0]
+        let s:value[0] = val
+        let pbl = repeat('#', val)
+        let pbr = repeat('.', s:width[0] - val)
+        let txt = printf(s:format[0], '['.pbl.pbr.']') . extra
+        let &statusline = txt
+        " TLogDBG txt
+        redrawstatus
+        " redraw
+        " call tlib#notify#Echo(txt)
+    endif
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/qfl.vim

@@ -0,0 +1,317 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2018-02-08
+" @Revision:    69
+
+" :nodoc:
+TLet g:tlib#qfl#world = {
+            \ 'type': 'mi',
+            \ 'query': 'Select entry',
+            \ 'pick_last_item': 0,
+            \ 'resize_vertical': 0,
+            \ 'resize': 20,
+            \ 'scratch': '__TLibQFL__',
+            \ 'tlib_UseInputListScratch': 'call tlib#qfl#InitListBuffer(world)',
+            \ 'key_handlers': [
+                \ {'key':  5, 'agent': 'tlib#qfl#AgentWithSelected', 'key_name': '<c-e>', 'help': 'Run a command on selected lines'},
+                \ {'key': 16, 'agent': 'tlib#qfl#AgentPreviewQFE',   'key_name': '<c-p>', 'help': 'Preview'},
+                \ {'key': 60, 'agent': 'tlib#qfl#AgentGotoQFE',      'key_name': '<',     'help': 'Jump (don''t close the list)'},
+                \ {'key': 19, 'agent': 'tlib#qfl#AgentSplitBuffer',  'key_name': '<c-s>', 'help': 'Show in split buffer'},
+                \ {'key': 20, 'agent': 'tlib#qfl#AgentTabBuffer',    'key_name': '<c-t>', 'help': 'Show in tab'},
+                \ {'key': 22, 'agent': 'tlib#qfl#AgentVSplitBuffer', 'key_name': '<c-v>', 'help': 'Show in vsplit buffer'},
+                \ {'key': 12, 'agent': 'tlib#qfl#AgentEditLine',     'key_name': '<c-l>', 'help': 'Edit selected line(s)'},
+                \ {'key': "\<c-insert>", 'agent': 'tlib#qfl#SetFollowCursor', 'key_name': '<c-ins>', 'help': 'Toggle trace cursor'},
+            \ ],
+            \ 'return_agent': 'tlib#qfl#AgentEditQFE',
+            \ }
+
+
+function! tlib#qfl#FormatQFLE(qfe) dict abort "{{{3
+    let filename = tlib#qfl#QfeFilename(a:qfe)
+    let short_filename = get(self, 'qfl_short_filename', '')
+    if short_filename ==# 'basename'
+        let filename = matchstr(filename, '[^\\/]\+$')
+    elseif !empty(short_filename)
+        let filename = pathshorten(filename)
+    endif
+    return printf("%s|%d| %s", filename, a:qfe.lnum, get(a:qfe, "text"))
+endf
+
+
+function! tlib#qfl#QfeFilename(qfe) abort "{{{3
+    let filename = get(a:qfe, 'filename')
+    if empty(filename)
+        let filename = bufname(get(a:qfe, 'bufnr'))
+    endif
+    return filename
+endf
+
+
+function! tlib#qfl#InitListBuffer(world) "{{{3
+    let set_syntax = get(a:world, 'set_syntax', 'tlib#qfl#SetSyntax')
+    call call(set_syntax, [], a:world)
+    if has('balloon_eval')
+        setlocal ballooneval balloonexpr=tlib#qfl#Balloon()
+    endif
+endf
+
+
+function! tlib#qfl#SetSyntax() dict abort "{{{3
+    let syntax = get(self, 'qfl_list_syntax', '')
+    let nextgroup = get(self, 'qfl_list_syntax_nextgroup', '')
+    " TLogVAR syntax, nextgroup
+    if !empty(syntax)
+        exec printf('runtime syntax/%s.vim', syntax)
+    endif
+    syn match TTagedFilesFilename /\%(\f\+\| \)\+\ze|\d\+| / nextgroup=TTagedFilesLNum
+    if !empty(nextgroup)
+        exec 'syn match TTagedFilesLNum /|\d\+|\s\+/ nextgroup='. nextgroup
+    else
+        syn match TTagedFilesLNum /|\d\+|/
+    endif
+    hi def link TTagedFilesFilename Directory
+    hi def link TTagedFilesLNum LineNr
+endf
+
+
+function! tlib#qfl#Balloon() "{{{3
+    let world = getbufvar(v:beval_bufnr, 'tlibDisplayListWorld')
+    let current = max([1, world.offset]) + v:beval_lnum - 1
+    if current > len(world.table)
+        let current = len(world.table)
+    endif
+    let baseidx = world.GetBaseIdx0(current)
+    " TLogVAR world.offset, v:beval_lnum, current, baseidx
+    let item = world.data[baseidx]
+    let bufnr = get(item, 'bufnr', 0)
+    let bufname = get(item, 'filename', '')
+    if bufnr == 0 && !empty(bufname)
+        let bufnr = bufnr(bufname)
+    endif
+    if empty(bufname) && bufnr > 0
+        let bufname = bufname(bufnr)
+    endif
+    " TLogVAR item
+    if bufnr == 0
+        return ''
+    else
+        let lines = [printf("%d#%d: %s", bufnr, item.lnum, bufname)]
+        if has('balloon_multiline')
+            let desc = {'nr': 'Error number', 'type': 'Error type', 'text': ''}
+            for key in ['nr', 'type', 'text']
+                if has_key(item, key) && !empty(item[key])
+                    let keydesc = get(desc, key, key)
+                    if empty(keydesc)
+                        let text = item[key]
+                    else
+                        let text = printf("%s: %s", key, item[key])
+                    endif
+                    call add(lines, text)
+                endif
+            endfor
+        endif
+        return join(lines, "\n")
+    endif
+    " v:beval_bufnr	number of the buffer in which balloon is going to show
+    " v:beval_winnr	number of the window
+    " v:beval_lnum	line number
+    " v:beval_col	column number (byte index)
+    " v:beval_text	word under or after the mouse pointer
+endf
+
+
+function! tlib#qfl#AgentEditQFE(world, selected, ...) "{{{3
+    TVarArg ['cmd_edit', ''], ['cmd_buffer', ''], ['set_origin', 1]
+    " TVarArg ['cmd_edit', 'edit'], ['cmd_buffer', 'buffer']
+    " TLogVAR a:selected
+    if empty(a:selected)
+        " call a:world.RestoreOrigin()
+        " call a:world.ResetSelected()
+    else
+        call a:world.RestoreOrigin()
+        for idx in a:selected
+            let idx -= 1
+            " TLogVAR idx
+            if idx >= 0
+                " TLogVAR a:world.data
+                " call tlog#Debug(string(map(copy(a:world.data), 'v:val.bufnr')))
+                " TLogVAR idx, a:world.data[idx]
+                let qfe = a:world.data[idx]
+                " let back = a:world.SwitchWindow('win')
+                " TLogVAR cmd_edit, cmd_buffer, qfe
+                let fn = tlib#qfl#QfeFilename(qfe)
+                " TLogVAR cmd_edit, cmd_buffer, fn
+                if empty(cmd_edit) && empty(cmd_buffer)
+                    if tlib#file#Edit(fn)
+                        call tlib#buffer#ViewLine(qfe.lnum)
+                    endif
+                else
+                    call tlib#file#With(cmd_edit, cmd_buffer, [fn], a:world)
+                    " TLogDBG bufname('%')
+                    " TLogVAR &filetype
+                    call tlib#buffer#ViewLine(qfe.lnum)
+                    " exec back
+                endif
+            endif
+        endfor
+        if set_origin
+            call a:world.SetOrigin()
+        endif
+    endif
+    return a:world
+endf 
+
+
+function! tlib#qfl#AgentPreviewQFE(world, selected) "{{{3
+    " TLogVAR a:selected
+    let back = a:world.SwitchWindow('win')
+    call tlib#qfl#AgentEditQFE(a:world, a:selected[0:0], '', '', 0)
+    exec back
+    redraw
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#qfl#AgentGotoQFE(world, selected) "{{{3
+    let world = a:world
+    if !empty(a:selected)
+        let world = tlib#agent#Suspend(world, a:selected)
+        call tlib#qfl#AgentEditQFE(world, a:selected[0:0])
+    endif
+    return world
+endf
+
+
+function! tlib#qfl#AgentWithSelected(world, selected, ...) "{{{3
+    let cmd = a:0 >= 1 ? a:1 : input('Ex command: ', '', 'command')
+    let world = a:world
+    if !empty(cmd)
+        let world = tlib#qfl#RunCmdOnSelected(world, a:selected, cmd)
+    else
+        let world.state = 'redisplay'
+    endif
+    return world
+endf
+
+
+function! tlib#qfl#RunCmdOnSelected(world, selected, cmd, ...) "{{{3
+    let close_scratch = a:0 >= 1 ? a:1 : 1
+    if close_scratch
+        call a:world.CloseScratch()
+    endif
+    " TLogVAR a:cmd
+    for entry in a:selected
+        " TLogVAR entry, a:world.GetBaseItem(entry)
+        call tlib#qfl#AgentEditQFE(a:world, [entry], '', '', 0)
+        " TLogDBG bufname('%')
+        exec a:cmd
+        " let item = a:world.data[a:world.GetBaseIdx(entry - 1)]
+        " <+TODO+>
+        let item = a:world.data[entry - 1]
+        " TLogVAR entry, item, getline('.')
+        if has_key(a:world, 'GetBufferLines')
+            let lines = a:world.GetBufferLines('.', '.')
+        else
+            let lines = getline('.', '.')
+        endif
+        let item['text'] = tlib#string#Strip(lines[0])
+    endfor
+    if has_key(a:world, 'AfterRunCmd')
+        if bufnr('%') == a:world.bufnr
+            call a:world.AfterRunCmd()
+        else
+            " <+TODO+> Run in other buffer
+        endif
+    endif
+    " call s:FormatBase(a:world)
+    call a:world.RestoreOrigin()
+    let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#qfl#AgentSplitBuffer(world, selected) "{{{3
+    call a:world.CloseScratch()
+    return tlib#qfl#AgentEditQFE(a:world, a:selected, 'split', 'sbuffer')
+endf
+
+
+function! tlib#qfl#AgentTabBuffer(world, selected) "{{{3
+    call a:world.CloseScratch()
+    return tlib#qfl#AgentEditQFE(a:world, a:selected, 'tabedit', 'tab sbuffer')
+endf
+
+
+function! tlib#qfl#AgentVSplitBuffer(world, selected) "{{{3
+    call a:world.CloseScratch()
+    return tlib#qfl#AgentEditQFE(a:world, a:selected, 'vertical split', 'vertical sbuffer')
+endf
+
+
+" function! tlib#qfl#AgentOpenBuffer(world, selected) "{{{3
+" endf
+
+
+function! tlib#qfl#AgentEditLine(world, selected) "{{{3
+    call a:world.CloseScratch()
+    let cmd = 'call tlib#qfl#EditLine(".")'
+    return tlib#qfl#RunCmdOnSelected(a:world, a:selected, cmd)
+    let a:world.state = 'reset'
+    return a:world
+endf
+
+
+function! tlib#qfl#EditLine(lnum) "{{{3
+    call inputsave()
+    let line = input('', getline(a:lnum))
+    call inputrestore()
+    if !empty(line)
+        call setline(line(a:lnum), line)
+    endif
+endf
+
+
+function! tlib#qfl#SetFollowCursor(world, selected) "{{{3
+    if empty(a:world.follow_cursor)
+        let a:world.follow_cursor = 'tlib#qfl#AgentPreviewQFE'
+    else
+        let a:world.follow_cursor = ''
+    endif
+    let a:world.state = 'redisplay'
+    return a:world
+endf
+
+
+function! tlib#qfl#QflList(list, ...) abort "{{{3
+    TVarArg ['world_dict', {}], ['anyway', 0], ['suspended', 0]
+    Tlibtrace 'tlib', world_dict, anyway, suspended
+    " TLogVAR a:list, world_dict, anyway, suspended
+    if !anyway && empty(a:list)
+        return
+    endif
+    let world = copy(g:tlib#qfl#world)
+    if !empty(world_dict)
+        let world = tlib#eval#Extend(world, world_dict)
+    endif
+    " TLogVAR world
+    let world = tlib#World#New(world)
+    " echom "DBG world" string(sort(keys(world)))
+    let world.data  = copy(a:list)
+    if !has_key(world, 'format_data')
+        let world.format_data = 'tlib#qfl#FormatQFLE'
+    endif
+    " TLogVAR world
+    " TLogVAR world.data
+    " call s:FormatBase(world)
+    " TLogVAR world.base
+    return tlib#input#ListW(world, suspended ? 'hibernate' : '')
+endf
+
+
+function! tlib#qfl#Browse(...) abort "{{{3
+    let list = getqflist()
+    return call(function('tlib#qfl#QflList'), [list] + a:000)
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/rx.vim

@@ -0,0 +1,54 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    114
+
+
+" :def: function! tlib#rx#Escape(text, ?magic='m')
+" magic can be one of: m, M, v, V
+" See :help 'magic'
+function! tlib#rx#Escape(text, ...) "{{{3
+    TVarArg 'magic'
+    if empty(magic)
+        let magic = 'm'
+    endif
+    if magic =~# '^\\\?m$'
+        return escape(a:text, '^$.*\[]~')
+    elseif magic =~# '^\\\?M$'
+        return escape(a:text, '^$\')
+    elseif magic =~# '^\\\?V$'
+        return escape(a:text, '\')
+    elseif magic =~# '^\\\?v$'
+        return substitute(a:text, '[^0-9a-zA-Z_]', '\\&', 'g')
+    else
+        echoerr 'tlib: Unsupported magic type'
+        return a:text
+    endif
+endf
+
+" :def: function! tlib#rx#EscapeReplace(text, ?magic='m')
+" Escape return |sub-replace-special|.
+function! tlib#rx#EscapeReplace(text, ...) "{{{3
+    TVarArg ['magic', 'm']
+    return escape(a:text, '\&~')
+endf
+
+
+function! tlib#rx#Suffixes(...) "{{{3
+    TVarArg ['magic', 'm']
+    let sfx = split(&suffixes, ',')
+    call map(sfx, 'tlib#rx#Escape(v:val, magic)')
+    if magic ==# 'v'
+        return '('. join(sfx, '|') .')$'
+    elseif magic ==# 'V'
+        return '\('. join(sfx, '\|') .'\)\$'
+    else
+        return '\('. join(sfx, '\|') .'\)$'
+    endif
+endf
+
+
+function! tlib#rx#LooksLikeRegexp(text) abort "{{{3
+    return a:text =~ '[.?*+{}\[\]]'
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/scratch.vim

@@ -0,0 +1,136 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    255
+
+
+" Scratch window position. By default the list window is opened on the 
+" bottom. Set this variable to 'topleft' or '' to change this behaviour.
+" See |tlib#input#List()|.
+TLet g:tlib_scratch_pos = 'botright'
+
+" If you want the scratch buffer to be fully removed, you might want to 
+" set this variable to 'wipe'.
+" See also https://github.com/tomtom/tlib_vim/pull/16
+TLet g:tlib#scratch#hidden = 'hide'
+
+
+" :def: function! tlib#scratch#UseScratch(?keyargs={})
+" Display a scratch buffer (a buffer with no file). See :TScratch for an 
+" example.
+" Return the scratch buffer's number.
+" Values for keyargs:
+"   scratch_split ... 1: split, 0: window, -1: tab
+function! tlib#scratch#UseScratch(...) "{{{3
+    exec tlib#arg#Let([['keyargs', {}]])
+    " TLogDBG string(keys(keyargs))
+    let id = get(keyargs, 'scratch', '__Scratch__')
+    " TLogVAR id, bufwinnr(id)
+    " TLogVAR bufnr(id), bufname(id)
+    " TLogVAR 1, winnr(), bufnr('%'), bufname("%")
+    if bufwinnr(id) != -1
+        " echom 'DBG noautocmd keepalt keepj' bufwinnr(id) 'wincmd w'
+        exec 'noautocmd keepalt keepj' bufwinnr(id) 'wincmd w'
+        " TLogVAR "reuse", bufnr("%"), bufname("%")
+    else
+        let winpos = ''
+        let bn = bufnr(id)
+        let wpos = get(keyargs, 'scratch_pos', g:tlib_scratch_pos)
+        " TLogVAR keyargs.scratch_vertical
+        if get(keyargs, 'scratch_vertical')
+            let wpos .= ' vertical'
+            let winpos = tlib#fixes#Winpos()
+        endif
+        " TLogVAR wpos
+        let scratch_split = get(keyargs, 'scratch_split', 1)
+        if bn != -1
+            " TLogVAR bn
+            let wn = bufwinnr(bn)
+            if wn != -1
+                " TLogVAR wn
+                exec 'noautocmd keepalt keepj' (wn .'wincmd w')
+            else
+                if scratch_split == 1
+                    let cmd = wpos.' sbuffer!'
+                elseif scratch_split == -1
+                    let cmd = wpos.' tab sbuffer!'
+                else
+                    let cmd = 'buffer!'
+                endif
+                " TLogVAR cmd, bn
+                silent exec 'noautocmd keepalt keepj' cmd bn
+            endif
+        else
+            " TLogVAR id
+            if scratch_split == 1
+                let cmd = wpos.' split'
+            elseif scratch_split == -1
+                let cmd = wpos.' tab split'
+            else
+                let cmd = 'edit'
+            endif
+            " TLogVAR cmd, id
+            silent exec 'noautocmd keepalt keepj' cmd escape(id, '%#\ ')
+            " silent exec 'split '. id
+        endif
+        let ft = get(keyargs, 'scratch_filetype', '')
+        " TLogVAR ft, winpos
+        if !empty(winpos)
+            exec winpos
+        endif
+        setlocal buftype=nofile
+        let &l:bufhidden = get(keyargs, 'scratch_hidden', g:tlib#scratch#hidden)
+        setlocal noswapfile
+        setlocal nobuflisted
+        setlocal foldmethod=manual
+        setlocal foldcolumn=0
+        setlocal nospell
+        setlocal modifiable
+        setlocal noreadonly
+        " TLogVAR &ft, ft
+        if !empty(ft)
+            let &l:ft = ft
+        endif
+    endif
+    let keyargs.scratch = bufnr('%')
+    let keyargs.scratch_tabpagenr = tabpagenr()
+    let keyargs.scratch_winnr = winnr()
+    " TLogVAR 2, winnr(), bufnr('%'), bufname("%"), keyargs.scratch
+    return keyargs.scratch
+endf
+
+
+" Close a scratch buffer as defined in keyargs (usually a World).
+" Return 1 if the scratch buffer is closed (or if it already was 
+" closed).
+function! tlib#scratch#CloseScratch(keyargs, ...) "{{{3
+    TVarArg ['reset_scratch', 1]
+    let scratch = get(a:keyargs, 'scratch', '')
+    " TLogVAR scratch, reset_scratch
+    " TLogDBG string(tlib#win#List())
+    if !empty(scratch) && winnr('$') > 1
+        let wn = bufwinnr(scratch)
+        " TLogVAR wn
+        try
+            if wn != -1
+                " TLogDBG winnr()
+                let wb = tlib#win#Set(wn)
+                let winpos = tlib#fixes#Winpos()
+                wincmd c
+                if get(a:keyargs, 'scratch_vertical') && !empty(winpos)
+                    exec winpos
+                endif
+                " exec wb 
+                " redraw
+                " TLogVAR winnr()
+            endif
+            return 1
+        finally
+            if reset_scratch
+                let a:keyargs.scratch = ''
+            endif
+        endtry
+    endif
+    return 0
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/selection.vim

@@ -0,0 +1,40 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2017-09-28
+" @Revision:    4
+
+
+" :display: tlib#selection#GetSelection(mode, ?mbeg="'<", ?mend="'>", ?opmode='selection')
+" mode can be one of: selection, lines, block
+function! tlib#selection#GetSelection(mode, ...) range "{{{3
+    if a:0 >= 2
+        let mbeg = a:1
+        let mend = a:2
+    else
+        let mbeg = "'<"
+        let mend = "'>"
+    endif
+    let opmode = a:0 >= 3 ? a:3 : 'selection'
+    let l0   = line(mbeg)
+    let l1   = line(mend)
+    let text = getline(l0, l1)
+    let c0   = col(mbeg)
+    let c1   = col(mend)
+    " TLogVAR mbeg, mend, opmode, l0, l1, c0, c1
+    " TLogVAR text[-1]
+    " TLogVAR len(text[-1])
+    if opmode == 'block'
+        let clen = c1 - c0
+        call map(text, 'tlib#string#Strcharpart(v:val, c0, clen)')
+    elseif opmode == 'selection'
+        if c1 > 1
+            let text[-1] = tlib#string#Strcharpart(text[-1], 0, c1 - (a:mode == 'o' || c1 > len(text[-1]) ? 0 : 1))
+        endif
+        if c0 > 1
+            let text[0] = tlib#string#Strcharpart(text[0], c0 - 1)
+        endif
+    endif
+    return text
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/signs.vim

@@ -0,0 +1,103 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2009-03-12.
+" @Last Change: 2011-03-10.
+" @Revision:    0.0.45
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+let s:base = 2327
+let s:register = {}
+
+
+" Clear all signs with name SIGN.
+function! tlib#signs#ClearAll(sign) "{{{3
+    " TLog a:sign
+    for bn in keys(s:register)
+        let idxs = keys(s:register)
+        call filter(idxs, 's:register[v:val].sign == a:sign')
+        " TLogVAR bns
+        for idx in idxs
+            exec 'sign unplace '. idx .' buffer='. s:register[idx].bn
+            call remove(s:register, idx)
+        endfor
+    endfor
+endf
+
+
+" Clear all signs with name SIGN in buffer BUFNR.
+function! tlib#signs#ClearBuffer(sign, bufnr) "{{{3
+    for bn in keys(s:register)
+        let idxs = keys(s:register)
+        call filter(idxs, 's:register[v:val].sign == a:sign && s:register[v:val].bn == a:bufnr')
+        " TLogVAR bns
+        for idx in idxs
+            exec 'sign unplace '. idx .' buffer='. s:register[idx].bn
+            call remove(s:register, idx)
+        endfor
+    endfor
+endf
+
+
+" function! tlib#signs#Clear(sign, list) "{{{3
+"     " TLogVAR a:sign
+"     let done = []
+"     for item in a:list
+"         let bn = get(item, 'bufnr', -1)
+"         if index(done, bn) == -1
+"             let idxs = keys(s:register)
+"             call filter(idxs, 's:register[v:val].sign == a:sign && s:register[v:val].bn == bn')
+"             for idx in idxs
+"                 exec 'sign unplace '. idx .' buffer='. s:register[idx].bn
+"                 call remove(s:register, idx)
+"             endfor
+"             call add(done, bn)
+"         endif
+"     endfor
+" endf
+
+
+" Add signs for all locations in LIST. LIST must adhere with the 
+" quickfix list format (see |getqflist()|; only the fields lnum and 
+" bufnr are required).
+"
+" list:: a quickfix or location list
+" sign:: a sign defined with |:sign-define|
+function! tlib#signs#Mark(sign, list) "{{{3
+    " TLogVAR a:sign
+    for item in a:list
+        let idx = s:SignId(item)
+        if idx >= 0
+            let lnum = get(item, 'lnum', 0)
+            if lnum > 0
+                let bn = get(item, 'bufnr')
+                exec ':sign place '. idx .' line='. lnum .' name='. a:sign .' buffer='. bn
+                let s:register[idx] = {'sign': a:sign, 'bn': bn}
+            endif
+        endif
+    endfor
+endf
+
+
+function! s:SignId(item) "{{{3
+    " TLogVAR a:item
+    " let bn  = bufnr('%')
+    let bn = get(a:item, 'bufnr', -1)
+    if bn == -1
+        return -1
+    else
+        let idx = s:base + bn * 500
+        while has_key(s:register, idx)
+            let idx += 1
+        endwh
+        return idx
+    endif
+endf
+
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

sources_non_forked_fallback/tlib/autoload/tlib/string.vim

@@ -0,0 +1,208 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    148
+
+
+" :def: function! tlib#string#RemoveBackslashes(text, ?chars=' ')
+" Remove backslashes from text (but only in front of the characters in 
+" chars).
+function! tlib#string#RemoveBackslashes(text, ...) "{{{3
+    exec tlib#arg#Get(1, 'chars', ' ')
+    " TLogVAR chars
+    let rv = substitute(a:text, '\\\(['. chars .']\)', '\1', 'g')
+    return rv
+endf
+
+
+" :display: tlib#string#Chomp(string, ?max=0)
+function! tlib#string#Chomp(string, ...) "{{{3
+    let quant = a:0 >= 1 ? '\{,'. a:1 .'}' : '\+'
+    return substitute(a:string, '[[:cntrl:][:space:]]'. quant .'$', '', '')
+endf
+
+
+" Format a template string. Placeholders have the format "%{NAME}". A 
+" "%" can be inserted as "%%".
+"
+" Examples:
+"   echo tlib#string#Format("foo %{bar} foo", {'bar': 123}, ?prefix='%')
+"   => foo 123 foo
+function! tlib#string#Format(template, dict, ...) "{{{3
+    let prefix = a:0 >= 1 ? a:1 : '%'
+    let pesc = prefix . prefix
+    let prx = tlib#rx#Escape(prefix)
+    let parts = split(a:template, '\ze'. prx .'\({.\{-}}\|.\)')
+    let partrx = '^'. prx .'\({\(.\{-}\)}\|\(.\)\)\(.*\)$'
+    let out = []
+    for part in parts
+        let ml   = matchlist(part, partrx)
+        if empty(ml)
+            let rest = part
+        else
+            let var  = empty(ml[2]) ? ml[3] : ml[2]
+            let rest = ml[4]
+            if has_key(a:dict, var)
+                call add(out, a:dict[var])
+            elseif var ==# pesc
+                call add(out, prefix)
+            else
+                call add(out, ml[1])
+            endif
+        endif
+        call add(out, rest)
+    endfor
+    return join(out, '')
+endf
+
+
+" This function deviates from |printf()| in certain ways.
+" Additional items:
+"     %{rx}      ... insert escaped regexp
+"     %{fuzzyrx} ... insert typo-tolerant regexp
+function! tlib#string#Printf1(format, string) "{{{3
+    let s = split(a:format, '%.\zs')
+    " TLogVAR s
+    return join(map(s, 's:PrintFormat(v:val, a:string)'), '')
+endf
+
+function! s:PrintFormat(format, string) "{{{3
+    let cut = match(a:format, '%\({.\{-}}\|.\)$')
+    if cut == -1
+        return a:format
+    else
+        let head = cut > 0 ? a:format[0 : cut - 1] : ''
+        let tail = a:format[cut : -1]
+        " TLogVAR head, tail
+        if tail == '%{fuzzyrx}'
+            let frx = []
+            for i in range(len(a:string))
+                if i > 0
+                    let pb = i - 1
+                else
+                    let pb = 0
+                endif
+                let slice = tlib#rx#Escape(a:string[pb : i + 1])
+                call add(frx, '['. slice .']')
+                call add(frx, '.\?')
+            endfor
+            let tail = join(frx, '')
+        elseif tail == '%{rx}'
+            let tail = tlib#rx#Escape(a:string)
+        elseif tail == '%%'
+            let tail = '%'
+        elseif tail == '%s'
+            let tail = a:string
+        endif
+        " TLogVAR tail
+        return head . tail
+    endif
+endf
+" function! tlib#string#Printf1(format, string) "{{{3
+"     let n = len(split(a:format, '%\@<!%s', 1)) - 1
+"     let f = a:format
+"     if f =~ '%\@<!%{fuzzyrx}'
+"         let frx = []
+"         for i in range(len(a:string))
+"             if i > 0
+"                 let pb = i - 1
+"             else
+"                 let pb = 0
+"             endif
+"             let slice = tlib#rx#Escape(a:string[pb : i + 1])
+"             call add(frx, '['. slice .']')
+"             call add(frx, '.\?')
+"         endfor
+"         let f = s:RewriteFormatString(f, '%{fuzzyrx}', join(frx, ''))
+"     endif
+"     if f =~ '%\@<!%{rx}'
+"         let f = s:RewriteFormatString(f, '%{rx}', tlib#rx#Escape(a:string))
+"     endif
+"     if n == 0
+"         return substitute(f, '%%', '%', 'g')
+"     else
+"         let a = repeat([a:string], n)
+"         return call('printf', insert(a, f))
+"     endif
+" endf
+
+
+function! s:RewriteFormatString(format, pattern, string) "{{{3
+    let string = substitute(a:string, '%', '%%', 'g')
+    return substitute(a:format, tlib#rx#Escape(a:pattern), escape(string, '\'), 'g')
+endf
+
+
+function! tlib#string#TrimLeft(string) "{{{3
+    return substitute(a:string, '^[[:space:][:cntrl:]]\+', '', '')
+endf
+
+
+function! tlib#string#TrimRight(string) "{{{3
+    return substitute(a:string, '[[:space:][:cntrl:]]\+$', '', '')
+endf
+
+
+function! tlib#string#Strip(string) "{{{3
+    return tlib#string#TrimRight(tlib#string#TrimLeft(a:string))
+endf
+
+
+function! tlib#string#Count(string, rx) "{{{3
+    let s:count = 0
+    call substitute(a:string, a:rx, '\=s:CountHelper()', 'g')
+    return s:count
+endf
+
+function! s:CountHelper() "{{{3
+    let s:count += 1
+endf
+
+
+function! tlib#string#SplitCommaList(text, ...) abort "{{{3
+    let sep = a:0 >= 1 ? a:1 : ',\s*'
+    let parts = split(a:text, '\\\@<!\zs'. sep)
+    let parts = map(parts, 'substitute(v:val, ''\\\(.\)'', ''\1'', ''g'')')
+    return parts
+endf
+
+
+function! tlib#string#Input(...) abort "{{{3
+    TVarArg ['text', ''], ['completion', '']
+    call inputsave()
+    let rv = call(function('input'), a:000)
+    call inputrestore()
+    return rv
+endf
+
+
+" :display: tlib#string#MatchAll(string, sep_regexp, ?item_regexp='') abort
+function! tlib#string#MatchAll(string, regexp, ...) abort "{{{3
+    let eregexp = a:0 >= 1 ? a:1 : ''
+    Tlibtrace 'tlib', a:string, a:regexp, eregexp
+    let ms = []
+    if a:regexp =~ '\\ze'
+        let regexp1 = substitute(a:regexp, '\\ze.*$', '', '')
+    else
+        let regexp1 = a:regexp
+    endif
+    for m in split(a:string, '\ze'. regexp1)
+        let m1 = matchstr(m, !empty(eregexp) ? eregexp : a:regexp)
+        Tlibtrace 'tlib', m, m1
+        if !empty(m1)
+            call add(ms, m1)
+        endif
+    endfor
+    return ms
+endf
+
+if exists('*strcharpart')
+    function! tlib#string#Strcharpart(...) abort "{{{3
+        return call(function('strcharpart'), a:000)
+    endf
+else
+    function! tlib#string#Strcharpart(...) abort "{{{3
+        return call(function('strpart'), a:000)
+    endf
+endif
+

sources_non_forked_fallback/tlib/autoload/tlib/syntax.vim

@@ -0,0 +1,38 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    13
+
+
+function! tlib#syntax#Collect() "{{{3
+    let acc = {}
+    let syn = ''
+    for line in tlib#cmd#OutputAsList('syntax')
+        if line =~ '^---'
+            continue
+        elseif line =~ '^\w'
+            let ml = matchlist(line, '^\(\w\+\)\s\+\(xxx\s\+\(.*\)\|\(cluster.*\)\)$')
+            if empty(ml)
+                " echoerr 'Internal error: '. string(line)
+            else
+                let [m_0, syn, m_1, m_def1, m_def2; m_rest] = ml
+                let acc[syn] = [empty(m_def1) ? m_def2 : m_def1]
+            endif
+        else
+            call add(acc[syn], matchstr(line, '^\s\+\zs.*$'))
+        endif
+    endfor
+    return acc
+endf
+
+
+" :def: function! tlib#syntax#Names(?rx='')
+function! tlib#syntax#Names(...) "{{{3
+    TVarArg 'rx'
+    let names = keys(tlib#syntax#Collect())
+    if !empty(rx)
+        call filter(names, 'v:val =~ rx')
+    endif
+    return names
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/sys.vim

@@ -0,0 +1,218 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2017-04-12.
+" @Revision:    62
+
+
+if !exists('g:tlib#sys#special_protocols')
+    " A list of |regexp|s matching protocol names that should be handled 
+    " by |g:tlib#sys#system_browser|.
+    " CAVEAT: Must be a |\V| |regexp|.
+    let g:tlib#sys#special_protocols = ['https\?', 'nntp', 'mailto']   "{{{2
+endif
+
+
+if !exists('g:tlib#sys#special_suffixes')
+    " A list of |regexp|s matching suffixes that should be handled by 
+    " |g:tlib#sys#system_browser|.
+    " CAVEAT: Must be a |\V| |regexp|.
+    let g:tlib#sys#special_suffixes = ['xlsx\?', 'docx\?', 'pptx\?', 'accdb', 'mdb', 'sqlite', 'pdf', 'jpg', 'png', 'gif', 'od\[tspg]']    "{{{2
+endif
+
+
+if !exists('g:tlib#sys#system_rx')
+    " Open links matching this |regexp| with |g:tlib#sys#system_browser|.
+    " CAVEAT: Must be a |\V| |regexp|.
+    let g:tlib#sys#system_rx = printf('\V\%(\^\%(%s\):\|.\%(%s\)\$\)', join(g:tlib#sys#special_protocols, '\|'), join(g:tlib#sys#special_suffixes, '\|'))   "{{{2
+endif
+
+
+if !exists("g:tlib#sys#system_browser")
+    if exists('g:netrw_browsex_viewer')
+        " Open files in the system browser.
+        " :read: let g:tlib#sys#system_browser = ... "{{{2
+        let g:tlib#sys#system_browser = "exec 'silent !'. g:netrw_browsex_viewer shellescape('%s')"
+    elseif has("win32") || has("win16") || has("win64")
+        " let g:tlib#sys#system_browser = "exec 'silent ! start \"\"' shellescape('%s')"
+        let g:tlib#sys#system_browser = "exec 'silent ! RunDll32.EXE URL.DLL,FileProtocolHandler' shellescape('%s')"
+    elseif has("mac")
+        let g:tlib#sys#system_browser = "exec 'silent !open' shellescape('%s')"
+    elseif exists('$XDG_CURRENT_DESKTOP') && !empty($XDG_CURRENT_DESKTOP)
+        let g:tlib#sys#system_browser = "exec 'silent !xdg-open' shellescape('%s') '&'"
+    elseif !empty($GNOME_DESKTOP_SESSION_ID) || $DESKTOP_SESSION ==# 'gnome'
+        let g:tlib#sys#system_browser = "exec 'silent !gnome-open' shellescape('%s')"
+    elseif exists("$KDEDIR") && !empty($KDEDIR)
+        let g:tlib#sys#system_browser = "exec 'silent !kfmclient exec' shellescape('%s')"
+    else
+        let g:tlib#sys#system_browser = ''
+    endif
+endif
+
+
+if !exists('g:tlib#sys#windows')
+    let g:tlib#sys#windows = &shell !~ 'sh' && (has('win16') || has('win32') || has('win64'))   "{{{2
+endif
+
+
+if !exists('g:tlib#sys#null')
+    let g:tlib#sys#null = g:tlib#sys#windows ? 'NUL' : (filereadable('/dev/null') ? '/dev/null' : '')    "{{{2
+endif
+
+
+let s:cygwin = {}
+
+function! tlib#sys#IsCygwinBin(cmd) "{{{3
+    " TLogVAR a:cmd
+    if !g:tlib#sys#windows
+        return 0
+    elseif has_key(s:cygwin, a:cmd)
+        let rv = s:cygwin[a:cmd]
+    else
+        if !tlib#sys#IsExecutable('cygpath', 1) || !tlib#sys#IsExecutable('which', 1)
+            let rv = 0
+        else
+            let which = substitute(system('which '. shellescape(a:cmd)), '\n$', '', '')
+            " echom "DBG which:" which
+            if which =~ '^/'
+                let filename = system('cygpath -ma '. shellescape(which))
+                " echom "DBG filename:" filename
+                let rv = filename =~ g:tlib#sys#cygwin_path_rx
+            else
+                let rv = 0
+            endif
+        endif
+        let s:cygwin[a:cmd] = rv
+    endif
+    " TLogVAR rv
+    return rv
+endf
+
+
+let s:executables = {}
+
+function! tlib#sys#IsExecutable(cmd, ...) "{{{3
+    " TLogVAR a:cmd
+    " echom "DBG has_key(s:executables, a:cmd)" has_key(s:executables, a:cmd)
+    if !has_key(s:executables, a:cmd)
+        let executable = executable(a:cmd)
+        " TLogVAR 1, executable
+        let ignore_cyg = a:0 >= 1 ? a:1 : !g:tlib#sys#windows
+        if !executable && !ignore_cyg
+            let executable = tlib#sys#IsCygwinBin(a:cmd)
+            " TLogVAR 2, executable
+        endif
+        let s:executables[a:cmd] = executable
+    endif
+    " echom "DBG s:executables[a:cmd]" s:executables[a:cmd]
+    return s:executables[a:cmd]
+endf
+
+
+if !exists('g:tlib#sys#check_cygpath')
+    " If true, check whether we have to convert a path via cyppath -- 
+    " see |tlib#sys#MaybeUseCygpath|
+    let g:tlib#sys#check_cygpath = g:tlib#sys#windows && tlib#sys#IsExecutable('cygpath', 1)   "{{{2
+endif
+
+
+if !exists('g:tlib#sys#cygwin_path_rx')
+    " If a full windows filename (with slashes instead of backslashes) 
+    " matches this |regexp|, it is assumed to be a cygwin executable.
+    let g:tlib#sys#cygwin_path_rx = '/cygwin/'   "{{{2
+endif
+
+
+if !exists('g:tlib#sys#cygwin_expr')
+    " For cygwin binaries, convert command calls using this vim 
+    " expression.
+    let g:tlib#sys#cygwin_expr = '"bash -c ''". escape(%s, "''\\") ."''"'   "{{{2
+endif
+
+
+function! tlib#sys#GetCmd(cmd) "{{{3
+    if !empty(g:tlib#sys#cygwin_expr) && tlib#sys#IsCygwinBin(matchstr(a:cmd, '^\S\+'))
+        let cmd = eval(printf(g:tlib#sys#cygwin_expr, string(a:cmd)))
+        " TLogVAR cmd
+        return cmd
+    else
+        return a:cmd
+    endif
+endf
+
+
+" If cmd seems to be a cygwin executable, use cygpath to convert 
+" filenames. This assumes that cygwin's which command returns full 
+" filenames for non-cygwin executables.
+function! tlib#sys#MaybeUseCygpath(cmd) "{{{3
+    " echom "DBG" a:cmd
+    if g:tlib#sys#check_cygpath && tlib#sys#IsCygwinBin(a:cmd)
+        return 'cygpath -u "%s"'
+    endif
+    return ''
+endf
+
+
+function! tlib#sys#ConvertPath(converter, filename) "{{{3
+    return tlib#string#Chomp(system(printf(a:converter, shellescape(a:filename))))
+endf
+
+
+let s:native_filenames = {}
+
+function! tlib#sys#FileArgs(cmd, files) "{{{3
+    let cygpath = tlib#sys#MaybeUseCygpath(a:cmd)
+    " TLogVAR cygpath
+    if empty(cygpath)
+        return a:files
+    else
+        let files = map(copy(a:files), 'has_key(s:native_filenames, v:val) ? s:native_filenames[v:val] : tlib#sys#CygPath(v:val)')
+        return files
+    endif
+endf
+
+
+" Check whether filename matches |g:tlib#sys#system_rx|, i.e. whether it 
+" is a special file that should not be opened in vim.
+function! tlib#sys#IsSpecial(filename) abort "{{{3
+    return a:filename =~ g:tlib#sys#system_rx
+endf
+
+
+" Open filename with the default OS application (see 
+" |g:tlib#sys#system_browser|), if |tlib#sys#IsSpecial()| return 1. 
+" Returns 1 if successful or 0 otherwise.
+function! tlib#sys#Open(filename) abort "{{{3
+    Tlibtrace 'tlib', a:filename
+    if !empty(g:tlib#sys#system_browser) && tlib#sys#IsSpecial(a:filename)
+        try
+            call tlib#sys#OpenWithSystemViewer(a:filename)
+            return 1
+        catch
+            echohl ErrorMsg
+            echom v:exception
+            echohl NONE
+        endtry
+    endif
+    return 0
+endf
+
+
+" Open filename with the default system viewer.
+function! tlib#sys#OpenWithSystemViewer(filename) abort "{{{3
+    let cmd = printf(g:tlib#sys#system_browser, a:filename)
+    " let cmd = printf(g:tlib#sys#system_browser, escape(a:filename, ' %#!'))
+    Tlibtrace 'tlib', cmd
+    exec cmd
+endf
+
+
+" :def: function! tlib#sys#SystemInDir(dir, expr, ?input='')
+function! tlib#sys#SystemInDir(dir, ...) abort "{{{3
+    call tlib#dir#CD(a:dir)
+    try
+        return call(function('system'), a:000)
+    finally
+        silent cd! -
+    endtry
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/tab.vim

@@ -0,0 +1,49 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    31
+
+
+" Return a dictionary of bufnumbers => [[tabpage, winnr] ...]
+function! tlib#tab#BufMap() "{{{3
+    let acc = {}
+    for t in range(tabpagenr('$'))
+        let bb = tabpagebuflist(t + 1)
+        for b in range(len(bb))
+            let bn = bb[b]
+            let bd = [t + 1, b + 1]
+            if has_key(acc, bn)
+                call add(acc[bn], bd)
+            else
+                let acc[bn] = [bd]
+            endif
+        endfor
+    endfor
+    return acc
+endf
+
+
+" Find a buffer's window at some tab page.
+function! tlib#tab#TabWinNr(buffer) "{{{3
+    let bn = bufnr(a:buffer)
+    let bt = tlib#tab#BufMap()
+    let tn = tabpagenr()
+    let wn = winnr()
+    let bc = get(bt, bn)
+    if !empty(bc)
+        for [t, w] in bc
+            if t == tn
+                return [t, w]
+            endif
+        endfor
+        return bc[0]
+    endif
+endf
+
+
+function! tlib#tab#Set(tabnr) "{{{3
+    if a:tabnr > 0
+        exec a:tabnr .'tabnext'
+    endif
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/tag.vim

@@ -0,0 +1,133 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    64
+
+
+" Extra tags for |tlib#tag#Retrieve()| (see there). Can also be buffer-local.
+TLet g:tlib_tags_extra = ''
+
+" Filter the tag description through |substitute()| for these filetypes. 
+" This applies only if the tag cmd field (see |taglist()|) is used.
+" :nodefault:
+TLet g:tlib_tag_substitute = {
+            \ 'java': [['\s*{\s*$', '', '']],
+            \ 'ruby': [['\<\(def\|class\|module\)\>\s\+', '', '']],
+            \ 'vim':  [
+            \   ['^\s*com\%[mand]!\?\(\s\+-\S\+\)*\s*\u\w*\zs.*$', '', ''],
+            \   ['^\s*\(let\|aug\%[roup]\|fu\%[nction]!\?\|com\%[mand]!\?\(\s\+-\S\+\)*\)\s*', '', ''],
+            \   ['"\?\s*{{{\d.*$', '', ''],
+            \ ],
+            \ }
+
+
+" :def: function! tlib#tag#Retrieve(rx, ?extra_tags=0)
+" Get all tags matching rx. Basically, this function simply calls 
+" |taglist()|, but when extra_tags is true, the list of the tag files 
+" (see 'tags') is temporarily expanded with |g:tlib_tags_extra|.
+"
+" Example use:
+" If you want to include tags for, eg, JDK, normal tags use can become 
+" slow. You could proceed as follows:
+"     1. Create a tags file for the JDK sources. When creating the tags 
+"     file, make sure to include inheritance information and the like 
+"     (command-line options like --fields=+iaSm --extra=+q should be ok).
+"     In this example, we want tags only for public methods (there are 
+"     most likely better ways to do this): >
+"          ctags -R --fields=+iaSm --extra=+q ${JAVA_HOME}/src
+"          head -n 6 tags > tags0
+"          grep access:public tags >> tags0
+" <    2. Make 'tags' include project specific tags files. In 
+"      ~/vimfiles/after/ftplugin/java.vim insert: >
+"          let b:tlib_tags_extra = $JAVA_HOME .'/tags0'
+" <    3. When this function is invoked as >
+"          echo tlib#tag#Retrieve('print')
+" <    it will return only project-local tags. If it is invoked as >
+"          echo tlib#tag#Retrieve('print', 1)
+" <    tags from the JDK will be included.
+function! tlib#tag#Retrieve(rx, ...) "{{{3
+    TVarArg ['extra_tags', 0]
+    Tlibtrace 'tlib', a:rx, extra_tags
+    if extra_tags
+        let tags_orig = &l:tags
+        if empty(tags_orig)
+            setlocal tags<
+        endif
+        try
+            let more_tags = tlib#var#Get('tlib_tags_extra', 'bg')
+            if !empty(more_tags)
+                let &l:tags .= ','. more_tags
+            endif
+            let taglist = taglist(a:rx)
+        finally
+            let &l:tags = tags_orig
+        endtry
+    else
+        let taglist = taglist(a:rx)
+    endif
+    Tlibtrace 'tlib', len(taglist)
+    return copy(taglist)
+endf
+
+
+" Retrieve tags that meet the constraints (a dictionnary of fields and 
+" regexp, with the exception of the kind field which is a list of chars). 
+" For the use of the optional use_extra argument see 
+" |tlib#tag#Retrieve()|.
+" :def: function! tlib#tag#Collect(constraints, ?use_extra=1, ?match_front=1)
+function! tlib#tag#Collect(constraints, ...) "{{{3
+    TVarArg ['use_extra', 0], ['match_end', 1], ['match_front', 1]
+    Tlibtrace 'tlib', a:constraints, use_extra, match_end, match_front
+    let rx = get(a:constraints, 'name', '')
+    if empty(rx) || rx == '*'
+        let rx = '.'
+    else
+        let rxl = ['\C']
+        if match_front
+            call add(rxl, '^')
+        endif
+        " call add(rxl, tlib#rx#Escape(rx))
+        call add(rxl, rx)
+        if match_end
+            call add(rxl, '$')
+        endif
+        let rx = join(rxl, '')
+    endif
+    Tlibtrace 'tlib', rx, use_extra
+    let tags = tlib#tag#Retrieve(rx, use_extra)
+    Tlibtrace 'tlib', len(tags)
+    for [field, rx] in items(a:constraints)
+        if !empty(rx) && rx != '*'
+            " TLogVAR field, rx
+            if field == 'kind'
+                call filter(tags, 'v:val.kind =~ "['. rx .']"')
+            elseif field != 'name'
+                call filter(tags, '!empty(get(v:val, field)) && get(v:val, field) =~ rx')
+            endif
+        endif
+    endfor
+    Tlibtrace 'tlib', len(tags)
+    return tags
+endf
+
+
+function! tlib#tag#Format(tag) "{{{3
+    if has_key(a:tag, 'signature')
+        let name = a:tag.name . a:tag.signature
+    elseif a:tag.cmd[0] == '/'
+        let name = a:tag.cmd
+        let name = substitute(name, '^/\^\?\s*', '', '')
+        let name = substitute(name, '\s*\$\?/$', '', '')
+        let name = substitute(name, '\s\{2,}', ' ', 'g')
+        let tsub = tlib#var#Get('tlib_tag_substitute', 'bg')
+        if has_key(tsub, &filetype)
+            for [rx, rplc, sub] in tsub[&filetype]
+                let name = substitute(name, rx, rplc, sub)
+            endfor
+        endif
+    else
+        let name = a:tag.name
+    endif
+    return name
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/textobjects.vim

@@ -0,0 +1,45 @@
+" textobjects.vim
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-01-09.
+" @Last Change: 2010-01-10.
+" @Revision:    0.0.29
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+
+" :tag: standard-paragraph
+" Select a "Standard Paragraph", i.e. a text block followed by blank 
+" lines. Other than |ap|, the last paragraph in a document is handled 
+" just the same.
+"
+" The |text-object| can be accessed as "sp". Example: >
+"
+"   vsp ... select the current standard paragraph
+"
+" Return 1, if the paragraph is the last one in the document.
+function! tlib#textobjects#StandardParagraph() "{{{3
+    if line("'}") == line('$')
+        norm! vip
+        return 1
+    else
+        norm! vap
+        return 0
+    endif
+endf
+
+
+function! tlib#textobjects#Init() "{{{3
+    if !exists('s:tlib_done_textobjects')
+        " sp ... Standard paragraph (for use as |text-objects|).
+        vnoremap <silent> sp <Esc>:call tlib#textobjects#StandardParagraph()<CR>
+        onoremap <silent> sp :<C-u>normal Vsp<CR>
+        let s:tlib_done_textobjects = 1
+    endif
+endf
+
+
+let &cpo = s:save_cpo
+unlet s:save_cpo

sources_non_forked_fallback/tlib/autoload/tlib/time.vim

@@ -0,0 +1,84 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    42
+
+
+function! tlib#time#MSecs() "{{{3
+    let rts = reltimestr(reltime())
+    return substitute(rts, '\.', '', '')
+endf
+
+
+function! tlib#time#Now() "{{{3
+    if has('reltime')
+        let rts = reltimestr(reltime())
+        let rtl = map(split(rts, '\.'), 'str2nr(v:val)')
+    else
+        let rtl = [localtime()]
+    endif
+    return rtl
+endf
+
+
+function! tlib#time#FormatNow() "{{{3
+    let rtl = tlib#time#Now()
+    if len(rtl) == 2
+        let rts = strftime(g:tlib#date#date_format .' %H:%M:%S', rtl[0]) .'.'. rtl[1]
+    else
+        let rts = strftime(g:tlib#date#date_format .' %H:%M:%S', rtl[0])
+    endif
+    return rts
+endf
+
+
+function! tlib#time#Diff(a, b, ...) "{{{3
+    TVarArg ['resolution', 2]
+    let [as, am] = a:a
+    let [bs, bm] = a:b
+    let rv = 0 + (as - bs)
+    if resolution > 0
+        let rv .= repeat('0', resolution)
+        let am = am[0 : resolution - 1]
+        let bm = bm[0 : resolution - 1]
+        let rv += (am - bm)
+    endif
+    return rv
+endf
+
+
+function! tlib#time#DiffMSecs(a, b, ...) "{{{3
+    TVarArg ['resolution', 2]
+    if a:a == a:b
+        return 0
+    endif
+    let a = printf('%30s', a:a[0 : -(7 - resolution)])
+    let b = printf('%30s', a:b[0 : -(7 - resolution)])
+    for i in range(0, 29)
+        if a[i] != b[i]
+            let a = a[i : -1]
+            let b = b[i : -1]
+            return a - b
+        endif
+    endfor
+    return 0
+endf
+
+
+function! tlib#time#Command(cmd, ...) abort "{{{3
+    let loops = a:0 >= 1 ? a:1 : 1
+    let silent = a:0 >= 1 ? a:1 : 0
+    let start = tlib#time#Now()
+    for loop in range(loops)
+        if silent
+            silent! exec a:cmd
+        else
+            exec a:cmd
+        endif
+    endfor
+    let end = tlib#time#Now()
+    let diff = tlib#time#Diff(end, start)
+    echom 'Time:' diff
+    return diff
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/trace.vim

@@ -0,0 +1,198 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     https://github.com/tomtom
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Last Change: 2017-03-09
+" @Revision:    205
+
+
+if !exists('g:tlib#trace#backtrace')
+    " The length of the backtrace that should be included in 
+    " |tlib#trace#Print()|.
+    let g:tlib#trace#backtrace = 2   "{{{2
+endif
+
+
+if !exists('g:tlib#trace#printer')
+    " Possible values:
+    "   - 'echom'
+    "   - ['file', FILENAME]
+    let g:tlib#trace#printer = 'echom'   "{{{2
+endif
+
+
+if !exists('g:tlib#trace#hl')
+    let g:tlib#trace#hl = {'error': 'ErrorMsg', 'fatal': 'ErrorMsg', 'warn': 'WarningMsg'}   "{{{2
+endif
+
+
+" Print traces from |tlib#trace#Print()|.
+function! tlib#trace#Printer_echom(type, text, args) abort "{{{3
+    let hl = get(g:tlib#trace#hl, a:type, '')
+    try
+        if !empty(hl)
+            exec 'echohl' hl
+        endif
+        echom a:text
+    finally
+        if !empty(hl)
+            echohl NONE
+        endif
+    endtry
+endf
+
+
+function! tlib#trace#Printer_file(type, text, args) abort "{{{3
+    let filename = get(a:args, 0, '')
+    if exists(filename) && !filewritable(filename)
+        throw 'tlib#trace#Printer_file: Cannot write to file: '. filename
+    else
+        call writefile([a:text], filename, 'a')
+    endif
+endf
+
+
+" Set the tracing |regexp|. See |:Tlibtrace|.
+" This will also call |tlib#trace#Enable()|.
+"
+" Examples:
+"   call tlib#trace#Set(["+foo", "-bar"])
+"   call tlib#trace#Set("+foo,-bar")
+function! tlib#trace#Set(vars, ...) abort "{{{3
+    let reset = a:0 >= 1 ? a:1 : 0
+    if reset
+        call tlib#trace#Reset()
+    endif
+    if empty(a:vars)
+        return
+    endif
+    call tlib#trace#Enable()
+    if type(a:vars) == v:t_string
+        let vars = tlib#string#SplitCommaList(a:vars, '[,[:space:]]\+')
+        let opts = {}
+    elseif type(a:vars) == v:t_dict
+        let vars = a:vars.__rest__
+        if has_key(a:vars, 'file')
+            let g:tlib#trace#printer = ['file', a:vars.file]
+        endif
+        if has_key(a:vars, 'echo')
+            let g:tlib#trace#printer = 'echom'
+        endif
+    else
+        let vars = a:vars
+        let opts = {}
+    endif
+    " TLogVAR vars
+    for rx in vars
+        let rx1 = substitute(rx, '^[+-]', '', 'g')
+        if rx1 !~# '^\%(error\|warn\|fatal\)$'
+            let erx1 = tlib#rx#Escape(rx1)
+            " TLogVAR rx, rx1
+            " echom "DBG" s:trace_rx
+            if rx =~ '^-'
+                let erx1 .= '\[0-\d\]\\?'
+                if s:trace_rx =~# '[(|]'. erx1 .'\\'
+                    let s:trace_rx = substitute(s:trace_rx, '\\|'. erx1, '', '')
+                endif
+                " elseif rx =~ '^+'
+            else
+                if erx1 =~ '\d$'
+                    let erx1 = substitute(erx1, '\d$', '[0-\0]\\?', '')
+                else
+                    let erx1 .= '[0-9]\?'
+                endif
+                if s:trace_rx !~# '[(|]'. erx1 .'\\'
+                    let s:trace_rx = substitute(s:trace_rx, '\ze\\)\$', '\\|'. escape(erx1, '\'), '')
+                endif
+                " else
+                "     echohl WarningMsg
+                "     echom 'tlib#trace#Print: Unsupported syntax:' rx
+                "     echohl NONE
+            endif
+            " echom "DBG" s:trace_rx
+        endif
+    endfor
+    echom "SetTrace:" s:trace_rx
+endf
+
+
+function! tlib#trace#Backtrace(caller) abort "{{{3
+    let caller = split(a:caller, '\.\.')
+    let start  = max([0, len(caller) - g:tlib#trace#backtrace - 1])
+    let caller = caller[start : -1]
+    return join(caller, '..')
+endf
+
+
+" Print the values of vars. The first value is a "guard" (see 
+" |:Tlibtrace|).
+function! tlib#trace#Print(caller, vars, values) abort "{{{3
+    " echom "DBG tlib#trace#Print" string(a:vars) string(a:values)
+    let msg = ['TRACE']
+    let guard = a:values[0]
+    if type(guard) == 0
+        let cond = guard
+    else
+        let cond = guard =~# s:trace_rx
+    endif
+    " TLogVAR guard, cond, a:vars, a:values
+    if cond
+        call add(msg, guard)
+        call add(msg, tlib#time#FormatNow() .':')
+        if g:tlib#trace#backtrace > 0
+            let bt = tlib#trace#Backtrace(a:caller)
+            if !empty(bt)
+                call add(msg, bt .':')
+            endif
+        endif
+        if len(a:vars) == len(a:values)
+            for i in range(1, len(a:vars) - 1)
+                let v = substitute(a:vars[i], ',$', '', '')
+                if type(a:values[i]) == v:t_func
+                    let r = string(a:values[i])
+                else
+                    let r = a:values[i]
+                endif
+                if v =~# '^\([''"]\).\{-}\1$'
+                    call add(msg, r .';')
+                else
+                    call add(msg, v .'='. string(r) .';')
+                endif
+                unlet r
+            endfor
+        else
+            call add(msg, join(a:values[1:-1]))
+        endif
+        if type(g:tlib#trace#printer) == v:t_string
+            let printer = g:tlib#trace#printer
+            let args = []
+        else
+            let [printer; args] = g:tlib#trace#printer
+        endif
+        call tlib#trace#Printer_{printer}(guard, join(msg), args)
+    endif
+endf
+
+
+function! tlib#trace#Reset() abort "{{{3
+    let s:trace_rx = '^\%(error\|fatal\|warn\|info\)$'
+    let g:tlib#trace#printer = 'echom'
+endf
+
+
+" Enable tracing via |:Tlibtrace|.
+function! tlib#trace#Enable() abort "{{{3
+    if !exists('s:trace_rx')
+        call tlib#trace#Reset()
+        " :nodoc:
+        command! -nargs=+ -bang Tlibtrace call tlib#trace#Print(expand('<sfile>'), [<f-args>], [<args>])
+    endif
+endf
+
+
+" Disable tracing via |:Tlibtrace|.
+function! tlib#trace#Disable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ -bang Tlibtrace :
+    unlet! s:trace_rx
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/type.vim

@@ -0,0 +1,142 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-09-30.
+" @Last Change: 2017-02-22.
+" @Revision:    57
+
+
+let g:tlib#type#nil = []
+
+
+" Enable type assertiona via |:Tlibtype|.
+function! tlib#type#Enable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ Tlibtype call tlib#type#Check(expand('<sfile>'), [<f-args>], [<args>])
+endf
+
+
+" Disable type assertiona via |:Tlibtype|.
+function! tlib#type#Disable() abort "{{{3
+    " :nodoc:
+    command! -nargs=+ Tlibtype :
+endf
+
+
+function! tlib#type#IsNil(expr) abort "{{{3
+    return tlib#type#Is(a:expr, v:t_none) || a:expr is g:tlib#type#nil
+endf
+
+
+function! tlib#type#IsNumber(expr)
+    return tlib#type#Is(a:expr, 0)
+endf
+
+
+function! tlib#type#IsString(expr)
+    return tlib#type#Is(a:expr, 1)
+endf
+
+
+function! tlib#type#IsFuncref(expr)
+    return tlib#type#Is(a:expr, 2)
+endf
+
+
+function! tlib#type#IsList(expr)
+    return tlib#type#Is(a:expr, 3)
+endf
+
+
+function! tlib#type#IsDictionary(expr)
+    return tlib#type#Is(a:expr, 4)
+endf
+
+
+function! tlib#type#Is(val, type) abort "{{{3
+    if has_key(s:schemas, a:type)
+        return tlib#type#Has(a:val, a:type)
+    else
+        if type(a:type) == 0
+            let type = a:type
+        elseif a:type =~? '^b\%[oolean]$'
+            let type = v:t_bool
+        elseif a:type =~? '^c\%[hannel]$'
+            let type = v:t_channel
+        elseif a:type =~? '^d\%[ictionary]$'
+            let type = v:t_dict
+        elseif a:type =~? '^fl\%[oat]$'
+            let type = v:t_float
+        elseif a:type =~? '^fu\%[ncref]$'
+            let type = v:t_func
+        elseif a:type =~? '^j\%[ob]$'
+            let type = v:t_job
+        elseif a:type =~? '^l\%[ist]$'
+            let type = v:t_list
+        elseif a:type =~? '^\%(nil\|null\|none\)$'
+            let type = v:t_none
+        elseif a:type =~? '^n\%[umber]$'
+            let type = v:t_number
+        elseif a:type =~? '^s\%[tring]$'
+            let type = v:t_string
+        else
+            throw 'tlib#type#Is: Unknown type: ' a:type
+        endif
+        Tlibtrace 'tlib', a:val, a:type, type, type(a:val), type(a:val) == a:type
+        return type(a:val) == type
+    endif
+endf
+
+
+function! tlib#type#Are(vals, type) abort "{{{3
+    return tlib#assert#Map(a:vals, 'tlib#type#Is(v:val,'. string(a:type) .')')
+endf
+
+
+let s:schemas = {}
+
+
+function! tlib#type#Define(name, schema) abort "{{{3
+    let s:schemas[a:name] = deepcopy(a:schema)
+endf
+
+
+function! tlib#type#Has(val, schema) abort "{{{3
+    Tlibtrace 'tlib', type(a:val), type(a:schema)
+    if !tlib#type#IsDictionary(a:val)
+        Tlibtrace 'tlib', 'not a dictionary', a:val
+        return 0
+    endif
+    if tlib#type#IsString(a:schema)
+        Tlibtrace 'tlib', a:schema
+        let schema = copy(s:schemas[a:schema])
+    else
+        let schema = copy(a:schema)
+    endif
+    if tlib#type#IsDictionary(schema)
+        return tlib#assert#All(map(schema, 'has_key(a:val, v:key) && tlib#type#Is(a:val[v:key], v:val)'))
+    else
+        Tlibtrace 'tlib', keys(a:val), schema
+        return tlib#assert#All(map(schema, 'has_key(a:val, v:val)'))
+    endif
+endf
+
+
+function! tlib#type#Have(vals, schema) abort "{{{3
+    return tlib#assert#Map(a:vals, 'tlib#type#Has(v:val,'. string(a:schema) .')')
+endf
+
+
+function! tlib#type#Check(caller, names, vals) abort "{{{3
+    Tlibtrace 'tlib', a:names, a:vals, len(a:names)
+    for i in range(0, len(a:names) - 1, 2)
+        let val = a:vals[i]
+        let type = a:vals[i + 1]
+        Tlibtrace 'tlib', i, val, type
+        if !tlib#type#Is(val, type)
+            let name = matchstr(a:names[i], '^''\zs.\{-}\ze'',\?$')
+            throw 'tlib#type#Check: Type mismatch: '. name .':'. a:vals[i + 1]
+        endif
+    endfor
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/url.vim

@@ -0,0 +1,52 @@
+" url.vim
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2007-06-30.
+" @Last Change: 2011-03-10.
+" @Revision:    0.0.28
+
+
+" TODO: These functions could use printf() now.
+
+" Decode an encoded URL.
+function! tlib#url#Decode(url) "{{{3
+    return substitute(a:url, '\(+\|%\(%\|\x\x\)\)', '\=tlib#url#DecodeChar(submatch(1))', 'g')
+endf
+
+
+" Decode a single character.
+function! tlib#url#DecodeChar(char) "{{{3
+    if a:char == '%%'
+        return '%'
+    elseif a:char == '+'
+        return ' '
+    else
+        return nr2char("0x".a:char[1 : -1])
+    endif
+endf
+
+
+" Encode a single character.
+function! tlib#url#EncodeChar(char) "{{{3
+    if a:char == '%'
+        return '%%'
+    elseif a:char == ' '
+        return '+'
+    else
+        return printf("%%%X", char2nr(a:char))
+    endif
+endf
+
+
+" Encode an URL.
+function! tlib#url#Encode(url, ...) "{{{3
+    TVarArg ['extrachars', '']
+    let rx = '\([^a-zA-Z0-9_.'. extrachars .'-]\)'
+    " TLogVAR a:url, rx
+    let rv = substitute(a:url, rx, '\=tlib#url#EncodeChar(submatch(1))', 'g')
+    " TLogVAR rv
+    return rv
+endf
+
+

sources_non_forked_fallback/tlib/autoload/tlib/var.vim

@@ -0,0 +1,90 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    34
+
+
+" Define a variable called NAME if yet undefined.
+" You can also use the :TLLet command.
+"
+" EXAMPLES: >
+"   exec tlib#var#Let('g:foo', 1)
+"   TLet g:foo = 1
+function! tlib#var#Let(name, val) "{{{3
+    return printf('if !exists(%s) | let %s = %s | endif', string(a:name), a:name, string(a:val))
+    " return printf('if !exists(%s) | let %s = %s | endif', string(a:name), a:name, a:val)
+endf
+
+
+" :def: function! tlib#var#EGet(var, namespace, ?default='')
+" Retrieve a variable by searching several namespaces.
+"
+" EXAMPLES: >
+"   let g:foo = 1
+"   let b:foo = 2
+"   let w:foo = 3
+"   echo eval(tlib#var#EGet('foo', 'vg'))  => 1
+"   echo eval(tlib#var#EGet('foo', 'bg'))  => 2
+"   echo eval(tlib#var#EGet('foo', 'wbg')) => 3
+function! tlib#var#EGet(var, namespace, ...) "{{{3
+    let pre  = []
+    let post = []
+    for namespace in split(a:namespace, '\zs')
+        let var = namespace .':'. a:var
+        call add(pre,  printf('exists("%s") ? %s : (', var, var))
+        call add(post, ')')
+    endfor
+    let default = a:0 >= 1 ? a:1 : ''
+    return join(pre) . string(default) . join(post)
+endf
+
+
+" :def: function! tlib#var#Get(var, namespace, ?default='')
+" Retrieve a variable by searching several namespaces.
+"
+" EXAMPLES: >
+"   let g:foo = 1
+"   let b:foo = 2
+"   let w:foo = 3
+"   echo tlib#var#Get('foo', 'bg')  => 1
+"   echo tlib#var#Get('foo', 'bg')  => 2
+"   echo tlib#var#Get('foo', 'wbg') => 3
+function! tlib#var#Get(var, namespace, ...) "{{{3
+    let var_ = substitute(a:var, '#', '_', 'g')
+    for namespace in split(a:namespace, '\zs')
+        let vname = namespace ==# 'g' ? a:var : var_
+        let var = namespace .':'. vname
+        if exists(var)
+            return {var}
+        elseif namespace ==# 'g'
+            try
+                let val = {var}
+            catch /^Vim\%((\a\+)\)\=:E\(121\|15\)/
+                continue
+            endtry
+            return val
+        endif
+    endfor
+    return a:0 >= 1 ? a:1 : ''
+endf
+
+
+" :def: function! tlib#var#List(rx, ?prefix='')
+" Get a list of variables matching rx.
+" EXAMPLE:
+"   echo tlib#var#List('tlib_', 'g:')
+function! tlib#var#List(rx, ...) "{{{3
+    TVarArg ['prefix', 'g:']
+    if v:version >= 704
+        exec 'let varlist = keys('. prefix .')'
+    else
+        redir => vars
+        silent! exec 'let '. prefix
+        redir END
+        let varlist = split(vars, '\n')
+        call map(varlist, 'matchstr(v:val, ''^\S\+'')')
+    endif
+    call filter(varlist, 'v:val =~ a:rx')
+    return varlist
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/vcs.vim

@@ -0,0 +1,230 @@
+" @Author:      Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2012-03-08.
+" @Last Change: 2017-04-10.
+" @Revision:    224
+
+scriptencoding utf-8
+
+
+" A dictionarie of supported VCS (currently: git, hg, svn, bzr).
+" :display: g:tlib#vcs#def                 {...}
+TLet g:tlib#vcs#def = {
+            \ 'git': {
+            \     'dir': '.git',
+            \     'ls': 'git ls-files --full-name',
+            \     'ls.postprocess': '*tlib#vcs#GitLsPostprocess',
+            \     'diff': 'git diff --no-ext-diff -U0 %s',
+            \     'status': 'git status -s',
+            \     'status.filterrx': '^\C[ MADRCU!?]\{2}\s'},
+            \ 'hg': {
+            \     'dir': '.hg',
+            \     'diff': 'hg diff -U0 %s',
+            \     'ls': 'hg manifest'},
+            \ 'svn': {
+            \     'dir': '.svn',
+            \     'diff': 'svn diff --diff-cmd diff --extensions -U0 %s'},
+            \ 'bzr': {
+            \     'dir': '.bzr',
+            \     'diff': 'bzr diff --diff-options=-U0 %s'}
+            \ }
+
+
+" A dictionary of custom executables for VCS commands. If the value is 
+" empty, support for that VCS will be removed. If no key is present, it 
+" is assumed that the VCS "type" is the name of the executable.
+" :display: g:tlib#vcs#executables         {...}
+TLet g:tlib#vcs#executables = {}
+
+
+" If non-empty, use it as a format string to check whether a VCS is 
+" installed on your computer.
+TLet g:tlib#vcs#check = has('win16') || has('win32') || has('win64') ? '%s.exe' : '%s'
+
+
+if !empty(g:tlib#vcs#check)
+    for [s:cmd, s:def] in items(g:tlib#vcs#def)
+        if !has_key(g:tlib#vcs#executables, s:cmd)
+            let s:cmd1 = printf(g:tlib#vcs#check, s:cmd)
+            let g:tlib#vcs#executables[s:cmd] = executable(s:cmd1) ? s:cmd1 : ''
+        endif
+    endfor
+    unlet! s:cmd s:def s:cmd1
+endif
+
+
+function! tlib#vcs#Executable(type) "{{{3
+    return get(g:tlib#vcs#executables, a:type, '')
+endf
+
+
+let s:vcs_cache = {}
+autocmd TLib FocusGained * let s:vcs_cache = {}
+
+
+function! tlib#vcs#FindVCS(filename) "{{{3
+    let type = ''
+    let dir  = ''
+    let filename = fnamemodify(a:filename, ':p')
+    let dirname = isdirectory(filename) ? filename : fnamemodify(filename, ':h')
+    if !has_key(s:vcs_cache, dirname)
+        let path = escape(dirname, ';') .';'
+        " TLogVAR filename, dirname, path
+        Tlibtrace 'tlib', filename, path
+        let depth = -1
+        for vcs in keys(g:tlib#vcs#def)
+            let subdir = g:tlib#vcs#def[vcs].dir
+            let vcsdir = finddir(subdir, path)
+            " TLogVAR vcs, subdir, vcsdir
+            Tlibtrace 'tlib', vcs, subdir, vcsdir
+            if !empty(vcsdir)
+                let vcsdir_depth = len(split(fnamemodify(vcsdir, ':p'), '\/'))
+                if vcsdir_depth > depth
+                    let depth = vcsdir_depth
+                    let type = vcs
+                    let dir = vcsdir
+                    " TLogVAR type, depth
+                endif
+            endif
+        endfor
+        Tlibtrace 'tlib', type, dir
+        " TLogVAR type, dir
+        if empty(type)
+            let s:vcs_cache[dirname] = ['', '']
+        else
+            let s:vcs_cache[dirname] = [type, dir]
+        endif
+    endif
+    return s:vcs_cache[dirname]
+endf
+
+
+function! s:GetCmd(vcstype, cmd)
+    let vcsdef = get(g:tlib#vcs#def, a:vcstype, {})
+    if has_key(vcsdef, a:cmd)
+        let cmd = vcsdef[a:cmd]
+        if cmd =~# '^\*'
+            let cmd = substitute(cmd, '^\*', '', '')
+        else
+            let bin = get(g:tlib#vcs#executables, a:vcstype, '')
+            if empty(bin)
+                let cmd = ''
+            elseif bin != a:vcstype
+                " let bin = escape(shellescape(bin), '\')
+                let bin = escape(bin, '\')
+                let cmd = substitute(cmd, '^.\{-}\zs'. escape(a:vcstype, '\'), bin, '')
+            endif
+        endif
+        return cmd
+    else
+        return ''
+    endif
+endf
+
+
+" :display: tlib#vcs#Ls(?filename=bufname('%'), ?vcs=[type, dir])
+" Return the files under VCS.
+function! tlib#vcs#Ls(...) "{{{3
+    if a:0 >= 2
+        let vcs = a:2
+    else
+        let vcs = tlib#vcs#FindVCS(a:0 >= 1 ? a:1 : bufname('%'))
+    endif
+    Tlibtrace 'tlib', vcs, a:000
+    " TLogVAR vcs
+    if !empty(vcs)
+        let [vcstype, vcsdir] = vcs
+        if has_key(g:tlib#vcs#def, vcstype)
+            let ls = s:GetCmd(vcstype, 'ls')
+            " TLogVAR ls
+            if !empty(ls)
+                let rootdir = fnamemodify(vcsdir, ':p:h:h')
+                " TLogVAR vcsdir, rootdir
+                if ls =~# '%s'
+                    let cmd = printf(ls, shellescape(rootdir))
+                else
+                    let cmd = ls
+                endif
+                " TLogVAR cmd, getcwd()
+                Tlibtrace 'tlib', getcwd(), vcstype, vcsdir, rootdir, cmd
+                let filess = tlib#sys#SystemInDir(rootdir, cmd)
+                " TLogVAR filess
+                let files = split(filess, '\n')
+                let postprocess = s:GetCmd(vcstype, 'ls.postprocess')
+                if !empty(postprocess)
+                    call map(files, 'call(postprocess, [v:val])')
+                endif
+                call map(files, 'join([rootdir, v:val], "/")')
+                " TLogVAR files
+                return files
+            endif
+        endif
+    endif
+    return []
+endf
+
+
+" :display: tlib#vcs#Diff(filename, ?vcs=[type, dir])
+" Return the diff for "filename"
+function! tlib#vcs#Diff(filename, ...) "{{{3
+    let vcs = a:0 >= 1 ? a:1 : tlib#vcs#FindVCS(a:filename)
+    if !empty(vcs)
+        let [vcstype, vcsdir] = vcs
+        let diff = s:GetCmd(vcstype, 'diff')
+        if !empty(diff)
+            let cmd = printf(diff, shellescape(fnamemodify(a:filename, ':p')))
+            let patch = system(cmd)
+            return patch
+        endif
+    endif
+    return []
+endf
+
+
+function! tlib#vcs#GitLsPostprocess(filename) abort "{{{3
+    if a:filename =~# '^".\{-}"$'
+        let filename = matchstr(a:filename, '^"\zs.\{-}\ze"$')
+        let filename = substitute(filename, '\%(\\\@<!\\\(\d\d\d\)\)\+', '\=eval(''"''. submatch(0) .''"'')', 'g')
+        " let filename = eval(a:filename)
+        " TLogVAR a:filename, filename, &enc
+        return filename
+    else
+        return a:filename
+    endif
+endf
+
+
+function! tlib#vcs#Status(...) abort "{{{3
+    let filename = a:0 >= 1 ? a:1 : '%'
+    let vcs = a:0 >= 2 ? a:2 : tlib#vcs#FindVCS(filename)
+    if !empty(vcs)
+        let [vcstype, vcsdir] = vcs
+        let cstatus = s:GetCmd(vcstype, 'status')
+        if !empty(cstatus)
+            let status = exists('*systemlist') ? systemlist(cstatus) : split(system(cstatus), '\n')
+            let sfilter = s:GetCmd(vcstype, 'status.filterrx')
+            if !empty(sfilter)
+                let status = filter(status, 'v:val =~# sfilter')
+            endif
+            return status
+        endif
+    endif
+endf
+
+
+function! tlib#vcs#IsDirty(...) abort "{{{3
+    let filename = a:0 >= 1 ? a:1 : '%'
+    let vcs = a:0 >= 2 ? a:2 : tlib#vcs#FindVCS(filename)
+    let status = tlib#vcs#Status(filename, vcs)
+    return empty(status) ? '' : vcs[0] .'!'
+endf
+
+
+" function! tlib#vcs#EnableTStatus() abort "{{{3
+"     if has('vim_starting')
+"         autocmd VimEnter * TStatusregister1 --event=FocusGained,BufRead,BufWritePost %s tlib#vcs#IsDirty()
+"     else
+"         TStatusregister1 --event=FocusGained,BufRead,BufWritePost %s tlib#vcs#IsDirty()
+"     endif
+" endf
+

sources_non_forked_fallback/tlib/autoload/tlib/vim.vim

@@ -0,0 +1,152 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @GIT:         http://github.com/tomtom/tlib_vim/
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created:     2010-07-19.
+" @Last Change: 2012-06-08.
+" @Revision:    37
+
+
+let s:restoreframecmd = ''
+let s:fullscreen = 0
+
+if has('win16') || has('win32') || has('win64')
+
+    if !exists('g:tlib#vim#simalt_maximize')
+        " The alt-key for maximizing the window.
+        " CAUTION: The value of this paramter depends on your locale and 
+        " maybe the windows version you are running.
+        let g:tlib#vim#simalt_maximize = 'x'   "{{{2
+    endif
+
+    if !exists('g:tlib#vim#simalt_restore')
+        " The alt-key for restoring the window.
+        " CAUTION: The value of this paramter depends on your locale and 
+        " maybe the windows version you are running.
+        let g:tlib#vim#simalt_restore = 'r'   "{{{2
+    endif
+
+    if !exists('g:tlib#vim#use_vimtweak')
+        " If true, use the vimtweak.dll for windows. This will enable 
+        " tlib to remove the caption for fullscreen windows.
+        let g:tlib#vim#use_vimtweak = 0   "{{{2
+    endif
+
+    " Maximize the window.
+    " You might need to redefine |g:tlib#vim#simalt_maximize| if it doesn't 
+    " work for you.
+    fun! tlib#vim#Maximize(fullscreen) "{{{3
+        if !has("gui_running")
+            return
+        endif
+        call s:SaveFrameParams()
+        let s:fullscreen = a:fullscreen
+        if g:tlib#vim#use_vimtweak && a:fullscreen
+            call libcallnr("vimtweak.dll", "EnableCaption", 0)
+        endif
+        exec 'simalt ~'. g:tlib#vim#simalt_maximize
+    endf
+
+    " Restore the original vimsize after having called |tlib#vim#Maximize()|.
+    function! tlib#vim#RestoreWindow() "{{{3
+        if !has("gui_running")
+            return
+        endif
+        if g:tlib#vim#use_vimtweak
+            call libcallnr("vimtweak.dll", "EnableCaption", 1)
+        endif
+        exec 'simalt ~'. g:tlib#vim#simalt_restore
+        call s:RestoreFrameParams()
+    endf
+
+else
+
+    if !exists('g:tlib#vim#use_wmctrl')
+        " If true, use wmctrl for X windows to make a window 
+        " maximized/fullscreen.
+        "
+        " This is the preferred method for maximizing windows under X 
+        " windows. Some window managers have problem coping with the 
+        " default method of setting 'lines' and 'columns' to a large 
+        " value.
+        let g:tlib#vim#use_wmctrl = executable('wmctrl')  "{{{2
+    endif
+
+    " :nodoc:
+    fun! tlib#vim#Maximize(fullscreen) "{{{3
+        if !has("gui_running")
+            return
+        endif
+        call s:SaveFrameParams()
+        let s:fullscreen = a:fullscreen
+        if g:tlib#vim#use_wmctrl
+            if a:fullscreen
+                silent !wmctrl -r :ACTIVE: -b add,fullscreen
+            else
+                silent !wmctrl -r :ACTIVE: -b add,maximized_vert,maximized_horz
+            endif
+        else
+            set lines=1000 columns=1000 
+        endif
+    endf
+
+    " :nodoc:
+    function! tlib#vim#RestoreWindow() "{{{3
+        if !has("gui_running")
+            return
+        endif
+        if g:tlib#vim#use_wmctrl
+            if s:fullscreen
+                silent !wmctrl -r :ACTIVE: -b remove,fullscreen
+            else
+                silent !wmctrl -r :ACTIVE: -b remove,maximized_vert,maximized_horz
+            endif
+        endif
+        call s:RestoreFrameParams()
+    endf
+
+endif
+
+
+function! s:SaveFrameParams() "{{{3
+    let s:restoreframecmd = printf("set lines=%d columns=%d | winpos %d %d", &lines, &columns, getwinposx(), getwinposy())
+endf
+
+
+function! s:RestoreFrameParams() "{{{3
+    if !empty(s:restoreframecmd)
+        exec s:restoreframecmd
+        let s:restoreframecmd = ''
+    endif
+endf
+
+
+" :display: tlib#vim##CopyFunction(old, new, overwrite=0)
+function! tlib#vim#CopyFunction(old, new, ...) "{{{3
+    let overwrite = a:0 >= 1 ? a:1 : 0
+    redir => oldfn
+    exec 'silent function' a:old
+    redir END
+    if exists('*'. a:new)
+        if overwrite > 0
+            exec 'delfunction' a:new
+        elseif overwrite < 0
+            throw 'tlib#vim##CopyFunction: Function already exists: '. a:old .' -> '. a:new
+        else
+            return
+        endif
+    endif
+    let fn = split(oldfn, '\n')
+    let fn = map(fn, 'substitute(v:val, ''^\d\+'', "", "")')
+    let fn[0] = substitute(fn[0], '\V\^\s\*fu\%[nction]!\?\s\+\zs'. a:old, a:new, '')
+    let t = @t
+    try
+        let @t = join(fn, "\n")
+        redir => out
+        @t
+        redir END
+    finally
+        let @t = t
+    endtry
+endf
+

sources_non_forked_fallback/tlib/autoload/tlib/win.vim

@@ -0,0 +1,201 @@
+" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
+" @Website:     http://www.vim.org/account/profile.php?user_id=4037
+" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Revision:    84
+
+
+if !exists('g:tlib#win#use_winid')
+    let g:tlib#win#use_winid = exists('*win_gotoid') && exists('*win_getid')   "{{{2
+endif
+
+
+" Return vim code to jump back to the original window.
+function! tlib#win#Set(winnr) "{{{3
+    if a:winnr > 0
+        " TLogVAR a:winnr
+        " TLogDBG winnr()
+        " TLogDBG string(tlib#win#List())
+        if winnr() != a:winnr && winbufnr(a:winnr) != -1
+            let rv = winnr().'wincmd w'
+            exec a:winnr .'wincmd w'
+            " TLogVAR rv
+            " TLogDBG string(tlib#win#List())
+            return rv
+        endif
+    endif
+    return ''
+endf
+
+
+if g:tlib#win#use_winid
+    let g:tlib#win#null_id = -1
+    function! tlib#win#GetID() abort "{{{3
+        return win_getid()
+    endf
+    function! tlib#win#GotoID(win_id) abort "{{{3
+        call win_gotoid(a:win_id)
+    endf
+else
+    let s:win_id = 0
+    let g:tlib#win#null_id = {}
+    function! tlib#win#GetID() abort "{{{3
+        if !exists('w:tlib_win_id')
+            let s:win_id += 1
+            let w:tlib_win_id = s:win_id
+        endif
+        return {'tabpagenr': tabpagenr(), 'bufnr': bufnr('%'), 'winnr': winnr(), 'win_id': w:tlib_win_id}
+    endf
+    function! tlib#win#GotoID(win_id) abort "{{{3
+        Tlibtrace 'tlib', a:win_id
+        if tabpagenr() != a:win_id.tabpagenr
+            exec 'tabnext' a:win_id.tabpagenr
+        endif
+        for wnr in range(1, winnr('$'))
+            let win_id = getwinvar(wnr, 'tlib_win_id', -1)
+            Tlibtrace 'tlib', wnr, win_id
+            if win_id == a:win_id.win_id
+                Tlibtrace 'tlib', wnr
+                exec wnr 'wincmd w'
+                return
+            endif
+        endfor
+        " Was the window closed? What should we do now?
+        if winnr() != a:win_id.winnr
+            exec a:win_id.winnr 'wincmd w'
+        endif
+        if bufnr('%') != a:win_id.bufnr
+            exec 'hide buffer' a:win_id.bufnr
+        endif
+    endf
+endif
+
+
+" Return vim code to jump back to the original window.
+function! tlib#win#SetById(win_id) "{{{3
+    if a:win_id != g:tlib#win#null_id
+        if g:tlib#win#use_winid
+            let win_id = tlib#win#GetID()
+        else
+            let win_id = tlib#win#GetID().win_id
+        endif
+        call tlib#win#GotoID(a:win_id)
+        return printf('call tlib#win#GotoID(%s)', win_id)
+        " " TLogVAR a:winnr
+        " " TLogDBG winnr()
+        " " TLogDBG string(tlib#win#List())
+        " if winnr() != a:winnr && winbufnr(a:winnr) != -1
+        "     let rv = winnr().'wincmd w'
+        "     exec a:winnr .'wincmd w'
+        "     " TLogVAR rv
+        "     " TLogDBG string(tlib#win#List())
+        "     return rv
+        " endif
+    endif
+    return ''
+endf
+ 
+
+" :def: function! tlib#win#GetLayout(?save_view=0)
+function! tlib#win#GetLayout(...) "{{{3
+    TVarArg ['save_view', 0]
+    let views = {}
+    if save_view
+        let winnr = winnr()
+        windo let views[winnr()] = winsaveview()
+        " for w in range(1, winnr('$'))
+        "     call tlib#win#Set(w)
+        "     let views[w] = winsaveview()
+        " endfor
+        call tlib#win#Set(winnr)
+    endif
+    return {'winnr': winnr('$'), 'winrestcmd': winrestcmd(), 'views': views, 'cmdheight': &cmdheight, 'guioptions': &guioptions, 'tabpagenr': tabpagenr()}
+endf
+
+
+function! tlib#win#SetLayout(layout) "{{{3
+    if a:layout.tabpagenr == tabpagenr() && a:layout.winnr == winnr('$')
+        " TLogVAR a:layout.winrestcmd
+        " TLogDBG string(tlib#win#List())
+        exec a:layout.winrestcmd
+        if !empty(a:layout.views)
+            let winnr = winnr()
+            " TLogVAR winnr
+            for [w, v] in items(a:layout.views)
+                " TLogVAR w, v
+                call tlib#win#Set(w)
+                call winrestview(v)
+            endfor
+            call tlib#win#Set(winnr)
+        endif
+        if a:layout.cmdheight != &cmdheight
+            let &cmdheight = a:layout.cmdheight
+        endif
+        " TLogDBG string(tlib#win#List())
+        return 1
+    endif
+    return 0
+endf
+
+
+function! tlib#win#List() "{{{3
+    let wl = {}
+    for wn in range(1, winnr('$'))
+        let wl[wn] = bufname(winbufnr(wn))
+    endfor
+    return wl
+endf
+
+
+" " :def: function! tlib#win#GetLayout1(?save_view=0)
+" " Contrary to |tlib#win#GetLayout|, this version doesn't use 
+" " |winrestcmd()|. It can also save windows views.
+" function! tlib#win#GetLayout1(...) "{{{3
+"     TVarArg ['save_view', 0]
+"     let winnr = winnr()
+"     let acc = {}
+"     for w in range(1, winnr('$'))
+"         let def = {'h': winheight(w), 'w': winwidth(w)}
+"         if save_view
+"             call tlib#win#Set(w)
+"             let def.view = winsaveview()
+"         endif
+"         let acc[w] = def
+"     endfor
+"     call tlib#win#Set(winnr)
+"     return acc
+" endf
+" 
+" 
+" " Reset layout from the value of |tlib#win#GetLayout1|.
+" function! tlib#win#SetLayout1(layout) "{{{3
+"     if len(a:layout) != winnr('$')
+"         return 0
+"     endif
+"     let winnr = winnr()
+"     for [w, def] in items(a:layout)
+"         if tlib#win#Set(w)
+"             exec 'resize '. def.h
+"             exec 'vertical resize '. def.w
+"             if has_key(def, 'view')
+"                 call winrestview(def.view)
+"             endif
+"         else
+"             break
+"         endif
+"     endfor
+"     call tlib#win#Set(winnr)
+"     return 1
+" endf
+
+
+function! tlib#win#Width(wnr) "{{{3
+    return winwidth(a:wnr) - &fdc
+endf
+
+
+function! tlib#win#WinDo(ex) "{{{3
+    let w = winnr()
+    exec 'windo '. a:ex
+    exec w .'wincmd w'
+endf
+