From d25ef8c287e04909d64e7de107031a73b7709ec3 Mon Sep 17 00:00:00 2001
From: Austin Ziegler <austin@zieglers.ca>
Date: Tue, 10 Sep 2024 17:16:00 -0400
Subject: [PATCH] vim9script Port of vim-unimpaired

- Expose most of the functions used for map building through autoload so
  that others can more easily add maps in the same manner without
  copying code.

- Incorporate tpope/vim-unimpaired#230, tpope/vim-unimpaired#228

- Use <ScriptCmd> instead of `:<C-U>`, which required some rethinking
  because of the use of `<C-R>=`.

- Added additional maps from
  - phongnh/vim-toggler: conceallevel, showmatch, incsearch, expandtab,
    showcmd
  - riceissa/vim-more-toggling: syntax
---
 .github/FUNDING.yml          |   5 +-
 README.markdown => README.md |  58 ++--
 autoload/pairs.vim           | 558 +++++++++++++++++++++++++++++++
 doc/pairs.txt                | 198 +++++++++++
 doc/unimpaired.txt           | 165 ----------
 plugin/pairs.vim             | 181 ++++++++++
 plugin/unimpaired.vim        | 623 -----------------------------------
 7 files changed, 971 insertions(+), 817 deletions(-)
 rename README.markdown => README.md (57%)
 create mode 100644 autoload/pairs.vim
 create mode 100644 doc/pairs.txt
 delete mode 100644 doc/unimpaired.txt
 create mode 100644 plugin/pairs.vim
 delete mode 100644 plugin/unimpaired.vim

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index e2a49d1..be9531e 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,2 +1,3 @@
-github: tpope
-custom: ["https://www.paypal.me/vimpope"]
+github: halostatue
+buy_me_a_coffee: halostatue
+ko_fi: halostatue
diff --git a/README.markdown b/README.md
similarity index 57%
rename from README.markdown
rename to README.md
index e5ab747..6d7fbcb 100644
--- a/README.markdown
+++ b/README.md
@@ -1,31 +1,34 @@
+# vim-pairs
+
+This is a vim 9 fork of [tpope/vim-unimpaired][unimpaired].
+
 # unimpaired.vim
 
-Much of unimpaired.vim was extracted from my vimrc when I noticed a
-pattern: complementary pairs of mappings.  They mostly fall into four
-categories.
+Much of unimpaired.vim was extracted from my vimrc when I noticed a pattern:
+complementary pairs of mappings. They mostly fall into four categories.
 
-There are mappings which are simply short normal mode aliases for
-commonly used ex commands. `]q` is :cnext. `[q` is :cprevious. `]a` is
-:next.  `[b` is :bprevious.  See the documentation for the full set of
-20 mappings and mnemonics.  All of them take a count.
+There are mappings which are simply short normal mode aliases for commonly used
+ex commands. `]q` is :cnext. `[q` is :cprevious. `]a` is :next. `[b` is
+:bprevious. See the documentation for the full set of 20 mappings and mnemonics.
+All of them take a count.
 
-There are linewise mappings. `[<Space>` and `]<Space>` add newlines
-before and after the cursor line. `[e` and `]e` exchange the current
-line with the one above or below it.
+There are linewise mappings. `[<Space>` and `]<Space>` add newlines before and
+after the cursor line. `[e` and `]e` exchange the current line with the one
+above or below it.
 
 There are mappings for toggling options. `[os`, `]os`, and `yos` perform
-`:set spell`, `:set nospell`, and `:set invspell`, respectively.  There's also
-`l` (`list`), `n` (`number`), `w` (`wrap`), `x` (`cursorline cursorcolumn`),
-and several others, plus mappings to help alleviate the `set paste` dance.
-Consult the documentation.
+`:set spell`, `:set nospell`, and `:set invspell`, respectively. There's also
+`l` (`list`), `n` (`number`), `w` (`wrap`), `x` (`cursorline cursorcolumn`), and
+several others, plus mappings to help alleviate the `set paste` dance. Consult
+the documentation.
 
-There are mappings for encoding and decoding. `[x` and `]x` encode and
-decode XML (and HTML). `[u` and `]u` encode and decode URLs. `[y` and
-`]y` do C String style escaping.
+There are mappings for encoding and decoding. `[x` and `]x` encode and decode
+XML (and HTML). `[u` and `]u` encode and decode URLs. `[y` and `]y` do C String
+style escaping.
 
 And in the miscellaneous category, there's `[f` and `]f` to go to the
-next/previous file in the directory, and `[n` and `]n` to jump between
-SCM conflict markers.
+next/previous file in the directory, and `[n` and `]n` to jump between SCM
+conflict markers.
 
 The `.` command works with all operator mappings, and will work with the
 linewise mappings as well if you install
@@ -43,7 +46,7 @@ support:
 
 ## FAQ
 
-> My non-US keyboard makes it hard to type `[` and `]`.  Can I configure
+> My non-US keyboard makes it hard to type `[` and `]`. Can I configure
 > different prefix characters?
 
 The easiest solution is to map to `[` and `]` directly:
@@ -55,7 +58,7 @@ The easiest solution is to map to `[` and `]` directly:
     xmap < [
     xmap > ]
 
-Note we're not using the `noremap` family because we *do* want to recursively
+Note we're not using the `noremap` family because we _do_ want to recursively
 invoke unimpaired.vim's maps.
 
 ## Contributing
