I broke up with neovim....vim is my best friend now

dot_vim/plugged/vim-vsnip-integ/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 hrsh7th
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dot_vim/plugged/vim-vsnip-integ/README.md

@@ -0,0 +1,48 @@
+# vim-vsnip-integ
+
+This plugin provides some plugins integration.
+
+- Snippet completion
+- Snippet expansion
+
+
+# Requirements
+
+- [vim-vsnip](https://github.com/hrsh7th/vim-vsnip)
+	- You should set [mapping](https://github.com/hrsh7th/vim-vsnip/blob/master/README.md#2-setting).
+
+
+# Integrations
+
+### LSP
+
+#### [vim-lsp](https://github.com/prabirshrestha/vim-lsp)
+- Support snippet text expansion.
+
+#### [vim-lsc](https://github.com/natebosch/vim-lsc)
+- Support snippet text expansion.
+
+#### [yegappan/lsp](https://github.com/yegappan/lsp)
+- Support snippet text expansion.
+
+#### [LanguageClient-neovim](https://github.com/autozimu/LanguageClient-neovim)
+- Support snippet text expansion.
+
+#### [nvim builtin-lsp omnifunc](https://github.com/neovim/neovim)
+- Support snippet text expansion.
+- Support textEdit/additionalTextEdits at CompleteDone.
+
+
+### Completion
+
+#### [asyncomplete.vim](https://github.com/prabirshrestha/asyncomplete.vim)
+- Snippet completion.
+
+#### [vim-mucomplete](https://github.com/lifepillar/vim-mucomplete)
+- Snippet completion.
+
+#### [ddc.vim](https://github.com/Shougo/ddc.vim)
+- Snippet completion.
+- ddc.vim remove duplicated keyword by default.  
+If you want to list up both of them, please add `'dup': 'keep'` .
+

dot_vim/plugged/vim-vsnip-integ/after/plugin/vsnip_integ.vim

@@ -0,0 +1 @@
+call vsnip_integ#integration#attach()

dot_vim/plugged/vim-vsnip-integ/autoload/vsnip_integ.vim

@@ -0,0 +1,318 @@
+let s:TextEdit = vital#vsnip#import('VS.LSP.TextEdit')
+let s:Position = vital#vsnip#import('VS.LSP.Position')
+
+let s:stop_complete_done = v:false
+let s:stop_complete_done_after = v:false
+
+"
+" CompleteDone context.
+"
+" When completed LSP item, context will have `completion_item` key.
+" When completed snippet item, context will have `snippet` key.
+"
+let s:context = {
+\   'done_line': '',
+\   'done_pos': [],
+\   'completed_item': v:null,
+\   'sources': [],
+\
+\   'snippet': '',
+\
+\   'complete_position': {},
+\   'completion_item': v:null,
+\ }
+
+inoremap <silent> <Plug>(vsnip_integ:on_complete_done_after) <C-r>=<SID>on_complete_done_after()<CR>
+
+"
+" vsnip_integ#skip_complete_done_after
+"
+function! vsnip_integ#skip_complete_done_after() abort
+  let s:stop_complete_done_after = v:true
+  call timer_start(0, { -> execute('let s:stop_complete_done_after = v:false') })
+endfunction
+
+"
+" vsnip_integ#do_complete_done
+"
+" @param context = {
+"   completed_item: v:completed_item;
+"   completion_item: LSP.CompletionItem;
+"   complete_position?: LSP.Position; // that sent on `textDocument/completion`
+"   apply_additional_text_edits: v:true | v:false;
+" } | {
+"   completed_item: v:completed_item;
+"   snippet: string; // that's format is LSP's snippet format
+" }
+"
+function! vsnip_integ#do_complete_done(context) abort
+  if s:stop_complete_done | return | endif
+  let s:stop_complete_done = v:true
+  call timer_start(0, { -> execute('let s:stop_complete_done = v:false') })
+
+  let s:context = {
+  \   'done_line': getline('.'),
+  \   'done_pos': getcurpos(),
+  \   'completed_item': a:context.completed_item,
+  \   'sources': [],
+  \
+  \   'snippet': get(a:context, 'snippet', v:null),
+  \
+  \   'completion_item': get(a:context, 'completion_item', v:null),
+  \   'complete_position': get(a:context, 'complete_position', v:null),
+  \   'apply_additional_text_edits': get(a:context, 'apply_additional_text_edits', v:false),
+  \ }
+  call feedkeys("\<Plug>(vsnip_integ:on_complete_done_after)")
+endfunction
+
+"
+" vsnip_integ#on_complete_done
+"
+function! vsnip_integ#on_complete_done(completed_item) abort
+  let l:context = s:extract_user_data(a:completed_item)
+  if !empty(l:context)
+    if s:stop_complete_done | return | endif
+    let s:stop_complete_done = v:true
+    call timer_start(0, { -> execute('let s:stop_complete_done = v:false') })
+
+    let s:context = extend(l:context, {
+    \   'done_line': getline('.'),
+    \   'done_pos': getcurpos(),
+    \   'completed_item': a:completed_item,
+    \   'apply_additional_text_edits': v:true,
+    \ })
+    call feedkeys("\<Plug>(vsnip_integ:on_complete_done_after)")
+  endif
+endfunction
+
+"
+" on_complete_done_after
+"
+function! s:on_complete_done_after() abort
+  if s:stop_complete_done_after | return '' | endif
+
+  " Fix lnum for external additionalTextEdits
+  let s:context.done_pos[1] = getcurpos()[1]
+
+  " Check <BS> or <C-h>
+  if strlen(getline('.')) < strlen(s:context.done_line)
+    return ''
+  endif
+
+  " Remove completed text
+  let l:expand_text = s:get_expand_text(s:context)
+  if strlen(l:expand_text) > 0
+    call s:remove_completed_text(s:context)
+  endif
+
+  " additionalTextEdits
+  if get(s:context, 'apply_additional_text_edits', v:false)
+    call s:apply_additional_text_edits(s:context)
+  endif
+
+  " Expand snippet.
+  if strlen(l:expand_text) > 0
+    call vsnip#anonymous(l:expand_text)
+  endif
+
+  return ''
+endfunction
+
+"
+" get_expand_text
+"
+function! s:get_expand_text(context) abort
+  let l:done_line = a:context.done_line
+  let l:done_pos = a:context.done_pos
+  let l:completed_item = a:context.completed_item
+  let l:snippet = get(a:context, 'snippet', v:null)
+  let l:completion_item = get(a:context, 'completion_item', v:null)
+
+  " Snippet body.
+  if l:snippet isnot# v:null
+    return type(l:snippet) == type([]) ? join(l:snippet, "\n") : l:snippet
+  endif
+
+  " LSP CompletionItem.
+  if l:completion_item isnot# v:null
+    let l:word = l:completed_item.word
+    if has_key(l:completion_item, 'textEdit') && type(l:completion_item.textEdit) == type({})
+      let l:lsp_done_pos = s:Position.vim_to_lsp('%', [l:done_pos[1], l:done_pos[2] + l:done_pos[3]])
+      let l:text_edit = copy(l:completion_item.textEdit)
+      let l:text_edit.range.start.character = min([l:lsp_done_pos['character'] - strchars(l:word), l:text_edit.range.start.character])
+      let l:text_edit.range.end.character = max([l:lsp_done_pos['character'], l:text_edit.range.end.character])
+      let l:text_edit_before = strcharpart(l:done_line, 0, l:completion_item.textEdit.range.start.character)
+      let l:text_edit_after = strcharpart(l:done_line, l:completion_item.textEdit.range.end.character, strchars(l:done_line) - l:completion_item.textEdit.range.end.character)
+      if l:done_line !=# l:text_edit_before . s:trim_unmeaning_tabstop(l:completion_item.textEdit.newText) . l:text_edit_after
+        return l:completion_item.textEdit.newText
+      endif
+    elseif has_key(l:completion_item, 'insertText') && type(l:completion_item.insertText) == type('')
+      if l:word !=# s:trim_unmeaning_tabstop(l:completion_item.insertText)
+        return l:completion_item.insertText
+      endif
+    endif
+  endif
+
+  return ''
+endfunction
+
+"
+" apply_additional_text_edits
+"
+function! s:apply_additional_text_edits(context) abort
+  if type(get(a:context, 'completion_item', v:null)) != type({})
+    return
+  endif
+  if type(get(a:context.completion_item, 'additionalTextEdits', v:null)) != type([])
+    return
+  endif
+  if len(a:context.completion_item.additionalTextEdits) == 0
+    return
+  endif
+
+  " Special ignore case (Some lsp clients will expand additionalTextEdits by itself).
+  for l:id in ['lcn', 'vimlsp']
+    if index(s:context.sources, l:id) >= 0 && vsnip_integ#detection#exists(l:id)
+      return
+    endif
+  endfor
+
+  call s:TextEdit.apply(bufnr('%'), a:context.completion_item.additionalTextEdits)
+endfunction
+
+"
+" remove_completed_text
+"
+function! s:remove_completed_text(context) abort
+  let l:done_line = a:context.done_line
+  let l:done_pos = a:context.done_pos
+  let l:completed_item = a:context.completed_item
+  let l:completion_item = get(a:context, 'completion_item', v:null)
+  let l:complete_position = get(a:context, 'complete_position', v:null)
+  let l:lsp_done_pos = s:Position.vim_to_lsp('%', [l:done_pos[1], l:done_pos[2] + l:done_pos[3]])
+
+  " Remove trigger character.
+  call setline('.', l:done_line)
+
+  " Create range to remove.
+  let l:range = {
+        \   'start': {
+        \     'line': l:lsp_done_pos['line'],
+        \     'character': l:lsp_done_pos['character'] - strchars(l:completed_item.word)
+        \   },
+        \   'end': l:lsp_done_pos
+        \ }
+
+  " Support `textEdit` range for LSP CompletionItem.
+  if !empty(l:completion_item) && has_key(l:completion_item, 'textEdit') && type(l:completion_item.textEdit) == type({})
+    let l:range.start.character = min([l:range.start.character, l:completion_item.textEdit.range.start.character])
+    let l:range.end.character = max([l:range.end.character, l:completion_item.textEdit.range.end.character])
+  endif
+
+  " Remove range.
+  call s:TextEdit.apply(bufnr('%'), [{
+  \   'range': l:range,
+  \   'newText': ''
+  \ }])
+  call cursor(s:Position.lsp_to_vim('%', l:range.start))
+endfunction
+
+"
+" extract_user_data
+"
+function! s:extract_user_data(completed_item) abort
+  try
+    " Has no `user_data`.
+    if !has_key(a:completed_item, 'user_data')
+      return {}
+    endif
+
+    " Decode user_data.
+    let l:user_data = a:completed_item.user_data
+    if type(l:user_data) == type('')
+      let l:user_data = json_decode(l:user_data)
+    elseif s:has_key(l:user_data, 'lspitem')
+      " ddc-nvim-lsp
+      return {
+      \   'sources': ['ddc'],
+      \   'completion_item': json_decode(l:user_data.lspitem)
+      \ }
+    endif
+
+    " Support dict only.
+    if type(l:user_data) != type({})
+      return {}
+    endif
+
+    if vsnip_integ#detection#exists('yegappan_lsp') && has_key(l:user_data, 'label')
+      return {
+      \   'sources': ['yegappan_lsp'],
+      \   'completion_item': l:user_data
+      \ }
+    endif
+
+    " LanguageClient-neovim
+    if s:has_key(l:user_data, 'lspitem')
+      return {
+      \   'sources': ['lcn'],
+      \   'completion_item': l:user_data.lspitem
+      \ }
+    endif
+
+    " neovim built-in
+    if s:has_key(l:user_data, 'nvim') && s:has_key(l:user_data.nvim, 'lsp') && s:has_key(l:user_data.nvim.lsp, 'completion_item')
+      return {
+      \   'sources': ['nvim'],
+      \   'completion_item': l:user_data.nvim.lsp.completion_item
+      \ }
+    endif
+
+    " neovim built-in
+    if s:has_key(l:user_data, 'lsp') && s:has_key(l:user_data.lsp, 'completion_item')
+      return {
+      \   'sources': ['nvim'],
+      \   'completion_item': l:user_data.lsp.completion_item
+      \ }
+    endif
+
+    " vim-lsc
+    if s:has_key(l:user_data, 'snippet') && s:has_key(l:user_data, 'snippet_trigger')
+      return {
+      \   'sources': ['lsc'],
+      \   'snippet': l:user_data.snippet
+      \ }
+    endif
+
+    " vsnip
+    if s:has_key(l:user_data, 'vsnip')
+      return {
+      \   'sources': ['vsnip'],
+      \   'snippet': join(l:user_data.vsnip.snippet, "\n")
+      \ }
+    endif
+  catch /.*/
+    if g:vsnip_integ_debug
+      echomsg string([v:exception, v:throwpoint])
+    endif
+  endtry
+
+  return {}
+endfunction
+
+"
+" has_key
+"
+function! s:has_key(maybe_dict, key) abort
+  if type(a:maybe_dict) != type({})
+    return v:false
+  endif
+  return has_key(a:maybe_dict, a:key)
+endfunction
+
+"
+" trim_unmeaning_tabstop
+"
+function! s:trim_unmeaning_tabstop(text) abort
+  return substitute(a:text, '\%(\$0\|\${0}\)$', '', 'g')
+endfunction
+

dot_vim/plugged/vim-vsnip-integ/autoload/vsnip_integ/detection.vim

@@ -0,0 +1,37 @@
+let s:definition = {
+\   'vimlsp': { -> exists('g:lsp_loaded') },
+\   'lsc': { -> exists('g:loaded_lsc') },
+\   'lcn': { -> exists('g:LanguageClient_serverCommands') },
+\   'asyncomplete': { -> exists('g:asyncomplete_loaded') },
+\   'mucomplete': { -> exists('g:loaded_mucomplete') },
+\   'ddc': { -> s:runtimepath("autoload/ddc.vim") },
+\   'yegappan_lsp': { -> s:runtimepath('autoload/lsp/lspserver.vim') },
+\ }
+
+
+let s:cache = {}
+
+"
+" vsnip_integ#detection#definition
+"
+function! vsnip_integ#detection#definition() abort
+  return copy(s:definition)
+endfunction
+
+"
+" vsnip_integ#detection#exists
+"
+function! vsnip_integ#detection#exists(id) abort
+  if !has_key(s:cache, a:id)
+    let s:cache[a:id] = s:definition[a:id]()
+  endif
+  return s:cache[a:id]
+endfunction
+
+"
+" runtimepath
+"
+function! s:runtimepath(path) abort
+  return !empty(globpath(&runtimepath, a:path))
+endfunction
+

dot_vim/plugged/vim-vsnip-integ/autoload/vsnip_integ/integration.vim

@@ -0,0 +1,26 @@
+let s:attached = v:false
+
+"
+" vsnip_integ#integration#attach
+"
+" TODO: improve initialization.
+"
+function! vsnip_integ#integration#attach() abort
+  if s:attached
+    return
+  endif
+  let s:attached = v:true
+
+  for l:name in keys(vsnip_integ#detection#definition())
+    try
+      if vsnip_integ#detection#exists(l:name)
+        call vsnip_integ#integration#{l:name}#attach()
+      endif
+    catch /.*/
+      if g:vsnip_integ_debug
+        echomsg string([v:exception, v:throwpoint])
+      endif
+    endtry
+  endfor
+endfunction
+

dot_vim/plugged/vim-vsnip-integ/autoload/vsnip_integ/integration/asyncomplete.vim

@@ -0,0 +1,55 @@
+function! vsnip_integ#integration#asyncomplete#attach() abort
+  call asyncomplete#register_source(
+  \   s:get_source_option({
+  \     'name': 'vsnip',
+  \     'whitelist': ['*'],
+  \     'completor': function('s:completor'),
+  \   })
+  \ )
+endfunction
+
+"
+" get_source_option
+"
+function! s:get_source_option(opts) abort
+  let l:defaults = {
+  \   'name': 'vsnip',
+  \   'completor': function('s:completor'),
+  \   'whitelist': ['*']
+  \ }
+  return extend(l:defaults, a:opts)
+endfunction
+
+"
+" completor
+"
+function! s:completor(opts, ctx) abort
+  let l:before_line = getline('.')
+  let l:idx = min([strlen(l:before_line), col('.') - 2])
+  let l:idx = max([l:idx, 0])
+  let l:before_line =  l:before_line[0 : l:idx]
+
+  if len(matchstr(l:before_line, s:get_keyword_pattern() . '$')) < 1
+    return
+  endif
+
+
+  call asyncomplete#complete(
+  \   a:opts.name,
+  \   a:ctx,
+  \   a:ctx.col - strlen(matchstr(a:ctx.typed, '\k*$')),
+  \   vsnip#get_complete_items(bufnr('%'))
+  \ )
+endfunction
+
+"
+" get_keyword_pattern
+"
+function! s:get_keyword_pattern() abort
+  let l:keywords = split(&iskeyword, ',')
+  let l:keywords = filter(l:keywords, { _, k -> match(k, '\d\+-\d\+') == -1 })
+  let l:keywords = filter(l:keywords, { _, k -> k !=# '@' })
+  let l:pattern = '\%(' . join(map(l:keywords, { _, v -> '\V' . escape(v, '\') . '\m' }), '\|') . '\|\w\)*'
+  return l:pattern
+endfunction
+

dot_vim/plugged/vim-vsnip-integ/autoload/vsnip_integ/integration/lcn.vim

@@ -0,0 +1,7 @@
+"
+" vsnip_integ#integration#lcn#attach
+"
+function! vsnip_integ#integration#lcn#attach() abort
+  let g:LanguageClient_hasSnippetSupport = v:true
+endfunction
+

dot_vim/plugged/vim-vsnip-integ/autoload/vsnip_integ/integration/lsc.vim

@@ -0,0 +1,7 @@
+"
+" vsnip_integ#integration#lsc#attach
+"
+function! vsnip_integ#integration#lsc#attach() abort
+  let g:lsc_enable_snippet_support = v:true
+endfunction
+

dot_vim/plugged/vim-vsnip-integ/autoload/vsnip_integ/integration/mucomplete.vim

@@ -0,0 +1,31 @@
+"
+" vsnip_integ#integration#mucomplete#attach
+"
+function! vsnip_integ#integration#mucomplete#attach() abort
+  call mucomplete#add_user_mapping('vsnip', "\<C-r>=vsnip_integ#integration#mucomplete#complete()\<CR>")
+endfunction
+
+"
+" vsnip_integ#integration#mucomplete#complete
+"
+function! vsnip_integ#integration#mucomplete#complete() abort
+  let l:before_line = getline('.')
+  let l:idx = min([strlen(l:before_line), col('.') - 2])
+  let l:idx = max([l:idx, 0])
+  let l:before_line =  l:before_line[0 : l:idx]
+  let l:keyword = matchstr(l:before_line, '\k\+$')
+
+  if l:keyword == ''
+    return ''
+  endif
+
+  let l:candidates = vsnip#get_complete_items(bufnr('%'))
+  let l:match = map(l:candidates, { _, val -> (l:keyword == val["word"][0:strlen(l:keyword)-1]) ? val : ''})
+  
+  if !empty(l:candidates)
+    call complete(col('.') - strlen(l:keyword), l:match)
+  endif
+
+  return ''
+endfunction
+

dot_vim/plugged/vim-vsnip-integ/autoload/vsnip_integ/integration/vimlsp.vim

@@ -0,0 +1,32 @@
+"
+" vsnip_integ#integration#vimlsp#attach
+"
+function! vsnip_integ#integration#vimlsp#attach() abort
+  let g:lsp_text_edit_enabled = v:true
+  let g:lsp_get_supported_capabilities = [function('s:get_supported_capabilities')]
+  let g:lsp_snippet_expand = [{ option -> vsnip#anonymous(option.snippet) }]
+endfunction
+
+"
+" get_supported_capabilities.
+"
+function! s:get_supported_capabilities(server_info) abort
+  let l:capabilities = lsp#default_get_supported_capabilities(a:server_info)
+
+  if !has_key(l:capabilities, 'textDocument')
+    let l:capabilities.textDocument = {}
+  endif
+
+  if !has_key(l:capabilities.textDocument, 'completion')
+    let l:capabilities.textDocument.completion = {}
+  endif
+
+  if !has_key(l:capabilities.textDocument.completion, 'completionItem')
+    let l:capabilities.textDocument.completion.completionItem = {}
+  endif
+
+  let l:capabilities.textDocument.completion.completionItem.snippetSupport = v:true
+
+  return l:capabilities
+endfunction
+

dot_vim/plugged/vim-vsnip-integ/autoload/vsnip_integ/integration/yegappan_lsp.vim

@@ -0,0 +1,7 @@
+"
+" vsnip_integ#integration#yegappan_lsp#attach
+"
+function! vsnip_integ#integration#yegappan_lsp#attach() abort
+  call LspOptionsSet({ 'snippetSupport': v:true })
+endfunction
+

dot_vim/plugged/vim-vsnip-integ/denops/@ddc-sources/vsnip.ts

@@ -0,0 +1,22 @@
+import {
+  BaseSource,
+  Item,
+} from "https://deno.land/x/ddc_vim@v3.1.0/types.ts#^";
+import { Denops, fn } from "https://deno.land/x/ddc_vim@v3.1.0/deps.ts#^";
+
+type Params = Record<string, never>;
+
+export class Source extends BaseSource<Params> {
+  async gather(args: {
+    denops: Denops;
+  }): Promise<Item[]> {
+    return args.denops.call(
+      "vsnip#get_complete_items",
+      await fn.bufnr(args.denops),
+    ) as Promise<Item[]>;
+  }
+
+  params(): Params {
+    return {};
+  }
+}

dot_vim/plugged/vim-vsnip-integ/doc/tags

@@ -0,0 +1,5 @@
+vim-vsnip-integ	vsnip_integ.txt	/*vim-vsnip-integ*
+vsnip-integ	vsnip_integ.txt	/*vsnip-integ*
+vsnip-integ-contents	vsnip_integ.txt	/*vsnip-integ-contents*
+vsnip-integ-example	vsnip_integ.txt	/*vsnip-integ-example*
+vsnip-integ-install	vsnip_integ.txt	/*vsnip-integ-install*

dot_vim/plugged/vim-vsnip-integ/doc/vsnip_integ.txt

@@ -0,0 +1,38 @@
+*vim-vsnip-integ* *vsnip-integ*
+
+vim-vsnip integrations.
+
+
+==============================================================================
+CONTENTS                                                *vsnip-integ-contents*
+
+INSTALL                                                  |vsnip-integ-install|
+EXPAMPLE                                                 |vsnip-integ-example|
+
+
+==============================================================================
+INSTALL                                                  *vsnip-integ-install*
+
+You can use your favorite plugin manager.
+
+>
+  " dein.vim
+  call dein#add('hrsh7th/vim-vsnip-integ')
+
+  " vim-plug
+  Plug 'hrsh7th/vim-vsnip-integ'
+
+  " neobundle
+  NeoBundle 'hrsh7th/vim-vsnip-integ'
+<
+
+==============================================================================
+EXAMPLE                                                 *vsnip-integ-example*
+
+Using vnsip-integ with implemented completion engine by some plugin.
+
+>
+  " Shougo/pum.vim
+  autocmd User PumCompleteDone call vsnip_integ#on_complete_done(g:pum#completed_item)
+<
+

dot_vim/plugged/vim-vsnip-integ/dot_git/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/master

dot_vim/plugged/vim-vsnip-integ/dot_git/config

@@ -0,0 +1,11 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+[remote "origin"]
+	url = https://github.com/hrsh7th/vim-vsnip-integ.git
+	fetch = +refs/heads/*:refs/remotes/origin/*
+[branch "master"]
+	remote = origin
+	merge = refs/heads/master

dot_vim/plugged/vim-vsnip-integ/dot_git/description

@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/applypatch-msg.sample

@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "applypatch-msg".
+
+. git-sh-setup
+commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
+test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
+:

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/commit-msg.sample

@@ -0,0 +1,24 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by "git commit" with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "commit-msg".
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
+# hook is more suited to it.
+#
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines.
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	exit 1
+}

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/fsmonitor-watchman.sample

@@ -0,0 +1,174 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	    "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	my $last_update_line = "";
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+		$last_update_line = qq[\n"since": $last_update_token,];
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {$last_update_line
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		    "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/post-update.sample

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, rename this file to "post-update".
+
+exec git update-server-info

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/pre-applypatch.sample

@@ -0,0 +1,14 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+. git-sh-setup
+precommit="$(git rev-parse --git-path hooks/pre-commit)"
+test -x "$precommit" && exec "$precommit" ${1+"$@"}
+:

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/pre-commit.sample

@@ -0,0 +1,49 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# Note that the use of brackets around a tr range is ok here, (it's
+	# even required, for portability to Solaris 10's /usr/bin/tr), since
+	# the square bracket bytes happen to fall in the designated range.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+  git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/pre-merge-commit.sample

@@ -0,0 +1,13 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git merge" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message to
+# stderr if it wants to stop the merge commit.
+#
+# To enable this hook, rename this file to "pre-merge-commit".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+        exec "$GIT_DIR/hooks/pre-commit"
+:

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/pre-push.sample

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+# An example hook script to verify what is about to be pushed.  Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed.  If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/pre-rebase.sample

@@ -0,0 +1,169 @@
+#!/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master.  Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next?  If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master           ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+   merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+   it is deleted.  If you need to build on top of it to correct
+   earlier mistakes, a new topic branch is created by forking at
+   the tip of the "master".  This is not strictly necessary, but
+   it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+   branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next".  Young
+    topic branches can have stupid mistakes you would rather
+    clean up before publishing, and things that have not been
+    merged into other branches can be easily rebased without
+    affecting other people.  But once it is published, you would
+    not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+    Then you can delete it.  More importantly, you should not
+    build on top of it -- other people may already want to
+    change things related to the topic as patches against your
+    "master", so if you need further changes, it is better to
+    fork the topic (perhaps with the same name) afresh from the
+    tip of "master".
+
+Let's look at this example:
+
+		   o---o---o---o---o---o---o---o---o---o "next"
+		  /       /           /           /
+		 /   a---a---b A     /           /
+		/   /               /           /
+	       /   /   c---c---c---c B         /
+	      /   /   /             \         /
+	     /   /   /   b---b C     \       /
+	    /   /   /   /             \     /
+    ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished.  It has been fully merged up to "master" and "next",
+   and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master        next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/pre-receive.sample

@@ -0,0 +1,24 @@
+#!/bin/sh
+#
+# An example hook script to make use of push options.
+# The example simply echoes all push options that start with 'echoback='
+# and rejects all pushes when the "reject" push option is used.
+#
+# To enable this hook, rename this file to "pre-receive".
+
+if test -n "$GIT_PUSH_OPTION_COUNT"
+then
+	i=0
+	while test "$i" -lt "$GIT_PUSH_OPTION_COUNT"
+	do
+		eval "value=\$GIT_PUSH_OPTION_$i"
+		case "$value" in
+		echoback=*)
+			echo "echo from the pre-receive-hook: ${value#*=}" >&2
+			;;
+		reject)
+			exit 1
+		esac
+		i=$((i + 1))
+	done
+fi

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/prepare-commit-msg.sample

@@ -0,0 +1,42 @@
+#!/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/push-to-checkout.sample

@@ -0,0 +1,78 @@
+#!/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+#   head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

dot_vim/plugged/vim-vsnip-integ/dot_git/hooks/update.sample

@@ -0,0 +1,128 @@
+#!/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+#   This boolean sets whether unannotated tags will be allowed into the
+#   repository.  By default they won't be.
+# hooks.allowdeletetag
+#   This boolean sets whether deleting tags will be allowed in the
+#   repository.  By default they won't be.
+# hooks.allowmodifytag
+#   This boolean sets whether a tag may be modified after creation. By default
+#   it won't be.
+# hooks.allowdeletebranch
+#   This boolean sets whether deleting branches will be allowed in the
+#   repository.  By default they won't be.
+# hooks.denycreatebranch
+#   This boolean sets whether remotely creating branches will be denied
+#   in the repository.  By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo "  $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

dot_vim/plugged/vim-vsnip-integ/dot_git/info/exclude

@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

dot_vim/plugged/vim-vsnip-integ/dot_git/logs/HEAD

@@ -0,0 +1,2 @@
+0000000000000000000000000000000000000000 1cf89903f12777b90dd79eb4b3d7fbc0b9a254a1 LinlyBoi <libkyy@e.email> 1676062730 +0200	clone: from https://github.com/hrsh7th/vim-vsnip-integ.git
+1cf89903f12777b90dd79eb4b3d7fbc0b9a254a1 1cf89903f12777b90dd79eb4b3d7fbc0b9a254a1 LinlyBoi <libkyy@e.email> 1676062732 +0200	checkout: moving from master to master

dot_vim/plugged/vim-vsnip-integ/dot_git/logs/refs/heads/master

@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 1cf89903f12777b90dd79eb4b3d7fbc0b9a254a1 LinlyBoi <libkyy@e.email> 1676062730 +0200	clone: from https://github.com/hrsh7th/vim-vsnip-integ.git

dot_vim/plugged/vim-vsnip-integ/dot_git/logs/refs/remotes/origin/HEAD

@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 1cf89903f12777b90dd79eb4b3d7fbc0b9a254a1 LinlyBoi <libkyy@e.email> 1676062730 +0200	clone: from https://github.com/hrsh7th/vim-vsnip-integ.git

dot_vim/plugged/vim-vsnip-integ/dot_git/packed-refs

@@ -0,0 +1,14 @@
+# pack-refs with: peeled fully-peeled sorted 
+daf0f5ecfc573474bdd99e9dd7c6923a31dafb18 refs/remotes/origin/add-manual-skip
+2e64525aeef846baf33a20369e82dacc67c1b8c4 refs/remotes/origin/asyncomplete
+60dfb85f115de98204b35ecb731bd3c053ea53fc refs/remotes/origin/auto_expand_trial
+0fa6c485c557423d3a4447a26870787d37abc7b6 refs/remotes/origin/deoplete-lsp
+a185fc07092b9965b55697a689cf376da569b328 refs/remotes/origin/fix-deoplete
+eb12ebddf52734562dd34e9daa50393914f94a21 refs/remotes/origin/fix-remaining-completed-item
+371b1a7a6b826e7b1e2803bb278f84167c0d37f2 refs/remotes/origin/language-client-neovim
+1cf89903f12777b90dd79eb4b3d7fbc0b9a254a1 refs/remotes/origin/master
+14486e20197f9ec12b896ddc42dcce08aefe067e refs/remotes/origin/new-vim-lsp
+1d49f96976cb2b067457eedf25adda58003e9edd refs/remotes/origin/nvim-lsp
+f2111b9fce0aa0447336b5f6c88a7bc02299d0f0 refs/remotes/origin/set-capability
+d97f7dd84f8a06e66d424616e750706ba7248b5c refs/remotes/origin/stop-compe
+c29a58f9caa7516b2da4952681967d204ea4ad9c refs/remotes/origin/vim-lsp

dot_vim/plugged/vim-vsnip-integ/dot_git/refs/heads/master

@@ -0,0 +1 @@
+1cf89903f12777b90dd79eb4b3d7fbc0b9a254a1

dot_vim/plugged/vim-vsnip-integ/dot_git/refs/remotes/origin/HEAD

@@ -0,0 +1 @@
+ref: refs/remotes/origin/master

dot_vim/plugged/vim-vsnip-integ/dot_git/shallow

@@ -0,0 +1,13 @@
+0fa6c485c557423d3a4447a26870787d37abc7b6
+14486e20197f9ec12b896ddc42dcce08aefe067e
+1cf89903f12777b90dd79eb4b3d7fbc0b9a254a1
+1d49f96976cb2b067457eedf25adda58003e9edd
+2e64525aeef846baf33a20369e82dacc67c1b8c4
+371b1a7a6b826e7b1e2803bb278f84167c0d37f2
+60dfb85f115de98204b35ecb731bd3c053ea53fc
+a185fc07092b9965b55697a689cf376da569b328
+c29a58f9caa7516b2da4952681967d204ea4ad9c
+d97f7dd84f8a06e66d424616e750706ba7248b5c
+daf0f5ecfc573474bdd99e9dd7c6923a31dafb18
+eb12ebddf52734562dd34e9daa50393914f94a21
+f2111b9fce0aa0447336b5f6c88a7bc02299d0f0

dot_vim/plugged/vim-vsnip-integ/dot_gitignore

@@ -0,0 +1,3 @@
+.mypy_cache
+__pycache__
+/doc/tags

dot_vim/plugged/vim-vsnip-integ/plugin/vsnip_integ.vim

@@ -0,0 +1,17 @@
+if exists('g:loaded_vsnip_integ')
+  finish
+endif
+let g:loaded_vsnip_integ = v:true
+
+let g:vsnip_integ_debug = get(g:, 'vsnip_integ_debug', v:false)
+
+augroup vsnip_integ
+  autocmd!
+  autocmd User vsnip#expand call vsnip_integ#skip_complete_done_after()
+  if has('#CompleteDonePre')
+    autocmd CompleteDonePre * if complete_info(['mode']).mode !=? '' | call vsnip_integ#on_complete_done(v:completed_item) | endif
+  else
+    autocmd CompleteDone * call vsnip_integ#on_complete_done(v:completed_item)
+  endif
+augroup END
+