[[plugins]]
repo = 'https://github.com/4513ECHO/lightline-ddu-ui-ff'
on_source = ['lightline.vim']

[[plugins]]
repo = 'https://github.com/4513ECHO/registerm.vim'
on_map = { t = '<Plug>' }
hook_add = '''
tnoremap <C-\><C-y> <Plug>(registerm)
tnoremap <C-\><C-r> <Plug>(registerm-getchar)
'''

[[plugins]]
repo = 'https://github.com/4513ECHO/vim-readme-viewer'
on_cmd = ['DeinReadme']
on_source = ['ddu.vim']
hook_add = '''
let g:readme_viewer#plugin_manager = 'dein.vim'
'''

[[plugins]]
repo = 'https://github.com/4513ECHO/vim-snipewin'
on_func = ['snipewin#select']
on_map = { n = '<Plug>' }
hook_add = '''
let g:snipewin_label_chars = 'ASDFGHJKLQWERTYUIOP'
let g:snipewin_label_font = 'asciian_inverted'
nnoremap <C-w>W <Plug>(snipewin)
nnoremap <C-w>X <Cmd>call snipewin#select({ winid -> snipewin#callback#swap(winid) })<CR>
nnoremap <C-w>O <Cmd>call snipewin#select({ winid -> snipewin#callback#only(winid) })<CR>
'''

[[plugins]]
repo = 'https://github.com/4513ECHO/vim-vimhelp-url'
on_cmd = ['HelpUrl']

[[plugins]]
repo = 'https://github.com/bronson/vim-trailing-whitespace'
on_cmd = ['FixWhitespace']
on_event = ['InsertLeave']
hook_add = '''
let g:extra_whitespace_ignored_filetypes = ['diff', 'help', 'capture', 'tsv']
'''

[[plugins]]
repo = 'https://github.com/chrisbra/Recover.vim'
on_event = ['BufWinEnter', 'FocusGained', 'SwapExists']

[[plugins]]
repo = 'https://github.com/christoomey/vim-tmux-navigator'
if = '!has("gui_running")'
on_cmd = [
  'TmuxNavigateLeft', 'TmuxNavigateDown',
  'TmuxNavigateUp', 'TmuxNavigateRight',
]
hook_add = '''
let g:tmux_navigator_no_mappings = v:true
nnoremap <A-h> <Cmd>TmuxNavigateLeft<CR>
nnoremap <A-j> <Cmd>TmuxNavigateDown<CR>
nnoremap <A-k> <Cmd>TmuxNavigateUp<CR>
nnoremap <A-l> <Cmd>TmuxNavigateRight<CR>
'''

[[plugins]]
repo = 'https://github.com/cocopon/lightline-hybrid.vim'

[[plugins]]
repo = 'https://github.com/cohama/lexima.vim'
on_event = ['InsertEnter', 'CmdlineEnter']
hooks_file = '$DEIN_DIR/settings/lexima.vim'

[[plugins]]
repo = 'https://github.com/github/copilot.vim'
on_cmd = ['Copilot']
on_event = ['InsertEnter']
hook_add = '''
let g:copilot_no_maps = v:true
inoremap <silent><expr> <C-g><C-g> copilot#Accept()
inoremap <silent><expr> <C-g><C-w> copilot#AcceptWord()
inoremap <C-g><C-]> <Cmd>call copilot#Next()<CR>
inoremap <C-g><C-[> <Cmd>call copilot#Previous()<CR>
autocmd vimrc OptionSet buftype
      \ : if !empty(&buftype) && &buftype !=# 'acwrite' && bufname() !=# 'mininote'
      \ |   let b:copilot_enabled = v:false
      \ | endif
'''

[[plugins]]
repo = 'https://github.com/halkn/lightline-lsp'
on_source = ['lightline.vim']
if = '!has("nvim")'

[[plugins]]
repo = 'https://github.com/haya14busa/dein-command.vim'
on_cmd = ['Dein']

