if exists('g:loaded_plug')

finish

let g:loaded_plug = 1

let s:cpo_save = &cpo

set cpo&vim

let s:plug_src = 'https://github.com/junegunn/vim-plug.git'

let s:plug_tab = get(s:, 'plug_tab', -1)

let s:plug_buf = get(s:, 'plug_buf', -1)

let s:mac_gui = has('gui_macvim') && has('gui_running')

let s:is_win = has('win32') || has('win64')

let s:nvim = has('nvim') && exists('*jobwait') && !s:is_win

let s:vim8 = has('patch-8.0.0039') && exists('*job_start')

let s:me = resolve(expand('<sfile>:p'))

let s:base_spec = { 'branch': 'master', 'frozen': 0 }

let s:TYPE = {

\ 'string': type(''),

\ 'list': type([]),

\ 'dict': type({}),

\ 'funcref': type(function('call'))

\ }

let s:loaded = get(s:, 'loaded', {})

let s:triggers = get(s:, 'triggers', {})

function! plug#begin(...)

if a:0 > 0

let s:plug_home_org = a:1

let home = s:path(fnamemodify(expand(a:1), ':p'))

elseif exists('g:plug_home')

let home = s:path(g:plug_home)

elseif !empty(&rtp)

let home = s:path(split(&rtp, ',')[0]) . '/plugged'

else

return s:err('Unable to determine plug home. Try calling plug#begin() with a path argument.')

endif

let g:plug_home = home

let g:plugs = {}

let g:plugs_order = []

let s:triggers = {}

call s:define_commands()

return 1

function! s:define_commands()

command! -nargs=+ -bar Plug call plug#(<args>)

if !executable('git')

return s:err('`git` executable not found. Most commands will not be available. To suppress this message, prepend `silent!` to `call plug#begin(...)`.')

endif

command! -nargs=* -bar -bang -complete=customlist,s:names PlugInstall call s:install(<bang>0, [<f-args>])

command! -nargs=* -bar -bang -complete=customlist,s:names PlugUpdate call s:update(<bang>0, [<f-args>])

command! -nargs=0 -bar -bang PlugClean call s:clean(<bang>0)

command! -nargs=0 -bar PlugUpgrade if s:upgrade() | execute 'source' s:esc(s:me) | endif

command! -nargs=0 -bar PlugStatus call s:status()

command! -nargs=0 -bar PlugDiff call s:diff()

command! -nargs=? -bar -bang -complete=file PlugSnapshot call s:snapshot(<bang>0, <f-args>)

function! s:to_a(v)

return type(a:v) == s:TYPE.list ? a:v : [a:v]

function! s:to_s(v)

return type(a:v) == s:TYPE.string ? a:v : join(a:v, "\n") . "\n"

function! s:glob(from, pattern)

return s:lines(globpath(a:from, a:pattern))

function! s:source(from, ...)

let found = 0

for pattern in a:000

for vim in s:glob(a:from, pattern)

execute 'source' s:esc(vim)

let found = 1

endfor

endfor

return found

function! s:assoc(dict, key, val)

let a:dict[a:key] = add(get(a:dict, a:key, []), a:val)

function! s:ask(message, ...)

call inputsave()

echohl WarningMsg

let answer = input(a:message.(a:0 ? ' (y/N/a) ' : ' (y/N) '))

echohl None

call inputrestore()

echo "\r"

return (a:0 && answer =~? '^a') ? 2 : (answer =~? '^y') ? 1 : 0

function! s:ask_no_interrupt(...)

try

return call('s:ask', a:000)

catch

return 0

endtry

function! plug#end()

if !exists('g:plugs')

return s:err('Call plug#begin() first')

endif

if exists('#PlugLOD')

augroup PlugLOD

autocmd!

augroup END

augroup! PlugLOD

endif

let lod = { 'ft': {}, 'map': {}, 'cmd': {} }

filetype off

for name in g:plugs_order

if !has_key(g:plugs, name)

continue

endif

let plug = g:plugs[name]

if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for')

let s:loaded[name] = 1

continue

endif

if has_key(plug, 'on')

let s:triggers[name] = { 'map': [], 'cmd': [] }

for cmd in s:to_a(plug.on)

if cmd =~? '^<Plug>.\+'

if empty(mapcheck(cmd)) && empty(mapcheck(cmd, 'i'))

call s:assoc(lod.map, cmd, name)

endif

call add(s:triggers[name].map, cmd)

elseif cmd =~# '^[A-Z]'

if exists(':'.cmd) != 2

call s:assoc(lod.cmd, cmd, name)

endif

call add(s:triggers[name].cmd, cmd)

else

call s:err('Invalid `on` option: '.cmd.

\ '. Should start with an uppercase letter or `<Plug>`.')

endif

endfor

endif

if has_key(plug, 'for')

let types = s:to_a(plug.for)

if !empty(types)

augroup filetypedetect

call s:source(s:rtp(plug), 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim')

augroup END

endif

for type in types

call s:assoc(lod.ft, type, name)

endfor

endif

endfor

for [cmd, names] in items(lod.cmd)

execute printf(

\ 'command! -nargs=* -range -bang %s call s:lod_cmd(%s, "<bang>", <line1>, <line2>, <q-args>, %s)',

\ cmd, string(cmd), string(names))

endfor

for [map, names] in items(lod.map)

for [mode, map_prefix, key_prefix] in

\ [['i', '<C-O>', ''], ['n', '', ''], ['v', '', 'gv'], ['o', '', '']]

execute printf(

\ '%snoremap <silent> %s %s:<C-U>call <SID>lod_map(%s, %s, "%s")<CR>',

\ mode, map, map_prefix, string(map), string(names), key_prefix)

endfor

endfor

for [ft, names] in items(lod.ft)

augroup PlugLOD

execute printf('autocmd FileType %s call <SID>lod_ft(%s, %s)',

\ ft, string(ft), string(names))

augroup END

endfor

call s:reorg_rtp()

filetype plugin indent on

if has('vim_starting')

if has('syntax') && !exists('g:syntax_on')

syntax enable

end

else

call s:reload_plugins()

endif

function! s:loaded_names()

return filter(copy(g:plugs_order), 'get(s:loaded, v:val, 0)')

function! s:load_plugin(spec)

call s:source(s:rtp(a:spec), 'plugin/**/*.vim', 'after/plugin/**/*.vim')

function! s:reload_plugins()

for name in s:loaded_names()

call s:load_plugin(g:plugs[name])

endfor

function! s:trim(str)

return substitute(a:str, '[\/]\+$', '', '')

function! s:version_requirement(val, min)

for idx in range(0, len(a:min) - 1)

let v = get(a:val, idx, 0)

if v < a:min[idx] | return 0

elseif v > a:min[idx] | return 1

endif

endfor

return 1

function! s:git_version_requirement(...)

if !exists('s:git_version')

let s:git_version = map(split(split(s:system('git --version'))[-1], '\.'), 'str2nr(v:val)')

endif

return s:version_requirement(s:git_version, a:000)

function! s:progress_opt(base)

return a:base && !s:is_win &&

\ s:git_version_requirement(1, 7, 1) ? '--progress' : ''

if s:is_win

function! s:rtp(spec)

return s:path(a:spec.dir . get(a:spec, 'rtp', ''))

endfunction

function! s:path(path)

return s:trim(substitute(a:path, '/', '\', 'g'))

endfunction

function! s:dirpath(path)

return s:path(a:path) . '\'

endfunction

function! s:is_local_plug(repo)

return a:repo =~? '^[a-z]:\|^[%~]'

endfunction

function! s:rtp(spec)

return s:dirpath(a:spec.dir . get(a:spec, 'rtp', ''))

endfunction

function! s:path(path)

return s:trim(a:path)

endfunction

function! s:dirpath(path)

return substitute(a:path, '[/\\]*$', '/', '')

endfunction

function! s:is_local_plug(repo)

return a:repo[0] =~ '[/$~]'

endfunction

function! s:err(msg)

echohl ErrorMsg

echom '[vim-plug] '.a:msg

echohl None

function! s:warn(cmd, msg)

echohl WarningMsg

execute a:cmd 'a:msg'

echohl None

function! s:esc(path)

return escape(a:path, ' ')

function! s:escrtp(path)

return escape(a:path, ' ,')

function! s:remove_rtp()

for name in s:loaded_names()

let rtp = s:rtp(g:plugs[name])

execute 'set rtp-='.s:escrtp(rtp)

let after = globpath(rtp, 'after')

if isdirectory(after)

execute 'set rtp-='.s:escrtp(after)

endif

endfor

function! s:reorg_rtp()

if !empty(s:first_rtp)

execute 'set rtp-='.s:first_rtp

execute 'set rtp-='.s:last_rtp

endif

if exists('s:prtp') && s:prtp !=# &rtp

call s:remove_rtp()

unlet! s:middle

endif

let s:middle = get(s:, 'middle', &rtp)

let rtps = map(s:loaded_names(), 's:rtp(g:plugs[v:val])')

let afters = filter(map(copy(rtps), 'globpath(v:val, "after")'), 'isdirectory(v:val)')

let rtp = join(map(rtps, 'escape(v:val, ",")'), ',')

\ . ','.s:middle.','

\ . join(map(afters, 'escape(v:val, ",")'), ',')

let &rtp = substitute(substitute(rtp, ',,*', ',', 'g'), '^,\|,$', '', 'g')

let s:prtp = &rtp

if !empty(s:first_rtp)

execute 'set rtp^='.s:first_rtp

execute 'set rtp+='.s:last_rtp

endif

function! s:doautocmd(...)

if exists('#'.join(a:000, '#'))

execute 'doautocmd' ((v:version > 703 || has('patch442')) ? '<nomodeline>' : '') join(a:000)

endif

function! s:dobufread(names)

for name in a:names

let path = s:rtp(g:plugs[name]).'/**'

for dir in ['ftdetect', 'ftplugin']

if len(finddir(dir, path))

return s:doautocmd('BufRead')

endif

endfor

endfor

function! plug#load(...)

if a:0 == 0

return s:err('Argument missing: plugin name(s) required')

endif

if !exists('g:plugs')

return s:err('plug#begin was not called')

endif

let unknowns = filter(copy(a:000), '!has_key(g:plugs, v:val)')

if !empty(unknowns)

let s = len(unknowns) > 1 ? 's' : ''

return s:err(printf('Unknown plugin%s: %s', s, join(unknowns, ', ')))

end

for name in a:000

call s:lod([name], ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])

endfor

call s:dobufread(a:000)

return 1

function! s:remove_triggers(name)

if !has_key(s:triggers, a:name)

return

endif

for cmd in s:triggers[a:name].cmd

execute 'silent! delc' cmd

endfor

for map in s:triggers[a:name].map

execute 'silent! unmap' map

execute 'silent! iunmap' map

endfor

call remove(s:triggers, a:name)

function! s:lod(names, types, ...)

for name in a:names

call s:remove_triggers(name)

let s:loaded[name] = 1

endfor

call s:reorg_rtp()

for name in a:names

let rtp = s:rtp(g:plugs[name])

for dir in a:types

call s:source(rtp, dir.'/**/*.vim')

endfor

if a:0

if !s:source(rtp, a:1) && !empty(s:glob(rtp, a:2))

execute 'runtime' a:1

endif

call s:source(rtp, a:2)

endif

call s:doautocmd('User', name)

endfor

function! s:lod_ft(pat, names)

let syn = 'syntax/'.a:pat.'.vim'

call s:lod(a:names, ['plugin', 'after/plugin'], syn, 'after/'.syn)

execute 'autocmd! PlugLOD FileType' a:pat

call s:doautocmd('filetypeplugin', 'FileType')

call s:doautocmd('filetypeindent', 'FileType')

function! s:lod_cmd(cmd, bang, l1, l2, args, names)

call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])

