Vimで日本語入力する思考記録

{
  "nya": "にゃ",
  "ya": "や",
  "a": "あ",
}

inoremap nya にゃ
inoremap ya や
inoremap a あ

let preceding_str = getline('.')->slice(0, charcol('.')-1)

function! k#ins_a() abort
  let preceding_str = getline('.')->slice(0, charcol('.')-1)

  if slice(preceding_str, -2) ==# 'ny'
    return "\<bs>\<bs>にゃ"
  endif
  if slice(preceding_str, -1) ==# 'y'
    return "\<bs>や"
  endif
  return 'あ'
endfunction

inoremap <expr> a k#ins_a()

echo slice('hoge', -10)
" -> hoge

let s:kana_start_pos = [0, 0]

function! k#ins_y() abort
  let current_pos = getcharpos('.')[1:2]
  if s:kana_start_pos[0] != current_pos[0] || s:kana_start_pos[1] > current_pos[1]
    let s:kana_start_pos = current_pos
  endif
  return 'y'
endfunction

inoremap <expr> y k#ins_y()

 function! k#ins_a() abort
+  if s:kana_start_pos[0] != line('.')
+    let s:kana_start_pos = [0, 0]
+    return 'あ'
+  endif

- let preceding_str = getline('.')->slice(0, charcol('.')-1)
+ let preceding_str = getline('.')->slice(s:kana_start_pos[1]-1, charcol('.')-1)
+ let s:kana_start_pos = [0, 0]

 " 略
  endfunction

let s:is_enable = v:false

function! k#is_enable() abort
  return s:is_enable
endfunction

function! k#toggle() abort
  return k#is_enable() ? k#disable() : k#enable()
endfunction

inoremap <expr> <c-j> k#toggle()

let s:keys_to_remaps = []
let s:keys_to_unmaps = []

function! k#enable() abort
  let s:keys_to_remaps = []
  let s:keys_to_unmaps = []

  for k in ['n', 'y', 'a']
    let current_map = maparg(k, 'i', 0, 1)
    if empty(current_map)
      call add(s:keys_to_unmaps, k)
    else
      call add(s:keys_to_remaps, current_map)
    endif
    execute $'inoremap <expr> {k} k#ins_{k}()'
  endfor

  let s:is_enable = v:true
  return ''
endfunction

function! k#disable() abort
  for m in s:keys_to_remaps
    call mapset('i', 0, m)
  endfor
  for k in s:keys_to_unmaps
    execute 'iunmap' k
  endfor

  let s:keys_to_remaps = []
  let s:keys_to_unmaps = []

  let s:is_enable = v:false
  return ''
endfunction

augroup k_augroup
  autocmd!
  autocmd InsertLeave * call k#disable()
augroup END

 function! k#ins_y() abort
   let current_pos = getcharpos('.')[1:2]
   if s:kana_start_pos[0] != current_pos[0] || s:kana_start_pos[1] > current_pos[1]
     let s:kana_start_pos = current_pos
   endif

+  let preceding_str = getline('.')->slice(s:kana_start_pos[1]-1, charcol('.')-1)
+  if slice(preceding_str, -1) ==# 'y'
+    return "\<bs>っy"
+  endif

   return 'y'
 endfunction

function! k#initialize() abort
  let raw = {
        \ "nya": "にゃ",
        \ "ya": "や",
        \ "yy": "っy",
        \ "a": "あ",
        \ }

  let s:start_keys = {}
  let s:end_keys = {}

  for [key, val] in items(raw)

    let preceding_keys = slice(key, 0, -1)
    let start_key = slice(key, 0, 1)
    let end_key = slice(key, -1)

    let s:start_keys[start_key] = 1
    if !has_key(s:end_keys, end_key)
      let s:end_keys[end_key] = {}
    endif
    let s:end_keys[end_key][preceding_keys] = val
  endfor
endfunction

call k#initialize()

echo s:start_keys
" -> {'a': 1, 'y': 1, 'n': 1}

echo s:end_keys
" -> {'a': {'': 'あ', 'y': 'や', 'ny': 'にゃ'}, 'y': {'y': 'っy'}}

function! k#ins(key) abort
  " かな入力開始位置の更新
  let current_pos = getcharpos('.')[1:2]
  if s:kana_start_pos[0] != current_pos[0] || s:kana_start_pos[1] > current_pos[1]
    let s:kana_start_pos = current_pos
  endif

  " かな変換辞書の取得
  let kana_dict = get(s:end_keys, a:key, {})

  if !empty(kana_dict)
    " 先行入力の取得
    let preceding_str = getline('.')->slice(s:kana_start_pos[1]-1, charcol('.')-1)

    " 先行入力の末尾で変換を試みる
    " 長いマッチから短いマッチへ順に調べていく
    let i = len(preceding_str)
    while i > 0
      let tail_str = slice(preceding_str, -i)
      if has_key(kana_dict, tail_str)
        " マッチしたらその文字を返すが、マッチした文字はそのぶん<bs>して削除する
        return repeat("\<bs>", i) .. kana_dict[tail_str]
      endif
      let i -= 1
    endwhile
  endif

  " 空文字のキーがデフォルト値
  return get(kana_dict, '', a:key)
endfunction

-    execute $"inoremap <expr> {k} k#ins_k()"
+    execute $"inoremap <expr> {k} k#ins('{k}')"

{
  "a": "あ",
  "i": "い",
  "u": "う",
  "e": "え",
  "o": "お",
  "ka": "か",
  "ki": "き",
  "ku": "く",
  "ke": "け",
  "ko": "こ",
  "kk": "っk",
  "sa": "さ",
  "si": "し",
  "su": "す",
  "se": "せ",
  "so": "そ",
  "ss": "っs",
......
}

 function! k#initialize() abort