[[plugins]]
repo = 'https://github.com/haya14busa/vim-asterisk'
on_map = { nx = '<Plug>' }
hook_add = '''
let g:asterisk#keeppos = v:true
nnoremap *  <Plug>(asterisk-z*)<Plug>(search-post)
nnoremap #  <Plug>(asterisk-z#)<Plug>(search-post)
nnoremap g* <Plug>(asterisk-gz*)<Plug>(search-post)
nnoremap g# <Plug>(asterisk-gz#)<Plug>(search-post)
xnoremap *  <Plug>(asterisk-z*)<Plug>(search-post)
xnoremap #  <Plug>(asterisk-z#)<Plug>(search-post)
xnoremap g* <Plug>(asterisk-gz*)<Plug>(search-post)
xnoremap g# <Plug>(asterisk-gz#)<Plug>(search-post)
'''

[[plugins]]
repo = 'https://github.com/haya14busa/vim-edgemotion'
on_map = { nx = '<Plug>' }
hook_add = '''
nnoremap <C-j> <Plug>(edgemotion-j)
nnoremap <C-k> <Plug>(edgemotion-k)
xnoremap <C-j> <Plug>(edgemotion-j)
xnoremap <C-k> <Plug>(edgemotion-k)
'''

[[plugins]]
repo = 'https://github.com/hrsh7th/vim-searchx'
on_func = ['searchx#']
hook_add = '''
let g:searchx = #{
      \ auto_accept: v:true,
      \ markers: split('ASDFGHJKLQWERTYUIOPZXCVBNM', '.\zs'),
      \ nohlsearch: #{ jump: v:true },
      \ scrolltime: 200,
      \ scrolloff: &scrolloff,
      \ }

function! g:searchx.convert(input) abort
  if a:input !~# '\k' && a:input !~# '\v^^|[*$]$'
    return '\V' .. a:input
  endif
  return a:input->split('\s\+')->join('.\{-}')
endfunction

autocmd vimrc User SearchxLeave call searchx#clear()
autocmd vimrc User SearchxAccept normal! zzzv

nnoremap ? <Cmd>call searchx#start(#{ dir: 0 })<CR>
nnoremap / <Cmd>call searchx#start(#{ dir: 1 })<CR>
xnoremap ? <Cmd>call searchx#start(#{ dir: 0 })<CR>
xnoremap / <Cmd>call searchx#start(#{ dir: 1 })<CR>

cnoremap <C-g> <Cmd>call searchx#next_dir()<CR><Plug>(search-post)
cnoremap <C-t> <Cmd>call searchx#prev_dir()<CR><Plug>(search-post)

nnoremap N <Cmd>call searchx#prev_dir()<CR><Plug>(search-post)
nnoremap n <Cmd>call searchx#next_dir()<CR><Plug>(search-post)
xnoremap N <Cmd>call searchx#prev_dir()<CR><Plug>(search-post)
xnoremap n <Cmd>call searchx#next_dir()<CR><Plug>(search-post)
'''

[[plugins]]
repo = 'https://github.com/itchyny/lightline.vim'
lazy = true
hook_add = '''
autocmd vimrc VimEnter * ++once call timer_start(0, { -> dpp#source('lightline.vim') })
autocmd vimrc ModeChanged t:n* call lightline#update()
'''
hook_source = '''
let g:lightline = #{
      \ subseparator: #{ left: '/', right: '/' },
      \ tabline_subseparator: #{ left: '|', right: '|' },
      \ active: #{
      \   left: [
      \     ['mode', 'paste'],
      \     ['readonly', 'filename', 'modified'],
      \     ['protocol', 'ddu-ui-ff'] + (has('nvim') ? [] : ['lsp_progress']),
      \   ],
      \   right: [
      \     ['lsp_errors', 'lsp_warnings', 'lineinfo'],
      \     ['percent'],
      \     ['colorscheme', 'fileformat', 'fileencoding', 'filetype'],
      \   ],
      \ },
      \ inactive: #{ left: [['filename', 'modified']] },
      \ tabline: #{ left: [['tabs']], right: [] },
      \ tab: #{
      \   active: ['tabnum', 'tabname'],
      \   inactive: ['tabnum', 'tabname'],
      \ },
      \ component: #{
      \   lineinfo: '%3l:%-2v',
      \ },
      \ component_function: #{
      \   colorscheme: 'lightline#component#vimrc#colorscheme',
      \   ddu-ui-ff: 'lightline#ddu_ui_ff#component',
      \   fileencoding: 'lightline#component#vimrc#file_encoding',
      \   fileformat: 'lightline#component#vimrc#file_format',
      \   filename: 'lightline#component#vimrc#filename',
      \   lsp_progress: 'lightline_lsp_progress#progress',
      \   mode: 'lightline#component#vimrc#mode',
      \   modified: 'lightline#component#vimrc#modified',
      \   protocol: 'lightline#component#vimrc#protocol',
      \   readonly: 'lightline#component#vimrc#readonly',
      \ },
      \ component_expand: #{
      \   lsp_errors: has('nvim') ? 'lightline#lsp#errors' :'lightline_lsp#errors',
      \   lsp_warnings: has('nvim') ? 'lightline#lsp#warnings' :'lightline_lsp#warnings',
      \ },
      \ component_type: #{
      \   lsp_errors: 'error',
      \   lsp_warnings: 'warning',
      \ },
      \ tab_component_function: #{
      \   tabname: 'lightline#component#vimrc#tabname',
      \ },
      \ }

let &laststatus = has('nvim') ? 3 : 2
call user#colorscheme#update_lightline()
messages
'''

[[plugins]]
repo = 'https://github.com/itchyny/vim-external'
on_map = { nx = '<Plug>' }
hook_add = '''
nnoremap gx <Plug>(external-browser)
xnoremap gx <Plug>(external-browser)
'''

[[plugins]]
repo = 'https://github.com/kana/vim-niceblock'
on_map = { x = '<Plug>' }
hook_add = '''
xnoremap I  <Plug>(niceblock-I)
xnoremap gI <Plug>(niceblock-gI)
xnoremap A  <Plug>(niceblock-A)
'''

[[plugins]]
repo = 'https://github.com/kana/vim-submode'
on_map = { n = '<Plug>' }
hook_add = '''
let g:submode_always_show_submode = v:true
let g:submode_keep_leaving_key = v:true
nnoremap <C-w>> <Plug>(submode-dummy)
nnoremap <C-w>< <Plug>(submode-dummy)
nnoremap <C-w>+ <Plug>(submode-dummy)
nnoremap <C-w>- <Plug>(submode-dummy)
nnoremap zl <Plug>(submode-dummy)
nnoremap zh <Plug>(submode-dummy)
nnoremap zL <Plug>(submode-dummy)
nnoremap zH <Plug>(submode-dummy)
nnoremap zj <Plug>(submode-dummy)
nnoremap zk <Plug>(submode-dummy)
'''
hook_source = '''
" resize window
for s:k in ['>', '<', '+', '-']
  call submode#enter_with('resizewin', 'n', '', $'<C-w>{s:k}', $'<C-w>{s:k}')
  call submode#map('resizewin', 'n', '', s:k, $'<C-w>{s:k}')
endfor
" scroll without cursor moving
for s:k in ['l', 'h', 'L', 'H']
  call submode#enter_with('stickycursor', 'n', '', $'z{s:k}', $'z{s:k}')
  call submode#map('stickycursor', 'n', '', s:k, $'z{s:k}')
endfor
for [s:k1, s:k2] in [['j', '<C-e>'], ['k', '<C-y>']]
  call submode#enter_with('stickycursor', 'n', '', $'z{s:k1}', s:k2)
  call submode#map('stickycursor', 'n', '', s:k1, s:k2)
endfor
'''

[[plugins]]
repo = 'https://github.com/kuuote/lspoints'
merged = false
hook_add = '''
let g:lspoints#extensions = ['copilot']
'''

[[plugins]]
repo = 'https://github.com/kyoh86/vim-ripgrep'
on_cmd = ['Rg']
hook_source = '''
autocmd vimrc QuickFixCmdPre,QuickFixCmdPost Rg :
function! s:ripgrep(args) abort
  doautocmd <nomodeline> QuickFixCmdPre Rg
  eval ['--smart-case', a:args]->join()->ripgrep#search()
  doautocmd <nomodeline> QuickFixCmdPost Rg
endfunction
command! -nargs=1 -complete=file Rg call s:ripgrep(<q-args>)
'''

[[plugins]]
repo = 'https://github.com/lambdalisue/vim-file-protocol'
on_path = ['^file://']

