*lua.txt*    Nvim


                            NVIM REFERENCE MANUAL


Lua engine                                                           *lua* *Lua*

                                       Type |gO| to see the table of contents.

==============================================================================
INTRODUCTION                                                       *lua-intro*

The Lua 5.1 script engine is builtin and always available. Try this command to
get an idea of what lurks beneath: >vim

    :lua vim.print(package.loaded)

Nvim includes a "standard library" |lua-stdlib| for Lua.  It complements the
"editor stdlib" (|vimscript-functions| + |Ex-command|s) and the |API|, all of
which can be used from Lua code (|lua-vimscript| |vim.api|). These three
namespaces form the Nvim programming interface.

Lua plugins and user config are automatically discovered and loaded, just like
Vimscript. See |lua-guide| for practical guidance.

You can also run Lua scripts from your shell using the |-l| argument: >
    nvim -l foo.lua [args...]
<
                                                                  *lua-compat*
Lua 5.1 is the permanent interface for Nvim Lua. Plugins should target Lua 5.1
as specified in |luaref|; later versions (which are essentially different,
incompatible, dialects) are not supported. This includes extensions such as
`goto` that some Lua 5.1 interpreters like LuaJIT may support.

                                                                  *lua-luajit*
While Nvim officially only requires Lua 5.1 support, it should be built with
LuaJIT or a compatible fork on supported platforms for performance reasons.
LuaJIT also comes with useful extensions such as `ffi`, |lua-profile|, and
enhanced standard library functions; these cannot be assumed to be available,
and Lua code in |init.lua| or plugins should check the `jit` global variable
before using them: >lua
  if jit then
    -- code for luajit
  else
    -- code for plain lua 5.1
  end
<
One exception is the LuaJIT `bit` extension, which is always available: when
built with PUC Lua, Nvim includes a fallback implementation which provides
`require("bit")`. See |lua-bit|.

                                                                  *lua-profile*
If Nvim is built with LuaJIT, Lua code can be profiled via >lua
    -- Start a profiling session:
    require('jit.p').start('ri1', '/tmp/profile')

    -- Perform arbitrary tasks (use plugins, scripts, etc.) ...

    -- Stop the session. Profile is written to /tmp/profile.
    require('jit.p').stop()

See https://luajit.org/ext_profiler.html or the `p.lua` source for details: >
    :lua vim.cmd.edit(package.searchpath('jit.p', package.path))

==============================================================================
LUA CONCEPTS AND IDIOMS                                         *lua-concepts*

Lua is very simple, and _consistent_: while there are some quirks, once you
internalize those quirks, everything works the same everywhere. Scopes
(closures) in particular are very consistent, unlike JavaScript or most other
languages.