@@ -67,12 +70,13 @@ See the contribution guidelines for
 
 Like unimpaired.vim? Follow the repository on
 [GitHub](https://github.com/tpope/vim-unimpaired) and vote for it on
-[vim.org](http://www.vim.org/scripts/script.php?script_id=1590).  And if
-you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
-[Twitter](http://twitter.com/tpope) and
-[GitHub](https://github.com/tpope).
+[vim.org](http://www.vim.org/scripts/script.php?script_id=1590). And if you're
+feeling especially charitable, follow [tpope](http://tpo.pe/) on
+[Twitter](http://twitter.com/tpope) and [GitHub](https://github.com/tpope).
 
 ## License
 
-Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
-See `:help license`.
+Copyright (c) Tim Pope. Distributed under the same terms as Vim itself. See
+`:help license`.
+
+[unimpaired]: https://github.com/tpope/vim-unimpaired
diff --git a/autoload/pairs.vim b/autoload/pairs.vim
new file mode 100644
index 0000000..fbdd0c1
--- /dev/null
+++ b/autoload/pairs.vim
@@ -0,0 +1,558 @@
+vim9script
+
+# autoload/pairs.vim: Functions used for defining pair definitions. Translated to
+# vim9script from tpope/vim-unimpaired.
+
+# Returns the string to define a single mapping `lhs` in `mode` that will execute `rhs`.
+#
+# If `rhs` does not begin with `<Plug>`, then `<script>` will be added to the `flags`. The
+# `flags` values can be any :map-arguments value (<buffer>, <nowait>, <silent>, <special>,
+# <script>, <expr>, <unique>).
+#
+# If `g:<mode>remap` is a dictionary, the `lhs` will be modified based on successive
+# lookups in this dictionary. The following replaces `[` and `]` mappings with `<` and `>`
+# mappings. The lookup will be performed by removing characters from the end of `lhs` to
+# allow for more specific to less specific matches.
+#
+#     g:nremap = { "[": "<", "]": ">" }
+#     g:xremap = { "[": "<", "]": ">" }
+#     g:oremap = { "[": "<", "]": ">" }
+#
+# If the target value is blank or `<skip>`, the mapping will be ignored.
+#
+# See tpope/vim-unimpaired#145 and tpope/vim-unimpaired@1a4bfc16b625.
+export def Map(mode: string, base_lhs: string, rhs: string, flags: string = ''): string
+  var skip = false
+  var head = base_lhs
+  var tail = ''
+
+  var remaps = g:->get(mode .. 'remap', {})
+
+  if type(remaps) == v:t_dict && !remaps->empty()
+    while !head->empty()
+      if remaps->has_key(head)
+        head = remaps[head]
+
+        if head->empty() || head ==? '<skip>'
+          skip = true
+        endif
+
+        break
+      endif
+
+      tail = head->matchstr('<[^<>]*>$\|.$') .. tail
+      head = head->substitute('<[^<>]*>$\|.$', '', '')
+    endwhile
+  endif
+
+  var lhs = head .. tail
+
+  if !skip && maparg(lhs, mode)->empty()
+    var dfn = [mode .. 'map']
+    var dflags = flags .. (flags !~? '<script>' && rhs =~? '^<Plug>' ? '' : '<script>')
+
+    if !dflags->empty()
+      dfn->add(dflags)
+    endif
+
+    dfn->extend([lhs, rhs])
+
+    return dfn->join(' ')
+  endif
+
+  return ''
+enddef
+
+# Map a family of commands: next, previous, first, and last.
+export def MapNextFamily(base_map: string, base_cmd: string, current: string)
+  var prefix = $"<Plug>(pairs-{base_cmd}" # <Plug>(pairs-b
+  var cmd = $"\" .. (v:count ? v:count : \"\") .. \"{base_cmd}"
+  var zv = (base_cmd ==# 'l' || base_cmd ==# 'c' ? 'zv' : '')
+  var tail = '<CR>' .. zv
+
+  # <Plug>(pairs-bprevious) => :bprevious
+  execute $"nnoremap <silent> {prefix}previous) :<C-U>execute \"{cmd}previous\"{tail}"
+  execute $"nnoremap <silent> {prefix}next) :<C-U>execute \"{cmd}next\"{tail}"
+  execute $"nnoremap {prefix}first) "
+    .. $":<C-U><C-R>=v:count ? v:count .. \"{current}\" : \"{base_cmd}first\"<CR><CR>{zv}"
+  execute $"nnoremap {prefix}last) "
+    .. $":<C-U><C-R>=v:count ? v:count .. \"{current}\" : \"{base_cmd}last\"<CR><CR>{zv}"
+
+  # <Plug>PairsBPrevious => :bprevious
+
+  execute Map('n', $"[{base_map}", $"{prefix}previous)")
+  execute Map('n', $"]{base_map}", $"{prefix}next)")
+  execute Map('n', $"[{base_map->toupper()}", $"{prefix}first)")
+  execute Map('n', $"]{base_map->toupper()}", $"{prefix}last)")
+
+  if base_cmd ==# 'c' || base_cmd == 'l'
+    execute $"nnoremap <silent> {prefix}pfile) :<C-U>execute \"{cmd}pfile\"{tail}"
+    execute $"nnoremap <silent> {prefix}nfile) :<C-U>execute \"{cmd}nfile\"{tail}"
+    execute Map('n', $"[<C-{base_map->toupper()}>", $"{prefix}pfile)")
+    execute Map('n', $"]<C-{base_map->toupper()}>", $"{prefix}nfile)")
+  endif
+
+  if base_cmd ==# 't'
+    nnoremap <silent> <Plug>(pairs-ptprevious) :<C-U>execute v:count1 .. "ptprevious"<CR>
+    nnoremap <silent> <Plug>(pairs-ptnext) :<C-U>execute v:count1 .. "ptnext"<CR>
+    execute Map('n', '[<C-T>', '<Plug>(pairs-ptprevious)')
+    execute Map('n', ']<C-T>', '<Plug>(pairs-ptnext)')
+  endif
+enddef
+
+def Entries(base_path: string): list<string>
+  var path = base_path
+    ->substitute('[\\/]$', '', '')
+    ->substitute('[[$*]', '[&]', 'g')
+  var files = glob(path .. '/.*')->split("\n") + glob(path .. '/*')->split("\n")
+
+  files = files
+    ->map((_, v) => v->substitute("[\\/]$", "", ""))
+    ->filter((_, v) => v !~# "[\\\\/]\\.\\.\\=$")
+
+  var filter_suffixes = &suffixes
+    ->escape('~.*$^')
+    ->split(',')
+    ->filter((_, v) => !v->empty())
+
+  if !filter_suffixes->empty()
+    filter_suffixes = filter_suffixes->join('$\|') .. '$'
+    files = files->filter((_, v) -> v !~# filter_suffixes)
+  endif
+
+  return files->sort()
+enddef
+
+def FileByOffset(offset: number): string
+  var file = expand('%:p')
+
+  if file->empty()
+    file = getcwd() .. '/'
+  endif
+
+  var pos = offset
+
+  while pos != 0
+    var files = Entries(file->fnamemodify(':h'))
+
+    files = offset < 0
+      ? files->filter((_, v) => v <# file)->reverse()
+      : files->filter((_, v) => v ># file)
+
+    var temp = files->get(0, '')
+
+    if temp->empty()
+      file = file->fnamemodify(':h')
+    else
+      file = temp
+      var found = 1
+
+      while file->isdirectory()
+        files = Entries(file)
+
+        if files->empty()
+          found = 0
+          break
+        endif
+
+        file = files[pos > 0 ? 0 : -1]
+      endwhile
+
+      pos += (pos > 0 ? -1 : 1) * found
+    endif
+  endwhile
+
+  return file
+enddef
+
+def GetWindow(): dict<any>
+  return win_getid()->getwininfo()->get(0, {})
+enddef
+
+export def PreviousFileEntry(count: number): string
+  var window = GetWindow()
+
+  return window->get('loclist')
+    ? 'lolder ' .. count
+    : window->get('quickfix')
+    ? 'colder ' .. count
+    : 'edit ' .. fnameescape(fnamemodify(FileByOffset(-count), ':.'))
+enddef
+
+export def NextFileEntry(count: number): string
+  var window = GetWindow()
+
+
+  return window->get('loclist')
+    ? 'lnewer ' .. count
+    : window->get('quickfix')
+    ? 'cnewer ' .. count
+    : 'edit ' .. fnameescape(fnamemodify(FileByOffset(count), ':.'))
+enddef
+
+export def Context(reverse: bool): number
+  return search('^\(@@ .* @@\|[<=>|]\{7}[<=>|]\@!\)', reverse ? 'bW' : 'W')
+enddef
+
+export def ContextMotion(reverse: bool)
+  if reverse
+    normal -
+  endif
+
+  search('^@@ .* @@\|^diff \|^[<=>|]\{7}[<=>|]\@!', 'bWc')
+
+  var end: number = 0
+
+  if getline('.') =~# '^diff '
+    end = search('^diff ', 'Wn') - 1
+    if end < 0
+      end = line('$')
+    endif
+  elseif getline('.') =~# '^@@ '
+    end = search('^@@ .* @@\|^diff ', 'Wn') - 1
+    if end < 0
+      end = line('$')
+    endif
+  elseif getline('.') =~# '^=\{7\}'
+    normal +
+    end = search('^>\{7}>\@!', 'Wnc')
+  elseif getline('.') =~# '^[<=>|]\{7\}'
+    end = search('^[<=>|]\{7}[<=>|]\@!', 'Wn') - 1
+  else
+    return
+  endif
+
+  if end > line('.')
+    execute 'normal! V' .. (end - line('.')) .. 'j'
+  elseif end == line('.')
+    normal! V
+  endif
+enddef
+
+export def BlankUp(): string
+  var cmd = $"put!=repeat(nr2char(10), v:count1)|silent normal '']+"
+  if &modifiable
+    cmd ..= $"|silent! call repeat#set(\"<Plug>(pairs-blank-up)\", v:count1)"
+  endif
+  return cmd
+enddef
+
+export def BlankDown(): string
+  var cmd = $"put =repeat(nr2char(10), v:count1)|silent normal ''[-"
+  if &modifiable
+    cmd ..= $"|silent! call repeat#set(\"<Plug>(pairs-blank-down)\", v:count1)"
+  endif
+  return cmd
+enddef
+
+def ExecCopyMove(cmd: string)
+  var old_fdm = &foldmethod
+
+  if old_fdm !=# 'manual'
+    setlocal foldmethod=manual
+    &foldmethod = 'manual'
+  endif
+
+  normal! m`
+  # silent! execute cmd
+  execute cmd
+  normal! ``
+
+  if old_fdm !=# 'manual'
+    &foldmethod = old_fdm
+  endif
+enddef
+
+export def CopyMove(action: string, cmd: string, count: any, map: string)
+  ExecCopyMove($"{action} {cmd}{count}")
+  silent! call repeat#set($"\<Plug>(pairs-{action}-{map})", count)
+enddef
+
+export def CopyMoveSelectionUp(action: string, count: any)
+  ExecCopyMove($"'<,'>{action} '<--{count}")
+  silent! call repeat#set($"\<Plug>(pairs-{action}-selection-up)", count)
+enddef
+
+export def CopyMoveSelectionDown(action: string, count: any)
+  ExecCopyMove($"'<,'>{action} '>+{count}")
+  silent! call repeat#set("\<Plug>(pairs-{action}-selection-down)", count)
+enddef
+
+def StatuslineRefresh(): string
+  &l:readonly = &l:readonly
+  return ''
+enddef
+
+export def CursorOptions(): string
+  return &cursorline && &cursorcolumn ? 'nocursorline nocursorcolumn' : 'cursorline cursorcolumn'
+enddef
+
+# Define a feature for a given mapset. `mapset` must be a list of strings representing
+# multiple characters to map for the same toggle or a single string for a short map.
+#
+# The feature dictionary must have `enable`, `disable` and either `test` or `toggle` keys.
+# If `test` is present, it will be turned into a conditional expression. Otherwise, the
+# `toggle` value will be used by itself (for a function call). Because `<ScriptCmd>` is
+# used, `<C-R>=` expressions are unavailable in `toggle`, so use `test` instead.
+#
+#     if test
+#       enable
+#     else
+#       disable
+#     endif
+#
+# The feature dictionary may have an `after` key which will be appended to the behaviour.
+export def MapFeature(mapset: any, feature: dict<string>)
+  var maps = type(mapset) == v:t_list ? mapset : [mapset]
+  var tail = feature->get('after', '')
+  var toggle = feature->has_key('test')
+    ? $"if {feature.test}<Bar>{feature.disable}<Bar>else<Bar>{feature.enable}<Bar>endif"
+    : feature.toggle
+
+  if !tail->empty()
+    tail = $"<Bar>{tail}"
+  endif
+
+  for map in maps
+    execute $"nmap <script> <Plug>(pairs-enable){map} <ScriptCmd>{feature.enable}{tail}<CR>"
+    execute $"nmap <script> <Plug>(pairs-disable){map} <ScriptCmd>{feature.disable}{tail}<CR>"
+    execute $"nmap <script> <Plug>(pairs-toggle){map} <ScriptCmd>{toggle}{tail}<CR>"
+  endfor
+enddef
+
+# Map the toggles for a boolean option.
+export def MapBooleanOption(mapset: any, op: string, mode: string)
+  MapFeature(mapset, { enable: $"{mode} {op}", disable: $"{mode} no{op}", test: $"&{op}",
+    after: "StatuslineRefresh()" })
+enddef
+
+export def ColorColumn(should_clear: bool): string
+  if !&colorcolumn->empty()
+    w:colorcolumn = &colorcolumn
+  endif
+  return should_clear ? '' : w:->get('colorcolumn', g:->get('pairs_colorcolumn', '+1'))
+enddef
+
+var Spaste: list<any> = null_list
+
+def RestorePaste()
+  if Spaste != null_list
+    &paste = Spaste[0]
+    &mouse = Spaste[1]
+    Spaste = null_list
+  endif
+
+  autocmd! pairs_paste
+enddef
+
+export def SetupPaste()
+  Spaste = [&paste, &mouse]
+
+  set paste
+  set mouse=
+
+  augroup pairs_paste
+    autocmd!
+    autocmd InsertLeave * <ScriptCmd>RestorePaste()
+    if exists('##ModeChanged')
+      autocmd ModeChanged *:n <ScriptCmd>RestorePaste()
+    else
+      autocmd CursorHold,CursorMoved * <ScriptCmd>RestorePaste()
+    endif
+  augroup END
+enddef
+
+export def Putline(how: string, map: string)
+  var [body, type] = [getreg(v:register), getregtype(v:register)]
+  if type ==# 'V'
+    execute 'normal! "' .. v:register .. how
+  else
+    setreg(v:register, body, 'l')
+    execute 'normal! "' .. v:register .. how
+    setreg(v:register, body, type)
+  endif
+
+  silent! call repeat#set("\<Plug>(pairs-put-" .. map .. ")")
+enddef
+def StringEncode(str: string): string
+  var map = {"\n": 'n', "\r": 'r', "\t": 't', "\b": 'b', "\f": '\f', '"': '"', '\': '\'}
+  return str->substitute(
+    "[\001-\033\\\\\"]",
+    '\="\\" .. get(map, submatch(0), printf("%03o", char2nr(submatch(0))))',
+    'g'
+  )
+enddef
+
+def StringDecode(value: string): string
+  var map = {'n': "\n", 'r': "\r", 't': "\t", 'b': "\b", 'f': "\f", 'e': "\e", 'a': "\001", 'v': "\013", "\n": ''}
+
+  var str = value
+
+  if str =~# '^\s*".\{-\}\\\@<!\%(\\\\\)*"\s*\n\=$'
+    str = str->substitute('^\s*\zs"', '', '')->substitute('"\ze\s*\n\=$', '', '')
+  endif
+
+  return str->substitute(
+    '\\\(\o\{1,3\}\|x\x\{1,2\}\|u\x\{1,4\}\|.\)',
+    '\=get(map, submatch(1), submatch(1) =~? "^[0-9xu]" ? nr2char(str2nr("0" .. substitute(submatch(1), "^[Uu]", "x", ""), 16)) : submatch(1))',
+    'g'
+  )
+enddef
+
+def UrlEncode(str: string): string
+  # iconv trick to convert utf-8 bytes to 8bits indiviual char.
+  return str
+    ->iconv('latin1', 'utf-8')
+    ->substitute('[^A-Za-z0-9_.~-]', '\="%" .. printf("%02X", char2nr(submatch(0)))', 'g')
+enddef
+
+def UrlDecode(value: string): string
+  return value
+    ->substitute('%0[Aa]\n$', '%0A', '')
+    ->substitute('%0[Aa]', '\n', 'g')
+    ->substitute('+', ' ', 'g')
+    ->substitute('%\(\x\x\)', '\=nr2char(str2nr("0x" .. submatch(1), 16))', 'g')
+    ->iconv('utf-8', 'latin1')
+enddef
+
+# HTML entities {{{2
+g:pairs_html_entities = {
+      \ 'nbsp':     160, 'iexcl':    161, 'cent':     162, 'pound':    163,
+      \ 'curren':   164, 'yen':      165, 'brvbar':   166, 'sect':     167,
+      \ 'uml':      168, 'copy':     169, 'ordf':     170, 'laquo':    171,
+      \ 'not':      172, 'shy':      173, 'reg':      174, 'macr':     175,
+      \ 'deg':      176, 'plusmn':   177, 'sup2':     178, 'sup3':     179,
+      \ 'acute':    180, 'micro':    181, 'para':     182, 'middot':   183,
+      \ 'cedil':    184, 'sup1':     185, 'ordm':     186, 'raquo':    187,
+      \ 'frac14':   188, 'frac12':   189, 'frac34':   190, 'iquest':   191,
+      \ 'Agrave':   192, 'Aacute':   193, 'Acirc':    194, 'Atilde':   195,
+      \ 'Auml':     196, 'Aring':    197, 'AElig':    198, 'Ccedil':   199,
+      \ 'Egrave':   200, 'Eacute':   201, 'Ecirc':    202, 'Euml':     203,
+      \ 'Igrave':   204, 'Iacute':   205, 'Icirc':    206, 'Iuml':     207,
+      \ 'ETH':      208, 'Ntilde':   209, 'Ograve':   210, 'Oacute':   211,
+      \ 'Ocirc':    212, 'Otilde':   213, 'Ouml':     214, 'times':    215,
+      \ 'Oslash':   216, 'Ugrave':   217, 'Uacute':   218, 'Ucirc':    219,
+      \ 'Uuml':     220, 'Yacute':   221, 'THORN':    222, 'szlig':    223,
+      \ 'agrave':   224, 'aacute':   225, 'acirc':    226, 'atilde':   227,
+      \ 'auml':     228, 'aring':    229, 'aelig':    230, 'ccedil':   231,
+      \ 'egrave':   232, 'eacute':   233, 'ecirc':    234, 'euml':     235,
+      \ 'igrave':   236, 'iacute':   237, 'icirc':    238, 'iuml':     239,
+      \ 'eth':      240, 'ntilde':   241, 'ograve':   242, 'oacute':   243,
+      \ 'ocirc':    244, 'otilde':   245, 'ouml':     246, 'divide':   247,
+      \ 'oslash':   248, 'ugrave':   249, 'uacute':   250, 'ucirc':    251,
+      \ 'uuml':     252, 'yacute':   253, 'thorn':    254, 'yuml':     255,
+      \ 'OElig':    338, 'oelig':    339, 'Scaron':   352, 'scaron':   353,
+      \ 'Yuml':     376, 'circ':     710, 'tilde':    732, 'ensp':    8194,
+      \ 'emsp':    8195, 'thinsp':  8201, 'zwnj':    8204, 'zwj':     8205,
+      \ 'lrm':     8206, 'rlm':     8207, 'ndash':   8211, 'mdash':   8212,
+      \ 'lsquo':   8216, 'rsquo':   8217, 'sbquo':   8218, 'ldquo':   8220,
+      \ 'rdquo':   8221, 'bdquo':   8222, 'dagger':  8224, 'Dagger':  8225,
+      \ 'permil':  8240, 'lsaquo':  8249, 'rsaquo':  8250, 'euro':    8364,
+      \ 'fnof':     402, 'Alpha':    913, 'Beta':     914, 'Gamma':    915,
+      \ 'Delta':    916, 'Epsilon':  917, 'Zeta':     918, 'Eta':      919,
+      \ 'Theta':    920, 'Iota':     921, 'Kappa':    922, 'Lambda':   923,
+      \ 'Mu':       924, 'Nu':       925, 'Xi':       926, 'Omicron':  927,
+      \ 'Pi':       928, 'Rho':      929, 'Sigma':    931, 'Tau':      932,
+      \ 'Upsilon':  933, 'Phi':      934, 'Chi':      935, 'Psi':      936,
+      \ 'Omega':    937, 'alpha':    945, 'beta':     946, 'gamma':    947,
+      \ 'delta':    948, 'epsilon':  949, 'zeta':     950, 'eta':      951,
+      \ 'theta':    952, 'iota':     953, 'kappa':    954, 'lambda':   955,
+      \ 'mu':       956, 'nu':       957, 'xi':       958, 'omicron':  959,
+      \ 'pi':       960, 'rho':      961, 'sigmaf':   962, 'sigma':    963,
+      \ 'tau':      964, 'upsilon':  965, 'phi':      966, 'chi':      967,
+      \ 'psi':      968, 'omega':    969, 'thetasym': 977, 'upsih':    978,
+      \ 'piv':      982, 'bull':    8226, 'hellip':  8230, 'prime':   8242,
+      \ 'Prime':   8243, 'oline':   8254, 'frasl':   8260, 'weierp':  8472,
+      \ 'image':   8465, 'real':    8476, 'trade':   8482, 'alefsym': 8501,
+      \ 'larr':    8592, 'uarr':    8593, 'rarr':    8594, 'darr':    8595,
+      \ 'harr':    8596, 'crarr':   8629, 'lArr':    8656, 'uArr':    8657,
+      \ 'rArr':    8658, 'dArr':    8659, 'hArr':    8660, 'forall':  8704,
+      \ 'part':    8706, 'exist':   8707, 'empty':   8709, 'nabla':   8711,
+      \ 'isin':    8712, 'notin':   8713, 'ni':      8715, 'prod':    8719,
+      \ 'sum':     8721, 'minus':   8722, 'lowast':  8727, 'radic':   8730,
+      \ 'prop':    8733, 'infin':   8734, 'ang':     8736, 'and':     8743,
+      \ 'or':      8744, 'cap':     8745, 'cup':     8746, 'int':     8747,
+      \ 'there4':  8756, 'sim':     8764, 'cong':    8773, 'asymp':   8776,
+      \ 'ne':      8800, 'equiv':   8801, 'le':      8804, 'ge':      8805,
+      \ 'sub':     8834, 'sup':     8835, 'nsub':    8836, 'sube':    8838,
+      \ 'supe':    8839, 'oplus':   8853, 'otimes':  8855, 'perp':    8869,
+      \ 'sdot':    8901, 'lceil':   8968, 'rceil':   8969, 'lfloor':  8970,
+      \ 'rfloor':  8971, 'lang':    9001, 'rang':    9002, 'loz':     9674,
+      \ 'spades':  9824, 'clubs':   9827, 'hearts':  9829, 'diams':   9830,
+      \ 'apos':      39}
+# }}}2
+
+def XmlEncode(str: string): string
+  return str
+    ->substitute('&', '\&amp;', 'g')
+    ->substitute('<', '\&lt;', 'g')
+    ->substitute('>', '\&gt;', 'g')
+    ->substitute('"', '\&quot;', 'g')
+    ->substitute("'", '\&apos;', 'g')
+enddef
+
+def XmlEntityDecode(str: string): string
+  return str
+    ->substitute('\c&#\%(0*38\|x0*26\);', '&amp;', 'g')
+    ->substitute('\c&#\(\d\+\);', '\=nr2char(str2nr(submatch(1)))', 'g')
+    ->substitute('\c&#\(x\x\+\);', '\=nr2char(str2nr("0" .. submatch(1), 16))', 'g')
+    ->substitute('\c&apos;', "'", 'g')
+    ->substitute('\c&quot;', '"', 'g')
+    ->substitute('\c&gt;', '>', 'g')
+    ->substitute('\c&lt;', '<', 'g')
+    ->substitute('\C&\(\%(amp;\)\@!\w*\);', '\=nr2char(get(g:pairs_html_entities, submatch(1), 63))', 'g')
+    ->substitute('\c&amp;', '\&', 'g')
+enddef
+
+def XmlDecode(str: string): string
+  return XmlEntityDecode(
+    str->substitute('<\%([[:alnum:]-]\+=\%("[^"]*"\|''[^'']*''\)\|.\)\{-\}>', '', 'g')
+  )
+enddef
+
+def Transform(xtype: string, dir: string, otype: string = '')
+  var algorithm = $"{xtype}{dir}"
+  var sel_save = &selection
+  var cb_save = &clipboard
+
+  set selection=inclusive clipboard-=unnamed clipboard-=unnamedplus
+
+  var reg_save = getreginfo('@')
+
+  if otype ==# 'line'
+    silent execute "normal! '[V']y"
+    setreg('@', getreg('@')->substitute("\n$", '', ''))
+  elseif otype ==# 'block'
+    silent execute "normal! `[\<C-V>`]y"
+  else
+    silent execute "normal! `[v`]y"
+  endif
+
+  setreg('@', call(algorithm, [getreg('@')]))
+  normal! gvp
+
+  setreg('@', reg_save)
+
+  &selection = sel_save
+  &clipboard = cb_save
+enddef
+
+def TransformSetup(xtype: string, dir: string): string
+  &operatorfunc = function(Transform, [xtype, dir])
+  return 'g@'
+enddef
+
+export def MapTransform(key: string, xtype: string, dir: string)
+  var name = $"{xtype}-{dir}"
+  var tf = $"Transform('{xtype}', '{dir}')"
+
+  var tfs = $'TransformSetup("{xtype}", "{dir}")'
+
+  execute $"nnoremap <expr> <Plug>(pairs-{name}) {tfs}"
+  execute $"xnoremap <expr> <Plug>(pairs-{name}) {tfs}"
+  execute $"nnoremap <expr> <Plug>(pairs-{name}-line) {tfs} .. '_'"
+
+  execute Map('n', key, $"<Plug>(pairs-{name})")
+  execute Map('x', key, $"<Plug>(pairs-{name})")
+  execute Map('n', key .. key[key->strlen() - 1], $"<Plug>(pairs-{name}-line)")
+enddef
diff --git a/doc/pairs.txt b/doc/pairs.txt
new file mode 100644
index 0000000..ea096d2
--- /dev/null
+++ b/doc/pairs.txt
@@ -0,0 +1,198 @@
+*pairs.txt*  Pairs of handy bracket mappings
+
+Author:   Austin Ziegler
+Based on: tpope/vim-unimpaired by Tim Pope <http://tpo.pe/>
+License:  Same terms as Vim itself (see |license|)
+
+This plugin is only available if 'compatible' is not set.
+
+INTRODUCTION                                    *pairs*
+
+This is a vim9script port of Tim Pope's tpope/vim-unimpaired. It differs from
+tpope/vim-unimpaired in a few different ways:
+
+- the `<Plug>(unimpaired-*)` mappings have been renamed to `<Plug>(pairs-*)`;
+- the `<Plug>unimpaired*` mappings have been removed;
+- several additional mappings have been added (some from pull requests on
+  unimpaired, others from phongnh/vim-toggler u riceissa/vim-more-toggling);
+- the functions previously in `plugin/unimpaired.vim` have been moved to
+  `autoload/pairs.vim` to allow easier addition of mappings using the same
+  tools that pairs does.
+
+NEXT AND PREVIOUS                               *pairs-next*
+
+The following maps all correspond to normal mode commands. If a count is
+given, it becomes an argument to the command. A mnemonic for the "a" commands
+is "args" and for the "q" commands is "quickfix".
+
+      Type        Mapping   Command       Mapping   Command~
+      args        *[a*        |:previous|     *]a*        |:next|
+                  *[A*        |:first|        *]A*        |:last|
+
+      buffer      *[b*        |:bprevious|    *]b*        |:bnext|
+                  *[B*        |:bfirst|       *]B*        |:blast|
+
+      location    *[l*        |:lprevious|    *]l*        |:lnext|
+                  *[L*        |:lfirst|       *]L*        |:llast|
+                  *[<C-L>*    |:lpfile|       *]<C-L>*    |:lnfile|
+
+      quickfix    *[q*        |:cprevious|    *]q*        |:cnext|
+                  *[Q*        |:cfirst|       *]Q*        |:clast|
+                  *[<C-Q>*    |:cpfile|       *]<C-Q>*    |:cnfile|
+
+                  ~NOTE~: <C-Q> only works in a terminal with flow control
+                          disabled with `stty -ixon`.
+
+      tab         *[t*        |:tprevious|    *]t*        |:tnext|
+                  *[T*        |:tfirst|       *]T*        |:tlast|
+                  *[<C-T>*    |:ptprevious|   *]<C-T>*    |:ptnext|
+
+      files       *[f* *]f*
+
+                  Goes to the previous (`[f`) or next (`]f`) file
+                  alphabetically relative to the current file. In the
+                  |quickfix| window, this is equivalent to |:colder| and
+                  |:cnewer|.
+
+      diff        *[n* *]n*
+
+                  Goes to the previous (`[n`) or next (`]n`) source control
+                  conflict marker or diff/patch hunk. Try `d[n` or `d]n`
+                  inside a conflict.
+
+LINE OPERATIONS                                 *pairs-lines*
+
+These maps operate on the current line.
+
+                                                *[<Space>*
+[<Space>                Add [count] blank lines above the cursor.
+
+                                                *]<Space>*
+]<Space>                Add [count] blank lines below the cursor.
+
+                                                *[e* *v_[e*
+[e                      Exchange the current line or selection with [count]
+                        lines above it.
+
+                                                *]e* *v_]e*
+]e                      Exchange the current line or selection with [count]
+                        lines below it.
+
+                                                *[e* *v_[e*
+[E                      Copy the current line or selection [count] lines above
+                        it.
+
+                                                *]e* *v_]e*
+]E                      Copy the current line or selection [count] lines below
+                        it.
+
+OPTION TOGGLING                                 *pairs-toggling*
+
+These maps toggle options. Most of these are single boolean flags, but some
+enforce boolean behaviour on other constructs. Unless otherwise noted, these
+settings are set local to the window or buffer using |:setlocal| or the
+equivalent.
+
+    On      Off     Toggle    Option/Notes ~
+    *[ob*     *]ob*     *yob*       |'background'| (global)
+                              `light` is on; `dark` is off
+    *[ot*     *]ot*     *yot*       |'colorcolumn'|
+                              On uses `+1` or the last value
+    *[oC*     *]oC*     *yoC*       |'conceallevel'|
+                              `2` is on; `0` is off
+    *[ou*     *]ou*     *you*       |'cursorcolumn'|
+    *[o|*     *]o|*     *yo|*
+    *[oc*     *]oc*     *yoc*       |'cursorline'|
+    *[o-*     *]o-*     *yo-*
+    *[o_*     *]o_*     *yo_*
+    *[ox*     *]ox*     *yox*       |'cursorline'| |'cursorcolumn'|
+    *[o+*     *]o+*     *yo+*       `x` or `+` like a crosshair
+    *[od*     *]od*     *yod*       |'diff'|
+                              Calls |:diffthis| and |:diffoff|
+    *[oe*     *]oe*     *yoe*       |'expandtab'|
+    *[oW*     *]oW*     *yoW*       |'formatoptions'| auto-wrap (|fo-t|)
+    *[oI*     *]oI*     *yoI*       |'incsearch'|
+    *[oS*     *]oS*     *yoS*       |'incsearch'| (global)
+    *[oh*     *]oh*     *yoh*       |'hlsearch'|
+    *[oi*     *]oi*     *yoi*       |'ignorecase'|
+    *[ol*     *]ol*     *yol*       |'list'|
+    *[on*     *]on*     *yon*       |'number'|
+    *[or*     *]or*     *yor*       |'relativenumber'|
+    *[o;*     *]o;*     *yo;*       |'showcmd'|
+    *[os*     *]os*     *yos*       |'spell'|
+    *[oy*     *]oY*     *yoy*       |syntax|
+    *[oY*     *]oY*     *yoY*       |syntax| (global)
+    *[ov*     *]ov*     *yov*       |'virtualedit'|
+    *[ow*     *]ow*     *yow*       |'wrap'|
+
+The mnemonic for y is that if you tilt it a bit it looks like a switch.
+
+                                                *<s* *>s* *=s*
+Alternative prefixes for on/off/toggle: <s, >s, =s.
+
+PASTING                                         *pairs-pasting*
+
+These maps are experimental:
+
+*>p*    Paste after linewise, increasing indent.
+*>P*    Paste before linewise, increasing indent.
+*<p*    Paste after linewise, decreasing indent.
+*<P*    Paste before linewise, decreasing indent.
+*=p*    Paste after linewise, reindenting.
+*=P*    Paste before linewise, reindenting.
+
+|]p|, |[p|, |[P|, and |]P| have also been remapped to force linewise pasting,
+while preserving their usual indent matching behavior.
+
+                                                *[op* *]op* *yop*
+A toggle has not been provided for 'paste' because the typical use case of
+wrapping of a solitary insertion is inefficient:  You toggle twice, but
+you only paste once (YOPO).  Instead, press [op, ]op, or yop to invoke |O|,
+|o|, or |0||C| with 'paste' already set.  Leaving insert mode sets 'nopaste'
+automatically.
+
+ENCODING AND DECODING                           *pairs-encoding*
+
+Each of these operations has a map that takes a motion, a map that
+targets [count] lines, and a visual mode map.  The linewise variant integrates
+with repeat.vim.
+
+Mnemonic: encoding always comes before decoding; "[" always comes before "]".
+
+                                                *[x* *[xx* *v_[x*
+[x{motion}              XML encode.
+[xx                     <foo bar="baz"> => &lt;foo bar=&quot;baz&quot;&gt;
+{Visual}[x
+
+                                                *]x* *]xx* *v_]x*
+]x{motion}              XML decode.  HTML entities are handled as well.
+]xx
+{Visual}]x
+
+                                                *[u* *[uu* *v_[u*
+[u{motion}              URL encode.
+[uu                     foo bar => foo%20bar
+{Visual}[u
+
+                                                *]u* *]uu* *v_]u*
+]u{motion}              URL decode.
+]uu
+{Visual}]u
+
+                                        *[y* *[yy* *v_[y* *[C* *[CC* *v_[C*
+[y{motion}              C String encode.  Backslash escape control
+[yy                     characters, quotation marks, and backslashes.
+{Visual}[y
+[C{motion}
+[CC
+{Visual}[C
+
+                                        *]y* *]yy* *v_]y* *]C* *]CC* *v_]C*
+]y{motion}              C String decode.
+]yy
+{Visual}]y
+]C{motion}
+]CC
+{Visual}]C
+
+ vim:tw=78:et:ft=help:norl:
diff --git a/doc/unimpaired.txt b/doc/unimpaired.txt
deleted file mode 100644
index b03f42f..0000000
--- a/doc/unimpaired.txt
+++ /dev/null
@@ -1,165 +0,0 @@
-*unimpaired.txt*  Pairs of handy bracket mappings
-
-Author:  Tim Pope <http://tpo.pe/>
-License: Same terms as Vim itself (see |license|)
-
-This plugin is only available if 'compatible' is not set.
-
-INTRODUCTION                                    *unimpaired*
-
-This plugin provides several pairs of bracket maps.
-
-NEXT AND PREVIOUS                               *unimpaired-next*
-
-The following maps all correspond to normal mode commands.  If a count is
-given, it becomes an argument to the command.  A mnemonic for the "a" commands
-is "args" and for the "q" commands is "quickfix".
-
-*[a*     |:previous|
-*]a*     |:next|
-*[A*     |:first|
-*]A*     |:last|
-*[b*     |:bprevious|
-*]b*     |:bnext|
-*[B*     |:bfirst|
-*]B*     |:blast|
-*[l*     |:lprevious|
-*]l*     |:lnext|
-*[L*     |:lfirst|
-*]L*     |:llast|
-*[<C-L>* |:lpfile|
-*]<C-L>* |:lnfile|
-*[q*     |:cprevious|
-*]q*     |:cnext|
-*[Q*     |:cfirst|
-*]Q*     |:clast|
-*[<C-Q>* |:cpfile| (Note that <C-Q> only works in a terminal if you disable
-*]<C-Q>* |:cnfile| flow control: stty -ixon)
-*[t*     |:tprevious|
-*]t*     |:tnext|
-*[T*     |:tfirst|
-*]T*     |:tlast|
-*[<C-T>* |:ptprevious|
-*]<C-T>* |:ptnext|
-
-                                                *[f*
-[f                      Go to the file preceding the current one
-                        alphabetically in the current file's directory.  In
-                        the quickfix window, equivalent to |:colder|.
-
-                                                *]f*
-]f                      Go to the file succeeding the current one
-                        alphabetically in the current file's directory.  In
-                        the quickfix window, equivalent to |:cnewer|.
-
-                                                *[n*
-[n                      Go to the previous SCM conflict marker or diff/patch
-                        hunk.  Try d[n inside a conflict.
-
-                                                *]n*
-]n                      Go to the next SCM conflict marker or diff/patch hunk.
-                        Try d]n inside a conflict.
-
-LINE OPERATIONS                                 *unimpaired-lines*
-
-                                                *[<Space>*
-[<Space>                Add [count] blank lines above the cursor.
-
-                                                *]<Space>*
-]<Space>                Add [count] blank lines below the cursor.
-
-                                                *[e* *v_[e*
-[e                      Exchange the current line with [count] lines above it.
-
-                                                *]e* *v_]e*
-]e                      Exchange the current line with [count] lines below it.
-
-OPTION TOGGLING                                 *unimpaired-toggling*
-
-On	Off	Toggle	Option
-*[ob*	*]ob*	*yob*	'background' (dark is off, light is on)
-*[oc*	*]oc*	*yoc*	'cursorline'
-*[od*	*]od*	*yod*	'diff' (actually |:diffthis| / |:diffoff|)
-*[oh*	*]oh*	*yoh*	'hlsearch'
-*[oi*	*]oi*	*yoi*	'ignorecase'
-*[ol*	*]ol*	*yol*	'list'
-*[on*	*]on*	*yon*	'number'
-*[or*	*]or*	*yor*	'relativenumber'
-*[os*	*]os*	*yos*	'spell'
-*[ot*	*]ot*	*yot*	'colorcolumn' ("+1" or last used value)
-*[ou*	*]ou*	*you*	'cursorcolumn'
-*[ov*	*]ov*	*yov*	'virtualedit'
-*[ow*	*]ow*	*yow*	'wrap'
-*[ox*	*]ox*	*yox*	'cursorline' 'cursorcolumn' (x as in crosshairs)
-
-The mnemonic for y is that if you tilt it a bit it looks like a switch.
-
-                                                *<s* *>s* *=s*
-Alternative prefixes for on/off/toggle: <s, >s, =s.
-
-PASTING                                         *unimpaired-pasting*
-
-These are experimental:
-
-*>p*    Paste after linewise, increasing indent.
-*>P*    Paste before linewise, increasing indent.
-*<p*    Paste after linewise, decreasing indent.
-*<P*    Paste before linewise, decreasing indent.
-*=p*    Paste after linewise, reindenting.
-*=P*    Paste before linewise, reindenting.
-
-|]p|, |[p|, |[P|, and |]P| have also been remapped to force linewise pasting,
-while preserving their usual indent matching behavior.
-
-                                                *[op* *]op* *yop*
-A toggle has not been provided for 'paste' because the typical use case of
-wrapping of a solitary insertion is inefficient:  You toggle twice, but
-you only paste once (YOPO).  Instead, press [op, ]op, or yop to invoke |O|,
-|o|, or |0||C| with 'paste' already set.  Leaving insert mode sets 'nopaste'
-automatically.
-
-ENCODING AND DECODING                           *unimpaired-encoding*
-
-Each of these operations has a map that takes a motion, a map that
-targets [count] lines, and a visual mode map.  The linewise variant integrates
-with repeat.vim.
-
-Mnemonic: encoding always comes before decoding; "[" always comes before "]".
-
-                                                *[x* *[xx* *v_[x*
-[x{motion}              XML encode.
-[xx                     <foo bar="baz"> => &lt;foo bar=&quot;baz&quot;&gt;
-{Visual}[x
-
-                                                *]x* *]xx* *v_]x*
-]x{motion}              XML decode.  HTML entities are handled as well.
-]xx
-{Visual}]x
-
-                                                *[u* *[uu* *v_[u*
-[u{motion}              URL encode.
-[uu                     foo bar => foo%20bar
-{Visual}[u
-
-                                                *]u* *]uu* *v_]u*
-]u{motion}              URL decode.
-]uu
-{Visual}]u
-
-                                        *[y* *[yy* *v_[y* *[C* *[CC* *v_[C*
-[y{motion}              C String encode.  Backslash escape control
-[yy                     characters, quotation marks, and backslashes.
-{Visual}[y
-[C{motion}
-[CC
-{Visual}[C
-
-                                        *]y* *]yy* *v_]y* *]C* *]CC* *v_]C*
-]y{motion}              C String decode.
-]yy
-{Visual}]y
-]C{motion}
-]CC
-{Visual}]C
-
- vim:tw=78:et:ft=help:norl:
diff --git a/plugin/pairs.vim b/plugin/pairs.vim
new file mode 100644
index 0000000..e374e4f
--- /dev/null
+++ b/plugin/pairs.vim
@@ -0,0 +1,181 @@
+vim9script
+
+# pairs.vim - Pairs of handy bracket mappings and other toggles.
+#
+# This is a vim9script port of tpope/vim-unimpaired with additional configuration options
+# adapted from additional sources, including:
+#
+# - phongnh/vim-toggler: conceallevel, showmatch, incsearch, expandtab, showcmd
+# - riceissa/vim-more-toggling: syntax
+
+if g:->get('loaded_pairs', false)
+  finish
+endif
+
+g:loaded_pairs = true
+
+import autoload 'pairs.vim'
+
+# Section: Next and previous mappings.
+pairs.MapNextFamily('a', '', 'argument')
+pairs.MapNextFamily('b', 'b', 'buffer')
+pairs.MapNextFamily('l', 'l', 'll')
+pairs.MapNextFamily('q', 'c', 'cc')
+pairs.MapNextFamily('t', 't', 'trewind')
+
+nnoremap <silent> <Plug>(pairs-directory-next) <ScriptCmd>execute pairs.NextFileEntry(v:count1)<CR>
+nnoremap <silent> <Plug>(pairs-directory-previous) <ScriptCmd>execute pairs.PreviousFileEntry(v:count1)<CR>
+execute pairs.Map('n', ']f', '<Plug>(pairs-directory-next)')
+execute pairs.Map('n', '[f', '<Plug>(pairs-directory-previous)')
+
+# Section: Diff
+
+nnoremap <silent> <Plug>(pairs-context-previous) <ScriptCmd>pairs.Context(v:true)<CR>
+nnoremap <silent> <Plug>(pairs-context-next) <ScriptCmd>pairs.Context(v:false)<CR>
+vnoremap <silent> <Plug>(pairs-context-previous) <ScriptCmd>execute 'normal! gv'<Bar>call pairs.Context(v:true)<CR>
+vnoremap <silent> <Plug>(pairs-context-next) <ScriptCmd>execute 'normal! gv'<Bar>call pairs.Context(v:false)<CR>
+onoremap <silent> <Plug>(pairs-context-previous) <ScriptCmd>pairs.ContextMotion(v:true)<CR>
+onoremap <silent> <Plug>(pairs-context-next) <ScriptCmd>pairs.ContextMotion(v:false)<CR>
+
+execute pairs.Map('n', '[n', '<Plug>(pairs-context-previous)')
+execute pairs.Map('n', ']n', '<Plug>(pairs-context-next)')
+execute pairs.Map('x', '[n', '<Plug>(pairs-context-previous)')
+execute pairs.Map('x', ']n', '<Plug>(pairs-context-next)')
+execute pairs.Map('o', '[n', '<Plug>(pairs-context-previous)')
+execute pairs.Map('o', ']n', '<Plug>(pairs-context-next)')
+
+# Section: Line operations
+
+nnoremap <silent> <Plug>(pairs-blank-up) <ScriptCmd>execute pairs.BlankUp()<CR>
+nnoremap <silent> <Plug>(pairs-blank-down) <ScriptCmd>execute pairs.BlankDown()<CR>
+
+execute pairs.Map('n', '[<Space>', '<Plug>(pairs-blank-up)')
+execute pairs.Map('n', ']<Space>', '<Plug>(pairs-blank-down)')
+
+nnoremap <silent> <Plug>(pairs-move-up) <ScriptCmd>pairs.CopyMove('move', '--', v:count1, 'up')<CR>
+nnoremap <silent> <Plug>(pairs-move-down) <ScriptCmd>pairs.Move('move', '+', v:count1, 'down')<CR>
+noremap <silent> <Plug>(pairs-move-selection-up) <ScriptCmd>pairs.MoveSelectionUp('move', v:count1)<CR>
+noremap <silent> <Plug>(pairs-move-selection-down) <ScriptCmd>pairs.MoveSelectionDown('move', v:count1)<CR>
+
+execute pairs.Map('n', '[e', '<Plug>(pairs-move-up)')
+execute pairs.Map('n', ']e', '<Plug>(pairs-move-down)')
+execute pairs.Map('x', '[e', '<Plug>(pairs-move-selection-up)')
+execute pairs.Map('x', ']e', '<Plug>(pairs-move-selection-down)')
+
+nnoremap <silent> <Plug>(pairs-copy-up) <ScriptCmd>pairs.CopyMove('copy', '-', v:count1, 'up')<CR>
+nnoremap <silent> <Plug>(pairs-copy-down) <ScriptCmd>pairs.CopyMove('copy', '', v:count1, 'down')<CR>
+noremap <silent> <Plug>(pairs-copy-selection-up) <ScriptCmd>pairs.CopyMoveSelectionUp('copy', v:count1)<CR>
+noremap <silent> <Plug>(pairs-copy-selection-down) <ScriptCmd>pairs.CopyMoveSelectionDown('copy', v:count1)<CR>
+
+execute pairs.Map('n', '[E', '<Plug>(pairs-copy-up)')
+execute pairs.Map('n', ']E', '<Plug>(pairs-copy-down)')
+execute pairs.Map('x', '[E', '<Plug>(pairs-copy-selection-up)')
+execute pairs.Map('x', ']E', '<Plug>(pairs-copy-selection-down)')
+
+# Section: Option toggling
+
+pairs.MapFeature('b', { enable: 'set background=light', disable: 'set background=dark',
+  test: "&background == 'light'" })
+
+pairs.MapFeature('t', { enable: '&l:colorcolumn = ColorColumn(false)',
+  disable: '&l:colorcolumn = ColorColumn(true)',
+  test: '!&l:colorcolumn->empty()'
+})
+
+# Adapted from phongnh/vim-toggler yoC
+pairs.MapFeature('C', { enable: 'setlocal conceallevel=2',
+  disable: 'setlocal conceallevel=0', test: '&conceallevel > 0' })
+
+pairs.MapBooleanOption(['c', '-', '_'], 'cursorline', 'setlocal')
+pairs.MapBooleanOption(['u', '<Bar>'], 'cursorcolumn', 'setlocal')
+
+pairs.MapFeature('d', { enable: 'diffthis', disable: 'diffoff', test: '&diff' })
+
+pairs.MapBooleanOption('e', 'expandtab', 'setlocal')
+pairs.MapBooleanOption('I', 'incsearch', 'setlocal')
+pairs.MapBooleanOption('S', 'incsearch', 'set')
+pairs.MapBooleanOption('h', 'hlsearch', 'set')
+pairs.MapBooleanOption('i', 'ignorecase', 'set')
+pairs.MapBooleanOption('l', 'list', 'setlocal')
+pairs.MapBooleanOption('n', 'number', 'setlocal')
+pairs.MapBooleanOption('r', 'relativenumber', 'setlocal')
+pairs.MapBooleanOption(';', 'showcmd', 'set')
+pairs.MapBooleanOption('M', 'showmatch', 'set')
+pairs.MapBooleanOption('s', 'spell', 'setlocal')
+pairs.MapBooleanOption('w', 'wrap', 'setlocal')
+
+pairs.MapFeature('t', { enable: 'setlocal formatoptions+=t',
+  disable: 'setlocal formatoptions-=t', test: '&l:formatoptions =~# "t"' })
+
+pairs.MapFeature('v', { enable: 'setlocal virtualedit+=all', disable: 'setlocal virtualedit-=all',
+  test: '&l:virtualedit =~# "all"' })
+
+pairs.MapFeature(['x', '+'], { enable: 'setlocal cursorline cursorcolumn',
+  disable: 'setlocal nocursorline nocursorcolumn',
+  test: '&l:cursorline && &l:cursorcolumn',
+  after: 'StatuslineRefresh()'
+})
+
+pairs.MapFeature('Y', { enable: 'syntax enable', disable: 'syntax off',
+  test: 'exists("g:syntax_on")'
+})
+
+pairs.MapFeature('y', { enable: '&l:syntax = "ON"', disable: '&l:syntax = "OFF"',
+  test: '&l:syntax !=# "OFF"', after: 'echo &l:syntax'
+})
+
+execute pairs.Map('n', 'yo', '<Plug>(pairs-toggle)')
+execute pairs.Map('n', '[o', '<Plug>(pairs-enable)')
+execute pairs.Map('n', ']o', '<Plug>(pairs-disable)')
+execute pairs.Map('n', 'yo<Esc>', '<Nop>')
+execute pairs.Map('n', '[o<Esc>', '<Nop>')
+execute pairs.Map('n', ']o<Esc>', '<Nop>')
+execute pairs.Map('n', '=s', '<Plug>(pairs-toggle)')
+execute pairs.Map('n', '<s', '<Plug>(pairs-enable)')
+execute pairs.Map('n', '>s', '<Plug>(pairs-disable)')
+execute pairs.Map('n', '=s<Esc>', '<Nop>')
+execute pairs.Map('n', '<s<Esc>', '<Nop>')
+execute pairs.Map('n', '>s<Esc>', '<Nop>')
+
+nmap <script><silent> <Plug>(pairs-paste) <ScriptCmd>pairs.SetupPaste()<CR>
+
+nmap <script><silent> <Plug>(pairs-enable)p <ScriptCmd>pairs.SetupPaste()<CR>O
+nmap <script><silent> <Plug>(pairs-disable)p <ScriptCmd>pairs.SetupPaste()<CR>o
+nmap <script><silent> <Plug>(pairs-toggle)p <ScriptCmd>pairs.SetupPaste()<CR>0C
+
+# Section: Put
+
+nnoremap <silent> <Plug>(pairs-put-above) <ScriptCmd>pairs.Putline('[p', 'above')<CR>
+nnoremap <silent> <Plug>(pairs-put-below) <ScriptCmd>pairs.Putline(']p', 'below')<CR>
+nnoremap <silent> <Plug>(pairs-put-above-rightward) <ScriptCmd>pairs.Putline(v:count1 .. '[p', 'Above')<CR>>']
+nnoremap <silent> <Plug>(pairs-put-below-rightward) <ScriptCmd>pairs.Putline(v:count1 .. ']p', 'Below')<CR>>']
+nnoremap <silent> <Plug>(pairs-put-above-leftward) <ScriptCmd>pairs.Putline(v:count1 .. '[p', 'Above')<CR><']
+nnoremap <silent> <Plug>(pairs-put-below-leftward) <ScriptCmd>pairs.Putline(v:count1 .. ']p', 'Below')<CR><']
+nnoremap <silent> <Plug>(pairs-put-above-reformat) <ScriptCmd>pairs.Putline(v:count1 .. '[p', 'Above')<CR>=']
+nnoremap <silent> <Plug>(pairs-put-below-reformat) <ScriptCmd>pairs.Putline(v:count1 .. ']p', 'Below')<CR>=']
+
+execute pairs.Map('n', '[p', '<Plug>(pairs-put-above)')
+execute pairs.Map('n', ']p', '<Plug>(pairs-put-below)')
+execute pairs.Map('n', '[P', '<Plug>(pairs-put-above)')
+execute pairs.Map('n', ']P', '<Plug>(pairs-put-below)')
+
+execute pairs.Map('n', '>P', "<Plug>(pairs-put-above-rightward)")
+execute pairs.Map('n', '>p', "<Plug>(pairs-put-below-rightward)")
+execute pairs.Map('n', '<P', "<Plug>(pairs-put-above-leftward)")
+execute pairs.Map('n', '<p', "<Plug>(pairs-put-below-leftward)")
+execute pairs.Map('n', '=P', "<Plug>(pairs-put-above-reformat)")
+execute pairs.Map('n', '=p', "<Plug>(pairs-put-below-reformat)")
+
+# Section: Encoding and decoding
+
+pairs.MapTransform('[y', 'String', 'Encode')
+pairs.MapTransform(']y', 'String', 'Decode')
+pairs.MapTransform('[C', 'String', 'Encode')
+pairs.MapTransform(']C', 'String', 'Decode')
+pairs.MapTransform('[u', 'Url', 'Encode')
+pairs.MapTransform(']u', 'Url', 'Decode')
+pairs.MapTransform('[x', 'Xml', 'Encode')
+pairs.MapTransform(']x', 'Xml', 'Decode')
+
+# vim:set sw=2 sts=2:
+defcompile
diff --git a/plugin/unimpaired.vim b/plugin/unimpaired.vim
deleted file mode 100644
index 81e19a4..0000000
--- a/plugin/unimpaired.vim
+++ /dev/null
@@ -1,623 +0,0 @@
-" unimpaired.vim - Pairs of handy bracket mappings
-" Maintainer:   Tim Pope <http://tpo.pe/>
-" Version:      2.1
-" GetLatestVimScripts: 1590 1 :AutoInstall: unimpaired.vim
-
-if exists("g:loaded_unimpaired") || &cp || v:version < 700
-  finish
-endif
-let g:loaded_unimpaired = 1
-
-function! s:Map(...) abort
-  let [mode, head, rhs; rest] = a:000
-  let flags = get(rest, 0, '') . (rhs =~# '^<Plug>' ? '' : '<script>')
-  let tail = ''
-  let keys = get(g:, mode.'remap', {})
-  if type(keys) == type({}) && !empty(keys)
-    while !empty(head) && len(keys)
-      if has_key(keys, head)
-        let head = keys[head]
-        if empty(head)
-          let head = '<skip>'
-        endif
-        break
-      endif
-      let tail = matchstr(head, '<[^<>]*>$\|.$') . tail
-      let head = substitute(head, '<[^<>]*>$\|.$', '', '')
-    endwhile
-  endif
-  if head !=# '<skip>' && empty(maparg(head.tail, mode))
-    return mode.'map ' . flags . ' ' . head.tail . ' ' . rhs
-  endif
-  return ''
-endfunction
-
-" Section: Next and previous
-
-function! s:MapNextFamily(map, cmd, current) abort
-  let prefix = '<Plug>(unimpaired-' . a:cmd
-  let map = '<Plug>unimpaired'.toupper(a:map)
-  let cmd = '".(v:count ? v:count : "")."'.a:cmd
-  let zv = (a:cmd ==# 'l' || a:cmd ==# 'c' ? 'zv' : '')
-  let end = '"<CR>'.zv
-  execute 'nnoremap <silent> '.prefix.'previous) :<C-U>exe "'.cmd.'previous'.end
-  execute 'nnoremap <silent> '.prefix.'next)     :<C-U>exe "'.cmd.'next'.end
-  execute 'nnoremap '.prefix.'first)    :<C-U><C-R>=v:count ? v:count . "' . a:current . '" : "' . a:cmd . 'first"<CR><CR>' . zv
-  execute 'nnoremap '.prefix.'last)     :<C-U><C-R>=v:count ? v:count . "' . a:current . '" : "' . a:cmd . 'last"<CR><CR>' . zv
-  execute 'nnoremap <silent> '.map.'Previous :<C-U>exe "'.cmd.'previous'.end
-  execute 'nnoremap <silent> '.map.'Next     :<C-U>exe "'.cmd.'next'.end
-  execute 'nnoremap <silent> '.map.'First    :<C-U>exe "'.cmd.'first'.end
-  execute 'nnoremap <silent> '.map.'Last     :<C-U>exe "'.cmd.'last'.end
-  exe s:Map('n', '['.        a:map , prefix.'previous)')
-  exe s:Map('n', ']'.        a:map , prefix.'next)')
-  exe s:Map('n', '['.toupper(a:map), prefix.'first)')
-  exe s:Map('n', ']'.toupper(a:map), prefix.'last)')
-  if a:cmd ==# 'c' || a:cmd ==# 'l'
-    execute 'nnoremap <silent> '.prefix.'pfile)  :<C-U>exe "'.cmd.'pfile'.end
-    execute 'nnoremap <silent> '.prefix.'nfile)  :<C-U>exe "'.cmd.'nfile'.end
-    execute 'nnoremap <silent> '.map.'PFile :<C-U>exe "'.cmd.'pfile'.end
-    execute 'nnoremap <silent> '.map.'NFile :<C-U>exe "'.cmd.'nfile'.end
-    exe s:Map('n', '[<C-'.toupper(a:map).'>', prefix.'pfile)')
-    exe s:Map('n', ']<C-'.toupper(a:map).'>', prefix.'nfile)')
-  elseif a:cmd ==# 't'
-    nnoremap <silent> <Plug>(unimpaired-ptprevious) :<C-U>exe v:count1 . "ptprevious"<CR>
-    nnoremap <silent> <Plug>(unimpaired-ptnext) :<C-U>exe v:count1 . "ptnext"<CR>
-    execute 'nnoremap <silent> '.map.'PPrevious :<C-U>exe "p'.cmd.'previous'.end
-    execute 'nnoremap <silent> '.map.'PNext :<C-U>exe "p'.cmd.'next'.end
-    exe s:Map('n', '[<C-T>', '<Plug>(unimpaired-ptprevious)')
-    exe s:Map('n', ']<C-T>', '<Plug>(unimpaired-ptnext)')
-  endif
-endfunction
-
-call s:MapNextFamily('a', '' , 'argument')
-call s:MapNextFamily('b', 'b', 'buffer')
-call s:MapNextFamily('l', 'l', 'll')
-call s:MapNextFamily('q', 'c', 'cc')
-call s:MapNextFamily('t', 't', 'trewind')
-
-function! s:entries(path) abort
-  let path = substitute(a:path,'[\\/]$','','')
-  let path = substitute(path, '[[$*]', '[&]', 'g')
-  let files = split(glob(path."/.*"),"\n")
-  let files += split(glob(path."/*"),"\n")
-  call map(files,'substitute(v:val,"[\\/]$","","")')
-  call filter(files,'v:val !~# "[\\\\/]\\.\\.\\=$"')
-
-  let filter_suffixes = substitute(escape(&suffixes, '~.*$^'), ',', '$\\|', 'g') .'$'
-  call filter(files, 'v:val !~# filter_suffixes')
-
-  return sort(files)
-endfunction
-
-function! s:FileByOffset(num) abort
-  let file = expand('%:p')
-  if empty(file)
-    let file = getcwd() . '/'
-  endif
-  let num = a:num
-  while num
-    let files = s:entries(fnamemodify(file,':h'))
-    if a:num < 0
-      call reverse(filter(files,'v:val <# file'))
-    else
-      call filter(files,'v:val ># file')
-    endif
-    let temp = get(files,0,'')
-    if empty(temp)
-      let file = fnamemodify(file,':h')
-    else
-      let file = temp
-      let found = 1
-      while isdirectory(file)
-        let files = s:entries(file)
-        if empty(files)
-          let found = 0
-          break
-        endif
-        let file = files[num > 0 ? 0 : -1]
-      endwhile
-      let num += (num > 0 ? -1 : 1) * found
-    endif
-  endwhile
-  return file
-endfunction
-
-function! s:fnameescape(file) abort
-  if exists('*fnameescape')
-    return fnameescape(a:file)
-  else
-    return escape(a:file," \t\n*?[{`$\\%#'\"|!<")
-  endif
-endfunction
-
-function! s:GetWindow() abort
-  if exists('*getwininfo') && exists('*win_getid')
-    return get(getwininfo(win_getid()), 0, {})
-  else
-    return {}
-  endif
-endfunction
-
-function! s:PreviousFileEntry(count) abort
-  let window = s:GetWindow()
-
-  if get(window, 'loclist')
-    return 'lolder ' . a:count
-  elseif get(window, 'quickfix')
-    return 'colder ' . a:count
-  else
-    return 'edit ' . s:fnameescape(fnamemodify(s:FileByOffset(-v:count1), ':.'))
-  endif
-endfunction
-
-function! s:NextFileEntry(count) abort
-  let window = s:GetWindow()
-
-  if get(window, 'loclist')
-    return 'lnewer ' . a:count
-  elseif get(window, 'quickfix')
-    return 'cnewer ' . a:count
-  else
-    return 'edit ' . s:fnameescape(fnamemodify(s:FileByOffset(v:count1), ':.'))
-  endif
-endfunction
-
-nnoremap <silent> <Plug>(unimpaired-directory-next)     :<C-U>execute <SID>NextFileEntry(v:count1)<CR>
-nnoremap <silent> <Plug>(unimpaired-directory-previous) :<C-U>execute <SID>PreviousFileEntry(v:count1)<CR>
-nnoremap <silent> <Plug>unimpairedDirectoryNext     :<C-U>execute <SID>NextFileEntry(v:count1)<CR>
-nnoremap <silent> <Plug>unimpairedDirectoryPrevious :<C-U>execute <SID>PreviousFileEntry(v:count1)<CR>
-exe s:Map('n', ']f', '<Plug>(unimpaired-directory-next)')
-exe s:Map('n', '[f', '<Plug>(unimpaired-directory-previous)')
-
-" Section: Diff
-
-nnoremap <silent> <Plug>(unimpaired-context-previous) :<C-U>call <SID>Context(1)<CR>
-nnoremap <silent> <Plug>(unimpaired-context-next)     :<C-U>call <SID>Context(0)<CR>
-vnoremap <silent> <Plug>(unimpaired-context-previous) :<C-U>exe 'normal! gv'<Bar>call <SID>Context(1)<CR>
-vnoremap <silent> <Plug>(unimpaired-context-next)     :<C-U>exe 'normal! gv'<Bar>call <SID>Context(0)<CR>
-onoremap <silent> <Plug>(unimpaired-context-previous) :<C-U>call <SID>ContextMotion(1)<CR>
-onoremap <silent> <Plug>(unimpaired-context-next)     :<C-U>call <SID>ContextMotion(0)<CR>
-
-exe s:Map('n', '[n', '<Plug>(unimpaired-context-previous)')
-exe s:Map('n', ']n', '<Plug>(unimpaired-context-next)')
-exe s:Map('x', '[n', '<Plug>(unimpaired-context-previous)')
-exe s:Map('x', ']n', '<Plug>(unimpaired-context-next)')
-exe s:Map('o', '[n', '<Plug>(unimpaired-context-previous)')
-exe s:Map('o', ']n', '<Plug>(unimpaired-context-next)')
-
-nnoremap <silent> <Plug>unimpairedContextPrevious :<C-U>call <SID>Context(1)<CR>
-nnoremap <silent> <Plug>unimpairedContextNext     :<C-U>call <SID>Context(0)<CR>
-xnoremap <silent> <Plug>unimpairedContextPrevious :<C-U>exe 'normal! gv'<Bar>call <SID>Context(1)<CR>
-xnoremap <silent> <Plug>unimpairedContextNext     :<C-U>exe 'normal! gv'<Bar>call <SID>Context(0)<CR>
-onoremap <silent> <Plug>unimpairedContextPrevious :<C-U>call <SID>ContextMotion(1)<CR>
-onoremap <silent> <Plug>unimpairedContextNext     :<C-U>call <SID>ContextMotion(0)<CR>
-
-function! s:Context(reverse) abort
-  call search('^\(@@ .* @@\|[<=>|]\{7}[<=>|]\@!\)', a:reverse ? 'bW' : 'W')
-endfunction
-
-function! s:ContextMotion(reverse) abort
-  if a:reverse
-    -
-  endif
-  call search('^@@ .* @@\|^diff \|^[<=>|]\{7}[<=>|]\@!', 'bWc')
-  if getline('.') =~# '^diff '
-    let end = search('^diff ', 'Wn') - 1
-    if end < 0
-      let end = line('$')
-    endif
-  elseif getline('.') =~# '^@@ '
-    let end = search('^@@ .* @@\|^diff ', 'Wn') - 1
-    if end < 0
-      let end = line('$')
-    endif
-  elseif getline('.') =~# '^=\{7\}'
-    +
-    let end = search('^>\{7}>\@!', 'Wnc')
-  elseif getline('.') =~# '^[<=>|]\{7\}'
-    let end = search('^[<=>|]\{7}[<=>|]\@!', 'Wn') - 1
-  else
-    return
-  endif
-  if end > line('.')
-    execute 'normal! V'.(end - line('.')).'j'
-  elseif end == line('.')
-    normal! V
-  endif
-endfunction
-
-" Section: Line operations
-
-function! s:BlankUp() abort
-  let cmd = 'put!=repeat(nr2char(10), v:count1)|silent '']+'
-  if &modifiable
-    let cmd .= '|silent! call repeat#set("\<Plug>(unimpaired-blank-up)", v:count1)'
-  endif
-  return cmd
-endfunction
-
-function! s:BlankDown() abort
-  let cmd = 'put =repeat(nr2char(10), v:count1)|silent ''[-'
-  if &modifiable
-    let cmd .= '|silent! call repeat#set("\<Plug>(unimpaired-blank-down)", v:count1)'
-  endif
-  return cmd
-endfunction
-
-nnoremap <silent> <Plug>(unimpaired-blank-up)   :<C-U>exe <SID>BlankUp()<CR>
-nnoremap <silent> <Plug>(unimpaired-blank-down) :<C-U>exe <SID>BlankDown()<CR>
-
-nnoremap <silent> <Plug>unimpairedBlankUp   :<C-U>exe <SID>BlankUp()<CR>
-nnoremap <silent> <Plug>unimpairedBlankDown :<C-U>exe <SID>BlankDown()<CR>
-
-exe s:Map('n', '[<Space>', '<Plug>(unimpaired-blank-up)')
-exe s:Map('n', ']<Space>', '<Plug>(unimpaired-blank-down)')
-
-function! s:ExecMove(cmd) abort
-  let old_fdm = &foldmethod
-  if old_fdm !=# 'manual'
-    let &foldmethod = 'manual'
-  endif
-  normal! m`
-  silent! exe a:cmd
-  norm! ``
-  if old_fdm !=# 'manual'
-    let &foldmethod = old_fdm
-  endif
-endfunction
-
-function! s:Move(cmd, count, map) abort
-  call s:ExecMove('move'.a:cmd.a:count)
-  silent! call repeat#set("\<Plug>(unimpaired-move-".a:map.")", a:count)
-endfunction
-
-function! s:MoveSelectionUp(count) abort
-  call s:ExecMove("'<,'>move'<--".a:count)
-  silent! call repeat#set("\<Plug>(unimpaired-move-selection-up)", a:count)
-endfunction
-
-function! s:MoveSelectionDown(count) abort
-  call s:ExecMove("'<,'>move'>+".a:count)
-  silent! call repeat#set("\<Plug>(unimpaired-move-selection-down)", a:count)
-endfunction
-
-nnoremap <silent> <Plug>(unimpaired-move-up)            :<C-U>call <SID>Move('--',v:count1,'up')<CR>
-nnoremap <silent> <Plug>(unimpaired-move-down)          :<C-U>call <SID>Move('+',v:count1,'down')<CR>
-noremap  <silent> <Plug>(unimpaired-move-selection-up)   :<C-U>call <SID>MoveSelectionUp(v:count1)<CR>
-noremap  <silent> <Plug>(unimpaired-move-selection-down) :<C-U>call <SID>MoveSelectionDown(v:count1)<CR>
-nnoremap <silent> <Plug>unimpairedMoveUp            :<C-U>call <SID>Move('--',v:count1,'up')<CR>
-nnoremap <silent> <Plug>unimpairedMoveDown          :<C-U>call <SID>Move('+',v:count1,'down')<CR>
-noremap  <silent> <Plug>unimpairedMoveSelectionUp   :<C-U>call <SID>MoveSelectionUp(v:count1)<CR>
-noremap  <silent> <Plug>unimpairedMoveSelectionDown :<C-U>call <SID>MoveSelectionDown(v:count1)<CR>
-
-exe s:Map('n', '[e', '<Plug>(unimpaired-move-up)')
-exe s:Map('n', ']e', '<Plug>(unimpaired-move-down)')
-exe s:Map('x', '[e', '<Plug>(unimpaired-move-selection-up)')
-exe s:Map('x', ']e', '<Plug>(unimpaired-move-selection-down)')
-
-" Section: Option toggling
-
-function! s:StatuslineRefresh() abort
-  let &l:readonly = &l:readonly
-  return ''
-endfunction
-
-function! s:Toggle(op) abort
-  call s:StatuslineRefresh()
-  return eval('&'.a:op) ? 'no'.a:op : a:op
-endfunction
-
-function! s:CursorOptions() abort
-  return &cursorline && &cursorcolumn ? 'nocursorline nocursorcolumn' : 'cursorline cursorcolumn'
-endfunction
-
-function! s:option_map(letter, option, mode) abort
-  exe 'nmap <script> <Plug>(unimpaired-enable)' .a:letter ':<C-U>'.a:mode.' '.a:option.'<C-R>=<SID>StatuslineRefresh()<CR><CR>'
-  exe 'nmap <script> <Plug>(unimpaired-disable)'.a:letter ':<C-U>'.a:mode.' no'.a:option.'<C-R>=<SID>StatuslineRefresh()<CR><CR>'
-  exe 'nmap <script> <Plug>(unimpaired-toggle)' .a:letter ':<C-U>'.a:mode.' <C-R>=<SID>Toggle("'.a:option.'")<CR><CR>'
-endfunction
-
-nmap <script> <Plug>(unimpaired-enable)b  :<C-U>set background=light<CR>
-nmap <script> <Plug>(unimpaired-disable)b :<C-U>set background=dark<CR>
-nmap <script> <Plug>(unimpaired-toggle)b  :<C-U>set background=<C-R>=&background == "dark" ? "light" : "dark"<CR><CR>
-call s:option_map('c', 'cursorline', 'setlocal')
-call s:option_map('-', 'cursorline', 'setlocal')
-call s:option_map('_', 'cursorline', 'setlocal')
-call s:option_map('u', 'cursorcolumn', 'setlocal')
-call s:option_map('<Bar>', 'cursorcolumn', 'setlocal')
-nmap <script> <Plug>(unimpaired-enable)d  :<C-U>diffthis<CR>
-nmap <script> <Plug>(unimpaired-disable)d :<C-U>diffoff<CR>
-nmap <script> <Plug>(unimpaired-toggle)d  :<C-U><C-R>=&diff ? "diffoff" : "diffthis"<CR><CR>
-call s:option_map('h', 'hlsearch', 'set')
-call s:option_map('i', 'ignorecase', 'set')
-call s:option_map('l', 'list', 'setlocal')
-call s:option_map('n', 'number', 'setlocal')
-call s:option_map('r', 'relativenumber', 'setlocal')
-call s:option_map('s', 'spell', 'setlocal')
-call s:option_map('w', 'wrap', 'setlocal')
-if empty(maparg('<Plug>(unimpaired-toggle)z', 'n'))
-  call s:option_map('z', 'spell', 'setlocal')
-endif
-nmap <script> <Plug>(unimpaired-enable)v  :<C-U>set virtualedit+=all<CR>
-nmap <script> <Plug>(unimpaired-disable)v :<C-U>set virtualedit-=all<CR>
-nmap <script> <Plug>(unimpaired-toggle)v  :<C-U>set <C-R>=(&virtualedit =~# "all") ? "virtualedit-=all" : "virtualedit+=all"<CR><CR>
-nmap <script> <Plug>(unimpaired-enable)x  :<C-U>set cursorline cursorcolumn<CR>
-nmap <script> <Plug>(unimpaired-disable)x :<C-U>set nocursorline nocursorcolumn<CR>
-nmap <script> <Plug>(unimpaired-toggle)x  :<C-U>set <C-R>=<SID>CursorOptions()<CR><CR>
-nmap <script> <Plug>(unimpaired-enable)+  :<C-U>set cursorline cursorcolumn<CR>
-nmap <script> <Plug>(unimpaired-disable)+ :<C-U>set nocursorline nocursorcolumn<CR>
-nmap <script> <Plug>(unimpaired-toggle)+  :<C-U>set <C-R>=<SID>CursorOptions()<CR><CR>
-
-function! s:ColorColumn(should_clear) abort
-  if !empty(&colorcolumn)
-    let s:colorcolumn = &colorcolumn
-  endif
-  return a:should_clear ? '' : get(s:, 'colorcolumn', get(g:, 'unimpaired_colorcolumn', '+1'))
-endfunction
-nmap <script> <Plug>(unimpaired-enable)t  :<C-U>set colorcolumn=<C-R>=<SID>ColorColumn(0)<CR><CR>
-nmap <script> <Plug>(unimpaired-disable)t :<C-U>set colorcolumn=<C-R>=<SID>ColorColumn(1)<CR><CR>
-nmap <script> <Plug>(unimpaired-toggle)t  :<C-U>set colorcolumn=<C-R>=<SID>ColorColumn(!empty(&cc))<CR><CR>
-
-exe s:Map('n', 'yo', '<Plug>(unimpaired-toggle)')
-exe s:Map('n', '[o', '<Plug>(unimpaired-enable)')
-exe s:Map('n', ']o', '<Plug>(unimpaired-disable)')
-exe s:Map('n', 'yo<Esc>', '<Nop>')
-exe s:Map('n', '[o<Esc>', '<Nop>')
-exe s:Map('n', ']o<Esc>', '<Nop>')
-exe s:Map('n', '=s', '<Plug>(unimpaired-toggle)')
-exe s:Map('n', '<s', '<Plug>(unimpaired-enable)')
-exe s:Map('n', '>s', '<Plug>(unimpaired-disable)')
-exe s:Map('n', '=s<Esc>', '<Nop>')
-exe s:Map('n', '<s<Esc>', '<Nop>')
-exe s:Map('n', '>s<Esc>', '<Nop>')
-
-function! s:RestorePaste() abort
-  if exists('s:paste')
-    let &paste = s:paste
-    let &mouse = s:mouse
-    unlet s:paste
-    unlet s:mouse
-  endif
-  autocmd! unimpaired_paste
-endfunction
-
-function! s:SetupPaste() abort
-  let s:paste = &paste
-  let s:mouse = &mouse
-  set paste
-  set mouse=
-  augroup unimpaired_paste
-    autocmd!
-    autocmd InsertLeave * call s:RestorePaste()
-    if exists('##ModeChanged')
-      autocmd ModeChanged *:n call s:RestorePaste()
-    else
-      autocmd CursorHold,CursorMoved * call s:RestorePaste()
-    endif
-  augroup END
-endfunction
-
-nnoremap <silent> <Plug>unimpairedPaste :call <SID>SetupPaste()<CR>
-nmap <script><silent> <Plug>(unimpaired-paste) :<C-U>call <SID>SetupPaste()<CR>
-
-nmap <script><silent> <Plug>(unimpaired-enable)p  :<C-U>call <SID>SetupPaste()<CR>O
-nmap <script><silent> <Plug>(unimpaired-disable)p :<C-U>call <SID>SetupPaste()<CR>o
-nmap <script><silent> <Plug>(unimpaired-toggle)p  :<C-U>call <SID>SetupPaste()<CR>0C
-
-" Section: Put
-
-function! s:putline(how, map) abort
-  let [body, type] = [getreg(v:register), getregtype(v:register)]
-  if type ==# 'V'
-    exe 'normal! "'.v:register.a:how
-  else
-    call setreg(v:register, body, 'l')
-    exe 'normal! "'.v:register.a:how
-    call setreg(v:register, body, type)
-  endif
-  silent! call repeat#set("\<Plug>(unimpaired-put-".a:map.")")
-endfunction
-
-nnoremap <silent> <Plug>(unimpaired-put-above) :call <SID>putline('[p', 'above')<CR>
-nnoremap <silent> <Plug>(unimpaired-put-below) :call <SID>putline(']p', 'below')<CR>
-nnoremap <silent> <Plug>(unimpaired-put-above-rightward) :<C-U>call <SID>putline(v:count1 . '[p', 'Above')<CR>>']
-nnoremap <silent> <Plug>(unimpaired-put-below-rightward) :<C-U>call <SID>putline(v:count1 . ']p', 'Below')<CR>>']
-nnoremap <silent> <Plug>(unimpaired-put-above-leftward)  :<C-U>call <SID>putline(v:count1 . '[p', 'Above')<CR><']
-nnoremap <silent> <Plug>(unimpaired-put-below-leftward)  :<C-U>call <SID>putline(v:count1 . ']p', 'Below')<CR><']
-nnoremap <silent> <Plug>(unimpaired-put-above-reformat)  :<C-U>call <SID>putline(v:count1 . '[p', 'Above')<CR>=']
-nnoremap <silent> <Plug>(unimpaired-put-below-reformat)  :<C-U>call <SID>putline(v:count1 . ']p', 'Below')<CR>=']
-nnoremap <silent> <Plug>unimpairedPutAbove :call <SID>putline('[p', 'above')<CR>
-nnoremap <silent> <Plug>unimpairedPutBelow :call <SID>putline(']p', 'below')<CR>
-
-exe s:Map('n', '[p', '<Plug>(unimpaired-put-above)')
-exe s:Map('n', ']p', '<Plug>(unimpaired-put-below)')
-exe s:Map('n', '[P', '<Plug>(unimpaired-put-above)')
-exe s:Map('n', ']P', '<Plug>(unimpaired-put-below)')
-
-exe s:Map('n', '>P', "<Plug>(unimpaired-put-above-rightward)")
-exe s:Map('n', '>p', "<Plug>(unimpaired-put-below-rightward)")
-exe s:Map('n', '<P', "<Plug>(unimpaired-put-above-leftward)")
-exe s:Map('n', '<p', "<Plug>(unimpaired-put-below-leftward)")
-exe s:Map('n', '=P', "<Plug>(unimpaired-put-above-reformat)")
-exe s:Map('n', '=p', "<Plug>(unimpaired-put-below-reformat)")
-
-" Section: Encoding and decoding
-
-function! s:string_encode(str) abort
-  let map = {"\n": 'n', "\r": 'r', "\t": 't', "\b": 'b', "\f": '\f', '"': '"', '\': '\'}
-  return substitute(a:str,"[\001-\033\\\\\"]",'\="\\".get(map,submatch(0),printf("%03o",char2nr(submatch(0))))','g')
-endfunction
-
-function! s:string_decode(str) abort
-  let map = {'n': "\n", 'r': "\r", 't': "\t", 'b': "\b", 'f': "\f", 'e': "\e", 'a': "\001", 'v': "\013", "\n": ''}
-  let str = a:str
-  if str =~# '^\s*".\{-\}\\\@<!\%(\\\\\)*"\s*\n\=$'
-    let str = substitute(substitute(str,'^\s*\zs"','',''),'"\ze\s*\n\=$','','')
-  endif
-  return substitute(str,'\\\(\o\{1,3\}\|x\x\{1,2\}\|u\x\{1,4\}\|.\)','\=get(map,submatch(1),submatch(1) =~? "^[0-9xu]" ? nr2char("0".substitute(submatch(1),"^[Uu]","x","")) : submatch(1))','g')
-endfunction
-
-function! s:url_encode(str) abort
-  " iconv trick to convert utf-8 bytes to 8bits indiviual char.
-  return substitute(iconv(a:str, 'latin1', 'utf-8'),'[^A-Za-z0-9_.~-]','\="%".printf("%02X",char2nr(submatch(0)))','g')
-endfunction
-
-function! s:url_decode(str) abort
-  let str = substitute(substitute(substitute(a:str,'%0[Aa]\n$','%0A',''),'%0[Aa]','\n','g'),'+',' ','g')
-  return iconv(substitute(str,'%\(\x\x\)','\=nr2char("0x".submatch(1))','g'), 'utf-8', 'latin1')
-endfunction
-
-" HTML entities {{{2
-
-let g:unimpaired_html_entities = {
-      \ 'nbsp':     160, 'iexcl':    161, 'cent':     162, 'pound':    163,
-      \ 'curren':   164, 'yen':      165, 'brvbar':   166, 'sect':     167,
-      \ 'uml':      168, 'copy':     169, 'ordf':     170, 'laquo':    171,
-      \ 'not':      172, 'shy':      173, 'reg':      174, 'macr':     175,
-      \ 'deg':      176, 'plusmn':   177, 'sup2':     178, 'sup3':     179,
-      \ 'acute':    180, 'micro':    181, 'para':     182, 'middot':   183,
-      \ 'cedil':    184, 'sup1':     185, 'ordm':     186, 'raquo':    187,
-      \ 'frac14':   188, 'frac12':   189, 'frac34':   190, 'iquest':   191,
-      \ 'Agrave':   192, 'Aacute':   193, 'Acirc':    194, 'Atilde':   195,
-      \ 'Auml':     196, 'Aring':    197, 'AElig':    198, 'Ccedil':   199,
-      \ 'Egrave':   200, 'Eacute':   201, 'Ecirc':    202, 'Euml':     203,
-      \ 'Igrave':   204, 'Iacute':   205, 'Icirc':    206, 'Iuml':     207,
-      \ 'ETH':      208, 'Ntilde':   209, 'Ograve':   210, 'Oacute':   211,
-      \ 'Ocirc':    212, 'Otilde':   213, 'Ouml':     214, 'times':    215,
-      \ 'Oslash':   216, 'Ugrave':   217, 'Uacute':   218, 'Ucirc':    219,
-      \ 'Uuml':     220, 'Yacute':   221, 'THORN':    222, 'szlig':    223,
-      \ 'agrave':   224, 'aacute':   225, 'acirc':    226, 'atilde':   227,
-      \ 'auml':     228, 'aring':    229, 'aelig':    230, 'ccedil':   231,
-      \ 'egrave':   232, 'eacute':   233, 'ecirc':    234, 'euml':     235,
-      \ 'igrave':   236, 'iacute':   237, 'icirc':    238, 'iuml':     239,
-      \ 'eth':      240, 'ntilde':   241, 'ograve':   242, 'oacute':   243,
-      \ 'ocirc':    244, 'otilde':   245, 'ouml':     246, 'divide':   247,
-      \ 'oslash':   248, 'ugrave':   249, 'uacute':   250, 'ucirc':    251,
-      \ 'uuml':     252, 'yacute':   253, 'thorn':    254, 'yuml':     255,
-      \ 'OElig':    338, 'oelig':    339, 'Scaron':   352, 'scaron':   353,
-      \ 'Yuml':     376, 'circ':     710, 'tilde':    732, 'ensp':    8194,
-      \ 'emsp':    8195, 'thinsp':  8201, 'zwnj':    8204, 'zwj':     8205,
-      \ 'lrm':     8206, 'rlm':     8207, 'ndash':   8211, 'mdash':   8212,
-      \ 'lsquo':   8216, 'rsquo':   8217, 'sbquo':   8218, 'ldquo':   8220,
-      \ 'rdquo':   8221, 'bdquo':   8222, 'dagger':  8224, 'Dagger':  8225,
-      \ 'permil':  8240, 'lsaquo':  8249, 'rsaquo':  8250, 'euro':    8364,
-      \ 'fnof':     402, 'Alpha':    913, 'Beta':     914, 'Gamma':    915,
-      \ 'Delta':    916, 'Epsilon':  917, 'Zeta':     918, 'Eta':      919,
-      \ 'Theta':    920, 'Iota':     921, 'Kappa':    922, 'Lambda':   923,
-      \ 'Mu':       924, 'Nu':       925, 'Xi':       926, 'Omicron':  927,
-      \ 'Pi':       928, 'Rho':      929, 'Sigma':    931, 'Tau':      932,
-      \ 'Upsilon':  933, 'Phi':      934, 'Chi':      935, 'Psi':      936,
-      \ 'Omega':    937, 'alpha':    945, 'beta':     946, 'gamma':    947,
-      \ 'delta':    948, 'epsilon':  949, 'zeta':     950, 'eta':      951,
-      \ 'theta':    952, 'iota':     953, 'kappa':    954, 'lambda':   955,
-      \ 'mu':       956, 'nu':       957, 'xi':       958, 'omicron':  959,
-      \ 'pi':       960, 'rho':      961, 'sigmaf':   962, 'sigma':    963,
-      \ 'tau':      964, 'upsilon':  965, 'phi':      966, 'chi':      967,
-      \ 'psi':      968, 'omega':    969, 'thetasym': 977, 'upsih':    978,
-      \ 'piv':      982, 'bull':    8226, 'hellip':  8230, 'prime':   8242,
-      \ 'Prime':   8243, 'oline':   8254, 'frasl':   8260, 'weierp':  8472,
-      \ 'image':   8465, 'real':    8476, 'trade':   8482, 'alefsym': 8501,
-      \ 'larr':    8592, 'uarr':    8593, 'rarr':    8594, 'darr':    8595,
-      \ 'harr':    8596, 'crarr':   8629, 'lArr':    8656, 'uArr':    8657,
-      \ 'rArr':    8658, 'dArr':    8659, 'hArr':    8660, 'forall':  8704,
-      \ 'part':    8706, 'exist':   8707, 'empty':   8709, 'nabla':   8711,
-      \ 'isin':    8712, 'notin':   8713, 'ni':      8715, 'prod':    8719,
-      \ 'sum':     8721, 'minus':   8722, 'lowast':  8727, 'radic':   8730,
-      \ 'prop':    8733, 'infin':   8734, 'ang':     8736, 'and':     8743,
-      \ 'or':      8744, 'cap':     8745, 'cup':     8746, 'int':     8747,
-      \ 'there4':  8756, 'sim':     8764, 'cong':    8773, 'asymp':   8776,
-      \ 'ne':      8800, 'equiv':   8801, 'le':      8804, 'ge':      8805,
-      \ 'sub':     8834, 'sup':     8835, 'nsub':    8836, 'sube':    8838,
-      \ 'supe':    8839, 'oplus':   8853, 'otimes':  8855, 'perp':    8869,
-      \ 'sdot':    8901, 'lceil':   8968, 'rceil':   8969, 'lfloor':  8970,
-      \ 'rfloor':  8971, 'lang':    9001, 'rang':    9002, 'loz':     9674,
-      \ 'spades':  9824, 'clubs':   9827, 'hearts':  9829, 'diams':   9830,
-      \ 'apos':      39}
-
-" }}}2
-
-function! s:xml_encode(str) abort
-  let str = a:str
-  let str = substitute(str,'&','\&amp;','g')
-  let str = substitute(str,'<','\&lt;','g')
-  let str = substitute(str,'>','\&gt;','g')
-  let str = substitute(str,'"','\&quot;','g')
-  let str = substitute(str,"'",'\&apos;','g')
-  return str
-endfunction
-
-function! s:xml_entity_decode(str) abort
-  let str = substitute(a:str,'\c&#\%(0*38\|x0*26\);','&amp;','g')
-  let str = substitute(str,'\c&#\(\d\+\);','\=nr2char(submatch(1))','g')
-  let str = substitute(str,'\c&#\(x\x\+\);','\=nr2char("0".submatch(1))','g')
-  let str = substitute(str,'\c&apos;',"'",'g')
-  let str = substitute(str,'\c&quot;','"','g')
-  let str = substitute(str,'\c&gt;','>','g')
-  let str = substitute(str,'\c&lt;','<','g')
-  let str = substitute(str,'\C&\(\%(amp;\)\@!\w*\);','\=nr2char(get(g:unimpaired_html_entities,submatch(1),63))','g')
-  return substitute(str,'\c&amp;','\&','g')
-endfunction
-
-function! s:xml_decode(str) abort
-  let str = substitute(a:str,'<\%([[:alnum:]-]\+=\%("[^"]*"\|''[^'']*''\)\|.\)\{-\}>','','g')
-  return s:xml_entity_decode(str)
-endfunction
-
-function! s:Transform(algorithm,type) abort
-  let sel_save = &selection
-  let cb_save = &clipboard
-  set selection=inclusive clipboard-=unnamed clipboard-=unnamedplus
-  let reg_save = exists('*getreginfo') ? getreginfo('@') : getreg('@')
-  if a:type ==# 'line'
-    silent exe "normal! '[V']y"
-    let @@ = substitute(@@, "\n$", '', '')
-  elseif a:type ==# 'block'
-    silent exe "normal! `[\<C-V>`]y"
-  else
-    silent exe "normal! `[v`]y"
-  endif
-  if a:algorithm =~# '^\u\|#'
-    let @@ = {a:algorithm}(@@)
-  else
-    let @@ = s:{a:algorithm}(@@)
-  endif
-  norm! gvp
-  call setreg('@', reg_save)
-  let &selection = sel_save
-  let &clipboard = cb_save
-endfunction
-
-function! s:TransformOpfunc(type) abort
-  return s:Transform(s:encode_algorithm, a:type)
-endfunction
-
-function! s:TransformSetup(algorithm) abort
-  let s:encode_algorithm = a:algorithm
-  let &opfunc = matchstr(expand('<sfile>'), '<SNR>\d\+_').'TransformOpfunc'
-  return 'g@'
-endfunction
-
-function! UnimpairedMapTransform(algorithm, key) abort
-  let name = tr(a:algorithm, '_', '-')
-  exe 'nnoremap <expr> <Plug>unimpaired_'    .a:algorithm.' <SID>TransformSetup("'.a:algorithm.'")'
-  exe 'xnoremap <expr> <Plug>unimpaired_'    .a:algorithm.' <SID>TransformSetup("'.a:algorithm.'")'
-  exe 'nnoremap <expr> <Plug>unimpaired_line_'.a:algorithm.' <SID>TransformSetup("'.a:algorithm.'")."_"'
-  exe 'nnoremap <expr> <Plug>(unimpaired-' . name . ') <SID>TransformSetup("'.a:algorithm.'")'
-  exe 'xnoremap <expr> <Plug>(unimpaired-' . name . ') <SID>TransformSetup("'.a:algorithm.'")'
-  exe 'nnoremap <expr> <Plug>(unimpaired-' . name . '-line) <SID>TransformSetup("'.a:algorithm.'")."_"'
-  exe s:Map('n', a:key, '<Plug>(unimpaired-' . name . ')')
-  exe s:Map('x', a:key, '<Plug>(unimpaired-' . name . ')')
-  exe s:Map('n', a:key.a:key[strlen(a:key)-1], '<Plug>(unimpaired-' . name . '-line)')
-  return ''
-endfunction
-
-exe UnimpairedMapTransform('string_encode','[y')
-exe UnimpairedMapTransform('string_decode',']y')
-exe UnimpairedMapTransform('string_encode','[C')
-exe UnimpairedMapTransform('string_decode',']C')
-exe UnimpairedMapTransform('url_encode','[u')
-exe UnimpairedMapTransform('url_decode',']u')
-exe UnimpairedMapTransform('xml_encode','[x')
-exe UnimpairedMapTransform('xml_decode',']x')
-
-" vim:set sw=2 sts=2: