` (first make split by `_`): >\n a _b_c\n aa_bb_cc\n<\n Ignore some split matches. It modifies `split_exclude_patterns` option by\n adding commonly wanted patterns. See more details in\n |MiniAlign.gen_step.ignore_split()|.\n\n Before: >\n /* This_is_assumed_to_be_comment */\n a\"_\"_b\n aa_bb\n<\n After typing `_i` (first make split by `_`): >\n /* This_is_assumed_to_be_comment */\n a\"_\"_b\n aa _bb\n<\n Pair neighboring parts.\n\n Before: >\n a_b_c\n aaa_bbb_ccc\n<\n After typing `_p` (first make split by `_`): >\n a_ b_ c\n aaa_bbb_ccc\n<\n Trim parts from whitespace on both sides (keeping indentation).\n\n Before: >\n a _ b _ c\n aa _bb _cc\n<\n After typing `_t` (first make split by `_`): >\n a _b _c\n aa_bb_cc\n<\n# Delete some last pre-step ~\n\n Delete one of the pre-steps. If there is only one kind of pre-steps,\n remove its latest added one. If not, prompt user to choose pre-step kind\n by entering single character: `s`plit, `j`ustify, `m`erge.\n\n Examples:\n - `tp` results in only \"trim\" step to be left.\n - `it` prompts to choose which step to delete (pre-split or\n pre-justify in this case).\n\n# Special configurations for common splits ~\n\n<=> Use special pattern to align by a group of consecutive \"=\". It can be\n preceded by any number of punctuation marks and followed by some sommon\n punctuation characters. Trim whitespace and merge with single space.\n\n Before: >\n a=b\n aa<=bb\n aaa===bbb\n aaaa = cccc\n<\n After typing `=`: >\n a = b\n aa <= bb\n aaa === bbb\n aaaa = cccc\n<\n<,> Besides splitting by \",\" character, trim whitespace, pair neighboring\n parts and merge with single space.\n\n Before: >\n a,b\n aa,bb\n aaa , bbb\n<\n After typing `,`: >\n a, b\n aa, bb\n aaa, bbb\n<\n<|> Split by \"|\" character, trim whitespace, merge with single space.\n\n Before: >\n |a|b|\n |aa|bb|\n |aaa | bbb |\n<\n After typing `|`: >\n | a | b |\n | aa | bb |\n | aaa | bbb |\n<\n (Space bar) Squash consecutive whitespace into single space (except\n possible indentation) and split by `%s+` pattern (keeps indentation).\n\n Before: >\n a b c\n aa bb cc\n<\n After typing ``: >\n a b c\n aa bb cc\n<\n------------------------------------------------------------------------------\n *MiniAlign-examples*\nCopy lines in modifiable buffer, initiate alignment with preview (`gAip`)\nand try typing suggested key sequences.\nThese are modified examples taken from 'junegunn/vim-easy-align'.\n\n# Equal sign ~\n\nLines: >\n\n # This=is=assumed=to be a comment\n \"a =\"\n a =\n a = 1\n bbbb = 2\n ccccccc = 3\n ccccccccccccccc\n ddd = 4\n eeee === eee = eee = eee=f\n fff = ggg += gg &&= gg\n g != hhhhhhhh == 888\n i := 5\n i %= 5\n i *= 5\n j =~ 5\n j >= 5\n aa => 123\n aa <<= 123\n aa >>= 123\n bbb => 123\n c => 1233123\n d => 123\n dddddd &&= 123\n dddddd ||= 123\n dddddd /= 123\n gg <=> ee\n<\nKey sequences:\n- `=`\n- `=jc`\n- `=jr`\n- `=m!`\n- `=p`\n- `=i` (execute `:lua vim.o.commentstring = '# %s'` for full experience)\n- `=`\n- `=p`\n- `=fn==1`\n- `=fn==1t`\n- `=frow>7`\n\n------------------------------------------------------------------------------\n *MiniAlign.setup()*\n `MiniAlign.setup`({config})\nModule setup\n\nParameters ~\n{config} `(table|nil)` Module config table. See |MiniAlign.config|.\n\nUsage ~\n>lua\n require('mini.align').setup() -- use default config\n -- OR\n require('mini.align').setup({}) -- replace {} with your config table\n<\n------------------------------------------------------------------------------\n *MiniAlign.config*\n `MiniAlign.config`\nDefaults ~\n>lua\n MiniAlign.config = {\n -- Module mappings. Use `''` (empty string) to disable one.\n mappings = {\n start = 'ga',\n start_with_preview = 'gA',\n },\n\n -- Modifiers changing alignment steps and/or options\n modifiers = {\n -- Main option modifiers\n ['s'] = --,\n ['j'] = --,\n ['m'] = --,\n\n -- Modifiers adding pre-steps\n ['f'] = --,\n ['i'] = --,\n ['p'] = --,\n ['t'] = --,\n\n -- Delete some last pre-step\n [''] = --,\n\n -- Special configurations for common splits\n ['='] = --,\n ['|'] = --,\n [' '] = --,\n },\n\n -- Default options controlling alignment process\n options = {\n split_pattern = '',\n justify_side = 'left',\n merge_delimiter = '',\n },\n\n -- Default steps performing alignment (if `nil`, default is used)\n steps = {\n pre_split = {},\n split = nil,\n pre_justify = {},\n justify = nil,\n pre_merge = {},\n merge = nil,\n },\n\n -- Whether to disable showing non-error feedback\n -- This also affects (purely informational) helper messages shown after\n -- idle time if user input is required.\n silent = false,\n }\n<\n# Modifiers ~\n\n`MiniAlign.config.modifiers` is used to define interactive user experience\nof managing alignment process. It is a table with single character keys and\nmodifier function values.\n\nEach modifier function:\n- Is called when corresponding modifier key is pressed.\n- Has signature `(steps, opts)` and should modify any of its input in place.\n\nExamples:\n- Modifier function used for default 'i' modifier: >lua\n\n function(steps, _)\n table.insert(steps.pre_split, MiniAlign.gen_step.ignore_split())\n end\n<\n- Tweak 't' modifier to use highest indentation instead of keeping it: >lua\n\n require('mini.align').setup({\n modifiers = {\n t = function(steps, _)\n local trim_high = MiniAlign.gen_step.trim('both', 'high')\n table.insert(steps.pre_justify, trim_high)\n end\n }\n })\n<\n- Tweak `j` modifier to cycle through available \"justify_side\" option\n values (like in 'junegunn/vim-easy-align'): >lua\n\n require('mini.align').setup({\n modifiers = {\n j = function(_, opts)\n local next_option = ({\n left = 'center', center = 'right', right = 'none', none = 'left',\n })[opts.justify_side]\n opts.justify_side = next_option or 'left'\n end,\n },\n })\n<\n# Options ~\n\n`MiniAlign.config.options` defines default values of options used to control\nbehavior of steps.\n\nExamples:\n- Set `justify_side = 'center'` to center align at initialization.\n\nFor more details about options see |MiniAlign.align_strings()| and entries of\n|MiniAlign.gen_step| for default main steps.\n\n# Steps ~\n\n`MiniAlign.config.steps` defines default steps to be applied during\nalignment process.\n\nExamples:\n- Align by default only first pair of columns: >lua\n\n local align = require('mini.align')\n align.setup({\n steps = {\n pre_justify = { align.gen_step.filter('n == 1') }\n },\n })\n<\n------------------------------------------------------------------------------\n *MiniAlign.align_strings()*\n `MiniAlign.align_strings`({strings}, {opts}, {steps})\nAlign strings\n\nFor details about alignment process see |MiniAlign-algorithm|.\n\nParameters ~\n{strings} `(table)` Array of strings.\n{opts} `(table|nil)` Options. Its copy will be passed to steps as second\n argument. Extended with `MiniAlign.config.options`.\n This is a place to control default main steps:\n - `opts.split_pattern` - Lua pattern(s) used to make split parts.\n - `opts.split_exclude_patterns` - which split matches should be ignored.\n - `opts.justify_side` - which direction(s) alignment should be done.\n - `opts.justify_offsets` - offsets tweaking width of first column\n - `opts.merge_delimiter` - which delimiter(s) to use when merging.\n For more information see |MiniAlign.gen_step| entry for corresponding\n default step.\n{steps} `(table|nil)` Steps. Extended with `MiniAlign.config.steps`.\n Possible `nil` values are replaced with corresponding default steps:\n - `split` - |MiniAlign.gen_step.default_split()|.\n - `justify` - |MiniAlign.gen_step.default_justify()|.\n - `merge` - |MiniAlign.gen_step.default_merge()|.\n\n------------------------------------------------------------------------------\n *MiniAlign.align_user()*\n `MiniAlign.align_user`({mode})\nAlign current region with user-supplied steps\n\nMostly designed to be used inside mappings.\n\nWill use |MiniAlign.align_strings()| and set the following options in `opts`:\n- `justify_offsets` - array of offsets used to achieve actual alignment of\n a region. It is non-trivial (not array of zeros) only for charwise\n selection: offset of first string is computed as width of prefix to the\n left of region start.\n- `region` - current affected region (see |MiniAlign-glossary|). Can be\n used to create more advanced steps.\n- `mode` - mode of selection (see |MiniAlign-glossary|).\n\nParameters ~\n{mode} `(string)` Selection mode. One of \"char\", \"line\", \"block\".\n\n------------------------------------------------------------------------------\n *MiniAlign.as_parts()*\n `MiniAlign.as_parts`({arr2d})\nConvert 2d array of strings to parts\n\nThis function verifies if input is a proper 2d array of strings and adds\nmethods to its copy.\n\nClass ~\n{parts}\n\nFields ~\n{apply} `(function)` Takes callable `f` and applies it to every part.\n Callable should have signature `(s, data)`: `s` is a string part,\n `data` - table with its data ( has row number, has column number).\n Returns new 2d array.\n\n{apply_inplace} `(function)` Takes callable `f` and applies it to every part.\n Should have same signature as in `apply` method. Outputs (should all be\n strings) are assigned in place to a corresponding parts element. Returns\n parts itself to enable method chaining.\n\n{get_dims} `(function)` Return dimensions of parts array: a table with\n and keys having number of rows and number of columns (maximum\n number of elements across all rows).\n\n{group} `(function)` Concatenate neighboring strings based on supplied\n boolean mask and direction (one of \"left\", default, or \"right\"). Has\n signature `(mask, direction)` and modifies parts in place. Returns parts\n itself to enable method chaining.\n Example:\n - Parts: `{ { \"a\", \"b\", \"c\" }, { \"d\", \"e\" }, { \"f\" } }`\n - Mask: `{ { false, false, true }, { true, false }, { false } }`\n - Result for direction \"left\": `{ { \"abc\" }, { \"d\", \"e\" }, { \"f\" } }`\n - Result for direction \"right\": `{ { \"ab\",\"c\" }, { \"de\" }, { \"f\" } }`\n\n{pair} `(function)` Concatenate neighboring element pairs. Takes\n `direction` as input (one of \"left\", default, or \"right\") and applies\n `group()` for an alternating mask.\n Example:\n - Parts: `{ { \"a\", \"b\", \"c\" }, { \"d\", \"e\" }, { \"f\" } }`\n - Result for direction \"left\": `{ { \"ab\", \"c\" }, { \"de\" }, { \"f\" } }`\n - Result for direction \"right\": `{ { \"a\", \"bc\" }, { \"de\" }, { \"f\" } }`\n\n{slice_col} `(function)` Return column with input index `j`. Note: it might\n not be an array if rows have unequal number of columns.\n\n{slice_row} `(function)` Return row with input index `i`.\n\n{trim} `(function)` Trim elements whitespace. Has signature `(direction, indent)`\n and modifies parts in place. Returns parts itself to enable method chaining.\n - Possible values of `direction`: \"both\" (default), \"left\", \"right\",\n \"none\". Defines from which side whitespaces should be removed.\n - Possible values of `indent`: \"keep\" (default), \"low\", \"high\", \"remove\".\n Defines what to do with possible indent (left whitespace of first string\n in a row). Value \"keep\" keeps it; \"low\" makes all indent equal to the\n lowest across rows; \"high\" - highest across rows; \"remove\" - removes indent.\n\nUsage ~\n>lua\n parts = MiniAlign.as_parts({ { 'a', 'b' }, { 'c' } })\n print(vim.inspect(parts.get_dims())) -- Should be { row = 2, col = 2 }\n\n parts.apply_inplace(function(s, data)\n return ' ' .. data.row .. s .. data.col .. ' '\n end)\n print(vim.inspect(parts)) -- Should be { { ' 1a1 ', ' 1b2 ' }, { ' 2c1 ' } }\n\n parts.trim('both', 'remove').pair()\n print(vim.inspect(parts)) -- Should be { { '1a11b2' }, { '2c1' } }\n<\n------------------------------------------------------------------------------\n *MiniAlign.new_step()*\n `MiniAlign.new_step`({name}, {action})\nCreate step\n\nA step is basically a named callable object. Having a name bundled with\nsome action powers helper status message during interactive alignment process.\n\nParameters ~\n{name} `(string)` Step name.\n{action} `(function|table)` Step action. Should be a callable object\n (see |vim.is_callable()|).\n\nReturn ~\n`(table)` A table with keys: with `name` argument, with `action`.\n\n------------------------------------------------------------------------------\n *MiniAlign.gen_step*\n `MiniAlign.gen_step`\nGenerate common action steps\n\nThis is a table with function elements. Call to actually get step.\n\nEach step action is a function that has signature `(object, opts)`, where\n`object` is either parts or array of strings (depends on which stage of\nalignment process it is assumed to be applied) and `opts` is table of options.\n\nOutputs of elements named `default_*` are used as default corresponding main\nstep (split, justify, merge). Behavior of all of them depend on values from\nsupplied options (second argument).\n\nOutputs of other elements depend on both step generator input values and\noptions supplied at execution. This design is mostly because their output\ncan be used several times in pre-steps.\n\nUsage ~\n>lua\n local align = require('mini.align')\n align.setup({\n modifiers = {\n -- Use 'T' modifier to remove both whitespace and indent\n T = function(steps, _)\n table.insert(steps.pre_justify, align.gen_step.trim('both', 'remove'))\n end,\n },\n options = {\n -- By default align \"right\", \"left\", \"right\", \"left\", ...\n justify_side = { 'right', 'left' },\n },\n steps = {\n -- Align by default only first pair of columns\n pre_justify = { align.gen_step.filter('n == 1') },\n },\n })\n<\n------------------------------------------------------------------------------\n *MiniAlign.gen_step.default_split()*\n `MiniAlign.gen_step.default_split`()\nGenerate default split step\n\nOutput splits strings using matches of Lua pattern(s) from `split_pattern`\noption which are not dismissed by `split_exclude_patterns` option.\n\nOutline of how single string is split:\n- Convert `split_pattern` option to array of strings (string is converted\n as one-element array). This array will be recycled in case there are more\n split matches than in converted `split_pattern` array (which almost always).\n- Find all forbidden spans (intervals inside string) - all matches of all\n patterns in `split_exclude_patterns`.\n- Find match for the next pattern. If it is not inside any forbidden span,\n add preceding unmatched substring and matched split as two parts. Repeat\n with the next pattern.\n- If no pattern match is found, add the rest of string as final part.\n\nOutput uses following options (as part second argument, `opts` table):\n- - string or array of strings used to detect split matches\n and create parts. Default: `''` meaning no matches (whole string is used\n as part). Examples: `'%s+'`, `{ '<', '>' }`.\n- - array of strings defining which regions to\n exclude from being matched. Default: `{}`. Examples: `{ '\".-\"', '^%s*#.*' }`.\n\nReturn ~\n`(table)` A step named \"split\" and with appropriate callable action.\n\nSee also ~\n|MiniAlign.gen_step.ignore_split()| heavily uses `split_exclude_patterns`.\n\n------------------------------------------------------------------------------\n *MiniAlign.gen_step.default_justify()*\n `MiniAlign.gen_step.default_justify`()\nGenerate default justify step\n\nOutput makes column elements of string parts have equal width by adding\nleft and/or right whitespace padding. Which side(s) to pad is defined by\n`justify_side` option. Width of first column can be tweaked with `justify_offsets`\noption.\n\nOutline of how parts are justified:\n- Convert `justify_side` option to array of strings (single string is\n converted as one-element array). Recycle this array to have length equal\n to number of columns in parts.\n- For all columns compute maximum width of strings from it (add offsets from\n `justify_offsets` to first column widths). Note: for left alignment, width\n of last row element does not affect column width. This is mainly because\n it won't be padded and helps dealing with \"no single match\" lines.\n- Make all elements have same width inside column by adding appropriate\n amount of whitespace. Which side(s) to add is controlled by the corresponding\n `justify_side` array element. Note: padding is done with spaces which\n might conflict with tab indentation.\n\nOutput uses following options (as part second argument, `opts` table):\n- - string or array of strings. Each element can be one of\n \"left\" (pad right side), \"center\" (pad both sides equally), \"right\" (pad\n left side), \"none\" (no padding). Default: \"left\".\n- - array of numeric left offsets of rows. Used to adjust\n for possible not equal indents, like in case of charwise selection when\n left edge is not on the first column. Default: array of zeros. Set\n automatically during interactive alignment in charwise mode.\n\nReturn ~\n`(table)` A step named \"justify\" and with appropriate callable action.\n\n------------------------------------------------------------------------------\n *MiniAlign.gen_step.default_merge()*\n `MiniAlign.gen_step.default_merge`()\nGenerate default merge step\n\nOutput merges rows of parts into strings by placing merge delimiter(s)\nbetween them.\n\nOutline of how parts are converted to array of strings:\n- Convert `merge_delimiter` option to array of strings (single string is\n converted as one-element array). Recycle this array to have length equal\n to number of columns in parts minus 1. Also possibly trim leading whitespace\n in first merge character to not affect indentation.\n- Exclude empty strings from parts. They add nothing to output except extra\n usage of merge delimiter.\n- Concatenate each row interleaving with array of merge delimiters.\n\nOutput uses following options (as part second argument, `opts` table):\n- - string or array of strings. Default: `''`.\n Examples: `' '`, `{ '', ' ' }`.\n\nReturn ~\n`(table)` A step named \"merge\" and with appropriate callable action.\n\n------------------------------------------------------------------------------\n *MiniAlign.gen_step.filter()*\n `MiniAlign.gen_step.filter`({expr})\nGenerate filter step\n\nConstruct function predicate from supplied Lua string expression and make\nstep evaluating it on every part element.\n\nOutline of how filtering is done:\n- Convert Lua filtering expression into function predicate which can be\n evaluated in manually created context (some specific variables being set).\n- Compute boolean mask for parts by applying predicate to each element of\n 2d array with special variables set to specific values (see next section).\n- Group parts with computed mask. See `group()` method of parts in\n |MiniAlign.as_parts()|.\n\nSpecial variables which can be used in expression:\n- - row number of current element.\n- - total number of rows in parts.\n- - column number of current element.\n- - total number of columns in current row.\n- - string value of current element.\n- - column pair number of current element. Useful when filtering by\n result of pattern splitting.\n- - total number of column pairs in current row.\n- All variables from global table `_G`.\n\nTips:\n- This general filtering approach can be used to both include and exclude\n certain parts from alignment. Examples:\n - Use `row ~= 2` to align all parts except from second row.\n - Use `n == 1` to align only by first pair of columns.\n- Filtering by last equal sign usually can be done with `n >= (N - 1)`\n (because there is usually something to the right of it).\n\nParameters ~\n{expr} `(string)` Lua expression as a string which will be used as predicate.\n\nReturn ~\n`(table|nil)` A step named \"filter\" and with appropriate callable action.\n\n------------------------------------------------------------------------------\n *MiniAlign.gen_step.ignore_split()*\n `MiniAlign.gen_step.ignore_split`({patterns}, {exclude_comment})\nGenerate ignore step\n\nOutput adds certain values to `split_exclude_patterns` option. Should be\nused as pre-split step.\n\nParameters ~\n{patterns} `(table)` Array of patterns to be added to\n `split_exclude_patterns` as is. Default: `{ [[\".-\"]] }` (excludes strings\n for most cases).\n{exclude_comment} `(boolean|nil)` Whether to add comment pattern to\n `split_exclude_patterns`. Comment pattern is derived from 'commentstring'\n option. Default: `true`.\n\nReturn ~\n`(table)` A step named \"ignore\" and with appropriate callable action.\n\nSee also ~\n|MiniAlign.gen_step.default_split()| for details about\n `split_exclude_patterns` option.\n\n------------------------------------------------------------------------------\n *MiniAlign.gen_step.pair()*\n `MiniAlign.gen_step.pair`({direction})\nGenerate pair step\n\nOutput calls `pair()` method of parts (see |MiniAlign.as_parts()|) with\nsupplied `direction` argument.\n\nParameters ~\n{direction} `(string)` Which direction to pair. One of \"left\" (default) or\n\n\nReturn ~\n`(table)` A step named \"pair\" and with appropriate callable action.\n\n------------------------------------------------------------------------------\n *MiniAlign.gen_step.trim()*\n `MiniAlign.gen_step.trim`({direction}, {indent})\nGenerate trim step\n\nOutput calls `trim()` method of parts (see |MiniAlign.as_parts()|) with\nsupplied `direction` and `indent` arguments.\n\nParameters ~\n{direction} `(string|nil)` Which sides to trim whitespace. One of \"both\"\n (default), \"left\", \"right\", \"none\".\n{indent} `(string|nil)` What to do with possible indent (left whitespace\n of first string in a row). One of \"keep\" (default), \"low\", \"high\", \"remove\".\n\nReturn ~\n`(table)` A step named \"trim\" and with appropriate callable action.\n\n\n vim:tw=78:ts=8:noet:ft=help:norl:"
},
{
"path": "doc/mini-animate.txt",
"content": "*mini.animate* Animate common Neovim actions\n\nMIT License Copyright (c) 2022 Evgeni Chasnovski\n\n------------------------------------------------------------------------------\n *MiniAnimate*\nFeatures:\n- Works out of the box with a single `require('mini.animate').setup()`.\n No extra mappings or commands needed.\n\n- Animate cursor movement inside same buffer by showing customizable path.\n See |MiniAnimate.config.cursor| for more details.\n\n- Animate scrolling with a series of subscrolls (\"smooth scrolling\").\n See |MiniAnimate.config.scroll| for more details.\n\n- Animate window resize by gradually changing sizes of all windows.\n See |MiniAnimate.config.resize| for more details.\n\n- Animate window open/close with visually updating floating window.\n See |MiniAnimate.config.open| and |MiniAnimate.config.close| for more details.\n\n- Timings for all actions can be customized independently.\n See |MiniAnimate-timing| for more details.\n\n- Action animations can be enabled/disabled independently.\n\n- All animations are asynchronous/non-blocking and trigger a targeted event\n which can be used to perform actions after animation is done.\n\n- |MiniAnimate.animate()| function which can be used to perform own animations.\n\nNotes:\n- Cursor movement is animated inside same window and buffer, not as cursor\n moves across the screen.\n\n- Scroll and resize animations are done with \"side effects\": they actually\n change the state of what is animated (window view and sizes\n respectively). This has a downside of possibly needing extra work to\n account for asynchronous nature of animation (like adjusting certain\n mappings, etc.). See |MiniAnimate.config.scroll| and\n |MiniAnimate.config.resize| for more details.\n\n# Setup ~\n\nThis module needs a setup with `require('mini.animate').setup({})` (replace\n`{}` with your `config` table). It will create global Lua table `MiniAnimate`\nwhich you can use for scripting or manually (with `:lua MiniAnimate.*`).\n\nSee |MiniAnimate.config| for available config settings.\n\nYou can override runtime config settings (like `config.modifiers`) locally\nto buffer inside `vim.b.minianimate_config` which should have same structure\nas `MiniAnimate.config`. See |mini.nvim-buffer-local-config| for more details.\n\n# Comparisons ~\n\n- [Neovide](https://neovide.dev/):\n - Neovide is a standalone GUI which has more control over its animations.\n While 'mini.animate' works inside terminal emulator (with all its\n limitations, like lack of pixel-size control over animations).\n - Neovide animates cursor movement across screen, while 'mini.animate' -\n as it moves across same buffer.\n - Neovide has fixed number of animation effects per action, while\n 'mini.animate' is fully customizable.\n - 'mini.animate' implements animations for window open/close, while\n Neovide does not.\n- [edluffy/specs.nvim](https://github.com/edluffy/specs.nvim):\n - 'mini.animate' approaches cursor movement visualization via\n customizable path function (uses extmarks), while 'specs.nvim' can\n customize within its own visual effects (shading and floating\n window resizing).\n- [karb94/neoscroll.nvim](https://github.com/karb94/neoscroll.nvim):\n - Scroll animation is triggered only inside dedicated mappings.\n 'mini.animate' animates scroll resulting from any window view change.\n- [anuvyklack/windows.nvim](https://github.com/anuvyklack/windows.nvim):\n - Resize animation is done only within custom commands and mappings,\n while 'mini.animate' animates any resize with appropriate values of\n 'winheight' / 'winwidth' and 'winminheight' / 'winminwidth').\n\n# Highlight groups ~\n\n- `MiniAnimateCursor` - highlight of cursor during its animated movement.\n- `MiniAnimateNormalFloat` - highlight of floating window for `open` and\n `close` animations.\n\nTo change any highlight group, set it directly with |nvim_set_hl()|.\n\n# Disabling ~\n\nTo disable, set `vim.g.minianimate_disable` (globally) or\n`vim.b.minianimate_disable` (for a buffer) to `true`. Considering high\nnumber of different scenarios and customization intentions, writing exact\nrules for disabling module's functionality is left to user. See\n|mini.nvim-disabling-recipes| for common recipes.\n\n------------------------------------------------------------------------------\n *MiniAnimate.setup()*\n `MiniAnimate.setup`({config})\nModule setup\n\nParameters ~\n{config} `(table|nil)` Module config table. See |MiniAnimate.config|.\n\nUsage ~\n>lua\n require('mini.animate').setup() -- use default config\n -- OR\n require('mini.animate').setup({}) -- replace {} with your config table\n<\n------------------------------------------------------------------------------\n *MiniAnimate.config*\n `MiniAnimate.config`\nDefaults ~\n>lua\n MiniAnimate.config = {\n -- Cursor path\n cursor = {\n -- Whether to enable this animation\n enable = true,\n\n -- Timing of animation (how steps will progress in time)\n timing = --,\n\n -- Path generator for visualized cursor movement\n path = --,\n },\n\n -- Vertical scroll\n scroll = {\n -- Whether to enable this animation\n enable = true,\n\n -- Timing of animation (how steps will progress in time)\n timing = --,\n\n -- Subscroll generator based on total scroll\n subscroll = --,\n },\n\n -- Window resize\n resize = {\n -- Whether to enable this animation\n enable = true,\n\n -- Timing of animation (how steps will progress in time)\n timing = --,\n\n -- Subresize generator for all steps of resize animations\n subresize = --,\n },\n\n -- Window open\n open = {\n -- Whether to enable this animation\n enable = true,\n\n -- Timing of animation (how steps will progress in time)\n timing = --,\n\n -- Floating window config generator visualizing specific window\n winconfig = --,\n\n -- 'winblend' (window transparency) generator for floating window\n winblend = --,\n },\n\n -- Window close\n close = {\n -- Whether to enable this animation\n enable = true,\n\n -- Timing of animation (how steps will progress in time)\n timing = --,\n\n -- Floating window config generator visualizing specific window\n winconfig = --,\n\n -- 'winblend' (window transparency) generator for floating window\n winblend = --,\n },\n }\n<\n# General ~\n\n- *MiniAnimate-timing* Every animation is a non-blockingly scheduled series of\n specific actions. They are executed in a sequence of timed steps controlled\n by `timing` option. It is a callable which, given next and total step numbers,\n returns wait time (in ms).\n See |MiniAnimate.gen_timing| for builtin timing functions.\n See |MiniAnimate.animate()| for more details about animation process.\n\n- Every animation can be enabled/disabled independently by setting `enable`\n option to `true`/`false`.\n\n- *MiniAnimate-done-event* Every animation triggers custom |User| event when it\n is finished. It is named `MiniAnimateDoneXxx` with `Xxx` replaced by capitalized\n supported animation action name (like `MiniAnimateDoneCursor`). Use it to\n schedule some action after certain animation is completed. Alternatively,\n you can use |MiniAnimate.execute_after()| (usually preferred in mappings).\n\n- Each animation has its main step generator which defines how particular\n animation is done. They all are callables which take some input data and\n return an array of step data. Length of that array determines number of\n animation steps. Outputs `nil` and empty table result in no animation.\n\n# Cursor ~\n*MiniAnimate.config.cursor*\n\nThis animation is triggered for each movement of cursor inside same window\nand buffer. Its visualization step consists from placing single extmark (see\n|extmarks|) at certain position. This extmark contains single space and is\nhighlighted with `MiniAnimateCursor` highlight group.\n\nExact places of extmark and their number is controlled by `path` option. It\nis a callable which takes `destination` argument (2d integer point in\n`(line, col)` coordinates) and returns array of relative to `(0, 0)` places\nfor extmark to be placed. Example:\n- Input `(2, -3)` means cursor jumped 2 lines forward and 3 columns backward.\n- Output `{ {0, 0 }, { 0, -1 }, { 0, -2 }, { 0, -3 }, { 1, -3 } }` means\n that path is first visualized along the initial line and then along final\n column.\n\nSee |MiniAnimate.gen_path| for builtin path generators.\n\nNotes:\n- Input `destination` value is computed ignoring folds. This is by design\n as it helps better visualize distance between two cursor positions.\n- Outputs of path generator resulting in a place where extmark can't be\n placed are silently omitted during animation: this step won't show any\n visualization.\n\nConfiguration example: >lua\n\n local animate = require('mini.animate')\n animate.setup({\n cursor = {\n -- Animate for 200 milliseconds with linear easing\n timing = animate.gen_timing.linear({ duration = 200, unit = 'total' }),\n\n -- Animate with shortest line for any cursor move\n path = animate.gen_path.line({\n predicate = function() return true end,\n }),\n }\n })\n<\nAfter animation is done, `MiniAnimateDoneCursor` event is triggered.\n\n# Scroll ~\n*MiniAnimate.config.scroll*\n\nThis animation is triggered for each vertical scroll of current window.\nIts visualization step consists from performing a small subscroll which all\nin total will result into needed total scroll.\n\nExact subscroll values and their number is controlled by `subscroll` option.\nIt is a callable which takes `total_scroll` argument (single non-negative\ninteger) and returns array of non-negative integers each representing the\namount of lines needed to be scrolled inside corresponding step. All\nsubscroll values should sum to input `total_scroll`.\nExample:\n- Input `5` means that total scroll consists from 5 lines (either up or down,\n which doesn't matter).\n- Output of `{ 1, 1, 1, 1, 1 }` means that there are 5 equal subscrolls.\n\nSee |MiniAnimate.gen_subscroll| for builtin subscroll generators.\n\nNotes:\n- Input value of `total_scroll` is computed taking folds into account.\n- As scroll animation is essentially a precisely scheduled non-blocking\n subscrolls, this has two important interconnected consequences:\n - If another scroll is attempted during the animation, it is done based\n on the **currently visible** window view. Example: if user presses\n |CTRL-D| and then |CTRL-U| when animation is half done, window will not\n display the previous view half of 'scroll' above it. This especially\n affects mouse wheel scrolling, as each its turn results in a new scroll\n for number of lines defined by 'mousescroll'. Tweak it to your liking.\n - It breaks the use of several relative scrolling commands in the same\n command. Use |MiniAnimate.execute_after()| to schedule action after\n reaching target window view.\n Example: a useful `nnoremap n nzvzz` mapping (consecutive application\n of |n|, |zv|, and |zz|) should be expressed in the following way: >lua\n\n 'lua vim.cmd(\"normal! n\"); ' ..\n 'MiniAnimate.execute_after(\"scroll\", \"normal! zvzz\")'\n<\n- Default timing might conflict with scrolling via holding a key (like `j` or `k`\n with 'wrap' enabled) due to high key repeat rate: next scroll is done before\n first step of current one finishes. Resolve this by not scrolling like that\n or by ensuring maximum value of step duration to be lower than between\n repeated keys: set timing like `function(_, n) return math.min(250/n, 10) end`\n or use timing with constant step duration.\n\nConfiguration example: >lua\n\n local animate = require('mini.animate')\n animate.setup({\n scroll = {\n -- Animate for 200 milliseconds with linear easing\n timing = animate.gen_timing.linear({ duration = 200, unit = 'total' }),\n\n -- Animate equally but with at most 120 steps instead of default 60\n subscroll = animate.gen_subscroll.equal({ max_output_steps = 120 }),\n }\n })\n<\nAfter animation is done, `MiniAnimateDoneScroll` event is triggered.\n\n# Resize ~\n*MiniAnimate.config.resize*\n\nThis animation is triggered for window resize while having same layout of\nsame windows. For example, it won't trigger when window is opened/closed or\nafter something like |CTRL-W_K|. Its visualization step consists from setting\ncertain sizes to all visible windows (last step being for \"true\" final sizes).\n\nExact window step sizes and their number is controlled by `subresize` option.\nIt is a callable which takes `sizes_from` and `sizes_to` arguments (both\ntables with window id as keys and dimension table as values) and returns\narray of same shaped data.\nExample:\n- Input: >lua\n\n -- First\n { [1000] = {width = 7, height = 5}, [1001] = {width = 7, height = 10} }\n -- Second\n { [1000] = {width = 9, height = 5}, [1001] = {width = 5, height = 10} }\n -- Means window 1000 increased its width by 2 in expense of window 1001\n<\n- The following output demonstrates equal resizing: >lua\n\n {\n { [1000] = {width = 8, height = 5}, [1001] = {width = 6, height = 10} },\n { [1000] = {width = 9, height = 5}, [1001] = {width = 5, height = 10} },\n }\n<\nSee |MiniAnimate.gen_subresize| for builtin subresize generators.\n\nNotes:\n\n- As resize animation is essentially a precisely scheduled non-blocking\n subresizes, this has two important interconnected consequences:\n - If another resize is attempted during the animation, it is done based\n on the **currently visible** window sizes. This might affect relative\n resizing.\n - It breaks the use of several relative resizing commands in the same\n command. Use |MiniAnimate.execute_after()| to schedule action after\n reaching target window sizes.\n\nConfiguration example: >lua\n\n local is_many_wins = function(sizes_from, sizes_to)\n return vim.tbl_count(sizes_from) >= 3\n end\n local animate = require('mini.animate')\n animate.setup({\n resize = {\n -- Animate for 200 milliseconds with linear easing\n timing = animate.gen_timing.linear({ duration = 200, unit = 'total' }),\n\n -- Animate only if there are at least 3 windows\n subresize = animate.gen_subscroll.equal({ predicate = is_many_wins }),\n }\n })\n<\nAfter animation is done, `MiniAnimateDoneResize` event is triggered.\n\n# Window open/close ~\n*MiniAnimate.config.open*\n*MiniAnimate.config.close*\n\nThese animations are similarly triggered for regular (non-floating) window\nopen/close. Their visualization step consists from drawing empty floating\nwindow with customizable config and transparency.\n\nExact window visualization characteristics are controlled by `winconfig`\nand `winblend` options.\n\nThe `winconfig` option is a callable which takes window id (|window-ID|) as\ninput and returns an array of floating window configs (as in `config`\nargument of |nvim_open_win()|). Its length determines number of animation steps.\nExample:\n- The following output results into two animation steps with second being\n upper left quarter of a first: >lua\n\n {\n {\n row = 0, col = 0,\n width = 10, height = 10,\n relative = 'editor', anchor = 'NW', focusable = false,\n zindex = 1, border = 'none', style = 'minimal',\n },\n {\n row = 0, col = 0,\n width = 5, height = 5,\n relative = 'editor', anchor = 'NW', focusable = false,\n zindex = 1, border = 'none', style = 'minimal',\n },\n }\n<\nThe `winblend` option is similar to `timing` option: it is a callable\nwhich, given current and total step numbers, returns value of floating\nwindow's 'winblend' option. Note, that it is called for current step (so\nstarts from 0), as opposed to `timing` which is called before step.\nExample:\n- Function `function(s, n) return 80 + 20 * s / n end` results in linear\n transition from `winblend` value of 80 to 100.\n\nSee |MiniAnimate.gen_winconfig| for builtin window config generators.\nSee |MiniAnimate.gen_winblend| for builtin window transparency generators.\n\nConfiguration example: >lua\n\n local animate = require('mini.animate')\n animate.setup({\n open = {\n -- Animate for 400 milliseconds with linear easing\n timing = animate.gen_timing.linear({ duration = 400, unit = 'total' }),\n\n -- Animate with wiping from nearest edge instead of default static one\n winconfig = animate.gen_winconfig.wipe({ direction = 'from_edge' }),\n\n -- Make bigger windows more transparent\n winblend = animate.gen_winblend.linear({ from = 80, to = 100 }),\n },\n\n close = {\n -- Animate for 400 milliseconds with linear easing\n timing = animate.gen_timing.linear({ duration = 400, unit = 'total' }),\n\n -- Animate with wiping to nearest edge instead of default static one\n winconfig = animate.gen_winconfig.wipe({ direction = 'to_edge' }),\n\n -- Make bigger windows more transparent\n winblend = animate.gen_winblend.linear({ from = 100, to = 80 }),\n },\n })\n<\nAfter animation is done, `MiniAnimateDoneOpen` or `MiniAnimateDoneClose`\nevent is triggered for `open` and `close` animation respectively.\n\n------------------------------------------------------------------------------\n *MiniAnimate.is_active()*\n `MiniAnimate.is_active`({animation_type})\nCheck animation activity\n\nParameters ~\n{animation_type} `(string)` One of supported animation types\n (entries of |MiniAnimate.config|, like `'cursor'`, etc.).\n\nReturn ~\n`(boolean)` Whether the animation is currently active.\n\n------------------------------------------------------------------------------\n *MiniAnimate.execute_after()*\n `MiniAnimate.execute_after`({animation_type}, {action})\nExecute action after some animation is done\n\nExecute action immediately if animation is not active (checked with\n|MiniAnimate.is_active()|). Else, schedule its execution until after\nanimation is done (on corresponding \"done event\", see\n|MiniAnimate-done-event|).\n\nMostly meant to be used inside mappings.\n\nExample:\n\nA useful `nnoremap n nzvzz` mapping (consecutive application of |n|, |zv|, and |zz|)\nshould be expressed in the following way: >lua\n\n 'lua vim.cmd(\"normal! n\"); ' ..\n 'MiniAnimate.execute_after(\"scroll\", \"normal! zvzz\")'\n<\nParameters ~\n{animation_type} `(string)` One of supported animation types\n (as in |MiniAnimate.is_active()|).\n{action} `(string|function)` Action to be executed. If string, executed as\n command (via |vim.cmd()|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.animate()*\n `MiniAnimate.animate`({step_action}, {step_timing}, {opts})\nAnimate action\n\nThis is equivalent to asynchronous execution of the following algorithm:\n- Call `step_action(0)` immediately after calling this function. Stop if\n action returned `false` or `nil`.\n- Wait `step_timing(1)` milliseconds.\n- Call `step_action(1)`. Stop if it returned `false` or `nil`.\n- Wait `step_timing(2)` milliseconds.\n- Call `step_action(2)`. Stop if it returned `false` or `nil`.\n- ...\n\nNotes:\n- Animation is also stopped on action error or if maximum number of steps\n is reached.\n- Asynchronous execution is done with |uv.new_timer()|. It only allows\n integer parts as repeat value. This has several implications:\n - Outputs of `step_timing()` are accumulated in order to preserve total\n execution time.\n - Any wait time less than 1 ms means that action will be executed\n immediately.\n\nParameters ~\n{step_action} `(function|table)` Callable which takes `step` (integer 0, 1, 2,\n etc. indicating current step) and executes some action. Its return value\n defines when animation should stop: values `false` and `nil` (equivalent\n to no explicit return) stop animation timer; any other continues it.\n{step_timing} `(function|table)` Callable which takes `step` (integer 1, 2, etc.\n indicating next step) and returns how many milliseconds to wait before\n executing this step action.\n{opts} `(table|nil)` Options. Possible fields:\n - - Maximum value of allowed step to execute. Default: 10000000.\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_timing*\n `MiniAnimate.gen_timing`\nGenerate animation timing\n\nEach field corresponds to one family of progression which can be customized\nfurther by supplying appropriate arguments.\n\nThis is a table with function elements. Call to actually get timing function.\n\nExample: >lua\n\n local animate = require('mini.animate')\n animate.setup({\n cursor = {\n timing = animate.gen_timing.linear({ duration = 100, unit = 'total' })\n },\n })\n<\nSee also ~\n|MiniIndentscope.gen_animation| for similar concept in 'mini.indentscope'.\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_timing.none()*\n `MiniAnimate.gen_timing.none`()\nGenerate timing with no animation\n\nShow final result immediately. Usually better to use `enable` field in `config`\nif you want to disable animation.\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_timing.linear()*\n `MiniAnimate.gen_timing.linear`({opts})\nGenerate timing with linear progression\n\nParameters ~\n{opts} `(table|nil)` Options that control progression. Possible keys:\n - `(string)` - a subtype of progression. One of \"in\"\n (accelerating from zero speed), \"out\" (decelerating to zero speed),\n \"in-out\" (default; accelerating halfway, decelerating after).\n - `(number)` - duration (in ms) of a unit. Default: 20.\n - `(string)` - which unit's duration `opts.duration` controls. One\n of \"step\" (default; ensures average duration of step to be `opts.duration`)\n or \"total\" (ensures fixed total duration regardless of scope's range).\n\nReturn ~\n`(function)` Timing function (see |MiniAnimate-timing|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_timing.quadratic()*\n `MiniAnimate.gen_timing.quadratic`({opts})\nGenerate timing with quadratic progression\n\nParameters ~\n{opts} `(table|nil)` Options that control progression. Possible keys:\n - `(string)` - a subtype of progression. One of \"in\"\n (accelerating from zero speed), \"out\" (decelerating to zero speed),\n \"in-out\" (default; accelerating halfway, decelerating after).\n - `(number)` - duration (in ms) of a unit. Default: 20.\n - `(string)` - which unit's duration `opts.duration` controls. One\n of \"step\" (default; ensures average duration of step to be `opts.duration`)\n or \"total\" (ensures fixed total duration regardless of scope's range).\n\nReturn ~\n`(function)` Timing function (see |MiniAnimate-timing|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_timing.cubic()*\n `MiniAnimate.gen_timing.cubic`({opts})\nGenerate timing with cubic progression\n\nParameters ~\n{opts} `(table|nil)` Options that control progression. Possible keys:\n - `(string)` - a subtype of progression. One of \"in\"\n (accelerating from zero speed), \"out\" (decelerating to zero speed),\n \"in-out\" (default; accelerating halfway, decelerating after).\n - `(number)` - duration (in ms) of a unit. Default: 20.\n - `(string)` - which unit's duration `opts.duration` controls. One\n of \"step\" (default; ensures average duration of step to be `opts.duration`)\n or \"total\" (ensures fixed total duration regardless of scope's range).\n\nReturn ~\n`(function)` Timing function (see |MiniAnimate-timing|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_timing.quartic()*\n `MiniAnimate.gen_timing.quartic`({opts})\nGenerate timing with quartic progression\n\nParameters ~\n{opts} `(table|nil)` Options that control progression. Possible keys:\n - `(string)` - a subtype of progression. One of \"in\"\n (accelerating from zero speed), \"out\" (decelerating to zero speed),\n \"in-out\" (default; accelerating halfway, decelerating after).\n - `(number)` - duration (in ms) of a unit. Default: 20.\n - `(string)` - which unit's duration `opts.duration` controls. One\n of \"step\" (default; ensures average duration of step to be `opts.duration`)\n or \"total\" (ensures fixed total duration regardless of scope's range).\n\nReturn ~\n`(function)` Timing function (see |MiniAnimate-timing|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_timing.exponential()*\n `MiniAnimate.gen_timing.exponential`({opts})\nGenerate timing with exponential progression\n\nParameters ~\n{opts} `(table|nil)` Options that control progression. Possible keys:\n - `(string)` - a subtype of progression. One of \"in\"\n (accelerating from zero speed), \"out\" (decelerating to zero speed),\n \"in-out\" (default; accelerating halfway, decelerating after).\n - `(number)` - duration (in ms) of a unit. Default: 20.\n - `(string)` - which unit's duration `opts.duration` controls. One\n of \"step\" (default; ensures average duration of step to be `opts.duration`)\n or \"total\" (ensures fixed total duration regardless of scope's range).\n\nReturn ~\n`(function)` Timing function (see |MiniAnimate-timing|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_path*\n `MiniAnimate.gen_path`\nGenerate cursor animation path\n\nFor more information see |MiniAnimate.config.cursor|.\n\nThis is a table with function elements. Call to actually get generator.\n\nExample: >lua\n\n local animate = require('mini.animate')\n animate.setup({\n cursor = {\n -- Animate with line-column angle instead of shortest line\n path = animate.gen_path.angle(),\n }\n })\n<\n------------------------------------------------------------------------------\n *MiniAnimate.gen_path.line()*\n `MiniAnimate.gen_path.line`({opts})\nGenerate path as shortest line\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(function)` - a callable which takes `destination` as input and\n returns boolean value indicating whether animation should be done.\n Default: `false` if `destination` is within one line of origin (reduces\n flickering), `true` otherwise.\n - `(number)` - maximum number of steps in output.\n Default: 1000.\n\nReturn ~\n`(function)` Path function (see |MiniAnimate.config.cursor|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_path.angle()*\n `MiniAnimate.gen_path.angle`({opts})\nGenerate path as line/column angle\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(function)` - a callable which takes `destination` as input and\n returns boolean value indicating whether animation should be done.\n Default: `false` if `destination` is within one line of origin (reduces\n flickering), `true` otherwise.\n - `(number)` - maximum number of steps per side in output.\n Default: 1000.\n - `(string)` - one of `\"horizontal\"` (default; animates\n across initial line first) or `\"vertical\"` (animates across initial\n column first).\n\nReturn ~\n`(function)` Path function (see |MiniAnimate.config.cursor|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_path.walls()*\n `MiniAnimate.gen_path.walls`({opts})\nGenerate path as closing walls at final position\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(function)` - a callable which takes `destination` as input and\n returns boolean value indicating whether animation should be done.\n Default: `false` if `destination` is within one line of origin (reduces\n flickering), `true` otherwise.\n - `(number)` - initial width of left and right walls. Default: 10.\n\nReturn ~\n`(function)` Path function (see |MiniAnimate.config.cursor|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_path.spiral()*\n `MiniAnimate.gen_path.spiral`({opts})\nGenerate path as diminishing spiral at final position\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(function)` - a callable which takes `destination` as input and\n returns boolean value indicating whether animation should be done.\n Default: `false` if `destination` is within one line of origin (reduces\n flickering), `true` otherwise.\n - `(number)` - initial width of spiral. Default: 2.\n\nReturn ~\n`(function)` Path function (see |MiniAnimate.config.cursor|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_subscroll*\n `MiniAnimate.gen_subscroll`\nGenerate scroll animation subscroll\n\nFor more information see |MiniAnimate.config.scroll|.\n\nThis is a table with function elements. Call to actually get generator.\n\nExample: >lua\n\n local animate = require('mini.animate')\n animate.setup({\n scroll = {\n -- Animate equally but with 120 maximum steps instead of default 60\n subscroll = animate.gen_subscroll.equal({ max_output_steps = 120 }),\n }\n })\n<\n------------------------------------------------------------------------------\n *MiniAnimate.gen_subscroll.equal()*\n `MiniAnimate.gen_subscroll.equal`({opts})\nGenerate subscroll with equal steps\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(function)` - a callable which takes `total_scroll` as\n input and returns boolean value indicating whether animation should be\n done. Default: `false` if `total_scroll` is 1 or less (reduces\n unnecessary waiting), `true` otherwise.\n - `(number)` - maximum number of subscroll steps in output.\n Adjust this to reduce computations in expense of reduced smoothness.\n Default: 60.\n\nReturn ~\n`(function)` Subscroll function (see |MiniAnimate.config.scroll|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_subresize*\n `MiniAnimate.gen_subresize`\nGenerate resize animation subresize\n\nFor more information see |MiniAnimate.config.resize|.\n\nThis is a table with function elements. Call to actually get generator.\n\nExample: >lua\n\n local is_many_wins = function(sizes_from, sizes_to)\n return vim.tbl_count(sizes_from) >= 3\n end\n local animate = require('mini.animate')\n animate.setup({\n resize = {\n -- Animate only if there are at least 3 windows\n subresize = animate.gen_subresize.equal({ predicate = is_many_wins }),\n }\n })\n<\n------------------------------------------------------------------------------\n *MiniAnimate.gen_subresize.equal()*\n `MiniAnimate.gen_subresize.equal`({opts})\nGenerate subresize with equal steps\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(function)` - a callable which takes `sizes_from` and\n `sizes_to` as input and returns boolean value indicating whether\n animation should be done. Default: always `true`.\n\nReturn ~\n`(function)` Subresize function (see |MiniAnimate.config.resize|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_winconfig*\n `MiniAnimate.gen_winconfig`\nGenerate open/close animation winconfig\n\nFor more information see |MiniAnimate.config.open| or |MiniAnimate.config.close|.\n\nThis is a table with function elements. Call to actually get generator.\n\nExample: >lua\n\n local is_not_single_window = function(win_id)\n local tabpage_id = vim.api.nvim_win_get_tabpage(win_id)\n return #vim.api.nvim_tabpage_list_wins(tabpage_id) > 1\n end\n local animate = require('mini.animate')\n animate.setup({\n open = {\n -- Animate with wiping from nearest edge instead of default static one\n -- and only if it is not a single window in tabpage\n winconfig = animate.gen_winconfig.wipe({\n predicate = is_not_single_window,\n direction = 'from_edge',\n }),\n },\n close = {\n -- Animate with wiping to nearest edge instead of default static one\n -- and only if it is not a single window in tabpage\n winconfig = animate.gen_winconfig.wipe({\n predicate = is_not_single_window,\n direction = 'to_edge',\n }),\n },\n })\n<\n------------------------------------------------------------------------------\n *MiniAnimate.gen_winconfig.static()*\n `MiniAnimate.gen_winconfig.static`({opts})\nGenerate winconfig for static floating window\n\nThis will result into floating window statically covering whole target\nwindow.\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(function)` - a callable which takes `win_id` as input and\n returns boolean value indicating whether animation should be done.\n Default: always `true`.\n - `(number)` - number of output steps, all with same config.\n Useful to tweak smoothness of transparency animation (done inside\n `winblend` config option). Default: 25.\n\nReturn ~\n`(function)` Winconfig function (see |MiniAnimate.config.open|\n or |MiniAnimate.config.close|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_winconfig.center()*\n `MiniAnimate.gen_winconfig.center`({opts})\nGenerate winconfig for center-focused animated floating window\n\nThis will result into floating window growing from or shrinking to the\ntarget window center.\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(function)` - a callable which takes `win_id` as input and\n returns boolean value indicating whether animation should be done.\n Default: always `true`.\n - `(string)` - one of `\"to_center\"` (default; window will\n shrink from full coverage to center) or `\"from_center\"` (window will\n grow from center to full coverage).\n\nReturn ~\n`(function)` Winconfig function (see |MiniAnimate.config.open|\n or |MiniAnimate.config.close|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_winconfig.wipe()*\n `MiniAnimate.gen_winconfig.wipe`({opts})\nGenerate winconfig for wiping animated floating window\n\nThis will result into floating window growing from or shrinking to the\nnearest edge. This also takes into account the split type of target window:\nvertically split window will progress towards vertical edge; horizontally -\ntowards horizontal.\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(function)` - a callable which takes `win_id` as input and\n returns boolean value indicating whether animation should be done.\n Default: always `true`.\n - `(string)` - one of `\"to_edge\"` (default; window will\n shrink from full coverage to nearest edge) or `\"from_edge\"` (window\n will grow from edge to full coverage).\n\nReturn ~\n`(function)` Winconfig function (see |MiniAnimate.config.open|\n or |MiniAnimate.config.close|).\n\n------------------------------------------------------------------------------\n *MiniAnimate.gen_winblend*\n `MiniAnimate.gen_winblend`\nGenerate open/close animation `winblend` progression\n\nFor more information see |MiniAnimate.config.open| or |MiniAnimate.config.close|.\n\nThis is a table with function elements. Call to actually get transparency\nfunction.\n\nExample: >lua\n\n local animate = require('mini.animate')\n animate.setup({\n open = {\n -- Change transparency from 60 to 80 instead of default 80 to 100\n winblend = animate.gen_winblend.linear({ from = 60, to = 80 }),\n },\n close = {\n -- Change transparency from 60 to 80 instead of default 80 to 100\n winblend = animate.gen_winblend.linear({ from = 60, to = 80 }),\n },\n })\n<\n------------------------------------------------------------------------------\n *MiniAnimate.gen_winblend.linear()*\n `MiniAnimate.gen_winblend.linear`({opts})\nGenerate linear `winblend` progression\n\nParameters ~\n{opts} `(table|nil)` Options that control generator. Possible keys:\n - `(number)` - initial value of 'winblend'.\n - `(number)` - final value of 'winblend'.\n\nReturn ~\n`(function)` Winblend function (see |MiniAnimate.config.open|\n or |MiniAnimate.config.close|).\n\n\n vim:tw=78:ts=8:noet:ft=help:norl:"
},
{
"path": "doc/mini-base16.txt",
"content": "*mini.base16* Base16 colorscheme creation\n\nMIT License Copyright (c) 2021 Evgeni Chasnovski\n\n------------------------------------------------------------------------------\n *MiniBase16*\nFast implementation of [chriskempson/base16](https://github.com/chriskempson/base16)\ncolor scheme (with Copyright (C) 2012 Chris Kempson) adapted for modern Neovim\nLua plugins. Extra features:\n- Configurable automatic support of cterm colors (see |highlight-cterm|).\n- Opinionated palette generator based only on background and foreground\n colors.\n\nSupported highlight groups:\n- Built-in Neovim LSP and diagnostic.\n\n- Plugins (either with explicit definition or by verification that default\n highlighting works appropriately):\n - [nvim-mini/mini.nvim](https://nvim-mini.org/mini.nvim)\n - [akinsho/bufferline.nvim](https://github.com/akinsho/bufferline.nvim)\n - [anuvyklack/hydra.nvim](https://github.com/anuvyklack/hydra.nvim)\n - [DanilaMihailov/beacon.nvim](https://github.com/DanilaMihailov/beacon.nvim)\n - [folke/lazy.nvim](https://github.com/folke/lazy.nvim)\n - [folke/noice.nvim](https://github.com/folke/noice.nvim)\n - [folke/snacks.nvim](https://github.com/folke/snacks.nvim)\n - [folke/todo-comments.nvim](https://github.com/folke/todo-comments.nvim)\n - [folke/trouble.nvim](https://github.com/folke/trouble.nvim)\n - [folke/which-key.nvim](https://github.com/folke/which-key.nvim)\n - [ggandor/leap.nvim](https://github.com/ggandor/leap.nvim)\n - [ggandor/lightspeed.nvim](https://github.com/ggandor/lightspeed.nvim)\n - [glepnir/dashboard-nvim](https://github.com/glepnir/dashboard-nvim)\n - [glepnir/lspsaga.nvim](https://github.com/glepnir/lspsaga.nvim)\n - [HiPhish/rainbow-delimiters.nvim](https://github.com/HiPhish/rainbow-delimiters.nvim)\n - [hrsh7th/nvim-cmp](https://github.com/hrsh7th/nvim-cmp)\n - [justinmk/vim-sneak](https://github.com/justinmk/vim-sneak)\n - [ibhagwan/fzf-lua](https://github.com/ibhagwan/fzf-lua)\n - [kevinhwang91/nvim-bqf](https://github.com/kevinhwang91/nvim-bqf)\n - [kevinhwang91/nvim-ufo](https://github.com/kevinhwang91/nvim-ufo)\n - [lewis6991/gitsigns.nvim](https://github.com/lewis6991/gitsigns.nvim)\n - [lukas-reineke/indent-blankline.nvim](https://github.com/lukas-reineke/indent-blankline.nvim)\n - [MeanderingProgrammer/render-markdown.nvim](https://github.com/MeanderingProgrammer/render-markdown.nvim)\n - [neoclide/coc.nvim](https://github.com/neoclide/coc.nvim)\n - [NeogitOrg/neogit](https://github.com/NeogitOrg/neogit)\n - [nvim-lualine/lualine.nvim](https://github.com/nvim-lualine/lualine.nvim)\n - [nvim-neo-tree/neo-tree.nvim](https://github.com/nvim-neo-tree/neo-tree.nvim)\n - [nvim-telescope/telescope.nvim](https://github.com/nvim-telescope/telescope.nvim)\n - [nvim-tree/nvim-tree.lua](https://github.com/nvim-tree/nvim-tree.lua)\n - [OXY2DEV/helpview.nvim](https://github.com/OXY2DEV/helpview.nvim)\n - [OXY2DEV/markview.nvim](https://github.com/OXY2DEV/markview.nvim)\n - [phaazon/hop.nvim](https://github.com/phaazon/hop.nvim)\n - [rcarriga/nvim-dap-ui](https://github.com/rcarriga/nvim-dap-ui)\n - [rcarriga/nvim-notify](https://github.com/rcarriga/nvim-notify)\n - [rlane/pounce.nvim](https://github.com/rlane/pounce.nvim)\n - [romgrk/barbar.nvim](https://github.com/romgrk/barbar.nvim)\n - [stevearc/aerial.nvim](https://github.com/stevearc/aerial.nvim)\n - [williamboman/mason.nvim](https://github.com/williamboman/mason.nvim)\n\n# Setup ~\n\nThis module needs a setup with `require('mini.base16').setup({})` (replace\n`{}` with your `config` table). It will create global Lua table\n`MiniBase16` which you can use for scripting or manually (with\n`:lua MiniBase16.*`).\n\nSee |MiniBase16.config| for `config` structure and default values.\n\nThis module doesn't have runtime options, so using `vim.b.minibase16_config`\nwill have no effect here.\n\nExample: >lua\n\n require('mini.base16').setup({\n palette = {\n base00 = '#112641',\n base01 = '#3a475e',\n base02 = '#606b81',\n base03 = '#8691a7',\n base04 = '#d5dc81',\n base05 = '#e2e98f',\n base06 = '#eff69c',\n base07 = '#fcffaa',\n base08 = '#ffcfa0',\n base09 = '#cc7e46',\n base0A = '#46a436',\n base0B = '#9ff895',\n base0C = '#ca6ecf',\n base0D = '#42f7ff',\n base0E = '#ffc4ff',\n base0F = '#00a5c5',\n },\n use_cterm = true,\n plugins = {\n default = false,\n ['nvim-mini/mini.nvim'] = true,\n },\n })\n<\n# Notes ~\n\n1. This is used to create some of plugin's color schemes\n (see |MiniBase16-color-schemes|).\n2. Using `setup()` doesn't actually create a |:colorscheme|. It basically\n creates a coordinated set of |highlight-groups|. To create your own theme:\n - Put \"myscheme.lua\" file (name after your chosen theme name) inside\n any \"colors\" directory reachable from 'runtimepath' (\"colors\" inside\n your Neovim config directory is usually enough).\n - Inside \"myscheme.lua\" call `require('mini.base16').setup()` with your\n palette and only after that set |g:colors_name| to \"myscheme\".\n\n------------------------------------------------------------------------------\n *MiniBase16-color-schemes*\n# Base16 colorschemes ~\n\nThis module comes with several pre-built color schemes. Each of them is\na |mini.base16| theme created with faster version of the following Lua code: >lua\n\n require('mini.base16').setup({ palette = palette, use_cterm = true })\n<\nActivate them as regular |:colorscheme| (for example, `:colorscheme minischeme`).\n\n## minischeme ~\n*minischeme*\n\nBlue and yellow main colors with high contrast and saturation palette.\nPalettes are: >lua\n\n -- For dark 'background':\n MiniBase16.mini_palette('#112641', '#e2e98f', 75)\n\n -- For light 'background':\n MiniBase16.mini_palette('#e2e5ca', '#002a83', 75)\n<\n## minicyan ~\n*minicyan*\n\nCyan and grey main colors with moderate contrast and saturation palette.\nPalettes are: >lua\n\n -- For dark 'background':\n MiniBase16.mini_palette('#0A2A2A', '#D0D0D0', 50)\n\n -- For light 'background':\n MiniBase16.mini_palette('#C0D2D2', '#262626', 80)\n<\n------------------------------------------------------------------------------\n *MiniBase16.setup()*\n `MiniBase16.setup`({config})\nModule setup\n\nSetup is done by applying base16 palette to enable colorscheme. Highlight\ngroups make an extended set from original\n[base16-vim](https://github.com/chriskempson/base16-vim/) plugin. It is a\ngood idea to have `config.palette` respect the original [styling\nprinciples](https://github.com/chriskempson/base16/blob/master/styling.md).\n\nBy default only 'gui highlighting' (see |highlight-gui| and\n|'termguicolors'|) is supported. To support 'cterm highlighting' (see\n|highlight-cterm|) supply `config.use_cterm` argument in one of the formats:\n- `true` to auto-generate from `palette` (as closest colors).\n- Table with similar structure to `palette` but having terminal colors\n (integers from 0 to 255) instead of hex strings.\n\nParameters ~\n{config} `(table)` Module config table. See |MiniBase16.config|.\n\nUsage ~\n>lua\n require('mini.base16').setup({}) -- replace {} with your config table\n -- needs `palette` field present\n<\n------------------------------------------------------------------------------\n *MiniBase16.config*\n `MiniBase16.config`\nDefaults ~\n>lua\n MiniBase16.config = {\n -- Table with names from `base00` to `base0F` and values being strings of\n -- HEX colors with format \"#RRGGBB\". NOTE: this should be explicitly\n -- supplied in `setup()`.\n palette = nil,\n\n -- Whether to support cterm colors. Can be boolean, `nil` (same as\n -- `false`), or table with cterm colors. See `setup()` documentation for\n -- more information.\n use_cterm = nil,\n\n -- Plugin integrations. Use `default = false` to disable all integrations.\n -- Also can be set per plugin (see |MiniBase16.config|).\n plugins = { default = true },\n }\n<\n# Plugin integrations ~\n\n`config.plugins` defines for which supported plugins highlight groups will\nbe created. Limiting number of integrations slightly decreases startup time.\nIt is a table with boolean (`true`/`false`) values which are applied as follows:\n- If plugin name (as listed in |mini.base16|) has entry, it is used.\n- Otherwise `config.plugins.default` is used.\n\nExample which will load only \"mini.nvim\" integration: >lua\n\n require('mini.base16').setup({\n palette = require('mini.base16').mini_palette('#112641', '#e2e98f', 75),\n plugins = {\n default = false,\n ['nvim-mini/mini.nvim'] = true,\n }\n })\n<\n------------------------------------------------------------------------------\n *MiniBase16.mini_palette()*\n `MiniBase16.mini_palette`({background}, {foreground}, {accent_chroma})\nCreate 'mini' palette\n\nCreate base16 palette based on the HEX (string '#RRGGBB') colors of main\nbackground and foreground with optional setting of accent chroma (see\ndetails).\n\n# Algorithm design ~\n\n- Main operating color space is\n [CIELCh(uv)](https://en.wikipedia.org/wiki/CIELUV#Cylindrical_representation_(CIELCh))\n which is a cylindrical representation of a perceptually uniform CIELUV\n color space. It defines color by three values: lightness L (values from 0\n to 100), chroma (positive values), and hue (circular values from 0 to 360\n degrees). Useful converting tool: https://www.easyrgb.com/en/convert.php\n- There are four important lightness values: background, foreground, focus\n (around the middle of background and foreground, leaning towards\n foreground), and edge (extreme lightness closest to foreground).\n- First four colors have the same chroma and hue as `background` but\n lightness progresses from background towards focus.\n- Second four colors have the same chroma and hue as `foreground` but\n lightness progresses from foreground towards edge in such a way that\n 'base05' color is main foreground color.\n- The rest eight colors are accent colors which are created in pairs\n - Each pair has same hue from set of hues 'most different' to\n background and foreground hues (if respective chorma is positive).\n - All colors have the same chroma equal to `accent_chroma` (if not\n provided, chroma of foreground is used, as they will appear next\n to each other). Note: this means that in case of low foreground\n chroma, it is a good idea to set `accent_chroma` manually.\n Values from 30 (low chorma) to 80 (high chroma) are common.\n - Within pair there is base lightness (equal to foreground\n lightness) and alternative (equal to focus lightness). Base\n lightness goes to colors which will be used more frequently in\n code: base08 (variables), base0B (strings), base0D (functions),\n base0E (keywords).\n How exactly accent colors are mapped to base16 palette is a result of\n trial and error. One rule of thumb was: colors within one hue pair should\n be more often seen next to each other. This is because it is easier to\n distinguish them and seems to be more visually appealing. That is why\n `base0D` and `base0F` have same hues because they usually represent\n functions and delimiter (brackets included).\n\nParameters ~\n{background} `(string)` Background HEX color (formatted as `#RRGGBB`).\n{foreground} `(string)` Foreground HEX color (formatted as `#RRGGBB`).\n{accent_chroma} `(number)` Optional positive number (usually between 0\n and 100). Default: chroma of foreground color.\n\nReturn ~\n`(table)` Table with base16 palette.\n\nUsage ~\n>lua\n local p = require('mini.base16').mini_palette('#112641', '#e2e98f', 75)\n require('mini.base16').setup({ palette = p })\n<\n------------------------------------------------------------------------------\n *MiniBase16.rgb_palette_to_cterm_palette()*\n `MiniBase16.rgb_palette_to_cterm_palette`({palette})\nConverts palette with RGB colors to terminal colors\n\nUseful for caching `use_cterm` variable to increase speed.\n\nParameters ~\n{palette} `(table)` Table with base16 palette (same as in\n `MiniBase16.config.palette`).\n\nReturn ~\n`(table)` Table with base16 palette using |highlight-cterm|.\n\n\n vim:tw=78:ts=8:noet:ft=help:norl:"
},
{
"path": "doc/mini-basics.txt",
"content": "*mini.basics* Common configuration presets\n\nMIT License Copyright (c) 2023 Evgeni Chasnovski\n\n------------------------------------------------------------------------------\n *MiniBasics*\nInstall, create 'init.lua', add `require('mini.basics').setup()`, and you\nare good to go.\n\nFeatures:\n- Presets for common options. It will only change option if it wasn't\n manually set before. See more in |MiniBasics.config.options|.\n\n- Presets for common mappings. It will only add a mapping if it wasn't\n manually created before. See more in |MiniBasics.config.mappings|.\n\n- Presets for common autocommands. See more in |MiniBasics.config.autocommands|.\n\n- Reverse compatibility is a high priority. Any decision to change already\n present behavior will be made with great care.\n\nNotes:\n- Main goal of this module is to provide a relatively easier way for\n new-ish Neovim users to have better \"works out of the box\" experience\n while having documented relevant options/mappings/autocommands to study.\n It is based partially on survey among Neovim users and partially is\n coming from personal preferences.\n\n However, more seasoned users almost surely will find something useful.\n\n Still, it is recommended to read about used options/mappings/autocommands\n and decide if they are needed. The main way to do that is by reading\n Neovim's help pages (linked in help file) and this module's source code\n (thoroughly documented for easier comprehension).\n\n# Setup ~\n\nThis module needs a setup with `require('mini.basics').setup({})` (replace\n`{}` with your `config` table). It will create global Lua table `MiniBasics`\nwhich you can use for scripting or manually (with `:lua MiniBasics.*`).\n\nSee |MiniBasics.config| for available config settings.\n\nTo stop module from showing non-error feedback, set `config.silent = true`.\n\n# Comparisons ~\n\n- [tpope/vim-sensible](https://github.com/tpope/vim-sensible):\n - Most of 'tpope/vim-sensible' is already incorporated as default\n options in Neovim (see |nvim-defaults|). This module has a much\n broader effect.\n- [tpope/vim-unimpaired](https://github.com/tpope/vim-unimpaired):\n - The 'tpope/vim-unimpaired' has mapping for toggling options with `yo`\n prefix. This module implements similar functionality with `\\` prefix\n (see |MiniBasics.config.mappings|).\n\n------------------------------------------------------------------------------\n *MiniBasics.setup()*\n `MiniBasics.setup`({config})\nModule setup\n\nParameters ~\n{config} `(table|nil)` Module config table. See |MiniBasics.config|.\n\nUsage ~\n>lua\n require('mini.basics').setup() -- use default config\n -- OR\n require('mini.basics').setup({}) -- replace {} with your config table\n<\n------------------------------------------------------------------------------\n *MiniBasics.config*\n `MiniBasics.config`\nDefaults ~\n>lua\n MiniBasics.config = {\n -- Options. Set field to `false` to disable.\n options = {\n -- Basic options ('number', 'ignorecase', and many more)\n basic = true,\n\n -- Extra UI features ('winblend', 'listchars', 'pumheight', ...)\n extra_ui = false,\n\n -- Presets for window borders ('single', 'double', ...)\n -- Default 'auto' infers from 'winborder' option\n win_borders = 'auto',\n },\n\n -- Mappings. Set field to `false` to disable.\n mappings = {\n -- Basic mappings (better 'jk', save with Ctrl+S, ...)\n basic = true,\n\n -- Prefix for mappings that toggle common options ('wrap', 'spell', ...).\n -- Supply empty string to not create these mappings.\n option_toggle_prefix = [[\\]],\n\n -- Window navigation with , resize with \n windows = false,\n\n -- Move cursor in Insert, Command, and Terminal mode with \n move_with_alt = false,\n },\n\n -- Autocommands. Set field to `false` to disable\n autocommands = {\n -- Basic autocommands (highlight on yank, start Insert in terminal, ...)\n basic = true,\n\n -- Set 'relativenumber' only in linewise and blockwise Visual mode\n relnum_in_visual_mode = false,\n },\n\n -- Whether to disable showing non-error feedback\n silent = false,\n }\n<\n# Options ~\n*MiniBasics.config.options*\n\nUsage example: >lua\n\n require('mini.basics').setup({\n options = {\n basic = true,\n extra_ui = true,\n win_borders = 'double',\n }\n })\n<\n## options.basic ~\n\nThe `config.options.basic` sets certain options to values which are quite\ncommonly used (judging by study of available Neovim pre-configurations,\npublic dotfiles, and surveys).\nAny option is changed only if it was not set manually beforehand.\nFor exact changes, please see source code ('lua/mini/basics.lua').\n\nHere is the list of affected options (put cursor on it and press |CTRL-]|):\n- General:\n - Sets || key to ||. Be sure to make all Leader mappings\n after this (otherwise they are made with default ).\n - Runs `:filetype plugin indent on` (see |:filetype-overview|)\n - |'backup'|\n - |'mouse'|\n - |'undofile'|\n - |'writebackup'|\n- Appearance\n - |'breakindent'|\n - |'cursorline'|\n - |'fillchars'|\n - |'linebreak'|\n - |'number'|\n - |'ruler'|\n - |'showmode'|\n - |'signcolumn'|\n - |'shortmess'|\n - |'splitbelow'|\n - |'splitkeep'|\n - |'splitright'|\n - |'termguicolors'| (on Neovim<0.10; later versions have it smartly enabled)\n - |'wrap'|\n- Editing\n - |'completeopt'|\n - |'formatoptions'|\n - |'ignorecase'|\n - |'incsearch'|\n - |'infercase'|\n - |'smartcase'|\n - |'smartindent'|\n - |'virtualedit'|\n\n## options.extra_ui ~\n\nThe `config.options.extra_ui` sets certain options for visual appearance\nwhich might not be aligned with common preferences, but still worth trying.\nAny option is changed only if it was not set manually beforehand.\nFor exact changes, please see source code ('lua/mini/basics.lua').\n\nList of affected options:\n- |'list'|\n- |'listchars'|\n- |'pumblend'|\n- |'pumheight'|\n- |'winblend'|\n- Runs `:syntax on` (see |:syntax-on|)\n\n## options.win_borders ~\n\nThe `config.options.win_borders` updates |'fillchars'| to have a consistent set\nof characters for window border (`vert`, `horiz`, `msgsep`, etc.).\n\nAvailable values:\n- `'auto'` - infer from |'winborder'|. On Neovim<0.11 do nothing.\n- `'bold'` - bold lines.\n- `'dot'` - dot in every cell.\n- `'double'` - double line.\n- `'single'` - single line.\n- `'solid'` - no symbol, only background.\n\n# Mappings ~\n*MiniBasics.config.mappings*\n\nUsage example: >lua\n\n require('mini.basics').setup({\n mappings = {\n basic = true,\n option_toggle_prefix = [[\\]],\n windows = true,\n move_with_alt = true,\n }\n })\n<\nIf you want some mappings to be different or not made at all, set or delete\nthem after calling |MiniBasics.setup()|.\n\n## mappings.basic ~\n\nThe `config.mappings.basic` creates mappings for certain commonly mapped actions\n(judging by study of available Neovim pre-configurations and public dotfiles).\n\nSome of the mappings override built-in ones to either improve their\nbehavior or override its default not very useful action.\nIt will only add a mapping if it wasn't manually created before.\n\nHere is a table with created mappings : >\n\n |Keys | Modes | Description |\n |-------|-----------------|-----------------------------------------------|\n | j | Normal, Visual | Move down by visible lines with no [count] |\n | k | Normal, Visual | Move up by visible lines with no [count] |\n | go | Normal | Add [count] empty lines after cursor |\n | gO | Normal | Add [count] empty lines before cursor |\n | gy | Normal, Visual | Copy to system clipboard |\n | gp | Normal, Visual | Paste from system clipboard |\n | gV | Normal | Visually select latest changed or yanked text |\n | g/ | Visual | Search inside current visual selection |\n | * | Visual | Search forward for current visual selection |\n | # | Visual | Search backward for current visual selection |\n | | Normal, Visual, | Save and go to Normal mode |\n | | Insert | |\n<\nNotes:\n- See |[count]| for its meaning.\n- On Neovim>=0.10 mappings for `#` and `*` are not created as their\n enhanced variants are made built-in. See |v_star-default| and |v_#-default|.\n- On Neovim>=0.11 there are |[| / |]
![\"mini.nvim\"](\"logo.png\")