[[plugins]]
repo = 'https://github.com/lambdalisue/vim-gin'
on_cmd = ['Gin', 'GinDiff', 'GinLog', 'GinStatus']
hook_add = '''
let g:gin_chaperon_persistent_args = ['++opener=tabedit']
let g:gin_diff_persistent_args = ['++opener=tabedit']
let g:gin_log_default_args = ['--oneline']
autocmd vimrc OptionSet diff call s:on_gin_chaperon(v:option_new)
function! s:on_gin_chaperon(diff) abort
  if a:diff
    nnoremap <buffer> ZZ <Cmd>Gin ++wait add %<Bar>diffoff!<Bar>tabclose<CR>
  else
    nunmap <buffer> ZZ
  endif
endfunction
'''
[plugins.ftplugin]
gin-log = '''
nnoremap <buffer> a <Cmd>Ddu -name=gin_action<CR>
nnoremap <buffer> I <Plug>(gin-action-fixup:instant-fixup)
'''
gin-status = '''
nnoremap <buffer> a <Cmd>Ddu -name=gin_action<CR>
'''
gitcommit = '''
nnoremap <buffer> ZZ <Cmd>Apply<CR>
'''
gitrebase = '''
nnoremap <buffer> ZZ <Cmd>Apply<CR>
'''

[[plugins]]
repo = 'https://github.com/lambdalisue/vim-kensaku'
denops_wait = false
on_func = ['kensaku#']
hook_add = '''
let s:kensaku_state = #{ converted: v:false, cmdline: #{ prev: '', converted: '' } }
function! s:convert_kensaku() abort
  if s:kensaku_state.converted &&
        \ getcmdline()->stridx(s:kensaku_state.cmdline.converted) > -1
    let s:kensaku_state.converted = v:false
    let s:kensaku_state.cmdline.converted = ''
    call setcmdline(s:kensaku_state.cmdline.prev)
  else
    let s:kensaku_state.converted = v:true
    let s:kensaku_state.cmdline.prev = getcmdline()
    let s:kensaku_state.cmdline.converted = kensaku#query(s:kensaku_state.cmdline.prev)
    call setcmdline(s:kensaku_state.cmdline.converted)
  endif
endfunction
autocmd vimrc CmdlineLeave * let s:kensaku_state.converted = v:false
cnoremap <C-x><C-k> <Cmd>call <SID>convert_kensaku()<CR>
'''

[[plugins]]
repo = 'https://github.com/lambdalisue/vim-pinkyless'
on_map = { icn = '<Plug>' }
hook_add = '''
let g:pinkyless#keyboard = 'JIS'
let g:pinkyless_default_keymap = v:false
noremap! <C-g><C-l> <Plug>(pinkyless-capslock-toggle)
noremap! ; <Plug>(pinkyless-stickyshift-enter)
nnoremap r <Plug>(pinkyless-stickyreplace-enter)
'''
# NOTE: Override keymap to enable remap
hook_post_source = '''
function! s:pinkyless_enter(trigger) abort
  let char = pinkyless#stickyshift#enter(a:trigger)
  return char !~# a:trigger ? char : feedkeys(char, 'ni') ?? ''
endfunction
map! <expr> <Plug>(pinkyless-stickyshift-enter) <SID>pinkyless_enter(';')
'''

[[plugins]]
repo = 'https://github.com/lambdalisue/vim-suda'
on_cmd = ['SudaRead', 'SudaWrite']

[[plugins]]
repo = 'https://github.com/lambdalisue/vim-protocol'
on_path = ['^https\?://']

[[plugins]]
repo = 'https://github.com/lambdalisue/vim-quickrun-neovim-job'

[[plugins]]
repo = 'https://github.com/machakann/vim-highlightedundo'
on_map = { n = '<Plug>' }
hook_add = '''
nnoremap u     <Plug>(highlightedundo-undo)
nnoremap <C-r> <Plug>(highlightedundo-redo)
nnoremap U     <Plug>(highlightedundo-Undo)
nnoremap g-    <Plug>(highlightedundo-gminus)
nnoremap g+    <Plug>(highlightedundo-gplus)
'''

[[plugins]]
repo = 'https://github.com/mattn/vim-maketable'
on_cmd = ['MakeTable', 'UnmakeTable']

[[plugins]]
repo = 'https://github.com/mattn/vim-sonictemplate'
on_cmd = ['Template']
hook_add = '''
let g:sonictemplate_vim_template_dir = [
      \ g:config_home .. '/template',
      \ ]
let g:sonictemplate_vim_vars = #{
      \ _: #{
      \   author: 'Hibiki',
      \ },
      \ help: #{
      \   author: 'Hibiki <mail@4513echo.dev>',
      \   author_without_mail: 'Hibiki(4513ECHO)',
      \   license: 'MIT License',
      \ },
      \ }
let g:sonictemplate_key = ''
let g:sonictemplate_intelligent_key = ''
let g:sonictemplate_postfix_key = ''
'''

[[plugins]]
repo = 'https://github.com/mhinz/vim-signify'
on_event = ['BufRead']
hook_add = '''
call setcellwidths([[0x2503, 0x2503, 1]])
let g:signify_sign_add               = '┃'
let g:signify_sign_change            = '┃'
let g:signify_sign_delete            = '┃'
let g:signify_sign_delete_first_line = '┃'
let g:signify_line_highlight = v:false
" from `:help signify-mappings`
autocmd vimrc User SignifyHunk call s:show_current_hunk()
function! s:show_current_hunk() abort
  let h = sy#util#get_hunk_stats()
  if !empty(h)
    echo $'[Hunk {h.current_hunk}/{h.total_hunks}]'
  endif
endfunction
'''

[[plugins]]
repo = 'https://github.com/micchy326/lightline-lsp-progress'
on_source = ['lightline.vim']
if = '!has("nvim")'

[[plugins]]
repo = 'https://github.com/osyo-manga/vim-jplus'
on_map = { nx = '<Plug>' }
hook_add = '''
nnoremap J  <Plug>(jplus-getchar)<Space>
xnoremap J  <Plug>(jplus-getchar)<Space>
nnoremap gJ <Plug>(jplus)
xnoremap gJ <Plug>(jplus)
let g:jplus#config = #{
      \ _: #{
      \   delimiter: '',
      \   right_matchstr_pattern: '^\s*#\s*\zs.*\|\s*\zs.*',
      \   left_matchstr_pattern: '^.\{-}\%(\ze\s*\\$\|$\)',
      \ },
      \ vim: #{
      \   right_matchstr_pattern: '^\s*\\\s*\zs.*\|^\s*"\s*\zs.*\|\s*\zs.*',
      \ }}
'''

[[plugins]]
repo = 'https://github.com/Shougo/context_filetype.vim'
on_func = ['context_filetype#get']
hook_source = '''
let g:context_filetype#filetypes =
      \ context_filetype#default_filetypes()->extendnew(#{
      \ markdown: [['\(\h\w*\)', '\1'], ['viml', 'vim']]
      \   ->map({ -> #{
      \     start: '^\s*```\s*' .. v:val[0],
      \     end: '^\s*```$',
      \     filetype: v:val[1],
      \   } }),
      \ })
'''

[[plugins]]
repo = 'https://github.com/skanehira/denops-translate.vim'
depends = ['denops.vim']
on_cmd = ['Translate']
hook_add = '''
nnoremap <Leader>t <Cmd>Translate<CR>
xnoremap <Leader>t :Translate<CR>
'''

[[plugins]]
repo = 'https://github.com/statiolake/vim-quickrun-runner-nvimterm'

[[plugins]]
repo = 'https://github.com/rhysd/clever-f.vim'
on_map = { nxo = '<Plug>' }
hook_add = '''
nnoremap F <Plug>(clever-f-F)
nnoremap T <Plug>(clever-f-T)
nnoremap f <Plug>(clever-f-f)
nnoremap t <Plug>(clever-f-t)
onoremap F <Plug>(clever-f-F)
onoremap T <Plug>(clever-f-T)
onoremap f <Plug>(clever-f-f)
onoremap t <Plug>(clever-f-t)
xnoremap F <Plug>(clever-f-F)
xnoremap T <Plug>(clever-f-T)
xnoremap f <Plug>(clever-f-f)
xnoremap t <Plug>(clever-f-t)
nnoremap ;         <Plug>(clever-f-repeat-forward)
nnoremap <Leader>, <Plug>(clever-f-repeat-back)
xnoremap ;         <Plug>(clever-f-repeat-forward)
xnoremap <Leader>, <Plug>(clever-f-repeat-back)
onoremap ;         <Plug>(clever-f-repeat-forward)
onoremap <Leader>, <Plug>(clever-f-repeat-back)
let g:clever_f_across_no_line = v:true
let g:clever_f_ignore_case = v:true
let g:clever_f_smart_case = v:true
let g:clever_f_use_migemo = v:true
let g:clever_f_chars_match_any_signs = "\<C-g>"
'''

