From 83e22c7e3b936e423855d9d5635aa1c3db8fa4e2 Mon Sep 17 00:00:00 2001
From: xluffy <xquang.foss@gmail.com>
Date: Thu, 16 Jun 2016 08:29:07 +0700
Subject: [PATCH 01/16] Update install auto-pair

- Manual install with copy plugin file
- Install with Pathogen
- Install with Vundle plugin manager
---
 README.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 72bde89..4625589 100644
--- a/README.md
+++ b/README.md
@@ -4,11 +4,13 @@ Insert or delete brackets, parens, quotes in pair.
 
 Installation
 ------------
-copy plugin/auto-pairs.vim to ~/.vim/plugin
 
-or if you are using `pathogen`:
-
-```git clone git://github.com/jiangmiao/auto-pairs.git ~/.vim/bundle/auto-pairs```
+* Manual
+  * Copy `plugin/auto-pairs.vim` to `~/.vim/plugin`
+* [Pathogen](https://github.com/tpope/vim-pathogen)
+  * `git clone git://github.com/jiangmiao/auto-pairs.git ~/.vim/bundle/auto-pairs`
+* [Vundle](https://github.com/VundleVim/Vundle.vim)
+  * `Plugin 'jiangmiao/auto-pairs'`
 
 Features
 --------

From 3c290d9308c1b651c588865c3741a12654ae640e Mon Sep 17 00:00:00 2001
From: Ruslan Kiyanchuk <ruslan.kiyanchuk@gmail.com>
Date: Tue, 18 Sep 2018 17:42:41 -0700
Subject: [PATCH 02/16] Spell fix

Remove duplicated word.
---
 doc/AutoPairs.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/AutoPairs.txt b/doc/AutoPairs.txt
index 49ff549..afe589e 100644
--- a/doc/AutoPairs.txt
+++ b/doc/AutoPairs.txt
@@ -178,7 +178,7 @@ System Shortcuts:
     <M-b>: BackInsert (|g:AutoPairsShortcutBackInsert|)
 
 
-    To rebind keys <M-p>, <M-e> or <M-n> or in case of conflicts conflicts with
+    To rebind keys <M-p>, <M-e> or <M-n> or in case of conflicts with
     another keys:
 
         let g:AutoPairsShortcutToggle = '<another key>'

From cf921dadceae27d05ae05543342af23e3b6955e5 Mon Sep 17 00:00:00 2001
From: "Mikhail f. Shiryaev" <mr.felixoid@gmail.com>
Date: Sat, 12 Jan 2019 15:58:06 +0100
Subject: [PATCH 03/16] Fix breaking of keymap behavior

---
 plugin/auto-pairs.vim | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/plugin/auto-pairs.vim b/plugin/auto-pairs.vim
index b2a9af7..b062ba8 100644
--- a/plugin/auto-pairs.vim
+++ b/plugin/auto-pairs.vim
@@ -501,6 +501,20 @@ function! AutoPairsInit()
     execute 'noremap <buffer> <silent> ' . g:AutoPairsShortcutJump. ' :call AutoPairsJump()<CR>'
   end
 
+  if &keymap != ''
+    let l:imsearch = &imsearch
+    let l:iminsert = &iminsert
+    let l:imdisable = &imdisable
+    execute 'setlocal keymap=' . &keymap
+    execute 'setlocal imsearch=' . l:imsearch
+    execute 'setlocal iminsert=' . l:iminsert
+    if l:imdisable
+      execute 'setlocal imdisable'
+    else
+      execute 'setlocal noimdisable'
+    end
+  end
+
 endfunction
 
 function! s:ExpandMap(map)

From 4ec359716a48fe0953f38208e45063bdc5e551d6 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 04:18:06 +0800
Subject: [PATCH 04/16] Bump version 1.3.4

---
 plugin/auto-pairs.vim | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/plugin/auto-pairs.vim b/plugin/auto-pairs.vim
index b062ba8..93a4ed3 100644
--- a/plugin/auto-pairs.vim
+++ b/plugin/auto-pairs.vim
@@ -1,8 +1,8 @@
 " Insert or delete brackets, parens, quotes in pairs.
 " Maintainer:	JiangMiao <jiangfriend@gmail.com>
 " Contributor: camthompson
-" Last Change:  2017-06-17
-" Version: 1.3.3
+" Last Change:  2019-01-15
+" Version: 1.3.4
 " Homepage: http://www.vim.org/scripts/script.php?script_id=3599
 " Repository: https://github.com/jiangmiao/auto-pairs
 " License: MIT

From 738d1f18a8cc6b3f8e0597304e0b2bce7c107dce Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 04:21:48 +0800
Subject: [PATCH 05/16] Support multibytes pairs

---
 plugin/auto-pairs.vim | 514 +++++++++++++++++-------------------------
 1 file changed, 211 insertions(+), 303 deletions(-)

diff --git a/plugin/auto-pairs.vim b/plugin/auto-pairs.vim
index 93a4ed3..bfa072c 100644
--- a/plugin/auto-pairs.vim
+++ b/plugin/auto-pairs.vim
@@ -16,10 +16,6 @@ if !exists('g:AutoPairs')
   let g:AutoPairs = {'(':')', '[':']', '{':'}',"'":"'",'"':'"', '`':'`'}
 end
 
-if !exists('g:AutoPairsParens')
-  let g:AutoPairsParens = {'(':')', '[':']', '{':'}'}
-end
-
 if !exists('g:AutoPairsMapBS')
   let g:AutoPairsMapBS = 1
 end
@@ -95,263 +91,226 @@ let s:Right = s:Go."\<RIGHT>"
 let g:AutoPairsClosedPairs = {}
 
 
-function! AutoPairsInsert(key)
-  if !b:autopairs_enabled
-    return a:key
-  end
+" unicode len
+func! s:ulen(s)
+  return len(split(a:s, '\zs'))
+endf
 
+func! s:left(s)
+  return repeat(s:Left, s:ulen(a:s))
+endf
+
+func! s:right(s)
+  return repeat(s:Right, s:ulen(a:s))
+endf
+
+func! s:delete(s)
+  return repeat("\<DEL>", s:ulen(a:s))
+endf
+
+func! s:backspace(s)
+  return repeat("\<BS>", s:ulen(a:s))
+endf
+
+func! s:getline()
   let line = getline('.')
   let pos = col('.') - 1
   let before = strpart(line, 0, pos)
   let after = strpart(line, pos)
-  let next_chars = split(after, '\zs')
-  let current_char = get(next_chars, 0, '')
-  let next_char = get(next_chars, 1, '')
-  let prev_chars = split(before, '\zs')
-  let prev_char = get(prev_chars, -1, '')
-
-  let eol = 0
-  if col('$') -  col('.') <= 1
-    let eol = 1
-  end
-
-  " Ignore auto close if prev character is \
-  if prev_char == '\'
-    return a:key
-  end
-
-  " The key is difference open-pair, then it means only for ) ] } by default
-  if !has_key(b:AutoPairs, a:key)
-    let b:autopairs_saved_pair = [a:key, getpos('.')]
-
-    " Skip the character if current character is the same as input
-    if current_char == a:key
-      return s:Right
-    end
-
-    if !g:AutoPairsFlyMode
-      " Skip the character if next character is space
-      if current_char == ' ' && next_char == a:key
-        return s:Right.s:Right
-      end
-
-      " Skip the character if closed pair is next character
-      if current_char == ''
-        if g:AutoPairsMultilineClose
-          let next_lineno = line('.')+1
-          let next_line = getline(nextnonblank(next_lineno))
-          let next_char = matchstr(next_line, '\s*\zs.')
-        else
-          let next_char = matchstr(line, '\s*\zs.')
-        end
-        if next_char == a:key
-          return "\<ESC>e^a"
-        endif
-      endif
-    endif
-
-    " Fly Mode, and the key is closed-pairs, search closed-pair and jump
-    if g:AutoPairsFlyMode && has_key(b:AutoPairsClosedPairs, a:key)
-      let n = stridx(after, a:key)
-      if n != -1
-        return repeat(s:Right, n+1)
-      end
-      if search(a:key, 'W')
-        " force break the '.' when jump to different line
-        return "\<Right>"
-      endif
-    endif
-
-    " Insert directly if the key is not an open key
-    return a:key
-  end
-
-  let open = a:key
-  let close = b:AutoPairs[open]
-
-  if current_char == close && open == close
-    return s:Right
-  end
-
-  " Ignore auto close ' if follows a word
-  " MUST after closed check. 'hello|'
-  if a:key == "'" && prev_char =~ '\v\w'
-    return a:key
-  end
-
-  " support for ''' ``` and """
-  if open == close
-    " The key must be ' " `
-    let pprev_char = line[col('.')-3]
-    if pprev_char == open && prev_char == open
-      " Double pair found
-      return repeat(a:key, 4) . repeat(s:Left, 3)
-    end
-  end
-
-  let quotes_num = 0
-  " Ignore comment line for vim file
-  if &filetype == 'vim' && a:key == '"'
-    if before =~ '^\s*$'
-      return a:key
-    end
-    if before =~ '^\s*"'
-      let quotes_num = -1
-    end
-  end
-
-  " Keep quote number is odd.
-  " Because quotes should be matched in the same line in most of situation
-  if g:AutoPairsSmartQuotes && open == close
-    " Remove \\ \" \'
-    let cleaned_line = substitute(line, '\v(\\.)', '', 'g')
-    let n = quotes_num
-    let pos = 0
-    while 1
-      let pos = stridx(cleaned_line, open, pos)
-      if pos == -1
+  if g:AutoPairsMultilineClose
+    let n = line('$')
+    let i = line('.')+1
+    while i <= n
+      let line = getline(i)
+      let after = after.' '.line
+      if !(line =~ '\v^\s*$')
         break
       end
-      let n = n + 1
-      let pos = pos + 1
+      let i = i+1
     endwhile
-    if n % 2 == 1
-      return a:key
+  end
+  return [before, after]
+endf
+
+" add or delete pairs base on g:AutoPairs
+" AutoPairsDefine(addPairs:dict[, removeOpenPairList:list])
+"
+" eg:
+"   au FileType html let b:AutoPairs = AutoPairsDefine({'<!--' : '-->'}, ['{'])
+"   add <!-- --> pair and remove '{' for html file
+func! AutoPairsDefine(pairs, ...)
+  let r = copy(g:AutoPairs)
+  for [open, close] in items(a:pairs)
+    let r[open] = close
+  endfor
+  if a:0 > 1
+    for open in a:1
+      unlet r[open]
+    endfor
+  end
+  return r
+endf
+
+func! AutoPairsInsert(key)
+  if !b:autopairs_enabled
+    return a:key
+  end
+
+  let b:autopairs_saved_pair = [a:key, getpos('.')]
+
+  let [before, after] = s:getline()
+
+  " Ignore auto close if prev character is \
+  if before[-1:-1] == '\'
+    return a:key
+  end
+
+  " check close pairs
+  for [open, close] in b:AutoPairsList
+    if close[0] == a:key
+      let m = matchlist(after, '\v^\s*(\V'.close.'\v)')
+      if len(m) > 0
+        " skip close pair
+        call search(m[1], 'We')
+        return "\<Right>"
+      end
+    end
+  endfor
+
+  " check open pairs
+  let text=before.a:key
+  for [open, close] in b:AutoPairsList
+    let m = matchstr(text, '\V'.open.'\v$')
+    if m != ''
+      " process the open pair
+      
+      " remove inserted pair
+      " if the pairs include < > and  <!-- --> 
+      " when <!-- is detected the inserted pair < > should be clean up 
+      let bs = repeat("\<BS>", s:ulen(m)-1)
+      if bs != ''
+        call feedkeys(bs)
+      end
+      call feedkeys(m.close.s:left(close), "n")
+      return ""
+      " return m.close.s:left(close)
+    end
+  endfor
+
+  " Fly Mode, and the key is closed-pairs, search closed-pair and jump
+  if g:AutoPairsFlyMode &&  a:key =~ '\v[\}\]\)]'
+    let n = stridx(after, a:key)
+    if n != -1
+      return repeat(s:Right, n+1)
+    end
+    if search(a:key, 'We')
+      return "\<Right>"
     endif
   endif
 
-  return open.close.s:Left
-endfunction
+  return a:key
+endf
 
-function! AutoPairsDelete()
+func! AutoPairsDelete()
   if !b:autopairs_enabled
     return "\<BS>"
   end
 
-  let line = getline('.')
-  let pos = col('.') - 1
-  let current_char = get(split(strpart(line, pos), '\zs'), 0, '')
-  let prev_chars = split(strpart(line, 0, pos), '\zs')
-  let prev_char = get(prev_chars, -1, '')
-  let pprev_char = get(prev_chars, -2, '')
-
-  if pprev_char == '\'
-    return "\<BS>"
-  end
-
-  " Delete last two spaces in parens, work with MapSpace
-  if has_key(b:AutoPairs, pprev_char) && prev_char == ' ' && current_char == ' '
-    return "\<BS>\<DEL>"
-  endif
-
-  " Delete Repeated Pair eg: '''|''' [[|]] {{|}}
-  if has_key(b:AutoPairs, prev_char)
-    let times = 0
-    let p = -1
-    while get(prev_chars, p, '') == prev_char
-      let p = p - 1
-      let times = times + 1
-    endwhile
-
-    let close = b:AutoPairs[prev_char]
-    let left = repeat(prev_char, times)
-    let right = repeat(close, times)
-
-    let before = strpart(line, pos-times, times)
-    let after  = strpart(line, pos, times)
-    if left == before && right == after
-      return repeat("\<BS>\<DEL>", times)
+  let [before, after] = s:getline()
+  for [open, close] in b:AutoPairsList
+    let b = matchstr(before, '\V'.open.'\v\s*$')
+    let a = matchstr(after, '^\s*\V'.close)
+    if b != '' && a != ''
+      return repeat("\<BS>", s:ulen(b)).repeat("\<DELETE>", s:ulen(a))
     end
-  end
-
-
-  if has_key(b:AutoPairs, prev_char)
-    let close = b:AutoPairs[prev_char]
-    if match(line,'^\s*'.close, col('.')-1) != -1
-      " Delete (|___)
-      let space = matchstr(line, '^\s*', col('.')-1)
-      return "\<BS>". repeat("\<DEL>", len(space)+1)
-    elseif match(line, '^\s*$', col('.')-1) != -1
-      " Delete (|__\n___)
-      let nline = getline(line('.')+1)
-      if nline =~ '^\s*'.close
-        if &filetype == 'vim' && prev_char == '"'
-          " Keep next line's comment
-          return "\<BS>"
-        end
-
-        let space = matchstr(nline, '^\s*')
-        return "\<BS>\<DEL>". repeat("\<DEL>", len(space)+1)
-      end
-    end
-  end
-
+  endfor
   return "\<BS>"
-endfunction
-
-function! AutoPairsJump()
-  call search('["\]'')}]','W')
-endfunction
-" string_chunk cannot use standalone
-let s:string_chunk = '\v%(\\\_.|[^\1]|[\r\n]){-}'
-let s:ss_pattern = '\v''' . s:string_chunk . ''''
-let s:ds_pattern = '\v"'  . s:string_chunk . '"'
-
-func! s:RegexpQuote(str)
-  return substitute(a:str, '\v[\[\{\(\<\>\)\}\]]', '\\&', 'g')
 endf
 
-func! s:RegexpQuoteInSquare(str)
-  return substitute(a:str, '\v[\[\]]', '\\&', 'g')
-endf
-
-" Search next open or close pair
-func! s:FormatChunk(open, close)
-  let open = s:RegexpQuote(a:open)
-  let close = s:RegexpQuote(a:close)
-  let open2 = s:RegexpQuoteInSquare(a:open)
-  let close2 = s:RegexpQuoteInSquare(a:close)
-  if open == close
-    return '\v'.open.s:string_chunk.close
-  else
-    return '\v%(' . s:ss_pattern . '|' . s:ds_pattern . '|' . '[^'.open2.close2.']|[\r\n]' . '){-}(['.open2.close2.'])'
-  end
-endf
 
 " Fast wrap the word in brackets
-function! AutoPairsFastWrap()
-  let line = getline('.')
-  let current_char = line[col('.')-1]
-  let next_char = line[col('.')]
-  let open_pair_pattern = '\v[({\[''"]'
-  let at_end = col('.') >= col('$') - 1
+func! AutoPairsFastWrap()
   normal! x
-  " Skip blank
-  if next_char =~ '\v\s' || at_end
-    call search('\v\S', 'W')
-    let line = getline('.')
-    let next_char = line[col('.')-1]
-  end
-
-  if has_key(b:AutoPairs, next_char)
-    let followed_open_pair = next_char
-    let inputed_close_pair = current_char
-    let followed_close_pair = b:AutoPairs[next_char]
-    if followed_close_pair != followed_open_pair
-      " TODO replace system searchpair to skip string and nested pair.
-      " eg: (|){"hello}world"} will transform to ({"hello})world"}
-      call searchpair('\V'.followed_open_pair, '', '\V'.followed_close_pair, 'W')
-    else
-      call search(s:FormatChunk(followed_open_pair, followed_close_pair), 'We')
-    end
-    return s:Right.inputed_close_pair.s:Left
+  let [before, after] = s:getline()
+  if after[0] =~ '\v[\{\[\(]'
+    normal! %
+    normal! p
   else
-    normal! he
-    return s:Right.current_char.s:Left
+    normal! e
+    normal! p
   end
-endfunction
+  return ""
+endf
 
-function! AutoPairsMap(key)
+func! AutoPairsJump()
+  call search('["\]'')}]','W')
+endf
+
+func! AutoPairsMoveCharacter(key)
+  let c = getline(".")[col(".")-1]
+  let escaped_key = substitute(a:key, "'", "''", 'g')
+  return "\<DEL>\<ESC>:call search("."'".escaped_key."'".")\<CR>a".c."\<LEFT>"
+endf
+
+func! AutoPairsBackInsert()
+  if exists('b:autopairs_saved_pair')
+    let pair = b:autopairs_saved_pair[0]
+    let pos  = b:autopairs_saved_pair[1]
+    call setpos('.', pos)
+    return pair
+  endif
+  return ''
+endf
+
+func! AutoPairsReturn()
+  if b:autopairs_enabled == 0
+    return ''
+  end
+  let before = getline(line('.')-1)
+  let after = getline('.')
+  let cmd = ''
+  for [open, close] in b:AutoPairsList
+    if before =~ '\V'.open.'\v\s*$' && after =~ '^\s*\V'.close
+      if g:AutoPairsCenterLine && winline() * 3 >= winheight(0) * 2
+        " Recenter before adding new line to avoid replacing line content
+        let cmd = "zz"
+      end
+
+      " If equalprg has been set, then avoid call =
+      " https://github.com/jiangmiao/auto-pairs/issues/24
+      if &equalprg != ''
+        return "\<ESC>".cmd."O"
+      endif
+
+      " conflict with javascript and coffee
+      " javascript   need   indent new line
+      " coffeescript forbid indent new line
+      if &filetype == 'coffeescript' || &filetype == 'coffee'
+        return "\<ESC>".cmd."k==o"
+      else
+        return "\<ESC>".cmd."=ko"
+      endif
+    end
+  endfor
+  return ''
+endf
+
+func! AutoPairsSpace()
+  if !b:autopairs_enabled
+    return "\<SPACE>"
+  end
+
+  let [before, after] = s:getline()
+
+  for [open, close] in b:AutoPairsList
+    if before =~ '\V'.open.'\v$' && after =~ '^\V'.close
+      return "\<SPACE>\<SPACE>".s:Left
+    end
+  endfor
+  return "\<SPACE>"
+endf
+
+func! AutoPairsMap(key)
   " | is special key which separate map command from text
   let key = a:key
   if key == '|'
@@ -361,9 +320,9 @@ function! AutoPairsMap(key)
   " use expr will cause search() doesn't work
   execute 'inoremap <buffer> <silent> '.key." <C-R>=AutoPairsInsert('".escaped_key."')<CR>"
 
-endfunction
+endf
 
-function! AutoPairsToggle()
+func! AutoPairsToggle()
   if b:autopairs_enabled
     let b:autopairs_enabled = 0
     echo 'AutoPairs Disabled.'
@@ -372,69 +331,13 @@ function! AutoPairsToggle()
     echo 'AutoPairs Enabled.'
   end
   return ''
-endfunction
+endf
 
-function! AutoPairsMoveCharacter(key)
-  let c = getline(".")[col(".")-1]
-  let escaped_key = substitute(a:key, "'", "''", 'g')
-  return "\<DEL>\<ESC>:call search("."'".escaped_key."'".")\<CR>a".c."\<LEFT>"
-endfunction
+func! s:sortByLength(i1, i2)
+  return len(a:i2[0])-len(a:i1[0])
+endf
 
-function! AutoPairsReturn()
-  if b:autopairs_enabled == 0
-    return ''
-  end
-  let line = getline('.')
-  let pline = getline(line('.')-1)
-  let prev_char = pline[strlen(pline)-1]
-  let cmd = ''
-  let cur_char = line[col('.')-1]
-  if has_key(b:AutoPairs, prev_char) && b:AutoPairs[prev_char] == cur_char
-    if g:AutoPairsCenterLine && winline() * 3 >= winheight(0) * 2
-      " Recenter before adding new line to avoid replacing line content
-      let cmd = "zz"
-    end
-
-    " If equalprg has been set, then avoid call =
-    " https://github.com/jiangmiao/auto-pairs/issues/24
-    if &equalprg != ''
-      return "\<ESC>".cmd."O"
-    endif
-
-    " conflict with javascript and coffee
-    " javascript   need   indent new line
-    " coffeescript forbid indent new line
-    if &filetype == 'coffeescript' || &filetype == 'coffee'
-      return "\<ESC>".cmd."k==o"
-    else
-      return "\<ESC>".cmd."=ko"
-    endif
-  end
-  return ''
-endfunction
-
-function! AutoPairsSpace()
-  let line = getline('.')
-  let prev_char = line[col('.')-2]
-  let cmd = ''
-  let cur_char =line[col('.')-1]
-  if has_key(g:AutoPairsParens, prev_char) && g:AutoPairsParens[prev_char] == cur_char
-    let cmd = "\<SPACE>".s:Left
-  endif
-  return "\<SPACE>".cmd
-endfunction
-
-function! AutoPairsBackInsert()
-  if exists('b:autopairs_saved_pair')
-    let pair = b:autopairs_saved_pair[0]
-    let pos  = b:autopairs_saved_pair[1]
-    call setpos('.', pos)
-    return pair
-  endif
-  return ''
-endfunction
-
-function! AutoPairsInit()
+func! AutoPairsInit()
   let b:autopairs_loaded  = 1
   if !exists('b:autopairs_enabled')
     let b:autopairs_enabled = 1
@@ -444,6 +347,9 @@ function! AutoPairsInit()
   if !exists('b:AutoPairs')
     let b:AutoPairs = g:AutoPairs
   end
+  " sort pairs by length, longer pair should have higher priority
+  let b:AutoPairsList = sort(items(b:AutoPairs), "s:sortByLength")
+
 
   if !exists('b:AutoPairsMoveCharacter')
     let b:AutoPairsMoveCharacter = g:AutoPairsMoveCharacter
@@ -451,6 +357,8 @@ function! AutoPairsInit()
 
   " buffer level map pairs keys
   for [open, close] in items(b:AutoPairs)
+    let open = open[len(open)-1]
+    let close = close[0]
     call AutoPairsMap(open)
     if open != close
       call AutoPairsMap(close)
@@ -515,15 +423,15 @@ function! AutoPairsInit()
     end
   end
 
-endfunction
+endf
 
-function! s:ExpandMap(map)
+func! s:ExpandMap(map)
   let map = a:map
   let map = substitute(map, '\(<Plug>\w\+\)', '\=maparg(submatch(1), "i")', 'g')
   return map
-endfunction
+endf
 
-function! AutoPairsTryInit()
+func! AutoPairsTryInit()
   if exists('b:autopairs_loaded')
     return
   end
@@ -586,7 +494,7 @@ function! AutoPairsTryInit()
     end
   endif
   call AutoPairsInit()
-endfunction
+endf
 
 " Always silent the command
 inoremap <silent> <SID>AutoPairsReturn <C-R>=AutoPairsReturn()<CR>

From 680f4fefcdfce5cb527c9607af1fc06b08a4d104 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 12:43:46 +0800
Subject: [PATCH 06/16] Keep clipboard when fastwrap

---
 plugin/auto-pairs.vim | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/plugin/auto-pairs.vim b/plugin/auto-pairs.vim
index bfa072c..bcfd0ec 100644
--- a/plugin/auto-pairs.vim
+++ b/plugin/auto-pairs.vim
@@ -185,7 +185,7 @@ func! AutoPairsInsert(key)
       " process the open pair
       
       " remove inserted pair
-      " if the pairs include < > and  <!-- --> 
+      " eg: if the pairs include < > and  <!-- --> 
       " when <!-- is detected the inserted pair < > should be clean up 
       let bs = repeat("\<BS>", s:ulen(m)-1)
       if bs != ''
@@ -199,10 +199,6 @@ func! AutoPairsInsert(key)
 
   " Fly Mode, and the key is closed-pairs, search closed-pair and jump
   if g:AutoPairsFlyMode &&  a:key =~ '\v[\}\]\)]'
-    let n = stridx(after, a:key)
-    if n != -1
-      return repeat(s:Right, n+1)
-    end
     if search(a:key, 'We')
       return "\<Right>"
     endif
@@ -230,6 +226,7 @@ endf
 
 " Fast wrap the word in brackets
 func! AutoPairsFastWrap()
+  let c = @"
   normal! x
   let [before, after] = s:getline()
   if after[0] =~ '\v[\{\[\(]'
@@ -239,6 +236,7 @@ func! AutoPairsFastWrap()
     normal! e
     normal! p
   end
+  let @" = c
   return ""
 endf
 

From 1884e426ca065a8e0ef4b38565d2ed0b900f6f30 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 17:03:32 +0800
Subject: [PATCH 07/16] Fix delete pairs incorrect

---
 plugin/auto-pairs.vim | 108 ++++++++++++++++++++++++++++++++++--------
 1 file changed, 89 insertions(+), 19 deletions(-)

diff --git a/plugin/auto-pairs.vim b/plugin/auto-pairs.vim
index bcfd0ec..2cb6340 100644
--- a/plugin/auto-pairs.vim
+++ b/plugin/auto-pairs.vim
@@ -29,6 +29,10 @@ if !exists('g:AutoPairsMapCR')
   let g:AutoPairsMapCR = 1
 end
 
+if !exists('g:AutoPairsWildClosedPair')
+  let g:AutoPairsWildClosedPair = ']'
+end
+
 if !exists('g:AutoPairsMapSpace')
   let g:AutoPairsMapSpace = 1
 end
@@ -87,8 +91,6 @@ let s:Left = s:Go."\<LEFT>"
 let s:Right = s:Go."\<RIGHT>"
 
 
-" Will auto generated {']' => '[', ..., '}' => '{'}in initialize.
-let g:AutoPairsClosedPairs = {}
 
 
 " unicode len
@@ -132,6 +134,22 @@ func! s:getline()
   return [before, after]
 endf
 
+" split text to two part
+func! s:matchend(text, open)
+    let m = matchstr(a:text, '\V'.a:open.'\v$')
+    if m == ""
+      return []
+    end
+    return [a:text, strpart(a:text, 0, len(a:text)-len(m)), m]
+endf
+func! s:matchbegin(text, close)
+    let m = matchstr(a:text, '^\V'.a:close)
+    if m == ""
+      return []
+    end
+    return [a:text, m, strpart(a:text, len(m), len(a:text)-len(m))]
+endf
+
 " add or delete pairs base on g:AutoPairs
 " AutoPairsDefine(addPairs:dict[, removeOpenPairList:list])
 "
@@ -168,7 +186,7 @@ func! AutoPairsInsert(key)
   " check close pairs
   for [open, close] in b:AutoPairsList
     if close[0] == a:key
-      let m = matchlist(after, '\v^\s*(\V'.close.'\v)')
+      let m = s:matchbegin(after, '\v\s*\V'.close)
       if len(m) > 0
         " skip close pair
         call search(m[1], 'We')
@@ -180,18 +198,45 @@ func! AutoPairsInsert(key)
   " check open pairs
   let text=before.a:key
   for [open, close] in b:AutoPairsList
-    let m = matchstr(text, '\V'.open.'\v$')
-    if m != ''
+    let m = s:matchend(text, open)
+    if len(m) > 0
       " process the open pair
       
       " remove inserted pair
       " eg: if the pairs include < > and  <!-- --> 
       " when <!-- is detected the inserted pair < > should be clean up 
-      let bs = repeat("\<BS>", s:ulen(m)-1)
+      " <?php ?> should backspace 4 times php and <?
+      let target = m[1]
+      let openPair = m[2]
+      let text = before
+      let i = 0
+      while len(text) >= len(target) && target != text 
+        let found = 0
+        " delete pair
+        for [o, c] in b:AutoPairsList
+          let m = s:matchend(text, o)
+          if len(m) > 0
+            let found = 1
+            let text = m[1]
+            let i = i + 1
+            break
+          end
+        endfor
+        if !found
+          " delete charactor
+          let m = s:matchend(text, '\v.')
+          if len(m) == 0
+            break
+          end
+          let i = i + 1
+          let text = m[1]
+        end
+      endwhile
+      let bs = repeat("\<BS>", i)
       if bs != ''
         call feedkeys(bs)
       end
-      call feedkeys(m.close.s:left(close), "n")
+      call feedkeys(openPair.close.s:left(close), "n")
       return ""
       " return m.close.s:left(close)
     end
@@ -214,9 +259,16 @@ func! AutoPairsDelete()
 
   let [before, after] = s:getline()
   for [open, close] in b:AutoPairsList
-    let b = matchstr(before, '\V'.open.'\v\s*$')
-    let a = matchstr(after, '^\s*\V'.close)
+    let b = matchstr(before, '\V'.open.'\v\s?$')
+    let a = matchstr(after, '^\v\s*\V'.close)
     if b != '' && a != ''
+      if b[-1:-1] == ' '
+        if a[0] == ' '
+          return "\<BS>\<DELETE>"
+        else
+          return "\<BS>"
+        end
+      end
       return repeat("\<BS>", s:ulen(b)).repeat("\<DELETE>", s:ulen(a))
     end
   endfor
@@ -229,10 +281,18 @@ func! AutoPairsFastWrap()
   let c = @"
   normal! x
   let [before, after] = s:getline()
-  if after[0] =~ '\v[\{\[\(]'
+  if after[0] =~ '\v[\{\[\(\<]'
     normal! %
     normal! p
   else
+    for [open, close] in b:AutoPairsList
+      if after =~ '^\s*\V'.open
+        call search(close, 'We')
+        normal! p
+        let @" = c
+        return ""
+      end
+    endfor
     normal! e
     normal! p
   end
@@ -340,30 +400,40 @@ func! AutoPairsInit()
   if !exists('b:autopairs_enabled')
     let b:autopairs_enabled = 1
   end
-  let b:AutoPairsClosedPairs = {}
 
   if !exists('b:AutoPairs')
     let b:AutoPairs = g:AutoPairs
   end
-  " sort pairs by length, longer pair should have higher priority
-  let b:AutoPairsList = sort(items(b:AutoPairs), "s:sortByLength")
 
 
   if !exists('b:AutoPairsMoveCharacter')
     let b:AutoPairsMoveCharacter = g:AutoPairsMoveCharacter
   end
 
+  let b:AutoPairsList = []
+
   " buffer level map pairs keys
   for [open, close] in items(b:AutoPairs)
-    let open = open[len(open)-1]
-    let close = close[0]
-    call AutoPairsMap(open)
-    if open != close
-      call AutoPairsMap(close)
+    let o = open[len(open)-1]
+    let m = matchlist(close, '\v(.*)//(.*)$')
+    let mapclose = 1
+    if len(m) > 0 
+      if m[1] =~ 'n'
+        let mapclose = 0
+      end
+      let close = m[1]
     end
-    let b:AutoPairsClosedPairs[close] = open
+    let c = close[0]
+    call AutoPairsMap(o)
+    if o != c && mapclose
+      call AutoPairsMap(c)
+    end
+    let b:AutoPairsList += [[open, close]]
   endfor
 
+  " sort pairs by length, longer pair should have higher priority
+  let b:AutoPairsList = sort(b:AutoPairsList, "s:sortByLength")
+
   for key in split(b:AutoPairsMoveCharacter, '\s*')
     let escaped_key = substitute(key, "'", "''", 'g')
     execute 'inoremap <silent> <buffer> <M-'.key."> <C-R>=AutoPairsMoveCharacter('".escaped_key."')<CR>"

From adf9224a4122920c29a96792adbb5a4d5a36a764 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 17:03:40 +0800
Subject: [PATCH 08/16] update README

---
 README.md | 104 ++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 86 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index 7cdcbf9..fda583f 100644
--- a/README.md
+++ b/README.md
@@ -89,24 +89,10 @@ Features
 
         }|
 
-*   Support ``` ''' and """
-
-        input:
-            '''
-
-        output:
-            '''|'''
-
-*   Delete Repeated Pairs in one time
-
-        input: """|""" (press <BS> at |)
-        output: |
-
-        input: {{|}} (press <BS> at |)
-        output: |
-
-        input: [[[[[[|]]]]]] (press <BS> at |)
-        output: |
+*  Multibyte Pairs
+        
+        Support any multibyte pairs such as <!-- -->, <% %>, """ """
+        See multibyte pairs section for details
 
 *  Fly Mode
 
@@ -298,6 +284,88 @@ TroubleShooting
     Because AutoPairs uses Meta(Alt) key as shortcut, it is conflict with some Swedish character such as å.
     To fix the issue, you need remap or disable the related shortcut.
 
+Multibyte Pairs
+---------------
+
+    The default pairs is {'(':')', '[':']', '{':'}',"'":"'",'"':'"', '`':'`'}
+    You could also define multibyte pairs such as <!-- -->, <% %> and so on
+
+    Here are some examples
+
+* General usage
+
+    au FileType php      let b:AutoPairs = AutoPairsDefine({'<?' : '?>', '<?php': '?>'})
+
+    the first key of closed pair ? will be mapped
+
+    pairs: '<?' : '?>', '<?php': '?>'
+    input: <?
+    output: <?|?>
+
+    input: <?php
+    output: <?php|?>
+
+    input: he<?php|?> (press <BS> at|)
+    output: he|
+
+    input: <?php|?> (press ? at|)
+    output: <?php?>|
+
+    pair: '[[':']]'
+    input: [[|]] (press <BR>)
+    output: | ([[ and ]] will be deleted the [['s priority is higher than [ for it's longer)
+
+* Modifier
+
+    The text after //  in close pair is modifiers
+
+    n - do not map the first charactor of closed pair
+
+    for 'begin' 'end' pair, e is a charactor, if map e to jump will be annoy, so use modifier 'n' to skip key map
+
+    au FileType ruby     let b:AutoPairs = AutoPairsDefine({'begin': 'end//n]'})
+
+
+    input: begin
+    output: begin|end
+
+    input: begin|end (press <BR> on |)
+    output: |
+
+    input: begin|end (press e on |)
+    output: begineend (will not jump for e is not mapped)
+
+* Advanced usage
+
+    au FileType rust     let b:AutoPairs = AutoPairsDefine({'\w\zs<': '>'})
+
+    if press < after a word will generate the pair
+
+    when use regexp MUST use \zs to prevent catching
+    if use '\w<' without \zs,  for text hello<|> press <BS> on | will output 'hell', the 'o' has been deleted
+
+    pair: '\w\zs<': '>'
+    input: h <
+    output: h <
+
+    input: h<
+    output: h<|>
+
+    input: h<|> press <BR>
+    output: h|
+
+    pair: '\ws<': '>' (WRONG pair which missed \zs)
+    input: h<|> press <BR>
+    output: | (charactor 'h' is deleted)
+
+
+    the 'begin' 'end' pair write in
+
+    au FileType ruby     let b:AutoPairs = AutoPairsDefine({'\v(^|[^\w])\zsbegin': 'end//n'})
+
+    will be better, only auto pair when at start of line or follow non-word text
+
+
 Known Issues
 -----------------------
 Breaks '.' - [issue #3](https://github.com/jiangmiao/auto-pairs/issues/3)

From 4d5060c80c1e78e6670e2092c44cee4dcb04cb04 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 17:17:06 +0800
Subject: [PATCH 09/16] Add wild closed pair

---
 README.md             | 22 ++++++++++++++--------
 plugin/auto-pairs.vim |  6 +++---
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index fda583f..667e9ed 100644
--- a/README.md
+++ b/README.md
@@ -57,13 +57,6 @@ Features
 
 *   Fast Wrap
 
-        input: |'hello' (press (<M-e> at |)
-        output: ('hello')
-
-        wrap string, only support c style string
-        input: |'h\\el\'lo' (press (<M-e> at |)
-        output ('h\\ello\'')
-
         input: |[foo, bar()] (press (<M-e> at |)
         output: ([foo, bar()])
 
@@ -250,6 +243,13 @@ Options
         Map <M-(> <M-)> <M-[> <M-]> <M-{> <M-}> <M-"> <M-'> to
         move character under the cursor to the pair.
 
+*   g:AutoPairsWildClosedPair
+
+        Default: ']'
+
+        Jump over following closed pair
+        for pair {'begin': 'end//n]'}, e is not mapped, use wild closed pair ] to jump over 'end'
+
 Buffer Level Pairs Setting
 --------------------------
 
@@ -290,7 +290,13 @@ Multibyte Pairs
     The default pairs is {'(':')', '[':']', '{':'}',"'":"'",'"':'"', '`':'`'}
     You could also define multibyte pairs such as <!-- -->, <% %> and so on
 
-    Here are some examples
+* Function AutoPairsDefine(addPairs:dict[, removeOpenPairList:list])
+
+    add or delete pairs base on g:AutoPairs
+
+    eg:
+        au FileType html let b:AutoPairs = AutoPairsDefine({'<!--' : '-->'}, ['{'])
+        add <!-- --> pair and remove '{' for html file
 
 * General usage
 
diff --git a/plugin/auto-pairs.vim b/plugin/auto-pairs.vim
index 2cb6340..ae79b32 100644
--- a/plugin/auto-pairs.vim
+++ b/plugin/auto-pairs.vim
@@ -2,7 +2,7 @@
 " Maintainer:	JiangMiao <jiangfriend@gmail.com>
 " Contributor: camthompson
 " Last Change:  2019-01-15
-" Version: 1.3.4
+" Version: 2.0.0
 " Homepage: http://www.vim.org/scripts/script.php?script_id=3599
 " Repository: https://github.com/jiangmiao/auto-pairs
 " License: MIT
@@ -185,8 +185,8 @@ func! AutoPairsInsert(key)
 
   " check close pairs
   for [open, close] in b:AutoPairsList
-    if close[0] == a:key
-      let m = s:matchbegin(after, '\v\s*\V'.close)
+    if a:key == g:AutoPairsWildClosedPair || close[0] == a:key
+      let m = s:matchbegin(after, '\v\s*\zs\V'.close)
       if len(m) > 0
         " skip close pair
         call search(m[1], 'We')

From 177664ab1aa9b12e50134a4b004ddb5e694cd115 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 18:40:51 +0800
Subject: [PATCH 10/16] Update README

---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index 667e9ed..944201a 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,7 @@ Insert or delete brackets, parens, quotes in pair.
 
 Installation
 ------------
+
 copy plugin/auto-pairs.vim to ~/.vim/plugin
 
 or if you are using `pathogen`:
@@ -249,6 +250,7 @@ Options
 
         Jump over following closed pair
         for pair {'begin': 'end//n]'}, e is not mapped, use wild closed pair ] to jump over 'end'
+        use <M-b> to back insert ] after jumping
 
 Buffer Level Pairs Setting
 --------------------------
@@ -259,6 +261,7 @@ eg:
 
     " When the filetype is FILETYPE then make AutoPairs only match for parenthesis
     au Filetype FILETYPE let b:AutoPairs = {"(": ")"}
+    au FileType php      let b:AutoPairs = AutoPairsDefine({'<?' : '?>', '<?php': '?>'})
 
 TroubleShooting
 ---------------
@@ -298,6 +301,8 @@ Multibyte Pairs
         au FileType html let b:AutoPairs = AutoPairsDefine({'<!--' : '-->'}, ['{'])
         add <!-- --> pair and remove '{' for html file
 
+    the pair implict start with \V, so if want to match start of line ^ should be write in \^ vim comment {'\^"': ''}
+
 * General usage
 
     au FileType php      let b:AutoPairs = AutoPairsDefine({'<?' : '?>', '<?php': '?>'})

From bec90a4076cd559e290b61abda8073800f06c720 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 18:52:47 +0800
Subject: [PATCH 11/16] Update README

---
 README.md | 92 +++++++++++++++++++++++++++----------------------------
 1 file changed, 46 insertions(+), 46 deletions(-)

diff --git a/README.md b/README.md
index e1fe0bb..41b351b 100644
--- a/README.md
+++ b/README.md
@@ -296,86 +296,86 @@ Multibyte Pairs
 
 * Function AutoPairsDefine(addPairs:dict[, removeOpenPairList:list])
 
-    add or delete pairs base on g:AutoPairs
+        add or delete pairs base on g:AutoPairs
 
-    eg:
-        au FileType html let b:AutoPairs = AutoPairsDefine({'<!--' : '-->'}, ['{'])
-        add <!-- --> pair and remove '{' for html file
+        eg:
+            au FileType html let b:AutoPairs = AutoPairsDefine({'<!--' : '-->'}, ['{'])
+            add <!-- --> pair and remove '{' for html file
 
-    the pair implict start with \V, so if want to match start of line ^ should be write in \^ vim comment {'\^"': ''}
+        the pair implict start with \V, so if want to match start of line ^ should be write in \^ vim comment {'\^"': ''}
 
 * General usage
 
-    au FileType php      let b:AutoPairs = AutoPairsDefine({'<?' : '?>', '<?php': '?>'})
+        au FileType php      let b:AutoPairs = AutoPairsDefine({'<?' : '?>', '<?php': '?>'})
 
-    the first key of closed pair ? will be mapped
+        the first key of closed pair ? will be mapped
 
-    pairs: '<?' : '?>', '<?php': '?>'
-    input: <?
-    output: <?|?>
+        pairs: '<?' : '?>', '<?php': '?>'
+        input: <?
+        output: <?|?>
 
-    input: <?php
-    output: <?php|?>
+        input: <?php
+        output: <?php|?>
 
-    input: he<?php|?> (press <BS> at|)
-    output: he|
+        input: he<?php|?> (press <BS> at|)
+        output: he|
 
-    input: <?php|?> (press ? at|)
-    output: <?php?>|
+        input: <?php|?> (press ? at|)
+        output: <?php?>|
 
-    pair: '[[':']]'
-    input: [[|]] (press <BR>)
-    output: | ([[ and ]] will be deleted the [['s priority is higher than [ for it's longer)
+        pair: '[[':']]'
+        input: [[|]] (press <BR>)
+        output: | ([[ and ]] will be deleted the [['s priority is higher than [ for it's longer)
 
 * Modifier
 
-    The text after //  in close pair is modifiers
+        The text after //  in close pair is modifiers
 
-    n - do not map the first charactor of closed pair
+        n - do not map the first charactor of closed pair
 
-    for 'begin' 'end' pair, e is a charactor, if map e to jump will be annoy, so use modifier 'n' to skip key map
+        for 'begin' 'end' pair, e is a charactor, if map e to jump will be annoy, so use modifier 'n' to skip key map
 
-    au FileType ruby     let b:AutoPairs = AutoPairsDefine({'begin': 'end//n]'})
+        au FileType ruby     let b:AutoPairs = AutoPairsDefine({'begin': 'end//n]'})
 
 
-    input: begin
-    output: begin|end
+        input: begin
+        output: begin|end
 
-    input: begin|end (press <BR> on |)
-    output: |
+        input: begin|end (press <BR> on |)
+        output: |
 
-    input: begin|end (press e on |)
-    output: begineend (will not jump for e is not mapped)
+        input: begin|end (press e on |)
+        output: begineend (will not jump for e is not mapped)
 
 * Advanced usage
 
-    au FileType rust     let b:AutoPairs = AutoPairsDefine({'\w\zs<': '>'})
+        au FileType rust     let b:AutoPairs = AutoPairsDefine({'\w\zs<': '>'})
 
-    if press < after a word will generate the pair
+        if press < after a word will generate the pair
 
-    when use regexp MUST use \zs to prevent catching
-    if use '\w<' without \zs,  for text hello<|> press <BS> on | will output 'hell', the 'o' has been deleted
+        when use regexp MUST use \zs to prevent catching
+        if use '\w<' without \zs,  for text hello<|> press <BS> on | will output 'hell', the 'o' has been deleted
 
-    pair: '\w\zs<': '>'
-    input: h <
-    output: h <
+        pair: '\w\zs<': '>'
+        input: h <
+        output: h <
 
-    input: h<
-    output: h<|>
+        input: h<
+        output: h<|>
 
-    input: h<|> press <BR>
-    output: h|
+        input: h<|> press <BR>
+        output: h|
 
-    pair: '\ws<': '>' (WRONG pair which missed \zs)
-    input: h<|> press <BR>
-    output: | (charactor 'h' is deleted)
+        pair: '\ws<': '>' (WRONG pair which missed \zs)
+        input: h<|> press <BR>
+        output: | (charactor 'h' is deleted)
 
 
-    the 'begin' 'end' pair write in
+        the 'begin' 'end' pair write in
 
-    au FileType ruby     let b:AutoPairs = AutoPairsDefine({'\v(^|[^\w])\zsbegin': 'end//n'})
+        au FileType ruby     let b:AutoPairs = AutoPairsDefine({'\v(^|[^\w])\zsbegin': 'end//n'})
 
-    will be better, only auto pair when at start of line or follow non-word text
+        will be better, only auto pair when at start of line or follow non-word text
 
 
 Known Issues

From 3c7fde2643f1c611c15cb9c30e124d49dca1a4ef Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 19:08:18 +0800
Subject: [PATCH 12/16] Update README

---
 README.md | 57 +++++++++++++++++++++++++++----------------------------
 1 file changed, 28 insertions(+), 29 deletions(-)

diff --git a/README.md b/README.md
index 41b351b..3aa8cb8 100644
--- a/README.md
+++ b/README.md
@@ -84,11 +84,6 @@ Features
 
         }|
 
-*  Multibyte Pairs
-        
-        Support any multibyte pairs such as <!-- -->, <% %>, """ """
-        See multibyte pairs section for details
-
 *  Fly Mode
 
         input: if(a[3)
@@ -118,6 +113,11 @@ Features
 
         See Fly Mode section for details
 
+*  Multibyte Pairs
+        
+        Support any multibyte pairs such as <!-- -->, <% %>, """ """
+        See multibyte pairs section for details
+
 Fly Mode
 --------
 Fly Mode will always force closed-pair jumping instead of inserting. only for ")", "}", "]"
@@ -264,30 +264,6 @@ eg:
     au Filetype FILETYPE let b:AutoPairs = {"(": ")"}
     au FileType php      let b:AutoPairs = AutoPairsDefine({'<?' : '?>', '<?php': '?>'})
 
-TroubleShooting
----------------
-    The script will remap keys ([{'"}]) <BS>,
-    If auto pairs cannot work, use :imap ( to check if the map is corrected.
-    The correct map should be <C-R>=AutoPairsInsert("\(")<CR>
-    Or the plugin conflict with some other plugins.
-    use command :call AutoPairsInit() to remap the keys.
-
-
-* How to insert parens purely
-
-    There are 3 ways
-
-    1. use Ctrl-V ) to insert paren without trigger the plugin.
-
-    2. use Alt-P to turn off the plugin.
-
-    3. use DEL or <C-O>x to delete the character insert by plugin.
-
-* Swedish Character Conflict
-
-    Because AutoPairs uses Meta(Alt) key as shortcut, it is conflict with some Swedish character such as å.
-    To fix the issue, you need remap or disable the related shortcut.
-
 Multibyte Pairs
 ---------------
 
@@ -377,6 +353,29 @@ Multibyte Pairs
 
         will be better, only auto pair when at start of line or follow non-word text
 
+TroubleShooting
+---------------
+    The script will remap keys ([{'"}]) <BS>,
+    If auto pairs cannot work, use :imap ( to check if the map is corrected.
+    The correct map should be <C-R>=AutoPairsInsert("\(")<CR>
+    Or the plugin conflict with some other plugins.
+    use command :call AutoPairsInit() to remap the keys.
+
+
+* How to insert parens purely
+
+    There are 3 ways
+
+    1. use Ctrl-V ) to insert paren without trigger the plugin.
+
+    2. use Alt-P to turn off the plugin.
+
+    3. use DEL or <C-O>x to delete the character insert by plugin.
+
+* Swedish Character Conflict
+
+    Because AutoPairs uses Meta(Alt) key as shortcut, it is conflict with some Swedish character such as å.
+    To fix the issue, you need remap or disable the related shortcut.
 
 Known Issues
 -----------------------

From ea2fd8a2deb77a33dd8849c7fa7383b84317b684 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 19:10:52 +0800
Subject: [PATCH 13/16] Update README

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 3aa8cb8..c80af60 100644
--- a/README.md
+++ b/README.md
@@ -300,7 +300,7 @@ Multibyte Pairs
         output: <?php?>|
 
         pair: '[[':']]'
-        input: [[|]] (press <BR>)
+        input: [[|]] (press <BS>)
         output: | ([[ and ]] will be deleted the [['s priority is higher than [ for it's longer)
 
 * Modifier
@@ -317,7 +317,7 @@ Multibyte Pairs
         input: begin
         output: begin|end
 
-        input: begin|end (press <BR> on |)
+        input: begin|end (press <BS> on |)
         output: |
 
         input: begin|end (press e on |)
@@ -339,11 +339,11 @@ Multibyte Pairs
         input: h<
         output: h<|>
 
-        input: h<|> press <BR>
+        input: h<|> press <BS>
         output: h|
 
         pair: '\ws<': '>' (WRONG pair which missed \zs)
-        input: h<|> press <BR>
+        input: h<|> press <BS>
         output: | (charactor 'h' is deleted)
 
 

From 423ee192c727bc27e272a28fbb3f951a9548a765 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 19:38:21 +0800
Subject: [PATCH 14/16] Prevent jumping multi line if open pair equals close
 pair

---
 README.md             | 2 +-
 plugin/auto-pairs.vim | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index c80af60..862c9b9 100644
--- a/README.md
+++ b/README.md
@@ -342,7 +342,7 @@ Multibyte Pairs
         input: h<|> press <BS>
         output: h|
 
-        pair: '\ws<': '>' (WRONG pair which missed \zs)
+        pair: '\w<': '>' (WRONG pair which missed \zs)
         input: h<|> press <BS>
         output: | (charactor 'h' is deleted)
 
diff --git a/plugin/auto-pairs.vim b/plugin/auto-pairs.vim
index 6509c31..a79dd4e 100644
--- a/plugin/auto-pairs.vim
+++ b/plugin/auto-pairs.vim
@@ -114,12 +114,12 @@ func! s:backspace(s)
   return repeat("\<BS>", s:ulen(a:s))
 endf
 
-func! s:getline()
+func! s:getline(...)
   let line = getline('.')
   let pos = col('.') - 1
   let before = strpart(line, 0, pos)
   let after = strpart(line, pos)
-  if g:AutoPairsMultilineClose
+  if a:0 == 0 && g:AutoPairsMultilineClose
     let n = line('$')
     let i = line('.')+1
     while i <= n
@@ -186,6 +186,9 @@ func! AutoPairsInsert(key)
   " check close pairs
   for [open, close] in b:AutoPairsList
     if a:key == g:AutoPairsWildClosedPair || close[0] == a:key
+      if open == close
+        let [before, after] = s:getline(0)
+      end
       let m = s:matchbegin(after, '\v\s*\zs\V'.close)
       if len(m) > 0
         " skip close pair

From 7d721d261f18127ae6fb1220ab226d2593db2e7a Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 21:33:19 +0800
Subject: [PATCH 15/16] Indent line when return

---
 plugin/auto-pairs.vim | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/plugin/auto-pairs.vim b/plugin/auto-pairs.vim
index a79dd4e..e791c42 100644
--- a/plugin/auto-pairs.vim
+++ b/plugin/auto-pairs.vim
@@ -336,7 +336,8 @@ func! AutoPairsReturn()
   let after = getline('.')
   let cmd = ''
   for [open, close] in b:AutoPairsList
-    if before =~ '\V'.open.'\v\s*$' && after =~ '^\s*\V'.close
+    "  before =~ '\V'.open.'\v\s*$' &&
+    if after =~ '^\s*\V'.close
       if g:AutoPairsCenterLine && winline() * 3 >= winheight(0) * 2
         " Recenter before adding new line to avoid replacing line content
         let cmd = "zz"

From 38d53d4df05ddec3a75fa801c4ba8600b8fcd4a9 Mon Sep 17 00:00:00 2001
From: Miao Jiang <jiangfriend@gmail.com>
Date: Tue, 15 Jan 2019 22:26:37 +0800
Subject: [PATCH 16/16] Close empty pairs smartly

---
 plugin/auto-pairs.vim | 43 ++++++++++++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 17 deletions(-)

diff --git a/plugin/auto-pairs.vim b/plugin/auto-pairs.vim
index e791c42..d329bb5 100644
--- a/plugin/auto-pairs.vim
+++ b/plugin/auto-pairs.vim
@@ -114,11 +114,12 @@ func! s:backspace(s)
   return repeat("\<BS>", s:ulen(a:s))
 endf
 
-func! s:getline(...)
+func! s:getline()
   let line = getline('.')
   let pos = col('.') - 1
   let before = strpart(line, 0, pos)
   let after = strpart(line, pos)
+  let afterline = after
   if a:0 == 0 && g:AutoPairsMultilineClose
     let n = line('$')
     let i = line('.')+1
@@ -131,7 +132,7 @@ func! s:getline(...)
       let i = i+1
     endwhile
   end
-  return [before, after]
+  return [before, after, afterline]
 endf
 
 " split text to two part
@@ -176,7 +177,7 @@ func! AutoPairsInsert(key)
 
   let b:autopairs_saved_pair = [a:key, getpos('.')]
 
-  let [before, after] = s:getline()
+  let [before, after, afterline] = s:getline()
 
   " Ignore auto close if prev character is \
   if before[-1:-1] == '\'
@@ -186,16 +187,20 @@ func! AutoPairsInsert(key)
   " check close pairs
   for [open, close] in b:AutoPairsList
     if a:key == g:AutoPairsWildClosedPair || close[0] == a:key
-      if open == close
-        let [before, after] = s:getline(0)
-      end
-      let m = s:matchbegin(after, '\v\s*\zs\V'.close)
-      if len(m) > 0
-        " skip close pair
-        let c = matchstr(after, '^\V'.close)
-        if c != ""
-          return s:right(c)
+      " the close pair is in the same line
+      let m = matchstr(afterline, '^\v\s*\V'.close)
+      if m != ''
+        if before =~ '\V'.open.'\v\s*$' && m[0] =~ '\v\s'
+          " remove the space we inserted if the text in pairs is blank
+          return "\<DEL>".s:right(m[1:])
         else
+          return s:right(m)
+        end
+      end
+      if open != close
+        let m = s:matchend(after, '^\v\s*\zs\V'.close)
+        if len(m) > 0
+          " skip close pair greedy
           call search(m[1], 'We')
           return "\<Right>"
         end
@@ -265,7 +270,7 @@ func! AutoPairsDelete()
     return "\<BS>"
   end
 
-  let [before, after] = s:getline()
+  let [before, after, ig] = s:getline()
   for [open, close] in b:AutoPairsList
     let b = matchstr(before, '\V'.open.'\v\s?$')
     let a = matchstr(after, '^\v\s*\V'.close)
@@ -288,7 +293,7 @@ endf
 func! AutoPairsFastWrap()
   let c = @"
   normal! x
-  let [before, after] = s:getline()
+  let [before, after, ig] = s:getline()
   if after[0] =~ '\v[\{\[\(\<]'
     normal! %
     normal! p
@@ -301,8 +306,12 @@ func! AutoPairsFastWrap()
         return ""
       end
     endfor
-    normal! e
-    normal! p
+    if after[1:1] =~ '\v[a-zA-Z0-9_]'
+      normal! e
+      normal! p
+    else
+      normal! p
+    end
   end
   let @" = c
   return ""
@@ -367,7 +376,7 @@ func! AutoPairsSpace()
     return "\<SPACE>"
   end
 
-  let [before, after] = s:getline()
+  let [before, after, ig] = s:getline()
 
   for [open, close] in b:AutoPairsList
     if before =~ '\V'.open.'\v$' && after =~ '^\V'.close