-   let raw = {
-         \ "nya": "にゃ",
-         \ "ya": "や",
-         \ "yy": "っy",
-         \ "a": "あ",
-         \ }
+  let raw = json_decode(join(readfile('./kana_table.json'), "\n"))

   " 略
 endfunction

 function! k#enable() abort
   let s:keys_to_remaps = []
   let s:keys_to_unmaps = []

-  for k in ['n', 'y', 'a']
+  for k in extendnew(s:start_keys, s:end_keys)->keys()
    " 略
   endfor

   let s:is_enable = v:true
   return ''
 endfunction

function! s:capital(char) abort
  return substitute(a:char, '.', '\U\0', '')
endfunction

   for k in extendnew(s:start_keys, s:end_keys)->keys()
     " 略
     execute $"inoremap <expr> {k} k#ins('{k}')"
+    if k =~ '\l'
+      execute $"inoremap <expr> {s:capital(k)} k#ins('{k}',1)"
+    endif
   endfor

+let s:henkan_start_pos = [0, 0]

-function! k#ins(key) abort
+function! k#ins(key, henkan = v:false) abort
   let current_pos = getcharpos('.')[1:2]
   if s:kana_start_pos[0] != current_pos[0] || s:kana_start_pos[1] > current_pos[1]
     let s:kana_start_pos = current_pos
   endif

+  if a:henkan
+    let s:henkan_start_pos = current_pos
+  endif

   " 略
 endfunction

function! k#henkan(fallback_key) abort
  let current_pos = getcharpos('.')[1:2]
  if s:henkan_start_pos[0] != current_pos[0] || s:henkan_start_pos[1] > current_pos[1]
    return a:fallback_key
  endif

  let preceding_str = getline('.')->slice(s:henkan_start_pos[1]-1, charcol('.')-1)
  echomsg preceding_str

  let s:henkan_start_pos = [0, 0]
  return ''
endfunction

function! k#kakutei(fallback_key) abort
  let current_pos = getcharpos('.')[1:2]
  if s:henkan_start_pos[0] != current_pos[0] || s:henkan_start_pos[1] > current_pos[1]
    return a:fallback_key
  endif

  let s:henkan_start_pos = [0, 0]
  return ''
endfunction

 function! k#enable() abort
  " 略

+  inoremap <expr> <space> k#henkan(" ")
+  call add(s:keys_to_unmaps, "<space>")
+  inoremap <expr> <cr> k#kakutei("\n")
+  call add(s:keys_to_unmaps, "<cr>")

   let s:is_enable = v:true
   return ''
 endfunction

 function! k#ins(key, henkan = v:false) abort
   " 略

   if a:henkan
-  let s:henkan_start_pos = current_pos
+    if s:henkan_start_pos[0] != current_pos[0] || s:henkan_start_pos[1] > current_pos[1]
+      let s:henkan_start_pos = current_pos
+    else
+      let preceding_str = getline('.')->slice(s:henkan_start_pos[1]-1, charcol('.')-1)
+      echomsg preceding_str .. a:key
+    endif
   endif

  " 略
 endfunction

かわり /代わり;replacement.「-の品」/変わり;change.「-ない」/変り/代り/替わり/替り/

^yomi /(kanji(;description)?/)+$

❯ rg --no-filename --no-line-number --encoding euc-jp '^かわりみ ' ~/.cache/vim/SKK-JISYO.L
かわりみ /変わり身/変り身/

let s:jisyo = {
      \ 'path': expand('~/.cache/vim/SKK-JISYO.L'),
      \ 'encoding': 'euc-jp'
      \ }

function! s:to_kanji(str) abort
  let cmd = $"rg --no-filename --no-line-number --encoding {s:jisyo.encoding} '^{a:str} ' {s:jisyo.path}"
  let results = systemlist(cmd)

  if len(results) == 0
    echomsg 'No Kanji'
    return ''
  endif

  let kanji_list = []
  for r in results
    let tmp = split(r, '/')
    " splitしたときの最初の要素は「読み」なので不要
    call extend(kanji_list, tmp[1:])
  endfor

  " TODO: 候補複数の場合の選択UIは後で作る
  let selected = kanji_list[0]

  " ;以降は説明なので消す
  return substitute(selected, ';.*', '', '')
endfunction

echomsg s:to_kanji('にほんご')
" -> 日本語
echomsg s:to_kanji('かk')
" -> 書

 function! k#henkan(fallback_key) abort
   let current_pos = getcharpos('.')[1:2]
   if s:henkan_start_pos[0] != current_pos[0] || s:henkan_start_pos[1] > current_pos[1]
     return a:fallback_key
   endif
 
   let preceding_str = getline('.')->slice(s:henkan_start_pos[1]-1, charcol('.')-1)
   echomsg preceding_str
 
+  let converted = s:to_kanji(preceding_str)
+  if converted ==# ''
+    return ''
+  endif
 
   let s:henkan_start_pos = [0, 0]
-  return ''
+  return repeat("\<bs>", strcharlen(preceding_str)) .. converted
 endfunction

+  let kana_dict = get(s:end_keys, a:key, {})
   if a:henkan
     if s:henkan_start_pos[0] != current_pos[0] || s:henkan_start_pos[1] > current_pos[1]
       let s:henkan_start_pos = current_pos
     else
       let preceding_str = getline('.')->slice(s:henkan_start_pos[1]-1, charcol('.')-1)
       echomsg preceding_str .. a:key
  
+      let converted = s:to_kanji(preceding_str .. a:key)
+      if converted ==# ''
+        return get(kana_dict, '', a:key)
+      endif
  
+      let s:henkan_start_pos = [0, 0]
+      return repeat("\<bs>", strcharlen(preceding_str)) .. converted .. get(kana_dict, '', a:key)
     endif
   endif

-  let kana_dict = get(s:end_keys, a:key, {})

function! k#get_henkan_list(str) abort
  let cmd = $"rg --no-filename --no-line-number --encoding {s:jisyo.encoding} '^{a:str} ' {s:jisyo.path}"
  let results = systemlist(cmd)

  let kanji_list = []
  for r in results
    let tmp = split(r, '/')
    call extend(kanji_list, tmp[1:])
  endfor

  return kanji_list
endfunction

function! k#completefunc()
  " 補完の始点のcol
  let preceding_str = getline('.')->slice(0, s:henkan_start_pos[1]-1)
  echomsg 'completefunc preceding_str' preceding_str
  let start_col = strlen(preceding_str)+1

  let comp_list = []
  for k in s:latest_kanji_list
    " ;があってもなくても良いよう_restを使う
    let [word, info; _rest] = split(k, ';') + ['']
    " :h complete-items
    call add(comp_list, {
          \ 'word': word,
          \ 'menu': info,
          \ 'info': info
          \ })
  endfor

  call complete(start_col, comp_list)

  return ''
endfunction

 function! k#henkan(fallback_key) abort
+  if pumvisible()
+    return "\<c-n>"
+  endif

   " 略

   let preceding_str = getline('.')->slice(s:henkan_start_pos[1]-1, charcol('.')-1)
+        \->substitute("n$", "ん", "")
   echomsg preceding_str

-  let converted = s:to_kanji(preceding_str)
-  if converted ==# ''
+  let s:latest_kanji_list = k#get_henkan_list(preceding_str)
+  if empty(s:latest_kanji_list)
+    echomsg 'No Kanji'
     return ''
   endif

-  let s:henkan_start_pos = [0, 0]
-  return repeat("\<bs>", strcharlen(preceding_str)) .. converted
+  return "\<c-r>=k#completefunc()\<cr>\<c-n>"
 endfunction

 augroup k_augroup
   autocmd!
   autocmd InsertLeave * call k#disable()
+  autocmd CompleteDonePre * if get(complete_info(), 'selected', -1) >= 0
+        \ |   let s:henkan_start_pos = [0, 0]
+        \ | endif

 augroup END

echo split('漢字', ';')
" -> ['漢字']
" -> [word, info] にマッピングしようとすると要素数不整合でエラー
" -> let [word, info] = split(k, ';') + [''] を使う

echo split('漢字;説明', ';') + ['']
" -> ['漢字', '説明', '']
" -> [word, info] にマッピングしようとすると要素数不整合でエラー
" -> let [word, info; _rest] = split(k, ';') + [''] を使う

 function! k#ins(key, henkan = v:false) abort
 " 略
   let kana_dict = get(s:end_keys, a:key, {})
   if a:henkan
     if s:henkan_start_pos[0] != current_pos[0] || s:henkan_start_pos[1] > current_pos[1]
       let s:henkan_start_pos = current_pos
     else
       let preceding_str = getline('.')->slice(s:henkan_start_pos[1]-1, charcol('.')-1)
       echomsg 'okuri-ari:' preceding_str .. a:key

-      let converted = s:to_kanji(preceding_str .. a:key)
-      if converted ==# ''
+      let s:latest_kanji_list = k#get_henkan_list(preceding_str .. a:key)
+      if empty(s:latest_kanji_list)
+        echomsg 'okuri-ari: No Kanji'
         return get(kana_dict, '', a:key)
       endif

-      let s:henkan_start_pos = [0, 0]
-      return repeat("\<bs>", strcharlen(preceding_str)) .. converted .. get(kana_dict, '', a:key)
+      return $"\<c-r>=k#completefunc('{a:key}')\<cr>\<c-n>"
     endif
   endif

-function! k#completefunc()
+function! k#completefunc(suffix_key = '')
 " 略

-          \ 'word': word,
+          \ 'word': word .. a:suffix_key,

 " 略

" " sample
" nnoremap sm <cmd>call inline_mark#display(line('.'), col('.'), '▽')<cr>
" nnoremap sn <cmd>call inline_mark#clear()<cr>

" namespaceのキーまたはproptypeにファイルパスを使い、
" 名前が他のプラグインとぶつかるのを防ぐ
let s:file_name = expand('%:p')
let s:hl = 'Normal'

if has('nvim')
  let s:ns_id = -1

  function! inline_mark#clear() abort
    if s:ns_id < 0
      return
    endif
    call nvim_buf_clear_namespace(0, s:ns_id, 0, -1)
    let s:ns_id = -1
  endfunction

  function! inline_mark#display(lnum, col, text) abort
    if s:ns_id < 0
      let s:ns_id = nvim_create_namespace(s:file_name)
    endif

    " nvim_buf_set_extmarkは0-basedなので、1を引く
    call nvim_buf_set_extmark(0, s:ns_id, a:lnum - 1, a:col - 1, {
          \   'virt_text': [[a:text, s:hl]],
          \   'virt_text_pos': 'inline',
          \ })
  endfunction
else
  function! inline_mark#clear() abort
    call prop_type_delete(s:file_name, {})
  endfunction

  function! inline_mark#display(lnum, col, text) abort
    if empty(prop_type_get(s:file_name))
      call prop_type_add(s:file_name, {'highlight': s:hl})
    endif

    call prop_add(a:lnum, a:col, {
          \   'type': s:file_name,
          \   'text': a:text,
          \ })
  endfunction
endif

source ./inline_mark.vim

function! s:char_col_to_byte_col(lnum, char_col) abort
  return getline(a:lnum)->slice(0, a:char_col-1)->strlen()+1
endfunction

let s:henkan_marker = "▽"
let s:select_marker = "▼"

function! s:set_henkan_start_pos(pos) abort
  let s:henkan_start_pos = a:pos

  let [lnum, char_col] = s:henkan_start_pos
  let byte_col = s:char_col_to_byte_col(lnum, char_col)
  call inline_mark#display(lnum, byte_col, s:henkan_marker)
endfunction

function! s:set_henkan_select_mark() abort
  call inline_mark#clear()
  let [lnum, char_col] = s:henkan_start_pos
  let byte_col = s:char_col_to_byte_col(lnum, char_col)
  call inline_mark#display(lnum, byte_col, s:select_marker)
endfunction

function! s:clear_henkan_start_pos() abort
  let s:henkan_start_pos = [0, 0]
  call inline_mark#clear()
endfunction

- let s:henkan_start_pos = a:pos
+ call s:set_henkan_start_pos(current_pos)

- let s:henkan_start_pos = [0, 0]
+ call s:clear_henkan_start_pos()

 function! k#completefunc(suffix_key = '')
+  call s:set_henkan_select_mark()

   " 略
 endfunction

-function! k#ins(key, henkan = v:false) abort
+function! s:get_insert_char(key, henkan = v:false) abort
 " 略

" hira / zen_kata / han_kata / abbrev
let s:inner_mode = 'hira'

function! k#ins(key, henkan = v:false) abort
  let char = s:get_insert_char(a:key, a:henkan)
  if s:inner_mode == 'zen_kata'
    return s:hira_to_kata(char)
  endif
  " TODO: implement other modes
  return char
endfunction

function! s:set_inner_mode(mode) abort
  let s:inner_mode = a:mode
endfunction

function! s:toggle_inner_mode(mode) abort
  call s:set_inner_mode(s:inner_mode == 'hira' ? a:mode : 'hira')
endfunction

function! k#zen_kata(...) abort
  let current_pos = getcharpos('.')[1:2]
  if s:henkan_start_pos[0] != current_pos[0] || s:henkan_start_pos[1] > current_pos[1]
    call s:toggle_inner_mode('zen_kata')
    return ''
  endif

  let preceding_str = getline('.')->slice(s:henkan_start_pos[1]-1, charcol('.')-1)
        \->substitute("n$", "ん", "")
  call s:clear_henkan_start_pos()
  return repeat("\<bs>", strcharlen(preceding_str)) .. s:hira_to_kata(preceding_str)
endfunction

 function! k#enable() abort
   " 略

+  inoremap <expr> q k#zen_kata('q')
+  call add(s:keys_to_unmaps, 'q')
+  call s:set_inner_mode('hira')

   let s:is_enable = v:true
   return ''
 endfunction

{
  "a": "あ",

  略......

  "z<space>": "　",
  "q": { "func": "zen_kata" },
  "<cr>": { "func": "kakutei" },
  "<space>": { "func": "henkan" },
  "<c-q>": { "func": "han_kata" },
}

" c-cはキャンセルなので含めていない
function! s:trans_special_key(str) abort
  return a:str->substitute('<space>', "\<space>", 'g')
        \ ->substitute('<s-space>', "\<s-space>", 'g')
        \ ->substitute('<cr>', "\<cr>", 'g')
        \ ->substitute('<bs>', "\<bs>", 'g')
        \ ->substitute('<c-a>', "\<c-a>", 'g')
        \ ->substitute('<c-b>', "\<c-b>", 'g')
        \ ->substitute('<c-d>', "\<c-d>", 'g')
        \ ->substitute('<c-e>', "\<c-e>", 'g')
        \ ->substitute('<c-f>', "\<c-f>", 'g')
        \ ->substitute('<c-g>', "\<c-g>", 'g')
        \ ->substitute('<c-h>', "\<c-h>", 'g')
        \ ->substitute('<c-i>', "\<c-i>", 'g')
        \ ->substitute('<c-j>', "\<c-j>", 'g')
        \ ->substitute('<c-k>', "\<c-k>", 'g')
        \ ->substitute('<c-l>', "\<c-l>", 'g')
        \ ->substitute('<c-m>', "\<c-m>", 'g')
        \ ->substitute('<c-n>', "\<c-n>", 'g')
        \ ->substitute('<c-o>', "\<c-o>", 'g')
        \ ->substitute('<c-p>', "\<c-p>", 'g')
        \ ->substitute('<c-q>', "\<c-q>", 'g')
        \ ->substitute('<c-r>', "\<c-r>", 'g')
        \ ->substitute('<c-s>', "\<c-s>", 'g')
        \ ->substitute('<c-t>', "\<c-t>", 'g')
        \ ->substitute('<c-u>', "\<c-u>", 'g')
        \ ->substitute('<c-v>', "\<c-v>", 'g')
        \ ->substitute('<c-w>', "\<c-w>", 'g')
        \ ->substitute('<c-x>', "\<c-x>", 'g')
        \ ->substitute('<c-y>', "\<c-y>", 'g')
        \ ->substitute('<c-z>', "\<c-z>", 'g')
endfunction

 function! k#initialize() abort
 " 略
-   for [key, val] in items(raw)
+   for [k, val] in items(raw)
+    let key = s:trans_special_key(k)
 " 略

 function! k#enable() abort
 " 略
-  for k in extendnew(s:start_keys, s:end_keys)->keys()
+  for key in extendnew(s:start_keys, s:end_keys)->keys()
+    let k = keytrans(key)
 " 略
-    execute $"inoremap <expr> {k} k#ins('{k}')"
-    if k =~ '\l'
+    execute $"inoremap <expr> {k} k#ins('{key}')"
+    if key =~ '^\l$'


 " 略

-function! s:get_insert_char(key, henkan = v:false) abort
+function! s:get_insert_spec(key, henkan = v:false) abort

 function! k#ins(key, henkan = v:false) abort
-  let char = s:get_insert_char(a:key, a:henkan)
+  let spec = s:get_insert_spec(a:key, a:henkan)

+  if type(spec) == v:t_dict
+    return call($'k#{out.spec}', [a:key])
+  endif

+  let char = spec

   if s:inner_mode == 'zen_kata'
     return s:hira_to_kata(char)
   endif

   " TODO: implement other modes
   return char
 endfunction

" e.g. <space> -> \<space>
function! s:trans_special_key(str) abort
  return substitute(a:str, '<[^>]*>', {m -> eval($'"\{m[0]}"')}, 'g')
endfunction

" たまにsplit文字列の描画がおかしくなるので注意
let s:hankana_list = ('ｧｱｨｲｩｳｪｴｫｵｶｶﾞｷｷﾞｸｸﾞｹｹﾞｺｺﾞ'
      \ .. 'ｻｻﾞｼｼﾞｽｽﾞｾｾﾞｿｿﾞﾀﾀﾞﾁﾁﾞｯﾂﾂﾞﾃﾃﾞﾄﾄﾞ'
      \ .. 'ﾅﾆﾇﾈﾉﾊﾊﾞﾊﾟﾋﾋﾞﾋﾟﾌﾌﾞﾌﾟﾍﾍﾞﾍﾟﾎﾎﾞﾎﾟ'
      \ .. 'ﾏﾐﾑﾒﾓｬﾔｭﾕｮﾖﾗﾘﾙﾚﾛﾜﾜｲｴｦﾝｳﾞｰｶｹ')
      \ ->split('.[ﾞﾟ]\?\zs')
let s:zen_kata_origin = char2nr('ァ', v:true)
let s:griph_map = { 'ー': '-', '〜': '~', '、': '､', '。': '｡', '「': '｢', '」': '｣', '・': '･' }

function! s:zen_kata_to_han_kata(str) abort
  return a:str->substitute('.', {m->get(s:griph_map,m[0],m[0])}, 'g')
        \ ->substitute('[ァ-ヶ]', {m->get(s:hankana_list, char2nr(m[0], v:true) - s:zen_kata_origin, m[0])}, 'g')
        \ ->substitute('[！-～]', {m->nr2char(char2nr(m[0], v:true) - 65248, v:true)}, 'g')
endfunction

 function! s:get_insert_spec(key, henkan = v:false) abort
   " 略
       if has_key(kana_dict, tail_str)
-         return repeat("\<bs>", i) .. kana_dict[tail_str]
+        if type(kana_dict[tail_str]) == v:t_dict
+          let result = { 'prefix': repeat("\<bs>", i) }
+          call extend(result, kana_dict[tail_str])
+          return result
+        else
+          return repeat("\<bs>", i) .. kana_dict[tail_str]
+        endif
       endif
  " 略
endfunction

   if type(spec) == v:t_dict
-    return call($'k#{spec.func}', [a:key])
+    return get(spec, 'prefix', '') .. call($'k#{spec.func}', [a:key])
   endif

-let s:jisyo = {
-        \ 'path': expand('~/.cache/vim/SKK-JISYO.L'),
-        \ 'encoding': 'euc-jp'
-        \ },
+let s:jisyo_list = [
+      \   { 'path': expand('~/.cache/vim/SKK-JISYO.L'), 'encoding': 'euc-jp' },
+      \   { 'path': expand('~/.cache/vim/SKK-JISYO.geo'), 'encoding': 'euc-jp' },
+      \   { 'path': expand('~/.cache/vim/SKK-JISYO.emoji'), 'encoding': 'utf-8' },
+      \ ]

 function! k#get_henkan_list(str) abort
-  let cmd = $"rg --no-filename --no-line-number --encoding {s:jisyo.encoding} '^{a:str} ' {s:jisyo.path}"
-  let results = systemlist(cmd)
   let henkan_list = []
-  for r in results
-   let tmp = split(r, '/')
-   call extend(henkan_list, tmp[1:])
+  for jisyo in s:jisyo_list
+    let cmd = $"rg --no-filename --no-line-number --encoding {jisyo.encoding} '^{a:str} ' {s:jisyo.path}"
+    let results = systemlist(cmd)
+    for r in results
+      let tmp = split(r, '/')
+      call extend(henkan_list, tmp[1:])
+    endfor
   endfor

   return henkan_list
 endfunction

function! k#cmd_buf() abort
  " とりあえずコマンドと検索のみ対応
  let cmdtype = getcmdtype()
  if ':/?' !~# cmdtype
    return
  endif

  " コンテキストを保存
  let s:cb_ctx = {
        \ 'type': cmdtype,
        \ 'text': getcmdline(),
        \ 'col': getcmdpos(),
        \ 'view': winsaveview(),
        \ 'winid': win_getid(),
        \ }

  " 1行のバッファを作成
  botright 1new
  setlocal buftype=nowrite bufhidden=wipe noswapfile

  " コマンドモードから脱出
  call feedkeys("\<c-c>", 'n')

  " 入力済みの内容とカーソル位置をバッファに反映
  call setline(1, s:cb_ctx.text)
  call cursor(1, s:cb_ctx.col)

  " インサートモード開始
  if strlen(s:cb_ctx.text) < s:cb_ctx.col
    startinsert!
  else
    startinsert
  endif
  call k#enable()

  " 改行されたとき（行数が1を超えたとき）またはインサートモードを抜けたときに
  " 入力された内容をcmdlineへ反映
  augroup k_cmd_buf
    autocmd!
    autocmd InsertEnter <buffer> ++once
          \ autocmd TextChanged,TextChangedI,TextChangedP,InsertLeave <buffer> ++nested
          \   if line('$') > 1 || mode() !=# 'i'
          \ |   stopinsert
          \ |   let s:cb_ctx.line = s:cb_ctx.type .. getline(1, '$')->join('')
          \ |   quit!
          \ |   call win_gotoid(s:cb_ctx.winid)
          \ |   call winrestview(s:cb_ctx.view)
          \ |   call timer_start(1, {->feedkeys(s:cb_ctx.line, 'nt')})
          \ | endif
  augroup END
endfunction

cnoremap <c-j> <cmd>call k#cmd_buf()<cr>

脱出時のコマンドを生で書くと即TextChangedが発火して終了してしまったので
InsertEnterでラップ
    autocmd InsertEnter <buffer> ++once

脱出時のイベントを定義
なおwindow移動時のイベントは発火してほしいのでnestedをつけておく
          \ autocmd TextChanged,TextChangedI,TextChangedP,InsertLeave <buffer> ++nested
          \   if line('$') > 1 || mode() !=# 'i'

インサート終了
          \ |   stopinsert

入力内容から改行を削除してコマンド文字列を抽出
          \ |   let s:cb_ctx.line = s:cb_ctx.type .. getline(1, '$')->join('')

ウィンドウを脱出
bufhidden=wipeとかを設定しているのでバッファは削除される
          \ |   quit!

もとのウィンドウへ移動、カーソル位置などを復帰
          \ |   call win_gotoid(s:cb_ctx.winid)
          \ |   call winrestview(s:cb_ctx.view)

コマンド文字列を入力
          \ |   call timer_start(1, {->feedkeys(s:cb_ctx.line, 'nt')})
          \ | endif

-let s:kana_start_pos = [0, 0]
-let s:henkan_start_pos = [0, 0]
+let w:kana_start_pos = [0, 0]
+let w:henkan_start_pos = [0, 0]

" 変数名を文字列連結で作ってしまうと後からgrepしづらくなるので
" 行数が嵩むが直接記述する
function! s:is_same_line_right_col(target) abort
  let target_name = ''
  if a:target ==# 'kana'
    let target_name = 'kana_start_pos'
  elseif a:target ==# 'henkan'
    let target_name = 'henkan_start_pos'
  else
    throw 'wrong target name'
  endif

  let target = get(w:, target_name, [0, 0])
  let current_pos = getcharpos('.')[1:2]

  return target[0] ==# current_pos[0] && target[1] < current_pos[1]
endfunction

function! s:get_preceding_str(target, trim_trail_n = v:true) abort
  let target_name = ''
  if a:target ==# 'kana'
    let target_name = 'kana_start_pos'
  elseif a:target ==# 'henkan'
    let target_name = 'henkan_start_pos'
  else
    throw 'wrong target name'
  endif

  let start_col = get(w:, target_name, [0, 0])[1]

  let preceding_str = getline('.')->slice(start_col-1, charcol('.')-1)
  if a:trim_trail_n
    return preceding_str->substitute("n$", "ん", "")
  endif
  return preceding_str
endfunction

function! s:hira_to_dakuten(str) abort
  return a:str->substitute('[^[:alnum:][:graph:][:space:]]', {m->m[0] .. '゛'}, 'g')
endfunction

 function! k#ins(key, henkan = v:false) abort
   let spec = s:get_insert_spec(key, a:henkan)

   let result = type(spec) == v:t_dict ? get(spec, 'prefix', '') .. call($'k#{spec.func}', [a:key])
        " 各モードは略
        \ : spec

-   return result
+   call feedkeys(result, 'n')
 endfunction

-    execute $"inoremap <expr> {k} k#ins('{key}')"
+    execute $"inoremap {k} <cmd>call k#ins('{key}')<cr>"

   " in k#enable()
   for key in extendnew(s:start_keys, s:end_keys)->keys()
     let k = keytrans(key)
+    let k_lt = substitute(k, '<', '<lt>', 'g')
     let current_map = maparg(k, 'i', 0, 1)
     if empty(current_map)
       call add(s:keys_to_unmaps, k)
     else
       call add(s:keys_to_remaps, current_map)
     endif
-    execute $"inoremap <expr> {k} k#ins('{key}')"
+    execute $"inoremap {k} <cmd>call k#ins('{k_lt}')<cr>"

 function! k#ins(key, henkan = v:false) abort
-  let spec = s:get_insert_spec(a:key, a:henkan)
+  let key = s:trans_special_key(a:key)
+  let spec = s:get_insert_spec(key, a:henkan)
 
-   let result = type(spec) == v:t_dict ? get(spec, 'prefix', '') .. call($'k#{spec.func}', [a:key])
+   let result = type(spec) == v:t_dict ? get(spec, 'prefix', '') .. call($'k#{spec.func}', [key])
         " 略
         \ : spec

-  return result
+  call feedkeys(result, 'n')
 endfunction

+let s:user_jisyo_path = expand('~/.cache/vim/SKK-JISYO.user')

 let s:jisyo_list = [
       \   { 'path': expand('~/.cache/vim/SKK-JISYO.L'), 'encoding': 'euc-jp' },
+      \   { 'path': s:user_jisyo_path, 'encoding': 'utf-8' },
       \   { 'path': expand('~/.cache/vim/SKK-JISYO.geo'), 'encoding': 'euc-jp' },
       \   { 'path': expand('~/.cache/vim/SKK-JISYO.emoji'), 'encoding': 'utf-8' },
       \ ]

  " k#initialize()内部に追加
  if glob(s:user_jisyo_path)->empty()
    call fnamemodify(s:user_jisyo_path, ':p:h')
          \ ->iconv(&encoding, &termencoding)
          \ ->mkdir('p')
    let user_jisyo_lines = [
          \ ';; フォーマット',
          \ ';; yomi /(henkan(;setsumei)?/)+',
          \ ';;',
          \ ';; okuri-ari entries.',
          \ ';; okuri-nasi entries.',
          \ ]
    call writefile(user_jisyo_lines, s:user_jisyo_path)
  endif

;; フォーマット
;; yomi /(henkan(;setsumei)?/)+
;;
;; okuri-ari entries.
;; okuri-nasi entries.

 function! k#completefunc(suffix_key = '')
   " comp_listに変換候補を詰めるところまで略

+  let preceding_str = s:get_preceding_str('henkan')  .. a:suffix_key
+  call add(comp_list, {
+        \ 'word': preceding_str,
+        \ 'abbr': '[辞書登録]',
+        \ 'menu': preceding_str,
+        \ 'info': preceding_str,
+        \ 'user_data': { 'yomi': preceding_str, 'func': 'jisyo_touroku' }
+        \ })
 
   call complete(start_col, comp_list)

   return ''
 endfunction

-  if empty(s:latest_henkan_list)
-    echomsg 'No Kanji'
-    return ''
-  endif

 augroup k_augroup
   autocmd!
   " 略
+  autocmd CompleteDonePre * echomsg 'completed' v:completed_item
 augroup END

+  let current_pos = getcharpos('.')[1:2]
+  let is_trailing = getline('.')->strcharlen() < current_pos[1]
   call add(comp_list, {
         \ 'word': preceding_str,
         \ 'abbr': '[辞書登録]',
         \ 'menu': preceding_str,
         \ 'info': preceding_str,
-        \ 'user_data': { 'yomi': preceding_str, 'func': 'jisyo_touroku' }
+        \ 'user_data': {
+        \   'yomi': preceding_str,
+        \   'jisyo_touroku': {
+        \     'yomi': preceding_str,
+        \     'start_pos': b:henkan_start_pos,
+        \     'cursor_pos': getcharpos('.')[1:2],
+        \     'is_trailing': is_trailing,
+        \     'suffix_key': a:suffix_key,
+        \   }
+        \   }
         \ })

   let user_data = get(a:completed_item, 'user_data', {})
-  if type(user_data) == v:t_dict
-    let func = get(user_data, 'func', '')
+  if type(user_data) != v:t_dict
+    return
+  endif
 
-    if func !=# ''
-      echomsg 'jisyo touroku'
-    endif
+  if has_key(user_data, 'jisyo_touroku')
+    let jt = user_data.jisyo_touroku
+    let b:jisyo_touroku_ctx = jt
+
+    autocmd BufEnter <buffer> ++once call s:buf_enter_try_user_henkan()
+
+    let okuri = '+/okuri-' .. (jt.suffix_key ==# '' ? 'nasi' : 'ari')
+    execute 'botright 5new' okuri s:user_jisyo_path
+
+    call feedkeys($"\<c-o>o{jt.yomi} //\<c-g>U\<left>\<cmd>call k#enable()\<cr>", 'n')
+  endif
+endfunction

function! s:buf_enter_try_user_henkan() abort
  call setcursorcharpos(b:jisyo_touroku_ctx.cursor_pos)
  if b:jisyo_touroku_ctx.is_trailing
    startinsert!
  else
    startinsert
  endif

  call k#enable()

  let s:latest_henkan_list = k#get_henkan_list(b:jisyo_touroku_ctx.yomi)
  if empty(s:latest_henkan_list)
    return
  endif

  let henkan_result = substitute(s:latest_henkan_list[0].henkan, ';.*', '', '')
  call feedkeys(repeat("\<bs>", strcharlen(b:jisyo_touroku_ctx.yomi)) .. henkan_result, 'n')

  " 送り仮名の補完
  if b:jisyo_touroku_ctx.suffix_key !=# ''
    let tmp_pos = b:jisyo_touroku_ctx.start_pos
    let tmp_pos[1] += strcharlen(henkan_result)
    let b:kana_start_pos = tmp_pos
    call feedkeys(b:jisyo_touroku_ctx.suffix_key, 'n')
  endif
endfunction

function! s:url_encode(str)
  return range(0, strlen(a:str)-1)
        \ ->map({i -> a:str[i] =~ '[-.~]\|\w' ? a:str[i] : printf("%%%02x", char2nr(a:str[i]))})
        \ ->join('')
endfunction

❯ curl -s 'http://www.google.com/transliterate?langpair=ja-Hira|ja&text=%E3%81%8B%E3%82%8F%E3%82%8A%E3%81%BF%E3%81%AB%E3%82%93%E3%81%8E%E3%82%87%E3%81%86'
[["かわりみ",["変わり身","カワリミ","変り身","変わりみ","代わりみ"]],["にんぎょう",["人形","ニンギョウ","人業","人行","にんぎょう"]]]

function! k#google_henkan(str) abort
  let url_base = 'http://www.google.com/transliterate?langpair=ja-Hira|ja&text='
  let encoded = s:url_encode(a:str)
  let result = system($"curl -s '{url_base}{encoded}'")
  try
    return json_decode(result)->map({_,v->v[1][0]})->join('')
  catch
    echomsg v:exception
    return ''
  endtry
endfunction

 function! k#completefunc(suffix_key = '')
   " 略
+  let google_exists = v:false
   let comp_list = []
   for k in s:latest_henkan_list
     " 略
+  let google_exists = google_exists || has_key(k, 'by_google')
   endfor
 
   let current_pos = getcharpos('.')[1:2]
   let is_trailing = getline('.')->strcharlen() < current_pos[1]
+  let context = {
+        \   'yomi': preceding_str,
+        \   'start_pos': b:henkan_start_pos,
+        \   'cursor_pos': getcharpos('.')[1:2],
+        \   'is_trailing': is_trailing,
+        \   'suffix_key': a:suffix_key,
+        \ }
+
+  if !google_exists
+    call add(comp_list, {
+          \ 'word': preceding_str,
+          \ 'abbr': '[Google変換]',
+          \ 'dup': 1,
+          \ 'user_data': { 'yomi': preceding_str, 'google_trans': context }
+          \ })
+  endif
   " 略 
 endfunction

  if has_key(user_data, 'google_trans')
    let gt = user_data.google_trans
    let henkan_result = k#google_henkan(gt.yomi)
    if henkan_result ==# ''
      echomsg 'Google変換で結果が得られませんでした。'
      return
    endif
    call insert(s:latest_henkan_list, {
          \ 'henkan': henkan_result,
          \ 'mark': '[Google]',
          \ 'yomi': gt.yomi,
          \ 'by_google': v:true
          \ })

    let b:henkan_start_pos = gt.start_pos
    call feedkeys("\<c-r>=k#completefunc()\<cr>\<c-n>", 'n')
    return
  endif

 function! k#enable() abort
   " 略
+    autocmd TextChangedI * call s:auto_complete()
   " 略
 endfunction

let s:latest_auto_complete_str = ''
let s:min_auto_complete_length = 2
function! s:auto_complete() abort
  let preceding_str = s:get_preceding_str('henkan', v:false)
        \ ->substitute('\a*$', '', '')

  if strcharlen(preceding_str) < s:min_auto_complete_length
    return
  endif

  echomsg 'auto_complete' preceding_str

  " 冒頭のmin_lengthぶんの文字が異なった場合はhenkan_listを更新
  if slice(preceding_str, 0, s:min_auto_complete_length) !=# slice(s:latest_auto_complete_str, 0, s:min_auto_complete_length)
    call k#update_henkan_list(preceding_str, 0)
  endif

  let s:latest_auto_complete_str = preceding_str

  call feedkeys("\<c-r>=k#autocompletefunc()\<cr>", 'n')
endfunction

-function! k#update_henkan_list(str) abort
+function! k#update_henkan_list(str, exact_match = v:true) abort
+  let str = a:exact_match ? $'{a:str} ' : a:str
   let henkan_list = []
   for jisyo in s:jisyo_list
     let mark = get(jisyo, 'mark', '') ==# '' ? '' : $'[{jisyo.mark}]'
-    let cmd = $"rg --no-filename --no-line-number --encoding {jisyo.encoding} '^{a:str} ' {jisyo.path}"
+    let cmd = $"rg --no-filename --no-line-number --encoding {jisyo.encoding} '^{str}' {jisyo.path}"
     let results = systemlist(cmd)
     for r in results
       let tmp = split(r, '/')
       call extend(henkan_list, tmp[1:]->map({_,v->{
             \ 'henkan': v,
-            \ 'yomi': a:str,
+            \ 'yomi': tmp[0]->substitute(' *$', '', ''),
             \ 'mark': mark
             \ }}))
     endfor
   endfor

   let s:latest_henkan_list = henkan_list
 endfunction

function! k#autocompletefunc()
  let [lnum, char_col] = b:henkan_start_pos
  let start_col = s:char_col_to_byte_col(lnum, char_col)

  let comp_list = []
  for k in s:latest_henkan_list
    " 前方一致で絞り込む
    if k.yomi !~# $'^{s:latest_auto_complete_str}'
      continue
    endif
    " ;があってもなくても良いよう_restを使う
    let [word, info; _rest] = split(k.henkan, ';') + ['']
    " :h complete-items
    call add(comp_list, {
          \ 'word': word,
          \ 'menu': info .. k.mark,
          \ 'info': info .. k.mark,
          \ 'user_data': { 'yomi': k.yomi }
          \ })
  endfor

  call complete(start_col, comp_list)

  return ''
endfunction

 function! s:complete_done_pre(complete_info, completed_item) abort
   echomsg a:complete_info a:completed_item
-  if get(a:complete_info, 'selected', -1) >= 0 && s:is_same_line_right_col('henkan')
+
+  if get(a:complete_info, 'selected', -1) < 0
+    " not selected
+    return
+  endif
+
+  if s:is_same_line_right_col('henkan')

-    let cmd = $"rg --no-filename --no-line-number --encoding {jisyo.encoding} '^{str}' {jisyo.path}"
+    let cmd = $"rg --no-filename --no-line-number --encoding {jisyo.encoding} '^{str}' {jisyo.path} 2>/dev/null"

+   ";": { "func": "sticky" },

" 変換中→送りあり変換を予約
" それ以外→現在位置に変換ポイントを設定
function! k#sticky(...) abort
  if s:is_same_line_right_col('henkan')
    let s:next_okuri = v:true
  else
    let current_pos = getcharpos('.')[1:2]
    call s:set_henkan_start_pos(current_pos)
  endif
  return ''
endfunction

 function! s:get_insert_spec(key, henkan = v:false) abort
   " 略
   let kana_dict = get(s:end_keys, a:key, {})
-  if a:henkan
+  let next_okuri = get(s:, 'next_okuri', v:false)
+  if a:henkan || next_okuri
-    if !s:is_same_line_right_col('henkan') || pumvisible()
+    if !next_okuri && (!s:is_same_line_right_col('henkan') || pumvisible())
       call s:set_henkan_start_pos(current_pos)
     else
       let preceding_str = s:get_preceding_str('henkan', v:false)

       call k#update_henkan_list(preceding_str .. a:key)
 
+      let s:next_okuri = v:false
+
       return $"\<c-r>=k#completefunc('{get(kana_dict,'',a:key)}')\<cr>\<c-n>"
     endif
  " 略
 endfunction
   endif