[[plugins]]
repo = 'https://github.com/RRethy/vim-hexokinase'
on_event = ['BufRead', 'InsertLeave']
hook_add = '''
let g:Hexokinase_highlighters = ['backgroundfull']
let g:Hexokinase_optOutPatterns = ['colour_names']
let g:Hexokinase_ftOptInPatterns = #{
      \ css: [
      \   'full_hex', 'triple_hex', 'rgb',
      \   'rgba', 'hsl', 'hsla', 'colour_names'
      \ ],
      \ html: [
      \   'full_hex', 'triple_hex', 'rgb',
      \   'rgba', 'hsl', 'hsla', 'colour_names'
      \ ],
      \ }
let g:Hexokinase_ftDisabled = ['molder', 'ddu-ff', 'ddu-ff-filter']
let g:Hexokinase_executable_path = expand('$AQUA_ROOT_DIR/bin/hexokinase')
'''

[[plugins]]
repo = 'https://github.com/spywhere/lightline-lsp'
name = 'lightline-nvim-lsp'
on_source = ['lightline.vim']
if = 'has("nvim")'
hook_add = '''
let g:lightline#lsp#indicator_errors = '✗'
let g:lightline#lsp#indicator_warnings = '‼'
'''

[[plugins]]
repo = 'https://github.com/thinca/vim-localrc'
on_event = ['BufRead']
hook_add = '''
let g:localrc_filename = '.vimrc.local'
'''

[[plugins]]
repo = 'https://github.com/thinca/vim-partedit'
depends = ['context_filetype.vim']
on_cmd = ['Partedit']
on_func = ['partedit#start']
hook_add = '''
let g:partedit#opener = 'split'
function! s:operator_partedit() abort
  let context = context_filetype#get()
  if context.range ==# [[0, 0], [0, 0]]
    echohl WarningMsg
    echomsg '[partedit] Context is not found'
    echohl NONE
    return
  endif
  call partedit#start(context.range[0][0], context.range[1][0],
        \ #{ filetype: context.filetype })
  nnoremap <buffer> q <Cmd>ParteditEnd<Bar>close<CR>
endfunction
nnoremap <C-x><C-x> <Cmd>call <SID>operator_partedit()<CR>
'''
[plugins.ftplugin]
help = '''
let b:partedit_filetype = 'vim'
let b:partedit_prefix = "\<Tab>"
'''
toml = '''
let b:partedit_filetype = 'vim'
let b:partedit_auto_prefix = v:false
'''

[[plugins]]
repo = 'https://github.com/thinca/vim-quickrun'
on_cmd = ['QuickRun']
on_map = { nx = '<Plug>' }
hook_add = '''
nnoremap <Leader>rr <Plug>(quickrun)
nnoremap <Leader>r <Plug>(quickrun-op)
xnoremap <Leader>r <Plug>(quickrun)
let g:quickrun_config = {
      \ '_': {
      \   'hook/time/enable': v:false,
      \   'outputter': 'buffer',
      \   'outputter/buffer/close_on_empty': v:true,
      \   'outputter/buffer/opener': 'botright 10new',
      \   'outputter/error/error': 'quickfix',
      \   'outputter/error/success': 'buffer',
      \   'runner': has('nvim') ? 'neovim_job' : 'job',
      \   'runner/nvimterm/opener': 'botright 10new',
      \   'runner/terminal/opener': 'botright 10new',
      \ },
      \ 'typescript': #{
      \   type: 'deno/run',
      \ },
      \ 'typescriptreact': #{
      \   type: 'deno/run',
      \ },
      \ 'sh': #{
      \   runner: has('nvim') ? 'nvimterm' : 'terminal',
      \ },
      \ 'zsh': #{
      \   runner: has('nvim') ? 'nvimterm' : 'terminal',
      \ },
      \ 'json': #{
      \   type: 'json/gojq',
      \ },
      \ 'json/gojq': #{
      \   command: 'gojq',
      \   exec: '%c %o %a < %s',
      \ },
      \ 'lua': #{
      \   type: 'lua/vim',
      \ },
      \ 'deno/run': #{
      \   cmdopt: '--no-check --allow-all',
      \   command: 'deno',
      \   exec: 'NO_COLOR=1 %c run %o %s %a',
      \   tempfile: '%{tempname()}.ts',
      \ },
      \ }
" from https://github.com/aiotter/dotfiles/blob/8e759221/.config/nvim/plugins/others.toml#L27
autocmd vimrc WinEnter *
      \ : if winnr('$') == 1 && &filetype == 'quickrun'
      \ |   quit
      \ | endif
'''
[plugins.ftplugin]
quickrun = '''
nnoremap <buffer> q <C-w>q
nnoremap <buffer> <C-c> <Cmd>call quickrun#session#sweep()<CR>
'''

[[plugins]]
repo = 'https://github.com/tweekmonster/helpful.vim'
on_cmd = ['HelpfulVersion']

[[plugins]]
repo = 'https://github.com/tyru/capture.vim'
on_cmd = ['Capture', 'CaptureJson']
hook_source = '''
command! -bang -bar -nargs=1 -complete=expression CaptureJson
      \ call s:capture_json(<f-args>, '<bang>')
function! s:capture_json(value, bang) abort
  execute printf('Capture%s echo json_encode(%sto_string(%s))',
        \ a:bang, expand('<SID>'), a:value)
  if &filetype ==# 'capture'
    silent execute '%!gojq'
    setlocal filetype=json
  endif
endfunction
function! s:to_string(expr) abort
  let type = type(a:expr)
  if type ==# v:t_list || type ==# v:t_dict
    return copy(a:expr)->map({ -> s:to_string(v:val) })
  elseif type ==# v:t_func
    return string(a:expr)
  endif
  return a:expr
endfunction
'''
[plugins.ftplugin]
capture = '''
nnoremap <buffer> q <C-w>q
'''

[[plugins]]
repo = 'https://github.com/tyru/caw.vim'
on_map = { nxo = '<Plug>' }
depends = ['context_filetype.vim', 'vim-operator-user']
hook_add = '''
let g:caw_no_default_keymappings = v:true
nnoremap <silent> <Bslash> <Plug>(caw:hatpos:toggle:operator)
onoremap <silent> <Bslash> <Plug>(caw:hatpos:toggle:operator)
xnoremap <silent> <Bslash> <Plug>(caw:hatpos:toggle:operator)
'''
# NOTE: Workaround of https://github.com/tyru/caw.vim/issues/183
# based on https://github.com/tyru/caw.vim/pull/185
lua_add = '''
local M = {}
---@param lnum integer
---@param col integer
---@return boolean
function M.has_syntax(lnum, col)
  return vim
    .iter(vim.treesitter.get_captures_at_pos(0, lnum - 1, col - 1))
    :any(function(capture) return capture.capture == "comment" end)
end
---@diagnostic disable-next-line: duplicate-set-field
_G.package.preload.caw = function() return M end
'''
[plugins.ftplugin]
gitcommit = '''
let b:caw_oneline_comment = ';'
'''

[[plugins]]
repo = 'https://github.com/yuttie/comfortable-motion.vim'
on_func = ['comfortable_motion#flick']
hook_add = '''
let g:comfortable_motion_no_default_key_mappings = v:true
nnoremap <C-d> <Cmd>call comfortable_motion#flick(winheight(0) * 2)<CR>
nnoremap <C-u> <Cmd>call comfortable_motion#flick(winheight(0) * -2)<CR>
nnoremap <C-f> <Cmd>call comfortable_motion#flick(winheight(0) * 4)<CR>
nnoremap <C-b> <Cmd>call comfortable_motion#flick(winheight(0) * -4)<CR>
'''