Lua has three fundamental mechanisms—one for "each major aspect of
programming": tables, closures, and coroutines.
https://www.lua.org/doc/cacm2018.pdf
- Tables are the "object" or container datastructure: they represent both
  lists and maps, you can extend them to represent your own datatypes and
  change their behavior using |metatable|s (like Python's "datamodel").
- EVERY scope in Lua is a closure: a function is a closure, a module is
  a closure, a `do` block (|lua-do|) is a closure--and they all work the same.
  A Lua module is literally just a big closure discovered on the "path"
  (where your modules are found: |package.cpath|).
- Stackful coroutines enable cooperative multithreading, generators, and
  versatile control for both Lua and its host (Nvim).

                                                          *lua-error-handling*
Lua functions may throw |lua-errors| for exceptional (unexpected) failures,
which you can handle with |pcall()|.
                                                       *lua-result-or-message*
When failure is normal and expected, it's idiomatic to return `nil` which
signals to the caller that failure is not "exceptional" and must be handled.
This "result-or-message" pattern is expressed as the multi-value return type
`any|nil,nil|string`, or in LuaLS notation: >

    ---@return any|nil    # result on success, nil on failure.
    ---@return nil|string # nil on success, error message on failure.
<
Examples of the "result-or-message" pattern:
- |vim.ui.open()|
- |io.open()|
- |luv-error-handling|

When a caller can't proceed on failure, it's idiomatic to `assert()` the
"result-or-message" result: >lua

    local value = assert(fn())

Guidance: use the "result-or-message" pattern for...
- Functions where failure is expected, especially when communicating with the
  external world. E.g. HTTP requests or LSP requests often fail because of
  server problems, even if the caller did everything right.
- Functions that return a value, e.g. Foo:new().
- When there is a list of known error codes which can be returned as a third
  value (like |luv-error-handling|).
<
                                                                    *iterator*
An iterator is just a function that can be called repeatedly to get the "next"
value of a collection (or any other |iterable|). This interface is expected by
|for-in| loops, produced by |pairs()|, supported by |vim.iter|, etc.
https://www.lua.org/pil/7.1.html

                                                                    *iterable*
An "iterable" is anything that |vim.iter()| can consume: tables, dicts, lists,
iterator functions, tables implementing the |__call()| metamethod, and
|vim.iter()| objects.

                                                               *list-iterator*
Iterators on |lua-list| tables have a "middle" and "end", whereas iterators in
general may be logically infinite. Therefore some |vim.iter| operations (e.g.
|Iter:rev()|) make sense only on list-like tables (which are finite by
definition).

                                                           *lua-function-call*
Lua functions can be called in multiple ways. Consider the function: >lua
    local foo = function(a, b)
        print("A: ", a)
        print("B: ", b)
    end

The first way to call this function is: >lua
    foo(1, 2)
    -- ==== Result ====
    -- A: 1
    -- B: 2

This way of calling a function is familiar from most scripting languages. In
Lua, any missing arguments are passed as `nil`, and extra parameters are
silently discarded. Example: >lua
    foo(1)
    -- ==== Result ====
    -- A: 1
    -- B: nil
<
                                                                      *kwargs*
When calling a function, you can omit the parentheses if the function takes
exactly one string literal (`"foo"`) or table literal (`{1,2,3}`). The latter
is often used to mimic "named parameters" ("kwargs" or "keyword args") as in
languages like Python and C#. Example: >lua
    local func_with_opts = function(opts)
        local will_do_foo = opts.foo
        local filename = opts.filename
        -- ...
    end

    func_with_opts { foo = true, filename = "hello.world" }
<
There's nothing special going on here except that parentheses are implicitly
added. But visually, this small bit of sugar gets reasonably close to a
"keyword args" interface.

                                                                   *lua-regex*
Lua intentionally does not support regular expressions, instead it has limited
|lua-pattern|s which avoid the performance pitfalls of extended regex. Lua
scripts can also use Vim regex via |vim.regex()|.

Examples: >lua

    print(string.match("foo123bar123", "%d+"))
    -- 123
    print(string.match("foo123bar123", "[^%d]+"))
    -- foo
    print(string.match("foo123bar123", "[abc]+"))
    -- ba
    print(string.match("foo.bar", "%.bar"))
    -- .bar
<
                                                                  *lua-truthy*
Only `false` and `nil` evaluate to "false" in Lua. All other values are "true".


==============================================================================
IMPORTING LUA MODULES                                        *lua-module-load*

Modules are searched for under the directories specified in 'runtimepath' and
|packages-runtimepath|, in the order they appear in the output of this command
>vim
    :echo nvim_list_runtime_paths()
<
Any "." in the module name is treated as a directory separator when searching.
For a module `foo.bar`, each directory is searched for `lua/foo/bar.lua`, then
`lua/foo/bar/init.lua`.  If no files are found, the directories are searched
again for a shared library with a name matching `lua/foo/bar.?`, where `?` is
a list of suffixes (such as `so` or `dll`) derived from the initial value of
|package.cpath|. If still no files are found, Nvim falls back to Lua's default
search mechanism. The first script found is run and `require()` returns the
value returned by the script if any, else `true`.

The return value is cached after the first call to `require()` for each module,
with subsequent calls returning the cached value without searching for, or
executing any script. For further details see |require()|.

For example, if 'runtimepath' is `foo,bar` and |package.cpath| was
`./?.so;./?.dll` at startup, `require('mod')` searches these paths in order
and loads the first module found ("first wins"): >
    foo/lua/mod.lua
    foo/lua/mod/init.lua
    bar/lua/mod.lua
    bar/lua/mod/init.lua
    foo/lua/mod.so
    foo/lua/mod.dll
    bar/lua/mod.so
    bar/lua/mod.dll
<
Note:

- Although 'runtimepath' is tracked, Nvim does not track current
  values of |package.path| or |package.cpath|. If you happen to delete some
  paths from there you can set 'runtimepath' to trigger an update: >vim
      let &runtimepath = &runtimepath

- Skipping paths from 'runtimepath' which contain semicolons applies both to
  |package.path| and |package.cpath|. Given that there are some badly written
  plugins using shell, which will not work with paths containing semicolons,
  it is better to not have them in 'runtimepath' at all.

                                                         *lua-script-location*
To get its own location, Lua scripts/modules can use |debug.getinfo()|: >
    debug.getinfo(1, 'S').source:gsub('^@', '')
<

==============================================================================
COMMANDS                                                        *lua-commands*

These commands execute a Lua chunk from either the command line (:lua, :luado)
or a file (:luafile) on the given line [range]. As always in Lua, each chunk
has its own scope (closure), so only global variables are shared between
command calls. The |lua-stdlib| modules, user modules, and anything else on
|package.path| are available.

The Lua print() function redirects its output to the Nvim message area, with
arguments separated by " " (space) instead of "\t" (tab).

                                                                  *:lua=* *:lua*
:lua {chunk}
    Executes Lua chunk {chunk}. If {chunk} starts with "=" the rest of the
    chunk is evaluated as an expression and printed. `:lua =expr` and `:=expr`
    are equivalent to `:lua print(vim.inspect(expr))`. |E5107| |E5108|

    Examples: >vim
        :lua vim.api.nvim_command('echo "Hello, Nvim!"')
<    To see the Lua version: >vim
        :lua print(_VERSION)
<    To see the LuaJIT version: >vim
        :lua =jit.version
<
:{range}lua
    Executes buffer lines in {range} as Lua code. Unlike |:source|, this
    always treats the lines as Lua code.

    Example: select the following code and type ":lua<Enter>" to execute it: >lua
        print(string.format(
            'unix time: %s', os.time()))
<
                                                                *:lua-heredoc*
:lua << [trim] [{endmarker}]
{script}
{endmarker}
    Executes Lua script {script} from within Vimscript. You can omit
    [endmarker] after the "<<" and use a dot "." after {script} (similar to
    |:append|, |:insert|). Refer to |:let-heredoc| for more information.

    Example: >vim
        function! CurrentLineInfo()
        lua << EOF
        local linenr = vim.api.nvim_win_get_cursor(0)[1]
        local curline = vim.api.nvim_buf_get_lines(0, linenr - 1, linenr, false)[1]
        print(string.format('Line [%d] has %d bytes', linenr, #curline))
        EOF
        endfunction
<
    Note that the `local` variables will disappear when the block finishes.
    But not globals.

                                                                      *:luado*
:[range]luado {body}
    Executes Lua chunk "function(line, linenr) {body} end" for each buffer
    line in [range], where `line` is the current line text (without <EOL>),
    and `linenr` is the current line number. If the function returns a string
    that becomes the text of the corresponding buffer line. Default [range] is
    the whole file: "1,$". |E5109| |E5110| |E5111|

    Examples: >vim
        :luado return string.format("%s\t%d", line:reverse(), #line)

        :lua require"lpeg"
        :lua -- balanced parenthesis grammar:
        :lua bp = lpeg.P{ "(" * ((1 - lpeg.S"()") + lpeg.V(1))^0 * ")" }
        :luado if bp:match(line) then return "=>\t" .. line end
<
                                                                    *:luafile*
:luafile {file}
    Execute Lua script in {file}.
    The whole argument is used as the filename (like |:edit|), spaces do not
    need to be escaped. Alternatively you can |:source| Lua files.
    |E5111| |E5112| |E5113|

    Examples: >vim
        :luafile script.lua
        :luafile %
<

==============================================================================
luaeval()                                                 *lua-eval*

The (dual) equivalent of "vim.eval" for passing Lua values to Nvim is
"luaeval". "luaeval" takes an expression string and an optional argument used
for _A inside expression and returns the result of the expression. It is
semantically equivalent in Lua to: >lua

    local chunkheader = "local _A = select(1, ...) return "
    function luaeval (expstr, arg)
        local chunk = assert(loadstring(chunkheader .. expstr, "luaeval"))
        return chunk(arg) -- return typval
    end
<
Lua nils, numbers, strings, tables and booleans are converted to their
respective Vimscript types. If a Lua string contains a NUL byte, it will be
converted to a |Blob|. Conversion of other Lua types is an error.

The magic global "_A" contains the second argument to luaeval().

Example: >vim
    :echo luaeval('_A[1] + _A[2]', [40, 2])
    " 42
    :echo luaeval('string.match(_A, "[a-z]+")', 'XYXfoo123')
    " foo
<
                                                         *lua-table-ambiguous*
Lua tables are used as both dictionaries and lists, so it is impossible to
decide whether empty table is a list or a dict. Also Lua does not have integer
numbers. To disambiguate these cases, we define:
                                                                    *lua-list*
0. Empty table is a list. Use |vim.empty_dict()| to represent empty dict.
1. Table with N consecutive (no `nil` values, aka "holes") integer keys 1…N is
   a list. See also |list-iterator|.
                                                                    *lua-dict*
2. Table with string keys, none of which contains NUL byte, is a dict.
3. Table with string keys, at least one of which contains NUL byte, is also
   considered to be a dictionary, but this time it is converted to
   a |msgpack-special-map|.
                                     *lua-special-tbl* *E5100* *E5101* *E5102*
4. Table with `vim.type_idx` key may be a dictionary, a list or floating-point
   value:
   - `{[vim.type_idx]=vim.types.float, [vim.val_idx]=1}` is converted to
     a floating-point 1.0. Note that by default integral Lua numbers are
     converted to |Number|s, non-integral are converted to |Float|s. This
     variant allows integral |Float|s.
   - `{[vim.type_idx]=vim.types.dictionary}` is converted to an empty
     dictionary, `{[vim.type_idx]=vim.types.dictionary, [42]=1, a=2}` is
     converted to a dictionary `{'a': 42}`: non-string keys are ignored.
     Without `vim.type_idx` key tables with keys not fitting in 1., 2. or 3.
     are errors.
   - `{[vim.type_idx]=vim.types.array}` is converted to an empty list. As well
     as `{[vim.type_idx]=vim.types.array, [42]=1}`: integral keys that do not
     form a 1-step sequence from 1 to N are ignored, as well as all
     non-integral keys.

Examples: >vim

    :echo luaeval('math.pi')
    :function Rand(x,y) " random uniform between x and y
    :  return luaeval('(_A.y-_A.x)*math.random()+_A.x', {'x':a:x,'y':a:y})
    :  endfunction
    :echo Rand(1,10)
<
Note: Second argument to `luaeval` is converted ("marshalled") from Vimscript
to Lua, so changes to Lua containers do not affect values in Vimscript. Return
value is also always converted. When converting, |msgpack-special-dict|s are
treated specially.

==============================================================================
Vimscript v:lua interface                                         *v:lua-call*

From Vimscript the special `v:lua` prefix can be used to call Lua functions
which are global or accessible from global tables. The expression >vim
    call v:lua.func(arg1, arg2)
is equivalent to the Lua chunk >lua
    return func(...)
where the args are converted to Lua values. The expression >vim
    call v:lua.somemod.func(args)
is equivalent to the Lua chunk >lua
    return somemod.func(...)

Lua module functions can be accessed like: >vim
    call v:lua.require'mypack'.func(arg1, arg2)
    call v:lua.require'mypack.submod'.func(arg1, arg2)
Note: Only single quote form without parens is allowed. Using
`require"mypack"` or `require('mypack')` as a prefix does NOT work.

You can use `v:lua` in "func" options like 'tagfunc', 'omnifunc', etc.
For example consider the following Lua omnifunc handler: >lua

    function mymod.omnifunc(findstart, base)
      if findstart == 1 then
        return 0
      else
        return {'stuff', 'steam', 'strange things'}
      end
    end
    -- Note: The module ("mymod") must be a Lua global, or use require() as
    -- shown above to access it from a package.
    vim.bo[buf].omnifunc = 'v:lua.mymod.omnifunc'

You can also use `v:lua` to call Lua functions as Vimscript |method|s: >vim
    :eval arg1->v:lua.somemod.func(arg2)
<
Note: `v:lua` without a call is not allowed in a Vimscript expression:
|Funcref|s cannot represent Lua functions. The following are errors: >vim

    let g:Myvar = v:lua.myfunc        " Error
    call SomeFunc(v:lua.mycallback)   " Error
    let g:foo = v:lua                 " Error
    let g:foo = v:['lua']             " Error
<
==============================================================================
Lua standard modules                                              *lua-stdlib*

The Nvim Lua "standard library" (stdlib) is the `vim` module, which exposes
various functions and sub-modules. It is always loaded, thus `require("vim")`
is unnecessary.

You can peek at the module properties: >vim

    :lua vim.print(vim)

Result is something like this: >

    {
      _os_proc_children = <function 1>,
      _os_proc_info = <function 2>,
      ...
      api = {
        nvim__id = <function 5>,
        nvim__id_array = <function 6>,
        ...
      },
      deepcopy = <function 106>,
      gsplit = <function 107>,
      ...
    }

To find documentation on e.g. the "deepcopy" function: >vim

    :help vim.deepcopy()

Note that underscore-prefixed functions (e.g. "_os_proc_children") are
internal/private and must not be used by plugins.

------------------------------------------------------------------------------
VIM.UV                                                   *lua-loop* *vim.uv*

`vim.uv` exposes the "luv" Lua bindings for the libUV library that Nvim uses
for networking, filesystem, and process management, see |luvref.txt|.
In particular, it allows interacting with the main Nvim |luv-event-loop|.

                                                    *E5560* *lua-loop-callbacks*
It is an error to directly invoke `vim.api` functions (except |api-fast|) in
`vim.uv` callbacks. For example, this is an error: >lua

    local timer = vim.uv.new_timer()
    timer:start(1000, 0, function()
      vim.api.nvim_command('echomsg "test"')
    end)
<
To avoid the error, |schedule| the callback: >lua

    local timer = vim.uv.new_timer()
    timer:start(1000, 0, vim.schedule_wrap(function()
      vim.api.nvim_command('echomsg "test"')
    end))
<
(For one-shot timers, see |vim.defer_fn()|, which automatically adds the
wrapping.)

Example: repeating timer
    1. Save this code to a file.
    2. Execute it with ":luafile %". >lua

    -- Create a timer handle (implementation detail: uv_timer_t).
    local timer = vim.uv.new_timer()
    local i = 0
    -- Waits 1000ms, then repeats every 750ms until timer:close().
    timer:start(1000, 750, function()
      print('timer invoked! i='..tostring(i))
      if i > 4 then
        timer:close()  -- Always close handles to avoid leaks.
      end
      i = i + 1
    end)
    print('sleeping');
<
Example: File-change detection                                    *watch-file*
    1. Save this code to a file.
    2. Execute it with ":luafile %".
    3. Use ":Watch %" to watch any file.
    4. Try editing the file from another text editor.
    5. Observe that the file reloads in Nvim (because on_change() calls
       |:checktime|). >lua

    local w = vim.uv.new_fs_event()
    local function on_change(err, fname, status)
      -- Do work...
      vim.api.nvim_command('checktime')
      -- Debounce: stop/start.
      w:stop()
      watch_file(fname)
    end
    function watch_file(fname)
      local fullpath = vim.api.nvim_call_function(
        'fnamemodify', {fname, ':p'})
      w:start(fullpath, {}, vim.schedule_wrap(function(...)
        on_change(...) end))
    end
    vim.api.nvim_command(
      "command! -nargs=1 Watch call luaeval('watch_file(_A)', expand('<args>'))")
<
                                                         *inotify-limitations*
When on Linux you may need to increase the maximum number of `inotify` watches
and queued events as the default limit can be too low. To increase the limit,
run: >bash
    sysctl fs.inotify.max_user_watches=494462
<
This will increase the limit to 494462 watches and queued events. These lines
can be added to `/etc/sysctl.conf` to make the changes persistent.

Note that each watch is a structure in the Kernel, thus available memory is
also a bottleneck for using inotify. In fact, a watch can take up to 1KB of
space. This means a million watches could result in 1GB of extra RAM usage.

Example: TCP echo-server                                          *tcp-server*
    1. Save this code to a file.
    2. Execute it with ":luafile %".
    3. Note the port number.
    4. Connect from any TCP client (e.g. "nc 0.0.0.0 36795"): >lua

    local function create_server(host, port, on_connect)
      local server = vim.uv.new_tcp()
      server:bind(host, port)
      server:listen(128, function(err)
        assert(not err, err)  -- Check for errors.
        local sock = vim.uv.new_tcp()
        server:accept(sock)  -- Accept client connection.
        on_connect(sock)  -- Start reading messages.
      end)
      return server
    end
    local server = create_server('0.0.0.0', 0, function(sock)
      sock:read_start(function(err, chunk)
        assert(not err, err)  -- Check for errors.
        if chunk then
          sock:write(chunk)  -- Echo received messages to the channel.
        else  -- EOF (stream closed).
          sock:close()  -- Always close handles to avoid leaks.
        end
      end)
    end)
    print('TCP echo-server listening on port: '..server:getsockname().port)
<
Multithreading                                            *lua-loop-threading*

Plugins can perform work in separate (os-level) threads using the threading
APIs in luv, for instance `vim.uv.new_thread`. Each thread has its own
separate Lua interpreter state, with no access to Lua globals on the main
thread. Neither can the editor state (buffers, windows, etc) be directly
accessed from threads.

A subset of the `vim.*` stdlib is available in threads, including:

- `vim.uv` with a separate event loop per thread.
- `vim.mpack` and `vim.json` (useful for serializing messages between threads)
- `require` in threads can use Lua packages from the global |package.path|
- `print()` and `vim.inspect`
- `vim.text.diff`
- Most utility functions in `vim.*` that work with pure Lua values, like
  `vim.split`, `vim.tbl_*`, `vim.list_*`, etc.
- `vim.is_thread()` returns true from a non-main thread.


==============================================================================
VIM                                                              *vim.builtin*


vim.api.{func}({...})                                                *vim.api*
    Invokes Nvim |API| function {func} with arguments {...}.
    Example: call the "nvim_get_current_line()" API function: >lua
        print(tostring(vim.api.nvim_get_current_line()))

vim.NIL                                                              *vim.NIL*
    Special value representing NIL in |RPC| and |v:null| in Vimscript
    conversion, and similar cases. Lua `nil` cannot be used as part of a Lua
    table representing a Dictionary or Array, because it is treated as
    missing: `{"foo", nil}` is the same as `{"foo"}`.

vim.type_idx                                                    *vim.type_idx*
    Type index for use in |lua-special-tbl|. Specifying one of the values from
    |vim.types| allows typing the empty table (it is unclear whether empty Lua
    table represents empty list or empty array) and forcing integral numbers
    to be |Float|. See |lua-special-tbl| for more details.

vim.val_idx                                                      *vim.val_idx*
    Value index for tables representing |Float|s. A table representing
    floating-point value 1.0 looks like this: >lua
        {
          [vim.type_idx] = vim.types.float,
          [vim.val_idx] = 1.0,
        }
<    See also |vim.type_idx| and |lua-special-tbl|.

vim.types                                                          *vim.types*
    Table with possible values for |vim.type_idx|. Contains two sets of
    key-value pairs: first maps possible values for |vim.type_idx| to
    human-readable strings, second maps human-readable type names to values
    for |vim.type_idx|. Currently contains pairs for `float`, `array` and
        `dictionary` types.

    Note: One must expect that values corresponding to `vim.types.float`,
    `vim.types.array` and `vim.types.dictionary` fall under only two following
    assumptions:
    1. Value may serve both as a key and as a value in a table. Given the
       properties of Lua tables this basically means “value is not `nil`”.
    2. For each value in `vim.types` table `vim.types[vim.types[value]]` is the
       same as `value`.
    No other restrictions are put on types, and it is not guaranteed that
    values corresponding to `vim.types.float`, `vim.types.array` and
    `vim.types.dictionary` will not change or that `vim.types` table will only
    contain values for these three types.

                                                   *log_levels* *vim.log.levels*
Log levels are one of the values defined in `vim.log.levels`:

    vim.log.levels.DEBUG
    vim.log.levels.ERROR
    vim.log.levels.INFO
    vim.log.levels.TRACE
    vim.log.levels.WARN
    vim.log.levels.OFF



vim.empty_dict()                                            *vim.empty_dict()*
    Creates a special empty table (marked with a metatable), which Nvim
    converts to an empty dictionary when translating Lua values to Vimscript
    or API types. Nvim by default converts an empty table `{}` without this
    metatable to an list/array.

    Note: If numeric keys are present in the table, Nvim ignores the metatable
    marker and converts the dict to a list/array anyway.

    Return: ~
        (`table`)

vim.iconv({str}, {from}, {to})                                   *vim.iconv()*
    The result is a String, which is the text {str} converted from encoding
    {from} to encoding {to}. When the conversion fails `nil` is returned. When
    some characters could not be converted they are replaced with "?". The
    encoding names are whatever the iconv() library function can accept, see
    ":Man 3 iconv".

    Parameters: ~
      • {str}   (`string`) Text to convert
      • {from}  (`string`) Encoding of {str}
      • {to}    (`string`) Target encoding

    Return: ~
        (`string?`) Converted string if conversion succeeds, `nil` otherwise.

vim.in_fast_event()                                      *vim.in_fast_event()*
    Returns true if the code is executing as part of a "fast" event handler,
    where most of the API is disabled. These are low-level events (e.g.
    |lua-loop-callbacks|) which can be invoked whenever Nvim polls for input.
    When this is `false` most API functions are callable (but may be subject
    to other restrictions such as |textlock|).

vim.rpcnotify({channel}, {method}, {...})                    *vim.rpcnotify()*
    Sends {event} to {channel} via |RPC| and returns immediately. If {channel}
    is 0, the event is broadcast to all channels.

    This function also works in a fast callback |lua-loop-callbacks|.

    Parameters: ~
      • {channel}  (`integer`)
      • {method}   (`string`)
      • {...}      (`any?`)

vim.rpcrequest({channel}, {method}, {...})                  *vim.rpcrequest()*
    Invokes |RPC| `method` on `channel` and blocks until a response is
    received.

    Note: Msgpack NIL values in the response are represented as |vim.NIL|.

    Example: see |nvim_exec_lua()|

    Parameters: ~
      • {channel}  (`integer`)
      • {method}   (`string`)
      • {...}      (`any?`)

vim.schedule({fn})                                            *vim.schedule()*
    Schedules {fn} to be invoked soon by the main event-loop. Useful to avoid
    |textlock| or other temporary restrictions.

    Parameters: ~
      • {fn}  (`fun()`)

    Return (multiple): ~
        (`nil`) result
        (`string?`) err Error message if scheduling failed, `nil` otherwise.

vim.str_utf_end({str}, {index})                            *vim.str_utf_end()*
    Gets the distance (in bytes) from the last byte of the codepoint
    (character) that {index} points to.

    Examples: >lua
        -- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)

        -- Returns 0 because the index is pointing at the last byte of a character
        vim.str_utf_end('æ', 2)

        -- Returns 1 because the index is pointing at the penultimate byte of a character
        vim.str_utf_end('æ', 1)
<

    Parameters: ~
      • {str}    (`string`)
      • {index}  (`integer`)

    Return: ~
        (`integer`)

vim.str_utf_pos({str})                                     *vim.str_utf_pos()*
    Gets a list of the starting byte positions of each UTF-8 codepoint in the
    given string.

    Embedded NUL bytes are treated as terminating the string.

    Parameters: ~
      • {str}  (`string`)

    Return: ~
        (`integer[]`)

vim.str_utf_start({str}, {index})                        *vim.str_utf_start()*
    Gets the distance (in bytes) from the starting byte of the codepoint
    (character) that {index} points to.

    The result can be added to {index} to get the starting byte of a
    character.

    Examples: >lua
        -- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)

        -- Returns 0 because the index is pointing at the first byte of a character
        vim.str_utf_start('æ', 1)

        -- Returns -1 because the index is pointing at the second byte of a character
        vim.str_utf_start('æ', 2)
<

    Parameters: ~
      • {str}    (`string`)
      • {index}  (`integer`)

    Return: ~
        (`integer`)

vim.stricmp({a}, {b})                                          *vim.stricmp()*
    Compares strings case-insensitively.

    Parameters: ~
      • {a}  (`string`)
      • {b}  (`string`)

    Return: ~
        (`0|1|-1`) if strings are equal, {a} is greater than {b} or {a} is
        lesser than {b}, respectively.

vim.ui_attach({ns}, {opts}, {callback})                      *vim.ui_attach()*
    WARNING: This feature is experimental/unstable.

    Subscribe to |ui-events|, similar to |nvim_ui_attach()| but receive events
    in a Lua callback. Used to implement screen elements like popupmenu or
    message handling in Lua.

    {callback} receives event name plus additional parameters. See
    |ui-popupmenu| and the sections below for event format for respective
    events.

    Callbacks for `msg_show` events originating from internal messages (as
    opposed to events from commands or API calls) are executed in |api-fast|
    context; showing the message needs to be scheduled.

    Excessive errors inside the callback will result in forced detachment.

    WARNING: This api is considered experimental. Usability will vary for
    different screen elements. In particular `ext_messages` behavior is
    subject to further changes and usability improvements. This is expected to
    be used to handle messages when setting 'cmdheight' to zero (which is
    likewise experimental).

    Example (stub for a |ui-popupmenu| implementation): >lua
        ns = vim.api.nvim_create_namespace('my_fancy_pum')

        vim.ui_attach(ns, {ext_popupmenu=true}, function(event, ...)
          if event == 'popupmenu_show' then
            local items, selected, row, col, grid = ...
            print('display pum ', #items)
          elseif event == 'popupmenu_select' then
            local selected = ...
            print('selected', selected)
          elseif event == 'popupmenu_hide' then
            print('FIN')
          end
        end)
<

    Parameters: ~
      • {ns}        (`integer`) Namespace ID
      • {opts}      (`table<string, any>`) Optional parameters.
                    • {ext_…}? (`boolean`) Any of |ui-ext-options|, if true
                      enable events for the respective UI element.
                    • {set_cmdheight}? (`boolean`) If false, avoid setting
                      'cmdheight' to 0 when `ext_messages` is enabled.
      • {callback}  (`fun(event: string, ...): any`) Function called for each
                    UI event. A truthy return value signals to Nvim that the
                    event is handled, in which case it is not propagated to
                    remote UIs.

vim.ui_detach({ns})                                          *vim.ui_detach()*
    Detach a callback previously attached with |vim.ui_attach()| for the given
    namespace {ns}.

    Parameters: ~
      • {ns}  (`integer`) Namespace ID

vim.wait({time}, {callback}, {interval}, {fast_only})             *vim.wait()*
    Waits up to `time` milliseconds, until `callback` returns `true`
    (success). Executes `callback` immediately, then on user events, internal
    events, and approximately every `interval` milliseconds (default 200).
    Returns all `callback` results on success.

    Nvim processes other events while waiting. Cannot be called during an
    |api-fast| event.

    Examples: >lua
        -- Wait for 100 ms, allowing other events to process.
        vim.wait(100)

        -- Wait up to 1000 ms or until `vim.g.foo` is true, at intervals of ~500 ms.
        vim.wait(1000, function() return vim.g.foo end, 500)

        -- Wait indefinitely until `vim.g.foo` is true, and get the callback results.
        local ok, rv1, rv2, rv3 = vim.wait(math.huge, function()
          return vim.g.foo, 'a', 42, { ok = { 'yes' } }
        end)

        -- Schedule a function to set a value in 100ms. This would wait 10s if blocked, but actually
        -- only waits 100ms because `vim.wait` processes other events while waiting.
        vim.defer_fn(function() vim.g.timer_result = true end, 100)
        if vim.wait(10000, function() return vim.g.timer_result end) then
          print('Only waiting a little bit of time!')
        end
<

    Parameters: ~
      • {time}       (`number`) Number of milliseconds to wait. Must be
                     non-negative number, any fractional part is truncated.
      • {callback}   (`fun(): boolean, ...?`) Optional callback. Waits until
                     {callback} returns true
      • {interval}   (`integer?`) (Approximate) number of milliseconds to wait
                     between polls
      • {fast_only}  (`boolean?`) If true, only |api-fast| events will be
                     processed.

    Return (multiple): ~
        (`boolean`)
        (`-1|-2?`)
        • If callback returns `true` before timeout: `true, nil, ...`
        • On timeout: `false, -1`
        • On interrupt: `false, -2`
        • On error: the error is raised.


==============================================================================
LUA-VIMSCRIPT BRIDGE                                           *lua-vimscript*

Nvim Lua provides an interface or "bridge" to Vimscript variables and
functions, and editor commands and options.

Objects passed over this bridge are COPIED (marshalled): there are no
"references". |lua-guide-variables| For example, using `vim.fn.remove()` on a
Lua list copies the list object to Vimscript and does NOT modify the Lua list: >lua
    local list = { 1, 2, 3 }
    vim.fn.remove(list, 0)
    vim.print(list)  --> "{ 1, 2, 3 }"
<


vim.call({func}, {...})                                           *vim.call()*
    Invokes |vim-function| or |user-function| {func} with arguments {...}.
    See also |vim.fn|.
    Equivalent to: >lua
        vim.fn[func]({...})
<
vim.cmd({command})
    See |vim.cmd()|.

vim.fn.{func}({...})                                                  *vim.fn*
    Invokes |vim-function| or |user-function| {func} with arguments {...}.
    To call autoload functions, use the syntax: >lua
        vim.fn['some#function']({...})
<
    Unlike vim.api.|nvim_call_function()| this converts directly between Vim
    objects and Lua objects. If the Vim function returns a float, it will be
    represented directly as a Lua number. Empty lists and dictionaries both
    are represented by an empty table.

    Note: |v:null| values as part of the return value is represented as
    |vim.NIL| special value

    Note: vim.fn keys are generated lazily, thus `pairs(vim.fn)` only
    enumerates functions that were called at least once.

    Note: The majority of functions cannot run in |api-fast| callbacks with some
    undocumented exceptions which are allowed.

                                                           *lua-vim-variables*
The Vim editor global dictionaries |g:| |w:| |b:| |t:| |v:| can be accessed
from Lua conveniently and idiomatically by referencing the `vim.*` Lua tables
described below. In this way you can easily read and modify global Vimscript
variables from Lua.

Example: >lua

    vim.g.foo = 5     -- Set the g:foo Vimscript variable.
    print(vim.g.foo)  -- Get and print the g:foo Vimscript variable.
    vim.g.foo = nil   -- Delete (:unlet) the Vimscript variable.
    vim.b[2].foo = 6  -- Set b:foo for buffer 2
<

Note that setting dictionary fields directly will not write them back into
Nvim. This is because the index into the namespace simply returns a copy.
Instead the whole dictionary must be written as one. This can be achieved by
creating a short-lived temporary.

Example: >lua

    vim.g.my_dict.field1 = 'value'  -- Does not work

    local my_dict = vim.g.my_dict   --
    my_dict.field1 = 'value'        -- Instead do
    vim.g.my_dict = my_dict         --

vim.g                                                                  *vim.g*
    Global (|g:|) editor variables.
    Key with no value returns `nil`.

vim.b                                                                  *vim.b*
    Buffer-scoped (|b:|) variables for the current buffer.
    Invalid or unset key returns `nil`. Can be indexed with
    an integer to access variables for a specific buffer.

vim.w                                                                  *vim.w*
    Window-scoped (|w:|) variables for the current window.
    Invalid or unset key returns `nil`. Can be indexed with
    an integer to access variables for a specific window.

vim.t                                                                  *vim.t*
    Tabpage-scoped (|t:|) variables for the current tabpage.
    Invalid or unset key returns `nil`. Can be indexed with
    an integer to access variables for a specific tabpage.

vim.v                                                                  *vim.v*
    |v:| variables.
    Invalid or unset key returns `nil`.


                                                                 *lua-options*
                                                             *lua-vim-options*
                                                                 *lua-vim-set*
                                                            *lua-vim-setlocal*

Vim options can be accessed through |vim.o|, which behaves like Vimscript
|:set|.

    Examples: ~

    To set a boolean toggle:
        Vimscript: `set number`
        Lua:       `vim.o.number = true`

    To set a string value:
        Vimscript: `set wildignore=*.o,*.a,__pycache__`
        Lua:       `vim.o.wildignore = '*.o,*.a,__pycache__'`

Similarly, there is |vim.bo| and |vim.wo| for setting buffer-scoped and
window-scoped options. Note that this must NOT be confused with
|local-options| and |:setlocal|. There is also |vim.go| that only accesses the
global value of a |global-local| option, see |:setglobal|.


                                                               *vim.opt_local*
                                                              *vim.opt_global*
                                                                     *vim.opt*


A special interface |vim.opt| exists for conveniently interacting with list-
and map-style options from Lua: It allows accessing them as Lua tables and
offers object-oriented method for adding and removing entries.

    Examples: ~

    The following methods of setting a list-style option are equivalent:
        In Vimscript: >vim
            set wildignore=*.o,*.a,__pycache__
<
        In Lua using `vim.o`: >lua
            vim.o.wildignore = '*.o,*.a,__pycache__'
<
        In Lua using `vim.opt`: >lua
            vim.opt.wildignore = { '*.o', '*.a', '__pycache__' }
<
    To replicate the behavior of |:set+=|, use: >lua

        vim.opt.wildignore:append { "*.pyc", "node_modules" }
<
    To replicate the behavior of |:set^=|, use: >lua

        vim.opt.wildignore:prepend { "new_first_value" }
<
    To replicate the behavior of |:set-=|, use: >lua

        vim.opt.wildignore:remove { "node_modules" }
<
    The following methods of setting a map-style option are equivalent:
        In Vimscript: >vim
            set listchars=space:_,tab:>~
<
        In Lua using `vim.o`: >lua
            vim.o.listchars = 'space:_,tab:>~'
<
        In Lua using `vim.opt`: >lua
            vim.opt.listchars = { space = '_', tab = '>~' }
<

Note that |vim.opt| returns an `Option` object, not the value of the option,
which is accessed through |vim.opt:get()|:

    Examples: ~

    The following methods of getting a list-style option are equivalent:
        In Vimscript: >vim
            echo wildignore
<
        In Lua using `vim.o`: >lua
            print(vim.o.wildignore)
<
        In Lua using `vim.opt`: >lua
            vim.print(vim.opt.wildignore:get())
<

In any of the above examples, to replicate the behavior |:setlocal|, use
`vim.opt_local`. Additionally, to replicate the behavior of |:setglobal|, use
`vim.opt_global`.


Option:append({value})                                      *vim.opt:append()*
    Append a value to string-style options. See |:set+=|

    These are equivalent: >lua
        vim.opt.formatoptions:append('j')
        vim.opt.formatoptions = vim.opt.formatoptions + 'j'
<

    Parameters: ~
      • {value}  (`string`) Value to append

Option:get()                                                   *vim.opt:get()*
    Returns a Lua-representation of the option. Boolean, number and string
    values will be returned in exactly the same fashion.

    For values that are comma-separated lists, an array will be returned with
    the values as entries in the array: >lua
        vim.cmd [[set wildignore=*.pyc,*.o]]

        vim.print(vim.opt.wildignore:get())
        -- { "*.pyc", "*.o", }

        for _, ignore_pattern in ipairs(vim.opt.wildignore:get()) do
            print("Will ignore:", ignore_pattern)
        end
        -- Will ignore: *.pyc
        -- Will ignore: *.o
<

    For values that are comma-separated maps, a table will be returned with
    the names as keys and the values as entries: >lua
        vim.cmd [[set listchars=space:_,tab:>~]]

        vim.print(vim.opt.listchars:get())
        --  { space = "_", tab = ">~", }

        for char, representation in pairs(vim.opt.listchars:get()) do
            print(char, "=>", representation)
        end
<

    For values that are lists of flags, a set will be returned with the flags
    as keys and `true` as entries. >lua
        vim.cmd [[set formatoptions=njtcroql]]

        vim.print(vim.opt.formatoptions:get())
        -- { n = true, j = true, c = true, ... }

        local format_opts = vim.opt.formatoptions:get()
        if format_opts.j then
            print("J is enabled!")
        end
<

    Return: ~
        (`string|integer|boolean?`) value of option

Option:prepend({value})                                    *vim.opt:prepend()*
    Prepend a value to string-style options. See |:set^=|

    These are equivalent: >lua
        vim.opt.wildignore:prepend('*.o')
        vim.opt.wildignore = vim.opt.wildignore ^ '*.o'
<

    Parameters: ~
      • {value}  (`string`) Value to prepend

Option:remove({value})                                      *vim.opt:remove()*
    Remove a value from string-style options. See |:set-=|

    These are equivalent: >lua
        vim.opt.wildignore:remove('*.pyc')
        vim.opt.wildignore = vim.opt.wildignore - '*.pyc'
<

    Parameters: ~
      • {value}  (`string`) Value to remove

vim.bo[{bufnr}]                                                       *vim.bo*
    Gets or sets buffer-scoped |options| on buffer {bufnr} (or "current
    buffer" if 0 or omitted). Like `:setlocal`. Invalid {bufnr} or key is an
    error.

    Example: >lua
        local bufnr = vim.api.nvim_get_current_buf()
        vim.bo[bufnr].buflisted = true    -- same as vim.bo.buflisted = true
        print(vim.bo.comments)
        print(vim.bo.baz)                 -- error: invalid key
<

vim.env                                                              *vim.env*
    Gets or sets environment variables in the current editor process. See
    |expand-env| and |:let-environment| for the Vimscript behavior. Invalid or
    unset key returns `nil`.

    Example: >lua
        vim.env.FOO = 'bar'
        print(vim.env.TERM)
<

vim.go                                                                *vim.go*
    Gets or sets global |options|. Like `:setglobal`. Invalid key is an error.

    Note: unlike |vim.o|, this accesses the global option value and thus is
    mostly useful with |global-local| options.

    Example: >lua
        vim.go.cmdheight = 4
        print(vim.go.columns)
        print(vim.go.bar)     -- error: invalid key
<

vim.o                                                                  *vim.o*
    Gets or sets |options|. Works like `:set`, so buffer/window-scoped options
    target the current buffer/window. Invalid key is an error.

    Example: >lua
        vim.o.cmdheight = 4
        print(vim.o.columns)
        print(vim.o.foo)     -- error: invalid key
<

vim.wo[{winid}][{bufnr}]                                              *vim.wo*
    Gets or sets window-scoped |options| on window {winid} (or "current
    window" if 0 or omitted) and buffer {bufnr} (0 for current buffer). Like
    `:setlocal` if setting a |global-local| option or if {bufnr} is specified,
    like `:set` otherwise. Invalid {winid}, {bufnr}, or key is an error.

    Note: only bufnr=0 (current window-buffer) is supported, currently.

    Example: >lua
        local winid = vim.api.nvim_get_current_win()
        vim.wo[winid].number = true    -- same as vim.wo.number = true
        print(vim.wo.foldmarker)
        print(vim.wo.quux)             -- error: invalid key
        vim.wo[winid][0].spell = false -- like ':setlocal nospell'
<


==============================================================================
Lua module: vim                                                      *lua-vim*

vim.cmd({cmd})                                                     *vim.cmd()*
    Executes Vimscript (|Ex-command|s).

    Can be indexed with a command name to get a function, thus you can write
    `vim.cmd.echo(…)` instead of `vim.cmd{cmd='echo',…}`.

    Examples: >lua
        -- Single command:
        vim.cmd('echo 42')
        -- Multiline script:
        vim.cmd([[
          augroup my.group
            autocmd!
            autocmd FileType c setlocal cindent
          augroup END
        ]])

        -- Ex command :echo "foo". Note: string literals must be double-quoted.
        vim.cmd('echo "foo"')
        vim.cmd { cmd = 'echo', args = { '"foo"' } }
        vim.cmd.echo({ args = { '"foo"' } })
        vim.cmd.echo('"foo"')

        -- Ex command :write! myfile.txt
        vim.cmd('write! myfile.txt')
        vim.cmd { cmd = 'write', args = { 'myfile.txt' }, bang = true }
        vim.cmd.write { args = { 'myfile.txt' }, bang = true }
        vim.cmd.write { 'myfile.txt', bang = true }

        -- Ex command :vertical resize +2
        vim.cmd.resize({ '+2', mods = { vertical = true } })

        -- Pass arg literally, without needing to escape special chars:
        vim.cmd.edit({ '%foo"|bar#baz"', magic = { file = false, bar = false } })
<

    Parameters: ~
      • {cmd}  (`string|table`) Command(s) to execute.
               • The string form supports multiline Vimscript (alias to
                 |nvim_exec2()|, behaves like |:source|).
               • The table form executes a single command (alias to
                 |nvim_cmd()|).

    See also: ~
      • |ex-cmd-index|

vim.defer_fn({fn}, {timeout})                                 *vim.defer_fn()*
    Defers calling {fn} until {timeout} ms passes.

    Use to do a one-shot timer that calls {fn}. Note: The {fn} is |schedule|d
    automatically, so API functions are safe to call.

    Parameters: ~
      • {fn}       (`function`) Callback to call once `timeout` expires
      • {timeout}  (`integer`) Number of milliseconds to wait before calling
                   `fn`

    Return: ~
        (`uv.uv_timer_t`) timer luv timer object

                                                             *vim.deprecate()*
vim.deprecate({name}, {alternative}, {version}, {plugin}, {backtrace})
    Shows a deprecation message to the user.

    Parameters: ~
      • {name}         (`string`) Deprecated feature (function, API, etc.).
      • {alternative}  (`string?`) Suggested alternative feature.
      • {version}      (`string`) Version when the deprecated function will be
                       removed.
      • {plugin}       (`string?`) Name of the plugin that owns the deprecated
                       feature. Defaults to "Nvim".
      • {backtrace}    (`boolean?`) Prints backtrace. Defaults to true.

    Return: ~
        (`string?`) Deprecation message, or nil if no message was shown.

vim.inspect()                                                  *vim.inspect()*
    Gets a human-readable representation of the given object.

    Overloads: ~
      • `fun(x: any, opts?: vim.inspect.Opts): string`

    Return: ~
        (`string`)

    See also: ~
      • |vim.print()|
      • https://github.com/kikito/inspect.lua
      • https://github.com/mpeterv/vinspect

vim.keycode({str})                                             *vim.keycode()*
    Translates keycodes.

    Example: >lua
        local k = vim.keycode
        vim.g.mapleader = k'<bs>'
<

    Parameters: ~
      • {str}  (`string`) String to be converted.

    Return: ~
        (`string`)

    See also: ~
      • |nvim_replace_termcodes()|

vim.lua_omnifunc({find_start})                            *vim.lua_omnifunc()*
    Omnifunc for completing Lua values from the runtime Lua interpreter,
    similar to the builtin completion for the `:lua` command.

    Activate using `set omnifunc=v:lua.vim.lua_omnifunc` in a Lua buffer.

    Parameters: ~
      • {find_start}  (`1|0`)

vim.notify({msg}, {level}, {opts})                              *vim.notify()*
    Displays a notification to the user.

    This function can be overridden by plugins to display notifications using
    a custom provider (such as the system notification provider). By default,
    writes to |:messages|.

    Parameters: ~
      • {msg}    (`string`) Content of the notification to show to the user.
      • {level}  (`integer?`) One of the values from |vim.log.levels|.
      • {opts}   (`table?`) Optional parameters. Unused by default.

vim.notify_once({msg}, {level}, {opts})                    *vim.notify_once()*
    Displays a notification only one time.

    Like |vim.notify()|, but subsequent calls with the same message will not
    display a notification.

    Parameters: ~
      • {msg}    (`string`) Content of the notification to show to the user.
      • {level}  (`integer?`) One of the values from |vim.log.levels|.
      • {opts}   (`table?`) Optional parameters. Unused by default.

    Return: ~
        (`boolean`) true if message was displayed, else false

vim.on_key({fn}, {ns_id}, {opts})                               *vim.on_key()*
    Adds Lua function {fn} with namespace id {ns_id} as a listener to every,
    yes every, input key.

    The Nvim command-line option |-w| is related but does not support
    callbacks and cannot be toggled dynamically.

    Note: ~
      • {fn} will be removed on error.
      • {fn} won't be invoked recursively, i.e. if {fn} itself consumes input,
        it won't be invoked for those keys.
      • {fn} will not be cleared by |nvim_buf_clear_namespace()|

    Parameters: ~
      • {fn}     (`fun(key: string, typed: string): string??`) Function
                 invoked for every input key, after mappings have been applied
                 but before further processing. Arguments {key} and {typed}
                 are raw keycodes, where {key} is the key after mappings are
                 applied, and {typed} is the key(s) before mappings are
                 applied. {typed} may be empty if {key} is produced by
                 non-typed key(s) or by the same typed key(s) that produced a
                 previous {key}. If {fn} returns an empty string, {key} is
                 discarded/ignored, and if {key} is <Cmd> then the
                 "<Cmd>…<CR>" sequence is discarded as a whole. When {fn} is
                 `nil`, the callback associated with namespace {ns_id} is
                 removed.
      • {ns_id}  (`integer?`) Namespace ID. If nil or 0, generates and returns
                 a new |nvim_create_namespace()| id.
      • {opts}   (`table?`) Optional parameters

    Return: ~
        (`integer`) Namespace id associated with {fn}. Or count of all
        callbacks if on_key() is called without arguments.

    See also: ~
      • |keytrans()|

vim.paste({lines}, {phase})                                      *vim.paste()*
    Paste handler, invoked by |nvim_paste()|.

    Note: This is provided only as a "hook", don't call it directly; call
    |nvim_paste()| instead, which arranges redo (dot-repeat) and invokes
    `vim.paste`.

    Example: To remove ANSI color codes when pasting: >lua
        vim.paste = (function(overridden)
          return function(lines, phase)
            for i,line in ipairs(lines) do
              -- Scrub ANSI color codes from paste input.
              lines[i] = line:gsub('\27%[[0-9;mK]+', '')
            end
            return overridden(lines, phase)
          end
        end)(vim.paste)
<

    Parameters: ~
      • {lines}  (`string[]`) |readfile()|-style list of lines to paste.
                 |channel-lines|
      • {phase}  (`-1|1|2|3`) -1: "non-streaming" paste: the call contains all
                 lines. If paste is "streamed", `phase` indicates the stream
                 state:
                 • 1: starts the paste (exactly once)
                 • 2: continues the paste (zero or more times)
                 • 3: ends the paste (exactly once)

    Return: ~
        (`boolean`) result false if client should cancel the paste.

    See also: ~
      • |paste|

vim.print({...})                                                 *vim.print()*
    "Pretty prints" the given arguments and returns them unmodified.

    Example: >lua
        local hl_normal = vim.print(vim.api.nvim_get_hl(0, { name = 'Normal' }))
<

    Parameters: ~
      • {...}  (`any`)

    Return: ~
        (`any`) given arguments.

    See also: ~
      • |vim.inspect()|
      • |:=|

vim.schedule_wrap({fn})                                  *vim.schedule_wrap()*
    Returns a function which calls {fn} via |vim.schedule()|.

    The returned function passes all arguments to {fn}.

    Example: >lua
        function notify_readable(_err, readable)
          vim.notify("readable? " .. tostring(readable))
        end
        vim.uv.fs_access(vim.fn.stdpath("config"), "R", vim.schedule_wrap(notify_readable))
<

    Parameters: ~
      • {fn}  (`function`)

    Return: ~
        (`function`)

    See also: ~
      • |lua-loop-callbacks|
      • |vim.schedule()|
      • |vim.in_fast_event()|

                                                         *vim.str_byteindex()*
vim.str_byteindex({s}, {encoding}, {index}, {strict_indexing})
    Convert UTF-32, UTF-16 or UTF-8 {index} to byte index. If
    {strict_indexing} is false then an out of range index will return byte
    length instead of throwing an error.

    Invalid UTF-8 and NUL is treated like in |vim.str_utfindex()|. An {index}
    in the middle of a UTF-16 sequence is rounded upwards to the end of that
    sequence.

    Parameters: ~
      • {s}                (`string`)
      • {encoding}         (`"utf-8"|"utf-16"|"utf-32"`)
      • {index}            (`integer`)
      • {strict_indexing}  (`boolean?`) default: true

    Return: ~
        (`integer`)

                                                          *vim.str_utfindex()*
vim.str_utfindex({s}, {encoding}, {index}, {strict_indexing})
    Convert byte index to UTF-32, UTF-16 or UTF-8 indices. If {index} is not
    supplied, the length of the string is used. All indices are zero-based.

    If {strict_indexing} is false then an out of range index will return
    string length instead of throwing an error. Invalid UTF-8 bytes, and
    embedded surrogates are counted as one code point each. An {index} in the
    middle of a UTF-8 sequence is rounded upwards to the end of that sequence.

    Parameters: ~
      • {s}                (`string`)
      • {encoding}         (`"utf-8"|"utf-16"|"utf-32"`)
      • {index}            (`integer?`)
      • {strict_indexing}  (`boolean?`) default: true

    Return: ~
        (`integer`)


==============================================================================
Lua module: vim.inspector                                      *vim.inspector*

vim.inspect_pos({buf}, {row}, {col}, {filter})             *vim.inspect_pos()*
    Get all the items at a given buffer position.

    Can also be pretty-printed with `:Inspect!`.                   *:Inspect!*

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {buf}     (`integer?`) defaults to the current buffer
      • {row}     (`integer?`) row to inspect, 0-based. Defaults to the row of
                  the current cursor
      • {col}     (`integer?`) col to inspect, 0-based. Defaults to the col of
                  the current cursor
      • {filter}  (`table?`) Table with key-value pairs to filter the items
                  • {extmarks} (`boolean|"all"`, default: true) Include
                    extmarks. When `all`, then extmarks without a `hl_group`
                    will also be included.
                  • {semantic_tokens} (`boolean`, default: true) Include
                    semantic token highlights.
                  • {syntax} (`boolean`, default: `true`) Include syntax based
                    highlight groups.
                  • {treesitter} (`boolean`, default: `true`) Include
                    treesitter based highlight groups.

    Return: ~
        (`table`) a table with the following key-value pairs. Items are in
        "traversal order":
        • treesitter: a list of treesitter captures
        • syntax: a list of syntax groups
        • semantic_tokens: a list of semantic tokens
        • extmarks: a list of extmarks
        • buffer: the buffer used to get the items
        • row: the row used to get the items
        • col: the col used to get the items

vim.show_pos({buf}, {row}, {col}, {filter})                   *vim.show_pos()*
    Show all the items at a given buffer position.

    Can also be shown with `:Inspect`.                              *:Inspect*

    Example: To bind this function to the vim-scriptease inspired `zS` in
    Normal mode: >lua
        vim.keymap.set('n', 'zS', vim.show_pos)
<

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {buf}     (`integer?`) defaults to the current buffer
      • {row}     (`integer?`) row to inspect, 0-based. Defaults to the row of
                  the current cursor
      • {col}     (`integer?`) col to inspect, 0-based. Defaults to the col of
                  the current cursor
      • {filter}  (`table?`) A table with the following fields:
                  • {extmarks} (`boolean|"all"`, default: true) Include
                    extmarks. When `all`, then extmarks without a `hl_group`
                    will also be included.
                  • {semantic_tokens} (`boolean`, default: true) Include
                    semantic token highlights.
                  • {syntax} (`boolean`, default: `true`) Include syntax based
                    highlight groups.
                  • {treesitter} (`boolean`, default: `true`) Include
                    treesitter based highlight groups.




*vim.Ringbuf*

    Fields: ~
      • {clear}  (`fun()`) See |Ringbuf:clear()|.
      • {peek}   (`fun(): T?`) See |Ringbuf:peek()|.
      • {pop}    (`fun(): T?`) See |Ringbuf:pop()|.
      • {push}   (`fun(item: T)`) See |Ringbuf:push()|.


Ringbuf:clear()                                              *Ringbuf:clear()*
    Clear all items

Ringbuf:peek()                                                *Ringbuf:peek()*
    Returns the first unread item without removing it

    Return: ~
        (`any?`)

Ringbuf:pop()                                                  *Ringbuf:pop()*
    Removes and returns the first unread item

    Return: ~
        (`any?`)

Ringbuf:push({item})                                          *Ringbuf:push()*
    Adds an item, overriding the oldest item if the buffer is full.

    Parameters: ~
      • {item}  (`any`)

vim.deep_equal({a}, {b})                                    *vim.deep_equal()*
    Deep compare values for equality

    Tables are compared recursively unless they both provide the `eq`
    metamethod. All other types are compared using the equality `==` operator.
    Cyclic tables are supported.

    Parameters: ~
      • {a}  (`any`) First value
      • {b}  (`any`) Second value

    Return: ~
        (`boolean`) `true` if values are equals, else `false`

vim.deepcopy({orig}, {noref})                                 *vim.deepcopy()*
    Returns a deep copy of the given object. Non-table objects are copied as
    in a typical Lua assignment, whereas table objects are copied recursively.
    Functions are naively copied, so functions in the copied table point to
    the same functions as those in the input table. Userdata and threads are
    not copied and will throw an error.

    Note: `noref=true` is much more performant on tables with unique table
    fields, while `noref=false` is more performant on tables that reuse table
    fields.

    Parameters: ~
      • {orig}   (`table`) Table to copy
      • {noref}  (`boolean?`) When `false` (default) a contained table is only
                 copied once and all references point to this single copy.
                 When `true` every occurrence of a table results in a new
                 copy. This also means that a cyclic reference can cause
                 `deepcopy()` to fail.

    Return: ~
        (`table`) Table of copied keys and (nested) values.

vim.defaulttable({createfn})                              *vim.defaulttable()*
    Creates a table whose missing keys are provided by {createfn} (like
    Python's "defaultdict").

    If {createfn} is `nil` it defaults to defaulttable() itself, so accessing
    nested keys creates nested tables: >lua
        local a = vim.defaulttable()
        a.b.c = 1
<

    Parameters: ~
      • {createfn}  (`fun(key:any):any?`) Provides the value for a missing
                    `key`.

    Return: ~
        (`table`) Empty table with `__index` metamethod.

vim.endswith({s}, {suffix})                                   *vim.endswith()*
    Tests if `s` ends with `suffix`.

    Parameters: ~
      • {s}       (`string`) String
      • {suffix}  (`string`) Suffix to match

    Return: ~
        (`boolean`) `true` if `suffix` is a suffix of `s`

vim.gsplit({s}, {sep}, {opts})                                  *vim.gsplit()*
    Gets an |iterator| that splits a string at each instance of a separator,
    in "lazy" fashion (as opposed to |vim.split()| which is "eager").

    Example: >lua
        for s in vim.gsplit(':aa::b:', ':', {plain=true}) do
          print(s)
        end
<

    If you want to also inspect the separator itself (instead of discarding
    it), use |string.gmatch()|. Example: >lua
        for word, num in ('foo111bar222'):gmatch('([^0-9]*)(%d*)') do
          print(('word: %s num: %s'):format(word, num))
        end
<

    Parameters: ~
      • {s}     (`string`) String to split
      • {sep}   (`string`) Separator or pattern
      • {opts}  (`table?`) Keyword arguments |kwargs|:
                • {plain}? (`boolean`) Use `sep` literally (as in
                  string.find).
                • {trimempty}? (`boolean`) Discard empty segments at start and
                  end of the sequence.

    Return: ~
        (`fun():string?`) Iterator over the split components

    See also: ~
      • |string.gmatch()|
      • |vim.split()|
      • |lua-pattern|s
      • https://www.lua.org/pil/20.2.html
      • http://lua-users.org/wiki/StringLibraryTutorial

vim.is_callable({f})                                       *vim.is_callable()*
    Returns true if object `f` can be called as a function.

    Parameters: ~
      • {f}  (`any?`) Any object

    Return: ~
        (`boolean`) `true` if `f` is callable, else `false`

vim.isarray({t})                                               *vim.isarray()*
    Tests if `t` is an "array": a table indexed only by integers (potentially
    non-contiguous).

    If the indexes start from 1 and are contiguous then the array is also a
    list. |vim.islist()|

    Empty table `{}` is an array, unless it was created by |vim.empty_dict()|
    or returned as a dict-like |API| or Vimscript result, for example from
    |rpcrequest()| or |vim.fn|.

    Parameters: ~
      • {t}  (`any?`)

    Return: ~
        (`boolean`) `true` if array-like table, else `false`.

    See also: ~
      • https://github.com/openresty/luajit2#tableisarray

vim.islist({t})                                                 *vim.islist()*
    Tests if `t` is a "list": a table indexed only by contiguous integers
    starting from 1 (what |lua-length| calls a "regular array").

    Empty table `{}` is a list, unless it was created by |vim.empty_dict()| or
    returned as a dict-like |API| or Vimscript result, for example from
    |rpcrequest()| or |vim.fn|.

    Parameters: ~
      • {t}  (`any?`)

    Return: ~
        (`boolean`) `true` if list-like table, else `false`.

    See also: ~
      • |vim.isarray()|

vim.list.bisect({t}, {val}, {opts})                        *vim.list.bisect()*
    Search for a position in a sorted |lua-list| {t} where {val} can be
    inserted while keeping the list sorted.

    Use {bound} to determine whether to return the first or the last position,
    defaults to "lower", i.e., the first position.

    NOTE: Behavior is undefined on unsorted lists!

    Example: >lua

        local t = { 1, 2, 2, 3, 3, 3 }
        local first = vim.list.bisect(t, 3)
        -- `first` is `val`'s first index if found,
        -- useful for existence checks.
        print(t[first]) -- 3

        local last = vim.list.bisect(t, 3, { bound = 'upper' })
        -- Note that `last` is 7, not 6,
        -- this is suitable for insertion.

        table.insert(t, last, 4)
        -- t is now { 1, 2, 2, 3, 3, 3, 4 }

        -- You can use lower bound and upper bound together
        -- to obtain the range of occurrences of `val`.

        -- 3 is in [first, last)
        for i = first, last - 1 do
          print(t[i]) -- { 3, 3, 3 }
        end
<

    Attributes: ~
        Since: 0.12.0

    Parameters: ~
      • {t}     (`any[]`) A comparable list.
      • {val}   (`any`) The value to search.
      • {opts}  (`table?`) A table with the following fields:
                • {bound}? (`'lower'|'upper'`, default: `'lower'`) Specifies
                  the search variant.
                  • "lower": returns the first position where inserting {val}
                    keeps the list sorted.
                  • "upper": returns the last position where inserting {val}
                    keeps the list sorted..
                • {hi}? (`integer`, default: `#t + 1`) End index of the list,
                  exclusive.
                • {key}? (`fun(val: any): any`) Optional, compare the return
                  value instead of the {val} itself if provided.
                • {lo}? (`integer`, default: `1`) Start index of the list.

    Return: ~
        (`integer`) index serves as either the lower bound or the upper bound
        position.

vim.list.unique({t}, {key})                                *vim.list.unique()*
    Removes duplicate values from a |lua-list| in-place.

    Only the first occurrence of each value is kept. The operation is
    performed in-place and the input table is modified.

    Accepts an optional `key` argument, which if provided is called for each
    value in the list to compute a hash key for uniqueness comparison. This is
    useful for deduplicating table values or complex objects. If `key` returns
    `nil` for a value, that value will be considered unique, even if multiple
    values return `nil`.

    Example: >lua

        local t = {1, 2, 2, 3, 1}
        vim.list.unique(t)
        -- t is now {1, 2, 3}

        local t = { {id=1}, {id=2}, {id=1} }
        vim.list.unique(t, function(x) return x.id end)
        -- t is now { {id=1}, {id=2} }
<

    Attributes: ~
        Since: 0.12.0

    Parameters: ~
      • {t}    (`any[]`)
      • {key}  (`fun(x: T): any?`) Optional hash function to determine
               uniqueness of values

    Return: ~
        (`any[]`) The deduplicated list

    See also: ~
      • |Iter:unique()|

vim.list_contains({t}, {value})                          *vim.list_contains()*
    Checks if a list-like table (integer keys without gaps) contains `value`.

    Parameters: ~
      • {t}      (`table`) Table to check (must be list-like, not validated)
      • {value}  (`any`) Value to compare

    Return: ~
        (`boolean`) `true` if `t` contains `value`

    See also: ~
      • |vim.tbl_contains()| for checking values in general tables

vim.list_extend({dst}, {src}, {start}, {finish})           *vim.list_extend()*
    Extends a list-like table with the values of another list-like table.

    NOTE: This mutates dst!

    Parameters: ~
      • {dst}     (`table`) List which will be modified and appended to
      • {src}     (`table`) List from which values will be inserted
      • {start}   (`integer?`) Start index on src. Defaults to 1
      • {finish}  (`integer?`) Final index on src. Defaults to `#src`

    Return: ~
        (`table`) dst

    See also: ~
      • |vim.tbl_extend()|

vim.list_slice({list}, {start}, {finish})                   *vim.list_slice()*
    Creates a copy of a table containing only elements from start to end
    (inclusive)

    Parameters: ~
      • {list}    (`any[]`) Table
      • {start}   (`integer?`) Start range of slice
      • {finish}  (`integer?`) End range of slice

    Return: ~
        (`any[]`) Copy of table sliced from start to finish (inclusive)

vim.pesc({s})                                                     *vim.pesc()*
    Escapes magic chars in |lua-pattern|s.

    Parameters: ~
      • {s}  (`string`) String to escape

    Return: ~
        (`string`) %-escaped pattern string

    See also: ~
      • https://github.com/rxi/lume

vim.ringbuf({size})                                            *vim.ringbuf()*
    Create a ring buffer limited to a maximal number of items. Once the buffer
    is full, adding a new entry overrides the oldest entry. >lua
        local ringbuf = vim.ringbuf(4)
        ringbuf:push("a")
        ringbuf:push("b")
        ringbuf:push("c")
        ringbuf:push("d")
        ringbuf:push("e")    -- overrides "a"
        print(ringbuf:pop()) -- returns "b"
        print(ringbuf:pop()) -- returns "c"

        -- Can be used as iterator. Pops remaining items:
        for val in ringbuf do
          print(val)
        end
<

    Returns a Ringbuf instance with the following methods:
    • |Ringbuf:push()|
    • |Ringbuf:pop()|
    • |Ringbuf:peek()|
    • |Ringbuf:clear()|

    Parameters: ~
      • {size}  (`integer`)

    Return: ~
        (`vim.Ringbuf`) ringbuf See |vim.Ringbuf|.

vim.spairs({t})                                                 *vim.spairs()*
    Enumerates key-value pairs of a table, ordered by key.

    Parameters: ~
      • {t}  (`table`) Dict-like table

    Return (multiple): ~
        (`fun(table: table<K, V>, index?: K):K, V`) |for-in| iterator over
        sorted keys and their values
        (`table`)

    See also: ~
      • Based on
        https://github.com/premake/premake-core/blob/master/src/base/table.lua

vim.split({s}, {sep}, {opts})                                    *vim.split()*
    Splits a string at each instance of a separator and returns the result as
    a table (unlike |vim.gsplit()|).

    Examples: >lua
        split(":aa::b:", ":")                   --> {'','aa','','b',''}
        split("axaby", "ab?")                   --> {'','x','y'}
        split("x*yz*o", "*", {plain=true})      --> {'x','yz','o'}
        split("|x|y|z|", "|", {trimempty=true}) --> {'x', 'y', 'z'}
<

    Parameters: ~
      • {s}     (`string`) String to split
      • {sep}   (`string`) Separator or pattern
      • {opts}  (`table?`) Keyword arguments |kwargs|:
                • {plain}? (`boolean`) Use `sep` literally (as in
                  string.find).
                • {trimempty}? (`boolean`) Discard empty segments at start and
                  end of the sequence.

    Return: ~
        (`string[]`) List of split components

    See also: ~
      • |vim.gsplit()|
      • |string.gmatch()|

vim.startswith({s}, {prefix})                               *vim.startswith()*
    Tests if `s` starts with `prefix`.

    Parameters: ~
      • {s}       (`string`) String
      • {prefix}  (`string`) Prefix to match

    Return: ~
        (`boolean`) `true` if `prefix` is a prefix of `s`

vim.tbl_contains({t}, {value}, {opts})                    *vim.tbl_contains()*
    Checks if a table contains a given value, specified either directly or via
    a predicate that is checked for each value.

    Example: >lua
        vim.tbl_contains({ 'a', { 'b', 'c' } }, function(v)
          return vim.deep_equal(v, { 'b', 'c' })
        end, { predicate = true })
        -- true
<

    Parameters: ~
      • {t}      (`table`) Table to check
      • {value}  (`any`) Value to compare or predicate function reference
      • {opts}   (`table?`) Keyword arguments |kwargs|:
                 • {predicate}? (`boolean`) `value` is a function reference to
                   be checked (default false)

    Return: ~
        (`boolean`) `true` if `t` contains `value`

    See also: ~
      • |vim.list_contains()| for checking values in list-like tables

vim.tbl_count({t})                                           *vim.tbl_count()*
    Counts the number of non-nil values in table `t`. >lua
        vim.tbl_count({ a=1, b=2 })  --> 2
        vim.tbl_count({ 1, 2 })      --> 2
<

    Parameters: ~
      • {t}  (`table`) Table

    Return: ~
        (`integer`) Number of non-nil values in table

    See also: ~
      • https://github.com/Tieske/Penlight/blob/master/lua/pl/tablex.lua

vim.tbl_deep_extend({behavior}, {...})                 *vim.tbl_deep_extend()*
    Merges two or more tables recursively.

    Only |lua-dict| tables are merged recursively; |lua-list| tables are
    treated as opaque values (overwritten instead of merged). That is
    convenient for merging default/user configurations where lists typically
    should not be merged together.

    Example: >lua
        -- Set `config.settings.…` without worrying about whether intermediate dicts exist.
        local config = { settings = { tailwindCSS = { foo = 'bar' } } }
        local merged = vim.tbl_deep_extend('force',
          config,
          { settings = { tailwindCSS = { experimental = { configFile = '/my/config.json' } } } }
        )
        vim.print(merged)
<

    Parameters: ~
      • {behavior}  (`'error'|'keep'|'force'|fun(key:any, prev_value:any?, value:any): any`)
                    Decides what to do if a key is found in more than one map:
                    • "error": raise an error
                    • "force": use value from the rightmost map
                    • "keep": use value from the leftmost map
                    • If a function, it receives the current key, the previous
                      value in the currently merged table (if present), the
                      current value and should return the value for the given
                      key in the merged table.
      • {...}       (`table`) Two or more tables

    Return: ~
        (`table`) Merged table

    See also: ~
      • |vim.tbl_extend()|

vim.tbl_extend({behavior}, {...})                           *vim.tbl_extend()*
    Merges two or more tables.

    Parameters: ~
      • {behavior}  (`'error'|'keep'|'force'|fun(key:any, prev_value:any?, value:any): any`)
                    Decides what to do if a key is found in more than one map:
                    • "error": raise an error
                    • "force": use value from the rightmost map
                    • "keep": use value from the leftmost map
                    • If a function, it receives the current key, the previous
                      value in the currently merged table (if present), the
                      current value and should return the value for the given
                      key in the merged table.
      • {...}       (`table`) Two or more tables

    Return: ~
        (`table`) Merged table

    See also: ~
      • |extend()|

vim.tbl_filter({fn}, {t})                                   *vim.tbl_filter()*
    Filter a table using a predicate function

    Parameters: ~
      • {fn}  (`function`) Function
      • {t}   (`table`) Table

    Return: ~
        (`any[]`) Table of filtered values

vim.tbl_get({o}, {...})                                        *vim.tbl_get()*
    Gets a (nested) value from table `o` given by a sequence of keys `...`, or
    `nil` if not found.

    Note: To set deeply nested keys, see |vim.tbl_deep_extend()|.

    Example: >lua
        local o = { a = { b = true } }
        -- Get `o.a.b`.
        vim.print(vim.tbl_get(o, 'a', 'b')) -- true
        o.a = {}
        vim.print(vim.tbl_get(o, 'a', 'b')) -- nil
<

    Parameters: ~
      • {o}    (`table`) Table to index
      • {...}  (`any`) Optional keys (0 or more, variadic) via which to index
               the table

    Return: ~
        (`any`) Nested value indexed by key (if it exists), else nil

    See also: ~
      • |unpack()|
      • |vim.tbl_deep_extend()|

vim.tbl_isempty({t})                                       *vim.tbl_isempty()*
    Checks if a table is empty.

    Parameters: ~
      • {t}  (`table`) Table to check

    Return: ~
        (`boolean`) `true` if `t` is empty

    See also: ~
      • https://github.com/premake/premake-core/blob/master/src/base/table.lua

vim.tbl_keys({t})                                             *vim.tbl_keys()*
    Return a list of all keys used in a table. However, the order of the
    return table of keys is not guaranteed.

    Parameters: ~
      • {t}  (`table`) Table

    Return: ~
        (`any[]`) List of keys

    See also: ~
      • From
        https://github.com/premake/premake-core/blob/master/src/base/table.lua

vim.tbl_map({fn}, {t})                                         *vim.tbl_map()*
    Applies function `fn` to all values of table `t`, in `pairs()` iteration
    order (which is not guaranteed to be stable, even when the data doesn't
    change).

    Parameters: ~
      • {fn}  (`fun(value: T): any`) Function
      • {t}   (`table<any, T>`) Table

    Return: ~
        (`table`) Table of transformed values

vim.tbl_values({t})                                         *vim.tbl_values()*
    Return a list of all values used in a table. However, the order of the
    return table of values is not guaranteed.

    Parameters: ~
      • {t}  (`table`) Table

    Return: ~
        (`any[]`) List of values

vim.trim({s})                                                     *vim.trim()*
    Trim whitespace (Lua pattern "%s") from both sides of a string.

    Parameters: ~
      • {s}  (`string`) String to trim

    Return: ~
        (`string`) String with whitespace removed from its beginning and end

    See also: ~
      • |lua-pattern|s
      • https://www.lua.org/pil/20.2.html

                                                              *vim.validate()*
vim.validate({name}, {value}, {validator}, {optional}, {message})
    Validate function arguments.

    This function has two valid forms:
    1. `vim.validate(name, value, validator[, optional][, message])`
       Validates that argument {name} with value {value} satisfies
       {validator}. If {optional} is given and is `true`, then {value} may be
       `nil`. If {message} is given, then it is used as the expected type in
       the error message.
       Example: >lua
         function vim.startswith(s, prefix)
          vim.validate('s', s, 'string')
          vim.validate('prefix', prefix, 'string')
          -- ...
        end
<

    2. `vim.validate(spec)` (deprecated) where `spec` is of type
       `table<string,[value:any, validator: vim.validate.Validator, optional_or_msg? : boolean|string]>)`
       Validates a argument specification. Specs are evaluated in alphanumeric
       order, until the first failure.
       Example: >lua
         function user.new(name, age, hobbies)
          vim.validate{
            name={name, 'string'},
            age={age, 'number'},
            hobbies={hobbies, 'table'},
          }
          -- ...
        end
<

    Examples with explicit argument values (can be run directly): >lua
        vim.validate('arg1', {'foo'}, 'table')
           --> NOP (success)
        vim.validate('arg2', 'foo', 'string')
           --> NOP (success)

        vim.validate('arg1', 1, 'table')
           --> error('arg1: expected table, got number')

        vim.validate('arg1', 3, function(a) return (a % 2) == 0 end, 'even number')
           --> error('arg1: expected even number, got 3')
<

    If multiple types are valid they can be given as a list. >lua
        vim.validate('arg1', {'foo'}, {'table', 'string'})
        vim.validate('arg2', 'foo', {'table', 'string'})
        -- NOP (success)

        vim.validate('arg1', 1, {'string', 'table'})
        -- error('arg1: expected string|table, got number')
<

    Note: ~
      • `validator` set to a value returned by |lua-type()| provides the best
        performance.

    Parameters: ~
      • {name}       (`string`) Argument name
      • {value}      (`any`) Argument value
      • {validator}  (`vim.validate.Validator`)
                     • (`string|string[]`): Any value that can be returned
                       from |lua-type()| in addition to `'callable'`:
                       `'boolean'`, `'callable'`, `'function'`, `'nil'`,
                       `'number'`, `'string'`, `'table'`, `'thread'`,
                       `'userdata'`.
                     • (`fun(val:any): boolean, string?`) A function that
                       returns a boolean and an optional string message.
      • {optional}   (`boolean?`) Parameter is optional (may be omitted or
                     nil)
      • {message}    (`string?`) message when validation fails

    Overloads: ~
      • `fun(name: string, val: any, validator: vim.validate.Validator, message: string)`
      • `fun(spec: table<string,[any, vim.validate.Validator, boolean|string]>)`


==============================================================================
Lua module: vim.base64                                            *vim.base64*

vim.base64.decode({str})                                 *vim.base64.decode()*
    Decode a Base64 encoded string.

    Parameters: ~
      • {str}  (`string`) Base64 encoded string

    Return: ~
        (`string`) Decoded string

vim.base64.encode({str})                                 *vim.base64.encode()*
    Encode {str} using Base64.

    Parameters: ~
      • {str}  (`string`) String to encode

    Return: ~
        (`string`) Encoded string


==============================================================================
Lua module: vim.filetype                                        *vim.filetype*

vim.filetype.add({filetypes})                             *vim.filetype.add()*
    Add new filetype mappings.

    Filetype mappings can be added either by extension or by filename (either
    the "tail" or the full file path). The full file path is checked first,
    followed by the file name. If a match is not found using the filename,
    then the filename is matched against the list of |lua-pattern|s (sorted by
    priority) until a match is found. Lastly, if pattern matching does not
    find a filetype, then the file extension is used.

    The filetype can be either a string (in which case it is used as the
    filetype directly) or a function. If a function, it takes the full path
    and buffer number of the file as arguments (along with captures from the
    matched pattern, if any) and should return a string that will be used as
    the buffer's filetype. Optionally, the function can return a second
    function value which, when called, modifies the state of the buffer. This
    can be used to, for example, set filetype-specific buffer variables. This
    function will be called by Nvim before setting the buffer's filetype.

    Filename patterns can specify an optional priority to resolve cases when a
    file path matches multiple patterns. Higher priorities are matched first.
    When omitted, the priority defaults to 0. A pattern can contain
    environment variables of the form "${SOME_VAR}" that will be automatically
    expanded. If the environment variable is not set, the pattern won't be
    matched.

    See $VIMRUNTIME/lua/vim/filetype.lua for more examples.

    Example: >lua
        vim.filetype.add({
          extension = {
            foo = 'fooscript',
            bar = function(path, bufnr)
              if some_condition() then
                return 'barscript', function(bufnr)
                  -- Set a buffer variable
                  vim.b[bufnr].barscript_version = 2
                end
              end
              return 'bar'
            end,
          },
          filename = {
            ['.foorc'] = 'toml',
            ['/etc/foo/config'] = 'toml',
          },
          pattern = {
            ['.*/etc/foo/.*'] = 'fooscript',
            -- Using an optional priority
            ['.*/etc/foo/.*%.conf'] = { 'dosini', { priority = 10 } },
            -- A pattern containing an environment variable
            ['${XDG_CONFIG_HOME}/foo/git'] = 'git',
            ['.*README.(%a+)'] = function(path, bufnr, ext)
              if ext == 'md' then
                return 'markdown'
              elseif ext == 'rst' then
                return 'rst'
              end
            end,
          },
        })
<

    To add a fallback match on contents, use >lua
        vim.filetype.add {
          pattern = {
            ['.*'] = {
              function(path, bufnr)
                local content = vim.api.nvim_buf_get_lines(bufnr, 0, 1, false)[1] or ''
                if vim.regex([[^#!.*\\<mine\\>]]):match_str(content) ~= nil then
                  return 'mine'
                elseif vim.regex([[\\<drawing\\>]]):match_str(content) ~= nil then
                  return 'drawing'
                end
              end,
              { priority = -math.huge },
            },
          },
        }
<

    Parameters: ~
      • {filetypes}  (`table`) A table containing new filetype maps (see
                     example).
                     • {extension}? (`vim.filetype.mapping`)
                     • {filename}? (`vim.filetype.mapping`)
                     • {pattern}? (`vim.filetype.mapping`)

                                                   *vim.filetype.get_option()*
vim.filetype.get_option({filetype}, {option})
    Get the default option value for a {filetype}.

    The returned value is what would be set in a new buffer after 'filetype'
    is set, meaning it should respect all FileType autocmds and ftplugin
    files.

    Example: >lua
        vim.filetype.get_option('vim', 'commentstring')
<

    Note: this uses |nvim_get_option_value()| but caches the result. This
    means |ftplugin| and |FileType| autocommands are only triggered once and
    may not reflect later changes.

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {filetype}  (`string`) Filetype
      • {option}    (`string`) Option name

    Return: ~
        (`string|boolean|integer`) Option value

vim.filetype.inspect()                                *vim.filetype.inspect()*
    Inspect the current state of the filetype registry.

    Returns a copy of the internal tables used for filetype detection by
    extension, filename, or pattern. Note: Due to the dynamic nature of
    filetype detection, this is only useful for checking whether a certain
    extension, filename, or pattern has been registered so far. In addition,
    the `pattern` table is in an internal format optimized for fast lookup.
    Prefer |vim.filetype.match()| for checking the detected filetype for a
    given pattern.

    Return: ~
        (`table<string, table<string, vim.filetype.mapping|table<string, vim.filetype.mapping>>>`)

vim.filetype.match({args})                              *vim.filetype.match()*
    Perform filetype detection.

    The filetype can be detected using one of three methods:
    1. Using an existing buffer

    2. Using only a file name

    3. Using only file contents

    Of these, option 1 provides the most accurate result as it uses both the
    buffer's filename and (optionally) the buffer contents. Options 2 and 3
    can be used without an existing buffer, but may not always provide a match
    in cases where the filename (or contents) cannot unambiguously determine
    the filetype.

    Each of the three options is specified using a key to the single argument
    of this function. Example: >lua
        -- Using a buffer number
        vim.filetype.match({ buf = 42 })

        -- Override the filename of the given buffer
        vim.filetype.match({ buf = 42, filename = 'foo.c' })

        -- Using a filename without a buffer
        vim.filetype.match({ filename = 'main.lua' })

        -- Using file contents
        vim.filetype.match({ contents = {'#!/usr/bin/env bash'} })
<

    Parameters: ~
      • {args}  (`table`) Table specifying which matching strategy to use.
                Accepted keys are:
                • {buf}? (`integer`) Buffer number to use for matching.
                  Mutually exclusive with {contents}
                • {contents}? (`string[]`) An array of lines representing file
                  contents to use for matching. Can be used with {filename}.
                  Mutually exclusive with {buf}.
                • {filename}? (`string`) Filename to use for matching. When
                  {buf} is given, defaults to the filename of the given buffer
                  number. The file need not actually exist in the filesystem.
                  When used without {buf} only the name of the file is used
                  for filetype matching. This may result in failure to detect
                  the filetype in cases where the filename alone is not enough
                  to disambiguate the filetype.

    Return (multiple): ~
        (`string?`) The matched filetype, if any.
        (`function?`) A function `fun(buf: integer)` that modifies buffer
        state when called (for example, to set some filetype specific buffer
        variables).
        (`boolean?`) true if a match was found by falling back to a generic
        filetype (i.e., ".conf"), which indicates the filetype should be set
        with `:setf FALLBACK conf`. See |:setfiletype|.


==============================================================================
Lua module: vim.fs                                                    *vim.fs*

                                                               *vim.fs.copy()*

Use |filecopy()| or |uv.fs_copyfile()| to performantly copy an existing file.

Example: >lua
    vim.fn.filecopy('foo.txt', 'bar.txt')
<

                                                             *vim.fs.exists()*

Use |uv.fs_stat()| to check a file's type, and whether it exists.

Example: >lua
    if vim.uv.fs_stat(file) then
      vim.print('file exists')
    end
<

                                                               *vim.fs.read()*

You can use |readblob()| to get a file's contents without explicitly
opening/closing it. Or use |io.lines()| to iterate lines in a text file.

Example: >lua
    vim.print(vim.fn.readblob('.git/config'))
<

                                                              *vim.fs.write()*

You can use |writefile()| to write a file without explicitly opening/closing
it.

Example: >lua
    vim.fn.writefile('foo\0bar', 'data.bin', 'b')
<


vim.fs.abspath({path})                                      *vim.fs.abspath()*
    Converts `path` to an absolute path. Expands tilde (~) at the beginning of
    the path to the user's home directory. Does not check if the path exists,
    normalize the path, resolve symlinks or hardlinks (including `.` and
    `..`), or expand environment variables. If the path is already absolute,
    it is returned unchanged. Also converts `\` path separators to `/`.

    Attributes: ~
        Since: 0.11.0

    Parameters: ~
      • {path}  (`string`) Path

    Return: ~
        (`string`) Absolute path

vim.fs.basename({file})                                    *vim.fs.basename()*
    Gets the basename of the given path (not expanded/resolved).

    Attributes: ~
        Since: 0.8.0

    Parameters: ~
      • {file}  (`string?`) Path

    Return: ~
        (`string?`) Basename of {file}

vim.fs.dir({path}, {opts})                                      *vim.fs.dir()*
    Gets an iterator over items found in `path` (normalized via
    |vim.fs.normalize()|).

    Attributes: ~
        Since: 0.8.0

    Parameters: ~
      • {path}  (`string`) Directory to iterate over, normalized via
                |vim.fs.normalize()|.
      • {opts}  (`table?`) Optional keyword arguments:
                • {depth}? (`integer`, default: `1`) How deep to traverse.
                • {follow}? (`boolean`, default: `false`) Follow symbolic
                  links.
                • {skip}? (`fun(dir_name: string): boolean`) Predicate to
                  control traversal. Return false to stop searching the
                  current directory. Only useful when depth > 1 Return an
                  iterator over the items located in {path}

    Return: ~
        (`Iterator`) over items in {path}. Each iteration yields two values:
        "name" and "type". "name" is the basename of the item relative to
        {path}. "type" is one of the following: "file", "directory", "link",
        "fifo", "socket", "char", "block", "unknown".

vim.fs.dirname({file})                                      *vim.fs.dirname()*
    Gets the parent directory of the given path (not expanded/resolved, the
    caller must do that).

    Attributes: ~
        Since: 0.8.0

    Parameters: ~
      • {file}  (`string?`) Path

    Return: ~
        (`string?`) Parent directory of {file}

vim.fs.ext({file}, {opts})                                      *vim.fs.ext()*
    Return the file's last extension, if any.

    Similar to |fnamemodify()| with the |::e| modifier. The extension does not
    include a leading period.

    Examples: >lua
        vim.fs.ext('archive.tar.gz') -- 'gz'
        vim.fs.ext('~/.git') -- ''
        vim.fs.ext('plugin/myplug.lua') -- 'lua'
<

    Attributes: ~
        Since: 0.12.0

    Parameters: ~
      • {file}  (`string`) Path
      • {opts}  (`table?`) Reserved for future use

    Return: ~
        (`string`) Extension of {file}

vim.fs.find({names}, {opts})                                   *vim.fs.find()*
    Find files or directories (or other items as specified by `opts.type`) in
    the given path.

    Finds items given in {names} starting from {path}. If {upward} is "true"
    then the search traverses upward through parent directories; otherwise,
    the search traverses downward. Note that downward searches are recursive
    and may search through many directories! If {stop} is non-nil, then the
    search stops when the directory given in {stop} is reached. The search
    terminates when {limit} (default 1) matches are found. You can set {type}
    to "file", "directory", "link", "socket", "char", "block", or "fifo" to
    narrow the search to find only that type.

    Examples: >lua
        -- List all test directories under the runtime directory.
        local dirs = vim.fs.find(
          { 'test', 'tst', 'testdir' },
          { limit = math.huge, type = 'directory', path = './runtime/' }
        )

        -- Get all "lib/*.cpp" and "lib/*.hpp" files, using Lua patterns.
        -- Or use `vim.glob.to_lpeg(…):match(…)` for glob/wildcard matching.
        local files = vim.fs.find(function(name, path)
          return name:match('.*%.[ch]pp$') and path:match('[/\\]lib$')
        end, { limit = math.huge, type = 'file' })
<

    Attributes: ~
        Since: 0.8.0

    Parameters: ~
      • {names}  (`string|string[]|fun(name: string, path: string): boolean`)
                 Names of the items to find. Must be base names, paths and
                 globs are not supported when {names} is a string or a table.
                 If {names} is a function, it is called for each traversed
                 item with args:
                 • name: base name of the current item
                 • path: full path of the current item

                 The function should return `true` if the given item is
                 considered a match.
      • {opts}   (`table?`) Optional keyword arguments:
                 • {follow}? (`boolean`, default: `false`) Follow symbolic
                   links.
                 • {limit}? (`number`, default: `1`) Stop searching after this
                   many matches. Use `math.huge` for "unlimited".
                 • {path}? (`string`) Path to begin searching from, defaults
                   to |current-directory|. Not expanded.
                 • {stop}? (`string`) Stop searching when this directory is
                   reached. The directory itself is not searched.
                 • {type}? (`string`) Find only items of the given type. If
                   omitted, all items that match {names} are included.
                 • {upward}? (`boolean`, default: `false`) Search upward
                   through parent directories. Otherwise, search child
                   directories (recursively).

    Return: ~
        (`string[]`) Normalized paths |vim.fs.normalize()| of all matching
        items

vim.fs.joinpath({...})                                     *vim.fs.joinpath()*
    Concatenates partial paths (one absolute or relative path followed by zero
    or more relative paths). Slashes are normalized: redundant slashes are
    removed, and (on Windows) backslashes are replaced with forward-slashes.
    Empty segments are removed. Paths are not expanded/resolved.

    Examples:
    • "foo/", "/bar" => "foo/bar"
    • "", "after/plugin" => "after/plugin"
    • Windows: "a\foo\", "\bar" => "a/foo/bar"

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {...}  (`string`)

    Return: ~
        (`string`)

vim.fs.normalize({path}, {opts})                          *vim.fs.normalize()*
    Normalize a path to a standard format. A tilde (~) character at the
    beginning of the path is expanded to the user's home directory and
    environment variables are also expanded. "." and ".." components are also
    resolved, except when the path is relative and trying to resolve it would
    result in an absolute path.
    • "." as the only part in a relative path:
      • "." => "."
      • "././" => "."
    • ".." when it leads outside the current directory
      • "foo/../../bar" => "../bar"
      • "../../foo" => "../../foo"
    • ".." in the root directory returns the root directory.
      • "/../../" => "/"

    On Windows, backslash (\) characters are converted to forward slashes (/).

    Examples: >lua
        [[C:\Users\jdoe]]                         => "C:/Users/jdoe"
        "~/src/neovim"                            => "/home/jdoe/src/neovim"
        "$XDG_CONFIG_HOME/nvim/init.vim"          => "/Users/jdoe/.config/nvim/init.vim"
        "~/src/nvim/api/../tui/./tui.c"           => "/home/jdoe/src/nvim/tui/tui.c"
        "./foo/bar"                               => "foo/bar"
        "foo/../../../bar"                        => "../../bar"
        "/home/jdoe/../../../bar"                 => "/bar"
        "C:foo/../../baz"                         => "C:../baz"
        "C:/foo/../../baz"                        => "C:/baz"
        [[\\?\UNC\server\share\foo\..\..\..\bar]] => "//?/UNC/server/share/bar"
<

    Attributes: ~
        Since: 0.8.0

    Parameters: ~
      • {path}  (`string`) Path to normalize
      • {opts}  (`table?`) A table with the following fields:
                • {expand_env}? (`boolean`, default: `true`) Expand
                  environment variables.
                • {win}? (`boolean`, default: `true` in Windows, `false`
                  otherwise) Path is a Windows path.

    Return: ~
        (`string`) Normalized path

vim.fs.parents({start})                                     *vim.fs.parents()*
    Iterate over all the parents of the given path (not expanded/resolved, the
    caller must do that).

    Example: >lua
        local root_dir
        for dir in vim.fs.parents(vim.api.nvim_buf_get_name(0)) do
          if vim.fn.isdirectory(dir .. '/.git') == 1 then
            root_dir = dir
            break
          end
        end

        if root_dir then
          print('Found git repository at', root_dir)
        end
<

    Attributes: ~
        Since: 0.8.0

    Parameters: ~
      • {start}  (`string`) Initial path.

    Return (multiple): ~
        (`fun(_, dir: string): string?`) Iterator
        (`nil`)
        (`string?`)

vim.fs.relpath({base}, {target}, {opts})                    *vim.fs.relpath()*
    Gets `target` path relative to `base`, or `nil` if `base` is not an
    ancestor.

    Example: >lua
        vim.fs.relpath('/var', '/var/lib') -- 'lib'
        vim.fs.relpath('/var', '/usr/bin') -- nil
<

    Attributes: ~
        Since: 0.11.0

    Parameters: ~
      • {base}    (`string`)
      • {target}  (`string`)
      • {opts}    (`table?`) Reserved for future use

    Return: ~
        (`string?`)

vim.fs.rm({path}, {opts})                                        *vim.fs.rm()*
    Removes a file or directory.

    Removes symlinks without touching the origin. To remove the origin,
    resolve it explicitly with |uv.fs_realpath()|: >lua
        vim.fs.rm(vim.uv.fs_realpath('symlink-dir'), { recursive = true })
<

    Attributes: ~
        Since: 0.11.0

    Parameters: ~
      • {path}  (`string`) Path to remove (not expanded/resolved).
      • {opts}  (`table?`) A table with the following fields:
                • {force}? (`boolean`) Ignore nonexistent files and arguments.
                • {recursive}? (`boolean`) Remove directory contents
                  recursively.

vim.fs.root({source}, {marker})                                *vim.fs.root()*
    Find the first parent directory containing a specific "marker", relative
    to a file path or buffer.

    If the buffer is unnamed (has no backing file) or has a non-empty
    'buftype' then the search begins from Nvim's |current-directory|.

    Examples: >lua
        -- Find the root of a Python project, starting from file 'main.py'
        vim.fs.root(vim.fs.joinpath(vim.env.PWD, 'main.py'), {'pyproject.toml', 'setup.py' })

        -- Find the root of a git repository
        vim.fs.root(0, '.git')

        -- Find the parent directory containing any file with a .csproj extension
        vim.fs.root(0, function(name, path)
          return vim.fs.ext(name) == 'csproj'
        end)

        -- Find the first ancestor directory containing EITHER "stylua.toml" or ".luarc.json"; if
        -- not found, find the first ancestor containing ".git":
        vim.fs.root(0, { { 'stylua.toml', '.luarc.json' }, '.git' })
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {source}  (`integer|string`) Buffer number (0 for current buffer) or
                  file path (absolute or relative, expanded via `abspath()`)
                  to begin the search from.
      • {marker}  (`(string|string[]|fun(name: string, path: string): boolean)[]|string|fun(name: string, path: string): boolean`)
                  Filename, function, or list thereof, that decides how to
                  find the root. To indicate "equal priority", specify items
                  in a nested list `{ { 'a.txt', 'b.lua' }, … }`. A function
                  item must return true if `name` and `path` are a match. Each
                  item (which may itself be a nested list) is evaluated
                  in-order against all ancestors, until a match is found.

    Return: ~
        (`string?`) Directory path containing one of the given markers, or nil
        if no directory was found.


==============================================================================
Lua module: vim.glob                                                *vim.glob*

Glob-to-LPeg Converter (Peglob) This module converts glob patterns to LPeg
patterns according to the LSP 3.17 specification:
https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#pattern

Glob grammar overview:
• `*` to match zero or more characters in a path segment
• `?` to match on one character in a path segment
• `**` to match any number of path segments, including none
• `{}` to group conditions (e.g. `*.{ts,js}` matches TypeScript and JavaScript
  files)
• `[]` to declare a range of characters to match in a path segment (e.g.,
  `example.[0-9]` to match on `example.0`, `example.1`, …)
• `[!...]` to negate a range of characters to match in a path segment (e.g.,
  `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)

Additional constraints:
• A Glob pattern must match an entire path, with partial matches considered
  failures.
• The pattern only determines success or failure, without specifying which
  parts correspond to which characters.
• A path segment is the portion of a path between two adjacent path separators
  (`/`), or between the start/end of the path and the nearest separator.
• The `**` (globstar) pattern matches zero or more path segments, including
  intervening separators (`/`). Within pattern strings, `**` must be delimited
  by path separators (`/`) or pattern boundaries and cannot be adjacent to any
  characters other than `/`. If `**` is not the final element, it must be
  followed by `/`.
• `{}` (braced conditions) contains valid Glob patterns as branches, separated
  by commas. Commas are exclusively used for separating branches and cannot
  appear within a branch for any other purpose. Nested `{}` structures are
  allowed, but `{}` must contain at least two branches—zero or one branch is
  not permitted.
• In `[]` or `[!...]`, a character range consists of character intervals
  (e.g., `a-z`) or individual characters (e.g., `w`). A range including `/`
  won’t match that character.


vim.glob.to_lpeg({pattern})                               *vim.glob.to_lpeg()*
    Parses a raw glob into an |lua-lpeg| pattern.

    Parameters: ~
      • {pattern}  (`string`) The raw glob pattern

    Return: ~
        (`vim.lpeg.Pattern`) An |lua-lpeg| representation of the pattern


==============================================================================
Lua module: vim.hl                                                    *vim.hl*

vim.hl.on_yank({opts})                                      *vim.hl.on_yank()*
    Highlight the yanked text during a |TextYankPost| event.

    Add the following to your `init.vim`: >vim
        autocmd TextYankPost * silent! lua vim.hl.on_yank {higroup='Visual', timeout=300}
<

    Parameters: ~
      • {opts}  (`table?`) Optional parameters
                • event event structure (default vim.v.event)
                • higroup highlight group for yanked region (default
                  "IncSearch")
                • on_macro highlight when executing macro (default false)
                • on_visual highlight when yanking visual selection (default
                  true)
                • priority integer priority (default
                  |vim.hl.priorities|`.user`)
                • timeout time in ms before highlight is cleared (default 150)

vim.hl.priorities                                          *vim.hl.priorities*
    Table with default priorities used for highlighting:
    • `syntax`: `50`, used for standard syntax highlighting
    • `treesitter`: `100`, used for treesitter-based highlighting
    • `semantic_tokens`: `125`, used for LSP semantic token highlighting
    • `diagnostics`: `150`, used for code analysis such as diagnostics
    • `user`: `200`, used for user-triggered highlights such as LSP document
      symbols or `on_yank` autocommands

                                                              *vim.hl.range()*
vim.hl.range({buf}, {ns}, {higroup}, {start}, {finish}, {opts})
    Apply highlight group to range of text.

    Parameters: ~
      • {buf}      (`integer`) Buffer number to apply highlighting to
      • {ns}       (`integer`) Namespace to add highlight to
      • {higroup}  (`string`) Highlight group to use for highlighting
      • {start}    (`[integer,integer]|string`) Start of region as a (line,
                   column) tuple or string accepted by |getpos()|
      • {finish}   (`[integer,integer]|string`) End of region as a (line,
                   column) tuple or string accepted by |getpos()|
      • {opts}     (`table?`) A table with the following fields:
                   • {inclusive}? (`boolean`, default: `false`) Indicates
                     whether the range is end-inclusive
                   • {priority}? (`integer`, default:
                     `vim.hl.priorities.user`) Highlight priority
                   • {regtype}? (`string`, default: `'v'` i.e. charwise) Type
                     of range. See |getregtype()|
                   • {timeout}? (`integer`, default: -1 no timeout) Time in ms
                     before highlight is cleared

    Return (multiple): ~
        (`uv.uv_timer_t?`) range_timer A timer which manages how much time the
        highlight has left
        (`fun()?`) range_clear A function which allows clearing the highlight
        manually. nil is returned if timeout is not specified


==============================================================================
Lua module: vim.iter                                                *vim.iter*

*vim.iter()* is an interface for |iterable|s: it wraps a table or function
argument into an *Iter* object with methods (such as |Iter:filter()| and
|Iter:map()|) that transform the underlying source data. These methods can be
chained to create iterator "pipelines": the output of each pipeline stage is
input to the next stage. The first stage depends on the type passed to
`vim.iter()`:
• Lists or arrays (|lua-list|) yield only the value of each element.
  • Holes (nil values) are allowed (but discarded).
  • Use pairs() to treat array/list tables as dicts (preserve holes and
    non-contiguous integer keys): `vim.iter(pairs(…))`.
  • Use |Iter:enumerate()| to also pass the index to the next stage.
    • Or initialize with ipairs(): `vim.iter(ipairs(…))`.
• Non-list tables (|lua-dict|) yield both the key and value of each element.
• Function |iterator|s yield all values returned by the underlying function.
• Tables with a |__call()| metamethod are treated as function iterators.

The iterator pipeline terminates when the underlying |iterable| is exhausted
(for function iterators this means it returned nil).

Note: `vim.iter()` scans table input to decide if it is a list or a dict; to
avoid this cost you can wrap the table with an iterator e.g.
`vim.iter(ipairs({…}))`, but that precludes the use of |list-iterator|
operations such as |Iter:rev()|).

Examples: >lua
    local it = vim.iter({ 1, 2, 3, 4, 5 })
    it:map(function(v)
      return v * 3
    end)
    it:rev()
    it:skip(2)
    it:totable()
    -- { 9, 6, 3 }

    -- ipairs() is a function iterator which returns both the index (i) and the value (v)
    vim.iter(ipairs({ 1, 2, 3, 4, 5 })):map(function(i, v)
      if i > 2 then return v end
    end):totable()
    -- { 3, 4, 5 }

    local it = vim.iter(vim.gsplit('1,2,3,4,5', ','))
    it:map(function(s) return tonumber(s) end)
    for i, d in it:enumerate() do
      print(string.format("Column %d is %d", i, d))
    end
    -- Column 1 is 1
    -- Column 2 is 2
    -- Column 3 is 3
    -- Column 4 is 4
    -- Column 5 is 5

    vim.iter({ a = 1, b = 2, c = 3, z = 26 }):any(function(k, v)
      return k == 'z'
    end)
    -- true

    local rb = vim.ringbuf(3)
    rb:push("a")
    rb:push("b")
    vim.iter(rb):totable()
    -- { "a", "b" }
<


Iter:all({pred})                                                  *Iter:all()*
    Returns true if all items in the iterator match the given predicate.

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {pred}  (`fun(...):boolean`) Predicate function. Takes all values
                returned from the previous stage in the pipeline as arguments
                and returns true if the predicate matches.

Iter:any({pred})                                                  *Iter:any()*
    Returns true if any of the items in the iterator match the given
    predicate.

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {pred}  (`fun(...):boolean`) Predicate function. Takes all values
                returned from the previous stage in the pipeline as arguments
                and returns true if the predicate matches.

Iter:each({f})                                                   *Iter:each()*
    Calls a function once for each item in the pipeline, draining the
    iterator.

    For functions with side effects. To modify the values in the iterator, use
    |Iter:map()|.

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {f}  (`fun(...)`) Function to execute for each item in the pipeline.
             Takes all of the values returned by the previous stage in the
             pipeline as arguments.

Iter:enumerate()                                            *Iter:enumerate()*
    Yields the item index (count) and value for each item of an iterator
    pipeline.

    For list tables, this is more efficient: >lua
        vim.iter(ipairs(t))
<

    instead of: >lua
        vim.iter(t):enumerate()
<

    Example: >lua

        local it = vim.iter(vim.gsplit('abc', '')):enumerate()
        it:next()
        -- 1	'a'
        it:next()
        -- 2	'b'
        it:next()
        -- 3	'c'
<

    Attributes: ~
        Since: 0.10.0

    Return: ~
        (`Iter`)

Iter:filter({f})                                               *Iter:filter()*
    Filters an iterator pipeline.

    Example: >lua
        local bufs = vim.iter(vim.api.nvim_list_bufs()):filter(vim.api.nvim_buf_is_loaded)
<

    Parameters: ~
      • {f}  (`fun(...):boolean`) Takes all values returned from the previous
             stage in the pipeline and returns false or nil if the current
             iterator element should be removed.

    Return: ~
        (`Iter`)

Iter:find({f})                                                   *Iter:find()*
    Find the first value in the iterator that satisfies the given predicate.

    Advances the iterator. Returns nil and drains the iterator if no value is
    found.

    Examples: >lua

        local it = vim.iter({ 3, 6, 9, 12 })
        it:find(12)
        -- 12

        local it = vim.iter({ 3, 6, 9, 12 })
        it:find(20)
        -- nil

        local it = vim.iter({ 3, 6, 9, 12 })
        it:find(function(v) return v % 4 == 0 end)
        -- 12
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {f}  (`any`)

    Return: ~
        (`any`)

Iter:flatten({depth})                                         *Iter:flatten()*
    Flattens a |list-iterator|, un-nesting nested values up to the given
    {depth}. Errors if it attempts to flatten a dict-like value.

    Examples: >lua
        vim.iter({ 1, { 2 }, { { 3 } } }):flatten():totable()
        -- { 1, 2, { 3 } }

        vim.iter({1, { { a = 2 } }, { 3 } }):flatten():totable()
        -- { 1, { a = 2 }, 3 }

        vim.iter({ 1, { { a = 2 } }, { 3 } }):flatten(math.huge):totable()
        -- error: attempt to flatten a dict-like table
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {depth}  (`number?`) Depth to which |list-iterator| should be
                 flattened (defaults to 1)

    Return: ~
        (`Iter`)

Iter:fold({init}, {f})                                           *Iter:fold()*
    Folds ("reduces") an iterator into a single value.         *Iter:reduce()*

    Examples: >lua
        -- Create a new table with only even values
        vim.iter({ a = 1, b = 2, c = 3, d = 4 })
          :filter(function(k, v) return v % 2 == 0 end)
          :fold({}, function(acc, k, v)
            acc[k] = v
            return acc
          end) --> { b = 2, d = 4 }

        -- Get the "maximum" item of an iterable.
        vim.iter({ -99, -4, 3, 42, 0, 0, 7 })
          :fold({}, function(acc, v)
            acc.max = math.max(v, acc.max or v)
            return acc
          end) --> { max = 42 }
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {init}  (`any`) Initial value of the accumulator.
      • {f}     (`fun(acc:A, ...):A`) Accumulation function.

    Return: ~
        (`any`)

Iter:join({delim})                                               *Iter:join()*
    Collect the iterator into a delimited string.

    Each element in the iterator is joined into a string separated by {delim}.

    Consumes the iterator.

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {delim}  (`string`) Delimiter

    Return: ~
        (`string`)

Iter:last()                                                      *Iter:last()*
    Drains the iterator and returns the last item.

    Example: >lua

        local it = vim.iter(vim.gsplit('abcdefg', ''))
        it:last()
        -- 'g'

        local it = vim.iter({ 3, 6, 9, 12, 15 })
        it:last()
        -- 15
<

    Attributes: ~
        Since: 0.10.0

    Return: ~
        (`any`)

    See also: ~
      • |Iter:rpeek()|

Iter:map({f})                                                     *Iter:map()*
    Maps the items of an iterator pipeline to the values returned by `f`.

    If the map function returns nil, the value is filtered from the iterator.

    Example: >lua
        local it = vim.iter({ 1, 2, 3, 4 }):map(function(v)
          if v % 2 == 0 then
            return v * 3
          end
        end)
        it:totable()
        -- { 6, 12 }
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {f}  (`fun(...):...:any`) Mapping function. Takes all values returned
             from the previous stage in the pipeline as arguments and returns
             one or more new values, which are used in the next pipeline
             stage. Nil return values are filtered from the output.

    Return: ~
        (`Iter`)

Iter:next()                                                      *Iter:next()*
    Gets the next value from the iterator.

    Example: >lua

        local it = vim.iter(string.gmatch('1 2 3', '%d+')):map(tonumber)
        it:next()
        -- 1
        it:next()
        -- 2
        it:next()
        -- 3
<

    Attributes: ~
        Since: 0.10.0

    Return: ~
        (`any`)

Iter:nth({n})                                                     *Iter:nth()*
    Gets the nth value of an iterator (and advances to it).

    If `n` is negative, offsets from the end of a |list-iterator|.

    Example: >lua
        local it = vim.iter({ 3, 6, 9, 12 })
        it:nth(2)
        -- 6
        it:nth(2)
        -- 12

        local it2 = vim.iter({ 3, 6, 9, 12 })
        it2:nth(-2)
        -- 9
        it2:nth(-2)
        -- 3
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {n}  (`number`) Index of the value to return. May be negative if the
             source is a |list-iterator|.

    Return: ~
        (`any`)

Iter:peek()                                                      *Iter:peek()*
    Gets the next value from the iterator without consuming it.

    The value returned by |Iter:peek()| will be returned again by the next
    call to |Iter:next()|.

    Example: >lua

        local it = vim.iter({ 3, 6, 9, 12 })
        it:peek()
        -- 3
        it:peek()
        -- 3
        it:next()
        -- 3
<

    Attributes: ~
        Since: 0.10.0

    Return: ~
        (`any`)

Iter:pop()                                                        *Iter:pop()*
    "Pops" a value from a |list-iterator| (gets the last value and decrements
    the tail).

    Example: >lua
        local it = vim.iter({1, 2, 3, 4})
        it:pop()
        -- 4
        it:pop()
        -- 3
<

    Attributes: ~
        Since: 0.10.0

    Return: ~
        (`any`)

Iter:rev()                                                        *Iter:rev()*
    Reverses a |list-iterator| pipeline.

    Example: >lua

        local it = vim.iter({ 3, 6, 9, 12 }):rev()
        it:totable()
        -- { 12, 9, 6, 3 }
<

    Attributes: ~
        Since: 0.10.0

    Return: ~
        (`Iter`)

Iter:rfind({f})                                                 *Iter:rfind()*
    Gets the first value satisfying a predicate, from the end of a
    |list-iterator|.

    Advances the iterator. Returns nil and drains the iterator if no value is
    found.

    Examples: >lua

        local it = vim.iter({ 1, 2, 3, 2, 1 }):enumerate()
        it:rfind(1)
        -- 5	1
        it:rfind(1)
        -- 1	1
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {f}  (`any`)

    Return: ~
        (`any`)

    See also: ~
      • |Iter:find()|

Iter:rpeek()                                                    *Iter:rpeek()*
    Gets the last value of a |list-iterator| without consuming it.

    Example: >lua
        local it = vim.iter({1, 2, 3, 4})
        it:rpeek()
        -- 4
        it:rpeek()
        -- 4
        it:pop()
        -- 4
<

    Attributes: ~
        Since: 0.10.0

    Return: ~
        (`any`)

    See also: ~
      • |Iter:last()|

Iter:rskip({n})                                                 *Iter:rskip()*
    Discards `n` values from the end of a |list-iterator| pipeline.

    Example: >lua
        local it = vim.iter({ 1, 2, 3, 4, 5 }):rskip(2)
        it:next()
        -- 1
        it:pop()
        -- 3
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {n}  (`number`) Number of values to skip.

    Return: ~
        (`Iter`)

Iter:skip({n})                                                   *Iter:skip()*
    Skips `n` values of an iterator pipeline, or skips values while a
    predicate returns |lua-truthy|.

    When a predicate is used, skipping stops at the first value for which the
    predicate returns non-truthy. That value is not consumed and will be
    returned by the next call to |Iter:next()|

    Example: >lua

        local it = vim.iter({ 3, 6, 9, 12 }):skip(2)
        it:next()
        -- 9

        local function pred(x) return x < 10 end
        local it2 = vim.iter({ 3, 6, 9, 12 }):skip(pred)
        it2:next()
        -- 12
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {n}  (`integer|fun(...):boolean`) Number of values to skip or a
             predicate.

    Return: ~
        (`Iter`)

Iter:slice({first}, {last})                                     *Iter:slice()*
    Sets the start and end of a |list-iterator| pipeline.

    Equivalent to `:skip(first - 1):rskip(len - last + 1)`.

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {first}  (`number`)
      • {last}   (`number`)

    Return: ~
        (`Iter`)

Iter:take({n})                                                   *Iter:take()*
    Transforms an iterator to yield only the first n values, or all values
    satisfying a predicate.

    Example: >lua
        local it = vim.iter({ 1, 2, 3, 4 }):take(2)
        it:next()
        -- 1
        it:next()
        -- 2
        it:next()
        -- nil

        local function pred(x) return x < 2 end
        local it2 = vim.iter({ 1, 2, 3, 4 }):take(pred)
        it2:next()
        -- 1
        it2:next()
        -- nil
<

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {n}  (`integer|fun(...):boolean`) Number of values to take or a
             predicate.

    Return: ~
        (`Iter`)

Iter:totable()                                                *Iter:totable()*
    Collect the iterator into a table.

    The resulting table depends on the initial source in the iterator
    pipeline. Array-like tables and function iterators will be collected into
    an array-like table. If multiple values are returned from the final stage
    in the iterator pipeline, each value will be included in a table.

    Examples: >lua
        vim.iter(string.gmatch('100 20 50', '%d+')):map(tonumber):totable()
        -- { 100, 20, 50 }

        vim.iter({ 1, 2, 3 }):map(function(v) return v, 2 * v end):totable()
        -- { { 1, 2 }, { 2, 4 }, { 3, 6 } }

        vim.iter({ a = 1, b = 2, c = 3 }):filter(function(k, v) return v % 2 ~= 0 end):totable()
        -- { { 'a', 1 }, { 'c', 3 } }
<

    The generated table is an array-like table with consecutive, numeric
    indices. To create a map-like table with arbitrary keys, use
    |Iter:fold()|.

    Attributes: ~
        Since: 0.10.0

    Return: ~
        (`table`)

Iter:unique({key})                                             *Iter:unique()*
    Removes duplicate values from an iterator pipeline.

    Only the first occurrence of each value is kept.

    Accepts an optional `key` argument, which if provided is called for each
    value in the iterator to compute a hash key for uniqueness comparison.
    This is useful for deduplicating table values or complex objects. If `key`
    returns `nil` for a value, that value will be considered unique, even if
    multiple values return `nil`.

    If a function-based iterator returns multiple arguments, uniqueness is
    checked based on the first return value. To change this behavior, specify
    `key`.

    Examples: >lua
        vim.iter({ 1, 2, 2, 3, 2 }):unique():totable()
        -- { 1, 2, 3 }

        vim.iter({ {id=1}, {id=2}, {id=1} })
          :unique(function(x)
            return x.id
          end)
          :totable()
        -- { {id=1}, {id=2} }
<

    Attributes: ~
        Since: 0.12.0

    Parameters: ~
      • {key}  (`fun(...):any?`) Optional hash function to determine
               uniqueness of values.

    Return: ~
        (`Iter`)

    See also: ~
      • |vim.list.unique()|


==============================================================================
Lua module: vim.json                                                *vim.json*

This module provides encoding and decoding of Lua objects to and from
JSON-encoded strings. Supports |vim.NIL| and |vim.empty_dict()|.


vim.json.decode({str}, {opts})                             *vim.json.decode()*
    Decodes (or "unpacks") stringified JSON to a Lua object.
    • Decodes JSON "null" as |vim.NIL| (controllable by {opts}, see below).
    • Decodes empty object as |vim.empty_dict()|.
    • Decodes empty array as `{}` (empty Lua table).

    Example: >lua
        vim.print(vim.json.decode('{"bar":[],"foo":{},"zub":null}'))
        -- { bar = {}, foo = vim.empty_dict(), zub = vim.NIL }
<

    Parameters: ~
      • {str}   (`string`) Stringified JSON data.
      • {opts}  (`table?`) A table with the following fields:
                • {luanil}? (`{ object?: boolean, array?: boolean }`, default:
                  `nil`) Convert `null` in JSON objects and/or arrays to Lua
                  `nil` instead of |vim.NIL|.
                • {skip_comments}? (`boolean`, default: `false`) Allows
                  JavaScript-style comments within JSON data. Comments are
                  treated as whitespace and may appear anywhere whitespace is
                  valid in JSON. Supports single-line comments beginning with
                  '//' and block comments enclosed with '/' and '/'.

    Return: ~
        (`any`)

vim.json.encode({obj}, {opts})                             *vim.json.encode()*
    Encodes (or "packs") a Lua object to stringified JSON.

    Example: Implement a basic 'formatexpr' for JSON, so |gq| with a motion
    formats JSON in a buffer. (The motion must operate on a valid JSON
    object.) >lua
        function _G.fmt_json()
          local indent = vim.bo.expandtab and (' '):rep(vim.o.shiftwidth) or '\t'
          local lines = vim.api.nvim_buf_get_lines(0, vim.v.lnum - 1, vim.v.lnum + vim.v.count - 1, true)
          local o = vim.json.decode(table.concat(lines, '\n'))
          local stringified = vim.json.encode(o, { indent = indent, sort_keys = true })
          lines = vim.split(stringified, '\n')
          vim.api.nvim_buf_set_lines(0, vim.v.lnum - 1, vim.v.count, true, lines)
        end
        vim.o.formatexpr = 'v:lua.fmt_json()'
<

    Parameters: ~
      • {obj}   (`any`)
      • {opts}  (`table?`) A table with the following fields:
                • {escape_slash}? (`boolean`, default: `false`) Escape slash
                  characters "/" in string values.
                • {indent}? (`string`, default: `""`) If non-empty, each value
                  in a JSON object or array starts on a new line and is
                  prefixed with `indent` per nesting level. Adds a space after
                  colons. Does not add a final newline.
                • {sort_keys}? (`boolean`, default: `false`) Sort object keys
                  in alphabetical order.

    Return: ~
        (`string`)


==============================================================================
Lua module: vim.keymap                                            *vim.keymap*

vim.keymap.del({modes}, {lhs}, {opts})                      *vim.keymap.del()*
    Remove an existing mapping. Examples: >lua
        vim.keymap.del('n', 'lhs')

        vim.keymap.del({'n', 'i', 'v'}, '<leader>w', { buf = 5 })
<

    Parameters: ~
      • {modes}  (`string|string[]`)
      • {lhs}    (`string`)
      • {opts}   (`table?`) A table with the following fields:
                 • {buf}? (`integer`) Remove a mapping from the given buffer.
                   `0` for current.

    See also: ~
      • |vim.keymap.set()|

vim.keymap.set({modes}, {lhs}, {rhs}, {opts})               *vim.keymap.set()*
    Defines a |mapping| of |keycodes| to a function or keycodes.

    Examples: >lua
        -- Map "x" to a Lua function:
        vim.keymap.set('n', 'x', function() print('real lua function') end)
        -- Map "<leader>x" to multiple modes for the current buffer:
        vim.keymap.set({'n', 'v'}, '<leader>x', vim.lsp.buf.references, { buf = 0 })
        -- Map <Tab> to an expression (|:map-<expr>|):
        vim.keymap.set('i', '<Tab>', function()
          return vim.fn.pumvisible() == 1 and '<C-n>' or '<Tab>'
        end, { expr = true })
        -- Map "[%%" to a <Plug> mapping:
        vim.keymap.set('n', '[%%', '<Plug>(MatchitNormalMultiBackward)')

        -- Use `getregionpos(getpos('v'))` to get the "current visual selection":
        vim.keymap.set('x', 'M', function()
          local region = vim.fn.getregionpos(vim.fn.getpos('v'), vim.fn.getpos('.'), {
            type = 'v',
            exclusive = false,
            eol = false,
          })
          local line1 = region[1][1][2]
          local line2 = region[#region][1][2]
          vim.print({ line1, line2 })
        end)
<

    Parameters: ~
      • {modes}  (`string|string[]`) Mode "short-name" (see
                 |nvim_set_keymap()|), or a list thereof.
      • {lhs}    (`string`) Left-hand side |{lhs}| of the mapping.
      • {rhs}    (`string|function`) Right-hand side |{rhs}| of the mapping,
                 can be a Lua function.
      • {opts}   (`table?`) Table of |:map-arguments|. Same as
                 |nvim_set_keymap()| {opts}, except:
                 • {replace_keycodes} defaults to `true` if "expr" is `true`.
                 • {noremap} is not supported; use {remap} instead (see
                   below).

                 Also accepts:
                 • {buf}? (`integer`) Creates buffer-local mapping, `0` for
                   current buffer.
                 • {remap}? (`boolean`, default: `false`) Make the mapping
                   recursive. Inverse of {noremap}.

    See also: ~
      • |nvim_set_keymap()|
      • |maparg()|
      • |mapcheck()|
      • |mapset()|


==============================================================================
Lua module: vim.loader                                            *vim.loader*

vim.loader.enable({enable})                              *vim.loader.enable()*
    WARNING: This feature is experimental/unstable.

    Enables or disables the experimental Lua module loader:

    Enable (`enable=true`):
    • overrides |loadfile()|
    • adds the Lua loader using the byte-compilation cache
    • adds the libs loader
    • removes the default Nvim loader

    Disable (`enable=false`):
    • removes the loaders
    • adds the default Nvim loader

    Parameters: ~
      • {enable}  (`boolean?`) true/nil to enable, false to disable

vim.loader.find({modname}, {opts})                         *vim.loader.find()*
    WARNING: This feature is experimental/unstable.

    Finds Lua modules for the given module name.

    Parameters: ~
      • {modname}  (`string`) Module name, or `"*"` to find the top-level
                   modules instead
      • {opts}     (`table?`) Options for finding a module:
                   • {all}? (`boolean`, default: `false`) Search for all
                     matches.
                   • {paths}? (`string[]`, default: `{}`) Extra paths to
                     search for modname
                   • {patterns}? (`string[]`, default:
                     `{"/init.lua", ".lua"}`) List of patterns to use when
                     searching for modules. A pattern is a string added to the
                     basename of the Lua module being searched.
                   • {rtp}? (`boolean`, default: `true`) Search for modname in
                     the runtime path.

    Return: ~
        (`table[]`) A list of objects with the following fields:
        • {modname} (`string`) Name of the module
        • {modpath} (`string`) Path of the module
        • {stat}? (`uv.fs_stat.result`) The fs_stat of the module path. Won't
          be returned for `modname="*"`

vim.loader.reset({path})                                  *vim.loader.reset()*
    WARNING: This feature is experimental/unstable.

    Resets the cache for the path, or all the paths if path is nil.

    Parameters: ~
      • {path}  (`string?`) path to reset


==============================================================================
Lua module: vim.lpeg                                                *vim.lpeg*


LPeg is a pattern-matching library for Lua, based on Parsing Expression
Grammars (PEGs). https://bford.info/packrat/

                                                   *lua-lpeg* *vim.lpeg.Pattern*
The LPeg library for parsing expression grammars is included as `vim.lpeg`
(https://www.inf.puc-rio.br/~roberto/lpeg/).

In addition, its regex-like interface is available as |vim.re|
(https://www.inf.puc-rio.br/~roberto/lpeg/re.html).



Pattern:match({subject}, {init}, {...})                      *Pattern:match()*
    Matches the given `pattern` against the `subject` string. If the match
    succeeds, returns the index in the subject of the first character after
    the match, or the captured values (if the pattern captured any value). An
    optional numeric argument `init` makes the match start at that position in
    the subject string. As usual in Lua libraries, a negative value counts
    from the end. Unlike typical pattern-matching functions, `match` works
    only in anchored mode; that is, it tries to match the pattern with a
    prefix of the given subject string (at position `init`), not with an
    arbitrary substring of the subject. So, if we want to find a pattern
    anywhere in a string, we must either write a loop in Lua or write a
    pattern that matches anywhere.

    Example: >lua
        local pattern = lpeg.R('az') ^ 1 * -1
        assert(pattern:match('hello') == 6)
        assert(lpeg.match(pattern, 'hello') == 6)
        assert(pattern:match('1 hello') == nil)
<

    Parameters: ~
      • {subject}  (`string`)
      • {init}     (`integer?`)
      • {...}      (`any`)

    Return: ~
        (`any`) ...

vim.lpeg.B({pattern})                                           *vim.lpeg.B()*
    Returns a pattern that matches only if the input string at the current
    position is preceded by `patt`. Pattern `patt` must match only strings
    with some fixed length, and it cannot contain captures. Like the `and`
    predicate, this pattern never consumes any input, independently of success
    or failure.

    Parameters: ~
      • {pattern}  (`vim.lpeg.Pattern|string|integer|boolean|table`)

    Return: ~
        (`vim.lpeg.Pattern`)

vim.lpeg.C({patt})                                              *vim.lpeg.C()*
    Creates a simple capture, which captures the substring of the subject that
    matches `patt`. The captured value is a string. If `patt` has other
    captures, their values are returned after this one.

    Example: >lua
        local function split (s, sep)
          sep = lpeg.P(sep)
          local elem = lpeg.C((1 - sep) ^ 0)
          local p = elem * (sep * elem) ^ 0
          return lpeg.match(p, s)
        end
        local a, b, c = split('a,b,c', ',')
        assert(a == 'a')
        assert(b == 'b')
        assert(c == 'c')
<

    Parameters: ~
      • {patt}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.Carg({n})                                           *vim.lpeg.Carg()*
    Creates an argument capture. This pattern matches the empty string and
    produces the value given as the nth extra argument given in the call to
    `lpeg.match`.

    Parameters: ~
      • {n}  (`integer`)

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.Cb({name})                                            *vim.lpeg.Cb()*
    Creates a back capture. This pattern matches the empty string and produces
    the values produced by the most recent group capture named `name` (where
    `name` can be any Lua value). Most recent means the last complete
    outermost group capture with the given name. A Complete capture means that
    the entire pattern corresponding to the capture has matched. An Outermost
    capture means that the capture is not inside another complete capture. In
    the same way that LPeg does not specify when it evaluates captures, it
    does not specify whether it reuses values previously produced by the group
    or re-evaluates them.

    Parameters: ~
      • {name}  (`any`)

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.Cc({...})                                             *vim.lpeg.Cc()*
    Creates a constant capture. This pattern matches the empty string and
    produces all given values as its captured values.

    Parameters: ~
      • {...}  (`any`)

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.Cf({patt}, {func})                                    *vim.lpeg.Cf()*
    Creates a fold capture. If `patt` produces a list of captures C1 C2 ...
    Cn, this capture will produce the value
    `func(...func(func(C1, C2), C3)...,Cn)`, that is, it will fold (or
    accumulate, or reduce) the captures from `patt` using function `func`.
    This capture assumes that `patt` should produce at least one capture with
    at least one value (of any type), which becomes the initial value of an
    accumulator. (If you need a specific initial value, you may prefix a
    constant capture to `patt`.) For each subsequent capture, LPeg calls
    `func` with this accumulator as the first argument and all values produced
    by the capture as extra arguments; the first result from this call becomes
    the new value for the accumulator. The final value of the accumulator
    becomes the captured value.

    Example: >lua
        local number = lpeg.R('09') ^ 1 / tonumber
        local list = number * (',' * number) ^ 0
        local function add(acc, newvalue) return acc + newvalue end
        local sum = lpeg.Cf(list, add)
        assert(sum:match('10,30,43') == 83)
<

    Parameters: ~
      • {patt}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)
      • {func}  (`fun(acc, newvalue)`)

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.Cg({patt}, {name})                                    *vim.lpeg.Cg()*
    Creates a group capture. It groups all values returned by `patt` into a
    single capture. The group may be anonymous (if no name is given) or named
    with the given name (which can be any non-nil Lua value).

    Parameters: ~
      • {patt}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)
      • {name}  (`string?`)

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.Cmt({patt}, {fn})                                    *vim.lpeg.Cmt()*
    Creates a match-time capture. Unlike all other captures, this one is
    evaluated immediately when a match occurs (even if it is part of a larger
    pattern that fails later). It forces the immediate evaluation of all its
    nested captures and then calls `function`. The given function gets as
    arguments the entire subject, the current position (after the match of
    `patt`), plus any capture values produced by `patt`. The first value
    returned by `function` defines how the match happens. If the call returns
    a number, the match succeeds and the returned number becomes the new
    current position. (Assuming a subject sand current position `i`, the
    returned number must be in the range `[i, len(s) + 1]`.) If the call
    returns `true`, the match succeeds without consuming any input (so, to
    return true is equivalent to return `i`). If the call returns `false`,
    `nil`, or no value, the match fails. Any extra values returned by the
    function become the values produced by the capture.

    Parameters: ~
      • {patt}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)
      • {fn}    (`fun(s: string, i: integer, ...: any)`) (position:
                boolean|integer, ...: any)

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.Cp()                                                  *vim.lpeg.Cp()*
    Creates a position capture. It matches the empty string and captures the
    position in the subject where the match occurs. The captured value is a
    number.

    Example: >lua
        local I = lpeg.Cp()
        local function anywhere(p) return lpeg.P({I * p * I + 1 * lpeg.V(1)}) end
        local match_start, match_end = anywhere('world'):match('hello world!')
        assert(match_start == 7)
        assert(match_end == 12)
<

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.Cs({patt})                                            *vim.lpeg.Cs()*
    Creates a substitution capture. This function creates a substitution
    capture, which captures the substring of the subject that matches `patt`,
    with substitutions. For any capture inside `patt` with a value, the
    substring that matched the capture is replaced by the capture value (which
    should be a string). The final captured value is the string resulting from
    all replacements.

    Example: >lua
        local function gsub (s, patt, repl)
          patt = lpeg.P(patt)
          patt = lpeg.Cs((patt / repl + 1) ^ 0)
          return lpeg.match(patt, s)
        end
        assert(gsub('Hello, xxx!', 'xxx', 'World') == 'Hello, World!')
<

    Parameters: ~
      • {patt}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.Ct({patt})                                            *vim.lpeg.Ct()*
    Creates a table capture. This capture returns a table with all values from
    all anonymous captures made by `patt` inside this table in successive
    integer keys, starting at 1. Moreover, for each named capture group
    created by `patt`, the first value of the group is put into the table with
    the group name as its key. The captured value is only the table.

    Parameters: ~
      • {patt}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)

    Return: ~
        (`vim.lpeg.Capture`)

vim.lpeg.locale({tab})                                     *vim.lpeg.locale()*
    Returns a table with patterns for matching some character classes
    according to the current locale. The table has fields named `alnum`,
    `alpha`, `cntrl`, `digit`, `graph`, `lower`, `print`, `punct`, `space`,
    `upper`, and `xdigit`, each one containing a correspondent pattern. Each
    pattern matches any single character that belongs to its class. If called
    with an argument `table`, then it creates those fields inside the given
    table and returns that table.

    Example: >lua
        lpeg.locale(lpeg)
        local space = lpeg.space ^ 0
        local name = lpeg.C(lpeg.alpha ^ 1) * space
        local sep = lpeg.S(',;') * space
        local pair = lpeg.Cg(name * '=' * space * name) * sep ^ -1
        local list = lpeg.Cf(lpeg.Ct('') * pair ^ 0, rawset)
        local t = list:match('a=b, c = hi; next = pi')
        assert(t.a == 'b')
        assert(t.c == 'hi')
        assert(t.next == 'pi')
        local locale = lpeg.locale()
        assert(type(locale.digit) == 'userdata')
<

    Parameters: ~
      • {tab}  (`table?`)

    Return: ~
        (`vim.lpeg.Locale`)

vim.lpeg.match({pattern}, {subject}, {init}, {...})         *vim.lpeg.match()*
    Matches the given `pattern` against the `subject` string. If the match
    succeeds, returns the index in the subject of the first character after
    the match, or the captured values (if the pattern captured any value). An
    optional numeric argument `init` makes the match start at that position in
    the subject string. As usual in Lua libraries, a negative value counts
    from the end. Unlike typical pattern-matching functions, `match` works
    only in anchored mode; that is, it tries to match the pattern with a
    prefix of the given subject string (at position `init`), not with an
    arbitrary substring of the subject. So, if we want to find a pattern
    anywhere in a string, we must either write a loop in Lua or write a
    pattern that matches anywhere.

    Example: >lua
        local pattern = lpeg.R('az') ^ 1 * -1
        assert(pattern:match('hello') == 6)
        assert(lpeg.match(pattern, 'hello') == 6)
        assert(pattern:match('1 hello') == nil)
<

    Parameters: ~
      • {pattern}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)
      • {subject}  (`string`)
      • {init}     (`integer?`)
      • {...}      (`any`)

    Return: ~
        (`any`) ...

vim.lpeg.P({value})                                             *vim.lpeg.P()*
    Converts the given value into a proper pattern. The following rules are
    applied:
    • If the argument is a pattern, it is returned unmodified.
    • If the argument is a string, it is translated to a pattern that matches
      the string literally.
    • If the argument is a non-negative number `n`, the result is a pattern
      that matches exactly `n` characters.
    • If the argument is a negative number `-n`, the result is a pattern that
      succeeds only if the input string has less than `n` characters left:
      `lpeg.P(-n)` is equivalent to `-lpeg.P(n)` (see the unary minus
      operation).
    • If the argument is a boolean, the result is a pattern that always
      succeeds or always fails (according to the boolean value), without
      consuming any input.
    • If the argument is a table, it is interpreted as a grammar (see
      Grammars).
    • If the argument is a function, returns a pattern equivalent to a
      match-time capture over the empty string.

    Parameters: ~
      • {value}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)

    Return: ~
        (`vim.lpeg.Pattern`)

vim.lpeg.R({...})                                               *vim.lpeg.R()*
    Returns a pattern that matches any single character belonging to one of
    the given ranges. Each `range` is a string `xy` of length 2, representing
    all characters with code between the codes of `x` and `y` (both
    inclusive). As an example, the pattern `lpeg.R('09')` matches any digit,
    and `lpeg.R('az', 'AZ')` matches any ASCII letter.

    Example: >lua
        local pattern = lpeg.R('az') ^ 1 * -1
        assert(pattern:match('hello') == 6)
<

    Parameters: ~
      • {...}  (`string`)

    Return: ~
        (`vim.lpeg.Pattern`)

vim.lpeg.S({string})                                            *vim.lpeg.S()*
    Returns a pattern that matches any single character that appears in the
    given string (the `S` stands for Set). As an example, the pattern
    `lpeg.S('+-*/')` matches any arithmetic operator. Note that, if `s` is a
    character (that is, a string of length 1), then `lpeg.P(s)` is equivalent
    to `lpeg.S(s)` which is equivalent to `lpeg.R(s..s)`. Note also that both
    `lpeg.S('')` and `lpeg.R()` are patterns that always fail.

    Parameters: ~
      • {string}  (`string`)

    Return: ~
        (`vim.lpeg.Pattern`)

vim.lpeg.setmaxstack({max})                           *vim.lpeg.setmaxstack()*
    Sets a limit for the size of the backtrack stack used by LPeg to track
    calls and choices. The default limit is `400`. Most well-written patterns
    need little backtrack levels and therefore you seldom need to change this
    limit; before changing it you should try to rewrite your pattern to avoid
    the need for extra space. Nevertheless, a few useful patterns may
    overflow. Also, with recursive grammars, subjects with deep recursion may
    also need larger limits.

    Parameters: ~
      • {max}  (`integer`)

vim.lpeg.type({value})                                       *vim.lpeg.type()*
    Returns the string `"pattern"` if the given value is a pattern, otherwise
    `nil`.

    Parameters: ~
      • {value}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)

    Return: ~
        (`"pattern"?`)

vim.lpeg.V({v})                                                 *vim.lpeg.V()*
    Creates a non-terminal (a variable) for a grammar. This operation creates
    a non-terminal (a variable) for a grammar. The created non-terminal refers
    to the rule indexed by `v` in the enclosing grammar.

    Example: >lua
        local b = lpeg.P({'(' * ((1 - lpeg.S '()') + lpeg.V(1)) ^ 0 * ')'})
        assert(b:match('((string))') == 11)
        assert(b:match('(') == nil)
<

    Parameters: ~
      • {v}  (`boolean|string|number|function|table|thread|userdata|lightuserdata`)

    Return: ~
        (`vim.lpeg.Pattern`)

vim.lpeg.version()                                        *vim.lpeg.version()*
    Returns a string with the running version of LPeg.

    Return: ~
        (`string`)


==============================================================================
Lua module: vim.mpack                                              *vim.mpack*

This module provides encoding and decoding of Lua objects to and from
msgpack-encoded strings. Supports |vim.NIL| and |vim.empty_dict()|.


vim.mpack.decode({str})                                   *vim.mpack.decode()*
    Decodes (or "unpacks") the msgpack-encoded {str} to a Lua object.

    Parameters: ~
      • {str}  (`string`)

    Return: ~
        (`any`)

vim.mpack.encode({obj})                                   *vim.mpack.encode()*
    Encodes (or "packs") Lua object {obj} as msgpack in a Lua string.

    Parameters: ~
      • {obj}  (`any`)

    Return: ~
        (`string`)


==============================================================================
Lua module: vim.net                                                  *vim.net*

*vim.net.request.Response*

    Fields: ~
      • {body}  (`string`) The HTTP body of the request


vim.net.request({url}, {opts}, {on_response})              *vim.net.request()*
    Makes an HTTP GET request to the given URL, asynchronously passing the
    result to the specified `on_response`, `outpath` or `outbuf`.

    Examples: >lua
        -- Write response body to file
        vim.net.request('https://neovim.io/charter/', {
          outpath = 'vision.html',
        })

        -- Process the response
        vim.net.request(
          'https://api.github.com/repos/neovim/neovim',
          {},
          function (err, res)
            if err then return end
            local stars = vim.json.decode(res.body).stargazers_count
            vim.print(('Neovim currently has %d stars'):format(stars))
          end
        )

        -- Write to both file and current buffer, but cancel it
        local job = vim.net.request('https://neovim.io/charter/', {
          outpath = 'vision.html',
          outbuf = 0,
        })
        job:close()
<

    Parameters: ~
      • {url}          (`string`) The URL for the request.
      • {opts}         (`table?`) A table with the following fields:
                       • {outbuf}? (`integer`) Buffer to save the response
                         body to.
                       • {outpath}? (`string`) File path to save the response
                         body to.
                       • {retry}? (`integer`) Number of retries on transient
                         failures (default: 3).
                       • {verbose}? (`boolean`) Enables verbose output.
      • {on_response}  (`fun(err: string?, response: vim.net.request.Response?)?`)
                       Callback invoked on request completion. The `body`
                       field in the response parameter contains the raw
                       response data (text or binary).

    Return: ~
        (`{ close: fun() }`) Table with method to cancel, similar to
        |vim.SystemObj|.


==============================================================================
Lua module: vim.pos                                                  *vim.pos*

EXPERIMENTAL: This API is unstable, do not use it. Its semantics are not yet
finalized. Subscribe to this issue to stay updated:
https://github.com/neovim/neovim/issues/25509

Provides operations to compare, calculate, and convert positions represented
by |vim.Pos| objects.


*vim.Pos*
    Represents a well-defined position.

    A |vim.Pos| object contains the {row} and {col} coordinates of a position.
    To create a new |vim.Pos| object, call `vim.pos()`.

    Example: >lua
        local pos1 = vim.pos(0, 3, 5)
        local pos2 = vim.pos(0, 4, 0)

        -- Operators are overloaded for comparing two `vim.Pos` objects.
        if pos1 < pos2 then
          print("pos1 comes before pos2")
        end

        if pos1 ~= pos2 then
          print("pos1 and pos2 are different positions")
        end
<

    It may include optional fields that enable additional capabilities, such
    as format conversions.

    Fields: ~
      • {buf}  (`integer`) buffer handle.
      • {col}  (`integer`) 0-based byte index.
      • {row}  (`integer`) 0-based byte index.


cursor({buf}, {pos})                                        *vim.pos.cursor()*
    Creates a new |vim.Pos| from cursor position (see |api-indexing|).

    Parameters: ~
      • {buf}  (`integer`)
      • {pos}  (`[integer, integer]`)

extmark({buf}, {row}, {col})                               *vim.pos.extmark()*
    Creates a new |vim.Pos| from extmark position (see |api-indexing|).

    Parameters: ~
      • {buf}  (`integer`)
      • {row}  (`integer`)
      • {col}  (`integer`)

lsp({buf}, {pos}, {position_encoding})                         *vim.pos.lsp()*
    Creates a new |vim.Pos| from `lsp.Position`.

    Example: >lua
        local lsp_pos = {
          line = 3,
          character = 5
        }

        local pos = vim.pos.lsp(0, lsp_pos, 'utf-16')
<

    Parameters: ~
      • {buf}                (`integer`)
      • {pos}                (`lsp.Position`)
      • {position_encoding}  (`lsp.PositionEncodingKind`)

offset({buf}, {offset})                                     *vim.pos.offset()*
    Creates a new |vim.Pos| from buffer offset.

    Parameters: ~
      • {buf}     (`integer`)
      • {offset}  (`integer`)

    Return: ~
        (`vim.Pos`) See |vim.Pos|.

to_cursor({pos})                                         *vim.pos.to_cursor()*
    Converts |vim.Pos| to cursor position (see |api-indexing|).

    Parameters: ~
      • {pos}  (`vim.Pos`) See |vim.Pos|.

    Return (multiple): ~
        (`integer`)
        (`integer`)

to_extmark({pos})                                       *vim.pos.to_extmark()*
    Converts |vim.Pos| to extmark position (see |api-indexing|).

    Parameters: ~
      • {pos}  (`vim.Pos`) See |vim.Pos|.

    Return (multiple): ~
        (`integer`)
        (`integer`)

to_lsp({pos}, {position_encoding})                          *vim.pos.to_lsp()*
    Converts |vim.Pos| to `lsp.Position`.

    Example: >lua
        local pos = vim.pos(0, 3, 5)

        -- Convert to LSP position, you can call it in a method style.
        local lsp_pos = pos:to_lsp('utf-16')
<

    Parameters: ~
      • {pos}                (`vim.Pos`) See |vim.Pos|.
      • {position_encoding}  (`lsp.PositionEncodingKind`)

to_offset({pos})                                         *vim.pos.to_offset()*
    Converts |vim.Pos| to buffer offset.

    Parameters: ~
      • {pos}  (`vim.Pos`) See |vim.Pos|.

    Return: ~
        (`integer`)


==============================================================================
Lua module: vim.range                                              *vim.range*

EXPERIMENTAL: This API is unstable, do not use it. Its semantics are not yet
finalized. Subscribe to this issue to stay updated:
https://github.com/neovim/neovim/issues/25509

Provides operations to compare, calculate, and convert ranges represented by
|vim.Range| objects.


*vim.Range*
    Represents a range. Call `vim.range()` to create a new range.

    A range contains a start and end position (see |vim.Pos|). The end
    position is exclusive. Positions must have the same optional fields.

    May include optional fields that enable additional capabilities, such as
    format conversions.

    Example: >lua
        local pos1 = vim.pos(0, 3, 5)
        local pos2 = vim.pos(0, 4, 0)

        -- Create a range from two positions.
        local range1 = vim.range(pos1, pos2)
        -- Or create a range from four integers representing start and end positions.
        local range2 = vim.range(0, 3, 5, 4, 0)

        -- Because `vim.Range` is end exclusive, `range1` and `range2` both represent
        -- a range starting at the row 3, column 5 and ending at where the row 3 ends
        -- (including the newline at the end of line 3).

        -- Operators are overloaded for comparing two `vim.Pos` objects.
        if range1 == range2 then
          print("range1 and range2 are the same range")
        end
<

    Fields: ~
      • {buf}        (`integer`) Optional buffer handle.
      • {end_col}    (`integer`) 0-based byte index.
      • {end_row}    (`integer`) 0-based byte index.
      • {start_col}  (`integer`) 0-based byte index.
      • {start_row}  (`integer`) 0-based byte index.


cursor({buf}, {start_pos}, {end_pos})                     *vim.range.cursor()*
    Creates a new |vim.Range| from mark-like range (see |api-indexing|).

    Example: >lua
        local start = vim.api.nvim_win_get_cursor(0)
        -- move the cursor
        local end_ = vim.api.nvim_win_get_cursor(0)

        local range = vim.range.cursor(0, start, end_)
<

    Parameters: ~
      • {buf}        (`integer`)
      • {start_pos}  (`[integer, integer]`)
      • {end_pos}    (`[integer, integer]`)

                                                         *vim.range.extmark()*
extmark({buf}, {start_row}, {start_col}, {end_row}, {end_col})
    Creates a new |vim.Range| from extmark range (see |api-indexing|).

    Example: >lua
        local range = vim.range.extmark(0, 3, 5, 4, 0)
<

    Parameters: ~
      • {buf}        (`integer`)
      • {start_row}  (`integer`)
      • {start_col}  (`integer`)
      • {end_row}    (`integer`)
      • {end_col}    (`integer`)

has({outer}, {inner})                                        *vim.range.has()*
    Checks whether {outer} range contains {inner} range or position.

    Parameters: ~
      • {outer}  (`vim.Range`) See |vim.Range|.
      • {inner}  (`vim.Range|vim.Pos`)

    Return: ~
        (`boolean`) `true` if {outer} range fully contains {inner} range or
        position.

intersect({r1}, {r2})                                  *vim.range.intersect()*
    Computes the common range shared by the given ranges.

    Parameters: ~
      • {r1}  (`vim.Range`) First range to intersect. See |vim.Range|.
      • {r2}  (`vim.Range`) Second range to intersect. See |vim.Range|.

    Return: ~
        (`vim.Range?`) range that is present inside both `r1` and `r2`. `nil`
        if such range does not exist. See |vim.Range|.

is_empty({range})                                       *vim.range.is_empty()*
    Checks whether the given range is empty; i.e., start >= end.

    Parameters: ~
      • {range}  (`vim.Range`) See |vim.Range|.

    Return: ~
        (`boolean`) `true` if the given range is empty.

lsp({buf}, {range}, {position_encoding})                     *vim.range.lsp()*
    Creates a new |vim.Range| from `lsp.Range`.

    Example: >lua
        local lsp_range = {
          ['start'] = { line = 3, character = 5 },
          ['end'] = { line = 4, character = 0 }
        }

        local range = vim.range.lsp(0, lsp_range, 'utf-16')
<

    Parameters: ~
      • {buf}                (`integer`)
      • {range}              (`lsp.Range`)
      • {position_encoding}  (`lsp.PositionEncodingKind`)

to_cursor({range})                                     *vim.range.to_cursor()*
    Converts |vim.Range| to mark-like range (see |api-indexing|).

    Example: >lua
        local range = vim.range(0, 3, 5, 4, 0)

        -- Convert to cursor range, you can call it in a method style.
        local cursor_range = range:to_cursor()
<

    Parameters: ~
      • {range}  (`vim.Range`) See |vim.Range|.

to_extmark({range})                                   *vim.range.to_extmark()*
    Converts |vim.Range| to extmark range (see |api-indexing|).

    Example: >lua
        local range = vim.range(0, 3, 5, 4, 0)

        -- Convert to extmark range, you can call it in a method style.
        local extmark_range = range:to_extmark()
<

    Parameters: ~
      • {range}  (`vim.Range`) See |vim.Range|.

to_lsp({range}, {position_encoding})                      *vim.range.to_lsp()*
    Converts |vim.Range| to `lsp.Range`.

    Example: >lua
        local range = vim.range(0, 3, 5, 4, 0)

        -- Convert to LSP range, you can call it in a method style.
        local lsp_range = range:to_lsp('utf-16')
<

    Parameters: ~
      • {range}              (`vim.Range`) See |vim.Range|.
      • {position_encoding}  (`lsp.PositionEncodingKind`)

    Return: ~
        (`lsp.Range`)


==============================================================================
Lua module: vim.re                                                    *vim.re*

The `vim.re` module provides a conventional regex-like syntax for pattern
usage within LPeg |vim.lpeg|. (Unrelated to |vim.regex| which provides Vim
|regexp| from Lua.)

See https://www.inf.puc-rio.br/~roberto/lpeg/re.html for the original
documentation including regex syntax and examples.


vim.re.compile({string}, {defs})                            *vim.re.compile()*
    Compiles the given {string} and returns an equivalent LPeg pattern. The
    given string may define either an expression or a grammar. The optional
    {defs} table provides extra Lua values to be used by the pattern.

    Parameters: ~
      • {string}  (`string`)
      • {defs}    (`table?`)

    Return: ~
        (`vim.lpeg.Pattern`)

vim.re.find({subject}, {pattern}, {init})                      *vim.re.find()*
    Searches the given {pattern} in the given {subject}. If it finds a match,
    returns the index where this occurrence starts and the index where it
    ends. Otherwise, returns nil.

    An optional numeric argument {init} makes the search starts at that
    position in the subject string. As usual in Lua libraries, a negative
    value counts from the end.

    Parameters: ~
      • {subject}  (`string`)
      • {pattern}  (`vim.lpeg.Pattern|string`)
      • {init}     (`integer?`)

    Return (multiple): ~
        (`integer?`) the index where the occurrence starts, nil if no match
        (`integer?`) the index where the occurrence ends, nil if no match

vim.re.gsub({subject}, {pattern}, {replacement})               *vim.re.gsub()*
    Does a global substitution, replacing all occurrences of {pattern} in the
    given {subject} by {replacement}.

    Parameters: ~
      • {subject}      (`string`)
      • {pattern}      (`vim.lpeg.Pattern|string`)
      • {replacement}  (`string`)

    Return: ~
        (`string`)

vim.re.match({subject}, {pattern}, {init})                    *vim.re.match()*
    Matches the given {pattern} against the given {subject}, returning all
    captures.

    Parameters: ~
      • {subject}  (`string`)
      • {pattern}  (`vim.lpeg.Pattern|string`)
      • {init}     (`integer?`)

    Return: ~
        (`integer|vim.lpeg.Capture?`)

    See also: ~
      • vim.lpeg.match()

vim.re.updatelocale()                                  *vim.re.updatelocale()*
    Updates the pre-defined character classes to the current locale.


==============================================================================
Lua module: vim.regex                                              *vim.regex*

The `vim.regex` interface allows Lua code to use Vim regexes.
• Matches within a single line.
• Does not check for interrupts (CTRL-C), so can be used from an |api-fast|
  context.


                                                          *regex:match_line()*
regex:match_line({buf}, {line_idx}, {start}, {end_})
    Matches line at `line_idx` (zero-based) in buffer `buf`. Match is
    restricted to byte index range `start` and `end_` if given, otherwise see
    |regex:match_str()|. Returned byte indices are relative to `start` if
    given.

    Parameters: ~
      • {buf}       (`integer`)
      • {line_idx}  (`integer`)
      • {start}     (`integer?`)
      • {end_}      (`integer?`)

    Return (multiple): ~
        (`integer?`) match start (byte index) relative to `start`, or `nil` if
        no match
        (`integer?`) match end (byte index) relative to `start`, or `nil` if
        no match

regex:match_str({str})                                     *regex:match_str()*
    Matches string `str` against this regex. To match the string precisely,
    surround the regex with "^" and "$". Returns the byte indices for the
    start and end of the match, or `nil` if there is no match. Because any
    integer is "truthy", `regex:match_str()` can be directly used as a
    condition in an if-statement.

    Parameters: ~
      • {str}  (`string`)

    Return (multiple): ~
        (`integer?`) match start (byte index), or `nil` if no match
        (`integer?`) match end (byte index), or `nil` if no match

vim.regex({re})                                                  *vim.regex()*
    Parses the Vim regex `re` and returns a regex object. Regexes are "magic"
    and case-sensitive by default, regardless of 'magic' and 'ignorecase'.
    They can be controlled with flags, see |/magic| and |/ignorecase|.

    Parameters: ~
      • {re}  (`string`)

    Return: ~
        (`vim.regex`)


==============================================================================
Lua module: vim.secure                                            *vim.secure*

vim.secure.read({path})                                    *vim.secure.read()*
    If {path} is a file: attempt to read the file, prompting the user if the
    file should be trusted.

    If {path} is a directory: return true if the directory is trusted
    (non-recursive), prompting the user as necessary.

    The user's choice is persisted in a trust database at
    $XDG_STATE_HOME/nvim/trust.

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {path}  (`string`) Path to a file or directory to read.

    Return: ~
        (`boolean|string?`) If {path} is not trusted or does not exist,
        returns `nil`. Otherwise, returns the contents of {path} if it is a
        file, or true if {path} is a directory.

    See also: ~
      • |:trust|

vim.secure.trust({opts})                                  *vim.secure.trust()*
    Manage the trust database.

    The trust database is located at |$XDG_STATE_HOME|/nvim/trust.

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {opts}  (`table`) A table with the following fields:
                • {action} (`'allow'|'deny'|'remove'`) One of:
                  • `'allow'` to add a file to the trust database and trust
                    it,
                  • `'deny'` to add a file to the trust database and deny it,
                  • `'remove'` to remove file from the trust database
                • {bufnr}? (`integer`) Buffer number to update. Mutually
                  exclusive with {path}.
                • {path}? (`string`) Path to a file to update. Mutually
                  exclusive with {bufnr}.

    Return (multiple): ~
        (`boolean`) success true if operation was successful
        (`string`) msg full path if operation was successful, else error
        message


==============================================================================
Lua module: vim.snippet                                          *vim.snippet*

*vim.snippet.ActiveFilter*

    Fields: ~
      • {direction}  (`vim.snippet.Direction`) Navigation direction. -1 for
                     previous, 1 for next.


vim.snippet.active({filter})                            *vim.snippet.active()*
    Returns `true` if there's an active snippet in the current buffer,
    applying the given filter if provided.

    Parameters: ~
      • {filter}  (`vim.snippet.ActiveFilter?`) Filter to constrain the search
                  with:
                  • `direction` (vim.snippet.Direction): Navigation direction.
                    Will return `true` if the snippet can be jumped in the
                    given direction. See |vim.snippet.ActiveFilter|.

    Return: ~
        (`boolean`)

vim.snippet.expand({input})                             *vim.snippet.expand()*
    Expands the given snippet text. Refer to
    https://microsoft.github.io/language-server-protocol/specification/#snippet_syntax
    for the specification of valid input.

    Tabstops are highlighted with |hl-SnippetTabstop| and
    |hl-SnippetTabstopActive|.

    Parameters: ~
      • {input}  (`string`)

vim.snippet.jump({direction})                             *vim.snippet.jump()*
    Jumps to the next (or previous) placeholder in the current snippet, if
    possible.

    By default `<Tab>` is setup to jump if a snippet is active. The default
    mapping looks like: >lua
        vim.keymap.set({ 'i', 's' }, '<Tab>', function()
           if vim.snippet.active({ direction = 1 }) then
             return '<Cmd>lua vim.snippet.jump(1)<CR>'
           else
             return '<Tab>'
           end
         end, { desc = '...', expr = true, silent = true })
<

    Parameters: ~
      • {direction}  (`vim.snippet.Direction`) Navigation direction. -1 for
                     previous, 1 for next.

vim.snippet.stop()                                        *vim.snippet.stop()*
    Exits the current snippet.


==============================================================================
Lua module: vim.spell                                              *vim.spell*

vim.spell.check({str})                                     *vim.spell.check()*
    Check {str} for spelling errors. Similar to the Vimscript function
    |spellbadword()|.

    Note: The behaviour of this function is dependent on: 'spelllang',
    'spellfile', 'spellcapcheck' and 'spelloptions' which can all be local to
    the buffer. Consider calling this with |nvim_buf_call()|.

    Example: >lua
        vim.spell.check("the quik brown fox")
        -- =>
        -- {
        --     {'quik', 'bad', 5}
        -- }
<

    Parameters: ~
      • {str}  (`string`)

    Return: ~
        (`[string, 'bad'|'rare'|'local'|'caps', integer][]`) List of tuples
        with three items:
        • The badly spelled word.
        • The type of the spelling error: "bad" spelling mistake "rare" rare
          word "local" word only valid in another region "caps" word should
          start with Capital
        • The position in {str} where the word begins.


==============================================================================
Lua module: vim.system                                        *lua-vim-system*

*vim.SystemCompleted*

    Fields: ~
      • {code}     (`integer`)
      • {signal}   (`integer`)
      • {stderr}?  (`string`) `nil` if stderr is disabled or has a custom
                   handler.
      • {stdout}?  (`string`) `nil` if stdout is disabled or has a custom
                   handler.

*vim.SystemObj*

    Fields: ~
      • {cmd}         (`string[]`) Command name and args
      • {is_closing}  (`fun(self: vim.SystemObj): boolean`) See
                      |SystemObj:is_closing()|.
      • {kill}        (`fun(self: vim.SystemObj, signal: integer|string)`) See
                      |SystemObj:kill()|.
      • {pid}         (`integer`) Process ID
      • {wait}        (`fun(self: vim.SystemObj, timeout: integer?): vim.SystemCompleted`)
                      See |SystemObj:wait()|.
      • {write}       (`fun(self: vim.SystemObj, data: string[]|string?)`) See
                      |SystemObj:write()|.


SystemObj:is_closing()                                *SystemObj:is_closing()*
    Checks if the process handle is closing or already closed.

    This method returns `true` if the underlying process handle is either
    `nil` or is in the process of closing. It is useful for determining
    whether it is safe to perform operations on the process handle.

    Return: ~
        (`boolean`)

SystemObj:kill({signal})                                    *SystemObj:kill()*
    Sends a signal to the process.

    The signal can be specified as an integer or as a string.

    Example: >lua
        local obj = vim.system({'sleep', '10'})
        obj:kill('sigterm') -- sends SIGTERM to the process
<

    Parameters: ~
      • {signal}  (`integer|string`) Signal to send to the process. See
                  |luv-constants|.

SystemObj:wait({timeout})                                   *SystemObj:wait()*
    Waits for the process to complete or until the specified timeout elapses.

    This method blocks execution until the associated process has exited or
    the optional `timeout` (in milliseconds) has been reached. If the process
    does not exit before the timeout, it is forcefully terminated with SIGKILL
    (signal 9), and the exit code is set to 124.

    If no `timeout` is provided, the method will wait indefinitely (or use the
    timeout specified in the options when the process was started).

    Example: >lua
        local obj = vim.system({'echo', 'hello'}, { text = true })
        local result = obj:wait(1000) -- waits up to 1000ms
        print(result.code, result.signal, result.stdout, result.stderr)
<

    Parameters: ~
      • {timeout}  (`integer?`)

    Return: ~
        (`vim.SystemCompleted`) See |vim.SystemCompleted|.

SystemObj:write({data})                                    *SystemObj:write()*
    Writes data to the stdin of the process or closes stdin.

    If `data` is a list of strings, each string is written followed by a
    newline.

    If `data` is a string, it is written as-is.

    If `data` is `nil`, the write side of the stream is shut down and the pipe
    is closed.

    Example: >lua
        local obj = vim.system({'cat'}, { stdin = true })
        obj:write({'hello', 'world'}) -- writes 'hello\nworld\n' to stdin
        obj:write(nil) -- closes stdin
<

    Parameters: ~
      • {data}  (`string[]|string?`)

vim.system({cmd}, {opts}, {on_exit})                            *vim.system()*
    Runs a system command or throws an error if {cmd} cannot be run.

    The command runs directly (not in 'shell') so shell builtins such as
    "echo" in cmd.exe, cmdlets in powershell, or "help" in bash, will not work
    unless you actually invoke a shell: `vim.system({'bash', '-c', 'help'})`.

    Examples: >lua
        local on_exit = function(obj)
          print(obj.code)
          print(obj.signal)
          print(obj.stdout)
          print(obj.stderr)
        end

        -- Runs asynchronously:
        vim.system({'echo', 'hello'}, { text = true }, on_exit)

        -- Runs synchronously:
        local obj = vim.system({'echo', 'hello'}, { text = true }):wait()
        -- { code = 0, signal = 0, stdout = 'hello\n', stderr = '' }
<

    See |uv.spawn()| for more details. Note: unlike |uv.spawn()|, vim.system
    throws an error if {cmd} cannot be run.

    Parameters: ~
      • {cmd}      (`string[]`) Command to execute
      • {opts}     (`table?`) A table with the following fields:
                   • {clear_env}? (`boolean`) `env` defines the job
                     environment exactly, instead of merging current
                     environment. Note: if `env` is `nil`, the current
                     environment is used but without `NVIM` set.
                   • {cwd}? (`string`) Set the current working directory for
                     the sub-process.
                   • {detach}? (`boolean`) Spawn the child process in a
                     detached state - this will make it a process group
                     leader, and will effectively enable the child to keep
                     running after the parent exits. Note that the child
                     process will still keep the parent's event loop alive
                     unless the parent process calls |uv.unref()| on the
                     child's process handle.
                   • {env}? (`table<string,string|number>`) Set environment
                     variables for the new process. Inherits the current
                     environment with `NVIM` set to |v:servername|.
                   • {stderr}? (`fun(err:string?, data: string?)|boolean`,
                     default: `true`) Handle output from stderr.
                   • {stdin}? (`string|string[]|true`) If `true`, then a pipe
                     to stdin is opened and can be written to via the
                     `write()` method to SystemObj. If `string` or `string[]`
                     then will be written to stdin and closed.
                   • {stdout}? (`fun(err:string?, data: string?)|boolean`,
                     default: `true`) Handle output from stdout.
                   • {text}? (`boolean`) Handle stdout and stderr as text.
                     Normalizes line endings by replacing `\r\n` with `\n`.
                   • {timeout}? (`integer`) Run the command with a time limit
                     in ms. Upon timeout the process is sent the TERM signal
                     (15) and the exit code is set to 124.
      • {on_exit}  (`fun(out: vim.SystemCompleted)?`) Called when subprocess
                   exits. When provided, the command runs asynchronously. See
                   return of SystemObj:wait().

    Overloads: ~
      • `fun(cmd: string[], on_exit: fun(out: vim.SystemCompleted)): vim.SystemObj`

    Return: ~
        (`vim.SystemObj`) See |vim.SystemObj|.


==============================================================================
Lua module: vim.text                                                *vim.text*

vim.text.diff({a}, {b}, {opts})                              *vim.text.diff()*
    Run diff on strings {a} and {b}. Any indices returned by this function,
    either directly or via callback arguments, are 1-based.

    Examples: >lua
        vim.text.diff('a\n', 'b\nc\n')
        -- =>
        -- @@ -1 +1,2 @@
        -- -a
        -- +b
        -- +c

        vim.text.diff('a\n', 'b\nc\n', {result_type = 'indices'})
        -- =>
        -- {
        --   {1, 1, 1, 2}
        -- }
<

    Parameters: ~
      • {a}     (`string`) First string to compare
      • {b}     (`string`) Second string to compare
      • {opts}  (`table?`) Optional parameters:
                • {algorithm}? (`'myers'|'minimal'|'patience'|'histogram'`,
                  default: `'myers'`) Diff algorithm to use. Values:
                  • `myers`: the default algorithm
                  • `minimal`: spend extra time to generate the smallest
                    possible diff
                  • `patience`: patience diff algorithm
                  • `histogram`: histogram diff algorithm
                • {ctxlen}? (`integer`) Context length
                • {ignore_blank_lines}? (`boolean`) Ignore blank lines
                • {ignore_cr_at_eol}? (`boolean`) Ignore carriage return at
                  end-of-line
                • {ignore_whitespace}? (`boolean`) Ignore whitespace
                • {ignore_whitespace_change}? (`boolean`) Ignore whitespace
                  change
                • {ignore_whitespace_change_at_eol}? (`boolean`) Ignore
                  whitespace change at end-of-line.
                • {indent_heuristic}? (`boolean`) Use the indent heuristic for
                  the internal diff library.
                • {interhunkctxlen}? (`integer`) Inter hunk context length
                • {linematch}? (`boolean|integer`) Run linematch on the
                  resulting hunks from xdiff. When integer, only hunks upto
                  this size in lines are run through linematch. Requires
                  `result_type = indices`, ignored otherwise.
                • {on_hunk}?
                  (`fun(start_a: integer, count_a: integer, start_b: integer, count_b: integer): integer?`)
                  Invoked for each hunk in the diff. Return a negative number
                  to cancel the callback for any remaining hunks. Arguments:
                  • `start_a` (`integer`): Start line of hunk in {a}.
                  • `count_a` (`integer`): Hunk size in {a}.
                  • `start_b` (`integer`): Start line of hunk in {b}.
                  • `count_b` (`integer`): Hunk size in {b}.
                • {result_type}? (`'unified'|'indices'`, default: `'unified'`)
                  Form of the returned diff:
                  • `unified`: String in unified format.
                  • `indices`: Array of hunk locations. Note: This option is
                    ignored if `on_hunk` is used.

    Return: ~
        (`string|integer[][]?`) See {opts.result_type}. `nil` if
        {opts.on_hunk} is given.

vim.text.hexdecode({enc})                               *vim.text.hexdecode()*
    Hex decode a string.

    Parameters: ~
      • {enc}  (`string`) String to decode

    Return (multiple): ~
        (`string?`) Decoded string
        (`string?`) Error message, if any

vim.text.hexencode({str})                               *vim.text.hexencode()*
    Hex encode a string.

    Parameters: ~
      • {str}  (`string`) String to encode

    Return: ~
        (`string`) Hex encoded string

vim.text.indent({size}, {text}, {opts})                    *vim.text.indent()*
    Sets the indent (i.e. the common leading whitespace) of non-empty lines in
    `text` to `size` spaces/tabs.

    Indent is calculated by number of consecutive indent chars.
    • The first indented, non-empty line decides the indent char (space/tab):
      • `SPC SPC TAB …` = two-space indent.
      • `TAB SPC …` = one-tab indent.
    • Set `opts.expandtab` to treat tabs as spaces.

    To "dedent" (remove the common indent), pass `size=0`: >lua
        vim.print(vim.text.indent(0, ' a\n  b\n'))
<

    To adjust relative-to an existing indent, call indent() twice: >lua
        local indented, old_indent = vim.text.indent(0, ' a\n b\n')
        indented = vim.text.indent(old_indent + 2, indented)
        vim.print(indented)
<

    To ignore the final, blank line when calculating the indent, use gsub()
    before calling indent(): >lua
        local text = '  a\n  b\n '
        vim.print(vim.text.indent(0, (text:gsub('\n[\t ]+\n?$', '\n'))))
<

    Parameters: ~
      • {size}  (`integer`) Number of spaces.
      • {text}  (`string`) Text to indent.
      • {opts}  (`{ expandtab?: integer }?`)

    Return (multiple): ~
        (`string`) Indented text.
        (`integer`) Indent size before modification.


==============================================================================
Lua module: vim.ui                                                    *vim.ui*

vim.ui.input({opts}, {on_confirm})                            *vim.ui.input()*
    Prompts the user for input, allowing arbitrary (potentially asynchronous)
    work until `on_confirm`.

    Example: >lua
        local opts = { prompt = 'Enter value for shiftwidth: ', scope = 'buffer' }
        vim.ui.input(opts, function(input)
            vim.o.shiftwidth = tonumber(input)
        end)
<

    Parameters: ~
      • {opts}        (`table?`) Additional options. See |input()|
                      • {completion}? (`string`) Specifies type of completion
                        supported for input. Supported types are the same that
                        can be supplied to a user-defined command using the
                        "-complete=" argument. See |:command-completion|
                      • {default}? (`string`) Default reply to the input
                      • {highlight}? (`function`) Function that will be used
                        for highlighting user inputs.
                      • {prompt}? (`string`) Text of the prompt
                      • {scope}?
                        (`'cursor'|'line'|'buffer'|'window'|'tabpage'|'editor'|'project'`)
                        Input scope, as in "This input is for something at
                        cursor/line/etc scope". Can be used by `vim.ui.input`
                        implementations to tweak behavior and presentation.
                        For example, the input may adjust the floating window
                        position: near the cursor if `cursor`, in window
                        corner if `buffer` or `window`, etc.
      • {on_confirm}  (`fun(input?: string)`) Called once the user confirms or
                      abort the input. `input` is what the user typed (it
                      might be an empty string if nothing was entered), or
                      `nil` if the user aborted the dialog.

vim.ui.open({path}, {opt})                                     *vim.ui.open()*
    Opens `path` with the system default handler (macOS `open`, Windows
    `explorer.exe`, Linux `xdg-open`, …), or returns (but does not show) an
    error message on failure.

    Can also be invoked with `:Open`.                                  *:Open*

    Expands "~/" and environment variables in filesystem paths.

    Examples: >lua
        -- Asynchronous.
        vim.ui.open("https://neovim.io/")
        vim.ui.open("~/path/to/file")
        -- Use the "osurl" command to handle the path or URL.
        vim.ui.open("gh#neovim/neovim!29490", { cmd = { 'osurl' } })
        -- Synchronous (wait until the process exits).
        local cmd, err = vim.ui.open("$VIMRUNTIME")
        if cmd then
          cmd:wait()
        end
<

    Parameters: ~
      • {path}  (`string`) Path or URL to open
      • {opt}   (`table?`) Options
                • {cmd}? (`string[]`) Command used to open the path or URL.

    Return (multiple): ~
        (`vim.SystemObj?`) Command object, or nil if not found. See
        |vim.SystemObj|.
        (`string?`) Error message on failure, or nil on success.

    See also: ~
      • |vim.system()|

vim.ui.progress_status()                            *vim.ui.progress_status()*
    Gets a status description summarizing currently running progress messages.
    Convenient for inclusion in 'statusline'.

    Return: ~
        (`string`) Progress status

vim.ui.select({items}, {opts}, {on_choice})                  *vim.ui.select()*
    Prompts the user to pick from a list of items, allowing arbitrary
    (potentially asynchronous) work until `on_choice`.

    Plugins may override `vim.ui.select` to provide a custom "picker"
    interface; they are expected to call the `format_item` and `preview_item`
    handlers (if any) provided by the caller. They may also use the `kind`
    hint (if provided by the caller) to decide how to handle some items.

    Note: the default `vim.ui.select` currently doesn't support preview.

    Example: >lua
        vim.ui.select({ 'tabs', 'spaces' }, {
          prompt = 'Select tabs or spaces:',
          format_item = function(item)
            return ('I choose %s!'):format(item)
          end,
          preview_item = function(item)
            local lines = { 'This is ' .. vim.inspect(item) }
            local buf = vim.api.nvim_create_buf(false, true)
            vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
            vim.bo[buf].bufhidden = 'wipe'
            return { buf = buf }
          end,
        }, function(choice)
          vim.o.expandtab = choice == 'spaces'
          vim.print(('Selected "%s" => expandtab=%s'):format(choice, vim.o.expandtab))
        end)
<

    Parameters: ~
      • {items}      (`any[]`) Arbitrary items
      • {opts}       (`table`) Options
                     • {format_item}? (`fun(item: any):string`, default:
                       `tostring`) Decides how to format items when displayed
                       in the picker.
                     • {kind}? (`string`) Arbitrary hint string indicating the
                       item shape. The picker may wish to use this to infer
                       the structure or semantics of `items`, or the context
                       in which select() was called.
                     • {preview_item}?
                       (`fun(item: any):{buf?:integer, pos?:[integer,integer], pos_end?:[integer,integer]}`)
                       Decides how to preview an item by preparing a scratch
                       buffer with the item details (including text,
                       highlighting, etc.). When the picker decides to
                       "preview" an item, it should call this function. Must
                       return a table with these keys:
                       • {buf}? (`integer`) Buffer containing the previewed
                         item details, or nil if no preview should be shown.
                       • {pos}? (`[integer, integer]`) Specifies the
                         (1,0)-indexed cursor position in the preview buffer.
                         If nil, should be treated as `{ 1, 0 }`.
                       • {pos_end}? (`[integer, integer]`) Specifies the
                         (1,0)-indexed (end-exclusive) end position of the
                         preview range. If nil, no range is intended for a
                         preview.
                     • {prompt}? (`string`, default: `"Select one of:"`)
                       Prompt text.
      • {on_choice}  (`fun(item: T?, idx: integer?)`) Called once the user
                     made a choice. `idx` is the 1-based index of `item`
                     within `items`, or `nil` if the user aborted the dialog.


==============================================================================
Lua module: vim.uri                                                  *vim.uri*

vim.uri_decode({str})                                       *vim.uri_decode()*
    URI-decodes a string containing percent escapes.

    Parameters: ~
      • {str}  (`string`) string to decode

    Return: ~
        (`string`) decoded string

vim.uri_encode({str}, {rfc})                                *vim.uri_encode()*
    URI-encodes a string using percent escapes.

    Parameters: ~
      • {str}  (`string`) string to encode
      • {rfc}  (`"rfc2396"|"rfc2732"|"rfc3986"?`)

    Return: ~
        (`string`) encoded string

vim.uri_from_bufnr({buf})                               *vim.uri_from_bufnr()*
    Gets a URI from a bufnr.

    Parameters: ~
      • {buf}  (`integer`)

    Return: ~
        (`string`) URI

vim.uri_from_fname({path})                              *vim.uri_from_fname()*
    Gets a URI from a file path.

    Parameters: ~
      • {path}  (`string`) Path to file

    Return: ~
        (`string`) URI

vim.uri_to_bufnr({uri})                                   *vim.uri_to_bufnr()*
    Gets the buffer for a uri. Creates a new unloaded buffer if no buffer for
    the uri already exists.

    Parameters: ~
      • {uri}  (`string`)

    Return: ~
        (`integer`) bufnr

vim.uri_to_fname({uri})                                   *vim.uri_to_fname()*
    Gets a filename from a URI.

    Parameters: ~
      • {uri}  (`string`)

    Return: ~
        (`string`) filename or unchanged URI for non-file URIs


==============================================================================
Lua module: vim.version                                          *vim.version*

The `vim.version` module provides functions for comparing versions and ranges
conforming to the https://semver.org spec. Plugins, and plugin managers, can
use this to check available tools and dependencies on the current system.

Example: >lua
    local v = vim.version.parse(vim.system({'tmux', '-V'}):wait().stdout, {strict=false})
    if vim.version.gt(v, {3, 2, 0}) then
      -- ...
    end
<

*vim.version()* returns the version of the current Nvim process.

VERSION RANGE SPEC                                             *version-range*

A version "range spec" defines a semantic version range which can be tested
against a version, using |vim.version.range()|.

Supported range specs are shown in the following table. Note: suffixed
versions (1.2.3-rc1) are not matched. >
    1.2.3             is 1.2.3
    =1.2.3            is 1.2.3
    >1.2.3            greater than 1.2.3
    <1.2.3            before 1.2.3
    >=1.2.3           at least 1.2.3
    <=1.2.3           at most 1.2.3
    ~1.2.3            is >=1.2.3 <1.3.0       "reasonably close to 1.2.3"
    ^1.2.3            is >=1.2.3 <2.0.0       "compatible with 1.2.3"
    ^0.2.3            is >=0.2.3 <0.3.0       (0.x.x is special)
    ^0.0.1            is =0.0.1               (0.0.x is special)
    ^1.2              is >=1.2.0 <2.0.0       (like ^1.2.0)
    ~1.2              is >=1.2.0 <1.3.0       (like ~1.2.0)
    ^1                is >=1.0.0 <2.0.0       "compatible with 1"
    ~1                same                    "reasonably close to 1"
    1.x               same
    1.*               same
    1                 same
    *                 any version
    x                 same

    1.2.3 - 2.3.4     is >=1.2.3 <2.3.4

    Partial right: missing pieces treated as x (2.3 => 2.3.x).
    1.2.3 - 2.3       is >=1.2.3 <2.4.0
    1.2.3 - 2         is >=1.2.3 <3.0.0

    Partial left: missing pieces treated as 0 (1.2 => 1.2.0).
    1.2 - 2.3.0       is 1.2.0 - 2.3.0
<


*vim.VersionRange*

    Fields: ~
      • {from}  (`vim.Version`)
      • {has}   (`fun(self: vim.VersionRange, version: string|vim.Version): boolean`)
                See |VersionRange:has()|.
      • {to}?   (`vim.Version`)


VersionRange:has({version})                               *VersionRange:has()*
    Check if a version is in the range (inclusive `from`, exclusive `to`).

    Example: >lua
        local r = vim.version.range('1.0.0 - 2.0.0')
        print(r:has('1.9.9'))       -- true
        print(r:has('2.0.0'))       -- false
        print(r:has(vim.version())) -- check against current Nvim version
<

    Or use cmp(), le(), lt(), ge(), gt(), and/or eq() to compare a version
    against `.to` and `.from` directly: >lua
        local r = vim.version.range('1.0.0 - 2.0.0') -- >=1.0, <2.0
        print(vim.version.ge({1,0,3}, r.from) and vim.version.lt({1,0,3}, r.to))
<

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {version}  (`string|vim.Version`)

    Return: ~
        (`boolean`)

    See also: ~
      • https://github.com/npm/node-semver#ranges

vim.version.cmp({v1}, {v2})                                *vim.version.cmp()*
    Parses and compares two version objects (the result of
    |vim.version.parse()|, or specified literally as a `{major, minor, patch}`
    tuple, e.g. `{1, 0, 3}`).

    Example: >lua
        if vim.version.cmp({1,0,3}, {0,2,1}) == 0 then
          -- ...
        end
        local v1 = vim.version.parse('1.0.3-pre')
        local v2 = vim.version.parse('0.2.1')
        if vim.version.cmp(v1, v2) == 0 then
          -- ...
        end
<

    Note: ~
      • Per semver, build metadata is ignored when comparing two
        otherwise-equivalent versions.

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {v1}  (`vim.Version|number[]|string`) Version object.
      • {v2}  (`vim.Version|number[]|string`) Version to compare with `v1`.

    Return: ~
        (`integer`) -1 if `v1 < v2`, 0 if `v1 == v2`, 1 if `v1 > v2`.

vim.version.eq({v1}, {v2})                                  *vim.version.eq()*
    Returns `true` if the given versions are equal. See |vim.version.cmp()|
    for usage.

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {v1}  (`vim.Version|number[]|string`)
      • {v2}  (`vim.Version|number[]|string`)

    Return: ~
        (`boolean`)

vim.version.ge({v1}, {v2})                                  *vim.version.ge()*
    Returns `true` if `v1 >= v2`. See |vim.version.cmp()| for usage.

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {v1}  (`vim.Version|number[]|string`)
      • {v2}  (`vim.Version|number[]|string`)

    Return: ~
        (`boolean`)

vim.version.gt({v1}, {v2})                                  *vim.version.gt()*
    Returns `true` if `v1 > v2`. See |vim.version.cmp()| for usage.

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {v1}  (`vim.Version|number[]|string`)
      • {v2}  (`vim.Version|number[]|string`)

    Return: ~
        (`boolean`)

vim.version.intersect({r1}, {r2})                    *vim.version.intersect()*
    Computes the common range shared by the given ranges.

    Attributes: ~
        Since: 0.12.0

    Parameters: ~
      • {r1}  (`vim.VersionRange`) First range to intersect. See
              |vim.VersionRange|.
      • {r2}  (`vim.VersionRange`) Second range to intersect. See
              |vim.VersionRange|.

    Return: ~
        (`vim.VersionRange?`) Maximal range that is present inside both `r1`
        and `r2`. `nil` if such range does not exist. See |vim.VersionRange|.

vim.version.last({versions})                              *vim.version.last()*
    TODO: generalize this, move to func.lua

    Parameters: ~
      • {versions}  (`vim.Version[]`)

    Return: ~
        (`vim.Version?`)

vim.version.le({v1}, {v2})                                  *vim.version.le()*
    Returns `true` if `v1 <= v2`. See |vim.version.cmp()| for usage.

    Attributes: ~
        Since: 0.10.0

    Parameters: ~
      • {v1}  (`vim.Version|number[]|string`)
      • {v2}  (`vim.Version|number[]|string`)

    Return: ~
        (`boolean`)

vim.version.lt({v1}, {v2})                                  *vim.version.lt()*
    Returns `true` if `v1 < v2`. See |vim.version.cmp()| for usage.

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {v1}  (`vim.Version|number[]|string`)
      • {v2}  (`vim.Version|number[]|string`)

    Return: ~
        (`boolean`)

vim.version.parse({version}, {opts})                     *vim.version.parse()*
    Parses a semantic version string and returns a version object which can be
    used with other `vim.version` functions. For example "1.0.1-rc1+build.2"
    returns: >
        { major = 1, minor = 0, patch = 1, prerelease = "rc1", build = "build.2" }
<

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {version}  (`string`) Version string to parse.
      • {opts}     (`table?`) Options for parsing.
                   • {strict}? (`boolean`, default: `false`) If `true`, no
                     coercion is attempted on input not conforming to semver
                     v2.0.0. If `false`, `parse()` attempts to coerce input
                     such as "1.0", "0-x", "tmux 3.2a" into valid versions.

    Return: ~
        (`vim.Version?`) `Version` object or `nil` if input is invalid.

    See also: ~
      • https://semver.org/spec/v2.0.0.html

vim.version.range({spec})                                *vim.version.range()*
    Parses a semver |version-range| "spec" and returns |vim.VersionRange|
    object:

    Attributes: ~
        Since: 0.9.0

    Parameters: ~
      • {spec}  (`string`) Version range "spec"

    Return: ~
        (`vim.VersionRange?`) See |vim.VersionRange|.


==============================================================================
UI2                                                                      *ui2*

WARNING: This is an experimental feature intended to replace the builtin
message + cmdline presentation layer.

To enable this feature (default opts shown): >lua
    require('vim._core.ui2').enable({
      enable = true, -- Whether to enable or disable the UI.
      msg = { -- Options related to the message module.
        ---@type 'cmd'|'msg' Default message target, either in the
        ---cmdline or in a separate ephemeral message window.
        ---@type string|table<string, 'cmd'|'msg'|'pager'> Default message target
        ---or table mapping |ui-messages| kinds and triggers to a target.
        targets = 'cmd',
        cmd = { -- Options related to messages in the cmdline window.
          height = 0.5 -- Maximum height while expanded for messages beyond 'cmdheight'.
        },
        dialog = { -- Options related to dialog window.
          height = 0.5, -- Maximum height.
        },
        msg = { -- Options related to msg window.
          height = 0.5, -- Maximum height.
          timeout = 4000, -- Time a message is visible in the message window.
        },
        pager = { -- Options related to message window.
          height = 1, -- Maximum height.
        },
      },
    })
<

There are four special windows/buffers for presenting messages and cmdline:
• "cmd": Cmdline. Also used for 'showcmd', 'showmode', 'ruler', and messages
  by default.
• "msg": Message window, shows ephemeral messages useful for 'cmdheight' == 0.
• "pager": Pager window, shows |:messages| and certain messages that are never
  "collapsed".
• "dialog": Dialog window, shows modal prompts that expect user input.

The buffer 'filetype' is set to the above-listed id ("cmd", "msg", …).
Handle the |FileType| event to configure any local options for these windows
and their respective buffers.

Unlike the legacy |hit-enter| prompt, messages exceeding 'cmdheight' are
instead "collapsed", followed by a `[+x]` "spill" indicator, where `x`
indicates the spilled lines. To see the full messages, do either:
• ENTER immediately after interactive |:| cmdline shows a message and returns
  to |Normal-mode|.
• |g<| at any time.

 vim:tw=78:ts=8:sw=4:sts=4:et:ft=help:norl:
