diff --git a/.config/nvim/init.lua b/.config/nvim/init.lua
index cc9a734..c13031a 100644
--- a/.config/nvim/init.lua
+++ b/.config/nvim/init.lua
@@ -199,3 +199,24 @@ require('onedark').setup {
 require('onedark').load()
 
 require('func.puppet')
+require('mini.cursorword').setup()
+
+local hipatterns = require('mini.hipatterns')
+hipatterns.setup({
+  highlighters = {
+    -- Highlight standalone 'FIXME', 'HACK', 'TODO', 'NOTE'
+    fixme = { pattern = '%f[%w]()FIXME()%f[%W]', group = 'MiniHipatternsFixme' },
+    hack  = { pattern = '%f[%w]()HACK()%f[%W]',  group = 'MiniHipatternsHack'  },
+    todo  = { pattern = '%f[%w]()TODO()%f[%W]',  group = 'MiniHipatternsTodo'  },
+    note  = { pattern = '%f[%w]()NOTE()%f[%W]',  group = 'MiniHipatternsNote'  },
+
+    -- Highlight hex color strings (`#rrggbb`) using that color
+    hex_color = hipatterns.gen_highlighter.hex_color(),
+  },
+})
+
+require('mini.indentscope').setup()
+--require('mini.pairs').setup()
+require('mini.splitjoin').setup()
+require('mini.surround').setup()
+require('mini.trailspace').setup()
diff --git a/.config/nvim/lua/mini/cursorword.lua b/.config/nvim/lua/mini/cursorword.lua
new file mode 100644
index 0000000..9568ff4
--- /dev/null
+++ b/.config/nvim/lua/mini/cursorword.lua
@@ -0,0 +1,287 @@
+--- *mini.cursorword* Autohighlight word under cursor
+--- *MiniCursorword*
+---
+--- MIT License Copyright (c) 2021 Evgeni Chasnovski
+---
+--- ==============================================================================
+---
+--- Features:
+--- - Autohighlight word under cursor with customizable delay.
+---
+--- - Current word under cursor can be highlighted differently.
+---
+--- - Highlighting is triggered only if current cursor character is a |[:keyword:]|.
+---
+--- - Highlighting stops in insert and terminal modes.
+---
+--- - "Word under cursor" is meant as in Vim's |<cword>|: something user would
+---   get as 'iw' text object.
+---
+--- # Setup~
+---
+--- This module needs a setup with `require('mini.cursorword').setup({})`
+--- (replace `{}` with your `config` table). It will create global Lua table
+--- `MiniCursorword` which you can use for scripting or manually (with
+--- `:lua MiniCursorword.*`).
+---
+--- See |MiniCursorword.config| for `config` structure and default values.
+---
+--- You can override runtime config settings locally to buffer inside
+--- `vim.b.minicursorword_config` which should have same structure as
+--- `MiniCursorword.config`. See |mini.nvim-buffer-local-config| for more details.
+---
+--- # Highlight groups~
+---
+--- * `MiniCursorword` - highlight group of a non-current cursor word.
+---   Default: plain underline.
+---
+--- * `MiniCursorwordCurrent` - highlight group of a current word under cursor.
+---   Default: links to `MiniCursorword` (so `:hi clear MiniCursorwordCurrent`
+---   will lead to showing `MiniCursorword` highlight group).
+---   Note: To not highlight it, use
+---
+---   `:hi! MiniCursorwordCurrent guifg=NONE guibg=NONE gui=NONE cterm=NONE`
+---
+--- To change any highlight group, modify it directly with |:highlight|.
+---
+--- # Disabling~
+---
+--- To disable core functionality, set `vim.g.minicursorword_disable` (globally) or
+--- `vim.b.minicursorword_disable` (for a buffer) to `true`. Considering high
+--- number of different scenarios and customization intentions, writing exact
+--- rules for disabling module's functionality is left to user. See
+--- |mini.nvim-disabling-recipes| for common recipes. Note: after disabling
+--- there might be highlighting left; it will be removed after next
+--- highlighting update.
+---
+--- Module-specific disabling:
+--- - Don't show highlighting if cursor is on the word that is in a blocklist
+---   of current filetype. In this example, blocklist for "lua" is "local" and
+---   "require" words, for "javascript" - "import":
+--- >
+---   _G.cursorword_blocklist = function()
+---     local curword = vim.fn.expand('<cword>')
+---     local filetype = vim.bo.filetype
+---
+---     -- Add any disabling global or filetype-specific logic here
+---     local blocklist = {}
+---     if filetype == 'lua' then
+---       blocklist = { 'local', 'require' }
+---     elseif filetype == 'javascript' then
+---       blocklist = { 'import' }
+---     end
+---
+---     vim.b.minicursorword_disable = vim.tbl_contains(blocklist, curword)
+---   end
+---
+---   -- Make sure to add this autocommand *before* calling module's `setup()`.
+---   vim.cmd('au CursorMoved * lua _G.cursorword_blocklist()')
+
+-- Module definition ==========================================================
+local MiniCursorword = {}
+local H = {}
+
+--- Module setup
+---
+---@param config table|nil Module config table. See |MiniCursorword.config|.
+---
+---@usage `require('mini.cursorword').setup({})` (replace `{}` with your `config` table)
+MiniCursorword.setup = function(config)
+  -- Export module
+  _G.MiniCursorword = MiniCursorword
+
+  -- Setup config
+  config = H.setup_config(config)
+
+  -- Apply config
+  H.apply_config(config)
+
+  -- Define behavior
+  H.create_autocommands()
+
+  -- Create default highlighting
+  H.create_default_hl()
+end
+
+--- Module config
+---
+--- Default values:
+---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
+MiniCursorword.config = {
+  -- Delay (in ms) between when cursor moved and when highlighting appeared
+  delay = 100,
+}
+--minidoc_afterlines_end
+
+-- Module functionality =======================================================
+
+-- Helper data ================================================================
+-- Module default config
+H.default_config = vim.deepcopy(MiniCursorword.config)
+
+-- Delay timer
+H.timer = vim.loop.new_timer()
+
+-- Information about last match highlighting (stored *per window*):
+-- - Key: windows' unique buffer identifiers.
+-- - Value: table with:
+--     - `id` field for match id (from `vim.fn.matchadd()`).
+--     - `word` field for matched word.
+H.window_matches = {}
+
+-- Helper functionality =======================================================
+-- Settings -------------------------------------------------------------------
+H.setup_config = function(config)
+  -- General idea: if some table elements are not present in user-supplied
+  -- `config`, take them from default config
+  vim.validate({ config = { config, 'table', true } })
+  config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
+
+  vim.validate({ delay = { config.delay, 'number' } })
+
+  return config
+end
+
+H.apply_config = function(config) MiniCursorword.config = config end
+
+H.create_autocommands = function()
+  local augroup = vim.api.nvim_create_augroup('MiniCursorword', {})
+
+  local au = function(event, pattern, callback, desc)
+    vim.api.nvim_create_autocmd(event, { group = augroup, pattern = pattern, callback = callback, desc = desc })
+  end
+
+  au('CursorMoved', '*', H.auto_highlight, 'Auto highlight cursorword')
+  au({ 'InsertEnter', 'TermEnter', 'QuitPre' }, '*', H.auto_unhighlight, 'Auto unhighlight cursorword')
+  au('ModeChanged', '*:[^i]', H.auto_highlight, 'Auto highlight cursorword')
+
+  au('ColorScheme', '*', H.create_default_hl, 'Ensure proper colors')
+  au('FileType', 'TelescopePrompt', function() vim.b.minicursorword_disable = true end, 'Disable locally')
+end
+
+--stylua: ignore
+H.create_default_hl = function()
+  vim.api.nvim_set_hl(0, 'MiniCursorword',        { default = true, underline = true })
+  vim.api.nvim_set_hl(0, 'MiniCursorwordCurrent', { default = true, link = 'MiniCursorword' })
+end
+
+H.is_disabled = function() return vim.g.minicursorword_disable == true or vim.b.minicursorword_disable == true end
+
+H.get_config = function(config)
+  return vim.tbl_deep_extend('force', MiniCursorword.config, vim.b.minicursorword_config or {}, config or {})
+end
+
+-- Autocommands ---------------------------------------------------------------
+H.auto_highlight = function()
+  -- Stop any possible previous delayed highlighting
+  H.timer:stop()
+
+  -- Stop highlighting immediately if module is disabled when cursor is not on
+  -- 'keyword'
+  if not H.should_highlight() then return H.unhighlight() end
+
+  -- Get current information
+  local win_id = vim.api.nvim_get_current_win()
+  local win_match = H.window_matches[win_id] or {}
+  local curword = H.get_cursor_word()
+
+  -- Only immediately update highlighting of current word under cursor if
+  -- currently highlighted word equals one under cursor
+  if win_match.word == curword then
+    H.unhighlight(true)
+    H.highlight(true)
+    return
+  end
+
+  -- Stop highlighting previous match (if it exists)
+  H.unhighlight()
+
+  -- Delay highlighting
+  H.timer:start(
+    H.get_config().delay,
+    0,
+    vim.schedule_wrap(function()
+      -- Ensure that always only one word is highlighted
+      H.unhighlight()
+      H.highlight()
+    end)
+  )
+end
+
+H.auto_unhighlight = function()
+  -- Stop any possible previous delayed highlighting
+  H.timer:stop()
+  H.unhighlight()
+end
+
+-- Highlighting ---------------------------------------------------------------
+---@param only_current boolean|nil Whether to forcefully highlight only current word
+---   under cursor.
+---@private
+H.highlight = function(only_current)
+  -- A modified version of https://stackoverflow.com/a/25233145
+  -- Using `matchadd()` instead of a simpler `:match` to tweak priority of
+  -- 'current word' highlighting: with `:match` it is higher than for
+  -- `incsearch` which is not convenient.
+  local win_id = vim.api.nvim_get_current_win()
+  if not vim.api.nvim_win_is_valid(win_id) then return end
+
+  if not H.should_highlight() then return end
+
+  H.window_matches[win_id] = H.window_matches[win_id] or {}
+
+  -- Add match highlight for current word under cursor
+  local current_word_pattern = [[\k*\%#\k*]]
+  local match_id_current = vim.fn.matchadd('MiniCursorwordCurrent', current_word_pattern, -1)
+  H.window_matches[win_id].id_current = match_id_current
+
+  -- Don't add main match id if not needed or if one is already present
+  if only_current or H.window_matches[win_id].id ~= nil then return end
+
+  -- Add match highlight for non-current word under cursor. NOTEs:
+  -- - Using `\(...\)\@!` allows to not match current word.
+  -- - Using 'very nomagic' ('\V') allows not escaping.
+  -- - Using `\<` and `\>` matches whole word (and not as part).
+  local curword = H.get_cursor_word()
+  local pattern = string.format([[\(%s\)\@!\&\V\<%s\>]], current_word_pattern, curword)
+  local match_id = vim.fn.matchadd('MiniCursorword', pattern, -1)
+
+  -- Store information about highlight
+  H.window_matches[win_id].id = match_id
+  H.window_matches[win_id].word = curword
+end
+
+---@param only_current boolean|nil Whether to remove highlighting only of current
+---   word under cursor.
+---@private
+H.unhighlight = function(only_current)
+  -- Don't do anything if there is no valid information to act upon
+  local win_id = vim.api.nvim_get_current_win()
+  local win_match = H.window_matches[win_id]
+  if not vim.api.nvim_win_is_valid(win_id) or win_match == nil then return end
+
+  -- Use `pcall` because there is an error if match id is not present. It can
+  -- happen if something else called `clearmatches`.
+  pcall(vim.fn.matchdelete, win_match.id_current)
+  H.window_matches[win_id].id_current = nil
+
+  if not only_current then
+    pcall(vim.fn.matchdelete, win_match.id)
+    H.window_matches[win_id] = nil
+  end
+end
+
+H.should_highlight = function() return not H.is_disabled() and H.is_cursor_on_keyword() end
+
+H.is_cursor_on_keyword = function()
+  local col = vim.fn.col('.')
+  local curchar = vim.api.nvim_get_current_line():sub(col, col)
+
+  -- Use `pcall()` to catch `E5108` (can happen in binary files, see #112)
+  local ok, match_res = pcall(vim.fn.match, curchar, '[[:keyword:]]')
+  return ok and match_res >= 0
+end
+
+H.get_cursor_word = function() return vim.fn.escape(vim.fn.expand('<cword>'), [[\/]]) end
+
+return MiniCursorword
diff --git a/.config/nvim/lua/mini/hipatterns.lua b/.config/nvim/lua/mini/hipatterns.lua
new file mode 100644
index 0000000..73b88b7
--- /dev/null
+++ b/.config/nvim/lua/mini/hipatterns.lua
@@ -0,0 +1,1021 @@
+--- *mini.hipatterns* Highlight patterns in text
+--- *MiniHipatterns*
+---
+--- MIT License Copyright (c) 2023 Evgeni Chasnovski
+---
+--- ==============================================================================
+---
+--- Features:
+--- - Highlight text with configurable patterns and highlight groups (can be
+---   string or callable).
+---
+--- - Highlighting is updated asynchronously with configurable debounce delay.
+---
+--- - Function to get matches in a buffer (see |MiniHipatterns.get_matches()|).
+---
+--- See |MiniHipatterns-examples| for common configuration examples.
+---
+--- Notes:
+--- - It does not define any highlighters by default. Add to `config.highlighters`
+---   to have a visible effect.
+---
+--- - Sometimes (especially during frequent buffer updates on same line numbers)
+---   highlighting can be outdated or not applied when it should be. This is due
+---   to asynchronous nature of updates reacting to text changes (via
+---   `on_lines` of |nvim_buf_attach()|).
+---   To make them up to date, use one of the following:
+---     - Scroll window (for example, with |CTRL-E| / |CTRL-Y|). This will ensure
+---       up to date highlighting inside window view.
+---     - Hide and show buffer.
+---     - Execute `:edit` (if you enabled highlighting with |MiniHipatterns.setup()|).
+---     - Manually call |MiniHipatterns.update()|.
+---
+--- - If you experience flicker when typing near highlighted pattern in Insert
+---   mode, it might be due to `delay` configuration of 'mini.completion' or
+---   using built-in completion.
+---   For better experience with 'mini.completion', make sure that its
+---   `delay.completion` is less than this module's `delay.text_change` (which
+---   it is by default).
+---   The reason for this is (currently unresolvable) limitations of Neovim's
+---   built-in completion implementation.
+---
+--- # Setup ~
+---
+--- Setting up highlights can be done in two ways:
+--- - Manually for every buffer with `require('mini.hipatterns').enable()`.
+---   This will enable highlighting only in one particular buffer until it is
+---   unloaded (which also includes calling `:edit` on current file).
+---
+--- - Globally with `require('mini.hipatterns').setup({})` (replace `{}` with
+---   your `config` table). This will auto-enable highlighting in "normal"
+---   buffers (see 'buftype'). Use |MiniHipatterns.enable()| to manually enable
+---   in other buffers.
+---   It will also create global Lua table `MiniHipatterns` which you can use
+---   for scripting or manually (with `:lua MiniHipatterns.*`).
+---
+--- See |MiniHipatterns.config| for `config` structure and default values.
+---
+--- You can override runtime config settings (like highlighters and delays)
+--- locally to buffer inside `vim.b.minihipatterns_config` which should have
+--- same structure as `MiniHipatterns.config`.
+--- See |mini.nvim-buffer-local-config| for more details.
+---
+--- # Comparisons ~
+---
+--- - 'folke/todo-comments':
+---     - Oriented for "TODO", "NOTE", "FIXME" like patterns, while this module
+---       can work with any Lua patterns and computable highlight groups.
+---     - Has functionality beyond text highlighting (sign placing,
+---       "telescope.nvim" extension, etc.), while this module only focuses on
+---       highlighting text.
+--- - 'folke/paint.nvim':
+---     - Mostly similar to this module, but with slightly less functionality,
+---       such as computed pattern and highlight group, asynchronous delay, etc.
+--- - 'NvChad/nvim-colorizer.lua':
+---     - Oriented for color highlighting, while this module can work with any
+---       Lua patterns and computable highlight groups.
+---     - Has more built-in color spaces to highlight, while this module out of
+---       the box provides only hex color highlighting
+---       (see |MiniHipatterns.gen_highlighter.hex_color()|). Other types are
+---       also possible to implement.
+--- - 'uga-rosa/ccc.nvim':
+---     - Has more than color highlighting functionality, which is compared to
+---       this module in the same way as 'NvChad/nvim-colorizer.lua'.
+---
+--- # Highlight groups~
+---
+--- * `MiniHipatternsFixme` - suggested group to use for `FIXME`-like patterns.
+--- * `MiniHipatternsHack` - suggested group to use for `HACK`-like patterns.
+--- * `MiniHipatternsTodo` - suggested group to use for `TODO`-like patterns.
+--- * `MiniHipatternsNote` - suggested group to use for `NOTE`-like patterns.
+---
+--- To change any highlight group, modify it directly with |:highlight|.
+---
+--- # Disabling ~
+---
+--- This module can be disabled in three ways:
+--- - Globally: set `vim.g.minihipatterns_disable` to `true`.
+--- - Locally for buffer permanently: set `vim.b.minihipatterns_disable` to `true`.
+--- - Locally for buffer temporarily (until next auto-enabling event if set up
+---   with |MiniHipatterns.setup()|): call |MiniHipatterns.disable()|.
+---
+--- Considering high number of different scenarios and customization
+--- intentions, writing exact rules for disabling module's functionality is
+--- left to user. See |mini.nvim-disabling-recipes| for common recipes.
+
+--- # Common configuration examples ~
+---
+--- - Special words used to convey different level of attention: >
+---
+---   require('mini.hipatterns').setup({
+---     highlighters = {
+---       fixme = { pattern = 'FIXME', group = 'MiniHipatternsFixme' },
+---       hack  = { pattern = 'HACK',  group = 'MiniHipatternsHack'  },
+---       todo  = { pattern = 'TODO',  group = 'MiniHipatternsTodo'  },
+---       note  = { pattern = 'NOTE',  group = 'MiniHipatternsNote'  },
+---     }
+---   })
+--- <
+--- - To match only when pattern appears as a standalone word, use frontier
+---   patterns `%f`. For example, instead of `'TODO'` pattern use
+---   `'%f[%w]()TODO()%f[%W]'`. In this case, for example, 'TODOING' or 'MYTODO'
+---   won't match, but 'TODO' and 'TODO:' will.
+---
+--- - Color hex (like `#rrggbb`) highlighting: >
+---
+---   local hipatterns = require('mini.hipatterns')
+---   hipatterns.setup({
+---     highlighters = {
+---       hex_color = hipatterns.gen_highlighter.hex_color(),
+---     }
+---   })
+--- <
+---   You can customize which part of hex color is highlighted by using `style`
+---   field of input options. See |MiniHipatterns.gen_highlighter.hex_color()|.
+---
+--- - Colored words: >
+---
+---   local words = { red = '#ff0000', green = '#00ff00', blue = '#0000ff' }
+---   local word_color_group = function(_, match)
+---     local hex = words[match]
+---     if hex == nil then return nil end
+---     return MiniHipatterns.compute_hex_color_group(hex, 'bg')
+---   end
+---
+---   local hipatterns = require('mini.hipatterns')
+---   hipatterns.setup({
+---     highlighters = {
+---       word_color = { pattern = '%S+', group = word_color_group },
+---     },
+---   })
+---
+--- - Trailing whitespace (if don't want to use more specific 'mini.trailspace'): >
+---
+---   { pattern = '%f[%s]%s*$', group = 'Error' }
+---
+--- - Censor certain sensitive information: >
+---
+---   local censor_extmark_opts = function(_, match, _)
+---     local mask = string.rep('x', vim.fn.strchars(match))
+---     return {
+---       virt_text = { { mask, 'Comment' } }, virt_text_pos = 'overlay',
+---       priority = 200, right_gravity = false,
+---     }
+---   end
+---
+---   require('mini.hipatterns').setup({
+---     highlighters = {
+---       censor = {
+---         pattern = 'password: ()%S+()',
+---         group = '',
+---         extmark_opts = censor_extmark_opts,
+---       },
+---     },
+---   })
+---
+--- - Enable only in certain filetypes. There are at least these ways to do it:
+---     - (Suggested) With `vim.b.minihipatterns_config` in |filetype-plugin|.
+---       Basically, create "after/ftplugin/<filetype>.lua" file in your config
+---       directory (see |$XDG_CONFIG_HOME|) and define `vim.b.minihipatterns_config`
+---       there with filetype specific highlighters.
+---
+---       This assumes `require('mini.hipatterns').setup()` call.
+---
+---       For example, to highlight keywords in EmmyLua comments in Lua files,
+---       create "after/ftplugin/lua.lua" with the following content: >
+---
+---         vim.b.minihipatterns_config = {
+---           highlighters = {
+---             emmylua = { pattern = '^%s*%-%-%-()@%w+()', group = 'Special' }
+---           }
+---         }
+--- <
+---     - Use callable `pattern` with condition. For example: >
+---
+---       require('mini.hipatterns').setup({
+---         highlighters = {
+---           emmylua = {
+---             pattern = function(buf_id)
+---               if vim.bo[buf_id].filetype ~= 'lua' then return nil end
+---               return '^%s*%-%-%-()@%w+()'
+---             end,
+---             group = 'Special',
+---           },
+---         },
+---       })
+--- <
+--- - Disable only in certain filetypes. Enable with |MiniHipatterns.setup()|
+---   and set `vim.b.minihipatterns_disable` buffer-local variable to `true` for
+---   buffer you want disabled. See |mini.nvim-disabling-recipes| for more examples.
+---@tag MiniHipatterns-examples
+
+---@alias __hipatterns_buf_id number|nil Buffer identifier in which to enable highlighting.
+---   Default: 0 for current buffer.
+
+---@diagnostic disable:undefined-field
+---@diagnostic disable:discard-returns
+---@diagnostic disable:unused-local
+
+-- Module definition ==========================================================
+local MiniHipatterns = {}
+local H = {}
+
+--- Module setup
+---
+---@param config table|nil Module config table. See |MiniHipatterns.config|.
+---
+---@usage `require('mini.hipatterns').setup({})` (replace `{}` with your `config` table)
+---@text
+--- Note: no highlighters is defined by default. Add them for visible effect.
+MiniHipatterns.setup = function(config)
+  -- Export module
+  _G.MiniHipatterns = MiniHipatterns
+
+  -- Setup config
+  config = H.setup_config(config)
+
+  -- Apply config
+  H.apply_config(config)
+
+  -- Define behavior
+  H.create_autocommands()
+  for _, win_id in ipairs(vim.api.nvim_list_wins()) do
+    H.auto_enable({ buf = vim.api.nvim_win_get_buf(win_id) })
+  end
+
+  -- Create default highlighting
+  H.create_default_hl()
+end
+
+--- Module config
+---
+--- Default values:
+---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
+---@text # Options ~
+---
+--- ## Highlighters ~
+---
+--- `highlighters` table defines which patterns will be highlighted by placing
+--- |extmark| at the match start. It might or might not have explicitly named
+--- fields, but having them is recommended and is required for proper use of
+--- `vim.b.minihipatterns_config` as buffer-local config. By default it is
+--- empty expecting user definition.
+---
+--- Each entry defines single highlighter as a table with the following fields:
+--- - <pattern> `(string|function|table)` - Lua pattern to highlight. Can be
+---   either string, callable returning the string, or an array of those.
+---   If string:
+---     - It can have submatch delimited by placing `()` on start and end, NOT
+---       by surrounding with it. Otherwise it will result in error containing
+---       `number expected, got string`. Example: `xx()abcd()xx` will match `abcd`
+---       only if `xx` is placed before and after it.
+---
+---   If callable:
+---     - It will be called for every enabled buffer with its identifier as input.
+---
+---     - It can return `nil` meaning this particular highlighter will not work
+---       in this particular buffer.
+---
+---   If array:
+---     - Each element is matched and highlighted with the same highlight group.
+---
+--- - <group> `(string|function)` - name of highlight group to use. Can be either
+---   string or callable returning the string.
+---   If callable:
+---     - It will be called for every pattern match with the following arguments:
+---         - `buf_id` - buffer identifier.
+---         - `match` - string pattern match to be highlighted.
+---         - `data` - extra table with information about the match.
+---           It has at least these fields:
+---             - <full_match> - string with full pattern match.
+---             - <line> - match line number (1-indexed).
+---             - <from_col> - match starting byte column (1-indexed).
+---             - <to_col> - match ending byte column (1-indexed, inclusive).
+---
+---     - It can return `nil` meaning this particular match will not be highlighted.
+---
+--- - <extmark_opts> `(table|function|nil)` - optional extra options
+---   for |nvim_buf_set_extmark()|. If callable, will be called in the same way
+---   as callable <group> (`data` will also contain `hl_group` key with <group>
+---   value) and should return a table with all options for extmark (including
+---   `end_row`, `end_col`, `hl_group`, and `priority`).
+---   Note: if <extmark_opts> is supplied, <priority> is ignored.
+---
+--- - <priority> `(number|nil)` - SOFT DEPRECATED in favor
+---   of `extmark_opts = { priority = <value> }`.
+---   Optional highlighting priority (as in |nvim_buf_set_extmark()|).
+---   Default: 200. See also |vim.highlight.priorities|.
+---
+--- See "Common use cases" section for the examples.
+---
+--- ## Delay ~
+---
+--- `delay` is a table defining delays in milliseconds used for asynchronous
+--- highlighting process.
+---
+--- `delay.text_change` is used to delay highlighting updates by accumulating
+--- them (in debounce fashion). Smaller values will lead to faster response but
+--- more frequent updates. Bigger - slower response but less frequent updates.
+---
+--- `delay.scroll` is used to delay updating highlights in current window view
+--- during scrolling (see |WinScrolled| event). These updates are present to
+--- ensure up to date highlighting after scroll.
+MiniHipatterns.config = {
+  -- Table with highlighters (see |MiniHipatterns.config| for more details).
+  -- Nothing is defined by default. Add manually for visible effect.
+  highlighters = {},
+
+  -- Delays (in ms) defining asynchronous highlighting process
+  delay = {
+    -- How much to wait for update after every text change
+    text_change = 200,
+
+    -- How much to wait for update after window scroll
+    scroll = 50,
+  },
+}
+--minidoc_afterlines_end
+
+--- Enable highlighting in buffer
+---
+--- Notes:
+--- - With default config it will highlight nothing, as there are no default
+---   highlighters.
+---
+--- - Buffer highlighting is enabled until buffer is unloaded from memory
+---   or |MiniHipatterns.disable()| on this buffer is called.
+---
+--- - `:edit` disables this, as it is mostly equivalent to closing and opening
+---   buffer. In order for highlighting to persist after `:edit`, call
+---   |MiniHipatterns.setup()|.
+---
+---@param buf_id __hipatterns_buf_id
+---@param config table|nil Optional buffer-local config. Should have the same
+---   structure as |MiniHipatterns.config|. Values will be taken in this order:
+---   - From this `config` argument (if supplied).
+---   - From buffer-local config in `vim.b.minihipatterns_config` (if present).
+---   - From global config (if |MiniHipatterns.setup()| was called).
+---   - From default values.
+MiniHipatterns.enable = function(buf_id, config)
+  buf_id = H.validate_buf_id(buf_id)
+  config = H.validate_config_arg(config)
+
+  -- Don't enable more than once
+  if H.is_buf_enabled(buf_id) then return end
+
+  -- Register enabled buffer with cached data for performance
+  H.update_cache(buf_id, config)
+
+  -- Add buffer watchers
+  vim.api.nvim_buf_attach(buf_id, false, {
+    -- Called on every text change (`:h nvim_buf_lines_event`)
+    on_lines = function(_, _, _, from_line, _, to_line)
+      local buf_cache = H.cache[buf_id]
+      -- Properly detach if highlighting is disabled
+      if buf_cache == nil then return true end
+      H.process_lines(buf_id, from_line + 1, to_line, buf_cache.delay.text_change)
+    end,
+
+    -- Called when buffer content is changed outside of current session
+    on_reload = function() pcall(MiniHipatterns.update, buf_id) end,
+
+    -- Called when buffer is unloaded from memory (`:h nvim_buf_detach_event`),
+    -- **including** `:edit` command
+    on_detach = function() MiniHipatterns.disable(buf_id) end,
+  })
+
+  -- Add buffer autocommands
+  local augroup = vim.api.nvim_create_augroup('MiniHipatternsBuffer' .. buf_id, { clear = true })
+  H.cache[buf_id].augroup = augroup
+
+  local update_buf = vim.schedule_wrap(function()
+    if not H.is_buf_enabled(buf_id) then return end
+
+    H.update_cache(buf_id, config)
+
+    local delay_ms = H.cache[buf_id].delay.text_change
+    H.process_lines(buf_id, 1, vim.api.nvim_buf_line_count(buf_id), delay_ms)
+  end)
+
+  vim.api.nvim_create_autocmd(
+    { 'BufWinEnter', 'FileType' },
+    { group = augroup, buffer = buf_id, callback = update_buf, desc = 'Update highlighting for whole buffer' }
+  )
+
+  vim.api.nvim_create_autocmd(
+    'WinScrolled',
+    { group = augroup, buffer = buf_id, callback = H.update_view, desc = 'Update highlighting in view' }
+  )
+
+  -- Add highlighting to whole buffer
+  H.process_lines(buf_id, 1, vim.api.nvim_buf_line_count(buf_id), 0)
+end
+
+--- Disable highlighting in buffer
+---
+--- Note that if |MiniHipatterns.setup()| was called, the effect is present
+--- until the next auto-enabling event. To permanently disable highlighting in
+--- buffer, set `vim.b.minihipatterns_disable` to `true`
+---
+---@param buf_id __hipatterns_buf_id
+MiniHipatterns.disable = function(buf_id)
+  buf_id = H.validate_buf_id(buf_id)
+
+  local buf_cache = H.cache[buf_id]
+  if buf_cache == nil then return end
+  H.cache[buf_id] = nil
+
+  vim.api.nvim_del_augroup_by_id(buf_cache.augroup)
+  for _, ns in pairs(H.ns_id) do
+    H.clear_namespace(buf_id, ns, 0, -1)
+  end
+end
+
+--- Toggle highlighting in buffer
+---
+--- Call |MiniHipatterns.disable()| if enabled; |MiniHipatterns.enable()| otherwise.
+---
+---@param buf_id __hipatterns_buf_id
+---@param config table|nil Forwarded to |MiniHipatterns.enable()|.
+MiniHipatterns.toggle = function(buf_id, config)
+  buf_id = H.validate_buf_id(buf_id)
+  config = H.validate_config_arg(config)
+
+  if H.is_buf_enabled(buf_id) then
+    MiniHipatterns.disable(buf_id)
+  else
+    MiniHipatterns.enable(buf_id, config)
+  end
+end
+
+--- Update highlighting in range
+---
+--- Works only in buffer with enabled highlighting. Effect takes immediately
+--- without delay.
+---
+---@param buf_id __hipatterns_buf_id
+---@param from_line number|nil Start line from which to update (1-indexed).
+---@param to_line number|nil End line from which to update (1-indexed, inclusive).
+MiniHipatterns.update = function(buf_id, from_line, to_line)
+  buf_id = H.validate_buf_id(buf_id)
+
+  if not H.is_buf_enabled(buf_id) then H.error(string.format('Buffer %d is not enabled.', buf_id)) end
+
+  from_line = from_line or 1
+  if type(from_line) ~= 'number' then H.error('`from_line` should be a number.') end
+  to_line = to_line or vim.api.nvim_buf_line_count(buf_id)
+  if type(to_line) ~= 'number' then H.error('`to_line` should be a number.') end
+
+  -- Process lines immediately without delay
+  H.process_lines(buf_id, from_line, to_line, 0)
+end
+
+--- Get an array of enabled buffers
+---
+---@return table Array of buffer identifiers with enabled highlighting.
+MiniHipatterns.get_enabled_buffers = function()
+  local res = {}
+  for buf_id, _ in pairs(H.cache) do
+    if vim.api.nvim_buf_is_valid(buf_id) then
+      table.insert(res, buf_id)
+    else
+      -- Clean up if buffer is invalid and for some reason is still enabled
+      H.cache[buf_id] = nil
+    end
+  end
+
+  -- Ensure consistent order
+  table.sort(res)
+
+  return res
+end
+
+--- Get buffer matches
+---
+---@param buf_id number|nil Buffer identifier for which to return matches.
+---   Default: `nil` for current buffer.
+---@param highlighters table|nil Array of highlighter identifiers (as in
+---   `highlighters` field of |MiniHipatterns.config|) for which to return matches.
+---   Default: all available highlighters (ordered by string representation).
+---
+---@return table Array of buffer matches which are tables with following fields:
+---   - <bufnr> `(number)` - buffer identifier of a match.
+---   - <highlighter> `(any)` - highlighter identifier which produced the match.
+---   - <lnum> `(number)` - line number of the match start (starts with 1).
+---   - <col> `(number)` - column number of the match start (starts with 1).
+---   - <end_lnum> `(number|nil)` - line number of the match end (starts with 1).
+---   - <end_col> `(number|nil)` - column number next to the match end
+---     (implements end-exclusive region; starts with 1).
+---   - <hl_group> `(string|nil)` - name of match's highlight group.
+---
+---   Matches are ordered first by supplied `highlighters`, then by line and
+---   column of match start.
+MiniHipatterns.get_matches = function(buf_id, highlighters)
+  buf_id = (buf_id == nil or buf_id == 0) and vim.api.nvim_get_current_buf() or buf_id
+  if not (type(buf_id) == 'number' and vim.api.nvim_buf_is_valid(buf_id)) then
+    H.error('`buf_id` is not valid buffer identifier.')
+  end
+
+  local all_highlighters = H.get_all_highlighters()
+  highlighters = highlighters or all_highlighters
+  if not vim.tbl_islist(highlighters) then H.error('`highlighters` should be an array.') end
+  highlighters = vim.tbl_filter(function(x) return vim.tbl_contains(all_highlighters, x) end, highlighters)
+
+  local position_compare = function(a, b) return a[2] < b[2] or (a[2] == b[2] and a[3] < b[3]) end
+  local res = {}
+  for _, hi_id in ipairs(highlighters) do
+    local extmarks = H.get_extmarks(buf_id, H.ns_id[hi_id], 0, -1, { details = true })
+    table.sort(extmarks, position_compare)
+
+    for _, extmark in ipairs(extmarks) do
+      local end_lnum, end_col = extmark[4].end_row, extmark[4].end_col
+      end_lnum = type(end_lnum) == 'number' and (end_lnum + 1) or end_lnum
+      end_col = type(end_col) == 'number' and (end_col + 1) or end_col
+      --stylua: ignore
+      local entry = {
+        bufnr = buf_id,        highlighter = hi_id,
+        lnum = extmark[2] + 1, col = extmark[3] + 1,
+        end_lnum = end_lnum,   end_col = end_col,
+        hl_group = extmark[4].hl_group,
+      }
+      table.insert(res, entry)
+    end
+  end
+  return res
+end
+
+--- Generate builtin highlighters
+---
+--- This is a table with function elements. Call to actually get highlighter.
+MiniHipatterns.gen_highlighter = {}
+
+--- Highlight hex color string
+---
+--- This will match color hex string in format `#rrggbb` and highlight it
+--- according to `opts.style` displaying matched color.
+---
+--- Highlight group is computed using |MiniHipatterns.compute_hex_color_group()|,
+--- so all its usage notes apply here.
+---
+---@param opts table|nil Options. Possible fields:
+---   - <style> `(string)` - one of:
+---       - `'full'` -  highlight background of whole hex string with it. Default.
+---       - `'#'` - highlight background of only `#`.
+---       - `'line'` - highlight underline with that color.
+---       - `'inline'` - highlight text of <inline_text>.
+---         Note: requires Neovim>=0.10.
+---   - <priority> `(number)` - priority of highlighting. Default: 200.
+---   - <filter> `(function)` - callable object used to filter buffers in which
+---     highlighting will take place. It should take buffer identifier as input
+---     and return `false` or `nil` to not highlight inside this buffer.
+---   - <inline_text> `(string)` - string to be placed and highlighted with color
+---     to the right of match in case <style> is "inline". Default: "█".
+---
+---@return table Highlighter table ready to be used as part of `config.highlighters`.
+---   Both `pattern` and `group` are callable.
+---
+---@usage >
+---   local hipatterns = require('mini.hipatterns')
+---   hipatterns.setup({
+---     highlighters = {
+---       hex_color = hipatterns.gen_highlighter.hex_color(),
+---     }
+---   })
+MiniHipatterns.gen_highlighter.hex_color = function(opts)
+  local default_opts = { style = 'full', priority = 200, filter = H.always_true, inline_text = '█' }
+  opts = vim.tbl_deep_extend('force', default_opts, opts or {})
+
+  local style = opts.style
+  if style == 'inline' and vim.fn.has('nvim-0.10') == 0 then
+    H.error('Style "inline" in `gen_highlighter.hex_color()` requires Neovim>=0.10.')
+  end
+
+  local pattern = style == '#' and '()#()%x%x%x%x%x%x%f[%X]' or '#%x%x%x%x%x%x%f[%X]'
+  local hl_style = ({ full = 'bg', ['#'] = 'bg', line = 'line', inline = 'fg' })[style] or 'bg'
+
+  local extmark_opts = { priority = opts.priority }
+  if opts.style == 'inline' then
+    local priority, inline_text = opts.priority, opts.inline_text
+    ---@diagnostic disable:cast-local-type
+    extmark_opts = function(_, _, data)
+      local virt_text = { { inline_text, data.hl_group } }
+      return { virt_text = virt_text, virt_text_pos = 'inline', priority = priority, right_gravity = false }
+    end
+  end
+
+  return {
+    pattern = H.wrap_pattern_with_filter(pattern, opts.filter),
+    group = function(_, _, data) return MiniHipatterns.compute_hex_color_group(data.full_match, hl_style) end,
+    extmark_opts = extmark_opts,
+  }
+end
+
+--- Compute and create group to highlight hex color string
+---
+--- Notes:
+--- - This works properly only with enabled |termguicolors|.
+---
+--- - To increase performance, it caches highlight groups per `hex_color`. If
+---   you want to try different style in current Neovim session, execute
+---   |:colorscheme| command to clear cache. Needs a call to |MiniHipatterns.setup()|.
+---
+---@param hex_color string Hex color string in format `#rrggbb`.
+---@param style string One of:
+---   - `'bg'` - highlight background with `hex_color` and foreground with black or
+---     white (whichever is more visible). Default.
+---   - `'fg'` - highlight foreground with `hex_color`.
+---   - `'line'` - highlight underline with `hex_color`.
+---
+---@return string Name of created highlight group appropriate to show `hex_color`.
+MiniHipatterns.compute_hex_color_group = function(hex_color, style)
+  local hex = hex_color:lower():sub(2)
+  local group_name = 'MiniHipatterns' .. hex
+
+  -- Use manually tracked table instead of `vim.fn.hlexists()` because the
+  -- latter still returns true for cleared highlights
+  if H.hex_color_groups[group_name] then return group_name end
+
+  -- Define highlight group if it is not already defined
+  if style == 'bg' then
+    -- Compute opposite color based on Oklab lightness (for better contrast)
+    local opposite = H.compute_opposite_color(hex)
+    vim.api.nvim_set_hl(0, group_name, { fg = opposite, bg = hex_color })
+  end
+
+  if style == 'fg' then vim.api.nvim_set_hl(0, group_name, { fg = hex_color }) end
+
+  if style == 'line' then vim.api.nvim_set_hl(0, group_name, { sp = hex_color, underline = true }) end
+
+  -- Keep track of created groups to properly react on `:hi clear`
+  H.hex_color_groups[group_name] = true
+
+  return group_name
+end
+
+-- Helper data ================================================================
+-- Module default config
+H.default_config = vim.deepcopy(MiniHipatterns.config)
+
+-- Timers
+H.timer_debounce = vim.loop.new_timer()
+H.timer_view = vim.loop.new_timer()
+
+-- Namespaces per highlighter name
+H.ns_id = {}
+
+-- Cache of queued changes used for debounced highlighting
+H.change_queue = {}
+
+-- Cache per enabled buffer
+H.cache = {}
+
+-- Data about created highlight groups for hex colors
+H.hex_color_groups = {}
+
+-- Helper functionality =======================================================
+-- Settings -------------------------------------------------------------------
+H.setup_config = function(config)
+  -- General idea: if some table elements are not present in user-supplied
+  -- `config`, take them from default config
+  vim.validate({ config = { config, 'table', true } })
+  config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
+
+  vim.validate({
+    highlighters = { config.highlighters, 'table' },
+    delay = { config.delay, 'table' },
+  })
+
+  vim.validate({
+    ['delay.text_change'] = { config.delay.text_change, 'number' },
+    ['delay.scroll'] = { config.delay.scroll, 'number' },
+  })
+
+  return config
+end
+
+H.apply_config = function(config) MiniHipatterns.config = config end
+
+H.create_autocommands = function()
+  local augroup = vim.api.nvim_create_augroup('MiniHipatterns', {})
+
+  local au = function(event, pattern, callback, desc)
+    vim.api.nvim_create_autocmd(event, { group = augroup, pattern = pattern, callback = callback, desc = desc })
+  end
+
+  au('BufEnter', '*', H.auto_enable, 'Enable highlighting')
+  au('ColorScheme', '*', H.on_colorscheme, 'Reload all enabled pattern highlighters')
+end
+
+--stylua: ignore
+H.create_default_hl = function()
+  vim.api.nvim_set_hl(0, 'MiniHipatternsFixme', { default = true, link = 'DiagnosticError' })
+  vim.api.nvim_set_hl(0, 'MiniHipatternsHack',  { default = true, link = 'DiagnosticWarn' })
+  vim.api.nvim_set_hl(0, 'MiniHipatternsTodo',  { default = true, link = 'DiagnosticInfo' })
+  vim.api.nvim_set_hl(0, 'MiniHipatternsNote',  { default = true, link = 'DiagnosticHint' })
+end
+
+H.is_disabled = function(buf_id)
+  local buf_disable = H.get_buf_var(buf_id, 'minihipatterns_disable')
+  return vim.g.minihipatterns_disable == true or buf_disable == true
+end
+
+H.get_config = function(config, buf_id)
+  local buf_config = H.get_buf_var(buf_id, 'minihipatterns_config') or {}
+  return vim.tbl_deep_extend('force', MiniHipatterns.config, buf_config, config or {})
+end
+
+H.get_buf_var = function(buf_id, name)
+  if not vim.api.nvim_buf_is_valid(buf_id) then return nil end
+  return vim.b[buf_id or 0][name]
+end
+
+-- Autocommands ---------------------------------------------------------------
+H.auto_enable = vim.schedule_wrap(function(data)
+  if H.is_buf_enabled(data.buf) then return end
+
+  -- Autoenable only in valid normal buffers. This function is scheduled so as
+  -- to have the relevant `buftype`.
+  if vim.api.nvim_buf_is_valid(data.buf) and vim.bo[data.buf].buftype == '' then MiniHipatterns.enable(data.buf) end
+end)
+
+H.update_view = vim.schedule_wrap(function(data)
+  -- Update view only in enabled buffers
+  local buf_cache = H.cache[data.buf]
+  if buf_cache == nil then return end
+
+  -- NOTE: due to scheduling (which is necessary for better performance),
+  -- current buffer can be not the target one. But as there is no proper (easy
+  -- and/or fast) way to get the view of certain buffer (except the current)
+  -- accept this approach. The main problem of current buffer having not
+  -- enabled highlighting is solved during processing buffer highlighters.
+
+  -- Debounce without aggregating redraws (only last view should be updated)
+  H.timer_view:stop()
+  H.timer_view:start(buf_cache.delay.scroll, 0, H.process_view)
+end)
+
+H.on_colorscheme = function()
+  -- Reset created highlight groups for hex colors, as they are probably
+  -- cleared after `:hi clear`
+  H.hex_color_groups = {}
+
+  -- Reload all currently enabled buffers
+  for buf_id, _ in pairs(H.cache) do
+    MiniHipatterns.disable(buf_id)
+    MiniHipatterns.enable(buf_id)
+  end
+end
+
+-- Validators -----------------------------------------------------------------
+H.validate_buf_id = function(x)
+  if x == nil or x == 0 then return vim.api.nvim_get_current_buf() end
+
+  if not (type(x) == 'number' and vim.api.nvim_buf_is_valid(x)) then
+    H.error('`buf_id` should be `nil` or valid buffer id.')
+  end
+
+  return x
+end
+
+H.validate_config_arg = function(x)
+  if x == nil or type(x) == 'table' then return x or {} end
+  H.error('`config` should be `nil` or table.')
+end
+
+H.validate_string = function(x, name)
+  if type(x) == 'string' then return x end
+  H.error(string.format('`%s` should be string.'))
+end
+
+-- Enabling -------------------------------------------------------------------
+H.is_buf_enabled = function(buf_id) return H.cache[buf_id] ~= nil end
+
+H.update_cache = function(buf_id, config)
+  local buf_cache = H.cache[buf_id] or {}
+  local buf_config = H.get_config(config, buf_id)
+  buf_cache.highlighters = H.normalize_highlighters(buf_config.highlighters)
+  buf_cache.delay = buf_config.delay
+
+  H.cache[buf_id] = buf_cache
+end
+
+H.normalize_highlighters = function(highlighters)
+  local res = {}
+  for hi_name, hi in pairs(highlighters) do
+    -- Allow pattern to be string, callable, or array of those. Convert all
+    -- valid cases into array of callables.
+    local pattern = type(hi.pattern) == 'string' and function() return hi.pattern end or hi.pattern
+    if vim.is_callable(pattern) then pattern = { pattern } end
+    local is_pattern_ok = vim.tbl_islist(pattern)
+    if is_pattern_ok then
+      for i, pat in ipairs(pattern) do
+        pattern[i] = type(pat) == 'string' and function() return pat end or pat
+        is_pattern_ok = is_pattern_ok and vim.is_callable(pattern[i])
+      end
+    end
+
+    local group = type(hi.group) == 'string' and function() return hi.group end or hi.group
+
+    -- TODO: Remove after Neovim 0.11 is released
+    local has_raw_priority = type(hi.priority) == 'number'
+    if has_raw_priority then
+      local msg = '`priority` field of highlighter is soft deprecated.'
+        .. ' Use `extmark_opts = { priority = <value> }`.'
+        .. ' This works for now but will be removed after the next stable release.'
+      vim.notify_once(msg, vim.log.levels.WARN)
+    end
+    local extmark_opts = hi.extmark_opts or { priority = has_raw_priority and hi.priority or 200 }
+    if type(extmark_opts) == 'table' then
+      local t = extmark_opts
+      ---@diagnostic disable:cast-local-type
+      extmark_opts = function(_, _, data)
+        local opts = vim.deepcopy(t)
+        opts.hl_group = opts.hl_group or data.hl_group
+        opts.end_row = opts.end_row or (data.line - 1)
+        opts.end_col = opts.end_col or data.to_col
+        return opts
+      end
+    end
+
+    if is_pattern_ok and vim.is_callable(group) and vim.is_callable(extmark_opts) then
+      res[hi_name] = { pattern = pattern, group = group, extmark_opts = extmark_opts }
+      H.ns_id[hi_name] = vim.api.nvim_create_namespace('MiniHipatterns-' .. hi_name)
+    end
+  end
+
+  return res
+end
+
+H.get_all_highlighters = function()
+  local hi_arr = vim.tbl_map(function(x) return { x, tostring(x) } end, vim.tbl_keys(H.ns_id))
+  table.sort(hi_arr, function(a, b) return a[2] < b[2] end)
+  return vim.tbl_map(function(x) return x[1] end, hi_arr)
+end
+
+-- Processing -----------------------------------------------------------------
+H.process_lines = vim.schedule_wrap(function(buf_id, from_line, to_line, delay_ms)
+  -- Make sure that that at least one line is processed (important to react
+  -- after deleting line with extmark non-trivial `extmark_opts`)
+  table.insert(H.change_queue, { buf_id, math.min(from_line, to_line), math.max(from_line, to_line) })
+
+  -- Debounce
+  H.timer_debounce:stop()
+  H.timer_debounce:start(delay_ms, 0, H.process_change_queue)
+end)
+
+H.process_view = vim.schedule_wrap(function()
+  table.insert(H.change_queue, { vim.api.nvim_get_current_buf(), vim.fn.line('w0'), vim.fn.line('w$') })
+
+  -- Process immediately assuming debouncing should be already done
+  H.process_change_queue()
+end)
+
+H.process_change_queue = vim.schedule_wrap(function()
+  local queue = H.normalize_change_queue()
+
+  for buf_id, lines_to_process in pairs(queue) do
+    H.process_buffer_changes(buf_id, lines_to_process)
+  end
+
+  H.change_queue = {}
+end)
+
+H.normalize_change_queue = function()
+  local res = {}
+  for _, change in ipairs(H.change_queue) do
+    -- `change` is { buf_id, from_line, to_line }; lines are already 1-indexed
+    local buf_id = change[1]
+
+    local buf_lines_to_process = res[buf_id] or {}
+    for i = change[2], change[3] do
+      buf_lines_to_process[i] = true
+    end
+
+    res[buf_id] = buf_lines_to_process
+  end
+
+  return res
+end
+
+H.process_buffer_changes = vim.schedule_wrap(function(buf_id, lines_to_process)
+  -- Return early if buffer is not proper.
+  -- Also check if buffer is enabled here mostly for better resilience. It
+  -- might be actually needed due to various `schedule_wrap`s leading to change
+  -- queue entry with not target (and improper) buffer.
+  local buf_cache = H.cache[buf_id]
+  if not vim.api.nvim_buf_is_valid(buf_id) or H.is_disabled(buf_id) or buf_cache == nil then return end
+
+  -- Optimizations are done assuming small-ish number of highlighters and
+  -- large-ish number of lines to process
+
+  -- Process highlighters
+  for hi_name, hi in pairs(buf_cache.highlighters) do
+    -- Remove current highlights
+    local ns = H.ns_id[hi_name]
+    for l_num, _ in pairs(lines_to_process) do
+      H.clear_namespace(buf_id, ns, l_num - 1, l_num)
+    end
+
+    -- Add new highlights
+    for _, pattern in ipairs(hi.pattern) do
+      H.apply_highlighter_pattern(pattern(buf_id), hi, buf_id, ns, lines_to_process)
+    end
+  end
+end)
+
+H.apply_highlighter_pattern = vim.schedule_wrap(function(pattern, hi, buf_id, ns, lines_to_process)
+  if type(pattern) ~= 'string' then return end
+  local group, extmark_opts = hi.group, hi.extmark_opts
+  local pattern_has_line_start = pattern:sub(1, 1) == '^'
+
+  -- Apply per proper line
+  for l_num, _ in pairs(lines_to_process) do
+    local line = H.get_line(buf_id, l_num)
+    local from, to, sub_from, sub_to = line:find(pattern)
+
+    while from and (from <= to) do
+      -- Compute full pattern match
+      local full_match = line:sub(from, to)
+
+      -- Compute (possibly inferred) submatch
+      sub_from, sub_to = sub_from or from, sub_to or (to + 1)
+      -- - Make last column end-inclusive
+      sub_to = sub_to - 1
+      local match = line:sub(sub_from, sub_to)
+
+      -- Set extmark based on submatch
+      local data = { full_match = full_match, line = l_num, from_col = sub_from, to_col = sub_to }
+      local hl_group = group(buf_id, match, data)
+      if hl_group ~= nil then
+        data.hl_group = hl_group
+        H.set_extmark(buf_id, ns, l_num - 1, sub_from - 1, extmark_opts(buf_id, match, data))
+      end
+
+      -- Overcome an issue that `string.find()` doesn't recognize `^` when
+      -- `init` is more than 1
+      if pattern_has_line_start then break end
+
+      from, to, sub_from, sub_to = line:find(pattern, to + 1)
+    end
+  end
+end)
+
+-- Built-in highlighters ------------------------------------------------------
+H.wrap_pattern_with_filter = function(pattern, filter)
+  return function(...)
+    if not filter(...) then return nil end
+    return pattern
+  end
+end
+
+H.compute_opposite_color = function(hex)
+  local dec = tonumber(hex, 16)
+  local b = H.correct_channel(math.fmod(dec, 256) / 255)
+  local g = H.correct_channel(math.fmod((dec - b) / 256, 256) / 255)
+  local r = H.correct_channel(math.floor(dec / 65536) / 255)
+
+  local l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b
+  local m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b
+  local s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b
+
+  local l_, m_, s_ = H.cuberoot(l), H.cuberoot(m), H.cuberoot(s)
+
+  local L = H.correct_lightness(0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_)
+
+  return L < 0.5 and '#ffffff' or '#000000'
+end
+
+-- Function for RGB channel correction. Assumes input in [0; 1] range
+-- https://bottosson.github.io/posts/colorwrong/#what-can-we-do%3F
+H.correct_channel = function(x) return 0.04045 < x and math.pow((x + 0.055) / 1.055, 2.4) or (x / 12.92) end
+
+-- Function for lightness correction
+-- https://bottosson.github.io/posts/colorpicker/#intermission---a-new-lightness-estimate-for-oklab
+H.correct_lightness = function(x)
+  local k1, k2 = 0.206, 0.03
+  local k3 = (1 + k1) / (1 + k2)
+
+  return 0.5 * (k3 * x - k1 + math.sqrt((k3 * x - k1) ^ 2 + 4 * k2 * k3 * x))
+end
+
+-- Utilities ------------------------------------------------------------------
+H.error = function(msg) error(string.format('(mini.hipatterns) %s', msg), 0) end
+
+H.get_line =
+  function(buf_id, line_num) return vim.api.nvim_buf_get_lines(buf_id, line_num - 1, line_num, false)[1] or '' end
+
+H.set_extmark = function(...) pcall(vim.api.nvim_buf_set_extmark, ...) end
+
+H.get_extmarks = function(...)
+  local ok, res = pcall(vim.api.nvim_buf_get_extmarks, ...)
+  if not ok then return {} end
+  return res
+end
+
+H.clear_namespace = function(...) pcall(vim.api.nvim_buf_clear_namespace, ...) end
+
+H.always_true = function() return true end
+
+H.cuberoot = function(x) return math.pow(x, 0.333333) end
+
+return MiniHipatterns
diff --git a/.config/nvim/lua/mini/indentscope.lua b/.config/nvim/lua/mini/indentscope.lua
new file mode 100644
index 0000000..5ef9cf1
--- /dev/null
+++ b/.config/nvim/lua/mini/indentscope.lua
@@ -0,0 +1,1104 @@
+--- *mini.indentscope* Visualize and work with indent scope
+--- *MiniIndentscope*
+---
+--- MIT License Copyright (c) 2022 Evgeni Chasnovski
+---
+--- ==============================================================================
+---
+--- Indent scope (or just "scope") is a maximum set of consecutive lines which
+--- contains certain reference line (cursor line by default) and every member
+--- has indent not less than certain reference indent ("indent at cursor" by
+--- default: minimum between cursor column and indent of cursor line).
+---
+--- Features:
+--- - Visualize scope with animated vertical line. It is very fast and done
+---   automatically in a non-blocking way (other operations can be performed,
+---   like moving cursor). You can customize debounce delay and animation rule.
+---
+--- - Customization of scope computation options can be done on global level
+---   (in |MiniIndentscope.config|), for a certain buffer (using
+---   `vim.b.miniindentscope_config` buffer variable), or within a call (using
+---   `opts` variable in |MiniIndentscope.get_scope|).
+---
+--- - Customizable notion of a border: which adjacent lines with strictly lower
+---   indent are recognized as such. This is useful for a certain filetypes
+---   (for example, Python or plain text).
+---
+--- - Customizable way of line to be considered "border first". This is useful
+---   if you want to place cursor on function header and get scope of its body.
+---
+--- - There are textobjects and motions to operate on scope. Support |count|
+---   and dot-repeat (in operator pending mode).
+---
+--- # Setup~
+---
+--- This module needs a setup with `require('mini.indentscope').setup({})`
+--- (replace `{}` with your `config` table). It will create global Lua table
+--- `MiniIndentscope` which you can use for scripting or manually (with `:lua
+--- MiniIndentscope.*`).
+---
+--- See |MiniIndentscope.config| for available config settings.
+---
+--- You can override runtime config settings locally to buffer inside
+--- `vim.b.miniindentscope_config` which should have same structure as
+--- `MiniIndentscope.config`. See |mini.nvim-buffer-local-config| for more details.
+---
+--- # Comparisons~
+---
+--- - 'lukas-reineke/indent-blankline.nvim':
+---     - Its main functionality is about showing static guides of indent levels.
+---     - Implementation of 'mini.indentscope' is similar to
+---       'indent-blankline.nvim' (using |extmarks| on first column to be shown
+---       even on blank lines). They can be used simultaneously, but it will
+---       lead to one of the visualizations being on top (hiding) of another.
+---
+--- # Highlight groups~
+---
+--- * `MiniIndentscopeSymbol` - symbol showing on every line of scope if its
+---   indent is multiple of 'shiftwidth'.
+--- * `MiniIndentscopeSymbolOff` - symbol showing on every line of scope if its
+---   indent is not multiple of 'shiftwidth'.
+---   Default: links to `MiniIndentscopeSymbol`.
+---
+--- To change any highlight group, modify it directly with |:highlight|.
+---
+--- # Disabling~
+---
+--- To disable autodrawing, set `vim.g.miniindentscope_disable` (globally) or
+--- `vim.b.miniindentscope_disable` (for a buffer) to `true`. Considering high
+--- number of different scenarios and customization intentions, writing exact
+--- rules for disabling module's functionality is left to user. See
+--- |mini.nvim-disabling-recipes| for common recipes.
+
+--- Drawing of scope indicator
+---
+--- Draw of scope indicator is done as iterative animation. It has the
+--- following design:
+--- - Draw indicator on origin line (where cursor is at) immediately. Indicator
+---   is visualized as `MiniIndentscope.config.symbol` placed to the right of
+---   scope's border indent. This creates a line from top to bottom scope edges.
+--- - Draw upward and downward concurrently per one line. Progression by one
+---   line in both direction is considered to be one step of animation.
+--- - Before each step wait certain amount of time, which is decided by
+---   "animation function". It takes next and total step numbers (both are one
+---   or bigger) and returns number of milliseconds to wait before drawing next
+---   step. Comparing to a more popular "easing functions" in animation (input:
+---   duration since animation start; output: percent of animation done), it is
+---   a discrete inverse version of its derivative. Such interface proved to be
+---   more appropriate for kind of task at hand.
+---
+--- Special cases~
+---
+--- - When scope to be drawn intersects (same indent, ranges overlap) currently
+---   visible one (at process or finished drawing), drawing is done immediately
+---   without animation. With most common example being typing new text, this
+---   feels more natural.
+--- - Scope for the whole buffer is not drawn as it is isually redundant.
+---   Technically, it can be thought as drawn at column 0 (because border
+---   indent is -1) which is not visible.
+---@tag MiniIndentscope-drawing
+
+-- Module definition ==========================================================
+local MiniIndentscope = {}
+local H = {}
+
+--- Module setup
+---
+---@param config table|nil Module config table. See |MiniIndentscope.config|.
+---
+---@usage `require('mini.indentscope').setup({})` (replace `{}` with your `config` table)
+MiniIndentscope.setup = function(config)
+  -- Export module
+  _G.MiniIndentscope = MiniIndentscope
+
+  -- Setup config
+  config = H.setup_config(config)
+
+  -- Apply config
+  H.apply_config(config)
+
+  -- Define behavior
+  H.create_autocommands()
+
+  -- Create default highlighting
+  H.create_default_hl()
+end
+
+--- Module config
+---
+--- Default values:
+---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
+---@text # Options ~
+---
+--- - Options can be supplied globally (from this `config`), locally to buffer
+---   (via `options` field of `vim.b.miniindentscope_config` buffer variable),
+---   or locally to call (as argument to |MiniIndentscope.get_scope()|).
+---
+--- - Option `border` controls which line(s) with smaller indent to categorize
+---   as border. This matters for textobjects and motions.
+---   It also controls how empty lines are treated: they are included in scope
+---   only if followed by a border. Another way of looking at it is that indent
+---   of blank line is computed based on value of `border` option.
+---   Here is an illustration of how `border` works in presence of empty lines:
+--- >
+---                              |both|bottom|top|none|
+---   1|function foo()           | 0  |  0   | 0 | 0  |
+---   2|                         | 4  |  0   | 4 | 0  |
+---   3|    print('Hello world') | 4  |  4   | 4 | 4  |
+---   4|                         | 4  |  4   | 2 | 2  |
+---   5|  end                    | 2  |  2   | 2 | 2  |
+--- <
+---   Numbers inside a table are indent values of a line computed with certain
+---   value of `border`. So, for example, a scope with reference line 3 and
+---   right-most column has body range depending on value of `border` option:
+---     - `border` is "both":   range is 2-4, border is 1 and 5 with indent 2.
+---     - `border` is "top":    range is 2-3, border is 1 with indent 0.
+---     - `border` is "bottom": range is 3-4, border is 5 with indent 0.
+---     - `border` is "none":   range is 3-3, border is empty with indent `nil`.
+---
+--- - Option `indent_at_cursor` controls if cursor position should affect
+---   computation of scope. If `true`, reference indent is a minimum of
+---   reference line's indent and cursor column. In main example, here how
+---   scope's body range differs depending on cursor column and `indent_at_cursor`
+---   value (assuming cursor is on line 3 and it is whole buffer):
+--- >
+---     Column\Option true|false
+---        1 and 2    2-5 | 2-4
+---      3 and more   2-4 | 2-4
+--- <
+--- - Option `try_as_border` controls how to act when input line can be
+---   recognized as a border of some neighbor indent scope. In main example,
+---   when input line is 1 and can be recognized as border for inner scope,
+---   value `try_as_border = true` means that inner scope will be returned.
+---   Similar, for input line 5 inner scope will be returned if it is
+---   recognized as border.
+MiniIndentscope.config = {
+  -- Draw options
+  draw = {
+    -- Delay (in ms) between event and start of drawing scope indicator
+    delay = 100,
+
+    -- Animation rule for scope's first drawing. A function which, given
+    -- next and total step numbers, returns wait time (in ms). See
+    -- |MiniIndentscope.gen_animation| for builtin options. To disable
+    -- animation, use `require('mini.indentscope').gen_animation.none()`.
+    --minidoc_replace_start animation = --<function: implements constant 20ms between steps>,
+    animation = function(s, n) return 20 end,
+    --minidoc_replace_end
+
+    -- Symbol priority. Increase to display on top of more symbols.
+    priority = 2,
+  },
+
+  -- Module mappings. Use `''` (empty string) to disable one.
+  mappings = {
+    -- Textobjects
+    object_scope = 'ii',
+    object_scope_with_border = 'ai',
+
+    -- Motions (jump to respective border line; if not present - body line)
+    goto_top = '[i',
+    goto_bottom = ']i',
+  },
+
+  -- Options which control scope computation
+  options = {
+    -- Type of scope's border: which line(s) with smaller indent to
+    -- categorize as border. Can be one of: 'both', 'top', 'bottom', 'none'.
+    border = 'both',
+
+    -- Whether to use cursor column when computing reference indent.
+    -- Useful to see incremental scopes with horizontal cursor movements.
+    indent_at_cursor = true,
+
+    -- Whether to first check input line to be a border of adjacent scope.
+    -- Use it if you want to place cursor on function header to get scope of
+    -- its body.
+    try_as_border = false,
+  },
+
+  -- Which character to use for drawing scope indicator
+  symbol = '╎',
+}
+--minidoc_afterlines_end
+
+-- Module functionality =======================================================
+--- Compute indent scope
+---
+--- Indent scope (or just "scope") is a maximum set of consecutive lines which
+--- contains certain reference line (cursor line by default) and every member
+--- has indent not less than certain reference indent ("indent at column" by
+--- default). Here "indent at column" means minimum between input column value
+--- and indent of reference line. When using cursor column, this allows for a
+--- useful interactive view of nested indent scopes by making horizontal
+--- movements within line.
+---
+--- Options controlling actual computation is taken from these places in order:
+--- - Argument `opts`. Use it to ensure independence from other sources.
+--- - Buffer local variable `vim.b.miniindentscope_config` (`options` field).
+---   Useful to define local behavior (for example, for a certain filetype).
+--- - Global options from |MiniIndentscope.config|.
+---
+--- Algorithm overview~
+---
+--- - Compute reference "indent at column". Reference line is an input `line`
+---   which might be modified to one of its neighbors if `try_as_border` option
+---   is `true`: if it can be viewed as border of some neighbor scope, it will.
+--- - Process upwards and downwards from reference line to search for line with
+---   indent strictly less than reference one. This is like casting rays up and
+---   down from reference line and reference indent until meeting "a wall"
+---   (character to the right of indent or buffer edge). Latest line before
+---   meeting is a respective end of scope body. It always exists because
+---   reference line is a such one.
+--- - Based on top and bottom lines with strictly lower indent, construct
+---   scopes's border. The way it is computed is decided based on `border`
+---   option (see |MiniIndentscope.config| for more information).
+--- - Compute border indent as maximum indent of border lines (or reference
+---   indent minus one in case of no border). This is used during drawing
+---   visual indicator.
+---
+--- Indent computation~
+---
+--- For every line indent is intended to be computed unambiguously:
+--- - For "normal" lines indent is an output of |indent()|.
+--- - Indent is `-1` for imaginary lines 0 and past last line.
+--- - For blank and empty lines indent is computed based on previous
+---   (|prevnonblank()|) and next (|nextnonblank()|) non-blank lines. The way
+---   it is computed is decided based on `border` in order to not include blank
+---   lines at edge of scope's body if there is no border there. See
+---   |MiniIndentscope.config| for a details example.
+---
+---@param line number|nil Input line number (starts from 1). Can be modified to a
+---   neighbor if `try_as_border` is `true`. Default: cursor line.
+---@param col number|nil Column number (starts from 1). Default: if
+---   `indent_at_cursor` option is `true` - cursor column from `curswant` of
+---   |getcurpos()| (allows for more natural behavior on empty lines);
+---   `math.huge` otherwise in order to not incorporate cursor in computation.
+---@param opts table|nil Options to override global or buffer local ones (see
+---   |MiniIndentscope.config|).
+---
+---@return table Table with scope information:
+---   - <body> - table with <top> (top line of scope, inclusive), <bottom>
+---     (bottom line of scope, inclusive), and <indent> (minimum indent within
+---     scope) keys. Line numbers start at 1.
+---   - <border> - table with <top> (line of top border, might be `nil`),
+---     <bottom> (line of bottom border, might be `nil`), and <indent> (indent
+---     of border) keys. Line numbers start at 1.
+---   - <buf_id> - identifier of current buffer.
+---   - <reference> - table with <line> (reference line), <column> (reference
+---     column), and <indent> ("indent at column") keys.
+MiniIndentscope.get_scope = function(line, col, opts)
+  opts = H.get_config({ options = opts }).options
+
+  -- Compute default `line` and\or `col`
+  if not (line and col) then
+    local curpos = vim.fn.getcurpos()
+
+    line = line or curpos[2]
+    line = opts.try_as_border and H.border_correctors[opts.border](line, opts) or line
+
+    -- Use `curpos[5]` (`curswant`, see `:h getcurpos()`) to account for blank
+    -- and empty lines.
+    col = col or (opts.indent_at_cursor and curpos[5] or math.huge)
+  end
+
+  -- Compute "indent at column"
+  local line_indent = H.get_line_indent(line, opts)
+  local indent = math.min(col, line_indent)
+
+  -- Make early return
+  local body = { indent = indent }
+  if indent <= 0 then
+    body.top, body.bottom, body.indent = 1, vim.fn.line('$'), line_indent
+  else
+    local up_min_indent, down_min_indent
+    body.top, up_min_indent = H.cast_ray(line, indent, 'up', opts)
+    body.bottom, down_min_indent = H.cast_ray(line, indent, 'down', opts)
+    body.indent = math.min(line_indent, up_min_indent, down_min_indent)
+  end
+
+  return {
+    body = body,
+    border = H.border_from_body[opts.border](body, opts),
+    buf_id = vim.api.nvim_get_current_buf(),
+    reference = { line = line, column = col, indent = indent },
+  }
+end
+
+--- Draw scope manually
+---
+--- Scope is visualized as a vertical line within scope's body range at column
+--- equal to border indent plus one (or body indent if border is absent).
+--- Numbering starts from one.
+---
+---@param scope table|nil Scope. Default: output of |MiniIndentscope.get_scope|
+---   with default arguments.
+---@param opts table|nil Options. Currently supported:
+---    - <animation_fun> - animation function for drawing. See
+---      |MiniIndentscope-drawing| and |MiniIndentscope.gen_animation|.
+---    - <priority> - priority number for visualization. See `priority` option
+---      for |nvim_buf_set_extmark()|.
+MiniIndentscope.draw = function(scope, opts)
+  scope = scope or MiniIndentscope.get_scope()
+  local config = H.get_config()
+  local draw_opts =
+    vim.tbl_deep_extend('force', { animation_fun = config.draw.animation, priority = config.draw.priority }, opts or {})
+
+  H.undraw_scope()
+
+  H.current.scope = scope
+  H.draw_scope(scope, draw_opts)
+end
+
+--- Undraw currently visible scope manually
+MiniIndentscope.undraw = function() H.undraw_scope() end
+
+--- Generate builtin animation function
+---
+--- This is a builtin source to generate animation function for usage in
+--- `MiniIndentscope.config.draw.animation`. Most of them are variations of
+--- common easing functions, which provide certain type of progression for
+--- revealing scope visual indicator.
+---
+--- Each field corresponds to one family of progression which can be customized
+--- further by supplying appropriate arguments.
+---
+--- Examples ~
+--- - Don't use animation: `MiniIndentscope.gen_animation.none()`
+--- - Use quadratic "out" easing with total duration of 1000 ms:
+---   `gen_animation.quadratic({ easing = 'out', duration = 1000, unit = 'total' })`
+---
+---@seealso |MiniIndentscope-drawing| for more information about how drawing is done.
+MiniIndentscope.gen_animation = {}
+
+---@alias __indentscope_animation_opts table|nil Options that control progression. Possible keys:
+---   - <easing> `(string)` - a subtype of progression. One of "in"
+---     (accelerating from zero speed), "out" (decelerating to zero speed),
+---     "in-out" (default; accelerating halfway, decelerating after).
+---   - <duration> `(number)` - duration (in ms) of a unit. Default: 20.
+---   - <unit> `(string)` - which unit's duration `opts.duration` controls. One
+---     of "step" (default; ensures average duration of step to be `opts.duration`)
+---     or "total" (ensures fixed total duration regardless of scope's range).
+---@alias __indentscope_animation_return function Animation function (see |MiniIndentscope-drawing|).
+
+--- Generate no animation
+---
+--- Show indicator immediately. Same as animation function always returning 0.
+MiniIndentscope.gen_animation.none = function()
+  return function() return 0 end
+end
+
+--- Generate linear progression
+---
+---@param opts __indentscope_animation_opts
+---
+---@return __indentscope_animation_return
+MiniIndentscope.gen_animation.linear =
+  function(opts) return H.animation_arithmetic_powers(0, H.normalize_animation_opts(opts)) end
+
+--- Generate quadratic progression
+---
+---@param opts __indentscope_animation_opts
+---
+---@return __indentscope_animation_return
+MiniIndentscope.gen_animation.quadratic =
+  function(opts) return H.animation_arithmetic_powers(1, H.normalize_animation_opts(opts)) end
+
+--- Generate cubic progression
+---
+---@param opts __indentscope_animation_opts
+---
+---@return __indentscope_animation_return
+MiniIndentscope.gen_animation.cubic =
+  function(opts) return H.animation_arithmetic_powers(2, H.normalize_animation_opts(opts)) end
+
+--- Generate quartic progression
+---
+---@param opts __indentscope_animation_opts
+---
+---@return __indentscope_animation_return
+MiniIndentscope.gen_animation.quartic =
+  function(opts) return H.animation_arithmetic_powers(3, H.normalize_animation_opts(opts)) end
+
+--- Generate exponential progression
+---
+---@param opts __indentscope_animation_opts
+---
+---@return __indentscope_animation_return
+MiniIndentscope.gen_animation.exponential =
+  function(opts) return H.animation_geometrical_powers(H.normalize_animation_opts(opts)) end
+
+--- Move cursor within scope
+---
+--- Cursor is placed on a first non-blank character of target line.
+---
+---@param side string One of "top" or "bottom".
+---@param use_border boolean|nil Whether to move to border or within scope's body.
+---   If particular border is absent, body is used.
+---@param scope table|nil Scope to use. Default: output of |MiniIndentscope.get_scope()|.
+MiniIndentscope.move_cursor = function(side, use_border, scope)
+  scope = scope or MiniIndentscope.get_scope()
+
+  -- This defaults to body's side if it is not present in border
+  local target_line = use_border and scope.border[side] or scope.body[side]
+  target_line = math.min(math.max(target_line, 1), vim.fn.line('$'))
+
+  vim.api.nvim_win_set_cursor(0, { target_line, 0 })
+  -- Move to first non-blank character to allow chaining scopes
+  vim.cmd('normal! ^')
+end
+
+--- Function for motion mappings
+---
+--- Move to a certain side of border. Respects |count| and dot-repeat (in
+--- operator-pending mode). Doesn't move cursor for scope that is not shown
+--- (drawing indent less that zero).
+---
+---@param side string One of "top" or "bottom".
+---@param add_to_jumplist boolean|nil Whether to add movement to jump list. It is
+---   `true` only for Normal mode mappings.
+MiniIndentscope.operator = function(side, add_to_jumplist)
+  local scope = MiniIndentscope.get_scope()
+
+  -- Don't support scope that can't be shown
+  if H.scope_get_draw_indent(scope) < 0 then return end
+
+  -- Add movement to jump list. Needs remembering `count1` before that because
+  -- it seems to reset it to 1.
+  local count = vim.v.count1
+  if add_to_jumplist then vim.cmd('normal! m`') end
+
+  -- Make sequence of jumps
+  for _ = 1, count do
+    MiniIndentscope.move_cursor(side, true, scope)
+    -- Use `try_as_border = false` to enable chaining
+    scope = MiniIndentscope.get_scope(nil, nil, { try_as_border = false })
+
+    -- Don't support scope that can't be shown
+    if H.scope_get_draw_indent(scope) < 0 then return end
+  end
+end
+
+--- Function for textobject mappings
+---
+--- Respects |count| and dot-repeat (in operator-pending mode). Doesn't work
+--- for scope that is not shown (drawing indent less that zero).
+---
+---@param use_border boolean|nil Whether to include border in textobject. When
+---   `true` and `try_as_border` option is `false`, allows "chaining" calls for
+---   incremental selection.
+MiniIndentscope.textobject = function(use_border)
+  local scope = MiniIndentscope.get_scope()
+
+  -- Don't support scope that can't be shown
+  if H.scope_get_draw_indent(scope) < 0 then return end
+
+  -- Allow chaining only if using border
+  local count = use_border and vim.v.count1 or 1
+
+  -- Make sequence of incremental selections
+  for _ = 1, count do
+    -- Try finish cursor on border
+    local start, finish = 'top', 'bottom'
+    if use_border and scope.border.bottom == nil then
+      start, finish = 'bottom', 'top'
+    end
+
+    H.exit_visual_mode()
+    MiniIndentscope.move_cursor(start, use_border, scope)
+    vim.cmd('normal! V')
+    MiniIndentscope.move_cursor(finish, use_border, scope)
+
+    -- Use `try_as_border = false` to enable chaining
+    scope = MiniIndentscope.get_scope(nil, nil, { try_as_border = false })
+
+    -- Don't support scope that can't be shown
+    if H.scope_get_draw_indent(scope) < 0 then return end
+  end
+end
+
+-- Helper data ================================================================
+-- Module default config
+H.default_config = vim.deepcopy(MiniIndentscope.config)
+
+-- Namespace for drawing vertical line
+H.ns_id = vim.api.nvim_create_namespace('MiniIndentscope')
+
+-- Timer for doing animation
+H.timer = vim.loop.new_timer()
+
+-- Table with current relevalnt data:
+-- - `event_id` - counter for events.
+-- - `scope` - latest drawn scope.
+-- - `draw_status` - status of current drawing.
+H.current = { event_id = 0, scope = {}, draw_status = 'none' }
+
+-- Functions to compute indent in ambiguous cases
+H.indent_funs = {
+  ['min'] = function(top_indent, bottom_indent) return math.min(top_indent, bottom_indent) end,
+  ['max'] = function(top_indent, bottom_indent) return math.max(top_indent, bottom_indent) end,
+  ['top'] = function(top_indent, bottom_indent) return top_indent end,
+  ['bottom'] = function(top_indent, bottom_indent) return bottom_indent end,
+}
+
+-- Functions to compute indent of blank line to satisfy `config.options.border`
+H.blank_indent_funs = {
+  ['none'] = H.indent_funs.min,
+  ['top'] = H.indent_funs.bottom,
+  ['bottom'] = H.indent_funs.top,
+  ['both'] = H.indent_funs.max,
+}
+
+-- Functions to compute border from body
+H.border_from_body = {
+  ['none'] = function(body, opts) return {} end,
+  ['top'] = function(body, opts) return { top = body.top - 1, indent = H.get_line_indent(body.top - 1, opts) } end,
+  ['bottom'] = function(body, opts) return { bottom = body.bottom + 1, indent = H.get_line_indent(body.bottom + 1, opts) } end,
+  ['both'] = function(body, opts)
+    return {
+      top = body.top - 1,
+      bottom = body.bottom + 1,
+      indent = math.max(H.get_line_indent(body.top - 1, opts), H.get_line_indent(body.bottom + 1, opts)),
+    }
+  end,
+}
+
+-- Functions to correct line in case it is a border
+H.border_correctors = {
+  ['none'] = function(line, opts) return line end,
+  ['top'] = function(line, opts)
+    local cur_indent, next_indent = H.get_line_indent(line, opts), H.get_line_indent(line + 1, opts)
+    return (cur_indent < next_indent) and (line + 1) or line
+  end,
+  ['bottom'] = function(line, opts)
+    local prev_indent, cur_indent = H.get_line_indent(line - 1, opts), H.get_line_indent(line, opts)
+    return (cur_indent < prev_indent) and (line - 1) or line
+  end,
+  ['both'] = function(line, opts)
+    local prev_indent, cur_indent, next_indent =
+      H.get_line_indent(line - 1, opts), H.get_line_indent(line, opts), H.get_line_indent(line + 1, opts)
+
+    if prev_indent <= cur_indent and next_indent <= cur_indent then return line end
+
+    -- If prev and next indents are equal and bigger than current, prefer next
+    if prev_indent <= next_indent then return line + 1 end
+
+    return line - 1
+  end,
+}
+
+-- Helper functionality =======================================================
+-- Settings -------------------------------------------------------------------
+H.setup_config = function(config)
+  -- General idea: if some table elements are not present in user-supplied
+  -- `config`, take them from default config
+  vim.validate({ config = { config, 'table', true } })
+  config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
+
+  -- Validate per nesting level to produce correct error message
+  vim.validate({
+    draw = { config.draw, 'table' },
+    mappings = { config.mappings, 'table' },
+    options = { config.options, 'table' },
+    symbol = { config.symbol, 'string' },
+  })
+
+  vim.validate({
+    ['draw.delay'] = { config.draw.delay, 'number' },
+    ['draw.animation'] = { config.draw.animation, 'function' },
+    ['draw.priority'] = { config.draw.priority, 'number' },
+
+    ['mappings.object_scope'] = { config.mappings.object_scope, 'string' },
+    ['mappings.object_scope_with_border'] = { config.mappings.object_scope_with_border, 'string' },
+    ['mappings.goto_top'] = { config.mappings.goto_top, 'string' },
+    ['mappings.goto_bottom'] = { config.mappings.goto_bottom, 'string' },
+
+    ['options.border'] = { config.options.border, 'string' },
+    ['options.indent_at_cursor'] = { config.options.indent_at_cursor, 'boolean' },
+    ['options.try_as_border'] = { config.options.try_as_border, 'boolean' },
+  })
+  return config
+end
+
+H.apply_config = function(config)
+  MiniIndentscope.config = config
+  local maps = config.mappings
+
+  --stylua: ignore start
+  H.map('n', maps.goto_top, [[<Cmd>lua MiniIndentscope.operator('top', true)<CR>]], { desc = 'Go to indent scope top' })
+  H.map('n', maps.goto_bottom, [[<Cmd>lua MiniIndentscope.operator('bottom', true)<CR>]], { desc = 'Go to indent scope bottom' })
+
+  H.map('x', maps.goto_top, [[<Cmd>lua MiniIndentscope.operator('top')<CR>]], { desc = 'Go to indent scope top' })
+  H.map('x', maps.goto_bottom, [[<Cmd>lua MiniIndentscope.operator('bottom')<CR>]], { desc = 'Go to indent scope bottom' })
+  H.map('x', maps.object_scope, '<Cmd>lua MiniIndentscope.textobject(false)<CR>', { desc = 'Object scope' })
+  H.map('x', maps.object_scope_with_border, '<Cmd>lua MiniIndentscope.textobject(true)<CR>', { desc = 'Object scope with border' })
+
+  -- Use `<Cmd>...<CR>` to have proper dot-repeat
+  -- See https://github.com/neovim/neovim/issues/23406
+  -- TODO: use local functions if/when that issue is resolved
+  H.map('o', maps.goto_top, [[<Cmd>lua MiniIndentscope.operator('top')<CR>]], { desc = 'Go to indent scope top' })
+  H.map('o', maps.goto_bottom, [[<Cmd>lua MiniIndentscope.operator('bottom')<CR>]], { desc = 'Go to indent scope bottom' })
+  H.map('o', maps.object_scope, '<Cmd>lua MiniIndentscope.textobject(false)<CR>', { desc = 'Object scope' })
+  H.map('o', maps.object_scope_with_border, '<Cmd>lua MiniIndentscope.textobject(true)<CR>', { desc = 'Object scope with border' })
+  --stylua: ignore start
+end
+
+H.create_autocommands = function()
+  local augroup = vim.api.nvim_create_augroup('MiniIndentscope', {})
+
+  local au = function(event, pattern, callback, desc)
+    vim.api.nvim_create_autocmd(event, { group = augroup, pattern = pattern, callback = callback, desc = desc })
+  end
+
+  au(
+    { 'CursorMoved', 'CursorMovedI', 'ModeChanged' },
+    '*',
+    function() H.auto_draw({ lazy = true }) end,
+    'Auto draw indentscope lazily'
+  )
+  au(
+    { 'TextChanged', 'TextChangedI', 'TextChangedP', 'WinScrolled' },
+    '*',
+    function() H.auto_draw() end,
+    'Auto draw indentscope'
+  )
+end
+
+--stylua: ignore
+H.create_default_hl = function()
+  vim.api.nvim_set_hl(0, 'MiniIndentscopeSymbol',    { default = true, link = 'Delimiter' })
+  vim.api.nvim_set_hl(0, 'MiniIndentscopeSymbolOff', { default = true, link = 'MiniIndentscopeSymbol' })
+end
+
+H.is_disabled = function() return vim.g.miniindentscope_disable == true or vim.b.miniindentscope_disable == true end
+
+H.get_config = function(config)
+  return vim.tbl_deep_extend('force', MiniIndentscope.config, vim.b.miniindentscope_config or {}, config or {})
+end
+
+-- Autocommands ---------------------------------------------------------------
+H.auto_draw = function(opts)
+  if H.is_disabled() then
+    H.undraw_scope()
+    return
+  end
+
+  opts = opts or {}
+  local scope = MiniIndentscope.get_scope()
+
+  -- Make early return if nothing has to be done. Doing this before updating
+  -- event id allows to not interrupt ongoing animation.
+  if opts.lazy and H.current.draw_status ~= 'none' and H.scope_is_equal(scope, H.current.scope) then return end
+
+  -- Account for current event
+  local local_event_id = H.current.event_id + 1
+  H.current.event_id = local_event_id
+
+  -- Compute drawing options for current event
+  local draw_opts = H.make_autodraw_opts(scope)
+
+  -- Allow delay
+  if draw_opts.delay > 0 then H.undraw_scope(draw_opts) end
+
+  -- Use `defer_fn()` even if `delay` is 0 to draw indicator only after all
+  -- events are processed (stops flickering)
+  vim.defer_fn(function()
+    if H.current.event_id ~= local_event_id then return end
+
+    H.undraw_scope(draw_opts)
+
+    H.current.scope = scope
+    H.draw_scope(scope, draw_opts)
+  end, draw_opts.delay)
+end
+
+-- Scope ----------------------------------------------------------------------
+-- Line indent:
+-- - Equals output of `vim.fn.indent()` in case of non-blank line.
+-- - Depends on `MiniIndentscope.config.options.border` in such way so as to
+--   ignore blank lines before line not recognized as border.
+H.get_line_indent = function(line, opts)
+  local prev_nonblank = vim.fn.prevnonblank(line)
+  local res = vim.fn.indent(prev_nonblank)
+
+  -- Compute indent of blank line depending on `options.border` values
+  if line ~= prev_nonblank then
+    local next_indent = vim.fn.indent(vim.fn.nextnonblank(line))
+    local blank_rule = H.blank_indent_funs[opts.border]
+    res = blank_rule(res, next_indent)
+  end
+
+  return res
+end
+
+H.cast_ray = function(line, indent, direction, opts)
+  local final_line, increment = 1, -1
+  if direction == 'down' then
+    final_line, increment = vim.fn.line('$'), 1
+  end
+
+  local min_indent = math.huge
+  for l = line, final_line, increment do
+    local new_indent = H.get_line_indent(l + increment, opts)
+    if new_indent < indent then return l, min_indent end
+    if new_indent < min_indent then min_indent = new_indent end
+  end
+
+  return final_line, min_indent
+end
+
+H.scope_get_draw_indent = function(scope) return scope.border.indent or (scope.body.indent - 1) end
+
+H.scope_is_equal = function(scope_1, scope_2)
+  if type(scope_1) ~= 'table' or type(scope_2) ~= 'table' then return false end
+
+  return scope_1.buf_id == scope_2.buf_id
+    and H.scope_get_draw_indent(scope_1) == H.scope_get_draw_indent(scope_2)
+    and scope_1.body.top == scope_2.body.top
+    and scope_1.body.bottom == scope_2.body.bottom
+end
+
+H.scope_has_intersect = function(scope_1, scope_2)
+  if type(scope_1) ~= 'table' or type(scope_2) ~= 'table' then return false end
+  if (scope_1.buf_id ~= scope_2.buf_id) or (H.scope_get_draw_indent(scope_1) ~= H.scope_get_draw_indent(scope_2)) then
+    return false
+  end
+
+  local body_1, body_2 = scope_1.body, scope_2.body
+  return (body_2.top <= body_1.top and body_1.top <= body_2.bottom)
+    or (body_1.top <= body_2.top and body_2.top <= body_1.bottom)
+end
+
+-- Indicator ------------------------------------------------------------------
+--- Compute indicator of scope to be displayed
+---
+--- Indicator is visual representation of scope in current window view using
+--- extmarks. Currently only needed because Neovim can't correctly process
+--- horizontal window scroll (Neovim issue:
+--- https://github.com/neovim/neovim/issues/14050)
+---
+---@return table|nil Table with indicator info or empty one in case indicator
+---   shouldn't be drawn.
+---@private
+H.indicator_compute = function(scope)
+  scope = scope or H.current.scope
+  local indent = H.scope_get_draw_indent(scope)
+
+  -- Don't draw indicator that should be outside of screen. This condition is
+  -- (perpusfully) "responsible" for not drawing indicator spanning whole file.
+  if indent < 0 then return {} end
+
+  -- Text indentation should depend on current window view because it will use
+  -- `virt_text_win_col` attribute of extmark options (the only way to reliably
+  -- put it anywhere on screen; important to show properly on empty lines).
+  local col = indent - vim.fn.winsaveview().leftcol
+  if col < 0 then return {} end
+
+  -- Pick highlight group based on if indent is a multiple of shiftwidth.
+  -- This adds visual indicator of whether indent is "correct".
+  local hl_group = (indent % vim.fn.shiftwidth() == 0) and 'MiniIndentscopeSymbol' or 'MiniIndentscopeSymbolOff'
+  local virt_text = { { H.get_config().symbol, hl_group } }
+
+  return {
+    buf_id = vim.api.nvim_get_current_buf(),
+    virt_text = virt_text,
+    virt_text_win_col = col,
+    top = scope.body.top,
+    bottom = scope.body.bottom,
+  }
+end
+
+-- Drawing --------------------------------------------------------------------
+H.draw_scope = function(scope, opts)
+  scope = scope or {}
+  opts = opts or {}
+
+  local indicator = H.indicator_compute(scope)
+
+  -- Don't draw anything if nothing to be displayed
+  if indicator.virt_text == nil or #indicator.virt_text == 0 then
+    H.current.draw_status = 'finished'
+    return
+  end
+
+  -- Make drawing function
+  local draw_fun = H.make_draw_function(indicator, opts)
+
+  -- Perform drawing
+  H.current.draw_status = 'drawing'
+  H.draw_indicator_animation(indicator, draw_fun, opts.animation_fun)
+end
+
+H.draw_indicator_animation = function(indicator, draw_fun, animation_fun)
+  -- Draw from origin (cursor line but within indicator range)
+  local top, bottom = indicator.top, indicator.bottom
+  local origin = math.min(math.max(vim.fn.line('.'), top), bottom)
+
+  local step = 0
+  local n_steps = math.max(origin - top, bottom - origin)
+  local wait_time = 0
+
+  local draw_step
+  draw_step = vim.schedule_wrap(function()
+    -- Check for not drawing outside of interval is done inside `draw_fun`
+    local success = draw_fun(origin - step)
+    if step > 0 then success = success and draw_fun(origin + step) end
+
+    if not success or step == n_steps then
+      H.current.draw_status = step == n_steps and 'finished' or H.current.draw_status
+      H.timer:stop()
+      return
+    end
+
+    step = step + 1
+    wait_time = wait_time + animation_fun(step, n_steps)
+
+    -- Repeat value of `timer` seems to be rounded down to milliseconds. This
+    -- means that values less than 1 will lead to timer stop repeating. Instead
+    -- call next step function directly.
+    if wait_time < 1 then
+      H.timer:set_repeat(0)
+      -- Use `return` to make this proper "tail call"
+      return draw_step()
+    else
+      H.timer:set_repeat(wait_time)
+
+      -- Restart `wait_time` only if it is actually used. Do this accounting
+      -- actually set repeat time.
+      wait_time = wait_time - H.timer:get_repeat()
+
+      -- Usage of `again()` is needed to overcome the fact that it is called
+      -- inside callback and to restart initial timer. Mainly this is needed
+      -- only in case of transition from 'non-repeating' timer to 'repeating'
+      -- one in case of complex animation functions. See
+      -- https://docs.libuv.org/en/v1.x/timer.html#api
+      H.timer:again()
+    end
+  end)
+
+  -- Start non-repeating timer without callback execution. This shouldn't be
+  -- `timer:start(0, 0, draw_step)` because it will execute `draw_step` on the
+  -- next redraw (flickers on window scroll).
+  H.timer:start(10000000, 0, draw_step)
+
+  -- Draw step zero (at origin) immediately
+  draw_step()
+end
+
+H.undraw_scope = function(opts)
+  opts = opts or {}
+
+  -- Don't operate outside of current event if able to verify
+  if opts.event_id and opts.event_id ~= H.current.event_id then return end
+
+  pcall(vim.api.nvim_buf_clear_namespace, H.current.scope.buf_id or 0, H.ns_id, 0, -1)
+
+  H.current.draw_status = 'none'
+  H.current.scope = {}
+end
+
+H.make_autodraw_opts = function(scope)
+  local config = H.get_config()
+  local res = {
+    event_id = H.current.event_id,
+    type = 'animation',
+    delay = config.draw.delay,
+    animation_fun = config.draw.animation,
+    priority = config.draw.priority,
+  }
+
+  if H.current.draw_status == 'none' then return res end
+
+  -- Draw immediately scope which intersects (same indent, overlapping ranges)
+  -- currently drawn or finished. This is more natural when typing text.
+  if H.scope_has_intersect(scope, H.current.scope) then
+    res.type = 'immediate'
+    res.delay = 0
+    res.animation_fun = MiniIndentscope.gen_animation.none()
+    return res
+  end
+
+  return res
+end
+
+H.make_draw_function = function(indicator, opts)
+  local extmark_opts = {
+    hl_mode = 'combine',
+    priority = opts.priority,
+    right_gravity = false,
+    virt_text = indicator.virt_text,
+    virt_text_win_col = indicator.virt_text_win_col,
+    virt_text_pos = 'overlay',
+  }
+
+  local current_event_id = opts.event_id
+
+  return function(l)
+    -- Don't draw if outdated
+    if H.current.event_id ~= current_event_id and current_event_id ~= nil then return false end
+
+    -- Don't draw if disabled
+    if H.is_disabled() then return false end
+
+    -- Don't put extmark outside of indicator range
+    if not (indicator.top <= l and l <= indicator.bottom) then return true end
+
+    return pcall(vim.api.nvim_buf_set_extmark, indicator.buf_id, H.ns_id, l - 1, 0, extmark_opts)
+  end
+end
+
+-- Animations -----------------------------------------------------------------
+--- Imitate common power easing function
+---
+--- Every step is preceded by waiting time decreasing/increasing in power
+--- series fashion (`d` is "delta", ensures total duration time):
+--- - "in":  d*n^p; d*(n-1)^p; ... ; d*2^p;     d*1^p
+--- - "out": d*1^p; d*2^p;     ... ; d*(n-1)^p; d*n^p
+--- - "in-out": "in" until 0.5*n, "out" afterwards
+---
+--- This way it imitates `power + 1` common easing function because animation
+--- progression behaves as sum of `power` elements.
+---
+---@param power number Power of series.
+---@param opts table Options from `MiniIndentscope.gen_animation` entry.
+---@private
+H.animation_arithmetic_powers = function(power, opts)
+  -- Sum of first `n_steps` natural numbers raised to `power`
+  local arith_power_sum = ({
+    [0] = function(n_steps) return n_steps end,
+    [1] = function(n_steps) return n_steps * (n_steps + 1) / 2 end,
+    [2] = function(n_steps) return n_steps * (n_steps + 1) * (2 * n_steps + 1) / 6 end,
+    [3] = function(n_steps) return n_steps ^ 2 * (n_steps + 1) ^ 2 / 4 end,
+  })[power]
+
+  -- Function which computes common delta so that overall duration will have
+  -- desired value (based on supplied `opts`)
+  local duration_unit, duration_value = opts.unit, opts.duration
+  local make_delta = function(n_steps, is_in_out)
+    local total_time = duration_unit == 'total' and duration_value or (duration_value * n_steps)
+    local total_parts
+    if is_in_out then
+      -- Examples:
+      -- - n_steps=5: 3^d, 2^d, 1^d, 2^d, 3^d
+      -- - n_steps=6: 3^d, 2^d, 1^d, 1^d, 2^d, 3^d
+      total_parts = 2 * arith_power_sum(math.ceil(0.5 * n_steps)) - (n_steps % 2 == 1 and 1 or 0)
+    else
+      total_parts = arith_power_sum(n_steps)
+    end
+    return total_time / total_parts
+  end
+
+  return ({
+    ['in'] = function(s, n) return make_delta(n) * (n - s + 1) ^ power end,
+    ['out'] = function(s, n) return make_delta(n) * s ^ power end,
+    ['in-out'] = function(s, n)
+      local n_half = math.ceil(0.5 * n)
+      local s_halved
+      if n % 2 == 0 then
+        s_halved = s <= n_half and (n_half - s + 1) or (s - n_half)
+      else
+        s_halved = s < n_half and (n_half - s + 1) or (s - n_half + 1)
+      end
+      return make_delta(n, true) * s_halved ^ power
+    end,
+  })[opts.easing]
+end
+
+--- Imitate common exponential easing function
+---
+--- Every step is preceded by waiting time decreasing/increasing in geometric
+--- progression fashion (`d` is 'delta', ensures total duration time):
+--- - 'in':  (d-1)*d^(n-1); (d-1)*d^(n-2); ...; (d-1)*d^1;     (d-1)*d^0
+--- - 'out': (d-1)*d^0;     (d-1)*d^1;     ...; (d-1)*d^(n-2); (d-1)*d^(n-1)
+--- - 'in-out': 'in' until 0.5*n, 'out' afterwards
+---
+---@param opts table Options from `MiniIndentscope.gen_animation` entry.
+---@private
+H.animation_geometrical_powers = function(opts)
+  -- Function which computes common delta so that overall duration will have
+  -- desired value (based on supplied `opts`)
+  local duration_unit, duration_value = opts.unit, opts.duration
+  local make_delta = function(n_steps, is_in_out)
+    local total_time = duration_unit == 'step' and (duration_value * n_steps) or duration_value
+    -- Exact solution to avoid possible (bad) approximation
+    if n_steps == 1 then return total_time + 1 end
+    if is_in_out then
+      local n_half = math.ceil(0.5 * n_steps)
+      -- Example for n_steps=6:
+      -- Steps: (d-1)*d^2, (d-1)*d^1, (d-1)*d^0, (d-1)*d^0, (d-1)*d^1, (d-1)*d^2
+      -- Sum: 2 * (d - 1) * (d^0 + d^1 + d^2) = 2 * (d^3 - 1)
+      -- Solution: 2 * (d^3 - 1) = total_time =>
+      --   d = math.pow(0.5 * total_time + 1, 1 / 3)
+      --
+      -- Example for n_steps=5:
+      -- Steps: (d-1)*d^2, (d-1)*d^1, (d-1)*d^0, (d-1)*d^1, (d-1)*d^2
+      -- Sum: 2 * (d - 1) * (d^0 + d^1 + d^2) - (d - 1) = 2 * (d^3 - 1) - (d - 1)
+      -- Solution: 2 * (d^3 - 1) - (d - 1) = total_time =>
+      --   As there is no general explicit solution, use approximation =>
+      --   (Exact solution without `- (d-1)`):
+      --     d_0 = math.pow(0.5 * total_time + 1, 1 / 3);
+      --   (Correction by solving exactly withtou `- (d-1)` for
+      --   `total_time_corr = total_time + (d_0 - 1)`):
+      --     d_1 = math.pow(0.5 * total_time_corr + 1, 1 / 3)
+      if n_steps % 2 == 1 then total_time = total_time + math.pow(0.5 * total_time + 1, 1 / n_half) - 1 end
+      return math.pow(0.5 * total_time + 1, 1 / n_half)
+    end
+    return math.pow(total_time + 1, 1 / n_steps)
+  end
+
+  return ({
+    ['in'] = function(s, n)
+      local delta = make_delta(n)
+      return (delta - 1) * delta ^ (n - s)
+    end,
+    ['out'] = function(s, n)
+      local delta = make_delta(n)
+      return (delta - 1) * delta ^ (s - 1)
+    end,
+    ['in-out'] = function(s, n)
+      local n_half, delta = math.ceil(0.5 * n), make_delta(n, true)
+      local s_halved
+      if n % 2 == 0 then
+        s_halved = s <= n_half and (n_half - s) or (s - n_half - 1)
+      else
+        s_halved = s < n_half and (n_half - s) or (s - n_half)
+      end
+      return (delta - 1) * delta ^ s_halved
+    end,
+  })[opts.easing]
+end
+
+H.normalize_animation_opts = function(x)
+  x = vim.tbl_deep_extend('force', { easing = 'in-out', duration = 20, unit = 'step' }, x or {})
+
+  if not vim.tbl_contains({ 'in', 'out', 'in-out' }, x.easing) then
+    H.error([[In `gen_animation` option `easing` should be one of 'in', 'out', or 'in-out'.]])
+  end
+
+  if type(x.duration) ~= 'number' or x.duration < 0 then
+    H.error([[In `gen_animation` option `duration` should be a positive number.]])
+  end
+
+  if not vim.tbl_contains({ 'total', 'step' }, x.unit) then
+    H.error([[In `gen_animation` option `unit` should be one of 'step' or 'total'.]])
+  end
+
+  return x
+end
+
+-- Utilities ------------------------------------------------------------------
+H.error = function(msg) error(('(mini.indentscope) %s'):format(msg)) end
+
+H.map = function(mode, lhs, rhs, opts)
+  if lhs == '' then return end
+  opts = vim.tbl_deep_extend('force', { silent = true }, opts or {})
+  vim.keymap.set(mode, lhs, rhs, opts)
+end
+
+H.exit_visual_mode = function()
+  local ctrl_v = vim.api.nvim_replace_termcodes('<C-v>', true, true, true)
+  local cur_mode = vim.fn.mode()
+  if cur_mode == 'v' or cur_mode == 'V' or cur_mode == ctrl_v then vim.cmd('normal! ' .. cur_mode) end
+end
+
+return MiniIndentscope
diff --git a/.config/nvim/lua/mini/pairs.lua b/.config/nvim/lua/mini/pairs.lua
new file mode 100644
index 0000000..5529353
--- /dev/null
+++ b/.config/nvim/lua/mini/pairs.lua
@@ -0,0 +1,614 @@
+--- *mini.pairs* Autopairs
+--- *MiniPairs*
+---
+--- MIT License Copyright (c) 2021 Evgeni Chasnovski
+---
+--- ==============================================================================
+---
+--- Features:
+--- - Functionality to work with 'paired' characters conditional on cursor's
+---   neighborhood (two characters to its left and right).
+---
+--- - Usage should be through making appropriate mappings using |MiniPairs.map|
+---   or in |MiniPairs.setup| (for global mapping), |MiniPairs.map_buf| (for
+---   buffer mapping).
+---
+--- - Pairs get automatically registered to be recognized by `<BS>` and `<CR>`.
+---
+--- What it doesn't do:
+--- - It doesn't support multiple characters as "open" and "close" symbols. Use
+---   snippets for that.
+---
+--- - It doesn't support dependency on filetype. Use |i_CTRL-V| to insert
+---   single symbol or `autocmd` command or 'after/ftplugin' approach to:
+---     - `lua MiniPairs.map_buf(0, 'i', <*>, <pair_info>)` : make new mapping
+---       for '<*>' in current buffer.
+---     - `lua MiniPairs.unmap_buf(0, 'i', <*>, <pair>)`: unmap key `<*>` while
+---       unregistering `<pair>` pair in current buffer. Note: this reverts
+---       mapping done by |MiniPairs.map_buf|. If mapping was done with
+---       |MiniPairs.map|, unmap for buffer in usual Neovim manner:
+---       `inoremap <buffer> <*> <*>` (this maps `<*>` key to do the same it
+---       does by default).
+---     - Disable module for buffer (see 'Disabling' section).
+---
+--- # Setup~
+---
+--- This module needs a setup with `require('mini.pairs').setup({})`
+--- (replace `{}` with your `config` table). It will create global Lua table
+--- `MiniPairs` which you can use for scripting or manually (with
+--- `:lua MiniPairs.*`).
+---
+--- See |MiniPairs.config| for `config` structure and default values.
+---
+--- This module doesn't have runtime options, so using `vim.b.minipairs_config`
+--- will have no effect here.
+---
+--- # Example mappings~
+---
+--- - Register quotes inside `config` of |MiniPairs.setup|: >
+---   mappings = {
+---     ['"'] = { register = { cr = true } },
+---     ["'"] = { register = { cr = true } },
+---   }
+--- <
+--- - Insert `<>` pair if `<` is typed at line start, don't register for `<CR>`: >
+---   lua MiniPairs.map('i', '<', { action = 'open', pair = '<>', neigh_pattern = '\r.', register = { cr = false } })
+---   lua MiniPairs.map('i', '>', { action = 'close', pair = '<>', register = { cr = false } })
+--- <
+--- - Create symmetrical `$$` pair only in Tex files: >
+---   au FileType tex lua MiniPairs.map_buf(0, 'i', '$', {action = 'closeopen', pair = '$$'})
+--- <
+--- # Notes~
+---
+--- - Make sure to make proper mapping of `<CR>` in order to support completion
+---   plugin of your choice:
+---     - For |MiniCompletion| see 'Helpful key mappings' section.
+---     - For current implementation of "hrsh7th/nvim-cmp" there is no need to
+---       make custom mapping. You can use default setup, which will confirm
+---       completion selection if popup is visible and expand pair otherwise.
+--- - Having mapping in terminal mode can conflict with:
+---     - Autopairing capabilities of interpretators (`ipython`, `radian`).
+---     - Vim mode of terminal itself.
+---
+--- # Disabling~
+---
+--- To disable, set `vim.g.minipairs_disable` (globally) or `vim.b.minipairs_disable`
+--- (for a buffer) to `true`. Considering high number of different scenarios
+--- and customization intentions, writing exact rules for disabling module's
+--- functionality is left to user. See |mini.nvim-disabling-recipes| for common
+--- recipes.
+
+---@alias __pairs_neigh_pattern string|nil Pattern for two neighborhood characters.
+---   Character "\r" indicates line start, "\n" - line end.
+---@alias __pairs_pair string String with two characters representing pair.
+---@alias __pairs_unregistered_pair string Pair which should be unregistered from both
+---   `<BS>` and `<CR>`. Should be explicitly supplied to avoid confusion.
+---   Supply `''` to not unregister pair.
+
+-- Module definition ==========================================================
+local MiniPairs = {}
+local H = {}
+
+--- Module setup
+---
+---@param config table|nil Module config table. See |MiniPairs.config|.
+---
+---@usage `require('mini.completion').setup({})` (replace `{}` with your `config` table)
+MiniPairs.setup = function(config)
+  -- Export module
+  _G.MiniPairs = MiniPairs
+
+  -- Setup config
+  config = H.setup_config(config)
+
+  -- Apply config
+  H.apply_config(config)
+
+  -- Define behavior
+  H.create_autocommands()
+end
+
+--- Module config
+---
+--- Default values:
+---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
+MiniPairs.config = {
+  -- In which modes mappings from this `config` should be created
+  modes = { insert = true, command = false, terminal = false },
+
+  -- Global mappings. Each right hand side should be a pair information, a
+  -- table with at least these fields (see more in |MiniPairs.map|):
+  -- - <action> - one of "open", "close", "closeopen".
+  -- - <pair> - two character string for pair to be used.
+  -- By default pair is not inserted after `\`, quotes are not recognized by
+  -- `<CR>`, `'` does not insert pair after a letter.
+  -- Only parts of tables can be tweaked (others will use these defaults).
+  -- Supply `false` instead of table to not map particular key.
+  mappings = {
+    ['('] = { action = 'open', pair = '()', neigh_pattern = '[^\\].' },
+    ['['] = { action = 'open', pair = '[]', neigh_pattern = '[^\\].' },
+    ['{'] = { action = 'open', pair = '{}', neigh_pattern = '[^\\].' },
+
+    [')'] = { action = 'close', pair = '()', neigh_pattern = '[^\\].' },
+    [']'] = { action = 'close', pair = '[]', neigh_pattern = '[^\\].' },
+    ['}'] = { action = 'close', pair = '{}', neigh_pattern = '[^\\].' },
+
+    ['"'] = { action = 'closeopen', pair = '""', neigh_pattern = '[^\\].', register = { cr = false } },
+    ["'"] = { action = 'closeopen', pair = "''", neigh_pattern = '[^%a\\].', register = { cr = false } },
+    ['`'] = { action = 'closeopen', pair = '``', neigh_pattern = '[^\\].', register = { cr = false } },
+  },
+}
+--minidoc_afterlines_end
+
+-- Module functionality =======================================================
+--- Make global mapping
+---
+--- This is a wrapper for |nvim_set_keymap()| but instead of right hand side of
+--- mapping (as string) it expects table with pair information:
+--- - `action` - one of "open" (for |MiniPairs.open|), "close" (for
+---   |MiniPairs.close|), or "closeopen" (for |MiniPairs.closeopen|).
+--- - `pair` - two character string to be used as argument for action function.
+--- - `neigh_pattern` - optional 'two character' neighborhood pattern to be
+---   used as argument for action function. Default: '..' (no restriction from
+---   neighborhood).
+--- - `register` - optional table with information about whether this pair
+---   should be recognized by `<BS>` (in |MiniPairs.bs|) and/or `<CR>` (in
+---   |MiniPairs.cr|). Should have boolean elements `bs` and `cr` which are
+---   both `true` by default (if not overridden explicitly).
+---
+--- Using this function instead of |nvim_set_keymap()| allows automatic
+--- registration of pairs which will be recognized by `<BS>` and `<CR>`.
+--- For Neovim>=0.7 it also infers mapping description from `pair_info`.
+---
+---@param mode string `mode` for |nvim_set_keymap()|.
+---@param lhs string `lhs` for |nvim_set_keymap()|.
+---@param pair_info table Table with pair information.
+---@param opts table|nil Optional table `opts` for |nvim_set_keymap()|. Elements
+---   `expr` and `noremap` won't be recognized (`true` by default).
+MiniPairs.map = function(mode, lhs, pair_info, opts)
+  pair_info = H.validate_pair_info(pair_info)
+  opts = vim.tbl_deep_extend('force', opts or {}, { expr = true, noremap = true })
+  opts.desc = H.infer_mapping_description(pair_info)
+
+  vim.api.nvim_set_keymap(mode, lhs, H.pair_info_to_map_rhs(pair_info), opts)
+  H.register_pair(pair_info, mode, 'all')
+
+  -- Ensure that `<BS>` and `<CR>` are mapped for input mode
+  H.ensure_cr_bs(mode)
+end
+
+--- Make buffer mapping
+---
+--- This is a wrapper for |nvim_buf_set_keymap()| but instead of string right
+--- hand side of mapping it expects table with pair information similar to one
+--- in |MiniPairs.map|.
+---
+--- Using this function instead of |nvim_buf_set_keymap()| allows automatic
+--- registration of pairs which will be recognized by `<BS>` and `<CR>`.
+--- For Neovim>=0.7 it also infers mapping description from `pair_info`.
+---
+---@param buffer number `buffer` for |nvim_buf_set_keymap()|.
+---@param mode string `mode` for |nvim_buf_set_keymap()|.
+---@param lhs string `lhs` for |nvim_buf_set_keymap()|.
+---@param pair_info table Table with pair information.
+---@param opts table|nil Optional table `opts` for |nvim_buf_set_keymap()|.
+---   Elements `expr` and `noremap` won't be recognized (`true` by default).
+MiniPairs.map_buf = function(buffer, mode, lhs, pair_info, opts)
+  pair_info = H.validate_pair_info(pair_info)
+  opts = vim.tbl_deep_extend('force', opts or {}, { expr = true, noremap = true })
+  opts.desc = H.infer_mapping_description(pair_info)
+
+  vim.api.nvim_buf_set_keymap(buffer, mode, lhs, H.pair_info_to_map_rhs(pair_info), opts)
+  H.register_pair(pair_info, mode, buffer == 0 and vim.api.nvim_get_current_buf() or buffer)
+
+  -- Ensure that `<BS>` and `<CR>` are mapped for input mode
+  H.ensure_cr_bs(mode)
+end
+
+--- Remove global mapping
+---
+--- A wrapper for |nvim_del_keymap()| which registers supplied `pair`.
+---
+---@param mode string `mode` for |nvim_del_keymap()|.
+---@param lhs string `lhs` for |nvim_del_keymap()|.
+---@param pair __pairs_unregistered_pair
+MiniPairs.unmap = function(mode, lhs, pair)
+  -- `pair` should be supplied explicitly
+  vim.validate({ pair = { pair, 'string' } })
+
+  -- Use `pcall` to allow 'deleting' already deleted mapping
+  pcall(vim.api.nvim_del_keymap, mode, lhs)
+  if pair == '' then return end
+  H.unregister_pair(pair, mode, 'all')
+end
+
+--- Remove buffer mapping
+---
+--- Wrapper for |nvim_buf_del_keymap()| which also unregisters supplied `pair`.
+---
+--- Note: this only reverts mapping done by |MiniPairs.map_buf|. If mapping was
+--- done with |MiniPairs.map|, unmap for buffer in usual Neovim manner:
+--- `inoremap <buffer> <*> <*>` (this maps `<*>` key to do the same it does by
+--- default).
+---
+---@param buffer number `buffer` for |nvim_buf_del_keymap()|.
+---@param mode string `mode` for |nvim_buf_del_keymap()|.
+---@param lhs string `lhs` for |nvim_buf_del_keymap()|.
+---@param pair __pairs_unregistered_pair
+MiniPairs.unmap_buf = function(buffer, mode, lhs, pair)
+  -- `pair` should be supplied explicitly
+  vim.validate({ pair = { pair, 'string' } })
+
+  -- Use `pcall` to allow 'deleting' already deleted mapping
+  pcall(vim.api.nvim_buf_del_keymap, buffer, mode, lhs)
+  if pair == '' then return end
+  H.unregister_pair(pair, mode, buffer == 0 and vim.api.nvim_get_current_buf() or buffer)
+end
+
+--- Process "open" symbols
+---
+--- Used as |map-expr| mapping for "open" symbols in asymmetric pair ('(', '[',
+--- etc.). If neighborhood doesn't match supplied pattern, function results
+--- into "open" symbol. Otherwise, it pastes whole pair and moves inside pair
+--- with |<Left>|.
+---
+--- Used inside |MiniPairs.map| and |MiniPairs.map_buf| for an actual mapping.
+---
+---@param pair __pairs_pair
+---@param neigh_pattern __pairs_neigh_pattern
+---
+---@return string Keys performing "open" action.
+MiniPairs.open = function(pair, neigh_pattern)
+  if H.is_disabled() or not H.neigh_match(neigh_pattern) then return pair:sub(1, 1) end
+
+  return ('%s%s'):format(pair, H.get_arrow_key('left'))
+end
+
+--- Process "close" symbols
+---
+--- Used as |map-expr| mapping for "close" symbols in asymmetric pair (')',
+--- ']', etc.). If neighborhood doesn't match supplied pattern, function
+--- results into "close" symbol. Otherwise it jumps over symbol to the right of
+--- cursor (with |<Right>|) if it is equal to "close" one and inserts it
+--- otherwise.
+---
+--- Used inside |MiniPairs.map| and |MiniPairs.map_buf| for an actual mapping.
+---
+---@param pair __pairs_pair
+---@param neigh_pattern __pairs_neigh_pattern
+---
+---@return string Keys performing "close" action.
+MiniPairs.close = function(pair, neigh_pattern)
+  if H.is_disabled() or not H.neigh_match(neigh_pattern) then return pair:sub(2, 2) end
+
+  local close = pair:sub(2, 2)
+  if H.get_cursor_neigh(1, 1) == close then
+    return H.get_arrow_key('right')
+  else
+    return close
+  end
+end
+
+--- Process "closeopen" symbols
+---
+--- Used as |map-expr| mapping for 'symmetrical' symbols (from pairs '""',
+--- '\'\'', '``').  It tries to perform 'closeopen action': move over right
+--- character (with |<Right>|) if it is equal to second character from pair or
+--- conditionally paste pair otherwise (with |MiniPairs.open()|).
+---
+--- Used inside |MiniPairs.map| and |MiniPairs.map_buf| for an actual mapping.
+---
+---@param pair __pairs_pair
+---@param neigh_pattern __pairs_neigh_pattern
+---
+---@return string Keys performing "closeopen" action.
+MiniPairs.closeopen = function(pair, neigh_pattern)
+  if H.is_disabled() or H.get_cursor_neigh(1, 1) ~= pair:sub(2, 2) then
+    return MiniPairs.open(pair, neigh_pattern)
+  else
+    return H.get_arrow_key('right')
+  end
+end
+
+--- Process |<BS>|
+---
+--- Used as |map-expr| mapping for `<BS>` in Insert mode. It removes whole pair
+--- (via executing `<Del>` after input key) if neighborhood is equal to a whole
+--- pair recognized for current buffer. Pair is recognized for current buffer
+--- if it is registered for global or current buffer mapping. Pair is
+--- registered as a result of calling |MiniPairs.map| or |MiniPairs.map_buf|.
+---
+--- Mapped by default inside |MiniPairs.setup|.
+---
+--- This can be used to modify other Insert mode keys to respect neighborhood
+--- pair. Examples: >
+---
+---   local map_bs = function(lhs, rhs)
+---     vim.keymap.set('i', lhs, rhs, { expr = true, replace_keycodes = false })
+---   end
+---
+---   map_bs('<C-h>', 'v:lua.MiniPairs.bs()')
+---   map_bs('<C-w>', 'v:lua.MiniPairs.bs("\23")')
+---   map_bs('<C-u>', 'v:lua.MiniPairs.bs("\21")')
+---
+---@param key string|nil Key to use. Default: `<BS>`.
+---
+---@return string Keys performing "backspace" action.
+MiniPairs.bs = function(key)
+  local res = key or H.keys.bs
+
+  local neigh = H.get_cursor_neigh(0, 1)
+  if not H.is_disabled() and H.is_pair_registered(neigh, vim.fn.mode(), 0, 'bs') then
+    res = ('%s%s'):format(res, H.keys.del)
+  end
+
+  return res
+end
+
+--- Process |i_<CR>|
+---
+--- Used as |map-expr| mapping for `<CR>` in insert mode. It puts "close"
+--- symbol on next line (via `<CR><C-o>O`) if neighborhood is equal to a whole
+--- pair recognized for current buffer. Pair is recognized for current buffer
+--- if it is registered for global or current buffer mapping. Pair is
+--- registered as a result of calling |MiniPairs.map| or |MiniPairs.map_buf|.
+---
+--- Mapped by default inside |MiniPairs.setup|.
+---
+---@param key string|nil Key to use. Default: `<CR>`.
+---
+---@return string Keys performing "new line" action.
+MiniPairs.cr = function(key)
+  local res = key or H.keys.cr
+
+  local neigh = H.get_cursor_neigh(0, 1)
+  if not H.is_disabled() and H.is_pair_registered(neigh, vim.fn.mode(), 0, 'cr') then
+    res = ('%s%s'):format(res, H.keys.above)
+  end
+
+  return res
+end
+
+-- Helper data ================================================================
+-- Module default config
+H.default_config = vim.deepcopy(MiniPairs.config)
+
+-- Default value of `pair_info` for mapping functions
+H.default_pair_info = { neigh_pattern = '..', register = { bs = true, cr = true } }
+
+-- Pair sets registered *per mode-buffer-key*. Buffer `'all'` contains pairs
+-- registered for all buffers.
+H.registered_pairs = {
+  i = { all = { bs = {}, cr = {} } },
+  c = { all = { bs = {}, cr = {} } },
+  t = { all = { bs = {}, cr = {} } },
+}
+
+-- Precomputed keys to increase speed
+-- stylua: ignore start
+local function escape(s) return vim.api.nvim_replace_termcodes(s, true, true, true) end
+H.keys = {
+  above     = escape('<C-o>O'),
+  bs        = escape('<bs>'),
+  cr        = escape('<cr>'),
+  del       = escape('<del>'),
+  keep_undo = escape('<C-g>U'),
+  -- NOTE: use `get_arrow_key()` instead of `H.keys.left` or `H.keys.right`
+  left      = escape('<left>'),
+  right     = escape('<right>')
+}
+-- stylua: ignore end
+
+-- Helper functionality =======================================================
+-- Settings -------------------------------------------------------------------
+H.setup_config = function(config)
+  -- General idea: if some table elements are not present in user-supplied
+  -- `config`, take them from default config
+  vim.validate({ config = { config, 'table', true } })
+  config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
+
+  -- Validate per nesting level to produce correct error message
+  vim.validate({
+    modes = { config.modes, 'table' },
+    mappings = { config.mappings, 'table' },
+  })
+
+  vim.validate({
+    ['modes.insert'] = { config.modes.insert, 'boolean' },
+    ['modes.command'] = { config.modes.command, 'boolean' },
+    ['modes.terminal'] = { config.modes.terminal, 'boolean' },
+  })
+
+  local validate_mapping = function(pair_info, prefix)
+    -- Allow `false` to not create mapping
+    if pair_info == false then return end
+    H.validate_pair_info(pair_info, prefix)
+  end
+
+  validate_mapping(config.mappings['('], "mappings['(']")
+  validate_mapping(config.mappings['['], "mappings['[']")
+  validate_mapping(config.mappings['{'], "mappings['{']")
+  validate_mapping(config.mappings[')'], "mappings[')']")
+  validate_mapping(config.mappings[']'], "mappings[']']")
+  validate_mapping(config.mappings['}'], "mappings['}']")
+  validate_mapping(config.mappings['"'], "mappings['\"']")
+  validate_mapping(config.mappings["'"], 'mappings["\'"]')
+  validate_mapping(config.mappings['`'], "mappings['`']")
+
+  return config
+end
+
+H.apply_config = function(config)
+  MiniPairs.config = config
+
+  -- Setup mappings in supplied modes
+  local mode_ids = { insert = 'i', command = 'c', terminal = 't' }
+  -- Compute in which modes mapping should be set up
+  local mode_array = {}
+  for name, to_set in pairs(config.modes) do
+    if to_set then table.insert(mode_array, mode_ids[name]) end
+  end
+
+  local map_conditionally = function(mode, key, pair_info)
+    -- Allow `false` to not create mapping
+    if pair_info == false then return end
+
+    -- This also should take care of mapping `<BS>` and `<CR>`
+    MiniPairs.map(mode, key, pair_info)
+  end
+
+  for _, mode in pairs(mode_array) do
+    for key, pair_info in pairs(config.mappings) do
+      map_conditionally(mode, key, pair_info)
+    end
+  end
+end
+
+H.create_autocommands = function()
+  local augroup = vim.api.nvim_create_augroup('MiniPairs', {})
+
+  local au = function(event, pattern, callback, desc)
+    vim.api.nvim_create_autocmd(event, { group = augroup, pattern = pattern, callback = callback, desc = desc })
+  end
+
+  au('FileType', { 'TelescopePrompt', 'fzf' }, function() vim.b.minipairs_disable = true end, 'Disable locally')
+end
+
+H.is_disabled = function() return vim.g.minipairs_disable == true or vim.b.minipairs_disable == true end
+
+-- Pair registration ----------------------------------------------------------
+H.register_pair = function(pair_info, mode, buffer)
+  -- Process new mode
+  H.registered_pairs[mode] = H.registered_pairs[mode] or { all = { bs = {}, cr = {} } }
+  local mode_pairs = H.registered_pairs[mode]
+
+  -- Process new buffer
+  mode_pairs[buffer] = mode_pairs[buffer] or { bs = {}, cr = {} }
+
+  -- Register pair if it is not already registered
+  local register, pair = pair_info.register, pair_info.pair
+  if register.bs and not vim.tbl_contains(mode_pairs[buffer].bs, pair) then
+    table.insert(mode_pairs[buffer].bs, pair)
+  end
+  if register.cr and not vim.tbl_contains(mode_pairs[buffer].cr, pair) then
+    table.insert(mode_pairs[buffer].cr, pair)
+  end
+end
+
+H.unregister_pair = function(pair, mode, buffer)
+  local mode_pairs = H.registered_pairs[mode]
+  if not (mode_pairs and mode_pairs[buffer]) then return end
+
+  local buf_pairs = mode_pairs[buffer]
+  for _, key in ipairs({ 'bs', 'cr' }) do
+    for i, p in ipairs(buf_pairs[key]) do
+      if p == pair then table.remove(buf_pairs[key], i) end
+    end
+  end
+end
+
+H.is_pair_registered = function(pair, mode, buffer, key)
+  local mode_pairs = H.registered_pairs[mode]
+  if not mode_pairs then return false end
+
+  if vim.tbl_contains(mode_pairs['all'][key], pair) then return true end
+
+  buffer = buffer == 0 and vim.api.nvim_get_current_buf() or buffer
+  local buf_pairs = mode_pairs[buffer]
+  if not buf_pairs then return false end
+
+  return vim.tbl_contains(buf_pairs[key], pair)
+end
+
+H.ensure_cr_bs = function(mode)
+  local has_any_cr_pair, has_any_bs_pair = false, false
+  for _, pair_tbl in pairs(H.registered_pairs[mode]) do
+    has_any_cr_pair = has_any_cr_pair or not vim.tbl_isempty(pair_tbl.cr)
+    has_any_bs_pair = has_any_bs_pair or not vim.tbl_isempty(pair_tbl.bs)
+  end
+
+  -- NOTE: this doesn't distinguish between global and buffer mappings. Both
+  -- `<BS>` and `<CR>` should work as normal even if no pairs are registered
+  if has_any_bs_pair then
+    -- Use not `silent` in Command mode to make it redraw
+    local opts = { silent = mode ~= 'c', expr = true, replace_keycodes = false, desc = 'MiniPairs <BS>' }
+    H.map(mode, '<BS>', 'v:lua.MiniPairs.bs()', opts)
+  end
+  if mode == 'i' and has_any_cr_pair then
+    local opts = { expr = true, replace_keycodes = false, desc = 'MiniPairs <CR>' }
+    H.map(mode, '<CR>', 'v:lua.MiniPairs.cr()', opts)
+  end
+end
+
+-- Work with pair_info --------------------------------------------------------
+H.validate_pair_info = function(pair_info, prefix)
+  prefix = prefix or 'pair_info'
+  vim.validate({ [prefix] = { pair_info, 'table' } })
+  pair_info = vim.tbl_deep_extend('force', H.default_pair_info, pair_info)
+
+  vim.validate({
+    [prefix .. '.action'] = { pair_info.action, 'string' },
+    [prefix .. '.pair'] = { pair_info.pair, 'string' },
+    [prefix .. '.neigh_pattern'] = { pair_info.neigh_pattern, 'string' },
+    [prefix .. '.register'] = { pair_info.register, 'table' },
+  })
+
+  vim.validate({
+    [prefix .. '.register.bs'] = { pair_info.register.bs, 'boolean' },
+    [prefix .. '.register.cr'] = { pair_info.register.cr, 'boolean' },
+  })
+
+  return pair_info
+end
+
+H.pair_info_to_map_rhs = function(pair_info)
+  return ('v:lua.MiniPairs.%s(%s, %s)'):format(
+    pair_info.action,
+    vim.inspect(pair_info.pair),
+    vim.inspect(pair_info.neigh_pattern)
+  )
+end
+
+H.infer_mapping_description = function(pair_info)
+  local action_name = pair_info.action:sub(1, 1):upper() .. pair_info.action:sub(2)
+  return ('%s action for %s pair'):format(action_name, vim.inspect(pair_info.pair))
+end
+
+-- Utilities ------------------------------------------------------------------
+H.get_cursor_neigh = function(start, finish)
+  local line, col
+  if vim.fn.mode() == 'c' then
+    line = vim.fn.getcmdline()
+    col = vim.fn.getcmdpos()
+    -- Adjust start and finish because output of `getcmdpos()` starts counting
+    -- columns from 1
+    start = start - 1
+    finish = finish - 1
+  else
+    line = vim.api.nvim_get_current_line()
+    col = vim.api.nvim_win_get_cursor(0)[2]
+  end
+
+  -- Add '\r' and '\n' to always return 2 characters
+  return string.sub(('%s%s%s'):format('\r', line, '\n'), col + 1 + start, col + 1 + finish)
+end
+
+H.neigh_match = function(pattern) return (pattern == nil) or (H.get_cursor_neigh(0, 1):find(pattern) ~= nil) end
+
+H.get_arrow_key = function(key)
+  if vim.fn.mode() == 'i' then
+    -- Using left/right keys in insert mode breaks undo sequence and, more
+    -- importantly, dot-repeat. To avoid this, use 'i_CTRL-G_U' mapping.
+    return H.keys.keep_undo .. H.keys[key]
+  else
+    return H.keys[key]
+  end
+end
+
+H.map = function(mode, lhs, rhs, opts)
+  if lhs == '' then return end
+  opts = vim.tbl_deep_extend('force', { silent = true }, opts or {})
+  vim.keymap.set(mode, lhs, rhs, opts)
+end
+
+return MiniPairs
diff --git a/.config/nvim/lua/mini/splitjoin.lua b/.config/nvim/lua/mini/splitjoin.lua
new file mode 100644
index 0000000..5853cef
--- /dev/null
+++ b/.config/nvim/lua/mini/splitjoin.lua
@@ -0,0 +1,1122 @@
+--- *mini.splitjoin* Split and join arguments
+--- *MiniSplitjoin*
+---
+--- MIT License Copyright (c) 2023 Evgeni Chasnovski
+---
+--- ==============================================================================
+---
+--- Features:
+--- - Mappings and Lua functions that modify arguments (regions inside brackets
+---   between allowed separators) under cursor.
+---
+---   Supported actions:
+---     - Toggle - split if arguments are on single line, join otherwise.
+---       Main supported function of the module. See |MiniSplitjoin.toggle()|.
+---     - Split - make every argument separator be on end of separate line.
+---       See |MiniSplitjoin.split()|.
+---     - Join - make all arguments be on single line.
+---       See |MiniSplitjoin.join()|.
+---
+--- - Mappings are dot-repeatable in Normal mode and work in Visual mode.
+---
+--- - Customizable argument detection (see |MiniSplitjoin.config.detect|):
+---     - Which brackets can contain arguments.
+---     - Which strings can separate arguments.
+---     - Which regions are excluded when looking for separators (like inside
+---       nested brackets or quotes).
+---
+--- - Customizable pre and post hooks for both split and join. See `split` and
+---   `join` in |MiniSplitjoin.config|. There are several built-in ones
+---   in |MiniSplitjoin.gen_hook|.
+---
+--- - Works inside comments by using modified notion of indent.
+---   See |MiniSplitjoin.get_indent_part()|.
+---
+--- - Provides low-level Lua functions for split and join at positions.
+---   See |MiniSplitjoin.split_at()| and |MiniSplitjoin.join_at()|.
+---
+--- Notes:
+--- - Search for arguments is done using Lua patterns (regex-like approach).
+---   Certain amount of false positives is to be expected.
+---
+--- - This module is mostly designed around |MiniSplitjoin.toggle()|. If target
+---   split positions are on different lines, join first and then split.
+---
+--- - Actions can be done on Visual mode selection, which mostly present as
+---   a safety route in case of incorrect detection of initial region.
+---   It uses |MiniSplitjoin.get_visual_region()| which treats selection as full
+---   brackets (include brackets in selection).
+---
+--- # Setup ~
+---
+--- This module needs a setup with `require('mini.splitjoin').setup({})` (replace
+--- `{}` with your `config` table). It will create global Lua table `MiniSplitjoin`
+--- which you can use for scripting or manually (with `:lua MiniSplitjoin.*`).
+---
+--- See |MiniSplitjoin.config| for available config settings.
+---
+--- You can override runtime config settings (like action hooks) locally to
+--- buffer inside `vim.b.minisplitjoin_config` which should have same structure
+--- as `MiniSplitjoin.config`. See |mini.nvim-buffer-local-config| for more details.
+---
+--- # Comparisons ~
+---
+--- - 'FooSoft/vim-argwrap':
+---     - Mostly has the same design as this module.
+---     - Doesn't work inside comments, while this module does.
+---     - Has more built-in ways to control split and join, while this module
+---       intentionally provides only handful.
+--- - 'AndrewRadev/splitjoin.vim':
+---     - More oriented towards language-depended transformations, while this
+---       module intntionally deals with more generic text-related functionality.
+--- - 'Wansmer/treesj':
+---     - Operates based on tree-sitter nodes. This is more accurate in
+---       some edge cases, but **requires** tree-sitter parser.
+---     - Doesn't work inside comments or strings.
+---
+--- # Disabling~
+---
+--- To disable, set `g:minisplitjoin_disable` (globally) or `b:minisplitjoin_disable`
+--- (for a buffer) to `v:true`. Considering high number of different scenarios
+--- and customization intentions, writing exact rules for disabling module's
+--- functionality is left to user. See |mini.nvim-disabling-recipes| for common
+--- recipes.
+
+--- - POSITION - table with fields <line> and <col> containing line and column
+---   numbers respectively. Both are 1-indexed. Example: `{ line = 2, col = 1 }`.
+---
+--- - REGION - table representing region in a buffer. Fields: <from> and
+---   <to> for inclusive start and end positions. Example: >
+---
+---   { from = { line = 1, col = 1 }, to = { line = 2, col = 1 } }
+---@tag MiniSplitjoin-glossary
+
+---@alias __splitjoin_options table|nil Options. Has structure from |MiniSplitjoin.config|
+---   inheriting its default values.
+---
+---   Following extra optional fields are allowed:
+---   - <position> `(table)` - position at which to find smallest bracket region.
+---     See |MiniSplitjoin-glossary| for the structure.
+---     Default: cursor position.
+---   - <region> `(table)` - region at which to perform action. Assumes inclusive
+---     both start at left bracket and end at right bracket.
+---     See |MiniSplitjoin-glossary| for the structure.
+---     Default: `nil` to automatically detect region.
+---@alias __splitjoin_hook_brackets - <brackets> `(table)` - array of bracket patterns indicating on which
+---      brackets action should be made. Has same structure as `brackets`
+---      in |MiniSplitjoin.config.detect|.
+---      Default: `MiniSplitjoin.config.detect.brackets`.
+
+---@diagnostic disable:undefined-field
+---@diagnostic disable:discard-returns
+---@diagnostic disable:unused-local
+
+-- Module definition ==========================================================
+local MiniSplitjoin = {}
+local H = {}
+
+--- Module setup
+---
+---@param config table|nil Module config table. See |MiniSplitjoin.config|.
+---
+---@usage `require('mini.splitjoin').setup({})` (replace `{}` with your `config` table)
+MiniSplitjoin.setup = function(config)
+  -- Export module
+  _G.MiniSplitjoin = MiniSplitjoin
+
+  -- Setup config
+  config = H.setup_config(config)
+
+  -- Apply config
+  H.apply_config(config)
+end
+
+--- Module config
+---
+--- Default values:
+---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
+---@text                                                    *MiniSplitjoin.config.detect*
+--- # Detection ~
+---
+--- The table at `config.detect` controls how arguments are detected using Lua
+--- patterns. General idea is to convert whole buffer into a single line,
+--- perform string search, and convert results back into 2d positions.
+---
+--- Example configuration: >
+---
+---   require('mini.splitjoin').setup({
+---     detect = {
+---       -- Detect only inside balanced parenthesis
+---       brackets = { '%b()' },
+---
+---       -- Allow both `,` and `;` to separate arguments
+---       separator = '[,;]',
+---
+---       -- Make any separator define an argument
+---       exclude_regions = {},
+---     },
+---   })
+---
+--- ## Outer brackets ~
+---
+--- `detect.brackets` is an array of Lua patterns used to find enclosing region.
+--- It is done by traversing whole buffer to find the smallest region matching
+--- any supplied pattern.
+---
+--- Default: `nil`, inferred as `{ '%b()', '%b[]', '%b{}' }`.
+--- So an argument can be inside a balanced `()`, `[]`, or `{}`.
+---
+--- Example: `brackets = { '%b()' }` will search for arguments only inside
+--- balanced `()`.
+---
+--- ## Separator ~
+---
+--- `detect.separator` is a single Lua pattern defining which strings should be
+--- treated as argument separators.
+---
+--- Empty string in `detect.separator` will result in only surrounding brackets
+--- used as separators.
+---
+--- Only end of pattern match will be used as split/join positions.
+---
+--- Default: `','`. So an argument can be separated only with comma.
+---
+--- Example: `separator = { '[,;]' }` will treat both `,` and `;` as separators.
+---
+--- ## Excluded regions ~
+---
+--- `detect.exclude_regions` is an array of Lua patterns for sub-regions from which
+--- to exclude separators. Enables correct detection in case of nested brackets
+--- and quotes.
+---
+--- Default: `nil`; inferred as `{ '%b()', '%b[]', '%b{}', '%b""', "%b''" }`.
+--- So a separator **can not** be inside a balanced `()`, `[]`, `{}` (representing
+--- nested argument regions) or `""`, `''` (representing strings).
+---
+--- Example: `exclude_regions = {}` will not exclude any regions. So in case of
+--- `f(a, { b, c })` it will detect both commas as argument separators.
+---
+--- # Hooks ~
+---
+--- `split.hooks_pre`, `split.hooks_post`, `join.hooks_pre`, and `join.hooks_post`
+--- are arrays of hook functions. If empty (default) no hook is applied.
+---
+--- Hooks should take and return array of positions. See |MiniSplitjoin-glossary|.
+---
+--- They can be used to tweak actions:
+---
+--- - Pre-hooks are called before action. Each is applied on the output of
+---   previous one. Input of first hook are detected split/join positions.
+---   Output of last one is actually used to perform split/join.
+---
+--- - Post-hooks are called after action. Each is applied on the output of
+---   previous one. Input of first hook are split/join positions from actual
+---   action plus its region's right end as last position (for easier hook code).
+---   Output of last one is used as action return value.
+---
+--- For more specific details see |MiniSplitjoin.split()| and |MiniSplitjoin.join()|.
+---
+--- See |MiniSplitjoin.gen_hook| for generating common hooks with examples.
+MiniSplitjoin.config = {
+  -- Module mappings. Use `''` (empty string) to disable one.
+  -- Created for both Normal and Visual modes.
+  mappings = {
+    toggle = 'gS',
+    split = '',
+    join = '',
+  },
+
+  -- Detection options: where split/join should be done
+  detect = {
+    -- Array of Lua patterns to detect region with arguments.
+    -- Default: { '%b()', '%b[]', '%b{}' }
+    brackets = nil,
+
+    -- String Lua pattern defining argument separator
+    separator = ',',
+
+    -- Array of Lua patterns for sub-regions to exclude separators from.
+    -- Enables correct detection in presence of nested brackets and quotes.
+    -- Default: { '%b()', '%b[]', '%b{}', '%b""', "%b''" }
+    exclude_regions = nil,
+  },
+
+  -- Split options
+  split = {
+    hooks_pre = {},
+    hooks_post = {},
+  },
+
+  -- Join options
+  join = {
+    hooks_pre = {},
+    hooks_post = {},
+  },
+}
+--minidoc_afterlines_end
+
+--- Toggle arguments
+---
+--- Overview:
+--- - Detect region at input position: either by using supplied `opts.region` or
+---   by finding smallest bracketed region surrounding position.
+---   See |MiniSplitjoin.config.detect| for more details.
+--- - If region spans single line, use |MiniSplitjoin.split()| with found region.
+---   Otherwise use |MiniSplitjoin.join()|.
+---
+---@param opts __splitjoin_options
+---
+---@return any Output of chosen `split()` or `join()` action.
+MiniSplitjoin.toggle = function(opts)
+  if H.is_disabled() then return end
+
+  opts = H.get_opts(opts)
+
+  local region = opts.region or H.find_smallest_bracket_region(opts.position, opts.detect.brackets)
+  if region == nil then return end
+
+  opts.region = region
+  if region.from.line == region.to.line then
+    return MiniSplitjoin.split(opts)
+  else
+    return MiniSplitjoin.join(opts)
+  end
+end
+
+--- Split arguments
+---
+--- Overview:
+--- - Detect region: either by using supplied `opts.region` or by finding smallest
+---   bracketed region surrounding input position (cursor position by default).
+---   See |MiniSplitjoin.config.detect| for more details.
+---
+--- - Find separator positions using `separator` and `exclude_regions` from `opts`.
+---   Both brackets are treated as separators.
+---   See |MiniSplitjoin.config.detect| for more details.
+---   Note: stop if no separator positions are found.
+---
+--- - Modify separator positions to represent split positions. Last split position
+---   (which is inferred from right bracket) is moved one column to left so that
+---   right bracket would move on new line.
+---
+--- - Apply all hooks from `opts.split.hooks_pre`. Each is applied on the output of
+---   previous one. Input of first hook is split positions from previous step.
+---   Output of last one is used as split positions in next step.
+---
+--- - Split and update split positions with |MiniSplitjoin.split_at()|.
+---
+--- - Apply all hooks from `opts.split.hooks_post`. Each is applied on the output of
+---   previous one. Input of first hook is split positions from previous step plus
+---   region's right end (for easier hook code).
+---   Output of last one is used as function return value.
+---
+--- Note:
+--- - By design, it doesn't detect if argument **should** be split, so application
+---   on arguments spanning multiple lines can lead to undesirable result.
+---
+---@param opts __splitjoin_options
+---
+---@return any Output of last `opts.split.hooks_post` or `nil` if no split positions
+---   found. Default: return value of |MiniSplitjoin.split_at()| application.
+MiniSplitjoin.split = function(opts)
+  if H.is_disabled() then return end
+
+  opts = H.get_opts(opts)
+
+  local region = opts.region or H.find_smallest_bracket_region(opts.position, opts.detect.brackets)
+  if region == nil then return nil end
+
+  local positions = H.find_split_positions(region, opts.detect.separator, opts.detect.exclude_regions)
+  if #positions == 0 then return nil end
+
+  -- Call pre-hooks
+  for _, hook in ipairs(opts.split.hooks_pre) do
+    positions = hook(positions)
+  end
+
+  -- Split at positions
+  local split_positions = MiniSplitjoin.split_at(positions)
+
+  -- Call post-hooks to tweak splits. Add right bracket for easier hook code.
+  local last = split_positions[#split_positions]
+  local last_next_line = vim.fn.getline(last.line + 1)
+  local new_col = MiniSplitjoin.get_indent_part(last_next_line):len() + 1
+  table.insert(split_positions, { line = last.line + 1, col = new_col })
+
+  for _, hook in ipairs(opts.split.hooks_post) do
+    split_positions = hook(split_positions)
+  end
+
+  return split_positions
+end
+
+--- Join arguments
+---
+--- Overview:
+--- - Detect region: either by using supplied `opts.region` or by finding smallest
+---   bracketed region surrounding input position (cursor position by default).
+---   See |MiniSplitjoin.config.detect| for more details.
+---
+--- - Compute join positions to be line ends of all but last region lines.
+---   Note: stop if no join positions are found.
+---
+--- - Apply all hooks from `opts.join.hooks_pre`. Each is applied on the output
+---   of previous one. Input of first hook is join positions from previous step.
+---   Output of last one is used as join positions in next step.
+---
+--- - Join and update join positions with |MiniSplitjoin.join_at()|.
+---
+--- - Apply all hooks from `opts.join.hooks_post`. Each is applied on the output
+---   of previous one. Input of first hook is join positions from previous step
+---   plus region's right end for easier hook code.
+---   Output of last one is used as function return value.
+---
+---@param opts __splitjoin_options
+---
+---@return any Output of last `opts.split.hooks_post` or `nil` of no join positions
+---   found. Default: return value of |MiniSplitjoin.join_at()| application.
+MiniSplitjoin.join = function(opts)
+  if H.is_disabled() then return end
+
+  opts = H.get_opts(opts)
+
+  local region = opts.region or H.find_smallest_bracket_region(opts.position, opts.detect.brackets)
+  if region == nil then return nil end
+
+  local positions = H.find_join_positions(region)
+  if #positions == 0 then return nil end
+
+  -- Call pre-hooks
+  for _, hook in ipairs(opts.join.hooks_pre) do
+    positions = hook(positions)
+  end
+
+  -- Join at positions
+  local join_positions = MiniSplitjoin.join_at(positions)
+
+  -- Call post-hooks to tweak joins. Add right bracket for easier hook code.
+  local last = join_positions[#join_positions]
+  table.insert(join_positions, { line = last.line, col = last.col + 1 })
+
+  for _, hook in ipairs(opts.join.hooks_post) do
+    join_positions = hook(join_positions)
+  end
+
+  return join_positions
+end
+
+--- Generate common hooks
+---
+--- This is a table with function elements. Call to actually get hook.
+---
+--- All generated post-hooks return updated versions of their input reflecting
+--- changes done inside hook.
+---
+--- Example for `lua` filetype (place it in 'lua.lua' filetype plugin, |ftplugin|): >
+---
+---   local gen_hook = MiniSplitjoin.gen_hook
+---   local curly = { brackets = { '%b{}' } }
+---
+---   -- Add trailing comma when splitting inside curly brackets
+---   local add_comma_curly = gen_hook.add_trailing_separator(curly)
+---
+---   -- Delete trailing comma when joining inside curly brackets
+---   local del_comma_curly = gen_hook.del_trailing_separator(curly)
+---
+---   -- Pad curly brackets with single space after join
+---   local pad_curly = gen_hook.pad_brackets(curly)
+---
+---   -- Create buffer-local config
+---   vim.b.minisplitjoin_config = {
+---     split = { hooks_post = { add_comma_curly } },
+---     join  = { hooks_post = { del_comma_curly, pad_curly } },
+---   }
+MiniSplitjoin.gen_hook = {}
+
+--- Generate hook to pad brackets
+---
+--- This is a join post-hook. Use in `join.hooks_post` of |MiniSplitjoin.config|.
+---
+---@param opts table|nil Options. Possible fields:
+---    - <pad> `(string)` - pad to add after first and before last join positions.
+---      Default: `' '` (single space).
+---    __splitjoin_hook_brackets
+---
+---@return function A hook which adds inner pad to first and last join positions and
+---   returns updated input join positions.
+MiniSplitjoin.gen_hook.pad_brackets = function(opts)
+  opts = opts or {}
+  local pad = opts.pad or ' '
+  local brackets = opts.brackets or H.get_opts(opts).detect.brackets
+  local n_pad = pad:len()
+
+  return function(join_positions)
+    -- Act only on actual join
+    local n_pos = #join_positions
+    if n_pos == 0 or pad == '' then return join_positions end
+
+    -- Act only if brackets are matched. First join position should be exactly
+    -- on left bracket, last - just before right bracket.
+    local first, last = join_positions[1], join_positions[n_pos]
+    local brackets_matched = H.is_positions_inside_brackets(first, last, brackets)
+    if not brackets_matched then return join_positions end
+
+    -- Pad only in case of non-trivial join
+    if first.line == last.line and (last.col - first.col) <= 1 then return join_positions end
+
+    -- Add pad after left and before right edges
+    H.set_text(first.line - 1, last.col - 1, first.line - 1, last.col - 1, { pad })
+    H.set_text(first.line - 1, first.col, first.line - 1, first.col, { pad })
+
+    -- Update `join_positions` to reflect text change
+    -- - Account for left pad
+    for i = 2, n_pos do
+      join_positions[i].col = join_positions[i].col + n_pad
+    end
+    -- - Account for right pad
+    join_positions[n_pos].col = join_positions[n_pos].col + n_pad
+
+    return join_positions
+  end
+end
+
+--- Generate hook to add trailing separator
+---
+--- This is a split post-hook. Use in `split.hooks_post` of |MiniSplitjoin.config|.
+---
+---@param opts table|nil Options. Possible fields:
+---    - <sep> `(string)` - separator to add before last split position.
+---      Default: `','`.
+---    __splitjoin_hook_brackets
+---
+---@return function A hook which adds separator before last split position and
+---   returns updated input split positions.
+MiniSplitjoin.gen_hook.add_trailing_separator = function(opts)
+  opts = opts or {}
+  local sep = opts.sep or ','
+  local brackets = opts.brackets or H.get_opts(opts).detect.brackets
+
+  return function(split_positions)
+    -- Add only in case there is at least one argument
+    local n_pos = #split_positions
+    if n_pos < 3 then return split_positions end
+
+    -- Act only if brackets are matched
+    local first, last = split_positions[1], split_positions[n_pos]
+    local brackets_matched = H.is_positions_inside_brackets(first, last, brackets)
+    if not brackets_matched then return split_positions end
+
+    -- Act only if there is no trailing separator already
+    local target_line = vim.fn.getline(last.line - 1)
+    local target_col = target_line:find(vim.pesc(sep) .. '$')
+    if target_col ~= nil then return split_positions end
+
+    -- Add trailing separator
+    local col = target_line:len()
+    H.set_text(last.line - 2, col, last.line - 2, col, { sep })
+
+    -- Don't update `split_positions`, as appending to line has no effect
+    return split_positions
+  end
+end
+
+--- Generate hook to delete trailing separator
+---
+--- This is a join post-hook. Use in `join.hooks_post` of |MiniSplitjoin.config|.
+---
+---@param opts table|nil Options. Possible fields:
+---    - <sep> `(string)` - separator to remove before last join position.
+---      Default: `','`.
+---    __splitjoin_hook_brackets
+---
+---@return function A hook which adds separator before last split position and
+---   returns updated input split positions.
+MiniSplitjoin.gen_hook.del_trailing_separator = function(opts)
+  opts = opts or {}
+  local sep = opts.sep or ','
+  local brackets = opts.brackets or H.get_opts(opts).detect.brackets
+  local n_sep = sep:len()
+
+  return function(join_positions)
+    -- Act only on actual join
+    local n_pos = #join_positions
+    if n_pos == 0 then return join_positions end
+
+    -- Act only if brackets are matched
+    local first, last = join_positions[1], join_positions[n_pos]
+    local brackets_matched = H.is_positions_inside_brackets(first, last, brackets)
+    if not brackets_matched then return join_positions end
+
+    -- Act only if there is matched trailing separator
+    local target_line = vim.fn.getline(last.line):sub(1, last.col - 1)
+    local target_col = target_line:find(vim.pesc(sep) .. '%s*$')
+    if target_col == nil then return join_positions end
+
+    -- Remove trailing separator
+    H.set_text(last.line - 1, target_col - 1, last.line - 1, target_col - 1 + n_sep, {})
+
+    -- Update `join_positions` to reflect text change. Update last as it moved.
+    -- Do not update second to last because it didn't affect what was tracked.
+    join_positions[n_pos] = { line = last.line, col = last.col - n_sep }
+
+    return join_positions
+  end
+end
+
+--- Split at positions
+---
+--- Overview:
+--- - For each position move all characters after it to next line and make it have
+---   same indent as current one (see |MiniSplitjoin.get_indent_part()|).
+---   Also remove trailing whitespace at position line.
+---
+--- - Increase indent of inner lines by a single pad: tab in case of |noexpandtab|
+---   or |shiftwidth()| number of spaces otherwise.
+---
+--- Notes:
+--- - Cursor is adjusted to follow text updates.
+--- - Use output of this function to keep track of input positions.
+---
+---@param positions table Array of positions at which to perform split.
+---   See |MiniSplitjoin-glossary| for their structure. Note: they don't have
+---   to be ordered, but first and last ones will be used to infer lines for
+---   which indent will be increased.
+---
+---@return table Array of new positions to where input `positions` were moved.
+MiniSplitjoin.split_at = function(positions)
+  local n_pos = #positions
+  if n_pos == 0 then return {} end
+
+  -- Cache values that might change
+  local cursor_extmark = H.put_extmark_at_positions({ H.get_cursor_pos() })[1]
+  local input_extmarks = H.put_extmark_at_positions(positions)
+
+  -- Split at extmark positions
+  for i = 1, n_pos do
+    H.split_at_extmark(input_extmarks[i])
+  end
+
+  -- Increase indent of inner lines
+  local first_new_pos = H.get_extmark_pos(input_extmarks[1])
+  local last_new_pos = H.get_extmark_pos(input_extmarks[n_pos])
+  H.increase_indent(first_new_pos.line + 1, last_new_pos.line)
+
+  -- Put cursor back on tracked position
+  H.put_cursor_at_extmark(cursor_extmark)
+
+  -- Reconstruct input positions
+  local res = vim.tbl_map(H.get_extmark_pos, input_extmarks)
+  vim.api.nvim_buf_clear_namespace(0, H.ns_id, 0, -1)
+  return res
+end
+
+--- Join at positions
+---
+--- Overview:
+--- - For each position join its line with the next line. Joining is done by
+---   replacing trailing whitespace of the line and indent of its next line
+---   (see |MiniSplitjoin.get_indent_part()|) with a pad string (single space except
+---   empty string for first and last positions). To adjust this, use hooks
+---   (for example, see |MiniSplitjoin.gen_hook.pad_brackets()|).
+---
+--- Notes:
+--- - Cursor is adjusted to follow text updates.
+--- - Use output of this function to keep track of input positions.
+---
+---@param positions table Array of positions at which to perform join.
+---   See |MiniSplitjoin-glossary| for their structure. Note: they don't have
+---   to be ordered, but first and last ones will have different pad string.
+---
+---@return table Array of new positions to where input `positions` were moved.
+MiniSplitjoin.join_at = function(positions)
+  local n_pos = #positions
+  if n_pos == 0 then return {} end
+
+  -- Cache values that might change
+  local cursor_extmark = H.put_extmark_at_positions({ H.get_cursor_pos() })[1]
+  local input_extmarks = H.put_extmark_at_positions(positions)
+
+  -- Join at positions which are changing following extmarks
+  for i = 1, n_pos do
+    local cur_pad_string = (i == 1 or i == n_pos) and '' or ' '
+    H.join_at_extmark(input_extmarks[i], cur_pad_string)
+  end
+
+  -- Put cursor back on tracked position
+  H.put_cursor_at_extmark(cursor_extmark)
+
+  -- Reconstruct input positions
+  local res = vim.tbl_map(H.get_extmark_pos, input_extmarks)
+  vim.api.nvim_buf_clear_namespace(0, H.ns_id, 0, -1)
+  return res
+end
+
+--- Get previous visual region
+---
+--- Get previous visual selection using |`<| and |`>| marks in the format of
+--- region (see |MiniSplitjoin-glossary|). Used in Visual mode mappings.
+---
+--- Note:
+--- - Both marks are included in region, so for better
+--- - In linewise Visual mode
+---
+---@return table A region. See |MiniSplitjoin-glossary| for exact structure.
+MiniSplitjoin.get_visual_region = function()
+  local from_pos, to_pos = vim.fn.getpos("'<"), vim.fn.getpos("'>")
+  local from, to = { line = from_pos[2], col = from_pos[3] }, { line = to_pos[2], col = to_pos[3] }
+  -- Tweak for linewise Visual selection
+  if vim.fn.visualmode() == 'V' then
+    from.col, to.col = 1, vim.fn.col({ to.line, '$' }) - 1
+  end
+
+  return { from = from, to = to }
+end
+
+--- Get string's indent part
+---
+---@param line string String for which to compute indent.
+---@param respect_comments boolean|nil Whether to respect comments as indent part.
+---   Default: `true`.
+---
+---@return string Part of input representing line's indent. Can be empty string.
+---   Use `string.len()` to compute indent in bytes.
+MiniSplitjoin.get_indent_part = function(line, respect_comments)
+  if respect_comments == nil then respect_comments = true end
+  if not respect_comments then return line:match('^%s*') end
+
+  -- Make it respect various comment leaders
+  local comment_indent = H.get_comment_indent(line, H.get_comment_leaders())
+  if comment_indent ~= '' then return comment_indent end
+
+  return line:match('^%s*')
+end
+
+--- Operator for Normal mode mappings
+---
+--- Main function to be used in expression mappings. No need to use it
+--- directly, everything is setup in |MiniSplitjoin.setup()|.
+---
+---@param task string Name of task.
+MiniSplitjoin.operator = function(task)
+  local is_init_call = task == 'toggle' or task == 'split' or task == 'join'
+  if not is_init_call then
+    MiniSplitjoin[H.cache.operator_task]()
+    return ''
+  end
+
+  if H.is_disabled() then
+    -- Using `<Esc>` prevents moving cursor caused by current implementation
+    -- detail of adding `' '` inside expression mapping
+    return [[\<Esc>]]
+  end
+
+  H.cache.operator_task = task
+  vim.o.operatorfunc = 'v:lua.MiniSplitjoin.operator'
+  return 'g@'
+end
+
+-- Helper data ================================================================
+-- Module default config
+H.default_config = vim.deepcopy(MiniSplitjoin.config)
+
+H.ns_id = vim.api.nvim_create_namespace('MiniSplitjoin')
+
+H.cache = { operator_task = nil }
+
+-- Helper functionality =======================================================
+-- Settings -------------------------------------------------------------------
+H.setup_config = function(config)
+  -- General idea: if some table elements are not present in user-supplied
+  -- `config`, take them from default config
+  vim.validate({ config = { config, 'table', true } })
+  config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
+
+  vim.validate({
+    mappings = { config.mappings, 'table' },
+    detect = { config.detect, 'table' },
+    split = { config.split, 'table' },
+    join = { config.join, 'table' },
+  })
+
+  vim.validate({
+    ['mappings.toggle'] = { config.mappings.toggle, 'string', true },
+    ['mappings.split'] = { config.mappings.split, 'string' },
+    ['mappings.join'] = { config.mappings.join, 'string', true },
+
+    ['detect.brackets'] = { config.detect.brackets, 'table', true },
+    ['detect.separator'] = { config.detect.separator, 'string' },
+    ['detect.exclude_regions'] = { config.detect.exclude_regions, 'table', true },
+
+    ['split.hooks_pre'] = { config.split.hooks_pre, 'table' },
+    ['split.hooks_post'] = { config.split.hooks_post, 'table' },
+
+    ['join.hooks_pre'] = { config.join.hooks_pre, 'table' },
+    ['join.hooks_post'] = { config.join.hooks_post, 'table' },
+  })
+
+  return config
+end
+
+--stylua: ignore
+H.apply_config = function(config)
+  MiniSplitjoin.config = config
+
+  -- Make mappings
+  local maps = config.mappings
+
+  H.map('n', maps.toggle, 'v:lua.MiniSplitjoin.operator("toggle") . " "', { expr = true, desc = 'Toggle arguments' })
+  H.map('n', maps.split,  'v:lua.MiniSplitjoin.operator("split") . " "',  { expr = true, desc = 'Split arguments' })
+  H.map('n', maps.join,   'v:lua.MiniSplitjoin.operator("join") . " "',   { expr = true, desc = 'Join arguments' })
+
+  H.map('x', maps.toggle, ':<C-u>lua MiniSplitjoin.toggle({ region = MiniSplitjoin.get_visual_region() })<CR>', { desc = 'Toggle arguments' })
+  H.map('x', maps.split,  ':<C-u>lua MiniSplitjoin.split({ region = MiniSplitjoin.get_visual_region() })<CR>',  { desc = 'Split arguments' })
+  H.map('x', maps.join,   ':<C-u>lua MiniSplitjoin.join({ region = MiniSplitjoin.get_visual_region() })<CR>',   { desc = 'Join arguments' })
+end
+
+H.is_disabled = function() return vim.g.minisplitjoin_disable == true or vim.b.minisplitjoin_disable == true end
+
+H.get_config = function(config)
+  return vim.tbl_deep_extend('force', MiniSplitjoin.config, vim.b.minisplitjoin_config or {}, config or {})
+end
+
+H.get_opts = function(opts)
+  opts = opts or {}
+
+  -- Infer detect options. Can't use usual `vim.tbl_deep_extend()` because it
+  -- doesn't work properly on arrays
+  local default_detect = {
+    brackets = { '%b()', '%b[]', '%b{}' },
+    separator = ',',
+    exclude_regions = { '%b()', '%b[]', '%b{}', '%b""', "%b''" },
+  }
+  local config = H.get_config()
+
+  return {
+    position = opts.position or H.get_cursor_pos(),
+    region = opts.region,
+    -- Extend `detect` not deeply to avoid unwanted values from longer defaults
+    detect = vim.tbl_extend('force', default_detect, config.detect, opts.detect or {}),
+    split = vim.tbl_deep_extend('force', config.split, opts.split or {}),
+    join = vim.tbl_deep_extend('force', config.join, opts.join or {}),
+  }
+end
+
+-- Split ----------------------------------------------------------------------
+H.split_at_extmark = function(extmark_id)
+  local pos = H.get_extmark_pos(extmark_id)
+
+  -- Split
+  H.set_text(pos.line - 1, pos.col, pos.line - 1, pos.col, { '', '' })
+
+  -- Remove trailing whitespace on split line
+  local split_line = vim.fn.getline(pos.line)
+  local start_of_trailspace = split_line:find('%s*$')
+  H.set_text(pos.line - 1, start_of_trailspace - 1, pos.line - 1, split_line:len(), {})
+
+  -- Adjust indent on new line
+  local cur_indent = MiniSplitjoin.get_indent_part(vim.fn.getline(pos.line + 1))
+  local new_indent = MiniSplitjoin.get_indent_part(split_line)
+  H.set_text(pos.line, 0, pos.line, cur_indent:len(), { new_indent })
+end
+
+H.find_split_positions = function(region, separator, exclude_regions)
+  local sep_positions = H.find_separator_positions(region, separator, exclude_regions)
+  local n_pos = #sep_positions
+
+  sep_positions[n_pos].col = sep_positions[n_pos].col - 1
+  return sep_positions
+end
+
+-- Join -----------------------------------------------------------------------
+H.join_at_extmark = function(extmark_id, pad)
+  local line_num = H.get_extmark_pos(extmark_id).line
+  if vim.api.nvim_buf_line_count(0) <= line_num then return end
+
+  -- Join by replacing trailing whitespace of current line and indent of next
+  -- one with `pad`
+  local lines = vim.api.nvim_buf_get_lines(0, line_num - 1, line_num + 1, true)
+  local above_start_col = lines[1]:len() - lines[1]:match('%s*$'):len()
+  local below_end_col = MiniSplitjoin.get_indent_part(lines[2]):len()
+
+  H.set_text(line_num - 1, above_start_col, line_num, below_end_col, { pad })
+end
+
+H.find_join_positions = function(region, separator, exclude_regions)
+  local lines = vim.api.nvim_buf_get_lines(0, region.from.line - 1, region.to.line, true)
+
+  -- Join whole region into single line
+  local res = {}
+  local init_line = region.from.line - 1
+  for i = 1, #lines - 1 do
+    table.insert(res, { line = init_line + i, col = lines[i]:len() })
+  end
+  return res
+end
+
+-- Detect ---------------------------------------------------------------------
+H.find_smallest_bracket_region = function(position, brackets)
+  local neigh = H.get_neighborhood()
+  local cur_offset = neigh.pos_to_offset(position)
+
+  local best_span = H.find_smallest_covering(neigh['1d'], cur_offset, brackets)
+  if best_span == nil then return nil end
+
+  return neigh.span_to_region(best_span)
+end
+
+H.find_smallest_covering = function(line, ref_offset, patterns)
+  local res, min_width = nil, math.huge
+  for _, pattern in ipairs(patterns) do
+    local cur_init = 0
+    local left, right = string.find(line, pattern, cur_init)
+    while left do
+      if left <= ref_offset and ref_offset <= right and (right - left) < min_width then
+        res, min_width = { from = left, to = right }, right - left
+      end
+
+      cur_init = left + 1
+      left, right = string.find(line, pattern, cur_init)
+    end
+  end
+
+  return res
+end
+
+H.find_separator_positions = function(region, separator, exclude_regions)
+  if separator == '' then return { region.from, region.to } end
+
+  local neigh = H.get_neighborhood()
+  local region_span = neigh.region_to_span(region)
+  local region_s = neigh['1d']:sub(region_span.from, region_span.to)
+
+  -- Match separator endings
+  local seps = {}
+  region_s:gsub(separator .. '()', function(r) table.insert(seps, r - 1) end)
+
+  -- Remove separators that are in excluded regions.
+  local inner_string, forbidden = region_s:sub(2, -2), {}
+  local add_to_forbidden = function(l, r) table.insert(forbidden, { from = l + 1, to = r }) end
+
+  for _, pat in ipairs(exclude_regions) do
+    inner_string:gsub('()' .. pat .. '()', add_to_forbidden)
+  end
+
+  -- - Also exclude trailing separator
+  inner_string:gsub('()' .. separator .. '%s*()$', add_to_forbidden)
+
+  local sub_offsets = vim.tbl_filter(function(x) return not H.is_offset_inside_spans(x, forbidden) end, seps)
+
+  -- Treat enclosing brackets as separators
+  if region_s:len() > 2 then
+    -- Use only last bracket in case of empty brackets
+    table.insert(sub_offsets, 1, 1)
+  end
+  table.insert(sub_offsets, region_s:len())
+
+  -- Convert offsets to positions
+  local start_offset = region_span.from
+  return vim.tbl_map(function(sub_off) return neigh.offset_to_pos(start_offset + sub_off - 1) end, sub_offsets)
+end
+
+H.is_offset_inside_spans = function(ref_point, spans)
+  for _, span in ipairs(spans) do
+    if span.from <= ref_point and ref_point <= span.to then return true end
+  end
+  return false
+end
+
+H.is_positions_inside_brackets = function(from_pos, to_pos, brackets)
+  local text_lines = vim.api.nvim_buf_get_text(0, from_pos.line - 1, from_pos.col - 1, to_pos.line - 1, to_pos.col, {})
+  local text = table.concat(text_lines, '\n')
+
+  for _, b in ipairs(brackets) do
+    if text:find('^' .. b .. '$') ~= nil then return true end
+  end
+  return false
+end
+
+H.is_char_at_position = function(position, char)
+  local present_char = vim.fn.getline(position.line):sub(position.col, position.col)
+  return present_char == char
+end
+
+-- Simplified version of "neighborhood" from 'mini.ai':
+-- - Use whol buffer.
+-- - No empty regions or spans.
+--
+-- NOTEs:
+-- - `region = { from = { line = a, col = b }, to = { line = c, col = d } }`.
+--   End-inclusive charwise selection. All `a`, `b`, `c`, `d` are 1-indexed.
+-- - `offset` is the number between 1 to `neigh1d:len()`.
+H.get_neighborhood = function()
+  local neigh2d = vim.api.nvim_buf_get_lines(0, 0, -1, false)
+  -- Append 'newline' character to distinguish between lines in 1d case
+  -- (crucial for handling empty lines)
+  for k, v in pairs(neigh2d) do
+    neigh2d[k] = v .. '\n'
+  end
+  local neigh1d = table.concat(neigh2d, '')
+  local n_lines = #neigh2d
+
+  -- Compute offsets for just before line starts
+  local line_offsets = {}
+  local cur_offset = 0
+  for i = 1, n_lines do
+    line_offsets[i] = cur_offset
+    cur_offset = cur_offset + neigh2d[i]:len()
+  end
+
+  -- Convert 2d buffer position to 1d offset
+  local pos_to_offset = function(pos) return line_offsets[pos.line] + pos.col end
+
+  -- Convert 1d offset to 2d buffer position
+  local offset_to_pos = function(offset)
+    for i = 1, n_lines - 1 do
+      if line_offsets[i] < offset and offset <= line_offsets[i + 1] then
+        return { line = i, col = offset - line_offsets[i] }
+      end
+    end
+
+    return { line = n_lines, col = offset - line_offsets[n_lines] }
+  end
+
+  -- Convert 2d region to 1d span
+  local region_to_span =
+    function(region) return { from = pos_to_offset(region.from), to = pos_to_offset(region.to) } end
+
+  -- Convert 1d span to 2d region
+  local span_to_region = function(span) return { from = offset_to_pos(span.from), to = offset_to_pos(span.to) } end
+
+  return {
+    ['1d'] = neigh1d,
+    ['2d'] = neigh2d,
+    pos_to_offset = pos_to_offset,
+    offset_to_pos = offset_to_pos,
+    region_to_span = region_to_span,
+    span_to_region = span_to_region,
+  }
+end
+
+-- Extmarks -------------------------------------------------------------------
+H.put_extmark_at_positions = function(positions)
+  return vim.tbl_map(
+    function(pos) return vim.api.nvim_buf_set_extmark(0, H.ns_id, pos.line - 1, pos.col - 1, {}) end,
+    positions
+  )
+end
+
+H.get_extmark_pos = function(extmark_id)
+  local res = vim.api.nvim_buf_get_extmark_by_id(0, H.ns_id, extmark_id, {})
+  return { line = res[1] + 1, col = res[2] + 1 }
+end
+
+H.get_cursor_pos = function()
+  local cur_pos = vim.api.nvim_win_get_cursor(0)
+  return { line = cur_pos[1], col = cur_pos[2] + 1 }
+end
+
+H.put_cursor_at_extmark = function(id)
+  local new_pos = vim.api.nvim_buf_get_extmark_by_id(0, H.ns_id, id, {})
+  vim.api.nvim_win_set_cursor(0, { new_pos[1] + 1, new_pos[2] })
+  vim.api.nvim_buf_del_extmark(0, H.ns_id, id)
+end
+
+-- Indent ---------------------------------------------------------------------
+H.increase_indent = function(from_line, to_line)
+  local lines = vim.api.nvim_buf_get_lines(0, from_line - 1, to_line, true)
+
+  -- Respect comment leaders only if all lines are commented
+  local comment_leaders = H.get_comment_leaders()
+  local respect_comments = H.is_comment_block(lines, comment_leaders)
+
+  -- Increase indent of all lines (end-inclusive)
+  local pad = vim.bo.expandtab and string.rep(' ', vim.fn.shiftwidth()) or '\t'
+  for i, l in ipairs(lines) do
+    local n_indent = MiniSplitjoin.get_indent_part(l, respect_comments):len()
+
+    -- Don't increase indent of blank lines (possibly respecting comments)
+    local cur_by_string = l:len() == n_indent and '' or pad
+
+    local line_num = from_line + i - 1
+    H.set_text(line_num - 1, n_indent, line_num - 1, n_indent, { cur_by_string })
+  end
+end
+
+H.get_comment_indent = function(line, comment_leaders)
+  local res = ''
+
+  for _, leader in ipairs(comment_leaders) do
+    local cur_match = line:match('^%s*' .. vim.pesc(leader) .. '%s*')
+    -- Use biggest match in case of several matches. Allows respecting "nested"
+    -- comment leaders like "---" and "--".
+    if type(cur_match) == 'string' and res:len() < cur_match:len() then res = cur_match end
+  end
+
+  return res
+end
+
+-- Comments -------------------------------------------------------------------
+H.get_comment_leaders = function()
+  local res = {}
+
+  -- From 'commentstring'
+  local main_leader = vim.split(vim.bo.commentstring, '%%s')[1]
+  -- - Ensure there is no whitespace before or after
+  table.insert(res, vim.trim(main_leader))
+
+  -- From 'comments'
+  for _, comment_part in ipairs(vim.opt_local.comments:get()) do
+    local prefix, suffix = comment_part:match('^(.*):(.*)$')
+
+    -- Control whitespace around suffix
+    suffix = vim.trim(suffix)
+
+    if prefix:find('b') then
+      -- Respect `b` flag (for blank) requiring space, tab or EOL after it
+      table.insert(res, suffix .. ' ')
+      table.insert(res, suffix .. '\t')
+    elseif prefix:find('f') == nil then
+      -- Add otherwise ignoring `f` flag (only first line should have it)
+      table.insert(res, suffix)
+    end
+  end
+
+  return res
+end
+
+H.is_comment_block = function(lines, comment_leaders)
+  for _, l in ipairs(lines) do
+    if not H.is_commented(l, comment_leaders) then return false end
+  end
+  return true
+end
+
+H.is_commented = function(line, comment_leaders)
+  for _, leader in ipairs(comment_leaders) do
+    if line:find('^%s*' .. vim.pesc(leader) .. '%s*') ~= nil then return true end
+  end
+  return false
+end
+
+-- Utilities ------------------------------------------------------------------
+H.error = function(msg) error(string.format('(mini.splitjoin) %s', msg), 0) end
+
+H.map = function(mode, lhs, rhs, opts)
+  if lhs == '' then return end
+  opts = vim.tbl_deep_extend('force', { silent = true }, opts or {})
+  vim.keymap.set(mode, lhs, rhs, opts)
+end
+
+H.set_text = function(start_row, start_col, end_row, end_col, replacement)
+  local ok = pcall(vim.api.nvim_buf_set_text, 0, start_row, start_col, end_row, end_col, replacement)
+  if not ok or #replacement == 0 then return end
+
+  -- Fix cursor position if it was exactly on start position.
+  -- See https://github.com/neovim/neovim/issues/22526.
+  local cursor = vim.api.nvim_win_get_cursor(0)
+  if (start_row + 1) == cursor[1] and start_col == cursor[2] then
+    vim.api.nvim_win_set_cursor(0, { cursor[1], cursor[2] + replacement[1]:len() })
+  end
+end
+
+return MiniSplitjoin
diff --git a/.config/nvim/lua/mini/surround.lua b/.config/nvim/lua/mini/surround.lua
new file mode 100644
index 0000000..dd55f37
--- /dev/null
+++ b/.config/nvim/lua/mini/surround.lua
@@ -0,0 +1,2233 @@
+--- *mini.surround* Surround actions
+--- *MiniSurround*
+---
+--- MIT License Copyright (c) 2021 Evgeni Chasnovski
+---
+--- ==============================================================================
+---
+--- Fast and feature-rich surrounding. Can be configured to have experience
+--- similar to 'tpope/vim-surround' (see |MiniSurround-vim-surround-config|).
+---
+--- Features:
+--- - Actions (all of them are dot-repeatable out of the box and respect
+---   |[count]|) with configurable keymappings:
+---     - Add surrounding with `sa` (in visual mode or on motion).
+---     - Delete surrounding with `sd`.
+---     - Replace surrounding with `sr`.
+---     - Find surrounding with `sf` or `sF` (move cursor right or left).
+---     - Highlight surrounding with `sh`.
+---     - Change number of neighbor lines with `sn` (see |MiniSurround-algorithm|).
+---
+--- - Surrounding is identified by a single character as both "input" (in
+---   `delete` and `replace` start, `find`, and `highlight`) and "output" (in
+---   `add` and `replace` end):
+---     - 'f' - function call (string of alphanumeric symbols or '_' or '.'
+---       followed by balanced '()'). In "input" finds function call, in
+---       "output" prompts user to enter function name.
+---     - 't' - tag. In "input" finds tag with same identifier, in "output"
+---       prompts user to enter tag name.
+---     - All symbols in brackets '()', '[]', '{}', '<>". In "input' represents
+---       balanced brackets (open - with whitespace pad, close - without), in
+---       "output" - left and right parts of brackets.
+---     - '?' - interactive. Prompts user to enter left and right parts.
+---     - All other alphanumeric, punctuation, or space characters represent
+---       surrounding with identical left and right parts.
+---
+--- - Configurable search methods to find not only covering but possibly next,
+---   previous, or nearest surrounding. See more in |MiniSurround.config|.
+---
+--- - All actions involving finding surrounding (delete, replace, find,
+---   highlight) can be used with suffix that changes search method to find
+---   previous/last. See more in |MiniSurround.config|.
+---
+--- Known issues which won't be resolved:
+--- - Search for surrounding is done using Lua patterns (regex-like approach).
+---   So certain amount of false positives should be expected.
+---
+--- - When searching for "input" surrounding, there is no distinction if it is
+---   inside string or comment. So in this case there will be not proper match
+---   for a function call: 'f(a = ")", b = 1)'.
+---
+--- - Tags are searched using regex-like methods, so issues are inevitable.
+---   Overall it is pretty good, but certain cases won't work. Like self-nested
+---   tags won't match correctly on both ends: '<a><a></a></a>'.
+---
+--- # Setup~
+---
+--- This module needs a setup with `require('mini.surround').setup({})`
+--- (replace `{}` with your `config` table). It will create global Lua table
+--- `MiniSurround` which you can use for scripting or manually (with
+--- `:lua MiniSurround.*`).
+---
+--- See |MiniSurround.config| for `config` structure and default values.
+---
+--- You can override runtime config settings locally to buffer inside
+--- `vim.b.minisurround_config` which should have same structure as
+--- `MiniSurround.config`. See |mini.nvim-buffer-local-config| for more details.
+---
+--- To stop module from showing non-error feedback, set `config.silent = true`.
+---
+--- # Example usage~
+---
+--- Regular mappings:
+--- - `saiw)` - add (`sa`) for inner word (`iw`) parenthesis (`)`).
+--- - `saiw?[[<CR>]]<CR>` - add (`sa`) for inner word (`iw`) interactive
+---   surrounding (`?`): `[[` for left and `]]` for right.
+--- - `2sdf` - delete (`sd`) second (`2`) surrounding function call (`f`).
+--- - `sr)tdiv<CR>` - replace (`sr`) surrounding parenthesis (`)`) with tag
+---   (`t`) with identifier 'div' (`div<CR>` in command line prompt).
+--- - `sff` - find right (`sf`) part of surrounding function call (`f`).
+--- - `sh}` - highlight (`sh`) for a brief period of time surrounding curly
+---   brackets (`}`).
+---
+--- Extended mappings (temporary force "prev"/"next" search methods):
+--- - `sdnf` - delete (`sd`) next (`n`) function call (`f`).
+--- - `srlf(` - replace (`sd`) last (`l`) function call (`f`) with padded
+---   bracket (`(`).
+--- - `2sfnt` - find (`sf`) second (2) next (`n`) tag (`t`).
+--- - `shl}` - highlight (`sh`) last (`l`) second (`2`) curly bracket (`}`).
+---
+--- # Comparisons~
+---
+--- - 'tpope/vim-surround':
+---     - 'vim-surround' has completely different, with other focus set of
+---       default mappings, while 'mini.surround' has a more coherent set.
+---     - 'mini.surround' supports dot-repeat, customized search path (see
+---       |MiniSurround.config|), customized specifications (see
+---       |MiniSurround-surround-specification|) allowing usage of tree-sitter
+---       queries (see |MiniSurround.gen_spec.input.treesitter()|),
+---       highlighting and finding surrounding, "last"/"next" extended
+---       mappings. While 'vim-surround' does not.
+--- - 'machakann/vim-sandwich':
+---     - Both have same keybindings for common actions (add, delete, replace).
+---     - Otherwise same differences as with 'tpop/vim-surround' (except
+---       dot-repeat because 'vim-sandwich' supports it).
+--- - 'kylechui/nvim-surround':
+---     - 'nvim-surround' is designed after 'tpope/vim-surround' with same
+---       default mappings and logic, while 'mini.surround' has mappings
+---       similar to 'machakann/vim-sandwich'.
+---     - 'mini.surround' has more flexible customization of input surrounding
+---       (with composed patterns, region pair(s), search methods).
+---     - 'mini.surround' supports |[count]| in both input and output
+---       surrounding (see |MiniSurround-count|) while 'nvim-surround' doesn't.
+---     - 'mini.surround' supports "last"/"next" extended mappings.
+--- - |mini.ai|:
+---     - Both use similar logic for finding target: textobject in 'mini.ai'
+---       and surrounding pair in 'mini.surround'. While 'mini.ai' uses
+---       extraction pattern for separate `a` and `i` textobjects,
+---       'mini.surround' uses it to select left and right surroundings
+---       (basically a difference between `a` and `i` textobjects).
+---     - Some builtin specifications are slightly different:
+---         - Quotes in 'mini.ai' are balanced, in 'mini.surround' they are not.
+---         - The 'mini.surround' doesn't have argument surrounding.
+---         - Default behavior in 'mini.ai' selects one of the edges into `a`
+---           textobject, while 'mini.surround' - both.
+---
+--- # Highlight groups~
+---
+--- * `MiniSurround` - highlighting of requested surrounding.
+---
+--- To change any highlight group, modify it directly with |:highlight|.
+---
+--- # Disabling~
+---
+--- To disable, set `vim.g.minisurround_disable` (globally) or
+--- `vim.b.minisurround_disable` (for a buffer) to `true`. Considering high
+--- number of different scenarios and customization intentions, writing exact
+--- rules for disabling module's functionality is left to user. See
+--- |mini.nvim-disabling-recipes| for common recipes.
+
+--- Builtin surroundings~
+---
+--- This table describes all builtin surroundings along with what they
+--- represent. Explanation:
+--- - `Key` represents the surrounding identifier: single character which should
+---   be typed after action mappings (see |MiniSurround.config.mappings|).
+--- - `Name` is a description of surrounding.
+--- - `Example line` contains a string for which examples are constructed. The
+---   `*` denotes the cursor position over `a` character.
+--- - `Delete` shows the result of typing `sd` followed by surrounding identifier.
+---   It aims to demonstrate "input" surrounding which is also used in replace
+---   with `sr` (surrounding id is typed first), highlight with `sh`, find with
+---   `sf` and `sF`.
+--- - `Replace` shows the result of typing `sr!` followed by surrounding
+---   identifier (with possible follow up from user). It aims to demonstrate
+---   "output" surrounding which is also used in adding with `sa` (followed by
+---   textobject/motion or in Visual mode).
+---
+--- Example: typing `sd)` with cursor on `*` (covers `a` character) changes line
+--- `!( *a (bb) )!` into `! aa (bb) !`. Typing `sr!)` changes same initial line
+--- into `(( aa (bb) ))`.
+--- >
+---  |Key|     Name      |  Example line |    Delete   |     Replace     |
+---  |---|---------------|---------------|-------------|-----------------|
+---  | ( |  Balanced ()  | !( *a (bb) )! |  !aa (bb)!  | ( ( aa (bb) ) ) |
+---  | [ |  Balanced []  | ![ *a [bb] ]! |  !aa [bb]!  | [ [ aa [bb] ] ] |
+---  | { |  Balanced {}  | !{ *a {bb} }! |  !aa {bb}!  | { { aa {bb} } } |
+---  | < |  Balanced <>  | !< *a <bb> >! |  !aa <bb>!  | < < aa <bb> > > |
+---  |---|---------------|---------------|-------------|-----------------|
+---  | ) |  Balanced ()  | !( *a (bb) )! | ! aa (bb) ! | (( aa (bb) ))   |
+---  | ] |  Balanced []  | ![ *a [bb] ]! | ! aa [bb] ! | [[ aa [bb] ]]   |
+---  | } |  Balanced {}  | !{ *a {bb} }! | ! aa {bb} ! | {{ aa {bb} }}   |
+---  | > |  Balanced <>  | !< *a <bb> >! | ! aa <bb> ! | << aa <bb> >>   |
+---  | b |  Alias for    | !( *a {bb} )! | ! aa {bb} ! | (( aa {bb} ))   |
+---  |   |  ), ], or }   |               |             |                 |
+---  |---|---------------|---------------|-------------|-----------------|
+---  | q |  Alias for    | !'aa'*a'aa'!  | !'aaaaaa'!  | "'aa'aa'aa'"    |
+---  |   |  ", ', or `   |               |             |                 |
+---  |---|---------------|---------------|-------------|-----------------|
+---  | ? |  User prompt  | !e * o!       | ! a !       | ee a oo         |
+---  |   |(typed e and o)|               |             |                 |
+---  |---|---------------|---------------|-------------|-----------------|
+---  | t |      Tag      | !<x>*</x>!    | !a!         | <y><x>a</x></y> |
+---  |   |               |               |             | (typed y)       |
+---  |---|---------------|---------------|-------------|-----------------|
+---  | f | Function call | !f(*a, bb)!   | !aa, bb!    | g(f(*a, bb))    |
+---  |   |               |               |             | (typed g)       |
+---  |---|---------------|---------------|-------------|-----------------|
+---  |   |    Default    | !_a*a_!       | !aaa!       | __aaa__         |
+---  |   |   (typed _)   |               |             |                 |
+---  |---|---------------|---------------|-------------|-----------------|
+--- <
+--- Notes:
+--- - All examples assume default `config.search_method`.
+--- - Open brackets differ from close brackets by how they treat inner edge
+---   whitespace: open includes it left and right parts, close does not.
+--- - Output value of `b` alias is same as `)`. For `q` alias - same as `"`.
+--- - Default surrounding is activated for all characters which are not
+---   configured surrounding identifiers. Note: due to special handling of
+---   underlying `x.-x` Lua pattern (see |MiniSurround-search-algorithm|), it
+---   doesn't really support non-trivial `[count]` for "cover" search method.
+---@tag MiniSurround-surround-builtin
+
+--- Note: this is similar to |MiniAi-glossary|.
+---
+--- - REGION - table representing region in a buffer. Fields: <from> and
+---   <to> for inclusive start and end positions (<to> might be `nil` to
+---   describe empty region). Each position is also a table with line <line>
+---   and column <col> (both start at 1). Examples:
+---   - `{ from = { line = 1, col = 1 }, to = { line = 2, col = 1 } }`
+---   - `{ from = { line = 10, col = 10 } }` - empty region.
+--- - REGION PAIR - table representing regions for left and right surroundings.
+---   Fields: <left> and <right> with regions. Examples:
+---   `{`
+---     `left  = { from = { line = 1, col = 1 }, to = { line = 1, col = 1 } },`
+---     `right = { from = { line = 1, col = 3 } },`
+---   `}`
+--- - PATTERN - string describing Lua pattern.
+--- - SPAN - interval inside a string (end-exclusive). Like [1, 5). Equal
+---   `from` and `to` edges describe empty span at that point.
+--- - SPAN `A = [a1, a2)` COVERS `B = [b1, b2)` if every element of
+---   `B` is within `A` (`a1 <= b < a2`).
+---   It also is described as B IS NESTED INSIDE A.
+--- - NESTED PATTERN - array of patterns aimed to describe nested spans.
+--- - SPAN MATCHES NESTED PATTERN if there is a sequence of consecutively
+---   nested spans each matching corresponding pattern within substring of
+---   previous span (or input string for first span). Example:
+---     Nested patterns: `{ '%b()', '^. .* .$' }` (balanced `()` with inner space)
+---     Input string: `( ( () ( ) ) )`
+---                   `123456789012345`
+---   Here are all matching spans [1, 15) and [3, 13). Both [5, 7) and [8, 10)
+---   match first pattern but not second. All other combinations of `(` and `)`
+---   don't match first pattern (not balanced).
+--- - COMPOSED PATTERN: array with each element describing possible pattern
+---   (or array of them) at that place. Composed pattern basically defines all
+---   possible combinations of nested pattern (their cartesian product).
+---   Examples:
+---     1. Composed pattern: `{ { '%b()', '%b[]' }, '^. .* .$' }`
+---        Composed pattern expanded into equivalent array of nested patterns:
+---         `{ '%b()', '^. .* .$' }` and `{ '%b[]', '^. .* .$' }`
+---        Description: either balanced `()` or balanced `[]` but both with
+---        inner edge space.
+---     2. Composed pattern:
+---        `{ { { '%b()', '^. .* .$' }, { '%b[]', '^.[^ ].*[^ ].$' } }, '.....' }`
+---        Composed pattern expanded into equivalent array of nested patterns:
+---        `{ '%b()', '^. .* .$', '.....' }` and
+---        `{ '%b[]', '^.[^ ].*[^ ].$', '.....' }`
+---        Description: either "balanced `()` with inner edge space" or
+---        "balanced `[]` with no inner edge space", both with 5 or more characters.
+--- - SPAN MATCHES COMPOSED PATTERN if it matches at least one nested pattern
+---   from expanded composed pattern.
+---@tag MiniSurround-glossary
+
+--- Surround specification is a table with keys:
+--- - <input> - defines how to find and extract surrounding for "input"
+---   operations (like `delete`). See more in 'Input surrounding' setction.
+--- - <output> - defines what to add on left and right for "output" operations
+---   (like `add`). See more in 'Output surrounding' section.
+---
+--- Example of surround info for builtin `)` identifier: >
+---   {
+---     input = { '%b()', '^.().*().$' },
+---     output = { left = '(', right = ')' }
+---   }
+--- <
+--- # Input surrounding ~
+---
+--- Specification for input surrounding has a structure of composed pattern
+--- (see |MiniSurround-glossary|) with two differences:
+--- - Last pattern(s) should have two or four empty capture groups denoting
+---   how the last string should be processed to extract surrounding parts:
+---     - Two captures represent left part from start of string to first
+---       capture and right part - from second capture to end of string.
+---       Example: `a()b()c` defines left surrounding as 'a', right - 'c'.
+---     - Four captures define left part inside captures 1 and 2, right part -
+---       inside captures 3 and 4. Example: `a()()b()c()` defines left part as
+---       empty, right part as 'c'.
+--- - Allows callable objects (see |vim.is_callable()|) in certain places
+---   (enables more complex surroundings in exchange of increase in configuration
+---   complexity and computations):
+---     - If specification itself is a callable, it will be called without
+---       arguments and should return one of:
+---         - Composed pattern. Useful for implementing user input. Example of
+---           simplified variant of input surrounding for function call with
+---           name taken from user prompt:
+--- >
+---           function()
+---             local left_edge = vim.pesc(vim.fn.input('Function name: '))
+---             return { string.format('%s+%%b()', left_edge), '^.-%(().*()%)$' }
+---           end
+--- <
+---         - Single region pair (see |MiniSurround-glossary|). Useful to allow
+---           full control over surrounding. Will be taken as is. Example of
+---           returning first and last lines of a buffer:
+--- >
+---           function()
+---             local n_lines = vim.fn.line('$')
+---             return {
+---               left = {
+---                 from = { line = 1, col = 1 },
+---                 to = { line = 1, col = vim.fn.getline(1):len() },
+---               },
+---               right = {
+---                 from = { line = n_lines, col = 1 },
+---                 to = { line = n_lines, col = vim.fn.getline(n_lines):len() },
+---               },
+---             }
+---           end
+--- <
+---         - Array of region pairs. Useful for incorporating other instruments,
+---           like treesitter (see |MiniSurround.gen_spec.treesitter()|). The
+---           best region pair will be picked in the same manner as with composed
+---           pattern (respecting options `n_lines`, `search_method`, etc.) using
+---           output region (from start of left region to end of right region).
+---           Example using edges of "best" line with display width more than 80:
+--- >
+---           function()
+---             local make_line_region_pair = function(n)
+---               local left = { line = n, col = 1 }
+---               local right = { line = n, col = vim.fn.getline(n):len() }
+---               return {
+---                 left = { from = left, to = left },
+---                 right = { from = right, to = right },
+---               }
+---             end
+---
+---             local res = {}
+---             for i = 1, vim.fn.line('$') do
+---               if vim.fn.getline(i):len() > 80 then
+---                 table.insert(res, make_line_region_pair(i))
+---               end
+---             end
+---             return res
+---           end
+--- <
+---     - If there is a callable instead of assumed string pattern, it is expected
+---       to have signature `(line, init)` and behave like `pattern:find()`.
+---       It should return two numbers representing span in `line` next after
+---       or at `init` (`nil` if there is no such span).
+---       !IMPORTANT NOTE!: it means that output's `from` shouldn't be strictly
+---       to the left of `init` (it will lead to infinite loop). Not allowed as
+---       last item (as it should be pattern with captures).
+---       Example of matching only balanced parenthesis with big enough width:
+--- >
+---         {
+---           '%b()',
+---           function(s, init)
+---             if init > 1 or s:len() < 5 then return end
+---             return 1, s:len()
+---           end,
+---           '^.().*().$'
+---         }
+--- >
+--- More examples:
+--- - See |MiniSurround.gen_spec| for function wrappers to create commonly used
+---   surrounding specifications.
+---
+--- - Pair of balanced brackets from set (used for builtin `b` identifier):
+---   `{ { '%b()', '%b[]', '%b{}' }, '^.().*().$' }`
+---
+--- - Lua block string: `{ '%[%[().-()%]%]' }`
+---
+--- # Output surrounding ~
+---
+--- A table with <left> (plain text string) and <right> (plain text string)
+--- fields. Strings can contain new lines character `\n` to add multiline parts.
+---
+--- Examples:
+--- - Lua block string: `{ left = '[[', right = ']]' }`
+--- - Brackets on separate lines (indentation is not preserved):
+---   `{ left = '(\n', right = '\n)' }`
+---@tag MiniSurround-surround-specification
+
+--- Count with actions
+---
+--- |[count]| is supported by all actions in the following ways:
+---
+--- - In add, two types of `[count]` is supported in Normal mode:
+---   `[count1]sa[count2][textobject]`. The `[count1]` defines how many times
+---   left and right parts of output surrounding will be repeated and `[count2]` is
+---   used for textobject.
+---   In Visual mode `[count]` is treated as `[count1]`.
+---   Example: `2sa3aw)` and `v3aw2sa)` will result into textobject `3aw` being
+---   surrounded by `((` and `))`.
+---
+--- - In delete/replace/find/highlight `[count]` means "find n-th surrounding
+---   and execute operator on it".
+---   Example: `2sd)` on line `(a(b(c)b)a)` with cursor on `c` will result into
+---   `(ab(c)ba)` (and not in `(abcba)` if it would have meant "delete n times").
+---@tag MiniSurround-count
+
+--- Search algorithm design
+---
+--- Search for the input surrounding relies on these principles:
+--- - Input surrounding specification is constructed based on surrounding
+---   identifier (see |MiniSurround-surround-specification|).
+--- - General search is done by converting some 2d buffer region (neighborhood
+---   of reference region) into 1d string (each line is appended with `\n`).
+---   Then search for a best span matching specification is done inside string
+---   (see |MiniSurround-glossary|). After that, span is converted back into 2d
+---   region. Note: first search is done inside reference region lines, and
+---   only after that - inside its neighborhood within `config.n_lines` (see
+---   |MiniSurround.config|).
+--- - The best matching span is chosen by iterating over all spans matching
+---   surrounding specification and comparing them with "current best".
+---   Comparison also depends on reference region (tighter covering is better,
+---   otherwise closer is better) and search method (if span is even considered).
+--- - Extract pair of spans (for left and right regions in region pair) based
+---   on extraction pattern (last item in nested pattern).
+--- - For |[count]| greater than 1, steps are repeated with current best match
+---   becoming reference region. One such additional step is also done if final
+---   region is equal to reference region.
+---
+--- Notes:
+--- - Iteration over all matched spans is done in depth-first fashion with
+---   respect to nested pattern.
+--- - It is guaranteed that span is compared only once.
+--- - For the sake of increasing functionality, during iteration over all
+---   matching spans, some Lua patterns in composed pattern are handled
+---   specially.
+---     - `%bxx` (`xx` is two identical characters). It denotes balanced pair
+---       of identical characters and results into "paired" matches. For
+---       example, `%b""` for `"aa" "bb"` would match `"aa"` and `"bb"`, but
+---       not middle `" "`.
+---     - `x.-y` (`x` and `y` are different strings). It results only in matches with
+---       smallest width. For example, `e.-o` for `e e o o` will result only in
+---       middle `e o`. Note: it has some implications for when parts have
+---       quantifiers (like `+`, etc.), which usually can be resolved with
+---       frontier pattern `%f[]`.
+---@tag MiniSurround-search-algorithm
+
+-- Module definition ==========================================================
+local MiniSurround = {}
+local H = {}
+
+--- Module setup
+---
+---@param config table|nil Module config table. See |MiniSurround.config|.
+---
+---@usage `require('mini.surround').setup({})` (replace `{}` with your `config` table)
+MiniSurround.setup = function(config)
+  -- Export module
+  _G.MiniSurround = MiniSurround
+
+  -- Setup config
+  config = H.setup_config(config)
+
+  -- Apply config
+  H.apply_config(config)
+
+  -- Create default highlighting
+  H.create_default_hl()
+end
+
+--- Module config
+---
+--- Default values:
+---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
+---@text                                               *MiniSurround-vim-surround-config*
+--- # Setup similar to 'tpope/vim-surround'~
+---
+--- This module is primarily designed after 'machakann/vim-sandwich'. To get
+--- behavior closest to 'tpope/vim-surround' (but not identical), use this setup:
+--- >
+---   require('mini.surround').setup({
+---     mappings = {
+---       add = 'ys',
+---       delete = 'ds',
+---       find = '',
+---       find_left = '',
+---       highlight = '',
+---       replace = 'cs',
+---       update_n_lines = '',
+---
+---       -- Add this only if you don't want to use extended mappings
+---       suffix_last = '',
+---       suffix_next = '',
+---     },
+---     search_method = 'cover_or_next',
+---   })
+---
+---   -- Remap adding surrounding to Visual mode selection
+---   vim.keymap.del('x', 'ys')
+---   vim.keymap.set('x', 'S', [[:<C-u>lua MiniSurround.add('visual')<CR>]], { silent = true })
+---
+---   -- Make special mapping for "add surrounding for line"
+---   vim.keymap.set('n', 'yss', 'ys_', { remap = true })
+--- <
+--- # Options~
+---
+--- ## Custom surroundings~
+---
+--- User can define own surroundings by supplying `config.custom_surroundings`.
+--- It should be a **table** with keys being single character surrounding
+--- identifier and values - surround specification (see
+--- |MiniSurround-surround-specification|).
+---
+--- General recommendations:
+--- - In `config.custom_surroundings` only some data can be defined (like only
+---   `output`). Other fields will be taken from builtin surroundings.
+--- - Function returning surround info at <input> or <output> fields of
+---   specification is helpful when user input is needed (like asking for
+---   function name). Use |input()| or |MiniSurround.user_input()|. Return
+---   `nil` to stop any current surround operation.
+---
+--- Examples of using `config.custom_surroundings` (see more examples at
+--- |MiniSurround.gen_spec|):
+--- >
+---   local surround = require('mini.surround')
+---   surround.setup({
+---     custom_surroundings = {
+---       -- Make `)` insert parts with spaces. `input` pattern stays the same.
+---       [')'] = { output = { left = '( ', right = ' )' } },
+---
+---       -- Use function to compute surrounding info
+---       ['*'] = {
+---         input = function()
+---           local n_star = MiniSurround.user_input('Number of * to find: ')
+---           local many_star = string.rep('%*', tonumber(n_star) or 1)
+---           return { many_star .. '().-()' .. many_star }
+---         end,
+---         output = function()
+---           local n_star = MiniSurround.user_input('Number of * to output: ')
+---           local many_star = string.rep('*', tonumber(n_star) or 1)
+---           return { left = many_star, right = many_star }
+---         end,
+---       },
+---     },
+---   })
+---
+---   -- Create custom surrounding for Lua's block string `[[...]]`. Use this inside
+---   -- autocommand or 'after/ftplugin/lua.lua' file.
+---   vim.b.minisurround_config = {
+---     custom_surroundings = {
+---       s = {
+---         input = { '%[%[().-()%]%]' },
+---         output = { left = '[[', right = ']]' },
+---       },
+---     },
+---   }
+--- <
+--- ## Respect selection type ~
+---
+--- Boolean option `config.respect_selection_type` controls whether to respect
+--- selection type when adding and deleting surrounding. When enabled:
+--- - Linewise adding places surroundings on separate lines while indenting
+---   surrounded lines ones.
+--- - Deleting surroundings which look like they were the result of linewise
+---   adding will act to revert it: delete lines with surroundings and dedent
+---   surrounded lines ones.
+--- - Blockwise adding places surroundings on whole edges, not only start and
+---   end of selection. Note: it doesn't really work outside of text and in
+---   presence of multibyte characters; and probably won't due to
+---   implementation difficulties.
+---
+--- ## Search method ~
+---
+--- Value of `config.search_method` defines how best match search is done.
+--- Based on its value, one of the following matches will be selected:
+--- - Covering match. Left/right edge is before/after left/right edge of
+---   reference region.
+--- - Previous match. Left/right edge is before left/right edge of reference
+---   region.
+--- - Next match. Left/right edge is after left/right edge of reference region.
+--- - Nearest match. Whichever is closest among previous and next matches.
+---
+--- Possible values are:
+--- - `'cover'` - use only covering match. Don't use either previous or
+---   next; report that there is no surrounding found.
+--- - `'cover_or_next'` (default) - use covering match. If not found, use next.
+--- - `'cover_or_prev'` - use covering match. If not found, use previous.
+--- - `'cover_or_nearest'` - use covering match. If not found, use nearest.
+--- - `'next'` - use next match.
+--- - `'previous'` - use previous match.
+--- - `'nearest'` - use nearest match.
+---
+--- Note: search is first performed on the reference region lines and only
+--- after failure - on the whole neighborhood defined by `config.n_lines`. This
+--- means that with `config.search_method` not equal to `'cover'`, "previous"
+--- or "next" surrounding will end up as search result if they are found on
+--- first stage although covering match might be found in bigger, whole
+--- neighborhood. This design is based on observation that most of the time
+--- operation is done within reference region lines (usually cursor line).
+---
+--- Here is an example of how replacing `)` with `]` surrounding is done based
+--- on a value of `'config.search_method'` when cursor is inside `bbb` word:
+--- - `'cover'`:         `(a) bbb (c)` -> `(a) bbb (c)` (with message)
+--- - `'cover_or_next'`: `(a) bbb (c)` -> `(a) bbb [c]`
+--- - `'cover_or_prev'`: `(a) bbb (c)` -> `[a] bbb (c)`
+--- - `'cover_or_nearest'`: depends on cursor position.
+---   For first and second `b` - as in `cover_or_prev` (as previous match is
+---   nearer), for third - as in `cover_or_next` (as next match is nearer).
+--- - `'next'`:          `(a) bbb (c)` -> `(a) bbb [c]`. Same outcome for `(bbb)`.
+--- - `'prev'`:          `(a) bbb (c)` -> `[a] bbb (c)`. Same outcome for `(bbb)`.
+--- - `'nearest'`: depends on cursor position (same as in `'cover_or_nearest'`).
+---
+--- ## Search suffixes~
+---
+--- To provide more searching possibilities, 'mini.surround' creates extended
+--- mappings force "prev" and "next" methods for particular search. It does so
+--- by appending mapping with certain suffix: `config.mappings.suffix_last` for
+--- mappings which will use "prev" search method, `config.mappings.suffix_next`
+--- - "next" search method.
+---
+--- Notes:
+--- - It creates new mappings only for actions involving surrounding search:
+---   delete, replace, find (right and left), highlight.
+--- - All new mappings behave the same way as if `config.search_method` is set
+---   to certain search method. They are dot-repeatable, respect |[count]|, etc.
+--- - Supply empty string to disable creation of corresponding set of mappings.
+---
+--- Example with default values (`n` for `suffix_next`, `l` for `suffix_last`)
+--- and initial line `(aa) (bb) (cc)`.
+--- - Typing `sdn)` with cursor inside `(aa)` results into `(aa) bb (cc)`.
+--- - Typing `sdl)` with cursor inside `(cc)` results into `(aa) bb (cc)`.
+--- - Typing `2srn)]` with cursor inside `(aa)` results into `(aa) (bb) [cc]`.
+MiniSurround.config = {
+  -- Add custom surroundings to be used on top of builtin ones. For more
+  -- information with examples, see `:h MiniSurround.config`.
+  custom_surroundings = nil,
+
+  -- Duration (in ms) of highlight when calling `MiniSurround.highlight()`
+  highlight_duration = 500,
+
+  -- Module mappings. Use `''` (empty string) to disable one.
+  mappings = {
+    add = 'sa', -- Add surrounding in Normal and Visual modes
+    delete = 'sd', -- Delete surrounding
+    find = 'sf', -- Find surrounding (to the right)
+    find_left = 'sF', -- Find surrounding (to the left)
+    highlight = 'sh', -- Highlight surrounding
+    replace = 'sr', -- Replace surrounding
+    update_n_lines = 'sn', -- Update `n_lines`
+
+    suffix_last = 'l', -- Suffix to search with "prev" method
+    suffix_next = 'n', -- Suffix to search with "next" method
+  },
+
+  -- Number of lines within which surrounding is searched
+  n_lines = 20,
+
+  -- Whether to respect selection type:
+  -- - Place surroundings on separate lines in linewise mode.
+  -- - Place surroundings on each line in blockwise mode.
+  respect_selection_type = false,
+
+  -- How to search for surrounding (first inside current line, then inside
+  -- neighborhood). One of 'cover', 'cover_or_next', 'cover_or_prev',
+  -- 'cover_or_nearest', 'next', 'prev', 'nearest'. For more details,
+  -- see `:h MiniSurround.config`.
+  search_method = 'cover',
+
+  -- Whether to disable showing non-error feedback
+  silent = false,
+}
+--minidoc_afterlines_end
+
+-- Module functionality =======================================================
+--- Add surrounding
+---
+--- No need to use it directly, everything is setup in |MiniSurround.setup|.
+---
+---@param mode string Mapping mode (normal by default).
+MiniSurround.add = function(mode)
+  -- Needed to disable in visual mode
+  if H.is_disabled() then return '<Esc>' end
+
+  -- Get marks' positions based on current mode
+  local marks = H.get_marks_pos(mode)
+
+  -- Get surround info. Try take from cache only in not visual mode (as there
+  -- is no intended dot-repeatability).
+  local surr_info
+  if mode == 'visual' then
+    surr_info = H.get_surround_spec('output', false)
+  else
+    surr_info = H.get_surround_spec('output', true)
+  end
+  if surr_info == nil then return '<Esc>' end
+
+  -- Extend parts based on provided `[count]` before operator (if this is not
+  -- from dot-repeat and was done already)
+  if not surr_info.did_count then
+    local count = H.cache.count or vim.v.count1
+    surr_info.left, surr_info.right = surr_info.left:rep(count), surr_info.right:rep(count)
+    surr_info.did_count = true
+  end
+
+  -- Add surrounding.
+  -- Possibly deal with linewise and blockwise addition separately
+  local respect_selection_type = H.get_config().respect_selection_type
+
+  if not respect_selection_type or marks.selection_type == 'charwise' then
+    -- Begin insert from right to not break column numbers
+    -- Insert after the right mark (`+ 1` is for that)
+    H.region_replace({ from = { line = marks.second.line, col = marks.second.col + 1 } }, surr_info.right)
+    H.region_replace({ from = marks.first }, surr_info.left)
+
+    -- Set cursor to be on the right of left surrounding
+    H.set_cursor(marks.first.line, marks.first.col + surr_info.left:len())
+
+    return
+  end
+
+  if marks.selection_type == 'linewise' then
+    local from_line, to_line = marks.first.line, marks.second.line
+
+    -- Save current range indent and indent surrounded lines
+    local init_indent = H.get_range_indent(from_line, to_line)
+    H.shift_indent('>', from_line, to_line)
+
+    -- Put cursor on the start of first surrounded line
+    H.set_cursor_nonblank(from_line)
+
+    -- Put surroundings on separate lines
+    vim.fn.append(to_line, init_indent .. surr_info.right)
+    vim.fn.append(from_line - 1, init_indent .. surr_info.left)
+
+    return
+  end
+
+  if marks.selection_type == 'blockwise' then
+    -- NOTE: this doesn't work with mix of multibyte and normal characters, as
+    -- well as outside of text lines.
+    local from_col, to_col = marks.first.col, marks.second.col
+    -- - Ensure that `to_col` is to the right of `from_col`. Can be not the
+    --   case if visual block was selected from "south-west" to "north-east".
+    from_col, to_col = math.min(from_col, to_col), math.max(from_col, to_col)
+
+    for i = marks.first.line, marks.second.line do
+      H.region_replace({ from = { line = i, col = to_col + 1 } }, surr_info.right)
+      H.region_replace({ from = { line = i, col = from_col } }, surr_info.left)
+    end
+
+    H.set_cursor(marks.first.line, from_col + surr_info.left:len())
+
+    return
+  end
+end
+
+--- Delete surrounding
+---
+--- No need to use it directly, everything is setup in |MiniSurround.setup|.
+MiniSurround.delete = function()
+  -- Find input surrounding region
+  local surr = H.find_surrounding(H.get_surround_spec('input', true))
+  if surr == nil then return '<Esc>' end
+
+  -- Delete surrounding region. Begin with right to not break column numbers.
+  H.region_replace(surr.right, {})
+  H.region_replace(surr.left, {})
+
+  -- Set cursor to be on the right of deleted left surrounding
+  local from = surr.left.from
+  H.set_cursor(from.line, from.col)
+
+  -- Possibly tweak deletion of linewise surrounding. Should act as reverse to
+  -- linewise addition.
+  if not H.get_config().respect_selection_type then return end
+
+  local from_line, to_line = surr.left.from.line, surr.right.from.line
+  local is_linewise_delete = from_line < to_line and H.is_line_blank(from_line) and H.is_line_blank(to_line)
+  if is_linewise_delete then
+    -- Dedent surrounded lines
+    H.shift_indent('<', from_line, to_line)
+
+    -- Place cursor on first surrounded line
+    H.set_cursor_nonblank(from_line + 1)
+
+    -- Delete blank lines left after deleting surroundings
+    local buf_id = vim.api.nvim_get_current_buf()
+    vim.fn.deletebufline(buf_id, to_line)
+    vim.fn.deletebufline(buf_id, from_line)
+  end
+end
+
+--- Replace surrounding
+---
+--- No need to use it directly, everything is setup in |MiniSurround.setup|.
+MiniSurround.replace = function()
+  -- Find input surrounding region
+  local surr = H.find_surrounding(H.get_surround_spec('input', true))
+  if surr == nil then return '<Esc>' end
+
+  -- Get output surround info
+  local new_surr_info = H.get_surround_spec('output', true)
+  if new_surr_info == nil then return '<Esc>' end
+
+  -- Replace by parts starting from right to not break column numbers
+  H.region_replace(surr.right, new_surr_info.right)
+  H.region_replace(surr.left, new_surr_info.left)
+
+  -- Set cursor to be on the right of left surrounding
+  local from = surr.left.from
+  H.set_cursor(from.line, from.col + new_surr_info.left:len())
+end
+
+--- Find surrounding
+---
+--- No need to use it directly, everything is setup in |MiniSurround.setup|.
+MiniSurround.find = function()
+  -- Find surrounding region
+  local surr = H.find_surrounding(H.get_surround_spec('input', true))
+  if surr == nil then return '<Esc>' end
+
+  -- Make array of unique positions to cycle through
+  local pos_array = H.surr_to_pos_array(surr)
+
+  -- Cycle cursor through positions
+  local dir = H.cache.direction or 'right'
+  H.cursor_cycle(pos_array, dir)
+
+  -- Open 'enough folds' to show cursor
+  vim.cmd('normal! zv')
+end
+
+--- Highlight surrounding
+---
+--- No need to use it directly, everything is setup in |MiniSurround.setup|.
+MiniSurround.highlight = function()
+  -- Find surrounding region
+  local surr = H.find_surrounding(H.get_surround_spec('input', true))
+  if surr == nil then return '<Esc>' end
+
+  -- Highlight surrounding region
+  local config = H.get_config()
+  local buf_id = vim.api.nvim_get_current_buf()
+
+  H.region_highlight(buf_id, surr.left)
+  H.region_highlight(buf_id, surr.right)
+
+  vim.defer_fn(function()
+    H.region_unhighlight(buf_id, surr.left)
+    H.region_unhighlight(buf_id, surr.right)
+  end, config.highlight_duration)
+end
+
+--- Update `MiniSurround.config.n_lines`
+---
+--- Convenient wrapper for updating `MiniSurround.config.n_lines` in case the
+--- default one is not appropriate.
+MiniSurround.update_n_lines = function()
+  if H.is_disabled() then return '<Esc>' end
+
+  local n_lines = MiniSurround.user_input('New number of neighbor lines', MiniSurround.config.n_lines)
+  n_lines = math.floor(tonumber(n_lines) or MiniSurround.config.n_lines)
+  MiniSurround.config.n_lines = n_lines
+end
+
+--- Ask user for input
+---
+--- This is mainly a wrapper for |input()| which allows empty string as input,
+--- cancelling with `<Esc>` and `<C-c>`, and slightly modifies prompt. Use it
+--- to ask for input inside function custom surrounding (see |MiniSurround.config|).
+MiniSurround.user_input = function(prompt, text)
+  -- Major issue with both `vim.fn.input()` is that the only way to distinguish
+  -- cancelling with `<Esc>` and entering empty string with immediate `<CR>` is
+  -- through `cancelreturn` option (see `:h input()`). In that case the return
+  -- of `cancelreturn` will mean actual cancel, which removes possibility of
+  -- using that string. Although doable with very obscure string, this is not
+  -- very clean.
+  -- Overcome this by adding temporary keystroke listener.
+  local on_key = vim.on_key or vim.register_keystroke_callback
+  local was_cancelled = false
+  on_key(function(key)
+    if key == vim.api.nvim_replace_termcodes('<Esc>', true, true, true) then was_cancelled = true end
+  end, H.ns_id.input)
+
+  -- Ask for input
+  -- NOTE: it would be GREAT to make this work with `vim.ui.input()` but I
+  -- didn't find a way to make it work without major refactor of whole module.
+  -- The main issue is that `vim.ui.input()` is designed to perform action in
+  -- callback and current module design is to get output immediately. Although
+  -- naive approach of
+  -- `local res; vim.ui.input({...}, function(input) res = input end)`
+  -- works in default `vim.ui.input`, its reimplementations can return from it
+  -- immediately and proceed in main event loop. Couldn't find a relatively
+  -- simple way to stop execution of this current function until `ui.input()`'s
+  -- callback finished execution.
+  local opts = { prompt = '(mini.surround) ' .. prompt .. ': ', default = text or '' }
+  vim.cmd('echohl Question')
+  -- Use `pcall` to allow `<C-c>` to cancel user input
+  local ok, res = pcall(vim.fn.input, opts)
+  vim.cmd([[echohl None | echo '' | redraw]])
+
+  -- Stop key listening
+  on_key(nil, H.ns_id.input)
+
+  if not ok or was_cancelled then return end
+  return res
+end
+
+--- Generate common surrounding specifications
+---
+--- This is a table with two sets of generator functions: <input> and <output>
+--- (currently empty). Each is a table with values being function generating
+--- corresponding surrounding specification.
+---
+--- Example: >
+---   local ts_input = require('mini.surround').gen_spec.input.treesitter
+---   require('mini.surround').setup({
+---     custom_surroundings = {
+---       -- Use tree-sitter to search for function call
+---       f = {
+---         input = ts_input({ outer = '@call.outer', inner = '@call.inner' })
+---       },
+---     }
+---   })
+---
+---@seealso |MiniAi.gen_spec|
+MiniSurround.gen_spec = { input = {}, output = {} }
+
+--- Treesitter specification for input surrounding
+---
+--- This is a specification in function form. When called with a pair of
+--- treesitter captures, it returns a specification function outputting an
+--- array of region pairs derived from <outer> and <inner> captures. It first
+--- searches for all matched nodes of outer capture and then completes each one
+--- with the biggest match of inner capture inside that node (if any). The result
+--- region pair is a difference between regions of outer and inner captures.
+---
+--- In order for this to work, apart from working treesitter parser for desired
+--- language, user should have a reachable language-specific 'textobjects'
+--- query (see |get_query()|). The most straightforward way for this is to have
+--- 'textobjects.scm' query file with treesitter captures stored in some
+--- recognized path. This is primarily designed to be compatible with
+--- 'nvim-treesitter/nvim-treesitter-textobjects' plugin, but can be used
+--- without it.
+---
+--- Two most common approaches for having a query file:
+--- - Install 'nvim-treesitter/nvim-treesitter-textobjects'. It has curated and
+---   well maintained builtin query files for many languages with a standardized
+---   capture names, like `call.outer`, `call.inner`, etc.
+--- - Manually create file 'after/queries/<language name>/textobjects.scm' in
+---   your |$XDG_CONFIG_HOME| directory. It should contain queries with
+---   captures (later used to define surrounding parts). See |lua-treesitter-query|.
+--- To verify that query file is reachable, run (example for "lua" language)
+--- `:lua print(vim.inspect(vim.treesitter.query.get_files('lua', 'textobjects')))`
+--- (output should have at least an intended file).
+---
+--- Example configuration for function definition textobject with
+--- 'nvim-treesitter/nvim-treesitter-textobjects' captures:
+--- >
+---   local ts_input = require('mini.surround').gen_spec.input.treesitter
+---   require('mini.surround').setup({
+---     custom_textobjects = {
+---       f = ts_input({ outer = '@call.outer', inner = '@call.inner' }),
+---     }
+---   })
+--- >
+---
+--- Notes:
+--- - By default query is done using 'nvim-treesitter' plugin if it is present
+---   (falls back to builtin methods otherwise). This allows for a more
+---   advanced features (like multiple buffer languages, custom directives, etc.).
+---   See `opts.use_nvim_treesitter` for how to disable this.
+--- - It uses buffer's |filetype| to determine query language.
+--- - On large files it is slower than pattern-based textobjects. Still very
+---   fast though (one search should be magnitude of milliseconds or tens of
+---   milliseconds on really large file).
+---
+---@param captures table Captures for outer and inner parts of region pair:
+---   table with <outer> and <inner> fields with captures for outer
+---   (`[left.form; right.to]`) and inner (`(left.to; right.from)` both edges
+---   exclusive, i.e. they won't be a part of surrounding) regions. Each value
+---   should be a string capture starting with `'@'`.
+---@param opts table|nil Options. Possible values:
+---   - <use_nvim_treesitter> - whether to try to use 'nvim-treesitter' plugin
+---     (if present) to do the query. It implements more advanced behavior at
+---     cost of increased execution time. Provides more coherent experience if
+---     'nvim-treesitter-textobjects' queries are used. Default: `true`.
+---
+---@return function Function which returns array of current buffer region pairs
+---   representing differences between outer and inner captures.
+---
+---@seealso |MiniSurround-surround-specification| for how this type of
+---   surrounding specification is processed.
+--- |get_query()| for how query is fetched in case of no 'nvim-treesitter'.
+--- |Query:iter_captures()| for how all query captures are iterated in case of
+---   no 'nvim-treesitter'.
+--- |MiniAi.gen_spec.treesitter()| for similar 'mini.ai' generator.
+MiniSurround.gen_spec.input.treesitter = function(captures, opts)
+  opts = vim.tbl_deep_extend('force', { use_nvim_treesitter = true }, opts or {})
+  captures = H.prepare_captures(captures)
+
+  return function()
+    -- Get array of matched treesitter nodes
+    local has_nvim_treesitter, _ = pcall(require, 'nvim-treesitter')
+    local node_pair_querier = (has_nvim_treesitter and opts.use_nvim_treesitter) and H.get_matched_node_pairs_plugin
+      or H.get_matched_node_pairs_builtin
+    local matched_node_pairs = node_pair_querier(captures)
+
+    -- Return array of region pairs
+    return vim.tbl_map(function(node_pair)
+      -- `node:range()` returns 0-based numbers for end-exclusive region
+      local left_from_line, left_from_col, right_to_line, right_to_col = node_pair.outer:range()
+      local left_from = { line = left_from_line + 1, col = left_from_col + 1 }
+      local right_to = { line = right_to_line + 1, col = right_to_col }
+
+      local left_to, right_from
+      if node_pair.inner == nil then
+        left_to = right_to
+        right_from = H.pos_to_right(right_to)
+        right_to = nil
+      else
+        local left_to_line, left_to_col, right_from_line, right_from_col = node_pair.inner:range()
+        left_to = { line = left_to_line + 1, col = left_to_col + 1 }
+        right_from = { line = right_from_line + 1, col = right_from_col }
+        -- Take into account that inner capture should be both edges exclusive
+        left_to, right_from = H.pos_to_left(left_to), H.pos_to_right(right_from)
+      end
+
+      return { left = { from = left_from, to = left_to }, right = { from = right_from, to = right_to } }
+    end, matched_node_pairs)
+  end
+end
+
+-- Helper data ================================================================
+-- Module default config
+H.default_config = vim.deepcopy(MiniSurround.config)
+
+-- Namespaces to be used within module
+H.ns_id = {
+  highlight = vim.api.nvim_create_namespace('MiniSurroundHighlight'),
+  input = vim.api.nvim_create_namespace('MiniSurroundInput'),
+}
+
+--stylua: ignore
+-- Builtin surroundings
+H.builtin_surroundings = {
+  -- Use balanced pair for brackets. Use opening ones to possibly
+  -- replace/delete innder edge whitespace.
+  ['('] = { input = { '%b()', '^.%s*().-()%s*.$' }, output = { left = '( ', right = ' )' } },
+  [')'] = { input = { '%b()', '^.().*().$' },       output = { left = '(',  right = ')' } },
+  ['['] = { input = { '%b[]', '^.%s*().-()%s*.$' }, output = { left = '[ ', right = ' ]' } },
+  [']'] = { input = { '%b[]', '^.().*().$' },       output = { left = '[',  right = ']' } },
+  ['{'] = { input = { '%b{}', '^.%s*().-()%s*.$' }, output = { left = '{ ', right = ' }' } },
+  ['}'] = { input = { '%b{}', '^.().*().$' },       output = { left = '{',  right = '}' } },
+  ['<'] = { input = { '%b<>', '^.%s*().-()%s*.$' }, output = { left = '< ', right = ' >' } },
+  ['>'] = { input = { '%b<>', '^.().*().$' },       output = { left = '<',  right = '>' } },
+  -- Derived from user prompt
+  ['?'] = {
+    input = function()
+      local left = MiniSurround.user_input('Left surrounding')
+      if left == nil or left == '' then return end
+      local right = MiniSurround.user_input('Right surrounding')
+      if right == nil or right == '' then return end
+
+      return { vim.pesc(left) .. '().-()' .. vim.pesc(right) }
+    end,
+    output = function()
+      local left = MiniSurround.user_input('Left surrounding')
+      if left == nil then return end
+      local right = MiniSurround.user_input('Right surrounding')
+      if right == nil then return end
+      return { left = left, right = right }
+    end,
+  },
+  -- Brackets
+  ['b'] = { input = { { '%b()', '%b[]', '%b{}' }, '^.().*().$' }, output = { left = '(', right = ')' } },
+  -- Function call
+  ['f'] = {
+    input = { '%f[%w_%.][%w_%.]+%b()', '^.-%(().*()%)$' },
+    output = function()
+      local fun_name = MiniSurround.user_input('Function name')
+      if fun_name == nil then return nil end
+      return { left = ('%s('):format(fun_name), right = ')' }
+    end,
+  },
+  -- Tag
+  ['t'] = {
+    input = { '<(%w-)%f[^<%w][^<>]->.-</%1>', '^<.->().*()</[^/]->$' },
+    output = function()
+      local tag_full = MiniSurround.user_input('Tag name')
+      if tag_full == nil then return nil end
+      local tag_name = tag_full:match('^%S*')
+      return { left = '<' .. tag_full .. '>', right = '</' .. tag_name .. '>' }
+    end,
+  },
+  -- Quotes
+  ['q'] = { input = { { "'.-'", '".-"', '`.-`' }, '^.().*().$' }, output = { left = '"', right = '"' } },
+}
+
+-- Cache for dot-repeatability. This table is currently used with these keys:
+-- - 'input' - surround info for searching (in 'delete' and 'replace' start).
+-- - 'output' - surround info for adding (in 'add' and 'replace' end).
+-- - 'direction' - direction in which `MiniSurround.find()` should go. Used to
+--   enable same `operatorfunc` pattern for dot-repeatability.
+-- - 'search_method' - search method.
+-- - 'msg_shown' - whether helper message was shown.
+H.cache = {}
+
+-- Helper functionality =======================================================
+-- Settings -------------------------------------------------------------------
+H.setup_config = function(config)
+  -- General idea: if some table elements are not present in user-supplied
+  -- `config`, take them from default config
+  vim.validate({ config = { config, 'table', true } })
+  config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
+
+  -- Validate per nesting level to produce correct error message
+  vim.validate({
+    custom_surroundings = { config.custom_surroundings, 'table', true },
+    highlight_duration = { config.highlight_duration, 'number' },
+    mappings = { config.mappings, 'table' },
+    n_lines = { config.n_lines, 'number' },
+    respect_selection_type = { config.respect_selection_type, 'boolean' },
+    search_method = { config.search_method, H.is_search_method },
+    silent = { config.silent, 'boolean' },
+  })
+
+  vim.validate({
+    ['mappings.add'] = { config.mappings.add, 'string' },
+    ['mappings.delete'] = { config.mappings.delete, 'string' },
+    ['mappings.find'] = { config.mappings.find, 'string' },
+    ['mappings.find_left'] = { config.mappings.find_left, 'string' },
+    ['mappings.highlight'] = { config.mappings.highlight, 'string' },
+    ['mappings.replace'] = { config.mappings.replace, 'string' },
+    ['mappings.update_n_lines'] = { config.mappings.update_n_lines, 'string' },
+
+    ['mappings.suffix_last'] = { config.mappings.suffix_last, 'string' },
+    ['mappings.suffix_next'] = { config.mappings.suffix_next, 'string' },
+  })
+
+  return config
+end
+
+H.apply_config = function(config)
+  MiniSurround.config = config
+
+  local expr_map = function(lhs, rhs, desc) H.map('n', lhs, rhs, { expr = true, desc = desc }) end
+  --stylua: ignore start
+  -- Make regular mappings
+  local m = config.mappings
+
+  expr_map(m.add,       H.make_operator('add', nil, nil, true), 'Add surrounding')
+  expr_map(m.delete,    H.make_operator('delete'),              'Delete surrounding')
+  expr_map(m.replace,   H.make_operator('replace'),             'Replace surrounding')
+  expr_map(m.find,      H.make_operator('find', 'right'),       'Find right surrounding')
+  expr_map(m.find_left, H.make_operator('find', 'left'),        'Find left surrounding')
+  expr_map(m.highlight, H.make_operator('highlight'),           'Highlight surrounding')
+
+  H.map('n', m.update_n_lines, MiniSurround.update_n_lines, { desc = 'Update `MiniSurround.config.n_lines`' })
+  H.map('x', m.add, [[:<C-u>lua MiniSurround.add('visual')<CR>]], { desc = 'Add surrounding to selection' })
+
+  -- Make extended mappings
+  local suffix_map = function(lhs, suffix, rhs, desc)
+    -- Don't create extended mapping if user chose not to create regular one
+    if lhs == '' then return end
+    expr_map(lhs .. suffix, rhs, desc)
+  end
+
+  if m.suffix_last ~= '' then
+    local operator_prev = function(method, direction)
+      return H.make_operator(method, direction, 'prev')
+    end
+
+    local suff = m.suffix_last
+    suffix_map(m.delete,    suff, operator_prev('delete'),        'Delete previous surrounding')
+    suffix_map(m.replace,   suff, operator_prev('replace'),       'Replace previous surrounding')
+    suffix_map(m.find,      suff, operator_prev('find', 'right'), 'Find previous right surrounding')
+    suffix_map(m.find_left, suff, operator_prev('find', 'left'),  'Find previous left surrounding')
+    suffix_map(m.highlight, suff, operator_prev('highlight'),     'Highlight previous surrounding')
+  end
+
+  if m.suffix_next ~= '' then
+    local operator_next = function(method, direction)
+      return H.make_operator(method, direction, 'next')
+    end
+
+    local suff = m.suffix_next
+    suffix_map(m.delete,    suff, operator_next('delete'),        'Delete next surrounding')
+    suffix_map(m.replace,   suff, operator_next('replace'),       'Replace next surrounding')
+    suffix_map(m.find,      suff, operator_next('find', 'right'), 'Find next right surrounding')
+    suffix_map(m.find_left, suff, operator_next('find', 'left'),  'Find next left surrounding')
+    suffix_map(m.highlight, suff, operator_next('highlight'),     'Highlight next surrounding')
+  end
+  --stylua: ignore end
+end
+
+H.create_default_hl = function() vim.api.nvim_set_hl(0, 'MiniSurround', { default = true, link = 'IncSearch' }) end
+
+H.is_disabled = function() return vim.g.minisurround_disable == true or vim.b.minisurround_disable == true end
+
+H.get_config = function(config)
+  return vim.tbl_deep_extend('force', MiniSurround.config, vim.b.minisurround_config or {}, config or {})
+end
+
+H.is_search_method = function(x, x_name)
+  x = x or H.get_config().search_method
+  x_name = x_name or '`config.search_method`'
+
+  local allowed_methods = vim.tbl_keys(H.span_compare_methods)
+  if vim.tbl_contains(allowed_methods, x) then return true end
+
+  table.sort(allowed_methods)
+  local allowed_methods_string = table.concat(vim.tbl_map(vim.inspect, allowed_methods), ', ')
+  local msg = ([[%s should be one of %s.]]):format(x_name, allowed_methods_string)
+  return false, msg
+end
+
+H.validate_search_method = function(x, x_name)
+  local is_valid, msg = H.is_search_method(x, x_name)
+  if not is_valid then H.error(msg) end
+end
+
+-- Mappings -------------------------------------------------------------------
+H.make_operator = function(task, direction, search_method, ask_for_textobject)
+  return function()
+    if H.is_disabled() then
+      -- Using `<Esc>` helps to stop moving cursor caused by current
+      -- implementation detail of adding `' '` inside expression mapping
+      return [[\<Esc>]]
+    end
+
+    H.cache = { count = vim.v.count1, direction = direction, search_method = search_method }
+
+    vim.o.operatorfunc = 'v:lua.MiniSurround.' .. task
+
+    -- NOTEs:
+    -- - Prepend with command to reset `vim.v.count1` to allow
+    -- `[count1]sa[count2][textobject]`.
+    -- - Concatenate `' '` to operator output to "disable" motion
+    --   required by `g@`. It is used to enable dot-repeatability.
+    return '<Cmd>echon ""<CR>g@' .. (ask_for_textobject and '' or ' ')
+  end
+end
+
+-- Work with surrounding info -------------------------------------------------
+H.get_surround_spec = function(sur_type, use_cache)
+  local res
+
+  -- Try using cache
+  if use_cache then
+    res = H.cache[sur_type]
+    if res ~= nil then return res end
+  else
+    H.cache = {}
+  end
+
+  -- Prompt user to enter identifier of surrounding
+  local char = H.user_surround_id(sur_type)
+  if char == nil then return nil end
+
+  -- Get surround specification
+  res = H.make_surrounding_table()[char][sur_type]
+
+  -- Allow function returning spec or surrounding region(s)
+  if vim.is_callable(res) then res = res() end
+
+  -- Do nothing if supplied not appropriate structure
+  if not H.is_surrounding_info(res, sur_type) then return nil end
+
+  -- Wrap callable tables to be an actual functions. Otherwise they might be
+  -- confused with list of patterns.
+  if H.is_composed_pattern(res) then res = vim.tbl_map(H.wrap_callable_table, res) end
+
+  -- Track identifier for possible messages. Use metatable to pass
+  -- `vim.tbl_islist()` check.
+  res = setmetatable(res, { __index = { id = char } })
+
+  -- Cache result
+  if use_cache then H.cache[sur_type] = res end
+
+  return res
+end
+
+H.make_surrounding_table = function()
+  -- Extend builtins with data from `config`
+  local surroundings = vim.tbl_deep_extend('force', H.builtin_surroundings, H.get_config().custom_surroundings or {})
+
+  -- Add possibly missing information from default surrounding info
+  for char, info in pairs(surroundings) do
+    local default = H.get_default_surrounding_info(char)
+    surroundings[char] = vim.tbl_deep_extend('force', default, info)
+  end
+
+  -- Use default surrounding info for not supplied single character identifier
+  --stylua: ignore start
+  return setmetatable(surroundings, {
+    __index = function(_, key) return H.get_default_surrounding_info(key) end,
+  })
+  --stylua: ignore end
+end
+
+H.get_default_surrounding_info = function(char)
+  local char_esc = vim.pesc(char)
+  return { input = { char_esc .. '().-()' .. char_esc }, output = { left = char, right = char } }
+end
+
+H.is_surrounding_info = function(x, sur_type)
+  if sur_type == 'input' then
+    return H.is_composed_pattern(x) or H.is_region_pair(x) or H.is_region_pair_array(x)
+  elseif sur_type == 'output' then
+    return (type(x) == 'table' and type(x.left) == 'string' and type(x.right) == 'string')
+  end
+end
+
+H.is_region = function(x)
+  if type(x) ~= 'table' then return false end
+  local from_is_valid = type(x.from) == 'table' and type(x.from.line) == 'number' and type(x.from.col) == 'number'
+  -- Allow `to` to be `nil` to describe empty regions
+  local to_is_valid = true
+  if x.to ~= nil then
+    to_is_valid = type(x.to) == 'table' and type(x.to.line) == 'number' and type(x.to.col) == 'number'
+  end
+  return from_is_valid and to_is_valid
+end
+
+H.is_region_pair = function(x)
+  if type(x) ~= 'table' then return false end
+  return H.is_region(x.left) and H.is_region(x.right)
+end
+
+H.is_region_pair_array = function(x)
+  if not vim.tbl_islist(x) then return false end
+  for _, v in ipairs(x) do
+    if not H.is_region_pair(v) then return false end
+  end
+  return true
+end
+
+H.is_composed_pattern = function(x)
+  if not (vim.tbl_islist(x) and #x > 0) then return false end
+  for _, val in ipairs(x) do
+    local val_type = type(val)
+    if not (val_type == 'table' or val_type == 'string' or vim.is_callable(val)) then return false end
+  end
+  return true
+end
+
+-- Work with finding surrounding ----------------------------------------------
+---@param surr_spec table Composed pattern. Last item(s) - extraction template.
+---@param opts table Options.
+---@private
+H.find_surrounding = function(surr_spec, opts)
+  if surr_spec == nil then return end
+  if H.is_region_pair(surr_spec) then return surr_spec end
+
+  opts = vim.tbl_deep_extend('force', H.get_default_opts(), opts or {})
+  H.validate_search_method(opts.search_method, 'search_method')
+
+  local region_pair = H.find_surrounding_region_pair(surr_spec, opts)
+  if region_pair == nil then
+    local msg = ([[No surrounding '%s%s' found within %d line%s and `config.search_method = '%s'`.]]):format(
+      opts.n_times > 1 and opts.n_times or '',
+      surr_spec.id,
+      opts.n_lines,
+      opts.n_lines > 1 and 's' or '',
+      opts.search_method
+    )
+    H.message(msg)
+  end
+
+  return region_pair
+end
+
+H.find_surrounding_region_pair = function(surr_spec, opts)
+  local reference_region, n_times, n_lines = opts.reference_region, opts.n_times, opts.n_lines
+
+  if n_times == 0 then return end
+
+  -- Find `n_times` matching spans evolving from reference region span
+  -- First try to find inside 0-neighborhood
+  local neigh = H.get_neighborhood(reference_region, 0)
+  local reference_span = neigh.region_to_span(reference_region)
+
+  local find_next = function(cur_reference_span)
+    local res = H.find_best_match(neigh, surr_spec, cur_reference_span, opts)
+
+    -- If didn't find in 0-neighborhood, possibly try extend one
+    if res.span == nil then
+      -- Stop if no need to extend neighborhood
+      if n_lines == 0 or neigh.n_neighbors > 0 then return {} end
+
+      -- Update data with respect to new neighborhood
+      local cur_reference_region = neigh.span_to_region(cur_reference_span)
+      neigh = H.get_neighborhood(reference_region, n_lines)
+      reference_span = neigh.region_to_span(reference_region)
+      cur_reference_span = neigh.region_to_span(cur_reference_region)
+
+      -- Recompute based on new neighborhood
+      res = H.find_best_match(neigh, surr_spec, cur_reference_span, opts)
+    end
+
+    return res
+  end
+
+  local find_res = { span = reference_span }
+  for _ = 1, n_times do
+    find_res = find_next(find_res.span)
+    if find_res.span == nil then return end
+  end
+
+  -- Extract final span
+  local extract = function(span, extract_pattern)
+    -- Use table extract pattern to allow array of regions as surrounding spec
+    -- Pair of spans is constructed based on best region pair
+    if type(extract_pattern) == 'table' then return extract_pattern end
+
+    -- First extract local (with respect to best matched span) surrounding spans
+    local s = neigh['1d']:sub(span.from, span.to - 1)
+    local local_surr_spans = H.extract_surr_spans(s, extract_pattern)
+
+    -- Convert local spans to global
+    local off = span.from - 1
+    local left, right = local_surr_spans.left, local_surr_spans.right
+    return {
+      left = { from = left.from + off, to = left.to + off },
+      right = { from = right.from + off, to = right.to + off },
+    }
+  end
+
+  local final_spans = extract(find_res.span, find_res.extract_pattern)
+  local outer_span = { from = final_spans.left.from, to = final_spans.right.to }
+
+  -- Ensure that output region is different from reference.
+  if H.is_span_covering(reference_span, outer_span) then
+    find_res = find_next(find_res.span)
+    if find_res.span == nil then return end
+    final_spans = extract(find_res.span, find_res.extract_pattern)
+    outer_span = { from = final_spans.left.from, to = final_spans.right.to }
+    if H.is_span_covering(reference_span, outer_span) then return end
+  end
+
+  -- Convert to region pair
+  return { left = neigh.span_to_region(final_spans.left), right = neigh.span_to_region(final_spans.right) }
+end
+
+H.get_default_opts = function()
+  local config = H.get_config()
+  local cur_pos = vim.api.nvim_win_get_cursor(0)
+  return {
+    n_lines = config.n_lines,
+    n_times = H.cache.count or vim.v.count1,
+    -- Empty region at cursor position
+    reference_region = { from = { line = cur_pos[1], col = cur_pos[2] + 1 } },
+    search_method = H.cache.search_method or config.search_method,
+  }
+end
+
+-- Work with treesitter surrounding -------------------------------------------
+H.prepare_captures = function(captures)
+  local is_capture = function(x) return type(x) == 'string' and x:sub(1, 1) == '@' end
+
+  if not (type(captures) == 'table' and is_capture(captures.outer) and is_capture(captures.inner)) then
+    H.error('Wrong format for `captures`. See `MiniSurround.gen_spec.input.treesitter()` for details.')
+  end
+
+  return { outer = captures.outer, inner = captures.inner }
+end
+
+H.get_matched_node_pairs_plugin = function(captures)
+  -- Hope that 'nvim-treesitter.query' is stable enough
+  local ts_queries = require('nvim-treesitter.query')
+  local ts_parsers = require('nvim-treesitter.parsers')
+
+  -- This is a modified version of `ts_queries.get_capture_matches_recursively`
+  -- source code which keeps track of match language
+  local matches = {}
+  local parser = ts_parsers.get_parser(0)
+  if parser then
+    parser:for_each_tree(function(tree, lang_tree)
+      local lang = lang_tree:lang()
+      local lang_matches = ts_queries.get_capture_matches(0, captures.outer, 'textobjects', tree:root(), lang)
+      for _, m in pairs(lang_matches) do
+        m.lang = lang
+      end
+      vim.list_extend(matches, lang_matches)
+    end)
+  end
+
+  return vim.tbl_map(
+    function(match)
+      local node_outer = match.node
+      -- Pick inner node as the biggest node matching inner query. This is
+      -- needed because query output is not quaranteed to come in order.
+      local matches_inner = ts_queries.get_capture_matches(0, captures.inner, 'textobjects', node_outer, match.lang)
+      local nodes_inner = vim.tbl_map(function(x) return x.node end, matches_inner)
+      return { outer = node_outer, inner = H.get_biggest_node(nodes_inner) }
+    end,
+    -- This call should handle multiple languages in buffer
+    matches
+  )
+end
+
+H.get_matched_node_pairs_builtin = function(captures)
+  -- Fetch treesitter data for buffer
+  local lang = vim.bo.filetype
+  local ok, parser = pcall(vim.treesitter.get_parser, 0, lang)
+  if not ok then H.error_treesitter('parser', lang) end
+
+  local query = vim.treesitter.get_query(lang, 'textobjects')
+  if query == nil then H.error_treesitter('query', lang) end
+
+  -- Remove leading '@'
+  local capture_outer, capture_inner = captures.outer:sub(2), captures.inner:sub(2)
+
+  -- Compute nodes matching outer capture
+  local nodes_outer = {}
+  for _, tree in ipairs(parser:trees()) do
+    vim.list_extend(nodes_outer, H.get_builtin_matched_nodes(capture_outer, tree:root(), query))
+  end
+
+  -- Make node pairs with biggest node matching inner capture inside outer node
+  return vim.tbl_map(function(node_outer)
+    local nodes_inner = H.get_builtin_matched_nodes(capture_inner, node_outer, query)
+    return { outer = node_outer, inner = H.get_biggest_node(nodes_inner) }
+  end, nodes_outer)
+end
+
+H.get_builtin_matched_nodes = function(capture, root, query)
+  local res = {}
+  for capture_id, node, _ in query:iter_captures(root, 0) do
+    if query.captures[capture_id] == capture then table.insert(res, node) end
+  end
+  return res
+end
+
+H.get_biggest_node = function(node_arr)
+  local best_node, best_byte_count = nil, -math.huge
+  for _, node in ipairs(node_arr) do
+    local _, _, start_byte = node:start()
+    local _, _, end_byte = node:end_()
+    local byte_count = end_byte - start_byte + 1
+    if best_byte_count < byte_count then
+      best_node, best_byte_count = node, byte_count
+    end
+  end
+
+  return best_node
+end
+
+H.error_treesitter = function(failed_get, lang)
+  local bufnr = vim.api.nvim_get_current_buf()
+  local msg = string.format([[Can not get %s for buffer %d and language '%s'.]], failed_get, bufnr, lang)
+  H.error(msg)
+end
+
+-- Work with matching spans ---------------------------------------------------
+---@param neighborhood table Output of `get_neighborhood()`.
+---@param surr_spec table
+---@param reference_span table Span to cover.
+---@param opts table Fields: <search_method>.
+---@private
+H.find_best_match = function(neighborhood, surr_spec, reference_span, opts)
+  local best_span, best_nested_pattern, current_nested_pattern
+  local f = function(span)
+    if H.is_better_span(span, best_span, reference_span, opts) then
+      best_span = span
+      best_nested_pattern = current_nested_pattern
+    end
+  end
+
+  if H.is_region_pair_array(surr_spec) then
+    -- Iterate over all spans representing outer regions in array
+    for _, region_pair in ipairs(surr_spec) do
+      -- Construct outer region used to find best region pair
+      local outer_region = { from = region_pair.left.from, to = region_pair.right.to or region_pair.right.from }
+
+      -- Consider outer region only if it is completely within neighborhood
+      if neighborhood.is_region_inside(outer_region) then
+        -- Make future extract pattern based directly on region pair
+        current_nested_pattern = {
+          {
+            left = neighborhood.region_to_span(region_pair.left),
+            right = neighborhood.region_to_span(region_pair.right),
+          },
+        }
+
+        f(neighborhood.region_to_span(outer_region))
+      end
+    end
+  else
+    -- Iterate over all matched spans
+    for _, nested_pattern in ipairs(H.cartesian_product(surr_spec)) do
+      current_nested_pattern = nested_pattern
+      H.iterate_matched_spans(neighborhood['1d'], nested_pattern, f)
+    end
+  end
+
+  local extract_pattern
+  if best_nested_pattern ~= nil then extract_pattern = best_nested_pattern[#best_nested_pattern] end
+  return { span = best_span, extract_pattern = extract_pattern }
+end
+
+H.iterate_matched_spans = function(line, nested_pattern, f)
+  local max_level = #nested_pattern
+  -- Keep track of visited spans to ensure only one call of `f`.
+  -- Example: `((a) (b))`, `{'%b()', '%b()'}`
+  local visited = {}
+
+  local process
+  process = function(level, level_line, level_offset)
+    local pattern = nested_pattern[level]
+    local next_span = function(s, init) return H.string_find(s, pattern, init) end
+    if vim.is_callable(pattern) then next_span = pattern end
+
+    local is_same_balanced = type(pattern) == 'string' and pattern:match('^%%b(.)%1$') ~= nil
+    local init = 1
+    while init <= level_line:len() do
+      local from, to = next_span(level_line, init)
+      if from == nil then break end
+
+      if level == max_level then
+        local found_match = H.new_span(from + level_offset, to + level_offset)
+        local found_match_id = string.format('%s_%s', found_match.from, found_match.to)
+        if not visited[found_match_id] then
+          f(found_match)
+          visited[found_match_id] = true
+        end
+      else
+        local next_level_line = level_line:sub(from, to)
+        local next_level_offset = level_offset + from - 1
+        process(level + 1, next_level_line, next_level_offset)
+      end
+
+      -- Start searching from right end to implement "balanced" pair.
+      -- This doesn't work with regular balanced pattern because it doesn't
+      -- capture nested brackets.
+      init = (is_same_balanced and to or from) + 1
+    end
+  end
+
+  process(1, line, 0)
+end
+
+-- NOTE: spans are end-exclusive to allow empty spans via `from == to`
+H.new_span = function(from, to) return { from = from, to = to == nil and from or (to + 1) } end
+
+---@param candidate table Candidate span to test against `current`.
+---@param current table|nil Current best span.
+---@param reference table Reference span to cover.
+---@param opts table Fields: <search_method>.
+---@private
+H.is_better_span = function(candidate, current, reference, opts)
+  -- Candidate should be never equal or nested inside reference
+  if H.is_span_covering(reference, candidate) or H.is_span_equal(candidate, reference) then return false end
+
+  return H.span_compare_methods[opts.search_method](candidate, current, reference)
+end
+
+H.span_compare_methods = {
+  cover = function(candidate, current, reference)
+    local res = H.is_better_covering_span(candidate, current, reference)
+    if res ~= nil then return res end
+    -- If both are not covering, `candidate` is not better (as it must cover)
+    return false
+  end,
+
+  cover_or_next = function(candidate, current, reference)
+    local res = H.is_better_covering_span(candidate, current, reference)
+    if res ~= nil then return res end
+
+    -- If not covering, `candidate` must be "next" and closer to reference
+    if not H.is_span_on_left(reference, candidate) then return false end
+    if current == nil then return true end
+
+    local dist = H.span_distance.next
+    return dist(candidate, reference) < dist(current, reference)
+  end,
+
+  cover_or_prev = function(candidate, current, reference)
+    local res = H.is_better_covering_span(candidate, current, reference)
+    if res ~= nil then return res end
+
+    -- If not covering, `candidate` must be "previous" and closer to reference
+    if not H.is_span_on_left(candidate, reference) then return false end
+    if current == nil then return true end
+
+    local dist = H.span_distance.prev
+    return dist(candidate, reference) < dist(current, reference)
+  end,
+
+  cover_or_nearest = function(candidate, current, reference)
+    local res = H.is_better_covering_span(candidate, current, reference)
+    if res ~= nil then return res end
+
+    -- If not covering, `candidate` must be closer to reference
+    if current == nil then return true end
+
+    local dist = H.span_distance.near
+    return dist(candidate, reference) < dist(current, reference)
+  end,
+
+  next = function(candidate, current, reference)
+    if H.is_span_covering(candidate, reference) then return false end
+
+    -- `candidate` must be "next" and closer to reference
+    if not H.is_span_on_left(reference, candidate) then return false end
+    if current == nil then return true end
+
+    local dist = H.span_distance.next
+    return dist(candidate, reference) < dist(current, reference)
+  end,
+
+  prev = function(candidate, current, reference)
+    if H.is_span_covering(candidate, reference) then return false end
+
+    -- `candidate` must be "previous" and closer to reference
+    if not H.is_span_on_left(candidate, reference) then return false end
+    if current == nil then return true end
+
+    local dist = H.span_distance.prev
+    return dist(candidate, reference) < dist(current, reference)
+  end,
+
+  nearest = function(candidate, current, reference)
+    if H.is_span_covering(candidate, reference) then return false end
+
+    -- `candidate` must be closer to reference
+    if current == nil then return true end
+
+    local dist = H.span_distance.near
+    return dist(candidate, reference) < dist(current, reference)
+  end,
+}
+
+H.span_distance = {
+  -- Other possible choices of distance between [a1, a2] and [b1, b2]:
+  -- - Hausdorff distance: max(|a1 - b1|, |a2 - b2|).
+  --   Source:
+  --   https://math.stackexchange.com/questions/41269/distance-between-two-ranges
+  -- - Minimum distance: min(|a1 - b1|, |a2 - b2|).
+
+  -- Distance is chosen so that "next span" in certain direction is the closest
+  next = function(span_1, span_2) return math.abs(span_1.from - span_2.from) end,
+  prev = function(span_1, span_2) return math.abs(span_1.to - span_2.to) end,
+  near = function(span_1, span_2) return math.min(math.abs(span_1.from - span_2.from), math.abs(span_1.to - span_2.to)) end,
+}
+
+H.is_better_covering_span = function(candidate, current, reference)
+  local candidate_is_covering = H.is_span_covering(candidate, reference)
+  local current_is_covering = H.is_span_covering(current, reference)
+
+  if candidate_is_covering and current_is_covering then
+    -- Covering candidate is better than covering current if it is narrower
+    return (candidate.to - candidate.from) < (current.to - current.from)
+  end
+  if candidate_is_covering and not current_is_covering then return true end
+  if not candidate_is_covering and current_is_covering then return false end
+
+  -- Return `nil` if neither span is covering
+  return nil
+end
+
+--stylua: ignore
+H.is_span_covering = function(span, span_to_cover)
+  if span == nil or span_to_cover == nil then return false end
+  if span.from == span.to then
+    return (span.from == span_to_cover.from) and (span_to_cover.to == span.to)
+  end
+  if span_to_cover.from == span_to_cover.to then
+    return (span.from <= span_to_cover.from) and (span_to_cover.to < span.to)
+  end
+
+  return (span.from <= span_to_cover.from) and (span_to_cover.to <= span.to)
+end
+
+H.is_span_equal = function(span_1, span_2)
+  if span_1 == nil or span_2 == nil then return false end
+  return (span_1.from == span_2.from) and (span_1.to == span_2.to)
+end
+
+H.is_span_on_left = function(span_1, span_2)
+  if span_1 == nil or span_2 == nil then return false end
+  return (span_1.from <= span_2.from) and (span_1.to <= span_2.to)
+end
+
+H.is_point_inside_spans = function(point, spans)
+  for _, span in ipairs(spans) do
+    if span[1] <= point and point <= span[2] then return true end
+  end
+  return false
+end
+
+-- Work with operator marks ---------------------------------------------------
+H.get_marks_pos = function(mode)
+  -- Region is inclusive on both ends
+  local mark1, mark2
+  if mode == 'visual' then
+    mark1, mark2 = '<', '>'
+  else
+    mark1, mark2 = '[', ']'
+  end
+
+  local pos1 = vim.api.nvim_buf_get_mark(0, mark1)
+  local pos2 = vim.api.nvim_buf_get_mark(0, mark2)
+
+  local selection_type = H.get_selection_type(mode)
+
+  -- Tweak position in linewise mode as marks are placed on the first column
+  if selection_type == 'linewise' then
+    -- Move start mark past the indent
+    local _, line1_indent = vim.fn.getline(pos1[1]):find('^%s*')
+    pos1[2] = line1_indent
+
+    -- Move end mark to the last character (` - 2` here because `col()` returns
+    -- column right after the last 1-based column)
+    pos2[2] = vim.fn.col({ pos2[1], '$' }) - 2
+  end
+
+  -- Make columns 1-based instead of 0-based. This is needed because
+  -- `nvim_buf_get_mark()` returns the first 0-based byte of mark symbol and
+  -- all the following operations are done with Lua's 1-based indexing.
+  pos1[2], pos2[2] = pos1[2] + 1, pos2[2] + 1
+
+  -- Tweak second position to respect multibyte characters. Reasoning:
+  -- - These positions will be used with `region_replace()` to add some text,
+  --   which operates on byte columns.
+  -- - For the first mark we want the first byte of symbol, then text will be
+  --   insert to the left of the mark.
+  -- - For the second mark we want last byte of symbol. To add surrounding to
+  --   the right, use `pos2[2] + 1`.
+  if mode == 'visual' and vim.o.selection == 'exclusive' then
+    -- Respect 'selection' option
+    pos2[2] = pos2[2] - 1
+  else
+    local line2 = vim.fn.getline(pos2[1])
+    -- Use `math.min()` because it might lead to 'index out of range' error
+    -- when mark is positioned at the end of line (that extra space which is
+    -- selected when selecting with `v$`)
+    local utf_index = vim.str_utfindex(line2, math.min(#line2, pos2[2]))
+    -- This returns the last byte inside character because `vim.str_byteindex()`
+    -- 'rounds upwards to the end of that sequence'.
+    pos2[2] = vim.str_byteindex(line2, utf_index)
+  end
+
+  return {
+    first = { line = pos1[1], col = pos1[2] },
+    second = { line = pos2[1], col = pos2[2] },
+    selection_type = selection_type,
+  }
+end
+
+H.get_selection_type = function(mode)
+  if (mode == 'char') or (mode == 'visual' and vim.fn.visualmode() == 'v') then return 'charwise' end
+  if (mode == 'line') or (mode == 'visual' and vim.fn.visualmode() == 'V') then return 'linewise' end
+  if (mode == 'block') or (mode == 'visual' and vim.fn.visualmode() == '\22') then return 'blockwise' end
+end
+
+-- Work with cursor -----------------------------------------------------------
+H.set_cursor = function(line, col) vim.api.nvim_win_set_cursor(0, { line, col - 1 }) end
+
+H.set_cursor_nonblank = function(line)
+  H.set_cursor(line, 1)
+  vim.cmd('normal! ^')
+end
+
+H.compare_pos = function(pos1, pos2)
+  if pos1.line < pos2.line then return '<' end
+  if pos1.line > pos2.line then return '>' end
+  if pos1.col < pos2.col then return '<' end
+  if pos1.col > pos2.col then return '>' end
+  return '='
+end
+
+H.cursor_cycle = function(pos_array, dir)
+  local cur_pos = vim.api.nvim_win_get_cursor(0)
+  cur_pos = { line = cur_pos[1], col = cur_pos[2] + 1 }
+
+  local compare, to_left, to_right, res_pos
+  -- NOTE: `pos_array` should be an increasingly ordered array of positions
+  for _, pos in pairs(pos_array) do
+    compare = H.compare_pos(cur_pos, pos)
+    -- Take position when moving to left if cursor is strictly on right.
+    -- This will lead to updating `res_pos` until the rightmost such position.
+    to_left = compare == '>' and dir == 'left'
+    -- Take position when moving to right if cursor is strictly on left.
+    -- This will update result only once leading to the leftmost such position.
+    to_right = res_pos == nil and compare == '<' and dir == 'right'
+    if to_left or to_right then res_pos = pos end
+  end
+
+  res_pos = res_pos or (dir == 'right' and pos_array[1] or pos_array[#pos_array])
+  H.set_cursor(res_pos.line, res_pos.col)
+end
+
+-- Work with user input -------------------------------------------------------
+H.user_surround_id = function(sur_type)
+  -- Get from user single character surrounding identifier
+  local needs_help_msg = true
+  vim.defer_fn(function()
+    if not needs_help_msg then return end
+
+    local msg = string.format('Enter %s surrounding identifier (single character) ', sur_type)
+    H.echo(msg)
+    H.cache.msg_shown = true
+  end, 1000)
+  local ok, char = pcall(vim.fn.getcharstr)
+  needs_help_msg = false
+  H.unecho()
+
+  -- Terminate if couldn't get input (like with <C-c>) or it is `<Esc>`
+  if not ok or char == '\27' then return nil end
+
+  if char:find('^[%w%p%s]$') == nil then
+    H.message('Input must be single character: alphanumeric, punctuation, or space.')
+    return nil
+  end
+
+  return char
+end
+
+-- Work with positions --------------------------------------------------------
+H.pos_to_left = function(pos)
+  if pos.line == 1 and pos.col == 1 then return { line = pos.line, col = pos.col } end
+  if pos.col == 1 then return { line = pos.line - 1, col = H.get_line_cols(pos.line - 1) } end
+  return { line = pos.line, col = pos.col - 1 }
+end
+
+H.pos_to_right = function(pos)
+  local n_cols = H.get_line_cols(pos.line)
+  -- Using `>` and not `>=` helps with removing '\n' and in the last line
+  if pos.line == vim.api.nvim_buf_line_count(0) and pos.col > n_cols then return { line = pos.line, col = n_cols } end
+  if pos.col > n_cols then return { line = pos.line + 1, col = 1 } end
+  return { line = pos.line, col = pos.col + 1 }
+end
+
+-- Work with regions ----------------------------------------------------------
+H.region_replace = function(region, text)
+  -- Compute start and end position for `vim.api.nvim_buf_set_text()`.
+  -- Indexing is zero-based. Rows - end-inclusive, columns - end-exclusive.
+  local start_row, start_col = region.from.line - 1, region.from.col - 1
+
+  local end_row, end_col
+  -- Allow empty region
+  if H.region_is_empty(region) then
+    end_row, end_col = start_row, start_col
+  else
+    end_row, end_col = region.to.line - 1, region.to.col
+
+    -- Possibly correct to allow removing new line character
+    if end_row < vim.api.nvim_buf_line_count(0) and H.get_line_cols(end_row + 1) < end_col then
+      end_row, end_col = end_row + 1, 0
+    end
+  end
+
+  -- Allow single string as replacement
+  if type(text) == 'string' then text = { text } end
+
+  -- Allow `\n` in string to denote new lines
+  if #text > 0 then text = vim.split(table.concat(text, '\n'), '\n') end
+
+  -- Replace. Use `pcall()` to do nothing if some position is out of bounds.
+  pcall(vim.api.nvim_buf_set_text, 0, start_row, start_col, end_row, end_col, text)
+end
+
+H.surr_to_pos_array = function(surr)
+  local res = {}
+
+  local append_position = function(pos, correction_direction)
+    if pos == nil then return end
+    -- Don't go past the line if it is not empty
+    if H.get_line_cols(pos.line) < pos.col and pos.col > 1 then
+      pos = correction_direction == 'left' and H.pos_to_left(pos) or H.pos_to_right(pos)
+    end
+
+    -- Don't add duplicate. Assumes that positions are used increasingly.
+    local line, col = pos.line, pos.col
+    local last = res[#res]
+    if not (last ~= nil and last.line == line and last.col == col) then
+      table.insert(res, { line = line, col = col })
+    end
+  end
+
+  -- Possibly correct position towards inside of surrounding region
+  -- Also don't add positions from empty regions
+  if not H.region_is_empty(surr.left) then
+    append_position(surr.left.from, 'right')
+    append_position(surr.left.to, 'right')
+  end
+  if not H.region_is_empty(surr.right) then
+    append_position(surr.right.from, 'left')
+    append_position(surr.right.to, 'left')
+  end
+
+  return res
+end
+
+H.region_highlight = function(buf_id, region)
+  -- Don't highlight empty region
+  if H.region_is_empty(region) then return end
+  local ns_id = H.ns_id.highlight
+
+  -- Indexing is zero-based. Rows - end-inclusive, columns - end-exclusive.
+  local from_line, from_col, to_line, to_col =
+    region.from.line - 1, region.from.col - 1, region.to.line - 1, region.to.col
+  vim.highlight.range(buf_id, ns_id, 'MiniSurround', { from_line, from_col }, { to_line, to_col })
+end
+
+H.region_unhighlight = function(buf_id, region)
+  local ns_id = H.ns_id.highlight
+
+  -- Remove highlights from whole lines as it is the best available granularity
+  vim.api.nvim_buf_clear_namespace(buf_id, ns_id, region.from.line - 1, (region.to or region.from).line)
+end
+
+H.region_is_empty = function(region) return region.to == nil end
+
+-- Work with text -------------------------------------------------------------
+H.get_range_indent = function(from_line, to_line)
+  local n_indent, indent = math.huge, nil
+
+  local lines = vim.api.nvim_buf_get_lines(0, from_line - 1, to_line, true)
+  local n_indent_cur, indent_cur
+  for _, l in ipairs(lines) do
+    _, n_indent_cur, indent_cur = l:find('^(%s*)')
+
+    -- Don't indent blank lines
+    if n_indent_cur < n_indent and n_indent_cur < l:len() then
+      n_indent, indent = n_indent_cur, indent_cur
+    end
+  end
+
+  return indent or ''
+end
+
+H.shift_indent = function(command, from_line, to_line)
+  if to_line < from_line then return end
+  vim.cmd('silent ' .. from_line .. ',' .. to_line .. command)
+end
+
+H.is_line_blank = function(line_num) return vim.fn.nextnonblank(line_num) ~= line_num end
+
+-- Work with Lua patterns -----------------------------------------------------
+H.extract_surr_spans = function(s, extract_pattern)
+  local positions = { s:match(extract_pattern) }
+
+  local is_all_numbers = true
+  for _, pos in ipairs(positions) do
+    if type(pos) ~= 'number' then is_all_numbers = false end
+  end
+
+  local is_valid_positions = is_all_numbers and (#positions == 2 or #positions == 4)
+  if not is_valid_positions then
+    local msg = 'Could not extract proper positions (two or four empty captures) from '
+      .. string.format([[string '%s' with extraction pattern '%s'.]], s, extract_pattern)
+    H.error(msg)
+  end
+
+  if #positions == 2 then
+    return { left = H.new_span(1, positions[1] - 1), right = H.new_span(positions[2], s:len()) }
+  end
+  return { left = H.new_span(positions[1], positions[2] - 1), right = H.new_span(positions[3], positions[4] - 1) }
+end
+
+-- Work with cursor neighborhood ----------------------------------------------
+---@param reference_region table Reference region.
+---@param n_neighbors number Maximum number of neighbors to include before
+---   start line and after end line.
+---@private
+H.get_neighborhood = function(reference_region, n_neighbors)
+  -- Compute '2d neighborhood' of (possibly empty) region
+  local from_line, to_line = reference_region.from.line, (reference_region.to or reference_region.from).line
+  local line_start = math.max(1, from_line - n_neighbors)
+  local line_end = math.min(vim.api.nvim_buf_line_count(0), to_line + n_neighbors)
+  local neigh2d = vim.api.nvim_buf_get_lines(0, line_start - 1, line_end, false)
+  -- Append 'newline' character to distinguish between lines in 1d case
+  for k, v in pairs(neigh2d) do
+    neigh2d[k] = v .. '\n'
+  end
+
+  -- '1d neighborhood': position is determined by offset from start
+  local neigh1d = table.concat(neigh2d, '')
+
+  -- Convert 2d buffer position to 1d offset
+  local pos_to_offset = function(pos)
+    if pos == nil then return nil end
+    local line_num = line_start
+    local offset = 0
+    while line_num < pos.line do
+      offset = offset + neigh2d[line_num - line_start + 1]:len()
+      line_num = line_num + 1
+    end
+
+    return offset + pos.col
+  end
+
+  -- Convert 1d offset to 2d buffer position
+  local offset_to_pos = function(offset)
+    if offset == nil then return nil end
+    local line_num = 1
+    local line_offset = 0
+    while line_num <= #neigh2d and line_offset + neigh2d[line_num]:len() < offset do
+      line_offset = line_offset + neigh2d[line_num]:len()
+      line_num = line_num + 1
+    end
+
+    return { line = line_start + line_num - 1, col = offset - line_offset }
+  end
+
+  -- Convert 2d region to 1d span
+  local region_to_span = function(region)
+    if region == nil then return nil end
+    local is_empty = region.to == nil
+    local to = region.to or region.from
+    return { from = pos_to_offset(region.from), to = pos_to_offset(to) + (is_empty and 0 or 1) }
+  end
+
+  -- Convert 1d span to 2d region
+  local span_to_region = function(span)
+    if span == nil then return nil end
+    -- NOTE: this might lead to outside of line positions due to added `\n` at
+    -- the end of lines in 1d-neighborhood.
+    local res = { from = offset_to_pos(span.from) }
+
+    -- Convert empty span to empty region
+    if span.from < span.to then res.to = offset_to_pos(span.to - 1) end
+    return res
+  end
+
+  local is_region_inside = function(region)
+    local res = line_start <= region.from.line
+    if region.to ~= nil then res = res and (region.to.line <= line_end) end
+    return res
+  end
+
+  return {
+    n_neighbors = n_neighbors,
+    region = reference_region,
+    ['1d'] = neigh1d,
+    ['2d'] = neigh2d,
+    pos_to_offset = pos_to_offset,
+    offset_to_pos = offset_to_pos,
+    region_to_span = region_to_span,
+    span_to_region = span_to_region,
+    is_region_inside = is_region_inside,
+  }
+end
+
+-- Utilities ------------------------------------------------------------------
+H.echo = function(msg, is_important)
+  if H.get_config().silent then return end
+
+  -- Construct message chunks
+  msg = type(msg) == 'string' and { { msg } } or msg
+  table.insert(msg, 1, { '(mini.surround) ', 'WarningMsg' })
+
+  -- Avoid hit-enter-prompt
+  local max_width = vim.o.columns * math.max(vim.o.cmdheight - 1, 0) + vim.v.echospace
+  local chunks, tot_width = {}, 0
+  for _, ch in ipairs(msg) do
+    local new_ch = { vim.fn.strcharpart(ch[1], 0, max_width - tot_width), ch[2] }
+    table.insert(chunks, new_ch)
+    tot_width = tot_width + vim.fn.strdisplaywidth(new_ch[1])
+    if tot_width >= max_width then break end
+  end
+
+  -- Echo. Force redraw to ensure that it is effective (`:h echo-redraw`)
+  vim.cmd([[echo '' | redraw]])
+  vim.api.nvim_echo(chunks, is_important, {})
+end
+
+H.unecho = function()
+  if H.cache.msg_shown then vim.cmd([[echo '' | redraw]]) end
+end
+
+H.message = function(msg) H.echo(msg, true) end
+
+H.error = function(msg) error(string.format('(mini.surround) %s', msg)) end
+
+H.map = function(mode, lhs, rhs, opts)
+  if lhs == '' then return end
+  opts = vim.tbl_deep_extend('force', { silent = true }, opts or {})
+  vim.keymap.set(mode, lhs, rhs, opts)
+end
+
+H.get_line_cols = function(line_num) return vim.fn.getline(line_num):len() end
+
+H.string_find = function(s, pattern, init)
+  init = init or 1
+
+  -- Match only start of full string if pattern says so.
+  -- This is needed because `string.find()` doesn't do this.
+  -- Example: `string.find('(aaa)', '^.*$', 4)` returns `4, 5`
+  if pattern:sub(1, 1) == '^' then
+    if init > 1 then return nil end
+    return string.find(s, pattern)
+  end
+
+  -- Handle patterns `x.-y` differently: make match as small as possible. This
+  -- doesn't allow `x` be present inside `.-` match, just as with `yyy`. Which
+  -- also leads to a behavior similar to punctuation id (like with `va_`): no
+  -- covering is possible, only next, previous, or nearest.
+  local check_left, _, prev = string.find(pattern, '(.)%.%-')
+  local is_pattern_special = check_left ~= nil and prev ~= '%'
+  if not is_pattern_special then return string.find(s, pattern, init) end
+
+  -- Make match as small as possible
+  local from, to = string.find(s, pattern, init)
+  if from == nil then return end
+
+  local cur_from, cur_to = from, to
+  while cur_to == to do
+    from, to = cur_from, cur_to
+    cur_from, cur_to = string.find(s, pattern, cur_from + 1)
+  end
+
+  return from, to
+end
+
+---@param arr table List of items. If item is list, consider as set for
+---   product. Else - make it single item list.
+---@private
+H.cartesian_product = function(arr)
+  if not (type(arr) == 'table' and #arr > 0) then return {} end
+  arr = vim.tbl_map(function(x) return vim.tbl_islist(x) and x or { x } end, arr)
+
+  local res, cur_item = {}, {}
+  local process
+  process = function(level)
+    for i = 1, #arr[level] do
+      table.insert(cur_item, arr[level][i])
+      if level == #arr then
+        -- Flatten array to allow tables as elements of step tables
+        table.insert(res, vim.tbl_flatten(cur_item))
+      else
+        process(level + 1)
+      end
+      table.remove(cur_item, #cur_item)
+    end
+  end
+
+  process(1)
+  return res
+end
+
+H.wrap_callable_table = function(x)
+  if vim.is_callable(x) and type(x) == 'table' then return function(...) return x(...) end end
+  return x
+end
+
+return MiniSurround
diff --git a/.config/nvim/lua/mini/trailspace.lua b/.config/nvim/lua/mini/trailspace.lua
new file mode 100644
index 0000000..fd3894c
--- /dev/null
+++ b/.config/nvim/lua/mini/trailspace.lua
@@ -0,0 +1,197 @@
+--- *mini.trailspace* Trailspace (highlight and remove)
+--- *MiniTrailspace*
+---
+--- MIT License Copyright (c) 2021 Evgeni Chasnovski
+---
+--- ==============================================================================
+---
+--- Features:
+--- - Highlighting is done only in modifiable buffer by default, only in Normal
+---   mode, and stops in Insert mode and when leaving window.
+---
+--- - Trim all trailing whitespace with |MiniTrailspace.trim()|.
+---
+--- - Trim all trailing empty lines with |MiniTrailspace.trim_last_lines()|.
+---
+--- # Setup~
+---
+--- This module needs a setup with `require('mini.trailspace').setup({})`
+--- (replace `{}` with your `config` table). It will create global Lua table
+--- `MiniTrailspace` which you can use for scripting or manually (with
+--- `:lua MiniTrailspace.*`).
+---
+--- See |MiniTrailspace.config| for `config` structure and default values.
+---
+--- You can override runtime config settings locally to buffer inside
+--- `vim.b.minitrailspace_config` which should have same structure as
+--- `MiniTrailspace.config`. See |mini.nvim-buffer-local-config| for more details.
+---
+--- # Highlight groups~
+---
+--- * `MiniTrailspace` - highlight group for trailing space.
+---
+--- To change any highlight group, modify it directly with |:highlight|.
+---
+--- # Disabling~
+---
+--- To disable, set `vim.g.minitrailspace_disable` (globally) or
+--- `vim.b.minitrailspace_disable` (for a buffer) to `true`. Considering high
+--- number of different scenarios and customization intentions, writing exact
+--- rules for disabling module's functionality is left to user. See
+--- |mini.nvim-disabling-recipes| for common recipes. Note: after disabling
+--- there might be highlighting left; it will be removed after next
+--- highlighting update (see |events| and `MiniTrailspace` |augroup|).
+
+-- Module definition ==========================================================
+local MiniTrailspace = {}
+local H = {}
+
+--- Module setup
+---
+---@param config table|nil Module config table. See |MiniTrailspace.config|.
+---
+---@usage `require('mini.trailspace').setup({})` (replace `{}` with your `config` table)
+MiniTrailspace.setup = function(config)
+  -- Export module
+  _G.MiniTrailspace = MiniTrailspace
+
+  -- Setup config
+  config = H.setup_config(config)
+
+  -- Apply config
+  H.apply_config(config)
+
+  -- Define behavior
+  H.create_autocommands(config)
+
+  -- Create default highlighting
+  H.create_default_hl()
+
+  -- Initialize highlight (usually takes effect during startup)
+  vim.defer_fn(MiniTrailspace.highlight, 0)
+end
+
+--- Module config
+---
+--- Default values:
+---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
+MiniTrailspace.config = {
+  -- Highlight only in normal buffers (ones with empty 'buftype'). This is
+  -- useful to not show trailing whitespace where it usually doesn't matter.
+  only_in_normal_buffers = true,
+}
+--minidoc_afterlines_end
+
+-- Module functionality =======================================================
+--- Highlight trailing whitespace in current window
+MiniTrailspace.highlight = function()
+  -- Highlight only in normal mode
+  if H.is_disabled() or vim.fn.mode() ~= 'n' then
+    MiniTrailspace.unhighlight()
+    return
+  end
+
+  -- Possibly work only in normal buffers
+  if H.get_config().only_in_normal_buffers and not H.is_buffer_normal() then return end
+
+  -- Don't add match id on top of existing one
+  if H.get_match_id() ~= nil then return end
+
+  vim.fn.matchadd('MiniTrailspace', [[\s\+$]])
+end
+
+--- Unhighlight trailing whitespace in current window
+MiniTrailspace.unhighlight = function()
+  -- Use `pcall` because there is an error if match id is not present. It can
+  -- happen if something else called `clearmatches`.
+  pcall(vim.fn.matchdelete, H.get_match_id())
+end
+
+--- Trim trailing whitespace
+MiniTrailspace.trim = function()
+  -- Save cursor position to later restore
+  local curpos = vim.api.nvim_win_get_cursor(0)
+  -- Search and replace trailing whitespace
+  vim.cmd([[keeppatterns %s/\s\+$//e]])
+  vim.api.nvim_win_set_cursor(0, curpos)
+end
+
+--- Trim last blank lines
+MiniTrailspace.trim_last_lines = function()
+  local n_lines = vim.api.nvim_buf_line_count(0)
+  local last_nonblank = vim.fn.prevnonblank(n_lines)
+  if last_nonblank < n_lines then vim.api.nvim_buf_set_lines(0, last_nonblank, n_lines, true, {}) end
+end
+
+-- Helper data ================================================================
+-- Module default config
+H.default_config = vim.deepcopy(MiniTrailspace.config)
+
+-- Helper functionality =======================================================
+-- Settings -------------------------------------------------------------------
+H.setup_config = function(config)
+  -- General idea: if some table elements are not present in user-supplied
+  -- `config`, take them from default config
+  vim.validate({ config = { config, 'table', true } })
+  config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
+
+  vim.validate({ only_in_normal_buffers = { config.only_in_normal_buffers, 'boolean' } })
+
+  return config
+end
+
+H.apply_config = function(config) MiniTrailspace.config = config end
+
+H.create_autocommands = function(config)
+  local augroup = vim.api.nvim_create_augroup('MiniTrailspace', {})
+
+  local au = function(event, pattern, callback, desc)
+    vim.api.nvim_create_autocmd(event, { group = augroup, pattern = pattern, callback = callback, desc = desc })
+  end
+
+  -- NOTE: Respecting both `WinEnter` and `BufEnter` seems to be useful to
+  -- account of different order of handling buffer opening in new window.
+  -- Notable example: 'nvim-tree' at commit a1600e5.
+  au({ 'WinEnter', 'BufEnter', 'InsertLeave' }, '*', MiniTrailspace.highlight, 'Highlight')
+  au({ 'WinLeave', 'BufLeave', 'InsertEnter' }, '*', MiniTrailspace.unhighlight, 'Unhighlight')
+
+  if config.only_in_normal_buffers then
+    -- Add tracking of 'buftype' changing because it can be set after events on
+    -- which highlighting is done. If not done, highlighting appears but
+    -- disappears if buffer is reentered.
+    au('OptionSet', 'buftype', H.track_normal_buffer, 'Track normal buffer')
+  end
+end
+
+H.create_default_hl = function() vim.api.nvim_set_hl(0, 'MiniTrailspace', { default = true, link = 'Error' }) end
+
+H.is_disabled = function() return vim.g.minitrailspace_disable == true or vim.b.minitrailspace_disable == true end
+
+H.get_config = function(config)
+  return vim.tbl_deep_extend('force', MiniTrailspace.config, vim.b.minitrailspace_config or {}, config or {})
+end
+
+H.track_normal_buffer = function()
+  if not H.get_config().only_in_normal_buffers then return end
+
+  -- This should be used with 'OptionSet' event for 'buftype' option
+  -- Empty 'buftype' means "normal buffer"
+  if vim.v.option_new == '' then
+    MiniTrailspace.highlight()
+  else
+    MiniTrailspace.unhighlight()
+  end
+end
+
+H.is_buffer_normal = function(buf_id) return vim.bo[buf_id or 0].buftype == '' end
+
+H.get_match_id = function()
+  -- NOTE: this can be replaced with more efficient custom tracking of id per
+  -- window but it will have more edge cases (like won't update on manual
+  -- `clearmatches()`)
+  for _, match in ipairs(vim.fn.getmatches()) do
+    if match.group == 'MiniTrailspace' then return match.id end
+  end
+end
+
+return MiniTrailspace