call s:dobufread(a:names)

execute printf('%s%s%s %s', (a:l1 == a:l2 ? '' : (a:l1.','.a:l2)), a:cmd, a:bang, a:args)

function! s:lod_map(map, names, prefix)

call s:lod(a:names, ['ftdetect', 'after/ftdetect', 'plugin', 'after/plugin'])

call s:dobufread(a:names)

let extra = ''

while 1

let c = getchar(0)

if c == 0

break

endif

let extra .= nr2char(c)

endwhile

let prefix = v:count ? v:count : ''

let prefix .= '"'.v:register.a:prefix

if mode(1) == 'no'

if v:operator == 'c'

let prefix = "\<esc>" . prefix

endif

let prefix .= v:operator

endif

call feedkeys(prefix, 'n')

call feedkeys(substitute(a:map, '^<Plug>', "\<Plug>", '') . extra)

function! plug#(repo, ...)

if a:0 > 1

return s:err('Invalid number of arguments (1..2)')

endif

try

let repo = s:trim(a:repo)

let opts = a:0 == 1 ? s:parse_options(a:1) : s:base_spec

let name = get(opts, 'as', fnamemodify(repo, ':t:s?\.git$??'))

let spec = extend(s:infer_properties(name, repo), opts)

if !has_key(g:plugs, name)

call add(g:plugs_order, name)

endif

let g:plugs[name] = spec

let s:loaded[name] = get(s:loaded, name, 0)

catch

return s:err(v:exception)

endtry

function! s:parse_options(arg)

let opts = copy(s:base_spec)

let type = type(a:arg)

if type == s:TYPE.string

let opts.tag = a:arg

elseif type == s:TYPE.dict

call extend(opts, a:arg)

if has_key(opts, 'dir')

let opts.dir = s:dirpath(expand(opts.dir))

endif

else

throw 'Invalid argument type (expected: string or dictionary)'

endif

return opts

function! s:infer_properties(name, repo)

let repo = a:repo

if s:is_local_plug(repo)

return { 'dir': s:dirpath(expand(repo)) }

else

if repo =~ ':'

let uri = repo

else

if repo !~ '/'

let repo = 'vim-scripts/'. repo

endif

let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git')

let uri = printf(fmt, repo)

endif

let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') )

return { 'dir': dir, 'uri': uri }

endif

function! s:install(force, names)

call s:update_impl(0, a:force, a:names)

function! s:update(force, names)

call s:update_impl(1, a:force, a:names)

function! plug#helptags()

if !exists('g:plugs')

return s:err('plug#begin was not called')

endif

for spec in values(g:plugs)

let docd = join([spec.dir, 'doc'], '/')

if isdirectory(docd)

silent! execute 'helptags' s:esc(docd)

endif

endfor

return 1

function! s:syntax()

syntax clear

syntax region plug1 start=/\%1l/ end=/\%2l/ contains=plugNumber

syntax region plug2 start=/\%2l/ end=/\%3l/ contains=plugBracket,plugX

syn match plugNumber /[0-9]\+[0-9.]*/ contained

syn match plugBracket /[[\]]/ contained

syn match plugX /x/ contained

syn match plugDash /^-/

syn match plugPlus /^+/

syn match plugStar /^*/

syn match plugMessage /\(^- \)\@<=.*/

syn match plugName /\(^- \)\@<=[^ ]*:/

syn match plugSha /\%(: \)\@<=[0-9a-f]\{4,}$/

syn match plugTag /(tag: [^)]\+)/

syn match plugInstall /\(^+ \)\@<=[^:]*/

syn match plugUpdate /\(^* \)\@<=[^:]*/

syn match plugCommit /^ \X*[0-9a-f]\{7} .*/ contains=plugRelDate,plugEdge,plugTag

syn match plugEdge /^ \X\+$/

syn match plugEdge /^ \X*/ contained nextgroup=plugSha

syn match plugSha /[0-9a-f]\{7}/ contained

syn match plugRelDate /([^)]*)$/ contained

syn match plugNotLoaded /(not loaded)$/

syn match plugError /^x.*/

syn region plugDeleted start=/^\~ .*/ end=/^\ze\S/

syn match plugH2 /^.*:\n-\+$/

syn keyword Function PlugInstall PlugStatus PlugUpdate PlugClean

hi def link plug1 Title

hi def link plug2 Repeat

hi def link plugH2 Type

hi def link plugX Exception

hi def link plugBracket Structure

hi def link plugNumber Number

hi def link plugDash Special

hi def link plugPlus Constant

hi def link plugStar Boolean

hi def link plugMessage Function

hi def link plugName Label

hi def link plugInstall Function

hi def link plugUpdate Type

hi def link plugError Error

hi def link plugDeleted Ignore

hi def link plugRelDate Comment

hi def link plugEdge PreProc

hi def link plugSha Identifier

hi def link plugTag Constant

hi def link plugNotLoaded Comment

function! s:lpad(str, len)

return a:str . repeat(' ', a:len - len(a:str))

function! s:lines(msg)

return split(a:msg, "[\r\n]")

function! s:lastline(msg)

return get(s:lines(a:msg), -1, '')

function! s:new_window()

execute get(g:, 'plug_window', 'vertical topleft new')

function! s:plug_window_exists()

let buflist = tabpagebuflist(s:plug_tab)

return !empty(buflist) && index(buflist, s:plug_buf) >= 0

function! s:switch_in()

if !s:plug_window_exists()

return 0

endif

if winbufnr(0) != s:plug_buf

let s:pos = [tabpagenr(), winnr(), winsaveview()]

execute 'normal!' s:plug_tab.'gt'

let winnr = bufwinnr(s:plug_buf)

execute winnr.'wincmd w'

call add(s:pos, winsaveview())

else

let s:pos = [winsaveview()]

endif

setlocal modifiable

return 1

function! s:switch_out(...)

call winrestview(s:pos[-1])

setlocal nomodifiable

if a:0 > 0

execute a:1

endif

if len(s:pos) > 1

execute 'normal!' s:pos[0].'gt'

execute s:pos[1] 'wincmd w'

call winrestview(s:pos[2])

endif

function! s:finish_bindings()

nnoremap <silent> <buffer> R :call <SID>retry()<cr>

nnoremap <silent> <buffer> D :PlugDiff<cr>

nnoremap <silent> <buffer> S :PlugStatus<cr>

nnoremap <silent> <buffer> U :call <SID>status_update()<cr>

xnoremap <silent> <buffer> U :call <SID>status_update()<cr>

nnoremap <silent> <buffer> ]] :silent! call <SID>section('')<cr>

nnoremap <silent> <buffer> [[ :silent! call <SID>section('b')<cr>

function! s:prepare(...)

if empty(getcwd())

throw 'Invalid current working directory. Cannot proceed.'

endif

for evar in ['$GIT_DIR', '$GIT_WORK_TREE']

if exists(evar)

throw evar.' detected. Cannot proceed.'

endif

endfor

call s:job_abort()

if s:switch_in()

if b:plug_preview == 1

pc

endif

enew

else

call s:new_window()

endif

nnoremap <silent> <buffer> q :if b:plug_preview==1<bar>pc<bar>endif<bar>bd<cr>

if a:0 == 0

call s:finish_bindings()

endif

let b:plug_preview = -1

let s:plug_tab = tabpagenr()

let s:plug_buf = winbufnr(0)

call s:assign_name()

for k in ['<cr>', 'L', 'o', 'X', 'd', 'dd']

execute 'silent! unmap <buffer>' k

endfor

setlocal buftype=nofile bufhidden=wipe nobuflisted noswapfile nowrap cursorline modifiable

setf vim-plug

if exists('g:syntax_on')

call s:syntax()

endif

function! s:assign_name()

let prefix = '[Plugins]'

let name = prefix

let idx = 2

while bufexists(name)

let name = printf('%s (%s)', prefix, idx)

let idx = idx + 1

endwhile

silent! execute 'f' fnameescape(name)

function! s:chsh(swap)

let prev = [&shell, &shellredir]

if !s:is_win && a:swap

set shell=sh shellredir=>%s\ 2>&1

endif

return prev

function! s:bang(cmd, ...)

try

let [sh, shrd] = s:chsh(a:0)

let cmd = a:0 ? s:with_cd(a:cmd, a:1) : a:cmd

let g:_plug_bang = '!'.escape(cmd, '#!%')

execute "normal! :execute g:_plug_bang\<cr>\<cr>"

finally

unlet g:_plug_bang

let [&shell, &shellredir] = [sh, shrd]

endtry

return v:shell_error ? 'Exit status: ' . v:shell_error : ''

function! s:regress_bar()

let bar = substitute(getline(2)[1:-2], '.*\zs=', 'x', '')

call s:progress_bar(2, bar, len(bar))

function! s:is_updated(dir)

return !empty(s:system_chomp('git log --pretty=format:"%h" "HEAD...HEAD@{1}"', a:dir))

function! s:do(pull, force, todo)

for [name, spec] in items(a:todo)

if !isdirectory(spec.dir)

continue

endif

let installed = has_key(s:update.new, name)

let updated = installed ? 0 :

\ (a:pull && index(s:update.errors, name) < 0 && s:is_updated(spec.dir))

if a:force || installed || updated

execute 'cd' s:esc(spec.dir)

call append(3, '- Post-update hook for '. name .' ... ')

let error = ''

let type = type(spec.do)

if type == s:TYPE.string

if spec.do[0] == ':'

call s:load_plugin(spec)

try

execute spec.do[1:]

catch

let error = v:exception

endtry

if !s:plug_window_exists()

cd -

throw 'Warning: vim-plug was terminated by the post-update hook of '.name

endif

else

let error = s:bang(spec.do)

endif

elseif type == s:TYPE.funcref

try

let status = installed ? 'installed' : (updated ? 'updated' : 'unchanged')

call spec.do({ 'name': name, 'status': status, 'force': a:force })

catch

let error = v:exception

endtry

else

let error = 'Invalid hook type'

endif

call s:switch_in()

call setline(4, empty(error) ? (getline(4) . 'OK')

\ : ('x' . getline(4)[1:] . error))

if !empty(error)

call add(s:update.errors, name)

call s:regress_bar()

endif

cd -

endif

endfor

function! s:hash_match(a, b)

return stridx(a:a, a:b) == 0 || stridx(a:b, a:a) == 0

function! s:checkout(spec)

let sha = a:spec.commit

let output = s:system('git rev-parse HEAD', a:spec.dir)

if !v:shell_error && !s:hash_match(sha, s:lines(output)[0])

let output = s:system(

\ 'git fetch --depth 999999 && git checkout '.s:esc(sha), a:spec.dir)

endif

return output

function! s:finish(pull)

let new_frozen = len(filter(keys(s:update.new), 'g:plugs[v:val].frozen'))

if new_frozen

let s = new_frozen > 1 ? 's' : ''

call append(3, printf('- Installed %d frozen plugin%s', new_frozen, s))

endif

call append(3, '- Finishing ... ') | 4

redraw

call plug#helptags()

call plug#end()

call setline(4, getline(4) . 'Done!')

redraw

let msgs = []

if !empty(s:update.errors)

call add(msgs, "Press 'R' to retry.")

endif

if a:pull && len(s:update.new) < len(filter(getline(5, '$'),

\ "v:val =~ '^- ' && stridx(v:val, 'Already up-to-date') < 0"))

call add(msgs, "Press 'D' to see the updated changes.")

endif

echo join(msgs, ' ')

call s:finish_bindings()

function! s:retry()

if empty(s:update.errors)

return

endif

echo

call s:update_impl(s:update.pull, s:update.force,

\ extend(copy(s:update.errors), [s:update.threads]))

function! s:is_managed(name)

return has_key(g:plugs[a:name], 'uri')

function! s:names(...)

return sort(filter(keys(g:plugs), 'stridx(v:val, a:1) == 0 && s:is_managed(v:val)'))

function! s:check_ruby()

silent! ruby require 'thread'; VIM::command("let g:plug_ruby = '#{RUBY_VERSION}'")

if !exists('g:plug_ruby')

redraw!

return s:warn('echom', 'Warning: Ruby interface is broken')

endif

let ruby_version = split(g:plug_ruby, '\.')

unlet g:plug_ruby

return s:version_requirement(ruby_version, [1, 8, 7])

function! s:update_impl(pull, force, args) abort

let args = copy(a:args)

let threads = (len(args) > 0 && args[-1] =~ '^[1-9][0-9]*$') ?

\ remove(args, -1) : get(g:, 'plug_threads', 16)

let managed = filter(copy(g:plugs), 's:is_managed(v:key)')

let todo = empty(args) ? filter(managed, '!v:val.frozen || !isdirectory(v:val.dir)') :

\ filter(managed, 'index(args, v:key) >= 0')

if empty(todo)

return s:warn('echo', 'No plugin to '. (a:pull ? 'update' : 'install'))

endif

if !s:is_win && s:git_version_requirement(2, 3)

let s:git_terminal_prompt = exists('$GIT_TERMINAL_PROMPT') ? $GIT_TERMINAL_PROMPT : ''

let $GIT_TERMINAL_PROMPT = 0

for plug in values(todo)

let plug.uri = substitute(plug.uri,

\ '^https://git::@github\.com', 'https://github.com', '')

endfor

endif

if !isdirectory(g:plug_home)

try

call mkdir(g:plug_home, 'p')